Linux网络异常处理（6.12）

最新推荐文章于 2024-09-21 11:01:19 发布
最新推荐文章于 2024-09-21 11:01:19 发布
阅读量1k 收藏
点赞数
分类专栏： Linux网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haoge921026/article/details/46522879
版权
本文详细解析了网络异常处理策略，包括客户端和服务端的异常情况处理方法，以及实现心跳包的方法。同时，文章深入介绍了广播和组播的原理、流程和使用方法，包括如何接收和发送广播消息及组播消息。通过实例代码展示了如何在不同场景下应用这些网络技术，旨在提升开发者在网络编程领域的实践能力。
摘要由CSDN通过智能技术生成
[1] 网络异常处理
    1. 客户端出了问题(死机、重启了、网络断了...)
    2. 服务端出了问题(死机、重启了、网络断了、内存耗尽、...)
    3. 网络不正常
    
    解决办法: 心跳包
    
    心跳包的实现方法:
    1. 利用TCP协议的KeepAlive(TCP协议实现的心跳包)
       见《tcp_keepalive》的服务端
       
    2. 设置接收超时检测心跳，对端需要定时发送
       heart_beat程序只在接收端实现了如何(利用阻塞超时)检测超时
       
    3. 如何实现应用程序的定时发送和超时检测?
       alarm
    
    总结: 利用实现心跳包
    
[2] 广播

    1. 接收端流程

//       (1) 创建套接字
           sockfd = socket(AF_INET, SOCK_DGRAM, 0);
           
//       (2) 绑定IP和端口到socket
           struct sockaddr_in addr;
           
           bzero(&addr, sizeof(addr));
           addr.sin_family = AF_INET;
           addr.sin_port = htons(port);
           addr.sin_addr.s_addr = inet_addr(ip);
           // addr.sin_addr.s_addr = INADDR_ANY;
           
           ret = bind(sockfd, (struct sockaddr *)&addr, sizeof(addr));
           
//       (3) 接收
           struct sockaddr_in peer_addr;
           socklen_t addrlen = sizeof(peer_addr);
           
           ret = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&peer_addr, &addrlen);
           
//       (3) 关闭
           close(sockfd);
    2. 发送端流程 
//       (1) 创建套接字
           sockfd = socket(AF_INET, SOCK_DGRAM, 0);
           
//       (2) 设置套接字，使能广播
           int on = 1;
           
           ret = setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
           if (-1 == set){
             
           }
           
           SOL_SOCKET:          //设置的选项在socket层
           SO_BROADCAST:        //设置是否允许广播 0 - 不能 1-可以
           
//       (3) 通过广播地址发送广播
           struct sockaddr_in broad_addr;
           
           bzero(&broad_addr, sizeof(broad_addr));
           broad_addr.sin_family = AF_INET;
           broad_addr.sin_port = htons(port);
           broad_addr.sin_addr.s_addr = inet_addr//(一定填广播(192.168.0.255));
           
           ret = sendto(sockfd, buf, len, 0, (struct sockaddr *)&broad_addr, sizeof(broad_addr));
           
//       (4) 关闭
           clos(sockfd);

[3] 组播        
    1. 分组
       每个D类IP地址就是一个组，组播实现原理:
       接收 -- 加入一个组
       发送 -- 向一个组(目标IP地址为组播地址)发送数据包  
       
    2. 组播地址(IP地址和网卡地址)
       IP地址: D类地址 ，高位固定为1110，范围: 224.0.0.0-239.255.255.255
       网卡地址: 前24bit固定为01-00-5e, 最后23bit是D类IP地址的后23bit直接映射下来 -- 仅仅正对于以太网
       
    3. 接收流程 

//       (1) 创建套接字
           sockfd = socket(AF_INET, SOCK_DGRAM, 0);
           
//       (2) 加入组
           struct ip_mreq mreq;
           mreq.imr_multiaddr.s_addr = inet_addr(argv[1]);  // "224.10.10.1"
           mreq.imr_interface.s_addr = INADDR_ANY;
           
           ret = setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
           
