buffer: read and write

The buffer_pread and buffer_pwrite functions provide a POSIX pread and pwrite
inspired API to get and set parts of a memory buffer.  The buffer_read and
buffer_write functions wrap the pread/pwrite variants and update the current
buffer offset.

Signed-off-by: Josef 'Jeff' Sipek <[email protected]>

Author: jeffpc

buffer.c

@@ -216,6 +216,57 @@ int buffer_truncate(struct buffer *buffer, size_t size)
 	return 0;
 }
 
+ssize_t buffer_pread(struct buffer *buffer, void *buf, size_t len, size_t off)
+{
+	ssize_t ret;
+
+	if (!buffer || !buf)
+		return -EINVAL;
+
+	if (buffer->ops->check_read) {
+		ret = buffer->ops->check_read(buffer, buf, len, off);
+		if (ret)
+			return ret;
+	}
+
+	if (off >= buffer->used)
+		ret = 0;
+	else if ((off + len) > buffer->used)
+		ret = buffer->used - off;
+	else
+		ret = len;
+
+	if (ret)
+		buffer->ops->copyout(buffer, off, buf, ret);
+
+	return ret;
+}
+
+ssize_t buffer_pwrite(struct buffer *buffer, const void *buf, size_t len,
+		      size_t off)
+{
+	ssize_t ret;
+
+	if (!buffer || !buf)
+		return -EINVAL;
+
+	if (buffer->ops->check_write) {
+		ret = buffer->ops->check_write(buffer, buf, len, off);
+		if (ret)
+			return ret;
+	}
+
+	ret = resize(buffer, off + len);
+	if (ret)
+		return ret;
+
+	buffer->ops->copyin(buffer, off, buf, len);
+
+	buffer->used = MAX(buffer->used, off + len);
+
+	return len;
+}
+
 /*
  * Generic implementations
  */
