Linux c==网络编程、循环服务器、并发服务器、I/O多路转接

最新推荐文章于 2024-08-13 10:33:07 发布
最新推荐文章于 2024-08-13 10:33:07 发布
阅读量609 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31108501/article/details/53457303
版权 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netdb.h>

#define PORT 3333
#define MAX_SIZE 1024

int main()
{
    int sockfd;
    int new_fd;

    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;

    int n_read;
    int ser_size;
    int opt = 1;

    char buffer[MAX_SIZE];

    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("socket error!\n");
    exit(1);
    }

    printf("socket success.............!\n");

    if(setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)) < 0)
    {
        perror("set socket option error!\n");
    exit(1);
    }

    bzero(&server_addr,0);
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr("192.168.1.10"); 

    if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)
    {
        perror("bind error!\n");
    exit(1);
    }

    printf("bind success.............!\n");
    listen(sockfd,5);

    printf("listen success.............!\n");

    printf("accepting..................!\n");

    while(1)
    {
        ser_size = sizeof client_addr;

        if((new_fd = accept(sockfd,(struct sockaddr *)&client_addr,&ser_size)) < 0)
        {
            perror("accept error!\n");
        exit(1);
        }

        printf("accept success.................!\n");

    //read\recv

        printf("reading............!\n");
        n_read = read(new_fd,buffer,sizeof(buffer));

        if(n_read < 0)
        {
            perror("read client msg error!\n");
        exit(1);
        }

        buffer[n_read] = '\0';

        printf("recv msg = %s\n",buffer);
    }

    return 0;
}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89

客户端：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

#define PORT 3333
#define MAX_SIZE 1024

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        printf("Please input server ip!\n");
    exit(1);
    }

    int sockfd;
    int n_write;

    struct sockaddr_in server_addr;

    char buffer[MAX_SIZE];

    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("client socket error!\n");
    exit(1);
    }

    bzero(&server_addr,0);

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)
    {
        perror("connect server error!\n");
    exit(1);
    }

    while(1)
    {
        memset(buffer,0,sizeof(buffer));
    printf("Please input send msg:\n");
        gets(buffer);

        n_write = write(sockfd,buffer,strlen(buffer));

    if(n_write == -1)
    {
        perror("send to server msg error!\n");
        exit(1);
    }
    }

    return 0;
}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

缺点：只能接收到一个客户端，且等待其结束后才能接受下一个客户端

并发服务器：

服务器：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netdb.h>

#define PORT 3333
#define MAX_SIZE 1024

void * read_msg(void *arg)
{
    int n_read;

    int new_fd = *((int *)arg);

    char buffer[MAX_SIZE];

    printf("new_fd = %d\n",new_fd);

    while(1)
    {
        memset(buffer,0,sizeof(buffer));

    n_read = read(new_fd,buffer,sizeof(buffer));

    if(n_read < 0)
    {
        perror("recv client msg error!\n");
        exit(1);
    }

    if(n_read == 0)
    {
        printf("client is close!!\n");
        close(new_fd);
        pthread_exit(NULL);
    }

    buffer[n_read] = '\0';

    printf("recv msg:%s\n",buffer);
    }
}

int main()
{
    int sockfd;
    int new_fd;

    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;

    int n_read;
    int ser_size;
    int opt = 1;

    char buffer[MAX_SIZE];

    pthread_t id;

    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("socket error!\n");
    exit(1);
    }

    printf("socket success.............!\n");

    if(setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)) < 0)
    {
        perror("set socket option error!\n");
    exit(1);
    }

    bzero(&server_addr,0);
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr("192.168.1.10"); 

    if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)
    {
        perror("bind error!\n");
    exit(1);
    }

    printf("bind success.............!\n");
    listen(sockfd,5);

    printf("listen success.............!\n");

    printf("accepting..................!\n");

    while(1)
    {
        ser_size = sizeof client_addr;

        if((new_fd = accept(sockfd,(struct sockaddr *)&client_addr,&ser_size)) < 0)
        {
            perror("accept error!\n");
        exit(1);
        }

        printf("accept success.................!\n");

    pthread_create(&id,NULL,read_msg,&new_fd);
    }

    return 0;
}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113

