Mercurial > hg > ucx / changeset

     1.1 --- a/test/buffer_tests.c	Tue May 06 12:03:16 2014 +0200
     1.2 +++ b/test/buffer_tests.c	Tue May 06 12:30:12 2014 +0200
     1.3 @@ -363,6 +363,8 @@
     1.4  
     1.5  UCX_TEST(test_ucx_buffer_write) {
     1.6      char *buffer = (char*) malloc(32);
     1.7 +    memset(buffer, 0, 32);
     1.8 +    
     1.9      memset(buffer, 32, 8);
    1.10      for (int i = 8; i < 16 ; i++) {
    1.11          buffer[i] = 40+i;
    1.12 @@ -432,6 +434,7 @@
    1.13  
    1.14  UCX_TEST(test_ucx_buffer_write_ax) {
    1.15      char *buffer = (char*) malloc(16);
    1.16 +    memset(buffer, 0, 16);
    1.17  
    1.18      UcxBuffer *b = ucx_buffer_new(buffer, 16,
    1.19              UCX_BUFFER_AUTOEXTEND | UCX_BUFFER_AUTOFREE);

     2.1 --- a/ucx/buffer.c	Tue May 06 12:03:16 2014 +0200
     2.2 +++ b/ucx/buffer.c	Tue May 06 12:30:12 2014 +0200
     2.3 @@ -31,22 +31,22 @@
     2.4  #include <stdlib.h>
     2.5  #include <string.h>
     2.6  
     2.7 -UcxBuffer *ucx_buffer_new(void *space, size_t size, int flags) {
     2.8 +UcxBuffer *ucx_buffer_new(void *space, size_t capacity, int flags) {
     2.9      UcxBuffer *buffer = (UcxBuffer*) malloc(sizeof(UcxBuffer));
    2.10      if (buffer) {
    2.11          buffer->flags = flags;
    2.12          if (!space) {
    2.13 -            buffer->space = (char*)malloc(size);
    2.14 +            buffer->space = (char*)malloc(capacity);
    2.15              if (!buffer->space) {
    2.16                  free(buffer);
    2.17                  return NULL;
    2.18              }
    2.19 -            memset(buffer->space, 0, size);
    2.20 +            memset(buffer->space, 0, capacity);
    2.21              buffer->flags |= UCX_BUFFER_AUTOFREE;
    2.22          } else {
    2.23              buffer->space = (char*)space;
    2.24          }
    2.25 -        buffer->capacity = size;
    2.26 +        buffer->capacity = capacity;
    2.27          buffer->size = 0;
    2.28  
    2.29          buffer->pos = 0;
    2.30 @@ -64,13 +64,8 @@
    2.31  
    2.32  UcxBuffer* ucx_buffer_extract(
    2.33          UcxBuffer *src, size_t start, size_t length, int flags) {
    2.34 -    if(src->size == 0) {
    2.35 -        return NULL;
    2.36 -    }
    2.37 -    if (length == 0) {
    2.38 -        length = src->size - start;
    2.39 -    }
    2.40 -    if (start+length > src->size) {
    2.41 +    
    2.42 +    if (src->size == 0 || length == 0 || start+length > src->capacity) {
    2.43          return NULL;
    2.44      }
    2.45  
    2.46 @@ -99,13 +94,21 @@
    2.47      case SEEK_END:
    2.48          npos = buffer->size;
    2.49          break;
    2.50 +    case SEEK_SET:
    2.51 +        npos = 0;
    2.52 +        break;
    2.53      default:
    2.54 -        npos = 0;
    2.55 +        return -1;
    2.56      }
    2.57  
    2.58 +    size_t opos = npos;
    2.59      npos += offset;
    2.60      
    2.61 -    if (npos > buffer->size) {
    2.62 +    if ((offset > 0 && npos < opos) || (offset < 0 && npos > opos)) {
    2.63 +        return -1;
    2.64 +    }
    2.65 +    
    2.66 +    if (npos >= buffer->size) {
    2.67          return -1;
    2.68      } else {
    2.69          buffer->pos = npos;
    2.70 @@ -120,7 +123,17 @@
    2.71  
    2.72  int ucx_buffer_extend(UcxBuffer *buffer, size_t len) {
    2.73      size_t newcap = buffer->capacity;
    2.74 -    while (buffer->pos + len > newcap) newcap <<= 1;
    2.75 +    
    2.76 +    if (buffer->capacity + len < buffer->capacity) {
    2.77 +        return -1;
    2.78 +    }
    2.79 +    
    2.80 +    while (buffer->capacity + len > newcap) {
    2.81 +        newcap <<= 1;
    2.82 +        if (newcap < buffer->capacity) {
    2.83 +            return -1;
    2.84 +        }
    2.85 +    }
    2.86      
    2.87      char *newspace = (char*)realloc(buffer->space, newcap);
    2.88      if (newspace) {
    2.89 @@ -137,18 +150,25 @@
    2.90  size_t ucx_buffer_write(const void *ptr, size_t size, size_t nitems,
    2.91          UcxBuffer *buffer) {
    2.92      size_t len = size * nitems;
    2.93 -    if (buffer->pos + len > buffer->capacity) {
    2.94 +    size_t required = buffer->pos + len;
    2.95 +    if (buffer->pos > required) {
    2.96 +        return 0;
    2.97 +    }
    2.98 +    
    2.99 +    if (required > buffer->capacity) {
   2.100          if ((buffer->flags & UCX_BUFFER_AUTOEXTEND) == UCX_BUFFER_AUTOEXTEND) {
   2.101 -            if(ucx_buffer_extend(buffer, len)) {
   2.102 -                return -1;
   2.103 +            if (ucx_buffer_extend(buffer, required - buffer->capacity)) {
   2.104 +                return 0;
   2.105              }
   2.106          } else {
   2.107              len = buffer->capacity - buffer->pos;
   2.108 -            if (size > 1) len -= len%size;
   2.109 +            if (size > 1) {
   2.110 +                len -= len%size;
   2.111 +            }
   2.112          }
   2.113      }
   2.114      
   2.115 -    if (len <= 0) {
   2.116 +    if (len == 0) {
   2.117          return len;
   2.118      }
   2.119      

     3.1 --- a/ucx/buffer.h	Tue May 06 12:03:16 2014 +0200
     3.2 +++ b/ucx/buffer.h	Tue May 06 12:30:12 2014 +0200
     3.3 @@ -97,11 +97,11 @@
     3.4   * 
     3.5   * @param space pointer to the memory area, or <code>NULL</code> to allocate
     3.6   * new memory
     3.7 - * @param size the size of the buffer
     3.8 + * @param capacity the capacity of the buffer
     3.9   * @param flags buffer features (see UcxBuffer.flags)
    3.10   * @return the new buffer
    3.11   */
    3.12 -UcxBuffer *ucx_buffer_new(void *space, size_t size, int flags);
    3.13 +UcxBuffer *ucx_buffer_new(void *space, size_t capacity, int flags);
    3.14  
    3.15  /**
    3.16   * Destroys a buffer.