网络编程：OSI协议，TCP/IP协议，IP地址，UDP编程

已于 2024-08-16 19:23:04 修改
阅读量1.1k 收藏 23
点赞数 20
文章标签： tcp/ip udp TCP编程 嵌入式 linux
于 2024-08-15 20:04:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64378221/article/details/141230227
版权

目录

国际网络通信协议标准：

1.OSI协议：

 2.TCP/IP协议模型：

 应用层  ：

 传输层：

  网络层：             IPV4协议            IP地址

 IP地址的划分：            公有地址            私有地址

        MAC地址：

        端口号：

 UDP编程

1.套接字：

2.流程  

3.函数接口

（1） socket

 （2）sendto 

（3） inet_addr

（4） htons 

（5） bind 

（6）recvfrom 

 主机作为发送端

主机作为接收端

 网络：
协议：通信双方约定的一套标准 

国际网络通信协议标准：

1.OSI协议：

        应用层          发送的数据内容
        表示层          数据是否加密
        会话层          是否建立会话连接
        传输层          数据传输的方式
        网络层          数据的路由
        数据链路层      局域网内部通信
        物理层          物理介质的连接

 2.TCP/IP协议模型：

 
        应用层          发送的数据内容
        传输层          数据传输的方式
        网络层          数据由一台主机到达另一台主机
        网络接口层      物理介质连接 

 应用层  ：


            FTP     文件传输协议    
            TFTP    简单文件传输协议
            HTTP    超文本传输协议
            HTTPS   安全超文本传输协议
            SMTP    简单邮件传输协议
            TELNET  网络终端登录协议
            DNS     域名系统
            .. 

 传输层：

    TCP     传输控制协议
     UDP     用户数据报协议

            UDP：不安全、不可靠的传输方式
                 UDP机制简单
                 UDP占用的资源开销比较小
            TCP：安全、可靠的传输方式
                 TCP机制复杂
                 TCP占用的资源开销比较大 
                    三次握手建立连接,确认双方能够通信
                    通信过程中保障数据传输的完整性
                    四次挥手断开连接,确保数据传输的完整

  网络层： 
            IPV4协议
            IP地址

            管理员IP地址形式：192.168.0.167
            内存IP地址形式：  11000000.10101000.00000000.10100111

            IP地址 = 网络位 + 主机位 
            网络位：IP地址所属的网段（局域网的编号）
            主机位：局域网中的第几台主机
            网段号：网络位不变，主机位全为0 
            广播号：网络位不变, 主机位全为1 
            子网掩码：每个IP地址都会搭配一个子网掩码,用来区分IP地址的网络位及主机位
                     子网掩码展开成二进制,1对应的部分就是IP地址的网络位,0对应的部分就是IP地址的主机位
            192.168.0.167
            255.255.255.0
            11000000.10101000.00000000.10100111
            11111111.11111111.11111111.00000000

            网段号192.168.0.0
            广播号192.168.0.255

 IP地址的划分：
            公有地址
            私有地址

            A类：1.0.0.0 ~ 126.255.255.255
                子网掩码：255.0.0.0 
                管理超大规模型网络
                私有地址：10.0.0.0 ~ 10.255.255.255

            B类：128.0.0.0 ~ 191.255.255.255
                子网掩码：255.255.0.0 
                管理大中规模型网络
                私有地址：172.16.0.0 - 172.31.255.255

            C类：192.0.0.0 ~ 223.255.255.255
                子网掩码：255.255.255.0
                管理中小规模型网络
                私有地址：192.168.0.0 ~ 192.168.255.255

            D类：224.0.0.0 ~ 239.255.255.255
                用于组播：255.255.255.0

            E类：240.0.0.0 ~ 255.255.255.255
                用于实验和研究：255.255.255.0

        MAC地址：

 设备自带网卡的地址（该地址是唯一的）


        端口号：

 找到同一台主机不同的应用程序

 UDP编程

1.套接字：


        实现Linux系统下的网络通信
        套接字：一次通信对象的抽象

2.流程  

