net_sockets.c 15.1 KB
Newer Older
1
/*
2
 *  TCP/IP or UDP/IP networking functions
3
 *
4
 *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
5
 *  SPDX-License-Identifier: Apache-2.0
6
 *
7 8 9
 *  Licensed under the Apache License, Version 2.0 (the "License"); you may
 *  not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
10
 *
11
 *  http://www.apache.org/licenses/LICENSE-2.0
12
 *
13 14 15 16 17
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
18
 *
19
 *  This file is part of mbed TLS (https://tls.mbed.org)
20 21
 */

22
#if !defined(MBEDTLS_CONFIG_FILE)
23
#include "mbedtls/config.h"
24
#else
25
#include MBEDTLS_CONFIG_FILE
26
#endif
27

28
#if defined(MBEDTLS_NET_C)
29

30 31 32 33 34
#if !defined(unix) && !defined(__unix__) && !defined(__unix) && \
    !defined(__APPLE__) && !defined(_WIN32)
#error "This module only works on Unix and Windows, see MBEDTLS_NET_C in config.h"
#endif

35 36 37 38 39 40
#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#include <stdlib.h>
#endif

41
#include "mbedtls/net_sockets.h"
42

43 44
#include <string.h>

45 46
#if (defined(_WIN32) || defined(_WIN32_WCE)) && !defined(EFIX64) && \
    !defined(EFI32)
47

48 49 50 51
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#endif
/* Enables getaddrinfo() & Co */
52
#define _WIN32_WINNT 0x0501
53 54
#include <ws2tcpip.h>

55 56 57
#include <winsock2.h>
#include <windows.h>

58
#if defined(_MSC_VER)
59 60 61 62 63
#if defined(_WIN32_WCE)
#pragma comment( lib, "ws2.lib" )
#else
#pragma comment( lib, "ws2_32.lib" )
#endif
64
#endif /* _MSC_VER */
65

66 67
#define read(fd,buf,len)        recv(fd,(char*)buf,(int) len,0)
#define write(fd,buf,len)       send(fd,(char*)buf,(int) len,0)
68 69 70 71
#define close(fd)               closesocket(fd)

static int wsa_init_done = 0;

72
#else /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
73 74 75 76 77 78 79 80 81 82 83

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <netdb.h>
#include <errno.h>
84

85
#endif /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
86

87 88 89 90 91 92 93 94
/* Some MS functions want int and MSVC warns if we pass size_t,
 * but the standard fucntions use socklen_t, so cast only for MSVC */
#if defined(_MSC_VER)
#define MSVC_INT_CAST   (int)
#else
#define MSVC_INT_CAST
#endif

95
#include <stdio.h>
96

97 98
#include <time.h>

99
#include <stdint.h>
100

101
/*
102
 * Prepare for using the sockets interface
103
 */
104
static int net_prepare( void )
105
{
106 107
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
    !defined(EFI32)
108 109 110 111
    WSADATA wsaData;

    if( wsa_init_done == 0 )
    {
112
        if( WSAStartup( MAKEWORD(2,0), &wsaData ) != 0 )
113
            return( MBEDTLS_ERR_NET_SOCKET_FAILED );
114 115 116 117

        wsa_init_done = 1;
    }
#else
118
#if !defined(EFIX64) && !defined(EFI32)
119
    signal( SIGPIPE, SIG_IGN );
120
#endif
121
#endif
122
    return( 0 );
123 124
}

125 126 127 128 129 130 131 132
/*
 * Initialize a context
 */
void mbedtls_net_init( mbedtls_net_context *ctx )
{
    ctx->fd = -1;
}

133
/*
134
 * Initiate a TCP connection with host:port and the given protocol
135
 */
