Linux on nayun blog

LinuxHttp工具

Tue, 05 Aug 2025 14:28:04 +0800

wget
#

wget获取指定ip路由下的全部文件
-r：递归
--no-parent：无父目录
--accept：接收文件，支持通配符
--reject：拒绝文件，支持通配符
-P：指定下载路径

</>
shell


1wget -r --no-parent --accept "*.zip*" --reject "*.html" ip:port -P ./download/

Http文件服务器
#

python3 http server模块快速启动
python3 -m http.server 8000 --directory /path/

</>
console


1Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

优点：快速
缺点：不能直观看到本地ip

python3 代码

</>
python


 1import socket
 2import sys
 3import http.server
 4import socketserver
 5import traceback
 6
 7class Handler(http.server.SimpleHTTPRequestHandler):
 8 def __init__(self, *args, **kwargs):
 9 super().__init__(*args, directory=target, **kwargs)
10
11 def end_headers(self):
12 self.send_header('Connection', 'close')
13 super().end_headers()
14
15def get_local_ip() -> str:
16 try:
17 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
18 s.connect(("8.8.8.8", 80))
19 local_ip = s.getsockname()[0]
20 s.close()
21 return local_ip
22 except Exception as e:
23 raise Exception(f"无法获取IP: {str(e)}\n请检查网络环境")
24
25if __name__ == '__main__':
26 local_ip = get_local_ip()
27 target = ''
28 try:
29 target = sys.argv[1]
30 except:
31 target = "."
32
33 with socketserver.ThreadingTCPServer(("", 0), Handler) as httpd:
34 port = httpd.server_address[1]
35 print(f"Serving HTTP on http://{local_ip}:{port}/")
36 try:
37 httpd.serve_forever()
38 except:
39 print(traceback.format_exc())
40 finally:
41 httpd.server_close()
42 print('exit.')

</> shell

1python3 autofileserver.py /path/

优点：快速、直观看到ip:port

日志分析

Wed, 30 Jul 2025 16:44:17 +0800

纯python处理
#

支持关键字正则表达式组合，逐行后处理，跨平台兼容

日志关键字处理
#

需求：

1次遍历，O(n)
多关键字(支持regex pattern)
关键字一对一自定义处理方法解耦
处理结果统计，每个关键字的成功/失败处理量+处理总量

例子：
找到日志中包含kwA的日志，执行dealA(line) -> pass/fail处理方法
找到日志中包含kwB的日志，执行dealB(line) -> pass/fail处理方法
…

思路：

每行日志查询全部关键字，有关键字出现，进入deallog回调
通过deal_log回调函数，在回调内部区分kw，执行不同逻辑
结束时输出关键字相关处理总量

</>
python


 1import re
 2from collection import defaultdict
 3def keywords_check(checktitle, text, checklist, deal_log=(lambda pt, line:True)) -> int, str:
# checklist 入参多类型支持(dict, list)
checklist = list(dict.fromkeys(checklist))
# 计数器
kw_counter, err_counter = defaultdict(int), defaultdict(int)
for line in text:
found = [pattern for pattern in checklist if re.search(pattern, line) is not None]
if not found:continue
for pattern in found:
kw_counter[pattern] += 1
if False == deal_log(pattern, line):
err_counter[pattern] += 1
msg = "{} done, total {} records, {} errors\n{}".format(
checktitle
, (kw_sum:=sum(kw_counter.values()))
, sum(err_counter.values())
, "".join(["[{}]: {} records, {} errors\n".format(
pattern
, kw_counter.get(pattern, 0)
, err_counter.get(pattern, 0)
) for pattern in checklist
])
)
return kw_sum, msg
27
28checklist = {
'pt1':r"^kwA*$",
'pt2':r"^kwB*$",
'pt3':r"^kwC*$",
32}
33def deal_log(pt, line):
if pt == checklist['pt1']:
return dealA(line)
elif pt == checklist['pt2']:
return dealB(line)
elif pt == checklist['pt3']:
return dealC(line)
else:
return False
42
43keywords_check('check keywords', checklist.values(), deal_log)

数据收集
#

可以使用上面的keywords_check方法，通过自定义deal_log方法收集数据
完成数据收集之后自定义数据分析方法

Linux文件读写

Tue, 29 Jul 2025 15:19:16 +0800

核心思想
#

一切皆文件（Everything is a File），提供了一套统一的接口 (open(), read(), write(), close(), ioctl() 等系统调用) 来操作各种资源，极大地简化了程序设计。

不仅指普通的文本文件、二进制可执行文件、图片、视频等，还包括：

