Unix API 列表

其實man最實在.......

// restrict 表明所限定的指針是訪問一個數據唯一且初始的方式，不會有其他指針指向該數據，是用於編譯器優化處理的一種方式。
// p.274
#include <stdlib.h>
void abort(void);     
// 終止

#include <sys/socket.h>
int accept(int sockfd,struct sockaddr * restrict addr, socklen_t * restrict len);

#include <unistd.h>
int access(const char * pathname,int mode);//mode: R_OK,W_OK,X_OK,F_OK

#include <unistd.h>
unsigned int alarm(unsigned int seconds);

#include <time.h>
char * asctime(const struct tm *tmpptr);

#include <stdlib.h>
int atexit(void (*func)(void));

#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr * addr, socklen_t len);

#include <stdlib.h>
void * calloc(size_t nobj, size_t size);

#include <termios.h>
speed_t cfgetispeed(const struct termios * termptr);

#include <termios.h>
speed_t cfgetospeed(const struct termios * termptr);

#include <termios.h>
int cfsetispeed(struct termios * termptr, speed_t speed);

#include <termios.h>
int cfsetospeed(struct termios * termptr, speed_t speed);

#include <unistd.h>
int chdir(const char * pathname);

#include <sys/stat.h>
int chmod(const char * pathname, mode_t mode);
// mode: S_IS[UG]ID, S_ISVTX, S_I[RWX](USR|GRP|OTH)

#include <unistd.h>
int chown(const char * pathname, uid_t owner, gid_t group);

#include <stdio.h>
void clearerr(FILE * fp);

#include <unistd.h>
int close(int filedes);

#include <dirent.h>
int closedir(DIR * dp);

#include <syslog.h>
void closelog(void);

#include <sys/socket.h>
unsigned char * CMSG_DATA(struct cmsghdr * cp);

#include <sys/socket.h>
struct cmsghdr * CMSG_FIRSTHDR(struct msghdr *mp);

#include <sys/socket.h>
unsigned int CMSG_LEN(unsigned int nbytes);

#include <sys/socket.h>
struct cmsghdr * CMSG_NXTHDR(struct msghdr *mp,struct cmsghdr *cp);

#include <sys/socket.h>
int connect(int fd,const struct sockaddr * addr, socklen_t len);

#include <fcntl.h>
int create(const char *pathname, mode_t mode);
// mode: S_IS[UG]ID, S_ISVTX, S_I[RWX](USR|GRP|OTH)

#include <stdio.h>
char *ctermid(char *ptr);

#include <time.h>
char * ctime*(const time_t * calptr);

#include <unistd.h>
int dup(int filedes);

#include <unistd.h>
int dup2(int filedes, int filedes2);

#include <grp.h>
void endgrent(void);

#include <netdb.h>
void endhostent(void);

#include <netdb.h>
void endnetent(void);

#include <netdb.h>
void endprotoent(void);

#include <pwd.h>
void endpwent(void);

#include <netdb.h>
void endservent(void);

#include <shadow.h>
void endspent(void);

#include <unistd.h>
int execl(const char *pathname, const char *arg0,.../* (char *)0*/);

#include <unistd.h>
int execle(const char *pathname, const char *arg0,.../* (char *)0*/,char * const envp[]);

#include <unistd.h>
int execlp(const char *filename, const char *arg0,.../* (char *)0*/);

#include <unistd.h>
int execv(const char *pathname, char *argv[]);

#include <unistd.h>
int execv(const char *pathname, char *argv[],char * envp[]);

#include <unistd.h>
int execv(const char *filename, char *argv[]);

#include <stdlib.h>
void _Exit(int status);

#include <unist.h>
void _exit(int status);

#include <stdlib.h>
void exit(int status);

#include <stropts.h>
int fattach(int filedes, const char * path);

#include <unistd.h>
int fchdir(int filedes);

#include <sys/stat.h>
int fchmod(int filedes, mode_t mode);
// mode: S_IS[UG]ID, S_ISVTX, S_I[RWX](USR|GRP|OTH)

#include <unistd.h>
int fchown(int filedes, uid_t owner, gid_t group);

#include <stdio.h>
int fclose(FILE * fp);

#include <fcntl.h>
int fcntl(int filedes, int cmd, ... /* int arg */);
// cmd: F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_SETFL
// 		F_GETOWN, F_SETOWN, F_GETLK, F_SETLK, F_SETLKW

