Keep It Simple & Stupid

TypeScript 函数定义

2025-10-29T00:00:00.000Z

写 ts 写得比较少，也不是持续的写，外加上 LLM 的帮助，对于 ts 的语法是有些怠惰了，这里整理下 ts 的函数定义。

加上自己对于各种东西都是够用就行，所以…

基础函数和常量

方式一：函数声明


function add(a: number, b: number): number {
  return a + b;
}

最易懂的方式，函数名是 add。

方式二：函数表达式 / 箭头函数


const add = (a: number, b: number): number => {
  return a + b;
};

在这里，定义了一个常量 add。它的值是一个匿名函数（这里是箭头函数）。函数本身没有名字，是 add 这个常量指向了它。这里稍微看一下也没有阅读障碍。

方式三：对象方法

const calculator = {
  add(x: number, y: number): number {
    return x + y;
  },
  subtract(x: number, y: number): number {
    return x - y;
  }
};

省略了方式一的 function 关键字，也没有阅读障碍。

方法四：函数类型

// 定义一个函数类型
type GreetFunc = (name: string) => string;

// 应用这个类型
const greet: GreetFunc = (name) => {
  return `Hello, ${name}`;
};

给四种函数加上泛型

现在，给这四种函数加上泛型。

方式一：函数声明 + 泛型

对于函数声明，泛型紧跟在函数名后面。


function createArray(item: T): T[] {
  return [item];
}

这个语法很直观，createArray 是一个泛型函数。

方式二：箭头函数 + 泛型

对于一个被赋值给常量的箭头函数，它的“函数”部分其实是从 = 号后面才开始的。


// 分解来看
const createEntity =      // 这是在定义一个常量
  extends ...>(...) => { ... } // 这才是一个完整的、匿名的、带有泛型的箭头函数

所以，泛型必须作为这个箭头函数定义的一部分，放在参数列表 (...) 的前面。

正确的语法：


// const [变量名] = [泛型定义][参数列表] => [函数体]
export const createEntity = extends Record<string, any>>(
  data: Omit'id' | 'createdAt' | 'updatedAt'>
): T & { id: string; createdAt: Date; updatedAt: Date } => {
  // ...
};

对我来说，这种写法已经开始让我迷糊了。

如果试图把泛型放在常量名后面，就会出现语法错误：


// ❌ 错误的语法
export const createEntityextends ...> = (data: ...) => { ... };
// SyntaxError: '=' expected.
// 因为 TypeScript 会认为 createEntity<...> 是一个类型或特殊语法，而不是变量名。

方式三：对象方法 + 泛型

泛型语法：泛型放在方法名之后，参数列表之前。


const collection = {
  items: [],
  add(item: T): T[] {
    this.items.push(item);
    return this.items;
  }

方法四：函数类型 + 泛型

// 定义一个泛型函数类型
type IdentityFunc = (arg: T) => T;

// 应用这个类型
const identity: IdentityFunc<number> = (arg) => {
  return arg;
};

泛型的位置都是在参数列表前。

其实 TypeScript 的文档肯定很清晰且详细的解释并说明了这些，但是真的够用就行了，遇到不会的再看吧。

https://www.typescriptlang.org/docs/handbook/2/functions.html

Samsung S24 和 Samsung Watch 5 国行刷外版系统（可能通用）

2024-12-16T00:00:00.000Z

Samsung 设备更改其他地区系统时需要退出 Google 账号和 Samsung 账号。

Samsung S24

需要找到想要刷的指定地区版本的固件，一般通过以下两个网站查找：

比如 S24 国行版系统固件：https://sxrom.cn/Find.aspx?MODEL=SM-S9210&CSC=CHC

S24 型号为 SM-S9210，CSC 是国家代码，这里的 CHC 是中国，港版为 TGY，台版为 BRI。

注意：确保互刷的系统版本安全策略版本对应正确：

ROM（刷机包）的倒数第 5 位，即是“安全政策”版本。这个数字，不能小于手机上“安全政策”版本，但可以等于。如有版本号为 N9760ZCS6HWH1 的“安全政策”版本就是 6。
手机上“安全政策”版本查找方式：手机设置 - 关于手机 - 软件信息 - 基带版本。
对比它们倒数第 5 位的数字（如下图）：如果 ROM 的版本低于手机，那么该 ROM 无法刷入手机，但也不会损坏手机，会在刷机一开始就报错。
如果该机型的国行和港版 ROM 可以互刷，也要遵循这个规则。
官方一般每隔几个月，在随 ROM 的更新时，更新一次这个数字，官方称之为“安全政策”更新。安全政策的更新之后，将无法退回。
港版的更新有时快于国行，如果恰好手机上港版已经升级到新的“安全政策”，但国行 ROM 还是老的“安全政策”版本，那么此时就无法刷到国行，请等待数日，国行 ROM 更新后即可刷回国行。
因为“安全政策”只用一个字符来表示，所以 9 之后就是 A，A 之后又是 B。
源自：https://sxrom.cn/help4.aspx

下载 Samsung Odin

Samsung Odin 是适用于 Samsung Android 智能手机和平板电脑设备的刷机工具。

Odin 下载地址：https://odindownload.com。
如果 Odin 连接不上设备（设备需要在 Download 模式下，参见后面步骤），可能还需要下载驱动：https://developer.samsung.com/android-usb-driver。

解压在第 1 步下载的固件，会发现有 AP, BL, CP, CSC, HOME-CSC 开头的这几个文件。
将手机进入 Download 模式（手机插上线，关机状态下同时按音量加减）看到警告界面后按音量上。解压官方四件套之后，使用 Odin 刷入。只需要将 BL、AP、CP、CSC 开头的 tarball 放入 Odin 的对应槽位刷入即可。
PASS，结束。

刷回步骤应该也一样，没有测试过。

Samsung Watch 5

下载固件以及 NetOdin，但是 Watch 5 的固件比较少。

NetOdin - https://t.me/swapplication/258
Firmware for Galaxy Watch 5
Galaxy Watch 5 SM-R900 40 mm - https://t.me/swapplication/296
Galaxy Watch 5 SM-R910 44 mm - https://t.me/swapplication/297
Galaxy Watch 5 PRO SM - R920 45mm - https://t.me/swapplication/298
源自：https://xdaforums.com/t/flash-sgw5-with-netodin-succeed.4551903/post-89809935

我手上的是 44 mm。

刷写步骤。
1. 手表开机状态下，长按右侧两个按键，重启直到出现 SAMSUNG logo 且下方有 Rehbooting 字样时连按三次上键。
2. 此时会进入一个界面（可能是 fastboot 模式？），这个模式下上键短按是切换，长按是选择。选择 Download(Wireless)。
3. 电脑搜索连接手表的开启的热点，名称应该是手表的型号。
4. 打开 NetOdin, 在 AP 栏选择指定的固件包，刷入即可。（似乎只支持 tar 包，如果下载的固件不是 tar 格式可以先解压再转成 tar 包)
5. PASS，结束。

参考

使用 Pandoc 把 Markdown 转为 PDF 文件

2024-11-24T00:00:00.000Z

在 Arch Linux 上使用 Pandoc 把带中文的 Markdown 转换成 PDF。

必要的软件和字体

Pandoc 我选择安装 bin 包，我可不想看到更新的时候一堆 Haskell 依赖。

1	pandoc-bin

Tex Live 环境

1	texlive-core texlive-langchinese texlive-latexextra texlive-bin

转换 Markdown 为 PDF

Pandoc 默认使用的 pdflatex 命令无法处理 Unicode 字符，如果要把包含中文的 Markdown 文件转为 PDF，生成的 PDF 文件中文位置会是空白 ^[1]。

1	pandoc --pdf-engine=xelatex -V CJKmainfont="Source Han Sans CN" file.md -o file.pdf

--pdf-engine=xelatex：使用 XeLaTeX 作为 PDF 生成引擎，支持中文。-V CJKmainfont="Source Han Sans CN"：指定主中文字体，我这里使用思源。

参考资料

1.pandoc FAQ ↩

MSS、MTU 和 TCP 拥塞堵塞

2024-08-30T00:00:00.000Z

MTU

MTU(Maximum Transmission Unit) 最大传输单元，是指数据链路层上面所能通过的最大数据包大小（以字节为单位）。这一分片过程发生在 IP 层（OSI 模型的第 3 层，即网络层）。

关于 MTU 和 MSS，cloudflare 文章中提供了一张非常好理解的图：

一个 MTU 最大 1500 bytes，如果超过这个数量则会被分片。

MSS

MSS(Maximum Segment Size) 最大分段大小，限制通过网络（例如互联网）传输的数据包或小数据块的大小。通过网络传输的所有数据都被分解成数据包。数据包附有几个标头，其中包含有关其内容和目的地的信息。MSS 测量数据包的非标头部分，称为有效负载。它只是一个参数，一个限制。

如果将数据包比作运输卡车，标头是卡车本身，有效负载是拖车和货物，那么 MSS 就像只测量拖车的秤。如果拖车过重，则不允许卡车继续前往目的地。

MSS 是第 4 层（传输层）的参数，与 TCP 一起使用。

MTU - (TCP 标头 + IP 标头) = MSS

IP 标头和 TCP 标头分别占用 20 bytes。所以一个 MSS 最大 1460 bytes。TCP 一个包最大是可以发送 1460 bytes。

TCP 拥塞堵塞

TCP 发送数据包并不是每次只发送一个，而是一次发送一组包，然后等待 ACK，接着发送下一组包。这里就涉及到拥塞控制窗口 cwnd 与 TCP 的拥塞控制机制。

TCP 拥塞堵塞就是根据 MSS 的大小来控制。比如拥塞控制窗口 cwnd 大小为 10 的时候，TCP 连接建立起来之后会发 10 个 MSS 数据（TCP 的单位一般都是 MSS 计数），等待对等方的 ACK 之后再进行下一轮的数据发送，并且逐渐增大 cwnd 的值。
当发生拥塞堵塞时，会从慢启动切换到拥塞控制算法。关于这两种算法详细参见维基百科的解释。

搭建了一个 100ms，关闭了 tcp-segmentation-offload 参数环境，在这里面测试的一段抓包数据：

 1   0.000000  192.168.1.2 → 192.168.1.1  TCP 74 43218 → 5001 [SYN] Seq=0 Win=64240 Len=0 MSS=1460 SACK_PERM TSval=984956032 TSecr=0 WS=128
 2   0.100707  192.168.1.1 → 192.168.1.2  TCP 74 5001 → 43218 [SYN, ACK] Seq=0 Ack=1 Win=65160 Len=0 MSS=1460 SACK_PERM TSval=3503908013 TSecr=984956032 WS=128
 3   0.100771  192.168.1.2 → 192.168.1.1  TCP 66 43218 → 5001 [ACK] Seq=1 Ack=1 Win=64256 Len=0 TSval=984956133 TSecr=3503908013
 4   0.102053  192.168.1.2 → 192.168.1.1  TCP 130 43218 → 5001 [PSH, ACK] Seq=1 Ack=1 Win=64256 Len=64 TSval=984956134 TSecr=3503908013
 5   0.102122  192.168.1.2 → 192.168.1.1  TCP 1514 43218 → 5001 [ACK] Seq=65 Ack=1 Win=64256 Len=1448 TSval=984956134 TSecr=3503908013
 6   0.102130  192.168.1.2 → 192.168.1.1  TCP 1514 43218 → 5001 [PSH, ACK] Seq=1513 Ack=1 Win=64256 Len=1448 TSval=984956134 TSecr=3503908013
 7   0.102161  192.168.1.2 → 192.168.1.1  TCP 1514 43218 → 5001 [ACK] Seq=2961 Ack=1 Win=64256 Len=1448 TSval=984956134 TSecr=3503908013
 8   0.102165  192.168.1.2 → 192.168.1.1  TCP 1514 43218 → 5001 [PSH, ACK] Seq=4409 Ack=1 Win=64256 Len=1448 TSval=984956134 TSecr=3503908013
 9   0.102176  192.168.1.2 → 192.168.1.1  TCP 1514 43218 → 5001 [ACK] Seq=5857 Ack=1 Win=64256 Len=1448 TSval=984956134 TSecr=3503908013
10   0.102179  192.168.1.2 → 192.168.1.1  TCP 1514 43218 → 5001 [PSH, ACK] Seq=7305 Ack=1 Win=64256 Len=1448 TSval=984956134 TSecr=3503908013
11   0.102187  192.168.1.2 → 192.168.1.1  TCP 1514 43218 → 5001 [ACK] Seq=8753 Ack=1 Win=64256 Len=1448 TSval=984956134 TSecr=3503908013
12   0.102189  192.168.1.2 → 192.168.1.1  TCP 1514 43218 → 5001 [PSH, ACK] Seq=10201 Ack=1 Win=64256 Len=1448 TSval=984956134 TSecr=3503908013
13   0.102196  192.168.1.2 → 192.168.1.1  TCP 1514 43218 → 5001 [ACK] Seq=11649 Ack=1 Win=64256 Len=1448 TSval=984956134 TSecr=3503908013
14   0.202685  192.168.1.1 → 192.168.1.2  TCP 66 5001 → 43218 [ACK] Seq=1 Ack=65 Win=65152 Len=0 TSval=3503908115 TSecr=984956134

第二个字段是时间。

发现 1-2 之间花费了 1 个 RTT(100ms)，13-14 之间也花费了 1 个 RTT，第一个 RTT 用于建立连接，第二个 RTT 传输数据。4-13 则是 cwnd 的大小。

可以尝试修改 cwnd 的值，查看慢启动时的变化。尝试使用 sudo ip netns exec ns2 ip route add default via 192.168.1.1 dev veth1 initcwnd 20 但修改未生效。

TSO(tcp-segmentation-offload)

我们抓包会发现实际上的 tcp payload 大小会超过 MTU(1500) 限制，其中一个原因（其他未了解）是开启了 tcp-segmentation-offload 参数，
这个参数利用 NIC（网络接收卡）接收较大的数据包，并在硬件层面将其分成适合 MTU 的较小段发送到网络。所以我们抓到的包实际上会显示成更大的包，
但是在网络上传输的是被分段的小包。

关闭 tcp-segmentation-offload，以后面测试环境为例：

1 2	sudo ip netns exec ns2 ethtool --show-offload veth1 \| grep offload sudo ip netns exec ns2 ethtool -K veth1 tso off

测试环境构建

sudo ip link add veth0 type veth peer name veth1
ip link

