binyo 0.0.1

data/ext/binyo/io_buffer.c

@@ -0,0 +1,143 @@
+/*
+ * binyo - Fast binary IO for Ruby
+ *
+ * Copyright (c) 2012-2013
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "binyo-io-buffer.h"
+#include "binyo-error.h"
+#include "binyo-error-internal.h"
+
+binyo_byte_buffer *
+binyo_buffer_new(void)
+{
+    binyo_byte_buffer *ret;
+    ret = ALLOC(binyo_byte_buffer);
+    memset(ret, 0, sizeof(binyo_byte_buffer));
+    return ret;
+}
+
+binyo_byte_buffer *
+binyo_buffer_new_size(size_t size)
+{
+    binyo_byte_buffer *ret;
+    ret = binyo_buffer_new();
+    ret->init_size = size;
+    return ret;
+}
+
+binyo_byte_buffer *
+binyo_buffer_new_prealloc(uint8_t *b, size_t len)
+{
+    binyo_byte_buffer *ret;
+    ret = binyo_buffer_new();
+    ret->data = b;
+    ret->limit = len;
+    ret->prealloc = 1;
+    return ret;
+}
+
+static const size_t BINYO_BUF_MAX = SIZE_MAX / BINYO_BYTE_BUFFER_GROWTH_FACTOR;
+
+static int
+int_buffer_grow(binyo_byte_buffer *buffer, size_t cur_len)
+{
+    size_t new_size;
+
+    if (buffer->prealloc) {
+	binyo_error_add("Cannot grow preallocated buffer");
+	return BINYO_ERR;
+    }
+
+    if (buffer->data == NULL) {
+	size_t alloc_size = buffer->init_size > cur_len ? buffer->init_size : cur_len;
+	buffer->data = ALLOC_N(uint8_t, alloc_size);
+	buffer->limit = alloc_size;
+	return BINYO_OK;
+    }
+
+    /* avoid infinite loop for limit == 1 */
+    new_size = buffer->limit == 1 ? 2 : buffer->limit;
+
+    while (new_size - buffer->size < cur_len) {
+	if (new_size >= BINYO_BUF_MAX) {
+	    binyo_error_add("Cannot grow buffer");
+	    return BINYO_ERR;
+	}
+    	new_size *= BINYO_BYTE_BUFFER_GROWTH_FACTOR;
+    }
+
+    REALLOC_N(buffer->data, uint8_t, new_size);
+    buffer->limit = new_size; 
+    return BINYO_OK;
+}
+
+ssize_t
+binyo_buffer_write(binyo_byte_buffer *buffer, uint8_t *b, size_t len)
+{
+    if (!b) return BINYO_ERR;
+    if (len == 0) return 0;
+    if (len > SSIZE_MAX) return BINYO_ERR;
+
+    if (buffer->limit - buffer->size < len) {
+	if (int_buffer_grow(buffer, len) == BINYO_ERR)
+	    return BINYO_ERR;
+    }
+
+    memcpy(buffer->data + buffer->size, b, len);
+    buffer->size += len;
+    return (ssize_t) len;
+}
+
+void
+binyo_buffer_free_secure(binyo_byte_buffer *buffer)
+{
+    if (buffer && buffer->data) {
+	memset(buffer->data, 0, buffer->limit);
+    }
+    binyo_buffer_free(buffer);
+}
+
+void
+binyo_buffer_free(binyo_byte_buffer *buffer)
+{
+    if (!buffer) return;
+    if (buffer->data && (!buffer->prealloc))
+	xfree(buffer->data);
+    xfree(buffer);
+}
+
+size_t
+binyo_buffer_get_bytes_free(binyo_byte_buffer *buffer, uint8_t **out)
+{
+    size_t ret;
+
+    if (!buffer) return 0;
+
+    *out = buffer->data;
+    ret = buffer->size;
+    xfree(buffer);
+    return ret;
+}
+

data/ext/binyo/io_in_bytes.c

