在讨论程式码是什么之前，我们先来谈论一下什么是可执行档？我们说过，在 Linux 系统上面，一个档案能不能被执行看的是有没有可执行的那个权限 (具有 x permission)，不过，Linux 系统上真正认识的可执行档其实是二进位档案 ( binary program)，例如 /usr/bin/passwd, /bin/touch 这些个档案即为二进位程式码。

或许你会说 shell scripts 不是也可以执行吗？其实 shell scripts 只是利用 shell (例如 bash) 这支程式的功能进行一些判断式，而最终执行的除了 bash 提供的功能外，仍是呼叫一些已经编译好的二进位程式来执行的呢！ 当然啦， bash 本身也是一支二进位程式啊！那么我怎么知道一个档案是否为 binary 呢？还记得我们在第七章里面提到的 file 这个指令的功能吗？对啦！用他就是了！我们现在来测试一下：

# 先以系统的档案测试看看：
[root@www ~]# file /bin/bash
/bin/bash: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), for GNU/
Linux 2.6.9, dynamically linked (uses shared libs), for GNU/Linux 2.6.9, stripped

# 如果是系统提供的 /etc/init.d/syslog 呢？
[root@www ~]# file /etc/init.d/syslog
/etc/init.d/syslog: Bourne-Again shell script text executable

看到了吧！如果是 binary 而且是可以执行的时候，他就会显示执行档类别 (ELF 32-bit LSB executable)， 同时会说明是否使用动态函式库 (shared libs)，而如果是一般的 script ，那他就会显示出 text executables 之类的字样！

Tips: 事实上，syslog 的资料显示出 Bourne-Again ... 那一行，是因为你的 scripts 上面第一行有宣告 #!/bin/bash 的缘故，如果你将 script 的第一行拿掉，那么不管 /etc/init.d/syslog 的权限为何，他其实显示的是 ASCII 文字档的资讯喔！

既然 Linux 作业系统真正认识的其实是 binary program，那么我们是如何做出这样的一支 binary 的程式呢？首先，我们必须要写程式，用什么东西写程式？就是一般的文书处理器啊！鸟哥都喜欢使用 vim 来进行程式的撰写，写完的程式就是所谓的原始程式码啰！ 这个程式码档案其实就是一般的纯文字档。 在完成这个原始码档案的编写之后，再来就是要将这个档案‘编译’成为作业系统看的懂得 binary program 啰！而要编译自然就需要‘编译器’来动作， 经过编译器的编译与连结之后，就会产生一支可以执行的 binary program 啰。

举个例子来说，在 Linux 上面最标准的程式语言为 C ，所以我使用 C 的语法进行原始程式码的书写，写完之后，以 Linux 上标准的 C 语言编译器 gcc 这支程式来编译，就可以制作一支可以执行的 binary program 啰。整个的流程有点像这样：

图 1.1.1、利用 gcc 编译器进行程式的编译流程示意图"

事实上，在编译的过程当中还会产生所谓的目标档 (Object file)，这些档案是以 *.o 的副档名样式存在的！至于 C 语言的原始码档案通常以 *.c 作为副档名。此外，有的时候，我们会在程式当中‘引用、呼叫’ 其他的外部副程式，或者是利用其他软体提供的‘函数功能’，这个时候，我们就必须要在编译的过程当中， 将该函式库给他加进去，如此一来，编译器就可以将所有的程式码与函式库作一个连结 (Link) 以产生正确的执行档啰。

总之，我们可以这么说：

• 开放源码：就是程式码，写给人类看的程式语言，但机器并不认识，所以无法执行；
• 编译器：将程式码转译成为机器看的懂得语言，就类似翻译者的角色；
• 可执行档：经过编译器变成二进位程式后，机器看的懂所以可以执行的档案。

在前一小节的图1.1.1示意图中，在编译的过程里面有提到函式库这东西。 什么是函式库呢？先举个例子来说：我们的 Linux 系统上通常已经提供一个可以进行身份验证的模组， 就是在第十四章提到的 PAM 模组。这个 PAM 提供的功能可以让很多的程式在被执行的时候，除了可以验证使用者登入的资讯外， 还可以将身份确认的资料记录在登录档里面，以方便系统管理员的追踪！

既然有这么好用的功能，那如果我要编写具有身份认证功能的程式时，直接引用该 PAM 的功能就好啦，如此一来，我就不需要重新设计认证机制啰！也就是说，只要在我写的程式码里面，设定去呼叫 PAM 的函式功能，我的程式就可以利用 Linux 原本就有的身份认证的程序咯！除此之外，其实我们的 Linux 核心也提供了相当多的函式库来给硬体开发者利用喔。

函式库又分为动态与静态函式库，这两个咚咚的分别我们在后面的小节再加以说明。 这里我们以一个简单的流程图，来示意一支有呼叫外部函式库的程式的执行情况。

图 1.2.1、程式执行时引用外部动态函式库的示意图

很简单的示意图啊！^_^！而如果要在程式里面加入引用的函式库，就需要如图 1.1.1 所示， 亦即在编译的过程当中，就需要加入函式库的相关设定啰。 事实上， Linux 的核心提供很多的核心相关函式库与外部参数， 这些核心功能在设计硬体的驱动程式的时候是相当有用的资讯，这些核心相关资讯大多放置在 /usr/include, /lib, /usr/lib 里面哩！我们在本章的后续小节再来探讨。反正我们可以简单的这么想：

• 函式库：就类似副程式的角色，可以被呼叫来执行的一段功能函数。

事实上，使用类似 gcc 的编译器来进行编译的过程并不简单，因为一套软体并不会仅有一支程式， 而是有一堆程式码档案。所以除了每个主程式与副程式均需要写上一笔编译过程的指令外，还需要写上最终的连结程序。 程式码小的时候还好，如果是类似 WWW 伺服器软体 (例如 Apache) ，或者是类似核心的原始码，动则数百 MBytes 的资料量，编译指令会写到疯掉～这个时候，我们就可以使用 make 这个指令的相关功能来进行编译过程的指令简化了！

当执行 make 时，make 会在当时的目录下搜寻 Makefile (or makefile) 这个文字档，而 Makefile 里面则记录了原始码如何编译的详细资讯！ make 会自动的判别原始码是否经过变动了，而自动更新执行档，是软体工程师相当好用的一个辅助工具呢！

咦！make 是一支程式，会去找 Makefile ，那 Makefile 怎么写？ 通常软体开发商都会写一支侦测程式来侦测使用者的作业环境， 以及该作业环境是否有软体开发商所需要的其他功能，该侦测程式侦测完毕后，就会主动的建立这个 Makefile 的规则档案啦！通常这支侦测程式的档名为 configure 或者是 config 。

咦！那为什么要侦测作业环境呢？在第一章当中， 不是曾经提过其实每个 Linux distribution 都使用同样的核心吗？但你得要注意， 不同版本的核心所使用的系统呼叫可能不相同，而且每个软体所需要的相依的函式库也不相同， 同时，软体开发商不会仅针对 Linux 开发，而是会针对整个 Unix-Like 做开发啊！ 所以他也必须要侦测该作业系统平台有没有提供合适的编译器才行！所以当然要侦测环境啊！ 一般来说，侦测程式会侦测的资料大约有底下这些：

• 是否有适合的编译器可以编译本软体的程式码；
• 是否已经存在本软体所需要的函式库，或其他需要的相依软体；
• 作业系统平台是否适合本软体，包括 Linux 的核心版本；
• 核心的表头定义档 (header include) 是否存在 (驱动程式必须要的侦测)。

至于 make 与 configure 运作流程的相关性，我们可以使用底下的图示来示意一下啊！ 下图中，你要进行的任务其实只有两个，一个是执行 configure 来建立 Makefile ， 这个步骤一定要成功！成功之后再以 make 来呼叫所需要的资料来编译即可！非常简单！

图 1.3.1、透过 configure 与 make 进行编译示意图

由于不同的 Linux distribution 的函式库档案所放置的路径，或者是函式库的档名订定， 或者是预设安装的编译器，以及核心的版本都不相同，因此理论上，你无法在 CentOS 5.x 上面编译出 binary program 后，还将他拿到 SuSE 上面执行，这个动作通常是不可能成功的！ 因为呼叫的目标函式库位置可能不同 (参考图1.2.1) ， 核心版本更不可能相同！所以能够执行的情况是微乎其微！所以同一套软体要在不同的平台上面执行时， 必须要重复编译！所以才需要原始码嘛！了解乎！

详细的 make 用法与 Makefile 规则，在后续的小节里面再探讨啰！

从前面几个小节的说明来看，我们知道所谓的原始程式码，其实就是一些写满了程式码的纯文字档案。 那我们在第九章压缩指令的介绍当中， 也了解了纯文字档在网路上其实是很浪费频宽的一种档案格式！ 所以啦，如果能够将这些原始码透过档案的打包与压缩技术来将档案的数量与容量减小， 不但让使用者容易下载，软体开发商的网站频宽也能够节省很多很多啊！这就是 Tarball 档案的由来啰！

