UNIX常用系统函数

最新推荐文章于 2024-01-18 20:38:33 发布

flingblue

最新推荐文章于 2024-01-18 20:38:33 发布

阅读量3.5k

点赞数

文章标签： unix socket struct signal buffer symlink

getopt（分析命令行参数）
相关函数

表头文件 #include<unistd.h>

定义函数 int getopt(int argc,char * const argv[ ],const char * optstring);

函数说明 getopt()用来分析命令行参数。参数argc和argv是由main()传递的参数个数和内容。参数optstring 则代表欲处理的选项字符串。此函数会返回在argv 中下一个的选项字母，此字母会对应参数optstring 中的字母。如果选项字符串里的字母后接着冒号":"，则表示还有相关的参数，全域变量optarg 即会指向此额外参数。如果getopt()找不到符合的参数则会印出错信息，并将全域变量optopt设为""字符，如果不希望getopt()印出错信息，则只要将全域变量opterr设为0即可。

返回值如果找到符合的参数则返回此参数字母，如果参数不包含在参数optstring 的选项字母则返回""字符，分析结束则返回-1。

范例 #include<stdio.h>
#include<unistd.h>
int main(int argc,char **argv)
{
int ch;
opterr = 0;
while((ch = getopt(argc,argv,"a:bcde"))!= -1)
switch(ch)
{
case 'a':
printf("option a:'%s'/n",optarg);
break;
case 'b':
printf("option b :b/n");
break;
default:
printf("other option :%c/n",ch);
}
printf("optopt +%c/n",optopt);
}

执行 $./getopt –b
option b:b
$./getopt –c
other option:c
$./getopt –a
other option :
$./getopt –a12345
option a:'12345'

isatty（判断文件描述词是否是为终端机）
相关函数 ttyname

表头文件 #include<unistd.h>

定义函数 int isatty(int desc);

函数说明如果参数desc所代表的文件描述词为一终端机则返回1，否则返回0。

返回值如果文件为终端机则返回1，否则返回0。

范例参考ttyname()。

select（I/O多工机制）
表头文件 #include<sys/time.h>
#include<sys/types.h>
#include<unistd.h>

定义函数 int select(int n,fd_set * readfds,fd_set * writefds,fd_set * exceptfds,struct timeval * timeout);

函数说明 select()用来等待文件描述词状态的改变。参数n代表最大的文件描述词加1，参数readfds、writefds 和exceptfds 称为描述词组，是用来回传该描述词的读，写或例外的状况。底下的宏提供了处理这三种描述词组的方式:
FD_CLR(inr fd,fd_set* set)；用来清除描述词组set中相关fd 的位
FD_ISSET(int fd,fd_set *set)；用来测试描述词组set中相关fd 的位是否为真
FD_SET（int fd,fd_set*set）；用来设置描述词组set中相关fd的位
FD_ZERO（fd_set *set）；用来清除描述词组set的全部位

参数 timeout为结构timeval，用来设置select()的等待时间，其结构定义如下
struct timeval
{
time_t tv_sec;
time_t tv_usec;
};

返回值如果参数timeout设为NULL则表示select（）没有timeout。

错误代码执行成功则返回文件描述词状态已改变的个数，如果返回0代表在描述词状态改变前已超过timeout时间，当有错误发生时则返回-1，错误原因存于errno，此时参数readfds，writefds，exceptfds和timeout的值变成不可预测。
EBADF 文件描述词为无效的或该文件已关闭
EINTR 此调用被信号所中断
EINVAL 参数n 为负值。
ENOMEM 核心内存不足

