net_sockets.h
mbedtls/config.h
mbedtls/ssl.h
stddef.h
stdint.h
net.h
mbedtls/asn1.h
mbedtls/bignum.h
mbedtls/check_config.h
mbedtls/cipher.h
mbedtls/config.h
mbedtls/dhm.h
mbedtls/ecdh.h
mbedtls/ecdsa.h
mbedtls/ecp.h
mbedtls/md.h
net_sockets.h
mbedtls/pk.h
mbedtls/platform_time.h
mbedtls/platform_util.h
mbedtls/rsa.h
mbedtls/ssl.h
mbedtls/ssl_ciphersuites.h
mbedtls/threading.h
mbedtls/x509.h
mbedtls/x509_crl.h
mbedtls/x509_crt.h
limits.h
pthread.h
stddef.h
stdint.h
stdio.h
stdlib.h
time.h
net.h
net_sockets.h
mbedtls_net_context
MBEDTLS_ERR_NET_SOCKET_FAILED
-0x0042

Failed to open a socket.

MBEDTLS_ERR_NET_CONNECT_FAILED
-0x0044

The connection to the given server / port failed.

MBEDTLS_ERR_NET_BIND_FAILED
-0x0046

Binding of the socket failed.

MBEDTLS_ERR_NET_LISTEN_FAILED
-0x0048

Could not listen on the socket.

MBEDTLS_ERR_NET_ACCEPT_FAILED
-0x004A

Could not accept the incoming connection.

MBEDTLS_ERR_NET_RECV_FAILED
-0x004C

Reading information from the socket failed.

MBEDTLS_ERR_NET_SEND_FAILED
-0x004E

Sending information through the socket failed.

MBEDTLS_ERR_NET_CONN_RESET
-0x0050

Connection was reset by peer.

MBEDTLS_ERR_NET_UNKNOWN_HOST
-0x0052

Failed to get an IP address for the given hostname.

MBEDTLS_ERR_NET_BUFFER_TOO_SMALL
-0x0043

Buffer is too small to hold the data.

MBEDTLS_ERR_NET_INVALID_CONTEXT
-0x0045

The context is invalid, eg because it was free()ed.

MBEDTLS_ERR_NET_POLL_FAILED
-0x0047

Polling the net context failed.

MBEDTLS_ERR_NET_BAD_INPUT_DATA
-0x0049

Input invalid.

MBEDTLS_NET_LISTEN_BACKLOG
10

The backlog that listen() should use.

MBEDTLS_NET_PROTO_TCP
0

The TCP transport protocol

MBEDTLS_NET_PROTO_UDP
1

The UDP transport protocol

MBEDTLS_NET_POLL_READ
1

Used in `mbedtls_net_poll` to check for pending data

MBEDTLS_NET_POLL_WRITE
2

Used in `mbedtls_net_poll` to check if write possible

struct mbedtls_net_context typedef struct mbedtls_net_context mbedtls_net_context mbedtls_net_context

Wrapper type for sockets.

Currently backed by just a file descriptor, but might be more in the future (eg two file descriptors for combined IPv4 + IPv6 support, or additional structures for hand-made UDP demultiplexing).

void void mbedtls_net_init (mbedtls_net_context *ctx) mbedtls_net_init mbedtls_net_context * ctx

Initialize a context Just makes the context ready to be used or freed safely.

ctx

Context to initialize

int int mbedtls_net_connect (mbedtls_net_context *ctx, const char *host, const char *port, int proto) mbedtls_net_connect mbedtls_net_context * ctx const char * host const char * port int proto

Initiate a connection with host:port in the given protocol.

ctx

Socket to use

host

Host to connect to

port

Port to connect to

proto

Protocol: MBEDTLS_NET_PROTO_TCP or MBEDTLS_NET_PROTO_UDP

0 if successful, or one of: MBEDTLS_ERR_NET_SOCKET_FAILED, MBEDTLS_ERR_NET_UNKNOWN_HOST, MBEDTLS_ERR_NET_CONNECT_FAILED

Sets the socket in connected mode even with UDP.

int int mbedtls_net_bind (mbedtls_net_context *ctx, const char *bind_ip, const char *port, int proto) mbedtls_net_bind mbedtls_net_context * ctx const char * bind_ip const char * port int proto

Create a receiving socket on bind_ip:port in the chosen protocol. If bind_ip == NULL, all interfaces are bound.

ctx

Socket to use

bind_ip

IP to bind to, can be NULL

port

Port number to use

proto

Protocol: MBEDTLS_NET_PROTO_TCP or MBEDTLS_NET_PROTO_UDP

0 if successful, or one of: MBEDTLS_ERR_NET_SOCKET_FAILED, MBEDTLS_ERR_NET_UNKNOWN_HOST, MBEDTLS_ERR_NET_BIND_FAILED, MBEDTLS_ERR_NET_LISTEN_FAILED