#include <unistd.h>
int fdatasync(int filedes);

#include <sys/select.h>
void FD_CLR(int fd, fd_set * fdset);

#include <stropts.h>
int fdatach(const char * path);

#include <sys/select.h>
int FD_ISSET(int fd, fd_set * fdset);

#include <stdio.h>
FILE * fdopen(int fd, const char * type);

#include <sys/select.h>
void FD_SET(int fd, fd_set * fdset);

#include <.h>
void FD_ZERO(fd_set * fd_set);

#include <stdio.h>
int feof(FILE * fp);

#include <stdio.h>
int ferror(FILE * fp);

#include <stdio.h>
int fflush(FILE * fp);

#include <stdio.h>
int fgetc(FILE * fp);

#include <stdio.h>
int fgetpos(FILE * restrict fp, fpos_t * restrict pos);

#include <stdio.h>
char *fgets(char *restrict buf, int n, FILE* restrict fp);

#include <stdio.h>
int fileno(FILE * fp);

#include <stdio.h>
void flockfile(FILE *fp);

#include <stdio.h>
FILE * fopen(const char * restrict pathname, const char * restrict type);
// type : "r","w","a","r+","w+","a+"

#include <unistd.h>
pid_t fork(void);

#include <unist.h>
long fpathconf(int filedes, int name);

#include <stdio.h>
int fprintf(FILE * restrict fp, const char * restrict formate,...);

#include <stdio.h>
int fputc(int c, FILE * fp);

#include <stdio.h>
int fputs(const char * restrict str, FILE * restrict fp);

#include <stdio.h>
size_t fread(void * restrict ptr, size_t size, size_t nobj, FILE * restrict fp);

#include <stdlib.h>
void free(void * ptr);

#include <sys/socket.h>
#include <netdb.h>
void freeaddrinfo(struct addrinfo * ai);

#include <stdio.h>
FILE * freopen(const char * restrict pathname, const char * restrict type, FILE * restrict fp);

#include <stdio.h> 
int fscanf(FILE * restrict fp, const char * restrict format, ...);

#include <stdio.h>
int fseek(FILE * fp, long offset, int whence);
// whence: SEEK_SET, SEEK_CUR, SEEK_END

#include <stdio.h>
int fseeko(FILE *fp, off_t offset, int whence);
// whence: SEEK_SET, SEEK_CUR, SEEK_END

#include <stdio.h>
int fsetpos(FILE * fp, const fpos_t * pos);

#include <sys/stat.h>
int fstat(int filedes, struct stat * buf);

#include <unistd.h>
int fsync(int filedes);

#include <stdio.h>
long ftell(FILE * fp);

#include <stdio.h>
off_t ftello(FILE * fp);

#include <sys/ipc.h>
key_t ftok(const char * path, int id);

#include <unistd.h>
int ftruncate(int filedes, off_t length);

#include <stdio.h>
int ftrylockfile(FILE * fp);

#include <stdio.h>
int funlockfile(FILE * fp);

#include <stdio.h>
#include <wchar.h>
int fwide(FILE * fp, int mode);

#include <stdio.h>
size_t fwrite(const void * restrict ptr, size_t size, size_t nobj, FILE * restrict fp);

#include <netdb.h>
const char * gai_strerror(int error);

#include <netdb.h>
#include <sys/socket.h>
int getaddrinfo(const char * restrict host, const char * restrict service,
				const struct addrinfo * restrict hint,
				struct addrinfo ** restrict res);

#include <stdio.h>
int getc(FILE * fp);

#include <stdio.h>
int getchar(void);

#include <stdio.h>
int getchar_unlocked(FILE * fp);

#include <unistd.h>
char * getcwd(char * buf, size_t size);

#include <unistd.h>
gid_t getegid(void);

#include <stdlib.h>
char * getenv(const char * name);

#include <unistd.h>
uid_t geteuid(void);

#include <unistd.h>
gid_t getgid(void);

#include <grp.h>
struct group * getgrent(void);

#include <grp.h>
struct group * getgrgid(gid_t gid);

#include <grp.h>
struct group * getgrnam(const char * name);

#include <unistd.h>
int getgroups(int gidsetsize, gid_t grouplist[]);

#include <netdb.h>
struct hostnet *gethostent(void);

#include <unistd.h>
int gethostname(char * name, int namelen);

