linux下加载Fat32和NTFS分区

Fat32:

1.临时挂载：在终端运行命令mount -t vfat -o iocharset=utf8,umask=000 /dev/hda2 /mnt/wind/

其中/dev/hda2替换为你要加载的分区，/mnt/wind/替换为你的挂载目录。

2.开机自动挂载：在/etc/fstab文件中添加一行，/dev/hda2 /mnt/wind vfat umask=000,iocharset=utf8

NTFS:

1.根据系统内核版本下载支持ntfs的内核补丁，安装。

2.临时挂载：mount -t ntfs -o nls=utf8,umask=000 /dev/hda1 /mnt/winc

修改红色部分，同上。

对于大多数 UNIX 和 Linux 用户，终端无疑是不可或缺的。本文将描述一个可以让 UNIX 终端会话完整受控的软件包，它叫做 Ttyutils。这篇文档将向大家介绍 Ttyutils 的基本使用方法以及它的实现机制。

在本文档中，UNIX 终端也泛指 Linux 终端。并且，本文中的终端不仅仅包括物理终端，也包括虚拟控制台，图形仿真终端，例如 xterm, 和具备网络能力的仿真终端，例如 putty。

为了有助更加形象的描述，这篇文档会使用截获，捕获，甚至偷窥这样的词语，但这是没有恶意的。

监控终端会话

在通常情况下，当用户从终端登录 UNIX 主机时，系统登录程序会记录用户的登录时间，主机名称等信息到系统 utmp 数据库和 wtmp 数据库，却不能跟踪用户进入 shell 之后的会话。

有一些程序，例如 script，可以记录用户在终端上的会话到一个文件中，然后在后来的某个时候通过那个文件重现用户当时的会话。script 的局限性在于它只能记录，而不能干涉用户的会话，例如当用户在命令行输入"rm -fr /"这样的命令时，它没有办法阻止。

在一些受控的环境中，系统管理员必须有能力实时的查看用户的会话，或者因为好奇，想偷窥远程登录到你的主机的用户在干些什么，并且，如果必要，还可以实时的禁止或者终止用户进行更多的操作，这是很有趣的。

在 UNIX 中，有很多使用终端作为人机交互接口的应用程序，例如常用的 shell, vi，还有一些特定于行业的应用程序，例如我们在银行里办理业务时，营业柜员使用的操作接口。如果能够通过截获和实时的分析程序的输出所引起的终端变化， 并可以根据这些变化的特征来触发特殊的动作将是非常有用的。例如，当用户在提示符下输入 vi 两个字符时，就自动的启动 vi 编辑器，这样就可以省去按下回车键的麻烦。

考虑这样的情况，有一个运行在终端上的重要软件包，例如金融机构的业务处理系统，需要对现有的业务进行改造，例如为了支持新的设备，但是却因为各种原因， 不能修改系统的代码。这可以通过对现有的系统进行监控和分析来做到，并且，因为没有直接修改现有的系统，可以很容易的移除或修改。

Ttyutils 是为这个目标设计的一个软件包，它主要包括三个实用程序：ttyexec，ttyadmin，和 ttylook。

安装 ttyutils

Ttyutils 软件包使用 RPM 包发布，首先从参考资源列出的地址下载 ttyutils 软件包的最新版本，然后使用下面的命令安装 :

# rpm -Uvh ./ttyutils-@version.@release.@platform.rpm

其中 @version，@release 和 @platform 分别是版本号，发行号，以及平台。

安装 RPM 软件包通常需要 root 权限。

安装完成后，你可能需要配置一下日志文件。Ttyutils 的日志采用 syslog 函数记录，采用的 facility 为 LOG_LOCAL3，默认情况下，在 Linux 平台，所有消息将输出到 /var/log/messages 文件中，可以通过配置 /etc/syslog.conf 来重定向到一个单独的文件中，例如下面是一个例子 :

# Save ttyutils messages to ttyutils.log
local3.* /var/log/ttyutils.log

对于不支持 local3 作为 facility 的系统，可以采用下面的语法 :

# Save ttyutils messages to ttyutils.log
*.debug /var/log/syslog.out

Ttyutils 软件包的程序支持 --logfile 选项，它可以将日志重定向到一个指定的文件中。

一切就绪，下面开始一个简单的会话。

登录两个终端 A 和 B，在终端 A 的 shell 提示符下输入 :

$ ttyexec
$ tty
/dev/pts/3

其中"/dev/pts/3"是 tty 命令的输出，可能会是其它的名字，记住这个名字，然后在终端 B 输入：

$ ttylook --pts /dev/pts/3 -w

这时终端 A 的输出将会反应在终端 B，反之亦然。

其中，ttyexec 是监控程序，它的使用方法与 shell 中命令 exec 相似，被 ttyexec 启动的程序的输入输出将被 ttyexec 截获，如果没有参数，那么它会执行在 /etc/passwd 文件中为当前用户设置的 shell 程序。

