C语言网

 找回密码
 加入社区!

QQ登录

只需一步,快速开始

楼主: jiangbowen

Linux C 函数参考   [复制链接]

Rank: 3Rank: 3

主题
0
帖子
174
C币
956 枚
在线时间
32 小时
发表于 2010-3-12 11:26:27 |显示全部楼层
getpwnam(从密码文件中取得指定账号的数据)

相关函数        getpw,fgetpwent,getpwent,getpwuid
表头文件        #include<pwd.h>
#include<sys/types.h>
定义函数        struct passwd * getpwnam(const char * name);
函数说明        getpwnam()用来逐一搜索参数name指定的账号名称,找到时便将该用户的数据以passwd结构返回。passwd结构请参考getpwent()。
返回值        返回passwd结构数据,如果返回NULL则表示已无数据,或有错误发生。

范例       
/*取得root账号的识别码和根目录*/
#include<pwd.h>
#include<sys/types.h>
main()
{
struct passwd *user;
user = getpwnam(“root”);
printf(“name:%s\n”,user->pw_name);
printf(“uid:%d\n”,user->pw_uid);
printf(“home:%s\n”,user->pw_dir);
}
执行       
name:root
uid:0
home:/root


getpwuid(从密码文件中取得指定uid的数据)

相关函数        getpw,fgetpwent,getpwent,getpwnam
表头文件        #include<pwd.h>
#include<sys/types.h>
定义函数        struct passwd * getpwuid(uid_t uid);
函数说明        getpwuid()用来逐一搜索参数uid指定的用户识别码,找到时便将该用户的数据以passwd结构返回。passwd结构请参考getpwent()。
返回值        返回passwd结构数据,如果返回NULL则表示已无数据,或者有错误发生。

范例       
#include<pwd.h>
#include<sys/types.h>
main()
{
struct passwd *user;
user= getpwuid(6);
printf(“name:%s\n”,user->pw_name);
printf(“uid:%d\n”,user->pw_uid);
printf(“home:%s\n”,user->pw_dir);
}
执行       
name:shutdown
uid:6
home:/sbin


getuid(取得真实的用户识别码)

相关函数        geteuid,setreuid,setuid
表头文件        #include<unistd.h>
#include<sys/types.h>
定义函数        uid_t getuid(void);
函数说明        getuid()用来取得执行目前进程的用户识别码。
返回值        用户识别码

范例       
main()
{
printf(“uid is %d\n”,getuid());
}
执行       
uid is 0 /*当使用root身份执行范例程序时*/


getutent(从utmp文件中取得账号登录数据)

相关函数        getutent,getutid,getutline,setutent,endutent,pututline,utmpname
表头文件        #include<utmp.h>
定义函数        struct utmp *getutent(void);
函数说明        getutent()用来从utmp文件(/var/run/utmp)中读取一项登录数据,该数据以utmp结构返回。第一次调用时会取得第一位用户数据,之后每调用一次就会返回下一项数据,直到已无任何数据时返回NULL。
utmp结构定义如下:
struct utmp
{
short int ut_type;   /*登录类型*/
pid_t ut_pid;       /*login进程的pid*/
char ut_line[UT_LINESIZE];/*登录装置名,省略了“/dev/”*/
char ut_id[4];     /* Inittab ID*/
char ut_user[UT_NAMESIZE];/*登录账号*/
char ut_host[UT_HOSTSIZE];/*登录账号的远程主机名称*/
struxt exit_status ut_exit;/* 当类型为DEAD_PROCESS时进程的结束状态*/
long int ut_session; /*Sessioc ID*/
struct timeval ut_tv;  /*时间记录*/
int32_t ut_addr_v6[4]; /*远程主机的网络地址*/
char __unused[20];  /* 保留未使用*/
};
ut_type有以下几种类型:
EMPTY                此为空的记录。
RUN_LVL             记录系统run-level的改变
BOOT_TIME           记录系统开机时间
NEW_TIME    记录系统时间改变后的时间
OLD_TINE     记录当改变系统时间时的时间。
INIT_PROCESS 记录一个由init衍生出来的进程。
LOGIN_PROCESS 记录login进程。
USER_PROCESS 记录一般进程。
DEAD_PROCESS 记录一结束的进程。
ACCOUNTING   目前尚未使用。

exit_status结构定义:
struct exit_status
{
short int e_termination;  /*进程结束状态*/
short int e_exit; /*进程退出状态*/
};
timeval的结构定义请参考gettimeofday()。
相关常数定义如下:
UT_LINESIZE    32
UT_NAMESIZE   32
UT_HOSTSIZE    256
返回值        返回utmp结构数据,如果返回NULL则表示已无数据,或有错误发生。
附加说明        getutent()在第一次调用时会打开utmp文件,读取数据完毕后可使用endutent()来关闭该utmp文件。

范例       
#include<utmp.h>
main()
{
struct utmp *u;
while((u=getutent())){
  if(u->ut_type = = USER_PROCESS)
   printf(“%d %s %s %s \n”,u->ut_type,u->ut_user,u->ut_line,u->ut_host);
}
endutent();
}
执行       
/* 表示有三个root账号分别登录/dev/pts/0,/dev/pts/1,/dev/pts/2 */
7 root pts/0
7 root pts/1
7 root pts/2


getutid(从utmp文件中查找特定的记录)

相关函数        getutent,getutline
表头文件        #include<utmp.h>
定义函数        strcut utmp *getutid(strcut utmp *ut);
函数说明        getutid()用来从目前utmp文件的读写位置逐一往后搜索参数ut指定的记录,如果ut->ut_type为RUN_LVL,BOOT_TIME,NEW_TIME,OLD_TIME其中之一则查找与ut->ut_type相符的记录;若ut->ut_type为INIT_PROCESS,LOGIN_PROCESS,USER_PROCESS或DEAD_PROCESS其中之一,则查找与ut->ut_id相符的记录。找到相符的记录便将该数据以utmp结构返回。utmp结构请参考getutent()。
返回值        返回utmp结构数据,如果返回NULL则表示已无数据,或有错误发生。

范例       
#include<utmp.h>
main()
{
struct utmp ut,*u;
ut.ut_type=RUN_LVL;
while((u= getutid(&ut))){
printf(“%d %s %s %s\n”,u->ut_type,u->ut_user,u->ut_line,u->ut_host);
}
}
执行       
1 runlevel -


getutline(从utmp文件中查找特定的记录)

相关函数        getutent,getutid,pututline
表头文件        #include<utmp.h>
定义函数        struct utmp * getutline (struct utmp *ut);
函数说明        getutline()用来从目前utmp文件的读写位置逐一往后搜索ut_type为USER_PROCESS或LOGIN_PROCESS的记录,而且ut_line和ut->ut_line相符。找到相符的记录便将该数据以utmp结构返回,utmp结构请参考getutent()。
返回值        返回utmp结构数据,如果返回NULL则表示已无数据,或有错误发生。

范例       
#include<utmp.h>
main()
{
struct utmp ut,*u;
strcpy (ut.ut_line,”pts/1”);
while ((u=getutline(&ut))){
  printf(“%d %s %s %s \n”,u->ut_type,u->ut_user,u->ut_line,u->ut_host);
}
}
执行       
7 root pts/1


initgroups(初始化组清单)

相关函数        setgrent,endgrent
表头文件        #include<grp.h>
#include<sys/types.h>
定义函数        int initgroups(const char *user,gid_t group);
函数说明        initgroups()用来从组文件(/etc/group)中读取一项组数据,若该组数据的成员中有参数user时,便将参数group组识别码加入到此数据中。
返回值        执行成功则返回0,失败则返回-1,错误码存于errno。



pututline(将utmp记录写入文件)

相关函数        getutent,getutid,getutline
表头文件        #include<utmp.h>
定义函数        void pututline(struct utmp *ut);
函数说明        pututline()用来将参数ut的utmp结构记录到utmp文件中。此函数会先用getutid()来取得正确的写入位置,如果没有找到相符的记录则会加入到utmp文件尾,utmp结构请参考getutent()。
返回值        无
附加说明        需要有写入/var/run/utmp的权限

范例       
#include<utmp.h>
main()
{
  struct utmp ut;
  ut.ut_type =USER_PROCESS;
  ut.ut_pid=getpid();
  strcpy(ut.ut_user,”kids”);
  strcpy(ut.ut_line,”pts/1”);
  strcpy(ut.ut_host,”www.gnu.org”);
  pututline(&ut);
}
执行       
/*执行范例后用指令who -l 观察*/
root pts/0 dec9 19:20
kids pts/1 dec12 10:31(www.gnu.org)
root pts/2 dec12 13:33


seteuid(设置有效的用户识别码)

相关函数        setuid,setreuid,setfsuid
表头文件        #include<unistd.h>
定义函数        int seteuid(uid_t euid);
函数说明        seteuid()用来重新设置执行目前进程的有效用户识别码。在Linux下,seteuid(euid)相当于setreuid(-1,euid)。
返回值        执行成功则返回0,失败则返回-1,错误代码存于errno
附加说明        请参考setuid



setfsgid(设置文件系统的组识别码)

相关函数        setuid,setreuid,seteuid,setfsuid
表头文件        #include<unistd.h>
定义函数        int setfsgid(uid_t fsgid);
函数说明        setfsgid()用来重新设置目前进程的文件系统的组识别码。一般情况下,文件系统的组识别码(fsgid)与有效的组识别码(egid)是相同的。如果是超级用户调用此函数,参数fsgid可以为任何值,否则参数fsgid必须为real/effective/saved的组识别码之一。
返回值        执行成功则返回0,失败则返回-1,错误代码存于errno。
附加说明        此函数为Linux特有。
错误代码        EPERM 权限不够,无法完成设置。



setfsuid(设置文件系统的用户识别码)

相关函数        setuid,setreuid,seteuid,setfsgid
表头文件        #include<unistd.h>
定义函数        int setfsuid(uid_t fsuid);
函数说明        setfsuid()用来重新设置目前进程的文件系统的用户识别码。一般情况下,文件系统的用户识别码(fsuid)与有效的用户识别码(euid)是相同的。如果是超级用户调用此函数,参数fsuid可以为任何值,否则参数fsuid必须为real/effective/saved的用户识别码之一。
返回值        执行成功则返回0,失败则返回-1,错误代码存于errno
附加说明        此函数为Linux特有
错误代码        EPERM  权限不够,无法完成设置。



setgid(设置真实的组识别码)

相关函数        getgid,setregid,getegid,setegid
表头文件        #include<unistd.h>
定义函数        int setgid(gid_t gid);
函数说明        setgid()用来将目前进程的真实组识别码(real gid)设成参数gid值。如果是以超级用户身份执行此调用,则real、effective与saved gid都会设成参数gid。
返回值        设置成功则返回0,失败则返回-1,错误代码存于errno中。
错误代码        EPERM 并非以超级用户身份调用,而且参数gid并非进程的effective gid或saved gid值之一。



setgrent(从头读取组文件中的组数据)

相关函数        getgrent,endgrent
表头文件        #include<grp.h>
#include<sys/types.h>
定义函数        void setgrent(void);
函数说明        setgrent()用来将getgrent()的读写地址指回组文件开头。
返回值        无
附加说明        请参考setpwent()。

Rank: 3Rank: 3

主题
0
帖子
174
C币
956 枚
在线时间
32 小时
发表于 2010-3-12 11:26:41 |显示全部楼层
setgroups(设置组代码)