#include <unistd.h>
char * getlogin(void);

#include <stropts.h>
int getmsg(int filedes, struct strbuf * restrict ctlptr, 
			struct strbuf* restrict dataptr, int * restrict flagptr);

#include <sys/socket.h>
#include <netdb.h>
int getnameinfo(const struct sockaddr * restrict addr, socklen_t alen
				char * restrict host, socklen_t hostlen, char * restrict service,
				socklen_t servlen, unsigned int flags);

#include <netdb.h>
struct netent * getnetbyaddr(uint32_t ,int type);

#include <netdb.h>
struct netent * getnetbyname(const  char * name);

#include <netdb.h>
struct netnet * getnetent(void);

#include <fcntl.h>
extern int optind,opterr,optopt;
extern char * optarg;
int getopt(int argc, char * const argv[], const char * options);

#include <sys/socket.h>
int getpeername(int sockfd, struct sockaddr * restrict addr, socklen_t * restrict alenp);

#include <unistd.h>
pid_t getpgid(pid_t pid);

#include <unistd.h>
pid_t getpgrp(void);

#include <unistd.h>
pid_t getpid(void);

#include <stropts.h>
int getpmsg(int filedes, struct strbuf * restrict ctlptr, 
			struct strbuf * restrict dataptr, int * restrict bandptr,
			int * restrict flagptr);

#include <unistd.h>
pid_t getppid(void);

#include <netdb.h>
struct protoent * getprotobyname(const char * name);

#include <netdb.h>
struct protoent * getprotobynumber(int proto);

#include <netdb.h>
struct protoent * getprotoent(void);

#include <pwd.h>
struct passwd * getpwent(void);

#include <pwd.h>
struct passwd * getpwname(const char *name);

#include <pwd.h>
struct passwd * getpwuid(uid_t uid);

#include <sys/resource.h>
int getrlimit(int resource ,struct rlimit * rlptr);

#include <stdio.h>
char * gets(char * buf);

#include <netdb.h>
struct servent * getservbyname(const char * name ,const char * proto);

#include <netdb.h>
struct servent * getservbyport(int port, const char * proto);

#include <netdb.h>
struct servent * getservent(void);

#include <unistd.h>
pid_t getsid(pid_t pid);

#include <sys/socket.h>
int getsockname(int sockfd, struct sockaddr * restrict addr, socklen_t * restrict alenp);

#include <sys/socket.h>
int getsockopt(int sockfd, int level, int option, void * restrict val, socklen_t * restrict lenp);

#include <shadow.h>
struct spwd * getspent(void);

#include <shadow.h>
struct spwd * getspnam(const char * name);

#include <sys/time.h>
int gettimeofday(struct timeval * restrict tp, void * restrict tzp);

#include <unistd.h>
uid_t getuid(void);

#include <time.h>
struct tm * gmtime(const time_t * calptr);

#include <stdlib.h>
int grantpt(int filedes);

#include <arpa/inet.h>
uint32_t htonl(uint32_t hostint32);

#include <arpa/inet.h>
uint16_t htons(uint16_t hostint16);

#include <arpa/inet.h>
const char * inet_ntop(int domain,const void* restrict addr, char * restrict str, socklen_t size);
#include <arpa/inet.h>
int inet_pton(int domain, const void * restrict str, void * restrict addr);

#include <grp.h>
#include <unistd.h>
int initgroups(const char * username ,gid_t basegid);

#include <unistd.h>
#include <sys/ioctl.h>
#include <stropts.h>
int ioctl(int filedes, int request, ...);



#include <stropts.h>
int isastream(int filedes);

#include <unistd.h>
int isatty(int filedes);

#include <signal.h>
int kill(pid_t pid, int signo);

#include <unistd.h>
int lchown(const char * pathname ,uid_t owner, gid_t group);

#include <unistd.h>
int link(const char * existingpath, const char * newpath);

#include <sys/socket.h>
int listen(int sockfd, int backlog);

#include <time.h>
struct tm * localtime(const time_t * calptr);

#include <setjump.h>
void longjmp(jmp_buf env, int val);

#include <unistd.h> 
off_t lseek(int filedes, off_t offset, int whence);

#include <sys/stat.h>
int lstat(const char * restrict pathname, struct stat * restrict buf);

#include <stdlib.h>
void * malloc(size_t size);

