简单的TCP网络程序

最新推荐文章于 2024-05-23 20:22:36 发布
最新推荐文章于 2024-05-23 20:22:36 发布
阅读量4.6k 收藏 30
点赞数 10
分类专栏： Linux 网络 文章标签： 简单的TCP网络程序 简单的TCP网络程序（多线程版本） 简单的TCP网络程序（多进程版本） TCP协议的三次握手和四次挥手 tcp的协议通讯流程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37941471/article/details/80738319
版权
Linux 同时被 2 个专栏收录
33 篇文章 3 订阅
订阅专栏
网络
11 篇文章 1 订阅
订阅专栏

下面是我的另外一篇文章TCP协议和UDP协议的区别：
https://blog.csdn.net/qq_37941471/article/details/80888827
这样我们可以更清楚的理解程序

TCP服务器和客户端实现需要的接口：

下面介绍的接口都在这个头文件中：

#include <sys/socket.h>
#include <sys/types.h>
1. 创建套接字 ( socket() )

int socket(int domain, int type, int protocol); 

int socket(int domain, int type, int protocol);  
  1.domain 指定使用何种的地址类型
      协议                  说明
    PF_INET/AF_INET Ipv4   网络协议
    PF_INET6/AF_INET6      Ipv6 网络协议
  2. type的类别。见表：
    类型            说明
    SOCK_STREAM 提供双向连续且可信赖的数据流, 即TCP
    SOCK_DGRAM  使用不连续不可信赖的数据包连接，即UDP
  3. protocol 用来指定socket 所使用的传输协议编号，通常为0
  4.返回值：成功(0);失败(-1)
  5. socket()打开一个网络通讯接口，如果成功的话，就想open()一样返回一个文件描述符
2. 命名套接字 
//2. 命名套接字

    struct sockaddr_in local;
    local.sin_family = AF_INET;//Ipv4: AF_INET;Ipv6: AF_INET6
    local.sin_port = htons(atoi(argv[2]));//端口号是2位的数
    local.sin_addr.s_addr = inet_addr(argv[1]);
3. 绑定端口号 ( bind() )

int bind(int sockfd, struct sockaddr * my_addr, int addrlen); 

int bind(int sockfd, struct sockaddr * my_addr, int addrlen);  
  1. 返回值：成功(0);失败(-1)
  2. 作用：将参数sockfd和myaddr绑定在一起
  3. struct sockaddr * ：是一个通用的结构体
4. 开始监听socket (TCP,服务器)

int listen(int socket,int backlog);

4. 接受请求 （TCP，服务器）

int accept(int socket, struct sockaddr* address,socklen_t* address_len);

5. 建立连接 （TCP，客户端）

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

代码实现：

创建下面的文件： 
Makefile Tcp_server.c Tcp_client.c
Makefile：
.PHONY:all clean
all:Tcp_server Tcp_client
Tcp_server:Tcp_server.c
    gcc $^ -o $@
Tcp_client:Tcp_client.c
    gcc $^ -o $@
clean:
    rm -rf Tcp_serever Tcp_client
Tcp_server.c：
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>   
#include <errno.h>
#include <string.h>
#include <stdlib.h>

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

     //1. 创建套接字

     int listen_sock = socket(AF_INET, SOCK_STREAM , 0 );// SOCK_DGRAM 表示UDP
     if(listen_sock < 0)
     {   
     perror("socket");
     return 2;
     }   
     printf("Socker:%d\n",listen_sock);
    //2. 命名套接字

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(atoi(argv[2]));//端口号是2位的数
    local.sin_addr.s_addr = inet_addr(argv[1]);


    // 3. 绑定端口号
     if( bind(listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0  )
     {
     perror("bind");
     return 3;
     }

     // 4. 开始监听listen_sock
     if( listen(listen_sock,5) < 0 )//这里的5是允许有5个客户端连接等待，如果收到更多的请求则忽略
     {
     perror("listen");
     return 4;
     }


     // 5. 接受请求
     printf("bind and listen success,wait accept...\n");

     for(;;)
     {
     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 new link![%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));

     char buf[128];
     while(1)
     {
         ssize_t s = read(new_sock,buf,sizeof(buf)-1);
         if( s > 0 )
         {
         buf[s] = 0;
         printf("client# %s \n",buf);
         write(new_sock,buf,strlen(buf));
         }
         else if( s == 0 )
         {
         printf("quit!\n");
         break;
         }
         else
         {
         perror(" read ");
         break;
         }
     }
     close(new_sock);// 如果不关闭,文件描述符泄漏
     }
     return 0;
}
Tcp_client.c：
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>   
#include <errno.h>
#include <string.h>
#include <stdlib.h>