//       (3) 绑定IP地址和端口
           struct sockaddr_in addr;
           
           bzero(&addr, sizeof(addr));
           addr.sin_family = AF_INET;
           addr.sin_port = htons(port);
           addr.sin_addr.s_addr = inet_addr(ip);
           // addr.sin_addr.s_addr = INADDR_ANY;
           
           ret = bind(sockfd, (struct sockaddr *)&addr, sizeof(addr));
           
//       (4) 接收
           struct sockaddr_in peer_addr;
           socklen_t addrlen = sizeof(peer_addr);
           
           ret = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&peer_addr, &addrlen);
           
//       (3) 关闭
           close(sockfd);
    4. 发送流程 
//       (1) 创建套接字
           sockfd = socket(AF_INET, SOCK_DGRAM, 0);
           
//       (2) 发送
           struct sockaddr_in muticast_addr;
           
           bzero(&muticast_addr, sizeof(muticast_addr));
           muticast_addr.sin_family = AF_INET;
           muticast_addr.sin_port = htons(port);
           muticast_addr.sin_addr.s_addr = inet_addr//(一定填多播(224.10.10.1));
           
           ret = sendto(sockfd, buf, len, 0, (struct sockaddr *)&broad_addr, sizeof(broad_addr));
           
//       (3) 关闭
           close(sockfd);

send.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <strings.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

// ./send 192.168.0.255 8888
int main(int argc, const char *argv[])
{
	int ret;
	int sockfd;
	int on = 1;
	char packet[1024];
	struct sockaddr_in broad_addr;
	
	if (argc < 3){
		fprintf(stderr, "Usage: %s <broadcast ip> <port>\n", argv[0]);
		exit(EXIT_FAILURE);
	}
	
	// 1. 创建报文套接字
	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (-1 == sockfd){
		perror("Fail to socket.");
		exit(EXIT_FAILURE);
	}
	
	// 2. 设置套接字广播属性
  ret = setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
  if (-1 == ret){
  	perror("Fail to setsockopt.");
  	exit(EXIT_FAILURE);
  }
  
  // 3. 通过广播地址发送数据包到指定端口
	bzero(&broad_addr, sizeof(broad_addr));
	broad_addr.sin_family = AF_INET;
	broad_addr.sin_port = htons(atoi(argv[2]));
	broad_addr.sin_addr.s_addr = inet_addr(argv[1]);
	
	while (1){
		putchar('\n');
		putchar('>');
		fgets(packet, sizeof(packet), stdin);
		packet[strlen(packet) - 1] = '\0';
		
		ret = sendto(sockfd, packet, strlen(packet), 0, (struct sockaddr *)&broad_addr, sizeof(broad_addr));
		if (-1 == ret){
			perror("Fail to sendto.");
  		break;
		}
		
		if (strcmp(packet, "quit") == 0){
			break;
		}
	}
	
	// 4. 关闭套接字
	close(sockfd);
	
	return 0;
}
recv.c 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <strings.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

// ./recv 192.168.2.255 8888
int main(int argc, const char *argv[])
{
	int ret;
	int sockfd;
	char packet[1024];
	struct sockaddr_in broad_addr;
	struct sockaddr_in peer_addr;
	socklen_t addrlen = sizeof(peer_addr);
	
	if (argc < 3){
		fprintf(stderr, "Usage: %s <broadcast ip> <port>\n", argv[0]);
		exit(EXIT_FAILURE);
	}
	
	// 1. 创建报文套接字
	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (-1 == sockfd){
		perror("Fail to socket.");
		exit(EXIT_FAILURE);
	}
	
	// 2. 绑定广播地址和端口
	bzero(&broad_addr, sizeof(broad_addr));
	broad_addr.sin_family = AF_INET;
	broad_addr.sin_port = htons(atoi(argv[2]));
	// broad_addr.sin_addr.s_addr = inet_addr(argv[1]);
	broad_addr.sin_addr.s_addr = INADDR_ANY;
	
	ret = bind(sockfd, (struct sockaddr *)&broad_addr, sizeof(broad_addr));
	if (-1 == ret){
		perror("Fail to bind.");
		exit(EXIT_FAILURE);
	}
	
	while (1){
		// 3. 接收广播
		ret = recvfrom(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&peer_addr, &addrlen);
		if (-1 == ret){
			perror("Fail to recvfrom.");
			break;
		}
		packet[ret] = '\0';
		
		printf("---------------------------------------\n");
		printf("ip       : %s\n", inet_ntoa(peer_addr.sin_addr));
		printf("port     : %d\n", ntohs(peer_addr.sin_port));
		printf("recv(%d)  : %s\n", ret, packet);
		printf("---------------------------------------\n");
		if (strcmp(packet, "quit") == 0){
			break;
		}
	}
	
	// 4. 关闭套接字
	close(sockfd);
	
	return 0;
}