Tips: 想一想，一个核心的原始码档案大约要 300~500 MB 以上，如果每个人都去下载这样的一个核心档案， 呵呵！那么网路频宽不被吃的死翘翘才怪呢！

所谓的 Tarball 档案，其实就是将软体的所有原始码档案先以 tar 打包，然后再以压缩技术来压缩，通常最常见的就是以 gzip 来压缩了。因为利用了 tar 与 gzip 的功能，所以 tarball 档案一般的副档名就会写成 *.tar.gz 或者是简写为 *.tgz 啰！不过，近来由于 bzip2 的压缩率较佳，所以 Tarball 渐渐的以 bzip2 的压缩技术来取代 gzip 啰！因此档名也会变成 *.tar.bz2 之类的哩。所以说， Tarball 是一个软体包， 你将他解压缩之后，里面的档案通常就会有：

• 原始程式码档案；
• 侦测程式档案 (可能是 configure 或 config 等档名)；
• 本软体的简易说明与安装说明 (INSTALL 或 README)。

其中最重要的是那个 INSTALL 或者是 README 这两个档案，通常你只要能够参考这两个档案， Tarball 软体的安装是很简单的啦！我们在后面的章节会再继续介绍 Tarball 这个玩意儿。

将原始码作了一个简单的介绍，也知道了系统其实认识的可执行档是 binary program 之后，好了，得要聊一聊，那么怎么安装与升级一个 Tarball 的软体？为什么要安装一个新的软体呢？当然是因为我们的主机上面没有该软体啰！那么， 为何要升级呢？原因可能有底下这些：

• 需要新的功能，但旧有主机的旧版软体并没有，所以需要升级到新版的软体；
• 旧版本的软体上面可能有资安上的顾虑，所以需要更新到新版的软体；
• 旧版的软体执行效能不彰，或者执行的能力不能让管理者满足。

在上面的需求当中，尤其需要注意的是第二点，当一个软体有安全上的顾虑时，千万不要怀疑， 赶紧更新软体吧！否则造成网路危机，那可不是闹着玩的！那么更新的方法有哪些呢？ 基本上更新的方法可以分为两大类，分别是：

• 直接以原始码透过编译来安装与升级；
• 直接以编译好的 binary program 来安装与升级。

上面第一点很简单，就是直接以 Tarball 在自己的机器上面进行侦测、编译、 安装与设定等等动作来升级就是了。不过，这样的动作虽然让使用者在安装过程当中具有很高的弹性， 但毕竟是比较麻烦一点，如果 Linux distribution 厂商能够针对自己的作业平台先进行编译等过程，再将编译好的 binary program 释出的话，那由于我的系统与该 Linux distribution 的环境是相同的，所以他所释出的 binary program 就可以在我的机器上面直接安装啦！省略了侦测与编译等等繁杂的过程呢！

这个预先编译好程式的机制存在于很多 distribution 喔，包括有 Red Hat 系统 (含 Fedora/CentOS 系列) 发展的 RPM 软体管理机制与 yum 线上更新模式； Debian 使用的 dpkg 软体管理机制与 APT 线上更新模式等等。

由于 CentOS 系统是依循标准的 Linux distribution，所以可以使用 Tarball 直接进行编译的安装与升级， 当然也可以使用 RPM 相关的机制来进行安装与升级啰！本章节主要针对 Tarball ，至于 RPM 则留待下个章节再来介绍呢！

好了，那么一个软体的 Tarball 是如何安装的呢？基本流程是这样的啦：

1. 将 Tarball 由厂商的网页下载下来；
2. 将 Tarball 解开，产生很多的原始码档案；
3. 开始以 gcc 进行原始码的编译 (会产生目标档 object files)；
4. 然后以 gcc 进行函式库、主、副程式的连结，以形成主要的 binary file；
5. 将上述的 binary file 以及相关的设定档安装至自己的主机上面。

上面第 3, 4 步骤当中，我们可以透过 make 这个指令的功能来简化他， 所以整个步骤其实是很简单的啦！只不过你就得需要至少有 gcc 以及 make 这两个软体在你的 Linux 系统里面才行喔！ 详细的过程以及需要的软体我们在后面的章节继续来介绍的啦！

我们以 Linux 上面最常见的 C 语言来撰写第一支程式！第一支程式最常作的就是..... 在荧幕上面印出‘Hello World！’的字样～当然， 这里我们是以简单的 C 语言来撰写，如果你对于 C 有兴趣的话，那么请自行购买相关的书籍喔！ ^_^ 好了，不啰唆，立刻编辑第一支程式吧！

Tips: 请先确认你的 Linux 系统里面已经安装了 gcc 了喔！如果尚未安装 gcc 的话，请先参考下一节的 RPM 安装法，先安装好 gcc 之后，再回来阅读本章。 如果你已经有网路了，那么直接使用‘ yum groupinstall "Development Tools" ’ 预先安装好所需的所有软体即可。 rpm 与 yum 均会在下一章介绍。

• 编辑程式码，亦即原始码

[root@www ~]# vim hello.c   <==用 C 语言写的程式副档名建议用 .c
#include <stdio.h>
int main(void)
{
        printf("Hello World\n");
}

上面是用 C 语言的语法写成的一个程式档案。第一行的那个‘ # ’并不是注解喔！如果你担心输入错误， 请到底下的连结下载这个档案：

• http://linux.vbird.org/linux_basic/0520source/hello.c

• 开始编译与测试执行

[root@www ~]# gcc hello.c
[root@www ~]# ll hello.c a.out
-rwxr-xr-x 1 root root 4725 Jun  5 02:41 a.out   <==此时会产生这个档名
-rw-r--r-- 1 root root   72 Jun  5 02:40 hello.c

[root@www ~]# ./a.out
Hello World  <==呵呵！成果出现了！

在预设的状态下，如果我们直接以 gcc 编译原始码，并且没有加上任何参数，则执行档的档名会被自动设定为 a.out 这个档案名称！ 所以你就能够直接执行 ./a.out 这个执行档啦！上面的例子很简单吧！那个 hello.c 就是原始码，而 gcc 就是编译器，至于 a.out 就是编译成功的可执行 binary program 啰！ 咦！那如果我想要产生目标档 (object file) 来进行其他的动作，而且执行档的档名也不要用预设的 a.out ，那该如何是好？其实你可以将上面的第 2 个步骤改成这样：

[root@www ~]# gcc -c hello.c
[root@www ~]# ll hello*
-rw-r--r-- 1 root root  72 Jun  5 02:40 hello.c
-rw-r--r-- 1 root root 868 Jun  5 02:44 hello.o  <==就是被产生的目标档

[root@www ~]# gcc -o hello hello.o
[root@www ~]# ll hello*
-rwxr-xr-x 1 root root 4725 Jun  5 02:47 hello  <==这就是可执行档！ -o 的结果
-rw-r--r-- 1 root root   72 Jun  5 02:40 hello.c
-rw-r--r-- 1 root root  868 Jun  5 02:44 hello.o

[root@www ~]# ./hello
Hello World

这个步骤主要是利用 hello.o 这个目标档制作出一个名为 hello 的执行档，详细的 gcc 语法我们会在后续章节中继续介绍！透过这个动作后，我们可以得到 hello 及 hello.o 两个档案， 真正可以执行的是 hello 这个 binary program 喔！ 或许你会觉得，咦！只要一个动作作出 a.out 就好了，干嘛还要先制作目标档再做成执行档呢？ 呵呵！透过下个范例，你就可以知道为什么啦！

如果我们在一个主程式里面又呼叫了另一个副程式呢？这是很常见的一个程式写法， 因为可以简化整个程式的易读性！在底下的例子当中，我们以 thanks.c 这个主程式去呼叫 thanks_2.c 这个副程式，写法很简单：

• 撰写所需要的主、副程式

# 1. 编辑主程式：
[root@www ~]# vim thanks.c
#include <stdio.h>
int main(void)
{
        printf("Hello World\n");
        thanks_2();
}
# 上面的 thanks_2(); 那一行就是呼叫副程式啦！

[root@www ~]# vim thanks_2.c
#include <stdio.h>
void thanks_2(void)
{
        printf("Thank you!\n");
}

上面这两个档案你可以到底下下载：

• http://linux.vbird.org/linux_basic/0520source/thanks.c
• http://linux.vbird.org/linux_basic/0520source/thanks_2.c

• 进行程式的编译与连结 (Link)

