C++ rio_readlineb函数代码示例

void process_rstheader(rio_t *rp)
{
    char buf[MAXLEN];
    rio_readlineb(rp, buf, MAXLEN);
    while(strcmp(buf, "\r\n"))
        rio_readlineb(rp, buf, MAXLEN);
}

void echo(int connfd){

    size_t n;
    char buf[MAXLINE];
    rio_t rio;

    rio_readinitb(&rio, connfd);
    if((n = rio_readlineb(&rio, buf, MAXLINE)) < 0){
        fprintf(stderr, "rio_readlineb error \n");
        exit(0);
    }
    
    while(n != 0){
        printf("server received %d bytes\n", n);
        if(rio_writen(connfd, buf, n) != n){
            fprintf(stderr, "rio_writen error\n");
            exit(0);
        }
        if((n = rio_readlineb(&rio, buf, MAXLINE)) < 0){
            fprintf(stderr, "rio_readlineb error \n");
            exit(0);
        }

    }

}

/* $begin read_requesthdrs */
void send_requesthdrs(rio_t *rp, int file, char* host) 
{
	
	char buf[MAXLINE];
	int hosthdr = 0;
	int bufLen;

    bufLen = rio_readlineb(rp, buf, MAXLINE);
	rio_writen(file, buf, bufLen);
	while(strcmp(buf, "\r\n")) 
	{          
		bufLen = rio_readlineb(rp, buf, MAXLINE);
		
		if(!strncasecmp(buf, "Connection", strlen("Connection")))
		{
			continue;
		}
		if(!strncasecmp(buf, "Proxy-Connection", strlen("Proxy-Connection")))
		{
			continue;
		}
		if(!strncasecmp(buf, "User-Agent", strlen("User-Agent")))
		{
			continue;
		}
		if(!strncasecmp(buf, "Accept", strlen("Accept")))
		{
			continue;
		}
		if(!strncasecmp(buf, "Accept-Encoding", strlen("Accept-Encoding")))
		{
			continue;
		}
		if(!strncasecmp(buf, "Host", strlen("Host")))
		{
			hosthdr = 1;
		}
		//this is broken. When we understand how to do Host, we'll fix it.
		

		if(0 && !strncasecmp(buf,"\r\n",strlen("\r\n")) && !hosthdr)
		{
			char tmp[MAXLINE];
			sprintf(tmp, "Host: %s\r\n",host);
			rio_writen(file, tmp, strlen(tmp));
			printf(tmp);
		}
    		rio_writen(file, buf, bufLen);
		if(!strncasecmp(buf,"Cookie",strlen("Cookie")))
		{
			printf("Cookie: <POTENTIALLY BINARY DATA REDACTED>\r\n");
		}
		else
		{
			printf(buf);
		}
	}
}

/* Send Request from browser to the server*/
int SendRequest(int clientfd, rio_t serverrio_t, char* hostname, char* uriname){
    int i,byte;
    int flag[5] = {0};
    char headerBuff[MAXHEADERSIZE]; 
    char requestLine[MAXHEADERSIZE];

    sprintf(requestLine,"GET %s HTTP/1.0\r\n",uriname);
    rio_writen(clientfd,requestLine,strlen(requestLine));


    byte = rio_readlineb(&serverrio_t,headerBuff,sizeof(headerBuff));
    if( strstr(headerBuff,"Host:") != NULL){
        getHostname(headerBuff,hostname);
    }
    sprintf(requestLine,"Host: %s\r\n",hostname);
    rio_writen(clientfd,requestLine,strlen(requestLine));

    while( (byte = rio_readlineb(&serverrio_t,headerBuff,sizeof(headerBuff))) >0){
        if(strncmp(headerBuff,"GET",3) == 0){
        }
        else if(strncmp(headerBuff,"Host",4) == 0){
        }
        else if(strncmp(headerBuff,"\r",1) == 0){
            break;
        }
        else if(strncmp(headerBuff,"User-Agent:",11) == 0){
            rio_writen(clientfd,headerSet[0],strlen(headerSet[0]));
            flag[0] = 1;
        }
        else if(strncmp(headerBuff,"Accept:",7) == 0){
            rio_writen(clientfd,headerSet[1],strlen(headerSet[1]));
            flag[1] = 1;
        }
        else if(strncmp(headerBuff,"Accept-Encoding:",16) == 0){
            rio_writen(clientfd,headerSet[2],strlen(headerSet[2]));
            flag[2] = 1;
        }
        else if(strncmp(headerBuff,"Connection:",11) == 0){
            rio_writen(clientfd,headerSet[3],strlen(headerSet[3]));
            flag[3] = 1;
        }
        else if(strncmp(headerBuff,"Proxy-Connection:",17) == 0){
            rio_writen(clientfd,headerSet[4],strlen(headerSet[4]));
            flag[4] = 1;
        }
        else{
            rio_writen(clientfd,headerBuff,strlen(headerBuff));
        }
    }
    for(i = 0 ; i < 5 ;i++){
        if(flag[i] == 0){
            rio_writen(clientfd,headerSet[i],strlen(headerSet[i]));
            flag[i] = 1;
        }
    }
    rio_writen(clientfd,"\r\n",strlen("\r\n"));
    return 1;
}

