buffer.c 2.86 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/* buffer.c
 *
 * A bare-bones string stream.
 */

/* nettle, low-level cryptographics library
 *
 * Copyright (C) 2002 Niels Mller
 *  
 * The nettle library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 * 
 * The nettle library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with the nettle library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#include "buffer.h"

Niels Möller's avatar
Niels Möller committed
28
#include <assert.h>
29
30
31
#include <stdlib.h>
#include <string.h>

32
33
34
int
nettle_buffer_grow(struct nettle_buffer *buffer,
		   unsigned length)
35
{
36
  assert(buffer->size <= buffer->alloc);
37
38
  
  if (buffer->size + length > buffer->alloc)
39
    {
40
41
42
43
44
45
46
47
      unsigned alloc;
      uint8_t *p;
      
      if (!buffer->realloc)
	return 0;
      
      alloc = buffer->alloc * 2 + length + 100;
      p = buffer->realloc(buffer->realloc_ctx, buffer->contents, alloc);
48
49
50
51
52
53
      if (!p)
	return 0;
      
      buffer->contents = p;
      buffer->alloc = alloc;
    }
54
  return 1;
55
56
}

57
58
59
60
61
62
63
64
65
66
67
68
void
nettle_buffer_init_realloc(struct nettle_buffer *buffer,
			   void *realloc_ctx,
			   nettle_realloc_func realloc)
{
  buffer->contents = NULL;
  buffer->alloc = 0;
  buffer->realloc = realloc;
  buffer->realloc_ctx = realloc_ctx;
  buffer->size = 0;
}

69
70
71
72
73
74
void
nettle_buffer_init_size(struct nettle_buffer *buffer,
			unsigned length, uint8_t *space)
{
  buffer->contents = space;
  buffer->alloc = length;
75
76
  buffer->realloc = NULL;
  buffer->realloc_ctx = NULL;
77
78
79
80
81
82
  buffer->size = 0;
}

void
nettle_buffer_clear(struct nettle_buffer *buffer)
{
83
84
85
86
87
88
  if (buffer->realloc)
    buffer->realloc(buffer->realloc_ctx, buffer->contents, 0);

  buffer->contents = NULL;
  buffer->alloc = 0;
  buffer->size = 0;
89
90
}

91
92
93
94
95
96
void
nettle_buffer_reset(struct nettle_buffer *buffer)
{
  buffer->size = 0;
}

97
98
99
100
101
uint8_t *
nettle_buffer_space(struct nettle_buffer *buffer,
		    unsigned length)
{
  uint8_t *p;
102
103
104

  if (!nettle_buffer_grow(buffer, length))
    return NULL;
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

  p = buffer->contents + buffer->size;
  buffer->size += length;
  return p;
}
     
int
nettle_buffer_write(struct nettle_buffer *buffer,
		    unsigned length, const uint8_t *data)
{
  uint8_t *p = nettle_buffer_space(buffer, length);
  if (p)
    {
      memcpy(p, data, length);
      return 1;
    }
  else
    return 0;
}
124
125
126
127
128
129
130

int
nettle_buffer_copy(struct nettle_buffer *dst,
		   const struct nettle_buffer *src)
{
  nettle_buffer_write(dst, src->size, src->contents);
}