Linux：TCP Socket编程（代码实战）

最新推荐文章于 2024-05-04 00:25:15 发布
最新推荐文章于 2024-05-04 00:25:15 发布
阅读量2.4k 收藏 19
点赞数 9
分类专栏： Linux/网络/操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43937101/article/details/118190838
版权

目录

1. TCP的Socket编程

1.1 TCP的编程流程

和UDP编程一样，我们在考虑TCP的时候也要考虑到接收方和发送方，也就是是说要考虑接收方和发送方的，但是由于TCP是有连接，可靠有序且面向字节流的传输层协议，因此，TCP的编程流程要比UDP复杂一些。

用图来表示的话如下：
在这里插入图片描述

1.2 TCP Socket的接口

创建套接字socket()、关闭套接字close()和绑定地址信息bind()这三个函数均和UDP的一样，可以看我之前写的这篇文章

1.2.1 服务端监听连接接口

int listen(int sockfd, int backlog);

参数：

  • sockfd：套接字描述符
  • backlog：已完成连接队列的大小

    注：服务端和客户端在进行三次握手的过程中，会存在两个队列，一个是已完成连接的队列，一个是未完成连接的队列，未完成连接的队列中存储的是没有完成三次握手的连接；而已完成连接的队列中存储的是已经完成三次连接，并且等待被服务端"accept"的连接，或者也可以理解为当前连接状态为"ESTABLISHED"的连接。

对backlog参数的具体理解：

由于TCP连接首先要进行三次握手，而想要和服务端建立连接的客户端却有很多个，在同一时间内可能会有多个客户端再和服务端进行三次握手。而backlog控制的就是已完成连接队列的大小，因此backlog影响了服务端在一瞬间的连接的接收能力，或者说影响了服务端并发接收新连接的能力，注意不能将其理解为 服务端建立连接的数量。

1.2.2 服务端获取新连接接口

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

作用：

从已完成连接队列中获取已经完成三次握手的连接。（当没有连接的时候，调用该接口会发送阻塞）

参数：

  • sockfd：套接字描述符
  • addr：客户端的地址信息结构
  • addrlen：客户端的地址信息结构的长度

返回值：(非常重要)

成功则返回新连接的套接字描述符，失败则返回-1。

对accept返回值的深入理解：

如图：
在这里插入图片描述
这就是为什么返回值如此重要原因，因为他关系着后面收发数据时所对应在服务端中的缓冲区时哪一个。

1.2.3 客户端发起连接接口

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数：

  • sockfd：套接字描述符
  • addr：服务端的地址信息结构
  • addrlen：服务端的地址信息结构的长度

返回值：

成功则返回0，失败则返回小于0的数。

1.2.4 发送数据接口

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

参数：

  • sockfd：套接字描述符
  • buf：待要发送的数据
  • len：待要发送数据的长度
  • flags：0为阻塞发送，MSG_OOB为发送带外数据

带外数据：即在紧急情况下所产生的数据，会越过前面进行排队的数据优先进行发送。

返回值：

成功则返回的字节数量，失败则返回-1。

1.2.5 接收数据接口

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

参数：

  • sockfd：套接字描述符
  • buf：将接收到的数据放到buf中
  • len：接收数据的长度
  • flags：0为阻塞接收，即如果没有发送数据，则recv接口会阻塞

返回值：

  • >0：正常接收了多少字节的数据
  • ==0：对端将连接关闭（即对端机器调用了close函数关闭了套接字）
  • >0：接收失败

1.3 三次握手的简单验证

由于三次握手是操作系统内核自动完成的，因此我们只需要给出服务端的的代码到listen接口即可。

#include <unistd.h>
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <iostream>

using namespace std;


int main()
{
    //1. 创建套接字
    int sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    if(sockfd < 0)
    {
        cout << "TCP socket failed" << endl;
        return 0;
    }

    //2.绑定地址信息
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(18989);
    addr.sin_addr.s_addr = inet_addr("0.0.0.0");
    int ret = bind(sockfd,(struct sockaddr *)&addr,sizeof(addr));
    if(ret < 0)
    {
        cout << "bind failed" << endl;
        return 0;
    }

    //3.进行侦听(告诉OS内核可以与客户端建立连接了)
    //listen函数中blocklog参数，设定的是已完成三次握手并已建立连接的队列的容量
    ret = listen(sockfd,1);
    if(ret < 0)
    {
        cout << "listen failed" << endl;
        return 0;
    }
    while(1)
    {};
    return 0;
}

