TCP套接字（网络）编程

最新推荐文章于 2022-10-19 16:12:44 发布
原创 最新推荐文章于 2022-10-19 16:12:44 发布 · 774 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#TCP #网络编程 #服务器端 #客户端

简单的TCP网络编程

本文中用到的内容可在另一篇博客中见到 UDP套接字编程
一. 初识TCP协议

        TCP 叫做传输控制协议。它具有以下特点：
（1）传输层的协议
（2）面向连接：基于TCP进行网络通信时，要先建立连接，建立成功才能通信。而UDP不需要连接可直接通信，所以相对而言，TCP的速度较慢，因为建立和维护连接需要花费资源。
（3）可靠传输：相对UDP而言，TCP增加了出错重传等机制，以确保数据的可靠性，而UDP则没有，这也是UDP较快的一个原因
（4）面向字节流：UDP面向数据报，所以发送方发来一个数据报，它要一次全部接收；而TCP面向字节流，不管发送方发来多少数据，接收方一次可以接收任意长度的数据。

二. TCP相关的接口函数
1. listen函数
    （1）函数原型：

   （2）函数功能：将客户端的套接字变为被动连接套接字，使一个进程可以接受其他进程的请求，即只有处理监听状态的套接字，才可以被客户端连接
    （3）函数参数：

        sockfd：套接字的文件描述符，即服务器端的已绑定但是未连接的套接字
        backlog：连接请求队列（一般是5）
注意：

        当系统资源不够支持服务器端对所有发送请求的客户端进行处理时，发送连接请求的客户端就要在底层排序，等待服务器端可以来处理它们。
        首先，为了使服务器端一直处于忙碌状态，从而实现资源的利用最大化。所以我们有了底层的等待队列，这样能够保证服务器端实现对资源的最大利用化。
        同时，等待队列不能过长。一个是因为等待队列过长时，有的客户端会迟迟得不到处理，而一直等待可能会使得它做不了其他事；再一个是因为等待队列也需要花费资源来维护，队列过长，耗费的资源也越多，我们应该将更多地资源用以服务。所以队列的长度一般为5，当请求超过5个时，多余的会被直接忽略。
2. connect函数

    （1）函数原型：
    （2）函数功能：客户端通过该函数向服务器端发送连接请求
    （3）函数参数：

        sockfd：客户端的套接字
        addr：保存目的IP地址与目的端口号的结构体指针
        addrlrn：参数addr的长度
    （4）返回值：成功返回0，失败返回-1
3. accept函数
    （1）函数原型：

    （2）函数功能：在调用connect函数成功客户端与服务器端成功建立连接后，即三次握手完成后，服务器调用accept函数接受连接

    （3）函数参数：
        sockfd：服务器端的套接字
        addr： 指向已连接的客户端的套接字的结构体，若设置为NULL，就表示服务器端不关心客户端地址，是输出型参数
        addrlen：参数addr的长度
    （4）函数返回值：输入输出型参数，传入的是调用者提供的缓冲区addr的长度，以避免缓冲区溢出。输出的是实际客户端结构体变量addr的长度，此时，可能没有占满调用者提供的缓冲区的大小

三. TCP套接字编程实现
1. 服务器端（ 基于单进程连接）实现

实现过程：

（1）在服务器端要调用socket打开一个网卡文件用于网络通信

（2）调用bind函数将服务器程序与特定的IP地址和端口号进行绑定，以便客户端能找到该服务器与之连接通信

（3）服务器基于TCP协议，所以要使上述的网卡文件处于监听状态才能接受客户端发来的连接请求

（4）当客户端调用connect函数与服务器端建立连接成功后，服务器需要调用accept函数来接收连接

（5）双方开始进行通信

（6）因为可能有多个客户端会向服务器发送建立连接请求，所以服务器需要不断的调用accept函数来接受连接请求，所以应该让（4）（5）处于一个死循环中。
实现代码： 
//TCP服务器,只能允许一个人连接                                                                                                                                          
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netinet/in.h>
#include <string.h>

#define MAXSIZE 128

