Linux 网络编程(UDP模型，libevent库使用)

1.ctags的使用

安装命令：sudo apt install exuberant-ctags

要使用ctags需要在当前目录生成 tags 文件，可以组织目录内所有.c间函数调用关系

生成方法：1.在项目目录下输入命令：ctags ./* -R

2.在任意一个文件内使用 ctrl+p

一些快捷命令：

命令	作用
ctrl + ]	光标放置于调用函数上，跳转至函数定义位置
ctrl + t	返回到此前跳转位置
ctrl + o	在文件左边列出文件列表，再次 ctrl+o关闭
F4	在文件右边列出函数列表，再次 F4 关闭

2.UDP通信的实现

1.使用到的函数

1.recvfrom函数：包含在头文件<sys/types.h>和<sys/socket.h>

函数原型：

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen);
    作用：接受信息，涵盖了客户端或者服务器的信息
    参数解释：
        参数sockfd：服务器socket
        参数buf：缓冲区
        参数len：缓冲区大小
        参数src_addr：对端的结构体对象
        参数addrlen：结构体大小
    返回值：成功返回接受的数据字符个数，失败返回-1，返回0，表示对端关闭

2.sendto函数：包含在头文件<sys/types.h>和<sys/socket.h>

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);
    作用：发送信息，涵盖了客户端或者服务器的信息
    参数解释：
        参数sockfd：服务器socket
        参数buf：缓冲区
        参数len：缓冲区大小
        参数src_addr：目标结构体对象
        参数addrlen：结构体大小
    返回值：成功返回写出的数据字符个数，失败返回-1，返回0，表示对端关闭

3.fgets函数：包含在头文件<stdio.h>

函数原型：

char *fgets(char *s, int size, FILE *stream); 
    作用：从stream流中读取size个字符存储到字符指针变量s所指向的内存空间
    参数解释：
        参数s：表示存储字符的空间地址
        参数size：读取字符串的长度
        参数stream：表示从何种流中读取，可以是标准输入流stdin，也可以是文件流

UDP客户端实现代码

#include<stdio.h>
#include<string.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include<unistd.h>

int main()
{
    int cfd = socket(AF_INET, SOCK_DGRAM, 0);
    struct sockaddr_in client_addr;
    client_addr.sin_family = AF_INET;
    client_addr.sin_port = htons(12345);
    inet_pton(AF_INET, "127.0.0.1", &client_addr.sin_addr.s_addr);
    char buf[1024] = {0};
    while(fgets(buf, 1024, stdin) != NULL)
    {
        //参数5使用的是服务器的socket信息
        int n = sendto(cfd, buf, strlen(buf), 0, (struct sockaddr*)&client_addr,sizeof(client_addr)); 
        memset(buf, 0, 1024);
        recvfrom(cfd, buf, 1024, 0, NULL, 0);
        printf("服务器发来消息：%s", buf);
    }
    
    close(cfd);
    return 0;
}

UDP服务器实现代码

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include<ctype.h>

int main()
{
    int lfd = socket(AF_INET, SOCK_DGRAM, 0);//在这里使用sock_dgram
    struct sockaddr_in sev_addr;
    bzero(&sev_addr, sizeof(sev_addr));
    sev_addr.sin_family = AF_INET;
    sev_addr.sin_port = htons(12345);
    sev_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    
    bind(lfd, (struct sockaddr*)&sev_addr, sizeof(sev_addr));
    printf("wait connecting.....\n");
    struct sockaddr_in client_addr;
    char buf[1024] = {0};
    int i;
    while(1)
    {
        int client_len = sizeof(client_addr);
        //接受客户端的同时，参数5可以获取到客户端的socket信息
        int n = recvfrom(lfd, buf, 1024, 0, (struct sockaddr*)&client_addr, &client_len);
        printf("客户端发来消息：%s",buf); 
        for(i = 0;i < n;i++);
        {
            buf[i] = toupper(buf[i]);
        }
        //给获取到的客户端发送消息
        sendto(lfd, buf, n, 0, (struct sockaddr*)&client_addr, sizeof(client_addr));
    }
    close(lfd);
    return 0;
}    

3.本地套接字

概念：进程间通信的一种方式是使用UNIX套接字，人们在使用这种方式时往往用的不是网络套接字，而是一种称为本地套接字的方式，就是创建一个伪文件访问绑定结构体成员中的path作为一个通信的介质

1.使用到的函数以及结构体

1.socket_un结构体

结构体原型：

struct sockaddr_un
        {
            sa_family_t  sun_family；    //地址结构体类型，只能是AF_LOCAL或AF_UNIX
            char         sun_path[108]；    //本地文件的路径通常放在/tmp下
        }
    在sockaddr_un需要使用strcpy()函数把伪文件名赋值给岑有sun_path

2.offset函数：包含在头文件<stddef.h>

函数原型：

size_t offsetof(type, member);
    作用：计算结构体成员在内存中的偏移量
    参数解释：
            参数type：结构体名称
            参数member：是结构体的内部成员
        返回值：返回成员在结构体中的偏移量

3.unlink函数：包含在头文件<unistd.h>

函数原型：

int unlink(const char *pathname);
    作用：从文件系统中删除一个名称。如果名称是文件的最后一个连接，并且没有其它进程将文件打开
，名称对应的文件会实际被删除
        参数解释：需要解除连接的文件名

本地套接字通信的客户端代码实现

#include<stdio.h>
#include<unistd.h>
#include<ctype.h>
#include<string.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include<sys/un.h>
#include<stddef.h>

#define CLIENT_FILE "client.socket"
#define SERVER_FILE "serv.socket"

int main()
{
    int cfd = socket(AF_UNIX, SOCK_STREAM, 0);
    struct sockaddr_un client_addr;
    bzero(&client_addr, sizeof(client_addr));
    client_addr.sun_family = AF_UNIX;
    strcpy(client_addr.sun_path, CLIENT_FILE);
    //因为本地套接字不会自动绑定socket端口号和ip地址信息，所以需要使用bind函数进行绑定
    int len = offsetof(struct sockaddr_un, sun_path) + strlen(client_addr.sun_path);
    unlink(CLIENT_FILE);
    bind(cfd, (struct sockaddr*)&client_addr, len);    //需要手动绑定数据信息,在本地套接字是不会自动绑定结构体信息的
    
    

    struct sockaddr_un serv_addr;
    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sun_family = AF_UNIX;
    strcpy(serv_addr.sun_path, SERVER_FILE);
    len = offsetof(struct sockaddr_un, sun_path) + strlen(serv_addr.sun_path);
    //因为是需要连接的是服务器，所以需要传服务器的文件套接字
    connect(cfd, (struct sockaddr*)&serv_addr, len);

    char buf[1024] = {0};
    while(fgets(buf, 1024, stdin) != NULL)
    {
        write(cfd, buf, strlen(buf));
        int ret = read(cfd, buf, 1024);
        if(ret == 0 || ret == -1)
        {
            printf("error\n");
            break;
        }
        printf("服务器%s发来消息：%s\n", serv_addr.sun_path, buf);
    }
    close(cfd);
    return 0;
}
    

本地通信的套接字服务器代码实现

#include<stdio.h>
#include<unistd.h>
#include<stddef.h>
#include<string.h>
#include<ctype.h>
#include<arpa/inet.h>
#include<sys/un.h>

#define SERV_FILE "serv.socket"

int main()
{
    int lfd = socket(AF_UNIX, SOCK_STREAM, 0);
    struct sockaddr_un serv_addr;
    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sun_family = AF_UNIX;
    strcpy(serv_addr.sun_path, SERV_FILE);//把文件路径复制到结构体成员
    //因为结构体sockaddr_un具有首部2字节长度，所以需要使用该函数计算path的实际长度    
    int len = offsetof(struct sockaddr_un, sun_path) + strlen(serv_addr.sun_path);//求取文件名字的实际长度
    
    unlink(SERV_FILE);//如果该文件socket存在则先删除
    bind(lfd, (struct sockaddr*)&serv_addr, len);//绑定给socket
    
    listen(lfd, 20);

    struct sockaddr_un client_addr;//给accept函数使用，用来绑定客户端的信息    
    char buf[1024] = {0};    

    printf("Accept....\n");
    while(1)
    {
        int client_len = sizeof(client_addr);//作为accept函数的第三个参数
        //参数2是客户端本地套接字信息，但是和服务器的一样，参数三获取到的是client_addr.sun_path的实际长度
        int cfd = accept(lfd, (struct sockaddr*)&client_addr, (socklen_t*)&client_len);
        
        len -= offsetof(struct sockaddr_un, sun_path);/* 得到文件名的长度 */
               client_addr.sun_path[len] = '\0';                 /* 确保打印时,没有乱码出现 */

            printf("client bind filename %s\n", client_addr.sun_path);
        
        int size = 0;
        int i = 0;
        while((size = read(cfd, buf, 1024)) > 0)
        {
            for(i = 0;i < size;i ++)
            {
                buf[i] = toupper(buf[i]);
            }
            printf("客户端%s的消息：%s\n", client_addr.sun_path, buf);
            write(cfd, buf, size);
        }
        close(cfd);
    }


    close(lfd);    
    return 0;
}