[3] unix域套接字--流式

    1. 头文件
       #include <sys/un.h>
       
    2. 数据结构
       struct sockaddr_un {
        sa_family_t sun_family;
         // __SOCKADDR_COMMON (sun_);
         
        // #define __SOCKADDR_COMMON(sa_prefix) \                                                              
        // sa_family_t sa_prefix##family     
         // 替换原理，带参数的宏，实参替换形参(整个宏中所有的) 
                                                                   
         char sun_path[108]; // 字符串(unix域套接字文件的名)
       };


    3. 服务端流程
       1. 创建套接字
          sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
          
       2. 绑定地址到socket
struct sockaddr_un server_addr;

server_addr.sun_family = AF_UNIX;
strcpy(server_addr.sun_path, "mypath");

ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));

3. 设置为监听模式
   ret = listen(sockfd, 10);
   
4. 接收请求
   clientfd = accept(sockfd, NULL, NULL);
      
5. 接收数据
   ret = recv(clientfd, buf, sizeof(buf), 0);
   
6. 发送数据
   ret = send(clientfd, buf, len, 0);
   
7. 关闭套接字
   close(clientfd);
   close(sockfd);
   
4. 客户端流程
  1. 创建套接字
          sockfd = socket(AF_UNIX, SOCK_STREAM, 0);

server.c

/*
 * 实现目标:
 * UNIX域套接字通讯
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <pthread.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/un.h>

void *handler(void *arg)
{
	int ret = 0;
	int clientfd = (int)(long int)arg;
	char packet[1024];
	
	while (1){
		// 5. 接收数据
		ret = recv(clientfd, packet, sizeof(packet), 0);
		if (-1 == ret){
			perror("Fail to accept.");
			break;
		}
		packet[ret] = '\0';
		
		printf("--------------------------------\n");
		printf("recv(%d): %s\n", ret, packet);
		printf("--------------------------------\n");
		if (strcmp(packet, "quit") == 0){
			break;
		}
		
	}
	
	// 6. 关闭套接字
	close(clientfd);
	
	return (void *)0;
}


// ./server mypath
int main(int argc, const char *argv[])
{
	int ret;
	int sockfd;
	int clientfd;
	pthread_t tid;
	char packet[1024];
	struct sockaddr_un server_addr;
	
	if (argc < 2){
		fprintf(stderr, "Usage: %s <path>\n", argv[0]);
		exit(EXIT_FAILURE);
	}
	
	// 1. 创建套接字
	sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
	if (-1 == sockfd){
		perror("Fail to socket.");
		exit(EXIT_FAILURE);
	}
	
	// 2. 绑定地址
	server_addr.sun_family = AF_UNIX;
	strcpy(server_addr.sun_path, argv[1]);
	
	ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret){
		perror("Fail to bind.");
		exit(EXIT_FAILURE);
	}
	
	// 3. 设置为监听模式
	ret = listen(sockfd, 10);
	if (-1 == ret){
		perror("Fail to listen.");
		exit(EXIT_FAILURE);
	}
	
	while (1){
		// 4. 接收连接请求
		clientfd = accept(sockfd, NULL, NULL);
		if (-1 == clientfd){
			perror("Fail to accept.");
			exit(EXIT_FAILURE);
		}
		printf("--------------------------------\n");
		printf("accept a client\n");
		printf("--------------------------------\n");
	
    pthread_create(&tid, NULL, handler, (void *)(long int)clientfd);
    pthread_detach(tid);
	}
	
	// 6. 关闭套接字
	close(sockfd);
	unlink(argv[1]);
	
	return 0;
}
client.c 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <errno.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/un.h>

// ./client "mypath"
int main(int argc, const char *argv[])
{
	int ret = 0;
	int sockfd;
	char packet[1024];
	struct sockaddr_un server_addr;
	
	if (argc < 2){
		fprintf(stderr, "Usage: %s <path>\n", argv[0]);
		exit(EXIT_FAILURE);
	}
	
	// 1. 创建监听socket
	sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
	if (-1 == sockfd){
		perror("Fail to socket.");
		exit(EXIT_FAILURE);
	}
	
	// 2. 连接服务端(connect)
	server_addr.sun_family = AF_UNIX;
	strcpy(server_addr.sun_path, argv[1]);
	
	ret = connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret){
		perror("Fail to connect.");
		exit(EXIT_FAILURE);
	}
	
	while (1){
		putchar('\n');
		putchar('>');
		fgets(packet, sizeof(packet), stdin);
		packet[strlen(packet) - 1] = '\0';
		
		// 3. 发送(写)
		ret = send(sockfd, packet, strlen(packet), 0);
		if (-1 == ret){
			perror("Fail to connect.");
			exit(EXIT_FAILURE);
		}
		
		/* 4. 接收(读)
		ret = recv(sockfd, packet, sizeof(packet), 0);
		if (-1 == ret){
			perror("Fail to connect.");
			exit(EXIT_FAILURE);
		}
		packet[ret] = '\0';
		
		printf("--------------------------------\n");
		printf("recv(%d) : %s\n", ret, packet);
		printf("--------------------------------\n");*/
		
		if (strcmp(packet, "quit") == 0) break;
	}
	
	// 5. 关闭套接字
	close(sockfd);
	
	
	return 0;
}


          
       2. 连接服务器
          struct sockaddr_un server_addr;

