适用于希望为 FreeBSD 开发软件的人（而不仅仅是开发 FreeBSD 本身的人）

翻译项目一览表

版权 © 1995-2023 FreeBSD 文档计划

1.1. 在 FreeBSD 上开发

所以在这里。系统已安装完成，您准备开始编程了。但从哪开始呢？FreeBSD 提供了什么？作为一名程序员，它能为我做些什么？

这些是本章试图回答的一些问题。当然，编程像其他行业一样有不同水平的熟练程度。对于有些人来说，这是一种爱好，对于其他人来说，这是他们的职业。本章的信息可能针对初学者程序员；确实，对于不熟悉 FreeBSD 平台的程序员也会有用。

1.2. BSD 远景

为了尽可能生产最好的类 UNIX®操作系统软件包，同时尊重原始软件工具思想，以及可用性，性能和稳定性。

1.3. 架构指南

我们的意识形态可以通过以下准则来描述

• 不要添加新功能，除非实施者无法在没有它的情况下完成真正的应用程序。

• 决定系统是什么和决定系统不是什么一样重要。不要满足世界上所有的需求；相反，使系统具有可扩展性，以便可以以向上兼容的方式满足额外的需求。

• 从一个例子泛化的唯一更糟糕的事情是从没有例子泛化。

• 如果问题没有完全被理解，最好根本不提供解决方案。

• 如果您可以用 10％的工作获得所需效果的 90％，请使用更简单的解决方案。

• 尽量将复杂性隔离。

• 提供机制，而不是策略。特别是，将用户界面策略交由客户端处理。

来自 Scheifler & Gettys：“X Window System”

1.4. /usr/src 的布局

FreeBSD 的完整源代码可从我们的公共 Git 存储库获取。源代码通常安装在 /usr/src 中。源树的布局由顶层的 README.md 文件描述。

欢迎来到开发者手册。本手册还在不断完善中，是许多人共同努力的成果。许多部分尚不存在，一些已存在的部分也需要更新。如果您有兴趣参与这个项目，请发送电子邮件至 FreeBSD 文档项目邮件列表。

本文档的最新版本始终可从 FreeBSD 全球网络服务器获取。也可以从 FreeBSD 下载服务器或众多镜像站点之一以各种格式和压缩选项下载。

本章记录了适用于 FreeBSD 源代码树的各种准则和政策。

5.1. 风格指南

一致的编码风格非常重要，特别是对于像 FreeBSD 这样的大型项目。代码应该遵循在 style(9)和 style.Makefile(5)中描述的 FreeBSD 编码风格。

5.2. MAINTAINER 关于 Makefiles

如果 FreeBSD src/发行版的特定部分由一个或一组人维护，通过在 src/MAINTAINERS 中的条目进行通信传达。在Ports集合中维护者通过向有问题的port的 Makefile 添加 MAINTAINER 行向世界表达他们的维护权：

MAINTAINER= email-addresses

维护者的作用如下：

• 维护者拥有并负责该代码。这意味着他或她负责修复有关该代码部分的错误并回答问题报告，在涉及贡献的软件的情况下，需适时追踪新版本。

• 应该在提交变更到已定义维护者的目录之前将其发送给维护者进行审核。只有在维护者在不可接受的时间内未做出回应，即多封电子邮件后才允许在没有经过维护者审查的情况下提交更改。然而，建议尽可能让其他人审查这些更改。

• 当然，未经同意不可将个人或组添加为维护者来承担这一责任。另一方面，它不必是一个提交者，可以很容易地是一组人。

5.3. 贡献软件

FreeBSD 发行版的某些部分由 FreeBSD 项目之外积极维护的软件组成。出于历史原因，我们称之为贡献软件。一些例子包括 LLVM、zlib(3)和 awk(1)。

管理贡献软件的接受流程涉及创建供应商分支，可以在其中干净地导入软件（无需修改），并可以以版本化的方式跟踪更新。然后，将供应商分支的内容应用于源代码树，可能会进行本地修改。FreeBSD 特定的构建粘合剂在源代码树中维护，而不是在供应商分支中。

根据其需求和复杂性，个别软件项目可能会根据维护者的判断偏离此过程。更新特定贡献软件的确切步骤应记录在一个名为 FREEBSD-upgrade 的文件中；例如，libarchive 的 FREEBSD-upgrade 文件。

贡献的软件通常放置在源代码树的 contrib/子目录中，但也有一些例外情况。仅由内核使用的贡献软件位于 sys/contrib/下。

5.3.1. 供应商导入

管理贡献软件和供应商分支的标准流程在 Committer's Guide 中有详细描述。

5.4. 受限文件

偶尔可能需要在 FreeBSD 源代码树中包含一个受限制的文件。例如，如果设备在操作之前需要加载一小段二进制代码，并且我们没有该代码的源代码，那么该二进制文件就被称为受限制的。以下政策适用于在 FreeBSD 源代码树中包含受限制文件。

1. 任何由系统 CPU 解释或执行且不以源代码格式存在的文件都是受限制的。

2. 任何许可证比 BSD 或 GNU 更具限制性的文件都是受限制的。

3. 一个包含可下载二进制数据供硬件使用的文件不受限制，除非（1）或（2）适用于它。

4. 任何受限制的文件在添加到存储库之前都需要核心团队的特定批准。

5. 受限的文件放在 src/contrib 或 src/sys/contrib 中。

6. 整个模块应该保持在一起。除非存在与非受限制代码的代码共享，否则没有拆分的必要。

7. 在过去，二进制文件通常会被 uuencode，然后命名为 arch/filename.o.uu。这已不再必要，二进制文件可以无修改地添加到代码库中。

8. 内核文件：

   1. 在构建简易性时，应始终引用 conf/files.*中的内容。

   2. 应始终包含在 LINT 中，但核心团队根据情况决定是否应将其注释掉。核心团队当然可以随后改变他们的想法。

   3. 发布工程师决定是否将其包含在发布中。

9. 用户空间文件：

   1. 核心团队决定代码是否应该成为 make world 的一部分。

   2. 发行工程团队决定是否将其纳入发布版。

5.5. 共享库

如果您正在为port或其他没有共享库支持的软件添加支持，则版本号应遵循以下规则。通常，生成的版本号与软件的发布版本无关。

对于ports:

• 优先使用上游已选择的数字

• 如果上游提供符号版本控制，请确保我们使用他们的脚本

对于基本系统：

• 从 1 开始启动库版本

• 强烈建议为新库添加符号版本

• 如果有不兼容的更改，请使用符号版本处理，保持向后 ABI 兼容

• 如果这是不可能的，或者库不使用符号版本控制，请提升库版本

• 即使考虑为符号版本化库提升库版本之前，请与发布工程团队协商，提供改变如此重要以至于应该允许破坏 ABI 的原因

例如，添加函数和修复不改变接口是可以的，而删除函数，更改函数调用语法等应提供向后兼容符号，否则将强制更改主版本号。

进行更改的提交者有责任处理库版本控制。

ELF 动态链接器会严格匹配库名称。一个流行的约定是将库版本写成 libexample.so.x.y 的形式，其中 x 是主版本，y 是次版本。常见的做法是将库的 soname ( DT_SONAME ELF 标签) 设置为 libexample.so.x ，并在安装库时设置 libexample.so.x→libexample.so.x.y 和 libexample.so→libexample.so.x 的符号链接以对应最新的次版本 y。因为静态链接器在指定 -lexample 命令行选项时会搜索 libexample.so ，所以与 libexample 链接的对象会依赖于正确的库。几乎所有流行的构建系统都会自动使用这个方案。

2.1. 简介

本章是介绍如何使用 FreeBSD 提供的一些编程工具的简介，尽管其中的大部分内容也适用于许多其他版本的 UNIX®。它并不试图详细描述编码。本章的大部分内容假定读者几乎没有编程知识，尽管希望大多数程序员会在其中找到一些有价值的东西。

2.2. 引言

FreeBSD 提供了一个出色的开发环境。C 和 C++的编译器以及汇编器与基本系统一起提供，更不用说经典的 UNIX 工具如 sed 和 awk 了。如果这还不够，还有许多编译器和解释器在Ports集合中。下面的部分，编程入门，列出了一些可用的选项。FreeBSD 与 POSIX 和 ANSI C 等标准非常兼容，同时也与其自己的 BSD 传统兼容，因此可以编写在各种平台上几乎不经过或经过很少修改就能编译和运行的应用程序。

但是，如果您以前从未在 UNIX 平台上编写程序，所有这些功能可能会让人感到非常不知所措。本文档旨在帮助您快速上手，而不深入探讨更高级的主题。本文档的目的是给您提供足够的基础知识，以便能够理解文档的内容。

大多数文档无需或几乎无需编程知识，尽管它确实假定您具备使用 UNIX 和学习的基本能力！

2.3. 编程入门

程序是一组指令，告诉计算机做各种事情；有时候，它必须执行的指令取决于它执行前一个指令时发生了什么。本节概述了您可以给出这些指令的两种主要方式，通常称为“命令”。一种方式使用解释器，另一种方式使用编译器。由于人类语言对计算机来说太难以以一种明确的方式理解，因此通常会用专门设计用于此目的的语言编写命令。

2.3.1. 解释器

有了解释器，语言就成为了一个环境，在这里你在提示符下键入命令，环境会为你执行这些命令。对于更复杂的程序，你可以把命令键入文件，并让解释器加载该文件并执行其中的命令。如果出了问题，许多解释器会将你转到调试器以帮助你跟踪问题。

其优点在于你可以立即看到命令的结果，错误可以很容易地纠正。最大的缺点是当你想与他人共享你的程序时。他们必须有相同的解释器，或者你必须有某种方法将其提供给他们，并且他们需要理解如何使用它。此外，用户可能不喜欢如果他们按错键就被送入调试器！从性能角度来看，解释器可能会使用大量内存，并且通常不像编译器那样高效地生成代码。

在我看来，如果你以前没有进行过任何编程，解释性语言是开始的最佳方式。这种环境通常在诸如 Lisp、Smalltalk、Perl 和 Basic 等语言中找到。也可以说 UNIX®shell ( sh , csh )本身就是一个解释器，并且事实上许多人确实编写shell "脚本"来帮助执行各种在他们的机器上的"家务"任务。事实上，UNIX®原始哲学的一部分是提供许多可以在shell脚本中链接在一起以执行有用任务的小型实用程序。

在 FreeBSD 中提供的解释器

这里是从 FreeBSD Ports Collection 可用的解释器列表，简要讨论了一些更受欢迎的解释型语言。

如何从手册的Ports部分找到并安装Ports Collection 中的应用程序的说明。

BASIC 是“初学者通用符号指令代码”的缩写。在上世纪 50 年代为大学生编程教学开发，80 年代随着每台值得尊敬的个人电脑提供，BASIC 是许多程序员的第一种编程语言。它也是 Visual Basic 的基础。

Bywater Basic 解释器可以在Ports集合中的 lang/bwbasic 找到，Phil Cockroft 的 Basic 解释器（前身为 Rabbit Basic）可在 lang/pbasic 中找到。

Lisp 是一种在上世纪 50 年代开发的语言，作为当时流行的“数值计算”语言的替代方案。与基于数字不同，Lisp 是基于列表的；事实上，名称是“List Processing”的缩写。在人工智能领域非常流行。

Lisp 是一种非常强大和复杂的语言，但可能相当庞大和笨重。

可在 FreeBSD 的Ports集合中找到可在 UNIX®系统上运行的各种 Lisp 实现。GNU Common Lisp 可以在 lang/gcl 中找到。由 Bruno Haible 和 Michael Stoll 开发的 CLISP 可作为 lang/clisp 使用。对于 CMUCL，其中还包括一个高度优化的编译器，或者像 SLisp 这样的简单的 Lisp 实现，它在几百行 C 代码中实现了大部分 Common Lisp 构造，分别可以在 lang/cmucl 和 lang/slisp 中找到。

Perl 非常受系统管理员欢迎，用于编写脚本；也经常用于编写 CGI 脚本的 World Wide Web 服务器。

Perl 在Ports集合中作为 lang/perl5.24 对所有 FreeBSD 版本可用。

Scheme 是 Lisp 的一个方言，比 Common Lisp 更紧凑、更干净。在大学中很受欢迎，因为它简单到可以教给本科生作为第一门语言，同时又具有足够高的抽象级别可用于研究工作。

Scheme 可从Ports集合中作为 lang/elk 获取 Elk Scheme 解释器。MIT Scheme 解释器可在 lang/mit-scheme 找到，SCM Scheme 解释器在 lang/scm 中。

IconIcon 是一种具有广泛处理字符串和结构的高级语言。FreeBSD 上的 Icon 版本可以在 Ports 集合中找到，位置为 lang/icon。

LuaLua 是一种轻量级的可嵌入脚本语言。它具有广泛的可移植性，相对简单。Lua 可以在 lang/lua 中的 Ports 集合中找到。它也作为 /usr/libexec/flua 包含在基本系统中，供基本系统组件使用。第三方软件不应依赖 flua。

PythonPython 是一种面向对象的解释性语言。其支持者认为它是开始编程的最佳语言之一，因为相对容易入门，但与其他用于开发大型复杂应用程序的流行解释性语言相比并不受限制（Perl 和 Tcl 是用于此类任务的另外两种流行语言）。

Python 的最新版本可从 lang/python 的Ports集合中获取。

RubyRuby 是一种解释型的、纯面向对象的编程语言。由于其易于理解的语法、编写代码时的灵活性以及轻松开发和维护大型复杂程序的能力，它已经变得非常流行。

Ruby 可从 lang/ruby32 的Ports集合中获取。

Tcl 和 TkTcl 是一种可嵌入的解释性语言，因其在许多平台上的可移植性而变得广泛使用并因此变得流行。它可用于快速编写小型原型应用程序，或者（与 Tk，一个 GUI 工具包相结合）用于编写功能丰富的完整程序。

FreeBSD 提供各种版本的 Tcl 作为 ports。最新版本 Tcl 8.7 可在 lang/tcl87 中找到。

2.3.3. 编译器

编译器有所不同。首先，您使用编辑器在文件（或文件）中编写代码。然后运行编译器，看看它是否接受您的程序。如果没有编译成功，请咬紧牙关，回到编辑器；如果编译成功并给您一个程序，您可以在shell命令提示符或调试器中运行它，以查看它是否正常工作。^[ 1]^

很明显，这并不像使用解释器那样直接。然而，它使您可以做很多解释器很难甚至不可能做到的事情，比如编写与操作系统密切交互的代码-甚至编写您自己的操作系统！如果您需要编写非常高效的代码，则编译器非常有用，因为编译器可以花费时间优化代码，而这在解释器中是不可接受的。此外，为编译器编写的程序通常比为解释器编写的程序更简单-您可以简单地给他们一个可执行文件副本，假设他们使用与您相同的操作系统。

由于在使用单独的程序时编辑-编译-运行-调试周期相当乏味，许多商业编译器制造商已经生产了集成开发环境（简称 IDE）。FreeBSD 在基本系统中不包括 IDE，但在Ports集合中提供了 devel/kdevelop，并且许多人使用 Emacs 以此为目的。有关将 Emacs 用作 IDE，请参阅《使用 Emacs 作为开发环境》。

2.4. 使用 cc 进行编译

本节介绍用于 C 和 C ++的 clang 编译器，因为它安装在 FreeBSD 基本系统中。 clang 安装为 cc ；GNU 编译器 gcc 可在Ports Collection 中获得。 使用解释器生成程序的细节在解释器的文档和在线帮助中通常有很好的介绍。

一旦您完成了您的杰作，下一步是将其转换为可以（希望！）在 FreeBSD 上运行的东西。 这通常涉及几个步骤，每个步骤由一个单独的程序完成。

1. 预处理您的源代码，删除注释并执行其他技巧，如在 C 中展开宏。

2. 检查代码的语法，看看您是否遵守了语言的规则。如果没有，它会抱怨！

3. 将源代码转换为汇编语言-这非常接近机器代码，但仍可被人类理解。据说。

4. 将汇编语言转换为机器码-是的，我们在谈论位和字节，这里是一和零。

5. 检查您是否以一致的方式使用了诸如函数和全局变量之类的东西。例如，如果您调用了一个不存在的函数，它会报错。

6. 如果您正在尝试从几个源代码文件生成可执行文件，请想办法将它们全部组合在一起。

7. 弄清楚如何生成系统运行时加载程序能够加载到内存并运行的内容。

8. 最后，在文件系统上编写可执行文件。

编译一词通常用于指代步骤 1 至 4，其他步骤则称为链接。有时步骤 1 被称为预处理，步骤 3 至 4 被称为汇编。

幸运的是，几乎所有这些细节对您而言都是隐藏的，因为 cc 是一个前端，它会为您调用所有这些程序并使用正确的参数；只需键入

% cc foobar.c

将导致 foobar.c 通过上述所有步骤进行编译。如果您有多个文件要编译，只需执行类似操作

% cc foo.c bar.c

请注意，语法检查只是检查语法而已。它不会检查您可能犯的任何逻辑错误，比如将程序放入无限循环中，或者在本应使用二进制排序时使用冒泡排序。^[ 2]^

有很多选项可供 cc 使用，所有这些选项都在手册页中。这里是一些最重要的选项，以及如何使用它们的示例。

-o filename 文件的输出名称。如果你不使用这个选项， cc 将生成一个名为 a.out 的可执行文件。

% cc foobar.c               executable is a.out
% cc -o foobar foobar.c     executable is foobar

-c 只编译文件，不链接它。这对于你只想检查语法的玩具程序，或者如果你在使用 Makefile 时非常有用。

% cc -c foobar.c

这将产生一个对象文件（而不是可执行文件）称为 foobar.o。这可以与其他对象文件链接在一起成为一个可执行文件。

-g 创建可执行文件的调试版本。这使编译器将关于哪个源文件的哪一行对应于哪个函数调用的信息放入可执行文件中。调试器可以使用这些信息在您逐步执行程序时显示源代码，这非常有用；缺点是所有这些额外信息使程序变得更大。通常，在开发程序时您使用 -g 进行编译，然后在满意程序正常工作时，不使用 -g 进行编译生成“发布版本”。

% cc -g foobar.c

这将产生程序的调试版本。 ^[4]^

-O 创建可执行文件的优化版本。编译器会尝试执行各种巧妙的技巧，以产生比正常情况下运行更快的可执行文件。您可以在 -O 后面添加一个数字来指定更高级别的优化，但这经常会暴露编译器优化器中的错误。

% cc -O -o foobar foobar.c

这将生成 foobar 的优化版本。

以下三个标志将强制 cc 检查您的代码是否符合相关的国际标准，通常称为 ANSI 标准，严格来说它是 ISO 标准。

-Wall 启用 cc 的作者认为值得的所有警告。尽管名称如此，它不会启用 cc 能够的所有警告。

-ansi 关闭 cc 提供的大多数非 ANSI C 特性。尽管名称如此，它并不能严格保证您的代码符合标准。

-pedantic 关闭所有 cc 的非 ANSI C 特性。

没有这些标志， cc 将允许您使用其标准之外的一些非标准扩展。其中一些非常有用，但无法与其他编译器一起使用 - 实际上，标准的主要目标之一是允许人们编写可以在任何系统上的任何编译器上运行的代码。这被称为可移植代码。

通常，您应该尽量使您的代码尽可能具有可移植性，否则您以后可能不得不完全重写程序才能使其在其他地方运行 - 谁知道您未来几年可能会使用什么？

% cc -Wall -ansi -pedantic -o foobar foobar.c

在检查 foobar.c 是否符合标准后，这将生成一个名为 foobar 的可执行文件。

-llibrary 指定在链接时要使用的函数库。

最常见的例子是编译使用 C 语言中的一些数学函数的程序。与大多数其他平台不同，这些函数在与标准 C 库不同的库中，您必须告诉编译器将其添加进去。

规则是，如果库被称为 libsomething.a，你给 cc 参数 -lsomething 。例如，数学库是 libm.a，所以你给 cc 参数 -lm 。数学库的一个常见问题是它必须是命令行中的最后一个库。

% cc -o foobar foobar.c -lm

这将链接数学库函数到 foobar 中。

如果您正在编译 C++ 代码，请使用 c++。在 FreeBSD 上也可以使用 clang++ 调用 c++。

% c++ -o foobar foobar.cc

这将从 C++ 源文件 foobar.cc 生成可执行文件 foobar。

2.4.1. 常见 cc 查询和问题

2.4.1.1. 我编译了一个名为 foobar.c 的文件，但我找不到一个名为 foobar 的可执行文件。它去哪了？

记住， cc 会调用名为 a.out 的可执行文件，除非你另行指定。使用 -o filename 选项：

% cc -o foobar foobar.c

2.4.1.2. 好的，我有一个名为 foobar 的可执行文件，在运行 ls 时可以看到它，但是当我在命令提示符中输入 foobar 时，它告诉我找不到这个文件。为什么找不到它呢？

与 MS-DOS®不同，UNIX®在尝试找出您要运行的可执行文件时不会查找当前目录，除非您告诉它。键入 ./foobar ，这意味着“运行当前目录中名为 foobar 的文件”。

2.4.2. 我将我的可执行文件命名为 test，但是当我运行它时什么都不会发生。出了什么问题？

大多数 UNIX®系统都有一个名为 test 的程序在/usr/bin 中，而shell会在检查当前目录之前先运行它。要么输入：

% ./test

要么为您的程序选择一个更好的名称！

2.4.2.1. 我编译了我的程序，起初似乎一切正常，然后出现了一个错误，说了一些关于核心转储的东西。那是什么意思？

核心转储的名称可以追溯到 UNIX® 的早期，当时机器使用核心存储数据。 基本上，如果程序在某些条件下失败，系统会将核心存储器的内容写入一个名为 core 的文件中，程序员随后可以查看该文件以找出问题所在。

2.4.2.2。令人着迷的东西，但我现在该怎么办？

使用调试器分析核心（请参阅调试）。

当我的程序转储核心时，它显示关于分段错误的信息。那是什么意思？

这基本上意味着您的程序尝试在内存上执行某种非法操作；UNIX®旨在保护操作系统和其他程序免受恶意程序的侵害。

这种情况的常见原因有：

• 尝试写入空指针，例如

  复制

  char *foo = NULL;
  strcpy(foo, "bang!");

• 使用未初始化的指针，例如

  复制

  char *foo;
  strcpy(foo, "bang!");

  指针将具有一些随机值，幸运的话，它将指向内存中不可用于您的程序的区域，内核将在您的程序造成任何损害之前终止您的程序。如果您不幸，它将指向您自己程序内的某个位置，并损坏您的数据结构之一，导致程序神秘地失败。

• 尝试访问数组末尾之后的内容，例如

  复制

  int bar[20];
  bar[27] = 6;

• 尝试将某物存储在只读内存中，例如

  复制

  char *foo = "My string";
  strcpy(foo, "bang!");

  UNIX® 编译器通常将类似 "My string" 的字符串文本放入只读内存区域。

• 与 malloc() 和 free() 一起做坏事，例如

  复制

  char bar[80];
  free(bar);

  要么

  复制

  char *foo = malloc(27);
  free(foo);
  free(foo);

做这些错误中的一个通常不会导致错误，但这总是一个不好的习惯。一些系统和编译器比其他系统更宽容，这就是为什么在一个系统上运行良好的程序在另一个系统上尝试时可能会崩溃。

2.4.2.4. 有时候当我收到核心转储时，它会显示总线错误。我的 UNIX®书上说这意味着硬件问题，但计算机似乎仍在正常运行。这是真的吗？

不，幸运的是不会（除非当然你真的遇到了硬件问题...）。这通常是另一种说法，即您以不应该的方式访问了内存。

2.4.2.5. 这个转储核心的过程听起来可能非常有用，如果我想要发生这种情况，我可以做到吗？还是我必须等到出现错误？

是的，只需转到另一个控制台或 xterm，执行

% ps

以查找您的程序的进程 ID，并执行

% kill -ABRT pid

其中 pid 是您查找的进程 ID。

如果您的程序陷入无限循环，这将非常有用。例如，如果您的程序恰好陷入 SIGABRT 陷阱，还有其他几个信号会产生类似的效果。

或者，您可以通过调用 abort() 函数从程序内部创建核心转储。查看 abort(3)的手册页以了解更多信息。

如果您想从程序外部创建核心转储，但又不希望进程终止，可以使用 gcore 程序。有关更多信息，请参阅 gcore(1)的手册页。

2.5. 制造

2.5.1. 什么是 make ?

当你在处理一个只有一个或两个源文件的简单程序时，键入

% cc file1.c file2.c

不是太糟糕，但当有多个文件时很快变得非常乏味，而且编译也可能需要一段时间。

一个解决方法是使用目标文件，只有在源代码发生更改时才重新编译源文件。所以我们可以有类似这样的东西：

% cc file1.o file2.o … file37.c …

如果我们已经更改了 file37.c，但没有更改其他任何文件，自上次编译以来。这可能会大大加快编译速度，但并不能解决输入问题。

或者我们可以编写一个shell脚本来解决输入问题，但这将需要重新编译所有内容，在大型项目上效率会很低。

如果我们有成百上千的源文件散落在周围会发生什么？如果我们和其他人合作，在使用其他源文件时他们忘记告诉我们已经更改了其中一个源文件，会怎样？

或许我们可以将两种解决方案结合起来，编写类似shell脚本的东西，其中包含一些神奇的规则，规定何时需要编译源文件。现在我们所需要的是一个能够理解这些规则的程序，因为这对shell来说有点太复杂了。

这个程序叫做 make 。它读取一个名为 makefile 的文件，该文件告诉它不同文件之间的依赖关系，并计算出哪些文件需要重新编译，哪些不需要。例如，一条规则可以说“如果 fromboz.o 比 fromboz.c 旧，这意味着有人修改了 fromboz.c，所以需要重新编译。” makefile 还包含告诉 make 如何重新编译源文件的规则，使其成为一个更强大的工具。

Makefile 通常与其所适用的源代码保存在同一个目录中，可以命名为 makefile、Makefile 或 MAKEFILE。大多数程序员使用名称 Makefile，因为这样可以将其放在目录列表的顶部，便于查看。^[ 5]^

2.5.2. 使用 make 的示例

这是一个非常简单的 make 文件：

foo: foo.c
	cc -o foo foo.c

它由两行组成，一个依赖行和一个创建行。

这里的依赖行由程序的名称（称为目标），后跟一个冒号，然后是空格，然后是源文件的名称组成。当 make 读取这行时，它会查看 foo 是否存在；如果存在，它会比较 foo 上次修改的时间和 foo.c 上次修改的时间。如果 foo 不存在，或者比 foo.c 旧，那么它会查看创建行以找出该执行什么操作。换句话说，这是确定何时需要重新编译 foo.c 的规则。

创建行以制表符开头（按制表符键），然后是您在命令提示符处创建 foo 时要键入的命令。如果 foo 已过时或不存在，则 make 会执行此命令以创建它。换句话说，这是告诉 make 如何重新编译 foo.c 的规则。

因此，当您键入 make 时，它将确保 foo 相对于您对 foo.c 的最新更改是最新的。这个原则可以扩展到具有数百个目标的 Makefile-事实上，在 FreeBSD 上，只需在适当的目录中键入 make world 就可以编译整个操作系统！

Makefile 的另一个有用属性是目标不必是程序。例如，我们可以有一个看起来像这样的 make 文件：

foo: foo.c
	cc -o foo foo.c

install:
	cp foo /home/me

我们可以通过输入来告诉 make 我们要制作哪个目标：

% make target

make 然后只会查看该目标，忽略其他任何目标。例如，如果我们在上述 makefile 中键入 make foo ，make 将忽略 install 目标。

如果我们只输入 make ，make 将始终查看第一个目标，然后停止而不查看其他任何目标。因此，如果我们在这里输入 make ，它将直接转到 foo 目标，如果需要的话重新编译 foo，然后停止而不继续到 install 目标。

注意， install 目标实际上并不依赖于任何东西！这意味着当我们尝试通过键入 make install 来生成该目标时，下一行上的命令总是被执行。在这种情况下，它将 foo 复制到用户的主目录中。这在应用程序的 makefile 中经常被使用，这样当应用程序被正确编译后，可以安装在正确的目录中。

这是一个稍微令人困惑的主题要去解释。如果你不太理解 make 的工作原理，最好的方法是编写一个简单的程序像“hello world”，以及一个像上面那样的 make 文件，并进行实验。然后逐渐使用多个源文件，或者将源文件包含一个头文件。 touch 在这里非常有用-它可以更改文件的日期而无需手动编辑。

2.5.3. Make 和 include 文件

C 代码通常以要包含的文件列表开头，例如 stdio.h。其中一些文件是系统包含文件，另一些来自您目前正在工作的项目：

#include <stdio.h>
#include "foo.h"