4.事件异步通信模型

在这个模型中需要使用到libevent库，下载网址：www.libevent.org，下载tar安装包并且上传到linux服务器

1.如图，是上传的安装包

2.使用如下命令进行解包

tar -zxvf libevent-2.1.10-stable.tar.gx

生成如下文件

3.进入该文件

4.执行如下命令

1. ./configure
2. make
3. sudo make install

这样就可以使用libevent库了

使用libevent创建服务器的过程

1.使用socket创建套接字

2.设置端口复用->setsockopt()

3.绑定IP地址->bind

4.设置监听->listen

5.创建地基->event_base_new()函数

作用：event_base_new（）函数分配并且返回一个新的具有默认设置的event_base。函数会检测环境变量，返回一个到event_base的指针。

函数原型：

struct  event_base  * event_base_new(void );

    返回值：如果发生错误，则返回NULL

6.创建服务器socket对应的事件->event_new函数

作用：分配并初始化一个新的event结构体，准备被添加

函数原型：

struct event*event_new(struct event_base*base, evutil_socket_t fd, short whar, 
                            event_callback_fn cb, void *arg);
    参数解释：
        参数base：event_base_new的返回值
        参数 fd：绑定到event上的 文件描述符
        参数what：对应的事件(r w e)
            EV_READ    一次 读事件
            EV_WRTIE    一次 写事件
            EV_PERSIST    持续触发，结合 event_base_dispatch函数使用，生效
        参数cb：一旦事件满足监听条件，触发该事件的处理函数，就是回调函数
        参数arg：回调的函数的参数
    返回值：成功创建的 event
    
    回调函数的规范书写：