# 2. 开始将原始码编译成为可执行的 binary file ：
[root@www ~]# gcc -c thanks.c thanks_2.c
[root@www ~]# ll thanks*
-rw-r--r-- 1 root root  76 Jun  5 16:13 thanks_2.c
-rw-r--r-- 1 root root 856 Jun  5 16:13 thanks_2.o  <==编译产生的！
-rw-r--r-- 1 root root  92 Jun  5 16:11 thanks.c
-rw-r--r-- 1 root root 908 Jun  5 16:13 thanks.o    <==编译产生的！
[root@www ~]# gcc -o thanks thanks.o thanks_2.o
[root@www ~]# ll thanks*
-rwxr-xr-x 1 root root 4870 Jun  5 16:17 thanks     <==最终结果会产生这玩意儿

# 3. 执行一下这个档案：
[root@www ~]# ./thanks
Hello World
Thank you!

知道为什么要制作出目标档了吗？由于我们的原始码档案有时并非仅只有一个档案，所以我们无法直接进行编译。 这个时候就需要先产生目标档，然后再以连结制作成为 binary 可执行档。另外，如果有一天，你更新了 thanks_2.c 这个档案的内容，则你只要重新编译 thanks_2.c 来产生新的 thanks_2.o ，然后再以连结制作出新的 binary 可执行档即可！而不必重新编译其他没有更动过的原始码档案。 这对于软体开发者来说，是一个很重要的功能，因为有时候要将偌大的原始码全部编译完成，会花很长的一段时间呢！

此外，如果你想要让程式在执行的时候具有比较好的效能，或者是其他的除错功能时， 可以在编译的过程里面加入适当的参数，例如底下的例子：

[root@www ~]# gcc -O -c thanks.c thanks_2.c  <== -O 为产生最佳化的参数

[root@www ~]# gcc -Wall -c thanks.c thanks_2.c
thanks.c: In function 'main':
thanks.c:5: warning: implicit declaration of function 'thanks_2'
thanks.c:6: warning: control reaches end of non-void function
# -Wall 为产生更详细的编译过程资讯。上面的讯息为警告讯息 (warning)
# 所以不用理会也没有关系！

至于更多的 gcc 额外参数功能，就得要 man gcc 啰～呵呵！可多的跟天书一样～

刚刚我们都仅只是在荧幕上面印出一些字眼而已，如果说要计算数学公式呢？例如我们想要计算出三角函数里面的 sin (90度角)。要注意的是，大多数的程式语言都是使用径度而不是一般我们在计算的‘角度’， 180 度角约等于 3.14 径度！嗯！那我们就来写一下这个程式吧！

[root@www ~]# vim sin.c
#include <stdio.h>
int main(void)
{
        float value;
        value = sin ( 3.14 / 2 );
        printf("%f\n",value);
}

上面这个档案的内容可以在底下取得！

• http://linux.vbird.org/linux_basic/0520source/sin.c

那要如何编译这支程式呢？我们先直接编译看看：

[root@www ~]# gcc sin.c
sin.c: In function 'main':
sin.c:5: warning: incompatible implicit declaration of built-in function 'sin'
/tmp/ccsfvijY.o: In function `main':
sin.c:(.text+0x1b): undefined reference to `sin'
collect2: ld returned 1 exit status
# 注意看到上面最后一行，会有个错误讯息，代表没有成功！

特别注意上面的错误讯息，唉啊！怎么没有编译成功？它说的是‘undefined reference to sin’，说的是‘没有 sin 的相关定义参考值！’，为什么会这样呢？这是因为 C 语言里面的 sin 函示是写在 libm.so 这个函式库中，而我们并没有在原始码里面将这个函式库功能加进去， 所以当然就需要在编译与连结的时候将这个函式库给他连结进执行档里面啊！我们可以这样做：

• 编译时加入额外函式库连结的方式：

[root@www ~]# gcc sin.c -lm -L/lib -L/usr/lib  <==重点在 -lm 
[root@www ~]# ./a.out                          <==尝试执行新档案！
1.000000

特别注意，使用 gcc 编译时所加入的那个 -lm 是有意义的，他可以拆开成两部份来看：

• -l ：是‘加入某个函式库(library)’的意思，
•  m ：则是 libm.so 这个函式库，其中， lib 与副档名(.a 或 .so)不需要写

所以 -lm 表示使用 libm.so (或 libm.a) 这个函式库的意思～至于那个 -L 后面接的路径呢？这表示： ‘我要的函式库 libm.so 请到 /lib 或 /usr/lib 里面搜寻！’

上面的说明很清楚了吧！不过，要注意的是，由于 Linux 预设是将函式库放置在 /lib 与 /usr/lib 当中，所以你没有写 -L/lib 与 -L/usr/lib 也没有关系的！不过，万一哪天你使用的函式库并非放置在这两个目录下，那么 -L/path 就很重要了！否则会找不到函式库喔！

除了连结的函式库之外，你或许已经发现一个奇怪的地方，那就是在我们的 sin.c 当中第一行‘ #include <stdio.h>’，这行说的是要将一些定义资料由 stdio.h 这个档案读入，这包括 printf 的相关设定。这个档案其实是放置在 /usr/include/stdio.h 的！那么万一这个档案并非放置在这里呢？那么我们就可以使用底下的方式来定义出要读取的 include 档案放置的目录：

[root@www ~]# gcc sin.c -lm -I/usr/include

-I/path 后面接的路径( Path )就是设定要去搜寻相关的 include 档案的目录啦！不过，同样的，预设值是放置在 /usr/include 底下，除非你的 include 档案放置在其他路径，否则也可以略过这个项目！

透过上面的几个小范例，你应该对于 gcc 以及原始码有一定程度的认识了，再接下来，我们来稍微整理一下 gcc 的简易使用方法吧！

前面说过， gcc 为 Linux 上面最标准的编译器，这个 gcc 是由 GNU 计划所维护的，有兴趣的朋友请自行前往参考。既然 gcc 对于 Linux 上的 Open source 是这么样的重要，所以底下我们就列举几个 gcc 常见的参数，如此一来大家应该更容易了解原始码的各项功能吧！

# 仅将原始码编译成为目标档，并不制作连结等功能：
[root@www ~]# gcc -c hello.c
# 会自动的产生 hello.o 这个档案，但是并不会产生 binary 执行档。

# 在编译的时候，依据作业环境给予最佳化执行速度
[root@www ~]# gcc -O hello.c -c
# 会自动的产生 hello.o 这个档案，并且进行最佳化喔！

# 在进行 binary file 制作时，将连结的函式库与相关的路径填入
[root@www ~]# gcc sin.c -lm -L/usr/lib -I/usr/include
# 这个指令较常下达在最终连结成 binary file 的时候，
# -lm 指的是 libm.so 或 libm.a 这个函式库档案；
# -L 后面接的路径是刚刚上面那个函式库的搜寻目录；
# -I 后面接的是原始码内的 include 档案之所在目录。

# 将编译的结果输出成某个特定档名
[root@www ~]# gcc -o hello hello.c
# -o 后面接的是要输出的 binary file 档名

# 在编译的时候，输出较多的讯息说明
[root@www ~]# gcc -o hello hello.c -Wall
# 加入 -Wall 之后，程式的编译会变的较为严谨一点，
# 所以警告讯息也会显示出来！

比较重要的大概就是这一些。另外，我们通常称 -Wall 或者 -O 这些非必要的参数为旗标 (FLAGS)，因为我们使用的是 C 程式语言，所以有时候也会简称这些旗标为 CFLAGS ，这些变数偶尔会被使用的喔！尤其是在后头会介绍的 make 相关的用法时，更是重要的很呐！ ^_^

先来想像一个案例，假设我的执行档里面包含了四个原始码档案，分别是 main.c haha.c sin_value.c cos_value.c 这四个档案，这四个档案的目的是：

• main.c ：主要的目的是让使用者输入角度资料与呼叫其他三支副程式；
• haha.c ：输出一堆有的没有的讯息而已；
• sin_value.c ：计算使用者输入的角度(360) sin 数值；
• cos_value.c ：计算使用者输入的角度(360) cos 数值。

这四个档案你可以到 http://linux.vbird.org/linux_basic/0520source/main.tgz 来下载。由于这四个档案里面包含了相关性，并且还用到数学函式在里面，所以如果你想要让这个程式可以跑， 那么就需要这样编译：

# 1. 先进行目标档的编译，最终会有四个 *.o 的档名出现：
[root@www ~]# gcc -c main.c
[root@www ~]# gcc -c haha.c
[root@www ~]# gcc -c sin_value.c
[root@www ~]# gcc -c cos_value.c

# 2. 再进行连结成为执行档，并加入 libm 的数学函式，以产生 main 执行档：
[root@www ~]# gcc -o main main.o haha.o sin_value.o cos_value.o \
> -lm -L/usr/lib -L/lib

# 3. 本程式的执行结果，必须输入姓名、360 度角的角度值来计算：
[root@www ~]# ./main 
Please input your name: VBird  <==这里先输入名字
Please enter the degree angle (ex> 90): 30   <==输入以 360 度角为主的角度
Hi, Dear VBird, nice to meet you.    <==这三行为输出的结果喔！
The Sin is:  0.50
The Cos is:  0.87

