网络编程day3

多进程并发服务器

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/wait.h>

#define ERR_MSG(msg) do{\
    fprintf(stderr, "line:%d ", __LINE__);\
    perror(msg);\
}while(0)

#define IP "192.168.31.45"   //本机IP ifconfig
#define PORT 6666           //1024-49151

int deal_cli_msg(int newfd, struct sockaddr_in cin);

//回收僵尸进程
void handler(int sig)
{
    while(waitpid(-1, NULL, WNOHANG) > 0); 
}


int main(int argc, const char *argv[])
{
    //捕获17 SIGCHLD 号信号，回收僵尸进程
    __sighandler_t s = signal(17, handler);
    if(SIG_ERR == s)
    {   
        ERR_MSG("signal");
        return -1; 
    }   

    //创建流式套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0); 
    if(sfd < 0)
    {   
        ERR_MSG("socket");
        return -1; 
    }   
    printf("sfd = %d\n", sfd);

    //允许端口快速重用，当检测到该端口号没有被进程正常占用时候
	//允许端口快速被新的进程占用覆盖
    int reuse = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
    {   
        ERR_MSG("setsockopt");
        return -1; 
    }   
    printf("允许端口快速重用成功\n");



    //填充地址信息结构体，
    //真实的地址信息结构体根据地址族指定 AF_INET:man 7 ip
    struct sockaddr_in sin;
    sin.sin_family      = AF_INET;          //必须填AF_INET;
    sin.sin_port        = htons(PORT) ;     //端口号，1024~49151
    sin.sin_addr.s_addr = inet_addr(IP);    //本机IP， ifconfig
     //必须绑定
    //将IP和端口绑定到套接字上;
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
    {   
        ERR_MSG("bind");
        return -1; 
    }   
    printf("bind success __%d__\n", __LINE__); 

    //将套接字设置为被动监听状态，监听是否有客户端连接成功;
    if(listen(sfd, 128) < 0)
    {   
        ERR_MSG("listen");
        return -1; 
    }   
    printf("listen success __%d__\n", __LINE__);


    struct sockaddr_in cin;     //存储连接成功的客户端地址信息
    socklen_t addrlen = sizeof(cin);
    int newfd = -1; 
    pid_t cpid = 0;

	//从已完成连接的队列头中获取一个客户端信息，生成一个新的文件描述符
    while(1)
    {   
        //父进程只负责连接
        //阻塞函数，从已完成连接的队列头中获取一个客户端信息，生成一个新的文件描述符，
        //该文件描述符才是与客户端通信的文件描述符！！！
        newfd = accept(sfd, (struct sockaddr*)&cin, &addrlen);
        if(newfd < 0)
        {
            ERR_MSG("accept");
            return -1; 
        }
        printf("[%s:%d] newfd=%d 连接成功__%d__\n", \
                inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd, __LINE__);

        //能运行到当前位置，则代表有客户端连接成功，且生成一个新的newfd
		//需要创建一个子进程
             //用于与客户端交互 
        cpid = fork();
        if(cpid > 0)                                                                                
        {
            close(newfd);
        }
        else if(0 == cpid)   //子进程,与客户端交互
        {
            close(sfd);
            deal_cli_msg(newfd, cin);
            exit(0);            //退出子进程，子进程只负责交互，对应客户端退出后，结束子进程
        }
        else
        {
            perror("fork");
            return -1; 
        }


    }   
	//关闭文件描述符
    close(sfd);

    return 0;
}


int deal_cli_msg(int newfd, struct sockaddr_in cin)
{
    char buf[128] = ""; 
    ssize_t res = 0;
    while(1)
    {   
		//对于字符串的操作，操作之前或者操作之后要清空
		//防止之前的数据对这次操作有干扰
        bzero(buf, sizeof(buf));
        //接收
        res = recv(newfd, buf, sizeof(buf), 0); 
        if(res < 0)
        {
            ERR_MSG("recv");
            return -1; 
        }
        else if(0 == res)
        {
            printf("[%s:%d] newfd=%d 客户端下线__%d__\n", \
                    inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd, __LINE__);
            break;
        }
        printf("[%s:%d] newfd=%d : %s __%d__\n", \
                inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd, buf, __LINE__);

        //发送 将数据拼接字符串后发送回去
        strcat(buf, "*_*");
        if(send(newfd, buf, sizeof(buf), 0) < 0)
        {
            ERR_MSG("send");
            return -1; 
        }
        printf("发送成功\n");
    }   

    close(newfd);
    return 0;
}