typedef void(*event_callback_fn)(evutil_socket_t fd, short, void*)

7.把服务器socket对应的事件放上event_base地基上->event_add函数

作用：该函数将event_new创建出来的事件挂上地基，实现监听

函数原型：

int event_add(struct event* ev, const struct timeval *tv)
    参数解释：
        参数ev：event_new的返回值
        参数tv：表示超时时间
            NULL：表示没有超时，一直等待，直到有事件触发，才会调用回调函数
            非0值：如果超过指定的时间，即使没有事件触发也会调用回调函数    

8.进入时间循环->event_base_dispatch

作用：事件调度循环，此循环将运行event，直到不再有挂起或活动的事件，或者直到有东西调用event_base_loopbreak（）或event_ base_loopexit（）

函数原型：

int event_base_dispatch(struct event_base *);
    参数：event_base_new创建的返回值

事件处理调用函数：
int event_base_loop(struct event_base *, int);
    作用：等待事件变为活动状态，然后运行它们的回调。这是比event_base_dispatch更灵活版本。
默认情况下，此循环将运行事件库，直到不再存在挂起或活动事件，
或者直到调用event_base_loopbreak（）或event_ base_loopexit（）
    参数解释：
        参数1：event_base_new的返回值
        参数2：可以设置重写函数的参数
    返回值：如果成功，则返回0；如果发生错误，则返回1；
            如果由于没有挂起或活动的事件而退出，则返回2

9.释放资源->event_base_free函数和event_free函数

作用：event_base_free释放地基的资源，event_free函数释放事件资源

使用libevent实现的服务器代码

#include<stdio.h>
#include<stdlib.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<string.h>
#include<event.h>

struct event* connev;

//回调函数的原型:typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void* arg)
//读数据回调函数
void readcb(evutil_socket_t fd, short events, void* arg)
{
    int n ;
    char buf[1024];
    memset(buf, 0x00, sizeof(buf));
    n = read(fd, buf, sizeof(buf));
    printf("客户端发来消息：%s\n", buf);
    if(n <= 0)
    {
        close(fd);
        //将对应的客户端事件从地基上删除
        event_del(connev);
    }
    else
        write(fd, buf, n);
}