要测试三次握手是否成功，我们不需要编写客户端代码进行验证，而是借助windows下的一个工具telnet，telnet可以模仿TCP进行三次握手，就只是单纯的建立连接，其他什么都不会做。

使用telnet + 公网ip + 端口号即可对其进行测试，需要注意的是，这条命令是在windows下的cmd窗口运行的。

首先我们需要将服务端运行起来然后再使用telnet进行测试
在这里插入图片描述
当一回车之后，会新弹出一个telnet的窗口，代表三次握手成功。
在这里插入图片描述
下面给出两种失败的情况
情况1：端口不存在
在这里插入图片描述
情况2：公网ip错误
在这里插入图片描述

我们多使用telnet建立几次连接，然后看看当前服务器端口的使用情况。
这里总共使用telnet与当前服务器进行了三次的连接，即进行了三个三次握手，而我们在代码中设置的已完成连接的队列的大小为1，我们可以使用netstat -anp | grep 18989查看18989端口的使用情况。
在这里插入图片描述
我们可以清楚的看到该服务端建立了两次连接，但是我们设置的backlog为1，按理说只能连接一次，那这是什么情况呢？原因是操作系统内核的问题，内核中的代码逻辑是这样的

// q为 已完成连接队列   ，capacity_为当前我们设置的backlog的大小
if(q.size() < capacity_)
{
	//不建立连接 
}

因此，根据这个逻辑来分析，他会建立两次连接，是正常的，并不是我们代码的问题。
但是有一点需要注意的是，在验证三次握手的时候，我们服务器端的代码绝对不能用accept来接收，因为一旦用accept接收之后，就会从当前已完成队列中取走一个连接，导致我们看到的连接结果会多一条，如图：
在这里插入图片描述

2. 代码实战

本次TCP的代码有三种形式：单进程版本、多进程版本和多线程版本，但是这些版本均只是针对服务端而言，其中单进程和多进程的客户端的代码都是相同的，因此在这里我们首先给出客户端的代码。

#include <unistd.h>
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <iostream>

using namespace std;

/*
 * 1. 创建套接字
 * 2. 建立连接请求
 * 3. TCP三次握手建立连接----OS会自动进行，不需要我们进行控制
 * 4. 接收数据、发送数据
 * 5. 关闭套接字
 */ 

int main()
{
    //1. 创建套接字
    int sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    if(sockfd < 0)
    {
        cout << "TCP socket failed" << endl;
        return 0;
    }

    //2.进行连接
    //0.0.0.0：任意网卡地址，注意不是任一，它的含义就是哪个网卡地址都行
    //当服务器端绑定的地址为0.0.0.0，那么我们客户端想要与服务端建立连接的时候
    //有两种方法： 
    //1.若是运行服务器的这台机器本身是能够上网的，
    // 那么我们只需要连接它的网卡地址中的任意一个就行，(0.0.0.0为任意地址)
    //2.若是运行服务器的这台机器是要经过类似于腾讯云、阿里云这样的
    // 云服务器读对私网ip进行转换才能上网的，那么我们就需要连接它的公网ip。
    
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(18989);
    //此处我们使用的公网ip
    addr.sin_addr.s_addr = inet_addr("118.89.67.215");

    int ret = connect(sockfd,(struct sockaddr *)&addr,sizeof(addr));
    if(ret < 0)
    {
        cout << "connnect failed" << endl;
        return 0;
    }

    //3.接收和发送数据
    while(1)
    {
        //这里接收数据和发送数据是没有顺序而言的
        //因为已经经过三次握手，客户端和服务端的连接以及建立成功了
        char buf[1024] = {0};
        
        //发送数据
        sprintf(buf,"hello server,i am client2\n");
        ssize_t send_ret = send(sockfd,buf,strlen(buf),0); 
        if(send_ret < 0)
        {
            cout << "send failed" << endl;
            continue;
        }
        memset(buf,'\0',sizeof(buf));

        ssize_t recv_size = recv(sockfd,buf,sizeof(buf)-1,0);
        if(recv_size < 0)
        {
            cout << "recv failed" << endl;
            continue;
        }
        else if(recv_size == 0)
        {
            cout << "Peer close" << endl;
            close(sockfd);
            return 0;
        }
        
        cout << "recv data is : " << buf << endl;


    }

    close(sockfd);
    return 0;
}