相关函数        initgroups,getgroup,getgid,setgid
表头文件        #include<grp.h>
定义函数        int setgroups(size_t size,const gid_t * list);
函数说明        setgroups()用来将list数组中所标明的组加入到目前进程的组设置中。参数size为list〔〕的gid_t数目,最大值为NGROUP(32)。
返回值        设置成功则返回0,如有错误则返回-1。
错误代码        EFAULT 参数list数组地址不合法。
EPERM 权限不足,必须是root权限
EINVAL 参数size值大于NGROUP(32)。



setpwent(从头读取密码文件中的账号数据)

相关函数        getpwent,endpwent
表头文件        #include<pwd.h>
#include<sys/types.h>
定义函数        void setpwent(void);
函数说明        setpwent()用来将getpwent()的读写地址指回密码文件开头。
返回值        无

范例       
#include<pwd.h>
#include<sys/types.h>
main()
{
  struct passwd *user;
  int i;
  for(i=0;i<4;i++){
  user=getpwent();
   printf(“%s :%d :%d :%s:%s:%s\n”,user->pw_name,user->pw_uid,user->pw_gid,
user->pw_gecos,user->pw_dir,user->pw_shell);
}
  setpwent();
  user=getpwent();
  printf(“%s :%d :%d :%s:%s:%s\n”,user->pw_name,user->pw_uid,user->pw_gid,
user->pw_gecos,user->pw_dir,user->pw_shell);
endpwent();
}
执行       
root:0:0:root:/root:/bin/bash
bin:1:1:bin:/bin
daemon:2:2:daemon:/sbin
adm:3:4:adm:/var/adm
root:0:0:root:/root:/bin/bash


setregid(设置真实及有效的组识别码)

相关函数        setgid,setegid,setfsgid
表头文件        #include<unistd.h>
定义函数        int setregid(gid_t rgid,gid_t egid);
函数说明        setregid()用来将参数rgid设为目前进程的真实组识别码,将参数egid设置为目前进程的有效组识别码。如果参数rgid或egid值为-1,则对应的识别码不会改变。
返回值        执行成功则返回0,失败则返回-1,错误代码存于errno。



setreuid(设置真实及有效的用户识别码)

相关函数        setuid,seteuid,setfsuid
表头文件        #include<unistd.h>
定义函数        int setreuid(uid_t ruid,uid_t euid);
函数说明        setreuid()用来将参数ruid设为目前进程的真实用户识别码,将参数euid设置为目前进程的有效用户识别码。如果参数ruid或euid值为-1,则对应的识别码不会改变。
返回值        执行成功则返回0,失败则返回-1,错误代码存于errno。
附加说明        请参考setuid()。



setuid(设置真实的用户识别码)

相关函数        getuid,setreuid,seteuid,setfsuid
表头文件        #include<unistd.h>
定义函数        int setuid(uid_t uid)
函数说明        setuid()用来重新设置执行目前进程的用户识别码。不过,要让此函数有作用,其有效的用户识别码必须为0(root)。在Linux下,当root使用setuid()来变换成其他用户识别码时,root权限会被抛弃,完全转换成该用户身份,也就是说,该进程往后将不再具有可setuid()的权利,如果只是向暂时抛弃root权限,稍后想重新取回权限,则必须使用seteuid()。
返回值        执行成功则返回0,失败则返回-1,错误代码存于errno。
附加说明        一般在编写具setuid root 的程序时,为减少此类程序带来的系统安全风险,在使用完root权限后建议马上执行setuid(getuid());来抛弃root权限。此外,进程uid和euid不一致时Linux系统将不会产生core dump。





setutent(从头读取utmp文件中的登录数据)

相关函数        getutent,endutent
表头文件        #include<utmp.h>
定义函数        void setutent(void);
函数说明        setutent()用来将getutent()的读写地址指回utmp文件开头。
附加说明        请参考setpwent()或setgrent()。



utmpname(设置utmp文件路径)

相关函数        getutent,getutid,getutline,setutent,endutent,pututline
表头文件        #include<utmp.h>
定义函数        void  utmpname(const char * file);
函数说明        utmpname()用来设置utmp文件的路径,以提供utmp相关函数的存取路径。如果没有使用utmpname()则默认utmp文件路径为/var/run/utmp。
返回值        无


crypt(将密码或数据编码)

相关函数        getpass
表头文件        #define _XOPEN_SOURCE
#include<unistd.h>
定义函数        char * crypt (const char *key,const char * salt);
函数说明        crypt()将使用Data Encryption Standard (DES)演算法将参数key所指的字符串加以编码,key字符串长度仅取前8个字符,超过此长度的字符没有意义。参数salt为两个字符组成的字符串,由a-z、A-Z、0-9,“.”和“/”所组成,用来决定使用4096种不同内建表格的哪一个。函数执行成功后会返回指向编码过的字符串指针,参数key所指的字符串不会有所更动。编码过的字符串长度为13个字符,前两个字符为参数salt代表的字符串。
返回值        返回一个指向以NULL结尾的密码字符串。
附加说明        使用GCC编译时需加-lcrypt。

范例       
#include<unistd.h>
main()
{
  char passwd[13];
  char *key;
  char slat[2];
  key= getpass(“Input First Password:”);
  slat[0]=key[0];
  slat[1]=key[1];
  strcpy(passwd,crypt(key slat));
  key=getpass(“Input Second Password:”);
  slat[0]=passwd[0];
  slat[1]=passwd[1];
  printf(“After crypt(),1st passwd :%s\n”,passwd);
  printf(“After crypt(),2nd passwd:%s \n”,crypt(key slat));
}
执行       
Input First Password:                 /* 输入test,编码后存于passwd[ ] */
Input Second Password               /*输入test,密码相同编码后也会相同*/
After crypt () 1st Passwd : teH0wLIpW0gyQ
After crypt () 2nd Passwd : teH0wLIpW0gyQ


bsearch(二元搜索)

相关函数        qsort
表头文件        #include<stdlib.h>
定义函数        void *bsearch(const void *key,const void *base,size_t nmemb,size_t size,int (*compar) (const void*,const void*));
函数说明        bsearch()利用二元搜索从排序好的数组中查找数据。参数key指向欲查找的关键数据,参数base指向要被搜索的数组开头地址,参数nmemb代表数组中的元素数量,每一元素的大小则由参数size决定,最后一项参数compar为一函数指针,这个函数用来判断两个元素之间的大小关系,若传给compar的第一个参数所指的元素数据大于第二个参数所指的元素数据则必须回传大于0的值,两个元素数据相等则回传0。
附加说明        找到关键数据则返回找到的地址,如果在数组中找不到关键数据则返回NULL。

范例       
#include<stdio.h>
#include<stdlib.h>
#define NMEMB 5
#define SIZE 10
int compar(const void *a,const void *b)
{
return (strcmp((char *)a,(char *)b));
}
main()
{
  char data[50][size]={“linux”,”freebsd”,”solaris”,”sunos”,”windows”};
  char key[80],*base ,*offset;
  int i, nmemb=NMEMB,size=SIZE;
  while(1){
   printf(“>”);
   fgets(key,sizeof(key),stdin);
   key[strlen(key)-1]=’\0’;
   if(!strcmp(key,”exit”))break;
   if(!strcmp(key,”list”)){
for(i=0;i<nmemb;i++)
   printf(“%s\n”,data[i]);
  continue;
}
   base = data[0];
   qsort(base,nmemb,size,compar);
   offset = (char *) bsearch(key,base,nmemb,size,compar);
   if( offset = =NULL){
printf(“%s not found!\n”,key);
strcpy(data[nmemb++],key);
printf(“Add %s to data array\n”,key);
}else{
printf(“found: %s \n”,offset);
}
}
}
执行       
>hello            /*输入hello字符串*/
hello not found!          /*找不到hello字符串*/
add hello to data array    /*将hello字符串加入*/
>.list                 /*列出所有数据*/
freebsd
linux
solaris
sunos
windows
hello
>hello
found: hello

Rank: 3Rank: 3

主题
0
帖子
174
C币
956 枚
在线时间
32 小时
发表于 2010-3-12 11:26:56 |显示全部楼层
lfind(线性搜索)

相关函数        lsearch
表头文件        #include<stdlib.h>
定义函数        void *lfind (const void *key,const void *base,size_t *nmemb,size_t size,int(* compar) (const void * ,const void *));
函数说明        lfind(()利用线性搜索在数组中从头至尾一项项查找数据。参数key指向欲查找的关键数据,参数base指向要被搜索的数组开头地址,参数nmemb代表数组中的元素数量,每一元素的大小则由参数size决定,最后一项参数compar为一函数指针,这个函数用来判断两个元素是否相同,若传给compar的异地个参数所指的元素数据和第二个参数所指的元素数据相同时则返回0,两个元素数据不相同则返回非0值。lfind()与lsearch()不同点在于,当找不到关键数据时lfind()仅会返回NULL,而不会主动把该笔数据加入数组尾端。
返回值        找到关键数据则返回找到的该笔元素的地址,如果在数组中找不到关键数据则返回空指针(NULL)。

范例       
参考lsearch()。


lsearch(线性搜索)

相关函数        lfind
表头文件        #include<stdlib.h>
定义函数        void *lsearch(const void * key ,const void * base ,size_t * nmemb,size_t size, int ( * compar) (const void * ,const void *));
函数说明        lsearch()利用线性搜索在数组中从头至尾一项项查找数据。参数key指向欲查找的关键数据,参数base指向要被搜索的数组开头地址,参数nmemb代表数组中的元素数量,每一元素的大小则由参数size决定,最后一项参数compar为一函数指针,这个函数用来判断两个元素是否相同,若传给compar的第一个参数所指的元素数据和第二个参数所指的元素数据相同时则返回0,两个元素数据不相同则返回非0值。如果lsearch()找不到关键数据时会主动把该项数据加入数组里。
返回值        找到关键数据则返回找到的该笔元素的四肢,如果在数组中找不到关键数据则将此关键数据加入数组,再把加入数组后的地址返回。

范例       
#include<stdio.h>
#include<stdlib.h>
#define NMEMB 50
#define SIZE 10
int compar (comst void *a,const void *b)
{
  return (strcmp((char *) a, (char *) b));
}
main()
{
  char data[NMEMB][SIZE]={“Linux”,”freebsd”,”solzris”,”sunos”,”windows”};
  char key[80],*base,*offset;
  int i, nmemb=NMEMB,size=SIZE;
  for(i=1;i<5;i++){
  fgets(key,sizeof9key),stdin);
  key[strlen(key)-1]=’\0’;
base = data[0];
offset = (char *)lfind(key,base,&nmemb,size,compar);
if(offset ==NULL){
  printf(“%s not found!\n”,key);
  offset=(char *) lsearch(key,base,&nmemb,size,compar);
printf(“Add %s to data array\n”,offset);
}else{
printf(“found : %s \n”,offset);
}
}
}
执行       
linux
found:linux
os/2
os/2 not found!
add os/2 to data array
os/2
found : os/2


qsort(利用快速排序法排列数组)

相关函数        bsearch
表头文件        #include<stdlib.h>
定义函数        void qsort(void * base,size_t nmemb,size_t size,int ( * compar)(const void *, const void *));
函数说明        参数base指向欲排序的数组开头地址,参数nmemb代表数组中的元素数量,每一元素的大小则由参数size决定,最后一项参数compar为一函数指针,这个函数用来判断两个元素间的大小关系,若传给compar的第一个参数所指的元素数据大于第二个参数所指的元素数据则必须回传大于零的值,两个元素数据相等则回传0。
返回值        无
附加说明       