int main(int argc,char* argv[])
{
        if(argc != 3)
    {
        printf("Usage:%s ip port\n",argv[0]);
        return 1; 
    }   
    //1. 创建套接字

    int sock = socket(AF_INET, SOCK_STREAM , 0 );// SOCK_DGRAM 表示UDP
    if( sock < 0 )
    {   
        perror("socket");
        return 2;
    }   
    printf("Socker:%d\n",sock);

    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]);

    // 2. 建立连接
    if( connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0  )
    {
        perror(" connnet ");
        return 3;
    }

    char buf[128];
    while(1)
    {
        printf("Please Enter:");
        fflush(stdout);
        ssize_t s = read(0,buf,sizeof(buf)-1);
        if( s > 0 )
        {
        buf[s-1] = 0;
        write(sock,buf,strlen(buf));
        read(sock,buf,sizeof(buf)-1);
        printf("server echo# %s\n",buf);
        }
    }
    return 0;
}

测试代码：

在建立连接之前应该把防火墙关掉：

sudo service iptables stop
1. 先编译运行服务器

这里写图片描述

2. 再编译运行客户端，并向服务器发送消息

这里写图片描述

3. 再连接一个客户端，会发现新连接的客户端在等待，等待别的客户端退出，自己才能连接上，这个时候服务器会收到客户端连接和退出以及新的连接的信息。

新连接的客户端处于阻塞状态：
这里写图片描述
退出之前的客户端连接：
这里写图片描述
新的连接重新建立连接：
这里写图片描述
这个时候服务器端同时也收到了两个客户端退出以及建立新的连接的消息：
这里写图片描述

另外，我们可以在同一网段和别的ip去建立连接：

一. 先去ping 别人的ip,下面就是成功的信息：
这里写图片描述

二. 再去向别人发送客户端的可执行文件：192.168.31.209 是对方的ip地址，：/home是把可执行文件发到对方的home目录下，最底下是输入对方的密码

这里写图片描述

三. 自己去运行服务器端：
192.168.31.32是我自己的ip地址，8080是绑定的端口

./Tcp_server 192.168.31.32 8080

四. 别人运行客户端：
ip地址和端口同服务器的

./Tcp_client 192.168.31.32 8080

我们可以发现上面的程序只能处理一个连接，有新的连接时会阻塞，所以为了改进这个程序，写出了多进程版本和多线程版本，以及两个版本之间的关系，及其优缺点：

多线程版本：

代码实现：

只需要将上面的服务器代码修改一下：

Tcp_server.c：
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>   
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>  

void serviceIO (int sock)
{

     char buf[128];
     while(1)
     {
         ssize_t s = read(sock,buf,sizeof(buf)-1);
         if( s > 0 )
         {
         buf[s] = 0;
         printf("client# %s \n",buf);
         write(sock,buf,strlen(buf));
         }
         else if( s == 0 )
         {
         printf("quit!\n");
         break;
         }
         else
         {
         perror("read");
         break;
         }
     }
     close(sock);
}

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

     //1. 创建套接字

     int listen_sock = socket(AF_INET, SOCK_STREAM , 0 );// SOCK_DGRAM 表示UDP
     if(listen_sock < 0)
     {   
     perror("socket");
     return 2;
     }   
     printf("Socker:%d\n",listen_sock);
    //2. 命名套接字

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(atoi(argv[2]));//端口号是2位的数
    local.sin_addr.s_addr = htnol(INADDR_ANY);//INADDR_ANY可以绑定任意ip


    // 3. 绑定端口号
     if( bind(listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0  )
     {
     perror("bind");
     return 3;
     }

     // 4. 开始监听listen_sock
     if( listen(listen_sock,5) < 0 )//这里的5是允许有5个客户端连接等待，如果收到更多的请求则忽略
     {
     perror("listen");
     return 4;
     }


     // 5. 接受请求
     printf("bind and listen success,wait accept...\n");

     for(;;)
     {
     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 new link![%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));


     pid_t id = fork();
     if( id == 0  )//child
     {
         close(listen_sock);
         if( fork() > 0 )//这块创建了孙子进程，而fork()>0其实就是子进程，让其退出，这个时候父进程就可以回收子进程，继续去accpet,然后孙子进程实现服务
         {
         exit(0);
         }
         serviceIO(new_sock);
         exit(0);
     }
     else//father
     {
         waitpid(id,NULL,0);
     }
     }
     return 0;
}
测试代码：

