Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 1 | /* |
| 2 | * SSL server demonstration program using pthread for handling multiple |
| 3 | * clients. |
| 4 | * |
Bence Szépkúti | a2947ac | 2020-08-19 16:37:36 +0200 | [diff] [blame] | 5 | * Copyright The Mbed TLS Contributors |
Bence Szépkúti | f744bd7 | 2020-06-05 13:02:18 +0200 | [diff] [blame] | 6 | * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later |
| 7 | * |
| 8 | * This file is provided under the Apache License 2.0, or the |
| 9 | * GNU General Public License v2.0 or later. |
| 10 | * |
| 11 | * ********** |
| 12 | * Apache License 2.0: |
Manuel Pégourié-Gonnard | 37ff140 | 2015-09-04 14:21:07 +0200 | [diff] [blame] | 13 | * |
| 14 | * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 15 | * not use this file except in compliance with the License. |
| 16 | * You may obtain a copy of the License at |
| 17 | * |
| 18 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 19 | * |
| 20 | * Unless required by applicable law or agreed to in writing, software |
| 21 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 22 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 23 | * See the License for the specific language governing permissions and |
| 24 | * limitations under the License. |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 25 | * |
Bence Szépkúti | f744bd7 | 2020-06-05 13:02:18 +0200 | [diff] [blame] | 26 | * ********** |
| 27 | * |
| 28 | * ********** |
| 29 | * GNU General Public License v2.0 or later: |
| 30 | * |
| 31 | * This program is free software; you can redistribute it and/or modify |
| 32 | * it under the terms of the GNU General Public License as published by |
| 33 | * the Free Software Foundation; either version 2 of the License, or |
| 34 | * (at your option) any later version. |
| 35 | * |
| 36 | * This program is distributed in the hope that it will be useful, |
| 37 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 38 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 39 | * GNU General Public License for more details. |
| 40 | * |
| 41 | * You should have received a copy of the GNU General Public License along |
| 42 | * with this program; if not, write to the Free Software Foundation, Inc., |
| 43 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
| 44 | * |
| 45 | * ********** |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 46 | */ |
| 47 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 48 | #if !defined(MBEDTLS_CONFIG_FILE) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 49 | #include "mbedtls/config.h" |
Manuel Pégourié-Gonnard | cef4ad2 | 2014-04-29 12:39:06 +0200 | [diff] [blame] | 50 | #else |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 51 | #include MBEDTLS_CONFIG_FILE |
Manuel Pégourié-Gonnard | cef4ad2 | 2014-04-29 12:39:06 +0200 | [diff] [blame] | 52 | #endif |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 53 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 54 | #if defined(MBEDTLS_PLATFORM_C) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 55 | #include "mbedtls/platform.h" |
Rich Evans | f90016a | 2015-01-19 14:26:37 +0000 | [diff] [blame] | 56 | #else |
Rich Evans | 18b78c7 | 2015-02-11 14:06:19 +0000 | [diff] [blame] | 57 | #include <stdio.h> |
Manuel Pégourié-Gonnard | 3ef6a6d | 2018-12-10 14:31:45 +0100 | [diff] [blame] | 58 | #include <stdlib.h> |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 59 | #define mbedtls_fprintf fprintf |
| 60 | #define mbedtls_printf printf |
| 61 | #define mbedtls_snprintf snprintf |
Manuel Pégourié-Gonnard | 3ef6a6d | 2018-12-10 14:31:45 +0100 | [diff] [blame] | 62 | #define mbedtls_exit exit |
| 63 | #define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS |
| 64 | #define MBEDTLS_EXIT_FAILURE EXIT_FAILURE |
Rich Evans | f90016a | 2015-01-19 14:26:37 +0000 | [diff] [blame] | 65 | #endif |
| 66 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 67 | #if !defined(MBEDTLS_BIGNUM_C) || !defined(MBEDTLS_CERTS_C) || \ |
| 68 | !defined(MBEDTLS_ENTROPY_C) || !defined(MBEDTLS_SSL_TLS_C) || \ |
| 69 | !defined(MBEDTLS_SSL_SRV_C) || !defined(MBEDTLS_NET_C) || \ |
| 70 | !defined(MBEDTLS_RSA_C) || !defined(MBEDTLS_CTR_DRBG_C) || \ |
| 71 | !defined(MBEDTLS_X509_CRT_PARSE_C) || !defined(MBEDTLS_FS_IO) || \ |
| 72 | !defined(MBEDTLS_THREADING_C) || !defined(MBEDTLS_THREADING_PTHREAD) || \ |
| 73 | !defined(MBEDTLS_PEM_PARSE_C) |
Rich Evans | 85b05ec | 2015-02-12 11:37:29 +0000 | [diff] [blame] | 74 | int main( void ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 75 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 76 | mbedtls_printf("MBEDTLS_BIGNUM_C and/or MBEDTLS_CERTS_C and/or MBEDTLS_ENTROPY_C " |
| 77 | "and/or MBEDTLS_SSL_TLS_C and/or MBEDTLS_SSL_SRV_C and/or " |
| 78 | "MBEDTLS_NET_C and/or MBEDTLS_RSA_C and/or " |
| 79 | "MBEDTLS_CTR_DRBG_C and/or MBEDTLS_X509_CRT_PARSE_C and/or " |
| 80 | "MBEDTLS_THREADING_C and/or MBEDTLS_THREADING_PTHREAD " |
| 81 | "and/or MBEDTLS_PEM_PARSE_C not defined.\n"); |
Krzysztof Stachowiak | 3b0c430 | 2019-04-24 14:24:46 +0200 | [diff] [blame] | 82 | mbedtls_exit( 0 ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 83 | } |
| 84 | #else |
Manuel Pégourié-Gonnard | 4b3e5ef | 2015-03-27 11:24:27 +0100 | [diff] [blame] | 85 | |
| 86 | #include <stdlib.h> |
| 87 | #include <string.h> |
| 88 | |
| 89 | #if defined(_WIN32) |
| 90 | #include <windows.h> |
| 91 | #endif |
| 92 | |
| 93 | #include "mbedtls/entropy.h" |
| 94 | #include "mbedtls/ctr_drbg.h" |
| 95 | #include "mbedtls/certs.h" |
| 96 | #include "mbedtls/x509.h" |
| 97 | #include "mbedtls/ssl.h" |
Andres AG | 788aa4a | 2016-09-14 14:32:09 +0100 | [diff] [blame] | 98 | #include "mbedtls/net_sockets.h" |
Manuel Pégourié-Gonnard | 4b3e5ef | 2015-03-27 11:24:27 +0100 | [diff] [blame] | 99 | #include "mbedtls/error.h" |
| 100 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 101 | #if defined(MBEDTLS_SSL_CACHE_C) |
Manuel Pégourié-Gonnard | 4b3e5ef | 2015-03-27 11:24:27 +0100 | [diff] [blame] | 102 | #include "mbedtls/ssl_cache.h" |
| 103 | #endif |
| 104 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 105 | #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) |
Manuel Pégourié-Gonnard | 4b3e5ef | 2015-03-27 11:24:27 +0100 | [diff] [blame] | 106 | #include "mbedtls/memory_buffer_alloc.h" |
| 107 | #endif |
| 108 | |
Manuel Pégourié-Gonnard | 3ef6a6d | 2018-12-10 14:31:45 +0100 | [diff] [blame] | 109 | |
Manuel Pégourié-Gonnard | 4b3e5ef | 2015-03-27 11:24:27 +0100 | [diff] [blame] | 110 | #define HTTP_RESPONSE \ |
| 111 | "HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n" \ |
| 112 | "<h2>mbed TLS Test Server</h2>\r\n" \ |
| 113 | "<p>Successful connection using: %s</p>\r\n" |
| 114 | |
| 115 | #define DEBUG_LEVEL 0 |
| 116 | |
| 117 | #define MAX_NUM_THREADS 5 |
| 118 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 119 | mbedtls_threading_mutex_t debug_mutex; |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 120 | |
Manuel Pégourié-Gonnard | 61ee351 | 2015-06-23 17:35:03 +0200 | [diff] [blame] | 121 | static void my_mutexed_debug( void *ctx, int level, |
| 122 | const char *file, int line, |
| 123 | const char *str ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 124 | { |
Manuel Pégourié-Gonnard | 61ee351 | 2015-06-23 17:35:03 +0200 | [diff] [blame] | 125 | long int thread_id = (long int) pthread_self(); |
| 126 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 127 | mbedtls_mutex_lock( &debug_mutex ); |
Manuel Pégourié-Gonnard | 61ee351 | 2015-06-23 17:35:03 +0200 | [diff] [blame] | 128 | |
| 129 | ((void) level); |
| 130 | mbedtls_fprintf( (FILE *) ctx, "%s:%04d: [ #%ld ] %s", |
| 131 | file, line, thread_id, str ); |
| 132 | fflush( (FILE *) ctx ); |
| 133 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 134 | mbedtls_mutex_unlock( &debug_mutex ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 135 | } |
| 136 | |
| 137 | typedef struct { |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 138 | mbedtls_net_context client_fd; |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 139 | int thread_complete; |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 140 | const mbedtls_ssl_config *config; |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 141 | } thread_info_t; |
| 142 | |
| 143 | typedef struct { |
| 144 | int active; |
| 145 | thread_info_t data; |
| 146 | pthread_t thread; |
| 147 | } pthread_info_t; |
| 148 | |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 149 | static thread_info_t base_info; |
| 150 | static pthread_info_t threads[MAX_NUM_THREADS]; |
| 151 | |
| 152 | static void *handle_ssl_connection( void *data ) |
| 153 | { |
| 154 | int ret, len; |
| 155 | thread_info_t *thread_info = (thread_info_t *) data; |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 156 | mbedtls_net_context *client_fd = &thread_info->client_fd; |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 157 | long int thread_id = (long int) pthread_self(); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 158 | unsigned char buf[1024]; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 159 | mbedtls_ssl_context ssl; |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 160 | |
Manuel Pégourié-Gonnard | 955028f | 2014-07-12 01:27:34 +0200 | [diff] [blame] | 161 | /* Make sure memory references are valid */ |
Manuel Pégourié-Gonnard | 41d479e | 2015-04-29 00:48:22 +0200 | [diff] [blame] | 162 | mbedtls_ssl_init( &ssl ); |
Manuel Pégourié-Gonnard | 955028f | 2014-07-12 01:27:34 +0200 | [diff] [blame] | 163 | |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 164 | mbedtls_printf( " [ #%ld ] Setting up SSL/TLS data\n", thread_id ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 165 | |
| 166 | /* |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 167 | * 4. Get the SSL context ready |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 168 | */ |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 169 | if( ( ret = mbedtls_ssl_setup( &ssl, thread_info->config ) ) != 0 ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 170 | { |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 171 | mbedtls_printf( " [ #%ld ] failed: mbedtls_ssl_setup returned -0x%04x\n", |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 172 | thread_id, -ret ); |
| 173 | goto thread_exit; |
| 174 | } |
| 175 | |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 176 | mbedtls_ssl_set_bio( &ssl, client_fd, mbedtls_net_send, mbedtls_net_recv, NULL ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 177 | |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 178 | /* |
| 179 | * 5. Handshake |
| 180 | */ |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 181 | mbedtls_printf( " [ #%ld ] Performing the SSL/TLS handshake\n", thread_id ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 182 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 183 | while( ( ret = mbedtls_ssl_handshake( &ssl ) ) != 0 ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 184 | { |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 185 | if( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 186 | { |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 187 | mbedtls_printf( " [ #%ld ] failed: mbedtls_ssl_handshake returned -0x%04x\n", |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 188 | thread_id, -ret ); |
| 189 | goto thread_exit; |
| 190 | } |
| 191 | } |
| 192 | |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 193 | mbedtls_printf( " [ #%ld ] ok\n", thread_id ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 194 | |
| 195 | /* |
| 196 | * 6. Read the HTTP Request |
| 197 | */ |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 198 | mbedtls_printf( " [ #%ld ] < Read from client\n", thread_id ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 199 | |
| 200 | do |
| 201 | { |
| 202 | len = sizeof( buf ) - 1; |
| 203 | memset( buf, 0, sizeof( buf ) ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 204 | ret = mbedtls_ssl_read( &ssl, buf, len ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 205 | |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 206 | if( ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 207 | continue; |
| 208 | |
| 209 | if( ret <= 0 ) |
| 210 | { |
| 211 | switch( ret ) |
| 212 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 213 | case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY: |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 214 | mbedtls_printf( " [ #%ld ] connection was closed gracefully\n", |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 215 | thread_id ); |
| 216 | goto thread_exit; |
| 217 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 218 | case MBEDTLS_ERR_NET_CONN_RESET: |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 219 | mbedtls_printf( " [ #%ld ] connection was reset by peer\n", |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 220 | thread_id ); |
| 221 | goto thread_exit; |
| 222 | |
| 223 | default: |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 224 | mbedtls_printf( " [ #%ld ] mbedtls_ssl_read returned -0x%04x\n", |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 225 | thread_id, -ret ); |
| 226 | goto thread_exit; |
| 227 | } |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 228 | } |
| 229 | |
| 230 | len = ret; |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 231 | mbedtls_printf( " [ #%ld ] %d bytes read\n=====\n%s\n=====\n", |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 232 | thread_id, len, (char *) buf ); |
| 233 | |
| 234 | if( ret > 0 ) |
| 235 | break; |
| 236 | } |
| 237 | while( 1 ); |
| 238 | |
| 239 | /* |
| 240 | * 7. Write the 200 Response |
| 241 | */ |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 242 | mbedtls_printf( " [ #%ld ] > Write to client:\n", thread_id ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 243 | |
| 244 | len = sprintf( (char *) buf, HTTP_RESPONSE, |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 245 | mbedtls_ssl_get_ciphersuite( &ssl ) ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 246 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 247 | while( ( ret = mbedtls_ssl_write( &ssl, buf, len ) ) <= 0 ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 248 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 249 | if( ret == MBEDTLS_ERR_NET_CONN_RESET ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 250 | { |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 251 | mbedtls_printf( " [ #%ld ] failed: peer closed the connection\n", |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 252 | thread_id ); |
| 253 | goto thread_exit; |
| 254 | } |
| 255 | |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 256 | if( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 257 | { |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 258 | mbedtls_printf( " [ #%ld ] failed: mbedtls_ssl_write returned -0x%04x\n", |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 259 | thread_id, ret ); |
| 260 | goto thread_exit; |
| 261 | } |
| 262 | } |
| 263 | |
| 264 | len = ret; |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 265 | mbedtls_printf( " [ #%ld ] %d bytes written\n=====\n%s\n=====\n", |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 266 | thread_id, len, (char *) buf ); |
| 267 | |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 268 | mbedtls_printf( " [ #%ld ] . Closing the connection...", thread_id ); |
Manuel Pégourié-Gonnard | 6b0d268 | 2014-03-25 11:24:43 +0100 | [diff] [blame] | 269 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 270 | while( ( ret = mbedtls_ssl_close_notify( &ssl ) ) < 0 ) |
Manuel Pégourié-Gonnard | 6b0d268 | 2014-03-25 11:24:43 +0100 | [diff] [blame] | 271 | { |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 272 | if( ret != MBEDTLS_ERR_SSL_WANT_READ && |
| 273 | ret != MBEDTLS_ERR_SSL_WANT_WRITE ) |
Manuel Pégourié-Gonnard | 6b0d268 | 2014-03-25 11:24:43 +0100 | [diff] [blame] | 274 | { |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 275 | mbedtls_printf( " [ #%ld ] failed: mbedtls_ssl_close_notify returned -0x%04x\n", |
Manuel Pégourié-Gonnard | 6b0d268 | 2014-03-25 11:24:43 +0100 | [diff] [blame] | 276 | thread_id, ret ); |
| 277 | goto thread_exit; |
| 278 | } |
| 279 | } |
| 280 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 281 | mbedtls_printf( " ok\n" ); |
Manuel Pégourié-Gonnard | 6b0d268 | 2014-03-25 11:24:43 +0100 | [diff] [blame] | 282 | |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 283 | ret = 0; |
| 284 | |
| 285 | thread_exit: |
| 286 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 287 | #ifdef MBEDTLS_ERROR_C |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 288 | if( ret != 0 ) |
| 289 | { |
| 290 | char error_buf[100]; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 291 | mbedtls_strerror( ret, error_buf, 100 ); |
Manuel Pégourié-Gonnard | 30eceb7 | 2015-05-11 14:42:56 +0200 | [diff] [blame] | 292 | mbedtls_printf(" [ #%ld ] Last error was: -0x%04x - %s\n\n", |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 293 | thread_id, -ret, error_buf ); |
| 294 | } |
| 295 | #endif |
| 296 | |
Manuel Pégourié-Gonnard | 3d7d00a | 2015-06-30 15:55:03 +0200 | [diff] [blame] | 297 | mbedtls_net_free( client_fd ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 298 | mbedtls_ssl_free( &ssl ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 299 | |
| 300 | thread_info->thread_complete = 1; |
| 301 | |
| 302 | return( NULL ); |
| 303 | } |
| 304 | |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 305 | static int thread_create( mbedtls_net_context *client_fd ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 306 | { |
| 307 | int ret, i; |
| 308 | |
| 309 | /* |
| 310 | * Find in-active or finished thread slot |
| 311 | */ |
| 312 | for( i = 0; i < MAX_NUM_THREADS; i++ ) |
| 313 | { |
| 314 | if( threads[i].active == 0 ) |
| 315 | break; |
| 316 | |
| 317 | if( threads[i].data.thread_complete == 1 ) |
| 318 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 319 | mbedtls_printf( " [ main ] Cleaning up thread %d\n", i ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 320 | pthread_join(threads[i].thread, NULL ); |
| 321 | memset( &threads[i], 0, sizeof(pthread_info_t) ); |
| 322 | break; |
| 323 | } |
| 324 | } |
| 325 | |
| 326 | if( i == MAX_NUM_THREADS ) |
| 327 | return( -1 ); |
| 328 | |
| 329 | /* |
| 330 | * Fill thread-info for thread |
| 331 | */ |
| 332 | memcpy( &threads[i].data, &base_info, sizeof(base_info) ); |
| 333 | threads[i].active = 1; |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 334 | memcpy( &threads[i].data.client_fd, client_fd, sizeof( mbedtls_net_context ) ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 335 | |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 336 | if( ( ret = pthread_create( &threads[i].thread, NULL, handle_ssl_connection, |
| 337 | &threads[i].data ) ) != 0 ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 338 | { |
| 339 | return( ret ); |
| 340 | } |
| 341 | |
| 342 | return( 0 ); |
| 343 | } |
| 344 | |
Rich Evans | 85b05ec | 2015-02-12 11:37:29 +0000 | [diff] [blame] | 345 | int main( void ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 346 | { |
| 347 | int ret; |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 348 | mbedtls_net_context listen_fd, client_fd; |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 349 | const char pers[] = "ssl_pthread_server"; |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 350 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 351 | mbedtls_entropy_context entropy; |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 352 | mbedtls_ctr_drbg_context ctr_drbg; |
| 353 | mbedtls_ssl_config conf; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 354 | mbedtls_x509_crt srvcert; |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 355 | mbedtls_x509_crt cachain; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 356 | mbedtls_pk_context pkey; |
| 357 | #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 358 | unsigned char alloc_buf[100000]; |
| 359 | #endif |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 360 | #if defined(MBEDTLS_SSL_CACHE_C) |
| 361 | mbedtls_ssl_cache_context cache; |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 362 | #endif |
| 363 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 364 | #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) |
| 365 | mbedtls_memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 366 | #endif |
| 367 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 368 | #if defined(MBEDTLS_SSL_CACHE_C) |
| 369 | mbedtls_ssl_cache_init( &cache ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 370 | #endif |
| 371 | |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 372 | mbedtls_x509_crt_init( &srvcert ); |
| 373 | mbedtls_x509_crt_init( &cachain ); |
| 374 | |
| 375 | mbedtls_ssl_config_init( &conf ); |
| 376 | mbedtls_ctr_drbg_init( &ctr_drbg ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 377 | memset( threads, 0, sizeof(threads) ); |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 378 | mbedtls_net_init( &listen_fd ); |
| 379 | mbedtls_net_init( &client_fd ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 380 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 381 | mbedtls_mutex_init( &debug_mutex ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 382 | |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 383 | base_info.config = &conf; |
| 384 | |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 385 | /* |
| 386 | * We use only a single entropy source that is used in all the threads. |
| 387 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 388 | mbedtls_entropy_init( &entropy ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 389 | |
| 390 | /* |
| 391 | * 1. Load the certificates and private RSA key |
| 392 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 393 | mbedtls_printf( "\n . Loading the server cert. and key..." ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 394 | fflush( stdout ); |
| 395 | |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 396 | /* |
| 397 | * This demonstration program uses embedded test certificates. |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 398 | * Instead, you may want to use mbedtls_x509_crt_parse_file() to read the |
| 399 | * server and CA certificates, as well as mbedtls_pk_parse_keyfile(). |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 400 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 401 | ret = mbedtls_x509_crt_parse( &srvcert, (const unsigned char *) mbedtls_test_srv_crt, |
| 402 | mbedtls_test_srv_crt_len ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 403 | if( ret != 0 ) |
| 404 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 405 | mbedtls_printf( " failed\n ! mbedtls_x509_crt_parse returned %d\n\n", ret ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 406 | goto exit; |
| 407 | } |
| 408 | |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 409 | ret = mbedtls_x509_crt_parse( &cachain, (const unsigned char *) mbedtls_test_cas_pem, |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 410 | mbedtls_test_cas_pem_len ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 411 | if( ret != 0 ) |
| 412 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 413 | mbedtls_printf( " failed\n ! mbedtls_x509_crt_parse returned %d\n\n", ret ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 414 | goto exit; |
| 415 | } |
| 416 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 417 | mbedtls_pk_init( &pkey ); |
| 418 | ret = mbedtls_pk_parse_key( &pkey, (const unsigned char *) mbedtls_test_srv_key, |
| 419 | mbedtls_test_srv_key_len, NULL, 0 ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 420 | if( ret != 0 ) |
| 421 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 422 | mbedtls_printf( " failed\n ! mbedtls_pk_parse_key returned %d\n\n", ret ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 423 | goto exit; |
| 424 | } |
| 425 | |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 426 | mbedtls_printf( " ok\n" ); |
| 427 | |
| 428 | /* |
| 429 | * 1b. Seed the random number generator |
| 430 | */ |
| 431 | mbedtls_printf( " . Seeding the random number generator..." ); |
| 432 | |
| 433 | if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy, |
| 434 | (const unsigned char *) pers, |
| 435 | strlen( pers ) ) ) != 0 ) |
| 436 | { |
| 437 | mbedtls_printf( " failed: mbedtls_ctr_drbg_seed returned -0x%04x\n", |
| 438 | -ret ); |
| 439 | goto exit; |
| 440 | } |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 441 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 442 | mbedtls_printf( " ok\n" ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 443 | |
| 444 | /* |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 445 | * 1c. Prepare SSL configuration |
| 446 | */ |
| 447 | mbedtls_printf( " . Setting up the SSL data...." ); |
| 448 | |
| 449 | if( ( ret = mbedtls_ssl_config_defaults( &conf, |
| 450 | MBEDTLS_SSL_IS_SERVER, |
Manuel Pégourié-Gonnard | b31c5f6 | 2015-06-17 13:53:47 +0200 | [diff] [blame] | 451 | MBEDTLS_SSL_TRANSPORT_STREAM, |
| 452 | MBEDTLS_SSL_PRESET_DEFAULT ) ) != 0 ) |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 453 | { |
| 454 | mbedtls_printf( " failed: mbedtls_ssl_config_defaults returned -0x%04x\n", |
| 455 | -ret ); |
| 456 | goto exit; |
| 457 | } |
| 458 | |
| 459 | mbedtls_ssl_conf_rng( &conf, mbedtls_ctr_drbg_random, &ctr_drbg ); |
| 460 | mbedtls_ssl_conf_dbg( &conf, my_mutexed_debug, stdout ); |
| 461 | |
| 462 | /* mbedtls_ssl_cache_get() and mbedtls_ssl_cache_set() are thread-safe if |
| 463 | * MBEDTLS_THREADING_C is set. |
| 464 | */ |
| 465 | #if defined(MBEDTLS_SSL_CACHE_C) |
| 466 | mbedtls_ssl_conf_session_cache( &conf, &cache, |
| 467 | mbedtls_ssl_cache_get, |
| 468 | mbedtls_ssl_cache_set ); |
| 469 | #endif |
| 470 | |
| 471 | mbedtls_ssl_conf_ca_chain( &conf, &cachain, NULL ); |
| 472 | if( ( ret = mbedtls_ssl_conf_own_cert( &conf, &srvcert, &pkey ) ) != 0 ) |
| 473 | { |
| 474 | mbedtls_printf( " failed\n ! mbedtls_ssl_conf_own_cert returned %d\n\n", ret ); |
| 475 | goto exit; |
| 476 | } |
| 477 | |
| 478 | mbedtls_printf( " ok\n" ); |
| 479 | |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 480 | /* |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 481 | * 2. Setup the listening TCP socket |
| 482 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 483 | mbedtls_printf( " . Bind on https://localhost:4433/ ..." ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 484 | fflush( stdout ); |
| 485 | |
Manuel Pégourié-Gonnard | c0d7494 | 2015-06-23 12:30:57 +0200 | [diff] [blame] | 486 | if( ( ret = mbedtls_net_bind( &listen_fd, NULL, "4433", MBEDTLS_NET_PROTO_TCP ) ) != 0 ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 487 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 488 | mbedtls_printf( " failed\n ! mbedtls_net_bind returned %d\n\n", ret ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 489 | goto exit; |
| 490 | } |
| 491 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 492 | mbedtls_printf( " ok\n" ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 493 | |
| 494 | reset: |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 495 | #ifdef MBEDTLS_ERROR_C |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 496 | if( ret != 0 ) |
| 497 | { |
| 498 | char error_buf[100]; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 499 | mbedtls_strerror( ret, error_buf, 100 ); |
| 500 | mbedtls_printf( " [ main ] Last error was: -0x%04x - %s\n", -ret, error_buf ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 501 | } |
| 502 | #endif |
| 503 | |
| 504 | /* |
| 505 | * 3. Wait until a client connects |
| 506 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 507 | mbedtls_printf( " [ main ] Waiting for a remote connection\n" ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 508 | |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 509 | if( ( ret = mbedtls_net_accept( &listen_fd, &client_fd, |
Manuel Pégourié-Gonnard | 0b104b0 | 2015-05-14 21:52:40 +0200 | [diff] [blame] | 510 | NULL, 0, NULL ) ) != 0 ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 511 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 512 | mbedtls_printf( " [ main ] failed: mbedtls_net_accept returned -0x%04x\n", ret ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 513 | goto exit; |
| 514 | } |
| 515 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 516 | mbedtls_printf( " [ main ] ok\n" ); |
| 517 | mbedtls_printf( " [ main ] Creating a new thread\n" ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 518 | |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 519 | if( ( ret = thread_create( &client_fd ) ) != 0 ) |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 520 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 521 | mbedtls_printf( " [ main ] failed: thread_create returned %d\n", ret ); |
Manuel Pégourié-Gonnard | 3d7d00a | 2015-06-30 15:55:03 +0200 | [diff] [blame] | 522 | mbedtls_net_free( &client_fd ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 523 | goto reset; |
| 524 | } |
| 525 | |
| 526 | ret = 0; |
| 527 | goto reset; |
| 528 | |
| 529 | exit: |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 530 | mbedtls_x509_crt_free( &srvcert ); |
| 531 | mbedtls_pk_free( &pkey ); |
| 532 | #if defined(MBEDTLS_SSL_CACHE_C) |
| 533 | mbedtls_ssl_cache_free( &cache ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 534 | #endif |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 535 | mbedtls_ctr_drbg_free( &ctr_drbg ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 536 | mbedtls_entropy_free( &entropy ); |
Manuel Pégourié-Gonnard | 0af00e8 | 2015-05-11 11:32:43 +0200 | [diff] [blame] | 537 | mbedtls_ssl_config_free( &conf ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 538 | |
Manuel Pégourié-Gonnard | 5db6432 | 2015-06-30 15:40:39 +0200 | [diff] [blame] | 539 | mbedtls_net_free( &listen_fd ); |
| 540 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 541 | mbedtls_mutex_free( &debug_mutex ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 542 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 543 | #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) |
| 544 | mbedtls_memory_buffer_alloc_free(); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 545 | #endif |
| 546 | |
| 547 | #if defined(_WIN32) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 548 | mbedtls_printf( " Press Enter to exit this program.\n" ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 549 | fflush( stdout ); getchar(); |
| 550 | #endif |
| 551 | |
Krzysztof Stachowiak | 3b0c430 | 2019-04-24 14:24:46 +0200 | [diff] [blame] | 552 | mbedtls_exit( ret ); |
Paul Bakker | f9c4953 | 2013-12-19 15:40:58 +0100 | [diff] [blame] | 553 | } |
| 554 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 555 | #endif /* MBEDTLS_BIGNUM_C && MBEDTLS_CERTS_C && MBEDTLS_ENTROPY_C && |
| 556 | MBEDTLS_SSL_TLS_C && MBEDTLS_SSL_SRV_C && MBEDTLS_NET_C && |
| 557 | MBEDTLS_RSA_C && MBEDTLS_CTR_DRBG_C && MBEDTLS_THREADING_C && |
| 558 | MBEDTLS_THREADING_PTHREAD && MBEDTLS_PEM_PARSE_C */ |