linux网络编程-广播、多播、套接字

最新推荐文章于 2024-06-25 15:34:01 发布
最新推荐文章于 2024-06-25 15:34:01 发布
阅读量363 收藏 1
点赞数
分类专栏： linux 网络编程 文章标签： linux 网络 网络通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59949484/article/details/132150798
版权

广播和组播

广播

前面介绍的数据包发送方式只有一个接受方，称为单播
如果同时发给局域网中的所有主机，称为广播
只有用户数据报(使用UDP协议)套接字才能广播


广播地址


以192.168.1.0 (255.255.255.0) 网段为例，最大的主机地址192.168.1.255代表该网段的广播地址
发到该地址的数据包被所有的主机接收
255.255.255.255在所有网段中都代表广播地址

广播发送

创建用户数据报套接字
缺省创建的套接字不允许广播数据包，需要设置属性
setsockopt可以设置套接字属性
接收方地址指定为广播地址
指定端口信息
发送数据包

setsockopt

int  setsockopt(int  s,  int level,  int  optname, const void *optval, socklen_t  optlen);

头文件：<sys/socket.h>
level : 选项级别（例如SOL_SOCKET）
optname : 选项名（例如SO_BROADCAST）
optval : 存放选项值的缓冲区的地址
optlen : 缓冲区长度
返回值：成功返回0   失败返回-1并设置errno 

广播发送示例

sockfd = socket(,,);
……
int on = 1;
setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
……
sendto(;;;;;);

广播接收

创建用户数据报套接字

绑定本机IP地址和端口
绑定的端口必须和发送方指定的端口相同

等待接收数据

 

要点：


广播编程是基于 UDP 编程
1．发送方要通过 setsockopt 设置套接字广播属性
2．发送方的发送地址为广播地址：XXX．XXX．XXX．255
3．接收方和发送方的端口号要相同 


/*udp demo */

/* usage:
 * ./client serv_ip serv_port 
*/
#include "net.h"
void usage (char *s)
{
	printf ("\nThis is udp demo!\n");
	printf ("\nUsage:\n\t %s serv_ip serv_port", s);
	printf ("\n\t serv_ip: udp server ip address");
	printf ("\n\t serv_port: udp server port(serv_port > 5000)\n\n");
}

int main (int argc, char *argv[])
{
	int fd = -1;
	int port = SERV_PORT;

	port = atoi (argv[2]);
	if (port < 0 || (port > 0 && port <= 5000)) {
		usage (argv[0]);
		exit (1);
	}
	struct sockaddr_in sin;
	if (argc != 3) {
		usage (argv[0]);
		exit (1);
	}

	/* 1. 创建socket fd */
	if ((fd = socket (AF_INET, SOCK_DGRAM, 0)) < 0) {	//UDP编程
		perror ("socket");
		exit (1);
	}

	/* 允许广播设置 */
	int b_br = 1;
	setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &b_br, sizeof(int));

	/*2.1 填充struct sockaddr_in结构体变量 */
	bzero (&sin, sizeof (sin));

	sin.sin_family = AF_INET;
	sin.sin_port = htons (SERV_PORT);	//网络字节序的端口号
#if 0
	sin.sin_addr.s_addr = inet_addr (argv[1]);
#else
	if (inet_pton (AF_INET, argv[1], (void *) &sin.sin_addr) != 1) {
		perror ("inet_pton");
		exit (1);
	}
#endif
	printf ("broadcast demo started!\n");
	char buf[BUFSIZ];
	while (1) {
		fprintf (stderr, "pls input string:");
		bzero (buf, BUFSIZ);
		if (fgets (buf, BUFSIZ - 1, stdin) == NULL) {
			perror ("fgets");
			continue;
		}

		sendto (fd, buf, strlen (buf), 0, (struct sockaddr *) &sin, sizeof (sin));

		if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) {	//用户输入了quit字符
			printf ("Client is exited!\n");
			break;
		}

	}
	close (fd);
	return 0;
}

 

组播


单播方式只能发给一个接收方。

广播方式发给所有的主机。过多的广播会大量占用网络带宽，造成广播风暴，影响正常的通信。

