odr/odr_mem.c

   1 /*
   2  * Copyright (c) 1995, Index Data
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: odr_mem.c,v $
   7  * Revision 1.9  1995-10-13 16:08:08  quinn
   8  * Added OID utility
   9  *
  10  * Revision 1.8  1995/09/29  17:12:24  quinn
  11  * Smallish
  12  *
  13  * Revision 1.7  1995/09/27  15:02:59  quinn
  14  * Modified function heads & prototypes.
  15  *
  16  * Revision 1.6  1995/08/21  09:10:41  quinn
  17  * Smallish fixes to suppport new formats.
  18  *
  19  * Revision 1.5  1995/05/16  08:50:55  quinn
  20  * License, documentation, and memory fixes
  21  *
  22  * Revision 1.4  1995/05/15  11:56:09  quinn
  23  * More work on memory management.
  24  *
  25  * Revision 1.3  1995/04/18  08:15:21  quinn
  26  * Added dynamic memory allocation on encoding (whew). Code is now somewhat
  27  * neater. We'll make the same change for decoding one day.
  28  *
  29  * Revision 1.2  1995/03/17  10:17:52  quinn
  30  * Added memory management.
  31  *
  32  * Revision 1.1  1995/03/14  10:27:40  quinn
  33  * Modified makefile to use common lib
  34  * Beginning to add memory management to odr
  35  *
  36  */
  37
  38 #include <stdlib.h>
  39 #include <odr.h>
  40 #include <dmalloc.h>
  41
  42 /* ------------------------ NIBBLE MEMORY ---------------------- */
  43
  44 #define ODR_MEM_CHUNK (10*1024)
  45
  46 typedef struct odr_memblock
  47 {
  48     char *buf;
  49     int size;
  50     int top;
  51     int total;
  52     struct odr_memblock *next;
  53 } odr_memblock;
  54
  55 static odr_memblock *freelist = 0; /* global freelist */
  56
  57 static void free_block(odr_memblock *p)
  58 {
  59     p->next = freelist;
  60     freelist = p;
  61 }
  62
  63 /*
  64  * acquire a block with a minimum of size free bytes.
  65  */
  66 static odr_memblock *get_block(int size)
  67 {
  68     odr_memblock *r, *l;
  69
  70     for (r = freelist, l = 0; r; l = r, r = r->next)
  71         if (r->size >= size)
  72             break;
  73     if (r)
  74         if (l)
  75             l->next = r->next;
  76         else
  77             freelist = r->next;
  78     else
  79     {
  80         int get = ODR_MEM_CHUNK;
  81
  82         if (get < size)
  83             get = size;
  84         if (!(r = malloc(sizeof(*r))))
  85             abort();
  86         if (!(r->buf = malloc(r->size = get)))
  87             abort();
  88     }
  89     r->top = 0;
  90     r->total = 0;
  91     return r;
  92 }
  93
  94 /*
  95  * Return p to the global freelist.
  96  */
  97 void odr_release_mem(ODR_MEM p)
  98 {
  99     odr_memblock *t;
 100
 101     while (p)
 102     {
 103         t = p;
 104         p = p->next;
 105         free_block(t);
 106     }
 107 }
 108
 109 /*
 110  * Extract the memory control block from o.
 111  */
 112 ODR_MEM odr_extract_mem(ODR o)
 113 {
 114     ODR_MEM r = o->mem;
 115
 116     o->mem = 0;
 117     return r;
 118 }
 119
 120 void *odr_malloc(ODR o, int size)
 121 {
 122     struct odr_memblock *p = o->mem;
 123     char *r;
 124
 125     if (!o)
 126     {
 127         if (!(r = malloc(size)))
 128             abort();
 129         return r;
 130     }
 131     if (!p || p->size - p->top < size)
 132         if (!(p = get_block(size)))
 133             abort();
 134         else
 135         {
 136             if (o->mem)
 137                 p->total = o->mem->total;
 138             p->next = o->mem;
 139             o->mem = p;
 140         }
 141     r = p->buf + p->top;
 142     /* align size */
 143     p->top += (size + (sizeof(long) - 1)) & ~(sizeof(long) - 1);
 144     p->total += size;
 145     return r;
 146 }
 147
 148 int odr_total(ODR o)
 149 {
 150     return o->mem ? o->mem->total : 0;
 151 }
 152
 153 /* ---------- memory management for data encoding ----------*/
 154
 155
 156 int odr_grow_block(odr_ecblock *b, int min_bytes)
 157 {
 158     int togrow;
 159
 160     if (!b->can_grow)
 161         return -1;
 162     if (!b->size)
 163         togrow = 1024;
 164     else
 165         togrow = b->size;
 166     if (togrow < min_bytes)
 167         togrow = min_bytes;
 168     if (b->size && !(b->buf = realloc(b->buf, b->size += togrow)))
 169         abort();
 170     else if (!b->size && !(b->buf = malloc(b->size = togrow)))
 171         abort();
 172 #ifdef ODR_DEBUG
 173     fprintf(stderr, "New size for encode_buffer: %d\n", b->size);
 174 #endif
 175     return 0;
 176 }
 177
 178 int odr_write(ODR o, unsigned char *buf, int bytes)
 179 {
 180     if (o->ecb.pos + bytes >= o->ecb.size && odr_grow_block(&o->ecb, bytes))
 181     {
 182         o->error = OSPACE;
 183         return -1;
 184     }
 185     memcpy(o->ecb.buf + o->ecb.pos, buf, bytes);
 186     o->ecb.pos += bytes;
 187     if (o->ecb.pos > o->ecb.top)
 188         o->ecb.top = o->ecb.pos;
 189     return 0;
 190 }
 191
 192 int odr_seek(ODR o, int whence, int offset)
 193 {
 194     if (whence == ODR_S_CUR)
 195         offset += o->ecb.pos;
 196     else if (whence == ODR_S_END)
 197         offset += o->ecb.top;
 198     if (offset > o->ecb.size && odr_grow_block(&o->ecb, offset - o->ecb.size))
 199     {
 200         o->error = OSPACE;
 201         return -1;
 202     }
 203     o->ecb.pos = offset;
 204     return 0;
 205 }