Linux库函数说明

struct socket   

{   

    socket_state              state;   

    unsigned long             flags;   

    const struct proto_ops    *ops;   

    struct fasync_struct      *fasync_list;   

    struct file               *file;   

    struct sock               *sk;   

    wait_queue_head_t         wait;   

    short                     type;   

};   

 

1.套接字连接相关    客户端：socket connect send recv   服务端： socket  bind  listen accept  send recv

 socket(创建socket client/server)    bind(绑定socket server)     listen(监听socket连接  server)   connect(建立socket连线 client)   accept(接受socket连线 server)  

  send(经socket传送数据  client/server)     recv(经socket接收数据  client/server)  

        1.1   socket()函数用法

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

                 参数：domain：即协议域，又称为协议族（family）常用的协议族有，AF_INET、AF_INET6

                           type：指定socket类型。常用的socket类型有，SOCK_STREAM、SOCK_DGRAM等

                           protocol：指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP  如调用者不想指定，可用0指定，表示缺省。

                 返回值：0,1,2分别表示标准输入、标准输出、标准错误；其他打开的文件描述符都会大于2, 错误时就返回 -1

                

                服务端：

        1.2   bind()函数用法

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

                参数：sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket，给这个描述字绑定一个名字

                            addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址

                            addrlen：对应的是地址的长度。

                返回值：成功返回 0  失败返回-1

                

        1.3   listen()函数用法

                int listen(int sockfd, int backlog)

                参数：sockfd：要监听的socket描述字

                            backlog：相应socket可以排队的最大连接个数

                返回值：成功返回 0  失败返回-1

                listen函数将socket变为被动类型的，对应的accept()为主动类型

                                    

        1.4   accept()函数用法

                int accept(int sockfd, struct sockaddr* addr, socklen_t* len)；

                参数：sockfd :套接字描述符  

                            addr :指向局部的数据结构sockaddr_in的指针。用于存放客户端的地址

                            len     : sizeof(struct sockaddr_in)

                返回：返回值是一个新的套接字描述符，它代表的是和客户端的新的连接，可以把它理解成是一个客户端的socket,这个socket包含的是     客户端的ip和port信息 。

                            -1:代表accept失败

                

                

                客户端：

        1.5   connect()函数用法

                用于客户端建立tcp连接，发起三次握手过程。

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

                参数：sockfd：标识一个套接字描述符

                            server_addr：套接字s想要连接的主机地址和端口号

                            addrlen：套接字s想要连接的主机地址和端口号

                返回：0：成功  -1：失败

 

                              

        1.6  send()函数用法

                ssize_t send(int sockfd, void *buff, size_t nbytes, int flags);

                参数：sockfd：发送端套接字描述符

                            buff：包含待发送数据的缓冲区。

                            nbytes：缓冲区中数据的长度。

                            flags：调用执行方式。一般设置为0

                返回：所发送数据的字节数

                      SOCKET_ERROR

                         

        1.7   recv()函数用法

                ssize_t recv(int sockfd, void *buff, size_t nbytes, int flags);

                参数：sockfd：接收端套接字描述符

                            buff：存放recv函数接收到的数据的缓冲区

                            nbytes：指明buff的长度

                            flags：调用执行方式。 一般设置为0

                返回：实际copy的字节数

                      SOCKET_ERROR

                      

        1.8 ioctl:

            /* include/linux/sockios.h                 */

            /* Socket configuration controls. */

            

            #define SIOCGIFNAME            0x8910        /* get iface name                        */

            #define SIOCSIFLINK            0x8911        /* set iface channel                    */

            #define SIOCGIFCONF            0x8912        /* get iface list                        */

            #define SIOCGIFFLAGS            0x8913        /* get flags                            */

            #define SIOCSIFFLAGS            0x8914        /* set flags                            */

            #define SIOCGIFADDR            0x8915        /* get PA address                        */

            #define SIOCSIFADDR            0x8916        /* set PA address                        */

            #define SIOCGIFDSTADDR        0x8917        /* get remote PA address            */

            #define SIOCSIFDSTADDR        0x8918        /* set remote PA address            */

            #define SIOCGIFBRDADDR        0x8919        /* get broadcast PA address        */

            #define SIOCSIFBRDADDR        0x891a        /* set broadcast PA address        */

            #define SIOCGIFNETMASK        0x891b        /* get network PA mask            */

            #define SIOCSIFNETMASK        0x891c        /* set network PA mask            */

            #define SIOCGIFMETRIC            0x891d        /* get metric                            */

            #define SIOCSIFMETRIC            0x891e        /* set metric                            */

            #define SIOCGIFMEM            0x891f        /* get memory address (BSD)        */

            #define SIOCSIFMEM            0x8920        /* set memory address (BSD)        */

            #define SIOCGIFMTU            0x8921        /* get MTU size                            */

            #define SIOCSIFMTU            0x8922        /* set MTU size                            */

            #define SIOCSIFNAME            0x8923        /* set interface name                     */

            #define SIOCSIFHWADDR            0x8924        /* set hardware address                 */

            #define SIOCGIFENCAP            0x8925        /* get/set encapsulations             */

            #define SIOCSIFENCAP            0x8926        

            #define SIOCGIFHWADDR            0x8927        /* Get hardware address            */

            #define SIOCGIFSLAVE            0x8929        /* Driver slaving support            */

            #define SIOCSIFSLAVE            0x8930

            #define SIOCADDMULTI            0x8931        /* Multicast address lists        */

            #define SIOCDELMULTI            0x8932                

            #define SIOCGIFINDEX            0x8933        /* name -> if_index mapping        */        

            #define SIOCSIFPFLAGS            0x8934        /* set/get extended flags set      */

            #define SIOCGIFPFLAGS            0x8935

            #define SIOCDIFADDR            0x8936        /* delete PA address                */

            #define SIOCSIFHWBROADCAST  0x8937            /* set hardware broadcast addr  */

            #define SIOCGIFCOUNT            0x8938        /* get number of devices                 */

            ...

            #define SIOCETHTOOL             0x8946          /* Ethtool interface                     */              

                      

                      

                

             