2.1 单进程版本的TCP代码

单进程版本的服务端代码如下：

#include <unistd.h>
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <iostream>

using namespace std;

/*
 * 1. 创建套接字
 * 2. 绑定地址信息
 * 3. 进行监听--(告诉OS内核可以接收客户端发送的新请求了并且监听新连接的到来)
 * 4. TCP三次握手建立连接----OS会自动进行，不需要我们进行控制
 * 5. 接收新连接
 * 6. 接收数据、发送数据
 * 7. 关闭套接字
 */ 

int main()
{
    //1. 创建套接字
    int sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    if(sockfd < 0)
    {
        cout << "TCP socket failed" << endl;
        return 0;
    }

    //2.绑定地址信息
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(18989);
    addr.sin_addr.s_addr = inet_addr("0.0.0.0");
    int ret = bind(sockfd,(struct sockaddr *)&addr,sizeof(addr));
    if(ret < 0)
    {
        cout << "bind failed" << endl;
        return 0;
    }

    //3.进行侦听(告诉OS内核可以与客户端建立连接了)
    //listen函数中blocklog参数，设定的是已完成三次握手并已建立连接的队列的容量
    ret = listen(sockfd,1);
    if(ret < 0)
    {
        cout << "listen failed" << endl;
        return 0;
    }

    //4.接收新连接
    struct sockaddr_in client_addr;
    socklen_t socklen = sizeof(client_addr);
    int new_sockfd = accept(sockfd,
    			(struct sockaddr *)&client_addr,&socklen);

    if(new_sockfd < 0)
    {
        cout << "accept failed" << endl;
        return 0;
    }

    printf("accept success: %s:%d, and new_sockfd is %d\n",
    inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port),
    			new_sockfd);

    //5.接收和发送数据
    while(1)
    {
        //这里接收数据和发送数据是没有顺序而言的
        //因为已经经过三次握手，客户端和服务端的连接以及建立成功了
        
        char buf[1024] = {0};

        ssize_t recv_size = recv(new_sockfd,buf,sizeof(buf)-1,0);
        if(recv_size < 0)
        {
            cout << "recv failed" << endl;
            continue;
        }
        else if(recv_size == 0)
        {
            cout << "Peer close" << endl;
            close(new_sockfd);
            close(sockfd);
            return 0;
        }
        
        cout << "accrpt data is : " << buf << endl;

        //发送数据
        memset(buf,'\0',sizeof(buf));
        sprintf(buf,"hello lient,i am server,i am %s:%d\n",
        		inet_ntoa(addr.sin_addr),ntohs(addr.sin_port));
        		
        ssize_t send_ret = send(new_sockfd,buf,strlen(buf),0); 
        if(send_ret < 0)
        {
            cout << "send failed" << endl;
            continue;
        }

    }

    close(sockfd);
    return 0;
}

分析完代码后，我们来看看客户端与服务端之间的通信吧！！

分别运行客户端和服务端所得到的结果如下：
服务端的结果：
在这里插入图片描述
客户端的结果：
在这里插入图片描述
看上去好像成功了，但是这只是一个客户端与服务器通信的情况，如果是多个客户端呢？他的情况是怎样的？在上面的基础上，我们再运行一个客户端，看看其结果如何：
在这里插入图片描述
我们发现第二个客户端完全不运行，这是什么情况呢？我们使用ps aux | grep []加pstack []命令来对其进行分析。
在这里插入图片描述
稍微对服务端代码进行分析就可知，因为服务端accept在while循环外面，所以只能从已完成连接队列中拿出一次连接进行通信，而第二个客户端进来后，虽然和服务端三次握手成功建立了连接，但是并没有被服务端接收其连接，因此当客户端代码走到recv逻辑的时候就会发生阻塞，因为客户端是不会给他回复任何消息的。
 