int main(....

为了确保在 foo.h 更改时重新编译此文件，您必须在 Makefile 中添加它：

foo: foo.c foo.h

当您的项目变得越来越庞大，您有越来越多自己维护的包含文件时，跟踪所有包含文件以及依赖于它的文件将是一种痛苦。如果更改一个包含文件但忘记重新编译所有依赖于它的文件，结果将是灾难性的。 clang 有一个选项来分析您的文件并生成包含文件及其依赖关系的列表： -MM 。

如果您将此添加到您的 Makefile 中：

depend:
	cc -E -MM *.c > .depend

并运行 make depend ，文件.depend 将显示一个对象文件列表，C 文件和包含文件：

foo.o: foo.c foo.h

如果您更改 foo.h，下次运行 make 时，所有依赖于 foo.h 的文件将被重新编译。

每次向文件中添加包含文件时，不要忘记运行 make depend 。

2.5.4. FreeBSD Makefiles

编写 Makefiles 可能会相当复杂。幸运的是，像 FreeBSD 这样的基于 BSD 的系统自带一些非常强大的 Makefiles 作为系统的一部分。一个很好的例子是 FreeBSD ports 系统。这是典型 ports Makefile 的基本部分。

MASTER_SITES=   ftp://freefall.cdrom.com/pub/FreeBSD/LOCAL_PORTS/
DISTFILES=      scheme-microcode+dist-7.3-freebsd.tgz

.include <bsd.port.mk>

现在，如果我们转到此port的目录并键入 make ，将会发生以下情况：

1. 将检查系统上是否已存在此port的源代码。

2. 如果不存在，则将建立到 MASTER_SITES 中 URL 的 FTP 连接以下载源代码。

3. 源代码的校验和将被计算并与已知的良好源代码的校验和进行比较。这是为了确保源代码在传输过程中没有损坏。

4. 适用于 FreeBSD 的源代码所需的任何更改都会被应用-这被称为打补丁。

5. 源代码所需的任何特殊配置都将完成。（许多 UNIX®程序发行版尝试确定它们正在编译的 UNIX®版本以及哪些可选的 UNIX®功能存在-这就是在 FreeBSD ports场景中提供信息的地方）。

6. 编译程序的源代码。实际上，我们转到解压源代码的目录，执行 make - 程序的 make 文件包含构建程序所需的必要信息。

7. 现在我们有了程序的已编译版本。如果希望，现在可以测试它；当对程序感到满意时，可以输入 make install 。这将导致程序及其所需的任何支持文件被复制到正确的位置；还会在 package database 中进行记录，以便稍后可以轻松卸载port，如果我们改变主意的话。

现在我认为您会同意，这对于一个四行脚本来说相当令人印象深刻！

秘密在最后一行，告诉 make 查找名为 bsd.port.mk 的系统 makefile。很容易忽略这一行，但这是所有聪明技巧的来源-有人编写了一个 makefile，告诉 make 执行上述所有操作（还有一些我没有提到的其他操作，包括处理可能发生的任何错误），任何人都可以通过在自己的 makefile 中加入一行来访问它！

如果您想查看这些系统 makefile，它们位于 /usr/share/mk，但最好等到您对 makefile 有了一些实践后再查看，因为它们非常复杂（如果您确实查看它们，请确保您随身携带一瓶浓咖啡！）

2.5.5. make 的更高级用法

Make 是一个非常强大的工具，可以做比上面简单示例展示的更多事情。不幸的是，有几个不同版本的 make ，它们之间有很大的区别。了解它们能做什么的最好方法可能是阅读文档-希望这个介绍能为您提供一个基础，让您可以做到这一点。make(1) 手册页面提供了关于变量、参数以及如何使用 make 的全面讨论。

在 ports 中，许多应用程序使用 GNU make，它有一套非常好的 "info" 页面。如果您安装了其中任何一个 ports，GNU make 将自动安装为 gmake 。它也作为一个 port 和独立软件包提供。

要查看 GNU make 的 info 页面，您需要编辑 /usr/local/info 目录中的 dir，以添加一个条目。这涉及添加一行，例如

 * Make: (make).                 The GNU Make utility.

到文件中。一旦完成此操作，您可以键入 info ，然后从菜单中选择 make（或者在 Emacs 中，执行 C-h i ）。

2.6. 调试

2.6.1. 可用调试器介绍

使用调试器允许在更受控制的情况下运行程序。通常，可以逐行执行程序，检查变量的值，更改它们，告诉调试器运行到某个特定点然后停止，等等。还可以附加到已经运行的程序，或加载核心文件以调查程序崩溃的原因。

本节旨在快速介绍使用调试器，并不涵盖诸如调试内核之类的专业主题。有关更多信息，请参阅内核调试。

FreeBSD 提供的标准调试器称为 lldb （LLVM 调试器）。由于它是该版本的标准安装的一部分，因此无需采取任何特殊操作即可使用它。它具有良好的命令帮助，可通过 help 命令访问，以及网页教程和文档。

FreeBSD 中另一个可用的调试器称为 gdb （GNU 调试器）。与 lldb 不同，它不会默认安装在 FreeBSD 上；要使用它，请从 ports 或软件包中安装 devel/gdb。它具有出色的在线帮助，以及一组信息页面。

这两个调试器具有类似的功能集，因此使用哪一个在很大程度上取决于个人口味。如果只熟悉其中一个，请使用该调试器。对于既不熟悉也不熟悉但想要在 Emacs 中使用一个调试器的人，需要使用 gdb ，因为 Emacs 不支持 lldb 。否则，请尝试两者，看看您更喜欢哪一个。

2.6.2. 使用 lldb

2.6.2.1. 启动 lldb

通过输入启动 lldb

% lldb -- progname

运行带有 lldb 的程序

使用 -g 编译程序，以充分利用 lldb 的功能。没有也可以运行，但只会显示当前运行函数的名称，而不是源代码。如果显示类似以下行：

Breakpoint 1: where = temp`main, address = …

（在设置断点时没有显示源代码文件名和行号），这意味着程序没有使用 -g 编译。

在 lldb 提示符下，输入 breakpoint set -n main 。这将告诉调试器不显示正在运行的程序的预备设置代码，并在程序代码的开头停止执行。现在输入 process launch 来实际启动程序- 它将从设置代码的开头开始运行，然后在调用 main() 时被调试器停止。

逐行执行程序，输入 thread step-over 。当程序执行到函数调用时，通过输入 thread step-in 进入该函数调用。在函数调用中，通过输入 thread step-out 返回，或使用 up 和 down 快速查看调用方。

这里是一个简单的示例，展示如何通过 lldb 来发现程序中的错误。 这是我们的程序（有一个故意的错误）：

#include <stdio.h>

int bazz(int anint);

main() {
	int i;

	printf("This is my program\n");
	bazz(i);
	return 0;
}

int bazz(int anint) {
	printf("You gave me %d\n", anint);
	return anint;
}

该程序将 i 设置为 5 ，并将其传递给一个函数 bazz() ，该函数打印出我们给定的数字。

编译并运行程序会显示

% cc -g -o temp temp.c
% ./temp
This is my program
anint = -5360

那不是预期的情况！是时候看看发生了什么！

% lldb -- temp
(lldb) target create "temp"
Current executable set to 'temp' (x86_64).
(lldb) breakpoint set -n main				Skip the set-up code
Breakpoint 1: where = temp`main + 15 at temp.c:8:2, address = 0x00000000002012ef	lldb puts breakpoint at main()
(lldb) process launch					Run as far as main()
Process 9992 launching
Process 9992 launched: '/home/pauamma/tmp/temp' (x86_64)	Program starts running

Process 9992 stopped
* thread #1, name = 'temp', stop reason = breakpoint 1.1	lldb stops at main()
    frame #0: 0x00000000002012ef temp`main at temp.c:8:2
   5	main() {
   6		int i;
   7
-> 8		printf("This is my program\n");			Indicates the line where it stopped
   9		bazz(i);
   10		return 0;
   11	}
(lldb) thread step-over			Go to next line
This is my program						Program prints out
Process 9992 stopped
* thread #1, name = 'temp', stop reason = step over
    frame #0: 0x0000000000201300 temp`main at temp.c:9:7
   6		int i;
   7
   8		printf("This is my program\n");
-> 9		bazz(i);
   10		return 0;
   11	}
   12
(lldb) thread step-in			step into bazz()
Process 9992 stopped
* thread #1, name = 'temp', stop reason = step in
    frame #0: 0x000000000020132b temp`bazz(anint=-5360) at temp.c:14:29	lldb displays stack frame
   11	}
   12
   13	int bazz(int anint) {
-> 14		printf("You gave me %d\n", anint);
   15		return anint;
   16	}
(lldb)

等一下！anint 怎么到 -5360 了？它不是在 main() 中设置为 5 的吗？让我们上到 main() 看看。

(lldb) up		Move up call stack
frame #1: 0x000000000020130b temp`main at temp.c:9:2		lldb displays stack frame
   6		int i;
   7
   8		printf("This is my program\n");
-> 9		bazz(i);
   10		return 0;
   11	}
   12
(lldb) frame variable i			Show us the value of i
(int) i = -5360							lldb displays -5360

噢！看代码，我们忘记初始化 i 了。我们本意是要放置

