1 files changed, 159 insertions, 191 deletions

diff --git a/fw/fe310/eos/net/cell.c b/fw/fe310/eos/net/cell.c
index c0c77af..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 buf_len) {
+static void cell_handle_msg(unsigned char type, EOSMessage *msg, uint16_t len) {
     unsigned char mtype;
     unsigned char idx;
 
-    if ((buffer == NULL) || (buf_len < 1)) {
-        eos_net_bad_handler(type, buffer, buf_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, buf_len);
+        evt_handler[idx](mtype & ~EOS_CELL_MTYPE_MASK, msg, len);
     } else {
-        eos_net_bad_handler(type, buffer, buf_len);
+        eos_net_bad_handler(type, msg, len);
     }
 }
 
@@ -50,166 +50,141 @@ 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(EOS_NET_MTYPE_CELL, buffer, buf_len + offset, !sync, 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 buf_len, uint8_t *status, uint8_t *connected) {
-    if (buf_len < 2) return EOS_ERR_SIZE;
+    if (len < 2) return EOS_ERR_SIZE;
 
     if (buffer[0] != (EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_STATUS)) return EOS_ERR_NET;
     buffer++;
-    buf_len--;
+    len--;
 
     *status = buffer[0];
     buffer++;
-    buf_len--;
+    len--;
 
     if (*status == EOS_CELL_STATUS_PPP) {
-        if (buf_len < 1) return EOS_ERR_SIZE;
+        if (len < 1) return EOS_ERR_SIZE;
         if (connected) *connected = buffer[0];
         buffer++;
-        buf_len--;
+        len--;
     }
     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 buf_len;
-    int do_release;
+    uint16_t len;
     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;
-    buf_len = 1;
-    buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_STATUS;
+    len = 1;
+    msg->buffer[0] = EOS_CELL_MTYPE_DEV | EOS_CELL_MTYPE_STATUS;
 
-    rv = eos_net_xchg(&type, buffer, &buf_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, buf_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_alloc(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_alloc(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 buf_len;
+    uint16_t len;
 
     addr_len = strlen(addr);
     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,49 +196,60 @@ 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;
-    buf_len = 5;
-    memcpy(buffer + buf_len, addr, addr_len);
-    buf_len += addr_len;
-    memcpy(buffer + buf_len, txt, txt_len);
-    buf_len += txt_len;
-    return _eos_net_send(EOS_NET_MTYPE_CELL, buffer, buf_len, async, 1);
+
+    buffer += 5;
+    len = 5;
+
+    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, txt, txt_len);
+    buffer += txt_len;
+    len += txt_len;
+
+    return eos_net_send_sync(EOS_NET_MTYPE_CELL, msg, len);
 }
 
-int _eos_cell_sms_parse(unsigned char *buffer, uint16_t buf_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 (buf_len < 4 + EOS_CELL_SMS_SIZE_TS) return EOS_ERR_SIZE;
+    if (len < 4 + EOS_CELL_SMS_SIZE_TS) return EOS_ERR_SIZE;
 
     if (buffer[0] != (EOS_CELL_MTYPE_SMS | EOS_CELL_MTYPE_SMS_MSG)) return EOS_ERR_NET;
     buffer += 3 + EOS_CELL_SMS_SIZE_TS;
-    buf_len -= 3 + EOS_CELL_SMS_SIZE_TS;
+    len -= 3 + EOS_CELL_SMS_SIZE_TS;
 
     _addr_len = *buffer;
     if (_addr_len > EOS_CELL_SMS_SIZE_ADDR) return EOS_ERR_SIZE;
-    if ((_addr_len == 0) || (buf_len < (_addr_len + 1))) return EOS_ERR_SIZE;
+    if ((_addr_len == 0) || (len < (_addr_len + 1))) return EOS_ERR_SIZE;
     if (addr && addr_len) {
         *addr = buffer + 1;
         *addr_len = _addr_len;
     }
     buffer += _addr_len + 1;
-    buf_len -= _addr_len + 1;
+    len -= _addr_len + 1;
 
-    if (buf_len > EOS_CELL_SMS_SIZE_TXT) return EOS_ERR_SIZE;
+    if (len > EOS_CELL_SMS_SIZE_TXT) return EOS_ERR_SIZE;
     if (txt && txt_len) {
         *txt = buffer;
-        *txt_len = buf_len;
+        *txt_len = len;
     }
 
     return EOS_OK;
 }
 
-int eos_cell_sms_parse(unsigned char *buffer, uint16_t buf_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, buf_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 buf_len, char *addr, uint
     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 buf_len;
-    int do_release;
+    uint16_t len;
     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;
-    buf_len = 1;
-    buffer[0] = EOS_CELL_MTYPE_PDP | atype;
+    len = 1;
+    msg->buffer[0] = EOS_CELL_MTYPE_PDP | atype;
 
-    rv = eos_net_xchg(&type, buffer, &buf_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) || (buf_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;
 
-    buf_len--;
-    if ((buf_len > EOS_CELL_PDP_SIZE_ARG) || (buf_len > arg_size - 1)) {
-        rv = EOS_ERR_SIZE;
-        goto cell_pdp_get_fin;
-    }
-    memcpy(buffer + 1, arg, buf_len);
-    arg[buf_len] = '\0';
+    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);
 }