2.select(非阻塞方式完成程序)      

 

        void FD_ZERO (fd_set *fdset); // 清空fdset集合

        void FD_SET (int fd,fd_set *fdset); // 将fd文件描述符添加到fdset中

        void FD_CLR (int fd,fd_set *fdset); // 将fd文件描述符从fdset中删除

        intFD_ISSET(int fd,fd_set *fdset); // 检查集合中fd文件描述符是否可以读写

        int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval*timeout);

        fd_set可以理解为一个集合，这个集合中存放的是文件描述符(filedescriptor)  ，fd是其中一个，当fd读变化或者写变化时响应

        参数： maxfdp：fdset集合中所有文件描述符的范围  一般为所有文件描述符最大值加1

                     readfds: 指向fd_set结构的指针,监视fdset中文件描述符的读变化   //返回后值可能变化，需要每次重新调用添加文件描述符的宏FD_SET

                     writefds: 指向fd_set结构的指针,监视fdset中文件描述符的写变化  //一般为NULL

                     errorfds：用来监视文件错误异常

                     timeout:    NULL:阻塞模式

                                         0：非阻塞模式，立即返回

                                         timeout:timeout范围内阻塞，超出非阻塞

        返回值： 返回状态发生变化的描述符总数

                         正值：文件描述符变化总数

                         0：等待超时，没有可读写或错误文件

                         负值：select错误

                

3.memcpy（拷贝内存内容）和memset（将一段内存空间填入某值）memcmp(比较内存内容)

 

        3.1 memcpy()

                void *memcpy(void *dest, void *src, unsigned int count);

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

                        由src所指内存区域复制count个字节到dest所指内存区域。 src和dest所指内存区域不能重叠

                参数：dest：复制到的目标内存区域

                            src：源被复制的内存区域

                            count：从源内存区域内复制字节个数

                返回值：无或者指向dest的指针

注：当src和dest内存发生局部重叠时，memmove 能够保证复制结果是正确的，memcpy不能保证

 

        3.2 memcmp()

                int memcmp(const void *buf1, const void *buf2, unsigned int count);

                        比较内存区域buf1和buf2的前count个字节    按字节比较

                参数：

                返回值：当buf1<buf2时，返回值<0

                                当buf1=buf2时，返回值=0

                                当buf1>buf2时，返回值>0

 

        3.3 memset()

                void *memset(void *buffer, int c, int count)；

                        给内存赋值的函数

                        这个函数在socket中多用于清空数组    memset(buffer, 0, sizeof(buffer))

                参数：buffer：指针或数组

                            c：赋给buffer的值

                            count：buffer的长度

                返回值：无

 

