Add a new extension library: connection

README.md

@@ -339,12 +339,35 @@ void api_timer_restart(user_timer_t timer, int interval);
 Currently we provide the sensor API's as one library extension sample. In the header file ```lib/app-libs/extension/sensor/sensor.h```, the API set is defined as below:
 ``` C
 sensor_t sensor_open(const char* name, int index,
-                                     void(*on_sensor_event)(sensor_t, attr_container_t *, void *),
-                                     void *user_data);
+                     void(*on_sensor_event)(sensor_t, attr_container_t *, void *),
+                     void *user_data);
 bool sensor_config(sensor_t sensor, int interval, int bit_cfg, int delay);
 bool sensor_config_with_attr_container(sensor_t sensor, attr_container_t *cfg);
 bool sensor_close(sensor_t sensor);
 ```
+We provide the connection API's as another sample. In the header file `lib/app-libs/extension/connection/connection.h.`, the API set is defined as below:
+``` C
+/* Connection event type */
+typedef enum {
+    /* Data is received */
+    CONN_EVENT_TYPE_DATA = 1,
+    /* Connection is disconnected */
+    CONN_EVENT_TYPE_DISCONNECT
+} conn_event_type_t;
+
+typedef void (*on_connection_event_f)(connection_t *conn,
+                                      conn_event_type_t type,
+                                      const char *data,
+                                      uint32 len,
+                                      void *user_data);
+connection_t *api_open_connection(const char *name,
+                                  attr_container_t *args,
+                                  on_connection_event_f on_event,
+                                  void *user_data);
+void api_close_connection(connection_t *conn);
+int api_send_on_connection(connection_t *conn, const char *data, uint32 len);
+bool api_config_connection(connection_t *conn, attr_container_t *cfg);
+```
 
 The mechanism of exporting native API to WASM application
 =======================================================

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

