Unix编程常见问题解答

2. 一般文件操作(包括管道和套接字)
*********************************

请同时参考套接字FAQ，在
http://www.lcg.org/sock-faq/

2.1 如何管理多个连接？
======================
“我想同时监控一个以上的文件描述符(fd)/连接(connection)/流(stream)，
应该怎么办？”

使用 select() 或 poll() 函数。

注意：select() 在BSD中被引入，而poll()是SysV STREAM流控制的产物。因此，
这里就有了平台移植上的考虑：纯粹的BSD系统可能仍然缺少poll()，而早一些
的SVR3系统中可能没有select()，尽管在SVR4中将其加入。目前两者都是POSIX.
1g标准，（译者注：因此在linux上两者都存在）

select()和poll()本质上来讲做的是同一件事，只是完成的方法不一样。两者都
通过检验一组文件描述符来检测是否有特定的时间将在上面发生并在一定的时间
内等待其发生。

[重要事项：无论select()还是poll()都不对普通文件起很大效用，它们着重用
于套接口(socket)、管道(pipe)、伪终端(pty)、终端设备(tty)和其他一些字符
设备，但是这些操作都是系统相关(system-dependent)的。]

2.2.1 我如何使用select()函数？
------------------------------
select()函数的接口主要是建立在一种叫'fd_set'类型的基础上。它('fd_set')
是一组文件描述符(fd)的集合。由于fd_set类型的长度在不同平台上不同，因此
应该用一组标准的宏定义来处理此类变量：

fd_set set;
FD_ZERO(&set); /* 将set清零 */
FD_SET(fd, &set); /* 将fd加入set */
FD_CLR(fd, &set); /* 将fd从set中清除 */
FD_ISSET(fd, &set); /* 如果fd在set中则真　*/

在过去，一个fd_set通常只能包含少于等于32个文件描述符，因为fd_set其实只
用了一个int的比特矢量来实现，在大多数情况下，检查fd_set能包括任意值的
文件描述符是系统的责任，但确定你的fd_set到底能放多少有时你应该检查/修
改宏FD_SETSIZE的值。*这个值是系统相关的*，同时检查你的系统中的select()
的man手册。有一些系统对多于1024个文件描述符的支持有问题。[译者注：
linux就是这样的系统！你会发现sizeof(fd_set)的结果是128(*8 =
FD_SETSIZE=1024)　尽管很少你会遇到这种情况。]

select的基本接口十分简单：

int select(int nfds, fd_set *readset, fd_set *writeset,
fd_set *exceptset, struct timeval *timeout);
其中：
nfds : 需要检查的文件描述符个数，数值应该比是三组fd_set中最大数
更大，而不是实际文件描述符的总数。
readset: 用来检查可读性的一组文件描述符。
writeset: 用来检查可写性的一组文件描述符。
exceptset: 用来检查意外状态的文件描述符。(注：错误并不是意外状态)
timeout: NULL指针代表无限等待，否则是指向timeval结构的指针，代表最
长等待时间。(如果其中tv_sec和tv_usec都等于0, 则文件描述符
的状态不被影响，但函数并不挂起)

函数将返回响应操作的对应操作文件描述符的总数，且三组数据均在恰当位置被
修改，只有响应操作的那一些没有修改。接着应该用FD_ISSET宏来查找返回的文
件描述符组。

这里是一个简单的测试单个文件描述符可读性的例子：

int isready(int fd)
{
int rc;
fd_set fds;
struct timeval tv;

FD_ZERO(&fds);
FD_SET(fd,&fds);
tv.tv_sec = tv.tv_usec = 0;

rc = select(fd+1, &fds, NULL, NULL, &tv);
if (rc < 0)
return -1;

return FD_ISSET(fd,&fds) ? 1 : 0;
}

当然如果我们把NULL指针作为fd_set传入的话，这就表示我们对这种操作的发生
不感兴趣，但select() 还是会等待直到其发生或者超过等待时间。

[译者注：在linux中，timeout指的是程序在非sleep状态中度过的时间，而不是
实际上过去的时间，这就会引起和非linux平台移植上的时间不等问题。移植问
题还包括在System V风格中select()在函数退出前会把timeout设为未定义的
NULL状态，而在BSD中则不是这样，linux在这点上遵从System V，因此在重复利
用timeout指针问题上也应该注意。]