当通过 ttyexec 在终端 A 监控了一个程序之后，ttyexec 自身不会记录任何关于会话的标准输入输出信息到某个文件或者其它地方，如果用户想查看被监控的程序的标准输出，需要使用在另外一个终端 B 上使用 ttylook 连接到那个 ttyexec，当连接建立以后，ttyexec 就会将截获的数据发送给 ttylook，而 ttylook 则将这些数据输出到终端 B 上。这个时候，终端 B 的屏幕和终端 A 的屏幕将会一样，并且如果不断开连接，将会实时的保持同步。这就相当于两个终端共享了一个用户会话。因为 ttyexec 支持多个 ttylook 连接，也就是说可以三个，四个，或者更多个终端共享同一个用户会话。

ttyadmin 是用于管理当前系统中运行的 ttyexec 进程的工具，对于熟悉 Ttyutils 的用户，它提供了一些很有用的功能。

使用 ttyexec 截获用户会话

ttyexec 是监控程序，被它监控的程序的标准输入输出将会被 ttyexec 截获，ttyexec 的用法很简单，只需要在命令行指定一个将被监控的程序名称即可，例如：

$ ttyexec vim

如果那个程序需要参数，直接跟在命令行后面即可，例如 :

$ ttyexec vim /etc/inittab

使用 ttyexec 不需要任何的特权。

如果没有在命令行中指定一个程序名称，那么 ttyexec 将会尝试去执行当前用户在 /etc/passwd 文件中登记的 shell 程序。

一个简单的技巧用来完整的监控用户从登录开始到退出登录之间的完整会话，就是在用户的 profile 文件最后加入下面的二行 :

ttyexec
exit $?

在本文档中，运行一个 ttyexec 实例就是为了监控一个用户在终端的会话，所以，有时候为了描述方便，也用一个 ttyexec 实例来代表一个监控的用户会话。

使用 ttylook 控制用户会话

当使用 ttyexec 监控了一个程序之后，如果想偷窥被监控终端上的会话，就需要在另外一个终端使用 ttylook 连接到 ttyexec。

使用 ttylook，必须要知道运行 ttyexec 的那个终端的终端名称，伪终端名称，或者进程 ID 中的至少一个。这可以很容易的从 ttyadmin 获得，看下图：

这是运行在 IBM AIX5.1 上的 ttyadmin 的截图，在主窗口中，每一行列出了当前系统中的一个 ttyexec 实例，信息包括运行它的用户 ( 图中故意模糊了 )，进程 ID，终端名称，伪终端名称，运行的时间和运行的命令。

在上图中我们可以看到当前系统有 13 个 ttyexec 实例在运行。

在上图中，如果用 ttylook 连接被监控的终端 /dev/pts/16，可以使用下面的命令中的任意一个，它们是等价的：

$ ttylook --tty /dev/pts/16
$ ttylook --pid 319688
$ ttylook --pts /dev/ttypf

在默认情况下，ttylook 在只读模式运行，也就是说，它只能偷窥被监控的终端，而不能操作被监控的终端，如果要操作被监控的终端，它必须通过命令行 --writable 进入可写模式。

但是进入了可写模式很危险，特别是你不希望让被监控终端上的用户发现的时候。所以默认是只读模式。

回顾一下，假设用户 1 在终端 A 在上运行着 ttyexec，用户 2 在终端 B 上运行着 ttylook，当 ttylook 连接到的 ttyexec 实例后，终端 A 和终端 B 的屏幕内容将实时同步，所以，用户 1 在被监控终端上的所有会话对于用户 2 而言就暴露无遗了。

使用 ttyadmin 管理 ttyexec 实例

在系统中通常会有多个 ttyexec 实例在运行，前面的 ttyadmin 截图已经大致说明了 ttyadmin 的用途，但它除了可以列出当前系统中所有的 ttyexec 实例外，还有一些其它的用途，例如它可以很容易的启动 ttylook，查看 ttyexec 实例的事件表等等。

使用 ttyexec 的事件触发

如果只是希望监控用户在终端上的会话的话，那么只需要使用前面描述的内容即可，但是如果还想得到更多，那么就可能需要这里描述的内容－ 事件触发。

ttyexec 的一个有用的机制是事件触发，它是根据被监控程序的标准输出引起终端屏幕的变化来工作的，每当被监控程序改变终端屏幕的内容时，ttyexec 会根据更新后的屏幕内容与事件表中的事件条件进行匹配，如果成功，那么就会执行一个事件定义的程序。

事件表

在 ttyexec 内容维护了一个事件表，每个节点是一个事件，每个事件由 4 个部分组成：

• 事件的名称；
• 事件的组名称；
• 事件的匹配器；
• 事件的动作；