范例       
#define nmemb 7
#include <stdlib.h>
int compar (const void *a ,const void *b)
{
  int *aa=(int * ) a,*bb = (int * )b;
  if( * aa >* bb)return 1;
  if( * aa == * bb) return 0;
  if( * aa < *bb) return -1;
}
main( )
{
  int base[nmemb]={ 3,102,5,-2,98,52,18};
  int i;
  for ( i=0; i<nmemb;i++)
   printf(“%d “,base[i]);
  printf(“\n”);
  qsort(base,nmemb,sizeof(int),compar);
  for(i=0;i<nmemb;i++)
   printf(“%d”base[i]);
printf(“\n”);
}
执行       
3 102 5 -2 98 52 18
-2 3 5 18 52 98 102


rand(产生随机数)

相关函数        srand,random,srandom
表头文件        #include<stdlib.h>
定义函数        int rand(void)
函数说明        rand()会返回一随机数值,范围在0至RAND_MAX间。在调用此函数产生随机数前,必须先利用srand()设好随机数种子,如果未设随机数种子,rand()在调用时会自动设随机数种子为1。关于随机数种子请参考srand()。
返回值        返回0至RAND_MAX之间的随机数值,RAND_MAX定义在stdlib.h,其值为2147483647。

范例       
/* 产生介于1到10间的随机数值,此范例未设随机数种子,完整的随机数产生请参考srand()*/
#include<stdlib.h>
main()
{
int i,j;
for(i=0;i<10;i++)
  {
j=1+(int)(10.0*rand()/(RAND_MAX+1.0));
printf(“%d “,j);
}
}
执行       
9 4 8 8 10 2 4 8 3 6
9 4 8 8 10 2 4 8 3 6


srand(设置随机数种子)

相关函数        rand,random srandom
表头文件        #include<stdlib.h>
定义函数        void srand (unsigned int seed);
函数说明        srand() 用来设置rand()产生随机数时的随机数种子。参数seed必须是个整数,通常可以利用geypid()或time(0)的返回值来当做seed。如果每次seed都设相同值,rand()所产生的随机数值每次就会一样。
返回值        无

范例       
/* 产生介于1到10间的随机数值,此范例与执行结果可与rand()参照*/
#include<time.h>
#include<stdlib.h>
main()
{
  int i,j;
  srand((int)time(0));
  for(i=0;i<10;i++)
  {
   j=1+(int)(10.0*rand()/(RAND_MAX+1.0));
   printf(“ %d “,j);
}
}
执行       
5  8  8  8  10  2  10  8  9  9
2  9  7  4  10  3  2  10  8  7


close(关闭文件)

相关函数        open,fcntl,shutdown,unlink,fclose
表头文件        #include<unistd.h>
定义函数        int close(int fd);
函数说明        当使用完文件后若已不再需要则可使用close()关闭该文件,二close()会让数据写回磁盘,并释放该文件所占用的资源。参数fd为先前由open()或creat()所返回的文件描述词。
返回值        若文件顺利关闭则返回0,发生错误时返回-1。
错误代码        EBADF 参数fd非有效的文件描述词或该文件已关闭。
附加说明        虽然在进程结束时,系统会自动关闭已打开的文件,但仍建议自行关闭文件,并确实检查返回值。

范例       
参考open()

creat(建立文件)

相关函数        read,write,fcntl,close,link,stat,umask,unlink,fopen
表头文件        #include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
定义函数        int creat(const char * pathname, mode_tmode);
函数说明        参数pathname指向欲建立的文件路径字符串。creat()相当于使用下列的调用方式调用open():
  open(const char * pathname ,
(O_CREAT|O_WRONLY|O_TRUNC));
错误代码        关于参数mode请参考open()函数。
返回值        creat() 会返回新的文件描述词,若有错误发生则会返回-1,并把错误代码设给errno。
EEXIST               参数pathname所指的文件已存在。
EACCESS             参数pathname所指定的文件不符合所要求测试的权限
EROFS                欲打开写入权限的文件存在于只读文件系统内
EFAULT               参数pathname指针超出可存取的内存空间
EINVAL               参数mode不正确。
ENAMETOOLONG     参数pathname太长。
ENOTDIR             参数pathname为一目录
ENOMEM             核心内存不足
ELOOP                参数pathname有过多符号连接问题。
EMFILE               已达到进程可同时打开的文件数上限
ENFILE                已达到系统可同时打开的文件数上限
附加说明        creat() 无法建立特别的装置文件,如果需要请使用mknod()。

范例       
请参考open()。





dup(复制文件描述词)

相关函数        open,close,fcntl,dup2
表头文件        #include<unistd.h>
定义函数        int dup (int oldfd);
函数说明        dup()用来复制参数oldfd所指的文件描述词,并将它返回。此新的文件描述词和参数oldfd指的是同一个文件,共享所有的锁定、读写位置和各项权限或旗标。例如,当利用lseek()对某个文件描述词作用时,另一个文件描述词的读写位置也会随着改变。
不过,文件描述词之间并不共享close-on-exec旗标
返回值        当复制成功时,则返回最小及尚未使用的文件描述词。若有错误则返回-1,errno会存放错误代码。
错误代码        EBADF  参数fd非有效的文件描述词,或该文件已关闭。


dup2(复制文件描述词)

相关函数        open,close,fcntl,dup
表头文件        #include<unistd.h>
定义函数        int dup2(int odlfd,int newfd);
函数说明        dup2()用来复制参数oldfd所指的文件描述词,并将它拷贝至参数newfd后一块返回。若参数newfd为一已打开的文件描述词,则newfd所指的文件会先被关闭。dup2()所复制的文件描述词,与原来的文件描述词共享各种文件状态,详情可参考dup()。
返回值        当复制成功时,则返回最小及尚未使用的文件描述词。若有错误则返回-1,errno会存放错误代码。
附加说明        dup2()相当于调用fcntl(oldfd,F_DUPFD,newfd);请参考fcntl()。
错误代码        EBADF 参数fd非有效的文件描述词,或该文件已关闭





fcntl(文件描述词操作)

相关函数        open,flock
表头文件        #include<unistd.h>
#include<fcntl.h>
定义函数        int fcntl(int fd , int cmd);
int fcntl(int fd,int cmd,long arg);
int fcntl(int fd,int cmd,struct flock * lock);
函数说明        fcntl()用来操作文件描述词的一些特性。参数fd代表欲设置的文件描述词,参数cmd代表欲操作的指令,有以下几种情况:
F_DUPFD  用来查找大于或等于参数arg的最小且仍未使用的文件描述词,并且复制参数fd的文件描述词。执行成功则返回新复制的文件描述词。请参考dup2()。
F_GETFD   取得close-on-exec旗标。若此旗标的FD_CLOEXEC位为0,代表在调用exec()相关函数时文件将不会关闭。
F_SETFD  设置close-on-exec旗标。该旗标以参数arg的FD_CLOEXEC位决定。
F_GETFL  取得文件描述词状态旗标,此旗标为open()的参数flags。
F_SETFL   设置文件描述词状态旗标,参数arg为新旗标,但只允许O_APPEND、O_NONBLOCK和O_ASYNC位的改变,其他位的改变将不受影响。
F_GETLK   取得文件锁定的状态
F_SETLK    设置文件锁定的状态。此时flcok结构的l_type值必须是F_RDLCK、F_WRLCK或F_UNLCK。如果无法建立锁定,则返回-1,错误代码为EACCES或EAGAIN。
F_SETLKW  F_SETLK作用相同,但是无法建立锁定时,此调用会一直等到锁定动作成功为止。若在等待锁定的过程中被信号中断时,会立即返回-1,错误代码为EINTR。参数lock指针为flock结构指针,定义如下:
struct flcok
{
  short int l_type; /* 锁定的状态*/
  short int l_whence;/*决定l_start位置*/
  off_t  l_start;   /*锁定区域的开头位置*/
  off_t  l_len;   /*锁定区域的大小*/
  pid_t l_pid;    /*锁定动作的进程*/
};
l_type 有三种状态:
  F_RDLCK  建立一个供读取用的锁定
  F_WRLCK  建立一个供写入用的锁定
  F_UNLCK  删除之前建立的锁定
l_whence也有三种方式:
  SEEK_SET  以文件开头为锁定的起始位置。
  SEEK_CUR 以目前文件读写位置为锁定的起始位置
  SEEK_END 以文件结尾为锁定的起始位置。
  
返回值        成功则返回0,若有错误则返回-1,错误原因存于errno.

Rank: 3Rank: 3

主题
0
帖子
174
C币
956 枚
在线时间
32 小时
发表于 2010-3-12 11:27:10 |显示全部楼层
flock(锁定文件或解除锁定)

相关函数        open,fcntl
表头文件        #include<sys/file.h>
定义函数        int flock(int fd,int operation);
函数说明        flock()会依参数operation所指定的方式对参数fd所指的文件做各种锁定或解除锁定的动作。此函数只能锁定整个文件,无法锁定文件的某一区域。
参数operation有下列四种情况:
LOCK_SH 建立共享锁定。多个进程可同时对同一个文件作共享锁定。
LOCK_EX 建立互斥锁定。一个文件同时只有一个互斥锁定。
LOCK_UN 解除文件锁定状态。
LOCK_NB 无法建立锁定时,此操作可不被阻断,马上返回进程。通常与LOCK_SH或LOCK_EX做OR(|)组合。
单一文件无法同时建立共享锁定和互斥锁定,而当使用dup()或fork()时文件描述词不会继承此种锁定。
返回值        返回0表示成功,若有错误则返回-1,错误代码存于errno。


fsync(将缓冲区数据写回磁盘)

相关函数        sync
表头文件        #include<unistd.h>
定义函数        int fsync(int fd);
函数说明        fsync()负责将参数fd所指的文件数据,由系统缓冲区写回磁盘,以确保数据同步。
返回值        成功则返回0,失败返回-1,errno为错误代码


lseek(移动文件的读写位置)

相关函数        dup,open,fseek
表头文件        #include<sys/types.h>
#include<unistd.h>
定义函数        off_t lseek(int fildes,off_t offset ,int whence);
函数说明        每一个已打开的文件都有一个读写位置,当打开文件时通常其读写位置是指向文件开头,若是以附加的方式打开文件(如O_APPEND),则读写位置会指向文件尾。当read() 或write()时,读写位置会随之增加,lseek()便是用来控制该文件的读写位置。参数fildes为已打开的文件描述词,参数offset为根据参数whence来移动读写位置的位移数。参数whence为下列其中一种:
SEEK_SET  参数offset即为新的读写位置。
SEEK_CUR 以目前的读写位置往后增加offset个位移量。
SEEK_END 将读写位置指向文件尾后再增加offset个位移量。
当whence值为SEEK_CUR或SEEK_END时,参数offet允许负值的出现。
下列是教特别的使用方式:
1) 欲将读写位置移到文件开头时:lseek(int fildes,0,SEEK_SET);
2) 欲将读写位置移到文件尾时:lseek(int fildes,0,SEEK_END);
3) 想要取得目前文件位置时:lseek(int fildes,0,SEEK_CUR);
返回值        当调用成功时则返回目前的读写位置,也就是距离文件开头多少个字节。若有错误则返回-1,errno会存放错误代码。
附加说明        Linux系统不允许lseek()对tty装置作用,此项动作会令lseek()返回ESPIPE。

范例       
参考本函数说明

mkstemp(建立唯一的临时文件)

相关函数        mktemp
表头文件        #include<stdlib.h>
定义函数        int mkstemp(char * template);
函数说明        mkstemp()用来建立唯一的临时文件。参数template所指的文件名称字符串中最后六个字符必须是XXXXXX。mkstemp()会以可读写模式和0600权限来打开该文件,如果该文件不存在则会建立该文件。打开该文件后其文件描述词会返回。
文件顺利打开后返回可读写的文件描述词。若果文件打开失败则返回NULL,并把错误代码存在errno中。
错误代码        EINVAL 参数template字符串最后六个字符非XXXXXX。
EEXIST 无法建立临时文件。
附加说明        参数template所指的文件名称字符串必须声明为数组,如:
  char template[ ] =”template-XXXXXX”;