Regardless of the protocol, opens the sockets and binds it. In addition, make the socket listening if protocol is TCP.

int int mbedtls_net_accept (mbedtls_net_context *bind_ctx, mbedtls_net_context *client_ctx, void *client_ip, size_t buf_size, size_t *cip_len) mbedtls_net_accept mbedtls_net_context * bind_ctx mbedtls_net_context * client_ctx void * client_ip size_t buf_size size_t * cip_len

Accept a connection from a remote client.

bind_ctx

Relevant socket

client_ctx

Will contain the connected client socket

client_ip

Will contain the client IP address, can be NULL

buf_size

Size of the client_ip buffer

cip_len

Will receive the size of the client IP written, can be NULL if client_ip is null

0 if successful, or MBEDTLS_ERR_NET_SOCKET_FAILED, MBEDTLS_ERR_NET_BIND_FAILED, MBEDTLS_ERR_NET_ACCEPT_FAILED, or MBEDTLS_ERR_NET_BUFFER_TOO_SMALL if buf_size is too small, MBEDTLS_ERR_SSL_WANT_READ if bind_fd was set to non-blocking and accept() would block.

int int mbedtls_net_poll (mbedtls_net_context *ctx, uint32_t rw, uint32_t timeout) mbedtls_net_poll mbedtls_net_context * ctx uint32_t rw uint32_t timeout

Check and wait for the context to be ready for read/write.

The current implementation of this function uses select() and returns an error if the file descriptor is `FD_SETSIZE` or greater.

ctx

Socket to check

rw

Bitflag composed of MBEDTLS_NET_POLL_READ and MBEDTLS_NET_POLL_WRITE specifying the events to wait for:

- If MBEDTLS_NET_POLL_READ is set, the function will return as soon as the net context is available for reading.

- If MBEDTLS_NET_POLL_WRITE is set, the function will return as soon as the net context is available for writing.

timeout

Maximal amount of time to wait before returning, in milliseconds. If `timeout` is zero, the function returns immediately. If `timeout` is -1u, the function blocks potentially indefinitely.

Bitmask composed of MBEDTLS_NET_POLL_READ/WRITE on success or timeout, or a negative return code otherwise.

int int mbedtls_net_set_block (mbedtls_net_context *ctx) mbedtls_net_set_block mbedtls_net_context * ctx

Set the socket blocking.

ctx

Socket to set

0 if successful, or a non-zero error code

int int mbedtls_net_set_nonblock (mbedtls_net_context *ctx) mbedtls_net_set_nonblock mbedtls_net_context * ctx

Set the socket non-blocking.

ctx

Socket to set

0 if successful, or a non-zero error code

void void mbedtls_net_usleep (unsigned long usec) mbedtls_net_usleep unsigned long usec

Portable usleep helper.

usec

Amount of microseconds to sleep

Real amount of time slept will not be less than select()'s timeout granularity (typically, 10ms).

int int mbedtls_net_recv (void *ctx, unsigned char *buf, size_t len) mbedtls_net_recv void * ctx unsigned char * buf size_t len

Read at most 'len' characters. If no error occurs, the actual amount read is returned.

ctx

Socket

buf

The buffer to write to

len

Maximum length of the buffer

the number of bytes received, or a non-zero error code; with a non-blocking socket, MBEDTLS_ERR_SSL_WANT_READ indicates read() would block.

int int mbedtls_net_send (void *ctx, const unsigned char *buf, size_t len) mbedtls_net_send void * ctx const unsigned char * buf size_t len

Write at most 'len' characters. If no error occurs, the actual amount read is returned.

ctx

Socket

buf

The buffer to read from

len

The length of the buffer

the number of bytes sent, or a non-zero error code; with a non-blocking socket, MBEDTLS_ERR_SSL_WANT_WRITE indicates write() would block.

int int mbedtls_net_recv_timeout (void *ctx, unsigned char *buf, size_t len, uint32_t timeout) mbedtls_net_recv_timeout void * ctx unsigned char * buf size_t len uint32_t timeout

Read at most 'len' characters, blocking for at most 'timeout' seconds. If no error occurs, the actual amount read is returned.

The current implementation of this function uses select() and returns an error if the file descriptor is `FD_SETSIZE` or greater.

ctx

Socket

buf

The buffer to write to

len

Maximum length of the buffer

timeout

Maximum number of milliseconds to wait for data 0 means no timeout (wait forever)

The number of bytes received if successful. MBEDTLS_ERR_SSL_TIMEOUT if the operation timed out. MBEDTLS_ERR_SSL_WANT_READ if interrupted by a signal. Another negative error code (MBEDTLS_ERR_NET_xxx) for other failures.