事件名称 是事件唯一的标识， 事件组名称 是对多个事件的划分，这两个名称主要用于事件的管理。

事件匹配器 由一个或多个 事件条件 组成，每个 事件条件 又根据类型的不同而不同，我们介绍完虚拟终端后再回头描述事件条件。

事件动作 是一个程序的名称和它的参数 ( 如果有的话 )，它是一个标准的可执行程序，在事件的匹配器得到匹配时执行。

虚拟终端

ttyexec 内部运行着一个虚拟的终端，它可以正确的解析发送到实际终端的那些控制序列，并在内存中重构一个和真实终端屏幕一样大小的屏幕，它的内容和用户在实际终端上看到的是一样的，但是对于用户而言，它是不可见的。

每当被监控的程序改变终端屏幕的内容时，ttyexec 的虚拟终端也会同步更新自己的屏幕，然后它开始检查事件表，如果发现了匹配的事件，就执行为事件定义的事件动作。

事件匹配

在 ttyexec 的事件表的每个事件中， 事件匹配器 由一到多个 事件条件 组成， 事件条件 是真正要去和虚拟终端屏幕比对的单元， 事件匹配器 只有在所有事件条件都匹配的情况下才是匹配的。

每个 事件条件 的类型有两种，第一种是根据光标的位置，第二种是根据屏幕上的数据。

光标位置是指光标到达某个指定的坐标时，条件就得到了满足，这种类型的条件需要两个参数，坐标的行和列。

屏幕的内容是指屏幕某个区域的内容达到预期的值，这种类型的条件需要四个参数，行，起始列，长度，以及一个正则表达式。

因为一个 事件匹配器 可以包含多个条件，并且只有匹配器中的所有条件都得到满足时，匹配器才算匹配，所以可以定义出很精确的匹配，当然也可以定义很模糊的匹配。

事件表维护

因为事件需要根据不同的应用场合而进行独立的设置，所以必须有能力去管理 ttyexec 的事件表，这需要了解一些基本的计算机编程。

有两种途径来管理 ttyexec 的事件表，第一种是通过 ttyexec 的配置文件，叫做 ttyexec.lua，这个文件使用标准的 Lua 程序语言。这种方式称为静态事件管理。

第二种方式是使用 ttyutils 提供的编程接口，外部程序可以动态的维护 ttyexec 事件表，这种方式称为动态事件管理。动态事件管理很强很实用，因为这样我们就可以在事件触发之后的程序中再去动态的管理 ttyexec 的事件表，这可以为事件提供了上下文关系。

在一个复杂的环境中，通常利用静态管理来维护 ttyexec 的初始事件，而在适当的时候利用动态事件管理来动态的维护 ttyexec 的事件表。

RPC 服务

远程过程调用 (remote process call)RPC 服务是 ttyexec 为进程间通讯提供的接口，注意它和 SUN RPC 没有任何的关系，并且不能跨网络使用。

当事件触发时，事件动作程序被启用，事件动作程序是一个标准的应用程序，它可以做任何它喜欢的事情，但是有时候，它需要和 ttyexec 交互，例如它可能需要获取当前终端屏幕的内容， ttyexec 为这样的情况提供了准备，称为 RPC 服务。

Ttyexec 提供了下面的服务 :

• snap: 获取当前终端屏幕的快照；
• feed: 发送数据作为实终端的标准输入；
• suspend/resume_stdio: 悬挂 / 恢复实终端标准输入；
• suspend/resume_stdout: 悬挂 / 恢复实终端标准输出；
• insert/remove_event: 添加 / 删除事件表中的事件；

下面用一个例子描述如何编写一个 C 程序来使用上面提供的 feed 服务，包括从源代码编写到编译，连接完整的步骤。

#include <ttyutils.h>

int
main (int argc, char *argv[])
{
 TRpcTarget target;

 if (!t_init ())
 return 1;

 target.rt_timeout = 3;
 target.rt_type = RPC_TARGET_PTS;
 target.rt_pts = "/dev/pts/3";

 if (!t_rpc_call_set_target (&target))
 {
 t_println ("set rpc target failed.");
 return 1;
 }

 if (!t_rpc_call_feed ("hello", 5))
 {
 g_warning (_("rpc call failed."));
 return 1;
 }

 t_uninit ();
 return 0;
}

将上面的代码保存到文件 example.c，然后到用下面的命令编译它 :

$ cc -o example example.c `pkg-config --cflags --libs ttyutils-1`

第 1 行包含了头文件 <ttyutils.h>，这是每个外挂程序应该做的。

第 6 行声明了一个 TRpcTarget 结构的变量，这个结构描述如下 :

typedef enum
{
 RPC_TARGET_TTY,
 RPC_TARGET_PTS,
 RPC_TARGET_PID,
 RPC_TARGET_PATH
} TRpcTargetType;
 
