lib/gnutls_str.h

   1 /*
   2  * Copyright (C) 2000-2012 Free Software Foundation, Inc.
   3  *
   4  * Author: Nikos Mavrogiannopoulos
   5  *
   6  * This file is part of GnuTLS.
   7  *
   8  * The GnuTLS is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 3 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  20  *
  21  */
  22
  23 #ifndef GNUTLS_STR_H
  24 #define GNUTLS_STR_H
  25
  26 #include <gnutls_int.h>
  27 #include <gnutls_datum.h>
  28
  29 void _gnutls_str_cpy (char *dest, size_t dest_tot_size, const char *src);
  30 void _gnutls_mem_cpy (char *dest, size_t dest_tot_size, const char *src,
  31                       size_t src_size);
  32 void _gnutls_str_cat (char *dest, size_t dest_tot_size, const char *src);
  33
  34 typedef struct
  35 {
  36   uint8_t *allocd;               /* pointer to allocated data */
  37   uint8_t *data;                 /* API: pointer to data to copy from */
  38   size_t max_length;
  39   size_t length;                /* API: current length */
  40 } gnutls_buffer_st;
  41
  42 /* Initialize a buffer */
  43 void _gnutls_buffer_init (gnutls_buffer_st *);
  44
  45 /* Free the data in a buffer */
  46 void _gnutls_buffer_clear (gnutls_buffer_st *);
  47
  48 /* Set the buffer data to be of zero length */
  49 inline static void _gnutls_buffer_reset (gnutls_buffer_st * buf)
  50 {
  51   buf->data = buf->allocd;
  52   buf->length = 0;
  53 }
  54
  55 int _gnutls_buffer_resize (gnutls_buffer_st *, size_t new_size);
  56
  57 int _gnutls_buffer_append_str (gnutls_buffer_st *, const char *str);
  58 int _gnutls_buffer_append_data (gnutls_buffer_st *, const void *data,
  59                                 size_t data_size);
  60
  61 #include <gnutls_num.h>
  62
  63 void _gnutls_buffer_replace_data( gnutls_buffer_st * buf, gnutls_datum_t * data);
  64
  65 int _gnutls_buffer_append_prefix (gnutls_buffer_st * buf, int pfx_size, size_t data_size);
  66
  67 int _gnutls_buffer_append_mpi (gnutls_buffer_st * buf, int pfx_size, bigint_t, int lz);
  68
  69 int _gnutls_buffer_append_data_prefix (gnutls_buffer_st * buf, int pfx_size,
  70                                        const void *data, size_t data_size);
  71 void _gnutls_buffer_pop_data (gnutls_buffer_st *, void *, size_t * size);
  72 void _gnutls_buffer_pop_datum (gnutls_buffer_st *, gnutls_datum_t *,
  73                                size_t max_size);
  74
  75 int _gnutls_buffer_pop_prefix (gnutls_buffer_st * buf, size_t * data_size,
  76                                int check);
  77
  78 int _gnutls_buffer_pop_data_prefix (gnutls_buffer_st * buf, void *data,
  79                                     size_t * data_size);
  80
  81 int _gnutls_buffer_pop_datum_prefix (gnutls_buffer_st * buf,
  82                                      gnutls_datum_t * data);
  83 int _gnutls_buffer_to_datum (gnutls_buffer_st * str, gnutls_datum_t * data);
  84
  85 int _gnutls_buffer_escape (gnutls_buffer_st * dest, int all,
  86                            const char *const invalid_chars);
  87 int _gnutls_buffer_unescape (gnutls_buffer_st * dest);
  88
  89 #ifndef __attribute__
  90 /* This feature is available in gcc versions 2.5 and later.  */
  91 #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5)
  92 #define __attribute__(Spec)     /* empty */
  93 #endif
  94 #endif
  95
  96 int _gnutls_buffer_append_printf (gnutls_buffer_st * dest, const char *fmt,
  97                                   ...)
  98   __attribute__ ((format (printf, 2, 3)));
  99
 100 void _gnutls_buffer_hexprint (gnutls_buffer_st * str,
 101                               const void *data, size_t len);
 102 void _gnutls_buffer_hexdump (gnutls_buffer_st * str, const void *data,
 103                              size_t len, const char *spc);
 104 void _gnutls_buffer_asciiprint (gnutls_buffer_st * str,
 105                                 const char *data, size_t len);
 106
 107 char *_gnutls_bin2hex (const void *old, size_t oldlen, char *buffer,
 108                        size_t buffer_size, const char *separator);
 109 int _gnutls_hex2bin (const char * hex_data, size_t hex_size, uint8_t * bin_data,
 110                      size_t * bin_size);
 111
 112 int _gnutls_hostname_compare (const char *certname, size_t certnamesize,
 113                               const char *hostname, int level);
 114
 115 #define MAX_CN 256
 116 #define MAX_DN 1024
 117
 118 #define BUFFER_APPEND(b, x, s) { \
 119         ret = _gnutls_buffer_append_data(b, x, s); \
 120         if (ret < 0) { \
 121             gnutls_assert(); \
 122             return ret; \
 123         } \
 124     }
 125
 126 /* append data prefixed with 4-bytes length field*/
 127 #define BUFFER_APPEND_PFX4(b, x, s) { \
 128         ret = _gnutls_buffer_append_data_prefix(b, 32, x, s); \
 129         if (ret < 0) { \
 130             gnutls_assert(); \
 131             return ret; \
 132         } \
 133     }
 134
 135 #define BUFFER_APPEND_PFX3(b, x, s) { \
 136         ret = _gnutls_buffer_append_data_prefix(b, 24, x, s); \
 137         if (ret < 0) { \
 138             gnutls_assert(); \
 139             return ret; \
 140         } \
 141     }
 142
 143 #define BUFFER_APPEND_PFX2(b, x, s) { \
 144         ret = _gnutls_buffer_append_data_prefix(b, 16, x, s); \
 145         if (ret < 0) { \
 146             gnutls_assert(); \
 147             return ret; \
 148         } \
 149     }
 150
 151 #define BUFFER_APPEND_PFX1(b, x, s) { \
 152         ret = _gnutls_buffer_append_data_prefix(b, 8, x, s); \
 153         if (ret < 0) { \
 154             gnutls_assert(); \
 155             return ret; \
 156         } \
 157     }
 158
 159 #define BUFFER_APPEND_NUM(b, s) { \
 160         ret = _gnutls_buffer_append_prefix(b, 32, s); \
 161         if (ret < 0) { \
 162             gnutls_assert(); \
 163             return ret; \
 164         } \
 165     }
 166
 167 #define BUFFER_POP(b, x, s) { \
 168         size_t is = s; \
 169         _gnutls_buffer_pop_data(b, x, &is); \
 170         if (is != s) { \
 171             ret = GNUTLS_E_PARSING_ERROR; \
 172             gnutls_assert(); \
 173             goto error; \
 174         } \
 175     }
 176
 177 #define BUFFER_POP_DATUM(b, o) { \
 178         gnutls_datum_t d; \
 179         ret = _gnutls_buffer_pop_datum_prefix(b, &d); \
 180         if (ret >= 0) \
 181             ret = _gnutls_set_datum (o, d.data, d.size); \
 182         if (ret < 0) { \
 183             gnutls_assert(); \
 184             goto error; \
 185         } \
 186     }
 187
 188 #define BUFFER_POP_NUM(b, o) { \
 189         size_t s; \
 190         ret = _gnutls_buffer_pop_prefix(b, &s, 0); \
 191         if (ret < 0) { \
 192             gnutls_assert(); \
 193             goto error; \
 194         } \
 195         o = s; \
 196     }
 197
 198 #endif