1 files changed, 65 insertions, 96 deletions

diff --git a/fw/fe310/eos/net/wifi.c b/fw/fe310/eos/net/wifi.c
index 1391121..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 buf_len) {
+static void wifi_handle_msg(unsigned char type, EOSMessage *msg, uint16_t len) {
     unsigned char mtype;
 
-    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];
     if ((mtype < EOS_WIFI_MAX_MTYPE) && evt_handler[mtype]) {
-        evt_handler[mtype](mtype, buffer, buf_len);
+        evt_handler[mtype](mtype, msg, len);
     } else {
-        eos_net_bad_handler(type, buffer, buf_len);
+        eos_net_bad_handler(type, msg, len);
     }
 }
 
@@ -44,147 +44,116 @@ eos_evt_handler_t eos_wifi_get_handler(unsigned char mtype) {
     return NULL;
 }
 
-int eos_wifi_status_parse(unsigned char *buffer, uint16_t buf_len, uint8_t *status, uint8_t ip_addr[], char *ssid, uint16_t ssid_size) {
-    if (buf_len < 2) return EOS_ERR_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;
     buffer++;
-    buf_len--;
+    len--;
 
     *status = buffer[0];
     buffer++;
-    buf_len--;
+    len--;
 
     switch (*status) {
         case EOS_WIFI_STATUS_GOT_IP:
-            if (buf_len < sizeof(uint32_t)) return EOS_ERR_SIZE;
+            if (len < sizeof(uint32_t)) return EOS_ERR_SIZE;
             if (ip_addr) memcpy(ip_addr, buffer, sizeof(uint32_t));
             buffer += sizeof(uint32_t);
-            buf_len -= sizeof(uint32_t);
+            len -= sizeof(uint32_t);
         case EOS_WIFI_STATUS_CONNECTED:
             if (ssid) {
-                if ((buf_len == 0) || (buf_len > EOS_WIFI_SIZE_SSID) || (buf_len > ssid_size - 1)) return EOS_ERR_SIZE;
-                memcpy(ssid, buffer, buf_len);
-                ssid[buf_len] = '\0';
+                if ((len == 0) || (len > EOS_WIFI_SIZE_SSID) || (len > ssid_size - 1)) return EOS_ERR_SIZE;
+                memcpy(ssid, buffer, len);
+                ssid[len] = '\0';
             }
             break;
     }
     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 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_WIFI;
-    buf_len = 1;
-    buffer[0] = EOS_WIFI_MTYPE_STATUS;
+    len = 1;
+    msg->buffer[0] = EOS_WIFI_MTYPE_STATUS;
 
-    rv = eos_net_xchg(&type, buffer, &buf_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, buf_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);
 }