typedef struct _TRpcTarget TRpcTarget;
struct _TRpcTarget
{
 TRpcTargetType rt_type;
 guint32 rt_timeout;
 union
 {
 gchar *t_tty;
 gchar *t_pts;
 pid_t t_pid;
 gchar *t_path;
 } rt_target;
};
#define rt_tty rt_target.t_tty
#define rt_pts rt_target.t_pts
#define rt_pid rt_target.t_pid
#define rt_path rt_target.t_path

第 8 行调用了 t_init() 函数，要使用 ttyexec 接口的程序应该首先调用这个函数 ( 在调用其它接口函数之前 )。

第 11 行到 13 行设置 RPC 的目标，这里我们选择的是使用伪终端名称 "/dev/pts/3"。

上面 TRcTargetType 的枚举定义了我们可以使用的连接方式，它们分别是 :

RPC_TARGET_TTY ttyexec 实例使用的终端名称

RPC_TARGET_PTS ttyexec 实例运行命令的伪终端名称

RPC_TARGET_PID ttyexec 的进程 ID

RPC_TARGET_PATH ttyexec 为 RPC 服务建立的 UNIX 套接字名称

结构 TRpcTarget 中的联合体 rt_target 中的每个成员分别对应于每种不同的连接方式。为了方便的访问到 rt_target 中的成员，还分别定义了一些简化的宏 (rt_tty 等等 )。

第 15 到 19 行调用 t_rpc_call_set_target() 函数，它用我们上面设置好的 target 结构体作为参数。

t_println() 是一个调试用的函数，当编译程序时定义了 DEBUG 或者 T_DEBUG 时，它的功能和 printf() 类似，当没有定义上面的两个宏时，它不生成任何代码。

第 21 到 25 行调用函数 t_rpc_call_feed ()，这个函数访问 ttyexec 提供的 feed 服务，它的作用是发送一些数据到 ttyexec 作为标准输入。

g_warning() 是 glib 提供的一个函数，它的作用是输出一条警告消息。

第 27 行调用 t_uninit() 函数，它的作用是释放资源，应该在程序退出之前调用。

回页首

Ttyutils 内部原理描述

前面描述了如何使用 ttyutils 软件包中的程序来监控终端的会话，读者可能好奇它的内部是如何工作的，这一部分将描述这些内容。

实现 ttyexec

ttyexec 是一个监控程序，它通过建立一个伪终端来运行一个应用程序，从而达到监控那个应用程序的目的。所以，要理解 ttyexec 的实现，必须理解伪终端。

伪终端

伪终端这个名词暗示它是一个虚拟的终端，应用程序可以将其作为一个终端设别使用，但是它不是一个真实的终端，一个伪终端由两端构成，分别称为伪终端主设备 和从设备，任何写到伪终端主设备的输入都会作为从设备端的输入，反之亦然。事实上所有从设备端的输入都来自于主设备上的用户进程。这看起来就像一个流管 道，但从设备上的终端行规程使我们拥有普通管道之外的其他处理能力。

文件 /dev/ptmx 是一个字符设备，它用来建立伪终端主从设备。

截获进程输入输出

ttyexec 通过建立一个伪终端，然后调用 fork。子进程建立了一个新的对话，打开一个相应的伪终端从设备，将它复制成标准输入、标准输出和标准出错，然后调用 exec。伪终端从设备成为子进程的控制终端。

对于伪终端从设备之上的用户进程来说，其标准输入、标准输出和标准出错都能当作终端设备使用。用户进程能够调用所有输入 / 输出函数。

虚拟终端

当 ttyexec 从伪终端主设备接收到数据后，这些数据是原始的 Escape 序列，它还需要传递给内置的 Escape 解析器，最后在内存中构造一个和屏幕上相同的虚拟终端。

注意虚拟终端，伪终端和实际终端之间的区别，下面的图描述了它们之间的关系：

当使用 ttyexec 执行其它命令时， ttyexec 实际上拥有了两个终端设备，一个是继承于 shell 的实终端 ( 也可能是伪终端，例如在终端仿真程序中运行 ttyexec)，另外一个是 ttyexec 建立的伪终端，后者将被 ttyexec 执行的命令使用。

当在使用 ttyadmin 时，得到的输出中有一栏名为 TTY，还有一栏名为 PTS，分别指的就是上面的实终端和伪终端。

ttyexec 拥有两个终端设备，其中伪终端被用于执行的命令，因为伪终端的一端的输出将会是另一端的输入，也就是说，被 ttyexec 执行的命令的所有输出将是 ttyexec 的输入，所以， ttyexec 截获了被执行的命令的全部终端输出。

同样，因为用户从真实终端的数据要通过 ttyexec 转发到伪终端上执行的命令，所以 ttyexec 也截获了用户的所有输入，并且可以模拟用户的输入发送数据到伪终端，这可以用于自动填充数据这样的场合。

