软件安装：原始码与Tarball

软件安装

在Windows系统上面的软件都是一模一样的安装，但是你无法修改该软件的源代码，万一想要增加或减少该软件的某些功能时，那就只能求助于开发软件的厂商了，

又例如网络上的病毒，可能会对某些软件造成影响，导致主机的当机或其他数据的损坏等，此时如果你可以对该开发软件进行修改的话，就可以很快速的修补好该软件

的漏洞，而不必等到软件开放商提供修补的程序包

只要有网络存在的一天，程序的漏洞是永远补不完的

Linux的优点是软件几乎都是经过GPL的授权，每个软件几乎都提供源代码，并可以自行修改程序代码

开放源码的含义：

可执行文件，在Linux系统上面，一个档案能不能被执行看得是有没有可执行的那个X权限，而Linux系统上真正认识的可执行文件其实是二进制文件，例 

如/usr/bin/passwd, /bin/touch这些档案即为二进制程序代码，所有就算有X权限，也不能保证可以执行成功的，其实Shell Script只是利用shell(例如bash)这个程序的功能进行

一些判断式，最终执行的除了bash提供的功能外，仍是呼叫一些已经编译好的二进制程序来执行，bash本身也是一支二进制程序，可以通过file来检验某个档案是否为binary

例如 :

file /bin/bash,结果中如果会显示执行文件类别(ELF 32-bit LSB executable)，同时会说明是否使用动态函数库(shared libs)，那就一定是binary而且是可执行的

如果是一般的script ，那就会显示出text executables之类的字样

file /etc/init.d/syslog， syslog的数据显示出Bourne-Again ... 那一行，纯粹是第一行有宣告 #!/bin/bash 的缘故，如果将这行去掉，那么不管/etc/init.d/syslog 的权限为何，

他其实显示的是ASCII文本文件的信息

需要做出一支binary的程序，先要使用vim来进行程序的撰写，写完的程序就是所谓的源代码，这个源代码其实就是一般的纯文本档，在完成这个原始码档案的编写之后，再来

就是将这个档案编译成为系统看得懂得binary program，此时当然就需要【编译程序】，经过编译程序的编译与连接之后，就完成了一支可执行的binary program啦

在Linux上面最标准的程序语言是C，所以可以使用C的语法进行源代码的书写，写完后，以LInux上标准的C语言编译程序gcc这支程序来编译，就可以制作出一支可执行的

binary program啦，事实上，在编译的过程中会产生所谓的目标文件(Object file),这个档案以*.o的扩展名样式存在，至于C语言的原始码档案通常以*.c作为扩展名，有时候

我们会在程序当中引用，呼叫其他外部子程序，或者是其他软件提供的【函数功能】，这个时候，要在编译的过程当中，将该函数库给加进去，编译程序就可以将所有的程序

代码与函数库做一个连接以产生正确的执行档

开放源码：就是程序代码，写给人类看的程序语言，但机器并不认识，所以无法执行；

编译程序：将程序代码转译成为机器看的懂得语言，就类似翻译者的角色；

可执行文件：经过编译程序变成二进制程序后，机器看的懂所以可以执行的档案。

函式库的含义：在Linux系统上通常已经提供一个可以进行身份验证的模块，就是PAM模块，PAM模块的功能就是可以让很多的程序在被执行的时候

除了可以验证用户登录的信息，还可以降身份确认的数据记录在登录档里面，方便管理员追踪，当你需要编写具有身份认证功能的程序时，直接引用该PAM的功能就好了

不需要重新设计认证机制了，只要在写程序代码里面，去呼叫PAM的函数功能，你写的程序就可以利用Linux原本就有的身份认证的程序了，LInux中提供了相当多的函式库来

给硬件开发者利用的，凼式库又分为动态与静态凼式库

如果想要在程序里面加入引用的函式库，亦即在编辑的过程中，就需要加入函式库的相关设定，Linux核心提供很多的核心相关函式库与外部参数，这些功能在设计硬件的驱动

