嵌入式学习——网络编程（TCP）——day31

已于 2024-06-15 16:46:33 修改
阅读量1.1k 收藏 17
点赞数 9
文章标签： 网络 学习 tcp/ip c语言 开发语言 笔记
于 2024-06-03 23:02:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47798402/article/details/139426281
版权

1. TCP和UDP的区别

        TCP（Transmission Control Protocol，传输控制协议）

        UDP（User Datagram Protocol，用户数据报协议）

1.1 连接方式

  • TCP 是面向连接的协议，它在数据传输前需要通过三次握手建立一个可靠的连接，确保双方都准备好进行通信，并维护连接状态直到连接被明确关闭（四次挥手）。
  • UDP 是无连接的协议，它不建立正式的连接就可以直接发送数据包。发送端和接收端之间没有事先的握手过程，每个数据报都是独立发送的。

1.2 可靠性

  • TCP 提供可靠的数据传输服务，确保数据包按序、无损地到达接收端。它通过序列号、确认应答、错误检测、重传机制和流量控制来保证数据的可靠性和顺序。
  • UDP 不提供这些保障，数据包可能丢失、重复或乱序到达，适用于对实时性要求高于数据完整性的应用。

1.3 速度与效率

  • TCP 因其额外的控制信息和确认过程，相比UDP来说，传输效率较低，但提供了更高的可靠性。
  • UDP 由于其简单、无连接的特性，传输速度快，延迟低，适合实时应用。

1.4 数据包处理

  • TCP 将数据视为字节流，可以拆分和重组数据包，适合传输大量或连续的数据。
  • UDP 保留了数据报的边界，作为独立的数据单元传输，适合一次性传输小块或具有明确界限的数据。

1.5 应用场景

  • TCP 适用于需要高度可靠传输的应用，如Web浏览、电子邮件、文件传输（FTP）等。
  • UDP 适用于实时性要求高、可以容忍一定数据丢失的应用，如在线游戏、语音通话、视频流、DNS查询等。

1.6 资源消耗与复杂性

  • TCP 需要更多的系统资源来维护连接状态和执行复杂的错误恢复机制。
  • UDP 相对轻量，对系统资源的需求较少，程序实现也更为简单

2. TCP接口函数

2.1 socket

        socket(AF_INET, SOCK_STREAM, 0);

2.2 connect

          int connect(int sockfd, const struct sockaddr *addr,
                   socklen_t addrlen);
          功能:
            向接收端发送三次握手链接请求
          参数:
            sockfd:文件描述符
            addr:接收方地址空间首地址
            addrlen:接收方地址的大小
          返回值:
            成功返回0 
            失败返回-1 

2.3 send （发的太块会阻塞）

          ssize_t send(int sockfd, const void *buf, size_t len, int flags);
          功能:
            发送数据
          参数:
            sockfd:文件描述符
            buf:存放数据空间首地址
            len:发送数据长度
            flags:属性 默认为0 
          返回值:
            成功返回发送字节数
            失败返回-1 

2.4 recv

          ssize_t recv(int sockfd, void *buf, size_t len, int flags);
          功能:
            接收数据
          参数:
            sockfd:文件描述符
            buf:存放数据空间首地址 
            len:最多接收数据大小
            flags:属性 默认为0 
          返回值：
            成功返回实际接收字节数
            失败返回-1 
            对方关闭套接字返回0 

2.5 listen

          int listen(int sockfd, int backlog);
          功能:
            监听链接请求
          参数:
            sockfd:文件描述符
            backlog:允许最多等待链接的个数
          返回值:
            成功返回0 
            失败返回-1 

2.6 accept（返回通信套接字）

          int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
          功能:
            处理等待队列中第一个链接
          参数:
            sockfd:文件描述符 
            addr:存放链接对方地址信息空间首地址
            addrlen:想要接收地址大小变量空间首地址
          返回值:
            成功返回与发送端建立的新文件描述符（通信套接字）
            失败返回-1 
2.7 inet_addr

      in_addr_t inet_addr(const char *cp);
      功能:
        将字符串IP地址转换为二进制IP地址 
      参数:
        cp:字符串IP地址空间首地址
      返回值:
        成功返回二进制IP地址