范例常见的程序片段:fs_set readset；
FD_ZERO(&readset);
FD_SET(fd,&readset);
select(fd+1,&readset,NULL,NULL,NULL);
if(FD_ISSET(fd,readset){……}

ttyname（返回一终端机名称）
相关函数 Isatty

表头文件 #include<unistd.h>

定义函数 char * ttyname(int desc);

函数说明如果参数desc所代表的文件描述词为一终端机，则会将此终端机名称由一字符串指针返回，否则返回NULL。

返回值如果成功则返回指向终端机名称的字符串指针，有错误情况发生时则返回NULL。

范例 #include<unistd.h>
#include<sys/types.h>
#include <sys/stat.h>
#include<fcntl.h>
main()
{
int fd;
char * file = "/dev/tty";
fd = open (fiel,O_RDONLY);
printf("%s",file);
if(isatty(fd)){
printf("is a tty./n");
printf("ttyname = %s /n",ttyname(fd));
}
else printf(" is not a tty/n");
close(fd);
}

执行 /dev/tty is a tty
ttyname = /dev/tty

添加评论 | 阅读评论 (1)
3:45 | 固定链接 | 引用通告 (0) | 记录它

固定链接关闭

http://net.pku.edu.cn/~yhf/linux_c/function/15.html

getenv（取得环境变量内容）
相关函数 putenv，setenv，unsetenv

表头文件 #include<stdlib.h>

定义函数 char * getenv(const char *name);

函数说明 getenv()用来取得参数name环境变量的内容。参数name为环境变量的名称，如果该变量存在则会返回指向该内容的指针。环境变量的格式为name＝value。

返回值执行成功则返回指向该内容的指针，找不到符合的环境变量名称则返回NULL。

范例 #include<stdlib.h>
mian()
{
char *p;
if((p = getenv("USER")))
printf("USER=%s/n",p);
}

执行 USER = root

putenv（改变或增加环境变量）
相关函数 getenv，setenv，unsetenv

表头文件 #include4<stdlib.h>

定义函数 int putenv(const char * string);

函数说明 putenv()用来改变或增加环境变量的内容。参数string的格式为name＝value，如果该环境变量原先存在，则变量内容会依参数string改变，否则此参数内容会成为新的环境变量。

返回值执行成功则返回0，有错误发生则返回-1。

错误代码 ENOMEM 内存不足，无法配置新的环境变量空间。

范例 #include<stdlib.h>
main()
{
char *p;
if((p = getenv("USER")))
printf("USER =%s/n",p);
putenv("USER=test");
printf("USER+5s/n",getenv("USER"));
}

执行 USER=root
USER=root

setenv（改变或增加环境变量）
相关函数 getenv，putenv，unsetenv

表头文件 #include<stdlib.h>

定义函数 int setenv(const char *name,const char * value,int overwrite);

函数说明 setenv()用来改变或增加环境变量的内容。参数name为环境变量名称字符串。

参数 value则为变量内容，参数overwrite用来决定是否要改变已存在的环境变量。如果overwrite不为0，而该环境变量原已有内容，则原内容会被改为参数value所指的变量内容。如果overwrite为0，且该环境变量已有内容，则参数value会被忽略。

返回值执行成功则返回0，有错误发生时返回-1。

错误代码 ENOMEM 内存不足，无法配置新的环境变量空间

范例 #include<stdlib.h>
main()
{
char * p;
if((p=getenv("USER")))
printf("USER =%s/n",p);
setenv("USER","test",1);
printf("USER=%s/n",getenv("USEr"));
unsetenv("USER");
printf("USER=%s/n",getenv("USER"));
}

执行 USER = root
USER = test
USER = (null)

添加评论
3:44 | 固定链接 | 引用通告 (0) | 记录它

固定链接关闭

http://net.pku.edu.cn/~yhf/linux_c/function/14.html

accept（接受socket连线）
相关函数 socket，bind，listen，connect

表头文件 #include<sys/types.h>
#include<sys/socket.h>

定义函数 int accept(int s,struct sockaddr * addr,int * addrlen);

函数说明 accept()用来接受参数s的socket连线。参数s的socket必需先经bind()、listen()函数处理过，当有连线进来时accept()会返回一个新的socket处理代码，往后的数据传送与读取就是经由新的socket处理，而原来参数s的socket能继续使用accept()来接受新的连线要求。连线成功时，参数addr所指的结构会被系统填入远程主机的地址数据，参数addrlen为scokaddr的结构长度。关于结构sockaddr的定义请参考bind()。

返回值成功则返回新的socket处理代码，失败返回-1，错误原因存于errno中。

错误代码 EBADF 参数s 非合法socket处理代码。
EFAULT 参数addr指针指向无法存取的内存空间。
ENOTSOCK 参数s为一文件描述词，非socket。
EOPNOTSUPP 指定的socket并非SOCK_STREAM。
EPERM 防火墙拒绝此连线。
ENOBUFS 系统的缓冲内存不足。
ENOMEM 核心内存不足。

范例参考listen()。

bind（对socket定位）
相关函数 socket，accept，connect，listen

表头文件 #include<sys/types.h>
#include<sys/socket.h>

定义函数 int bind(int sockfd,struct sockaddr * my_addr,int addrlen);

函数说明 bind()用来设置给参数sockfd的socket一个名称。此名称由参数my_addr指向一sockaddr结构，对于不同的socket domain定义了一个通用的数据结构
struct sockaddr
{
unsigned short int sa_family;
char sa_data[14];
};
sa_family 为调用socket（）时的domain参数，即AF_xxxx值。
sa_data 最多使用14个字符长度。
此sockaddr结构会因使用不同的socket domain而有不同结构定义，例如使用AF_INET domain，其socketaddr结构定义便为
struct socketaddr_in
{
unsigned short int sin_family;
uint16_t sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[8];
};
struct in_addr
{
uint32_t s_addr;
};
sin_family 即为sa_family
sin_port 为使用的port编号
sin_addr.s_addr 为IP 地址
sin_zero 未使用。

参数 addrlen为sockaddr的结构长度。

返回值成功则返回0，失败返回-1，错误原因存于errno中。

错误代码 EBADF 参数sockfd 非合法socket处理代码。
EACCESS 权限不足
ENOTSOCK 参数sockfd为一文件描述词，非socket。

范例参考listen()

connect（建立socket连线）
相关函数 socket，bind，listen

表头文件 #include<sys/types.h>
#include<sys/socket.h>

定义函数 int connect (int sockfd,struct sockaddr * serv_addr,int addrlen);

函数说明 connect()用来将参数sockfd 的socket 连至参数serv_addr 指定的网络地址。结构sockaddr请参考bind()。参数addrlen为sockaddr的结构长度。

返回值成功则返回0，失败返回-1，错误原因存于errno中。

错误代码 EBADF 参数sockfd 非合法socket处理代码
EFAULT 参数serv_addr指针指向无法存取的内存空间
ENOTSOCK 参数sockfd为一文件描述词，非socket。
EISCONN 参数sockfd的socket已是连线状态
ECONNREFUSED 连线要求被server端拒绝。
ETIMEDOUT 企图连线的操作超过限定时间仍未有响应。
ENETUNREACH 无法传送数据包至指定的主机。
EAFNOSUPPORT sockaddr结构的sa_family不正确。
EALREADY socket为不可阻断且先前的连线操作还未完成。

范例 /* 利用socket的TCP client
此程序会连线TCP server，并将键盘输入的字符串传送给server。
TCP server范例请参考listen（）。
*/
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#define PORT 1234
#define SERVER_IP " 127.0.0.1"
main()
{
int s;
struct sockaddr_in addr;
char buffer[256];
if((s = socket(AF_INET,SOCK_STREAM,0))<0){
perror("socket");
exit(1);
}
/* 填写sockaddr_in结构*/
bzero(&addr,sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port=htons(PORT);
addr.sin_addr.s_addr = inet_addr(SERVER_IP);
/* 尝试连线*/
if(connect(s,&addr,sizeof(addr))<0){
perror("connect");
exit(1);
}
/* 接收由server端传来的信息*/
recv(s,buffer,sizeof(buffer),0);
printf("%s/n",buffer);
while(1){
bzero(buffer,sizeof(buffer));
/* 从标准输入设备取得字符串*/
read(STDIN_FILENO,buffer,sizeof(buffer));
/* 将字符串传给server端*/
if(send(s,buffer,sizeof(buffer),0)<0){
perror("send");
exit(1);
}
}
}

执行 $ ./connect
Welcome to server!
hi I am client! /*键盘输入*/
/*<Ctrl+C>中断程序*/

endprotoent（结束网络协议数据的读取）
相关函数 getprotoent，getprotobyname，getprotobynumber，setprotoent

表头文件 #include<netdb.h>

定义函数 void endprotoent(void);

函数说明 endprotoent()用来关闭由getprotoent()打开的文件。

返回值

范例参考getprotoent()

endservent（结束网络服务数据的读取）
相关函数 getservent，getservbyname，getservbyport，setservent

表头文件 #include<netdb.h>

定义函数 void endservent(void);

函数说明 endservent()用来关闭由getservent()所打开的文件。

返回值

范例参考getservent()。

getsockopt（取得socket状态）
相关函数 setsockopt

表头文件 #include<sys/types.h>
#include<sys/socket.h>

定义函数 int getsockopt(int s,int level,int optname,void* optval,socklen_t* optlen);

函数说明 getsockopt()会将参数s所指定的socket状态返回。参数optname代表欲取得何种选项状态，而参数optval则指向欲保存结果的内存地址，参数optlen则为该空间的大小。参数level、optname请参考setsockopt()。

返回值成功则返回0，若有错误则返回-1，错误原因存于errno

错误代码 EBADF 参数s 并非合法的socket处理代码
ENOTSOCK 参数s为一文件描述词，非socket
ENOPROTOOPT 参数optname指定的选项不正确
EFAULT 参数optval指针指向无法存取的内存空间

范例 #include<sys/types.h>
#include<sys/socket.h>
main()
{
int s,optval,optlen = sizeof(int);
if((s = socket(AF_INET,SOCK_STREAM,0))<0) perror("socket");
getsockopt(s,SOL_SOCKET,SO_TYPE,&optval,&optlen);
printf("optval = %d/n",optval);
close(s);}

执行 optval = 1 /*SOCK_STREAM的定义正是此值*/

htonl（将32位主机字符顺序转换成网络字符顺序）
相关函数 htons，ntohl，ntohs

表头文件 #include<netinet/in.h>

定义函数 unsigned long int htonl(unsigned long int hostlong);

函数说明 htonl（）用来将参数指定的32位hostlong 转换成网络字符顺序。

返回值返回对应的网络字符顺序。

范例参考getservbyport()或connect()。

htons（将16位主机字符顺序转换成网络字符顺序）
相关函数 htonl，ntohl，ntohs

表头文件 #include<netinet/in.h>

定义函数 unsigned short int htons(unsigned short int hostshort);

函数说明 htons()用来将参数指定的16位hostshort转换成网络字符顺序。

返回值返回对应的网络字符顺序。

范例参考connect()。

inet_addr（将网络地址转成二进制的数字）
相关函数 inet_aton，inet_ntoa

表头文件 #include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>

定义函数 unsigned long int inet_addr(const char *cp);

函数说明 inet_addr()用来将参数cp所指的网络地址字符串转换成网络所使用的二进制数字。网络地址字符串是以数字和点组成的字符串，例如:"163.13.132.68"。

返回值成功则返回对应的网络二进制的数字，失败返回-1。

inet_aton（将网络地址转成网络二进制的数字）
相关函数 inet_addr，inet_ntoa

表头文件 #include<sys/scoket.h>
#include<netinet/in.h>
#include<arpa/inet.h>

定义函数 int inet_aton(const char * cp,struct in_addr *inp);

函数说明 inet_aton()用来将参数cp所指的网络地址字符串转换成网络使用的二进制的数字，然后存于参数inp所指的in_addr结构中。
结构in_addr定义如下
struct in_addr
{
unsigned long int s_addr;
};

返回值成功则返回非0值，失败则返回0。

inet_ntoa（将网络二进制的数字转换成网络地址）
相关函数 inet_addr，inet_aton

表头文件 #include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>

定义函数 char * inet_ntoa(struct in_addr in);

函数说明 inet_ntoa()用来将参数in所指的网络二进制的数字转换成网络地址，然后将指向此网络地址字符串的指针返回。

返回值成功则返回字符串指针，失败则返回NULL。

listen（等待连接）
相关函数 socket，bind，accept，connect

表头文件 #include<sys/socket.h>

定义函数 int listen(int s,int backlog);

函数说明 listen()用来等待参数s 的socket连线。参数backlog指定同时能处理的最大连接要求，如果连接数目达此上限则client端将收到ECONNREFUSED的错误。Listen()并未开始接收连线，只是设置socket为listen模式，真正接收client端连线的是accept()。通常listen()会在socket()，bind()之后调用，接着才调用accept()。

返回值成功则返回0，失败返回-1，错误原因存于errno

附加说明 listen()只适用SOCK_STREAM或SOCK_SEQPACKET的socket类型。如果socket为AF_INET则参数backlog 最大值可设至128。

错误代码 EBADF 参数sockfd非合法socket处理代码
EACCESS 权限不足
EOPNOTSUPP 指定的socket并未支援listen模式。

范例 #include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#define PORT 1234
#define MAXSOCKFD 10
main()
{
int sockfd,newsockfd,is_connected[MAXSOCKFD],fd;
struct sockaddr_in addr;
int addr_len = sizeof(struct sockaddr_in);
fd_set readfds;
char buffer[256];
char msg[ ] ="Welcome to server!";
if ((sockfd = socket(AF_INET,SOCK_STREAM,0))<0){
perror("socket");
exit(1);
}
bzero(&addr,sizeof(addr));
addr.sin_family =AF_INET;
addr.sin_port = htons(PORT);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(sockfd,&addr,sizeof(addr))<0){
perror("connect");
exit(1);
}
if(listen(sockfd,3)<0){
perror("listen");
exit(1);
}
for(fd=0;fd<MAXSOCKFD;fd++)
is_connected[fd]=0;
while(1){
FD_ZERO(&readfds);
FD_SET(sockfd,&readfds);
for(fd=0;fd<MAXSOCKFD;fd++)
if(is_connected[fd]) FD_SET(fd,&readfds);
if(!select(MAXSOCKFD,&readfds,NULL,NULL,NULL))continue;
for(fd=0;fd<MAXSOCKFD;fd++)
if(FD_ISSET(fd,&readfds)){
if(sockfd = =fd){
if((newsockfd = accept (sockfd,&addr,&addr_len))<0)
perror("accept");
write(newsockfd,msg,sizeof(msg));
is_connected[newsockfd] =1;
printf("cnnect from %s/n",inet_ntoa( addr.sin_addr));
}else{
bzero(buffer,sizeof(buffer));
if(read(fd,buffer,sizeof(buffer))<=0){
printf("connect closed./n");
is_connected[fd]=0;
close(fd);
}else
printf("%s",buffer);
}
}
}
}

执行 $ ./listen
connect from 127.0.0.1
hi I am client
connected closed.

ntohl（将32位网络字符顺序转换成主机字符顺序）
相关函数 htonl，htons，ntohs

表头文件 #include<netinet/in.h>

定义函数 unsigned long int ntohl(unsigned long int netlong);

函数说明 ntohl()用来将参数指定的32位netlong转换成主机字符顺序。

返回值返回对应的主机字符顺序。

范例参考getservent()。

ntohs（将16位网络字符顺序转换成主机字符顺序）
相关函数 htonl，htons，ntohl

表头文件 #include<netinet/in.h>

定义函数 unsigned short int ntohs(unsigned short int netshort);

函数说明 ntohs()用来将参数指定的16位netshort转换成主机字符顺序。

返回值返回对应的主机顺序。

范例参考getservent()。

recv（经socket接收数据）
相关函数 recvfrom，recvmsg，send，sendto，socket

表头文件 #include<sys/types.h>
#include<sys/socket.h>

定义函数 int recv(int s,void *buf,int len,unsigned int flags);

函数说明 recv()用来接收远端主机经指定的socket传来的数据，并把数据存到由参数buf 指向的内存空间，参数len为可接收数据的最大长度。

参数 flags一般设0。其他数值定义如下:
MSG_OOB 接收以out-of-band 送出的数据。
MSG_PEEK 返回来的数据并不会在系统内删除，如果再调用recv()会返回相同的数据内容。
MSG_WAITALL强迫接收到len大小的数据后才能返回，除非有错误或信号产生。
MSG_NOSIGNAL此操作不愿被SIGPIPE信号中断返回值成功则返回接收到的字符数，失败返回-1，错误原因存于errno中。

错误代码 EBADF 参数s非合法的socket处理代码
EFAULT 参数中有一指针指向无法存取的内存空间
ENOTSOCK 参数s为一文件描述词，非socket。
EINTR 被信号所中断
EAGAIN 此动作会令进程阻断，但参数s的socket为不可阻断
ENOBUFS 系统的缓冲内存不足。
ENOMEM 核心内存不足
EINVAL 传给系统调用的参数不正确。

范例参考listen()。

recvfrom（经socket接收数据）
相关函数 recv，recvmsg，send，sendto，socket

表头文件 #include<sys/types.h>
#include<sys/socket.h>

定义函数 int recvfrom(int s,void *buf,int len,unsigned int flags ,struct sockaddr *from ,int *fromlen);

函数说明 recv()用来接收远程主机经指定的socket 传来的数据，并把数据存到由参数buf 指向的内存空间，参数len 为可接收数据的最大长度。参数flags 一般设0，其他数值定义请参考recv()。参数from用来指定欲传送的网络地址，结构sockaddr 请参考bind()。参数fromlen为sockaddr的结构长度。

返回值成功则返回接收到的字符数，失败则返回-1，错误原因存于errno中。

错误代码 EBADF 参数s非合法的socket处理代码
EFAULT 参数中有一指针指向无法存取的内存空间。
ENOTSOCK 参数s为一文件描述词，非socket。
EINTR 被信号所中断。
EAGAIN 此动作会令进程阻断，但参数s的socket为不可阻断。
ENOBUFS 系统的缓冲内存不足
ENOMEM 核心内存不足
EINVAL 传给系统调用的参数不正确。

范例 /*利用socket的UDP client
此程序会连线UDP server，并将键盘输入的字符串传给server。
UDP server 范例请参考sendto（）。
*/
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<sys/typs.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#define PORT 2345
#define SERVER_IP " 127.0.0.1"
main()
{
int s,len;
struct sockaddr_in addr;
int addr_len =sizeof(struct sockaddr_in);
char buffer[256];
/* 建立socket*/
if((s = socket(AF_INET,SOCK_DGRAM,0))<0){
perror("socket");
exit(1);
}
/* 填写sockaddr_in*/
bzero(&addr,sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
addr.sin_addr.s_addr = inet_addr(SERVER_IP);
while(1){
bzero(buffer,sizeof(buffer));
/* 从标准输入设备取得字符串*/
len =read(STDIN_FILENO,buffer,sizeof(buffer));
/* 将字符串传送给server端*/
sendto(s,buffer,len,0,&addr,addr_len);
/* 接收server端返回的字符串*/
len = recvfrom(s,buffer,sizeof(buffer),0,&addr,&addr_len);
printf("receive: %s",buffer);
}
}

执行 (先执行udp server 再执行udp client)
hello /*从键盘输入字符串*/
receive: hello /*server端返回来的字符串*/

recvmsg（经socket接收数据）
相关函数 recv，recvfrom，send，sendto，sendmsg，socket

表头文件 #include<sys/types.h>
#include<sys/socktet.h>

定义函数 int recvmsg(int s,struct msghdr *msg,unsigned int flags);

函数说明 recvmsg()用来接收远程主机经指定的socket传来的数据。参数s为已建立好连线的socket，如果利用UDP协议则不需经过连线操作。参数msg指向欲连线的数据结构内容，参数flags一般设0，详细描述请参考send()。关于结构msghdr的定义请参考sendmsg()。

返回值成功则返回接收到的字符数，失败则返回-1，错误原因存于errno中。

错误代码 EBADF 参数s非合法的socket处理代码。
EFAULT 参数中有一指针指向无法存取的内存空间
ENOTSOCK 参数s为一文件描述词，非socket。
EINTR 被信号所中断。
EAGAIN 此操作会令进程阻断，但参数s的socket为不可阻断。
ENOBUFS 系统的缓冲内存不足
ENOMEM 核心内存不足
EINVAL 传给系统调用的参数不正确。

范例参考recvfrom()。

send（经socket传送数据）
相关函数 sendto，sendmsg，recv，recvfrom，socket

表头文件 #include<sys/types.h>
#include<sys/socket.h>

定义函数 int send(int s,const void * msg,int len,unsigned int falgs);

函数说明 send()用来将数据由指定的socket 传给对方主机。参数s为已建立好连接的socket。参数msg指向欲连线的数据内容，参数len则为数据长度。参数flags一般设0，其他数值定义如下
MSG_OOB 传送的数据以out-of-band 送出。
MSG_DONTROUTE 取消路由表查询
MSG_DONTWAIT 设置为不可阻断运作
MSG_NOSIGNAL 此动作不愿被SIGPIPE 信号中断。

返回值成功则返回实际传送出去的字符数，失败返回-1。错误原因存于errno

错误代码 EBADF 参数s 非合法的socket处理代码。
EFAULT 参数中有一指针指向无法存取的内存空间
ENOTSOCK 参数s为一文件描述词，非socket。
EINTR 被信号所中断。
EAGAIN 此操作会令进程阻断，但参数s的socket为不可阻断。
ENOBUFS 系统的缓冲内存不足
ENOMEM 核心内存不足
EINVAL 传给系统调用的参数不正确。

范例参考connect()

sendmsg（经socket传送数据）
相关函数 send，sendto，recv，recvfrom，recvmsg，socket

表头文件 #include<sys/types.h>
#include<sys/socket.h>

定义函数 int sendmsg(int s,const strcut msghdr *msg,unsigned int flags);

函数说明 sendmsg()用来将数据由指定的socket传给对方主机。参数s为已建立好连线的socket，如果利用UDP协议则不需经过连线操作。参数msg 指向欲连线的数据结构内容，参数flags一般默认为0，详细描述请参考send()。
结构msghdr定义如下
struct msghdr
{
void *msg_name; /*Address to send to /receive from . */
socklen_t msg_namelen; /* Length of addres data */
strcut iovec * msg_iov; /* Vector of data to send/receive into */
size_t msg_iovlen; /* Number of elements in the vector */
void * msg_control; /* Ancillary dat */
size_t msg_controllen; /* Ancillary data buffer length */
int msg_flags; /* Flags on received message */
};

返回值成功则返回实际传送出去的字符数，失败返回-1，错误原因存于errno

错误代码 EBADF 参数s 非合法的socket处理代码。
EFAULT 参数中有一指针指向无法存取的内存空间
ENOTSOCK 参数s为一文件描述词，非socket。
EINTR 被信号所中断。
EAGAIN 此操作会令进程阻断，但参数s的socket为不可阻断。
ENOBUFS 系统的缓冲内存不足
ENOMEM 核心内存不足
EINVAL 传给系统调用的参数不正确。

范例参考sendto()。

sendto（经socket传送数据）
相关函数 send , sendmsg,recv , recvfrom , socket

表头文件 #include < sys/types.h >
#include < sys/socket.h >

定义函数 int sendto ( int s , const void * msg, int len, unsigned int flags, const
struct sockaddr * to , int tolen ) ;

函数说明 sendto() 用来将数据由指定的socket传给对方主机。参数s为已建好连线的socket,如果利用UDP协议则不需经过连线操作。参数msg指向欲连线的数据内容，参数flags 一般设0，详细描述请参考send()。参数to用来指定欲传送的网络地址，结构sockaddr请参考bind()。参数tolen为sockaddr的结果长度。

返回值成功则返回实际传送出去的字符数，失败返回－1，错误原因存于errno 中。

错误代码 EBADF 参数s非法的socket处理代码。
EFAULT 参数中有一指针指向无法存取的内存空间。
WNOTSOCK canshu s为一文件描述词，非socket。
EINTR 被信号所中断。
EAGAIN 此动作会令进程阻断，但参数s的soket为补课阻断的。
ENOBUFS 系统的缓冲内存不足。
EINVAL 传给系统调用的参数不正确。

范例 #include < sys/types.h >
#include < sys/socket.h >
# include <netinet.in.h>
#include <arpa.inet.h>
#define PORT 2345 /*使用的port*/
main(){
int sockfd,len;
struct sockaddr_in addr;
char buffer[256];
/*建立socket*/
if(sockfd=socket (AF_INET,SOCK_DGRAM,0))<0){
perror ("socket");
exit(1);
}
/*填写sockaddr_in 结构*/
bzero ( &addr, sizeof(addr) );
addr.sin_family=AF_INET;
addr.sin_port=htons(PORT);
addr.sin_addr=hton1(INADDR_ANY) ;
if (bind(sockfd, &addr, sizeof(addr))<0){
perror("connect");
exit(1);
}
while(1){
bezro(buffer,sizeof(buffer));
len = recvfrom(socket,buffer,sizeof(buffer), 0 , &addr &addr_len);
/*显示client端的网络地址*/
printf("receive from %s/n " , inet_ntoa( addr.sin_addr));
/*将字串返回给client端*/
sendto(sockfd,buffer,len,0,&addr,addr_len);"
}
}

执行请参考recvfrom()

setprotoent（打开网络协议的数据文件）
相关函数 getprotobyname, getprotobynumber, endprotoent

表头文件 #include <netdb.h>

定义函数 void setprotoent (int stayopen);

函数说明 setprotoent()用来打开/etc/protocols，如果参数stayopen值为1，则接下来的getprotobyname()或getprotobynumber()将不会自动关闭此文件。

setservent（打开主机网络服务的数据文件）
相关函数 getservent, getservbyname, getservbyport, endservent

表头文件 #include < netdb.h >

定义函数 void setservent (int stayopen);

函数说明 setservent()用来打开/etc/services，如果参数stayopen值为1，则接下来的getservbyname()或getservbyport()将补回自动关闭文件。

setsockopt（设置socket状态）
相关函数 getsockopt

表头文件 #include<sys/types.h>
#include<sys/socket.h>

定义函数 int setsockopt(int s,int level,int optname,const void * optval,,socklen_toptlen);

函数说明 setsockopt()用来设置参数s所指定的socket状态。参数level代表欲设置的网络层，一般设成SOL_SOCKET以存取socket层。参数optname代表欲设置的选项，有下列几种数值:
SO_DEBUG 打开或关闭排错模式
SO_REUSEADDR 允许在bind（）过程中本地地址可重复使用
SO_TYPE 返回socket形态。
SO_ERROR 返回socket已发生的错误原因
SO_DONTROUTE 送出的数据包不要利用路由设备来传输。
SO_BROADCAST 使用广播方式传送
SO_SNDBUF 设置送出的暂存区大小
SO_RCVBUF 设置接收的暂存区大小
SO_KEEPALIVE 定期确定连线是否已终止。
SO_OOBINLINE 当接收到OOB 数据时会马上送至标准输入设备
SO_LINGER 确保数据安全且可靠的传送出去。

参数 optval代表欲设置的值，参数optlen则为optval的长度。

返回值成功则返回0，若有错误则返回-1，错误原因存于errno。

附加说明 EBADF 参数s并非合法的socket处理代码
ENOTSOCK 参数s为一文件描述词，非socket
ENOPROTOOPT 参数optname指定的选项不正确。
EFAULT 参数optval指针指向无法存取的内存空间。

范例参考getsockopt()。

shutdown（终止socket通信）
相关函数 socket，connect

表头文件 #include<sys/socket.h>

定义函数 int shutdown(int s,int how);

函数说明 shutdown()用来终止参数s所指定的socket连线。参数s是连线中的socket处理代码，参数how有下列几种情况:
how=0 终止读取操作。
how=1 终止传送操作
how=2 终止读取及传送操作

返回值成功则返回0，失败返回-1，错误原因存于errno。

错误代码 EBADF 参数s不是有效的socket处理代码
ENOTSOCK 参数s为一文件描述词，非socket
ENOTCONN 参数s指定的socket并未连线

socket（建立一个socket通信）
相关函数 accept，bind，connect，listen

表头文件 #include<sys/types.h>
#include<sys/socket.h>

定义函数 int socket(int domain,int type,int protocol);

函数说明 socket()用来建立一个新的socket，也就是向系统注册，通知系统建立一通信端口。参数domain 指定使用何种的地址类型，完整的定义在/usr/include/bits/socket.h 内，底下是常见的协议:
PF_UNIX/PF_LOCAL/AF_UNIX/AF_LOCAL UNIX 进程通信协议
PF_INETAF_INET Ipv4网络协议
PF_INET6/AF_INET6 Ipv6 网络协议
PF_IPX/AF_IPX IPX-Novell协议
PF_NETLINK/AF_NETLINK 核心用户接口装置
PF_X25/AF_X25 ITU-T X.25/ISO-8208 协议
PF_AX25/AF_AX25 业余无线AX.25协议
PF_ATMPVC/AF_ATMPVC 存取原始ATM PVCs
PF_APPLETALK/AF_APPLETALK appletalk（DDP）协议
PF_PACKET/AF_PACKET 初级封包接口

参数 type有下列几种数值:
SOCK_STREAM 提供双向连续且可信赖的数据流，即TCP。支持
OOB 机制，在所有数据传送前必须使用connect()来建立连线状态。
SOCK_DGRAM 使用不连续不可信赖的数据包连接
SOCK_SEQPACKET 提供连续可信赖的数据包连接
SOCK_RAW 提供原始网络协议存取
SOCK_RDM 提供可信赖的数据包连接
SOCK_PACKET 提供和网络驱动程序直接通信。
protocol用来指定socket所使用的传输协议编号，通常此参考不用管它，设为0即可。

返回值成功则返回socket处理代码，失败返回-1。

错误代码 EPROTONOSUPPORT 参数domain指定的类型不支持参数type或protocol指定的协议
ENFILE 核心内存不足，无法建立新的socket结构
EMFILE 进程文件表溢出，无法再建立新的socket
EACCESS 权限不足，无法建立type或protocol指定的协议
ENOBUFS/ENOMEM 内存不足
EINVAL 参数domain/type/protocol不合法

范例参考connect()。

添加评论
3:44 | 固定链接 | 引用通告 (0) | 记录它

固定链接关闭

http://net.pku.edu.cn/~yhf/linux_c/function/13.html

alarm（设置信号传送闹钟）
相关函数 signal，sleep

表头文件 #include<unistd.h>

定义函数 unsigned int alarm(unsigned int seconds);

函数说明 alarm()用来设置信号SIGALRM在经过参数seconds指定的秒数后传送给目前的进程。如果参数seconds 为0，则之前设置的闹钟会被取消，并将剩下的时间返回。

返回值返回之前闹钟的剩余秒数，如果之前未设闹钟则返回0。

范例 #include<unistd.h>
#include<signal.h>
void handler() {
printf("hello/n");
}
main()
{
int i;
signal(SIGALRM,handler);
alarm(5);
for(i=1;i<7;i++){
printf("sleep %d .../n",i);
sleep(1);
}
}

执行 sleep 1 ...
sleep 2 ...
sleep 3 ...
sleep 4 ...
sleep 5 ...
hello
sleep 6 ...

kill（传送信号给指定的进程）
相关函数 raise，signal

表头文件 #include<sys/types.h>
#include<signal.h>

定义函数 int kill(pid_t pid,int sig);

函数说明 kill()可以用来送参数sig指定的信号给参数pid指定的进程。参数pid有几种情况:
pid>0 将信号传给进程识别码为pid 的进程。
pid=0 将信号传给和目前进程相同进程组的所有进程
pid=-1 将信号广播传送给系统内所有的进程
pid<0 将信号传给进程组识别码为pid绝对值的所有进程
参数sig代表的信号编号可参考附录D

返回值执行成功则返回0，如果有错误则返回-1。

错误代码 EINVAL 参数sig 不合法
ESRCH 参数pid 所指定的进程或进程组不存在
EPERM 权限不够无法传送信号给指定进程

范例 #include<unistd.h>
#include<signal.h>
#include<sys/types.h>
#include<sys/wait.h>
main()
{
pid_t pid;
int status;
if(!(pid= fork())){
printf("Hi I am child process!/n");
sleep(10);
return;
}
else{
printf("send signal to child process (%d) /n",pid);
sleep(1);
kill(pid ,SIGABRT);
wait(&status);
if(WIFSIGNALED(status))
printf("chile process receive signal %d/n",WTERMSIG(status));
}
}

执行 sen signal to child process(3170)
Hi I am child process!
child process receive signal 6

pause（让进程暂停直到信号出现）
相关函数 kill，signal，sleep

表头文件 #include<unistd.h>

定义函数 int pause(void);

函数说明 pause()会令目前的进程暂停（进入睡眠状态），直到被信号(signal)所中断。

返回值只返回-1。

错误代码 EINTR 有信号到达中断了此函数。

sigaction（查询或设置信号处理方式）
相关函数 signal，sigprocmask，sigpending，sigsuspend

表头文件 #include<signal.h>

定义函数 int sigaction(int signum,const struct sigaction *act ,struct sigaction *oldact);

函数说明 sigaction()会依参数signum指定的信号编号来设置该信号的处理函数。参数signum可以指定SIGKILL和SIGSTOP以外的所有信号。
如参数结构sigaction定义如下
struct sigaction
{
void (*sa_handler) (int);
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer) (void);
}
sa_handler此参数和signal()的参数handler相同，代表新的信号处理函数，其他意义请参考signal()。
sa_mask 用来设置在处理该信号时暂时将sa_mask 指定的信号搁置。
sa_restorer 此参数没有使用。
sa_flags 用来设置信号处理的其他相关操作，下列的数值可用。
OR 运算（|）组合
A_NOCLDSTOP : 如果参数signum为SIGCHLD，则当子进程暂停时并不会通知父进程
SA_ONESHOT/SA_RESETHAND:当调用新的信号处理函数前，将此信号处理方式改为系统预设的方式。
SA_RESTART:被信号中断的系统调用会自行重启
SA_NOMASK/SA_NODEFER:在处理此信号未结束前不理会此信号的再次到来。
如果参数oldact不是NULL指针，则原来的信号处理方式会由此结构sigaction 返回。