编译的过程需要进行好多动作啊！而且如果要重新编译，则上述的流程得要重新来一遍，光是找出这些指令就够烦人的了！ 如果可以的话，能不能一个步骤就给他完成上面所有的动作呢？那就利用 make 这个工具吧！ 先试看看在这个目录下建立一个名为 makefile 的档案，内容如下：

# 1. 先编辑 makefile 这个规则档，内容只要作出 main 这个执行档
[root@www ~]# vim makefile
main: main.o haha.o sin_value.o cos_value.o
	gcc -o main main.o haha.o sin_value.o cos_value.o -lm
# 注意：第二行的 gcc 之前是 <tab> 按键产生的空格喔！

# 2. 尝试使用 makefile 制订的规则进行编译的行为：
[root@www ~]# rm -f main *.o   <==先将之前的目标档去除
[root@www ~]# make
cc    -c -o main.o main.c
cc    -c -o haha.o haha.c
cc    -c -o sin_value.o sin_value.c
cc    -c -o cos_value.o cos_value.c
gcc -o main main.o haha.o sin_value.o cos_value.o -lm
# 此时 make 会去读取 makefile 的内容，并根据内容直接去给他编译相关的档案啰！

# 3. 在不删除任何档案的情况下，重新执行一次编译的动作：
[root@www ~]# make
make: `main' is up to date.
# 看到了吧！是否很方便呢！只会进行更新 (update) 的动作而已。

或许你会说：‘如果我建立一个 shell script 来将上面的所有动作都集结在一起，不是具有同样的效果吗？’呵呵！ 效果当然不一样，以上面的测试为例，我们仅写出 main 需要的目标档，结果 make 会主动的去判断每个目标档相关的原始码档案，并直接予以编译，最后再直接进行连结的动作！ 真的是很方便啊！此外，如果我们更动过某些原始码档案，则 make 也可以主动的判断哪一个原始码与相关的目标档档案有更新过， 并仅更新该档案，如此一来，将可大大的节省很多编译的时间呢！要知道，某些程式在进行编译的行为时，会消耗很多的 CPU 资源呢！所以说， make 有这些好处：

• 简化编译时所需要下达的指令；
• 若在编译完成之后，修改了某个原始码档案，则 make 仅会针对被修改了的档案进行编译，其他的 object file 不会被更动；
• 最后可以依照相依性来更新 (update) 执行档。

既然 make 有这么多的优点，那么我们当然就得好好的了解一下 make 这个令人关心的家伙啦！而 make 里面最需要注意的大概就是那个规则档案，也就是 makefile 这个档案的语法啦！所以底下我们就针对 makefile 的语法来加以介绍啰。

make 的语法可是相当的多而复杂的，有兴趣的话可以到 GNU (注1) 去查阅相关的说明，鸟哥这里仅列出一些基本的规则，重点在于让读者们未来在接触原始码时，不会太紧张啊！ 好了，基本的 makefile 规则是这样的：

标的(target): 目标档1 目标档2
<tab>   gcc -o 欲建立的执行档 目标档1 目标档2

那个标的 (target) 就是我们想要建立的资讯，而目标档就是具有相关性的 object files ，那建立执行档的语法就是以 <tab> 按键开头的那一行！特别给他留意喔，‘命令列必须要以 tab 按键作为开头’才行！他的规则基本上是这样的：

• 在 makefile 当中的 # 代表注解；
• <tab> 需要在命令行 (例如 gcc 这个编译器指令) 的第一个字元；
• 标的 (target) 与相依档案(就是目标档)之间需以‘:’隔开。

同样的，我们以刚刚上一个小节的范例进一步说明，如果我想要有两个以上的执行动作时， 例如下达一个指令就直接清除掉所有的目标档与执行档，该如何制作呢？

# 1. 先编辑 makefile 来建立新的规则，此规则的标的名称为 clean ：
[root@www ~]# vi makefile
main: main.o haha.o sin_value.o cos_value.o
	gcc -o main main.o haha.o sin_value.o cos_value.o -lm
clean:
	rm -f main main.o haha.o sin_value.o cos_value.o

# 2. 以新的标的 (clean) 测试看看执行 make 的结果：
[root@www ~]# make clean  <==就是这里！透过 make 以 clean 为标的
rm -rf main main.o haha.o sin_value.o cos_value.o

如此一来，我们的 makefile 里面就具有至少两个标的，分别是 main 与 clean ，如果我们想要建立 main 的话，输入‘make main’，如果想要清除有的没的，输入‘make clean’即可啊！而如果想要先清除目标档再编译 main 这个程式的话，就可以这样输入：‘make clean main’，如下所示：

[root@www ~]# make clean main
rm -rf main main.o haha.o sin_value.o cos_value.o
cc    -c -o main.o main.c
cc    -c -o haha.o haha.c
cc    -c -o sin_value.o sin_value.c
cc    -c -o cos_value.o cos_value.c
gcc -o main main.o haha.o sin_value.o cos_value.o -lm

这样就很清楚了吧！但是，你是否会觉得，咦！ makefile 里面怎么重复的资料这么多啊！没错！所以我们可以再藉由 shell script 那时学到的‘变数’来更简化 makefile 喔：

[root@www ~]# vi makefile
LIBS = -lm
OBJS = main.o haha.o sin_value.o cos_value.o
main: ${OBJS}
        gcc -o main ${OBJS} ${LIBS}
clean:
        rm -f main ${OBJS}

与 bash shell script 的语法有点不太相同，变数的基本语法为：

1. 变数与变数内容以‘=’隔开，同时两边可以具有空格；
2. 变数左边不可以有 <tab> ，例如上面范例的第一行 LIBS 左边不可以是 <tab>；
3. 变数与变数内容在‘=’两边不能具有‘:’；
4. 在习惯上，变数最好是以‘大写字母’为主；
5. 运用变数时，以 ${变数} 或 $(变数) 使用；
6. 在该 shell 的环境变数是可以被套用的，例如提到的 CFLAGS 这个变数！
7. 在指令列模式也可以给予变数。

由于 gcc 在进行编译的行为时，会主动的去读取 CFLAGS 这个环境变数，所以，你可以直接在 shell 定义出这个环境变数，也可以在 makefile 档案里面去定义，更可以在指令列当中给予这个咚咚呢！例如：

[root@www ~]# CFLAGS="-Wall" make clean main
# 这个动作在上 make 进行编译时，会去取用 CFLAGS 的变数内容！

也可以这样：

[root@www ~]# vi makefile
LIBS = -lm
OBJS = main.o haha.o sin_value.o cos_value.o
CFLAGS = -Wall
main: ${OBJS}
	gcc -o main ${OBJS} ${LIBS}
clean:
	rm -f main ${OBJS}

咦！我可以利用指令列进行环境变数的输入，也可以在档案内直接指定环境变数，那万一这个 CFLAGS 的内容在指令列与 makefile 里面并不相同时，以那个方式输入的为主？呵呵！问了个好问题啊！ 环境变数取用的规则是这样的：

1. make 指令列后面加上的环境变数为优先；
2. makefile 里面指定的环境变数第二；
3. shell 原本具有的环境变数第三。

此外，还有一些特殊的变数需要了解的喔：

• $@：代表目前的标的(target)

所以我也可以将 makefile 改成：

[root@www ~]# vi makefile
LIBS = -lm
OBJS = main.o haha.o sin_value.o cos_value.o
CFLAGS = -Wall
main: ${OBJS}
	gcc -o $@ ${OBJS} ${LIBS}   <==那个 $@ 就是 main ！
clean:
	rm -f main ${OBJS}

这样是否稍微了解了 makefile (也可能是 Makefile) 的基本语法？这对于你未来自行修改原始码的编译规则时，是很有帮助的喔！^_^！

从原始码的说明我们晓得要制作一个 binary program 需要很多咚咚的呢！这包括底下这些基础的软体：

• gcc 或 cc 等 C 语言编译器 (compiler)：
  
  没有编译器怎么进行编译的动作？所以 C compiler 是一定要有的。不过 Linux 上面有众多的编译器，其中当然以 GNU 的 gcc 是首选的自由软体编译器啰！事实上很多在 Linux 平台上面发展的软体的原始码，原本就是以 gcc 为底来设计的呢。
  
  
• make 及 autoconfig 等软体：
  
  一般来说，以 Tarball 方式释出的软体当中，为了简化编译的流程，通常都是配合前几个小节提到的 make 这个指令来依据目标档案的相依性而进行编译。但是我们也知道说 make 需要 makefile 这个档案的规则，那由于不同的系统里面可能具有的基础软体环境并不相同， 所以就需要侦测使用者的作业环境，好自行建立一个 makefile 档案。这个自行侦测的小程式也必须要藉由 autoconfig 这个相关的软体来辅助才行。
  
  
• 需要 Kernel 提供的 Library 以及相关的 Include 档案：
  
  从前面的原始码编译过程，我们晓得函式库 (library) 的重要性，同时也晓得有 include 档案的存在。很多的软体在发展的时候都是直接取用系统核心提供的函式库与 include 档案的，这样才可以与这个作业系统相容啊！尤其是在‘驱动程式方面的模组 ’，例如网路卡、音效卡、USB 等驱动程式在安装的时候，常常是需要核心提供的相关资讯的。在 Red Hat 的系统当中 (包含 Fedora/CentOS 等系列) ，这个核心相关的功能通常都是被包含在 kernel-source 或 kernel-header 这些软体名称当中，所以记得要安装这些软体喔！

虽然 Tarball 的安装上面相当的简单，如同我们前面几个小节的例子，只要顺着开发商提供的 README 与 INSTALL 档案所载明的步骤来进行，安装是很容易的。但是我们却还是常常会在 BBS 或者是新闻群组当中发现这些留言：‘我在执行某个程式的侦测档案时，他都会告诉我没有 gcc 这个软体，这是怎么回事？’还有：‘我没有办法使用 make 耶！这是什么问题？’呵呵！ 这就是没有安装上面提到的那些基础软体啦！

咦！为什么使用者不安装这些软体啊？这是因为目前的 Linux distribution 大多已经偏向于桌上型电脑的使用 (非伺服器端)，他们希望使用者能够按照厂商自己的希望来安装相关的软体即可， 所以通常‘预设’是没有安装 gcc 或者是 make 等软体的。所以啦，如果你希望未来可以自行安装一些以 Tarball 方式释出的软体时，记得请自行挑选想要安装的软体名称喔！例如在 CentOS 或者是 Red Hat 当中记得选择 Development Tools 以及 Kernel Source Development 等相关字眼的软体群集呢。

那万一我已经安装好一部 Linux 主机，但是使用的是预设值所安装的软体，所以没有 make, gcc 等咚咚，该如何是好？呵呵！问题其实不大啦，目前使用最广泛的 CentOS/Fedora 或者是 Red Hat 大多是以 RPM (下一章会介绍) 来安装软体的，所以，你只要拿出当初安装 Linux 时的原版光碟，然后以下一章介绍的 RPM 来一个一个的加入到你的 Linux 主机里面就好啦！很简单的啦！ 尤其现在又有 yum 这玩意儿，更方便呐！

在 CentOS 当中，如果你已经有网路可以连上 Internet 的话，那么就可以使用下一章会谈到的 yum 啰！ 透过 yum 的软体群组安装功能，你可以这样做：

• 如果是要安装 gcc 等软体发展工具，请使用‘ yum groupinstall "Development Tools" ’
• 若待安装的软体需要图形介面支援，一般还需要‘ yum groupinstall "X Software Development" ’
• 若安装的软体较旧，可能需要‘ yum groupinstall "Legacy Software Development" ’

大概就是这样，更多的资讯请参考下一章的介绍喔。

我们提过以 Tarball 方式释出的软体是需要重新编译可执行的 binary program 的。而 Tarball 是以 tar 这个指令来打包与压缩的档案，所以啦，当然就需要先将 Tarball 解压缩，然后到原始码所在的目录下进行 makefile 的建立，再以 make 来进行编译与安装的动作啊！所以整个安装的基础动作大多是这样的：

1. 取得原始档：将 tarball 档案在 /usr/local/src 目录下解压缩；
2. 取得步骤流程：进入新建立的目录底下，去查阅 INSTALL 与 README 等相关档案内容 (很重要的步骤！)；
3. 相依属性软体安装：根据 INSTALL/README 的内容察看并安装好一些相依的软体 (非必要)；
4. 建立 makefile：以自动侦测程式 (configure 或 config) 侦测作业环境，并建立 Makefile 这个档案；
5. 编译：以 make 这个程式并使用该目录下的 Makefile 做为他的参数设定档，来进行 make (编译或其他) 的动作；
6. 安装：以 make 这个程式，并以 Makefile 这个参数设定档，依据 install 这个标的 (target) 的指定来安装到正确的路径！

注意到上面的第二个步骤，通常在每个软体在释出的时候，都会附上 INSTALL 或者是 README 这种档名的说明档，这些说明档请‘确实详细的’ 阅读过一遍，通常这些档案会记录这个软体的安装要求、软体的工作项目、 与软体的安装参数设定及技巧等，只要仔细的读完这些档案，基本上，要安装好 tarball 的档案，都不会有什么大问题啰。

至于 makefile 在制作出来之后，里头会有相当多的标的 (target)，最常见的就是 install 与 clean 啰！通常‘make clean’代表着将目标档 (object file) 清除掉，‘make’则是将原始码进行编译而已。 注意喔！编译完成的可执行档与相关的设定档还在原始码所在的目录当中喔！因此，最后要进行‘make install’来将编译完成的所有咚咚都给他安装到正确的路径去，这样就可以使用该软体啦！

OK！我们底下约略提一下大部分的 tarball 软体之安装的指令下达方式：

1. ./configure
   这个步骤就是在建立 Makefile 这个档案啰！通常程式开发者会写一支 scripts 来检查你的 Linux 系统、相关的软体属性等等，这个步骤相当的重要， 因为未来你的安装资讯都是这一步骤内完成的！另外，这个步骤的相关资讯应该要参考一下该目录下的 README 或 INSTALL 相关的档案！
   
   
2. make clean
   make 会读取 Makefile 中关于 clean 的工作。这个步骤不一定会有，但是希望执行一下，因为他可以去除目标档案！因为谁也不确定原始码里面到底有没有包含上次编译过的目标档案 (*.o) 存在，所以当然还是清除一下比较妥当的。 至少等一下新编译出来的执行档我们可以确定是使用自己的机器所编译完成的嘛！
   
   
3. make
   make 会依据 Makefile 当中的预设工作进行编译的行为！编译的工作主要是进行 gcc 来将原始码编译成为可以被执行的 object files ，但是这些 object files 通常还需要一些函式库之类的 link 后，才能产生一个完整的执行档！使用 make 就是要将原始码编译成为可以被执行的可执行档，而这个可执行档会放置在目前所在的目录之下， 尚未被安装到预定安装的目录中；
   
   
4. make install
   通常这就是最后的安装步骤了，make 会依据 Makefile 这个档案里面关于 install 的项目，将上一个步骤所编译完成的资料给他安装到预定的目录中，就完成安装啦！

请注意，上面的步骤是一步一步来进行的，而其中只要一个步骤无法成功，那么后续的步骤就完全没有办法进行的！ 因此，要确定每一的步骤都是成功的才可以！举个例子来说，万一今天你在 ./configure 就不成功了，那么就表示 Makefile 无法被建立起来，要知道，后面的步骤都是根据 Makefile 来进行的，既然无法建立 Makefile，后续的步骤当然无法成功啰！

另外，如果在 make 无法成功的话，那就表示原始档案无法被编译成可执行档，那么 make install 主要是将编译完成的档案给他放置到档案系统中的，既然都没有可用的执行档了，怎么进行安装？ 所以啰，要每一个步骤都正确无误才能往下继续做！此外，如果安装成功， 并且是安装在独立的一个目录中，例如 /usr/local/packages 这个目录中好了，那么你就必需手动的将这个软体的 man page 给他写入 /etc/man.config 里面去。

或许你已经发现了也说不定，那就是为什么前一个小节里面， Tarball 要在 /usr/local/src 里面解压缩呢？基本上，在预设的情况下，原本的 Linux distribution 释出安装的软体大多是在 /usr 里面的，而使用者自行安装的软体则建议放置在 /usr/local 里面。这是考量到管理使用者所安装软体的便利性。

怎么说呢？我们晓得几乎每个软体都会提供线上说明的服务，那就是 info 与 man 的功能。在预设的情况下， man 会去搜寻 /usr/local/man 里面的说明文件， 因此，如果我们将软体安装在 /usr/local 底下的话，那么自然安装完成之后， 该软体的说明文件就可以被找到了。此外，如果你所管理的主机其实是由多人共同管理的， 或者是如同学校里面，一部主机是由学生管理的，但是学生总会毕业吧？ 所以需要进行交接，如果大家都将软体安装在 /usr/local 底下，那么管理上不就显的特别的容易吗！

所以啰，通常我们会建议大家将自己安装的软体放置在 /usr/local 下，至于原始码 (Tarball)则建议放置在 /usr/local/src (src 为 source 的缩写)底下啊。

再来，让我们先来看一看 Linux distribution 预设的安装软体的路径会用到哪些？我们以 apache 这个软体来说明的话 (apache 是 WWW 伺服器软体，详细的资料请参考伺服器架设篇。你的系统不见得有装这个软体)：

• /etc/httpd
• /usr/lib
• /usr/bin
• /usr/share/man

我们会发现软体的内容大致上是摆在 etc, lib, bin, man 等目录当中，分别代表‘设定档、函式库、执行档、线上说明档’。 好了，那么你是以 tarball 来安装时呢？如果是放在预设的 /usr/local 里面，由于 /usr/local 原本就预设这几个目录了，所以你的资料就会被放在：

• /usr/local/etc
• /usr/local/bin
• /usr/local/lib
• /usr/local/man

但是如果你每个软体都选择在这个预设的路径下安装的话， 那么所有的软体的档案都将放置在这四个目录当中，因此，如果你都安装在这个目录下的话， 那么未来再想要升级或移除的时候，就会比较难以追查档案的来源啰！ 而如果你在安装的时候选择的是单独的目录，例如我将 apache 安装在 /usr/local/apache 当中，那么你的档案目录就会变成：

• /usr/local/apache/etc
• /usr/local/apache/bin
• /usr/local/apache/lib
• /usr/local/apache/man

呵呵！单一软体的档案都在同一个目录之下，那么要移除该软体就简单的多了！ 只要将该目录移除即可视为该软体已经被移除啰！以上面为例，我想要移除 apache 只要下达‘rm -rf /usr/local/apache’ 就算移除这个软体啦！当然啰，实际安装的时候还是得视该软体的 Makefile 里头的 install 资讯才能知道到底他的安装情况为何的。因为例如 sendmail 的安装就很麻烦......

这个方式虽然有利于软体的移除，但不晓得你有没有发现，我们在执行某些指令的时候，与该指令是否在 PATH 这个环境变数所记录的路径有关，以上面为例，我的 /usr/local/apache/bin 肯定是不在 PATH 里面的，所以执行 apache 的指令就得要利用绝对路径了，否则就得将这个 /usr/local/apache/bin 加入 PATH 里面。另外，那个 /usr/local/apache/man 也需要加入 man page 搜寻的路径当中啊！

除此之外， Tarball 在升级的时候也是挺困扰的，怎么说呢？我们还是以 apache 来说明好了。WWW 伺服器为了考虑互动性，所以通常会将 PHP+MySQL+Apache 一起安装起来 (详细的资讯请参考伺服器架设篇) ，果真如此的话，那么每个软体在安装的时候‘都有一定的顺序与程序！’ 因为他们三者之间具有相关性，所以安装时必需要三者同时考虑到他们的函式库与相关的编译参数。

假设今天我只要升级 PHP 呢？有的时候因为只有涉及动态函式库的升级，那么我只要升级 PHP 即可！其他的部分或许影响不大。但是如果今天 PHP 需要重新编译的模组比较多，那么可能会连带的，连 Apache 这个程式也需要重新编译过才行！真是有点给他头痛的！没办法啦！使用 tarball 确实有他的优点啦，但是在这方面，确实也有他一定的伤脑筋程度。

由于 Tarball 在升级与安装上面具有这些特色，亦即 Tarball 在反安装上面具有比较高的难度 (如果你没有好好规划的话～)，所以，为了方便 Tarball 的管理，通常鸟哥会这样建议使用者：

1. 最好将 tarball 的原始资料解压缩到 /usr/local/src 当中；
   
   
2. 安装时，最好安装到 /usr/local 这个预设路径下；
   
   
3. 考虑未来的反安装步骤，最好可以将每个软体单独的安装在 /usr/local 底下；
   
   
4. 为安装到单独目录的软体之 man page 加入 man path 搜寻：
   如果你安装的软体放置到 /usr/local/software/ ，那么 man page 搜寻的设定中，可能就得要在 /etc/man.config 内的 40~50 行左右处，写入如下的一行：

   MANPATH /usr/local/software/man

   这样才可以使用 man 来查询该软体的线上文件啰！

读万卷书不如行万里路啊！所以当然我们就来给他测试看看，看你是否真的了解了如何利用 Tarball 来安装软体呢？我们利用时间伺服器 (network time protocol) ntp 这个软体来测试安装看看。先请到 http://www.ntp.org/downloads.html 这个目录去下载档案，请下载最新版本的档案即可。或者直接到鸟哥的网站下载 2009/05 公告释出的稳定版本：

http://linux.vbird.org/linux_basic/0520source/ntp-4.2.4p7.tar.gz

假设我对这个软体的要求是这样的：

• 假设 ntp-4.2.4p7.tar.gz 这个档案放置在 /root 这个目录下；
• 原始码请解开在 /usr/local/src 底下；
• 我要安装到 /usr/local/ntp 这个目录中；

那么你可以依照底下的步骤来安装测试看看 (如果可以的话，请你不要参考底下的文件资料， 先自行安装过一遍这个软体，然后再来对照一下鸟哥的步骤喔！)。

• 解压缩下载的 tarball ，并参阅 README/INSTALL 档案

[root@www ~]# cd /usr/local/src   <==切换目录
[root@www src]# tar -zxvf /root/ntp-4.2.4p7.tar.gz  <==解压缩到此目录
ntp-4.2.4p7/         <==会建立这个目录喔！
ntp-4.2.4p7/libopts/
....(底下省略)....
[root@www src]# cd ntp-4.2.4p7/
[root@www ntp-4.2.4p7]# vi INSTALL  <==记得 README 也要看一下！
# 特别看一下 28 行到 54 行之间的安装简介！可以了解如何安装的流程喔！

• 检查 configure 支援参数，并实际建置 makefile 规则档

[root@www ntp*]# ./configure --help | more  <==查询可用的参数有哪些
  --prefix=PREFIX         install architecture-independent files in PREFIX
  --enable-all-clocks     + include all suitable non-PARSE clocks:
  --enable-parse-clocks   - include all suitable PARSE clocks:
# 上面列出的是比较重要的，或者是你可能需要的参数功能！

[root@www ntp*]# ./configure --prefix=/usr/local/ntp \
>  --enable-all-clocks --enable-parse-clocks  <==开始建立makefile
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
....(中间省略)....
checking for gcc... gcc           <==也有找到 gcc 编译器了！
....(中间省略)....
config.status: creating Makefile  <==现在知道这个重要性了吧？
config.status: creating config.h
config.status: executing depfiles commands

一般来说 configure 设定参数较重要的就是那个 --prefix=/path 了，--prefix 后面接的路径就是‘这个软体未来要安装到那个目录去？’如果你没有指定 --prefix=/path 这个参数，通常预设参数就是 /usr/local 至于其他的参数意义就得要参考 ./configure --help 了！ 这个动作完成之后会产生 makefile 或 Makefile 这个档案。当然啦，这个侦测检查的过程会显示在荧幕上， 特别留意关于 gcc 的检查，还有最重要的是最后需要成功的建立起 Makefile 才行！

• 最后开始编译与安装噜！

[root@www ntp*]# make clean; make
[root@www ntp*]# make check
[root@www ntp*]# make install
# 将资料给他安装在 /usr/local/ntp 底下

整个动作就这么简单，你完成了吗？完成之后到 /usr/local/ntp 你发现了什么？

我们在本章一开始介绍了为何需要进行软体的升级，这是很重要的喔！那假如我是以 Tarball 来进行某个软体的安装，那么是否当我要升级这个软体时，就得要下载这个软体的完整全新的 Tarball 呢？举个例子来说，鸟哥帮昆山资传系架了个讨论区在 http://www.dic.ksu.edu.tw/phpbb3 这个网址，这个讨论区是以 phpBB 这个软体来架设的，而鸟哥的讨论区版本为 phpbb3.0.4.tar.gz ，目前 (2009/06) 最新释出的版本则是 phpbb3.0.5.tar.gz 。那我是否需要下载全新的 phpbb3.0.5.tar.gz 这个档案来更新原本的旧程式呢？

事实上，当我们发现一些软体的漏洞，通常是某一段程式码写的不好所致。因此， 所谓的‘更新原始码’常常是只有更改部分档案的小部分内容而已。既然如此的话， 那么我们是否可以就那些被更动的档案来进行修改就可以咯？也就是说， 旧版本到新版本间没有更动过的档案就不要理他，仅将有修订过的档案部分来处理即可。

这有什么好处呢？首先，没有更动过的档案的目标档 (object file) 根本就不需要重新编译，而且有更动过的档案又可以利用 make 来自动 update (更新)，如此一来，我们原先的设定 (makefile 档案里面的规则) 将不需要重新改写或侦测！可以节省很多宝贵的时间呢 (例如后续章节会提到的核心的编译！)

从上面的说明当中，我们可以发现，如果可以将旧版的原始码资料改写成新版的版本， 那么就能直接编译了，而不需要将全部的新版 Tarball 重新下载一次呢！可以节省频宽与时间说！那么如何改写原始码？ 难道要我们一个档案一个档案去参考然后修订吗？当然没有这么没人性！

我们在第十二章、正规表示法的时候有提到一个比对档案的指令，那就是 diff，这个指令可以将‘两个档案之间的差异性列出来’呢！那我们也知道新旧版本的档案之间， 其实只有修改一些程式码而已，那么我们可以透过 diff 比对出新旧版本之间的文字差异，然后再以相关的指令来将旧版的档案更新吗？ 呵呵！当然可以啦！那就是 patch 这个指令啦！很多的软体开发商在更新了原始码之后，几乎都会释出所谓的 patch file，也就是直接将原始码 update 而已的一个方式喔！我们底下以一个简单的范例来说明给你了解喔！

关于 diff 与 patch 的基本用法我们在第十二章都谈过了，所以这里不再就这两个指令的语法进行介绍， 请回去参阅第十二章的内容。这里我们来举个案例解释一下好了。假设我们刚刚计算三角函数的程式 (main) 历经多次改版， 0.1 版仅会简单的输出， 0.2 版的输出就会含有角度值，因此这两个版本的内容不相同。如下所示，两个档案的意义为：

• http://linux.vbird.org/linux_basic/0520source/main-0.1.tgz ：main 的 0.1 版；
• http://linux.vbird.org/linux_basic/0520source/main_0.1_to_0.2.patch ：main 由 0.1 升级到 0.2 的 patch file；

请您先下载这两个档案，并且解压缩到你的 /root 底下。你会发现系统产生一个名为 main-0.1 的目录。 该目录内含有五个档案，就是刚刚的程式加上一个 Makefile 的规则档案。你可以到该目录下去看看 Makefile 的内容， 在这一版当中含有 main 与 clean 两个标的功能而已。至于 0.2 版则加入了 install 与 uninstall 的规则设定。 接下来，请看一下我们的作法啰：

• 测试旧版程式的功能

[root@www ~]# tar -zxvf main-0.1.tgz
[root@www ~]# cd main-0.1
[root@www main-0.1]# make clean main
[root@www main-0.1]# ./main
version 0.1
Please input your name: VBird
Please enter the degree angle (ex> 90): 45
Hi, Dear VBird, nice to meet you.
The Sin is:  0.71
The Cos is:  0.71

与之前的结果非常类似，只是鸟哥将 Makefile 直接给您了！但如果你下达 make install 时，系统会告知没有 install 的 target 啊！而且版本是 0.1 也告知了。那么如何更新到 0.2 版呢？透过这个 patch 档案吧！这个档案的内容有点像这样：

• 查阅 patch file 内容

[root@www main-0.1]# vim ~/main_0.1_to_0.2.patch
diff -Naur main-0.1/cos_value.c main-0.2/cos_value.c
--- main-0.1/cos_value.c        2009-06-09 22:52:33.000000000 +0800
+++ main-0.2/cos_value.c        2009-06-12 00:45:10.000000000 +0800
@@ -6,5 +6,5 @@
 {
        float value;
....(底下省略)....

上面表格内有个底线的部分，那代表使用 diff 去比较时，被比较的两个档案所在路径，这个路径非常的重要喔！ 因为 patch 的基本语法如下：

patch -p数字 < patch_file

特别留意那个‘ -p数字’，那是与 patch_file 里面列出的档名有关的资讯。假如在 patch_file 第一行写的是这样：

*** /home/guest/example/expatch.old

那么当我下达‘ patch -p0 < patch_file ’时，则更新的档案是‘ /home/guest/example/expatch.old ’，如果‘ patch -p1 < patch_file’，则更新的档案为‘home/guest/example/expatch.old’，如果‘patch -p4 < patch_file’则更新‘expatch.old’，也就是说， -pxx 那个 xx 代表‘拿掉几个斜线(/)’的意思！这样可以理解了吗？ 好了，根据刚刚上头的资料，我们可以发现比较的档案是在 main-0.1/xxx 与 main-0.2/xxx ， 所以说，如果你是在 main-0.1 底下，并且想要处理更新时，就得要拿掉一个目录 (因为并没有 main-0.2 的目录存在， 我们是在当前的目录进行更新的！)，因此使用的是 -p1 才对喔！所以：

• 更新原始码，并且重新编译程式！

[root@www main-0.1]# patch -p1 < ../main_0.1_to_0.2.patch
patching file cos_value.c
patching file main.c
patching file Makefile
patching file sin_value.c
# 请注意，鸟哥目前所在目录是在 main-0.1 底下喔！注意与 patch 档案的相对路径！
# 虽然有五个档案，但其实只有四个档案有修改过喔！上面显示有改过的档案！

[root@www main-0.1]# make clean main
[root@www main-0.1]# ./main
version 0.2
Please input your name: VBird
Please enter the degree angle (ex> 90): 45
Hi, Dear VBird, nice to meet you.
The sin(45.000000) is:  0.71
The cos(45.000000) is:  0.71
# 你可以发现，输出的结果中版本变了，输出资讯多了括号 () 喔！

[root@www main-0.1]# make install   <==将他安装到 /usr/local/bin 给大家用
cp -a main /usr/local/bin
[root@www main-0.1]# main           <==直接输入指令可执行！
[root@www main-0.1]# make uninstall <==移除此软体！
rm -f /usr/local/bin/main

很有趣的练习吧！所以你只要下载 patch file 就能够对你的软体原始码更新了！只不过更新了原始码并非软体就更新！你还是得要将该软体进行编译后，才会是最终正确的软体喔！ 因为 patch 的功能主要仅只是更新原始码档案而已！切记切记！此外，如果你 patch 错误呢？没关系的！我们的 patch 是可以还原的啊！透过‘ patch -R < ../main_0.1_to_0.2.patch ’就可以还原啦！很有趣吧！

首先我们要知道的是，函式库的类型有哪些？依据函式库被使用的类型而分为两大类，分别是静态 (Static) 与动态 (Dynamic) 函式库两类。底下我们来谈一谈这两种类行的函式库吧！

• 静态函式库的特色：

• 副档名：(副档名为 .a)
  这类的函式库通常副档名为 libxxx.a 的类型；
  
  
• 编译行为：
  这类函式库在编译的时候会直接整合到执行程式当中，所以利用静态函式库编译成的档案会比较大一些喔；
  
  
• 独立执行的状态：
  这类函式库最大的优点，就是编译成功的可执行档可以独立执行，而不需要再向外部要求读取函式库的内容 (请参照动态函式库的说明)。
  
  
• 升级难易度：
  虽然执行档可以独立执行，但因为函式库是直接整合到执行档中， 因此若函式库升级时，整个执行档必须要重新编译才能将新版的函式库整合到程式当中。 也就是说，在升级方面，只要函式库升级了，所有将此函式库纳入的程式都需要重新编译！

• 动态函式库的特色：

• 副档名：(副档名为 .so)
  这类函式库通常副档名为 libxxx.so 的类型；
  
  
• 编译行为：
  动态函式库与静态函式库的编译行为差异挺大的。 与静态函式库被整个捉到程式中不同的，动态函式库在编译的时候，在程式里面只有一个‘指向 (Pointer)’的位置而已。也就是说，动态函式库的内容并没有被整合到执行档当中，而是当执行档要使用到函式库的机制时， 程式才会去读取函式库来使用。由于执行档当中仅具有指向动态函式库所在的指标而已， 并不包含函式库的内容，所以他的档案会比较小一点。
  
  
• 独立执行的状态：
  这类型的函式库所编译出来的程式不能被独立执行， 因为当我们使用到函式库的机制时，程式才会去读取函式库，所以函式库档案‘必须要存在’才行，而且，函式库的‘所在目录也不能改变’，因为我们的可执行档里面仅有‘指标’亦即当要取用该动态函式库时， 程式会主动去某个路径下读取，呵呵！所以动态函式库可不能随意移动或删除，会影响很多相依的程式软体喔！
  
  
• 升级难易度：
  虽然这类型的执行档无法独立运作，然而由于是具有指向的功能， 所以，当函式库升级后，执行档根本不需要进行重新编译的行为，因为执行档会直接指向新的函式库档案 (前提是函式库新旧版本的档名相同喔！)。

目前的 Linux distribution 比较倾向于使用动态函式库，因为如同上面提到的最重要的一点， 就是函式库的升级方便！由于 Linux 系统里面的软体相依性太复杂了，如果使用太多的静态函式库，那么升级某一个函式库时， 都会对整个系统造成很大的冲击！因为其他相依的执行档也要同时重新编译啊！ 这个时候动态函式库可就有用多了，因为只要动态函式库升级就好，其他的软体根本无须变动。

那么这些函式库放置在哪里呢？绝大多数的函式库都放置在：/usr/lib, /lib 目录下！ 此外，Linux 系统里面很多的函式库其实 kernel 就提供了，那么 kernel 的函式库放在哪里？呵呵！就是在 /lib/modules 里面啦！里面的资料可多着呢！不过要注意的是， 不同版本的核心提供的函式库差异性是挺大的，所以 kernel 2.4.xx 版本的系统不要想将核心换成 2.6.xx 喔！ 很容易由于函式库的不同而导致很多原本可以执行的软体无法顺利运作呢！

在了解了动态与静态函式库，也知道我们目前的 Linux 大多是将函式库做成动态函式库之后，再来要知道的就是，那有没有办法增加函式库的读取效能？ 我们知道记忆体的存取速度是硬碟的好几倍，所以，如果我们将常用到的动态函式库先载入记忆体当中 (快取, cache)，如此一来，当软体要取用动态函式库时，就不需要从头由硬碟里面读出啰！ 这样不就可以增进动态函式库的读取速度？没错，是这样的！这个时候就需要 ldconfig 与 /etc/ld.so.conf 的协助了。

如何将动态函式库载入快取记忆体当中呢？

1. 首先，我们必须要在 /etc/ld.so.conf 里面写下‘ 想要读入快取记忆体当中的动态函式库所在的目录’，注意喔， 是目录而不是档案；
2. 接下来则是利用 ldconfig 这个执行档将 /etc/ld.so.conf 的资料读入快取当中；
3. 同时也将资料记录一份在 /etc/ld.so.cache 这个档案当中呐！

图 5.2.1、使用 ldconfig 预载入动态函式库到记忆体中

事实上， ldconfig 还可以用来判断动态函式库的连结资讯呢！赶紧利用 CentOS 来测试看看。假设你想要将目前你系统下的 MySQL 函式库加入到快取当中时，可以这样做：

[root@www ~]# ldconfig [-f conf] [ -C cache]
[root@www ~]# ldconfig [-p]
选项与参数：
-f conf ：那个 conf 指的是某个档案名称，也就是说，使用 conf 作为 libarary 
	  函式库的取得路径，而不以 /etc/ld.so.conf 为预设值
-C cache：那个 cache 指的是某个档案名称，也就是说，使用 cache 作为快取暂存
	  的函式库资料，而不以 /etc/ld.so.cache 为预设值
-p	：列出目前有的所有函式库资料内容 (在 /etc/ld.so.cache 内的资料！)

范例一：假设我的 MySQL 资料库函式库在 /usr/lib/mysql 当中，如何读进 cache ？
[root@www ~]# vi /etc/ld.so.conf
include ld.so.conf.d/*.conf
/usr/lib/mysql   <==这一行新增的啦！

[root@www ~]# ldconfig  <==画面上不会显示任何的资讯，不要太紧张！正常的！

[root@www ~]# ldconfig -p
530 libs found in cache `/etc/ld.so.cache'
        libz.so.1 (libc6) => /usr/lib/libz.so.1
        libxslt.so.1 (libc6) => /usr/lib/libxslt.so.1
