TCP_server

最新推荐文章于 2024-02-05 21:37:33 发布
最新推荐文章于 2024-02-05 21:37:33 发布
阅读量406 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 网络编程 文章标签： socket server tcp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/shiyingkang___/article/details/76128714
本文介绍了网络编程的基本概念，包括创建套接字、绑定IP与端口、监听与接受连接等核心步骤，并提供了单进程、多进程及多线程版本的服务器端与客户端代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

编写代码前首先了解几个重要接口：

创建套接字：

创建套接字，其实是在创建一个文件描述符。

#include<sys/types.h>
#include<sys/socket.h>
int socket(int domain,int type,int protocol);

参数：
domain ：AF_INET 使用IPV4协议；
type：SOCK_STREAM 使用TCP协议；
protocol：0 状态参数；
返回值： 成功返回一个文件描述符sockfd，失败返回-1；

绑定IP，port：

#include<sys/types.h>
#include<sys/socket.h>
int bind(int sockfd,const struct sockaddr *addr,socklen_t addrlen);

参数：
sockfd：sock 要被绑定的文件描述符；
addr：sockaddr数据结构的地址；
addrlen：sockadde数据结构的大小（字节）；
返回值：成功返回0，失败返回-1；

参数中的‘struct sockaddr’ 结构体，是sock地址的泛型化接口，我们使用IPV4协议，使用的sockaddr接口应该是‘struct sockaddr_in’，因此在使用的时候需要进行地址的强制转化。

使用命令： grep -ER ‘struct sockaddr_in {’ /usr/include/
显示：/usr/include/linux/in.h:struct sockaddr_in {
键入命令： vim /usr/include/linux/in.h

可以查找结构体定义，如图：
这里写图片描述
因此在绑定IP，port之前首先要对’struct sockaddr_in’的对象进行赋值，也就是后面代码中的：

struct sockaddr_in local;
local.sin_family = AF_INET;
local.sin_addr.s_addr = inet_addr(ip);
local.sin_port = htons(port);

监听函数：

#include<sys/types.h>
#include<sys/socket.h>
int listen(int sockfd,int backlog);

参数：
sockfd：sock 要监听的文件描述符；
backlog：10 sockfd等待连接队列可能增长的最大长度；
返回值：成功返回0，失败返回-1；

接受一个连接：

#include<sys/types.h>
#include<sys/socket.h>
int accept(int sockfd,struct sockaddr *addr,socklen_t *addrlen);

参数：
sockfd：listen_sock 监听到连接的文件描述符
addr：&client 记录客户端IP，port的一个sockaddr结构的指针
addrlen：&len 调用者对其进行初始化，即client方的sockaddr结构大小
返回值：成功返回一个服务型的文件描述符，失败返回-1
因为要获取client方的IP，port信息，因此在函数调用前要先构建一个结构体对象：

struct sockaddr_in client;
socklen_t len = sizeof(client);

连接一台服务器：

#include<sys.types.h>
#include<sys/socket.h>
int connect(int sockfd,const struct sockaddr *addr,socklen_t addrlen);

参数:
sockfd：若该套接字是SOCK_STREAM,则尝试进行连接
addr：客户端sockaddr的地址
addrlen：客户端sockaddr的地址长度
返回值：成功返回0，失败返回-1

下面看看单进程版本服务器的代码，以及客户端代码：

//服务器server端:

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


void usage(char* str)
{
    printf("usage:%s [local_addr] [local_port]\n",str);
}

int startup(char* ip,int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        exit(2);
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port =htons( port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
    {
        perror("bind");
        exit(3);
    }

    if(listen(sock,10)<0)
    {
        perror("listen");
        exit(4);
    }
    return sock;
}

int main(int argc,char* argv[])
{
    if(argc<3)
    {
        usage(argv[0]);
        exit(1);
    }

    int listen_sock = startup(argv[1],atoi(argv[2]));

    while(1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int new_sock = accept(listen_sock,(struct sockaddr*)&client,&len);

        if(new_sock<0)
        {       
            perror("accept");
            continue;
        }
        printf("get a client: [%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));

        char buf[1024];
        while(1)
        {
            ssize_t s = read(new_sock,buf,sizeof(buf)-1);
            if(s>0)
            {
                buf[s] = 0;
                if(buf[0] != 0)
                {
                    printf("client:# %s\n",buf);
                    printf("Please Enter:");
                    fgets(buf,sizeof(buf),stdin);
                    write(new_sock,buf,strlen(buf)+1);
                    printf("Please Wait...\n");
                }
            }
            else if(s == 0)
            {
                printf("client send over\n");
                close(new_sock);
                break;
            }
            else
            {
                break;
            }
        }
    }
    close(listen_sock);
    return 0;
}

代码的大致情况是，首先创建一个套接字listen_sock，用来监听链接的，而这个套接字创建出来后先要绑定IP地址还有端口号，因为是一个服务器，所以要有固定的IP和port，然后监听链接，当有链接请求时，listen_sock被accept函数调用获得，client方的IP和port，从而成功建立链接，返回一个服务型的新的套接字new_sock,通过new_sock进行服务器与客户端的通信。

//客户client端：

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


void usage(char* str)
{
    printf("usage:%s [local_addr] [local_port]\n",str);
}

int startup(char* ip,int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        return 2;
    }

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(port);
    server.sin_addr.s_addr = inet_addr(ip);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server))<0)
    {
        perror("connect");
        return 3;
    }
    return sock;
}

