TCP编程

已于 2024-08-16 18:50:00 修改
阅读量982 收藏 17
点赞数 9
文章标签： tcp/ip 服务器 linux TCP编程
于 2024-08-16 18:48:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64378221/article/details/141266885
版权

步骤 

发端:                                                                 收端:

socket （创建套接字）                                       socket（创建套接字）

                                                                   bind （本机地址绑定）

                                                                   listen （监听）

connect（请求连接）                                          accept （处理连接）

send （发送数据）                                               recv （发送数据）

recv （接收数据）                                                send （接收数据）

close （关闭套接字）                                           close （关闭套接字）

函数接口 

（1）socket 

  TCP: socket(AF_INET, SOCK_STREAM, 0);

功能:

      创建套接字

（2） listen 

listen 
        int listen(int sockfd, int backlog);
        功能:
            监听发送三次握手连接的套接字,并放入等到处理队列中
        参数:
            sockfd:套接字文件描述符
            backlog:等待队列的大小(最多存放尚未被处理的三次握手请求的个数)，

                                可以设置为0，即收到一个连接请求，处理一个连接请求
        返回值:
            成功返回0 
            失败返回-1 

（3） accept 

accept 
          int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
          功能：
              处理等待队列中的第一个套接字
          参数：
              sockfd:套接字文件描述符 
              addr:存放发送方IP地址的空间首地址
              addrlen：存放发送方IP地址的空间大小
          返回值:
              成功返回一个新的文件描述符
              失败返回-1 

（4） connect 

connect 
          int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
          功能:
            向接收方发起连接请求
          参数:
            sockfd:套接字文件描述符
            addr:接收方的IP地址和端口号
            addrlen:接收方的IP地址和端口号的大小
          返回值:
            成功返回0 
            失败返回-1 

（5） send 

send 
          ssize_t send(int sockfd, const void *buf, size_t len, int flags);
          功能:
            向接收方发送数据
          参数:
            sockfd:套接字文件描述符
            buf:要发送的数据的首地址 
            len:要发送的数据的长度
            flags:标志位 
          返回值：
            成功返回发送字节数
            失败返回-1 

（6） recv 

recv 
          ssize_t recv(int sockfd, void *buf, size_t len, int flags);
          功能:
            接收发送方发送的数据
          参数:
            sockfd:套接字文件描述符
            buf:接收数据的缓冲区首地址
            len:接收数据的缓冲区的大小
            flags:标志位 
          返回值：
            成功返回实际接收字节数
            失败返回-1 
            对方关闭返回0 

练习一：利用TCP实现简单收发功能 

本机作为客户端

#include "../head.h"
int main()
{
    int sockfd;
    struct sockaddr_in recvaddr;
    int ret=0;
    char tmpbuff[256]={0};
    ssize_t nsize=0;
    recvaddr.sin_family=AF_INET;
    recvaddr.sin_port=htons(30000);
    recvaddr.sin_addr.s_addr=inet_addr("192.168.0.187");
    //创建套接字
    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd==-1)
    {
        return -1;
    }
    //发送连接请求
    ret=connect(sockfd,(struct sockaddr *)&recvaddr,sizeof(recvaddr) );
    if(ret==-1)
    {
        return -1;
    }

    //发送数据
    fgets(tmpbuff,sizeof(tmpbuff),stdin);
    tmpbuff[strlen(tmpbuff)-1]='\0';
    nsize=send(sockfd,tmpbuff,strlen(tmpbuff),0);
    if(nsize==-1)
    {
        return -1;
    }
    printf("发送成功\n");
    //接收数据
    memset(tmpbuff,0,sizeof(tmpbuff));
    nsize=recv(sockfd,tmpbuff,sizeof(tmpbuff),0);
    if(nsize==-1)
    {
        return -1;
    }
    printf("接收到的字节数:%ld,内容为:%s\n",nsize,tmpbuff);
    //关闭套接字
    close(sockfd);
    return 0;
}

本机作为服务端