sudo ip netns add ns1
sudo ip netns add ns5
sudo ip netns list

sudo ip link set veth0 netns ns1
sudo ip link set veth1 netns ns2

sudo ip netns exec ns1 ip link
sudo ip netns exec ns2 ip link

sudo ip netns exec ns1 ip addr add 192.168.1.1/24 dev veth0
sudo ip netns exec ns1 ip link set veth0 up
sudo ip netns exec ns2 ip addr add 192.168.1.2/24 dev veth1
sudo ip netns exec ns2 ip link set veth1 up

sudo ip netns exec ns1 ping 192.168.1.2

sudo ip netns exec ns1 tc qdisc add dev veth0 root netem rate 1mbit delay 100ms

sudo ip netns exec ns1 ping 192.168.1.2 # 会发现延迟为 100 ms 以上

在 ns1 中启动 iperf 服务器：

1	sudo ip netns exec ns1 iperf -s -B 192.168.1.1

tcpdump 抓包：

1	sudo ip netns exec ns1 tcpdump -i veth0 -w iperf_traffic_ns1.pcap

同样，可以在 ns2 中抓取 veth1 接口的数据包：

1	sudo ip netns exec ns2 tcpdump -i veth1 -w iperf_traffic_ns2.pcap

在 ns2 中启动 iperf 客户端：

1	sudo ip netns exec ns2 iperf -c 192.168.1.1 -B 192.168.1.2 -t 30

这里测试 30 秒。

清理环境：

1 2	sudo ip netns del ns1 sudo ip netns del ns2

网络分层模型

2024-08-28T00:00:00.000Z

模型这些抽象的概念，用于帮助自己理解一些网络架构，但是发现面对一些名词或者概念时总是无法对上，想整理记录一下。

OSI 模型

OSI 模型的七层包括：

1. 应用程序层：由软件应用程序生成并可由其使用的数据。该层使用的主要协议是 HTTP。
1. 表示层：将数据转换为应用程序可以接受的形式。一些机构认为 HTTPS 加密和解密在该层进行。
1. 会话层：控制计算机之间的连接（这也可以由 TCP 协议在第 4 层处理）。
1. 传输层：提供在两个连接设备之间传输数据以及控制服务质量的方法。这里使用的主要协议是 TCP 和 UDP。
1. 网络层：处理不同网络之间的数据路由和发送。该层使用的最重要协议是 IP 和 ICMP。
1. 数据链路层：处理同一网络中不同设备之间的通信。如果第 3 层比作一封邮件上的地址，那么第 2 层就指明了该地址的办公室号码或公寓号码。以太网是这里最常用的协议。
1. 物理层：数据包被转换为电脉冲、无线电脉冲或光脉冲，并以比特（信息的最小单位）的形式通过电线、无线电波或电缆进行传输。

想起考试时背的一串 应表会传网数物。

Cloudflare 的一篇文章中提到：

请务必记住，OSI 模型是对使得 Internet 正常工作的众多流程的概念化的抽象描述，阐述模型以及将其应用到现实世界中的 Internet 时，有时是主观的。OSI 模型有助于人们讨论网络设备和协议，确定哪些协议由哪些软件和硬件使用，并大致显示 Internet 的工作方式。但它并未严格地分步定义 Internet 连接的普遍运作方式。

没必要去严格的根据分层模型去学习 Internet 的工作方式，对其有一个大致的了解即可。比如，经常会被询问到 xxx 协议属于哪一层？
我觉得这个问题不太好回答，引用其他博客中的说明：

我觉得这种讨论没有意义。因为我们实际上在讨论两个东西而且试图将两个概念融合在一起。即：
协议工作在几层（基于几层实现）？协议为几层提供服务？
如果分开讨论，就清楚很多了。ARP 基于二层（意味着只用到了二层的功能，不需要三层的东西就可以工作）实现，为三层提供服务，帮助找到 IP 对应的 MAC 地址。
我们可以给很多有类似争议的协议定义：
TLS 基于四层实现，为应用层提供服务；TCP 基于三层实现，为应用层提供服务；ICMP 工作在三层，为三层提供服务；EIGRP 和 OSPF 基于 IP 协议，为三层提供服务；BGP 基于四层实现，为三层提供服务（是不是很神奇？因为 BGP 通过 TCP 交换路由信息，为三层提供转发路由）；

TCP/IP 模型

1. 应用程序层：这大致相当于 OSI 模型中的第 7 层。
1. 传输层：对应于 OSI 模型中的第 4 层。
1. 互联网层：对应于 OSI 模型中的第 3 层。
1. 网络访问层：结合了 OSI 模型中第 1 层和第 2 层的过程。

分层的意义

Linux Network sysctl parameters

2024-08-19T00:00:00.000Z

In Process（接收数据包）

数据包到达 NIC:

MAC 验证和 FCS 检查：NIC 会检查数据包的 MAC 地址 (如果 NIC 不处于混杂模式) 和帧校验序列 (FCS)。如果 MAC 地址不匹配或 FCS 检查失败，数据包会被丢弃。
DMA 传输：如果数据包通过了验证，NIC 会使用直接内存访问 (DMA) 将数据包传输到内存中。内存区域由驱动程序预先准备并映射。
接收环形缓冲区：NIC 会将数据包的引用添加到接收环形缓冲区 (rx) 中。接收环形缓冲区是一个用于存储待处理数据包的队列。
硬件中断：NIC 会发出一个硬件中断 (IRQ) 通知 CPU 数据包已到达。

驱动程序处理：

中断处理程序：CPU 会运行中断处理程序，该程序会执行驱动程序代码。
NAPI 调度：驱动程序会调度一个 NAPI (网络协议中断)，清除硬件中断并返回。
软中断：驱动程序会发出一个软中断 (NET_RX_SOFTIRQ)。
NAPI 循环：NAPI 会从接收环形缓冲区中轮询数据包，直到达到预设的时间限制或数据包数量限制。

Linux 内核处理：

内存分配：Linux 会为数据包分配一个 sk_buff 结构体，用于存储数据包的元数据。
元数据填充：Linux 会填充 sk_buff 结构体的元数据，包括协议类型、接口信息、MAC 头部等。
内核堆栈：Linux 会将 sk_buff 传递给内核堆栈 (netif_receive_skb)。
网络头部：内核会设置网络头部，并将 sk_buff 克隆到其他地方 (例如 tcpdump) 用于调试。
流量控制：数据包会进入一个由 netdev_max_backlog 参数定义的队列调度算法 (qdisc) 中。默认的队列调度算法由 default_qdisc 参数定义。
IP 处理：数据包会被传递给 IP 层 (ip_rcv)。
网络过滤器：数据包会经过网络过滤器 (netfilter) 的 PREROUTING 阶段。
路由查找：内核会查找路由表，决定数据包是进行转发还是本地处理。
本地处理：如果数据包是本地处理的，它会经过网络过滤器 (LOCAL_IN) 阶段。
L4 处理：数据包会被传递给 L4 协议 (例如 TCP) 的处理函数 (例如 tcp_v4_rcv)。

应用程序处理：

套接字查找：内核会找到与数据包匹配的套接字。
TCP 状态机：数据包会进入 TCP 状态机。
接收缓冲区：数据包会被添加到接收缓冲区中，缓冲区大小由 tcp_rmem 规则定义。
缓冲区自适应调整：如果 tcp_moderate_rcvbuf 启用，内核会自动调整接收缓冲区的大小。
信号通知：内核会向应用程序发送信号，通知应用程序有数据可读 (例如 epoll 或其他轮询机制)。
应用程序读取：应用程序会醒来并读取数据。

Out Process（发送数据包）

应用程序发送数据：

数据包分配：应用程序会使用 sendmsg 或其他方法发送数据包，并为数据包分配一个 sk_buff 结构体。
套接字写缓冲区：sk_buff 会被添加到套接字的写缓冲区中，缓冲区大小由 tcp_wmem 参数定义。

TCP 处理：

TCP 头部构建：TCP 会构建 TCP 头部，包括源端口、目标端口和校验和。
L3 处理：TCP 会调用 L3 处理函数 (例如 tcp_write_xmit 和 tcp_transmit_skb)，将数据包传递给 IP 层。

IP 处理：

IP 头部构建：IP 层会构建 IP 头部，并调用网络过滤器 (LOCAL_OUT) 进行处理。
路由查找：IP 层会查找路由表，决定数据包的输出路径。
网络过滤器：数据包会经过网络过滤器 (POST_ROUTING) 阶段。
数据包分片：如果数据包太大，IP 层会将数据包分片 (ip_output)。

L2 处理：

发送函数：IP 层会调用 L2 发送函数 (dev_queue_xmit)，将数据包传递给网络接口卡 (NIC)。

NIC 处理：

发送队列：数据包会进入 NIC 的发送队列 (txqueuelen)，队列调度算法由 default_qdisc 参数定义。
环形缓冲区：NIC 驱动程序会将数据包添加到发送环形缓冲区 (tx) 中。
软中断：驱动程序会发出一个软中断 (NET_TX_SOFTIRQ)，通知 CPU 数据包已准备好发送。
硬件中断使能：驱动程序会重新使能 NIC 的硬件中断。
DMA 传输：驱动程序会将数据包从内存映射到 DMA 区域，并由 NIC 通过 DMA 传输到网络。
硬件中断：NIC 发送完毕后，会发出一个硬件中断，通知 CPU 数据包已发送完成。

驱动程序处理：

中断处理：驱动程序会处理硬件中断，并关闭中断。
NAPI 轮询：驱动程序会调度 NAPI 轮询系统，处理接收数据包并释放内存。

环形缓冲区 (Ring Buffer - tx,rx)

接收环形缓冲区 (rx):

作用：接收环形缓冲区用于缓冲从网络接收到的数据包。当 NIC 接收数据包的速度超过内核处理数据包的速度时，数据包会被放入接收环形缓冲区中等待处理。
为什么要使用接收环形缓冲区：使用接收环形缓冲区可以避免数据包丢失，特别是当网络流量突然增加时。
调整大小：如果出现数据包丢失或溢出 (即接收数据包的速度超过内核处理速度)，可以尝试增加接收环形缓冲区的大小。
副作用：增加接收环形缓冲区的大小可能会增加延迟。

发送环形缓冲区 (tx):

作用：发送环形缓冲区用于存储待发送的数据包。当应用程序发送数据包的速度超过 NIC 处理数据包的速度时，数据包会被放入发送环形缓冲区中等待发送。
为什么要使用发送环形缓冲区：使用发送环形缓冲区可以避免数据包丢失，并提高网络性能。
调整大小：如果出现数据包丢失或溢出，可以尝试增加发送环形缓冲区的大小。
副作用：增加发送环形缓冲区的大小可能会增加延迟。

如何查看和调整环形缓冲区大小：

查看命令：ethtool -g ethX | --show-ring
调整命令：ethtool -G ethX rx value tx value | --set-ring (其中 value 是新的环形缓冲区大小)

如何监控环形缓冲区状态：

监控命令：ethtool -S ethX | grep -e "err" -e "drop" -e "over" -e "miss" -e "timeout" -e "reset" -e "restar" -e "collis" -e "over" | grep -v "\: 0" | --statistics
监控指标：该命令会显示一些错误、丢包、溢出、超时等指标，可以用来监控环形缓冲区的状态。

中断合并 (Interrupt Coalescence, IC)

定义：中断合并技术是指将多个硬件中断合并成一个中断，以减少 CPU 中断次数，从而提高 CPU 利用率和网络性能。
工作原理：NIC 会在收到一定数量的数据包或经过一定时间后，才会发出一个硬件中断。
参数：中断合并技术通常使用以下参数来控制：
rx-usecs: 接收数据包时，NIC 等待的时间 (微秒)，超过该时间才会发出中断。
tx-usecs: 发送数据包时，NIC 等待的时间 (微秒)，超过该时间才会发出中断。
rx-frames: 接收数据包时，NIC 等待的帧数，超过该帧数才会发出中断。
tx-frames: 发送数据包时，NIC 等待的帧数，超过该帧数才会发出中断。

为什么要使用中断合并：

减少 CPU 使用率：中断合并可以减少 CPU 处理中断的次数，从而降低 CPU 使用率。
提高网络吞吐量：减少中断次数可以提高网络吞吐量，因为 CPU 可以花更多时间处理数据包，而不是处理中断。

中断合并的副作用：

增加延迟：中断合并可能会增加延迟，因为 NIC 需要等待更长时间才能发出中断。

如何查看和调整中断合并参数：

查看命令：ethtool -c ethX | --show-coalesce
调整命令：ethtool -C ethX rx-usecs value tx-usecs value | --coalesce (其中 value 是新的中断合并参数值)

如何监控中断状态：

监控命令：cat /proc/interrupts
监控指标：该命令会显示每个中断的触发次数，可以用来监控中断合并的效果。

软中断合并 (Interrupt Coalescing, soft IRQ) 和入站队列 (ingress qdisc)

netdev_budget_usecs: 定义了 NAPI (网络协议中断) 轮询周期中允许的最大时间长度 (微秒)。NAPI 轮询会持续进行，直到时间超过 netdev_budget_usecs 或处理的数据包数量达到 netdev_budget。
作用：软中断合并可以减少 CPU 处理软中断的次数，提高 CPU 利用率和网络性能。
监控指标：cat /proc/net/softnet_stat 可以查看软中断合并的统计信息，包括 dropped (由于 netdev_max_backlog 溢出而丢弃的数据包数量) 和 squeezed (由于 netdev_budget 或时间限制而无法处理完的数据包数量)。
调整命令：sysctl -w net.core.netdev_budget_usecs value 可以调整 netdev_budget_usecs 的值。

可以使用 sysctl parameter 来查看值，包括后面。

NAPI 轮询预算 (netdev_budget):

netdev_budget: 定义了 NAPI 轮询周期中允许从所有网络接口处理的最大数据包数量。在一次轮询周期中，所有注册了 NAPI 轮询的网络接口会以循环方式进行轮询。
作用：netdev_budget 限制了 NAPI 轮询周期中处理的数据包数量，避免单个网络接口占用过多 CPU 资源。
监控指标：cat /proc/net/softnet_stat 可以查看 NAPI 轮询的统计信息。
调整命令：sysctl -w net.core.netdev_budget value 可以调整 netdev_budget 的值。

网络接口权重 (dev_weight):

