为什么浏览器用我的proxy访问网站老是喜欢创建新连接阿?

asert · 发表于 2007-2-1 00:18:47

我都在对server的request里和对client的response里添加了Connection: Keep-Alive,但是浏览器仍然请求一个页面里的图片和其他资源,都重新和我的proxy创建新的连接来请求,导致proxy对网站的资源也不断的创建新的连接来请求资源,而大部分网站发现这样浪费资源的创建新连接请求资源的方式很快就拒绝连接;怎么解决这个问题呢?
下面是proxy的代码

kitty.c

#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <signal.h>
#include <sys/select.h>
#include "unp.h"
typedef enum {RESPONSE,REQUEST} msg_t;
#define MAXBUF 4096
#define MAXURI 400
#define MIN(a,b) ((a) > (b)?(b):(a))
void process(int fd,int id);
void clienterror(int fd,char *errnum,char *shortmsg,char *longmsg);
ssize_t extract_host(const char *uri,char *buf,int len);
ssize_t extract_fieldname(const char *line,char *buf,int len);
ssize_t extract_fieldvalue(const char *line,char *buf,int len);
ssize_t extract_field(int id,int sockfd,char *headerline,char *fieldname_ptr,int namelen,char *fieldvalue_ptr,int valuelen,msg_t type);
int read_first_headerline(int id,int sockfd,char *headerline,int len,msg_t type);
void debug(const char *fmt,...) {
va_list ap;
va_start(ap,fmt);
vprintf(fmt,ap);
va_end(ap);
}
int equals(char *c1,char *c2) {
return strncasecmp(c1,c2,strlen(c2)) == 0;
}
void sigchld_handler(int sig) {
while(waitpid(-1,0,WNOHANG) > 0);
return;
}
int id = 0;
int main(int argc,char **argv) {
int listenfd,connfd,port;
struct sockaddr_in cliaddr;
socklen_t addrlen = sizeof(struct sockaddr_in);
char straddr[50];
if(argc != 2) {
fprintf(stderr,"usage:%s <port>\n",argv[0]);
exit(1);
}
port = atoi(argv[1]);
listenfd = open_listenfd(port);
signal(SIGCHLD,sigchld_handler);
while(1) {
connfd = accept(listenfd,&cliaddr,&addrlen);
inet_ntop(AF_INET,&cliaddr.sin_addr.s_addr,straddr,sizeof(straddr));
debug("accept remote addr:%s, port:%d, connfd:%d\n",straddr,ntohs(cliaddr.sin_port),connfd);
++id;
if(fork() == 0) {
//child process
close(listenfd);
process(connfd,id);
close(connfd);
exit(0);
}
close(connfd);
}
}
void process(int clifd,int id) {
/* buffer for storing http requests that received from client or http responses that received from server */
char headerline[MAXLINE];
/* buffer for being pointed by fieldname_ptr and fieldvalue_ptr or storing data that received from server */
char databuf[MAXBUF];
/* buffer for storing http requests that will send to server or will send to client */
char sendbuf[MAXBUF];
char uri[MAXURI],method[10],version[10],host[MAXURI],statuscode[3],reason_phrase[20];
/*the socket descriptor that connected to server */
int servfd = -1;
ssize_t size;
char *ptr = sendbuf;
int left = MAXBUF;
char *fieldname_ptr = databuf,*fieldvalue_ptr = databuf + (MAXBUF / 2);
int client_keep_alive = 1;
int client_alive_time = 10;/* 10 seconds is default */
int httprequest_count = 0;/* the count that client use the connection to send httprequests to kitty proxy*/
int server_keep_alive = 1;
fd_set rset;
struct timeval timeout;
FD_ZERO(&rset);
while(httprequest_count == 0 || client_keep_alive) {
FD_SET(clifd,&rset);
timeout.tv_sec = client_alive_time;
timeout.tv_usec = 0;
//debug("%d: before select\n",clifd);
size = select(clifd + 1,&rset,NULL,NULL,&timeout);
//debug("%d: the returned value from select method is %d\n",clifd,size);
if(size == 0) {/* timeout */
break;
} else if(size == -1) { /* error */
debug("select error\n");
break;
}
size = read_first_headerline(id,clifd,headerline,MAXLINE,REQUEST);
if(size < 0) {
goto clean;
}
httprequest_count++;
//TODO:how to do if buffer overflow?
sscanf(headerline,"%s %s %s\r\n",method,uri,version);
debug("\n%d: from client:\n",id);
debug("%d: %s %s %s\n",id,method,uri,version);
if(equals(method,"GET")) {
size = extract_host(uri,host,MAXLINE);
if(size < 0) {
clienterror(clifd,"400","Bad Request","Kitty can not extract host from request line");
return;
}
/* appending the Request-Line that received from client to sendbuf*/
size = snprintf(ptr,left,headerline);
ptr += size;
left -= size;
while(1) {
size = extract_field(id,clifd,headerline,fieldname_ptr,MAXLINE / 2,fieldvalue_ptr,MAXLINE / 2,REQUEST);
if(size == 0) {
break;
} else if(size < 0) {
goto clean;
}
debug("%d: %s: %s\n",id,fieldname_ptr,fieldvalue_ptr);
if(equals(fieldname_ptr,"Proxy-Connection") || equals(fieldname_ptr,"Connection")) {
if(equals(fieldvalue_ptr,"Keep-Alive")) {
client_keep_alive = 1;
} else {
client_keep_alive = 0;
}
continue;
} else if(equals(fieldname_ptr,"Keep-Alive")) {
// client_alive_time = atoi(fieldvalue_ptr);
continue;
} else if(equals(fieldname_ptr,"Host")) {}
else if(equals(fieldname_ptr,"Cookie")) {}
else if(equals(fieldname_ptr,"Pragma")) {}
else if(equals(fieldname_ptr,"Cache-Control")) {}
else if(equals(fieldname_ptr,"User-Agent")) {}
else if(equals(fieldname_ptr,"Accept-Language")) {}
else if(equals(fieldname_ptr,"Accept-Encoding")) {}
else if(equals(fieldname_ptr,"Accept-Charset")) {}
else if(equals(fieldname_ptr,"Accept")) {}
size = snprintf(ptr,left,headerline);
ptr += size;
left -= size;
}
} else {/* currently only support GET */
clienterror(clifd,"501","Not Implemented","Kitty does not implement this method");
goto clean;
}
//tell server keep connection alive
size = snprintf(ptr,left,"Connection: Keep-Alive\r\n");
ptr += size;
left -= size;
/* mark the end of http message headers */
snprintf(ptr,left,"\r\n");
//debug("\nsend to server:\n%s\n",sendbuf);
/* now kitty proxy try to connect to the server */
if(servfd == -1 || !server_keep_alive) {
if(httprequest_count > 1) {
debug("%d: disconnect to server\n",id);
close(servfd);
}
debug("%d: connect to %s\n",id,host);
servfd = tcp_connect(host,80);
if(servfd < 0) {
clienterror(clifd,"504","Gateway Timeout","Kitty can not connect to the server");
goto clean;
}
}
/* send http request headers to server */
size = writen(servfd, sendbuf, strlen(sendbuf));
if(size < 0) {
clienterror(clifd,"500","Internal Server Error","Kitty send request error");
goto clean;
}
ptr = sendbuf;
left = MAXBUF;
//debug("%d: from server:\n",id);
/* read response status line from server */
size = read_first_headerline(id,servfd,headerline,MAXLINE,RESPONSE);
if(size < 0) {
goto clean;
}
sscanf("%s %s %s",version,statuscode,reason_phrase);
//debug("%d: %s %s %s\n",id,version,statuscode,reason_phrase);
size = snprintf(ptr,left,headerline);
ptr += size;
left -= size;
while(1) {
size = extract_field(id,servfd,headerline,fieldname_ptr,MAXLINE / 2,fieldvalue_ptr,MAXLINE / 2,RESPONSE);
if(size == 0) {
break;
} else if(size < 0) {
goto clean;
}
//debug("%d: response:%s: %s\n",id,fieldname_ptr,fieldvalue_ptr);
if(equals(fieldname_ptr,"Connection")) {
if(equals(fieldvalue_ptr,"Keep-Alive")) {
server_keep_alive = 1;
} else {
server_keep_alive = 0;
}
debug("%d: server keep alive : %d\n",id,server_keep_alive);
continue;
} else if(equals(fieldname_ptr,"Host")) {}
else if(equals(fieldname_ptr,"Cookie")) {}
else if(equals(fieldname_ptr,"Pragma")) {}
else if(equals(fieldname_ptr,"Cache-Control")) {}
size = snprintf(ptr,left,headerline);
ptr += size;
left -= size;
}
//tell client keep connection alive
size = snprintf(ptr,left,"Connection: Keep-Alive\r\n");
ptr += size;
left -= size;
snprintf(ptr,left,"\r\n");
/* write http response headers to client */
debug("%d: to client:\n%s",id,sendbuf);
size = writen(clifd, sendbuf, strlen(sendbuf));
if(size < 0) {
debug("an socket error happened while write to client");
goto clean;
}
/* write response entity to client */
debug("%d: write entity to client...\n",id);
while(1) {
/* read from server */
size = read(servfd,databuf,sizeof(databuf));
if(size < 0) {
debug("an error happend while read from server:%s\n",strerror(errno));
//error
goto clean;
} else if(size > 0) {
/* write to client */
size = writen(clifd,databuf,size);
if(size < 0) {
debug("a error happend while write to client:%s\n",strerror(errno));
goto clean;
}
} else {
debug("%d: finished transfer\n",id);
break;
}
}
}
clean:
debug("%d: http request count = %d\n",id,httprequest_count);
if(servfd != -1) {
close(servfd);
}
}
void clienterror(int fd,char *errnum,char *shortmsg,char *longmsg) {
char buf[MAXLINE]={0},body[MAXBUF]={0};
debug("%d: an error occured,error num:%s,longmsg:%s\n",fd,errnum,longmsg);
// int len = strlen(longmsg);
// int i;
// printf("len:%d\n",len);
// for(i = 0;i < len;i++){
// printf("%d",*(longmsg + i));
// }
// printf("\n\n");
//build the HTTP response body
sprintf(body,"<html><title>Error</title>\n");
sprintf(body,"%s<body bgcolor='ffffff'>\n",body);
sprintf(body,"%s%s: %s\n",body,errnum,shortmsg);
sprintf(body,"%s<p>%s\n",body,longmsg);
sprintf(body,"%s<hr><em>Kitty Proxy</em>\n",body);
sprintf(buf,"HTTP/1.1 %s %s\r\n",errnum,shortmsg);
writen(fd,buf,strlen(buf));
sprintf(buf,"Content-type:text/html\r\n");
writen(fd,buf,strlen(buf));
sprintf(buf,"Content-length:%d\r\n\r\n",strlen(body));
writen(fd,buf,strlen(buf));
writen(fd,body,strlen(body));
}
/*
* if it is not a absoluteURI or is bad absoluteURI then return -1;
* if the given buffer is not big enough to store host then return -2;
* if done successfully then return the size of host;
*/
ssize_t extract_host(const char *uri,char *buf,int len) {
char *s, *e;
int host_len;
if(strncasecmp(uri,"http://",strlen("http://")) == 0) {/* absolute uri */
s = uri + strlen("http://");
e = strchr(s,'/');
if(!e) {
return -1;
}
host_len = e - s;
if(len < host_len + 1) {
return -2;
}
strncpy(buf,s,host_len);
*(buf + host_len) = 0;
return host_len;
}
return -1;
}
/*
* if the request-header field is bad then return -1;
* if the given buffer is not big enough to store field name then return -2;
* if done successfully then return the size of field name;
*/
ssize_t extract_fieldname(const char *line,char *buf,int len) {
char *p = line;
int fieldname_len;
while(*p != ':' && *p != 0 )
p++;
if(*p == 0) {
return -1;
} else {
//TODO:should I remove all heading space and trailing space before calculate fieldname length?
fieldname_len = p - line;
if(len < fieldname_len + 1) {
return -2;
}
}
strncpy(buf,line,fieldname_len);
*(buf + fieldname_len) = 0;
return fieldname_len;
}
/*
* if the request-header field is bad then return -1;
* if the given buffer is not big enough to store field value then return -2;
* if done successfully then return the size of field value;
*/
ssize_t extract_fieldvalue(const char *line,char *buf,int len) {
char *p = strchr(line,':');
int fieldvalue_len;
if(!p) {
return -1;
}
p++;
while(*p == ' ')
p++;
fieldvalue_len = strlen(p) - 2;/* exclude last CRLF */
if(len < fieldvalue_len + 1) {
return -2;
}
strncpy(buf,p,fieldvalue_len);
*(buf + fieldvalue_len) = 0;
return fieldvalue_len;
}
/*
* return -2 when read error
* return -1 when the request is bad
* return 0 when encounter CRLF
* return 1 if anything is OK
*/
ssize_t extract_field(int id,int sockfd,char *headerline,char *fieldname_ptr,int namelen,char *fieldvalue_ptr,int valuelen,msg_t type) {
int size = readline(sockfd,headerline,MAXLINE);
char *s = (type == REQUEST) ? "request":"response";
if(size == 0) {/* encounter EOF */
debug("%d: readline encounter EOF when extracting field from %s\n",id,s);
return -2;
} else if(size == -1) { /* error */
debug("%d: readline error when extracting field from %s : %s\n",id,s,strerror(errno));
return -2;
}
if(equals(headerline,"\r\n")) {
debug("%d: reach end in %s\n",id,s);
return 0;
}
size = extract_fieldname(headerline, fieldname_ptr, namelen);
if(size < 0) {
if(type == REQUEST) {
clienterror(sockfd,"400","Bad Request",headerline);
} else {
clienterror(sockfd,"500","Internal Server Error","");
}
return -1;
}
size = extract_fieldvalue(headerline, fieldvalue_ptr, valuelen);
if(size < 0) {
if(type == REQUEST) {
clienterror(sockfd,"400","Bad Request",headerline);
} else {
clienterror(sockfd,"500","Internal Server Error","");
}
return -1;
}
return 1;
}
/*
* RFC HTTP/1.1:
* In the interest of robustness, servers SHOULD ignore any empty line(s) received
* where a Request-Line is expected. In other words, if the server is reading the
* protocol stream at the beginning of a message and receives a CRLF first, it
* should ignore the CRLF.
*
* return -1 if read error otherwise return 0;
*/
int read_first_headerline(int id,int sockfd,char *headerline,int len,msg_t type) {
int size;
char *s = (type == REQUEST) ? "request":"response";
do {
size = readline(sockfd,headerline,len);
if(size == 0) {/* encounter EOF */
debug("%d: readline encounter EOF when reading first headerline from %s\n",id,s);
return -1;
} else if(size == -1) { /* error */
debug("%d: readline error when reading first headerline from %s : %s\n",id,s,strerror(errno));
return -1;
}
} while(equals(headerline,"\r\n"));
return 0;
}