千万不可以使用下列的表达方式
  char  *template = “template-XXXXXX”;

范例       
#include<stdlib.h>
main( )
{
  int fd;
  char template[ ]=”template-XXXXXX”;
  fd=mkstemp(template);
  printf(“template = %s\n”,template);
  close(fd);
}
执行       
template = template-lgZcbo


open(打开文件)

相关函数        read,write,fcntl,close,link,stat,umask,unlink,fopen
表头文件        #include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
定义函数        int open( const char * pathname, int flags);
int open( const char * pathname,int flags, mode_t mode);
函数说明        参数pathname指向欲打开的文件路径字符串。下列是参数flags所能使用的旗标:
O_RDONLY  以只读方式打开文件
O_WRONLY  以只写方式打开文件
O_RDWR    以可读写方式打开文件。上述三种旗标是互斥的,也就是不可同时使用,但可与下列的旗标利用OR(|)运算符组合。
O_CREAT  若欲打开的文件不存在则自动建立该文件。
O_EXCL   如果O_CREAT也被设置,此指令会去检查文件是否存在。文件若不存在则建立该文件,否则将导致打开文件错误。此外,若O_CREAT与O_EXCL同时设置,并且欲打开的文件为符号连接,则会打开文件失败。
O_NOCTTY 如果欲打开的文件为终端机设备时,则不会将该终端机当成进程控制终端机。
O_TRUNC  若文件存在并且以可写的方式打开时,此旗标会令文件长度清为0,而原来存于该文件的资料也会消失。
O_APPEND  当读写文件时会从文件尾开始移动,也就是所写入的数据会以附加的方式加入到文件后面。
O_NONBLOCK  以不可阻断的方式打开文件,也就是无论有无数据读取或等待,都会立即返回进程之中。
O_NDELAY  同O_NONBLOCK。
O_SYNC  以同步的方式打开文件。
O_NOFOLLOW 如果参数pathname所指的文件为一符号连接,则会令打开文件失败。
O_DIRECTORY  如果参数pathname所指的文件并非为一目录,则会令打开文件失败。此为Linux2.2以后特有的旗标,以避免一些系统安全问题。参数mode则有下列数种组合,只有在建立新文件时才会生效,此外真正建文件时的权限会受到umask值所影响,因此该文件权限应该为(mode-umaks).
S_IRWXU00700 权限,代表该文件所有者具有可读、可写及可执行的权限。
S_IRUSR  或S_IREAD,00400权限,代表该文件所有者具有可读取的权限。
S_IWUSR  或S_IWRITE,00200权限,代表该文件所有者具有可写入的权限。
S_IXUSR 或S_IEXEC,00100权限,代表该文件所有者具有可执行的权限。
S_IRWXG 00070权限,代表该文件用户组具有可读、可写及可执行的权限。
S_IRGRP 00040权限,代表该文件用户组具有可读的权限。
S_IWGRP 00020权限,代表该文件用户组具有可写入的权限。
S_IXGRP 00010权限,代表该文件用户组具有可执行的权限。
S_IRWXO 00007权限,代表其他用户具有可读、可写及可执行的权限。
S_IROTH 00004权限,代表其他用户具有可读的权限
S_IWOTH 00002权限,代表其他用户具有可写入的权限。
S_IXOTH 00001权限,代表其他用户具有可执行的权限。
返回值        若所有欲核查的权限都通过了检查则返回0值,表示成功,只要有一个权限被禁止则返回-1。
错误代码        EEXIST  参数pathname所指的文件已存在,却使用了O_CREAT和O_EXCL旗标
EACCESS 参数pathname所指的文件不符合所要求测试的权限。
EROFS    欲测试写入权限的文件存在于只读文件系统内。
EFAULT 参数pathname指针超出可存取内存空间。
EINVAL 参数mode不正确。
ENAMETOOLONG 参数pathname太长。
ENOTDIR 参数pathname不是目录。
ENOMEM 核心内存不足。
ELOOP  参数pathname有过多符号连接问题。
EIO  I/O存取错误。
附加说明        使用access()作用户认证方面的判断要特别小心,例如在access()后再作open()空文件可能会造成系统安全上的问题。

范例       
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
main()
{
  int fd,size;
  char s [ ]=”Linux Programmer!\n”,buffer[80];
  fd=open(“/tmp/temp”,O_WRONLY|O_CREAT);
  write(fd,s,sizeof(s));
  close(fd);
  fd=open(“/tmp/temp”,O_RDONLY);
  size=read(fd,buffer,sizeof(buffer));
  close(fd);
  printf(“%s”,buffer);
}
执行       
Linux Programmer!

Rank: 3Rank: 3

主题
0
帖子
174
C币
956 枚
在线时间
32 小时
发表于 2010-3-12 11:27:29 |显示全部楼层
read(由已打开的文件读取数据)

相关函数        readdir,write,fcntl,close,lseek,readlink,fread
表头文件        #include<unistd.h>
定义函数        ssize_t read(int fd,void * buf ,size_t count);
函数说明        read()会把参数fd所指的文件传送count个字节到buf指针所指的内存中。若参数count为0,则read()不会有作用并返回0。返回值为实际读取到的字节数,如果返回0,表示已到达文件尾或是无可读取的数据,此外文件读写位置会随读取到的字节移动。
附加说明        如果顺利read()会返回实际读到的字节数,最好能将返回值与参数count作比较,若返回的字节数比要求读取的字节数少,则有可能读到了文件尾、从管道(pipe)或终端机读取,或者是read()
被信号中断了读取动作。当有错误发生时则返回-1,错误代码存入errno中,而文件读写位置则无法预期。
错误代码        EINTR  此调用被信号所中断。
EAGAIN 当使用不可阻断I/O时(O_NONBLOCK),若无数据可读取则返回此值。
EBADF 参数fd非有效的文件描述词,或该文件已关闭。

范例       
参考open()。


sync(将缓冲区数据写回磁盘)

相关函数        fsync
表头文件        #include<unistd.h>
定义函数        int sync(void)
函数说明        sync()负责将系统缓冲区数据写回磁盘,以确保数据同步。
返回值        返回0。



write(将数据写入已打开的文件内)

相关函数        open,read,fcntl,close,lseek,sync,fsync,fwrite
表头文件        #include<unistd.h>
定义函数        ssize_t write (int fd,const void * buf,size_t count);
函数说明        write()会把参数buf所指的内存写入count个字节到参数fd所指的文件内。当然,文件读写位置也会随之移动。
返回值        如果顺利write()会返回实际写入的字节数。当有错误发生时则返回-1,错误代码存入errno中。
错误代码        EINTR  此调用被信号所中断。
EAGAIN 当使用不可阻断I/O时(O_NONBLOCK),若无数据可读取则返回此值。
EADF  参数fd非有效的文件描述词,或该文件已关闭。

范例       
请参考open()。


clearerr(清除文件流的错误旗标)

相关函数        feof
表头文件        #include<stdio.h>
定义函数        void clearerr(FILE * stream);
函数说明        clearerr()清除参数stream指定的文件流所使用的错误旗标。
返回值        无


fclose(关闭文件)

相关函数        close,fflush,fopen,setbuf
表头文件        #include<stdio.h>
定义函数        int fclose(FILE * stream);
函数说明        fclose()用来关闭先前fopen()打开的文件。此动作会让缓冲区内的数据写入文件中,并释放系统所提供的文件资源。
返回值        若关文件动作成功则返回0,有错误发生时则返回EOF并把错误代码存到errno。
错误代码        EBADF表示参数stream非已打开的文件。

范例       
请参考fopen()。


fdopen(将文件描述词转为文件指针)

相关函数        fopen,open,fclose
表头文件        #include<stdio.h>
定义函数        FILE * fdopen(int fildes,const char * mode);
函数说明        fdopen()会将参数fildes的文件描述词,转换为对应的文件指针后返回。参数mode字符串则代表着文件指针的流形态,此形态必须和原先文件描述词读写模式相同。关于mode字符串格式请参考fopen()。
返回值        转换成功时返回指向该流的文件指针。失败则返回NULL,并把错误代码存在errno中。

范例       
#include<stdio.h>
main()
{
  FILE * fp =fdopen(0,”w+”);
  fprintf(fp,”%s\n”,”hello!”);
  fclose(fp);
}
执行       
hello!
feof(检查文件流是否读到了文件尾)

相关函数        fopen,fgetc,fgets,fread
表头文件        #include<stdio.h>
定义函数        int feof(FILE * stream);
函数说明        feof()用来侦测是否读取到了文件尾,尾数stream为fopen()所返回之文件指针。如果已到文件尾则返回非零值,其他情况返回0。
返回值        返回非零值代表已到达文件尾。


fflush(更新缓冲区)

相关函数        write,fopen,fclose,setbuf
表头文件        #include<stdio.h>
定义函数        int fflush(FILE* stream);
函数说明        fflush()会强迫将缓冲区内的数据写回参数stream指定的文件中。如果参数stream为NULL,fflush()会将所有打开的文件数据更新。
返回值        成功返回0,失败返回EOF,错误代码存于errno中。
错误代码        EBADF  参数stream指定的文件未被打开,或打开状态为只读。其它错误代码参考write()。


fgetc(由文件中读取一个字符)

相关函数        fopen,fread,fscanf,getc
表头文件        #include<stdio.h>
定义函数        int fgetc(FILE * stream);
函数说明        fgetc()用来从参数stream所指的文件中读取一个字符。若读到文件尾而无数据时便返回EOF。
返回值        fgetc()会返回读取到的字符,若返回EOF则表示到了文件尾。

范例       
#include<stdio.h>
main()
{
  FILE *fp;
  int c;
  fp=fopen(“exist”,”r”);
  while((c=fgetc(fp))!=EOF)
printf(“%c”,c);
   fclose(fp);
}


fgets(由文件中读取一字符串)

相关函数        fopen,fread,fscanf,getc
表头文件        #include<stdio.h>
定义函数        char * fgets(char * s,int size,FILE * stream);
函数说明        fgets()用来从参数stream所指的文件内读入字符并存到参数s所指的内存空间,直到出现换行字符、读到文件尾或是已读了size-1个字符为止,最后会加上NULL作为字符串结束。
返回值        fgets()若成功则返回s指针,返回NULL则表示有错误发生。

范例       
#include<stdio.h>
main()
{
char s[80];
fputs(fgets(s,80,stdin),stdout);
}
执行       
this is a test  /*输入*/
this is a test  /*输出*/


fileno(返回文件流所使用的文件描述词)

相关函数        open,fopen
表头文件        #include<stdio.h>
定义函数        int fileno(FILE * stream);
函数说明        fileno()用来取得参数stream指定的文件流所使用的文件描述词。
返回值        返回文件描述词。

范例       
#include<stdio.h>
main()
{
  FILE * fp;
  int fd;
  fp=fopen(“/etc/passwd”,”r”);
  fd=fileno(fp);
  printf(“fd=%d\n”,fd);
  fclose(fp);
}
执行       
fd=3


fopen(打开文件)