dev_weight: 定义了内核在 NAPI 中断中处理单个网络接口的最大数据包数量，这是一个每个 CPU 的变量。对于支持 LRO (大型接收卸载) 或 GRO_HW (硬件聚合接收) 的驱动程序，一个硬件聚合的数据包会被计为一个数据包。
作用：dev_weight 限制了 NAPI 中断中处理单个网络接口的数据包数量，避免单个网络接口占用过多 CPU 资源。
监控指标：cat /proc/net/softnet_stat 可以查看 NAPI 轮询的统计信息。
调整命令：sysctl -w net.core.dev_weight value 可以调整 dev_weight 的值。

入站队列最大长度 (netdev_max_backlog):

netdev_max_backlog: 定义了网络接口接收数据包的速度超过内核处理速度时，在入站队列 (ingress qdisc) 中允许的最大数据包数量。
作用：netdev_max_backlog 限制了入站队列的大小，避免数据包溢出导致丢包。
监控指标：cat /proc/net/softnet_stat 可以查看入站队列的统计信息。
调整命令：sysctl -w net.core.netdev_max_backlog value 可以调整 netdev_max_backlog 的值。

softnet_stat

https://insights-core.readthedocs.io/en/latest/shared_parsers_catalog/softnet_stat.html

出站队列长度 (txqueuelen) 和默认队列调度器 (default_qdisc)

出站队列长度 (txqueuelen):

txqueuelen: 定义了网络接口发送数据包的速度超过网络处理速度时，在出站队列 (egress qdisc) 中允许的最大数据包数量。
作用：txqueuelen 限制了出站队列的大小，避免数据包溢出导致丢包。它也为流量控制 (Traffic Control, TC) 提供了一个缓冲区，可以用来应对连接突发和流量整形。
监控指标：ip -s link 可以查看出站队列的统计信息。
调整命令：ip link set dev ethX txqueuelen N 可以调整 txqueuelen 的值，其中 ethX 是网络接口名称，N 是新的队列长度。

默认队列调度器 (default_qdisc):

default_qdisc: 定义了内核为网络设备使用的默认队列调度器。
作用：队列调度器负责管理出站队列中的数据包，并决定数据包发送的顺序。不同的队列调度器有不同的算法，可以用来优化网络性能，例如减少延迟、提高吞吐量、防止缓冲区膨胀 (bufferbloat) 等。
监控指标：tc -s qdisc ls dev ethX 可以查看当前使用的队列调度器。
调整命令：sysctl -w net.core.default_qdisc value 可以调整 default_qdisc 的值，其中 value 是新的队列调度器名称。

常见队列调度器：

pfifo_fast: 先入先出 (FIFO) 队列调度器，简单高效，但无法进行流量控制。
pfifo_backlog: 与 pfifo_fast 相似，但会记录每个连接的已发送数据包数量，可以用来防止连接突发。
codel: 一种基于延迟的队列调度器，可以有效地防止缓冲区膨胀。
fq_codel: 一种基于公平度的队列调度器，可以保证不同连接的公平性。
htb: 一种基于层次结构的队列调度器，可以用来进行复杂的流量控制。

TCP Read and Write Buffers/Queues

内存压力策略由 tcp_mem 和 tcp_moderate_rcvbuf 定义。

接收缓冲区 (`tcp_rmem`)

作用： tcp_rmem 定义了 TCP 套接字接收缓冲区的大小，用来存储从网络接收到的数据。接收缓冲区可以帮助应用程序应对网络延迟和突发流量，并提高数据传输效率。
参数： tcp_rmem 包含三个值：
- min: 在系统内存压力较大的情况下，接收缓冲区会缩小到 min 的大小。
- default: TCP 套接字创建时，接收缓冲区的大小会初始化为 default 的大小。
- max: 接收缓冲区的大小不会超过 max 的大小。
监控指标： cat /proc/net/sockstat 可以查看 TCP 套接字的接收缓冲区使用情况。
调整命令： sysctl -w net.ipv4.tcp_rmem="min default max" 可以调整 tcp_rmem 的值。

发送缓冲区 (`tcp_wmem`)

作用： tcp_wmem 定义了 TCP 套接字发送缓冲区的大小，用来存储要发送到网络的数据。发送缓冲区可以帮助应用程序应对网络延迟和突发流量，并提高数据传输效率。
参数： tcp_wmem 包含三个值：
- min: 在系统内存压力较大的情况下，发送缓冲区会缩小到 min 的大小。
- default: TCP 套接字创建时，发送缓冲区的大小会初始化为 default 的大小。
- max: 发送缓冲区的大小不会超过 max 的大小。
监控指标： cat /proc/net/sockstat 可以查看 TCP 套接字的发送缓冲区使用情况。
调整命令： sysctl -w net.ipv4.tcp_wmem="min default max" 可以调整 tcp_wmem 的值。

接收缓冲区自动调整 (`tcp_moderate_rcvbuf`)

作用： tcp_moderate_rcvbuf 启用后，TCP 会根据网络条件自动调整接收缓冲区的大小，以优化数据传输效率。
监控指标： cat /proc/net/sockstat 可以查看 TCP 套接字的接收缓冲区使用情况。
调整命令： sysctl -w net.ipv4.tcp_moderate_rcvbuf value 可以启用或禁用接收缓冲区自动调整功能。

注意：

调整 tcp_rmem 和 tcp_wmem 的值可能会影响应用程序的性能，建议在调整之前进行测试。
调整 tcp_rmem 和 tcp_wmem 的值需要重启应用程序才能生效。
启用 tcp_moderate_rcvbuf 会让内核自动调整接收缓冲区的大小，可能会导致一些应用程序出现问题，建议谨慎使用。

命令汇总：

参数	查看命令	调整命令	监控指标
`tcp_rmem`	`sysctl net.ipv4.tcp_rmem`	`sysctl -w net.ipv4.tcp_rmem="min default max"`	`cat /proc/net/sockstat`
`tcp_wmem`	`sysctl net.ipv4.tcp_wmem`	`sysctl -w net.ipv4.tcp_wmem="min default max"`	`cat /proc/net/sockstat`
`tcp_moderate_rcvbuf`	`sysctl net.ipv4.tcp_moderate_rcvbuf`	`sysctl -w net.ipv4.tcp_moderate_rcvbuf value`	`cat /proc/net/sockstat`

参考

linux-network-performance-parameters

EPUB 格式规范

2024-08-14T00:00:00.000Z

EPUB 格式是一种 zip 格式，大概由这些内容组成：

❯ tree
.
├── META-INF
│   └── container.xml
├── mimetype
└── OEBPS
    ├── content.opf
    ├── Images
    │   ├── book01_01.jpg
    │   ├── book01_02.jpg
    │   ├── book01_03.jpg
    │   ├── book01_04.jpg
    │   ├── book01_05.jpg
    │   ├── book01_06.jpg
    │   └── book01_info.jpg
    ├── Styles
    │   └── style.css
    ├── Text
    │   ├── book01_back_cover.xhtml
    │   ├── book01_front_cover.xhtml
    │   ├── book01_illustration01.xhtml
    │   ├── book01_illustration02.xhtml
    │   ├── book01_illustration03.xhtml
    │   ├── book01_illustration04.xhtml
    │   ├── book01_index.xhtml
    │   ├── book01_info.xhtml
    │   ├── by.xhtml
    │   ├── cover.xhtml
    │   ├── Section0001.xhtml
    │   ├── Section0002.xhtml
    │   ├── Section0003.xhtml
    │   ├── Section0004.xhtml
    │   ├── Section0005.xhtml
    │   ├── Section0006.xhtml
    │   ├── Section0007.xhtml
    │   ├── Section0008.xhtml
    │   ├── Section0009.xhtml
    │   ├── Section0010.xhtml
    │   ├── Section0011.xhtml
    │   ├── Section0012.xhtml
    │   ├── Section0013.xhtml
    │   ├── Section0014.xhtml
    │   └── Section0015.xhtml
    └── toc.ncx

Mime Type file: application/epub+zip.
META-INF folder (container file which points to the location of the .opf file), signatures, encryption, rights, are xml files
OEBPS folder stores the book content .(opf, ncx, html, svg, png, css, etc. files)

META-INF

这个文件夹下主要存储关于 EPUB 文件本身的元数据信息和描述性信息。

Container – META-INF/container.xml

container.xml 文件必须标识容器中包含的 EPUB 出版物的根文件的媒体类型和路径。

示例：



    
        
            media-type="application/oebps-package+xml" />

带有根文件 OEBPS/My Crazy Life.opf的 EPUB 出版物



    
        
            media-type="application/oebps-package+xml" />
        
            media-type="application/oebps-package+xml" />

将包含 SVG 和 XHTML 的《The Sandman》合并到同一个容器中

Encryption – META-INF/encryption.xml

Manifest – META-INF/manifest.xml

Metadata – META-INF/metadata.xml

Rights Management – META-INF/rights.xml

Digital Signatures – META-INF/signatures.xml

OEBPS

在 OEBPS 中包含两个必要文件：*.opf 和 *.ncx。

OPF

OPF 包含四个子元素：metadata, manifest, spine, guide.

Metadata

EPUB 的元数据，比如 title, language, identifier, cover, etc. title 和 identifier 是必要的。

identifier 由数字图书的创建者定义，必须唯一。对于图书出版商来说，
这个字段一般包括 ISBN 或者 Library of Congress 编号；也可以使用 URL 或者随机生成的唯一用户 ID。

示例：


  urn:uuid:53a846f0-302c-4f90-9798-bb219328309f
  三毛全集1.撒哈拉的故事
  三毛
  zh
  2016-08-18
  哈尔滨出版社
  2003-07-01
  7-80639-879-1/I·235

Manifest

列出了 package 中所包含的所有文件（包括 xhtml, css, png, ncx, etc）。

示例：

Spine

所有 xhtml 文档的阅读顺序，可以将 OPF spine 理解为是书中“页面”的顺序，
解析的时候按照文档顺序从上到下依次读取 spine。

在 spine 中的每个 itemref 元素都需要有一个 idref 属性，这个属性和 manifest 中的某个 ID 匹配。

spine 中的 linear 属性表明该项是作为线性阅读顺序中的一项，还是和先后次序无关。

示例：

Guide

出版物基本结构特征的一组参考，例如目录、前言、参考书目等。

NCX file

NCX file 是 Navigation Control file for XML 的缩写，通常命名为 toc.ncx。
该文件由 EPUB 文件的分层目录组成。

NCX 的标记中包含四个 meta 元素：

uid：数字图书的惟一 ID。该元素应该和 OPF 文件中的 dc:identifier 对应。
depth：反映目录表中层次的深度。
totalPageCount 和 maxPageNumber：仅用于纸质图书，保留 0 即可。

docTitle/text 的内容是图书的标题，和 OPF 中的 dc:title 匹配。

navMap 定义了图书的目录。navMap 包含一个或多个 navPoint 元素，每个 navPoint
都要包含下列元素：

playOrder: 说明文档的阅读顺序。和 OPF spine 中 itemref 元素的顺序相同。
navLabel/text: 该章节的标题。通常是本章的标题或者数字。
content: 其中的 src 属性指向包含这些内容的物理资源。为 OPF manifest 中声明的文件。
可以拥有多个 navPoint 元素。



 "http://www.daisy.org/z3986/2005/ncx-2005-1.dtd">
  
    
    
    
    
  
  
    三毛全集
  
  
    
      
        撒哈拉的故事
      
      
      
        
          目录
        
        
      
      
        
          妈妈的一封信（代序）
        
        
      
      
        
          回乡小笺（四版代序）
        
        
      
      
        
          沙漠中的饭店
        
        
      
      
        
          结婚记
        
        
      
      
        
          悬壶济世
        
        
      
      
        
          娃娃新娘
        
        
      
      
        
          荒山之夜
        
        
      
      
        
          沙漠观浴记
        
        
      
      
        
          爱的寻求
        
        
      
      
        
          芳邻
        
        
      
      
        
          素人渔夫
        
        
      
      
        
          死果
        
        
      
      
        
          天梯
        
        
      
      
        
          白手成家
        
        
      
      
        
          三毛一生大事记
        
        
      
    
    
      
        制作说明

NCX vs OPF spine

NCX 中有章节内容，OPF spine 主要描述章节顺序。NCX 更详细。

参考链接：

TCP 握手与挥手

2024-08-14T00:00:00.000Z

最近在看某个项目的一个功能：network-lock, 感觉还挺有意思的，于是写了一个 TCP Demo 来测试这个功能，但是在我手动将 server 关闭的时候发现不能马上使用上次 server 监听的端口，而是跟我说端口已被占用，有些好奇，于是就有了以下的一些折腾。顺便在这里记录一下关于 TCP 三次握手与挥手的笔记。顺带 tcpdump 分析。

介绍

在网络通信中，TCP（Transmission Control Protocol）是一种可靠的传输协议，而 TCP 三次握手是建立 TCP 连接时的重要过程之一。

概述

TCP 三次握手，包括三个步骤：

客户端发送 SYN 请求：客户端向服务器发送一个 SYN（同步）标志的数据包，表明它想要建立连接。
服务器响应 ACK 和 SYN：服务器接收到客户端的 SYN 请求后，向客户端发送一个 ACK（确认）数据包，表示已收到客户端的请求，并发送自己的 SYN 标志，以示同意建立连接。
客户端发送 ACK：客户端接收到服务器的 ACK 和 SYN 后，向服务器发送一个 ACK 确认数据包，表示已收到服务器的响应，连接建立完成。

代码示例与 tcpdump 分析

下面是一个 client 和 server 建立 TCP 连接的代码。我最开始是用 C 写的，但是后面发现 Python 写起来舒服多了。

这个 Server 会监听 localhost 的 8880 端口。
Server.py:

import socket


server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)


server_address = ('localhost', 8880)
print('Starting up on {} port {}'.format(*server_address))
server_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_FASTOPEN, 1)
server_socket.bind(server_address)

server_socket.listen(1)

while True:
    print('Waiting for a connection...')
    connection, client_address = server_socket.accept()
    try:
        print('Connection from', client_address)

        while True:
            try:
                data = connection.recv(1024)
                # TCP_QUICKACK
                # connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK, 1)
                print('Received:', data.decode())

                if not data:
                    print('No data received from', client_address)
                    break
            except ConnectionResetError:
                print('Connection is reset by the client')
                break
            except KeyboardInterrupt:
                print('KeyboardInterrupt')
                connection.close()
                exit(0)
    finally:
        connection.close()