136
int mbedtls_net_connect( mbedtls_net_context *ctx, const char *host, const char *port, int proto )
137
{
138
    int ret;
139 140
    struct addrinfo hints, *addr_list, *cur;

141 142
    if( ( ret = net_prepare() ) != 0 )
        return( ret );
143

144
    /* Do name resolution with both IPv6 and IPv4 */
145 146
    memset( &hints, 0, sizeof( hints ) );
    hints.ai_family = AF_UNSPEC;
147 148
    hints.ai_socktype = proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;
    hints.ai_protocol = proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;
149

150
    if( getaddrinfo( host, port, &hints, &addr_list ) != 0 )
151
        return( MBEDTLS_ERR_NET_UNKNOWN_HOST );
152 153

    /* Try the sockaddrs until a connection succeeds */
154
    ret = MBEDTLS_ERR_NET_UNKNOWN_HOST;
155 156
    for( cur = addr_list; cur != NULL; cur = cur->ai_next )
    {
157
        ctx->fd = (int) socket( cur->ai_family, cur->ai_socktype,
158
                            cur->ai_protocol );
159
        if( ctx->fd < 0 )
160
        {
161
            ret = MBEDTLS_ERR_NET_SOCKET_FAILED;
162 163 164
            continue;
        }

165
        if( connect( ctx->fd, cur->ai_addr, MSVC_INT_CAST cur->ai_addrlen ) == 0 )
166 167 168 169 170
        {
            ret = 0;
            break;
        }

171
        close( ctx->fd );
172
        ret = MBEDTLS_ERR_NET_CONNECT_FAILED;
173 174 175 176 177
    }

    freeaddrinfo( addr_list );

    return( ret );
178 179 180 181 182
}

/*
 * Create a listening socket on bind_ip:port
 */
183
int mbedtls_net_bind( mbedtls_net_context *ctx, const char *bind_ip, const char *port, int proto )
184
{
185
    int n, ret;
186 187
    struct addrinfo hints, *addr_list, *cur;

188 189
    if( ( ret = net_prepare() ) != 0 )
        return( ret );
190

191
    /* Bind to IPv6 and/or IPv4, but only in the desired protocol */
192 193
    memset( &hints, 0, sizeof( hints ) );
    hints.ai_family = AF_UNSPEC;
194 195
    hints.ai_socktype = proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;
    hints.ai_protocol = proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;
196 197 198
    if( bind_ip == NULL )
        hints.ai_flags = AI_PASSIVE;

199
    if( getaddrinfo( bind_ip, port, &hints, &addr_list ) != 0 )
200
        return( MBEDTLS_ERR_NET_UNKNOWN_HOST );
201 202

    /* Try the sockaddrs until a binding succeeds */
203
    ret = MBEDTLS_ERR_NET_UNKNOWN_HOST;
204 205
    for( cur = addr_list; cur != NULL; cur = cur->ai_next )
    {
206
        ctx->fd = (int) socket( cur->ai_family, cur->ai_socktype,
207
                            cur->ai_protocol );
208
        if( ctx->fd < 0 )
209
        {
210
            ret = MBEDTLS_ERR_NET_SOCKET_FAILED;
211 212 213
            continue;
        }

214
        n = 1;
215
        if( setsockopt( ctx->fd, SOL_SOCKET, SO_REUSEADDR,
216 217
                        (const char *) &n, sizeof( n ) ) != 0 )
        {
218
            close( ctx->fd );
219
            ret = MBEDTLS_ERR_NET_SOCKET_FAILED;
220 221
            continue;
        }
222

223
        if( bind( ctx->fd, cur->ai_addr, MSVC_INT_CAST cur->ai_addrlen ) != 0 )
224
        {
225
            close( ctx->fd );
226
            ret = MBEDTLS_ERR_NET_BIND_FAILED;
227 228 229
            continue;
        }

230
        /* Listen only makes sense for TCP */
231
        if( proto == MBEDTLS_NET_PROTO_TCP )
232
        {
233
            if( listen( ctx->fd, MBEDTLS_NET_LISTEN_BACKLOG ) != 0 )
234
            {
235
                close( ctx->fd );
236
                ret = MBEDTLS_ERR_NET_LISTEN_FAILED;
237 238
                continue;
            }
239 240 241 242 243 244 245 246 247 248 249
        }

        /* I we ever get there, it's a success */
        ret = 0;
        break;
    }

    freeaddrinfo( addr_list );

    return( ret );

250 251
}