相关函数        open,fclose
表头文件        #include<stdio.h>
定义函数        FILE * fopen(const char * path,const char * mode);
函数说明        参数path字符串包含欲打开的文件路径及文件名,参数mode字符串则代表着流形态。mode有下列几种形态字符串:
r    打开只读文件,该文件必须存在。
r+   打开可读写的文件,该文件必须存在。
w    打开只写文件,若文件存在则文件长度清为0,即该文件内容会消失。若文件不存在则建立该文件。
w+   打开可读写文件,若文件存在则文件长度清为零,即该文件内容会消失。若文件不存在则建立该文件。
a    以附加的方式打开只写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾,即文件原先的内容会被保留。
a+  以附加方式打开可读写的文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾后,即文件原先的内容会被保留。
上述的形态字符串都可以再加一个b字符,如rb、w+b或ab+等组合,加入b字符用来告诉函数库打开的文件为二进制文件,而非纯文字文件。不过在POSIX系统,包含Linux都会忽略该字符。由fopen()所建立的新文件会具有S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH(0666)权限,此文件权限也会参考umask值。
返回值        文件顺利打开后,指向该流的文件指针就会被返回。若果文件打开失败则返回NULL,并把错误代码存在errno中。
附加说明        一般而言,开文件后会作一些文件读取或写入的动作,若开文件失败,接下来的读写动作也无法顺利进行,所以在fopen()后请作错误判断及处理。

范例       
#include<stdio.h>
main()
{
FILE * fp;
fp=fopen(“noexist”,”a+”);
if(fp= =NULL) return;
fclose(fp);
}


fputc(将一指定字符写入文件流中)

相关函数        fopen,fwrite,fscanf,putc
表头文件        #include<stdio.h>
定义函数        int fputc(int c,FILE * stream);
函数说明        fputc会将参数c转为unsigned char后写入参数stream指定的文件中。
返回值        fputc()会返回写入成功的字符,即参数c。若返回EOF则代表写入失败。

范例       
#include<stdio.h>
main()
{
FILE * fp;
char a[26]=”abcdefghijklmnopqrstuvwxyz”;
int i;
fp= fopen(“noexist”,”w”);
for(i=0;i<26;i++)
fputc(a[i],fp);
fclose(fp);}
fputs(将一指定的字符串写入文件内)

相关函数        fopen,fwrite,fscanf,fputc,putc
表头文件        #include<stdio.h>
定义函数        int fputs(const char * s,FILE * stream);
函数说明        fputs()用来将参数s所指的字符串写入到参数stream所指的文件内。
返回值        若成功则返回写出的字符个数,返回EOF则表示有错误发生。

范例       
请参考fgets()。


fread(从文件流读取数据)

相关函数        fopen,fwrite,fseek,fscanf
表头文件        #include<stdio.h>
定义函数        size_t fread(void * ptr,size_t size,size_t nmemb,FILE * stream);
函数说明        fread()用来从文件流中读取数据。参数stream为已打开的文件指针,参数ptr指向欲存放读取进来的数据空间,读取的字符数以参数size*nmemb来决定。fread()会返回实际读取到的nmemb数目,如果此值比参数nmemb来得小,则代表可能读到了文件尾或有错误发生,这时必须用feof()或ferror()来决定发生什么情况。
返回值        返回实际读取到的nmemb数目。
附加说明       

范例       
#include<stdio.h>
#define nmemb 3
struct test
{
  char name[20];
  int size;
}s[nmemb];
main()
{
FILE * stream;
int i;
stream = fopen(“/tmp/fwrite”,”r”);
fread(s,sizeof(struct test),nmemb,stream);
fclose(stream);
for(i=0;i<nmemb;i++)
  printf(“name[%d]=%-20s:size[%d]=%d\n”,i,s[i].name,i,s[i].size);
}
执行       
name[0]=Linux!                size[0]=6
name[1]=FreeBSD!             size[1]=8
name[2]=Windows2000          size[2]=11


freopen(打开文件)

相关函数        fopen,fclose
表头文件        #include<stdio.h>
定义函数        FILE * freopen(const char * path,const char * mode,FILE * stream);
函数说明        参数path字符串包含欲打开的文件路径及文件名,参数mode请参考fopen()说明。参数stream为已打开的文件指针。freopen()会将原stream所打开的文件流关闭,然后打开参数path的文件。
返回值        文件顺利打开后,指向该流的文件指针就会被返回。如果文件打开失败则返回NULL,并把错误代码存在errno中。

范例       
#include<stdio.h>
main()
{
FILE * fp;
fp=fopen(“/etc/passwd”,”r”);
fp=freopen(“/etc/group”,”r”,fp);
fclose(fp);
}


fseek(移动文件流的读写位置)

相关函数        rewind,ftell,fgetpos,fsetpos,lseek
表头文件        #include<stdio.h>
定义函数        int fseek(FILE * stream,long offset,int whence);
函数说明        fseek()用来移动文件流的读写位置。参数stream为已打开的文件指针,参数offset为根据参数whence来移动读写位置的位移数。参数whence为下列其中一种:SEEK_SET从距文件开头offset位移量为新的读写位置。SEEK_CUR以目前的读写位置往后增加offset个位移量。SEEK_END将读写位置指向文件尾后再增加offset个位移量。
当whence值为SEEK_CUR或SEEK_END时,参数offset允许负值的出现。下列是较特别的使用方式:
1)欲将读写位置移动到文件开头时:fseek(FILE * stream,0,SEEK_SET);
2)欲将读写位置移动到文件尾时:fseek(FILE * stream,0,0SEEK_END);
返回值        当调用成功时则返回0,若有错误则返回-1,errno会存放错误代码。
附加说明        fseek()不像lseek()会返回读写位置,因此必须使用ftell()来取得目前读写的位置。

范例       
#include<stdio.h>
main()
{
FILE * stream;
long offset;
fpos_t pos;
stream=fopen(“/etc/passwd”,”r”);
fseek(stream,5,SEEK_SET);
printf(“offset=%d\n”,ftell(stream));
rewind(stream);
fgetpos(stream,&pos);
printf(“offset=%d\n”,pos);
pos=10;
fsetpos(stream,&pos);
printf(“offset = %d\n”,ftell(stream));
fclose(stream);
}
执行       
offset = 5
offset =0
offset=10


ftell(取得文件流的读取位置)

相关函数        fseek,rewind,fgetpos,fsetpos
表头文件        #include<stdio.h>
定义函数        long ftell(FILE * stream);
函数说明        ftell()用来取得文件流目前的读写位置。参数stream为已打开的文件指针。
返回值        当调用成功时则返回目前的读写位置,若有错误则返回-1,errno会存放错误代码。
错误代码        EBADF  参数stream无效或可移动读写位置的文件流。

范例       
参考fseek()。


fwrite(将数据写至文件流)

相关函数        fopen,fread,fseek,fscanf
表头文件        #include<stdio.h>
定义函数        size_t fwrite(const void * ptr,size_t size,size_t nmemb,FILE * stream);
函数说明        fwrite()用来将数据写入文件流中。参数stream为已打开的文件指针,参数ptr指向欲写入的数据地址,总共写入的字符数以参数size*nmemb来决定。fwrite()会返回实际写入的nmemb数目。
返回值        返回实际写入的nmemb数目。

范例       
#include<stdio.h>
#define set_s (x,y) {strcoy(s[x].name,y);s[x].size=strlen(y);}
#define nmemb 3
struct test
{
char name[20];
int size;
}s[nmemb];
main()
{
FILE * stream;
set_s(0,”Linux!”);
set_s(1,”FreeBSD!”);
set_s(2,”Windows2000.”);
stream=fopen(“/tmp/fwrite”,”w”);
fwrite(s,sizeof(struct test),nmemb,stream);
fclose(stream);
}
执行       
参考fread()。

Rank: 3Rank: 3

主题
0
帖子
174
C币
956 枚
在线时间
32 小时
发表于 2010-3-12 11:27:51 |显示全部楼层
getc(由文件中读取一个字符)

相关函数        read,fopen,fread,fgetc
表头文件        #include<stdio.h>
定义函数        int getc(FILE * stream);
函数说明        getc()用来从参数stream所指的文件中读取一个字符。若读到文件尾而无数据时便返回EOF。虽然getc()与fgetc()作用相同,但getc()为宏定义,非真正的函数调用。
返回值        getc()会返回读取到的字符,若返回EOF则表示到了文件尾。

范例       
参考fgetc()。


getchar(由标准输入设备内读进一字符)

相关函数        fopen,fread,fscanf,getc
表头文件        #include<stdio.h>
定义函数        int getchar(void);
函数说明        getchar()用来从标准输入设备中读取一个字符。然后将该字符从unsigned char转换成int后返回。
返回值        getchar()会返回读取到的字符,若返回EOF则表示有错误发生。
附加说明        getchar()非真正函数,而是getc(stdin)宏定义。

范例       
#include<stdio.h>
main()
{
FILE * fp;
int c,i;
for(i=0li<5;i++)
{
  c=getchar();
  putchar(c);
}
}
执行       
1234 /*输入*/
1234 /*输出*/


gets(由标准输入设备内读进一字符串)

相关函数        fopen,fread,fscanf,fgets
表头文件        #include<stdio.h>
定义函数        char * gets(char *s);
函数说明        gets()用来从标准设备读入字符并存到参数s所指的内存空间,直到出现换行字符或读到文件尾为止,最后加上NULL作为字符串结束。
返回值        gets()若成功则返回s指针,返回NULL则表示有错误发生。
附加说明        由于gets()无法知道字符串s的大小,必须遇到换行字符或文件尾才会结束输入,因此容易造成缓冲溢出的安全性问题。建议使用fgets()取代。

范例       
参考fgets()
mktemp(产生唯一的临时文件名)

相关函数        tmpfile
表头文件        #include<stdlib.h>
定义函数        char * mktemp(char * template);
函数说明        mktemp()用来产生唯一的临时文件名。参数template所指的文件名称字符串中最后六个字符必须是XXXXXX。产生后的文件名会借字符串指针返回。
返回值        文件顺利打开后,指向该流的文件指针就会被返回。如果文件打开失败则返回NULL,并把错误代码存在errno中。
附加说明        参数template所指的文件名称字符串必须声明为数组,如 char template[ ]=”template-XXXXXX”;不可用char * template=”template-XXXXXX”;

范例       
#include<stdlib.h>
main()
{
  char template[ ]=”template-XXXXXX”;
  mktemp(template);
  printf(“template=%s\n”,template);
}


putc(将一指定字符写入文件中)

相关函数        fopen,fwrite,fscanf,fputc
表头文件        #include<stdio.h>
定义函数        int putc(int c,FILE * stream);
函数说明        putc()会将参数c转为unsigned char后写入参数stream指定的文件中。虽然putc()与fputc()作用相同,但putc()为宏定义,非真正的函数调用。
返回值        putc()会返回写入成功的字符,即参数c。若返回EOF则代表写入失败。
范例       
参考fputc()。


putchar(将指定的字符写到标准输出设备)

相关函数        fopen,fwrite,fscanf,fputc
表头文件        #include<stdio.h>
定义函数        int putchar (int c);
函数说明        putchar()用来将参数c字符写到标准输出设备。
返回值        putchar()会返回输出成功的字符,即参数c。若返回EOF则代表输出失败。
附加说明        putchar()非真正函数,而是putc(c,stdout)宏定义。

范例       
参考getchar()。


rewind(重设文件流的读写位置为文件开头)

相关函数        fseek,ftell,fgetpos,fsetpos
表头文件        #include<stdio.h>
定义函数        void rewind(FILE * stream);
函数说明        rewind()用来把文件流的读写位置移至文件开头。参数stream为已打开的文件指针。此函数相当于调用fseek(stream,0,SEEK_SET)。
返回值        无

范例       
参考fseek()
setbuf(设置文件流的缓冲区)

