linux高级编程常用的系统调用函数整理

这一个月来,因为电脑原因,没有过多的进行Android方面的开发,而是选择了学习Linux/Unix高级编程方面的知识,目前到了总结阶段。现贴出学习过程中遇到的基本系统调用函数,方便以后查找和回忆,接下来也将更新自己的学习总结和理解。

动态加载共享库函数

需要的添加的头文件  
#include <dlfcn.h>
编译时需要加上的参数   -ldl

函数系列:
1.void *dlopen(const char *filename,int flag);

功能:加载一个动态库文件,当这个库文件被重复加载的时候,函数只返回同一个地址,并且dl库中维护的引用计数会加一。
      也就是说,如果返回成功,则会使引用计数+1。不同的是首次加载时,会把库文件加载到内存,并返回该内存的地址值
       ,不是首次加载时,则只返回地址值,同时增加引用计数。
参数:
    filename  指定要加载的库文件的名字
    flag      RTLD_LAZY   延迟绑定   
              RTLD_NOW    立即加载
返回值:
    成功=> 返回一个地址。
    失败=> NULL

2.char *dlerror(void);

功能:返回最近的错误信息。错误信息由dlopen、dlclose、dlsym函数调用产生。
参数:void
返回值:成功返回错误信息,如果返回NULL,代表没有错误

3.void *dlsym(void *handle,const char *symbol);

功能:是将handle指向的动态库中的symbol加载到内存中
参数:
    handle  是dlopen函数的返回值
    symbol   是要加载到内存的符号 
返回值:
    symbol被加载到内存中的地址

4.int dlclose(void *handle);

功能:让库文件的引用量减一,如果这个引用量减为0,同时其他的加载库没有使用库中的symbol时,这个动态库就会被卸载
参数: handle  是dlopen函数的返回值
返回值:    0  正确返回
        非0 失败返回

错误处理相关函数

需要包含的头文件
 #include <errno.h>
errno.h头文件定义了一个整型的全局变量errno,当系统调用或者一些库函数发生错误时设置errno,通过errno值发现错误信息

处理函数:

1.void perror(const char *s);

需要包含的头文件    
#include <stdio.h>

功能: 打印系统错误信息
参数:s  字符串,一般是系统调用或者库函数的调用函数名
返回值:void

2.char *strerror(int errnum);

需要包含的头文件
#include <string.h>

功能:根据错误号返回一个描述错误信息的字符串
参数: errnum:  错误编号
返回值:该字符串的首地址

操作环境变量的函数

需要包含的头文件
#include <stdlib.h>

函数系列
1.char *getenv(const char *name);

功能:获取name指定的环境变量的值。
参数:name  环境变量的名字
返回值: NULL: 没有找到环境变量的值 =>失败
    指向环境变量值的地址   =>成功

2.int setenv(const char *name, const char *value,int overwrite);

功能:改变或添加环境变量
参数:
    name:代表了环境变量的名字
    value:环境变量的值
    overwrite:判断环境变量的名字存在的时候,是否改变环境变量的值
        参数选择:   0   不改变
                    非0  改变
返回值:
    0 代表成功
    -1 代表失败  并且设置errno的值

3.int unsetenv(const char *name);

功能:从环境变量列表中,删除name指定的环境变量
参数:
    name:环境变量的名字
返回值:
    0 代表成功
    -1 代表失败  并且设置errno的值

4.int putenv(char *string);

功能:改变或添加一个环境变量
参数:
    string   name=value的形式
         如果name在环境列表中不存在,则往列表中添加该环境
         如果name在环境列表中存在,则改变该环境的值value  
返回值:
    0代表成功
    非0 代表失败

mmap内存映射系列参数

需要添加的头文件
#include <sys/mman.h>

函数系列:
1.void *mmap(void *addr, size_t len,int prot, int flags,int fildes, off_t off);

功能:在调用该方法的进程的虚拟地址空间创建一个新的映射,起始地址由addr决定,长度由length指定

参数:
addr:   NULL 由系统自动分配
    非NULL  在建议的地址上分配
len:    指定了映射的长度
prot:
    PROT_READ           Data can be read.
    PROT_WRITE          Data can be written.
    PROT_EXEC           Data can be executed.
    PROT_NONE           Data cannot be accessed.