发送端流程：1.创建套接字
               2.发送信息
               3.关闭套接字

    接收端流程： 1.创建套接字       
                2.绑定IP和Port
                3.接收信息 
                4.关闭套接字

3.函数接口

（1） socket

socket 
      int socket(int domain, int type, int protocol);
      功能：
        创建套接字
      参数：
        domain: AF_INET 表示IPV4协议
        type:套接字类型
            SOCK_STREAM：流式套接字
            SOCK_DGRAM:数据报套接字
            SOCK_RAW：原始套接字
        protocol:
            TCP和UDP协议：0
      返回值：  
        成功返回用来通信的文件描述符
        失败返回-1 
 

 （2）sendto 

sendto 
      ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);
      功能:
        发送信息
      参数:
        sockfd:套接字文件描述符
        buf:发送数据空间首地址
        len:发送数据长度
        flags:发送属性 默认为0 
        dest_addr:目标地址存放空间首地址
        addrlen:目的地址的长度

struct sockaddr_in {
            sa_family_t    sin_family; /* address family: AF_INET */
            in_port_t      sin_port;   /* port in network byte order */
            struct in_addr sin_addr;   /* internet address */
        };

        /* Internet address. */
        struct in_addr {
            uint32_t       s_addr;     /* address in network byte order */
        };

      返回值:
        成功返回发送字节数
        失败返回-1 

  如果sendto对应的套接字没有绑定端口，则sendto绑定一个随机端口完成发送功能

（3） inet_addr

inet_addr
      in_addr_t inet_addr(const char *cp);
      功能：
        将字符串的IP地址转换为32位的地址类型

（4） htons 

htons 
      uint16_t htons(uint16_t hostshort);
      功能：    
        将本地字节序(小端)转换成网络大端字节序
 

（5） bind 

bind 
      int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
      功能：
        将套接字与IP地址和端口进行绑定
      参数:
        addr:绑定地址结构体空间首地址
        addrlen:绑定地址空间大小
      返回值：
        成功返回0 
        失败返回-1 
      注意：
        只能绑定自己的IP地址

（6）recvfrom 

 ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen);
      功能：
        接收信息
      参数：
        sockfd：套接字文件描述符
        buf：接收数据空间首地址
        len：接收数据长度
        flags：接收的属性 默认为0 
        src_addr：存放发送方地址空间的地址
        addrlen: 要接收的发送方地址的长度
      返回值：
        成功返回实际接收字节数
        失败返回-1 

 练习一：

主机作为发送端

#include "../head.h"
//主机作为发送方
int main()
{
    int sockfd=0;
    ssize_t nsize=0;
    struct sockaddr_in recvaddr;
    struct sockaddr_in sendaddr;
    //创建用来通信的套接字
    sockfd=socket(AF_INET,SOCK_DGRAM,0);//AF_INET：IPV4协议族，SOCK_DGRAM：UDP数据报套接字
    if(sockfd==-1)
    {
        perror("failed to socket");
        return -1;
    }
    //将发送端套接字与IP地址和端口号绑定
    sendaddr.sin_family=AF_INET;
    sendaddr.sin_port=htons(30000);
    sendaddr.sin_addr.s_addr=inet_addr("192.168.0.185");
    bind(sockfd,(struct sockaddr *)&sendaddr,sizeof(sendaddr));

    //为目的地址赋值
    recvaddr.sin_family=AF_INET;//协议族为IPV4
    recvaddr.sin_port=htons(8080);//端口号（ htons() 将本地字节序（小端）转换为网络字节序（大端））（发送给wltszs4.3.29网络调试助手）
    recvaddr.sin_addr.s_addr=inet_addr("192.168.0.135");//IP地址（ inet_addr() 将字符串类型转换为二进制地址类型）
    
    //向目的地址发送数据
    nsize=sendto(sockfd,"66666666666",12,0,(struct sockaddr *)&recvaddr,sizeof(recvaddr));//注意强制类型转换
    if(nsize==-1)
    {
        perror("failed to sendto");
        return 0;
    }
    printf("发送成功\n");
    //关闭套接字
    close(sockfd);
    return 0;
}

主机作为接收端