#include "../head.h"
int main()
{
    int sockfd;
    struct sockaddr_in recvaddr;
    ssize_t nsize;
    int confd;
    char tmpbuff[256]={0};
    int ret=0;
    //创建套接字
    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd==-1)
    {
        perror("failed to sockfd");
        return -1;
    }
    //绑定IP地址 端口号
    recvaddr.sin_family=AF_INET;
    recvaddr.sin_port=htons(30000);
    recvaddr.sin_addr.s_addr=inet_addr("192.168.0.187");
    ret=bind(sockfd,(struct sockaddr *)&recvaddr,sizeof(recvaddr));
    if(ret==-1)
    {
        perror("failed to bind");
        return -1;
    }
    //监听
    ret=listen(sockfd,10);// 监听发送三次握手连接的套接字,并放入等到处理队列中，监听队列写0也可以，即发一个请求，处理一个请求
    if(ret == -1)
    {
        perror("failed to listen");
        return -1;
    }  
    //处理连接请求
    confd=accept(sockfd,NULL,NULL);//处理等待队列中的第一个套接字
    if(confd==-1)
    {
        perror("failed to config");
        return -1;
    }
    //接收数据
    nsize=recv(confd,tmpbuff,sizeof(tmpbuff),0);
    if(nsize==-1)
    {
        perror("failed to recv");
        return -1;
       
    }
     printf("接收字节数:%ld,内容为：%s\n",nsize,tmpbuff);
    //发送数据
    memset(tmpbuff,0,sizeof(tmpbuff));
    fgets(tmpbuff,sizeof(tmpbuff),stdin);
    tmpbuff[strlen(tmpbuff)-1]='\0';
    nsize=send(confd,tmpbuff,strlen(tmpbuff),0);
    if(nsize==-1)
    {
        perror("failed to send");
        return -1;
    }
    printf("发送成功\n");
    //关闭套接字
    close(confd);
    close(sockfd);
    return 0;
}

 练习二：利用TCP实现发送文件功能

发送文件端

#include "../head.h"
int main()
{
    int sockfd;
    FILE *fp=NULL;
    char tmpbuff[1000]={0};
    ssize_t nsize=0;
    size_t size=0;
    int ret=0;
    
    struct sockaddr_in recvaddr;
    //创建套接字
    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd==-1)
    {
        perror("failed to socket");
        return -1;
    }
    recvaddr.sin_family=AF_INET;
    recvaddr.sin_port=htons(50000);
    recvaddr.sin_addr.s_addr=inet_addr("192.168.0.187");
    //建立连接
    ret=connect(sockfd,(struct sockaddr *)&recvaddr,sizeof(recvaddr));
    if(ret==-1)
    {
        perror("failed to connect");
        return -1;
    }
    printf("连接成功\n");
    //发送文件名
    printf("请输入要发送的文件名：");
    fgets(tmpbuff,sizeof(tmpbuff),stdin);
    tmpbuff[strlen(tmpbuff)-1]='\0';
    nsize=send(sockfd,tmpbuff,strlen(tmpbuff),0);
    if(nsize==-1)
    {
        perror("failed to send");
        return -1;
    }
    //打开文件
    fp=fopen(tmpbuff,"r");
    if(fp==NULL)
    {
        perror("failed to fopen");
        return -1;
    }
    //发送数据
    while(1)
    {
        size=fread(tmpbuff,1,sizeof(tmpbuff),fp);
        if(size<=0)
        {
            break;
        }
        if(!strcmp(tmpbuff,".quit"))
        {
            break;
        }
        nsize=send(sockfd,tmpbuff,size,0);
        if(nsize==-1)
        {
            perror("failed to send");
             break;
        }
    }
    //关闭套接字
    close(sockfd);
    //关闭文件
    fclose(fp);
    return 0;
}

 接收文件端

#include "../head.h"
int main()
{
    int sockfd;
    char tmpbuff[1000]={0};
    struct sockaddr_in recvaddr;
    size_t size;
    ssize_t nsize=0;
    FILE *fp=NULL;
    int ret=0;
    int confd=0;
    //创建套接字
    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd==-1)
    {
        perror("failed to sockfd");
        return -1;
    }

    //绑定
    recvaddr.sin_family=AF_INET;
    recvaddr.sin_port=htons(50000);
    recvaddr.sin_addr.s_addr=inet_addr("192.168.0.187");
    ret=bind(sockfd,(struct sockaddr *)&recvaddr,sizeof(recvaddr));
    if(ret==-1)
    {
        perror("failed to bind");
        return -1;
    }
    //监听
    ret=listen(sockfd,10);
    if(ret==-1)
    {
        perror("failed to listen");
        return -1;
    }
    //处理连接
    confd=accept(sockfd,NULL,NULL);
    if(confd==-1)
    {
        perror("failed to accept");
        return -1;
    }
    printf("连接成功\n");
    //接收文件名
    nsize=recv(confd,tmpbuff,sizeof(tmpbuff),0);
    if(nsize==-1)
    {
        perror("failed to recv");
        return -1;
    }
    printf("tmpbuff=%s\n",tmpbuff);
    //创建文件
    fp=fopen(tmpbuff,"w");
    if(fp==NULL)
    {
        perror("failed to fopen");
        return -1;
    }
    //接收文件内容
    while(1)
    {
        nsize=recv(confd,tmpbuff,sizeof(tmpbuff),0);
        if(nsize<=0)
        {
            break;
        }
        if(!strcmp(tmpbuff,".quit"))
        {
            break;
        }
        fwrite(tmpbuff,1,nsize,fp);
    }
    //关闭套接字
    close(sockfd);
    close(confd);
    //关闭文件
    fclose(fp);
    
    return 0;
}