....(底下省略)....
#       函式库名称 => 该函式库实际路径

透过上面的动作，我们可以将 MySQL 的相关函式库给他读入快取当中，这样可以加快函式库读取的效率呢！ 在某些时候，你可能会自行加入某些 Tarball 安装的动态函式库，而你想要让这些动态函式库的相关连结可以被读入到快取当中， 这个时候你可以将动态函式库所在的目录名称写入 /etc/ld.so.conf 当中，然后执行 ldconfig 就可以啦！

说了这么多，那么我如何判断某个可执行的 binary 档案含有什么动态函式库呢？很简单，利用 ldd 就可以晓得了！例如我想要知道 /usr/bin/passwd 这个程式含有的动态函式库有哪些，可以这样做：

[root@www ~]# ldd [-vdr] [filename]
选项与参数：
-v ：列出所有内容资讯；
-d ：重新将资料有遗失的 link 点秀出来！
-r ：将 ELF 有关的错误内容秀出来！

范例一：找出 /usr/bin/passwd 这个档案的函式库资料
[root@www ~]# ldd /usr/bin/passwd
....(前面省略)....
        libaudit.so.0 => /lib/libaudit.so.0 (0x00494000)     <==SELinux
        libselinux.so.1 => /lib/libselinux.so.1 (0x00101000) <==SELinux
        libc.so.6 => /lib/libc.so.6 (0x00b99000)
        libpam.so.0 => /lib/libpam.so.0 (0x004ab000)         <==PAM 模组