那能否将服务端accept代码放到while循环里面？答案肯定也是不行的，稍微分析一下，当while循环每次走到accept逻辑的时候，都要从已完成连接队列中获取连接，当队列为空的时候就会阻塞掉，因此，当有两个客户端的时候，它们之间只能通信一次，然后就会陷入到accept阻塞的逻辑中。

稍微总结一下，单进程版本的TCP代码当有多个客户端与其服务器进行通信的时候，依据代码逻辑的不同，可能会产生两种阻塞：recv阻塞和accept阻塞。

那么该如何解决呢？有三种解决办法。

  • 多进程版本的TCP代码
  • 多线程版本的TCP代码
  • 使用多路转接的技术（这个在后面会进行讲解）

2.2 多进程版本的TCP代码

再写多进程代码的时候，一定要注意的点有：父进程只管accept，子进程只管send和recv数据，因为父子进程的进程虚拟空间是几乎相同的，父进程从已完成连接队列中得到的套接字，子进程也能拥有。

但是一定要注意到进程等待，如果子进程先于父进程退出，且父进程没有进行相应的进程等待，那么该子进程就会变成僵尸进程。但是如果我们直接在父进程的逻辑中加上wait函数是行不通的，因为，随着客户端的增多，父进程创建出的子进程也逐渐变多，wait函数会捕捉子进程退出时所发出的SIGCHLD信号，但是是不知道捕捉的是哪一个进程的。

因此，在这里，我们使用signal函数将SIGCHLD该信号处理重新用我们自己的逻辑定义一下即可。

服务端的代码如下：

#include <unistd.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <signal.h>
#include <netinet/in.h>
#include <string.h>
#include <iostream>

using namespace std;

void signalcallBack(int)
{
    wait(NULL);
    return;
}

int main()
{
    signal(SIGCHLD,signalcallBack);
   
    //创建套接字
    int listen_sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    if(listen_sock < 0)
    {
        cout << "socket failed" << endl;
        return 0;
    }
    
    //绑定地址信息
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(18989);
    addr.sin_addr.s_addr = inet_addr("0.0.0.0");
    int ret = bind(listen_sock,(struct sockaddr *)&addr,sizeof(addr));
    if(ret < 0)
    {
        cout << "bind failed" << endl;
        return 0;
    }

    //帧听
    ret = listen(listen_sock,1);
    if(ret < 0)
    {
        cout << "listen failed" << endl;
        return 0;
    }

    while(1)
    {
        struct sockaddr_in peer_addr;
        socklen_t peerlen;
        int new_sockfd = accept(listen_sock,
        				(struct sockaddr *)&peer_addr,&peerlen);
        if(new_sockfd < 0)
        {
            cout << "accept failed" << endl;
            return 0;
        }
        pid_t fork_ret = fork();
        if(fork_ret < 0)
        {
            cout << "fork failed" << endl;
            continue;
        }
        else if(fork_ret == 0)
        {
            close(listen_sock);
            //child
            //在子进程中只实现接收和发送数据
            while(1)
            {
                char buf[1024] = {0};
             ssize_t recv_size = recv(new_sockfd,buf,sizeof(buf)-1,0);
                if(recv_size < 0)
                {
                    cout << "recv failed" << endl;
                    continue;
                }
                else if(recv_size == 0)
                {
                    cout << "peer failed" << endl;
                    break;
                }

                cout << "i recv: " << buf << endl;

                //接收数据
                memset(buf,'\0',sizeof(buf));
                sprintf(buf,"hello client,%s:%d\n",
                		inet_ntoa(peer_addr.sin_addr),
                		ntohs(peer_addr.sin_port));
                ssize_t send_size = send(new_sockfd,buf,strlen(buf),0);
                if(send_size < 0)
                {
                    cout << "send failed" << endl;
                    break;
                }
            }
        }

        else
        {
            //father
            //要进行进程等待，防止子进程变成僵尸进程
            //但是还存在着的问题是，该父进程可能会创建多个子进程
            //若是直接在父进程中进行进程等待的话，就意味着若只有一个子进程退出
            //父进程也会随之等待到资源，然后continue上去会陷入到accept的逻辑中
            //因此，我们需要设置信号，自定义信号的处理逻辑，每当有一个sigchild
            //信号发送出来的时候，我们让其在自定义的处理函数进行进程等待即可
            continue;
        }
    }

    return 0;
}