复制代码

然后是要用的unp.h和unp.c

unp.h

#ifndef UNP_H_
#define UNP_H_
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <netinet/udp.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netdb.h>
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <stdarg.h>
#include <sys/ioctl.h>
#include <net/if.h>
#define MAXLINE 1000
#define LISTENQ 1024
struct addrinfo * host_serv(const char *host,const char *serv,int family,int socktype);
char *sock_ntop_host(const struct sockaddr * sa, socklen_t len);
void sock_set_port(struct sockaddr *sa, socklen_t salen, int port);
int sock_get_port(struct sockaddr *sa, socklen_t salen);
int sock_cmp_addr(const struct sockaddr *sa1,const struct sockaddr *sa2,socklen_t salen);
void tv_sub(struct timeval *out,struct timeval *in);
uint16_t in_cksum(uint16_t *addr,size_t len);
int tcp_connect(const char *host,const int port);
size_t writen(int fd,const void *c,size_t len);
ssize_t readline(int fd,void *vptr,size_t maxlen);
void err_quit(const char *fmt,...);
int getifaddr(int family, unsigned int ifindex, const char *ifname,void *ifaddr);
int open_clientfd(char *hostname,int port);
int open_listenfd(int port);
#endif /*UNP_H_*/

复制代码

unp.c