组播(又称为多播)是一种折中的方式。只有加入某个多播组的主机才能收到数据。

多播方式既可以发给多个主机，又能避免象广播那样带来过多的负载(每台主机要到传输层才能判断广播包是否要处理)

组播是一个人发送,加入到多播组的人接受数据
组播的 IP 地址:224.0.0.1~239.255.255.254(中间除掉广播)

组播必须基于UDP的编程方法

网络地址

A类地址
第1字节为网络地址，其他3个字节为主机地址。第1字节的最高位固定为0
1.0.0.1 – 126.255.255.255

B类地址
第1字节和第2字节是网络地址，其他2个字节是主机地址。第1字节的前两位固定为10
128.0.0.1 – 191.255.255.255

C类地址
前3个字节是网络地址，最后1个字节是主机地址。第1字节的前3位固定为110
192.0.0.1 – 223.255.255.255

D类地址（组播地址）
不分网络地址和主机地址，第1字节的前4位固定为1110
224.0.0.1 – 239.255.255.255

组播发送

创建用户数据报套接字

接收方地址指定为组播地址

指定端口信息

发送数据包

组播接收

创建用户数据报套接字

加入多播组

绑定本机IP地址和端口
绑定的端口必须和发送方指定的端口相同

等待接收数据


加入多播组

struct ip_mreq
{
     struct  in_addr  imr_multiaddr;
     struct  in_addr  imr_interface;
};

struct  ip_mreq  mreq;
bzero(&mreq, sizeof(mreq));
mreq.imr_multiaddr.s_addr = inet_addr(“235.10.10.3”);
mreq.imr_interface.s_addr = htonl(INADDR_ANY);

setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq,  
                  sizeof(mreq));

 

 

#include "net.h"