flags:
    MAP_PRIVATE     私有的,只能被自己看到
    MAP_ANONYMOUS   匿名文件   将内存映射过来

fileds: 文件描述符 0
off:    文件的偏移位置 0
返回值:
    失败:返回MAP_FAILED 
    成功:返回一个指向该映射空间的地址

2.int munmap(void *addr, size_t len);

功能:解除映射
参数:
    addr:mmap的返回值
    len:mmap里的len值
返回值:
    0代表成功
    -1代表失败,并设置errno

文件操作函数

需要包含的头文件
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

函数系列

1.
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
int open(const char *pathname, int flags,…);

功能:打开一个文件或者设备
参数:
pathname:文件的路径名字 
flags:
以下三个只能包含其中一个
O_RDONLY   只读方式打开
O_WRONLY   只写方式打开
O_RDWR     读写方式打开

以下的参数可用或的方式进行拼接

文件创建的标记:
O_CREAT 文件不存在,则创建文件,创建文件的时候,需要指定文件的权限。
O_TRUNC 这个标记不能和只读标记一起使用,打开一个文件,如果文件不存在,创建这个文件。如果文件存在,将文件内容清空为0;
O_EXCL  和O_CREAT一起使用,要创建的文件已经存在的时候,调用失败。

文件状态的标记
O_APPEND   追加的方式打开文件

mode:指定文件的权限,当创建文件时,需要这个参数申明文件的权限


返回值:
    成功:返回文件的描述符。
    失败:返回-1,errno被设置

注意:在mode中声明的文件权限需要和umask进行与操作,才能确定最终的文件权限
mode & ~umask
umask 称为权限掩码,可以用umask命令用来察看umask掩码,也可以用“umask  权限数字”这样的指令来改变umask掩码的值

2.int close(int fd);

功能:关闭文件
参数:
fd: open的时候创建的文件描述符
返回值:
    0 代表成功
    -1 代表失败  errno被设置

3.ssize_t read(int fd, void *buf, size_t count);

功能:从指定的文件描述符中读取内容
参数:
    fd: open返回的文件描述符
    buf:读取内容到buf指定的内存空间里
    count:我想要读取的字节的个数
返回值:
    失败:返回-1  errno被设置
    成功:返回的是实际读取到的字节数。如果是0,代表到达了文件的尾部

4.ssize_t write(int fd, const void *buf,size_t count);

功能:往文件中写入数据
参数:
    fd:open函数的返回值
    buf: 将buf指向的内存中的数据写入到fd指向的文件中
    count:想要写入文件的字节数
返回值:
    失败:返回-1 errno被设置
    成功:返回实际写入文件的字节数

5.off_t lseek(int fd, off_t offset,int whence);

需要额外包含的头文件
#include <sys/types.h>

功能:改变文件进行都写操作时的偏移量
参数:
    fd:  open函数的返回值
    offset: 偏移位置
    whence:
        SEEK_SET   文件的开头
        SEEK_CUR   当前位置
        SEEK_END   文件末尾
返回值:
    失败:返回-1,errno被设置
    成功:返回位置

文件描述符的复制函数

需要包含的头文件
#include <unistd.h>

1.int dup(int oldfd);

功能:复制文件描述符
参数:oldfd   要复制的文件描述符
返回值:
    成功:返回新的文件描述符
    失败:返回-1  errno被设置

2.int dup2(int oldfd, int newfd);

功能:复制文件描述符
参数:
    oldfd     旧的文件描述符
    newfd     新的文件描述符
返回值:
    成功:返回新的文件描述符
    失败:返回-1   errno被设置

操作文件锁函数

需要包含的头文件: 
#include <unistd.h>
#include <fcntl.h>

1.int fcntl(int fd, int cmd, … /* arg */ );