通过虚拟终端在内存中重构一个终端屏幕，可以实时的跟踪屏幕的变化，并且根据当前屏幕的特征来触发事件，完成特定的事情。

伪终端是双向通讯设备，所以 ttyexec 可以输入数据到伪终端来模拟设备的标准输入 ( 键盘输入 )，ttyexec 提供的 feed RPC 服务就利用了这个特征。

需要澄清的一点是，虽然 ttyexec 能够控制被执行命令在终端上的的输入和输出，但不能改变被执行命令的内部程序逻辑。

支持 ttylook

Ttyexec 通过内置了一个网络服务器来支持 ttylook，这个服务在 ttyexec 中称为 lookd，它利用 UNIX socket 等待和 ttylook 建立一个双向的通讯，将截获的数据发送给 ttylook 即可，这项服务不能跨网络使用。

因为是双向通讯，所以 ttylook 也可以发送数据给 ttyexec 来写入伪终端主设备作为被 ttyexec 执行的程序的标准输入。

支持 RPC 服务

ttyexec 通过内置的一个网络服务器来支持 RPC 服务，这个服务在 ttyexec 中称为 RPCD，它利用 UNIX socket 等待和应用程序建立一个双向的通讯，然后根据应用程序的请求，返回相应的响应，这项服务不能跨网络使用。

因为 RPC 请求和响应的格式是由 ttyexec 内部定义的，为了方便开发人员使用，Ttyutils 提供了一个库，对这些细节进行了封装，所以在应用程序中使用 RPC 服务是非常简单的事情。

支持事件触发

事件触发的根本在于前面提到的虚拟终端，在 ttyexec 中，维护了一个事件表，每当虚拟终端发生变化时，它将会去用当前虚拟终端屏幕的内容去逐项匹配事件表中的事件，如果能够匹配，那么将触发一个动作。

因为终端的变化非常的频繁，如果事件表中有大量的事件，那么速度会受到一定的影响，但是为了确保实时性，这样的匹配是需要的，具体事件表能够加载多少事件没有限制，这个由管理人员根据系统的处理能力而定。

实现 ttylook

Ttylook 是 ttyexec lookd 服务器的客户端，它实现了两项功能：

1．从 ttyexec 接收数据，然后写到 用户终端 。

2．从 用户终端 接收数据，然后发送到 ttyexec。

这里 用户终端 是指运行 ttylook 的终端。

接收 ttyexec 的数据

ttylook 在启动时，将通过 UNIX socket 和 ttyexec 建立连接。

ttyexec 接收了这个连接之后，它会将所有被监控程序的标准输出数据 ( 输出到终端屏幕上的数据 ) 传送给 ttylook，然后 ttylook 简单的将这些数据写到用户的终端屏幕。

注意 ttylook 不理睬在 socket 之间传送的数据内容，这些数据直接被写到用户终端屏幕，所以如果运行 ttyexec 和 ttylook 的终端类型不同，那么可能会出现屏幕的内容错乱。

发送数据给 ttyexec

ttylook 在启动时，会将用户终端的标准输入 ( 键盘 ) 至于关闭回显模式，这样，用户在终端上的输入在屏幕上是不可见的。

但是 ttylook 会得到这些输入数据，然后将这些数据传送给 ttyexec，ttyexec 会将这些数据作为用户的输入写到被监控的进程，这就好像运行 ttyexec 的用户输入了数据一样。

实现 ttyadmin

当 ttyexec 启动的时候，它会将它自身的信息注册到一个系统区域，称为黄页，这个黄页是用一片共享内存实现的，ttyexec 注册的信息包括它的进程 ID，终端和伪终端名称，lookd 服务和 rpcd 服务帮定的地址，等等，每个 ttyexec 在黄叶中占据一项。

当 ttyexec 退出的时候，它会将自身的注册信息从黄页中删除。

Ttyadmin 主要是管理这个黄页的程序。

查看 ttyexec 实例

在 ttyadmin 启动时，它建立一个全屏幕的窗口，然后查询黄页，得到当前系统中所有 ttyexec 实例的注册信息，并将这些数据缓存到自己的内部表中。

然后它格式化得到的信息，显示在主窗口中。

后续的所有操作 ( 例如排序 ) 都是基于这个内部表，但是允许用户去重读黄页 ( 当前的实现是按下空格键或者设定一个更新超时 )。

管理 ttyexec 实例

ttyadmin 提供了对 ttyexec 的管理能力，这些能力可以在运行 ttyadmin 时通过帮助获得，这里要说明的是，这些管理功能主要是基于黄页中的信息。

虽然 ttyadmin 可以查看和管理 ttyexec，但是它和 ttyexec 没有直接的关系。

ttyexec 也为 ttyadmin 提供了一些管理功能 ( 例如查询事件表的内容 )，这是通过 ttyexec 的 RPC 服务实现的，在这种情况下，ttyadmin 只能算是 ttyexec 的一个 RPC 客户端。