252 253
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
    !defined(EFI32)
254
/*
255 256
 * Check if the requested operation would be blocking on a non-blocking socket
 * and thus 'failed' with a negative return value.
257
 */
258
static int net_would_block( const mbedtls_net_context *ctx )
259
{
260
    ((void) ctx);
261
    return( WSAGetLastError() == WSAEWOULDBLOCK );
262
}
263
#else
264 265 266 267 268 269
/*
 * Check if the requested operation would be blocking on a non-blocking socket
 * and thus 'failed' with a negative return value.
 *
 * Note: on a blocking socket this function always returns 0!
 */
270
static int net_would_block( const mbedtls_net_context *ctx )
271 272 273 274
{
    /*
     * Never return 'WOULD BLOCK' on a non-blocking socket
     */
275
    if( ( fcntl( ctx->fd, F_GETFL ) & O_NONBLOCK ) != O_NONBLOCK )
276 277
        return( 0 );

278 279 280 281 282 283 284 285 286 287 288 289
    switch( errno )
    {
#if defined EAGAIN
        case EAGAIN:
#endif
#if defined EWOULDBLOCK && EWOULDBLOCK != EAGAIN
        case EWOULDBLOCK:
#endif
            return( 1 );
    }
    return( 0 );
}
290
#endif /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
291 292 293 294

/*
 * Accept a connection from a remote client
 */
295 296
int mbedtls_net_accept( mbedtls_net_context *bind_ctx,
                        mbedtls_net_context *client_ctx,
297
                        void *client_ip, size_t buf_size, size_t *ip_len )
298
{
299 300 301
    int ret;
    int type;

302
    struct sockaddr_storage client_addr;
303

304
#if defined(__socklen_t_defined) || defined(_SOCKLEN_T) ||  \
305
    defined(_SOCKLEN_T_DECLARED) || defined(__DEFINED_socklen_t)
306
    socklen_t n = (socklen_t) sizeof( client_addr );
307
    socklen_t type_len = (socklen_t) sizeof( type );
308 309
#else
    int n = (int) sizeof( client_addr );
310
    int type_len = (int) sizeof( type );
311 312
#endif

313
    /* Is this a TCP or UDP socket? */
314 315
    if( getsockopt( bind_ctx->fd, SOL_SOCKET, SO_TYPE,
                    (void *) &type, &type_len ) != 0 ||
316 317
        ( type != SOCK_STREAM && type != SOCK_DGRAM ) )
    {
318
        return( MBEDTLS_ERR_NET_ACCEPT_FAILED );
319
    }
320

321 322 323
    if( type == SOCK_STREAM )
    {
        /* TCP: actual accept() */
324
        ret = client_ctx->fd = (int) accept( bind_ctx->fd,
325 326 327 328 329 330 331
                                         (struct sockaddr *) &client_addr, &n );
    }
    else
    {
        /* UDP: wait for a message, but keep it in the queue */
        char buf[1] = { 0 };

332
        ret = (int) recvfrom( bind_ctx->fd, buf, sizeof( buf ), MSG_PEEK,
333
                        (struct sockaddr *) &client_addr, &n );
334 335 336 337 338 339 340 341 342

#if defined(_WIN32)
        if( ret == SOCKET_ERROR &&
            WSAGetLastError() == WSAEMSGSIZE )
        {
            /* We know buf is too small, thanks, just peeking here */
            ret = 0;
        }
#endif
343 344 345
    }

    if( ret < 0 )
346
    {
347
        if( net_would_block( bind_ctx ) != 0 )
348
            return( MBEDTLS_ERR_SSL_WANT_READ );
349

350
        return( MBEDTLS_ERR_NET_ACCEPT_FAILED );
351 352
    }

353 354
    /* UDP: hijack the listening socket to communicate with the client,
     * then bind a new socket to accept new connections */
355 356
    if( type != SOCK_STREAM )
    {
357 358 359
        struct sockaddr_storage local_addr;
        int one = 1;

360
        if( connect( bind_ctx->fd, (struct sockaddr *) &client_addr, n ) != 0 )
361
            return( MBEDTLS_ERR_NET_ACCEPT_FAILED );
362

363
        client_ctx->fd = bind_ctx->fd;
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
        bind_ctx->fd   = -1; /* In case we exit early */

        n = sizeof( struct sockaddr_storage );
        if( getsockname( client_ctx->fd,
                         (struct sockaddr *) &local_addr, &n ) != 0 ||
            ( bind_ctx->fd = (int) socket( local_addr.ss_family,
                                           SOCK_DGRAM, IPPROTO_UDP ) ) < 0 ||
            setsockopt( bind_ctx->fd, SOL_SOCKET, SO_REUSEADDR,
                        (const char *) &one, sizeof( one ) ) != 0 )
        {
            return( MBEDTLS_ERR_NET_SOCKET_FAILED );
        }

        if( bind( bind_ctx->fd, (struct sockaddr *) &local_addr, n ) != 0 )
        {
            return( MBEDTLS_ERR_NET_BIND_FAILED );
        }
381 382
    }

383
    if( client_ip != NULL )
384 385 386 387
    {
        if( client_addr.ss_family == AF_INET )
        {
            struct sockaddr_in *addr4 = (struct sockaddr_in *) &client_addr;
388 389 390 391 392 393
            *ip_len = sizeof( addr4->sin_addr.s_addr );

            if( buf_size < *ip_len )
                return( MBEDTLS_ERR_NET_BUFFER_TOO_SMALL );

            memcpy( client_ip, &addr4->sin_addr.s_addr, *ip_len );
394 395 396 397
        }
        else
        {
            struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) &client_addr;
398 399 400 401 402 403
            *ip_len = sizeof( addr6->sin6_addr.s6_addr );

            if( buf_size < *ip_len )
                return( MBEDTLS_ERR_NET_BUFFER_TOO_SMALL );

            memcpy( client_ip, &addr6->sin6_addr.s6_addr, *ip_len);
404 405
        }
    }