server_addr.sun_family = AF_UNIX;
strcpy(server_addr.sun_path, "mypath");

ret = connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));

  3. 发送数据
   ret = send(clientfd, buf, len, 0);
   
4. 接收数据
   ret = recv(clientfd, buf, sizeof(buf), 0);
   
5. 关闭套接字
   close(sockfd);
  
[3] unix域套接字--报文
    1. 客户端流程
       1. 创建套接字
          sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
          
       2. 绑定(自己)地址
          struct sockaddr_un self_addr;

self_addr.sun_family = AF_UNIX;
strcpy(self_addr.sun_path, "client_addr");

ret = bind(sockfd, (struct sockaddr *)&self_addr, sizeof(self_addr));

3. 发送/接收
   struct sockaddr_un server_addr;

server_addr.sun_family = AF_UNIX;
strcpy(server_addr.sun_path, "server_addr");

   ret = sendto(sockfd, buf, len, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
   
   
   // 接收
   struct sockaddr_un peer_addr;
   socklen_t addrlen = sizeof(peer_addr);
   
   ret = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&peer_addr, &addrlen);
   
4. 关闭套接字
   close(sockfd);
   unlink("client_addr");
       
    2. 服务端流程
       1. 创建套接字
          sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
          
       2. 绑定(自己)地址
          struct sockaddr_un self_addr;

self_addr.sun_family = AF_UNIX;
strcpy(self_addr.sun_path, "server_addr");

ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));

  3. 接收
     struct sockaddr_un peer_addr;
   socklen_t addrlen = sizeof(peer_addr);
   
   ret = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&peer_addr, &addrlen);
   

4. 发送
   ret = sendto(sockfd, buf, len, 0, (struct sockaddr *)&peer_addr, sizeof(peer_addr));
   
5. 关闭
   close(sockfd);
   unlink("server_addr");

client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <errno.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/un.h>