void read_requesthdrs(rio_t *rp)
{
	char buf[MAXLINE];
	rio_readlineb(rp, buf, MAXLINE);
	while(strcmp(buf, "\r\n"))
	{
		rio_readlineb(rp, buf, MAXLINE);
	}
}

void read_requesthdrs(rio_t *rp)
{
	char buf[MAXLINE];

	rio_readlineb(rp, buf, MAXLINE);
	while (strcmp(buf, "\r\n")) {
		rio_readlineb(rp, buf, MAXLINE);
		printf("%s", buf);
	}
	return;
}

/* parse_request parses request from client and stores the 
 * information in a client_request structure */
int parse_request(struct client_request *request, int clientfd)
{
	char buf[MAXBUF], method[MAXLINE], uri[MAXLINE], port[MAXLINE], *ptr;
	rio_t rio;
	
	port[0] = 0;
	
	rio_readinitb(&rio, clientfd);
	rio_readlineb(&rio, buf, MAXLINE - 1);
	if (sscanf(buf, "%s %s %*s", method, uri) < 2)
	{
		printf("parsing error %s\n", buf);
		return -1;
	}
	strcpy(request->request_line, buf);
	if (sscanf(uri, "http://%[^:/]:%[^/]/%*s", request->host, port) < 1)
		return -1;
	if (*port == 0)
		request->server_port = 80;
	else
		request->server_port = atoi(port);
	
	if (strcmp(method, "GET"))
		return -2;
	
	sprintf(request->request, "GET %s HTTP/1.0\r\nHost: %s\r\n", uri, request->host);
	
	/* reads all headers */
	while (1)
	{
		rio_readlineb(&rio, buf, MAXLINE - 1);
		
		/* need to change connection header to close */
		if ((ptr = strstr(buf, "Connection:")) != NULL)
		{
			strcat(request->request, "Connection: close\n");
			continue;
		}
		
		/* need to delete keep-alive header */
		if ((ptr = strcasestr(buf, "keep-alive")) != NULL)
			continue;
			
		/* host is already in the header */
		if ((ptr = strstr(buf, "Host:")) != NULL)
			continue;
		strcat(request->request, buf);
		if (*buf == '\r' && *(buf + 1) == '\n')
			break;
	}
	request->request_length = strlen(request->request);
	return 0;
}

/* $begin hdr_concat */
void hdr_concat(rio_t *rio_client,char *hdr_server,char *hostname, char *pathname)
    {
        char add_info[MAXLINE];
        char buf[MAXLINE];
        char *ptr;
        int n=0;
        int off=0;
        if (rio_readlineb(rio_client,buf,MAXLINE)!=0){
            
            ptr=buf;
            if (!strncmp(buf,"Host:",5)){
                ptr+=5;
                *ptr='\0';
                strstr(hostname,ptr);
            }
        }
        
        memset(buf,0,MAXLINE);
        memset(add_info,0,MAXLINE);
        while((n=rio_readlineb(rio_client,buf,MAXLINE))>0){
            if (!strcmp(buf,"\r\n"))
                break;
            ptr=buf;
            if (!strncmp(buf,"User-Agent:",11)||
                !strncmp(buf,"Accept:",7)||
                !strncmp(buf,"Accept-Encoding:",16)||
                !strncmp(buf,"Connection:",11)||
                !strncmp(buf,"Proxy-Connection:",17)){
                continue;
            }
            else{
                memcpy(add_info+off,buf,n);
                memset(buf,0,MAXLINE);
                off+=n;
            }
            
        }

        sprintf(hdr_server,"GET %s HTTP/1.0\r\n",pathname);
        sprintf(hdr_server,"%sHost: %s\r\n",hdr_server,hostname);
        strcat(hdr_server,user_agent_hdr);
        strcat(hdr_server,accept_hdr);
        strcat(hdr_server,accept_encoding_hdr);
        strcat(hdr_server,conn);
        strcat(hdr_server,proxy_conn);
        strcat(hdr_server,"\r\n");
        strcat(hdr_server,add_info);
    }

void check_clients(Pool *p)
{
    int i, connfd, n;
    char buf[MAXLINE];
    rio_t rio;

    for(i = 0; (i <= p->maxi) && (p->nready > 0); i++){
        connfd = p->clientfd[i];
        rio = p->clientrio[i];

        if((connfd > 0) && (FD_ISSET(connfd, &p->ready_set))){
            p->nready --;
            if((n = rio_readlineb(&rio, buf, MAXLINE)) != 0 ){
                byte_cnt += n;
                printf("Server received %d (%d total) bytes on fd %d\n",
                        n, byte_cnt, connfd);
                rio_writen(connfd, buf, n);
            }
            else {
                close(connfd);
                FD_CLR(connfd, &p->read_set);
                p->clientfd[i] = -1;
            }
        }
    }
}