406 407 408 409 410 411 412

    return( 0 );
}

/*
 * Set the socket blocking or non-blocking
 */
413
int mbedtls_net_set_block( mbedtls_net_context *ctx )
414
{
415 416
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
    !defined(EFI32)
417
    u_long n = 0;
418
    return( ioctlsocket( ctx->fd, FIONBIO, &n ) );
419
#else
420
    return( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL ) & ~O_NONBLOCK ) );
421 422 423
#endif
}

424
int mbedtls_net_set_nonblock( mbedtls_net_context *ctx )
425
{
426 427
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
    !defined(EFI32)
428
    u_long n = 1;
429
    return( ioctlsocket( ctx->fd, FIONBIO, &n ) );
430
#else
431
    return( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL ) | O_NONBLOCK ) );
432 433 434 435 436 437
#endif
}

/*
 * Portable usleep helper
 */
438
void mbedtls_net_usleep( unsigned long usec )
439
{
440 441 442
#if defined(_WIN32)
    Sleep( ( usec + 999 ) / 1000 );
#else
443
    struct timeval tv;
444
    tv.tv_sec  = usec / 1000000;
445 446
#if defined(__unix__) || defined(__unix) || \
    ( defined(__APPLE__) && defined(__MACH__) )
447
    tv.tv_usec = (suseconds_t) usec % 1000000;
448
#else
449
    tv.tv_usec = usec % 1000000;
450
#endif
451
    select( 0, NULL, NULL, NULL, &tv );
452
#endif
453 454 455 456 457
}

/*
 * Read at most 'len' characters
 */