功能:操作文件描述符,为其设置文件操作锁
参数:
    fd: open 函数的返回值
    cmd:
        F_GETLK,    获得一个锁
        F_SETLK ,  设置一个锁,如果已经有一把互斥锁
            F_SETLKW ,  释放一个等待的锁(F_SETLKD的阻塞版本)
    参数结构体:第三个参数 
        struct flock {
                   ...
                   short l_type;    /* Type of lock: F_RDLCK,           读,写,解锁。
                                     F_WRLCK, F_UNLCK */
                   short l_whence;  /* How to interpret l_start:         锁的位置。  ---
                                     SEEK_SET, SEEK_CUR, SEEK_END */        
                   off_t l_start;   /* Starting offset for lock */       开始偏移量 ---    这三个参数确定锁的开始位置及长度。
                   off_t l_len;     /* Number of bytes to lock */       锁的长度   ---
                   pid_t l_pid;     /* PID of process blocking our lock         
                                         (F_GETLK only) */
                    ...
             };


返回值:
    0代表成功。
    -1 代表失败,errno被设置。

获取文件的元数据操作

1.int stat(const char *path, struct stat *buf);

需要包含的头文件
   #include <sys/types.h>
   #include <sys/stat.h>
   #include <unistd.h>

功能:  得到文件的相关信息
参数:
    buf:返回文件的描述结构体指针,当函数返回0时,可在buf中察看文件的元数据信息
    path:文件路径名。
返回值:0 成功
    -1 失败,errno被设置。

文件的描述结构体指针
struct stat {
                   dev_t     st_dev;     /* ID of device containing file */
           ino_t     st_ino;     /* inode number */     inode号
           mode_t    st_mode;    /* protection */       权限
           nlink_t   st_nlink;   /* number of hard links */ 硬链接数
           uid_t     st_uid;     /* user ID of owner */     用户id
           gid_t     st_gid;     /* group ID of owner */    组ID
           dev_t     st_rdev;    /* device ID (if special file) */ 
           off_t     st_size;    /* total size, in bytes */ 文件长度
           blksize_t st_blksize; /* blocksize for file system I/O */
           blkcnt_t  st_blocks;  /* number of 512B blocks allocated */
           time_t    st_atime;   /* time of last access */  最后一次访问的时间
           time_t    st_mtime;   /* time of last modification */    最后修改的时间
           time_t    st_ctime;   /* time of last status change */ 最后一次状态改变的时间
       };

2.struct passwd *getpwuid(uid_t uid);

需要包含的头文件
#include <sys/types.h>
    #include <pwd.h>

功能:返回一个指向密码数据库中与用户id参数匹配的相关数据的指针
参数:uid 用户的id
返回值:一个结构体指针,结构体成员定义如下:
struct passwd {
           char   *pw_name;       /* username */
           char   *pw_passwd;     /* user password */
           uid_t   pw_uid;        /* user ID */
           gid_t   pw_gid;        /* group ID */
           char   *pw_gecos;      /* user information */
           char   *pw_dir;        /* home directory */
           char   *pw_shell;      /* shell program */
       };

3.struct group *getgrgid(gid_t gid);

需要包含的头文件:
#include <sys/types.h>
    #include <grp.h>

功能:返回一个指向用户组数据库中与组id参数匹配的相关数据的指针
参数:gid 组id
返回值:
       struct group {
           char   *gr_name;       /* group name */
           char   *gr_passwd;     /* group password */
           gid_t   gr_gid;        /* group ID */
           char  **gr_mem;        /* group members */
       };

文件夹操作函数

需要包含的头文件
#include <sys/types.h>
#include <dirent.h>

1.DIR *opendir(const char *name);

功能:打开一个文件夹
参数:
    name  文件夹的名字
返回值:
    失败:NULL errno被设置
    成功:返回一个指向文件夹流首地址

2.int closedir(DIR *dirp);

功能:关闭一个文件夹
参数:
    dirp  opendir的返回值
返回值:
    0 成功
    -1 失败  errno被设置

3.struct dirent *readdir(DIR *dirp);

功能:读取文件夹内容,返回dirent指针
参数:
    dirp  opendir函数的返回值
返回值:
    NULL   失败或者到达了文件的末尾
    如果是失败 errno被设置,如果是到达文件末尾,errno没有被设置
    返回一个地址  成功
    struct dirent {
           ino_t  d_ino; /*inode number */
           off_t  d_off; /*offset to the next dirent */
           unsigned short d_reclen; /*length of this record */
           unsigned char  d_type; /*type of file; not supported by all file system types */
           char   d_name[256]; /* filename */
    };

在程序中获得自己的进程id函数

需要包含的头文件
#include <sys/types.h>
#include <unistd.h>