2.1.2 我如何使用poll()？
------------------------
poll()接受一个指向结构'struct pollfd'列表的指针，其中包括了你想测试的
文件描述符和事件。事件由一个在结构中事件域的比特掩码确定。当前的结构在
调用后将被填写并在事件发生后返回。在SVR4(可能更早的一些版本)中的
"poll.h"文件中包含了用于确定事件的一些宏定义。事件的等待时间精确到毫秒
(但令人困惑的是等待时间的类型却是int)，当等待时间为0时，poll()函数立即
返回，-1则使poll()一直挂起直到一个指定事件发生。下面是pollfd的结构。

struct pollfd {
int fd; /* 文件描述符 */
short events; /* 等待的事件 */
short revents; /* 实际发生了的事件 */
};

于select()十分相似，当返回正值时，代表满足响应事件的文件描述符的个数，
如果返回0则代表在规定事件内没有事件发生。如发现返回为负则应该立即查看
errno，因为这代表有错误发生。

如果没有事件发生，revents会被清空，所以你不必多此一举。

这里是一个例子：

/* 检测两个文件描述符，分别为一般数据和高优先数据。如果事件发生
则用相关描述符和优先度调用函数handler()，无时间限制等待，直到
错误发生或描述符挂起。*/

#include <stdlib.h>
#include <stdio.h>

#include <sys/types.h>
#include <stropts.h>
#include <poll.h>

#include <unistd.h>
#include <errno.h>
#include <string.h>

#define NORMAL_DATA 1
#define HIPRI_DATA 2