这个 Client 会与 Server 建立连接并每隔 2s 发送当前时间给 Server。
Client.py:

import socket
import time

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server_address = ('localhost', 8880)
print('Connecting to {} port {}'.format(*server_address))
client_socket.connect(server_address)

try:
    while True:
        message = 'Hello, server! Time is {}'.format(time.ctime())
        print('Sending:', message)
        # client_socket.sendall(message.encode())
        client_socket.sendto(message.encode(), server_address)
        time.sleep(2)

finally:
    print('Closing the connection')
    client_socket.close()

运行这两个代码，使用 tcpdump 来监听 8880 端口的 tcp 数据包：

三次握手：

$ tcpdump -i lo -n port 8880  --absolute-tcp-sequence-numbers

tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on lo, link-type EN10MB (Ethernet), snapshot length 262144 bytes
16:18:18.333865 IP 127.0.0.1.57830 > 127.0.0.1.8880: Flags [S], seq 1857514943, win 33280, options [mss 65495,sackOK,TS val 3851230309 ecr 0,nop,wscale 7], length 0
16:18:18.333874 IP 127.0.0.1.8880 > 127.0.0.1.57830: Flags [S.], seq 3256784619, ack 1857514944, win 33280, options [mss 65495,sackOK,TS val 3851230309 ecr 3851230309,nop,wscale 7], length 0
16:18:18.333880 IP 127.0.0.1.57830 > 127.0.0.1.8880: Flags [.], ack 3256784620, win 260, options [nop,nop,TS val 3851230309 ecr 3851230309], length 0

16:18:18.333910 IP 127.0.0.1.57830 > 127.0.0.1.8880: Flags [P.], seq 1857514944:1857514991, ack 3256784620, win 260, options [nop,nop,TS val 3851230309 ecr 3851230309], length 47
16:18:18.333912 IP 127.0.0.1.8880 > 127.0.0.1.57830: Flags [.], ack 1857514991, win 260, options [nop,nop,TS val 3851230309 ecr 3851230309], length 0

PS: tcpdump 的参数说明：
i lo: 监听 lo 网卡
n: 不解析 IP 地址
port 8880: 只监听 8880 端口的数据包
absolute-tcp-sequence-numbers: 显示绝对的 TCP 序列号，如果不加这个参数，tcpdump 会显示相对的序列号。

tcpdump 输出的 Flags 字段解释：

[.] - ACK (Acknowledgment)
[S] - SYN (Start Connection)
[P] - PSH (Push Data)
[F] - FIN (Finish Connection)
[R] - RST (Reset Connection)
[S.] - SYN-ACK (SynAcK Packet)

可以看到，Client 发送了一个 SYN 数据包，Server 回复了一个 SYN+ACK 数据包，Client 再回复一个 ACK 数据包，三次握手完成。

seq 和 ack 是 TCP 数据包中的两个重要字段，seq 表示数据包的序列号，ack 表示确认号。SYN 数据包的 seq 是随机的，SYN+ACK 数据包的 seq 是随机的，ack 是 SYN 数据包的 seq+1，ACK 数据包的 seq 是 SYN+ACK 数据包的 ack，ack 是 SYN+ACK 数据包的 seq+1。

seq 和 ack 的作用是用来保证数据包的可靠传输。TCP 通过 seq 和 ack 来保证数据包的有序传输和可靠接收。

三次挥手与四次挥手：

三次挥手

1
2
3

16:21:10.284200 IP 127.0.0.1.57830 > 127.0.0.1.8880: Flags [F.], seq 1857515790, ack 3256784620, win 260, options [nop,nop,TS val 3851402259 ecr 3851400314], length 0
16:21:10.284297 IP 127.0.0.1.8880 > 127.0.0.1.57830: Flags [F.], seq 3256784620, ack 1857515791, win 260, options [nop,nop,TS val 3851402259 ecr 3851402259], length 0
16:21:10.284308 IP 127.0.0.1.57830 > 127.0.0.1.8880: Flags [.], ack 3256784621, win 260, options [nop,nop,TS val 3851402259 ecr 3851402259], length 0

三次挥手的过程只是将 FIN 与 ACK 数据包一同发送。

三次挥手是 Linux 默认开启 TCP 延迟确认机制，而 RFC795 中是四次挥手：https://www.rfc-editor.org/rfc/rfc793#section-3.5

关于 TCP 延迟确认机制，可以使用 TCP_QUICKACK 关闭：https://www.man7.org/linux/man-pages/man7/tcp.7.html, 关于这个参数，这个参数并不是 永久性的，设置或清除这个标志只会暂时地启用或禁用快速确认模式。随后的 TCP 协议操作会根据内部协议处理和延迟确认超时等因素再次进入或退出快速确认模式。因此，这个标志的状态在操作过程中可能会动态变化。可以看上面的 server.py 中的使用方法

RFC1122 中对 Delay ACK 的说明：

1
2
3

Delayed ACK's
Delay < 0.5 seconds
2nd full-sized segment ACK'd

如 RFC1122 所说，一个主机可以延迟发送 ACK 报文高达 500 毫秒。此外，以每完整的数据包为一段，ACK 报文必须每两段发送一次（所以上面的三次挥手过程最后会发送一个 ACK 报文）。

延迟的 ACK 可以使应用程序有机会更新 TCP 接收窗口，也可以立即发送 ACK 报文。对于某些协议（如 Telnet），通过将 ACK、窗口更新和响应数据组合到一个段中，可以将服务器发送的响应数量减少 3 倍。

四次挥手

Client 发送一个 FIN 数据包，表示不再发送数据了。进入 FIN_WAIT_1 状态。
Server 收到 FIN 数据包后，回复一个 ACK 数据包，表示收到了 Client 的 FIN 数据包。进入 CLOSED_WAIT 状态。
Client 收到 ACK 数据包，进入 FIN_WAIT_2 状态。
Server 发送一个 FIN 数据包，表示不再发送数据了。进入 LAST_ACK 状态。
Client 收到 FIN 数据包后，回复一个 ACK 数据包，表示收到了 Server 的 FIN 数据包。进入 TIME_WAIT 状态。
服务端收到了 ACK 应答报文后，就进入了 CLOSE 状态，至此服务端已经完成连接的关闭。

首先发出 FIN 的一侧，如果在给“对侧”的 FIN 响应了 ACK（发送了最后一个 ACK 数据包），那么就会超时等待 2 * MSL 时间（处于 TIME_WAIT 状态），然后关闭连接。在这段超时等待时间内，本地的端口不能被新连接使用；

RFC793 定义了 MSL 为 2 分钟，Linux 设置成了 30s 。参数 tcp_max_tw_buckets 控制并发的 TIME_WAIT 的数量，默认值是 180000，如果超限，那么，系统会把多的 TIME_WAIT 状态的连接给 destory 掉，然后在日志里打一个警告（如：time wait bucket table overflow）

这也就是手动将 server 进程杀掉之后，端口仍被占用的原因。TCP 连接关闭之后，不会马上释放这个 socket，之后任何想将新 socket 绑定到相同的地址和端口的操作都会失败，直到旧的 socket 关闭为止。

可以使用 SO_REUSEADDR 解决这个问题。https://stackoverflow.com/questions/14388706/how-do-so-reuseaddr-and-so-reuseport-differ
还有一种方式是设置 SO_LINGER 选项的超时时长参数为 0。这是不推荐使用的方法：https://stackoverflow.com/questions/3757289/when-is-tcp-option-so-linger-0-required

TIEM_WAIT 的意义

这个状态是避免延时的包的到达与随后的新连接相混淆和保证「被动关闭连接」的一方，能被正确的关闭。

保证「被动关闭连接」的一方可以被正确关闭：

如果客户端（主动关闭方）最后一次 ACK 报文（第四次挥手）在网络中丢失了，那么按照 TCP 可靠性原则，服务端（被动关闭方）会重发 FIN 报文。

假设客户端没有 TIME_WAIT 状态，而是在发完最后一次回 ACK 报文就直接进入 CLOSE 状态，如果该 ACK 报文丢失了，服务端则重传的 FIN 报文，而这时客户端已经进入到关闭状态了，在收到服务端重传的 FIN 报文后，就会回 RST 报文。

TCP Fast Open

2024-08-14T00:00:00.000Z

折腾 TCP 的同时看到了 TCP Fast Open 这个有趣的参数，它是对 TCP 的优化，无需等待 3 次握手，应用程序就可以通过 TCP 发送数据。

正常 TCP 建立连接过程：

    Client                                               Server

1.  CLOSED                                               LISTEN

2.  SYN-SENT    -->           SYN M                  --> SYN-RECEIVED

3.  ESTABLISHED <--        SYN N,ACK M+1             <-- SYN-RECEIVED

4.  ESTABLISHED -->          ACK N+1                 --> ESTABLISHED

当前 TCP 实现的问题是，只有在连接发起方收到来自对等 TCP 的 ACK（确认）段后，才能在连接上交换数据。也就是说，只有在三次握手的第三步（发起方发送的 ACK 报文段）中，数据才能从客户端发送到服务器。因此，在对等点之间交换数据之前，就会损失一个完整的往返时间 (round trip time) 。这种丢失的 RTT 是短网络对话延迟的重要组成部分。TCP Fast Open 就是为了解决这个问题。

消除 RTT

    Client                                               Server

1.  CLOSED                                               LISTEN

2.  SYN-SENT    --> SYN, with cookie + data          --> SYN-RECEIVED---
                                                                       | Server TCP validates cookie, passes data to application
3.  Client      <--        SYN-ACK                   <-- SYN-RECEIVED---

4.  Client      <--        responses                 <-- Server          Server can send responses before receiving client ACK

4.  ESTABLISHED -->          ACK                     --> ESTABLISHED

上图所示步骤如下：

客户端 TCP 发送 SYN，其中包含 TFO cookie（指定为 TCP 选项）和来自客户端应用程序的数据。
服务器 TCP 通过基于新 SYN 的源 IP 地址重复加密过程来验证 TFO cookie。如果 cookie 被证明是有效的，那么服务器 TCP 就可以确信这个 SYN 来自它声称来自的地址。这意味着服务器 TCP 可以立即将应用程序数据传递给服务器应用程序。
从这里开始，TCP 会话正常进行：服务器 TCP 向客户端发送 SYN-ACK 段，然后客户端 TCP 进行确认，从而完成三向握手。服务器 TCP 还可以在收到客户端的 ACK 之前向客户端 TCP 发送响应数据段。

这是一个使用 tcpdump 查看使用了 TCP_FAST_OPEN 选项的抓包记录：

1. IP 127.0.0.1.51902 > 127.0.0.1.8000: Flags [S], seq 3550480872:3550480878, win 33280, options [mss 65495,sackOK,TS val 1437621030 ecr 0,nop,wscale 7,tfo  cookie ce80700cf8e6113c,nop,nop], length 6
2. IP 127.0.0.1.8000 > 127.0.0.1.51902: Flags [S.], seq 2245778431, ack 3550480873, win 33280, options [mss 65495,sackOK,TS val 1437621030 ecr 1437621030,nop,wscale 7], length 0
3. IP 127.0.0.1.51902 > 127.0.0.1.8000: Flags [P.], seq 3550480873:3550480879, ack 2245778432, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 6
4. IP 127.0.0.1.8000 > 127.0.0.1.51902: Flags [.], ack 3550480879, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 0
5. IP 127.0.0.1.8000 > 127.0.0.1.51902: Flags [P.], seq 2245778432:2245778438, ack 3550480879, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 6
6. IP 127.0.0.1.51902 > 127.0.0.1.8000: Flags [.], ack 2245778438, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 0
7. IP 127.0.0.1.8000 > 127.0.0.1.51902: Flags [F.], seq 2245778438, ack 3550480879, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 0
8. IP 127.0.0.1.51902 > 127.0.0.1.8000: Flags [F.], seq 3550480879, ack 2245778439, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 0
9. IP 127.0.0.1.8000 > 127.0.0.1.51902: Flags [.], ack 3550480880, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 0

可以看到 3 这个数据段在 4 这个 ACK 数据包之前。并且 options 中有一个 cookie 字段。

Server.py:

import socket


server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)


server_address = ('localhost', 8880)
print('Starting up on {} port {}'.format(*server_address))
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_FASTOPEN, 1)
server_socket.bind(server_address)

server_socket.listen(1)

while True:
    print('Waiting for a connection...')
    connection, client_address = server_socket.accept()
    try:
        print('Connection from', client_address)

        while True:
            data = connection.recv(1024)
            # TCP_QUICKACK
            connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK, 1)
            print('Received:', data.decode())

            if not data:
                print('No data received from', client_address)
                break

    finally:
        connection.close()

Client.py:

import socket

addr = ("localhost", 8880)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.sendto("hello!".encode(), 536870912, addr)

print(s.recv(1000))

sendto 需要提供 ip, 因为是 connectionless.

具体参考：

[1] https://lwn.net/Articles/508865/

Ansible

2024-08-12T00:00:00.000Z

一些关于 Ansible 的笔记。

Playbook

Playbooks 是自动化蓝图，它们采用 yml 格式，Ansible 使用它们来部署和配置被管理的节点。

Playbook

一个 playbook 是一个 plays 的列表，它们定义了 Ansible 执行操作的顺序（从上到下），以实现一个整体目标。

Play

一个 play 是一个任务（tasks）的有序列表，这些任务映射到 inventory 中的被管理节点。

Task

一个 task 是对单个模块的引用，它定义了 Ansible 将要执行的操作。

可以理解为脚本

Module

模块是 Ansible 在被管理节点上运行的代码或二进制文件的单元。Ansible 模块被分组在 collections 中，每个模块都有一个完全限定的集合名称（FQCN）。

Ansible 自带的 Modules: https://docs.ansible.com/ansible/latest/collections/index.html. 也可以自己实现。

可以使用 ansible-doc 查看某个模块。

自定义 Module

https://docs.ansible.com/ansible/latest/reference_appendices/module_utils.html

示例：


from ansible.module_utils.basic import AnsibleModule

def run_module():
    module_args = dict(
        path=dict(type='str', required=True)
    )

    result = dict(
        changed=False,
        original_message='',
        message=''
    )

    module = AnsibleModule(
        argument_spec=module_args,
        supports_check_mode=True
    )

    path = module.params['path']

    try:
        with open(path, 'r') as file:
            content = file.read()
        result['message'] = content
    except Exception as e:
        module.fail_json(msg=str(e), **result)

    module.exit_json(**result)