相关函数        setbuffer,setlinebuf,setvbuf
表头文件        #include<stdio.h>
定义函数        void setbuf(FILE * stream,char * buf);
函数说明        在打开文件流后,读取内容之前,调用setbuf()可以用来设置文件流的缓冲区。参数stream为指定的文件流,参数buf指向自定的缓冲区起始地址。如果参数buf为NULL指针,则为无缓冲IO。setbuf()相当于调用:setvbuf(stream,buf,buf?_IOFBF:_IONBF,BUFSIZ);
返回值        无


setbuffer(设置文件流的缓冲区)

相关函数        setlinebuf,setbuf,setvbuf
表头文件        #include<stdio.h>
定义函数        void setbuffer(FILE * stream,char * buf,size_t size);
函数说明        在打开文件流后,读取内容之前,调用setbuffer()可用来设置文件流的缓冲区。参数stream为指定的文件流,参数buf指向自定的缓冲区起始地址,参数size为缓冲区大小。
返回值        无


setlinebuf(设置文件流为线性缓冲区)

相关函数        setbuffer,setbuf,setvbuf
表头文件        #include<stdio.h>
定义函数        void setlinebuf(FILE * stream);
函数说明        setlinebuf()用来设置文件流以换行为依据的无缓冲IO。相当于调用:setvbuf(stream,(char * )NULL,_IOLBF,0);请参考setvbuf()。
返回值        无


setvbuf(设置文件流的缓冲区)

相关函数        setbuffer,setlinebuf,setbuf
表头文件        #include<stdio.h>
定义函数        int setvbuf(FILE * stream,char * buf,int mode,size_t size);
函数说明        在打开文件流后,读取内容之前,调用setvbuf()可以用来设置文件流的缓冲区。参数stream为指定的文件流,参数buf指向自定的缓冲区起始地址,参数size为缓冲区大小,参数mode有下列几种:
_IONBF  无缓冲IO
_IOLBF   以换行为依据的无缓冲IO
_IOFBF   完全无缓冲IO。如果参数buf为NULL指针,则为无缓冲IO。
返回值        无


ungetc(将指定字符写回文件流中)

相关函数        fputc,getchar,getc
表头文件        #include<stdio.h>
定义函数        int ungetc(int c,FILE * stream);
函数说明        ungetc()将参数c字符写回参数stream所指定的文件流。这个写回的字符会由下一个读取文件流的函数取得。
返回值        成功则返回c字符,若有错误则返回EOF。


atexit(设置程序正常结束前调用的函数)

相关函数        _exit,exit,on_exit
表头文件        #include<stdlib.h>
定义函数        int atexit (void (*function)(void));
函数说明        atexit()用来设置一个程序正常结束前调用的函数。当程序通过调用exit()或从main中返回时,参数function所指定的函数会先被调用,然后才真正由exit()结束程序。
返回值        如果执行成功则返回0,否则返回-1,失败原因存于errno中。

范例       
#include<stdlib.h>
void my_exit(void)
{
  printf(“before exit () !\n”);
}
main()
{
  atexit (my_exit);
  exit(0);
}
执行       
before exit()!


execl(执行文件)

相关函数        fork,execle,execlp,execv,execve,execvp
表头文件        #include<unistd.h>
定义函数        int execl(const char * path,const char * arg,....);
函数说明        execl()用来执行参数path字符串所代表的文件路径,接下来的参数代表执行该文件时传递过去的argv〔0〕、argv[1]……,最后一个参数必须用空指针(NULL)作结束。
返回值        如果执行成功则函数不会返回,执行失败则直接返回-1,失败原因存于errno中。

范例       
#include<unistd.h>
main()
{
execl(“/bin/ls”,”ls”,”-al”,”/etc/passwd”,(char * )0);
}
执行       
/*执行/bin/ls -al /etc/passwd */
-rw-r--r--  1  root    root       705 Sep 3 13 :52  /etc/passwd


execlp(从PATH环境变量中查找文件并执行)

相关函数        fork,execl,execle,execv,execve,execvp
表头文件        #include<unistd.h>
定义函数        int execlp(const char * file,const char * arg,……);
函数说明        execlp()会从PATH环境变量所指的目录中查找符合参数file的文件名,找到后便执行该文件,然后将第二个以后的参数当做该文件的argv[0]、argv[1]……,最后一个参数必须用空指针(NULL)作结束。
返回值        如果执行成功则函数不会返回,执行失败则直接返回-1,失败原因存于errno中。
错误代码        参考execve()。

范例       
/* 执行 ls -al /etc/passwd execlp()会依PATH变量中的/bin找到/bin/ls */
#include<unistd.h>
main()
{
  execlp(“ls”,”ls”,”-al”,”/etc/passwd”,(char *)0);
}
执行       
-rw-r--r-- 1  root   root   705 Sep 3 13 :52 /etc/passwd

execv(执行文件)

相关函数        fork,execl,execle,execlp,execve,execvp
表头文件        #include<unistd.h>
定义函数        int execv (const char * path, char * const argv[ ]);
函数说明        execv()用来执行参数path字符串所代表的文件路径,与execl()不同的地方在于execve()只需两个参数,第二个参数利用数组指针来传递给执行文件。
返回值        如果执行成功则函数不会返回,执行失败则直接返回-1,失败原因存于errno中。
错误代码        请参考execve()。

范例       
/* 执行 /bin/ls -al /etc/passwd */
#include<unistd.h>
main()
{
  char * argv[ ]={“ls”,”-al”,”/etc/passwd”,(char*) }};
  execv(“/bin/ls”,argv);
}
执行       
-rw-r--r--  1  root   root  705 Sep 3 13 :52 /etc/passwd


execve(执行文件)

相关函数        fork,execl,execle,execlp,execv,execvp
表头文件        #include<unistd.h>
定义函数        int execve(const char * filename,char * const argv[ ],char * const envp[ ]);
函数说明        execve()用来执行参数filename字符串所代表的文件路径,第二个参数系利用数组指针来传递给执行文件,最后一个参数则为传递给执行文件的新环境变量数组。
返回值        如果执行成功则函数不会返回,执行失败则直接返回-1,失败原因存于errno中。
错误代码        EACCES   1. 欲执行的文件不具有用户可执行的权限。
           2. 欲执行的文件所属的文件系统是以noexec方式挂上。
           3.欲执行的文件或script翻译器非一般文件。
EPERM    1.进程处于被追踪模式,执行者并不具有root权限,欲
执行的文件具有SUID或SGID位。
2.欲执行的文件所属的文件系统是以nosuid方式挂
上,欲执行的文件具有SUID或SGID位元,但执行
者并不具有root权限。
E2BIG      参数数组过大
ENOEXEC   无法判断欲执行文件的执行文件格式,有可能是格式
错误或无法在此平台执行。
EFAULT     参数filename所指的字符串地址超出可存取空间范
围。
ENAMETOOLONG 参数filename所指的字符串太长。
ENOENT   参数filename字符串所指定的文件不存在。
ENOMEM   核心内存不足
ENOTDIR   参数filename字符串所包含的目录路径并非有效目录
EACCES    参数filename字符串所包含的目录路径无法存取,权
限不足
ELOOP     过多的符号连接
ETXTBUSY 欲执行的文件已被其他进程打开而且正把数据写入该
文件中
EIO       I/O存取错误
ENFILE   已达到系统所允许的打开文件总数。
EMFILE   已达到系统所允许单一进程所能打开的文件总数。
EINVAL   欲执行文件的ELF执行格式不只一个PT_INTERP节区
EISDIR    ELF翻译器为一目录
ELIBBAD  ELF翻译器有问题。

范例       
#include<unistd.h>
main()
{
  char * argv[ ]={“ls”,”-al”,”/etc/passwd”,(char *)0};
  char * envp[ ]={“PATH=/bin”,0}
  execve(“/bin/ls”,argv,envp);
}
执行       
-rw-r--r--  1  root  root  705 Sep 3 13 :52 /etc/passwd


execvp(执行文件)

相关函数        fork,execl,execle,execlp,execv,execve
表头文件        #include<unistd.h>
定义函数        int execvp(const char *file ,char * const argv []);
函数说明        execvp()会从PATH环境变量所指的目录中查找符合参数file的文件名,找到后便执行该文件,然后将第二个参数argv传给该欲执行的文件。
返回值        如果执行成功则函数不会返回,执行失败则直接返回-1,失败原因存于errno中。
错误代码        请参考execve()。

范例       
/*请与execlp()范例对照*/
#include<unistd.h>
main()
{
  char * argv[ ] ={ “ls”,”-al”,”/etc/passwd”,0};
  execvp(“ls”,argv);
}
执行       
-rw-r--r-- 1  root  root   705 Sep 3 13 :52 /etc/passwd


exit(正常结束进程)

相关函数        _exit,atexit,on_exit
表头文件        #include<stdlib.h>
定义函数        void exit(int status);
函数说明        exit()用来正常终结目前进程的执行,并把参数status返回给父进程,而进程所有的缓冲区数据会自动写回并关闭未关闭的文件。
返回值        无

范例       
参考wait()


_exit(结束进程执行)

相关函数        exit,wait,abort
表头文件        #include<unistd.h>
定义函数        void _exit(int status);
函数说明        _exit()用来立刻结束目前进程的执行,并把参数status返回给父进程,并关闭未关闭的文件。此函数调用后不会返回,并且会传递SIGCHLD信号给父进程,父进程可以由wait函数取得子进程结束状态。
返回值        无
附加说明        _exit()不会处理标准I/O缓冲区,如要更新缓冲区请使用exit()。

Rank: 3Rank: 3

主题
0
帖子
174
C币
956 枚
在线时间
32 小时
发表于 2010-3-12 11:28:14 |显示全部楼层
vfork(建立一个新的进程)

相关函数        wait,execve
表头文件        #include<unistd.h>
定义函数        pid_t vfork(void);
函数说明        vfork()会产生一个新的子进程,其子进程会复制父进程的数据与堆栈空间,并继承父进程的用户代码,组代码,环境变量、已打开的文件代码、工作目录和资源限制等。Linux使用copy-on-write(COW)技术,只有当其中一进程试图修改欲复制的空间时才会做真正的复制动作,由于这些继承的信息是复制而来,并非指相同的内存空间,因此子进程对这些变量的修改和父进程并不会同步。此外,子进程不会继承父进程的文件锁定和未处理的信号。注意,Linux不保证子进程会比父进程先执行或晚执行,因此编写程序时要留意死锁或竞争条件的发生。
返回值        如果vfork()成功则在父进程会返回新建立的子进程代码(PID),而在新建立的子进程中则返回0。如果vfork失败则直接返回-1,失败原因存于errno中。
错误代码        EAGAIN   内存不足
ENOMEM  内存不足,无法配置核心所需的数据结构空间。

范例       
#include<unistd.h>
main()
{
  if(vfork() = =0)
{
  printf(“This is the child process\n”);
}else{
printf(“This is the parent process\n”);
}
}
执行       
this is the parent process
this is the child process


getpgid(取得进程组识别码)

相关函数        setpgid,setpgrp,getpgrp
表头文件        #include<unistd.h>
定义函数        pid_t getpgid( pid_t pid);
函数说明        getpgid()用来取得参数pid指定进程所属的组识别码。如果参数pid为0,则会取得目前进程的组识别码。
返回值        执行成功则返回组识别码,如果有错误则返回-1,错误原因存于errno中。
错误代码        ESRCH   找不到符合参数pid指定的进程。

范例       
/*取得init 进程(pid=1)的组识别码*/
#include<unistd.h>
mian()
{
  printf(“init gid = %d\n”,getpgid(1));
}
执行       
init gid = 0


