• 网络缓冲区

            windows下的体系，我不是特别了解。以下所有的内容都是在Linux下的理解，如果不对的地方，评论区欢迎留言。

    Linux收发数据

     接收数据

    大体的流程如上图所示，接下来我们对图中一些名词进行解释。

    -------------------------------------------------------------------------------------------------------------------------

    DMA:

    • 一种计算机系统中的技术，用于在外设和内存之间直接传输数据，而不需要CPU的干预。DMA技术通过在外设和内存之间建立直接的数据传输通路，绕过CPU直接进行数据传输。DMA控制器负责管理数据传输的过程，而CPU可以继续执行其他任务，提高了系统的并发性和效率。

    扩展1：

    • 在传统的计算机系统中，数据的传输通常需要通过CPU来完成。

    扩展2：

    • DMA技术可以应用于多种外设。例如：硬盘、音频设备等，当外设需要进行数据传输时，DMA控制器会向CPU发送请求，CPU将数据传输的任务交给DMA控制器处理。DMA控制器会直接读取或写入数据而不需要CPU干预。数据传输完成后，DMA控制器会向CPU发送中断信号，通知操作完成。

    -------------------------------------------------------------------------------------------------------------------------

    硬中断:

    • 向CPU发起硬中断的作用是通知CPU发生了一个重要的事件或需要CPU的处理。硬中断时由硬件设备触发的中断信号，用于引起CPU的注意并中断当前正在执行的程序。
    • 当硬件设备需要CPU的处理时，它会向CPU发送一个中断请求。CPU会暂停当前正在执行的程序，并跳转至一个预定义的中断处理程序来处理中断。中断处理程序是操作系统或设备驱动程序提供的，用于对中断事件进行处理。

    -------------------------------------------------------------------------------------------------------------------------

    屏蔽硬中断:

    • 处理器屏蔽硬中断是为了确保关键代码的执行不会被中断打断。

    -------------------------------------------------------------------------------------------------------------------------

    软中断：

    • CPU发起软中断的作用是触发操作系统中的中断处理程序，从而实现与操作系统进行交互和执行特定的系统功能。

    -------------------------------------------------------------------------------------------------------------------------

    总述:

            网卡是计算机里的一个硬件，专门负责接收和发送网络包，当网卡接收到一个网络包后，会通过DNA技术将网络包写入到指定的内存地址，也就是写入到RingBuffer中，这是一个环形缓冲区。接着网卡向CPU发起硬中断，当CPU收到硬件中断请求后，根据中断注册表，调用已经注册的中断处理函数(中断处理函数:暂时屏蔽硬中断、发起软中断-->通知内核里的ksoftirqd线程进行轮询从ringbuffer中读数据、恢复中断)。ksoftirqd线程从ringbuffer中获取一个数据帧之后保存在sk_buffer中，并且交给网络协议栈进行数据帧处理，经过协议栈处理完后的数据被放到socket读缓冲区中，等待应用程序通过系统调用读取数据。

    发送数据

            这个过程没有好说的，跟接收数据的返过程。需要注意的是TCP保证可靠交付，需要超时重传，需要备份。UDP是不需要的，不需要备份。

    用户层角度对数据包的处理流程

    用户态网络缓冲区

    为什么需要用户态网络缓冲区?(为什么需要为每条连接准备一个发送缓冲区和一个接收缓冲区?)

    • 从业务层面来说，我们可以看到read和处理数据包，组成数据包和write写入之间存在处理速度上的差异，也就是说当需要产生数据的能力比处理数据的能力强时，防止数据丢失，需要将数据未处理的数据进行短暂的存储。(生产者的速度大于消费者的速度是)
    • 从posix api接口(read、write)层面(粘包)，不能确定一次性接收数据，也不能保证一次性发送数据。

            由于存在这样的问题，我们需要设计一个缓冲区解决这样的问题...

    不同的网络模型会不会影响用户态网络缓冲区的设计？

            显然不会，上面两个矛盾发生在读取数据之后和处理数据之间，而不同的网络模型是对IO的不同处理方式。两个过程不是在同一阶段。换句话说就是一个是作用于读数据的方式不同，一个是作用于处理数据和读取快慢的问题上，而不是读取方式的问题上。

    UDP和TCP协议是否影响用户态网络缓冲区的设计？

            显然不会，很明显可以看出，UDP和TCP已经完成了将数据包写入socket缓冲区，而上面两个矛盾发生在处理数据和读写数据之间。两个不在通过阶段。换句话说就是UDP和TCP协议都存在上面的两个矛盾。

    用户态网络缓冲区的设计 

       这里的代码不要求完全自己实现，能看懂就行，知道其原理和缺点和优点就可以了。

    • 定长buffer:

            就是一个固定长度的数组，然后增加一个记录当前空闲的起始位置。

            优点:

            结构简单，易于实现。

            缺点：

            需要频繁的腾挪数据。

            需要实现扩缩容机制。

    • ringBuffer:

            就是一个环形队列，我们可以做到更好一点。就是采用2的能次幂大小的队列，这样可以把取余操作转成位操作，提高处理速度。

            具体的情况这里就不做分析了，为了方便大家理解代码，我把各种会出现的情况图罗列出来，不明白的话，评论区见。

            优点:

            不需要频繁的腾挪数据。

            缺点：

            需要实现扩缩容机制，扩缩容时需要腾挪数据。

            造成不连续的空间，可能引发多次系统调用。

    • chainBuffer：

            就是通过队列的将一块块空间连在一起，说白了就是把数组的连续空间变成了链表的方式，然后记录第一个块位置和最后一个块的位置，错觉上看起来像个连续的空间。

            优点:
            不腾挪数据
            动态扩缩容，不腾挪数据

            缺点：

            造成不连续的空间，可能引发多次系统调用

    RingBuffer代码 

    1. #ifndef _ringbuffer_h
    2. #define _ringbuffer_h
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. // #include   // for uint_max
    8. #include 
    9. #include 
    10.  
    11. typedef struct ringbuffer_s buffer_t;
    12.  
    13. buffer_t * buffer_new(uint32_t sz);
    14.  
    15. uint32_t buffer_len(buffer_t *r);
    16.  
    17.  
    18. void buffer_free(buffer_t *r);
    19.  
    20. int buffer_add(buffer_t *r, const void *data, uint32_t sz);
    21.  
    22. int buffer_remove(buffer_t *r, void *data, uint32_t sz);
    23.  
    24. int buffer_drain(buffer_t *r, uint32_t sz);
    25.  
    26. int buffer_search(buffer_t *r, const char* sep, const int seplen);
    27.  
    28. uint8_t * buffer_write_atmost(buffer_t *r);
    29.  
    30. #endif
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include "buffer.h"
    6.  
    7. struct ringbuffer_s {
    8.     uint32_t size;
    9.     uint32_t tail;
    10.     uint32_t head;
    11.     uint8_t * buf;
    12. };
    13.  
    14. #define min(lth, rth) ((lth)<(rth)?(lth):(rth))
    15.  
    16. static inline int is_power_of_two(uint32_t num) {
    17.     if (num < 2) return 0;
    18.     return (num & (num - 1)) == 0;
    19. }
    20.  
    21. static inline uint32_t roundup_power_of_two(uint32_t num) {
    22.     if (num == 0) return 2;
    23.     int i = 0;
    24.     for (; num != 0; i++)
    25.         num >>= 1;
    26.     return 1U << i;
    27. }
    28.  
    29. buffer_t * buffer_new(uint32_t sz) {
    30.     if (!is_power_of_two(sz)) sz = roundup_power_of_two(sz);
    31.     buffer_t * buf = (buffer_t *)malloc(sizeof(buffer_t) + sz);
    32.     if (!buf) {
    33.         return NULL;
    34.     }
    35.     buf->size = sz;
    36.     buf->head = buf->tail = 0;
    37.     buf->buf = (uint8_t *)(buf + 1);
    38.     return buf;
    39. }
    40.  
    41. void buffer_free(buffer_t *r) {
    42.     free(r);
    43.     r = NULL;
    44. }
    45.  
    46. static uint32_t
    47. rb_isempty(buffer_t *r) {
    48.     return r->head == r->tail;
    49. }
    50.  
    51. static uint32_t
    52. rb_isfull(buffer_t *r) {
    53.     return r->size == (r->tail - r->head);
    54. }
    55.  
    56. static uint32_t
    57. rb_len(buffer_t *r) {
    58.     return r->tail - r->head;
    59. }
    60.  
    61. static uint32_t
    62. rb_remain(buffer_t *r) {
    63.     return r->size - r->tail + r->head;
    64. }
    65.  
    66. int buffer_add(buffer_t *r, const void *data, uint32_t sz) {
    67.     if (sz > rb_remain(r)) {
    68.         return -1;
    69.     }
    70.  
    71.     uint32_t i;
    72.     i = min(sz, r->size - (r->tail & (r->size - 1)));
    73.  
    74.     memcpy(r->buf + (r->tail & (r->size - 1)), data, i);
    75.     memcpy(r->buf, data+i, sz-i);
    76.  
    77.     r->tail += sz;
    78.     return 0;
    79. }
    80.  
    81. int buffer_remove(buffer_t *r, void *data, uint32_t sz) {
    82.     assert(!rb_isempty(r));
    83.     uint32_t i;
    84.     sz = min(sz, r->tail - r->head);
    85.  
    86.     i = min(sz, r->size - (r->head & (r->size - 1)));
    87.     memcpy(data, r->buf+(r->head & (r->size - 1)), i);
    88.     memcpy(data+i, r->buf, sz-i);
    89.  
    90.     r->head += sz;
    91.     return sz;
    92. }
    93.  
    94. int buffer_drain(buffer_t *r, uint32_t sz) {
    95.     if (sz > rb_len(r))
    96.         sz = rb_len(r);
    97.     r->head += sz;
    98.     return sz;
    99. }
    100.  
    101. // 找 buffer 中 是否包含特殊字符串（界定数据包的）
    102. int buffer_search(buffer_t *r, const char* sep, const int seplen) {
    103.     int i;
    104.     for (i = 0; i <= rb_len(r)-seplen; i++) {
    105.         int pos = (r->head + i) & (r->size - 1);
    106.         if (pos + seplen > r->size) {
    107.             if (memcmp(r->buf+pos, sep, r->size-pos))
    108.                 return 0;
    109.             if (memcmp(r->buf, sep+r->size-pos, pos+seplen-r->size) == 0) {
    110.                 return i+seplen;
    111.             }
    112.         }
    113.         if (memcmp(r->buf+pos, sep, seplen) == 0) {
    114.             return i+seplen;
    115.         }
    116.     }
    117.     return 0;
    118. }
    119.  
    120. uint32_t buffer_len(buffer_t *r) {
    121.     return rb_len(r);
    122. }
    123.  
    124. uint8_t * buffer_write_atmost(buffer_t *r) {
    125.     uint32_t rpos = r->head & (r->size - 1);
    126.     uint32_t wpos = r->tail & (r->size - 1);
    127.     if (wpos < rpos) {
    128.         uint8_t* temp = (uint8_t *)malloc(r->size * sizeof(uint8_t));
    129.         memcpy(temp, r->buf+rpos, r->size - rpos);
    130.         memcpy(temp+r->size-rpos, r->buf, wpos);
    131.         free(r->buf);
    132.         r->buf = temp;
    133.         return r->buf;
    134.     }
    135.     return r->buf + rpos;
    136. }

    chainBuffer代码 

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include "buffer.h"
    6.  
    7.  
    8. struct buf_chain_s {
    9.     struct buf_chain_s *next;
    10.     uint32_t buffer_len;
    11.     uint32_t misalign;
    12.     uint32_t off;
    13.     uint8_t *buffer;
    14. };
    15.  
    16. struct buffer_s {
    17.     buf_chain_t *first;
    18.     buf_chain_t *last;
    19.     buf_chain_t **last_with_datap;
    20.     uint32_t total_len;
    21.     uint32_t last_read_pos; // for sep read
    22. };
    23.  
    24. #define CHAIN_SPACE_LEN(ch) ((ch)->buffer_len - ((ch)->misalign + (ch)->off))
    25. #define MIN_BUFFER_SIZE 1024
    26. #define MAX_TO_COPY_IN_EXPAND 4096
    27. #define BUFFER_CHAIN_MAX_AUTO_SIZE 4096
    28. #define MAX_TO_REALIGN_IN_EXPAND 2048
    29. #define BUFFER_CHAIN_MAX 16*1024*1024  // 16M
    30. #define BUFFER_CHAIN_EXTRA(t, c) (t *)((buf_chain_t *)(c) + 1)
    31. #define BUFFER_CHAIN_SIZE sizeof(buf_chain_t)
    32.  
    33. uint32_t
    34. buffer_len(buffer_t *buf) {
    35.     return buf->total_len;
    36. }
    37.  
    38. buffer_t *
    39. buffer_new(uint32_t sz) {
    40.     (void)sz;
    41.     buffer_t * buf = (buffer_t *) malloc(sizeof(buffer_t));
    42.     if (!buf) {
    43.         return NULL;
    44.     }
    45.     memset(buf, 0, sizeof(*buf));
    46.     buf->last_with_datap = &buf->first;
    47.     return buf;
    48. }
    49.  
    50. static buf_chain_t *
    51. buf_chain_new(uint32_t size) {
    52.     buf_chain_t *chain;
    53.     uint32_t to_alloc;
    54.     if (size > BUFFER_CHAIN_MAX - BUFFER_CHAIN_SIZE)
    55.         return (NULL);
    56.     size += BUFFER_CHAIN_SIZE;
    57.     
    58.     if (size < BUFFER_CHAIN_MAX / 2) {
    59.         to_alloc = MIN_BUFFER_SIZE;
    60.         while (to_alloc < size) {
    61.             to_alloc <<= 1;
    62.         }
    63.     } else {
    64.         to_alloc = size;
    65.     }
    66.     if ((chain = malloc(to_alloc)) == NULL)
    67.         return (NULL);
    68.     memset(chain, 0, BUFFER_CHAIN_SIZE);
    69.     chain->buffer_len = to_alloc - BUFFER_CHAIN_SIZE;
    70.     chain->buffer = BUFFER_CHAIN_EXTRA(uint8_t, chain);
    71.     return (chain);
    72. }
    73.  
    74. static void 
    75. buf_chain_free_all(buf_chain_t *chain) {
    76.     buf_chain_t *next;
    77.     for (; chain; chain = next) {
    78.         next = chain->next;
    79.         free(chain);
    80.     }
    81. }
    82.  
    83. void
    84. buffer_free(buffer_t *buf) {
    85.     buf_chain_free_all(buf->first);
    86. }
    87.  
    88.  
    89. static buf_chain_t **
    90. free_empty_chains(buffer_t *buf) {
    91.     buf_chain_t **ch = buf->last_with_datap;
    92.     while ((*ch) && (*ch)->off != 0)
    93.         ch = &(*ch)->next;
    94.     if (*ch) {
    95.         buf_chain_free_all(*ch);
    96.         *ch = NULL;
    97.     }
    98.     return ch;
    99. }
    100.  
    101. static void
    102. buf_chain_insert(buffer_t *buf, buf_chain_t *chain) {
    103.     if (*buf->last_with_datap == NULL) {
    104.         buf->first = buf->last = chain;
    105.     } else {
    106.         buf_chain_t **chp;
    107.         chp = free_empty_chains(buf);
    108.         *chp = chain;
    109.         if (chain->off)
    110.             buf->last_with_datap = chp;
    111.         buf->last = chain;
    112.     }
    113.     buf->total_len += chain->off;
    114. }
    115.  
    116. static inline buf_chain_t *
    117. buf_chain_insert_new(buffer_t *buf, uint32_t datlen) {
    118.     buf_chain_t *chain;
    119.     if ((chain = buf_chain_new(datlen)) == NULL)
    120.         return NULL;
    121.     buf_chain_insert(buf, chain);
    122.     return chain;
    123. }
    124.  
    125. static int
    126. buf_chain_should_realign(buf_chain_t *chain, uint32_t datlen)
    127. {
    128.     return chain->buffer_len - chain->off >= datlen &&
    129.         (chain->off < chain->buffer_len / 2) &&
    130.         (chain->off <= MAX_TO_REALIGN_IN_EXPAND);
    131. }
    132.  
    133. static void
    134. buf_chain_align(buf_chain_t *chain) {
    135.     memmove(chain->buffer, chain->buffer + chain->misalign, chain->off);
    136.     chain->misalign = 0;
    137. }
    138.  
    139. int buffer_add(buffer_t *buf, const void *data_in, uint32_t datlen) {
    140.     buf_chain_t *chain, *tmp;
    141.     const uint8_t *data = data_in;
    142.     uint32_t remain, to_alloc;
    143.     int result = -1;
    144.     if (datlen > BUFFER_CHAIN_MAX - buf->total_len) {
    145.         goto done;
    146.     }
    147.  
    148.     if (*buf->last_with_datap == NULL) {
    149.         chain = buf->last;
    150.     } else {
    151.         chain = *buf->last_with_datap;
    152.     }
    153.  
    154.     if (chain == NULL) {
    155.         chain = buf_chain_insert_new(buf, datlen);
    156.         if (!chain)
    157.             goto done;
    158.     }
    159.  
    160.     remain = chain->buffer_len - chain->misalign - chain->off;
    161.     if (remain >= datlen) {
    162.         memcpy(chain->buffer + chain->misalign + chain->off, data, datlen);
    163.         chain->off += datlen;
    164.         buf->total_len += datlen;
    165.         // buf->n_add_for_cb += datlen;
    166.         goto out;
    167.     } else if (buf_chain_should_realign(chain, datlen)) {
    168.         buf_chain_align(chain);
    169.  
    170.         memcpy(chain->buffer + chain->off, data, datlen);
    171.         chain->off += datlen;
    172.         buf->total_len += datlen;
    173.         // buf->n_add_for_cb += datlen;
    174.         goto out;
    175.     }
    176.     to_alloc = chain->buffer_len;
    177.     if (to_alloc <= BUFFER_CHAIN_MAX_AUTO_SIZE/2)
    178.         to_alloc <<= 1;
    179.     if (datlen > to_alloc)
    180.         to_alloc = datlen;
    181.     tmp = buf_chain_new(to_alloc);
    182.     if (tmp == NULL)
    183.         goto done;
    184.     if (remain) {
    185.         memcpy(chain->buffer + chain->misalign + chain->off, data, remain);
    186.         chain->off += remain;
    187.         buf->total_len += remain;
    188.         // buf->n_add_for_cb += remain;
    189.     }
    190.  
    191.     data += remain;
    192.     datlen -= remain;
    193.  
    194.     memcpy(tmp->buffer, data, datlen);
    195.     tmp->off = datlen;
    196.     buf_chain_insert(buf, tmp);
    197.     // buf->n_add_for_cb += datlen;
    198. out:
    199.     result = 0;
    200. done:
    201.     return result;
    202. }
    203.  
    204. static uint32_t
    205. buf_copyout(buffer_t *buf, void *data_out, uint32_t datlen) {
    206.     buf_chain_t *chain;
    207.     char *data = data_out;
    208.     uint32_t nread;
    209.     chain = buf->first;
    210.     if (datlen > buf->total_len)
    211.         datlen = buf->total_len;
    212.     if (datlen == 0)
    213.         return 0;
    214.     nread = datlen;
    215.  
    216.     while (datlen && datlen >= chain->off) {
    217.         uint32_t copylen = chain->off;
    218.         memcpy(data,
    219.             chain->buffer + chain->misalign,
    220.             copylen);
    221.         data += copylen;
    222.         datlen -= copylen;
    223.  
    224.         chain = chain->next;
    225.     }
    226.     if (datlen) {
    227.         memcpy(data, chain->buffer + chain->misalign, datlen);
    228.     }
    229.  
    230.     return nread;
    231. }
    232.  
    233. static inline void
    234. ZERO_CHAIN(buffer_t *dst) {
    235.     dst->first = NULL;
    236.     dst->last = NULL;
    237.     dst->last_with_datap = &(dst)->first;
    238.     dst->total_len = 0;
    239. }
    240.  
    241. int buffer_drain(buffer_t *buf, uint32_t len) {
    242.     buf_chain_t *chain, *next;
    243.     uint32_t remaining, old_len;
    244.     old_len = buf->total_len;
    245.     if (old_len == 0)
    246.         return 0;
    247.  
    248.     if (len >= old_len) {
    249.         len = old_len;
    250.         for (chain = buf->first; chain != NULL; chain = next) {
    251.             next = chain->next;
    252.             free(chain);
    253.         }
    254.         ZERO_CHAIN(buf);
    255.     } else {
    256.         buf->total_len -= len;
    257.         remaining = len;
    258.         for (chain = buf->first; remaining >= chain->off; chain = next) {
    259.             next = chain->next;
    260.             remaining -= chain->off;
    261.  
    262.             if (chain == *buf->last_with_datap) {
    263.                 buf->last_with_datap = &buf->first;
    264.             }
    265.             if (&chain->next == buf->last_with_datap)
    266.                 buf->last_with_datap = &buf->first;
    267.  
    268.             free(chain);
    269.         }
    270.  
    271.         buf->first = chain;
    272.         chain->misalign += remaining;
    273.         chain->off -= remaining;
    274.     }
    275.     
    276.     // buf->n_del_for_cb += len;
    277.     return len;
    278. }
    279.  
    280. int buffer_remove(buffer_t *buf, void *data_out, uint32_t datlen) {
    281.     uint32_t n = buf_copyout(buf, data_out, datlen);
    282.     if (n > 0) {
    283.         if (buffer_drain(buf, n) < 0)
    284.             n = -1;
    285.     }
    286.     return (int)n;
    287. }
    288.  
    289. static bool
    290. check_sep(buf_chain_t * chain, int from, const char *sep, int seplen) {
    291.     for (;;) {
    292.         int sz = chain->off - from;
    293.         if (sz >= seplen) {
    294.             return memcmp(chain->buffer + chain->misalign + from, sep, seplen) == 0;
    295.         }
    296.         if (sz > 0) {
    297.             if (memcmp(chain->buffer + chain->misalign + from, sep, sz)) {
    298.                 return false;
    299.             }
    300.         }
    301.         chain = chain->next;
    302.         sep += sz;
    303.         seplen -= sz;
    304.         from = 0;
    305.     }
    306. }
    307.  
    308. int buffer_search(buffer_t *buf, const char* sep, const int seplen) {
    309.     buf_chain_t *chain;
    310.     int i;
    311.     chain = buf->first;
    312.     if (chain == NULL)
    313.         return 0;
    314.     int bytes = chain->off;
    315.     while (bytes <= buf->last_read_pos) {
    316.         chain = chain->next;
    317.         if (chain == NULL)
    318.             return 0;
    319.         bytes += chain->off;
    320.     }
    321.     bytes -= buf->last_read_pos;
    322.     int from = chain->off - bytes;
    323.     for (i = buf->last_read_pos; i <= buf->total_len - seplen; i++) {
    324.         if (check_sep(chain, from, sep, seplen)) {
    325.             buf->last_read_pos = 0;
    326.             return i+seplen;
    327.         }
    328.         ++from;
    329.         --bytes;
    330.         if (bytes == 0) {
    331.             chain = chain->next;
    332.             from = 0;
    333.             if (chain == NULL)
    334.                 break;
    335.             bytes = chain->off;
    336.         }
    337.     }
    338.     buf->last_read_pos = i;
    339.     return 0;
    340. }
    341.  
    342. uint8_t * buffer_write_atmost(buffer_t *p) {
    343.     buf_chain_t *chain, *next, *tmp, *last_with_data;
    344.     uint8_t *buffer;
    345.     uint32_t remaining;
    346.     int removed_last_with_data = 0;
    347.     int removed_last_with_datap = 0;
    348.  
    349.     chain = p->first;
    350.     uint32_t size = p->total_len;
    351.  
    352.     if (chain->off >= size) {
    353.         return chain->buffer + chain->misalign;
    354.     }
    355.  
    356.     remaining = size - chain->off;
    357.     for (tmp=chain->next; tmp; tmp=tmp->next) {
    358.         if (tmp->off >= (size_t)remaining)
    359.             break;
    360.         remaining -= tmp->off;
    361.     }
    362.     if (chain->buffer_len - chain->misalign >= (size_t)size) {
    363.         /* already have enough space in the first chain */
    364.         size_t old_off = chain->off;
    365.         buffer = chain->buffer + chain->misalign + chain->off;
    366.         tmp = chain;
    367.         tmp->off = size;
    368.         size -= old_off;
    369.         chain = chain->next;
    370.     } else {
    371.         if ((tmp = buf_chain_new(size)) == NULL) {
    372.             return NULL;
    373.         }
    374.         buffer = tmp->buffer;
    375.         tmp->off = size;
    376.         p->first = tmp;
    377.     }
    378.  
    379.     last_with_data = *p->last_with_datap;
    380.     for (; chain != NULL && (size_t)size >= chain->off; chain = next) {
    381.         next = chain->next;
    382.  
    383.         if (chain->buffer) {
    384.             memcpy(buffer, chain->buffer + chain->misalign, chain->off);
    385.             size -= chain->off;
    386.             buffer += chain->off;
    387.         }
    388.         if (chain == last_with_data)
    389.             removed_last_with_data = 1;
    390.         if (&chain->next == p->last_with_datap)
    391.             removed_last_with_datap = 1;
    392.  
    393.         free(chain);
    394.     }
    395.  
    396.     if (chain != NULL) {
    397.         memcpy(buffer, chain->buffer + chain->misalign, size);
    398.         chain->misalign += size;
    399.         chain->off -= size;
    400.     } else {
    401.         p->last = tmp;
    402.     }
    403.  
    404.     tmp->next = chain;
    405.  
    406.     if (removed_last_with_data) {
    407.         p->last_with_datap = &p->first;
    408.     } else if (removed_last_with_datap) {
    409.         if (p->first->next && p->first->next->off)
    410.             p->last_with_datap = &p->first->next;
    411.         else
    412.             p->last_with_datap = &p->first;
    413.     }
    414.     return tmp->buffer + tmp->misalign;
    415. }
    416.
  • 相关阅读:
    Linux - 进程
    APP破解去广告
    多环境镜像晋级/复用最佳实践
    springBoot2笔记
    linux驱动34：tasklet小任务机制
    【图与网络数学模型】3.Ford-Fulkerson算法求解网络最大流问题
    【双指针】有效三角形的个数
    群狼调研（长沙学校满意度调查）开展长沙游客满意度调查
    Golang 中的静态类型和动态类型
    jar包加入本地maven仓库
  • 原文地址：https://blog.csdn.net/weixin_46120107/article/details/134236107