def main():
    run_module()

if __name__ == '__main__':
    main()

使用模块：

在你的 playbook 中引用自定义模块：

- name: Test custom module
  hosts: localhost
  tasks:
    - name: Read content from file
      my_module:
        path: /path/to/your/file.txt
      register: result

    - name: Show result
      debug:
        var: result.message

运行 playbook：

确保 my_module.py 文件在 library 目录下，Ansible 会自动查找该目录中的模块。然后运行你的 playbook：

1	ansible-playbook your_playbook.yml

示例

为了更好地理解这些概念，以下是一个简单的 playbook 示例：

- name: Ensure web server is installed and running
  hosts: webservers
  become: yes

  tasks:
    - name: Install Apache
      ansible.builtin.yum:
        name: httpd
        state: present

    - name: Start Apache service
      ansible.builtin.service:
        name: httpd
        state: started

在这个示例中：

Playbook 是整个 yml 文件。
Play 是从 - name: Ensure web server is installed and running 开始的部分。
Task 是 Install Apache 和 Start Apache service 这两个步骤。
Module 是 ansible.builtin.yum 和 ansible.builtin.service，它们分别用于安装 Apache 和启动 Apache 服务。

kubespray

kubespray 就是使用 ansible 进行生产环境的 k8s 部署，ansible 提供一个 playbook cluster.yml，类似：

- hosts: bastion:k8s_cluster:etcd_k8s
  gather_facts: True
  roles:
    - { role: kubernetes/pre-pkg/releases }

hosts: bastion:k8s_cluster:etcd_k8s: 这部分指定了要运行 playbook 的目标主机（或主机组）。bastion, k8s_cluster, etcd_k8s 可能是定义在你的 Ansible 清单文件中的主机或主机组。这意味着该任务将会在这些主机上执行。

gather_facts: True: 这个选项表示在执行任务之前，Ansible 会收集目标主机的事实（即主机的系统信息，如 IP 地址、操作系统类型等）。这些事实可以在后续任务中使用。

roles: 这部分定义了要在目标主机上执行的角色列表。每个角色包含了一系列任务、变量、模板和其他文件，可以自动应用到目标主机上。

{ role: kubernetes/pre-pkg/releases }: 这是一种简化的方式来定义角色。在这里，kubernetes/pre-pkg/releases 是角色的名称，表示这是一个与 Kubernetes 相关的角色，位于 pre-pkg/releases 目录中。这个角色可能包含了一些预定义的任务，用于设置或管理 Kubernetes 集群的特定组件或版本。

roles 是 Ansible 用来组织和复用代码的机制，通过指定一个或多个角色，可以在多个主机上执行复杂的自动化任务。

在 role 目录下有一系列 task 文件，比如：

defaults:
作用：存储角色的默认变量值。defaults/main.yml 文件通常包含所有角色的默认设置。这些默认值可以在 playbook 或 vars 文件中被覆盖。
files:
作用：存放角色可能需要分发到目标主机上的静态文件。Ansible 的 copy 或 template 模块可以从这个目录中复制文件到目标主机。
handlers:
作用：存储在任务中触发的处理程序（handlers）。处理程序通常在某个条件满足时被调用，例如在配置文件改变后重新启动服务。
meta:
作用：存储角色的元数据文件，通常是 main.yml 文件。元数据文件定义了角色的依赖关系、支持的 Ansible 版本、以及其他角色的依赖等信息。
tasks:
作用：存放角色的主要任务文件。tasks/main.yml 是角色执行的主要任务入口文件，可能导入其他任务文件。
templates:
作用：存放 Jinja2 模板文件。模板文件通常用于动态生成配置文件，并通过 template 模块分发到目标主机。
vars:
作用：存储角色的变量文件。vars/main.yml 文件通常包含在角色中定义的变量，这些变量的优先级比 defaults 中定义的更高，但比 playbook 中定义的低。

minikube 设置代理

2024-08-10T00:00:00.000Z

在好久以前就折腾过 minikube 的代理配置，但是当时懒得写下来（其实也没啥配置步骤），想了想还是写下来算了，以后免得又忘记。

minikube 会在宿主机上创建一个 bridge 让集群与宿主机通信：

39: br-820c7fa60371:  mtu 1500 qdisc noqueue state UP group default
    link/ether 02:42:8d:3f:96:ae brd ff:ff:ff:ff:ff:ff
    inet 192.168.49.1/24 brd 192.168.49.255 scope global br-820c7fa60371
       valid_lft forever preferred_lft forever

可以使用 minikube profile list 查看：

❯ minikube profile list
|----------|-----------|---------|--------------|------|---------|---------|-------|----------------|--------------------|
| Profile  | VM Driver | Runtime |      IP      | Port | Version | Status  | Nodes | Active Profile | Active Kubecontext |
|----------|-----------|---------|--------------|------|---------|---------|-------|----------------|--------------------|
| minikube | docker    | docker  | 192.168.49.2 | 8443 | v1.30.0 | Running |     1 | *              | *                  |
|----------|-----------|---------|--------------|------|---------|---------|-------|----------------|--------------------|

也就是可以将环境变量修改成 192.168.49.1 地址就可以将让集群使用宿主机的代理：

k8s_proxy() {
  proxy_server="http://192.168.49.1:10809"
  no_proxy="localhost,127.0.0.1,.local,192.168.49.2"
  export http_proxy="$proxy_server"
  export https_proxy="$proxy_server"
  export all_proxy="$proxy_server"
  export HTTP_PROXY="$proxy_server"
  export HTTPS_PROXY="$proxy_server"
  export ALL_PROXY="$proxy_server"

  export no_proxy="$no_proxy"
  export NO_PROXY="$no_proxy"
}

代理客户端监听至 0.0.0.0 ~~（虽然有些危险，但是自己的电脑应该也没事吧）~~。

Linux 设置默认麦克风以及音频输出

2024-07-24T00:00:00.000Z

最近在想办法医治我的拖延症，于是从各种出现的小问题开始解决。因为我其中一台笔记本在飞书开会的时候经常会出现默认麦克风无法使用的情况，经常需要调整，不说很大的问题，但是也是一个小问题。

没有使用 PulseAudio 作为我的音频服务器，如果是想查看 PulseAudio 的设置方法，参考 Arch Wiki。

通过 PipeWire 设置默认麦克风。最开始我参考 Arch Wiki
中的内容，使用 arecord -L 查看所有设备：

1	arecord -L

输出：

null
    Discard all samples (playback) or generate zero samples (capture)
pipewire
    PipeWire Sound Server
default
    Default ALSA Output (currently PipeWire Media Server)
sysdefault:CARD=sofhdadsp
    sof-hda-dsp,
    Default Audio Device

才发现默认麦克风由 PipeWire 控制。所以直接配置 PipeWire 来选择默认的录音设备，不修改 ~/.asoundrc。

查看麦克风设备：

1	pactl list short sources

输出：

48      alsa_output.pci-0000_00_1f.3-platform-skl_hda_dsp_generic.HiFi__HDMI3__sink.monitor       PipeWire s24-32le 2ch 48000Hz    SUSPENDED
49      alsa_output.pci-0000_00_1f.3-platform-skl_hda_dsp_generic.HiFi__HDMI2__sink.monitor       PipeWire s24-32le 2ch 48000Hz    SUSPENDED
50      alsa_output.pci-0000_00_1f.3-platform-skl_hda_dsp_generic.HiFi__HDMI1__sink.monitor       PipeWire s24-32le 2ch 48000Hz    SUSPENDED
51      alsa_output.pci-0000_00_1f.3-platform-skl_hda_dsp_generic.HiFi__Speaker__sink.monitor     PipeWire s32le 2ch 48000Hz       SUSPENDED
52      alsa_input.pci-0000_00_1f.3-platform-skl_hda_dsp_generic.HiFi__Mic2__source       PipeWires24-32le 2ch 48000Hz     SUSPENDED
53      alsa_input.pci-0000_00_1f.3-platform-skl_hda_dsp_generic.HiFi__Mic1__source       PipeWires32le 2ch 48000Hz        SUSPENDED

所以到底哪一个是有效的麦克风呢？我并没有去往下查找这些麦克风命名的规范以及各种信息，可以看到最右边的输出是 SUSPENDED，所以可以通过开启麦克风来进行测试（我也不知道为什么使用 arecord 命令麦克风会正常工作，或许是全遍历一边吧）：

1	arecord -vv --format=dat /dev/null

这时，就可以发现处于 RUNNING 的麦克风设备是可以正常工作的了，选择设备名称，设置为默认麦克风：

1	pactl set-default-source

验证一下：

1	pactl info \| grep "Default Source"

好，现在飞书会议麦克风设置成系统默认也可以正常工作了。

音频输出方面是因为笔记本每次插上 HDMI 之后都会错误都会错误切换到 HDMI 那边，然而显示器并没有这个功能。

同样列出可用的输出设备（Sinks）：

1	pactl list sinks

或者：

1	pactl list sinks

找到能出声的输出设备，把它设置成默认输出设备：

1	pactl set-default-sink alsa_output.pci-0000_00_1f.3-platform-skl_hda_dsp_generic.HiFi__Speaker__sink

参考：

Vhost-user Protocol

2024-07-04T00:00:00.000Z

vhost-user enables VIRTIO devices to be implemented as separate processes outside of QEMU.

SAR 命令输出解释

2024-04-16T00:00:00.000Z

SAR (System Activity Reporter)

在这里记录一下 sar 输出的解释，以及输出的指标有什么作用。
其实都在 mannual 中说的很清楚了，在这里记录只是加深自己的理解和分析这些参数可以知道什么。

sar 功能：

sar 收集系统的性能数据，包括 CPU 使用率、内存使用情况、磁盘 IO、网络流量等，并以可读的格式呈现。
sar 还可以生成历史数据报告，帮助管理员了解系统的负载、趋势和峰值。

常用参数：

-u：CPU 使用情况
-r：内存使用情况
-b：磁盘 IO 情况
-n：网络流量情况
-q：负载情况

CPU

下面命令每隔 1 秒输出所有信息一次，总共输出 10 次。

1	sar -u ALL 1 10

输出：

Linux 6.8.4-arch1-1 (xun) 04/16/2024 _x86_64_(20 CPU)

10:21:16 AM     CPU      %usr     %nice      %sys   %iowait    %steal      %irq     %soft    %guest    %gnice     %idle
10:21:17 AM     all      0.75      0.00      0.60      0.00      0.00      0.15      0.05      0.00      0.00     98.45
10:21:18 AM     all      0.61      0.00      0.35      0.00      0.00      0.10      0.05      0.00      0.00     98.89
10:21:19 AM     all      2.31      0.00      0.70      0.00      0.00      0.25      0.05      0.00      0.00     96.69
10:21:20 AM     all      0.85      0.00      0.55      0.05      0.00      0.15      0.05      0.00      0.00     98.35
10:21:21 AM     all      0.55      0.00      0.55      0.00      0.00      0.00      0.15      0.00      0.00     98.75
10:21:22 AM     all      0.70      0.00      0.30      0.00      0.00      0.15      0.15      0.00      0.00     98.69
10:21:23 AM     all      0.50      0.00      0.25      0.00      0.00      0.05      0.00      0.00      0.00     99.19
10:21:24 AM     all      0.55      0.00      0.30      0.00      0.00      0.10      0.00      0.00      0.00     99.05
10:21:25 AM     all      0.35      0.00      0.30      0.00      0.00      0.10      0.10      0.00      0.00     99.15
10:21:26 AM     all      0.65      0.00      0.30      0.00      0.00      0.15      0.05      0.00      0.00     98.85
Average:        all      0.78      0.00      0.42      0.01      0.00      0.12      0.07      0.00      0.00     98.61

%user / %usr：
- %user 或 %usr 表示 CPU 在执行用户级别（应用程序）任务时的利用率。这包括处理运行在用户空间的应用程序和处理器等待其工作完成的时间。高的 %user 值可能表示系统上有许多用户级别任务在运行。
- 示例：%user 或 %usr 在 50% 以上，可能表示系统上有大量用户级别任务正在运行。
这两个指标的区别在于是否包括运行虚拟处理器的时间。%user 包括，%usr 不包括。
%nice：
- %nice 表示 CPU 在执行用户级别（应用程序）任务，并具有 nice 优先级的任务时的利用率。nice 值较高的任务具有较低的优先级。
- 示例：%nice 在 10% 以上，可能表示有一些优先级较低的任务正在执行。
%system / %sys：
- %system 或 %sys 表示 CPU 在执行系统级别（内核）任务时的利用率。这包括内核运行的系统任务、处理中断和执行系统调用的时间。
- 示例：%system 或 %sys 在 20% 以上，可能表示系统内核在执行大量的系统级别任务或处理中断。
%system 包括服务硬件和软件中断的时间，%sys 不包括。
%iowait：
- %iowait 表示 CPU 在等待磁盘 IO 完成时的空闲时间百分比。如果此值较高，则表示系统中有较多的 IO 操作正在进行，可能存在 IO 瓶颈。
- 示例：%iowait 在 30% 以上，可能表示系统中存在磁盘 IO 瓶颈。但只是可能，因为 iowait 是以一个 CPU 的角度的状态，而不是以进程的状态。
  参考 iowait 的含义
%steal：
- %steal 表示在虚拟化环境中，CPU 被其他虚拟处理器占用时的时间百分比。这可能由于宿主系统或其他虚拟机的高 CPU 使用率导致。
- 示例：%steal 在 5% 以上，可能表示虚拟化环境中 CPU 竞争较高。
%irq / %soft：
- %irq 表示 CPU 用于处理硬件中断的时间百分比，而 %soft 表示 CPU 用于处理软件中断的时间百分比。高的值可能表示系统中有较多的中断发生。
- 示例：%irq 或 %soft 在 5% 以上，可能表示系统中有大量的中断发生。
%guest / %gnice：
- %guest 或 %gnice 表示 CPU 用于运行虚拟处理器的时间百分比，或者用于运行具有 nice 优先级的虚拟处理器的时间百分比。
- 示例：%guest 或 %gnice 在 10% 以上，可能表示虚拟化环境中的虚拟处理器占用较多 CPU 资源。
%idle：
- %idle 表示 CPU 空闲且系统没有未完成的磁盘 IO 请求的时间百分比。较高的 %idle 值表示系统的 CPU 使用率较低。
- 示例：%idle 在 60% 以上，表示系统中的 CPU 大部分时间处于空闲状态。

