Linux网络编程

最新推荐文章于 2024-07-11 08:57:39 发布
最新推荐文章于 2024-07-11 08:57:39 发布
阅读量855 收藏 23
点赞数 25
分类专栏： Linux高级编程 文章标签： 网络 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bronya_a/article/details/136519261
版权

进程间的通信：

同一主机内通信
       传统的进程间通信方式（管道（有名，无名），信号）

       IPC对象（共享内存，消息队列，信号量（灯）集）

不同主机间通信

TCP编程基础知识：

1、网络基础 ===》A B C D E 类

IP地址 == 网络位 + 主机位

IP地址的分类: 点分十进制   ipv4

A类       0.    -127.

B类        128. -191.

C类       192. -223.

网关（局域网 门gate）    主机号全是 0（最后一位是1） 子网掩码（全是 0 网络号）

广播                                   主机号全是 255 会给全部网发送信息

端口号：

       编号---16位的数据

       2个字节

       0~65535//65536个数字

作用：

       用来标识 计算机中 用于通信的 某个进程

       IP+端口号==》网络中通信的进程//地址

       通信 两端

       源IP + 源端口 《==》目标IP + 目标端口

通信的四元组

网络链接：

物理层面：有线—WiFi—宽带（光纤）--

网络编程

       open system interconnect

1、OSI 模型  ===》开放系统互联模型  ==》分为7层：

       理想模型  ==》尚未实现

              tftp

              b  /etc/passwd

              a /etc/123

              应用层 

              表示层  加密解密  gzip

              会话层  网络断开，连接状态，keep-close keep-alive

              传输层tcp  udp  协议  文件    视频，音频  ipx

              网络层ip   NAT

              链路层  交换机  数据的格式化  帧 校验

              物理层         100Mb/8  10Gbits   100MB 同轴电缆

              （物理层              发送的是 比特流）

                                   尾|1010 0100|头   ---帧格式

OSI         七层体系结构

IP---->网卡（mac地址）//ip地址 向 mac 地址转换的功能

RARP      //反向

TCP: Transmission Control Protocol(类似 打电话)

特点：1.面向连接  2.可靠传输 3.字节流

面向连接（就是在进行通信之前，必须建立好一条逻辑上的通路）

提供可靠传输（四个“无”，无丢失、无失序、无时差、无重复）

建立连接：

tcp三次握手 目的：建立连接

client      --------------------------   server

1            -------我要通话---------->  1

2            <------恩，你可以--------    2

3            --------恩，好的-------->    3

UDP:（类似 生活中的广播 直播）

特点：1.无连接    2.不可靠       3.数据报

              不提供可靠传输，在数据发送时，不需要建立连接

应用：

（1）、小数据，但是对速度要求较高（qq、及时文本信息、语音等）

（2）、广播、组播

（3）、无线网的传输

socket

  1. socket 函数接口-系统调用
  2. socket 是一种特殊的文件 专门用来 用于“网络通信”

eg：fifo---用于同一主机内的进程间

        socket 用于不同主机间进程的通信

  1. socket是网络通信中，抽象出来的

客户端：

       socket           //买了一部手机

       bind       //可选    socket 绑定 一个 sim卡

       connect         //拨打电话

       write

       read

       close

服务器端

       socket           //买了一部手机

       bind              //绑定 一个 sim卡

       listen             //待机 – 来电了

       accept           //接听电话

       write

       read

       close

socket

int socket(int domain, int type, int protocol);

功能：创建一个新的套接字，用于网络通信。

参数：   @domain      指定套接字的协议族，常见的协议族有AF_INET（IPv4 地址族）、AF_INET6（IPv6 地址族）、AF_UNIX（UNIX 域套接字）等。

@type           指定套接字的类型，常见的类型有SOCK_STREAM（流套接字，用于 TCP）和 SOCK_DGRAM（数据报套接字，用于 UDP）等。

@protocol     指定使用的协议，通常可以传入‘0’，表示让系统根据‘domain’和‘type’参数选择合适的协议。

返回值：       成功       返回       新创建的套接字的文件描述符(File Descriptor)

                     失败       返回       ‘-1’，并设置全局变量errno表示错误原因

connect

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

功能：          连接到远程套接字。