2.8 htons

      uint16_t htons(uint16_t hostshort);
      功能:
        将本地字节序（小端）转换为网络字节序（大端）
      参数:
        hostshort:本地端口号
      返回值:
        返回网络字节序端口号
        
      uint16_t ntohs(uint16_t netshort);
      功能:
        将网络字节序（大端）转换为本地字节序（小端）

2.9 bind 

      int bind(int sockfd, const struct sockaddr *addr,
                socklen_t addrlen);
      功能:
        将套接字与IP地址端口绑定在一起
      参数:
        sockfd:文件描述符 
        addr:结构体空间首地址 
        addrlen:信息的长度
      返回值:
        成功返回0 
        失败返回-1 

2.10 示例程序

（1）TCP单向通信

        1. 头文件

#ifndef _HEAD_H_
#define _HEAD_H_

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> 
#include <arpa/inet.h>
#include <time.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>

#endif

        2. makefile

all:send recv

send:send.c
	gcc $^ -o $@
recv:recv.c
	gcc $^ -o $@

        3. recv.c

#include "head.h"

int main(int argc, char const *argv[])
{
    int confd = 0;
    int listfd = 0;
    int ret_connect = 0;
    int ret_bind = 0;
    int ret_listen = 0;
    struct sockaddr_in recvaddr;
    struct sockaddr_in sendaddr;
    socklen_t addrlen = sizeof(sendaddr);
    ssize_t ret_send = 0;
    ssize_t ret_recv = 0;

    listfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listfd)
    {
        perror("socket error!\n");
        return -1;
    }

    bzero(&recvaddr,sizeof(recvaddr));
    bzero(&sendaddr,sizeof(sendaddr));

    recvaddr.sin_family = AF_INET;
    recvaddr.sin_port = htons(50000);
    recvaddr.sin_addr.s_addr = inet_addr("192.168.0.109");

    ret_bind = bind(listfd, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (-1 == ret_bind)
    {
        perror("bind error!\n");
        return -1;
    }

    ret_listen = listen(listfd, 3);
    if (-1 == ret_listen)
    {
        perror("listen error!\n");
        return -1;     
    }

    confd = accept(listfd, (struct sockaddr *)&sendaddr, &addrlen);
    if (-1 == confd)
    {
        perror("accept error!\n");
        return -1;  
    }

    while (1)
    {
        char buf[256] = {0};
 
        ret_recv = recv(confd, buf, sizeof(buf), 0);
        if (ret_recv <= 0)
        {
            break;
        }

        time_t tm;
        time(&tm);
        sprintf(buf, "%s %s", buf, ctime(&tm));

        ret_send = send(confd, buf, strlen(buf), 0);
        if (-1 == ret_send)
        {
            perror("send error!\n");
            return -1;        
        } 
    }
    
    close(confd);
    close(listfd);

    return 0;
}

        4. send.c

#include "head.h"

int main(int argc, char const *argv[])
{
    int confd = 0;
    int ret_connect = 0;
    struct sockaddr_in recvaddr;
    socklen_t addrlen = 0;
    ssize_t ret_send = 0;
    ssize_t ret_recv = 0;

    confd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == confd)
    {
        perror("socket error!\n");
        return -1;
    }

    bzero(&recvaddr, sizeof(recvaddr));

    recvaddr.sin_family = AF_INET;
    recvaddr.sin_port = htons(50000);
    recvaddr.sin_addr.s_addr = inet_addr("192.168.0.109");

    ret_connect = connect(confd, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (-1 == ret_connect)
    {
        perror("connect error!\n");
        return -1;        
    }

    while (1)
    {
        char buf[256] = {"supercarrydoinb"};
        ret_send = send(confd, buf, strlen(buf), 0);
        if (-1 == ret_connect)
        {
            perror("send error!\n");
            return -1;        
        }  
        ret_recv = recv(confd, buf, sizeof(buf), 0);
        if (ret_recv <= 0)
        {
            break;
        }

        printf("%s", buf);
        sleep(1);
    }
    
    close(confd);

    return 0;
}

(2) TCP实现多线程双机聊天（chat）——注意：！！线程编译gcc要加后缀 -lpthread

        1. 头文件

#ifndef _HEAD_H_
#define _HEAD_H_

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> 
#include <arpa/inet.h>
#include <time.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>

#endif

        2. makefile

all:send recv

send:send.c
	gcc $^ -o $@ -lpthread
recv:recv.c
	gcc $^ -o $@ -lpthread

        3. send.c

#include "head.h"