4.strstr（在一字符串中查找指定的字符串） strcpy（拷贝字符串） strcmp（比较字符串） strncmp(比较两个字符串前n位)    strcasestr(在"子串"与"父串"进行比较的时候，"不区分大小写")

    strncat(添加字符串)  strchr(首次出现相同字符)  strrchr(右侧查找相同字符)

        4.1  strstr()

                char *strstr(char *str1, const char *str2);

                        用于判断字符串str2是否是str1的子串

                参数：str1: 被查找目标

                            str2: 要查找对象

                返回值：若str2是str1的子串，则返回str2在str1的首次出现的地址；如果str2不是str1的子串，则返回NULL。

 

        4.2  strcpy()

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

                        复制字符串的库函数

                参数：dst: 目标

                            src: 源  src->dst

                返回值：返回dst指针。

 

        4.3  strcmp()

                int strcmp(const char *s1,const char *s2);

                        比较字符串s1和s2    通过‘\0’结束

                参数：

                返回值：当s1<s2时，返回值<0

                                当s1=s2时，返回值=0

                                当s>s2时，返回值>0    

        4.3  strncmp()

                int strncmp(char *str1,char * str2，int n)

                        比较字符串str1和str2的前n个字符    

                参数：

                返回值：当s1<s2时，返回值<0

                                当s1=s2时，返回值=0

                                当s>s2时，返回值>0            

 

        4.4   strncat()

                char *strncat(char *dest,char *src,int n);

                        把src所指字符串的前n个字符添加到dest结尾处，覆盖dest结尾处的'/0'，实现字符串连接

                参数：dest: 目标

                            src: 源  src->dst

                            n：添加字符字节数

                返回值：返回指针，连接后的字符串        

        4.5        strchr()

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

                        查找字符串s中首次出现c字符的位置

                参数：

                返回值：首次出现c的位置的指针  否则为NULL

        4.6        strrchr()

                char *strrchr(const char *str, char c);

                找一个字符c在另一个字符串str中最后出现的位置（也就是从str的右侧开始查找字符c首次出现的位置）

                参数：

                返回值：返回从字符串中的这个位置起，一直到字符串结束的所有字符。否则为NULL

        4.7   strcasestr()

                #define _GNU_SOURCE

                char *strcasestr(const char *str1, const char *str2);

                        用于判断字符串str2是否是str1的子串，不区分大小写，使用时和#define _GNU_SOURCE一起使用。

                参数：str1: 被查找目标

                            str2: 要查找对象

                返回值：若str2是str1的子串，则返回str2在str1的首次出现的地址；如果str2不是str1的子串，则返回NULL。

                

                

5.opendir(打开目录)  readdir(读取目录)  stat(取得文件状态)

        想要获取某目录下（比如a目下）b文件的详细信息，我们应该怎样做？

        首先，我们使用opendir函数打开目录a，返回指向目录a的DIR结构体c。

        接着，我们调用readdir(c)函数读取目录a下所有文件（包括目录），返回指向目录a下所有文件的dirent结构体d。

        然后，我们遍历d，调用stat（d->name,stat *e）来获取每个文件的详细信息，存储在stat结构体e中

        5.1  opendir()

                DIR *opendir(const char *name);

                        打开一个与给定的目录名name相对应的目录流，并返回一个指向该目录流的指针。打开后，该目录流指向了目录中的第一个目录项。

                参数：name：目录名

                返回值：打开成功，返回指向目录流的指针；打开失败，则返回NULL

        5.2  readdir()

                struct dirent *readdir(DIR *dir);

                        函数返回一个指向dirent结构体的指针，该结构体代表了由dir指向的目录流中的下一个目录项

        5.3  closedir()

                int closedir(DIR *dir);

                        关闭与指针dir相联系的目录流.

                参数：

                返回值：成功时返回0；失败是返回-1

        5.4   stat()

                int stat(const char * file_name, struct stat *buf);

                        将参数file_name 所指的文件状态, 复制到参数buf 所指的结构中

                参数：file_name：dirent结构体对应name子项

                            buf：stat结构体，存储每个文件详细信息

                返回值：执行成功则返回0，失败返回-1

        附：

            struct stat {

        mode_t     st_mode;       //文件对应的模式，文件，目录等

        ino_t      st_ino;        //inode节点号

        dev_t      st_dev;        //设备号码

        dev_t      st_rdev;       //特殊设备号码

        nlink_t    st_nlink;      //文件的连接数

        uid_t      st_uid;        //文件所有者

        gid_t      st_gid;        //文件所有者对应的组

        off_t      st_size;       //普通文件，对应的文件字节数

        time_t     st_atime;      //文件最后被访问的时间

        time_t     st_mtime;      //文件内容最后被修改的时间

        time_t     st_ctime;      //文件状态改变时间

        blksize_t st_blksize;     //文件内容对应的块大小

        blkcnt_t   st_blocks;     //文件内容对应的块数量

      };

 