#include <sys/stat.h>
int mkdir(const char * pathname, mode_t mode);

#include <sys/stat.h>
int mkfifo(const char * pathname, mode_t mode);

#include <stdlib.h>
int mkstemp(char * template);

#include <time.h>
tiem_t mktime(struct tm * tmptr);

#include <sys/mman.h>
caddr_t * mmap(void * addr, size_t len, int  prot, int flag, int filedes, off_t off);
// prot: PROT_READ PROT_WRITE PROT_EXEC PROT_NONE
// flag: MAP_FIXED MAP_SHARED MAP_PRIVATE

#include <sys/mman.h>
int mprotect(void * addr,size_t len, int prot);

#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds * buf);

#include <sys/msg.h>
int msgget(key_t key, int flag);

#include <sys/msg.h>
ssize_t msgrcv(int msqid, void * ptr, size_t nbytes, long type, int flag);

#include <sys/msg.h>
int msgsnd(int msqid,const void * ptr, size_t nbytes, int flag);

#include <sys/mman.h>
int msync(void * addr, size_t len, int flags);

#include <sys/mman.h>
int munmap(caddr_t addr, size_t len);

#include <arpa/inet.h>
uint32_t ntohl(uint32_t netint32);

#include <arpa/inet.h>
uint16_t ntohs(uint16_t netint16);

#include <fcntl.h>
int open(const char * pathname, int oflag, ... /*mode_t mode*/);
// oflag: 	O_RDONLY O_WRONLY ORDWR
// 	 	O_APPEND O_CREAT O_DSYNC O_EXCL O_NOCTTY
// 	 	O_NONBLOCK O_RSYNC O_SYNC O_TRUNC
// mode:	S_IS[UG]ID, S_ISVTX, S_I[RWX](USR|GRP|OTH) 

#include <direct.h>
DIR * opendir(const char * pathname);

#include <syslog.h>
void openlog(char ident, int option, int facility);
// option: LOG_CONS LOG_NEDLAY LOG_NOWAIT LOG_ODELAY LOG_PERROR LOG_PD
// facility: LOG_AUTH LOG_AUTHPRIV LOG_CRON LOG_DAEMON LOG_FTP LOG_KERN ...

#include <unistd.h>
long pathconf(const char * pathname ,int name);

#include <unistd.h>
int pause(void);

#include <stdio.h>
void perror(const char * msg);

#include <unistd.h>
int pipe(int filedes[2]);

#include <poll.h>
int poll(struct pollfd fdarray[], nfds_t nfds, int timeout);

#include <stdio.h>
FILE * popen(const char * cmdstring,const char * type);
// type: "r" "w"

#include <stdlib.h>
#include <fcntl.h>
int posix_openpt(int oflag);
// oflag: O_RWRD O_NOCTTY

#include <unistd.h>
ssize_t pread(int filedes, void *buf, size_t nbytes, off_t offset );

#include <stdio.h>
int printf(const char * restrict formate, ...);

#include <sys/select.h>
int pselect(int maxfdp1, fd_set * restrict readfs, fd_set * restrict writefds,
	    fd_set * restrict exceptfds, const struct timespec * restrict tsptr,
	    const sigset_t * restrict sigmask);

#include <signal.h>
#include <siginfo.h>
void psignal(int signo, const char * msg);

#include <pthread.h>
int pthread_atfork(void (* prepare) (void), void (* parent)(void), void (* child)(void));

#include <pthread.h>
int pthread_attr_destroy(pthread_attr_t * attr);

#include <pthread.h>
int pthread_attr_getdetachstate(const pthread_attr_t * restrict attr, int * detachstate);

#include <pthread.h>
int pthread_attr_getguardsize(const pthread_attr_t * restrict attr,size_t restrict guardsize);

#include <pthread.h>
int pthread_attr_getstack(const pthread_attr_t * restrict attr,void ** restrict stackaddr, size_t * restrict stacksize);

#include <pthread.h>
int pthread_attr_getstacksize(const pthread_attr_t * restrict attr, size_t * restrict stacksize);

#include <pthread.h>
int pthread_attr_init(pthread_attr_t * attr);

#include <pthread.h>
int pthread_attr_setdetachstate(pthread_attr_t * attr, int detachstate);

#include <pthread.h>
int pthread_attr_setguardsize(pthread_attr_t * attr, size_t guardsize);