程序的时候是相当有用的信息，这些核心相关信息大多放置在/usr/include , /lib, /usr/lib里面，函式库类似子程序的东东，可以被呼叫来执行的一段功能函数

make与configure

由于一套软件不会仅有一支程序，而是有一堆程序代码档案，所以每个主程序与子程序都需要写上一笔编译过程的指令外，还需要写上最终的连接程序，此时gcc编译过程就

不简单了，像WWW服务器软件或者是类似核心的源代码，动则数百MBytes的数据量，编译程序会写到疯的，此时可以使用make这个指令的相关功能来进行编译过程的指令

简化了

当执行make时，会在当时的目录下搜索makefile这个文本文件，而makefile则记录了原始码如何编译的详细信息，make会自动判断原始码是否经过变动了，而自行更新执行档

makefile是一支程序，通常软件开发商都会写一支侦测程序，侦测用户的作业环境，这个侦测程序的文件名为configure或者config，软件开发商不会仅针对Linux开发，而是

针对Unix-like开发的，所以要侦测该操作系统平台有没有提供合适的编译程序，侦测程序会侦测的数据如下这些

是否有合适的编译程序可以编译本软件的程序代码；

是否已经存在本软件所需要的凼式库，或者他需要的相依软件；

操作系统平台是否合适本软件，包括 Linux 的核心版本；

核心的表头定义档 (header include) 是否存在 (驱动程序必须要的侦测)

make与configure运作流程的相关性，一个是执行configure来建立Makefile，成功之后再以make来呼叫所需要的数据来编译即可

编译执行的顺序是：程序源代码官网下载，接着通过configure侦测程序找到所需函式库，编译器，其他所需资料，都找到则由configure主动建立makefile文件，接着执行make

指令依据makefile的定义，呼叫原始码，函式库，编译器来进行编译，最终产生软件(含设定档与执行档)

由于函式库路径和名称，或者安装的编译程序与核心的版本都不相同，因此无法将centos上编译出的binary program 拿到Suse上面执行，不可能成功的，所以同一款软件在

不同的平台上面执行时，必须要重新编译

Tarball软件

软件的源代码其实就是写满了程序代码的纯文本档案，如果在网络上传输是很浪费带宽的一种文本格式，所以需要将原始码打包与压缩来将数量与容量减小，不但与用户容易

下载，网站的带宽也节省了很多，这就是Tarball档案的由来

Tarball档案 其实就是就是先将原始码通过tar打包，接着使用gzip或bzip2来压缩，生成的档名为*.tar.gz或*.tar.bz2之类的名称，Tarball是一个软件包，解压后的档案通常有：

1.源代码档案

2.侦测程序档案(可能是configure或config等档名)

3.简易说明及安装说明(INSTALL或README)  通常你只要能够参考这两个档案

tarball软件的升级

1.需要新的功能，但旧有主机的旧版软件并没有，所以需要升级到新版的软件

2.旧版本的软件上面可能有资安上的顾虑，所以需要更新到新版的软件

3.旧版的软件执行效能不好，或者执行的能力不能让管理者满足

更新或升级的方法包含两大类

1.直接以原始码透过编译来安装不升级

2.直接以编译好的 binary program 来安装不升级

直接以tarball在自己的机器上面进行侦测，编译，安装于设定，比较麻烦，如果厂商能针对自己的作业平台先进行编译，再将编译好的binary program放出的话，

由于我的环境与该Linux distribution的环境是相同的，他所放出的binary program就可以在我的机器环境上直接安装，省略了侦测与编译复杂的过程

即可以使用tarball直接进行编译的安装或升级，也可以使用rpm或dpkg相关机制来进行安装与升级

一个软件的 Tarball的安装过程

1. 将 Tarball 由厂商的网页下载下来

2. 将 Tarball 解开，产生很多的原始码档案

3. 开始以 gcc 进行原始码的编译 (会产生目标文件 object files)；

4. 然后以 gcc 进行凼式库、主、子程序的链接，以形成主要的 binary file；

