X-Git-Url: https://git.distorted.org.uk/u/mdw/catacomb/blobdiff_plain/01a66582b578383a6f65665c71ff43bdd15c3978..6b80b6c48a47fd4f9f8329e2e56a228fa3e2c7f4:/buf.c?ds=sidebyside diff --git a/buf.c b/buf.c new file mode 100644 index 0000000..e03be65 --- /dev/null +++ b/buf.c @@ -0,0 +1,314 @@ +/* -*-c-*- + * + * $Id: buf.c,v 1.1 2003/10/11 21:02:33 mdw Exp $ + * + * Buffer handling + * + * (c) 2001 Straylight/Edgeware + */ + +/*----- Licensing notice --------------------------------------------------* + * + * This file is part of Catacomb. + * + * Catacomb is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * Catacomb 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 Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with Catacomb; if not, write to the Free + * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, + * MA 02111-1307, USA. + */ + +/*----- Revision history --------------------------------------------------* + * + * $Log: buf.c,v $ + * Revision 1.1 2003/10/11 21:02:33 mdw + * Import buf stuff from tripe. + * + * Revision 1.4 2001/06/19 22:09:54 mdw + * Expose interface, for use in the proxy. + * + * Revision 1.3 2001/03/03 12:06:48 mdw + * Use 16-bit lengths on MPs, since there's a packet limit of 64K anyway. + * + * Revision 1.2 2001/02/16 21:23:20 mdw + * Various minor changes. Check that MPs are in canonical form when + * loading. + * + * Revision 1.1 2001/02/03 20:26:37 mdw + * Initial checkin. + * + */ + +/*----- Header files ------------------------------------------------------*/ + +#include + +#include + +#include "buf.h" + +/*----- Main code ---------------------------------------------------------*/ + +/* --- @buf_init@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * @void *p@ = pointer to a buffer + * @size_t sz@ = size of the buffer + * + * Returns: --- + * + * Use: Initializes the buffer block appropriately. + */ + +void buf_init(buf *b, void *p, size_t sz) +{ + b->base = b->p = p; + b->limit = b->p + sz; + b->f = 0; +} + +/* --- @buf_break@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * + * Returns: Some negative value. + * + * Use: Marks a buffer as broken. + */ + +int buf_break(buf *b) { b->f |= BF_BROKEN; return (-1); } + +/* --- @buf_flip@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * + * Returns: --- + * + * Use: Flips a buffer so that if you've just been writing to it, + * you can now read from the bit you've written. + */ + +void buf_flip(buf *b) +{ + b->limit = b->p; + b->p = b->base; +} + +/* --- @buf_ensure@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * @size_t sz@ = size of data wanted + * + * Returns: Zero if it worked, nonzero if there wasn't enough space. + * + * Use: Ensures that there are @sz@ bytes still in the buffer. + */ + +int buf_ensure(buf *b, size_t sz) { return (BENSURE(b, sz)); } + +/* --- @buf_get@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * @size_t sz@ = size of the buffer + * + * Returns: Pointer to the place in the buffer. + * + * Use: Reserves a space in the buffer of the requested size, and + * returns its start address. + */ + +void *buf_get(buf *b, size_t sz) +{ + void *p; + if (BENSURE(b, sz)) + return (0); + p = BCUR(b); + BSTEP(b, sz); + return (p); +} + +/* --- @buf_put@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * @const void *p@ = pointer to a buffer + * @size_t sz@ = size of the buffer + * + * Returns: Zero if it worked, nonzero if there wasn't enough space. + * + * Use: Fetches data from some place and puts it in the buffer + */ + +int buf_put(buf *b, const void *p, size_t sz) +{ + if (BENSURE(b, sz)) + return (-1); + memcpy(BCUR(b), p, sz); + BSTEP(b, sz); + return (0); +} + +/* --- @buf_getbyte@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * + * Returns: A byte, or less than zero if there wasn't a byte there. + * + * Use: Gets a single byte from a buffer. + */ + +int buf_getbyte(buf *b) +{ + if (BENSURE(b, 1)) + return (-1); + return (*b->p++); +} + +/* --- @buf_putbyte@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * @int ch@ = byte to write + * + * Returns: Zero if OK, nonzero if there wasn't enough space. + * + * Use: Puts a single byte in a buffer. + */ + +int buf_putbyte(buf *b, int ch) +{ + if (BENSURE(b, 1)) + return (-1); + *b->p++ = ch; + return (0); +} + +/* --- @buf_getu16@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * @uint16 *w@ = where to put the word + * + * Returns: Zero if OK, or nonzero if there wasn't a word there. + * + * Use: Gets a 16-bit word from a buffer. + */ + +int buf_getu16(buf *b, uint16 *w) +{ + if (BENSURE(b, 2)) + return (-1); + *w = LOAD16(b->p); + BSTEP(b, 2); + return (0); +} + +/* --- @buf_putu16@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * @uint16 w@ = word to write + * + * Returns: Zero if OK, nonzero if there wasn't enough space. + * + * Use: Puts a 16-but word in a buffer. + */ + +int buf_putu16(buf *b, uint16 w) +{ + if (BENSURE(b, 2)) + return (-1); + STORE16(b->p, w); + BSTEP(b, 2); + return (0); +} + +/* --- @buf_getu32@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * @uint32 *w@ = where to put the word + * + * Returns: Zero if OK, or nonzero if there wasn't a word there. + * + * Use: Gets a 32-bit word from a buffer. + */ + +int buf_getu32(buf *b, uint32 *w) +{ + if (BENSURE(b, 4)) + return (-1); + *w = LOAD32(b->p); + BSTEP(b, 4); + return (0); +} + +/* --- @buf_putu32@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * @uint32 w@ = word to write + * + * Returns: Zero if OK, nonzero if there wasn't enough space. + * + * Use: Puts a 32-but word in a buffer. + */ + +int buf_putu32(buf *b, uint32 w) +{ + if (BENSURE(b, 4)) + return (-1); + STORE32(b->p, w); + BSTEP(b, 4); + return (0); +} + +/* --- @buf_getmp@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * + * Returns: A multiprecision integer, or null if there wasn't one there. + * + * Use: Gets a multiprecision integer from a buffer. + */ + +mp *buf_getmp(buf *b) +{ + uint16 sz; + mp *m; + if (buf_getu16(b, &sz) || buf_ensure(b, sz)) + return (0); + m = mp_loadb(MP_NEW, BCUR(b), sz); + if (mp_octets(m) != sz) { + mp_drop(m); + return (0); + } + BSTEP(b, sz); + return (m); +} + +/* --- @buf_putmp@ --- * + * + * Arguments: @buf *b@ = pointer to a buffer block + * @mp *m@ = a multiprecision integer + * + * Returns: Zero if it worked, nonzero if there wasn't enough space. + * + * Use: Puts a multiprecision integer to a buffer. + */ + +int buf_putmp(buf *b, mp *m) +{ + size_t sz = mp_octets(m); + assert(sz < MASK16); + if (buf_putu16(b, sz) || buf_ensure(b, sz)) + return (-1); + mp_storeb(m, BCUR(b), sz); + BSTEP(b, sz); + return (0); +} + +/*----- That's all, folks -------------------------------------------------*/