// ./server client_addr server_addr
int main(int argc, const char *argv[])
{
	int ret = 0;
	int sockfd;
	char packet[1024];
	struct sockaddr_un server_addr;
	struct sockaddr_un peer_addr;
	socklen_t addrlen = sizeof(server_addr);
	
	if (argc < 3){
		fprintf(stderr, "Usage: %s <client addr> <server addr>\n", argv[0]);
		exit(EXIT_FAILURE);
	}
	
	// 1. 创建套接字
	sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
	if (-1 == sockfd){
		perror("Fail to socket");
		exit(EXIT_FAILURE);
	}
	
  // 2. 绑定(自己)地址
	peer_addr.sun_family = AF_UNIX;
	strcpy(peer_addr.sun_path, argv[1]);
	
	ret = bind(sockfd, (struct sockaddr *)&peer_addr, sizeof(peer_addr));
	if (-1 == ret){
		perror("Fail to bind");
		exit(EXIT_FAILURE);
	}
	
	server_addr.sun_family = AF_UNIX;
	strcpy(server_addr.sun_path, argv[2]);
  
	while (1){
  
	  putchar('\n');
	  putchar('>');
	  fgets(packet, sizeof(packet), stdin);
	  packet[strlen(packet) - 1] = '\0';
	  
	  // 3. 发送(写)
	  ret = sendto(sockfd, packet, strlen(packet), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
	 	if (-1 == ret){
	 		perror("Fail to sendto.");
	 		break;
	 	}
	 	
	 	printf("-----------------------------\n");
	 	printf("send : %s\n", packet);
	 	printf("-----------------------------\n");
	 	
	  
	  // 4. 接收(读)
	  ret = recvfrom(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&server_addr, &addrlen);
	  if (-1 == ret){
	  	perror("Fail to recvfrom.");
	 		break;
	  }
	  packet[ret] = '\0';
	 	
	 	printf("-----------------------------\n");
		printf("recv(%d): %s\n", ret, packet);
		printf("-----------------------------\n");
	 	
	  if (strcmp(packet, "quit") == 0){
	  	break;
	  }
	}
  
  // 5. 关闭
  close(sockfd);
  unlink(argv[1]);
	
	return 0;
}
server.c 

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/un.h>

// ./server server_addr
int main(int argc, const char *argv[])
{
	int ret = 0;
	int sockfd;
	char packet[1024];
	struct sockaddr_un server_addr;
	 struct sockaddr_un peer_addr;
	socklen_t addrlen = sizeof(peer_addr);
	
	if (argc < 2){
		fprintf(stderr, "Usage: %s <src addr>\n", argv[0]);
		exit(EXIT_FAILURE);
	}
	
	// 1. 创建套接字
	sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
	if (-1 == sockfd){
		perror("Fail to socket.");
		exit(EXIT_FAILURE);
	}
	
	// 2. 绑定(自己)地址
	server_addr.sun_family = AF_UNIX;
  strcpy(server_addr.sun_path, argv[1]);
	
	ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret){
		perror("Fail to bind.");
		exit(EXIT_FAILURE);
	}
  	
	while (1){
		// 3. 接收数据包
		ret = recvfrom(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&peer_addr, &addrlen);
		if (-1 == ret){
			perror("Fail to recvfrom.");
			break;
		}
		packet[ret] = '\0';
		
		printf("-----------------------------\n");
		printf("from   : %s\n", peer_addr.sun_path);
		printf("recv(%d): %s\n", ret, packet);
		printf("-----------------------------\n");
		
		// 4. 发送数据包
		ret = sendto(sockfd, packet, ret, 0, (struct sockaddr *)&peer_addr, sizeof(peer_addr));
		if (-1 == ret){
			perror("Fail to sendto.");
			break;
		}
		
		if (strcmp(packet, "quit") == 0){
			break;
		}
	}
	
	// 5. 关闭
	close(sockfd);
	unlink(argv[1]);
	
	return 0;
}