....(底下省略)....
# 我们前言的部分不是一直提到 passwd 有使用到 pam 的模组吗！怎么知道？
# 利用 ldd 察看一下这个档案，看到 libpam.so 了吧？这就是 pam 提供的函式库

范例二：找出 /lib/libc.so.6 这个函式的相关其他函式库！
[root@www ~]# ldd -v /lib/libc.so.6
        /lib/ld-linux.so.2 (0x00ab3000)
        linux-gate.so.1 =>  (0x00636000)

        Version information:  <==使用 -v 选项，增加显示其他版本资讯！
        /lib/libc.so.6:
                ld-linux.so.2 (GLIBC_PRIVATE) => /lib/ld-linux.so.2
                ld-linux.so.2 (GLIBC_2.3) => /lib/ld-linux.so.2
                ld-linux.so.2 (GLIBC_2.1) => /lib/ld-linux.so.2

未来如果你常常升级安装 RPM 的软体时 (下一章节会介绍)，应该常常会发现那个‘ 相依属性’的问题吧！没错！我们可以先以 ldd 来视察‘相依函式库’之间的相关性！以先取得了解！ 例如上面的例子中，我们检查了 libc.so.6 这个在 /lib 当中的函式库，结果发现他其实还跟 ld-linux.so.2 有关！所以我们就需要来了解一下，那个档案到底是什么软体的函式库呀？使用 -v 这个参数还可以得知该函式库来自于哪一个软体！像上面的资料中，就可以得到该 libc.so.6 其实可以支援 GLIBC_2.1 等的版本！