6.scandir（读取特定的目录数据）

        函数scandir扫描dir目录下以及dir子目录下满足filter过滤模式的文件，返回的结果是compare函数经过排序的，并保存在 namelist中。

        注意namelist是通过malloc动态分配内存的,所以在使用时要注意释放内存。

        alphasort和versionsort是使用到的两种排序的函数。

        int scandir(const char *dir,struct dirent **namelist,int (*filter)(const void *b),int (*compare)(const struct dirent **, const struct dirent ** ));

        if(namelist)

            free(namelist);

        参数：dir：将要扫描的目录

                    namelist：返回结果保存的内存空间（动态分配内存，需要释放）

                    filter：过滤dir目录下文件

                    compare：结果排序    

        返回值：返回找到匹配模式文件的个数，否则返回-1.

        

7. malloc()，calloc()，realloc()，alloca（）

        7.1    void* malloc(unsigned int size);                                                                        堆区  有程序员手动申请内存和释放

                在内存的动态存储区中分配一块长度为size字节的连续区域，                           

                参数：size：分配空间的长度

                返回值：返回该区域的首地址.

                

        7.2 void* realloc(void* ptr, unsigned int newsize);                                         堆区  有程序员手动申请内存和释放

                给一个已经分配了地址的指针重新分配空间

                参数：ptr：原有的空间地址

                          newsize：ptr重新申请的地址长度.

                返回值：返回值不一定是原来ptr对应的地址，最好将其重新赋值给ptr.

                如果传一个空指针（ptr=0）给 realloc并返回一个新地址，则相当于malloc

                

        7.3 void* calloc(size_t num, size_t size);                                                             堆区  有程序员手动申请内存和释放

                在内存中申请num个单个长度为size字节大小的连续地址空间.

                参数：num：申请的连续地址空间的个数

                          size：申请的单个连续空间的字节长度

                返回值：成功返回第一个连续空间的字节长度的首地址

                                失败返回NULL;

                

        7.4 void *alloca(size_t size)；                                                                                    栈区  系统自动释放

                从堆栈空间(stack)中配置size字节的内存空间，函数返回时自动释放空间   

                参数：size：用来配置的内存空间长度

                返回值：成功返回内存空间的首地址，

                                失败返回NULL；

                                

8.  atexit(void *p())

          //传入一个函数，每次调用exit的时候都会去调用这个传入的函数，一般用来作程序结束前的清理工作，传入的函数必须

          是无参数的，最多可以传入32个，调用的顺序和传入的顺序相反。(非_exit())

          

9. typedef void (*sighandler_t)(int);

        sighandler_t signal(int signum, sighandler_t handler);

          //作用1：站在应用程序的角度，注册一个信号处理函数

      //作用2：忽略信号，设置信号默认处理 信号的安装和回复

      参数：signum：准备注册或屏蔽的信号

                  handler：接收到指定信号时将要调用的函数   SIG_IGN屏蔽  SIG_DFL 恢复默认

      返回值：成功：返回以前该信号的处理函数的地址

                      失败：SIG_ERR

                      

10.  feof(是否读完 fread end of file)     ferror(是否正常结束)   clearerr(重置结束标志和错误标志)

 

        10.1 int feof(FILE *fp)

            用于检测是否读到文件的末尾。

            参数：fp 正在读取的文件的文件标志符

            返回值：未访问到文件末尾 返回0

                            访问到文件末尾 返回1

                                    

        10.2 int ferror(FILE *fp)

            用于检测是否出现读写错误。

            参数：fp 正在读写的文件的文件标志符

            返回值：正常访问结束 返回0

                            非正常访问结束 返回非零 errno

                                    

        10.3 void clearerr(FILE *fp)

                    重置文件结束标志和错误标志

                                    

11.gethostname(得到本机主机名或者域名)  gethostbyname(通过域名或者主机命返回IP地址)

 

        11.1 intPASCAL FAR gethostname(char FAR *name, int namelen)

            返回本地主机的标准主机名

            参数：name  指向将要存放主机名的缓冲区指针

                        namelen  缓冲区的长度

            返回值：正确返回0 ，否则返回SOCKET_ERROR

            

        11.2 struct hostent*gethostbyname(const char *name)

            返回对应于给定主机名的主机信息

            参数：name 指向主机名的指针

            返回值：正确返回一个hostent结构体，否则返回NULL

        

        struct hostent

    {

        char   *h_name;         //主机的规范名         

        char    **h_aliases;  //主机的别名

        int    h_addrtype;        //主机ip地址的类型

        int    h_length;            //主机ip地址的长度

        char   **h_addr_list;    //网络字节序存储的主机IP地址

        #define h_addr h_addr_list[0]

    };

            