5. 将上述的 binary file 以及相关的配置文件安装至自己的主机上面。

3和4可以由make这个指令来简化，步骤就是这样，不过你至少需要gcc与make这两个软件在你的Linux系统里面才行

使用传统程序语言进行编译的范例

需要清楚 原始码  编译程序  函式库   执行档之间的相关性

运用C语言撰写程序  ，前提已经安装gcc，没有安装，使用yum groupinstall "Development Tools" 进行安装

[root@www ~]# vim hello.c <==用 C 语言写的程序扩展名建议用 .c 

#include <stdio.h> 

int main(void) { 

printf("Hello World\n"); 

}

接着执行编译 gcc hello.c

此时会生成一个档名为a.out的文件

执行这个binary文件./a.out 就会输出Hello World

当直接以gcc编译原始码，没有加上任何参数，则执行档的档名会被自动设定为a.out这个文件名，hello.c就是原始码，gcc就是编译程序，a.out就是编译成功后的binary文件

如果想要产生目标文件(object file)来进行其他的动作，而执行档的档名不要用预设的a.out 其实可以在编译的时候改成这样：

gcc -c hello.c 接着查看的时候会看到一个hello.o的目标文件，接着gcc -o hello hello.o生成可执行文件hello ，接着执行./hello 出现结果了

为什么先要制作目标文件再做成执行档呢？

主 ， 子程序链接：子程序的编译

在一个主程序里面又呼叫了另一个子程序，例如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"); }

进行程序的编译与链接(link)

gcc -c thanks.c thanks_2.c 生成两个.o结尾的目标文件，接着再执行gcc -o thanks thanks.o thanks_2.o 产生执行档 thanks文件，接着执行./thanks 产生结果

目标文件作用，由于原始码档案不是只有一个档案，所以无法直接编译，此时需要先产生目标文件，然后再以连接制作成binary可执行文件，如果某天需要对thanks_2.c这个

档案进行更新，只要重新编译thanks_2.c来产生新的thanks_2.o，然后再制作成新的binary的可执行文件，而不需重新编译其他没有改动过的原始码档案，有时候将偌大的

的原始码全部编译完成会花上很长的时间

如果先让程序在执行的时候具有比较好的效能，或者其他的出错功能，可以在编译的过程中加入适当的参数

gcc -O -c thanks.c thanks_2.c          -O 会产生优化的参数

gcc -Wall -c thanks.c thanks_2.c 产生更详细的编译过程信息

呼叫外部函式库，加入连接的函式库

[root@www ~]# vim sin.c 

#include <stdio.h> int main(void) { float value; value = sin ( 3.14 / 2 ); printf("%f\n",value); }

直接 gcc sin.c 编译，会产生错误讯息，代表没有成功， 会提示undefined reference to sin 没有sin的相关定义参考值，因为C语言里面的sin函数是写在libm.so这个函式库

中的，编译时没有在源码中加入这个函式库功能进去，所以当然需要再编译于连结的时候将这个函式库给他链接进执行档里面，

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

gcc sin.c -lm -L/lib -L/usr/lib <==重点在 -lm 尝试执行新档案 ./a.out 输出结果了

使用 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 就很重要了！否则会找不到凼式库

『 #include <stdio.h>』 这个内容的含义是将一些定义数据由stdio.c这个档案读入，这包括printf的相关设定，这个档案其实是放置在/usr/include/stdio.h 的，那么万一这个

档案不放在这个目录下时，那么就可以使用gcc sin.c -lm -I/usr/include来定义出要读取档案的目录

-I/path 后面接的路径( Path )就是设定要去搜寻相关的 include 档案的目录啦

我们接着稍微整理一下gcc的简易使用方法，gcc是linux上面最标准的编译程序，gcc对于Linux上的Open source是那么样的重要

了解gcc的一些功能：

仅将原始码编译成为目标文件，并不制作链接等功能：gcc -c hello.c   会自动的产生 hello.o 这个档案，但是并不会产生 binary 执行档。