int poll_two_normal(int fd1,int fd2)
{
struct pollfd poll_list[2];
int retval;

poll_list[0].fd = fd1;
poll_list[1].fd = fd2;
poll_list[0].events = POLLIN|POLLPRI;
poll_list[1].events = POLLIN|POLLPRI;

while(1)
{
retval = poll(poll_list,(unsigned long)2,-1);
/* retval 总是大于0或为-1，因为我们在阻塞中工作 */

if(retval < 0)
{
fprintf(stderr,"poll错误: %s
",strerror(errno));
return -1;
}

if(((poll_list[0].revents&POLLHUP) == POLLHUP) ||
((poll_list[0].revents&POLLERR) == POLLERR) ||
((poll_list[0].revents&POLLNVAL) == POLLNVAL) ||
((poll_list[1].revents&POLLHUP) == POLLHUP) ||
((poll_list[1].revents&POLLERR) == POLLERR) ||
((poll_list[1].revents&POLLNVAL) == POLLNVAL))
return 0;

if((poll_list[0].revents&POLLIN) == POLLIN)
handle(poll_list[0].fd,NORMAL_DATA);
if((poll_list[0].revents&POLLPRI) == POLLPRI)
handle(poll_list[0].fd,HIPRI_DATA);
if((poll_list[1].revents&POLLIN) == POLLIN)
handle(poll_list[1].fd,NORMAL_DATA);
if((poll_list[1].revents&POLLPRI) == POLLPRI)
handle(poll_list[1].fd,HIPRI_DATA);
}
}

2.1.3 我是否可以同时使用SysV IPC和select()/poll()？
---------------------------------------------------
*不能。* (除非在AIX上，因为它用一个无比奇怪的方法来实现这种组合)

一般来说，同时使用select()或poll()和SysV 消息队列会带来许多麻烦。SysV
IPC的对象并不是用文件描述符来处理的，所以它们不能被传递给select()和
poll()。这里有几种解决方法，其粗暴程度各不相同：
- 完全放弃使用SysV IPC。
- 用fork()，然后让子进程来处理SysV IPC，然后用管道或套接口和父进程
说话。父进程则使用select()。
- 同上，但让子进程用select()，然后和父亲用消息队列交流。
- 安排进程发送消息给你，在发送消息后再发送一个信号。*警告*：要做好
这个并不简单，非常容易写出会丢失消息或引起死锁的程序。
……另外还有其他方法。

2.2 我如何才能知道和对方的连接被终止？
======================================
如果你在读取一个管道、套接口、FIFO等设备时，当写入端关闭连接时，你将会
得到一个文件结束符(EOF)(read()返回零字节读取)。如果你试图向一个管道或
套接口写入，当读取方关闭连接，你将得到一个SIGPIPE的信号，它会使进程终
止除非指定处理方法。(如果你选择屏蔽或忽略信号，write()会以EPIPE错误退
出。)

2.3 什么是读取目录的最好方法？
==============================
历史上曾有过许多不同的目录读取方法，但目前你应该使用POSIX.1标准的
<dirent.h>接口。

opendir()函数打开一个指定的目录；readdir()将目录以一种标准的格式读入；
closedir()关闭描述符。还有一些其他如rewinddir()、telldir()和seekdir()
等函数，相信不难理解。

如果你想用文件匹配符('*','?')，那么你可以使用大多数系统中都存在的glob()
函数，或者可以查看fnmatch()函数来得到匹配的文件名，或者用ftw()来遍历整
个目录树。

2.4 我如何才能知道一个文件被另外进程打开？
==========================================
这又是一个“经常不被回答的问题”，因为一般来说你的程序不会关心文件是否
正被别人打开。如果你需要处理文件的并发操作，那你应该使用咨询性文件锁。

一般来说要做到这点很难，像fuser或lsof这样可以告诉你文件使用情况的工具
通过解析内核数据来达到目的，但这种方法十分不健康！而且你不能从你的程序
中调用它们来获取信息，因为也许当它们执行完成之后，文件的使用状况在瞬间
又发生了变化，你无法保证这些信息的正确。

2.5 我如何锁住一个文件？
========================
有三种不同的文件锁，这三种都是“咨询性”的，也就是说它们依靠程序之间的
合作，所以一个项目中的所有程序封锁政策的一致是非常重要的，当你的程序需
要和第三方软件共享文件时应该格外地小心。

有些程序利用诸如 FIlENAME.lock 的文件锁文件，然后简单地测试此类文件是否
存在。这种方法显然不太好，因为当产生文件的进程被杀后，锁文件依然存在，
这样文件也许会被永久锁住。UUCP中把产生文件的进程号PID存入文件，但这样做
仍然不保险，因为PID的利用是回收型的。

这里是三个文件锁函数：
flock();
lockf();
fcntl();

flock()是从BSD中衍生出来的，但目前在大多数UNIX系统上都能找到，在单个主
机上flock()简单有效，但它不能在NFS上工作。Perl中也有一个有点让人迷惑的
flock()函数，但却是在perl内部实现的。

fcntl()是唯一的符合POSIX标准的文件锁实现，所以也是唯一可移植的。它也同
时是最强大的文件锁——也是最难用的。在NFS文件系统上，fcntl()请求会被递
交给叫rpc.lockd的守护进程，然后由它负责和主机端的lockd对话，和flock()
不同，fcntl()可以实现记录层上的封锁。

lockf()只是一个简化了的fcntl()文件锁接口。

无论你使用哪一种文件锁，请一定记住在锁生效之前用sync来更新你所有的文件
输入/输出。

lock(fd);
write_to(some_function_of(fd));
flush_output_to(fd); /* 在去锁之前一定要冲洗输出 */
unlock(fd);
do_something_else; /* 也许另外一个进程会更新它 */
lock(fd);
seek(fd, somewhere); /* 因为原来的文件指针已不安全 */
do_something_with(fd);
...

一些有用的fcntl()封锁方法(为了简洁略去错误处理):


#include <fcntl.h>
#include <unistd.h>

read_lock(int fd) /* 整个文件上的一个共享的文件锁 */
{
fcntl(fd, F_SETLKW, file_lock(F_RDLCK, SEEK_SET));
}

write_lock(int fd) /* 整个文件上的一个排外文件锁 */
{
fcntl(fd, F_SETLKW, file_lock(F_WRLCK, SEEK_SET));
}

append_lock(int fd) /* 一个封锁文件结尾的锁，
其他进程可以访问现有内容 */
{
fcntl(fd, F_SETLKW, file_lock(F_WRLCK, SEEK_END));
}

前面所用的file_lock函数如下：

struct flock* file_lock(short type, short whence)
{
static struct flock ret ;
ret.l_type = type ;
ret.l_start = 0 ;
ret.l_whence = whence ;
ret.l_len = 0 ;
ret.l_pid = getpid() ;
return &ret ;
}

2.6 我如何能发现一个文件已由另外一个进程更新？
==============================================
这又几乎是一个经常不被回答的问题，因为问这个问题的人通常期待能有一个系
统级的告示来反映当前目录或文件被修改，但没有什么保证移植性的实现方法，
IRIX有一个非标准的功能用来监测文件操作，但从未听说在其他平台上也有相类
似的功能。

一般来说，你能尽的最大努力就是用fstat()函数，通过监视文件的mtime和ctime
你能得知文件什么时候被修改了，或者被删除/连接/改名了，听起来很复杂，所
以你应该反思一下为什么你要做这些。

2.7 请问du是怎样工作的？
========================
du只简单地用stat()(更准确地说是用lstat()函数)遍历目录结构中的每个文件
和目录，并将它们所占用的磁盘块加在一起。

如果你想知道其中细节，总是这么一句话：“读下源代码吧，老兄！”

BSD(FreeBSD、NetBSD和OpenBSD)的源代码在这些发行的FTP网站的源码目录里，
GNU版本的源码当然可以在任何一个GNU镜像站点中找到——前提是你自己懂得如
何解包。

2.8 我如何得到一个文件的长度？
==============================
用stat()或在文件打开后用fstat()。

这两个调用会将文件信息填入一个结构中， 其中你能找到诸如文件主人、属性、
大小、最后访问时间、最后修改时间等所有关于此文件的东西。

下面的程序大体示范如何用stat()得到文件大小。

#include <stdlib.h>
#include <stdio.h>

#include <sys/types.h>
#include <sys/stat.h>

int get_file_size(char *path,off_t *size)
{
struct stat file_stats;

if(stat(path,&file_stats))
return -1;

*size = file_stats.st_size;
return 0;
}

2.9 我如何像shell里一样扩展在文件名里的'~'？
============================================
'~'的标准用法如下：如果单独使用或者后面跟一个'/'，那么'~'就被当作当前
用户的home目录，[译者注：事实上'~'就被替换为$HOME环境变量]，如果'~'后
直接跟一个用户名，则被替换的就是那个用户的home目录。如果没有合适的匹
配，则shell不会做任何改动。

请注意，有可能一些文件的确是以'~'打头的，不分青红皂白地将'~'替换会使你
的程序无法打开这些文件。一般来说，从shell通过命令行或环境变量传递入程
序的文件名不须要进行替换，因为shell已经替你做好，而程序自己生成的、用
户输入的，或从配置文件中读取的却应该进行替换。

这里是一段用标准string类的C++实现：

string expand_path(const string& path)
{
if (path.length() == 0 || path[0] != '~')
return path;

const char *pfx = NULL;
string::size_type pos = path.find_first_of('/');

if (path.length() == 1 || pos == 1)
{
pfx = getenv("HOME");
if (!pfx)
{
// 我们想替换"~/"，但$HOME却没有设置
struct passwd *pw = getpwuid(getuid());
if (pw)
pfx = pw->pw_dir;
}
}
else
{
string user(path,1,(pos==string::npos) ? string::npos : pos-1);
struct passwd *pw = getpwnam(user.c_str());
if (pw)
pfx = pw->pw_dir;
}
// 如果我们不能找到能替换的选择，则将path返回

if (!pfx)
return path;

string result(pfx);

if (pos == string::npos)
return result;

if (result.length() == 0 || result[result.length()-1] != '/')
result += '/';

result += path.substr(pos+1);

return result;
}

2.10 有名管道(FIFO)能做什么？
=============================

2.10.1 什么是有名管道？
-----------------------
有名管道是一个能在互不相关进程之间传送数据的特殊文件。一个或多个进程向
内写入数据，在另一端由一个进程负责读出。有名管道是在文件系统中可见的，
也就是说ls可以直接看到。(有名管道又称FIFO，也就是先入先出。)

有名管道可以将无关的进程联系起来，而无名的普通管道一般只能将父子进程联
系起来——除非你很努力地去尝试——当然也能联系两个无关进程。有名管道是
严格单向的，尽管在一些系统中无名管道是双向的。

2.10.2 我如何建立一个有名管道？
-------------------------------
在shell下交互地建立一个有名管道，你可以用mknod或mkfifo命令。在有些系统
中，mknod产生的文件可能在/etc目录下，也就是说，可能不在你的目录下出现，
所以请查看你系统中的man手册。[译者注：在linux下，可以看一下fifo(4)]

要在程序中建立一个有名管道：

/* 明确设置umask，因为你不知道谁会读写管道 */
umask(0);
if (mkfifo("test_fifo", S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP))
{
perror("mkfifo");
exit(1);
}

也可以使用mknod。[译者注：在linux下不推荐使用mknod，因为其中有许多臭虫
在NFS下工作更要小心，能使用mkfifo就不要用mknod，因为mkfifo()是POSIX.1
标准。]

/* 明确设置umask，因为你不知道谁会读写管道 */
umask(0);
if (mknod("test_fifo",
S_IFIFO | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
0))
{
perror("mknod");
exit(1);
}

2.10.3 我如何使用一个有名管道？
-------------------------------
使用有名管道十分简单：你如同使用一个普通文件一样打开它，用read()和
write()进行操作。但对管道使用open()时可能引起阻塞，下面一些常用规律可
以参考。

* 如果你同时用读写方式(O_RDWR)方式打开，则不会引起阻塞。
* 如果你用只读方式(O_RDONLY)方式打开，则open()会阻塞一直到有写方打
开管道，除非你指定了O_NONBLOCK，来保证打开成功。
* 同样以写方式(O_WRONLY)打开也会阻塞到有读方打开管道，不同的是如果
O_NONBLOCK被指定open()会以失败告终。

当对有名管道进行读写的时，注意点和操作普通管道和套接字时一样：当写入方
关闭连接时read()返回EOF，如果没有听众write()会得到一个SIGPIPE的信号，
对此信号进行屏蔽或忽略会引发一个EPIPE错误退出。

2.10.4 能否在NFS上使用有名管道？
--------------------------------
不能，在NFS协议中没有相关功能。(你可能可以在一个NFS文件系统中用有名管
道联系两个同在客户端的进程。)

2.10.5 能否让多个进程同时向有名管道内写入数据？
-----------------------------------------------
如果每次写入的数据少于PIPE_BUF的大小，那么就不会出现数据交叉的情况。但
由于对写入的多少没有限制，而read()操作会读取尽可能多的数据，因此你不能
知道数据到底是谁写入的。

PIPE_BUF的大小根据POSIX标准不能小于512，一些系统里在<limits.h>中被定
义，[译者注：linux中不是，其值是4096。]这可以通过pathconf()或fpathconf()
对单独管道进行咨询得到。

2.10.6 有名管道的应用
---------------------
“我如何时间服务器和多个客户端的双向交流？”

一对多的形式经常出现，只要每次客户端向服务器发出的指令小于PIPE_BUF，它
们就可以通过一个有名管道向服务器发送数据。客户端可以很容易地知道服务器
传发数据的管道名。

但问题在于，服务器不能用一个管道来和所有客户打交道。如果不止一个客户在
读一个管道，是无法确保每个客户都得到自己对应的回复。

一个办法就是每个客户在向服务器发送信息前都建立自己的读入管道，或让服务
器在得到数据后建立管道。使用客户的进程号(pid)作为管道名是一种常用的方
法。客户可以先把自己的进程号告诉服务器，然后到那个以自己进程号命名的管
道中读取回复。


3. 终端输入/输出
****************

3.1 我怎样使我的程序不回射输入？
================================

我怎样能使我的程序不回射输入，就象登录时询问我的口令时那样？

有一个简单方法，也有一个稍微复杂点的方法：

简单方法是使用‘getpass()’函数，它几乎能在所有Unix系统上找到。它以一个
给定的字符串参数作为提示符(prompt)。它读取输入直到读到一个‘EOF’或换
行符(译者注：‘EOF’用‘^d’输入，而换行符为‘^m’或回车)然后返回一个
指向位于静态内存区包含键入字符的字符串指针。(译者注：字符串不包含换行
符)

复杂一点的方法是使用‘tcgetattr()’函数和‘tcsetattr()’函数，两个函数都使用
一个‘struct termios’结构来操纵终端。下面这两段程序应当能设置回射状态和
不回射状态。

#include <stdlib.h>
#include <stdio.h>

#include <termios.h>
#include <string.h>

static struct termios stored_settings;

void echo_off(void)
{
struct termios new_settings;
tcgetattr(0,&stored_settings);
new_settings = stored_settings;
new_settings.c_lflag &= (~ECHO);
tcsetattr(0,TCSANOW,&new_settings);
return;
}

void echo_on(void)
{
tcsetattr(0,TCSANOW,&stored_settings);
return;
}

两段程序使用到的都是在POSIX标准定义的。

3.2 我怎样从终端读取单个字符？
==============================

我怎样从终端读取单个字符？我的程序总是要等着用户按回车。

终端通常在标准(canonical)模式，在此模式输入总是经编辑后以行读入。你可以
设置终端为非标准(non-canonical)模式，而在此模式下你可以设置在输入传递给
你的程序前读入多少字符。你也可以设定非标准模式的计时器为0，这个计时器
根据设定的时间间隔清空你的缓冲区。这样做使你可以使用‘getc()’函数立即
获得用户的按键输入。我们使用的‘tcgetattr()’函数和‘tcsetattr()’函数都
是在POSIX中定义用来操纵‘termios’结构的。

#include <stdlib.h>
#include <stdio.h>

#include <termios.h>
#include <string.h>

static struct termios stored_settings;

void set_keypress(void)
{
struct termios new_settings;

tcgetattr(0,&stored_settings);

new_settings = stored_settings;

/* Disable canonical mode, and set buffer size to 1 byte */
new_settings.c_lflag &= (~ICANON);
new_settings.c_cc[VTIME] = 0;
new_settings.c_cc[VMIN] = 1;

tcsetattr(0,TCSANOW,&new_settings);
return;
}

void reset_keypress(void)
{
tcsetattr(0,TCSANOW,&stored_settings);
return;
}

3.3 我怎样检查是否一个键被摁下？
================================

我怎样检查是否一个键被摁下？在DOS上我用‘kbhit()’函数，但是在UNIX
上看来没有相同作用的函数？

如果你设定了终端为单一字符模式(参见上一个问题解答)，那么(在大多数系统)
上你可以使用‘select()’函数或‘poll()’函数测试输入是否可读。

3.4 我怎样将光标在屏幕里移动？
==============================

我怎样将光标在屏幕里移动？我想不用curses而做全屏编辑。(译者注：curses
是一个C/C++编程工具库，它提供编程者许多函数调用，在不用关心终端类型
的情况下操纵终端的显示)。

不开玩笑，你也许不应该想去做这个。Curses工具库知道怎样控制不同终端类型
所表现出的奇特的东西(oddities)；当然termcap/terminfo数据会告诉你任何终端类型
具有的这些奇特东西，但你可能会发现正确把握所有这些奇特组合是一件艰巨的
工作。(译者注：在linux系统上，termcap数据位于/etc/termcap，而terminfo数据位于
/usr/share/terminfo下按不同终端类型首字母存放的不同文件，目前终端类型数已逾
两千种)

但是，你坚决要把你自己搞的手忙脚乱(getting your hands dirty)，那么去研究一下
‘termcap’的函数集，特别是‘tputs()’，‘tparm()’和‘tgoto()’函数。

3.5 pttys是什么？
=================

Pseudo-teletypes(pttys, ptys，或其它不同的缩写)是具有两部份的伪设备(pseudo-devices)：
一部份为“主人”一边，你可以认为是一个‘用户’，另一部份是“仆人”一边，
它象一个标准的tty设备一样工作。

它们之所以存在是为了提供在程序控制下的一种模拟串行终端行为的方法。比
如，‘telnet’在远端系统使用一个伪终端；服务器的远端登录shell程序只是从“仆
人”一边的tty设备期待着得到操作行为，而在“主人”一边的伪终端由一个守护程
序控制，同时守护程序将所有数据通过网络转发。pttys也被其它程序使用，比如
‘xterm’，‘expect’，‘script’，‘screen’，‘emacs’和其它很多程序。

3.6 怎样控制一个串行口和调制解调器？
====================================

Unix系统下对于串行口的控制很大程度上受串行终端传统的使用影响。以往，
需要不同ioctls函数调用的组合和其它黑客行为才能控制一个串行设备的正确操
作，不过值得庆幸的是，POSIX在这个方面的标准化作了一些努力。

如果你使用的系统不支持‘<termios.h>’头文件，‘tcsetattr()’和其它相关函数，
那么你只能到其它地方去找点资料(或将你的老古董系统升级一下)。

但是不同的系统仍然有显著的区别，主要是在设备名，硬件流控制的操作，和
调制解调器的信号方面。(只要可能，尽量让设备驱动程序去做握手(handshaking)
工作，而不要试图直接操纵握手信号。)

打开和初始华串行设备的基本步骤是：

* 调用‘open()’函数打开设备；而且可能需要使用特定标志作为参数：

`O_NONBLOCK'
除非使用这个标志，否则打开一个供拨入(dial-in)或由调制解调器控制的设
备会造成‘open()’调用被阻塞直到线路接通(carrier is present)。一个非
阻塞的打开操作给你在需要时令调制解调器控制失效的机会。(参见下面的
CLOCAL)

`O_NOCTTY'
在自4.4BSD演化的系统上这个标志是多余的，但在其它系统上它控制串行
设备是否成为会话的控制终端。在大多数情况下你可能不想获得一个控制
终端，所以就要设置这个标志，但是也有例外情况。

* 调用‘tcgetattr()’函数获得当前设备模式。虽然有人会经常取消(ignore)得到的
大多数或全部初始设定，但它仍然不失为一个初始化‘struct termios’结构的
便利方法。

* 设置termios 结构里‘c_iflag’，‘c_oflag’，‘c_flag’，‘c_lfag’和‘c_cc’
为合适的值。(参见下面部分。)

* 调用‘cfsetispeed()’和‘cfsetospeed()’设定设想的波特率。很少系统允许你
设置不同的输入和输出速度，所以普通规律是你需要设成同一个设想的值。

* 调用‘tcsetattr()’设定设备模式。

* 如果你是用‘O_NONBLOCK’标志打开的端口，你可能希望调用‘fcntl()’
函数将‘O_NONBLOCK’标志重新设置成关闭。因为不同系统看来对是否
由非阻塞打开的端口对今后的‘read()’调用造成影响有不同的处理；所以
最好显式地设置好。

一旦你打开并设置了端口，你可以正常地调用‘read()’函数和‘write()’函数。
注意到‘read()’函数的行为将受到你调用‘tcsetattr()’函数时的标志参数设定
的控制。

‘tcflush()’，‘tcdrain()’，‘tcsendbreak()’和‘tcflow()’是其它一些你应当
注意的函数。

当你使用完端口想要关闭时，要注意一些系统上特别恶心的小危险；如果有任何
输出数据等待被写到设备(比如输出流被硬件或软件握手而暂停)，你的进程将因
为‘close()’函数调用而被挂起(hang)直到输出数据排空，而且这时的进程是*不
可杀的*(unkillably)。所以调用‘tcflush()’函数丢弃待发数据可能是个明智之举。

(在我的经验中，在tty设备上被阻塞的输出数据是造成不可杀进程最普通的原因。)

3.6.1 串行设备和类型
--------------------

不同系统用于串行端口设备的设备名大相径庭。以下是不同系统的一些例子：

* ‘/dev/tty[0-9][a-z]’作为直接访问设备，而
‘/dev/tty[0-9][A-Z]’ 作为调制解调器控制设备(比如SCO Unix)

* ‘/dev/cua[0-9]p[0-9]’作为直接访问设备，‘/dev/cul[0-9]p[0-9]’作为拨出设
备，而‘/dev/ttyd[0-9]p[0-9]’作为拨入设备(比如HP-UX)

* ‘/dev/cua[a-z][0-9]’作为拨出设备而‘/dev/tty[a-z][0-9]’作为拨入设备(比如
FreeBSD)

是否正确地同所用设备名交互，并在任何硬件握手信号线上产生相应的效果是
与系统，配置和硬件有关的，但是差不多总是遵循下面这些规则(假设硬件是
RS-232 DTE)：

- 对于任何设备的一个成功打开操作应当设置DTR和RTS

- 一个对于由调制解调器控制或供拨入的设备的阻塞打开操作将等待DCD(并且
可能DSR和/或CTS也需要)被设置，通常在设置DTR/RTS之后。

- 如果一个对于拨出设备的打开操作正巧赶上一个对于相应拨入设备的打开操作
因为等待线路接通而阻塞，那么打开拨出的操作*也许*造成打开拨入的操作完
成，但*也许也不*造成。一些系统为拨入和拨出端口实现一个简单的共享方案，
当拨出端口在使用时，拨入端口被有效地设置成睡眠状态(“put to sleep”)；其
它系统不这样做，在这种系统上为避免竞争(contention)问题，需要外部的协助才
能使拨入和拨出共享端口(比如UUCP锁定文件的使用)。

3.6.2 设置termios的标志位
-------------------------

这里是对你在使用你自己打开的串行设备时设置termios标志的一些提示(即与你使
用已存在的控制tty相反)

3.6.2.1 c_iflag
...............

你也许希望将*所有*‘c_iflag’的标志位设成0，除非你希望使用软件流控制(ick)，
在这种情况下你设置‘IXON’和‘IXOFF’。(译者注：有三个标志控制流控制：
IXON，IXOFF ，和IXANY，如果IXON被设置，那么tty输入队列的软件流控制
被设置。当程序无法跟上输入队列的速度，tty传输一个STOP字符，而当输入队
列差不多空时发送START字符。如果IXON被设置，那么tty输出队列的软件流控
制被设置。当tty所连接的设备跟不上输出速度，tty将阻塞程序对tty的写操作。如果
IXANY被设置，那么一旦tty从设备收到任何字符，被暂定的输出将继续 - 译自SCO
Unix 网上文档http://uw7doc.sco.com/SDK_sysprog/CTOC-TermDevCntl.html，“TTY flow
control”章节，第五，六段)

3.6.2.2 c_oflag
...............

大部分‘c_oflag’的标志位是为了能使对于慢终端的输出可以正常工作所做的这
样或那样的黑客行为，由此，一些较新的系统认为几乎所有这些标志位已经过
时从而摈弃了它们(特别是所有血淋淋(gory)的输出排列对齐(output-padding)选项)。
如同‘c_iflag’，将它设置成全0对于大部分应用程序来说是合理的。

3.6.2.3 c_cflag
...............

当设置字符的大小时，记住首先使用‘CSIZE’屏蔽，比如设置8位字符，需要：

attr.c_cflag &= ~CSIZE;
attr.c_cflag |= CS8;

在‘c_cflag’里的其它你有可能需要设置为*真*的标志包括‘CREAD’和
‘HUPCL’。

如果你需要产生偶校验，那么设置‘PARENB’并清除‘PARODD’；如果你
需要产生奇校验，那么同时设置‘PARENB’和‘PARODD’。如果你根本不
想设置校验，那么确认清除‘PARENB’。

清除‘CSTOPB’ ，除非你真需要产生两个停止位。

设置硬件流控制的标志可能也能在‘c_cflag’中找到，但它们不是被标准化的(
这是一个遗憾)

3.6.2.4 c_lflag
...............

大部分应用程序可能需要关闭‘ICANON’(标准状态，即基于行的，并进行输
入处理)，‘ECHO’和‘ISIG’。

‘IEXTEN’是个更复杂的问题。如果你不把它关闭，具体实现允许你作一些非
标准的事情(比如在‘c_cc’中定义增加的控制字符)从而可能导致不可预料的接
果，但是在一些系统上，你可能需要保持‘IEXTEN’标志为真以得到一些有用
的特征，比如硬件流控制。

3.6.2.5 c_cc
............

这是一个包括输入中带有特殊含义字符的数组。这些字符被命名为‘VINTR’，
‘VSTOP’等等；这些名字是这个数组的索引。

(这些字符中的两个其实根本不是字符，而是当‘ICANON’被关闭时对于
‘read()’函数行为的控制；它们是‘VMIN’和‘VTIME’。)

这些索引名字经常被提及的方式会让人以为它们是实在的变量，比如“设置
VMIN为1” 其实意味着“设置c_cc[VMIN]为1”。这种简写是有用的并且只是
偶尔引起误会。

‘c_cc’的很多变量位置只有当其它标志被设定时才会用到。

只有‘ICANON’被设置，才用到以下变量：
‘VEOF’，‘VEOL’，‘VERASE’，‘VKILL’(如果定义了而且
‘IEXTEN’被设定，那么‘VEOL2’，‘VSTATUS’和‘VWERASE’
也用到)

只有‘ISIG’被设置，才用到以下变量：
‘VINTR’，‘VQUIT’，‘VSUSP’(如果定义了而且‘IEXTEN’被设定，
那么‘VDSUSP’也用到)

只有‘IXON’或‘IXOFF’被设置，才用到以下变量：
‘VSTOP’，‘VSTART’

只有‘ICANON’被取消，才用到以下变量：
‘VMIN’，‘VTIME’

不同系统实现会定义增加的‘c_cc’变量。谨慎的做法是在设定你希望使用的值
以前，使用‘_POSIX_VDISABLE’初始化这些变量(常量‘NCCS’提供这个数
组的大小)

‘VMIN’和‘VTIME’(根据不同的实现方法，它们有可能和‘VEOF’和‘VEOL’
分享相同两个变量)具有以下含义。‘VTIME’的值(如果不为0)总是被解释为以十
分之一秒为单位的计时器)(译者注：VTIME变量是一个字节长，所以1表示0.1秒，
最大为255，表示25.5秒)

`c_cc[VMIN] > 0, c_cc[VTIME] > 0'
只要输入已经有VMIN字节长，或者输入至少有一个字符而在读取最后一个字
符之前VTIME已经过期，或者被信号中断，‘read()’将返回。

`c_cc[VMIN] > 0, c_cc[VTIME] == 0'
只要输入已经有VMIN字节长，或者被信号中断，‘read()’将返回。否则，将
无限等待下去。

`c_cc[VMIN] == 0, c_cc[VTIME] > 0'
只要有输入‘read()’就返回；如果VTIME过期却没有数据，它会返回没有读
到字符。(这和调制解调器挂断时的文件结束标志有一点冲突；使用1作为VMIN，
调用‘alarm()’或‘select()’函数并给定超时参数可以避免这个问题。)

`c_cc[VMIN] == 0, c_cc[VTIME] == 0'
‘read()’总是立刻返回；如果没有数据则返回没有读到字符。(与上面的问题
相同)

4. 系统信息
***********

[1] [2] [3]

编辑 webmaster