硬件设备：硬盘 (/dev/sda1)、键盘 (/dev/input)、显示器 (/dev/fb0)、声卡 (/dev/snd)、甚至内存 (/dev/mem) 都被表示为文件。对这些“设备文件”的读写操作实际上是与硬件交互。
进程信息：正在运行的程序（进程）的信息和控制接口可以通过 /proc 文件系统访问（如 /proc/1234 对应 PID 为 1234 的进程）。
系统信息和配置： /sys 文件系统暴露内核参数、硬件信息和配置选项。
网络套接字：网络通信的端点。
管道：进程间通信的通道。

特性	普通文件	管道(Pipe)	Socket(TCP)
打开方式	路径直接打开	pipe()系统调用	socket()+bind/connect
数据存储	持久化存储	内存缓冲区	网络传输
访问模式	随机访问	顺序访问	顺序访问
生命周期	显式创建/删除	进程结束自动销毁	连接关闭即失效
进程通信	不支持进程间通信	支持相关进程通信	支持跨网络通信
阻塞行为	通常非阻塞	读空阻塞/写满阻塞	默认阻塞

1. 普通文件
#

代码通用实现
#

1. python
#

基本方法：with open(fp, mode)
示例

</>
python


 1with open('text.txt', 'w', encoding='utf-8') as f: # 'w' 覆盖写
 2 f.write("Hello Python!\n")
 3 f.writelines(["Line 1\n", "Line 2\n"]) # 写入多行
 4
 5with open('text.txt', 'r', encoding='utf-8') as f:
 6 content = f.read() # 一次性读取
 7
 8with open('text.txt', 'r') as f:
 9 lines = f.readlines() # 返回列表
10
11# ========== 二进制文件读写 ==========
12data = b'\x48\x65\x6C\x6C\x6F\x21' # "Hello!" 的二进制
13with open('binary.bin', 'wb') as f: # 'wb' 二进制写
14 f.write(data)
15
16with open('binary.bin', 'rb') as f:
17 binary_content = f.read()
18 print("二进制内容:", binary_content) # b'Hello!'
19 print("解码为字符串:", binary_content.decode('utf-8'))

2. c++
#

基本方法：fstream
1. 读：std::ifstream
2. 写：std::ofstream
注：创建流对象后需要手动关闭
示例

</>
c++


 1#include <iostream>
 2#include <fstream>
 3#include <vector>
 4#include <string>
 5
 6int main() {
// ========== 文本文件读写 ==========
// 写入文本文件
std::ofstream textOut("text.txt");
if (textOut.is_open()) {
textOut << "Hello C++!\n";
textOut << "Line 1\nLine 2\n";
textOut.close();
std::cout << "文本写入成功" << std::endl;
} else {
std::cerr << "文本文件打开失败" << std::endl;
}
18
// 读取文本文件
std::ifstream textIn("text.txt");
if (textIn.is_open()) {
std::string line;
std::cout << "文本内容:" << std::endl;
while (std::getline(textIn, line)) { // 逐行读取
std::cout << line << std::endl;
}
textIn.close();
} else {
std::cerr << "文本文件打开失败" << std::endl;
}
31
// ========== 二进制文件读写 ==========
// 写入二进制文件
std::ofstream binOut("binary.bin", std::ios::binary);
char data[] = {0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x21}; // "Hello!"
if (binOut.is_open()) {
binOut.write(data, sizeof(data));
binOut.close();
std::cout << "二进制写入成功" << std::endl;
} else {
std::cerr << "二进制文件打开失败" << std::endl;
}
43
// 读取二进制文件
std::ifstream binIn("binary.bin", std::ios::binary);
if (binIn.is_open()) {
// 获取文件大小
binIn.seekg(0, std::ios::end);
size_t size = binIn.tellg();
binIn.seekg(0, std::ios::beg);
51
// 读取到vector
std::vector<char> buffer(size);
binIn.read(buffer.data(), size);
binIn.close();
56
std::cout << "二进制内容: ";
for (char c : buffer) std::cout << c; // 输出 "Hello!"
std::cout << std::endl;
} else {
std::cerr << "二进制文件打开失败" << std::endl;
}
63
return 0;
65}

3. golang
#

基本方法：os
1. 读：
  1. 整体读取：os.ReadFile
  2. 逐行读取：
    1. os.Open
    2. bufio.NewScanner
2. 写：os.WriteFile

</>
golang


 1package main
 2
 3import (
"fmt"
"io"
"os"
"bufio"
 8)
 9