1.pid_t getpid(void);
2.pid_t getppid(void);

功能:1.获取调用进程的pid
     2.获取调用进程的父pid
参数:void
返回值:见功能

在程序中创建新进程的函数

需要包含的头文件
#include <unistd.h>

1.pid_t fork(void);

功能:创建一个子进程
参数:void
返回值:
    失败:返回-1  errno被设置
    成功:返回两个值
        在父进程里     子进程的pid
        在子进程里      0

进程退出时执行相关操作的函数:

需要包含的头文件
#include <stdlib.h>

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

功能:注册一个函数,在进程退出的时候,调用他
参数:void (*function)(void)函数    
返回值:
    0 成功
    非0 失败、

2.int on_exit(void (function)(int , void ), void *arg);

功能:注册一个函数,在进程退出的时候,调用他
参数:
    void (*function)(int , void *):函数名
    void *arg:函数参数
返回值:
    0 成功
    非0 失败

进程退出函数

需要包含的头文件
 #include <unistd.h>

1.void _exit(int status);

功能:终止当前调用进程
参数:父进程退出进程的状态码,可以在wait函数中察看
返回值:void

保持进程同步的函数

需要包含的头文件
#include <sys/types.h>
#include <sys/wait.h>

1.pid_t wait(int *status);

功能:等待子进程的结束
参数:
    status:获取子进程的结束状态码
返回值:
    成功:子进程的pid
    失败:-1 
附:
WIFEXITED(status)用来判断子进程是否正常终止
WEXITSTATUS(status)获取子进程正常终止的状态码

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

功能:等待子进程的结束
参数:
    pid  指定等待的子进程,参数见下
        <-1  等待gid等于pid参数绝对值的进程 
        -1   等待任意一个子进程
        0    等待gid等于父进程的gid的进程
        >0   等待进程pid等于参数pid的进程

    status  子进程的退出状态
    options  选项
        WNOHANG  如果没有子进程退出,立即返回
        0      阻塞

返回值:
    子进程的pid
    如果指定的子进程的状态没有改变   0  
    -1 失败

程序的装入系列函数=》exec函数组

需要包含的头文件
#include <unistd.h>
全局环境遍量:extern char **environ;

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

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

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

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

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

6.int execvpe(const char *file,char *const argv[],char *const envp[]);

功能:在进程中装载一个可执行文件
参数:
    path   要加载的程序的路径
    file   要加载的程序的名字,具体路径由PATH环境变量提供
    arg    list   arg0 arg1 arg2...
        arg0必须和程序的文件名一致   
        最后一个肯定是(char *)NULL
    envp: 传环境变量。
    argv:  array  这个数组的第一个元素需要跟可执行文件的
            名字一致。最后一个元素需要是NULL。

返回值:
    在出现错误的时候,才被返回,返回值是-1,errno被设置。

区分:在exec函数组中,exec为函数前缀,后面的第一个字母决定参数为arg(list)还是argv(array),两者分别对应l和v
在函数中,p代表文件路径由Path环境变量提供,第一个参数只需要填写文件名
     没有p代表需要第一个参数为要加载系统的环境路径
     e代表需要传入相关的环境变量

创建一个无名管道:

需要的头文件:
#include <unistd.h>

1.int pipe(int pipefd[2]);

功能:创建一个管道。返回两个文件描述符
参数:
    pipefd[2]
    pipefd[0]   读端
    pipefd[1]   写端

返回值:
    0 成功
    -1 失败  errno被设置

创建一个有名管道:

需要包含的头文件:
#include <sys/types.h>
#include <sys/stat.h>

1.int mkfifo(const char *pathname, mode_t mode);

功能:创建一个有名管道
参数:
    pathname: 文件路径的名字
    mode:权限
返回值:
    0 成功
    -1 失败   errno被设置

获取当前目录的绝对路径函数

需要包含的头文件    
#include <unistd.h>

1.char *getcwd(char *buf, size_t size);

功能:返回一个字符串,表示当前调用进程的工作目录的绝对路径
参数:
    buf  把当前工作目录的绝对路径复制到buf中
    size buf空间的大小
返回值:成功返回当前工作目录
    失败返回FAISE

信号注册函数

需要包含的头文件    
#include <signal.h> 
//需要声明的函数类型为void(*)(int),重命名为sighandler_t;
typedef void (*sighandler_t)(int);