This function will block (until data becomes available or timeout is reached) even if the socket is set to non-blocking. Handling timeouts with non-blocking reads requires a different strategy.

void void mbedtls_net_close (mbedtls_net_context *ctx) mbedtls_net_close mbedtls_net_context * ctx

Closes down the connection and free associated data.

ctx

The context to close

This function frees and clears data associated with the context but does not free the memory pointed to by `ctx`. This memory is the responsibility of the caller.

void void mbedtls_net_free (mbedtls_net_context *ctx) mbedtls_net_free mbedtls_net_context * ctx

Gracefully shutdown the connection and free associated data.

ctx

The context to free

This function frees and clears data associated with the context but does not free the memory pointed to by `ctx`. This memory is the responsibility of the caller.

Network sockets abstraction layer to integrate Mbed TLS into a BSD-style sockets API.

The network sockets module provides an example integration of the Mbed TLS library into a BSD sockets implementation. The module is intended to be an example of how Mbed TLS can be integrated into a networking stack, as well as to be Mbed TLS's network integration for its supported platforms.

The module is intended only to be used with the Mbed TLS library and is not intended to be used by third party application software directly.

The supported platforms are as follows:

- Microsoft Windows and Windows CE

- POSIX/Unix platforms including Linux, OS X

    /*
    *CopyrightTheMbedTLSContributors
    *SPDX-License-Identifier:Apache-2.0ORGPL-2.0-or-later
    */
    #ifndefMBEDTLS_NET_SOCKETS_H
    #defineMBEDTLS_NET_SOCKETS_H

    #if!defined(MBEDTLS_CONFIG_FILE)
    #include"mbedtls/config.h"
    #else
    #includeMBEDTLS_CONFIG_FILE
    #endif

    #include"mbedtls/ssl.h"

    #include<stddef.h>
    #include<stdint.h>

    #defineMBEDTLS_ERR_NET_SOCKET_FAILED-0x0042
    #defineMBEDTLS_ERR_NET_CONNECT_FAILED-0x0044
    #defineMBEDTLS_ERR_NET_BIND_FAILED-0x0046
    #defineMBEDTLS_ERR_NET_LISTEN_FAILED-0x0048
    #defineMBEDTLS_ERR_NET_ACCEPT_FAILED-0x004A
    #defineMBEDTLS_ERR_NET_RECV_FAILED-0x004C
    #defineMBEDTLS_ERR_NET_SEND_FAILED-0x004E
    #defineMBEDTLS_ERR_NET_CONN_RESET-0x0050
    #defineMBEDTLS_ERR_NET_UNKNOWN_HOST-0x0052
    #defineMBEDTLS_ERR_NET_BUFFER_TOO_SMALL-0x0043
    #defineMBEDTLS_ERR_NET_INVALID_CONTEXT-0x0045
    #defineMBEDTLS_ERR_NET_POLL_FAILED-0x0047
    #defineMBEDTLS_ERR_NET_BAD_INPUT_DATA-0x0049

    #defineMBEDTLS_NET_LISTEN_BACKLOG10
    #defineMBEDTLS_NET_PROTO_TCP0
    #defineMBEDTLS_NET_PROTO_UDP1
    #defineMBEDTLS_NET_POLL_READ1
    #defineMBEDTLS_NET_POLL_WRITE2
    #ifdef__cplusplus
    extern"C"{
    #endif

    typedefstructmbedtls_net_context{
    intfd;
    }
    mbedtls_net_context;

    voidmbedtls_net_init(mbedtls_net_context*ctx);

    intmbedtls_net_connect(mbedtls_net_context*ctx,constchar*host,constchar*port,intproto);

    intmbedtls_net_bind(mbedtls_net_context*ctx,constchar*bind_ip,constchar*port,intproto);

    intmbedtls_net_accept(mbedtls_net_context*bind_ctx,
    mbedtls_net_context*client_ctx,
    void*client_ip,size_tbuf_size,size_t*cip_len);

    intmbedtls_net_poll(mbedtls_net_context*ctx,uint32_trw,uint32_ttimeout);

    intmbedtls_net_set_block(mbedtls_net_context*ctx);

    intmbedtls_net_set_nonblock(mbedtls_net_context*ctx);

    voidmbedtls_net_usleep(unsignedlongusec);

    intmbedtls_net_recv(void*ctx,unsignedchar*buf,size_tlen);

    intmbedtls_net_send(void*ctx,constunsignedchar*buf,size_tlen);

    intmbedtls_net_recv_timeout(void*ctx,unsignedchar*buf,size_tlen,
    uint32_ttimeout);

    voidmbedtls_net_close(mbedtls_net_context*ctx);

    voidmbedtls_net_free(mbedtls_net_context*ctx);

    #ifdef__cplusplus
    }
    #endif

    #endif/*net_sockets.h*/