在编译的时候，依据作业环境给予优化执行速度 gcc -O hello.c -c   会自动的产生 hello.o 这个档案，并且进行优化喔

在进行 binary file 制作时，将连结的凼式库与相关的路径填入

gcc sin.c -lm -L/usr/lib -I/usr/include  这个指令较常下达在最终连结成 binary file 的时候，-lm 指的是 libm.so 或 libm.a 这个凼式库档案；

-L 后面接的路径是刚刚上面那个凼式库的搜寻目录；

-I  后面接的是原始码内的 include 档案之所在目录。

将编译的结果输出成某个特定档名  gcc -o hello hello.c     -o 后面接的是要输出的 binary file 檔名

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

用make进行宏编译

执行make的功能是可以减化编译过程里面下达的指令，同时还具有很多很方便的功能，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 数值。

由于这四个档案里面包含了相关性，并且还用到数学函式在里面，如果想要运行，需要这样：

先进行目标文件的编译，最终会有四个 *.o 的档名出现： gcc -c main.c     gcc -c haha.c     gcc -c sin_value.c      gcc -c cos_value.c

2. 再进行连结成为执行档，并加入 libm 的数学凼式，以产生 main 执行档：gcc -o main main.o haha.o sin_value.o cos_value.o  -lm -L/usr/lib -L/lib

3. 本程序的执行结果，必须输入姓名、360 度角的角度值来计算：./main 接着输入内容 最后输出结果

上面的编译过程需要很多动作，如果想要重新编译，则需要重新再来一遍，光是这些指令烦死人了，所以可以利用make这个工具，先来尝试在目录下建立一个名为makefile的

档案

先来编辑makefile这个规则文件，内容只要做出main这个执行档

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> 按键产生的空格喔！

接着执行make 此时make会去读取makefile这个文件内容，并根据内容直接去给他编译相关的档案

直接在不删除任何档案的情况下，重新执行一次编译的动作make，结果只会进行更新 (update) 的动作而已

make还会主动的判断哪个原始码与相关的目标文件档案有更新过，并仅更新该档案，可以大大节省编译的时间，编译很耗费CPU资源

make 有这些好处

简化编译时所需要下达的指令；

若在编译完成之后，修改了某个原始码档案，则 make 仅会针对被修改了的档案进行编译，其他的 object file 不会被更动；

最后可以依照相依性来更新 (update) 执行档

makefile的基本语法与变量

目标(target): 目标文件1 目标文件2

<tab> gcc -o 欲建立的执行文件 目标文件1 目标文件2

target就是我们想要建立的信息，目标文件则是具有相关性的object files，执行操作前面必须加上<tab> 按键，

1.在 makefile 当中的 # 代表批注；

2.<tab> 需要在命令行 (例如 gcc 这个编译程序指令) 的第一个字符；

3.目标 (target) 与相依档案(就是目标文件)之间需以『:』隔开.

建立清除所有的目标文件与执行文件的命令：

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

执行以新的目标(clean) 接着执行make clean , 这样就行了

此时makefile中有两个目标，main与clean，需要再make后面加上target，还可以执行make clean main 先清除在生成

上面看到makefile中的重复内容太多，可以进行简化

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}

1. 变量与变量内容以『=』隔开，同时两边可以具有空格；

2. 变量左边不可以有 <tab> ，例如上面范例的第一行 LIBS 左边不可以是 <tab>；

3. 变量与变量内容在『=』两边不能具有『:』

4. 在习惯上，变数最好是以『大写字母』为主；

5. 运用变量时，以 ${变量} 或 $(变量) 使用；

6. 在该 shell 的环境变量是可以被套用的，例如提到的 CFLAGS 这个变数！

7. 在指令列模式也可以给予变量。

由亍 gcc 在进行编译的行为时，会主动的去读取 CFLAGS 这个环境变量，所以，你可以直接在 shell 定义出这个环境变量，也可以在 makefile 档案里面去定义，更可以在指令

