add support for multi sal devices concurrently

net/sal_module_wrapper/sal_module_wrapper.c

@@ -1,100 +1,161 @@
 #include "sal_module_wrapper.h"
 
-static sal_module_t *g_sal_module = NULL;
+static sal_module_t *cur_sal_module = NULL;
+static k_list_t sal_module_device_list;
 
 int tos_sal_module_register(sal_module_t *module)
 {
-    if (!g_sal_module) {
-        g_sal_module = module;
+    if (!module) {
+        return -1;
+    }
+    
+    if (sal_module_device_list.next == NULL || sal_module_device_list.prev == NULL) {\
+        tos_list_init(&sal_module_device_list);
+    }
+
+    tos_list_add_tail(&module->sal_module_list, &sal_module_device_list);    
+
+    return 0;
+}
+
+int tos_sal_module_unregister(sal_module_t *module)
+{
+    if (!module) {
+        return -1;
+    }
+
+    tos_list_del(&module->sal_module_list);    
+
+    return 0;
+}
+
+int tos_sal_module_set_status(sal_module_t *module, sal_device_status_t status)
+{
+    if (module) {
+        module->sal_module_status = status;
         return 0;
     }
 
     return -1;
 }
 
-int tos_sal_module_register_default()
+void tos_sal_module_set_local_ip(sal_module_t *module, char* ip)
 {
-    g_sal_module = NULL;
+    if (module && ip) {
+        strncpy(module->sal_module_ip, ip, sizeof(module->sal_module_ip));
+    }
 
-    return 0;
+    return;
 }
 
-int tos_sal_module_init(void)
+int tos_sal_module_set_default(char *sal_module_device_name)
 {
-    if (g_sal_module && g_sal_module->init) {
-        return g_sal_module->init();
+    k_list_t     *cur = NULL;
+    sal_module_t *sal_module = NULL;
+
+    TOS_LIST_FOR_EACH(cur, &sal_module_device_list) {
+        sal_module = TOS_LIST_ENTRY(cur, sal_module_t, sal_module_list);
+        if (sal_module == NULL) {
+            continue;
+        }
+        else {
+            if (strcmp(sal_module->sal_module_name, sal_module_device_name) == 0) {
+//                tos_list_del(cur);
+//                tos_list_add(cur, &sal_module_device_list);
+                cur_sal_module = sal_module;
+                return 0;
+            }
+        }
     }
+
     return -1;
 }
 
+int tos_sal_module_get_type(void)
+{
+    if (cur_sal_module) {
+        return cur_sal_module->sal_module_type;
+    }
+
+    return -1;
+}
+
+// int tos_sal_module_init(void)
+// {
+//     if (cur_sal_module && cur_sal_module->init) {
+//         return cur_sal_module->init();
+//     }
+//     return -1;
+// }
+
 int tos_sal_module_parse_domain(const char *host_name, char *host_ip, size_t host_ip_len)
 {
-    if (g_sal_module && g_sal_module->parse_domain) {
-        return g_sal_module->parse_domain(host_name, host_ip, host_ip_len);
+    if (cur_sal_module && cur_sal_module->parse_domain) {
+        return cur_sal_module->parse_domain(host_name, host_ip, host_ip_len);
     }
     return -1;
 }
 
 int tos_sal_module_connect(const char *ip, const char *port, sal_proto_t proto)
 {
-    if (g_sal_module && g_sal_module->connect) {
-        return g_sal_module->connect(ip, port, proto);
+    if (cur_sal_module && cur_sal_module->connect) {
+        return cur_sal_module->connect(ip, port, proto);
     }
     return -1;
 }
 
 int tos_sal_module_send(int sock, const void *buf, size_t len)
 {
-    if (g_sal_module && g_sal_module->send) {
-        return g_sal_module->send(sock, buf, len);
+    if (cur_sal_module && cur_sal_module->send) {
+        return cur_sal_module->send(sock, buf, len);
     }
     return -1;
 }
 
 int tos_sal_module_recv(int sock, void *buf, size_t len)
 {
-    if (g_sal_module && g_sal_module->recv) {
-        return g_sal_module->recv(sock, buf, len);
+    if (cur_sal_module && cur_sal_module->recv) {
+        return cur_sal_module->recv(sock, buf, len);
     }
     return -1;
 }
 
 int tos_sal_module_recv_timeout(int sock, void *buf, size_t len, uint32_t timeout)
 {
-    if (g_sal_module && g_sal_module->recv_timeout) {
-        return g_sal_module->recv_timeout(sock, buf, len, timeout);
+    if (cur_sal_module && cur_sal_module->recv_timeout) {
+        return cur_sal_module->recv_timeout(sock, buf, len, timeout);
     }
     return -1;
 }
 
 int tos_sal_module_sendto(int sock, char *ip, char *port, const void *buf, size_t len)
 {
-    if (g_sal_module && g_sal_module->sendto) {
-        return g_sal_module->sendto(sock, ip, port, buf, len);
+    if (cur_sal_module && cur_sal_module->sendto) {
+        return cur_sal_module->sendto(sock, ip, port, buf, len);
     }
     return -1;
 }
 
 int tos_sal_module_recvfrom(int sock, void *buf, size_t len)
 {
-    if (g_sal_module && g_sal_module->recvfrom) {
-        return g_sal_module->recvfrom(sock, buf, len);
+    if (cur_sal_module && cur_sal_module->recvfrom) {
+        return cur_sal_module->recvfrom(sock, buf, len);
     }
     return -1;
 }
 
 int tos_sal_module_recvfrom_timeout(int sock, void *buf, size_t len, uint32_t timeout)
 {
-    if (g_sal_module && g_sal_module->recvfrom_timeout) {
-        return g_sal_module->recvfrom_timeout(sock, buf, len, timeout);
+    if (cur_sal_module && cur_sal_module->recvfrom_timeout) {
+        return cur_sal_module->recvfrom_timeout(sock, buf, len, timeout);
     }
     return -1;
 }
 
 int tos_sal_module_close(int sock)
 {
-    if (g_sal_module && g_sal_module->close) {
-        return g_sal_module->close(sock);
+    if (cur_sal_module && cur_sal_module->close) {
+        return cur_sal_module->close(sock);
     }
     return -1;
 }

net/sal_module_wrapper/sal_module_wrapper.h

@@ -20,13 +20,39 @@
 
 #include <stdint.h>
 #include <stdio.h>
+#include "tos_k.h"
+
+#define SAL_MODULE_DEVICE_NAME_MAX  10
 
 typedef enum sal_protocol_en {
     TOS_SAL_PROTO_TCP,
     TOS_SAL_PROTO_UDP,
 } sal_proto_t;
 
+typedef enum sal_device_status_en {
+    TOS_SAL_MODULE_AVAILABLE,
+    TOS_SAL_MODULE_UNAVAILABLE,
+} sal_device_status_t;
+
+typedef enum sal_device_type_en {
+    TOS_SAL_MODULE_GPRS,
+    TOS_SAL_MODULE_WIFI,
+    TOS_SAL_MODULE_4G_LTE,
+    TOS_SAL_MODULE_4G_CAT1,
+    TOS_SAL_MODULE_NB_IOT,
+} sal_device_type_t;
+
 typedef struct sal_module_st {
+    char                    sal_module_name[SAL_MODULE_DEVICE_NAME_MAX];
+
+    char                    sal_module_ip[15];
+
+    k_list_t                sal_module_list;
+
+    sal_device_type_t       sal_module_type;
+
+    sal_device_status_t     sal_module_status;
+    
     int (*init)(void);
 
     int (*get_local_mac)(char *mac);
@@ -63,6 +89,8 @@ typedef struct sal_module_st {
  */
 int tos_sal_module_register(sal_module_t *module);
 
+int tos_sal_module_unregister(sal_module_t *module);
+
 /**
  * @brief Register a default sal module.
  *
@@ -72,16 +100,24 @@ int tos_sal_module_register(sal_module_t *module);
  *
  * @return  errcode
  */
-int tos_sal_module_register_default(void);
 
-/**
- * @brief Initialize the module.
- *
- * @attention None
- *
- * @return  errcode
- */
-int tos_sal_module_init(void);
+
+int tos_sal_module_set_status(sal_module_t *module, sal_device_status_t status);
+
+void tos_sal_module_set_local_ip(sal_module_t *module, char* ip);
+
+int tos_sal_module_set_default(char *sal_module_device_name);
+
+int tos_sal_module_get_type(void);
+
+// /**
+//  * @brief Initialize the module.
+//  *
+//  * @attention None
+//  *
+//  * @return  errcode
+//  */
+// int tos_sal_module_init(void);
 
 /**
  * @brief Convert domain to ip address.