Import app manager, samples and test-tools

core/app-mgr/app-manager/CMakeLists.txt

@@ -0,0 +1,28 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+include_directories (.
+                     include
+                     platform/include
+                     platform/${PLATFORM}
+                     ../classlib/include
+                     utils/coap/er-coap
+                     utils/coap/extension
+                     ../external/iwasm/include)
+
+
+file (GLOB_RECURSE source_all ../../app-manager/*.c)
+
+add_library (appmgrlib ${source_all})
+

core/app-mgr/app-manager/app_manager.c

@@ -0,0 +1,406 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "app_manager.h"
+#include "app_manager_host.h"
+#include "bh_queue.h"
+#include "bh_memory.h"
+#include "bh_thread.h"
+#include "attr_container.h"
+#include "event.h"
+#include "watchdog.h"
+#include "coap_ext.h"
+
+/* Queue of app manager */
+static bh_queue *g_app_mgr_queue;
+
+void*
+get_app_manager_queue()
+{
+    return g_app_mgr_queue;
+}
+
+void app_manager_post_applets_update_event()
+{
+    module_data *m_data;
+    attr_container_t *attr_cont;
+    request_t msg;
+    int num = 0, i = 0;
+    char *url = "/applets";
+
+    if (!event_is_registered(url))
+        return;
+
+    if (!(attr_cont = attr_container_create("All Applets"))) {
+        app_manager_printf(
+                "Post applets update event failed: allocate memory failed.");
+        return;
+    }
+
+    vm_mutex_lock(&module_data_list_lock);
+
+    m_data = module_data_list;
+    while (m_data) {
+        num++;
+        m_data = m_data->next;
+    }
+
+    if (!(attr_container_set_int(&attr_cont, "num", num))) {
+        app_manager_printf(
+                "Post applets update event failed: set attr container key failed.");
+        goto fail;
+    }
+
+    m_data = module_data_list;
+    while (m_data) {
+        char buf[32];
+        i++;
+        snprintf(buf, sizeof(buf), "%s%d", "applet", i);
+        if (!(attr_container_set_string(&attr_cont, buf, m_data->module_name))) {
+            app_manager_printf(
+                    "Post applets update event failed: set attr applet name key failed.");
+            goto fail;
+        }
+        snprintf(buf, sizeof(buf), "%s%d", "heap", i);
+        if (!(attr_container_set_int(&attr_cont, buf, m_data->heap_size))) {
+            app_manager_printf(
+                    "Post applets update event failed: set attr heap key failed.");
+            goto fail;
+        }
+        m_data = m_data->next;
+    }
+
+    memset(&msg, 0, sizeof(msg));
+    msg.url = url;
+    msg.action = COAP_EVENT;
+    msg.payload = (char*) attr_cont;
+    send_request_to_host(&msg);
+
+    app_manager_printf("Post applets update event success!\n");
+    attr_container_dump(attr_cont);
+
+    fail: vm_mutex_unlock(&module_data_list_lock);
+    attr_container_destroy(attr_cont);
+}
+
+static int get_applets_count()
+{
+    module_data *m_data;
+    int num = 0;
+
+    vm_mutex_lock(&module_data_list_lock);
+
+    m_data = module_data_list;
+    while (m_data) {
+        num++;
+        m_data = m_data->next;
+    }
+
+    vm_mutex_unlock(&module_data_list_lock);
+
+    return num;
+}
+
+/* Query fw apps info if name = NULL, otherwise query specify app */
+static bool app_manager_query_applets(request_t *msg, const char *name)
+{
+    module_data *m_data;
+    attr_container_t *attr_cont;
+    int num = 0, i = 0, len;
+    bool ret = false, found = false;
+    response_t response[1] = { 0 };
+
+    attr_cont = attr_container_create("Applets Info");
+    if (!attr_cont) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Query Applets failed: allocate memory failed.");
+        return false;
+    }
+
+    vm_mutex_lock(&module_data_list_lock);
+
+    m_data = module_data_list;
+    while (m_data) {
+        num++;
+        m_data = m_data->next;
+    }
+
+    if (name == NULL && !(attr_container_set_int(&attr_cont, "num", num))) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Query Applets failed: set attr container key failed.");
+        goto fail;
+    }
+
+    m_data = module_data_list;
+    while (m_data) {
+        char buf[32];
+
+        if (name == NULL) {
+            i++;
+            snprintf(buf, sizeof(buf), "%s%d", "applet", i);
+            if (!(attr_container_set_string(&attr_cont, buf,
+                    m_data->module_name))) {
+                SEND_ERR_RESPONSE(msg->mid,
+                        "Query Applets failed: set attr container key failed.");
+                goto fail;
+            }
+            snprintf(buf, sizeof(buf), "%s%d", "heap", i);
+            if (!(attr_container_set_int(&attr_cont, buf, m_data->heap_size))) {
+                SEND_ERR_RESPONSE(msg->mid,
+                        "Query Applets failed: set attr container heap key failed.");
+                goto fail;
+            }
+        } else if (!strcmp(name, m_data->module_name)) {
+            found = true;
+            if (!(attr_container_set_string(&attr_cont, "name",
+                    m_data->module_name))) {
+                SEND_ERR_RESPONSE(msg->mid,
+                        "Query Applet failed: set attr container key failed.");
+                goto fail;
+            }
+            if (!(attr_container_set_int(&attr_cont, "heap", m_data->heap_size))) {
+                SEND_ERR_RESPONSE(msg->mid,
+                        "Query Applet failed: set attr container heap key failed.");
+                goto fail;
+            }
+        }
+
+        m_data = m_data->next;
+    }
+
+    if (name != NULL && !found) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Query Applet failed: the app is not found.");
+        goto fail;
+    }
+
+    len = attr_container_get_serialize_length(attr_cont);
+
+    make_response_for_request(msg, response);
+    set_response(response, CONTENT_2_05,
+    FMT_ATTR_CONTAINER, (char*) attr_cont, len);
+    send_response_to_host(response);
+
+    ret = true;
+    app_manager_printf("Query Applets success!\n");
+    attr_container_dump(attr_cont);
+
+    fail: vm_mutex_unlock(&module_data_list_lock);
+    attr_container_destroy(attr_cont);
+    return ret;
+}
+
+void applet_mgt_reqeust_handler(request_t *request, void *unused)
+{
+    bh_message_t msg;
+    /* deep copy, but not use app self heap, but use global heap */
+    request_t *req = clone_request(request);
+
+    if (!req)
+        return;
+
+    msg = bh_new_msg(RESTFUL_REQUEST, req, sizeof(*req), request_cleaner);
+    if (!msg) {
+        request_cleaner(req);
+        return;
+    }
+
+    bh_post_msg2(get_app_manager_queue(), msg);
+}
+
+/* return -1 for error */
+static int get_module_type(char *kv_str)
+{
+    int module_type = -1;
+    char type_str[8] = { 0 };
+
+    find_key_value(kv_str, strlen(kv_str), "type", type_str,
+            sizeof(type_str) - 1, '&');
+
+    if (strlen(type_str) == 0)
+        module_type = Module_WASM_App;
+    else if (strcmp(type_str, "jeff") == 0)
+        module_type = Module_Jeff;
+    else if (strcmp(type_str, "wasm") == 0)
+        module_type = Module_WASM_App;
+    else if (strcmp(type_str, "wasmlib") == 0)
+        module_type = Module_WASM_Lib;
+
+    return module_type;
+}
+
+#define APP_NAME_MAX_LEN 128
+
+/* Queue callback of App Manager */
+
+static void app_manager_queue_callback(void *message)
+{
+    request_t *request = (request_t *) bh_message_payload((bh_message_t)message);
+    int mid = request->mid, module_type, offset;
+
+    if ((offset = check_url_start(request->url, strlen(request->url), "/applet"))
+            > 0) {
+        module_type = get_module_type(request->url + offset);
+
+        if (module_type == -1) {
+            SEND_ERR_RESPONSE(mid,
+                    "Applet Management failed: invalid module type.");
+            goto fail;
+        }
+
+        /* Install Applet */
+        if (request->action == COAP_PUT) {
+            if (get_applets_count() >= MAX_APP_INSTALLATIONS) {
+                SEND_ERR_RESPONSE(mid,
+                        "Install Applet failed: exceed max app installations.");
+                goto fail;
+            }
+
+            if (!request->payload) {
+                SEND_ERR_RESPONSE(mid,
+                        "Install Applet failed: invalid payload.");
+                goto fail;
+            }
+            if (g_module_interfaces[module_type]
+                    && g_module_interfaces[module_type]->module_install) {
+                if (!g_module_interfaces[module_type]->module_install(request))
+                    goto fail;
+            }
+        }
+        /* Uninstall Applet */
+        else if (request->action == COAP_DELETE) {
+            module_type = get_module_type(request->url + offset);
+            if (module_type == -1) {
+                SEND_ERR_RESPONSE(mid,
+                        "Uninstall Applet failed: invalid module type.");
+                goto fail;
+            }
+
+            if (g_module_interfaces[module_type]
+                    && g_module_interfaces[module_type]->module_uninstall) {
+                if (!g_module_interfaces[module_type]->module_uninstall(
+                        request))
+                    goto fail;
+            }
+        }
+        /* Query Applets installed */
+        else if (request->action == COAP_GET) {
+            char name[APP_NAME_MAX_LEN] = { 0 };
+            char *properties = request->url + offset;
+            find_key_value(properties, strlen(properties), "name", name,
+                    sizeof(name) - 1, '&');
+            if (strlen(name) > 0)
+                app_manager_query_applets(request, name);
+            else
+                app_manager_query_applets(request, NULL);
+        } else {
+            SEND_ERR_RESPONSE(mid, "Invalid request of applet: invalid action");
+        }
+    }
+    /* Event Register/Unregister */
+    else if ((offset = check_url_start(request->url, strlen(request->url),
+            "/event/")) > 0) {
+        char url_buf[256] = { 0 };
+
+        strncpy(url_buf, request->url + offset, sizeof(url_buf) - 1);
+
+        if (!event_handle_event_request(request->action, url_buf, ID_HOST)) {
+            SEND_ERR_RESPONSE(mid, "Handle event request failed.");
+            goto fail;
+        }
+        send_error_response_to_host(mid, CONTENT_2_05, NULL); /* OK */
+    } else {
+        int i;
+        for (i = 0; i < Module_Max; i++) {
+            if (g_module_interfaces[i]
+                    && g_module_interfaces[i]->module_handle_host_url) {
+                if (g_module_interfaces[i]->module_handle_host_url(request))
+                    break;
+            }
+        }
+
+    }
+
+    fail:
+
+    return;
+
+}
+
+static void module_interfaces_init()
+{
+    int i;
+    for (i = 0; i < Module_Max; i++) {
+        if (g_module_interfaces[i] && g_module_interfaces[i]->module_init)
+            g_module_interfaces[i]->module_init();
+    }
+}
+
+void app_manager_startup(host_interface *interface)
+{
+    module_interfaces_init();
+
+    /* Create queue of App Manager */
+    g_app_mgr_queue = bh_queue_create();
+    if (!g_app_mgr_queue)
+        return;
+
+    if (!module_data_list_init())
+        goto fail1;
+
+    if (!watchdog_startup())
+        goto fail2;
+
+    /* Initialize Host */
+    app_manager_host_init(interface);
+
+    am_register_resource("/app/", targeted_app_request_handler, ID_APP_MGR);
+
+    /*/app/ and /event/ are both processed by applet_mgt_reqeust_handler*/
+    am_register_resource("/applet", applet_mgt_reqeust_handler, ID_APP_MGR);
+    am_register_resource("/event/", applet_mgt_reqeust_handler, ID_APP_MGR);
+
+    app_manager_printf("App Manager started.\n");
+
+    /* Enter loop run */
+    bh_queue_enter_loop_run(g_app_mgr_queue, app_manager_queue_callback);
+
+    fail2: module_data_list_destroy();
+
+    fail1: bh_queue_destroy(g_app_mgr_queue);
+}
+
+#include "module_config.h"
+
+module_interface *g_module_interfaces[Module_Max] = {
+#if ENABLE_MODULE_JEFF != 0
+        &jeff_module_interface,
+#else
+        NULL,
+#endif
+
+#if ENABLE_MODULE_WASM_APP != 0
+        &wasm_app_module_interface,
+#else
+        NULL,
+#endif
+
+#if ENABLE_MODULE_WASM_LIB != 0
+        &wasm_lib_module_interface
+#else
+        NULL
+#endif
+    };

core/app-mgr/app-manager/app_manager.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef APP_MANAGER_H
+#define APP_MANAGER_H
+
+#include "bh_platform.h"
+#include "bh_common.h"
+#include "bh_queue.h"
+#include "korp_types.h"
+#include "app_manager_export.h"
+#include "native_interface.h"
+#include "shared_utils.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef __ZEPHYR__
+#define app_manager_printf printf
+#else
+#define app_manager_printf printk
+#endif
+
+#define ID_HOST -3
+#define ID_APP_MGR -2
+#define ID_NONE (uint32)-1
+
+#define SEND_ERR_RESPONSE(mid, err_msg) do {                            \
+  app_manager_printf("%s\n", err_msg);                                  \
+  send_error_response_to_host(mid, INTERNAL_SERVER_ERROR_5_00, err_msg);  \
+} while (0)
+
+extern module_interface *g_module_interfaces[Module_Max];
+
+/* Lock of the module data list */
+extern korp_mutex module_data_list_lock;
+
+/* Module data list */
+extern module_data *module_data_list;
+
+void
+app_manager_add_module_data(module_data *m_data);
+
+void
+app_manager_del_module_data(module_data *m_data);
+
+bool
+module_data_list_init();
+
+void
+module_data_list_destroy();
+
+bool
+app_manager_is_interrupting_module(uint32 module_type);
+
+void release_module(module_data *m_data);
+
+void
+module_data_list_remove(module_data *m_data);
+
+void*
+app_manager_timer_create(void (*timer_callback)(void*),
+        watchdog_timer *wd_timer);
+
+void
+app_manager_timer_destroy(void *timer);
+
+void
+app_manager_timer_start(void *timer, int timeout);
+
+void
+app_manager_timer_stop(void *timer);
+
+watchdog_timer*
+app_manager_get_wd_timer_from_timer_handle(void *timer);
+
+int
+app_manager_signature_verify(const uint8_t *file, unsigned int file_len,
+        const uint8_t *signature, unsigned int sig_size);
+
+void targeted_app_request_handler(request_t *request, void *unused);
+
+#if BEIHAI_ENABLE_TOOL_AGENT != 0
+void *
+app_manager_get_tool_agent_queue();
+#endif
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif
+

core/app-mgr/app-manager/app_manager_host.c

@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_common.h"
+#include "korp_types.h"
+#include "app_manager_host.h"
+#include "app_manager.h"
+#include "app_manager_export.h"
+#include "coap_ext.h"
+#include "bh_memory.h"
+#include "bh_thread.h"
+
+/* host communication interface */
+static host_interface host_commu;
+
+/* IMRTLink Two leading bytes */
+static unsigned char leadings[] = { (unsigned char) 0x12, (unsigned char) 0x34 };
+
+/* IMRTLink Receiving Phase */
+typedef enum recv_phase_t {
+    Phase_Non_Start, Phase_Leading, Phase_Type, Phase_Size, Phase_Payload
+} recv_phase_t;
+
+/* IMRTLink Receive Context */
+typedef struct recv_context_t {
+    recv_phase_t phase;
+    bh_link_msg_t message;
+    int size_in_phase;
+} recv_context_t;
+
+/* Current IMRTLink receive context */
+static recv_context_t recv_ctx;
+
+/* Lock for device write */
+static korp_mutex host_lock;
+
+static bool enable_log = false;
+
+static bool is_little_endian()
+{
+    long i = 0x01020304;
+    unsigned char* c = (unsigned char*) &i;
+    return (*c == 0x04) ? true : false;
+}
+
+static void exchange32(uint8* pData)
+{
+    uint8 value = *pData;
+    *pData = *(pData + 3);
+    *(pData + 3) = value;
+
+    value = *(pData + 1);
+    *(pData + 1) = *(pData + 2);
+    *(pData + 2) = value;
+}
+
+/* return:
+ *  1: complete message received
+ *  0: incomplete message received
+ */
+static int on_imrt_link_byte_arrive(unsigned char ch, recv_context_t *ctx)
+{
+    if (ctx->phase == Phase_Non_Start) {
+        ctx->message.payload_size = 0;
+
+        if (ctx->message.payload) {
+            bh_free(ctx->message.payload);
+            ctx->message.payload = NULL;
+        }
+
+        if (ch == leadings[0]) {
+            if (enable_log)
+                app_manager_printf("##On byte arrive: got leading 0\n");
+            ctx->phase = Phase_Leading;
+        }
+
+        return 0;
+    } else if (ctx->phase == Phase_Leading) {
+        if (ch == leadings[1]) {
+            if (enable_log)
+                app_manager_printf("##On byte arrive: got leading 1\n");
+            ctx->phase = Phase_Type;
+        } else
+            ctx->phase = Phase_Non_Start;
+
+        return 0;
+    } else if (ctx->phase == Phase_Type) {
+        if (ctx->size_in_phase++ == 0) {
+            if (enable_log)
+                app_manager_printf("##On byte arrive: got type 0\n");
+            ctx->message.message_type = ch;
+        } else {
+            if (enable_log)
+                app_manager_printf("##On byte arrive: got type 1\n");
+            ctx->message.message_type |= (ch << 8);
+            ctx->message.message_type = ntohs(ctx->message.message_type);
+            ctx->phase = Phase_Size;
+            ctx->size_in_phase = 0;
+        }
+
+        return 0;
+    } else if (ctx->phase == Phase_Size) {
+        unsigned char *p = (unsigned char *) &ctx->message.payload_size;
+
+        if (enable_log)
+            app_manager_printf("##On byte arrive: got payload_size, byte %d\n",
+                    ctx->size_in_phase);
+        p[ctx->size_in_phase++] = ch;
+
+        if (ctx->size_in_phase == sizeof(ctx->message.payload_size)) {
+#ifndef __ZEPHYR__
+            ctx->message.payload_size = ntohl(ctx->message.payload_size);
+#else
+            if (is_little_endian())
+            exchange32((uint8*)&ctx->message.payload_size);
+#endif
+            ctx->phase = Phase_Payload;
+
+            if (enable_log)
+                app_manager_printf("##On byte arrive: payload_size: %d\n",
+                        ctx->message.payload_size);
+            if (ctx->message.payload) {
+                bh_free(ctx->message.payload);
+                ctx->message.payload = NULL;
+            }
+
+            /* message completion */
+            if (ctx->message.payload_size == 0) {
+                ctx->phase = Phase_Non_Start;
+                if (enable_log)
+                    app_manager_printf(
+                            "##On byte arrive: receive end, payload_size is 0.\n");
+                return 1;
+            }
+
+            if (ctx->message.payload_size > 1024 * 1024) {
+                ctx->phase = Phase_Non_Start;
+                return 0;
+            }
+
+            if (ctx->message.message_type != INSTALL_WASM_BYTECODE_APP) {
+                ctx->message.payload = (char *) bh_malloc(
+                        ctx->message.payload_size);
+                if (!ctx->message.payload) {
+                    ctx->phase = Phase_Non_Start;
+                    return 0;
+                }
+            }
+
+            ctx->phase = Phase_Payload;
+            ctx->size_in_phase = 0;
+        }
+
+        return 0;
+    } else if (ctx->phase == Phase_Payload) {
+        if (ctx->message.message_type == INSTALL_WASM_BYTECODE_APP) {
+            int received_size;
+            module_on_install_request_byte_arrive_func module_on_install =
+                    g_module_interfaces[Module_WASM_App]->module_on_install;
+
+            ctx->size_in_phase++;
+
+            if (module_on_install != NULL) {
+                if (module_on_install(ch, ctx->message.payload_size,
+                        &received_size)) {
+                    if (received_size == ctx->message.payload_size) {
+                        /* whole wasm app received */
+                        ctx->phase = Phase_Non_Start;
+                        return 1;
+                    }
+                } else {
+                    /* receive or handle fail */
+                    ctx->phase = Phase_Non_Start;
+                    return 0;
+                }
+                return 0;
+            } else {
+                ctx->phase = Phase_Non_Start;
+                return 0;
+            }
+        } else {
+            ctx->message.payload[ctx->size_in_phase++] = ch;
+
+            if (ctx->size_in_phase == ctx->message.payload_size) {
+                ctx->phase = Phase_Non_Start;
+                if (enable_log)
+                    app_manager_printf(
+                            "##On byte arrive: receive end, payload_size is %d.\n",
+                            ctx->message.payload_size);
+                return 1;
+            }
+            return 0;
+        }
+    }
+
+    return 0;
+}
+
+int aee_host_msg_callback(void *msg, uint16_t msg_len)
+{
+    unsigned char *p = msg, *p_end = p + msg_len;
+
+    /*app_manager_printf("App Manager receive %d bytes from Host\n", msg_len);*/
+
+    for (; p < p_end; p++) {
+        int ret = on_imrt_link_byte_arrive(*p, &recv_ctx);
+
+        if (ret == 1) {
+            if (recv_ctx.message.payload) {
+                int msg_type = recv_ctx.message.message_type;
+
+                if (msg_type == REQUEST_PACKET) {
+                    request_t request;
+                    memset(&request, 0, sizeof(request));
+
+                    if (!unpack_request(recv_ctx.message.payload,
+                            recv_ctx.message.payload_size, &request))
+                        continue;
+
+                    request.sender = ID_HOST;
+
+                    am_dispatch_request(&request);
+                } else {
+                    printf("unexpected host msg type: %d\n", msg_type);
+                }
+
+                bh_free(recv_ctx.message.payload);
+                recv_ctx.message.payload = NULL;
+                recv_ctx.message.payload_size = 0;
+            }
+
+            memset(&recv_ctx, 0, sizeof(recv_ctx));
+        }
+    }
+
+    return 0;
+}
+
+bool app_manager_host_init(host_interface *interface)
+{
+    vm_mutex_init(&host_lock);
+    memset(&recv_ctx, 0, sizeof(recv_ctx));
+
+    host_commu.init = interface->init;
+    host_commu.send = interface->send;
+    host_commu.destroy = interface->destroy;
+
+    if (host_commu.init != NULL)
+      return host_commu.init();
+
+    return true;
+}
+
+int app_manager_host_send_msg(int msg_type, const unsigned char *buf, int size)
+{
+    /* send an IMRT LINK message contains the buf as payload */
+    if (host_commu.send != NULL) {
+        int size_s = size, n;
+        char header[16];
+
+        vm_mutex_lock(&host_lock);
+        /* leading bytes */
+        bh_memcpy_s(header, 2, leadings, 2);
+
+        /* message type */
+        // todo: check if use network byte order!!!
+        *((uint16*) (header + 2)) = htons(msg_type);
+
+        /* payload length */
+        if (is_little_endian())
+            exchange32((uint8*) &size_s);
+
+        bh_memcpy_s(header + 4, 4, &size_s, 4);
+        n = host_commu.send(NULL, header, 8);
+        if (n != 8) {
+            vm_mutex_unlock(&host_lock);
+            return 0;
+        }
+
+        /* payload */
+        n = host_commu.send(NULL, buf, size);
+        vm_mutex_unlock(&host_lock);
+
+        printf("sent %d bytes to host\n", n);
+        return n;
+    } else {
+        printf("no send api provided\n");
+    }
+    return 0;
+}

core/app-mgr/app-manager/app_manager_host.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _APP_MANAGER_HOST_H_
+#define _APP_MANAGER_HOST_H_
+
+#include "wasm_export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HOST_MODE_AON  1
+#define HOST_MODE_UART 2
+#define HOST_MODE_TEST 3
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif
+

core/app-mgr/app-manager/app_mgr.cmake