#include <pthread.h>
int pthread_attr_setstack(const pthread_attr_t * attr, void * stackaddr,size_t * stacksize);

#include <pthread.h>
int pthread_attr_setstacksize(const pthread_attr_t * attr, size_t stacksize);

#include <pthread.h>
int pthread_cancel(pthread_t tid);

#include <pthread.h>
int pthread_cleanup_pop(int execut);

#include <pthread.h>
int pthread_cleanup_push(void (*rtn)(void *), void * arg);

#include <pthread.h>
int pthread_condattr_destroy(pthread_condattr_t * attr);

#include <pthread.h>
int pthread_condattr_getpshared(const pthreat_condattr_t * restrict attr, int * restrict pshared);

#include <pthread.h>
int pthread_condattr_init(pthread_condattr_t * attr);
#include <pthread.h>
int pthread_condattr_setpshared(pthread_condattr_t * attr, int pshared);

#include <pthread.h>
int pthread_cond_broadcast(pthread_cond_t * cond);

#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t * cond);

#include <pthread.h>
int pthread_cond_init(pthread_cond_t * restrict cond, pthread_condattr_t * restrict attr);

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t * cond);

#include <pthread.h>
int pthread_cond_timewait(pthread_cond_t * restrict cond, pthread_mutex_t * restrict mutex, const struct timespec * restrict timeout);

#include <pthread.h>
int pthread_wait(pthread_cond_t * restrict cond, pthread_mutex_t * restrict mutex);

#include <pthread.h>
int pthread_create(pthread_t * restrict tidp, const pthread_attr_t * restrict attr, void *(* start_rtn)(void), void * restrict arg);

#include <pthread.h>
int pthread_detach(pthread_t tid);

#include <pthread.h>
int pthread_equal(pthread_t tid1,pthread_t tid2);

#include <pthread.h>
void pthread_exit(void * rval_ptr);

#include <pthread.h>
int pthread_getconcurrency(void);

#include <pthread.h>
void pthread_getspecific(pthread_key_t key);

#include <pthread.h>
int pthread_join(pthread_t thread, void ** rval_ptr);

#include <pthread.h>
int pthread_key_create(pthread_key_t * keyp, void (* destructor)(void *));

#include <pthread.h>
int pthread_key_delete(pthread_key_t * keyp);

#include <pthread.h>
int pthread_kill(pthread_t thread, int signo);

#include <pthread.h>
int pthread_mutexattr_destory(pthread_mutexattr_t * attr);

#include <pthread.h>
int pthread_mutexattr_getpshared(const pthread_mutexattr_t * restrict attr, int * restrict pshared);

#include <pthread.h>
int pthread_mutexattr_gettype(const pthread_mutexattr_t * restrict attr, int * restrict type);

#include <pthread.h>
int pthread_mutexattr_init(pthread_mutexattr_t * attr);

#include <pthread.h>
int pthread_mutexattr_setpshared(pthread_mutexattr_t * attr, int pshared);

#include <pthread.h>
int pthread_mutexattr_settype(pthread_mutexattr_t * attr, int type);

#include <pthread.h>
int pthread_mutexattr_destroy(pthread_mutex_t * mutex);

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t * restrict mutex, const pthread_mutexattr_t *restrict attr);

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t * mutex);

#include <pthread.h>
int pthread_mutex_trylock(pthread_mutex_t * mutex);

#include <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t * mutex);

#include <pthread.h>
int pthread_once(pthread_once_t * initflag, void (*initfn)(void));

#include <pthread.h>
int pthread_rwlockattr_destroy(pthread_rwlockattr_t * attr);

#include <pthread.h>
int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t * restrict attr,int * restrict pshared);

#include <pthread.h>
int pthread_rwlockattr_init(pthread_rwlockattr_t * attr);

#include <pthread.h>
int pthread_rwlockattr_setpshared(pthread_rwlockattr_t * attr,int pshared);

#include <pthread.h>
int pthread_rwlock_destroy(pthread_rwlockattr_t * attr);

#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t * restrict rwlock,const pthread_rwlockattr_t * restrict attr);

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t * rwlock);

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t * rwlock);

#include <pthread.h>
int pthread_rwlock_tryrdlock(pthread_rwlock_t * rwlock);

#include <pthread.h>
int pthread_rwlock_trywrlock(pthread_rwlock_t * rwlock);