10func main() {
textContent := "Hello Go!\nLine 1\nLine 2\n"
err := os.WriteFile("text.txt", []byte(textContent), 0644) // 覆盖写入
if err != nil {
fmt.Println("文本写入失败:", err)
} else {
fmt.Println("文本写入成功")
}
18
data, err := os.ReadFile("text.txt") // 一次性读取
if err != nil {
fmt.Println("文本读取失败:", err)
} else {
fmt.Println("文本内容:\n", string(data))
}
25
// 逐行读取（使用 bufio）
file, err := os.Open("text.txt")
if err != nil {
fmt.Println("文件打开失败:", err)
return
}
defer file.Close()
33
fmt.Println("逐行读取:")
scanner := bufio.NewScanner(file)
for scanner.Scan() {
fmt.Println(scanner.Text()) // 输出每一行
}
39
// ========== 二进制文件读写 ==========
binaryData := []byte{0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x21} // "Hello!"
err = os.WriteFile("binary.bin", binaryData, 0644)
if err != nil {
fmt.Println("二进制写入失败:", err)
} else {
fmt.Println("二进制写入成功")
}
48
binContent, err := os.ReadFile("binary.bin")
if err != nil {
fmt.Println("二进制读取失败:", err)
} else {
fmt.Println("二进制内容:", binContent) // [72 101 108 108 111 33]
fmt.Println("解码为字符串:", string(binContent)) // "Hello!"
}
56
// 大文件分块读取
largeFile, err := os.Open("largefile.bin")
if err != nil {
fmt.Println("大文件打开失败:", err)
return
}
defer largeFile.Close()
64
buffer := make([]byte, 1024) // 1KB缓冲区
for {
n, err := largeFile.Read(buffer)
if err == io.EOF {
break // 文件结束
}
if err != nil {
fmt.Println("读取错误:", err)
break
}
fmt.Printf("读取 %d 字节\n", n)
// 处理 buffer[:n]
}
78}

2. 管道
#

代码实现
#

1. python
#

</>
python


 1import os
 2r, w = os.pipe()
 3pid = os.fork()
 4if pid == 0: # Child
 5 os.close(w)
 6 data = os.read(r, 100)
 7 print("Pipe read:", data.decode())
 8 os._exit(0)
 9else: # Parent
10 os.close(r)
11 os.write(w, b"Pipe message")
12 os.wait()

2. c++
#

</>
c++


 1#include <iostream>
 2#include <fstream>
 3#include <unistd.h>
 4#include <sys/wait.h>
 5#include <sys/socket.h>
 6#include <netinet/in.h>
 7
 8int main() {
 9 int fd[2]; pipe(fd);
10 if (fork() == 0) { // Child
11 close(fd[1]);
12 char buf[100];
13 read(fd[0], buf, sizeof(buf));
14 std::cout << "Pipe read: " << buf << std::endl;
15 exit(0);
16 } else { // Parent
17 close(fd[0]);
18 write(fd[1], "Pipe message", 13);
19 wait(nullptr);
20 }
21}

3. golang
#

</>
golang


 1package main
 2
 3import (
 4 "fmt"
 5 "io"
 6 "net"
 7)
 8func main() {
 9
10 r, w, _ := os.Pipe()
11 go func() {
12 w.Write([]byte("Pipe message"))
13 w.Close()
14 }()
15 pipeData, _ := io.ReadAll(r)
16 fmt.Println("Pipe read:", string(pipeData))
17}

3. 网络套接字socket
#

代码实现
#

1.python
#

</>
python


 1
 2import socket
 3# Server
 4srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 5srv.bind(('127.0.0.1', 12345))
 6srv.listen(1)
 7# Client
 8cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 9cli.connect(('127.0.0.1', 12345))
10# Accept and send
11conn, _ = srv.accept()
12conn.send(b"Socket data")
13print("Socket read:", cli.recv(100).decode())
14cli.close(); srv.close()

2. c++
#

</>
c++


 1#include <iostream>
 2#include <fstream>
 3#include <unistd.h>
 4#include <sys/wait.h>
 5#include <sys/socket.h>
 6#include <netinet/in.h>
 7
 8int main() {
 9 // Server setup
10 int srv_fd = socket(AF_INET, SOCK_STREAM, 0);
11 sockaddr_in addr = {AF_INET, htons(12345), INADDR_ANY};
12 bind(srv_fd, (sockaddr*)&addr, sizeof(addr));
13 listen(srv_fd, 1);
14 // Client connect
15 int cli_fd = socket(AF_INET, SOCK_STREAM, 0);
16 connect(cli_fd, (sockaddr*)&addr, sizeof(addr));
17 // Communication
18 int conn_fd = accept(srv_fd, nullptr, nullptr);
19 send(conn_fd, "Socket data", 12, 0);
20 char buffer[100];
21 recv(cli_fd, buffer, sizeof(buffer), 0);
22 std::cout << "Socket read: " << buffer << std::endl;
23 close(cli_fd); close(srv_fd);
24}

