libevent源码解析（六）evbuffer读写查找接口函数

短命女 2022-05-21 04:24 247阅读 0赞

### 一.前言 ###

在前一篇文章里我们给出了evbuffer和evbuffer\_chain相关的基础增删之类的接口函数，在本文中我们重点研究evbuffer的读写查找等接口函数的实现原理。

### 二.查找函数分析 ###

（1）evbuffer\_ptr结构体

该结构体用于查找使用。

/**
        指向buffer中指定位置，可以快速的浏览而不需要反复查找
        修改evbuffer会导致其失效
        Pointer to a position within an evbuffer.
    
        Used when repeatedly searching through a buffer.  Calling any function
        that modifies or re-packs the buffer contents may invalidate all
        evbuffer_ptrs for that buffer.  Do not modify or contruct these values
        except with evbuffer_ptr_set.
    
        An evbuffer_ptr can represent any position from the start of a buffer up
        to a position immediately after the end of a buffer.
    
        @see evbuffer_ptr_set()
     */
    
    struct evbuffer_ptr {
        ev_ssize_t pos;
    
        /* Do not alter or rely on the values of fields: they are for internal
         * use */
        struct {
            void *chain;
            size_t pos_in_chain;
        } internal_;
    };

（2）evbuffer\_ptr\_set()函数

给evbuffer\_ptr进行赋值。

/* 给evbuffer_ptr赋值
      * 两种使用方式：
      *（1）  evbuffer_ptr_set(buf, &pos, N, EVBUFFER_PTR_SET)
      *     从buffer开始设置第N位为pos指向的位置  
      *（2）  evbuffer_ptr_set(buf, &pos, N, EVBUFFER_PTR_ADD)
      *     向前N位，指向pos
      *
      *  对于未初始化的evbuffer_ptr只能用第一种
      */
    int
    evbuffer_ptr_set(struct evbuffer *buf, struct evbuffer_ptr *pos,
        size_t position, enum evbuffer_ptr_how how)
    {
        size_t left = position;
        struct evbuffer_chain *chain = NULL;
        int result = 0;
    
        EVBUFFER_LOCK(buf);
    
        /* 这里注意两种how的不同在于一个是pos = position * 另一个是pos = postion + pos，即从pos开始数position位置 */
        switch (how) {
        case EVBUFFER_PTR_SET:
            chain = buf->first;
            pos->pos = position;
            position = 0;
            break;
        case EVBUFFER_PTR_ADD:
            /* this avoids iterating over all previous chains if we just want to advance the position */
            if (pos->pos < 0 || EV_SIZE_MAX - position < (size_t)pos->pos) {
                EVBUFFER_UNLOCK(buf);
                return -1;
            }
            chain = pos->internal_.chain;
            pos->pos += position;
            position = pos->internal_.pos_in_chain;
            break;
        }
    
        EVUTIL_ASSERT(EV_SIZE_MAX - left >= position);
        while (chain && position + left >= chain->off) {
            left -= chain->off - position;
            chain = chain->next;
            position = 0;
        }
        if (chain) {
            pos->internal_.chain = chain;
            pos->internal_.pos_in_chain = position + left;
        } else if (left == 0) {
            /* The first byte in the (nonexistent) chain after the last chain */
            pos->internal_.chain = NULL;
            pos->internal_.pos_in_chain = 0;
        } else {
            PTR_NOT_FOUND(pos);
            result = -1;
        }
    
        EVBUFFER_UNLOCK(buf);
    
        return result;
    }

（3）搜索函数evbuffer\_search()

主要调用evbuffer\_search\_range（）

struct evbuffer_ptr
    evbuffer_search(struct evbuffer *buffer, const char *what, size_t len, const struct evbuffer_ptr *start)
    {
        return evbuffer_search_range(buffer, what, len, start, NULL);
    }

(4)evbuffer\_search\_range（）

/*查找函数，指明范围*/
    struct evbuffer_ptr
    evbuffer_search_range(struct evbuffer *buffer, const char *what, size_t len, const struct evbuffer_ptr *start, const struct evbuffer_ptr *end)
    {
        struct evbuffer_ptr pos;
        struct evbuffer_chain *chain, *last_chain = NULL;
        const unsigned char *p;
        char first;
    
        EVBUFFER_LOCK(buffer);
    
        /*start和end指明了查找的范围*/
        if (start) {
            memcpy(&pos, start, sizeof(pos));
            chain = pos.internal_.chain;
        } else {
            pos.pos = 0;
            chain = pos.internal_.chain = buffer->first;
            pos.internal_.pos_in_chain = 0;
        }
    
        if (end)
            last_chain = end->internal_.chain;
    
        if (!len || len > EV_SSIZE_MAX)
            goto done;
    
        first = what[0];
    
        /*根据start和end赋值得到的evbuffer_chain进行查找*/
        while (chain) {
            const unsigned char *start_at =
                chain->buffer + chain->misalign +
                pos.internal_.pos_in_chain;
    
            /* const void * memchr ( const void * ptr, int value, size_t num ); * 函数的作用是:在ptr指向的内存块中(长度为num个字节),需找字符value。 * 如果找到就返回对应的位置，找不到返回NULL */
            p = memchr(start_at, first,
                chain->off - pos.internal_.pos_in_chain);
            if (p) {
                //pos指向了这个chain中出现等于what[0]字符的位置
    
                pos.pos += p - start_at;
                pos.internal_.pos_in_chain += p - start_at;
    
                //evbuffer_ptr_memcmp比较整个字符串。如果有需要的话，该函数会跨
                //evbuffer_chain进行比较，但不会修改pos。如果成功匹配，那么返回0          
                if (!evbuffer_ptr_memcmp(buffer, &pos, what, len)) {
                    //end之后的就算找到了也算是失败
                    if (end && pos.pos + (ev_ssize_t)len > end->pos)
                        goto not_found;
                    else
                        goto done;
                }
                ++pos.pos;
                ++pos.internal_.pos_in_chain;
                //找完了也没找到
                if (pos.internal_.pos_in_chain == chain->off) {
                    chain = pos.internal_.chain = chain->next;
                    pos.internal_.pos_in_chain = 0;
                }
            } else {
                if (chain == last_chain)
                    goto not_found;
                /*在下一个evbuffer_chain寻找*/
                pos.pos += chain->off - pos.internal_.pos_in_chain;
                chain = pos.internal_.chain = chain->next;
                pos.internal_.pos_in_chain = 0;
            }
        }
    
    not_found:
        PTR_NOT_FOUND(&pos);
    done:
        EVBUFFER_UNLOCK(buffer);
        return pos;
    }