12.inet_addr（点分十进制的IP转换成长整数型数）inet_aton（ip地址转化为二进制数值）   inet_ntoa（十进制网络字节序转换为点分十进制IP格式的字符串）   inet_pton（点分十进制的ip地址转化为网络传输的数值格式）inet_ntop（将数值格式转化为点分十进制的ip地址格式）

    

        12.1  in_addr_t inet_addr(const char *cp)

            将一个点分十进制的IP转换成一个长整数型数（u_long类型）

            参数：cp  IP地址 点分十进制

            返回值：正确返回无符号长整数型数，否则返回INADDR_NONE

            inet_addr("127.0.0.1");

            

        12.2   int inet_aton(const char *cp, struct in_addr *inp)

            把ip地址转化为二进制数值

            参数：cp ip地址  点分十进制

                        inp 存储转化后的二进制数值

            返回值：返回非零成功  否则返回0

            这个转换完后不能用于网络传输，还需要调用htons或htonl函数才能将主机字节顺序转化为网络字节顺序

            

        12.3  char * inet_ntoa(struct in_addr in);

            将一个十进制网络字节序转化为点分十进制IP地址

            参数：struct in_addr 网络上的IP地址

            返回值：，返回一个字符指针，否则返回NULL

            

        12.4  int inet_pton(int family, const char *strptr, void *addrptr)

            将一个点分十进制的ip地址转化为用于网络传输的数值格式

            参数：family  AF_INET   AF_INET6

                        strptr  IP地址     点分十进制

                        addrptr    数值格式   用于网络传输     sin_addr

            返回值：若成功则为1，若输入不是有效的表达式则为0，若出错则为-1  

        

        12.5  const char * inet_ntop(int family, const void *addrptr, char *strptr, size_t len)

            将数值格式转化为点分十进制的ip地址格式

            参数：family  AF_INET   AF_INET6

                        addrptr 数值格式   用于网络传输   sin_addr

                        strptr  IP地址    点分十进制

                        len          sizeof(strptr)

            返回值：若成功则返回指向结构的指针，若出错则为NULL

            

13.   poll(非阻塞方式完成程序) 类似select()

        #include <poll.h>

　　int poll(struct pollfd fd[], nfds_t nfds, int timeout)

        把当前的文件指针挂到等待队列

        参数：结构体 struct pollfd{

                                                        　　int fd;          //文件描述符

                                                        　　short events;    //请求的事件   POLLIN

                                                        　　short revents;   //返回的事件        可不指定

　                                                    　};

                    nfds：要监视的描述符的数目。

                    timeout：超时处理  ms   为-1时永远不会超时

        返回值：>0 数组fd中准备好读、写或出错状态的那些socket描述符的总数量；

                        =0 数组fds中没有任何socket描述符准备好读、写，或出错

                        -1 poll函数调用失败，同时会自动设置全局变量errno

        可完成连接队列的大小可自行设定，select为FD_SETSIZE固定

        

14. 头文件：#include <unistd.h>

        int unlink(const char * pathname);

        unlink()会删除参数pathname 指定的文件. 如果该文件名为最后连接点,

        但有其他进程打开了此文件, 则在所有关于此文件的文件描述词皆关闭后才会删除.

        如果参数pathname 为一符号连接, 则此连接会被删除。

        参数：pathname 待操作文件名

        返回值：成功则返回0, 失败返回-1, 错误原因存于errno

        

        错误代码：

        1、EROFS 文件存在于只读文件系统内。

        2、EFAULT 参数pathname 指针超出可存取内存空间。

        3、ENAMETOOLONG 参数pathname 太长。

        4、ENOMEM 核心内存不足。

        5、ELOOP 参数pathname 有过多符号连接问题。

        6、EIO I/O 存取错误。

    

15. #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);

        参数：fd：文件描述符操

                    cmd；对应操作命令

                    arg；供命令使用的参数

                    lock；同上

        

        返回值： 成功则返回0，若有错误则返回-1，错误原因存于errno.

fcntl函数有5种功能：

        1.复制一个现有的描述符（cmd=F_DUPFD）.

        2.获得／设置文件描述符标记(cmd=F_GETFD或F_SETFD).

        3.获得／设置文件状态标记(cmd=F_GETFL或F_SETFL).

        4.获得／设置异步I/O所有权(cmd=F_GETOWN或F_SETOWN).

        5.获得／设置记录锁(cmd=F_GETLK,F_SETLK或F_SETLKW).

        

        F_DUPFD   返回一个如下描述的(文件)描述符:                            

                    （1）最小的大于或等于arg的一个可用的描述符                          

                    （2）与原始操作符一样的某对象的引用               

                    （3）如果对象是文件(file)的话,返回一个新的描述符,这个描述符与arg共享相同的偏移量(offset)                    

                    （4）相同的访问模式(读,写或读/写)                          

                    （5）相同的文件状态标志(如:两个文件描述符共享相同的状态标志)                            