多线程并发服务器

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <pthread.h>

#define ERR_MSG(msg) do{\
    fprintf(stderr, "line:%d ", __LINE__);\
    perror(msg);\
}while(0)

#define IP "192.168.31.45"   //本机IP ifconfig
#define PORT 6666           //1024-49151

//需要传递给线程处理函数的参数
struct cli_msg
{
    int newfd;
    struct sockaddr_in cin;
};


void* deal_cli_msg(void* arg);


int main(int argc, const char *argv[])
{
    //创建流式套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sfd < 0)
    {
        ERR_MSG("socket");
        return -1;
    }
    printf("sfd = %d\n", sfd);

    //允许端口快速重复使用     // 当检测到该端口号没有被进程正常占用时候
	

	//允许端口快速被新的进程占用覆盖
    int reuse = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
    {
        ERR_MSG("setsockopt");
        return -1;
    }
    printf("允许端口快速重用成功\n");



    //填充地址信息结构体，
    //真实的地址信息结构体根据地址族指定 AF_INET:man 7 ip
    struct sockaddr_in sin;
    sin.sin_family      = AF_INET;          //必须填AF_INET;
    sin.sin_port        = htons(PORT) ;     //端口号，1024~49151
    sin.sin_addr.s_addr = inet_addr(IP);    //本机IP， ifconfig

    //将IP和端口绑定到套接字上;
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
    {
        ERR_MSG("bind");
        return -1;
    }
    printf("bind success __%d__\n", __LINE__);

    //将套接字设置为被动监听状态     ，监听是否有客户端连接成功;
    if(listen(sfd, 128) < 0)
    {
        ERR_MSG("listen");
        return -1;
    }
    printf("listen success __%d__\n", __LINE__);


    struct sockaddr_in cin;     //存储连接成功的客户端地址信息
    socklen_t addrlen = sizeof(cin);
    int newfd = -1;
    pthread_t tid;
    struct cli_msg info;
    //阻塞函数，从已完成连接的队列头中获取一个客户端信息，生成一个新的文件描述符，
    //该文件描述符才是与客户端通信的文件描述符！！！
    while(1)
    {
        //主线程负责连接
        //预选文件描述符：阻塞在当前位置的时候会先预选一个没有被使用的文件描述符
        //当解除阻塞的时候，会判断该预选文件描述符是否被使用，
        //如果没有被使用，则直接返回该预选文件描述符
        //如果被使用，则重新遍历选择一个文件描述符返回。
        newfd = accept(sfd, (struct sockaddr*)&cin, &addrlen);
        if(newfd < 0)
        {
            ERR_MSG("accept");
            return -1;
        }
        printf("[%s:%d] newfd=%d 连接成功__%d__\n", \
                inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd, __LINE__);

        info.newfd = newfd;
        info.cin = cin;

        //能运行到当前位置，则代表有子进程连接成功，则需要创建一个分支线程用于与客户端交互
        if(pthread_create(&tid, NULL, deal_cli_msg, &info) != 0)
        {
            fprintf(stderr, "line:%d pthread_create failed\n", __LINE__);
            return -1;
        }

        pthread_detach(tid);        //分离线程
    }
	//关闭文件描述符
    close(sfd);

    return 0;
}

void* deal_cli_msg(void* arg)       //void* arg = &info
{
    //必须另存，如果使用全局变量，或者指针解引用的方式访问外部变量  
    //会导致每次accept函数运行成功后，newfd以及cin会被覆盖。

    int newfd = ((struct cli_msg*)arg)->newfd;
    struct sockaddr_in cin = ((struct cli_msg*)arg)->cin;

    char buf[128] = "";
    ssize_t res = 0;
    while(1)
    {
        bzero(buf, sizeof(buf));
        //接收
        res = recv(newfd, buf, sizeof(buf), 0);
        if(res < 0)
        {
            ERR_MSG("recv");
            break;
        }
        else if(0 == res)
        {
            printf("[%s:%d] newfd=%d 客户端下线__%d__\n", \
                    inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd, __LINE__);
            break;
        }
        printf("[%s:%d] newfd=%d : %s __%d__\n", \
                inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd, buf, __LINE__);

        //发送 将数据拼接字符串后发送回去
        strcat(buf, "*_*");
        if(send(newfd, buf, sizeof(buf), 0) < 0)
        {
            ERR_MSG("send");
            break;
        }                                                                                    
        printf("发送成功\n");
    }

    close(newfd);
    pthread_exit(NULL);
}