与 iostat 输出参数中关于 CPU 的差不多。

Memory

kbmemused：
- 表示已使用的内存量（以千字节为单位），计算公式为总安装内存 - kbmemfree - kbbuffers - kbcached - kbslab。
%memused：
- 表示已使用内存的百分比。
kbbuffers：
- 表示内核用作缓冲区的内存量（以千字节为单位）。
kbcached：
- 表示内核用作缓存的数据内存量（以千字节为单位）。
kbcommit：
- 表示当前工作负载所需的内存量（以千字节为单位），是确保系统永远不会发生内存不足的估计值，包括 RAM 和 swap 需要的内存。
%commit：
- 表示当前工作负载所需内存的百分比，相对于总内存（RAM+swap）。由于内核通常会过度承诺内存，因此此数字可能大于 100%。
kbactive：
- 表示活跃内存量（以千字节为单位），最近使用且通常不会被回收的内存。
kbinact：
- 表示非活跃内存量（以千字节为单位），较长时间未被使用，更容易被回收以用于其他目的的内存。
kbdirty：
- 表示等待写回磁盘的内存量（以千字节为单位）。
kbanonpg：
- 表示映射到用户空间页表中的非文件备份页面的内存量（以千字节为单位）。
kbslab：
- 表示内核用于缓存数据结构的内存量（以千字节为单位）。
kbkstack：
- 表示用于内核堆栈空间的内存量（以千字节为单位）。
kbpgtbl：
- 表示用于最低级别页表的内存量（以千字节为单位）。
kbvmused：
- 表示已使用的虚拟地址空间的内存量（以千字节为单位）。

MYSQL 101

2024-04-14T00:00:00.000Z

MYSQL 的一些常见命令总结，方便自己更快复习。

一些常用的重要的 SQL 命令

SELECT - extracts data from a database
UPDATE - updates data in a database
DELETE - deletes data from a database
INSERT INTO - inserts new data into a database
CREATE DATABASE - creates a new database
ALTER DATABASE - modifies a database
CREATE TABLE - creates a new table
ALTER TABLE - modifies a table
DROP TABLE - deletes a table
CREATE INDEX - creates an index (search key)
DROP INDEX - deletes an index

SELECT

语法：

1 2	SELECT column1, column2, ... FROM table_name;

1	SELECT * FROM table_name;

SELECT DISTINCT

SELECT DISTINCT 语句用于返回不同的值。

1 2	SELECT DISTINCT column1, column2, ... FROM table_name;

获取不同的 column 的数量：

1	SELECT COUNT(DISTINCT column) FROM table_name;

WHERE

WHERE 子句用于过滤记录。

1
2
3

SELECT column1, column2, ...
FROM table_name
WHERE condition;

WHERE 还可以用于 UPDATE，DELETE 等等。

AND/OR/NOT

WHERE 子句可以和 AND, OR, NOT 运算符结合使用。

AND

1
2
3

SELECT column1, column2, ...
FROM table_name
WHERE condition1 AND condition2 AND condition3 ...;

OR

1
2
3

SELECT column1, column2, ...
FROM table_name
WHERE condition1 OR condition2 OR condition3 ...;

NOT

1
2
3

SELECT column1, column2, ...
FROM table_name
WHERE NOT condition;

AND 和 OR, NOT 结合使用

在满足 condition1 的同时满足 condition2/condition3:

1 2	SELECT * FROM table_name WHERE condition1 AND (condition2 OR condition3)

多个否定：

1 2	SELECT * FROM table_name WHERE NOT condition1 AND NOT condition2;

ORDER BY

ORDER BY 关键字用于按升序或降序对结果集进行排序。

1
2
3

SELECT column1, column2, ...
FROM table_name
ORDER BY column1, column2, ... ASC|DESC;

ASC:Ascending（升序）, DESC: descending（降序）

INSERT INTO

INSERT INTO 语句用于在表中插入新记录。

指定要插入的值：

1 2	INSERT INTO table_name (column1, column2, column3, ...) VALUES (value1, value2, value3, ...)

向表的所有列添加内容，不需要在 SQL 中指定列名称：

1 2	INSERT INTO table_name VALUES(value1, value2, value3, ...);

NULL 值

判断一个字段是否为 NULL:

1
2
3

SELECT column_names
FROM table_name
WHERE column_name IS NULL;

与 NOT 配合使用：

1
2
3

SELECT column_name
FROM table_name
WHERE column_name IS NOT NULL;

UPDATE SET

UPDATE 用于更新已存在的记录。

1
2
3

UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;

WARN: 注意使用 UPDATE SET 语句时要添加 WHERE，不然，表中的所有记录都会被修改。

DELETE

1	DELETE FROM table_name WHERE condition;

LIMIT

LIMIT 指定返回的记录数。

SELECT column_name
FROM table_name
WHERE condition
LIMIT number;

从查找出的记录中返回前 3 条记录：

1 2	SELECT * FROM table_name LIMIT 3;

配合 OFFSET 使用

从查找出来的第 3 个记录开始返回（不包括第 3 个）：

1 2	SELECT * FROM table_name LIMIT 3 OFFSET 3;

常用于分页返回

配合 WHERE 使用

1
2
3

SELECT * FROM table_name
WHERE condition
LIMIT 3;

MYSQL Functions

一些常见的函数。

MIN(), MAX()

MIN() 函数返回所选列的最小值。
MAX() 函数返回所选列的最大值。

1
2
3

SELECT MIN(column_name)
FROM table_name
WHERE condition;

1
2
3

SELECT MAX(column_name)
FROM table_name
WHERE condition;

COUNT(), AVG(), SUM()

COUNT() 函数返回与指定条件匹配的行数。

1
2
3

SELECT COUNT(column_name)
FROM table_name
WHERE condition;

AVG() 函数返回列的值为数字的平均值。

1
2
3

SELECT AVG(column_name)
FROM table_name
WHERE condition;

SUM() 函数返回列的值为数字的总和。

1
2
3

SELECT SUM(column_name)
FROM table_name
WHERE condition;

LIKE

LIKE 运算符在 WHERE 子句中使用以搜索列中的指定模式。

有两个通配符经常与 LIKE 运算符一起使用：

百分号 % 表示零个、一个或多个字符
下划线符号 _ 代表一个，单个字符。（占位符）

百分号和下划线可以组合使用。

以 a 开头且必须要两个字符以上：

1 2	SELECT * FROM table_name WHERE column_name LIKE 'a_%';

IN

IN 运算符允许在 WHERE 子句中指定多个值。

IN 运算符是多个 OR 条件的简写。

1
2
3

SELECT *
FROM table_name
WHERE column_name IN (value1, value2, ...);

BETWEEN

BETWEEN 运算符选择给定范围内的值。这些值可以是数字、文本或日期。

BETWEEN 运算符具有包容性：包括开始值和结束值。

1
2
3

SELECT *
FROM table_name
WHERE column_name BETWEEN value1 AND value2;

当 BETWEEN 比较的是字符串时，会按照字符串的字典序进行比较。

别名 AS

别名用于为表或表中的列提供临时名称。

别名通常用于使列名更具可读性。

别名仅在该查询期间存在。

使用 AS 关键字创建别名。

Alias Column:

1 2	SELECT column_name AS alias_name FROM table_name;

Alias Table:

1 2	SELECT column_name FROM table_name AS alias_name;

JOIN

JOIN 子句用于根据它们之间的相关列组合来自两个或多个表的行。

四种 JOIN 类型：

INNER JOIN：返回两个表中值匹配的记录
LEFT JOIN：返回左表所有记录，右表匹配记录
RIGHT JOIN：返回右表的所有记录，以及左表的匹配记录
CROSS JOIN：返回两个表中的所有记录

INNER/LEFT/RIGHT 语法：

返回符合两表中 column3 相等的 table1.column1 和 table2.column1 列：

SELECT table1.column1, table2.column1, ...
FROM table1
INNER/LEFT/RIGHT JOIN table2
ON table1.column3=table2.column3;

CROSS 语法：

1
2
3

SELECT column_names,....
FROM table1
CROSS JOIN table2;

下面以这两个表为例：

mysql> select * from fruits;
+------+--------+
| id   | name   |
+------+--------+
|    1 | apple  |
|    2 | banana |
|    3 | cherry |
|    4 | peach  |
|    7 | test   |
+------+--------+

mysql> select * from product;
+------+------+---------+
| id   | fid  | pname   |
+------+------+---------+
|    1 |    1 | apples  |
|    2 |    2 | bananas |
|    3 |    3 | cherrys |
|    4 |    4 | peachs  |
+------+------+---------+

INNER JOIN

LEFT JOIN

LEFT JOIN 关键字返回左表中的所有记录，即使右边没有匹配项。

mysql> select p.pname, f.name from product as p left join fruits as f on p.fid=f.id;
+---------+--------+
| pname   | name   |
+---------+--------+
| apples  | apple  |
| bananas | banana |
| cherrys | cherry |
| peachs  | peach  |
+---------+--------+

可以看到匹配的全是左表的记录。可以看 RIGHT JOIN 示例。

RIGHT JOIN

RIGHT JOIN 关键字返回右表中的所有记录，即使左边没有匹配项。

mysql> select p.pname, f.name from product as p right join fruits as f on p.fid=f.id;
+---------+--------+
| pname   | name   |
+---------+--------+
| apples  | apple  |
| bananas | banana |
| cherrys | cherry |
| peachs  | peach  |
| NULL    | test   |
+---------+--------+

看到 pname 为 NULL 这里返回右表 fruits 的所有内容，不管有没有匹配上。
只不过 pname 为 NULL。

CROSS JOIN

CROSS JOIN 返回两个表行数的乘积。

mysql> select p.pname,f.name from product as p cross join fruits as f;
+---------+--------+
| pname   | name   |
+---------+--------+
| peachs  | apple  |
| cherrys | apple  |
| bananas | apple  |
| apples  | apple  |
| peachs  | banana |
| cherrys | banana |
| bananas | banana |
| apples  | banana |
| peachs  | cherry |
| cherrys | cherry |
| bananas | cherry |
| apples  | cherry |
| peachs  | peach  |
| cherrys | peach  |
| bananas | peach  |
| apples  | peach  |
| peachs  | test   |
| cherrys | test   |
| bananas | test   |
| apples  | test   |
+---------+--------+

SELF JOIN

区分这两个：

mysql> select A.name, B.name from fruits as A, fruits as B where A.id <> B.id;
+--------+--------+
| name   | name   |
+--------+--------+
| test   | apple  |
| peach  | apple  |
| cherry | apple  |
| banana | apple  |
| test   | banana |
| peach  | banana |
| cherry | banana |
| apple  | banana |
| test   | cherry |
| peach  | cherry |
| banana | cherry |
| apple  | cherry |
| test   | peach  |
| cherry | peach  |
| banana | peach  |
| apple  | peach  |
| peach  | test   |
| cherry | test   |
| banana | test   |
| apple  | test   |
+--------+--------+
20 rows in set (0.00 sec)

mysql> select A.name, B.name from fruits as A, fruits as B;
+--------+--------+
| name   | name   |
+--------+--------+
| test   | apple  |
| peach  | apple  |
| cherry | apple  |
| banana | apple  |
| apple  | apple  |
| test   | banana |
| peach  | banana |
| cherry | banana |
| banana | banana |
| apple  | banana |
| test   | cherry |
| peach  | cherry |
| cherry | cherry |
| banana | cherry |
| apple  | cherry |
| test   | peach  |
| peach  | peach  |
| cherry | peach  |
| banana | peach  |
| apple  | peach  |
| test   | test   |
| peach  | test   |
| cherry | test   |
| banana | test   |
| apple  | test   |
+--------+--------+
25 rows in set (0.00 sec)

连接操作中排除那些自身匹配的情况，确保只有不同 fruit 之间的匹配会被包含在结果中。

UNION

UNION 运算符用于组合两个或多个 SELECT 语句的结果集。

UNION 中的每个 SELECT 语句必须具有相同的列数
列还必须具有相似的数据类型
每个 SELECT 语句中的列也必须是相同的顺序

1
2
3

SELECT column_name(s) FROM table1
UNION
SELECT column_name(s) FROM table2;

UNION 会将结果都排在一起。

GROUP BY

GROUP BY 语句将具有相同值的行分组为汇总行，例如"查找每个地区的客户数量"。

GROUP BY 语句通常与聚合函数 (COUNT()、MAX(), MIN(), SUM(), AVG()) 按一列或多列对结果集进行分组。

语法：

SELECT column_name(s)
FROM table_name
WHERE condition
GROUP BY column_name(s)
ORDER BY column_name(s);

一眼看过去，不懂 GROUP BY 的作用，举例：

存在以下表：

+------+--------+
| id   | name   |
+------+--------+
|    1 | apple  |
|    2 | banana |
|    3 | cherry |
|    4 | peach  |
|    7 | test   |
|   99 | apple  |
+------+--------+

考虑以下输出：

mysql> select name from fruits group by name;
+--------+
| name   |
+--------+
| apple  |
| banana |
| cherry |
| peach  |
| test   |
+--------+

与：

mysql> select distinct name from fruits;
+--------+
| name   |
+--------+
| apple  |
| banana |
| cherry |
| peach  |
| test   |
+--------+

DISTINCT 输出与我们通过上面的 GROUP BY 查询得到的结果相同。

select name, count(*) from fruits group by name;

输出：

mysql> select name, count(*) from fruits group by name;
+--------+----------+
| name   | count(*) |
+--------+----------+
| apple  |        2 |
| banana |        1 |
| cherry |        1 |
| peach  |        1 |
| test   |        1 |
+--------+----------+

HAVING

HVAING 与聚合函数一起使用，因为 WHERE 不能与聚合函数一起使用。

语法：

SELECT column_name(s)
FROM table_name
WHERE condition
GROUP BY column_name(s)
HAVING condition
ORDER BY column_name(s);

查询数量在两个以上的 fruit:

mysql> select count(id), name from fruits group by name  having count(id) > 1;
+-----------+-------+
| count(id) | name  |
+-----------+-------+
|         2 | apple |
+-----------+-------+

必须使用 GROUP BY，因为 name 属于非聚合列

EXISTS

EXISTS 运算符用于测试子查询中是否存在任何记录。

如果子查询返回一条或多条记录，EXISTS 运算符返回 TRUE。

语法：