int startup(int port, char* ip) 
{
    //1.创建套接字,这里是流式的套接字，因为TCP面向字节流
    int sock = socket(AF_INET, SOCK_STREAM, 0); 
    if(sock < 0)
    {   
        printf("socket error\n");
        exit(2);//套接字创建失败，直接终止进程,因为没有套接字网络通信根本无法实现，后续代码根本不用执行
    }   
    //2.绑定
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);//端口号
    local.sin_addr.s_addr = inet_addr(ip);//IP

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

    //3.监听:一直等待客户来连接(因为TCP是面向连接的)，提取新连接；
    if(listen(sock, 5) < 0)//最多容纳5个客户连接请求
    {   
        printf("listen error\n");
        exit(4);
    }   
    return sock;//返回一个监听套接字
}

void service(int sock, char* ip, int port)
{
    char buf[MAXSIZE];
    while(1)
    {
        //TCP是流式套接字，可直接用读写文件的接口操作
        //read返回值为0时，说明对方(客户端)已关闭
        ssize_t s = read(sock, buf, sizeof(buf)-1);
        if(s > 0)
        {
            buf[s] = 0;
            printf("[%s:%d]say# %s\n", ip, port, buf);
            //TCP套接字是全双工的,两个可以同时读写
            write(sock, buf, strlen(buf));
        }
        else if(s == 0)
        {
            printf("client [%s:%d] quit!\n", ip, port);
            break;
        }
        else
        {
            printf("read error\n");
            break;
        }
    }
}

//./tcp_server 127.0.0.1 8080
int main(int argc, char* argv[])
{
    if(argc != 3)
    {                                                                                                                                                                   
        printf("Usage: %s [ip] [port]\n", argv[0]);
        exit(1);
    }

    //创建套接字
    int listen_sock = startup(atoi(argv[2]), argv[1]);
    
    struct sockaddr_in peer;
    char ipbuf[24];
    for( ; ; )
    {
        ipbuf[0] = 0;
        socklen_t len = sizeof(peer);
        //从监听套接字中拿连接
        int new_sock = accept(listen_sock, (struct sockaddr*)&peer, &len);
        if(new_sock < 0)//拿连接失败，不用管，因为还可以去拿其他连接
        {
            printf("accept error\n");
            continue;
        }
        //获得了一个新连接
        inet_ntop(AF_INET, (const void*)&peer.sin_addr, ipbuf, sizeof(ipbuf));//将四字节IP地址转换为点分十进制
        int p = ntohs(peer.sin_port);//端口号：网络序列转换为主机序列的端口号
        printf("get a new connect,[%s:%d]\n", ipbuf, p);//将新连接的IP和端口号打印

        //提供服务
        service(new_sock, ipbuf, p);
        close(new_sock);
    }
    return 0;
}

2. 客户端实现
实现过程：

（1）客户端端先打开网卡文件，得到文件描述符

（2）客户端不需要绑定固定的端口号，它的端口号是由内核自动进行分配。所以直接调用connect函数向服务器端发送连接请求

（3）当连接成功，服务器端调用accept函数接收客户端的连接请求后，双方便开始进行通信，通信完毕需要关闭网卡文件
实现代码： 
//TCP客户端                                                                                                                                                             
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netinet/in.h>
#include <string.h>

#define MAXSIZE 128

//./tcp_client 127.0.0.1 8080
int main(int argc, char* argv[])
{
    if(argc != 3)
    {   
        printf("Usage: %s [ip] [port]\n", argv[0]);
        return 1;
    }   
    //创建套接字
    int sock = socket(AF_INET, SOCK_STREAM, 0); 
    if(sock < 0)
    {   
        printf("socket error\n");
        return 2;
    }   
    //客户端不用绑定(bind)，不用监听(listen)，不用获取新连接(accept)
     
    //客户端有一个个性化操作connect,向服务器发起连接
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);
    if(connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0)
    {   
        printf("connect error\n");
        return 3;
    }   
    //走到这，连接成功
    char buf[MAXSIZE];
    while(1)
    {
        printf("please enter# ");
        fflush(stdout);
        ssize_t s = read(0, buf, sizeof(buf)-1);
        if(s > 0)
        {
            buf[s-1] = 0;//去掉回车符号
            if(strcmp("quit", buf) == 0)//客户端输入quit表示客户端退出
            {
                printf("client quit\n");
                break;
            }
            write(sock, buf, strlen(buf));
            s = read(sock, buf, sizeof(buf)-1);
            buf[s] = 0;
            printf("serevr echo# %s\n",buf);

        }

    }
    close(sock);
    return 0;
}

