Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 1 | /* |
Manuel Pégourié-Gonnard | f4acfe1 | 2014-09-17 10:56:54 +0200 | [diff] [blame] | 2 | * TCP/IP or UDP/IP networking functions |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 3 | * |
Bence Szépkúti | 1e14827 | 2020-08-07 13:07:28 +0200 | [diff] [blame] | 4 | * Copyright The Mbed TLS Contributors |
Manuel Pégourié-Gonnard | 37ff140 | 2015-09-04 14:21:07 +0200 | [diff] [blame] | 5 | * SPDX-License-Identifier: Apache-2.0 |
| 6 | * |
| 7 | * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 8 | * not use this file except in compliance with the License. |
| 9 | * You may obtain a copy of the License at |
| 10 | * |
| 11 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 12 | * |
| 13 | * Unless required by applicable law or agreed to in writing, software |
| 14 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 15 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 16 | * See the License for the specific language governing permissions and |
| 17 | * limitations under the License. |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 18 | */ |
| 19 | |
Nicholas Wilson | 2682edf | 2017-12-05 12:08:15 +0000 | [diff] [blame] | 20 | /* Enable definition of getaddrinfo() even when compiling with -std=c99. Must |
| 21 | * be set before config.h, which pulls in glibc's features.h indirectly. |
| 22 | * Harmless on other platforms. */ |
Flavio Ceolin | a79c30b | 2020-05-27 22:41:19 -0700 | [diff] [blame] | 23 | #ifndef _POSIX_C_SOURCE |
Nicholas Wilson | 2682edf | 2017-12-05 12:08:15 +0000 | [diff] [blame] | 24 | #define _POSIX_C_SOURCE 200112L |
Flavio Ceolin | a79c30b | 2020-05-27 22:41:19 -0700 | [diff] [blame] | 25 | #endif |
| 26 | #ifndef _XOPEN_SOURCE |
nia | 0b01fd9 | 2020-06-11 12:29:15 +0100 | [diff] [blame] | 27 | #define _XOPEN_SOURCE 600 /* sockaddr_storage */ |
Flavio Ceolin | a79c30b | 2020-05-27 22:41:19 -0700 | [diff] [blame] | 28 | #endif |
Nicholas Wilson | 2682edf | 2017-12-05 12:08:15 +0000 | [diff] [blame] | 29 | |
Gilles Peskine | db09ef6 | 2020-06-03 01:43:33 +0200 | [diff] [blame] | 30 | #include "common.h" |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 31 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 32 | #if defined(MBEDTLS_NET_C) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 33 | |
Manuel Pégourié-Gonnard | 325ce09 | 2016-02-22 10:33:34 +0100 | [diff] [blame] | 34 | #if !defined(unix) && !defined(__unix__) && !defined(__unix) && \ |
Augustin Cavalier | 60bc47d | 2018-04-11 20:27:32 -0400 | [diff] [blame] | 35 | !defined(__APPLE__) && !defined(_WIN32) && !defined(__QNXNTO__) && \ |
Ørjan Malde | 479d8de | 2020-05-20 09:32:39 +0000 | [diff] [blame] | 36 | !defined(__HAIKU__) && !defined(__midipix__) |
Manuel Pégourié-Gonnard | 325ce09 | 2016-02-22 10:33:34 +0100 | [diff] [blame] | 37 | #error "This module only works on Unix and Windows, see MBEDTLS_NET_C in config.h" |
| 38 | #endif |
| 39 | |
SimonB | d5800b7 | 2016-04-26 07:43:27 +0100 | [diff] [blame] | 40 | #if defined(MBEDTLS_PLATFORM_C) |
| 41 | #include "mbedtls/platform.h" |
| 42 | #else |
| 43 | #include <stdlib.h> |
SimonB | d5800b7 | 2016-04-26 07:43:27 +0100 | [diff] [blame] | 44 | #endif |
| 45 | |
Andres AG | 788aa4a | 2016-09-14 14:32:09 +0100 | [diff] [blame] | 46 | #include "mbedtls/net_sockets.h" |
Janos Follath | 73c616b | 2019-12-18 15:07:04 +0000 | [diff] [blame] | 47 | #include "mbedtls/error.h" |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 48 | |
Rich Evans | 00ab470 | 2015-02-06 13:43:58 +0000 | [diff] [blame] | 49 | #include <string.h> |
| 50 | |
Paul Bakker | fa6a620 | 2013-10-28 18:48:30 +0100 | [diff] [blame] | 51 | #if (defined(_WIN32) || defined(_WIN32_WCE)) && !defined(EFIX64) && \ |
| 52 | !defined(EFI32) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 53 | |
Gilles Peskine | ea7dbbe | 2018-03-15 23:25:21 +0100 | [diff] [blame] | 54 | #define IS_EINTR( ret ) ( ( ret ) == WSAEINTR ) |
Hanno Becker | ef52796 | 2018-03-15 15:49:24 +0000 | [diff] [blame] | 55 | |
opatomic | 2b2acf1 | 2020-04-24 10:00:36 -0400 | [diff] [blame] | 56 | #if !defined(_WIN32_WINNT) |
Manuel Pégourié-Gonnard | 3b6269a | 2014-03-21 10:31:12 +0100 | [diff] [blame] | 57 | /* Enables getaddrinfo() & Co */ |
Manuel Pégourié-Gonnard | 1321135 | 2013-12-17 17:38:55 +0100 | [diff] [blame] | 58 | #define _WIN32_WINNT 0x0501 |
Fabio Alessandrelli | df60856 | 2018-04-03 19:40:11 +0200 | [diff] [blame] | 59 | #endif |
| 60 | |
Manuel Pégourié-Gonnard | 6a398d4 | 2013-12-17 16:10:58 +0100 | [diff] [blame] | 61 | #include <ws2tcpip.h> |
Manuel Pégourié-Gonnard | 6a398d4 | 2013-12-17 16:10:58 +0100 | [diff] [blame] | 62 | |
Manuel Pégourié-Gonnard | 1321135 | 2013-12-17 17:38:55 +0100 | [diff] [blame] | 63 | #include <winsock2.h> |
| 64 | #include <windows.h> |
opatomic | 2b2acf1 | 2020-04-24 10:00:36 -0400 | [diff] [blame] | 65 | #if (_WIN32_WINNT < 0x0501) |
| 66 | #include <wspiapi.h> |
| 67 | #endif |
Manuel Pégourié-Gonnard | 1321135 | 2013-12-17 17:38:55 +0100 | [diff] [blame] | 68 | |
Paul Bakker | f0fc2a2 | 2013-12-30 15:42:43 +0100 | [diff] [blame] | 69 | #if defined(_MSC_VER) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 70 | #if defined(_WIN32_WCE) |
| 71 | #pragma comment( lib, "ws2.lib" ) |
| 72 | #else |
| 73 | #pragma comment( lib, "ws2_32.lib" ) |
| 74 | #endif |
Paul Bakker | f0fc2a2 | 2013-12-30 15:42:43 +0100 | [diff] [blame] | 75 | #endif /* _MSC_VER */ |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 76 | |
Andres Amaya Garcia | bd9d42c | 2017-07-12 14:04:40 +0100 | [diff] [blame] | 77 | #define read(fd,buf,len) recv( fd, (char*)( buf ), (int)( len ), 0 ) |
| 78 | #define write(fd,buf,len) send( fd, (char*)( buf ), (int)( len ), 0 ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 79 | #define close(fd) closesocket(fd) |
| 80 | |
| 81 | static int wsa_init_done = 0; |
| 82 | |
Paul Bakker | db20c10 | 2014-06-17 14:34:44 +0200 | [diff] [blame] | 83 | #else /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */ |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 84 | |
| 85 | #include <sys/types.h> |
| 86 | #include <sys/socket.h> |
| 87 | #include <netinet/in.h> |
| 88 | #include <arpa/inet.h> |
| 89 | #include <sys/time.h> |
| 90 | #include <unistd.h> |
| 91 | #include <signal.h> |
| 92 | #include <fcntl.h> |
| 93 | #include <netdb.h> |
| 94 | #include <errno.h> |
Paul Bakker | b3bb6c0 | 2009-07-27 21:09:47 +0000 | [diff] [blame] | 95 | |
Gilles Peskine | ea7dbbe | 2018-03-15 23:25:21 +0100 | [diff] [blame] | 96 | #define IS_EINTR( ret ) ( ( ret ) == EINTR ) |
Hanno Becker | ef52796 | 2018-03-15 15:49:24 +0000 | [diff] [blame] | 97 | |
Paul Bakker | db20c10 | 2014-06-17 14:34:44 +0200 | [diff] [blame] | 98 | #endif /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */ |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 99 | |
Manuel Pégourié-Gonnard | 9de64f5 | 2015-07-01 15:51:43 +0200 | [diff] [blame] | 100 | /* Some MS functions want int and MSVC warns if we pass size_t, |
Andres Amaya Garcia | bd9d42c | 2017-07-12 14:04:40 +0100 | [diff] [blame] | 101 | * but the standard functions use socklen_t, so cast only for MSVC */ |
Manuel Pégourié-Gonnard | 9de64f5 | 2015-07-01 15:51:43 +0200 | [diff] [blame] | 102 | #if defined(_MSC_VER) |
| 103 | #define MSVC_INT_CAST (int) |
| 104 | #else |
| 105 | #define MSVC_INT_CAST |
| 106 | #endif |
| 107 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 108 | #include <stdio.h> |
Paul Bakker | fa9b100 | 2013-07-03 15:31:03 +0200 | [diff] [blame] | 109 | |
Andrzej Kurek | 516e1b0 | 2022-03-02 10:55:08 -0500 | [diff] [blame^] | 110 | #if defined(MBEDTLS_HAVE_TIME) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 111 | #include <time.h> |
Andrzej Kurek | 516e1b0 | 2022-03-02 10:55:08 -0500 | [diff] [blame^] | 112 | #endif |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 113 | |
Manuel Pégourié-Gonnard | 9386664 | 2015-06-22 19:21:23 +0200 | [diff] [blame] | 114 | #include <stdint.h> |
Paul Bakker | 5c2364c | 2012-10-01 14:41:15 +0000 | [diff] [blame] | 115 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 116 | /* |
Manuel Pégourié-Gonnard | 2e5c316 | 2013-12-13 11:55:32 +0100 | [diff] [blame] | 117 | * Prepare for using the sockets interface |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 118 | */ |
Manuel Pégourié-Gonnard | 173402b | 2013-12-17 15:57:05 +0100 | [diff] [blame] | 119 | static int net_prepare( void ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 120 | { |
Paul Bakker | fa6a620 | 2013-10-28 18:48:30 +0100 | [diff] [blame] | 121 | #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ |
| 122 | !defined(EFI32) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 123 | WSADATA wsaData; |
| 124 | |
| 125 | if( wsa_init_done == 0 ) |
| 126 | { |
Peter Vaskovic | 7015de7 | 2014-05-15 02:54:37 +0200 | [diff] [blame] | 127 | if( WSAStartup( MAKEWORD(2,0), &wsaData ) != 0 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 128 | return( MBEDTLS_ERR_NET_SOCKET_FAILED ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 129 | |
| 130 | wsa_init_done = 1; |
| 131 | } |
| 132 | #else |
Paul Bakker | fa6a620 | 2013-10-28 18:48:30 +0100 | [diff] [blame] | 133 | #if !defined(EFIX64) && !defined(EFI32) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 134 | signal( SIGPIPE, SIG_IGN ); |
| 135 | #endif |
Paul Bakker | fa6a620 | 2013-10-28 18:48:30 +0100 | [diff] [blame] | 136 | #endif |
Manuel Pégourié-Gonnard | ee5db1d | 2013-12-17 16:46:19 +0100 | [diff] [blame] | 137 | return( 0 ); |
Manuel Pégourié-Gonnard | 2e5c316 | 2013-12-13 11:55:32 +0100 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | /* |
Gilles Peskine | 0f6351f | 2021-06-20 23:08:19 +0200 | [diff] [blame] | 141 | * Return 0 if the file descriptor is valid, an error otherwise. |
| 142 | * If for_select != 0, check whether the file descriptor is within the range |
| 143 | * allowed for fd_set used for the FD_xxx macros and the select() function. |
| 144 | */ |
| 145 | static int check_fd( int fd, int for_select ) |
| 146 | { |
| 147 | if( fd < 0 ) |
| 148 | return( MBEDTLS_ERR_NET_INVALID_CONTEXT ); |
| 149 | |
Gilles Peskine | 51859aa | 2021-06-20 22:01:36 +0200 | [diff] [blame] | 150 | #if (defined(_WIN32) || defined(_WIN32_WCE)) && !defined(EFIX64) && \ |
| 151 | !defined(EFI32) |
| 152 | (void) for_select; |
| 153 | #else |
Gilles Peskine | 0f6351f | 2021-06-20 23:08:19 +0200 | [diff] [blame] | 154 | /* A limitation of select() is that it only works with file descriptors |
| 155 | * that are strictly less than FD_SETSIZE. This is a limitation of the |
| 156 | * fd_set type. Error out early, because attempting to call FD_SET on a |
| 157 | * large file descriptor is a buffer overflow on typical platforms. */ |
| 158 | if( for_select && fd >= FD_SETSIZE ) |
| 159 | return( MBEDTLS_ERR_NET_POLL_FAILED ); |
Gilles Peskine | 51859aa | 2021-06-20 22:01:36 +0200 | [diff] [blame] | 160 | #endif |
Gilles Peskine | 0f6351f | 2021-06-20 23:08:19 +0200 | [diff] [blame] | 161 | |
| 162 | return( 0 ); |
| 163 | } |
| 164 | |
| 165 | /* |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 166 | * Initialize a context |
| 167 | */ |
| 168 | void mbedtls_net_init( mbedtls_net_context *ctx ) |
| 169 | { |
| 170 | ctx->fd = -1; |
| 171 | } |
| 172 | |
| 173 | /* |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 174 | * Initiate a TCP connection with host:port and the given protocol |
Manuel Pégourié-Gonnard | 2e5c316 | 2013-12-13 11:55:32 +0100 | [diff] [blame] | 175 | */ |
Simon Butcher | 532c94d | 2016-11-10 17:30:18 +0000 | [diff] [blame] | 176 | int mbedtls_net_connect( mbedtls_net_context *ctx, const char *host, |
| 177 | const char *port, int proto ) |
Manuel Pégourié-Gonnard | 2e5c316 | 2013-12-13 11:55:32 +0100 | [diff] [blame] | 178 | { |
Janos Follath | 865b3eb | 2019-12-16 11:46:15 +0000 | [diff] [blame] | 179 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Manuel Pégourié-Gonnard | 10934de | 2013-12-13 12:54:09 +0100 | [diff] [blame] | 180 | struct addrinfo hints, *addr_list, *cur; |
Manuel Pégourié-Gonnard | 10934de | 2013-12-13 12:54:09 +0100 | [diff] [blame] | 181 | |
Manuel Pégourié-Gonnard | 173402b | 2013-12-17 15:57:05 +0100 | [diff] [blame] | 182 | if( ( ret = net_prepare() ) != 0 ) |
| 183 | return( ret ); |
Manuel Pégourié-Gonnard | 10934de | 2013-12-13 12:54:09 +0100 | [diff] [blame] | 184 | |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 185 | /* Do name resolution with both IPv6 and IPv4 */ |
Manuel Pégourié-Gonnard | 10934de | 2013-12-13 12:54:09 +0100 | [diff] [blame] | 186 | memset( &hints, 0, sizeof( hints ) ); |
| 187 | hints.ai_family = AF_UNSPEC; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 188 | hints.ai_socktype = proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM; |
| 189 | hints.ai_protocol = proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP; |
Manuel Pégourié-Gonnard | 10934de | 2013-12-13 12:54:09 +0100 | [diff] [blame] | 190 | |
Manuel Pégourié-Gonnard | c0d7494 | 2015-06-23 12:30:57 +0200 | [diff] [blame] | 191 | if( getaddrinfo( host, port, &hints, &addr_list ) != 0 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 192 | return( MBEDTLS_ERR_NET_UNKNOWN_HOST ); |
Manuel Pégourié-Gonnard | 10934de | 2013-12-13 12:54:09 +0100 | [diff] [blame] | 193 | |
| 194 | /* Try the sockaddrs until a connection succeeds */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 195 | ret = MBEDTLS_ERR_NET_UNKNOWN_HOST; |
Manuel Pégourié-Gonnard | 10934de | 2013-12-13 12:54:09 +0100 | [diff] [blame] | 196 | for( cur = addr_list; cur != NULL; cur = cur->ai_next ) |
| 197 | { |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 198 | ctx->fd = (int) socket( cur->ai_family, cur->ai_socktype, |
Paul Bakker | 00f5c52 | 2013-12-31 10:45:16 +0100 | [diff] [blame] | 199 | cur->ai_protocol ); |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 200 | if( ctx->fd < 0 ) |
Manuel Pégourié-Gonnard | 10934de | 2013-12-13 12:54:09 +0100 | [diff] [blame] | 201 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 202 | ret = MBEDTLS_ERR_NET_SOCKET_FAILED; |
Manuel Pégourié-Gonnard | 10934de | 2013-12-13 12:54:09 +0100 | [diff] [blame] | 203 | continue; |
| 204 | } |
| 205 | |
Manuel Pégourié-Gonnard | 9de64f5 | 2015-07-01 15:51:43 +0200 | [diff] [blame] | 206 | if( connect( ctx->fd, cur->ai_addr, MSVC_INT_CAST cur->ai_addrlen ) == 0 ) |
Manuel Pégourié-Gonnard | 10934de | 2013-12-13 12:54:09 +0100 | [diff] [blame] | 207 | { |
| 208 | ret = 0; |
| 209 | break; |
| 210 | } |
| 211 | |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 212 | close( ctx->fd ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 213 | ret = MBEDTLS_ERR_NET_CONNECT_FAILED; |
Manuel Pégourié-Gonnard | 10934de | 2013-12-13 12:54:09 +0100 | [diff] [blame] | 214 | } |
| 215 | |
| 216 | freeaddrinfo( addr_list ); |
| 217 | |
| 218 | return( ret ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | /* |
| 222 | * Create a listening socket on bind_ip:port |
| 223 | */ |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 224 | int mbedtls_net_bind( mbedtls_net_context *ctx, const char *bind_ip, const char *port, int proto ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 225 | { |
Manuel Pégourié-Gonnard | 173402b | 2013-12-17 15:57:05 +0100 | [diff] [blame] | 226 | int n, ret; |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 227 | struct addrinfo hints, *addr_list, *cur; |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 228 | |
Manuel Pégourié-Gonnard | 173402b | 2013-12-17 15:57:05 +0100 | [diff] [blame] | 229 | if( ( ret = net_prepare() ) != 0 ) |
| 230 | return( ret ); |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 231 | |
Manuel Pégourié-Gonnard | db2468d | 2015-06-30 17:19:48 +0200 | [diff] [blame] | 232 | /* Bind to IPv6 and/or IPv4, but only in the desired protocol */ |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 233 | memset( &hints, 0, sizeof( hints ) ); |
| 234 | hints.ai_family = AF_UNSPEC; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 235 | hints.ai_socktype = proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM; |
| 236 | hints.ai_protocol = proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP; |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 237 | if( bind_ip == NULL ) |
| 238 | hints.ai_flags = AI_PASSIVE; |
| 239 | |
Manuel Pégourié-Gonnard | c0d7494 | 2015-06-23 12:30:57 +0200 | [diff] [blame] | 240 | if( getaddrinfo( bind_ip, port, &hints, &addr_list ) != 0 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 241 | return( MBEDTLS_ERR_NET_UNKNOWN_HOST ); |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 242 | |
| 243 | /* Try the sockaddrs until a binding succeeds */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 244 | ret = MBEDTLS_ERR_NET_UNKNOWN_HOST; |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 245 | for( cur = addr_list; cur != NULL; cur = cur->ai_next ) |
| 246 | { |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 247 | ctx->fd = (int) socket( cur->ai_family, cur->ai_socktype, |
Paul Bakker | 00f5c52 | 2013-12-31 10:45:16 +0100 | [diff] [blame] | 248 | cur->ai_protocol ); |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 249 | if( ctx->fd < 0 ) |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 250 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 251 | ret = MBEDTLS_ERR_NET_SOCKET_FAILED; |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 252 | continue; |
| 253 | } |
| 254 | |
Manuel Pégourié-Gonnard | fd6b4cc | 2013-12-17 13:59:01 +0100 | [diff] [blame] | 255 | n = 1; |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 256 | if( setsockopt( ctx->fd, SOL_SOCKET, SO_REUSEADDR, |
Paul Bakker | 874bd64 | 2014-04-17 12:43:05 +0200 | [diff] [blame] | 257 | (const char *) &n, sizeof( n ) ) != 0 ) |
| 258 | { |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 259 | close( ctx->fd ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 260 | ret = MBEDTLS_ERR_NET_SOCKET_FAILED; |
Paul Bakker | 874bd64 | 2014-04-17 12:43:05 +0200 | [diff] [blame] | 261 | continue; |
| 262 | } |
Manuel Pégourié-Gonnard | fd6b4cc | 2013-12-17 13:59:01 +0100 | [diff] [blame] | 263 | |
Manuel Pégourié-Gonnard | 9de64f5 | 2015-07-01 15:51:43 +0200 | [diff] [blame] | 264 | if( bind( ctx->fd, cur->ai_addr, MSVC_INT_CAST cur->ai_addrlen ) != 0 ) |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 265 | { |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 266 | close( ctx->fd ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 267 | ret = MBEDTLS_ERR_NET_BIND_FAILED; |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 268 | continue; |
| 269 | } |
| 270 | |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 271 | /* Listen only makes sense for TCP */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 272 | if( proto == MBEDTLS_NET_PROTO_TCP ) |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 273 | { |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 274 | if( listen( ctx->fd, MBEDTLS_NET_LISTEN_BACKLOG ) != 0 ) |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 275 | { |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 276 | close( ctx->fd ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 277 | ret = MBEDTLS_ERR_NET_LISTEN_FAILED; |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 278 | continue; |
| 279 | } |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 280 | } |
| 281 | |
Brian J Murray | 2adecba | 2016-11-06 04:45:15 -0800 | [diff] [blame] | 282 | /* Bind was successful */ |
Manuel Pégourié-Gonnard | 389ce63 | 2013-12-13 14:00:51 +0100 | [diff] [blame] | 283 | ret = 0; |
| 284 | break; |
| 285 | } |
| 286 | |
| 287 | freeaddrinfo( addr_list ); |
| 288 | |
| 289 | return( ret ); |
| 290 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 291 | } |
| 292 | |
Paul Bakker | fa6a620 | 2013-10-28 18:48:30 +0100 | [diff] [blame] | 293 | #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ |
| 294 | !defined(EFI32) |
Paul Bakker | 8002541 | 2014-01-23 20:59:49 +0100 | [diff] [blame] | 295 | /* |
| 296 | * Check if the requested operation would be blocking on a non-blocking socket |
| 297 | * and thus 'failed' with a negative return value. |
| 298 | */ |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 299 | static int net_would_block( const mbedtls_net_context *ctx ) |
Paul Bakker | 8002541 | 2014-01-23 20:59:49 +0100 | [diff] [blame] | 300 | { |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 301 | ((void) ctx); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 302 | return( WSAGetLastError() == WSAEWOULDBLOCK ); |
Paul Bakker | 8002541 | 2014-01-23 20:59:49 +0100 | [diff] [blame] | 303 | } |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 304 | #else |
Paul Bakker | 8002541 | 2014-01-23 20:59:49 +0100 | [diff] [blame] | 305 | /* |
| 306 | * Check if the requested operation would be blocking on a non-blocking socket |
| 307 | * and thus 'failed' with a negative return value. |
| 308 | * |
| 309 | * Note: on a blocking socket this function always returns 0! |
| 310 | */ |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 311 | static int net_would_block( const mbedtls_net_context *ctx ) |
Paul Bakker | 8002541 | 2014-01-23 20:59:49 +0100 | [diff] [blame] | 312 | { |
Hanno Becker | a6ed9c5 | 2017-05-04 13:39:22 +0100 | [diff] [blame] | 313 | int err = errno; |
Hanno Becker | f4e5b7e | 2018-04-03 16:28:09 +0100 | [diff] [blame] | 314 | |
Paul Bakker | 8002541 | 2014-01-23 20:59:49 +0100 | [diff] [blame] | 315 | /* |
Jaeden Amero | a152e42 | 2019-05-29 09:38:29 +0100 | [diff] [blame] | 316 | * Never return 'WOULD BLOCK' on a blocking socket |
Paul Bakker | 8002541 | 2014-01-23 20:59:49 +0100 | [diff] [blame] | 317 | */ |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 318 | if( ( fcntl( ctx->fd, F_GETFL ) & O_NONBLOCK ) != O_NONBLOCK ) |
Hanno Becker | a6ed9c5 | 2017-05-04 13:39:22 +0100 | [diff] [blame] | 319 | { |
| 320 | errno = err; |
Paul Bakker | 8002541 | 2014-01-23 20:59:49 +0100 | [diff] [blame] | 321 | return( 0 ); |
Hanno Becker | a6ed9c5 | 2017-05-04 13:39:22 +0100 | [diff] [blame] | 322 | } |
Paul Bakker | 8002541 | 2014-01-23 20:59:49 +0100 | [diff] [blame] | 323 | |
Hanno Becker | a6ed9c5 | 2017-05-04 13:39:22 +0100 | [diff] [blame] | 324 | switch( errno = err ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 325 | { |
| 326 | #if defined EAGAIN |
| 327 | case EAGAIN: |
| 328 | #endif |
| 329 | #if defined EWOULDBLOCK && EWOULDBLOCK != EAGAIN |
| 330 | case EWOULDBLOCK: |
| 331 | #endif |
| 332 | return( 1 ); |
| 333 | } |
| 334 | return( 0 ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 335 | } |
Paul Bakker | db20c10 | 2014-06-17 14:34:44 +0200 | [diff] [blame] | 336 | #endif /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */ |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 337 | |
| 338 | /* |
| 339 | * Accept a connection from a remote client |
| 340 | */ |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 341 | int mbedtls_net_accept( mbedtls_net_context *bind_ctx, |
| 342 | mbedtls_net_context *client_ctx, |
Manuel Pégourié-Gonnard | 0b104b0 | 2015-05-14 21:52:40 +0200 | [diff] [blame] | 343 | void *client_ip, size_t buf_size, size_t *ip_len ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 344 | { |
Janos Follath | 865b3eb | 2019-12-16 11:46:15 +0000 | [diff] [blame] | 345 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 346 | int type; |
| 347 | |
Manuel Pégourié-Gonnard | 6e315a9 | 2013-12-13 16:21:25 +0100 | [diff] [blame] | 348 | struct sockaddr_storage client_addr; |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 349 | |
Paul Bakker | 394c56f | 2011-12-20 12:19:03 +0000 | [diff] [blame] | 350 | #if defined(__socklen_t_defined) || defined(_SOCKLEN_T) || \ |
nia | 0b01fd9 | 2020-06-11 12:29:15 +0100 | [diff] [blame] | 351 | defined(_SOCKLEN_T_DECLARED) || defined(__DEFINED_socklen_t) || \ |
okhowang(王沛文) | 76158ce | 2020-09-03 15:36:36 +0800 | [diff] [blame] | 352 | defined(socklen_t) || (defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112L) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 353 | socklen_t n = (socklen_t) sizeof( client_addr ); |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 354 | socklen_t type_len = (socklen_t) sizeof( type ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 355 | #else |
| 356 | int n = (int) sizeof( client_addr ); |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 357 | int type_len = (int) sizeof( type ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 358 | #endif |
| 359 | |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 360 | /* Is this a TCP or UDP socket? */ |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 361 | if( getsockopt( bind_ctx->fd, SOL_SOCKET, SO_TYPE, |
| 362 | (void *) &type, &type_len ) != 0 || |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 363 | ( type != SOCK_STREAM && type != SOCK_DGRAM ) ) |
| 364 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 365 | return( MBEDTLS_ERR_NET_ACCEPT_FAILED ); |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 366 | } |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 367 | |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 368 | if( type == SOCK_STREAM ) |
| 369 | { |
| 370 | /* TCP: actual accept() */ |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 371 | ret = client_ctx->fd = (int) accept( bind_ctx->fd, |
Simon Butcher | 532c94d | 2016-11-10 17:30:18 +0000 | [diff] [blame] | 372 | (struct sockaddr *) &client_addr, &n ); |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 373 | } |
| 374 | else |
| 375 | { |
| 376 | /* UDP: wait for a message, but keep it in the queue */ |
| 377 | char buf[1] = { 0 }; |
| 378 | |
Embedthis Software | a25cab8 | 2015-09-09 08:49:48 -0700 | [diff] [blame] | 379 | ret = (int) recvfrom( bind_ctx->fd, buf, sizeof( buf ), MSG_PEEK, |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 380 | (struct sockaddr *) &client_addr, &n ); |
Manuel Pégourié-Gonnard | 16a17a4 | 2015-06-30 11:20:22 +0200 | [diff] [blame] | 381 | |
| 382 | #if defined(_WIN32) |
| 383 | if( ret == SOCKET_ERROR && |
| 384 | WSAGetLastError() == WSAEMSGSIZE ) |
| 385 | { |
| 386 | /* We know buf is too small, thanks, just peeking here */ |
| 387 | ret = 0; |
| 388 | } |
| 389 | #endif |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 390 | } |
| 391 | |
| 392 | if( ret < 0 ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 393 | { |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 394 | if( net_would_block( bind_ctx ) != 0 ) |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 395 | return( MBEDTLS_ERR_SSL_WANT_READ ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 396 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 397 | return( MBEDTLS_ERR_NET_ACCEPT_FAILED ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 398 | } |
| 399 | |
Manuel Pégourié-Gonnard | abc729e | 2015-07-01 01:28:24 +0200 | [diff] [blame] | 400 | /* UDP: hijack the listening socket to communicate with the client, |
| 401 | * then bind a new socket to accept new connections */ |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 402 | if( type != SOCK_STREAM ) |
| 403 | { |
Manuel Pégourié-Gonnard | abc729e | 2015-07-01 01:28:24 +0200 | [diff] [blame] | 404 | struct sockaddr_storage local_addr; |
| 405 | int one = 1; |
| 406 | |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 407 | if( connect( bind_ctx->fd, (struct sockaddr *) &client_addr, n ) != 0 ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 408 | return( MBEDTLS_ERR_NET_ACCEPT_FAILED ); |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 409 | |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 410 | client_ctx->fd = bind_ctx->fd; |
Manuel Pégourié-Gonnard | abc729e | 2015-07-01 01:28:24 +0200 | [diff] [blame] | 411 | bind_ctx->fd = -1; /* In case we exit early */ |
| 412 | |
| 413 | n = sizeof( struct sockaddr_storage ); |
| 414 | if( getsockname( client_ctx->fd, |
| 415 | (struct sockaddr *) &local_addr, &n ) != 0 || |
| 416 | ( bind_ctx->fd = (int) socket( local_addr.ss_family, |
| 417 | SOCK_DGRAM, IPPROTO_UDP ) ) < 0 || |
| 418 | setsockopt( bind_ctx->fd, SOL_SOCKET, SO_REUSEADDR, |
| 419 | (const char *) &one, sizeof( one ) ) != 0 ) |
| 420 | { |
| 421 | return( MBEDTLS_ERR_NET_SOCKET_FAILED ); |
| 422 | } |
| 423 | |
| 424 | if( bind( bind_ctx->fd, (struct sockaddr *) &local_addr, n ) != 0 ) |
| 425 | { |
| 426 | return( MBEDTLS_ERR_NET_BIND_FAILED ); |
| 427 | } |
Manuel Pégourié-Gonnard | f5a1312 | 2014-03-23 17:38:16 +0100 | [diff] [blame] | 428 | } |
| 429 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 430 | if( client_ip != NULL ) |
Manuel Pégourié-Gonnard | 6e315a9 | 2013-12-13 16:21:25 +0100 | [diff] [blame] | 431 | { |
Manuel Pégourié-Gonnard | 6e315a9 | 2013-12-13 16:21:25 +0100 | [diff] [blame] | 432 | if( client_addr.ss_family == AF_INET ) |
| 433 | { |
| 434 | struct sockaddr_in *addr4 = (struct sockaddr_in *) &client_addr; |
Manuel Pégourié-Gonnard | 0b104b0 | 2015-05-14 21:52:40 +0200 | [diff] [blame] | 435 | *ip_len = sizeof( addr4->sin_addr.s_addr ); |
| 436 | |
| 437 | if( buf_size < *ip_len ) |
| 438 | return( MBEDTLS_ERR_NET_BUFFER_TOO_SMALL ); |
| 439 | |
| 440 | memcpy( client_ip, &addr4->sin_addr.s_addr, *ip_len ); |
Manuel Pégourié-Gonnard | 6e315a9 | 2013-12-13 16:21:25 +0100 | [diff] [blame] | 441 | } |
| 442 | else |
| 443 | { |
| 444 | struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) &client_addr; |
Manuel Pégourié-Gonnard | 0b104b0 | 2015-05-14 21:52:40 +0200 | [diff] [blame] | 445 | *ip_len = sizeof( addr6->sin6_addr.s6_addr ); |
| 446 | |
| 447 | if( buf_size < *ip_len ) |
| 448 | return( MBEDTLS_ERR_NET_BUFFER_TOO_SMALL ); |
| 449 | |
| 450 | memcpy( client_ip, &addr6->sin6_addr.s6_addr, *ip_len); |
Manuel Pégourié-Gonnard | 6e315a9 | 2013-12-13 16:21:25 +0100 | [diff] [blame] | 451 | } |
Manuel Pégourié-Gonnard | 6e315a9 | 2013-12-13 16:21:25 +0100 | [diff] [blame] | 452 | } |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 453 | |
| 454 | return( 0 ); |
| 455 | } |
| 456 | |
| 457 | /* |
| 458 | * Set the socket blocking or non-blocking |
| 459 | */ |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 460 | int mbedtls_net_set_block( mbedtls_net_context *ctx ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 461 | { |
Paul Bakker | fa6a620 | 2013-10-28 18:48:30 +0100 | [diff] [blame] | 462 | #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ |
| 463 | !defined(EFI32) |
Paul Bakker | f4f6968 | 2011-04-24 16:08:12 +0000 | [diff] [blame] | 464 | u_long n = 0; |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 465 | return( ioctlsocket( ctx->fd, FIONBIO, &n ) ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 466 | #else |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 467 | return( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL ) & ~O_NONBLOCK ) ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 468 | #endif |
| 469 | } |
| 470 | |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 471 | int mbedtls_net_set_nonblock( mbedtls_net_context *ctx ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 472 | { |
Paul Bakker | fa6a620 | 2013-10-28 18:48:30 +0100 | [diff] [blame] | 473 | #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ |
| 474 | !defined(EFI32) |
Paul Bakker | f4f6968 | 2011-04-24 16:08:12 +0000 | [diff] [blame] | 475 | u_long n = 1; |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 476 | return( ioctlsocket( ctx->fd, FIONBIO, &n ) ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 477 | #else |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 478 | return( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL ) | O_NONBLOCK ) ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 479 | #endif |
| 480 | } |
| 481 | |
| 482 | /* |
Hanno Becker | e09ca3d | 2017-05-22 15:06:06 +0100 | [diff] [blame] | 483 | * Check if data is available on the socket |
| 484 | */ |
| 485 | |
| 486 | int mbedtls_net_poll( mbedtls_net_context *ctx, uint32_t rw, uint32_t timeout ) |
| 487 | { |
Janos Follath | 865b3eb | 2019-12-16 11:46:15 +0000 | [diff] [blame] | 488 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Hanno Becker | e09ca3d | 2017-05-22 15:06:06 +0100 | [diff] [blame] | 489 | struct timeval tv; |
| 490 | |
| 491 | fd_set read_fds; |
| 492 | fd_set write_fds; |
| 493 | |
| 494 | int fd = ctx->fd; |
| 495 | |
Gilles Peskine | 0f6351f | 2021-06-20 23:08:19 +0200 | [diff] [blame] | 496 | ret = check_fd( fd, 1 ); |
| 497 | if( ret != 0 ) |
| 498 | return( ret ); |
Gilles Peskine | ddf4374 | 2021-02-24 19:49:44 +0100 | [diff] [blame] | 499 | |
Gilles Peskine | ec4733b | 2018-04-05 14:55:47 +0200 | [diff] [blame] | 500 | #if defined(__has_feature) |
| 501 | #if __has_feature(memory_sanitizer) |
| 502 | /* Ensure that memory sanitizers consider read_fds and write_fds as |
| 503 | * initialized even on platforms such as Glibc/x86_64 where FD_ZERO |
| 504 | * is implemented in assembly. */ |
Hanno Becker | f4e5b7e | 2018-04-03 16:28:09 +0100 | [diff] [blame] | 505 | memset( &read_fds, 0, sizeof( read_fds ) ); |
| 506 | memset( &write_fds, 0, sizeof( write_fds ) ); |
Gilles Peskine | ec4733b | 2018-04-05 14:55:47 +0200 | [diff] [blame] | 507 | #endif |
| 508 | #endif |
Hanno Becker | f4e5b7e | 2018-04-03 16:28:09 +0100 | [diff] [blame] | 509 | |
Hanno Becker | e09ca3d | 2017-05-22 15:06:06 +0100 | [diff] [blame] | 510 | FD_ZERO( &read_fds ); |
| 511 | if( rw & MBEDTLS_NET_POLL_READ ) |
| 512 | { |
| 513 | rw &= ~MBEDTLS_NET_POLL_READ; |
| 514 | FD_SET( fd, &read_fds ); |
| 515 | } |
| 516 | |
| 517 | FD_ZERO( &write_fds ); |
| 518 | if( rw & MBEDTLS_NET_POLL_WRITE ) |
| 519 | { |
| 520 | rw &= ~MBEDTLS_NET_POLL_WRITE; |
| 521 | FD_SET( fd, &write_fds ); |
| 522 | } |
| 523 | |
| 524 | if( rw != 0 ) |
| 525 | return( MBEDTLS_ERR_NET_BAD_INPUT_DATA ); |
| 526 | |
| 527 | tv.tv_sec = timeout / 1000; |
| 528 | tv.tv_usec = ( timeout % 1000 ) * 1000; |
| 529 | |
Hanno Becker | 9ac6403 | 2018-03-15 12:19:31 +0000 | [diff] [blame] | 530 | do |
| 531 | { |
| 532 | ret = select( fd + 1, &read_fds, &write_fds, NULL, |
| 533 | timeout == (uint32_t) -1 ? NULL : &tv ); |
Hanno Becker | 80e06d7 | 2018-03-15 14:41:55 +0000 | [diff] [blame] | 534 | } |
Gilles Peskine | ea7dbbe | 2018-03-15 23:25:21 +0100 | [diff] [blame] | 535 | while( IS_EINTR( ret ) ); |
Hanno Becker | e09ca3d | 2017-05-22 15:06:06 +0100 | [diff] [blame] | 536 | |
| 537 | if( ret < 0 ) |
| 538 | return( MBEDTLS_ERR_NET_POLL_FAILED ); |
| 539 | |
| 540 | ret = 0; |
| 541 | if( FD_ISSET( fd, &read_fds ) ) |
| 542 | ret |= MBEDTLS_NET_POLL_READ; |
| 543 | if( FD_ISSET( fd, &write_fds ) ) |
| 544 | ret |= MBEDTLS_NET_POLL_WRITE; |
| 545 | |
| 546 | return( ret ); |
| 547 | } |
| 548 | |
| 549 | /* |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 550 | * Portable usleep helper |
| 551 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 552 | void mbedtls_net_usleep( unsigned long usec ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 553 | { |
Manuel Pégourié-Gonnard | acecb65 | 2015-07-01 11:29:31 +0200 | [diff] [blame] | 554 | #if defined(_WIN32) |
| 555 | Sleep( ( usec + 999 ) / 1000 ); |
| 556 | #else |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 557 | struct timeval tv; |
Manuel Pégourié-Gonnard | e423246 | 2014-11-21 09:52:23 +0100 | [diff] [blame] | 558 | tv.tv_sec = usec / 1000000; |
Manuel Pégourié-Gonnard | acecb65 | 2015-07-01 11:29:31 +0200 | [diff] [blame] | 559 | #if defined(__unix__) || defined(__unix) || \ |
| 560 | ( defined(__APPLE__) && defined(__MACH__) ) |
Manuel Pégourié-Gonnard | e423246 | 2014-11-21 09:52:23 +0100 | [diff] [blame] | 561 | tv.tv_usec = (suseconds_t) usec % 1000000; |
Sander Niemeijer | ef5087d | 2014-08-16 12:45:52 +0200 | [diff] [blame] | 562 | #else |
Manuel Pégourié-Gonnard | e423246 | 2014-11-21 09:52:23 +0100 | [diff] [blame] | 563 | tv.tv_usec = usec % 1000000; |
Sander Niemeijer | ef5087d | 2014-08-16 12:45:52 +0200 | [diff] [blame] | 564 | #endif |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 565 | select( 0, NULL, NULL, NULL, &tv ); |
Manuel Pégourié-Gonnard | acecb65 | 2015-07-01 11:29:31 +0200 | [diff] [blame] | 566 | #endif |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 567 | } |
| 568 | |
| 569 | /* |
| 570 | * Read at most 'len' characters |
| 571 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 572 | int mbedtls_net_recv( void *ctx, unsigned char *buf, size_t len ) |
Paul Bakker | fa6a620 | 2013-10-28 18:48:30 +0100 | [diff] [blame] | 573 | { |
Janos Follath | 865b3eb | 2019-12-16 11:46:15 +0000 | [diff] [blame] | 574 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 575 | int fd = ((mbedtls_net_context *) ctx)->fd; |
Manuel Pégourié-Gonnard | 9bd0afd | 2015-07-01 19:03:27 +0200 | [diff] [blame] | 576 | |
Gilles Peskine | 0f6351f | 2021-06-20 23:08:19 +0200 | [diff] [blame] | 577 | ret = check_fd( fd, 0 ); |
| 578 | if( ret != 0 ) |
| 579 | return( ret ); |
Manuel Pégourié-Gonnard | 9bd0afd | 2015-07-01 19:03:27 +0200 | [diff] [blame] | 580 | |
| 581 | ret = (int) read( fd, buf, len ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 582 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 583 | if( ret < 0 ) |
| 584 | { |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 585 | if( net_would_block( ctx ) != 0 ) |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 586 | return( MBEDTLS_ERR_SSL_WANT_READ ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 587 | |
Paul Bakker | fa6a620 | 2013-10-28 18:48:30 +0100 | [diff] [blame] | 588 | #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ |
| 589 | !defined(EFI32) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 590 | if( WSAGetLastError() == WSAECONNRESET ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 591 | return( MBEDTLS_ERR_NET_CONN_RESET ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 592 | #else |
| 593 | if( errno == EPIPE || errno == ECONNRESET ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 594 | return( MBEDTLS_ERR_NET_CONN_RESET ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 595 | |
| 596 | if( errno == EINTR ) |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 597 | return( MBEDTLS_ERR_SSL_WANT_READ ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 598 | #endif |
| 599 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 600 | return( MBEDTLS_ERR_NET_RECV_FAILED ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 601 | } |
| 602 | |
| 603 | return( ret ); |
| 604 | } |
| 605 | |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 606 | /* |
Manuel Pégourié-Gonnard | c8d8e97 | 2014-10-01 15:01:39 +0200 | [diff] [blame] | 607 | * Read at most 'len' characters, blocking for at most 'timeout' ms |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 608 | */ |
Hanno Becker | e09ca3d | 2017-05-22 15:06:06 +0100 | [diff] [blame] | 609 | int mbedtls_net_recv_timeout( void *ctx, unsigned char *buf, |
| 610 | size_t len, uint32_t timeout ) |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 611 | { |
Janos Follath | 865b3eb | 2019-12-16 11:46:15 +0000 | [diff] [blame] | 612 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 613 | struct timeval tv; |
| 614 | fd_set read_fds; |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 615 | int fd = ((mbedtls_net_context *) ctx)->fd; |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 616 | |
Gilles Peskine | 0f6351f | 2021-06-20 23:08:19 +0200 | [diff] [blame] | 617 | ret = check_fd( fd, 1 ); |
| 618 | if( ret != 0 ) |
| 619 | return( ret ); |
Gilles Peskine | ddf4374 | 2021-02-24 19:49:44 +0100 | [diff] [blame] | 620 | |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 621 | FD_ZERO( &read_fds ); |
| 622 | FD_SET( fd, &read_fds ); |
| 623 | |
Manuel Pégourié-Gonnard | c8d8e97 | 2014-10-01 15:01:39 +0200 | [diff] [blame] | 624 | tv.tv_sec = timeout / 1000; |
| 625 | tv.tv_usec = ( timeout % 1000 ) * 1000; |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 626 | |
Manuel Pégourié-Gonnard | 0761733 | 2015-06-24 23:00:03 +0200 | [diff] [blame] | 627 | ret = select( fd + 1, &read_fds, NULL, NULL, timeout == 0 ? NULL : &tv ); |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 628 | |
| 629 | /* Zero fds ready means we timed out */ |
| 630 | if( ret == 0 ) |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 631 | return( MBEDTLS_ERR_SSL_TIMEOUT ); |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 632 | |
| 633 | if( ret < 0 ) |
| 634 | { |
| 635 | #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ |
| 636 | !defined(EFI32) |
| 637 | if( WSAGetLastError() == WSAEINTR ) |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 638 | return( MBEDTLS_ERR_SSL_WANT_READ ); |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 639 | #else |
| 640 | if( errno == EINTR ) |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 641 | return( MBEDTLS_ERR_SSL_WANT_READ ); |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 642 | #endif |
| 643 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 644 | return( MBEDTLS_ERR_NET_RECV_FAILED ); |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 645 | } |
| 646 | |
| 647 | /* This call will not block */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 648 | return( mbedtls_net_recv( ctx, buf, len ) ); |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 649 | } |
Manuel Pégourié-Gonnard | 9d9b003 | 2014-09-18 11:22:45 +0200 | [diff] [blame] | 650 | |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 651 | /* |
| 652 | * Write at most 'len' characters |
| 653 | */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 654 | int mbedtls_net_send( void *ctx, const unsigned char *buf, size_t len ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 655 | { |
Janos Follath | 865b3eb | 2019-12-16 11:46:15 +0000 | [diff] [blame] | 656 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 657 | int fd = ((mbedtls_net_context *) ctx)->fd; |
Manuel Pégourié-Gonnard | 9bd0afd | 2015-07-01 19:03:27 +0200 | [diff] [blame] | 658 | |
Gilles Peskine | 0f6351f | 2021-06-20 23:08:19 +0200 | [diff] [blame] | 659 | ret = check_fd( fd, 0 ); |
| 660 | if( ret != 0 ) |
| 661 | return( ret ); |
Manuel Pégourié-Gonnard | 9bd0afd | 2015-07-01 19:03:27 +0200 | [diff] [blame] | 662 | |
| 663 | ret = (int) write( fd, buf, len ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 664 | |
| 665 | if( ret < 0 ) |
| 666 | { |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 667 | if( net_would_block( ctx ) != 0 ) |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 668 | return( MBEDTLS_ERR_SSL_WANT_WRITE ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 669 | |
Paul Bakker | fa6a620 | 2013-10-28 18:48:30 +0100 | [diff] [blame] | 670 | #if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \ |
| 671 | !defined(EFI32) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 672 | if( WSAGetLastError() == WSAECONNRESET ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 673 | return( MBEDTLS_ERR_NET_CONN_RESET ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 674 | #else |
| 675 | if( errno == EPIPE || errno == ECONNRESET ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 676 | return( MBEDTLS_ERR_NET_CONN_RESET ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 677 | |
| 678 | if( errno == EINTR ) |
Manuel Pégourié-Gonnard | 8836994 | 2015-05-06 16:19:31 +0100 | [diff] [blame] | 679 | return( MBEDTLS_ERR_SSL_WANT_WRITE ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 680 | #endif |
| 681 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 682 | return( MBEDTLS_ERR_NET_SEND_FAILED ); |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 683 | } |
| 684 | |
| 685 | return( ret ); |
| 686 | } |
| 687 | |
| 688 | /* |
Robert Larsen | df8e511 | 2019-08-23 10:55:47 +0200 | [diff] [blame] | 689 | * Close the connection |
| 690 | */ |
| 691 | void mbedtls_net_close( mbedtls_net_context *ctx ) |
| 692 | { |
| 693 | if( ctx->fd == -1 ) |
| 694 | return; |
| 695 | |
| 696 | close( ctx->fd ); |
| 697 | |
| 698 | ctx->fd = -1; |
| 699 | } |
| 700 | |
| 701 | /* |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 702 | * Gracefully close the connection |
| 703 | */ |
Manuel Pégourié-Gonnard | 3d7d00a | 2015-06-30 15:55:03 +0200 | [diff] [blame] | 704 | void mbedtls_net_free( mbedtls_net_context *ctx ) |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 705 | { |
Manuel Pégourié-Gonnard | 9189585 | 2015-06-30 13:34:45 +0200 | [diff] [blame] | 706 | if( ctx->fd == -1 ) |
| 707 | return; |
| 708 | |
| 709 | shutdown( ctx->fd, 2 ); |
| 710 | close( ctx->fd ); |
| 711 | |
| 712 | ctx->fd = -1; |
Paul Bakker | 5121ce5 | 2009-01-03 21:22:43 +0000 | [diff] [blame] | 713 | } |
| 714 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 715 | #endif /* MBEDTLS_NET_C */ |