struct sockaddr_in sendaddr;
struct sockaddr_in recvaddr;

void *th1(void *arg)
{
    int confd = *(int *)arg;
    ssize_t ret_recv = 0;
    while (1)
    {
        char buf[256] = {0};
        ret_recv = recv(confd, buf, sizeof(buf), 0);
        if (-1 == ret_recv)
        {
            perror("recv error!\n");
        }
        printf("from recv: %s\n", buf);
    }
}

void *th2(void *arg)
{
    int confd = *(int *)arg;
    ssize_t ret_send = 0;
    while (1)
    {
        printf("to recv:");
        char buf[256] = {0};
        fgets(buf, sizeof(buf), stdin);
        buf[strlen(buf)-1] = '\0';
        ret_send= send(confd, buf, strlen(buf), 0);
        if (-1 == ret_send)
        {
            perror("send error!\n");
        }
    }
}

int main(int argc, char const *argv[])
{
    int confd = 0;
    int ret_connect = 0;
    socklen_t addrlen = sizeof(sendaddr);
    ssize_t ret_recv = 0;
    ssize_t ret_send = 0;
    pthread_t tid1;
    pthread_t tid2;
    char buf[256] = {0};

    confd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == confd)
    {
        perror("socket error!\n");
        return -1;
    }

    bzero(&recvaddr, sizeof(recvaddr));
    bzero(&sendaddr, sizeof(sendaddr));

    recvaddr.sin_family = AF_INET;
    recvaddr.sin_port = htons(50000);
    recvaddr.sin_addr.s_addr = inet_addr("192.168.0.109");

    ret_connect = connect(confd, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (-1 == ret_connect)
    {
        perror("connect error!\n");
        return -1;
    }
    
#if 0
    ret_recv = recv(confd, buf, sizeof(buf), 0);
    if (-1 == ret_recv)
    {
        perror("recv error!\n");
        return -1;
    }
#endif

    pthread_create(&tid1, NULL, th1, &confd);
    pthread_create(&tid2, NULL, th2, &confd);

    pthread_join(tid1, NULL);
    pthread_join(tid1, NULL);
    
    return 0;
}

        4. recv.c

#include "head.h"

struct sockaddr_in sendaddr;
struct sockaddr_in recvaddr;

void *th1(void *arg)
{
    int confd = *(int *)arg;
    ssize_t ret_recv = 0;
    while (1)
    {
        char buf[256] = {0};
        ret_recv = recv(confd, buf, sizeof(buf), 0);
        if (-1 == ret_recv)
        {
            perror("recv error!\n");
        }
        printf("from send: %s\n", buf);
    }
}

void *th2(void *arg)
{
    int confd = *(int *)arg;
    ssize_t ret_send = 0;
    while (1)
    {
        printf("to send:");
        char buf[256] = {0};
        fgets(buf, sizeof(buf), stdin);
        buf[strlen(buf)-1] = '\0';
        ret_send = send(confd, buf, strlen(buf), 0);
        if (-1 == ret_send)
        {
            perror("send error!\n");
        }
    }
}

int main(int argc, char const *argv[])
{
    int listfd = 0;
    int confd = 0;
    int ret_bind = 0;
    int ret_listen = 0;
    socklen_t addrlen = sizeof(sendaddr);
    ssize_t ret_recv = 0;
    ssize_t ret_send = 0;
    pthread_t tid1;
    pthread_t tid2;
    char buf[256] = {0};

    listfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listfd)
    {
        perror("socket error!\n");
        return -1;
    }

    bzero(&recvaddr, sizeof(recvaddr));
    bzero(&sendaddr, sizeof(sendaddr));

    recvaddr.sin_family = AF_INET;
    recvaddr.sin_port = htons(50000);
    recvaddr.sin_addr.s_addr = inet_addr("192.168.0.109");

    ret_bind = bind(listfd, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (-1 == ret_bind)
    {
        perror("bind error!\n");
        return -1;
    }

    ret_listen = listen(listfd, 3);
    if (-1 == ret_listen)
    {
        perror("listen error!\n");
        return -1;        
    }

    confd = accept(listfd, (struct sockaddr *)&sendaddr, &addrlen);
    if (-1 == confd)
    {
        perror("accept error!\n");
        return -1;         
    }
    
#if 0
    ret_recv = recv(confd, buf, sizeof(buf), 0);
    if (-1 == ret_recv)
    {
        perror("recv error!\n");
        return -1;
    }
#endif

    pthread_create(&tid1, NULL, th1, &confd);
    pthread_create(&tid2, NULL, th2, &confd);

    pthread_join(tid1, NULL);
    pthread_join(tid1, NULL);
    
    return 0;
}