与UDP一样，我们提供本地环回测试，测试结果如下：
        图左为服务器端，图右为客户端。
        上述代码的实现过程，在一个客户端与服务器连接之后进行通信时，其他客户端会连接不上。因为，上述客户端的代码实现中，当一个客户端连接之后，服务器进入到与该客户端通信的死循环中，所有服务器端无法调用accept函数接受其他客户端发来的请求，直至该客户端断开连接之后。
        然而在实际应用中，服务器应该可以同时处理多个客户端的请求，所以上述服务器端代码还需要改进。
3. 基于多进程连接的服务器端实现
实现过程：
        我们可以通过创建子进程的方式提供多个执行流，当一个客户端发来请求时，主进程创建一个子进程与客户端进行通信，父进程的任务仅仅是不断的接收新的客户端请求，创建子进程与之通信。要注意的就是，子进程完成通信后退出，要回收它的资源并释放。

所以我们将上面的单进程版本，修改main函数如下即可： 
//./tcp_server 127.0.0.1 8080
int main(int argc, char* argv[])
{
    if(argc != 3)                                                                                                                                                       
    {
        printf("Usage: %s [ip] [port]\n", argv[0]);
        exit(1);
    }
    
    //创建套接字
    int listen_sock = startup(atoi(argv[2]), argv[1]);
    
    struct sockaddr_in peer;
    char ipbuf[24];
    for( ; ; )
    {
        ipbuf[0] = 0;
        socklen_t len = sizeof(peer);
        //从监听套接字中拿连接
        int new_sock = accept(listen_sock, (struct sockaddr*)&peer, &len);
        if(new_sock < 0)//拿连接失败，不用管，因为还可以去拿其他连接
        {
            printf("accept error\n");
            continue;
        }
        //获得了一个新连接
        inet_ntop(AF_INET, (const void*)&peer.sin_addr, ipbuf, sizeof(ipbuf));//将四字节IP地址转换为点分十进制
        int p = ntohs(peer.sin_port);//端口号：网络序列转换为主机序列的端口号
        printf("get a new connect,[%s:%d]\n", ipbuf, p);//将新连接的IP和端口号打印

        //父进程获取新连接，子进程为其提供服务，提供完子进程退出；然后父进程再获取，子进程再通过
        pid_t id = fork();
        if(id == 0)//child提供服务
        {
            //子进程继承父进程文件描述符表，打开了两个套接字：listen_sock、new_sock,
            //而子进程不需要listen_sock,防止意外，所以关闭它
            close(listen_sock);

            if(fork() > 0)//它退出后，它的子进程变成孤儿进程，被1号进程回收
            {
                exit(0);
            }
            //提供完服务，就关闭，然后子进程退出                                                                                                                        
            service(new_sock, ipbuf, p);
            close(new_sock);
            exit(0);
        }
        else if(id > 0)//father获得新连接
        {
            //上面子进程可以不关listen_scok,因为不去访问它即可，但是这里父进程必须关闭
            //因为每次创建子进程，都会给它文件描述符，这里不关，创建一个子进程给一个文件描述符，
            //但文件描述符有上限，所以关闭它
            close(new_sock);
            
            //父进程需要等待子进程
            //否则每次创建的子进程退出了，但是父进程不退出，循环下去会产生很多僵尸进程，可能导致内存泄漏问题
            //阻塞等待让父进程卡住，损耗效率;非阻塞等待也不好用，也有可能造成内存泄漏;信号章节的等待方式有局限性
            waitpid(id, NULL, 0);
        }
        else//创建失败，因为系统压力太大，不能承受新连接
        {
            printf("fork error\n");
            continue;
        }
    }
    return 0;
}

        这里注意一下用以提供服务的子进程的释放方法。
4. 基于多进程的服务器版本

实现思想：
        我们也可以让服务器通过创建多线程的方法来提供多个执行流，从而实现多个客户端可以同时连接服务器。主线程接收客户端发来的请求并创建新线程，新线程与客户端进行通信。在上述多进程的程序中主要考虑的问题是父进程在阻塞等待时不能接收连接请求。多线程环境中主线程理应对新线程进行回收，可以通过线程分离来实现。当新线程退出时自己回收资源，不必主线程来回收，所以主线程在创建完新线程之后，直接对其进行分离，就可以连续不断接受新的连接请求了。