getpgrp(取得进程组识别码)

相关函数        setpgid,getpgid,getpgrp
表头文件        #include<unistd.h>
定义函数        pid_t getpgrp(void);
函数说明        getpgrp()用来取得目前进程所属的组识别码。此函数相当于调用getpgid(0);
返回值        返回目前进程所属的组识别码。

范例       
#include<unistd.h>
main()
{
printf(“my gid =%d\n”,getpgrp());
}
执行       
my gid =29546
getpid(取得进程识别码)

相关函数        fork,kill,getpid
表头文件        #include<unistd.h>
定义函数        pid_t getpid(void);
函数说明        getpid()用来取得目前进程的进程识别码,许多程序利用取到的此值来建立临时文件,以避免临时文件相同带来的问题。
返回值        目前进程的进程识别码

范例       
#include<unistd.h>
main()
{
printf(“pid=%d\n”,getpid());
}
执行       
pid=1494 /*每次执行结果都不一定相同*/


getppid(取得父进程的进程识别码)

相关函数        fork,kill,getpid
表头文件        #include<unistd.h>
定义函数        pid_t getppid(void);
函数说明        getppid()用来取得目前进程的父进程识别码。
返回值        目前进程的父进程识别码。

范例       
#include<unistd.h>
main()
{
printf(“My parent ‘pid =%d\n”,getppid());
}
执行       
My parent ‘pid =463


getpriority(取得程序进程执行优先权)

相关函数        setpriority,nice
表头文件        #include<sys/time.h>
#include<sys/resource.h>
定义函数        int getpriority(int which,int who);
函数说明        getpriority()可用来取得进程、进程组和用户的进程执行优先权。参数which有三种数值,参数who则依which值有不同定义:
which            who                   代表的意义        
PRIO_PROCESS  who             为进程识别码
PRIO_PGRP    who               为进程的组识别码
PRIO_USER      who            为用户识别码
此函数返回的数值介于-20至20之间,代表进程执行优先权,数值越低代表有较高的优先次序,执行会较频繁。
返回值        返回进程执行优先权,如有错误发生返回值则为-1且错误原因存于errno。
附加说明        由于返回值有可能是-1,因此要同时检查errno是否存有错误原因。最好在调用次函数前先清除errno变量。
错误代码        ESRCH  参数which或who可能有错,而找不到符合的进程
EINVAL  参数which值错误。


nice(改变进程优先顺序)

相关函数        setpriority,getpriority
表头文件        #include<unistd.h>
定义函数        int nice(int inc);
函数说明        nice()用来改变进程的进程执行优先顺序。参数inc数值越大则优先顺序排在越后面,即表示进程执行会越慢。只有超级用户才能使用负的inc值,代表优先顺序排在前面,进程执行会较快。
返回值        如果执行成功则返回0,否则返回-1,失败原因存于errno中。
错误代码        EPERM 一般用户企图转用负的参数inc值改变进程优先顺序。


on_exit(设置程序正常结束前调用的函数)

相关函数        _exit,atexit,exit
表头文件        #include<stdlib.h>
定义函数        int on_exit(void (* function)(int, void*),void *arg);
函数说明        on_exit()用来设置一个程序正常结束前调用的函数。当程序通过调用exit()或从main中返回时,参数function所指定的函数会先被调用,然后才真正由exit()结束程序。参数arg指针会传给参数function函数,详细情况请见范例。
返回值        如果执行成功则返回0,否则返回-1,失败原因存于errno中。
附加说明       

范例       
#include<stdlib.h>
void my_exit(int status,void *arg)
{
printf(“before exit()!\n”);
printf(“exit (%d)\n”,status);
printf(“arg = %s\n”,(char*)arg);
}
main()
{
char * str=”test”;
on_exit(my_exit,(void *)str);
exit(1234);
}
执行       
before exit()!
exit (1234)
arg = test


setpgid(设置进程组识别码)

相关函数        getpgid,setpgrp,getpgrp
表头文件        #include<unistd.h>
定义函数        int setpgid(pid_t pid,pid_t pgid);
函数说明        setpgid()将参数pid指定进程所属的组识别码设为参数pgid指定的组识别码。如果参数pid为0,则会用来设置目前进程的组识别码,如果参数pgid为0,则会以目前进程的进程识别码来取代。
返回值        执行成功则返回组识别码,如果有错误则返回-1,错误原因存于errno中。
错误代码        EINVAL  参数pgid小于0。
EPERM  进程权限不足,无法完成调用。
ESRCH  找不到符合参数pid指定的进程。


setpgrp(设置进程组识别码)

相关函数        getpgid,setpgid,getpgrp
表头文件        #include<unistd.h>
定义函数        int setpgrp(void);
函数说明        setpgrp()将目前进程所属的组识别码设为目前进程的进程识别码。此函数相当于调用setpgid(0,0)。
返回值        执行成功则返回组识别码,如果有错误则返回-1,错误原因存于errno中。



setpriority(设置程序进程执行优先权)

相关函数        getpriority,nice
表头文件        #include<sys/time.h>
#include<sys/resource.h>
定义函数        int setpriority(int which,int who, int prio);
函数说明        setpriority()可用来设置进程、进程组和用户的进程执行优先权。参数which有三种数值,参数who则依which值有不同定义:
which                 who代表的意义                  
PRIO_PROCESS    who为进程识别码
PRIO_PGRP         who为进程的组识别码
PRIO_USER        who为用户识别码
参数prio介于-20至20之间。代表进程执行优先权,数值越低代表有较高的优先次序,执行会较频繁。此优先权默认是0,而只有超级用户(root)允许降低此值。
返回值        执行成功则返回0,如果有错误发生返回值则为-1,错误原因存于errno。
ESRCH    参数which或who可能有错,而找不到符合的进程
EINVAL    参数which值错误。
EPERM    权限不够,无法完成设置
EACCES   一般用户无法降低优先权


system(执行shell命令)

相关函数        fork,execve,waitpid,popen
表头文件        #include<stdlib.h>
定义函数        int system(const char * string);
函数说明        system()会调用fork()产生子进程,由子进程来调用/bin/sh-c string来执行参数string字符串所代表的命令,此命令执行完后随即返回原调用的进程。在调用system()期间SIGCHLD信号会被暂时搁置,SIGINT和SIGQUIT信号则会被忽略。
返回值        如果system()在调用/bin/sh时失败则返回127,其他失败原因返回-1。若参数string为空指针(NULL),则返回非零值。如果system()调用成功则最后会返回执行shell命令后的返回值,但是此返回值也有可能为system()调用/bin/sh失败所返回的127,因此最好能再检查errno来确认执行成功。
附加说明        在编写具有SUID/SGID权限的程序时请勿使用system(),system()会继承环境变量,通过环境变量可能会造成系统安全的问题。

范例       
#include<stdlib.h>
main()
{
system(“ls -al /etc/passwd /etc/shadow”);
}
执行       
-rw-r--r--  1  root   root    705 Sep 3 13 :52 /etc/passwd
-r---------  1  root   root    572 Sep 2 15 :34 /etc/shadow


wait(等待子进程中断或结束)

相关函数        waitpid,fork
表头文件        #include<sys/types.h>
#include<sys/wait.h>
定义函数        pid_t wait (int * status);
函数说明        wait()会暂时停止目前进程的执行,直到有信号来到或子进程结束。如果在调用wait()时子进程已经结束,则wait()会立即返回子进程结束状态值。子进程的结束状态值会由参数status返回,而子进程的进程识别码也会一快返回。如果不在意结束状态值,则参数status可以设成NULL。子进程的结束状态值请参考waitpid()。
返回值        如果执行成功则返回子进程识别码(PID),如果有错误发生则返回-1。失败原因存于errno中。
附加说明       

