#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

int main() {
    printf("Client Start\n");
    int fd = socket(2, 1, 0);               //逆向得到的参数

    char lines[] = "D0Y0uKSk";

    struct sockaddr_in serv_addr;               //套接字结构地址
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;             //IPv4
    serv_addr.sin_addr.s_addr = inet_addr("1.14.92.115");   //地址
    serv_addr.sin_port = htons(1234);           //端口

    printf("Connecting..\n");
    connect(fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));   //接通accept
    printf("Done !\n");

    char buffer[40];       				 	//回响容器
    read(fd, buffer, sizeof(buffer) - 1);
    printf("%s\n", buffer);
    memset(&buffer, 0, sizeof(buffer));

    printf("%s\n", lines);
    write(fd, lines, sizeof(lines) - 1);

    read(fd, buffer, sizeof(buffer) - 1);
    printf("%s\n", buffer);
    memset(&buffer, 0, sizeof(buffer));

    close(fd);
    return 0;
}

"Phew Phew collect the keys below , don't forget to put them in flag{} format"

int main(int argc, char **argv) 
{
    int listenfd, connfd;
    char hostname[MAXLINE], port[MAXLINE];
    socklen_t clientlen;
    struct sockaddr_storage clientaddr;

    //输入端口参数
    if (argc != 2) {
	fprintf(stderr, "usage: %s <port>\n", argv[0]);
	exit(1);
    }

    //监听描述符
    listenfd = Open_listenfd(argv[1]);
    while (1) {
	clientlen = sizeof(clientaddr);
    //接受请求成为描述符
	connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen); 
        //读取套接字信息，IP和端口
        Getnameinfo((SA *) &clientaddr, clientlen, hostname, MAXLINE, 
                    port, MAXLINE, 0);
        printf("Accepted connection from (%s, %s)\n", hostname, port);
    //响应
	doit(connfd); 
    //关闭接受描述符
	Close(connfd);                                            
    }
}

void doit(int fd) 
{
    int is_static;
    struct stat sbuf;
    char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE];
    char filename[MAXLINE], cgiargs[MAXLINE];
    rio_t rio;

    //读取请求行
    Rio_readinitb(&rio, fd);
    if (!Rio_readlineb(&rio, buf, MAXLINE))  
        return;
    printf("%s", buf);
    sscanf(buf, "%s %s %s", method, uri, version);       //解析请求行
    if (strcasecmp(method, "GET")) {                     //是否为GET请求
        clienterror(fd, method, "501", "Not Implemented",
                    "Tiny does not implement this method");
        return;
    }                                                    
    read_requesthdrs(&rio);    //显示请求行和头（printf）                          

    
    is_static = parse_uri(uri, filename, cgiargs);      //解析uri
    if (stat(filename, &sbuf) < 0) {                    
	clienterror(fd, filename, "404", "Not found",
		    "Tiny couldn't find this file");
	return;
    }                                                    

    if (is_static) {       
	if (!(S_ISREG(sbuf.st_mode)) || !(S_IRUSR & sbuf.st_mode)) { 
	    clienterror(fd, filename, "403", "Forbidden",
			"Tiny couldn't read the file");
	    return;
	}
	serve_static(fd, filename, sbuf.st_size);        //静态
    }
    else { 
	if (!(S_ISREG(sbuf.st_mode)) || !(S_IXUSR & sbuf.st_mode)) { 
	    clienterror(fd, filename, "403", "Forbidden",
			"Tiny couldn't run the CGI program");
	    return;
	}
	serve_dynamic(fd, filename, cgiargs);            //动态
    }
}

void serve_static(int fd, char *filename, int filesize)
{
    int srcfd;
    char *srcp, filetype[MAXLINE], buf[MAXBUF];

    //发送响应行和报头
    get_filetype(filename, filetype);    
    sprintf(buf, "HTTP/1.0 200 OK\r\n"); 
    Rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Server: Tiny Web Server\r\n");
    Rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Content-length: %d\r\n", filesize);
    Rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Content-type: %s\r\n\r\n", filetype);
    Rio_writen(fd, buf, strlen(buf));    

    //回响载体
    srcfd = Open(filename, O_RDONLY, 0); 
    srcp = Mmap(0, filesize, PROT_READ, MAP_PRIVATE, srcfd, 0); //映射内存保证原文件纯净
    Close(srcfd);                       
    Rio_writen(fd, srcp, filesize);     
    Munmap(srcp, filesize);             
}