@@ -0,0 +1,196 @@
+/*
+ * binyo - Fast binary IO for Ruby
+ *
+ * Copyright (c) 2012-2013
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "binyo.h"
+
+struct binyo_byte_ary_st {
+    uint8_t *p;
+    size_t len;
+};
+
+typedef struct binyo_instream_bytes_st {
+    binyo_instream_interface *methods;
+    struct binyo_byte_ary_st *src;
+    size_t num_read;
+} binyo_instream_bytes;
+
+#define int_safe_cast(out, in)		binyo_safe_cast_instream((out), (in), BINYO_INSTREAM_TYPE_BYTES, binyo_instream_bytes)
+
+static binyo_instream_bytes* int_bytes_alloc(void);
+static ssize_t int_bytes_read(binyo_instream *in, uint8_t *buf, size_t len);
+static ssize_t int_bytes_gets(binyo_instream *in, char *line, size_t len);
+static int int_bytes_seek(binyo_instream *in, off_t offset, int whence);
+static void int_bytes_free(binyo_instream *in);
+
+static binyo_instream_interface binyo_interface_bytes = {
+    BINYO_INSTREAM_TYPE_BYTES,
+    int_bytes_read,
+    NULL,
+    int_bytes_gets,
+    int_bytes_seek,
+    NULL,
+    int_bytes_free
+};
+
+binyo_instream *
+binyo_instream_new_bytes(uint8_t *bytes, size_t len)
+{
+    binyo_instream_bytes *in;
+    struct binyo_byte_ary_st *byte_ary;
+
+    in = int_bytes_alloc();
+    byte_ary = ALLOC(struct binyo_byte_ary_st);
+    byte_ary->p = bytes;
+    byte_ary->len = len;
+    in->src = byte_ary;
+    return (binyo_instream *) in;
+}
+
+static binyo_instream_bytes*
+int_bytes_alloc(void)
+{
+    binyo_instream_bytes *ret;
+    ret = ALLOC(binyo_instream_bytes);
+    memset(ret, 0, sizeof(binyo_instream_bytes));
+    ret->methods = &binyo_interface_bytes;
+    return ret;
+}
+
+static ssize_t
+int_bytes_read(binyo_instream *instream, uint8_t *buf, size_t len)
+{
+    struct binyo_byte_ary_st *src;
+    size_t to_read;
+    binyo_instream_bytes *in;
+
+    int_safe_cast(in, instream);
+
+    if (!buf) return BINYO_ERR;
+
+    src = in->src;
+
+    if (in->num_read == src->len)
+	return BINYO_IO_EOF;
+
+    /* Check for SSIZE_MAX already done in io.c */
+    to_read = src->len - in->num_read < len ? src->len - in->num_read : len;
+    memcpy(buf, src->p, to_read);
+    src->p += to_read;
+    in->num_read += to_read;
+    return (ssize_t) to_read;
+}
+
+static ssize_t
+int_bytes_gets(binyo_instream *instream, char *line, size_t len)
+{
+    struct binyo_byte_ary_st *src;
+    binyo_instream_bytes *in;
+    ssize_t ret = 0;
+    size_t to_read;
+    char *d;
+    char *end;
+
+    int_safe_cast(in, instream);
+    src = in->src;
+
+    if (in->num_read == src->len)
+	return BINYO_IO_EOF;
+
+    d = line;
+    to_read = src->len - in->num_read < len ? src->len - in->num_read : len;
+    end = d + to_read;
+
+    /* ret cannot exceed SSIZE_MAX, check for len already done in io.c */
+    while (d < end) {
+	*d = *(src->p);    
+	src->p++;
+	if (*d == '\n') {
+            in->num_read++;
+	    break;
+        }
+	d++;
+	ret++;
+    }
+    in->num_read += ret;
+
+    if (*d == '\n' && *(d - 1) == '\r')
+	ret--;
+
+    return ret;
+}
+
+static int
+int_bytes_set_pos(binyo_instream_bytes *in, off_t offset, size_t num_read)
+{
+    struct binyo_byte_ary_st *src = in->src;
+
+    if (src->len - offset <= num_read) {
+	binyo_error_add("Unreachable seek position");
+	return BINYO_ERR;
+    }
+    src->p += offset;
+    in->num_read += offset;
+    return BINYO_OK;
+}
+
+/* TODO check overflow */
+static int
+int_bytes_seek(binyo_instream *instream, off_t offset, int whence)
+{
+    struct binyo_byte_ary_st *src;
+    size_t num_read;
+    binyo_instream_bytes *in;
+
+    int_safe_cast(in, instream);
+
+    src = in->src;
+    num_read = in->num_read;
+
+    switch (whence) {
+	case SEEK_CUR:
+	    return int_bytes_set_pos(in, offset, num_read);
+	case SEEK_SET:
+	    return int_bytes_set_pos(in, offset - num_read, num_read);
+	case SEEK_END:
+	    return int_bytes_set_pos(in, offset + src->len - num_read, num_read);
+	default:
+	    binyo_error_add("Unknown whence: %d", whence);
+	    return BINYO_ERR;
+    }
+}
+
+static void
+int_bytes_free(binyo_instream *instream)
+{
+    binyo_instream_bytes *in;
+
+    if (!instream) return;
+    int_safe_cast(in, instream);
+
+    xfree(in->src);
+}
+