参数：          @ sockfd：要连接的本地套接字的文件描述符。

                     @ addr：指向远程套接字地址结构的指针，

通常是 struct sockaddr 类型的指针

@ addrlen：远程套接字地址结构的长度。

返回值：       如果连接成功，返回 0；

如果出现错误，返回 -1，并设置全局变量 errno 表示具体的错误原因。

bzero

void bzero(void *s, size_t n);

功能：          将指定的内存区域清零，即将该区域内的每个字节都设置为零  
参数：          @ s：指向要清零的内存区域的指针。

                     @ n：要清零的字节数。

返回值：       bzero 函数没有返回值。

inet_addr

in_addr_t inet_addr(const char *cp);

功能：          用于将点分十进制格式的 IPv4 地址转换为网络字节序的二进制格式。

参数：          @ cp：指向点分十进制格式的 IPv4 地址字符串的指针。

返回值：       如果转换成功，则返回一个 in_addr_t 类型的值，该值是网络字节序表示的 IPv4 地址。

如果转换失败，则返回 INADDR_NONE，它是一个特殊的常量，表示转换失败。

bind

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

功能：          将一个地址绑定到一个套接字。

参数：          @ sockfd：套接字描述符，用于标识要绑定地址的套接字。

                     @ addr：指向 struct sockaddr 结构的指针，包含要绑定到套接字的地址信息。

                     @ addrlen：addr 结构的大小（以字节为单位）。

返回值：       执行成功时返回0，

执行失败时返回-1，并设置全局变量 errno 来指示错误的原因。

listen

int listen(int sockfd, int backlog);

功能：          将套接字标记为被动套接字，用于接受连接请求。

参数：          @ sockfd：套接字描述符，用于标识要监听的套接字。

                     @ backlog：指定待处理连接队列的最大长度。

当已建立连接数达到 backlog 时，新的连接将被拒绝或排队等待处理。

返回值：       执行成功时返回0

                        执行失败时返回-1，并设置全局变量 errno 来指示错误的原因。

accept

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

功能：          接受对于绑定到套接字的连接请求，并创建一个新的套接字用于通信。

参数：          @ sockfd：表示服务器套接字的文件描述符，用于标识要接受连接的套接字。

@ addr：指向结构体 sockaddr 的指针，用于存储连接方的地址信息。如果不需要此信息，可以将其设置为 NULL。

                     @ addrlen：表示 addr 指向的地址结构体的长度。

返回值：       若成功则返回一个非负整数，表示新的套接字的文件描述符；

若失败则返回-1，同时设置全局变量 errno 表示错误原因。

创造一个client端

创造一个serve端

通过网络传输文件

客服端：

       socket

       connect

//step1   先把文件名发过去

       struct msg dt;

       dt.len = -1;

       strcpy(dt.data,argv[3]);

       write(fd,&dt,sizeof(struct msg));

close

服务器：

       socket

       bind

       listen

       accept

//接受文件名

tcp 粘包       问题

  1. 手动加一个    分隔符号

buf[ ] = {“1.txt”@#include<stdio.h>}

  1. 指定每次传输的长度    /每次发固定的长度

buf[ ] = { }//10个字节

  1. 用结构体

struct msg
{

        int len;

        char data[256];

};

struct msg dt;

write(fd,&dt,sizeof(struct msg));

struct msg rdt

       read(fd,&rdt,sizeof(struct msg));

recv

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

功能：          从已连接的套接字接收消息。

参数：          @sockfd：已连接的套接字描述符。

                     @buf：用于存储接收到的数据的缓冲区的指针。

                     @len：缓冲区的大小，即要接收的数据的最大字节数。

                     @flags：接收操作的标志，通常为 0 表示阻塞接收

返回值：       成功       返回       接收到的字节数，

错误       则返回   -1。

send

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

功能：          用于发送数据到已连接的套接字

参数：          @sockfd：套接字描述符，指定要发送数据的套接字。

                     @buf：指向要发送数据的缓冲区的指针。

                     @len：要发送的数据的长度，以字节为单位。

@flags：用于控制发送操作的标志位，具体取值取决于系统和网络协议的实现。通常情况下，可以将其设置为 0，表示不启用任何特殊的选项或标志。

返回值          成功       返回       发送的字节数，

错误       返回       -1。

网络编程之 UDP

  1. 特性： 无链接  2.不可靠  3.大数据  
  2. 框架： C/S模式

 server：socket() ===>bind()===>recvfrom()===>close()

 client：socket() ===>bind()===>sendto() ===>close()

recvfrom

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,

struct sockaddr *src_addr, socklen_t *addrlen);

