10 files changed, 349 insertions, 472 deletions

diff --git a/fw/fe310/eos/net/Makefile b/fw/fe310/eos/net/Makefile
index fc65454..d743a54 100644
--- a/fw/fe310/eos/net/Makefile
+++ b/fw/fe310/eos/net/Makefile
@@ -1,6 +1,6 @@
 include ../../common.mk
 
-obj = rng.o pwr.o wifi.o sock.o cell.o
+obj = rng.o wifi.o cell.o sock.o
 lib = ../../libeos-net.a
 
 
diff --git a/fw/fe310/eos/net/cell.c b/fw/fe310/eos/net/cell.c
index 96216ba..aa1200d 100644
--- a/fw/fe310/eos/net/cell.c
+++ b/fw/fe310/eos/net/cell.c
@@ -10,21 +10,21 @@
 
 static eos_evt_handler_t evt_handler[EOS_CELL_MAX_MTYPE];
 
-static void cell_handle_msg(unsigned char type, unsigned char *buffer, uint16_t len) {
+static void cell_handle_msg(unsigned char type, EOSMessage *msg, uint16_t len) {
     unsigned char mtype;
     unsigned char idx;
 
-    if ((buffer == NULL) || (len < 1)) {
-        eos_net_bad_handler(type, buffer, len);
+    if ((msg == NULL) || (len < 1)) {
+        eos_net_bad_handler(type, msg, len);
         return;
     }
 
-    mtype = buffer[0];
+    mtype = msg->buffer[0];
     idx = (mtype & EOS_CELL_MTYPE_MASK) >> 4;
     if ((idx < EOS_CELL_MAX_MTYPE) && evt_handler[idx]) {
-        evt_handler[idx](mtype & ~EOS_CELL_MTYPE_MASK, buffer, len);
+        evt_handler[idx](mtype & ~EOS_CELL_MTYPE_MASK, msg, len);
     } else {
-        eos_net_bad_handler(type, buffer, len);
+        eos_net_bad_handler(type, msg, len);
     }
 }
 
@@ -50,12 +50,9 @@ eos_evt_handler_t eos_cell_get_handler(unsigned char mtype) {
     return NULL;
 }
 
-int eos_cell_send_buffer(unsigned char *buffer, uint16_t buf_len, uint16_t offset, int sync) {
-    buffer -= offset;
-    return eos_net_send_async(EOS_NET_MTYPE_CELL, buffer, buf_len + offset, 1);
-}
+int eos_cell_status_parse(EOSMessage *msg, uint16_t len, uint8_t *status, uint8_t *connected) {
+    unsigned char *buffer = msg->buffer;
 
-int eos_cell_status_parse(unsigned char *buffer, uint16_t len, uint8_t *status, uint8_t *connected) {
     if (len < 2) return EOS_ERR_SIZE;
 
     if (buffer[0] != (EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_STATUS)) return EOS_ERR_NET;
@@ -75,127 +72,110 @@ int eos_cell_status_parse(unsigned char *buffer, uint16_t len, uint8_t *status,
     return EOS_OK;
 }
 
-int eos_cell_status(uint8_t *status, uint8_t *connected, unsigned char *buffer) {
+int eos_cell_status(uint8_t *status, uint8_t *connected, EOSMessage *msg) {
     unsigned char type;
     uint16_t len;
-    int do_release;
     int rv;
 
-    do_release = 0;
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        do_release = 1;
-    }
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
     type = EOS_NET_MTYPE_CELL;
     len = 1;
-    buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_STATUS;
+    msg->buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_STATUS;
 
-    rv = eos_net_xchg(&type, buffer, &len);
-    if (rv) goto cell_status_fin;
+    rv = eos_net_xchg(&type, msg, &len);
+    if (rv) return rv;
 
-    if (type != EOS_NET_MTYPE_CELL) {
-        rv = EOS_ERR_NET;
-        goto cell_status_fin;
-    }
+    if (type != EOS_NET_MTYPE_CELL) return EOS_ERR_NET;
 
-    rv = eos_cell_status_parse(buffer, len, status, connected);
+    return eos_cell_status_parse(msg, len, status, connected);
+}
+
+int eos_cell_uart_take(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-cell_status_fin:
-    if (do_release) eos_net_free(buffer, 1);
-    return rv;
+    msg->buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_TAKE;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
 
-int eos_cell_uart_take(unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_uart_give(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_TAKE;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_GIVE;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
 
-int eos_cell_uart_give(unsigned char *buffer, int sync) {
-    int async;
+unsigned char *eos_cell_uart_msg2data(EOSMessage *msg, uint16_t *len, uint16_t *size) {
+    if (len && (*len < 1)) return NULL;
+    if (msg->size < 1) return NULL;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_GIVE;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    if (len && (msg->buffer[0] != (EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_DATA))) return NULL;
+
+    if (len) *len -= 1;
+    if (size) *size = msg->size - 1;
+    return msg->buffer + 1;
 }
 
-unsigned char *eos_cell_uart_data_buffer(uint16_t *offset) {
-    unsigned char *buffer;
+int eos_cell_uart_send(EOSMessage *msg, uint16_t len) {
+    msg->buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_DATA;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, len + 1);
+}
 
-    buffer = eos_net_alloc();
-    buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_DATA;
-    *offset = 1;
-    return buffer + *offset;
+int eos_cell_uart_send_async(EOSMessage *msg, uint16_t len, int more) {
+    msg->buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_UART_DATA;
+    return eos_net_send(EOS_NET_MTYPE_CELL, msg, len + 1, more);
 }
 
-int eos_cell_voice_dial(char *num, unsigned char *buffer, int sync) {
+int eos_cell_voice_dial(char *num, EOSMessage *msg) {
     int async;
     size_t num_len;
 
     num_len = strlen(num);
     if (num_len > EOS_CELL_SIZE_PHNUM) return EOS_ERR_SIZE;
+    if (msg->size < 1 + num_len) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_DIAL;
-    memcpy(buffer + 1, num, num_len);
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1 + num_len, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_DIAL;
+    memcpy(msg->buffer + 1, num, num_len);
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1 + num_len);
 }
 
-int eos_cell_voice_answer(unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_voice_answer(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_ANSWER;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_ANSWER;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
 
-int eos_cell_voice_hangup(unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_voice_hangup(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_HANGUP;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_HANGUP;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
 
-unsigned char *eos_cell_voice_pcm_buffer(uint16_t *offset) {
-    unsigned char *buffer;
+unsigned char *eos_cell_voice_msg2pcm(EOSMessage *msg, uint16_t *len, uint16_t *size) {
+    if (len && (*len < 1)) return NULL;
+    if (msg->size < 1) return NULL;
+
+    if (len && (msg->buffer[0] != (EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_PCM))) return NULL;
 
-    buffer = eos_net_alloc();
-    buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_PCM;
-    *offset = 1;
-    return buffer + *offset;
+    if (len) *len -= 1;
+    if (size) *size = msg->size - 1;
+    return msg->buffer + 1;
 }
 
-int eos_cell_sms_send(char *addr, char *txt, unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_voice_pcm_send(EOSMessage *msg, uint16_t len) {
+    msg->buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_PCM;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, len + 1);
+}
+
+int eos_cell_voice_pcm_send_async(EOSMessage *msg, uint16_t len, int more) {
+    msg->buffer[0] = EOS_CELL_MTYPE_VOICE | EOS_CELL_MTYPE_VOICE_PCM;
+    return eos_net_send(EOS_NET_MTYPE_CELL, msg, len + 1, more);
+}
+
+int eos_cell_sms_send(char *addr, char *txt, EOSMessage *msg) {
+    unsigned char *buffer = msg->buffer;
     size_t addr_len, txt_len;
     uint16_t len;
 
@@ -203,13 +183,8 @@ int eos_cell_sms_send(char *addr, char *txt, unsigned char *buffer, int sync) {
     txt_len = strlen(txt);
     if (addr_len > EOS_CELL_SMS_SIZE_ADDR) return EOS_ERR_SIZE;
     if (txt_len > EOS_CELL_SMS_SIZE_TXT) return EOS_ERR_SIZE;
+    if (msg->size < 5) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
     buffer[0] = EOS_CELL_MTYPE_SMS | EOS_CELL_MTYPE_SMS_MSG;
     buffer[1] = 0;
     buffer[2] = 0;
@@ -221,15 +196,25 @@ int eos_cell_sms_send(char *addr, char *txt, unsigned char *buffer, int sync) {
         buffer[3] = EOS_CELL_SMS_ADDRTYPE_OTHER;
     }
     buffer[4] = addr_len;
+
+    buffer += 5;
     len = 5;
-    memcpy(buffer + len, addr, addr_len);
+
+    if (msg->size < 5 + addr_len + txt_len) return EOS_ERR_SIZE;
+
+    memcpy(buffer, addr, addr_len);
+    buffer += addr_len;
     len += addr_len;
-    memcpy(buffer + len, txt, txt_len);
+
+    memcpy(buffer, txt, txt_len);
+    buffer += txt_len;
     len += txt_len;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, len, async, 1);
+
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, len);
 }
 
-int _eos_cell_sms_parse(unsigned char *buffer, uint16_t len, char **addr, uint16_t *addr_len, char **txt, uint16_t *txt_len) {
+int _eos_cell_sms_parse(EOSMessage *msg, uint16_t len, char **addr, uint16_t *addr_len, char **txt, uint16_t *txt_len) {
+    unsigned char *buffer = msg->buffer;
     uint16_t _addr_len;
 
     if (len < 4 + EOS_CELL_SMS_SIZE_TS) return EOS_ERR_SIZE;
@@ -257,13 +242,14 @@ int _eos_cell_sms_parse(unsigned char *buffer, uint16_t len, char **addr, uint16
     return EOS_OK;
 }
 
-int eos_cell_sms_parse(unsigned char *buffer, uint16_t len, char *addr, uint16_t addr_size, char *txt, uint16_t txt_size) {
+int eos_cell_sms_parse(EOSMessage *msg, uint16_t len, char *addr, uint16_t addr_size, char *txt, uint16_t txt_size) {
     char *_addr, *_txt;
     uint16_t _addr_len, _txt_len;
     int rv;
 
-    rv = _eos_cell_sms_parse(buffer, len, &_addr, &_addr_len, &_txt, &_txt_len);
+    rv = _eos_cell_sms_parse(msg, len, &_addr, &_addr_len, &_txt, &_txt_len);
     if (rv) return rv;
+
     if (addr_size <  _addr_len + 1) return EOS_ERR_SIZE;
     if (txt_size <  _txt_len + 1) return EOS_ERR_SIZE;
     memcpy(addr, _addr, _addr_len);
@@ -274,107 +260,89 @@ int eos_cell_sms_parse(unsigned char *buffer, uint16_t len, char *addr, uint16_t
     return EOS_OK;
 }
 
-int eos_cell_pdp_get(unsigned char atype, char *arg, uint16_t arg_size, unsigned char *buffer) {
+char *eos_cell_sms_msg2txt(EOSMessage *msg, uint16_t *len) {
+    char *txt;
+    uint16_t txt_len;
+    int rv;
+
+    rv = _eos_cell_sms_parse(msg, *len, NULL, NULL, &txt, &txt_len);
+    if (rv) return NULL;
+
+    *len = txt_len;
+    return txt;
+}
+
+int eos_cell_pdp_get(unsigned char atype, char *arg, uint16_t arg_size, EOSMessage *msg) {
     unsigned char type;
     uint16_t len;
-    int do_release;
     int rv;
 
-    do_release = 0;
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        do_release = 1;
-    }
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
     type = EOS_NET_MTYPE_CELL;
     len = 1;
-    buffer[0] = EOS_CELL_MTYPE_PDP | atype;
+    msg->buffer[0] = EOS_CELL_MTYPE_PDP | atype;
 
-    rv = eos_net_xchg(&type, buffer, &len);
-    if (rv) goto cell_pdp_get_fin;
+    rv = eos_net_xchg(&type, msg, &len);
+    if (rv) return rv;
 
-    if ((type != EOS_NET_MTYPE_CELL) || (len == 0) || (buffer[0] != EOS_CELL_MTYPE_PDP | atype)) {
-        rv = EOS_ERR_NET;
-        goto cell_pdp_get_fin;
-    }
+    if ((type != EOS_NET_MTYPE_CELL) || (len < 1) || (msg->buffer[0] != EOS_CELL_MTYPE_PDP | atype)) return EOS_ERR_NET;
 
     len--;
-    if ((len > EOS_CELL_PDP_SIZE_ARG) || (len > arg_size - 1)) {
-        rv = EOS_ERR_SIZE;
-        goto cell_pdp_get_fin;
-    }
-    memcpy(buffer + 1, arg, len);
+    if ((len > EOS_CELL_PDP_SIZE_ARG) || (len > arg_size - 1)) return EOS_ERR_SIZE;
+
+    memcpy(msg->buffer + 1, arg, len);
     arg[len] = '\0';
 
-cell_pdp_get_fin:
-    if (do_release) eos_net_free(buffer, 1);
-    return rv;
+    return EOS_OK;
 }
 
-int eos_cell_pdp_set(unsigned char atype, char *arg, unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_pdp_set(unsigned char atype, char *arg, EOSMessage *msg) {
     size_t arg_len;
 
     arg_len = strlen(arg);
     if (arg_len > EOS_CELL_PDP_SIZE_ARG) return EOS_ERR_SIZE;
+    if (msg->size < 1 + arg_len) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_PDP | atype;
-    memcpy(buffer + 1, arg, arg_len);
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1 + arg_len, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_PDP | atype;
+    memcpy(msg->buffer + 1, arg, arg_len);
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1 + arg_len);
 }
 
-int eos_cell_pdp_get_apn(char *apn, uint16_t apn_size, unsigned char *buffer) {
-    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_APN, apn, apn_size, buffer);
+int eos_cell_pdp_get_apn(char *apn, uint16_t apn_size, EOSMessage *msg) {
+    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_APN, apn, apn_size, msg);
 }
 
-int eos_cell_pdp_set_apn(char *apn, unsigned char *buffer, int sync) {
-    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_APN, apn, buffer, sync);
+int eos_cell_pdp_set_apn(char *apn, EOSMessage *msg) {
+    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_APN, apn, msg);
 }
 
-int eos_cell_pdp_get_usr(char *usr, uint16_t usr_size, unsigned char *buffer) {
-    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_USR, usr, usr_size, buffer);
+int eos_cell_pdp_get_usr(char *usr, uint16_t usr_size, EOSMessage *msg) {
+    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_USR, usr, usr_size, msg);
 }
 
-int eos_cell_pdp_set_usr(char *usr, unsigned char *buffer, int sync) {
-    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_USR, usr, buffer, sync);
+int eos_cell_pdp_set_usr(char *usr, EOSMessage *msg) {
+    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_USR, usr, msg);
 }
 
-int eos_cell_pdp_get_pwd(char *pwd, uint16_t pwd_size, unsigned char *buffer) {
-    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_PWD, pwd, pwd_size, buffer);
+int eos_cell_pdp_get_pwd(char *pwd, uint16_t pwd_size, EOSMessage *msg) {
+    return eos_cell_pdp_get(EOS_CELL_MTYPE_PDP_GET_PWD, pwd, pwd_size, msg);
 }
 
-int eos_cell_pdp_set_pwd(char *pwd, unsigned char *buffer, int sync) {
-    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_PWD, pwd, buffer, sync);
+int eos_cell_pdp_set_pwd(char *pwd, EOSMessage *msg) {
+    return eos_cell_pdp_set(EOS_CELL_MTYPE_PDP_SET_PWD, pwd, msg);
 }
 
-int eos_cell_pdp_connect(unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_pdp_connect(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_PDP | EOS_CELL_MTYPE_PDP_CONNECT;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_PDP | EOS_CELL_MTYPE_PDP_CONNECT;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
 
-int eos_cell_pdp_disconnect(unsigned char *buffer, int sync) {
-    int async;
+int eos_cell_pdp_disconnect(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_CELL_MTYPE_PDP | EOS_CELL_MTYPE_PDP_DISCONNECT;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_CELL_MTYPE_PDP | EOS_CELL_MTYPE_PDP_DISCONNECT;
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, 1);
 }
diff --git a/fw/fe310/eos/net/cell.h b/fw/fe310/eos/net/cell.h
index ac334e9..9517d8e 100644
--- a/fw/fe310/eos/net/cell.h
+++ b/fw/fe310/eos/net/cell.h
@@ -1,4 +1,5 @@
 #include <stdint.h>
+
 #include "../event.h"
 
 #define EOS_CELL_MTYPE_DEV              0x10
@@ -27,7 +28,6 @@
 #define EOS_CELL_MTYPE_VOICE_END        7
 #define EOS_CELL_MTYPE_VOICE_MISS       8
 #define EOS_CELL_MTYPE_VOICE_BUSY       9
-#define EOS_CELL_MTYPE_VOICE_ERR        10
 
 #define EOS_CELL_MTYPE_SMS_MSG          1
 #define EOS_CELL_MTYPE_SMS_LIST         2
@@ -71,30 +71,35 @@
 void eos_cell_init(void);
 void eos_cell_set_handler(unsigned char mtype, eos_evt_handler_t handler);
 eos_evt_handler_t eos_cell_get_handler(unsigned char mtype);
-int eos_cell_send_buffer(unsigned char *buffer, uint16_t buf_len, uint16_t offset, int sync);
-
-int eos_cell_status_parse(unsigned char *buffer, uint16_t len, uint8_t *status, uint8_t *connected);
-int eos_cell_status(uint8_t *status, uint8_t *connected, unsigned char *buffer);
-
-int eos_cell_uart_take(unsigned char *buffer, int sync);
-int eos_cell_uart_give(unsigned char *buffer, int sync);
-unsigned char *eos_cell_uart_data_buffer(uint16_t *offset);
-
-int eos_cell_voice_dial(char *num, unsigned char *buffer, int sync);
-int eos_cell_voice_answer(unsigned char *buffer, int sync);
-int eos_cell_voice_hangup(unsigned char *buffer, int sync);
-unsigned char *eos_cell_voice_pcm_buffer(uint16_t *offset);
-int eos_cell_sms_send(char *addr, char *txt, unsigned char *buffer, int sync);
-int _eos_cell_sms_parse(unsigned char *buffer, uint16_t len, char **addr, uint16_t *addr_len, char **txt, uint16_t *txt_len);
-int eos_cell_sms_parse(unsigned char *buffer, uint16_t len, char *addr, uint16_t addr_size, char *txt, uint16_t txt_size);
-
-int eos_cell_pdp_get(unsigned char atype, char *arg, uint16_t arg_size, unsigned char *buffer);
-int eos_cell_pdp_set(unsigned char atype, char *arg, unsigned char *buffer, int sync);
-int eos_cell_pdp_get_apn(char *apn, uint16_t apn_size, unsigned char *buffer);
-int eos_cell_pdp_set_apn(char *apn, unsigned char *buffer, int sync);
-int eos_cell_pdp_get_usr(char *usr, uint16_t usr_size, unsigned char *buffer);
-int eos_cell_pdp_set_usr(char *usr, unsigned char *buffer, int sync);
-int eos_cell_pdp_get_pwd(char *pwd, uint16_t pwd_size, unsigned char *buffer);
-int eos_cell_pdp_set_pwd(char *pwd, unsigned char *buffer, int sync);
-int eos_cell_pdp_connect(unsigned char *buffer, int sync);
-int eos_cell_pdp_disconnect(unsigned char *buffer, int sync);
+
+int eos_cell_status_parse(EOSMessage *msg, uint16_t len, uint8_t *status, uint8_t *connected);
+int eos_cell_status(uint8_t *status, uint8_t *connected, EOSMessage *msg);
+
+int eos_cell_uart_take(EOSMessage *msg);
+int eos_cell_uart_give(EOSMessage *msg);
+unsigned char *eos_cell_uart_msg2data(EOSMessage *msg, uint16_t *len, uint16_t *size);
+int eos_cell_uart_send(EOSMessage *msg, uint16_t len);
+int eos_cell_uart_send_async(EOSMessage *msg, uint16_t len, int more);
+
+int eos_cell_voice_dial(char *num, EOSMessage *msg);
+int eos_cell_voice_answer(EOSMessage *msg);
+int eos_cell_voice_hangup(EOSMessage *msg);
+unsigned char *eos_cell_voice_msg2pcm(EOSMessage *msg, uint16_t *len, uint16_t *size);
+int eos_cell_voice_pcm_send(EOSMessage *msg, uint16_t len);
+int eos_cell_voice_pcm_send_async(EOSMessage *msg, uint16_t len, int more);
+
+int eos_cell_sms_send(char *addr, char *txt, EOSMessage *msg);
+int _eos_cell_sms_parse(EOSMessage *msg, uint16_t len, char **addr, uint16_t *addr_len, char **txt, uint16_t *txt_len);
+int eos_cell_sms_parse(EOSMessage *msg, uint16_t len, char *addr, uint16_t addr_size, char *txt, uint16_t txt_size);
+char *eos_cell_sms_msg2txt(EOSMessage *msg, uint16_t *len);
+
+int eos_cell_pdp_get(unsigned char atype, char *arg, uint16_t arg_size, EOSMessage *msg);
+int eos_cell_pdp_set(unsigned char atype, char *arg, EOSMessage *msg);
+int eos_cell_pdp_get_apn(char *apn, uint16_t apn_size, EOSMessage *msg);
+int eos_cell_pdp_set_apn(char *apn, EOSMessage *msg);
+int eos_cell_pdp_get_usr(char *usr, uint16_t usr_size, EOSMessage *msg);
+int eos_cell_pdp_set_usr(char *usr, EOSMessage *msg);
+int eos_cell_pdp_get_pwd(char *pwd, uint16_t pwd_size, EOSMessage *msg);
+int eos_cell_pdp_set_pwd(char *pwd, EOSMessage *msg);
+int eos_cell_pdp_connect(EOSMessage *msg);
+int eos_cell_pdp_disconnect(EOSMessage *msg);
diff --git a/fw/fe310/eos/net/pwr.c b/fw/fe310/eos/net/pwr.c
deleted file mode 100644
index 308a05a..0000000
--- a/fw/fe310/eos/net/pwr.c
+++ /dev/null
@@ -1,80 +0,0 @@
-#include <stdlib.h>
-#include <stdint.h>
-
-#include "eos.h"
-#include "event.h"
-#include "dev/net.h"
-
-#include "soc/pwr.h"
-#include "soc/spi.h"
-#include "dev/spi.h"
-#include "dev/net.h"
-#include "dev/lcd.h"
-#include "eve/eve.h"
-#include "dev/flash.h"
-
-#include "pwr.h"
-
-static eos_evt_handler_t evt_handler[EOS_PWR_MAX_MTYPE];
-static unsigned char power_btn_down;
-
-static void pwr_handle_msg(unsigned char type, unsigned char *buffer, uint16_t len) {
-    unsigned char mtype;
-
-    if ((buffer == NULL) || (len < 1)) {
-        eos_net_bad_handler(type, buffer, len);
-        return;
-    }
-
-    mtype = buffer[0];
-    if ((mtype < EOS_PWR_MAX_MTYPE) && evt_handler[mtype]) {
-        evt_handler[mtype](mtype, buffer, len);
-    } else {
-        eos_net_bad_handler(type, buffer, len);
-    }
-}
-
-static void pwr_handle_btn(unsigned char type, unsigned char *buffer, uint16_t len) {
-    int rv;
-    unsigned char level = buffer[1];
-
-    eos_net_free(buffer, 0);
-    if (!level) {
-        power_btn_down = 1;
-        return;
-    }
-    if (!power_btn_down) return;
-
-    rv = eos_lcd_sleep();
-
-    rv = eos_spi_select(EOS_SPI_DEV_EVE);
-    if (!rv) {
-        eve_pwr_sleep();
-        eos_spi_deselect();
-    }
-
-    rv = eos_net_sleep(1000);
-
-    eos_flash_norm();
-
-    eos_pwr_sleep();
-}
-
-void eos_pwr_net_init(void) {
-    int i;
-
-    for (i=0; i<EOS_PWR_MAX_MTYPE; i++) {
-        evt_handler[i] = NULL;
-    }
-    eos_net_set_handler(EOS_NET_MTYPE_POWER, pwr_handle_msg);
-    eos_pwr_set_handler(EOS_PWR_MTYPE_BUTTON, pwr_handle_btn);
-}
-
-void eos_pwr_set_handler(unsigned char mtype, eos_evt_handler_t handler) {
-    if (mtype < EOS_PWR_MAX_MTYPE) evt_handler[mtype] = handler;
-}
-
-eos_evt_handler_t eos_pwr_get_handler(unsigned char mtype) {
-    if (mtype < EOS_PWR_MAX_MTYPE) return evt_handler[mtype];
-    return NULL;
-}
diff --git a/fw/fe310/eos/net/pwr.h b/fw/fe310/eos/net/pwr.h
deleted file mode 100644
index b82a96b..0000000
--- a/fw/fe310/eos/net/pwr.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdint.h>
-#include "../event.h"
-
-#define EOS_PWR_MTYPE_BUTTON    1
-
-#define EOS_PWR_MAX_MTYPE       2
-
-void eos_pwr_net_init(void);
-void eos_pwr_set_handler(unsigned char mtype, eos_evt_handler_t handler);
-eos_evt_handler_t eos_pwr_get_handler(unsigned char mtype);
diff --git a/fw/fe310/eos/net/rng.c b/fw/fe310/eos/net/rng.c
index 7d05a81..414a6fa 100644
--- a/fw/fe310/eos/net/rng.c
+++ b/fw/fe310/eos/net/rng.c
@@ -2,26 +2,34 @@
 #include <stdint.h>
 #include <string.h>
 
+#include "eos.h"
+#include "event.h"
 #include "dev/net.h"
 
 int getentropy(unsigned char *b, size_t sz) {
     unsigned char type;
-    unsigned char *buffer;
+    EOSMessage msg;
     uint16_t len;
     int rv;
 
-    buffer = eos_net_alloc();
-
     type = EOS_NET_MTYPE_RNG;
     len = sizeof(uint16_t);
-    buffer[0] = sz >> 8;
-    buffer[1] = sz;
 
-    rv = eos_net_xchg(&type, buffer, &len);
+    eos_net_alloc(&msg);
+
+    if ((msg.size < len) || (msg.size < sz)) {
+        eos_net_free(&msg, 1);
+        return -1;
+    }
+
+    msg.buffer[0] = sz >> 8;
+    msg.buffer[1] = sz;
+
+    rv = eos_net_xchg(&type, &msg, &len);
     if (rv || (len != sz)) rv = -1;
 
-    if (!rv) memcpy(b, buffer, sz);
-    eos_net_free(buffer, 1);
+    if (!rv) memcpy(b, msg.buffer, sz);
+    eos_net_free(&msg, 1);
 
     return rv;
 }
diff --git a/fw/fe310/eos/net/sock.c b/fw/fe310/eos/net/sock.c
index c9934e8..0c2f07d 100644
--- a/fw/fe310/eos/net/sock.c
+++ b/fw/fe310/eos/net/sock.c
@@ -10,26 +10,41 @@
 
 static eos_evt_handler_t evt_handler[EOS_SOCK_MAX_SOCK];
 
-static void sock_handle_msg(unsigned char type, unsigned char *buffer, uint16_t len) {
+static void sock_handle_msg(unsigned char type, EOSMessage *msg, uint16_t len) {
     unsigned char sock;
+    int i;
 
-    if ((buffer == NULL) || (len < 2)) {
-        eos_net_bad_handler(type, buffer, len);
-        return;
-    }
-
-    sock = buffer[1];
-    if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK) || (evt_handler[sock - 1] == NULL)) {
-        eos_net_bad_handler(type, buffer, len);
+    if ((msg == NULL) || (len < 2)) {
+        eos_net_bad_handler(type, msg, len);
         return;
     }
 
-    switch(buffer[0]) {
-        case EOS_SOCK_MTYPE_PKT:
-            evt_handler[sock - 1](type, buffer, len);
+    switch(msg->buffer[0]) {
+        case EOS_SOCK_MTYPE_PKT: {
+            sock = msg->buffer[1];
+            if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK) || (evt_handler[sock - 1] == NULL)) {
+                eos_net_bad_handler(type, msg, len);
+                return;
+            }
+            evt_handler[sock - 1](type, msg, len);
             break;
+        }
+
+        case EOS_SOCK_MTYPE_CLOSE: {
+            for (i=1; i<len; i++) {
+                sock = msg->buffer[i];
+                if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK) || (evt_handler[sock - 1] == NULL)) {
+                    eos_net_bad_handler(type, msg, len);
+                    continue;
+                }
+                evt_handler[sock - 1](type, msg, len);
+                evt_handler[sock - 1] = NULL;
+            }
+            break;
+        }
+
         default:
-            eos_net_bad_handler(type, buffer, len);
+            eos_net_bad_handler(type, msg, len);
             break;
     }
 }
@@ -52,63 +67,44 @@ eos_evt_handler_t eos_sock_get_handler(unsigned char sock) {
     return NULL;
 }
 
-int eos_sock_open_udp(eos_evt_handler_t handler, unsigned char *buffer) {
+int eos_sock_open_udp(eos_evt_handler_t handler, EOSMessage *msg) {
     unsigned char type;
     uint16_t len;
-    int do_release;
     int rv, sock;
 
-    do_release = 0;
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        do_release = 1;
-    }
+    if (msg->size < 2) return EOS_ERR_SIZE;
 
     type = EOS_NET_MTYPE_SOCK;
     len = 1;
-    buffer[0] = EOS_SOCK_MTYPE_OPEN_DGRAM;
+    msg->buffer[0] = EOS_SOCK_MTYPE_OPEN_DGRAM;
 
-    rv = eos_net_xchg(&type, buffer, &len);
-    if (rv) goto sock_open_udp_fin;
+    rv = eos_net_xchg(&type, msg, &len);
+    if (rv) return rv;
 
-    if (type != EOS_NET_MTYPE_SOCK) {
-        rv = EOS_ERR_NET;
-        goto sock_open_udp_fin;
-    }
-    if (len < 2) {
-        rv = EOS_ERR_SIZE;
-        goto sock_open_udp_fin;
-    }
+    if (type != EOS_NET_MTYPE_SOCK) return EOS_ERR_NET;
+    if (len < 2) return EOS_ERR_SIZE;
 
-    sock = buffer[1];
-    if (sock == 0) {
-        rv = EOS_ERR_NET;
-        goto sock_open_udp_fin;
-    }
+    sock = msg->buffer[1];
+    if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK)) return EOS_ERR_NET;
 
-    rv = sock;
     eos_sock_set_handler(sock, handler);
-
-sock_open_udp_fin:
-    if (do_release) eos_net_free(buffer, 1);
-    return rv;
+    return sock;
 }
 
-void eos_sock_close(unsigned char sock, unsigned char *buffer) {
-    int async;
+void eos_sock_close(unsigned char sock, EOSMessage *msg) {
+    if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK)) return;
+    if (msg->size < 2) return;
 
-    async = 0;
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    }
-    buffer[0] = EOS_SOCK_MTYPE_CLOSE;
-    buffer[1] = sock;
-    _eos_net_send(EOS_NET_MTYPE_SOCK, buffer, 2, async, 1);
+    msg->buffer[0] = EOS_SOCK_MTYPE_CLOSE;
+    msg->buffer[1] = sock;
+    eos_net_send_sync(EOS_NET_MTYPE_SOCK, msg, 2);
     eos_sock_set_handler(sock, NULL);
 }
 
-static int sock_send(unsigned char sock, unsigned char *msg, uint16_t msg_len, EOSNetAddr *addr, unsigned char *buffer) {
+static void sock_sendto(unsigned char sock, EOSNetAddr *addr, EOSMessage *msg) {
+    unsigned char *buffer;
+
+    buffer = msg->buffer;
     buffer[0] = EOS_SOCK_MTYPE_PKT;
     buffer[1] = sock;
     buffer += 2;
@@ -117,47 +113,60 @@ static int sock_send(unsigned char sock, unsigned char *msg, uint16_t msg_len, E
     buffer[0] = addr->port >> 8;
     buffer[1] = addr->port;
     buffer += sizeof(addr->port);
-    if (msg) {
-        if (msg_len + EOS_SOCK_SIZE_UDP_HDR > EOS_NET_SIZE_BUF) return EOS_ERR_SIZE;
-        memcpy(buffer, msg, msg_len);
-    }
-
-    return EOS_OK;
 }
 
-int eos_sock_sendto(unsigned char sock, unsigned char *msg, size_t msg_len, EOSNetAddr *addr, unsigned char *buffer) {
-    int rv;
-
-    rv = sock_send(sock, msg, msg_len, addr, buffer);
-    if (rv) return rv;
+int eos_sock_sendto(unsigned char sock, EOSNetAddr *addr, EOSMessage *msg, uint16_t pkt_len) {
+    if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK)) return EOS_ERR_NET;
 
-    return eos_net_send(EOS_NET_MTYPE_SOCK, buffer, msg_len + EOS_SOCK_SIZE_UDP_HDR);
+    sock_sendto(sock, addr, msg);
+    return eos_net_send_sync(EOS_NET_MTYPE_SOCK, msg, pkt_len + EOS_SOCK_SIZE_UDP_HDR);
 }
 
-int eos_sock_sendto_async(unsigned char sock, unsigned char *msg, size_t msg_len, EOSNetAddr *addr, unsigned char *buffer, unsigned char more) {
-    int rv;
+int eos_sock_sendto_async(unsigned char sock, EOSNetAddr *addr, EOSMessage *msg, uint16_t pkt_len, int more) {
+    if ((sock == 0) || (sock > EOS_SOCK_MAX_SOCK)) return EOS_ERR_NET;
 
-    rv = sock_send(sock, msg, msg_len, addr, buffer);
-    if (rv) return rv;
-
-    return eos_net_send_async(EOS_NET_MTYPE_SOCK, buffer, msg_len + EOS_SOCK_SIZE_UDP_HDR, more);
+    sock_sendto(sock, addr, msg);
+    return eos_net_send(EOS_NET_MTYPE_SOCK, msg, pkt_len + EOS_SOCK_SIZE_UDP_HDR, more);
 }
 
-int eos_sock_recvfrom(unsigned char *buffer, uint16_t len, unsigned char *msg, size_t msg_size, EOSNetAddr *addr) {
+int eos_sock_recvfrom(EOSMessage *msg, uint16_t len, EOSNetAddr *addr, unsigned char *pkt, size_t pkt_size) {
+    char *buffer = msg->buffer;
+
     if (len < EOS_SOCK_SIZE_UDP_HDR) return EOS_ERR_SIZE;
 
+    if (buffer[0] == EOS_SOCK_MTYPE_CLOSE) return EOS_SOCK_ERR_CLOSED;
     if (buffer[0] != EOS_SOCK_MTYPE_PKT) return EOS_ERR_NET;
 
     buffer += 2;
-    memcpy(addr->host, buffer, sizeof(addr->host));
+    if (addr) {
+        memcpy(addr->host, buffer, sizeof(addr->host));
+    }
     buffer += sizeof(addr->host);
-    addr->port  = (uint16_t)buffer[0] << 8;
-    addr->port |= (uint16_t)buffer[1];
+    if (addr) {
+        addr->port  = (uint16_t)buffer[0] << 8;
+        addr->port |= (uint16_t)buffer[1];
+    }
     buffer += sizeof(addr->port);
-    if (msg) {
-        if (msg_size < len - EOS_SOCK_SIZE_UDP_HDR) return EOS_ERR_SIZE;
-        memcpy(msg, buffer, len - EOS_SOCK_SIZE_UDP_HDR);
+    if (pkt) {
+        if (pkt_size < len - EOS_SOCK_SIZE_UDP_HDR) return EOS_ERR_SIZE;
+        memcpy(pkt, buffer, len - EOS_SOCK_SIZE_UDP_HDR);
     }
 
     return EOS_OK;
 }
+
+unsigned char *eos_sock_msg2pkt(EOSMessage *msg, uint16_t *len, uint16_t *pkt_size) {
+    if (len && (*len < EOS_SOCK_SIZE_UDP_HDR)) return NULL;
+    if (msg->size < EOS_SOCK_SIZE_UDP_HDR) return NULL;
+
+    if (len && (msg->buffer[0] != EOS_SOCK_MTYPE_PKT)) return NULL;
+
+    if (len) *len -= EOS_SOCK_SIZE_UDP_HDR;
+    if (pkt_size) *pkt_size = msg->size - EOS_SOCK_SIZE_UDP_HDR;
+    return msg->buffer + EOS_SOCK_SIZE_UDP_HDR;
+}
+
+void eos_sock_pkt2msg(EOSMessage *msg, unsigned char *pkt, uint16_t pkt_size) {
+    msg->buffer = pkt - EOS_SOCK_SIZE_UDP_HDR;
+    msg->size = pkt_size + EOS_SOCK_SIZE_UDP_HDR;
+}
diff --git a/fw/fe310/eos/net/sock.h b/fw/fe310/eos/net/sock.h
index e2f8637..e873a7d 100644
--- a/fw/fe310/eos/net/sock.h
+++ b/fw/fe310/eos/net/sock.h
@@ -1,4 +1,5 @@
 #include <stdint.h>
+
 #include "../event.h"
 
 #define EOS_SOCK_MTYPE_PKT          0
@@ -11,6 +12,8 @@
 
 #define EOS_IPv4_ADDR_SIZE          4
 
+#define EOS_SOCK_ERR_CLOSED         -1021
+
 typedef struct EOSNetAddr {
     unsigned char host[EOS_IPv4_ADDR_SIZE];
     uint16_t port;
@@ -20,9 +23,12 @@ void eos_sock_init(void);
 void eos_sock_set_handler(unsigned char sock, eos_evt_handler_t handler);
 eos_evt_handler_t eos_sock_get_handler(unsigned char sock);
 
-int eos_sock_open_udp(eos_evt_handler_t handler, unsigned char *buffer);
-void eos_sock_close(unsigned char sock, unsigned char *buffer);
+int eos_sock_open_udp(eos_evt_handler_t handler, EOSMessage *msg);
+void eos_sock_close(unsigned char sock, EOSMessage *msg);
+
+int eos_sock_sendto(unsigned char sock, EOSNetAddr *addr, EOSMessage *msg, uint16_t pkt_len);
+int eos_sock_sendto_async(unsigned char sock, EOSNetAddr *addr, EOSMessage *msg, uint16_t pkt_len, int more);
+int eos_sock_recvfrom(EOSMessage *msg, uint16_t len, EOSNetAddr *addr, unsigned char *pkt, size_t pkt_size);
 
-int eos_sock_sendto(unsigned char sock, unsigned char *msg, size_t msg_len, EOSNetAddr *addr, unsigned char *buffer);
-int eos_sock_sendto_async(unsigned char sock, unsigned char *msg, size_t msg_len, EOSNetAddr *addr, unsigned char *buffer, unsigned char more);
-int eos_sock_recvfrom(unsigned char *buffer, uint16_t len, unsigned char *msg, size_t msg_size, EOSNetAddr *addr);
+unsigned char *eos_sock_msg2pkt(EOSMessage *msg, uint16_t *len, uint16_t *pkt_size);
+void eos_sock_pkt2msg(EOSMessage *msg, unsigned char *pkt, uint16_t pkt_size);
diff --git a/fw/fe310/eos/net/wifi.c b/fw/fe310/eos/net/wifi.c
index ebbb9ca..59f149c 100644
--- a/fw/fe310/eos/net/wifi.c
+++ b/fw/fe310/eos/net/wifi.c
@@ -10,19 +10,19 @@
 
 static eos_evt_handler_t evt_handler[EOS_WIFI_MAX_MTYPE];
 
-static void wifi_handle_msg(unsigned char type, unsigned char *buffer, uint16_t len) {
+static void wifi_handle_msg(unsigned char type, EOSMessage *msg, uint16_t len) {
     unsigned char mtype;
 
-    if ((buffer == NULL) || (len < 1)) {
-        eos_net_bad_handler(type, buffer, len);
+    if ((msg == NULL) || (len < 1)) {
+        eos_net_bad_handler(type, msg, len);
         return;
     }
 
-    mtype = buffer[0];
+    mtype = msg->buffer[0];
     if ((mtype < EOS_WIFI_MAX_MTYPE) && evt_handler[mtype]) {
-        evt_handler[mtype](mtype, buffer, len);
+        evt_handler[mtype](mtype, msg, len);
     } else {
-        eos_net_bad_handler(type, buffer, len);
+        eos_net_bad_handler(type, msg, len);
     }
 }
 
@@ -44,7 +44,9 @@ eos_evt_handler_t eos_wifi_get_handler(unsigned char mtype) {
     return NULL;
 }
 
-int eos_wifi_status_parse(unsigned char *buffer, uint16_t len, uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size) {
+int eos_wifi_status_parse(EOSMessage *msg, uint16_t len, uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size) {
+    unsigned char *buffer = msg->buffer;
+
     if (len < 2) return EOS_ERR_SIZE;
 
     if (buffer[0] != EOS_WIFI_MTYPE_STATUS) return EOS_ERR_NET;
@@ -72,119 +74,86 @@ int eos_wifi_status_parse(unsigned char *buffer, uint16_t len, uint8_t *status,
     return EOS_OK;
 }
 
-int eos_wifi_status(uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size, unsigned char *buffer) {
+int eos_wifi_status(uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size, EOSMessage *msg) {
     unsigned char type;
     uint16_t len;
-    int do_release;
     int rv;
 
-    do_release = 0;
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        do_release = 1;
-    }
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
     type = EOS_NET_MTYPE_WIFI;
     len = 1;
-    buffer[0] = EOS_WIFI_MTYPE_STATUS;
+    msg->buffer[0] = EOS_WIFI_MTYPE_STATUS;
 
-    rv = eos_net_xchg(&type, buffer, &len);
-    if (rv) goto wifi_status_fin;
+    rv = eos_net_xchg(&type, msg, &len);
+    if (rv) return rv;
 
-    if (type != EOS_NET_MTYPE_WIFI) {
-        rv = EOS_ERR_NET;
-        goto wifi_status_fin;
-    }
-    rv = eos_wifi_status_parse(buffer, len, status, ip_addr, ssid, ssid_size);
+    if (type != EOS_NET_MTYPE_WIFI) return EOS_ERR_NET;
 
-wifi_status_fin:
-    if (do_release) eos_net_free(buffer, 1);
-    return rv;
+    return eos_wifi_status_parse(msg, len, status, ip_addr, ssid, ssid_size);
 }
 
-int eos_wifi_start(unsigned char *buffer, int sync) {
-    int async;
+int eos_wifi_start(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_WIFI_MTYPE_START;
-    return _eos_net_send(EOS_NET_MTYPE_WIFI, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_WIFI_MTYPE_START;
+    return eos_net_send_sync(EOS_NET_MTYPE_WIFI, msg, 1);
 }
 
-int eos_wifi_stop(unsigned char *buffer, int sync) {
-    int async;
+int eos_wifi_stop(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_WIFI_MTYPE_STOP;
-    return _eos_net_send(EOS_NET_MTYPE_WIFI, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_WIFI_MTYPE_STOP;
+    return eos_net_send_sync(EOS_NET_MTYPE_WIFI, msg, 1);
 }
 
-int eos_wifi_scan(unsigned char *buffer, int sync) {
-    int async;
+int eos_wifi_scan(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_WIFI_MTYPE_SCAN;
-    return _eos_net_send(EOS_NET_MTYPE_WIFI, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_WIFI_MTYPE_SCAN;
+    return eos_net_send_sync(EOS_NET_MTYPE_WIFI, msg, 1);
+}
+
+unsigned char *eos_wifi_scan2data(EOSMessage *msg, uint16_t *len) {
+    if (*len < 1) return NULL;
+
+    if (msg->buffer[0] != EOS_WIFI_MTYPE_SCAN) return NULL;
+
+    if (len) *len -= 1;
+    return msg->buffer + 1;
 }
 
-int eos_wifi_connect(char *ssid, char *pwd, unsigned char *buffer, int sync) {
-    unsigned char *buf;
+int eos_wifi_connect(char *ssid, char *pwd, EOSMessage *msg) {
+    unsigned char *buffer = msg->buffer;
     size_t ssid_len, pwd_len;
-    int async;
 
     ssid_len = strlen(ssid);
     pwd_len = strlen(pwd);
     if (ssid_len > EOS_WIFI_SIZE_SSID) return EOS_ERR_SIZE;
     if (pwd_len > EOS_WIFI_SIZE_PWD) return EOS_ERR_SIZE;
+    if (msg->size < 3 + ssid_len + pwd_len) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buf = buffer;
-    buf[0] = EOS_WIFI_MTYPE_CONNECT;
-    buf++;
+    buffer[0] = EOS_WIFI_MTYPE_CONNECT;
+    buffer++;
 
-    *buf = ssid_len;
-    buf++;
+    *buffer = ssid_len;
+    buffer++;
 
-    memcpy(buf, ssid, ssid_len);
-    buf += ssid_len;
+    memcpy(buffer, ssid, ssid_len);
+    buffer += ssid_len;
 
-    *buf = pwd_len;
-    buf++;
+    *buffer = pwd_len;
+    buffer++;
 
-    memcpy(buf, pwd, pwd_len);
-    buf += pwd_len;
+    memcpy(buffer, pwd, pwd_len);
+    buffer += pwd_len;
 
-    return _eos_net_send(EOS_NET_MTYPE_WIFI, buffer, 3 + ssid_len + pwd_len, async, 1);
+    return eos_net_send_sync(EOS_NET_MTYPE_WIFI, msg, 3 + ssid_len + pwd_len);
 }
 
-int eos_wifi_disconnect(unsigned char *buffer, int sync) {
-    int async;
+int eos_wifi_disconnect(EOSMessage *msg) {
+    if (msg->size < 1) return EOS_ERR_SIZE;
 
-    if (buffer == NULL) {
-        buffer = eos_net_alloc();
-        async = 1;
-    } else {
-        async = !sync;
-    }
-    buffer[0] = EOS_WIFI_MTYPE_DISCONNECT;
-    return _eos_net_send(EOS_NET_MTYPE_WIFI, buffer, 1, async, 1);
+    msg->buffer[0] = EOS_WIFI_MTYPE_DISCONNECT;
+    return eos_net_send_sync(EOS_NET_MTYPE_WIFI, msg, 1);
 }
diff --git a/fw/fe310/eos/net/wifi.h b/fw/fe310/eos/net/wifi.h
index 93d2fc4..1f64d73 100644
--- a/fw/fe310/eos/net/wifi.h
+++ b/fw/fe310/eos/net/wifi.h
@@ -1,4 +1,5 @@
 #include <stdint.h>
+
 #include "../event.h"
 
 #define EOS_WIFI_MTYPE_STATUS           0
@@ -24,10 +25,11 @@ void eos_wifi_init(void);
 void eos_wifi_set_handler(unsigned char mtype, eos_evt_handler_t handler);
 eos_evt_handler_t eos_wifi_get_handler(unsigned char mtype);
 
-int eos_wifi_status_parse(unsigned char *buffer, uint16_t len, uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size);
-int eos_wifi_status(uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size, unsigned char *buffer);
-int eos_wifi_start(unsigned char *buffer, int sync);
-int eos_wifi_stop(unsigned char *buffer, int sync);
-int eos_wifi_scan(unsigned char *buffer, int sync);
-int eos_wifi_connect(char *ssid, char *pwd, unsigned char *buffer, int sync);
-int eos_wifi_disconnect(unsigned char *buffer, int sync);
\ No newline at end of file
+int eos_wifi_status_parse(EOSMessage *msg, uint16_t len, uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size);
+int eos_wifi_status(uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size, EOSMessage *msg);
+int eos_wifi_start(EOSMessage *msg);
+int eos_wifi_stop(EOSMessage *msg);
+int eos_wifi_scan(EOSMessage *msg);
+unsigned char *eos_wifi_scan2data(EOSMessage *msg, uint16_t *len);
+int eos_wifi_connect(char *ssid, char *pwd, EOSMessage *msg);
+int eos_wifi_disconnect(EOSMessage *msg);