#include <pthread.h>
int pthread_rwlock_unlock(pthread_rwlock_t * rwlock);

#include <pthread.h>
int pthread_rwlock_wrlock(pthread_rwlock_t * rwlock);

#include <pthread.h>
pthread_t pthread_self(void);

#include <pthread.h>
int pthread_setcancelstate(int state, int * oldstate);

#include <pthread.h>
int pthread_setcanceltype(int type, int * oldtype);

#include <pthread.h>
int pthread_setconcurrency(int level);

#include <pthread.h>
int pthread_setspecific(pthread_key_t key, const void * value);

#include <pthread.h>
int pthread_sigmask(int how, const sigset_t * restrict set, sigset_t * restrict oset);

#include <pthread.h>
int pthread_testcancel(void);

#include <stdlib.h>
char * ptsname(int filedes);

#include <stdio.h>
int putc(int c, FILE * fp);

#include <stdio.h>
int putchar(int c);

#include <stdio.h>
int putchar_unlocked(int c);

#include <stdio.h>
int putc_unlocked(int c,FILE *fp);

#include <stdlib.h>
int putenv(char * str);

#include <stropts.h>
int putmsg(int filedes, const struct strbuf * ctlptr, const struct strbuf * dataptr, int flag);
// flag: 0, RS_HIPRI

#include <stropts.h>
int putpmsg(int filedes, const struct strbuf * ctlptr, const struct strbuf * dataptr,int band, int flag);
// flag: 0,MSG_HIPRI,MSG_BAND 

#include <stdio.h>
int puts(const char *str);

#include <unistd.h>
ssize_t pwrite(int filedes, const void * buf, size_t nbytes,off_t offset);

#include <signal.h>
int raise(int signo);

#include <unistd.h>
struct dirent * readidr(DIR * dp);

#include <unistd.h>
int readlink(const char * restrict pathname, char * restrict buf, size_t bufsize);

#include <unistd.h>
ssize_t read(int filedes, void * buf, size_t nbytes);

#include <sys/uio.h>
ssize_t readv(int filedes, const struct iovec * iov, int iovcnt);

#include <stdlib.h>
void * realloc(void * ptr, size_t newsize);

#include <sys/socket.h>
ssize_t recv(int sockfd, void * buf, size_t nbytes, int flags);
// flags: 0, MSG_PEEK, MSG_OOB, MSG_WAITALL

#include <sys/socket.h>
ssize_t recvfrom(int sockfd, void * buf, size_t nbytes, int flags, 
				 struct sockaddr * restrict addr, socklen_t * restrict addrlen);
// flags: 0, MSG_PEEK, MSG_OOB, MSG_WAITALL

#include <sys/socket.h>
ssize_t recvmsg(int sockfd, struct msghdr * msg, int flags);
// flags: 0, MSG_PEEK, MSG_OOB, MSG_WAITALL

#include <stdio.h>
int remove(const char * pathname);

#include <stdio.h>
int rename(const char * oldname, const char *newname);

#include <stdio.h>
void rewind(FILE *fp);

#include <dirnet.h>
void rewinddir(DIR * dp);

#include <unistd.h>
int rmdir(const char * pathname);

#include <stdio.h>
int scanf(const char * restrict format,...);

#include <dirent.h>
void seekdir(DIR * dp, long loc);

#include <sys/select.h>
int select(int maxfdp1, fd_set *restrict readfds, fd_set * restrict writefds,
		   fd_set restrict exceptfds, struct timeval * restrict tvptr);

#include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, ... /* union semun arg*/);
// cmd:IPC_STAT IPC_SET, IPC_RMID, GETPID, GETNCNT , GETZCNT, GETVAL, SETALL

#include <sys/sem.h>
int semget(key_t key, int nsems, int flag);

#include <sys/sem.h>
int semop(int semid, struct sembuf semoparray[], size_t nops);

#include <sys/socket.h>
ssize_t send(int sockfd, const void * buf, size_t nbytes, int flags);
// flags:0, MSG_DONROUTE, MSG_EOR, MSG_OOB

#include <sys/socket.h>
ssize_t sendmsg(int sockfd, const struct msghdr * msg, int flags);
// flags:0, MSG_DONROUTE, MSG_EOR, MSG_OOB

#include <sys/socket.h>
ssize_t sendto(int sockfd, const void * buf, size_t nbytes, int flags, 
			   const struct sockaddr * destaddr, socklen_t destlen);