功能：          用于UDP协议中获取对方发送的数据。

参数：          @sockfd 本地的套接字id

                     @buff   要存储数据的内存区，一般是数组或者动态内存。

                     @len    要获取的数据长度，一般是buff的大小。

                     @flags  获取方式，0 阻塞

                     @src_addr 可选，表示对方的地址信息结构体，

如果为NULL，表示不关心对方地址。

                     @addrlen  对方地址信息结构体大小。

                                 如果对方地址是NULL，则该值也为NULL。

返回值：       成功      接收到的数据长度

                     失败     -1；      

sendto

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,

                const struct sockaddr *dest_addr, socklen_t addrlen);

功能：          用于UDP协议中向对方发送数据。

参数：          @sockfd  本地的套接字id

                     @buff    本地的数据存储，一般是要发送的数据。

@len     要发送的数据长度

@flags   要发送数据方式，0 表示阻塞发送。

                 @dest_addr: 必选，表示要发送到的目标主机信息结构体。

                     @addrlen ：目标地址长度。

返回值：       成功     发送的数据长度

                 失败     -1；

代码练习

e1用TCP的方式在client 和 server间进行点对点收发信息

//TCP client 端
#include <stdio.h>    
#include <sys/types.h>	    
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(int argc, const char *argv[])
{
	int fd = socket(AF_INET,SOCK_STREAM,0);

	if(fd < 0)
	{
		perror("socket fail");
		return -1;
	}

	printf("fd = %d\n",fd);

	struct sockaddr_in seraddr;
	bzero(&seraddr,sizeof(seraddr));
	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(50002);
	seraddr.sin_addr.s_addr = inet_addr("192.168.1.3");

	if(connect(fd,(const struct sockaddr*)&seraddr,sizeof(seraddr)) < 0)
	{
		perror("connect fail");
		return -1;
	}
	pid_t pid;
	pid = fork();
	if(pid > 0)
	{
		while(1)
		{
			char buf[1024] = {0};
			scanf("%s",buf);
			write(fd,buf,strlen(buf));
			if(strncmp(buf,"quit",4) == 0)
			{
				return 0;
			}
		}
	}
	if(pid == 0)
	{
		while(1)
		{
			char ch[1024] = {0};
			read(fd,ch,sizeof(ch));
			if(strncmp(ch,"quit",4) == 0)
			{
				return 0;
			}
			char resend[1024] = {0};
			sprintf(resend,"ser: %s\n",ch);
			//write(connfd,resend,sizeof(resend));
			write(1,resend,sizeof(resend));
		}
	}

	return 0;
}



//TCP server端
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>


int main(int argc, const char *argv[])
{
	int fd = socket(AF_INET,SOCK_STREAM,0);
	if(fd < 0)
	{
		perror("socket fail");
		return -1;
	}

	struct sockaddr_in seraddr;
	bzero(&seraddr,sizeof(seraddr));
	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(50002);
	seraddr.sin_addr.s_addr = inet_addr("192.168.1.3");

	if(bind(fd,(const struct sockaddr*)&seraddr,sizeof(seraddr)) < 0)
	{
		perror("bind fail");
		return -1;
	}

	if(listen(fd,5) < 0)
	{
		perror("listen fail");
		return -1;
	}

	int connfd = 0;
	struct sockaddr_in cliaddr;
	bzero(&cliaddr,sizeof(cliaddr));
	socklen_t len = sizeof(cliaddr);
	char ch[1024] = {0};
	char sh[1024] = {0};

	if((connfd = accept(fd,(struct sockaddr *)&cliaddr,&len)) < 0)
	{
		perror("accept fail");
		return -1;
	}
	printf("connfd = %d\n",connfd);
	puts("-----------------------");
	printf("ip = %s\n",inet_ntoa(cliaddr.sin_addr));
	printf("port = %d\n",ntohs(cliaddr.sin_port));
	puts("-----------------------");
	pid_t pid = fork();
	if(pid < 0)
	{
		perror("fork error");
		return -1;
	}
	if(pid > 0)
	{
		while(1)
		{
			char ch[1024] = {0};
			read(connfd,ch,sizeof(ch));
			if(strncmp(ch,"quit",4) == 0)
			{
				return 0;
			}
			char resend[1024] = {0};
			sprintf(resend,"cli: %s\n",ch);
			//write(connfd,resend,sizeof(resend));
			write(1,resend,sizeof(resend));
		}
	}
	if(pid == 0)
	{
		while(1)
		{
			char buf[1024] = {0};
			scanf("%s",buf);
			write(connfd,buf,strlen(buf));
			if(strncmp(buf,"quit",4) == 0)
			{
				return 0;
			}
		}
	}

	
	return 0;
}