VNC，全称为Virtual Network Computing，它是一个桌面共享系统。它的功能，类似于windows中的远程桌面功能。VNC使用了RFB(Remote FrameBuffer，远程帧缓冲）协议来实现远程控制另外一台计算机。它把键盘、鼠标动作发送到远程计算机，并把远程计算机的屏幕发回到本地。
VNC技术与平台无关，VNC Viewer可以和VNC Server在不同的操作系统上。VNC几乎支持所有的操作系统，也支持Java，甚至可以通过支持Java的浏览器来访问VNC Server。多个VNC客户端可以同时连接到一个VNC Server上。
VNC最初由AT&T开发的，它的源代码是开源的。

在CentOs 4.3上配置VNC服务很简单(这里假定你的计算机上已经安装了VNC软件)

首先需要配置VNC密码，密码在使用客户端连接服务器时使用。
注意：VNC密码保存在用户的主目录中，每个用户都可以设置自己的密码。因此，请使用你的用户名(尽量不要使用root)运行下列命令：

然后输入密码。

接下来就可以启动VNC server了。在启动VNC server时，需要为你的server指定一个display参数。你可以把display理解为一个桌面，每个用户都可以有自己的桌面。VNC客户端 在连接时，可以指定连接到哪个桌面上。在系统中，display号不能重复，也就是说，如果有用户已经建立了名为“:1”的display，另外一个用户 就不能再使用“:1”了，他可以使用“:2”。
启动VNC server的命令是：

例如，

最后，需要配置一下防火墙，允许VNC客户端连接VNC server。VNC server监听的端口从5900开始，display :1的监听5901，display :2监听5902，以此类推。CentOs的防火墙缺省是不允许连接这些端口的，所以需要使用下面的步骤打开防火墙（需要root权限)：

找到下面的语句：

在此行之前，加上下面的内容：

这句话的含义是，允许其它机器访问本机的5900到5903端口，这样，display:1, display:2, display:3的用户就可以连接到本机。

然后使用root身份重新启动防火墙：

好了，现在就可以运行客户端软件，连接到VNC server上了。
VNC客户端软件很多，在linux下有vncviewer，KDE还提供了一个krdc（它的菜单项就是”Remote Desktop Connection”，远程桌面连接）。
在window也有不少vnc客户端，你可以到http://www.realvnc.com/去下载一个，安装就可以用了。

假设VNC server的IP地址是192.168.1.1，display是:1。在VNC viewer的server栏中输入：“192.168.1.1:1”，然后连接。OK，你可以看到自己的桌面了。以后不管你什么时候关闭自己的本地PC机都不怕了，只要server不关机，你只要连接到VNC server，你就可以看到你前一天关闭本地PC机时的桌面还保持着原样。

不过…这个桌面怎么这么丑？！
原来vncserver默认使用的窗口管理器是twm，这是一个很简陋的窗口管理器，你可以把你的桌面改成GNOME或KDE。
方法是，进入你自己的home目录，然后编辑这个文件：.vnc/xstartup，下面是这个文件的内容：

你可以把像上面这样把”twm &”这一行注释掉，然后在下面加入一行”gnome-session &”，或者是”startkde &”，分别启动GNOME桌面和KDE桌面。

如果server重启了，那你就需要重新运行一次vncserver命令来启动VNC server，这很麻烦。有没有更好的方法呢？

有！我们可以把VNC server启动成后台服务。执行如下步骤：

首先要允许VNC server在系统启动过程中被启动。这可以通过“系统设置–>服务器设置–>服务”菜单来配置，把vncserver一项选上就可以了。
如果使用命令行的话，以root身份运行以下两条命令：

然后编辑/etc/sysconfig/vncservers，以下是文件内容：

解释一下这个文件：
VNCSERVERS这一行是配置在系统启动时启动几个VNC server，上面的例子里运行了三个VNC server，其中user1在display :1，user2在display :2，user3在display :3。
VNCSERVERARGS这三行，分别为VNC server 1, 2, 3配置启动参数，上面的例子里对user1和user2使用屏幕分辨率1024×768，对user3使用800×600。
其它支持的参数请使用“man vncserver”命令查询。

编辑好这个文件后，保存，然后以root身份运行：

这样user1, user2, user3的vncserver就启动了。
以后每次系统重启时，都会自动启动这三个用户的vncserver。

注意：上面三个用户必须已经使用vncpasswd命令设置过vnc密码，不然他的vncserver启动会失败！

C语言编译全过程

右键单击-编辑键-添加，加上utf8,即可

/apps/nautilus/preferences/media_automount

Here are some interesting facts about running Linux kernel. Following information is quite useful if you are planning to compile your own custom kernel

But where is my kernel stored?
Your compiled kernel is always installed in /boot directory:

