【C语言】socket编程-2：客户端-服务器通信案例

最新推荐文章于 2021-11-03 17:07:30 发布

岳谷子

最新推荐文章于 2021-11-03 17:07:30 发布

阅读量612

点赞数

分类专栏： C学习

本文链接：https://blog.csdn.net/IPGsoz/article/details/105624607

版权

C学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1. 服务器

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



#define ERR_EXIT(m) \
                do\
                {\
                        perror(m);\
                        exit(EXIT_FAILURE);\
                }while(0)
int main(void)
{
        int listenfd;
        //1. 创建套接字（监听套接字）：安装一部电话机
        if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
                ERR_EXIT("socket");
        //2. 绑定地址：分配一个电话号码
        struct sockaddr_in servaddr;
        memset(&servaddr, 0, sizeof(servaddr));//初始化
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(5188);//端口用网络字节序，端口是2个字节，属于短字节
        /* 以下三种方式都可以绑定本机地址 */
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY表示本机的任意地址结构体，接受的是>网络字节序
        /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");//显式输入本机的地址 */
        /* inet_aton("127.0.0.1", &servaddr.sin_addr); */
        /*REUSEADDR: 重复使用地址，可防止当关闭服务器程序之后，地址进入CLOSE_WAIT状态，无法重新
        连接，因此如果将此socket设置为可重复使用地址类型，那么关闭服务器程序之后可以立马再次
        运行，不会报bind:Address already in use错误*/
        int on = 1;
        if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR/*definition?*/, &on, sizeof(on)) < 0)
                ERR_EXIT("setsockopt");
        /*REUSEADDR: to avoid the error -> bind: Address already in use */
        if (bind(listenfd, (struct sockaddr*)&servaddr,sizeof(servaddr)) < 0)
                ERR_EXIT("bind");

        //3. 监听状态
        //一般来说，listen函数应该在调用socket和bind函数之后，调用函数accept之前调用
        //listen将主动套接字变成被动套接字
        if ((listen(listenfd/*被动套接字*/, SOMAXCONN)) < 0)
                ERR_EXIT("listen");

        //4. 接受对等方连接
        struct sockaddr_in peeraddr;
        socklen_t peerlen = sizeof(peeraddr); //！！！长度必须有初始值，否则accpet函数返回失败
        int conn;//已连接套接字（非负整数）
                        //accept成功后，会自动返回客户端的socket地址（IP和端口）到peeraddr结构体
        if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)
                ERR_EXIT("accept");
                        //如果accept函数返回成功，则会将套接字从已完成连接队列中移走，以让更多客户端
可以连接进来
        //打印客户端的IP和端口
        printf("IP=%s, Port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));

        //5. 通信内容
        char recvbuf[1024];
        while (1)
        {
                memset(recvbuf, 0, sizeof(recvbuf));
                //从客户端接收
                int ret = read(conn/*主动套接字*/,recvbuf, sizeof(recvbuf));
                fputs(recvbuf, stdout);
                //回射给客户端
                write(conn, recvbuf, ret);//回射服务器，就是将接收到的字符串又发送回给客户端，所以这
里的字节数就是
                        //接收到的字符串的长度ret
        }
        //6. 关闭套接字
        close(conn);
        close(listenfd);
}

2. 客户端

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

#define ERR_EXIT(m) \
                do\
                {\
                        perror(m);\
                        exit(EXIT_FAILURE);\
                }while(0)

