GNUnet  0.11.x
buffer.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2020 GNUnet e.V.
4 
5  GNUnet is free software; you can redistribute it and/or modify it under the
6  terms of the GNU Affero General Public License as published by the Free Software
7  Foundation; either version 3, or (at your option) any later version.
8 
9  GNUnet is distributed in the hope that it will be useful, but WITHOUT ANY
10  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
11  A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
12 
13  You should have received a copy of the GNU Affero General Public License along with
14  GNUnet; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
15 */
21 #include "platform.h"
22 #include "gnunet_util_lib.h"
23 #include "gnunet_buffer_lib.h"
24 
34 void
35 GNUNET_buffer_prealloc (struct GNUNET_Buffer *buf, size_t capacity)
36 {
37  /* Buffer should be zero-initialized */
38  GNUNET_assert (0 == buf->mem);
39  GNUNET_assert (0 == buf->capacity);
40  GNUNET_assert (0 == buf->position);
41  buf->mem = GNUNET_malloc (capacity);
42  buf->capacity = capacity;
43  buf->warn_grow = GNUNET_YES;
44 }
45 
46 
53 void
55  size_t n)
56 {
57  size_t new_capacity = buf->position + n;
58 
59  /* guard against overflow */
60  GNUNET_assert (new_capacity >= buf->position);
61  if (new_capacity <= buf->capacity)
62  return;
63  /* warn if calculation of expected size was wrong */
65  if (new_capacity < buf->capacity * 2)
66  new_capacity = buf->capacity * 2;
67  buf->capacity = new_capacity;
68  if (NULL != buf->mem)
69  buf->mem = GNUNET_realloc (buf->mem, new_capacity);
70  else
71  buf->mem = GNUNET_malloc (new_capacity);
72 }
73 
74 
84 void
86  const char *data,
87  size_t len)
88 {
90  memcpy (buf->mem + buf->position, data, len);
91  buf->position += len;
92 }
93 
94 
101 void
103  const char *str)
104 {
105  size_t len = strlen (str);
106 
107  GNUNET_buffer_write (buf, str, len);
108 }
109 
110 
121 char *
123 {
124  char *res;
125 
126  /* ensure 0-termination */
127  if ( (0 == buf->position) || ('\0' != buf->mem[buf->position - 1]))
128  {
130  buf->mem[buf->position++] = '\0';
131  }
132  res = buf->mem;
133  memset (buf, 0, sizeof (struct GNUNET_Buffer));
134  return res;
135 }
136 
137 
147 void *
149 {
150  *size = buf->position;
151  void *res = buf->mem;
152  memset (buf, 0, sizeof (struct GNUNET_Buffer));
153  return res;
154 }
155 
156 
162 void
164 {
165  GNUNET_free (buf->mem);
166  memset (buf, 0, sizeof (struct GNUNET_Buffer));
167 }
168 
169 
178 void
179 GNUNET_buffer_write_path (struct GNUNET_Buffer *buf, const char *str)
180 {
181  size_t len = strlen (str);
182 
183  while ( (0 != len) && ('/' == str[0]) )
184  {
185  str++;
186  len--;
187  }
188  if ( (0 == buf->position) || ('/' != buf->mem[buf->position - 1]) )
189  {
191  buf->mem[buf->position++] = '/';
192  }
193  GNUNET_buffer_write (buf, str, len);
194 }
195 
196 
207 void
208 GNUNET_buffer_write_fstr (struct GNUNET_Buffer *buf, const char *fmt, ...)
209 {
210  va_list args;
211 
212  va_start (args, fmt);
213  GNUNET_buffer_write_vfstr (buf, fmt, args);
214  va_end (args);
215 }
216 
217 
228 void
230  const char *fmt,
231  va_list args)
232 {
233  int res;
234  va_list args2;
235 
236  va_copy (args2, args);
237  res = vsnprintf (NULL, 0, fmt, args2);
238  va_end (args2);
239 
240  GNUNET_assert (res >= 0);
241  GNUNET_buffer_ensure_remaining (buf, res + 1);
242 
243  va_copy (args2, args);
244  res = vsnprintf (buf->mem + buf->position, res + 1, fmt, args2);
245  va_end (args2);
246 
247  GNUNET_assert (res >= 0);
248  buf->position += res;
249  GNUNET_assert (buf->position <= buf->capacity);
250 }
size_t capacity
Capacity of the buffer.
char * GNUNET_buffer_reap_str(struct GNUNET_Buffer *buf)
Clear the buffer and return the string it contained.
Definition: buffer.c:122
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void * GNUNET_buffer_reap(struct GNUNET_Buffer *buf, size_t *size)
Clear the buffer and return its contents.
Definition: buffer.c:148
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void GNUNET_buffer_write(struct GNUNET_Buffer *buf, const char *data, size_t len)
Write bytes to the buffer.
Definition: buffer.c:85
void GNUNET_buffer_write_str(struct GNUNET_Buffer *buf, const char *str)
Write a 0-terminated string to a buffer, excluding the 0-terminator.
Definition: buffer.c:102
#define GNUNET_realloc(ptr, size)
Wrapper around realloc.
void GNUNET_buffer_write_fstr(struct GNUNET_Buffer *buf, const char *fmt,...)
Write a 0-terminated formatted string to a buffer, excluding the 0-terminator.
Definition: buffer.c:208
static char buf[2048]
void GNUNET_buffer_clear(struct GNUNET_Buffer *buf)
Free the backing memory of the given buffer.
Definition: buffer.c:163
char * mem
Backing memory.
size_t position
Current write position.
static int res
static unsigned int size
Size of the "table".
Definition: peer.c:67
void GNUNET_buffer_write_vfstr(struct GNUNET_Buffer *buf, const char *fmt, va_list args)
Write a 0-terminated formatted string to a buffer, excluding the 0-terminator.
Definition: buffer.c:229
void GNUNET_buffer_prealloc(struct GNUNET_Buffer *buf, size_t capacity)
Initialize a buffer with the given capacity.
Definition: buffer.c:35
void GNUNET_buffer_ensure_remaining(struct GNUNET_Buffer *buf, size_t n)
Make sure that at least n bytes remaining in the buffer.
Definition: buffer.c:54
void GNUNET_buffer_write_path(struct GNUNET_Buffer *buf, const char *str)
Write a path component to a buffer, ensuring that there is exactly one slash between the previous con...
Definition: buffer.c:179
Common buffer management functions.
uint32_t data
The data value.
int warn_grow
Log a warning if the buffer is grown over its initially allocated capacity.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...