SELECT column_name(s)
FROM table_name
WHERE EXISTS
(SELECT column_name FROM table_name WHERE condition);

INSERT INTO SELECT

INSERT INTO SELECT 语句从一个表中复制数据并将其插入到另一个表中。

INSERT INTO SELECT 语句要求源表和目标表中的数据类型匹配。

目标表中的现有记录不受影响。

语法：

将一个表的所有列复制到另一个表：

1
2
3

INSERT INTO table2
SELECT * FROM table1
WHERE condition;

仅将一个表中的一些列复制到另一个表中：

INSERT INTO table2 (column1, column2, column3, ...)
SELECT column1, column2, column3, ...
FROM table1
WHERE condition;

CASE

CASE 语句遍历条件并在满足第一个条件时返回一个值（如 if-then-else 语句）。因此，一旦条件为真，它将停止读取并返回结果。如果没有条件为真，则返回 ELSE 子句中的值。

如果没有 ELSE 部分且没有条件为真，则返回 NULL。

语法：

CASE
    WHEN condition1 THEN result1
    WHEN condition2 THEN result2
    WHEN conditionN THEN resultN
    ELSE result
END;

TCP 握手与挥手

2024-04-03T00:00:00.000Z

介绍

在网络通信中，TCP（Transmission Control Protocol）是一种可靠的传输协议，而TCP三次握手是建立TCP连接时的重要过程之一。

概述

TCP 三次握手，包括三个步骤：

客户端发送SYN请求：客户端向服务器发送一个SYN（同步）标志的数据包，表明它想要建立连接。
服务器响应ACK和SYN：服务器接收到客户端的SYN请求后，向客户端发送一个ACK（确认）数据包，表示已收到客户端的请求，并发送自己的SYN标志，以示同意建立连接。
客户端发送ACK：客户端接收到服务器的ACK和SYN后，向服务器发送一个ACK确认数据包，表示已收到服务器的响应，连接建立完成。

代码示例与 tcpdump 分析

下面是一个 client 和 server 建立 TCP 连接的代码。我最开始是用 C 写的，但是后面发现 Python 写起来舒服多了。

这个 Server 会监听 localhost 的 8880 端口。
Server.py:

import socket


server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)


server_address = ('localhost', 8880)
print('Starting up on {} port {}'.format(*server_address))
server_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_FASTOPEN, 1)
server_socket.bind(server_address)

server_socket.listen(1)

while True:
    print('Waiting for a connection...')
    connection, client_address = server_socket.accept()
    try:
        print('Connection from', client_address)

        while True:
            try:
                data = connection.recv(1024)
                # TCP_QUICKACK
                # connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK, 1)
                print('Received:', data.decode())

                if not data:
                    print('No data received from', client_address)
                    break
            except ConnectionResetError:
                print('Connection is reset by the client')
                break
            except KeyboardInterrupt:
                print('KeyboardInterrupt')
                connection.close()
                exit(0)
    finally:
        connection.close()

这个 Client 会与 Server 建立连接并每隔 2s 发送当前时间给 Server 。
Client.py:

import socket
import time

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server_address = ('localhost', 8880)
print('Connecting to {} port {}'.format(*server_address))
client_socket.connect(server_address)

try:
    while True:
        message = 'Hello, server! Time is {}'.format(time.ctime())
        print('Sending:', message)
        # client_socket.sendall(message.encode())
        client_socket.sendto(message.encode(), server_address)
        time.sleep(2)

finally:
    print('Closing the connection')
    client_socket.close()

运行这两个代码，使用 tcpdump 来监听 8880 端口的 tcp 数据包：

三次握手：

$ tcpdump -i lo -n port 8880  --absolute-tcp-sequence-numbers

tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on lo, link-type EN10MB (Ethernet), snapshot length 262144 bytes
16:18:18.333865 IP 127.0.0.1.57830 > 127.0.0.1.8880: Flags [S], seq 1857514943, win 33280, options [mss 65495,sackOK,TS val 3851230309 ecr 0,nop,wscale 7], length 0
16:18:18.333874 IP 127.0.0.1.8880 > 127.0.0.1.57830: Flags [S.], seq 3256784619, ack 1857514944, win 33280, options [mss 65495,sackOK,TS val 3851230309 ecr 3851230309,nop,wscale 7], length 0
16:18:18.333880 IP 127.0.0.1.57830 > 127.0.0.1.8880: Flags [.], ack 3256784620, win 260, options [nop,nop,TS val 3851230309 ecr 3851230309], length 0

16:18:18.333910 IP 127.0.0.1.57830 > 127.0.0.1.8880: Flags [P.], seq 1857514944:1857514991, ack 3256784620, win 260, options [nop,nop,TS val 3851230309 ecr 3851230309], length 47
16:18:18.333912 IP 127.0.0.1.8880 > 127.0.0.1.57830: Flags [.], ack 1857514991, win 260, options [nop,nop,TS val 3851230309 ecr 3851230309], length 0

PS: tcpdump 的参数说明：
i lo: 监听 lo 网卡
n: 不解析 IP 地址
port 8880: 只监听 8880 端口的数据包
absolute-tcp-sequence-numbers: 显示绝对的 TCP 序列号，如果不加这个参数，tcpdump 会显示相对的序列号。

tcpdump 输出的 Flags 字段解释：

[.] - ACK (Acknowledgment)
[S] - SYN (Start Connection)
[P] - PSH (Push Data)
[F] - FIN (Finish Connection)
[R] - RST (Reset Connection)
[S.] - SYN-ACK (SynAcK Packet)

可以看到，Client 发送了一个 SYN 数据包，Server 回复了一个 SYN+ACK 数据包，Client 再回复一个 ACK 数据包，三次握手完成。

seq 和 ack 的作用是用来保证数据包的可靠传输。TCP 通过 seq 和 ack 来保证数据包的有序传输和可靠接收。

三次挥手与四次挥手：

三次挥手

1
2
3

16:21:10.284200 IP 127.0.0.1.57830 > 127.0.0.1.8880: Flags [F.], seq 1857515790, ack 3256784620, win 260, options [nop,nop,TS val 3851402259 ecr 3851400314], length 0
16:21:10.284297 IP 127.0.0.1.8880 > 127.0.0.1.57830: Flags [F.], seq 3256784620, ack 1857515791, win 260, options [nop,nop,TS val 3851402259 ecr 3851402259], length 0
16:21:10.284308 IP 127.0.0.1.57830 > 127.0.0.1.8880: Flags [.], ack 3256784621, win 260, options [nop,nop,TS val 3851402259 ecr 3851402259], length 0

三次挥手的过程只是将 FIN 与 ACK 数据包一同发送。

三次挥手是 Linux 默认开启 TCP 延迟确认机制，而 RFC795 中是四次挥手：https://www.rfc-editor.org/rfc/rfc793#section-3.5

关于 TCP 延迟确认机制，可以使用 TCP_QUICKACK 关闭：https://www.man7.org/linux/man-pages/man7/tcp.7.html, 关于这个参数，这个参数并不是 永久性的，设置或清除这个标志只会暂时地启用或禁用快速确认模式。随后的TCP协议操作会根据内部协议处理和延迟确认超时等因素再次进入或退出快速确认模式。因此，这个标志的状态在操作过程中可能会动态变化。可以看上面的 server.py 中的使用方法

RFC1122 中对 Delay ACK 的说明：

1
2
3

Delayed ACK's
Delay < 0.5 seconds
2nd full-sized segment ACK'd

四次挥手

Client 发送一个 FIN 数据包，表示不再发送数据了。进入 FIN_WAIT_1 状态。
Server 收到 FIN 数据包后，回复一个 ACK 数据包，表示收到了 Client 的 FIN 数据包。进入 CLOSED_WAIT 状态。
Client 收到 ACK 数据包，进入 FIN_WAIT_2 状态。
Server 发送一个 FIN 数据包，表示不再发送数据了。进入 LAST_ACK 状态。
Client 收到 FIN 数据包后，回复一个 ACK 数据包，表示收到了 Server 的 FIN 数据包。进入 TIME_WAIT 状态。
服务端收到了 ACK 应答报文后，就进入了 CLOSE 状态，至此服务端已经完成连接的关闭。

可以使用 SO_REUSEADDR 解决这个问题。https://stackoverflow.com/questions/14388706/how-do-so-reuseaddr-and-so-reuseport-differ
还有一种方式是设置 SO_LINGER 选项的超时时长参数为 0 。这是不推荐使用的方法：https://stackoverflow.com/questions/3757289/when-is-tcp-option-so-linger-0-required

TIEM_WAIT 的意义

这个状态是避免延时的包的到达与随后的新连接相混淆和保证「被动关闭连接」的一方，能被正确的关闭。

保证「被动关闭连接」的一方可以被正确关闭：

如果客户端（主动关闭方）最后一次 ACK 报文（第四次挥手）在网络中丢失了，那么按照 TCP 可靠性原则，服务端（被动关闭方）会重发 FIN 报文。

阅读流程分享

2024-04-02T00:00:00.000Z

最近入了一个墨水屏设备用来看和写，用以改善我的阅读流程（只是自己想要一个墨水屏设备罢了）。这里分享一下我的阅读流程。

PS: 墨水屏设备是「汉王 n10」

为什么需要改善？

我最初的阅读流程非常松散，没有一个明确的流程，以前阅读博客文章只在手机上手动管理 RSS 订阅，但是电脑上却没有 RSS 订阅，这就导致了在不同端上阅读的不一致。
虽然有尝试过使用 FreshRSS 来管理订阅，但是中途服务器过期了就再也没有折腾过了。
除此之外，我自己也想尝试养成阅读书籍的习惯，但是一直没有找到一个好的方法来管理自己的书籍，经常在电脑上看着看着就不知道丢哪了。
而且我更想的是在睡前或者闲暇时间看书，这就排除了电脑这个设备。手机显然不是一个合适的选择，于是在去年就想入手一个墨水屏设备，只是最近才下手买入。

如何改善？

下图是我改善后的阅读流程图：

使用的工具：

Miniflux: 一个 feed reader，但是不一定要在网页上阅读。这个工具提供了许多集成功能，我是通过开启 Fever API 在我的墨水屏设备上使用 FeedMe 进行阅读。其实网页端也非常好了，我也可以不用 FeedMe 进行阅读而是直接在网页上进行。
slash: 这个是一个链接缩短和共享平台，可以通过添加 url 和 name 快速访问网站。
einkbro: 一个基于 Android WebView 的小型、快速的 Web 浏览器。它专为电子墨水设备量身定制，但也适用于普通 Android 设备。
dufs: 一个支持静态服务、上传、搜索、访问控制、webdav…的文件服务器。
Round-Sync: 我用来与我的 webdav 服务器同步摘抄和笔记。
FeedMe: 这个阅读软件没有公布源码。其实只在网页上阅读已经完全够了。这个软件可有可无。
memos: 一个开源、轻量级笔记服务。我用来记录自己的一些碎碎念。
plain-app: 是一个开源应用程序，允许通过网络浏览器管理您的手机。使用安全、易于使用的 Web 界面从桌面访问文件、视频、音乐、联系人、短信、通话等，我用来传输文件。
legado: 阅读 3.0, 阅读是一款可以自定义来源阅读网络内容的工具，为广大网络文学爱好者提供一种方便、快捷舒适的试读体验。

解决我在阅读时候的“痛点”，需要在以下方面改善：

稳定的阅读来源
多端同步阅读
方便添加阅读源（对于博客/公众号等一些网页链接）
摘抄/笔记同步

关于阅读来源：

RSS, 可以使用 wewe-rss 订阅公众号
网页文章
电子书

通过向 Miniflux 添加想要订阅的博客或者公众号来获取文章。除此之外，在我的墨水屏设备会有一些电子书。

多端同步阅读：

slash 用来同步网页链接文章
- 使用 slash 进行文章链接的同步，可以通过 slash 的前端页面进行查看。可以通过 Telegram Bot 添加文章内容。
- 在墨水屏设备上将 slash 设置为 einkbro 浏览器的主页，方便点击文章链接进行阅读。
  关于 einkbro 我准备自己改一下它的功能，因为它目前只支持将文章链接添加到 pocket，没有 slash，这就导致我如果看到我订阅的 RSS 中的有趣的文章想分享还需要转到 slash 页面去添加
Miniflux 用来同步 RSS 文章
- 使用 Miniflux 进行 RSS Feeds 的聚合，定时刷新订阅的 RSS 链接。
- 使用 FeedMe 查看 Miniflux 的内容，或在 einkbro 中查看所需文章，实现对 RSS Feeds 的管理和阅读。

添加阅读源/稍后阅读：

类似于 pocket 的需求，也就是 read it later。将想要稍后阅读的文章链接存放起来稍后阅读。

Telegram Bot 添加
- 可以通过 Telegram Bot (tgbot) 将想要阅读的文章链接添加到服务器。
网页添加
- 也可以在网页中添加文章链接。不过就是需要打开浏览器输入网址（麻烦）。

关于电子书方面暂时没有什么大的需求，就算有也可以通过汉王的服务或者 plain-app 进行传输，主要还是各种文章。

阅读摘抄和笔记同步：

通过 WebDav 将书籍摘抄和笔记同步到服务器中。
- 服务器部署了 dufs 这样一个 webdav 服务器，我还可以利用它同步我的网文阅读进度。我用 legado 看网文。
对摘抄内容进行处理后发送到自己的 memos 网站，完善书籍阅读后的操作流程。
- memos 部署的 memos。向这里倒一些垃圾是很必要的。

实现细节

其实需要我折腾写些代码的地方只是如何方便地添加阅读源/稍后阅读和同步摘抄笔记到 memos。
添加阅读源/稍后阅读我特意写了一个 Telegram Bot 来完成这件事情。

Telegram Bot: https://github.com/Xunop/save-link

目前只实现了向 Miniflux 添加 RSS 订阅源和向 slash 添加分享链接：

/start - Start the bot
/help - Get help
[website] [name] #tags - Save a link with a name
[rss feed] [category] - Save an rss feed

同步摘抄笔记到 memos 则是写了一个脚本：https://github.com/Xunop/notes2memos

那阅读设备呢？ ~~购买墨水屏设备~~

最后

我只希望我的墨水屏设备不会吃灰，然后自己养成看书的习惯。

TCP Fast Open

2024-03-18T00:00:00.000Z

折腾 TCP 的同时看到了 TCP Fast Open 这个有趣的参数，它是对 TCP 的优化，无需等待 3 次握手，应用程序就可以通过 TCP 发送数据。