// flags:0, MSG_DONROUTE, MSG_EOR, MSG_OOB

#include <stdio.h>
void setbuf(FILE *restrict fp, char *restrict buf);

#include <unistd.h>
int setegid(gid_t gid);

#include <stdlib.h>
int setenv(const char *mname, const char * value, int rewrite);

#include <unistd.h>
int seteuid(uid_t uid);

#include <unistd.h>
int setgid(gid_t gid);

#include <grp.h>
int setgrent(void);

#include <grp.h>
#include <unistd.h>
int setgroups(int ngroups, const gid_t grouplist[]);

#include <netdb.h>
void sethostent(int stayopen);

#include <setjump.h>
int setjump(jmp_buf env);

#include <syslog.h>
int setlogmask(int maskpri);

#include <netdb.h>
void setnetent(int stayopen);

#include <unistd.h>
int setpgid(pid_t pid, pid_t  pgid);

#include <netdb.h>
void setprotoent(int stayopen);

#include <pwd.h>
void setpwent(void);

#include <unistd.h>
int setregid(gid_t rgid, gid_t egid);

#include <unistd.h>
int setreuid(uid_t ruid, uid_t euid);

#include <sys/resource.h>
int setrlimit(int resource, const struct rlimit * rlptr);

#include <netdb.h>
void set setservent(int stayopen);

#include <unistd>
pid_t setsid(void);

#include <sys/socket.h>
int setsockopt(int sockfd, int level, int option, const void * val, socklen_t len);

#include <shadow.h>
void setspent(void);

#include <unistd.h>
int setuid(uid_t uid);

#include <stdio.h>
int setvbuf(FILE * restrict fp, char * restrict buf, int mode, size_t size);

#include <sys/shm.h>
void * shmat(int shmid, const void * addr, int flag);

#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds * buf);
// cmd: IPC_STAT, IPC_SET, IPC_RMID, SHM_LOCK, SHM_UNLOCK

#include <sys/shm.h>
int shmdt(void * addr);

#include <sys/shm.h>
int shmget(key_t key, int size, int flag);
// flag: 0, IPC_CREATE, IPC_EXEL

#include <sys/socket.h>
int shotdown(int sockfd, int how);
// how: SHUT_RD, SHUT_WR, SHUT_RDWR

#include <signal.h>
int sig2str(int signo, char * str);

#include <signal.h>
itnt sigaction(int signo, const struct sigaction * restrict act, struct sigaction ( restrict oact);

#include <signal.h>
int sigaddset(sigset_t * set, int signo);

#include <signal.h>
int sigdelset(sigset_t * set);

#include <signal.h>
int sigemptyset(sigset_t * set);

#include <signal.h>
int sigfillset(sigset_t * set);

#include <signal.h>
int sigismember(const sigset_t *set, int signo);

#include <setjmp.h>
int siglongjmp(sigjmp_buf env, int val);

#include <signal.h>
void (*signal(int signo, viod (*func)(int)));

#include <signal.h>
int sigpending(sigset_t * set);

#include <signal.h>
int sigprocmask(int how, const sigset_t * restrict set, sigset_t * restrict oset);
// how: SIG_BLOCK, SIG_UNBLOCK, SIG_SETMASK

#include <setjmp.h>
int sigsetjmp(sigjmp_buf env, int savemask);

#include <signal.h>
int sigsuspend(const sigset_t * sigmask);

#include <signal.h>
int sigwait(const sigset)t *restrict set, int * restrict signop);

#include <unistd.h>
unsigned int sleep(unsigned int seconds);

#include <stdio.h>
int snprintf(char * restrict buf, size_t n, const char * restrict format, ...);

#include <sys/socket.h>
int sockatmark(int sockfd);

#include <sys/socket.h>
int socket(int domain,int int type, int protocol);
// domain: AF_INET
// type: SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_SEQPACKET

#include <sys/socket.h>
int socketpair(int domain, int type, int protocol, in tsockfd[2]);

#include <stdio.h>
int sprintf(char *restrict buf, const char * restrict format, ...);

#include <stdio.h>
int sscanf(char * restrict buf, const char * restrict format, ...);

#include <sys/stat.h>
int stat(const char * restrict pathname, struct stat * restrict buf);

#include <signal.h>
int str2sig(const char *str, int *signop);