@@ -252,3 +303,21 @@ void generic_buffer_copyin_panic(struct buffer *buffer, size_t off,
 {
 	panic("buffer copyin called");
 }
+
+/* copyout implementations */
+void generic_buffer_copyout_memcpy(struct buffer *buffer, size_t off,
+				   void *data, size_t datalen)
+{
+	memcpy(data, buffer->data + off, datalen);
+}
+
+void generic_buffer_copyout_nop(struct buffer *buffer, size_t off, void *data,
+				size_t datalen)
+{
+}
+
+void generic_buffer_copyout_panic(struct buffer *buffer, size_t off, void *data,
+				  size_t datalen)
+{
+	panic("buffer copyout called");
+}

buffer_heap.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Josef 'Jeff' Sipek <[email protected]>
+ * Copyright (c) 2017-2018 Josef 'Jeff' Sipek <[email protected]>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -27,4 +27,5 @@ const struct buffer_ops heap_buffer = {
 	.free = free,
 	.clear = generic_buffer_clear_memset,
 	.copyin = generic_buffer_copyin_memcpy,
+	.copyout = generic_buffer_copyout_memcpy,
 };

buffer_impl.h

@@ -47,4 +47,12 @@ extern void generic_buffer_copyin_nop(struct buffer *buffer, size_t off,
 extern void generic_buffer_copyin_panic(struct buffer *buffer, size_t off,
 					const void *newdata, size_t newdatalen);
 
+/* copyout implementations */
+extern void generic_buffer_copyout_memcpy(struct buffer *buffer, size_t off,
+					  void *data, size_t datalen);
+extern void generic_buffer_copyout_nop(struct buffer *buffer, size_t off,
+				       void *data, size_t datalen);
+extern void generic_buffer_copyout_panic(struct buffer *buffer, size_t off,
+					 void *data, size_t datalen);
+
 #endif

buffer_sink.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Josef 'Jeff' Sipek <[email protected]>
+ * Copyright (c) 2017-2018 Josef 'Jeff' Sipek <[email protected]>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,15 @@
 
 #include "buffer_impl.h"
 
+static int sink_buffer_check_read(struct buffer *buffer, void *data, size_t len,
+				  size_t off)
+{
+	return -ENOTSUP;
+}
+
 const struct buffer_ops sink_buffer = {
+	.check_read = sink_buffer_check_read,
+
 	/*
 	 * no need for:
 	 *  - realloc since we use SIZE_MAX alloc size
@@ -31,4 +39,5 @@ const struct buffer_ops sink_buffer = {
 
 	.clear = generic_buffer_clear_nop,
 	.copyin = generic_buffer_copyin_nop,
+	.copyout = generic_buffer_copyout_panic,
 };

buffer_static.c

@@ -69,20 +69,39 @@ static int static_buffer_check_truncate_rw(struct buffer *buffer, size_t size)
 	return -ENOSPC;
 }
 
+static int static_buffer_check_write_ro(struct buffer *buffer, const void *buf,
+				        size_t len, size_t off)
+{
+	return -EROFS;
+}
+
+static int static_buffer_check_write_rw(struct buffer *buffer, const void *buf,
+				        size_t len, size_t off)
+{
+	if ((off + len) <= buffer->allocsize)
+		return 0;
+
+	return -ENOSPC;
+}
+
 /* a read-only static buffer */
 const struct buffer_ops static_buffer_ro = {
 	.check_append = static_buffer_check_append_ro,
 	.check_truncate = static_buffer_check_truncate_ro,
+	.check_write = static_buffer_check_write_ro,
 
 	.clear = generic_buffer_clear_panic,
 	.copyin = generic_buffer_copyin_panic,
+	.copyout = generic_buffer_copyout_memcpy,
 };
 
 /* a read-write static buffer */
 const struct buffer_ops static_buffer_rw = {
 	.check_append = static_buffer_check_append_rw,
 	.check_truncate = static_buffer_check_truncate_rw,
+	.check_write = static_buffer_check_write_rw,
 
 	.clear = generic_buffer_clear_memset,
 	.copyin = generic_buffer_copyin_memcpy,
+	.copyout = generic_buffer_copyout_memcpy,
 };

buffer_stdio.c

@@ -45,6 +45,14 @@ static void stdio_buffer_copyin(struct buffer *buffer, size_t off,
 		      strerror(errno));
 }
 
+static void stdio_buffer_copyout(struct buffer *buffer, size_t off,
+				 void *data, size_t datalen)
+{
+	if (fread(data, datalen, 1, buffer->private) != 1)
+		panic("%s: failed to read data from buffer: %s", __func__,
+		      strerror(errno));
+}
+
 const struct buffer_ops stdio_buffer = {
 	.check_truncate = stdio_buffer_check_truncate,
 	.check_seek = stdio_buffer_check_seek,
@@ -57,4 +65,5 @@ const struct buffer_ops stdio_buffer = {
 
 	.clear = generic_buffer_clear_panic,
 	.copyin = stdio_buffer_copyin,
+	.copyout = stdio_buffer_copyout,
 };

include/jeffpc/buffer.h

@@ -36,14 +36,17 @@ struct buffer;
 struct buffer_ops {
 	/* op checking */
 	int (*check_append)(struct buffer *, const void *, size_t);
+	int (*check_read)(struct buffer *, void *, size_t, size_t);
 	int (*check_truncate)(struct buffer *, size_t);
+	int (*check_write)(struct buffer *, const void *, size_t, size_t);
 	ssize_t (*check_seek)(struct buffer *, off_t, int, size_t);
 
 	/* data manipulation */
 	void *(*realloc)(void *, size_t);
 	void (*free)(void *);
 	void (*clear)(struct buffer *, size_t, size_t);
 	void (*copyin)(struct buffer *, size_t, const void *, size_t);
+	void (*copyout)(struct buffer *, size_t, void *, size_t);
 };
 
 struct buffer {
@@ -73,6 +76,10 @@ extern void buffer_init_stdio(struct buffer *buffer, FILE *f);
 extern int buffer_append(struct buffer *buffer, const void *data, size_t size);
 extern ssize_t buffer_seek(struct buffer *buffer, off_t offset, int whence);
 extern int buffer_truncate(struct buffer *buffer, size_t size);
+extern ssize_t buffer_pread(struct buffer *buffer, void *data, size_t len,
+			    size_t off);
+extern ssize_t buffer_pwrite(struct buffer *buffer, const void *data, size_t len,
+			     size_t off);
 
 static inline size_t buffer_used(struct buffer *buffer)
 {
@@ -119,4 +126,31 @@ static inline int buffer_append_str(struct buffer *buffer, const struct str *s)
 	return buffer_append_cstr(buffer, str);
 }
 
+/* same as buffer_pread(), but it uses and updates current offset */
+static inline ssize_t buffer_read(struct buffer *buffer, void *buf, size_t len)
+{
+	ssize_t ret;
+
+	ret = buffer_pread(buffer, buf, len, buffer->off);
+
+	if (ret >= 0)
+		buffer->off += ret;
+
+	return ret;
+}
+
+/* same as buffer_pwrite(), but it uses and updates current offset */
+static inline ssize_t buffer_write(struct buffer *buffer, const void *buf,
+				   size_t len)
+{
+	ssize_t ret;
+
+	ret = buffer_pwrite(buffer, buf, len, buffer->off);
+
+	if (ret >= 0)
+		buffer->off += ret;
+
+	return ret;
+}
+
 #endif

mapfile-vers

@@ -42,6 +42,8 @@ JEFFPC_0.10 {
 		buffer_init_sink;
 		buffer_init_static;
 		buffer_init_stdio;
+		buffer_pread;
+		buffer_pwrite;
 		buffer_seek;
 		buffer_truncate;