...
main() {
	int i;

	i = 5;
	printf("This is my program\n");
...

但我们遗漏了 i=5; 行。因为我们没有初始化 i，所以当程序运行时，它会使用内存区域中的任意数字，而在这种情况下恰好是 -5360 。

2.6.2.3. 使用 lldb 检查核心文件

核心文件基本上是一个文件，其中包含进程在崩溃时的完整状态。在“旧日里”，程序员们不得不打印核心文件的十六进制列表，并苦苦钻研机器码手册，但现在生活变得更容易了。顺便说一句，在 FreeBSD 和其他 4.4BSD 系统下，核心文件被称为 progname.core，而不仅仅是 core，以便更清楚地表明核心文件属于哪个程序。

要检查核心文件，请除了程序本身外，还指定核心文件的名称。不要像通常那样启动 lldb ，而是键入 lldb -c progname.core -- progname 。

调试器将显示类似于这样的内容：

% lldb -c progname.core -- progname
(lldb) target create "progname" --core "progname.core"
Core file '/home/pauamma/tmp/progname.core' (x86_64) was loaded.
(lldb)

在这种情况下，程序被称为 progname，因此核心文件被称为 progname.core。调试器不会显示程序崩溃的原因或位置。为此，请使用 thread backtrace all 。这也会显示程序转储核心的函数是如何被调用的。

(lldb) thread backtrace all
 thread #1, name = 'progname', stop reason = signal SIGSEGV
   frame #0: 0x0000000000201347 progname`bazz(anint=5) at temp2.c:17:10
    frame #1: 0x0000000000201312 progname`main at temp2.c:10:2
    frame #2: 0x000000000020110f progname`_start(ap=<unavailable>, cleanup=<unavailable>) at crt1.c:76:7
(lldb)

SIGSEGV 表示程序尝试访问内存（通常运行代码或读/写数据）的位置不属于它，但不提供任何具体信息。为此，请查看文件 temp2.c 的第 10 行的源代码，在 bazz() 中。回溯还显示，在这种情况下， bazz() 是从 main() 调用的。

2.6.2.4. 使用 lldb 附加到正在运行的程序

lldb 的一个最棒的功能是它可以附加到已经运行的程序。当然，这需要足够的权限才能这样做。一个常见的问题是在一个分叉的程序中单步执行，并希望跟踪子进程，但调试器只会跟踪父进程。

要做到这一点，启动另一个 lldb ，使用 ps 找到子进程的进程 ID，然后执行

(lldb) process attach -p pid

在 lldb 中，然后像往常一样进行调试。

要让这个功能正常工作，调用 fork 创建子元素的代码需要像以下这样做（感谢 gdb 信息页面）：

...
if ((pid = fork()) < 0)		/* _Always_ check this */
	error();
else if (pid == 0) {		/* child */
	int PauseMode = 1;

	while (PauseMode)
		sleep(10);	/* Wait until someone attaches to us */
	...
} else {			/* parent */
	...

现在需要做的只是附加到子元素，将 PauseMode 设置为 0 ，使用 expr PauseMode = 0 等待 sleep() 调用返回。

2.6.3. 使用 LLDB 进行远程调试

从 LLDB 12.0.0 开始，FreeBSD 支持远程调试。这意味着 lldb-server 可以在一个主机上启动以调试程序，而交互式 lldb 客户端可以从另一个主机连接到它。

要启动新的进程以进行远程调试，请在远程服务器上运行 lldb-server ，然后输入。

% lldb-server g host:port -- progname

启动后立即停止该进程，并 lldb-server 等待客户端连接。

在本地启动 lldb ，然后输入以下命令以连接到远程服务器：

(lldb) gdb-remote host:port

lldb-server 也可以连接到正在运行的进程。要执行此操作，请在远程服务器上输入以下内容：

% lldb-server g host:port --attach pid-or-name

2.6.4. 使用 gdb

2.6.4.1. 启动 gdb

通过输入以下内容启动 gdb

% gdb progname

尽管许多人更喜欢在 Emacs 中运行它。要做到这一点，请输入：

 M-x gdb RET progname RET

最后，对于那些觉得文本命令提示风格令人反感的人，Ports集合中有一个图形化界面 (devel/xxgdb)可用。

2.6.4.2. 使用 gdb 运行程序

使用 -g 编译程序，以充分利用 gdb 。没有也能运行，但只会显示当前运行函数的名称，而不是源代码。像这样的一行：

... (no debugging symbols found) ...

当 gdb 启动时，意味着程序未使用 -g 编译。

在 gdb 提示符下，输入 break main 。这将告诉调试器跳过正在运行程序中的预备设置代码，并在程序代码开头停止执行。现在输入 run 启动程序-它将从设置代码开头开始运行，然后在调用 main() 时被调试器停止。

逐行执行程序，按 n 。在函数调用时，按 s 进入函数。在函数调用中，按 f 返回，或使用 up 和 down 快速查看调用者。

这里是一个简单的示例，演示如何使用 gdb 在程序中发现错误。这是我们的程序（带有一个故意的错误）：

#include <stdio.h>

int bazz(int anint);

main() {
	int i;

	printf("This is my program\n");
	bazz(i);
	return 0;
}

int bazz(int anint) {
	printf("You gave me %d\n", anint);
	return anint;
}

该程序将 i 设置为 5 ，并将其传递给一个函数 bazz() ，该函数打印出我们给它的数字。

编译和运行程序显示

% cc -g -o temp temp.c
% ./temp
This is my program
anint = 4231

那不是我们所期望的！是时候看看发生了什么！

% gdb temp
GDB is free software and you are welcome to distribute copies of it
 under certain conditions; type "show copying" to see the conditions.
There is absolutely no warranty for GDB; type "show warranty" for details.
GDB 4.13 (i386-unknown-freebsd), Copyright 1994 Free Software Foundation, Inc.
(gdb) break main				Skip the set-up code
Breakpoint 1 at 0x160f: file temp.c, line 9.	gdb puts breakpoint at main()
(gdb) run					Run as far as main()
Starting program: /home/james/tmp/temp		Program starts running

Breakpoint 1, main () at temp.c:9		gdb stops at main()
(gdb) n						Go to next line
This is my program				Program prints out
(gdb) s						step into bazz()
bazz (anint=4231) at temp.c:17			gdb displays stack frame
(gdb)

等一下！anint 是怎么变成 4231 的？它不是应该设为 5 在 main() 中吗？让我们上到 main() 看一看。

(gdb) up					Move up call stack
#1  0x1625 in main () at temp.c:11		gdb displays stack frame
(gdb) p i					Show us the value of i
$1 = 4231					gdb displays 4231

哦亲爱的！看着这段代码，我们忘了初始化 i。我们本打算放

...
main() {
	int i;

	i = 5;
	printf("This is my program\n");
...

但我们遗漏了 i=5; 这一行。由于我们没有初始化 i，在程序运行时，它拥有那个区域内存中的任意数字，在这种情况下恰好是 4231 。

2.6.4.3. 使用 gdb 检查核心文件

核心文件基本上是一个包含进程在崩溃时完整状态的文件。在“往昔”，程序员必须打印出核心文件的十六进制列表，并苦思冥想于机器码手册，但现在生活变得容易一些。顺便说一句，在 FreeBSD 和其他 4.4BSD 系统下，核心文件称为 progname.core 而不仅仅是 core，以便清楚地表示核心文件属于哪个程序。

要检查一个核心文件，以通常的方式启动 gdb 。而不是输入 break 或 run ，输入

(gdb) core progname.core

如果核心文件不在当前目录中，请首先键入 dir /path/to/core/file 。

调试器应该显示类似以下内容：

% gdb progname
GDB is free software and you are welcome to distribute copies of it
 under certain conditions; type "show copying" to see the conditions.
There is absolutely no warranty for GDB; type "show warranty" for details.
GDB 4.13 (i386-unknown-freebsd), Copyright 1994 Free Software Foundation, Inc.
(gdb) core progname.core
Core was generated by `progname'.
Program terminated with signal 11, Segmentation fault.
Cannot access memory at address 0x7020796d.
#0  0x164a in bazz (anint=0x5) at temp.c:17
(gdb)

在这种情况下，程序被称为 progname，因此核心文件称为 progname.core。我们可以看到程序由于尝试访问一个在内存中对它不可用的区域而崩溃，此区域位于一个名为 bazz 的函数中。

有时候，能够查看函数的调用方式是很有用的，因为问题可能出现在复杂程序的调用堆栈中很长的地方。 bt 导致 gdb 打印出调用堆栈的回溯:

(gdb) bt
#0  0x164a in bazz (anint=0x5) at temp.c:17
#1  0xefbfd888 in end ()
#2  0x162c in main () at temp.c:11
(gdb)

当程序崩溃时，会调用 end() 函数；在这种情况下， bazz() 函数是从 main() 调用的。

2.6.4.4. 通过 gdb 连接到正在运行的程序

gdb 最好的功能之一是它可以附加到已经运行的程序。当然，这需要足够的权限才能这样做。一个常见的问题是在一个分叉并希望跟踪子进程的程序中进行步进，但调试器只会跟踪父进程。

要做到这一点，启动另一个 gdb ，使用 ps 查找子进程的进程 ID，然后执行

(gdb) attach pid

在 gdb 中，然后像往常一样进行调试。

为了使其正常工作，调用 fork 创建子项的代码需要执行类似以下操作（感谢 gdb 信息页面）：

...
if ((pid = fork()) < 0)		/* _Always_ check this */
	error();
else if (pid == 0) {		/* child */
	int PauseMode = 1;

	while (PauseMode)
		sleep(10);	/* Wait until someone attaches to us */
	...
} else {			/* parent */
	...

现在所需的只是附加到子项，将 PauseMode 设置为 0 ，并等待 sleep() 调用返回！

2.7. 使用 Emacs 作为开发环境

2.7.1. Emacs

Emacs 是一个高度可定制的编辑器-事实上，它已经被定制到了一个程度，更像是一个操作系统而不是一个编辑器！许多开发人员和系统管理员实际上几乎所有的时间都在 Emacs 中工作，只是偶尔登出一下。

在这里是不可能甚至仅概括 Emacs 能做的一切的，但下面是一些对开发人员感兴趣的功能：

• 非常强大的编辑器，允许对字符串和正则表达式（模式）进行查找和替换，跳转到块表达式的开始/结束等。

• 下拉菜单和在线帮助。

• 语言相关的语法高亮和缩进。

• 完全定制化。

• 您可以在 Emacs 中编译和调试程序。

• 在编译错误时，您可以跳转到有问题的源代码行。

• 用于阅读 GNU 超文本文档的 info 程序的友好前端，包括 Emacs 本身的文档。

• 友好的 gdb 前端，允许您在逐步执行程序时查看源代码。

肯定还有许多被忽视的。

Emacs 可以使用 editors/emacs port在 FreeBSD 上进行安装。

安装完成后，启动它，按下 C-h t 以阅读 Emacs 教程-这意味着按住 Ctrl 键，按下 h 键，释放 Ctrl 键，然后按下 t 键。(或者，您也可以使用鼠标从帮助菜单中选择 Emacs 教程。)

尽管 Emacs 有菜单，但学习按键绑定是非常值得的，因为在编辑时按下几个键比试图找到鼠标然后点击正确位置要快得多。当您与经验丰富的 Emacs 用户交谈时，您会发现他们经常轻松地抛出像“M-x replace-s RET foo RET bar RET”这样的表达，所以知道它们是什么意思是有用的。而且无论如何，Emacs 有太多有用的功能，以至于它们无法全部适合菜单栏中。

幸运的是，很容易掌握组合键，因为它们显示在菜单项旁边。我的建议是，使用菜单项，比如打开一个文件，直到你理解它是如何工作的并且感到自信，然后尝试按下 C-x C-f。当你对此感到满意时，再转向另一个菜单命令。

如果你记不住特定组合键的作用，可以从帮助菜单中选择描述键，并输入它-Emacs 会告诉你它的作用。你也可以使用命令 Apropos 菜单项来查找所有包含特定单词的命令，以及其旁边的组合键。

顺便说一句，上面的表达意思是按住 Meta 键，按下 x，释放 Meta 键，输入 replace-s （缩写为 replace-string -Emacs 的另一个特性是你可以缩写命令），按下回车键，输入 foo （你想要替换的字符串），再次按下回车键，输入 bar（你想要用 foo 替换的字符串），然后再次按下回车。Emacs 将执行你刚刚请求的搜索和替换操作。

如果您想知道 Meta 究竟是什么，它是许多 UNIX®工作站具有的一个特殊键。不幸的是，PC 没有这样的键，因此通常是 alt 键（或者如果您不幸的话，是 escape 键）。

哦，要退出 Emacs，请执行 C-x C-c （这意味着按住控制键，按下 x 键，按下 c 键，然后释放控制键）。如果有任何未保存的文件打开，Emacs 会询问您是否要保存它们。（忽略文档中说 C-z 是离开 Emacs 的通常方法的部分-那会让 Emacs 在后台运行，并且只有在您使用没有虚拟终端的系统时才真正有用）。

2.7.2. 配置 Emacs

Emacs 做了许多美好的事情;其中一些是内置的，一些需要配置。

Emacs 不使用专有的宏语言进行配置，而是使用一种专门为编辑器调整的 Lisp 版本，称为 Emacs Lisp。如果您想继续学习类似 Common Lisp 之类的内容，使用 Emacs Lisp 可以帮助您很多。Emacs Lisp 具有许多 Common Lisp 的特性，尽管它相对较小（因此更容易掌握）。

学习 Emacs Lisp 的最佳途径是阅读在线的 Emacs 参考手册。

然而，不需要实际了解任何 Lisp 就可以开始配置 Emacs，因为我已经包含了一个示例.emacs，这应该足以让您开始。只需将其复制到您的主目录并重新启动 Emacs（如果它已经在运行）；它将从该文件中读取命令，并（希望）为您提供一个有用的基本设置。

2.7.3. 一个示例.emacs

不幸的是，在这里有太多内容要详细解释；然而，有一两点值得一提。

• 一切以 ; 开头的内容都是注释，Emacs 会忽略它。

• 在第一行， -- Emacs-Lisp -- 是为了让我们可以在 Emacs 中编辑.emacs 本身，并获得用于编辑 Emacs Lisp 的所有花哨功能。Emacs 通常会根据文件名来猜测这一点，对于.emacs 可能猜测不正确。

• 在某些模式下，Tab 键绑定到缩进功能，因此当您按 Tab 键时，它会缩进当前行的代码。如果您想在您正在编写的任何内容中放置一个制表符，请在按 Tab 键时按住 Control 键。

• 该文件通过从文件名猜测语言来支持 C、C++、Perl、Lisp 和 Scheme 的语法高亮显示。

• Emacs 已经有一个预定义的函数称为 next-error 。在编译输出窗口中，这允许您通过执行 M-n 从一个编译错误移动到下一个；我们定义了一个补充函数 previous-error ，它允许您通过执行 M-p 转到上一个错误。最好的功能是 C-c C-c 将打开发生错误的源文件并跳转到适当的行。

• 我们启用了 Emacs 作为服务器的功能，这样，如果您在 Emacs 之外做一些事情并且想要编辑一个文件，您只需输入

  复制

  % emacsclient filename

  然后您可以在 Emacs 中编辑文件！^[ 6]^

示例 1. 一个示例 .emacs

;; -*-Emacs-Lisp-*-

;; This file is designed to be re-evaled; use the variable first-time
;; to avoid any problems with this.
(defvar first-time t
  "Flag signifying this is the first time that .emacs has been evaled")

;; Meta
(global-set-key "\M- " 'set-mark-command)
(global-set-key "\M-\C-h" 'backward-kill-word)
(global-set-key "\M-\C-r" 'query-replace)
(global-set-key "\M-r" 'replace-string)
(global-set-key "\M-g" 'goto-line)
(global-set-key "\M-h" 'help-command)

;; Function keys
(global-set-key [f1] 'manual-entry)
(global-set-key [f2] 'info)
(global-set-key [f3] 'repeat-complex-command)
(global-set-key [f4] 'advertised-undo)
(global-set-key [f5] 'eval-current-buffer)
(global-set-key [f6] 'buffer-menu)
(global-set-key [f7] 'other-window)
(global-set-key [f8] 'find-file)
(global-set-key [f9] 'save-buffer)
(global-set-key [f10] 'next-error)
(global-set-key [f11] 'compile)
(global-set-key [f12] 'grep)
(global-set-key [C-f1] 'compile)
(global-set-key [C-f2] 'grep)
(global-set-key [C-f3] 'next-error)
(global-set-key [C-f4] 'previous-error)
(global-set-key [C-f5] 'display-faces)
(global-set-key [C-f8] 'dired)
(global-set-key [C-f10] 'kill-compilation)

;; Keypad bindings
(global-set-key [up] "\C-p")
(global-set-key [down] "\C-n")
(global-set-key [left] "\C-b")
(global-set-key [right] "\C-f")
(global-set-key [home] "\C-a")
(global-set-key [end] "\C-e")
(global-set-key [prior] "\M-v")
(global-set-key [next] "\C-v")
(global-set-key [C-up] "\M-\C-b")
(global-set-key [C-down] "\M-\C-f")
(global-set-key [C-left] "\M-b")
(global-set-key [C-right] "\M-f")
(global-set-key [C-home] "\M-<")
(global-set-key [C-end] "\M->")
(global-set-key [C-prior] "\M-<")
(global-set-key [C-next] "\M->")

;; Mouse
(global-set-key [mouse-3] 'imenu)

;; Misc
(global-set-key [C-tab] "\C-q\t")	; Control tab quotes a tab.
(setq backup-by-copying-when-mismatch t)

;; Treat 'y' or <CR> as yes, 'n' as no.
(fset 'yes-or-no-p 'y-or-n-p)
(define-key query-replace-map [return] 'act)
(define-key query-replace-map [?\C-m] 'act)

;; Load packages
(require 'desktop)
(require 'tar-mode)

;; Pretty diff mode
(autoload 'ediff-buffers "ediff" "Intelligent Emacs interface to diff" t)
(autoload 'ediff-files "ediff" "Intelligent Emacs interface to diff" t)
(autoload 'ediff-files-remote "ediff"
  "Intelligent Emacs interface to diff")

(if first-time
    (setq auto-mode-alist
	  (append '(("\\.cpp$" . c++-mode)
		    ("\\.hpp$" . c++-mode)
		    ("\\.lsp$" . lisp-mode)
		    ("\\.scm$" . scheme-mode)
		    ("\\.pl$" . perl-mode)
		    ) auto-mode-alist)))

;; Auto font lock mode
(defvar font-lock-auto-mode-list
  (list 'c-mode 'c++-mode 'c++-c-mode 'emacs-lisp-mode 'lisp-mode 'perl-mode 'scheme-mode)
  "List of modes to always start in font-lock-mode")

(defvar font-lock-mode-keyword-alist
  '((c++-c-mode . c-font-lock-keywords)
    (perl-mode . perl-font-lock-keywords))
  "Associations between modes and keywords")

(defun font-lock-auto-mode-select ()
  "Automatically select font-lock-mode if the current major mode is in font-lock-auto-mode-list"
  (if (memq major-mode font-lock-auto-mode-list)
      (progn
	(font-lock-mode t))
    )
  )

(global-set-key [M-f1] 'font-lock-fontify-buffer)

;; New dabbrev stuff
;(require 'new-dabbrev)
(setq dabbrev-always-check-other-buffers t)
(setq dabbrev-abbrev-char-regexp "\\sw\\|\\s_")
(add-hook 'emacs-lisp-mode-hook
	  '(lambda ()
	     (set (make-local-variable 'dabbrev-case-fold-search) nil)
	     (set (make-local-variable 'dabbrev-case-replace) nil)))
(add-hook 'c-mode-hook
	  '(lambda ()
	     (set (make-local-variable 'dabbrev-case-fold-search) nil)
	     (set (make-local-variable 'dabbrev-case-replace) nil)))
(add-hook 'text-mode-hook
	  '(lambda ()
	     (set (make-local-variable 'dabbrev-case-fold-search) t)
	     (set (make-local-variable 'dabbrev-case-replace) t)))

;; C++ and C mode...
(defun my-c++-mode-hook ()
  (setq tab-width 4)
  (define-key c++-mode-map "\C-m" 'reindent-then-newline-and-indent)
  (define-key c++-mode-map "\C-ce" 'c-comment-edit)
  (setq c++-auto-hungry-initial-state 'none)
  (setq c++-delete-function 'backward-delete-char)
  (setq c++-tab-always-indent t)
  (setq c-indent-level 4)
  (setq c-continued-statement-offset 4)
  (setq c++-empty-arglist-indent 4))

(defun my-c-mode-hook ()
  (setq tab-width 4)
  (define-key c-mode-map "\C-m" 'reindent-then-newline-and-indent)
  (define-key c-mode-map "\C-ce" 'c-comment-edit)
  (setq c-auto-hungry-initial-state 'none)
  (setq c-delete-function 'backward-delete-char)
  (setq c-tab-always-indent t)
;; BSD-ish indentation style
  (setq c-indent-level 4)
  (setq c-continued-statement-offset 4)
  (setq c-brace-offset -4)
  (setq c-argdecl-indent 0)
  (setq c-label-offset -4))

;; Perl mode
(defun my-perl-mode-hook ()
  (setq tab-width 4)
  (define-key c++-mode-map "\C-m" 'reindent-then-newline-and-indent)
  (setq perl-indent-level 4)
  (setq perl-continued-statement-offset 4))

;; Scheme mode...
(defun my-scheme-mode-hook ()
  (define-key scheme-mode-map "\C-m" 'reindent-then-newline-and-indent))

;; Emacs-Lisp mode...
(defun my-lisp-mode-hook ()
  (define-key lisp-mode-map "\C-m" 'reindent-then-newline-and-indent)
  (define-key lisp-mode-map "\C-i" 'lisp-indent-line)
  (define-key lisp-mode-map "\C-j" 'eval-print-last-sexp))

;; Add all of the hooks...
(add-hook 'c++-mode-hook 'my-c++-mode-hook)
(add-hook 'c-mode-hook 'my-c-mode-hook)
(add-hook 'scheme-mode-hook 'my-scheme-mode-hook)
(add-hook 'emacs-lisp-mode-hook 'my-lisp-mode-hook)
(add-hook 'lisp-mode-hook 'my-lisp-mode-hook)
(add-hook 'perl-mode-hook 'my-perl-mode-hook)

;; Complement to next-error
(defun previous-error (n)
  "Visit previous compilation error message and corresponding source code."
  (interactive "p")
  (next-error (- n)))

;; Misc...
(transient-mark-mode 1)
(setq mark-even-if-inactive t)
(setq visible-bell nil)
(setq next-line-add-newlines nil)
(setq compile-command "make")
(setq suggest-key-bindings nil)
(put 'eval-expression 'disabled nil)
(put 'narrow-to-region 'disabled nil)
(put 'set-goal-column 'disabled nil)
(if (>= emacs-major-version 21)
	(setq show-trailing-whitespace t))

;; Elisp archive searching
(autoload 'format-lisp-code-directory "lispdir" nil t)
(autoload 'lisp-dir-apropos "lispdir" nil t)
(autoload 'lisp-dir-retrieve "lispdir" nil t)
(autoload 'lisp-dir-verify "lispdir" nil t)

;; Font lock mode
(defun my-make-face (face color &optional bold)
  "Create a face from a color and optionally make it bold"
  (make-face face)
  (copy-face 'default face)
  (set-face-foreground face color)
  (if bold (make-face-bold face))
  )

(if (eq window-system 'x)
    (progn
      (my-make-face 'blue "blue")
      (my-make-face 'red "red")
      (my-make-face 'green "dark green")
      (setq font-lock-comment-face 'blue)
      (setq font-lock-string-face 'bold)
      (setq font-lock-type-face 'bold)
      (setq font-lock-keyword-face 'bold)
      (setq font-lock-function-name-face 'red)
      (setq font-lock-doc-string-face 'green)
      (add-hook 'find-file-hooks 'font-lock-auto-mode-select)

      (setq baud-rate 1000000)
      (global-set-key "\C-cmm" 'menu-bar-mode)
      (global-set-key "\C-cms" 'scroll-bar-mode)
      (global-set-key [backspace] 'backward-delete-char)
					;      (global-set-key [delete] 'delete-char)
      (standard-display-european t)
      (load-library "iso-transl")))

;; X11 or PC using direct screen writes
(if window-system
    (progn
      ;;      (global-set-key [M-f1] 'hilit-repaint-command)
      ;;      (global-set-key [M-f2] [?\C-u M-f1])
      (setq hilit-mode-enable-list
	    '(not text-mode c-mode c++-mode emacs-lisp-mode lisp-mode
		  scheme-mode)
	    hilit-auto-highlight nil
	    hilit-auto-rehighlight 'visible
	    hilit-inhibit-hooks nil
	    hilit-inhibit-rebinding t)
      (require 'hilit19)
      (require 'paren))
  (setq baud-rate 2400)			; For slow serial connections
  )

;; TTY type terminal
(if (and (not window-system)
	 (not (equal system-type 'ms-dos)))
    (progn
      (if first-time
	  (progn
	    (keyboard-translate ?\C-h ?\C-?)
	    (keyboard-translate ?\C-? ?\C-h)))))

;; Under UNIX
(if (not (equal system-type 'ms-dos))
    (progn
      (if first-time
	  (server-start))))

;; Add any face changes here
(add-hook 'term-setup-hook 'my-term-setup-hook)
(defun my-term-setup-hook ()
  (if (eq window-system 'pc)
      (progn
;;	(set-face-background 'default "red")
	)))

;; Restore the "desktop" - do this as late as possible
(if first-time
    (progn
      (desktop-load-default)
      (desktop-read)))

;; Indicate that this file has been read at least once
(setq first-time nil)

;; No need to debug anything now

(setq debug-on-error nil)

;; All done
(message "All done, %s%s" (user-login-name) ".")

2.7.4. 扩展 Emacs 理解的语言范围

现在，如果您只想在已经适应的语言（C、C++、Perl、Lisp 和 Scheme）中编程，那么这一切都很顺利，但是如果一个名为"whizbang"的新语言出现了，充满了令人兴奋的特性，会发生什么呢？

首先要做的是找出 whizbang 是否附带告诉 Emacs 有关该语言的任何文件。这些文件通常以.el 结尾，缩写为"Emacs Lisp"。例如，如果 whizbang 是一个 FreeBSD port，我们可以通过以下方式找到这些文件

% find /usr/ports/lang/whizbang -name "*.el" -print

并将它们复制到 Emacs 站点 Lisp 目录中进行安装。在 FreeBSD 上，这个目录是/usr/local/share/emacs/site-lisp。

所以例如，如果来自 find 命令的输出是

/usr/ports/lang/whizbang/work/misc/whizbang.el

我们会执行

# cp /usr/ports/lang/whizbang/work/misc/whizbang.el /usr/local/share/emacs/site-lisp

接下来，我们需要决定 whizbang 源文件具有什么扩展名。假设为了论证的目的，它们都以 .wiz 结尾。我们需要向我们的 .emacs 添加一个条目，以确保 Emacs 能够使用 whizbang.el 中的信息。

在.emacs 中找到 auto-mode-alist 条目，并添加一行 whizbang，例如：

...
("\\.lsp$" . lisp-mode)
("\\.wiz$" . whizbang-mode)
("\\.scm$" . scheme-mode)
...

这意味着当您编辑以.wiz 结尾的文件时，Emacs 会自动进入 whizbang-mode 模式。

在此下方，您会找到 font-lock-auto-mode-list 条目。像这样将 whizbang-mode 添加到其中：

;; Auto font lock mode
(defvar font-lock-auto-mode-list
  (list 'c-mode 'c++-mode 'c++-c-mode 'emacs-lisp-mode 'whizbang-mode 'lisp-mode 'perl-mode 'scheme-mode)
  "List of modes to always start in font-lock-mode")

这意味着当编辑.wiz 文件时，Emacs 将始终启用 font-lock-mode （即语法高亮显示）。

这就是所需的全部。如果在打开.wiz 文件时还有其他自动完成的事情，您可以添加 whizbang-mode hook （请参阅 my-scheme-mode-hook 以查看一个添加 auto-indent 的简单示例）。

2.8. 更多阅读

有关设置开发环境以贡献 FreeBSD 本身修复的信息，请参阅 development(7)。

• Brian Harvey and Matthew Wright Simply Scheme MIT 1994. ISBN 0-262-08226-8

• Randall Schwartz Learning Perl O’Reilly 1993 ISBN 1-56592-042-2

• Patrick Henry Winston and Berthold Klaus Paul Horn Lisp (3rd Edition) Addison-Wesley 1989 ISBN 0-201-08319-1

• Brian W. Kernighan and Rob Pike The Unix Programming Environment Prentice-Hall 1984 ISBN 0-13-937681-X

• Brian W. Kernighan and Dennis M. Ritchie The C Programming Language (2nd Edition) Prentice-Hall 1988 ISBN 0-13-110362-8

• Bjarne Stroustrup The C++ Programming Language Addison-Wesley 1991 ISBN 0-201-53992-6

• W. Richard Stevens Advanced Programming in the Unix Environment Addison-Wesley 1992 ISBN 0-201-56317-7

• W. Richard Stevens Unix Network Programming Prentice-Hall 1990 ISBN 0-13-949876-1

1. 如果您在shell中运行它，可能会导致核心转储。

2. 如果您不知道，二进制排序是一种有效的排序方法，而冒泡排序则不是。

3. 其原因根植于历史的尘埃之中。

4. 注意，我们没有使用 -o 标志来指定可执行文件的名称，因此我们将得到一个名为 a.out 的可执行文件。生成一个名为 foobar 的调试版本留给读者作为练习！

5. 他们不使用 MAKEFILE 形式，因为大写字母通常用于 README 等文档文件。

6. 许多 Emacs 用户将他们的 EDITOR 环境设置为 emacsclient，因此每次需要编辑文件时都会发生这种情况。

3.1. 概要

本章描述了困扰 UNIX®程序员数十年的一些安全问题，以及可用于帮助程序员避免编写易受攻击代码的新工具。

3.2. 安全设计方法论

编写安全应用程序需要对生活持非常谨慎和悲观的态度。应用程序应该以“最小权限”原则运行，以确保没有任何进程以超出其完成功能所需的最低访问权限。应尽可能重用先前经过测试的代码，以避免他人可能已经修复的常见错误。

UNIX®环境的一个陷阱是很容易对环境的健全性做出假设。应用程序永远不应信任用户输入（以各种形式出现）、系统资源、进程间通信或事件的定时。UNIX®进程不是同步执行的，因此逻辑操作很少是原子的。

3.3. 缓冲区溢出

缓冲区溢出自冯·诺伊曼 1 架构的最初阶段就存在。它们首次在 1988 年与莫里斯互联网蠕虫一起广为人知。不幸的是，同一基本攻击手法至今仍然有效。迄今为止，最常见的缓冲区溢出攻击类型是基于破坏堆栈。

大多数现代计算机系统使用栈来传递参数给过程并存储局部变量。栈是进程映像的高内存区域中的后进先出（LIFO）缓冲区。当程序调用函数时，将创建一个新的“栈帧”。这个栈帧包括传递给函数的参数以及动态数量的局部变量空间。 “栈指针”是一个保存栈顶当前位置的寄存器。由于随着新值被推送到栈顶，该值不断改变，因此许多实现还提供了一个“帧指针”，该指针位于栈帧的开始附近，以便局部变量可以更容易地相对于此值进行寻址。函数调用的返回地址也存储在栈中，这是堆栈溢出攻击的原因，因为溢出函数中的局部变量可能会覆盖该函数的返回地址，从而使恶意用户可以执行任何他或她想要的代码。

尽管基于栈的攻击远远是最常见的，但也可能使用基于堆的（malloc/free）攻击来溢出堆栈。

C 语言不像许多其他语言那样对数组或指针执行自动边界检查。此外，标准 C 库中充斥着一些非常危险的函数。

3.3.1. 缓冲区溢出示例

以下示例代码包含一个缓冲区溢出，旨在覆盖返回地址并跳过函数调用后紧接的指令。（受 4 启发）

#include <stdio.h>

void manipulate(char *buffer) {
  char newbuffer[80];
  strcpy(newbuffer,buffer);
}

int main() {
  char ch,buffer[4096];
  int i=0;

  while ((buffer[i++] = getchar()) != '\n') {};

  i=1;
  manipulate(buffer);
  i=2;
  printf("The value of i is : %d\n",i);
  return 0;
}

让我们看看如果我们在按回车键之前向我们的小程序输入 160 个空格会导致该进程的内存映像是什么样子。

显然可以设计更恶意的输入来执行实际的编译指令（比如 exec(/bin/sh)）。

3.3.2. 避免缓冲区溢出

解决栈溢出问题最直接的方法是始终使用长度限制的内存和字符串复制函数。 strncpy 和 strncat 是标准 C 库的一部分。这些函数接受一个长度值作为参数，该值不应大于目标缓冲区的大小。然后，这些函数将从源复制最多'长度'字节到目的地。然而，这些函数存在一些问题。如果输入缓冲区的大小与目标相同大，这两个函数都不保证 NUL 终止。长度参数在 strncpy 和 strncat 之间也使用不一致，因此程序员很容易混淆它们的正确用法。与 strcpy 相比，当将短字符串复制到大缓冲区时，性能损失也很大，因为 strncpy NUL 填充了指定的大小。

另一个内存复制实现存在以解决这些问题。 strlcpy 和 strlcat 函数保证在给定非零长度参数时始终将目标字符串以 NUL 终止。

基于编译器的运行时边界检查

不幸的是，仍然有大量的公共代码在使用中，它们在内存中盲目复制数据而不使用我们刚讨论过的任何有界复制例程。幸运的是，有一种方法可以帮助防止这种攻击 - 运行时边界检查，这是由几个 C/C++编译器实现的。

ProPolice 是其中一个编译器特性，已集成到 gcc(1)版本 4.1 及更高版本中。它取代并扩展了早期的 StackGuard gcc(1)扩展。

ProPolice 通过在调用任何函数之前在堆栈的关键区域放置伪随机数来帮助防护堆栈型缓冲区溢出和其他攻击。当函数返回时，这些“canaries”会被检查，如果发现它们已被更改，则立即中止可执行文件。因此，任何试图修改返回地址或在堆栈上存储其他变量以运行恶意代码的尝试都不太可能成功，因为攻击者还必须设法保持伪随机 canaries 不变。

使用 ProPolice 重新编译应用是阻止大多数缓冲区溢出攻击的有效手段，但仍可能会被破坏。

3.3.2.2. 基于库的运行时边界检查

编译器基于机制对于只有二进制可用的软件是完全无用的，对于这种情况下你无法重新编译软件。针对这些情况，有许多库重新实现 C 库的不安全函数 ( strcpy , fscanf , getwd , 等等..) 并确保这些函数永远不会写出栈指针。

• libsafe

• libverify

• 自卫

不幸的是，这些基于库的防御措施存在许多缺点。这些库只保护非常少量与安全相关的问题，而忽略了修复实际问题。如果应用程序是使用 -fomit-frame-pointer 编译的，这些防御可能会失败。此外，LD_PRELOAD 和 LD_LIBRARY_PATH 环境变量可能会被用户覆盖/取消设置。

3.4. SetUID 问题

任何给定进程都关联至少 6 个不同的 ID，因此您必须非常小心处理进程在任何给定时间具有的访问权限。特别是，所有 seteuid 应用程序应在不再需要特权时放弃特权。

只有超级用户进程才能更改真实用户 ID。登录程序在用户最初登录时设置此 ID，很少更改。

如果程序设置了其 seteuid 位， exec() 函数将设置有效用户 ID。应用程序可以随时调用 seteuid() 将有效用户 ID 设置为真实用户 ID 或保存的设置用户 ID。当有效用户 ID 由 exec() 函数设置时，先前的值将保存在保存的设置用户 ID 中。

3.5. 限制你的程序环境

限制进程的传统方法是使用 chroot() 系统调用。该系统调用会改变进程及其子进程引用的所有其他路径的根目录。要使此调用成功，进程必须对被引用的目录具有执行（搜索）权限。新环境实际上直到您切换到新环境后才生效。还应该注意，如果进程具有 root 特权，它可以很容易地跳出 chroot 环境。可以通过创建设备节点来读取内核内存，将调试器连接到 chroot 环境外的进程，或以许多其他创造性的方式来实现这一点。

chroot() 系统调用的行为可以通过 kern.chroot_allow_open_directories sysctl 变量来进行一定程度的控制。当此值设置为 0 时，如果存在任何打开的目录，则 chroot() 将因为 EPERM 而失败。如果设置为默认值 1，则如果存在任何打开目录并且进程已经受到 chroot() 调用的约束，那么 chroot() 将因为 EPERM 而失败。对于任何其他值，打开目录的检查将完全被绕过。

3.5.1. FreeBSD 的jail功能

“Jail”的概念是在 chroot() 的基础上进行扩展，通过限制超级用户的权限来创建一个真正的“虚拟服务器”。一旦设置了 jail ，所有的网络通信必须通过指定的 IP 地址进行，而在这个jail中，“root 权限”的权力受到严格限制。

在 jail 中，通过 suser() 调用测试内核中超级用户权限的任何尝试都会失败。然而，一些对 suser() 的调用已更改为一个新的接口 suser_xxx() 。这个函数负责识别或拒绝对被 jail 进程的超级用户权限的访问。

在受 jail 的环境中，超级用户进程有权力：

• 使用 setuid , seteuid , setgid , setegid , setgroups , setreuid , setregid , setlogin 操纵凭据

• 使用 setrlimit 设置资源限制

• 修改一些 sysctl 节点（kern.hostname）

• chroot()

• 在一个 vnode 上设置标志： chflags ， fchflags

• 设置 vnode 的属性，如文件权限、所有者、组、大小、访问时间和修改时间。

• 绑定到互联网域中的特权ports（ports < 1024）

Jail 是一个非常有用的工具，可在安全环境中运行应用程序，但它确实有一些缺点。当前，IPC 机制尚未转换为 suser_xxx ，因此无法在jail中运行诸如 MySQL 之类的应用程序。超级用户访问可能在jail中意味非常有限，但无法精确指定"非常有限"具体意味着什么。

3.5.2. POSIX®.1e 进程功能

POSIX®发布了一个工作草案，其中添加了事件审计、访问控制列表、细粒度特权、信息标记和强制访问控制。

这是一个正在进行中的工作，是 TrustedBSD 项目的重点。一些最初的工作已经提交到 FreeBSD-CURRENT（cap_set_proc(3)）。

3.6. 信任

应用程序永远不应假设用户环境的任何内容是健全的。这包括（但绝对不限于）：用户输入、信号、环境变量、资源、IPC、内存映射、文件系统工作目录、文件描述符、打开文件的数量等。

您永远不应假设自己可以捕获用户可能提供的所有形式的无效输入。相反，您的应用程序应使用积极过滤，只允许您认为安全的特定输入子集。不正确的数据验证是许多漏洞的根源，特别是在全球网络上的 CGI 脚本中。对于文件名，您需要特别注意路径（"../"，"/"），符号链接和shell转义字符。

Perl 有一个非常酷的功能称为“Taint”模式，可用于防止脚本以不安全的方式使用程序外部获取的数据。此模式将检查命令行参数、环境变量、区域设置信息、某些系统调用的结果（ readdir() ， readlink() ， getpwxxx() ）以及所有文件输入。

3.7. 竞争条件

竞争条件是由事件的相对时序的意外依赖引起的异常行为。换句话说，程序员错误地假定一个特定事件总会在另一个事件之前发生。

竞争条件的一些常见原因是信号、访问检查和文件打开。信号本质上是异步事件，因此在处理它们时必须格外小心。用 access(2) 和 open(2) 检查访问明显不是原子操作。用户可以在两次调用之间移动文件。而是，特权应用程序应该首先 seteuid() ，然后直接调用 open() 。沿着同样的思路，应用程序在 open() 之前应该始终设置适当的 umask，以避免产生不必要的 chmod() 调用。

4.1. 编写符合 I18N 标准的应用程序

为了使您的应用程序对其他语言的使用者更有用，我们希望您编写符合 I18N 的代码。GNU gcc 编译器和诸如 QT 和 GTK 之类的 GUI 库通过对字符串的特殊处理来支持 I18N。使程序符合 I18N 非常容易。它允许贡献者快速地将您的应用程序翻译成其他语言。有关更多详细信息，请参考特定库的 I18N 文档。

与普遍看法相反，符合 I18N 的代码很容易编写。通常，只需要使用特定库函数包装您的字符串即可。此外，请确保支持宽字符或多字节字符。

4.1.1. 统一 I18N 工作的呼吁

我们注意到，每个国家的个别 I18N/L10N 工作一直在重复彼此的努力。我们许多人一再且低效地重复造轮子。我们希望 I18N 中的各个主要团体能够聚集到一个类似核心团队责任的团体努力中。

目前，我们希望当您编写或 port I18N 程序时，您可以将其发送到每个国家相关的 FreeBSD 邮件列表进行测试。未来，我们希望创建能够在所有语言中即插即用而无需肮脏的黑客技巧的应用程序。

已建立 FreeBSD 国际化邮件列表。如果您是 I18N/L10N 开发人员，请发送您的评论、想法、问题以及您认为与之相关的任何内容。

4.1.2. Perl 和 Python

Perl 和 Python 都具有 I18N 和宽字符处理库。请使用它们来实现 I18N 合规性。

4.2. 具有 POSIX.1 本地化消息和本地语言支持（NLS）

超越基本的 I18N 功能，比如支持各种输入编码或支持国家约定，比如不同的十进制分隔符，在更高级别的 I18N 中，可以将各种程序写入输出的消息本地化。 做到这一点的常见方法是使用 POSIX.1 NLS 功能，这些功能作为 FreeBSD 基本系统的一部分提供。

4.2.1. 将本地化消息组织成目录文件

POSIX.1 NLS 基于目录文件，其中包含所需编码的本地化消息。 消息被组织成集合，每条消息在所包含集合中都用整数编号标识。 目录文件通常以包含本地化消息的区域设置命名，后跟 .msg 扩展名。 例如，ISO8859-2 编码的匈牙利消息应存储在名为 hu_HU.ISO8859-2 的文件中。

这些目录文件是常见的文本文件，包含编号的消息。可以通过在行首使用 $ 符号来编写注释。集合边界也由特殊注释分隔，其中关键字 set 必须直接跟在 $ 符号后面。然后 set 关键字跟着集合编号。例如：

$set 1

实际消息条目以消息编号开头，后跟本地化消息。来自 printf(3)的著名修饰符会被接受：

15 "File not found: %s\n"

语言目录文件在能够从程序中打开之前必须被编译成二进制形式。这种转换通过 gencat(1)实用程序完成。它的第一个参数是编译后目录的文件名，后续参数是输入目录。本地化消息也可以组织成多个目录文件，然后所有这些文件都可以通过 gencat(1)处理。

4.2.2. 使用源代码中的目录文件

使用目录文件很简单。要使用相关函数，必须包含 nl_types.h。在使用目录之前，必须使用 catopen(3) 打开它。该函数接受两个参数。第一个参数是已安装和编译的目录的名称。通常使用程序的名称，例如 grep。在查找已编译的目录文件时将使用此名称。catopen(3) 调用在 /usr/share/nls/locale/catname 和 /usr/local/share/nls/locale/catname 中查找此文件，其中 locale 是区域设置， catname 是正在讨论的目录名称。第二个参数是一个常量，可以有两个值：

• NL_CAT_LOCALE ，这意味着所使用的目录文件将基于 LC_MESSAGES 。

• 0 ，这意味着必须使用 LANG 打开正确的目录。

catopen(3) 调用返回一个 nl_catd 类型的目录标识符。请参阅手册页以获取可能返回的错误代码列表。

打开目录后，catgets(3) 可用于检索消息。第一个参数是 catopen(3) 返回的目录标识符，第二个是集编号，第三个是消息编号，第四个是回退消息，如果无法从目录文件中检索到请求的消息，将返回该回退消息。

使用目录文件后，必须通过调用 catclose(3)来关闭它，catclose(3)有一个参数，即目录 id。

4.2.3. 一个实际示例

以下示例将演示如何以灵活的方式使用 NLS 目录的简单解决方案。

下面的行需要放入程序的公共头文件中，该头文件包含所有需要本地化消息的源文件中：

#ifdef WITHOUT_NLS
#define getstr(n)	 nlsstr[n]
#else
#include nl_types.h

extern nl_catd		 catalog;
#define getstr(n)	 catgets(catalog, 1, n, nlsstr[n])
#endif

extern char		*nlsstr[];

接下来，将这些行放入主源文件的全局声明部分：

#ifndef WITHOUT_NLS
#include nl_types.h
nl_catd	 catalog;
#endif

/*
 * Default messages to use when NLS is disabled or no catalog
 * is found.
 */
char    *nlsstr[] = {
        "",
/* 1*/  "some random message",
/* 2*/  "some other message"
};

接下来是真正的代码片段，打开，读取和关闭目录：

#ifndef WITHOUT_NLS
	catalog = catopen("myapp", NL_CAT_LOCALE);
#endif

...

printf(getstr(1));

...

#ifndef WITHOUT_NLS
	catclose(catalog);
#endif

将字符串减少至本地化

通过使用 libc 错误消息，可以很好地减少需要本地化的字符串。这对于避免重复并为可能遇到的许多程序的常见错误提供一致的错误消息也非常有用。

首先，这里有一个不使用 libc 错误消息的示例：

#include err.h
...
if (!S_ISDIR(st.st_mode))
	errx(1, "argument is not a directory");

这可以通过阅读 errno 并相应地打印错误消息来转换为打印错误消息：

#include err.h
#include errno.h
...
if (!S_ISDIR(st.st_mode)) {
	errno = ENOTDIR;
	err(1, NULL);
}

在这个例子中，自定义字符串被消除，因此在本地化程序时，翻译人员的工作量会减少，当用户遇到此错误时，他们将看到通常的"不是目录"错误消息。这个消息对他们来说可能更为熟悉。请注意，为了直接访问 errno ，有必要包含 errno.h。

值得注意的是，有些情况下， errno 是由前面的调用自动设置的，因此不需要显式设置它：

#include err.h
...
if ((p = malloc(size)) == NULL)
	err(1, NULL);

利用 bsd.nls.mk

使用目录文件需要一些重复的步骤，比如编译目录文件并将其安装到适当的位置。为了进一步简化这个过程，bsd.nls.mk 引入了一些宏。不需要显式包含 bsd.nls.mk，它是从通用的 Makefiles 中引入的，比如 bsd.prog.mk 或 bsd.lib.mk。

通常只需要定义 NLSNAME ，其中应该将作为 catopen(3) 第一个参数提到的目录名称列出，并在 NLS 中列出目录文件，但不包括它们的 .msg 扩展名。这里有一个示例，使得在之前的代码示例中与 NLS 一起使用时可以禁用 NLS。必须定义 WITHOUT_NLS make(1) 变量，以便在没有 NLS 支持的情况下构建程序。

.if !defined(WITHOUT_NLS)
NLS=	es_ES.ISO8859-1
NLS+=	hu_HU.ISO8859-2
NLS+=	pt_BR.ISO8859-1
.else
CFLAGS+=	-DWITHOUT_NLS
.endif

传统上，目录文件放置在 nls 子目录下，这是 bsd.nls.mk 的默认行为。但是，可以通过 NLSSRCDIR make(1)变量覆盖目录的位置。预编译目录文件的默认名称也遵循之前提到的命名约定。可以通过设置 NLSNAME 变量来覆盖它。还有其他选项可以微调目录文件的处理，但通常不需要，因此这里不进行描述。有关 bsd.nls.mk 的更多信息，请参考文件本身，它简短易懂。

作为一个内核开发者，需要理解内核构建过程。要调试 FreeBSD 内核，需要能够构建一个内核。有两种已知的方法可以实现这一点：

构建和安装内核的支持过程在 FreeBSD 手册的“构建和安装自定义内核”章节中有详细记录。

9.1. 构建更快但更易出错的方式

用这种方式构建内核在处理内核代码时可能很有用，而且在仅在内核配置文件中调整了一个或两个选项时，实际上可能比文档中的过程更快。另一方面，这可能导致意外的内核构建中断。

1. 运行 config(8) 以生成内核源代码：

   复制

   # /usr/sbin/config MYKERNEL

2. 进入构建目录。在如上运行后，config(8) 将打印该目录的名称。

   复制

   # cd ../compile/MYKERNEL

3. 编译内核：

   复制

   # make depend
   # make

4. 安装新内核：

   复制

   # make install

[1] Dave A Patterson and John L Hennessy. Copyright® 1998 Morgan Kaufmann Publishers, Inc. 1-55860-428-6. Morgan Kaufmann Publishers, Inc. Computer Organization and Design. The Hardware / Software Interface. 1-2.

[2] W. Richard Stevens. Copyright® 1993 Addison Wesley Longman, Inc. 0-201-56317-7. Addison Wesley Longman, Inc. Advanced Programming in the Unix Environment. 1-2.

[3] Marshall Kirk McKusick and George Neville-Neil. Copyright® 2004 Addison-Wesley. 0-201-70245-2. Addison-Wesley. The Design and Implementation of the FreeBSD Operating System. 1-2.

[4] Aleph One. Phrack 49; "Smashing the Stack for Fun and Profit".

[5] Chrispin Cowan, Calton Pu, and Dave Maier. StackGuard; Automatic Adaptive Detection and Prevention of Buffer-Overflow Attacks.

[6] Todd Miller and Theo de Raadt. strlcpy and strlcat — consistent, safe string copy and concatenation.

回归测试用于测试系统的特定部分，以确保其按预期工作，并确保旧漏洞不会再次引入。

FreeBSD 回归测试工具可以在 FreeBSD 源码树中的目录 src/tools/regression 找到。

6.1. 微基准测试清单

本节包含在 FreeBSD 或 FreeBSD 本身上进行正确微基准测试的提示。

使用所有建议并非每次都可能实现，但使用越多，则基准测试测试小差异的能力就越好。

• 禁用 APM 和任何其他形式的时钟操作（ACPI？）。

• 在单用户模式下运行。例如，cron(8)和其他守护程序只会增加噪音。sshd(8)守护程序也可能会引起问题。如果在测试期间需要 ssh 访问，则要么禁用 SSHv1 密钥重新生成，要么在测试期间终止父 sshd 守护程序。

• 不要运行 ntpd(8)。

• 如果生成 syslog(3)事件，请使用空的/etc/syslogd.conf 运行 syslogd(8)，否则不要运行它。

• 最小化磁盘 I/O，尽量避免。

• 不要挂载不需要的文件系统。

• 如果可能的话，将 /、/usr 和任何其他文件系统挂载为只读。这样可以从 I/O 操作中移除对磁盘的访问时间更新等影响。

• 在每次运行之前使用 newfs(8) 重新初始化读写测试文件系统，并从 tar(1) 或 dump(8) 文件填充它。开始测试前卸载并挂载它。这将产生一致的文件系统布局。对于 worldstone 测试，这将适用于 /usr/obj（只需使用 newfs 重新初始化并挂载）。为了获得 100% 的重现性，可以从 dd(1) 文件填充文件系统（即： dd if=myimage of=/dev/ad0s1h bs=1m ）。

• 使用 malloc 支持或预加载 md(4)分区。

• 在测试的各个迭代之间重新启动，这会提供更一致的状态。

• 从内核中删除所有非必要的设备驱动程序。例如，如果测试不需要 USB，请勿将 USB 放入内核。经常挂接的驱动程序会有计时器正在计时。

• 卸载未使用的硬件。如果磁盘没有用于测试，请使用 atacontrol(8)和 camcontrol(8)卸载磁盘。

• 除非正在测试网络，否则不要配置网络，或者在测试完成后将结果发送到另一台计算机。

• 禁用“涡轮增压模式”，因为它们使时钟频率明确依赖于环境。这意味着在完全相同的代码上运行基准测试可能取决于一天中的时间、咖啡与苏打水的对比，甚至办公室里有多少其他人。

• 一个很好的模式是： bababa{bbbaaa}* 。这在第 1+1 次运行后给出提示（这样如果测试完全走错了，就可以停止测试），在前 3+3 次运行后给出标准偏差（给出一个很好的指示，是否值得长时间运行），以及稍后的趋势和交互数。* 使用 ministat(1) 看看这些数字是否显著。如果你忘记了或从未学习过标准偏差和学生 T 检验，考虑购买《统计学漫画指南》ISBN: 0062731025，强烈推荐。* 除非测试是后台 fsck 的基准测试，否则不要使用后台 fsck(8)。同样，在启动后至少 60+ fsck 运行时间秒后，在 /etc/rc.conf 中禁用 background_fsck ，因为 rc(8) 会唤醒并检查是否需要在启用后台 fsck 时在任何文件系统上运行 fsck 。同样，确保没有闲置的快照，除非基准测试是带有快照的测试。* 如果基准测试显示意外的糟糕性能，请检查诸如来自意想不到的来源的高中断量之类的问题。有报道称某些版本的 ACPI 会“表现不端”并生成过多的中断。为帮助诊断奇怪的测试结果，拍摄一些 vmstat -i 的快照并寻找任何异常情况。* 一定要小心内核和用户空间的优化参数，以及调试。很容易让一些东西溜走，后来才意识到测试并非在比较相同的事物。* 除非测试感兴趣对这些功能进行基准测试，否则绝不能启用 WITNESS 和 INVARIANTS 内核选项进行基准测试。 WITNESS 可导致性能下降 400%+。同样，在 -CURRENT 中，默认的用户空间 malloc(3) 参数与它们在生产版本中的提供方式不同。

6.2. FreeBSD 源代码搭配盒

源代码搭配盒包括:

• 一个构建脚本，燃点盒子（tinderbox），用于自动检出特定版本的 FreeBSD 源代码树并构建它。

• 一个监督脚本，tbmaster，用于监视各个 Tinderbox 实例，记录它们的输出，并发送失败通知邮件。

• 一个名为 index.cgi 的 CGI 脚本，读取一组 tbmaster 日志，并呈现这些日志的易读 HTML 摘要。

• 一组构建服务器，不断测试最重要的 FreeBSD 代码分支的最新版本。

• 一个 Web 服务器，保留完整的 Tinderbox 日志并显示最新摘要。

对于在这个阶段有关火柴盒和 tbmaster 脚本更多信息，请参阅它们各自的手册页：tinderbox(1)和 tbmaster(1)。

6.3. 索引.cgi 脚本

index.cgi 脚本生成火柴盒和 tbmaster 日志的 HTML 摘要。尽管最初设计用作 CGI 脚本，如其名称所示，但该脚本也可以从命令行或 cron(8)作业中运行，在这种情况下，它将查找位于脚本所在目录的日志。当作为 CGI 脚本运行时，它将自动检测上下文，生成 HTTP 头。它符合 XHTML 标准，并使用 CSS 进行样式设置。

脚本在 main() 块开始运行，通过尝试验证它是否正在官方 Tinderbox 网站上运行。如果不是，则生成一个页面，指示这不是官方网站，并提供官方网站的网址。

接下来，它扫描日志目录以获取配置、分支和体系结构的清单，以避免在脚本中硬编码列表，并可能导致空白行或列。这些信息是从日志文件的名称匹配以下模式中获得的：

tinderbox-$config-$branch-$arch-$machine.{brief,full}

在官方 Tinderbox 构建服务器上使用的配置是根据它们构建的分支命名的。例如， releng_8 配置用于构建 RELENG_8 以及所有仍受支持的发布分支。

一旦所有这些启动程序都成功完成，每个配置都调用 do_config() 。

do_config() 函数为单个 Tinderbox 配置生成 HTML。

它首先生成一个标题行，然后迭代使用指定配置构建的每个分支构建，以以下方式为每个生成一个结果行：

• 对于每个项目：

  • 对于该体系结构中的每台机器：

    • 如果存在简要日志文件，则：

      • 调用 success() 以确定构建的结果。

      • 输出修改的大小。

      • 输出简要日志文件的大小，并附上日志文件的链接。

      • 如果存在完整的日志文件，则：

        • 输出完整日志文件的大小，并附带日志文件的链接。

    • 否则：

      • 没有输出。

上述 success() 函数扫描一个简短的日志文件，以查找字符串“tinderbox run completed”，以确定构建是否成功。

配置和分支根据它们的分支等级进行排序。计算方法如下：

• HEAD 和 CURRENT 的等级为 9999。

• RELENG_x 的等级为 xx 99。

• RELENG_x_y 的等级为 xxyy。

这意味着 HEAD 始终排名最高，而 RELENG 分支按数字顺序排名，每个 STABLE 分支排名都高于从中分叉出的发行分支。例如，对于 FreeBSD 8，由高到低的顺序将是：

• RELENG_8 （分支等级 899）。

• RELENG_8_3 （分支等级 803）。

• RELENG_8_2 （分支等级 802）。

• RELENG_8_1 （分支等级 801）。

• RELENG_8_0 （分支等级 800）。

Tinderbox 在表格中每个单元格使用的颜色由 CSS 定义。成功构建显示为绿色文本；不成功的构建显示为红色文本。随着时间的推移，颜色会逐渐变为灰色，每半小时颜色会更接近灰色。

6.4. 官方构建服务器

官方 Tinderbox 构建服务器由 Sentex Data Communications 托管，他们也托管 FreeBSD Netperf 集群。

目前存在三台构建服务器：

freebsd-current.sentex.ca 构建：

• HEAD 适用于 amd64、arm、i386、i386/pc98、ia64、mips、powerpc、powerpc64 和 sparc64。

• RELENG_9 和支持的 9.X 分支，适用于 amd64、arm、i386、i386/pc98、ia64、mips、powerpc、powerpc64 和 sparc64。

freebsd-stable.sentex.ca 构建：

• RELENG_8 和支持的 8.X 分支，适用于 amd64、i386、i386/pc98、ia64、mips、powerpc 和 sparc64。

免费加拿大（sentex.ca）的构建:

• RELENG_7 和支持的 7.X 分支，适用于 amd64、i386、i386/pc98、ia64、powerpc 和 sparc64。

6.5。官方摘要站点

定制官方构建服务器的摘要和日志可在线查看，网址为 http://tinderbox.FreeBSD.org，由 Dag-Erling Smørgrav < des@FreeBSD.org> 托管并设置如下：

• 一个 cron(8) 作业定期检查构建服务器，并使用 rsync(1) 下载任何新的日志文件。

• Apache 被设置为使用 index.cgi 作为 DirectoryIndex 。

7.1. 概要

BSD sockets 将进程间通信提升到一个新水平。通信进程不再需要在同一台机器上运行。它们仍然可以，但不一定要这样。

这些进程不仅无需在同一台机器上运行，它们也无需在同一操作系统下运行。多亏了 BSD sockets，您的 FreeBSD 软件可以与运行在 Macintosh®上的程序，运行在 Sun™工作站上的另一个程序，以及在 Windows® 2000 下运行的另一个程序平滑合作，它们都连接在基于以太网的局域网上。

但您的软件同样可以与在另一个建筑物内运行的进程合作，或者在另一个大陆上，潜艇内，或航天飞机内运行的进程合作。

它还可以与不属于计算机（至少不是严格意义上的计算机）的进程合作，例如打印机、数码相机、医疗设备等设备。几乎任何具有数字通信能力的设备。

7.2. 网络与多样性

我们已经暗示了网络的多样性。许多不同的系统必须相互通信。而且它们必须说同一种语言。它们还必须以相同的方式理解这种语言。

人们常常认为肢体语言是普遍适用的。但事实并非如此。在我十几岁的时候，我父亲带我去了保加利亚。当时我们坐在索非亚的一个公园的桌子旁，一个小贩走过来想要卖给我们一些炒杏仁。

那时候我还没学到太多保加利亚语，所以，我没有说不，而是摇了摇头，这在全世界都被认为是“不”的肢体语言。小贩很快开始给我们端来了一些杏仁。

后来我想起在保加利亚，摇头意味着说“是”。我马上开始点头。小贩注意到了，拿走了他的杏仁，然后走开了。对于一个不了解情况的观察者来说，我的肢体语言并没有改变：我继续使用摇头和点头的语言。改变的是肢体语言的含义。起初，小贩和我解释同样的语言，却具有完全不同的意义。我必须调整我对那种语言的理解，以便让小贩理解。

与计算机相同：相同的符号可能具有不同，甚至完全相反的含义。因此，为了让两台计算机彼此理解，它们不仅必须就相同的语言达成一致，还必须就语言的相同解释达成一致。

7.3. 协议

虽然各种编程语言往往具有复杂的语法并使用许多多字母保留字（这使得它们易于人类程序员理解），但数据通信的语言往往非常简洁。它们通常不使用多字节字，而是经常使用单个位。这样做有一个非常令人信服的理由：当数据在计算机内部以接近光速的速度传输时，它在两台计算机之间传输时往往要慢得多。

由于数据通信中使用的语言非常简洁，我们通常将其称为协议而不是语言。

当数据从一台计算机传输到另一台计算机时，它总是使用多个协议。这些协议是分层的。数据可以被比作洋葱的内部：你必须剥离几层“外皮”才能获得数据。这最好是用图片来说明：

图 1. 协议层

在这个例子中，我们正在尝试从通过以太网连接的网页中获取图像。

图像由原始数据组成，这只是我们的软件可以处理的一系列 RGB 值，即将其转换为图像并显示在我们的显示器上。

可惜，我们的软件无法知道原始数据是如何组织的：它是一系列 RGB 值，还是一系列灰度强度，或者是 CMYK 编码的颜色？数据是否由 8 位量表示，或者它们的大小为 16 位，或者也许是 4 位？图像由多少行和列组成？某些像素应该是透明的吗？

我觉得你明白了吧…

为了告诉我们的软件如何处理原始数据，它被编码为 PNG 文件。它可以是 GIF，也可以是 JPEG，但它是 PNG。

PNG 是一种协议。

在这一点上，我能听到你们中的一些人在喊叫，“不，它不是！它是一种文件格式！”

当然，它当然是一种文件格式。但从数据通信的角度来看，文件格式就是一种协议：文件结构是一种语言，一种简洁的语言，向我们的进程传达数据的组织方式。因此，它就是一种协议。

遗憾的是，如果我们收到的只是 PNG 文件，我们的软件将面临一个严重的问题：它应该如何知道数据代表的是图像，而不是一些文本，或者可能是声音，或其他什么？其次，它应该如何知道图像是 PNG 格式，而不是 GIF，JPEG 或其他某种图像格式？

为了获取这些信息，我们正在使用另一种协议：HTTP。该协议可以准确告诉我们数据代表一幅镜像，并且使用 PNG 协议。它还可以告诉我们一些其他的东西，但让我们在这里专注于协议层面。

所以，现在我们有一些数据包裹在 PNG 协议中，再包裹在 HTTP 协议中。我们如何从服务器获取它呢？

通过 TCP/IP 在以太网上，就是这样。确实，这是另外三个协议。而不是继续从内到外讲述，我现在要谈论以太网，因为这样更容易解释其余部分。

以太网是一种连接局域网（LAN）中计算机的有趣系统。每台计算机都有一个网络接口卡（NIC），其中包含一个称为地址的独特的 48 位 ID。世界上没有两个以太网 NIC 具有相同的地址。

这些 NIC 都彼此连接在一起。每当一台计算机想要与同一以太网 LAN 中的另一台计算机通信时，它会通过网络发送一条消息。每个 NIC 都会看到这条消息。但作为以太网协议的一部分，数据包含目标 NIC 的地址（以及其他内容）。因此，所有网络接口卡中只有一个会注意到它，其余的会忽略它。

但并非所有计算机都连接到同一网络。仅仅因为我们通过以太网接收到数据并不意味着它起源于我们自己的局域网。它可能来自我们的网络通过互联网连接的其他网络（甚至可能不是基于以太网的网络）。

所有数据都是使用 IP（即互联网协议）在互联网上传输的。它的基本作用是让我们知道数据是从世界上的哪里到达的，以及它应该去哪里。它不能保证我们会接收到数据，只能告诉我们如果接收到数据的话它是从哪里来的。

即使我们接收到数据，IP 也不能保证我们会按照其他计算机发送给我们的顺序接收到不同的数据块。因此，我们可以在接收到图像的左上角之前接收到图像的中心，在接收到图像的右下角之后接收到它，例如。

是 TCP（即传输控制协议）要求发送方重新发送任何丢失的数据，并将其全部按正确的顺序放置。

总而言之，一个计算机向另一个计算机传输图像的过程需要五种不同的协议。我们接收到的数据被包装成 PNG 协议，然后被包装成 HTTP 协议，再被包装成 TCP 协议，接着是 IP 协议，最后是以太网协议。

哦，顺便提一下，可能还涉及到其他几种协议。例如，如果我们的局域网通过拨号连接到互联网，那么会使用调制解调器上的 PPP 协议，该调制解调器又使用各种调制解调器协议，等等，等等，等等……

作为开发者，你现在可能会问，“我应该如何处理这一切？”

幸运的是，您不必处理所有这些。 您只需要处理其中的一部分，而不是全部。 具体来说，您无需担心物理连接（在我们的情况下是以太网和可能的 PPP 等）。 您也无需处理 Internet 协议或传输控制协议。

换句话说，您无需做任何事情来接收来自其他计算机的数据。 好吧，您确实需要请求数据，但这几乎和打开文件一样简单。

一旦您收到数据，就由您决定如何处理它。 在我们的情况下，您需要了解 HTTP 协议和 PNG 文件结构。

使用类比，所有的互联网协议都变成了一个灰色地带：并不是因为我们不理解它是如何工作的，而是因为我们不再关心它。套接字接口为我们处理了这个灰色地带：

图 2. 套接字覆盖的协议层

我们只需要理解告诉我们如何解释数据的任何协议，而不需要了解如何从另一个进程接收数据，也不需要了解如何将数据发送到另一个进程。

7.4. BSD 套接字模型

BSD 套接字建立在基本的 UNIX® 模型之上：一切皆为文件。在我们的例子中，套接字允许我们接收一个类似 HTTP 文件的内容。然后我们需要从中提取 PNG 文件。

由于互联网工作的复杂性，我们不能仅仅使用 open 系统调用，或者 open() C 函数。相反，我们需要采取几个步骤来“打开”一个套接字。

Once we do, however, we can start treating the socket the same way we treat any file descriptor: We can read from it, write to it, pipe it, and, eventually, close it.

7.5. Essential Socket Functions

While FreeBSD offers different functions to work with sockets, we only need four to "open" a socket. And in some cases we only need two.

7.5.1. 客户端-服务器的区别

通常，基于套接字的数据通信的一端是服务器，另一端是客户端。

7.5.1.1. 共同元素

7.5.1.1.1. socket

客户端和服务器都使用的一个函数是 socket(2)。它是这样声明的：

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

返回值的类型与 open 相同，都是整数。FreeBSD 从与文件句柄相同的池中分配其值。这使得套接字可以像文件一样对待。

domain 参数告诉系统您希望使用哪种协议族。它们中有很多，有些是特定供应商的，其他则非常常见。它们在 sys/socket.h 中声明。

使用 PF_INET 用于 UDP、TCP 和其他互联网协议（IPv4）。

为 type 参数定义了五个值，在 sys/socket.h 中再次定义。所有这些值都以“SOCK_”开头。最常见的是 SOCK_STREAM ，它告诉系统您正在请求可靠的流传递服务（与 PF_INET 一起使用时为 TCP）。

如果您请求 SOCK_DGRAM ，您将请求无连接的数据报传递服务（在我们的情况下为 UDP）。

如果您想要负责低层协议（如 IP），甚至是网络接口（例如以太网），您需要指定 SOCK_RAW 。

最后， protocol 参数取决于前两个参数，并非始终有意义。在这种情况下，请使用 0 作为其值。

7.5.1.1.2. sockaddr

sockets 系列的各种函数期望内存中的一个小区域的地址（或指针，用 C 术语来说）。sys/socket.h 中的各种 C 声明将其称为 struct sockaddr 。这个结构在同一个文件中声明：

/*
 * Structure used by kernel to store most
 * addresses.
 */
struct sockaddr {
	unsigned char	sa_len;		/* total length */
	sa_family_t	sa_family;	/* address family */
	char		sa_data[14];	/* actually longer; address value */
};
#define	SOCK_MAXADDRLEN	255		/* longest possible addresses */

请注意 sa_data 字段声明的模糊性，就像一个 14 字节的数组一样，注释暗示可能不止 14 个。

这种模糊性是有意的。套接字是一个非常强大的接口。尽管大多数人可能认为它只是互联网接口而已 - 现在大多数应用程序可能仅用于此目的 - 套接字可以用于几乎任何类型的进程间通信，其中互联网（或更准确地说是 IP）只是其中之一。

sys/socket.h 是指套接字将处理的各种协议类型作为地址族，并在 sockaddr 的定义之前列出它们。

/*
 * Address families.
 */
#define	AF_UNSPEC	0		/* unspecified */
#define	AF_LOCAL	1		/* local to host (pipes, portals) */
#define	AF_UNIX		AF_LOCAL	/* backward compatibility */
#define	AF_INET		2		/* internetwork: UDP, TCP, etc. */
#define	AF_IMPLINK	3		/* arpanet imp addresses */
#define	AF_PUP		4		/* pup protocols: e.g. BSP */
#define	AF_CHAOS	5		/* mit CHAOS protocols */
#define	AF_NS		6		/* XEROX NS protocols */
#define	AF_ISO		7		/* ISO protocols */
#define	AF_OSI		AF_ISO
#define	AF_ECMA		8		/* European computer manufacturers */
#define	AF_DATAKIT	9		/* datakit protocols */
#define	AF_CCITT	10		/* CCITT protocols, X.25 etc */
#define	AF_SNA		11		/* IBM SNA */
#define AF_DECnet	12		/* DECnet */
#define AF_DLI		13		/* DEC Direct data link interface */
#define AF_LAT		14		/* LAT */
#define	AF_HYLINK	15		/* NSC Hyperchannel */
#define	AF_APPLETALK	16		/* Apple Talk */
#define	AF_ROUTE	17		/* Internal Routing Protocol */
#define	AF_LINK		18		/* Link layer interface */
#define	pseudo_AF_XTP	19		/* eXpress Transfer Protocol (no AF) */
#define	AF_COIP		20		/* connection-oriented IP, aka ST II */
#define	AF_CNT		21		/* Computer Network Technology */
#define pseudo_AF_RTIP	22		/* Help Identify RTIP packets */
#define	AF_IPX		23		/* Novell Internet Protocol */
#define	AF_SIP		24		/* Simple Internet Protocol */
#define	pseudo_AF_PIP	25		/* Help Identify PIP packets */
#define	AF_ISDN		26		/* Integrated Services Digital Network*/
#define	AF_E164		AF_ISDN		/* CCITT E.164 recommendation */
#define	pseudo_AF_KEY	27		/* Internal key-management function */
#define	AF_INET6	28		/* IPv6 */
#define	AF_NATM		29		/* native ATM access */
#define	AF_ATM		30		/* ATM */
#define pseudo_AF_HDRCMPLT 31		/* Used by BPF to not rewrite headers
					 * in interface output routine
					 */
#define	AF_NETGRAPH	32		/* Netgraph sockets */
#define	AF_SLOW		33		/* 802.3ad slow protocol */
#define	AF_SCLUSTER	34		/* Sitara cluster protocol */
#define	AF_ARP		35
#define	AF_BLUETOOTH	36		/* Bluetooth sockets */
#define	AF_MAX		37

用于 IP 的一个是 AF_INET。 它是常量 2 的符号。

它是 sockaddr 的 sa_family 字段中列出的地址族，决定了如何使用 sa_data 这些名义模糊的字节。

具体来说，每当地址族是 AF_INET 时，我们可以使用 netinet/in.h 中找到的 struct sockaddr_in ，无论 sockaddr 期望什么：

/*
 * Socket address, internet style.
 */
struct sockaddr_in {
	uint8_t		sin_len;
	sa_family_t	sin_family;
	in_port_t	sin_port;
	struct	in_addr sin_addr;
	char	sin_zero[8];
};

我们可以这样来可视化它的组织结构：

图 3. sockaddr_in 结构

三个重要字段分别是 sin_family ，即结构的第一个字节， sin_port ，一个在第 2 和第 3 字节中找到的 16 位值，以及 sin_addr ，一个 32 位整数表示的 IP 地址，存储在第 4-7 字节中。

现在，让我们试着填写它。假设我们正在尝试为白天协议编写客户端，该协议简单地表示其服务器将向 port 13 写入表示当前日期和时间的文本字符串。我们想使用 TCP/IP，因此需要在地址族字段中指定 AF_INET 。 AF_INET 被定义为 2 。让我们使用 192.43.244.18 的 IP 地址，这是美国联邦政府的时间服务器（ time.nist.gov ）。

sockaddr_in 的特定示例图 4。

顺便说一下， sin_addr 字段被声明为 struct in_addr 类型，在 netinet/in.h 中定义：

/*
 * Internet address (a structure for historical reasons)
 */
struct in_addr {
	in_addr_t s_addr;
};

除此之外， in_addr_t 是一个 32 位整数。

192.43.244.18 仅仅是一个便利的表示法，以列举所有 8 位字节，从最高有效位开始，来表达 32 位整数。

到目前为止，我们把 sockaddr 看作一个抽象概念。 我们的计算机不把 short 整数作为一个单独的 16 位实体来存储，而是作为 2 个字节的序列。类似地，它将 32 位整数存储为 4 个字节的序列。

假设我们编写了这样的代码：

sa.sin_family      = AF_INET;
sa.sin_port        = 13;
sa.sin_addr.s_addr = (((((192 << 8) | 43) << 8) | 244) << 8) | 18;

结果会是什么样子呢？

当然，这取决于情况。在基于 Pentium®或其他 x86 的计算机上，它会是这样的：

Intel 系统上的 sockaddr_in 图 5。

在另一个系统上，它可能看起来像这样：

MSB 系统上的 sockaddr_in 图 6。

在 PDP 上可能会看起来有所不同。但以上两种是今天最常见的使用方式。

通常，希望编写可移植代码的程序员会假装这些差异不存在。他们可以逃脱（除非他们用汇编语言编码）。然而，当编写套接字时，你不能那么轻易地逃脱。

为什么？

因为在与另一台计算机通信时，通常不知道它是先存储数据的最高有效字节（MSB）还是最低有效字节（LSB）。

也许你在想，“所以，套接字不会帮我处理吗？”

不会。

While that answer may surprise you at first, remember that the general sockets interface only understands the sa_len and sa_family fields of the sockaddr structure. You do not have to worry about the byte order there (of course, on FreeBSD sa_family is only 1 byte anyway, but many other UNIX® systems do not have sa_len and use 2 bytes for sa_family, and expect the data in whatever order is native to the computer).

But the rest of the data is just sa_data[14] as far as sockets goes. Depending on the address family, sockets just forwards that data to its destination.

Indeed, when we enter a port number, it is because we want the other computer to know what service we are asking for. And, when we are the server, we read the port number so we know what service the other computer is expecting from us. Either way, sockets only has to forward the port number as data. It does not interpret it in any way.

同样，我们输入 IP 地址告诉路上的每个人数据应该发送到哪里。套接字只是将其作为数据转发。

这就是为什么我们（程序员，而不是套接字）必须区分我们计算机使用的字节顺序和发送数据给其他计算机的传统字节顺序之间的差异。

我们将我们计算机使用的字节顺序称为主机字节顺序，或者只是主机顺序。

在 IP 上发送多字节数据的惯例是先发送最高有效字节。我们将其称为网络字节顺序，或简称网络顺序。

现在，如果我们为基于英特尔的计算机编译上述代码，我们的主机字节顺序将产生：

图 7. 英特尔系统上的主机字节顺序

但网络字节顺序要求我们先将数据存储为 MSB：

图 8. 网络字节顺序

不幸的是，我们的主机顺序恰好与网络顺序相反。

我们有几种处理它的方法。一种方法是在我们的代码中反转值：

sa.sin_family      = AF_INET;
sa.sin_port        = 13 << 8;
sa.sin_addr.s_addr = (((((18 << 8) | 244) << 8) | 43) << 8) | 192;

这将欺骗我们的编译器将数据存储为网络字节顺序。在某些情况下，这确实是解决问题的方法（例如，在汇编语言中编程时）。然而，在大多数情况下，这可能会导致问题。

假设你用 C 编写了一个基于套接字的程序。你知道它将在 Pentium® 上运行，所以你把所有常量反向输入，并强制它们符合网络字节顺序。这运行良好。

然后，有一天，您信任的旧奔腾®变成了生锈的旧奔腾®。您用一个主机顺序与网络顺序相同的系统来替换它。您需要重新编译所有的软件。除了您写的那个程序之外，所有软件继续表现良好。

自那以后，您已经忘记了您曾经强制所有常量为相反的主机顺序。您花费一些质量时间拔掉您的头发，叫出您听说过的所有神明的名字（和一些您编造的），用软皮球棒击打您的监视器，并执行尝试弄清为什么一切运作良好的事情突然完全不起作用的所有其他传统仪式。

最终，您弄清楚了，说了几句脏话，然后开始重新编写代码。

幸运的是，你不是第一个面对这个问题的人。其他人已经创建了 htons(3)和 htonl(3) C 函数，用于将主机字节顺序转换为网络字节顺序中的 short 和 long ，以及用于另一种方式的 ntohs(3)和 ntohl(3) C 函数。

在 MSB 优先系统上，这些函数不起作用。在 LSB 优先系统上，它们会将值转换为正确的顺序。

因此，无论你的软件在哪种系统上编译，如果你使用这些函数，你的数据都将按正确的顺序排列。

7.5.1.2. 客户端功能

通常情况下，客户端会发起与服务器的连接。客户端知道它要调用哪个服务器：它知道服务器的 IP 地址，并且知道服务器所在的 port。这类似于你拿起电话拨打号码（地址），然后在有人接听后，询问负责 wingdings 的人（port）。

7.5.1.2.1. connect

一旦客户端创建了一个套接字，它需要将其连接到远程系统上的特定 port。它使用 connect(2)：

int connect(int s, const struct sockaddr *name, socklen_t namelen);

s 参数是套接字，即 socket 函数返回的值。 name 是指向我们广泛讨论过的 sockaddr 结构的指针。最后， namelen 通知系统我们的 sockaddr 结构中有多少字节。

如果 connect 成功，则返回 0 。否则返回 -1 并将错误代码存储在 errno 中。

有许多原因可能导致 connect 失败。例如，尝试连接到互联网时，IP 地址可能不存在，或者它可能已关闭，或者忙得不可开交，或者在指定的 port 处没有服务器在监听。或者它可能直接拒绝对特定代码的任何请求。

7.5.1.2.2. 我们的第一个客户

现在我们已经了解足够的信息，可以编写一个非常简单的客户端，该客户端将从 192.43.244.18 获取当前时间并将其打印到标准输出。

/*
 * daytime.c
 *
 * Programmed by G. Adam Stanislav
 */
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
  register int s;
  register int bytes;
  struct sockaddr_in sa;
  char buffer[BUFSIZ+1];

  if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
    perror("socket");
    return 1;
  }

  bzero(&sa, sizeof sa);

  sa.sin_family = AF_INET;
  sa.sin_port = htons(13);
  sa.sin_addr.s_addr = htonl((((((192 << 8) | 43) << 8) | 244) << 8) | 18);
  if (connect(s, (struct sockaddr *)&sa, sizeof sa) < 0) {
    perror("connect");
    close(s);
    return 2;
  }

  while ((bytes = read(s, buffer, BUFSIZ)) > 0)
    write(1, buffer, bytes);

  close(s);
  return 0;
}

继续，在您的编辑器中输入它，保存为 daytime.c，然后编译并运行它：

% cc -O3 -o daytime daytime.c
% ./daytime

52079 01-06-19 02:29:25 50 0 1 543.9 UTC(NIST) *
%

在这种情况下，日期是 2001 年 6 月 19 日，时间是 02:29:25 UTC。当然，您的结果会有所不同。

7.5.1.3. 服务器功能

典型的服务器不会发起连接。相反，它等待客户端调用并请求服务。它不知道客户端何时会调用，也不知道会有多少客户端会调用。它可能会静静地坐在那里等待，一会儿的功夫，下一刻可能会发现自己被来自多个客户端的请求淹没，所有客户端都在同一时间内呼叫。

套接字接口提供了三个基本函数来处理这个。

7.5.1.3.1. bind

Ports 就像是电话线的分机：拨打号码后，您可以拨分机号码来联系特定的人员或部门。

IP ports 有 65535 个，但服务器通常只处理其中一个进来的请求。这就像告诉电话室操作员我们已经上班，并且可以在特定的分机上接听电话。我们使用 bind(2)告诉套接字我们要服务的port。

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

除了在 addr 中指定port外，服务器可能还包括其 IP 地址。但是，它可以只使用象征常数 INADDR_ANY 来指示它将为指定的port处理所有请求，而不管其 IP 地址是什么。这个符号以及其他几个类似的符号在 netinet/in.h 中声明。

#define	INADDR_ANY		(u_int32_t)0x00000000

假设我们正在为 TCP/IP 上的白天协议编写服务器。回想一下，它使用端口port 13。我们的 sockaddr_in 结构将如下所示：

图 9. 示例服务器 sockaddr_in

7.5.1.3.2. listen

继续我们办公电话类比，告诉电话总机您将在哪个分机后，您现在走进办公室，确保自己的电话已插好线并且铃声已打开。此外，确保您已激活呼叫等待功能，这样您在与某人通话时也能听到电话响铃。

服务器通过 listen(2) 函数确保所有这些。

int listen(int s, int backlog);

在这里， backlog 变量告诉套接字在您忙于处理上一个请求时要接受多少传入请求。换句话说，它确定了挂起连接队列的最大大小。

7.5.1.3.3. accept

在你听到电话响的声音之后，通过接听电话来接受通话。您现在已与您的客户建立了连接。此连接保持活动状态，直到您或您的客户挂断电话。

服务器使用 accept(2)函数接受连接。

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

请注意，此时 addrlen 是一个指针。这是必要的，因为在这种情况下，是套接字填充 addr ， sockaddr_in 结构。

返回值是一个整数。实际上， accept 返回一个新的套接字。您将使用这个新套接字与客户端通信。

旧套接字会发生什么？它会继续监听更多请求（记住我们传递给 listen 的 backlog 变量吗？）直到我们 close 它。

现在，新套接字仅用于通信。它已完全连接。我们不能再次将其传递给 listen ，尝试接受其他连接。

7.5.1.3.4. 我们的第一个服务器

我们的第一个服务器将比我们的第一个客户端复杂一些：我们不仅有更多的套接字函数可用，而且需要将其编写为守护进程。

最好的方法是在绑定port后创建一个子进程。然后主进程退出并将控制权返回给调用它的shell（或任何其他调用它的程序）。

该子项调用 listen ，然后启动一个无限循环，该循环接受连接、为其提供服务，最终关闭套接字。

/*
 * daytimed - a port 13 server
 *
 * Programmed by G. Adam Stanislav
 * June 19, 2001
 */
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define BACKLOG 4

int main() {
    register int s, c;
    int b;
    struct sockaddr_in sa;
    time_t t;
    struct tm *tm;
    FILE *client;

    if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket");
        return 1;
    }

    bzero(&sa, sizeof sa);

    sa.sin_family = AF_INET;
    sa.sin_port   = htons(13);

    if (INADDR_ANY)
        sa.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(s, (struct sockaddr *)&sa, sizeof sa) < 0) {
        perror("bind");
        return 2;
    }

    switch (fork()) {
        case -1:
            perror("fork");
            return 3;
            break;
        default:
            close(s);
            return 0;
            break;
        case 0:
            break;
    }

    listen(s, BACKLOG);

    for (;;) {
        b = sizeof sa;

        if ((c = accept(s, (struct sockaddr *)&sa, &b)) < 0) {
            perror("daytimed accept");
            return 4;
        }

        if ((client = fdopen(c, "w")) == NULL) {
            perror("daytimed fdopen");
            return 5;
        }

        if ((t = time(NULL)) < 0) {
            perror("daytimed time");

            return 6;
        }

        tm = gmtime(&t);
        fprintf(client, "%.4i-%.2i-%.2iT%.2i:%.2i:%.2iZ\n",
            tm->tm_year + 1900,
            tm->tm_mon + 1,
            tm->tm_mday,
            tm->tm_hour,
            tm->tm_min,
            tm->tm_sec);

        fclose(client);
    }
}

我们首先创建一个套接字。然后在 sa 中填写 sockaddr_in 结构。注意对 INADDR_ANY 的条件性使用：

if (INADDR_ANY)
        sa.sin_addr.s_addr = htonl(INADDR_ANY);

它的值是 0 。由于我们刚刚使用 bzero 的整个结构，将其再次设置为 0 是多余的。但是如果我们将我们的代码移植到另一个系统，其中 INADDR_ANY 或许不是零，那么我们需要将其分配给 sa.sin_addr.s_addr 。大多数现代 C 编译器足够聪明，注意到 INADDR_ANY 是一个常量。只要它是零，它们就会优化整个条件语句从代码中移除。

在我们成功地调用 bind 后，我们准备成为守护程序：我们使用 fork 来创建一个子进程。在父进程和子进程中， s 变量是我们的套接字。父进程不需要它，所以它调用 close ，然后返回 0 以通知它自己的父进程它已成功终止。

与此同时，子进程继续在后台工作。它调用 listen 并将其后备设置为 4 。这里不需要一个很大的值，因为白天不是许多客户端一直请求的协议，并且因为它可以立即处理每个请求。

最后，守护程序启动一个无休止的循环，执行以下步骤：

1. 调用 accept 。它在这里等待，直到客户端联系。此时，它会接收一个新的套接字 c ，用于与特定客户端通信。

2. 使用 C 函数 fdopen 将套接字从低级文件描述符转换为 C 风格的 FILE 指针。这将允许稍后使用 fprintf 。

3. 检查时间，并以 ISO 8601 格式打印到 client "文件"。然后使用 fclose 关闭文件。这将自动关闭套接字。

我们可以概括这一点，并将其用作许多其他服务器的模型:

图 10. 顺序服务器

这个流程图适用于顺序服务器，即一次只能为一个客户提供服务的服务器，就像我们之前在白天服务器中所能做的一样。只有在客户端和服务器之间没有真正的“对话”时才有可能：一旦服务器检测到与客户端的连接，它就会发送一些数据然后关闭连接。整个操作可能只需几纳秒，就完成了。

这个流程图的优点是，除了父 fork 退出之前的短暂时刻外，始终只有一个进程处于活动状态：我们的服务器不会占用太多内存和其他系统资源。

请注意，我们在流程图中添加了初始化守护程序。我们不需要初始化自己的守护程序，但这是程序流程中设置任何 signal 处理程序、打开可能需要的任何文件等的好地方。

流程图中的几乎所有内容都可以在许多不同的服务器上直接使用。serve 条目是个例外。我们将其视为一个“黑匣子”，即，您专门为自己的服务器设计的东西，只需“将其插入其余部分”即可。

并非所有协议都那么简单。许多协议接收来自客户端的请求，然后回复该请求，接着再次接收来自同一客户端的请求。因此，它们事先无法知道为客户端提供服务的时长。这类服务器通常为每个客户端启动一个新进程。在新进程为其客户端提供服务时，守护程序可以继续侦听更多连接。

现在，继续吧，将上述源代码保存为 daytimed.c（以字母 0 结尾的守护程序名称是惯例）。编译后，尝试运行它：

% ./daytimed
bind: Permission denied
%

发生了什么？正如你所记得的，白天协议使用 13。但是 1024 以下的所有端口都保留给超级用户（否则，任何人都可以启动一个假装为常用端口提供服务的守护程序，从而造成安全漏洞）。

请再试一次，这次以超级用户身份：

# ./daytimed
#

什么... 什么也没有？让我们再试一次：

# ./daytimed

bind: Address already in use
#

每个port 一次只能由一个程序绑定。我们的第一次尝试确实成功了：它启动了子守护程序并静静地返回。它仍在运行，并将继续运行，直到您杀死它，或者它的任何系统调用失败，或者您重新启动系统。

好吧，我们知道它在后台运行。但它是否正常工作呢？我们如何知道它是一个适合白天运行的服务器呢？简单：

% telnet localhost 13

Trying ::1...
telnet: connect to address ::1: Connection refused
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
2001-06-19T21:04:42Z
Connection closed by foreign host.
%

telnet 尝试了新的 IPv6，但失败了。它改用 IPv4 再次尝试，成功了。守护进程有效。

如果您可以通过 telnet 访问另一个 UNIX®系统，则可以使用它来测试远程访问服务器。我的计算机没有静态 IP 地址，所以我这样做：

% who

whizkid          ttyp0   Jun 19 16:59   (216.127.220.143)
xxx              ttyp1   Jun 19 16:06   (xx.xx.xx.xx)
% telnet 216.127.220.143 13

Trying 216.127.220.143...
Connected to r47.bfm.org.
Escape character is '^]'.
2001-06-19T21:31:11Z
Connection closed by foreign host.
%

再次，它有效。使用域名会有效吗？

% telnet r47.bfm.org 13

Trying 216.127.220.143...
Connected to r47.bfm.org.
Escape character is '^]'.
2001-06-19T21:31:40Z
Connection closed by foreign host.
%

顺便说一下，telnet 在我们的守护程序关闭套接字后打印“连接由外部主机关闭”消息。这向我们表明，确实，在我们的代码中使用 fclose(client); 是有效的。

7.6. 助手函数

FreeBSD C 库包含许多用于套接字编程的辅助函数。例如，在我们的示例客户端中，我们硬编码了 time.nist.gov IP 地址。但我们并不总是知道 IP 地址。即使我们知道，如果软件允许用户输入 IP 地址甚至域名，它会更加灵活。

7.6.1. gethostbyname

虽然没有办法将域名直接传递给任何套接字函数，但 FreeBSD C 库带有在 netdb.h 中声明的 gethostbyname(3) 和 gethostbyname2(3) 函数。

struct hostent * gethostbyname(const char *name);
struct hostent * gethostbyname2(const char *name, int af);

两者都返回指向 hostent 结构的指针，其中包含许多关于域的信息。就我们的目的而言，结构的 h_addr_list[0] 字段指向已存储在网络字节顺序中的 h_length 字节的正确地址。

这使我们能够创建一个更加灵活和更有用的白天程序的版本：

/*
 * daytime.c
 *
 * Programmed by G. Adam Stanislav
 * 19 June 2001
 */
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

int main(int argc, char *argv[]) {
  register int s;
  register int bytes;
  struct sockaddr_in sa;
  struct hostent *he;
  char buf[BUFSIZ+1];
  char *host;

  if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
    perror("socket");
    return 1;
  }

  bzero(&sa, sizeof sa);

  sa.sin_family = AF_INET;
  sa.sin_port = htons(13);

  host = (argc > 1) ? (char *)argv[1] : "time.nist.gov";

  if ((he = gethostbyname(host)) == NULL) {
    herror(host);
    return 2;
  }

  bcopy(he->h_addr_list[0],&sa.sin_addr, he->h_length);

  if (connect(s, (struct sockaddr *)&sa, sizeof sa) < 0) {
    perror("connect");
    return 3;
  }

  while ((bytes = read(s, buf, BUFSIZ)) > 0)
    write(1, buf, bytes);

  close(s);
  return 0;
}

现在，我们可以在命令行上输入域名（或 IP 地址，两者均可），程序将尝试连接到其白天服务器。否则，它仍将默认为 time.nist.gov 。但是，即使在这种情况下，我们也将使用 gethostbyname 而不是硬编码 192.43.244.18 。这样，即使其 IP 地址在未来发生变化，我们仍然可以找到它。

由于从您的本地服务器获取时间几乎不需要时间，您可以连续两次运行白天：首先从 time.nist.gov 获取时间，第二次从您自己的系统获取时间。然后，您可以比较结果，看看您的系统时钟是多么精确。

% daytime ; daytime localhost

52080 01-06-20 04:02:33 50 0 0 390.2 UTC(NIST) *
2001-06-20T04:02:35Z
%

正如您所看到的，我的系统比 NIST 时间提前两秒。

7.6.2. getservbyname

有时候，您可能不确定某个服务使用了什么port。在这种情况下，getservbyname(3)函数非常方便，该函数也在 netdb.h 中声明：

struct servent * getservbyname(const char *name, const char *proto);

结构体 servent 包含了 s_port ，其中包含了已经按网络字节顺序排列的正确port。

如果我们不知道白天服务的正确port，我们可以通过这种方式找到它：

struct servent *se;
  ...
  if ((se = getservbyname("daytime", "tcp")) == NULL {
    fprintf(stderr, "Cannot determine which port to use.\n");
    return 7;
  }
  sa.sin_port = se->s_port;

通常您确实知道port。 但是，如果您正在开发新协议，可能会在非官方port上进行测试。 将来的某一天，您将会注册协议及其port（如果不在别处，在您的 / etc / services 中至少会有 getservbyname ）。 在上述代码中，而不是返回错误，您只需使用临时port号码。 一旦您在 / etc / services 中列出了协议，您的软件将自动找到其port，而无需重新编写代码。

7.7. 并发服务器

与顺序服务器不同，并发服务器必须能够同时为多个客户端提供服务。例如，聊天服务器可能会为特定客户端提供几个小时的服务，它不能等到停止为一个客户端提供服务后再为下一个客户端提供服务。

这要求我们的流程图有显著变化：

图 11. 并发服务器

我们将服务器从守护进程移动到自己的服务器进程中。但是，由于每个子进程继承所有打开的文件（而套接字被视为文件），新进程不仅继承了“已接受句柄”即 accept 调用返回的套接字，还继承了顶部套接字，即顶部进程在一开始打开的套接字。

但是，服务器进程不需要此套接字，应立即 close 。同样，守护进程不再需要已接受的套接字，不仅应该，而且必须 close 它，否则，迟早会耗尽可用的文件描述符。

在服务器进程完成服务后，应关闭已接受的套接字。它现在退出，而不是返回 accept 。

在 UNIX®下，一个进程并不真正退出。相反，它会返回给其父进程。通常，父进程会等待其子进程，并获取返回值。然而，我们的守护进程不能简单地停止并等待。那样会背离创建额外进程的初衷。但如果它永远不这样做，其子进程将变成僵尸-不再起作用但仍然在系统中游荡。

出于这个原因，守护进程需要在其初始化守护进程阶段设置信号处理程序。至少要处理一个 SIGCHLD 信号，这样守护进程可以从系统中移除僵尸返回值，并释放它们占用的系统资源。

这就是为什么我们的流程图现在包含一个处理信号的框，它不连接到任何其他框。顺便说一句，许多服务器也处理 SIGHUP 信号，并通常解释为超级用户发出的信号，告诉它们应重新读取其配置文件。这使我们能够在无需终止和重新启动这些服务器的情况下更改设置。

10.1. 获取内核崩溃转储

运行开发内核（例如 FreeBSD-CURRENT）时，例如在极端条件下的内核（例如非常高的负载平均值，成千上万的连接，极高数量的并发用户，数百个jail（8）等），或者在 FreeBSD-STABLE 上使用新功能或设备驱动程序（例如 PAE），有时内核会发生崩溃。如果发生崩溃，本章将演示如何从崩溃中提取有用信息。

一旦内核发生崩溃，系统重启是不可避免的。一旦系统重新启动，系统的物理内存（RAM）的内容将丢失，以及在崩溃之前位于交换设备上的任何位。为了保留物理内存中的位，内核利用交换设备作为在崩溃后跨重启存储在 RAM 中的位的临时位置。通过这种方式，当 FreeBSD 在崩溃后启动时，现在可以提取内核映像，并进行调试。

可用几种类型的内核崩溃转储：

完整内存转储保存物理内存的完整内容。

迷你转储仅保存内核正在使用的内存页面（FreeBSD 6.2 及更高版本）。

TextdumpsHold 捕获、脚本化或交互式调试器输出（FreeBSD 7.1 及更高版本）。

Minidumps 是 FreeBSD 7.0 的默认转储类型，在大多数情况下将捕获完整内存转储中存在的所有必要信息，因为大多数问题只能使用内核状态来隔离。

10.1.1. 配置转储设备

内核将转储其物理内存的内容到转储设备之前，必须配置转储设备。 使用 dumpon(8)命令指定转储设备，告诉内核在哪里保存内核崩溃转储。 在交换分区使用 swapon(8)配置后，必须调用 dumpon(8)程序。 通常通过在 rc.conf(5)中设置 dumpdev 变量为交换设备路径（提取内核转储的推荐方式）或 AUTO 以使用第一个配置的交换设备来处理。 在 HEAD 中，默认为 dumpdev ，在 RELENG_*分支上更改为 NO （除了 RELENG_7，它保持设置为 AUTO ）。 在 FreeBSD 9.0-RELEASE 和更高版本中，bsdinstall 将在安装过程中询问是否应在目标系统上启用崩溃转储。

# mkdir /var/crash
# chmod 700 /var/crash

此外，请记住/var/crash 的内容是敏感的，很可能包含诸如密码之类的机密信息。

10.1.2. 提取内核转储

一旦将转储写入转储设备，必须在挂载交换设备之前提取转储。要从转储设备中提取转储，请使用 savecore(8)程序。如果在 rc.conf(5)中设置了 dumpdev ，则在崩溃后的第一次多用户引导时，将自动调用 savecore(8)，在交换设备挂载之前。提取的核心位置放置在 rc.conf(5)值 dumpdir 中，默认为/var/crash，并将命名为 vmcore.0。

如果/var/crash 中已经存在名为 vmcore.0 的文件（或者设置为 dumpdir 的任何内容），内核将为每次崩溃递增尾随数字，以避免覆盖现有的 vmcore（例如，vmcore.1）。在保存转储后，savecore(8)将始终在/var/crash 中创建一个名为 vmcore.last 的符号链接。此符号链接可用于查找最近转储的名称。

crashinfo(8) 实用程序生成一个文本文件，其中包含来自完整内存转储或迷你转储的信息摘要。如果在 rc.conf(5) 中设置了 dumpdev ，则在 savecore(8) 之后会自动调用 crashinfo(8)。输出保存在名为 core.txt.N 的文件中。

# fsck -p
# mount -a -t ufs       # make sure /var/crash is writable
# savecore /var/crash /dev/ad0s1b
# exit                  # exit to multi-user

这会指示 savecore(8) 从 /dev/ad0s1b 中提取一个内核转储，并将内容放在 /var/crash 中。不要忘记确保目标目录 /var/crash 有足够的空间来存储转储。还要记得指定正确的交换设备路径，因为它很可能与 /dev/ad0s1b 不同！

10.1.3. 测试内核转储配置

内核包含一个 sysctl(8) 节点，用于请求内核崩溃。这可用于验证系统是否正确配置以保存内核崩溃转储。在触发崩溃之前，您可能希望在单用户模式下将现有文件系统重新挂载为只读，以避免数据丢失。

# shutdown now
...
Enter full pathname of shell or RETURN for /bin/sh:
# mount -a -u -r
# sysctl debug.kdb.panic=1
debug.kdb.panic:panic: kdb_sysctl_panic
...

重新启动后，您的系统应在 /var/crash 中保存一个转储文件，并附有来自 crashinfo(8) 的匹配摘要。

10.2. 使用 kgdb 调试内核崩溃转储

要进入调试器并开始从转储中获取信息，请启动 kgdb：

# kgdb -n N

其中 N 是要检查的 vmcore.N 的后缀。要打开最近的转储，请使用：

# kgdb -n last

通常情况下，kgdb(1) 应该能够定位在生成转储时运行的内核。如果无法定位正确的内核，请将内核的路径名和转储作为两个参数传递给 kgdb：

# kgdb /boot/kernel/kernel /var/crash/vmcore.0

您可以像调试任何其他程序一样使用内核源代码来调试崩溃转储。

这个转储文件来自于一个 5.2-BETA 内核，崩溃是在内核深处发生的。下面的输出已经经过修改，在左侧包含了行号。这个第一次跟踪检查指令指针并获得一个回溯。在第 41 行使用的地址已经在第 17 行找到，用于 list 命令的指令指针。如果您无法自行调试出问题，大多数开发人员会要求至少要将这些信息发送给他们。但是，如果您解决了问题，请确保您的补丁通过问题报告、邮件列表或能够提交它的方式进入源码树！

 1:# cd /usr/obj/usr/src/sys/KERNCONF
 2:# kgdb kernel.debug /var/crash/vmcore.0
 3:GNU gdb 5.2.1 (FreeBSD)
 4:Copyright 2002 Free Software Foundation, Inc.
 5:GDB is free software, covered by the GNU General Public License, and you are
 6:welcome to change it and/or distribute copies of it under certain conditions.
 7:Type "show copying" to see the conditions.
 8:There is absolutely no warranty for GDB.  Type "show warranty" for details.
 9:This GDB was configured as "i386-undermydesk-freebsd"...
10:panic: page fault
11:panic messages:
12:---
13:Fatal trap 12: page fault while in kernel mode
14:cpuid = 0; apic id = 00
15:fault virtual address   = 0x300
16:fault code:             = supervisor read, page not present
17:instruction pointer     = 0x8:0xc0713860
18:stack pointer           = 0x10:0xdc1d0b70
19:frame pointer           = 0x10:0xdc1d0b7c
20:code segment            = base 0x0, limit 0xfffff, type 0x1b
21:                        = DPL 0, pres 1, def32 1, gran 1
22:processor eflags        = resume, IOPL = 0
23:current process         = 14394 (uname)
24:trap number             = 12
25:panic: page fault
26      cpuid = 0;
27:Stack backtrace:
28
29:syncing disks, buffers remaining... 2199 2199 panic: mi_switch: switch in a critical section
30:cpuid = 0;
31:Uptime: 2h43m19s
32:Dumping 255 MB
33: 16 32 48 64 80 96 112 128 144 160 176 192 208 224 240
34:---
35:Reading symbols from /boot/kernel/snd_maestro3.ko...done.
36:Loaded symbols for /boot/kernel/snd_maestro3.ko
37:Reading symbols from /boot/kernel/snd_pcm.ko...done.
38:Loaded symbols for /boot/kernel/snd_pcm.ko
39:#0  doadump () at /usr/src/sys/kern/kern_shutdown.c:240
40:240             dumping++;
41:(kgdb) list *0xc0713860
42:0xc0713860 is in lapic_ipi_wait (/usr/src/sys/i386/i386/local_apic.c:663).
43:658                     incr = 0;
44:659                     delay = 1;
45:660             } else
46:661                     incr = 1;
47:662             for (x = 0; x < delay; x += incr) {
48:663                     if ((lapic->icr_lo & APIC_DELSTAT_MASK) == APIC_DELSTAT_IDLE)
49:664                             return (1);
50:665                     ia32_pause();
51:666             }
52:667             return (0);
53:(kgdb) backtrace
54:#0  doadump () at /usr/src/sys/kern/kern_shutdown.c:240
55:#1  0xc055fd9b in boot (howto=260) at /usr/src/sys/kern/kern_shutdown.c:372
56:#2  0xc056019d in panic () at /usr/src/sys/kern/kern_shutdown.c:550
57:#3  0xc0567ef5 in mi_switch () at /usr/src/sys/kern/kern_synch.c:470
58:#4  0xc055fa87 in boot (howto=256) at /usr/src/sys/kern/kern_shutdown.c:312
59:#5  0xc056019d in panic () at /usr/src/sys/kern/kern_shutdown.c:550
60:#6  0xc0720c66 in trap_fatal (frame=0xdc1d0b30, eva=0)
61:    at /usr/src/sys/i386/i386/trap.c:821
62:#7  0xc07202b3 in trap (frame=
63:      {tf_fs = -1065484264, tf_es = -1065484272, tf_ds = -1065484272, tf_edi = 1, tf_esi = 0, tf_ebp = -602076292, tf_isp = -602076324, tf_ebx = 0, tf_edx = 0, tf_ecx = 1000000, tf_eax = 243, tf_trapno = 12, tf_err = 0, tf_eip = -1066321824, tf_cs = 8, tf_eflags = 65671, tf_esp = 243, tf_ss = 0})
64:    at /usr/src/sys/i386/i386/trap.c:250
65:#8  0xc070c9f8 in calltrap () at {standard input}:94
66:#9  0xc07139f3 in lapic_ipi_vectored (vector=0, dest=0)
67:    at /usr/src/sys/i386/i386/local_apic.c:733
68:#10 0xc0718b23 in ipi_selected (cpus=1, ipi=1)
69:    at /usr/src/sys/i386/i386/mp_machdep.c:1115
70:#11 0xc057473e in kseq_notify (ke=0xcc05e360, cpu=0)
71:    at /usr/src/sys/kern/sched_ule.c:520
72:#12 0xc0575cad in sched_add (td=0xcbcf5c80)
73:    at /usr/src/sys/kern/sched_ule.c:1366
74:#13 0xc05666c6 in setrunqueue (td=0xcc05e360)
75:    at /usr/src/sys/kern/kern_switch.c:422
76:#14 0xc05752f4 in sched_wakeup (td=0xcbcf5c80)
77:    at /usr/src/sys/kern/sched_ule.c:999
78:#15 0xc056816c in setrunnable (td=0xcbcf5c80)
79:    at /usr/src/sys/kern/kern_synch.c:570
80:#16 0xc0567d53 in wakeup (ident=0xcbcf5c80)
81:    at /usr/src/sys/kern/kern_synch.c:411
82:#17 0xc05490a8 in exit1 (td=0xcbcf5b40, rv=0)
83:    at /usr/src/sys/kern/kern_exit.c:509
84:#18 0xc0548011 in sys_exit () at /usr/src/sys/kern/kern_exit.c:102
85:#19 0xc0720fd0 in syscall (frame=
86:      {tf_fs = 47, tf_es = 47, tf_ds = 47, tf_edi = 0, tf_esi = -1, tf_ebp = -1077940712, tf_isp = -602075788, tf_ebx = 672411944, tf_edx = 10, tf_ecx = 672411600, tf_eax = 1, tf_trapno = 12, tf_err = 2, tf_eip = 671899563, tf_cs = 31, tf_eflags = 642, tf_esp = -1077940740, tf_ss = 47})
87:    at /usr/src/sys/i386/i386/trap.c:1010
88:#20 0xc070ca4d in Xint0x80_syscall () at {standard input}:136
89:---Can't read userspace from dump, or kernel process---
90:(kgdb) quit

10.3. 使用 DDB 进行在线内核调试

虽然 kgdb 作为一种脱机调试器提供了非常高级的用户界面，但它无法做一些事情。最重要的是断点设置和单步执行内核代码。

如果您需要在内核上进行低级调试，可以使用名为 DDB 的在线调试器。它允许设置断点，逐步执行内核函数，检查和更改内核变量等。但是，它无法访问内核源文件，只能访问全局和静态符号，而不能像 kgdb 那样访问完整的调试信息。

要配置内核以包含 DDB，请添加选项

options KDB

options DDB

到您的配置文件，并重新构建。（有关配置 FreeBSD 内核的详细信息，请参阅 FreeBSD 手册）。

一旦您的 DDB 内核运行起来，有几种方法可以进入 DDB。第一种，也是最早的方法是使用引导标志 -d 。内核将以调试模式启动，并在任何设备探测之前进入 DDB。因此，您甚至可以调试设备的探测/附加功能。要使用此功能，请退出加载程序的引导菜单，并在加载程序提示符处输入 boot -d 。

第二种情况是在系统引导后立即转到调试器。有两种简单的方法可以实现这一点。如果您想从命令提示符中断到调试器，请简单地键入以下命令：

# sysctl debug.kdb.enter=1

或者，如果您在系统控制台上，可以使用键盘上的热键。默认的中断到调试器序列是 Ctrl+Alt+ESC。对于 syscons，此序列可以重新映射，一些分发的映射已经这样做了，因此请确保您知道要使用的正确序列。对于允许在控制台线上使用串行线 BREAK 进入 DDB 的串行控制台，有一个选项（ options BREAK_TO_DEBUGGER 在内核配置文件中）。这不是默认选项，因为周围有很多不必要生成 BREAK 条件的串行适配器，例如在拔下电缆时。

第三种方式是，如果内核配置为使用它，任何恐慌条件都将分支到 DDB。出于这个原因，配置一个带有 DDB 的内核不明智，用于运行无人看管的机器。

要获得无人看管功能，请添加：

options	KDB_UNATTENDED

到内核配置文件中并重新构建/重新安装。

DDB 命令大致类似于某些 gdb 命令。您可能需要做的第一件事情是设置断点:

 break function-name address

默认情况下，数字被视为十六进制，但为了使它们与符号名称区分开；以字母 a-f 开头的十六进制数需要在前面加上 0x （对于其他数字而言，这是可选的）。可以使用简单的表达式，例如: function-name + 0x103 .

要退出调试器并继续执行，请键入:

 continue

要获取当前线程的堆栈跟踪，请使用：

 trace

要获取任意线程的堆栈跟踪，请将进程 ID 或线程 ID 指定为第二个参数 trace 。

如果要删除断点，请使用

 del
 del address-expression

第一种形式在断点命中后立即被接受，并删除当前断点。第二种形式可以移除任何断点，但您需要指定确切的地址；这可以从中获得：

 show b

或：

 show break

要单步执行内核，请尝试：

 s

这将进入函数，但你可以让 DDB 追踪它们，直到达到匹配的返回语句：

 n

要从内存中检查数据，请使用（例如）：

 x/wx 0xf0133fe0,40
 x/hd db_symtab_space
 x/bc termbuf,10
 x/s stringbuf

用于字/半字/字节访问，以及十六进制/十进制/字符/字符串显示。逗号后面的数字是对象计数。要显示接下来的 0x10 个项目，只需使用：

 x ,10

同样，使用

 x/ia foofunc,10

来反汇编 foofunc 的前 0x10 条指令，并显示它们以及它们距离 foofunc 起始处的偏移量。

用 write 命令修改内存：

 w/b termbuf 0xa 0xb 0
 w/w 0xf0010030 0 0

命令修饰符 ( b / h / w ) 指定要写入的数据的大小，随后的第一个表达式是要写入的地址，其余被解释为要写入连续内存位置的数据。

如果你需要了解当前寄存器，请使用：

 show reg

或者，您可以通过例如显示单个寄存器值

 p $eax

并通过修改它

 set $eax new-value

如果您需要从 DDB 调用一些内核函数，只需说

 call func(arg1, arg2, ...)

返回值将被打印。

要获取所有运行进程的 ps(1) 风格摘要，请使用：

 ps

现在您已经检查了内核失败的原因，并希望重新启动。请记住，根据先前故障的严重程度，内核的某些部分可能仍无法正常工作。执行以下操作之一以关闭并重新启动系统：

 panic

这将导致您的内核转储核心并重新启动，因此您可以稍后使用 kgdb(1)在更高级别上分析核心。

 call boot(0)

这可能是一个干净关闭运行系统的好方法， sync() 所有磁盘，并最终，在某些情况下，重新启动。只要内核的磁盘和文件系统接口没有损坏，这可能是一个几乎干净的关机方式。

 reset

这是灾难中的最后一招，几乎与按下大红按钮相同。

如果您需要简短的命令摘要，请输入：

 help

强烈建议在调试会话中准备打印版本的 ddb(4) 手册页面。请记住，在单步执行内核时很难阅读在线手册。

10.4. 使用远程 GDB 进行在线内核调试

FreeBSD 内核为在线调试提供了第二个 KDB 后端：gdb（4）。自 FreeBSD 2.2 以来就支持此功能，实际上非常方便。

GDB 长期以来一直支持远程调试。这是通过串行线路沿着一个非常简单的协议完成的。与上述其他调试方法不同，您需要两台机器来执行此操作。一台是提供调试环境的主机，其中包括所有源代码以及一个包含所有符号的内核二进制副本。另一台是运行完全相同内核副本（可选地删除了调试信息）的目标机器。

要使用远程 GDB，请确保您的内核配置中存在以下选项：

makeoptions     DEBUG=-g
options         KDB
options         GDB

请注意，在-STABLE 和-RELEASE 分支的内核中， GENERIC 默认情况下关闭了 GDB 选项，但在-CURRENT 上启用。

构建完成后，将内核复制到目标机器，并引导它。将目标机器的串行线连接到调试主机的任何串行线，其中该串行线上的 uart 设备设置为"flags 080"。有关如何设置 uart 设备上标志的信息，请参阅 uart(4)。

目标机器必须使其进入 GDB 后端，要么由于发生紧急情况，要么通过有意诱发陷阱进入调试器。在执行此操作之前，选择 GDB 调试器后端：

# sysctl debug.kdb.current=gdb
debug.kdb.current: ddb -> gdb

然后，强制进入调试器：

# sysctl debug.kdb.enter=1
debug.kdb.enter: 0KDB: enter: sysctl debug.kdb.enter

目标机现在等待远程 GDB 客户端的连接。在调试机上，前往目标内核的编译目录，并启动 gdb ：

# cd /usr/obj/usr/src/amd64.amd64/sys/GENERIC/
# kgdb kernel
GNU gdb (GDB) 10.2 [GDB v10.2 for FreeBSD]
Copyright (C) 2021 Free Software Foundation, Inc.
...
Reading symbols from kernel...
Reading symbols from /usr/obj/usr/src/amd64.amd64/sys/GENERIC/kernel.debug...
(kgdb)

通过以下方式启动远程调试会话（假设正在使用第一个串行port）：

(kgdb) target remote /dev/cuau0

您的主机 GDB 现在将控制目标内核：

Remote debugging using /dev/cuau0
kdb_enter (why=<optimized out>, msg=<optimized out>) at /usr/src/sys/kern/subr_kdb.c:506
506                     kdb_why = KDB_WHY_UNSET;
(kgdb)

您几乎可以像使用其他 GDB 会话一样使用此会话，包括完全访问源代码，在 Emacs 窗口中以 gud 模式运行它（这将在另一个 Emacs 窗口中自动显示源代码等）。

10.5. 调试控制台驱动程序

由于您需要一个控制台驱动程序来运行 DDB，如果控制台驱动程序本身出现故障，情况就会变得更加复杂。您可能会记得使用串行控制台（要么使用修改后的引导块，要么在提示符处指定 -h ），并将标准终端连接到您的第一个串行port。DDB 可在任何配置的控制台驱动程序上运行，包括串行控制台。

10.6. 调试死锁

您可能会遇到所谓的死锁，这是一个系统停止执行有用工作的情况。在这种情况下，为了提供有用的 bug 报告，请使用上一节中描述的 ddb(4)。在报告中包含 ps 和 trace 的疑似进程的输出。

如果可能的话，考虑进行进一步调查。如果您怀疑死锁发生在 VFS 层，请使用下面的方法。将这些选项添加到内核配置文件中。

makeoptions 	DEBUG=-g
options 	INVARIANTS
options 	INVARIANT_SUPPORT
options 	WITNESS
options 	WITNESS_SKIPSPIN
options 	DEBUG_LOCKS
options 	DEBUG_VFS_LOCKS
options 	DIAGNOSTIC

当发生死锁时，除了执行 ps 命令的输出外，还提供来自 show pcpu ， show allpcpu ， show locks ， show alllocks ， show lockedvnods 和 alltrace 的信息。

要为线程化进程获取有意义的回溯信息，请使用 thread thread-id 切换到线程堆栈，并使用 where 进行回溯。

10.7. 使用 Dcons 进行内核调试

dcons(4)是一个非常简单的控制台驱动程序，不直接与任何物理设备连接。它只是从内核或加载程序中的缓冲区读取和写入字符。由于其简单的特性，它在内核调试中非常有用，特别是与 FireWire®设备一起使用。目前，FreeBSD 提供了两种与缓冲区进行外部交互的方式，使用 dconschat(8)。

10.7.1. FireWire®上的 Dcons

大多数 FireWire®（IEEE1394）主机控制器都基于支持对主机内存进行物理访问的 OHCI 规范。这意味着一旦主机控制器初始化，我们可以在没有软件（内核）帮助的情况下访问主机内存。我们可以利用这个功能与 dcons(4)进行交互。dcons(4)提供类似于串行控制台的功能。它模拟两个串行端口，一个用于控制台和 DDB，另一个用于 GDB。由于远程内存访问完全由硬件处理，即使系统崩溃，dcons(4)缓冲区也是可访问的。

FireWire® 设备不仅限于集成到主板中。桌面上有 PCI 卡可用，笔记本电脑可以购买 CardBus 接口。

10.7.1.1. 在目标机器上启用 FireWire®和 Dcons 支持

要在目标机器的内核中启用 FireWire®和 Dcons 支持：

• 确保您的内核支持 dcons ， dcons_crom 和 firewire 。 Dcons 应该与内核静态链接。对于 dcons_crom 和 firewire ，模块应该没问题。

• 确保启用物理 DMA。您可能需要将 hw.firewire.phydma_enable=1 添加到 /boot/loader.conf 中。

• 添加用于调试的选项。

• 如果您使用 GDB 在 FireWire®上，请在/boot/loader.conf 中添加 dcons_gdb=1 。

• 在/etc/ttys 中启用 dcons 。

• 可选地，要强制 dcons 成为高级控制台，请将 hw.firewire.dcons_crom.force_console=1 添加到 loader.conf 中。

在 i386 或 amd64 上启用 FireWire® 和 Dcons 支持，请在 loader(8) 中添加以下内容：

在 /etc/make.conf 中添加 LOADER_FIREWIRE_SUPPORT=YES 并重新构建 loader(8)：

# cd /sys/boot/i386 && make clean && make && make install

要将 dcons(4) 作为主动低级控制台启用，请将 boot_multicons="YES" 添加到 /boot/loader.conf。

这里有一些配置示例。一个样本内核配置文件将包含：

device dcons
device dcons_crom
options KDB
options DDB
options GDB
options ALT_BREAK_TO_DEBUGGER

一个样本 /boot/loader.conf 将包含：

dcons_crom_load="YES"
dcons_gdb=1
boot_multicons="YES"
hw.firewire.phydma_enable=1
hw.firewire.dcons_crom.force_console=1

10.7.1.2. 在主机上启用 FireWire® 和 Dcons 支持

在主机上的内核中启用 FireWire® 支持：

# kldload firewire

找出 FireWire® 主机控制器的唯一 64 位标识符（EUI64），并使用 fwcontrol(8) 或 dmesg 找到目标机器的 EUI64。

运行 dconschat(8)，使用：

# dconschat -e \# -br -G 12345 -t 00-11-22-33-44-55-66-77

一旦 dconschat(8) 运行，可以使用以下组合键：

使用远程调试会话启动 kgdb(1)以附加远程 GDB：

 kgdb -r :12345 kernel

10.7.1.3. 一些一般提示

这里有一些一般提示：

利用 FireWire® 的速度优势，禁用其他慢速控制台驱动程序：

# conscontrol delete ttyd0	     # serial console
# conscontrol delete consolectl	# video/keyboard

emacs(1) 存在一个 GDB 模式；这是您需要添加到您的 .emacs 的内容：

(setq gud-gdba-command-name "kgdb -a -a -a -r :12345")
(setq gdb-many-windows t)
(xterm-mouse-mode 1)
M-x gdba

以及 DDD（devel/ddd）：

# remote serial protocol
LANG=C ddd --debugger kgdb -r :12345 kernel
# live core debug
LANG=C ddd --debugger kgdb kernel /dev/fwmem0.2

10.7.2. 使用 KVM 的 Dcons

我们可以直接通过 /dev/mem 读取 dcons(4) 缓冲区以获取活动系统的信息，并在崩溃系统的核心转储中获取。这些为您提供类似于 dmesg -a 的输出，但 dcons(4) 缓冲区包含更多信息。

10.7.2.1. 使用 KVM 的 Dcons

使用 dcons(4) 与 KVM：

转储活动系统的 dcons(4) 缓冲区：

# dconschat -1

转储崩溃转储的 dcons(4) 缓冲区：

# dconschat -1 -M vmcore.XX

可以通过实时核心调试进行调试：

# fwcontrol -m target_eui64
# kgdb kernel /dev/fwmem0.2

10.8. 内核调试选项术语表

本节简要介绍了用于调试的编译时内核选项的术语表

• options KDB ：在内核调试器框架中编译。对 options DDB 和 options GDB 必需。几乎没有性能开销。默认情况下，在发生紧急情况时会进入调试器，而不是自动重新启动。

• options KDB_UNATTENDED ：将 debug.debugger_on_panic sysctl 的默认值更改为 0，该值控制发生紧急情况时是否进入调试器。当 options KDB 未编译到内核中时，行为是在发生紧急情况时自动重新启动；当它编译到内核中时，默认行为是进入调试器，除非 options KDB_UNATTENDED 也编译进去。如果您想将内核调试器编译到内核中，但希望系统在您未使用调试器进行诊断时重新启动，请使用此选项。

• options KDB_TRACE ：将 debug.trace_on_panic sysctl 的默认值更改为 1，该值控制发生紧急情况时调试器是否自动打印堆栈跟踪。特别是在运行时，这对于在串行或 firewire 控制台上收集基本调试信息并仍然重新启动以恢复可能很有帮助。

• options DDB ：在系统的活动低级控制台上运行的交互式调试器，DDB 的支持编译。这包括视频控制台、串行控制台或 FireWire 控制台。它提供基本的集成调试功能，如堆栈跟踪、进程和线程列表、锁状态转储、VM 状态、文件系统状态和内核内存管理。DDB 不需要在第二台机器上运行软件或能够生成核心转储或完整的调试内核符号，并提供运行时内核的详细诊断。许多错误可以仅使用 DDB 输出进行完全诊断。此选项取决于 options KDB 。

• options GDB ：编译支持远程调试器 GDB，它可以通过串行电缆或 FireWire 操作。当进入调试器时，GDB 可以附加以检查结构内容、生成堆栈跟踪等。有些内核状态比在 DDB 中更难访问，DDB 能够自动生成内核状态的有用摘要，如自动遍历锁调试或内核内存管理结构，需要第二台运行调试器的机器。另一方面，GDB 结合了内核源代码和完整的调试符号的信息，并且了解完整的数据结构定义、本地变量，并且可编写脚本。此选项不需要在内核核心转储上运行 GDB。此选项取决于 options KDB 。

• options BREAK_TO_DEBUGGER ， options ALT_BREAK_TO_DEBUGGER ：允许在控制台上发送中断信号或替代信号进入调试器。如果系统在没有恐慌的情况下挂起，这是一个有用的进入调试器的方法。由于当前内核锁定，在串行控制台上生成的中断信号更可靠地进入调试器，并且通常建议使用。此选项几乎不会对性能产生影响。

• options INVARIANTS ：将大量运行时断言检查和测试编译到内核中，不断测试内核数据结构的完整性和内核算法的不变性。这些测试可能很昂贵，因此默认情况下不会编译进去，但有助于提供有用的“故障停止”行为，在内核数据损坏发生之前，某些类别的不良行为会进入调试器，使它们更容易调试。测试包括内存擦除和使用后释放测试，这是开销较大的重要开销来源之一。此选项取决于 options INVARIANT_SUPPORT 。

• options INVARIANT_SUPPORT ： options INVARIANTS 中的许多测试需要修改的数据结构或额外的内核符号来定义。

• options WITNESS ：此选项启用运行时锁定顺序跟踪和验证，是死锁诊断的宝贵工具。WITNESS 通过锁类型维护已获取的锁定顺序图，并在每次获取时检查图表中的循环（隐式或显式）。如果检测到循环，将向控制台生成警告和堆栈跟踪，指示可能发生死锁。为了使用 show locks 、 show witness 和 show alllocks DDB 命令，需要 WITNESS。此调试选项具有显着的性能开销，可以通过使用 options WITNESS_SKIPSPIN 来在一定程度上减轻。详细文档可在 witness(4)中找到。

• options WITNESS_SKIPSPIN ：禁用 WITNESS 的自旋锁顺序的运行时检查。由于调度器中最频繁地获取自旋锁，并且调度器事件经常发生，此选项可以显著加快运行 WITNESS 的系统速度。此选项取决于 options WITNESS 。

• options WITNESS_KDB ：将 debug.witness.kdb sysctl 的默认值更改为 1，这会导致 WITNESS 在检测到锁顺序违规时进入调试器，而不仅仅是打印警告。此选项取决于 options WITNESS 。

• options SOCKBUF_DEBUG ：对套接字缓冲区执行广泛的运行时一致性检查，这对于调试套接字错误和协议以及与套接字交互的设备驱动程序中的竞争条件非常有用。此选项显著影响网络性能，并可能改变设备驱动程序竞争中的时序。

• options DEBUG_VFS_LOCKS ：跟踪锁管理器/ vnode 锁的锁获取点，扩展了 DDB 中显示的信息量。此选项会对性能产生可衡量的影响。

• options DEBUG_MEMGUARD ：malloc(9) 内核内存分配器的替代品，使用 VM 系统来检测释放后分配内存的读取或写入。详细信息可在 memguard(9) 中找到。此选项会产生显著的性能影响，但在调试内核内存损坏错误时非常有帮助。

• options DIAGNOSTIC ：启用额外的、更昂贵的诊断测试，沿着 options INVARIANTS 的方向。

• options KASAN ：启用内核地址消毒剂。这将启用编译器插桩，可用于检测内核中的无效内存访问，如释放后使用和缓冲区溢出。这在很大程度上取代了 options DEBUG_MEMGUARD 。有关详细信息，请参阅 kasan(9)，以及当前支持的平台。

• options KMSAN ：启用内核内存消毒剂。这将启用编译器插桩，可用于检测未初始化内存的使用。有关详细信息，请参阅 kmsan(9)，以及当前支持的平台。

8.1 IPv6/IPsec 实施

本节应解释与 IPv6 和 IPsec 相关的实现内部。这些功能源自 KAME 项目

8.1.1. IPv6

8.1.1.1. 一致性

IPv6 相关功能符合或试图符合最新的 IPv6 规范集。为了以后参考，我们列出以下一些相关文件（注意：这不是一个完整的列表——这太难维护了……）。

详情请参阅文档中的具体章节、RFCs、手册页面或源代码中的注释。

在 KAME 稳定套件上进行了符合性测试，结果可以在 TAHI 项目的网站上查看。我们过去也参加过新罕布什尔大学 IOL 测试（http://www.iol.unh.edu/），使用我们以前的快照。

• RFC1639：FTP 大地址记录上的操作（FOOBAR）

  • RFC2428 优先于 RFC1639。FTP 客户端将首先尝试 RFC2428，如果失败则尝试 RFC1639。

• RFC1886：支持 IPv6 的 DNS 扩展

• RFC1933：IPv6 主机和路由器的过渡机制

  • 不支持 IPv4 兼容地址。

  • 不支持自动隧道（RFC 中第 4.3 节描述）。

  • gif(4)接口以通用方式实现 IPv[46]隧道，并涵盖规范中描述的"配置隧道"。有关详细信息，请参见本文档中的 23.5.1.5。

• RFC1981：IPv6 的路径 MTU 发现

• RFC2080：IPv6 的 RIPng

  • usr.sbin/route6d 支持此功能。

• RFC2292：IPv6 的高级套接字 API

  • 有关支持的库函数/内核 API，请参阅 sys/netinet6/ADVAPI。

• RFC2362：协议无关组播-稀疏模式（PIM-SM）

  • RFC2362 定义了 PIM-SM 的数据包格式。draft-ietf-pim-ipv6-01.txt 是基于这个协议编写的。

• RFC2373：IPv6 地址架构

  • 支持节点必需地址，并符合范围要求。

• RFC2374：IPv6 可聚合全局单播地址格式

  • 支持 64 位接口 ID 长度。

• RFC2375：IPv6 组播地址分配

  • 用户态应用程序使用 RFC 中分配的知名地址。

• RFC2428：IPv6 和 NAT 的 FTP 扩展

  • RFC2428 优先于 RFC1639。FTP 客户端首先尝试 RFC2428，如果失败则尝试 RFC1639。

• RFC2460：IPv6 规范

• RFC2461：IPv6 邻居发现

  • 查看本文档中的 23.5.1.2 节以获取详细信息。

• RFC2462：IPv6 无状态地址自动配置

  • 查看本文档中的 23.5.1.4 节以获取详细信息。

• RFC2463：IPv6 规范的 ICMPv6

  • 有关详细信息，请参阅本文档中的 23.5.1.9。

• RFC2464：在以太网网络上传输 IPv6 数据包

• RFC2465：IPv6 的 MIB：文本约定和通用组

  • 必要的统计数据由内核收集。实际的 IPv6 MIB 支持作为 ucd-snmp 的补丁包提供。

• RFC2466：IPv6 的 MIB：ICMPv6 组

  • 内核收集必要的统计数据。 实际的 IPv6 MIB 支持作为 ucd-snmp 的补丁包提供。

• RFC2467：在 FDDI 网络上传输 IPv6 数据包

• RFC2497：在 ARCnet 网络上传输 IPv6 数据包

• RFC2553：IPv6 的基本套接字接口扩展

  • IPv4 映射地址（3.7）和 IPv6 通配符绑定套接字（3.8）的特殊行为都受支持。详情请参阅本文档中的 23.5.1.12。

• RFC2675：IPv6 巨字节

  • 查看本文档中的 23.5.1.7 以获取详细信息。

• RFC2710：IPv6 的组播监听者发现

• RFC2711：IPv6 路由器警报选项

• IPv6 路由器重新编号

• 通过 ICMP 进行 IPv6 名称查找

• 通过 ICMP 进行 IPv6 名称查找

• draft-ietf-pim-ipv6-01.txt：IPv6 的 PIM

  • pim6dd(8)实现密集模式。pim6sd(8)实现稀疏模式。

• draft-itojun-ipv6-tcp-to-anycast-00：断开面向 IPv6 任播地址的 TCP 连接

• 草案 yamamoto-wideipv6-comm-model-00

  • 有关详细信息，请参阅本文档中的 23.5.1.6。

• draft-ietf-ipngwg-scopedaddr-format-00.txt：IPv6 范围地址格式的扩展

8.1.1.2. 邻居发现

邻居发现相当稳定。当前支持地址解析、重复地址检测和邻居不可达检测。在不久的将来，我们将在内核中添加代理邻居通告支持，并作为管理员工具添加不经请求的邻居通告传输命令。

如果重复地址检测失败，地址将被标记为“重复”，并生成消息到系统日志（通常也会到控制台）。管理员有责任检查并从重复地址检测失败中恢复。未来应该改进这种行为。

有些网络驱动程序会将多播数据包环回到自身，即使被指示不这样做（特别是在混杂模式下）。在这种情况下，DAD 可能会失败，因为 DAD 引擎看到入站的 NS 数据包（实际上来自节点本身），并将其视为重复的标志。您可能希望查看 sys/netinet6/nd6_nbr.c:nd6_dad_timer() 中标记为“启发式”条件的 #if 语句作为解决方法（请注意，“启发式”部分中的代码片段不符合规范）。

邻居发现规范（RFC2461）未涉及以下情况中的邻居缓存处理：

1. 当没有邻居缓存条目时，节点收到了未经请求的 RS/NS/NA/重定向数据包而没有链路层地址

2. 在没有链路层地址的中介上处理邻居缓存（我们需要一个带有 IsRouter 位的邻居缓存条目）

对于第一种情况，我们根据 IETF ipngwg 邮件列表上的讨论实施了基于临时解决方案。有关详细信息，请参阅源代码中的注释和从（IPng 7155）开始的电子邮件线程，日期为 1999 年 2 月 6 日。

IPv6 的本地链路确定规则（RFC2461）与 BSD 网络代码中的假设有很大不同。目前，不支持当默认路由器列表为空时的本地链路确定规则（RFC2461，第 5.2 节，第二段的最后一句 - 请注意，规范在该节中在几个地方误用了“主机”和“节点”这两个词）。

为避免可能的 DoS 攻击和无限循环，现在仅接受 ND 数据包上的 10 个选项。因此，如果您有 20 个前缀选项附加到 RA 上，只有前 10 个前缀将被识别。如果这给您带来麻烦，请在 FREEBSD-CURRENT 邮件列表上提出，并/或修改 sys/netinet6/nd6.c 中的 nd6_maxndopt。如果有很高的需求，我们可能会为该变量提供 sysctl 旋钮。

8.1.1.3. 范围索引

IPv6 使用范围地址。因此，对于 IPv6 地址，指定范围索引（链路本地地址的接口索引，或站点本地地址的站点索引）非常重要。没有范围索引，范围 IPv6 地址对内核来说是模棱两可的，内核将无法确定数据包的出站接口。

普通用户空间应用程序应使用高级 API（RFC2292）来指定范围索引或接口索引。为了类似的目的，在 sockaddr_in6 结构中定义了 sin6_scope_id 成员，该结构在 RFC2553 中定义。然而，对于 sin6_scope_id 的语义相当模糊。如果您关心应用程序的可移植性，我们建议您使用高级 API 而不是 sin6_scope_id。

在内核中，用于链路本地范围地址的接口索引嵌入到 IPv6 地址的第 2 个 16 位字（第 3 个和第 4 个字节）中。例如，您可能会看到类似以下内容：

	fe80:1::200:f8ff:fe01:6317

在路由表和接口地址结构（struct in6_ifaddr）中。上面的地址是一个属于接口标识符为 1 的网络接口的链路本地单播地址。嵌入的索引使我们能够有效地识别多个接口上的 IPv6 链路本地地址，并且只需进行少量代码更改。

路由守护程序和配置程序，如 route6d(8) 和 ifconfig(8)，需要操作 "嵌入式" 范围索引。这些程序使用路由套接字和 ioctls（如 SIOCGIFADDR_IN6），内核 API 将返回填入第二个 16 位字的 IPv6 地址。这些 API 用于操作内核的内部结构。使用这些 API 的程序必须准备处理内核版本之间的差异。

当您在命令行中指定范围地址时，永远不要写入嵌入式形式（例如 ff02:1::1 或 fe80:2::fedc）。这不应该起作用。始终使用标准形式，例如 ff02::1 或 fe80::fedc，并使用命令行选项来指定接口（例如 ping -6 -I ne0 ff02::1 ）。通常，如果一个命令没有命令行选项来指定出口接口，那么该命令就没有准备好接受范围地址。这可能与 IPv6 支持 "牙医诊所" 情况的前提相反。我们认为，规范需要一些改进。

一些用户空间工具支持扩展的数值 IPv6 语法，如 draft-ietf-ipngwg-scopedaddr-format-00.txt 中所述。您可以通过使用出口接口的名称，例如 "fe80::1%ne0"，来指定出口链路。这样，您就能够轻松地指定链路本地范围的地址。

要在程序中使用这个扩展，你需要使用 getaddrinfo(3) 和带有 NI_WITHSCOPEID 的 getnameinfo(3)。目前的实现假设链路和接口之间存在 1 对 1 的关系，这比规范所要求的更严格。

8.1.1.4. 即插即用

大多数 IPv6 无状态地址自动配置是在内核中实现的。邻居发现功能作为一个整体在内核中实现。主机的路由器通告 (RA) 输入在内核中实现。终端主机的路由器请求 (RS) 输出、路由器的 RS 输入以及路由器的 RA 输出是在用户空间中实现的。

8.1.1.4.1. 链路局域网和特殊地址的分配

IPv6 链路局域网地址是根据 IEEE802 地址（以太网 MAC 地址）生成的。每个接口在变为上行接口（IFF_UP）时会自动分配一个 IPv6 链路局域网地址。此外，链路局域网地址的直接路由也会添加到路由表中。

这是 netstat 命令的输出：

Internet6:
Destination                   Gateway                   Flags      Netif Expire
fe80:1::%ed0/64               link#1                    UC          ed0
fe80:2::%ep0/64               link#2                    UC          ep0

无 IEEE802 地址的接口（伪接口如隧道接口或 ppp 接口）将尝试从其他接口（如以太网接口）借用 IEEE802 地址。如果没有附加 IEEE802 硬件，将使用最后的备选伪随机值 MD5(hostname) 作为链路本地地址的来源。如果这对您的使用不适合，您将需要手动配置链路本地地址。

如果接口无法处理 IPv6（如缺乏组播支持），则不会为该接口分配链路本地地址。详细信息请参阅第 2 节。

每个接口都加入了被请求的多播地址和链路本地所有节点多播地址（例如，fe80::1:ff01:6317 和 ff02::1，在接口所连接的链路上）。除了链路本地地址之外，环回地址（::1）将被分配给环回接口。此外，::1/128 和 ff01::/32 会自动添加到路由表中，环回接口还加入了节点本地多播组 ff01::1。

主机上的无状态地址自动配置

在 IPv6 规范中，节点分为两类：路由器和主机。路由器转发发送给其他节点的数据包，主机不转发数据包。net.inet6.ip6.forwarding 定义了该节点是路由器还是主机（如果为 1，则为路由器；如果为 0，则为主机）。

当主机从路由器那里收到路由器通告时，主机可以通过无状态地址自动配置来自动配置自身。此行为可以通过 net.inet6.ip6.accept_rtadv 来控制（如果设置为 1，则主机会自动配置自身）。通过自动配置，接收接口的网络地址前缀（通常是全局地址前缀）被添加。默认路由也被配置。路由器定期生成路由器通告数据包。要请求相邻路由器生成 RA 数据包，主机可以发送路由器请求。要随时生成 RS 数据包，请使用 rtsol 命令。也可以使用 rtsold(8)守护程序。rtsold(8)在必要时生成路由器请求，并且非常适合移动使用（笔记本电脑）。如果希望忽略路由器通告，请使用 sysctl 将 net.inet6.ip6.accept_rtadv 设置为 0。

从路由器生成路由器通告，请使用 rtadvd(8)守护程序。

请注意，IPv6 规范假定以下项目，不符合规范的情况未指定：

• 只有主机会收听路由器通告

• 主机只有单个网络接口（除回环接口外）

因此，在路由器或多接口主机上启用 net.inet6.ip6.accept_rtadv 是不明智的。配置错误的节点可能表现出奇怪的行为（允许不符合规范的配置，适合那些希望进行一些实验的人）。

总结一下 sysctl 开关：

	accept_rtadv	forwarding	role of the node
	---		---		---
	0		0		host (to be manually configured)
	0		1		router
	1		0		autoconfigured host
					(spec assumes that host has single
					interface only, autoconfigured host
					with multiple interface is
					out-of-scope)
	1		1		invalid, or experimental
					(out-of-scope of spec)

RFC2462 对传入 RA 前缀信息选项的验证规则在 5.5.3（e）中。这是为了保护主机免受恶意（或配置错误）路由器广告非常短的前缀生存期。Jim Bound 向 ipngwg 邮件列表进行了更新（在存档中查找“(ipng 6712)”），并实施了 Jim 的更新。

查看文档中的 23.5.1.2，了解 DAD 与自动配置之间的关系。

8.1.1.5. 通用隧道接口

GIF（通用接口）是用于配置隧道的伪接口。详细信息请参阅 gif(4)。当前

• v6 in v6

• v6 in v4

• 在 v6 中的 v4

• 在 v4 中的 v4

可用。使用 gifconfig(8)为 gif 接口分配物理（外部）源和目标地址。在内部和外部 IP 头部使用相同地址族（v4 中的 v4，或 v6 中的 v6）的配置是危险的。很容易配置接口和路由表以执行无限级别的隧道。请注意。

gif 可以配置为 ECN-friendly。请查看章节 23.5.4.5 了解隧道的 ECN-friendly 设置，以及如何配置 gif(4)。

如果您想要使用 gif 接口配置一个 IPv4-in-IPv6 隧道，请仔细阅读 gif(4)。您需要自动删除分配给 gif 接口的 IPv6 链路本地地址。

8.1.1.6. 源地址选择

当前的源选择规则是面向范围的（有一些例外情况-请参见下文）。 对于给定的目的地，将通过以下规则选择源 IPv6 地址：

1. 如果用户明确指定了源地址（例如，通过高级 API），则使用指定的地址。

2. 如果对于外发接口分配了一个具有与目的地地址相同范围的地址（通常通过查找路由表确定），则使用该地址。 这是最典型的情况。

3. 如果没有满足上述条件的地址，请选择发送节点上一个接口分配的全局地址。

4. 如果没有满足上述条件的地址，并且目标地址是站点本地范围，请选择发送节点上一个接口分配的站点本地地址。

5. 如果没有满足上述条件的地址，请选择与目标的路由表条目关联的地址。这是最后的手段，可能会导致范围违规。

例如，对于 ff01::1，为 fe80:1::2a0:24ff:feab:839b 选择 fe80:1::200:f8ff:fe01:6317（请注意，嵌入式接口索引 - 描述在 23.5.1.3 中 - 帮助我们选择正确的源地址。这些嵌入索引不会传输到网络）。如果出站接口具有适用于范围的多个地址，则根据最长匹配原则选择源地址（规则 3）。假设出站接口提供了 2001:0DB8:808:1:200:f8ff:fe01:6317 和 2001:0DB8:9:124:200:f8ff:fe01:6317。将选择 2001:0DB8:808:1:200:f8ff:fe01:6317 作为目标 2001:0DB8:800::1 的源。

请注意，上述规则未在 IPv6 规范中记录。它被视为“由实现决定”的项目。有些情况下，我们不遵循上述规则。一个例子是连接的 TCP 会话，我们使用在 tcb 中保存的地址作为源地址。另一个例子是 Neighbor Advertisement 的源地址。根据规范（RFC2461 7.2.2），NA 的源地址应该是相应 NS 的目标地址。在这种情况下，我们遵循规范而不是上述最长匹配规则。

对于新连接（不适用规则 1 时），如果有其他选择可用，则不会选择已弃用地址（首选生存时间=0）作为源地址。如果没有其他选择可用，则废弃地址将被用作最后的选择。如果有多个废弃地址可选，则将使用上述范围规则从这些废弃地址中进行选择。如果出于某种原因希望禁止使用废弃地址，请将 net.inet6.ip6.use_deprecated 配置为 0。有关废弃地址的问题在 RFC2462 5.5.4 中有描述（注意：IETF ipngwg 正在就如何使用“废弃”地址进行一些讨论）。

8.1.1.7. 巨型负载

巨型负载逐跳选项已实现，并可用于发送载荷超过 65,535 八位组的 IPv6 数据包。但目前不支持 MTU 超过 65,535 的物理接口，因此这样的负载只能在环回接口（即 lo0）上看到。

如果您想尝试巨型负载，首先必须重新配置内核，使环回接口的 MTU 超过 65,535 字节；将以下内容添加到内核配置文件中：

options "LARGE_LOMTU" #To test jumbo payload

然后重新编译新内核。

然后，您可以使用 ping(8) 命令的 -6、-b 和 -s 选项来测试巨型负载。必须指定 -b 选项以扩大套接字缓冲区的大小，-s 选项指定数据包的长度，应大于 65,535。例如，输入以下命令：

% ping -6 -b 70000 -s 68000 ::1

IPv6 规范要求巨型负载选项不能用于携带片段头的数据包中。如果违反此条件，将向发送方发送 ICMPv6 参数问题消息。虽然遵循规范，但通常不会因此要求导致 ICMPv6 错误消息。

当接收到一个 IPv6 包时，会检查帧长度并将其与 IPv6 报头中的有效载荷长度字段或 Jumbo Payload 选项中的值（如果有的话）进行比较。如果前者短于后者，则丢弃该包并增加统计数据。你可以使用 -s -p ip6 选项查看 netstat(8)命令的输出统计数据：

% netstat -s -p ip6
	  ip6:
		(snip)
		1 with data size < data length

因此，除非错误的数据包是真正的 Jumbo Payload，即其数据包大小超过 65,535 字节，否则内核不会发送 ICMPv6 错误。如上所述，目前不支持具有如此巨大 MTU 的物理接口，因此很少返回 ICMPv6 错误。

目前不支持 TCP/UDP over jumbogram。这是因为我们没有介质（除了回环）来测试这个。如果你需要这个功能，请联系我们。

IPsec 不能在超大数据包上工作。这是由于支持 AH 的规范扭曲所致，在使用超大数据包时 AH 头的大小会影响有效载荷长度，这使得验证传入带有超大有效载荷选项的数据包变得非常困难。

*BSD 对超大数据包的支持存在基本问题。我们希望解决这些问题，但我们需要更多时间来完成。举几个例子：

• 在 4.4BSD 中，mbuf pkthdr.len 字段被类型化为"int"，因此在 32 位架构 CPU 上，它将无法容纳长度> 2G 的超大数据包。如果我们希望正确地支持超大数据包，该字段必须扩展以容纳 4G + IPv6 头 + 链路层头。因此，它必须扩展至至少 int64_t（u_int32_t 是不够的）。

• 我们错误地在许多地方使用"int"来保存数据包长度。我们需要将它们转换为更大的整数类型。需要非常小心，因为在计算数据包长度时可能会发生溢出。

• 我们错误地在各个地方检查 IPv6 头部的 ip6_plen 字段作为数据包有效载荷长度。我们应该检查 mbuf pkthdr.len。ip6_input()将在输入时对巨大有效载荷选项执行完整性检查，之后我们可以安全地使用 mbuf pkthdr.len。

• TCP 代码需要在很多地方进行仔细更新，当然。

8.1.1.8. 头部处理中的环路预防

IPv6 规范允许将任意数量的扩展标头放置在数据包上。 如果我们以 BSD IPv4 代码的方式实现 IPv6 数据包处理代码，则由于函数调用链过长，内核堆栈可能会溢出。 sys/netinet6 代码经过精心设计以避免内核堆栈溢出，因此 sys/netinet6 代码定义了自己的协议开关结构，称为"netinet6/ip6protosw.h"中的"struct ip6protosw"。 对于与 IPv4 部分（sys/netinet）兼容性的更新，没有进行这样的更新，但在其 pr_input()原型中添加了小更改。 因此，如果接收到具有大量 IPsec 标头的 IPsec-over-IPv4 数据包，则内核堆栈可能会崩溃。 IPsec-over-IPv6 没问题。 （当然，要处理所有这些 IPsec 标头，每个 IPsec 标头都必须通过每个 IPsec 检查。 因此，匿名攻击者将无法执行此类攻击。）

8.1.1.9. ICMPv6

RFC2463 发布后，IETF ipngwg 已决定禁止针对 ICMPv6 重定向的 ICMPv6 错误数据包，以防止网络介质上的 ICMPv6 风暴。这已经实现在内核中。

8.1.1.10. 应用程序

对于用户空间编程，我们支持 RFC2553、RFC2292 和即将发布的互联网草案中规定的 IPv6 套接字 API。

TCP/UDP over IPv6 is available and quite stable. You can enjoy telnet(1), ftp(1), rlogin(1), rsh(1), ssh(1), etc. These applications are protocol independent. That is, they automatically chooses IPv4 or IPv6 according to DNS.

8.1.1.11. Kernel Internals

While ip_forward() calls ip_output(), ip6_forward() directly calls if_output() since routers must not divide IPv6 packets into fragments.

ICMPv6 应尽可能包含原始数据包，最大长度为 1280 字节。例如，UDP6/IP6 不可达错误应包含所有扩展头部和未更改的 UDP6 和 IP6 头部。因此，除 TCP 外，所有 IP6 功能均不将网络字节顺序转换为主机字节顺序，以保存原始数据包。

tcp_input()、udp6_input() 和 icmp6_input() 不能假设 IP6 头部紧随传输头部之后，因为存在扩展头部。因此，in6_cksum() 被实现用于处理 IP6 头部和传输头部不连续的数据包。TCP/IP6 和 UDP6/IP6 头部结构不存在于校验和计算中。

为了更轻松地处理 IP6 头部、扩展头部和传输头部，网络驱动程序现在要求将数据包存储在一个或多个内部 mbuf 中。典型的旧驱动程序为 96 到 204 字节的数据准备两个内部 mbuf，但现在此类数据包数据存储在一个外部 mbuf 中。

netstat -s -p ip6 告诉您您的驱动程序是否符合此要求。在以下示例中，“cce0” 违反了该要求。（有关更多信息，请参阅第 2 节。）

Mbuf statistics:
                317 one mbuf
                two or more mbuf::
                        lo0 = 8
			cce0 = 10
                3282 one ext mbuf
                0 two or more ext mbuf

每个输入函数在开始时调用 IP6_EXTHDR_CHECK 来检查 IP6 和其标头之间的区域是否连续。IP6_EXTHDR_CHECK 仅在 mbuf 具有 M_LOOP 标志时调用 m_pullup()，也就是说，数据包来自环回接口。对于来自物理网络接口的数据包，永远不会调用 m_pullup()。

IP 和 IP6 的重组函数从不调用 m_pullup()。

8.1.1.12. IPv4 映射地址和 IPv6 通配符套接字

RFC2553 描述了 IPv4 映射地址（3.7）和 IPv6 通配符绑定套接字（3.8）的特殊行为。规范允许您：

• 通过 AF_INET6 通配符绑定套接字接受 IPv4 连接。

• 通过使用类似 ::ffff:10.1.1.1 的特殊地址形式在 AF_INET6 套接字上传输 IPv4 数据包。

但规范本身非常复杂，并未指定套接字层应如何行为。在这里，我们将前者称为“监听端”，将后者称为“发起端”，供参考之用。

您可以在相同的 port 上为两个地址族执行通配符绑定。

以下表格显示 FreeBSD 4.x 的行为。

listening side          initiating side
                (AF_INET6 wildcard      (connection to ::ffff:10.1.1.1)
                socket gets IPv4 conn.)
                ---                     ---
FreeBSD 4.x     configurable            supported
                default: enabled

以下各节将为您提供更多详细信息，以及如何配置行为。

关于监听端的评论：

看起来 RFC2553 对通配符绑定问题讨论得太少，特别是在port空间问题、故障模式和 AF_INET/INET6 通配符绑定之间的关系方面。对于这个 RFC 可能会有几种不同的解释，符合它但行为不同。因此，为了实现可移植的应用程序，您应该不假思索地假定内核的行为。使用 getaddrinfo(3)是最安全的方式。Port号空间和通配符绑定问题在 ipv6imp 邮件列表中详细讨论过，1999 年 3 月中旬，看起来没有明确的共识（即，直到实现者）。您可能想要查看邮件列表存档。

如果服务器应用程序希望接受 IPv4 和 IPv6 连接，将有两种选择。

一种是使用 AF_INET 和 AF_INET6 套接字（您将需要两个套接字）。使用 getaddrinfo(3)将 AI_PASSIVE 传递给 ai_flags，并使用 socket(2)和 bind(2)绑定返回的所有地址。通过打开多个套接字，您可以接受具有适当地址族的套接字的连接。IPv4 连接将由 AF_INET 套接字接受，IPv6 连接将由 AF_INET6 套接字接受。

另一种方法是使用一个 AF_INET6 通配符绑定套接字。使用 getaddrinfo(3)将 AI_PASSIVE 置入 ai_flags，并将 AF_INET6 置入 ai_family，并将第一个参数主机名设置为 NULL。然后使用 socket(2)和 bind(2)绑定返回的地址。（应为 IPv6 未指定地址）。您可以通过这一个套接字接受 IPv4 和 IPv6 数据包。

为了支持在 AF_INET6 通配符绑定套接字上仅支持 IPv6 流量，始终在向 AF_INET6 监听套接字发起连接时检查对等地址。如果地址是 IPv4 映射地址，则可能希望拒绝连接。可以使用 IN6_IS_ADDR_V4MAPPED()宏来检查条件。

为了更容易解决这个问题，有一个系统相关的 setsockopt(2)选项，IPV6_BINDV6ONLY，使用如下。

	int on;

	setsockopt(s, IPPROTO_IPV6, IPV6_BINDV6ONLY,
		   (char *)&on, sizeof (on)) < 0));

当此调用成功时，此套接字只接收 IPv6 数据包。

关于启动方面的评论：

给应用程序实现者的建议：为了实现一个可移植的 IPv6 应用程序（可在多个 IPv6 内核上运行），我们认为以下是成功的关键：

• 绝不要在代码中硬编码 AF_INET 或 AF_INET6。

• 在整个系统中使用 getaddrinfo(3) 和 getnameinfo(3)。永远不要使用 gethostby()、getaddrby()、inet_() 或 getipnodeby()。（为了轻松地使现有应用程序具备 IPv6 意识，有时 getipnodeby*() 会很有用。但如果可能的话，尽量重写代码以使用 getaddrinfo(3) 和 getnameinfo(3)。）

• 如果希望连接到目的地，请使用 getaddrinfo(3) 并尝试连接返回的所有目的地，就像 telnet(1) 一样。

• 一些 IPv6 堆栈带有有缺陷的 getaddrinfo(3)。将一个与您的应用程序一起提供的最小工作版本，并将其作为最后手段使用。

如果您想要为 IPv4 和 IPv6 的出站连接都使用 AF_INET6 套接字，您将需要使用 getipnodebyname(3)。当您希望尽可能少的工作将现有应用程序升级为 IPv6 兼容时，可能会选择这种方法。但请注意，这只是一个临时解决方案，因为 getipnodebyname(3)本身并不推荐，因为它根本不处理范围 IPv6 地址。对于 IPv6 名称解析，getaddrinfo(3)是首选的 API。因此，当您有时间这样做时，应重写您的应用程序以使用 getaddrinfo(3)。

在编写制作输出连接的应用程序时，如果您将 AF_INET 和 AF_INET6 视为完全独立的地址族，那么整个故事就会简单得多。{set,get}sockopt 问题会更简单，DNS 问题也会变得更简单。我们不建议您依赖 IPv4 映射地址。

8.1.1.12.1. 统一的 tcp 和 inpcb 代码

FreeBSD 4.x 在 IPv4 和 IPv6 之间使用共享的 tcp 代码（来自 sys/netinet/tcp*），并使用单独的 udp4/6 代码。 它使用统一的 inpcb 结构。

可以配置平台以支持 IPv4 映射地址。 内核配置总结如下：

• 通过默认，AF_INET6 套接字在某些条件下会获取 IPv4 连接，并可以发起连接到 IPv4 目的地中的 IPv4 映射 IPv6 地址。

• 您可以像下面这样在整个系统上禁用它的 sysctl。

8.1.1.12.1.1. 监听端

每个套接字都可以配置为支持特殊的 AF_INET6 通配符绑定（默认情况下已启用）。您可以像下面这样在每个套接字上禁用它。

	int on;

	setsockopt(s, IPPROTO_IPV6, IPV6_BINDV6ONLY,
		   (char *)&on, sizeof (on)) < 0));

通配符 AF_INET6 套接字仅在满足以下条件时抓取 IPv4 连接：

• 没有与 IPv4 连接匹配的 AF_INET 套接字。

• AF_INET6 套接字配置为接受 IPv4 流量，即 getsockopt(IPV6_BINDV6ONLY)返回 0。

打开/关闭顺序没有问题。

8.1.1.12.1.2. 启动端

FreeBSD 4.x 支持对 IPv4 映射地址(::ffff:10.1.1.1)的传出连接，如果节点配置为支持 IPv4 映射地址。

8.1.1.13. sockaddr_storage

当 RFC2553 即将最终确定时，关于如何命名 struct sockaddr_storage 成员进行了讨论。一个提议是在成员前面加上空格(如" ss_len")，因为它们不应该被修改。另一个提议是不加空格(如"ss_len")，因为我们需要直接访问这些成员。对此并没有明确的共识。

结果，RFC2553 如下定义结构 sockaddr_storage：

	struct sockaddr_storage {
		u_char	__ss_len;	/* address length */
		u_char	__ss_family;	/* address family */
		/* and bunch of padding */
	};

相反，XNET 草案如下定义：

	struct sockaddr_storage {
		u_char	ss_len;		/* address length */
		u_char	ss_family;	/* address family */
		/* and bunch of padding */
	};

1999 年 12 月达成共识，RFC2553bis 应选择后者（XNET）的定义。

当前实现符合 XNET 定义，基于 RFC2553bis 讨论。

如果你查看多个 IPv6 实现，你将能够看到两种定义。作为一个用户态程序员，最便捷的处理方式是：

1. 通过使用 GNU autoconf 确保 ss_family 和/或 ss_len 在平台上可用。

2. 将-Dss_family=ss_family 统一所有出现的地方（包括头文件）为 ss_family，或

3. 永远不要触碰__ss_family。转换为 sockaddr *并使用 sa_family，如：

   复制

   	struct sockaddr_storage ss;
   	family = ((struct sockaddr *)&ss)->sa_family

8.1.2. 网络驱动程序

现在，标准驱动程序需要支持以下两个项目:

1. mbuf 集群要求。在此稳定版本中，我们将 MINCLSIZE 更改为 MHLEN+1，以便使所有驱动程序的行为符合我们的预期。

2. 多播。如果 ifmcstat(8)未为接口提供任何多播组，则必须对该接口进行打补丁。

如果任何驱动程序不支持要求，则这些驱动程序不能用于 IPv6 和/或 IPsec 通信。如果您发现使用 IPv6/IPsec 时遇到任何问题，请将其报告给 FreeBSD 问题报告邮件列表。

（注意：过去我们要求所有 PCMCIA 驱动程序调用 in6_ifattach()。我们不再有此要求）

8.1.3. 翻译器

我们将 IPv4/IPv6 转换器分类为 4 种类型：

• 转换器 A --- 它用于过渡的早期阶段，使得从 IPv6 岛屿中的 IPv6 主机到 IPv4 海洋中的 IPv4 主机建立连接成为可能。

• 转换器 B --- 它用于过渡的早期阶段，使得从 IPv4 海洋中的 IPv4 主机到 IPv6 岛屿中的 IPv6 主机建立连接成为可能。

• 翻译者 C --- 它用于过渡的后期阶段，使得在 IPv4 岛中的 IPv4 主机与 IPv6 海洋中的 IPv6 主机建立连接成为可能。

• 翻译者 D --- 它用于过渡的后期阶段，使得在 IPv6 海洋中的 IPv6 主机与 IPv4 岛中的 IPv4 主机建立连接成为可能。

8.1.4. IPsec

IPsec 主要由三个组件组织。

1. 策略管理

2. 密钥管理

3. AH 和 ESP 处理

8.1.4.1. 策略管理

内核实现了实验性的策略管理代码。有两种管理安全策略的方式。一种是使用 setsockopt(2) 配置每个套接字的策略。在这种情况下，策略配置在 ipsec_set_policy(3) 中描述。另一种方式是使用 PF_KEY 接口配置基于内核数据包过滤器的策略，通过 setkey(8)。

策略条目未按索引重新排序，因此在添加时条目的顺序非常重要。

8.1.4.2. 密钥管理

此工具包中实现的密钥管理代码（sys/netkey）是自制的 PFKEY v2 实现。这符合 RFC2367。

用于 IPsec 协议的自制 IKE 守护程序"racoon"已包含在套件中（kame/kame/racoon）。基本上，您需要将 racoon 作为守护程序运行，然后设置一个需要密钥的策略（如 ping -P 'out ipsec esp/transport//use' ）。内核将根据需要与 racoon 守护程序联系以交换密钥。

8.1.4.3. AH 和 ESP 处理

IPsec 模块实现为标准 IPv4/IPv6 处理的“钩子”。在发送数据包时，ip{,6}_output()会检查是否需要进行 ESP/AH 处理，方法是检查是否找到匹配的 SPD（安全策略数据库）。如果需要 ESP/AH，将调用{esp,ah}{4,6}_output()，并相应更新 mbuf。在接收数据包时，将根据协议号调用{esp,ah}4_input()，即(*inetsw[proto])()。{esp,ah}4_input()将对数据包进行解密/验证其真实性，并为 ESP/AH 去除级联的标头和填充。在数据包接收时安全地去除 ESP/AH 标头是安全的，因为我们永远不会原样使用接收到的数据包。

通过使用 ESP/AH，TCP4/6 的有效数据段大小将受到 ESP/AH 插入的额外级联标头的影响。我们的代码会处理这种情况。

基本加密函数可以在目录"sys/crypto"中找到。ESP/AH 转换在{esp,ah}_core.c 中列出了包装函数。如果您希望添加一些算法，请在{esp,ah}_core.c 中添加包装函数，并将您的加密算法代码添加到 sys/crypto 中。

隧道模式在此版本中部分受支持，有以下限制：

• IPsec 隧道未与 GIF 通用隧道接口结合。这需要非常小心，因为我们可能会在 ip_output()和 tunnelifp→if_output()之间创建一个无限循环。关于统一它们是否更好，意见各不相同。

• MTU 和不分段比特（IPv4）的考虑需要更多检查，但基本上工作正常。

• AH 隧道的认证模型必须重新审视。我们将需要改进策略管理引擎，最终。

8.1.4.4. RFC 和 ID 的符合性

The IPsec code in the kernel conforms (or, tries to conform) to the following standards:

"old IPsec" specification documented in rfc182[5-9].txt

在 rfc240[1-6].txt、rfc241[01].txt、rfc2451.txt 和 draft-mcdonald-simple-ipsec-api-01.txt（草案已过期，但您可以从 ftp://ftp.kame.net/pub/internet-drafts/下载）中记录了新 IPsec 规范。 （注意：IKE 规范，rfc241[7-9].txt 在用户空间中实现为"racoon" IKE 守护程序）

目前支持的算法有：

• 旧 IPsec AH

  • 空 crypto 校验和（无文档，仅用于调试）

  • 带有 128 位 crypto 校验和的 keyed MD5（rfc1828.txt）

  • 带有 128 位 crypto 校验和的 keyed SHA1（无文档）

  • HMAC MD5 具有 128 位加密校验和 (rfc2085.txt)

  • HMAC SHA1 具有 128 位加密校验和 (没有文档)

• 旧的 IPsec ESP

  • 空加密（无文档，类似于 rfc2410.txt）

  • DES-CBC 模式（rfc1829.txt）

• 新 IPsec AH

  • 空的加密校验和（无文档，仅用于调试）

  • 带 96 位加密校验和的密钥 MD5（无文档）

  • 带 96 位加密校验和的密钥 SHA1（无文档）

  • 带有 96 位加密校验和的 HMAC MD5 (rfc2403.txt)

  • 带有 96 位加密校验和的 HMAC SHA1 (rfc2404.txt)

• 新的 IPsec ESP

  • 空加密（rfc2410.txt）

  • 带派生 IV 的 DES-CBC（draft-ietf-ipsec-ciph-des-derived-01.txt，草案已过期）

  • 带明确 IV 的 DES-CBC（rfc2405.txt）

  • 用明文 IV 的 3DES-CBC（rfc2451.txt）

  • BLOWFISH CBC（rfc2451.txt）

  • CAST128 CBC（rfc2451.txt）

  • RC5 CBC（rfc2451.txt）

  • 可以与上述每一个结合：

    • 使用 HMAC-MD5（96 位）的 ESP 认证

    • ESP 使用 HMAC-SHA1(96 位)进行身份验证

不支持以下算法:

• 老旧的 IPsec AH

  • HMAC MD5 带 128 位密码校验和+64 位重放预防（rfc2085.txt）

  • 带 160 位密码校验和的密钥 SHA1+32 位填充（rfc1852.txt）

IPsec（在内核中）和 IKE（在用户空间中作为"racoon"）已在多个互操作性测试活动中进行了测试，并且已知与许多其他实现很好地互操作。此外，当前的 IPsec 实现对 RFC 中记录的 IPsec 密码算法具有相当广泛的覆盖范围（我们仅涵盖没有知识产权问题的算法）。

8.1.4.5. IPsec 隧道上的 ECN 考虑

支持与 draft-ipsec-ecn-00.txt 中描述的 ECN 友好的 IPsec 隧道。

RFC2401 中描述了普通的 IPsec 隧道。在封装时，IPv4 的 TOS 字段（或 IPv6 的流量类字段）将从内部 IP 头复制到外部 IP 头。在解封装时，外部 IP 头将被简单丢弃。解封装规则与 ECN 不兼容，因为外部 IP 的 TOS/流量类字段上的 ECN 位将丢失。

要使 IPsec 隧道支持 ECN，我们应修改封装和解封装过程。这在 http://www.aciri.org/floyd/papers/draft-ipsec-ecn-00.txt 的第 3 章中有描述。

通过将 net.inet.ipsec.ecn（或 net.inet6.ipsec6.ecn）设置为某个值，IPsec 隧道实现可以提供三种行为：

• RFC2401：不考虑 ECN（sysctl 值为-1）

• 禁止 ECN (sysctl 值为 0)

• 允许 ECN (sysctl 值为 1)

请注意，行为可在每个节点进行配置，而不是每个 SA 进行配置（draft-ipsec-ecn-00 希望每个 SA 配置，但对我来说太复杂了）。

行为如下总结（详细信息请参阅源代码）：

encapsulate                     decapsulate
                ---                             ---
RFC2401         copy all TOS bits               drop TOS bits on outer
                from inner to outer.            (use inner TOS bits as is)

ECN forbidden   copy TOS bits except for ECN    drop TOS bits on outer
                (masked with 0xfc) from inner   (use inner TOS bits as is)
                to outer.  set ECN bits to 0.

ECN allowed     copy TOS bits except for ECN    use inner TOS bits with some
                CE (masked with 0xfe) from      change.  if outer ECN CE bit
                inner to outer.                 is 1, enable ECN CE bit on
                set ECN CE bit to 0.            the inner.

配置的一般策略如下：

• 如果 IPsec 隧道端点都支持 ECN 友好行为，最好将两端都配置为“允许 ECN”（sysctl 值为 1）。

• 如果另一端对 TOS 位非常严格，请使用"RFC2401"（sysctl 值为-1）。

• 在其他情况下，请使用"ECN 禁止"（sysctl 值为 0）。

默认行为是"ECN 禁止"（sysctl 值为 0）。

有关更多信息，请参阅：

http://www.aciri.org/floyd/papers/draft-ipsec-ecn-00.txt，RFC2481（显式拥塞通知），src/sys/netinet6/{ah,esp}_input.c

（感谢 Kenjiro Cho kjc@csl.sony.co.jp 进行详细分析）

8.1.4.6. 互操作性

这里是 KAME 代码过去测试 IPsec/IKE 互操作性的一些平台。请注意，双方可能已经修改了它们的实现，所以只需将以下列表用于参考目的。

Altiga, Ashley-laurent (vpcom.com), Data Fellows (F-Secure), Ericsson ACC, FreeS/WAN, 日立, IBM AIX®, IIJ, Intel, Microsoft® Windows NT®, NIST (Linux IPsec + plutoplus), Netscreen, OpenBSD, RedCreek, Routerware, SSH, Secure Computing, Soliton, 东芝, VPNet, 雅马哈 RT100i

这一章由 G. Adam Stanislav 撰写。

A.1. 概要

UNIX® 下的汇编语言编程是高度未记录的。一般认为没有人会想要使用它，因为各种 UNIX® 系统运行在不同的微处理器上，所以一切都应该用 C 语言编写以实现可移植性。

实际上，C 的可移植性相当于神话。即使是 C 程序在从一个 UNIX® 移植到另一个 UNIX® 时也需要进行修改，而不管每个系统运行在哪个处理器上。通常，这样的程序充满了依赖于其编译系统的条件语句。

即使我们相信所有的 UNIX®软件都应该用 C 语言或其他高级语言编写，我们仍然需要汇编语言程序员：谁会写访问内核的 C 库部分呢？

在本章中，我将尝试向您展示如何在 FreeBSD 下使用汇编语言编写 UNIX®程序。

本章不解释汇编语言的基础知识。关于这方面有足够的资源（要了解汇编语言的完整在线课程，请参阅 Randall Hyde 的《汇编语言艺术》；或者如果您更喜欢纸质书籍，请查看 Jeff Duntemann 的《逐步学习汇编语言》（ISBN：0471375233）。然而，一旦本章完成，任何汇编语言程序员都将能够快速高效地为 FreeBSD 编写程序。

版权 © 2000-2001 G. Adam Stanislav。保留所有权利。

A.2. 工具

A.2.1. 汇编器

汇编语言编程最重要的工具是汇编器，这种软件将汇编语言代码转换为机器语言。

FreeBSD 提供了三种非常不同的汇编器。llvm-as(1)（包含在 devel/llvm 中）和 as(1)（包含在 devel/binutils 中）都使用传统的 UNIX®汇编语言语法。

另一方面，nasm(1)（通过 devel/nasm 安装）使用 Intel 语法。它的主要优势是可以为许多操作系统汇编代码。

本章使用 nasm 语法，因为大多数来自其他操作系统的汇编语言程序员会发现这样更容易理解。而且，坦率地说，这是我习惯于的。

链接器

汇编器的输出，就像任何编译器的输出一样，需要链接以形成可执行文件。

标准的 ld(1)链接器随 FreeBSD 提供。它可以与用汇编器组装的代码一起工作。

A.3. 系统调用

A.3.1. 默认调用约定

默认情况下，FreeBSD 内核使用 C 调用约定。此外，尽管内核是使用 int 80h 访问的，但假定程序将调用发出 int 80h 的函数，而不是直接发出 int 80h 。

这种约定非常方便，比 MS-DOS®使用的 Microsoft®约定要好得多。为什么？因为 UNIX®约定允许任何用任何语言编写的程序访问内核。

汇编语言程序也可以做到。例如，我们可以打开一个文件：

kernel:
	int	80h	; Call kernel
	ret

open:
	push	dword mode
	push	dword flags
	push	dword path
	mov	eax, 5
	call	kernel
	add	esp, byte 12
	ret

这是一种非常干净和便携的编码方式。如果您需要将代码转移到一个使用不同中断或不同参数传递方式的 UNIX®系统，您需要更改的只是内核过程。

但是汇编语言程序员喜欢节省周期。上面的示例需要一个 call/ret 组合。我们可以通过 push 一个额外的双字来消除它：

open:
	push	dword mode
	push	dword flags
	push	dword path
	mov	eax, 5
	push	eax		; Or any other dword
	int	80h
	add	esp, byte 16

我们放置在 EAX 中的 5 标识内核函数，在本例中为 open 。

3.2. 替代调用约定

FreeBSD 是一个非常灵活的系统。 它提供了调用内核的其他方式。 但是，为了使其工作，系统必须安装 Linux 模拟。

Linux 是一个类似 UNIX® 的系统。 但是，其内核使用与 MS-DOS® 相同的通过寄存器传递参数的系统调用约定。 与 UNIX® 约定一样，函数号放置在 EAX 中。 然而，参数不是通过堆栈传递而是通过 EBX, ECX, EDX, ESI, EDI, EBP 传递。

open:
	mov	eax, 5
	mov	ebx, path
	mov	ecx, flags
	mov	edx, mode
	int	80h

这种约定在汇编语言编程方面与 UNIX® 方式相比有一个很大的缺点：每次进行内核调用时，您必须 push 寄存器，然后稍后 pop 它们。这使得您的代码更庞大，更慢。尽管如此，FreeBSD 为您提供了选择。

如果您选择 Linux 约定，您必须让系统知道这一点。在程序汇编和链接完成后，您需要给可执行文件打上标记：

% brandelf -t Linux filename

A.3.3. 您应该使用哪种约定？

如果你专门为 FreeBSD 编码，你应该始终使用 UNIX® 约定：它更快，你可以在寄存器中存储全局变量，你不必标记可执行文件，并且你不会强加在目标系统上安装 Linux 模拟软件包。

如果你想创建可以在 Linux 上运行的可移植代码，你可能仍然希望为 FreeBSD 用户提供尽可能高效的代码。在我解释基础知识之后，我会告诉你如何做到这一点。

A.3.4. 调用号码

要告诉内核您正在调用哪个系统服务，请将其编号放在 EAX 中。 当然，您需要知道编号是多少。

A.3.4.1. 系统调用文件

编号列在系统调用中。 locate syscalls 可以找到此文件的几种不同格式，这些格式都是从 syscalls.master 自动生成的。

您可以在 /usr/src/sys/kern/syscalls.master 找到默认 UNIX®调用约定的主文件。如果您需要使用在 Linux 仿真模式中实现的其他约定，请阅读 /usr/src/sys/i386/linux/syscalls.master。

syscalls.master 描述了调用的执行方式：

0	STD	NOHIDE	{ int nosys(void); } syscall nosys_args int
1	STD	NOHIDE	{ void exit(int rval); } exit rexit_args void
2	STD	POSIX	{ int fork(void); }
3	STD	POSIX	{ ssize_t read(int fd, void *buf, size_t nbyte); }
4	STD	POSIX	{ ssize_t write(int fd, const void *buf, size_t nbyte); }
5	STD	POSIX	{ int open(char *path, int flags, int mode); }
6	STD	POSIX	{ int close(int fd); }
etc...

它是最左边的列，告诉我们要放在 EAX 中的数字。

最右边的列告诉我们要 push 什么参数。它们从右到左 push 。

例如，要 open 文件，我们需要先 push {{$2}}，然后 flags ，然后存储 path 的地址。

返回值

大多数情况下，如果系统调用不返回某种值，它将毫无用处：打开文件的文件描述符、读取到缓冲区的字节数、系统时间等。

另外，系统需要告知我们是否发生错误：文件不存在、系统资源耗尽、我们传递了无效参数等。

A.4.1. Man Pages

传统查找 UNIX® 系统下各种系统调用信息的地方是手册页。FreeBSD 在第 2 节中描述其系统调用，有时在第 3 节中。

例如，open(2) 说：

如果成功， open() 返回一个非负整数，称为文件描述符。如果失败，它返回 -1 并设置 errno 以指示错误。

初次接触 UNIX® 和 FreeBSD 的汇编语言程序员会立即问出令人困惑的问题： errno 在哪里，我该如何到达那里呢？

A.4.2. 返回值在哪里？

不幸的是，这取决于...对于大多数系统调用，它在 EAX 中，但不是全部。一个好的经验法则是，在第一次使用系统调用时，要在 EAX 中查找返回值。如果那里没有，你需要进一步研究。

A.4.3. errno 在哪？

实际上，不存在…

errno 是 C 语言的一部分，而不是 UNIX®内核。当直接访问内核服务时，错误代码以 EAX 返回，通常正确返回值也会出现在同一个寄存器中。

这是完全合理的。如果没有错误，就没有错误代码。如果有错误，就没有返回值。一个寄存器可以包含其中一个。

A.4.4. 确定发生了错误

当使用标准 FreeBSD 调用约定时， carry flag 在成功时被清除，在失败时被设置。

当使用 Linux 仿真模式时， EAX 中的有符号值在成功时为非负，并包含返回值。在发生错误时，该值为负，即 -errno 。

A.5. 创建可移植代码

可移植性通常不是汇编语言的优势之一。然而，使用 nasm 编写可以在不同平台上汇编的汇编语言程序是可能的，特别是在 Windows®和 FreeBSD 等不同操作系统上。

当您希望您的代码在两个基于类似架构但不同的平台上运行时，这种可能性就更大了。

例如，FreeBSD 是 UNIX®，Linux 是类 UNIX®。我只提到了它们之间的三个差异（从汇编语言程序员的角度看）：调用约定、函数编号和返回值的方式。

处理函数编号

在许多情况下，功能编号是相同的。然而，即使它们不同，问题也很容易处理：在代码中不要使用数字，而是使用根据目标架构不同声明的常量：

%ifdef	LINUX
%define	SYS_execve	11
%else
%define	SYS_execve	59
%endif

处理约定

通过宏可以解决调用约定和返回值（ errno 问题）：

%ifdef	LINUX

%macro	system	0
	call	kernel
%endmacro

align 4
kernel:
	push	ebx
	push	ecx
	push	edx
	push	esi
	push	edi
	push	ebp

	mov	ebx, [esp+32]
	mov	ecx, [esp+36]
	mov	edx, [esp+40]
	mov	esi, [esp+44]
	mov	ebp, [esp+48]
	int	80h

	pop	ebp
	pop	edi
	pop	esi
	pop	edx
	pop	ecx
	pop	ebx

	or	eax, eax
	js	.errno
	clc
	ret

.errno:
	neg	eax
	stc
	ret

%else

%macro	system	0
	int	80h
%endmacro

%endif

A.5.3. 处理其他可移植性问题

上述解决方案可以处理大多数在 FreeBSD 和 Linux 之间编写可移植代码的情况。然而，对于一些内核服务，差异更深。

在这种情况下，您需要为这些特定的系统调用编写两个不同的处理程序，并使用条件汇编。幸运的是，您的大部分代码除了调用内核之外，通常只需要在代码中使用几个这样的条件部分。

使用库

您可以通过编写系统调用库来完全避免主代码中的可移植性问题。为 FreeBSD 编写一个单独的库，为 Linux 编写一个不同的库，以及为更多操作系统编写其他库。

在你的库中，为每个系统调用编写一个单独的函数（或者如果您更喜欢传统的汇编语言术语，则为过程）。使用传递参数的 C 调用约定。但仍然使用 EAX 来传递调用号码。在这种情况下，你的 FreeBSD 库可以非常简单，因为许多看似不同的函数实际上只是指向相同代码的标签：

sys.open:
sys.close:
[etc...]
	int	80h
	ret

你的 Linux 库将需要更多不同的函数。但是即使在这里，你也可以使用相同数量的参数来分组系统调用：

sys.exit:
sys.close:
[etc... one-parameter functions]
	push	ebx
	mov	ebx, [esp+12]
	int	80h
	pop	ebx
	jmp	sys.return

...

sys.return:
	or	eax, eax
	js	sys.err
	clc
	ret

sys.err:
	neg	eax
	stc
	ret

起初，库方法可能看起来有些不方便，因为它要求你生成一个代码依赖的单独文件。但它有许多优点：首先，你只需要编写一次，并且可以在所有程序中使用。你甚至可以让其他汇编语言程序员使用它，或者使用别人写的库。但是，库最大的优点也许是你的代码可以被简单地移植到其他系统，甚至是其他程序员，只需编写一个新库，而无需对代码进行任何更改。

如果你不喜欢拥有一个库的想法，你至少可以把所有的系统调用放在一个单独的汇编语言文件中，并将其与你的主程序链接起来。在这里，所有的移植者只需要创建一个新的目标文件，以便与你的主程序链接起来。

使用包含文件

如果您将软件发布为(或与之一起发布的)源代码，您可以使用宏，并将其放在一个单独的文件中，然后在您的代码中包含它们。

您的软件的搬运工将简单地编写一个新的包含文件。不需要库或外部目标文件，但您的代码是可移植的，无需编辑代码。

我们可以通过声明标准文件描述符来开始我们的 system.inc：

%define	stdin	0
%define	stdout	1
%define	stderr	2

接下来，我们为每个系统调用创建一个符号名称：

%define	SYS_nosys	0
%define	SYS_exit	1
%define	SYS_fork	2
%define	SYS_read	3
%define	SYS_write	4
; [etc...]

我们添加一个短的、非全局的过程，使用一个长名称，这样我们就不会在我们的代码中不小心重用该名称：

section	.text
align 4
access.the.bsd.kernel:
	int	80h
	ret

我们创建一个宏，它接受一个参数，即系统调用号码：

%macro	system	1
	mov	eax, %1
	call	access.the.bsd.kernel
%endmacro

最后，我们为每个系统调用创建宏。这些宏不带参数。

%macro	sys.exit	0
	system	SYS_exit
%endmacro

%macro	sys.fork	0
	system	SYS_fork
%endmacro

%macro	sys.read	0
	system	SYS_read
%endmacro

%macro	sys.write	0
	system	SYS_write
%endmacro

; [etc...]

继续，将其输入到您的编辑器中，并将其保存为 system.inc。随着我们讨论更多系统调用，我们将添加更多内容。

A.6.我们的第一个程序

我们现在准备好进行我们的第一个程序，必不可少的 Hello, World！

	%include	'system.inc'

	section	.data
	hello	db	'Hello, World!', 0Ah
	hbytes	equ	$-hello

	section	.text
	global	_start
_start:
	push	dword hbytes
	push	dword hello
	push	dword stdout
	sys.write

	push	dword 0
	sys.exit

这里是它的功能：第 1 行包括了定义、宏以及来自 system.inc 的代码。

第 3-5 行是数据：第 3 行开始数据部分/段。第 4 行包含字符串"Hello, World!"，后跟一个换行符（ 0Ah ）。第 5 行创建一个包含第 4 行字符串长度（以字节计）的常量。

第 7-16 行包含代码。请注意，FreeBSD 使用 elf 文件格式作为其可执行文件，这要求每个程序都从标记为 _start 的点开始（更准确地说，链接器期望如此）。此标签必须是全局的。

第 10-13 行要求系统将 hello 字符串的 hbytes 字节写入 stdout 。

第 15-16 行要求系统以 0 的返回值结束程序。 SYS_exit 系统调用永远不会返回，因此代码在那里结束。

A.6.1。汇编代码

在编辑器中输入代码，并将其保存在名为 hello.asm 的文件中。您需要 nasm 来进行汇编。

安装 nasm

如果您没有 nasm，请键入：

% su
Password:your root password
# cd /usr/ports/devel/nasm
# make install
# exit
%

如果你不想保留 nasm 源代码，可以键入 make install clean 而不仅仅是 make install 。

无论如何，FreeBSD 都将自动从互联网下载 nasm，并在您的系统上进行编译和安装。

现在您可以汇编，链接和运行代码：

% nasm -f elf hello.asm
% ld -s -o hello hello.o
% ./hello
Hello, World!
%

A.7. 编写 UNIX® 过滤器

常见的 UNIX® 应用程序类型是过滤器——一种从 stdin 读取数据，进行某种处理，然后将结果写入 stdout 的程序。

在本章中，我们将开发一个简单的过滤器，并学习如何从 stdin 读取和写入 stdout。这个过滤器将把输入的每个字节转换成一个十六进制数，并在其后跟一个空格。

%include	'system.inc'

section	.data
hex	db	'0123456789ABCDEF'
buffer	db	0, 0, ' '

section	.text
global	_start
_start:
	; read a byte from stdin
	push	dword 1
	push	dword buffer
	push	dword stdin
	sys.read
	add	esp, byte 12
	or	eax, eax
	je	.done

	; convert it to hex
	movzx	eax, byte [buffer]
	mov	edx, eax
	shr	dl, 4
	mov	dl, [hex+edx]
	mov	[buffer], dl
	and	al, 0Fh
	mov	al, [hex+eax]
	mov	[buffer+1], al

	; print it
	push	dword 3
	push	dword buffer
	push	dword stdout
	sys.write
	add	esp, byte 12
	jmp	short _start

.done:
	push	dword 0
	sys.exit

在数据部分，我们创建一个名为 hex 的数组。它按升序包含 16 个十六进制数字。该数组后面是一个缓冲区，我们将用于输入和输出。缓冲区的前两个字节最初设置为 0 。这是我们将写入两个十六进制数字的地方（第一个字节也是我们将读取输入的地方）。第三个字节是一个空格。

代码部分包括四个部分：读取字节、将其转换为十六进制数、写入结果，并最终退出程序。

要读取字节，我们要求系统从标准输入中读取一个字节，并将其存储在 buffer 的第一个字节中。系统返回读取的字节数为 EAX 。当数据正在传输时，这将是 1 ，或者当没有更多的输入数据可用时，这将是 0 。因此，我们检查 EAX 的值。如果是 0 ，我们跳转到 .done ，否则我们继续。

十六进制转换从 buffer 读取字节到 EAX ，或者实际上只是 AL ，同时将 EAX 的其余位清零。我们还将字节复制到 EDX ，因为我们需要分别转换上四位（半字节）和下四位。我们将结果存储在缓冲区的前两个字节中。

接下来，我们要求系统将缓冲区的三个字节，即两个十六进制数字和空格，写入标准输出。然后我们跳回程序的开头并处理下一个字节。

一旦没有更多的输入，我们要求系统退出我们的程序，返回零，这是传统意义上表示程序成功的值。

继续，将代码保存在名为 hex.asm 的文件中，然后输入以下内容（ ^D 表示按住控制键并在按住控制键的同时按 D ）：

% nasm -f elf hex.asm
% ld -s -o hex hex.o
% ./hex
Hello, World!
48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21 0A Here I come!
48 65 72 65 20 49 20 63 6F 6D 65 21 0A ^D %

我们能改进这个吗？首先，有点令人困惑，因为一旦我们转换了一行文本，我们的输入就不再从行的开头开始了。我们可以修改它，在每个 0A 后打印一个新行而不是一个空格。

%include	'system.inc'

section	.data
hex	db	'0123456789ABCDEF'
buffer	db	0, 0, ' '

section	.text
global	_start
_start:
	mov	cl, ' '

.loop:
	; read a byte from stdin
	push	dword 1
	push	dword buffer
	push	dword stdin
	sys.read
	add	esp, byte 12
	or	eax, eax
	je	.done

	; convert it to hex
	movzx	eax, byte [buffer]
	mov	[buffer+2], cl
	cmp	al, 0Ah
	jne	.hex
	mov	[buffer+2], al

.hex:
	mov	edx, eax
	shr	dl, 4
	mov	dl, [hex+edx]
	mov	[buffer], dl
	and	al, 0Fh
	mov	al, [hex+eax]
	mov	[buffer+1], al

	; print it
	push	dword 3
	push	dword buffer
	push	dword stdout
	sys.write
	add	esp, byte 12
	jmp	short .loop

.done:
	push	dword 0
	sys.exit

我们已经将空格存储在 CL 寄存器中。我们可以这样做是因为，与 Microsoft® Windows®不同，UNIX®系统调用不会修改任何未使用的寄存器的值来返回值。

这意味着我们只需要设置 CL 一次。因此，我们添加了一个新标签 .loop 并跳转到下一个字节，而不是跳转到 _start 。我们还添加了 .hex 标签，这样我们可以在 buffer 的第三个字节中有一个空格或一个新行。

一旦您已经更改了 hex.asm 以反映这些更改，请键入：

% nasm -f elf hex.asm
% ld -s -o hex hex.o
% ./hex
Hello, World!
48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21 0A
Here I come!
48 65 72 65 20 49 20 63 6F 6D 65 21 0A
^D %

看起来更好了。但这段代码效率很低！我们为每个字节两次（一次读取，一次写入输出）进行系统调用。

A.8. 缓冲输入和输出

通过缓冲输入和输出，我们可以提高代码的效率。我们创建一个输入缓冲区，并一次性读取一整个字节序列。然后我们逐个从缓冲区中获取它们。

我们还创建一个输出缓冲区。我们将输出存储在其中，直到它满为止。在那时，我们要求内核将缓冲区的内容写入标准输出。

当没有更多输入时，程序结束。但我们仍然需要要求内核最后一次将输出缓冲区的内容写入标准输出，否则一些输出将进入输出缓冲区，但永远不会被发送出去。不要忘记这一点，否则你会想知道为什么有些输出丢失了。

%include	'system.inc'

%define	BUFSIZE	2048

section	.data
hex	db	'0123456789ABCDEF'

section .bss
ibuffer	resb	BUFSIZE
obuffer	resb	BUFSIZE

section	.text
global	_start
_start:
	sub	eax, eax
	sub	ebx, ebx
	sub	ecx, ecx
	mov	edi, obuffer

.loop:
	; read a byte from stdin
	call	getchar

	; convert it to hex
	mov	dl, al
	shr	al, 4
	mov	al, [hex+eax]
	call	putchar

	mov	al, dl
	and	al, 0Fh
	mov	al, [hex+eax]
	call	putchar

	mov	al, ' '
	cmp	dl, 0Ah
	jne	.put
	mov	al, dl

.put:
	call	putchar
	jmp	short .loop

align 4
getchar:
	or	ebx, ebx
	jne	.fetch

	call	read

.fetch:
	lodsb
	dec	ebx
	ret

read:
	push	dword BUFSIZE
	mov	esi, ibuffer
	push	esi
	push	dword stdin
	sys.read
	add	esp, byte 12
	mov	ebx, eax
	or	eax, eax
	je	.done
	sub	eax, eax
	ret

align 4
.done:
	call	write		; flush output buffer
	push	dword 0
	sys.exit

align 4
putchar:
	stosb
	inc	ecx
	cmp	ecx, BUFSIZE
	je	write
	ret

align 4
write:
	sub	edi, ecx	; start of buffer
	push	ecx
	push	edi
	push	dword stdout
	sys.write
	add	esp, byte 12
	sub	eax, eax
	sub	ecx, ecx	; buffer is empty now
	ret

我们现在在源代码中有第三个部分，名为 .bss 。这个部分不包括在我们的可执行文件中，因此无法初始化。我们使用 resb 而不是 db 。它只是为我们保留请求大小的未初始化内存供我们使用。

我们利用系统不修改寄存器的事实：我们将寄存器用于原本需要存储在 .data 部分的全局变量。这也是为什么 UNIX®传递参数给系统调用的惯例是在堆栈上，优于 Microsoft 传递参数给寄存器的惯例：我们可以保留寄存器供我们自己使用。

我们使用 EDI 和 ESI 作为指向下一个要读取或写入的字节的指针。我们使用 EBX 和 ECX 来计算两个缓冲区中的字节数，这样我们就知道何时将输出转储到系统中，或者从系统中读取更多输入。

让我们看看现在它是如何工作的：

% nasm -f elf hex.asm
% ld -s -o hex hex.o
% ./hex
Hello, World!
Here I come!
48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21 0A
48 65 72 65 20 49 20 63 6F 6D 65 21 0A
^D %

不是你期望的吗？程序直到我们按下 ^D 后才打印输出。通过插入三行代码，每次我们将新行转换为 0A 时写出输出很容易解决。我已经用 > 标记了这三行（在您的 hex.asm 中不要复制 >）。

%include	'system.inc'

%define	BUFSIZE	2048

section	.data
hex	db	'0123456789ABCDEF'

section .bss
ibuffer	resb	BUFSIZE
obuffer	resb	BUFSIZE

section	.text
global	_start
_start:
	sub	eax, eax
	sub	ebx, ebx
	sub	ecx, ecx
	mov	edi, obuffer

.loop:
	; read a byte from stdin
	call	getchar

	; convert it to hex
	mov	dl, al
	shr	al, 4
	mov	al, [hex+eax]
	call	putchar

	mov	al, dl
	and	al, 0Fh
	mov	al, [hex+eax]
	call	putchar

	mov	al, ' '
	cmp	dl, 0Ah
	jne	.put
	mov	al, dl

.put:
	call	putchar
>	cmp	al, 0Ah
>	jne	.loop
>	call	write
	jmp	short .loop

align 4
getchar:
	or	ebx, ebx
	jne	.fetch

	call	read

.fetch:
	lodsb
	dec	ebx
	ret

read:
	push	dword BUFSIZE
	mov	esi, ibuffer
	push	esi
	push	dword stdin
	sys.read
	add	esp, byte 12
	mov	ebx, eax
	or	eax, eax
	je	.done
	sub	eax, eax
	ret

align 4
.done:
	call	write		; flush output buffer
	push	dword 0
	sys.exit

align 4
putchar:
	stosb
	inc	ecx
	cmp	ecx, BUFSIZE
	je	write
	ret

align 4
write:
	sub	edi, ecx	; start of buffer
	push	ecx
	push	edi
	push	dword stdout
	sys.write
	add	esp, byte 12
	sub	eax, eax
	sub	ecx, ecx	; buffer is empty now
	ret