　　　　　（6）与新的文件描述符结合在一起的close-on-exec标志被设置成交叉式访问execve(2)的系统调用                     

 

        F_GETFD     取得与文件描述符fd联合close-on-exec标志,类似FD_CLOEXEC.如果返回值和FD_CLOEXEC进行与运算结果是0的话,文件保持交叉式访问exec(),　　　　　　                      

                   否则如果通过exec运行的话,文件将被关闭(arg被忽略)                  

 

        F_SETFD     设置close-on-exec旗标。该旗标以参数arg的FD_CLOEXEC位决定。                   

 

        F_GETFL     取得fd的文件状态标志,如同下面的描述一样(arg被忽略)                    

 

        F_SETFL     设置给arg描述符状态标志,可以更改的几个标志是：O_APPEND， O_NONBLOCK，O_SYNC和O_ASYNC。

        

        F_GETOWN         取得当前正在接收SIGIO或者SIGURG信号的进程id或进程组id,进程组id返回成负值(arg被忽略)                    

 

        F_SETOWN         设置将接收SIGIO和SIGURG信号的进程id或进程组id,进程组id通过提供负值的arg来说明,否则,arg将被认为是进程id

              

命令字(cmd)F_GETFL和F_SETFL的标志如下面的描述:            

 

    O_NONBLOCK  非阻塞I/O;如果read(2)调用没有可读取的数据,或者如果write(2)操作将阻塞,read或write调用返回-1和EAGAIN错误               　　　　       　　

    

    O_APPEND    强制每次写(write)操作都添加在文件大的末尾,相当于open(2)的O_APPEND标志         

 

    O_DIRECT    最小化或去掉reading和writing的缓存影响.系统将企图避免缓存你的读或写的数据.

                如果不能够避免缓存,那么它将最小化已经被缓存了的数 据造成的影响.如果这个标志用的不够好,将大大的降低性能                      

 

    O_ASYNC     当I/O可用的时候,允许SIGIO信号发送到进程组,例如:当有数据可以读的时候

 

 

16.串口编程相关函数   tcflush（清空缓存函数）  tcgetattr（获取终端相关参数的函数）  tcsetattr（设置终端相关参数的函数）

        getopt（解析命令行选项参数函数）   perror（将上一个函数发生错误的原因输出到标准错误(stderr)）

        cfsetispeed（设置输入波特率）cfsetospeed（设置输出波特率）cfgetispeed（获取输入波特率）cfgetospeed（获取输出波特率）

        #include <termios.h>

        #include <unistd.h>

        struct termios

        {

                tcflag_t c_iflag; 输入模式标志，控制终端输入方式

              tcflag_t c_oflag; 输出模式标志，控制终端输出方式

              tcflag_t c_cflag; 控制模式标志，指定终端硬件控制信息

              tcflag_t c_lflag; 本地模式标志，控制终端编辑功能

              cc_t     c_cc(NCCS); 控制字符，用于保存中断驱动程序中的特殊字符，如输入借宿字符等。

        };   

        

        16.1  tcflush（int fd，int quene）

            作用是清空输入缓存和输出缓存   输入缓存是值中断驱动已接收，但用户未读的数据。相对而言，输出缓存是用户已写但尚未发出的数据。

            参数：fd：终端I/O打开的句柄

                        quene：需要清空的队列 控制tcflush的操作，取值为下面三个常数中的一个：

                        TCIFLUSH  // 清除正收到的数据，且不会读取出来。   I

                        TCOFLUSH  // 清除正写入的数据，且不会发送至终端。 O

                        TCIOFLUSH // 清除所有正在发生的I/O数据。                    I/O

            

            返回值：成功返回0 失败返回-1 并且为 errno 置值来指示错误

 

        16.2  tcgetattr（int fd, struct termios *termios_p）

            用于获取终端相关的参数

            参数：fd：打开的终端文件描述符

                        termios_p：函数返回的结果保存在termios的结构体termios_p中

            

            返回值：成功 0 失败-1

  

            注意：不要使用赋值语句，应该使用 &=~

            

        16.3  tcsetattr（int fd, int optional_actions, const struct termios *termios_p）

            用于设置终端相关的参数

            参数：fd：打开的终端文件描述符

                        optional_actions：用于控制修改其作用的时间

                            TCSANOW   不等数据传输完毕就立即改变属性  now

                        TCSADRAIN 等待所有数据传输结束才改变属性  drain

                        TCSAFLUSH 清空输出缓冲区才改变属性                flush

                        termios_p：将要修改的参数保存在termios的结构体termios_p中

            

            返回值：成功 0 失败-1

        

        16.4  int getopt（int argc,char * const argv[],const char *optstring）

            用来分析命令行参数

            参数：argc：main函数传递的参数个数

                        argv：main函数传递的参数内容

                        optstring：欲处理的选项字符串 a表示选项   a: 选项后必须跟一个参数  参数紧跟在选项后或者以空格隔开 该参数的指针赋给optarg

                                                 a:: 选项后面可跟也可不跟参数 若跟，参数必须紧跟在选项后不能以空格隔开。该参数的指针赋给optarg

            

            返回值：如果找到符合的参数则返回此参数字母，如果参数不包含在参数optstring 的选项字母则返回“?”字符，分析结束则返回-1

            扩展：

            extern char* optarg   保存选项的参数的指针

            extern int optind        再次调用 getopt() 时的下一个 argv 指针的索引

            extern int opterr   是否将错误信息输出到stderr   0表示不输出

            extern int optopt   当命令选项字符不包括在optstring中，或选项缺少必要参数时，该选项存储在optopt中，getopt返回"?"

        

        16.5  perror（const char *str）

            参数str所指的字符串会先打印出来，后面再加上错误原因字符串。此错误原因依照全局变量error的值来决定要输出的字符串。

        

        16.6  int cfsetispeed(struct termios *termptr, speed_t speed);（cfsetospeed）

            参数：termptr：指向termios结构的指针

                        speed：设置输入/输出波特率

            

            返回值：成功返回0,否则返回-1

            

        16.7  speed_t  cfgetispeed(const struct termios *termptr);（cfgetospeed）

            参数：termptr：指向termios结构的指针

            

            返回值：返回输入/输出的波特率

 

 