1.sighandler_t signal(int signum,sighandler_t handler);

功能:将handler和signum绑定,并向进程注册,当收到信号时,调用handler函数
参数:
    signum   信号编号或者信号名字
    handler   函数指针类型
返回值:
SIG_ERR   错误返回

给进程发送信号的函数

1.int kill(pid_t pid, int sig);

需要包含的头文件
#include <sys/types.h>
#include <signal.h>

功能:给pid指定的进程发送sig信号
参数:
    pid    进程编号
    sig    信号的编号
返回值:
    0   成功
    -1 失败  errno被设置

2.int raise(int sig);

需要包含的头文件:
#include <signal.h>
功能:给自己发送信号
参数:
    sig   信号编号 信号
返回值:
    0   成功
    非0 失败

3.unsigned int alarm(unsigned int seconds);

需要包含的头文件
#include <unistd.h>
功能:给进程自己发送SIGALRM信号
参数:
    seconds:延时时间
    0    取消alarm的设置
返回值:
    0   没有预先设置

等待一个信号的函数

需要的头文件
#include <unistd.h>

1.int pause(void);

功能:等待一个信号
参数:void
返回值:
-1 代表错误,并设置errno。如果errno==EINTR说明被信号打断。

处理sigset_t集合的几个函数

需要包含的头文件
#include <signal.h>

1.int sigemptyset(sigset_t *set);

功能:将set集合里的内容全部清空,清为0;
参数:
    set   要操作的sigset_t类型的集合,将该集合清空
返回值:
    0 成功
    -1 失败

2.int sigfillset(sigset_t *set);

功能:将set集合里的内容全部置1
参数:
    set 要操作的sigset_t类型的集合,将该集合的全部置1
返回值:
    0 成功
    -1 失败

3.int sigaddset(sigset_t *set, int signum);

功能:给set添加signum指定的信号。
参数:
    set   集合
    signum  指定的信号
返回值:
    0  成功
    -1 失败

4.int sigdelset(sigset_t *set,int signum);

功能:从set集合里移除signum指定的信号
参数:
    set 指定的集合
    signum  要移除的信号
返回值:
    0 成功
    -1 失败

5.int sigismember(const sigset_t *set,int signum);

功能:测试信号signum是不是set集合里的一个成员
参数:
    set  集合
    signum  指定的信号
返回值:
    1   集合里有这个信号
    0  集合里没有这个信号
    -1 失败错误

信号阻塞的操作函数

需要包含的头文件
#include <signal.h>

1.int sigprocmask(int how,const sigset_t *restrict set,sigset_t *restrict oset);

功能:检查和改变信号的阻塞,
参数:
    how:
        SIG_BLOCK  set指定的集合和进程的set集合并集操作(或)。
        SIG_SETMASK 直接使用set集合里的值来设定
        SIG_UNBLOCK ~set和当前进程的set做与操作
    set: 指定的集合
    oset:原先的旧的集合
返回值:
    0   成功
    -1 失败 errno被设置

2.int sigpending(sigset_t *set);

功能:检查未决信号
参数:
    set:用于获取未决信号集合
返回值:
    0  成功
    -1 失败 errno被设置

消息队列的相关操作函数

1.key_t ftok(const char *pathname,int proj_id);

需要包含的头文件:
#include <sys/types.h>
#include <sys/ipc.h>
功能:将pathname和proj_id转换为system v IPC键值
参数:
    pathname: 存在的,可以访问的,有效的文件名
    proj_id:0~255
返回值:
    失败:返回-1  errno被设置
    成功:返回键值

2.int msgget(key_t key, int msgflg);

需要包含的头文件
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

功能:得到一个和key相关联的消息队列 id
参数:
    key:ftok函数的返回值
    msgflg:
    IPC_CREAT  如果没有于key想关联的消息队列,则创建消息队列
    IPC_EXCL 和IPC_CREAT一起使用,如果消息队列存在,则报错,errno被设置为EEXIST
返回值:
    失败:返回-1  errno被设置
    成功:返回消息队列的id

3.int msgsnd(int msqid,const void *msgp,size_t msgsz, int msgflg);