int main(int argc,char* argv[])
{
    if(argc<3)
    {
        usage(argv[0]);
        exit(1);
    }

    int sock = startup(argv[1],atoi(argv[2]));

    printf("Connect to a server\n");

    while(1)
    {
        printf("Plesae Enter:");
        fflush(stdout);
        char buf[1024];
        fgets(buf,sizeof(buf),stdin);
        buf[sizeof(buf)-1] = 0;
        write(sock,buf,sizeof(buf));
        printf("Please wait ...\n");
        read(sock,buf,sizeof(buf));
        printf("server send:$ %s\n",buf);
    }
    close(sock);
    return 0;
}

与服务器端大致相同，因为client是发起连接请求的一端，所以client不需要绑定IP和port，也不需要进行监听，而获得一个链接，也就变成发起连接请求，建立连接成功后，就可以进行通讯了。

makefile：

.PHONY:all
all:server client
server:server.c
    gcc -o $@ $^
client:client.c
    gcc -o $@ $^
.PHONY:clean
clean:
    rm -f server client

多进程版本的服务器代码：

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


void usage(char* str)
{
    printf("usage:%s [local_addr] [local_port]\n",str);
}

int startup(char* ip,int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        exit(2);
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port =htons( port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
    {
        perror("bind");
        exit(3);
    }

    if(listen(sock,10)<0)
    {
        perror("listen");
        exit(4);
    }
    return sock;
}

int main(int argc,char* argv[])
{
    if(argc<3)
    {
        usage(argv[0]);
        exit(1);
    }

    int listen_sock = startup(argv[1],atoi(argv[2]));

    while(1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int new_sock = accept(listen_sock,(struct sockaddr*)&client,&len);

        if(new_sock<0)
        {       
            perror("accept");
            continue;
        }
        printf("get a client: [%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));



        pid_t id=fork();
        if(id<0)
        {
            perror("fork");
            close(new_sock);
            continue;
        }
        else if(id == 0)
        {
            close(listen_sock);
            if(fork()>0)
            {
                exit(0);
            }
            else
            {
                char buf[1024];
                while(1)
                {
                    ssize_t s = read(new_sock,buf,sizeof(buf)-1);
                    if(s>0)
                    {
                        buf[s] = 0;
                        if(buf[0] != 0)
                        {
                            printf("client[%s,%d]:# %s\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port),buf);
                            write(new_sock,buf,strlen(buf)+1);
                        }
                    }
                    else if(s == 0)
                    {
                        printf("client[%s:%d]send over\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
                        close(new_sock);
                        break;
                    }
                    else
                    {
                        close(new_sock);
                        break;
                    }

                }
                exit(5);
            }
        }
        else
        {
            close(new_sock);
            waitpid(id,NULL,0);
        }
    }
    close(listen_sock);
    return 0;
}

在单进程版本的基础上，在成功获取到一个连接后，使用fork函数创建子进程，让子进程去进行与客户端的通讯，因为子进程不需要监听，所以关闭listen_sock，父进程重新去获得一个新的连接，不需要进行与客户端的通信，因此关闭new_sock，但是由于子进程尚未退出，父进程需要进行等待，这样的话，事实上还是一个单进程的服务器，因此在子进程内部在fork一个子进程，让子进程的子进程去与客户端进行通讯，自己直接退出，这样父进程收到了子进程退出的信号，父进程就回去等待新的连接建立，而子进程的子进程，由于他的父进程直接退出，导致他变成孤儿进程，当他与客户端完成通信。他就会被操作系统回收。

多线程版本server服务器代码：

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



void usage(char* str)
{
    printf("usage:%s [local_addr] [local_port]\n",str);
}

int startup(char* ip,int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        exit(2);
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port =htons( port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
    {
        perror("bind");
        exit(3);
    }

    if(listen(sock,10)<0)
    {
        perror("listen");
        exit(4);
    }
    return sock;
}

void* handler_request(void* arg)
{
    int new_sock = *(int*)arg;
    char buf[1024];
    while(1)
    {

        ssize_t s = read(new_sock,buf,sizeof(buf)-1);
        if(s>0)
        {
            buf[s] = 0;
            if(buf[0] != 0)
            {
                printf("client:# %s\n",buf);
                write(new_sock,buf,strlen(buf)+1);
            }
        }
        else if(s == 0)
        {
            printf("client send over\n");
            close(new_sock);
            break;
        }
        else
        {
            close(new_sock);
            break;
        }

    }
    close(new_sock);
    return (void*)0;
}

int main(int argc,char* argv[])
{
    if(argc<3)
    {
        usage(argv[0]);
        exit(1);
    }

    int listen_sock = startup(argv[1],atoi(argv[2]));

    while(1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int new_sock = accept(listen_sock,(struct sockaddr*)&client,&len);

        if(new_sock<0)
        {       
            perror("accept");
            continue;
        }
        printf("get a client: [%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));

//     多线程版本
        pthread_t fid;
        pthread_create(&fid,NULL,(void*)handler_request,&new_sock);
        pthread_detach(fid);

    }
    close(listen_sock);
    return 0;
}

多线程版本服务器，是利用现成的可分离性来实现，多人连接服务器的；

//makefile
server:server.c
    gcc -o $@ $^ -lptnread
.PHONY:clean
clean:
    rm -f server

因为server.c加入了线程的库，使用了线程接口，因此在编译时要链接线程静态的库；

多线程版本中出现了两个新的函数接口：

//创建新线程：
#include<pthread.h>
int pthread_create(pthread_t *thread,const pthread_attr_t *attr,void *(*start_routine) (void *),void *arg);

参数：
thread：新创建启动的线程
start_routine：新建线程的启动例程；
arg：给启动历程传参；
返回值：成功返回0；失败返回错误码

//线程分离：
#include<pthread.h>
int pthread_detach(pthread_t thread);

参数：
thread：要分离的线程
返回值：成功返回0，失败返回错误码

网络-tcp-服务器(server)
weixin_44786231的博客
04-07 871
import socket def main(): # 1. 买个手机(创建套接字 socket) tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 2. 插入手机卡(绑定本地信息 bind) tcp_server_socket.bind(("", 7890)) ...
TCP--server
yangjinkui的博客
06-23 1150
一个在linux下的基于tcp的服务器和客户端；具体的网络基础参照谢希仁老师的《计算机网络》来入门；在TCP/IP协议中,“IP地址+TCP或UDP端⼜号”唯⼀标识⽹ 络通讯中的⼀个进程,“IP地址+端⼜号”就称为socket；先说一些规定吧： TCP/IP协议规定,⽹络数据流应采⽤⼤端字节序,即低地址⾼字节。 先发出的数据是低地址,后发出的数据是⾼地址。 所以为了程序的移植性，系统提供了一些接口
tcp_server
09-17
简单的tcp——sever端，可以实现与client端的通信。经测试有效。
TCP_Server
xiaochuan1984的博客
08-27 1669
通过监听本地端口，实现多线程TCP连接；
mock_tcp_server:一个 tcp 服务器模拟，如果接收到一些匹配的字节，它将响应特定的文件数据
06-27
server.conf { " host " : " 127.0.0.1 " , " port " : 8080 , " dump_request " : true , " matchs " : [{ " type " : " string " , " match_data " : " efg " , " response_file " : " test_1.txt " }, { ...
TCP_Server_and_Client.rar_tcp_tcp class_tcp server client
09-24
本资源“TCP_Server_and_Client.rar”似乎提供了一个基于TCP的服务器和客户端的基础框架，允许开发者通过继承和使用纯虚函数来实现特定的通信任务，从而方便代码的复用和移植。 TCP是一种面向连接的协议，它在数据...
tcp_server_honorus2_pythonTCP_tcp_tornado_pythonserver_
10-01
标题中的"tcp_server_honorus2_pythonTCP_tcp_tornado_pythonserver_"表明这是一个关于使用Python的Tornado框架构建TCP服务器的项目。Tornado是一个强大的、异步的网络库，特别适合处理高并发的TCP连接，常用于实时...
TCP_Server_test.zip_TCP test_tcp server
09-20
本文将深入探讨TCP服务器测试及其在多进程环境中的应用，以标题"TCP_Server_test.zip_TCP test_tcp server"和描述"简单TCP客户端应用程序（采用多进程书写）"为基础，讲解相关知识点。 首先，TCP是一种面向连接的、...
Tcp从Socket客户端上传文件到ServerSocket服务端
tang_tang1030的博客
06-16 2924
目的： 从客户端上传指定的文件到服务端，服务端返回上传结果 思路： 一、客户端：        1.创建客户端Socket，指定好IP地址和端口号        2.创建要上传的文件流对象        3.创建写入流(网络流)，从Socket获取。将指定文件写入到网络流中，以便服务端接收        4.从网络流中接收服务端返回的信息        5.关闭流资源 二
TCP/IP 某些最常见的错误原因码 (errno)列表
热门推荐
hireboy的专栏
05-28 1万+
--------------------------------------------------------------------------------     对于 OS/2 环境中的 TCP/IP 用户，下面的列表显示了最常见的 errno。它不是完整的错误列表。可以在文件 nerrno.h 中找到 Errno。此文件是 TCP/IP 产品包含文件的一部分。若尚未安装这些文件，则在您
【Socket网络通信 | 3.建立TCP Server】
你看的代码还不够多
01-23 3047
Socket网络通信 1、htons(port) 转换字节序 2、sock_addr.sin_addr 指定IP地址 一、Server 端必用的几个API 1.bind （用于绑定端口） 2.listen （监听端口） 3.accept （获取用户的连接信息）
简单的TcpServer（英译中）
weixin_70056514的博客
02-05 1705
实现一个简单的英译汉的功能。 下面介绍程序中用到的socket API,这些函数都在sys/socket.h中。socket()打开一个网络通讯端口,如果成功的话,就像open()一样返回一个文件描述符； 应用程序可以像读写文件一样用read/write在网络上收发数据； 如果socket()调用出错则返回-1； 对于IPv4, family参数指定为AF_INET； 对于TCP协议,type参数指定为SOCK_STREAM, 表示面向流的传输协议； protocol参数的就不做介绍了,指定为0即可。 服务
编写tcp_server
小葱的博客
07-24 8142
背景知识： 1.在TCP/IP协议中，IP地址+TCP/UCP端口号 —-》唯一标识网络通讯中的一个进程， 并且IP地址+端口号被称为socket。 2.内存中的多字节数据相对于内存地址有大端和小端之分， 而网络数据流同样有大端和小端之分。 TCP/IP协议规定，网络数据流应采用大端字节序，即就是低地址高字节。 所以：发送端把数据发送到发送缓冲区之前需要做字节序的转换。 而接收主机在
TCP server
alanzn的专栏
05-24 460
void CServerDlg::OnBUTTONOpen() {  //加载WSA //  WORD wVersionRequested; //  WSADATA wsaData; //  int err; //  wVersionRequested = MAKEWORD( 2, 2 ); //  err = WSAStartup( wVersionRequested, &wsa
hadoop搭建细节超全
最新发布
08-20
Hadoop超细节搭建，可以看看
``` CC=gcc CFLAGS=-Wall all:tcp_client tcp_server tcp_server:tcp_server.c $(CC) tcp_server.c -Wall -o tcp_server -lpthread clean: rm tcp_server tcp_client```请解释这个代码
03-09
然后看tcp_server目标，它依赖于tcp_server.c，编译命令使用gcc并链接pthread库。这里需要注意编译命令是否使用了CFLAGS变量，但实际用的是-Wall，可能用户应该用$(CFLAGS)来保持一致性。另外，-lpthread的位置是否...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值