椰子哥·天行者
关注
专栏目录
Python核心编程之序列下篇
LYX_WIN
12-08 1105
难道它们 的名字现在不应该都是'jane'了吗?正如我们在本章的开头所讨论的,无论 list()还是 tuple()都不可能做完全的转换(见 6.1.2 节).也就是说,你传给 tuple()的一个列表对象不可能变成一个元组,而你传给 list()的 对象也不可能真正的变成一个列表.虽然前后两个对象(原来的和新的对象)有着相同的数据集 合(所以相等 == ),但是变量指向的却不是同一个对象了(所以执行 is 操作会返回 false).还 要注意,即使它们的所有的值都相同,一个列表也不可能"等于"一个元组.
6.12 linux内核管理 ：内核位数
one_chao的博客
08-05 135
6.12 linux内核管理 ：内核位数 getconf LONG_BIT $ getconf LONG_BIT 64 如果返回的结果是32则说明是32位，返回的结果是64则说明是64位。
Linux Kernel 6.12版预计将支持在崩溃后显示二维码 后续可以解码排查错误
weixin_41446370的博客
09-01 600
经过两个月的讨论后目前红帽工程师准备的代码已经通过 DRM-Misc-Next 提交给 DRM-Next，以便能够赶上 Linux Kernel 6.12 的合并窗口，如无意外的话 Linux Kernel 6.12 将是首个支持崩溃后显示二维码的内核版本。Linux Kernel 的崩溃后显示二维码是将崩溃日志生成二维码，这样崩溃日志不会被截断，用户在必要的时候对二维码进行拍照以后后续解码内容分析崩溃的具体原因。
Linux网络流量控制工具—Netem（可用于网络故障注入）
chenglinhust的专栏
12-06 5551
Linux网络流量控制工具—Netem（可用于网络故障注入） 第一篇：概念篇         Netem 是 Linux 2.6 及以上内核版本提供的一个网络模拟功能模块。该功能模块可以用来在性能良好的局域网中，模拟出复杂的互联网传输性能，诸如低带宽、传输延迟、丢包等等情况。使用 Linux 2.6 (或以上) 版本内核的很多发行版 Linux 都开启了该内核功能，比如Fe
linux 判断网卡是否异常_Linux下检测网卡与网线连接状态
weixin_39668965的博客
02-07 496
Linux下检测网卡与网线连接状态，使用ioctl向socket发送SIOCETHTOOL命令字。link_stat.c#include #include #include #include #include #include #include #include #include #include #include int get_netlink_status(const char *if_nam...
linux主机网络异常日志,我的服务器日志中的linux – (网络不可达)错误
weixin_36313344的博客
05-01 792
我的Centos消息日志文件中有很多网络无法访问的行.他们似乎无法解决某些地址,我没有任何想法,为什么我的服务器必须首先解决它们.谁能让我知道这种错误的根源？我受到了攻击吗？Oct 23 11:39:03 server named[1585]: error (network unreachable) resolving './DNSKEY/IN': 2001:503:ba3e::2:30#53Oc...
linux c语言内核函数手册,Linux C函数实例速查手册
weixin_42515295的博客
04-30 1699
函数学习目录：第1章 初级I/O函数1.1 close函数：关闭已经打开的文件1.2 creat函数：创建一个文件1.3 dup函数：复制文件描述符1.4 dup2函数：复制文件描述符到指定的位置1.5 fcntl函数：改变文件的状态1.6 fsync函数：将缓冲区数据回写到磁盘文件1.7 Lseek函数：移动文件的读写位置1.8 open函数：打开一个文件1.9 read函数：读取文件的数据1....
linux总复习（二）
heyhsggstdggw的博客
06-18 2524
二、进阶与原理 （1）make和makefile 6.1 Linux C语言程序的编译和运行 确保已安装有gcc -o选项用于指定编译后的文件名 如不指定则默认生成a.out ./用于指定路径 Linux C头文件 基本头文件在/usr/include，附加头文件一般在/usr/include/sys或/usr/include/linux中 使用gcc的-I选项可以引入不在默认路径中的头文件 Linux C库文件 标准库文件一般位于/lib或/usr/lib 库文件可以分为静态库(.a)和共享库(.so)
Linux学习笔记
m0_68897489的博客
07-09 2303
linux
AUTOSAR从入门到精通-【应用篇】基于4G网络和CAN总线的车辆在线故障 诊断系统设计与实现
getusushu的博客
07-19 578
目前国内汽车保有数量逐年增加，国内家庭 拥有车辆的比例也在不断上升，人们出行时选择个人驾车的情况也越来越普遍。随之而来的是在国内频发的交通事故，尽管交通事故的发生原因是由多种因素组 成的，但汽车本身的运行状况也是不可忽视的重要因素。对于大部分驾驶员来说， 对于车辆的故障和隐患的相关知识是了解甚少的。而在使用汽车时，由于各种外 部或者内部原因，汽车难以避免地会发生故障，如果是一般的小故障可能只是造 成车辆出现异响、异味或其他异常现象，暂时不影响汽车的使用。
Linux_的异常处理 很强大的分析
09-04
Linux的驱动机制及实现.pdf 很详细 Linux的虚拟文件系统.pdf Linux_的异常处理.pdf 三部
Linux基本网络异常,Linux版本登录提示网络错误
weixin_31002379的博客
05-10 149
该楼层疑似违规已被系统折叠隐藏此楼查看此楼下了最新的版本2.5.8，进行登录提示网络错误：➜ APP ./WizNote-x86_64.AppImage[DEBUG] set server : "http://api.wiz.cn/"[WARNING]: QSslSocket: cannot resolve CRYPTO_num_locks ((null):0, (null))[WARNIN...
Linux 系统日志的分析与故障排除
GitHub_miao的博客
12-18 654
在脚本或应用程序中，通过syslog库可以自定义写入系统日志。# 示例代码：使用 syslog 写入自定义日志 logger -p local0.info "Custom log message"在Linux系统中，系统日志分析与故障排除是系统管理中不可或缺的重要环节。通过本文详细介绍的各种示例代码和高级技术，管理员可以全面了解系统的运行状况，追踪故障原因，确保系统的可靠性和安全性。从基础的日志文件位置、内容查看，到更高级的journalctlLogwatch。
46.Linux网络编程--网络超时优化
lzs940320的博客
05-13 366
一.超时引用必要性 在网络通信中，很多操作会使得进程阻塞例如 TCP套接字中的recv/accept/connect UDP套接字中的recvfrom 你也不能一直阻塞着不干活啊，避免进程在没有数据时无限制地阻塞，所以引入超时检测。 当设定的时间到时，进程从原操作返回继续运行。 二.设置超时的三种方法： 1.设置socket的属性 SO_RCVTIMEO，我们上面讲的改属性 例： 设置接收超时： struct timeval tout; tout.tv_sec = 5; t...
linux网络异常怎么办，可以试试这个命令
qq_36298872的博客
03-14 1243
在Linux系统维护工作中，及时有效地监控网络流量至关重要。面对突发的流量告警，快速锁定引起异常流量的具体进程往往成为关键任务。然而，现行状态下，登录Linux系统查究根源耗时较多，这对快速响应业务问题形成了挑战，直接影响到我们解决问题的效率和绩效评价。为此，下面就提供一套简易高效的排查Linux系统中导致网络异常的进程的方法，助力运维工作更加得心应手。
Linux内核移植实战总结
最新发布
qq_28576837的博客
09-21 1070
直接参考【】I.MX6U嵌入式Linux驱动开发指南V1.81本文仅作为个人笔记使用，方便进一步记录自己的实践总结。前两章我们简单了解了一下 Linux 内核顶层 Makefile 和 Linux 内核的启动流程，本章我们就来学习一下如何将 NXP官方提供的 Linux 内核移植到正点原子的 I.MX6U-ALPHA 开发板上。通过本章的学习，我们将掌握如何将半导体厂商提供的 Linux BSP 包移植到我们自己的平台上。
linux系统常出现的网络问题及解决方法
weixin_47450720的博客
03-22 6631
【代码】linux系统常出现的网络问题及解决方法。
Linux网络不通排查
qq_41661843的博客
01-25 2847
网络不通是Linux系统管理员经常遇到的问题。为了有效地解决这类问题，我们需要按照一定的步骤进行排查。下面是一些基本的排查步骤，以及如何通过命令的执行结果来分析问题。
Qt6.12网络编程实践：单服务器与多客户端架构
在完成Qt6网络编程后,我们可以将应用程序部署到不同的操作系统上,如Windows、Linux、macOS等。在部署过程中,需要注意平台相关的配置和兼容性问题。Qt Creator提供了统一的构建和运行环境,通过简单的配置可以生成针对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值