需要包含的头文件:
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
功能:向消息队列发送消息
参数:
    msqid: msgget函数的返回值
    msgp: 消息内容的地址
    msgsz:消息队列数据的长度
    msgflg:
        0  当消息队列的空间不足的时候,阻塞
        IPC_NOWAIT 消息队列空间不足的时候,函数立即返回错误代码,错误信息为EAGAIN

返回值:
    0 成功
    -1 失败 errno被设置

4.ssize_t msgrcv(int msqid, void *msgp,size_t msgsz, long msgtyp,int msgflg);

    需要包含的头文件:
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>

    功能:从消息队列接受消息
    参数:
        msqid:函数msgget的返回值
        msgp:从消息对列里接受消息到msgp指定的地址里
        msgsz:消息队列的长度
        msgtyp:指定接收的消息类型
        msgflg:IPC_NOWAIT 

    返回值:
        -1 失败  errno被设置
        接收到的消息体的长度。

共享内存的相关操作

1.ftok(3) 参见消息队列这个函数的介绍

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

需要包含的头文件:
#include <sys/ipc.h>
#include <sys/shm.h>

功能:分配一块共享内存
参数:
    key:  ftok(3)的返回值
    size: 向系统申请分配的内存大小。以页为单位
    shmflg:
        IPC_CREAT
        IPC_EXCL    
        mode_flags

    返回值:
    失败:返回-1 
    成功:返回共享内存的id

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

需要包含的头文件:
#include <sys/types.h>
#include <sys/shm.h>

功能:获得共享内存映射到进程的虚拟地址
参数:
    shmaddr  NULL
    shmid    shmget(2)的返回值
    shmflg:
    SHM_RDONLY  对共享内存  只读

返回值:
    失败:返回 (void *) -1  错误  errno被设置
    成功:返回虚拟地址

4.int shmdt(const void *shmaddr);

需要包含的头文件:
#include <sys/types.h>
#include <sys/shm.h>

功能:解除共享内存的映射
参数:
    shmaddr   shmat(2)的返回值
返回值:
    0 成功
    -1 失败

网络编程的相关操作函数:

基于TCP编程的服务端函数

步骤:

a)使用socket建立通信端

b)将sockfd和服务器的地址、端口绑定

c)监听套接字

d) accpet等待客户端发来的请求

e)提取客户端发来的数据、进行数据处理、回应客户端

f)关闭连接

系列函数:

需要的头文件
#include  <sys/types.h>     /*See NOTES */
#include <sys/socket.h>

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

功能:创建一个用于通讯的端点
参数:
    domain:
        AF_INET   用于ipv4协议家族
        AF_INET6  用于ipv6协议家族

    type:   
        SOCK_STREAM:指明采用TCP传输层协议
        SOCK_DGRAM:指明采用UDP传输层协议

    protocol:
        常设置为0   
返回值:
    失败 :返回 -1 错误 errno被设置
    成功 :返回一个用于通讯的文件描述符

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

功能:将一个socket和name绑定
参数:
    sockfd:socket函数调用成功返回的文件描述符
    addr:一个用于设置接收地址和设置通讯端口的结构体指针
    addrlen:addr指向的内存的长度
返回值:
    0 成功
    -1 失败  errno被设置
结构体指针定义如下:
    struct sockaddr {
           sa_family_t sa_family;
           char        sa_data[14];
    }
为定义方便,基于上面指针重新指定新的结构体:
    struct sockaddr_in   用于ipv4
    struct sockaddr_in6  用于ipv6

3.int listen(int sockfd, int backlog);

功能:坚挺套接字上的连接
参数:
    sockfd: socket(2)的返回值
    backlog: 未决连接,表示可监听的个数
返回值:
    0 成功
    -1 失败 errno被设置

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

功能:接收sockfd指定的连接
参数:
    sockfd:socket(2)的返回值
    addr:接收网络socket的地址,如果设置为NULL,不影响连接,但不能显示相关信息。
    addrlen:addr指向内存的长度
返回值:
    -1 失败  errno被设置
    accept文件描述符   

5.read(connfd,buf,size);

功能:见文件操作函数read

6.write(connfd,buf,size);

功能:见文件操作函数write

7.close(connfd);

关闭连接

大端小端转换相关函数:

需要的头文件
#include <arpa/inet.h> 

