2
* OpenVPN -- An application to securely tunnel IP networks
3
* over a single UDP port, with support for SSL/TLS-based
4
* session authentication and key exchange,
5
* packet encryption, packet authentication, and
8
* Copyright (C) 2002-2010 OpenVPN Technologies, Inc. <sales@openvpn.net>
10
* This program is free software; you can redistribute it and/or modify
11
* it under the terms of the GNU General Public License version 2
12
* as published by the Free Software Foundation.
14
* This program is distributed in the hope that it will be useful,
15
* but WITHOUT ANY WARRANTY; without even the implied warranty of
16
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
* GNU General Public License for more details.
19
* You should have received a copy of the GNU General Public License
20
* along with this program (see the file COPYING included with this
21
* distribution); if not, write to the Free Software Foundation, Inc.,
22
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31
#define BUF_SIZE_MAX 1000000
34
* Define verify_align function, otherwise
37
/* #define VERIFY_ALIGNMENT */
40
* Keep track of source file/line of buf_init calls
42
#ifdef VERIFY_ALIGNMENT
43
#define BUF_INIT_TRACKING
46
/**************************************************************************/
48
* Wrapper structure for dynamically allocated memory.
50
* The actual content stored in a \c buffer structure starts at the memory
51
* location \c buffer.data \c + \c buffer.offset, and has a length of \c
52
* buffer.len bytes. This, together with the space available before and
53
* after the content, is represented in the pseudocode below:
55
uint8_t *content_start = buffer.data + buffer.offset;
56
uint8_t *content_end = buffer.data + buffer.offset + buffer.len;
57
int prepend_capacity = buffer.offset;
58
int append_capacity = buffer.capacity - (buffer.offset + buffer.len);
63
int capacity; /**< Size in bytes of memory allocated by
65
int offset; /**< Offset in bytes of the actual content
66
* within the allocated memory. */
67
int len; /**< Length in bytes of the actual content
68
* within the allocated memory. */
69
uint8_t *data; /**< Pointer to the allocated memory. */
71
#ifdef BUF_INIT_TRACKING
72
const char *debug_file;
78
/**************************************************************************/
80
* Garbage collection entry for one dynamically allocated block of memory.
82
* This structure represents one link in the linked list contained in a \c
83
* gc_arena structure. Each time the \c gc_malloc() function is called,
84
* it allocates \c sizeof(gc_entry) + the requested number of bytes. The
85
* \c gc_entry is then stored as a header in front of the memory address
86
* returned to the caller.
90
struct gc_entry *next; /**< Pointer to the next item in the
96
* Garbage collection arena used to keep track of dynamically allocated
99
* This structure contains a linked list of \c gc_entry structures. When
100
* a block of memory is allocated using the \c gc_malloc() function, the
101
* allocation is registered in the function's \c gc_arena argument. All
102
* the dynamically allocated memory registered in a \c gc_arena can be
103
* freed using the \c gc_free() function.
107
struct gc_entry *list; /**< First element of the linked list of
108
* \c gc_entry structures. */
112
#define BPTR(buf) (buf_bptr(buf))
113
#define BEND(buf) (buf_bend(buf))
114
#define BLAST(buf) (buf_blast(buf))
115
#define BLEN(buf) (buf_len(buf))
116
#define BDEF(buf) (buf_defined(buf))
117
#define BSTR(buf) (buf_str(buf))
118
#define BCAP(buf) (buf_forward_capacity (buf))
120
void buf_clear (struct buffer *buf);
122
struct buffer clear_buf (void);
123
void free_buf (struct buffer *buf);
125
bool buf_assign (struct buffer *dest, const struct buffer *src);
127
void string_clear (char *str);
128
int string_array_len (const char **array);
130
size_t array_mult_safe (const size_t m1, const size_t m2, const size_t extra);
132
#define PA_BRACKET (1<<0)
133
char *print_argv (const char **p, struct gc_arena *gc, const unsigned int flags);
135
void buf_size_error (const size_t size);
137
/* for dmalloc debugging */
141
#define alloc_buf(size) alloc_buf_debug (size, __FILE__, __LINE__)
142
#define alloc_buf_gc(size, gc) alloc_buf_gc_debug (size, gc, __FILE__, __LINE__);
143
#define clone_buf(buf) clone_buf_debug (buf, __FILE__, __LINE__);
144
#define gc_malloc(size, clear, arena) gc_malloc_debug (size, clear, arena, __FILE__, __LINE__)
145
#define string_alloc(str, gc) string_alloc_debug (str, gc, __FILE__, __LINE__)
146
#define string_alloc_buf(str, gc) string_alloc_buf_debug (str, gc, __FILE__, __LINE__)
148
struct buffer alloc_buf_debug (size_t size, const char *file, int line);
149
struct buffer alloc_buf_gc_debug (size_t size, struct gc_arena *gc, const char *file, int line);
150
struct buffer clone_buf_debug (const struct buffer* buf, const char *file, int line);
151
void *gc_malloc_debug (size_t size, bool clear, struct gc_arena *a, const char *file, int line);
152
char *string_alloc_debug (const char *str, struct gc_arena *gc, const char *file, int line);
153
struct buffer string_alloc_buf_debug (const char *str, struct gc_arena *gc, const char *file, int line);
157
struct buffer alloc_buf (size_t size);
158
struct buffer alloc_buf_gc (size_t size, struct gc_arena *gc); /* allocate buffer with garbage collection */
159
struct buffer clone_buf (const struct buffer* buf);
160
void *gc_malloc (size_t size, bool clear, struct gc_arena *a);
161
char *string_alloc (const char *str, struct gc_arena *gc);
162
struct buffer string_alloc_buf (const char *str, struct gc_arena *gc);
166
#ifdef BUF_INIT_TRACKING
167
#define buf_init(buf, offset) buf_init_debug (buf, offset, __FILE__, __LINE__)
168
bool buf_init_debug (struct buffer *buf, int offset, const char *file, int line);
170
#define buf_init(buf, offset) buf_init_dowork (buf, offset)
174
/* inline functions */
177
buf_defined (const struct buffer *buf)
179
return buf->data != NULL;
183
buf_valid (const struct buffer *buf)
185
return likely (buf->data != NULL) && likely (buf->len >= 0);
188
static inline uint8_t *
189
buf_bptr (const struct buffer *buf)
192
return buf->data + buf->offset;
198
buf_len (const struct buffer *buf)
206
static inline uint8_t *
207
buf_bend (const struct buffer *buf)
209
return buf_bptr (buf) + buf_len (buf);
212
static inline uint8_t *
213
buf_blast (const struct buffer *buf)
215
if (buf_len (buf) > 0)
216
return buf_bptr (buf) + buf_len (buf) - 1;
222
buf_size_valid (const size_t size)
224
return likely (size < BUF_SIZE_MAX);
228
buf_size_valid_signed (const int size)
230
return likely (size >= -BUF_SIZE_MAX) && likely (size < BUF_SIZE_MAX);
234
buf_str (const struct buffer *buf)
236
return (char *)buf_bptr(buf);
240
buf_reset (struct buffer *buf)
249
buf_reset_len (struct buffer *buf)
256
buf_init_dowork (struct buffer *buf, int offset)
258
if (offset < 0 || offset > buf->capacity || buf->data == NULL)
261
buf->offset = offset;
266
buf_set_write (struct buffer *buf, uint8_t *data, int size)
268
if (!buf_size_valid (size))
269
buf_size_error (size);
272
buf->capacity = size;
274
if (size > 0 && data)
279
buf_set_read (struct buffer *buf, const uint8_t *data, int size)
281
if (!buf_size_valid (size))
282
buf_size_error (size);
283
buf->len = buf->capacity = size;
285
buf->data = (uint8_t *)data;
288
/* Like strncpy but makes sure dest is always null terminated */
290
strncpynt (char *dest, const char *src, size_t maxlen)
292
strncpy (dest, src, maxlen);
294
dest[maxlen - 1] = 0;
297
/* return true if string contains at least one numerical digit */
299
has_digit (const unsigned char* src)
311
* printf append to a buffer with overflow check
313
bool buf_printf (struct buffer *buf, const char *format, ...)
315
#if __USE_MINGW_ANSI_STDIO
316
__attribute__ ((format (gnu_printf, 2, 3)))
318
__attribute__ ((format (__printf__, 2, 3)))
324
* puts append to a buffer with overflow check
326
bool buf_puts (struct buffer *buf, const char *str);
329
* Like snprintf but guarantees null termination for size > 0
331
bool openvpn_snprintf(char *str, size_t size, const char *format, ...)
333
#if __USE_MINGW_ANSI_STDIO
334
__attribute__ ((format (gnu_printf, 3, 4)))
336
__attribute__ ((format (__printf__, 3, 4)))
342
* remove/add trailing characters
345
void buf_null_terminate (struct buffer *buf);
346
void buf_chomp (struct buffer *buf);
347
void buf_rmtail (struct buffer *buf, uint8_t remove);
350
* non-buffer string functions
352
void chomp (char *str);
353
void rm_trailing_chars (char *str, const char *what_to_delete);
354
const char *skip_leading_whitespace (const char *str);
355
void string_null_terminate (char *str, int len, int capacity);
358
* Write string in buf to file descriptor fd.
359
* NOTE: requires that string be null terminated.
361
void buf_write_string_file (const struct buffer *buf, const char *filename, int fd);
364
* write a string to the end of a buffer that was
365
* truncated by buf_printf
367
void buf_catrunc (struct buffer *buf, const char *str);
370
* convert a multi-line output to one line
372
void convert_to_one_line (struct buffer *buf);
375
* Parse a string based on a given delimiter char
377
bool buf_parse (struct buffer *buf, const int delim, char *line, const int size);
380
* Hex dump -- Output a binary buffer to a hex string and return it.
383
format_hex_ex (const uint8_t *data, int size, int maxoutput,
384
int space_break, const char* separator,
385
struct gc_arena *gc);
388
format_hex (const uint8_t *data, int size, int maxoutput, struct gc_arena *gc)
390
return format_hex_ex (data, size, maxoutput, 4, " ", gc);
394
* Return a buffer that is a subset of another buffer.
396
struct buffer buf_sub (struct buffer *buf, int size, bool prepend);
399
* Check if sufficient space to append to buffer.
403
buf_safe (const struct buffer *buf, int len)
405
return buf_valid (buf) && buf_size_valid (len)
406
&& buf->offset + buf->len + len <= buf->capacity;
410
buf_safe_bidir (const struct buffer *buf, int len)
412
if (buf_valid (buf) && buf_size_valid_signed (len))
414
const int newlen = buf->len + len;
415
return newlen >= 0 && buf->offset + newlen <= buf->capacity;
422
buf_forward_capacity (const struct buffer *buf)
426
int ret = buf->capacity - (buf->offset + buf->len);
436
buf_forward_capacity_total (const struct buffer *buf)
440
int ret = buf->capacity - buf->offset;
450
buf_reverse_capacity (const struct buffer *buf)
459
buf_inc_len (struct buffer *buf, int inc)
461
if (!buf_safe_bidir (buf, inc))
468
* Make space to prepend to a buffer.
469
* Return NULL if no space.
472
static inline uint8_t *
473
buf_prepend (struct buffer *buf, int size)
475
if (!buf_valid (buf) || size < 0 || size > buf->offset)
483
buf_advance (struct buffer *buf, int size)
485
if (!buf_valid (buf) || size < 0 || buf->len < size)
493
* Return a pointer to allocated space inside a buffer.
494
* Return NULL if no space.
497
static inline uint8_t *
498
buf_write_alloc (struct buffer *buf, int size)
501
if (!buf_safe (buf, size))
503
ret = BPTR (buf) + buf->len;
508
static inline uint8_t *
509
buf_write_alloc_prepend (struct buffer *buf, int size, bool prepend)
511
return prepend ? buf_prepend (buf, size) : buf_write_alloc (buf, size);
514
static inline uint8_t *
515
buf_read_alloc (struct buffer *buf, int size)
518
if (size < 0 || buf->len < size)
527
buf_write (struct buffer *dest, const void *src, int size)
529
uint8_t *cp = buf_write_alloc (dest, size);
532
memcpy (cp, src, size);
537
buf_write_prepend (struct buffer *dest, const void *src, int size)
539
uint8_t *cp = buf_prepend (dest, size);
542
memcpy (cp, src, size);
547
buf_write_u8 (struct buffer *dest, int data)
549
uint8_t u8 = (uint8_t) data;
550
return buf_write (dest, &u8, sizeof (uint8_t));
554
buf_write_u16 (struct buffer *dest, int data)
556
uint16_t u16 = htons ((uint16_t) data);
557
return buf_write (dest, &u16, sizeof (uint16_t));
561
buf_write_u32 (struct buffer *dest, int data)
563
uint32_t u32 = htonl ((uint32_t) data);
564
return buf_write (dest, &u32, sizeof (uint32_t));
568
buf_copy (struct buffer *dest, const struct buffer *src)
570
return buf_write (dest, BPTR (src), BLEN (src));
574
buf_copy_n (struct buffer *dest, struct buffer *src, int n)
576
uint8_t *cp = buf_read_alloc (src, n);
579
return buf_write (dest, cp, n);
583
buf_copy_range (struct buffer *dest,
585
const struct buffer *src,
591
|| src_index + src_len > src->len
593
|| dest->offset + dest_index + src_len > dest->capacity)
595
memcpy (dest->data + dest->offset + dest_index, src->data + src->offset + src_index, src_len);
596
if (dest_index + src_len > dest->len)
597
dest->len = dest_index + src_len;
601
/* truncate src to len, copy excess data beyond len to dest */
603
buf_copy_excess (struct buffer *dest,
611
struct buffer b = *src;
613
if (!buf_advance (&b, len))
615
return buf_copy (dest, &b);
624
buf_read (struct buffer *src, void *dest, int size)
626
uint8_t *cp = buf_read_alloc (src, size);
629
memcpy (dest, cp, size);
634
buf_read_u8 (struct buffer *buf)
640
buf_advance (buf, 1);
645
buf_read_u16 (struct buffer *buf)
648
if (!buf_read (buf, &ret, sizeof (uint16_t)))
653
static inline uint32_t
654
buf_read_u32 (struct buffer *buf, bool *good)
657
if (!buf_read (buf, &ret, sizeof (uint32_t)))
672
* Compare src buffer contents with match.
673
* *NOT* constant time. Do not use when comparing HMACs.
676
buf_string_match (const struct buffer *src, const void *match, int size)
678
if (size != src->len)
680
return memcmp (BPTR (src), match, size) == 0;
684
* Compare first size bytes of src buffer contents with match.
685
* *NOT* constant time. Do not use when comparing HMACs.
688
buf_string_match_head (const struct buffer *src, const void *match, int size)
690
if (size < 0 || size > src->len)
692
return memcmp (BPTR (src), match, size) == 0;
695
bool buf_string_match_head_str (const struct buffer *src, const char *match);
696
bool buf_string_compare_advance (struct buffer *src, const char *match);
697
int buf_substring_len (const struct buffer *buf, int delim);
700
* Print a string which might be NULL
702
const char *np (const char *str);
704
/*#define CHARACTER_CLASS_DEBUG*/
706
/* character classes */
708
#define CC_ANY (1<<0)
709
#define CC_NULL (1<<1)
711
#define CC_ALNUM (1<<2)
712
#define CC_ALPHA (1<<3)
713
#define CC_ASCII (1<<4)
714
#define CC_CNTRL (1<<5)
715
#define CC_DIGIT (1<<6)
716
#define CC_PRINT (1<<7)
717
#define CC_PUNCT (1<<8)
718
#define CC_SPACE (1<<9)
719
#define CC_XDIGIT (1<<10)
721
#define CC_BLANK (1<<11)
722
#define CC_NEWLINE (1<<12)
723
#define CC_CR (1<<13)
725
#define CC_BACKSLASH (1<<14)
726
#define CC_UNDERBAR (1<<15)
727
#define CC_DASH (1<<16)
728
#define CC_DOT (1<<17)
729
#define CC_COMMA (1<<18)
730
#define CC_COLON (1<<19)
731
#define CC_SLASH (1<<20)
732
#define CC_SINGLE_QUOTE (1<<21)
733
#define CC_DOUBLE_QUOTE (1<<22)
734
#define CC_REVERSE_QUOTE (1<<23)
735
#define CC_AT (1<<24)
736
#define CC_EQUAL (1<<25)
737
#define CC_LESS_THAN (1<<26)
738
#define CC_GREATER_THAN (1<<27)
739
#define CC_PIPE (1<<28)
740
#define CC_QUESTION_MARK (1<<29)
741
#define CC_ASTERISK (1<<30)
744
#define CC_NAME (CC_ALNUM|CC_UNDERBAR)
745
#define CC_CRLF (CC_CR|CC_NEWLINE)
747
bool char_class (const unsigned char c, const unsigned int flags);
748
bool string_class (const char *str, const unsigned int inclusive, const unsigned int exclusive);
749
bool string_mod (char *str, const unsigned int inclusive, const unsigned int exclusive, const char replace);
751
const char *string_mod_const (const char *str,
752
const unsigned int inclusive,
753
const unsigned int exclusive,
755
struct gc_arena *gc);
757
void string_replace_leading (char *str, const char match, const char replace);
759
#ifdef CHARACTER_CLASS_DEBUG
760
void character_class_debug (void);
764
* Verify that a pointer is correctly aligned
766
#ifdef VERIFY_ALIGNMENT
767
void valign4 (const struct buffer *buf, const char *file, const int line);
768
# define verify_align_4(ptr) valign4(buf, __FILE__, __LINE__)
770
# define verify_align_4(ptr)
774
* Very basic garbage collection, mostly for routines that return
775
* char ptrs to malloced strings.
778
void gc_transfer (struct gc_arena *dest, struct gc_arena *src);
780
void x_gc_free (struct gc_arena *a);
783
gc_defined (struct gc_arena *a)
785
return a->list != NULL;
789
gc_init (struct gc_arena *a)
795
gc_detach (struct gc_arena *a)
800
static inline struct gc_arena
809
gc_free (struct gc_arena *a)
816
gc_reset (struct gc_arena *a)
822
* Allocate memory to hold a structure
825
#define ALLOC_OBJ(dptr, type) \
827
check_malloc_return ((dptr) = (type *) malloc (sizeof (type))); \
830
#define ALLOC_OBJ_CLEAR(dptr, type) \
832
ALLOC_OBJ (dptr, type); \
833
memset ((dptr), 0, sizeof(type)); \
836
#define ALLOC_ARRAY(dptr, type, n) \
838
check_malloc_return ((dptr) = (type *) malloc (array_mult_safe (sizeof (type), (n), 0))); \
841
#define ALLOC_ARRAY_GC(dptr, type, n, gc) \
843
(dptr) = (type *) gc_malloc (array_mult_safe (sizeof (type), (n), 0), false, (gc)); \
846
#define ALLOC_ARRAY_CLEAR(dptr, type, n) \
848
ALLOC_ARRAY (dptr, type, n); \
849
memset ((dptr), 0, (array_mult_safe (sizeof(type), (n), 0))); \
852
#define ALLOC_ARRAY_CLEAR_GC(dptr, type, n, gc) \
854
(dptr) = (type *) gc_malloc (array_mult_safe (sizeof (type), (n), 0), true, (gc)); \
857
#define ALLOC_VAR_ARRAY_CLEAR_GC(dptr, type, atype, n, gc) \
859
(dptr) = (type *) gc_malloc (array_mult_safe (sizeof (atype), (n), sizeof (type)), true, (gc)); \
862
#define ALLOC_OBJ_GC(dptr, type, gc) \
864
(dptr) = (type *) gc_malloc (sizeof (type), false, (gc)); \
867
#define ALLOC_OBJ_CLEAR_GC(dptr, type, gc) \
869
(dptr) = (type *) gc_malloc (sizeof (type), true, (gc)); \
873
check_malloc_return (void *p)
880
* Manage lists of buffers
883
#ifdef ENABLE_BUFFER_LIST
888
struct buffer_entry *next;
893
struct buffer_entry *head; /* next item to pop/peek */
894
struct buffer_entry *tail; /* last item pushed */
895
int size; /* current number of entries */
896
int max_size; /* maximum size list should grow to */
899
struct buffer_list *buffer_list_new (const int max_size);
900
void buffer_list_free (struct buffer_list *ol);
902
bool buffer_list_defined (const struct buffer_list *ol);
903
void buffer_list_reset (struct buffer_list *ol);
905
void buffer_list_push (struct buffer_list *ol, const unsigned char *str);
906
struct buffer_entry *buffer_list_push_data (struct buffer_list *ol, const uint8_t *data, size_t size);
907
struct buffer *buffer_list_peek (struct buffer_list *ol);
908
void buffer_list_advance (struct buffer_list *ol, int n);
909
void buffer_list_pop (struct buffer_list *ol);
911
void buffer_list_aggregate (struct buffer_list *bl, const size_t max);
913
struct buffer_list *buffer_list_file (const char *fn, int max_line_len);
917
#endif /* BUFFER_H */
added
removed
src/openvpn/buffer.h
