Browse Source

add and use bs_capacityassert

master
Felix von Leitner 1 year ago
parent
commit
c8b8fbe93b
  1. 13
      buffer/bs_capacityassert.c
  2. 42
      buffer/bs_init_bstream_size.c
  3. 8
      buffer/prs_asciiz.c
  4. 8
      buffer/prs_asciiz_fixedlen.c
  5. 6
      parse.h

13
buffer/bs_capacityassert.c

@ -0,0 +1,13 @@
#include "parse.h"
// This function asserts that the caller wants to read n bytes from the stream.
// If there is less space available, set the stream to error state.
int bs_capacityassert(struct bytestream* bs,size_t capacity) {
if (bs->cur>=bs->max || // if EOF or error, return 0
bs->max - bs->cur < capacity) { // not EOF but less than that many bytes left
bs->cur = 1; // set stream to error state
bs->max = 0;
return 0; // return failure
}
return 1;
}

42
buffer/bs_init_bstream_size.c

@ -3,7 +3,7 @@
void bs_init_bstream_size(struct bytestream* bs,struct bytestream* other,size_t maxlen) {
bs->type = BSTREAM;
// check if we have enough capacity in the parent bytestream
if (bs_capacitycheck(other, maxlen)) {
if (bs_capacityassert(other, maxlen)) {
bs->cur = 0;
bs->max = maxlen;
} else {
@ -13,3 +13,43 @@ void bs_init_bstream_size(struct bytestream* bs,struct bytestream* other,size_t
}
bs->u.bs=other;
}
#ifdef UNITTEST
#include <assert.h>
#undef UNITTEST
#include "buffer/bs_get.c"
#include "buffer/bs_capacityassert.c"
#include "buffer/bs_init_membuf.c"
// we use membuf here, mock buffer stuff away
ssize_t buffer_getc(buffer* b,char* x) { return 0; }
int main() {
struct bytestream bs = BS_FROM_MEMBUF("\x12\x34\x56\x78",4);
struct bytestream sub;
assert(bs_get(&bs) == 0x12); // eat one byte
bs_init_bstream_size(&sub, &bs, 2); // 2 byte substream
assert(bs_get(&sub) == 0x34); // make sure we got the offset right
assert(bs_get(&sub) == 0x56); // read second (and last) byte
assert(bs_err(&sub) == 0); // should have no errors yet
assert(bs_err(&bs) == 0);
assert(bs_get(&sub) == 0); // next byte should error out
assert(bs_err(&sub)); // substream should have error state
assert(bs_err(&bs) == 0); // parent stream not
assert(bs_get(&bs) == 0x78); // and we should not have overstepped
// now check the range checking in bs_init_bstream_size itself
bs_init_membuf(&bs, "\x12\x34\x56\x78", 4);
bs_init_bstream_size(&sub, &bs, 4); // tight fit
assert(bs_err(&sub) == 0);
assert(bs_err(&bs) == 0);
bs_init_bstream_size(&sub, &bs, 5);
assert(bs_err(&sub));
assert(bs_err(&bs));
}
#endif

8
buffer/prs_asciiz.c

@ -45,11 +45,11 @@ ssize_t prs_asciiz(struct bytestream* bs, char* dest, size_t len) {
#undef UNITTEST
#include "buffer/bs_init_membuf.c"
#include "buffer/bs_get.c"
#include "buffer/buffer_peekc.c"
#include "buffer/buffer_getc.c"
#include "buffer/bs_peek.c"
#include "buffer/buffer_feed.c"
#include "buffer/buffer_stubborn2.c"
// we use membuf here, mock buffer stuff away
ssize_t buffer_getc(buffer* b,char* x) { return 0; }
ssize_t buffer_peekc(buffer* b,char* x) { return 0; }
int main() {
struct bytestream bs = BS_FROM_MEMBUF("fnord\n\0x",8);

8
buffer/prs_asciiz_fixedlen.c

@ -36,11 +36,11 @@ ssize_t prs_asciiz_fixedlen(struct bytestream* bs, char* dest, size_t len) {
#undef UNITTEST
#include "buffer/bs_init_membuf.c"
#include "buffer/bs_get.c"
#include "buffer/buffer_peekc.c"
#include "buffer/buffer_getc.c"
#include "buffer/bs_peek.c"
#include "buffer/buffer_feed.c"
#include "buffer/buffer_stubborn2.c"
// we use membuf here, mock buffer stuff away
ssize_t buffer_getc(buffer* b,char* x) { return 0; }
ssize_t buffer_peekc(buffer* b,char* x) { return 0; }
int main() {
struct bytestream bs = BS_FROM_MEMBUF("fnord\n\0x",8);

6
parse.h

@ -85,6 +85,12 @@ int bs_err(struct bytestream* bs);
/* Can we read this much more bytes from the bytestream? */
int bs_capacitycheck(struct bytestream* bs,size_t capacity);
/* Like bs_capacitycheck but will set stream to error state on fail */
int bs_capacityassert(struct bytestream* bs,size_t capacity);
/* Read n bytes from stream. Return n.
* Set stream to error state if not enough space or I/O error. */
size_t prs_readblob(struct bytestream* bs,unsigned char* dest,size_t destlen);
uint16_t prs_u16(struct bytestream* bs);
uint16_t prs_u16_big(struct bytestream* bs);

Loading…
Cancel
Save