返回值执行成功则返回0，如果有错误则返回-1。

错误代码 EINVAL 参数signum 不合法，或是企图拦截SIGKILL/SIGSTOPSIGKILL信号
EFAULT 参数act，oldact指针地址无法存取。
EINTR 此调用被中断

范例 #include<unistd.h>
#include<signal.h>
void show_handler(struct sigaction * act)
{
switch (act->sa_flags)
{
case SIG_DFL:printf("Default action/n");break;
case SIG_IGN:printf("Ignore the signal/n");break;
default: printf("0x%x/n",act->sa_handler);
}
}
main()
{
int i;
struct sigaction act,oldact;
act.sa_handler = show_handler;
act.sa_flags = SA_ONESHOT|SA_NOMASK;
sigaction(SIGUSR1,&act,&oldact);
for(i=5;i<15;i++)
{
printf("sa_handler of signal %2d =".i);
sigaction(i,NULL,&oldact);
}
}

执行 sa_handler of signal 5 = Default action
sa_handler of signal 6= Default action
sa_handler of signal 7 = Default action
sa_handler of signal 8 = Default action
sa_handler of signal 9 = Default action
sa_handler of signal 10 = 0x8048400
sa_handler of signal 11 = Default action
sa_handler of signal 12 = Default action
sa_handler of signal 13 = Default action
sa_handler of signal 14 = Default action

