2015-10-06 16:10:00 +01:00
|
|
|
/*
|
2017-06-30 08:22:17 +01:00
|
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
2015-10-06 16:10:00 +01:00
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
extmod/modussl_axtls: Add non-blocking mode support.
It consists of:
1. "do_handhake" param (default True) to wrap_socket(). If it's False,
handshake won't be performed by wrap_socket(), as it would be done in
blocking way normally. Instead, SSL socket can be set to non-blocking mode,
and handshake would be performed before the first read/write request (by
just returning EAGAIN to these requests, while instead reading/writing/
processing handshake over the connection). Unfortunately, axTLS doesn't
really support non-blocking handshake correctly. So, while framework for
this is implemented on MicroPython's module side, in case of axTLS, it
won't work reliably.
2. Implementation of .setblocking() method. It must be called on SSL socket
for blocking vs non-blocking operation to be handled correctly (for
example, it's not enough to wrap non-blocking socket with wrap_socket()
call - resulting SSL socket won't be itself non-blocking). Note that
.setblocking() propagates call to the underlying socket object, as
expected.
2019-03-01 20:48:16 +00:00
|
|
|
* Copyright (c) 2015-2019 Paul Sokolovsky
|
2015-10-06 16:10:00 +01:00
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "py/runtime.h"
|
|
|
|
#include "py/stream.h"
|
2020-03-27 06:17:35 +00:00
|
|
|
#include "py/objstr.h"
|
2015-10-06 16:10:00 +01:00
|
|
|
|
2016-07-12 23:49:38 +01:00
|
|
|
#if MICROPY_PY_USSL && MICROPY_SSL_AXTLS
|
2015-10-06 16:10:00 +01:00
|
|
|
|
|
|
|
#include "ssl.h"
|
|
|
|
|
|
|
|
typedef struct _mp_obj_ssl_socket_t {
|
|
|
|
mp_obj_base_t base;
|
|
|
|
mp_obj_t sock;
|
|
|
|
SSL_CTX *ssl_ctx;
|
|
|
|
SSL *ssl_sock;
|
|
|
|
byte *buf;
|
|
|
|
uint32_t bytes_left;
|
extmod/modussl_axtls: Add non-blocking mode support.
It consists of:
1. "do_handhake" param (default True) to wrap_socket(). If it's False,
handshake won't be performed by wrap_socket(), as it would be done in
blocking way normally. Instead, SSL socket can be set to non-blocking mode,
and handshake would be performed before the first read/write request (by
just returning EAGAIN to these requests, while instead reading/writing/
processing handshake over the connection). Unfortunately, axTLS doesn't
really support non-blocking handshake correctly. So, while framework for
this is implemented on MicroPython's module side, in case of axTLS, it
won't work reliably.
2. Implementation of .setblocking() method. It must be called on SSL socket
for blocking vs non-blocking operation to be handled correctly (for
example, it's not enough to wrap non-blocking socket with wrap_socket()
call - resulting SSL socket won't be itself non-blocking). Note that
.setblocking() propagates call to the underlying socket object, as
expected.
2019-03-01 20:48:16 +00:00
|
|
|
bool blocking;
|
2015-10-06 16:10:00 +01:00
|
|
|
} mp_obj_ssl_socket_t;
|
|
|
|
|
2017-06-13 23:01:12 +01:00
|
|
|
struct ssl_args {
|
2017-10-30 01:48:14 +00:00
|
|
|
mp_arg_val_t key;
|
|
|
|
mp_arg_val_t cert;
|
2017-06-13 23:01:12 +01:00
|
|
|
mp_arg_val_t server_side;
|
|
|
|
mp_arg_val_t server_hostname;
|
extmod/modussl_axtls: Add non-blocking mode support.
It consists of:
1. "do_handhake" param (default True) to wrap_socket(). If it's False,
handshake won't be performed by wrap_socket(), as it would be done in
blocking way normally. Instead, SSL socket can be set to non-blocking mode,
and handshake would be performed before the first read/write request (by
just returning EAGAIN to these requests, while instead reading/writing/
processing handshake over the connection). Unfortunately, axTLS doesn't
really support non-blocking handshake correctly. So, while framework for
this is implemented on MicroPython's module side, in case of axTLS, it
won't work reliably.
2. Implementation of .setblocking() method. It must be called on SSL socket
for blocking vs non-blocking operation to be handled correctly (for
example, it's not enough to wrap non-blocking socket with wrap_socket()
call - resulting SSL socket won't be itself non-blocking). Note that
.setblocking() propagates call to the underlying socket object, as
expected.
2019-03-01 20:48:16 +00:00
|
|
|
mp_arg_val_t do_handshake;
|
2017-06-13 23:01:12 +01:00
|
|
|
};
|
|
|
|
|
2015-10-06 16:10:00 +01:00
|
|
|
STATIC const mp_obj_type_t ussl_socket_type;
|
|
|
|
|
2020-03-27 06:17:35 +00:00
|
|
|
// Table of errors
|
|
|
|
struct ssl_errs {
|
|
|
|
int16_t errnum;
|
|
|
|
const char *errstr;
|
|
|
|
};
|
|
|
|
STATIC const struct ssl_errs ssl_error_tab[] = {
|
|
|
|
{ SSL_NOT_OK, "NOT_OK" },
|
|
|
|
{ SSL_ERROR_DEAD, "DEAD" },
|
|
|
|
{ SSL_CLOSE_NOTIFY, "CLOSE_NOTIFY" },
|
|
|
|
{ SSL_EAGAIN, "EAGAIN" },
|
|
|
|
{ SSL_ERROR_CONN_LOST, "CONN_LOST" },
|
|
|
|
{ SSL_ERROR_RECORD_OVERFLOW, "RECORD_OVERFLOW" },
|
|
|
|
{ SSL_ERROR_SOCK_SETUP_FAILURE, "SOCK_SETUP_FAILURE" },
|
|
|
|
{ SSL_ERROR_INVALID_HANDSHAKE, "INVALID_HANDSHAKE" },
|
|
|
|
{ SSL_ERROR_INVALID_PROT_MSG, "INVALID_PROT_MSG" },
|
|
|
|
{ SSL_ERROR_INVALID_HMAC, "INVALID_HMAC" },
|
|
|
|
{ SSL_ERROR_INVALID_VERSION, "INVALID_VERSION" },
|
|
|
|
{ SSL_ERROR_UNSUPPORTED_EXTENSION, "UNSUPPORTED_EXTENSION" },
|
|
|
|
{ SSL_ERROR_INVALID_SESSION, "INVALID_SESSION" },
|
|
|
|
{ SSL_ERROR_NO_CIPHER, "NO_CIPHER" },
|
|
|
|
{ SSL_ERROR_INVALID_CERT_HASH_ALG, "INVALID_CERT_HASH_ALG" },
|
|
|
|
{ SSL_ERROR_BAD_CERTIFICATE, "BAD_CERTIFICATE" },
|
|
|
|
{ SSL_ERROR_INVALID_KEY, "INVALID_KEY" },
|
|
|
|
{ SSL_ERROR_FINISHED_INVALID, "FINISHED_INVALID" },
|
|
|
|
{ SSL_ERROR_NO_CERT_DEFINED, "NO_CERT_DEFINED" },
|
|
|
|
{ SSL_ERROR_NO_CLIENT_RENOG, "NO_CLIENT_RENOG" },
|
|
|
|
{ SSL_ERROR_NOT_SUPPORTED, "NOT_SUPPORTED" },
|
|
|
|
};
|
|
|
|
|
|
|
|
STATIC NORETURN void ussl_raise_error(int err) {
|
|
|
|
for (size_t i = 0; i < MP_ARRAY_SIZE(ssl_error_tab); i++) {
|
|
|
|
if (ssl_error_tab[i].errnum == err) {
|
|
|
|
// construct string object
|
|
|
|
mp_obj_str_t *o_str = m_new_obj_maybe(mp_obj_str_t);
|
|
|
|
if (o_str == NULL) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
o_str->base.type = &mp_type_str;
|
|
|
|
o_str->data = (const byte *)ssl_error_tab[i].errstr;
|
|
|
|
o_str->len = strlen((char *)o_str->data);
|
|
|
|
o_str->hash = qstr_compute_hash(o_str->data, o_str->len);
|
|
|
|
// raise
|
|
|
|
mp_obj_t args[2] = { MP_OBJ_NEW_SMALL_INT(err), MP_OBJ_FROM_PTR(o_str)};
|
|
|
|
nlr_raise(mp_obj_exception_make_new(&mp_type_OSError, 2, 0, args));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mp_raise_OSError(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-08-19 13:29:53 +01:00
|
|
|
STATIC mp_obj_ssl_socket_t *ussl_socket_new(mp_obj_t sock, struct ssl_args *args) {
|
2020-02-27 04:36:53 +00:00
|
|
|
#if MICROPY_PY_USSL_FINALISER
|
2017-10-27 05:17:35 +01:00
|
|
|
mp_obj_ssl_socket_t *o = m_new_obj_with_finaliser(mp_obj_ssl_socket_t);
|
2020-02-27 04:36:53 +00:00
|
|
|
#else
|
2015-10-06 16:10:00 +01:00
|
|
|
mp_obj_ssl_socket_t *o = m_new_obj(mp_obj_ssl_socket_t);
|
2020-02-27 04:36:53 +00:00
|
|
|
#endif
|
2015-10-06 16:10:00 +01:00
|
|
|
o->base.type = &ussl_socket_type;
|
|
|
|
o->buf = NULL;
|
|
|
|
o->bytes_left = 0;
|
|
|
|
o->sock = sock;
|
extmod/modussl_axtls: Add non-blocking mode support.
It consists of:
1. "do_handhake" param (default True) to wrap_socket(). If it's False,
handshake won't be performed by wrap_socket(), as it would be done in
blocking way normally. Instead, SSL socket can be set to non-blocking mode,
and handshake would be performed before the first read/write request (by
just returning EAGAIN to these requests, while instead reading/writing/
processing handshake over the connection). Unfortunately, axTLS doesn't
really support non-blocking handshake correctly. So, while framework for
this is implemented on MicroPython's module side, in case of axTLS, it
won't work reliably.
2. Implementation of .setblocking() method. It must be called on SSL socket
for blocking vs non-blocking operation to be handled correctly (for
example, it's not enough to wrap non-blocking socket with wrap_socket()
call - resulting SSL socket won't be itself non-blocking). Note that
.setblocking() propagates call to the underlying socket object, as
expected.
2019-03-01 20:48:16 +00:00
|
|
|
o->blocking = true;
|
2015-10-06 16:10:00 +01:00
|
|
|
|
|
|
|
uint32_t options = SSL_SERVER_VERIFY_LATER;
|
extmod/modussl_axtls: Add non-blocking mode support.
It consists of:
1. "do_handhake" param (default True) to wrap_socket(). If it's False,
handshake won't be performed by wrap_socket(), as it would be done in
blocking way normally. Instead, SSL socket can be set to non-blocking mode,
and handshake would be performed before the first read/write request (by
just returning EAGAIN to these requests, while instead reading/writing/
processing handshake over the connection). Unfortunately, axTLS doesn't
really support non-blocking handshake correctly. So, while framework for
this is implemented on MicroPython's module side, in case of axTLS, it
won't work reliably.
2. Implementation of .setblocking() method. It must be called on SSL socket
for blocking vs non-blocking operation to be handled correctly (for
example, it's not enough to wrap non-blocking socket with wrap_socket()
call - resulting SSL socket won't be itself non-blocking). Note that
.setblocking() propagates call to the underlying socket object, as
expected.
2019-03-01 20:48:16 +00:00
|
|
|
if (!args->do_handshake.u_bool) {
|
|
|
|
options |= SSL_CONNECT_IN_PARTS;
|
|
|
|
}
|
2017-10-30 01:48:14 +00:00
|
|
|
if (args->key.u_obj != mp_const_none) {
|
|
|
|
options |= SSL_NO_DEFAULT_KEY;
|
|
|
|
}
|
2016-04-27 22:49:54 +01:00
|
|
|
if ((o->ssl_ctx = ssl_ctx_new(options, SSL_DEFAULT_CLNT_SESS)) == NULL) {
|
2016-10-07 03:52:14 +01:00
|
|
|
mp_raise_OSError(MP_EINVAL);
|
2015-10-06 16:10:00 +01:00
|
|
|
}
|
|
|
|
|
2017-10-30 01:48:14 +00:00
|
|
|
if (args->key.u_obj != mp_const_none) {
|
|
|
|
size_t len;
|
2020-02-27 04:36:53 +00:00
|
|
|
const byte *data = (const byte *)mp_obj_str_get_data(args->key.u_obj, &len);
|
2017-10-30 01:48:14 +00:00
|
|
|
int res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_RSA_KEY, data, len, NULL);
|
|
|
|
if (res != SSL_OK) {
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid key"));
|
2017-10-30 01:48:14 +00:00
|
|
|
}
|
|
|
|
|
2020-02-27 04:36:53 +00:00
|
|
|
data = (const byte *)mp_obj_str_get_data(args->cert.u_obj, &len);
|
2017-10-30 01:48:14 +00:00
|
|
|
res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_X509_CERT, data, len, NULL);
|
|
|
|
if (res != SSL_OK) {
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("invalid cert"));
|
2017-10-30 01:48:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-13 23:01:12 +01:00
|
|
|
if (args->server_side.u_bool) {
|
2016-04-28 15:27:20 +01:00
|
|
|
o->ssl_sock = ssl_server_new(o->ssl_ctx, (long)sock);
|
|
|
|
} else {
|
2017-06-13 23:01:12 +01:00
|
|
|
SSL_EXTENSIONS *ext = ssl_ext_new();
|
|
|
|
|
|
|
|
if (args->server_hostname.u_obj != mp_const_none) {
|
2020-02-27 04:36:53 +00:00
|
|
|
ext->host_name = (char *)mp_obj_str_get_str(args->server_hostname.u_obj);
|
2017-06-13 23:01:12 +01:00
|
|
|
}
|
2016-04-28 15:27:20 +01:00
|
|
|
|
2017-06-13 23:01:12 +01:00
|
|
|
o->ssl_sock = ssl_client_new(o->ssl_ctx, (long)sock, NULL, 0, ext);
|
|
|
|
|
extmod/modussl_axtls: Add non-blocking mode support.
It consists of:
1. "do_handhake" param (default True) to wrap_socket(). If it's False,
handshake won't be performed by wrap_socket(), as it would be done in
blocking way normally. Instead, SSL socket can be set to non-blocking mode,
and handshake would be performed before the first read/write request (by
just returning EAGAIN to these requests, while instead reading/writing/
processing handshake over the connection). Unfortunately, axTLS doesn't
really support non-blocking handshake correctly. So, while framework for
this is implemented on MicroPython's module side, in case of axTLS, it
won't work reliably.
2. Implementation of .setblocking() method. It must be called on SSL socket
for blocking vs non-blocking operation to be handled correctly (for
example, it's not enough to wrap non-blocking socket with wrap_socket()
call - resulting SSL socket won't be itself non-blocking). Note that
.setblocking() propagates call to the underlying socket object, as
expected.
2019-03-01 20:48:16 +00:00
|
|
|
if (args->do_handshake.u_bool) {
|
|
|
|
int res = ssl_handshake_status(o->ssl_sock);
|
2017-06-13 23:01:12 +01:00
|
|
|
|
extmod/modussl_axtls: Add non-blocking mode support.
It consists of:
1. "do_handhake" param (default True) to wrap_socket(). If it's False,
handshake won't be performed by wrap_socket(), as it would be done in
blocking way normally. Instead, SSL socket can be set to non-blocking mode,
and handshake would be performed before the first read/write request (by
just returning EAGAIN to these requests, while instead reading/writing/
processing handshake over the connection). Unfortunately, axTLS doesn't
really support non-blocking handshake correctly. So, while framework for
this is implemented on MicroPython's module side, in case of axTLS, it
won't work reliably.
2. Implementation of .setblocking() method. It must be called on SSL socket
for blocking vs non-blocking operation to be handled correctly (for
example, it's not enough to wrap non-blocking socket with wrap_socket()
call - resulting SSL socket won't be itself non-blocking). Note that
.setblocking() propagates call to the underlying socket object, as
expected.
2019-03-01 20:48:16 +00:00
|
|
|
if (res != SSL_OK) {
|
2020-03-27 06:17:35 +00:00
|
|
|
ussl_raise_error(res);
|
extmod/modussl_axtls: Add non-blocking mode support.
It consists of:
1. "do_handhake" param (default True) to wrap_socket(). If it's False,
handshake won't be performed by wrap_socket(), as it would be done in
blocking way normally. Instead, SSL socket can be set to non-blocking mode,
and handshake would be performed before the first read/write request (by
just returning EAGAIN to these requests, while instead reading/writing/
processing handshake over the connection). Unfortunately, axTLS doesn't
really support non-blocking handshake correctly. So, while framework for
this is implemented on MicroPython's module side, in case of axTLS, it
won't work reliably.
2. Implementation of .setblocking() method. It must be called on SSL socket
for blocking vs non-blocking operation to be handled correctly (for
example, it's not enough to wrap non-blocking socket with wrap_socket()
call - resulting SSL socket won't be itself non-blocking). Note that
.setblocking() propagates call to the underlying socket object, as
expected.
2019-03-01 20:48:16 +00:00
|
|
|
}
|
2016-04-28 15:27:20 +01:00
|
|
|
}
|
2017-06-13 23:01:12 +01:00
|
|
|
|
2015-10-06 16:10:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return o;
|
|
|
|
}
|
|
|
|
|
2019-08-19 13:29:53 +01:00
|
|
|
STATIC void ussl_socket_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
|
2015-10-06 16:10:00 +01:00
|
|
|
(void)kind;
|
2016-05-25 23:38:37 +01:00
|
|
|
mp_obj_ssl_socket_t *self = MP_OBJ_TO_PTR(self_in);
|
2015-10-06 16:10:00 +01:00
|
|
|
mp_printf(print, "<_SSLSocket %p>", self->ssl_sock);
|
|
|
|
}
|
|
|
|
|
2019-08-19 13:29:53 +01:00
|
|
|
STATIC mp_uint_t ussl_socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
|
2016-05-25 23:38:37 +01:00
|
|
|
mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(o_in);
|
2015-10-06 16:10:00 +01:00
|
|
|
|
2017-07-19 22:20:53 +01:00
|
|
|
if (o->ssl_sock == NULL) {
|
|
|
|
*errcode = EBADF;
|
|
|
|
return MP_STREAM_ERROR;
|
|
|
|
}
|
|
|
|
|
2015-10-06 16:10:00 +01:00
|
|
|
while (o->bytes_left == 0) {
|
|
|
|
mp_int_t r = ssl_read(o->ssl_sock, &o->buf);
|
2016-04-28 15:29:11 +01:00
|
|
|
if (r == SSL_OK) {
|
|
|
|
// SSL_OK from ssl_read() means "everything is ok, but there's
|
extmod/modussl_axtls: Add non-blocking mode support.
It consists of:
1. "do_handhake" param (default True) to wrap_socket(). If it's False,
handshake won't be performed by wrap_socket(), as it would be done in
blocking way normally. Instead, SSL socket can be set to non-blocking mode,
and handshake would be performed before the first read/write request (by
just returning EAGAIN to these requests, while instead reading/writing/
processing handshake over the connection). Unfortunately, axTLS doesn't
really support non-blocking handshake correctly. So, while framework for
this is implemented on MicroPython's module side, in case of axTLS, it
won't work reliably.
2. Implementation of .setblocking() method. It must be called on SSL socket
for blocking vs non-blocking operation to be handled correctly (for
example, it's not enough to wrap non-blocking socket with wrap_socket()
call - resulting SSL socket won't be itself non-blocking). Note that
.setblocking() propagates call to the underlying socket object, as
expected.
2019-03-01 20:48:16 +00:00
|
|
|
// no user data yet". It may happen e.g. if handshake is not
|
|
|
|
// finished yet. The best way we can treat it is by returning
|
|
|
|
// EAGAIN. This may be a bit unexpected in blocking mode, but
|
|
|
|
// default is to perform complete handshake in constructor, so
|
|
|
|
// this should not happen in blocking mode. On the other hand,
|
|
|
|
// in nonblocking mode EAGAIN (comparing to the alternative of
|
|
|
|
// looping) is really preferrable.
|
|
|
|
if (o->blocking) {
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
goto eagain;
|
|
|
|
}
|
2016-04-28 15:29:11 +01:00
|
|
|
}
|
2015-10-06 16:10:00 +01:00
|
|
|
if (r < 0) {
|
|
|
|
if (r == SSL_CLOSE_NOTIFY || r == SSL_ERROR_CONN_LOST) {
|
|
|
|
// EOF
|
|
|
|
return 0;
|
|
|
|
}
|
2017-11-01 22:14:11 +00:00
|
|
|
if (r == SSL_EAGAIN) {
|
2020-02-27 04:36:53 +00:00
|
|
|
eagain:
|
2017-11-01 22:14:11 +00:00
|
|
|
r = MP_EAGAIN;
|
|
|
|
}
|
2015-10-06 16:10:00 +01:00
|
|
|
*errcode = r;
|
|
|
|
return MP_STREAM_ERROR;
|
|
|
|
}
|
|
|
|
o->bytes_left = r;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size > o->bytes_left) {
|
|
|
|
size = o->bytes_left;
|
|
|
|
}
|
|
|
|
memcpy(buf, o->buf, size);
|
|
|
|
o->buf += size;
|
|
|
|
o->bytes_left -= size;
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2019-08-19 13:29:53 +01:00
|
|
|
STATIC mp_uint_t ussl_socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
|
2016-05-25 23:38:37 +01:00
|
|
|
mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(o_in);
|
2017-07-19 22:20:53 +01:00
|
|
|
|
|
|
|
if (o->ssl_sock == NULL) {
|
|
|
|
*errcode = EBADF;
|
|
|
|
return MP_STREAM_ERROR;
|
|
|
|
}
|
|
|
|
|
2015-10-06 16:10:00 +01:00
|
|
|
mp_int_t r = ssl_write(o->ssl_sock, buf, size);
|
|
|
|
if (r < 0) {
|
|
|
|
*errcode = r;
|
|
|
|
return MP_STREAM_ERROR;
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2019-08-19 13:29:53 +01:00
|
|
|
STATIC mp_uint_t ussl_socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
|
2018-03-07 06:48:53 +00:00
|
|
|
mp_obj_ssl_socket_t *self = MP_OBJ_TO_PTR(o_in);
|
2018-07-20 04:05:04 +01:00
|
|
|
if (request == MP_STREAM_CLOSE && self->ssl_sock != NULL) {
|
|
|
|
ssl_free(self->ssl_sock);
|
|
|
|
ssl_ctx_free(self->ssl_ctx);
|
|
|
|
self->ssl_sock = NULL;
|
2018-03-07 06:48:53 +00:00
|
|
|
}
|
2018-07-20 04:05:04 +01:00
|
|
|
// Pass all requests down to the underlying socket
|
|
|
|
return mp_get_stream(self->sock)->ioctl(self->sock, request, arg, errcode);
|
2018-03-07 06:48:53 +00:00
|
|
|
}
|
|
|
|
|
2019-08-19 13:29:53 +01:00
|
|
|
STATIC mp_obj_t ussl_socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
|
extmod/modussl_axtls: Add non-blocking mode support.
It consists of:
1. "do_handhake" param (default True) to wrap_socket(). If it's False,
handshake won't be performed by wrap_socket(), as it would be done in
blocking way normally. Instead, SSL socket can be set to non-blocking mode,
and handshake would be performed before the first read/write request (by
just returning EAGAIN to these requests, while instead reading/writing/
processing handshake over the connection). Unfortunately, axTLS doesn't
really support non-blocking handshake correctly. So, while framework for
this is implemented on MicroPython's module side, in case of axTLS, it
won't work reliably.
2. Implementation of .setblocking() method. It must be called on SSL socket
for blocking vs non-blocking operation to be handled correctly (for
example, it's not enough to wrap non-blocking socket with wrap_socket()
call - resulting SSL socket won't be itself non-blocking). Note that
.setblocking() propagates call to the underlying socket object, as
expected.
2019-03-01 20:48:16 +00:00
|
|
|
mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(self_in);
|
|
|
|
mp_obj_t sock = o->sock;
|
|
|
|
mp_obj_t dest[3];
|
|
|
|
mp_load_method(sock, MP_QSTR_setblocking, dest);
|
|
|
|
dest[2] = flag_in;
|
|
|
|
mp_obj_t res = mp_call_method_n_kw(1, 0, dest);
|
|
|
|
o->blocking = mp_obj_is_true(flag_in);
|
|
|
|
return res;
|
2016-07-14 23:05:06 +01:00
|
|
|
}
|
2019-08-19 13:29:53 +01:00
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_2(ussl_socket_setblocking_obj, ussl_socket_setblocking);
|
2016-07-14 23:05:06 +01:00
|
|
|
|
2016-05-25 23:38:37 +01:00
|
|
|
STATIC const mp_rom_map_elem_t ussl_socket_locals_dict_table[] = {
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
|
2019-08-19 13:29:53 +01:00
|
|
|
{ MP_ROM_QSTR(MP_QSTR_setblocking), MP_ROM_PTR(&ussl_socket_setblocking_obj) },
|
2018-03-07 06:48:53 +00:00
|
|
|
{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
|
2020-02-27 04:36:53 +00:00
|
|
|
#if MICROPY_PY_USSL_FINALISER
|
2018-06-13 04:16:21 +01:00
|
|
|
{ MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&mp_stream_close_obj) },
|
2020-02-27 04:36:53 +00:00
|
|
|
#endif
|
2015-10-06 16:10:00 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
STATIC MP_DEFINE_CONST_DICT(ussl_socket_locals_dict, ussl_socket_locals_dict_table);
|
|
|
|
|
|
|
|
STATIC const mp_stream_p_t ussl_socket_stream_p = {
|
2019-08-19 13:29:53 +01:00
|
|
|
.read = ussl_socket_read,
|
|
|
|
.write = ussl_socket_write,
|
|
|
|
.ioctl = ussl_socket_ioctl,
|
2015-10-06 16:10:00 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
STATIC const mp_obj_type_t ussl_socket_type = {
|
|
|
|
{ &mp_type_type },
|
|
|
|
// Save on qstr's, reuse same as for module
|
|
|
|
.name = MP_QSTR_ussl,
|
2019-08-19 13:29:53 +01:00
|
|
|
.print = ussl_socket_print,
|
2015-10-06 16:10:00 +01:00
|
|
|
.getiter = NULL,
|
|
|
|
.iternext = NULL,
|
2016-06-18 16:19:24 +01:00
|
|
|
.protocol = &ussl_socket_stream_p,
|
2020-02-27 04:36:53 +00:00
|
|
|
.locals_dict = (void *)&ussl_socket_locals_dict,
|
2015-10-06 16:10:00 +01:00
|
|
|
};
|
|
|
|
|
2016-05-25 23:38:37 +01:00
|
|
|
STATIC mp_obj_t mod_ssl_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
2015-10-06 16:10:00 +01:00
|
|
|
// TODO: Implement more args
|
2016-04-28 15:27:20 +01:00
|
|
|
static const mp_arg_t allowed_args[] = {
|
2019-12-16 04:40:05 +00:00
|
|
|
{ MP_QSTR_key, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
|
|
|
|
{ MP_QSTR_cert, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
|
2016-04-28 15:27:20 +01:00
|
|
|
{ MP_QSTR_server_side, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
|
2019-12-16 04:40:05 +00:00
|
|
|
{ MP_QSTR_server_hostname, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
|
extmod/modussl_axtls: Add non-blocking mode support.
It consists of:
1. "do_handhake" param (default True) to wrap_socket(). If it's False,
handshake won't be performed by wrap_socket(), as it would be done in
blocking way normally. Instead, SSL socket can be set to non-blocking mode,
and handshake would be performed before the first read/write request (by
just returning EAGAIN to these requests, while instead reading/writing/
processing handshake over the connection). Unfortunately, axTLS doesn't
really support non-blocking handshake correctly. So, while framework for
this is implemented on MicroPython's module side, in case of axTLS, it
won't work reliably.
2. Implementation of .setblocking() method. It must be called on SSL socket
for blocking vs non-blocking operation to be handled correctly (for
example, it's not enough to wrap non-blocking socket with wrap_socket()
call - resulting SSL socket won't be itself non-blocking). Note that
.setblocking() propagates call to the underlying socket object, as
expected.
2019-03-01 20:48:16 +00:00
|
|
|
{ MP_QSTR_do_handshake, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = true} },
|
2016-04-28 15:27:20 +01:00
|
|
|
};
|
|
|
|
|
2015-10-06 16:10:00 +01:00
|
|
|
// TODO: Check that sock implements stream protocol
|
2016-04-28 15:27:20 +01:00
|
|
|
mp_obj_t sock = pos_args[0];
|
|
|
|
|
2017-06-13 23:01:12 +01:00
|
|
|
struct ssl_args args;
|
2016-04-28 15:27:20 +01:00
|
|
|
mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args,
|
2020-02-27 04:36:53 +00:00
|
|
|
MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t *)&args);
|
2016-04-28 15:27:20 +01:00
|
|
|
|
2019-08-19 13:29:53 +01:00
|
|
|
return MP_OBJ_FROM_PTR(ussl_socket_new(sock, &args));
|
2015-10-06 16:10:00 +01:00
|
|
|
}
|
2016-04-28 15:27:20 +01:00
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mod_ssl_wrap_socket_obj, 1, mod_ssl_wrap_socket);
|
2015-10-06 16:10:00 +01:00
|
|
|
|
2016-05-25 23:38:37 +01:00
|
|
|
STATIC const mp_rom_map_elem_t mp_module_ssl_globals_table[] = {
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ussl) },
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_wrap_socket), MP_ROM_PTR(&mod_ssl_wrap_socket_obj) },
|
2015-10-06 16:10:00 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
STATIC MP_DEFINE_CONST_DICT(mp_module_ssl_globals, mp_module_ssl_globals_table);
|
|
|
|
|
|
|
|
const mp_obj_module_t mp_module_ussl = {
|
|
|
|
.base = { &mp_type_module },
|
2020-02-27 04:36:53 +00:00
|
|
|
.globals = (mp_obj_dict_t *)&mp_module_ssl_globals,
|
2015-10-06 16:10:00 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif // MICROPY_PY_USSL
|