having two named for the same thing.
gnutls_session_t session, opaque * data,
size_t length)
{
- gnutls_buffer *buf;
+ gnutls_buffer_st *buf;
if (length == 0)
return 0;
return GNUTLS_E_INVALID_REQUEST;
}
- if (_gnutls_buffer_append (buf, data, length) < 0)
+ if (_gnutls_buffer_append_data (buf, data, length) < 0)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
gnutls_assert ();
tmp = sizeOfPtr;
- _gnutls_string_get_data (&session->internals.handshake_recv_buffer,
+ _gnutls_buffer_get_data (&session->internals.handshake_recv_buffer,
iptr, &tmp);
return tmp;
}
gnutls_assert ();
tmp = sizeOfPtr;
- _gnutls_string_get_data (&session->internals.handshake_recv_buffer,
+ _gnutls_buffer_get_data (&session->internals.handshake_recv_buffer,
iptr, &tmp);
left -= tmp;
{
gnutls_assert ();
- _gnutls_buffer_append (&session->internals.
+ _gnutls_buffer_append_data (&session->internals.
handshake_recv_buffer, iptr, dsize);
session->internals.handshake_recv_buffer_htype = htype;
}
_gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data\n", (int) length);
- if (_gnutls_buffer_append (&session->internals.handshake_hash_buffer,
+ if (_gnutls_buffer_append_data (&session->internals.handshake_hash_buffer,
data, length) < 0)
{
gnutls_assert ();
ret = _gnutls_send_handshake (session, NULL, GNUTLS_HANDSHAKE_SUPPLEMENTAL);
else
{
- gnutls_buffer buf;
+ gnutls_buffer_st buf;
_gnutls_buffer_init (&buf);
ret = _gnutls_gen_supplemental (session, &buf);
typedef struct
{
- gnutls_buffer application_data_buffer; /* holds data to be delivered to application layer */
- gnutls_buffer handshake_hash_buffer; /* used to keep the last received handshake
+ gnutls_buffer_st application_data_buffer; /* holds data to be delivered to application layer */
+ gnutls_buffer_st handshake_hash_buffer; /* used to keep the last received handshake
* message */
union
{
} handshake_mac_handle;
int handshake_mac_handle_init; /* 1 when the previous union and type were initialized */
- gnutls_buffer handshake_data_buffer; /* this is a buffer that holds the current handshake message */
- gnutls_buffer ia_data_buffer; /* holds inner application data (TLS/IA) */
+ gnutls_buffer_st handshake_data_buffer; /* this is a buffer that holds the current handshake message */
+ gnutls_buffer_st ia_data_buffer; /* holds inner application data (TLS/IA) */
resumable_session_t resumable; /* TRUE or FALSE - if we can resume that session */
handshake_state_t handshake_state; /* holds
* a number which indicates where
gnutls_handshake_description_t handshake_send_buffer_htype;
content_type_t handshake_recv_buffer_type;
gnutls_handshake_description_t handshake_recv_buffer_htype;
- gnutls_buffer handshake_recv_buffer;
+ gnutls_buffer_st handshake_recv_buffer;
/* this buffer holds a record packet -mostly used for
* non blocking IO.
*/
- gnutls_buffer record_recv_buffer;
+ gnutls_buffer_st record_recv_buffer;
mbuffer_head_st record_send_buffer; /* holds cached data
* for the gnutls_io_write_buffered()
* function.
}
void
-_gnutls_string_init (gnutls_string * str,
- gnutls_alloc_function alloc_func,
- gnutls_realloc_function realloc_func,
- gnutls_free_function free_func)
+_gnutls_buffer_init (gnutls_buffer_st * str)
{
str->data = str->allocd = NULL;
str->max_length = 0;
str->length = 0;
-
- str->alloc_func = alloc_func;
- str->free_func = free_func;
- str->realloc_func = realloc_func;
}
void
-_gnutls_string_clear (gnutls_string * str)
+_gnutls_buffer_clear (gnutls_buffer_st * str)
{
if (str == NULL || str->allocd == NULL)
return;
- str->free_func (str->allocd);
+ gnutls_free (str->allocd);
str->data = str->allocd = NULL;
str->max_length = 0;
#define MIN_CHUNK 256
int
-_gnutls_string_append_data (gnutls_string * dest, const void *data,
+_gnutls_buffer_append_data (gnutls_buffer_st * dest, const void *data,
size_t data_size)
{
size_t tot_len = data_size + dest->length;
size_t new_len =
MAX (data_size, MIN_CHUNK) + MAX (dest->max_length, MIN_CHUNK);
- dest->allocd = dest->realloc_func (dest->allocd, new_len);
+ dest->allocd = gnutls_realloc (dest->allocd, new_len);
if (dest->allocd == NULL)
{
gnutls_assert ();
}
int
-_gnutls_string_resize (gnutls_string * dest, size_t new_size)
+_gnutls_buffer_resize (gnutls_buffer_st * dest, size_t new_size)
{
if (dest->max_length >= new_size)
{
size_t alloc_len =
MAX (new_size, MIN_CHUNK) + MAX (dest->max_length, MIN_CHUNK);
- dest->allocd = dest->realloc_func (dest->allocd, alloc_len);
+ dest->allocd = gnutls_realloc (dest->allocd, alloc_len);
if (dest->allocd == NULL)
{
gnutls_assert ();
}
int
-_gnutls_string_append_str (gnutls_string * dest, const char *src)
+_gnutls_buffer_append_str (gnutls_buffer_st * dest, const char *src)
{
- return _gnutls_string_append_data (dest, src, strlen (src));
+ return _gnutls_buffer_append_data (dest, src, strlen (src));
}
/* returns data from a string in a constant buffer.
* data are appended in the buffer.
*/
void
-_gnutls_string_get_datum (gnutls_string * str, gnutls_datum_t * data,
+_gnutls_buffer_get_datum (gnutls_buffer_st * str, gnutls_datum_t * data,
size_t req_size)
{
/* returns data from a string in a constant buffer.
*/
void
-_gnutls_string_get_data (gnutls_string * str, void *data, size_t * req_size)
+_gnutls_buffer_get_data (gnutls_buffer_st * str, void *data, size_t * req_size)
{
gnutls_datum_t tdata;
- _gnutls_string_get_datum (str, &tdata, *req_size);
+ _gnutls_buffer_get_datum (str, &tdata, *req_size);
*req_size = tdata.size;
memcpy (data, tdata.data, tdata.size);
}
int
-_gnutls_string_append_printf (gnutls_string * dest, const char *fmt, ...)
+_gnutls_buffer_append_printf (gnutls_buffer_st * dest, const char *fmt, ...)
{
va_list args;
int len;
if (len < 0 || !str)
return -1;
- len = _gnutls_string_append_str (dest, str);
+ len = _gnutls_buffer_append_str (dest, str);
free (str);
return len;
}
-static int _gnutls_string_insert_data(gnutls_string * dest, int pos, const void* str, size_t str_size)
+static int _gnutls_buffer_insert_data(gnutls_buffer_st * dest, int pos, const void* str, size_t str_size)
{
size_t orig_length = dest->length;
int ret;
- ret = _gnutls_string_resize(dest, dest->length+str_size); /* resize to make space */
+ ret = _gnutls_buffer_resize(dest, dest->length+str_size); /* resize to make space */
if (ret < 0)
return ret;
return 0;
}
-static void _gnutls_string_delete_data(gnutls_string * dest, int pos, size_t str_size)
+static void _gnutls_buffer_delete_data(gnutls_buffer_st * dest, int pos, size_t str_size)
{
memmove(&dest->data[pos], &dest->data[pos+str_size], dest->length-pos-str_size);
}
-int _gnutls_string_escape(gnutls_string * dest, const char *const invalid_chars)
+int _gnutls_buffer_escape(gnutls_buffer_st * dest, const char *const invalid_chars)
{
static const char *x = "0123456789ABCDEF";
int rv = -1;
t[1] = x[(dest->data[pos] & 0xf0) >> 4];
t[2] = x[(dest->data[pos] & 0x0f) >> 0];
- _gnutls_string_delete_data(dest, pos, 1);
+ _gnutls_buffer_delete_data(dest, pos, 1);
- if (_gnutls_string_insert_data(dest, pos, t, 3) < 0) {
+ if (_gnutls_buffer_insert_data(dest, pos, t, 3) < 0) {
rv = -1;
goto cleanup;
}
return rv;
}
-int _gnutls_string_unescape(gnutls_string * dest)
+int _gnutls_buffer_unescape(gnutls_buffer_st * dest)
{
int rv = -1;
int pos = 0;
sscanf(b, "%08x", &u);
x = u & 0xff;
- _gnutls_string_delete_data(dest, pos, 3);
- _gnutls_string_insert_data(dest, pos, &x, 1);
+ _gnutls_buffer_delete_data(dest, pos, 3);
+ _gnutls_buffer_insert_data(dest, pos, &x, 1);
}
pos++;
}
opaque *data; /* API: pointer to data to copy from */
size_t max_length;
size_t length; /* API: current length */
- gnutls_realloc_function realloc_func;
- gnutls_alloc_function alloc_func;
- gnutls_free_function free_func;
-} gnutls_string;
+} gnutls_buffer_st;
-void _gnutls_string_init (gnutls_string *, gnutls_alloc_function,
- gnutls_realloc_function, gnutls_free_function);
-void _gnutls_string_clear (gnutls_string *);
-int _gnutls_string_resize (gnutls_string *, size_t new_size);
+void _gnutls_buffer_init (gnutls_buffer_st *);
+void _gnutls_buffer_clear (gnutls_buffer_st *);
+int _gnutls_buffer_resize (gnutls_buffer_st *, size_t new_size);
-int _gnutls_string_append_str (gnutls_string *, const char *str);
-int _gnutls_string_append_data (gnutls_string *, const void *data,
+int _gnutls_buffer_append_str (gnutls_buffer_st *, const char *str);
+int _gnutls_buffer_append_data (gnutls_buffer_st *, const void *data,
size_t data_size);
-void _gnutls_string_get_data (gnutls_string *, void *, size_t * size);
-void _gnutls_string_get_datum (gnutls_string *, gnutls_datum_t *,
+void _gnutls_buffer_get_data (gnutls_buffer_st *, void *, size_t * size);
+void _gnutls_buffer_get_datum (gnutls_buffer_st *, gnutls_datum_t *,
size_t max_size);
-int _gnutls_string_escape(gnutls_string * dest, const char *const invalid_chars);
-int _gnutls_string_unescape(gnutls_string * dest);
+int _gnutls_buffer_escape(gnutls_buffer_st * dest, const char *const invalid_chars);
+int _gnutls_buffer_unescape(gnutls_buffer_st * dest);
#ifndef __attribute__
/* This feature is available in gcc versions 2.5 and later. */
# endif
#endif
-int _gnutls_string_append_printf (gnutls_string * dest, const char *fmt, ...)
+int _gnutls_buffer_append_printf (gnutls_buffer_st * dest, const char *fmt, ...)
__attribute__ ((format (printf, 2, 3)));
-typedef gnutls_string gnutls_buffer;
-
-#define _gnutls_buffer_init(buf) _gnutls_string_init(buf, gnutls_malloc, gnutls_realloc, gnutls_free);
-#define _gnutls_buffer_clear _gnutls_string_clear
-#define _gnutls_buffer_append _gnutls_string_append_data
-#define _gnutls_buffer_get_datum _gnutls_string_get_datum
-#define _gnutls_buffer_get_data _gnutls_string_get_data
-#define _gnutls_buffer_resize _gnutls_string_resize
-
char *_gnutls_bin2hex (const void *old, size_t oldlen, char *buffer,
size_t buffer_size, const char* separator);
int _gnutls_hex2bin (const opaque * hex_data, int hex_size, opaque * bin_data,
typedef int (*supp_recv_func) (gnutls_session_t session,
const opaque * data, size_t data_size);
-typedef int (*supp_send_func) (gnutls_session_t session, gnutls_buffer * buf);
+typedef int (*supp_send_func) (gnutls_session_t session, gnutls_buffer_st * buf);
typedef struct
{
}
int
-_gnutls_gen_supplemental (gnutls_session_t session, gnutls_buffer * buf)
+_gnutls_gen_supplemental (gnutls_session_t session, gnutls_buffer_st * buf)
{
gnutls_supplemental_entry *p;
int ret;
/* Make room for 3 byte length field. */
- ret = _gnutls_buffer_append (buf, "\0\0\0", 3);
+ ret = _gnutls_buffer_append_data (buf, "\0\0\0", 3);
if (ret < 0)
{
gnutls_assert ();
size_t sizepos = buf->length;
/* Make room for supplement type and length byte length field. */
- ret = _gnutls_buffer_append (buf, "\0\0\0\0", 4);
+ ret = _gnutls_buffer_append_data (buf, "\0\0\0\0", 4);
if (ret < 0)
{
gnutls_assert ();
int _gnutls_parse_supplemental (gnutls_session_t session,
const uint8_t * data, int data_size);
-int _gnutls_gen_supplemental (gnutls_session_t session, gnutls_buffer * buf);
+int _gnutls_gen_supplemental (gnutls_session_t session, gnutls_buffer_st * buf);
#include "gettext.h"
#define _(String) dgettext (PACKAGE, String)
-#define addf _gnutls_string_append_printf
-#define adds _gnutls_string_append_str
+#define addf _gnutls_buffer_append_printf
+#define adds _gnutls_buffer_append_str
static void
-hexdump (gnutls_string * str, const char *data, size_t len, const char *spc)
+hexdump (gnutls_buffer_st * str, const char *data, size_t len, const char *spc)
{
size_t j;
}
static void
-hexprint (gnutls_string * str, const char *data, size_t len)
+hexprint (gnutls_buffer_st * str, const char *data, size_t len)
{
size_t j;
}
static void
-print_key_usage (gnutls_string * str, gnutls_openpgp_crt_t cert,
+print_key_usage (gnutls_buffer_st * str, gnutls_openpgp_crt_t cert,
unsigned int idx)
{
unsigned int key_usage;
* otherwise the subkey.
*/
static void
-print_key_id (gnutls_string * str, gnutls_openpgp_crt_t cert, int idx)
+print_key_id (gnutls_buffer_st * str, gnutls_openpgp_crt_t cert, int idx)
{
gnutls_openpgp_keyid_t id;
int err;
* otherwise the subkey.
*/
static void
-print_key_fingerprint (gnutls_string * str, gnutls_openpgp_crt_t cert)
+print_key_fingerprint (gnutls_buffer_st * str, gnutls_openpgp_crt_t cert)
{
char fpr[128];
size_t fpr_size = sizeof (fpr);
}
static void
-print_key_revoked (gnutls_string * str, gnutls_openpgp_crt_t cert, int idx)
+print_key_revoked (gnutls_buffer_st * str, gnutls_openpgp_crt_t cert, int idx)
{
int err;
}
static void
-print_key_times (gnutls_string * str, gnutls_openpgp_crt_t cert, int idx)
+print_key_times (gnutls_buffer_st * str, gnutls_openpgp_crt_t cert, int idx)
{
time_t tim;
}
static void
-print_key_info (gnutls_string * str, gnutls_openpgp_crt_t cert, int idx)
+print_key_info (gnutls_buffer_st * str, gnutls_openpgp_crt_t cert, int idx)
{
int err;
unsigned int bits;
}
static void
-print_cert (gnutls_string * str, gnutls_openpgp_crt_t cert)
+print_cert (gnutls_buffer_st * str, gnutls_openpgp_crt_t cert)
{
int i, subkeys;
int err;
}
static void
-print_oneline (gnutls_string * str, gnutls_openpgp_crt_t cert)
+print_oneline (gnutls_buffer_st * str, gnutls_openpgp_crt_t cert)
{
int err, i;
gnutls_certificate_print_formats_t format,
gnutls_datum_t * out)
{
- gnutls_string str;
+ gnutls_buffer_st str;
- _gnutls_string_init (&str, gnutls_malloc, gnutls_realloc, gnutls_free);
+ _gnutls_buffer_init (&str);
if (format == GNUTLS_CRT_PRINT_ONELINE)
print_oneline (&str, cert);
else
{
- _gnutls_string_append_str (&str,
+ _gnutls_buffer_append_str (&str,
_("OpenPGP Certificate Information:\n"));
print_cert (&str, cert);
}
- _gnutls_string_append_data (&str, "\0", 1);
+ _gnutls_buffer_append_data (&str, "\0", 1);
out->data = str.data;
out->size = strlen (str.data);
static int unescape_string (char* output, const char* input, size_t* size, char terminator)
{
- gnutls_string str;
+ gnutls_buffer_st str;
int ret = 0;
char* p;
int len;
- _gnutls_string_init(&str, gnutls_malloc, gnutls_realloc, gnutls_free);
+ _gnutls_buffer_init(&str);
/* find terminator */
p = strchr(input, terminator);
else
len = strlen(input);
- ret = _gnutls_string_append_data(&str, input, len);
+ ret = _gnutls_buffer_append_data(&str, input, len);
if (ret < 0) {
gnutls_assert();
return ret;
}
- ret = _gnutls_string_unescape(&str);
+ ret = _gnutls_buffer_unescape(&str);
if (ret < 0) {
gnutls_assert();
return ret;
}
- ret = _gnutls_string_append_data(&str, "", 1);
+ ret = _gnutls_buffer_append_data(&str, "", 1);
if (ret < 0) {
gnutls_assert();
return ret;
}
- _gnutls_string_get_data(&str, output, size);
+ _gnutls_buffer_get_data(&str, output, size);
- _gnutls_string_clear(&str);
+ _gnutls_buffer_clear(&str);
return ret;
}
#define INVALID_CHARS "\\/\"'%&#@!?$* <>{}[]()`|:;,.+-"
-static int append(gnutls_string* dest, const char* tname, const char* p11name, int init)
+static int append(gnutls_buffer_st* dest, const char* tname, const char* p11name, int init)
{
- gnutls_string tmpstr;
+ gnutls_buffer_st tmpstr;
int ret;
- _gnutls_string_init(&tmpstr, gnutls_malloc, gnutls_realloc, gnutls_free);
- if ((ret=_gnutls_string_append_str(&tmpstr, tname))<0) {
+ _gnutls_buffer_init(&tmpstr);
+ if ((ret=_gnutls_buffer_append_str(&tmpstr, tname))<0) {
gnutls_assert();
goto cleanup;
}
- ret = _gnutls_string_escape(&tmpstr, INVALID_CHARS);
+ ret = _gnutls_buffer_escape(&tmpstr, INVALID_CHARS);
if (ret < 0) {
gnutls_assert();
goto cleanup;
}
- if ((ret=_gnutls_string_append_data(&tmpstr, "", 1)) < 0) {
+ if ((ret=_gnutls_buffer_append_data(&tmpstr, "", 1)) < 0) {
gnutls_assert();
goto cleanup;
}
- if ((ret=_gnutls_string_append_printf(dest, "%s%s=%s", (init!=0)?";":"", p11name, tmpstr.data)) < 0) {
+ if ((ret=_gnutls_buffer_append_printf(dest, "%s%s=%s", (init!=0)?";":"", p11name, tmpstr.data)) < 0) {
gnutls_assert();
goto cleanup;
}
ret = 0;
cleanup:
- _gnutls_string_clear(&tmpstr);
+ _gnutls_buffer_clear(&tmpstr);
return ret;
int pkcs11_info_to_url(const struct pkcs11_url_info* info, char** url)
{
- gnutls_string str;
+ gnutls_buffer_st str;
int init = 0;
int ret;
- _gnutls_string_init (&str, gnutls_malloc, gnutls_realloc, gnutls_free);
+ _gnutls_buffer_init (&str);
- _gnutls_string_append_str(&str, "pkcs11:");
+ _gnutls_buffer_append_str(&str, "pkcs11:");
if (info->token[0]) {
ret = append(&str, info->token, "token", init);
}
if (info->id[0] != 0) {
- ret = _gnutls_string_append_printf(&str, ";id=%s", info->id);
+ ret = _gnutls_buffer_append_printf(&str, ";id=%s", info->id);
if (ret < 0) {
gnutls_assert();
return ret;
}
}
- _gnutls_string_append_data(&str, "", 1);
+ _gnutls_buffer_append_data(&str, "", 1);
*url = str.data;
return 0;
cleanup:
- _gnutls_string_clear(&str);
+ _gnutls_buffer_clear(&str);
return ret;
}
}
struct pkey_list {
- gnutls_string *key_ids;
+ gnutls_buffer_st *key_ids;
size_t key_ids_size;
};
return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
}
- list->key_ids = gnutls_malloc(sizeof(gnutls_string)*list->key_ids_size);
+ list->key_ids = gnutls_malloc(sizeof(gnutls_buffer_st)*list->key_ids_size);
if (list->key_ids == NULL) {
gnutls_assert();
return GNUTLS_E_MEMORY_ERROR;
a[0].value = certid_tmp;
a[0].value_len = sizeof(certid_tmp);
- _gnutls_string_init(&list->key_ids[current], gnutls_malloc, gnutls_realloc, gnutls_free);
+ _gnutls_buffer_init(&list->key_ids[current]);
if (pakchois_get_attribute_value(pks, obj, a, 1) == CKR_OK) {
- _gnutls_string_append_data(&list->key_ids[current], a[0].value, a[0].value_len);
+ _gnutls_buffer_append_data(&list->key_ids[current], a[0].value, a[0].value_len);
current++;
}
pakchois_find_objects_final(pks);
if (plist.key_ids != NULL) {
for (i=0;i<plist.key_ids_size;i++) {
- _gnutls_string_clear(&plist.key_ids[i]);
+ _gnutls_buffer_clear(&plist.key_ids[i]);
}
gnutls_free( plist.key_ids);
}
const char *asn1_rdn_name, char *buf,
size_t * sizeof_buf)
{
- gnutls_string out_str;
+ gnutls_buffer_st out_str;
int k2, k1, result;
char tmpbuffer1[ASN1_MAX_NAME_SIZE];
char tmpbuffer2[ASN1_MAX_NAME_SIZE];
else
*sizeof_buf = 0;
- _gnutls_string_init (&out_str, gnutls_malloc, gnutls_realloc, gnutls_free);
+ _gnutls_buffer_init (&out_str);
k1 = 0;
do
result = _gnutls_asn2err (result);
goto cleanup;
}
-#define STR_APPEND(y) if ((result=_gnutls_string_append_str( &out_str, y)) < 0) { \
+#define STR_APPEND(y) if ((result=_gnutls_buffer_append_str( &out_str, y)) < 0) { \
gnutls_assert(); \
goto cleanup; \
}
if (buf)
{
- _gnutls_string_get_data (&out_str, buf, sizeof_buf);
+ _gnutls_buffer_get_data (&out_str, buf, sizeof_buf);
buf[*sizeof_buf] = 0;
}
else
gnutls_free (value2);
gnutls_free (string);
gnutls_free (escaped);
- _gnutls_string_clear (&out_str);
+ _gnutls_buffer_clear (&out_str);
return result;
}
#include "gettext.h"
#define _(String) dgettext (PACKAGE, String)
-#define addf _gnutls_string_append_printf
-#define adds _gnutls_string_append_str
+#define addf _gnutls_buffer_append_printf
+#define adds _gnutls_buffer_append_str
#define ERROR_STR (char*) "(error)"
static void
-hexdump (gnutls_string * str, const char *data, size_t len, const char *spc)
+hexdump (gnutls_buffer_st * str, const char *data, size_t len, const char *spc)
{
size_t j;
}
static void
-hexprint (gnutls_string * str, const char *data, size_t len)
+hexprint (gnutls_buffer_st * str, const char *data, size_t len)
{
size_t j;
static void
-asciiprint (gnutls_string * str, const char *data, size_t len)
+asciiprint (gnutls_buffer_st * str, const char *data, size_t len)
{
size_t j;
}
static void
-print_proxy (gnutls_string * str, gnutls_x509_crt_t cert)
+print_proxy (gnutls_buffer_st * str, gnutls_x509_crt_t cert)
{
int pathlen;
char *policyLanguage;
}
static void
-print_ski (gnutls_string * str, gnutls_x509_crt_t cert)
+print_ski (gnutls_buffer_st * str, gnutls_x509_crt_t cert)
{
char *buffer = NULL;
size_t size = 0;
} cert_type_t;
static void
-print_aki (gnutls_string * str, int type, cert_type_t cert)
+print_aki (gnutls_buffer_st * str, int type, cert_type_t cert)
{
char *buffer = NULL;
size_t size = 0;
}
static void
-print_key_usage (gnutls_string * str, const char *prefix, int type,
+print_key_usage (gnutls_buffer_st * str, const char *prefix, int type,
cert_type_t cert)
{
unsigned int key_usage;
#ifdef ENABLE_PKI
static void
-print_crldist (gnutls_string * str, gnutls_x509_crt_t cert)
+print_crldist (gnutls_buffer_st * str, gnutls_x509_crt_t cert)
{
char *buffer = NULL;
size_t size;
}
static void
-print_key_purpose (gnutls_string * str, const char *prefix, int type,
+print_key_purpose (gnutls_buffer_st * str, const char *prefix, int type,
cert_type_t cert)
{
int indx;
#endif
static void
-print_basic (gnutls_string * str, const char *prefix, int type,
+print_basic (gnutls_buffer_st * str, const char *prefix, int type,
cert_type_t cert)
{
int pathlen;
static void
-print_altname (gnutls_string * str, const char *prefix, int altname_type,
+print_altname (gnutls_buffer_st * str, const char *prefix, int altname_type,
cert_type_t cert)
{
unsigned int altname_idx;
}
static void
-print_extensions (gnutls_string * str, const char *prefix, int type,
+print_extensions (gnutls_buffer_st * str, const char *prefix, int type,
cert_type_t cert)
{
int i, err;
}
static void
-print_cert (gnutls_string * str, gnutls_x509_crt_t cert, int notsigned)
+print_cert (gnutls_buffer_st * str, gnutls_x509_crt_t cert, int notsigned)
{
/* Version. */
{
}
static void
-print_fingerprint (gnutls_string * str, gnutls_x509_crt_t cert,
+print_fingerprint (gnutls_buffer_st * str, gnutls_x509_crt_t cert,
gnutls_digest_algorithm_t algo)
{
int err;
}
static void
-print_keyid (gnutls_string * str, gnutls_x509_crt_t cert)
+print_keyid (gnutls_buffer_st * str, gnutls_x509_crt_t cert)
{
int err;
char buffer[20];
}
static void
-print_other (gnutls_string * str, gnutls_x509_crt_t cert, int notsigned)
+print_other (gnutls_buffer_st * str, gnutls_x509_crt_t cert, int notsigned)
{
if (!notsigned)
{
}
static void
-print_oneline (gnutls_string * str, gnutls_x509_crt_t cert)
+print_oneline (gnutls_buffer_st * str, gnutls_x509_crt_t cert)
{
/* Subject. */
{
gnutls_certificate_print_formats_t format,
gnutls_datum_t * out)
{
- gnutls_string str;
+ gnutls_buffer_st str;
if (format == GNUTLS_CRT_PRINT_FULL
|| format == GNUTLS_CRT_PRINT_UNSIGNED_FULL)
{
- _gnutls_string_init (&str, gnutls_malloc, gnutls_realloc, gnutls_free);
+ _gnutls_buffer_init (&str);
- _gnutls_string_append_str (&str, _("X.509 Certificate Information:\n"));
+ _gnutls_buffer_append_str (&str, _("X.509 Certificate Information:\n"));
print_cert (&str, cert, format == GNUTLS_CRT_PRINT_UNSIGNED_FULL);
- _gnutls_string_append_str (&str, _("Other Information:\n"));
+ _gnutls_buffer_append_str (&str, _("Other Information:\n"));
print_other (&str, cert, format == GNUTLS_CRT_PRINT_UNSIGNED_FULL);
- _gnutls_string_append_data (&str, "\0", 1);
+ _gnutls_buffer_append_data (&str, "\0", 1);
out->data = str.data;
out->size = strlen (str.data);
}
else if (format == GNUTLS_CRT_PRINT_ONELINE)
{
- _gnutls_string_init (&str, gnutls_malloc, gnutls_realloc, gnutls_free);
+ _gnutls_buffer_init (&str);
print_oneline (&str, cert);
- _gnutls_string_append_data (&str, "\0", 1);
+ _gnutls_buffer_append_data (&str, "\0", 1);
out->data = str.data;
out->size = strlen (str.data);
}
#ifdef ENABLE_PKI
static void
-print_crl (gnutls_string * str, gnutls_x509_crl_t crl, int notsigned)
+print_crl (gnutls_buffer_st * str, gnutls_x509_crl_t crl, int notsigned)
{
/* Version. */
{
gnutls_certificate_print_formats_t format,
gnutls_datum_t * out)
{
- gnutls_string str;
+ gnutls_buffer_st str;
- _gnutls_string_init (&str, gnutls_malloc, gnutls_realloc, gnutls_free);
+ _gnutls_buffer_init (&str);
- _gnutls_string_append_str
+ _gnutls_buffer_append_str
(&str, _("X.509 Certificate Revocation List Information:\n"));
print_crl (&str, crl, format == GNUTLS_CRT_PRINT_UNSIGNED_FULL);
- _gnutls_string_append_data (&str, "\0", 1);
+ _gnutls_buffer_append_data (&str, "\0", 1);
out->data = str.data;
out->size = strlen (str.data);
}
static void
-print_crq (gnutls_string * str, gnutls_x509_crq_t cert)
+print_crq (gnutls_buffer_st * str, gnutls_x509_crq_t cert)
{
/* Version. */
{
}
static void
-print_crq_other (gnutls_string * str, gnutls_x509_crq_t crq)
+print_crq_other (gnutls_buffer_st * str, gnutls_x509_crq_t crq)
{
int err;
size_t size = 0;
gnutls_certificate_print_formats_t format,
gnutls_datum_t * out)
{
- gnutls_string str;
+ gnutls_buffer_st str;
- _gnutls_string_init (&str, gnutls_malloc, gnutls_realloc, gnutls_free);
+ _gnutls_buffer_init (&str);
- _gnutls_string_append_str
+ _gnutls_buffer_append_str
(&str, _("PKCS #10 Certificate Request Information:\n"));
print_crq (&str, crq);
- _gnutls_string_append_str (&str, _("Other Information:\n"));
+ _gnutls_buffer_append_str (&str, _("Other Information:\n"));
print_crq_other (&str, crq);
- _gnutls_string_append_data (&str, "\0", 1);
+ _gnutls_buffer_append_data (&str, "\0", 1);
out->data = str.data;
out->size = strlen (str.data);
projects / thirdparty / gnutls.git / commitdiff