sigaddset（增加一个信号至信号集）
相关函数 sigemptyset，sigfillset，sigdelset，sigismember

表头文件 #include<signal.h>

定义函数 int sigaddset(sigset_t *set,int signum);

函数说明 sigaddset()用来将参数signum 代表的信号加入至参数set 信号集里。

返回值执行成功则返回0，如果有错误则返回-1。

错误代码 EFAULT 参数set指针地址无法存取
EINVAL 参数signum非合法的信号编号

sigdelset（从信号集里删除一个信号）
相关函数 sigemptyset，sigfillset，sigaddset，sigismember

表头文件 #include<signal.h>

定义函数 int sigdelset(sigset_t * set,int signum);

函数说明 sigdelset()用来将参数signum代表的信号从参数set信号集里删除。

返回值执行成功则返回0，如果有错误则返回-1。

错误代码 EFAULT 参数set指针地址无法存取
EINVAL 参数signum非合法的信号编号

sigemptyset（初始化信号集）
相关函数 sigaddset，sigfillset，sigdelset，sigismember

表头文件 #include<signal.h>

定义函数 int sigemptyset(sigset_t *set);

函数说明 sigemptyset()用来将参数set信号集初始化并清空。

返回值执行成功则返回0，如果有错误则返回-1。

错误代码 EFAULT 参数set指针地址无法存取

sigfillset（将所有信号加入至信号集）
相关函数 sigempty，sigaddset，sigdelset，sigismember

表头文件 #include<signal.h>

定义函数 int sigfillset(sigset_t * set);

函数说明 sigfillset()用来将参数set信号集初始化，然后把所有的信号加入到此信号集里。