1. 运行服务器代码，这里的ip地址是0代表可以为任意ip
这里写图片描述

2. 运行客户端代码，这里我是重新打开一个终端来实现的，所以服务器收到的连接信息是相同的ip,端口号不同，代表的是不同的进程

客户端一： 127.0.0.1:46845 这里的端口号是：46845
这里写图片描述
客户端一： 127.0.0.1:46846 这里的端口号是：46846
这里写图片描述
3. 服务器会一次收到连接和接受信息：
这里写图片描述
4. 客户端按照顺序全部退出，服务器会收到退出信息。
这里写图片描述
这里写图片描述
这里写图片描述

多线程版本：

代码实现：

只需要将上面的服务器代码修改一下：

Tcp_server.c：
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>   
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/wait.h>

typedef struct Arg
{
    int fd;
}Arg;
void ProcessRequest (int sock)
{

     char buf[128];
     while(1)
     {
         ssize_t s = read(sock,buf,sizeof(buf)-1);
         if( s > 0 )
         {
         buf[s] = 0;
         printf("client# %s \n",buf);
         write(sock,buf,strlen(buf));
         }
         else if( s == 0 )
         {
         printf("quit!\n");
         break;
         }
         else
         {
         perror("read");
         break;
         }
     }
     close(sock);
}
void* service(void* ptr)
{
    Arg* arg = (Arg *)ptr;
    ProcessRequest(arg->fd);
    free(arg);
    return NULL;
}
int main(int argc,char* argv[])
{
    if(argc != 3)
    {   
        printf("Usage:%s ip port\n",argv[0]);
        return 1; 
    }   

     //1. 创建套接字

     int listen_sock = socket(AF_INET, SOCK_STREAM , 0 );// SOCK_DGRAM 表示UDP
     if(listen_sock < 0)
     {   
     perror("socket");
     return 2;
     }   
     printf("Socker:%d\n",listen_sock);
    //2. 命名套接字

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(atoi(argv[2]));//端口号是2位的数
    local.sin_addr.s_addr = htnol(INADDR_ANY);//INADDR_ANY可以绑定任意ip



    // 3. 绑定端口号
     if( bind(listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0  )
     {
     perror("bind");
     return 3;
     }

     // 4. 开始监听listen_sock
     if( listen(listen_sock,5) < 0 )//这里的5是允许有5个客户端连接等待，如果收到更多的请求则忽略
     {
     perror("listen");
     return 4;
     }


     // 5. 接受请求
     printf("bind and listen success,wait accept...\n");

     for(;;)
     {
     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 new link![%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));


     pthread_t id = 0;
     Arg* arg = (Arg*)malloc(sizeof(Arg));
     arg->fd = new_sock;
     pthread_create(&id,NULL,service,(void *)arg);
     pthread_detach(id);
     }
     return 0;
}
测试代码：

1. 运行服务器代码，这里的ip地址是0代表可以为任意ip
这里写图片描述

2. 运行客户端代码

这里写图片描述
这里写图片描述
3. 客户端按照顺序全部退出，服务器会收到退出信息。
这里写图片描述
这里写图片描述
这里写图片描述

多进程版本和多线程版本的优缺点：

多进程和多线程的共同优点：支持多连接
多进程的优点和缺点：
优点：
   1.可以同时服务多个客户
   2.易于编写
   3.稳定。(任意一个进程挂掉，不会影响其他进程)
缺点：
   1.效率低（创建子进程需要时间）
   2.浪费资源
   3.服务的客户有上限
   4.性能较低
多线程的优点和缺点：
优点：
   相对多进程版本而言，缓解了性能问题和资源问题。
缺点：
  1. 不稳定。（任意一个线程挂掉，所有的线程都会退出）
  2. 共享资源，有风险。

TCP协议通讯过程

1. 下面是基于TCP协议的客户端和服务器程序的一般流程：

TCP在进行建立连接和断开连接时是基于状态机的。
我们把在TCP传输连接的建立和释放中的通信双方主机的这些状态称之为“有限状态机”（Finite State Machine，FSM）。

tcp连接状态：

这里写图片描述
这里写图片描述