目前有多种机制可以计算档案的指纹码，我们选择使用较为广泛的 MD5 与 SHA1 加密机制来处理。 同样的，我们以高速电脑中心谈到的 CentOS 5.3 的网路安装映像档来处理试看看好了。 在上面的连结网址上面，你会看到几个档案：

• CentOS-5.3-i386-netinstall.iso：CentOS 5.3 的网路安装映像档；
• md5sum.txt： MD5 指纹编码
• sha1sum.txt： SHA1 指纹编码

如果你下载了 CentOS-5.3-i386-netinstall.iso 后，再以 md5sum 与 sha1sum 去检验这个档案时， 档案所回传的指纹码应该要与网站上面提供的档案指纹码相同才对！我们由网站上面提供的指纹码知道这个映像档的指纹为：

• MD5 : 6ae4077a9fc2dcedca96013701bd2a43
• SHA1: a0c640ae0c68cc0d9558cf4f8855f24671b3dadb

[root@www ~]# md5sum/sha1sum [-bct] filename
[root@www ~]# md5sum/sha1sum [--status|--warn] --check filename
选项与参数：
-b ：使用 binary 的读档方式，预设为 Windows/DOS 档案型态的读取方式；
-c ：检验档案指纹；
-t ：以文字型态来读取档案指纹。