返回值执行成功则返回0，如果有错误则返回-1。

附加说明 EFAULT 参数set指针地址无法存取

sigismember（测试某个信号是否已加入至信号集里）
相关函数 sigemptyset，sigfillset，sigaddset，sigdelset

表头文件 #include<signal.h>

定义函数 int sigismember(const sigset_t *set,int signum);

函数说明 sigismember()用来测试参数signum 代表的信号是否已加入至参数set信号集里。如果信号集里已有该信号则返回1，否则返回0。

返回值信号集已有该信号则返回1，没有则返回0。如果有错误则返回-1。

错误代码 EFAULT 参数set指针地址无法存取
EINVAL 参数signum 非合法的信号编号

signal（设置信号处理方式）
相关函数 sigaction，kill，raise

表头文件 #include<signal.h>

定义函数 void (*signal(int signum,void(* handler)(int)))(int);

函数说明 signal()会依参数signum 指定的信号编号来设置该信号的处理函数。当指定的信号到达时就会跳转到参数handler指定的函数执行。如果参数handler不是函数指针，则必须是下列两个常数之一:
SIG_IGN 忽略参数signum指定的信号。
SIG_DFL 将参数signum 指定的信号重设为核心预设的信号处理方式。
关于信号的编号和说明，请参考附录D

返回值返回先前的信号处理函数指针，如果有错误则返回SIG_ERR(-1)。

附加说明在信号发生跳转到自定的handler处理函数执行后，系统会自动将此处理函数换回原来系统预设的处理方式，如果要改变此操作请改用sigaction()。

范例参考alarm()或raise()。

sigpending（查询被搁置的信号）
相关函数 signal，sigaction，sigprocmask，sigsuspend

表头文件 #include<signal.h>

定义函数 int sigpending(sigset_t *set);

函数说明 sigpending()会将被搁置的信号集合由参数set指针返回。

返回值执行成功则返回0，如果有错误则返回-1。

错误代码 EFAULT 参数set指针地址无法存取
EINTR 此调用被中断。

sigprocmask（查询或设置信号遮罩）
相关函数 signal，sigaction，sigpending，sigsuspend

表头文件 #include<signal.h>

定义函数 int sigprocmask(int how,const sigset_t *set,sigset_t * oldset);

函数说明 sigprocmask()可以用来改变目前的信号遮罩，其操作依参数how来决定
SIG_BLOCK 新的信号遮罩由目前的信号遮罩和参数set 指定的信号遮罩作联集
SIG_UNBLOCK 将目前的信号遮罩删除掉参数set指定的信号遮罩
SIG_SETMASK 将目前的信号遮罩设成参数set指定的信号遮罩。
如果参数oldset不是NULL指针，那么目前的信号遮罩会由此指针返回。

返回值执行成功则返回0，如果有错误则返回-1。

错误代码 EFAULT 参数set，oldset指针地址无法存取。
EINTR 此调用被中断

sleep（让进程暂停执行一段时间）
相关函数 signal，alarm

表头文件 #include<unistd.h>

定义函数 unsigned int sleep(unsigned int seconds);

函数说明 sleep()会令目前的进程暂停，直到达到参数seconds 所指定的时间，或是被信号所中断。

返回值若进程暂停到参数seconds 所指定的时间则返回0，若有信号中断则返回剩余秒数。

ferror（检查文件流是否有错误发生）
相关函数 clearerr，perror

表头文件 #include<stdio.h>

定义函数 int ferror(FILE *stream);

函数说明 ferror()用来检查参数stream所指定的文件流是否发生了错误情况，如有错误发生则返回非0值。

返回值如果文件流有错误发生则返回非0值。

perror（打印出错误原因信息字符串）
相关函数 strerror

表头文件 #include<stdio.h>

定义函数 void perror(const char *s);

函数说明 perror()用来将上一个函数发生错误的原因输出到标准错误(stderr)。参数s所指的字符串会先打印出，后面再加上错误原因字符串。此错误原因依照全局变量errno的值来决定要输出的字符串。

返回值

范例 #include<stdio.h>
main()
{
FILE *fp;
fp = fopen("/tmp/noexist","r+");
if(fp = =NULL) perror("fopen");
}

执行 $ ./perror
fopen : No such file or diretory

strerror（返回错误原因的描述字符串）
相关函数 perror

表头文件 #include<string.h>

定义函数 char * strerror(int errnum);

函数说明 strerror()用来依参数errnum的错误代码来查询其错误原因的描述字符串，然后将该字符串指针返回。

返回值返回描述错误原因的字符串指针。

范例 /* 显示错误代码0 至9 的错误原因描述*/
#include<string.h>
main()
{
int i;
for(i=0;i<10;i++)
printf("%d : %s/n",i,strerror(i));
}

执行 0 : Success
1 : Operation not permitted
2 : No such file or directory
3 : No such process
4 : Interrupted system call
5 : Input/output error
6 : Device not configured
7 : Argument list too long
8 : Exec format error
9 : Bad file descriptor

mkfifo（建立具名管道）
相关函数 pipe，popen，open，umask

表头文件 #include<sys/types.h>
#include<sys/stat.h>

定义函数 int mkfifo(const char * pathname,mode_t mode);

函数说明 mkfifo()会依参数pathname建立特殊的FIFO文件，该文件必须不存在，而参数mode为该文件的权限（mode%~umask），因此umask值也会影响到FIFO文件的权限。Mkfifo()建立的FIFO文件其他进程都可以用读写一般文件的方式存取。当使用open()来打开FIFO文件时，O_NONBLOCK旗标会有影响
1、当使用O_NONBLOCK 旗标时，打开FIFO 文件来读取的操作会立刻返回，但是若还没有其他进程打开FIFO 文件来读取，则写入的操作会返回ENXIO 错误代码。
2、没有使用O_NONBLOCK 旗标时，打开FIFO 来读取的操作会等到其他进程打开FIFO文件来写入才正常返回。同样地，打开FIFO文件来写入的操作会等到其他进程打开FIFO 文件来读取后才正常返回。

返回值若成功则返回0，否则返回-1，错误原因存于errno中。

错误代码 EACCESS 参数pathname所指定的目录路径无可执行的权限
EEXIST 参数pathname所指定的文件已存在。
ENAMETOOLONG 参数pathname的路径名称太长。
ENOENT 参数pathname包含的目录不存在
ENOSPC 文件系统的剩余空间不足
ENOTDIR 参数pathname路径中的目录存在但却非真正的目录。
EROFS 参数pathname指定的文件存在于只读文件系统内。

范例 #include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
main()
{
char buffer[80];
int fd;
unlink(FIFO);
mkfifo(FIFO,0666);
if(fork()>0){
char s[ ] = "hello!/n";
fd = open (FIFO,O_WRONLY);
write(fd,s,sizeof(s));
close(fd);
}
else{
fd= open(FIFO,O_RDONLY);
read(fd,buffer,80);
printf("%s",buffer);
close(fd);
}
}

执行 hello!

pclose（关闭管道I/O）
相关函数 popen

表头文件 #include<stdio.h>

定义函数 int pclose(FILE * stream);

函数说明 pclose()用来关闭由popen所建立的管道及文件指针。参数stream为先前由popen()所返回的文件指针。

返回值返回子进程的结束状态。如果有错误则返回-1，错误原因存于errno中。

错误代码 ECHILD pclose()无法取得子进程的结束状态。

范例参考popen()。

pipe（建立管道）
相关函数 mkfifo，popen，read，write，fork

表头文件 #include<unistd.h>

定义函数 int pipe(int filedes[2]);

函数说明 pipe()会建立管道，并将文件描述词由参数filedes数组返回。filedes[0]为管道里的读取端，filedes[1]则为管道的写入端。

返回值若成功则返回零，否则返回-1，错误原因存于errno中。

错误代码 EMFILE 进程已用完文件描述词最大量。
ENFILE 系统已无文件描述词可用。
EFAULT 参数filedes数组地址不合法。

范例 /* 父进程借管道将字符串"hello!/n"传给子进程并显示*/
#include <unistd.h>
main()
{
int filedes[2];
char buffer[80];
pipe(filedes);
if(fork()>0){
/* 父进程*/
char s[ ] = "hello!/n";
write(filedes[1],s,sizeof(s));
}
else{
/*子进程*/
read(filedes[0],buffer,80);
printf("%s",buffer);
}
}

执行 hello!

popen（建立管道I/O）
相关函数 pipe，mkfifo，pclose，fork，system，fopen

表头文件 #include<stdio.h>

定义函数 FILE * popen( const char * command,const char * type);

函数说明 popen()会调用fork()产生子进程，然后从子进程中调用/bin/sh -c来执行参数command的指令。参数type可使用"r"代表读取，"w"代表写入。依照此type值，popen()会建立管道连到子进程的标准输出设备或标准输入设备，然后返回一个文件指针。随后进程便可利用此文件指针来读取子进程的输出设备或是写入到子进程的标准输入设备中。此外，所有使用文件指针(FILE*)操作的函数也都可以使用，除了fclose()以外。

返回值若成功则返回文件指针，否则返回NULL，错误原因存于errno中。

错误代码 EINVAL参数type不合法。

注意事项在编写具SUID/SGID权限的程序时请尽量避免使用popen()，popen()会继承环境变量，通过环境变量可能会造成系统安全的问题。

范例 #include<stdio.h>
main()
{
FILE * fp;
char buffer[80];
fp=popen("cat /etc/passwd","r");
fgets(buffer,sizeof(buffer),fp);
printf("%s",buffer);
pclose(fp);
}

执行 root :x:0 0: root: /root: /bin/bash

添加评论
3:42 | 固定链接 | 引用通告 (0) | 记录它

固定链接关闭

http://net.pku.edu.cn/~yhf/linux_c/function/12.html

access（判断是否具有存取文件的权限）
相关函数 stat，open，chmod，chown，setuid，setgid

表头文件 #include<unistd.h>

定义函数 int access(const char * pathname,int mode);

函数说明 access()会检查是否可以读/写某一已存在的文件。参数mode有几种情况组合，R_OK，W_OK，X_OK 和F_OK。R_OK，W_OK与X_OK用来检查文件是否具有读取、写入和执行的权限。F_OK则是用来判断该文件是否存在。由于access()只作权限的核查，并不理会文件形态或文件内容，因此，如果一目录表示为"可写入"，表示可以在该目录中建立新文件等操作，而非意味此目录可以被当做文件处理。例如，你会发现DOS的文件都具有"可执行"权限，但用execve()执行时则会失败。