客户端：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

#define PORT 3333
#define MAX_SIZE 1024

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        printf("Please input server ip!\n");
    exit(1);
    }

    int sockfd;
    int n_write;

    struct sockaddr_in server_addr;

    char buffer[MAX_SIZE];

    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("client socket error!\n");
    exit(1);
    }

    bzero(&server_addr,0);

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sockfd,(struct sockaddr *)&server_addr,sizeof server_addr) < 0)
    {
        perror("connect server error!\n");
    exit(1);
    }

    while(1)
    {
        memset(buffer,0,sizeof(buffer));
    printf("Please input send msg:\n");
        gets(buffer);

        n_write = write(sockfd,buffer,strlen(buffer));

    if(n_write == -1)
    {
        perror("send to server msg error!\n");
        exit(1);
    }
    }

    return 0;
}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

缺点：在客户端没有发送数据时，每个线程仍需轮流切换，浪费CPU资源

I/O多路转接：

服务器：

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

/* 宏定义端口号 */
#define portnumber 8000

#define MAX_LINE 80



int main(void)
{
    int  lfd;
    int cfd;
    int sfd;
    int rdy;

    struct sockaddr_in sin;
    struct sockaddr_in cin;

    int client[FD_SETSIZE];  /* 客户端连接的套接字描述符数组 */

    int maxi;
    int maxfd;                        /* 最大连接数 */

    fd_set rset;
    fd_set allset;

    socklen_t addr_len;         /* 地址结构长度 */

    char buffer[MAX_LINE];

    int i;
    int n;
    int len;
    int opt = 1;   /* 套接字选项 */

    char addr_p[20];



    /* 对server_addr_in  结构进行赋值  */
    bzero(&sin,sizeof(struct sockaddr_in));   /* 先清零 */
    sin.sin_family=AF_INET;                 //
    sin.sin_addr.s_addr=htonl(INADDR_ANY);  //表示接受任何ip地址   将ip地址转换成网络字节序
    sin.sin_port=htons(portnumber);         //将端口号转换成网络字节序

    /* 调用socket函数创建一个TCP协议套接口 */
    if((lfd=socket(AF_INET,SOCK_STREAM,0))==-1) // AF_INET:IPV4;SOCK_STREAM:TCP
    {
        fprintf(stderr,"Socket error:%s\n\a",strerror(errno));
        exit(1);
    }
    printf("socket!\n");

    /*设置套接字选项 使用默认选项*/
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    /* 调用bind函数 将serer_addr结构绑定到sockfd上  */
    if(bind(lfd,(struct sockaddr *)(&sin),sizeof(struct sockaddr))==-1)
    {
        fprintf(stderr,"Bind error:%s\n\a",strerror(errno));
        exit(1);
    }
    printf("bind!\n");

    /* 开始监听端口   等待客户的请求 */
    if(listen(lfd,20)==-1)
    {
        fprintf(stderr,"Listen error:%s\n\a",strerror(errno));
        exit(1);
    }
    printf("listen!\n");
    printf("Accepting connections .......\n");

    maxfd = lfd;                                /*对最大文件描述符进行初始化*/
    maxi = -1;

    /*初始化客户端连接描述符集合*/
    for(i = 0;i < FD_SETSIZE;i++)
    {
        client[i] = -1;
    }

    FD_ZERO(&allset);                     /* 清空文件描述符集合 */
    FD_SET(lfd,&allset);                    /* 将监听字设置在集合内 */


    /* 开始服务程序的死循环 */
    while(1)
    {
        rset = allset;
        printf("selecting!\n");
        /*得到当前可以读的文件描述符数*/
        rdy = select(maxfd + 1, &rset, NULL, NULL, NULL);

        printf("selected!\n");
        if(FD_ISSET(lfd, &rset))
        {

            addr_len = sizeof(sin);
            printf("accepting!\n");
            /* 接受客户端的请求 */
            if((cfd=accept(lfd,(struct sockaddr *)(&cin),&addr_len))==-1)
            {
                fprintf(stderr,"Accept error:%s\n\a",strerror(errno));
                exit(1);
            }
            printf("accepted!\n");


                     /*查找一个空闲位置*/
            for(i = 0; i<FD_SETSIZE; i++)
            {       //printf("%d\t",client[i]);
                if(client[i] <= 0)
                {
                    client[i] = cfd;   /* 将处理该客户端的连接套接字设置到该位置 */
                    break;
                }
            }

        /* 太多的客户端连接   服务器拒绝俄请求  跳出循环 */
            if(i == FD_SETSIZE)
            {
                printf("too many clients");
                exit(1);
            }

            FD_SET(cfd, &allset);     /* 设置连接集合 */

            if(cfd > maxfd)                  /* 新的连接描述符 */
            {
                maxfd = cfd;
            }

            if(i > maxi)
            {
                maxi = i;
            }

            if(--rdy <= 0)                /* 减少一个连接描述符 */
            {
                continue;
            }

        }

        /* 对每一个连接描述符做处理 */
        for(i = 0;i< FD_SETSIZE;i++)
        {
            if((sfd = client[i]) < 0)
            {
                continue;
            }

            if(FD_ISSET(sfd, &rset))
            {
                printf("reading!\n");
                n = read(sfd,buffer,MAX_LINE);
                printf("%s\n",buffer);
                printf("read!\n");
                if(n == 0)
                {
                    printf("the other side has been closed. \n");
                    fflush(stdout);                                    /* 刷新 输出终端 */
                    close(sfd);

                    FD_CLR(sfd, &allset);                        /*清空连接描述符数组*/
                    client[i] = -1;
                }

                else
                {
                    /* 将客户端地址转换成字符串 */
                    inet_ntop(AF_INET, &cin.sin_addr, addr_p, sizeof(addr_p));
                    addr_p[strlen(addr_p)] = '\0';

                    /*打印客户端地址 和 端口号*/
                    printf("Client Ip is %s, port is %d\n",addr_p,ntohs(cin.sin_port));


                    /* 谐函数出错 */
                    if(n == 1)
                    {
                        exit(1);
                    }
                }

                /*如果没有可以读的套接字   退出循环*/
                if(--rdy <= 0)
                {
                    break;


            }
        }

    }

    close(lfd);       /* 关闭链接套接字 */
    return 0;
}

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212

客户端：

#include <stdlib.h> 
#include <stdio.h> 
#include <errno.h> 
#include <string.h> 
#include <netdb.h> 
#include <sys/types.h> 
#include <netinet/in.h> 
#include <sys/socket.h> 

#define portnumber 8000

int main(int argc, char *argv[]) 
{ 
    int nbytes;
    int sockfd; 
    char buffer[80]; 
    char buffer_2[80];
    struct sockaddr_in server_addr; 
    struct hostent *host; 

    if(argc!=2) 
    { 
        fprintf(stderr,"Usage:%s hostname \a\n",argv[0]); 
        exit(1); 
    } 

    if((host=gethostbyname(argv[1]))==NULL) 
    { 
        fprintf(stderr,"Gethostname error\n"); 
        exit(1); 
    } 

     /* 调用socket函数创建一个TCP协议套接口 */ 
    if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1) // AF_INET:Internet;SOCK_STREAM:TCP
    { 
        fprintf(stderr,"Socket Error:%s\a\n",strerror(errno)); 
        exit(1); 
    } 


    bzero(&server_addr,sizeof(server_addr)); // 
    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(portnumber);
    server_addr.sin_addr = *((struct in_addr *)host->h_addr);//?


    if(connect(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1) 
    { 
        fprintf(stderr,"Connect Error:%s\a\n",strerror(errno)); 
        exit(1); 
    } 

    while(1){

    printf("Please input char:\n");


    fgets(buffer,1024,stdin); 
    write(sockfd,buffer,strlen(buffer));
       #if 1
    if((nbytes=read(sockfd,buffer_2,81))==-1) 
        { 
            fprintf(stderr,"Read Error:%s\n",strerror(errno));
            exit(1); 
        }

        buffer_2[nbytes]='\0';
        printf("Client received from Server %s\n",buffer_2);
        #endif


    }   
    close(sockfd);
    exit(0); 
} 

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76

优点：使用select来充当监管作用

沈二月
关注
Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)
09-27
在Linux 系统下面用C 语言实现的高并发服务器的代码，具体用到了Epoll，线程池，数据库连接池。 具体可以看下连接http://blog.csdn.net/wuyuxing24/article/details/48758927
Linux c==网络编程、循环服务器、并发服务器、I/O多路转接 (23)
女王有颗钻石心
12-04 540
循环服务器服务器#include <stdio.h> #include <stdlib.h> #include <string.h>#include <sys/types.h> #include <sys/socket.h> #include <sys/stat.h> #include <netdb.h>#define PORT 3333 #define MAX_SIZE 1024int main(
Linux网络编程之循环服务器（其一）
最新发布
weixin_61503529的博客
08-13 1025
循环服务器在同一个时刻只能响应一个客户端的请求，处理完一个客户端的工作后，才能处理下一个客户端的工作，就好像分时工作一样。循环服务器指的是对于客户端的请求和连接，服务器在处理完毕一个后，再处理另一个，即串行处理客户机的请求。这个I/O模型对应的是同步阻塞模型。有关五种网络I/O模型的详细了解，请参考下面的博客：Linux网络编程之I/O模型(详解)
Linux网络编程之循环服务器
02-18 1382
1.介绍 Linux网络循环服务器是指逐个处理客户端的连接，处理完一个连接后再处理下一个连接，是一个串行处理的方式，比较适合时间服务器，DHCP服务器.对于TCP服务器来说，主要阻塞在accept函数，等待客户端的连接。而对于UDP服务器来说，主要阻塞在recv函数. 2.循环服务器模型 TCP循环服务器: 算法如下:          socket(...);
Linux C 网络编程——5. 并发服务器
矩阵实验室
11-05 2526
1. 原理 在Linux C 网络编程——4. 简单TCP Socket程序中实现了一个最基本的基于TCP的CS通信， 这里介绍一种可以允许Server端可以同时处理多个请求（并发服务器）。 原理：每次accept服务器调用fork()，创建一个子进程处理请求。 2. 实现 只需要修改上一篇文章中的Server.c的while循环即可 while(1) { addr_
linux c 网络编程 并发
xiaopohaibebo的专栏
08-16 3863
[精华] Linux下各类TCP网络服务器的实现源代码 -------------------------------------------------------------------------------- http://www.chinaunix.net 作者:zhoulifa 发表于：2006-07-11 22:53:24 【发表评论】【查看原文】【Linux讨论区】【关闭】
网络编程4：高并发服务器——多路I/O转接服务器设计（select、poll、epoll）
snaking616
05-04 556
select、poll、epoll三者优缺点对比 1.select /* According to earlier standards */ #include <sys/time.h> #include <sys/types.h> #include <unis...
UNIX环境高级编程：文件I/O与多路转接
"I/O多路转接是UNIX环境高级...总而言之，这本书不仅介绍了UNIX系统的基础知识，还深入探讨了高级编程技术，特别是I/O多路转接在处理并发I/O问题上的应用，对于理解UNIX/Linux系统的内部运作和编写高效程序至关重要。
Linux下I/O多路复用(select、poll、epoll)，含函数解析及注意要点 ，干货满满！！
C__YUE的博客
03-24 1325
liunx下基于c/c++的网络编程中的I/O多路复用（select、poll、epoll）介绍。 select是 Linux 原生的、可跨平台的多路复用技术 poll在 Linux 系统中常被用于高并发网络服务器编程 epoll是一种优于poll的 I/O 多路复用机制，在 Linux 系统中常被用于高并发网络服务器编程；epoll 使用eopll_event 通过epoll_create、epoll_ctl 和 epoll_wait 这三个系统调用来实现事件多路转接。 #多路复用#多路复用#多路复用
linux网络编程－高并发服务器
KHY666的博客
12-03 390
linux网络编程－高并发服务器 1.多进程\多线程版高并发服务器(使用与客服端数量不多的情况，不适用与大型开发，该方法需要自己监听\处理对系统资源消耗太大．应用比如智能家居系统．) 2.多路I\O转接服务器（多任务I\O服务器） 核心思想：不再由应用程序自己监听客服端的连接，由内核替代．主要的实现方法有三种： 1> select 2> poll 3> epoll １．多进程\多线程版高并发服务器 1>．多进程版 /**********************************
多进程/多线程实现服务器的并发
oorik的博客
09-24 1925
上一节提到的 TCP Socket 调用流程是最简单、最基本的，它基本只能一对一通信，因为使用的是同步阻塞的方式，当服务端在还没处理完一个客户端的网络 I/O 时，或者 读写操作发生阻塞时，其他客户端是无法与服务端连接的。本节我们讲讲最简单的两种方式，使用多线程和多进程实现服务器的并发。
linuxC 多线程并发服务器
w12563489的博客
09-26 354
linux c 多线程并发服务器
linux c 多进程并发服务器
weixin_45715405的博客
11-08 542
文章目录1、流程2、代码 1、流程 需求：将客户端发送过来的数据，转换成大写，并将大写回过去 参考： Linux c socket套接字（看完测底明白六大函数使用） Linux c 通过信号回收N个子进程 1、socket 创建监听套接字 2、bind 绑定地址结构 3、lisen 链接上限 4、创建子进程 子进程： 4.1 关闭用于建立连接的文件描述符（使用不到） 4.2 读 4.3 将读到的内容改写成小写 4.4 写给客户端 4.5 循环此过程，当read读到的数据为0时
Linux网络编程服务器模型选择之循环服务器
weixin_30263073的博客
03-22 155
在网络程序里面，通常都是一个服务器处理多个客户机，为了出个多个客户机的请求，服务器端的程序有不同的处理方式。本节开始介绍Linux下套接字编程的服务器模型选择，主要包括循环服务器模型、并发服务器模型、IO复用服务器模型等，这也是我们常见的几种网络服务器模型。其中基本可以分为两大类， 1. 循环服务器：循环服务器在同一时刻只能响应一个客户端的请求，是比较简单的一种模型； 2. 并发服务...
Linux c 建立高并发服务器（select）实现
十四木的博客
08-21 1132
什么是select，为什么要用select 我们前面介绍过如何使用多进程的方式实现服务器，使服务器能同时和多个客户端相连接，那我可不可以使用一个进程就解决这个问题，答案是肯定的。使用select的主旨就是不让应用程序自己去监视连接，取而代之的使用内核来监视。而且select具有跨平台性，是不是觉得立马高端了不少，但是select的缺点也很明显我们后面在谈。 select的各个参数 先来看看selet这个函数 ...
Linux （UDP和TCP）循环服务器
Travelerwz的博客
08-26 1086
Linux （UDP和TCP）循环服务器 参考：https://blog.csdn.net/tennysonsky/article/details/45671215 ​ 《unix网络编程》 按照处理方式分为：循环服务器和并发服务器 ·循环服务器：服务器在同一时刻只能响应一个客户端的请求 ·并发服务器：服务器在同一时刻可以响应多个客户端的请求 UDP循环服务器实现方法 U...
简单循环服务器
chenrang1850的博客
08-13 94
客户端部分： 比较简单 创建socket 然后connect服务器，进行通讯 发送数据，并且接收数据，然后关闭 服务器部分： 服务器要做的是创建socket，初始化地址信息，并且绑定socket，然后进行监听 然互就是在循环里处理客户端连接上来的请求，并且接...
TCP(循环服务器)---Linux
qq_52467056的博客
03-07 3214
一、模型 服务器模型可以分： 循环服务器：在同一时刻只能相应一个客户端的请求 并发服务器：在同一时刻可以相应多个客户端的请求 二、基础的TCP循环服务器 服务器端： #include <stdio.h> #include <sys/types.h> #include <stdlib.h> #include <sys/socket.h> #include <netinet/in.h> #include &...
Linux I/O 多路复用技术在并发服务器中的应用
这个课程内容旨在帮助学习者理解并掌握如何通过非阻塞I/O和I/O多路复用来构建更加高效和可靠的并发服务器，这对于信息安全和产品开发实践至关重要。通过这样的技术，开发者可以设计出能处理大量并发连接的服务器，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值