列当中给予这个东东

例如  CFLAGS="-Wall" make clean main

也可以这样：

[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}

环境变量取用的规则：

1. make 指令列后面加上的环境变量为优先； 

2. makefile 里面指定的环境变量第二；

3. shell 原本具有的环境变量第三。

特殊的变量：

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

gcc -o $@ ${OBJS} ${LIBS} <==那个 $@ 就是 main ！

Tarball 的管理与建议

建立具有原始码的Tarball来建立自己的软件，Tarball可以跨平台，编译程序可能不相同，Linux上的gcc，Windows上面的C语言，如果没有编译成功，够过修改小部分代码

就可以解决问题了，理论上Linux底下写的程序可以在Windows上面编译，这就是原始码的好处。

制作一个binary program需要很多东东，基础的软件包括：

C compiler是一定要的，gcc是首选的自由软件编译程序，事实上很多在Linux平台上面发展的软件的原始码，原本就是以gcc为底来设计的

make及autoconfig ，执行make命令需要makefile这个档案的规则，由于不同环境的因素，所以需要有侦测用户的作业环境，从而建立一个makefile档案，这个自行侦测的小程

序也必须要藉由autoconfig这个相关的软件来辅助

需要kernel提供的Libraryi及相关的include档案

很多软件在发展的时候都是直接取用系统核心提供的函式库与include档案，这样才能和操作系统兼容，尤其是【驱动程序方面的模块】例如：网络卡，声卡，USB等驱动程序

在安装的时候，需要核心提供的相关信息，这些核心相关的功能通常被包含在kernel-source或kernel-header这些软件名称当中，所以记得要安装这些软件

Development Tools 以及 Kernel Source Development相关的软件也要记得安装

yum的安装功能：

如果是要安装 gcc 等软件开发工具，请使用『 yum groupinstall "Development Tools" 』

若待安装的软件需要图形接口支持，一般还需要『 yum groupinstall "X Software Development" 』

若安装的软件较旧，可能需要『 yum groupinstall "Legacy Software Development" 』

Tarball安装的基本步骤

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档案

makefile中的多目标target，最常见的就是install与clean，通常make clean 将目标文件(object file) 清除掉，make则是将原始码进行编译而已，注意，编译完成的可执行

文件与相关的配置文件还在原始码所在的目录当中，最后要执行make install来将编译完成的所有东西都给他安装到正确的路径去

1. ./configure  开发者会写一支 scripts 来检查你的 Linux系统、相关的软件属性等等

2. make clean  这个步骤不一定会有，有的话用来除去目标档案，

3. make 进行gcc来将原始码编译成可执行的object files，这些object files通常还需要一些函式库之类的link后，才能产生一个完整的执行档，make可以将原始码编译成可以

执行的可执行文件，

4. make install  make 会依据 Makefile 这个档案里面关亍 install 的项目，将编译完成的数据安装到预定的目录中去

如果安装成功的话，并且是安装在独立的一个目录中，你就必须要手动的将这个软件的man page给他写入/etc/man.config里面去

原本的 Linux distribution 释出安装的软件大多是在 /usr 里面的，用户自行安装的软件则建议放置在 /usr/local 里面

预设man和info功能会去搜索/usr/local/man 里面的说明文件，在/usr/local底下安装的话，自然安装之后该软件的说明文件就可以被找到了，至于原始码(Tarball)则建议放置在

/usr/local/src底下

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 如果每个软件都是选择这个默认路径安装

的话，那么所有的软件的档案都放置在四个目录下，未来想要升级与移除的时候，就比较难找到原先的档案来源了，所以最好安装在/usr/local/apache/

想要移除apache只要下达rm -rf /usr/local/apache 这样就移除了这个软件了，具体安装的信息还得视该软件的Makefile里头的install信息才能得知具体的安装情况

这个方式虽然有利于软件的移除，但是该指令与PATH这个环境变量所记录的路径不在一起，/usr/local/apache/bin 肯定是不在PATH 里面，执行apache的指令就要用绝对路径