data/ext/binyo/io_in_cache.c

@@ -0,0 +1,144 @@
+/*
+ * binyo - Fast binary IO for Ruby
+ *
+ * Copyright (c) 2012-2013
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "binyo.h"
+
+typedef struct binyo_instream_cache_st {
+    binyo_instream_interface *methods;
+    binyo_instream *inner;
+    binyo_outstream *bytes;
+} binyo_instream_cache;
+
+#define int_safe_cast(out, in)		binyo_safe_cast_instream((out), (in), BINYO_INSTREAM_TYPE_CACHE, binyo_instream_cache)
+
+static binyo_instream_cache* int_cache_alloc(void);
+static ssize_t int_cache_read(binyo_instream *in, uint8_t *buf, size_t len);
+static int int_cache_seek(binyo_instream *in, off_t offset, int whence);
+static void int_cache_mark(binyo_instream *in);
+static void int_cache_free(binyo_instream *in);
+
+static binyo_instream_interface binyo_interface_cache = {
+    BINYO_INSTREAM_TYPE_CACHE,
+    int_cache_read,
+    NULL,
+    NULL,
+    int_cache_seek,
+    int_cache_mark,
+    int_cache_free
+};
+
+binyo_instream *
+binyo_instream_new_cache(binyo_instream *original)
+{
+    binyo_instream_cache *in;
+
+    in = int_cache_alloc();
+    in->inner = original;
+    in->bytes = binyo_outstream_new_bytes_size(1024);
+    return (binyo_instream *) in;
+}
+
+size_t
+binyo_instream_cache_get_bytes(binyo_instream *instream, uint8_t **out)
+{
+    binyo_instream_cache *in;
+    size_t ret;
+
+    int_safe_cast(in, instream);
+    ret = binyo_outstream_bytes_get_bytes_free(in->bytes, out);
+    in->bytes = binyo_outstream_new_bytes_size(1024);
+    return ret;
+}
+
+static binyo_instream_cache*
+int_cache_alloc(void)
+{
+    binyo_instream_cache *ret;
+    ret = ALLOC(binyo_instream_cache);
+    memset(ret, 0, sizeof(binyo_instream_cache));
+    ret->methods = &binyo_interface_cache;
+    return ret;
+}
+
+static ssize_t
+int_cache_read(binyo_instream *instream, uint8_t *buf, size_t len)
+{
+    ssize_t read;
+    binyo_instream_cache *in;
+
+    int_safe_cast(in, instream);
+
+    if (!buf) return BINYO_ERR;
+
+    read = binyo_instream_read(in->inner, buf, len);
+    if (read > 0)
+	binyo_outstream_write(in->bytes, buf, read);
+    return read;
+}
+
+static int
+int_cache_seek(binyo_instream *instream, off_t offset, int whence)
+{
+    binyo_instream_cache *in;
+
+    int_safe_cast(in, instream);
+    return binyo_instream_seek(in->inner, offset, whence);
+}
+
+static void
+int_cache_mark(binyo_instream *instream)
+{
+    binyo_instream_cache *in;
+
+    int_safe_cast(in, instream);
+    binyo_instream_mark(in->inner);
+}
+
+static void
+int_cache_free(binyo_instream *instream)
+{
+    binyo_instream_cache *in;
+
+    if (!instream) return;
+
+    int_safe_cast(in, instream);
+    binyo_instream_free(in->inner);
+    binyo_outstream_free(in->bytes);
+}
+
+void 
+binyo_instream_cache_free_wrapper(binyo_instream *instream)
+{
+    binyo_instream_cache *in;
+
+    if (!instream) return;
+
+    int_safe_cast(in, instream);
+    binyo_outstream_free(in->bytes);
+    xfree(in);
+}
+