buffer.c 2.37 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
28
29
30
/* 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"

#include <stdlib.h>
#include <string.h>

31
32
33
int
nettle_buffer_grow(struct nettle_buffer *buffer,
		   unsigned length)
34
{
35
36
37
  assert(buffer->size <= buffer->realloc);
  
  if (buffer->size + length > buffer->alloc)
38
    {
39
40
41
42
43
44
45
46
      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);
47
48
49
50
51
52
      if (!p)
	return 0;
      
      buffer->contents = p;
      buffer->alloc = alloc;
    }
53
  return 1;
54
55
56
57
58
59
60
61
}

void
nettle_buffer_init_size(struct nettle_buffer *buffer,
			unsigned length, uint8_t *space)
{
  buffer->contents = space;
  buffer->alloc = length;
62
63
  buffer->realloc = NULL;
  buffer->realloc_ctx = NULL;
64
65
66
67
68
69
  buffer->size = 0;
}

void
nettle_buffer_clear(struct nettle_buffer *buffer)
{
70
71
72
73
74
75
  if (buffer->realloc)
    buffer->realloc(buffer->realloc_ctx, buffer->contents, 0);

  buffer->contents = NULL;
  buffer->alloc = 0;
  buffer->size = 0;
76
77
78
79
80
81
82
}

uint8_t *
nettle_buffer_space(struct nettle_buffer *buffer,
		    unsigned length)
{
  uint8_t *p;
83
84
85

  if (!nettle_buffer_grow(buffer, length))
    return NULL;
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

  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;
}