e2.用udp的方式进行点对点聊天

//udp client端
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/wait.h>
#include <pthread.h>
#include <errno.h>


struct sockaddr_in seraddr;

void *do_recv(void *p)
{
	char buf[1024] = {0};
	int *fd = p;
	while(1)
	{
		recvfrom(*fd,buf,sizeof(buf),0,NULL,NULL);
		printf("ser:%s",buf);
		if(strncmp(buf,"quit",4) == 0)
		{
			exit(0);
		}
	}
}

void *do_send(void *p)
{
	char buf[1024] = {0};
	int *fd = p;
	while(1)
	{
		fgets(buf,sizeof(buf),stdin);
		sendto(*fd,buf,sizeof(buf),0,(const struct sockaddr*)&seraddr,sizeof(seraddr));
		if(strncmp(buf,"quit",4) == 0)
		{
			exit(0);
		}
	}
}

int main(int argc, const char *argv[])
{
	//socket
	int fd = socket(AF_INET,SOCK_DGRAM,0);//创造了一个udp协议的socket
	if(fd < 0)
	{
		perror("socket fail");
		return -1;
	}

//	struct sockaddr_in seraddr;
	bzero(&seraddr,sizeof(seraddr));
	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(50002);
	seraddr.sin_addr.s_addr = inet_addr("192.168.1.3");

	pthread_t tid[2];
	void *(do_something)[2] = {do_recv,do_send};
	int i = 0;
	int ret = 0;
	for(i = 0; i < 2; ++i)
	{
		ret = pthread_create(&tid[i],NULL,do_something[i],&fd);
		if(ret != 0 )
		{
			errno = ret;
			perror("pthread_create fail");
			return -1;
		}
	}

	pthread_exit(NULL);

	return 0;
}



//udp server端
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/wait.h>
#include <pthread.h>
#include <errno.h>

struct sockaddr_in cliaddr;
socklen_t len;

void do_recv(void *p)
{
	char buf[1024] = {0};
	int *fd = p;
	while(1)
	{
		recvfrom(*fd,buf,sizeof(buf),0,(struct sockaddr*)&cliaddr,&len);
		printf("cli:%s",buf);
		if(strncmp(buf,"quit",4) == 0)
		{
			exit(0);
		}
	}
}

void do_send(void *p)
{
	char buf[1024] = {0};
	int *fd = p;
	while(1)
	{
		fgets(buf,sizeof(buf),stdin);
		sendto(*fd,buf,strlen(buf) + 1,0,(const struct sockaddr*)&cliaddr,sizeof(cliaddr));
		if(strncmp(buf,"quit",4) == 0)
		{
			exit(0);
		}
	}
}

int main(int argc, const char *argv[])
{
	int fd = socket(AF_INET,SOCK_DGRAM,0);
	if(fd < 0)
	{
		perror("socket fail");
		return -1;
	}

	struct sockaddr_in seraddr;
	bzero(&seraddr,sizeof(seraddr));
	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(50002);
	seraddr.sin_addr.s_addr = inet_addr("192.168.1.3");

	if(bind(fd,(const struct sockaddr*)&seraddr,sizeof(seraddr)) < 0)
	{
		perror("bind fail");
		return -1;
	}
	
	char buf[1024] = {0};
	bzero(&cliaddr,sizeof(cliaddr));
	len = sizeof(cliaddr);
	
	recvfrom(fd,buf,sizeof(buf),0,(struct sockaddr*)&cliaddr,&len);
	printf("IP = %s\n",inet_ntoa(cliaddr.sin_addr));
	printf("PORT = %d\n",ntohs(cliaddr.sin_port));
	puts("--------------------------");
	
	void *do_something[2] = {do_recv,do_send};
	int i = 0, ret = 0;
	pthread_t tid[2];
	for(i = 0; i < 2; ++i)
	{
		ret = pthread_create(&tid[i],NULL,do_something[i],&fd);
		if(ret != 0)
		{
			errno = ret;
			perror("pthread_create fail");
			return -1;
		}
	}

	pthread_exit(NULL);
	
	return 0;
}