练习三：TCP 实现聊天功能(通过进程实现)

send.c

#include "../head.h"
int main()
{
    int sockfd;
    struct sockaddr_in recvaddr;
    char tmpbuff[256]={0};
    size_t nsize=0;
    int ret=0;
    pid_t pid;
    //创建套接字
     sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd==-1)
    {
        perror("failed to socket");
        return -1;
    }
    recvaddr.sin_family=AF_INET;
    recvaddr.sin_port=htons(40000);
    recvaddr.sin_addr.s_addr=inet_addr("192.168.0.187");
    //建立连接
    ret=connect(sockfd,(struct sockaddr *)&recvaddr,sizeof(recvaddr));
    if(ret==-1)
    {
        perror("failed to connect");
        return -1;
    }
    //创建进程
    pid=fork();
    if(pid==-1)
    {
        perror("failed to fork");
        return -1;
    }
    //子进程负责发
    if(pid==0)
    {
        while(1)
        {
            memset(tmpbuff,0,sizeof(tmpbuff));
            fgets(tmpbuff,sizeof(tmpbuff),stdin);
            tmpbuff[strlen(tmpbuff)-1]='\0';
            if(!strcmp(tmpbuff,".quit"))
            {
                break;
            }
            nsize=send(sockfd,tmpbuff,strlen(tmpbuff),0);
            if(nsize<=0)
            {
                break;
            }
        }
        kill(getppid(),SIGKILL);
    }
    //父进程负责收
    else if(pid>0)
    {
        while(1)
        {
            memset(tmpbuff,0,sizeof(tmpbuff));
            nsize=recv(sockfd,tmpbuff,sizeof(tmpbuff),0);
            if(nsize<=0)
            {
                break;
            }
            if(!strcmp(tmpbuff,".quit"))
            {
                break;
            }
            printf("接收内容:%s\n",tmpbuff);

        }
        kill(pid,SIGKILL);
    }
    //关闭套接字
    close(sockfd);
    return 0;
}

recv.c

#include "../head.h"
int main()
{
    int sockfd;
    struct sockaddr_in recvaddr;
    char tmpbuff[256]={0};
    int confd;
    size_t nsize=0;
    int ret=0;
    pid_t pid;
    //创建套接字
     sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd==-1)
    {
        perror("failed to socket");
        return -1;
    }
    //绑定
    recvaddr.sin_family=AF_INET;
    recvaddr.sin_port=htons(40000);
    recvaddr.sin_addr.s_addr=inet_addr("192.168.0.187");
    ret=bind(sockfd,(struct sockaddr *)&recvaddr,sizeof(recvaddr));
    if(ret==-1)
    {
        perror("failed to bind");
        return -1;
    }
    //监听
    ret=listen(sockfd,10);
    if(ret==-1)
    {
        perror("failed to bind");
        return -1;
    }
    //处理连接
    confd=accept(sockfd,NULL,NULL);
    if(confd==-1)
    {
        perror("failed to accept");
        return -1;
    }
    //创建进程
     pid=fork();
    if(pid==-1)
    {
        perror("failed to fork");
        return -1;
    }
    //子进程负责发
    if(pid==0)
    {
        while(1)
        {
            memset(tmpbuff,0,sizeof(tmpbuff));
            fgets(tmpbuff,sizeof(tmpbuff),stdin);
            tmpbuff[strlen(tmpbuff)-1]='\0';
            if(!strcmp(tmpbuff,".quit"))
            {
                break;
            }
            nsize=send(confd,tmpbuff,strlen(tmpbuff),0);
            if(nsize<=0)
            {
                break;
            }
        }
        kill(getppid(),SIGKILL);
    }
    //父进程负责收
    else if(pid>0)
    {
        while(1)
        {
            memset(tmpbuff,0,sizeof(tmpbuff));
            nsize=recv(confd,tmpbuff,sizeof(tmpbuff),0);
            if(nsize<=0)
            {
                break;
            }
            if(!strcmp(tmpbuff,".quit"))
            {
                break;
            }
            printf("接收内容：%s\n",tmpbuff);

        }
        kill(pid,SIGKILL);
    }
    //关闭套接字
    close(confd);
    close(sockfd);
    return 0;

}

