buffer.c 2.91 KB
Newer Older
1
2
3
4
5
6
7
/* buffer.c
 *
 * A bare-bones string stream.
 */

/* nettle, low-level cryptographics library
 *
Niels Möller's avatar
Niels Möller committed
8
 * Copyright (C) 2002 Niels Möller
9
10
11
12
13
14
15
16
17
18
19
20
21
 *  
 * 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
22
23
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02111-1301, USA.
24
25
 */

26
27
28
#if HAVE_CONFIG_H
# include "config.h"
#endif
29

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

34
35
#include "buffer.h"

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

61
62
63
void
nettle_buffer_init_realloc(struct nettle_buffer *buffer,
			   void *realloc_ctx,
64
			   nettle_realloc_func *realloc)
65
66
67
68
69
70
71
72
{
  buffer->contents = NULL;
  buffer->alloc = 0;
  buffer->realloc = realloc;
  buffer->realloc_ctx = realloc_ctx;
  buffer->size = 0;
}

73
74
void
nettle_buffer_init_size(struct nettle_buffer *buffer,
75
			size_t length, uint8_t *space)
76
77
78
{
  buffer->contents = space;
  buffer->alloc = length;
79
80
  buffer->realloc = NULL;
  buffer->realloc_ctx = NULL;
81
82
83
84
85
86
  buffer->size = 0;
}

void
nettle_buffer_clear(struct nettle_buffer *buffer)
{
87
88
89
90
91
92
  if (buffer->realloc)
    buffer->realloc(buffer->realloc_ctx, buffer->contents, 0);

  buffer->contents = NULL;
  buffer->alloc = 0;
  buffer->size = 0;
93
94
}

95
96
97
98
99
100
void
nettle_buffer_reset(struct nettle_buffer *buffer)
{
  buffer->size = 0;
}

101
102
uint8_t *
nettle_buffer_space(struct nettle_buffer *buffer,
103
		    size_t length)
104
105
{
  uint8_t *p;
106
107
108

  if (!nettle_buffer_grow(buffer, length))
    return NULL;
109
110
111
112
113
114
115
116

  p = buffer->contents + buffer->size;
  buffer->size += length;
  return p;
}
     
int
nettle_buffer_write(struct nettle_buffer *buffer,
117
		    size_t length, const uint8_t *data)
118
119
120
121
122
123
124
125
126
127
{
  uint8_t *p = nettle_buffer_space(buffer, length);
  if (p)
    {
      memcpy(p, data, length);
      return 1;
    }
  else
    return 0;
}
128
129
130
131
132

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