，否则需要将/usr/local/apache/bin 加入 PATH 里面，/usr/local/apache/man 也需要加入 man page 搜寻的路径当中

为了方便 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 来查询该软件的在线文件啰！

利用ntp做实验 http://linux.vbird.org/linux_basic/0520source/ntp-4.2.4p7.tar.gz

cd /usr/local/src <==切换目录

tar -zxvf /root/ntp-4.2.4p7.tar.gz <==解压缩到此目录

cd ntp-4.2.4p7/

vi INSTALL <==记得 README 也要看一下！注意查看安装简介

检查 configure 支持参数，并实际建置 makefile规则文件

./configure --help | more <==查询可用的参数有哪些

./configure --prefix=/usr/local/ntp(指定安装路径)  --enable-all-clocks --enable-parse-clocks <==开始建立makefile

最后开始编译与安装  make clean; make

make check

make install 这样就完成了

利用patch 更新原始码

通常更新原始码只要更改部分档案的小部分内容，只要将有修改过的档案部分处理即可，没有更动过的档案的目标文件(object file)根本不需要重新编译，有更改过的档案

可以利用make来自动update，原先的设定(makefile档案里面的规则)将不需要重新改写或侦测，需要一个比对档案的指令，那就是 diff，可以将两个档案的差异列出，然后

再以相关的指令来将旧版的档案更新，那就是patch指令，更新原始码之后，都会放出patch file，就是是直接将原始码update而已

两个档案的意义为

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；

原先的只有五个档案，四个程序加上一个makefile的规则档案，此前版本的makefile只有main与clean两个目标的功能而已，0.2版本加入了 install 与 uninstall 的规则设定

查阅 patch file 内容         vim ~/main_0.1_to_0.2.patch

上面表格内有个底线的部分，那代表使用 diff 去比较时，被比较的两个档案的所在路径，这个路径非常的重要喔

patch -p数字 < patch_file   -pxx 那个 xx 代表『拿掉几个斜线(/)』的

patch -p1 < ../main_0.1_to_0.2.patch 

接着make clean main 重新编译

接着执行执行档 ./main

你可以发现，输出的结果中版本变了，输出信息多了括号 () 喔！

make install <==将他安装到 /usr/local/bin 给大家用

cp -a main /usr/local/bin  加入环境变量 ，接着main <==直接输入指令可执行！

make uninstall <==移除此软件！

所以只要有patch file就能对你的软件原始码更新了，不过还得重新编译后，才会最终生成正确的软件，patch的功能主要只是更新原始码档案， patch命令还可以进行还原

透过『 patch -R < ../main_0.1_to_0.2.patch 』就可以还原啦！

有关核心版本的升级，不过kernel每次推出的patch档案仅针对前一个版本，所以假设要由 kernel 2.4.20 升级到 2.4.26，就必须要使用 patch 2.4.21, 2.4.22, 2.4.23, 2.4.24,

2.4.25, 2.4.26 六个档案来『依序更新』才行喔，当然有比对过2.4.20 与 2.4.26，那么你自然就可以使用该patch file来一次更新了

凼式库管理

分别是静态 (Static) 与动态 (Dynamic) 凼式库两类

静态凼式库的特色：

1.扩展名：(扩展名为 .a)

2.编译行为：这类凼式库在编译的时候会直接整合到执行程序当中，所以使用静态函式库编译成的档案会比较大一些

3.独立执行的状态：这类凼式库最大的优点，就是编译成功的可执行文件可以独立执行，而不需要再向外部要求读取凼式库的内容

4.升级难易度：因为函式库直接整合到执行档，因此函式库升级时，整个执行档必须要重新编译才能将新版的函式库整合到程序中，、

，在升级方面，只要凼式库升级了，所有将此凼式库纳入的程序都需要重新编译

动态凼式库的特色：

1.扩展名：(扩展名为 .so)