#include "../head.h"
int main()
{

    int sockfd=0;
    int ret=0;
    char tmpbuff[200]={0};
    ssize_t nsize=0;
    struct sockaddr_in recvaddr;
    //创建套接字
    sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd==-1)
    {
        perror("failed to socket");
        return -1;
    }
    //将套接字和IP地址与端口号绑定
    recvaddr.sin_family=AF_INET;
    recvaddr.sin_port=htons(20000);
    recvaddr.sin_addr.s_addr=inet_addr("192.168.0.185");
    ret=bind(sockfd,(struct sockaddr *)&recvaddr,sizeof(recvaddr));

    if(ret==-1)
    {
        perror("failed to bind");
        return 0;
    }
    //接受数据
    nsize=recvfrom(sockfd,tmpbuff,sizeof(tmpbuff),0,NULL,NULL);
    if(nsize==-1)
    {
        perror("failed to recvfrom");
        return 0;
    }
    //打印数据
    printf("接收到字节数:%ld,内容为:%s\n",nsize,tmpbuff);
    //关闭套接字
    close(sockfd);
    return 0;
}

练习二：利用UDP编程发送文件

发送端send.c

#include "../head.h"
int main()
{
    int sockfd;
    int ret=0;
    FILE *fp=NULL;
    struct sockaddr_in recvaddr;
    char readbuff[1024]={0};
    size_t size=0;
    ssize_t nsize=0;

   //创建套接字
    sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd==-1)
    {
        perror("failed to socket");
        return -1;
    }
    
    //为目的地址赋值
    recvaddr.sin_family=AF_INET;
    recvaddr.sin_port=htons(30000);
    recvaddr.sin_addr.s_addr=inet_addr("192.168.0.187");
    //输入要发送的文件名
    printf("请输入要发送的文件名：");
    fgets(readbuff,sizeof(readbuff),stdin);
    readbuff[strlen(readbuff)-1]='\0';
    //打开该文件
    fp=fopen(readbuff,"r");
    if(fp==NULL)
    {
        perror("failed to fopen send.txt");
        return -1;
    }
    
   //发送文件名
    nsize=sendto(sockfd,readbuff,strlen(readbuff)+1,0,(struct sockaddr *)&recvaddr,sizeof(recvaddr));
     if(nsize==-1)
    {
         perror("failed to sendto");
         return -1;
    }
//发送文件内容
while(1)
{
     size=fread(readbuff,1,sizeof(readbuff),fp);
     if(size<=0)
     {
        break;
     }
     nsize=sendto(sockfd,readbuff,size,0,(struct sockaddr *)&recvaddr,sizeof(recvaddr));
     if(nsize==-1)
    {
         perror("failed to sendto");
         return -1;
    }
}
//发送文件结尾关闭标志
    sprintf(readbuff,".quit");
    nsize=sendto(sockfd,readbuff,size,0,(struct sockaddr *)&recvaddr,sizeof(recvaddr));
     if(nsize==-1)
    {
         perror("failed to sendto");
         return -1;
    }
   //关闭套接字和文件
    close(sockfd);
    fclose(fp);
    return 0;  
   
}

接收文件端

#include "../head.h"
int main()
{
    int sockfd;
    int ret=0;
    FILE *fp=NULL;
    char filename[100]={0};
    char tmpbuff[1024]={0};
    struct sockaddr_in recvaddr;
    char readbuff[1024]={0};
    size_t size=0;
    ssize_t nsize=0;

   //创建套接字
    sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd==-1)
    {
        perror("failed to socket");
        return -1;
    }
    
   //绑定接收IP地址和套接字，端口号
    recvaddr.sin_family=AF_INET;
    recvaddr.sin_port=htons(30000);
    recvaddr.sin_addr.s_addr=inet_addr("192.168.0.187");
    bind(sockfd,(struct sockaddr *)&recvaddr,sizeof(recvaddr));
   //接收文件名
    nsize=recvfrom(sockfd,filename,sizeof(filename),0,NULL,NULL);
    if(nsize==-1)
    {
        perror("failed to recvfrom");
        return -1;
    }
    //创建文件
     fp=fopen(filename,"w");
    if(fp==NULL)
    {
        perror("failed to fopen");
        return -1;
    }
    //接收文件内容
    while (1)
    {
         nsize=recvfrom(sockfd,tmpbuff,sizeof(tmpbuff),0,NULL,NULL);
         if(nsize==0)
        {
            
            break;
        }
        if(!strcmp(tmpbuff,".quit"))
        {
            break;
        }
        fwrite(tmpbuff,nsize,1,fp);
    }
    //关闭套接字和文件
    close(sockfd);
    fclose(fp);
    return 0;  
   
}

