aboutsummaryrefslogtreecommitdiff
path: root/src/daemon
diff options
context:
space:
mode:
authorlv-426 <oxcafebaby@yahoo.com>2008-07-26 03:26:56 +0000
committerlv-426 <oxcafebaby@yahoo.com>2008-07-26 03:26:56 +0000
commit16abaea132ac90293a868ecb944abce24fd16d9f (patch)
tree490881a7b7ac6172608c2e9c9ba10d69160551b5 /src/daemon
parent14a57219373afd8dd110ee8af89b32767c72c1dc (diff)
downloadlibmicrohttpd-16abaea132ac90293a868ecb944abce24fd16d9f.tar.gz
libmicrohttpd-16abaea132ac90293a868ecb944abce24fd16d9f.zip
'microhttps.h' merge
gnutls version added to configure.ac to enable assersion before running curl tests GNUTLS symbol renaming
Diffstat (limited to 'src/daemon')
-rw-r--r--src/daemon/Makefile.am5
-rw-r--r--src/daemon/connection.c24
-rw-r--r--src/daemon/connection_https.c5
-rw-r--r--src/daemon/daemon.c8
-rw-r--r--src/daemon/daemon_test.c1
-rw-r--r--src/daemon/https/gnutls.h6
-rw-r--r--src/daemon/https/lgl/gc-gnulib.c744
-rw-r--r--src/daemon/https/lgl/gc-libgcrypt.c568
-rw-r--r--src/daemon/https/openpgp/gnutls_extra.c5
-rw-r--r--src/daemon/https/openpgp/gnutls_ia.c4
-rw-r--r--src/daemon/https/openpgp/gnutls_openpgp.c8
-rw-r--r--src/daemon/https/openpgp/pgp.c4
-rw-r--r--src/daemon/https/openpgp/pgp_privkey.c2
-rw-r--r--src/daemon/https/tests.c147
-rw-r--r--src/daemon/https/tls/auth_anon.c8
-rw-r--r--src/daemon/https/tls/auth_cert.c60
-rw-r--r--src/daemon/https/tls/auth_dhe.c6
-rw-r--r--src/daemon/https/tls/auth_rsa.c10
-rw-r--r--src/daemon/https/tls/auth_rsa_export.c6
-rw-r--r--src/daemon/https/tls/ext_cert_type.c18
-rw-r--r--src/daemon/https/tls/ext_inner_application.c4
-rw-r--r--src/daemon/https/tls/gnutls_algorithms.c406
-rw-r--r--src/daemon/https/tls/gnutls_auth.c6
-rw-r--r--src/daemon/https/tls/gnutls_buffers.c468
-rw-r--r--src/daemon/https/tls/gnutls_cert.c32
-rw-r--r--src/daemon/https/tls/gnutls_cipher.c40
-rw-r--r--src/daemon/https/tls/gnutls_cipher_int.c20
-rw-r--r--src/daemon/https/tls/gnutls_compress_int.c10
-rw-r--r--src/daemon/https/tls/gnutls_constate.c16
-rw-r--r--src/daemon/https/tls/gnutls_global.c49
-rw-r--r--src/daemon/https/tls/gnutls_handshake.c42
-rw-r--r--src/daemon/https/tls/gnutls_hash_int.c24
-rw-r--r--src/daemon/https/tls/gnutls_int.h2
-rw-r--r--src/daemon/https/tls/gnutls_kx.c8
-rw-r--r--src/daemon/https/tls/gnutls_priority.c17
-rw-r--r--src/daemon/https/tls/gnutls_record.c2
-rw-r--r--src/daemon/https/tls/gnutls_rsa_export.c2
-rw-r--r--src/daemon/https/tls/gnutls_session_pack.c40
-rw-r--r--src/daemon/https/tls/gnutls_sig.c28
-rw-r--r--src/daemon/https/tls/gnutls_state.c39
-rw-r--r--src/daemon/https/tls/gnutls_state.h2
-rw-r--r--src/daemon/https/tls/gnutls_ui.c32
-rw-r--r--src/daemon/https/tls/gnutls_x509.c8
-rw-r--r--src/daemon/https/x509/common.c4
-rw-r--r--src/daemon/https/x509/crl_write.c3
-rw-r--r--src/daemon/https/x509/crq.c2
-rw-r--r--src/daemon/https/x509/mpi.c4
-rw-r--r--src/daemon/https/x509/output.c10
-rw-r--r--src/daemon/https/x509/pkcs12.c4
-rw-r--r--src/daemon/https/x509/privkey_pkcs8.c28
-rw-r--r--src/daemon/https/x509/sign.c4
-rw-r--r--src/daemon/https/x509/x509.c10
-rw-r--r--src/daemon/https/x509/x509_privkey.c32
-rw-r--r--src/daemon/https/x509/x509_verify.c8
-rw-r--r--src/daemon/https/x509/x509_write.c3
-rw-r--r--src/daemon/postprocessor.c3
-rw-r--r--src/daemon/postprocessor_large_test.c5
57 files changed, 1531 insertions, 1525 deletions
diff --git a/src/daemon/Makefile.am b/src/daemon/Makefile.am
index 5dcf875b..72fdf3d7 100644
--- a/src/daemon/Makefile.am
+++ b/src/daemon/Makefile.am
@@ -1,4 +1,5 @@
1SUBDIRS = . 1# including '.' mixes up build order when HTTPS is enabled.
2SUBDIRS =
2 3
3AM_CPPFLAGS = \ 4AM_CPPFLAGS = \
4-I$(top_srcdir)/src/include \ 5-I$(top_srcdir)/src/include \
@@ -38,8 +39,8 @@ if ENABLE_HTTPS
38SUBDIRS += https . 39SUBDIRS += https .
39libmicrohttpd_la_SOURCES += connection_https.c 40libmicrohttpd_la_SOURCES += connection_https.c
40libmicrohttpd_la_LIBADD = \ 41libmicrohttpd_la_LIBADD = \
41 https/x509/libx509.la \
42 https/lgl/liblgl.la \ 42 https/lgl/liblgl.la \
43 https/x509/libx509.la \
43 https/tls/libtls.la \ 44 https/tls/libtls.la \
44 https/minitasn1/libasn1.la \ 45 https/minitasn1/libasn1.la \
45 https/opencdk/libopencdk.la \ 46 https/opencdk/libopencdk.la \
diff --git a/src/daemon/connection.c b/src/daemon/connection.c
index 77157f80..017f151c 100644
--- a/src/daemon/connection.c
+++ b/src/daemon/connection.c
@@ -284,9 +284,9 @@ try_ready_normal_body (struct MHD_Connection *connection)
284 ret = response->crc (response->crc_cls, 284 ret = response->crc (response->crc_cls,
285 connection->response_write_position, 285 connection->response_write_position,
286 response->data, 286 response->data,
287 MHD_MIN(response->data_buffer_size, 287 MHD_MIN (response->data_buffer_size,
288 response->total_size - 288 response->total_size -
289 connection->response_write_position)); 289 connection->response_write_position));
290 if (ret == -1) 290 if (ret == -1)
291 { 291 {
292 /* either error or http 1.0 transfer, close 292 /* either error or http 1.0 transfer, close
@@ -323,7 +323,7 @@ try_ready_chunked_body (struct MHD_Connection *connection)
323 char *buf; 323 char *buf;
324 struct MHD_Response *response; 324 struct MHD_Response *response;
325 unsigned int size; 325 unsigned int size;
326 char cbuf[10]; /* 10: max strlen of "%x\r\n" */ 326 char cbuf[10]; /* 10: max strlen of "%x\r\n" */
327 int cblen; 327 int cblen;
328 328
329 response = connection->response; 329 response = connection->response;
@@ -354,8 +354,8 @@ try_ready_chunked_body (struct MHD_Connection *connection)
354 354
355 ret = response->crc (response->crc_cls, 355 ret = response->crc (response->crc_cls,
356 connection->response_write_position, 356 connection->response_write_position,
357 &connection->write_buffer[sizeof(cbuf)], 357 &connection->write_buffer[sizeof (cbuf)],
358 connection->write_buffer_size - sizeof(cbuf) - 2); 358 connection->write_buffer_size - sizeof (cbuf) - 2);
359 if (ret == -1) 359 if (ret == -1)
360 { 360 {
361 /* end of message, signal other side! */ 361 /* end of message, signal other side! */
@@ -372,13 +372,13 @@ try_ready_chunked_body (struct MHD_Connection *connection)
372 } 372 }
373 if (ret > 0xFFFFFF) 373 if (ret > 0xFFFFFF)
374 ret = 0xFFFFFF; 374 ret = 0xFFFFFF;
375 cblen = snprintf (cbuf, sizeof(cbuf), "%X\r\n", ret); 375 cblen = snprintf (cbuf, sizeof (cbuf), "%X\r\n", ret);
376 EXTRA_CHECK(cblen <= sizeof(cbuf)); 376 EXTRA_CHECK (cblen <= sizeof (cbuf));
377 memcpy (&connection->write_buffer[sizeof(cbuf) - cblen], cbuf, cblen); 377 memcpy (&connection->write_buffer[sizeof (cbuf) - cblen], cbuf, cblen);
378 memcpy (&connection->write_buffer[sizeof(cbuf) + ret], "\r\n", 2); 378 memcpy (&connection->write_buffer[sizeof (cbuf) + ret], "\r\n", 2);
379 connection->response_write_position += ret; 379 connection->response_write_position += ret;
380 connection->write_buffer_send_offset = sizeof(cbuf) - cblen; 380 connection->write_buffer_send_offset = sizeof (cbuf) - cblen;
381 connection->write_buffer_append_offset = sizeof(cbuf) + ret + 2; 381 connection->write_buffer_append_offset = sizeof (cbuf) + ret + 2;
382 return MHD_YES; 382 return MHD_YES;
383} 383}
384 384
diff --git a/src/daemon/connection_https.c b/src/daemon/connection_https.c
index aed523ea..30b3f043 100644
--- a/src/daemon/connection_https.c
+++ b/src/daemon/connection_https.c
@@ -32,7 +32,7 @@
32#include "response.h" 32#include "response.h"
33#include "reason_phrase.h" 33#include "reason_phrase.h"
34 34
35#include "microhttpsd.h" 35#include "microhttpd.h"
36/* get opaque type */ 36/* get opaque type */
37#include "gnutls_int.h" 37#include "gnutls_int.h"
38#include "gnutls_record.h" 38#include "gnutls_record.h"
@@ -69,8 +69,7 @@ MHD_tls_connection_close_err (struct MHD_Connection *connection)
69} 69}
70 70
71union MHD_SessionInfo 71union MHD_SessionInfo
72MHD_get_tls_session_info (struct MHD_Connection *con, 72MHD_get_session_info (struct MHD_Connection *con, enum MHD_InfoType infoType)
73 enum MHD_InfoType infoType)
74{ 73{
75 /* return NULL if this isn't a SSL/TLS type connection */ 74 /* return NULL if this isn't a SSL/TLS type connection */
76 if (con->tls_session == NULL) 75 if (con->tls_session == NULL)
diff --git a/src/daemon/daemon.c b/src/daemon/daemon.c
index 965db0a6..d2e0987f 100644
--- a/src/daemon/daemon.c
+++ b/src/daemon/daemon.c
@@ -105,9 +105,9 @@ MHDS_init (struct MHD_Daemon *daemon)
105 } 105 }
106 else if (daemon->https_mem_cert && daemon->https_mem_key) 106 else if (daemon->https_mem_cert && daemon->https_mem_key)
107 { 107 {
108 key.data = (char*) daemon->https_mem_key; 108 key.data = (char *) daemon->https_mem_key;
109 key.size = strlen (daemon->https_mem_key); 109 key.size = strlen (daemon->https_mem_key);
110 cert.data = (char*) daemon->https_mem_cert; 110 cert.data = (char *) daemon->https_mem_cert;
111 cert.size = strlen (daemon->https_mem_cert); 111 cert.size = strlen (daemon->https_mem_cert);
112 112
113 gnutls_certificate_set_x509_key_mem (daemon->x509_cret, &cert, &key, 113 gnutls_certificate_set_x509_key_mem (daemon->x509_cret, &cert, &key,
@@ -127,7 +127,7 @@ MHDS_init (struct MHD_Daemon *daemon)
127 { 127 {
128 /* initialize Diffie Hellman parameters if necessary */ 128 /* initialize Diffie Hellman parameters if necessary */
129 /* TODO add other cipher suits */ 129 /* TODO add other cipher suits */
130 if (st.priority[i] == GNUTLS_KX_DHE_RSA) 130 if (st.priority[i] == MHD_GNUTLS_KX_DHE_RSA)
131 { 131 {
132 gnutls_dh_params_init (&daemon->dh_params); 132 gnutls_dh_params_init (&daemon->dh_params);
133 gnutls_dh_params_generate2 (daemon->dh_params, 1024); 133 gnutls_dh_params_generate2 (daemon->dh_params, 1024);
@@ -318,7 +318,7 @@ MHDS_handle_connection (void *data)
318 gnutls_priority_set (con->tls_session, con->daemon->priority_cache); 318 gnutls_priority_set (con->tls_session, con->daemon->priority_cache);
319 319
320 /* set needed credentials for certificate authentication. */ 320 /* set needed credentials for certificate authentication. */
321 gnutls_credentials_set (con->tls_session, GNUTLS_CRD_CERTIFICATE, 321 gnutls_credentials_set (con->tls_session, MHD_GNUTLS_CRD_CERTIFICATE,
322 con->daemon->x509_cret); 322 con->daemon->x509_cret);
323 323
324 /* TODO avoid gnutls blocking recv / write calls 324 /* TODO avoid gnutls blocking recv / write calls
diff --git a/src/daemon/daemon_test.c b/src/daemon/daemon_test.c
index 8048b438..a6ebbd15 100644
--- a/src/daemon/daemon_test.c
+++ b/src/daemon/daemon_test.c
@@ -25,6 +25,7 @@
25 */ 25 */
26 26
27#include "config.h" 27#include "config.h"
28#include "platform.h"
28#include "microhttpd.h" 29#include "microhttpd.h"
29#include <stdlib.h> 30#include <stdlib.h>
30#include <string.h> 31#include <string.h>
diff --git a/src/daemon/https/gnutls.h b/src/daemon/https/gnutls.h
index df34e72c..ec2c2977 100644
--- a/src/daemon/https/gnutls.h
+++ b/src/daemon/https/gnutls.h
@@ -64,7 +64,7 @@ extern "C"
64#define GNUTLS_CIPHER_RIJNDAEL_CBC GNUTLS_CIPHER_AES_128_CBC 64#define GNUTLS_CIPHER_RIJNDAEL_CBC GNUTLS_CIPHER_AES_128_CBC
65#define GNUTLS_CIPHER_ARCFOUR GNUTLS_CIPHER_ARCFOUR_128 65#define GNUTLS_CIPHER_ARCFOUR GNUTLS_CIPHER_ARCFOUR_128
66 66
67#include "microhttpsd.h" 67#include "microhttpd.h"
68 68
69 typedef enum 69 typedef enum
70 { 70 {
@@ -491,10 +491,6 @@ extern "C"
491 void gnutls_handshake_set_max_packet_length (gnutls_session_t session, 491 void gnutls_handshake_set_max_packet_length (gnutls_session_t session,
492 size_t max); 492 size_t max);
493 493
494/* returns libgnutls version (call it with a NULL argument)
495 */
496 const char *gnutls_check_version (const char *req_version);
497
498/* Functions for setting/clearing credentials 494/* Functions for setting/clearing credentials
499 */ 495 */
500 void gnutls_credentials_clear (gnutls_session_t session); 496 void gnutls_credentials_clear (gnutls_session_t session);
diff --git a/src/daemon/https/lgl/gc-gnulib.c b/src/daemon/https/lgl/gc-gnulib.c
index 05b12781..d1db6d8a 100644
--- a/src/daemon/https/lgl/gc-gnulib.c
+++ b/src/daemon/https/lgl/gc-gnulib.c
@@ -67,12 +67,14 @@
67#undef open 67#undef open
68#undef close 68#undef close
69 69
70Gc_rc gc_init(void) 70Gc_rc
71gc_init (void)
71{ 72{
72 return GC_OK; 73 return GC_OK;
73} 74}
74 75
75void gc_done(void) 76void
77gc_done (void)
76{ 78{
77 return; 79 return;
78} 80}
@@ -83,85 +85,85 @@ void gc_done(void)
83 85
84static Gc_rc 86static Gc_rc
85randomize (int level, char *data, size_t datalen) 87randomize (int level, char *data, size_t datalen)
86 { 88{
87 int fd; 89 int fd;
88 const char *device; 90 const char *device;
89 size_t len = 0; 91 size_t len = 0;
90 int rc; 92 int rc;
91 93
92 switch (level) 94 switch (level)
93 { 95 {
94 case 0: 96 case 0:
95 device = NAME_OF_NONCE_DEVICE; 97 device = NAME_OF_NONCE_DEVICE;
96 break; 98 break;
97 99
98 case 1: 100 case 1:
99 device = NAME_OF_PSEUDO_RANDOM_DEVICE; 101 device = NAME_OF_PSEUDO_RANDOM_DEVICE;
100 break; 102 break;
101 103
102 default: 104 default:
103 device = NAME_OF_RANDOM_DEVICE; 105 device = NAME_OF_RANDOM_DEVICE;
104 break; 106 break;
105 } 107 }
106 108
107 if (strcmp (device, "no") == 0) 109 if (strcmp (device, "no") == 0)
108 return GC_RANDOM_ERROR; 110 return GC_RANDOM_ERROR;
109 111
110 fd = open (device, O_RDONLY); 112 fd = open (device, O_RDONLY);
111 if (fd < 0) 113 if (fd < 0)
112 return GC_RANDOM_ERROR; 114 return GC_RANDOM_ERROR;
113 115
114 do 116 do
115 { 117 {
116 ssize_t tmp; 118 ssize_t tmp;
117 119
118 tmp = read (fd, data, datalen); 120 tmp = read (fd, data, datalen);
119 121
120 if (tmp < 0) 122 if (tmp < 0)
121 { 123 {
122 int save_errno = errno; 124 int save_errno = errno;
123 close (fd); 125 close (fd);
124 errno = save_errno; 126 errno = save_errno;
125 return GC_RANDOM_ERROR; 127 return GC_RANDOM_ERROR;
126 } 128 }
127 129
128 len += tmp; 130 len += tmp;
129 } 131 }
130 while (len < datalen); 132 while (len < datalen);
131 133
132 rc = close (fd); 134 rc = close (fd);
133 if (rc < 0) 135 if (rc < 0)
134 return GC_RANDOM_ERROR; 136 return GC_RANDOM_ERROR;
135 137
136 return GC_OK; 138 return GC_OK;
137 } 139}
138 140
139Gc_rc 141Gc_rc
140gc_nonce (char *data, size_t datalen) 142gc_nonce (char *data, size_t datalen)
141 { 143{
142 return randomize (0, data, datalen); 144 return randomize (0, data, datalen);
143 } 145}
144 146
145Gc_rc 147Gc_rc
146gc_pseudo_random (char *data, size_t datalen) 148gc_pseudo_random (char *data, size_t datalen)
147 { 149{
148 return randomize (1, data, datalen); 150 return randomize (1, data, datalen);
149 } 151}
150 152
151Gc_rc 153Gc_rc
152gc_random (char *data, size_t datalen) 154gc_random (char *data, size_t datalen)
153 { 155{
154 return randomize (2, data, datalen); 156 return randomize (2, data, datalen);
155 } 157}
156 158
157#endif 159#endif
158 160
159/* Memory allocation. */ 161/* Memory allocation. */
160void gc_set_allocators(gc_malloc_t func_malloc, 162void
161 gc_malloc_t secure_malloc, 163gc_set_allocators (gc_malloc_t func_malloc,
162 gc_secure_check_t secure_check, 164 gc_malloc_t secure_malloc,
163 gc_realloc_t func_realloc, 165 gc_secure_check_t secure_check,
164 gc_free_t func_free) 166 gc_realloc_t func_realloc, gc_free_t func_free)
165{ 167{
166 return; 168 return;
167} 169}
@@ -169,9 +171,9 @@ void gc_set_allocators(gc_malloc_t func_malloc,
169/* Ciphers. */ 171/* Ciphers. */
170 172
171typedef struct _gc_cipher_ctx 173typedef struct _gc_cipher_ctx
172 { 174{
173 Gc_cipher alg; 175 Gc_cipher alg;
174 Gc_cipher_mode mode; 176 Gc_cipher_mode mode;
175#ifdef GNULIB_GC_ARCTWO 177#ifdef GNULIB_GC_ARCTWO
176 arctwo_context arctwoContext; 178 arctwo_context arctwoContext;
177 char arctwoIV[ARCTWO_BLOCK_SIZE]; 179 char arctwoIV[ARCTWO_BLOCK_SIZE];
@@ -187,16 +189,16 @@ typedef struct _gc_cipher_ctx
187 rijndaelKeyInstance aesDecKey; 189 rijndaelKeyInstance aesDecKey;
188 rijndaelCipherInstance aesContext; 190 rijndaelCipherInstance aesContext;
189#endif 191#endif
190 } _gc_cipher_ctx; 192} _gc_cipher_ctx;
191 193
192Gc_rc gc_cipher_open(Gc_cipher alg, 194Gc_rc
193 Gc_cipher_mode mode, 195gc_cipher_open (Gc_cipher alg,
194 gc_cipher_handle * outhandle) 196 Gc_cipher_mode mode, gc_cipher_handle * outhandle)
195{ 197{
196 _gc_cipher_ctx *ctx; 198 _gc_cipher_ctx *ctx;
197 Gc_rc rc = GC_OK; 199 Gc_rc rc = GC_OK;
198 200
199 ctx = calloc(sizeof (*ctx), 1); 201 ctx = calloc (sizeof (*ctx), 1);
200 if (!ctx) 202 if (!ctx)
201 return GC_MALLOC_ERROR; 203 return GC_MALLOC_ERROR;
202 204
@@ -206,344 +208,341 @@ Gc_rc gc_cipher_open(Gc_cipher alg,
206 switch (alg) 208 switch (alg)
207 { 209 {
208#ifdef GNULIB_GC_ARCTWO 210#ifdef GNULIB_GC_ARCTWO
209 case GC_ARCTWO40: 211 case GC_ARCTWO40:
210 switch (mode) 212 switch (mode)
211 { 213 {
212 case GC_ECB: 214 case GC_ECB:
213 case GC_CBC: 215 case GC_CBC:
214 break; 216 break;
215 217
216 default: 218 default:
217 rc = GC_INVALID_CIPHER; 219 rc = GC_INVALID_CIPHER;
218 } 220 }
219 break; 221 break;
220#endif 222#endif
221 223
222#ifdef GNULIB_GC_ARCFOUR 224#ifdef GNULIB_GC_ARCFOUR
223 case GC_ARCFOUR128: 225 case GC_ARCFOUR128:
224 case GC_ARCFOUR40: 226 case GC_ARCFOUR40:
225 switch (mode) 227 switch (mode)
226 { 228 {
227 case GC_STREAM: 229 case GC_STREAM:
228 break; 230 break;
229 231
230 default: 232 default:
231 rc = GC_INVALID_CIPHER; 233 rc = GC_INVALID_CIPHER;
232 } 234 }
233 break; 235 break;
234#endif 236#endif
235 237
236#ifdef GNULIB_GC_DES 238#ifdef GNULIB_GC_DES
237 case GC_DES: 239 case GC_DES:
238 switch (mode) 240 switch (mode)
239 { 241 {
240 case GC_ECB: 242 case GC_ECB:
241 break; 243 break;
242 244
243 default: 245 default:
244 rc = GC_INVALID_CIPHER; 246 rc = GC_INVALID_CIPHER;
245 } 247 }
246 break; 248 break;
247#endif 249#endif
248 250
249#ifdef GNULIB_GC_RIJNDAEL 251#ifdef GNULIB_GC_RIJNDAEL
250 case GC_AES128: 252 case GC_AES128:
251 case GC_AES192: 253 case GC_AES192:
252 case GC_AES256: 254 case GC_AES256:
253 switch (mode) 255 switch (mode)
254 { 256 {
255 case GC_ECB: 257 case GC_ECB:
256 case GC_CBC: 258 case GC_CBC:
257 break; 259 break;
258 260
259 default: 261 default:
260 rc = GC_INVALID_CIPHER; 262 rc = GC_INVALID_CIPHER;
261 } 263 }
262 break; 264 break;
263#endif 265#endif
264 266
265 default: 267 default:
266 rc = GC_INVALID_CIPHER; 268 rc = GC_INVALID_CIPHER;
267 } 269 }
268 270
269 if (rc == GC_OK) 271 if (rc == GC_OK)
270 *outhandle = ctx; 272 *outhandle = ctx;
271 else 273 else
272 free(ctx); 274 free (ctx);
273 275
274 return rc; 276 return rc;
275} 277}
276 278
277Gc_rc gc_cipher_setkey(gc_cipher_handle handle, 279Gc_rc
278 size_t keylen, 280gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
279 const char *key)
280{ 281{
281 _gc_cipher_ctx *ctx = handle; 282 _gc_cipher_ctx *ctx = handle;
282 283
283 switch (ctx->alg) 284 switch (ctx->alg)
284 { 285 {
285#ifdef GNULIB_GC_ARCTWO 286#ifdef GNULIB_GC_ARCTWO
286 case GC_ARCTWO40: 287 case GC_ARCTWO40:
287 arctwo_setkey (&ctx->arctwoContext, keylen, key); 288 arctwo_setkey (&ctx->arctwoContext, keylen, key);
288 break; 289 break;
289#endif 290#endif
290 291
291#ifdef GNULIB_GC_ARCFOUR 292#ifdef GNULIB_GC_ARCFOUR
292 case GC_ARCFOUR128: 293 case GC_ARCFOUR128:
293 case GC_ARCFOUR40: 294 case GC_ARCFOUR40:
294 arcfour_setkey (&ctx->arcfourContext, key, keylen); 295 arcfour_setkey (&ctx->arcfourContext, key, keylen);
295 break; 296 break;
296#endif 297#endif
297 298
298#ifdef GNULIB_GC_DES 299#ifdef GNULIB_GC_DES
299 case GC_DES: 300 case GC_DES:
300 if (keylen != 8) 301 if (keylen != 8)
301 return GC_INVALID_CIPHER; 302 return GC_INVALID_CIPHER;
302 gl_des_setkey (&ctx->desContext, key); 303 gl_des_setkey (&ctx->desContext, key);
303 break; 304 break;
304#endif 305#endif
305 306
306#ifdef GNULIB_GC_RIJNDAEL 307#ifdef GNULIB_GC_RIJNDAEL
307 case GC_AES128: 308 case GC_AES128:
308 case GC_AES192: 309 case GC_AES192:
309 case GC_AES256: 310 case GC_AES256:
310 { 311 {
311 rijndael_rc rc; 312 rijndael_rc rc;
312 size_t i; 313 size_t i;
313 char keyMaterial[RIJNDAEL_MAX_KEY_SIZE + 1]; 314 char keyMaterial[RIJNDAEL_MAX_KEY_SIZE + 1];
314 315
315 for (i = 0; i < keylen; i++) 316 for (i = 0; i < keylen; i++)
316 sprintf (&keyMaterial[2 * i], "%02x", key[i] & 0xFF); 317 sprintf (&keyMaterial[2 * i], "%02x", key[i] & 0xFF);
317 318
318 rc = rijndaelMakeKey (&ctx->aesEncKey, RIJNDAEL_DIR_ENCRYPT, 319 rc = rijndaelMakeKey (&ctx->aesEncKey, RIJNDAEL_DIR_ENCRYPT,
319 keylen * 8, keyMaterial); 320 keylen * 8, keyMaterial);
320 if (rc < 0) 321 if (rc < 0)
321 return GC_INVALID_CIPHER; 322 return GC_INVALID_CIPHER;
322 323
323 rc = rijndaelMakeKey (&ctx->aesDecKey, RIJNDAEL_DIR_DECRYPT, 324 rc = rijndaelMakeKey (&ctx->aesDecKey, RIJNDAEL_DIR_DECRYPT,
324 keylen * 8, keyMaterial); 325 keylen * 8, keyMaterial);
325 if (rc < 0) 326 if (rc < 0)
326 return GC_INVALID_CIPHER; 327 return GC_INVALID_CIPHER;
327 328
328 rc = rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_ECB, NULL); 329 rc = rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_ECB, NULL);
329 if (rc < 0) 330 if (rc < 0)
330 return GC_INVALID_CIPHER; 331 return GC_INVALID_CIPHER;
331 } 332 }
332 break; 333 break;
333#endif 334#endif
334 335
335 default: 336 default:
336 return GC_INVALID_CIPHER; 337 return GC_INVALID_CIPHER;
337 } 338 }
338 339
339 return GC_OK; 340 return GC_OK;
340} 341}
341 342
342Gc_rc gc_cipher_setiv(gc_cipher_handle handle, 343Gc_rc
343 size_t ivlen, 344gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
344 const char *iv)
345{ 345{
346 _gc_cipher_ctx *ctx = handle; 346 _gc_cipher_ctx *ctx = handle;
347 347
348 switch (ctx->alg) 348 switch (ctx->alg)
349 { 349 {
350#ifdef GNULIB_GC_ARCTWO 350#ifdef GNULIB_GC_ARCTWO
351 case GC_ARCTWO40: 351 case GC_ARCTWO40:
352 if (ivlen != ARCTWO_BLOCK_SIZE) 352 if (ivlen != ARCTWO_BLOCK_SIZE)
353 return GC_INVALID_CIPHER; 353 return GC_INVALID_CIPHER;
354 memcpy (ctx->arctwoIV, iv, ivlen); 354 memcpy (ctx->arctwoIV, iv, ivlen);
355 break; 355 break;
356#endif 356#endif
357 357
358#ifdef GNULIB_GC_RIJNDAEL 358#ifdef GNULIB_GC_RIJNDAEL
359 case GC_AES128: 359 case GC_AES128:
360 case GC_AES192: 360 case GC_AES192:
361 case GC_AES256: 361 case GC_AES256:
362 switch (ctx->mode) 362 switch (ctx->mode)
363 {
364 case GC_ECB:
365 /* Doesn't use IV. */
366 break;
367
368 case GC_CBC:
369 { 363 {
370 rijndael_rc rc; 364 case GC_ECB:
371 size_t i; 365 /* Doesn't use IV. */
372 char ivMaterial[2 * RIJNDAEL_MAX_IV_SIZE + 1]; 366 break;
373 367
374 for (i = 0; i < ivlen; i++) 368 case GC_CBC:
375 sprintf (&ivMaterial[2 * i], "%02x", iv[i] & 0xFF); 369 {
370 rijndael_rc rc;
371 size_t i;
372 char ivMaterial[2 * RIJNDAEL_MAX_IV_SIZE + 1];
373
374 for (i = 0; i < ivlen; i++)
375 sprintf (&ivMaterial[2 * i], "%02x", iv[i] & 0xFF);
376
377 rc = rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_CBC,
378 ivMaterial);
379 if (rc < 0)
380 return GC_INVALID_CIPHER;
381 }
382 break;
376 383
377 rc = rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_CBC, 384 default:
378 ivMaterial);
379 if (rc < 0)
380 return GC_INVALID_CIPHER; 385 return GC_INVALID_CIPHER;
381 } 386 }
382 break; 387 break;
383
384 default:
385 return GC_INVALID_CIPHER;
386 }
387 break;
388#endif 388#endif
389 389
390 default: 390 default:
391 return GC_INVALID_CIPHER; 391 return GC_INVALID_CIPHER;
392 } 392 }
393 393
394 return GC_OK; 394 return GC_OK;
395} 395}
396 396
397Gc_rc gc_cipher_encrypt_inline(gc_cipher_handle handle, 397Gc_rc
398 size_t len, 398gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
399 char *data)
400{ 399{
401 _gc_cipher_ctx *ctx = handle; 400 _gc_cipher_ctx *ctx = handle;
402 401
403 switch (ctx->alg) 402 switch (ctx->alg)
404 { 403 {
405#ifdef GNULIB_GC_ARCTWO 404#ifdef GNULIB_GC_ARCTWO
406 case GC_ARCTWO40: 405 case GC_ARCTWO40:
407 switch (ctx->mode) 406 switch (ctx->mode)
408 {
409 case GC_ECB:
410 arctwo_encrypt (&ctx->arctwoContext, data, data, len);
411 break;
412
413 case GC_CBC:
414 for (; len >= ARCTWO_BLOCK_SIZE; len -= ARCTWO_BLOCK_SIZE,
415 data += ARCTWO_BLOCK_SIZE)
416 { 407 {
417 size_t i; 408 case GC_ECB:
418 for (i = 0; i < ARCTWO_BLOCK_SIZE; i++) 409 arctwo_encrypt (&ctx->arctwoContext, data, data, len);
419 data[i] ^= ctx->arctwoIV[i]; 410 break;
420 arctwo_encrypt (&ctx->arctwoContext, data, data, 411
421 ARCTWO_BLOCK_SIZE); 412 case GC_CBC:
422 memcpy (ctx->arctwoIV, data, ARCTWO_BLOCK_SIZE); 413 for (; len >= ARCTWO_BLOCK_SIZE; len -= ARCTWO_BLOCK_SIZE,
414 data += ARCTWO_BLOCK_SIZE)
415 {
416 size_t i;
417 for (i = 0; i < ARCTWO_BLOCK_SIZE; i++)
418 data[i] ^= ctx->arctwoIV[i];
419 arctwo_encrypt (&ctx->arctwoContext, data, data,
420 ARCTWO_BLOCK_SIZE);
421 memcpy (ctx->arctwoIV, data, ARCTWO_BLOCK_SIZE);
422 }
423 break;
424
425 default:
426 return GC_INVALID_CIPHER;
423 } 427 }
424 break; 428 break;
425
426 default:
427 return GC_INVALID_CIPHER;
428 }
429 break;
430#endif 429#endif
431 430
432#ifdef GNULIB_GC_ARCFOUR 431#ifdef GNULIB_GC_ARCFOUR
433 case GC_ARCFOUR128: 432 case GC_ARCFOUR128:
434 case GC_ARCFOUR40: 433 case GC_ARCFOUR40:
435 arcfour_stream (&ctx->arcfourContext, data, data, len); 434 arcfour_stream (&ctx->arcfourContext, data, data, len);
436 break; 435 break;
437#endif 436#endif
438 437
439#ifdef GNULIB_GC_DES 438#ifdef GNULIB_GC_DES
440 case GC_DES: 439 case GC_DES:
441 for (; len >= 8; len -= 8, data += 8) 440 for (; len >= 8; len -= 8, data += 8)
442 gl_des_ecb_encrypt (&ctx->desContext, data, data); 441 gl_des_ecb_encrypt (&ctx->desContext, data, data);
443 break; 442 break;
444#endif 443#endif
445 444
446#ifdef GNULIB_GC_RIJNDAEL 445#ifdef GNULIB_GC_RIJNDAEL
447 case GC_AES128: 446 case GC_AES128:
448 case GC_AES192: 447 case GC_AES192:
449 case GC_AES256: 448 case GC_AES256:
450 { 449 {
451 int nblocks; 450 int nblocks;
452 451
453 nblocks = rijndaelBlockEncrypt (&ctx->aesContext, &ctx->aesEncKey, 452 nblocks = rijndaelBlockEncrypt (&ctx->aesContext, &ctx->aesEncKey,
454 data, 8 * len, data); 453 data, 8 * len, data);
455 if (nblocks < 0) 454 if (nblocks < 0)
456 return GC_INVALID_CIPHER; 455 return GC_INVALID_CIPHER;
457 } 456 }
458 break; 457 break;
459#endif 458#endif
460 459
461 default: 460 default:
462 return GC_INVALID_CIPHER; 461 return GC_INVALID_CIPHER;
463 } 462 }
464 463
465 return GC_OK; 464 return GC_OK;
466} 465}
467 466
468Gc_rc gc_cipher_decrypt_inline(gc_cipher_handle handle, 467Gc_rc
469 size_t len, 468gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
470 char *data)
471{ 469{
472 _gc_cipher_ctx *ctx = handle; 470 _gc_cipher_ctx *ctx = handle;
473 471
474 switch (ctx->alg) 472 switch (ctx->alg)
475 { 473 {
476#ifdef GNULIB_GC_ARCTWO 474#ifdef GNULIB_GC_ARCTWO
477 case GC_ARCTWO40: 475 case GC_ARCTWO40:
478 switch (ctx->mode) 476 switch (ctx->mode)
479 {
480 case GC_ECB:
481 arctwo_decrypt (&ctx->arctwoContext, data, data, len);
482 break;
483
484 case GC_CBC:
485 for (; len >= ARCTWO_BLOCK_SIZE; len -= ARCTWO_BLOCK_SIZE,
486 data += ARCTWO_BLOCK_SIZE)
487 { 477 {
488 char tmpIV[ARCTWO_BLOCK_SIZE]; 478 case GC_ECB:
489 size_t i; 479 arctwo_decrypt (&ctx->arctwoContext, data, data, len);
490 memcpy (tmpIV, data, ARCTWO_BLOCK_SIZE); 480 break;
491 arctwo_decrypt (&ctx->arctwoContext, data, data, 481
492 ARCTWO_BLOCK_SIZE); 482 case GC_CBC:
493 for (i = 0; i < ARCTWO_BLOCK_SIZE; i++) 483 for (; len >= ARCTWO_BLOCK_SIZE; len -= ARCTWO_BLOCK_SIZE,
494 data[i] ^= ctx->arctwoIV[i]; 484 data += ARCTWO_BLOCK_SIZE)
495 memcpy (ctx->arctwoIV, tmpIV, ARCTWO_BLOCK_SIZE); 485 {
486 char tmpIV[ARCTWO_BLOCK_SIZE];
487 size_t i;
488 memcpy (tmpIV, data, ARCTWO_BLOCK_SIZE);
489 arctwo_decrypt (&ctx->arctwoContext, data, data,
490 ARCTWO_BLOCK_SIZE);
491 for (i = 0; i < ARCTWO_BLOCK_SIZE; i++)
492 data[i] ^= ctx->arctwoIV[i];
493 memcpy (ctx->arctwoIV, tmpIV, ARCTWO_BLOCK_SIZE);
494 }
495 break;
496
497 default:
498 return GC_INVALID_CIPHER;
496 } 499 }
497 break; 500 break;
498
499 default:
500 return GC_INVALID_CIPHER;
501 }
502 break;
503#endif 501#endif
504 502
505#ifdef GNULIB_GC_ARCFOUR 503#ifdef GNULIB_GC_ARCFOUR
506 case GC_ARCFOUR128: 504 case GC_ARCFOUR128:
507 case GC_ARCFOUR40: 505 case GC_ARCFOUR40:
508 arcfour_stream (&ctx->arcfourContext, data, data, len); 506 arcfour_stream (&ctx->arcfourContext, data, data, len);
509 break; 507 break;
510#endif 508#endif
511 509
512#ifdef GNULIB_GC_DES 510#ifdef GNULIB_GC_DES
513 case GC_DES: 511 case GC_DES:
514 for (; len >= 8; len -= 8, data += 8) 512 for (; len >= 8; len -= 8, data += 8)
515 gl_des_ecb_decrypt (&ctx->desContext, data, data); 513 gl_des_ecb_decrypt (&ctx->desContext, data, data);
516 break; 514 break;
517#endif 515#endif
518 516
519#ifdef GNULIB_GC_RIJNDAEL 517#ifdef GNULIB_GC_RIJNDAEL
520 case GC_AES128: 518 case GC_AES128:
521 case GC_AES192: 519 case GC_AES192:
522 case GC_AES256: 520 case GC_AES256:
523 { 521 {
524 int nblocks; 522 int nblocks;
525 523
526 nblocks = rijndaelBlockDecrypt (&ctx->aesContext, &ctx->aesDecKey, 524 nblocks = rijndaelBlockDecrypt (&ctx->aesContext, &ctx->aesDecKey,
527 data, 8 * len, data); 525 data, 8 * len, data);
528 if (nblocks < 0) 526 if (nblocks < 0)
529 return GC_INVALID_CIPHER; 527 return GC_INVALID_CIPHER;
530 } 528 }
531 break; 529 break;
532#endif 530#endif
533 531
534 default: 532 default:
535 return GC_INVALID_CIPHER; 533 return GC_INVALID_CIPHER;
536 } 534 }
537 535
538 return GC_OK; 536 return GC_OK;
539} 537}
540 538
541Gc_rc gc_cipher_close(gc_cipher_handle handle) 539Gc_rc
540gc_cipher_close (gc_cipher_handle handle)
542{ 541{
543 _gc_cipher_ctx *ctx = handle; 542 _gc_cipher_ctx *ctx = handle;
544 543
545 if (ctx) 544 if (ctx)
546 free(ctx); 545 free (ctx);
547 546
548 return GC_OK; 547 return GC_OK;
549} 548}
@@ -553,26 +552,25 @@ Gc_rc gc_cipher_close(gc_cipher_handle handle)
553#define MAX_DIGEST_SIZE 20 552#define MAX_DIGEST_SIZE 20
554 553
555typedef struct _gc_hash_ctx 554typedef struct _gc_hash_ctx
556 { 555{
557 Gc_hash alg; 556 Gc_hash alg;
558 Gc_hash_mode mode; 557 Gc_hash_mode mode;
559 char hash[MAX_DIGEST_SIZE]; 558 char hash[MAX_DIGEST_SIZE];
560#ifdef GNULIB_GC_MD5 559#ifdef GNULIB_GC_MD5
561 struct md5_ctx md5Context; 560 struct md5_ctx md5Context;
562#endif 561#endif
563#ifdef GNULIB_GC_SHA1 562#ifdef GNULIB_GC_SHA1
564 struct sha1_ctx sha1Context; 563 struct sha1_ctx sha1Context;
565#endif 564#endif
566 } _gc_hash_ctx; 565} _gc_hash_ctx;
567 566
568Gc_rc gc_hash_open(Gc_hash hash, 567Gc_rc
569 Gc_hash_mode mode, 568gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
570 gc_hash_handle * outhandle)
571{ 569{
572 _gc_hash_ctx *ctx; 570 _gc_hash_ctx *ctx;
573 Gc_rc rc = GC_OK; 571 Gc_rc rc = GC_OK;
574 572
575 ctx = calloc(sizeof (*ctx), 1); 573 ctx = calloc (sizeof (*ctx), 1);
576 if (!ctx) 574 if (!ctx)
577 return GC_MALLOC_ERROR; 575 return GC_MALLOC_ERROR;
578 576
@@ -582,169 +580,169 @@ Gc_rc gc_hash_open(Gc_hash hash,
582 switch (hash) 580 switch (hash)
583 { 581 {
584#ifdef GNULIB_GC_MD5 582#ifdef GNULIB_GC_MD5
585 case GC_MD5: 583 case GC_MD5:
586 md5_init_ctx (&ctx->md5Context); 584 md5_init_ctx (&ctx->md5Context);
587 break; 585 break;
588#endif 586#endif
589 587
590#ifdef GNULIB_GC_SHA1 588#ifdef GNULIB_GC_SHA1
591 case GC_SHA1: 589 case GC_SHA1:
592 sha1_init_ctx (&ctx->sha1Context); 590 sha1_init_ctx (&ctx->sha1Context);
593 break; 591 break;
594#endif 592#endif
595 593
596 default: 594 default:
597 rc = GC_INVALID_HASH; 595 rc = GC_INVALID_HASH;
598 break; 596 break;
599 } 597 }
600 598
601 switch (mode) 599 switch (mode)
602 { 600 {
603 case 0: 601 case 0:
604 break; 602 break;
605 603
606 default: 604 default:
607 rc = GC_INVALID_HASH; 605 rc = GC_INVALID_HASH;
608 break; 606 break;
609 } 607 }
610 608
611 if (rc == GC_OK) 609 if (rc == GC_OK)
612 *outhandle = ctx; 610 *outhandle = ctx;
613 else 611 else
614 free(ctx); 612 free (ctx);
615 613
616 return rc; 614 return rc;
617} 615}
618 616
619Gc_rc gc_hash_clone(gc_hash_handle handle, 617Gc_rc
620 gc_hash_handle * outhandle) 618gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
621{ 619{
622 _gc_hash_ctx *in = handle; 620 _gc_hash_ctx *in = handle;
623 _gc_hash_ctx *out; 621 _gc_hash_ctx *out;
624 622
625 *outhandle = out = calloc(sizeof (*out), 1); 623 *outhandle = out = calloc (sizeof (*out), 1);
626 if (!out) 624 if (!out)
627 return GC_MALLOC_ERROR; 625 return GC_MALLOC_ERROR;
628 626
629 memcpy(out, in, sizeof (*out)); 627 memcpy (out, in, sizeof (*out));
630 628
631 return GC_OK; 629 return GC_OK;
632} 630}
633 631
634size_t gc_hash_digest_length(Gc_hash hash) 632size_t
633gc_hash_digest_length (Gc_hash hash)
635{ 634{
636 size_t len; 635 size_t len;
637 636
638 switch (hash) 637 switch (hash)
639 { 638 {
640 case GC_MD2: 639 case GC_MD2:
641 len = GC_MD2_DIGEST_SIZE; 640 len = GC_MD2_DIGEST_SIZE;
642 break; 641 break;
643 642
644 case GC_MD4: 643 case GC_MD4:
645 len = GC_MD4_DIGEST_SIZE; 644 len = GC_MD4_DIGEST_SIZE;
646 break; 645 break;
647 646
648 case GC_MD5: 647 case GC_MD5:
649 len = GC_MD5_DIGEST_SIZE; 648 len = GC_MD5_DIGEST_SIZE;
650 break; 649 break;
651 650
652 case GC_RMD160: 651 case GC_RMD160:
653 len = GC_RMD160_DIGEST_SIZE; 652 len = GC_RMD160_DIGEST_SIZE;
654 break; 653 break;
655 654
656 case GC_SHA1: 655 case GC_SHA1:
657 len = GC_SHA1_DIGEST_SIZE; 656 len = GC_SHA1_DIGEST_SIZE;
658 break; 657 break;
659 658
660 default: 659 default:
661 return 0; 660 return 0;
662 } 661 }
663 662
664 return len; 663 return len;
665} 664}
666 665
667void gc_hash_write(gc_hash_handle handle, 666void
668 size_t len, 667gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
669 const char *data)
670{ 668{
671 _gc_hash_ctx *ctx = handle; 669 _gc_hash_ctx *ctx = handle;
672 670
673 switch (ctx->alg) 671 switch (ctx->alg)
674 { 672 {
675#ifdef GNULIB_GC_MD5 673#ifdef GNULIB_GC_MD5
676 case GC_MD5: 674 case GC_MD5:
677 md5_process_bytes (data, len, &ctx->md5Context); 675 md5_process_bytes (data, len, &ctx->md5Context);
678 break; 676 break;
679#endif 677#endif
680 678
681#ifdef GNULIB_GC_SHA1 679#ifdef GNULIB_GC_SHA1
682 case GC_SHA1: 680 case GC_SHA1:
683 sha1_process_bytes (data, len, &ctx->sha1Context); 681 sha1_process_bytes (data, len, &ctx->sha1Context);
684 break; 682 break;
685#endif 683#endif
686 684
687 default: 685 default:
688 break; 686 break;
689 } 687 }
690} 688}
691 689
692const char * gc_hash_read(gc_hash_handle handle) 690const char *
691gc_hash_read (gc_hash_handle handle)
693{ 692{
694 _gc_hash_ctx *ctx = handle; 693 _gc_hash_ctx *ctx = handle;
695 const char *ret= NULL; 694 const char *ret = NULL;
696 695
697 switch (ctx->alg) 696 switch (ctx->alg)
698 { 697 {
699#ifdef GNULIB_GC_MD5 698#ifdef GNULIB_GC_MD5
700 case GC_MD5: 699 case GC_MD5:
701 md5_finish_ctx (&ctx->md5Context, ctx->hash); 700 md5_finish_ctx (&ctx->md5Context, ctx->hash);
702 ret = ctx->hash; 701 ret = ctx->hash;
703 break; 702 break;
704#endif 703#endif
705 704
706#ifdef GNULIB_GC_SHA1 705#ifdef GNULIB_GC_SHA1
707 case GC_SHA1: 706 case GC_SHA1:
708 sha1_finish_ctx (&ctx->sha1Context, ctx->hash); 707 sha1_finish_ctx (&ctx->sha1Context, ctx->hash);
709 ret = ctx->hash; 708 ret = ctx->hash;
710 break; 709 break;
711#endif 710#endif
712 711
713 default: 712 default:
714 return NULL; 713 return NULL;
715 } 714 }
716 715
717 return ret; 716 return ret;
718} 717}
719 718
720void gc_hash_close(gc_hash_handle handle) 719void
720gc_hash_close (gc_hash_handle handle)
721{ 721{
722 _gc_hash_ctx *ctx = handle; 722 _gc_hash_ctx *ctx = handle;
723 723
724 free(ctx); 724 free (ctx);
725} 725}
726 726
727Gc_rc gc_hash_buffer(Gc_hash hash, 727Gc_rc
728 const void *in, 728gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
729 size_t inlen,
730 char *resbuf)
731{ 729{
732 switch (hash) 730 switch (hash)
733 { 731 {
734#ifdef GNULIB_GC_MD5 732#ifdef GNULIB_GC_MD5
735 case GC_MD5: 733 case GC_MD5:
736 md5_buffer (in, inlen, resbuf); 734 md5_buffer (in, inlen, resbuf);
737 break; 735 break;
738#endif 736#endif
739 737
740#ifdef GNULIB_GC_SHA1 738#ifdef GNULIB_GC_SHA1
741 case GC_SHA1: 739 case GC_SHA1:
742 sha1_buffer (in, inlen, resbuf); 740 sha1_buffer (in, inlen, resbuf);
743 break; 741 break;
744#endif 742#endif
745 743
746 default: 744 default:
747 return GC_INVALID_HASH; 745 return GC_INVALID_HASH;
748 } 746 }
749 747
750 return GC_OK; 748 return GC_OK;
@@ -753,39 +751,37 @@ Gc_rc gc_hash_buffer(Gc_hash hash,
753#ifdef GNULIB_GC_MD5 751#ifdef GNULIB_GC_MD5
754Gc_rc 752Gc_rc
755gc_md5 (const void *in, size_t inlen, void *resbuf) 753gc_md5 (const void *in, size_t inlen, void *resbuf)
756 { 754{
757 md5_buffer (in, inlen, resbuf); 755 md5_buffer (in, inlen, resbuf);
758 return GC_OK; 756 return GC_OK;
759 } 757}
760#endif 758#endif
761 759
762#ifdef GNULIB_GC_SHA1 760#ifdef GNULIB_GC_SHA1
763Gc_rc 761Gc_rc
764gc_sha1 (const void *in, size_t inlen, void *resbuf) 762gc_sha1 (const void *in, size_t inlen, void *resbuf)
765 { 763{
766 sha1_buffer (in, inlen, resbuf); 764 sha1_buffer (in, inlen, resbuf);
767 return GC_OK; 765 return GC_OK;
768 } 766}
769#endif 767#endif
770 768
771#ifdef GNULIB_GC_HMAC_MD5 769#ifdef GNULIB_GC_HMAC_MD5
772Gc_rc 770Gc_rc
773gc_hmac_md5 (const void *key, size_t keylen, 771gc_hmac_md5 (const void *key, size_t keylen,
774 const void *in, size_t inlen, char *resbuf) 772 const void *in, size_t inlen, char *resbuf)
775 { 773{
776 hmac_md5 (key, keylen, in, inlen, resbuf); 774 hmac_md5 (key, keylen, in, inlen, resbuf);
777 return GC_OK; 775 return GC_OK;
778 } 776}
779#endif 777#endif
780 778
781#ifdef GNULIB_GC_HMAC_SHA1 779#ifdef GNULIB_GC_HMAC_SHA1
782Gc_rc gc_hmac_sha1(const void *key, 780Gc_rc
783 size_t keylen, 781gc_hmac_sha1 (const void *key,
784 const void *in, 782 size_t keylen, const void *in, size_t inlen, char *resbuf)
785 size_t inlen,
786 char *resbuf)
787{ 783{
788 hmac_sha1(key, keylen, in, inlen, resbuf); 784 hmac_sha1 (key, keylen, in, inlen, resbuf);
789 return GC_OK; 785 return GC_OK;
790} 786}
791#endif 787#endif
diff --git a/src/daemon/https/lgl/gc-libgcrypt.c b/src/daemon/https/lgl/gc-libgcrypt.c
index da9c5e16..d65bb27c 100644
--- a/src/daemon/https/lgl/gc-libgcrypt.c
+++ b/src/daemon/https/lgl/gc-libgcrypt.c
@@ -35,24 +35,26 @@
35 35
36/* Initialization. */ 36/* Initialization. */
37 37
38Gc_rc gc_init(void) 38Gc_rc
39gc_init (void)
39{ 40{
40 gcry_error_t err; 41 gcry_error_t err;
41 42
42 err = gcry_control(GCRYCTL_ANY_INITIALIZATION_P); 43 err = gcry_control (GCRYCTL_ANY_INITIALIZATION_P);
43 if (err == GPG_ERR_NO_ERROR) 44 if (err == GPG_ERR_NO_ERROR)
44 { 45 {
45 if (gcry_check_version(GCRYPT_VERSION) == NULL) 46 if (gcry_check_version (GCRYPT_VERSION) == NULL)
46 return GC_INIT_ERROR; 47 return GC_INIT_ERROR;
47 48
48 err = gcry_control(GCRYCTL_INITIALIZATION_FINISHED, NULL, 0); 49 err = gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL, 0);
49 if (err != GPG_ERR_NO_ERROR) 50 if (err != GPG_ERR_NO_ERROR)
50 return GC_INIT_ERROR; 51 return GC_INIT_ERROR;
51 } 52 }
52 return GC_OK; 53 return GC_OK;
53} 54}
54 55
55void gc_done(void) 56void
57gc_done (void)
56{ 58{
57 return; 59 return;
58} 60}
@@ -63,167 +65,167 @@ void gc_done(void)
63 65
64Gc_rc 66Gc_rc
65gc_nonce (char *data, size_t datalen) 67gc_nonce (char *data, size_t datalen)
66 { 68{
67 gcry_create_nonce ((unsigned char *) data, datalen); 69 gcry_create_nonce ((unsigned char *) data, datalen);
68 return GC_OK; 70 return GC_OK;
69 } 71}
70 72
71Gc_rc 73Gc_rc
72gc_pseudo_random (char *data, size_t datalen) 74gc_pseudo_random (char *data, size_t datalen)
73 { 75{
74 gcry_randomize ((unsigned char *) data, datalen, GCRY_STRONG_RANDOM); 76 gcry_randomize ((unsigned char *) data, datalen, GCRY_STRONG_RANDOM);
75 return GC_OK; 77 return GC_OK;
76 } 78}
77 79
78Gc_rc 80Gc_rc
79gc_random (char *data, size_t datalen) 81gc_random (char *data, size_t datalen)
80 { 82{
81 gcry_randomize ((unsigned char *) data, datalen, GCRY_VERY_STRONG_RANDOM); 83 gcry_randomize ((unsigned char *) data, datalen, GCRY_VERY_STRONG_RANDOM);
82 return GC_OK; 84 return GC_OK;
83 } 85}
84 86
85#endif 87#endif
86 88
87/* Memory allocation. */ 89/* Memory allocation. */
88 90
89void gc_set_allocators(gc_malloc_t func_malloc, 91void
90 gc_malloc_t secure_malloc, 92gc_set_allocators (gc_malloc_t func_malloc,
91 gc_secure_check_t secure_check, 93 gc_malloc_t secure_malloc,
92 gc_realloc_t func_realloc, 94 gc_secure_check_t secure_check,
93 gc_free_t func_free) 95 gc_realloc_t func_realloc, gc_free_t func_free)
94{ 96{
95 gcry_set_allocation_handler(func_malloc, secure_malloc, secure_check, 97 gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
96 func_realloc, func_free); 98 func_realloc, func_free);
97} 99}
98 100
99/* Ciphers. */ 101/* Ciphers. */
100 102
101Gc_rc gc_cipher_open(Gc_cipher alg, 103Gc_rc
102 Gc_cipher_mode mode, 104gc_cipher_open (Gc_cipher alg,
103 gc_cipher_handle * outhandle) 105 Gc_cipher_mode mode, gc_cipher_handle * outhandle)
104{ 106{
105 int gcryalg, gcrymode; 107 int gcryalg, gcrymode;
106 gcry_error_t err; 108 gcry_error_t err;
107 109
108 switch (alg) 110 switch (alg)
109 { 111 {
110 case GC_AES128: 112 case GC_AES128:
111 gcryalg = GCRY_CIPHER_RIJNDAEL; 113 gcryalg = GCRY_CIPHER_RIJNDAEL;
112 break; 114 break;
113 115
114 case GC_AES192: 116 case GC_AES192:
115 gcryalg = GCRY_CIPHER_RIJNDAEL; 117 gcryalg = GCRY_CIPHER_RIJNDAEL;
116 break; 118 break;
117 119
118 case GC_AES256: 120 case GC_AES256:
119 gcryalg = GCRY_CIPHER_RIJNDAEL256; 121 gcryalg = GCRY_CIPHER_RIJNDAEL256;
120 break; 122 break;
121 123
122 case GC_3DES: 124 case GC_3DES:
123 gcryalg = GCRY_CIPHER_3DES; 125 gcryalg = GCRY_CIPHER_3DES;
124 break; 126 break;
125 127
126 case GC_DES: 128 case GC_DES:
127 gcryalg = GCRY_CIPHER_DES; 129 gcryalg = GCRY_CIPHER_DES;
128 break; 130 break;
129 131
130 case GC_ARCFOUR128: 132 case GC_ARCFOUR128:
131 case GC_ARCFOUR40: 133 case GC_ARCFOUR40:
132 gcryalg = GCRY_CIPHER_ARCFOUR; 134 gcryalg = GCRY_CIPHER_ARCFOUR;
133 break; 135 break;
134 136
135 case GC_ARCTWO40: 137 case GC_ARCTWO40:
136 gcryalg = GCRY_CIPHER_RFC2268_40; 138 gcryalg = GCRY_CIPHER_RFC2268_40;
137 break; 139 break;
138 140
139#ifdef ENABLE_CAMELLIA 141#ifdef ENABLE_CAMELLIA
140 case GC_CAMELLIA128: 142 case GC_CAMELLIA128:
141 gcryalg = GCRY_CIPHER_CAMELLIA128; 143 gcryalg = GCRY_CIPHER_CAMELLIA128;
142 break; 144 break;
143 145
144 case GC_CAMELLIA256: 146 case GC_CAMELLIA256:
145 gcryalg = GCRY_CIPHER_CAMELLIA256; 147 gcryalg = GCRY_CIPHER_CAMELLIA256;
146 break; 148 break;
147#endif 149#endif
148 150
149 default: 151 default:
150 return GC_INVALID_CIPHER; 152 return GC_INVALID_CIPHER;
151 } 153 }
152 154
153 switch (mode) 155 switch (mode)
154 { 156 {
155 case GC_ECB: 157 case GC_ECB:
156 gcrymode = GCRY_CIPHER_MODE_ECB; 158 gcrymode = GCRY_CIPHER_MODE_ECB;
157 break; 159 break;
158 160
159 case GC_CBC: 161 case GC_CBC:
160 gcrymode = GCRY_CIPHER_MODE_CBC; 162 gcrymode = GCRY_CIPHER_MODE_CBC;
161 break; 163 break;
162 164
163 case GC_STREAM: 165 case GC_STREAM:
164 gcrymode = GCRY_CIPHER_MODE_STREAM; 166 gcrymode = GCRY_CIPHER_MODE_STREAM;
165 break; 167 break;
166 168
167 default: 169 default:
168 return GC_INVALID_CIPHER; 170 return GC_INVALID_CIPHER;
169 } 171 }
170 172
171 err = gcry_cipher_open((gcry_cipher_hd_t *) outhandle, gcryalg, gcrymode, 0); 173 err =
172 if (gcry_err_code(err)) 174 gcry_cipher_open ((gcry_cipher_hd_t *) outhandle, gcryalg, gcrymode, 0);
175 if (gcry_err_code (err))
173 return GC_INVALID_CIPHER; 176 return GC_INVALID_CIPHER;
174 177
175 return GC_OK; 178 return GC_OK;
176} 179}
177 180
178Gc_rc gc_cipher_setkey(gc_cipher_handle handle, 181Gc_rc
179 size_t keylen, 182gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
180 const char *key)
181{ 183{
182 gcry_error_t err; 184 gcry_error_t err;
183 185
184 err = gcry_cipher_setkey ((gcry_cipher_hd_t) handle, key, keylen); 186 err = gcry_cipher_setkey ((gcry_cipher_hd_t) handle, key, keylen);
185 if (gcry_err_code(err)) 187 if (gcry_err_code (err))
186 return GC_INVALID_CIPHER; 188 return GC_INVALID_CIPHER;
187 189
188 return GC_OK; 190 return GC_OK;
189} 191}
190 192
191Gc_rc gc_cipher_setiv(gc_cipher_handle handle, 193Gc_rc
192 size_t ivlen, 194gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
193 const char *iv)
194{ 195{
195 gcry_error_t err; 196 gcry_error_t err;
196 197
197 err = gcry_cipher_setiv ((gcry_cipher_hd_t) handle, iv, ivlen); 198 err = gcry_cipher_setiv ((gcry_cipher_hd_t) handle, iv, ivlen);
198 if (gcry_err_code(err)) 199 if (gcry_err_code (err))
199 return GC_INVALID_CIPHER; 200 return GC_INVALID_CIPHER;
200 201
201 return GC_OK; 202 return GC_OK;
202} 203}
203 204
204Gc_rc gc_cipher_encrypt_inline(gc_cipher_handle handle, 205Gc_rc
205 size_t len, 206gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
206 char *data)
207{ 207{
208 if (gcry_cipher_encrypt((gcry_cipher_hd_t) handle, data, len, NULL, len) != 0) 208 if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle, data, len, NULL, len) !=
209 0)
209 return GC_INVALID_CIPHER; 210 return GC_INVALID_CIPHER;
210 211
211 return GC_OK; 212 return GC_OK;
212} 213}
213 214
214Gc_rc gc_cipher_decrypt_inline(gc_cipher_handle handle, 215Gc_rc
215 size_t len, 216gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
216 char *data)
217{ 217{
218 if (gcry_cipher_decrypt((gcry_cipher_hd_t) handle, data, len, NULL, len) != 0) 218 if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle, data, len, NULL, len) !=
219 0)
219 return GC_INVALID_CIPHER; 220 return GC_INVALID_CIPHER;
220 221
221 return GC_OK; 222 return GC_OK;
222} 223}
223 224
224Gc_rc gc_cipher_close(gc_cipher_handle handle) 225Gc_rc
226gc_cipher_close (gc_cipher_handle handle)
225{ 227{
226 gcry_cipher_close(handle); 228 gcry_cipher_close (handle);
227 229
228 return GC_OK; 230 return GC_OK;
229} 231}
@@ -231,22 +233,21 @@ Gc_rc gc_cipher_close(gc_cipher_handle handle)
231/* Hashes. */ 233/* Hashes. */
232 234
233typedef struct _gc_hash_ctx 235typedef struct _gc_hash_ctx
234 { 236{
235 Gc_hash alg; 237 Gc_hash alg;
236 Gc_hash_mode mode; 238 Gc_hash_mode mode;
237 gcry_md_hd_t gch; 239 gcry_md_hd_t gch;
238 } _gc_hash_ctx; 240} _gc_hash_ctx;
239 241
240Gc_rc gc_hash_open(Gc_hash hash, 242Gc_rc
241 Gc_hash_mode mode, 243gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
242 gc_hash_handle * outhandle)
243{ 244{
244 _gc_hash_ctx *ctx; 245 _gc_hash_ctx *ctx;
245 int gcryalg = 0, gcrymode = 0; 246 int gcryalg = 0, gcrymode = 0;
246 gcry_error_t err; 247 gcry_error_t err;
247 Gc_rc rc = GC_OK; 248 Gc_rc rc = GC_OK;
248 249
249 ctx = calloc(sizeof (*ctx), 1); 250 ctx = calloc (sizeof (*ctx), 1);
250 if (!ctx) 251 if (!ctx)
251 return GC_MALLOC_ERROR; 252 return GC_MALLOC_ERROR;
252 253
@@ -255,226 +256,225 @@ Gc_rc gc_hash_open(Gc_hash hash,
255 256
256 switch (hash) 257 switch (hash)
257 { 258 {
258 case GC_MD2: 259 case GC_MD2:
259 gcryalg = GCRY_MD_NONE; 260 gcryalg = GCRY_MD_NONE;
260 break; 261 break;
261 262
262 case GC_MD4: 263 case GC_MD4:
263 gcryalg = GCRY_MD_MD4; 264 gcryalg = GCRY_MD_MD4;
264 break; 265 break;
265 266
266 case GC_MD5: 267 case GC_MD5:
267 gcryalg = GCRY_MD_MD5; 268 gcryalg = GCRY_MD_MD5;
268 break; 269 break;
269 270
270 case GC_SHA1: 271 case GC_SHA1:
271 gcryalg = GCRY_MD_SHA1; 272 gcryalg = GCRY_MD_SHA1;
272 break; 273 break;
273 274
274 case GC_SHA256: 275 case GC_SHA256:
275 gcryalg = GCRY_MD_SHA256; 276 gcryalg = GCRY_MD_SHA256;
276 break; 277 break;
277 278
278 case GC_SHA384: 279 case GC_SHA384:
279 gcryalg = GCRY_MD_SHA384; 280 gcryalg = GCRY_MD_SHA384;
280 break; 281 break;
281 282
282 case GC_SHA512: 283 case GC_SHA512:
283 gcryalg = GCRY_MD_SHA512; 284 gcryalg = GCRY_MD_SHA512;
284 break; 285 break;
285 286
286 case GC_RMD160: 287 case GC_RMD160:
287 gcryalg = GCRY_MD_RMD160; 288 gcryalg = GCRY_MD_RMD160;
288 break; 289 break;
289 290
290 default: 291 default:
291 rc = GC_INVALID_HASH; 292 rc = GC_INVALID_HASH;
292 } 293 }
293 294
294 switch (mode) 295 switch (mode)
295 { 296 {
296 case 0: 297 case 0:
297 gcrymode = 0; 298 gcrymode = 0;
298 break; 299 break;
299 300
300 case GC_HMAC: 301 case GC_HMAC:
301 gcrymode = GCRY_MD_FLAG_HMAC; 302 gcrymode = GCRY_MD_FLAG_HMAC;
302 break; 303 break;
303 304
304 default: 305 default:
305 rc = GC_INVALID_HASH; 306 rc = GC_INVALID_HASH;
306 } 307 }
307 308
308 if (rc == GC_OK && gcryalg != GCRY_MD_NONE) 309 if (rc == GC_OK && gcryalg != GCRY_MD_NONE)
309 { 310 {
310 err = gcry_md_open(&ctx->gch, gcryalg, gcrymode); 311 err = gcry_md_open (&ctx->gch, gcryalg, gcrymode);
311 if (gcry_err_code(err)) 312 if (gcry_err_code (err))
312 rc = GC_INVALID_HASH; 313 rc = GC_INVALID_HASH;
313 } 314 }
314 315
315 if (rc == GC_OK) 316 if (rc == GC_OK)
316 *outhandle = ctx; 317 *outhandle = ctx;
317 else 318 else
318 free(ctx); 319 free (ctx);
319 320
320 return rc; 321 return rc;
321} 322}
322 323
323Gc_rc gc_hash_clone(gc_hash_handle handle, 324Gc_rc
324 gc_hash_handle * outhandle) 325gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
325{ 326{
326 _gc_hash_ctx *in = handle; 327 _gc_hash_ctx *in = handle;
327 _gc_hash_ctx *out; 328 _gc_hash_ctx *out;
328 int err; 329 int err;
329 330
330 *outhandle = out = calloc(sizeof (*out), 1); 331 *outhandle = out = calloc (sizeof (*out), 1);
331 if (!out) 332 if (!out)
332 return GC_MALLOC_ERROR; 333 return GC_MALLOC_ERROR;
333 334
334 memcpy(out, in, sizeof (*out)); 335 memcpy (out, in, sizeof (*out));
335 336
336 err = gcry_md_copy(&out->gch, in->gch); 337 err = gcry_md_copy (&out->gch, in->gch);
337 if (err) 338 if (err)
338 { 339 {
339 free(out); 340 free (out);
340 return GC_INVALID_HASH; 341 return GC_INVALID_HASH;
341 } 342 }
342 343
343 return GC_OK; 344 return GC_OK;
344} 345}
345 346
346size_t gc_hash_digest_length(Gc_hash hash) 347size_t
348gc_hash_digest_length (Gc_hash hash)
347{ 349{
348 size_t len; 350 size_t len;
349 351
350 switch (hash) 352 switch (hash)
351 { 353 {
352 case GC_MD2: 354 case GC_MD2:
353 len = GC_MD2_DIGEST_SIZE; 355 len = GC_MD2_DIGEST_SIZE;
354 break; 356 break;
355 357
356 case GC_MD4: 358 case GC_MD4:
357 len = GC_MD4_DIGEST_SIZE; 359 len = GC_MD4_DIGEST_SIZE;
358 break; 360 break;
359 361
360 case GC_MD5: 362 case GC_MD5:
361 len = GC_MD5_DIGEST_SIZE; 363 len = GC_MD5_DIGEST_SIZE;
362 break; 364 break;
363 365
364 case GC_RMD160: 366 case GC_RMD160:
365 len = GC_RMD160_DIGEST_SIZE; 367 len = GC_RMD160_DIGEST_SIZE;
366 break; 368 break;
367 369
368 case GC_SHA1: 370 case GC_SHA1:
369 len = GC_SHA1_DIGEST_SIZE; 371 len = GC_SHA1_DIGEST_SIZE;
370 break; 372 break;
371 373
372 case GC_SHA256: 374 case GC_SHA256:
373 len = GC_SHA256_DIGEST_SIZE; 375 len = GC_SHA256_DIGEST_SIZE;
374 break; 376 break;
375 377
376 case GC_SHA384: 378 case GC_SHA384:
377 len = GC_SHA384_DIGEST_SIZE; 379 len = GC_SHA384_DIGEST_SIZE;
378 break; 380 break;
379 381
380 case GC_SHA512: 382 case GC_SHA512:
381 len = GC_SHA512_DIGEST_SIZE; 383 len = GC_SHA512_DIGEST_SIZE;
382 break; 384 break;
383 385
384 default: 386 default:
385 return 0; 387 return 0;
386 } 388 }
387 389
388 return len; 390 return len;
389} 391}
390 392
391void gc_hash_hmac_setkey(gc_hash_handle handle, 393void
392 size_t len, 394gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key)
393 const char *key)
394{ 395{
395 _gc_hash_ctx *ctx = handle; 396 _gc_hash_ctx *ctx = handle;
396 gcry_md_setkey(ctx->gch, key, len); 397 gcry_md_setkey (ctx->gch, key, len);
397} 398}
398 399
399void gc_hash_write(gc_hash_handle handle, 400void
400 size_t len, 401gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
401 const char *data)
402{ 402{
403 _gc_hash_ctx *ctx = handle; 403 _gc_hash_ctx *ctx = handle;
404 gcry_md_write(ctx->gch, data, len); 404 gcry_md_write (ctx->gch, data, len);
405} 405}
406 406
407const char * gc_hash_read(gc_hash_handle handle) 407const char *
408gc_hash_read (gc_hash_handle handle)
408{ 409{
409 _gc_hash_ctx *ctx = handle; 410 _gc_hash_ctx *ctx = handle;
410 const char *digest; 411 const char *digest;
411 { 412 {
412 gcry_md_final (ctx->gch); 413 gcry_md_final (ctx->gch);
413 digest = gcry_md_read(ctx->gch, 0); 414 digest = gcry_md_read (ctx->gch, 0);
414 } 415 }
415 416
416 return digest; 417 return digest;
417} 418}
418 419
419void gc_hash_close(gc_hash_handle handle) 420void
421gc_hash_close (gc_hash_handle handle)
420{ 422{
421 _gc_hash_ctx *ctx = handle; 423 _gc_hash_ctx *ctx = handle;
422 424
423 gcry_md_close(ctx->gch); 425 gcry_md_close (ctx->gch);
424 426
425 free(ctx); 427 free (ctx);
426} 428}
427 429
428Gc_rc gc_hash_buffer(Gc_hash hash, 430Gc_rc
429 const void *in, 431gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
430 size_t inlen,
431 char *resbuf)
432{ 432{
433 int gcryalg; 433 int gcryalg;
434 434
435 switch (hash) 435 switch (hash)
436 { 436 {
437#ifdef GNULIB_GC_MD5 437#ifdef GNULIB_GC_MD5
438 case GC_MD5: 438 case GC_MD5:
439 gcryalg = GCRY_MD_MD5; 439 gcryalg = GCRY_MD_MD5;
440 break; 440 break;
441#endif 441#endif
442 442
443#ifdef GNULIB_GC_SHA1 443#ifdef GNULIB_GC_SHA1
444 case GC_SHA1: 444 case GC_SHA1:
445 gcryalg = GCRY_MD_SHA1; 445 gcryalg = GCRY_MD_SHA1;
446 break; 446 break;
447#endif 447#endif
448 448
449#ifdef GNULIB_GC_SHA256 449#ifdef GNULIB_GC_SHA256
450 case GC_SHA256: 450 case GC_SHA256:
451 gcryalg = GCRY_MD_SHA256; 451 gcryalg = GCRY_MD_SHA256;
452 break; 452 break;
453#endif 453#endif
454 454
455#ifdef GNULIB_GC_SHA384 455#ifdef GNULIB_GC_SHA384
456 case GC_SHA384: 456 case GC_SHA384:
457 gcryalg = GCRY_MD_SHA384; 457 gcryalg = GCRY_MD_SHA384;
458 break; 458 break;
459#endif 459#endif
460 460
461#ifdef GNULIB_GC_SHA512 461#ifdef GNULIB_GC_SHA512
462 case GC_SHA512: 462 case GC_SHA512:
463 gcryalg = GCRY_MD_SHA512; 463 gcryalg = GCRY_MD_SHA512;
464 break; 464 break;
465#endif 465#endif
466 466
467#ifdef GNULIB_GC_RMD160 467#ifdef GNULIB_GC_RMD160
468 case GC_RMD160: 468 case GC_RMD160:
469 gcryalg = GCRY_MD_RMD160; 469 gcryalg = GCRY_MD_RMD160;
470 break; 470 break;
471#endif 471#endif
472 472
473 default: 473 default:
474 return GC_INVALID_HASH; 474 return GC_INVALID_HASH;
475 } 475 }
476 476
477 gcry_md_hash_buffer(gcryalg, resbuf, in, inlen); 477 gcry_md_hash_buffer (gcryalg, resbuf, in, inlen);
478 478
479 return GC_OK; 479 return GC_OK;
480} 480}
@@ -483,144 +483,142 @@ Gc_rc gc_hash_buffer(Gc_hash hash,
483#ifdef GNULIB_GC_MD5 483#ifdef GNULIB_GC_MD5
484Gc_rc 484Gc_rc
485gc_md5 (const void *in, size_t inlen, void *resbuf) 485gc_md5 (const void *in, size_t inlen, void *resbuf)
486 { 486{
487 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5); 487 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
488 gcry_md_hd_t hd; 488 gcry_md_hd_t hd;
489 gpg_error_t err; 489 gpg_error_t err;
490 unsigned char *p; 490 unsigned char *p;
491 491
492 assert (outlen == GC_MD5_DIGEST_SIZE); 492 assert (outlen == GC_MD5_DIGEST_SIZE);
493 493
494 err = gcry_md_open (&hd, GCRY_MD_MD5, 0); 494 err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
495 if (err != GPG_ERR_NO_ERROR) 495 if (err != GPG_ERR_NO_ERROR)
496 return GC_INVALID_HASH; 496 return GC_INVALID_HASH;
497 497
498 gcry_md_write (hd, in, inlen); 498 gcry_md_write (hd, in, inlen);
499 499
500 p = gcry_md_read (hd, GCRY_MD_MD5); 500 p = gcry_md_read (hd, GCRY_MD_MD5);
501 if (p == NULL) 501 if (p == NULL)
502 { 502 {
503 gcry_md_close (hd); 503 gcry_md_close (hd);
504 return GC_INVALID_HASH; 504 return GC_INVALID_HASH;
505 } 505 }
506 506
507 memcpy (resbuf, p, outlen); 507 memcpy (resbuf, p, outlen);
508 508
509 gcry_md_close (hd); 509 gcry_md_close (hd);
510 510
511 return GC_OK; 511 return GC_OK;
512 } 512}
513#endif 513#endif
514 514
515#ifdef GNULIB_GC_SHA1 515#ifdef GNULIB_GC_SHA1
516Gc_rc 516Gc_rc
517gc_sha1 (const void *in, size_t inlen, void *resbuf) 517gc_sha1 (const void *in, size_t inlen, void *resbuf)
518 { 518{
519 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1); 519 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
520 gcry_md_hd_t hd; 520 gcry_md_hd_t hd;
521 gpg_error_t err; 521 gpg_error_t err;
522 unsigned char *p; 522 unsigned char *p;
523 523
524 assert (outlen == GC_SHA1_DIGEST_SIZE); 524 assert (outlen == GC_SHA1_DIGEST_SIZE);
525 525
526 err = gcry_md_open (&hd, GCRY_MD_SHA1, 0); 526 err = gcry_md_open (&hd, GCRY_MD_SHA1, 0);
527 if (err != GPG_ERR_NO_ERROR) 527 if (err != GPG_ERR_NO_ERROR)
528 return GC_INVALID_HASH; 528 return GC_INVALID_HASH;
529 529
530 gcry_md_write (hd, in, inlen); 530 gcry_md_write (hd, in, inlen);
531 531
532 p = gcry_md_read (hd, GCRY_MD_SHA1); 532 p = gcry_md_read (hd, GCRY_MD_SHA1);
533 if (p == NULL) 533 if (p == NULL)
534 { 534 {
535 gcry_md_close (hd); 535 gcry_md_close (hd);
536 return GC_INVALID_HASH; 536 return GC_INVALID_HASH;
537 } 537 }
538 538
539 memcpy (resbuf, p, outlen); 539 memcpy (resbuf, p, outlen);
540 540
541 gcry_md_close (hd); 541 gcry_md_close (hd);
542 542
543 return GC_OK; 543 return GC_OK;
544 } 544}
545#endif 545#endif
546 546
547#ifdef GNULIB_GC_HMAC_MD5 547#ifdef GNULIB_GC_HMAC_MD5
548Gc_rc 548Gc_rc
549gc_hmac_md5 (const void *key, size_t keylen, 549gc_hmac_md5 (const void *key, size_t keylen,
550 const void *in, size_t inlen, char *resbuf) 550 const void *in, size_t inlen, char *resbuf)
551 { 551{
552 size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5); 552 size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
553 gcry_md_hd_t mdh; 553 gcry_md_hd_t mdh;
554 unsigned char *hash; 554 unsigned char *hash;
555 gpg_error_t err; 555 gpg_error_t err;
556 556
557 assert (hlen == 16); 557 assert (hlen == 16);
558 558
559 err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC); 559 err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
560 if (err != GPG_ERR_NO_ERROR) 560 if (err != GPG_ERR_NO_ERROR)
561 return GC_INVALID_HASH; 561 return GC_INVALID_HASH;
562 562
563 err = gcry_md_setkey (mdh, key, keylen); 563 err = gcry_md_setkey (mdh, key, keylen);
564 if (err != GPG_ERR_NO_ERROR) 564 if (err != GPG_ERR_NO_ERROR)
565 { 565 {
566 gcry_md_close (mdh); 566 gcry_md_close (mdh);
567 return GC_INVALID_HASH; 567 return GC_INVALID_HASH;
568 } 568 }
569 569
570 gcry_md_write (mdh, in, inlen); 570 gcry_md_write (mdh, in, inlen);
571 571
572 hash = gcry_md_read (mdh, GCRY_MD_MD5); 572 hash = gcry_md_read (mdh, GCRY_MD_MD5);
573 if (hash == NULL) 573 if (hash == NULL)
574 { 574 {
575 gcry_md_close (mdh); 575 gcry_md_close (mdh);
576 return GC_INVALID_HASH; 576 return GC_INVALID_HASH;
577 } 577 }
578 578
579 memcpy (resbuf, hash, hlen); 579 memcpy (resbuf, hash, hlen);
580 580
581 gcry_md_close (mdh); 581 gcry_md_close (mdh);
582 582
583 return GC_OK; 583 return GC_OK;
584 } 584}
585#endif 585#endif
586 586
587#ifdef GNULIB_GC_HMAC_SHA1 587#ifdef GNULIB_GC_HMAC_SHA1
588Gc_rc gc_hmac_sha1(const void *key, 588Gc_rc
589 size_t keylen, 589gc_hmac_sha1 (const void *key,
590 const void *in, 590 size_t keylen, const void *in, size_t inlen, char *resbuf)
591 size_t inlen,
592 char *resbuf)
593{ 591{
594 size_t hlen = gcry_md_get_algo_dlen(GCRY_MD_SHA1); 592 size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
595 gcry_md_hd_t mdh; 593 gcry_md_hd_t mdh;
596 unsigned char *hash; 594 unsigned char *hash;
597 gpg_error_t err; 595 gpg_error_t err;
598 596
599 assert (hlen == GC_SHA1_DIGEST_SIZE); 597 assert (hlen == GC_SHA1_DIGEST_SIZE);
600 598
601 err = gcry_md_open(&mdh, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC); 599 err = gcry_md_open (&mdh, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
602 if (err != GPG_ERR_NO_ERROR) 600 if (err != GPG_ERR_NO_ERROR)
603 return GC_INVALID_HASH; 601 return GC_INVALID_HASH;
604 602
605 err = gcry_md_setkey(mdh, key, keylen); 603 err = gcry_md_setkey (mdh, key, keylen);
606 if (err != GPG_ERR_NO_ERROR) 604 if (err != GPG_ERR_NO_ERROR)
607 { 605 {
608 gcry_md_close(mdh); 606 gcry_md_close (mdh);
609 return GC_INVALID_HASH; 607 return GC_INVALID_HASH;
610 } 608 }
611 609
612 gcry_md_write(mdh, in, inlen); 610 gcry_md_write (mdh, in, inlen);
613 611
614 hash = gcry_md_read(mdh, GCRY_MD_SHA1); 612 hash = gcry_md_read (mdh, GCRY_MD_SHA1);
615 if (hash == NULL) 613 if (hash == NULL)
616 { 614 {
617 gcry_md_close(mdh); 615 gcry_md_close (mdh);
618 return GC_INVALID_HASH; 616 return GC_INVALID_HASH;
619 } 617 }
620 618
621 memcpy(resbuf, hash, hlen); 619 memcpy (resbuf, hash, hlen);
622 620
623 gcry_md_close(mdh); 621 gcry_md_close (mdh);
624 622
625 return GC_OK; 623 return GC_OK;
626} 624}
diff --git a/src/daemon/https/openpgp/gnutls_extra.c b/src/daemon/https/openpgp/gnutls_extra.c
index 95286102..55166644 100644
--- a/src/daemon/https/openpgp/gnutls_extra.c
+++ b/src/daemon/https/openpgp/gnutls_extra.c
@@ -55,11 +55,6 @@ gnutls_global_init_extra (void)
55 * libextra, then do not initialize the library. 55 * libextra, then do not initialize the library.
56 * This is because it may break things. 56 * This is because it may break things.
57 */ 57 */
58 if (strcmp (gnutls_check_version (NULL), VERSION) != 0)
59 {
60 return GNUTLS_E_LIBRARY_VERSION_MISMATCH;
61 }
62
63 _gnutls_init_extra++; 58 _gnutls_init_extra++;
64 59
65 if (_gnutls_init_extra != 1) 60 if (_gnutls_init_extra != 1)
diff --git a/src/daemon/https/openpgp/gnutls_ia.c b/src/daemon/https/openpgp/gnutls_ia.c
index 55b22e9c..def4a589 100644
--- a/src/daemon/https/openpgp/gnutls_ia.c
+++ b/src/daemon/https/openpgp/gnutls_ia.c
@@ -461,7 +461,7 @@ _gnutls_ia_client_handshake (gnutls_session_t session)
461 ssize_t len; 461 ssize_t len;
462 int ret; 462 int ret;
463 const struct gnutls_ia_client_credentials_st *cred = 463 const struct gnutls_ia_client_credentials_st *cred =
464 _gnutls_get_cred (session->key, GNUTLS_CRD_IA, NULL); 464 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
465 465
466 if (cred == NULL) 466 if (cred == NULL)
467 return GNUTLS_E_INTERNAL_ERROR; 467 return GNUTLS_E_INTERNAL_ERROR;
@@ -529,7 +529,7 @@ _gnutls_ia_server_handshake (gnutls_session_t session)
529 char buf[1024]; 529 char buf[1024];
530 int ret; 530 int ret;
531 const struct gnutls_ia_server_credentials_st *cred = 531 const struct gnutls_ia_server_credentials_st *cred =
532 _gnutls_get_cred (session->key, GNUTLS_CRD_IA, NULL); 532 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
533 533
534 if (cred == NULL) 534 if (cred == NULL)
535 return GNUTLS_E_INTERNAL_ERROR; 535 return GNUTLS_E_INTERNAL_ERROR;
diff --git a/src/daemon/https/openpgp/gnutls_openpgp.c b/src/daemon/https/openpgp/gnutls_openpgp.c
index af798bcd..61f79da8 100644
--- a/src/daemon/https/openpgp/gnutls_openpgp.c
+++ b/src/daemon/https/openpgp/gnutls_openpgp.c
@@ -112,10 +112,10 @@ openpgp_pk_to_gnutls_cert (gnutls_cert * cert, cdk_pkt_pubkey_t pk)
112 return GNUTLS_E_UNWANTED_ALGORITHM; 112 return GNUTLS_E_UNWANTED_ALGORITHM;
113 } 113 }
114 114
115 algo = GNUTLS_PK_RSA; 115 algo = MHD_GNUTLS_PK_RSA;
116 cert->subject_pk_algorithm = algo; 116 cert->subject_pk_algorithm = algo;
117 cert->version = pk->version; 117 cert->version = pk->version;
118 cert->cert_type = GNUTLS_CRT_OPENPGP; 118 cert->cert_type = MHD_GNUTLS_CRT_OPENPGP;
119 119
120 cert->key_usage = 0; 120 cert->key_usage = 0;
121 if (pk->pubkey_usage & CDK_KEY_USG_SIGN) 121 if (pk->pubkey_usage & CDK_KEY_USG_SIGN)
@@ -247,7 +247,7 @@ _gnutls_openpgp_raw_privkey_to_gkey (gnutls_privkey * pkey,
247 if (is_ELG (pke_algo)) 247 if (is_ELG (pke_algo))
248 return GNUTLS_E_UNWANTED_ALGORITHM; 248 return GNUTLS_E_UNWANTED_ALGORITHM;
249 else if (is_RSA (pke_algo)) 249 else if (is_RSA (pke_algo))
250 pkey->pk_algorithm = GNUTLS_PK_RSA; 250 pkey->pk_algorithm = MHD_GNUTLS_PK_RSA;
251 251
252leave: 252leave:
253 cdk_kbnode_release (snode); 253 cdk_kbnode_release (snode);
@@ -885,7 +885,7 @@ _gnutls_openpgp_crt_to_gcert (gnutls_cert * gcert, gnutls_openpgp_crt_t cert)
885 int ret; 885 int ret;
886 886
887 memset (gcert, 0, sizeof (gnutls_cert)); 887 memset (gcert, 0, sizeof (gnutls_cert));
888 gcert->cert_type = GNUTLS_CRT_OPENPGP; 888 gcert->cert_type = MHD_GNUTLS_CRT_OPENPGP;
889 889
890 890
891 ret = gnutls_openpgp_crt_export (cert, GNUTLS_OPENPGP_FMT_RAW, 891 ret = gnutls_openpgp_crt_export (cert, GNUTLS_OPENPGP_FMT_RAW,
diff --git a/src/daemon/https/openpgp/pgp.c b/src/daemon/https/openpgp/pgp.c
index d5e6ce09..84805d9a 100644
--- a/src/daemon/https/openpgp/pgp.c
+++ b/src/daemon/https/openpgp/pgp.c
@@ -337,7 +337,7 @@ gnutls_openpgp_crt_get_pk_algorithm (gnutls_openpgp_crt_t key,
337 int algo; 337 int algo;
338 338
339 if (!key) 339 if (!key)
340 return GNUTLS_PK_UNKNOWN; 340 return MHD_GNUTLS_PK_UNKNOWN;
341 341
342 algo = 0; 342 algo = 0;
343 pkt = cdk_kbnode_find_packet (key->knode, CDK_PKT_PUBLIC_KEY); 343 pkt = cdk_kbnode_find_packet (key->knode, CDK_PKT_PUBLIC_KEY);
@@ -347,7 +347,7 @@ gnutls_openpgp_crt_get_pk_algorithm (gnutls_openpgp_crt_t key,
347 *bits = cdk_pk_get_nbits (pkt->pkt.public_key); 347 *bits = cdk_pk_get_nbits (pkt->pkt.public_key);
348 algo = pkt->pkt.public_key->pubkey_algo; 348 algo = pkt->pkt.public_key->pubkey_algo;
349 if (is_RSA (algo)) 349 if (is_RSA (algo))
350 algo = GNUTLS_PK_RSA; 350 algo = MHD_GNUTLS_PK_RSA;
351 else 351 else
352 algo = GNUTLS_E_UNKNOWN_PK_ALGORITHM; 352 algo = GNUTLS_E_UNKNOWN_PK_ALGORITHM;
353 } 353 }
diff --git a/src/daemon/https/openpgp/pgp_privkey.c b/src/daemon/https/openpgp/pgp_privkey.c
index e09697eb..aee3599b 100644
--- a/src/daemon/https/openpgp/pgp_privkey.c
+++ b/src/daemon/https/openpgp/pgp_privkey.c
@@ -126,7 +126,7 @@ gnutls_openpgp_privkey_get_pk_algorithm (gnutls_openpgp_privkey_t key,
126 if (bits) 126 if (bits)
127 { 127 {
128 *bits = 0; 128 *bits = 0;
129 if (pk == GNUTLS_PK_RSA) 129 if (pk == MHD_GNUTLS_PK_RSA)
130 *bits = _gnutls_mpi_get_nbits (key->pkey.params[0]); 130 *bits = _gnutls_mpi_get_nbits (key->pkey.params[0]);
131 } 131 }
132 132
diff --git a/src/daemon/https/tests.c b/src/daemon/https/tests.c
index 35fc70e9..08db1dad 100644
--- a/src/daemon/https/tests.c
+++ b/src/daemon/https/tests.c
@@ -103,19 +103,20 @@ do_handshake (gnutls_session_t session)
103 return TEST_SUCCEED; 103 return TEST_SUCCEED;
104} 104}
105 105
106static int protocol_priority[16] = { GNUTLS_TLS1, GNUTLS_SSL3, 0 }; 106static int protocol_priority[16] = { GNUTLS_TLS1, MHD_GNUTLS_SSL3, 0 };
107static const int kx_priority[16] = 107static const int kx_priority[16] =
108 { GNUTLS_KX_RSA, GNUTLS_KX_DHE_DSS, GNUTLS_KX_DHE_RSA, 108 { MHD_GNUTLS_KX_RSA, MHD_GNUTLS_KX_DHE_DSS, MHD_GNUTLS_KX_DHE_RSA,
109 GNUTLS_KX_ANON_DH, 109 MHD_GNUTLS_KX_ANON_DH,
110 GNUTLS_KX_RSA_EXPORT, 0 110 MHD_GNUTLS_KX_RSA_EXPORT, 0
111}; 111};
112static const int cipher_priority[16] = 112static const int cipher_priority[16] =
113 { GNUTLS_CIPHER_3DES_CBC, GNUTLS_CIPHER_ARCFOUR_128, 113 { MHD_GNUTLS_CIPHER_3DES_CBC, MHD_GNUTLS_CIPHER_ARCFOUR_128,
114 GNUTLS_CIPHER_ARCFOUR_40, 0 114 MHD_GNUTLS_CIPHER_ARCFOUR_40, 0
115}; 115};
116static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 }; 116static const int comp_priority[16] = { MHD_GNUTLS_COMP_NULL, 0 };
117static const int mac_priority[16] = { GNUTLS_MAC_SHA1, GNUTLS_MAC_MD5, 0 }; 117static const int mac_priority[16] =
118static const int cert_type_priority[16] = { GNUTLS_CRT_X509, 0 }; 118 { MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_MAC_MD5, 0 };
119static const int cert_type_priority[16] = { MHD_GNUTLS_CRT_X509, 0 };
119 120
120#define ADD_ALL_CIPHERS(session) gnutls_cipher_set_priority(session, cipher_priority) 121#define ADD_ALL_CIPHERS(session) gnutls_cipher_set_priority(session, cipher_priority)
121#define ADD_ALL_COMP(session) gnutls_compression_set_priority(session, comp_priority) 122#define ADD_ALL_COMP(session) gnutls_compression_set_priority(session, comp_priority)
@@ -235,13 +236,13 @@ test_srp (gnutls_session_t session)
235 ADD_ALL_PROTOCOLS (session); 236 ADD_ALL_PROTOCOLS (session);
236 ADD_ALL_MACS (session); 237 ADD_ALL_MACS (session);
237 238
238 ADD_KX (session, GNUTLS_KX_SRP); 239 ADD_KX (session, MHD_GNUTLS_KX_SRP);
239 srp_detected = 0; 240 srp_detected = 0;
240 241
241 gnutls_srp_set_client_credentials_function (srp_cred, 242 gnutls_srp_set_client_credentials_function (srp_cred,
242 _test_srp_username_callback); 243 _test_srp_username_callback);
243 244
244 gnutls_credentials_set (session, GNUTLS_CRD_SRP, srp_cred); 245 gnutls_credentials_set (session, MHD_GNUTLS_CRD_SRP, srp_cred);
245 246
246 ret = do_handshake (session); 247 ret = do_handshake (session);
247 248
@@ -274,7 +275,7 @@ test_server (gnutls_session_t session)
274 ADD_ALL_MACS (session); 275 ADD_ALL_MACS (session);
275 ADD_ALL_KX (session); 276 ADD_ALL_KX (session);
276 277
277 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 278 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
278 279
279 ret = do_handshake (session); 280 ret = do_handshake (session);
280 if (ret != TEST_SUCCEED) 281 if (ret != TEST_SUCCEED)
@@ -321,9 +322,9 @@ test_export (gnutls_session_t session)
321 ADD_ALL_PROTOCOLS (session); 322 ADD_ALL_PROTOCOLS (session);
322 ADD_ALL_MACS (session); 323 ADD_ALL_MACS (session);
323 324
324 ADD_KX (session, GNUTLS_KX_RSA_EXPORT); 325 ADD_KX (session, MHD_GNUTLS_KX_RSA_EXPORT);
325 ADD_CIPHER (session, GNUTLS_CIPHER_ARCFOUR_40); 326 ADD_CIPHER (session, MHD_GNUTLS_CIPHER_ARCFOUR_40);
326 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 327 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
327 328
328 ret = do_handshake (session); 329 ret = do_handshake (session);
329 330
@@ -351,9 +352,9 @@ test_export_info (gnutls_session_t session)
351 ADD_ALL_PROTOCOLS (session); 352 ADD_ALL_PROTOCOLS (session);
352 ADD_ALL_MACS (session); 353 ADD_ALL_MACS (session);
353 354
354 ADD_KX (session, GNUTLS_KX_RSA_EXPORT); 355 ADD_KX (session, MHD_GNUTLS_KX_RSA_EXPORT);
355 ADD_CIPHER (session, GNUTLS_CIPHER_ARCFOUR_40); 356 ADD_CIPHER (session, MHD_GNUTLS_CIPHER_ARCFOUR_40);
356 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 357 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
357 358
358 ret = do_handshake (session); 359 ret = do_handshake (session);
359 360
@@ -399,8 +400,8 @@ test_dhe (gnutls_session_t session)
399 ADD_ALL_PROTOCOLS (session); 400 ADD_ALL_PROTOCOLS (session);
400 ADD_ALL_MACS (session); 401 ADD_ALL_MACS (session);
401 402
402 ADD_KX2 (session, GNUTLS_KX_DHE_RSA, GNUTLS_KX_DHE_DSS); 403 ADD_KX2 (session, MHD_GNUTLS_KX_DHE_RSA, MHD_GNUTLS_KX_DHE_DSS);
403 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 404 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
404 405
405 ret = do_handshake (session); 406 ret = do_handshake (session);
406 407
@@ -425,8 +426,8 @@ test_dhe_group (gnutls_session_t session)
425 ADD_ALL_PROTOCOLS (session); 426 ADD_ALL_PROTOCOLS (session);
426 ADD_ALL_MACS (session); 427 ADD_ALL_MACS (session);
427 428
428 ADD_KX2 (session, GNUTLS_KX_DHE_RSA, GNUTLS_KX_DHE_DSS); 429 ADD_KX2 (session, MHD_GNUTLS_KX_DHE_RSA, MHD_GNUTLS_KX_DHE_DSS);
429 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 430 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
430 431
431 ret = do_handshake (session); 432 ret = do_handshake (session);
432 433
@@ -464,10 +465,10 @@ test_ssl3 (gnutls_session_t session)
464 ADD_ALL_CIPHERS (session); 465 ADD_ALL_CIPHERS (session);
465 ADD_ALL_COMP (session); 466 ADD_ALL_COMP (session);
466 ADD_ALL_CERTTYPES (session); 467 ADD_ALL_CERTTYPES (session);
467 ADD_PROTOCOL (session, GNUTLS_SSL3); 468 ADD_PROTOCOL (session, MHD_GNUTLS_SSL3);
468 ADD_ALL_MACS (session); 469 ADD_ALL_MACS (session);
469 ADD_ALL_KX (session); 470 ADD_ALL_KX (session);
470 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 471 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
471 472
472 ret = do_handshake (session); 473 ret = do_handshake (session);
473 if (ret == TEST_SUCCEED) 474 if (ret == TEST_SUCCEED)
@@ -500,7 +501,7 @@ test_bye (gnutls_session_t session)
500 ADD_ALL_PROTOCOLS (session); 501 ADD_ALL_PROTOCOLS (session);
501 ADD_ALL_MACS (session); 502 ADD_ALL_MACS (session);
502 ADD_ALL_KX (session); 503 ADD_ALL_KX (session);
503 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 504 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
504 505
505 ret = do_handshake (session); 506 ret = do_handshake (session);
506 if (ret == TEST_FAILED) 507 if (ret == TEST_FAILED)
@@ -546,13 +547,13 @@ test_code_t
546test_aes (gnutls_session_t session) 547test_aes (gnutls_session_t session)
547{ 548{
548 int ret; 549 int ret;
549 ADD_CIPHER (session, GNUTLS_CIPHER_AES_128_CBC); 550 ADD_CIPHER (session, MHD_GNUTLS_CIPHER_AES_128_CBC);
550 ADD_ALL_COMP (session); 551 ADD_ALL_COMP (session);
551 ADD_ALL_CERTTYPES (session); 552 ADD_ALL_CERTTYPES (session);
552 ADD_ALL_PROTOCOLS (session); 553 ADD_ALL_PROTOCOLS (session);
553 ADD_ALL_MACS (session); 554 ADD_ALL_MACS (session);
554 ADD_ALL_KX (session); 555 ADD_ALL_KX (session);
555 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 556 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
556 557
557 ret = do_handshake (session); 558 ret = do_handshake (session);
558 return ret; 559 return ret;
@@ -563,13 +564,13 @@ test_code_t
563test_camellia (gnutls_session_t session) 564test_camellia (gnutls_session_t session)
564{ 565{
565 int ret; 566 int ret;
566 ADD_CIPHER (session, GNUTLS_CIPHER_CAMELLIA_128_CBC); 567 ADD_CIPHER (session, MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC);
567 ADD_ALL_COMP (session); 568 ADD_ALL_COMP (session);
568 ADD_ALL_CERTTYPES (session); 569 ADD_ALL_CERTTYPES (session);
569 ADD_ALL_PROTOCOLS (session); 570 ADD_ALL_PROTOCOLS (session);
570 ADD_ALL_MACS (session); 571 ADD_ALL_MACS (session);
571 ADD_ALL_KX (session); 572 ADD_ALL_KX (session);
572 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 573 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
573 574
574 ret = do_handshake (session); 575 ret = do_handshake (session);
575 return ret; 576 return ret;
@@ -582,17 +583,17 @@ test_openpgp1 (gnutls_session_t session)
582 int ret; 583 int ret;
583 ADD_ALL_CIPHERS (session); 584 ADD_ALL_CIPHERS (session);
584 ADD_ALL_COMP (session); 585 ADD_ALL_COMP (session);
585 ADD_CERTTYPE (session, GNUTLS_CRT_OPENPGP); 586 ADD_CERTTYPE (session, MHD_GNUTLS_CRT_OPENPGP);
586 ADD_ALL_PROTOCOLS (session); 587 ADD_ALL_PROTOCOLS (session);
587 ADD_ALL_MACS (session); 588 ADD_ALL_MACS (session);
588 ADD_ALL_KX (session); 589 ADD_ALL_KX (session);
589 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 590 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
590 591
591 ret = do_handshake (session); 592 ret = do_handshake (session);
592 if (ret == TEST_FAILED) 593 if (ret == TEST_FAILED)
593 return ret; 594 return ret;
594 595
595 if (gnutls_certificate_type_get (session) == GNUTLS_CRT_OPENPGP) 596 if (gnutls_certificate_type_get (session) == MHD_GNUTLS_CRT_OPENPGP)
596 return TEST_SUCCEED; 597 return TEST_SUCCEED;
597 598
598 return TEST_FAILED; 599 return TEST_FAILED;
@@ -603,18 +604,19 @@ test_unknown_ciphersuites (gnutls_session_t session)
603{ 604{
604 int ret; 605 int ret;
605#ifdef ENABLE_CAMELLIA 606#ifdef ENABLE_CAMELLIA
606 ADD_CIPHER4 (session, GNUTLS_CIPHER_AES_128_CBC, GNUTLS_CIPHER_3DES_CBC, 607 ADD_CIPHER4 (session, MHD_GNUTLS_CIPHER_AES_128_CBC,
607 GNUTLS_CIPHER_CAMELLIA_128_CBC, GNUTLS_CIPHER_ARCFOUR_128); 608 MHD_GNUTLS_CIPHER_3DES_CBC, MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC,
609 MHD_GNUTLS_CIPHER_ARCFOUR_128);
608#else 610#else
609 ADD_CIPHER4 (session, GNUTLS_CIPHER_AES_128_CBC, GNUTLS_CIPHER_3DES_CBC, 611 ADD_CIPHER4 (session, MHD_GNUTLS_CIPHER_AES_128_CBC,
610 GNUTLS_CIPHER_ARCFOUR_128, 0); 612 MHD_GNUTLS_CIPHER_3DES_CBC, MHD_GNUTLS_CIPHER_ARCFOUR_128, 0);
611#endif 613#endif
612 ADD_ALL_COMP (session); 614 ADD_ALL_COMP (session);
613 ADD_ALL_CERTTYPES (session); 615 ADD_ALL_CERTTYPES (session);
614 ADD_ALL_PROTOCOLS (session); 616 ADD_ALL_PROTOCOLS (session);
615 ADD_ALL_MACS (session); 617 ADD_ALL_MACS (session);
616 ADD_ALL_KX (session); 618 ADD_ALL_KX (session);
617 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 619 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
618 620
619 ret = do_handshake (session); 621 ret = do_handshake (session);
620 return ret; 622 return ret;
@@ -628,9 +630,9 @@ test_md5 (gnutls_session_t session)
628 ADD_ALL_COMP (session); 630 ADD_ALL_COMP (session);
629 ADD_ALL_CERTTYPES (session); 631 ADD_ALL_CERTTYPES (session);
630 ADD_ALL_PROTOCOLS (session); 632 ADD_ALL_PROTOCOLS (session);
631 ADD_MAC (session, GNUTLS_MAC_MD5); 633 ADD_MAC (session, MHD_GNUTLS_MAC_MD5);
632 ADD_ALL_KX (session); 634 ADD_ALL_KX (session);
633 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 635 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
634 636
635 ret = do_handshake (session); 637 ret = do_handshake (session);
636 return ret; 638 return ret;
@@ -647,7 +649,7 @@ test_zlib (gnutls_session_t session)
647 ADD_ALL_PROTOCOLS (session); 649 ADD_ALL_PROTOCOLS (session);
648 ADD_ALL_MACS (session); 650 ADD_ALL_MACS (session);
649 ADD_ALL_KX (session); 651 ADD_ALL_KX (session);
650 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 652 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
651 653
652 ret = do_handshake (session); 654 ret = do_handshake (session);
653 return ret; 655 return ret;
@@ -661,12 +663,12 @@ test_lzo (gnutls_session_t session)
661 gnutls_handshake_set_private_extensions (session, 1); 663 gnutls_handshake_set_private_extensions (session, 1);
662 664
663 ADD_ALL_CIPHERS (session); 665 ADD_ALL_CIPHERS (session);
664 ADD_COMP (session, GNUTLS_COMP_LZO); 666 ADD_COMP (session, MHD_GNUTLS_COMP_LZO);
665 ADD_ALL_CERTTYPES (session); 667 ADD_ALL_CERTTYPES (session);
666 ADD_ALL_PROTOCOLS (session); 668 ADD_ALL_PROTOCOLS (session);
667 ADD_ALL_MACS (session); 669 ADD_ALL_MACS (session);
668 ADD_ALL_KX (session); 670 ADD_ALL_KX (session);
669 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 671 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
670 672
671 ret = do_handshake (session); 673 ret = do_handshake (session);
672 674
@@ -681,9 +683,9 @@ test_sha (gnutls_session_t session)
681 ADD_ALL_COMP (session); 683 ADD_ALL_COMP (session);
682 ADD_ALL_CERTTYPES (session); 684 ADD_ALL_CERTTYPES (session);
683 ADD_ALL_PROTOCOLS (session); 685 ADD_ALL_PROTOCOLS (session);
684 ADD_MAC (session, GNUTLS_MAC_SHA1); 686 ADD_MAC (session, MHD_GNUTLS_MAC_SHA1);
685 ADD_ALL_KX (session); 687 ADD_ALL_KX (session);
686 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 688 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
687 689
688 ret = do_handshake (session); 690 ret = do_handshake (session);
689 return ret; 691 return ret;
@@ -693,13 +695,13 @@ test_code_t
693test_3des (gnutls_session_t session) 695test_3des (gnutls_session_t session)
694{ 696{
695 int ret; 697 int ret;
696 ADD_CIPHER (session, GNUTLS_CIPHER_3DES_CBC); 698 ADD_CIPHER (session, MHD_GNUTLS_CIPHER_3DES_CBC);
697 ADD_ALL_COMP (session); 699 ADD_ALL_COMP (session);
698 ADD_ALL_CERTTYPES (session); 700 ADD_ALL_CERTTYPES (session);
699 ADD_ALL_PROTOCOLS (session); 701 ADD_ALL_PROTOCOLS (session);
700 ADD_ALL_MACS (session); 702 ADD_ALL_MACS (session);
701 ADD_ALL_KX (session); 703 ADD_ALL_KX (session);
702 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 704 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
703 705
704 ret = do_handshake (session); 706 ret = do_handshake (session);
705 return ret; 707 return ret;
@@ -709,13 +711,13 @@ test_code_t
709test_arcfour (gnutls_session_t session) 711test_arcfour (gnutls_session_t session)
710{ 712{
711 int ret; 713 int ret;
712 ADD_CIPHER (session, GNUTLS_CIPHER_ARCFOUR_128); 714 ADD_CIPHER (session, MHD_GNUTLS_CIPHER_ARCFOUR_128);
713 ADD_ALL_COMP (session); 715 ADD_ALL_COMP (session);
714 ADD_ALL_CERTTYPES (session); 716 ADD_ALL_CERTTYPES (session);
715 ADD_ALL_PROTOCOLS (session); 717 ADD_ALL_PROTOCOLS (session);
716 ADD_ALL_MACS (session); 718 ADD_ALL_MACS (session);
717 ADD_ALL_KX (session); 719 ADD_ALL_KX (session);
718 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 720 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
719 721
720 ret = do_handshake (session); 722 ret = do_handshake (session);
721 return ret; 723 return ret;
@@ -725,13 +727,13 @@ test_code_t
725test_arcfour_40 (gnutls_session_t session) 727test_arcfour_40 (gnutls_session_t session)
726{ 728{
727 int ret; 729 int ret;
728 ADD_CIPHER (session, GNUTLS_CIPHER_ARCFOUR_40); 730 ADD_CIPHER (session, MHD_GNUTLS_CIPHER_ARCFOUR_40);
729 ADD_ALL_COMP (session); 731 ADD_ALL_COMP (session);
730 ADD_ALL_CERTTYPES (session); 732 ADD_ALL_CERTTYPES (session);
731 ADD_ALL_PROTOCOLS (session); 733 ADD_ALL_PROTOCOLS (session);
732 ADD_ALL_MACS (session); 734 ADD_ALL_MACS (session);
733 ADD_ALL_KX (session); 735 ADD_ALL_KX (session);
734 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 736 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
735 737
736 ret = do_handshake (session); 738 ret = do_handshake (session);
737 return ret; 739 return ret;
@@ -747,7 +749,7 @@ test_tls1 (gnutls_session_t session)
747 ADD_PROTOCOL (session, GNUTLS_TLS1); 749 ADD_PROTOCOL (session, GNUTLS_TLS1);
748 ADD_ALL_MACS (session); 750 ADD_ALL_MACS (session);
749 ADD_ALL_KX (session); 751 ADD_ALL_KX (session);
750 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 752 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
751 753
752 ret = do_handshake (session); 754 ret = do_handshake (session);
753 if (ret == TEST_SUCCEED) 755 if (ret == TEST_SUCCEED)
@@ -764,10 +766,10 @@ test_tls1_1 (gnutls_session_t session)
764 ADD_ALL_CIPHERS (session); 766 ADD_ALL_CIPHERS (session);
765 ADD_ALL_COMP (session); 767 ADD_ALL_COMP (session);
766 ADD_ALL_CERTTYPES (session); 768 ADD_ALL_CERTTYPES (session);
767 ADD_PROTOCOL (session, GNUTLS_TLS1_1); 769 ADD_PROTOCOL (session, MHD_GNUTLS_TLS1_1);
768 ADD_ALL_MACS (session); 770 ADD_ALL_MACS (session);
769 ADD_ALL_KX (session); 771 ADD_ALL_KX (session);
770 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 772 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
771 773
772 ret = do_handshake (session); 774 ret = do_handshake (session);
773 if (ret == TEST_SUCCEED) 775 if (ret == TEST_SUCCEED)
@@ -787,10 +789,10 @@ test_tls1_1_fallback (gnutls_session_t session)
787 ADD_ALL_CIPHERS (session); 789 ADD_ALL_CIPHERS (session);
788 ADD_ALL_COMP (session); 790 ADD_ALL_COMP (session);
789 ADD_ALL_CERTTYPES (session); 791 ADD_ALL_CERTTYPES (session);
790 ADD_PROTOCOL3 (session, GNUTLS_TLS1_1, GNUTLS_TLS1, GNUTLS_SSL3); 792 ADD_PROTOCOL3 (session, MHD_GNUTLS_TLS1_1, GNUTLS_TLS1, MHD_GNUTLS_SSL3);
791 ADD_ALL_MACS (session); 793 ADD_ALL_MACS (session);
792 ADD_ALL_KX (session); 794 ADD_ALL_KX (session);
793 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 795 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
794 796
795 ret = do_handshake (session); 797 ret = do_handshake (session);
796 if (ret != TEST_SUCCEED) 798 if (ret != TEST_SUCCEED)
@@ -798,7 +800,7 @@ test_tls1_1_fallback (gnutls_session_t session)
798 800
799 if (gnutls_protocol_get_version (session) == GNUTLS_TLS1) 801 if (gnutls_protocol_get_version (session) == GNUTLS_TLS1)
800 return TEST_SUCCEED; 802 return TEST_SUCCEED;
801 else if (gnutls_protocol_get_version (session) == GNUTLS_SSL3) 803 else if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
802 return TEST_UNSURE; 804 return TEST_UNSURE;
803 805
804 return TEST_FAILED; 806 return TEST_FAILED;
@@ -821,7 +823,7 @@ test_tls_disable (gnutls_session_t session)
821 ADD_ALL_PROTOCOLS (session); 823 ADD_ALL_PROTOCOLS (session);
822 ADD_ALL_MACS (session); 824 ADD_ALL_MACS (session);
823 ADD_ALL_KX (session); 825 ADD_ALL_KX (session);
824 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 826 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
825 827
826 ret = do_handshake (session); 828 ret = do_handshake (session);
827 if (ret == TEST_FAILED) 829 if (ret == TEST_FAILED)
@@ -829,7 +831,7 @@ test_tls_disable (gnutls_session_t session)
829 /* disable TLS 1.0 */ 831 /* disable TLS 1.0 */
830 if (ssl3_ok != 0) 832 if (ssl3_ok != 0)
831 { 833 {
832 protocol_priority[0] = GNUTLS_SSL3; 834 protocol_priority[0] = MHD_GNUTLS_SSL3;
833 protocol_priority[1] = 0; 835 protocol_priority[1] = 0;
834 } 836 }
835 } 837 }
@@ -852,8 +854,8 @@ test_rsa_pms (gnutls_session_t session)
852 ADD_ALL_CERTTYPES (session); 854 ADD_ALL_CERTTYPES (session);
853 ADD_ALL_PROTOCOLS (session); 855 ADD_ALL_PROTOCOLS (session);
854 ADD_ALL_MACS (session); 856 ADD_ALL_MACS (session);
855 ADD_KX (session, GNUTLS_KX_RSA); 857 ADD_KX (session, MHD_GNUTLS_KX_RSA);
856 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 858 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
857 859
858 ret = do_handshake (session); 860 ret = do_handshake (session);
859 if (ret == TEST_FAILED) 861 if (ret == TEST_FAILED)
@@ -874,7 +876,7 @@ test_max_record_size (gnutls_session_t session)
874 ADD_ALL_PROTOCOLS (session); 876 ADD_ALL_PROTOCOLS (session);
875 ADD_ALL_MACS (session); 877 ADD_ALL_MACS (session);
876 ADD_ALL_KX (session); 878 ADD_ALL_KX (session);
877 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 879 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
878 gnutls_record_set_max_size (session, 512); 880 gnutls_record_set_max_size (session, 512);
879 881
880 ret = do_handshake (session); 882 ret = do_handshake (session);
@@ -898,7 +900,7 @@ test_hello_extension (gnutls_session_t session)
898 ADD_ALL_PROTOCOLS (session); 900 ADD_ALL_PROTOCOLS (session);
899 ADD_ALL_MACS (session); 901 ADD_ALL_MACS (session);
900 ADD_ALL_KX (session); 902 ADD_ALL_KX (session);
901 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 903 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
902 gnutls_record_set_max_size (session, 512); 904 gnutls_record_set_max_size (session, 512);
903 905
904 ret = do_handshake (session); 906 ret = do_handshake (session);
@@ -929,14 +931,15 @@ test_version_rollback (gnutls_session_t session)
929 ADD_ALL_PROTOCOLS (session); 931 ADD_ALL_PROTOCOLS (session);
930 ADD_ALL_MACS (session); 932 ADD_ALL_MACS (session);
931 ADD_ALL_KX (session); 933 ADD_ALL_KX (session);
932 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 934 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
933 _gnutls_record_set_default_version (session, 3, 0); 935 _gnutls_record_set_default_version (session, 3, 0);
934 936
935 ret = do_handshake (session); 937 ret = do_handshake (session);
936 if (ret != TEST_SUCCEED) 938 if (ret != TEST_SUCCEED)
937 return ret; 939 return ret;
938 940
939 if (tls1_ok != 0 && gnutls_protocol_get_version (session) == GNUTLS_SSL3) 941 if (tls1_ok != 0
942 && gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
940 return TEST_FAILED; 943 return TEST_FAILED;
941 944
942 return TEST_SUCCEED; 945 return TEST_SUCCEED;
@@ -959,7 +962,7 @@ test_version_oob (gnutls_session_t session)
959 ADD_ALL_PROTOCOLS (session); 962 ADD_ALL_PROTOCOLS (session);
960 ADD_ALL_MACS (session); 963 ADD_ALL_MACS (session);
961 ADD_ALL_KX (session); 964 ADD_ALL_KX (session);
962 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 965 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
963 _gnutls_record_set_default_version (session, 5, 5); 966 _gnutls_record_set_default_version (session, 5, 5);
964 967
965 ret = do_handshake (session); 968 ret = do_handshake (session);
@@ -984,7 +987,7 @@ test_rsa_pms_version_check (gnutls_session_t session)
984 ADD_ALL_PROTOCOLS (session); 987 ADD_ALL_PROTOCOLS (session);
985 ADD_ALL_MACS (session); 988 ADD_ALL_MACS (session);
986 ADD_ALL_KX (session); 989 ADD_ALL_KX (session);
987 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 990 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
988 _gnutls_rsa_pms_set_version (session, 5, 5); /* use SSL 5.5 version */ 991 _gnutls_rsa_pms_set_version (session, 5, 5); /* use SSL 5.5 version */
989 992
990 ret = do_handshake (session); 993 ret = do_handshake (session);
@@ -1003,8 +1006,8 @@ test_anonymous (gnutls_session_t session)
1003 ADD_ALL_CERTTYPES (session); 1006 ADD_ALL_CERTTYPES (session);
1004 ADD_ALL_PROTOCOLS (session); 1007 ADD_ALL_PROTOCOLS (session);
1005 ADD_ALL_MACS (session); 1008 ADD_ALL_MACS (session);
1006 ADD_KX (session, GNUTLS_KX_ANON_DH); 1009 ADD_KX (session, MHD_GNUTLS_KX_ANON_DH);
1007 gnutls_credentials_set (session, GNUTLS_CRD_ANON, anon_cred); 1010 gnutls_credentials_set (session, MHD_GNUTLS_CRD_ANON, anon_cred);
1008 1011
1009 ret = do_handshake (session); 1012 ret = do_handshake (session);
1010 1013
@@ -1032,8 +1035,8 @@ test_session_resume2 (gnutls_session_t session)
1032 ADD_ALL_MACS (session); 1035 ADD_ALL_MACS (session);
1033 ADD_ALL_KX (session); 1036 ADD_ALL_KX (session);
1034 1037
1035 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 1038 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
1036 gnutls_credentials_set (session, GNUTLS_CRD_ANON, anon_cred); 1039 gnutls_credentials_set (session, MHD_GNUTLS_CRD_ANON, anon_cred);
1037 1040
1038 gnutls_session_set_data (session, session_data, session_data_size); 1041 gnutls_session_set_data (session, session_data, session_data_size);
1039 1042
@@ -1079,7 +1082,7 @@ test_certificate (gnutls_session_t session)
1079 ADD_ALL_MACS (session); 1082 ADD_ALL_MACS (session);
1080 ADD_ALL_KX (session); 1083 ADD_ALL_KX (session);
1081 1084
1082 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 1085 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
1083 1086
1084 ret = do_handshake (session); 1087 ret = do_handshake (session);
1085 if (ret == TEST_FAILED) 1088 if (ret == TEST_FAILED)
@@ -1148,7 +1151,7 @@ test_server_cas (gnutls_session_t session)
1148 ADD_ALL_MACS (session); 1151 ADD_ALL_MACS (session);
1149 ADD_ALL_KX (session); 1152 ADD_ALL_KX (session);
1150 1153
1151 gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); 1154 gnutls_credentials_set (session, MHD_GNUTLS_CRD_CERTIFICATE, xcred);
1152 gnutls_certificate_client_set_retrieve_function (xcred, cert_callback); 1155 gnutls_certificate_client_set_retrieve_function (xcred, cert_callback);
1153 1156
1154 ret = do_handshake (session); 1157 ret = do_handshake (session);
diff --git a/src/daemon/https/tls/auth_anon.c b/src/daemon/https/tls/auth_anon.c
index 18cad200..d32ef344 100644
--- a/src/daemon/https/tls/auth_anon.c
+++ b/src/daemon/https/tls/auth_anon.c
@@ -71,7 +71,7 @@ gen_anon_server_kx (gnutls_session_t session, opaque ** data)
71 gnutls_anon_server_credentials_t cred; 71 gnutls_anon_server_credentials_t cred;
72 72
73 cred = (gnutls_anon_server_credentials_t) 73 cred = (gnutls_anon_server_credentials_t)
74 _gnutls_get_cred (session->key, GNUTLS_CRD_ANON, NULL); 74 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
75 if (cred == NULL) 75 if (cred == NULL)
76 { 76 {
77 gnutls_assert (); 77 gnutls_assert ();
@@ -91,7 +91,7 @@ gen_anon_server_kx (gnutls_session_t session, opaque ** data)
91 g = mpis[1]; 91 g = mpis[1];
92 92
93 if ((ret = 93 if ((ret =
94 _gnutls_auth_info_set (session, GNUTLS_CRD_ANON, 94 _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
95 sizeof (anon_auth_info_st), 1)) < 0) 95 sizeof (anon_auth_info_st), 1)) < 0)
96 { 96 {
97 gnutls_assert (); 97 gnutls_assert ();
@@ -124,7 +124,7 @@ proc_anon_client_kx (gnutls_session_t session, opaque * data,
124 bits = _gnutls_dh_get_allowed_prime_bits (session); 124 bits = _gnutls_dh_get_allowed_prime_bits (session);
125 125
126 cred = (gnutls_anon_server_credentials_t) 126 cred = (gnutls_anon_server_credentials_t)
127 _gnutls_get_cred (session->key, GNUTLS_CRD_ANON, NULL); 127 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
128 if (cred == NULL) 128 if (cred == NULL)
129 { 129 {
130 gnutls_assert (); 130 gnutls_assert ();
@@ -158,7 +158,7 @@ proc_anon_server_kx (gnutls_session_t session, opaque * data,
158 158
159 /* set auth_info */ 159 /* set auth_info */
160 if ((ret = 160 if ((ret =
161 _gnutls_auth_info_set (session, GNUTLS_CRD_ANON, 161 _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
162 sizeof (anon_auth_info_st), 1)) < 0) 162 sizeof (anon_auth_info_st), 1)) < 0)
163 { 163 {
164 gnutls_assert (); 164 gnutls_assert ();
diff --git a/src/daemon/https/tls/auth_cert.c b/src/daemon/https/tls/auth_cert.c
index 43dcb777..c5c5d9f5 100644
--- a/src/daemon/https/tls/auth_cert.c
+++ b/src/daemon/https/tls/auth_cert.c
@@ -277,7 +277,7 @@ _find_openpgp_cert (const gnutls_certificate_credentials_t cred,
277 if ((_gnutls_check_pk_algo_in_list 277 if ((_gnutls_check_pk_algo_in_list
278 (pk_algos, pk_algos_length, 278 (pk_algos, pk_algos_length,
279 cred->cert_list[i][0].subject_pk_algorithm) == 0) 279 cred->cert_list[i][0].subject_pk_algorithm) == 0)
280 && (cred->cert_list[i][0].cert_type == GNUTLS_CRT_OPENPGP)) 280 && (cred->cert_list[i][0].cert_type == MHD_GNUTLS_CRT_OPENPGP))
281 { 281 {
282 *indx = i; 282 *indx = i;
283 break; 283 break;
@@ -350,7 +350,7 @@ get_issuers (gnutls_session_t session,
350 int i; 350 int i;
351 unsigned size; 351 unsigned size;
352 352
353 if (gnutls_certificate_type_get (session) != GNUTLS_CRT_X509) 353 if (gnutls_certificate_type_get (session) != MHD_GNUTLS_CRT_X509)
354 return 0; 354 return 0;
355 355
356 /* put the requested DNs to req_dn, only in case 356 /* put the requested DNs to req_dn, only in case
@@ -398,7 +398,7 @@ call_get_cert_callback (gnutls_session_t session,
398 gnutls_certificate_credentials_t cred; 398 gnutls_certificate_credentials_t cred;
399 399
400 cred = (gnutls_certificate_credentials_t) 400 cred = (gnutls_certificate_credentials_t)
401 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 401 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
402 if (cred == NULL) 402 if (cred == NULL)
403 { 403 {
404 gnutls_assert (); 404 gnutls_assert ();
@@ -435,7 +435,7 @@ call_get_cert_callback (gnutls_session_t session,
435 goto cleanup; 435 goto cleanup;
436 } 436 }
437 437
438 if (type == GNUTLS_CRT_X509) 438 if (type == MHD_GNUTLS_CRT_X509)
439 { 439 {
440 local_certs = alloc_and_load_x509_certs (st.cert.x509, st.ncerts); 440 local_certs = alloc_and_load_x509_certs (st.cert.x509, st.ncerts);
441 if (local_certs != NULL) 441 if (local_certs != NULL)
@@ -465,7 +465,7 @@ call_get_cert_callback (gnutls_session_t session,
465 465
466cleanup: 466cleanup:
467 467
468 if (st.type == GNUTLS_CRT_X509) 468 if (st.type == MHD_GNUTLS_CRT_X509)
469 { 469 {
470 if (st.deinit_all) 470 if (st.deinit_all)
471 { 471 {
@@ -517,7 +517,7 @@ _select_client_cert (gnutls_session_t session,
517 gnutls_datum_t *issuers_dn = NULL; 517 gnutls_datum_t *issuers_dn = NULL;
518 518
519 cred = (gnutls_certificate_credentials_t) 519 cred = (gnutls_certificate_credentials_t)
520 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 520 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
521 if (cred == NULL) 521 if (cred == NULL)
522 { 522 {
523 gnutls_assert (); 523 gnutls_assert ();
@@ -529,7 +529,7 @@ _select_client_cert (gnutls_session_t session,
529 529
530 /* use a callback to get certificate 530 /* use a callback to get certificate
531 */ 531 */
532 if (session->security_parameters.cert_type != GNUTLS_CRT_X509) 532 if (session->security_parameters.cert_type != MHD_GNUTLS_CRT_X509)
533 issuers_dn_length = 0; 533 issuers_dn_length = 0;
534 else 534 else
535 { 535 {
@@ -573,12 +573,12 @@ _select_client_cert (gnutls_session_t session,
573 */ 573 */
574 result = 0; 574 result = 0;
575 575
576 if (session->security_parameters.cert_type == GNUTLS_CRT_X509) 576 if (session->security_parameters.cert_type == MHD_GNUTLS_CRT_X509)
577 result = 577 result =
578 _find_x509_cert (cred, _data, _data_size, 578 _find_x509_cert (cred, _data, _data_size,
579 pk_algos, pk_algos_length, &indx); 579 pk_algos, pk_algos_length, &indx);
580 580
581 if (session->security_parameters.cert_type == GNUTLS_CRT_OPENPGP) 581 if (session->security_parameters.cert_type == MHD_GNUTLS_CRT_OPENPGP)
582 result = _find_openpgp_cert (cred, pk_algos, pk_algos_length, &indx); 582 result = _find_openpgp_cert (cred, pk_algos, pk_algos_length, &indx);
583 583
584 584
@@ -791,13 +791,13 @@ _gnutls_gen_cert_client_certificate (gnutls_session_t session, opaque ** data)
791{ 791{
792 switch (session->security_parameters.cert_type) 792 switch (session->security_parameters.cert_type)
793 { 793 {
794 case GNUTLS_CRT_OPENPGP: 794 case MHD_GNUTLS_CRT_OPENPGP:
795 if (_gnutls_openpgp_send_fingerprint (session) == 0) 795 if (_gnutls_openpgp_send_fingerprint (session) == 0)
796 return _gnutls_gen_openpgp_certificate (session, data); 796 return _gnutls_gen_openpgp_certificate (session, data);
797 else 797 else
798 return _gnutls_gen_openpgp_certificate_fpr (session, data); 798 return _gnutls_gen_openpgp_certificate_fpr (session, data);
799 799
800 case GNUTLS_CRT_X509: 800 case MHD_GNUTLS_CRT_X509:
801 return _gnutls_gen_x509_crt (session, data); 801 return _gnutls_gen_x509_crt (session, data);
802 802
803 default: 803 default:
@@ -811,9 +811,9 @@ _gnutls_gen_cert_server_certificate (gnutls_session_t session, opaque ** data)
811{ 811{
812 switch (session->security_parameters.cert_type) 812 switch (session->security_parameters.cert_type)
813 { 813 {
814 case GNUTLS_CRT_OPENPGP: 814 case MHD_GNUTLS_CRT_OPENPGP:
815 return _gnutls_gen_openpgp_certificate (session, data); 815 return _gnutls_gen_openpgp_certificate (session, data);
816 case GNUTLS_CRT_X509: 816 case MHD_GNUTLS_CRT_X509:
817 return _gnutls_gen_x509_crt (session, data); 817 return _gnutls_gen_x509_crt (session, data);
818 default: 818 default:
819 gnutls_assert (); 819 gnutls_assert ();
@@ -840,7 +840,7 @@ _gnutls_proc_x509_server_certificate (gnutls_session_t session,
840 gnutls_datum_t tmp; 840 gnutls_datum_t tmp;
841 841
842 cred = (gnutls_certificate_credentials_t) 842 cred = (gnutls_certificate_credentials_t)
843 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 843 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
844 if (cred == NULL) 844 if (cred == NULL)
845 { 845 {
846 gnutls_assert (); 846 gnutls_assert ();
@@ -849,7 +849,7 @@ _gnutls_proc_x509_server_certificate (gnutls_session_t session,
849 849
850 850
851 if ((ret = 851 if ((ret =
852 _gnutls_auth_info_set (session, GNUTLS_CRD_CERTIFICATE, 852 _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
853 sizeof (cert_auth_info_st), 1)) < 0) 853 sizeof (cert_auth_info_st), 1)) < 0)
854 { 854 {
855 gnutls_assert (); 855 gnutls_assert ();
@@ -982,7 +982,7 @@ _gnutls_proc_openpgp_server_certificate (gnutls_session_t session,
982 gnutls_datum_t tmp, akey = { NULL, 0 }; 982 gnutls_datum_t tmp, akey = { NULL, 0 };
983 983
984 cred = (gnutls_certificate_credentials_t) 984 cred = (gnutls_certificate_credentials_t)
985 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 985 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
986 if (cred == NULL) 986 if (cred == NULL)
987 { 987 {
988 gnutls_assert (); 988 gnutls_assert ();
@@ -990,7 +990,7 @@ _gnutls_proc_openpgp_server_certificate (gnutls_session_t session,
990 } 990 }
991 991
992 if ((ret = 992 if ((ret =
993 _gnutls_auth_info_set (session, GNUTLS_CRD_CERTIFICATE, 993 _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
994 sizeof (cert_auth_info_st), 1)) < 0) 994 sizeof (cert_auth_info_st), 1)) < 0)
995 { 995 {
996 gnutls_assert (); 996 gnutls_assert ();
@@ -1152,10 +1152,10 @@ _gnutls_proc_cert_server_certificate (gnutls_session_t session,
1152{ 1152{
1153 switch (session->security_parameters.cert_type) 1153 switch (session->security_parameters.cert_type)
1154 { 1154 {
1155 case GNUTLS_CRT_OPENPGP: 1155 case MHD_GNUTLS_CRT_OPENPGP:
1156 return _gnutls_proc_openpgp_server_certificate (session, 1156 return _gnutls_proc_openpgp_server_certificate (session,
1157 data, data_size); 1157 data, data_size);
1158 case GNUTLS_CRT_X509: 1158 case MHD_GNUTLS_CRT_X509:
1159 return _gnutls_proc_x509_server_certificate (session, data, data_size); 1159 return _gnutls_proc_x509_server_certificate (session, data, data_size);
1160 default: 1160 default:
1161 gnutls_assert (); 1161 gnutls_assert ();
@@ -1178,7 +1178,7 @@ _gnutls_check_supported_sign_algo (CertificateSigType algo)
1178 switch (algo) 1178 switch (algo)
1179 { 1179 {
1180 case RSA_SIGN: 1180 case RSA_SIGN:
1181 return GNUTLS_PK_RSA; 1181 return MHD_GNUTLS_PK_RSA;
1182 } 1182 }
1183 1183
1184 return -1; 1184 return -1;
@@ -1199,7 +1199,7 @@ _gnutls_proc_cert_cert_req (gnutls_session_t session, opaque * data,
1199 gnutls_protocol_t ver = gnutls_protocol_get_version (session); 1199 gnutls_protocol_t ver = gnutls_protocol_get_version (session);
1200 1200
1201 cred = (gnutls_certificate_credentials_t) 1201 cred = (gnutls_certificate_credentials_t)
1202 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 1202 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
1203 if (cred == NULL) 1203 if (cred == NULL)
1204 { 1204 {
1205 gnutls_assert (); 1205 gnutls_assert ();
@@ -1207,7 +1207,7 @@ _gnutls_proc_cert_cert_req (gnutls_session_t session, opaque * data,
1207 } 1207 }
1208 1208
1209 if ((ret = 1209 if ((ret =
1210 _gnutls_auth_info_set (session, GNUTLS_CRD_CERTIFICATE, 1210 _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
1211 sizeof (cert_auth_info_st), 0)) < 0) 1211 sizeof (cert_auth_info_st), 0)) < 0)
1212 { 1212 {
1213 gnutls_assert (); 1213 gnutls_assert ();
@@ -1244,7 +1244,7 @@ _gnutls_proc_cert_cert_req (gnutls_session_t session, opaque * data,
1244 return GNUTLS_E_UNKNOWN_PK_ALGORITHM; 1244 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
1245 } 1245 }
1246 1246
1247 if (ver == GNUTLS_TLS1_2) 1247 if (ver == MHD_GNUTLS_TLS1_2)
1248 { 1248 {
1249 /* read supported hashes */ 1249 /* read supported hashes */
1250 int hash_num; 1250 int hash_num;
@@ -1262,7 +1262,7 @@ _gnutls_proc_cert_cert_req (gnutls_session_t session, opaque * data,
1262 size = _gnutls_read_uint16 (p); 1262 size = _gnutls_read_uint16 (p);
1263 p += 2; 1263 p += 2;
1264 1264
1265 if (session->security_parameters.cert_type == GNUTLS_CRT_OPENPGP 1265 if (session->security_parameters.cert_type == MHD_GNUTLS_CRT_OPENPGP
1266 && size != 0) 1266 && size != 0)
1267 { 1267 {
1268 gnutls_assert (); // size should be zero 1268 gnutls_assert (); // size should be zero
@@ -1405,7 +1405,7 @@ _gnutls_gen_cert_server_cert_req (gnutls_session_t session, opaque ** data)
1405 */ 1405 */
1406 1406
1407 cred = (gnutls_certificate_credentials_t) 1407 cred = (gnutls_certificate_credentials_t)
1408 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 1408 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
1409 if (cred == NULL) 1409 if (cred == NULL)
1410 { 1410 {
1411 gnutls_assert (); 1411 gnutls_assert ();
@@ -1415,11 +1415,11 @@ _gnutls_gen_cert_server_cert_req (gnutls_session_t session, opaque ** data)
1415 size = CERTTYPE_SIZE + 2; /* 2 for gnutls_certificate_type_t + 2 for size of rdn_seq 1415 size = CERTTYPE_SIZE + 2; /* 2 for gnutls_certificate_type_t + 2 for size of rdn_seq
1416 */ 1416 */
1417 1417
1418 if (session->security_parameters.cert_type == GNUTLS_CRT_X509 && 1418 if (session->security_parameters.cert_type == MHD_GNUTLS_CRT_X509 &&
1419 session->internals.ignore_rdn_sequence == 0) 1419 session->internals.ignore_rdn_sequence == 0)
1420 size += cred->x509_rdn_sequence.size; 1420 size += cred->x509_rdn_sequence.size;
1421 1421
1422 if (ver == GNUTLS_TLS1_2) 1422 if (ver == MHD_GNUTLS_TLS1_2)
1423 /* Need at least one byte to announce the number of supported hash 1423 /* Need at least one byte to announce the number of supported hash
1424 functions (see below). */ 1424 functions (see below). */
1425 size += 1; 1425 size += 1;
@@ -1439,14 +1439,14 @@ _gnutls_gen_cert_server_cert_req (gnutls_session_t session, opaque ** data)
1439 pdata[2] = DSA_SIGN; /* only these for now */ 1439 pdata[2] = DSA_SIGN; /* only these for now */
1440 pdata += CERTTYPE_SIZE; 1440 pdata += CERTTYPE_SIZE;
1441 1441
1442 if (ver == GNUTLS_TLS1_2) 1442 if (ver == MHD_GNUTLS_TLS1_2)
1443 { 1443 {
1444 /* Supported hashes (nothing for now -- FIXME). */ 1444 /* Supported hashes (nothing for now -- FIXME). */
1445 *pdata = 0; 1445 *pdata = 0;
1446 pdata++; 1446 pdata++;
1447 } 1447 }
1448 1448
1449 if (session->security_parameters.cert_type == GNUTLS_CRT_X509 && 1449 if (session->security_parameters.cert_type == MHD_GNUTLS_CRT_X509 &&
1450 session->internals.ignore_rdn_sequence == 0) 1450 session->internals.ignore_rdn_sequence == 0)
1451 { 1451 {
1452 _gnutls_write_datum16 (pdata, cred->x509_rdn_sequence); 1452 _gnutls_write_datum16 (pdata, cred->x509_rdn_sequence);
@@ -1717,7 +1717,7 @@ _gnutls_server_select_cert (gnutls_session_t session,
1717 gnutls_certificate_credentials_t cred; 1717 gnutls_certificate_credentials_t cred;
1718 1718
1719 cred = (gnutls_certificate_credentials_t) 1719 cred = (gnutls_certificate_credentials_t)
1720 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 1720 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
1721 if (cred == NULL) 1721 if (cred == NULL)
1722 { 1722 {
1723 gnutls_assert (); 1723 gnutls_assert ();
diff --git a/src/daemon/https/tls/auth_dhe.c b/src/daemon/https/tls/auth_dhe.c
index 0262bda3..36c3be3f 100644
--- a/src/daemon/https/tls/auth_dhe.c
+++ b/src/daemon/https/tls/auth_dhe.c
@@ -93,7 +93,7 @@ gen_dhe_server_kx (gnutls_session_t session, opaque ** data)
93 gnutls_dh_params_t dh_params; 93 gnutls_dh_params_t dh_params;
94 94
95 cred = (gnutls_certificate_credentials_t) 95 cred = (gnutls_certificate_credentials_t)
96 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 96 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
97 if (cred == NULL) 97 if (cred == NULL)
98 { 98 {
99 gnutls_assert (); 99 gnutls_assert ();
@@ -123,7 +123,7 @@ gen_dhe_server_kx (gnutls_session_t session, opaque ** data)
123 p = mpis[0]; 123 p = mpis[0];
124 g = mpis[1]; 124 g = mpis[1];
125 125
126 if ((ret = _gnutls_auth_info_set (session, GNUTLS_CRD_CERTIFICATE, 126 if ((ret = _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
127 sizeof (cert_auth_info_st), 0)) < 0) 127 sizeof (cert_auth_info_st), 0)) < 0)
128 { 128 {
129 gnutls_assert (); 129 gnutls_assert ();
@@ -250,7 +250,7 @@ proc_dhe_client_kx (gnutls_session_t session, opaque * data,
250 gnutls_dh_params_t dh_params; 250 gnutls_dh_params_t dh_params;
251 251
252 cred = (gnutls_certificate_credentials_t) 252 cred = (gnutls_certificate_credentials_t)
253 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 253 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
254 if (cred == NULL) 254 if (cred == NULL)
255 { 255 {
256 gnutls_assert (); 256 gnutls_assert ();
diff --git a/src/daemon/https/tls/auth_rsa.c b/src/daemon/https/tls/auth_rsa.c
index 4430009d..ae5640ae 100644
--- a/src/daemon/https/tls/auth_rsa.c
+++ b/src/daemon/https/tls/auth_rsa.c
@@ -100,7 +100,7 @@ _gnutls_get_public_rsa_params (gnutls_session_t session,
100 /* EXPORT case: */ 100 /* EXPORT case: */
101 if (_gnutls_cipher_suite_get_kx_algo 101 if (_gnutls_cipher_suite_get_kx_algo
102 (&session->security_parameters.current_cipher_suite) 102 (&session->security_parameters.current_cipher_suite)
103 == GNUTLS_KX_RSA_EXPORT 103 == MHD_GNUTLS_KX_RSA_EXPORT
104 && _gnutls_mpi_get_nbits (peer_cert.params[0]) > 512) 104 && _gnutls_mpi_get_nbits (peer_cert.params[0]) > 512)
105 { 105 {
106 106
@@ -155,7 +155,7 @@ _gnutls_get_private_rsa_params (gnutls_session_t session,
155 gnutls_rsa_params_t rsa_params; 155 gnutls_rsa_params_t rsa_params;
156 156
157 cred = (gnutls_certificate_credentials_t) 157 cred = (gnutls_certificate_credentials_t)
158 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 158 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
159 if (cred == NULL) 159 if (cred == NULL)
160 { 160 {
161 gnutls_assert (); 161 gnutls_assert ();
@@ -174,7 +174,7 @@ _gnutls_get_private_rsa_params (gnutls_session_t session,
174 174
175 if (_gnutls_cipher_suite_get_kx_algo 175 if (_gnutls_cipher_suite_get_kx_algo
176 (&session->security_parameters.current_cipher_suite) 176 (&session->security_parameters.current_cipher_suite)
177 == GNUTLS_KX_RSA_EXPORT && bits > 512) 177 == MHD_GNUTLS_KX_RSA_EXPORT && bits > 512)
178 { 178 {
179 179
180 rsa_params = 180 rsa_params =
@@ -217,7 +217,7 @@ _gnutls_proc_rsa_client_kx (gnutls_session_t session, opaque * data,
217 int randomize_key = 0; 217 int randomize_key = 0;
218 ssize_t data_size = _data_size; 218 ssize_t data_size = _data_size;
219 219
220 if (gnutls_protocol_get_version (session) == GNUTLS_SSL3) 220 if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
221 { 221 {
222 /* SSL 3.0 222 /* SSL 3.0
223 */ 223 */
@@ -385,7 +385,7 @@ _gnutls_gen_rsa_client_kx (gnutls_session_t session, opaque ** data)
385 for (i = 0; i < params_len; i++) 385 for (i = 0; i < params_len; i++)
386 _gnutls_mpi_release (&params[i]); 386 _gnutls_mpi_release (&params[i]);
387 387
388 if (gnutls_protocol_get_version (session) == GNUTLS_SSL3) 388 if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
389 { 389 {
390 /* SSL 3.0 */ 390 /* SSL 3.0 */
391 *data = sdata.data; 391 *data = sdata.data;
diff --git a/src/daemon/https/tls/auth_rsa_export.c b/src/daemon/https/tls/auth_rsa_export.c
index 3c84121d..7c598226 100644
--- a/src/daemon/https/tls/auth_rsa_export.c
+++ b/src/daemon/https/tls/auth_rsa_export.c
@@ -81,7 +81,7 @@ gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
81 gnutls_certificate_credentials_t cred; 81 gnutls_certificate_credentials_t cred;
82 82
83 cred = (gnutls_certificate_credentials_t) 83 cred = (gnutls_certificate_credentials_t)
84 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 84 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
85 if (cred == NULL) 85 if (cred == NULL)
86 { 86 {
87 gnutls_assert (); 87 gnutls_assert ();
@@ -116,7 +116,7 @@ gen_rsa_export_server_kx (gnutls_session_t session, opaque ** data)
116 return GNUTLS_E_NO_TEMPORARY_RSA_PARAMS; 116 return GNUTLS_E_NO_TEMPORARY_RSA_PARAMS;
117 } 117 }
118 118
119 if ((ret = _gnutls_auth_info_set (session, GNUTLS_CRD_CERTIFICATE, 119 if ((ret = _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
120 sizeof (cert_auth_info_st), 0)) < 0) 120 sizeof (cert_auth_info_st), 0)) < 0)
121 { 121 {
122 gnutls_assert (); 122 gnutls_assert ();
@@ -213,7 +213,7 @@ _gnutls_peers_cert_less_512 (gnutls_session_t session)
213 return 0; 213 return 0;
214 } 214 }
215 215
216 if (peer_cert.subject_pk_algorithm != GNUTLS_PK_RSA) 216 if (peer_cert.subject_pk_algorithm != MHD_GNUTLS_PK_RSA)
217 { 217 {
218 gnutls_assert (); 218 gnutls_assert ();
219 _gnutls_gcert_deinit (&peer_cert); 219 _gnutls_gcert_deinit (&peer_cert);
diff --git a/src/daemon/https/tls/ext_cert_type.c b/src/daemon/https/tls/ext_cert_type.c
index f970e1fe..6f1c17bc 100644
--- a/src/daemon/https/tls/ext_cert_type.c
+++ b/src/daemon/https/tls/ext_cert_type.c
@@ -30,13 +30,13 @@
30#include "gnutls_errors.h" 30#include "gnutls_errors.h"
31#include "gnutls_num.h" 31#include "gnutls_num.h"
32#include "ext_cert_type.h" 32#include "ext_cert_type.h"
33#include <gnutls_state.h> 33#include "gnutls_state.h"
34#include <gnutls_num.h> 34#include "gnutls_num.h"
35 35
36inline static int _gnutls_num2cert_type (int num); 36inline static int _gnutls_num2cert_type (int num);
37inline static int _gnutls_cert_type2num (int record_size); 37inline static int _gnutls_cert_type2num (int record_size);
38 38
39/* 39/*
40 * In case of a server: if a CERT_TYPE extension type is received then it stores 40 * In case of a server: if a CERT_TYPE extension type is received then it stores
41 * into the session security parameters the new value. The server may use gnutls_session_certificate_type_get(), 41 * into the session security parameters the new value. The server may use gnutls_session_certificate_type_get(),
42 * to access it. 42 * to access it.
@@ -82,7 +82,7 @@ _gnutls_cert_type_recv_params (gnutls_session_t session,
82 } 82 }
83 } 83 }
84 else 84 else
85 { /* SERVER SIDE - we must check if the sent cert type is the right one 85 { /* SERVER SIDE - we must check if the sent cert type is the right one
86 */ 86 */
87 if (data_size > 1) 87 if (data_size > 1)
88 { 88 {
@@ -157,7 +157,7 @@ _gnutls_cert_type_send_params (gnutls_session_t session, opaque * data,
157 157
158 if (len == 1 && 158 if (len == 1 &&
159 session->internals.priorities.cert_type.priority[0] == 159 session->internals.priorities.cert_type.priority[0] ==
160 GNUTLS_CRT_X509) 160 MHD_GNUTLS_CRT_X509)
161 { 161 {
162 /* We don't use this extension if X.509 certificates 162 /* We don't use this extension if X.509 certificates
163 * are used. 163 * are used.
@@ -216,9 +216,9 @@ _gnutls_num2cert_type (int num)
216 switch (num) 216 switch (num)
217 { 217 {
218 case 0: 218 case 0:
219 return GNUTLS_CRT_X509; 219 return MHD_GNUTLS_CRT_X509;
220 case 1: 220 case 1:
221 return GNUTLS_CRT_OPENPGP; 221 return MHD_GNUTLS_CRT_OPENPGP;
222 default: 222 default:
223 return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER; 223 return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
224 } 224 }
@@ -232,9 +232,9 @@ _gnutls_cert_type2num (int cert_type)
232{ 232{
233 switch (cert_type) 233 switch (cert_type)
234 { 234 {
235 case GNUTLS_CRT_X509: 235 case MHD_GNUTLS_CRT_X509:
236 return 0; 236 return 0;
237 case GNUTLS_CRT_OPENPGP: 237 case MHD_GNUTLS_CRT_OPENPGP:
238 return 1; 238 return 1;
239 default: 239 default:
240 return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER; 240 return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
diff --git a/src/daemon/https/tls/ext_inner_application.c b/src/daemon/https/tls/ext_inner_application.c
index b86b7151..763e8cbf 100644
--- a/src/daemon/https/tls/ext_inner_application.c
+++ b/src/daemon/https/tls/ext_inner_application.c
@@ -77,7 +77,7 @@ _gnutls_inner_application_send_params (gnutls_session_t session,
77 if (session->security_parameters.entity == GNUTLS_CLIENT) 77 if (session->security_parameters.entity == GNUTLS_CLIENT)
78 { 78 {
79 gnutls_ia_client_credentials_t cred = (gnutls_ia_client_credentials_t) 79 gnutls_ia_client_credentials_t cred = (gnutls_ia_client_credentials_t)
80 _gnutls_get_cred (session->key, GNUTLS_CRD_IA, NULL); 80 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
81 81
82 if (cred) 82 if (cred)
83 ext->gnutls_ia_enable = 1; 83 ext->gnutls_ia_enable = 1;
@@ -85,7 +85,7 @@ _gnutls_inner_application_send_params (gnutls_session_t session,
85 else 85 else
86 { 86 {
87 gnutls_ia_server_credentials_t cred = (gnutls_ia_server_credentials_t) 87 gnutls_ia_server_credentials_t cred = (gnutls_ia_server_credentials_t)
88 _gnutls_get_cred (session->key, GNUTLS_CRD_IA, NULL); 88 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
89 89
90 if (cred) 90 if (cred)
91 ext->gnutls_ia_enable = 1; 91 ext->gnutls_ia_enable = 1;
diff --git a/src/daemon/https/tls/gnutls_algorithms.c b/src/daemon/https/tls/gnutls_algorithms.c
index 9921d076..56435345 100644
--- a/src/daemon/https/tls/gnutls_algorithms.c
+++ b/src/daemon/https/tls/gnutls_algorithms.c
@@ -42,30 +42,30 @@ typedef struct
42} gnutls_cred_map; 42} gnutls_cred_map;
43 43
44static const gnutls_cred_map cred_mappings[] = { 44static const gnutls_cred_map cred_mappings[] = {
45 {GNUTLS_KX_ANON_DH, 45 {MHD_GNUTLS_KX_ANON_DH,
46 GNUTLS_CRD_ANON, 46 MHD_GNUTLS_CRD_ANON,
47 GNUTLS_CRD_ANON}, 47 MHD_GNUTLS_CRD_ANON},
48 {GNUTLS_KX_RSA, 48 {MHD_GNUTLS_KX_RSA,
49 GNUTLS_CRD_CERTIFICATE, 49 MHD_GNUTLS_CRD_CERTIFICATE,
50 GNUTLS_CRD_CERTIFICATE}, 50 MHD_GNUTLS_CRD_CERTIFICATE},
51 {GNUTLS_KX_RSA_EXPORT, 51 {MHD_GNUTLS_KX_RSA_EXPORT,
52 GNUTLS_CRD_CERTIFICATE, 52 MHD_GNUTLS_CRD_CERTIFICATE,
53 GNUTLS_CRD_CERTIFICATE}, 53 MHD_GNUTLS_CRD_CERTIFICATE},
54 {GNUTLS_KX_DHE_DSS, 54 {MHD_GNUTLS_KX_DHE_DSS,
55 GNUTLS_CRD_CERTIFICATE, 55 MHD_GNUTLS_CRD_CERTIFICATE,
56 GNUTLS_CRD_CERTIFICATE}, 56 MHD_GNUTLS_CRD_CERTIFICATE},
57 {GNUTLS_KX_DHE_RSA, 57 {MHD_GNUTLS_KX_DHE_RSA,
58 GNUTLS_CRD_CERTIFICATE, 58 MHD_GNUTLS_CRD_CERTIFICATE,
59 GNUTLS_CRD_CERTIFICATE}, 59 MHD_GNUTLS_CRD_CERTIFICATE},
60 {GNUTLS_KX_SRP, 60 {MHD_GNUTLS_KX_SRP,
61 GNUTLS_CRD_SRP, 61 MHD_GNUTLS_CRD_SRP,
62 GNUTLS_CRD_SRP}, 62 MHD_GNUTLS_CRD_SRP},
63 {GNUTLS_KX_SRP_RSA, 63 {MHD_GNUTLS_KX_SRP_RSA,
64 GNUTLS_CRD_SRP, 64 MHD_GNUTLS_CRD_SRP,
65 GNUTLS_CRD_CERTIFICATE}, 65 MHD_GNUTLS_CRD_CERTIFICATE},
66 {GNUTLS_KX_SRP_DSS, 66 {MHD_GNUTLS_KX_SRP_DSS,
67 GNUTLS_CRD_SRP, 67 MHD_GNUTLS_CRD_SRP,
68 GNUTLS_CRD_CERTIFICATE}, 68 MHD_GNUTLS_CRD_CERTIFICATE},
69 {0, 69 {0,
70 0, 70 0,
71 0} 71 0}
@@ -101,17 +101,17 @@ typedef struct
101 * use GNUTLS_KX_RSA or GNUTLS_KX_DHE_RSA. 101 * use GNUTLS_KX_RSA or GNUTLS_KX_DHE_RSA.
102 */ 102 */
103static const gnutls_pk_map pk_mappings[] = { 103static const gnutls_pk_map pk_mappings[] = {
104 {GNUTLS_KX_RSA, 104 {MHD_GNUTLS_KX_RSA,
105 GNUTLS_PK_RSA, 105 MHD_GNUTLS_PK_RSA,
106 CIPHER_ENCRYPT}, 106 CIPHER_ENCRYPT},
107 {GNUTLS_KX_RSA_EXPORT, 107 {MHD_GNUTLS_KX_RSA_EXPORT,
108 GNUTLS_PK_RSA, 108 MHD_GNUTLS_PK_RSA,
109 CIPHER_SIGN}, 109 CIPHER_SIGN},
110 {GNUTLS_KX_DHE_RSA, 110 {MHD_GNUTLS_KX_DHE_RSA,
111 GNUTLS_PK_RSA, 111 MHD_GNUTLS_PK_RSA,
112 CIPHER_SIGN}, 112 CIPHER_SIGN},
113 {GNUTLS_KX_SRP_RSA, 113 {MHD_GNUTLS_KX_SRP_RSA,
114 GNUTLS_PK_RSA, 114 MHD_GNUTLS_PK_RSA,
115 CIPHER_SIGN}, 115 CIPHER_SIGN},
116 {0, 116 {0,
117 0, 117 0,
@@ -138,22 +138,22 @@ typedef struct
138 138
139static const gnutls_version_entry sup_versions[] = { 139static const gnutls_version_entry sup_versions[] = {
140 {"SSL3.0", 140 {"SSL3.0",
141 GNUTLS_SSL3, 141 MHD_GNUTLS_SSL3,
142 3, 142 3,
143 0, 143 0,
144 1}, 144 1},
145 {"TLS1.0", 145 {"TLS1.0",
146 GNUTLS_TLS1, 146 MHD_GNUTLS_TLS1_0,
147 3, 147 3,
148 1, 148 1,
149 1}, 149 1},
150 {"TLS1.1", 150 {"TLS1.1",
151 GNUTLS_TLS1_1, 151 MHD_GNUTLS_TLS1_1,
152 3, 152 3,
153 2, 153 2,
154 1}, 154 1},
155 {"TLS1.2", 155 {"TLS1.2",
156 GNUTLS_TLS1_2, 156 MHD_GNUTLS_TLS1_2,
157 3, 157 3,
158 3, 158 3,
159 1}, 159 1},
@@ -165,10 +165,10 @@ static const gnutls_version_entry sup_versions[] = {
165}; 165};
166 166
167/* Keep the contents of this struct the same as the previous one. */ 167/* Keep the contents of this struct the same as the previous one. */
168static const gnutls_protocol_t supported_protocols[] = { GNUTLS_SSL3, 168static const gnutls_protocol_t supported_protocols[] = { MHD_GNUTLS_SSL3,
169 GNUTLS_TLS1, 169 MHD_GNUTLS_TLS1_0,
170 GNUTLS_TLS1_1, 170 MHD_GNUTLS_TLS1_1,
171 GNUTLS_TLS1_2, 171 MHD_GNUTLS_TLS1_2,
172 0 172 0
173}; 173};
174 174
@@ -198,62 +198,64 @@ typedef struct gnutls_cipher_entry gnutls_cipher_entry;
198 */ 198 */
199static const gnutls_cipher_entry algorithms[] = { 199static const gnutls_cipher_entry algorithms[] = {
200 {"AES-256-CBC", 200 {"AES-256-CBC",
201 GNUTLS_CIPHER_AES_256_CBC, 201 MHD_GNUTLS_CIPHER_AES_256_CBC,
202 16, 202 16,
203 32, 203 32,
204 CIPHER_BLOCK, 204 CIPHER_BLOCK,
205 16, 205 16,
206 0}, 206 0},
207 {"AES-128-CBC", 207 {"AES-128-CBC",
208 GNUTLS_CIPHER_AES_128_CBC, 208 MHD_GNUTLS_CIPHER_AES_128_CBC,
209 16, 209 16,
210 16, 210 16,
211 CIPHER_BLOCK, 211 CIPHER_BLOCK,
212 16, 212 16,
213 0}, 213 0},
214 {"3DES-CBC", 214 {"3DES-CBC",
215 GNUTLS_CIPHER_3DES_CBC, 215 MHD_GNUTLS_CIPHER_3DES_CBC,
216 8, 216 8,
217 24, 217 24,
218 CIPHER_BLOCK, 218 CIPHER_BLOCK,
219 8, 219 8,
220 0}, 220 0},
221 {"DES-CBC", 221 {"DES-CBC",
222 GNUTLS_CIPHER_DES_CBC, 222 MHD_GNUTLS_CIPHER_DES_CBC,
223 8, 223 8,
224 8, 224 8,
225 CIPHER_BLOCK, 225 CIPHER_BLOCK,
226 8, 226 8,
227 0}, 227 0},
228 {"ARCFOUR-128", 228 {"ARCFOUR-128",
229 GNUTLS_CIPHER_ARCFOUR_128, 229 MHD_GNUTLS_CIPHER_ARCFOUR_128,
230 1, 230 1,
231 16, 231 16,
232 CIPHER_STREAM, 232 CIPHER_STREAM,
233 0, 233 0,
234 0}, 234 0},
235 {"ARCFOUR-40", 235 {"ARCFOUR-40",
236 GNUTLS_CIPHER_ARCFOUR_40, 236 MHD_GNUTLS_CIPHER_ARCFOUR_40,
237 1, 237 1,
238 5, 238 5,
239 CIPHER_STREAM, 239 CIPHER_STREAM,
240 0, 240 0,
241 1}, 241 1},
242 {"RC2-40", 242 {"RC2-40",
243 GNUTLS_CIPHER_RC2_40_CBC, 243 MHD_GNUTLS_CIPHER_RC2_40_CBC,
244 8, 244 8,
245 5, 245 5,
246 CIPHER_BLOCK, 246 CIPHER_BLOCK,
247 8, 247 8,
248 1}, 248 1},
249#ifdef ENABLE_CAMELLIA 249#ifdef ENABLE_CAMELLIA
250 {"CAMELLIA-256-CBC", GNUTLS_CIPHER_CAMELLIA_256_CBC, 16, 32, CIPHER_BLOCK, 250 {"CAMELLIA-256-CBC", MHD_GNUTLS_CIPHER_CAMELLIA_256_CBC, 16, 32,
251 CIPHER_BLOCK,
251 16, 0}, 252 16, 0},
252 {"CAMELLIA-128-CBC", GNUTLS_CIPHER_CAMELLIA_128_CBC, 16, 16, CIPHER_BLOCK, 253 {"CAMELLIA-128-CBC", MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC, 16, 16,
254 CIPHER_BLOCK,
253 16, 0}, 255 16, 0},
254#endif 256#endif
255 {"NULL", 257 {"NULL",
256 GNUTLS_CIPHER_NULL, 258 MHD_GNUTLS_CIPHER_NULL,
257 1, 259 1,
258 0, 260 0,
259 CIPHER_STREAM, 261 CIPHER_STREAM,
@@ -270,18 +272,18 @@ static const gnutls_cipher_entry algorithms[] = {
270 272
271/* Keep the contents of this struct the same as the previous one. */ 273/* Keep the contents of this struct the same as the previous one. */
272static const gnutls_cipher_algorithm_t supported_ciphers[] = 274static const gnutls_cipher_algorithm_t supported_ciphers[] =
273 { GNUTLS_CIPHER_AES_256_CBC, 275 { MHD_GNUTLS_CIPHER_AES_256_CBC,
274 GNUTLS_CIPHER_AES_128_CBC, 276 MHD_GNUTLS_CIPHER_AES_128_CBC,
275 GNUTLS_CIPHER_3DES_CBC, 277 MHD_GNUTLS_CIPHER_3DES_CBC,
276 GNUTLS_CIPHER_DES_CBC, 278 MHD_GNUTLS_CIPHER_DES_CBC,
277 GNUTLS_CIPHER_ARCFOUR_128, 279 MHD_GNUTLS_CIPHER_ARCFOUR_128,
278 GNUTLS_CIPHER_ARCFOUR_40, 280 MHD_GNUTLS_CIPHER_ARCFOUR_40,
279 GNUTLS_CIPHER_RC2_40_CBC, 281 MHD_GNUTLS_CIPHER_RC2_40_CBC,
280#ifdef ENABLE_CAMELLIA 282#ifdef ENABLE_CAMELLIA
281 GNUTLS_CIPHER_CAMELLIA_256_CBC, 283 MHD_GNUTLS_CIPHER_CAMELLIA_256_CBC,
282 GNUTLS_CIPHER_CAMELLIA_128_CBC, 284 MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC,
283#endif 285#endif
284 GNUTLS_CIPHER_NULL, 286 MHD_GNUTLS_CIPHER_NULL,
285 0 287 0
286}; 288};
287 289
@@ -304,19 +306,19 @@ typedef struct gnutls_hash_entry gnutls_hash_entry;
304static const gnutls_hash_entry hash_algorithms[] = { 306static const gnutls_hash_entry hash_algorithms[] = {
305 {"SHA1", 307 {"SHA1",
306 HASH_OID_SHA1, 308 HASH_OID_SHA1,
307 GNUTLS_MAC_SHA1, 309 MHD_GNUTLS_MAC_SHA1,
308 20}, 310 20},
309 {"MD5", 311 {"MD5",
310 HASH_OID_MD5, 312 HASH_OID_MD5,
311 GNUTLS_MAC_MD5, 313 MHD_GNUTLS_MAC_MD5,
312 16}, 314 16},
313 {"SHA256", 315 {"SHA256",
314 HASH_OID_SHA256, 316 HASH_OID_SHA256,
315 GNUTLS_MAC_SHA256, 317 MHD_GNUTLS_MAC_SHA256,
316 32}, 318 32},
317 {"NULL", 319 {"NULL",
318 NULL, 320 NULL,
319 GNUTLS_MAC_NULL, 321 MHD_GNUTLS_MAC_NULL,
320 0}, 322 0},
321 {0, 323 {0,
322 0, 324 0,
@@ -325,10 +327,10 @@ static const gnutls_hash_entry hash_algorithms[] = {
325}; 327};
326 328
327/* Keep the contents of this struct the same as the previous one. */ 329/* Keep the contents of this struct the same as the previous one. */
328static const gnutls_mac_algorithm_t supported_macs[] = { GNUTLS_MAC_SHA1, 330static const gnutls_mac_algorithm_t supported_macs[] = { MHD_GNUTLS_MAC_SHA1,
329 GNUTLS_MAC_MD5, 331 MHD_GNUTLS_MAC_MD5,
330 GNUTLS_MAC_SHA256, 332 MHD_GNUTLS_MAC_SHA256,
331 GNUTLS_MAC_NULL, 333 MHD_GNUTLS_MAC_NULL,
332 0 334 0
333}; 335};
334 336
@@ -349,10 +351,10 @@ const int _gnutls_comp_algorithms_size = MAX_COMP_METHODS;
349/* the compression entry is defined in gnutls_algorithms.h */ 351/* the compression entry is defined in gnutls_algorithms.h */
350 352
351gnutls_compression_entry _gnutls_compression_algorithms[MAX_COMP_METHODS] = 353gnutls_compression_entry _gnutls_compression_algorithms[MAX_COMP_METHODS] =
352 { GNUTLS_COMPRESSION_ENTRY (GNUTLS_COMP_NULL, 0x00, 0, 0, 0), 354 { GNUTLS_COMPRESSION_ENTRY (MHD_GNUTLS_COMP_NULL, 0x00, 0, 0, 0),
353#ifdef HAVE_LIBZ 355#ifdef HAVE_LIBZ
354 /* draft-ietf-tls-compression-02 */ 356 /* draft-ietf-tls-compression-02 */
355 GNUTLS_COMPRESSION_ENTRY (GNUTLS_COMP_DEFLATE, 0x01, 15, 8, 3), 357 GNUTLS_COMPRESSION_ENTRY (MHD_GNUTLS_COMP_DEFLATE, 0x01, 15, 8, 3),
356#endif 358#endif
357 {0, 359 {0,
358 0, 360 0,
@@ -364,9 +366,9 @@ gnutls_compression_entry _gnutls_compression_algorithms[MAX_COMP_METHODS] =
364 366
365static const gnutls_compression_method_t supported_compressions[] = { 367static const gnutls_compression_method_t supported_compressions[] = {
366#ifdef HAVE_LIBZ 368#ifdef HAVE_LIBZ
367 GNUTLS_COMP_DEFLATE, 369 MHD_GNUTLS_COMP_DEFLATE,
368#endif 370#endif
369 GNUTLS_COMP_NULL, 371 MHD_GNUTLS_COMP_NULL,
370 0 372 0
371}; 373};
372 374
@@ -402,33 +404,33 @@ typedef struct gnutls_kx_algo_entry gnutls_kx_algo_entry;
402 404
403static const gnutls_kx_algo_entry _gnutls_kx_algorithms[] = { 405static const gnutls_kx_algo_entry _gnutls_kx_algorithms[] = {
404#ifdef ENABLE_ANON 406#ifdef ENABLE_ANON
405 {"ANON-DH", GNUTLS_KX_ANON_DH, &anon_auth_struct, 1, 0}, 407 {"ANON-DH", MHD_GNUTLS_KX_ANON_DH, &anon_auth_struct, 1, 0},
406#endif 408#endif
407 {"RSA", 409 {"RSA",
408 GNUTLS_KX_RSA, 410 MHD_GNUTLS_KX_RSA,
409 &rsa_auth_struct, 411 &rsa_auth_struct,
410 0, 412 0,
411 0}, 413 0},
412 {"RSA-EXPORT", 414 {"RSA-EXPORT",
413 GNUTLS_KX_RSA_EXPORT, 415 MHD_GNUTLS_KX_RSA_EXPORT,
414 &rsa_export_auth_struct, 416 &rsa_export_auth_struct,
415 0, 417 0,
416 1 /* needs RSA params */ }, 418 1 /* needs RSA params */ },
417 {"DHE-RSA", 419 {"DHE-RSA",
418 GNUTLS_KX_DHE_RSA, 420 MHD_GNUTLS_KX_DHE_RSA,
419 &dhe_rsa_auth_struct, 421 &dhe_rsa_auth_struct,
420 1, 422 1,
421 0}, 423 0},
422 {"DHE-DSS", 424 {"DHE-DSS",
423 GNUTLS_KX_DHE_DSS, 425 MHD_GNUTLS_KX_DHE_DSS,
424 &dhe_dss_auth_struct, 426 &dhe_dss_auth_struct,
425 1, 427 1,
426 0}, 428 0},
427 429
428#ifdef ENABLE_SRP 430#ifdef ENABLE_SRP
429 {"SRP-DSS", GNUTLS_KX_SRP_DSS, &srp_dss_auth_struct, 0, 0}, 431 {"SRP-DSS", MHD_GNUTLS_KX_SRP_DSS, &srp_dss_auth_struct, 0, 0},
430 {"SRP-RSA", GNUTLS_KX_SRP_RSA, &srp_rsa_auth_struct, 0, 0}, 432 {"SRP-RSA", MHD_GNUTLS_KX_SRP_RSA, &srp_rsa_auth_struct, 0, 0},
431 {"SRP", GNUTLS_KX_SRP, &srp_auth_struct, 0, 0}, 433 {"SRP", MHD_GNUTLS_KX_SRP, &srp_auth_struct, 0, 0},
432#endif 434#endif
433#ifdef ENABLE_PSK 435#ifdef ENABLE_PSK
434 {"PSK", GNUTLS_KX_PSK, &psk_auth_struct, 0, 0}, 436 {"PSK", GNUTLS_KX_PSK, &psk_auth_struct, 0, 0},
@@ -445,16 +447,16 @@ static const gnutls_kx_algo_entry _gnutls_kx_algorithms[] = {
445/* Keep the contents of this struct the same as the previous one. */ 447/* Keep the contents of this struct the same as the previous one. */
446static const gnutls_kx_algorithm_t supported_kxs[] = { 448static const gnutls_kx_algorithm_t supported_kxs[] = {
447#ifdef ENABLE_ANON 449#ifdef ENABLE_ANON
448 GNUTLS_KX_ANON_DH, 450 MHD_GNUTLS_KX_ANON_DH,
449#endif 451#endif
450 GNUTLS_KX_RSA, 452 MHD_GNUTLS_KX_RSA,
451 GNUTLS_KX_RSA_EXPORT, 453 MHD_GNUTLS_KX_RSA_EXPORT,
452 GNUTLS_KX_DHE_RSA, 454 MHD_GNUTLS_KX_DHE_RSA,
453 GNUTLS_KX_DHE_DSS, 455 MHD_GNUTLS_KX_DHE_DSS,
454#ifdef ENABLE_SRP 456#ifdef ENABLE_SRP
455 GNUTLS_KX_SRP_DSS, 457 MHD_GNUTLS_KX_SRP_DSS,
456 GNUTLS_KX_SRP_RSA, 458 MHD_GNUTLS_KX_SRP_RSA,
457 GNUTLS_KX_SRP, 459 MHD_GNUTLS_KX_SRP,
458#endif 460#endif
459#ifdef ENABLE_PSK 461#ifdef ENABLE_PSK
460 GNUTLS_KX_PSK, 462 GNUTLS_KX_PSK,
@@ -585,139 +587,161 @@ typedef struct
585static const gnutls_cipher_suite_entry cs_algorithms[] = { 587static const gnutls_cipher_suite_entry cs_algorithms[] = {
586 /* ANON_DH */ 588 /* ANON_DH */
587 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_ARCFOUR_MD5, 589 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_ARCFOUR_MD5,
588 GNUTLS_CIPHER_ARCFOUR_128, 590 MHD_GNUTLS_CIPHER_ARCFOUR_128,
589 GNUTLS_KX_ANON_DH, GNUTLS_MAC_MD5, 591 MHD_GNUTLS_KX_ANON_DH, MHD_GNUTLS_MAC_MD5,
590 GNUTLS_SSL3), 592 MHD_GNUTLS_SSL3),
591 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_3DES_EDE_CBC_SHA1, 593 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_3DES_EDE_CBC_SHA1,
592 GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_ANON_DH, 594 MHD_GNUTLS_CIPHER_3DES_CBC,
593 GNUTLS_MAC_SHA1, GNUTLS_SSL3), 595 MHD_GNUTLS_KX_ANON_DH,
596 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_SSL3),
594 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_AES_128_CBC_SHA1, 597 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_AES_128_CBC_SHA1,
595 GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_ANON_DH, 598 MHD_GNUTLS_CIPHER_AES_128_CBC,
596 GNUTLS_MAC_SHA1, GNUTLS_SSL3), 599 MHD_GNUTLS_KX_ANON_DH,
600 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_SSL3),
597 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_AES_256_CBC_SHA1, 601 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_AES_256_CBC_SHA1,
598 GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_ANON_DH, 602 MHD_GNUTLS_CIPHER_AES_256_CBC,
599 GNUTLS_MAC_SHA1, GNUTLS_SSL3), 603 MHD_GNUTLS_KX_ANON_DH,
604 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_SSL3),
600#ifdef ENABLE_CAMELLIA 605#ifdef ENABLE_CAMELLIA
601 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_CAMELLIA_128_CBC_SHA1, 606 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_CAMELLIA_128_CBC_SHA1,
602 GNUTLS_CIPHER_CAMELLIA_128_CBC, 607 MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC,
603 GNUTLS_KX_ANON_DH, 608 MHD_GNUTLS_KX_ANON_DH,
604 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 609 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
605 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_CAMELLIA_256_CBC_SHA1, 610 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_CAMELLIA_256_CBC_SHA1,
606 GNUTLS_CIPHER_CAMELLIA_256_CBC, 611 MHD_GNUTLS_CIPHER_CAMELLIA_256_CBC,
607 GNUTLS_KX_ANON_DH, 612 MHD_GNUTLS_KX_ANON_DH,
608 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 613 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
609#endif 614#endif
610 615
611 /* SRP */ 616 /* SRP */
612 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_3DES_EDE_CBC_SHA1, 617 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_3DES_EDE_CBC_SHA1,
613 GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_SRP, 618 MHD_GNUTLS_CIPHER_3DES_CBC, MHD_GNUTLS_KX_SRP,
614 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 619 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
615 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_AES_128_CBC_SHA1, 620 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_AES_128_CBC_SHA1,
616 GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_SRP, 621 MHD_GNUTLS_CIPHER_AES_128_CBC, MHD_GNUTLS_KX_SRP,
617 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 622 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
618 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_AES_256_CBC_SHA1, 623 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_AES_256_CBC_SHA1,
619 GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_SRP, 624 MHD_GNUTLS_CIPHER_AES_256_CBC, MHD_GNUTLS_KX_SRP,
620 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 625 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
621 626
622 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_DSS_3DES_EDE_CBC_SHA1, 627 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_DSS_3DES_EDE_CBC_SHA1,
623 GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_SRP_DSS, 628 MHD_GNUTLS_CIPHER_3DES_CBC,
624 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 629 MHD_GNUTLS_KX_SRP_DSS,
630 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
625 631
626 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_RSA_3DES_EDE_CBC_SHA1, 632 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_RSA_3DES_EDE_CBC_SHA1,
627 GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_SRP_RSA, 633 MHD_GNUTLS_CIPHER_3DES_CBC,
628 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 634 MHD_GNUTLS_KX_SRP_RSA,
635 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
629 636
630 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_DSS_AES_128_CBC_SHA1, 637 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_DSS_AES_128_CBC_SHA1,
631 GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_SRP_DSS, 638 MHD_GNUTLS_CIPHER_AES_128_CBC,
632 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 639 MHD_GNUTLS_KX_SRP_DSS,
640 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
633 641
634 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_RSA_AES_128_CBC_SHA1, 642 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_RSA_AES_128_CBC_SHA1,
635 GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_SRP_RSA, 643 MHD_GNUTLS_CIPHER_AES_128_CBC,
636 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 644 MHD_GNUTLS_KX_SRP_RSA,
645 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
637 646
638 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_DSS_AES_256_CBC_SHA1, 647 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_DSS_AES_256_CBC_SHA1,
639 GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_SRP_DSS, 648 MHD_GNUTLS_CIPHER_AES_256_CBC,
640 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 649 MHD_GNUTLS_KX_SRP_DSS,
650 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
641 651
642 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_RSA_AES_256_CBC_SHA1, 652 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_SRP_SHA_RSA_AES_256_CBC_SHA1,
643 GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_SRP_RSA, 653 MHD_GNUTLS_CIPHER_AES_256_CBC,
644 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 654 MHD_GNUTLS_KX_SRP_RSA,
655 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
645 656
646 /* DHE_DSS */ 657 /* DHE_DSS */
647 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_ARCFOUR_SHA1, 658 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_ARCFOUR_SHA1,
648 GNUTLS_CIPHER_ARCFOUR_128, GNUTLS_KX_DHE_DSS, 659 MHD_GNUTLS_CIPHER_ARCFOUR_128,
649 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 660 MHD_GNUTLS_KX_DHE_DSS,
661 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
650 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_3DES_EDE_CBC_SHA1, 662 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_3DES_EDE_CBC_SHA1,
651 GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_DHE_DSS, 663 MHD_GNUTLS_CIPHER_3DES_CBC,
652 GNUTLS_MAC_SHA1, GNUTLS_SSL3), 664 MHD_GNUTLS_KX_DHE_DSS,
665 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_SSL3),
653 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_AES_128_CBC_SHA1, 666 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_AES_128_CBC_SHA1,
654 GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_DHE_DSS, 667 MHD_GNUTLS_CIPHER_AES_128_CBC,
655 GNUTLS_MAC_SHA1, GNUTLS_SSL3), 668 MHD_GNUTLS_KX_DHE_DSS,
669 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_SSL3),
656 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_AES_256_CBC_SHA1, 670 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_AES_256_CBC_SHA1,
657 GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_DHE_DSS, 671 MHD_GNUTLS_CIPHER_AES_256_CBC,
658 GNUTLS_MAC_SHA1, GNUTLS_SSL3), 672 MHD_GNUTLS_KX_DHE_DSS,
673 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_SSL3),
659#ifdef ENABLE_CAMELLIA 674#ifdef ENABLE_CAMELLIA
660 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_CAMELLIA_128_CBC_SHA1, 675 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_CAMELLIA_128_CBC_SHA1,
661 GNUTLS_CIPHER_CAMELLIA_128_CBC, 676 MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC,
662 GNUTLS_KX_DHE_DSS, 677 MHD_GNUTLS_KX_DHE_DSS,
663 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 678 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
664 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_CAMELLIA_256_CBC_SHA1, 679 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_DSS_CAMELLIA_256_CBC_SHA1,
665 GNUTLS_CIPHER_CAMELLIA_256_CBC, 680 MHD_GNUTLS_CIPHER_CAMELLIA_256_CBC,
666 GNUTLS_KX_DHE_DSS, 681 MHD_GNUTLS_KX_DHE_DSS,
667 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 682 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
668#endif 683#endif
669 /* DHE_RSA */ 684 /* DHE_RSA */
670 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_3DES_EDE_CBC_SHA1, 685 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_3DES_EDE_CBC_SHA1,
671 GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_DHE_RSA, 686 MHD_GNUTLS_CIPHER_3DES_CBC,
672 GNUTLS_MAC_SHA1, GNUTLS_SSL3), 687 MHD_GNUTLS_KX_DHE_RSA,
688 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_SSL3),
673 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_AES_128_CBC_SHA1, 689 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_AES_128_CBC_SHA1,
674 GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_DHE_RSA, 690 MHD_GNUTLS_CIPHER_AES_128_CBC,
675 GNUTLS_MAC_SHA1, GNUTLS_SSL3), 691 MHD_GNUTLS_KX_DHE_RSA,
692 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_SSL3),
676 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_AES_256_CBC_SHA1, 693 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_AES_256_CBC_SHA1,
677 GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_DHE_RSA, 694 MHD_GNUTLS_CIPHER_AES_256_CBC,
678 GNUTLS_MAC_SHA1, GNUTLS_SSL3), 695 MHD_GNUTLS_KX_DHE_RSA,
696 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_SSL3),
679#ifdef ENABLE_CAMELLIA 697#ifdef ENABLE_CAMELLIA
680 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_CAMELLIA_128_CBC_SHA1, 698 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_CAMELLIA_128_CBC_SHA1,
681 GNUTLS_CIPHER_CAMELLIA_128_CBC, 699 MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC,
682 GNUTLS_KX_DHE_RSA, 700 MHD_GNUTLS_KX_DHE_RSA,
683 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 701 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
684 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_CAMELLIA_256_CBC_SHA1, 702 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_DHE_RSA_CAMELLIA_256_CBC_SHA1,
685 GNUTLS_CIPHER_CAMELLIA_256_CBC, 703 MHD_GNUTLS_CIPHER_CAMELLIA_256_CBC,
686 GNUTLS_KX_DHE_RSA, 704 MHD_GNUTLS_KX_DHE_RSA,
687 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 705 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
688#endif 706#endif
689 /* RSA */ 707 /* RSA */
690 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_NULL_MD5, 708 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_NULL_MD5,
691 GNUTLS_CIPHER_NULL, 709 MHD_GNUTLS_CIPHER_NULL,
692 GNUTLS_KX_RSA, GNUTLS_MAC_MD5, GNUTLS_SSL3), 710 MHD_GNUTLS_KX_RSA, MHD_GNUTLS_MAC_MD5,
711 MHD_GNUTLS_SSL3),
693 712
694 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_EXPORT_ARCFOUR_40_MD5, 713 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_EXPORT_ARCFOUR_40_MD5,
695 GNUTLS_CIPHER_ARCFOUR_40, 714 MHD_GNUTLS_CIPHER_ARCFOUR_40,
696 GNUTLS_KX_RSA_EXPORT, GNUTLS_MAC_MD5, 715 MHD_GNUTLS_KX_RSA_EXPORT, MHD_GNUTLS_MAC_MD5,
697 GNUTLS_SSL3), 716 MHD_GNUTLS_SSL3),
698 717
699 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_ARCFOUR_SHA1, 718 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_ARCFOUR_SHA1,
700 GNUTLS_CIPHER_ARCFOUR_128, 719 MHD_GNUTLS_CIPHER_ARCFOUR_128,
701 GNUTLS_KX_RSA, GNUTLS_MAC_SHA1, GNUTLS_SSL3), 720 MHD_GNUTLS_KX_RSA, MHD_GNUTLS_MAC_SHA1,
721 MHD_GNUTLS_SSL3),
702 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_ARCFOUR_MD5, 722 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_ARCFOUR_MD5,
703 GNUTLS_CIPHER_ARCFOUR_128, 723 MHD_GNUTLS_CIPHER_ARCFOUR_128,
704 GNUTLS_KX_RSA, GNUTLS_MAC_MD5, GNUTLS_SSL3), 724 MHD_GNUTLS_KX_RSA, MHD_GNUTLS_MAC_MD5,
725 MHD_GNUTLS_SSL3),
705 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_3DES_EDE_CBC_SHA1, 726 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_3DES_EDE_CBC_SHA1,
706 GNUTLS_CIPHER_3DES_CBC, 727 MHD_GNUTLS_CIPHER_3DES_CBC,
707 GNUTLS_KX_RSA, GNUTLS_MAC_SHA1, GNUTLS_SSL3), 728 MHD_GNUTLS_KX_RSA, MHD_GNUTLS_MAC_SHA1,
729 MHD_GNUTLS_SSL3),
708 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_AES_128_CBC_SHA1, 730 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_AES_128_CBC_SHA1,
709 GNUTLS_CIPHER_AES_128_CBC, GNUTLS_KX_RSA, 731 MHD_GNUTLS_CIPHER_AES_128_CBC, MHD_GNUTLS_KX_RSA,
710 GNUTLS_MAC_SHA1, GNUTLS_SSL3), 732 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_SSL3),
711 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_AES_256_CBC_SHA1, 733 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_AES_256_CBC_SHA1,
712 GNUTLS_CIPHER_AES_256_CBC, GNUTLS_KX_RSA, 734 MHD_GNUTLS_CIPHER_AES_256_CBC, MHD_GNUTLS_KX_RSA,
713 GNUTLS_MAC_SHA1, GNUTLS_SSL3), 735 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_SSL3),
714#ifdef ENABLE_CAMELLIA 736#ifdef ENABLE_CAMELLIA
715 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_CAMELLIA_128_CBC_SHA1, 737 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_CAMELLIA_128_CBC_SHA1,
716 GNUTLS_CIPHER_CAMELLIA_128_CBC, GNUTLS_KX_RSA, 738 MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC,
717 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 739 MHD_GNUTLS_KX_RSA,
740 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
718 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_CAMELLIA_256_CBC_SHA1, 741 GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_RSA_CAMELLIA_256_CBC_SHA1,
719 GNUTLS_CIPHER_CAMELLIA_256_CBC, GNUTLS_KX_RSA, 742 MHD_GNUTLS_CIPHER_CAMELLIA_256_CBC,
720 GNUTLS_MAC_SHA1, GNUTLS_TLS1), 743 MHD_GNUTLS_KX_RSA,
744 MHD_GNUTLS_MAC_SHA1, MHD_GNUTLS_TLS1_0),
721#endif 745#endif
722 {0, 746 {0,
723 { 747 {
@@ -780,7 +804,7 @@ gnutls_mac_get_name (gnutls_mac_algorithm_t algorithm)
780gnutls_mac_algorithm_t 804gnutls_mac_algorithm_t
781gnutls_mac_get_id (const char *name) 805gnutls_mac_get_id (const char *name)
782{ 806{
783 gnutls_mac_algorithm_t ret = GNUTLS_MAC_UNKNOWN; 807 gnutls_mac_algorithm_t ret = MHD_GNUTLS_MAC_UNKNOWN;
784 808
785 GNUTLS_HASH_LOOP (if (strcasecmp (p->name, name) == 0) ret = p->id) 809 GNUTLS_HASH_LOOP (if (strcasecmp (p->name, name) == 0) ret = p->id)
786 ; 810 ;
@@ -847,7 +871,7 @@ _gnutls_x509_oid2mac_algorithm (const char *oid)
847 ; 871 ;
848 872
849 if (ret == 0) 873 if (ret == 0)
850 return GNUTLS_MAC_UNKNOWN; 874 return MHD_GNUTLS_MAC_UNKNOWN;
851 return ret; 875 return ret;
852} 876}
853 877
@@ -908,7 +932,7 @@ gnutls_compression_get_name (gnutls_compression_method_t algorithm)
908gnutls_compression_method_t 932gnutls_compression_method_t
909gnutls_compression_get_id (const char *name) 933gnutls_compression_get_id (const char *name)
910{ 934{
911 gnutls_compression_method_t ret = GNUTLS_COMP_UNKNOWN; 935 gnutls_compression_method_t ret = MHD_GNUTLS_COMP_UNKNOWN;
912 936
913 GNUTLS_COMPRESSION_LOOP (if 937 GNUTLS_COMPRESSION_LOOP (if
914 (strcasecmp 938 (strcasecmp
@@ -1099,7 +1123,7 @@ gnutls_cipher_get_name (gnutls_cipher_algorithm_t algorithm)
1099gnutls_cipher_algorithm_t 1123gnutls_cipher_algorithm_t
1100gnutls_cipher_get_id (const char *name) 1124gnutls_cipher_get_id (const char *name)
1101{ 1125{
1102 gnutls_cipher_algorithm_t ret = GNUTLS_CIPHER_UNKNOWN; 1126 gnutls_cipher_algorithm_t ret = MHD_GNUTLS_CIPHER_UNKNOWN;
1103 1127
1104 GNUTLS_LOOP (if (strcasecmp (p->name, name) == 0) ret = p->id) 1128 GNUTLS_LOOP (if (strcasecmp (p->name, name) == 0) ret = p->id)
1105 ; 1129 ;
@@ -1190,7 +1214,7 @@ gnutls_kx_get_name (gnutls_kx_algorithm_t algorithm)
1190gnutls_kx_algorithm_t 1214gnutls_kx_algorithm_t
1191gnutls_kx_get_id (const char *name) 1215gnutls_kx_get_id (const char *name)
1192{ 1216{
1193 gnutls_cipher_algorithm_t ret = GNUTLS_KX_UNKNOWN; 1217 gnutls_cipher_algorithm_t ret = MHD_GNUTLS_KX_UNKNOWN;
1194 1218
1195 GNUTLS_KX_LOOP (if (strcasecmp (p->name, name) == 0) ret = p->algorithm) 1219 GNUTLS_KX_LOOP (if (strcasecmp (p->name, name) == 0) ret = p->algorithm)
1196 ; 1220 ;
@@ -1267,7 +1291,7 @@ _gnutls_version_lowest (gnutls_session_t session)
1267 1291
1268 if (session->internals.priorities.protocol.priority == NULL) 1292 if (session->internals.priorities.protocol.priority == NULL)
1269 { 1293 {
1270 return GNUTLS_VERSION_UNKNOWN; 1294 return MHD_GNUTLS_VERSION_UNKNOWN;
1271 } 1295 }
1272 else 1296 else
1273 for (i = 0; i < session->internals.priorities.protocol.algorithms; i++) 1297 for (i = 0; i < session->internals.priorities.protocol.algorithms; i++)
@@ -1277,7 +1301,7 @@ _gnutls_version_lowest (gnutls_session_t session)
1277 } 1301 }
1278 1302
1279 if (min == 0xff) 1303 if (min == 0xff)
1280 return GNUTLS_VERSION_UNKNOWN; /* unknown version */ 1304 return MHD_GNUTLS_VERSION_UNKNOWN; /* unknown version */
1281 1305
1282 return min; 1306 return min;
1283} 1307}
@@ -1289,7 +1313,7 @@ _gnutls_version_max (gnutls_session_t session)
1289 1313
1290 if (session->internals.priorities.protocol.priority == NULL) 1314 if (session->internals.priorities.protocol.priority == NULL)
1291 { 1315 {
1292 return GNUTLS_VERSION_UNKNOWN; 1316 return MHD_GNUTLS_VERSION_UNKNOWN;
1293 } 1317 }
1294 else 1318 else
1295 for (i = 0; i < session->internals.priorities.protocol.algorithms; i++) 1319 for (i = 0; i < session->internals.priorities.protocol.algorithms; i++)
@@ -1299,7 +1323,7 @@ _gnutls_version_max (gnutls_session_t session)
1299 } 1323 }
1300 1324
1301 if (max == 0x00) 1325 if (max == 0x00)
1302 return GNUTLS_VERSION_UNKNOWN; /* unknown version */ 1326 return MHD_GNUTLS_VERSION_UNKNOWN; /* unknown version */
1303 1327
1304 return max; 1328 return max;
1305} 1329}
@@ -1333,7 +1357,7 @@ gnutls_protocol_get_name (gnutls_protocol_t version)
1333gnutls_protocol_t 1357gnutls_protocol_t
1334gnutls_protocol_get_id (const char *name) 1358gnutls_protocol_get_id (const char *name)
1335{ 1359{
1336 gnutls_protocol_t ret = GNUTLS_VERSION_UNKNOWN; 1360 gnutls_protocol_t ret = MHD_GNUTLS_VERSION_UNKNOWN;
1337 1361
1338 GNUTLS_VERSION_LOOP (if (strcasecmp (p->name, name) == 0) ret = p->id) 1362 GNUTLS_VERSION_LOOP (if (strcasecmp (p->name, name) == 0) ret = p->id)
1339 ; 1363 ;
@@ -1913,9 +1937,9 @@ gnutls_certificate_type_get_name (gnutls_certificate_type_t type)
1913{ 1937{
1914 const char *ret = NULL; 1938 const char *ret = NULL;
1915 1939
1916 if (type == GNUTLS_CRT_X509) 1940 if (type == MHD_GNUTLS_CRT_X509)
1917 ret = "X.509"; 1941 ret = "X.509";
1918 if (type == GNUTLS_CRT_OPENPGP) 1942 if (type == MHD_GNUTLS_CRT_OPENPGP)
1919 ret = "OPENPGP"; 1943 ret = "OPENPGP";
1920 1944
1921 return ret; 1945 return ret;
@@ -1933,19 +1957,19 @@ gnutls_certificate_type_get_name (gnutls_certificate_type_t type)
1933gnutls_certificate_type_t 1957gnutls_certificate_type_t
1934gnutls_certificate_type_get_id (const char *name) 1958gnutls_certificate_type_get_id (const char *name)
1935{ 1959{
1936 gnutls_certificate_type_t ret = GNUTLS_CRT_UNKNOWN; 1960 gnutls_certificate_type_t ret = MHD_GNUTLS_CRT_UNKNOWN;
1937 1961
1938 if (strcasecmp (name, "X.509") == 0 || strcasecmp (name, "X509") == 0) 1962 if (strcasecmp (name, "X.509") == 0 || strcasecmp (name, "X509") == 0)
1939 return GNUTLS_CRT_X509; 1963 return MHD_GNUTLS_CRT_X509;
1940 if (strcasecmp (name, "OPENPGP") == 0) 1964 if (strcasecmp (name, "OPENPGP") == 0)
1941 return GNUTLS_CRT_OPENPGP; 1965 return MHD_GNUTLS_CRT_OPENPGP;
1942 1966
1943 return ret; 1967 return ret;
1944} 1968}
1945 1969
1946static const gnutls_certificate_type_t supported_certificate_types[] = 1970static const gnutls_certificate_type_t supported_certificate_types[] =
1947 { GNUTLS_CRT_X509, 1971 { MHD_GNUTLS_CRT_X509,
1948 GNUTLS_CRT_OPENPGP, 1972 MHD_GNUTLS_CRT_OPENPGP,
1949 0 1973 0
1950}; 1974};
1951 1975
@@ -2006,18 +2030,18 @@ static const gnutls_sign_entry sign_algorithms[] = {
2006 {"RSA-SHA", 2030 {"RSA-SHA",
2007 SIG_RSA_SHA1_OID, 2031 SIG_RSA_SHA1_OID,
2008 GNUTLS_SIGN_RSA_SHA1, 2032 GNUTLS_SIGN_RSA_SHA1,
2009 GNUTLS_PK_RSA, 2033 MHD_GNUTLS_PK_RSA,
2010 GNUTLS_MAC_SHA1}, 2034 MHD_GNUTLS_MAC_SHA1},
2011 {"RSA-SHA256", 2035 {"RSA-SHA256",
2012 SIG_RSA_SHA256_OID, 2036 SIG_RSA_SHA256_OID,
2013 GNUTLS_SIGN_RSA_SHA256, 2037 GNUTLS_SIGN_RSA_SHA256,
2014 GNUTLS_PK_RSA, 2038 MHD_GNUTLS_PK_RSA,
2015 GNUTLS_MAC_SHA256}, 2039 MHD_GNUTLS_MAC_SHA256},
2016 {"RSA-MD5", 2040 {"RSA-MD5",
2017 SIG_RSA_MD5_OID, 2041 SIG_RSA_MD5_OID,
2018 GNUTLS_SIGN_RSA_MD5, 2042 GNUTLS_SIGN_RSA_MD5,
2019 GNUTLS_PK_RSA, 2043 MHD_GNUTLS_PK_RSA,
2020 GNUTLS_MAC_MD5}, 2044 MHD_GNUTLS_MAC_MD5},
2021 {"GOST R 34.10-2001", 2045 {"GOST R 34.10-2001",
2022 SIG_GOST_R3410_2001_OID, 2046 SIG_GOST_R3410_2001_OID,
2023 0, 2047 0,
@@ -2123,7 +2147,7 @@ typedef struct gnutls_pk_entry gnutls_pk_entry;
2123static const gnutls_pk_entry pk_algorithms[] = { 2147static const gnutls_pk_entry pk_algorithms[] = {
2124 {"RSA", 2148 {"RSA",
2125 PK_PKIX1_RSA_OID, 2149 PK_PKIX1_RSA_OID,
2126 GNUTLS_PK_RSA}, 2150 MHD_GNUTLS_PK_RSA},
2127 {"GOST R 34.10-2001", 2151 {"GOST R 34.10-2001",
2128 PK_GOST_R3410_2001_OID, 2152 PK_GOST_R3410_2001_OID,
2129 0}, 2153 0},
@@ -2161,7 +2185,7 @@ gnutls_pk_algorithm_get_name (gnutls_pk_algorithm_t algorithm)
2161gnutls_pk_algorithm_t 2185gnutls_pk_algorithm_t
2162_gnutls_x509_oid2pk_algorithm (const char *oid) 2186_gnutls_x509_oid2pk_algorithm (const char *oid)
2163{ 2187{
2164 gnutls_pk_algorithm_t ret = GNUTLS_PK_UNKNOWN; 2188 gnutls_pk_algorithm_t ret = MHD_GNUTLS_PK_UNKNOWN;
2165 const gnutls_pk_entry *p; 2189 const gnutls_pk_entry *p;
2166 2190
2167 for (p = pk_algorithms; p->name != NULL; p++) 2191 for (p = pk_algorithms; p->name != NULL; p++)
diff --git a/src/daemon/https/tls/gnutls_auth.c b/src/daemon/https/tls/gnutls_auth.c
index 89640402..bf4d6881 100644
--- a/src/daemon/https/tls/gnutls_auth.c
+++ b/src/daemon/https/tls/gnutls_auth.c
@@ -297,9 +297,9 @@ _gnutls_free_auth_info (gnutls_session_t session)
297 297
298 switch (session->key->auth_info_type) 298 switch (session->key->auth_info_type)
299 { 299 {
300 case GNUTLS_CRD_SRP: 300 case MHD_GNUTLS_CRD_SRP:
301 break; 301 break;
302 case GNUTLS_CRD_ANON: 302 case MHD_GNUTLS_CRD_ANON:
303 { 303 {
304 anon_auth_info_t info = _gnutls_get_auth_info (session); 304 anon_auth_info_t info = _gnutls_get_auth_info (session);
305 305
@@ -310,7 +310,7 @@ _gnutls_free_auth_info (gnutls_session_t session)
310 _gnutls_free_dh_info (dh_info); 310 _gnutls_free_dh_info (dh_info);
311 } 311 }
312 break; 312 break;
313 case GNUTLS_CRD_CERTIFICATE: 313 case MHD_GNUTLS_CRD_CERTIFICATE:
314 { 314 {
315 unsigned int i; 315 unsigned int i;
316 cert_auth_info_t info = _gnutls_get_auth_info (session); 316 cert_auth_info_t info = _gnutls_get_auth_info (session);
diff --git a/src/daemon/https/tls/gnutls_buffers.c b/src/daemon/https/tls/gnutls_buffers.c
index 5a272dca..bbc1bcc4 100644
--- a/src/daemon/https/tls/gnutls_buffers.c
+++ b/src/daemon/https/tls/gnutls_buffers.c
@@ -87,8 +87,8 @@
87 * push/pull function, and don't worry about thread conflicts, you can 87 * push/pull function, and don't worry about thread conflicts, you can
88 * also use gnutls_transport_set_global_errno(). 88 * also use gnutls_transport_set_global_errno().
89 **/ 89 **/
90void gnutls_transport_set_errno(gnutls_session_t session, 90void
91 int err) 91gnutls_transport_set_errno (gnutls_session_t session, int err)
92{ 92{
93 session->internals.errnum = err; 93 session->internals.errnum = err;
94} 94}
@@ -113,7 +113,8 @@ void gnutls_transport_set_errno(gnutls_session_t session,
113 * a thread-local variable. When feasible, using the guaranteed 113 * a thread-local variable. When feasible, using the guaranteed
114 * thread-safe gnutls_transport_set_errno() may be better. 114 * thread-safe gnutls_transport_set_errno() may be better.
115 **/ 115 **/
116void gnutls_transport_set_global_errno(int err) 116void
117gnutls_transport_set_global_errno (int err)
117{ 118{
118 errno = err; 119 errno = err;
119} 120}
@@ -121,10 +122,10 @@ void gnutls_transport_set_global_errno(int err)
121/* Buffers received packets of type APPLICATION DATA and 122/* Buffers received packets of type APPLICATION DATA and
122 * HANDSHAKE DATA. 123 * HANDSHAKE DATA.
123 */ 124 */
124int _gnutls_record_buffer_put(content_type_t type, 125int
125 gnutls_session_t session, 126_gnutls_record_buffer_put (content_type_t type,
126 opaque * data, 127 gnutls_session_t session,
127 size_t length) 128 opaque * data, size_t length)
128{ 129{
129 gnutls_buffer *buf; 130 gnutls_buffer *buf;
130 131
@@ -133,28 +134,27 @@ int _gnutls_record_buffer_put(content_type_t type,
133 134
134 switch (type) 135 switch (type)
135 { 136 {
136 case GNUTLS_APPLICATION_DATA: 137 case GNUTLS_APPLICATION_DATA:
137 buf = &session->internals.application_data_buffer; 138 buf = &session->internals.application_data_buffer;
138 _gnutls_buffers_log ("BUF[REC]: Inserted %d bytes of Data(%d)\n", 139 _gnutls_buffers_log ("BUF[REC]: Inserted %d bytes of Data(%d)\n",
139 length, type); 140 length, type);
140 break; 141 break;
141 142
142 case GNUTLS_HANDSHAKE: 143 case GNUTLS_HANDSHAKE:
143 buf = &session->internals.handshake_data_buffer; 144 buf = &session->internals.handshake_data_buffer;
144 _gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data(%d)\n", 145 _gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data(%d)\n",
145 length, type); 146 length, type);
146 break; 147 break;
147 148
148 case GNUTLS_INNER_APPLICATION: 149 case GNUTLS_INNER_APPLICATION:
149 buf = &session->internals.ia_data_buffer; 150 buf = &session->internals.ia_data_buffer;
150 _gnutls_buffers_log ("BUF[IA]: Inserted %d bytes of Data(%d)\n", length, 151 _gnutls_buffers_log ("BUF[IA]: Inserted %d bytes of Data(%d)\n", length,
151 type); 152 type);
152 break; 153 break;
153 154
154 default: 155 default:
155 gnutls_assert () 156 gnutls_assert ();
156 ; 157 return GNUTLS_E_INVALID_REQUEST;
157 return GNUTLS_E_INVALID_REQUEST;
158 } 158 }
159 159
160 if (_gnutls_buffer_append (buf, data, length) < 0) 160 if (_gnutls_buffer_append (buf, data, length) < 0)
@@ -166,22 +166,22 @@ int _gnutls_record_buffer_put(content_type_t type,
166 return 0; 166 return 0;
167} 167}
168 168
169int _gnutls_record_buffer_get_size(content_type_t type, 169int
170 gnutls_session_t session) 170_gnutls_record_buffer_get_size (content_type_t type, gnutls_session_t session)
171{ 171{
172 switch (type) 172 switch (type)
173 { 173 {
174 case GNUTLS_APPLICATION_DATA: 174 case GNUTLS_APPLICATION_DATA:
175 return session->internals.application_data_buffer.length; 175 return session->internals.application_data_buffer.length;
176 176
177 case GNUTLS_HANDSHAKE: 177 case GNUTLS_HANDSHAKE:
178 return session->internals.handshake_data_buffer.length; 178 return session->internals.handshake_data_buffer.length;
179 179
180 case GNUTLS_INNER_APPLICATION: 180 case GNUTLS_INNER_APPLICATION:
181 return session->internals.ia_data_buffer.length; 181 return session->internals.ia_data_buffer.length;
182 182
183 default: 183 default:
184 return GNUTLS_E_INVALID_REQUEST; 184 return GNUTLS_E_INVALID_REQUEST;
185 } 185 }
186} 186}
187 187
@@ -196,15 +196,16 @@ int _gnutls_record_buffer_get_size(content_type_t type,
196 * (gnutls leaves some data in the tcp buffer in order for select 196 * (gnutls leaves some data in the tcp buffer in order for select
197 * to work). 197 * to work).
198 **/ 198 **/
199size_t gnutls_record_check_pending(gnutls_session_t session) 199size_t
200gnutls_record_check_pending (gnutls_session_t session)
200{ 201{
201 return _gnutls_record_buffer_get_size(GNUTLS_APPLICATION_DATA, session); 202 return _gnutls_record_buffer_get_size (GNUTLS_APPLICATION_DATA, session);
202} 203}
203 204
204int _gnutls_record_buffer_get(content_type_t type, 205int
205 gnutls_session_t session, 206_gnutls_record_buffer_get (content_type_t type,
206 opaque * data, 207 gnutls_session_t session,
207 size_t length) 208 opaque * data, size_t length)
208{ 209{
209 if (length == 0 || data == NULL) 210 if (length == 0 || data == NULL)
210 { 211 {
@@ -214,70 +215,69 @@ int _gnutls_record_buffer_get(content_type_t type,
214 215
215 switch (type) 216 switch (type)
216 { 217 {
217 case GNUTLS_APPLICATION_DATA: 218 case GNUTLS_APPLICATION_DATA:
218 219
219 if (length > session->internals.application_data_buffer.length) 220 if (length > session->internals.application_data_buffer.length)
220 { 221 {
221 length = session->internals.application_data_buffer.length; 222 length = session->internals.application_data_buffer.length;
222 } 223 }
223 224
224 _gnutls_buffers_log ("BUFFER[REC][AD]: Read %d bytes of Data(%d)\n", 225 _gnutls_buffers_log ("BUFFER[REC][AD]: Read %d bytes of Data(%d)\n",
225 length, type); 226 length, type);
226 227
227 session->internals.application_data_buffer.length -= length; 228 session->internals.application_data_buffer.length -= length;
228 memcpy(data, session->internals.application_data_buffer.data, length); 229 memcpy (data, session->internals.application_data_buffer.data, length);
229 230
230 /* overwrite buffer */ 231 /* overwrite buffer */
231 memmove(session->internals.application_data_buffer.data, 232 memmove (session->internals.application_data_buffer.data,
232 &session->internals.application_data_buffer.data[length], 233 &session->internals.application_data_buffer.data[length],
233 session->internals.application_data_buffer.length); 234 session->internals.application_data_buffer.length);
234 235
235 /* we do no longer realloc the application_data_buffer.data, 236 /* we do no longer realloc the application_data_buffer.data,
236 * since it serves no practical reason. It also decreases 237 * since it serves no practical reason. It also decreases
237 * performance. 238 * performance.
238 */ 239 */
239 break; 240 break;
240 241
241 case GNUTLS_HANDSHAKE: 242 case GNUTLS_HANDSHAKE:
242 if (length > session->internals.handshake_data_buffer.length) 243 if (length > session->internals.handshake_data_buffer.length)
243 { 244 {
244 length = session->internals.handshake_data_buffer.length; 245 length = session->internals.handshake_data_buffer.length;
245 } 246 }
246 247
247 _gnutls_buffers_log ("BUF[REC][HD]: Read %d bytes of Data(%d)\n", 248 _gnutls_buffers_log ("BUF[REC][HD]: Read %d bytes of Data(%d)\n",
248 length, type); 249 length, type);
249 250
250 session->internals.handshake_data_buffer.length -= length; 251 session->internals.handshake_data_buffer.length -= length;
251 memcpy(data, session->internals.handshake_data_buffer.data, length); 252 memcpy (data, session->internals.handshake_data_buffer.data, length);
252 253
253 /* overwrite buffer */ 254 /* overwrite buffer */
254 memmove(session->internals.handshake_data_buffer.data, 255 memmove (session->internals.handshake_data_buffer.data,
255 &session->internals.handshake_data_buffer.data[length], 256 &session->internals.handshake_data_buffer.data[length],
256 session->internals.handshake_data_buffer.length); 257 session->internals.handshake_data_buffer.length);
257 258
258 break; 259 break;
259 260
260 case GNUTLS_INNER_APPLICATION: 261 case GNUTLS_INNER_APPLICATION:
261 if (length > session->internals.ia_data_buffer.length) 262 if (length > session->internals.ia_data_buffer.length)
262 length = session->internals.ia_data_buffer.length; 263 length = session->internals.ia_data_buffer.length;
263 264
264 _gnutls_buffers_log ("BUF[REC][IA]: Read %d bytes of Data(%d)\n", 265 _gnutls_buffers_log ("BUF[REC][IA]: Read %d bytes of Data(%d)\n",
265 length, type); 266 length, type);
266 267
267 session->internals.ia_data_buffer.length -= length; 268 session->internals.ia_data_buffer.length -= length;
268 memcpy(data, session->internals.ia_data_buffer.data, length); 269 memcpy (data, session->internals.ia_data_buffer.data, length);
269 270
270 /* overwrite buffer */ 271 /* overwrite buffer */
271 memmove(session->internals.ia_data_buffer.data, 272 memmove (session->internals.ia_data_buffer.data,
272 &session->internals.ia_data_buffer.data[length], 273 &session->internals.ia_data_buffer.data[length],
273 session->internals.ia_data_buffer.length); 274 session->internals.ia_data_buffer.length);
274 275
275 break; 276 break;
276 277
277 default: 278 default:
278 gnutls_assert () 279 gnutls_assert ();
279 ; 280 return GNUTLS_E_INVALID_REQUEST;
280 return GNUTLS_E_INVALID_REQUEST;
281 } 281 }
282 282
283 return length; 283 return length;
@@ -288,10 +288,9 @@ int _gnutls_record_buffer_get(content_type_t type,
288 * 288 *
289 * Flags are only used if the default recv() function is being used. 289 * Flags are only used if the default recv() function is being used.
290 */ 290 */
291static ssize_t _gnutls_read(gnutls_session_t session, 291static ssize_t
292 void *iptr, 292_gnutls_read (gnutls_session_t session,
293 size_t sizeOfPtr, 293 void *iptr, size_t sizeOfPtr, int flags)
294 int flags)
295{ 294{
296 size_t left; 295 size_t left;
297 ssize_t i = 0; 296 ssize_t i = 0;
@@ -309,23 +308,23 @@ static ssize_t _gnutls_read(gnutls_session_t session,
309 308
310 if (session->internals._gnutls_pull_func == NULL) 309 if (session->internals._gnutls_pull_func == NULL)
311 { 310 {
312 i = recv(GNUTLS_POINTER_TO_INT (fd), &ptr[sizeOfPtr - left], left, 311 i = recv (GNUTLS_POINTER_TO_INT (fd), &ptr[sizeOfPtr - left], left,
313 flags); 312 flags);
314#if HAVE_WINSOCK 313#if HAVE_WINSOCK
315 if (i < 0) 314 if (i < 0)
316 { 315 {
317 int tmperr = WSAGetLastError (); 316 int tmperr = WSAGetLastError ();
318 switch (tmperr) 317 switch (tmperr)
319 { 318 {
320 case WSAEWOULDBLOCK: 319 case WSAEWOULDBLOCK:
321 session->internals.errnum = EAGAIN; 320 session->internals.errnum = EAGAIN;
322 break; 321 break;
323 322
324 case WSAEINTR: 323 case WSAEINTR:
325 session->internals.errnum = EINTR; 324 session->internals.errnum = EINTR;
326 break; 325 break;
327 326
328 default: 327 default:
329 session->internals.errnum = EIO; 328 session->internals.errnum = EIO;
330 break; 329 break;
331 } 330 }
@@ -334,16 +333,16 @@ static ssize_t _gnutls_read(gnutls_session_t session,
334#endif 333#endif
335 } 334 }
336 else 335 else
337 i = session->internals._gnutls_pull_func(fd, &ptr[sizeOfPtr - 336 i = session->internals._gnutls_pull_func (fd, &ptr[sizeOfPtr -
338 left], left); 337 left], left);
339 338
340 if (i < 0) 339 if (i < 0)
341 { 340 {
342 int err = session->internals.errnum ? session->internals.errnum 341 int err = session->internals.errnum ? session->internals.errnum
343 : errno; 342 : errno;
344 343
345 _gnutls_read_log ("READ: %d returned from %d, errno=%d gerrno=%d\n", 344 _gnutls_read_log ("READ: %d returned from %d, errno=%d gerrno=%d\n",
346 i, fd, errno, session->internals.errnum); 345 i, fd, errno, session->internals.errnum);
347 346
348 if (err == EAGAIN || err == EINTR) 347 if (err == EAGAIN || err == EINTR)
349 { 348 {
@@ -351,7 +350,7 @@ static ssize_t _gnutls_read(gnutls_session_t session,
351 { 350 {
352 351
353 _gnutls_read_log ("READ: returning %d bytes from %d\n", 352 _gnutls_read_log ("READ: returning %d bytes from %d\n",
354 sizeOfPtr - left, fd); 353 sizeOfPtr - left, fd);
355 354
356 goto finish; 355 goto finish;
357 } 356 }
@@ -373,14 +372,14 @@ static ssize_t _gnutls_read(gnutls_session_t session,
373 _gnutls_read_log ("READ: Got %d bytes from %d\n", i, fd); 372 _gnutls_read_log ("READ: Got %d bytes from %d\n", i, fd);
374 373
375 if (i == 0) 374 if (i == 0)
376 break; /* EOF */ 375 break; /* EOF */
377 } 376 }
378 377
379 left -= i; 378 left -= i;
380 379
381 } 380 }
382 381
383 finish: 382finish:
384 383
385 if (_gnutls_log_level >= 7) 384 if (_gnutls_log_level >= 7)
386 { 385 {
@@ -388,21 +387,21 @@ static ssize_t _gnutls_read(gnutls_session_t session,
388 char tmp[16]; 387 char tmp[16];
389 388
390 _gnutls_read_log ("READ: read %d bytes from %d\n", (sizeOfPtr - left), 389 _gnutls_read_log ("READ: read %d bytes from %d\n", (sizeOfPtr - left),
391 fd); 390 fd);
392 391
393 for (x = 0; x < ((sizeOfPtr - left) / 16) + 1; x++) 392 for (x = 0; x < ((sizeOfPtr - left) / 16) + 1; x++)
394 { 393 {
395 line[0] = 0; 394 line[0] = 0;
396 395
397 sprintf(tmp, "%.4x - ", x); 396 sprintf (tmp, "%.4x - ", x);
398 _gnutls_str_cat(line, sizeof (line), tmp); 397 _gnutls_str_cat (line, sizeof (line), tmp);
399 398
400 for (j = 0; j < 16; j++) 399 for (j = 0; j < 16; j++)
401 { 400 {
402 if (sum < (sizeOfPtr - left)) 401 if (sum < (sizeOfPtr - left))
403 { 402 {
404 sprintf(tmp, "%.2x ", ((unsigned char *) ptr)[sum++]); 403 sprintf (tmp, "%.2x ", ((unsigned char *) ptr)[sum++]);
405 _gnutls_str_cat(line, sizeof (line), tmp); 404 _gnutls_str_cat (line, sizeof (line), tmp);
406 } 405 }
407 } 406 }
408 _gnutls_read_log ("%s\n", line); 407 _gnutls_read_log ("%s\n", line);
@@ -417,7 +416,8 @@ static ssize_t _gnutls_read(gnutls_session_t session,
417/* This function is only used with berkeley style sockets. 416/* This function is only used with berkeley style sockets.
418 * Clears the peeked data (read with MSG_PEEK). 417 * Clears the peeked data (read with MSG_PEEK).
419 */ 418 */
420int _gnutls_io_clear_peeked_data(gnutls_session_t session) 419int
420_gnutls_io_clear_peeked_data (gnutls_session_t session)
421{ 421{
422 char *peekdata; 422 char *peekdata;
423 int ret, sum; 423 int ret, sum;
@@ -435,12 +435,13 @@ int _gnutls_io_clear_peeked_data(gnutls_session_t session)
435 /* this was already read by using MSG_PEEK - so it shouldn't fail */ 435 /* this was already read by using MSG_PEEK - so it shouldn't fail */
436 sum = 0; 436 sum = 0;
437 do 437 do
438 { /* we need this to finish now */ 438 { /* we need this to finish now */
439 ret = _gnutls_read(session, peekdata, RCVLOWAT - sum, 0); 439 ret = _gnutls_read (session, peekdata, RCVLOWAT - sum, 0);
440 if (ret > 0) 440 if (ret > 0)
441 sum += ret; 441 sum += ret;
442 } while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN || sum 442 }
443 < RCVLOWAT); 443 while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN || sum
444 < RCVLOWAT);
444 445
445 gnutls_afree (peekdata); 446 gnutls_afree (peekdata);
446 447
@@ -455,7 +456,8 @@ int _gnutls_io_clear_peeked_data(gnutls_session_t session)
455 return 0; 456 return 0;
456} 457}
457 458
458void _gnutls_io_clear_read_buffer(gnutls_session_t session) 459void
460_gnutls_io_clear_read_buffer (gnutls_session_t session)
459{ 461{
460 session->internals.record_recv_buffer.length = 0; 462 session->internals.record_recv_buffer.length = 0;
461} 463}
@@ -469,10 +471,10 @@ void _gnutls_io_clear_read_buffer(gnutls_session_t session)
469 * which are stored in a local (in the session) buffer. A pointer (iptr) to this buffer is returned. 471 * which are stored in a local (in the session) buffer. A pointer (iptr) to this buffer is returned.
470 * 472 *
471 */ 473 */
472ssize_t _gnutls_io_read_buffered(gnutls_session_t session, 474ssize_t
473 opaque ** iptr, 475_gnutls_io_read_buffered (gnutls_session_t session,
474 size_t sizeOfPtr, 476 opaque ** iptr,
475 content_type_t recv_type) 477 size_t sizeOfPtr, content_type_t recv_type)
476{ 478{
477 ssize_t ret = 0, ret2 = 0; 479 ssize_t ret = 0, ret2 = 0;
478 size_t min; 480 size_t min;
@@ -485,7 +487,7 @@ ssize_t _gnutls_io_read_buffered(gnutls_session_t session,
485 487
486 if (sizeOfPtr > MAX_RECV_SIZE || sizeOfPtr == 0) 488 if (sizeOfPtr > MAX_RECV_SIZE || sizeOfPtr == 0)
487 { 489 {
488 gnutls_assert (); /* internal error */ 490 gnutls_assert (); /* internal error */
489 return GNUTLS_E_INVALID_REQUEST; 491 return GNUTLS_E_INVALID_REQUEST;
490 } 492 }
491 493
@@ -512,7 +514,7 @@ ssize_t _gnutls_io_read_buffered(gnutls_session_t session,
512 /* calculate the actual size, ie. get the minimum of the 514 /* calculate the actual size, ie. get the minimum of the
513 * buffered data and the requested data. 515 * buffered data and the requested data.
514 */ 516 */
515 min = MIN(session->internals.record_recv_buffer.length, sizeOfPtr); 517 min = MIN (session->internals.record_recv_buffer.length, sizeOfPtr);
516 if (min > 0) 518 if (min > 0)
517 { 519 {
518 /* if we have enough buffered data 520 /* if we have enough buffered data
@@ -532,9 +534,10 @@ ssize_t _gnutls_io_read_buffered(gnutls_session_t session,
532 /* Check if the previously read data plus the new data to 534 /* Check if the previously read data plus the new data to
533 * receive are longer than the maximum receive buffer size. 535 * receive are longer than the maximum receive buffer size.
534 */ 536 */
535 if ((session->internals.record_recv_buffer.length + recvdata) > MAX_RECV_SIZE) 537 if ((session->internals.record_recv_buffer.length + recvdata) >
538 MAX_RECV_SIZE)
536 { 539 {
537 gnutls_assert (); /* internal error */ 540 gnutls_assert (); /* internal error */
538 return GNUTLS_E_INVALID_REQUEST; 541 return GNUTLS_E_INVALID_REQUEST;
539 } 542 }
540 543
@@ -542,8 +545,8 @@ ssize_t _gnutls_io_read_buffered(gnutls_session_t session,
542 */ 545 */
543 alloc_size = recvdata + session->internals.record_recv_buffer.length; 546 alloc_size = recvdata + session->internals.record_recv_buffer.length;
544 session->internals.record_recv_buffer.data 547 session->internals.record_recv_buffer.data
545 = gnutls_realloc_fast(session->internals.record_recv_buffer.data, 548 = gnutls_realloc_fast (session->internals.record_recv_buffer.data,
546 alloc_size); 549 alloc_size);
547 if (session->internals.record_recv_buffer.data == NULL) 550 if (session->internals.record_recv_buffer.data == NULL)
548 { 551 {
549 gnutls_assert (); 552 gnutls_assert ();
@@ -557,12 +560,12 @@ ssize_t _gnutls_io_read_buffered(gnutls_session_t session,
557 /* READ DATA - but leave RCVLOWAT bytes in the kernel buffer. */ 560 /* READ DATA - but leave RCVLOWAT bytes in the kernel buffer. */
558 if (recvdata - recvlowat > 0) 561 if (recvdata - recvlowat > 0)
559 { 562 {
560 ret = _gnutls_read(session, &buf[buf_pos], recvdata - recvlowat, 0); 563 ret = _gnutls_read (session, &buf[buf_pos], recvdata - recvlowat, 0);
561 564
562 /* return immediately if we got an interrupt or eagain 565 /* return immediately if we got an interrupt or eagain
563 * error. 566 * error.
564 */ 567 */
565 if (ret < 0 && gnutls_error_is_fatal(ret) == 0) 568 if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
566 { 569 {
567 return ret; 570 return ret;
568 } 571 }
@@ -573,7 +576,7 @@ ssize_t _gnutls_io_read_buffered(gnutls_session_t session,
573 if (ret > 0) 576 if (ret > 0)
574 { 577 {
575 _gnutls_read_log ("RB: Have %d bytes into buffer. Adding %d bytes.\n", 578 _gnutls_read_log ("RB: Have %d bytes into buffer. Adding %d bytes.\n",
576 session->internals.record_recv_buffer.length, ret); 579 session->internals.record_recv_buffer.length, ret);
577 _gnutls_read_log ("RB: Requested %d bytes\n", sizeOfPtr); 580 _gnutls_read_log ("RB: Requested %d bytes\n", sizeOfPtr);
578 session->internals.record_recv_buffer.length += ret; 581 session->internals.record_recv_buffer.length += ret;
579 } 582 }
@@ -587,9 +590,9 @@ ssize_t _gnutls_io_read_buffered(gnutls_session_t session,
587 */ 590 */
588 if (ret == (recvdata - recvlowat) && recvlowat > 0) 591 if (ret == (recvdata - recvlowat) && recvlowat > 0)
589 { 592 {
590 ret2 = _gnutls_read(session, &buf[buf_pos], recvlowat, MSG_PEEK); 593 ret2 = _gnutls_read (session, &buf[buf_pos], recvlowat, MSG_PEEK);
591 594
592 if (ret2 < 0 && gnutls_error_is_fatal(ret2) == 0) 595 if (ret2 < 0 && gnutls_error_is_fatal (ret2) == 0)
593 { 596 {
594 return ret2; 597 return ret2;
595 } 598 }
@@ -598,8 +601,8 @@ ssize_t _gnutls_io_read_buffered(gnutls_session_t session,
598 { 601 {
599 _gnutls_read_log ("RB-PEEK: Read %d bytes in PEEK MODE.\n", ret2); 602 _gnutls_read_log ("RB-PEEK: Read %d bytes in PEEK MODE.\n", ret2);
600 _gnutls_read_log 603 _gnutls_read_log
601 ("RB-PEEK: Have %d bytes into buffer. Adding %d bytes.\nRB: Requested %d bytes\n", 604 ("RB-PEEK: Have %d bytes into buffer. Adding %d bytes.\nRB: Requested %d bytes\n",
602 session->internals.record_recv_buffer.length, ret2, sizeOfPtr); 605 session->internals.record_recv_buffer.length, ret2, sizeOfPtr);
603 session->internals.have_peeked_data = 1; 606 session->internals.have_peeked_data = 1;
604 session->internals.record_recv_buffer.length += ret2; 607 session->internals.record_recv_buffer.length += ret2;
605 608
@@ -610,7 +613,7 @@ ssize_t _gnutls_io_read_buffered(gnutls_session_t session,
610 { 613 {
611 gnutls_assert (); 614 gnutls_assert ();
612 /* that's because they are initialized to 0 */ 615 /* that's because they are initialized to 0 */
613 return MIN(ret, ret2); 616 return MIN (ret, ret2);
614 } 617 }
615 618
616 ret += ret2; 619 ret += ret2;
@@ -622,7 +625,7 @@ ssize_t _gnutls_io_read_buffered(gnutls_session_t session,
622 } 625 }
623 626
624 if (ret == 0) 627 if (ret == 0)
625 { /* EOF */ 628 { /* EOF */
626 gnutls_assert (); 629 gnutls_assert ();
627 return 0; 630 return 0;
628 } 631 }
@@ -648,12 +651,13 @@ ssize_t _gnutls_io_read_buffered(gnutls_session_t session,
648 651
649#define MEMSUB(x,y) ((ssize_t)((ptrdiff_t)x-(ptrdiff_t)y)) 652#define MEMSUB(x,y) ((ssize_t)((ptrdiff_t)x-(ptrdiff_t)y))
650 653
651inline static int _gnutls_buffer_insert(gnutls_buffer * buffer, 654inline static int
652 const opaque * _data, 655_gnutls_buffer_insert (gnutls_buffer * buffer,
653 size_t data_size) 656 const opaque * _data, size_t data_size)
654{ 657{
655 658
656 if ((MEMSUB (_data, buffer->data) >= 0) && (MEMSUB (_data, buffer->data) < (ssize_t) buffer->length)) 659 if ((MEMSUB (_data, buffer->data) >= 0)
660 && (MEMSUB (_data, buffer->data) < (ssize_t) buffer->length))
657 { 661 {
658 /* the given _data is part of the buffer. 662 /* the given _data is part of the buffer.
659 */ 663 */
@@ -665,12 +669,12 @@ inline static int _gnutls_buffer_insert(gnutls_buffer * buffer,
665 } 669 }
666 670
667 if (_data == buffer->data) 671 if (_data == buffer->data)
668 { /* then don't even memmove */ 672 { /* then don't even memmove */
669 buffer->length = data_size; 673 buffer->length = data_size;
670 return 0; 674 return 0;
671 } 675 }
672 676
673 memmove(buffer->data, _data, data_size); 677 memmove (buffer->data, _data, data_size);
674 buffer->length = data_size; 678 buffer->length = data_size;
675 679
676 return 0; 680 return 0;
@@ -686,9 +690,9 @@ inline static int _gnutls_buffer_insert(gnutls_buffer * buffer,
686 return 0; 690 return 0;
687} 691}
688 692
689inline static int _gnutls_buffer_get(gnutls_buffer * buffer, 693inline static int
690 const opaque ** ptr, 694_gnutls_buffer_get (gnutls_buffer * buffer,
691 size_t * ptr_size) 695 const opaque ** ptr, size_t * ptr_size)
692{ 696{
693 *ptr_size = buffer->length; 697 *ptr_size = buffer->length;
694 *ptr = buffer->data; 698 *ptr = buffer->data;
@@ -707,9 +711,9 @@ inline static int _gnutls_buffer_get(gnutls_buffer * buffer,
707 * to decrypt and verify the integrity. 711 * to decrypt and verify the integrity.
708 * 712 *
709 */ 713 */
710ssize_t _gnutls_io_write_buffered(gnutls_session_t session, 714ssize_t
711 const void *iptr, 715_gnutls_io_write_buffered (gnutls_session_t session,
712 size_t n) 716 const void *iptr, size_t n)
713{ 717{
714 size_t left; 718 size_t left;
715 unsigned j, x, sum = 0; 719 unsigned j, x, sum = 0;
@@ -740,7 +744,8 @@ ssize_t _gnutls_io_write_buffered(gnutls_session_t session,
740 { 744 {
741 /* checking is handled above */ 745 /* checking is handled above */
742 ret 746 ret
743 = _gnutls_buffer_get(&session->internals.record_send_buffer, &ptr, &n); 747 =
748 _gnutls_buffer_get (&session->internals.record_send_buffer, &ptr, &n);
744 if (ret < 0) 749 if (ret < 0)
745 { 750 {
746 gnutls_assert (); 751 gnutls_assert ();
@@ -748,7 +753,7 @@ ssize_t _gnutls_io_write_buffered(gnutls_session_t session,
748 } 753 }
749 754
750 _gnutls_write_log ("WRITE: Restoring old write. (%d bytes to send)\n", 755 _gnutls_write_log ("WRITE: Restoring old write. (%d bytes to send)\n",
751 n); 756 n);
752 } 757 }
753 758
754 _gnutls_write_log ("WRITE: Will write %d bytes to %d.\n", n, fd); 759 _gnutls_write_log ("WRITE: Will write %d bytes to %d.\n", n, fd);
@@ -762,22 +767,22 @@ ssize_t _gnutls_io_write_buffered(gnutls_session_t session,
762 767
763 if (session->internals._gnutls_push_func == NULL) 768 if (session->internals._gnutls_push_func == NULL)
764 { 769 {
765 i = send(GNUTLS_POINTER_TO_INT (fd), &ptr[n - left], left, 0); 770 i = send (GNUTLS_POINTER_TO_INT (fd), &ptr[n - left], left, 0);
766#if HAVE_WINSOCK 771#if HAVE_WINSOCK
767 if (i < 0) 772 if (i < 0)
768 { 773 {
769 int tmperr = WSAGetLastError (); 774 int tmperr = WSAGetLastError ();
770 switch (tmperr) 775 switch (tmperr)
771 { 776 {
772 case WSAEWOULDBLOCK: 777 case WSAEWOULDBLOCK:
773 session->internals.errnum = EAGAIN; 778 session->internals.errnum = EAGAIN;
774 break; 779 break;
775 780
776 case WSAEINTR: 781 case WSAEINTR:
777 session->internals.errnum = EINTR; 782 session->internals.errnum = EINTR;
778 break; 783 break;
779 784
780 default: 785 default:
781 session->internals.errnum = EIO; 786 session->internals.errnum = EIO;
782 break; 787 break;
783 } 788 }
@@ -786,19 +791,20 @@ ssize_t _gnutls_io_write_buffered(gnutls_session_t session,
786#endif 791#endif
787 } 792 }
788 else 793 else
789 i = session->internals._gnutls_push_func(fd, &ptr[n - left], left); 794 i = session->internals._gnutls_push_func (fd, &ptr[n - left], left);
790 795
791 if (i == -1) 796 if (i == -1)
792 { 797 {
793 int err = session->internals.errnum ? session->internals.errnum 798 int err = session->internals.errnum ? session->internals.errnum
794 : errno; 799 : errno;
795 800
796 if (err == EAGAIN || err == EINTR) 801 if (err == EAGAIN || err == EINTR)
797 { 802 {
798 session->internals.record_send_buffer_prev_size += n - left; 803 session->internals.record_send_buffer_prev_size += n - left;
799 804
800 retval = _gnutls_buffer_insert(&session->internals. 805 retval = _gnutls_buffer_insert (&session->internals.
801 record_send_buffer, &ptr[n - left], left); 806 record_send_buffer,
807 &ptr[n - left], left);
802 if (retval < 0) 808 if (retval < 0)
803 { 809 {
804 gnutls_assert (); 810 gnutls_assert ();
@@ -806,8 +812,8 @@ ssize_t _gnutls_io_write_buffered(gnutls_session_t session,
806 } 812 }
807 813
808 _gnutls_write_log 814 _gnutls_write_log
809 ("WRITE: Interrupted. Stored %d bytes to buffer. Already sent %d bytes.\n", 815 ("WRITE: Interrupted. Stored %d bytes to buffer. Already sent %d bytes.\n",
810 left, n - left); 816 left, n - left);
811 817
812 if (err == EAGAIN) 818 if (err == EAGAIN)
813 return GNUTLS_E_AGAIN; 819 return GNUTLS_E_AGAIN;
@@ -827,8 +833,8 @@ ssize_t _gnutls_io_write_buffered(gnutls_session_t session,
827 char tmp[16]; 833 char tmp[16];
828 834
829 _gnutls_write_log 835 _gnutls_write_log
830 ("WRITE: wrote %d bytes to %d. Left %d bytes. Total %d bytes.\n", 836 ("WRITE: wrote %d bytes to %d. Left %d bytes. Total %d bytes.\n",
831 i, fd, left, n); 837 i, fd, left, n);
832 for (x = 0; x < (unsigned) ((i) / 16) + 1; x++) 838 for (x = 0; x < (unsigned) ((i) / 16) + 1; x++)
833 { 839 {
834 line[0] = 0; 840 line[0] = 0;
@@ -836,15 +842,15 @@ ssize_t _gnutls_io_write_buffered(gnutls_session_t session,
836 if (sum > n - left) 842 if (sum > n - left)
837 break; 843 break;
838 844
839 sprintf(tmp, "%.4x - ", x); 845 sprintf (tmp, "%.4x - ", x);
840 _gnutls_str_cat(line, sizeof (line), tmp); 846 _gnutls_str_cat (line, sizeof (line), tmp);
841 847
842 for (j = 0; j < 16; j++) 848 for (j = 0; j < 16; j++)
843 { 849 {
844 if (sum < n - left) 850 if (sum < n - left)
845 { 851 {
846 sprintf(tmp, "%.2x ", ((unsigned char *) ptr)[sum++]); 852 sprintf (tmp, "%.2x ", ((unsigned char *) ptr)[sum++]);
847 _gnutls_str_cat(line, sizeof (line), tmp); 853 _gnutls_str_cat (line, sizeof (line), tmp);
848 } 854 }
849 else 855 else
850 break; 856 break;
@@ -867,16 +873,17 @@ ssize_t _gnutls_io_write_buffered(gnutls_session_t session,
867 * TLS write buffer (ie. because the previous write was 873 * TLS write buffer (ie. because the previous write was
868 * interrupted. 874 * interrupted.
869 */ 875 */
870ssize_t _gnutls_io_write_flush(gnutls_session_t session) 876ssize_t
877_gnutls_io_write_flush (gnutls_session_t session)
871{ 878{
872 ssize_t ret; 879 ssize_t ret;
873 880
874 if (session->internals.record_send_buffer.length == 0) 881 if (session->internals.record_send_buffer.length == 0)
875 return 0; /* done */ 882 return 0; /* done */
876 883
877 ret = _gnutls_io_write_buffered(session, NULL, 0); 884 ret = _gnutls_io_write_buffered (session, NULL, 0);
878 _gnutls_write_log ("WRITE FLUSH: %d [buffer: %d]\n", ret, 885 _gnutls_write_log ("WRITE FLUSH: %d [buffer: %d]\n", ret,
879 session->internals.record_send_buffer.length); 886 session->internals.record_send_buffer.length);
880 887
881 return ret; 888 return ret;
882} 889}
@@ -885,10 +892,11 @@ ssize_t _gnutls_io_write_flush(gnutls_session_t session)
885 * Handshake write buffer (ie. because the previous write was 892 * Handshake write buffer (ie. because the previous write was
886 * interrupted. 893 * interrupted.
887 */ 894 */
888ssize_t _gnutls_handshake_io_write_flush(gnutls_session_t session) 895ssize_t
896_gnutls_handshake_io_write_flush (gnutls_session_t session)
889{ 897{
890 ssize_t ret; 898 ssize_t ret;
891 ret = _gnutls_handshake_io_send_int(session, 0, 0, NULL, 0); 899 ret = _gnutls_handshake_io_send_int (session, 0, 0, NULL, 0);
892 if (ret < 0) 900 if (ret < 0)
893 { 901 {
894 gnutls_assert (); 902 gnutls_assert ();
@@ -909,11 +917,11 @@ ssize_t _gnutls_handshake_io_write_flush(gnutls_session_t session)
909/* This is a send function for the gnutls handshake 917/* This is a send function for the gnutls handshake
910 * protocol. Just makes sure that all data have been sent. 918 * protocol. Just makes sure that all data have been sent.
911 */ 919 */
912ssize_t _gnutls_handshake_io_send_int(gnutls_session_t session, 920ssize_t
913 content_type_t type, 921_gnutls_handshake_io_send_int (gnutls_session_t session,
914 gnutls_handshake_description_t htype, 922 content_type_t type,
915 const void *iptr, 923 gnutls_handshake_description_t htype,
916 size_t n) 924 const void *iptr, size_t n)
917{ 925{
918 size_t left; 926 size_t left;
919 ssize_t ret = 0; 927 ssize_t ret = 0;
@@ -928,8 +936,9 @@ ssize_t _gnutls_handshake_io_send_int(gnutls_session_t session,
928 /* resuming previously interrupted write 936 /* resuming previously interrupted write
929 */ 937 */
930 gnutls_assert (); 938 gnutls_assert ();
931 ret = _gnutls_buffer_get(&session->internals.handshake_send_buffer, &ptr, 939 ret =
932 &n); 940 _gnutls_buffer_get (&session->internals.handshake_send_buffer, &ptr,
941 &n);
933 if (ret < 0) 942 if (ret < 0)
934 { 943 {
935 gnutls_assert (); 944 gnutls_assert ();
@@ -951,11 +960,11 @@ ssize_t _gnutls_handshake_io_send_int(gnutls_session_t session,
951 size_t sum = 0, x, j; 960 size_t sum = 0, x, j;
952 961
953 _gnutls_write_log ("HWRITE: will write %d bytes to %d.\n", n, 962 _gnutls_write_log ("HWRITE: will write %d bytes to %d.\n", n,
954 gnutls_transport_get_ptr (session)); 963 gnutls_transport_get_ptr (session));
955 for (x = 0; x < ((n) / 16) + 1; x++) 964 for (x = 0; x < ((n) / 16) + 1; x++)
956 { 965 {
957 if (sum> n) 966 if (sum > n)
958 break; 967 break;
959 968
960 _gnutls_write_log ("%.4x - ", x); 969 _gnutls_write_log ("%.4x - ", x);
961 for (j = 0; j < 16; j++) 970 for (j = 0; j < 16; j++)
@@ -965,7 +974,7 @@ ssize_t _gnutls_handshake_io_send_int(gnutls_session_t session,
965 _gnutls_write_log ("%.2x ", ((unsigned char *) ptr)[sum++]); 974 _gnutls_write_log ("%.2x ", ((unsigned char *) ptr)[sum++]);
966 } 975 }
967 else 976 else
968 break; 977 break;
969 } 978 }
970 _gnutls_write_log ("\n"); 979 _gnutls_write_log ("\n");
971 } 980 }
@@ -974,7 +983,7 @@ ssize_t _gnutls_handshake_io_send_int(gnutls_session_t session,
974#endif 983#endif
975 984
976 if (n == 0) 985 if (n == 0)
977 { /* if we have no data to send */ 986 { /* if we have no data to send */
978 gnutls_assert (); 987 gnutls_assert ();
979 return 0; 988 return 0;
980 } 989 }
@@ -987,7 +996,7 @@ ssize_t _gnutls_handshake_io_send_int(gnutls_session_t session,
987 left = n; 996 left = n;
988 while (left > 0) 997 while (left > 0)
989 { 998 {
990 ret = _gnutls_send_int(session, type, htype, &ptr[n - left], left); 999 ret = _gnutls_send_int (session, type, htype, &ptr[n - left], left);
991 1000
992 if (ret <= 0) 1001 if (ret <= 0)
993 { 1002 {
@@ -1002,8 +1011,9 @@ ssize_t _gnutls_handshake_io_send_int(gnutls_session_t session,
1002 { 1011 {
1003 gnutls_assert (); 1012 gnutls_assert ();
1004 1013
1005 retval = _gnutls_buffer_insert(&session->internals. 1014 retval = _gnutls_buffer_insert (&session->internals.
1006 handshake_send_buffer, &ptr[n - left], left); 1015 handshake_send_buffer,
1016 &ptr[n - left], left);
1007 if (retval < 0) 1017 if (retval < 0)
1008 { 1018 {
1009 gnutls_assert (); 1019 gnutls_assert ();
@@ -1040,11 +1050,11 @@ ssize_t _gnutls_handshake_io_send_int(gnutls_session_t session,
1040/* This is a receive function for the gnutls handshake 1050/* This is a receive function for the gnutls handshake
1041 * protocol. Makes sure that we have received all data. 1051 * protocol. Makes sure that we have received all data.
1042 */ 1052 */
1043ssize_t _gnutls_handshake_io_recv_int(gnutls_session_t session, 1053ssize_t
1044 content_type_t type, 1054_gnutls_handshake_io_recv_int (gnutls_session_t session,
1045 gnutls_handshake_description_t htype, 1055 content_type_t type,
1046 void *iptr, 1056 gnutls_handshake_description_t htype,
1047 size_t sizeOfPtr) 1057 void *iptr, size_t sizeOfPtr)
1048{ 1058{
1049 size_t left; 1059 size_t left;
1050 ssize_t i; 1060 ssize_t i;
@@ -1068,20 +1078,21 @@ ssize_t _gnutls_handshake_io_recv_int(gnutls_session_t session,
1068 /* if requested less data then return it. 1078 /* if requested less data then return it.
1069 */ 1079 */
1070 gnutls_assert (); 1080 gnutls_assert ();
1071 memcpy(iptr, session->internals.handshake_recv_buffer.data, sizeOfPtr); 1081 memcpy (iptr, session->internals.handshake_recv_buffer.data,
1082 sizeOfPtr);
1072 1083
1073 session->internals.handshake_recv_buffer.length -= sizeOfPtr; 1084 session->internals.handshake_recv_buffer.length -= sizeOfPtr;
1074 1085
1075 memmove(session->internals.handshake_recv_buffer.data, 1086 memmove (session->internals.handshake_recv_buffer.data,
1076 &session->internals.handshake_recv_buffer. 1087 &session->internals.handshake_recv_buffer.
1077 data[sizeOfPtr], 1088 data[sizeOfPtr],
1078 session->internals.handshake_recv_buffer.length); 1089 session->internals.handshake_recv_buffer.length);
1079 1090
1080 return sizeOfPtr; 1091 return sizeOfPtr;
1081 } 1092 }
1082 gnutls_assert (); 1093 gnutls_assert ();
1083 memcpy(iptr, session->internals.handshake_recv_buffer.data, 1094 memcpy (iptr, session->internals.handshake_recv_buffer.data,
1084 session->internals.handshake_recv_buffer.length); 1095 session->internals.handshake_recv_buffer.length);
1085 1096
1086 htype = session->internals.handshake_recv_buffer_htype; 1097 htype = session->internals.handshake_recv_buffer_htype;
1087 type = session->internals.handshake_recv_buffer_type; 1098 type = session->internals.handshake_recv_buffer_type;
@@ -1094,7 +1105,7 @@ ssize_t _gnutls_handshake_io_recv_int(gnutls_session_t session,
1094 while (left > 0) 1105 while (left > 0)
1095 { 1106 {
1096 dsize = sizeOfPtr - left; 1107 dsize = sizeOfPtr - left;
1097 i = _gnutls_recv_int(session, type, htype, &ptr[dsize], left); 1108 i = _gnutls_recv_int (session, type, htype, &ptr[dsize], left);
1098 if (i < 0) 1109 if (i < 0)
1099 { 1110 {
1100 1111
@@ -1103,15 +1114,16 @@ ssize_t _gnutls_handshake_io_recv_int(gnutls_session_t session,
1103 gnutls_assert (); 1114 gnutls_assert ();
1104 1115
1105 session->internals.handshake_recv_buffer.data 1116 session->internals.handshake_recv_buffer.data
1106 = gnutls_realloc_fast(session->internals. 1117 = gnutls_realloc_fast (session->internals.
1107 handshake_recv_buffer.data, dsize); 1118 handshake_recv_buffer.data, dsize);
1108 if (session->internals.handshake_recv_buffer.data == NULL) 1119 if (session->internals.handshake_recv_buffer.data == NULL)
1109 { 1120 {
1110 gnutls_assert (); 1121 gnutls_assert ();
1111 return GNUTLS_E_MEMORY_ERROR; 1122 return GNUTLS_E_MEMORY_ERROR;
1112 } 1123 }
1113 1124
1114 memcpy(session->internals.handshake_recv_buffer.data, iptr, dsize); 1125 memcpy (session->internals.handshake_recv_buffer.data, iptr,
1126 dsize);
1115 1127
1116 session->internals.handshake_recv_buffer_htype = htype; 1128 session->internals.handshake_recv_buffer_htype = htype;
1117 session->internals.handshake_recv_buffer_type = type; 1129 session->internals.handshake_recv_buffer_type = type;
@@ -1128,7 +1140,7 @@ ssize_t _gnutls_handshake_io_recv_int(gnutls_session_t session,
1128 else 1140 else
1129 { 1141 {
1130 if (i == 0) 1142 if (i == 0)
1131 break; /* EOF */ 1143 break; /* EOF */
1132 } 1144 }
1133 1145
1134 left -= i; 1146 left -= i;
@@ -1144,21 +1156,22 @@ ssize_t _gnutls_handshake_io_recv_int(gnutls_session_t session,
1144 * for finished messages to use them. Used in HMAC calculation 1156 * for finished messages to use them. Used in HMAC calculation
1145 * and finished messages. 1157 * and finished messages.
1146 */ 1158 */
1147int _gnutls_handshake_buffer_put(gnutls_session_t session, 1159int
1148 opaque * data, 1160_gnutls_handshake_buffer_put (gnutls_session_t session,
1149 size_t length) 1161 opaque * data, size_t length)
1150{ 1162{
1151 1163
1152 if (length == 0) 1164 if (length == 0)
1153 return 0; 1165 return 0;
1154 1166
1155 if ((session->internals.max_handshake_data_buffer_size > 0) && ((length 1167 if ((session->internals.max_handshake_data_buffer_size > 0) && ((length
1156 + session-> 1168 + session->
1157 internals. 1169 internals.
1158 handshake_hash_buffer. 1170 handshake_hash_buffer.
1159 length) > session-> 1171 length) >
1160 internals. 1172 session->
1161 max_handshake_data_buffer_size)) 1173 internals.
1174 max_handshake_data_buffer_size))
1162 { 1175 {
1163 gnutls_assert (); 1176 gnutls_assert ();
1164 return GNUTLS_E_MEMORY_ERROR; 1177 return GNUTLS_E_MEMORY_ERROR;
@@ -1167,7 +1180,7 @@ int _gnutls_handshake_buffer_put(gnutls_session_t session,
1167 _gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data\n", length); 1180 _gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data\n", length);
1168 1181
1169 if (_gnutls_buffer_append (&session->internals.handshake_hash_buffer, data, 1182 if (_gnutls_buffer_append (&session->internals.handshake_hash_buffer, data,
1170 length) < 0) 1183 length) < 0)
1171 { 1184 {
1172 gnutls_assert (); 1185 gnutls_assert ();
1173 return GNUTLS_E_MEMORY_ERROR; 1186 return GNUTLS_E_MEMORY_ERROR;
@@ -1176,7 +1189,8 @@ int _gnutls_handshake_buffer_put(gnutls_session_t session,
1176 return 0; 1189 return 0;
1177} 1190}
1178 1191
1179int _gnutls_handshake_buffer_get_size(gnutls_session_t session) 1192int
1193_gnutls_handshake_buffer_get_size (gnutls_session_t session)
1180{ 1194{
1181 1195
1182 return session->internals.handshake_hash_buffer.length; 1196 return session->internals.handshake_hash_buffer.length;
@@ -1185,9 +1199,9 @@ int _gnutls_handshake_buffer_get_size(gnutls_session_t session)
1185/* this function does not touch the buffer 1199/* this function does not touch the buffer
1186 * and returns data from it (peek mode!) 1200 * and returns data from it (peek mode!)
1187 */ 1201 */
1188int _gnutls_handshake_buffer_peek(gnutls_session_t session, 1202int
1189 opaque * data, 1203_gnutls_handshake_buffer_peek (gnutls_session_t session,
1190 size_t length) 1204 opaque * data, size_t length)
1191{ 1205{
1192 if (length > session->internals.handshake_hash_buffer.length) 1206 if (length > session->internals.handshake_hash_buffer.length)
1193 { 1207 {
@@ -1196,16 +1210,16 @@ int _gnutls_handshake_buffer_peek(gnutls_session_t session,
1196 1210
1197 _gnutls_buffers_log ("BUF[HSK]: Peeked %d bytes of Data\n", length); 1211 _gnutls_buffers_log ("BUF[HSK]: Peeked %d bytes of Data\n", length);
1198 1212
1199 memcpy(data, session->internals.handshake_hash_buffer.data, length); 1213 memcpy (data, session->internals.handshake_hash_buffer.data, length);
1200 return length; 1214 return length;
1201} 1215}
1202 1216
1203/* this function does not touch the buffer 1217/* this function does not touch the buffer
1204 * and returns data from it (peek mode!) 1218 * and returns data from it (peek mode!)
1205 */ 1219 */
1206int _gnutls_handshake_buffer_get_ptr(gnutls_session_t session, 1220int
1207 opaque ** data_ptr, 1221_gnutls_handshake_buffer_get_ptr (gnutls_session_t session,
1208 size_t * length) 1222 opaque ** data_ptr, size_t * length)
1209{ 1223{
1210 if (length != NULL) 1224 if (length != NULL)
1211 *length = session->internals.handshake_hash_buffer.length; 1225 *length = session->internals.handshake_hash_buffer.length;
@@ -1220,7 +1234,8 @@ int _gnutls_handshake_buffer_get_ptr(gnutls_session_t session,
1220 1234
1221/* Does not free the buffer 1235/* Does not free the buffer
1222 */ 1236 */
1223int _gnutls_handshake_buffer_empty(gnutls_session_t session) 1237int
1238_gnutls_handshake_buffer_empty (gnutls_session_t session)
1224{ 1239{
1225 1240
1226 _gnutls_buffers_log ("BUF[HSK]: Emptied buffer\n"); 1241 _gnutls_buffers_log ("BUF[HSK]: Emptied buffer\n");
@@ -1230,7 +1245,8 @@ int _gnutls_handshake_buffer_empty(gnutls_session_t session)
1230 return 0; 1245 return 0;
1231} 1246}
1232 1247
1233int _gnutls_handshake_buffer_clear(gnutls_session_t session) 1248int
1249_gnutls_handshake_buffer_clear (gnutls_session_t session)
1234{ 1250{
1235 1251
1236 _gnutls_buffers_log ("BUF[HSK]: Cleared Data from buffer\n"); 1252 _gnutls_buffers_log ("BUF[HSK]: Cleared Data from buffer\n");
diff --git a/src/daemon/https/tls/gnutls_cert.c b/src/daemon/https/tls/gnutls_cert.c
index 0160d644..63c0b497 100644
--- a/src/daemon/https/tls/gnutls_cert.c
+++ b/src/daemon/https/tls/gnutls_cert.c
@@ -453,14 +453,14 @@ _gnutls_openpgp_crt_verify_peers (gnutls_session_t session,
453 gnutls_certificate_credentials_t cred; 453 gnutls_certificate_credentials_t cred;
454 int peer_certificate_list_size, ret; 454 int peer_certificate_list_size, ret;
455 455
456 CHECK_AUTH (GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST); 456 CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
457 457
458 info = _gnutls_get_auth_info (session); 458 info = _gnutls_get_auth_info (session);
459 if (info == NULL) 459 if (info == NULL)
460 return GNUTLS_E_INVALID_REQUEST; 460 return GNUTLS_E_INVALID_REQUEST;
461 461
462 cred = (gnutls_certificate_credentials_t) 462 cred = (gnutls_certificate_credentials_t)
463 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 463 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
464 if (cred == NULL) 464 if (cred == NULL)
465 { 465 {
466 gnutls_assert (); 466 gnutls_assert ();
@@ -537,7 +537,7 @@ gnutls_certificate_verify_peers2 (gnutls_session_t session,
537{ 537{
538 cert_auth_info_t info; 538 cert_auth_info_t info;
539 539
540 CHECK_AUTH (GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST); 540 CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
541 541
542 info = _gnutls_get_auth_info (session); 542 info = _gnutls_get_auth_info (session);
543 if (info == NULL) 543 if (info == NULL)
@@ -550,9 +550,9 @@ gnutls_certificate_verify_peers2 (gnutls_session_t session,
550 550
551 switch (gnutls_certificate_type_get (session)) 551 switch (gnutls_certificate_type_get (session))
552 { 552 {
553 case GNUTLS_CRT_X509: 553 case MHD_GNUTLS_CRT_X509:
554 return _gnutls_x509_cert_verify_peers (session, status); 554 return _gnutls_x509_cert_verify_peers (session, status);
555 case GNUTLS_CRT_OPENPGP: 555 case MHD_GNUTLS_CRT_OPENPGP:
556 return _gnutls_openpgp_crt_verify_peers (session, status); 556 return _gnutls_openpgp_crt_verify_peers (session, status);
557 default: 557 default:
558 return GNUTLS_E_INVALID_REQUEST; 558 return GNUTLS_E_INVALID_REQUEST;
@@ -606,7 +606,7 @@ gnutls_certificate_expiration_time_peers (gnutls_session_t session)
606{ 606{
607 cert_auth_info_t info; 607 cert_auth_info_t info;
608 608
609 CHECK_AUTH (GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST); 609 CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
610 610
611 info = _gnutls_get_auth_info (session); 611 info = _gnutls_get_auth_info (session);
612 if (info == NULL) 612 if (info == NULL)
@@ -622,11 +622,11 @@ gnutls_certificate_expiration_time_peers (gnutls_session_t session)
622 622
623 switch (gnutls_certificate_type_get (session)) 623 switch (gnutls_certificate_type_get (session))
624 { 624 {
625 case GNUTLS_CRT_X509: 625 case MHD_GNUTLS_CRT_X509:
626 return _gnutls_x509_get_raw_crt_expiration_time (&info-> 626 return _gnutls_x509_get_raw_crt_expiration_time (&info->
627 raw_certificate_list 627 raw_certificate_list
628 [0]); 628 [0]);
629 case GNUTLS_CRT_OPENPGP: 629 case MHD_GNUTLS_CRT_OPENPGP:
630 if (_E_gnutls_openpgp_get_raw_key_expiration_time == NULL) 630 if (_E_gnutls_openpgp_get_raw_key_expiration_time == NULL)
631 return (time_t) - 1; 631 return (time_t) - 1;
632 return _E_gnutls_openpgp_get_raw_key_expiration_time (&info-> 632 return _E_gnutls_openpgp_get_raw_key_expiration_time (&info->
@@ -651,7 +651,7 @@ gnutls_certificate_activation_time_peers (gnutls_session_t session)
651{ 651{
652 cert_auth_info_t info; 652 cert_auth_info_t info;
653 653
654 CHECK_AUTH (GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST); 654 CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
655 655
656 info = _gnutls_get_auth_info (session); 656 info = _gnutls_get_auth_info (session);
657 if (info == NULL) 657 if (info == NULL)
@@ -667,11 +667,11 @@ gnutls_certificate_activation_time_peers (gnutls_session_t session)
667 667
668 switch (gnutls_certificate_type_get (session)) 668 switch (gnutls_certificate_type_get (session))
669 { 669 {
670 case GNUTLS_CRT_X509: 670 case MHD_GNUTLS_CRT_X509:
671 return _gnutls_x509_get_raw_crt_activation_time (&info-> 671 return _gnutls_x509_get_raw_crt_activation_time (&info->
672 raw_certificate_list 672 raw_certificate_list
673 [0]); 673 [0]);
674 case GNUTLS_CRT_OPENPGP: 674 case MHD_GNUTLS_CRT_OPENPGP:
675 if (_E_gnutls_openpgp_get_raw_key_creation_time == NULL) 675 if (_E_gnutls_openpgp_get_raw_key_creation_time == NULL)
676 return (time_t) - 1; 676 return (time_t) - 1;
677 return _E_gnutls_openpgp_get_raw_key_creation_time (&info-> 677 return _E_gnutls_openpgp_get_raw_key_creation_time (&info->
@@ -690,9 +690,9 @@ _gnutls_raw_cert_to_gcert (gnutls_cert * gcert,
690{ 690{
691 switch (type) 691 switch (type)
692 { 692 {
693 case GNUTLS_CRT_X509: 693 case MHD_GNUTLS_CRT_X509:
694 return _gnutls_x509_raw_cert_to_gcert (gcert, raw_cert, flags); 694 return _gnutls_x509_raw_cert_to_gcert (gcert, raw_cert, flags);
695 case GNUTLS_CRT_OPENPGP: 695 case MHD_GNUTLS_CRT_OPENPGP:
696 if (_E_gnutls_openpgp_raw_key_to_gcert == NULL) 696 if (_E_gnutls_openpgp_raw_key_to_gcert == NULL)
697 { 697 {
698 gnutls_assert (); 698 gnutls_assert ();
@@ -713,9 +713,9 @@ _gnutls_raw_privkey_to_gkey (gnutls_privkey * key,
713{ 713{
714 switch (type) 714 switch (type)
715 { 715 {
716 case GNUTLS_CRT_X509: 716 case MHD_GNUTLS_CRT_X509:
717 return _gnutls_x509_raw_privkey_to_gkey (key, raw_key, key_enc); 717 return _gnutls_x509_raw_privkey_to_gkey (key, raw_key, key_enc);
718 case GNUTLS_CRT_OPENPGP: 718 case MHD_GNUTLS_CRT_OPENPGP:
719 if (_E_gnutls_openpgp_raw_privkey_to_gkey == NULL) 719 if (_E_gnutls_openpgp_raw_privkey_to_gkey == NULL)
720 { 720 {
721 gnutls_assert (); 721 gnutls_assert ();
@@ -778,7 +778,7 @@ _gnutls_x509_crt_to_gcert (gnutls_cert * gcert,
778 int ret = 0; 778 int ret = 0;
779 779
780 memset (gcert, 0, sizeof (gnutls_cert)); 780 memset (gcert, 0, sizeof (gnutls_cert));
781 gcert->cert_type = GNUTLS_CRT_X509; 781 gcert->cert_type = MHD_GNUTLS_CRT_X509;
782 782
783 if (!(flags & CERT_NO_COPY)) 783 if (!(flags & CERT_NO_COPY))
784 { 784 {
diff --git a/src/daemon/https/tls/gnutls_cipher.c b/src/daemon/https/tls/gnutls_cipher.c
index 8245b1c0..c9526ec6 100644
--- a/src/daemon/https/tls/gnutls_cipher.c
+++ b/src/daemon/https/tls/gnutls_cipher.c
@@ -45,7 +45,7 @@ inline static int
45is_write_comp_null (gnutls_session_t session) 45is_write_comp_null (gnutls_session_t session)
46{ 46{
47 if (session->security_parameters.write_compression_algorithm == 47 if (session->security_parameters.write_compression_algorithm ==
48 GNUTLS_COMP_NULL) 48 MHD_GNUTLS_COMP_NULL)
49 return 0; 49 return 0;
50 50
51 return 1; 51 return 1;
@@ -55,7 +55,7 @@ inline static int
55is_read_comp_null (gnutls_session_t session) 55is_read_comp_null (gnutls_session_t session)
56{ 56{
57 if (session->security_parameters.read_compression_algorithm == 57 if (session->security_parameters.read_compression_algorithm ==
58 GNUTLS_COMP_NULL) 58 MHD_GNUTLS_COMP_NULL)
59 return 0; 59 return 0;
60 60
61 return 1; 61 return 1;
@@ -64,7 +64,7 @@ is_read_comp_null (gnutls_session_t session)
64 64
65/* returns ciphertext which contains the headers too. This also 65/* returns ciphertext which contains the headers too. This also
66 * calculates the size in the header field. 66 * calculates the size in the header field.
67 * 67 *
68 * If random pad != 0 then the random pad data will be appended. 68 * If random pad != 0 then the random pad data will be appended.
69 */ 69 */
70int 70int
@@ -88,7 +88,7 @@ _gnutls_encrypt (gnutls_session_t session, const opaque * headers,
88 } 88 }
89 else 89 else
90 { 90 {
91 /* Here comp is allocated and must be 91 /* Here comp is allocated and must be
92 * freed. 92 * freed.
93 */ 93 */
94 ret = _gnutls_m_plaintext2compressed (session, &comp, &plain); 94 ret = _gnutls_m_plaintext2compressed (session, &comp, &plain);
@@ -199,10 +199,10 @@ mac_init (gnutls_mac_algorithm_t mac, opaque * secret, int secret_size,
199{ 199{
200 mac_hd_t td; 200 mac_hd_t td;
201 201
202 if (mac == GNUTLS_MAC_NULL) 202 if (mac == MHD_GNUTLS_MAC_NULL)
203 return GNUTLS_MAC_FAILED; 203 return GNUTLS_MAC_FAILED;
204 204
205 if (ver == GNUTLS_SSL3) 205 if (ver == MHD_GNUTLS_SSL3)
206 { /* SSL 3.0 */ 206 { /* SSL 3.0 */
207 td = _gnutls_mac_init_ssl3 (mac, secret, secret_size); 207 td = _gnutls_mac_init_ssl3 (mac, secret, secret_size);
208 } 208 }
@@ -217,7 +217,7 @@ mac_init (gnutls_mac_algorithm_t mac, opaque * secret, int secret_size,
217inline static void 217inline static void
218mac_deinit (mac_hd_t td, opaque * res, int ver) 218mac_deinit (mac_hd_t td, opaque * res, int ver)
219{ 219{
220 if (ver == GNUTLS_SSL3) 220 if (ver == MHD_GNUTLS_SSL3)
221 { /* SSL 3.0 */ 221 { /* SSL 3.0 */
222 _gnutls_mac_deinit_ssl3 (td, res); 222 _gnutls_mac_deinit_ssl3 (td, res);
223 } 223 }
@@ -251,7 +251,7 @@ calc_enc_length (gnutls_session_t session, int data_size,
251 } 251 }
252 252
253 /* make rnd a multiple of blocksize */ 253 /* make rnd a multiple of blocksize */
254 if (session->security_parameters.version == GNUTLS_SSL3 || 254 if (session->security_parameters.version == MHD_GNUTLS_SSL3 ||
255 random_pad == 0) 255 random_pad == 0)
256 { 256 {
257 rnd = 0; 257 rnd = 0;
@@ -271,7 +271,7 @@ calc_enc_length (gnutls_session_t session, int data_size,
271 *pad = (uint8_t) (blocksize - (length % blocksize)) + rnd; 271 *pad = (uint8_t) (blocksize - (length % blocksize)) + rnd;
272 272
273 length += *pad; 273 length += *pad;
274 if (session->security_parameters.version >= GNUTLS_TLS1_1) 274 if (session->security_parameters.version >= MHD_GNUTLS_TLS1_1)
275 length += blocksize; /* for the IV */ 275 length += blocksize; /* for the IV */
276 276
277 break; 277 break;
@@ -283,7 +283,7 @@ calc_enc_length (gnutls_session_t session, int data_size,
283 return length; 283 return length;
284} 284}
285 285
286/* This is the actual encryption 286/* This is the actual encryption
287 * Encrypts the given compressed datum, and puts the result to cipher_data, 287 * Encrypts the given compressed datum, and puts the result to cipher_data,
288 * which has cipher_size size. 288 * which has cipher_size size.
289 * return the actual encrypted data length. 289 * return the actual encrypted data length.
@@ -325,7 +325,8 @@ _gnutls_compressed2ciphertext (gnutls_session_t session,
325 session->connection_state.write_mac_secret.size, ver); 325 session->connection_state.write_mac_secret.size, ver);
326 326
327 if (td == GNUTLS_MAC_FAILED 327 if (td == GNUTLS_MAC_FAILED
328 && session->security_parameters.write_mac_algorithm != GNUTLS_MAC_NULL) 328 && session->security_parameters.write_mac_algorithm !=
329 MHD_GNUTLS_MAC_NULL)
329 { 330 {
330 gnutls_assert (); 331 gnutls_assert ();
331 return GNUTLS_E_INTERNAL_ERROR; 332 return GNUTLS_E_INTERNAL_ERROR;
@@ -340,7 +341,7 @@ _gnutls_compressed2ciphertext (gnutls_session_t session,
340 write_sequence_number), 8); 341 write_sequence_number), 8);
341 342
342 _gnutls_hmac (td, &type, 1); 343 _gnutls_hmac (td, &type, 1);
343 if (ver >= GNUTLS_TLS1) 344 if (ver >= MHD_GNUTLS_TLS1_0)
344 { /* TLS 1.0 or higher */ 345 { /* TLS 1.0 or higher */
345 _gnutls_hmac (td, &major, 1); 346 _gnutls_hmac (td, &major, 1);
346 _gnutls_hmac (td, &minor, 1); 347 _gnutls_hmac (td, &minor, 1);
@@ -372,7 +373,7 @@ _gnutls_compressed2ciphertext (gnutls_session_t session,
372 373
373 data_ptr = cipher_data; 374 data_ptr = cipher_data;
374 if (block_algo == CIPHER_BLOCK && 375 if (block_algo == CIPHER_BLOCK &&
375 session->security_parameters.version >= GNUTLS_TLS1_1) 376 session->security_parameters.version >= MHD_GNUTLS_TLS1_1)
376 { 377 {
377 /* copy the random IV. 378 /* copy the random IV.
378 */ 379 */
@@ -440,14 +441,15 @@ _gnutls_ciphertext2compressed (gnutls_session_t session,
440 blocksize = _gnutls_cipher_get_block_size (session->security_parameters. 441 blocksize = _gnutls_cipher_get_block_size (session->security_parameters.
441 read_bulk_cipher_algorithm); 442 read_bulk_cipher_algorithm);
442 443
443 /* initialize MAC 444 /* initialize MAC
444 */ 445 */
445 td = mac_init (session->security_parameters.read_mac_algorithm, 446 td = mac_init (session->security_parameters.read_mac_algorithm,
446 session->connection_state.read_mac_secret.data, 447 session->connection_state.read_mac_secret.data,
447 session->connection_state.read_mac_secret.size, ver); 448 session->connection_state.read_mac_secret.size, ver);
448 449
449 if (td == GNUTLS_MAC_FAILED 450 if (td == GNUTLS_MAC_FAILED
450 && session->security_parameters.read_mac_algorithm != GNUTLS_MAC_NULL) 451 && session->security_parameters.read_mac_algorithm !=
452 MHD_GNUTLS_MAC_NULL)
451 { 453 {
452 gnutls_assert (); 454 gnutls_assert ();
453 return GNUTLS_E_INTERNAL_ERROR; 455 return GNUTLS_E_INTERNAL_ERROR;
@@ -490,7 +492,7 @@ _gnutls_ciphertext2compressed (gnutls_session_t session,
490 492
491 /* ignore the IV in TLS 1.1. 493 /* ignore the IV in TLS 1.1.
492 */ 494 */
493 if (session->security_parameters.version >= GNUTLS_TLS1_1) 495 if (session->security_parameters.version >= MHD_GNUTLS_TLS1_1)
494 { 496 {
495 ciphertext.size -= blocksize; 497 ciphertext.size -= blocksize;
496 ciphertext.data += blocksize; 498 ciphertext.data += blocksize;
@@ -517,7 +519,7 @@ _gnutls_ciphertext2compressed (gnutls_session_t session,
517 519
518 /* Check the pading bytes (TLS 1.x) 520 /* Check the pading bytes (TLS 1.x)
519 */ 521 */
520 if (ver >= GNUTLS_TLS1 && pad_failed == 0) 522 if (ver >= MHD_GNUTLS_TLS1_0 && pad_failed == 0)
521 for (i = 2; i < pad; i++) 523 for (i = 2; i < pad; i++)
522 { 524 {
523 if (ciphertext.data[ciphertext.size - i] != 525 if (ciphertext.data[ciphertext.size - i] !=
@@ -544,7 +546,7 @@ _gnutls_ciphertext2compressed (gnutls_session_t session,
544 read_sequence_number), 8); 546 read_sequence_number), 8);
545 547
546 _gnutls_hmac (td, &type, 1); 548 _gnutls_hmac (td, &type, 1);
547 if (ver >= GNUTLS_TLS1) 549 if (ver >= MHD_GNUTLS_TLS1_0)
548 { /* TLS 1.x */ 550 { /* TLS 1.x */
549 _gnutls_hmac (td, &major, 1); 551 _gnutls_hmac (td, &major, 1);
550 _gnutls_hmac (td, &minor, 1); 552 _gnutls_hmac (td, &minor, 1);
@@ -563,7 +565,7 @@ _gnutls_ciphertext2compressed (gnutls_session_t session,
563 if (pad_failed != 0) 565 if (pad_failed != 0)
564 return pad_failed; 566 return pad_failed;
565 567
566 /* HMAC was not the same. 568 /* HMAC was not the same.
567 */ 569 */
568 if (memcmp (MAC, &ciphertext.data[length], hash_size) != 0) 570 if (memcmp (MAC, &ciphertext.data[length], hash_size) != 0)
569 { 571 {
diff --git a/src/daemon/https/tls/gnutls_cipher_int.c b/src/daemon/https/tls/gnutls_cipher_int.c
index c9200e5b..bfe734d5 100644
--- a/src/daemon/https/tls/gnutls_cipher_int.c
+++ b/src/daemon/https/tls/gnutls_cipher_int.c
@@ -36,40 +36,40 @@ _gnutls_cipher_init (gnutls_cipher_algorithm_t cipher,
36 36
37 switch (cipher) 37 switch (cipher)
38 { 38 {
39 case GNUTLS_CIPHER_AES_128_CBC: 39 case MHD_GNUTLS_CIPHER_AES_128_CBC:
40 err = gc_cipher_open (GC_AES128, GC_CBC, &ret); 40 err = gc_cipher_open (GC_AES128, GC_CBC, &ret);
41 break; 41 break;
42 42
43 case GNUTLS_CIPHER_AES_256_CBC: 43 case MHD_GNUTLS_CIPHER_AES_256_CBC:
44 err = gc_cipher_open (GC_AES256, GC_CBC, &ret); 44 err = gc_cipher_open (GC_AES256, GC_CBC, &ret);
45 break; 45 break;
46 46
47 case GNUTLS_CIPHER_3DES_CBC: 47 case MHD_GNUTLS_CIPHER_3DES_CBC:
48 err = gc_cipher_open (GC_3DES, GC_CBC, &ret); 48 err = gc_cipher_open (GC_3DES, GC_CBC, &ret);
49 break; 49 break;
50 50
51 case GNUTLS_CIPHER_DES_CBC: 51 case MHD_GNUTLS_CIPHER_DES_CBC:
52 err = gc_cipher_open (GC_DES, GC_CBC, &ret); 52 err = gc_cipher_open (GC_DES, GC_CBC, &ret);
53 break; 53 break;
54 54
55 case GNUTLS_CIPHER_ARCFOUR_128: 55 case MHD_GNUTLS_CIPHER_ARCFOUR_128:
56 err = gc_cipher_open (GC_ARCFOUR128, GC_STREAM, &ret); 56 err = gc_cipher_open (GC_ARCFOUR128, GC_STREAM, &ret);
57 break; 57 break;
58 58
59 case GNUTLS_CIPHER_ARCFOUR_40: 59 case MHD_GNUTLS_CIPHER_ARCFOUR_40:
60 err = gc_cipher_open (GC_ARCFOUR40, GC_STREAM, &ret); 60 err = gc_cipher_open (GC_ARCFOUR40, GC_STREAM, &ret);
61 break; 61 break;
62 62
63 case GNUTLS_CIPHER_RC2_40_CBC: 63 case MHD_GNUTLS_CIPHER_RC2_40_CBC:
64 err = gc_cipher_open (GC_ARCTWO40, GC_CBC, &ret); 64 err = gc_cipher_open (GC_ARCTWO40, GC_CBC, &ret);
65 break; 65 break;
66 66
67#ifdef ENABLE_CAMELLIA 67#ifdef ENABLE_CAMELLIA
68 case GNUTLS_CIPHER_CAMELLIA_128_CBC: 68 case MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC:
69 err = gc_cipher_open (GC_CAMELLIA128, GC_CBC, &ret); 69 err = gc_cipher_open (GC_CAMELLIA128, GC_CBC, &ret);
70 break; 70 break;
71 71
72 case GNUTLS_CIPHER_CAMELLIA_256_CBC: 72 case MHD_GNUTLS_CIPHER_CAMELLIA_256_CBC:
73 err = gc_cipher_open (GC_CAMELLIA256, GC_CBC, &ret); 73 err = gc_cipher_open (GC_CAMELLIA256, GC_CBC, &ret);
74 break; 74 break;
75#endif 75#endif
@@ -84,7 +84,7 @@ _gnutls_cipher_init (gnutls_cipher_algorithm_t cipher,
84 if (iv->data != NULL && iv->size > 0) 84 if (iv->data != NULL && iv->size > 0)
85 gc_cipher_setiv (ret, iv->size, iv->data); 85 gc_cipher_setiv (ret, iv->size, iv->data);
86 } 86 }
87 else if (cipher != GNUTLS_CIPHER_NULL) 87 else if (cipher != MHD_GNUTLS_CIPHER_NULL)
88 { 88 {
89 gnutls_assert (); 89 gnutls_assert ();
90 _gnutls_x509_log ("Crypto cipher[%d] error: %d\n", cipher, err); 90 _gnutls_x509_log ("Crypto cipher[%d] error: %d\n", cipher, err);
diff --git a/src/daemon/https/tls/gnutls_compress_int.c b/src/daemon/https/tls/gnutls_compress_int.c
index ecb439e5..77c733b0 100644
--- a/src/daemon/https/tls/gnutls_compress_int.c
+++ b/src/daemon/https/tls/gnutls_compress_int.c
@@ -48,7 +48,7 @@ _gnutls_comp_init (gnutls_compression_method_t method, int d)
48 switch (method) 48 switch (method)
49 { 49 {
50#ifdef HAVE_LIBZ 50#ifdef HAVE_LIBZ
51 case GNUTLS_COMP_DEFLATE: 51 case MHD_GNUTLS_COMP_DEFLATE:
52 { 52 {
53 int window_bits, mem_level; 53 int window_bits, mem_level;
54 int comp_level; 54 int comp_level;
@@ -88,7 +88,7 @@ _gnutls_comp_init (gnutls_compression_method_t method, int d)
88 break; 88 break;
89 } 89 }
90#endif 90#endif
91 case GNUTLS_COMP_NULL: 91 case MHD_GNUTLS_COMP_NULL:
92 break; 92 break;
93 } 93 }
94 return ret; 94 return ret;
@@ -109,7 +109,7 @@ _gnutls_comp_deinit (comp_hd_t handle, int d)
109 switch (handle->algo) 109 switch (handle->algo)
110 { 110 {
111#ifdef HAVE_LIBZ 111#ifdef HAVE_LIBZ
112 case GNUTLS_COMP_DEFLATE: 112 case MHD_GNUTLS_COMP_DEFLATE:
113 if (d) 113 if (d)
114 err = inflateEnd (handle->handle); 114 err = inflateEnd (handle->handle);
115 else 115 else
@@ -147,7 +147,7 @@ _gnutls_compress (comp_hd_t handle, const opaque * plain,
147 { 147 {
148 148
149#ifdef HAVE_LIBZ 149#ifdef HAVE_LIBZ
150 case GNUTLS_COMP_DEFLATE: 150 case MHD_GNUTLS_COMP_DEFLATE:
151 { 151 {
152 uLongf size; 152 uLongf size;
153 z_stream *zhandle; 153 z_stream *zhandle;
@@ -228,7 +228,7 @@ _gnutls_decompress (comp_hd_t handle, opaque * compressed,
228 switch (handle->algo) 228 switch (handle->algo)
229 { 229 {
230#ifdef HAVE_LIBZ 230#ifdef HAVE_LIBZ
231 case GNUTLS_COMP_DEFLATE: 231 case MHD_GNUTLS_COMP_DEFLATE:
232 { 232 {
233 uLongf out_size; 233 uLongf out_size;
234 z_stream *zhandle; 234 z_stream *zhandle;
diff --git a/src/daemon/https/tls/gnutls_constate.c b/src/daemon/https/tls/gnutls_constate.c
index c2323c46..eff2184f 100644
--- a/src/daemon/https/tls/gnutls_constate.c
+++ b/src/daemon/https/tls/gnutls_constate.c
@@ -96,7 +96,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
96 memcpy (&rrnd[TLS_RANDOM_SIZE], 96 memcpy (&rrnd[TLS_RANDOM_SIZE],
97 session->security_parameters.server_random, TLS_RANDOM_SIZE); 97 session->security_parameters.server_random, TLS_RANDOM_SIZE);
98 98
99 if (session->security_parameters.version == GNUTLS_SSL3) 99 if (session->security_parameters.version == MHD_GNUTLS_SSL3)
100 { /* SSL 3 */ 100 { /* SSL 3 */
101 ret = 101 ret =
102 _gnutls_ssl3_generate_random (session-> 102 _gnutls_ssl3_generate_random (session->
@@ -189,7 +189,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
189 189
190 /* generate the final keys */ 190 /* generate the final keys */
191 191
192 if (session->security_parameters.version == GNUTLS_SSL3) 192 if (session->security_parameters.version == MHD_GNUTLS_SSL3)
193 { /* SSL 3 */ 193 { /* SSL 3 */
194 ret = 194 ret =
195 _gnutls_ssl3_hash_md5 (&key_block[pos], 195 _gnutls_ssl3_hash_md5 (&key_block[pos],
@@ -221,7 +221,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
221 client_write_key_size = EXPORT_FINAL_KEY_SIZE; 221 client_write_key_size = EXPORT_FINAL_KEY_SIZE;
222 pos += key_size; 222 pos += key_size;
223 223
224 if (session->security_parameters.version == GNUTLS_SSL3) 224 if (session->security_parameters.version == MHD_GNUTLS_SSL3)
225 { /* SSL 3 */ 225 { /* SSL 3 */
226 ret = 226 ret =
227 _gnutls_ssl3_hash_md5 (&key_block[pos], key_size, 227 _gnutls_ssl3_hash_md5 (&key_block[pos], key_size,
@@ -323,7 +323,7 @@ _gnutls_set_keys (gnutls_session_t session, int hash_size, int IV_size,
323 return GNUTLS_E_MEMORY_ERROR; 323 return GNUTLS_E_MEMORY_ERROR;
324 } 324 }
325 325
326 if (session->security_parameters.version == GNUTLS_SSL3) 326 if (session->security_parameters.version == MHD_GNUTLS_SSL3)
327 { /* SSL 3 */ 327 { /* SSL 3 */
328 ret = _gnutls_ssl3_hash_md5 ("", 0, 328 ret = _gnutls_ssl3_hash_md5 ("", 0,
329 rrnd, TLS_RANDOM_SIZE * 2, 329 rrnd, TLS_RANDOM_SIZE * 2,
@@ -596,7 +596,7 @@ _gnutls_read_connection_state_init (gnutls_session_t session)
596 if (session->connection_state.read_cipher_state == 596 if (session->connection_state.read_cipher_state ==
597 GNUTLS_CIPHER_FAILED 597 GNUTLS_CIPHER_FAILED
598 && session->security_parameters. 598 && session->security_parameters.
599 read_bulk_cipher_algorithm != GNUTLS_CIPHER_NULL) 599 read_bulk_cipher_algorithm != MHD_GNUTLS_CIPHER_NULL)
600 { 600 {
601 gnutls_assert (); 601 gnutls_assert ();
602 return GNUTLS_E_INTERNAL_ERROR; 602 return GNUTLS_E_INTERNAL_ERROR;
@@ -633,7 +633,7 @@ _gnutls_read_connection_state_init (gnutls_session_t session)
633 if (session->connection_state.read_cipher_state == 633 if (session->connection_state.read_cipher_state ==
634 GNUTLS_CIPHER_FAILED 634 GNUTLS_CIPHER_FAILED
635 && session->security_parameters. 635 && session->security_parameters.
636 read_bulk_cipher_algorithm != GNUTLS_CIPHER_NULL) 636 read_bulk_cipher_algorithm != MHD_GNUTLS_CIPHER_NULL)
637 { 637 {
638 gnutls_assert (); 638 gnutls_assert ();
639 return GNUTLS_E_INTERNAL_ERROR; 639 return GNUTLS_E_INTERNAL_ERROR;
@@ -788,7 +788,7 @@ _gnutls_write_connection_state_init (gnutls_session_t session)
788 if (session->connection_state.write_cipher_state == 788 if (session->connection_state.write_cipher_state ==
789 GNUTLS_CIPHER_FAILED 789 GNUTLS_CIPHER_FAILED
790 && session->security_parameters. 790 && session->security_parameters.
791 write_bulk_cipher_algorithm != GNUTLS_CIPHER_NULL) 791 write_bulk_cipher_algorithm != MHD_GNUTLS_CIPHER_NULL)
792 { 792 {
793 gnutls_assert (); 793 gnutls_assert ();
794 return GNUTLS_E_INTERNAL_ERROR; 794 return GNUTLS_E_INTERNAL_ERROR;
@@ -827,7 +827,7 @@ _gnutls_write_connection_state_init (gnutls_session_t session)
827 if (session->connection_state.write_cipher_state == 827 if (session->connection_state.write_cipher_state ==
828 GNUTLS_CIPHER_FAILED 828 GNUTLS_CIPHER_FAILED
829 && session->security_parameters. 829 && session->security_parameters.
830 write_bulk_cipher_algorithm != GNUTLS_CIPHER_NULL) 830 write_bulk_cipher_algorithm != MHD_GNUTLS_CIPHER_NULL)
831 { 831 {
832 gnutls_assert (); 832 gnutls_assert ();
833 return GNUTLS_E_INTERNAL_ERROR; 833 return GNUTLS_E_INTERNAL_ERROR;
diff --git a/src/daemon/https/tls/gnutls_global.c b/src/daemon/https/tls/gnutls_global.c
index ddd3f426..5df0619b 100644
--- a/src/daemon/https/tls/gnutls_global.c
+++ b/src/daemon/https/tls/gnutls_global.c
@@ -35,7 +35,7 @@
35#include "internal.h" 35#include "internal.h"
36 36
37/* TODO fix : needed by GCRY_THREAD_OPTION_PTHREAD_IMPL but missing otherwise */ 37/* TODO fix : needed by GCRY_THREAD_OPTION_PTHREAD_IMPL but missing otherwise */
38#define ENOMEM 12 /* Out of memory */ 38#define ENOMEM 12 /* Out of memory */
39 39
40#ifdef HAVE_WINSOCK 40#ifdef HAVE_WINSOCK
41# include <winsock2.h> 41# include <winsock2.h>
@@ -53,7 +53,7 @@ extern const ASN1_ARRAY_TYPE gnutls_asn1_tab[];
53extern const ASN1_ARRAY_TYPE pkix_asn1_tab[]; 53extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
54 54
55LOG_FUNC _gnutls_log_func; 55LOG_FUNC _gnutls_log_func;
56int _gnutls_log_level = 0; /* default log level */ 56int _gnutls_log_level = 0; /* default log level */
57 57
58ASN1_TYPE _gnutls_pkix1_asn; 58ASN1_TYPE _gnutls_pkix1_asn;
59ASN1_TYPE _gnutls_gnutls_asn; 59ASN1_TYPE _gnutls_gnutls_asn;
@@ -148,7 +148,7 @@ gnutls_global_set_mem_functions (gnutls_alloc_function alloc_func,
148 gnutls_calloc = calloc; 148 gnutls_calloc = calloc;
149 } 149 }
150 else 150 else
151 { /* use the included ones */ 151 { /* use the included ones */
152 gnutls_calloc = _gnutls_calloc; 152 gnutls_calloc = _gnutls_calloc;
153 } 153 }
154 gnutls_strdup = _gnutls_strdup; 154 gnutls_strdup = _gnutls_strdup;
@@ -237,20 +237,20 @@ gnutls_global_init (void)
237 const char *p; 237 const char *p;
238 238
239 /* to enable multi-threading this call must precede any other call made to libgcrypt */ 239 /* to enable multi-threading this call must precede any other call made to libgcrypt */
240 gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread); 240 gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
241 241
242 /* set p to point at the required version of gcrypt */ 242 /* set p to point at the required version of gcrypt */
243 p = strchr(MHD_GCRYPT_VERSION, ':'); 243 p = strchr (MHD_GCRYPT_VERSION, ':');
244 if (p == NULL) 244 if (p == NULL)
245 p = MHD_GCRYPT_VERSION; 245 p = MHD_GCRYPT_VERSION;
246 else 246 else
247 p++; 247 p++;
248 248
249 /* this call initializes libgcrypt */ 249 /* this call initializes libgcrypt */
250 if (gcry_check_version(p) == NULL) 250 if (gcry_check_version (p) == NULL)
251 { 251 {
252 gnutls_assert(); 252 gnutls_assert ();
253 _gnutls_debug_log("Checking for libgcrypt failed '%s'\n", p); 253 _gnutls_debug_log ("Checking for libgcrypt failed '%s'\n", p);
254 return GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY; 254 return GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY;
255 } 255 }
256 256
@@ -279,17 +279,17 @@ gnutls_global_init (void)
279 } 279 }
280 280
281#ifdef DEBUG 281#ifdef DEBUG
282 gnutls_global_set_log_function(MHD_tls_log_func); 282 gnutls_global_set_log_function (MHD_tls_log_func);
283#endif 283#endif
284 284
285 /* initialize parser 285 /* initialize parser
286 * This should not deal with files in the final 286 * This should not deal with files in the final
287 * version. 287 * version.
288 */ 288 */
289 res = asn1_array2tree(pkix_asn1_tab, &_gnutls_pkix1_asn, NULL); 289 res = asn1_array2tree (pkix_asn1_tab, &_gnutls_pkix1_asn, NULL);
290 if (res != ASN1_SUCCESS) 290 if (res != ASN1_SUCCESS)
291 { 291 {
292 result = _gnutls_asn2err(res); 292 result = _gnutls_asn2err (res);
293 return result; 293 return result;
294 } 294 }
295 295
@@ -376,30 +376,3 @@ gnutls_transport_set_push_function (gnutls_session_t session,
376{ 376{
377 session->internals._gnutls_push_func = push_func; 377 session->internals._gnutls_push_func = push_func;
378} 378}
379
380#include <strverscmp.h>
381
382/**
383 * gnutls_check_version - This function checks the library's version
384 * @req_version: the version to check
385 *
386 * Check that the version of the library is at minimum the requested one
387 * and return the version string; return NULL if the condition is not
388 * satisfied. If a NULL is passed to this function, no check is done,
389 * but the version string is simply returned.
390 *
391 * See %LIBGNUTLS_VERSION for a suitable @req_version string.
392 *
393 * Return value: Version string of run-time library, or NULL if the
394 * run-time library does not meet the required version number. If
395 * %NULL is passed to this function no check is done and only the
396 * version string is returned.
397 **/
398const char *
399gnutls_check_version (const char *req_version)
400{
401 if (!req_version || strverscmp (req_version, VERSION) <= 0)
402 return VERSION;
403
404 return NULL;
405}
diff --git a/src/daemon/https/tls/gnutls_handshake.c b/src/daemon/https/tls/gnutls_handshake.c
index f943a669..991ef3cb 100644
--- a/src/daemon/https/tls/gnutls_handshake.c
+++ b/src/daemon/https/tls/gnutls_handshake.c
@@ -198,7 +198,7 @@ _gnutls_finished (gnutls_session_t session, int type, void *ret)
198 mac_hd_t td_sha; 198 mac_hd_t td_sha;
199 gnutls_protocol_t ver = gnutls_protocol_get_version (session); 199 gnutls_protocol_t ver = gnutls_protocol_get_version (session);
200 200
201 if (ver < GNUTLS_TLS1_2) 201 if (ver < MHD_GNUTLS_TLS1_2)
202 { 202 {
203 td_md5 = 203 td_md5 =
204 _gnutls_hash_copy (session->internals.handshake_mac_handle_md5); 204 _gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
@@ -217,7 +217,7 @@ _gnutls_finished (gnutls_session_t session, int type, void *ret)
217 return GNUTLS_E_HASH_FAILED; 217 return GNUTLS_E_HASH_FAILED;
218 } 218 }
219 219
220 if (ver < GNUTLS_TLS1_2) 220 if (ver < MHD_GNUTLS_TLS1_2)
221 { 221 {
222 _gnutls_hash_deinit (td_md5, concat); 222 _gnutls_hash_deinit (td_md5, concat);
223 _gnutls_hash_deinit (td_sha, &concat[16]); 223 _gnutls_hash_deinit (td_sha, &concat[16]);
@@ -283,7 +283,7 @@ _gnutls_negotiate_version (gnutls_session_t session,
283 * then we send him the highest we support. 283 * then we send him the highest we support.
284 */ 284 */
285 ret = _gnutls_version_max (session); 285 ret = _gnutls_version_max (session);
286 if (ret == GNUTLS_VERSION_UNKNOWN) 286 if (ret == MHD_GNUTLS_VERSION_UNKNOWN)
287 { 287 {
288 /* this check is not really needed. 288 /* this check is not really needed.
289 */ 289 */
@@ -423,7 +423,7 @@ _gnutls_read_client_hello (gnutls_session_t session, opaque * data,
423 423
424 /* Parse the extensions (if any) 424 /* Parse the extensions (if any)
425 */ 425 */
426 if (neg_version >= GNUTLS_TLS1) 426 if (neg_version >= MHD_GNUTLS_TLS1_0)
427 { 427 {
428 ret = _gnutls_parse_extensions (session, EXTENSION_APPLICATION, &data[pos], len); /* len is the rest of the parsed length */ 428 ret = _gnutls_parse_extensions (session, EXTENSION_APPLICATION, &data[pos], len); /* len is the rest of the parsed length */
429 if (ret < 0) 429 if (ret < 0)
@@ -440,7 +440,7 @@ _gnutls_read_client_hello (gnutls_session_t session, opaque * data,
440 return ret; 440 return ret;
441 } 441 }
442 442
443 if (neg_version >= GNUTLS_TLS1) 443 if (neg_version >= MHD_GNUTLS_TLS1_0)
444 { 444 {
445 ret = _gnutls_parse_extensions (session, EXTENSION_TLS, &data[pos], len); /* len is the rest of the parsed length */ 445 ret = _gnutls_parse_extensions (session, EXTENSION_TLS, &data[pos], len); /* len is the rest of the parsed length */
446 if (ret < 0) 446 if (ret < 0)
@@ -530,7 +530,7 @@ _gnutls_send_finished (gnutls_session_t session, int again)
530 return ret; 530 return ret;
531 } 531 }
532 532
533 if (gnutls_protocol_get_version (session) == GNUTLS_SSL3) 533 if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
534 { 534 {
535 ret = 535 ret =
536 _gnutls_ssl3_finished (session, 536 _gnutls_ssl3_finished (session,
@@ -582,7 +582,7 @@ _gnutls_recv_finished (gnutls_session_t session)
582 } 582 }
583 583
584 584
585 if (gnutls_protocol_get_version (session) == GNUTLS_SSL3) 585 if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
586 { 586 {
587 data_size = 36; 587 data_size = 36;
588 } 588 }
@@ -598,7 +598,7 @@ _gnutls_recv_finished (gnutls_session_t session)
598 return GNUTLS_E_ERROR_IN_FINISHED_PACKET; 598 return GNUTLS_E_ERROR_IN_FINISHED_PACKET;
599 } 599 }
600 600
601 if (gnutls_protocol_get_version (session) == GNUTLS_SSL3) 601 if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
602 { 602 {
603 ret = 603 ret =
604 _gnutls_ssl3_finished (session, 604 _gnutls_ssl3_finished (session,
@@ -653,7 +653,7 @@ _gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
653 memcpy (&cs.suite, &data[j], 2); 653 memcpy (&cs.suite, &data[j], 2);
654 kx = _gnutls_cipher_suite_get_kx_algo (&cs); 654 kx = _gnutls_cipher_suite_get_kx_algo (&cs);
655 655
656 if (_gnutls_map_kx_get_cred (kx, 1) == GNUTLS_CRD_CERTIFICATE) 656 if (_gnutls_map_kx_get_cred (kx, 1) == MHD_GNUTLS_CRD_CERTIFICATE)
657 { 657 {
658 algo = _gnutls_map_pk_get_pk (kx); 658 algo = _gnutls_map_pk_get_pk (kx);
659 659
@@ -848,7 +848,7 @@ _gnutls_server_select_comp_method (gnutls_session_t session,
848 848
849/* This function sends an empty handshake packet. (like hello request). 849/* This function sends an empty handshake packet. (like hello request).
850 * If the previous _gnutls_send_empty_handshake() returned 850 * If the previous _gnutls_send_empty_handshake() returned
851 * GNUTLS_E_AGAIN or GNUTLS_E_INTERRUPTED, then it must be called again 851 * GNUTLS_E_AGAIN or GNUTLS_E_INTERRUPTED, then it must be called again
852 * (until it returns ok), with NULL parameters. 852 * (until it returns ok), with NULL parameters.
853 */ 853 */
854int 854int
@@ -1536,7 +1536,7 @@ _gnutls_read_server_hello (gnutls_session_t session,
1536 1536
1537 /* Parse extensions. 1537 /* Parse extensions.
1538 */ 1538 */
1539 if (version >= GNUTLS_TLS1) 1539 if (version >= MHD_GNUTLS_TLS1_0)
1540 { 1540 {
1541 ret = _gnutls_parse_extensions (session, EXTENSION_ANY, &data[pos], len); /* len is the rest of the parsed length */ 1541 ret = _gnutls_parse_extensions (session, EXTENSION_ANY, &data[pos], len); /* len is the rest of the parsed length */
1542 if (ret < 0) 1542 if (ret < 0)
@@ -1711,7 +1711,7 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
1711 hver = session->internals.resumed_security_parameters.version; 1711 hver = session->internals.resumed_security_parameters.version;
1712 } 1712 }
1713 1713
1714 if (hver == GNUTLS_VERSION_UNKNOWN || hver == 0) 1714 if (hver == MHD_GNUTLS_VERSION_UNKNOWN || hver == 0)
1715 { 1715 {
1716 gnutls_assert (); 1716 gnutls_assert ();
1717 gnutls_free (data); 1717 gnutls_free (data);
@@ -1815,7 +1815,7 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
1815 1815
1816 /* Generate and copy TLS extensions. 1816 /* Generate and copy TLS extensions.
1817 */ 1817 */
1818 if (hver >= GNUTLS_TLS1) 1818 if (hver >= MHD_GNUTLS_TLS1_0)
1819 { 1819 {
1820 extdatalen = 1820 extdatalen =
1821 _gnutls_gen_extensions (session, extdata, sizeof (extdata)); 1821 _gnutls_gen_extensions (session, extdata, sizeof (extdata));
@@ -2105,7 +2105,7 @@ _gnutls_handshake_hash_init (gnutls_session_t session)
2105 if (session->internals.handshake_mac_handle_md5 == NULL) 2105 if (session->internals.handshake_mac_handle_md5 == NULL)
2106 { 2106 {
2107 session->internals.handshake_mac_handle_md5 = 2107 session->internals.handshake_mac_handle_md5 =
2108 _gnutls_hash_init (GNUTLS_MAC_MD5); 2108 _gnutls_hash_init (MHD_GNUTLS_MAC_MD5);
2109 2109
2110 if (session->internals.handshake_mac_handle_md5 == GNUTLS_HASH_FAILED) 2110 if (session->internals.handshake_mac_handle_md5 == GNUTLS_HASH_FAILED)
2111 { 2111 {
@@ -2117,7 +2117,7 @@ _gnutls_handshake_hash_init (gnutls_session_t session)
2117 if (session->internals.handshake_mac_handle_sha == NULL) 2117 if (session->internals.handshake_mac_handle_sha == NULL)
2118 { 2118 {
2119 session->internals.handshake_mac_handle_sha = 2119 session->internals.handshake_mac_handle_sha =
2120 _gnutls_hash_init (GNUTLS_MAC_SHA1); 2120 _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
2121 if (session->internals.handshake_mac_handle_sha == GNUTLS_HASH_FAILED) 2121 if (session->internals.handshake_mac_handle_sha == GNUTLS_HASH_FAILED)
2122 { 2122 {
2123 gnutls_assert (); 2123 gnutls_assert ();
@@ -2717,7 +2717,7 @@ check_server_params (gnutls_session_t session,
2717 2717
2718 /* Read the Diffie Hellman parameters, if any. 2718 /* Read the Diffie Hellman parameters, if any.
2719 */ 2719 */
2720 if (cred_type == GNUTLS_CRD_CERTIFICATE) 2720 if (cred_type == MHD_GNUTLS_CRD_CERTIFICATE)
2721 { 2721 {
2722 int delete; 2722 int delete;
2723 gnutls_certificate_credentials_t x509_cred = 2723 gnutls_certificate_credentials_t x509_cred =
@@ -2753,7 +2753,7 @@ check_server_params (gnutls_session_t session,
2753 2753
2754#ifdef ENABLE_ANON 2754#ifdef ENABLE_ANON
2755 } 2755 }
2756 else if (cred_type == GNUTLS_CRD_ANON) 2756 else if (cred_type == MHD_GNUTLS_CRD_ANON)
2757 { 2757 {
2758 gnutls_anon_server_credentials_t anon_cred = 2758 gnutls_anon_server_credentials_t anon_cred =
2759 (gnutls_anon_server_credentials_t) _gnutls_get_cred (session->key, 2759 (gnutls_anon_server_credentials_t) _gnutls_get_cred (session->key,
@@ -2768,7 +2768,7 @@ check_server_params (gnutls_session_t session,
2768#endif 2768#endif
2769#ifdef ENABLE_PSK 2769#ifdef ENABLE_PSK
2770 } 2770 }
2771 else if (cred_type == GNUTLS_CRD_PSK) 2771 else if (cred_type == MHD_GNUTLS_CRD_PSK)
2772 { 2772 {
2773 gnutls_psk_server_credentials_t psk_cred = 2773 gnutls_psk_server_credentials_t psk_cred =
2774 (gnutls_psk_server_credentials_t) _gnutls_get_cred (session->key, 2774 (gnutls_psk_server_credentials_t) _gnutls_get_cred (session->key,
@@ -2843,7 +2843,7 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
2843 2843
2844 cert_cred = 2844 cert_cred =
2845 (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key, 2845 (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key,
2846 GNUTLS_CRD_CERTIFICATE, 2846 MHD_GNUTLS_CRD_CERTIFICATE,
2847 NULL); 2847 NULL);
2848 2848
2849 /* If there are certificate credentials, find an appropriate certificate 2849 /* If there are certificate credentials, find an appropriate certificate
@@ -2909,9 +2909,9 @@ _gnutls_remove_unwanted_ciphersuites (gnutls_session_t session,
2909 (see cred_mappings in gnutls_algorithms.c), but it also 2909 (see cred_mappings in gnutls_algorithms.c), but it also
2910 requires a SRP credential. Don't use SRP kx unless we have a 2910 requires a SRP credential. Don't use SRP kx unless we have a
2911 SRP credential too. */ 2911 SRP credential too. */
2912 if (kx == GNUTLS_KX_SRP_RSA || kx == GNUTLS_KX_SRP_DSS) 2912 if (kx == MHD_GNUTLS_KX_SRP_RSA || kx == MHD_GNUTLS_KX_SRP_DSS)
2913 { 2913 {
2914 if (!_gnutls_get_cred (session->key, GNUTLS_CRD_SRP, NULL)) 2914 if (!_gnutls_get_cred (session->key, MHD_GNUTLS_CRD_SRP, NULL))
2915 delete = 1; 2915 delete = 1;
2916 } 2916 }
2917 2917
diff --git a/src/daemon/https/tls/gnutls_hash_int.c b/src/daemon/https/tls/gnutls_hash_int.c
index 2574f213..8746613b 100644
--- a/src/daemon/https/tls/gnutls_hash_int.c
+++ b/src/daemon/https/tls/gnutls_hash_int.c
@@ -35,16 +35,16 @@ _gnutls_mac2gc (gnutls_mac_algorithm_t mac)
35{ 35{
36 switch (mac) 36 switch (mac)
37 { 37 {
38 case GNUTLS_MAC_NULL: 38 case MHD_GNUTLS_MAC_NULL:
39 return -1; 39 return -1;
40 break; 40 break;
41 case GNUTLS_MAC_SHA1: 41 case MHD_GNUTLS_MAC_SHA1:
42 return GC_SHA1; 42 return GC_SHA1;
43 break; 43 break;
44 case GNUTLS_MAC_SHA256: 44 case MHD_GNUTLS_MAC_SHA256:
45 return GC_SHA256; 45 return GC_SHA256;
46 break; 46 break;
47 case GNUTLS_MAC_MD5: 47 case MHD_GNUTLS_MAC_MD5:
48 return GC_MD5; 48 return GC_MD5;
49 break; 49 break;
50 default: 50 default:
@@ -193,9 +193,9 @@ get_padsize (gnutls_mac_algorithm_t algorithm)
193{ 193{
194 switch (algorithm) 194 switch (algorithm)
195 { 195 {
196 case GNUTLS_MAC_MD5: 196 case MHD_GNUTLS_MAC_MD5:
197 return 48; 197 return 48;
198 case GNUTLS_MAC_SHA1: 198 case MHD_GNUTLS_MAC_SHA1:
199 return 40; 199 return 40;
200 default: 200 default:
201 return 0; 201 return 0;
@@ -322,7 +322,7 @@ ssl3_sha (int i, opaque * secret, int secret_len,
322 text1[j] = 65 + i; /* A==65 */ 322 text1[j] = 65 + i; /* A==65 */
323 } 323 }
324 324
325 td = _gnutls_hash_init (GNUTLS_MAC_SHA1); 325 td = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
326 if (td == NULL) 326 if (td == NULL)
327 { 327 {
328 gnutls_assert (); 328 gnutls_assert ();
@@ -345,7 +345,7 @@ ssl3_md5 (int i, opaque * secret, int secret_len,
345 mac_hd_t td; 345 mac_hd_t td;
346 int ret; 346 int ret;
347 347
348 td = _gnutls_hash_init (GNUTLS_MAC_MD5); 348 td = _gnutls_hash_init (MHD_GNUTLS_MAC_MD5);
349 if (td == NULL) 349 if (td == NULL)
350 { 350 {
351 gnutls_assert (); 351 gnutls_assert ();
@@ -362,7 +362,7 @@ ssl3_md5 (int i, opaque * secret, int secret_len,
362 return ret; 362 return ret;
363 } 363 }
364 364
365 _gnutls_hash (td, tmp, _gnutls_hash_get_algo_len (GNUTLS_MAC_SHA1)); 365 _gnutls_hash (td, tmp, _gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_SHA1));
366 366
367 _gnutls_hash_deinit (td, digest); 367 _gnutls_hash_deinit (td, digest);
368 return 0; 368 return 0;
@@ -375,9 +375,9 @@ _gnutls_ssl3_hash_md5 (void *first, int first_len,
375{ 375{
376 opaque digest[MAX_HASH_SIZE]; 376 opaque digest[MAX_HASH_SIZE];
377 mac_hd_t td; 377 mac_hd_t td;
378 int block = _gnutls_hash_get_algo_len (GNUTLS_MAC_MD5); 378 int block = _gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
379 379
380 td = _gnutls_hash_init (GNUTLS_MAC_MD5); 380 td = _gnutls_hash_init (MHD_GNUTLS_MAC_MD5);
381 if (td == NULL) 381 if (td == NULL)
382 { 382 {
383 gnutls_assert (); 383 gnutls_assert ();
@@ -408,7 +408,7 @@ _gnutls_ssl3_generate_random (void *secret, int secret_len,
408{ 408{
409 int i = 0, copy, output_bytes; 409 int i = 0, copy, output_bytes;
410 opaque digest[MAX_HASH_SIZE]; 410 opaque digest[MAX_HASH_SIZE];
411 int block = _gnutls_hash_get_algo_len (GNUTLS_MAC_MD5); 411 int block = _gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
412 int result, times; 412 int result, times;
413 413
414 output_bytes = 0; 414 output_bytes = 0;
diff --git a/src/daemon/https/tls/gnutls_int.h b/src/daemon/https/tls/gnutls_int.h
index 0c2133fb..5d30ac58 100644
--- a/src/daemon/https/tls/gnutls_int.h
+++ b/src/daemon/https/tls/gnutls_int.h
@@ -28,7 +28,7 @@
28#include <defines.h> 28#include <defines.h>
29 29
30#include "gnutls.h" 30#include "gnutls.h"
31#include "microhttpsd.h" 31#include "microhttpd.h"
32 32
33#include "extra.h" 33#include "extra.h"
34#include "gnutls_mem.h" 34#include "gnutls_mem.h"
diff --git a/src/daemon/https/tls/gnutls_kx.c b/src/daemon/https/tls/gnutls_kx.c
index 5e7f0d4d..2153a791 100644
--- a/src/daemon/https/tls/gnutls_kx.c
+++ b/src/daemon/https/tls/gnutls_kx.c
@@ -71,7 +71,7 @@ generate_normal_master (gnutls_session_t session, int keep_premaster)
71 _gnutls_bin2hex (session->security_parameters. 71 _gnutls_bin2hex (session->security_parameters.
72 server_random, 32, buf, sizeof (buf))); 72 server_random, 32, buf, sizeof (buf)));
73 73
74 if (gnutls_protocol_get_version (session) == GNUTLS_SSL3) 74 if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3)
75 { 75 {
76 opaque rnd[2 * TLS_RANDOM_SIZE + 1]; 76 opaque rnd[2 * TLS_RANDOM_SIZE + 1];
77 77
@@ -502,7 +502,7 @@ _gnutls_send_client_certificate (gnutls_session_t session, int again)
502 502
503 if (again == 0) 503 if (again == 0)
504 { 504 {
505 if (gnutls_protocol_get_version (session) != GNUTLS_SSL3 || 505 if (gnutls_protocol_get_version (session) != MHD_GNUTLS_SSL3 ||
506 session->internals.selected_cert_list_length > 0) 506 session->internals.selected_cert_list_length > 0)
507 { 507 {
508 /* TLS 1.0 or SSL 3.0 with a valid certificate 508 /* TLS 1.0 or SSL 3.0 with a valid certificate
@@ -523,7 +523,7 @@ _gnutls_send_client_certificate (gnutls_session_t session, int again)
523 * no certificate alert instead of an 523 * no certificate alert instead of an
524 * empty certificate. 524 * empty certificate.
525 */ 525 */
526 if (gnutls_protocol_get_version (session) == GNUTLS_SSL3 && 526 if (gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3 &&
527 session->internals.selected_cert_list_length == 0) 527 session->internals.selected_cert_list_length == 0)
528 { 528 {
529 ret = 529 ret =
@@ -631,7 +631,7 @@ _gnutls_recv_client_certificate (gnutls_session_t session)
631 */ 631 */
632 if (optional == OPTIONAL_PACKET && 632 if (optional == OPTIONAL_PACKET &&
633 ret == GNUTLS_E_WARNING_ALERT_RECEIVED && 633 ret == GNUTLS_E_WARNING_ALERT_RECEIVED &&
634 gnutls_protocol_get_version (session) == GNUTLS_SSL3 && 634 gnutls_protocol_get_version (session) == MHD_GNUTLS_SSL3 &&
635 gnutls_alert_get (session) == GNUTLS_A_SSL3_NO_CERTIFICATE) 635 gnutls_alert_get (session) == GNUTLS_A_SSL3_NO_CERTIFICATE)
636 { 636 {
637 637
diff --git a/src/daemon/https/tls/gnutls_priority.c b/src/daemon/https/tls/gnutls_priority.c
index d4f1eb6f..0dfb27e3 100644
--- a/src/daemon/https/tls/gnutls_priority.c
+++ b/src/daemon/https/tls/gnutls_priority.c
@@ -208,29 +208,30 @@ gnutls_certificate_type_set_priority (gnutls_session_t session,
208#endif 208#endif
209} 209}
210 210
211static const int protocol_priority[] = { GNUTLS_TLS1_1, 211static const int protocol_priority[] = { MHD_GNUTLS_TLS1_1,
212 GNUTLS_TLS1_0, 212 MHD_GNUTLS_TLS1_0,
213 GNUTLS_SSL3, 213 MHD_GNUTLS_SSL3,
214 0 214 0
215}; 215};
216 216
217static const int cipher_priority_secure256[] = { GNUTLS_CIPHER_AES_256_CBC, 217static const int cipher_priority_secure256[] =
218 { MHD_GNUTLS_CIPHER_AES_256_CBC,
218 0 219 0
219}; 220};
220 221
221static const int kx_priority_secure[] = { GNUTLS_KX_RSA, 222static const int kx_priority_secure[] = { MHD_GNUTLS_KX_RSA,
222 0 223 0
223}; 224};
224 225
225static const int mac_priority_secure[] = { GNUTLS_MAC_SHA1, 226static const int mac_priority_secure[] = { MHD_GNUTLS_MAC_SHA1,
226 0 227 0
227}; 228};
228 229
229static int cert_type_priority[] = { GNUTLS_CRT_X509, 230static int cert_type_priority[] = { MHD_GNUTLS_CRT_X509,
230 0 231 0
231}; 232};
232 233
233static const int comp_priority[] = { GNUTLS_COMP_NULL, 234static const int comp_priority[] = { MHD_GNUTLS_COMP_NULL,
234 0 235 0
235}; 236};
236 237
diff --git a/src/daemon/https/tls/gnutls_record.c b/src/daemon/https/tls/gnutls_record.c
index 2ec08942..e52cf922 100644
--- a/src/daemon/https/tls/gnutls_record.c
+++ b/src/daemon/https/tls/gnutls_record.c
@@ -787,7 +787,7 @@ get_temp_recv_buffer (gnutls_session_t session, gnutls_datum_t * tmp)
787{ 787{
788 size_t max_record_size; 788 size_t max_record_size;
789 789
790 if (gnutls_compression_get (session) != GNUTLS_COMP_NULL) 790 if (gnutls_compression_get (session) != MHD_GNUTLS_COMP_NULL)
791 max_record_size = MAX_RECORD_RECV_SIZE + EXTRA_COMP_SIZE; 791 max_record_size = MAX_RECORD_RECV_SIZE + EXTRA_COMP_SIZE;
792 else 792 else
793 max_record_size = MAX_RECORD_RECV_SIZE; 793 max_record_size = MAX_RECORD_RECV_SIZE;
diff --git a/src/daemon/https/tls/gnutls_rsa_export.c b/src/daemon/https/tls/gnutls_rsa_export.c
index 66fad085..7f4fafe1 100644
--- a/src/daemon/https/tls/gnutls_rsa_export.c
+++ b/src/daemon/https/tls/gnutls_rsa_export.c
@@ -264,7 +264,7 @@ gnutls_rsa_params_cpy (gnutls_rsa_params_t dst, gnutls_rsa_params_t src)
264int 264int
265gnutls_rsa_params_generate2 (gnutls_rsa_params_t params, unsigned int bits) 265gnutls_rsa_params_generate2 (gnutls_rsa_params_t params, unsigned int bits)
266{ 266{
267 return gnutls_x509_privkey_generate (params, GNUTLS_PK_RSA, bits, 0); 267 return gnutls_x509_privkey_generate (params, MHD_GNUTLS_PK_RSA, bits, 0);
268} 268}
269 269
270/** 270/**
diff --git a/src/daemon/https/tls/gnutls_session_pack.c b/src/daemon/https/tls/gnutls_session_pack.c
index c05e27cb..ed4945b6 100644
--- a/src/daemon/https/tls/gnutls_session_pack.c
+++ b/src/daemon/https/tls/gnutls_session_pack.c
@@ -79,7 +79,7 @@ _gnutls_session_pack (gnutls_session_t session,
79 switch (gnutls_auth_get_type (session)) 79 switch (gnutls_auth_get_type (session))
80 { 80 {
81#ifdef ENABLE_SRP 81#ifdef ENABLE_SRP
82 case GNUTLS_CRD_SRP: 82 case MHD_GNUTLS_CRD_SRP:
83 ret = pack_srp_auth_info (session, packed_session); 83 ret = pack_srp_auth_info (session, packed_session);
84 if (ret < 0) 84 if (ret < 0)
85 { 85 {
@@ -89,7 +89,7 @@ _gnutls_session_pack (gnutls_session_t session,
89 break; 89 break;
90#endif 90#endif
91#ifdef ENABLE_PSK 91#ifdef ENABLE_PSK
92 case GNUTLS_CRD_PSK: 92 case MHD_GNUTLS_CRD_PSK:
93 ret = pack_psk_auth_info (session, packed_session); 93 ret = pack_psk_auth_info (session, packed_session);
94 if (ret < 0) 94 if (ret < 0)
95 { 95 {
@@ -99,7 +99,7 @@ _gnutls_session_pack (gnutls_session_t session,
99 break; 99 break;
100#endif 100#endif
101#ifdef ENABLE_ANON 101#ifdef ENABLE_ANON
102 case GNUTLS_CRD_ANON: 102 case MHD_GNUTLS_CRD_ANON:
103 ret = pack_anon_auth_info (session, packed_session); 103 ret = pack_anon_auth_info (session, packed_session);
104 if (ret < 0) 104 if (ret < 0)
105 { 105 {
@@ -108,7 +108,7 @@ _gnutls_session_pack (gnutls_session_t session,
108 } 108 }
109 break; 109 break;
110#endif 110#endif
111 case GNUTLS_CRD_CERTIFICATE: 111 case MHD_GNUTLS_CRD_CERTIFICATE:
112 ret = pack_certificate_auth_info (session, packed_session); 112 ret = pack_certificate_auth_info (session, packed_session);
113 if (ret < 0) 113 if (ret < 0)
114 { 114 {
@@ -158,7 +158,7 @@ _gnutls_session_unpack (gnutls_session_t session,
158 switch (packed_session->data[0]) 158 switch (packed_session->data[0])
159 { 159 {
160#ifdef ENABLE_SRP 160#ifdef ENABLE_SRP
161 case GNUTLS_CRD_SRP: 161 case MHD_GNUTLS_CRD_SRP:
162 ret = unpack_srp_auth_info (session, packed_session); 162 ret = unpack_srp_auth_info (session, packed_session);
163 if (ret < 0) 163 if (ret < 0)
164 { 164 {
@@ -168,7 +168,7 @@ _gnutls_session_unpack (gnutls_session_t session,
168 break; 168 break;
169#endif 169#endif
170#ifdef ENABLE_PSK 170#ifdef ENABLE_PSK
171 case GNUTLS_CRD_PSK: 171 case MHD_GNUTLS_CRD_PSK:
172 ret = unpack_psk_auth_info (session, packed_session); 172 ret = unpack_psk_auth_info (session, packed_session);
173 if (ret < 0) 173 if (ret < 0)
174 { 174 {
@@ -178,7 +178,7 @@ _gnutls_session_unpack (gnutls_session_t session,
178 break; 178 break;
179#endif 179#endif
180#ifdef ENABLE_ANON 180#ifdef ENABLE_ANON
181 case GNUTLS_CRD_ANON: 181 case MHD_GNUTLS_CRD_ANON:
182 ret = unpack_anon_auth_info (session, packed_session); 182 ret = unpack_anon_auth_info (session, packed_session);
183 if (ret < 0) 183 if (ret < 0)
184 { 184 {
@@ -187,7 +187,7 @@ _gnutls_session_unpack (gnutls_session_t session,
187 } 187 }
188 break; 188 break;
189#endif 189#endif
190 case GNUTLS_CRD_CERTIFICATE: 190 case MHD_GNUTLS_CRD_CERTIFICATE:
191 ret = unpack_certificate_auth_info (session, packed_session); 191 ret = unpack_certificate_auth_info (session, packed_session);
192 if (ret < 0) 192 if (ret < 0)
193 { 193 {
@@ -273,7 +273,7 @@ pack_certificate_auth_info (gnutls_session_t session,
273 return GNUTLS_E_MEMORY_ERROR; 273 return GNUTLS_E_MEMORY_ERROR;
274 } 274 }
275 275
276 packed_session->data[0] = GNUTLS_CRD_CERTIFICATE; 276 packed_session->data[0] = MHD_GNUTLS_CRD_CERTIFICATE;
277 _gnutls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]); 277 _gnutls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
278 pos += 4 + PACK_HEADER_SIZE; 278 pos += 4 + PACK_HEADER_SIZE;
279 279
@@ -324,7 +324,7 @@ unpack_certificate_auth_info (gnutls_session_t session,
324 size_t pack_size; 324 size_t pack_size;
325 cert_auth_info_t info; 325 cert_auth_info_t info;
326 326
327 if (packed_session->data[0] != GNUTLS_CRD_CERTIFICATE) 327 if (packed_session->data[0] != MHD_GNUTLS_CRD_CERTIFICATE)
328 { 328 {
329 gnutls_assert (); 329 gnutls_assert ();
330 return GNUTLS_E_INVALID_REQUEST; 330 return GNUTLS_E_INVALID_REQUEST;
@@ -346,7 +346,7 @@ unpack_certificate_auth_info (gnutls_session_t session,
346 /* client and server have the same auth_info here 346 /* client and server have the same auth_info here
347 */ 347 */
348 ret = 348 ret =
349 _gnutls_auth_info_set (session, GNUTLS_CRD_CERTIFICATE, 349 _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
350 sizeof (cert_auth_info_st), 1); 350 sizeof (cert_auth_info_st), 1);
351 if (ret < 0) 351 if (ret < 0)
352 { 352 {
@@ -506,7 +506,7 @@ pack_srp_auth_info (gnutls_session_t session, gnutls_datum_t * packed_session)
506 return GNUTLS_E_MEMORY_ERROR; 506 return GNUTLS_E_MEMORY_ERROR;
507 } 507 }
508 508
509 packed_session->data[0] = GNUTLS_CRD_SRP; 509 packed_session->data[0] = MHD_GNUTLS_CRD_SRP;
510 _gnutls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]); 510 _gnutls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
511 511
512 if (pack_size > 0) 512 if (pack_size > 0)
@@ -525,7 +525,7 @@ unpack_srp_auth_info (gnutls_session_t session,
525 int ret; 525 int ret;
526 srp_server_auth_info_t info; 526 srp_server_auth_info_t info;
527 527
528 if (packed_session->data[0] != GNUTLS_CRD_SRP) 528 if (packed_session->data[0] != MHD_GNUTLS_CRD_SRP)
529 { 529 {
530 gnutls_assert (); 530 gnutls_assert ();
531 return GNUTLS_E_INVALID_REQUEST; 531 return GNUTLS_E_INVALID_REQUEST;
@@ -545,7 +545,7 @@ unpack_srp_auth_info (gnutls_session_t session,
545 } 545 }
546 546
547 ret = 547 ret =
548 _gnutls_auth_info_set (session, GNUTLS_CRD_SRP, 548 _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_SRP,
549 sizeof (srp_server_auth_info_st), 1); 549 sizeof (srp_server_auth_info_st), 1);
550 if (ret < 0) 550 if (ret < 0)
551 { 551 {
@@ -611,7 +611,7 @@ pack_anon_auth_info (gnutls_session_t session,
611 return GNUTLS_E_MEMORY_ERROR; 611 return GNUTLS_E_MEMORY_ERROR;
612 } 612 }
613 613
614 packed_session->data[0] = GNUTLS_CRD_ANON; 614 packed_session->data[0] = MHD_GNUTLS_CRD_ANON;
615 _gnutls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]); 615 _gnutls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
616 pos += 4 + PACK_HEADER_SIZE; 616 pos += 4 + PACK_HEADER_SIZE;
617 617
@@ -641,7 +641,7 @@ unpack_anon_auth_info (gnutls_session_t session,
641 int pos = 0, size, ret; 641 int pos = 0, size, ret;
642 anon_auth_info_t info; 642 anon_auth_info_t info;
643 643
644 if (packed_session->data[0] != GNUTLS_CRD_ANON) 644 if (packed_session->data[0] != MHD_GNUTLS_CRD_ANON)
645 { 645 {
646 gnutls_assert (); 646 gnutls_assert ();
647 return GNUTLS_E_INVALID_REQUEST; 647 return GNUTLS_E_INVALID_REQUEST;
@@ -664,7 +664,7 @@ unpack_anon_auth_info (gnutls_session_t session,
664 /* client and serer have the same auth_info here 664 /* client and serer have the same auth_info here
665 */ 665 */
666 ret = 666 ret =
667 _gnutls_auth_info_set (session, GNUTLS_CRD_ANON, 667 _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
668 sizeof (anon_auth_info_st), 1); 668 sizeof (anon_auth_info_st), 1);
669 if (ret < 0) 669 if (ret < 0)
670 { 670 {
@@ -775,7 +775,7 @@ pack_psk_auth_info (gnutls_session_t session, gnutls_datum_t * packed_session)
775 775
776 pos = 0; 776 pos = 0;
777 777
778 packed_session->data[pos] = GNUTLS_CRD_PSK; 778 packed_session->data[pos] = MHD_GNUTLS_CRD_PSK;
779 pos++; 779 pos++;
780 780
781 _gnutls_write_uint32 (pack_size, &packed_session->data[pos]); 781 _gnutls_write_uint32 (pack_size, &packed_session->data[pos]);
@@ -815,7 +815,7 @@ unpack_psk_auth_info (gnutls_session_t session,
815 int pos = 0, size, ret; 815 int pos = 0, size, ret;
816 psk_auth_info_t info; 816 psk_auth_info_t info;
817 817
818 if (packed_session->data[0] != GNUTLS_CRD_PSK) 818 if (packed_session->data[0] != MHD_GNUTLS_CRD_PSK)
819 { 819 {
820 gnutls_assert (); 820 gnutls_assert ();
821 return GNUTLS_E_INVALID_REQUEST; 821 return GNUTLS_E_INVALID_REQUEST;
@@ -838,7 +838,7 @@ unpack_psk_auth_info (gnutls_session_t session,
838 /* client and serer have the same auth_info here 838 /* client and serer have the same auth_info here
839 */ 839 */
840 ret = 840 ret =
841 _gnutls_auth_info_set (session, GNUTLS_CRD_PSK, 841 _gnutls_auth_info_set (session, MHD_GNUTLS_CRD_PSK,
842 sizeof (psk_auth_info_st), 1); 842 sizeof (psk_auth_info_st), 1);
843 if (ret < 0) 843 if (ret < 0)
844 { 844 {
diff --git a/src/daemon/https/tls/gnutls_sig.c b/src/daemon/https/tls/gnutls_sig.c
index 0456438f..da09e199 100644
--- a/src/daemon/https/tls/gnutls_sig.c
+++ b/src/daemon/https/tls/gnutls_sig.c
@@ -65,7 +65,7 @@ _gnutls_tls_sign_hdata (gnutls_session_t session,
65 return GNUTLS_E_HASH_FAILED; 65 return GNUTLS_E_HASH_FAILED;
66 } 66 }
67 67
68 if (ver == GNUTLS_SSL3) 68 if (ver == MHD_GNUTLS_SSL3)
69 { 69 {
70 ret = _gnutls_generate_master (session, 1); 70 ret = _gnutls_generate_master (session, 1);
71 if (ret < 0) 71 if (ret < 0)
@@ -83,7 +83,7 @@ _gnutls_tls_sign_hdata (gnutls_session_t session,
83 83
84 switch (cert->subject_pk_algorithm) 84 switch (cert->subject_pk_algorithm)
85 { 85 {
86 case GNUTLS_PK_RSA: 86 case MHD_GNUTLS_PK_RSA:
87 td_md5 = 87 td_md5 =
88 _gnutls_hash_copy (session->internals.handshake_mac_handle_md5); 88 _gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
89 if (td_md5 == NULL) 89 if (td_md5 == NULL)
@@ -92,7 +92,7 @@ _gnutls_tls_sign_hdata (gnutls_session_t session,
92 return GNUTLS_E_HASH_FAILED; 92 return GNUTLS_E_HASH_FAILED;
93 } 93 }
94 94
95 if (ver == GNUTLS_SSL3) 95 if (ver == MHD_GNUTLS_SSL3)
96 _gnutls_mac_deinit_ssl3_handshake (td_md5, concat, 96 _gnutls_mac_deinit_ssl3_handshake (td_md5, concat,
97 session->security_parameters. 97 session->security_parameters.
98 master_secret, TLS_MASTER_SIZE); 98 master_secret, TLS_MASTER_SIZE);
@@ -130,7 +130,7 @@ _gnutls_tls_sign_params (gnutls_session_t session,
130 opaque concat[36]; 130 opaque concat[36];
131 gnutls_protocol_t ver = gnutls_protocol_get_version (session); 131 gnutls_protocol_t ver = gnutls_protocol_get_version (session);
132 132
133 td_sha = _gnutls_hash_init (GNUTLS_MAC_SHA1); 133 td_sha = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
134 if (td_sha == NULL) 134 if (td_sha == NULL)
135 { 135 {
136 gnutls_assert (); 136 gnutls_assert ();
@@ -145,10 +145,10 @@ _gnutls_tls_sign_params (gnutls_session_t session,
145 145
146 switch (cert->subject_pk_algorithm) 146 switch (cert->subject_pk_algorithm)
147 { 147 {
148 case GNUTLS_PK_RSA: 148 case MHD_GNUTLS_PK_RSA:
149 if (ver < GNUTLS_TLS1_2) 149 if (ver < MHD_GNUTLS_TLS1_2)
150 { 150 {
151 mac_hd_t td_md5 = _gnutls_hash_init (GNUTLS_MAC_MD5); 151 mac_hd_t td_md5 = _gnutls_hash_init (MHD_GNUTLS_MAC_MD5);
152 if (td_md5 == NULL) 152 if (td_md5 == NULL)
153 { 153 {
154 gnutls_assert (); 154 gnutls_assert ();
@@ -213,7 +213,7 @@ _gnutls_sign (gnutls_pk_algorithm_t algo,
213 213
214 switch (algo) 214 switch (algo)
215 { 215 {
216 case GNUTLS_PK_RSA: 216 case MHD_GNUTLS_PK_RSA:
217 /* encrypt */ 217 /* encrypt */
218 if ((ret = 218 if ((ret =
219 _gnutls_pkcs1_rsa_encrypt (signature, data, params, params_size, 219 _gnutls_pkcs1_rsa_encrypt (signature, data, params, params_size,
@@ -301,7 +301,7 @@ _gnutls_verify_sig (gnutls_cert * cert,
301 301
302 switch (cert->subject_pk_algorithm) 302 switch (cert->subject_pk_algorithm)
303 { 303 {
304 case GNUTLS_PK_RSA: 304 case MHD_GNUTLS_PK_RSA:
305 305
306 vdata.data = hash_concat->data; 306 vdata.data = hash_concat->data;
307 vdata.size = hash_concat->size; 307 vdata.size = hash_concat->size;
@@ -352,7 +352,7 @@ _gnutls_verify_sig_hdata (gnutls_session_t session,
352 return GNUTLS_E_HASH_FAILED; 352 return GNUTLS_E_HASH_FAILED;
353 } 353 }
354 354
355 if (ver == GNUTLS_SSL3) 355 if (ver == MHD_GNUTLS_SSL3)
356 { 356 {
357 ret = _gnutls_generate_master (session, 1); 357 ret = _gnutls_generate_master (session, 1);
358 if (ret < 0) 358 if (ret < 0)
@@ -404,9 +404,9 @@ _gnutls_verify_sig_params (gnutls_session_t session,
404 opaque concat[36]; 404 opaque concat[36];
405 gnutls_protocol_t ver = gnutls_protocol_get_version (session); 405 gnutls_protocol_t ver = gnutls_protocol_get_version (session);
406 406
407 if (ver < GNUTLS_TLS1_2) 407 if (ver < MHD_GNUTLS_TLS1_2)
408 { 408 {
409 td_md5 = _gnutls_hash_init (GNUTLS_MAC_MD5); 409 td_md5 = _gnutls_hash_init (MHD_GNUTLS_MAC_MD5);
410 if (td_md5 == NULL) 410 if (td_md5 == NULL)
411 { 411 {
412 gnutls_assert (); 412 gnutls_assert ();
@@ -420,7 +420,7 @@ _gnutls_verify_sig_params (gnutls_session_t session,
420 _gnutls_hash (td_md5, params->data, params->size); 420 _gnutls_hash (td_md5, params->data, params->size);
421 } 421 }
422 422
423 td_sha = _gnutls_hash_init (GNUTLS_MAC_SHA1); 423 td_sha = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
424 if (td_sha == NULL) 424 if (td_sha == NULL)
425 { 425 {
426 gnutls_assert (); 426 gnutls_assert ();
@@ -435,7 +435,7 @@ _gnutls_verify_sig_params (gnutls_session_t session,
435 TLS_RANDOM_SIZE); 435 TLS_RANDOM_SIZE);
436 _gnutls_hash (td_sha, params->data, params->size); 436 _gnutls_hash (td_sha, params->data, params->size);
437 437
438 if (ver < GNUTLS_TLS1_2) 438 if (ver < MHD_GNUTLS_TLS1_2)
439 { 439 {
440 _gnutls_hash_deinit (td_md5, concat); 440 _gnutls_hash_deinit (td_md5, concat);
441 _gnutls_hash_deinit (td_sha, &concat[16]); 441 _gnutls_hash_deinit (td_sha, &concat[16]);
diff --git a/src/daemon/https/tls/gnutls_state.c b/src/daemon/https/tls/gnutls_state.c
index 6c361261..3fde3db4 100644
--- a/src/daemon/https/tls/gnutls_state.c
+++ b/src/daemon/https/tls/gnutls_state.c
@@ -130,7 +130,7 @@ _gnutls_session_cert_type_supported (gnutls_session_t session,
130 { 130 {
131 cred 131 cred
132 = (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key, 132 = (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key,
133 GNUTLS_CRD_CERTIFICATE, 133 MHD_GNUTLS_CRD_CERTIFICATE,
134 NULL); 134 NULL);
135 135
136 if (cred == NULL) 136 if (cred == NULL)
@@ -249,15 +249,15 @@ gnutls_init (gnutls_session_t * session, gnutls_connection_end_t con_end)
249 /* Set the defaults for initial handshake */ 249 /* Set the defaults for initial handshake */
250 (*session)->security_parameters.read_bulk_cipher_algorithm = 250 (*session)->security_parameters.read_bulk_cipher_algorithm =
251 (*session)->security_parameters.write_bulk_cipher_algorithm = 251 (*session)->security_parameters.write_bulk_cipher_algorithm =
252 GNUTLS_CIPHER_NULL; 252 MHD_GNUTLS_CIPHER_NULL;
253 253
254 (*session)->security_parameters.read_mac_algorithm = 254 (*session)->security_parameters.read_mac_algorithm =
255 (*session)->security_parameters.write_mac_algorithm = GNUTLS_MAC_NULL; 255 (*session)->security_parameters.write_mac_algorithm = MHD_GNUTLS_MAC_NULL;
256 256
257 (*session)->security_parameters.read_compression_algorithm 257 (*session)->security_parameters.read_compression_algorithm
258 = GNUTLS_COMP_NULL; 258 = MHD_GNUTLS_COMP_NULL;
259 (*session)->security_parameters.write_compression_algorithm 259 (*session)->security_parameters.write_compression_algorithm
260 = GNUTLS_COMP_NULL; 260 = MHD_GNUTLS_COMP_NULL;
261 261
262 (*session)->internals.enable_private = 0; 262 (*session)->internals.enable_private = 0;
263 263
@@ -435,7 +435,7 @@ _gnutls_dh_set_peer_public (gnutls_session_t session, mpi_t public)
435 435
436 switch (gnutls_auth_get_type (session)) 436 switch (gnutls_auth_get_type (session))
437 { 437 {
438 case GNUTLS_CRD_ANON: 438 case MHD_GNUTLS_CRD_ANON:
439 { 439 {
440 anon_auth_info_t info; 440 anon_auth_info_t info;
441 info = _gnutls_get_auth_info (session); 441 info = _gnutls_get_auth_info (session);
@@ -445,7 +445,7 @@ _gnutls_dh_set_peer_public (gnutls_session_t session, mpi_t public)
445 dh = &info->dh; 445 dh = &info->dh;
446 break; 446 break;
447 } 447 }
448 case GNUTLS_CRD_CERTIFICATE: 448 case MHD_GNUTLS_CRD_CERTIFICATE:
449 { 449 {
450 cert_auth_info_t info; 450 cert_auth_info_t info;
451 451
@@ -476,7 +476,7 @@ _gnutls_dh_set_secret_bits (gnutls_session_t session, unsigned bits)
476{ 476{
477 switch (gnutls_auth_get_type (session)) 477 switch (gnutls_auth_get_type (session))
478 { 478 {
479 case GNUTLS_CRD_ANON: 479 case MHD_GNUTLS_CRD_ANON:
480 { 480 {
481 anon_auth_info_t info; 481 anon_auth_info_t info;
482 info = _gnutls_get_auth_info (session); 482 info = _gnutls_get_auth_info (session);
@@ -485,7 +485,7 @@ _gnutls_dh_set_secret_bits (gnutls_session_t session, unsigned bits)
485 info->dh.secret_bits = bits; 485 info->dh.secret_bits = bits;
486 break; 486 break;
487 } 487 }
488 case GNUTLS_CRD_CERTIFICATE: 488 case MHD_GNUTLS_CRD_CERTIFICATE:
489 { 489 {
490 cert_auth_info_t info; 490 cert_auth_info_t info;
491 491
@@ -546,7 +546,7 @@ _gnutls_dh_set_group (gnutls_session_t session, mpi_t gen, mpi_t prime)
546 546
547 switch (gnutls_auth_get_type (session)) 547 switch (gnutls_auth_get_type (session))
548 { 548 {
549 case GNUTLS_CRD_ANON: 549 case MHD_GNUTLS_CRD_ANON:
550 { 550 {
551 anon_auth_info_t info; 551 anon_auth_info_t info;
552 info = _gnutls_get_auth_info (session); 552 info = _gnutls_get_auth_info (session);
@@ -556,7 +556,7 @@ _gnutls_dh_set_group (gnutls_session_t session, mpi_t gen, mpi_t prime)
556 dh = &info->dh; 556 dh = &info->dh;
557 break; 557 break;
558 } 558 }
559 case GNUTLS_CRD_CERTIFICATE: 559 case MHD_GNUTLS_CRD_CERTIFICATE:
560 { 560 {
561 cert_auth_info_t info; 561 cert_auth_info_t info;
562 562
@@ -832,10 +832,11 @@ _gnutls_PRF (gnutls_session_t session,
832 memcpy (s_seed, label, label_size); 832 memcpy (s_seed, label, label_size);
833 memcpy (&s_seed[label_size], seed, seed_size); 833 memcpy (&s_seed[label_size], seed, seed_size);
834 834
835 if (ver >= GNUTLS_TLS1_2) 835 if (ver >= MHD_GNUTLS_TLS1_2)
836 { 836 {
837 result = _gnutls_P_hash (GNUTLS_MAC_SHA1, secret, secret_size, s_seed, 837 result =
838 s_seed_size, total_bytes, ret); 838 _gnutls_P_hash (MHD_GNUTLS_MAC_SHA1, secret, secret_size, s_seed,
839 s_seed_size, total_bytes, ret);
839 if (result < 0) 840 if (result < 0)
840 { 841 {
841 gnutls_assert (); 842 gnutls_assert ();
@@ -854,16 +855,18 @@ _gnutls_PRF (gnutls_session_t session,
854 l_s++; 855 l_s++;
855 } 856 }
856 857
857 result = _gnutls_P_hash (GNUTLS_MAC_MD5, s1, l_s, s_seed, s_seed_size, 858 result =
858 total_bytes, o1); 859 _gnutls_P_hash (MHD_GNUTLS_MAC_MD5, s1, l_s, s_seed, s_seed_size,
860 total_bytes, o1);
859 if (result < 0) 861 if (result < 0)
860 { 862 {
861 gnutls_assert (); 863 gnutls_assert ();
862 return result; 864 return result;
863 } 865 }
864 866
865 result = _gnutls_P_hash (GNUTLS_MAC_SHA1, s2, l_s, s_seed, s_seed_size, 867 result =
866 total_bytes, o2); 868 _gnutls_P_hash (MHD_GNUTLS_MAC_SHA1, s2, l_s, s_seed, s_seed_size,
869 total_bytes, o2);
867 if (result < 0) 870 if (result < 0)
868 { 871 {
869 gnutls_assert (); 872 gnutls_assert ();
diff --git a/src/daemon/https/tls/gnutls_state.h b/src/daemon/https/tls/gnutls_state.h
index 7a920ee4..246432e6 100644
--- a/src/daemon/https/tls/gnutls_state.h
+++ b/src/daemon/https/tls/gnutls_state.h
@@ -69,4 +69,4 @@ int _gnutls_PRF (gnutls_session_t session,
69 69
70int gnutls_init (gnutls_session_t * session, gnutls_connection_end_t con_end); 70int gnutls_init (gnutls_session_t * session, gnutls_connection_end_t con_end);
71 71
72#define DEFAULT_CERT_TYPE GNUTLS_CRT_X509 72#define DEFAULT_CERT_TYPE MHD_GNUTLS_CRT_X509
diff --git a/src/daemon/https/tls/gnutls_ui.c b/src/daemon/https/tls/gnutls_ui.c
index 49ed2e96..e3511baa 100644
--- a/src/daemon/https/tls/gnutls_ui.c
+++ b/src/daemon/https/tls/gnutls_ui.c
@@ -83,13 +83,13 @@ gnutls_dh_get_group (gnutls_session_t session,
83 83
84 switch (gnutls_auth_get_type (session)) 84 switch (gnutls_auth_get_type (session))
85 { 85 {
86 case GNUTLS_CRD_ANON: 86 case MHD_GNUTLS_CRD_ANON:
87 anon_info = _gnutls_get_auth_info (session); 87 anon_info = _gnutls_get_auth_info (session);
88 if (anon_info == NULL) 88 if (anon_info == NULL)
89 return GNUTLS_E_INTERNAL_ERROR; 89 return GNUTLS_E_INTERNAL_ERROR;
90 dh = &anon_info->dh; 90 dh = &anon_info->dh;
91 break; 91 break;
92 case GNUTLS_CRD_CERTIFICATE: 92 case MHD_GNUTLS_CRD_CERTIFICATE:
93 cert_info = _gnutls_get_auth_info (session); 93 cert_info = _gnutls_get_auth_info (session);
94 if (cert_info == NULL) 94 if (cert_info == NULL)
95 return GNUTLS_E_INTERNAL_ERROR; 95 return GNUTLS_E_INTERNAL_ERROR;
@@ -140,7 +140,7 @@ gnutls_dh_get_pubkey (gnutls_session_t session, gnutls_datum_t * raw_key)
140 140
141 switch (gnutls_auth_get_type (session)) 141 switch (gnutls_auth_get_type (session))
142 { 142 {
143 case GNUTLS_CRD_ANON: 143 case MHD_GNUTLS_CRD_ANON:
144 { 144 {
145 anon_info = _gnutls_get_auth_info (session); 145 anon_info = _gnutls_get_auth_info (session);
146 if (anon_info == NULL) 146 if (anon_info == NULL)
@@ -148,7 +148,7 @@ gnutls_dh_get_pubkey (gnutls_session_t session, gnutls_datum_t * raw_key)
148 dh = &anon_info->dh; 148 dh = &anon_info->dh;
149 break; 149 break;
150 } 150 }
151 case GNUTLS_CRD_PSK: 151 case MHD_GNUTLS_CRD_PSK:
152 { 152 {
153 psk_info = _gnutls_get_auth_info (session); 153 psk_info = _gnutls_get_auth_info (session);
154 if (psk_info == NULL) 154 if (psk_info == NULL)
@@ -156,7 +156,7 @@ gnutls_dh_get_pubkey (gnutls_session_t session, gnutls_datum_t * raw_key)
156 dh = &psk_info->dh; 156 dh = &psk_info->dh;
157 break; 157 break;
158 } 158 }
159 case GNUTLS_CRD_CERTIFICATE: 159 case MHD_GNUTLS_CRD_CERTIFICATE:
160 { 160 {
161 161
162 cert_info = _gnutls_get_auth_info (session); 162 cert_info = _gnutls_get_auth_info (session);
@@ -195,7 +195,7 @@ gnutls_rsa_export_get_pubkey (gnutls_session_t session,
195 cert_auth_info_t info; 195 cert_auth_info_t info;
196 int ret; 196 int ret;
197 197
198 if (gnutls_auth_get_type (session) == GNUTLS_CRD_CERTIFICATE) 198 if (gnutls_auth_get_type (session) == MHD_GNUTLS_CRD_CERTIFICATE)
199 { 199 {
200 info = _gnutls_get_auth_info (session); 200 info = _gnutls_get_auth_info (session);
201 if (info == NULL) 201 if (info == NULL)
@@ -238,7 +238,7 @@ gnutls_dh_get_secret_bits (gnutls_session_t session)
238{ 238{
239 switch (gnutls_auth_get_type (session)) 239 switch (gnutls_auth_get_type (session))
240 { 240 {
241 case GNUTLS_CRD_ANON: 241 case MHD_GNUTLS_CRD_ANON:
242 { 242 {
243 anon_auth_info_t info; 243 anon_auth_info_t info;
244 244
@@ -247,7 +247,7 @@ gnutls_dh_get_secret_bits (gnutls_session_t session)
247 return GNUTLS_E_INTERNAL_ERROR; 247 return GNUTLS_E_INTERNAL_ERROR;
248 return info->dh.secret_bits; 248 return info->dh.secret_bits;
249 } 249 }
250 case GNUTLS_CRD_CERTIFICATE: 250 case MHD_GNUTLS_CRD_CERTIFICATE:
251 { 251 {
252 cert_auth_info_t info; 252 cert_auth_info_t info;
253 253
@@ -279,7 +279,7 @@ gnutls_dh_get_prime_bits (gnutls_session_t session)
279 279
280 switch (gnutls_auth_get_type (session)) 280 switch (gnutls_auth_get_type (session))
281 { 281 {
282 case GNUTLS_CRD_ANON: 282 case MHD_GNUTLS_CRD_ANON:
283 { 283 {
284 anon_auth_info_t info; 284 anon_auth_info_t info;
285 285
@@ -289,7 +289,7 @@ gnutls_dh_get_prime_bits (gnutls_session_t session)
289 dh = &info->dh; 289 dh = &info->dh;
290 break; 290 break;
291 } 291 }
292 case GNUTLS_CRD_CERTIFICATE: 292 case MHD_GNUTLS_CRD_CERTIFICATE:
293 { 293 {
294 cert_auth_info_t info; 294 cert_auth_info_t info;
295 295
@@ -346,7 +346,7 @@ gnutls_dh_get_peers_public_bits (gnutls_session_t session)
346 346
347 switch (gnutls_auth_get_type (session)) 347 switch (gnutls_auth_get_type (session))
348 { 348 {
349 case GNUTLS_CRD_ANON: 349 case MHD_GNUTLS_CRD_ANON:
350 { 350 {
351 anon_auth_info_t info; 351 anon_auth_info_t info;
352 352
@@ -357,7 +357,7 @@ gnutls_dh_get_peers_public_bits (gnutls_session_t session)
357 dh = &info->dh; 357 dh = &info->dh;
358 break; 358 break;
359 } 359 }
360 case GNUTLS_CRD_CERTIFICATE: 360 case MHD_GNUTLS_CRD_CERTIFICATE:
361 { 361 {
362 cert_auth_info_t info; 362 cert_auth_info_t info;
363 363
@@ -395,11 +395,11 @@ gnutls_certificate_get_ours (gnutls_session_t session)
395{ 395{
396 gnutls_certificate_credentials_t cred; 396 gnutls_certificate_credentials_t cred;
397 397
398 CHECK_AUTH (GNUTLS_CRD_CERTIFICATE, NULL); 398 CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, NULL);
399 399
400 cred 400 cred
401 = (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key, 401 = (gnutls_certificate_credentials_t) _gnutls_get_cred (session->key,
402 GNUTLS_CRD_CERTIFICATE, 402 MHD_GNUTLS_CRD_CERTIFICATE,
403 NULL); 403 NULL);
404 if (cred == NULL || cred->cert_list == NULL) 404 if (cred == NULL || cred->cert_list == NULL)
405 { 405 {
@@ -436,7 +436,7 @@ gnutls_certificate_get_peers (gnutls_session_t
436{ 436{
437 cert_auth_info_t info; 437 cert_auth_info_t info;
438 438
439 CHECK_AUTH (GNUTLS_CRD_CERTIFICATE, NULL); 439 CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, NULL);
440 440
441 info = _gnutls_get_auth_info (session); 441 info = _gnutls_get_auth_info (session);
442 if (info == NULL) 442 if (info == NULL)
@@ -460,7 +460,7 @@ gnutls_certificate_client_get_request_status (gnutls_session_t session)
460{ 460{
461 cert_auth_info_t info; 461 cert_auth_info_t info;
462 462
463 CHECK_AUTH (GNUTLS_CRD_CERTIFICATE, 0); 463 CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, 0);
464 464
465 info = _gnutls_get_auth_info (session); 465 info = _gnutls_get_auth_info (session);
466 if (info == NULL) 466 if (info == NULL)
diff --git a/src/daemon/https/tls/gnutls_x509.c b/src/daemon/https/tls/gnutls_x509.c
index 29d20957..7c84fa0a 100644
--- a/src/daemon/https/tls/gnutls_x509.c
+++ b/src/daemon/https/tls/gnutls_x509.c
@@ -108,7 +108,7 @@ _gnutls_x509_cert_verify_peers (gnutls_session_t session,
108 gnutls_x509_crt_t *peer_certificate_list; 108 gnutls_x509_crt_t *peer_certificate_list;
109 int peer_certificate_list_size, i, x, ret; 109 int peer_certificate_list_size, i, x, ret;
110 110
111 CHECK_AUTH (GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST); 111 CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
112 112
113 info = _gnutls_get_auth_info (session); 113 info = _gnutls_get_auth_info (session);
114 if (info == NULL) 114 if (info == NULL)
@@ -118,7 +118,7 @@ _gnutls_x509_cert_verify_peers (gnutls_session_t session,
118 } 118 }
119 119
120 cred = (gnutls_certificate_credentials_t) 120 cred = (gnutls_certificate_credentials_t)
121 _gnutls_get_cred (session->key, GNUTLS_CRD_CERTIFICATE, NULL); 121 _gnutls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
122 if (cred == NULL) 122 if (cred == NULL)
123 { 123 {
124 gnutls_assert (); 124 gnutls_assert ();
@@ -1054,8 +1054,8 @@ _gnutls_check_key_usage (const gnutls_cert * cert, gnutls_kx_algorithm_t alg)
1054 return GNUTLS_E_INTERNAL_ERROR; 1054 return GNUTLS_E_INTERNAL_ERROR;
1055 } 1055 }
1056 1056
1057 if (_gnutls_map_kx_get_cred (alg, 1) == GNUTLS_CRD_CERTIFICATE || 1057 if (_gnutls_map_kx_get_cred (alg, 1) == MHD_GNUTLS_CRD_CERTIFICATE ||
1058 _gnutls_map_kx_get_cred (alg, 0) == GNUTLS_CRD_CERTIFICATE) 1058 _gnutls_map_kx_get_cred (alg, 0) == MHD_GNUTLS_CRD_CERTIFICATE)
1059 { 1059 {
1060 1060
1061 key_usage = cert->key_usage; 1061 key_usage = cert->key_usage;
diff --git a/src/daemon/https/x509/common.c b/src/daemon/https/x509/common.c
index 98a655c7..82d433ce 100644
--- a/src/daemon/https/x509/common.c
+++ b/src/daemon/https/x509/common.c
@@ -1244,7 +1244,7 @@ _gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
1244 return _gnutls_asn2err (result); 1244 return _gnutls_asn2err (result);
1245 } 1245 }
1246 1246
1247 if (pk_algorithm == GNUTLS_PK_RSA) 1247 if (pk_algorithm == MHD_GNUTLS_PK_RSA)
1248 { 1248 {
1249 /* disable parameters, which are not used in RSA. 1249 /* disable parameters, which are not used in RSA.
1250 */ 1250 */
@@ -1363,7 +1363,7 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
1363 1363
1364 switch (algo) 1364 switch (algo)
1365 { 1365 {
1366 case GNUTLS_PK_RSA: 1366 case MHD_GNUTLS_PK_RSA:
1367 { 1367 {
1368 if ((result = _gnutls_x509_read_rsa_params (str, len, params)) < 0) 1368 if ((result = _gnutls_x509_read_rsa_params (str, len, params)) < 0)
1369 { 1369 {
diff --git a/src/daemon/https/x509/crl_write.c b/src/daemon/https/x509/crl_write.c
index 370a492c..465f1782 100644
--- a/src/daemon/https/x509/crl_write.c
+++ b/src/daemon/https/x509/crl_write.c
@@ -143,7 +143,8 @@ int
143gnutls_x509_crl_sign (gnutls_x509_crl_t crl, gnutls_x509_crt_t issuer, 143gnutls_x509_crl_sign (gnutls_x509_crl_t crl, gnutls_x509_crt_t issuer,
144 gnutls_x509_privkey_t issuer_key) 144 gnutls_x509_privkey_t issuer_key)
145{ 145{
146 return gnutls_x509_crl_sign2 (crl, issuer, issuer_key, GNUTLS_DIG_SHA1, 0); 146 return gnutls_x509_crl_sign2 (crl, issuer, issuer_key, MHD_GNUTLS_DIG_SHA1,
147 0);
147} 148}
148 149
149/** 150/**
diff --git a/src/daemon/https/x509/crq.c b/src/daemon/https/x509/crq.c
index 8e663d51..8a60d35f 100644
--- a/src/daemon/https/x509/crq.c
+++ b/src/daemon/https/x509/crq.c
@@ -805,7 +805,7 @@ gnutls_x509_crq_sign2 (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key,
805int 805int
806gnutls_x509_crq_sign (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key) 806gnutls_x509_crq_sign (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key)
807{ 807{
808 return gnutls_x509_crq_sign2 (crq, key, GNUTLS_DIG_SHA1, 0); 808 return gnutls_x509_crq_sign2 (crq, key, MHD_GNUTLS_DIG_SHA1, 0);
809} 809}
810 810
811/** 811/**
diff --git a/src/daemon/https/x509/mpi.c b/src/daemon/https/x509/mpi.c
index 7fbd0b75..0d39adb5 100644
--- a/src/daemon/https/x509/mpi.c
+++ b/src/daemon/https/x509/mpi.c
@@ -231,7 +231,7 @@ _gnutls_x509_crt_get_mpis (gnutls_x509_crt_t cert,
231 231
232 switch (pk_algorithm) 232 switch (pk_algorithm)
233 { 233 {
234 case GNUTLS_PK_RSA: 234 case MHD_GNUTLS_PK_RSA:
235 /* params[0] is the modulus, 235 /* params[0] is the modulus,
236 * params[1] is the exponent 236 * params[1] is the exponent
237 */ 237 */
@@ -365,7 +365,7 @@ _gnutls_x509_write_sig_params (ASN1_TYPE dst,
365 _gnutls_str_cpy (name, sizeof (name), dst_name); 365 _gnutls_str_cpy (name, sizeof (name), dst_name);
366 _gnutls_str_cat (name, sizeof (name), ".parameters"); 366 _gnutls_str_cat (name, sizeof (name), ".parameters");
367 367
368 if (pk_algorithm == GNUTLS_PK_RSA) 368 if (pk_algorithm == MHD_GNUTLS_PK_RSA)
369 { /* RSA */ 369 { /* RSA */
370 result = asn1_write_value (dst, name, NULL, 0); 370 result = asn1_write_value (dst, name, NULL, 0);
371 371
diff --git a/src/daemon/https/x509/output.c b/src/daemon/https/x509/output.c
index dcc87ab1..8892cf4e 100644
--- a/src/daemon/https/x509/output.c
+++ b/src/daemon/https/x509/output.c
@@ -612,7 +612,7 @@ print_cert (gnutls_string * str, gnutls_x509_crt_t cert, int notsigned)
612 addf (str, _("\tSubject Public Key Algorithm: %s\n"), name); 612 addf (str, _("\tSubject Public Key Algorithm: %s\n"), name);
613 switch (err) 613 switch (err)
614 { 614 {
615 case GNUTLS_PK_RSA: 615 case MHD_GNUTLS_PK_RSA:
616 { 616 {
617 gnutls_datum_t m, e; 617 gnutls_datum_t m, e;
618 618
@@ -932,7 +932,7 @@ print_fingerprint (gnutls_string * str, gnutls_x509_crt_t cert,
932 return; 932 return;
933 } 933 }
934 934
935 if (algo == GNUTLS_DIG_MD5) 935 if (algo == MHD_GNUTLS_DIG_MD5)
936 addf (str, _("\tMD5 fingerprint:\n\t\t")); 936 addf (str, _("\tMD5 fingerprint:\n\t\t"));
937 else 937 else
938 addf (str, _("\tSHA-1 fingerprint:\n\t\t")); 938 addf (str, _("\tSHA-1 fingerprint:\n\t\t"));
@@ -981,8 +981,8 @@ print_other (gnutls_string * str, gnutls_x509_crt_t cert, int notsigned)
981{ 981{
982 if (!notsigned) 982 if (!notsigned)
983 { 983 {
984 print_fingerprint (str, cert, GNUTLS_DIG_MD5); 984 print_fingerprint (str, cert, MHD_GNUTLS_DIG_MD5);
985 print_fingerprint (str, cert, GNUTLS_DIG_SHA1); 985 print_fingerprint (str, cert, MHD_GNUTLS_DIG_SHA1);
986 } 986 }
987 print_keyid (str, cert); 987 print_keyid (str, cert);
988} 988}
@@ -1088,7 +1088,7 @@ print_oneline (gnutls_string * str, gnutls_x509_crt_t cert)
1088 size_t size = sizeof (buffer); 1088 size_t size = sizeof (buffer);
1089 int err; 1089 int err;
1090 1090
1091 err = gnutls_x509_crt_get_fingerprint (cert, GNUTLS_DIG_SHA1, 1091 err = gnutls_x509_crt_get_fingerprint (cert, MHD_GNUTLS_DIG_SHA1,
1092 buffer, &size); 1092 buffer, &size);
1093 if (err < 0) 1093 if (err < 0)
1094 { 1094 {
diff --git a/src/daemon/https/x509/pkcs12.c b/src/daemon/https/x509/pkcs12.c
index 40f7a243..abd647b0 100644
--- a/src/daemon/https/x509/pkcs12.c
+++ b/src/daemon/https/x509/pkcs12.c
@@ -924,7 +924,7 @@ gnutls_pkcs12_generate_mac (gnutls_pkcs12_t pkcs12, const char *pass)
924 924
925 /* MAC the data 925 /* MAC the data
926 */ 926 */
927 td1 = _gnutls_hmac_init (GNUTLS_MAC_SHA1, key, sizeof (key)); 927 td1 = _gnutls_hmac_init (MHD_GNUTLS_MAC_SHA1, key, sizeof (key));
928 if (td1 == GNUTLS_MAC_FAILED) 928 if (td1 == GNUTLS_MAC_FAILED)
929 { 929 {
930 gnutls_assert (); 930 gnutls_assert ();
@@ -1050,7 +1050,7 @@ gnutls_pkcs12_verify_mac (gnutls_pkcs12_t pkcs12, const char *pass)
1050 1050
1051 /* MAC the data 1051 /* MAC the data
1052 */ 1052 */
1053 td1 = _gnutls_hmac_init (GNUTLS_MAC_SHA1, key, sizeof (key)); 1053 td1 = _gnutls_hmac_init (MHD_GNUTLS_MAC_SHA1, key, sizeof (key));
1054 if (td1 == GNUTLS_MAC_FAILED) 1054 if (td1 == GNUTLS_MAC_FAILED)
1055 { 1055 {
1056 gnutls_assert (); 1056 gnutls_assert ();
diff --git a/src/daemon/https/x509/privkey_pkcs8.c b/src/daemon/https/x509/privkey_pkcs8.c
index 0812fa3c..c0ce6a5c 100644
--- a/src/daemon/https/x509/privkey_pkcs8.c
+++ b/src/daemon/https/x509/privkey_pkcs8.c
@@ -139,7 +139,7 @@ _encode_privkey (gnutls_x509_privkey pkey, gnutls_datum * raw)
139 139
140 switch (pkey->pk_algorithm) 140 switch (pkey->pk_algorithm)
141 { 141 {
142 case GNUTLS_PK_RSA: 142 case MHD_GNUTLS_PK_RSA:
143 ret = 143 ret =
144 gnutls_x509_privkey_export (pkey, GNUTLS_X509_FMT_DER, NULL, &size); 144 gnutls_x509_privkey_export (pkey, GNUTLS_X509_FMT_DER, NULL, &size);
145 if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER) 145 if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
@@ -196,7 +196,7 @@ encode_to_private_key_info (gnutls_x509_privkey_t pkey,
196 gnutls_datum algo_params = { NULL, 0 }; 196 gnutls_datum algo_params = { NULL, 0 };
197 gnutls_datum algo_privkey = { NULL, 0 }; 197 gnutls_datum algo_privkey = { NULL, 0 };
198 198
199 if (pkey->pk_algorithm == GNUTLS_PK_RSA) 199 if (pkey->pk_algorithm == MHD_GNUTLS_PK_RSA)
200 { 200 {
201 oid = PK_PKIX1_RSA_OID; 201 oid = PK_PKIX1_RSA_OID;
202 /* parameters are null 202 /* parameters are null
@@ -612,17 +612,17 @@ read_pkcs_schema_params (schema_id schema, const char *password,
612 612
613 if ((schema) == PKCS12_3DES_SHA1) 613 if ((schema) == PKCS12_3DES_SHA1)
614 { 614 {
615 enc_params->cipher = GNUTLS_CIPHER_3DES_CBC; 615 enc_params->cipher = MHD_GNUTLS_CIPHER_3DES_CBC;
616 enc_params->iv_size = 8; 616 enc_params->iv_size = 8;
617 } 617 }
618 else if ((schema) == PKCS12_ARCFOUR_SHA1) 618 else if ((schema) == PKCS12_ARCFOUR_SHA1)
619 { 619 {
620 enc_params->cipher = GNUTLS_CIPHER_ARCFOUR_128; 620 enc_params->cipher = MHD_GNUTLS_CIPHER_ARCFOUR_128;
621 enc_params->iv_size = 0; 621 enc_params->iv_size = 0;
622 } 622 }
623 else if ((schema) == PKCS12_RC2_40_SHA1) 623 else if ((schema) == PKCS12_RC2_40_SHA1)
624 { 624 {
625 enc_params->cipher = GNUTLS_CIPHER_RC2_40_CBC; 625 enc_params->cipher = MHD_GNUTLS_CIPHER_RC2_40_CBC;
626 enc_params->iv_size = 8; 626 enc_params->iv_size = 8;
627 } 627 }
628 628
@@ -950,7 +950,7 @@ decode_private_key_info (const gnutls_datum_t * der,
950 /* we only support RSA and DSA private keys. 950 /* we only support RSA and DSA private keys.
951 */ 951 */
952 if (strcmp (oid, PK_PKIX1_RSA_OID) == 0) 952 if (strcmp (oid, PK_PKIX1_RSA_OID) == 0)
953 pkey->pk_algorithm = GNUTLS_PK_RSA; 953 pkey->pk_algorithm = MHD_GNUTLS_PK_RSA;
954 else 954 else
955 { 955 {
956 gnutls_assert (); 956 gnutls_assert ();
@@ -963,7 +963,7 @@ decode_private_key_info (const gnutls_datum_t * der,
963 /* Get the DER encoding of the actual private key. 963 /* Get the DER encoding of the actual private key.
964 */ 964 */
965 965
966 if (pkey->pk_algorithm == GNUTLS_PK_RSA) 966 if (pkey->pk_algorithm == MHD_GNUTLS_PK_RSA)
967 result = _decode_pkcs8_rsa_key (pkcs8_asn, pkey); 967 result = _decode_pkcs8_rsa_key (pkcs8_asn, pkey);
968 if (result < 0) 968 if (result < 0)
969 { 969 {
@@ -1021,7 +1021,7 @@ gnutls_x509_privkey_import_pkcs8 (gnutls_x509_privkey_t key,
1021 _data.data = data->data; 1021 _data.data = data->data;
1022 _data.size = data->size; 1022 _data.size = data->size;
1023 1023
1024 key->pk_algorithm = GNUTLS_PK_UNKNOWN; 1024 key->pk_algorithm = MHD_GNUTLS_PK_UNKNOWN;
1025 1025
1026 /* If the Certificate is in PEM format then decode it 1026 /* If the Certificate is in PEM format then decode it
1027 */ 1027 */
@@ -1082,7 +1082,7 @@ gnutls_x509_privkey_import_pkcs8 (gnutls_x509_privkey_t key,
1082 return 0; 1082 return 0;
1083 1083
1084cleanup: 1084cleanup:
1085 key->pk_algorithm = GNUTLS_PK_UNKNOWN; 1085 key->pk_algorithm = MHD_GNUTLS_PK_UNKNOWN;
1086 if (need_free) 1086 if (need_free)
1087 _gnutls_free_datum (&_data); 1087 _gnutls_free_datum (&_data);
1088 return result; 1088 return result;
@@ -1291,13 +1291,13 @@ oid2cipher (const char *oid, gnutls_cipher_algorithm_t * algo)
1291 1291
1292 if (strcmp (oid, DES_EDE3_CBC_OID) == 0) 1292 if (strcmp (oid, DES_EDE3_CBC_OID) == 0)
1293 { 1293 {
1294 *algo = GNUTLS_CIPHER_3DES_CBC; 1294 *algo = MHD_GNUTLS_CIPHER_3DES_CBC;
1295 return 0; 1295 return 0;
1296 } 1296 }
1297 1297
1298 if (strcmp (oid, DES_CBC_OID) == 0) 1298 if (strcmp (oid, DES_CBC_OID) == 0)
1299 { 1299 {
1300 *algo = GNUTLS_CIPHER_DES_CBC; 1300 *algo = MHD_GNUTLS_CIPHER_DES_CBC;
1301 return 0; 1301 return 0;
1302 } 1302 }
1303 1303
@@ -1697,11 +1697,11 @@ generate_key (schema_id schema,
1697 */ 1697 */
1698 1698
1699 if (schema == PKCS12_ARCFOUR_SHA1) 1699 if (schema == PKCS12_ARCFOUR_SHA1)
1700 enc_params->cipher = GNUTLS_CIPHER_ARCFOUR_128; 1700 enc_params->cipher = MHD_GNUTLS_CIPHER_ARCFOUR_128;
1701 else if (schema == PKCS12_3DES_SHA1) 1701 else if (schema == PKCS12_3DES_SHA1)
1702 enc_params->cipher = GNUTLS_CIPHER_3DES_CBC; 1702 enc_params->cipher = MHD_GNUTLS_CIPHER_3DES_CBC;
1703 else if (schema == PKCS12_RC2_40_SHA1) 1703 else if (schema == PKCS12_RC2_40_SHA1)
1704 enc_params->cipher = GNUTLS_CIPHER_RC2_40_CBC; 1704 enc_params->cipher = MHD_GNUTLS_CIPHER_RC2_40_CBC;
1705 1705
1706 if (gc_pseudo_random (rnd, 2) != GC_OK) 1706 if (gc_pseudo_random (rnd, 2) != GC_OK)
1707 { 1707 {
diff --git a/src/daemon/https/x509/sign.c b/src/daemon/https/x509/sign.c
index 275fc3f7..7b21825e 100644
--- a/src/daemon/https/x509/sign.c
+++ b/src/daemon/https/x509/sign.c
@@ -162,7 +162,7 @@ pkcs1_rsa_sign (gnutls_digest_algorithm_t hash, const gnutls_datum_t * text,
162 } 162 }
163 163
164 if ((ret = 164 if ((ret =
165 _gnutls_sign (GNUTLS_PK_RSA, params, params_len, &info, 165 _gnutls_sign (MHD_GNUTLS_PK_RSA, params, params_len, &info,
166 signature)) < 0) 166 signature)) < 0)
167 { 167 {
168 gnutls_assert (); 168 gnutls_assert ();
@@ -193,7 +193,7 @@ _gnutls_x509_sign (const gnutls_datum_t * tbs,
193 193
194 switch (signer->pk_algorithm) 194 switch (signer->pk_algorithm)
195 { 195 {
196 case GNUTLS_PK_RSA: 196 case MHD_GNUTLS_PK_RSA:
197 ret = 197 ret =
198 pkcs1_rsa_sign (hash, tbs, signer->params, signer->params_size, 198 pkcs1_rsa_sign (hash, tbs, signer->params, signer->params_size,
199 signature); 199 signature);
diff --git a/src/daemon/https/x509/x509.c b/src/daemon/https/x509/x509.c
index 96999d27..90696168 100644
--- a/src/daemon/https/x509/x509.c
+++ b/src/daemon/https/x509/x509.c
@@ -2041,7 +2041,7 @@ rsadsa_get_key_id (gnutls_x509_crt_t crt,
2041 return result; 2041 return result;
2042 } 2042 }
2043 2043
2044 if (pk == GNUTLS_PK_RSA) 2044 if (pk == MHD_GNUTLS_PK_RSA)
2045 { 2045 {
2046 result = _gnutls_x509_write_rsa_params (params, params_size, &der); 2046 result = _gnutls_x509_write_rsa_params (params, params_size, &der);
2047 if (result < 0) 2047 if (result < 0)
@@ -2053,7 +2053,7 @@ rsadsa_get_key_id (gnutls_x509_crt_t crt,
2053 else 2053 else
2054 return GNUTLS_E_INTERNAL_ERROR; 2054 return GNUTLS_E_INTERNAL_ERROR;
2055 2055
2056 hd = _gnutls_hash_init (GNUTLS_MAC_SHA1); 2056 hd = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
2057 if (hd == GNUTLS_HASH_FAILED) 2057 if (hd == GNUTLS_HASH_FAILED)
2058 { 2058 {
2059 gnutls_assert (); 2059 gnutls_assert ();
@@ -2130,7 +2130,7 @@ gnutls_x509_crt_get_key_id (gnutls_x509_crt_t crt,
2130 return pk; 2130 return pk;
2131 } 2131 }
2132 2132
2133 if (pk == GNUTLS_PK_RSA) 2133 if (pk == MHD_GNUTLS_PK_RSA)
2134 { 2134 {
2135 /* This is for compatibility with what GnuTLS has printed for 2135 /* This is for compatibility with what GnuTLS has printed for
2136 RSA/DSA before the code below was added. The code below is 2136 RSA/DSA before the code below was added. The code below is
@@ -2165,7 +2165,7 @@ gnutls_x509_crt_get_key_id (gnutls_x509_crt_t crt,
2165 return _gnutls_asn2err (result); 2165 return _gnutls_asn2err (result);
2166 } 2166 }
2167 2167
2168 result = gnutls_fingerprint (GNUTLS_DIG_SHA1, &pubkey, output_data, 2168 result = gnutls_fingerprint (MHD_GNUTLS_DIG_SHA1, &pubkey, output_data,
2169 output_data_size); 2169 output_data_size);
2170 2170
2171 gnutls_afree (pubkey.data); 2171 gnutls_afree (pubkey.data);
@@ -2581,7 +2581,7 @@ gnutls_x509_crt_get_pk_rsa_raw (gnutls_x509_crt_t crt,
2581 } 2581 }
2582 2582
2583 ret = gnutls_x509_crt_get_pk_algorithm (crt, NULL); 2583 ret = gnutls_x509_crt_get_pk_algorithm (crt, NULL);
2584 if (ret != GNUTLS_PK_RSA) 2584 if (ret != MHD_GNUTLS_PK_RSA)
2585 { 2585 {
2586 gnutls_assert (); 2586 gnutls_assert ();
2587 return GNUTLS_E_INVALID_REQUEST; 2587 return GNUTLS_E_INVALID_REQUEST;
diff --git a/src/daemon/https/x509/x509_privkey.c b/src/daemon/https/x509/x509_privkey.c
index ff295fcd..596aedc0 100644
--- a/src/daemon/https/x509/x509_privkey.c
+++ b/src/daemon/https/x509/x509_privkey.c
@@ -64,7 +64,7 @@ gnutls_x509_privkey_init (gnutls_x509_privkey_t * key)
64 if (*key) 64 if (*key)
65 { 65 {
66 (*key)->key = ASN1_TYPE_EMPTY; 66 (*key)->key = ASN1_TYPE_EMPTY;
67 (*key)->pk_algorithm = GNUTLS_PK_UNKNOWN; 67 (*key)->pk_algorithm = MHD_GNUTLS_PK_UNKNOWN;
68 return 0; /* success */ 68 return 0; /* success */
69 } 69 }
70 70
@@ -126,7 +126,7 @@ gnutls_x509_privkey_cpy (gnutls_x509_privkey_t dst, gnutls_x509_privkey_t src)
126 { 126 {
127 switch (dst->pk_algorithm) 127 switch (dst->pk_algorithm)
128 { 128 {
129 case GNUTLS_PK_RSA: 129 case MHD_GNUTLS_PK_RSA:
130 ret = _gnutls_asn1_encode_rsa (&dst->key, dst->params); 130 ret = _gnutls_asn1_encode_rsa (&dst->key, dst->params);
131 if (ret < 0) 131 if (ret < 0)
132 { 132 {
@@ -355,7 +355,7 @@ gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
355 _data.data = data->data; 355 _data.data = data->data;
356 _data.size = data->size; 356 _data.size = data->size;
357 357
358 key->pk_algorithm = GNUTLS_PK_UNKNOWN; 358 key->pk_algorithm = MHD_GNUTLS_PK_UNKNOWN;
359 359
360 /* If the Certificate is in PEM format then decode it */ 360 /* If the Certificate is in PEM format then decode it */
361 if (format == GNUTLS_X509_FMT_PEM) 361 if (format == GNUTLS_X509_FMT_PEM)
@@ -365,7 +365,7 @@ gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
365 /* Try the first header */ 365 /* Try the first header */
366 result 366 result
367 = _gnutls_fbase64_decode (PEM_KEY_RSA, data->data, data->size, &out); 367 = _gnutls_fbase64_decode (PEM_KEY_RSA, data->data, data->size, &out);
368 key->pk_algorithm = GNUTLS_PK_RSA; 368 key->pk_algorithm = MHD_GNUTLS_PK_RSA;
369 369
370 // TODO rm 370 // TODO rm
371// if (result == GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR) 371// if (result == GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR)
@@ -390,7 +390,7 @@ gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
390 need_free = 1; 390 need_free = 1;
391 } 391 }
392 392
393 if (key->pk_algorithm == GNUTLS_PK_RSA) 393 if (key->pk_algorithm == MHD_GNUTLS_PK_RSA)
394 { 394 {
395 key->key = _gnutls_privkey_decode_pkcs1_rsa_key (&_data, key); 395 key->key = _gnutls_privkey_decode_pkcs1_rsa_key (&_data, key);
396 if (key->key == NULL) 396 if (key->key == NULL)
@@ -399,7 +399,7 @@ gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
399 else 399 else
400 { 400 {
401 /* Try decoding with both, and accept the one that succeeds. */ 401 /* Try decoding with both, and accept the one that succeeds. */
402 key->pk_algorithm = GNUTLS_PK_RSA; 402 key->pk_algorithm = MHD_GNUTLS_PK_RSA;
403 key->key = _gnutls_privkey_decode_pkcs1_rsa_key (&_data, key); 403 key->key = _gnutls_privkey_decode_pkcs1_rsa_key (&_data, key);
404 404
405 // TODO rm 405 // TODO rm
@@ -416,7 +416,7 @@ gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
416 { 416 {
417 gnutls_assert (); 417 gnutls_assert ();
418 result = GNUTLS_E_ASN1_DER_ERROR; 418 result = GNUTLS_E_ASN1_DER_ERROR;
419 key->pk_algorithm = GNUTLS_PK_UNKNOWN; 419 key->pk_algorithm = MHD_GNUTLS_PK_UNKNOWN;
420 return result; 420 return result;
421 } 421 }
422 422
@@ -539,7 +539,7 @@ gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
539 } 539 }
540 540
541 key->params_size = RSA_PRIVATE_PARAMS; 541 key->params_size = RSA_PRIVATE_PARAMS;
542 key->pk_algorithm = GNUTLS_PK_RSA; 542 key->pk_algorithm = MHD_GNUTLS_PK_RSA;
543 543
544 return 0; 544 return 0;
545 545
@@ -605,7 +605,7 @@ gnutls_x509_privkey_export (gnutls_x509_privkey_t key,
605 return GNUTLS_E_INVALID_REQUEST; 605 return GNUTLS_E_INVALID_REQUEST;
606 } 606 }
607 607
608 if (key->pk_algorithm == GNUTLS_PK_RSA) 608 if (key->pk_algorithm == MHD_GNUTLS_PK_RSA)
609 msg = PEM_KEY_RSA; 609 msg = PEM_KEY_RSA;
610 else 610 else
611 msg = NULL; 611 msg = NULL;
@@ -615,7 +615,7 @@ gnutls_x509_privkey_export (gnutls_x509_privkey_t key,
615 */ 615 */
616 switch (key->pk_algorithm) 616 switch (key->pk_algorithm)
617 { 617 {
618 case GNUTLS_PK_RSA: 618 case MHD_GNUTLS_PK_RSA:
619 ret = _gnutls_asn1_encode_rsa (&key->key, key->params); 619 ret = _gnutls_asn1_encode_rsa (&key->key, key->params);
620 if (ret < 0) 620 if (ret < 0)
621 { 621 {
@@ -1204,7 +1204,7 @@ gnutls_x509_privkey_generate (gnutls_x509_privkey_t key,
1204 1204
1205 switch (algo) 1205 switch (algo)
1206 { 1206 {
1207 case GNUTLS_PK_RSA: 1207 case MHD_GNUTLS_PK_RSA:
1208 ret = _gnutls_rsa_generate_params (key->params, &params_len, bits); 1208 ret = _gnutls_rsa_generate_params (key->params, &params_len, bits);
1209 if (ret < 0) 1209 if (ret < 0)
1210 { 1210 {
@@ -1223,7 +1223,7 @@ gnutls_x509_privkey_generate (gnutls_x509_privkey_t key,
1223 } 1223 }
1224 1224
1225 key->params_size = params_len; 1225 key->params_size = params_len;
1226 key->pk_algorithm = GNUTLS_PK_RSA; 1226 key->pk_algorithm = MHD_GNUTLS_PK_RSA;
1227 1227
1228 break; 1228 break;
1229 default: 1229 default:
@@ -1233,7 +1233,7 @@ gnutls_x509_privkey_generate (gnutls_x509_privkey_t key,
1233 1233
1234 return 0; 1234 return 0;
1235 1235
1236cleanup:key->pk_algorithm = GNUTLS_PK_UNKNOWN; 1236cleanup:key->pk_algorithm = MHD_GNUTLS_PK_UNKNOWN;
1237 key->params_size = 0; 1237 key->params_size = 0;
1238 for (i = 0; i < params_len; i++) 1238 for (i = 0; i < params_len; i++)
1239 _gnutls_mpi_release (&key->params[i]); 1239 _gnutls_mpi_release (&key->params[i]);
@@ -1287,7 +1287,7 @@ gnutls_x509_privkey_get_key_id (gnutls_x509_privkey_t key,
1287 return GNUTLS_E_SHORT_MEMORY_BUFFER; 1287 return GNUTLS_E_SHORT_MEMORY_BUFFER;
1288 } 1288 }
1289 1289
1290 if (key->pk_algorithm == GNUTLS_PK_RSA) 1290 if (key->pk_algorithm == MHD_GNUTLS_PK_RSA)
1291 { 1291 {
1292 result = _gnutls_x509_write_rsa_params (key->params, key->params_size, 1292 result = _gnutls_x509_write_rsa_params (key->params, key->params_size,
1293 &der); 1293 &der);
@@ -1300,7 +1300,7 @@ gnutls_x509_privkey_get_key_id (gnutls_x509_privkey_t key,
1300 else 1300 else
1301 return GNUTLS_E_INTERNAL_ERROR; 1301 return GNUTLS_E_INTERNAL_ERROR;
1302 1302
1303 hd = _gnutls_hash_init (GNUTLS_MAC_SHA1); 1303 hd = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
1304 if (hd == GNUTLS_HASH_FAILED) 1304 if (hd == GNUTLS_HASH_FAILED)
1305 { 1305 {
1306 gnutls_assert (); 1306 gnutls_assert ();
@@ -1483,7 +1483,7 @@ gnutls_x509_privkey_fix (gnutls_x509_privkey_t key)
1483 asn1_delete_structure (&key->key); 1483 asn1_delete_structure (&key->key);
1484 switch (key->pk_algorithm) 1484 switch (key->pk_algorithm)
1485 { 1485 {
1486 case GNUTLS_PK_RSA: 1486 case MHD_GNUTLS_PK_RSA:
1487 ret = _gnutls_asn1_encode_rsa (&key->key, key->params); 1487 ret = _gnutls_asn1_encode_rsa (&key->key, key->params);
1488 if (ret < 0) 1488 if (ret < 0)
1489 { 1489 {
diff --git a/src/daemon/https/x509/x509_verify.c b/src/daemon/https/x509/x509_verify.c
index f01fed9d..75cdef04 100644
--- a/src/daemon/https/x509/x509_verify.c
+++ b/src/daemon/https/x509/x509_verify.c
@@ -500,7 +500,7 @@ decode_ber_digest_info (const gnutls_datum_t * info,
500 500
501 *hash = _gnutls_x509_oid2mac_algorithm (str); 501 *hash = _gnutls_x509_oid2mac_algorithm (str);
502 502
503 if (*hash == GNUTLS_MAC_UNKNOWN) 503 if (*hash == MHD_GNUTLS_MAC_UNKNOWN)
504 { 504 {
505 505
506 _gnutls_x509_log ("verify.c: HASH OID: %s\n", str); 506 _gnutls_x509_log ("verify.c: HASH OID: %s\n", str);
@@ -547,7 +547,7 @@ _pkcs1_rsa_verify_sig (const gnutls_datum_t * text,
547 const gnutls_datum_t * signature, 547 const gnutls_datum_t * signature,
548 mpi_t * params, int params_len) 548 mpi_t * params, int params_len)
549{ 549{
550 gnutls_mac_algorithm_t hash = GNUTLS_MAC_UNKNOWN; 550 gnutls_mac_algorithm_t hash = MHD_GNUTLS_MAC_UNKNOWN;
551 int ret; 551 int ret;
552 opaque digest[MAX_HASH_SIZE], md[MAX_HASH_SIZE]; 552 opaque digest[MAX_HASH_SIZE], md[MAX_HASH_SIZE];
553 int digest_size; 553 int digest_size;
@@ -613,7 +613,7 @@ dsa_verify_sig (const gnutls_datum_t * text,
613 gnutls_datum_t digest; 613 gnutls_datum_t digest;
614 GNUTLS_HASH_HANDLE hd; 614 GNUTLS_HASH_HANDLE hd;
615 615
616 hd = _gnutls_hash_init (GNUTLS_MAC_SHA1); 616 hd = _gnutls_hash_init (MHD_GNUTLS_MAC_SHA1);
617 if (hd == NULL) 617 if (hd == NULL)
618 { 618 {
619 gnutls_assert (); 619 gnutls_assert ();
@@ -643,7 +643,7 @@ verify_sig (const gnutls_datum_t * tbs,
643 643
644 switch (pk) 644 switch (pk)
645 { 645 {
646 case GNUTLS_PK_RSA: 646 case MHD_GNUTLS_PK_RSA:
647 647
648 if (_pkcs1_rsa_verify_sig 648 if (_pkcs1_rsa_verify_sig
649 (tbs, signature, issuer_params, issuer_params_size) != 0) 649 (tbs, signature, issuer_params, issuer_params_size) != 0)
diff --git a/src/daemon/https/x509/x509_write.c b/src/daemon/https/x509/x509_write.c
index d9529c33..8855eadb 100644
--- a/src/daemon/https/x509/x509_write.c
+++ b/src/daemon/https/x509/x509_write.c
@@ -632,7 +632,8 @@ int
632gnutls_x509_crt_sign (gnutls_x509_crt_t crt, gnutls_x509_crt_t issuer, 632gnutls_x509_crt_sign (gnutls_x509_crt_t crt, gnutls_x509_crt_t issuer,
633 gnutls_x509_privkey_t issuer_key) 633 gnutls_x509_privkey_t issuer_key)
634{ 634{
635 return gnutls_x509_crt_sign2 (crt, issuer, issuer_key, GNUTLS_DIG_SHA1, 0); 635 return gnutls_x509_crt_sign2 (crt, issuer, issuer_key, MHD_GNUTLS_DIG_SHA1,
636 0);
636} 637}
637 638
638/** 639/**
diff --git a/src/daemon/postprocessor.c b/src/daemon/postprocessor.c
index 9436ec9d..46c68518 100644
--- a/src/daemon/postprocessor.c
+++ b/src/daemon/postprocessor.c
@@ -1026,8 +1026,7 @@ MHD_destroy_post_processor (struct MHD_PostProcessor *pp)
1026 /* These internal strings need cleaning up since 1026 /* These internal strings need cleaning up since
1027 the post-processing may have been interrupted 1027 the post-processing may have been interrupted
1028 at any stage */ 1028 at any stage */
1029 if ( (pp->xbuf_pos > 0) || 1029 if ((pp->xbuf_pos > 0) || (pp->state != PP_Done))
1030 (pp->state != PP_Done) )
1031 ret = MHD_NO; 1030 ret = MHD_NO;
1032 else 1031 else
1033 ret = MHD_YES; 1032 ret = MHD_YES;
diff --git a/src/daemon/postprocessor_large_test.c b/src/daemon/postprocessor_large_test.c
index f3e1f478..0e8f593c 100644
--- a/src/daemon/postprocessor_large_test.c
+++ b/src/daemon/postprocessor_large_test.c
@@ -24,12 +24,9 @@
24 * @author Christian Grothoff 24 * @author Christian Grothoff
25 */ 25 */
26 26
27#include "config.h" 27#include "platform.h"
28#include "microhttpd.h" 28#include "microhttpd.h"
29#include "internal.h" 29#include "internal.h"
30#include <stdlib.h>
31#include <string.h>
32#include <stdio.h>
33 30
34#ifndef WINDOWS 31#ifndef WINDOWS
35#include <unistd.h> 32#include <unistd.h>
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-03 03:00:26 +0000