1. const char *inet_ntop(int af, const void *src,char *dst, socklen_t size);

功能:将网络地址指针表示的文本或二进制格式转换为字符串格式
参数:
    af: 指定使用ipv4还是ipv6
    src:指定地址->sin_addr.s_addr
    dst:转化后的字符串格式存储的地方
    size:dst的大小
返回值:成功:返回一个指向dst的非空指针
    失败:NULL,错误值被设置

2.int inet_pton(int af, const char *src, void *dst);

功能:将点分十进制转换为网络的格式
参数:
    af  :  AF_INET  IPV4
        AF_INET6  ipv6
    src: 字符串格式的ip地址
    dst:网络格式的ip地址存储区
返回值:
    1  成功
    -1 失败  errno被设置

3.int inet_aton(const char *cp, struct in_addr *inp);

需要包含的头文件
#include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>

功能:将点分十进制的主机ip地址转化为struct in_addr类型的网络地址
参数:
    cp:需要转化的点分十进制参数
    inp:转化后的结果存储区
返回值:
    0  失败
    非0 成功

4.char *inet_ntoa(struct in_addr in);

功能:将struct in_addr类型的网络地址转换为点分十进制的字符串格式。
参数:
in  网络地址
返回值:
    点分十进制的字符串

网络地址与主机地址相互转化的相关函数

需要包含的头文件
#include <arpa/inet.h>

1.uint32_t htonl(uint32_t hostlong);
2.uint16_t htons(uint16_t hostshort);
3.uint32_t ntohl(uint32_t netlong);
4.uint16_t ntohs(uint16_t netshort);

方法描述:
转化源格式 to 传化后格式 存储值类型
比如: htonl
h  hostaddr 主机地址
n  netaddr  网络地址
l  32位无符号整型的int类型
s  16位无符号整型的int类型

基于tcp的客户端连接:

步骤

a)创建socket(见socket方法)

b)使用sockfd和服务器端连接

c)业务处理(见read/write方法)

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

需要包含的头文件
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

功能:在socket(2)返回的文件描述符上启动一个连接
参数:
    sockfd:socket(2)的返回值
    addr: 服务器的地址
    addrlen:服务器地址结构的长度
返回值:
    0 成功
    -1 失败 errno被设置

UDP编程的相关参数

1.ssize_t recvfrom(int sockfd,void *buf,size_t len,int flags,struct sockaddr *src_addr, socklen_t *addrlen);

需要包含的头文件
#include <sys/types.h>
#include <sys/socket.h>

功能:从socket接收消息
参数:
    sockfd:socket(2)的返回值
    buf:用来存储接收到的信息
    len:成功得到消息的长度
    flags:取0
    src_addr:通讯对方的网络地址和端口号
    addrlen:src_addr指向的结构体的长度。
返回值:
    -1 错误
    接收到的信息的字节数

2.ssize_t sendto(int sockfd, const void *buf,size_t len, int flags,const struct sockaddr *dest_addr,socklen_t addrlen);

需要包含的头文件
#include <sys/types.h>
#include <sys/socket.h>

功能:通过socket发送一个消息
参数:
    sockfd:socket(2)返回值
    buf:要发送的数据存放的地址
    len:要发送的数据的长度
    flags:0
    dest_addr:目标的网络地址和端口号
    addrlen:dest_addr的长度
返回值:
    -1 错误 errno被设置
    发送出去的字节数

关于线程的基本操作函数

需要包含的头文件
#include <pthread.h>
编译时需要加上的参数 -pthread

1.int pthread_create(pthread_t thread, const pthread_attr_t *attr,void (start_routine) (void ),void *arg);

功能:创建一个线程
参数:
    thread:带回线程的id
    attr:一般设置为NULL
    start_routine:线程的执行函数
    arg:是start_routine函数的参数

返回值:
    成功:0 
    失败:返回一个错误number。

2.pthread_t pthread_self(void);

功能:获取调用该函数的线程id。
参数:
    void  不需要参数
返回值:
    返回调用该函数的线程的id。

3.void pthread_exit(void *retval);

功能:终止调用该函数的线程,返回一个可被同进程中的其他线程捕获的值(如果该线程处于join状态的话)
参数:
    retval,可被其他线程捕获的参数
返回值:
    void

4.int pthread_cancel(pthread_t thread);

