source: src/router/quagga/nhrpd/zbuf.h @ 31640

Last change on this file since 31640 was 31640, checked in by brainslayer, 4 months ago

update quagga

File size: 4.4 KB
Line 
1/* Stream/packet buffer API
2 * Copyright (c) 2014-2015 Timo TerÀs
3 *
4 * This file is free software: you may copy, redistribute and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 2 of the License, or
7 * (at your option) any later version.
8 */
9
10#ifndef ZBUF_H
11#define ZBUF_H
12
13#include <stdint.h>
14#include <string.h>
15#include <endian.h>
16#include <sys/types.h>
17
18#include "zassert.h"
19#include "list.h"
20
21struct zbuf {
22        struct list_head queue_list;
23        unsigned allocated : 1;
24        unsigned error : 1;
25        uint8_t *buf, *end;
26        uint8_t *head, *tail;
27};
28
29struct zbuf_queue {
30        struct list_head queue_head;
31};
32
33struct zbuf *zbuf_alloc(size_t size);
34void zbuf_init(struct zbuf *zb, void *buf, size_t len, size_t datalen);
35void zbuf_free(struct zbuf *zb);
36
37static inline size_t zbuf_size(struct zbuf *zb)
38{
39        return zb->end - zb->buf;
40}
41
42static inline size_t zbuf_used(struct zbuf *zb)
43{
44        return zb->tail - zb->head;
45}
46
47static inline size_t zbuf_tailroom(struct zbuf *zb)
48{
49        return zb->end - zb->tail;
50}
51
52static inline size_t zbuf_headroom(struct zbuf *zb)
53{
54        return zb->head - zb->buf;
55}
56
57void zbuf_reset(struct zbuf *zb);
58void zbuf_reset_head(struct zbuf *zb, void *ptr);
59ssize_t zbuf_read(struct zbuf *zb, int fd, size_t maxlen);
60ssize_t zbuf_write(struct zbuf *zb, int fd);
61ssize_t zbuf_recv(struct zbuf *zb, int fd);
62ssize_t zbuf_send(struct zbuf *zb, int fd);
63
64static inline void zbuf_set_rerror(struct zbuf *zb)
65{
66        zb->error = 1;
67        zb->head = zb->tail;
68}
69
70static inline void zbuf_set_werror(struct zbuf *zb)
71{
72        zb->error = 1;
73        zb->tail = zb->end;
74}
75
76static inline void *__zbuf_pull(struct zbuf *zb, size_t size, int error)
77{
78        void *head = zb->head;
79        if (size > zbuf_used(zb)) {
80                if (error) zbuf_set_rerror(zb);
81                return NULL;
82        }
83        zb->head += size;
84        return head;
85}
86
87#define zbuf_pull(zb, type) ((type *)__zbuf_pull(zb, sizeof(type), 1))
88#define zbuf_pulln(zb, sz) ((void *)__zbuf_pull(zb, sz, 1))
89#define zbuf_may_pull(zb, type) ((type *)__zbuf_pull(zb, sizeof(type), 0))
90#define zbuf_may_pulln(zb, sz) ((void *)__zbuf_pull(zb, sz, 0))
91
92void *zbuf_may_pull_until(struct zbuf *zb, const char *sep, struct zbuf *msg);
93
94static inline void zbuf_get(struct zbuf *zb, void *dst, size_t len)
95{
96        void *src = zbuf_pulln(zb, len);
97        if (src) memcpy(dst, src, len);
98}
99
100static inline uint8_t zbuf_get8(struct zbuf *zb)
101{
102        uint8_t *src = zbuf_pull(zb, uint8_t);
103        if (src) return *src;
104        return 0;
105}
106
107static inline uint32_t zbuf_get32(struct zbuf *zb)
108{
109        struct unaligned32 {
110                uint32_t value;
111        } __attribute__((packed));
112
113        struct unaligned32 *v = zbuf_pull(zb, struct unaligned32);
114        if (v) return v->value;
115        return 0;
116}
117
118static inline uint16_t zbuf_get_be16(struct zbuf *zb)
119{
120        struct unaligned16 {
121                uint16_t value;
122        } __attribute__((packed));
123
124        struct unaligned16 *v = zbuf_pull(zb, struct unaligned16);
125        if (v) return be16toh(v->value);
126        return 0;
127}
128
129static inline uint32_t zbuf_get_be32(struct zbuf *zb)
130{
131        return be32toh(zbuf_get32(zb));
132}
133
134static inline void *__zbuf_push(struct zbuf *zb, size_t size, int error)
135{
136        void *tail = zb->tail;
137        if (size > zbuf_tailroom(zb)) {
138                if (error) zbuf_set_werror(zb);
139                return NULL;
140        }
141        zb->tail += size;
142        return tail;
143}
144
145#define zbuf_push(zb, type) ((type *)__zbuf_push(zb, sizeof(type), 1))
146#define zbuf_pushn(zb, sz) ((void *)__zbuf_push(zb, sz, 1))
147#define zbuf_may_push(zb, type) ((type *)__zbuf_may_push(zb, sizeof(type), 0))
148#define zbuf_may_pushn(zb, sz) ((void *)__zbuf_push(zb, sz, 0))
149
150static inline void zbuf_put(struct zbuf *zb, const void *src, size_t len)
151{
152        void *dst = zbuf_pushn(zb, len);
153        if (dst) memcpy(dst, src, len);
154}
155
156static inline void zbuf_put8(struct zbuf *zb, uint8_t val)
157{
158        uint8_t *dst = zbuf_push(zb, uint8_t);
159        if (dst) *dst = val;
160}
161
162static inline void zbuf_put_be16(struct zbuf *zb, uint16_t val)
163{
164        struct unaligned16 {
165                uint16_t value;
166        } __attribute__((packed));
167
168        struct unaligned16 *v = zbuf_push(zb, struct unaligned16);
169        if (v) v->value = htobe16(val);
170}
171
172static inline void zbuf_put_be32(struct zbuf *zb, uint32_t val)
173{
174        struct unaligned32 {
175                uint32_t value;
176        } __attribute__((packed));
177
178        struct unaligned32 *v = zbuf_push(zb, struct unaligned32);
179        if (v) v->value = htobe32(val);
180}
181
182void zbuf_copy(struct zbuf *zb, struct zbuf *src, size_t len);
183
184void zbufq_init(struct zbuf_queue *);
185void zbufq_reset(struct zbuf_queue *);
186void zbufq_queue(struct zbuf_queue *, struct zbuf *);
187int zbufq_write(struct zbuf_queue *, int);
188
189#endif
Note: See TracBrowser for help on using the repository browser.