实现代码： 
//TCP多线程服务器                                                                                                                                                       
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netinet/in.h>
#include <string.h>
#include <pthread.h>

#define MAXSIZE 128

typedef struct
{
    int sock;
    char ip[24];
    int port;
}net_info_t;

int startup(int port, char* ip) 
{
    //1.创建套接字,这里是流式的套接字，因为TCP面向字节流
    int sock = socket(AF_INET, SOCK_STREAM, 0); 
    if(sock < 0)
    {   
        printf("socket error\n");
        exit(2);//套接字创建失败，直接终止进程,因为没有套接字网络通信根本无法实现，后续代码根本不用执行
    }   
    //2.绑定
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);//端口号
    local.sin_addr.s_addr = inet_addr(ip);//IP

    if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {   
        printf("bind error\n");
        exit(3);
    }   
    //3.监听:一直等待客户来连接(因为TCP是面向连接的)，提取新连接；
    if(listen(sock, 5) < 0)//最多容纳5个客户连接请求
    {
        printf("listen error\n");
        exit(4);
    }
    return sock;//返回一个监听套接字
}

void service(int sock, char* ip, int port)
{
    char buf[MAXSIZE];
    while(1)
    {
        //TCP是流式套接字，可直接用读写文件的接口操作
        //read返回值为0时，说明对方(客户端)已关闭
        ssize_t s = read(sock, buf, sizeof(buf)-1);
        if(s > 0)
        {
            buf[s] = 0;
            printf("[%s:%d]say# %s\n", ip, port, buf);
            //TCP套接字是全双工的,两个可以同时读写
            write(sock, buf, strlen(buf));
        }
        else if(s == 0)
        {
            printf("client [%s:%d] quit!\n", ip, port);
            break;
        }
        else
        {
            printf("read error\n");
            break;
        }                                                                                                                                                               
    }
}

void* thread_service(void* arg)
{
    net_info_t *p = (net_info_t* )arg;
    service(p->sock, p->ip, p->port);

    close(p->sock);
    free(p);
}

//./tcp_server 127.0.0.1 8080
int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        printf("Usage: %s [ip] [port]\n", argv[0]);
        exit(1);
    }
    
    //创建套接字
    int listen_sock = startup(atoi(argv[2]), argv[1]);
    
    struct sockaddr_in peer;
    char ipbuf[24];
    for( ; ; )
    {
        ipbuf[0] = 0;
        socklen_t len = sizeof(peer);
        //从监听套接字中拿连接
        int new_sock = accept(listen_sock, (struct sockaddr*)&peer, &len);
        if(new_sock < 0)//拿连接失败，不用管，因为还可以去拿其他连接
        {
            printf("accept error\n");
            continue;
        }
        //获得了一个新连接
        inet_ntop(AF_INET, (const void*)&peer.sin_addr, ipbuf, sizeof(ipbuf));//将四字节IP地址转换为点分十进制
        int p = ntohs(peer.sin_port);//端口号：网络序列转换为主机序列的端口号                                                                                           
        printf("get a new connect,[%s:%d]\n", ipbuf, p);//将新连接的IP和端口号打印

        //这里不用像多进程的版本关闭多余的文件描述符
        //因为线程共享地址空间，关掉一个文件，其他线程就看不到用不了了
        net_info_t* info = (net_info_t*)malloc(sizeof(net_info_t));
        if(info == NULL)
        {
            perror("malloc");
            close(new_sock);
            continue;
        }
        info->sock = new_sock;
        strcpy(info->ip,ipbuf);
        info->port = p;

        pthread_t tid;
        pthread_create(&tid, NULL, thread_service, (void* )info);
        pthread_detach(tid);//线程分离后，该线程的资源会自动释放
    }
    return 0;
}
        多进程版本和多线程版本的服务器代码都可以像单进程版本的方法测试，但是要注意用多台机器连接服务器端去测试。
四. 多进程与多线程版本的服务器的优缺点
1. 多进程
（1）优点
        1）能够处理多个用户；
        2）简单，编写周期短；
        3）稳定性强，一个进程挂掉不会影响其他进程
（2）缺点
        1）客户端连接后才创建子进程，性能受损
        2）每个进程特别吃资源，导致能服务的客户数是有上限的，且上限较低
        3）随客户的增多，CPU的调度压力也会增大，性能受到影响，客户端等待周期长