@@ -39,8 +39,10 @@ extern "C" {
 #define SECTION_TYPE_DATA 11
 
 enum {
-    WASM_Msg_Start = BASE_EVENT_MAX, TIMER_EVENT_WASM, SENSOR_EVENT_WASM,
-
+    WASM_Msg_Start = BASE_EVENT_MAX,
+    TIMER_EVENT_WASM,
+    SENSOR_EVENT_WASM,
+    CONNECTION_EVENT_WASM,
     WASM_Msg_End = WASM_Msg_Start + 100
 };
 

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

@@ -37,6 +37,7 @@
 #include "attr_container.h"
 #include "request.h"
 #include "sensor.h"
+#include "connection.h"
 #include "timer_wasm_app.h"
 
 #ifdef __cplusplus

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

@@ -0,0 +1,130 @@
+/*
+ * 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 "connection.h"
+#include "native_interface.h"
+
+/* Raw connection structure */
+typedef struct _connection {
+    /* Next connection */
+    struct _connection *next;
+
+    /* Handle of the connection */
+    uint32 handle;
+
+    /* Callback function called when event on this connection occurs */
+    on_connection_event_f on_event;
+
+    /* User data */
+    void *user_data;
+} connection_t;
+
+/* Raw connections list */
+static connection_t *g_conns = NULL;
+
+connection_t *api_open_connection(const char *name,
+                                  attr_container_t *args,
+                                  on_connection_event_f on_event,
+                                  void *user_data)
+{
+    connection_t *conn;
+    char *args_buffer = (char *)args;
+    uint32 handle, args_len = attr_container_get_serialize_length(args);
+
+    handle = wasm_open_connection((int32)name, (int32)args_buffer, args_len);
+    if (handle == -1)
+        return NULL;
+
+    conn = (connection_t *)malloc(sizeof(*conn));
+    if (conn == NULL) {
+        wasm_close_connection(handle);
+        return NULL;
+    }
+
+    memset(conn, 0, sizeof(*conn));
+    conn->handle = handle;
+    conn->on_event = on_event;
+    conn->user_data = user_data;
+
+    if (g_conns != NULL) {
+        conn->next = g_conns;
+        g_conns = conn;
+    } else {
+        g_conns = conn;
+    }
+
+    return conn;
+}
+
+void api_close_connection(connection_t *c)
+{
+    connection_t *conn = g_conns, *prev = NULL;
+
+    while (conn) {
+        if (conn == c) {
+            wasm_close_connection(c->handle);
+            if (prev != NULL)
+                prev->next = conn->next;
+            else
+                g_conns = conn->next;
+            free(conn);
+            return;
+        } else {
+            prev = conn;
+            conn = conn->next;
+        }
+    }
+}
+
+int api_send_on_connection(connection_t *conn, const char *data, uint32 len)
+{
+    return wasm_send_on_connection(conn->handle, (int32)data, len);
+}
+
+bool api_config_connection(connection_t *conn, attr_container_t *cfg)
+{
+    char *cfg_buffer = (char *)cfg;
+    uint32 cfg_len = attr_container_get_serialize_length(cfg);
+
+    return wasm_config_connection(conn->handle, (int32)cfg_buffer, cfg_len);
+}
+
+void on_connection_data(uint32 handle, char *buffer, uint32 len)
+{
+    connection_t *conn = g_conns;
+
+    while (conn != NULL) {
+        if (conn->handle == handle) {
+            if (len == 0) {
+                conn->on_event(conn,
+                               CONN_EVENT_TYPE_DISCONNECT,
+                               NULL,
+                               0,
+                               conn->user_data);
+            } else {
+                conn->on_event(conn,
+                               CONN_EVENT_TYPE_DATA,
+                               buffer,
+                               len,
+                               conn->user_data);
+            }
+
+            return;
+        }
+        conn = conn->next;
+    }
+}
+

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

@@ -0,0 +1,106 @@
+/*
+ * 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 _CONNECTION_H_
+#define _CONNECTION_H_
+
+#include "attr_container.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _connection;
+typedef struct _connection connection_t;
+
+/* Connection event type */
+typedef enum {
+    /* Data is received */
+    CONN_EVENT_TYPE_DATA = 1,
+    /* Connection is disconnected */
+    CONN_EVENT_TYPE_DISCONNECT
+} conn_event_type_t;
+
+/*
+ * @typedef on_connection_event_f
+ *
+ * @param conn the connection that the event belongs to
+ * @param type event type
+ * @param data the data received for CONN_EVENT_TYPE_DATA event
+ * @param len length of the data in byte
+ * @param user_data user data
+ */
+typedef void (*on_connection_event_f)(connection_t *conn,
+                                      conn_event_type_t type,
+                                      const char *data,
+                                      uint32 len,
+                                      void *user_data);
+
+/*
+ *****************
+ * Connection API's
+ *****************
+ */
+
+/*
+ * @brief Open a connection.
+ *
+ * @param name name of the connection, "TCP", "UDP" or "UART"
+ * @param args connection arguments, such as: ip:127.0.0.1, port:8888
+ * @param on_event callback function called when event occurs
+ * @param user_data user data
+ *
+ * @return the connection or NULL means fail
+ */
+connection_t *api_open_connection(const char *name,
+                                  attr_container_t *args,
+                                  on_connection_event_f on_event,
+                                  void *user_data);
+
+/*
+ * @brief Close a connection.
+ *
+ * @param conn connection
+ */
+void api_close_connection(connection_t *conn);
+
+/*
+ * Send data to the connection in non-blocking manner which returns immediately
+ *
+ * @param conn the connection
+ * @param data data buffer to be sent
+ * @param len length of the data in byte
+ *
+ * @return actual length sent, or -1 if fail(maybe underlying buffer is full)
+ */
+int api_send_on_connection(connection_t *conn, const char *data, uint32 len);
+
+/*
+ * @brief Configure connection.
+ *
+ * @param conn the connection
+ * @param cfg configurations
+ *
+ * @return true if success, false otherwise
+ */
+bool api_config_connection(connection_t *conn, attr_container_t *cfg);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

core/iwasm/lib/native-interface/connection_api.h

@@ -0,0 +1,38 @@
+/*
+ * 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 CONNECTION_API_H_
+#define CONNECTION_API_H_
+#include "bh_platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint32 wasm_open_connection(int32 name_offset, int32 args_offset, uint32 len);
+
+void wasm_close_connection(uint32 handle);
+
+int wasm_send_on_connection(uint32 handle, int32 data_offset, uint32 len);
+
+bool wasm_config_connection(uint32 handle, int32 cfg_offset, uint32 len);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* CONNECTION_API_H_ */

core/iwasm/lib/native-interface/native_interface.h

@@ -75,4 +75,14 @@ void wasm_timer_destory(timer_id_t timer_id);
 void wasm_timer_cancel(timer_id_t timer_id);
 void wasm_timer_restart(timer_id_t timer_id, int interval);
 uint32 wasm_get_sys_tick_ms(void);
-#endif /* DEPS_SSG_MICRO_RUNTIME_WASM_POC_APP_LIBS_NATIVE_INTERFACE_NATIVE_INTERFACE_H_ */
+
+/*
+ *   *** connection interface ***
+ */
+uint32 wasm_open_connection(int32 name_offset, int32 args_offset, uint32 len);
+void wasm_close_connection(uint32 handle);
+int wasm_send_on_connection(uint32 handle, int32 data_offset, uint32 len);
+bool wasm_config_connection(uint32 handle, int32 cfg_offset, uint32 len);
+
+#endif /* DEPS_SSG_MICRO_RUNTIME_WASM_PO
+C_APP_LIBS_NATIVE_INTERFACE_NATIVE_INTERFACE_H_ */

core/iwasm/lib/native/extension/connection/connection.inl

@@ -0,0 +1,20 @@
+/*
+* 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.
+*/
+
+EXPORT_WASM_API(wasm_open_connection),
+EXPORT_WASM_API(wasm_close_connection),
+EXPORT_WASM_API(wasm_send_on_connection),
+EXPORT_WASM_API(wasm_config_connection),