void serve_dynamic(int fd, char *filename, char *cgiargs) 
{
    char buf[MAXLINE], *emptylist[] = { NULL };

    //行与报头
    sprintf(buf, "HTTP/1.0 200 OK\r\n"); 
    Rio_writen(fd, buf, strlen(buf));
    sprintf(buf, "Server: Tiny Web Server\r\n");
    Rio_writen(fd, buf, strlen(buf));
  
    //子进程
    if (Fork() == 0) {
	
	setenv("QUERY_STRING", cgiargs, 1);  //用url参数初始化环境变量
	Dup2(fd, STDOUT_FILENO);        //重定向输出到fd
	Execve(filename, emptylist, environ);  //运行CGI程序
    }
    Wait(NULL); //等待子进程结束回收
}

signal(SIGPIPE,SIG_IGN);

//uri解析记录变量
char send_port[MAXLINE];
char send_host[MAXLINE];
char send_path[MAXLINE];

void doit(int fd) 
{
    char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE];
    char backbuf[MAXLINE],newhd[MAXLINE];
    char *send;
    rio_t rio,serverfd_rio;

    //读取请求行
    Rio_readinitb(&rio, fd);
    if (!Rio_readlineb(&rio, buf, MAXLINE))  
        return;
    printf("%s", buf);
    sscanf(buf, "%s %s %s", method, uri, version);       //解析请求行
    if (strcasecmp(method, "GET")) {                     //是否为GET请求
        clienterror(fd, method, "501", "Not Implemented",
                    "Tiny does not implement this method");
        return;
    }                                                    
    read_requesthdrs(&rio);    //显示请求行和头（printf）                          

    //解析uri为host port path
    parse_uri(uri);

    //改写
    sprintf(newhd, "GET %s HTTP/1.0\r\n", send_path);
    send = built_message(newhd,&rio);

	//开启远程服务器
    int serverfd = Open_clientfd(send_host,send_port);
    if (serverfd < 0)
    {
        printf("connection failed\n");
        return;
    }
	
    Rio_readinitb(&serverfd_rio, serverfd);
    //写入服务器
    Rio_writen(serverfd, send, strlen(send));

    size_t n;

    //回响
    while((n = Rio_readlineb(&serverfd_rio,backbuf,MAXLINE)) != 0)
    {
        printf("proxy received %d bytes,then send\n", (int)n);
        Rio_writen(fd,backbuf,n);
    }
    
    Close (serverfd);
}

void parse_uri(char *uri)
{
    //是否有host：port，port默认80
    char *hostpath = strstr(uri,"//");
    if(hostpath != NULL) //有
    {
        //是否有port
        char *portpath = strstr(hostpath + 2,":");
        if(portpath != NULL) //有
        {
            int num;
            sscanf(portpath+1,"%d%s",&num,send_path);
            sprintf(send_port,"%d",num);
            *portpath = NULL;
        }
        else //无
        {
        	char *path = strstr(hostpath + 2,"/");
        	if(path != NULL) 
        	{
                strcpy(send_path,path);
        		strcpy(send_port,"80");
            	*path = NULL;
			}
        }
        strcpy(send_host,hostpath + 2);
        return;
    }
    else  //无
    {
        char *path = strstr(uri,"/");
        if(path != NULL)
        {
            strcpy(send_path,path);
        }
        strcpy(send_port,"80");
        return;
    }
}

char *built_message( char *getit,rio_t *rp)
{
    //构造新头
    char buf[MAXLINE];
    char rio[MAXLINE];
    sprintf(buf,"%s",getit);
    sprintf(buf,"%sHost: %s\r\n",buf,send_host);
    sprintf(buf,"%sUser-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:10.0.3) Gecko/20120305 Firefox/10.0.3\r\n",buf);
    sprintf(buf,"%sConnection: close\r\n",buf);
    sprintf(buf,"%sProxy-Connection: close\r\n\r\n",buf);

    //补上原内容
    Rio_readnb(rp,rio,MAXLINE);
    sprintf(buf,"%s%s",buf,rio);
    return buf;
}   