int main(void)
{

	int fd = -1;
	struct sockaddr_in sin;

	/* 1. 创建socket fd */
	if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
	{	//udp程序
		perror("socket");
		exit(1);
	}

	/* 2. 允许绑定地址快速重用 */
	int b_reuse = 1;
	setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof(int));

	/*加入多播组*/
	struct ip_mreq mreq;//定义多播结构体
	bzero(&mreq, sizeof(mreq));//清零
	mreq.imr_multiaddr.s_addr = inet_addr(MULTICAST_IP);//头文件定义的IP地址
	mreq.imr_interface.s_addr = htonl(INADDR_ANY);//任意IP地址
	//设置多播
	setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));

	/*2. 绑定 */
	/*2.1 填充struct sockaddr_in结构体变量 */
	bzero(&sin, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(SERV_PORT);	//网络字节序的端口号

	/* 让服务器程序能绑定在任意的IP上 */
#if 1
	sin.sin_addr.s_addr = htonl(INADDR_ANY);
#else
	if (inet_pton(AF_INET, SERV_IP_ADDR, (void*)&sin.sin_addr) != 1)
	{
		perror("inet_pton");
		exit(1);
	}
#endif
	/*2.2 绑定 */
	if (bind(fd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
	{
		perror("bind");
		exit(1);
	}

	char buf[BUFSIZ];
	struct sockaddr_in cin;
	socklen_t addrlen = sizeof(cin);
	printf("\nmulticast demo started!\n");
	while (1)
	{
		bzero(buf, BUFSIZ);
		if (recvfrom(fd, buf, BUFSIZ - 1, 0, (struct sockaddr*)&cin, &addrlen) < 0)
		{
			perror("recvfrom");
			continue;
		}

		char ipv4_addr[16];
		if (!inet_ntop(AF_INET, (void*)&cin.sin_addr, ipv4_addr, sizeof(cin)))
		{
			perror("inet_ntop");
			exit(1);
		}

		printf("Recived from(%s:%d), data:%s", ipv4_addr, ntohs(cin.sin_port), buf);

		if (!strncasecmp(buf, QUIT_STR, strlen(QUIT_STR)))
		{	//用户输入了quit字符
			printf("Client(%s:%d) is exiting!\n", ipv4_addr, ntohs(cin.sin_port));
		}

	}

	close(fd);

	return 0;
}

UNIX域套接字

socket同样可以用于本地通信

创建套接字时使用本地协议PF_UNIX(或PF_LOCAL)。
  socket(AF_LOCAL, SOCK_STREAM, 0)
  socket(AF_LOCAL, SOCK_DGRAM, 0)

分为流式套接字和用户数据报套接字

和其他进程间通信方式相比使用方便、效率更高

常用于前后台进程通信

进程间通信：


1.进程间的数据共享：
管道、消息队列、共享内存、unix 域套接字
易用性： 消息队列 > unix 域套接字 >管道 > 共享内存 (经常要和信号量一起用) 效率：
共享内存 >unix 域套接字 >管道 > 消息队列常用：共享内存、unix 域套接字
2. 异步通信:
信号
3. 同步和互斥（做资源保护）

信号量


本地地址结构

       struct sockaddr_un        //  <sys/un.h>
        {
             sa_family_t  sun_family;
             char  sun_path[108];         // 套接字文件的路径
         };

 填充地址结构

    struct sockaddr_un myaddr;
     bzero(&myaddr,  sizeof(myaddr));
     myaddr.sun_family = AF_UNIX;      strcpy(myaddr.sun_path,  “/tmp/mysocket”);

流式套接字服务器端 

流式套接字客户端

 

UNIX域(用户数据报)套接字服务器端

 

 UNIX域(用户数据报)套接字客户端

 

 

 

#include <pthread.h>
#include <signal.h>
#include "net.h"

void cli_data_handle(void* arg);

void sig_child_handle(int signo)
{
	if (SIGCHLD == signo)
	{
		waitpid(-1, NULL, WNOHANG);
	}
}
int main(void)
{

	int fd = -1;

	signal(SIGCHLD, sig_child_handle);

	/* 1. 创建socket fd */
	if ((fd = socket(AF_LOCAL, SOCK_STREAM, 0)) < 0)
	{ //基于本地的TCP通信
		perror("socket");
		exit(1);
	}

	/* 允许绑定地址快速重用 */
	int b_reuse = 1;
	setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof(int));

	/* 2.1 填充sockaddr_un结构体变量 */
	struct sockaddr_un sun;
	bzero(&sun, sizeof(sun));
	sun.sun_family = AF_LOCAL;

	/* 判断是否存在如果UNIX_DOMAIN_FILE所指向的文件存在，则删除 */
	if (!access(UNIX_DOMAIN_FILE, F_OK))
	{
		unlink(UNIX_DOMAIN_FILE); / 删除文件
	}

	strncpy(sun.sun_path, UNIX_DOMAIN_FILE, strlen(UNIX_DOMAIN_FILE));


	/*2.2 绑定 */
	if (bind(fd, (struct sockaddr*)&sun, sizeof(sun)) < 0)
	{
		perror("bind");
		exit(1);
	}

	/*3. 调用listen()把主动套接字变成被动套接字 */
	if (listen(fd, BACKLOG) < 0)
	{
		perror("listen");
		exit(1);
	}
	printf("Unix domain server starting....OK!\n");
	int newfd = -1;
	/*4. 阻塞等待客户端连接请求 */
	while (1)
	{
		pid_t pid = -1;
		if ((newfd = accept(fd, NULL, NULL)) < 0)
		{
			perror("accept");
			break;
		}
		/*创建一个子进程用于处理已建立连接的客户的交互数据*/
		if ((pid = fork()) < 0)
		{
			perror("fork");
			break;
		}

		if (0 == pid)
		{  //子进程中
			close(fd);

			printf("Clinet is connected!\n");
			cli_data_handle(&newfd);
			return 0;

		}
		else
		{ //实际上此处 pid >0, 父进程中 
			close(newfd);
		}


	}


	close(fd);
	return 0;
}

void cli_data_handle(void* arg)
{
	int newfd = *(int*)arg;

	printf("Child handling process: newfd =%d\n", newfd);

	//..和newfd进行数据读写


	int ret = -1;
	char buf[BUFSIZ];
	char resp_buf[BUFSIZ + 10];
	while (1)
	{
		bzero(buf, BUFSIZ);
		do
		{
			ret = read(newfd, buf, BUFSIZ - 1);
		} while (ret < 0 && EINTR == errno);
		if (ret < 0)
		{

			perror("read");
			exit(1);
		}
		if (!ret)
		{				//对方已经关闭
			break;
		}
		printf("Receive data: %s\n", buf);

		if (!strncasecmp(buf, QUIT_STR, strlen(QUIT_STR)))
		{	//用户输入了quit字符
			printf("Client(fd=%d) is exiting!\n", newfd);
			break;
		}

		bzero(resp_buf, BUFSIZ + 10);

		strncpy(resp_buf, SERV_RESP_STR, strlen(SERV_RESP_STR));
		strcat(resp_buf, buf);
		do
		{
			ret = write(newfd, resp_buf, strlen(resp_buf));
		} while (ret < 0 && EINTR == errno);

	}
	close(newfd);

}


/*./client unix_domain_file */
#include "net.h"

void usage(char* s)
{
	printf("\n%s unix_domain_file\n\n", s);
}

int main(int argc, char** argv)
{
	int fd = -1;

	int port = -1;
	struct sockaddr_un sun;

	if (argc != 2)
	{
		usage(argv[0]);
		exit(1);
	}
	/* 1. 创建socket fd */
	if ((fd = socket(AF_LOCAL, SOCK_STREAM, 0)) < 0)
	{
		perror("socket");
		exit(1);
	}

	/*2.连接服务器 */

	/*2.1 填充struct sockaddr_un结构体变量 */
	bzero(&sun, sizeof(sun));

	sun.sun_family = AF_LOCAL;


	/*确保UNIX_DOMAIN_FILE要先存在并且可写，不存在则退出 */
	if (access(UNIX_DOMAIN_FILE, F_OK | W_OK) < 0)
	{
		exit(1);
	}
	strncpy(sun.sun_path, UNIX_DOMAIN_FILE, strlen(UNIX_DOMAIN_FILE));


	if (connect(fd, (struct sockaddr*)&sun, sizeof(sun)) < 0)
	{
		perror("connect");
		exit(1);
	}

	printf("Unix domain Client staring...OK!\n");

	int ret = -1;
	fd_set rset;
	int maxfd = -1;
	struct timeval tout;
	char buf[BUFSIZ];

	while (1)
	{
		FD_ZERO(&rset);
		FD_SET(0, &rset);
		FD_SET(fd, &rset);
		maxfd = fd;

		tout.tv_sec = 5;
		tout.tv_usec = 0;

		select(maxfd + 1, &rset, NULL, NULL, &tout);
		if (FD_ISSET(0, &rset))
		{	//标准键盘上有输入
//读取键盘输入，发送到网络套接字fd
			bzero(buf, BUFSIZ);
			do
			{
				ret = read(0, buf, BUFSIZ - 1);
			} while (ret < 0 && EINTR == errno);
			if (ret < 0)
			{
				perror("read");
				continue;
			}
			if (!ret)
				continue;

			if (write(fd, buf, strlen(buf)) < 0)
			{
				perror("write() to socket");
				continue;
			}

			if (!strncasecmp(buf, QUIT_STR, strlen(QUIT_STR)))
			{	//用户输入了quit字符
				printf("Client is exiting!\n");
				break;
			}
		}

		if (FD_ISSET(fd, &rset))
		{	//服务器给发送过来了数据
//读取套接字数据，处理
			bzero(buf, BUFSIZ);
			do
			{
				ret = read(fd, buf, BUFSIZ - 1);
			} while (ret < 0 && EINTR == errno);
			if (ret < 0)
			{
				perror("read from socket");
				continue;
			}
			if (!ret)
				break;			/* 服务器关闭 */

			//There is a BUG,FIXME!!
			printf("server said: %s\n", buf);
			if ((strlen(buf) > strlen(SERV_RESP_STR))
				&& !strncasecmp(buf + strlen(SERV_RESP_STR), QUIT_STR, strlen(QUIT_STR)))
			{	//用户输入了quit字符
				printf("Sender Client is exiting!\n");
				break;
			}

		}
	}

	/*4.关闭套接字 */
	close(fd);
}

#ifndef __MAKEU_NET_H__
#define __MAKEU_NET_H__

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/types.h>			/* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>			/* superset of previous */

#include <sys/select.h>
#include <sys/time.h>
//#include <sys/types.h>
#include <unistd.h>
#include <sys/un.h>

#define UNIX_DOMAIN_FILE "/tmp/my_domain_file.1"

#define BACKLOG 5


#define QUIT_STR "quit"
#define SERV_RESP_STR "SERVER:"
#endif

 

 

网络总结

 

m0_59949484
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux网络编程之广播
02-18 3520
1.概念 前面介绍的TCP,UDP都是单播方式，即一对一.而广播是一台主机向局域网内的所有主机发送数据。这时，同一网段的所有主机都能接收到数据。发送广播包的步骤大致如下: (1)确定一个发送广播的接口，如eth0 (2)确定广播的地址，通过ioctl函数，请求码设置为SIOCGIFBRDADDR得到广播的地址 (3)使用这个广播地址进行广播 由于TCP协议是端到端的协议，在通信之前，必须
Unix 网络编程_阅读笔记三 广播、多播、UDP套接字、信号驱动式I/O
MrWangyu的专栏
03-05 292
Unix 网络编程_阅读笔记 三 (Socket高级篇之广播、多播、UDP套接字、信号驱动式I/O） --Unix Network Programming 由 王宇 原创并发布 本文代码，在以下环境下编译通过 CentOS 6.4 Kernal version: 2.6.32 GCC version: 4.4.7 一、广播 1、用途和寻址方式 广播的用途之一是...
LINUX 下UDP发送广播
12-26
LINUX 下UDP发送广播，已编译好，可直接在linux下运行，文件包含客户端与服务端
Linux网络编程——广播
热门推荐
秋叶原 && Mike || 麦克
05-08 2万+
概述在生活中广播无处不在，像平时在大街上卖物品的商人，在进行推广产品的时候往往都是使用一个喇叭来进行吆喝：“十块钱买不了吃亏，十块钱买不了上当，走过路过千万不要错过”，这就是广播。那么在网络中的广播又是什么样子的呢？网络上的广播指：由一台主机向该主机所在子网内（同一个局域网）的所有主机发送数据的方式。如下图的 1 号主机广播给 2、3、4、5 号主机发送数据：实现广播，离不开广播地址，同一个子网（...
Linux 网络应用开发–-单播、广播和组播
最新发布
weixin_44373856的博客
06-25 730
TCP 和 UDP 他是都是网络当中的进程进行通信的，但是他们面向的群体或者是对象是 不同的，TCP 他是一对一的，一个服务器对应一个客户端，并且他在消息发送之前会和客户 端进行，三次握手，断开的会进行四次挥手.IPPROTO_IP： -- IP 层 -- 组播(man 7 ip) 专门组播 --- 你就填这个宏。ipaddr.imr_multiaddr.s_addr = inet_addr("多播组的 IP");
linux广播
weixin_30695195的博客
07-25 460
linux广播 // 发送端 #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netdb.h> #include <netinet/in.h> #in...
linux 广播
huangyimo的专栏
03-03 518
广播是一台主机向局域网内的所有主机发送数据。这时，同一网段的所有主机都能接收到数据。发送广播包的步骤大致如下: (1)确定一个发送广播的接口，如eth0 (2)确定广播的地址，通过ioctl函数，请求码设置为SIOCGIFBRDADDR得到广播的地址 (3)使用这个广播地址进行广播 在局域网内，广播通常用来探测服务器。 广播发送端： /*
linux上广播消息
redfivehit的专栏
04-19 1261
wall 请不要在开发机上跑程序
Linux网络编程--组播（多播）
ShawnWang1994的博客
01-03 1347
【1】前言 通过广播我们可以很方便地实现发送数据包给局域网中的所有主机。但广播同样存在很多问题，例如，平凡地发送广播包会造成所有主机数据链路层都来接受并给上层协议处理，容易引起网络风暴。组播（多播）是一种向特定群组发送广播的方式。组播是单播和广播的折中，当发送组播数据包时，只有加入指定多播组的主机数据链路层才会处理，其他主机在数据链路层会直接丢掉收到的数据包。 发送方把数据发向组播地址。接收方要提...
Linux网络编程笔记 第12章 套接字选项
weixin_48591705的博客
07-10 817
笔记
Linux下网络编程-UDP协议探测在线好友.pdf
07-12
2. 对套接字进行设置，如开启广播特性，以允许向同一网络内的所有设备发送数据。这可以通过`setsockopt()`函数实现，设置`SO_BROADCAST`选项： ```c char bBroadcast = 1; setsockopt(sockfd, SOL_SOCKET, SO_...
unix网络编程卷1：套接字联网api（第3版）
05-29
《Unix网络编程卷1：套接字联网API（第3版）》是网络编程领域的一本经典著作，由Steven McQuain和W. Richard Stevens共同撰写。这本书详细介绍了Unix系统中的网络编程，尤其是套接字（Sockets）API的使用，是IT专业...
Linux网络编程—单播多播与广播的实现文档编码
01-04
在给出的实验中，广播客户端（gb_client.c）和服务器端（gb_server.c）展示了如何创建和使用广播套接字。客户端首先创建一个UDP套接字，然后绑定到本地任意端口，以便接收广播数据。服务器端则设置套接字选项`SO_...
Linux上接收广播
liji_digital的博客
04-07 1706
在windows上实现广播比较简单：使用setsockopt结合SO_BROADAST即可。但是同样的代码不能在linux上获得同样的效果。 使用tcpdump监听，确实收到了广播包： stackoverflow上的解法： 修改代码，增加 INADDR_BROADCAST一项： #include <string> #include <stdlib.h> #include <string.h> #include <sys/types.h&gt..
Linux之广播和多播
imxiangzi的专栏
01-03 1208
最近学习Linux网络编程学到了广播与多播，就在这做点笔记。其中一些原理我就不介绍了，我觉得学习Linux网络编程，TCP/IP三卷还是基础，是需要好好看看。 广播的服务器端 : [cpp] view plaincopy #include    //#include    #include    #include    #inclu
Linux——广播
I am firo,I am here for you.
01-26 1614
缅怀Stevens大师。最好的参考资料：1.师从互联网。2.Linux man 命令：man 7 signal，man 7 socket。3.UNP v1第20章 。第一条：概述(0)广播用途：(0.1):资源发现 resource discovery：在知道我们所要访问的主机A（一般是服务器）位于本地子网络的前提下，但是我们不知道这个主机A的单播IP地址（就是平时用的IP地址呵呵），我们就可以通过发送广播分组给主机A，从而获得主机A 的IP地址。(0.2):减少网络分组流通：在多个客户主机与一个服务器主机
Linux网络编程系列之UDP广播
AABond的博客
10-14 2680
Linux网络编程系列之UDP广播，UPD广播的简单介绍和使用
Linux网络编程之UDP定时广播
qq_53928256的博客
04-08 891
在判断出需要发送广播信息的时候读取相应文件的信息内容发送。在本次设计中采用的方式是将需要定时发送的信息放入一个.txt后缀的文件中，将需要发送的时间按标准格式“%Y-%m-%d %H:%M:%S”放在前面，在通过一个制表符“\t”分割时间和需要发送的信息，紧接着写下需要广播发送的数据信息。服务端首先按行读取该txt文件的信息内容，并将每行的信息分成两项，时间字符串转换成time_t格式存储到结构体的time中，信息内容字符串则直接读取的结构体的message中，最后再将结构体存储到一个集合vector中。
Linux网络编程：TCP/UDP套接字与多播功能详解
Linux网络编程涉及协议选择、套接字创建和操作、地址转换、通信模式选择（单播、多播、广播）等多个方面，熟练掌握这些知识对于开发网络应用至关重要。通过实践，可以构建出高效、可靠的网络通信系统。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值