(3) TCP实现文件的传输（结构体）

        1. 头文件

#ifndef _HEAD_H_
#define _HEAD_H_

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> 
#include <arpa/inet.h>
#include <time.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>

#endif

        2. makefile

all:send recv

send:send.c
	gcc $^ -o $@ -lpthread
recv:recv.c
	gcc $^ -o $@ -lpthread

        3. send.c

#include "head.h"

typedef struct 
{
    char buf[1024];
    char filename[32];
    int rd_ret;
    int total;
}MSG;

int main(int argc, char const *argv[])
{
    int ret_connect = 0;
    int ret_stat = 0;
    int confd = 0;
    int openfd = 0;
    ssize_t ret_recv = 0;
    ssize_t ret_send = 0;
    struct sockaddr_in recvaddr;
    MSG msg;
    struct stat st;

    confd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == confd)
    {
        perror("socket error!\n");
        return -1;
    }

    bzero(&recvaddr, sizeof(recvaddr));
    bzero(&msg, sizeof(msg));

    recvaddr.sin_family = AF_INET;
    recvaddr.sin_port = htons(50000);
    recvaddr.sin_addr.s_addr = inet_addr("192.168.0.109");

    ret_connect = connect(confd, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (-1 == ret_connect)
    {
        perror("connetc error!\n");
        return -1;
    }

    openfd = open("./1.png", O_RDONLY);
    if (-1 == openfd)
    {
        perror("open error!\n");
        return -1;
    }

    strcpy(msg.filename, "2.png");

    ret_stat = stat("./1.png", &st);
    if (-1 == ret_stat)
    {
        perror("stat error!\n");
        return -1;
    }
    msg.total = st.st_size;

    while (1)
    {
        bzero(msg.buf, sizeof(msg.buf));

        msg.rd_ret = read(openfd, msg.buf, sizeof(msg.buf));
        send(confd, &msg, sizeof(msg), 0);
        if (msg.rd_ret <= 0)
        {
            break;
        }
        char buf[256] = {0};
        ret_recv = recv(confd, buf, sizeof(buf), 0);
        if (ret_recv <= 0)
        {
            break;
        }
        usleep(1000 * 200);
    }

    close(confd);
    close(openfd);

    return 0;
}

        4. recv.c

#include "head.h"

typedef struct 
{
    char buf[1024];
    char filename[32];
    int rd_ret;
    int total;
}MSG;