#include "cutil/unp.h"
struct addrinfo * host_serv(const char *host,const char *serv,int family,int socktype){
int n;
struct addrinfo hints,*res;
bzero(&hints,sizeof(struct addrinfo));
hints.ai_flags = AI_CANONNAME;
hints.ai_family = family;
hints.ai_socktype = socktype;
if((n = getaddrinfo(host,serv,&hints,&res)) != 0){
return (NULL);
}
return (res);
}
char *sock_ntop_host(const struct sockaddr * sa, socklen_t len){
static char str[128]; /* Unix domain is largest */
switch (sa->sa_family) {
case AF_INET: {
struct sockaddr_in *sin = (struct sockaddr_in *) sa;
if (inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str)) == NULL)
return(NULL);
return(str);
}
}
}
void sock_set_port(struct sockaddr *sa, socklen_t salen, int port) {
switch (sa->sa_family) {
case AF_INET:{
struct sockaddr_in *sin = (struct sockaddr_in *) sa;
sin->sin_port = port;
}
}
}
int sock_get_port(struct sockaddr *sa, socklen_t salen) {
switch (sa->sa_family) {
case AF_INET:{
struct sockaddr_in *sin = (struct sockaddr_in *) sa;
return sin->sin_port;
}
}
}
int sock_cmp_addr(const struct sockaddr *sa1,const struct sockaddr *sa2,socklen_t salen){
if(sa1->sa_family != sa2->sa_family){
return -1;
}
switch(sa1->sa_family){
case AF_INET:{
return (memcmp(&((struct sockaddr_in *)sa1)->sin_addr,
&((struct sockaddr_in *)sa2)->sin_addr,
sizeof(struct in_addr)));
}
}
return -1;
}
void tv_sub(struct timeval *out,struct timeval *in){
if((out->tv_usec -= in->tv_usec) < 0){
--out->tv_sec;
out->tv_usec += 1000000;
}
out->tv_sec -= in->tv_sec;
}
uint16_t in_cksum(uint16_t *addr,size_t len){
int nleft = len;
uint32_t sum = 0;
uint16_t *w = addr;
uint16_t answer = 0;
while(nleft > 1){
sum += *w++;
nleft -= 2;
}
if(nleft == 1){
*(unsigned char *)(&answer) = *(unsigned char *)w;
sum+=answer;
}
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >>16);
answer =~sum;
return (answer);
}
int tcp_connect(const char *host,const int port){
int sockfd;
struct hostent * hptr;
struct sockaddr_in servaddr;
int i;
if((hptr = gethostbyname(host)) == NULL){
fprintf(stderr,"gethostbyname error\n");
return -1;
}
if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0){
fprintf(stderr,"socket error\n");
close(sockfd);
return -1;
}
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(port);
memcpy(&servaddr.sin_addr,hptr->h_addr,sizeof(struct in_addr));
if((i = connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr))) < 0){
fprintf(stderr,"connect error\n");
return -1;
}
return sockfd;
}
size_t writen(int fd,const void *c,size_t len){
int n;
size_t left = len;
const void *ptr = c;
while(left > 0){
if((n = write(fd,ptr,len)) > 0){
left -= n;
ptr += n;
}
if(n < 0 && errno != EINTR){
return -1;
}
}
return len;
}
ssize_t readline(int fd,void *vptr,size_t maxlen){
ssize_t n,rc;
char c,*ptr;
ptr = vptr;
for(n=1;n<maxlen;n++){
again:
if((rc = read(fd,&c,1)) == 1){
*ptr ++= c;
if(c == '\n')
break;
}else if(rc == 0){
*ptr = 0;
return (n-1);
}else{
if(errno == EINTR){
goto again;
}
return -1;
}
}
*ptr = 0;
return n;
}
void err_quit(const char *fmt,...){
va_list ap;
va_start(ap,fmt);
vprintf(fmt,ap);
va_end(ap);
exit(1);
}
inline static int __getifaddr_ipv4(int ifindex, const char *ifname,
struct in_addr *ifaddr)
{
struct ifreq ifreq;
int sockfd;
int ret = -1;
char ifn[IFNAMSIZ];
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) >= 0)
{
strncpy(ifreq.ifr_name, ifname, IFNAMSIZ);
if ((ret = ioctl(sockfd, SIOCGIFADDR, &ifreq)) >= 0)
*ifaddr = ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr;
close(sockfd);
}
return ret;
}
#ifdef IPV6
#define PROC_IFINET6_PATH "/proc/net/if_inet6"
inline static int __getifaddr_ipv6(unsigned int ifindex, const char *ifname,
struct in6_addr *ifaddr)
{
FILE *fp = fopen(PROC_IFINET6_PATH, "r");
char addrstr[INET6_ADDRSTRLEN];
char seg[8][5];
int index, plen, scope, flags;
char ifn[IFNAMSIZ];
int ret = -1;
if (fp)
{
while (fscanf(fp, "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %s\n"
seg[0], seg[1], seg[2], seg[3], seg[4], seg[5], seg[6],
seg[7], &index, &plen, &scope, &flags, ifn) != EOF)
{
if (ifindex == index || ifindex == 0 && strcmp(ifn, ifname) == 0)
{
sprintf(addrstr, "%s:%s:%s:%s:%s:%s:%s:%s", seg[0], seg[1],
seg[2], seg[3], seg[4], seg[5], seg[6], seg[7]);
ret = inet_pton(AF_INET6, addrstr, ifaddr);
goto out;
}
}
errno = ENXIO;
out:
fclose(fp);
}
return ret;
}
#endif
int getifaddr(int family, unsigned int ifindex, const char *ifname,
void *ifaddr)
{
switch (family)
{
case AF_INET:
return __getifaddr_ipv4(ifindex, ifname, (struct in_addr *)ifaddr);
#ifdef IPV6
case AF_INET6:
return __getifaddr_ipv6(ifindex, ifname, (struct in6_addr *)ifaddr);
#endif
default:
errno = EAFNOSUPPORT;
return -1;
}
}
int open_clientfd(char *hostname,int port){
int clientfd;
struct hostent *hp;
struct sockaddr_in serveraddr;
if((clientfd = socket(AF_INET,SOCK_STREAM,0)) < 0){
return -1;// check errno for cause of error
}
//fill in server's IP address and port
if((hp = gethostbyname(hostname)) == NULL){
return -2;//check h_errno for cause of error
}
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);
//establish a connection with the server
if(connect(clientfd,(struct sockaddr *)&serveraddr,sizeof(serveraddr)) < 0){
return -1;
}
return clientfd;
}
int open_listenfd(int port){
int listenfd,optval=1;
struct sockaddr_in serveraddr;
//create a socket descriptor
if((listenfd = socket(AF_INET,SOCK_STREAM,0)) < 0){
return -1;
}
//eliminates "address already in use" error from bind
if(setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,(const void *)&optval,sizeof(int)) < 0){
return -1;
}
//listenfd will be an endpoint for all requests to port on any IP address for this host
bzero((char *)&serveraddr,sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1"); //htonl(INADDR_ANY);
serveraddr.sin_port = htons((unsigned short)port);
if(bind(listenfd,(struct sockaddr *)&serveraddr,sizeof(serveraddr)) < 0){
return -1;
}
//make it a listening socket ready to accept connection requests
if(listen(listenfd,LISTENQ) < 0){
return -1;
}
return listenfd;
}

复制代码

生成可执行代码:
gcc kitty.c unp.c -o kitty

运行:
./kitty 8000

然后设置浏览器的代理服务器选项

大家测试看看有没有需要修改的地方,谢谢

		自动登录	找回密码
密码			注册

为什么浏览器用我的proxy访问网站老是喜欢创建新连接阿?

本帖子中包含更多资源