功能: 向线程发送一个终止请求
参数:
    thread  向这个thread发送终止请求
返回值:
    0   成功
    非0 失败 错误的编号

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

功能: 等待一个线程结束,如果这个线程已经终止,则方法立即返回
参数: 
    thread:等待终止的线程
    retval:判断线程终止的原因
返回值:
    0 成功
    非0 错误  错误编码

6.int pthread_detach(pthread_t thread);

功能:分离一个线程
参数:
    thread   指定一个要分离的线程
返回值:
    0 成功
    非0  失败

线程间同步的相关函数

mutex锁的系列函数

1.int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *mutexattr);

功能:初始化mutex锁
参数:
    mutex:要初始化的mutex锁
    mutexattr:NULL
返回值:
    0 always

2.int pthread_mutex_lock(pthread_mutex_t *mutex);

功能: 上锁mutex,如果没有其他线程上锁,立即上锁,并返回,如果有其他线程上锁,挂起等待其他线程释放锁。
参数:
    mutex  要上的锁
返回值:
    0 成功
    非0 失败

3.int pthread_mutex_trylock(pthread_mutex_t *mutex);

功能:尝试加锁,如果其他线程没有上锁,立即上锁,正确返回。如果其他线程上锁,立即返回错误
参数:
    mutex:要上的锁
返回值:
    0 成功
    非0 失败

4.int pthread_mutex_unlock(pthread_mutex_t *mutex);

功能: 解锁
参数:
    mutex  要操作的锁
返回值:
    0 成功
    非0 失败

5.int pthread_mutex_destroy(pthread_mutex_t *mutex);

功能:销毁锁
参数:
    mutex  要销毁的锁
返回值:
    0 成功
    非0 失败

条件变量函数系列:

1.pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

功能: 静态初始化一个条件变量

2.int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr);

功能: 动态初始化一个条件变量
参数:
    cond:要初始化的条件变量
    cond_attr:指定为缺省属性,NULL
返回值:
    0  成功
    非0 失败 代表的是错误码

3.int pthread_cond_signal(pthread_cond_t *cond);

功能: 向等待的一个线程发送启用信号
参数:
    cond:  等待的条件变量
返回值:
    0  成功
    非0 失败 代表的是错误码

4.int pthread_cond_broadcast(pthread_cond_t *cond);

功能: 给所有等待条件变量的线程发送信号
参数:
    cond: 等待的条件变量
返回值:
    0  成功
    非0 失败 代表的是错误码

5.int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);

功能:等待某个条件变量
参数:
    cond: 等待的条件变量
    mutex:  加锁
返回值:
    0  成功
    非0 失败 代表的是错误码

6.int pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t *mutex,const struct timespec *abstime);

功能: 等待某个条件变量,如果超时,返回错误,错误码ETIMEDOUT。
参数:
    cond:等待的条件变量
    mutex:加锁
    abstime:等待的时间

返回值:
    0  成功
    非0 失败 代表的是错误码

7.int pthread_cond_destroy(pthread_cond_t *cond);

功能: 销毁条件变量
参数:
    cond:要销毁的条件变量
返回值:
    0  成功
    非0 失败 代表的是错误码

信号量集函数系列:

需要的包含的头文件
#include <semaphore.h>
编译的时候要加上-lrt 或者-pthread.

1.int sem_init(sem_t *sem, int pshared,unsigned int value);

功能: 初始化信号量集
参数:
    sem:sem就是要初始化的信号量集
    pshared: 0一个进程中的多个线程
    value:指定了信号集中的资源的数量
返回值:
    0 成功
    -1 失败  errno被设置

2.int sem_destroy(sem_t *sem);

功能: 销毁信号量集
参数:
    sem:    指定销毁的信号量集
返回值:
    0 成功
    -1 失败   errno被设置

3.int sem_post(sem_t *sem);

功能:释放资源,给指定的信号量集加1
参数:
sem:指定的信号量集
返回值:
0 成功
-1 失败 errno被设置

4.int sem_wait(sem_t *sem);

功能:使信号量集的值-1,如果信号量集的值为0,等待。直到信号量集的值大于0;
参数:
    sem: 指定要操作的信号量集
返回值:
    0 成功
    -1 失败  errno被设置
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页