UDP实现文件的发送、UDP实现全双工的聊天、TCP通信协议

最新推荐文章于 2024-05-20 20:42:03 发布
最新推荐文章于 2024-05-20 20:42:03 发布
阅读量763 收藏 14
点赞数 9
文章标签： 网络 vim linux TCP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71850179/article/details/136565238
版权

我要成为嵌入式高手之3月7日Linux高编第十七天！！
————————————————————————————

回顾

重要程序

1、UDP实现文件的发送

发端：

#include "head.h"

int main(void)
{
    int sockfd = 0;
    struct sockaddr_in recvaddr;
    ssize_t nsize = 0;
    int ret = 0;
    int fd = 0;
    char pathname[1024] = {0};
    char tmpbuff[1024] = {0};
    ssize_t nret;

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

    recvaddr.sin_family = AF_INET;
    recvaddr.sin_port = htons(33333);
    recvaddr.sin_addr.s_addr = inet_addr("192.168.1.167");

    memset(pathname, 0, sizeof(pathname));
    gets(pathname);
    
    nsize = sendto(sockfd, pathname, strlen(pathname), 0, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (nsize == -1)
    {
        perror("fail to sendto");
        return -1;
    }
    
    fd = open(pathname, O_RDONLY);
    if (fd == -1)
    {
        perror("fail to open");
        return -1;
    }
    printf("pathname: %s\n", pathname);

    while (1)
    {
        usleep(10);
        nret = read(fd, tmpbuff, sizeof(tmpbuff));

        nsize = sendto(sockfd, tmpbuff, nret, 0, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
        if (nsize == -1)
        {
            perror("fail to sendto tmpbuff");
            return -1;
        }

        if (nret <= 0)
        {
            break;
        }
    }
    
    sprintf(tmpbuff, "|__quit__|");
    nsize = sendto(sockfd, tmpbuff, strlen(tmpbuff)+1, 0, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (nsize == -1)
    {
        perror("fail to sendto tmpbuff");
        return -1;
    }

    printf("成功发送 %s 文件\n", pathname);

    close(fd);
    close(sockfd);


    return 0;
}

收端：

#include "head.h"

int main(void)
{
	int ret = 0;
	int sockfd = 0;
	char tmpbuff[4096] = {0};
	struct sockaddr_in recvaddr;
	ssize_t nsize = 0;
	struct sockaddr_in sendaddr;
	socklen_t len = sizeof(sendaddr);

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

	recvaddr.sin_family = AF_INET;
	recvaddr.sin_port = htons(33333);
	recvaddr.sin_addr.s_addr = inet_addr("192.168.1.167");

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


	nsize = recvfrom(sockfd, tmpbuff, sizeof(tmpbuff), 0, (struct sockaddr *)&sendaddr, &len);
	if (nsize == -1)
	{
		perror("fail to recvfrom");
		return -1;
	}


//	printf("%s:%d>>接受到%ld个字节：%s\n",inet_ntoa(sendaddr.sin_addr),ntohs(sendaddr.sin_port),nsize,tmpbuff);
	
	int fd = 0;
	char ch[1024]= {0};

	fd = open(tmpbuff,O_WRONLY | O_CREAT | O_TRUNC, 0664);
	if (fd == -1)
	{
		perror("fail to fopen");
		return -1;
	}

	while(nsize != 0)
	{
		memset(ch, 0, sizeof(ch));
		nsize = recvfrom(sockfd, ch, sizeof(ch), 0, (struct sockaddr *)&sendaddr, &len);
		if (nsize == -1)
		{
			perror("fail to recvfrom");
			return -1;
		}

		if (!strcmp(ch,"1"))
		{
			break;
		}

		write(fd,ch,nsize);
		printf("写入%ld字节\n",nsize);
	}


	printf("接受完成!\n");

	close(fd);

	close(sockfd);

	return 0;
}

2、UDP实现全双工的聊天

发送端

#include "head.h"

char name[32] = {0};
int sockfd = 0;
struct sockaddr_in recvaddr;
pthread_t tid_send;
pthread_t tid_recv;

void *sendfun(void *arg)
{
    ssize_t nsize = 0;
    struct msgbuf sendmsg;
    
    while(1)
    {
        memset(&sendmsg, 0, sizeof(sendmsg));
        sendmsg.type = MSG_TYPE_CHAT;
        sprintf(sendmsg.name, "%s", name);
        gets(sendmsg.text);    

        if (!strcmp(sendmsg.text, ".quit"))
        {
            sendmsg.type = MSG_TYPE_END;
        }

        nsize = sendto(sockfd, &sendmsg, sizeof(sendmsg), 0, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
        if (nsize == -1)
        {
            perror("fail to sendto");
            return NULL;
        }

        if (sendmsg.type == MSG_TYPE_END)
        {
            break;
        }
    }

    pthread_cancel(tid_recv);

    return NULL;
}

void *recvfun(void *arg)
{
    struct msgbuf recvmsg;
    ssize_t nsize = 0;

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

        if (recvmsg.type == MSG_TYPE_CHAT)
        {
            printf("%s(%s:%d)>%s\n", recvmsg.name, RECV_ADDR, RECV_PORT, recvmsg.text);
        }
        else if (recvmsg.type == MSG_TYPE_END)
        {
            break;
        }
    }
   
    pthread_cancel(tid_send);

    return NULL;
}

int main(void)
{
    ssize_t nsize = 0;
    struct msgbuf sendmsg;

    /*设置接收方信息*/
    recvaddr.sin_family = AF_INET;
    recvaddr.sin_port = htons(RECV_PORT);
    recvaddr.sin_addr.s_addr = inet_addr(RECV_ADDR);

    /*输入昵称*/
    printf("请输入您的昵称:\n");
    gets(name);
    
    /*创建套接字*/
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1)
    {
        perror("fail to sockfd");
        return -1;
    }
    
    /*设置要发送的信息*/
    memset(&sendmsg, 0, sizeof(sendmsg));
    sendmsg.type = MSG_TYPE_START;
    sprintf(sendmsg.name, "%s", name);

    /*发送信息*/
    nsize = sendto(sockfd, &sendmsg, sizeof(sendmsg), 0, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (nsize == -1)
    {
        perror("fail to sendto");
        return -1;
    }

    pthread_create(&tid_send, NULL, sendfun, NULL);
    pthread_create(&tid_recv, NULL, recvfun, NULL);

    pthread_join(tid_send, NULL);
    pthread_join(tid_recv, NULL);
    
    close(sockfd);

    return 0;
}

接收端

#include "head.h"

char name[32] = {0};
int sockfd = 0;
struct sockaddr_in recvaddr;
struct sockaddr_in sendaddr;
pthread_t tid_send;
pthread_t tid_recv;

void *sendfun(void *arg)
{
    ssize_t nsize = 0;
    struct msgbuf sendmsg;
    
    while(1)
    {
        memset(&sendmsg, 0, sizeof(sendmsg));
        sendmsg.type = MSG_TYPE_CHAT;
        sprintf(sendmsg.name, "%s", name);
        gets(sendmsg.text);    

        if (!strcmp(sendmsg.text, ".quit"))
        {
            sendmsg.type = MSG_TYPE_END;
        }

        nsize = sendto(sockfd, &sendmsg, sizeof(sendmsg), 0, (struct sockaddr *)&sendaddr, sizeof(sendaddr));
        if (nsize == -1)
        {
            perror("fail to sendto");
            return NULL;
        }

        if (sendmsg.type == MSG_TYPE_END)
        {
            break;
        }
    }

    pthread_cancel(tid_recv);

    return NULL;
}

void *recvfun(void *arg)
{
    struct msgbuf recvmsg;
    ssize_t nsize = 0;

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

        if (recvmsg.type == MSG_TYPE_CHAT)
        {
            printf("%s(%s:%d)>%s\n", recvmsg.name, inet_ntoa(sendaddr.sin_addr), ntohs(sendaddr.sin_port), recvmsg.text);
        }
        else if (recvmsg.type == MSG_TYPE_END)
        {
            break;
        }
    }
   
    pthread_cancel(tid_send);

    return NULL;
}

int main(void)
{
    char tmpbuff[1024] = {0};
    struct msgbuf recvmsg;
    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_ADDR);

    /*输入昵称*/
    printf("请输入您的昵称:\n");
    gets(name);
    
    /*创建套接字*/
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1)
    {
        perror("fail to sockfd");
        return -1;
    }
    
    ret = bind(sockfd, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    if (-1 == ret)
    {
        perror("fail to bind");
        return -1;
    }

    /*设置要发送的信息*/
    memset(&recvmsg, 0, sizeof(recvmsg));

    /*接收信息*/
    ret = recvfrom(sockfd, &recvmsg, sizeof(recvmsg), 0, (struct sockaddr *)&sendaddr, &addrlen);
    if (ret == -1)
    {
        perror("fail to recvfrom");
        return -1;
    }

    pthread_create(&tid_send, NULL, sendfun, NULL);
    pthread_create(&tid_recv, NULL, recvfun, NULL);

    pthread_join(tid_recv, NULL);
    pthread_join(tid_send, NULL);
    
    close(sockfd);

    return 0;
}

head.h

#ifndef _HEAD_H
#define _HEAD_H

#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <time.h>
#include <pwd.h>
#include <stdlib.h>
#include <grp.h>
#include <sys/wait.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/socket.h>
#include <netinet/ip.h>
#include <netinet/in.h>
#include <arpa/inet.h>

struct msgbuf
{
    int type;      //消息类型
    char name[32]; //昵称
    char text[32]; //消息
};

#define MSG_TYPE_START        100               //开始聊天消息类型
#define MSG_TYPE_END          200               //退出聊天消息类型
#define MSG_TYPE_CHAT         300               //聊天消息类型
#define RECV_ADDR             "192.168.1.172"   //接收端地址
#define RECV_PORT             50000             //接收端端口

#endif

学习笔记

TCP通信

TCP发端(客户端)

        socket -> connect -> send / recv-> close

TCP收端(服务端)

        socket -> bind -> listen -> accept -> send / recv -> close

 1、connect

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

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

功能：发起链接请求

参数：

        sockfd：套接字的描述符

        addr：目的地址存放空间首地址

        addrlen：IP地址的大小

返回值：成功0，失败-1；

2、send

#include <sys/types.h>
#include <sys/socket.h>

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

功能：发送数据

参数：

        sockfd：套接字描述符

        buf：发送数据空间的首地址

        len：发送数据的长度

        flags：属性默认为0

返回值：

        成功返回实际发送字节数

        失败返回-1；

3、recv

#include <sys/types.h>
#include <sys/socket.h>

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

功能：接收数据

参数：

        sockfd：套接字描述符

        buf：存放数据空间首地址

        len：最大接收数据的长度

        flags：属性默认0

返回值：

        成功返回实际接收字节数，失败返回-1；

        若对方退出，返回0

客户端：

#include "head.h"

int main(void)
{
    int ret = 0;
    int sockfd = 0;
    struct sockaddr_in serveaddr;
    char tmpbuff[1024] = {0};
    ssize_t nsize = 0;

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

    serveaddr.sin_family = AF_INET;
    serveaddr.sin_port = htons(50000);
    serveaddr.sin_addr.s_addr = inet_addr("192.168.1.101");
    ret = connect(sockfd, (struct sockaddr *)&serveaddr, sizeof(serveaddr));
    if (ret == -1)
    {
        perror("fail to connect");
        return -1;
    }

    gets(tmpbuff);
    nsize = send(sockfd, tmpbuff, strlen(tmpbuff), 0);
    if (nsize == -1)
    {
        perror("fail to send");
        return -1;
    }
   
    memset(tmpbuff, 0, sizeof(tmpbuff));
    nsize = recv(sockfd, tmpbuff, sizeof(tmpbuff), 0);
    if (nsize == -1)
    {
        perror("fail to recv");
        return -1;
    }

    printf("RECV: %s\n", tmpbuff);

    close(sockfd);

    return 0;
}

4、listen

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int listen(int sockfd, int backlog);

功能：监听客户端发送的链接请求，不会阻塞

参数：

        sockfd：套接字描述符

        backlog：允许等待的尚未被处理的三次握手请求的最大个数

返回值：成功0，失败-1；

5、accept

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

功能：

       处理等待链接队列中的第一个链接请求，若没有人发送链接请求会阻塞等待，直到有连接请求

参数：

        sockfd：套接字描述符

        addr：存放IP地址的空间首地址

        addrlen：存放IP地址大小空间首地址

返回值：

        成功返回一个新的文件描述符

        失败返回-1；

服务端：

#include "head.h"

int main(void)
{
    int sockfd = 0;
    struct sockaddr_in serveaddr;
    int ret = 0;
    int confd = 0;
    ssize_t nsize = 0;
    char tmpbuff[1024] = {0};

    serveaddr.sin_family = AF_INET;
    serveaddr.sin_port = htons(50000);
    serveaddr.sin_addr.s_addr = INADDR_ANY;

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

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

    ret = listen(sockfd, 10);
    if (-1 == ret)
    {
        perror("fail to listen");
        return -1;
    }

    confd = accept(sockfd, NULL, NULL);
    if (-1 == confd)
    {
        perror("fail to accept");
        return -1;
    }

    nsize = recv(confd, tmpbuff, sizeof(tmpbuff), 0);
    if (-1 == nsize)
    {
        perror("fail to recv");
        return -1;
    }

    printf("RECV: %s\n", tmpbuff);

    memset(tmpbuff, 0, sizeof(tmpbuff));
    gets(tmpbuff);
    nsize = send(confd, tmpbuff, strlen(tmpbuff), 0);
    if (-1 == nsize)
    {
        perror("fail to send");
        return -1;
    }

    close(confd);
    close(sockfd);

    return 0;
}

7.25！
关注
  • 9
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
xoom-wire:VLINGO XOOM平台SDK有线协议消息传递实现，例如使用VLINGO XOOM ACTOR的全双工TCP和UDP多播以及RSocket
04-09
放大线 VLINGO XOOM平台的SDK有线协议消息传递实现（例如，使用VLINGO XOOM ACTORS的全双工TCP和UDP多播以及RSocket）。 文件： ： 安装 < dependencies> < dependency> < groupId>io.vlingo.xoom</ groupId> < artifactId>xoom-wire</ artifactId> < version>1.6.0</ version> < scope>compile</ scope> </ dependency> </ dependencies> dependencies { compile ' io.vlingo.xoom:xoom-wire:1.6.0 ' } 许可证（有关完
VideoChat:使用基于TCPUDP的自定义婴儿双工传输协议（BDTP）进行视频聊天。 第四学期的作业
05-09
语音聊天 使用基于TCP / UDP的自定义婴儿双工传输协议（BDTP）进行语音聊天。 第四学期的作业
im即时通讯开发：网络通信传输层协议——UDP和TCP
蔚可云的博客
05-23 1277
互联网发展至今已经高度发达，而对于互联网应用（尤其即时通讯网专注的即时通讯技术这一块）的开发者来说，网络编程是基础中的基础，只有更好地理解相关基础知识，对于应用层的开发才能做到游刃有余。 相信计算机专业的朋友在大学都学过《计算机网络》这门课程，但据我个人了解计算机专业普通大学生对计算机网络的了解浅之又浅，很多人说这门学科没用，开发的时候也用不着，其实这样想是不对的。 UDP的全称是User Date Protocal，翻译成中文是用户数据包协议，它是一种不可靠的传输协议，一般情况下一个数据包(.
网络编程Socket套接字，UDP和TCP的服务器客户端程序实现
weixin_69417428的博客
02-28 1631
网络编程Socket套接字，实现UDP，TCP两个版本的服务器客户端网络通信程序，细节解析。
UDP是全双工通信的吗
weixin_42576410的博客
12-29 1551
是的，UDP 是全双工通信协议。 UDP(用户数据报协议)是一种无连接的协议，它可以在两台计算机之间进行数据传输。UDP 不像 TCP 那样提供可靠的数据传输机制，但是它具有更快的传输速度和更少的开销。 UDP 是全双工通信协议，这意味着它可以同时收发数据。它允许两台计算机在同一时间内进行双向通信。 ...
TCP和UDP都是全双工通信的吗
weixin_42590539的博客
12-29 860
是的，TCP和UDP都是全双工通信协议。这意味着在通信过程中，双方都能同时发送和接收数据。 TCP(传输控制协议)是一种面向连接的协议，它提供了可靠的数据传输服务。TCP在传输数据之前会建立一条逻辑连接，并在传输完成后断开连接。TCP还提供了数据流控制、拥塞控制和差错控制等功能。 UDP(用户数据报协议)是一种无连接的协议，它不建立逻辑连接，直接将数据发送到对方。UDP提供的是不可靠的数据传输服务...
c语言 tcp全双工通信,(传输层)TCP协议
weixin_28773055的博客
05-25 2557
目录首部格式图释:各个段位说明:源端口和目的端口:　　各占 2 字节.端口是传输层与应用层的服务接口.传输层的复用和分用功能都要通过端口才能实现序号:　　占 4 字节.TCP 连接中传送的数据流中的每一个字节都编上一个序号.序号字段的值则指的是本报文段所发送的数据的第一个字节的序号确认号:　　占 4 字节,是期望收到对方的下一个报文段的数据的第一个字节的序号数据偏移/首部长度:　　占 4 位,它指...
基于Socket的UDP和TCP编程介绍
01-19
　TCP：传输控制协议，一种面向连接的协议，给用户进程提供可靠的全双工的字节流，TCP套接口是字节流套接口(STream socket)的一种。 　UDP：用户数据报协议。UDP是一种无连接协议。UDP套接口是数据报套接口...
好用的TCP UDP调试助手NetAssist.exe
05-07
其中TCP提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的数据包发送。通俗说，它是事先为所发送的数据开辟出连接好的通道，然后再...
EDA/PLD中的基于Socket的UDP和TCP编程介绍
11-09
　TCP：传输控制协议，一种面向连接的协议，给用户进程提供可靠的全双工的字节流，TCP套接口是字节流套接口(stream socket)的一种。 　UDP：用户数据报协议。UDP是一种无连接协议。UDP套接口是数据报套接口(datagram...
TCP/UDP协议的区别及使用场景
weixin_45979623的博客
08-20 2261
本文主要介绍计算机网络OSI模型中传输层协议Protocol）与（User Datagram Protocol）的区别、各自的使用场景，以及面试中经常出现的一系列问题。Let's go!
TCP协议与UDP协议详解
zyyy0的博客
10-21 8935
下一次你从哪里开始发。掉电的是接收方：发送方是不知道对面挂了的，继续发数据(没有ack)，之后触发超时重传，重传几次之后仍没有应答，尝试重置链接(也会失败，触发复位报文段RST)，最后只能放弃连接。发送方发送数据的时候，就先计算一个校验和，接收方接收的时候，按照同样的规则再算一次校验和，最后看一下两次校验和是不是一样的(这里出现问题的概率还是比较小的)发送方发送数据的时候，就先计算一个校验和，接收方接收的时候，按照同样的规则再算一次校验和，最后看一下两次校验和是不是一样的(这里出现问题的概率还是比较小的)
网络协议 udp 通信实现步骤
Nick.Peng's Blogs
09-12 1128
前言socket： socket(简称 套接字) 是进程间通信的一种方式，它与其他进程间通信的一个主要不同是：它能实现不同主机间的进程间通信，socket 属于 全双工。 关于创建套接字的参数说明： socket.socket(AddressFamily, Type) Address Family：可以选择 AF_INET（用于 Internet 进程间通信） 或者 AF_UNIX（...
socket 网络编程快速入门（二）教你编写基于UDP/TCP的服务端多线程通信
NK_test的博客
08-18 6079
在上一篇博文中，我们介绍了利用socket进行简单的UDP/TCP的服务端和客户端的通信。 （一） 在基于UDP的程序中，你有没有想过，如果我的这台主机在通讯的时候要求既能够收到别的主机发来的数据，又能够自己向目的主机发出数据，该怎样实现？也就是说需要两个while循环同时进行。答案是使用多线程，一个线程用于接受数据，另一个线程用来发送数据。接下来我们介绍WinSock的多线程编程。 多线程
TCP/UDP协议基本介绍
qq_53180719的博客
06-10 3076
目录前言1、socket（套接字）2、UDP/TCP特点3、UDP协议细节4、TCP协议细节TCP协议的可靠性握手阶段正式通信阶段 断开阶段流量控制与拥塞控制其他细节小结TCP协议是面向连接的，可靠的，基于字节流的传输层通信协议。UDP协议是面向无连接，不可靠的，基于数据报的传输层通信协议。所谓套接字(Socket)，就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲，套接字上联应用进程，下联网络协议
Linux网络编程：网络基础
最新发布
weixin_73234157的博客
05-20 534
当我们形成计算机网络后，小明要给他的暗恋对象小红发一句“我喜欢你”，结果发给了小芳……，在计算机网络中会出现许许多多的主机，当我们进行网络通信时，我们要通过协议来找到指定的接收方。同理在单台主机中，数据从键盘中读入再转载到当前网卡也是需要协议的。简单来说：协议就是一种约定当计算机在读取数据时，发现数据中存在向网卡输送的标志（协议）时，就往网卡输送。当网卡读取到输送给小红，网卡就不会发送给小芳。
使用MPLS解决BGP的路由黑洞（详解）
qq_64302290的博客
05-18 232
我们知道在MPLS中数据的转发不再依靠路由表而是靠标签（注意：标签是在路由的基础上形成的）。所以在BGP中，我们依靠的就是这个特性来解决BGP的路由黑洞。BGP路由黑洞的解释：BGP的路由黑洞其实就是路由层面可达，数据层面不可达。（你可以收到对方的路由，但是不能和对方通讯。
云服务器遇到攻击怎么办，有哪些安全措施
dexunyun的博客
05-18 547
DDoS攻击对云服务器安全构成了严重威胁，但通过采取合适的防护策略，我们可以有效地降低攻击的影响。选择可靠的云服务提供商、部署DDoS防护服务是保护云服务器免受DDoS攻击的有效措施。德迅云安全提供了多种防护解决方案，可以帮助企业有效防止DDoS攻击，保护云服务器的安全，保障业务稳定。
C语言使用UDP实现全双工聊天
05-05
当然，如果你非要使用UDP协议实现全双工聊天的话，你需要在客户端和服务器端分别创建两个socket，并且分别进行绑定和监听。客户端和服务器端都需要使用sendto()和recvfrom()函数来发送和接收数据。但是需要注意的是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值