typedef struct {
    int *buf;          // 缓冲区数组         
    int n;             // 槽的最大数量
    int front;         // buf[(front+1)%n] 是第一个项目
    int rear;          // buf[rear%n] 是最后一个项目
    sem_t mutex;       //互斥锁，初始化1
    sem_t slots;       //记录槽，初始化n
    sem_t items;       //记录项目，初始化0
} sbuf_t;

void sbuf_insert(sbuf_t *sp, int item)
{
    P(&sp->slots);                          // 对slots加锁，保证槽位满时，客户端挂起
    P(&sp->mutex);                          // 对缓冲区互斥访问
    sp->buf[(++sp->rear)%(sp->n)] = item;   // 添加项目
    V(&sp->mutex);                          // 解锁
    V(&sp->items);                          //与slots对应地调整items
}

int sbuf_remove(sbuf_t *sp)
{
    int item;
    P(&sp->items);                          // 如果项目没有，服务端挂起
    P(&sp->mutex);                          // 加锁缓冲区
    item = sp->buf[(++sp->front)%(sp->n)];  // 移除项目
    V(&sp->mutex);                          // 解锁
    V(&sp->slots);                         
    return item;							//返回客户端的描述符
}

int main(int argc, char **argv) 
{
    int listenfd, connfd;
    char hostname[MAXLINE], port[MAXLINE];
    socklen_t clientlen;
    struct sockaddr_storage clientaddr;

    //输入端口参数
    if (argc != 2) {
	fprintf(stderr, "usage: %s <port>\n", argv[0]);
	exit(1);
    }
	//阻塞SIGPIPE信号
    signal(SIGPIPE,SIG_IGN);
    //监听描述符
    listenfd = Open_listenfd(argv[1]);
    
    //创建线程
    sbuf_init(&sbuf, SBUFSIZE);
    for(int i = 0; i < NTHREADS; i++)
    {
        Pthread_create(&tid, NULL, thread, NULL);
    }
    
    while (1) {
	clientlen = sizeof(clientaddr);
    //接受请求成为描述符
	connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen); 
    //插入描述符
    sbuf_insert(&sbuf, connfd);
        //读取套接字信息，IP和端口
        Getnameinfo((SA *) &clientaddr, clientlen, hostname, MAXLINE, 
                    port, MAXLINE, 0);
        printf("Accepted connection from (%s, %s)\n", hostname, port);                                       
    }
}

void *thread(void *vargp)
{
    Pthread_detach(pthread_self());
    while(1){
    //从缓冲区中读出描述符
    int connfd = sbuf_remove(&sbuf);

    doit(connfd);
    Close(connfd);}
}

int read_cnt;		//记录读者数量
sem_t mutex, w;    //都初始化为1，w导使有读无写，有写无读


void reader(void) 
{
    while(1){
        P(&mutex);
        readcnt++;
        if(readcnt==1) //第一个读者导致w加锁，则写者挂起；
            P(&w);
        V(&mutex);
        
        P(&mutex);
        readcnt--;
        if(readcnt==0) //最后一个读者结束解锁w
            V(&w);
        V(&mutex);
    }
}

void writer(void)
{
	while(1){
        P(&w);
        
        ...
        
        V(&w)
    }
}

typedef struct
{
    char obj[MAX_OBJECT_SIZE];
    char uri[MAXLINE];
    int LRU;
    int isEmpty;

    int read_cnt; //读者数量
    sem_t w;      //Cache信号量
    sem_t mutex;  //read_cnt信号量

} block;

typedef struct
{
    block data[MAX_CACHE];
    int num;
} Cache;