可能是我上传的图片太多了，上传图片总是失败，所以这里就不再进行结果的验证了。

2.3 多线程版本的TCP代码

多线程和多进程一样，也需要考虑几点，要将新的套接字传入线程入口函数，为此我们要在堆上申请一个空间用来存储新的套接字；为了不让线程进行等待，我们可以在线程入口函数中直接将自己线程分离掉即可；最后一点，一定要注意退出时对内存进行释放，关闭套接字，避免内存泄漏。

我在这里用一个类将TCP的各个接口给封装了起来，换句话说，到时候可以在客户端或服务端直接调用封装的类的接口即可实现逻辑。

封装的tcp类：

//tcp.hpp
#pragma once

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

#include <iostream>

using namespace std;

class tcp
{
    public:
        tcp() : sockfd_(-1)
        {}
        tcp(int sock) : sockfd_(sock)
        {}
        ~tcp()
        {
            close(sockfd_);
        }


        int createSockfd()
        {
            sockfd_ = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
            if(sockfd_ < 0)
            {
                cout << "socket failed" << endl;
                return -1;
            }
            return sockfd_;
        }

        int Bind(string ip = "0.0.0.0",uint16_t port = 18989)
        {
            struct sockaddr_in addr;
            addr.sin_family = AF_INET;
            addr.sin_port = htons(port);
            addr.sin_addr.s_addr = inet_addr(ip.c_str());


            int ret = bind(sockfd_,
            			(struct sockaddr *)&addr,sizeof(addr));
            if(ret < 0)
            {
                cout << "bind failed" << endl;
                return -1;
            }
            return ret;
        }

        int Listen(int backlog = 2)
        {
            int ret = listen(sockfd_,backlog);
            if(ret < 0)
            {
                cout << "listen failed" << endl;
                return -1;
            }
            return ret;
        }

        int Accept(struct sockaddr_in* addr,socklen_t* socklen)
        {
            int new_sockfd = accept(sockfd_,
            			(struct sockaddr *)addr,socklen);
            if(new_sockfd < 0)
            {
                cout << "accept failed" << endl;
                return -1;
            }
            return new_sockfd;
        }

        ssize_t Recv(char* buf,size_t len)
        {
            ssize_t ret = recv(sockfd_,buf,len,0);
            if(ret < 0)
            {
                cout << "recv failed" << endl;
            }
            return ret;
        }

        ssize_t Send(char* buf,size_t len)
        {
            ssize_t ret =  send(sockfd_,buf,len,0);
            if(ret < 0)
            {
                cout << "send faild" << endl;
                return -1;
            }

            return ret;
        }
    
    private:
        int sockfd_;
};

服务端代码：

#include "tcp.hpp"

void* TcpEntryPthread(void* arg)
{ 
    pthread_detach(pthread_self());
    tcp *tc = (tcp*) arg; 

    while(1)
    {
        char buf[1024] = {0};
        ssize_t ret = tc->Recv(buf,sizeof(buf)-1);
        if(ret < 0)
        {
            cout << "recv failed" << endl;
            continue;
        }
        else if(ret == 0)
        {
            cout << "peer close" << endl;
            break;
        }

        printf("client say: %s\n",buf);

        memset(buf,'\0',sizeof(buf));
        sprintf(buf,"hello client, i am server");

        ret = tc->Send(buf,strlen(buf));
        if(ret < 0)
        {
            cout << "send failed" << endl;
            continue;
        }
    }

    delete tc;
    return nullptr;
}

