#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>

#define USE_THREADS 1 // 1 多线程方式， 0 用多进程方式
//#define SERV_IP_ADDR "192.168.1.100"
#define SERV_PORT 9999

#if USE_THREADS
#include <pthread.h>
#else
#include <sys/wait.h>
#include <signal.h>
void sig_child_handle(int signo);
#endif

void cli_data_handle(void *argc);

int main (int argv, char **argc)
{
    int fd;
    struct sockaddr_in sin = {0};

    /* 创建套接字 */
    fd = socket(AF_INET, SOCK_STREAM, 0); //创建流式套接字，fd：套接字文件描述符
    if (fd < 0)
    {
        perror("socket");
        exit(-1);
    }

    // 优化3：运行绑定地址快速重用
    int b_reuse = 1;
    setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof(int));

    /* 初始化 struct sockaddr_in */
    sin.sin_family = AF_INET; // 网络族
    sin.sin_port = htons(SERV_PORT); // 端口号转成网络字节序
    
	// 优化1：让服务器能绑定在任意的ip上
	sin.sin_addr.s_addr = htonl(INADDR_ANY); // INADDR_ANY其实等于-1，这样整形所有的位都是1
    
    /* 绑定套接字 */
    if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)  
    {
        perror("bind");
        exit(-1);
    }

    /* 把主动套接字变成被动套接字 */
    if (listen(fd, 5) < 0)
    {
        perror("listen");
        exit(-1);
    }

    /* 阻塞等待客户端链接请求 */
    int newfd;
    struct sockaddr_in cin;
    socklen_t clen = sizeof(cin);

#if USE_THREADS   // 多线程方式运行服务端
    printf("sever is run threads\n");
    while(1)
    {
        newfd = accept(fd, (struct sockaddr *)&cin, &clen); // 得到新连接的客户端信息
        if (newfd < 0) 
        {
            perror("accept");
            exit(-1);
        }

        char ipv4_addr[16];
        if (!inet_ntop(AF_INET, (void *)&cin.sin_addr, ipv4_addr, clen))
        {
            perror("inet_ntop");
            exit(-1);
        }
        printf("new client is connectde : %s:%d\n", ipv4_addr, htons(sin.sin_port));

        // 优化2：没连接一个客户端创建一个线程专门处理这个客户端的读写
        pthread_t tid;
        pthread_create(&tid, NULL, (void *)cli_data_handle, (void *)&newfd);
    }
    
    close (fd);

    return 0;
}
#else	// 多进程方式运行服务端
    printf("sever is run process\n");
    pid_t pid = -1;

    // 设置进程在接收到SIGCHID信号时的处理函数，子进程结束会发SIGCHID信号给父进程
    signal(SIGCHLD, sig_child_handle);

    while (1)
    {
        newfd = accept(fd, (struct sockaddr *)&cin, &clen); // 得到新连接的客户端信息
        if (newfd < 0) 
        {
            perror("accept");
            exit(-1);
        }

        pid = fork(); // 创建一个子进程

        if (pid < 0)
        {
            perror("fork");
            exit(-1);
        }
        else if (pid == 0) // 子进程
        {
            close(fd); // 不需要就关闭父进程继承过来的
            char ipv4_addr[16];
            if (!inet_ntop(AF_INET, (void *)&cin.sin_addr, ipv4_addr, clen))
            {
                perror("inet_ntop");
                exit(-1);
            }
            printf("new client is connectde : %s:%d\n", ipv4_addr, ntohs(sin.sin_port));

            cli_data_handle((void *)&newfd);
            exit(1); // 对方断开了结束子进程
        }
        else // 父进程
        {
            close(newfd); // 父进程用不到为了不浪费资源就关闭
            /* 父进程继续下次循环等待accept（）返回 */
        }
    }
}

/* 进程接收到SIGCHID信号的处理函数 */
void sig_child_handle(int signo)
{
    if (SIGCHLD == signo)
    {
        waitpid(-1, NULL, WNOHANG); // 非阻塞查询是否有子进程结束需要回收
    }
} 
#endif

/* 与客户端的接收、发送处理函数 */
void cli_data_handle(void *argc)
{
    int cfd = *(int *)argc;
    
    /* 读写套接字 */
    #define BUF_SIZE 1024
    int ret = -1;
    char buf[BUF_SIZE];

    while (1) 
    {
        bzero (buf, BUF_SIZE); // 数组清零
        do 
        {
            ret = read (cfd, buf, BUF_SIZE-1);
        } while (ret < 0 && EINTR == errno); // EINTR读文件被中断，继续读文件

        if (ret < 0) 
        {
            perror ("read");
            exit (-1);
        }

        if (0 == ret) //对方已经关闭，文件读完了到文件末尾了
        { 
            break;
        }
        printf ("Receive data : %s\n", buf);

        if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
        {
            printf("Client is exiting!\n");
            break;
        }

        if (write(cfd, buf, strlen(buf) + 1) < 0) //发送数据到客户端
        {
            perror ("write");
            exit (-1);
        }
    }
	// 如果是线程处理函数，函数退出后就会自动删除该线程
    close (cfd);
}

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>

void usage(char *s)
{
    printf("\n%s serv_ip serv_port", s);
    printf("\n\t serv_ip: server ip address");
    printf("\n\t serv_port: server port(>5000)\n\n");
}

int main (int argc, char **argv)
{
    int fd;
    short port;
    struct sockaddr_in sin = {0};
    
    if (argc < 3)
    {
        usage(argv[0]);
        exit(1);
    }

    port = atoi(argv[2]);
    if (port < 5000)
    {
        usage(argv[0]);
        exit(1);
    }
    /* 创建套接字 */
    fd = socket(AF_INET, SOCK_STREAM, 0); //创建流式套接字，fd：套接字文件描述符
    if (fd < 0)
    {
        perror("socket");
        exit(-1);
    }

    /* 初始化 struct sockaddr_in */
    sin.sin_family = AF_INET; // 网络族
    sin.sin_port = htons(port); // 端口号转成网络字节序
    sin.sin_addr.s_addr = inet_addr(argv[1]); // 将点斜式ip转成整形ip，内部自动转成网络字节序

    /* 连接服务器 */
    if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        perror("bind");
        exit(-1);
     }
    printf("conect sever success\n");

    /* 读写套接字 */
    #define BUF_SIZE 1024
    char buf[BUF_SIZE];

    while (1)
    {
        bzero (buf, BUF_SIZE); // 数组清零
        if (fgets(buf, BUF_SIZE, stdin) < 0)
        {
                continue;
        }
        write(fd, buf, strlen(buf));

        if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
        {
                printf("Client is exiting!\n");
                break;
        }
    }

    close (fd);

    return 0;
}