int main(int argc, char const *argv[])
{
    int listfd = 0;
    int ret_bind = 0;
    int ret_listen = 0;
    int confd = 0;
    ssize_t ret_recv = 0;
    ssize_t ret_send = 0;
    struct sockaddr_in recvaddr;
    struct sockaddr_in sendaddr;
    socklen_t addrlen = sizeof(sendaddr);
    MSG msg;

    listfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listfd)
    {
        perror("socket error!\n");
        return -1;
    }

    bzero(&recvaddr, sizeof(recvaddr));
    bzero(&sendaddr, sizeof(sendaddr));
    bzero(&msg, sizeof(msg));

    recvaddr.sin_family = AF_INET;
    recvaddr.sin_port = htons(50000);
    recvaddr.sin_addr.s_addr = inet_addr("192.168.0.109");

    ret_bind = bind(listfd, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (-1 == ret_bind)
    {
        perror("bind error!\n");
        return -1;
    }


    ret_listen = listen(listfd, 3);
    if (-1 == ret_listen)
    {
        perror("listen error!\n");
        return -1;
    }

    confd = accept(listfd, (struct sockaddr *)&sendaddr, &addrlen);
    if (-1 == confd)
    {
        perror("accept error!\n");
        return -1;
    }

    int openfd = 0;
    int flag = 0;
    int total = 0;
    int current_size = 0;
    while (1)
    {
        ret_recv = recv(confd, &msg, sizeof(msg), 0);
        if (ret_recv <= 0)
        {
            break;
        }

        if (0 == msg.rd_ret)
        {
            printf("file upload end\n");
            return -1;
        }

        if (0 == flag)//拿到文件总大小
        {
            openfd = open(msg.filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
            if (-1 == openfd)
            {
                perror("open error!\n");
                return -1;
            }

            flag = 1;
            total = msg.total;
        }

        write(openfd, msg.buf, msg.rd_ret);
        current_size += msg.rd_ret;
        printf("%d / %d\n", current_size, total);
        char buf[256] = "go on";
        send(confd, buf, strlen(buf), 0);
    }

    close(confd);
    close(openfd);
    close(listfd);

    return 0;
}

Summit-
关注
  • 9
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
嵌入式linux同步网络时间和获取当前时间
吻等离子的博客
11-11 1565
cn.pool.ntp.org 中国开源免费NTP服务器。time1.aliyun.com 阿里云NTP服务器。time2.aliyun.com 阿里云NTP服务器。ntp1.aliyun.com 阿里云NTP服务器。ntp2.aliyun.com 阿里云NTP服务器。time1.google.com 谷歌NTP服务器。time2.google.com 谷歌NTP服务器。time3.google.com 谷歌NTP服务器。time4.google.com 谷歌NTP服务器。
嵌入式系统——基础知识.doc
01-09
嵌入式系统基础知识 嵌入式系统是指将计算机系统集成到微型电子设备中的系统，具有微型化、实时性、高可靠性、易移植性等特点。嵌入式系统的核心是一个只有几 KB 到几十 KB 的微内核，通常把嵌入式系统概念的重心...
【2024提前批/秋招笔试汇总2】——大疆-嵌入式软件-2023.08.06
Sunny_Coder的博客
11-11 664
A.GPU无法使用共享内存结构，提高通信速度B.GPU的并行数据处理可以大幅度提高运算能力C.GPU使用高速全局内存可以进一步提升运算速度D.GPU的计算能力比CPU强A.epoll相比于poll会随着fd的数目增长而降低效率B.边缘触融发模式（Edge Trigger）模式是epoll缺省的工作方式C.epoll工作在水平触发模式时如果用户不进行任何操作，该事件并不会丢失D.在大规模并发服务器场景中需要监听多个socket的时候，选择select比epoll高效。
arm嵌入式学习——学习总结整理.pdf
11-13
嵌入式系统的学习不仅涉及硬件平台的选择和配置，还涵盖了软件开发的全过程，包括编程语言、操作系统、算法和数据结构等多方面知识。随着物联网和人工智能的快速发展，深入理解和掌握ARM嵌入式系统技术将对个人的...
嵌入式培训经验分享——网络编程项目实战（在线电子词典）
09-05
在线电子词典采用服务器+客户端模式，运用TCP协议通信，，服务器端直接连接数据库。 1、服务器实现 功能 注册设计:如果用户没有注册,必须注册才能提供服务―包括修改用户名密码 （1）判断用户名有没有注册，如果有...
从CPU芯片到嵌入式产品——“板+底板”的合作模式
01-20
随着自动化数字化的时代来临，嵌入式产品越来越受到大家的欢迎。从身边的电脑手机等消费类电子产品，到医院的医疗设备，工厂的控制设备，甚至是卫星和宇宙飞船上的电子设备，嵌入式产品无处不在，它们已经和我们的...
如何自学嵌入式——嵌入式学习路线
07-18
嵌入式学习路线 一般的应用开发，例如桌面应用的开发，移动应用的开发，通常都是在一个IDE集成开发环境中完成。 开发者，熟悉了IDE的使用，熟悉了相关应用编程接口API，就能开发应用了。不需要关心系统本身的太多...
hmallox勒索病毒科普：了解其威胁与防御策略
safe130_的博客
07-14 966
halo，.360，.faust，.2700, .eking，elbie, .wis，.mkp，.malox，.rmallox，.mallox，.hmallox, .anony, .ma1x0，.live，.carver，.locked，_locked，.locked1，.svh , lockbit, .src, .secret , .datah, .BEAST,.DevicData-P, .kat6.l6st6r 等等，：用户从非官方或不受信任的源下载软件时，可能会无意中安装带有勒索病毒的软件包。
AI基于大模型语言存在的网络安全风险
yh
07-16 288
AI网络安全
【windows|014】TCP协议详解
小鹏linux的博客
07-15 1147
TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议。它工作在OSI模型的第四层，即传输层，为用户提供可靠的、有序的和无差错的数据传输服务。TCP协议与UDP协议是传输层的两大主要协议，但两者在设计上有明显的不同：TCP提供的是可靠的数据传输服务，而UDP则更注重传输的速度和效率
智能车存在网络安全隐患，如何应设计出更好的安全防护技术？
tigerman20201的博客
07-13 305
然而，高度的网络化和智能化也使智能车面临着严峻的网络安全挑战，如远程攻击、数据泄露和恶意控制等。未来，随着技术的不断发展，应持续加强对智能车网络安全的研究和创新，以应对不断变化的安全威胁。摘要：随着智能车技术的迅速发展，车辆的网络连接性不断增强，然而这也带来了诸多网络安全隐患。本文深入探讨了智能车面临的网络安全威胁，并提出了一系列创新的安全防护技术设计，旨在为智能车的安全运行提供更可靠的保障。黑客可以通过公共网络对智能车的通信系统进行攻击，干扰车辆的正常运行，甚至获取车辆的控制权。
RIP路由协议概述
张海涛的专栏
07-12 258
若该条路由在被记为16跳后，120s内还没有收到更新，则将这条路由从路由表中删除。发送路由更新时，目标地址为广播地址：255.255.255.255。路由器每隔30s从每个启动RIP协议的接口发送出路由更新信息。若一条路由在180s内没有收到更新，这条路由的跳数将记为16。发送路由更新时，目标地址为组播地址224.0.0.9。RIP是一个【距离——矢量】路由选择协议。发送路由更新时【不携带】子网掩码，属于。发送路由更新时【携带】子网掩码，属于。当路由器的更新周期为30s到来时，向邻居发送路由表。
H3C Intelligent Management Center无线认证新增设备如何配置
大鹏的博客
07-12 891
因为出口有多条宽带，所以静态路由要配置目的地址和下一跳，我太相信分公司的工程师了，导致一直有问题，没有正确指下一跳，然后一直通信单向可以，双向不行。下面有监控信息说明配置成功，配置的时候需要信息一致，包括高级设置重点安全提议，共享密钥等等。创建接入服务，调用接入策略，由于接入设备上配置带域名发送，则此处需配置服务后缀，与域名相同。选择手工增加设备，添加设备ip，若设备上配置nas ip，此处填nas ip地址。#// 配置portal服务器ip，共享密钥，重定向url。：共享密钥与设备侧填写的要一致，
计算机网络复习笔记【面向考纲整理】
无
07-13 377
计算机网络（简称网络）由若干结点（node，节点）和连接这些结点的链路（link）组成。
计网（1.1~1.4）
2301_76590691的博客
07-12 564
网络:由若干结点和连接这些结点的链路组成互联网:多个网络还可以通过路由器互连起来，这样就构成了一个覆盖范围更大的网络，也可 被称为“网络中的网络因特网是世界上最大的互连网络计算机网络的精确定义并未统一计算机网络的简单定义：一些互相连接的、自治的计算机的集合互连是指计算机之间可以通过有线或无线的方式进行数据通信自治是指独立的计算机，它有自己的硬件和软件，可以单独运行使用集合是指至少需要两台计算机。
Linux系统
最新发布
Baizeh的博客
07-16 830
把windows开发好的程序部署到linux操作系统上，因为windows操作系统漏洞太多容易被攻击。
CCNA-2-V7-模块7–9:可用且可靠的网络考试答案
YingtingXiao的博客
07-12 575
CCNA-2-V7-模块7–9:可用且可靠的网络考试答案
网络安全威胁情报到底是什么
学-> 思->用
07-10 612
网络安全威胁情报是提升组织安全态势的重要手段，通过收集和分析各种威胁信息，组织可以更有效地预防、检测和响应网络攻击。威胁情报的构成要素包括指标、TTPs、威胁行为体、漏洞、恶意软件和攻击事件。通过合理应用威胁情报，组织可以增强防御能力、提升事件响应效率，并通过情报共享与合作，共同应对复杂多变的网络威胁。
嵌入式软件开发技术：第6章 嵌入式Linux网络编程.ppt
05-31
"嵌入式Linux网络编程技术，包括TCP/IP协议概述，网络基础编程，以及网络高级编程。本章内容适用于嵌入式系统开发者，旨在帮助他们理解和掌握网络编程的关键概念，以便在嵌入式应用中实现网络通信功能。" 在嵌入式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值