//连接回调函数
void conncb(evutil_socket_t fd, short events, void* arg)
{
    struct event_base* base = (struct event_base*)arg;
    //接受客户端连接
    int cfd = accept(fd, NULL, NULL);
    if(cfd > 0)
    {    
        //创建客户端对应的事件并设置回调函数readcb
        //参数3是事件信号，参数4是回调函数
        connev = event_new(base, cfd, EV_READ|EV_PERSIST, readcb, NULL);
        if(connev == NULL)
        {
            //退出循环
            event_base_loopexit(base, NULL);
            printf("connev error\n");
            exit(1);
        }
        //将客户端对应的事件放到地基上
        event_add(connev, NULL);
    }
}

int main()
{
    //创建socket
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    //设置端口号复用
    int opt = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    //创建socket信息
    struct sockaddr_in serv_addr;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8888);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(lfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    //监听
    listen(lfd, 128);
    
    //创建地基
    struct event_base* base = event_base_new();
    if(base == NULL)
    {
        printf("event_base create error\n");
        return -1;
    }
    //创建监听文件描述符对应的事件
    struct event* ev = event_new(base, lfd, EV_READ|EV_PERSIST, conncb, base);
    if(ev == NULL)
    {
        printf("event_new error\n");
        return -1;
    }
    
    //将新的事件放到base地基上
    event_add(ev, NULL);
    //进入事件循环等待
    event_base_dispatch(base);
    //释放资源
    event_base_free(base);//释放地基资源
    event_free(ev);//释放事件资源
    
    close(lfd);
    return 0;
}

5.bufferevent的介绍

• bufferevent的读事件回调触发时机：

当数据由内核的读缓冲区到bufferevent的读缓冲区的时候，会触发bufferevent的读事件回调

注意:数据由内核到bufferevent的过程不是用户程序执行，而是由bufferevent内部操作的

• bufferevent的写事件回调触发时机：

当用户程序将数据写到bufferevent的写缓冲区之后，bufferevent会自动将数据写到内核的写缓冲区，

最终由内核程序将数据发送出去

• 事件回调：

当bufferevent绑定的socket连接，端口或者异常时候触发事件回调

使用的函数

1.函数原型