练习三：利用UDP编程实现聊天功能

1.(进程实现)

send.c

#include "../head.h"
int main()
{
    pid_t pid;
    struct sockaddr_in sendaddr;
    struct sockaddr_in recvaddr;
    char tmpbuff[100]={0};
    ssize_t size_send;
    ssize_t size_recv;
    int sockfd=0;
    sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd==-1)
    {
        perror("failed to socket");
        return -1;
    }
    recvaddr.sin_family=AF_INET;
    recvaddr.sin_port=htons(30000);
    recvaddr.sin_addr.s_addr=inet_addr("192.168.0.187");

//第一次发送是为了建立连接，数据可随机发送，不打印
    size_send = sendto(sockfd,"hello",6,0,(struct sockaddr *)&recvaddr,sizeof(recvaddr));
    if(size_send==-1)
    {
        perror("failed to sendto");
        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';
              
                size_send=sendto(sockfd,tmpbuff,strlen(tmpbuff),0,(struct sockaddr *)&recvaddr,sizeof(recvaddr));
                if(size_send==-1)
                {
                    perror("failed to sendto");
                    return -1;
                }
               
                if(!strcmp(tmpbuff,".quit"))
                {
                    
                    break;
                }
               
        }
        kill(getppid(),SIGKILL);

    }
    else if(pid>0)
    {
        while(1)
        {
            memset(tmpbuff,0,sizeof(tmpbuff));
            size_recv = recvfrom(sockfd,tmpbuff,sizeof(tmpbuff),0,NULL,NULL);
            if(size_recv==-1)
            {
                perror("failed to recvfrom");
                return -1;
            }
            if(!strcmp(tmpbuff,".quit"))
            {
                
                break;
            }
            printf("RECV:%s\n",tmpbuff);
        }
        kill(pid,SIGKILL);
         
    }
    close(sockfd);
    return 0;

}

recv.c

#include "../head.h"
int main()
{
    pid_t pid;
    struct sockaddr_in sendaddr;
    struct sockaddr_in recvaddr;
    size_t size_send;
    size_t size_recv;
    char tmpbuff[100]={0};
    socklen_t addrlen=sizeof(sendaddr);
    int ret=0;
    int sockfd=0;
    sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd==-1)
    {
        perror("failed to socket");
        return -1;
    }
    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;
    }
//第一次接收是为了建立连接，数据不打印
    size_recv = recvfrom(sockfd,tmpbuff,sizeof(tmpbuff),0,(struct sockaddr *)&sendaddr,&addrlen);
   
    if(size_recv==-1)
    {
        perror("failed to recvfrom");
        return -1;
    }

    pid=fork();
    if(pid==-1)
    {
        perror("failed to fork");
        return -1;
    }
    if(pid==0)
    {
        while(1)
        {
             memset(tmpbuff,0,sizeof(tmpbuff));
               size_recv = recvfrom(sockfd,tmpbuff,sizeof(tmpbuff),0,NULL,NULL);
             
            if(size_recv==-1)
            {
                perror("failed to sendto");
                return -1;
            }
            
            if(!strcmp(tmpbuff,".quit"))
            {
                
                break;
            }
            printf("RECV:%s\n",tmpbuff);
        }
     kill(getppid(),SIGKILL);
        
    }
    else if(pid>0)
    {
        while (1)
        {
            memset(tmpbuff,0,sizeof(tmpbuff));
            fgets(tmpbuff,sizeof(tmpbuff),stdin);
            tmpbuff[strlen(tmpbuff)-1]='\0';
            size_send=sendto(sockfd,tmpbuff,strlen(tmpbuff),0,(struct sockaddr *)&sendaddr,sizeof(sendaddr));
            if(size_send==-1)
            {
                perror("failed to sendto");
                return -1;
            }
            if(!strcmp(tmpbuff,".quit"))
            {
              
                break;
            }
           
        }
          kill(pid,SIGKILL);
        
    }
    close(sockfd);
    return 0;


}