范例       
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
main()
{
  pid_t pid;
  int status,i;
  if(fork()= =0){
printf(“This is the child process .pid =%d\n”,getpid());
exit(5);
}else{
sleep(1);
printf(“This is the parent process ,wait for child...\n”;
pid=wait(&status);
i=WEXITSTATUS(status);
printf(“child’s pid =%d .exit status=^d\n”,pid,i);
}
}
执行       
This is the child process.pid=1501
This is the parent process .wait for child...
child’s pid =1501,exit status =5


waitpid(等待子进程中断或结束)

相关函数        wait,fork
表头文件        #include<sys/types.h>
#include<sys/wait.h>
定义函数        pid_t waitpid(pid_t pid,int * status,int options);
函数说明        waitpid()会暂时停止目前进程的执行,直到有信号来到或子进程结束。如果在调用wait()时子进程已经结束,则wait()会立即返回子进程结束状态值。子进程的结束状态值会由参数status返回,而子进程的进程识别码也会一快返回。如果不在意结束状态值,则参数status可以设成NULL。参数pid为欲等待的子进程识别码,其他数值意义如下:
pid<-1  等待进程组识别码为pid绝对值的任何子进程。
pid=-1  等待任何子进程,相当于wait()。
pid=0   等待进程组识别码与目前进程相同的任何子进程。
pid>0   等待任何子进程识别码为pid的子进程。
参数option可以为0或下面的OR组合:
WNOHANG  如果没有任何已经结束的子进程则马上返回,不予以等待。
WUNTRACED 如果子进程进入暂停执行情况则马上返回,但结束状态不予以理会。
子进程的结束状态返回后存于status,底下有几个宏可判别结束情况:
WIFEXITED(status)如果子进程正常结束则为非0值。
WEXITSTATUS(status)取得子进程exit()返回的结束代码,一般会先用WIFEXITED来判断是否正常结束才能使用此宏。
WIFSIGNALED(status)如果子进程是因为信号而结束则此宏值为真
WTERMSIG(status) 取得子进程因信号而中止的信号代码,一般会先用WIFSIGNALED来判断后才使用此宏。
WIFSTOPPED(status) 如果子进程处于暂停执行情况则此宏值为真。一般只有使用WUNTRACED时才会有此情况。
WSTOPSIG(status) 取得引发子进程暂停的信号代码,一般会先用WIFSTOPPED来判断后才使用此宏。
返回值        如果执行成功则返回子进程识别码(PID),如果有错误发生则返回-1。失败原因存于errno中。

范例       
参考wait()。


fprintf(格式化输出数据至文件)

相关函数        printf,fscanf,vfprintf
表头文件        #include<stdio.h>
定义函数        int fprintf(FILE * stream, const char * format,.......);
函数说明        fprintf()会根据参数format字符串来转换并格式化数据,然后将结果输出到参数stream指定的文件中,直到出现字符串结束(‘\0‘)为止。
返回值        关于参数format字符串的格式请参考printf()。成功则返回实际输出的字符数,失败则返回-1,错误原因存于errno中。

范例       
#include<stdio.h>
main()
{
int i = 150;
int j = -100;
double k = 3.14159;
fprintf(stdout,”%d  %f  %x \n”,j,k,i);
fprintf(stdout,”%2d %*d\n”,i,2,i);
}
执行       
-100 3.141590 96
150 150


fscanf(格式化字符串输入)

相关函数        scanf,sscanf
表头文件        #include<stdio.h>
定义函数        int fscanf(FILE * stream ,const char *format,....);
函数说明        fscanf()会自参数stream的文件流中读取字符串,再根据参数format字符串来转换并格式化数据。
格式转换形式请参考scanf()。转换后的结构存于对应的参数内。
返回值        成功则返回参数数目,失败则返回-1,错误原因存于errno中。
附加说明       

范例       
#include<stdio.h>
main()
{
int i;
unsigned int j;
char s[5];
fscanf(stdin,”%d %x %5[a-z] %*s %f”,&i,&j,s,s);
printf(“%d %d %s \n”,i,j,s);
}
执行       
10 0x1b aaaaaaaaa bbbbbbbbbb  /*从键盘输入*/
10 27 aaaaa


printf(格式化输出数据)

相关函数        scanf,snprintf
表头文件        #include<stdio.h>
定义函数        int printf(const char * format,.............);
函数说明        printf()会根据参数format字符串来转换并格式化数据,然后将结果写出到标准输出设备,直到出现字符串结束(’\0’)为止。
参数format字符串可包含下列三种字符类型:
1.一般文本,伴随直接输出。
2.ASCII控制字符,如\t、\n等。
3.格式转换字符。
格式转换为一个百分比符号(%)及其后的格式字符所组成。一般而言,每个%符号在其后都必需有一printf()的参数与之相呼应(只有当%%转换字符出现时会直接输出%字符),而欲输出的数据类型必须与其相对应的转换字符类型相同。
printf()格式转换的一般形式如下:
  %〔flags〕〔width〕〔.prec〕type
以中括号括起来的参数为选择性参数,而%与type则是必要的。底下先介绍type的几种形式:
整数:
%d  整数的参数会被转成一有符号的十进制数字
%u  整数的参数会被转成一无符号的十进制数字
%o  整数的参数会被转成一无符号的八进制数字
%x  整数的参数会被转成一无符号的十六进制数字,并以小写abcdef表示
%X   整数的参数会被转成一无符号的十六进制数字,并以大写ABCDEF表示
浮点型数:
%f  double型的参数会被转成十进制数字,并取到小数点以下六位,四舍五入。
%e  double型的参数以指数形式打印,有一个数字会在小数点前,六位数字在小数点后,而在指数部分会以小写的e来表示。
%E  与%e作用相同,唯一区别是指数部分将以大写的E来表示。
%g  double型的参数会自动选择以%f或%e的格式来打印,其标准是根据欲打印的数值及所设置的有效位数来决定。
%G 与%g作用相同,唯一区别在以指数形态打印时会选择%E格式。
字符及字符串:
%c  整型数的参数会被转成unsigned char型打印出。
%s  指向字符串的参数会被逐字输出,直到出现NULL字符为止
%p  如果是参数是“void *”型指针则使用十六进制格式显示。
prec有几种情况:
1. 正整数的最小位数。
2.在浮点型数中代表小数位数
3.在%g格式代表有效位数的最大值。
4.在%s格式代表字符串的最大长度。
5.若为× 符号则代表下个参数值为最大长度。
width为参数的最小长度,若此栏并非数值,而是*符号,则表示以下一个参数当做参数长度。
flags有下列几种情况:
-    此旗标会将一数值向左对齐。
+   一般在打印负数时,printf()会加印一个负号,整数则不加任何负号。此旗标会使得在打印正数前多一个正号(+)。
#   此旗标会根据其后转换字符的不同而有不同含义。当在类型为o之前(如%#o),则会在打印八进制数值前多印一个o。而在类型为x之前(%#x)则会在打印十六进制数前多印’0x’,在型态为e、E、f、g或G之前则会强迫数值打印小数点。在类型为g或G之前时则同时保留小数点及小数位数末尾的零。
0   当有指定参数时,无数字的参数将补上0。默认是关闭此旗标,所以一般会打印出空白字符。
返回值        成功则返回实际输出的字符数,失败则返回-1,错误原因存于errno中。

范例       
#include<stdio.h>
main()
{
int i = 150;
int j = -100;
double k = 3.14159;
printf(“%d %f %x\n”,j,k,i);
printf(“%2d %*d\n”,i,2,i);  /*参数2会代入格式*中,而与%2d同意义*/
}
执行       
-100  3.14159  96
150  150


sacnf(格式化字符串输入)

相关函数        fscanf,snprintf
表头文件        #include<stdio.h>
定义函数        int scanf(const char * format,.......);
函数说明        scanf()会将输入的数据根据参数format字符串来转换并格式化数据。scanf()格式转换的一般形式如下:
%[*][size][l][h]type
以中括号括起来的参数为选择性参数,而%与type则是必要的。
* 代表该对应的参数数据忽略不保存。
size  为允许参数输入的数据长度。
l  输入的数据数值以long int 或double型保存。
h 输入的数据数值以short int 型保存。
底下介绍type的几种形式:
%d 输入的数据会被转成一有符号的十进制数字(int)。
%i  输入的数据会被转成一有符号的十进制数字,若输入数据以“0x”或“0X”开头代表转换十六进制数字,若以“0”开头则转换八进制数字,其他情况代表十进制。
%0 输入的数据会被转换成一无符号的八进制数字。
%u 输入的数据会被转换成一无符号的正整数。
%x 输入的数据为无符号的十六进制数字,转换后存于unsigned int型变量。
%X 同%x
%f 输入的数据为有符号的浮点型数,转换后存于float型变量。
%e 同%f
%E 同%f
%g 同%f
%s 输入数据为以空格字符为终止的字符串。
%c 输入数据为单一字符。
[]  读取数据但只允许括号内的字符。如[a-z]。
[^] 读取数据但不允许中括号的^符号后的字符出现,如[^0-9].
返回值        成功则返回参数数目,失败则返回-1,错误原因存于errno中。

范例       
#include <stdio.h>
main()
{
int i;
unsigned int j;
char s[5];
scanf(“%d %x %5[a-z] %*s %f”,&i,&j,s,s);
printf(“%d %d %s\n”,i,j,s);
}
执行       
10 0x1b aaaaaaaaaa   bbbbbbbbbb
10 27  aaaaa


sprintf(格式化字符串复制)

相关函数        printf,sprintf
表头文件        #include<stdio.h>
定义函数        int sprintf( char *str,const char * format,.........);
函数说明        sprintf()会根据参数format字符串来转换并格式化数据,然后将结果复制到参数str所指的字符串数组,直到出现字符串结束(’\0’)为止。关于参数format字符串的格式请参考printf()。
返回值        成功则返回参数str字符串长度,失败则返回-1,错误原因存于errno中。
附加说明        使用此函数得留意堆栈溢出,或改用snprintf()。

范例       
#include<stdio.h>
main()
{
char * a=”This is string A!”;
char buf[80];
sprintf(buf,”>>> %s<<<\n”,a);
printf(“%s”.buf);
}
执行       
>>>This is string A!<<<

Rank: 3Rank: 3

主题
0
帖子
174
C币
956 枚
在线时间
32 小时
发表于 2010-3-12 11:28:40 |显示全部楼层
sscanf(格式化字符串输入)

相关函数        scanf,fscanf
表头文件        #include<stdio.h>
定义函数        int sscanf (const char *str,const char * format,........);
函数说明        sscanf()会将参数str的字符串根据参数format字符串来转换并格式化数据。格式转换形式请参考scanf()。转换后的结果存于对应的参数内。
返回值        成功则返回参数数目,失败则返回-1,错误原因存于errno中。

范例       
#include<stdio.h>
main()
{
int i;
unsigned int j;
char input[ ]=”10 0x1b aaaaaaaa  bbbbbbbb”;
char s[5];
sscanf(input,”%d %x %5[a-z] %*s %f”,&i,&j,s,s);
printf(“%d %d %s\n”,i,j,s);
}
执行       
10 27 aaaaa


vfprintf(格式化输出数据至文件)

相关函数        printf,fscanf,fprintf
表头文件        #include<stdio.h>
#include<stdarg.h>
定义函数        int vfprintf(FILE *stream,const char * format,va_list ap);
函数说明        vfprintf()会根据参数format字符串来转换并格式化数据,然后将结果输出到参数stream指定的文件中,直到出现字符串结束(’\0’)为止。关于参数format字符串的格式请参考printf()。va_list用法请参考附录C或vprintf()范例。
返回值        成功则返回实际输出的字符数,失败则返回-1,错误原因存于errno中。

范例       
参考fprintf()及vprintf()。


vfscanf(格式化字符串输入)

相关函数        scanf,sscanf,fscanf
表头文件        #include<stdio.h>
定义函数        int vfscanf(FILE * stream,const char * format ,va_list ap);
函数说明        vfscanf()会自参数stream的文件流中读取字符串,再根据参数format字符串来转换并格式化数据。格式转换形式请参考scanf()。转换后的结果存于对应的参数内。va_list用法请参考附录C或vprintf()。
返回值        成功则返回参数数目,失败则返回-1,错误原因存于errno中。

范例       
参考fscanf()及vprintf()。


vprintf(格式化输出数据)

相关函数        printf,vfprintf,vsprintf
表头文件        #include<stdio.h>
#include<stdarg.h>
定义函数        int vprintf(const char * format,va_list ap);
函数说明        vprintf()作用和printf()相同,参数format格式也相同。
va_list为不定个数的参数列,用法及范例请参考附录C。
返回值        成功则返回实际输出的字符数,失败则返回-1,错误原因存于errno中。

范例       
#include<stdio.h>
#include<stdarg.h>
int my_printf( const char *format,……)
{
va_list ap;
int retval;
va_start(ap,format);
printf(“my_printf( ):”);
retval = vprintf(format,ap);
va_end(ap);
return retval;
}
main()
{
int i = 150,j = -100;
double k = 3.14159;
my_printf(“%d  %f  %x\n”,j,k,i);
my_printf(“%2d %*d\n”,i,2,i);
}
执行       
my_printf() : -100  3.14159  96
my_printf() : 150 150
vscanf(格式化字符串输入)

相关函数        vsscanf,vfscanf
表头文件        #include<stdio.h>
#include<stdarg.h>
定义函数        int vscanf( const char * format,va_list ap);
函数说明        vscanf()会将输入的数据根据参数format字符串来转换并格式化数据。格式转换形式请参考scanf()。转换后的结果存于对应的参数内。va_list用法请参考附录C或vprintf()范例。
返回值        成功则返回参数数目,失败则返回-1,错误原因存于errno中。

范例       
请参考scanf()及vprintf()。


vsprintf(格式化字符串复制)

相关函数        vnsprintf,vprintf,snprintf
表头文件        #include<stdio.h>
定义函数        int vsprintf( char * str,const char * format,va_list ap);
函数说明        vsprintf()会根据参数format字符串来转换并格式化数据,然后将结果复制到参数str所指的字符串数组,直到出现字符串结束(’\0’)为止。关于参数format字符串的格式请参考printf()。va_list用法请参考附录C或vprintf()范例。
返回值        成功则返回参数str字符串长度,失败则返回-1,错误原因存于errno中。

范例       
请参考vprintf()及vsprintf()。



vsscanf(格式化字符串输入)

相关函数        vscanf,vfscanf
表头文件        #include<stdio.h>
定义函数        int vsscanf(const char * str,const char * format,va_list ap);
函数说明        vsscanf()会将参数str的字符串根据参数format字符串来转换并格式化数据。格式转换形式请参考附录C或vprintf()范例。
返回值        成功则返回参数数目,失败则返回-1,错误原因存于errno中。

范例       
请参考sscanf()及vprintf()。


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

Rank: 3Rank: 3

主题
0
帖子
174
C币
956 枚
在线时间
32 小时
发表于 2010-3-12 11:28:56 |显示全部楼层
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  核心内存不足。

Rank: 3Rank: 3

主题
0
帖子
174
C币
956 枚
在线时间
32 小时
发表于 2010-3-12 11:29:11 |显示全部楼层
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
您需要登录后才可以回帖 登录 | 加入社区!

C语言 ( 粤ICP备11042647号-2 )

GMT+8, 2012-2-7 22:15

©2009-2011 cyuyan.com.cn

回顶部