其实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