#include <sys/socket.h>
ssize_t recvfrom(int sockfd, void *buff, size_t nbytes, 
                 int flags, struct sockaddr *from, socklen_t *addrlen);

ssize_t sendto(int sockfd, const void *buff, size_t nbytes, 
                 int flags, const struct sockaddr *to, socklen_t addrlen);
                 // 若成功均返回读或写的字节数，出错返回 -1
                 // 与标准 read，write 不同，可以返回 0 代表只读 0 字节
                 // 但是在 TCP 中 read 返回 0 代表对端关闭连接

int main(int argc, char ** argv){
    int sockfd;
    struct sockaddr_in servaddr, chiladdr;
    // 创建 UDP 套接字指定 SOCK_DGRAM
    sockfd = Socket(AF_INET, SOCK_DGRAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    aervaddr.sin_family = AF_INET;
    aervaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    aervaddr.sin_port = htons(SERV_PORT);
    // 绑定本机地址
    Bind(sockfd, (SA*)&servaddr, sizeof(servaddr));
    // 执行服务器回射逻辑
    dg_echo(sockfd, (SA*) &cliaddr, sizeof(cliaddr));
}

void dg_echo(int sockfd, SA *pcliaddr, socklen_t clilen)
{
	int			n;
	socklen_t	len;
	char		mesg[MAXLINE];

	for ( ; ; ) {
		len = clilen;
        // 使用 recvfrom 读取下一个到达端口的数据报，在使用 sendto 发送回发送者
		n = Recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);

		Sendto(sockfd, mesg, n, 0, pcliaddr, len);
	}
}

int main(int argc, char **argv)
{
	int					sockfd;
	struct sockaddr_in	servaddr;

	if (argc != 2)
		err_quit("usage: udpcli <IPaddress>");
    // 把服务器的 IP + port 填入一个地址结构，将该结构发送给 dg_cli，用来表示数据发送到哪里
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
    // 创建一个 UDP 套接字，调用 dg_cli
	sockfd = Socket(AF_INET, SOCK_DGRAM, 0);

	dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr));

	exit(0);
}

void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
{
	int	n;
	char	sendline[MAXLINE], recvline[MAXLINE + 1];
    // 从标准输入接收数据
	while (Fgets(sendline, MAXLINE, fp) != NULL) {
        // 发送给服务器
		Sendto(sockfd, sendline, strle n(sendline), 0, pservaddr, servlen);
        // 从服务器获取回射的数据
		n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);
        // 把数据的末尾置为 \0
		recvline[n] = 0;	/* null terminate */
        // 打印出来
		Fputs(recvline, stdout);
	}
}

void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
{
	int				n;
	char			sendline[MAXLINE], recvline[MAXLINE + 1];
	socklen_t		len;
	struct sockaddr	*preply_addr;
    // 分配一个地址结构
	preply_addr = Malloc(servlen);

	while (Fgets(sendline, MAXLINE, fp) != NULL) {

		Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);

		len = servlen;
		n = Recvfrom(sockfd, recvline, MAXLINE, 0, preply_addr, &len);
        // 判断目标地址和回来的数据报的发送地址是否一致，不一致的话就忽略
		if (len != servlen || memcmp(pservaddr, preply_addr, len) != 0) {
			printf("reply from %s (ignored)\n",
					Sock_ntop(preply_addr, len));
			continue;
		}

		recvline[n] = 0;	/* null terminate */
		Fputs(recvline, stdout);
	}
}

void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
{
	int		n;
	char	sendline[MAXLINE], recvline[MAXLINE + 1];
    // 对 UDP 套接字使用 connect
	Connect(sockfd, (SA *) pservaddr, servlen);

	while (Fgets(sendline, MAXLINE, fp) != NULL) {
        // 把传递函数换为 write 和 read
		Write(sockfd, sendline, strlen(sendline));

		n = Read(sockfd, recvline, MAXLINE);

		recvline[n] = 0;	/* null terminate */
		Fputs(recvline, stdout);
	}
}

	n = 220 * 1024;
    // 设置新的缓冲区大小为 n
	Setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n));

int main(int argc, char **argv)
{
	int					listenfd, connfd, udpfd, nready, maxfdp1;
	char				mesg[MAXLINE];
	pid_t				childpid;
	fd_set				rset;
	ssize_t				n;
	socklen_t			len;
	const int			on = 1;
	struct sockaddr_in	cliaddr, servaddr;
	void				sig_chld(int);

		/* 4create listening TCP socket */
    // 创建一个监听 TCP 套接字
	listenfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family      = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port        = htons(SERV_PORT);

	Setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
	Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));

	Listen(listenfd, LISTENQ);

		/* 4create UDP socket */
    // 创建一个 UDP 套接字并绑定和 TCP 相同的端口，并不需要设置端口重用套接字选项，因为 TCP 和 UDP 端口是重用的
	udpfd = Socket(AF_INET, SOCK_DGRAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family      = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port        = htons(SERV_PORT);

	Bind(udpfd, (SA *) &servaddr, sizeof(servaddr));
/* end udpservselect01 */

/* include udpservselect02 */
    // TCP 部分创建的子进程结束的信号处理部分
	Signal(SIGCHLD, sig_chld);	/* must call waitpid() */
    // 为 select 初始化一个描述符集，取最大的描述符值加一
	FD_ZERO(&rset);
	maxfdp1 = max(listenfd, udpfd) + 1;
	for ( ; ; ) {
		FD_SET(listenfd, &rset);
		FD_SET(udpfd, &rset);
        // 使用 select 判断 TCP 和 UDP 套接字是否可读
		if ( (nready = select(maxfdp1, &rset, NULL, NULL, NULL)) < 0) {
			if (errno == EINTR)
            // sig_chil 信号处理发送的错误，处理一下即可
				continue;		/* back to for() */
			else
				err_sys("select error");
		}
        // TCP 可读时，accept + fork + str_echo
		if (FD_ISSET(listenfd, &rset)) {
			len = sizeof(cliaddr);
			connfd = Accept(listenfd, (SA *) &cliaddr, &len);
	
			if ( (childpid = Fork()) == 0) {	/* child process */
				Close(listenfd);	/* close listening socket */
				str_echo(connfd);	/* process the request */
				exit(0);
			}
			Close(connfd);			/* parent closes connected socket */
		}
        // 如果 UDP 套接字可读，那么就有一个数据报到达，使用 recvfrom 读取，在使用 sendto 发回给客户
		if (FD_ISSET(udpfd, &rset)) {
			len = sizeof(cliaddr);
			n = Recvfrom(udpfd, mesg, MAXLINE, 0, (SA *) &cliaddr, &len);

			Sendto(udpfd, mesg, n, 0, (SA *) &cliaddr, len);
		}
	}
}