Here is listing of all installed kernel in my system (filename -> description)
$ ls -l /boot/

• config-2.6.12-1-386 --> Kernel configuration file generated by make menuconfig/make xconfig/make gconfig
• System.map-2.6.12-1-386 --> This file has a map of positions of symbols in the kernel. Device driver such as USB pen uses hot plug, which depend upon symbols generated by depmod utility
• vmlinuz-2.6.12-1-386 -- > Actual Kernel file
• initrd.img-2.6.12-1-386 --> Contains device drivers which are required to boot and load rest of operating system from disk. Usually SCSI and IDE drivers are stored in this file
• grub --> It is a directory, which stores grub Boot loader configuration file
• config --> Soft link to current kernel configuration file
• vmlinuz -> Soft link to current running kernel file
• System.map --> Soft link to current running kernel system map file

But what is 2.6.12 ... yup you are right it is kernel version

How do I find out version of running Linux kernel?
Use any one of the following command:
uname -r
OR
cat /proc/version

How do I find out where running kernel modules (device drivers) are stored?
Use any one of the following command:
ls /lib/modules/$(uname -r)
ls -d /lib/modules/$(uname -r)

How do I load kernel modules at boot time?
/etc/modules file should contain the names of kernel modules that are
to be loaded at boot time, one per line.
$ cat /etc/modules

This is one the essential and important task. Many time we upgrade our kernel and some precompiled drivers won't work with Linux. Especially if you have weird hardware; then vendor may send you driver code aka C files to compile. Or even you can write your own Linux kernel driver. Compiling kernel driver is easy. Kernel 2.6.xx makes it even much more easier. Following steps are required to compile driver as module:

1) You need running kernel source code; if you don't have a source code download it from kernel.org. Untar kernel source code (tar ball) in /usr/src using tar command:
$ tar -zxvf kernel* -C /usr/src

To be frank kernel headers are more than sufficient to compile kernel modules / drivers. See how to install kernel headers under Debian / Ubuntu Linux or RHEL / CentOS / Fedora Linux.

2) Next go to your kernel module source code directory and simply create the Makefile file as follows (assuming your kernel module name is foo):
$ vi Makefile

3) Add following text to it:

obj-m = foo.o
KVERSION = $(shell uname -r)
all:
        make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules
clean:
        make -C /lib/modules/$(KVERSION)/build M=$(PWD) clean

4) Compile module using make command (module build can be done by any user) :
$ make
It will finally creates the foo.ko module in current directory. You can see all actual compile command stored in .foo* files in same directory.

5) Once module compiled successfully, load it using insmod or modprobe command. You need to be root user or privileged user to run insmod:
# insmod foo.ko

Example: hello.c module

1) hello.c C source code. Copy following code and save to hello.c
$ mkdir demo; cd demo
$ vi hello.c


2)Add following c source code to it:

#include <linux/module.h>       /* Needed by all modules */
#include <linux/kernel.h>       /* Needed for KERN_INFO */
#include <linux/init.h>         /* Needed for the macros */

static int __init hello_start(void)
{
printk(KERN_INFO "Loading hello module...\n");
printk(KERN_INFO "Hello world\n");
return 0;
}

static void __exit hello_end(void)
{
printk(KERN_INFO "Goodbye Mr.\n");
}

module_init(hello_start);
module_exit(hello_end);

This is an example modified from original source for demonstration purpose.

3) Save the file. Create new Makefile as follows:
$ vi Makefile
Append following make commands:

obj-m = hello.o
KVERSION = $(shell uname -r)
all:
        make -C /lib/modules/$(KVERSION)/build M=$(PWD) modules
clean:
        make -C /lib/modules/$(KVERSION)/build M=$(PWD) clean

4) Save and close the file.

5) Compile hello.c module:
$ make

6) Become a root user (use su or sudo) and load the module:
$ su -
# insmod hello.ko


Note you can see message on screen if you are logged in as root under run level 3.

7) Verify that module loaded:
# lsmod | less

See message in /var/log/message file:
# tail -f /var/log/message

9) Unload the module:
# rmmod hello

10) Load module when Linux system comes up. File /etc/modules use to load kernel boot time. This file should contain the names of kernel modules that are to be loaded at boot time, one per line. First copy your module to /lib/modules/$(uname -r)/kernel/drivers. Following are suggested steps:

(a) Create directory for hello module:
# mkdir -p /lib/modules/$(uname -r)/kernel/drivers/hello
(b) Copy module:
# cp hello.ko /lib/modules/$(uname -r)/kernel/drivers/hello/
(c) Edit /etc/modules file under Debian Linux:
# vi /etc/modules
(d) Add following line to it:
hello
(e) Reboot to see changes. Use lsmod or dmesg command to verify module loaded or not.
# cat /proc/modules
OR
# lsmod | less