⊙^⊙
关注
  • 9
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
TCP/UDP包头介绍
bin080808jie的专栏
04-08 8298
TCP Transmission Control Protocol 面向连接的，可靠的，基于字节流的传输层通信协议 TCP传输的数据单元是它的报文段，包括首部和数据 传输过程中，报文都会进行封装后再传输（封装-->传输） TCP报文首部（包头） TCP包头为20字节 TCP包头解释 line 1：源端口号、目的端口号，用于建立连接时，确认源端口（本机）和目的主机的端口号 line 2：序号，用来表示发送端到接收端的数据字节流 line 3：确认序号，表示下一次所期望收到
【网络】传输层--趣谈网络协议（二）
weixin_56814032的博客
06-25 1312
一、UDP协议 传输层有两个比较重要的协议，一个是TCP，一个是UDP。 1、TCP和UDP的区别 TCP是面向连接的协议，在互通之前会先建立连接，属于有状态服务。所谓的建立连接，是为了在客户端和服务端维护连接，而建立一定的数据结构来维护双方交互的状态，用这样的数据结构来保证所谓的面向连接的特性。而UDP是面向无连接的，是无状态服务。 TCP提供可靠交付。通过TCP连接传输的数据，无差错、不丢失、不重复且按序到达。而UDP继承了IP包的特性，不保证不丢失，不保证按序到达。 TCP是面向字节流的，发
TCP/UDP/ARP/DNS/HTTP/帧的包头解析（保姆级分析）
ab9UQ8L的博客
02-13 3630
TCP/UDP/ARP/DNS/HTTP/帧的包头解析（保姆级分析）
各种数据包头的详解（tcp，udp，ipv4，ipv6）
qq_64302290的博客
07-07 3705
Tcp的协议号：6，udp的协议号：17，ICMP的协议号：1（ICMP为跨层封装），ospf的协议号为：89（ospf协议为跨层封装），eigrp的协议号为：88（跨层封装），当值为6时表示ip的上层使用的是tcp协议。第n个分片的偏移值为前n-1个分片的大小（第一个分片的值为0，第二个分片的值为第一个分片的大小，第三个分片的值为前两个分片的大小之和。MF：当这个bit等于1时，表示你还没收完的该数据的分片，后面还有该数据的分片，当它为0时则表示该分片时该数据的最后一个分片（该数据的分片已经被收完）。
UDP协议的简单概述
m0_55017965的博客
04-13 2182
UDP是User Datagram Protocol（用户数据协议）的简称，是一种无连接的协议，该协议工作在OSI模型中的第四层（传输层），处于IP协议的上一层。传输层的功能就是建立“端口到端口”的通信，UDP提供面向事务的简单的不可靠信息传送服务。UDP协议是一种无连接的协议，该协议用来支撑那些需要在计算机之间传输数据的网络应用，包括网络视频会议系统在内的众多客户/服务器模式的网络应用。3.UDP信息包的标题很短，只有8个字节，相对于TCP的20个字节信息包的额外开销很小。
ipv6实现tcp编程示例
09-04
ipv6实现tcp编程示例 Ipv6实现tcp编程示例是指在Ipv6网络环境下编写tcp协议的编程示例。Ipv6是Internet协议的下一代版本，它具有更好的安全性、扩展性和可扩展性等特点。tcp协议是传输层协议，提供了可靠的、面向...
tcp.rar_TCP编程pdf_tcp
09-23
TCP编程是网络编程中的重要环节，对于任何希望深入理解网络通信或者开发网络应用的初学者来说，都是必不可少的知识点。 在TCP编程中，首先要理解的是TCP的三次握手建立连接的过程。当一个主机想要与另一个主机建立...
TCP.rar_tcp编程
09-24
在TCP编程中，开发者通常会使用像Visual C++这样的编程环境来实现网络通信功能。本篇文章将深入探讨TCP编程的基本概念、原理以及如何在Visual C++环境下进行实践。 首先，TCP协议确保了数据的可靠传输，它通过三次...
Labview TCP编程.zip_DEMO_LabVIEW tcp_LabVIEW的TCP_labview编程
07-14
10. **实时系统中的TCP编程**：在LabVIEW RT（实时版）环境下，TCP编程也有其特殊考虑，如内存管理和实时性能优化。 通过深入研究这些DEMO，用户不仅可以学习到TCP的基本概念，还能掌握在LabVIEW中实现TCP通信的...
分析UDP数据包结构
热门推荐
liumengyan_ysu的专栏
01-22 1万+
一个典型的udp数据报包含如下几个部分：以太网MAC首部+网络层IP数据报首部+传输层UDP首部+要传输的数据 1.以太网MAC头 以太网MAC头由14个字节构成，6个目的地址，6个源地址，2个类型字段，目的地址和源地址是指网卡的MAC地址，具有唯一性。协议是指数据包的高级协议，0X8000：IP协议，0X0806：ARP协议，0X8035：RARP协议 如你要发送的目的MAC地址是：0
温故知新：IP头部
岁月留痕
10-31 4011
总是注重于应用层协议～冷不丁突然提起网络层、传输层的概念细节～真想不起了～嗯～温故知新吧～复习啦：（照例，网上转载的啦）1、IP报文格式　　　　IP协议是TCP/IP协议族中最为核心的协议。它提供不可靠、无连接的服务，也即依赖其他层的协议进行差错控制。在局域网环境，IP协议往往被封装在以太网帧（见本章1.3节）中传送。而所有的TCP、UDP、ICMP、IGMP数据都被封装在IP数据报中传送
TCP-UDP详解
xlxing
01-09 578
1. UDP详解 1.1 什么是UDP？ UDP（User Data Protocol，用户数据报协议）：属于传输层的协议，无连接，UDP适用于一次传输少量数据，对可靠性要求不高的应用环境。 不可靠（不保证不丢失，不保证按顺序到达） 基于数据报（一个一个地发，一个一个地收） 无状态（发出去就完事了，啥都不管） 无控制（不会根据外部环境（网络环境）来进行发包控制，应用让发就发，什么都不考虑） 1...
TCP协议、UDP协议（传输层重点协议）
AwwzJ_0821的博客
04-07 3836
此时收到了 500K 的数据，如果立刻应答，返回的窗口就是 500K，但是处理端处理接收端缓冲区的速度很快，一下子就把 500K 的数据从缓冲区中取走处理了，此时接收端缓冲区的剩余大小变成了 1M，说明可以接收的数据就不止 500K 了。接收端认为连接还在，一旦接收端有写入操作，就能发现连接已经不在了，就会进行 reset。当 我的麦克风 有问题时，我问“老师你能听见我说话吗”就等不到回应了，如果又说了“老师能听到吗”后，还是没有回应，我就知道了这次通信失败了（不具备可靠传输的条件了），于是我就放弃了。
【计算机网络】UDP协议概述
欢迎。
05-23 2842
UDP协议（User Datagram Protocol，用户数据报协议）：面向无连接的协议，不保证可靠性，但是具有较低的延迟和更快的传输速度，常用于实时音视频传输、广播和多播等场景。传输层的主要功能是在网络中的两个应用程序之间提供端到端的通信服务，包括数据传输的可靠性和流量控制等，以确保应用程序之间的数据传输是稳定和有效的。在UDP中，广播和组播都是用于将数据同时传输给多个接收方的方式。：UDP协议的头部非常简单，只有8个字节，相较于TCP协议，UDP协议的数据头较小，需要的传输数据大小更小。
计算机网络（二）—— 传输层协议（TCP & UDP）
敲敲敲
05-21 995
1.UDP协议 1.1 UDP协议的包头信息： 定长——8个字节，容易做解包 16位源端口 + 16位目的端口 + 16位UDP长度（决定了能传输的数据最大长度是64K） + 16位校验和（校验和就是为了防止数据错误，类似hash算法，发方计算得到校验和，收方用相同hash计算，比对数据，如果收端的hash值与发端的hash不一致，会直接丢弃） 1.2 UDP特点 无连接的（不用连接就发送）； 不可靠的（只管发，至于发成功没，发正确没是不能确定的） 面向数据报文（.
关于UDP-读这篇就够了（疑难杂症和使用）
木牛的博客
12-12 1005
本文为转载文章原文链接：https://www.qcloud.com/community/article/848077001486437077版权归原文所有关于UDP面向报文的传输方式决定了UDP的数据发送方式是一份一份的，也就是应用层交给UDP多长的报文，UDP就照样发送，即一次发送一个报文。那么UDP的报文大小由哪些影响因素呢？UDP数据包的理论长度是多少，合适的UDP数据包应该是多少呢？(1)UDP报文大小的影响因素，主要有以下3个。
linxu 软件编程 网络 udp tcp
最新发布
mxyzhy的博客
08-16 993
Linux软件编程tcp/ip
UDP的报文结构
m0_73730252的博客
05-21 655
UDP报文结构
UDP协议详解
waywt1的博客
09-11 1518
16位源/目的端口：表示数据从哪个进程来，到哪个进程去；16位UDP长度：表示整个数据报（UDP首部+UDP数据）的最大长度；16位UDP检验和：如果校验和出错，就会直接丢弃。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值