2. 服务器初始化 ： 
1. 调用socket ： 创建文件描述符
2. 调用bind : 将当前的文件描述符的ip和port绑定起来(ip+port = 套接)；如果这个端口已经被别人占用，则绑定(bind)失败
// 服务器有两个文件描述符
3. 调用listen : 声明当前这个文件描述符作为一个服务器的文件描述符。为后面的accpet做好准备
4. 调用accept : 阻塞，等待客户端请求连接；( 另外，accpet才是进行IO的 )
3. 客户端建立连接的过程 (三次握手)： 
1. 调用socket ： 创建文件描述符
2. 调用connect ：向服务器发起请求连接 (三次握手)
   第一次： 客户端 ：connect会发出SYN段 并阻塞 等待服务器的应答
   第二次： 服务器端：收到客户端的SYN 会应答客户端一个SYN-ACK段(表示同意连接)
   第三次: 客户端：收到SYN-ACK段后会从connect()返回 同时应答一个ACK段给服务器端

而在这个过程中，大家都会被问到一个问题就是：为什么是三次握手？而不是两次或者四次或者五次？

首先，tcp是可靠传输协议，需要三次握手建立连接服务。
三次握手的目的是“为了防止已经失效的连接请求报文段突然又传到服务端，因而产生错误”，这种情况是：client端发出了一个连接请求报文，而是因为某些未知的原因在某个网络节点上发生延迟、滞留，导致延迟到连接释放以后的某个时间才到达server端。本来这是一个早已失效的报文段，但是server收到此失效的报文之后，会误认为是client再次发出的一个新的连接请求，于是server端就向client又发出确认报文，表示同意建立连接。
如果不采用“三次握手”，那么只要server端发出确认报文就会认为新的连接已经建立了，但是client端此时并没有发出建立连接的请求，因此不会去向server端发送数据，server端没有收到数据就会一直等待，产生死锁现象，这样server端就会白白浪费掉很多资源。
如果采用“三次握手”的话就不会出现这种情况，client端首先发出连接请求并进入等待状态，server接收连接请求后同意建立连接，并向client返回报文段表示已经建立连接server进入SYN_RECV状态，client接收到server发出的确认信息后自己再发出确认信息，然后就可以建立直接通信。所以说只有三次握手在逻辑上才是最合适的，可以保障可靠性。
三次握手的最主要目的是保证连接是双工的，可靠更多的是通过重传机制来保证的。

而这里的两次和四次的情况是类似的，五次和三次是类似的，明明可以三次握手达到效果为什么要去握手五次呢？所以有了三次握手。

4. 数据传输的过程：

在这里我们先理解一下 全双工 和 半双工 的概念：
全双工：在同一条连接中，同一时刻，通信的双方可以同时写数据
半双工：在同一条连接中，同一时刻，只能在一方来写数据 

而这里建立连接后，TCP协议提供全双工的通信服务。
     1. 服务器端 ： accpet()返回后立刻调用read()，读socket就像读管道一样，如果没有数据到达就阻塞等待
     2. 客户端： 这个时候客户端调用write()发送请求给服务器，服务器收到后从read()返回，对客户端的请求进行处理。在此期间，客户端调用read()阻塞等待服务器的应答。
     3. 服务器端：调用write()将处理结果发回给客户端(即客户端的read()等待服务器的响应)，再次调用服务器端的read()，阻塞等待下一条请求。
     4. 客户端：收到后从read()返回，发送下一条请求，如此循环下去进行通信
5. 断开连接的过程 (四次挥手)： 
正常情况下，如果客户端没有更多的请求了，就会调用close()关闭连接。下面就是断开连接（四次挥手）过程 ：
   第一次：(客户端) 会向服务器端发FIN段
   第二次：此时(服务器端)收到FIN段，会回应一个ACK,同时read会返回0.
   第三次：read返回以后，服务器端就知道客户端关闭了连接，也调用close()去关闭连接，这个时候服务器端向客户端发送FIN
   第四次：客户端收到FIN后，再返回一个ACK给服务器
6. 如果四次挥手时，服务器先断开连接会出现什么情况？

两方建立连接，如果服务器端先断开连接，而客户端还开着；然后立即重启服务器端，会发现端口地址被占用，无法建立连接，因为主动断开连接的一方有一个等待的过程 ( TIME_WATE )。

服务器先断开连接后：

这里写图片描述
这里写图片描述
我们会发现，突然间断开服务器，而客户端还在连接中，立即重启服务器是不可以的！等一会才可以再次重启服务器。这是等一会的时间就是在四次挥手（断开连接）的时间。

