STATIC mp_obj_t mod_socket_sockaddr(mp_obj_t sockaddr_in) {
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(sockaddr_in, &bufinfo, MP_BUFFER_READ);
switch (((struct sockaddr*)bufinfo.buf)->sa_family) {
case AF_INET: {
struct sockaddr_in *sa = (struct sockaddr_in*)bufinfo.buf;
mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
t->items[0] = MP_OBJ_NEW_SMALL_INT(AF_INET);
t->items[1] = mp_obj_new_bytes((byte*)&sa->sin_addr, sizeof(sa->sin_addr));
t->items[2] = MP_OBJ_NEW_SMALL_INT(ntohs(sa->sin_port));
return MP_OBJ_FROM_PTR(t);
}
case AF_INET6: {
struct sockaddr_in6 *sa = (struct sockaddr_in6*)bufinfo.buf;
mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(5, NULL));
t->items[0] = MP_OBJ_NEW_SMALL_INT(AF_INET6);
t->items[1] = mp_obj_new_bytes((byte*)&sa->sin6_addr, sizeof(sa->sin6_addr));
t->items[2] = MP_OBJ_NEW_SMALL_INT(ntohs(sa->sin6_port));
t->items[3] = MP_OBJ_NEW_SMALL_INT(ntohl(sa->sin6_flowinfo));
t->items[4] = MP_OBJ_NEW_SMALL_INT(ntohl(sa->sin6_scope_id));
return MP_OBJ_FROM_PTR(t);
}
default: {
struct sockaddr *sa = (struct sockaddr*)bufinfo.buf;
mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(2, NULL));
t->items[0] = MP_OBJ_NEW_SMALL_INT(sa->sa_family);
t->items[1] = mp_obj_new_bytes((byte*)sa->sa_data, bufinfo.len - offsetof(struct sockaddr, sa_data));
return MP_OBJ_FROM_PTR(t);
}
}
return mp_const_none;
}
STATIC mp_obj_t btree_iternext(mp_obj_t self_in) {
mp_obj_btree_t *self = MP_OBJ_TO_PTR(self_in);
DBT key, val;
int res;
// Different ports may have different type sizes
mp_uint_t v;
bool desc = self->flags & FLAG_DESC;
if (self->start_key != MP_OBJ_NULL) {
int flags = R_FIRST;
if (self->start_key != mp_const_none) {
key.data = (void*)mp_obj_str_get_data(self->start_key, &v);
key.size = v;
flags = R_CURSOR;
} else if (desc) {
flags = R_LAST;
}
res = __bt_seq(self->db, &key, &val, flags);
self->start_key = MP_OBJ_NULL;
} else {
res = __bt_seq(self->db, &key, &val, desc ? R_PREV : R_NEXT);
}
if (res == RET_SPECIAL) {
return MP_OBJ_STOP_ITERATION;
}
CHECK_ERROR(res);
if (self->end_key != mp_const_none) {
DBT end_key;
end_key.data = (void*)mp_obj_str_get_data(self->end_key, &v);
end_key.size = v;
BTREE *t = self->db->internal;
int cmp = t->bt_cmp(&key, &end_key);
if (desc) {
cmp = -cmp;
}
if (self->flags & FLAG_END_KEY_INCL) {
cmp--;
}
if (cmp >= 0) {
self->end_key = MP_OBJ_NULL;
return MP_OBJ_STOP_ITERATION;
}
}
switch (self->flags & FLAG_ITER_TYPE_MASK) {
case FLAG_ITER_KEYS:
return mp_obj_new_bytes(key.data, key.size);
case FLAG_ITER_VALUES:
return mp_obj_new_bytes(val.data, val.size);
default: {
mp_obj_t pair_o = mp_obj_new_tuple(2, NULL);
mp_obj_tuple_t *pair = MP_OBJ_TO_PTR(pair_o);
pair->items[0] = mp_obj_new_bytes(key.data, key.size);
pair->items[1] = mp_obj_new_bytes(val.data, val.size);
return pair_o;
}
}
}
STATIC void esp_socket_recv_callback(void *arg, char *pdata, unsigned short len) {
struct espconn *conn = arg;
esp_socket_obj_t *s = conn->reverse;
if (s->cb_recv != mp_const_none) {
call_function_2_protected(s->cb_recv, s, mp_obj_new_bytes((byte *)pdata, len));
} else {
if (s->recvbuf == NULL) {
s->recvbuf = gc_alloc(len, false);
s->recvbuf_len = len;
if (s->recvbuf != NULL) {
memcpy(s->recvbuf, pdata, len);
}
} else {
s->recvbuf = gc_realloc(s->recvbuf, s->recvbuf_len + len, true);
if (s->recvbuf != NULL) {
memcpy(&s->recvbuf[s->recvbuf_len], pdata, len);
s->recvbuf_len += len;
}
}
if (s->recvbuf == NULL) {
esp_socket_close(s);
return;
}
}
}
STATIC mp_obj_t struct_unpack(mp_obj_t fmt_in, mp_obj_t data_in) {
// TODO: "The buffer must contain exactly the amount of data required by the format (len(bytes) must equal calcsize(fmt))."
const char *fmt = mp_obj_str_get_str(fmt_in);
char fmt_type = get_fmt_type(&fmt);
uint size = calcsize_items(fmt);
mp_obj_tuple_t *res = mp_obj_new_tuple(size, NULL);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(data_in, &bufinfo, MP_BUFFER_READ);
byte *p = bufinfo.buf;
for (uint i = 0; i < size; i++) {
machine_uint_t sz = 1;
if (unichar_isdigit(*fmt)) {
sz = get_fmt_num(&fmt);
}
if (sz > 1) {
// TODO: size spec support only for string len
assert(*fmt == 's');
}
mp_obj_t item;
if (*fmt == 's') {
item = mp_obj_new_bytes(p, sz);
p += sz;
fmt++;
} else {
item = mp_binary_get_val(fmt_type, *fmt++, &p);
}
res->items[i] = item;
}
return res;
}
STATIC mp_obj_t esp_flash_read(mp_obj_t offset_in, mp_obj_t len_or_buf_in) {
mp_int_t offset = mp_obj_get_int(offset_in);
mp_int_t len;
byte *buf;
bool alloc_buf = MP_OBJ_IS_INT(len_or_buf_in);
if (alloc_buf) {
len = mp_obj_get_int(len_or_buf_in);
buf = m_new(byte, len);
} else {
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(len_or_buf_in, &bufinfo, MP_BUFFER_WRITE);
len = bufinfo.len;
buf = bufinfo.buf;
}
// We know that allocation will be 4-byte aligned for sure
SpiFlashOpResult res = spi_flash_read(offset, (uint32_t*)buf, len);
if (res == SPI_FLASH_RESULT_OK) {
if (alloc_buf) {
return mp_obj_new_bytes(buf, len);
}
return mp_const_none;
}
if (alloc_buf) {
m_del(byte, buf, len);
}
mp_raise_OSError(res == SPI_FLASH_RESULT_TIMEOUT ? MP_ETIMEDOUT : MP_EIO);
}
STATIC mp_obj_t wiznet5k_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
wiznet5k_obj_t *self = MP_OBJ_TO_PTR(args[0]);
if (kwargs->used == 0) {
// Get config value
if (n_args != 2) {
mp_raise_TypeError("must query one param");
}
switch (mp_obj_str_get_qstr(args[1])) {
case MP_QSTR_mac: {
uint8_t buf[6];
wiznet5k_get_mac_address(self, buf);
return mp_obj_new_bytes(buf, 6);
}
default:
mp_raise_ValueError("unknown config param");
}
} else {
// Set config value(s)
if (n_args != 1) {
mp_raise_TypeError("can't specify pos and kw args");
}
mp_raise_ValueError("unknown config param");
}
}
STATIC mp_obj_t mod_termios_tcgetattr(mp_obj_t fd_in) {
struct termios term;
int fd = mp_obj_get_int(fd_in);
int res = tcgetattr(fd, &term);
RAISE_ERRNO(res, errno);
mp_obj_list_t *r = MP_OBJ_TO_PTR(mp_obj_new_list(7, NULL));
r->items[0] = MP_OBJ_NEW_SMALL_INT(term.c_iflag);
r->items[1] = MP_OBJ_NEW_SMALL_INT(term.c_oflag);
r->items[2] = MP_OBJ_NEW_SMALL_INT(term.c_cflag);
r->items[3] = MP_OBJ_NEW_SMALL_INT(term.c_lflag);
r->items[4] = MP_OBJ_NEW_SMALL_INT(cfgetispeed(&term));
r->items[5] = MP_OBJ_NEW_SMALL_INT(cfgetospeed(&term));
mp_obj_list_t *cc = MP_OBJ_TO_PTR(mp_obj_new_list(NCCS, NULL));
r->items[6] = MP_OBJ_FROM_PTR(cc);
for (int i = 0; i < NCCS; i++) {
if (i == VMIN || i == VTIME) {
cc->items[i] = MP_OBJ_NEW_SMALL_INT(term.c_cc[i]);
} else {
// https://docs.python.org/3/library/termios.html says value is *string*,
// but no way unicode chars could be there, if c_cc is defined to be a
// a "char". But it's type is actually cc_t, which can be anything.
// TODO: For now, we still deal with it like that.
cc->items[i] = mp_obj_new_bytes((byte*)&term.c_cc[i], 1);
}
}
return MP_OBJ_FROM_PTR(r);
}
STATIC mp_obj_t mod_ssl_getpeercert(mp_obj_t o_in, mp_obj_t binary_form) {
mp_obj_ssl_socket_t *o = MP_OBJ_TO_PTR(o_in);
if (!mp_obj_is_true(binary_form)) {
mp_raise_NotImplementedError(NULL);
}
const mbedtls_x509_crt* peer_cert = mbedtls_ssl_get_peer_cert(&o->ssl);
return mp_obj_new_bytes(peer_cert->raw.p, peer_cert->raw.len);
}
STATIC mp_obj_t esp_socket_onrecv(mp_obj_t self_in, mp_obj_t lambda_in) {
esp_socket_obj_t *s = self_in;
s->cb_recv = lambda_in;
if (s->recvbuf != NULL) {
call_function_2_protected(s->cb_recv, s,
mp_obj_new_bytes((byte *)s->recvbuf, s->recvbuf_len));
s->recvbuf = NULL;
}
return mp_const_none;
}
STATIC mp_obj_t mod_eoslib_read_action(void) {
size_t size = get_vm_api()->action_data_size();
if (size <= 0) {
return mp_const_none;
}
byte *data = calloc(size, 1);
get_vm_api()->read_action_data((char*)data, size);
mp_obj_t obj = mp_obj_new_bytes(data, size);
free(data);
return obj;
}
STATIC mp_obj_t btree_seq(size_t n_args, const mp_obj_t *args) {
mp_obj_btree_t *self = MP_OBJ_TO_PTR(args[0]);
int flags = MP_OBJ_SMALL_INT_VALUE(args[1]);
DBT key, val;
if (n_args > 2) {
// Different ports may have different type sizes
mp_uint_t v;
key.data = (void*)mp_obj_str_get_data(args[2], &v);
key.size = v;
}
int res = __bt_seq(self->db, &key, &val, flags);
if (res == RET_SPECIAL) {
return mp_const_none;
}
mp_obj_t pair_o = mp_obj_new_tuple(2, NULL);
mp_obj_tuple_t *pair = MP_OBJ_TO_PTR(pair_o);
pair->items[0] = mp_obj_new_bytes(key.data, key.size);
pair->items[1] = mp_obj_new_bytes(val.data, val.size);
return pair_o;
}
// method socket.recv(bufsize)
STATIC mp_obj_t esp_socket_recv(mp_obj_t self_in, mp_obj_t len_in) {
esp_socket_obj_t *s = self_in;
if (s->recvbuf == NULL) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"no data available"));
}
mp_uint_t mxl = mp_obj_get_int(len_in);
if (mxl >= s->recvbuf_len) {
mp_obj_t trt = mp_obj_new_bytes(s->recvbuf, s->recvbuf_len);
gc_free(s->recvbuf);
s->recvbuf = NULL;
return trt;
} else {
mp_obj_t trt = mp_obj_new_bytes(s->recvbuf, mxl);
memmove(s->recvbuf, &s->recvbuf[mxl], s->recvbuf_len - mxl);
s->recvbuf_len -= mxl;
s->recvbuf = gc_realloc(s->recvbuf, s->recvbuf_len, true);
return trt;
}
}
/**
* def read_cid(self)
*/
static mp_obj_t class_sd_read_cid(mp_obj_t self_in)
{
struct class_sd_t *self_p;
struct sd_cid_t cid;
mp_obj_t tuple[7];
self_p = MP_OBJ_TO_PTR(self_in);
if (sd_read_cid(&self_p->drv, &cid) != sizeof(cid)) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"sd_read_cid() failed"));
}
tuple[0] = MP_OBJ_NEW_SMALL_INT(cid.mid);
tuple[1] = mp_obj_new_bytes((const byte *)cid.oid, sizeof(cid.oid));
tuple[2] = mp_obj_new_bytes((const byte *)cid.pnm, sizeof(cid.pnm));
tuple[3] = MP_OBJ_NEW_SMALL_INT(cid.prv);
tuple[4] = mp_obj_new_int(cid.psn);
tuple[5] = mp_obj_new_int(cid.mdt);
tuple[6] = MP_OBJ_NEW_SMALL_INT(cid.crc);
return (mp_obj_new_attrtuple(&cid_fields[0], 7, tuple));
}
STATIC mp_obj_t wlan_scan(mp_obj_t self_in) {
STATIC const qstr wlan_scan_info_fields[] = {
MP_QSTR_ssid, MP_QSTR_bssid, MP_QSTR_sec, MP_QSTR_channel, MP_QSTR_rssi
};
// check for correct wlan mode
if (wlan_obj.mode == ROLE_AP) {
mp_raise_OSError(MP_EPERM);
}
Sl_WlanNetworkEntry_t wlanEntry;
mp_obj_t nets = mp_obj_new_list(0, NULL);
uint8_t _index = 0;
// trigger a new network scan
uint32_t scanSeconds = MODWLAN_SCAN_PERIOD_S;
ASSERT_ON_ERROR(sl_WlanPolicySet(SL_POLICY_SCAN , MODWLAN_SL_SCAN_ENABLE, (_u8 *)&scanSeconds, sizeof(scanSeconds)));
// wait for the scan to complete
mp_hal_delay_ms(MODWLAN_WAIT_FOR_SCAN_MS);
do {
if (sl_WlanGetNetworkList(_index++, 1, &wlanEntry) <= 0) {
break;
}
// we must skip any duplicated results
if (!wlan_scan_result_is_unique(nets, wlanEntry.bssid)) {
continue;
}
mp_obj_t tuple[5];
tuple[0] = mp_obj_new_str((const char *)wlanEntry.ssid, wlanEntry.ssid_len, false);
tuple[1] = mp_obj_new_bytes((const byte *)wlanEntry.bssid, SL_BSSID_LENGTH);
// 'normalize' the security type
if (wlanEntry.sec_type > 2) {
wlanEntry.sec_type = 2;
}
tuple[2] = mp_obj_new_int(wlanEntry.sec_type);
tuple[3] = mp_const_none;
tuple[4] = mp_obj_new_int(wlanEntry.rssi);
// add the network to the list
mp_obj_list_append(nets, mp_obj_new_attrtuple(wlan_scan_info_fields, 5, tuple));
} while (_index < MODWLAN_SL_MAX_NETWORKS);
return nets;
}
STATIC mp_obj_t hash_read (mp_obj_t self_in) {
mp_obj_hash_t *self = self_in;
if (!self->fixedlen) {
if (!self->digested) {
hash_update_internal(self, MP_OBJ_NULL, true);
}
} else if (self->c_size < self->b_size) {
// it's a fixed len block which is still incomplete
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
}
if (!self->digested) {
CRYPTOHASH_SHAMD5Read ((uint8_t *)self->hash);
self->digested = true;
}
return mp_obj_new_bytes(self->hash, self->h_size);
}
STATIC mp_obj_t btree_get(size_t n_args, const mp_obj_t *args) {
mp_obj_btree_t *self = MP_OBJ_TO_PTR(args[0]);
DBT key, val;
// Different ports may have different type sizes
mp_uint_t v;
key.data = (void*)mp_obj_str_get_data(args[1], &v);
key.size = v;
int res = __bt_get(self->db, &key, &val, 0);
if (res == RET_SPECIAL) {
if (n_args > 2) {
return args[2];
} else {
return mp_const_none;
}
}
CHECK_ERROR(res);
return mp_obj_new_bytes(val.data, val.size);
}
STATIC mp_obj_t mod_socket_inet_pton(mp_obj_t family_in, mp_obj_t addr_in) {
int family = mp_obj_get_int(family_in);
byte binaddr[BINADDR_MAX_LEN];
int r = inet_pton(family, mp_obj_str_get_str(addr_in), binaddr);
RAISE_ERRNO(r, errno);
if (r == 0) {
nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(EINVAL)));
}
int binaddr_len = 0;
switch (family) {
case AF_INET:
binaddr_len = sizeof(struct in_addr);
break;
case AF_INET6:
binaddr_len = sizeof(struct in6_addr);
break;
}
return mp_obj_new_bytes(binaddr, binaddr_len);
}
STATIC mp_obj_t mod_socket_inet_pton(mp_obj_t family_in, mp_obj_t addr_in) {
int family = mp_obj_get_int(family_in);
byte binaddr[BINADDR_MAX_LEN];
int r = inet_pton(family, mp_obj_str_get_str(addr_in), binaddr);
RAISE_ERRNO(r, errno);
if (r == 0) {
mp_raise_OSError(MP_EINVAL);
}
int binaddr_len = 0;
switch (family) {
case AF_INET:
binaddr_len = sizeof(struct in_addr);
break;
case AF_INET6:
binaddr_len = sizeof(struct in6_addr);
break;
}
return mp_obj_new_bytes(binaddr, binaddr_len);
}
STATIC mp_obj_t btree_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
mp_obj_btree_t *self = MP_OBJ_TO_PTR(self_in);
// Different ports may have different type sizes
mp_uint_t v;
if (value == MP_OBJ_NULL) {
// delete
DBT key;
key.data = (void*)mp_obj_str_get_data(index, &v);
key.size = v;
int res = __bt_delete(self->db, &key, 0);
if (res == RET_SPECIAL) {
nlr_raise(mp_obj_new_exception(&mp_type_KeyError));
}
CHECK_ERROR(res);
return mp_const_none;
} else if (value == MP_OBJ_SENTINEL) {
// load
DBT key, val;
key.data = (void*)mp_obj_str_get_data(index, &v);
key.size = v;
int res = __bt_get(self->db, &key, &val, 0);
if (res == RET_SPECIAL) {
nlr_raise(mp_obj_new_exception(&mp_type_KeyError));
}
CHECK_ERROR(res);
return mp_obj_new_bytes(val.data, val.size);
} else {
// store
DBT key, val;
key.data = (void*)mp_obj_str_get_data(index, &v);
key.size = v;
val.data = (void*)mp_obj_str_get_data(value, &v);
val.size = v;
int res = __bt_put(self->db, &key, &val, 0);
CHECK_ERROR(res);
return mp_const_none;
}
}
STATIC mp_obj_t machine_unique_id(void) {
uint32_t id = system_get_chip_id();
return mp_obj_new_bytes((byte*)&id, sizeof(id));
}
// Returns a string of 12 bytes (96 bits), which is the unique ID for the MCU.
STATIC mp_obj_t machine_unique_id(void) {
byte *id = (byte*)0x1234; //MP_HAL_UNIQUE_ID_ADDRESS;
return mp_obj_new_bytes(id, 12);
}
// Returns a string of 8 bytes (64 bits), which is the unique ID for the MCU
STATIC mp_obj_t machine_unique_id(void) {
uint32_t dev_id[2];
dev_id[0] = NRF_FICR->DEVICEID[0];
dev_id[1] = NRF_FICR->DEVICEID[1];
return mp_obj_new_bytes((const void*)&dev_id, 8);
}
/// \function unique_id()
/// Returns a string of 12 bytes (96 bits), which is the unique ID for the MCU.
STATIC mp_obj_t pyb_unique_id(void) {
byte *id = (byte*)0x1fff7a10;
return mp_obj_new_bytes(id, 12);
}
/// \function unique_id()
/// Returns a string of 12 bytes (96 bits), which is the unique ID for the MCU.
STATIC mp_obj_t pyb_unique_id(void) {
byte *id = (byte*)0x40048058;
return mp_obj_new_bytes(id, 12);
}
// Helper functions
static inline mp_obj_t mp_obj_from_sockaddr(const struct sockaddr *addr, socklen_t len) {
return mp_obj_new_bytes((const byte *)addr, len);
}
STATIC mp_obj_t machine_unique_id(void) {
uint8_t mac[SL_BSSID_LENGTH];
wlan_get_mac (mac);
return mp_obj_new_bytes(mac, SL_BSSID_LENGTH);
}