Compiling custom kernel has its own advantages and disadvantages. However, new Linux user / admin find it difficult to compile Linux kernel. Compiling kernel needs to understand few things and then just type couple of commands. This step by step howto covers compiling Linux kernel version 2.6.xx under Debian GNU Linux. However, instructions remains the same for any other distribution except for apt-get command.

Step # 1 Get Latest Linux kernel code

Visit http://kernel.org/ and download the latest source code. File name would be linux-x.y.z.tar.bz2, where x.y.z is actual version number. For example file inux-2.6.25.tar.bz2 represents 2.6.25 kernel version. Use wget command to download kernel source code:
$ cd /tmp
$ wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-x.y.z.tar.bz2

Note: Replace x.y.z with actual version number.

Step # 2 Extract tar (.tar.bz3) file

Type the following command:
# tar -xjvf linux-2.6.25.tar.bz2 -C /usr/src
# cd /usr/src

Step # 3 Configure kernel

Before you configure kernel make sure you have development tools (gcc compilers and related tools) are installed on your system. If gcc compiler and tools are not installed then use apt-get command under Debian Linux to install development tools.
# apt-get install gcc

Now you can start kernel configuration by typing any one of the command:

• $ make menuconfig - Text based color menus, radiolists & dialogs. This option also useful on remote server if you wanna compile kernel remotely.
• $ make xconfig - X windows (Qt) based configuration tool, works best under KDE desktop
• $ make gconfig - X windows (Gtk) based configuration tool, works best under Gnome Dekstop.

For example make menuconfig command launches following screen:
$ make menuconfig

You have to select different options as per your need. Each configuration option has HELP button associated with it so select help button to get help.

Step # 4 Compile kernel

Start compiling to create a compressed kernel image, enter:
$ make
Start compiling to kernel modules:
$ make modules

Install kernel modules (become a root user, use su command):
$ su -
# make modules_install


Step # 5 Install kernel

So far we have compiled kernel and installed kernel modules. It is time to install kernel itself.
# make install

It will install three files into /boot directory as well as modification to your kernel grub configuration file:

• System.map-2.6.25
• config-2.6.25
• vmlinuz-2.6.25

Step # 6: Create an initrd image

Type the following command at a shell prompt:
# cd /boot
# mkinitrd -o initrd.img-2.6.25 2.6.25

initrd images contains device driver which needed to load rest of the operating system later on. Not all computer requires initrd, but it is safe to create one.

Step # 7 Modify Grub configuration file - /boot/grub/menu.lst

Open file using vi:
# vi /boot/grub/menu.lst

title           Debian GNU/Linux, kernel 2.6.25 Default
root            (hd0,0)
kernel          /boot/vmlinuz root=/dev/hdb1 ro
initrd          /boot/initrd.img-2.6.25
savedefault
boot

Remember to setup correct root=/dev/hdXX device. Save and close the file. If you think editing and writing all lines by hand is too much for you, try out update-grub command to update the lines for each kernel in /boot/grub/menu.lst file. Just type the command:
# update-grub
Neat. Huh?

Step # 8 : Reboot computer and boot into your new kernel

Language and Country-Specific Settings

The system is, to a very large extent, internationalized and can be modified for local needs in a flexible manner. In other words, internationalization (I18N) allows specific localizations (L10N). The abbreviations I18N and L10N are derived from the first and last letters of the words and, in between, the number of letters omitted.

Settings are made with LC_ variables defined in the file /etc/sysconfig/language. This refers not only to native language support, but also to the categories Messages (Language), Character Set, Sort Order, Time and Date, Numbers, and Money. Each of these categories can be defined directly with its own variable or indirectly with a master variable in the file language (see the locale man page).

RC_LC_MESSAGES, RC_LC_CTYPE, RC_LC_COLLATE, RC_LC_TIME, RC_LC_NUMERIC, RC_LC_MONETARY

These variables are passed to the shell without the RC_ prefix and represent the listed categories. The shell profiles concerned are listed below. The current setting can be shown with the command locale.

RC_LC_ALL

This variable, if set, overwrites the values of the variables already mentioned.

RC_LANG

If none of the previous variables are set, this is the fallback. By default, only RC_LANG is set. This makes it easier for users to enter their own values.

ROOT_USES_LANG

A yes or no variable. If it is set to no, root always works in the POSIX environment.

The variables can be set with the YaST sysconfig editor (see Section 14.3.1, Changing the System Configuration Using the YaST sysconfig Editor). The value of such a variable contains the language code, country code, encoding, and modifier. The individual components are connected by special characters:

  LANG=[[_].[@]]

localedef -i en_US -f UTF-8 en_US.UTF-8

LANG=cs_CZ.UTF-8
LC_COLLATE=C

The Linux Boot Process

The Linux boot process consists of several stages each represented by a different component. The following list briefly summarizes the boot process and features all the major components involved.