17. assert(如果它的条件返回错误，则终止程序执行)

            #include <assert.h>

            void assert( int expression);

            如果其值为假（即为0），那么它先向stderr打印一条出错信息，然后通过调用 abort 来终止程序运行

            

            已放弃使用assert()的原因是，频繁的调用会极大的影响程序的性能，增加额外的开销。

            在调试结束后，可以通过在包含#include <assert.h>的语句之前插入 #define NDEBUG 来禁用assert调用，

            

        用法：

            1.在函数开始处检验传入参数的合法性     assert(nNewSize >= 0)

            2.每个assert只检验一个条件，因为同时检验多个条件时，如果断言失败，无法直观的判断是哪个条件失败  assert(nOffset>=0 && nOffset+nSize<=m_nInfomationSize)

            3.能使用改变环境的语句，因为assert只在DEBUG个生效，如果这么做，会使用程序在真正运行时遇到问题   assert(i++ < 100);

            4.ssert和后面的语句应空一行，以形成逻辑和视觉上的一致感

            5.有的地方，assert不能代替条件过滤     assert是用来避免显而易见的错误的，而不是处理异常的

            

        一个非常简单的使用assert的规律就是，在方法或者函数的最开始使用，如果在方法的中间使用则需要慎重考虑是否是应该的。

            方法的最开始还没开始一个功能过程，在一个功能过程执行中出现的问题几乎都是异常

        

18. access (判断文件是否存在以及权限)

    #include<unistd.h>

    int access(const char* pathname, int mode);

    输入：pathname： 是文件的路径名+文件名

                mode        ： 指定access的作用，取值如下

                

  F_OK 值为0，判断文件是否存在

  X_OK 值为1，判断对文件是可执行权限

  W_OK 值为2，判断对文件是否有写权限

  R_OK 值为4，判断对文件是否有读权限

  注：后三种可以使用或“|”的方式，一起使用，如W_OK|R_OK

 

19. strftime（格式化输出时间）

  size_t strftime(char *str, size_t maxsize, const char *format, const struct tm *timeptr)

     根据  format  中定义的格式化规则，格式化结构  timeptr  表示的时间，并把它存储在  str  中。

            参数：str：   指向目标数组的指针，用来复制产生的 C 字符串。

maxsize： 复制到 str 的最大字符数

format： 字符串，包含了普通字符和特殊格式说明符的任何组合。这些格式说明符用来替换 tm 中所指定时间