2.(线程实现)

send.c

#include "../head.h"

int sockfd = 0;
pthread_t tid1;
pthread_t tid2;
struct sockaddr_in recvaddr;

void *thread1(void *arg)
{
    char tmpbuff[1024] = {0};
    ssize_t nsize = 0;

    while (1)
    {
        memset(tmpbuff, 0, sizeof(tmpbuff));
        fgets(tmpbuff, sizeof(tmpbuff), stdin);
        tmpbuff[strlen(tmpbuff)-1] = '\0';
        
        nsize = sendto(sockfd, tmpbuff, strlen(tmpbuff), 0, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
        if (-1 == nsize)
        {
            perror("fail to sendto");
            return NULL;
        }

        if (!strcmp(tmpbuff, ".quit"))
        {
            break;
        }
    }
    pthread_cancel(tid2);

    return NULL;
}

void *thread2(void *arg)
{  
    char tmpbuff[1024] = {0};
    ssize_t nsize = 0;

    while (1)
    {
        memset(tmpbuff, 0, sizeof(tmpbuff));
        nsize = recvfrom(sockfd, tmpbuff, sizeof(tmpbuff), 0, NULL, NULL);
        if (-1 == nsize)
        {
            perror("fail to recvfrom");
            return NULL;
        }

        if (!strcmp(tmpbuff, ".quit"))
        {
            break;
        }
        
        printf("RECV:%s\n", tmpbuff);
    }
    pthread_cancel(tid1);

    return NULL;
}

int main(void)
{
    //1.创建套接字
    char tmpbuff[1024] = {"hello"};
    ssize_t nsize = 0;

    recvaddr.sin_family = AF_INET;
    recvaddr.sin_port = htons(RECV_PORT);
    recvaddr.sin_addr.s_addr = inet_addr(RECV_IP);

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (-1 == sockfd)
    {
        perror("fail to socket");
        return -1;
    }

    //2.发送一次
    nsize = sendto(sockfd, tmpbuff, strlen(tmpbuff), 0, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (-1 == nsize)
    {
        perror("fail to sendto");
        return -1;
    }

    //3.创建两个线程
    pthread_create(&tid1, NULL, thread1, NULL);
    pthread_create(&tid2, NULL, thread2, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    close(sockfd);

    return 0;
}

recv.c

#include "../head.h"

int sockfd = 0;
pthread_t tid1;
pthread_t tid2;
struct sockaddr_in recvaddr;
struct sockaddr_in sendaddr;

void *thread1(void *arg)
{
    char tmpbuff[1024] = {0};
    ssize_t nsize = 0;

    while (1)
    {
        memset(tmpbuff, 0, sizeof(tmpbuff));
        fgets(tmpbuff, sizeof(tmpbuff), stdin);
        tmpbuff[strlen(tmpbuff)-1] = '\0';
        
        nsize = sendto(sockfd, tmpbuff, strlen(tmpbuff), 0, (struct sockaddr *)&sendaddr, sizeof(sendaddr));
        if (-1 == nsize)
        {
            perror("fail to sendto");
            return NULL;
        }

        if (!strcmp(tmpbuff, ".quit"))
        {
            break;
        }
    }
    pthread_cancel(tid2);

    return NULL;
}

void *thread2(void *arg)
{  
    char tmpbuff[1024] = {0};
    ssize_t nsize = 0;

    while (1)
    {
        memset(tmpbuff, 0, sizeof(tmpbuff));
        nsize = recvfrom(sockfd, tmpbuff, sizeof(tmpbuff), 0, NULL, NULL);
        if (-1 == nsize)
        {
            perror("fail to recvfrom");
            return NULL;
        }

        if (!strcmp(tmpbuff, ".quit"))
        {
            break;
        }
        
        printf("RECV:%s\n", tmpbuff);
    }
    pthread_cancel(tid1);

    return NULL;
}

int main(void)
{
    //1.创建套接字
    char tmpbuff[1024] = {"hello"};
    ssize_t nsize = 0;
    int ret = 0;
    socklen_t addrlen = sizeof(sendaddr);

    recvaddr.sin_family = AF_INET;
    recvaddr.sin_port = htons(RECV_PORT);
    recvaddr.sin_addr.s_addr = inet_addr(RECV_IP);

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (-1 == sockfd)
    {
        perror("fail to socket");
        return -1;
    }

    ret = bind(sockfd, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (-1 == ret)
    {
        perror("fail to bind");
        return -1;
    }

    //2.接收一次
    nsize = recvfrom(sockfd, tmpbuff, sizeof(tmpbuff), 0, (struct sockaddr *)&sendaddr, &addrlen);
    if (-1 == nsize)
    {
        perror("fail to recvfrom");
        return -1;
    }

    //3.创建两个线程
    pthread_create(&tid1, NULL, thread1, NULL);
    pthread_create(&tid2, NULL, thread2, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    close(sockfd);

    return 0;
}

⊙^⊙
关注
  • 20
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OSI及TCP/IP的概念和区别
lingshengxiyou的博客
08-15 1736
TCP/IP协议(Transfer Controln Protocol/Internet Protocol)叫做传输控制/网际协议，又叫网络通讯协议，这个协议是Internet国际互联网络的基础。TCP/IP是网络中使用的基本的通信协议。虽然从名字上看TCP/IP包括两个协议，传输控制协议(TCP)和网际协议(IP)，但TCP/IP实际上 是一组协议，它包括上百个各种功能的协议，如：远程登录、文件传输和电子邮件等，而TCP协议和IP协议是保证数据完整传输的两个基本的重要协议。......
TCP/IP协议与OSI协议详解
m0_70888041的博客
10-31 1799
TCP/IP四层模型TCP/IP是一组协议的代名词，它还包括许多协议，组成了TCP/IP协议簇。TCP/IP协议簇分为四层，IP位于协议簇的第二层(对应OSI的第三层)，TCP位于协议簇的第三层(对应OSI的第四层)TCP/IP通讯协议采用了4层的层级结构，每一层都呼叫它的下一层所提供的网络来完成自己的需求。这4层分别为：应用层：应用程序间沟通的层，如简单电子邮件传输（SMTP）、文件传输协议（FTP）、网络远程访问协议（Telnet）等。 传输层：在此层中，它提供了节点间的数据传送服务，如传输控制协议（T
计算机网络基础：OSI模型与TCP/IP协议的关系
weixin_43263566的博客
11-14 2339
OSI与TCP-IP5层协议
计算机网络 —— OSI参考模型与TCP/IP
聚集机器学习、信息安全
12-16 4661
OSI参考模型与TCP/IP是计算机网络的基础，本文结合实例详细介绍了两者的概念与联系。
OSI与TCP/IP模型
Tianyueeiyang的博客
07-03 1460
OSI参考模型与TCP/IP模型都采用了分层体系结构，将庞大而复杂的问题转化为着干个较小且易于处理的子问题。不同的是OSl参考模型划分7层，分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层，而TCP/IP参考模型最多划分了5个层次，分别是物理层，数据链路层、网络层、传输层和应用层，将OSI参考模型中的高三层合并为一层统称应用层。在层次结构上，两者都采用了分层体系结构，但是TCP/IP参考模型比OSI参考模型更简化。
【网络编程】TCP/IP协议（互联网的基石）
qq_64928278的博客
09-04 3661
TCP/IP协议可以被视为互联网的基石。它是互联网通信的核心协议套件，负责实现不同计算机和网络之间的通信和数据交换。包括“三次握手”的介绍，以及层次结构，详细组成等方面的详细介绍！
OSI与TCP/IP的协议
asdfg___xiaobai的博客
09-02 1053
应用层、表示层、会话层为高三层，是面向用户的 网络层、数据链路层、物理层为低三层，是面向用户的 网络层，数据链路层，物理层为低三层，是面向硬件的 网络层及以下的通信为点到通信（主机与主机） 传输层的通信为端到端（端口到端口） ...
【TCP/IP】TCP/IP 四层分别有哪些协议|OSI四层/五层/七层协议
小鱼菜鸟的博客
07-22 7387
五层协议模型 应用层：http dns TFTP 、Telnet 、FTP、SMTP、NFS、Rlogin、 SNMP(UDP)…… 传输层：TCP、UDP 网络层： ICMP(ping tracerute) RIP(路由协议使用UDP) 数据链路层：ARP、RARP、ppp 物理层：比特流 运行于TCP协议之上的协议： HTTP协议：超文本传输...
OSI和TCP/IP模型简述
weixin_52159400的博客
01-23 3273
TCP/IP协议不仅包含TCP和IP协议。还包括了SLIP协议、ICMP协议、FTP协议、SMTP协议、UDP协议等。这些协议构成了TCP/IP协议簇。主要协议有Telent、FTP、SMTP等。网络接口层：主要协议有ARP、RARP，主要功能是提供链路管理错误检测、对不同通信媒介有关信息细节问题进行有效处理等。，是使用者使用平台和计算机信息网内部数据结合的通道，可以实现数据传输与数据共享。与传统的OSI对应的7层网络模型不同，TCP/IP协议将网络模型划分为四层。网际层：主要协议有ICMP、
Linux系统编程（14）UDP全双工通信和TCP半双工通信
weixin_68239724的博客
08-22 948
listen函数将创建的socket套接字设置为监听模式后，创建一个序列用来存储请求连接的设备，accept函数每次将第一个在队列中的请求进行处理后产生一个用来通信的和客户端建立连接的新的套接字 ，用来负责后续的通信。如果有更多的连接请求到达，新的连接可能会被拒绝或未处理，直到队列中有空闲位置。由于TCP面向连接和可靠性高的特性，因此，在使用TCP协议通信时，需要在客户端和服务端之间先建立连接才能进行数据通信。: 指定缓冲区的大小，即要接收的数据的最大字节数。结构体的指针，包含要绑定到的地址信息。
TCP/UDP的对比，粘包分包抓包，http协议
xgshxjhs_的博客
08-23 1174
当我们在浏览器输入一个网址，此时浏览器就会给对应的服务器发送一个 HTTP 请求，对应的服务器收到这个请求之后，经过计算处理，就会返回一个 HTTP 响应。注意： 当我们访问一些网页时，是显示通过 HTTPS 来进行通信的，并且当下大多数的网页都是通过 HTTPS 来进行通信的，因为 HTTPS 在 HTTP 的基础上做了一个加密的工作。协议： 为了使数据在网络上从源头到达目的，网络通信的参与方必须遵循相同的规则，这套规则称为协议，它最终体现为在网络上传输的数据包的格式。（2）指定要发送的数据的长度。
【嵌入式开发之网络编程】TCP并发实现
最新发布
boy_ding_jian的博客
08-26 249
在实例中，经常会存在多个客户端向服务端发送连接请求和传递数据的情况，为了解决这个问题，我们需要利用或者来实现并发。
网络通信编程UDP/TCP
lijiaweixx的博客
08-22 794
客户端向服务器发送 “我要和你断开连接” 的请求，服务器回复 “好的，可以断开”，服务器再发送 “我也要断开” 的请求，客户端最后回复 “好”，完成四次挥手断开连接。：客户端向服务器发送 “我要和你建立连接” 的请求，服务器回复 “好的，可以建立连接”，客户端再回复 “好”，完成三次握手建立连接。函数：从指定的套接字接收数据，并保存发送方的地址信息。接听客户端的连接请求（这一步完成后连接就建立好了，可以收发数据）。：主要针对服务器程序，绑定的是服务器所在电脑的 IP 地址。监听客户端的连接请求，使用。
嵌入式学习（网络通信UDP\TCP）
weixin_68103035的博客
08-22 1156
TCP：面向连接的协议。在数据传输前，必须先建立一条从源到目的地的可靠连接。双方通过“三次握手”过程协商连接参数，建立连接后才能进行数据传输。数据传输结束后，通过“四次挥手”断开连接。UDP：无连接的协议。无需事先建立连接，发送方可以直接向接收方发送数据报文。每个数据报文独立传输，相互之间没有直接关联。在网络通信中，不同端对应的任务和作用也不一样。1，创建一个用于通信的套接字（fd）2，连接服务器：需要指定连接的服务器的IP 和 端口3，建立连接成功，客户端和服务器建立连接通道1>可以发送数据。
TCP、UDP
2301_80338792的博客
08-22 523
服务器端：socket --->bind ----> recvfrom //保存了客户端的地址 srcaddr----> sprintf ---->sendto // srcaddr。客户端：socket --- > //fgets（实现多次通信）----> sendto ----> recvfrom ---->printf。-----好 ---------------->-----好 ----------------><----我也要断开----------每一个应用程序进程有一个端口号，
Instagram被封了？IP禁令与解决方法
IPFoxy666的博客
08-21 370
通过了解禁令背后的原因、采取必要的步骤解决禁令并遵循 Instagram 的指南，您可以重新获得平台访问权限并继续享受它而不会受到干扰。如果想在同一设备网络下同时运营多个Instagram账号，那么应该每个账号区分不同的IP网络，避免产生关联而被限制，经典的一机一号一IP，也可以借助代理IP与指纹浏览器/云手机等多开工具的集成。Instagram 制定了严格的指导方针，以确保为用户提供安全且有吸引力的环境，任何违反这些指导方针的行为都可能导致IP被屏蔽。Instagram 上的IP禁令。
C#使用 ModeBusTCP读取汇川Easy521PLC
weixin_67244432的博客
08-22 439
Modbus TCP是一种基于以太网TCP/IP的Modbus协议变种，它允许Modbus协议在以太网网络上运行，使得设备之间可以通过IP网络交换数据。00 00->协议标识符，Modbus TCP协议标识符为0x0000。0x06 写单个保持寄存器。0x10 写多个保持寄存器。00 06->报文长度，表示后面的报文长度为6个字节。0x03 读保持寄存器。0x0F 写多个线圈。03->功能码 0x01 读输出线圈。/* 00 01->事务标识符，随意指定。
TCP/UCP
m0_69699758的博客
08-23 418
Loop本地回环 定义：Loop本地回环通常指的是以127开头的IP地址段（127.0.0.1 – 127.255.255.254），其中127.0.0.1是最常用的地址，被称为本地回环地址（Loop back address）。 特点：不属于任何有类别地址类，代表设备的本地虚拟接口，默认被看作是不会宕掉的接口。 主要作用： 测试本机的网络配置：通过ping 127.0.0.1检查本机网卡和IP协议安装是否正常。 应用程序的资源调用：在SERVER/CLIENT程序中，当在同一台机器上运行且没有
【网络编程】第十章 网络层-IP（分片组装+网段+路由+NAT）
YQ20210216的博客
08-22 1260
将目的ip和路由表中子网掩码"按位与"之后得到网络地址，再和Destination比较，两者相等代表当前ip就是需要通过该项路由，此时通过Iface接口发出去，如果和Destination不相等，则继续与下一个子网掩码比较，以此类推，最后由default 默认路由发送出去。传输层一次向下交付的数据太多了会导致分片，数据链路层不支持过大的数据，这就需要在发送方网络层对数据进行分片，分片后的每片都有独立ip，分片会提高丢包的概率，影响传输速率。局域网中主机的私有IP 和 外网当中的某个公网IP之间的映射关系。
详解计算机网络基础：OSI与TCP/IP分层及协议
其中IP负责网络层功能，它是无连接的，而TCP提供可靠的传输服务，是基于IP协议的。 - IP协议的主要作用： - 分配网络地址：为每个网络分配一个全球唯一的网络号，为每个节点分配一个32位的IP地址。 - 路由选择：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值