int main()
{
    tcp tc;
    int ret = tc.createSockfd();
    if(ret < 0)
        return -1;
    //默认ip 0.0.0.0，默认端口18989
    ret = tc.Bind();
    if(ret < 0)
        return -1;
    //默认已完成连接队列大小为2
    ret = tc.Listen();
    if(ret < 0)
        return -1;
    
    while(1)
    {
        struct sockaddr_in addr;
        socklen_t socklen = sizeof(addr);
        int new_sockfd = tc.Accept(&addr,&socklen);
        if(new_sockfd < 0)
        {
            cout << "Please again to accept" << endl;
            continue;
        }
        
        //从这里开始创建工作线程
        //如果只是单纯的将new_sockfd传过去的话，是不行的
        //因为它是一个局部变量，因此，我们需要在堆上开辟出一个空间
        tcp *t = new tcp(new_sockfd);
        if(t == nullptr)
        {
            cout << "new class tcp failed" << endl;
            continue;
        }
        
        pthread_t tid;
        ret = pthread_create(&tid,NULL,TcpEntryPthread,t);
        if(ret < 0)
        {
            cout << "pthread_create failed" << endl;
            delete t;
            continue;
        }
    }
}
It‘s so simple
关注
  • 9
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
JAVA--基于TCP协议的Socket编程
不会飞的小飞侠24
10-12 4002
（1）java.net包的两个类Socket和ServerSocket，分别用来实现双向安全连接的客户端和服务器端
TCP之Socket编程
weixin_44390164的博客
09-26 114
服务端和客户端初始化socket，得到文件描述符 服务端调用bind，绑定在IP地址和端口 服务端调用listen，进行监听 服务端调用accept，等待客户端连接 客户端调用connect，向服务端的地址和端口发起连接请求 服务端accept返回用于传输的socket的文件描述符（另一个文件描述符） 客户端调用write写入数据；服务端调用read读取数据 当客户端断开连接时，会调用close，那么会向服务端发送一个EOF，那么服务端read读取数据时，就会读取到这个EOF，待处理完数据..
Python基础系列讲解——TCP协议的socket编程_基于tcp协议的socketpython编程
2401_84140734的博客
04-27 636
需要注意的是TCP客户端连接到服务器的ip和端口要与TCP服务器监听的ip和端口相同，服务器调用listen()开始监听端口，而后调用accept()时刻准备接受客户端的连接请求，此时服务器处于阻塞状态，直到服务器监听到客户端的请求后，接收请求并建立连接为止。
linux网络编程之TCP协议编程
m0_74228185的博客
11-17 407
TCP协议网络编程
Linux——socket编程之tcp通信
kkbca的博客
05-04 1226
前面我们学习，了解到了socket的概念与udp的实现方法，今天我们来学习一下面向连接的tcp通信。
Linux网络编程TCP参考代码
记录点滴，静心学习
03-21 522
参考例程（国嵌实验代码）： 服务端： #include #include #include #include #include #include #include #include #define portnumber 3333 int main(int argc, char *argv[]) { int sockfd,new_fd; struct
实战Linux socket编程Linux Socket Programming By Example
03-13
本书"Linux Socket Programming By Example"通过实例深入讲解了Linux下如何进行socket编程，帮助开发者掌握网络通信的基本原理和实践技巧。源代码的提供为学习者提供了直观的学习材料，确保能够实际操作并理解每一步...
Linux下C编程实战——源代码.7z
05-14
在Linux环境下进行C编程是一种非常常见且强大的技术实践。...这个“Linux下C编程实战——源代码”压缩包可能包含了这些概念的实例代码，供学习者参考和练习。记得动手实践，结合源代码加深理解和应用。
《实战 Linux Socket编程》练习代码
03-11
下面将根据提供的压缩包文件名“实战 Linux Socket编程代码”来解析其中可能包含的知识点。 1. **Socket基础知识**：Socket是网络通信的基础，它是进程间通信的一种方式，特别适用于跨网络的通信。在Linux系统中，...
实战linux socket编程--示例源码.rar_C++ socket_linux 源码_socket 编程 linux_s
09-22
- “实战linux socket编程--示例源码”是实际的源代码文件，包含了各种Socket编程的实例，如简单TCP服务器、客户端、UDP通信等。 - 分析这些源码，可以帮助读者理解Socket编程的具体实现，包括如何建立连接、发送...
网络编程，linux内核编程实战
最新发布
06-25
通过对"网络编程"和"Linux内核编程实战"的学习，开发者可以构建高性能、安全且高效的系统和服务，满足现代计算环境的需求。通过实践课程和文档，如"149-Linux内核技术实战课"和"80-网络编程实战"，可以深入理解和...
Linux下socket实现TCP网络通讯（多个客户端之间的通讯）
06-10
在学习《UNIX网络编程》基础上自己动手实现TCP服务器和客户端通讯，这个版本是进阶版程序——实现多个客户端的之间的通讯。程序包含了常规网络通讯的主要步骤，除此之外还运用了select()和poll()等技术，具有一定难度，程序思路清晰，代码注释详细，适合有一定基础的人学习。代码已经无误通过测试。初学者可以休息我的入门版程序——实现单个客户端的之间的通讯，可见我的其他资源。
Linux下tcp通信程序
12-08
Linux下tcp通信程序，含客户端和服务器以及Makefile，多线程-可同时收发操作。 不足：退出机制不太完整。
Linux Socket编程基于TCP的客户服务器程序和配置脚本
07-26
资源包含客户端程序tcpclient.c,服务器端程序tcpserver.c，Makefile文件以及一个自动化配置安装脚本 setup.sh，具体使用方法如下： 1 即make为运行make命令编译 client 和server， 2. 即包括1中内容和运行服务器端，在后台运行， 3. 删除编译产生的 .o文件，4. 终止服务器端后台运行，并删除所有文件 ------------------------------------ Usage: sh setup <args> args are Numbers as follows: 1. make, generate executions 2. run, make & run 3. make clean, rm *.o 4. make cleanall, rm files in 1&2 ---------------------- Exp: sh setup.sh 2 ---------------------- ------------------------------------ 在root权限下运行肯定没问题，在user权限下运行在笔者电脑上是没问题的
实战Linux Socket 编程.rar
08-14
实战Linux Socket 编程.rar linux网络编程
最简单的TCP模式SOCKET代码
02-19
这是一个服务端和客户端的TCP模式SOCKET编程代码
Linux下Socket TCP编程
qq_48802512的博客
03-26 4066
新手入门 很简单，全部注释了！ 基本步骤： 1）创建客户端的socket（初始化）。 2）向服务器发起连接请求。 3）与服务端通信，发送一个报文后等待回复，然后再发下一个报文。 4）不断的重复第3）步，直到全部的数据被发送完。 5）第4步：关闭socket，释放资源。 server.cpp /*Socket 客户端（server）编程 1）创建客户端的socket（初始化）。 2）向服务器发起连接请求。 3）与服务端通信，发送一个报文后等待回复，然后再发下一个报文。 4）不断的重复
一个详细的Linux下TCP，socket编程(加信号)
weixin_42316357的博客
03-20 206
做项目需要使用socket网络编程，就去图书馆借了UNIX网络编程，总结一下思路。 首先要确立一点的是服务端是至少需要两个socket套接字的，一个是监听套接字，另外的就是和客户端信息相互传输的套接字；而客户端只需要一个套接字，用于和服务端的信息传递。 下图就是整个socket的基本流程： 有人看这个图片就会问了，为什么服务端需要绑定ip和端口(bind函数)，客户端不需要呢？这是因为服务器如果不使用bind()函数进行IP和端口的绑定，内核就会就会选择一个临时端口，这使得客户端连接服务器很困难(端口未知)
Linux网络编程【一】：TCP socket套接字详解
Begin
05-26 8276
1.socket socket这个词可以表示很多概念: 在TCP/IP协议中,“IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程,“IP地址+端口号”就称为 socket。 在TCP协议中,建立连接的两个进程各自有一个socket来标识,那么这两个socket组成 的socketpair就唯一标识一个连接。 socket本身 有“插座”的意思,因此用来描述网络连接的一 对一关系
linux网络编程项目实战
03-16
Linux网络编程项目实战是一种实践性很强的学习方式，通过实际的项目开发，可以更深入地理解网络编程的原理和实现方式。在这个项目中，学习者需要掌握Linux系统的网络编程接口，如socket、select、epoll等，以及网络协议的基本知识，如TCP/IP协议、HTTP协议等。通过实现一个网络应用，如Web服务器、聊天室、FTP客户端等，可以提高自己的编程能力和实践经验，同时也可以更好地理解网络编程的应用场景和实现方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值