解决TIME_WAIT状态失败引起的bind失败的方法：

在Tcp_server.c代码的socket( ) 和 bind( ) 调用之间插入如下代码：

 int opt = 1;
 setsockopt(listen_sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
     int listen_sock = socket(AF_INET, SOCK_STREAM , 0 );// SOCK_DGRAM 表示UDP
     if(listen_sock < 0)
     {   
         perror("socket");
         return 2;
     }
     printf("Socker:%d\n",listen_sock);

     int opt = 1;
     setsockopt(listen_sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    //2. 命名套接字

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(atoi(argv[2]));//端口号是2位的数
    local.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY可以绑定任意ip

这里写图片描述
我们会发现，突然间断开服务器，而客户端还在连接中，立即重启服务器是可以的。

YAIMZA
关注
  • 10
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
tcp.rar_TCP程序_网络聊天程序
09-24
tcp/ip 网络聊天程序 网络聊天程序
网络编程三(TCP 通信的实现)
m0_48205251的博客
04-15 996
TCP 协议是面向的连接的，在通信时客户端与服务器端必须建立连接。在网络通讯中，第一次主动发起通讯的程序被称作客户端(Client)程序，简称客户端，而在 第一次通讯中等待连接的程序被称作服务器端(Server)程序，简称服务器。一旦通讯建立， 则客户端和服务器端完全一样，没有本质的区别。套接字 Socket 是一种进程间的数据交换机制。这些进程既可以在同一机器上，也可以在通过网络连接的不同机器上。换句话说，套接字起到通信端点的作用。
简单的TCP网络程序：英译汉服务器
最新发布
qq_64446981的博客
05-23 1636
下面介绍程序中用到的socket API,这些函数都在sys/socket.h中。
实验4tcp数据包的封装与发送
06-21
实验代码，实验用的请谨慎下载
网络编程—使用C语言实现发送TCP数据包，以命令行形式运行:SendTCP source_ip source_port dest_ip dest_port；（原理和常见错误分析）
weixin_44164333的博客
03-06 9210
任务要求： 1.以命令行形式运行:SendTCP source_ip source_port dest_ip dest_port； 2.头部参数自行设定，数据字段为“This is my homework of network of network,I am happy!”； 3.成功发送后在屏幕上输出“send OK”。 需求分析 本系统要求使用C语言作为基本开发语言，并且开发工具为绿色软件，...
C++编写自定义TCP包并发送
神棍之路
01-04 5302
转载修改自： https://blog.csdn.net/e_wsq/article/details/12766443 #include "pch.h" #include &lt;stdio.h&gt; #include &lt;winsock2.h&gt; #include &lt;ws2tcpip.h&gt; #include &lt;time.h&gt; #include &lt;wind...
发送tcp数据包实验设计
06-24
发送tcp数据包 C++程序实现。。。。。。
【网络技术】TCP详解
热门推荐
颜淡慕潇
07-06 3万+
TCP协议提供了可靠的数据传输、流量控制、拥塞控制、数据重传、数据分段和序列号等功能。 在TCP协议进行数据传输之前，需要先建立TCP连接，建立连接的过程中，客户端和服务器进行三次握手（SYN、SYN-ACK、ACK），以确保双方都能够接收和发送数据。 TCP协议通过使用ACK确认机制和序列号机制，保证传输的数据不会丢失、重复或者失序。每个数据包都会被确认，并且数据包的传输顺序不会发生错误。 此外，TCP协议还提供了流量控制、拥塞控制、数据重传、数据分段和序列号等功能，以满足不同的传输需求。
Tcp网络编程小程序
04-03
在该TCP网络程序中，服务器端扮演着服务提供者的角色，监听特定的端口，等待客户端的连接请求。当客户端连接成功后，服务器端可以接收客户端发送的数据，并进行相应的处理，例如回显或存储。服务器程序通常采用多...
Qt多线程TCP网络验证程序
06-15
前一阵子正好不忙，然后为了熟练Qt的TCP协议，就在空闲时间写了这么个练习程序，如果也有想要熟悉Qt的TCP协议的朋友，还是有看一看做一做对比的价值的，不过呢写着写着发现单纯的网络验证可能还是用http好一点，所以...
FTP-client_tcp_ftp_网络程序_简单的ftp程序_
10-03
标题中的“FTP-client_tcp_ftp_网络程序_简单的ftp程序_”表明这是一个关于FTP客户端的程序，使用TCP协议实现，并且设计简洁。FTP（File Transfer Protocol）是互联网上用于文件传输的标准协议，而TCP（Transmission...
java实现简单TCP聊天程序
08-27
java实现简单TCP聊天程序 本文主要介绍了java实现简单TCP聊天程序的知识点，包括服务端和客户端的代码实现。下面是详细的知识点解释： TCP协议 TCP（Transmission Control Protocol）是一种可靠的、面向连接的...
TCP粘包、拆包与解决方案、C++ 实现
houxian1103的博客
01-10 7155
说明： TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。即面向流的通信是无消息保护边界的。 TCP粘包、拆包图解 假设客户端分别发送了两个数据包D1和D2给服务端，由
网络编程——设计一个发送TCP数据包的程序
tqtiwvfdn的技术博客
05-28 7209
摘要 TCP/IP协议族是构建互联网的基石协议。在互联网中，从一台计算机向另外一台计算机传送数据，数据包可以通过两种协议传输。其中一种就是传输控制协议（Transmission Control Protocol，TCP）。TCP能够确保数据的传送，也确保数据包以它们正确的顺序传送，是一种提供可靠连接的传送协议。由于Java语言支持基于流的通信，即是用TCP协议进行传输，所以本次的课程设计将基
windows下C语言实现TCP通信
sinat_37372543的博客
02-27 7796
编译器：vs2017 语言：c语言 具体的原理可以在其他博客看到。在我学习winsock编程时，发现那些博客代码居然在我机器上没一个能运行，可能是我水平有限。于是我根据winsock相关知识，自己动手实现了一个，亲测能用，以下是代码。 服务器端 #include&lt;stdio.h&gt; #include&lt;Winsock2.h&gt; #include&lt;time.h&gt;...
网络编程：用tcp实现文件传输
qq_42343682的博客
03-30 6879
用tcp实现文件传输 文件发送端（tcp客户端） 1.网络链接 2.发送文件信息（文件名称， 文件大小） 3.发送文件内容（分段发送） 文件接收端 （tcp服务器） 1.网络初始化监听 2.接收文件信息（创建一个空文件准备接收数据） 3.接收文件内容（分段接收，计算接收得长度==文件大小） 完整代码： 发文件 /* 1. 文件发送端（tcp客户端） 1.网络链接 2.发送文件信息（文件名称， 文件大小） 3.发送文件内容（分段发送） */ #include <stdio.h> #i
TCP编程详解
AAAA202012的博客
10-18 2804
TCP回顾： ​ 1.面向连接的流式协议，可靠、出错重传、且每收到一个数据都要给出相应的确认； ​ 2.通信之前需要建立链接； ​ 3.服务器是被动链接，客户端是主动链接
一个简单的TCP通信程序
zsysingapore的博客
10-27 1317
1.基本通信过程 （1）调用socket()函数建立一个套接字，用于监听 （2）调用bind()函数为套接字绑定一个端口号，IP地址 （3）listen()函数，设置套接字处于监听状态 （4）若程序不退出，则反复执行 1）accept()函数等待客户机的连接。若远程计算机连接请求到来，则一个新的套接字与客户机直接的通信连接 2）rev()，send()利用新建连接与客户机通信 3)通信完 ，调用closesocket()函数关闭连接 （5）closesocket()关闭监听套接字，程序结束。 重点：！！！！
网络详解之TCP
weixin_52134286的博客
07-08 862
TCP 是面向连接的、可靠的、基于字节流的传输层通信协议。 其中: Socket：由 IP 地址和端口号组成 序列号：用来解决乱序问题等 窗口大小：用来做流量控制💡小知识控制位:情况一:数据包丢失 情况二:确认应答丢失 TCP 是面向连接的协议，所以使用 TCP 前必须先建立连接，而建立连接是通过三次握手来进行的。三次握手的过程如下图： 💡:为什么要进行三次握手? 1:首先进行三次握手最重要的原因是为了避免旧的重复连接初始化造成混乱 2:同步双方序列号💡:四次握手也能实现同步双方序列号,但是由于第二步...
labview TCP 网络通信程序
03-29
以下是一个简单的 LabVIEW TCP 网络通信程序示例： 1. 创建一个新的 LabVIEW 程序，并添加一个 TCP 服务器端口。 2. 将“TCP Listen” VI 拖放到主程序窗口中，并将其连接到服务器端口。 3. 在“TCP Listen” VI ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值