void doit(int fd) 
{
    char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE];
    char backbuf[MAXLINE],newhd[MAXLINE];
    char *send;
    char cache_tag[MAXLINE];
    rio_t rio,serverfd_rio;

    //读取请求行
    Rio_readinitb(&rio, fd);
    if (!Rio_readlineb(&rio, buf, MAXLINE))  
        return;
    printf("%s", buf);
    sscanf(buf, "%s %s %s", method, uri, version);       //解析请求行
   	strcpy(cache_tag,uri);
    if (strcasecmp(method, "GET")) {                     //是否为GET请求
        clienterror(fd, method, "501", "Not Implemented",
                    "Tiny does not implement this method");
        return;
    }                                                    
    read_requesthdrs(&rio);    //显示请求行和头（printf）
    
    //uri是否存在缓存中
    int i;
    if ((i = get_Cache(cache_tag)) != -1)
    {
        //加锁
        P(&cache.data[i].mutex);
        cache.data[i].read_cnt++;
        if (cache.data[i].read_cnt == 1)
            P(&cache.data[i].w);
        V(&cache.data[i].mutex);

        Rio_writen(connfd, cache.data[i].obj, strlen(cache.data[i].obj));

        P(&cache.data[i].mutex);
        cache.data[i].read_cnt--;
        if (cache.data[i].read_cnt == 0)
            V(&cache.data[i].w);
        V(&cache.data[i].mutex);
        return;
    }

    //解析uri为host port path
    parse_uri(uri);

    //改写
    sprintf(newhd, "GET %s HTTP/1.0\r\n", send_path);
    send = built_message(newhd,&rio);

	//开启远程服务器
    int serverfd = Open_clientfd(send_host,send_port);
    if (serverfd < 0)
    {
        printf("connection failed\n");
        return;
    }
	
    Rio_readinitb(&serverfd_rio, serverfd);
    //写入服务器
    Rio_writen(serverfd, send, strlen(send));

    char cache_buf[MAX_OBJECT_SIZE];
    int size_buf = 0;
    size_t n;

    //回响
    while((n = Rio_readlineb(&serverfd_rio,backbuf,MAXLINE)) != 0)
    {
        size_buf += n;
        if(size_buf < MAX_OBJECT_SIZE)
            strcat(cache_buf, buf);
        printf("proxy received %d bytes,then send\n", (int)n);
        Rio_writen(fd,backbuf,n);
    }
    
    Close (serverfd);
    
    //没有就写入缓存
    if(size_buf < MAX_OBJECT_SIZE){
        write_Cache(cache_tag, cache_buf);
    }

}

#define WSIZE 4     //一字的字节
#define DSIZE 8     //两字的字节
#define CHUNKSIZE (1<<12)       //延展一次堆的字节数

#define MAX(x,y) ((x) > (y) ? (x) : (y))
#define MIN(x,y) ((x) < (y) ? (x) : (y))

//大小或上分配位打包的标志字
#define PACK(size,alloc) ((size) | (alloc))

//读写p指针处的一个字
#define GET(p) (*(unsigned int *)(p))       
#define PUT(p,val) (*(unsigned int *)(p) = (val))

//读取标志字中的大小和分配状态
#define GET_SIZE(p) (GET(p) & ~0x7)
#define GET_ALLOC(p) (GET(p) & 0x1)

//给出开头或结尾标志字的位置(bp指针指向块的有效载体)
#define HDRP(bp) ((char *)(bp) - WSIZE)
#define FTRP(bp) ((char *)(bp) - DSIZE + GET_SIZE(HDRP(bp)))

//给出前一个或下一个块的bp指针
#define NEXT_BLKP(bp) ((char *)(bp) + GET_SIZE(HDRP(bp)))
#define PREV_BLKP(bp) ((char *)(bp) - GET_SIZE((char *)(bp) - DSIZE))

static char * heap_listp;
//下次适配记录之前的块
static char * prev_listp;

int mm_init(void)
{   
    //分配4个字(1个初始填充，2个序言，1个结尾)
    if((heap_listp = mem_sbrk(4*WSIZE)) == (void *)-1)
        return -1;
    PUT(heap_listp,0);
    PUT(heap_listp + WSIZE,PACK(DSIZE,1));
    PUT(heap_listp + (2 * WSIZE),PACK(DSIZE,1));
    PUT(heap_listp + (3*WSIZE),PACK(0,1));
    heap_listp += (2*WSIZE);
    prev_listp = heap_listp;

    //延展空闲块
    if(extend_heap(CHUNKSIZE/WSIZE) == NULL)
        return -1;
    return 0;
}

static void * extend_heap(size_t words)
{
    char * bp;
    size_t size;

    //满足2字对齐
    size = (words % 2) ? (words + 1) * WSIZE : words * WSIZE;
    if((long)(bp = mem_sbrk(size)) == -1)
        return NULL;
    
    //设置填充空闲块的头和尾，以及延展一个结束字
    PUT(HDRP(bp),PACK(size,0));
    PUT(FTRP(bp),PACK(size,0));
    PUT(HDRP(NEXT_BLKP(bp)),PACK(0,1));

    //合并空闲块，如果前面是的话
    prev_listp = coalesce(bp);
}