timeptr： 指向 tm 结构的指针，该结构包含了一个呗分解为以下各部分的日历时间

                返回值： 如果产生的 字符串小于 size 个字符（包括空结束字符），则会返回复制到 str 中的字符总数（不包括空结束字符）

                                否则返回零。

 

20 va_list()     va_start()  va_arg()     va_end()    _vsnprintf()

va_list宏定义了一个指针类型，这个指针类型指向参数列表中的参数。

void va_start(va_list ap, last_arg)，修改了用va_list申明的指针，使这个指针指向了不定长参数列表省略号前的参数。

type va_arg(va_list, type)，获取参数列表的下一个参数，并以type的类型返回。

void va_end(va_list ap)， 参数列表访问完以后，参数列表指针与其他指针一样，必须收回，否则出现野指针。

一般va_start 和va_end配套使用。

int vsnprintf(char* str, size_t size, const char* format, va_list ap);

和snprintf唯一不同的是最后一个参数和va_list配套使用

 

21.init_timer(初始化 定时器 )    add_timer(增加 定时器 )   del_timer(删除定时器)   mod_timer(修改定时器的expires)     

Linux的内核中定义了一个定时器结构：

#include <linux/timer.h>

struct timer_list{

    struct list head_list;

    unsigned long expires;//定时器到期时间

    unsigned long data;//作为参数被传入定时器处理函数

    void (*function)(unsigned long);

};

利用这个结构我们可以在驱动中很方便的使用定时器。

init_timer(struct timer_list *timer)

add_timer (struct timer_list *timer)

del_timer (struct timer_list *timer)

mod_time r (struct timer_list *timer,unsigned long expires);     

一般使用  mod_timer(&my_timer, jiffies+new_delay);    

         msecs_to_jiffies(3000)  ;3000ms

 

22.getrlimit(获取) s etrlimit(设置) 每个进程能够创建的各种系统资源的限制使用量

#include <sys/resource.h>

struct rlimit {

　　rlim_t rlim_cur;//soft limit curren limit

　　rlim_t rlim_max;//hard limit the max value for rlim_cur

};

在 Linux 系统中， Resouce limit 指在一个进程的执行过程中，它所能得到的资源的限制，比如进程的 core file 的最大值，虚拟内存的最大值等。

softlimit是指内核所能支持的资源上限。比如对于RLIMIT_NOFILE(一个进程能打开的最大文件数，内核默认是1024)，softlimit最大也只能达到1024。对于RLIMIT_CORE(core文件的大小，内核不做限制)，soft limit最大能是unlimited

hard limit在资源中只是作为softlimit的上限。当你设置hard limit后，你以后设置的softlimit只能小于hard limit

int getrlimit( int resource, struct rlimit *rlim);

int setrlimit( int resource, const struct rlimit *rlim);

参数：

resource：可能的选择有

 

RLIMIT_AS //进程的最大虚内存空间，字节为单位。

RLIMIT_CORE //内核转存文件的最大长度。

RLIMIT_CPU //最大允许的CPU使用时间，秒为单位。当进程达到软限制，内核将给其发送SIGXCPU信号，这一信号的默认行为是终止进程的执行。然而，可以捕捉信号，处理句柄可将控制 返回给主程序。如果进程继续耗费CPU时间，核心会以每秒一次的频率给其发送SIGXCPU信号，直到达到硬限制，那时将给进程发送 SIGKILL信号终止其执行。

RLIMIT_DATA //进程数据段的最大值。

RLIMIT_FSIZE //进程可建立的文件的最大长度。如果进程试图超出这一限制时，核心会给其发送SIGXFSZ信号，默认情况下将终止进程的执行。

RLIMIT_LOCKS //进程可建立的锁和租赁的最大值。

RLIMIT_MEMLOCK //进程可锁定在内存中的最大数据量，字节为单位。

RLIMIT_MSGQUEUE //进程可为POSIX消息队列分配的最大字节数。

RLIMIT_NICE //进程可通过setpriority() 或 nice()调用设置的最大完美值。

RLIMIT_NOFILE //指定比进程可打开的最大文件描述词大一的值，超出此值，将会产生EMFILE错误。

RLIMIT_NPROC //用户可拥有的最大进程数。

RLIMIT_RTPRIO //进程可通过sched_setscheduler 和 sched_setparam设置的最大实时优先级。

RLIMIT_SIGPENDING //用户可拥有的最大挂起信号数。

RLIMIT_STACK //最大的进程堆栈，以字节为单位。

返回说明：

 

成功执行时，返回0。失败返回-1，errno被设为以下的某个值

EFAULT：rlim指针指向的空间不可访问

EINVAL：参数无效

EPERM：增加资源限制值时，权能不允许

23.