Bronya_a
关注
  • 25
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux 网络编程
qq_39855356的博客
09-16 4310
linux系统编程-网络编程
Linux网络编程，包括tcp/upd，select/poll/epoll/pdf
04-14
linux网络编程 pdf # Linux网络编程基础 Linux网络编程是指在Linux操作系统上开发网络应用程序的过程。它主要涉及到TCP/UDP协议以及select/poll/epoll等多路复用技术。 TCP/UDP协议是网络通信的基础，其中TCP协议...
linux网络编程
m0_72749070的博客
09-03 5422
自学笔记整理，如有不对，请指正
Linux网络编程（2024超级详细、Linux）
嵌入式学习者(学生)
01-05 1539
本文是作者在学习linux网络编程的时候所写的学习笔记，同时方便巩固自己学习的知识和网友们一起分享，尚若发现有什么不对的地方，欢迎指正。
Linux网络编程——UDP编程
weixin_52109967的博客
08-15 2544
UDP通信的相关函数和实际案例代码。
Linux网络编程 | UDP编程
大柳_的博客。
06-01 2720
浅谈UDP。UDP是一种不可靠的、无连接的、数据报服务。发送端应用程序每执行一次写操作，UDP 模块就将其封装成一个 UDP 数据报发送。接收端必须及时针对每一个 UDP 数据报执行读操作，否则就会丢包。并且，如果用户没有指定足够的应用程序缓冲区来读取 UDP 数据，则 UDP 数据将被截断。 因此，采用UDP协议时必须要求接收端可以一次性收取完发送端一次发送的数据，不然就会造成数据丢失。 2.客户端 3.输出结果 UDP是一种无连接的传输方式，所以可以多个客户端同时发送。 服务器端关闭立马重启，客户
Linux网络编程之TCP编程
qq_54402650的博客
09-17 2360
socket网络编程 ;TCP提供面向连接的，一对一的可靠传输的协议;UDP提供不可靠，无连接的传输协议,实现TCP多进程和多线程的并发服务器，冲冲冲！
Linux网络编程_01_网络基础
柿子__
07-19 1374
Linux网络编程-网络基础
Linux 网络编程学习笔记——四、HTTP 通信
热门推荐
BeZer0的学习笔记
03-22 1万+
在 HTTP 通信链上，客户端和目标服务器之间通常存在某些中转代 理服务器，它们提供对目标资源的中转访问。一个 HTTP 请求可能被多个代理服务器转发，后面的服务器称为前面服务器的上游服务器。
Linux网络编程 | TCP详解
大柳_的博客。
06-01 3353
总结TCP相关问题TCP是一种面向链接的，可靠的，流式服务。TCP 字节流的特点，发送端执行的写操作次数和接收端执行的读操作次数之间没有任何数量关系，应用程序对数据的发送和接收是没有边界限制的。 此时可以看到 此时可以看到，发送端分别发送了hello world linux，而在接收端一次性收取完成，无法有效区分出三个单词，这就造成粘包问题 解决方法： 1.发送端每次发送之后要收到接收端的回复再进行下一次发送 2.制定协议，比如长宽高分别用【长】【宽】【高】表示。可靠性： 超时重传，应答确认，乱序重排流量控
SRS流媒体源码解析--service
weixin_54423699的博客
07-10 439
（1）对线程/协程的API的抽象// 存储线程的句柄// 条件变量// 锁// 获取线程/协程句柄// 条件变量操作// 创建一个新的条件变量实例// 销毁给定的条件变量// 使当前线程等待条件变量cond。线程会释放锁并阻塞，直到其他线程通过srs_cond_signal或srs_cond_broadcast唤醒它// 带超时的等待版本，如果在指定的timeout时间内条件未被满足，则函数会返回。// 唤醒一个等待在条件变量cond上的线程。
Mac虚拟机跑Windows流畅吗 Mac虚拟机连不上网络怎么解决 mac虚拟机网速慢怎么解决
2401_82916694的博客
07-10 578
选择Shared模式，你的Mac会当作虚拟机的路由器。一般来说，拥有更高性能的Cpu（如Apple M2或M3芯片）、更大的内存（建议16GB以上）、以及足够的存储空间可以显著提升虚拟机中Windows的运行流畅度。Mac的防火墙或其他安全设置可能阻止虚拟机访问网络，如果你的Mac主机可以访问网络，并且排查了上文介绍的情况，那么可以尝试关闭Mac电脑防火墙，再检查虚拟机是否可以连接网络。使用Mac虚拟机运行Windows是否流畅，取决于几个关键因素：硬件配置、虚拟机软件的选择以及虚拟机的设置。
从零开始做题：logtime
weixin_44626085的博客
07-10 236
给出1个pcapng文件。
YOLOv10改进 | 特殊场景检测篇 | 轻量级的低照度图像增强网络IAT改进YOLOv10暗光检测（全网独家首发）
Snu77的博客
07-11 6305
本文给大家带来的改进机制是轻量级的变换器模型：Illumination Adaptive Transformer (IAT)，用于图像增强和曝光校正。其基本原理是通过分解图像信号处理器（ISP）管道到局部和全局图像组件，从而恢复在低光或过/欠曝光条件下的正常光照sRGB图像。具体来说，IAT使用注意力查询来表示和调整ISP相关参数，例如颜色校正、伽马校正。模型具有约90k参数和约0.004s的处理速度，能够在低光增强和曝光校正的基准数据集上持续实现优于最新技术（State-of-The-Art, SOTA）
Zabbix自动发现
Lzcsfg的博客
07-08 748
在 Zabbix 中，自动发现（Auto Discovery）是一种强大的功能，用于自动识别和监控网络设备、服务或应用程序中的动态变化。通过自动发现功能，Zabbix 可以自动添加、配置和监控新的网络节点或服务，大大简化了管理和监控大规模环境的复杂性。
访问控制的定义与原理
最新发布
SafePloy_SH的博客
07-11 186
访问控制(Access Control)是一种重要的安全机制，用于限制对程序中的数据、函数、类以及计算机系统中资源(如文件、数据库、网络设备等)的访问权限。其主要目的是保护系统中的敏感信息和资源，防止未经授权的访问和操作，确保系统的安全性、完整性和可靠性。综上所述，访问控制是保障系统安全的重要手段之一，它通过限制用户对资源的访问权限来防止未经授权的访问和操作。允许用户对自身所创建的访问对象(如文件、数据表等)进行访问，并可将对这些对象的访问权授予其他用户或收回其访问权限。
UDP协议介绍和作用
小蜜蜂vs码农
07-10 1035
UDP协议介绍和作用
Linux 网络编程
06-22
Linux网络编程是指在Linux操作系统环境中进行的网络应用程序开发。它涉及利用内核提供的API（Application Programming Interface）和库函数，来创建能够与网络进行交互的程序，如服务器、客户端、协议解析器等。Linux网络编程主要围绕以下几个关键概念： 1. **套接字（Sockets）**：是网络编程的基本抽象，提供了应用程序与网络通信的接口。套接字是一个描述进程间通信资源的抽象概念。 2. **网络协议栈**：Linux使用TCP/IP协议栈，包括用户空间的库（如libpcap和socket API）和内核空间的协议实现，如IP、TCP、UDP等。 3. **网络编程模型**：通常有两种模型：面向连接（如TCP）和无连接（如UDP）。面向连接的通信更可靠，但设置连接过程较慢；无连接通信速度较快，但数据可能会乱序或丢失。 4. **网络库函数**：如`bind()`、`listen()`, `accept()`, `send()`, `recv()`, `select()`等，用于执行各种网络操作。 5. **多路复用I/O**：通过`epoll`, `kqueue`, `select/poll`等机制，提高网络程序的性能，同时处理多个套接字事件。 6. **网络编程安全**：包括认证（如SSL/TLS）、授权（访问控制）、防火墙规则等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值