458
int mbedtls_net_recv( void *ctx, unsigned char *buf, size_t len )
459
{
460
    int ret;
461
    int fd = ((mbedtls_net_context *) ctx)->fd;
462 463 464 465 466

    if( fd < 0 )
        return( MBEDTLS_ERR_NET_INVALID_CONTEXT );

    ret = (int) read( fd, buf, len );
467 468 469

    if( ret < 0 )
    {
470
        if( net_would_block( ctx ) != 0 )
471
            return( MBEDTLS_ERR_SSL_WANT_READ );
472

473 474
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
    !defined(EFI32)
475
        if( WSAGetLastError() == WSAECONNRESET )
476
            return( MBEDTLS_ERR_NET_CONN_RESET );
477 478
#else
        if( errno == EPIPE || errno == ECONNRESET )
479
            return( MBEDTLS_ERR_NET_CONN_RESET );
480 481

        if( errno == EINTR )
482
            return( MBEDTLS_ERR_SSL_WANT_READ );
483 484
#endif

485
        return( MBEDTLS_ERR_NET_RECV_FAILED );
486 487 488 489 490
    }

    return( ret );
}

491
/*
492
 * Read at most 'len' characters, blocking for at most 'timeout' ms
493
 */
494
int mbedtls_net_recv_timeout( void *ctx, unsigned char *buf, size_t len,
495
                      uint32_t timeout )
496 497 498 499
{
    int ret;
    struct timeval tv;
    fd_set read_fds;
500
    int fd = ((mbedtls_net_context *) ctx)->fd;
501

502 503 504
    if( fd < 0 )
        return( MBEDTLS_ERR_NET_INVALID_CONTEXT );

505 506 507
    FD_ZERO( &read_fds );
    FD_SET( fd, &read_fds );

508 509
    tv.tv_sec  = timeout / 1000;
    tv.tv_usec = ( timeout % 1000 ) * 1000;
510

511
    ret = select( fd + 1, &read_fds, NULL, NULL, timeout == 0 ? NULL : &tv );
512 513 514

    /* Zero fds ready means we timed out */
    if( ret == 0 )
515
        return( MBEDTLS_ERR_SSL_TIMEOUT );
516 517 518 519 520 521

    if( ret < 0 )
    {
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
    !defined(EFI32)
        if( WSAGetLastError() == WSAEINTR )
522
            return( MBEDTLS_ERR_SSL_WANT_READ );
523 524
#else
        if( errno == EINTR )
525
            return( MBEDTLS_ERR_SSL_WANT_READ );
526 527
#endif

528
        return( MBEDTLS_ERR_NET_RECV_FAILED );
529 530 531
    }

    /* This call will not block */
532
    return( mbedtls_net_recv( ctx, buf, len ) );
533 534
}

535 536 537
/*
 * Write at most 'len' characters
 */
538
int mbedtls_net_send( void *ctx, const unsigned char *buf, size_t len )
539
{
540
    int ret;
541
    int fd = ((mbedtls_net_context *) ctx)->fd;
542 543 544 545 546

    if( fd < 0 )
        return( MBEDTLS_ERR_NET_INVALID_CONTEXT );

    ret = (int) write( fd, buf, len );
547 548 549

    if( ret < 0 )
    {
550
        if( net_would_block( ctx ) != 0 )
551
            return( MBEDTLS_ERR_SSL_WANT_WRITE );
552

553 554
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
    !defined(EFI32)
555
        if( WSAGetLastError() == WSAECONNRESET )
556
            return( MBEDTLS_ERR_NET_CONN_RESET );
557 558
#else
        if( errno == EPIPE || errno == ECONNRESET )
559
            return( MBEDTLS_ERR_NET_CONN_RESET );
560 561

        if( errno == EINTR )
562
            return( MBEDTLS_ERR_SSL_WANT_WRITE );
563 564
#endif

565
        return( MBEDTLS_ERR_NET_SEND_FAILED );
566 567 568 569 570 571 572 573
    }

    return( ret );
}

/*
 * Gracefully close the connection
 */
574
void mbedtls_net_free( mbedtls_net_context *ctx )
575
{
576 577 578 579 580 581 582
    if( ctx->fd == -1 )
        return;

    shutdown( ctx->fd, 2 );
    close( ctx->fd );

    ctx->fd = -1;
583 584
}

585
#endif /* MBEDTLS_NET_C */