struct bufferevent* bufferevent_socket_new(struct event_base* base, 
                                        evutil_socket_t fd, int options);
        作用：对已经存在的socket创建bufferevent事件，可用于后面讲到的连接监听器的回调函数中
        参数解释：
            参数base：对应的根节点
            参数fd：文件描述符
            参数options：bufferevent的选项
                BEV_OPE_CLOSE_ON_FREE：释放bufferevent自动关闭底层接口
             (当bufferevent被释放以后，文件描述符也随之被close）
                BEV_OPT_THREADSAFE：使bufferevent能够在多线程下是安全的

2.函数原型：

int bufferevent_socket_connect(struct bufferevent* bev, 
                                struct sockaddr* serv, int socklen)
        作用：该函数封装了底层的socket与connect接口，通过调用此函数，
                可以将bufferevent事件与通信的socket进行绑定
        参数解释：
            参数bev：需要提前初始化的bufferevent事件
            参数serv：对端的ip地址，端口，协议结构指针
            参数socklen：描述serv的长度
        说明: 调用此函数以后，通信的 socket 与 bufferevent 缓冲区做了绑定，
                后面调用了bufferevent_setcb 函数以后，
                会对bufferevent 缓冲区的读写操作的事件设置回调函数，
                当往缓冲区中写数据的时候会触发写回调函数，
                当数据从 socket 的内核缓冲区读到 bufferevent 
                读缓冲区中的时候会触发读回调函数

3.函数原型：

void bufferevent_free(struct bufferevent* bufev);
        作用：释放bufferevent资源

4.函数原型：

void bufferevent_setcb(struct bufferevent* bufev,
                            bufferevent_data_cb readcb,
                            bufferevent_data_cb writecb,
                            bufferevent_event_cb eventcb, void *cbarg)
        作用：bufferevent_setcb用于设置bufferevent的回调函数，
                
        
         参数解释：
            参数bufev：bufferevent_socket_new()的返回值
            readcb，writecb，eventch分别对应读回调，写回调，事件回调，
               cbarg代表回调函数的参数

        回调函数的原型：
            typedef void(*bufferevent_data_cb)(struct bufferevent* bev, void* ctx) //读写回调函数
            typedef void(*bufferevent_event_cb)(struct bufferevent* bev, short, what, void* ctx)
            
            参数what：
                BEV_EVENT_EOF：遇到文件结束指示
                BEV_EVENT_ERROR：发生错误
                BEV_EVENT_TIMEOUT：发生超时
                BEV_EVENT_CONNECTED：请求的过程中连接已完成

5.函数原型：

int bufferevetn_write(struct bufferevent* bufev, const void* data, size_t size);
        作用：将data的数据写到bufferevent的写缓冲区

6.函数原型：

int bufferevetn_read(struct bufferevent* bufev, const void* data, size_t size);
        作用：将bufferevent的缓冲区数据读到data中，同时将读到的数据从bufferevent的缓冲区清除

6.函数原型：

void bufferevent_enable(struct bufferevent* bufev, short events)
    作用：启动bufferevent缓冲区
    参数events：EV_READ、EV_WRITE、EV_READ|EV_WRITE
    

6.链接监听器-evconnlistener

链接监听器封装了底层的 socket 通信相关函数，比如 socket, bind, listenaccept 这几个函数。链接监听器创建后实际上相当于调用了 socket, bind, listen此时等待新的客户端连接到来，如果有新的客户端连接，那么内部先进行调用accept处理，然后调用用户指定的回调函数

1.相关函数

1.函数原型：

struct evconnlistener* evconnlistener_new_bind(struct event_base* base, 
                                        evconnlistener_cb cb, void* ptr,
                                        unsigned flags, int backlog,
                                        const struct sockaddr* sa, int socklen)
        作用：是在当前没有套接字的情况下对链接监听器进行初始化，
                看最后 2 个参数实际上就是 bind 使用的关键参数, 
                   backlog 是listen 函数的关键参数
                    (略有不同的是如果 backlog 是-1, 那么监听器会自动选择一个合适的值,
                    如果填 0,那么监听器会认 listen 函数已经被调用过了) ,
                    ptr 是回调函数的参数, cb，是有新连接之后的回调函数,
                    但是注意这个回调函数触发的时候，
                    链接器已经处理好新连接了并将与新连接通信的描述符交给回调函数
        flag参数选项：
            LEV_OPT_LEAVE_SOCKETS_BLOCKING：文件描述符为阻塞的
            LEV_OPT_CLOSE_ON_FREE：关闭时自动释放
            LEV_OPT_REUSEABLE：端口复用
            LEV_OPT_THREADSAFE：分配锁，线程安全

    使用的回调函数：
        typedef void(*evconnlistener_cb)(struct evconnlistener* evl, 
                                        evutil_socket_t fd,    
                                        struct sockaddr*cliaddr,
                                        int socklen, void* ptr);

2.函数原型：

void evconnlistener_free(struct evconnlistener* lev);

作用：释放链接监听器

3.函数原型：

int evconnlistener_enable(struct evconnlistener* lev);

作用：使链接监听器生效

4.函数原型：

int evconnlistener_disable(struct evconnlistener* lev);

作用：使链接监听器失效

2.bufferevent的客户端

1.函数原型：

int bufferevent_socket_connect(struct bufferevent* bev,
                                struct sockaddr* address, int addrlen)
    作用：连接服务器
    参数解释：
        参数bev：bufferevent的事件对象
        参数2，3：对应connect的参数2，3

3.bufferevent的服务器函数

1.函数原型：

struct evconnlistener* evconnlistener_new_bind(
                    struct event_base* base,
                    evconnlistener_cb cb,
                    void *ptr,
                    unsigned flags,
                    int backlog,
                    const struct sockaddr* sa,
                    int socklen);
    作用：该函数可以完成socket，bind，listen，accept函数的功能
    参数解释：
        参数cb：监听回调函数，接受链接后，用户要做的操作
        参数ptr：回调函数的参数
        参数flags：可识别的标志
            LEV_OPT_CLOSE_ON_FREE：释放bufferevent时关闭底层传输端口
            LEV_OPT_REUSEABLE：端口复用
        参数backlog：listen函数中的参数2，传-1表示用默认最大值
        参数sa：服务器IP+PORT
        参数socklen：sa的大小
    返回值：成功创建的监听器

回调函数类型
typedef void(*evconnlistener_cb)(
                struct evconnlistenter* listen,
                evutil_socket_t sock,
                struct sockaddr* addr,
                int len,
                void* ptr)
    参数解释：
        参数listen：evconnlistenter_new_bind函数的返回值
        参数sock：用于通信的文件描述符，客户端的套接字
        参数adr：客户端的IP+端口
        参数len：addr的长度
        参数ptr：外部ptr传递的值
    注意：该回调函数不由我们区调用，由框架自动调用