范例一：将刚刚的档案下载后，测试看看指纹码
[root@www ~]# wget \
> http://ftp.twaren.net/Linux/CentOS/5.3/isos/i386/CentOS-5.3-i386-netinstall.iso
[root@www ~]# md5sum CentOS-5.3-i386-netinstall.iso
6ae4077a9fc2dcedca96013701bd2a43  CentOS-5.3-i386-netinstall.iso
[root@www ~]# sha1sum CentOS-5.3-i386-netinstall.iso
a0c640ae0c68cc0d9558cf4f8855f24671b3dadb  CentOS-5.3-i386-netinstall.iso
# 看！显示的编码是否与上面相同呢？赶紧测试看看！

一般而言，每个系统里面的档案内容大概都不相同，例如你的系统中的 /etc/passwd 这个登入资讯档与我的一定不一样，因为我们的使用者与密码、 Shell 及家目录等大概都不相同，所以由 md5sum 这个档案指纹分析程式所自行计算出来的指纹表当然就不相同啰！

好了，那么如何应用这个东西呢？基本上，你必须要在你的 Linux 系统上为你的这些重要的档案进行指纹资料库的建立 (好像在做户口调查！)，将底下这些档案建立资料库：

• /etc/passwd
• /etc/shadow( 假如你不让使用者改密码了 )
• /etc/group
• /usr/bin/passwd
• /sbin/portmap
• /bin/login ( 这个也很容易被骇！ )
• /bin/ls
• /bin/ps
• /usr/bin/top

这几个档案最容易被修改了！因为很多木马程式执行的时候，还是会有所谓的‘执行序, PID’为了怕被 root 追查出来，所以他们都会修改这些检查排程的档案，如果你可以替这些档案建立指纹资料库 (就是使用 md5sum 检查一次，将该档案指纹记录下来，然后常常以 shell script 的方式由程式自行来检查指纹表是否不同了！)，那么对于档案系统会比较安全啦！