17 \h'-\w'\\$1\ 'u'\\$1\ \c
22 .TH buf 3 "23 September 2005" "Straylight/Edgeware" "mLib utilities library"
24 buf \- reading and writing stuff in buffers
153 .B "#include <mLib/dstr.h>"
155 .BI "void buf_init(buf *" b ", void *" p ", size_t " sz );
156 .BI "void buf_flip(buf *" b );
157 .BI "octet *BBASE(buf *" b );
158 .BI "octet *BLIM(buf *" b );
159 .BI "octet *BCUR(buf *" b );
160 .BI "ptrdiff_t BSZ(buf *" b );
161 .BI "ptrdiff_t BLEN(buf *" b );
162 .BI "ptrdiff_t BLEFT(buf *" b );
164 .BI "int buf_break(buf *" b );
165 .BI "int BBAD(buf *" b );
166 .BI "int BOK(buf *" b );
168 .BI "int buf_ensure(buf *" b ", size_t " sz );
169 .BI "int BENSURE(buf *" b ", size_t " sz );
170 .BI "octet *BSTEP(buf *" b );
172 .BI "void *buf_get(buf *" b ", size_t " sz );
173 .BI "void *buf_put(buf *" b ", const void *" p ", size_t " sz );
175 .BI "int buf_getbyte(buf *" b );
176 .BI "int buf_putbyte(buf *" b ", int ch" );
177 .BI "int buf_getu" suff "(buf *" b ", uint" suff " *" w );
178 .BI "int buf_putu" suff "(buf *" b ", uint" suff " " w );
179 .BI "void *buf_getmem" suff "(buf *" b ", size_t *" sz );
180 .BI "int buf_putmem" suff "(buf *" b ", const void *" p ", size_t " sz );
181 .BI "int buf_getbuf" suff "(buf *" b ", buf *" bb );
182 .BI "int buf_putbuf" suff "(buf *" b ", buf *" bb );
183 .BI "int buf_getdstr" suff "(buf *" b ", dstr *" d );
184 .BI "int buf_putdstr" suff "(buf *" b ", dstr *" d );
185 .BI "int buf_putstr" suff "(buf *" b ", const char *" p );
190 interface allows relatively convenient reading and writing of structured
191 binary data from and to fixed-size memory buffers. It's useful for
192 formatting and parsing down network data packets, for example.
194 A buffer has three important pointers associated with it:
197 The base address of the buffer.
200 Just past the last usable byte in the buffer
203 The position in the buffer at which the next read or write will occur.
205 A buffer is created using the
207 function. You must pass it the buffer base address and size, and a
210 structure to fill in. It doesn't allocate any memory, so you don't need
213 structure in any way before forgetting about it.
215 A collection of macros is provided for finding the positions of the
216 various interesting pointers known about a buffer, and the sizes of the
217 regions of memory they imply.
235 The size of the buffer; i.e.,
241 The length of data in the buffer (if writing) or the amount of data
242 read (if reading); i.e.,
248 The amount of space left in the buffer (if writing) or the amount of
249 data yet to read (if reading); i.e.,
256 takes a buffer which has been used for writing, and makes it suitable
257 for reading. This turns out to be useful when building packets in
258 multi-layered networking software. Its precise behaviour is to preserve
271 to indicate that it has overflowed or that its contents are otherwise
272 invalid. The various buffer access functions described below all fail
273 on a broken buffer, and any errors they encounter cause the buffer to
274 become broken. Most simple programs which only use the supplied buffer
275 access functions can avoid the tedium of error-checking every function
276 call and just check the brokenness state at the end of their run.
280 will break a buffer. The macro
282 reports true (nonzero) if its buffer argument is broken, or false (zero)
283 otherwise; its counterpart
285 reports true if the buffer is OK, and false if it is broken.
286 .SS "Low-level buffer access"
287 Access to the data in the buffer is usually sequential. The
289 macro (or the equivalent
291 function) checks that the buffer is OK and that there is enough space
292 remaining in the buffer for
294 bytes: if so, it returns zero; otherwise it breaks the buffer and
299 macro advances the buffer's
303 bytes. It does no bounds checking. Together with
305 this provides sequential access to the buffer's contents.
309 function is the basis of most buffer access functions, whether for
310 reading or writing. If the buffer is OK, and there are
312 or more bytes remaining, it steps the buffer's
320 pointer; otherwise it breaks the buffer if necessary, and returns a null
327 bytes of data starting at
329 to the buffer. If it succeeded, it returns 0; otherwise it returns \-1.
330 .SS "Formatted buffer access"
333 returns the next byte from a buffer as a nonnegative integer, or \-1 on
336 writes its argument to a buffer, and returns 0 on succes; it returns \-1
339 Many of the remaining functions deal with integer formatting and buffer
340 lengths. The functions support 8-, 16-, 24- and 32-bit integers, in
341 big- or little-endian order; on platforms with 64-bit integers, these
342 are supported too. The functions' names carry a suffix which is the
343 width in bits of the integers they deal with and an optional
347 for big-endian byte order. (The variant with no letter uses big-endian
348 order. Use of these variants tends to mean `I don't really care, but be
349 consistent,' and is not recommended if you have an externally-defined
350 spec you're meant to be compatible with.)
354 reads an integer. On success, it stores the integer it read at the
357 given, and returns zero; on failure, it returns \-1. The function
359 write an integer. It returns zero on success or \-1 on failure.
361 Functions which deal with block lengths assume the length is prefixed to
362 the data, and don't include themselves. They also have an additional
364 variant, which deals with zero-terminated data. No checks are done on
365 writing that the data written contains no zero bytes.
369 fetches a block of data. On success, it returns its base address and
370 stores its length at the given address; on failure, it returns null.
373 writes a block of data; it return zero on success or \-1 on failure.
377 fetches a block of data and makes a second buffer point to it, i.e.,
382 pointers to the start of the block and its
384 pointer to just past the end. No copying of bulk data is performed.
387 writes the contents of a buffer (i.e., between its
391 pointers). The function
393 fetches a block of data and append it to a dynamic string (see
397 writes the contents of a dynamic string to a buffer. Finally, the
400 writes a standard C null-terminated string to a buffer. All these
401 functions return zero on success or \-1 on failure.
406 Mark Wooding, <mdw@distorted.org.uk>
~mdw / mLib / blob