返回值若所有欲查核的权限都通过了检查则返回0值，表示成功，只要有一权限被禁止则返回-1。

错误代码 EACCESS 参数pathname 所指定的文件不符合所要求测试的权限。
EROFS 欲测试写入权限的文件存在于只读文件系统内。
EFAULT 参数pathname指针超出可存取内存空间。
EINVAL 参数mode 不正确。
ENAMETOOLONG 参数pathname太长。
ENOTDIR 参数pathname为一目录。
ENOMEM 核心内存不足
ELOOP 参数pathname有过多符号连接问题。
EIO I/O 存取错误。

附加说明使用access()作用户认证方面的判断要特别小心，例如在access()后再做open()的空文件可能会造成系统安全上的问题。

范例 /* 判断是否允许读取/etc/passwd */
#include< unistd.h>
int main()
{
if (access("/etc/passwd",R_OK) = =0)
printf("/etc/passwd can be read/n");
}

执行 /etc/passwd can be read

alphasort（依字母顺序排序目录结构）
相关函数 scandir，qsort

表头文件 #include<dirent.h>

定义函数 int alphasort(const struct dirent **a,const struct dirent **b);

函数说明 alphasort()为scandir()最后调用qsort()函数时传给qsort()作为判断的函数，详细说明请参考scandir()及qsort()。

返回值参考qsort()。

范例 /* 读取/目录下所有的目录结构，并依字母顺序排列*/
main()
{
struct dirent **namelist;
int i,total;
total = scandir("/",&namelist ,0,alphasort);
if(total <0)
perror("scandir");
else{
for(i=0;i<total;i++)
printf("%s/n",namelist[i]->d_name);
printf("total = %d/n",total);
}
}

执行 ..
.gnome
.gnome_private
ErrorLog
Weblog
bin
boot
dev
dosc
dosd
etc
home
lib
lost+found
misc
mnt
opt
proc
root
sbin
tmp
usr
var
total = 24

chdir（改变当前的工作（目录）
相关函数 getcwd，chroot

表头文件 #include<unistd.h>

定义函数 int chdir(const char * path);

函数说明 chdir()用来将当前的工作目录改变成以参数path所指的目录。

返回值执行成功则返回0，失败返回-1，errno为错误代码。

范例 #include<unistd.h>
main()
{
chdir("/tmp");
printf("current working directory: %s/n",getcwd(NULL,NULL));
}

执行 current working directory :/tmp

chmod（改变文件的权限）
相关函数 fchmod，stat，open，chown

表头文件 #include<sys/types.h>
#include<sys/stat.h>

定义函数 int chmod(const char * path,mode_t mode);

函数说明 chmod()会依参数mode 权限来更改参数path 指定文件的权限。

参数 mode 有下列数种组合
S_ISUID 04000 文件的（set user-id on execution）位
S_ISGID 02000 文件的（set group-id on execution）位
S_ISVTX 01000 文件的sticky位
S_IRUSR（S_IREAD） 00400 文件所有者具可读取权限
S_IWUSR（S_IWRITE）00200 文件所有者具可写入权限
S_IXUSR（S_IEXEC） 00100 文件所有者具可执行权限
S_IRGRP 00040 用户组具可读取权限
S_IWGRP 00020 用户组具可写入权限
S_IXGRP 00010 用户组具可执行权限
S_IROTH 00004 其他用户具可读取权限
S_IWOTH 00002 其他用户具可写入权限
S_IXOTH 00001 其他用户具可执行权限
只有该文件的所有者或有效用户识别码为0，才可以修改该文件权限。基于系统安全，如果欲将数据写入一执行文件，而该执行文件具有S_ISUID 或S_ISGID 权限，则这两个位会被清除。如果一目录具有S_ISUID 位权限，表示在此目录下只有该文件的所有者或root可以删除该文件。

返回值权限改变成功返回0，失败返回-1，错误原因存于errno。

错误代码 EPERM 进程的有效用户识别码与欲修改权限的文件拥有者不同，而且也不具root权限。
EACCESS 参数path所指定的文件无法存取。
EROFS 欲写入权限的文件存在于只读文件系统内。
EFAULT 参数path指针超出可存取内存空间。
EINVAL 参数mode不正确
ENAMETOOLONG 参数path太长
ENOENT 指定的文件不存在
ENOTDIR 参数path路径并非一目录
ENOMEM 核心内存不足
ELOOP 参数path有过多符号连接问题。
EIO I/O 存取错误