2.编译行为：动态凼式库在编译的时候，在程序里面只有一个『指向 (Pointer)』的位置而已，只有当使用的时候才会去读取函式库，编译出的档案也会小一点

3.独立执行的状态：这类型的凼式库所编译出来的程序不能被独立执行，需要使用才会去读取函式库，函式库的位置也不能修改，我们的可执行文件仅有

『指标』亦即当要取用该动态凼式库时，程序才会主动的到路径下读取，所以动态凼式库可不能随意移动或删除，会影响很多相依的程序软件喔

升级难易度：，当凼式库升级后，执行档根本不需要进行重新编译的行为，因为执行档会直接指向新的函式库档案(前提是凼式库新旧版本的档名相同喔！)

目前的 Linux distribution 比较倾向亍使用动态凼式库，函式库方便，

绝大多数的凼式库都放置在：/usr/lib, /lib 目录下，  kernel 的凼式库在 /lib/modules 里，不同版本的函式库差异很大

增加凼式库的读取效能，内存访问速度是硬盘的好几倍，所以，最好将常用到的动态函式库加载到内存中，快取，当软件用到函式库，就不需要再从硬盘中读取了，能增加

动态函式库的读取速度，这个时候就需要 ldconfig 不 /etc/ld.so.conf 的协助了

将动态凼式库加载高速缓存当中

我们必须要在 /etc/ld.so.conf里面写下，想要读入高速缓存当中的动态凼式库所在的目录，是目录不是档案

接下来则是利用 ldconfig 这个执行档将 /etc/ld.so.conf 的资料读入快取当中

同时也将数据记录一份在 /etc/ld.so.cache 这个档案当中吶！

ldconfig 还可以用来判断动态凼式库的链接信息呢，假如你想要将目前系统下的MySql函式库加入到快取当中

ldconfig [-f conf] [ -C cache]

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

vi /etc/ld.so.conf

include ld.so.conf.d/*.conf

/usr/lib/mysql <==这一行新增的啦！

ldconfig -p   凼式库名称 => 该凼式库实际路径

你想要让这些动态凼式库的相关连结可以被读入到快取当中，这个时候你可以将动态凼式库所在的目录名称写入 /etc/ld.so.conf， 然后执行idconfig

程序的动态凼式库解析： ldd

判断某个可执行的 binary 档案含有什么动态凼式库，利用 ldd 就可以晓得了

例如我想要知道 /usr/bin/passwd 这个程序含有的动态凼式库有哪些

ldd [-vdr] [filename]

-v ：列出所有内容信息；

-d ：重新将资料有遗失的 link 点秀出来！

-r ：将 ELF 有关的错诨内容秀出来！

ldd /usr/bin/passwd       找出 /usr/bin/passwd 这个档案的凼式库数据

检验软件正确性

我们可以使用 MD5 这个指纹验证机制来判断该档案有没有被更动过！ ，这个时候就有 md5sum 不 sha1sum 这个档案指纹的咚咚出现啦

md5sum / sha1sum

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

md5sum/sha1sum [-bct] filename

md5sum/sha1sum [--status|--warn] --check filename选项不参数：

-b ：使用 binary 的读档方式，默认为 Windows/DOS 档案型态的读取方式；

-c ：检验档案指纹；

-t ：以文字型态来读取档案指纹。

将刚刚的档案下载后，测试看看指纹码 wget http://ftp.twaren.net/Linux/CentOS/5.3/isos/i386/CentOS-5.3-i386-netinstall.iso

md5sum CentOS-5.3-i386-netinstall.iso

sha1sum CentOS-5.3-i386-netinstall.iso

基本上，你必须要在你的 Linux 系统上为你的这些重要的档案进行指纹数据库的建立 (好像在做户口调查！)，将底下这些档案建立数据库

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

这几个档案最容易被修改了，你可以替这些档案建立指纹数据库(就是使用md5sum检查一次)，将该档案指纹记录下来，然后再以shell script的方式由程序自行来检查指纹表

是否不同，那样对文件系统比较安全