int main(void)
{
        int sock;
        //1. 创建套接字：安装一部电话机
        if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
                ERR_EXIT("socket");
        //2. 服务器套接字地址
        struct sockaddr_in servaddr;
        memset(&servaddr, 0, sizeof(servaddr));//初始化
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(5188);//服务器端口
        servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");//显式输入服务器的地址 */

        //3. connect发起连接
        //int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
        //连接成功后，会自动选择一个socket地址，主要是端口号（自动分配），IP为本机的地址
        if (connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
                ERR_EXIT("connect");
  //4. 通信内容
        char sendbuf[1024] = {0};
        char recvbuf[1024] = {0};
        while(fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
                //当标准输入不为空，即用户从标准输入输入数据
        {
                //发送给服务器
                write(sock, sendbuf, strlen(sendbuf));
                //从服务器接受回射
                read(sock, recvbuf, sizeof(recvbuf));
                fputs(recvbuf, stdout);//打印到标准输出

                //清空缓冲区
                memset(sendbuf, 0, sizeof(sendbuf));
                memset(recvbuf, 0, sizeof(recvbuf));
        }
        //4. 关闭套接字
        close(sock);

        return 0;
}

思考：

但是上面的服务器程序仍然还有一个问题，当服务器接受到一个客户端的连接请求之后，就立马进入了处理服务（接收-回射信息），而无法再监听和接受第二个乃至其他更多的客户端连接，即使客户端已经完成了三次握手已进入队列。因此，此案例只能进行一对一的通讯服务。

下面，将通过fork一个进程来处理其余套接字的连接请求，子进程用于处理通信服务，父进程则重新回去accept别的客户端请求。

void do_service(int conn);

#define ERR_EXIT(m) \
                do\
                {\
                        perror(m);\
                        exit(EXIT_FAILURE);\
                }while(0)
//Send and receive message
void do_service(int conn)
{
        char recvbuf[1024];
        while (1)
        {
                memset(recvbuf, 0, sizeof(recvbuf));
                //从客户端接收
                int ret = read(conn/*主动套接字*/,recvbuf, sizeof(recvbuf));
                fputs(recvbuf, stdout);
                if(ret == 0){
                    printf("client_close\n");//当客户端退出时，服务器端提示
                    break;//然后退出while循环，返回do_service
                }else if(ret == -1) {
                    ERR_EXIT("read")
                }
                //回射给客户端
                write(conn, recvbuf, ret);//回射服务器，就是将接收到的字符串又发送回给客户端，所以这
                                 // 里的字节数就是接收到的字符串ret   
         }
}

int main(void)
{
        int listenfd;
        //1. 创建套接字：安装一部电话机
        if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
                ERR_EXIT("socket");
        //2. 绑定地址：分配一个电话号码
        struct sockaddr_in servaddr;
        memset(&servaddr, 0, sizeof(servaddr));//初始化
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(5188);//端口用网络字节序，端口是2个字节，属于短字节
        /* 以下三种方式都可以绑定本机地址 */
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY表示本机的任意地址结构体，接受的是>网络字节序
        /* servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");//显式输入本机的地址 */
        /* inet_aton("127.0.0.1", &servaddr.sin_addr); */
        /*REUSEADDR: to avoid the error -> bind: Address already in use */
        int on = 1;
        if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR/*definition?*/, &on, sizeof(on)) < 0)
                ERR_EXIT("setsockopt");

        if (bind(listenfd, (struct sockaddr*)&servaddr,sizeof(servaddr)) < 0)
                ERR_EXIT("bind");

        //3. 监听状态
        //一般来说，listen函数应该在调用socket和bind函数之后，调用函数accept之前调用
        //listen将主动套接字变成被动套接字
        if ((listen(listenfd/*被动套接字*/, SOMAXCONN)) < 0)
                ERR_EXIT("listen");
        //4. 接受对等方连接
        struct sockaddr_in peeraddr;
        socklen_t peerlen = sizeof(peeraddr); //！！！长度必须有初始值，否则accpet函数返回失败
        int conn;//已连接套接字（非负整数）
                        //accept成功后，会自动返回客户端的socket地址（IP和端口）到peeraddr结    
                        //构体

        /*new create a son thread for accept a second connection*/
        pid_t pid;

        while(1) {
                if ((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)
                        ERR_EXIT("accept");
                        //如果accept函数返回成功，则会将套接字从已完成连接队列中移走，以让更多            
                        //客户端可以连接进来
                //打印客户端的IP和端口
                printf("IP=%s, Port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));

                pid = fork();//子进程
                if(pid == -1)
                        ERR_EXIT("fork");
                if(pid == 0){
                        //子进程用于处理通信服务，因此子进程不需要处理监听套接字
                        close(listenfd);
                        do_service(conn);//通信服务打包成do_service函数
                        exit(EXIT_SUCCESS);//do_service返回后，需要推出子进程，这个进程就没有存在的必要了
                }else{
                        //父进程回去处理accept函数，接受其他客户端请求
                        //因此父进程不需要处理已连接套接字，将其关闭
                        close(conn);
                }
        }
        return 0;
}

3. 套接字的分类

服务器端：

监听套接字：listenfd就是属于监听套接字，当与客户端三次握手成功之后，客户端进入已连接队列，accept() 函数从队列中返回一个连接，此连接为“已连接套接字”。监听套接字只负责监听、连接，不负责通信。
已连接套接字：当accept()返回之后，服务器就通过已连接套接字与客户端进行通信，为客户端提供服务。上面例子中的conn就是已连接套接字，它只负责通信，不负责连接。

客户端：

客户端只有一种套接字，那就是已连接套接字，因为客户端不需要监听。

像上面的例子，

当有一个服务器和3个客户端连接的时候，就总共有1个监听套接字，并返回3个已连接套接字，这3个已连接套接字是不同的，分别用于和对应的客户端通信，因此，不会发生串线的情况发生。

岳谷子

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
【C语言】socket编程-2：客户端-服务器通信案例

1. 服务器* ***************************************** *//* Echoserver.c *//* ***************************************** */#include <unistd.h>#include <sys/types.h>#include <sys/socke...
复制链接

扫一扫