3. golang
#

</>
golang


 1package main
 2
 3import (
 4 "fmt"
 5 "io"
 6 "net"
 7)
 8func main() {
 9 // Server
10 listener, _ := net.Listen("tcp", "127.0.0.1:12345")
11 go func() {
12 conn, _ := listener.Accept()
13 conn.Write([]byte("Socket data"))
14 conn.Close()
15 }()
16 // Client
17 conn, _ := net.Dial("tcp", "127.0.0.1:12345")
18 sockData, _ := io.ReadAll(conn)
19 fmt.Println("Socket read:", string(sockData))
20}

用户态、内核态内存空间

Mon, 14 Jul 2025 15:39:03 +0800

用户态、内核态指内存空间，CPU的各寄存器则是CPU硬件，不属于内存部分，仅在需要存档备份数据时保存至（用户态/内核态）内存
1、进程内核栈
每个进程都有自己独立的位于内核空间的内核栈，保存进程在内核态执行的函数调用栈、局部变量、寄存器状态等数据

linux系统切换进程时会切换

内核栈
将 CPU 的栈指针寄存器 (SP/ESP/RSP, x86架构) 从指向进程 A 的内核栈顶部，修改为指向进程 B 的内核栈顶部
页目录
系统切换进程时找到进程的页目录的物理基地址（mm->pgd指针），写入CR3(x86)/TTBR0(ARM)寄存

2、进程页目录
存储在物理内存中，进程在创建时，系统创建mm_struct结构，用mm->pgd指针保存页目录物理基地址（用来在系统切换进程时找到进程的页目录的物理基地址，写入CR3(x86)/TTBR0(ARM)寄存器，完成进程上下文切换）
页目录包含进程使用的全部内存的虚拟内存地址->物理内存地址的映射关系
3、进程硬件上下文
运行时各寄存器的中间结果、比如PC程序计数器（下一条指令地址）、SP栈指针寄存器（当前调用栈顶）
切换时，这些数据被保存到进程内核栈中

4、线程切换总是发生在同一个进程（同一个虚拟地址空间）内的线程之间。不同进程的线程之间的切换，本质上是通过上层的进程切换完成的
5、切换线程时只切换线程内核栈，同样CPU栈指针寄存器从指向线程A的内核栈顶->B的内核栈顶。因为同属一个进程，所以不切换页目录，也即使用同一虚拟内存空间

6、进程、线程切换都依赖内核调度器，抢占式调度（时间片、中断）
7、协程切换只在用户态通过程序本身调度切换，主动让出，显式让出控制权
8、

进程	线程	协程
切换内核栈、页目录	切换内核栈	仅切换寄存器状态

9、用户态进程与内核态进程全双工通信 -> Netlink Socket

相比传统 IPC (syscall, ioctl, procfs)，Netlink 具有显著优势：易于扩展、异步通信、完美支持内核模块、强大的组播能力、真正的全双工通信、开发者友好的标准 Socket API。

单播回显: 用户请求->内核处理->内核响应的双向通信模式
内核主动组播: 内核主动向多个订阅进程广播事件的能力

netlink属于无连接协议（无连接协议是一种通信协议，其中每个数据包的处理都是独立的，不需要在发送数据之前建立连接）

Linux on nayun blog

LinuxHttp工具

wget #

Http文件服务器 #

日志分析

纯python处理 #

日志关键字处理 #

数据收集 #

Linux文件读写

核心思想 #

1. 普通文件 #

代码通用实现 #

1. python #

2. c++ #

3. golang #

2. 管道 #

代码实现 #

1. python #

2. c++ #

3. golang #

3. 网络套接字socket #

代码实现 #

1.python #

2. c++ #

3. golang #

用户态、内核态内存空间

wget
#

Http文件服务器
#

纯python处理
#

日志关键字处理
#

数据收集
#

核心思想
#

1. 普通文件
#

代码通用实现
#

1. python
#

2. c++
#

3. golang
#

2. 管道
#

代码实现
#

1. python
#

2. c++
#

3. golang
#

3. 网络套接字socket
#

代码实现
#

1.python
#

2. c++
#

3. golang
#