@@ -0,0 +1,23 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set (__APP_MGR_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+include_directories(${__APP_MGR_DIR})
+
+
+file (GLOB source_all ${__APP_MGR_DIR}/*.c  ${__APP_MGR_DIR}/platform/${TARGET_PLATFORM}/*.c)
+
+set (APP_MGR_SOURCE ${source_all})
+

core/app-mgr/app-manager/ble_msg.c

@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if 0
+
+#define BLUETOOTH_INTERFACE_ADVERTISMENT_DATA_LENGTH   31
+/* ble_device_info */
+typedef struct ble_device_info {
+
+    /* address type */
+    uint8_t address_type;
+    /* MAC of Device */
+    uint8_t mac[6];
+    /* security level */
+    uint8_t security_level;
+    /* signal strength */
+    int8_t rssi;
+    /* uuid_16_type */
+    int8_t uuid_16_type;
+    /* uuid_32_type */
+    int8_t uuid_32_type;
+    /* uuid_128_type */
+    int8_t uuid_128_type;
+    /* error code */
+    uint8_t error_code;
+    /* scan response length*/
+    uint16_t adv_data_len;
+    /* advertisement data */
+    uint8_t *adv_data;
+    /* scan response length*/
+    uint16_t scan_response_len;
+    /* scan response */
+    uint8_t *scan_response;
+    /* next device */
+    struct ble_device_info *next;
+    /* private data length */
+    int private_data_length;
+    /* private data */
+    uint8_t *private_data;
+    /* value handle*/
+    uint16_t value_handle;
+    /* ccc handle*/
+    uint16_t ccc_handle;
+
+}ble_device_info;
+
+/* BLE message sub type */
+typedef enum BLE_SUB_EVENT_TYPE {
+    BLE_SUB_EVENT_DISCOVERY,
+    BLE_SUB_EVENT_CONNECTED,
+    BLE_SUB_EVENT_DISCONNECTED,
+    BLE_SUB_EVENT_NOTIFICATION,
+    BLE_SUB_EVENT_INDICATION,
+    BLE_SUB_EVENT_PASSKEYENTRY,
+    BLE_SUB_EVENT_SECURITY_LEVEL_CHANGE
+}BLE_SUB_EVENT_TYPE;
+
+/* Queue message, for BLE Event */
+typedef struct bh_queue_ble_sub_msg_t {
+    /* message type, should be one of QUEUE_MSG_TYPE */
+    BLE_SUB_EVENT_TYPE type;
+    /* payload size */
+    /*uint32_t payload_size;*/
+    char payload[1];
+}bh_queue_ble_sub_msg_t;
+
+static void
+app_instance_free_ble_msg(char *msg)
+{
+    bh_queue_ble_sub_msg_t *ble_msg = (bh_queue_ble_sub_msg_t *)msg;
+    ble_device_info *dev_info;
+
+    dev_info = (ble_device_info *) ble_msg->payload;
+
+    if (dev_info->scan_response != NULL)
+    bh_free(dev_info->scan_response);
+
+    if (dev_info->private_data != NULL)
+    bh_free(dev_info->private_data);
+
+    if (dev_info->adv_data != NULL)
+    bh_free(dev_info->adv_data);
+
+    if (dev_info != NULL)
+    bh_free(dev_info);
+}
+
+static void
+app_instance_queue_free_callback(bh_message_t queue_msg)
+{
+
+    char * payload = (char *)bh_message_payload(queue_msg);
+    if(payload == NULL)
+    return;
+
+    switch (bh_message_type(queue_msg))
+    {
+        /*
+         case SENSOR_EVENT: {
+         bh_sensor_event_t *sensor_event = (bh_sensor_event_t *) payload;
+         attr_container_t *event = sensor_event->event;
+         attr_container_destroy(event);
+         }
+         break;
+         */
+        case BLE_EVENT: {
+            app_instance_free_ble_msg(payload);
+            break;
+        }
+    }
+}
+
+#endif

core/app-mgr/app-manager/coding_rule.txt

@@ -0,0 +1,15 @@
+Coding rules:
+
+1. module implementation can include the export head files of associated runtime
+
+2. app manager only call access the module implementation through the interface API
+
+3. module implementation can call the app manager API from following files:
+   - util.c
+   - message.c
+   
+4. platform API: To define it   
+   
+5. Any platform dependent implementation of app manager should be implemented in the 
+   platform specific source file, such as app_mgr_zephyr.c   
+

core/app-mgr/app-manager/event.c

@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string.h>
+
+#include "event.h"
+
+#include "app_manager.h"
+#include "bh_memory.h"
+#include "coap_ext.h"
+
+typedef struct _subscribe {
+    struct _subscribe * next;
+    uint32 subscriber_id;
+} subscribe_t;
+
+typedef struct _event {
+    struct _event *next;
+    int subscriber_size;
+    subscribe_t * subscribers;
+    char url[1]; /* event url */
+} event_reg_t;
+
+event_reg_t *g_events = NULL;
+
+static bool find_subscriber(event_reg_t * reg, uint32 id, bool remove_found)
+{
+    subscribe_t* c = reg->subscribers;
+    subscribe_t * prev = NULL;
+    while (c) {
+        subscribe_t * next = c->next;
+        if (c->subscriber_id == id) {
+            if (remove_found) {
+                if (prev)
+                    prev->next = next;
+                else
+                    reg->subscribers = next;
+
+                bh_free(c);
+            }
+
+            return true;
+        } else {
+            prev = c;
+            c = next;
+        }
+    }
+
+    return false;
+}
+
+static bool check_url(const char *url)
+{
+    if (*url == 0)
+        return false;
+
+    return true;
+}
+
+bool am_register_event(const char *url, uint32_t reg_client)
+{
+    event_reg_t *current = g_events;
+
+    app_manager_printf("am_register_event adding url:(%s)\n", url);
+
+    if (!check_url(url)) {
+        app_manager_printf("am_register_event: invaild url:(%s)\n", url);
+        return false;
+    }
+    while (current) {
+        if (strcmp(url, current->url) == 0)
+            break;
+        current = current->next;
+    }
+
+    if (current == NULL) {
+        if (NULL
+                == (current = (event_reg_t *) bh_malloc(
+                        offsetof(event_reg_t, url) + strlen(url) + 1))) {
+            app_manager_printf("am_register_event: malloc fail\n");
+            return false;
+        }
+
+        memset(current, 0, sizeof(event_reg_t));
+        bh_strcpy_s(current->url, strlen(url) + 1, url);
+        current->next = g_events;
+        g_events = current;
+    }
+
+    if (find_subscriber(current, reg_client, false)) {
+        return true;
+    } else {
+        subscribe_t * s = (subscribe_t*) bh_malloc(sizeof(subscribe_t));
+        if (s == NULL)
+            return false;
+
+        memset(s, 0, sizeof(subscribe_t));
+        s->subscriber_id = reg_client;
+        s->next = current->subscribers;
+        current->subscribers = s;
+        app_manager_printf("client: %d registered event (%s)\n", reg_client,
+                url);
+    }
+
+    return true;
+}
+
+// @url: NULL means the client wants to unregister all its subscribed items
+bool am_unregister_event(const char *url, uint32_t reg_client)
+{
+    event_reg_t *current = g_events, *pre = NULL;
+
+    while (current != NULL) {
+        if (url == NULL || strcmp(current->url, url) == 0) {
+            event_reg_t * next = current->next;
+            if (find_subscriber(current, reg_client, true)) {
+                app_manager_printf("client: %d deregistered event (%s)\n",
+                        reg_client, current->url);
+            }
+
+            // remove the registration if no client subscribe it
+            if (current->subscribers == NULL) {
+                app_manager_printf("unregister for event deleted url:(%s)\n",
+                        current->url);
+                if (pre)
+                    pre->next = next;
+                else
+                    g_events = next;
+                bh_free(current);
+                current = next;
+                continue;
+            }
+        }
+        pre = current;
+        current = current->next;
+    }
+
+    return true;
+}
+
+bool event_handle_event_request(uint8_t code, const char *event_url,
+        uint32_t reg_client)
+{
+    if (code == COAP_PUT) { /* register */
+        return am_register_event(event_url, reg_client);
+    } else if (code == COAP_DELETE) { /* unregister */
+        return am_unregister_event(event_url, reg_client);
+    } else {
+        /* invalid request */
+        return false;
+    }
+}
+
+void am_publish_event(request_t * event)
+{
+    bh_assert(event->action == COAP_EVENT);
+
+    event_reg_t *current = g_events;
+    while (current) {
+        if (0 == strcmp(event->url, current->url)) {
+            subscribe_t* c = current->subscribers;
+            while (c) {
+                if (c->subscriber_id == ID_HOST) {
+                    send_request_to_host(event);
+                } else {
+                    module_request_handler(event, (void *)c->subscriber_id);
+                }
+                c = c->next;
+            }
+
+            return;
+        }
+
+        current = current->next;
+    }
+}
+
+bool event_is_registered(const char *event_url)
+{
+    event_reg_t *current = g_events;
+
+    while (current != NULL) {
+        if (strcmp(current->url, event_url) == 0) {
+            return true;
+        }
+        current = current->next;
+    }
+
+    return false;
+}

core/app-mgr/app-manager/event.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _EVENT_H_
+#define _EVENT_H_
+
+#include "bh_platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Handle event request from host agent
+ *
+ * @param code the coap packet code
+ * @param event_url the event url
+ *
+ * @return true if success, false otherwise
+ */
+bool
+event_handle_event_request(uint8_t code, const char *event_url,
+        uint32_t register);
+
+/**
+ * Test whether the event is registered
+ *
+ * @param event_url the event url
+ *
+ * @return true for registered, false for not registered
+ */
+bool
+event_is_registered(const char *event_url);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* _EVENT_H_ */

core/app-mgr/app-manager/message.c

@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "app_manager.h"
+#include "app_manager_host.h"
+#include "event.h"
+#include "attr_container.h"
+#include "bh_memory.h"
+#include "coap_ext.h"
+
+#if 0
+bool send_coap_packet_to_host(coap_packet_t * packet)
+{
+    int size;
+    uint8_t *buf;
+
+    size = coap_serialize_message_tcp(&packet, &buf);
+    if (!buf || size == 0)
+    return false;
+
+    app_manager_host_send_msg(buf, size);
+    bh_free(buf);
+
+    return true;
+}
+#endif
+
+bool send_request_to_host(request_t *msg)
+{
+    if (COAP_EVENT == msg->action && !event_is_registered(msg->url)) {
+        app_manager_printf("Event is not registered\n");
+        return false;
+    }
+
+    int size;
+    char * packet = pack_request(msg, &size);
+    if (packet == NULL)
+        return false;
+
+    app_manager_host_send_msg(REQUEST_PACKET, packet, size);
+
+    free_req_resp_packet(packet);
+
+    return true;
+}
+
+bool send_response_to_host(response_t *response)
+{
+    int size;
+    char * packet = pack_response(response, &size);
+    if (packet == NULL)
+        return false;
+
+    app_manager_host_send_msg(RESPONSE_PACKET, packet, size);
+
+    free_req_resp_packet(packet);
+
+    return true;
+}
+
+bool send_error_response_to_host(int mid, int status, const char *msg)
+{
+    int payload_len = 0;
+    attr_container_t *payload = NULL;
+    response_t response[1] = { 0 };
+
+    if (msg) {
+        payload = attr_container_create("");
+        if (payload) {
+            attr_container_set_string(&payload, "error message", msg);
+            payload_len = attr_container_get_serialize_length(payload);
+        }
+    }
+
+    set_response(response, status,
+    FMT_ATTR_CONTAINER, (const char *)payload, payload_len);
+    response->mid = mid;
+
+    send_response_to_host(response);
+
+    if (payload)
+        attr_container_destroy(payload);
+    return true;
+}
+

core/app-mgr/app-manager/module_config.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _MODULE_CONFIG_H_
+#define _MODULE_CONFIG_H_
+
+#define ENABLE_MODULE_JEFF 0
+#define ENABLE_MODULE_WASM_APP 1
+#define ENABLE_MODULE_WASM_LIB 1
+
+#ifdef ENABLE_MODULE_JEFF
+#include "module_jeff.h"
+#endif
+#ifdef ENABLE_MODULE_WASM_APP
+#include "module_wasm_app.h"
+#endif
+#ifdef ENABLE_MODULE_WASM_LIB
+#include "module_wasm_lib.h"
+#endif
+
+#endif /* _MODULE_CONFIG_H_ */

core/app-mgr/app-manager/module_jeff.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _MODULE_JEFF_H_
+#define _MODULE_JEFF_H_
+
+#include "app_manager.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern module_interface jeff_module_interface;
+
+/* sensor event */
+typedef struct bh_sensor_event_t {
+    /* Java sensor object */
+    void *sensor;
+    /* event of attribute container from context core */
+    void *event;
+} bh_sensor_event_t;
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* _MODULE_JEFF_H_ */

core/app-mgr/app-manager/module_utils.c

@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "app_manager.h"
+#include "app_manager_host.h"
+#include "bh_queue.h"
+#include "bh_memory.h"
+#include "bh_thread.h"
+#include "attr_container.h"
+#include "event.h"
+#include "watchdog.h"
+#include "coap_ext.h"
+
+/* Lock of the module data list */
+korp_mutex module_data_list_lock;
+
+/* Module data list */
+module_data *module_data_list;
+
+bool module_data_list_init()
+{
+    module_data_list = NULL;
+    return !vm_mutex_init(&module_data_list_lock) ? true : false;
+}
+
+void module_data_list_destroy()
+{
+
+    vm_mutex_lock(&module_data_list_lock);
+    if (module_data_list) {
+        while (module_data_list) {
+            module_data *p = module_data_list->next;
+            bh_free(module_data_list);
+            module_data_list = p;
+        }
+    }
+    vm_mutex_unlock(&module_data_list_lock);
+    vm_mutex_destroy(&module_data_list_lock);
+}
+
+static void module_data_list_add(module_data *m_data)
+{
+    static uint32 module_id_max = 1;
+    vm_mutex_lock(&module_data_list_lock);
+    // reserve some special ID
+    // TODO: check the new id is not already occupied!
+    if (module_id_max == 0xFFFFFFF0)
+        module_id_max = 1;
+    m_data->id = module_id_max++;
+    if (!module_data_list) {
+        module_data_list = m_data;
+    } else {
+        /* Set as head */
+        m_data->next = module_data_list;
+        module_data_list = m_data;
+    }
+    vm_mutex_unlock(&module_data_list_lock);
+}
+
+void module_data_list_remove(module_data *m_data)
+{
+    vm_mutex_lock(&module_data_list_lock);
+    if (module_data_list) {
+        if (module_data_list == m_data)
+            module_data_list = module_data_list->next;
+        else {
+            /* Search and remove it */
+            module_data *p = module_data_list;
+
+            while (p && p->next != m_data)
+                p = p->next;
+            if (p && p->next == m_data)
+                p->next = p->next->next;
+        }
+    }
+    vm_mutex_unlock(&module_data_list_lock);
+}
+
+module_data*
+module_data_list_lookup(const char *module_name)
+{
+    vm_mutex_lock(&module_data_list_lock);
+    if (module_data_list) {
+        module_data *p = module_data_list;
+
+        while (p) {
+            /* Search by module name */
+            if (!strcmp(module_name, p->module_name)) {
+                vm_mutex_unlock(&module_data_list_lock);
+                return p;
+            }
+            p = p->next;
+        }
+    }
+    vm_mutex_unlock(&module_data_list_lock);
+    return NULL;
+}
+
+module_data*
+module_data_list_lookup_id(unsigned int module_id)
+{
+    vm_mutex_lock(&module_data_list_lock);
+    if (module_data_list) {
+        module_data *p = module_data_list;
+
+        while (p) {
+            /* Search by module name */
+            if (module_id == p->id) {
+                vm_mutex_unlock(&module_data_list_lock);
+                return p;
+            }
+            p = p->next;
+        }
+    }
+    vm_mutex_unlock(&module_data_list_lock);
+    return NULL;
+}
+
+module_data *
+app_manager_get_module_data(uint32 module_type)
+{
+    if (g_module_interfaces[module_type]
+            && g_module_interfaces[module_type]->module_get_module_data)
+        return g_module_interfaces[module_type]->module_get_module_data();
+    return NULL;
+}
+
+void*
+app_manager_get_module_queue(uint32 module_type)
+{
+    return app_manager_get_module_data(module_type)->queue;
+}
+
+const char*
+app_manager_get_module_name(uint32 module_type)
+{
+    return app_manager_get_module_data(module_type)->module_name;
+}
+
+unsigned int app_manager_get_module_id(uint32 module_type)
+{
+    return app_manager_get_module_data(module_type)->id;
+}
+
+void*
+app_manager_get_module_heap(uint32 module_type)
+{
+    return app_manager_get_module_data(module_type)->heap;
+}
+
+module_data*
+app_manager_lookup_module_data(const char *name)
+{
+    return module_data_list_lookup(name);
+}
+
+void app_manager_add_module_data(module_data *m_data)
+{
+    module_data_list_add(m_data);
+}
+
+void app_manager_del_module_data(module_data *m_data)
+{
+    module_data_list_remove(m_data);
+
+    release_module(m_data);
+}
+
+bool app_manager_is_interrupting_module(uint32 module_type)
+{
+    return app_manager_get_module_data(module_type)->wd_timer.is_interrupting;
+}
+
+extern void destory_module_timer_ctx(unsigned int module_id);
+
+void release_module(module_data *m_data)
+{
+    watchdog_timer_destroy(&m_data->wd_timer);
+
+#ifdef HEAP_ENABLED /* TODO */
+    if(m_data->heap) gc_destroy_for_instance(m_data->heap);
+#endif
+
+    if (m_data->queue)
+        bh_queue_destroy(m_data->queue);
+
+    m_data->timer_ctx = NULL;
+
+    destory_module_timer_ctx(m_data->id);
+
+    bh_free(m_data);
+}
+
+int check_modules_timer_expiry()
+{
+    vm_mutex_lock(&module_data_list_lock);
+    module_data *p = module_data_list;
+    int ms_to_expiry = -1;
+
+    while (p) {
+
+        int next = get_expiry_ms(p->timer_ctx);
+        if (next != -1) {
+            if (ms_to_expiry == -1 || ms_to_expiry > next)
+                ms_to_expiry = next;
+        }
+
+        p = p->next;
+    }
+    vm_mutex_unlock(&module_data_list_lock);
+    return ms_to_expiry;
+}
+

core/app-mgr/app-manager/module_wasm_app.c

@@ -0,0 +1,992 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "module_wasm_app.h"
+
+#include "native_interface.h" /* for request_t type */
+#include "app_manager_host.h"
+#include "bh_queue.h"
+#include "attr_container.h"
+#include "bh_thread.h"
+#include "bh_memory.h"
+#include "coap_ext.h"
+#include "event.h"
+#include "watchdog.h"
+#include "runtime_lib.h"
+
+/* Wasm app 4 magic bytes */
+static unsigned char wasm_app_magics[] = { (unsigned char) 0x00,
+        (unsigned char) 0x61, (unsigned char) 0x73, (unsigned char) 0x6d };
+
+/* Wasm app 4 version bytes */
+static unsigned char wasm_app_version[] = { (unsigned char) 0x01,
+        (unsigned char) 0x00, (unsigned char) 0x00, (unsigned char) 0x00 };
+
+/* Wasm App Install Request Receiving Phase */
+typedef enum wasm_app_install_req_recv_phase_t {
+    Phase_Req_Ver,
+    Phase_Req_Action,
+    Phase_Req_Fmt,
+    Phase_Req_Mid,
+    Phase_Req_Sender,
+    Phase_Req_Url_Len,
+    Phase_Req_Payload_Len, /* payload is wasm app binary */
+    Phase_Req_Url,
+    Phase_Wasm_Magic,
+    Phase_Wasm_Version,
+    Phase_Wasm_Section_Type,
+    Phase_Wasm_Section_Size,
+    Phase_Wasm_Section_Content
+} wasm_app_install_req_recv_phase_t;
+
+/* Message for insall wasm app */
+typedef struct install_wasm_app_msg_t {
+    uint8_t request_version;
+    uint8_t request_action;
+    uint16_t request_fmt;
+    uint32_t request_mid;
+    uint32_t request_sender;
+    uint16_t request_url_len;
+    uint32_t wasm_app_size; /* payload size is just wasm app binary size */
+    char *request_url;
+    wasm_app_file_t wasm_app_binary;
+} install_wasm_app_msg_t;
+
+/* Wasm App Install Request Receive Context */
+typedef struct wasm_app_install_req_recv_ctx_t {
+    wasm_app_install_req_recv_phase_t phase;
+    int size_in_phase;
+    install_wasm_app_msg_t message;
+    int total_received_size;
+} wasm_app_install_req_recv_ctx_t;
+
+/* Current wasm bytecode app install request receive context */
+static wasm_app_install_req_recv_ctx_t recv_ctx;
+
+static bool wasm_app_module_init(void);
+static bool wasm_app_module_install(request_t *msg);
+static bool wasm_app_module_uninstall(request_t *msg);
+static void wasm_app_module_watchdog_kill(module_data *module_data);
+static bool wasm_app_module_handle_host_url(void *queue_msg);
+static module_data *wasm_app_module_get_module_data(void);
+static bool
+wasm_app_module_on_install_request_byte_arrive(uint8 ch, int request_total_size,
+        int *received_size);
+
+static bool module_wasm_app_handle_install_msg(install_wasm_app_msg_t *message);
+static void destroy_wasm_sections_list(wasm_section_t *sections);
+static void destroy_wasm_section_from_list(wasm_section_t **sections, int type);
+
+#define Max_Msg_Callback 10
+int g_msg_type[Max_Msg_Callback] = { 0 };
+message_type_handler_t g_msg_callbacks[Max_Msg_Callback] = { 0 };
+
+#define Max_Cleanup_Callback 10
+static resource_cleanup_handler_t g_cleanup_callbacks[Max_Cleanup_Callback] = {
+        0 };
+
+module_interface wasm_app_module_interface = { wasm_app_module_init,
+        wasm_app_module_install, wasm_app_module_uninstall,
+        wasm_app_module_watchdog_kill, wasm_app_module_handle_host_url,
+        wasm_app_module_get_module_data,
+        wasm_app_module_on_install_request_byte_arrive };
+
+static unsigned align_uint(unsigned v, unsigned b)
+{
+    unsigned m = b - 1;
+    return (v + m) & ~m;
+}
+
+static void app_instance_queue_callback(void *queue_msg)
+{
+    uint32 argv[2];
+    wasm_function_inst_t func_onRequest, func_onTimer;
+
+    module_data *m_data = app_manager_get_module_data(Module_WASM_App);
+    wasm_data *wasm_app_data = (wasm_data*) m_data->internal_data;
+    wasm_module_inst_t inst = wasm_app_data->wasm_module_inst;
+    int message_type = bh_message_type(queue_msg);
+
+    switch (message_type) {
+    case RESTFUL_REQUEST: {
+        request_t *request = (request_t *) bh_message_payload(queue_msg);
+        int size;
+        char *buffer;
+        int32 buffer_offset;
+
+        app_manager_printf("App %s got request, url %s, action %d\n",
+                m_data->module_name, request->url, request->action);
+
+        func_onRequest = wasm_runtime_lookup_function(inst, "_on_request",
+                "(i32i32)");
+        if (!func_onRequest) {
+            app_manager_printf("Cannot find function onRequest\n");
+            break;
+        }
+
+        buffer = pack_request(request, &size);
+        if (buffer == NULL)
+            break;
+
+        buffer_offset = wasm_runtime_module_dup_data(inst, buffer, size);
+        if (buffer_offset == 0) {
+            app_manager_printf("Got exception running wasm code: %s\n",
+                    wasm_runtime_get_exception(inst));
+            wasm_runtime_clear_exception(inst);
+            free_req_resp_packet(buffer);
+            break;
+        }
+
+        free_req_resp_packet(buffer);
+
+        argv[0] = (uint32) buffer_offset;
+        argv[1] = (uint32) size;
+
+        if (!wasm_runtime_call_wasm(inst, NULL, func_onRequest, 2, argv)) {
+            app_manager_printf("Got exception running wasm code: %s\n",
+                    wasm_runtime_get_exception(inst));
+            wasm_runtime_clear_exception(inst);
+            wasm_runtime_module_free(inst, buffer_offset);
+            break;
+        }
+
+        wasm_runtime_module_free(inst, buffer_offset);
+        app_manager_printf("Wasm app process request success.\n");
+        break;
+    }
+    case RESTFUL_RESPONSE: {
+        response_t *response = (response_t *) bh_message_payload(queue_msg);
+        int size;
+        char *buffer;
+        int32 buffer_offset;
+
+        app_manager_printf("App %s got response_t,status %d\n",
+                m_data->module_name, response->status);
+
+        wasm_function_inst_t func_onResponse = wasm_runtime_lookup_function(
+                inst, "_on_response", "(i32i32)");
+        if (!func_onResponse) {
+            app_manager_printf("Cannot find function on_response\n");
+            break;
+        }
+
+        buffer = pack_response(response, &size);
+        if (buffer == NULL)
+            break;
+
+        buffer_offset = wasm_runtime_module_dup_data(inst, buffer, size);
+        if (buffer_offset == 0) {
+            app_manager_printf("Got exception running wasm code: %s\n",
+                    wasm_runtime_get_exception(inst));
+            wasm_runtime_clear_exception(inst);
+            free_req_resp_packet(buffer);
+            break;
+        }
+
+        free_req_resp_packet(buffer);
+
+        argv[0] = (uint32) buffer_offset;
+        argv[1] = (uint32) size;
+
+        if (!wasm_runtime_call_wasm(inst, NULL, func_onResponse, 2, argv)) {
+            app_manager_printf("Got exception running wasm code: %s\n",
+                    wasm_runtime_get_exception(inst));
+            wasm_runtime_clear_exception(inst);
+            wasm_runtime_module_free(inst, buffer_offset);
+            break;
+        }
+
+        wasm_runtime_module_free(inst, buffer_offset);
+        app_manager_printf("Wasm app process response success.\n");
+        break;
+    }
+
+    case TIMER_EVENT_WASM: {
+        if (bh_message_payload(queue_msg)) {
+            /* Call Timer.callOnTimer() method */
+            func_onTimer = wasm_runtime_lookup_function(inst,
+                    "_on_timer_callback", "(i32)");
+
+            if (!func_onTimer) {
+                app_manager_printf("Cannot find function _on_timer_callback\n");
+                break;
+            }
+            unsigned int timer_id = (unsigned int) bh_message_payload(
+                    queue_msg);
+            argv[0] = timer_id;
+            if (!wasm_runtime_call_wasm(inst, NULL, func_onTimer, 1, argv)) {
+                app_manager_printf("Got exception running wasm code: %s\n",
+                        wasm_runtime_get_exception(inst));
+                wasm_runtime_clear_exception(inst);
+            }
+        }
+
+        break;
+    }
+
+    default: {
+        for (int i = 0; i < Max_Msg_Callback; i++) {
+            if (g_msg_type[i] == message_type) {
+                g_msg_callbacks[i](m_data, queue_msg);
+                return;
+            }
+        }
+        app_manager_printf("Invalid message type of WASM app queue message.\n");
+        break;
+    }
+    }
+}
+
+/* WASM app thread main routine */
+static void*
+wasm_app_routine(void *arg)
+{
+    wasm_function_inst_t func_onInit;
+    wasm_function_inst_t func_onDestroy;
+
+    module_data *m_data = (module_data *) arg;
+    wasm_data *wasm_app_data = (wasm_data*) m_data->internal_data;
+    wasm_module_inst_t inst = wasm_app_data->wasm_module_inst;
+    korp_tid thread = wasm_app_data->thread_id;
+
+    /* attach newly created thread to the VM managed instance */
+    if (!wasm_runtime_attach_current_thread(inst, m_data)) {
+        goto fail1;
+    }
+    app_manager_printf("WASM app '%s' started\n", m_data->module_name);
+
+    /* Call app's onInit() method */
+    func_onInit = wasm_runtime_lookup_function(inst, "_on_init", "()");
+    if (!func_onInit) {
+        app_manager_printf("Cannot find function on_init().\n");
+        goto fail2;
+    }
+
+    if (!wasm_runtime_call_wasm(inst, NULL, func_onInit, 0, NULL)) {
+        printf("Got exception running WASM code: %s\n",
+                wasm_runtime_get_exception(inst));
+        wasm_runtime_clear_exception(inst);
+        /* call on_destroy() in case some resources are opened in on_init()
+         * and then exception thrown */
+        goto fail3;
+    }
+
+    /* Enter queue loop run to receive and process applet queue message */
+    bh_queue_enter_loop_run(m_data->queue, app_instance_queue_callback);
+
+    app_manager_printf("App instance main thread exit.\n");
+
+    fail3:
+    /* Call WASM app onDestroy() method if there is */
+    func_onDestroy = wasm_runtime_lookup_function(inst, "_on_destroy", "()");
+    if (func_onDestroy)
+        wasm_runtime_call_wasm(inst, NULL, func_onDestroy, 0, NULL);
+
+    fail2: wasm_runtime_detach_current_thread(inst);
+
+    fail1:
+    vm_thread_detach(thread);
+    vm_thread_exit(NULL);
+
+    return NULL;
+}
+
+static void cleanup_app_resource(module_data *m_data)
+{
+    int i;
+    wasm_data *wasm_app_data = (wasm_data*) m_data->internal_data;
+
+    am_cleanup_registeration(m_data->id);
+
+    am_unregister_event(NULL, m_data->id);
+
+    for (i = 0; i < Max_Cleanup_Callback; i++) {
+        if (g_cleanup_callbacks[i] != NULL)
+            g_cleanup_callbacks[i](m_data->id);
+        else
+            break;
+    }
+
+    wasm_runtime_deinstantiate(wasm_app_data->wasm_module_inst);
+
+    /* Destroy remain sections (i.e. data segment section) from list. */
+    destroy_wasm_sections_list(wasm_app_data->sections);
+
+    if (wasm_app_data->wasm_module)
+        wasm_runtime_unload(wasm_app_data->wasm_module);
+
+    /* Destroy watchdog timer */
+    watchdog_timer_destroy(&m_data->wd_timer);
+
+    /* Remove module data from module data list and free it */
+    app_manager_del_module_data(m_data);
+
+}
+
+/************************************************************/
+/*        Module specific functions implementation          */
+/************************************************************/
+
+static bool wasm_app_module_init(void)
+{
+    /* Initialize WASM VM*/
+    if (!wasm_runtime_init()) {
+        app_manager_printf("WASM runtime environment initialization failed.\n");
+        return false;
+    }
+
+    return true;
+}
+
+#define APP_NAME_MAX_LEN 128
+#define MAX_INT_STR_LEN 11
+
+static bool wasm_app_module_install(request_t * msg)
+{
+    unsigned int m_data_size, wasm_app_aot_file_len, heap_size, timeout, timers,
+            err_size;
+    char *properties;
+    int properties_offset, i;
+    uint8 *wasm_app_aot_file;
+    wasm_app_file_t *wasm_app_file;
+    wasm_data *wasm_app_data;
+    package_type_t package_type;
+    module_data *m_data;
+    wasm_module_t module = NULL;
+    wasm_module_inst_t inst = NULL;
+    char m_name[APP_NAME_MAX_LEN] = { 0 }, timeout_str[MAX_INT_STR_LEN] = { 0 },
+            heap_size_str[MAX_INT_STR_LEN] = { 0 },
+            timers_str[MAX_INT_STR_LEN] = { 0 }, err[256];
+    /* Useless sections after load */
+    uint8 sections1[] = { SECTION_TYPE_USER,
+    SECTION_TYPE_TYPE,
+    SECTION_TYPE_IMPORT,
+    SECTION_TYPE_FUNC,
+    SECTION_TYPE_TABLE,
+    SECTION_TYPE_MEMORY,
+    SECTION_TYPE_GLOBAL,
+    SECTION_TYPE_EXPORT,
+    SECTION_TYPE_START,
+    SECTION_TYPE_ELEM,
+    /*SECTION_TYPE_CODE,*/
+    /*SECTION_TYPE_DATA*/};
+    /* Useless sections after instantiate */
+    uint8 sections2[] = { SECTION_TYPE_DATA };
+
+    err_size = sizeof(err);
+
+    /* Check payload */
+    if (!msg->payload || msg->payload_len == 0) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Install WASM app failed: invalid wasm file.");
+        return false;
+    }
+
+    /* Check app name */
+    properties_offset = check_url_start(msg->url, strlen(msg->url), "/applet");
+    bh_assert(properties_offset > 0);
+    if (properties_offset <= 0)
+        return false;
+    properties = msg->url + properties_offset;
+    find_key_value(properties, strlen(properties), "name", m_name,
+            sizeof(m_name) - 1, '&');
+
+    if (strlen(m_name) == 0) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Install WASM app failed: invalid app name.");
+        return false;
+    }
+
+    if (app_manager_lookup_module_data(m_name)) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Install WASM app failed: app already installed.");
+        return false;
+    }
+
+    /* Parse heap size */
+    heap_size = APP_HEAP_SIZE_DEFAULT;
+    find_key_value(properties, strlen(properties), "heap", heap_size_str,
+            sizeof(heap_size_str) - 1, '&');
+    if (strlen(heap_size_str) > 0) {
+        heap_size = atoi(heap_size_str);
+        if (heap_size < APP_HEAP_SIZE_MIN)
+            heap_size = APP_HEAP_SIZE_MIN;
+        else if (heap_size > APP_HEAP_SIZE_MAX)
+            heap_size = APP_HEAP_SIZE_MAX;
+    }
+
+    /* Judge the app type is AOTed or not */
+    package_type = get_package_type((uint8 *) msg->payload, msg->payload_len);
+
+    /* Load WASM file and instantiate*/
+    if (package_type == Wasm_Module_AoT) {
+        wasm_app_aot_file = (uint8 *) msg->payload;
+        wasm_app_aot_file_len = msg->payload_len;
+        inst = wasm_runtime_load_aot(wasm_app_aot_file, wasm_app_aot_file_len,
+                heap_size, err, err_size);
+        if (!inst) {
+            SEND_ERR_RESPONSE(msg->mid,
+                    "Install WASM app failed: load wasm aot binary failed.");
+            return false;
+        }
+    } else if (package_type == Wasm_Module_Bytecode) {
+        wasm_app_file = (wasm_app_file_t *) msg->payload;
+        module = wasm_runtime_load_from_sections(wasm_app_file->sections, err,
+                err_size);
+        if (!module) {
+            SEND_ERR_RESPONSE(msg->mid,
+                    "Install WASM app failed: load WASM file failed.");
+            printf("error: %s\n", err);
+            destroy_wasm_sections_list(wasm_app_file->sections);
+            return false;
+        }
+
+        /* Destroy useless sections from list after load */
+        for (i = 0; i < sizeof(sections1); i++)
+            destroy_wasm_section_from_list(&wasm_app_file->sections,
+                    sections1[i]);
+
+        inst = wasm_runtime_instantiate(module, 0, heap_size, err, err_size);
+        if (!inst) {
+            SEND_ERR_RESPONSE(msg->mid,
+                    "Install WASM app failed: instantiate wasm runtime failed.");
+            printf("error: %s\n", err);
+            wasm_runtime_unload(module);
+            destroy_wasm_sections_list(wasm_app_file->sections);
+            return false;
+        }
+
+        /* Destroy useless sections from list after instantiate */
+        for (i = 0; i < sizeof(sections2); i++)
+            destroy_wasm_section_from_list(&wasm_app_file->sections,
+                    sections2[i]);
+
+    } else {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Install WASM app failed: invalid wasm package type.");
+        return false;
+    }
+
+    /* Create module data including the wasm_app_data as its internal_data*/
+    m_data_size = offsetof(module_data, module_name) + strlen(m_name) + 1;
+    m_data_size = align_uint(m_data_size, 4);
+    m_data = bh_malloc(m_data_size + sizeof(wasm_data));
+    if (!m_data) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Install WASM app failed: allocate memory failed.");
+        goto fail;
+    }
+    memset(m_data, 0, m_data_size + sizeof(wasm_data));
+
+    m_data->module_type = Module_WASM_App;
+    m_data->internal_data = (uint8*) m_data + m_data_size;
+    wasm_app_data = (wasm_data*) m_data->internal_data;
+    wasm_app_data->wasm_module_inst = inst;
+    wasm_app_data->wasm_module = module;
+    wasm_app_data->m_data = m_data;
+    wasm_app_data->sections = wasm_app_file->sections;
+
+    /* Set module data - name and module type */
+    bh_strcpy_s(m_data->module_name, strlen(m_name) + 1, m_name);
+
+    /* Set module data - execution timeout */
+    timeout = DEFAULT_WATCHDOG_INTERVAL;
+    find_key_value(properties, strlen(properties), "wd", timeout_str,
+            sizeof(timeout_str) - 1, '&');
+    if (strlen(timeout_str) > 0)
+        timeout = atoi(timeout_str);
+    m_data->timeout = timeout;
+
+    /* Set module data - create queue */
+    m_data->queue = bh_queue_create();
+    if (!m_data->queue) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Install WASM app failed: create app queue failed.");
+        goto fail;
+    }
+
+    /* Set heap size */
+    m_data->heap_size = heap_size;
+
+    /* Set module data - timers number */
+    timers = DEFAULT_TIMERS_PER_APP;
+    find_key_value(properties, strlen(properties), "timers", timers_str,
+                   sizeof(timers_str) - 1, '&');
+    if (strlen(timers_str) > 0) {
+        timers = atoi(timers_str);
+        if (timers > MAX_TIMERS_PER_APP)
+            timers = MAX_TIMERS_PER_APP;
+    }
+
+    /* Attention: must add the module before start the thread! */
+    app_manager_add_module_data(m_data);
+
+    m_data->timer_ctx = create_wasm_timer_ctx(m_data->id, timers);
+    if (!m_data->timer_ctx) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Install WASM app failed: create app timers failed.");
+        goto fail;
+    }
+
+    /* Initialize watchdog timer */
+    if (!watchdog_timer_init(m_data)) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Install WASM app failed: create app watchdog timer failed.");
+        goto fail;
+    }
+
+    /* create a thread. This thread may not dedicate for this WASM app.
+     WASM app instance needs to attach to one thread */
+    if (vm_thread_create(&wasm_app_data->thread_id, wasm_app_routine,
+            (void*) m_data, APP_THREAD_STACK_SIZE_DEFAULT) != 0) {
+        module_data_list_remove(m_data);
+        SEND_ERR_RESPONSE(msg->mid,
+                "Install WASM app failed: create app threadf failed.");
+
+        goto fail;
+    }
+
+    /* only when thread is created it is the flag of installation success */
+    app_manager_post_applets_update_event();
+
+    app_manager_printf("Install WASM app success!\n");
+    send_error_response_to_host(msg->mid, CREATED_2_01, NULL); /* CREATED */
+
+    return true;
+
+    fail: if (m_data)
+        release_module(m_data);
+
+    wasm_runtime_deinstantiate(inst);
+
+    if (package_type == Wasm_Module_Bytecode)
+        wasm_runtime_unload(module);
+
+    if (package_type == Wasm_Module_Bytecode)
+        destroy_wasm_sections_list(wasm_app_file->sections);
+
+    return false;
+}
+
+/* Uninstall WASM app */
+static bool wasm_app_module_uninstall(request_t *msg)
+{
+    module_data *m_data;
+    wasm_data *wasm_app_data;
+    char m_name[APP_NAME_MAX_LEN] = { 0 };
+    char *properties;
+    int properties_offset;
+
+    properties_offset = check_url_start(msg->url, strlen(msg->url), "/applet");
+    /* TODO: assert(properties_offset > 0) */
+    if (properties_offset <= 0)
+        return false;
+    properties = msg->url + properties_offset;
+    find_key_value(properties, strlen(properties), "name", m_name,
+            sizeof(m_name) - 1, '&');
+
+    if (strlen(m_name) == 0) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Uninstall WASM app failed: invalid app name.");
+        return false;
+    }
+
+    m_data = app_manager_lookup_module_data(m_name);
+    if (!m_data) {
+        SEND_ERR_RESPONSE(msg->mid, "Uninstall WASM app failed: no app found.");
+        return false;
+    }
+
+    if (m_data->module_type != Module_WASM_App) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Uninstall WASM app failed: invalid module type.");
+        return false;
+    }
+
+    if (m_data->wd_timer.is_interrupting) {
+        SEND_ERR_RESPONSE(msg->mid,
+                "Uninstall WASM app failed: app is being interrupted by watchdog.");
+        return false;
+    }
+
+    /* Exit app queue loop run */
+    bh_queue_exit_loop_run(m_data->queue);
+
+    /* Wait for wasm app thread to exit */
+    wasm_app_data = (wasm_data*) m_data->internal_data;
+    vm_thread_join(wasm_app_data->thread_id, NULL, -1);
+
+    cleanup_app_resource(m_data);
+
+    app_manager_post_applets_update_event();
+
+    app_manager_printf("Uninstall WASM app successful!\n");
+
+    send_error_response_to_host(msg->mid, DELETED_2_02, NULL); /* DELETED */
+    return true;
+}
+
+static bool wasm_app_module_handle_host_url(void *queue_msg)
+{
+    //todo: implement in future
+    app_manager_printf("App handles host url address %d\n", (int) queue_msg);
+    return false;
+}
+
+static module_data*
+wasm_app_module_get_module_data(void)
+{
+    return wasm_runtime_get_current_thread_data();
+}
+
+static void wasm_app_module_watchdog_kill(module_data *m_data)
+{
+    //todo: implement in future
+    app_manager_printf("Watchdog kills app: %s\n", m_data->module_name);
+    return;
+}
+
+bool wasm_register_msg_callback(int message_type,
+        message_type_handler_t message_handler)
+{
+    int i;
+    int freeslot = -1;
+    for (i = 0; i < Max_Msg_Callback; i++) {
+        // replace handler for the same event registered
+        if (g_msg_type[i] == message_type)
+            break;
+
+        if (g_msg_callbacks[i] == NULL && freeslot == -1)
+            freeslot = i;
+    }
+
+    if (i != Max_Msg_Callback)
+        g_msg_callbacks[i] = message_handler;
+    else if (freeslot != -1) {
+        g_msg_callbacks[freeslot] = message_handler;
+        g_msg_type[freeslot] = message_type;
+    } else
+        return false;
+
+    return true;
+}
+
+bool wasm_register_cleanup_callback(resource_cleanup_handler_t handler)
+{
+    int i;
+
+    for (i = 0; i < Max_Cleanup_Callback; i++) {
+        if (g_cleanup_callbacks[i] == NULL) {
+            g_cleanup_callbacks[i] = handler;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+#define RECV_INTEGER(value, next_phase) do{  \
+  unsigned char *p = (unsigned char *)&value; \
+  p[recv_ctx.size_in_phase++] = ch;               \
+  if (recv_ctx.size_in_phase == sizeof(value)) {  \
+    if (sizeof(value) == 4)                   \
+      value = ntohl(value);                   \
+    else if (sizeof(value) == 2)              \
+      value = ntohs(value);                   \
+    recv_ctx.phase = next_phase;                  \
+    recv_ctx.size_in_phase = 0;                   \
+  }                                           \
+} while(0)
+
+/* return:
+ * 1: whole wasm app arrived
+ * 0: one valid byte arrived
+ * -1: fail to process the byte arrived, e.g. allocate memory fail
+ */
+static bool wasm_app_module_on_install_request_byte_arrive(uint8 ch,
+        int request_total_size, int *received_size)
+{
+    if (recv_ctx.phase == Phase_Req_Ver) {
+        recv_ctx.phase = Phase_Req_Ver;
+        recv_ctx.size_in_phase = 0;
+        recv_ctx.total_received_size = 0;
+    }
+
+    recv_ctx.total_received_size++;
+    *received_size = recv_ctx.total_received_size;
+
+    if (recv_ctx.phase == Phase_Req_Ver) {
+        if (ch != 1 /* REQUES_PACKET_VER from restful_utils.c */)
+            return false;
+        recv_ctx.phase = Phase_Req_Action;
+        return true;
+    } else if (recv_ctx.phase == Phase_Req_Action) {
+        recv_ctx.message.request_action = ch;
+        recv_ctx.phase = Phase_Req_Fmt;
+        recv_ctx.size_in_phase = 0;
+        return true;
+    } else if (recv_ctx.phase == Phase_Req_Fmt) {
+        RECV_INTEGER(recv_ctx.message.request_fmt, Phase_Req_Mid);
+        return true;
+    } else if (recv_ctx.phase == Phase_Req_Mid) {
+        RECV_INTEGER(recv_ctx.message.request_mid, Phase_Req_Sender);
+        return true;
+    } else if (recv_ctx.phase == Phase_Req_Sender) {
+        RECV_INTEGER(recv_ctx.message.request_sender, Phase_Req_Url_Len);
+        return true;
+    } else if (recv_ctx.phase == Phase_Req_Url_Len) {
+        unsigned char *p = (unsigned char *) &recv_ctx.message.request_url_len;
+
+        p[recv_ctx.size_in_phase++] = ch;
+        if (recv_ctx.size_in_phase
+                == sizeof(recv_ctx.message.request_url_len)) {
+            recv_ctx.message.request_url_len = ntohs(
+                    recv_ctx.message.request_url_len);
+            recv_ctx.message.request_url = bh_malloc(
+                    recv_ctx.message.request_url_len + 1);
+            if (NULL == recv_ctx.message.request_url)
+                goto fail;
+            memset(recv_ctx.message.request_url, 0,
+                    recv_ctx.message.request_url_len + 1);
+            recv_ctx.phase = Phase_Req_Payload_Len;
+            recv_ctx.size_in_phase = 0;
+        }
+        return true;
+    } else if (recv_ctx.phase == Phase_Req_Payload_Len) {
+        RECV_INTEGER(recv_ctx.message.wasm_app_size, Phase_Req_Url);
+        return true;
+    } else if (recv_ctx.phase == Phase_Req_Url) {
+        recv_ctx.message.request_url[recv_ctx.size_in_phase++] = ch;
+        if (recv_ctx.size_in_phase == recv_ctx.message.request_url_len) {
+            recv_ctx.phase = Phase_Wasm_Magic;
+            recv_ctx.size_in_phase = 0;
+        }
+        return true;
+    } else if (recv_ctx.phase == Phase_Wasm_Magic) {
+        /* start to receive wasm app binary */
+        unsigned char *p =
+                (unsigned char *) &recv_ctx.message.wasm_app_binary.magic;
+
+        if (ch == wasm_app_magics[recv_ctx.size_in_phase])
+            p[recv_ctx.size_in_phase++] = ch;
+        else
+            goto fail;
+
+        if (recv_ctx.size_in_phase
+                == sizeof(recv_ctx.message.wasm_app_binary.magic)) {
+            recv_ctx.phase = Phase_Wasm_Version;
+            recv_ctx.size_in_phase = 0;
+        }
+
+        return true;
+    } else if (recv_ctx.phase == Phase_Wasm_Version) {
+        unsigned char *p =
+                (unsigned char *) &recv_ctx.message.wasm_app_binary.version;
+
+        if (ch == wasm_app_version[recv_ctx.size_in_phase])
+            p[recv_ctx.size_in_phase++] = ch;
+        else
+            goto fail;
+
+        if (recv_ctx.size_in_phase
+                == sizeof(recv_ctx.message.wasm_app_binary.version)) {
+            recv_ctx.phase = Phase_Wasm_Section_Type;
+            recv_ctx.size_in_phase = 0;
+        }
+
+        return true;
+    } else if (recv_ctx.phase == Phase_Wasm_Section_Type) {
+        wasm_section_t *new_section;
+
+        if (!(new_section = (wasm_section_t *) bh_malloc(sizeof(wasm_section_t))))
+            goto fail;
+
+        memset(new_section, 0, sizeof(wasm_section_t));
+        new_section->section_type = ch;
+        new_section->next = NULL;
+
+        /* add the section to tail of link list */
+        if (NULL == recv_ctx.message.wasm_app_binary.sections) {
+            recv_ctx.message.wasm_app_binary.sections = new_section;
+            recv_ctx.message.wasm_app_binary.section_end = new_section;
+        } else {
+            recv_ctx.message.wasm_app_binary.section_end->next = new_section;
+            recv_ctx.message.wasm_app_binary.section_end = new_section;
+        }
+
+        recv_ctx.phase = Phase_Wasm_Section_Size;
+        recv_ctx.size_in_phase = 0;
+
+        return true;
+    } else if (recv_ctx.phase == Phase_Wasm_Section_Size) {
+        /* the last section is the current receiving one */
+        wasm_section_t *section = recv_ctx.message.wasm_app_binary.section_end;
+        uint32 byte;
+
+        bh_assert(section);
+
+        byte = ch;
+
+        section->section_body_size |= ((byte & 0x7f)
+                << recv_ctx.size_in_phase * 7);
+        recv_ctx.size_in_phase++;
+        /* check leab128 overflow for uint32 value */
+        if (recv_ctx.size_in_phase
+                > (sizeof(section->section_body_size) * 8 + 7 - 1) / 7) {
+            app_manager_printf(" LEB overflow when parsing section size\n");
+            goto fail;
+        }
+
+        if ((byte & 0x80) == 0) {
+            /* leb128 encoded section size parsed done */
+            if (!(section->section_body = bh_malloc(section->section_body_size)))
+                goto fail;
+            recv_ctx.phase = Phase_Wasm_Section_Content;
+            recv_ctx.size_in_phase = 0;
+        }
+
+        return true;
+    } else if (recv_ctx.phase == Phase_Wasm_Section_Content) {
+        /* the last section is the current receiving one */
+        wasm_section_t *section = recv_ctx.message.wasm_app_binary.section_end;
+
+        bh_assert(section);
+
+        section->section_body[recv_ctx.size_in_phase++] = ch;
+
+        if (recv_ctx.size_in_phase == section->section_body_size) {
+            if (recv_ctx.total_received_size == request_total_size) {
+                /* whole wasm app received */
+                if (module_wasm_app_handle_install_msg(&recv_ctx.message)) {
+                    bh_free(recv_ctx.message.request_url);
+                    recv_ctx.message.request_url = NULL;
+                    memset(&recv_ctx, 0, sizeof(recv_ctx));
+                    return true;
+                } else
+                    goto fail;
+            } else {
+                recv_ctx.phase = Phase_Wasm_Section_Type;
+                recv_ctx.size_in_phase = 0;
+                return true;
+            }
+        }
+
+        return true;
+    }
+
+    fail: if (recv_ctx.message.wasm_app_binary.sections != NULL) {
+        destroy_wasm_sections_list(recv_ctx.message.wasm_app_binary.sections);
+        recv_ctx.message.wasm_app_binary.sections = NULL;
+    }
+
+    if (recv_ctx.message.request_url != NULL) {
+        bh_free(recv_ctx.message.request_url);
+        recv_ctx.message.request_url = NULL;
+    }
+
+    recv_ctx.phase = Phase_Req_Ver;
+    recv_ctx.size_in_phase = 0;
+    recv_ctx.total_received_size = 0;
+
+    return false;
+}
+
+static bool module_wasm_app_handle_install_msg(install_wasm_app_msg_t *message)
+{
+    request_t *request = NULL;
+    bh_message_t msg;
+
+    request = (request_t *) bh_malloc(sizeof(request_t));
+    if (request == NULL)
+        return false;
+
+    memset(request, 0, sizeof(*request));
+    request->action = message->request_action;
+    request->fmt = message->request_fmt;
+    request->url = bh_strdup(message->request_url);
+    request->sender = ID_HOST;
+    request->mid = message->request_mid;
+    request->payload_len = sizeof(message->wasm_app_binary);
+    request->payload = bh_malloc(request->payload_len);
+
+    if (request->url == NULL || request->payload == NULL) {
+        request_cleaner(request);
+        return false;
+    }
+
+    /* Request payload is set to wasm_app_file_t struct,
+     * but not whole app buffer */
+    memcpy(request->payload, &message->wasm_app_binary, request->payload_len);
+
+    /* Since it's a wasm app install request, so directly post to app-mgr's
+     * queue. The benefit is that section list can be freed when the msg
+     * failed to post to app-mgr's queue. The defect is missing url check. */
+    if (!(msg = bh_new_msg(RESTFUL_REQUEST, request, sizeof(*request),
+            request_cleaner))) {
+        request_cleaner(request);
+        return false;
+    }
+
+    if (!bh_post_msg2(get_app_manager_queue(), msg))
+        return false;
+
+    return true;
+}
+
+static void destroy_wasm_sections_list(wasm_section_t *sections)
+{
+    wasm_section_t *cur = sections;
+
+    /* App-manager-host and module_wasm won't access the
+     * section list concurrently, so need lock to protect. */
+
+    while (cur) {
+        wasm_section_t *next = cur->next;
+        if (cur->section_body != NULL)
+            bh_free(cur->section_body);
+        bh_free(cur);
+        cur = next;
+    }
+}
+
+static void destroy_wasm_section_from_list(wasm_section_t **sections, int type)
+{
+    wasm_section_t *cur, *prev = NULL;
+
+    /* App-manager-host and module_wasm won't access the
+     * section list concurrently, so need lock to protect. */
+
+    cur = *sections;
+
+    while (cur) {
+        wasm_section_t *next = cur->next;
+
+        if (type == cur->section_type) {
+            if (prev)
+                prev->next = next;
+            else
+                *sections = next;
+
+            if (cur->section_body != NULL)
+                bh_free(cur->section_body);
+            bh_free(cur);
+            break;
+        } else {
+            prev = cur;
+        }
+        cur = next;
+    }
+}

core/app-mgr/app-manager/module_wasm_app.h

@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _MODULE_WASM_APP_H_
+#define _MODULE_WASM_APP_H_
+
+#include "bh_queue.h"
+#include "app_manager_export.h"
+#include "wasm_export.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SECTION_TYPE_USER 0
+#define SECTION_TYPE_TYPE 1
+#define SECTION_TYPE_IMPORT 2
+#define SECTION_TYPE_FUNC 3
+#define SECTION_TYPE_TABLE 4
+#define SECTION_TYPE_MEMORY 5
+#define SECTION_TYPE_GLOBAL 6
+#define SECTION_TYPE_EXPORT 7
+#define SECTION_TYPE_START 8
+#define SECTION_TYPE_ELEM 9
+#define SECTION_TYPE_CODE 10
+#define SECTION_TYPE_DATA 11
+
+enum {
+    WASM_Msg_Start = BASE_EVENT_MAX, TIMER_EVENT_WASM, SENSOR_EVENT_WASM,
+
+    WASM_Msg_End = WASM_Msg_Start + 100
+};
+
+typedef struct wasm_data {
+    /* for easily access the containing wasm module */
+    wasm_module_t wasm_module;
+    wasm_module_inst_t wasm_module_inst;
+    /* Permissions of the WASM app */
+    char *perms;
+    /*thread list mapped with this WASM module */
+    korp_tid thread_id;
+    /* for easily access the containing module data */
+    module_data* m_data;
+    /* section list of wasm bytecode */
+    wasm_section_list_t sections;
+} wasm_data;
+
+/* sensor event */
+typedef struct _sensor_event_data {
+    uint32 sensor_id;
+
+    int data_fmt;
+    /* event of attribute container from context core */
+    void *data;
+} sensor_event_data_t;
+
+/* WASM App File */
+typedef struct wasm_app_file {
+    /* magics */
+    int magic;
+    /* current version */
+    int version;
+    /* WASM section list */
+    wasm_section_list_t sections;
+    /* Last WASM section in the list */
+    wasm_section_t *section_end;
+} wasm_app_file_t;
+
+extern module_interface wasm_app_module_interface;
+
+typedef void (*message_type_handler_t)(module_data *m_data, bh_message_t msg);
+extern bool wasm_register_msg_callback(int msg_type,
+        message_type_handler_t message_handler);
+
+typedef void (*resource_cleanup_handler_t)(uint32 module_id);
+extern bool wasm_register_cleanup_callback(resource_cleanup_handler_t handler);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* _MODULE_WASM_APP_H_ */

core/app-mgr/app-manager/module_wasm_lib.c

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "module_wasm_lib.h"
+
+static bool wasm_lib_module_init(void)
+{
+    return false;
+}
+
+static bool wasm_lib_module_install(request_t *msg)
+{
+    (void) msg;
+    return false;
+}
+
+static bool wasm_lib_module_uninstall(request_t *msg)
+{
+    (void) msg;
+    return false;
+}
+
+static void wasm_lib_module_watchdog_kill(module_data *m_data)
+{
+    (void) m_data;
+}
+
+static bool wasm_lib_module_handle_host_url(void *queue_msg)
+{
+    (void) queue_msg;
+    return false;
+}
+
+static module_data*
+wasm_lib_module_get_module_data(void)
+{
+    return NULL;
+}
+
+module_interface wasm_lib_module_interface = { wasm_lib_module_init,
+        wasm_lib_module_install, wasm_lib_module_uninstall,
+        wasm_lib_module_watchdog_kill, wasm_lib_module_handle_host_url,
+        wasm_lib_module_get_module_data,
+        NULL };
+

core/app-mgr/app-manager/module_wasm_lib.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _MODULE_WASM_LIB_H_
+#define _MODULE_WASM_LIB_H_
+
+#include "app_manager.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern module_interface wasm_lib_module_interface;
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* _MODULE_WASM_LIB_H_ */

core/app-mgr/app-manager/platform/linux/app_mgr_linux.c

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "app_manager.h"
+
+void*
+app_manager_timer_create(void (*timer_callback)(void*),
+        watchdog_timer *wd_timer)
+{
+    /* TODO */
+    return NULL;
+}
+
+void app_manager_timer_destroy(void *timer)
+{
+    /* TODO */
+}
+
+void app_manager_timer_start(void *timer, int timeout)
+{
+    /* TODO */
+}
+
+void app_manager_timer_stop(void *timer)
+{
+    /* TODO */
+}
+
+watchdog_timer *
+app_manager_get_wd_timer_from_timer_handle(void *timer)
+{
+    /* TODO */
+    return NULL;
+}
+
+int app_manager_signature_verify(const uint8_t *file, unsigned int file_len,
+        const uint8_t *signature, unsigned int sig_size)
+{
+    return 1;
+}
+

core/app-mgr/app-manager/platform/zephyr/app_mgr_zephyr.c

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "app_manager.h"
+#include "bh_platform.h"
+#include "bh_memory.h"
+#include <autoconf.h>
+#include <zephyr.h>
+#include <kernel.h>
+#if 0
+#include <sigverify.h>
+#endif
+typedef struct k_timer_watchdog {
+    struct k_timer timer;
+    watchdog_timer *wd_timer;
+} k_timer_watchdog;
+
+void*
+app_manager_timer_create(void (*timer_callback)(void*),
+        watchdog_timer *wd_timer)
+{
+    struct k_timer_watchdog *timer = bh_malloc(sizeof(struct k_timer_watchdog));
+
+    if (timer) {
+        k_timer_init(&timer->timer, (void (*)(struct k_timer*)) timer_callback,
+        NULL);
+        timer->wd_timer = wd_timer;
+    }
+
+    return timer;
+}
+
+void app_manager_timer_destroy(void *timer)
+{
+    bh_free(timer);
+}
+
+void app_manager_timer_start(void *timer, int timeout)
+{
+    k_timer_start(timer, timeout, 0);
+}
+
+void app_manager_timer_stop(void *timer)
+{
+    k_timer_stop(timer);
+}
+
+watchdog_timer *
+app_manager_get_wd_timer_from_timer_handle(void *timer)
+{
+    return ((k_timer_watchdog*) timer)->wd_timer;
+}
+#if 0
+int app_manager_signature_verify(const uint8_t *file, unsigned int file_len,
+        const uint8_t *signature, unsigned int sig_size)
+{
+    return signature_verify(file, file_len, signature, sig_size);
+}
+#endif

core/app-mgr/app-manager/resource_reg.c

@@ -0,0 +1,214 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "native_interface.h"
+#include "shared_utils.h"
+#include "app_manager.h"
+#include "app_manager_export.h"
+#include "attr_container.h"
+#include "coap_ext.h"
+
+typedef struct _app_res_register {
+    struct _app_res_register *next;
+    char * url;
+    void (*request_handler)(request_t *, void *);
+    uint32 register_id;
+} app_res_register_t;
+
+static app_res_register_t * g_resources = NULL;
+
+void module_request_handler(request_t *request, void *user_data)
+{
+    unsigned int mod_id = (unsigned int) user_data;
+    bh_message_t msg;
+    module_data *m_data;
+    request_t *req;
+
+    /* Check module name */
+    m_data = module_data_list_lookup_id(mod_id);
+    if (!m_data) {
+        return;
+    }
+
+    if (m_data->wd_timer.is_interrupting) {
+        return;
+    }
+
+    req = clone_request(request);
+    if (!req) {
+        return;
+    }
+
+    /* Set queue message and send to applet's queue */
+    msg = bh_new_msg(RESTFUL_REQUEST, req, sizeof(*req), request_cleaner);
+    if (!msg) {
+        request_cleaner(req);
+        return;
+    }
+
+    if (!bh_post_msg2(m_data->queue, msg)) {
+        return;
+    }
+
+    app_manager_printf("Send request to app %s success.\n",
+            m_data->module_name);
+}
+
+void targeted_app_request_handler(request_t *request, void *unused)
+{
+    char applet_name[128] = { 0 };
+    int offset;
+    char *url = request->url;
+    module_data *m_data;
+
+    offset = check_url_start(request->url, strlen(request->url), "/app/");
+
+    if (offset <= 0) {
+        return;
+    }
+
+    strncpy(applet_name, request->url + offset, sizeof(applet_name) - 1);
+    char *p = strrchr(applet_name, '/');
+    if (p) {
+        *p = 0;
+    } else
+        return;
+    app_manager_printf("Send request to applet: %s\n", applet_name);
+
+    request->url = p + 1;
+
+    /* Check module name */
+    m_data = module_data_list_lookup(applet_name);
+    if (!m_data) {
+        SEND_ERR_RESPONSE(request->mid,
+                "Send request to applet failed: invalid applet name");
+        goto end;
+    }
+
+    module_request_handler(request, (void *)m_data->id);
+    end: request->url = url;
+
+}
+
+void am_send_response(response_t *response)
+{
+    module_data *m_data;
+
+    // if the receiver is not any of modules, just forward it to the host
+    m_data = module_data_list_lookup_id(response->reciever);
+    if (!m_data) {
+        send_response_to_host(response);
+
+    } else {
+        response_t * resp_for_send = clone_response(response);
+        if (!resp_for_send) {
+            return;
+        }
+
+        bh_message_t msg = bh_new_msg(RESTFUL_RESPONSE, resp_for_send,
+                sizeof(*resp_for_send), response_cleaner);
+        if (!msg) {
+            response_cleaner(resp_for_send);
+            return;
+        }
+
+        if (!bh_post_msg2(m_data->queue, msg)) {
+            return;
+        }
+    }
+}
+
+void * am_dispatch_request(request_t *request)
+{
+    app_res_register_t *r = g_resources;
+
+    while (r) {
+        if (check_url_start(request->url, strlen(request->url), r->url) > 0) {
+            r->request_handler(request, (void *)r->register_id);
+            return r;
+        }
+        r = r->next;
+    }
+    return NULL;
+}
+
+bool am_register_resource(const char *url,
+        void (*request_handler)(request_t *, void *), uint32 register_id)
+{
+    app_res_register_t * r = g_resources;
+    int register_num = 0;
+
+    while (r) {
+        if (strcmp(r->url, url) == 0) {
+            return false;
+        }
+
+        if (r->register_id == register_id)
+            register_num++;
+
+        r = r->next;
+    }
+
+    if (strlen(url) > RESOUCE_EVENT_URL_LEN_MAX)
+        return false;
+
+    if (register_num >= RESOURCE_REGISTRATION_NUM_MAX)
+        return false;
+
+    r = (app_res_register_t *) bh_malloc(sizeof(app_res_register_t));
+    if (r == NULL)
+        return false;
+
+    memset(r, 0, sizeof(*r));
+    r->url = bh_strdup(url);
+    if (r->url == NULL) {
+        bh_free(r);
+        return false;
+    }
+
+    r->request_handler = request_handler;
+    r->next = g_resources;
+    r->register_id = register_id;
+    g_resources = r;
+
+    return true;
+}
+
+void am_cleanup_registeration(uint32 register_id)
+{
+    app_res_register_t * r = g_resources;
+    app_res_register_t * prev = NULL;
+
+    while (r) {
+        app_res_register_t *next = r->next;
+
+        if (register_id == r->register_id) {
+            if (prev)
+                prev->next = next;
+            else
+                g_resources = next;
+
+            bh_free(r->url);
+            bh_free(r);
+        } else
+            /* if r is freed, should not change prev. Only set prev to r
+             when r isn't freed. */
+            prev = r;
+
+        r = next;
+    }
+}

core/app-mgr/app-manager/watchdog.c

@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "watchdog.h"
+#include "bh_queue.h"
+#include "bh_thread.h"
+#include "bh_memory.h"
+#include "jeff_export.h"
+
+#define WATCHDOG_THREAD_PRIORITY 5
+
+/* Queue of watchdog */
+static bh_queue *watchdog_queue;
+
+#ifdef WATCHDOG_ENABLED /* TODO */
+static void watchdog_timer_callback(void *timer)
+{
+    watchdog_timer *wd_timer = app_manager_get_wd_timer_from_timer_handle(
+            timer);
+
+    watchdog_timer_stop(wd_timer);
+
+    vm_mutex_lock(&wd_timer->lock);
+
+    if (!wd_timer->is_stopped) {
+
+        wd_timer->is_interrupting = true;
+
+        bh_post_msg(watchdog_queue, WD_TIMEOUT, wd_timer->module_data,
+                sizeof(module_data));
+    }
+
+    vm_mutex_unlock(&wd_timer->lock);
+}
+#endif
+
+bool watchdog_timer_init(module_data *m_data)
+{
+#ifdef WATCHDOG_ENABLED /* TODO */
+    watchdog_timer *wd_timer = &m_data->wd_timer;
+
+    if (BH_SUCCESS != vm_mutex_init(&wd_timer->lock))
+    return false;
+
+    if (!(wd_timer->timer_handle =
+                    app_manager_timer_create(watchdog_timer_callback, wd_timer))) {
+        vm_mutex_destroy(&wd_timer->lock);
+        return false;
+    }
+
+    wd_timer->module_data = m_data;
+    wd_timer->is_interrupting = false;
+    wd_timer->is_stopped = false;
+#endif
+    return true;
+}
+
+void watchdog_timer_destroy(watchdog_timer *wd_timer)
+{
+#ifdef WATCHDOG_ENABLED /* TODO */
+    app_manager_timer_destroy(wd_timer->timer_handle);
+    vm_mutex_destroy(&wd_timer->lock);
+#endif
+}
+
+void watchdog_timer_start(watchdog_timer *wd_timer)
+{
+    vm_mutex_lock(&wd_timer->lock);
+
+    wd_timer->is_interrupting = false;
+    wd_timer->is_stopped = false;
+    app_manager_timer_start(wd_timer->timer_handle,
+            wd_timer->module_data->timeout);
+
+    vm_mutex_unlock(&wd_timer->lock);
+}
+
+void watchdog_timer_stop(watchdog_timer *wd_timer)
+{
+    app_manager_timer_stop(wd_timer->timer_handle);
+}
+
+#ifdef WATCHDOG_ENABLED /* TODO */
+static void watchdog_queue_callback(void *queue_msg)
+{
+    if (bh_message_type(queue_msg) == WD_TIMEOUT) {
+        module_data *m_data = (module_data *) bh_message_payload(queue_msg);
+        if (g_module_interfaces[m_data->module_type]
+                && g_module_interfaces[m_data->module_type]->module_watchdog_kill) {
+            g_module_interfaces[m_data->module_type]->module_watchdog_kill(
+                    m_data);
+            app_manager_post_applets_update_event();
+        }
+    }
+}
+#endif
+
+#ifdef WATCHDOG_ENABLED /* TODO */
+static void*
+watchdog_thread_routine(void *arg)
+{
+    /* Enter loop run */
+    bh_queue_enter_loop_run(watchdog_queue, watchdog_queue_callback);
+
+    (void) arg;
+    return NULL;
+}
+#endif
+
+bool watchdog_startup()
+{
+    if (!(watchdog_queue = bh_queue_create())) {
+        app_manager_printf(
+                "App Manager start failed: create watchdog queue failed.\n");
+        return false;
+    }
+#if 0
+//todo: enable watchdog
+    /* Start watchdog thread */
+    if (!jeff_runtime_create_supervisor_thread_with_prio(watchdog_thread_routine, NULL,
+                    WATCHDOG_THREAD_PRIORITY)) {
+        bh_queue_destroy(watchdog_queue);
+        return false;
+    }
+#endif
+    return true;
+}

core/app-mgr/app-manager/watchdog.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef _WATCHDOG_H_
+#define _WATCHDOG_H_
+
+#include "app_manager.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool
+watchdog_timer_init(module_data *module_data);
+
+void
+watchdog_timer_destroy(watchdog_timer *wd_timer);
+
+void
+watchdog_timer_start(watchdog_timer *wd_timer);
+
+void
+watchdog_timer_stop(watchdog_timer *wd_timer);
+
+watchdog_timer*
+app_manager_get_watchdog_timer(void *timer);
+
+bool
+watchdog_startup();
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* _WATCHDOG_H_ */

core/app-mgr/app-mgr-shared/app_manager_export.h

@@ -0,0 +1,300 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _APP_MANAGER_EXPORT_H_
+#define _APP_MANAGER_EXPORT_H_
+
+#include "native_interface.h"
+#include "shared_utils.h"
+#include "bh_queue.h"
+#include "host_link.h"
+#include "runtime_timer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct attr_container_t;
+
+/* Queue message type */
+typedef enum QUEUE_MSG_TYPE {
+    COAP_PARSED = LINK_MSG_TYPE_MAX + 1,
+    RESTFUL_REQUEST,
+    RESTFUL_RESPONSE,
+    TIMER_EVENT = 5,
+    SENSOR_EVENT = 6,
+    GPIO_INTERRUPT_EVENT = 7,
+    BLE_EVENT = 8,
+    JDWP_REQUEST = 9,
+    WD_TIMEOUT = 10,
+    BASE_EVENT_MAX = 100
+
+} QUEUE_MSG_TYPE;
+
+typedef enum {
+    Module_Jeff, Module_WASM_App, Module_WASM_Lib, Module_Max
+} Module_Type;
+
+struct module_data;
+
+/* Watchdog timer of module */
+typedef struct watchdog_timer {
+    /* Timer handle of the platform */
+    void *timer_handle;
+    /* Module of the watchdog timer */
+    struct module_data *module_data;
+    /* Lock of the watchdog timer */
+    korp_mutex lock;
+    /* Flag indicates module is being interrupted by watchdog */
+    bool is_interrupting;
+    /* Flag indicates watchdog timer is stopped */
+    bool is_stopped;
+} watchdog_timer;
+
+typedef struct module_data {
+    struct module_data *next;
+
+    uint32 id;
+
+    /* Type of the module */
+    Module_Type module_type;
+
+    /* Heap of the module */
+    void *heap;
+
+    /* Heap size of the module */
+    int heap_size;
+
+    /* Module execution timeout in millisecond */
+    int timeout;
+
+    /* Queue of the module */
+    bh_queue *queue;
+
+    /* Watchdog timer of the module*/
+    struct watchdog_timer wd_timer;
+
+    timer_ctx_t timer_ctx;
+
+    /* max timers number app can create */
+    int timers;
+
+    /* Internal data of the module */
+    void *internal_data;
+
+    /* Module name */
+    char module_name[1];
+} module_data;
+
+/* Module function types */
+typedef bool (*module_init_func)(void);
+typedef bool (*module_install_func)(request_t *msg);
+typedef bool (*module_uninstall_func)(request_t *msg);
+typedef void (*module_watchdog_kill_func)(module_data *module_data);
+typedef bool (*module_handle_host_url_func)(void *queue_msg);
+typedef module_data *(*module_get_module_data_func)(void);
+
+/**
+ * @typedef module_on_install_request_byte_arrive_func
+ *
+ * @brief Define the signature of function to handle one byte of
+ *        module app install request for struct module_interface.
+ *
+ * @param ch the byte to be received and handled
+ * @param total_size total size of the request
+ * @param received_total_size currently received total size when the function return
+ *
+ * @return true if success, false otherwise
+ */
+typedef bool (*module_on_install_request_byte_arrive_func)(uint8 ch,
+        int total_size, int *received_total_size);
+
+/* Interfaces of each module */
+typedef struct module_interface {
+    module_init_func module_init;
+    module_install_func module_install;
+    module_uninstall_func module_uninstall;
+    module_watchdog_kill_func module_watchdog_kill;
+    module_handle_host_url_func module_handle_host_url;
+    module_get_module_data_func module_get_module_data;
+    module_on_install_request_byte_arrive_func module_on_install;
+} module_interface;
+
+/**
+ * @typedef host_init_func
+ * @brief Define the host initialize callback function signature for
+ * struct host_interface.
+ *
+ * @return true if success, false if fail
+ */
+typedef bool (*host_init_func)(void);
+
+/**
+ * @typedef host_send_fun
+ * @brief Define the host send callback function signature for
+ * struct host_interface.
+ *
+ * @param buf data buffer to send.
+ * @param size size of the data to send.
+ *
+ * @return size of the data sent in bytes
+ */
+typedef int (*host_send_fun)(void * ctx, const char *buf, int size);
+
+/**
+ * @typedef host_destroy_fun
+ * @brief Define the host receive callback function signature for
+ * struct host_interface.
+ *
+ */
+typedef void (*host_destroy_fun)();
+
+/* Interfaces of host communication */
+typedef struct host_interface {
+    host_init_func init;
+    host_send_fun send;
+    host_destroy_fun destroy;
+} host_interface;
+
+/**
+ * Initialize communication with Host
+ *
+ * @param interface host communication interface
+ *
+ * @return true if success, false otherwise
+ */
+bool
+app_manager_host_init(host_interface *interface);
+
+/**
+ * Send message to Host
+ *
+ * @param buf buffer to send
+ * @param size size of buffer
+ *
+ * @return size of buffer sent
+ */
+
+/* Startup app manager */
+void
+app_manager_startup(host_interface *interface);
+
+/* Get queue of current applet */
+void *
+app_manager_get_module_queue(uint32 module_type);
+
+/* Get applet name of current applet */
+const char *
+app_manager_get_module_name(uint32 module_type);
+
+/* Get heap of current applet */
+void *
+app_manager_get_module_heap(uint32 module_type);
+
+void*
+get_app_manager_queue();
+
+module_data*
+app_manager_get_module_data(uint32 module_type);
+
+unsigned int
+app_manager_get_module_id(uint32 module_type);
+
+module_data*
+app_manager_lookup_module_data(const char *name);
+
+module_data*
+module_data_list_lookup(const char *module_name);
+
+module_data*
+module_data_list_lookup_id(unsigned int module_id);
+
+void
+app_manager_post_applets_update_event();
+
+bool
+am_register_resource(const char *url,
+        void (*request_handler)(request_t *, void *), uint32 register_id);
+
+void am_cleanup_registeration(uint32 register_id);
+
+bool
+am_register_event(const char *url, uint32_t reg_client);
+
+bool
+am_unregister_event(const char *url, uint32_t reg_client);
+
+void am_publish_event(request_t * event);
+
+void * am_dispatch_request(request_t *request);
+
+void am_send_response(response_t *response);
+
+void module_request_handler(request_t *request, void *user_data);
+
+/**
+ * Send request message to host
+ *
+ * @param msg the request or event message.
+ *    It is event when msg->action==COAP_EVENT
+ *
+ * @return true if success, false otherwise
+ */
+bool
+send_request_to_host(request_t *msg);
+
+/**
+ * Send response message to host
+ *
+ * @param msg the response message
+ *
+ * @return true if success, false otherwise
+ */
+bool
+send_response_to_host(response_t *msg);
+
+/**
+ * Send response with mid and code to host
+ *
+ * @param mid the message id of response
+ * @param code the code/status of response
+ * @param msg the detailed message
+ *
+ * @return true if success, false otherwise
+ */
+bool
+send_error_response_to_host(int mid, int code, const char *msg);
+
+/**
+ * Check whether the applet has the permission
+ *
+ * @param perm the permission needed to check
+ *
+ * @return true if success, false otherwise
+ */
+
+int
+app_manager_host_send_msg(int msg_type, const unsigned char *buf, int size);
+
+bool
+bh_applet_check_permission(const char *perm);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif
+

core/app-mgr/app-mgr-shared/app_mgr_shared.cmake

@@ -0,0 +1,23 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set (APP_MGR_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+include_directories(${APP_MGR_SHARED_DIR})
+
+
+file (GLOB_RECURSE source_all ${APP_MGR_SHARED_DIR}/*.c)
+
+set (APP_MGR_SHARED_SOURCE ${source_all})
+

core/app-mgr/app-mgr-shared/host_link.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DEPS_APP_MGR_APP_MGR_SHARED_HOST_LINK_H_
+#define DEPS_APP_MGR_APP_MGR_SHARED_HOST_LINK_H_
+
+typedef enum LINK_MSG_TYPE {
+    COAP_TCP_RAW = 0,
+    COAP_UDP_RAW = 1,
+    REQUEST_PACKET,
+    RESPONSE_PACKET,
+    INSTALL_WASM_BYTECODE_APP,
+    CBOR_GENERIC = 30,
+
+    LINK_MSG_TYPE_MAX = 50
+} LINK_MSG_TYPE;
+
+/* Link message, or message between host and app manager */
+typedef struct bh_link_msg_t {
+    /* 2 bytes leading */
+    uint16_t leading_bytes;
+    /* message type, must be COAP_TCP or COAP_UDP */
+    uint16_t message_type;
+    /* size of payload */
+    uint32_t payload_size;
+    char *payload;
+} bh_link_msg_t;
+
+#endif /* DEPS_APP_MGR_APP_MGR_SHARED_HOST_LINK_H_ */

core/app-mgr/module.json

@@ -0,0 +1,53 @@
+{
+    "name": "aee",
+    "version": "0.0.1",
+    "description": "aee",
+    "type": "source",
+    "category": "middleware",
+    "arch": "x86, arc, posix",
+    "includes": [
+        "Beihai/classlib/include",
+        "Beihai/runtime/include",
+        "Beihai/runtime/platform/include",
+        "Beihai/runtime/platform/zephyr",
+        "Beihai/runtime/utils/coap/er-coap",
+        "Beihai/runtime/utils/coap/extension",
+        "iwasm/runtime/include",
+        "iwasm/runtime/platform/include",
+        "iwasm/runtime/platform/zephyr",
+        "iwasm/runtime/vmcore_wasm"
+    ],
+    "sources": [
+        "Beihai/classlib/native/internal/*.c",
+        "Beihai/classlib/native/*.c",
+        "Beihai/runtime/gc/*.c",
+        "Beihai/runtime/platform/zephyr/*.c",
+        "Beihai/runtime/utils/*.c",
+        "Beihai/runtime/utils/coap/er-coap/*.c",
+        "Beihai/runtime/utils/coap/extension/*.c",
+        "Beihai/runtime/vmcore_jeff/*.c",
+        "app-manager/app-manager.c",
+        "app-manager/app-manager-host.c",
+        "app-manager/app_mgr_zephyr.c",
+        "app-manager/event.c",
+        "app-manager/message.c",
+        "app-manager/module_jeff.c",
+        "app-manager/module_wasm_lib.c",
+        "app-manager/module_wasm_app.c",
+        "app-manager/watchdog.c",
+        "Beihai/products/iMRT/*.c",
+        "iwasm/runtime/utils/*.c",
+        "iwasm/runtime/platform/zephyr/*.c",
+        "iwasm/runtime/vmcore_wasm/*.c",
+        "iwasm/lib/lib-export\.c",
+        "iwasm/lib/aee/*.c",
+        "iwasm/products/zephyr/sample/src/*.c"
+    ],
+    "compile_definitions": [
+        "NVALGRIND",
+        "__JLF__",
+        "__ZEPHYR__"
+    ],
+    "target": "aee",
+    "dependencies": []
+}

core/iwasm/app-samples/smart-light/build.sh

@@ -0,0 +1,17 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+emcc -g -O3 *.c -s WASM=1 -s SIDE_MODULE=1 -s ASSERTIONS=1 -s STACK_OVERFLOW_CHECK=2 \
+     -s TOTAL_MEMORY=65536 -s TOTAL_STACK=4096 -o test.wasm
+#./jeffdump -o ../test_wasm.h -n wasm_test_file test.wasm

core/iwasm/app-samples/smart-light/main.c

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+//User LED
+#define LED_PORT "GPIOA"
+#define LED 5
+
+//User KEY
+#define KEY_PORT "GPIOC"
+#define KEY 13
+
+/** GPIO pin to be input. */
+#define GPIO_DIR_IN (0 << 0)
+
+/** GPIO pin to be output. */
+#define GPIO_DIR_OUT (1 << 0)
+
+void *device_get_binding(const char *);
+int gpio_pin_configure(void *, unsigned int, int);
+int gpio_pin_read(void *, unsigned int, unsigned int *);
+int gpio_pin_write(void *, unsigned int, unsigned int);
+
+int main(int argc, char **argv)
+{
+    unsigned int gpio_value;
+    unsigned char flag = 0;
+    struct device *dev, *key_dev;
+
+    dev = device_get_binding(LED_PORT);
+    /* Set LED pin as output */
+    gpio_pin_configure(dev, LED, GPIO_DIR_OUT);
+
+    key_dev = device_get_binding(KEY_PORT);
+    /* Set KEY pin as input */
+    gpio_pin_configure(key_dev, KEY, GPIO_DIR_IN);
+
+    while (1) {
+        gpio_pin_read(key_dev, KEY, &gpio_value);
+        if (!gpio_value) {
+            gpio_pin_write(dev, LED, 1);
+            if (!flag) {
+                printf("object detected\n");
+                flag = 1;
+            }
+        } else {
+            gpio_pin_write(dev, LED, 0);
+            flag = 0;
+        }
+    }
+    return 0;
+}

core/iwasm/lib/app-libs/base/bh_platform.c

@@ -71,7 +71,7 @@ uint16 htons(uint16 value)
     uint16 ret;
     if (is_little_endian()) {
         ret = value;
-        swap16(&ret);
+        swap16((uint8 *)&ret);
         return ret;
     }
 

core/iwasm/lib/app-libs/base/request.c

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "attr-container.h"
+#include "attr_container.h"
 #include "request.h"
 #include "shared_utils.h"
 #include "wasm_app.h"
@@ -138,9 +138,9 @@ static bool register_url_handler(const char *url,
 
     // tell app mgr to route this url to me
     if (reg_type == Reg_Request)
-        wasm_register_resource(url);
+        wasm_register_resource((int32)url);
     else
-        wasm_sub_event(url);
+        wasm_sub_event((int32)url);
 
     return true;
 }
@@ -242,7 +242,7 @@ void api_send_request(request_t * request, response_handler_f response_handler,
         }
     }
 
-    wasm_post_request(buffer, size);
+    wasm_post_request((int32)buffer, size);
 
     free_req_resp_packet(buffer);
 }
@@ -329,7 +329,7 @@ void api_response_send(response_t *response)
     if (buffer == NULL)
         return;
 
-    wasm_response_send(buffer, size);
+    wasm_response_send((int32)buffer, size);
     free_req_resp_packet(buffer);
 }
 
@@ -339,11 +339,11 @@ bool api_publish_event(const char *url, int fmt, void *payload, int payload_len)
 {
     int size;
     request_t request[1];
-    init_request(request, url, COAP_EVENT, fmt, payload, payload_len);
+    init_request(request, (char *)url, COAP_EVENT, fmt, payload, payload_len);
     char * buffer = pack_request(request, &size);
     if (buffer == NULL)
         return false;
-    wasm_post_request(buffer, size);
+    wasm_post_request((int32)buffer, size);
 
     free_req_resp_packet(buffer);
 

core/iwasm/lib/app-libs/base/wasm_app.h

@@ -34,7 +34,7 @@
 
 #include "native_interface.h"
 #include "shared_utils.h"
-#include "attr-container.h"
+#include "attr_container.h"
 #include "request.h"
 #include "sensor.h"
 #include "timer_wasm_app.h"

core/iwasm/lib/app-libs/extension/sensor/sensor.c

@@ -31,7 +31,7 @@ sensor_t sensor_open(const char* name, int index,
         sensor_event_handler_f sensor_event_handler,
         void *user_data)
 {
-    uint32 id = wasm_sensor_open(name, index);
+    uint32 id = wasm_sensor_open((int32)name, index);
     if (id == -1)
         return NULL;
 
@@ -66,7 +66,7 @@ bool sensor_config_with_attr_container(sensor_t sensor, attr_container_t *cfg)
     char *buffer = (char *)cfg;
     int len = attr_container_get_serialize_length(cfg);
 
-    return wasm_sensor_config_with_attr_container(sensor->handle, buffer, len);
+    return wasm_sensor_config_with_attr_container(sensor->handle, (int32)buffer, len);
 }
 
 bool sensor_config(sensor_t sensor, int interval, int bit_cfg, int delay)

core/iwasm/lib/app-libs/extension/sensor/sensor.h

@@ -17,7 +17,7 @@
 #ifndef _AEE_SENSOR_H_
 #define _AEE_SENSOR_H_
 
-#include "attr-container.h"
+#include "attr_container.h"
 
 #ifdef __cplusplus
 extern "C" {

core/iwasm/lib/native-interface/attr_container.c

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "attr-container.h"
+#include "attr_container.h"
 
 typedef union jvalue {
     bool z;
@@ -794,7 +794,7 @@ void attr_container_dump(const attr_container_t *attr_cont)
             break;
         case ATTR_TYPE_INT64:
             bh_memcpy_s(&value.j, sizeof(uint64_t), p, sizeof(uint64_t));
-            attr_container_printf(", type: int64, value: 0x%llx\n", value.j);
+            attr_container_printf(", type: int64, value: 0x%llx\n", (long long unsigned int)(value.j));
             p += 8;
             break;
         case ATTR_TYPE_BYTE:

core/iwasm/lib/native-interface/restful_utils.c

@@ -109,7 +109,10 @@ request_t * unpack_request(char * packet, int size, request_t * request)
     request->sender = ntohl(*((uint32*) (packet + 8)));
     request->payload_len = payload_len;
     request->url = REQUEST_PACKET_URL(packet);
-    request->payload = packet + REQUEST_PACKET_URL_OFFSET + url_len;
+    if (payload_len > 0)
+        request->payload = packet + REQUEST_PACKET_URL_OFFSET + url_len;
+    else
+        request->payload = NULL;
 
     return request;
 }
@@ -150,7 +153,10 @@ response_t * unpack_response(char * packet, int size, response_t * response)
     response->mid = ntohl(*((uint32*) (packet + 4)));
     response->reciever = ntohl(*((uint32*) (packet + 8)));
     response->payload_len = payload_len;
-    response->payload = packet + RESPONSE_PACKET_FIX_PART_LEN;
+    if (payload_len > 0)
+        response->payload = packet + RESPONSE_PACKET_FIX_PART_LEN;
+    else
+        response->payload = NULL;
 
     return response;
 }
@@ -238,7 +244,7 @@ response_t * clone_response(response_t * response)
 response_t * set_response(response_t * response, int status, int fmt,
         const char *payload, int payload_len)
 {
-    response->payload = payload;
+    response->payload = (void *)payload;
     response->payload_len = payload_len;
     response->status = status;
     response->fmt = fmt;
@@ -384,11 +390,9 @@ char * find_key_value(char * buffer, int buffer_len, char * key, char * value,
         int value_len, char delimiter)
 {
     char * p = buffer;
-    int i = 0;
     int remaining = buffer_len;
     int key_len = strlen(key);
 
-    char * item_start = p;
     while (*p != 0 && remaining > 0) {
         while (*p == ' ' || *p == delimiter) {
             p++;

core/iwasm/lib/native/base/base_lib_export.c

@@ -17,10 +17,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "lib-export.h"
+#include "lib_export.h"
 
 #ifdef WASM_ENABLE_BASE_LIB
-#include "base-lib-export.h"
+#include "base_lib_export.h"
 #endif
 
 static NativeSymbol extended_native_symbol_defs[] = {

core/iwasm/lib/native/base/base_lib_export.h

@@ -17,7 +17,7 @@
 #ifndef _BASE_LIB_EXPORT_H_
 #define _BASE_LIB_EXPORT_H_
 
-#include "attr-container.h"
+#include "attr_container.h"
 #include "native_interface.h"
 
 #endif /* end of _BASE_LIB_EXPORT_H_ */

core/iwasm/lib/native/base/request_response.c

@@ -15,11 +15,11 @@
  */
 
 #include "native_interface.h"
-#include "app-manager-export.h"
+#include "app_manager_export.h"
 #include "coap_ext.h"
-#include "wasm-export.h"
+#include "wasm_export.h"
 
-extern void module_request_handler(request_t *request, uint32 register_id);
+extern void module_request_handler(request_t *request, void *user_data);
 
 bool wasm_response_send(int32 buffer_offset, int size)
 {

core/iwasm/lib/native/base/timer_wrapper.c

@@ -15,7 +15,7 @@
  */
 
 #include "runtime_timer.h"
-#include "app-manager-export.h"
+#include "app_manager_export.h"
 #include "module_wasm_app.h"
 #include "bh_list.h"
 #include "bh_thread.h"

core/iwasm/lib/native/extension/sensor/runtime_sensor.c

@@ -15,7 +15,7 @@
  */
 
 #include "runtime_sensor.h"
-#include "app-manager-export.h"
+#include "app_manager_export.h"
 #include "module_wasm_app.h"
 #include "bh_thread.h"
 #include "bh_time.h"
@@ -168,7 +168,7 @@ uint32 wasm_sensor_open(int32 name_offset, int instance)
 
         memset(client, 0, sizeof(sensor_client_t));
         client->client_id = mod_id;
-        client->client_callback = wasm_sensor_callback;
+        client->client_callback = (void *)wasm_sensor_callback;
         client->interval = s->default_interval;
         client->next = s->clients;
         s->clients = client;

core/iwasm/lib/native/extension/sensor/runtime_sensor.h

@@ -18,7 +18,7 @@
 #define LIB_EXTENSION_RUNTIME_SENSOR_H_
 
 #include "bh_platform.h"
-#include "attr-container.h"
+#include "attr_container.h"
 struct _sys_sensor;
 typedef struct _sys_sensor* sensor_obj_t;
 

core/iwasm/lib/native/extension/sensor/sensor_mgr_ref.c

@@ -18,9 +18,9 @@
 #include "bh_queue.h"
 #include "bh_thread.h"
 #include "runtime_sensor.h"
-#include "attr-container.h"
+#include "attr_container.h"
 #include "module_wasm_app.h"
-#include "wasm-export.h"
+#include "wasm_export.h"
 
 /*
  *
@@ -99,11 +99,10 @@ static attr_container_t * read_test_sensor(void * sensor)
 
 static bool config_test_sensor(void * s, void * config)
 {
-
     return false;
 }
 
-static void * thread_sensor_check(void * arg)
+static void thread_sensor_check(void * arg)
 {
     while (1) {
         int ms_to_expiry = check_sensor_timers();
@@ -120,6 +119,8 @@ static void cb_wakeup_thread()
     vm_cond_signal(&cond);
 }
 
+void set_sensor_reshceduler(void (*callback)());
+
 void init_sensor_framework()
 {
     // init the mutext and conditions
@@ -138,7 +139,7 @@ void init_sensor_framework()
 
     wasm_register_cleanup_callback(sensor_cleanup_callback);
 
-    vm_thread_create(&tid, thread_sensor_check, NULL,
+    vm_thread_create(&tid, (void *)thread_sensor_check, NULL,
     BH_APPLET_PRESERVED_STACK_SIZE);
 
 }

core/iwasm/lib/native/libc/libc_wrapper.c

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include "wasm-native.h"
-#include "wasm-export.h"
+#include "wasm_native.h"
+#include "wasm_export.h"
 #include "wasm_log.h"
 #include "wasm_platform_log.h"
 
@@ -903,7 +903,9 @@ wasm_native_func_lookup(const char *module_name, const char *func_name)
 
     while (func_def < func_def_end) {
         if (!strcmp(func_def->module_name, module_name)
-            && !strcmp(func_def->func_name, func_name))
+            && (!strcmp(func_def->func_name, func_name)
+                || (func_def->func_name[0] == '_'
+                    && !strcmp(func_def->func_name + 1, func_name))))
             return (void*) (uintptr_t) func_def->func_ptr;
         func_def++;
     }

core/iwasm/products/linux/CMakeLists.txt

@@ -58,7 +58,7 @@ enable_language (ASM)
 
 include (../../runtime/platform/${PLATFORM}/platform.cmake)
 include (../../runtime/utils/utils.cmake)
-include (../../runtime/vmcore_wasm/vmcore.cmake)
+include (../../runtime/vmcore-wasm/vmcore.cmake)
 include (../../lib/native/base/wasm_lib_base.cmake)
 include (../../lib/native/libc/wasm_libc.cmake)
 include (${SHARED_LIB_DIR}/platform/${PLATFORM}/shared_platform.cmake)
@@ -68,12 +68,12 @@ add_library (vmlib
              ${WASM_PLATFORM_LIB_SOURCE}
              ${WASM_UTILS_LIB_SOURCE}
              ${VMCORE_LIB_SOURCE}
-             ${WASM_LIB_BASE_DIR}/base-lib-export.c
+             ${WASM_LIB_BASE_DIR}/base_lib_export.c
              ${WASM_LIBC_SOURCE}
              ${PLATFORM_SHARED_SOURCE}
              ${MEM_ALLOC_SHARED_SOURCE})
 
-add_executable (iwasm main.c ext-lib-export.c)
+add_executable (iwasm main.c ext_lib_export.c)
 
 install (TARGETS iwasm DESTINATION bin)
 
@@ -83,7 +83,7 @@ add_library (libiwasm SHARED
              ${WASM_PLATFORM_LIB_SOURCE}
              ${WASM_UTILS_LIB_SOURCE}
              ${VMCORE_LIB_SOURCE}
-             ${WASM_LIB_BASE_DIR}/base-lib-export.c
+             ${WASM_LIB_BASE_DIR}/base_lib_export.c
              ${WASM_LIBC_SOURCE}
              ${PLATFORM_SHARED_SOURCE}
              ${MEM_ALLOC_SHARED_SOURCE})

core/iwasm/products/linux/ext_lib_export.c

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include "lib-export.h"
+#include "lib_export.h"
 
 static NativeSymbol extended_native_symbol_defs[] = { };
 
-#include "ext-lib-export.h"
+#include "ext_lib_export.h"

core/iwasm/products/linux/main.c

@@ -24,7 +24,7 @@
 #include "wasm_platform.h"
 #include "wasm_platform_log.h"
 #include "wasm_thread.h"
-#include "wasm-export.h"
+#include "wasm_export.h"
 #include "wasm_memory.h"
 #include "bh_memory.h"
 

core/iwasm/products/zephyr/simple/CMakeLists.txt

@@ -27,7 +27,7 @@ set (SHARED_LIB_ROOT ${IWASM_ROOT}/../shared-lib)
 include_directories (${IWASM_ROOT}/runtime/include
                      ${IWASM_ROOT}/runtime/platform/include
                      ${IWASM_ROOT}/runtime/platform/zephyr
-                     ${IWASM_ROOT}/runtime/vmcore_wasm
+                     ${IWASM_ROOT}/runtime/vmcore-wasm
                      ${SHARED_LIB_ROOT}/include
                      ${SHARED_LIB_ROOT}/platform/include
                      ${SHARED_LIB_ROOT}/platform/zephyr)
@@ -37,14 +37,14 @@ set (IWASM_SRCS ${IWASM_ROOT}/runtime/utils/wasm_hashmap.c
                 ${IWASM_ROOT}/runtime/utils/wasm_dlfcn.c
                 ${IWASM_ROOT}/runtime/platform/zephyr/wasm_math.c
                 ${IWASM_ROOT}/runtime/platform/zephyr/wasm_platform.c
-                ${IWASM_ROOT}/runtime/platform/zephyr/wasm-native.c
-                ${IWASM_ROOT}/runtime/vmcore_wasm/wasm-application.c
-                ${IWASM_ROOT}/runtime/vmcore_wasm/wasm-interp.c
-                ${IWASM_ROOT}/runtime/vmcore_wasm/wasm-loader.c
-                ${IWASM_ROOT}/runtime/vmcore_wasm/wasm-runtime.c
-                ${IWASM_ROOT}/runtime/vmcore_wasm/invokeNative_general.c
+                ${IWASM_ROOT}/runtime/platform/zephyr/wasm_native.c
+                ${IWASM_ROOT}/runtime/vmcore-wasm/wasm_application.c
+                ${IWASM_ROOT}/runtime/vmcore-wasm/wasm_interp.c
+                ${IWASM_ROOT}/runtime/vmcore-wasm/wasm_loader.c
+                ${IWASM_ROOT}/runtime/vmcore-wasm/wasm_runtime.c
+                ${IWASM_ROOT}/runtime/vmcore-wasm/invokeNative_general.c
                 ${IWASM_ROOT}/lib/native/libc/libc_wrapper.c
-                ${IWASM_ROOT}/lib/native/base/base-lib-export.c
+                ${IWASM_ROOT}/lib/native/base/base_lib_export.c
                 ${SHARED_LIB_ROOT}/platform/zephyr/bh_platform.c
                 ${SHARED_LIB_ROOT}/platform/zephyr/bh_assert.c
                 ${SHARED_LIB_ROOT}/platform/zephyr/bh_thread.c
@@ -54,4 +54,4 @@ set (IWASM_SRCS ${IWASM_ROOT}/runtime/utils/wasm_hashmap.c
                 ${SHARED_LIB_ROOT}/mem-alloc/ems/ems_alloc.c
                 ${SHARED_LIB_ROOT}/mem-alloc/ems/ems_hmu.c)
 
-target_sources(app PRIVATE ${IWASM_SRCS} src/main.c src/ext-lib-export.c)
+target_sources(app PRIVATE ${IWASM_SRCS} src/main.c src/ext_lib_export.c)

core/iwasm/products/zephyr/simple/src/ext_lib_export.c

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include "lib-export.h"
+#include "lib_export.h"
 
 static NativeSymbol extended_native_symbol_defs[] = { };
 
-#include "ext-lib-export.h"
+#include "ext_lib_export.h"

core/iwasm/products/zephyr/simple/src/main.c

@@ -21,7 +21,7 @@
 #include "wasm_platform.h"
 #include "wasm_platform_log.h"
 #include "wasm_thread.h"
-#include "wasm-export.h"
+#include "wasm_export.h"
 #include "wasm_memory.h"
 #include "bh_memory.h"
 #include "test_wasm.h"

core/iwasm/readme.txt

@@ -0,0 +1,75 @@
+
+1. How to build iwasm in Linux
+
+  cd products/linux/
+  mkdir build && cd build
+  cmake .. && make
+
+2. How to build iwasm in Zephyr system
+  (1) clone zephyr source code
+
+    git clone https://github.com/zephyrproject-rtos/zephyr.git
+
+  (2) copy <iwasm_root_dir>/products/zephyr/simple directory to zephry/samples/
+
+    cd zephyr/samples/
+    cp -a <iwasm_root_dir>/products/zephyr/simple simple
+    cd simple
+
+  (3) create a link to <iwasm_root_dir> and rename it to iwasm
+
+    ln -s <iwasm_root_dir> iwasm
+
+  (4) create a link to <shared-lib_root_dir> and rename it to shared-lib
+
+    ln -s <shared-lib_root_dir> shared-lib
+
+  (5) build source code
+
+    mkdir build && cd build
+    source ../../../zephyr-env.sh
+    cmake -GNinja -DBOARD=qemu_x86 ..
+    ninja
+
+  (6) run simple
+
+    ninja run
+
+3. How to build iwasm in AliOS-Things platform
+  (1) clone AliOS-Things source code
+
+    git clone https://github.com/alibaba/AliOS-Things.git
+
+  (2) copy <iwasm_root_dir>/products/alios-things directory to AliOS-Things/middleware,
+      and rename it as iwasm
+
+    cp -a <iwasm_root_dir>/products/alios-things middleware/iwasm
+
+  (3) create a link to <iwasm_root_dir> in middleware/iwasm/ and rename it to iwasm
+
+    ln -s <iwasm_root_dir> middleware/iwasm/iwasm
+
+  (4) create a link to <shared-lib_root_dir> in middleware/iwasm/ and rename it to shared-lib
+
+    ln -s <shared-lib_root_dir> middle/iwasm/shared-lib
+
+  (5) modify sample source code of AliOS-Things to call iwasm_init() function
+
+    modify file app/example/helloworld/helloworld.c, in the beginning of
+    function application_start(), add:
+
+      bool iwasm_init(void);
+      iwasm_init();
+
+    modify file app/example/helloworld/helloworld.mk, change
+      $(NAME)_COMPONENTS := yloop cli
+    to
+      $(NAME)_COMPONENTS := yloop cli iwasm
+
+  (6) build source code
+
+    aos make helloworld@linuxhost
+
+  (7) run source code
+    ./out/helloworld@linuxhost/binary/helloworld@linuxhost.elf
+

core/iwasm/runtime/include/ext_lib_export.h

@@ -17,7 +17,7 @@
 #ifndef _EXT_LIB_EXPORT_H_
 #define _EXT_LIB_EXPORT_H_
 
-#include "lib-export.h"
+#include "lib_export.h"
 
 #ifdef __cplusplus
 extern "C" {

core/iwasm/runtime/platform/include/wa_thread.h

@@ -20,8 +20,8 @@
  *        thread relative function.
  */
 
-#ifndef _WASM_THREAD_H
-#define _WASM_THREAD_H
+#ifndef _WA_THREAD_H
+#define _WA_THREAD_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -59,5 +59,5 @@ ws_mutex_init(korp_mutex *mutex, bool is_recursive)
 }
 #endif
 
-#endif /* end of _WASM_THREAD_H */
+#endif /* end of _WA_THREAD_H */
 

core/iwasm/runtime/platform/linux/wasm_native.c

@@ -18,8 +18,8 @@
 #define _GNU_SOURCE /* for O_DIRECT */
 #endif
 
-#include "wasm-native.h"
-#include "wasm-runtime.h"
+#include "wasm_native.h"
+#include "wasm_runtime.h"
 #include "wasm_log.h"
 #include "wasm_memory.h"
 #include "wasm_platform_log.h"

core/iwasm/runtime/platform/zephyr/wasm_math.c

@@ -39,64 +39,64 @@ typedef uint32_t u_int32_t;
 typedef uint64_t u_int64_t;
 
 typedef union u32double_tag {
-  int *pint;
-  double *pdouble;
+    int *pint;
+    double *pdouble;
 } U32DOUBLE;
 
 static inline int *
 pdouble2pint(double *pdouble)
 {
-  U32DOUBLE u;
-  u.pdouble = pdouble;
-  return u.pint;
+    U32DOUBLE u;
+    u.pdouble = pdouble;
+    return u.pint;
 }
 
 typedef union
 {
-  double value;
-  struct
-  {
-    u_int32_t lsw;
-    u_int32_t msw;
-  } parts;
-  struct
-  {
-    u_int64_t w;
-  } xparts;
+    double value;
+    struct
+    {
+        u_int32_t lsw;
+        u_int32_t msw;
+    } parts;
+    struct
+    {
+        u_int64_t w;
+    } xparts;
 } ieee_double_shape_type_little;
 
 typedef union
 {
-  double value;
-  struct
-  {
-    u_int32_t msw;
-    u_int32_t lsw;
-  } parts;
-  struct
-  {
-    u_int64_t w;
-  } xparts;
+    double value;
+    struct
+    {
+        u_int32_t msw;
+        u_int32_t lsw;
+    } parts;
+    struct
+    {
+        u_int64_t w;
+    } xparts;
 } ieee_double_shape_type_big;
 
 typedef union {
-	double	d;
-	struct {
-		unsigned int	manl	:32;
-		unsigned int	manh	:20;
-		unsigned int	exp	:11;
-		unsigned int	sign	:1;
-	} bits;
+    double	d;
+    struct {
+        unsigned int	manl	:32;
+        unsigned int	manh	:20;
+        unsigned int	exp	:11;
+        unsigned int	sign	:1;
+    } bits;
 } IEEEd2bits_L;
 
 typedef union {
-	double	d;
-	struct {
-		unsigned int	sign	:1;
-		unsigned int	exp	:11;
-		unsigned int	manh	:20;
-		unsigned int	manl	:32;
-	} bits;
+    double	d;
+    struct {
+        unsigned int	sign	:1;
+        unsigned int	exp	:11;
+        unsigned int	manh	:20;
+        unsigned int	manl	:32;
+    } bits;
 } IEEEd2bits_B;
 
 #define __HIL(x) *(1+pdouble2pint(&x))
@@ -107,107 +107,107 @@ typedef union {
 /* Get two 32 bit ints from a double.  */
 
 #define EXTRACT_WORDS_L(ix0,ix1,d)				\
-do {								\
-  ieee_double_shape_type_little ew_u;	                 	\
-  ew_u.value = (d);						\
-  (ix0) = ew_u.parts.msw;					\
-  (ix1) = ew_u.parts.lsw;					\
-} while (0)
+        do {								\
+            ieee_double_shape_type_little ew_u;	                 	\
+            ew_u.value = (d);						\
+            (ix0) = ew_u.parts.msw;					\
+            (ix1) = ew_u.parts.lsw;					\
+        } while (0)
 
 /* Set a double from two 32 bit ints.  */
 
 #define INSERT_WORDS_L(d,ix0,ix1)				\
-do {								\
-  ieee_double_shape_type_little iw_u;	                 	\
-  iw_u.parts.msw = (ix0);					\
-  iw_u.parts.lsw = (ix1);					\
-  (d) = iw_u.value;						\
-} while (0)
+        do {								\
+            ieee_double_shape_type_little iw_u;	                 	\
+            iw_u.parts.msw = (ix0);					\
+            iw_u.parts.lsw = (ix1);					\
+            (d) = iw_u.value;						\
+        } while (0)
 
 /* Get two 32 bit ints from a double.  */
 
 #define EXTRACT_WORDS_B(ix0,ix1,d)				\
-do {								\
-  ieee_double_shape_type_big ew_u;	                 	\
-  ew_u.value = (d);						\
-  (ix0) = ew_u.parts.msw;					\
-  (ix1) = ew_u.parts.lsw;					\
-} while (0)
+        do {								\
+            ieee_double_shape_type_big ew_u;	                 	\
+            ew_u.value = (d);						\
+            (ix0) = ew_u.parts.msw;					\
+            (ix1) = ew_u.parts.lsw;					\
+        } while (0)
 
 /* Set a double from two 32 bit ints.  */
 
 #define INSERT_WORDS_B(d,ix0,ix1)				\
-do {								\
-  ieee_double_shape_type_big iw_u;	                 	\
-  iw_u.parts.msw = (ix0);					\
-  iw_u.parts.lsw = (ix1);					\
-  (d) = iw_u.value;						\
-} while (0)
+        do {								\
+            ieee_double_shape_type_big iw_u;	                 	\
+            iw_u.parts.msw = (ix0);					\
+            iw_u.parts.lsw = (ix1);					\
+            (d) = iw_u.value;						\
+        } while (0)
 
 /* Get the more significant 32 bit int from a double.  */
 #define GET_HIGH_WORD_L(i,d)					\
-do {								\
-  ieee_double_shape_type_little gh_u;			        \
-  gh_u.value = (d);						\
-  (i) = gh_u.parts.msw;						\
-} while (0)
+        do {								\
+            ieee_double_shape_type_little gh_u;			        \
+            gh_u.value = (d);						\
+            (i) = gh_u.parts.msw;						\
+        } while (0)
 
 /* Get the more significant 32 bit int from a double.  */
 #define GET_HIGH_WORD_B(i,d)					\
-do {								\
-  ieee_double_shape_type_big gh_u;			        \
-  gh_u.value = (d);						\
-  (i) = gh_u.parts.msw;						\
-} while (0)
+        do {								\
+            ieee_double_shape_type_big gh_u;			        \
+            gh_u.value = (d);						\
+            (i) = gh_u.parts.msw;						\
+        } while (0)
 
 /* Set the more significant 32 bits of a double from an int.  */
 #define SET_HIGH_WORD_L(d,v)					\
-do {								\
-  ieee_double_shape_type_little sh_u;				\
-  sh_u.value = (d);						\
-  sh_u.parts.msw = (v);						\
-  (d) = sh_u.value;						\
-} while (0)
+        do {								\
+            ieee_double_shape_type_little sh_u;				\
+            sh_u.value = (d);						\
+            sh_u.parts.msw = (v);						\
+            (d) = sh_u.value;						\
+        } while (0)
 
 /* Set the more significant 32 bits of a double from an int.  */
 #define SET_HIGH_WORD_B(d,v)					\
-do {								\
-  ieee_double_shape_type_big sh_u;				\
-  sh_u.value = (d);						\
-  sh_u.parts.msw = (v);						\
-  (d) = sh_u.value;						\
-} while (0)
+        do {								\
+            ieee_double_shape_type_big sh_u;				\
+            sh_u.value = (d);						\
+            sh_u.parts.msw = (v);						\
+            (d) = sh_u.value;						\
+        } while (0)
 
 /* Macro wrappers.  */
 #define EXTRACT_WORDS(ix0,ix1,d) do { \
-  if (is_little_endian)               \
-    EXTRACT_WORDS_L(ix0,ix1,d);       \
-  else                                \
-    EXTRACT_WORDS_B(ix0,ix1,d);       \
+        if (is_little_endian)               \
+        EXTRACT_WORDS_L(ix0,ix1,d);       \
+        else                                \
+        EXTRACT_WORDS_B(ix0,ix1,d);       \
 } while (0)
 
 #define INSERT_WORDS(d,ix0,ix1) do {  \
-  if (is_little_endian)               \
-    INSERT_WORDS_L(d,ix0,ix1);        \
-  else                                \
-    INSERT_WORDS_B(d,ix0,ix1);        \
+        if (is_little_endian)               \
+        INSERT_WORDS_L(d,ix0,ix1);        \
+        else                                \
+        INSERT_WORDS_B(d,ix0,ix1);        \
 } while (0)
 
 #define GET_HIGH_WORD(i,d)					\
-do {								\
-  if (is_little_endian)                                         \
-    GET_HIGH_WORD_L(i,d);              			        \
-  else                                                          \
-    GET_HIGH_WORD_B(i,d);                                       \
-} while (0)
+        do {								\
+            if (is_little_endian)                                         \
+            GET_HIGH_WORD_L(i,d);              			        \
+            else                                                          \
+            GET_HIGH_WORD_B(i,d);                                       \
+        } while (0)
 
 #define SET_HIGH_WORD(d,v)					\
-do {								\
-  if (is_little_endian)                                         \
-    SET_HIGH_WORD_L(d,v);        				\
-  else                                                          \
-    SET_HIGH_WORD_B(d,v);                                       \
-} while (0)
+        do {								\
+            if (is_little_endian)                                         \
+            SET_HIGH_WORD_L(d,v);        				\
+            else                                                          \
+            SET_HIGH_WORD_B(d,v);                                       \
+        } while (0)
 
 #define __HI(x) (is_little_endian ? __HIL(x) : __HIB(x))
 
@@ -220,14 +220,14 @@ do {								\
 #define	STRICT_ASSIGN(type, lval, rval)	((lval) = (rval))
 #else
 #define	STRICT_ASSIGN(type, lval, rval) do {	\
-	volatile type __lval;			\
-						\
-	if (sizeof(type) >= sizeof(long double))	\
-		(lval) = (rval);		\
-	else {					\
-		__lval = (rval);		\
-		(lval) = __lval;		\
-	}					\
+        volatile type __lval;			\
+        \
+        if (sizeof(type) >= sizeof(long double))	\
+        (lval) = (rval);		\
+        else {					\
+            __lval = (rval);		\
+            (lval) = __lval;		\
+        }					\
 } while (0)
 #endif
 
@@ -257,8 +257,8 @@ static const double
 static double
 #endif
 TWO52[2]={
-  4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
- -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
+        4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
+        -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
 };
 
 static double freebsd_sqrt(double x);
@@ -270,312 +270,312 @@ static int freebsd_isnan(double x);
 
 static double freebsd_sqrt(double x)		/* wrapper sqrt */
 {
-	double z;
-	int32_t sign = (int)0x80000000;
-	int32_t ix0,s0,q,m,t,i;
-	u_int32_t r,t1,s1,ix1,q1;
+    double z;
+    int32_t sign = (int)0x80000000;
+    int32_t ix0,s0,q,m,t,i;
+    u_int32_t r,t1,s1,ix1,q1;
 
- 	EXTRACT_WORDS(ix0,ix1,x);
+    EXTRACT_WORDS(ix0,ix1,x);
 
     /* take care of Inf and NaN */
-	if((ix0&0x7ff00000)==0x7ff00000) {
-	    return x*x+x;		/* sqrt(NaN)=NaN, sqrt(+inf)=+inf
+    if((ix0&0x7ff00000)==0x7ff00000) {
+        return x*x+x;		/* sqrt(NaN)=NaN, sqrt(+inf)=+inf
 					   sqrt(-inf)=sNaN */
-	}
+    }
     /* take care of zero */
-	if(ix0<=0) {
-	    if(((ix0&(~sign))|ix1)==0) return x;/* sqrt(+-0) = +-0 */
-	    else if(ix0<0)
-		return (x-x)/(x-x);		/* sqrt(-ve) = sNaN */
-	}
+    if(ix0<=0) {
+        if(((ix0&(~sign))|ix1)==0) return x;/* sqrt(+-0) = +-0 */
+        else if(ix0<0)
+            return (x-x)/(x-x);		/* sqrt(-ve) = sNaN */
+    }
     /* normalize x */
-	m = (ix0>>20);
-	if(m==0) {				/* subnormal x */
-	    while(ix0==0) {
-		m -= 21;
-		ix0 |= (ix1>>11); ix1 <<= 21;
-	    }
-	    for(i=0;(ix0&0x00100000)==0;i++) ix0<<=1;
-	    m -= i-1;
-	    ix0 |= (ix1>>(32-i));
-	    ix1 <<= i;
-	}
-	m -= 1023;	/* unbias exponent */
-	ix0 = (ix0&0x000fffff)|0x00100000;
-	if(m&1){	/* odd m, double x to make it even */
-	    ix0 += ix0 + ((ix1&sign)>>31);
-	    ix1 += ix1;
-	}
-	m >>= 1;	/* m = [m/2] */
+    m = (ix0>>20);
+    if(m==0) {				/* subnormal x */
+        while(ix0==0) {
+            m -= 21;
+            ix0 |= (ix1>>11); ix1 <<= 21;
+        }
+        for(i=0;(ix0&0x00100000)==0;i++) ix0<<=1;
+        m -= i-1;
+        ix0 |= (ix1>>(32-i));
+        ix1 <<= i;
+    }
+    m -= 1023;	/* unbias exponent */
+    ix0 = (ix0&0x000fffff)|0x00100000;
+    if(m&1){	/* odd m, double x to make it even */
+        ix0 += ix0 + ((ix1&sign)>>31);
+        ix1 += ix1;
+    }
+    m >>= 1;	/* m = [m/2] */
 
     /* generate sqrt(x) bit by bit */
-	ix0 += ix0 + ((ix1&sign)>>31);
-	ix1 += ix1;
-	q = q1 = s0 = s1 = 0;	/* [q,q1] = sqrt(x) */
-	r = 0x00200000;		/* r = moving bit from right to left */
+    ix0 += ix0 + ((ix1&sign)>>31);
+    ix1 += ix1;
+    q = q1 = s0 = s1 = 0;	/* [q,q1] = sqrt(x) */
+    r = 0x00200000;		/* r = moving bit from right to left */
 
-	while(r!=0) {
-	    t = s0+r;
-	    if(t<=ix0) {
-		s0   = t+r;
-		ix0 -= t;
-		q   += r;
-	    }
-	    ix0 += ix0 + ((ix1&sign)>>31);
-	    ix1 += ix1;
-	    r>>=1;
-	}
+    while(r!=0) {
+        t = s0+r;
+        if(t<=ix0) {
+            s0   = t+r;
+            ix0 -= t;
+            q   += r;
+        }
+        ix0 += ix0 + ((ix1&sign)>>31);
+        ix1 += ix1;
+        r>>=1;
+    }
 
-	r = sign;
-	while(r!=0) {
-	    t1 = s1+r;
-	    t  = s0;
-	    if((t<ix0)||((t==ix0)&&(t1<=ix1))) {
-		s1  = t1+r;
-		if(((t1&sign)==sign)&&(s1&sign)==0) s0 += 1;
-		ix0 -= t;
-		if (ix1 < t1) ix0 -= 1;
-		ix1 -= t1;
-		q1  += r;
-	    }
-	    ix0 += ix0 + ((ix1&sign)>>31);
-	    ix1 += ix1;
-	    r>>=1;
-	}
+    r = sign;
+    while(r!=0) {
+        t1 = s1+r;
+        t  = s0;
+        if((t<ix0)||((t==ix0)&&(t1<=ix1))) {
+            s1  = t1+r;
+            if(((t1&sign)==sign)&&(s1&sign)==0) s0 += 1;
+            ix0 -= t;
+            if (ix1 < t1) ix0 -= 1;
+            ix1 -= t1;
+            q1  += r;
+        }
+        ix0 += ix0 + ((ix1&sign)>>31);
+        ix1 += ix1;
+        r>>=1;
+    }
 
     /* use floating add to find out rounding direction */
-	if((ix0|ix1)!=0) {
-	    z = one-tiny; /* trigger inexact flag */
-	    if (z>=one) {
-	        z = one+tiny;
-	        if (q1==(u_int32_t)0xffffffff) { q1=0; q += 1;}
-		else if (z>one) {
-		    if (q1==(u_int32_t)0xfffffffe) q+=1;
-		    q1+=2;
-		} else
-	            q1 += (q1&1);
-	    }
-	}
-	ix0 = (q>>1)+0x3fe00000;
-	ix1 =  q1>>1;
-	if ((q&1)==1) ix1 |= sign;
-	ix0 += (m <<20);
+    if((ix0|ix1)!=0) {
+        z = one-tiny; /* trigger inexact flag */
+        if (z>=one) {
+            z = one+tiny;
+            if (q1==(u_int32_t)0xffffffff) { q1=0; q += 1;}
+            else if (z>one) {
+                if (q1==(u_int32_t)0xfffffffe) q+=1;
+                q1+=2;
+            } else
+                q1 += (q1&1);
+        }
+    }
+    ix0 = (q>>1)+0x3fe00000;
+    ix1 =  q1>>1;
+    if ((q&1)==1) ix1 |= sign;
+    ix0 += (m <<20);
 
-	INSERT_WORDS(z,ix0,ix1);
+    INSERT_WORDS(z,ix0,ix1);
 
-	return z;
+    return z;
 }
 
 static double freebsd_floor(double x)
 {
-	int32_t i0,i1,j0;
-	u_int32_t i,j;
+    int32_t i0,i1,j0;
+    u_int32_t i,j;
 
-	EXTRACT_WORDS(i0,i1,x);
+    EXTRACT_WORDS(i0,i1,x);
 
-	j0 = ((i0>>20)&0x7ff)-0x3ff;
-	if(j0<20) {
-	    if(j0<0) { 	/* raise inexact if x != 0 */
-		if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
-		    if(i0>=0) {i0=i1=0;}
-		    else if(((i0&0x7fffffff)|i1)!=0)
-			{ i0=0xbff00000;i1=0;}
-		}
-	    } else {
-		i = (0x000fffff)>>j0;
-		if(((i0&i)|i1)==0) return x; /* x is integral */
-		if(huge+x>0.0) {	/* raise inexact flag */
-		    if(i0<0) i0 += (0x00100000)>>j0;
-		    i0 &= (~i); i1=0;
-		}
-	    }
-	} else if (j0>51) {
-	    if(j0==0x400) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
-	} else {
-	    i = ((u_int32_t)(0xffffffff))>>(j0-20);
-	    if((i1&i)==0) return x;	/* x is integral */
-	    if(huge+x>0.0) { 		/* raise inexact flag */
-		if(i0<0) {
-		    if(j0==20) i0+=1;
-		    else {
-			j = i1+(1<<(52-j0));
-			if(j<i1) i0 +=1 ; 	/* got a carry */
-			i1=j;
-		    }
-		}
-		i1 &= (~i);
-	    }
-	}
+    j0 = ((i0>>20)&0x7ff)-0x3ff;
+    if(j0<20) {
+        if(j0<0) { 	/* raise inexact if x != 0 */
+            if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
+                if(i0>=0) {i0=i1=0;}
+                else if(((i0&0x7fffffff)|i1)!=0)
+                { i0=0xbff00000;i1=0;}
+            }
+        } else {
+            i = (0x000fffff)>>j0;
+            if(((i0&i)|i1)==0) return x; /* x is integral */
+            if(huge+x>0.0) {	/* raise inexact flag */
+                if(i0<0) i0 += (0x00100000)>>j0;
+                i0 &= (~i); i1=0;
+            }
+        }
+    } else if (j0>51) {
+        if(j0==0x400) return x+x;	/* inf or NaN */
+        else return x;		/* x is integral */
+    } else {
+        i = ((u_int32_t)(0xffffffff))>>(j0-20);
+        if((i1&i)==0) return x;	/* x is integral */
+        if(huge+x>0.0) { 		/* raise inexact flag */
+            if(i0<0) {
+                if(j0==20) i0+=1;
+                else {
+                    j = i1+(1<<(52-j0));
+                    if(j<i1) i0 +=1 ; 	/* got a carry */
+                    i1=j;
+                }
+            }
+            i1 &= (~i);
+        }
+    }
 
-	INSERT_WORDS(x,i0,i1);
+    INSERT_WORDS(x,i0,i1);
 
-	return x;
+    return x;
 }
 
 static double freebsd_ceil(double x)
 {
-	int32_t i0,i1,j0;
-	u_int32_t i,j;
-	EXTRACT_WORDS(i0,i1,x);
-	j0 = ((i0>>20)&0x7ff)-0x3ff;
-	if(j0<20) {
-	    if(j0<0) { 	/* raise inexact if x != 0 */
-		if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
-		    if(i0<0) {i0=0x80000000;i1=0;}
-		    else if((i0|i1)!=0) { i0=0x3ff00000;i1=0;}
-		}
-	    } else {
-		i = (0x000fffff)>>j0;
-		if(((i0&i)|i1)==0) return x; /* x is integral */
-		if(huge+x>0.0) {	/* raise inexact flag */
-		    if(i0>0) i0 += (0x00100000)>>j0;
-		    i0 &= (~i); i1=0;
-		}
-	    }
-	} else if (j0>51) {
-	    if(j0==0x400) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
-	} else {
-	    i = ((u_int32_t)(0xffffffff))>>(j0-20);
-	    if((i1&i)==0) return x;	/* x is integral */
-	    if(huge+x>0.0) { 		/* raise inexact flag */
-		if(i0>0) {
-		    if(j0==20) i0+=1;
-		    else {
-			j = i1 + (1<<(52-j0));
-			if(j<i1) i0+=1;	/* got a carry */
-			i1 = j;
-		    }
-		}
-		i1 &= (~i);
-	    }
-	}
-	INSERT_WORDS(x,i0,i1);
-	return x;
+    int32_t i0,i1,j0;
+    u_int32_t i,j;
+    EXTRACT_WORDS(i0,i1,x);
+    j0 = ((i0>>20)&0x7ff)-0x3ff;
+    if(j0<20) {
+        if(j0<0) { 	/* raise inexact if x != 0 */
+            if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
+                if(i0<0) {i0=0x80000000;i1=0;}
+                else if((i0|i1)!=0) { i0=0x3ff00000;i1=0;}
+            }
+        } else {
+            i = (0x000fffff)>>j0;
+            if(((i0&i)|i1)==0) return x; /* x is integral */
+            if(huge+x>0.0) {	/* raise inexact flag */
+                if(i0>0) i0 += (0x00100000)>>j0;
+                i0 &= (~i); i1=0;
+            }
+        }
+    } else if (j0>51) {
+        if(j0==0x400) return x+x;	/* inf or NaN */
+        else return x;		/* x is integral */
+    } else {
+        i = ((u_int32_t)(0xffffffff))>>(j0-20);
+        if((i1&i)==0) return x;	/* x is integral */
+        if(huge+x>0.0) { 		/* raise inexact flag */
+            if(i0>0) {
+                if(j0==20) i0+=1;
+                else {
+                    j = i1 + (1<<(52-j0));
+                    if(j<i1) i0+=1;	/* got a carry */
+                    i1 = j;
+                }
+            }
+            i1 &= (~i);
+        }
+    }
+    INSERT_WORDS(x,i0,i1);
+    return x;
 }
 
 static double freebsd_rint(double x)
 {
-	int32_t i0,j0,sx;
-	u_int32_t i,i1;
-	double w,t;
-	EXTRACT_WORDS(i0,i1,x);
-	sx = (i0>>31)&1;
-	j0 = ((i0>>20)&0x7ff)-0x3ff;
-	if(j0<20) {
-	    if(j0<0) {
-		if(((i0&0x7fffffff)|i1)==0) return x;
-		i1 |= (i0&0x0fffff);
-		i0 &= 0xfffe0000;
-		i0 |= ((i1|-i1)>>12)&0x80000;
-		SET_HIGH_WORD(x,i0);
-	        STRICT_ASSIGN(double,w,TWO52[sx]+x);
-	        t =  w-TWO52[sx];
-		GET_HIGH_WORD(i0,t);
-		SET_HIGH_WORD(t,(i0&0x7fffffff)|(sx<<31));
-	        return t;
-	    } else {
-		i = (0x000fffff)>>j0;
-		if(((i0&i)|i1)==0) return x; /* x is integral */
-		i>>=1;
-		if(((i0&i)|i1)!=0) {
-		    /*
-		     * Some bit is set after the 0.5 bit.  To avoid the
-		     * possibility of errors from double rounding in
-		     * w = TWO52[sx]+x, adjust the 0.25 bit to a lower
-		     * guard bit.  We do this for all j0<=51.  The
-		     * adjustment is trickiest for j0==18 and j0==19
-		     * since then it spans the word boundary.
-		     */
-		    if(j0==19) i1 = 0x40000000; else
-		    if(j0==18) i1 = 0x80000000; else
-		    i0 = (i0&(~i))|((0x20000)>>j0);
-		}
-	    }
-	} else if (j0>51) {
-	    if(j0==0x400) return x+x;	/* inf or NaN */
-	    else return x;		/* x is integral */
-	} else {
-	    i = ((u_int32_t)(0xffffffff))>>(j0-20);
-	    if((i1&i)==0) return x;	/* x is integral */
-	    i>>=1;
-	    if((i1&i)!=0) i1 = (i1&(~i))|((0x40000000)>>(j0-20));
-	}
-	INSERT_WORDS(x,i0,i1);
-	STRICT_ASSIGN(double,w,TWO52[sx]+x);
-	return w-TWO52[sx];
+    int32_t i0,j0,sx;
+    u_int32_t i,i1;
+    double w,t;
+    EXTRACT_WORDS(i0,i1,x);
+    sx = (i0>>31)&1;
+    j0 = ((i0>>20)&0x7ff)-0x3ff;
+    if(j0<20) {
+        if(j0<0) {
+            if(((i0&0x7fffffff)|i1)==0) return x;
+            i1 |= (i0&0x0fffff);
+            i0 &= 0xfffe0000;
+            i0 |= ((i1|-i1)>>12)&0x80000;
+            SET_HIGH_WORD(x,i0);
+            STRICT_ASSIGN(double,w,TWO52[sx]+x);
+            t =  w-TWO52[sx];
+            GET_HIGH_WORD(i0,t);
+            SET_HIGH_WORD(t,(i0&0x7fffffff)|(sx<<31));
+            return t;
+        } else {
+            i = (0x000fffff)>>j0;
+            if(((i0&i)|i1)==0) return x; /* x is integral */
+            i>>=1;
+            if(((i0&i)|i1)!=0) {
+                /*
+                 * Some bit is set after the 0.5 bit.  To avoid the
+                 * possibility of errors from double rounding in
+                 * w = TWO52[sx]+x, adjust the 0.25 bit to a lower
+                 * guard bit.  We do this for all j0<=51.  The
+                 * adjustment is trickiest for j0==18 and j0==19
+                 * since then it spans the word boundary.
+                 */
+                if(j0==19) i1 = 0x40000000; else
+                    if(j0==18) i1 = 0x80000000; else
+                        i0 = (i0&(~i))|((0x20000)>>j0);
+            }
+        }
+    } else if (j0>51) {
+        if(j0==0x400) return x+x;	/* inf or NaN */
+        else return x;		/* x is integral */
+    } else {
+        i = ((u_int32_t)(0xffffffff))>>(j0-20);
+        if((i1&i)==0) return x;	/* x is integral */
+        i>>=1;
+        if((i1&i)!=0) i1 = (i1&(~i))|((0x40000000)>>(j0-20));
+    }
+    INSERT_WORDS(x,i0,i1);
+    STRICT_ASSIGN(double,w,TWO52[sx]+x);
+    return w-TWO52[sx];
 }
 
 static int freebsd_isnan(double d)
 {
-	if (is_little_endian) {
-	  IEEEd2bits_L u;
-	  u.d = d;
-	  return (u.bits.exp == 2047 && (u.bits.manl != 0 || u.bits.manh != 0));
-	}
-	else {
-      IEEEd2bits_B u;
-	  u.d = d;
-	  return (u.bits.exp == 2047 && (u.bits.manl != 0 || u.bits.manh != 0));
-	}
+    if (is_little_endian) {
+        IEEEd2bits_L u;
+        u.d = d;
+        return (u.bits.exp == 2047 && (u.bits.manl != 0 || u.bits.manh != 0));
+    }
+    else {
+        IEEEd2bits_B u;
+        u.d = d;
+        return (u.bits.exp == 2047 && (u.bits.manl != 0 || u.bits.manh != 0));
+    }
 }
 
 static double freebsd_fabs(double x)
 {
-	u_int32_t high;
-	GET_HIGH_WORD(high,x);
-	SET_HIGH_WORD(x,high&0x7fffffff);
-        return x;
+    u_int32_t high;
+    GET_HIGH_WORD(high,x);
+    SET_HIGH_WORD(x,high&0x7fffffff);
+    return x;
 }
 
 double sqrt(double x)
 {
-  return freebsd_sqrt(x);
+    return freebsd_sqrt(x);
 }
 
 double floor(double x)
 {
-  return freebsd_floor(x);
+    return freebsd_floor(x);
 }
 
 double ceil(double x)
 {
-  return freebsd_ceil(x);
+    return freebsd_ceil(x);
 }
 
 double fmin(double x, double y)
 {
-  return x < y ? x : y;
+    return x < y ? x : y;
 }
 
 double fmax(double x, double y)
 {
-  return x > y ? x : y;
+    return x > y ? x : y;
 }
 
 double rint(double x)
 {
-  return freebsd_rint(x);
+    return freebsd_rint(x);
 }
 
 double fabs(double x)
 {
-  return freebsd_fabs(x);
+    return freebsd_fabs(x);
 }
 
 int isnan(double x)
 {
-  return freebsd_isnan(x);
+    return freebsd_isnan(x);
 }
 
 double trunc(double x)
 {
-  return (x > 0) ? freebsd_floor(x) : freebsd_ceil(x);
+    return (x > 0) ? freebsd_floor(x) : freebsd_ceil(x);
 }
 
 int signbit(double x)
 {
-  return ((__HI(x) & 0x80000000) >> 31);
+    return ((__HI(x) & 0x80000000) >> 31);
 }
 

core/iwasm/runtime/platform/zephyr/wasm_native.c

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "wasm-native.h"
+#include "wasm_native.h"
 
 
 void*

core/iwasm/runtime/vmcore-wasm/invokeNative_general.c

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "wasm-runtime.h"
+#include "wasm_runtime.h"
 
 void invokeNative(uint32 argv[], uint32 argc, void (*native_code)())
 {

core/iwasm/runtime/vmcore-wasm/wasm_application.c

@@ -18,9 +18,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include "wasm.h"
-#include "wasm-interp.h"
-#include "wasm-runtime.h"
-#include "wasm-thread.h"
+#include "wasm_interp.h"
+#include "wasm_runtime.h"
+#include "wasm_thread.h"
 #include "wasm_assert.h"
 #include "wasm_log.h"
 #include "wasm_memory.h"

core/iwasm/runtime/vmcore-wasm/wasm_interp.c

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include "wasm-interp.h"
-#include "wasm-runtime.h"
-#include "wasm-thread.h"
-#include "wasm-opcode.h"
-#include "wasm-loader.h"
+#include "wasm_interp.h"
+#include "wasm_runtime.h"
+#include "wasm_thread.h"
+#include "wasm_opcode.h"
+#include "wasm_loader.h"
 #include "wasm_log.h"
 #include "wasm_memory.h"
 

core/iwasm/runtime/vmcore-wasm/wasm_loader.c

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include "wasm-loader.h"
+#include "wasm_loader.h"
 #include "wasm.h"
-#include "wasm-native.h"
-#include "wasm-opcode.h"
-#include "wasm-runtime.h"
+#include "wasm_native.h"
+#include "wasm_opcode.h"
+#include "wasm_runtime.h"
 #include "wasm_log.h"
 #include "wasm_memory.h"
 
@@ -373,7 +373,10 @@ resolve_sym(const char *module_name, const char *field_name)
         return NULL;
 
     if (field_name[0] == '_'
-            && (sym = wasm_dlsym(NULL, field_name + 1)))
+        && (sym = wasm_dlsym(NULL, field_name + 1)))
+        return sym;
+
+    if ((sym = wasm_dlsym(NULL, field_name)))
         return sym;
 
     return NULL;

core/iwasm/runtime/vmcore-wasm/wasm_runtime.c

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include "wasm-runtime.h"
-#include "wasm-thread.h"
-#include "wasm-loader.h"
-#include "wasm-native.h"
-#include "wasm-interp.h"
+#include "wasm_runtime.h"
+#include "wasm_thread.h"
+#include "wasm_loader.h"
+#include "wasm_native.h"
+#include "wasm_interp.h"
 #include "wasm_log.h"
 #include "wasm_platform_log.h"
 #include "wasm_memory.h"

core/iwasm/runtime/vmcore-wasm/wasm_runtime.h

@@ -18,7 +18,7 @@
 #define _WASM_RUNTIME_H
 
 #include "wasm.h"
-#include "wasm-thread.h"
+#include "wasm_thread.h"
 #include "wasm_hashmap.h"
 
 #ifdef __cplusplus

core/iwasm/runtime/vmcore-wasm/wasm_thread.h

@@ -18,7 +18,7 @@
 #define _WASM_RUNTIME_THREAD_H
 
 #include "wasm_assert.h"
-#include "wasm_thread.h"
+#include "wa_thread.h"
 
 #ifdef __cplusplus
 extern "C" {

core/shared-lib/coap/LICENSE

@@ -0,0 +1,38 @@
+Contiki is licensed under the 3-clause BSD license. This license gives
+everyone the right to use and distribute the code, either in binary or
+source code format, as long as the copyright license is retained in
+the source code.
+
+The copyright for different parts of the code is held by different
+people and organizations, but the code is licensed under the same type
+of license. The license text is:
+
+  * Copyright (c) (Year), (Name of copyright holder)
+  * All rights reserved.
+  *
+  * Redistribution and use in source and binary forms, with or without
+  * modification, are permitted provided that the following conditions
+  * are met:
+  * 1. Redistributions of source code must retain the above copyright
+  *    notice, this list of conditions and the following disclaimer.
+  * 2. Redistributions in binary form must reproduce the above copyright
+  *    notice, this list of conditions and the following disclaimer in the
+  *    documentation and/or other materials provided with the distribution.
+  *
+  * 3. Neither the name of the copyright holder nor the names of its
+  *    contributors may be used to endorse or promote products derived
+  *    from this software without specific prior written permission.
+  *
+  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+      * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+  * OF THE POSSIBILITY OF SUCH DAMAGE.
+

core/shared-lib/coap/Makefile

@@ -0,0 +1,19 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+COAP_ROOT=${ZEPHYR_BASE}/subsys/aee/Beihai/runtime/utils/coap
+subdir-ccflags-y += -I${COAP_ROOT}/er-coap -I${COAP_ROOT}/extension
+
+obj-y += er-coap/
+obj-y += extension/

core/shared-lib/coap/er-coap/Makefile

@@ -0,0 +1,15 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+obj-y += er-coap.o

core/shared-lib/coap/er-coap/er-coap-conf.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the Contiki operating system.
+ */
+
+/**
+ * \file
+ *      Collection of default configuration values.
+ * \author
+ *      Matthias Kovatsch <kovatsch@inf.ethz.ch>
+ */
+
+#ifndef ER_COAP_CONF_H_
+#define ER_COAP_CONF_H_
+
+/* Features that can be disabled to achieve smaller memory footprint */
+#define COAP_LINK_FORMAT_FILTERING     0
+#define COAP_PROXY_OPTION_PROCESSING   0
+
+/* Listening port for the CoAP REST Engine */
+#ifndef COAP_SERVER_PORT
+#define COAP_SERVER_PORT               COAP_DEFAULT_PORT
+#endif
+
+/* The number of concurrent messages that can be stored for retransmission in the transaction layer. */
+#ifndef COAP_MAX_OPEN_TRANSACTIONS
+#define COAP_MAX_OPEN_TRANSACTIONS     4
+#endif /* COAP_MAX_OPEN_TRANSACTIONS */
+
+/* Maximum number of failed request attempts before action */
+#ifndef COAP_MAX_ATTEMPTS
+#define COAP_MAX_ATTEMPTS              4
+#endif /* COAP_MAX_ATTEMPTS */
+
+/* Conservative size limit, as not all options have to be set at the same time. Check when Proxy-Uri option is used */
+#ifndef COAP_MAX_HEADER_SIZE    /*     Hdr                  CoF  If-Match         Obs Blo strings   */
+#define COAP_MAX_HEADER_SIZE           512
+//(4 + COAP_TOKEN_LEN + 3 + 1 + COAP_ETAG_LEN + 4 + 4 + 30)  /* 65 */
+#endif /* COAP_MAX_HEADER_SIZE */
+
+/* Number of observer slots (each takes abot xxx bytes) */
+#ifndef COAP_MAX_OBSERVERS
+#define COAP_MAX_OBSERVERS    COAP_MAX_OPEN_TRANSACTIONS - 1
+#endif /* COAP_MAX_OBSERVERS */
+
+/* Interval in notifies in which NON notifies are changed to CON notifies to check client. */
+#define COAP_OBSERVE_REFRESH_INTERVAL  20
+
+#endif /* ER_COAP_CONF_H_ */

core/shared-lib/coap/er-coap/er-coap-constants.h

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the Contiki operating system.
+ */
+
+/**
+ * \file
+ *      Collection of constants specified in the CoAP standard.
+ * \author
+ *      Matthias Kovatsch <kovatsch@inf.ethz.ch>
+ */
+
+#ifndef ER_COAP_CONSTANTS_H_
+#define ER_COAP_CONSTANTS_H_
+
+#define COAP_DEFAULT_PORT                    5683
+
+#define COAP_DEFAULT_MAX_AGE                 60
+#define COAP_RESPONSE_TIMEOUT                3
+#define COAP_RESPONSE_RANDOM_FACTOR          1.5
+#define COAP_MAX_RETRANSMIT                  4
+
+#define COAP_HEADER_LEN                      4  /* | version:0x03 type:0x0C tkl:0xF0 | code | mid:0x00FF | mid:0xFF00 | */
+#define COAP_TOKEN_LEN                       8  /* The maximum number of bytes for the Token */
+#define COAP_ETAG_LEN                        8  /* The maximum number of bytes for the ETag */
+
+#define COAP_HEADER_VERSION_MASK             0xC0
+#define COAP_HEADER_VERSION_POSITION         6
+#define COAP_HEADER_TYPE_MASK                0x30
+#define COAP_HEADER_TYPE_POSITION            4
+#define COAP_HEADER_TOKEN_LEN_MASK           0x0F
+#define COAP_HEADER_TOKEN_LEN_POSITION       0
+
+#define COAP_HEADER_OPTION_DELTA_MASK        0xF0
+#define COAP_HEADER_OPTION_SHORT_LENGTH_MASK 0x0F
+
+/* CoAP message types */
+typedef enum {
+    COAP_TYPE_CON, /* confirmables */
+    COAP_TYPE_NON, /* non-confirmables */
+    COAP_TYPE_ACK, /* acknowledgements */
+    COAP_TYPE_RST /* reset */
+} coap_message_type_t;
+
+/* CoAP request method codes */
+typedef enum {
+    COAP_GET = 1, COAP_POST, COAP_PUT, COAP_DELETE
+} coap_method_t;
+
+/* CoAP response codes */
+typedef enum {
+    NO_ERROR = 0,
+
+    CREATED_2_01 = 65, /* CREATED */
+    DELETED_2_02 = 66, /* DELETED */
+    VALID_2_03 = 67, /* NOT_MODIFIED */
+    CHANGED_2_04 = 68, /* CHANGED */
+    CONTENT_2_05 = 69, /* OK */
+    CONTINUE_2_31 = 95, /* CONTINUE */
+
+    BAD_REQUEST_4_00 = 128, /* BAD_REQUEST */
+    UNAUTHORIZED_4_01 = 129, /* UNAUTHORIZED */
+    BAD_OPTION_4_02 = 130, /* BAD_OPTION */
+    FORBIDDEN_4_03 = 131, /* FORBIDDEN */
+    NOT_FOUND_4_04 = 132, /* NOT_FOUND */
+    METHOD_NOT_ALLOWED_4_05 = 133, /* METHOD_NOT_ALLOWED */
+    NOT_ACCEPTABLE_4_06 = 134, /* NOT_ACCEPTABLE */
+    PRECONDITION_FAILED_4_12 = 140, /* BAD_REQUEST */
+    REQUEST_ENTITY_TOO_LARGE_4_13 = 141, /* REQUEST_ENTITY_TOO_LARGE */
+    UNSUPPORTED_MEDIA_TYPE_4_15 = 143, /* UNSUPPORTED_MEDIA_TYPE */
+
+    INTERNAL_SERVER_ERROR_5_00 = 160, /* INTERNAL_SERVER_ERROR */
+    NOT_IMPLEMENTED_5_01 = 161, /* NOT_IMPLEMENTED */
+    BAD_GATEWAY_5_02 = 162, /* BAD_GATEWAY */
+    SERVICE_UNAVAILABLE_5_03 = 163, /* SERVICE_UNAVAILABLE */
+    GATEWAY_TIMEOUT_5_04 = 164, /* GATEWAY_TIMEOUT */
+    PROXYING_NOT_SUPPORTED_5_05 = 165, /* PROXYING_NOT_SUPPORTED */
+
+    /* Erbium errors */
+    MEMORY_ALLOCATION_ERROR = 192, PACKET_SERIALIZATION_ERROR,
+
+    /* Erbium hooks */
+    MANUAL_RESPONSE, PING_RESPONSE
+} coap_status_t;
+
+/* CoAP header option numbers */
+typedef enum {
+    COAP_OPTION_IF_MATCH = 1, /* 0-8 B */
+    COAP_OPTION_URI_HOST = 3, /* 1-255 B */
+    COAP_OPTION_ETAG = 4, /* 1-8 B */
+    COAP_OPTION_IF_NONE_MATCH = 5, /* 0 B */
+    COAP_OPTION_OBSERVE = 6, /* 0-3 B */
+    COAP_OPTION_URI_PORT = 7, /* 0-2 B */
+    COAP_OPTION_LOCATION_PATH = 8, /* 0-255 B */
+    COAP_OPTION_URI_PATH = 11, /* 0-255 B */
+    COAP_OPTION_CONTENT_FORMAT = 12, /* 0-2 B */
+    COAP_OPTION_MAX_AGE = 14, /* 0-4 B */
+    COAP_OPTION_URI_QUERY = 15, /* 0-255 B */
+    COAP_OPTION_ACCEPT = 17, /* 0-2 B */
+    COAP_OPTION_LOCATION_QUERY = 20, /* 0-255 B */
+    COAP_OPTION_BLOCK2 = 23, /* 1-3 B */
+    COAP_OPTION_BLOCK1 = 27, /* 1-3 B */
+    COAP_OPTION_SIZE2 = 28, /* 0-4 B */
+    COAP_OPTION_PROXY_URI = 35, /* 1-1034 B */
+    COAP_OPTION_PROXY_SCHEME = 39, /* 1-255 B */
+    COAP_OPTION_SIZE1 = 60, /* 0-4 B */
+} coap_option_t;
+
+/* CoAP Content-Formats */
+typedef enum {
+    TEXT_PLAIN = 0,
+    TEXT_XML = 1,
+    TEXT_CSV = 2,
+    TEXT_HTML = 3,
+    IMAGE_GIF = 21,
+    IMAGE_JPEG = 22,
+    IMAGE_PNG = 23,
+    IMAGE_TIFF = 24,
+    AUDIO_RAW = 25,
+    VIDEO_RAW = 26,
+    APPLICATION_LINK_FORMAT = 40,
+    APPLICATION_XML = 41,
+    APPLICATION_OCTET_STREAM = 42,
+    APPLICATION_RDF_XML = 43,
+    APPLICATION_SOAP_XML = 44,
+    APPLICATION_ATOM_XML = 45,
+    APPLICATION_XMPP_XML = 46,
+    APPLICATION_EXI = 47,
+    APPLICATION_FASTINFOSET = 48,
+    APPLICATION_SOAP_FASTINFOSET = 49,
+    APPLICATION_JSON = 50,
+    APPLICATION_X_OBIX_BINARY = 51
+} coap_content_format_t;
+
+#endif /* ER_COAP_CONSTANTS_H_ */

core/shared-lib/coap/er-coap/er-coap.h

@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file is part of the Contiki operating system.
+ */
+
+/**
+ * \file
+ *      An implementation of the Constrained Application Protocol (RFC).
+ * \author
+ *      Matthias Kovatsch <kovatsch@inf.ethz.ch>
+ */
+
+#ifndef ER_COAP_H_
+#define ER_COAP_H_
+
+#include "../extension/coap_platforms.h"
+#include <stddef.h> /* for size_t */
+#include <stdint.h>
+//#include "contiki-net.h"
+#include "er-coap-constants.h"
+#include "er-coap-conf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* sanity check for configured values */
+#define COAP_MAX_PACKET_SIZE  (COAP_MAX_HEADER_SIZE + REST_MAX_CHUNK_SIZE)
+/*#if COAP_MAX_PACKET_SIZE > (UIP_BUFSIZE - UIP_IPH_LEN - UIP_UDPH_LEN)
+ #error "UIP_CONF_BUFFER_SIZE too small for REST_MAX_CHUNK_SIZE"
+ #endif
+ */
+
+/* ------------------------------------------------------ */
+/* ------  section added by the coap request  ---------   */
+/* ------------------------------------------------------ */
+
+//typedef int (*restful_response_handler)(void *response,void *data);
+#define RX_TIMEOUT (-1)
+typedef int (*Tx_Data)(void * coap_ctx, const uip_ipaddr_t *dst_addr, void *buf, int len);
+typedef int (*Rx_Data) (void * coap_ctx, void *buf, int len, int timeout);
+typedef int (*Request_Handler) (void * coap_ctx, void *);
+
+typedef int (*CoAP_Res_Handler) (void * request, void * response, char **out_payload, int * payload_len);
+
+typedef struct _coap_resource_handler
+{
+	struct _coap_resource_handler * next;
+	char * url;
+	CoAP_Res_Handler get_handler;
+	CoAP_Res_Handler put_handler;
+	CoAP_Res_Handler post_handler;
+	CoAP_Res_Handler other_handler;  // create | delete
+}coap_resource_handler_t;
+
+
+
+typedef struct res_block_state
+{
+	struct res_block_state * next;
+	char * url;
+	void * buffer;
+	int buffer_size;
+	uint32_t block_num;
+	uint16_t block_size;
+                   uint16_t content_fmt;
+	uint32_t last_access;
+	uint8_t  is_get;
+} res_block_state_t;
+
+
+typedef struct peer_block_state
+{
+	struct peer_block_state * next;
+	struct net_addr_coap peer_addr;
+	res_block_state_t * list;
+}peer_block_state_t;
+
+
+typedef struct coap_context {
+  uint8_t  * buf;
+  uint32_t buf_len;		// the data length
+  uint32_t buf_size;  // the malloced buffer size
+
+  struct net_addr_coap my_addr;
+
+  // the address associated with current buffer
+  struct net_addr_coap src_addr;
+
+  uint8_t status;
+  uint8_t is_used;
+  uint8_t response_on_not_found;
+  uint16_t default_retrans_cnt;
+  uint32_t default_retrans_ms;
+
+  Tx_Data tx_data;
+  Rx_Data rx_data;
+
+  int socket;
+  char * user_data;
+
+  peer_block_state_t * blockwise_list;
+  coap_resource_handler_t * resource_handlers;
+
+  void * transactions;
+  void * transaction_lock;
+  uint32_t last_checktime;
+
+  void * request_handler;
+
+#ifdef WITH_DTLS
+struct dtls_context_t *dtls_context;
+dtls_handler_t dtls_handler;
+struct process *process;
+#endif /* WITH_DTLS */
+
+} coap_context_t;
+
+int add_resource_handler(coap_context_t * coap_ctx, coap_resource_handler_t * handler);
+
+
+// coap_context_t * coap_context_new(uip_ipaddr_t *my_addr, uint16_t my_port); //CANNOTBUILD
+void coap_context_close(coap_context_t *coap_ctx);
+void coap_ctx_send(coap_context_t *coap_ctx, uint8_t *data,
+                  uint16_t length);
+
+/* ---------------- end of section ------------------ */
+
+
+/* use Erbium CoAP for the REST Engine. Must come before include of rest-engine.h. */
+//#define REST coap_rest_implementation
+//#include "rest-engine.h"
+
+/* REST_MAX_CHUNK_SIZE can be different from 2^x so we need to get next lower 2^x for COAP_MAX_BLOCK_SIZE */
+#ifndef COAP_MAX_BLOCK_SIZE
+#define COAP_MAX_BLOCK_SIZE           (REST_MAX_CHUNK_SIZE < 32 ? 16 : \
+                                       (REST_MAX_CHUNK_SIZE < 64 ? 32 : \
+                                        (REST_MAX_CHUNK_SIZE < 128 ? 64 : \
+                                         (REST_MAX_CHUNK_SIZE < 256 ? 128 : \
+                                          (REST_MAX_CHUNK_SIZE < 512 ? 256 : \
+                                          (REST_MAX_CHUNK_SIZE < 1024 ? 512 : \
+                                          (REST_MAX_CHUNK_SIZE < 2048 ? 1024 : 2048)))))))
+#endif /* COAP_MAX_BLOCK_SIZE */
+
+/* direct access into the buffer */
+#define UIP_IP_BUF   ((struct uip_ip_hdr *)&uip_buf[UIP_LLH_LEN])
+#ifdef NETSTACK_CONF_WITH_IPV6
+#define UIP_UDP_BUF  ((struct uip_udp_hdr *)&uip_buf[uip_l2_l3_hdr_len])
+#else
+#define UIP_UDP_BUF  ((struct uip_udp_hdr *)&uip_buf[UIP_LLH_LEN + UIP_IPH_LEN])
+#endif
+
+/* bitmap for set options */
+enum { OPTION_MAP_SIZE = sizeof(uint8_t) * 8 };
+
+#define SET_OPTION(packet, opt) ((packet)->options[opt / OPTION_MAP_SIZE] |= 1 << (opt % OPTION_MAP_SIZE))
+#define IS_OPTION(packet, opt) ((packet)->options[opt / OPTION_MAP_SIZE] & (1 << (opt % OPTION_MAP_SIZE)))
+
+/* parsed message struct */
+typedef struct {
+  uint8_t *buffer; /* pointer to CoAP header / incoming packet buffer / memory to serialize packet */
+
+  uint8_t version;
+  coap_message_type_t type;
+  uint8_t code;
+  uint16_t mid;
+
+  uint8_t token_len;
+  uint8_t token[COAP_TOKEN_LEN];
+
+  uint8_t options[COAP_OPTION_SIZE1 / OPTION_MAP_SIZE + 1]; /* bitmap to check if option is set */
+
+  coap_content_format_t content_format; /* parse options once and store; allows setting options in random order  */
+  uint32_t max_age;
+  uint8_t etag_len;
+  uint8_t etag[COAP_ETAG_LEN];
+  size_t proxy_uri_len;
+  const char *proxy_uri;
+  size_t proxy_scheme_len;
+  const char *proxy_scheme;
+  size_t uri_host_len;
+  const char *uri_host;
+  size_t location_path_len;
+  const char *location_path;
+  uint16_t uri_port;
+  size_t location_query_len;
+  const char *location_query;
+  size_t uri_path_len;
+  const char *uri_path;
+  int32_t observe;
+  coap_content_format_t accept;
+  uint8_t if_match_len;
+  uint8_t if_match[COAP_ETAG_LEN];
+  uint32_t block2_num;
+  uint8_t block2_more;
+  uint32_t block2_size;
+  uint32_t block2_offset;
+  uint32_t block1_num;
+  uint8_t block1_more;
+  uint32_t block1_size;
+  uint32_t block1_offset;
+  uint32_t size2;
+  uint32_t size1;
+  size_t uri_query_len;
+  const char *uri_query;
+  uint8_t if_none_match;
+
+  uint32_t payload_len;
+  uint8_t *payload;
+} coap_packet_t;
+
+/* option format serialization */
+#define COAP_SERIALIZE_INT_OPTION(number, field, text) \
+  if(IS_OPTION(coap_pkt, number)) { \
+    PRINTF(text " [%u]\n", coap_pkt->field); \
+    option += coap_serialize_int_option(number, current_number, option, coap_pkt->field); \
+    current_number = number; \
+  }
+#define COAP_SERIALIZE_BYTE_OPTION(number, field, text) \
+  if(IS_OPTION(coap_pkt, number)) { \
+    PRINTF(text " %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n", coap_pkt->field##_len, \
+           coap_pkt->field[0], \
+           coap_pkt->field[1], \
+           coap_pkt->field[2], \
+           coap_pkt->field[3], \
+           coap_pkt->field[4], \
+           coap_pkt->field[5], \
+           coap_pkt->field[6], \
+           coap_pkt->field[7] \
+           ); /* FIXME always prints 8 bytes */ \
+    option += coap_serialize_array_option(number, current_number, option, coap_pkt->field, coap_pkt->field##_len, '\0'); \
+    current_number = number; \
+  }
+#define COAP_SERIALIZE_STRING_OPTION(number, field, splitter, text) \
+  if(IS_OPTION(coap_pkt, number)) { \
+    PRINTF(text " [%.*s]\n", coap_pkt->field##_len, coap_pkt->field); \
+    option += coap_serialize_array_option(number, current_number, option, (uint8_t *)coap_pkt->field, coap_pkt->field##_len, splitter); \
+    current_number = number; \
+  }
+#define COAP_SERIALIZE_BLOCK_OPTION(number, field, text) \
+  if(IS_OPTION(coap_pkt, number)) \
+  { \
+    PRINTF(text " [%lu%s (%u B/blk)]\n", coap_pkt->field##_num, coap_pkt->field##_more ? "+" : "", coap_pkt->field##_size); \
+    uint32_t block = coap_pkt->field##_num << 4; \
+    if(coap_pkt->field##_more) { block |= 0x8; } \
+    block |= 0xF & coap_log_2(coap_pkt->field##_size / 16); \
+    PRINTF(text " encoded: 0x%lX\n", block); \
+    option += coap_serialize_int_option(number, current_number, option, block); \
+    current_number = number; \
+  }
+
+/* to store error code and human-readable payload */
+extern coap_status_t erbium_status_code;
+extern char *coap_error_message;
+
+void coap_init_connection(uint16_t port);
+uint16_t coap_get_mid(void);
+
+void coap_init_message(void *packet, coap_message_type_t type, uint8_t code,
+                       uint16_t mid);
+size_t coap_serialize_message(void *packet, uint8_t *buffer);
+void coap_send_message(coap_context_t*, uip_ipaddr_t *addr, uint16_t port, uint8_t *data,
+                       uint16_t length);
+coap_status_t coap_parse_message(void *request, uint8_t *data,
+                                 uint16_t data_len);
+
+int coap_get_query_variable(void *packet, const char *name,
+                            const char **output);
+int coap_get_post_variable(void *packet, const char *name,
+                           const char **output);
+
+/*---------------------------------------------------------------------------*/
+
+int coap_set_status_code(void *packet, unsigned int code);
+
+int coap_set_token(void *packet, const uint8_t *token, size_t token_len);
+
+int coap_get_header_content_format(void *packet, unsigned int *format);
+int coap_set_header_content_format(void *packet, unsigned int format);
+
+int coap_get_header_accept(void *packet, unsigned int *accept);
+int coap_set_header_accept(void *packet, unsigned int accept);
+
+int coap_get_header_max_age(void *packet, uint32_t *age);
+int coap_set_header_max_age(void *packet, uint32_t age);
+
+int coap_get_header_etag(void *packet, const uint8_t **etag);
+int coap_set_header_etag(void *packet, const uint8_t *etag, size_t etag_len);
+
+int coap_get_header_if_match(void *packet, const uint8_t **etag);
+int coap_set_header_if_match(void *packet, const uint8_t *etag,
+                             size_t etag_len);
+
+int coap_get_header_if_none_match(void *packet);
+int coap_set_header_if_none_match(void *packet);
+
+int coap_get_header_proxy_uri(void *packet, const char **uri); /* in-place string might not be 0-terminated. */
+int coap_set_header_proxy_uri(void *packet, const char *uri);
+
+int coap_get_header_proxy_scheme(void *packet, const char **scheme); /* in-place string might not be 0-terminated. */
+int coap_set_header_proxy_scheme(void *packet, const char *scheme);
+
+int coap_get_header_uri_host(void *packet, const char **host); /* in-place string might not be 0-terminated. */
+int coap_set_header_uri_host(void *packet, const char *host);
+
+int coap_get_header_uri_path(void *packet, const char **path); /* in-place string might not be 0-terminated. */
+int coap_set_header_uri_path(void *packet, const char *path);
+
+int coap_get_header_uri_query(void *packet, const char **query); /* in-place string might not be 0-terminated. */
+int coap_set_header_uri_query(void *packet, const char *query);
+
+int coap_get_header_location_path(void *packet, const char **path); /* in-place string might not be 0-terminated. */
+int coap_set_header_location_path(void *packet, const char *path); /* also splits optional query into Location-Query option. */
+
+int coap_get_header_location_query(void *packet, const char **query); /* in-place string might not be 0-terminated. */
+int coap_set_header_location_query(void *packet, const char *query);
+
+int coap_get_header_observe(void *packet, uint32_t *observe);
+int coap_set_header_observe(void *packet, uint32_t observe);
+
+int coap_get_header_block2(void *packet, uint32_t *num, uint8_t *more,
+                           uint32_t *size, uint32_t *offset);
+int coap_set_header_block2(void *packet, uint32_t num, uint8_t more,
+                           uint32_t size);
+
+int coap_get_header_block1(void *packet, uint32_t *num, uint8_t *more,
+                           uint16_t *size, uint32_t *offset);
+int coap_set_header_block1(void *packet, uint32_t num, uint8_t more,
+                           uint16_t size);
+
+int coap_get_header_size2(void *packet, uint32_t *size);
+int coap_set_header_size2(void *packet, uint32_t size);
+
+int coap_get_header_size1(void *packet, uint32_t *size);
+int coap_set_header_size1(void *packet, uint32_t size);
+
+int coap_get_payload(void *packet, const uint8_t **payload);
+int coap_set_payload(void *packet, const void *payload, size_t length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ER_COAP_H_ */

core/shared-lib/coap/extension/Makefile

@@ -0,0 +1,15 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+obj-y += coap_over_tcp.o

core/shared-lib/coap/extension/coap_conversion.c

@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "coap_ext.h"
+
+char * coap_get_full_url_alloc(coap_packet_t * request)
+{
+    const char *url = NULL;
+    const char * query = NULL;
+    int url_len = coap_get_header_uri_path(request, &url);
+    int query_len = coap_get_header_uri_query(request, &query);
+
+    if (url_len == 0)
+        return NULL;
+
+    char * url_alloc = (char*) bh_malloc(url_len + 1 + query_len + 1);
+    memcpy(url_alloc, url, url_len);
+    url_alloc[url_len] = 0;
+
+    // make the url looks like /abc?e=f
+    if (query_len != 0) {
+        strcat(url_alloc, "&");
+        memcpy(url_alloc + strlen(url_alloc), query, query_len);
+        url_alloc[url_len + 1 + query_len] = 0;
+    }
+
+    return url_alloc;
+}
+
+void convert_request_to_coap_packet(request_t * req, coap_packet_t * packet)
+{
+    coap_init_message(packet, COAP_TYPE_NON, req->action, req->mid);
+    coap_set_token(packet, (uint8_t *) &req->mid, sizeof(req->mid));
+    coap_set_header_content_format(packet, req->fmt);
+
+    coap_set_header_uri_path(packet, req->url);
+
+    coap_set_payload(packet, req->payload, req->payload_len);
+
+    packet->mid = req->mid;
+}
+
+void convert_response_to_coap_packet(response_t * response,
+        coap_packet_t * packet)
+{
+    coap_init_message(packet, COAP_TYPE_NON, response->status, response->mid);
+    coap_set_token(packet, (uint8_t *) &response->mid, sizeof(response->mid));
+    coap_set_header_content_format(packet, response->fmt);
+    coap_set_payload(packet, response->payload, response->payload_len);
+
+    packet->mid = response->mid;
+}
+
+// return: the length of url.
+//         note: the url is probably not end with 0 due to coap packing design.
+int convert_coap_packet_to_request(coap_packet_t *packet, request_t *request)
+{
+    const char *url = NULL;
+    int url_len = coap_get_header_uri_path(packet, &url);
+
+    memset(request, 0, sizeof(*request));
+
+    request->action = packet->code;
+    request->fmt = packet->content_format;
+    if (packet->token_len == 4) {
+        request->mid = *((unsigned long *) packet->token);
+    } else {
+        request->mid = packet->mid;
+    }
+    request->payload = packet->payload;
+    request->payload_len = packet->payload_len;
+    request->url = (char *)url;
+    return url_len;
+}
+
+void convert_coap_packet_to_response(coap_packet_t *packet,
+        response_t *response)
+{
+    memset(response, 0, sizeof(*response));
+
+    response->status = packet->code;
+    response->fmt = packet->content_format;
+    if (packet->token_len == 4) {
+        response->mid = *((unsigned long *) packet->token);
+    } else {
+        response->mid = packet->mid;
+    }
+
+    response->payload = packet->payload;
+    response->payload_len = packet->payload_len;
+    return;
+}

core/shared-lib/coap/extension/coap_ext.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef COAP_EXTENSION_COAP_EXT_H_
+#define COAP_EXTENSION_COAP_EXT_H_
+
+#include "er-coap.h"
+#include "shared_utils.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define COAP_EVENT (COAP_DELETE + 2)
+
+char * coap_get_full_url_alloc(coap_packet_t * request);
+
+coap_status_t coap_parse_message_tcp(void *packet, uint8_t *data,
+        uint32_t data_len);
+
+int coap_serialize_message_tcp(void *packet, uint8_t ** buffer_out);
+int coap_set_payload_tcp(void *packet, const void *payload, size_t length);
+uint8_t coap_is_request(coap_packet_t * coap_message);
+
+uint16_t coap_find_mid(uint8_t *buffer);
+uint8_t coap_find_code(uint8_t *buffer);
+void coap_change_mid(uint8_t *buffer, uint16_t id);
+
+int add_resource_handler(coap_context_t * coap_ctx,
+        coap_resource_handler_t * handler);
+uint32_t check_blockwise_timeout_ms(coap_context_t * coap_ctx, int timeout_sec);
+
+int convert_coap_packet_to_request(coap_packet_t *packet, request_t *request);
+void convert_coap_packet_to_response(coap_packet_t *packet,
+        response_t *response);
+
+void convert_response_to_coap_packet(response_t * response,
+        coap_packet_t * packet);
+void convert_request_to_coap_packet(request_t * req, coap_packet_t * packet);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* COAP_EXTENSION_COAP_EXT_H_ */

core/shared-lib/coap/extension/coap_over_tcp.c

@@ -0,0 +1,481 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include "bh_common.h"
+#include "er-coap.h"
+#include "coap_ext.h"
+#include "er-coap-constants.h"
+
+#define DEBUG 0
+#if DEBUG
+#include <stdio.h>
+#define PRINTF(...) printf(__VA_ARGS__)
+#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((uint8_t *)addr)[0], ((uint8_t *)addr)[1], ((uint8_t *)addr)[2], ((uint8_t *)addr)[3], ((uint8_t *)addr)[4], ((uint8_t *)addr)[5], ((uint8_t *)addr)[6], ((uint8_t *)addr)[7], ((uint8_t *)addr)[8], ((uint8_t *)addr)[9], ((uint8_t *)addr)[10], ((uint8_t *)addr)[11], ((uint8_t *)addr)[12], ((uint8_t *)addr)[13], ((uint8_t *)addr)[14], ((uint8_t *)addr)[15])
+#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]", (lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3], (lladdr)->addr[4], (lladdr)->addr[5])
+#else
+#define PRINTF(...)
+#define PRINT6ADDR(addr)
+#define PRINTLLADDR(addr)
+#endif
+
+extern size_t
+coap_serialize_array_option(unsigned int number, unsigned int current_number,
+        uint8_t *buffer, uint8_t *array, size_t length, char split_char);
+extern size_t
+coap_serialize_int_option(unsigned int number, unsigned int current_number,
+        uint8_t *buffer, uint32_t value);
+extern uint16_t coap_log_2(uint16_t value);
+extern uint32_t coap_parse_int_option(uint8_t *bytes, size_t length);
+extern void
+coap_merge_multi_option(char **dst, size_t *dst_len, uint8_t *option,
+        size_t option_len, char separator);
+
+/*
+ *
+ 0                   1                   2                   3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |Len=15 |  TKL  | Extended Length (32 bits)
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |               |    Code       |  Token (if any, TKL bytes) ...
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |   Options (if any) ...
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |1 1 1 1 1 1 1 1|    Payload (if any) ...
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ */
+
+int coap_set_payload_tcp(void *packet, const void *payload, size_t length)
+{
+    coap_packet_t * const coap_pkt = (coap_packet_t *) packet;
+
+    coap_pkt->payload = (uint8_t *) payload;
+    coap_pkt->payload_len = MIN(REST_MAX_CHUNK_SIZE, length);
+
+    return coap_pkt->payload_len;
+}
+
+#if 0
+static size_t coap_calc_ext_len_field(int len)
+{
+    if(len < 13)
+    return 0;
+    else if(len <= (0xFF+13))
+    return 1;
+    else if(len <= (0xFFFF+269))
+    return 2;
+    else if(len < (0xFFFFFFFF+65805))
+    return 4;
+    else
+    return 0;
+}
+#endif
+
+static size_t coap_max_options_offset(void *packet)
+{
+    coap_packet_t * const coap_pkt = (coap_packet_t *) packet;
+    return 6 + coap_pkt->token_len;
+}
+
+int coap_serialize_message_tcp(void *packet, uint8_t ** buffer_out)
+{
+    coap_packet_t * const coap_pkt = (coap_packet_t *) packet;
+    uint8_t buffer[128];
+
+    uint8_t *option = buffer;
+    unsigned int current_number = 0;
+
+    if (coap_pkt->uri_path_len > 100) {
+        *buffer_out = 0;
+        return -1;
+    }
+
+    /* Serialize options */
+    current_number = 0;
+    if (0 == coap_pkt->token_len) {
+        bh_memcpy_s(coap_pkt->token, COAP_TOKEN_LEN, &coap_pkt->mid,
+                sizeof(coap_pkt->mid));
+        coap_pkt->token_len = sizeof(coap_pkt->mid);
+    }PRINTF("-Serializing options at %p-\n", option);
+
+    /* The options must be serialized in the order of their number */
+    COAP_SERIALIZE_BYTE_OPTION(COAP_OPTION_IF_MATCH, if_match, "If-Match");
+    COAP_SERIALIZE_STRING_OPTION(COAP_OPTION_URI_HOST, uri_host, '\0',
+            "Uri-Host");
+    COAP_SERIALIZE_BYTE_OPTION(COAP_OPTION_ETAG, etag, "ETag");
+    COAP_SERIALIZE_INT_OPTION(COAP_OPTION_IF_NONE_MATCH,
+            content_format - coap_pkt-> content_format /* hack to get a zero field */,
+            "If-None-Match");
+    COAP_SERIALIZE_INT_OPTION(COAP_OPTION_OBSERVE, observe, "Observe");
+    COAP_SERIALIZE_INT_OPTION(COAP_OPTION_URI_PORT, uri_port, "Uri-Port");
+    COAP_SERIALIZE_STRING_OPTION(COAP_OPTION_LOCATION_PATH, location_path, '/',
+            "Location-Path");
+    COAP_SERIALIZE_STRING_OPTION(COAP_OPTION_URI_PATH, uri_path, 0, //'/',
+            "Uri-Path");
+    COAP_SERIALIZE_INT_OPTION(COAP_OPTION_CONTENT_FORMAT, content_format,
+            "Content-Format");
+    COAP_SERIALIZE_INT_OPTION(COAP_OPTION_MAX_AGE, max_age, "Max-Age");
+    COAP_SERIALIZE_STRING_OPTION(COAP_OPTION_URI_QUERY, uri_query, '&',
+            "Uri-Query");
+    COAP_SERIALIZE_INT_OPTION(COAP_OPTION_ACCEPT, accept, "Accept");
+    COAP_SERIALIZE_STRING_OPTION(COAP_OPTION_LOCATION_QUERY, location_query,
+            '&', "Location-Query");
+    COAP_SERIALIZE_BLOCK_OPTION(COAP_OPTION_BLOCK2, block2, "Block2");
+    COAP_SERIALIZE_BLOCK_OPTION(COAP_OPTION_BLOCK1, block1, "Block1");
+    COAP_SERIALIZE_INT_OPTION(COAP_OPTION_SIZE2, size2, "Size2");
+    COAP_SERIALIZE_STRING_OPTION(COAP_OPTION_PROXY_URI, proxy_uri, '\0',
+            "Proxy-Uri");
+    COAP_SERIALIZE_STRING_OPTION(COAP_OPTION_PROXY_SCHEME, proxy_scheme, '\0',
+            "Proxy-Scheme");
+    COAP_SERIALIZE_INT_OPTION(COAP_OPTION_SIZE1, size1, "Size1");
+
+    /* Pack payload */
+    if (coap_pkt->payload_len) {
+        *option = 0xFF;
+        ++option;
+    }
+    uint32_t option_len = option - &buffer[0];
+
+    uint8_t * p = (uint8_t *) os_malloc(
+            coap_max_options_offset(packet) + option_len
+                    + coap_pkt->payload_len);
+    if (p == NULL)
+        return 0;
+    *buffer_out = p;
+
+    uint8_t first_4bits;
+
+    *p = (coap_pkt->token_len & 0xF);
+    uint32_t len = option_len + coap_pkt->payload_len;
+
+    if (len < 13) {
+        first_4bits = len;
+        *p++ |= first_4bits << 4;
+    } else if (len <= (0xFF + 13)) {
+        first_4bits = 13;
+        *p++ |= first_4bits << 4;
+        *p++ = len - 13;
+    } else if (len <= (0xFFFF + 269)) {
+        first_4bits = 14;
+        *p++ |= first_4bits << 4;
+        len -= 269;
+        *p = (uint8_t)(len >> 8);
+        p++;
+        *p = (uint8_t)(len & 0xFF);
+        p++;
+    } else {
+        first_4bits = 15;
+        *p++ |= first_4bits << 4;
+
+        len -= 65805;
+        *p++ = (uint8_t)(len >> 24);
+        *p++ = (uint8_t)(len >> 16);
+        *p++ = (uint8_t)(len >> 8);
+        *p++ = (uint8_t)(len & 0xFF);
+    }
+
+    *p = coap_pkt->code;
+    p++;
+
+    if (coap_pkt->token_len)
+        bh_memcpy_s(p, coap_pkt->token_len, coap_pkt->token,
+                coap_pkt->token_len);
+    p += coap_pkt->token_len;
+
+    bh_memcpy_s(p, option_len, buffer, option_len);
+    p += option_len;
+
+    bh_memcpy_s(p, coap_pkt->payload_len, coap_pkt->payload,
+            coap_pkt->payload_len);
+    p += coap_pkt->payload_len;
+
+    return (p - *buffer_out); /* packet length */
+}
+
+coap_status_t coap_parse_message_tcp(void *packet, uint8_t *data,
+        uint32_t data_len)
+{
+    coap_packet_t * const coap_pkt = (coap_packet_t *) packet;
+
+    /* initialize packet */
+    memset(coap_pkt, 0, sizeof(coap_packet_t));
+
+    /* pointer to packet bytes */
+    coap_pkt->buffer = data;
+
+    /* parse header fields */
+    coap_pkt->version = 1;
+    coap_pkt->type = COAP_TYPE_NON;
+    coap_pkt->token_len = MIN(COAP_TOKEN_LEN, data[0] & 0xF);
+    coap_pkt->mid = 0;
+
+    uint8_t *p = data;
+    uint8_t first_4bits = data[0] >> 4;
+
+    uint32_t options_payload_size;
+    uint8_t ext_len_field = 0;
+    if (first_4bits < 13) {
+        options_payload_size = first_4bits;
+        p++;
+    } else if (first_4bits == 13) {
+        ext_len_field = 1;
+        options_payload_size = data[1] + 13;
+        p += 2;
+    } else if (first_4bits == 14) {
+        ext_len_field = 2;
+        options_payload_size = (uint16_t)(data[1] << 8) + data[2] + 269;
+        p += 3;
+    } else if (first_4bits == 15) {
+        ext_len_field = 4;
+        options_payload_size = (data[1] << 24) + (data[2] << 16)
+                + (data[3] << 8) + data[4] + 65805;
+        p += 5;
+    }
+
+    // check the data size is smaller than the size indicated by the packet
+    if (ext_len_field + coap_pkt->token_len + 2 + options_payload_size
+            > data_len)
+        return BAD_REQUEST_4_00;
+
+    coap_pkt->code = *p++;
+    if (coap_pkt->token_len)
+        bh_memcpy_s(coap_pkt->token, COAP_TOKEN_LEN, p, coap_pkt->token_len);
+
+    if (coap_pkt->token_len >= 2) {
+        union {
+            uint16_t *mid;
+            uint8_t *token;
+        } mid_token_union;
+
+        mid_token_union.token = coap_pkt->token;
+        coap_pkt->mid = *(mid_token_union.mid);
+    }
+
+    p += coap_pkt->token_len;
+
+    uint8_t *current_option = p;
+    uint8_t * option_start = p;
+
+    /* parse options */
+    memset(coap_pkt->options, 0, sizeof(coap_pkt->options));
+
+    unsigned int option_number = 0;
+    unsigned int option_delta = 0;
+    size_t option_length = 0;
+
+    while (current_option < data + data_len) {
+        /* payload marker 0xFF, currently only checking for 0xF* because rest is reserved */
+        if ((current_option[0] & 0xF0) == 0xF0) {
+            coap_pkt->payload = ++current_option;
+            coap_pkt->payload_len = options_payload_size
+                    - (coap_pkt->payload - option_start);
+            //coap_pkt->payload_len = data_len - (coap_pkt->payload - data);
+            break;
+        }
+
+        option_delta = current_option[0] >> 4;
+        option_length = current_option[0] & 0x0F;
+        ++current_option;
+
+        /* avoids code duplication without function overhead */
+        unsigned int *x = &option_delta;
+
+        do {
+            if (*x == 13) {
+                *x += current_option[0];
+                ++current_option;
+            } else if (*x == 14) {
+                *x += 255;
+                *x += current_option[0] << 8;
+                ++current_option;
+                *x += current_option[0];
+                ++current_option;
+            }
+        } while (x != (unsigned int*) &option_length && (x =
+                (unsigned int*) &option_length));
+        option_length = *x;
+        option_number += option_delta;
+
+        PRINTF("OPTION %u (delta %u, len %u): ", option_number, option_delta,
+                option_length);
+
+        SET_OPTION(coap_pkt, option_number);
+
+        switch (option_number) {
+
+        case COAP_OPTION_CONTENT_FORMAT:
+            coap_pkt->content_format = coap_parse_int_option(current_option,
+                    option_length);
+            PRINTF("Content-Format [%u]\n", coap_pkt->content_format);
+            break;
+        case COAP_OPTION_MAX_AGE:
+            coap_pkt->max_age = coap_parse_int_option(current_option,
+                    option_length);
+            PRINTF("Max-Age [%lu]\n", coap_pkt->max_age);
+            break;
+        case COAP_OPTION_ETAG:
+            coap_pkt->etag_len = MIN(COAP_ETAG_LEN, option_length);
+            bh_memcpy_s(coap_pkt->etag, COAP_ETAG_LEN, current_option,
+                    coap_pkt->etag_len);
+            PRINTF("ETag %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n",
+                    coap_pkt->etag_len, coap_pkt->etag[0], coap_pkt->etag[1],
+                    coap_pkt->etag[2], coap_pkt->etag[3], coap_pkt->etag[4],
+                    coap_pkt->etag[5], coap_pkt->etag[6], coap_pkt->etag[7]
+            ); /*FIXME always prints 8 bytes */
+            break;
+        case COAP_OPTION_ACCEPT:
+            coap_pkt->accept = coap_parse_int_option(current_option,
+                    option_length);
+            PRINTF("Accept [%u]\n", coap_pkt->accept);
+            break;
+        case COAP_OPTION_IF_MATCH:
+            /* TODO support multiple ETags */
+            coap_pkt->if_match_len = MIN(COAP_ETAG_LEN, option_length);
+            bh_memcpy_s(coap_pkt->if_match, COAP_ETAG_LEN, current_option,
+                    coap_pkt->if_match_len);
+            PRINTF("If-Match %u [0x%02X%02X%02X%02X%02X%02X%02X%02X]\n",
+                    coap_pkt->if_match_len, coap_pkt->if_match[0],
+                    coap_pkt->if_match[1], coap_pkt->if_match[2],
+                    coap_pkt->if_match[3], coap_pkt->if_match[4],
+                    coap_pkt->if_match[5], coap_pkt->if_match[6],
+                    coap_pkt->if_match[7]
+            ); /* FIXME always prints 8 bytes */
+            break;
+        case COAP_OPTION_IF_NONE_MATCH:
+            coap_pkt->if_none_match = 1;
+            PRINTF("If-None-Match\n");
+            break;
+
+        case COAP_OPTION_PROXY_URI:
+#if COAP_PROXY_OPTION_PROCESSING
+            coap_pkt->proxy_uri = (char *)current_option;
+            coap_pkt->proxy_uri_len = option_length;
+#endif
+            PRINTF("Proxy-Uri NOT IMPLEMENTED [%.*s]\n", coap_pkt->proxy_uri_len,
+                    coap_pkt->proxy_uri);
+            coap_error_message = "This is a constrained server (Contiki)";
+            return PROXYING_NOT_SUPPORTED_5_05;
+            break;
+        case COAP_OPTION_PROXY_SCHEME:
+#if COAP_PROXY_OPTION_PROCESSING
+            coap_pkt->proxy_scheme = (char *)current_option;
+            coap_pkt->proxy_scheme_len = option_length;
+#endif
+            PRINTF("Proxy-Scheme NOT IMPLEMENTED [%.*s]\n",
+                    coap_pkt->proxy_scheme_len, coap_pkt->proxy_scheme);
+            coap_error_message = "This is a constrained server (Contiki)";
+            return PROXYING_NOT_SUPPORTED_5_05;
+            break;
+
+        case COAP_OPTION_URI_HOST:
+            coap_pkt->uri_host = (char *) current_option;
+            coap_pkt->uri_host_len = option_length;
+            PRINTF("Uri-Host [%.*s]\n", coap_pkt->uri_host_len, coap_pkt->uri_host);
+            break;
+        case COAP_OPTION_URI_PORT:
+            coap_pkt->uri_port = coap_parse_int_option(current_option,
+                    option_length);
+            PRINTF("Uri-Port [%u]\n", coap_pkt->uri_port);
+            break;
+        case COAP_OPTION_URI_PATH:
+            /* coap_merge_multi_option() operates in-place on the IPBUF, but final packet field should be const string -> cast to string */
+            coap_merge_multi_option((char **) &(coap_pkt->uri_path),
+                    &(coap_pkt->uri_path_len), current_option, option_length,
+                    '/');
+            PRINTF("Uri-Path [%.*s]\n", coap_pkt->uri_path_len, coap_pkt->uri_path);
+            break;
+        case COAP_OPTION_URI_QUERY:
+            /* coap_merge_multi_option() operates in-place on the IPBUF, but final packet field should be const string -> cast to string */
+            coap_merge_multi_option((char **) &(coap_pkt->uri_query),
+                    &(coap_pkt->uri_query_len), current_option, option_length,
+                    '&');
+            PRINTF("Uri-Query [%.*s]\n", coap_pkt->uri_query_len,
+                    coap_pkt->uri_query);
+            break;
+
+        case COAP_OPTION_LOCATION_PATH:
+            /* coap_merge_multi_option() operates in-place on the IPBUF, but final packet field should be const string -> cast to string */
+            coap_merge_multi_option((char **) &(coap_pkt->location_path),
+                    &(coap_pkt->location_path_len), current_option,
+                    option_length, '/');
+            PRINTF("Location-Path [%.*s]\n", coap_pkt->location_path_len,
+                    coap_pkt->location_path);
+            break;
+        case COAP_OPTION_LOCATION_QUERY:
+            /* coap_merge_multi_option() operates in-place on the IPBUF, but final packet field should be const string -> cast to string */
+            coap_merge_multi_option((char **) &(coap_pkt->location_query),
+                    &(coap_pkt->location_query_len), current_option,
+                    option_length, '&');
+            PRINTF("Location-Query [%.*s]\n", coap_pkt->location_query_len,
+                    coap_pkt->location_query);
+            break;
+
+        case COAP_OPTION_OBSERVE:
+            coap_pkt->observe = coap_parse_int_option(current_option,
+                    option_length);
+            PRINTF("Observe [%lu]\n", coap_pkt->observe);
+            break;
+        case COAP_OPTION_BLOCK2:
+            coap_pkt->block2_num = coap_parse_int_option(current_option,
+                    option_length);
+            coap_pkt->block2_more = (coap_pkt->block2_num & 0x08) >> 3;
+            coap_pkt->block2_size = 16 << (coap_pkt->block2_num & 0x07);
+            coap_pkt->block2_offset = (coap_pkt->block2_num & ~0x0000000F)
+                    << (coap_pkt->block2_num & 0x07);
+            coap_pkt->block2_num >>= 4;
+            PRINTF("Block2 [%lu%s (%u B/blk)]\n", coap_pkt->block2_num,
+                    coap_pkt->block2_more ? "+" : "", coap_pkt->block2_size);
+            break;
+        case COAP_OPTION_BLOCK1:
+            coap_pkt->block1_num = coap_parse_int_option(current_option,
+                    option_length);
+            coap_pkt->block1_more = (coap_pkt->block1_num & 0x08) >> 3;
+            coap_pkt->block1_size = 16 << (coap_pkt->block1_num & 0x07);
+            coap_pkt->block1_offset = (coap_pkt->block1_num & ~0x0000000F)
+                    << (coap_pkt->block1_num & 0x07);
+            coap_pkt->block1_num >>= 4;
+            PRINTF("Block1 [%lu%s (%u B/blk)]\n", coap_pkt->block1_num,
+                    coap_pkt->block1_more ? "+" : "", coap_pkt->block1_size);
+            break;
+        case COAP_OPTION_SIZE2:
+            coap_pkt->size2 = coap_parse_int_option(current_option,
+                    option_length);
+            PRINTF("Size2 [%lu]\n", coap_pkt->size2);
+            break;
+        case COAP_OPTION_SIZE1:
+            coap_pkt->size1 = coap_parse_int_option(current_option,
+                    option_length);
+            PRINTF("Size1 [%lu]\n", coap_pkt->size1);
+            break;
+        default:
+            PRINTF("unknown (%u)\n", option_number);
+            /* check if critical (odd) */
+            if (option_number & 1) {
+                coap_error_message = "Unsupported critical option";
+                return BAD_OPTION_4_02;
+            }
+        }
+
+        current_option += option_length;
+    } /* for */
+    PRINTF("-Done parsing-------\n");
+
+    return NO_ERROR;
+}
+

core/shared-lib/coap/extension/coap_platforms.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef COAP_PLATFORMS_H_
+#define COAP_PLATFORMS_H_
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "bh_platform.h"
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+/*#include "list_coap.h"*/
+#include <stdbool.h>
+
+#define COAP_TRANS_LOCK(ctx) coap_lock(ctx->transaction_lock)
+#define COAP_TRANS_UNLOCK(ctx )  coap_unlock(ctx->transaction_lock)
+
+/* REST_MAX_CHUNK_SIZE is the max size of payload.
+ * The maximum buffer size that is provided for resource responses and must be respected due to the limited IP buffer.
+ * Larger data must be handled by the resource and will be sent chunk-wise through a TCP stream or CoAP blocks.
+ */
+#ifndef REST_MAX_CHUNK_SIZE
+#define REST_MAX_CHUNK_SIZE     (1024*1024)
+#endif
+
+#ifndef MIN
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#endif /* MIN */
+
+#define CLOCK_SECOND 1000
+
+typedef enum {
+    A_Raw, A_Sock_Addr, A_IP_Addr, A_Custom
+} Net_Addr_Type;
+
+#define NET_ADDR_RAW_SIZE 32
+
+typedef struct net_addr_coap {
+    Net_Addr_Type addr_type;
+    union {
+        char raw[NET_ADDR_RAW_SIZE];
+        struct sockaddr_in sock_addr;
+    } u;
+    uint16_t port;
+    uint16_t addr_len;
+} net_addr_t;
+
+#define uip_ipaddr_t struct net_addr_coap
+
+#define memb_free(x, y)  free(x)
+
+void set_addr_ip(uip_ipaddr_t *, char * ip, int port);
+uip_ipaddr_t * new_net_addr(Net_Addr_Type type);
+void copy_net_addr(uip_ipaddr_t * dest, uip_ipaddr_t * src);
+bool compare_net_addr(uip_ipaddr_t * dest, uip_ipaddr_t * src);
+
+uint32_t get_elpased_ms(uint32_t * last_system_clock);
+uint32_t get_platform_time();
+uint32_t get_platform_time_sec();
+
+void coap_sleep_ms(uint32_t ms);
+void coap_lock(void *);
+void coap_unlock(void *);
+void * coap_create_lock();
+void coap_free_lock(void *);
+
+void *xalloc(uint32_t size);
+
+#define os_malloc   bh_malloc
+#define os_free     bh_free
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* COAP_PLATFORMS_H_ */

core/shared-lib/coap/lib_coap.cmake

@@ -0,0 +1,23 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set (LIB_COAP_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+include_directories(${LIB_COAP_DIR}/er-coap)
+include_directories(${LIB_COAP_DIR}/extension)
+
+file (GLOB_RECURSE source_all ${LIB_COAP_DIR}/*.c)
+
+set (LIB_COAP_SOURCE ${source_all})
+

core/shared-lib/include/bni.h

@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @file   bni.h
+ * @date   Mon Jul  2 16:54:58 2012
+ *
+ * @brief  Beihai native interface.
+ */
+
+#ifndef BNI_H
+#define BNI_H
+
+#include "bh_types.h"
+
+/* Primitive types */
+typedef uint8 jboolean;
+typedef int8 jbyte;
+typedef uint16 jchar;
+typedef int16 jshort;
+typedef int32 jint;
+typedef int64 jlong;
+typedef float jfloat;
+typedef double jdouble;
+typedef jint jsize;
+
+/* Predefined Java class types.  */
+struct _jobject;
+typedef struct _jobject *jobject;
+struct _jclass;
+typedef struct _jclass *jclass;
+struct _jstring;
+typedef struct _jstring *jstring;
+
+/* Values of jboolean: */
+#define BNI_FALSE  0
+#define BNI_TRUE   1
+
+/**
+ * Return the length of the array object.
+ *
+ * @param array Java array object
+ *
+ * @return the length of the Java array
+ */
+#define bni_array_length(array) ((jsize)((uint32)(array)->__length >> 2))
+
+/**
+ * Return the address of the first element of array object.
+ *
+ * @param array Java array object
+ *
+ * @return the address of the first element of array object
+ */
+#define bni_array_elem(array) ((array)->__elem)
+
+/**
+ * Find the Java class with given class name.
+ *
+ * @param name Java class name
+ *
+ * @return class object of the Java class if found, NULL otherwise
+ *
+ * @throws OutOfMemoryError if VM runs out of memory.
+ */
+jclass
+bni_find_class(const char *name);
+
+/**
+ * Throw an exception of given class with message.
+ *
+ * @param clazz class object of a subclass of java.lang.Throwable
+ * @param msg message for the exception or NULL if no message
+ *
+ * @return 0 if succeeds, nonzero otherwise
+ */
+jint
+bni_throw_new(jclass clazz, const char *msg);
+
+/**
+ * Throw a NullPointerException.
+ *
+ * @throws NullPointerException
+ */
+void
+bni_throw_npe(void);
+
+/**
+ * Throw an ArrayIndexOutOfBoundsException
+ *
+ * @param index the index used to access the array
+ *
+ * @throws ArrayIndexOutOfBoundsException
+ */
+void
+bni_throw_aioobe(int index);
+
+/**
+ * Determine whether an exception is being thrown.
+ *
+ * @return exception object if exception is thrown, NULL otherwise
+ */
+jobject
+bni_exception_occurred(void);
+
+/**
+ * Print the current exception to error-reporting channel.
+ */
+void
+bni_exception_describe(void);
+
+/**
+ * Clear the currently thrown exception.
+ */
+void
+bni_exception_clear(void);
+
+/**
+ * Return the Unicode character number of a string.
+ *
+ * @param str Java string object
+ *
+ * @return the Unicode character number of the string
+ */
+jsize
+bni_string_length(jstring str);
+
+/**
+ * Return the length in bytes of the modified UTF-8 representation of
+ * a string.
+ *
+ * @param str Java string object
+ * @param start start offset in the string
+ * @param len number of Unicode characters
+ *
+ * @return the UTF-8 length of the string
+ *
+ * @throws StringIndexOutOfBoundsException on index overflow.
+ */
+jsize
+bni_string_utf_length(jstring str, jsize start, jsize len);
+
+/**
+ * Copies len number of Unicode characters beginning at offset start
+ * to the given buffer buf.
+ *
+ * @param str Java string object
+ * @param start start offset in the string
+ * @param len number of Unicode characters to copy
+ * @param buf buffer for storing the result
+ */
+void
+bni_string_region(jstring str, jsize start, jsize len, jchar *buf);
+
+/**
+ * Translates len number of Unicode characters beginning at offset
+ * start into modified UTF-8 encoding and place the result in the
+ * given buffer buf.
+ *
+ * @param str Java string object
+ * @param start start offset in the string
+ * @param len number of Unicode characters to copy
+ * @param buf buffer for storing the result
+ *
+ * @throws StringIndexOutOfBoundsException on index overflow.
+ */
+void
+bni_string_utf_region(jstring str, jsize start, jsize len, char *buf);
+
+/**
+ * Translate Unicode characters into modified UTF-8 encoding and return
+ * the result.
+ *
+ * @param str Java string object
+ *
+ * @return the UTF-8 encoding string if succeeds, NULL otherwise
+ */
+char *
+bni_string_get_utf_chars(jstring str);
+
+/**
+ * Get the given Java object's class index.
+ *
+ * @param obj Java object
+ *
+ * @return -1 if obj is an array, class index of the object otherwise
+ */
+jint
+bni_object_class_index(jobject obj);
+
+/**
+ * Allocate memory from the current instance's private heap.
+ *
+ * @param size bytes to allocate
+ *
+ * @return pointer to the allocated memory
+ *
+ * @throws OutOfMemoryError if VM runs out of memory.
+ */
+void*
+bni_malloc(unsigned size);
+
+/**
+ * Allocate memory from the current instance's private heap and clear
+ * to zero.
+ *
+ * @param size bytes to allocate
+ *
+ * @return pointer to the allocated memory
+ *
+ * @throws OutOfMemoryError if VM runs out of memory.
+ */
+void*
+bni_calloc(unsigned size);
+
+/**
+ * Free the memory allocated from the current instance's private heap.
+ *
+ * @param ptr pointer to the memory in current instance's private heap
+ */
+void
+bni_free(void *ptr);
+
+#endif

core/shared-lib/include/jeff_export.h

@@ -0,0 +1,615 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @file   jeff-export.h
+ * @date   Wed Aug  3 18:17:30 2011
+ *
+ * @brief Exported interface for operating or executing JEFF files.
+ * All interface names start with "jeff_", which is the namespace name
+ * of this module.
+ */
+
+#ifndef JEFF_EXPORT_H
+#define JEFF_EXPORT_H
+
+#include "bni.h"
+#include "korp_types.h"
+
+/********************************************************************
+ *                  Exported internal types
+ ********************************************************************/
+
+/**
+ * JEFF file handle type
+ */
+struct JeffFileHeaderLinked;
+typedef struct JeffFileHeaderLinked *jeff_file_t;
+
+/**
+ * JEFF class type
+ */
+struct JeffClassHeaderLinked;
+typedef struct JeffClassHeaderLinked *jeff_class_t;
+
+/**
+ * VM instance handle type
+ */
+struct JeffInstanceLocalRoot;
+typedef struct JeffInstanceLocalRoot *jeff_instance_t;
+
+/**
+ * Record of one native method's definition.
+ */
+struct JeffNativeMethodDef {
+    /* Mangled name of the native method.  NULL for initialization
+     functions.  */
+    const char *mangled_name;
+
+    /* Points to the native C function.  */
+    void (*func_ptr)(uint32 *);
+
+    /* Return size type of the native function.  */
+    uint32 return_size_type;
+};
+
+/********************************************************************
+ *    Interface for operating global environment of the JEFF VM
+ ********************************************************************/
+
+/**
+ * Load the core library from the given file buffer and initialize the
+ * runtime environment (global objects etc.) of the VM.  The thread
+ * calls this function becomes the supervisor thread, which belongs to
+ * a unique supervisor instance.  Currently, if this init failed,
+ * partially initialized states of the VM runtime environment won't be
+ * cleaned up, so the VM must be shutdown and restarted.  method_defs
+ * points to an array of native method definition records.
+ * Initialization functions must be in the front of the array and
+ * following native method definitions must be sorted by their mangled
+ * names.
+ *
+ * @param file the JEFF file of the core library
+ * @param file_size the size of the JEFF file of the core library
+ * @param method_defs native method definition records
+ * @param method_defs_num number of native method records
+ * @param heap the heap for the current (supervisor) instance
+ *
+ * @return true if succeeds, otherwise the error cannot be recovered
+ */
+bool
+jeff_runtime_init(jeff_file_t file, unsigned file_size,
+        struct JeffNativeMethodDef *method_defs, unsigned method_defs_num,
+        void *heap);
+
+/**
+ * Load a JEFF file into the VM from the given file buffer.  It can be
+ * called from any VM thread.
+ *
+ * @param file the JEFF file to be loaded
+ * @param size the size of the JEFF file
+ * @param is_library whether the JEFF file is a library
+ * @param allow_to_load a function that returns true if classes in the
+ * given package is allowed to be loaded.  The NULL function pointer
+ * allows all packages.
+ * @param allow_to_link a function that returns true if classes in the
+ * given package is allowed to be linked to.  The NULL function
+ * pointer allows all packages.
+ *
+ * @return true if succeeds, otherwise detailed error information is
+ * passed to vmci_diagnostic_print.  The caller can catch it by
+ * implementing that function.
+ */
+bool
+jeff_runtime_load(jeff_file_t file, unsigned size, bool is_library,
+        bool (*allow_to_load)(const uint8 *pname, unsigned len),
+        bool (*allow_to_link)(const uint8 *pname, unsigned plen,
+                const uint8 *cname, unsigned clen));
+
+/**
+ * Unload a JEFF file from the VM.  All resources related to the JEFF
+ * file except the JEFF file itself are released.  It can be called
+ * from any VM thread.
+ *
+ * @param file the JEFF file to be unloaded
+ *
+ * @return true if succeeds, otherwise detailed error information is
+ * passed to vmci_diagnostic_print.  The caller can catch it by
+ * implementing that function.
+ */
+bool
+jeff_runtime_unload(jeff_file_t file);
+
+/**
+ * Return the JEFF file with the given file uid.
+ *
+ * @param fuid the unique id of a loaded JEFF file
+ *
+ * @return the JEFF file is exists, otherwise NULL
+ */
+jeff_file_t
+jeff_runtime_fuid_to_file(unsigned fuid);
+
+/**
+ * Return the file uid of the given JEFF file.
+ *
+ * @param file a loaded JEFF file
+ *
+ * @return the unique id of the given JEFF file
+ */
+unsigned
+jeff_runtime_file_to_fuid(jeff_file_t file);
+
+/**
+ * Create a supervisor thread belonging to the supervisor instance.
+ * Threads that may interact with VM core must be either the main
+ * thread of supervisor instance (which calls jeff_runtime_init) or
+ * created by this function so that VM core required data structures
+ * can be set up correctly.
+ *
+ * @param start_routine the start routine of the new thread
+ * @param arg argument to the start routine
+ *
+ * @return true if succeeds, false otherwise
+ */
+bool
+jeff_runtime_create_supervisor_thread(void* (*start_routine)(void *),
+        void *arg);
+
+/**
+ * Create a supervisor thread belonging to the supervisor instance.
+ * Threads that may interact with VM core must be either the main
+ * thread of supervisor instance (which calls jeff_runtime_init) or
+ * created by this function so that VM core required data structures
+ * can be set up correctly.
+ *
+ * @param start_routine the start routine of the new thread
+ * @param arg argument to the start routine
+ * @param prio thread priority
+ *
+ * @return true if succeeds, false otherwise
+ */
+bool
+jeff_runtime_create_supervisor_thread_with_prio(void* (*start_routine)(void *),
+        void *arg, int prio);
+
+/********************************************************************
+ *      Interface for operating instance local environment
+ ********************************************************************/
+
+/**
+ * Create a VM instance with the given JEFF file as its main file,
+ * (i.e. the file containing the main class of the VM instance).  This
+ * function can be called from any VM thread, but it must be isolated
+ * from JEFF file's unloading operation so that the main file won't be
+ * unloaded before it's locked by the new instance.  All instance
+ * local memory except stacks of threads are allocated from the given
+ * heap.  If succeeds, it increases reference count of the main_file
+ * and returns the handle of the new VM instance.  The new instance's
+ * main thread will run the start_routine with argument arg.  If the
+ * cleanup_routine is not NULL, it will be called after start_routine
+ * returns and just before the main thread exits.  It will also be
+ * called after the instance is destroied.  It is guaranteed to be
+ * called exactly once no matter how the instance terminates.
+ *
+ * @param main_file the main JEFF file of the new instance
+ * @param heap the private heap of the new instance
+ * @param stack_depth the maximal nesting levels of Java methods of
+ * the new instance.  It must be <= 16 * 1024.  Otherwise the instance
+ * creation will fail.
+ * @param start_routine start routine of the main thread.  Don't
+ * destroy the heap or inform other thread to do this at the end of
+ * this routine since after it returns, VM core will call destroy
+ * functions on objects allocated in this heap (e.g. locks and
+ * condition variables).  Do the destroying or informing of destroying
+ * in the cleanup_routine.
+ * @param arg the instance argument that will be passed to the start
+ * routine.  It can be get or set by jeff_runtime_get_instance_arg and
+ * jeff_runtime_set_instance arg from threads of the instance.  The
+ * caller can use it to store instance local data.
+ * @param cleanup_routine the optional cleanup routine for the
+ * instance, which may be NULL.  It may be executed in the end of the
+ * main thread of the created instance by this function if this
+ * instance exits normally, or it may be executed in a thread of other
+ * instance in case this instance is being killed by that instance.
+ * In both cases, this routine regards it is executed in a thread of
+ * this instance (the instance created by this function) because
+ * jeff_runtime_get_instance_arg will always return the argument of
+ * this instance.
+ *
+ * @return the VM instance handle if succeeds, NULL otherwise
+ */
+jeff_instance_t
+jeff_runtime_create_instance(jeff_file_t main_file, void *heap,
+        unsigned stack_depth, void* (*start_routine)(void *), void *arg,
+        void (*cleanup_routine)(void));
+
+/**
+ * Destroy the given VM instance and decrease the reference count of
+ * its main file and all explicitly used JEFF files.  It can be called
+ * from any VM thread.  If there are alive threads of the instance,
+ * they will be terminated mandatorily and then the cleanup routine is
+ * called if it's not NULL.
+ *
+ * @param handle the handle of the instance to be destroyed
+ */
+void
+jeff_runtime_destroy_instance(jeff_instance_t handle);
+
+/**
+ * Retrieve the current instance's argument.
+ *
+ * @return the current instance's argument
+ */
+void*
+jeff_runtime_get_instance_arg(void);
+
+/**
+ * Set the current instance's argument.
+ *
+ * @return the new argument for the current instance
+ */
+void
+jeff_runtime_set_instance_arg(void *arg);
+
+/**
+ * Retrieve the current instance's heap.
+ *
+ * @return the current instance's heap
+ */
+void*
+jeff_runtime_get_instance_heap(void);
+
+/**
+ * Suspend all threads of the given VM instance.  This function can
+ * only be called from thread that is not of the given VM instance.
+ *
+ * @param handle the handle of the instance to be suspended
+ */
+void
+jeff_runtime_suspend_instance(jeff_instance_t handle);
+
+/**
+ * Resume all threads of the given VM instance.  This function can
+ * only be called from thread that is not of the given VM instance.
+ *
+ * @param handle the handle of the instance to be resumed
+ */
+void
+jeff_runtime_resume_instance(jeff_instance_t handle);
+
+/**
+ * Interrupt all threads of the given VM instance.  This function can
+ * only be called from thread that is not of the given VM instance.
+ *
+ * @param handle the handle of the instance to be interrupted
+ * @param by_force whether the interruption is by force
+ */
+void
+jeff_runtime_interrupt_instance(jeff_instance_t handle, bool by_force);
+
+/**
+ * Wait for the given VM instance to terminate.
+ *
+ * @param ilr the VM instance to be waited for
+ * @param mills wait millseconds to return
+ */
+void
+jeff_runtime_wait_for_instance(jeff_instance_t ilr, int mills);
+
+/********************************************************************
+ *       Interface for operating thread local environment
+ ********************************************************************/
+
+/**
+ * Return true if there is an uncaught exception (thrown during
+ * running an application or applet command).
+ *
+ * @return true if there is an uncaught exception
+ */
+bool
+jeff_runtime_check_uncaught_exception(void);
+
+/**
+ * Print qualified name of the uncaught exception (and stack trace if
+ * enabled) by calling vmci_diagnostic_print.
+ */
+void
+jeff_runtime_print_uncaught_exception(void);
+
+/**
+ * Clear the uncaught exception.
+ */
+void
+jeff_runtime_reset_uncaught_exception(void);
+
+/**
+ * Change current thread to a safe state (VMWAIT).  After calling this
+ * and before calling jeff_runtime_exit_safe_state, all operations
+ * must be safe, i.e. no GC or system level resource operations are
+ * allowed because in a safe state, the VM instance is assumed to be
+ * able to perform GC, JDWP or termination at any time.  Usually, this
+ * function is called just before the native code is going to wait for
+ * something and the exiting safe state function is called just after
+ * the waiting returns.
+ */
+void
+jeff_runtime_enter_safe_state(void);
+
+/**
+ * Change current thread to an unsafe state (RUNNING) so that unsafe
+ * operations can also be done.
+ */
+void
+jeff_runtime_exit_safe_state(void);
+
+/**
+ * Set thread local error code for the current thread.
+ *
+ * @param code the error code to be set
+ */
+void
+jeff_runtime_set_error(unsigned code);
+
+/**
+ * Get the last error code of current thread.
+ *
+ * @return the last error code of current thread
+ */
+unsigned
+jeff_runtime_get_error(void);
+
+/********************************************************************
+ *                  Interface for GC support
+ ********************************************************************/
+
+/**
+ * Traverse all objects of the given heap that are global or locate in
+ * threads' frames and return them by calling vmci_gc_rootset_elem.
+ * This function will suspend all threads except the current one of
+ * the VM instance owning the given heap before traversing.  It
+ * traverses either all or none of the rootset objects, and returns
+ * true and false respectively.  If it returns false, the GC process
+ * shouldn't proceed and is not necessary to unmark anything because
+ * no objects are marked.  The function jeff_runtime_gc_finished must
+ * be called if and only if this function returns true so as to resume
+ * threads that are suspended during GC process.
+ *
+ * @param heap the heap for which rootset objects are looked up
+ *
+ * @return true if succeeds, false otherwise
+ */
+bool
+jeff_runtime_traverse_gc_rootset(void *heap);
+
+/**
+ * Get the reference offset table of the given object.  If the
+ * returned value R >= 0, *ret points to the reference offset table of
+ * the object and R is the number of offsets in the table.  Otherwise,
+ * if the returned value R < 0, all reference fields of the object
+ * must be in a continuous region (usually the object is an array),
+ * then *ret is the offset to the first field in the region and R is
+ * the number of such fields in the region.
+ *
+ * @param obj pointer to the Java object
+ * @param ret points to a pointer for storing the reference offset
+ * table if return value >= 0, or for storing the offset to the first
+ * object reference in the Java object if return value < 0
+ *
+ * @return number of offsets in the reference_offset table if >= 0, or
+ * number of object references in the object if < 0
+ */
+int
+jeff_object_get_reference_offsets(const jobject obj, uint16 **ret);
+
+/**
+ * Inform the containing VM instance that GC has finished and all
+ * suspended threads can be resumed.  This function must be called if
+ * and only if jeff_runtime_traverse_gc_rootset returns true.
+ */
+void
+jeff_runtime_gc_finished(void);
+
+/********************************************************************
+ *              Interface for tooling support
+ ********************************************************************/
+
+/**
+ * This function is used to suspend the main thread of VM instance so
+ * that debugger can have chance to connect to the VM instance, set
+ * breakpoints and do any other debug settings.  It must be called
+ * from the main thread of VM instance at the point just after VM
+ * instance initialization finishes and just before application code
+ * is to be executed.
+ */
+void
+jeff_tool_suspend_self(void);
+
+/**
+ * Start up tool agent thread for the given VM instance.  It can be
+ * called from any VM thread.
+ *
+ * @param handle the VM instance for which tool agent is started up
+ * @param queue queue of the tool agent
+ * @return true if succeeds, false otherwise
+ */
+bool
+jeff_tool_start_agent(jeff_instance_t handle, void *queue);
+
+/********************************************************************
+ *              Interface for toolkit support
+ ********************************************************************/
+
+/**
+ * Return the JEFF class pointer of the given class name.
+ *
+ * @param class_name the qualified class name
+ *
+ * @return the JEFF class pointer
+ */
+jeff_class_t
+jeff_tool_get_jeff_class(const char *class_name);
+
+/**
+ * Get the mangled class name of the given class.
+ *
+ * @param clz the JEFF class
+ * @param buf buffer for returning the mangled name
+ * @param buf_size size of the buffer
+ *
+ * @return actual size of the mangled class name including the
+ * terminating null byte
+ */
+unsigned
+jeff_tool_get_mangled_class_name(jeff_class_t clz, char *buf,
+        unsigned buf_size);
+
+/**
+ * Get class index of given class in its containing JEFF file.
+ *
+ * @param clz the JEFF class
+ *
+ * @return class index in the containing JEFF file
+ */
+int
+jeff_tool_get_class_index(jeff_class_t clz);
+
+/**
+ * Callback handler prototype for traversing fields of class.
+ *
+ * @param arg argument passed to the handler from caller
+ * @param access_flag access flag of the method
+ * @param name the field name
+ * @param descriptor mangled field type descriptor
+ * @param offset the offset of the field in the class
+ * @param size size of the field
+ */
+typedef void
+(*JeffToolFieldHandler)(void *arg, unsigned access_flag, const char *name,
+        const char *descriptor, unsigned offset, unsigned size);
+
+/**
+ * Traverse all fields of the given class, including those inherited
+ * from super classes.  The fields are traversed in the same order as
+ * the field layout of the class.
+ *
+ * @param arg argument to be passed to the handler
+ * @param clz the JEFF class
+ * @param instance instance fields or static fielts
+ * @param handler the callback handler for each field
+ */
+void
+jeff_tool_foreach_field(void *arg, jeff_class_t clz, bool instance,
+        JeffToolFieldHandler handler);
+
+/**
+ * Callback handler prototype for traversing methods of class.
+ *
+ * @param arg argument passed to the handler from caller
+ * @param access_flag access flag of the method
+ * @param name mangled name of the method
+ * @param descriptor mangled method arguments descriptor
+ * @param retune_type mangled descriptor of method's return type
+ */
+typedef void
+(*JeffToolMethodHandler)(void *arg, unsigned access_flag, const char *name,
+        const char *descriptor, const char *return_type);
+
+/**
+ * Traverse all methods of the given class.
+ *
+ * @param arg argument to be passed to the handler
+ * @param clz the JEFF class
+ * @param handler the callback handler for each method
+ */
+void
+jeff_tool_foreach_method(void *arg, jeff_class_t clz,
+        JeffToolMethodHandler handler);
+
+/**
+ * Callback handler prototype for traversing classes of main file.
+ *
+ * @param arg argument passed to the handler from caller
+ * @param clz pointer to one class in the main file
+ */
+typedef void
+(*JeffToolClassHandler)(void *arg, jeff_class_t clz);
+
+/**
+ * Traverse all classes of the main file.
+ *
+ * @param arg argument to be passed to the handler
+ * @param handler the callback handler for each class
+ */
+void
+jeff_tool_foreach_class(void *arg, JeffToolClassHandler handler);
+
+/********************************************************************
+ *              Interface for executing applications
+ ********************************************************************/
+
+/**
+ * Initialize global environment for executing Java applications.
+ *
+ * @return true if succeeds, false otherwise
+ */
+bool
+jeff_application_env_init(void);
+
+/**
+ * Find the unique class containing a public static "main
+ * ([Ljava.lang.String;)V" method from the main JEFF file of the
+ * current instance and execute that method.
+ *
+ * @param argc the number of arguments
+ * @param argv the arguments array
+ *
+ * @return true if the main method is called, false otherwise (e.g. an
+ * exception occurs when preparing the arguments Java string array)
+ */
+bool
+jeff_application_execute(int argc, char *argv[]);
+
+/********************************************************************
+ *              Interface for executing applets
+ ********************************************************************/
+
+/**
+ * Initialize global environment for executing applets.
+ *
+ * @return true if succeeds, false otherwise
+ */
+bool
+jeff_applet_env_init(void);
+
+/**
+ * Start to run from com.intel.runtime.core.RuntimeContext.main with a
+ * default message queue size and a default service class object.  If
+ * the main JEFF file of the current VM instance contains exactly one
+ * class that is derived from com.intel.util.IntelApplet, then use it
+ * as the default service class.
+ *
+ * @param queue_size the default main message queue size
+ * @param default_service_class qualified class name of the default
+ * service class (entry point class), which must be in the main JEFF
+ * file.  If NULL, find the default main class with rules described
+ * above.
+ *
+ * @return true if succeeds, false otherwise
+ */
+bool
+jeff_applet_start(int queue_size, const char *default_service_class);
+
+#endif

core/shared-lib/mem-alloc/ems/ems_alloc.c

@@ -152,7 +152,7 @@ void gci_add_fc(gc_heap_t *heap, hmu_t *hmu, gc_size_t size)
     bh_assert(
             hmu && (gc_uint8*) hmu >= heap->base_addr
                     && (gc_uint8*) hmu < heap->base_addr + heap->current_size);
-    bh_assert(((gc_uint32)(uintptr_t)hmu_to_obj(hmu) & 7) == 0);
+    bh_assert(((gc_uint32) hmu_to_obj(hmu) & 7) == 0);
     bh_assert(
             size > 0
                     && ((gc_uint8*) hmu) + size
@@ -242,7 +242,7 @@ BH_STATIC hmu_t *alloc_hmu(gc_heap_t *heap, gc_size_t size)
 
             p = node->next;
             node->next = p->next;
-            bh_assert(((gc_int32)(intptr_t)hmu_to_obj(p) & 7) == 0);
+            bh_assert(((gc_int32) hmu_to_obj(p) & 7) == 0);
 
             if ((gc_size_t) node_idx
                     != init_node_idx&& ((gc_size_t)node_idx << 3) >= size + GC_SMALLEST_SIZE) { /* with bigger size*/

core/shared-lib/platform/linux/bh_thread.c

@@ -75,7 +75,7 @@ static void *vm_thread_wrapper(void *arg)
 {
     thread_wrapper_arg * targ = arg;
     LOG_VERBOSE("THREAD CREATE 0x%08x\n", &targ);
-    targ->stack = (void *) ((uintptr_t)(&arg) & ~0xfff);
+    targ->stack = (void *) ((unsigned int) (&arg) & ~0xfff);
     _vm_tls_put(1, targ);
     targ->start(targ->arg);
     bh_free(targ);

core/shared-lib/utils/runtime_timer.c

@@ -417,7 +417,6 @@ int check_app_timers(timer_ctx_t ctx)
     vm_mutex_lock(&ctx->mutex);
 
     app_timer_t * t = ctx->g_app_timers;
-    app_timer_t * prev = NULL;
     app_timer_t * expired = NULL;
 
     uint64 now = bh_get_tick_ms();
@@ -443,8 +442,6 @@ int check_app_timers(timer_ctx_t ctx)
 
 void cleanup_app_timers(timer_ctx_t ctx)
 {
-    app_timer_t *t;
-
     vm_mutex_lock(&ctx->mutex);
 
     release_timer_list(&ctx->g_app_timers);