linux c api

字符串

void *memset(void *s, int c, size_t n);

wchar_t *wmemset(wchar_t *wcs, wchar_t wc, size_t n);

void bzero(void *s, size_t n);

void swab(const void *from, void *to, ssize_t n);

char *index(const char *s, int c);

char *rindex(const char *s, int c);

char *strchr(const char *s, int c);

char *strrchr(const char *s, int c);

char *strpbrk(const char *s, const char *accept);

char *strtok(char *str, const char *delim);

char *strtok_t(char *str, const char *delim, char **saveptr);

size_t strspn(const char *s, const char *accept);

size_t strcspn(const char *s, const char *reject);

char *strsep(char **stringp, const char *delim);

char *strcpy(char *dest, const char *src);

char *strncpy(char *desc, const char *src, size_t n);

char *stpcpy(char *dest, const char *src);

void bcopy(const void *src, void *dest, size_t n);

void *memmove(void *dest, const void *src, size_t n);

void *memcpy(void *dest, const void *src, size_t n);

void *memccpy(void *dest, const void *src, int c, size_t n);

void *memchr(const void *s, int c, size_t n);

void *memrchr(const void *s, int c, size_t n);

char *strdup(const char *s);

char *strndup(const char *s, size_t n);

char *strdupa(const char *s);

char *strndupa(const char *s, size_t n);

wchar_t *wcscpy(wchar_t *dest, const wchar_t *src);

wchar_t *wcsncpy(wchar_t *dest, const wchar_t *src, size_t n);

wchar_t *wcscat(wchar_t *dest, const wchar_t *src);

wchar_t *wmemcpy(wchar_t *desc, const wchar_t *src, size_t n);

输入、输出

outb(value, port), inb(port), outb_p(value, port), inb_p(port);

#include <unistd.h>

#include <sys/io.h>

int ioperm(unsigned long from, unsigned long num, int turn_on);

#include <int level>

int  iopl(int level);

文件、目录、路径

#include <limits.h>

#include <stdlib.h>

char *realpath(const char *path, char *resolved_path);

属组、用户

/usr/include/pwd.h

struct passwd

{

    char *pw_name;

    char *pw_passwd;

    __uid_t pw_udi;

    __gid_t pw_gid;

    char *pw_gecos;      /*real name.*/

    char *pw_dir;         /* home directory.*/

    char *pw_shell;      /*shell program.*/

};

struct passwd *getpwnam(const char *name);

struct passwd *getpwuid(uid_t uid);

int chown(const char *path, uid_t owner, gid_t group);

int fchown(int fd, uid_t owner, gid_t group);

int lchown(const char *path, uid_t owner, gid_t group);

时间

#include <time.h>

clock_t clock(void);

time_t time(time_t *t);

time_t mktime(struct tm *tm);

#define difftime(t1, to)  (double)(t1 - t0)

double difftime(time_t time1, time_t time0);

char *asctime(const struct tm *tp);

char *ctime(const time_t *tp);

struct tm *gmtime(const time_t *tp);

struct tm *localtime(const time_t *timep);

size_t strftime(char *s, size_t smax, const char *fmt, const struct tm *tp);

char *strptime(const char *s, const char *format, struct tm *tm);

信号

通讯

socket（unixdomain）

/usr/include/netinet/in.h

typedef uint32_t in_addr_t;

struct in_addr

{

    in_addr_t s_addr;

};

struct in6_addr
{
    union
      {
        uint8_t __u6_addr8[16];
#if defined __USE_MISC || defined __USE_GNU
        uint16_t __u6_addr16[8];
        uint32_t __u6_addr32[4];
#endif
      } __in6_u;
#define s6_addr                 __in6_u.__u6_addr8
#if defined __USE_MISC || defined __USE_GNU
# define s6_addr16              __in6_u.__u6_addr16
# define s6_addr32              __in6_u.__u6_addr32
#endif
};

int socket(int domain, int type, int protocol);

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

int listen(int sockfd, int backlog);

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, sturct timeval *timeout);

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);

int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int shutdown(int sockfd, int how);

int epoll_create(int size);

int epoll_create1(int flags);

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

int epoll_pwait(int epfd, struct epoll_event *events, int maxevents, int timeout , const sigset_t *sigmask);

pipe、FIFO

sginal、semaphore

int semget(key_t key, int nsems, int semflg);

int semop(int semid, struct sembuf *sops, unsigned nsops);

int settimedop(int semid, struct sembuf *sops, unsigned nsops, struct timespec *timeout);

int semctl(int semid, int semnum, int cmd, ...);

msg queue

shared memery

int shmget(key_t key, size_t size, int shmflg);

void *shmat(int shmid, const void *shmaddr, int shmflg);

int shmdt(const void *shmaddr);

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

线程

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

pthread_t pthread_self(void);

int pthread_equal(pthread_t t1, pthread_t t2);

void pthread_exit(void *retval);

int pthread_join(pthread_t thread, void **retval);

int pthread_cancel(pthread_t thread);

int pthread_detach(pthread_t thread);

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

int prhtead_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);

int pthrread_attr_init(pthread_attr_t *attr);

int pthread_attr_destory(pthread_attr_t *attr);

int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr);

int pthread_attr_getstackaddr(pthread_attr_t *attr, void *stackaddr);

int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize);

int pthread_attr_getstack(pthread_attr_t *attr, void **stackaddr, size_t *stacksize);

int pthread_getattr_np(pthread_t thread, pthread_attr_t *attr);

int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);

int pthread_attr_getstacksize(pthread_attr_t *attr, size_t *stacksize);

int pthread_setconcurrency(int new_level);
int pthread_getconcurrency(void);

进程

#include <unistd.h>

int execl(const char *path, const char *arg, ...);

int execlp(const char *file, const char *arg, ...);

int execle(const char *path, const char *arg, ..., char *const envp[]);

int execv(const char *path, char *const argv[]);

int execvp(const char *file, char *const argv[]);

#include <sys/types.h>

#include <sys/wait.h>

pid_t wait(int *status);

pid_t waitpid(pid_t pid, int *status, int options);

int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);

void exit(int status);

int atexit(void (*function)(void));