范例 /* 将/etc/passwd 文件权限设成S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH */
#include<sys/types.h>
#include<sys/stat.h>
main()
{
chmod("/etc/passwd",S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
}

chown（改变文件的所有者）
相关函数 fchown，lchown，chmod

表头文件 #include<sys/types.h>
#include<unistd.h>

定义函数 int chown(const char * path, uid_t owner,gid_t group);

函数说明 chown()会将参数path指定文件的所有者变更为参数owner代表的用户，而将该文件的组变更为参数group组。如果参数owner或group为-1，对应的所有者或组不会有所改变。root与文件所有者皆可改变文件组，但所有者必须是参数group组的成员。当root用chown()改变文件所有者或组时，该文件若具有S_ISUID或S_ISGID权限，则会清除此权限位，此外如果具有S_ISGID权限但不具S_IXGRP位，则该文件会被强制锁定，文件模式会保留。

返回值成功则返回0，失败返回-1，错误原因存于errno。

错误代码参考chmod（）。

范例 /* 将/etc/passwd 的所有者和组都设为root */
#include<sys/types.h>
#include<unistd.h>
main()
{
chown("/etc/passwd",0,0);
}

chroot（改变根目录）
相关函数 chdir

表头文件 #include<unistd.h>

定义函数 int chroot(const char * path);

函数说明 chroot()用来改变根目录为参数path 所指定的目录。只有超级用户才允许改变根目录，子进程将继承新的根目录。

返回值调用成功则返回0，失败则返-1，错误代码存于errno。

错误代码 EPERM 权限不足，无法改变根目录。
EFAULT 参数path指针超出可存取内存空间。
ENAMETOOLONG 参数path太长。
ENOTDIR 路径中的目录存在但却非真正的目录。
EACCESS 存取目录时被拒绝
ENOMEM 核心内存不足。
ELOOP 参数path有过多符号连接问题。
EIO I/O 存取错误。

范例 /* 将根目录改为/tmp ,并将工作目录切换至/tmp */
#include<unistd.h>
main()
{
chroot("/tmp");
chdir("/");
}

closedir（关闭目录）
相关函数 opendir

表头文件 #include<sys/types.h>
#include<dirent.h>

定义函数 int closedir(DIR *dir);

函数说明 closedir()关闭参数dir所指的目录流。

返回值关闭成功则返回0，失败返回-1，错误原因存于errno 中。

错误代码 EBADF 参数dir为无效的目录流

范例参考readir()。

fchdir（改变当前的工作目录）
相关函数 getcwd，chroot

表头文件 #include<unistd.h>

定义函数 int fchdir(int fd);

函数说明 fchdir()用来将当前的工作目录改变成以参数fd 所指的文件描述词。

返回值执行成功则返回0，失败返回-1，errno为错误代码。

附加说明

范例 #include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
main()
{
int fd;
fd = open("/tmp",O_RDONLY);
fchdir(fd);
printf("current working directory : %s /n",getcwd(NULL,NULL));
close(fd);
}

执行 current working directory : /tmp

fchmod（改变文件的权限）
相关函数 chmod，stat，open，chown

表头文件 #include<sys/types.h>
#include<sys/stat.h>

定义函数 int fchmod(int fildes,mode_t mode);

函数说明 fchmod()会依参数mode权限来更改参数fildes所指文件的权限。参数fildes为已打开文件的文件描述词。参数mode请参考chmod（）。

返回值权限改变成功则返回0，失败返回-1，错误原因存于errno。

错误原因 EBADF 参数fildes为无效的文件描述词。
EPERM 进程的有效用户识别码与欲修改权限的文件所有者不同，而且也不具root权限。
EROFS 欲写入权限的文件存在于只读文件系统内。
EIO I/O 存取错误。

范例 #include<sys/stat.h>
#include< fcntl.h>
main()
{
int fd;
fd = open ("/etc/passwd",O_RDONLY);
fchmod(fd,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
close(fd);
}

fchown（改变文件的所有者）
相关函数 chown，lchown，chmod

表头文件 #include<sys/types.h>
#include<unistd.h>

定义函数 int fchown(int fd,uid_t owner,gid_t group);

函数说明 fchown()会将参数fd指定文件的所有者变更为参数owner代表的用户，而将该文件的组变更为参数group组。如果参数owner或group为-1，对映的所有者或组有所改变。参数fd 为已打开的文件描述词。当root用fchown()改变文件所有者或组时，该文件若具S_ISUID或S_ISGID权限，则会清除此权限位。

返回值成功则返回0，失败则返回-1，错误原因存于errno。

错误代码 EBADF 参数fd文件描述词为无效的或该文件已关闭。
EPERM 进程的有效用户识别码与欲修改权限的文件所有者不同，而且也不具root权限，或是参数owner、group不正确。
EROFS 欲写入的文件存在于只读文件系统内。
ENOENT 指定的文件不存在
EIO I/O存取错误

范例 #include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
main()
{
int fd;
fd = open ("/etc/passwd",O_RDONLY);
chown(fd,0,0);
close(fd);
}

fstat（由文件描述词取得文件状态）
相关函数 stat，lstat，chmod，chown，readlink，utime

表头文件 #include<sys/stat.h>
#include<unistd.h>

定义函数 int fstat(int fildes,struct stat *buf);

函数说明 fstat()用来将参数fildes所指的文件状态，复制到参数buf所指的结构中(struct stat)。Fstat()与stat()作用完全相同，不同处在于传入的参数为已打开的文件描述词。详细内容请参考stat()。

返回值执行成功则返回0，失败返回-1，错误代码存于errno。

范例 #include<sys/stat.h>
#include<unistd.h >
#include<fcntk.h>
main()
{
struct stat buf;
int fd;
fd = open ("/etc/passwd",O_RDONLY);
fstat(fd,&buf);
printf("/etc/passwd file size +%d/n ",buf.st_size);
}

执行 /etc/passwd file size = 705

ftruncate（改变文件大小）
相关函数 open，truncate

表头文件 #include<unistd.h>

定义函数 int ftruncate(int fd,off_t length);

函数说明 ftruncate()会将参数fd指定的文件大小改为参数length指定的大小。参数fd为已打开的文件描述词，而且必须是以写入模式打开的文件。如果原来的文件大小比参数length大，则超过的部分会被删去。

返回值执行成功则返回0，失败返回-1，错误原因存于errno。

错误代码 EBADF 参数fd文件描述词为无效的或该文件已关闭。
EINVAL 参数fd 为一socket 并非文件，或是该文件并非以写入模式打开。

getcwd（取得当前的工作目录）
相关函数 get_current_dir_name，getwd，chdir

表头文件 #include<unistd.h>

定义函数 char * getcwd(char * buf,size_t size);

函数说明 getcwd()会将当前的工作目录绝对路径复制到参数buf所指的内存空间，参数size为buf的空间大小。在调用此函数时，buf所指的内存空间要足够大，若工作目录绝对路径的字符串长度超过参数size大小，则回值NULL，errno的值则为ERANGE。倘若参数buf为NULL，getcwd()会依参数size的大小自动配置内存(使用malloc())，如果参数size也为0，则getcwd()会依工作目录绝对路径的字符串程度来决定所配置的内存大小，进程可以在使用完此字符串后利用free()来释放此空间。

返回值执行成功则将结果复制到参数buf所指的内存空间，或是返回自动配置的字符串指针。失败返回NULL，错误代码存于errno。

范例 #include<unistd.h>
main()
{
char buf[80];
getcwd(buf,sizeof(buf));
printf("current working directory : %s/n",buf);
}

执行 current working directory :/tmp

link（建立文件连接）
相关函数 symlink，unlink

表头文件 #include<unistd.h>

定义函数 int link (const char * oldpath,const char * newpath);

函数说明 link()以参数newpath指定的名称来建立一个新的连接(硬连接)到参数oldpath所指定的已存在文件。如果参数newpath指定的名称为一已存在的文件则不会建立连接。

返回值成功则返回0，失败返回-1，错误原因存于errno。

附加说明 link()所建立的硬连接无法跨越不同文件系统，如果需要请改用symlink()。

错误代码 EXDEV 参数oldpath与newpath不是建立在同一文件系统。
EPERM 参数oldpath与newpath所指的文件系统不支持硬连接
EROFS 文件存在于只读文件系统内
EFAULT 参数oldpath或newpath 指针超出可存取内存空间。
ENAMETOLLONG 参数oldpath或newpath太长
ENOMEM 核心内存不足
EEXIST 参数newpath所指的文件名已存在。
EMLINK 参数oldpath所指的文件已达最大连接数目。
ELOOP 参数pathname有过多符号连接问题
ENOSPC 文件系统的剩余空间不足。
EIO I/O 存取错误。

范例 /* 建立/etc/passwd 的硬连接为pass */
#include<unistd.h>
main()
{
link("/etc/passwd","pass");
}

lstat（由文件描述词取得文件状态）
相关函数 stat，fstat，chmod，chown，readlink，utime

表头文件 #include<sys/stat.h>
#include<unistd.h>

定义函数 int lstat (const char * file_name.struct stat * buf);

函数说明 lstat()与stat()作用完全相同，都是取得参数file_name所指的文件状态，其差别在于，当文件为符号连接时，lstat()会返回该link本身的状态。详细内容请参考stat()。

返回值执行成功则返回0，失败返回-1，错误代码存于errno。

范例参考stat()。

opendir（打开目录）
相关函数 open，readdir，closedir，rewinddir，seekdir，telldir，scandir

表头文件 #include<sys/types.h>
#include<dirent.h>

定义函数 DIR * opendir(const char * name);

函数说明 opendir()用来打开参数name指定的目录，并返回DIR*形态的目录流，和open()类似，接下来对目录的读取和搜索都要使用此返回值。

返回值成功则返回DIR* 型态的目录流，打开失败则返回NULL。

错误代码 EACCESS 权限不足
EMFILE 已达到进程可同时打开的文件数上限。
ENFILE 已达到系统可同时打开的文件数上限。
ENOTDIR 参数name非真正的目录
ENOENT 参数name 指定的目录不存在，或是参数name 为一空字符串。
ENOMEM 核心内存不足。

readdir（读取目录）
相关函数 open，opendir，closedir，rewinddir，seekdir，telldir，scandir

表头文件 #include<sys/types.h>
#include<dirent.h>

定义函数 struct dirent * readdir(DIR * dir);

函数说明 readdir()返回参数dir目录流的下个目录进入点。
结构dirent定义如下
struct dirent
{
ino_t d_ino;
ff_t d_off;
signed short int d_reclen;
unsigned char d_type;
har d_name[256;
};
d_ino 此目录进入点的inode
d_off 目录文件开头至此目录进入点的位移
d_reclen _name的长度，不包含NULL字符
d_type d_name 所指的文件类型
d_name 文件名

返回值成功则返回下个目录进入点。有错误发生或读取到目录文件尾则返回NULL。

附加说明 EBADF参数dir为无效的目录流。

范例 #include<sys/types.h>
#include<dirent.h>
#include<unistd.h>
main()
{
DIR * dir;
struct dirent * ptr;
int i;
dir =opendir("/etc/rc.d");
while((ptr = readdir(dir))!=NULL)
{
printf("d_name: %s/n",ptr->d_name);
}
closedir(dir);
}

执行 d_name:.
d_name:..
d_name:init.d
d_name:rc0.d
d_name:rc1.d
d_name:rc2.d
d_name:rc3.d
d_name:rc4.d
d_name:rc5.d
d_name:rc6.d
d_name:rc
d_name:rc.local
d_name:rc.sysinit

readlink（取得符号连接所指的文件）
相关函数 stat，lstat，symlink

表头文件 #include<unistd.h>

定义函数 int readlink(const char * path ,char * buf,size_t bufsiz);

函数说明 readlink()会将参数path的符号连接内容存到参数buf所指的内存空间，返回的内容不是以NULL作字符串结尾，但会将字符串的字符数返回。若参数bufsiz小于符号连接的内容长度，过长的内容会被截断。

返回值执行成功则传符号连接所指的文件路径字符串，失败则返回-1，错误代码存于errno。

错误代码 EACCESS 取文件时被拒绝，权限不够
EINVAL 参数bufsiz 为负数
EIO I/O 存取错误。
ELOOP 欲打开的文件有过多符号连接问题。
ENAMETOOLONG 参数path的路径名称太长
ENOENT 参数path所指定的文件不存在
ENOMEM 核心内存不足
ENOTDIR 参数path路径中的目录存在但却非真正的目录。

remove（删除文件）
相关函数 link，rename，unlink

表头文件 #include<stdio.h>

定义函数 int remove(const char * pathname);

函数说明 remove()会删除参数pathname指定的文件。如果参数pathname为一文件，则调用unlink()处理，若参数pathname为一目录，则调用rmdir()来处理。请参考unlink()与rmdir()。

返回值成功则返回0，失败则返回-1，错误原因存于errno。

错误代码 EROFS 欲写入的文件存在于只读文件系统内
EFAULT 参数pathname指针超出可存取内存空间
ENAMETOOLONG 参数pathname太长
ENOMEM 核心内存不足
ELOOP 参数pathname有过多符号连接问题
EIO I/O 存取错误。

rename（更改文件名称或位置）
相关函数 link，unlink，symlink

表头文件 #include<stdio.h>

定义函数 int rename(const char * oldpath,const char * newpath);

函数说明 rename()会将参数oldpath 所指定的文件名称改为参数newpath所指的文件名称。若newpath所指定的文件已存在，则会被删除。

返回值执行成功则返回0，失败返回-1，错误原因存于errno

范例 /* 设计一个DOS下的rename指令rename 旧文件名新文件名*/
#include <stdio.h>
void main(int argc,char **argv)
{
if(argc<3){
printf("Usage: %s old_name new_name/n",argv[0]);
return;
}
printf("%s=>%s",argc[1],argv[2]);
if(rename(argv[1],argv[2]<0)
printf("error!/n");
else
printf("ok!/n");
}

rewinddir（重设读取目录的位置为开头位置）
相关函数 open，opendir，closedir，telldir，seekdir，readdir，scandir

表头文件 #include<sys/types.h>
#include<dirent.h>

定义函数 void rewinddir(DIR *dir);

函数说明 rewinddir()用来设置参数dir 目录流目前的读取位置为原来开头的读取位置。

返回值

错误代码 EBADF dir为无效的目录流

范例 #include<sys/types.h>
#include<dirent.h>
#include<unistd.h>
main()
{
DIR * dir;
struct dirent *ptr;
dir = opendir("/etc/rc.d");
while((ptr = readdir(dir))!=NULL)
{
printf("d_name :%s/n",ptr->d_name);
}
rewinddir(dir);
printf("readdir again!/n");
while((ptr = readdir(dir))!=NULL)
{
printf("d_name: %s/n",ptr->d_name);
}
closedir(dir);
}

执行 d_name:.
d_name:..
d_name:init.d
d_name:rc0.d
d_name:rc1.d
d_name:rc2.d
d_name:rc3.d
d_name:rc4.d
d_name:rc5.d
d_name:rc6.d
d_name:rc
d_name:rc.local
d_name:rc.sysinit
readdir again!
d_name:.
d_name:..
d_name:init.d
d_name:rc0.d
d_name:rc1.d
d_name: rc2.d
d_name:rc3.d
d_name:rc4.d
d_name:rc5.d
d_name:rc6.d
d_name:rc
d_name:rc.local
d_name:rc.sysinit

seekdir（设置下回读取目录的位置）
相关函数 open，opendir，closedir，rewinddir，telldir，readdir，scandir

表头文件 #include<dirent.h>

定义函数 void seekdir(DIR * dir,off_t offset);

函数说明 seekdir()用来设置参数dir目录流目前的读取位置，在调用readdir()时便从此新位置开始读取。参数offset 代表距离目录文件开头的偏移量。

返回值

错误代码 EBADF 参数dir为无效的目录流

范例 #include<sys/types.h>
#include<dirent.h>
#include<unistd.h>
main()
{
DIR * dir;
struct dirent * ptr;
int offset,offset_5,i=0;
dir=opendir("/etc/rc.d");
while((ptr = readdir(dir))!=NULL)
{
offset = telldir(dir);
if(++i = =5) offset_5 =offset;
printf("d_name :%s offset :%d /n",ptr->d_name,offset);
}
seekdir(dir offset_5);
printf("Readdir again!/n");
while((ptr = readdir(dir))!=NULL)
{
offset = telldir(dir);
printf("d_name :%s offset :%d/n",ptr->d_name.offset);
}
closedir(dir);
}

执行 d_name : . offset :12
d_name : .. offset:24
d_name : init.d offset 40
d_name : rc0.d offset :56
d_name :rc1.d offset :72
d_name:rc2.d offset :88
d_name:rc3.d offset 104
d_name:rc4.d offset:120
d_name:rc5.d offset:136
d_name:rc6.d offset:152
d_name:rc offset 164
d_name:rc.local offset :180
d_name:rc.sysinit offset :4096
readdir again!
d_name:rc2.d offset :88
d_name:rc3.d offset 104
d_name:rc4.d offset:120
d_name: rc5.d offset:136
d_name:rc6.d offset:152
d_name:rc offset 164
d_name:rc.local offset :180
d_name:rc.sysinit offset :4096

stat（取得文件状态）
相关函数 fstat，lstat，chmod，chown，readlink，utime

表头文件 #include<sys/stat.h>
#include<unistd.h>

定义函数 int stat(const char * file_name,struct stat *buf);

函数说明 stat()用来将参数file_name所指的文件状态，复制到参数buf所指的结构中。
下面是struct stat内各参数的说明
struct stat
{
dev_t st_dev; /*device*/
ino_t st_ino; /*inode*/
mode_t st_mode; /*protection*/
nlink_t st_nlink; /*number of hard links */
uid_t st_uid; /*user ID of owner*/
gid_t st_gid; /*group ID of owner*/
dev_t st_rdev; /*device type */
off_t st_size; /*total size, in bytes*/
unsigned long st_blksize; /*blocksize for filesystem I/O */
unsigned long st_blocks; /*number of blocks allocated*/
time_t st_atime; /* time of lastaccess*/
time_t st_mtime; /* time of last modification */
time_t st_ctime; /* time of last change */
};
st_dev 文件的设备编号
st_ino 文件的i-node
st_mode 文件的类型和存取的权限
st_nlink 连到该文件的硬连接数目，刚建立的文件值为1。
st_uid 文件所有者的用户识别码
st_gid 文件所有者的组识别码
st_rdev 若此文件为装置设备文件，则为其设备编号
st_size 文件大小，以字节计算
st_blksize 文件系统的I/O 缓冲区大小。
st_blcoks 占用文件区块的个数，每一区块大小为512 个字节。
st_atime 文件最近一次被存取或被执行的时间，一般只有在用mknod、utime、read、write与tructate时改变。
st_mtime 文件最后一次被修改的时间，一般只有在用mknod、utime和write时才会改变
st_ctime i-node最近一次被更改的时间，此参数会在文件所有者、组、权限被更改时更新先前所描述的st_mode 则定义了下列数种情况
S_IFMT 0170000 文件类型的位遮罩
S_IFSOCK 0140000 scoket
S_IFLNK 0120000 符号连接
S_IFREG 0100000 一般文件
S_IFBLK 0060000 区块装置
S_IFDIR 0040000 目录
S_IFCHR 0020000 字符装置
S_IFIFO 0010000 先进先出
S_ISUID 04000 文件的（set user-id on execution）位
S_ISGID 02000 文件的（set group-id on execution）位
S_ISVTX 01000 文件的sticky位
S_IRUSR（S_IREAD） 00400 文件所有者具可读取权限
S_IWUSR（S_IWRITE）00200 文件所有者具可写入权限
S_IXUSR（S_IEXEC） 00100 文件所有者具可执行权限
S_IRGRP 00040 用户组具可读取权限
S_IWGRP 00020 用户组具可写入权限
S_IXGRP 00010 用户组具可执行权限
S_IROTH 00004 其他用户具可读取权限
S_IWOTH 00002 其他用户具可写入权限
S_IXOTH 00001 其他用户具可执行权限
上述的文件类型在POSIX 中定义了检查这些类型的宏定义
S_ISLNK （st_mode）判断是否为符号连接
S_ISREG （st_mode）是否为一般文件
S_ISDIR （st_mode）是否为目录
S_ISCHR （st_mode）是否为字符装置文件
S_ISBLK （s3e）是否为先进先出
S_ISSOCK （st_mode）是否为socket
若一目录具有sticky 位（S_ISVTX），则表示在此目录下的文件只能被该文件所有者、此目录所有者或root来删除或改名。

返回值执行成功则返回0，失败返回-1，错误代码存于errno

错误代码 ENOENT 参数file_name指定的文件不存在
ENOTDIR 路径中的目录存在但却非真正的目录
ELOOP 欲打开的文件有过多符号连接问题，上限为16符号连接
EFAULT 参数buf为无效指针，指向无法存在的内存空间
EACCESS 存取文件时被拒绝
ENOMEM 核心内存不足
ENAMETOOLONG 参数file_name的路径名称太长

范例 #include<sys/stat.h>
#include< unistd.h>
mian()
{
struct stat buf;
stat ("/etc/passwd",&buf);
printf("/etc/passwd file size = %d /n",buf.st_size);
}

执行 /etc/passwd file size = 705

symlink（建立文件符号连接）
相关函数 link，unlink

表头文件 #include<unistd.h>

定义函数 int symlink( const char * oldpath,const char * newpath);

函数说明 symlink()以参数newpath指定的名称来建立一个新的连接(符号连接)到参数oldpath所指定的已存在文件。参数oldpath指定的文件不一定要存在，如果参数newpath指定的名称为一已存在的文件则不会建立连接。

返回值成功则返回0，失败返回-1，错误原因存于errno。

错误代码 EPERM 参数oldpath与newpath所指的文件系统不支持符号连接
EROFS 欲测试写入权限的文件存在于只读文件系统内
EFAULT 参数oldpath或newpath指针超出可存取内存空间。
ENAMETOOLONG 参数oldpath或newpath太长
ENOMEM 核心内存不足
EEXIST 参数newpath所指的文件名已存在。
EMLINK 参数oldpath所指的文件已达到最大连接数目
ELOOP 参数pathname有过多符号连接问题
ENOSPC 文件系统的剩余空间不足
EIO I/O 存取错误

范例 #include<unistd.h>
main()
{
symlink("/etc/passwd","pass");
}

telldir（取得目录流的读取位置）
相关函数 open，opendir，closedir，rewinddir，seekdir，readdir，scandir

表头文件 #include<dirent.h>

定义函数 off_t telldir(DIR *dir);

函数说明 telldir()返回参数dir目录流目前的读取位置。此返回值代表距离目录文件开头的偏移量返回值返回下个读取位置，有错误发生时返回-1。

错误代码 EBADF参数dir为无效的目录流。

范例 #include<sys/types.h>
#include<dirent.h>
#include<unistd.h>
main()
{
DIR *dir;
struct dirent *ptr;
int offset;
dir = opendir("/etc/rc.d");
while((ptr = readdir(dir))!=NULL)
{
offset = telldir (dir);
printf("d_name : %s offset :%d/n", ptr->d_name,offset);
}
closedir(dir);
}

truncate（改变文件大小）
相关函数 open，ftruncate

表头文件 #include<unistd.h>

定义函数 int truncate(const char * path,off_t length);

函数说明 truncate()会将参数path 指定的文件大小改为参数length 指定的大小。如果原来的文件大小比参数length大，则超过的部分会被删去。

返回值执行成功则返回0，失败返回-1，错误原因存于errno。

错误代码 EACCESS 参数path所指定的文件无法存取。
EROFS 欲写入的文件存在于只读文件系统内
EFAULT 参数path指针超出可存取内存空间
EINVAL 参数path包含不合法字符
ENAMETOOLONG 参数path太长
ENOTDIR 参数path路径并非一目录
EISDIR 参数path 指向一目录
ETXTBUSY 参数path所指的文件为共享程序，而且正被执行中
ELOOP 参数path'有过多符号连接问题
EIO I/O 存取错误。

umask（设置建立新文件时的权限遮罩）
相关函数 creat，open

表头文件 #include<sys/types.h>
#include<sys/stat.h>

定义函数 mode_t umask(mode_t mask);

函数说明 umask()会将系统umask值设成参数mask&0777后的值，然后将先前的umask值返回。在使用open()建立新文件时，该参数mode并非真正建立文件的权限，而是(mode&~umask)的权限值。例如，在建立文件时指定文件权限为0666，通常umask值默认为022，则该文件的真正权限则为0666&～022＝0644，也就是rw-r--r--返回值此调用不会有错误值返回。返回值为原先系统的umask值。

unlink（删除文件）
相关函数 link，rename，remove

表头文件 #include<unistd.h>

定义函数 int unlink(const char * pathname);

函数说明 unlink()会删除参数pathname指定的文件。如果该文件名为最后连接点，但有其他进程打开了此文件，则在所有关于此文件的文件描述词皆关闭后才会删除。如果参数pathname为一符号连接，则此连接会被删除。

返回值成功则返回0，失败返回-1，错误原因存于errno

错误代码 EROFS 文件存在于只读文件系统内
EFAULT 参数pathname指针超出可存取内存空间
ENAMETOOLONG 参数pathname太长
ENOMEM 核心内存不足
ELOOP 参数pathname 有过多符号连接问题
EIO I/O 存取错误

utime（修改文件的存取时间和更改时间）
相关函数 utimes，stat

表头文件 #include<sys/types.h>
#include<utime.h>

定义函数 int utime(const char * filename,struct utimbuf * buf);

函数说明 utime()用来修改参数filename文件所属的inode存取时间。
结构utimbuf定义如下
struct utimbuf{
time_t actime;
time_t modtime;
};

返回值如果参数buf为空指针(NULL)，则该文件的存取时间和更改时间全部会设为目前时间。
执行成功则返回0，失败返回-1，错误代码存于errno。

错误代码 EACCESS 存取文件时被拒绝，权限不足
ENOENT 指定的文件不存在。