int send_request(rio_t *rio, char *buf,
		struct status_line *status, int serverfd, int clientfd) {
	int len;
	if (strcmp(status->method, "CONNECT")) {
		len = snprintf(buf, MAXLINE, "%s %s %s\r\n" \
				"Connection: close\r\n",
				status->method,
				*status->path ? status->path : "/",
				status->version);
		if ((len = rio_writen(serverfd, buf, len)) < 0)
			return len;
		while (len != 2) {
			if ((len = rio_readlineb(rio, buf, MAXLINE)) < 0)
				return len;
			if (memcmp(buf, "Proxy-Connection: ", 18) == 0 ||
					memcmp(buf, "Connection: ", 12) == 0)
				continue;
			if ((len = rio_writen(serverfd, buf, len)) < 0)
				return len;
		}
		if (rio->rio_cnt &&
				(len = rio_writen(serverfd,
								  rio->rio_bufptr, rio->rio_cnt)) < 0)
			return len;
		return 20;
	} else {
		len = snprintf(buf, MAXLINE,
				"%s 200 OK\r\n\r\n", status->version);
		if ((len = rio_writen(clientfd, buf, len)) < 0)
			return len;
		return 300;
	}
}

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;
}

/******************************************************************************
* subroutine: parse_requestline                                               *
* purpose:    parse the content of request line                               *
* parameters: id        - the index of the client in the pool                 *
*             p         - a pointer of the pool data structure                *
*             context   - a pointer refers to HTTP context                    *
*             is_closed - an indicator if the current transaction is closed   *
* return:     0 on success -1 on error                                        *
******************************************************************************/
int parse_requestline(int id, pool *p, HTTPContext *context, int *is_closed)
{
    char buf[MAX_LINE];

    memset(buf, 0, MAX_LINE); 

    if (rio_readlineb(&p->clientrio[id], buf, MAX_LINE) < 0)
    {
        *is_closed = 1;
        Log("Error: rio_readlineb error in process_request \n");
        serve_error(p->clientfd[id], "500", "Internal Server Error",
                    "The server encountered an unexpected condition.", *is_closed);
        return -1;
    }

    if (sscanf(buf, "%s %s %s", context->method, context->uri, context->version) < 3)
    {
        *is_closed = 1;
        Log("Info: Invalid request line: '%s' \n", buf);
        serve_error(p->clientfd[id], "400", "Bad Request",
                    "The request is not understood by the server", *is_closed);
        return -1;
    }

    Log("Request: method=%s, uri=%s, version=%s \n",
        context->method, context->uri, context->version);
    return 0;
}

void doit(int fd)
{
	int clientfd, port, size = 0;
	ssize_t linecounter;
	rio_t client_rio, server_rio;
	char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE], serveraddr[MAXLINE], path[MAXLINE], message[MAXLINE];
	//read the HTTP request
	rio_readinitb(&client_rio, fd);
	rio_readlineb(&client_rio, buf, MAXLINE);
	sscanf(buf, "%s %s %s", method, uri, version);
	if(strcasecmp(method, "GET") != 0)
	{
		clienterror(fd, method, "501", "Not Implemented", "Proxy does not implement this method");
		return;
	}
	read_requesthdrs(&client_rio);
	//parse it to determine the name of the end server
	port = parse_uri(uri, serveraddr, path);
	//filter
	if(is_blocked_address(serveraddr))
	{
		clienterror(fd, serveraddr, "403", "Forbidden", "Proxy does not access this server");
		return;
	}
 	//open a connection to the end server
	if((clientfd = open_clientfd(serveraddr, port)) < 0)
	{
		clienterror(fd, serveraddr, "404", "Not Found", "Proxy does not found this server");
		return;
	}
	//send it the request
	sprintf(message, "GET %s HTTP/1.0\r\n", path);
	rio_writen(clientfd, message, strlen(message));
	sprintf(message, "HOST: %s\r\n\r\n", serveraddr);
	rio_writen(clientfd, message, strlen(message));
	//receive the reply, and forward the reply to the browser if the request is not blocked.
	rio_readinitb(&server_rio, clientfd);
	while((linecounter = rio_readlineb(&server_rio, message, MAXLINE)) != 0)
	{
		rio_writen(fd, message, linecounter);
		size += linecounter;
	}
	//log
	sem_wait(&mutex);
	log_report(serveraddr, size);
	sem_post(&mutex);
}

ssize_t Rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen)
{
	ssize_t rt;
	rt = rio_readlineb(rp, usrbuf, maxlen);
	if (rt == -1)
		unix_error("Rio_readlineb error");
	return rt;
}

ssize_t Rio_readlineb_s(rio_t *rp, void *usrbuf, size_t maxlen){
    ssize_t rc;
    if ((rc = rio_readlineb(rp, usrbuf, maxlen)) < 0){
		printf("Rio_readlineb error\n");
		rc = 0;
	}
    return rc;
}