1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/*
* Packet interface
* Copyright (C) 1999 Kunihiro Ishiguro
*
* This file is part of GNU Zebra.
*
* GNU Zebra is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2, or (at your option) any
* later version.
*
* GNU Zebra is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Zebra; see the file COPYING. If not, write to the Free
* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#ifndef _ZEBRA_STREAM_H
#define _ZEBRA_STREAM_H
#include "prefix.h"
/*
* A stream is an arbitrary buffer, whose contents generally are assumed to
* be in network order.
*
* A stream has the following attributes associated with it:
*
* - size: the allocated, invariant size of the buffer.
*
* - getp: the get position marker, denoting the offset in the stream where
* the next read (or 'get') will be from. This getp marker is
* automatically adjusted when data is read from the stream, the
* user may also manipulate this offset as they wish, within limits
* (see below)
*
* - endp: the end position marker, denoting the offset in the stream where
* valid data ends, and if the user attempted to write (or
* 'put') data where that data would be written (or 'put') to.
*
* These attributes are all size_t values.
*
* Constraints:
*
* 1. getp can never exceed endp
*
* - hence if getp is equal to endp, there is no more valid data that can be
* gotten from the stream (though, the user may reposition getp to earlier in
* the stream, if they wish).
*
* 2. endp can never exceed size
*
* - hence, if endp is equal to size, then the stream is full, and no more
* data can be written to the stream.
*
* In other words the following must always be true, and the stream
* abstraction is allowed internally to assert that the following property
* holds true for a stream, as and when it wishes:
*
* getp <= endp <= size
*
* It is the users responsibility to ensure this property is never violated.
*
* A stream therefore can be thought of like this:
*
* ---------------------------------------------------
* |XXXXXXXXXXXXXXXXXXXXXXXX |
* ---------------------------------------------------
* ^ ^ ^
* getp endp size
*
* This shows a stream containing data (shown as 'X') up to the endp offset.
* The stream is empty from endp to size. Without adjusting getp, there are
* still endp-getp bytes of valid data to be read from the stream.
*
* Methods are provided to get and put to/from the stream, as well as
* retrieve the values of the 3 markers and manipulate the getp marker.
*
* Note:
* At the moment, newly allocated streams are zero filled. Hence, one can
* use stream_forward_endp() to effectively create arbitrary zero-fill
* padding. However, note that stream_reset() does *not* zero-out the
* stream. This property should **not** be relied upon.
*
* Best practice is to use stream_put (<stream *>, NULL, <size>) to zero out
* any part of a stream which isn't otherwise written to.
*/
/* Stream buffer. */
struct stream
{
struct stream *next;
/* Remainder is ***private*** to stream
* direct access is frowned upon!
* Use the appropriate functions/macros
*/
size_t getp; /* next get position */
size_t endp; /* last valid data position */
size_t size; /* size of data segment */
unsigned char *data; /* data pointer */
};
/* First in first out queue structure. */
struct stream_fifo
{
size_t count;
struct stream *head;
struct stream *tail;
};
/* Utility macros. */
#define STREAM_SIZE(S) ((S)->size)
/* number of bytes which can still be written */
#define STREAM_WRITEABLE(S) ((S)->size - (S)->endp)
/* number of bytes still to be read */
#define STREAM_READABLE(S) ((S)->endp - (S)->getp)
/* deprecated macros - do not use in new code */
#define STREAM_PNT(S) stream_pnt((S))
#define STREAM_DATA(S) ((S)->data)
#define STREAM_REMAIN(S) STREAM_WRITEABLE((S))
/* Stream prototypes.
* For stream_{put,get}S, the S suffix mean:
*
* c: character (unsigned byte)
* w: word (two bytes)
* l: long (two words)
* q: quad (four words)
*/
extern struct stream *stream_new (size_t);
extern void stream_free (struct stream *);
extern struct stream * stream_copy (struct stream *new, struct stream *src);
extern struct stream *stream_dup (struct stream *);
extern size_t stream_resize (struct stream *, size_t);
extern size_t stream_get_getp (struct stream *);
extern size_t stream_get_endp (struct stream *);
extern size_t stream_get_size (struct stream *);
extern u_char *stream_get_data (struct stream *);
extern void stream_set_getp (struct stream *, size_t);
extern void stream_forward_getp (struct stream *, size_t);
extern void stream_forward_endp (struct stream *, size_t);
/* steam_put: NULL source zeroes out size_t bytes of stream */
extern void stream_put (struct stream *, void *, size_t);
extern int stream_putc (struct stream *, u_char);
extern int stream_putc_at (struct stream *, size_t, u_char);
extern int stream_putw (struct stream *, u_int16_t);
extern int stream_putw_at (struct stream *, size_t, u_int16_t);
extern int stream_putl (struct stream *, u_int32_t);
extern int stream_putl_at (struct stream *, size_t, u_int32_t);
extern int stream_putq (struct stream *, uint64_t);
extern int stream_putq_at (struct stream *, size_t, uint64_t);
extern int stream_put_ipv4 (struct stream *, u_int32_t);
extern int stream_put_in_addr (struct stream *, struct in_addr *);
extern int stream_put_prefix (struct stream *, struct prefix *);
extern void stream_get (void *, struct stream *, size_t);
extern u_char stream_getc (struct stream *);
extern u_char stream_getc_from (struct stream *, size_t);
extern u_int16_t stream_getw (struct stream *);
extern u_int16_t stream_getw_from (struct stream *, size_t);
extern u_int32_t stream_getl (struct stream *);
extern u_int32_t stream_getl_from (struct stream *, size_t);
extern uint64_t stream_getq (struct stream *);
extern uint64_t stream_getq_from (struct stream *, size_t);
extern u_int32_t stream_get_ipv4 (struct stream *);
#undef stream_read
#undef stream_write
/* Deprecated: assumes blocking I/O. Will be removed.
Use stream_read_try instead. */
extern int stream_read (struct stream *, int, size_t);
/* Deprecated: all file descriptors should already be non-blocking.
Will be removed. Use stream_read_try instead. */
extern int stream_read_unblock (struct stream *, int, size_t);
/* Read up to size bytes into the stream.
Return code:
>0: number of bytes read
0: end-of-file
-1: fatal error
-2: transient error, should retry later (i.e. EAGAIN or EINTR)
This is suitable for use with non-blocking file descriptors.
*/
extern ssize_t stream_read_try(struct stream *s, int fd, size_t size);
extern ssize_t stream_recvmsg (struct stream *s, int fd, struct msghdr *,
int flags, size_t size);
extern ssize_t stream_recvfrom (struct stream *s, int fd, size_t len,
int flags, struct sockaddr *from,
socklen_t *fromlen);
extern size_t stream_write (struct stream *, u_char *, size_t);
/* reset the stream. See Note above */
extern void stream_reset (struct stream *);
extern int stream_flush (struct stream *, int);
extern int stream_empty (struct stream *); /* is the stream empty? */
/* deprecated */
extern u_char *stream_pnt (struct stream *);
/* Stream fifo. */
extern struct stream_fifo *stream_fifo_new (void);
extern void stream_fifo_push (struct stream_fifo *fifo, struct stream *s);
extern struct stream *stream_fifo_pop (struct stream_fifo *fifo);
extern struct stream *stream_fifo_head (struct stream_fifo *fifo);
extern void stream_fifo_clean (struct stream_fifo *fifo);
extern void stream_fifo_free (struct stream_fifo *fifo);
#endif /* _ZEBRA_STREAM_H */
|