#include <string.h>
char strerror(int errnum);

#include <time.h>
size_t strftime(char *restrict buf , size_t maxsize, 
				const char *restrict format, const struct tm *restrict tmptr);

#include <string.h>
char * strsignal(int signo);

#include <unistd.h>
int symlink(const char *actualpath, const char *syspath);

#include <unistd.h>
void sync(void);

#include <unistd.h>
long sysconf(int name);
// name:	_SC_ARG_MAX, ....

#include <syslog.h>
void syslog(int priority, const char * cmdstring);

#include <stdlib.h>
int system(const char * cmdstring);

#include <termios.h>
int tcdrain(int filedes);

#include <termios.h>
int tcflow(int filedes, int action);
// action:	TCOOFF, TCOON, TCIOFF, FCION

#include <termios.h>
int tcflush(int filedes,int queue);
// queue: TCIFLUSH, TCOFLUSH,TCIOFLUSH

#include <termios.h>
int tcgetattr(int fileds, struct termios * termptr);

#include <unistd.h>
pid_t tcgetpgrp(int filedes);

#include <termios.h>
pid_t tcgetsid(int filedes);

#include <termios.h>
int tcsendbreak(int filedes, int duration);

#include <termios.h>
int tcsetattr(int filedes, int opt, const struct termios * termptr);

#include <unistd.h>
int tcsetpgrp(int filedes, pid_t pgrpid);

#include <dirent.h>
long telldir(DIR *dp);

#include <stdio.h>
char * tempnam(consnt char * directory, const char * prefix);

#include <time.h>
time_t time(time_t *calptr);

#include <sys/time.h>
clock_t times(struct tms * buf);

#include <stdio.h>
FILE * tmpfile(void);

#include <stdio.h>
char *tmpnam(char * ptr);

#include <unistd.h>
int truncate(const char * pathname, off_t length);

#include <unistd.h>
char * ttyname(int filedes);

#include <sys/stat.h>
mode_t umask(mode_t cmask);

#include <sys/utsname.h>
int uname(struct utsname *name);

#include <stdio.h>
int ungetc(int c, FILE *fp);

#include <unistd.h>
int unlink(const char * pathname);

#include <stdlib.h>
int unlockpt(int filedes);

#include <stdlib.h>
void unsetenv(const char *name);

#include <utime.h>
int utime(const char (pathname, const struct utimbuf *times);

#include <stdio.h>
#include <stdarg.h>
int vfprintf(FILE *restrict fp, const char *restrict format, va_list arg);

#include <stdio.h>
#include <stdarg.h>
int vfscanf(FILE *restrict fp, const char *restrict format, va_list arg);

#include <stdio.h>
#include <stdarg.h>
int vprintf(const char * restrict format, va_list arg);

#include <stdio.h>
#include <stdarg.h>
int vscanf(const char * restrict format, va_list arg);

#include <stdio.h>
#include <stdarg.h>
int vsnprintf(char * restrict buf, size_t n, const char * restrict format, va_list arg);

#include <stdio.h>
#include <stdarg.h>
int vsprintf(char * restrict buf, const char * restrict format, va_list arg);

#include <stdio.h>
#include <stdarg.h>
int vscanf(char * restrict buf, chonst char * restrict format, va_list):

#include <stdlog.h>
#include <stdarg.h>
void vsyslog(int proirity, const char * format, va_list arg);

#include <sys/wait.h>
pid_t wait(int * statloc);

#include <sys/wait.h>
int waitid(idtype_t idtype, id_t id, siginfo_t * infop, int options);
// idtype: P_PID, P_PGID, P_ALL
// options: WCONTINUED, WEXITED, WNOHANG, WNOWAIT, WSTOPPED

#include <sys/wait.h>
int waitid(pid_t pid, int *statloc, int options)

#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
pid_t wait3(int *statloc, int option, struct rusage * rusage);
// options: 0, WNOHANG, WUNTRACKED

#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
pid_t wait4(pid_t pid, int *statloc, int option, struct rusage * rusage);
// options: 0, WNOHANG, WUNTRACKED

#include <unistd.h>
ssize_t write(int filedes, const void * buf, size_t nbytes);

#include <sys/uio.h>
ssize_t writev(int filedes, const struct iovec * iov, int iovcnt);

請標明: http://blog.csdn.net/kangquan2008/article/details/7259329