正常 TCP 建立连接过程：

    Client                                               Server

1.  CLOSED                                               LISTEN

2.  SYN-SENT    -->           SYN M                  --> SYN-RECEIVED

3.  ESTABLISHED <--        SYN N,ACK M+1             <-- SYN-RECEIVED

4.  ESTABLISHED -->          ACK N+1                 --> ESTABLISHED

当前 TCP 实现的问题是，只有在连接发起方收到来自对等 TCP 的 ACK（确认）段后，才能在连接上交换数据。也就是说，只有在三次握手的第三步（发起方发送的ACK报文段）中，数据才能从客户端发送到服务器。因此，在对等点之间交换数据之前，就会损失一个完整的往返时间 (round trip time) 。这种丢失的 RTT 是短网络对话延迟的重要组成部分。TCP Fast Open 就是为了解决这个问题。

消除 RTT

    Client                                               Server

1.  CLOSED                                               LISTEN

2.  SYN-SENT    --> SYN, with cookie + data          --> SYN-RECEIVED---
                                                                       | Server TCP validates cookie, passes data to application
3.  Client      <--        SYN-ACK                   <-- SYN-RECEIVED---

4.  Client      <--        responses                 <-- Server          Server can send responses before receiving client ACK

4.  ESTABLISHED -->          ACK                     --> ESTABLISHED

上图所示步骤如下：

客户端 TCP 发送 SYN，其中包含 TFO cookie（指定为 TCP 选项）和来自客户端应用程序的数据。
服务器 TCP 通过基于新 SYN 的源 IP 地址重复加密过程来验证 TFO cookie。如果 cookie 被证明是有效的，那么服务器 TCP 就可以确信这个 SYN 来自它声称来自的地址。这意味着服务器TCP可以立即将应用程序数据传递给服务器应用程序。
从这里开始，TCP 会话正常进行：服务器 TCP 向客户端发送 SYN-ACK 段，然后客户端 TCP 进行确认，从而完成三向握手。服务器TCP还可以在收到客户端的 ACK 之前向客户端 TCP 发送响应数据段。

这是一个使用 tcpdump 查看使用了 TCP_FAST_OPEN 选项的抓包记录：

1. IP 127.0.0.1.51902 > 127.0.0.1.8000: Flags [S], seq 3550480872:3550480878, win 33280, options [mss 65495,sackOK,TS val 1437621030 ecr 0,nop,wscale 7,tfo  cookie ce80700cf8e6113c,nop,nop], length 6
2. IP 127.0.0.1.8000 > 127.0.0.1.51902: Flags [S.], seq 2245778431, ack 3550480873, win 33280, options [mss 65495,sackOK,TS val 1437621030 ecr 1437621030,nop,wscale 7], length 0
3. IP 127.0.0.1.51902 > 127.0.0.1.8000: Flags [P.], seq 3550480873:3550480879, ack 2245778432, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 6
4. IP 127.0.0.1.8000 > 127.0.0.1.51902: Flags [.], ack 3550480879, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 0
5. IP 127.0.0.1.8000 > 127.0.0.1.51902: Flags [P.], seq 2245778432:2245778438, ack 3550480879, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 6
6. IP 127.0.0.1.51902 > 127.0.0.1.8000: Flags [.], ack 2245778438, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 0
7. IP 127.0.0.1.8000 > 127.0.0.1.51902: Flags [F.], seq 2245778438, ack 3550480879, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 0
8. IP 127.0.0.1.51902 > 127.0.0.1.8000: Flags [F.], seq 3550480879, ack 2245778439, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 0
9. IP 127.0.0.1.8000 > 127.0.0.1.51902: Flags [.], ack 3550480880, win 260, options [nop,nop,TS val 1437621030 ecr 1437621030], length 0

可以看到 3 这个数据段在 4 这个 ACK 数据包之前。并且 options 中有一个 cookie 字段。

Server.py:

import socket


server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)


server_address = ('localhost', 8880)
print('Starting up on {} port {}'.format(*server_address))
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_FASTOPEN, 1)
server_socket.bind(server_address)

server_socket.listen(1)

while True:
    print('Waiting for a connection...')
    connection, client_address = server_socket.accept()
    try:
        print('Connection from', client_address)

        while True:
            data = connection.recv(1024)
            # TCP_QUICKACK
            connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK, 1)
            print('Received:', data.decode())

            if not data:
                print('No data received from', client_address)
                break

    finally:
        connection.close()

Client.py:

import socket

addr = ("localhost", 8880)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.sendto("hello!".encode(), 536870912, addr)

print(s.recv(1000))

sendto 需要提供 ip, 因为是 connectionless.

具体参考：

[1] https://lwn.net/Articles/508865/

23 年写的一些小脚本合集

2024-02-29T00:00:00.000Z

在这里稍微记录一下 23 年自己写的我觉得有意思的脚本。

生成博客文章

Links: https://github.com/Xunop/hexo-format

我以前写博客的方式是直接更改博客的源码，在 hexo 中的 _post 文件夹中写博客，感觉这个工作流很麻烦，于是就写了一个小脚本来完成将笔记转成博客文章这件事。
目前我的博客仓库里面有两个 git submodule , 分别是脚本和笔记，在我的笔记仓库提交 commit 之后，github action 会触发博客仓库的 github action 将我的笔记同步进博客的源码里面。

不过这个脚本写的非常乱，我现在看起来非常头痛 >_<。还有一些莫名其妙的功能，比如可以往 .fignore 文件中添加不想转为博客文章的文件。

清除没有礼貌的人

Links: https://github.com/Xunop/njupt-netlogout

我校的校园网需要登录账号才能上网，我的账号比较特殊，可以不断网，所以会有同学借我的账号来用，但是借的人多了达到了设备限制，使用者发现自己登不上就会去账号后台将其他人注销掉从而挤出一个名额给自己使用 :( 。
因为经常被他们挤下去，我也很烦，所以我扒了一下账号后台注销登录的接口，写成了一个脚本放在路由器上，将不在白名单内的用户都注销掉。

实施这个方案后确实没人跟我抢了，但是我想让一些人使用我的账号时需要我上路由器更新白名单就很麻烦，于是我在 dev-scheduling 分支中加了调度的功能。

如果登录的人数小于四个并且其中有一个我的设备，那么不需要注销用户。
后台会统计用户登录的时长跟被注销次数，由此公式：登录时长 / 被注销次数 维护一个队列，每次注销将注销队列头的设备。随着用户的登录时长越长，他被注销的概率就越大，但是被注销次数多了他的被注销概率也会变小。这个脚勉强可以用吧，反正我的设备都在白名单里面，不参与到队列计算中。

自动查询成绩

Links: https://github.com/Xunop/death-knell

在考完试之后不想每次都自己去查成绩（主要是不想过那种提心吊胆的生活），于是扒了一下接口写了一个小脚本来查询成绩，将查询结果用 webhook 发送到飞书的 bot 中。

LeetCode 推送

Links:

fork 别人写的 LeetCode 国际版的接口仓库，将里面的内容修改了一下（基本上没有一个接口是复用的，参数完全不同），部署到 vercel 上，可以获取一些 LeetCode CN 的信息。这是第一步。

拿到信息之后需要对信息进行处理，用云函数来处理信息，并且发送到飞书。是的，可以用这个来打卡。

还有一个放不出来，用飞书的机器人助手写了一堆应用流程来方便 bot 进行推送和交互。

目前实现的一些功能：

- 绑定 leetcode 用户名与飞书用户： @bot add username
- 解除绑定：@bot delete
绑定之后 bot 将会每天私信发送每日一题，在群组中也会发送。
- 查看每日一题：@bot daily
需要绑定才能使用的功能：
- 查看刷题记录：@bot solved
- 查看刷题使用的编程语言：@bot langs
- Bot 会在晚上 11:30 采集数据，在 11:40 发送今天提交的 ranking

我觉得还 … 挺有意思的。

批量下载音乐

Links: https://github.com/Xunop/dwn-songs

我第一次用到我平常学的东西帮到我身边很少接触计算机的人。

过年回家的时候，家里的发小给了我一个 u 盘，跟我说这个 u 盘他平时用来插到汽车上当车载音乐的，但是这里面的有些歌有问题无法正常播放，想让我帮他把里面的歌重新下一遍。

我当时以为里面没多少歌的，然后后面一直鸽他，直到他假期快结束的时候我才去看这里面的东西。看到 300 条我是彻底放弃自己手动帮他下歌了，后来花了十几分钟写了一个小小的脚本完成了这个工作，插到我发小车上播放时他非常满意。

这段代码很简单，就是发送几个请求，但是能用到自己学到的东西帮到身边的人还挺有意思的。

平时写的脚本还挺多的，大部分都是配合自己的电脑使用（因为用的是 Hyprland，欢迎尝试），脚本应该都是在我的 dotfile 里面。

gdb 常用操作记录

2023-10-02T00:00:00.000Z

因为写了一段时间内核中的 objtool，出现一些问题时需要使用 gdb 进行调试。这里记录一下自己的常用操作。学习建议还是看 gdb manual，这是一点点笔记，gdb 的使用那可真是太多了。

gdb 配置

gdb 有一个配置文件 .gdbinit ，可以在里面修改 gdb 配置。我的配置：

1
2
3

set pagination off
set history save on
set history expansion on

禁止分页
开启历史记录
可以使用 ! 执行上一条命令

常用操作

我调试的东西需要传递参数给它：

1	gdb --args ./tools/objtool/objtool -o arch/arm64/kernel/debug-monitors.o

start, next info print 一些就不记录在这了。

断点

打断点：

1	b check.c:1111

针对某个函数：

b func

栈帧

查看栈帧（backtrace/bt）：

bt num

0 表示当前正在执行的函数。
num 为查看栈帧的数量，不加 num 则显示全部。
如果 num 是正数，则栈帧从 0 开始计数，如果是负数，则从最大的栈帧编号开始计数。一个是正向，一个是反向。

(gdb) bt
    insn@entry=0x555555e73f60, state=...) at check.c:3739
    at check.c:4281
    at builtin-check.c:225

1	(gdb) bt -1

查看帧信息：

1	info frame num

num 为栈帧编号。
简写 i f num

查看当前帧的所有局部变量和函数参数：

1	info locals

info args

切换帧：

frame num

num 是栈帧编号。简写 f num

结构体

查看结构体中的字段及类型：

1	ptype struct

(gdb) ptype cfi
type = struct cfi_state {
    struct hlist_node hash;
    struct cfi_reg regs[32];
    struct cfi_reg vals[32];
    struct cfi_reg cfa;
    int stack_size;
    int drap_reg;
    int drap_offset;
    unsigned char type;
    _Bool bp_scratch;
    _Bool drap;
    _Bool signal;
    _Bool end;
} *

查看结构体中的所有字段的值：

(gdb) p cfi
$9 = (struct cfi_state *) 0x7fffffffd9b0

(gdb) p *((struct cfi_state *) cfi)
$10 = {hash = {next = 0x0, pprev = 0x0}, regs = {{base = -1, offset = 0} }, vals = {{base = -1,
      offset = 0} }, cfa = {base = 31, offset = 0}, stack_size = 0, drap_reg = -1, drap_offset = -1,
  type = 2 '\002', bp_scratch = false, drap = false, signal = false, end = false}

强转一下。

调用函数

p func

1 2	(gdb) p offstr(insn->sec, insn->offset) $13 = 0x555555ea0330 "mdscr_write+0x0"

多线程

info inferiors 查看进程列表
attach pid绑定进程 id
inferior num 切换到指定进程上进行调试
print $_exitcode 显示进程退出时的返回值
set follow-fork-mode child 追踪子进程
set follow-fork-mode parent 追踪父进程
set detach-on-fork on fork 调用时只追踪其中一个进程
set detach-on-fork off fork 调用时会同时追踪父子进程
set schedule-multiple on 调试某进程时，其他进程正常执行

Keep It Simple & Stupid

TypeScript 函数定义

基础函数和常量

给四种函数加上泛型

Samsung S24 和 Samsung Watch 5 国行刷外版系统（可能通用）

Samsung S24

Samsung Watch 5

参考

使用 Pandoc 把 Markdown 转为 PDF 文件

必要的软件和字体

转换 Markdown 为 PDF

参考资料

MSS、MTU 和 TCP 拥塞堵塞

MTU

MSS

TCP 拥塞堵塞

TSO(tcp-segmentation-offload)

测试环境构建

网络分层模型

OSI 模型

TCP/IP 模型

分层的意义

Linux Network sysctl parameters

In Process（接收数据包）

Out Process（发送数据包）

环形缓冲区 (Ring Buffer - tx,rx)

中断合并 (Interrupt Coalescence, IC)

软中断合并 (Interrupt Coalescing, soft IRQ) 和入站队列 (ingress qdisc)

NAPI 轮询预算 (netdev_budget):

网络接口权重 (dev_weight):

入站队列最大长度 (netdev_max_backlog):

softnet_stat

出站队列长度 (txqueuelen) 和 默认队列调度器 (default_qdisc)

出站队列长度 (txqueuelen):

默认队列调度器 (default_qdisc):

TCP Read and Write Buffers/Queues

接收缓冲区 (tcp_rmem)

发送缓冲区 (tcp_wmem)

接收缓冲区自动调整 (tcp_moderate_rcvbuf)

参考

EPUB 格式规范

META-INF

Container – META-INF/container.xml

Encryption – META-INF/encryption.xml

Manifest – META-INF/manifest.xml

Metadata – META-INF/metadata.xml

Rights Management – META-INF/rights.xml

Digital Signatures – META-INF/signatures.xml

OEBPS

OPF

Metadata

Manifest

Spine

Guide

NCX file

NCX vs OPF spine

TCP 握手与挥手

介绍

概述

代码示例与 tcpdump 分析

三次握手：

三次挥手与四次挥手：

三次挥手

四次挥手

TIEM_WAIT 的意义

TCP Fast Open

消除 RTT

Ansible

Playbook

Playbook

Play

Task

Module

自定义 Module

示例

kubespray

minikube 设置代理

Linux 设置默认麦克风以及音频输出

Vhost-user Protocol

SAR 命令输出解释

出站队列长度 (txqueuelen) 和默认队列调度器 (default_qdisc)

接收缓冲区 (`tcp_rmem`)

发送缓冲区 (`tcp_wmem`)

接收缓冲区自动调整 (`tcp_moderate_rcvbuf`)