2. 多线程

（1）优点
        1）能处理多个用户
        2）简单，编写周期短
（2）缺点
        1）每个线程也吃资源，导致能服务的客户数有上限，但是相比多进程较好一点
        2）随客户增多，CPU调度压力增大，但没多进程调度压力大
        3）稳定性差，可能会因为线程的安全问题使得服务器挂掉
五.TCP协议与UDP协议对比

1. TCP面向连接，UDP无连接
2. TCP面向字节流，UDP面向数据报
3.TCP可靠传输，UDP不可靠传输
        所以，TCP的传输速度比UDP慢，消耗的资源也比UDP多，消耗的时间也比UDP多。



网络套接字编程
E_kay的博客
06-10 631
1.ip地址 2.port 3.网络字节序 4.浅层次tcp和udp区别 5.udp协议实现网络通信 6.tcp协议实现网络通信 1.ip地址 a.作用：在网络中唯一标识一台主机 b.本质：uint32_t 无符号4个字节 c.源ip和目的ip地址 5元组 = 源ip+源端口+目的ip+目的端口+协议 ipv6：a.ipv4和ipv6制的不同版本的ip协议 b.ipv6并不兼容ipv4，两者的ip协议的报头格式不同 c.ipv6 1...
基本的TCP套接字编程
ooooo12345re的博客
06-02 1235
上图基本展示了TCP客户端与服务器编程的基本的流程。 1、面向连接编程（TCP） 面向连接的网络应用程序开发流程比较固定，需要开发者创建服务器与客户端两个应用程序，通过网络是想进程间的通讯。 ●     服务器端流程 1        创建套接字（socket） 2        服务绑定（bind） 3        服务侦听（listen） 4
TCP套接字网络编程实例（二）
逍遥游的博客
07-21 583
TCP套接字网络编程实例（二） 采用多线程实现客户端和服务器的聊天功能。OK，上代码。 1.客户端部分：   /* * 文件：tcp_client.c * 内容：利用TCP实现客户端和服务器的实时聊天。 * 注 ：服务器的端口号及IP，客户端的端口号及IP的输入通过main函数的argc和argv来实现。 * 未输入端口号的话使用默认端口号,服务器为1111,客户端为2222。...
TCP套接字编程
qizhihao123的博客
10-19 1353
TCP与UDP的区别相当大。它充分地实现了数据传输时的各种控制功能，可以进行丢包时重发控制，还可以对次序乱掉的分包进行顺序控制。而这些再UDP中都没有。此外，TCP作为一种面向有连接的协议，只要在确认通信对端存在时才会发生数据，从而可以控制通信流量的浪费。UDP不提供复杂的控制机制，利用IP提供面向无连接的通信服务。并且它是将应用程序发来的数据在收的那一刻，立即按照原样发送到网络上的一种机制。UDP是 User Datagram Protocol 的缩写，即用户数据报协议。
Python网络编程之TCP套接字简单用法示例
01-20
上学期学的计算机网络，因为之前还未学习python，而java则一知半解，C写起来又麻烦，所以一直都没有真正实现过TCP套接字编程。 最近学习了python，而用它来写套接字又十分方便简单，所以当然要试一试咯。 下面根据...
网络编程套接字 - TCP套接字
最新发布
09-08
下面将详细介绍TCP套接字的工作原理、特性以及在不同版本中的实现方式。 TCP套接字的工作流程主要包括以下几个步骤： 1. 建立连接：在TCP通信开始前，必须先建立连接，这被称为三次握手。客户端发送一个SYN（同步...
基于Python进行TCP套接字编程的基础知识 实验报告
01-08
进一步理解和掌握基于Python进行TCP套接字编程的知识，理解SMTP报文格式，能基于Python编写一个简单的SMTP客户端程序。 2实验条件 装有python环境的电脑两台 局域网环境 已经正常运行的邮件服务器 3实验报告内容及...
网络编程---UDP协议解析以及UDP套接字编程实现
IT_xiaoye的博客
05-26 2294
认识UDP协议 　　UDP协议全称是用户数据报协议[1]，在网络中它与TCP协议一样用于处理数据包，但不同于TCP的是，UDP是一种无连接的协议。。在OSI模型中，在第四层——传输层，处于IP协议的上一层。UDP有不提供数据包分组、组装和不能对数据包进行排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。UDP用来支持那些需要在计算机之间传输数据的网络应用。 　　简单来说，U...
tcp 套接字文件传输
11-28
初学者使用，一个简单的例子，服务器运行起来后监听有无客户端连接过来，有的话要求输入文件名进行传输。客户端命令行运行要加服务器端的IP。程序很简单，逻辑不是很完整，可以自己改善下，但是下载功能是可以运行的
TCP文件传输实现
03-23
这里面是很简单的两个控制台程序。主要是为了搞懂和熟悉网络TCP协议文件传输的基础知识！
【网络编程】基本TCP套接字
qq_41960161的博客
01-22 4700
在上一篇博客中，介绍了一些常用的套接字API。现在就用这些api来写一个简单的C/S架构，也就是一个服务器，一个客户端。 实现的功能如下： 1、客户从标准输入读入一行文本，并写给服务器； 2、服务器从网络输入读入这行文本，并回射给客户； 3、客户从网络输入读入这行回射文本，并显示在标准输出上。 这是一个全双工的TCP连接。 在这之前补充一下bind这个函数。bind就是将IP地址和端口与套接字符绑定的一个函数 ...
基于UDP/TCP网络套接字编程
X_simple的博客
06-29 418
套接字网络编程 ： IP地址：唯一标识网络上的一台主机 IPV4：uint32_t ---为了便于记忆，以点分十进制字符串形式展示 IPV6：uchar addr[16]---不向下兼容IPV4---没有发展起来 saddr(源IP地址)--> daddr（目的IP地址） 从哪个主机发送...
TCP基本套接字
qq_26646107的博客
08-15 952
TCP客户端和服务器编程离不开基本的套接字函数，学习TCP基本套接字很重要，下面学习一下基本的套接字接口，并实现一个简单的客户端和服务器程序。 socket函数 为了执行网络IO，一个进程要做的第一件事情就是要创建套接字。 在这里插入代码片 #include <sys/socket.h> int socket(int family, int type, int protocol) 返回：成功返回非负描述符，失败返回-1 family: AF_INET->IPV4协议 AF_INET6-&g
Linux网络编程 tcp套接字代码
小Z的博客
06-07 427
本次介绍一下TCP协议下的套接字代码，总体来看，tcp协议比udp协议更加安全可靠，无论是从用户使用的角度还是从编写代码的角度，你会发现与udp不同的是tcp在每次通信前，服务器端和客户端都会进行一次连接，连接成功后，才可以进行相互间的通信。 套接字API TCP套接字的API主要有以下几个： //建立套接字 int socket(int domain, int type, int pr...
tcp套接字、面向连接的传输服务
李小小小白的博客
02-16 333
服务端 import socket # 创建tcp套接字 sockfd = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 绑定地址 sockfd.bind(('0.0.0.0', 8888)) # 设置监听 sockfd.listen(5) print("Waiting for connect...") # 处理客户端连接 conn...
基本套接字：TCP 套接字
爱.NET
12-18 425
TCP套接字 Java为TCP协议提供了两个类：Socket类和ServerSocket类。一个Socket实例代表了TCP连接的一端。一个TCP连接（TCP connection）是一条抽象的双向信道，两端分别由IP地址和端口号确定。在开始通信之前，要建立一个TCP连接，这需要先由客户端TCP向服务器端TCP发送连接请求。ServerSocket实例则监听TCP连接请求，并为每个请求创...
利用网络套接字实现TCP交互
ZWE7616175的博客
05-09 555
我们来了解一下TCP交互流程： 大致流程如下： （1）服务器根据地址的类型（属于ipv4还是ipv6等）、socket类型（比如TCP、UDP）去创建socket，创建出的套接字socket本质上是个文件描述符。 （2）服务器绑定IP地址和端口号到套接字socket （3）服务器socket**监听**端口号请求，随时准备接收客户端发来的连接，但这个时候服务器的socket并没有被打开...
C语言实现TCP套接字编程实战教程
通过阅读和理解这些文件，可以进一步加深对C语言套接字编程的理解，特别是对TCP连接的建立、维护和终止的过程有更深刻的认识，对于希望深入学习网络编程和系统编程的开发者来说，这些文件是非常有价值的资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值