- Reset wifi_detection_type Flag when No devices to scan.

Description: When application starts presence without adding devices,
wifi_detection_type is never reset due to which future wifi presence are not started.

- Fixed security vulnerability issues.

Change-Id: I9e99d8ece766960c42a36c1d553c201f4fa8f6ec
Signed-off-by: saerome.kim <saerome.kim@samsung.com>

diff --git a/include/wifi-plugin.h b/include/wifi-plugin.h
index 1117aed..4f61ff8 100644 (file)
--- a/include/wifi-plugin.h
+++ b/include/wifi-plugin.h
@@ -45,11 +45,12 @@ typedef struct {
        gboolean new_device; /**< Is newly added device ?*/
        unsigned int supported_techs; /**< Operating system type of the target dev. */
        wifi_presence_status_e presence; /**< Detected type (see. wifi_presence_status_e) */
+       gboolean discriminant; /**< Weather to check or not */
 } uas_wifi_info_t;
 
-void __check_device_found(char* sbuf, char* ip_sbuf);
+void __check_device_found(char *sbuf, char*ip_sbuf);
 
-void __check_mobilelist();
+int __check_mobilelist(void);
 
 void __check_mobile_list_finish(bool is_check);
 #ifdef __cplusplus

diff --git a/include/wifi-scan.h b/include/wifi-scan.h
index cecbe9d..30e8b8e 100644 (file)
--- a/include/wifi-scan.h
+++ b/include/wifi-scan.h
@@ -42,7 +42,7 @@ extern "C" {
 #define MAX_SIZE_BUFFER 128 /**< Max. buffer size */
 #define SEND_MAC_TIMER 10 /**< Timer value until sending ARP request */
 #define ARP_MAC_TIMER 5 /**< Timer value until receiving ARP response */
-#define BROADCAST_MAC_ADDR     "ff:ff:ff:ff:ff:ff" /**< Broadcast adress */
+#define BROADCAST_MAC_ADDR "ff:ff:ff:ff:ff:ff" /**< Broadcast adress */
 #define MAX_MAC_ARP_COUNT 1 /**< Max. count of ARP request */
 #define ARP_PACKET_SIZE 60 /**< MAX ARP payload size */
 
@@ -62,7 +62,7 @@ struct arp_message {
        uint16_t p_type;/**< protocol type(ETH_P_IP) */
        uint8_t hw_len;/**< hardware address length */
        uint8_t p_len; /**< protocol address length */
-       uint16_t operation;/* ARP opcode */
+       uint16_t operation;/**< ARP opcode */
        uint8_t s_hwaddr[MAC_ADD_LENGTH]; /**< sender hardware address */
        uint8_t s_IPaddr[IP_ADD_LENGTH]; /**< sender IP address */
        uint8_t t_hwaddr[MAC_ADD_LENGTH]; /**< target hardware address */

diff --git a/src/wifi-networkmanager.c b/src/wifi-networkmanager.c
old mode 100755 (executable)
new mode 100644 (file)

diff --git a/src/wifi-plugin.c b/src/wifi-plugin.c
index a839ad8..7d0c09c 100644 (file)
--- a/src/wifi-plugin.c
+++ b/src/wifi-plugin.c
@@ -54,10 +54,10 @@ static int init(const uas_callbacks_t *callbacks)
                UA_WIFI_DBG("Wi-Fi plugin is already initialized");
                FUNC_EXIT;
                return UAS_STATUS_ALREADY_DONE;
-       } else {
-               uas_cbs = callbacks;
        }
 
+       uas_cbs = callbacks;
+
        detect_count = 0;
 
        if (__nm_init() != true) {
@@ -112,63 +112,16 @@ static int get_capability(uas_capability_e *capability)
        return UAS_STATUS_SUCCESS;
 }
 
-static int set_registered_devices(int num_devices, uas_device_info_t *devices)
-{
-       FUNC_ENTER;
-       int i, dev_count = 0;
-
-       retv_if(NULL == uas_cbs, UAS_STATUS_NOT_READY);
-
-       if (dev_list) {
-               g_slist_free_full(dev_list, g_free);
-               dev_list = NULL;
-       }
-
-       for (i = 0; i < num_devices; i++) {
-               uas_wifi_info_t* wifi_info;
-
-               wifi_info = _wifi_plugin_util_get_wifi_info_from_dev_info(&(devices[i]));
-
-               if (!wifi_info)
-                       continue;
-               else
-                       dev_count++;
-
-               wifi_info->mobile_flag = dev_count;
-               dev_list = g_slist_prepend(dev_list, wifi_info);
-       }
-
-       detect_count = dev_count;
-
-       if (uas_cbs->state_changed_cb) {
-               switch (curr_state) {
-               case UAS_STATE_NOT_READY:
-                       if (dev_list) {
-                               uas_cbs->state_changed_cb(UAS_STATE_READY);
-                               curr_state = UAS_STATE_READY;
-                       }
-                       break;
-               case UAS_STATE_READY:
-                       if (!dev_list) {
-                               uas_cbs->state_changed_cb(UAS_STATE_NOT_READY);
-                               curr_state = UAS_STATE_NOT_READY;
-                       }
-                       break;
-               }
-       }
-
-       FUNC_EXIT;
-       return UAS_STATUS_SUCCESS;
-}
-
-void __check_mobilelist()
+int __check_mobilelist(void)
 {
        int ret;
        GSList *l;
 
        if (!dev_list) {
                UA_WIFI_ERR("No devices to scan");
-               return ;
+               /* Reset detection flags */
+               wifi_detection_type = 0;
+               return -1;
        }
 
        for (l = dev_list; NULL != l; l = g_slist_next(l)) {
@@ -183,7 +136,7 @@ void __check_mobilelist()
                        if (initial_bursts == true) {
                                if (UAS_STATUS_SUCCESS != __init_ip_mac_count()) {
                                        UA_WIFI_ERR("ARP Init fail");
-                                       return;
+                                       return 0;
                                } else
                                        initial_bursts = false;
                        }
@@ -203,6 +156,7 @@ void __check_mobilelist()
        }
 
        __check_mobile_list_finish(false);
+       return 0;
 }
 
 void __reset_wifi_info()
@@ -409,6 +363,57 @@ static int add_device(uas_device_info_t *device)
        FUNC_EXIT;
        return UAS_STATUS_SUCCESS;
 }
+static int set_registered_devices(int num_devices, uas_device_info_t *devices)
+{
+       FUNC_ENTER;
+       int i, dev_count = 0;
+
+       retv_if(NULL == uas_cbs, UAS_STATUS_NOT_READY);
+
+       if (dev_list) {
+               g_slist_free_full(dev_list, g_free);
+               dev_list = NULL;
+       }
+
+       for (i = 0; i < num_devices; i++) {
+               uas_wifi_info_t* wifi_info;
+
+               wifi_info = _wifi_plugin_util_get_wifi_info_from_dev_info(&(devices[i]));
+
+               if (!wifi_info)
+                       continue;
+               else if (!wifi_info->discriminant) {
+                       UA_WIFI_DBG("Device [%s] discriminant false -> skip", wifi_info->mac_addr);
+                       continue;
+               } else
+                       dev_count++;
+
+               wifi_info->mobile_flag = dev_count;
+               dev_list = g_slist_prepend(dev_list, wifi_info);
+       }
+
+       detect_count = dev_count;
+
+       if (uas_cbs->state_changed_cb) {
+               switch (curr_state) {
+               case UAS_STATE_NOT_READY:
+                       if (dev_list) {
+                               uas_cbs->state_changed_cb(UAS_STATE_READY);
+                               curr_state = UAS_STATE_READY;
+                       }
+                       break;
+               case UAS_STATE_READY:
+                       if (!dev_list) {
+                               uas_cbs->state_changed_cb(UAS_STATE_NOT_READY);
+                               curr_state = UAS_STATE_NOT_READY;
+                       }
+                       break;
+               }
+       }
+
+       FUNC_EXIT;
+       return UAS_STATUS_SUCCESS;
+}
 
 static int remove_device(uas_device_info_t *device)
 {

diff --git a/src/wifi-scan.c b/src/wifi-scan.c
old mode 100755 (executable)
new mode 100644 (file)
index 6a41448..714737b
--- a/src/wifi-scan.c
+++ b/src/wifi-scan.c
@@ -43,7 +43,9 @@ static int __arp_packet_make(const char *mac)
                return UAS_STATUS_FAIL;
        }
 
-       memcpy(arp_data->arp_source_mac, source_mac_address, strlen(source_mac_address));
+       strncpy(arp_data->arp_source_mac, source_mac_address, strlen(source_mac_address));
+       arp_data->arp_source_mac[strlen(source_mac_address) + 1] = '\0';
+
        source_mac = ether_aton(source_mac_address);
 
        if (source_mac == NULL) {
@@ -56,8 +58,8 @@ static int __arp_packet_make(const char *mac)
                source_mac_address, ether_ntoa(source_mac));
 
        memset(&arp_data->arp, 0, sizeof(arp_data->arp));
-       memcpy(arp_data->arp.h_source, source_mac, MAC_ADD_LENGTH);
-       memcpy(arp_data->arp.s_hwaddr, source_mac, MAC_ADD_LENGTH);
+       memcpy(arp_data->arp.h_source, source_mac, sizeof(arp_data->arp));
+       memcpy(arp_data->arp.s_hwaddr, source_mac, sizeof(arp_data->arp));
 
        dest_mac = ether_aton(mac);
 
@@ -68,8 +70,8 @@ static int __arp_packet_make(const char *mac)
 
        UA_WIFI_INFO("Scan mac Address = %s dest_mac =%s", mac, ether_ntoa(dest_mac));
 
-       memcpy(arp_data->arp.h_dest, dest_mac, MAC_ADD_LENGTH);
-       memcpy(arp_data->arp.t_hwaddr, dest_mac, MAC_ADD_LENGTH);
+       memcpy(arp_data->arp.h_dest, dest_mac, sizeof(arp_data->arp.h_dest));
+       memcpy(arp_data->arp.t_hwaddr, dest_mac, sizeof(arp_data->arp.t_hwaddr));
 
        arp_data->arp.h_proto = htons(ETH_P_ARP); /* protocol type (Ethernet) */
        arp_data->arp.hw_type = htons(ARPHRD_ETHER); /* hardware type */
@@ -165,7 +167,7 @@ gboolean __arp_packet_receive(GIOChannel *source, GIOCondition condition,
                        uint32_t target_ip = 0;
 
                        memset(&arp_recv, 0, sizeof(arp_recv));
-                       memcpy(&arp_recv, buffer, sizeof(buffer));
+                       memcpy(&arp_recv, buffer, sizeof(arp_recv));
 
                        target_ip = inet_addr(arp_data->arp_source_ip);
 
@@ -179,10 +181,10 @@ gboolean __arp_packet_receive(GIOChannel *source, GIOCondition condition,
                                arp_recv.s_hwaddr[0], arp_recv.s_hwaddr[1], arp_recv.s_hwaddr[2],
                                arp_recv.s_hwaddr[3], arp_recv.s_hwaddr[4], arp_recv.s_hwaddr[5]);
 
-                       snprintf(tbuf, MAC_ADDRESS_STRING_SIZE, "%02x:%02x:%02x:%02x:%02x:%02x",
+                       snprintf(tbuf, sizeof(tbuf), "%02x:%02x:%02x:%02x:%02x:%02x",
                                arp_recv.t_hwaddr[0], arp_recv.t_hwaddr[1], arp_recv.t_hwaddr[2],
                                arp_recv.t_hwaddr[3], arp_recv.t_hwaddr[4], arp_recv.t_hwaddr[5]);
-                       snprintf(sbuf, MAC_ADDRESS_STRING_SIZE, "%02x:%02x:%02x:%02x:%02x:%02x",
+                       snprintf(sbuf, sizeof(sbuf), "%02x:%02x:%02x:%02x:%02x:%02x",
                                arp_recv.s_hwaddr[0], arp_recv.s_hwaddr[1], arp_recv.s_hwaddr[2],
                                arp_recv.s_hwaddr[3], arp_recv.s_hwaddr[4], arp_recv.s_hwaddr[5]);
 
@@ -194,13 +196,13 @@ gboolean __arp_packet_receive(GIOChannel *source, GIOCondition condition,
                        if (!strcasecmp(tbuf , "00:00:00:00:00:00"))
                                UA_WIFI_INFO("Broadcast packet.");
 
-                       snprintf(ip_sbuff, IP_ADDRESS_STRING_SIZE, "%d.%d.%d.%d",
+                       snprintf(ip_sbuff, sizeof(ip_sbuff), "%d.%d.%d.%d",
                                arp_recv.s_IPaddr[0], arp_recv.s_IPaddr[1],
                                arp_recv.s_IPaddr[2], arp_recv.s_IPaddr[3]);
                        UA_WIFI_INFO("source ip_sbuff = %s target ip = %d source ip = %d",
                                ip_sbuff, target_ip, __convert_uchar_to_uint(arp_recv.s_IPaddr));
 
-                       snprintf(ip_tbuff, IP_ADDRESS_STRING_SIZE, "%d.%d.%d.%d",
+                       snprintf(ip_tbuff, sizeof(ip_tbuff), "%d.%d.%d.%d",
                                arp_recv.t_IPaddr[0], arp_recv.t_IPaddr[1],
                                arp_recv.t_IPaddr[2], arp_recv.t_IPaddr[3]);
                        UA_WIFI_INFO("target ip_tbuff = %s target ip = %d source ip = %d",
@@ -280,7 +282,6 @@ static int __init_arp(const char *mac)
        char error_buf[MAX_SIZE_ERROR_BUFFER];
        char *iface_name = NULL;
        int val = 1;
-       int if_name_len ;
        struct ether_addr *dest_mac = NULL;
 
        dest_mac = ether_aton(mac);
@@ -314,18 +315,21 @@ static int __init_arp(const char *mac)
        /* ifreq structure creation */
        if (__nm_get_interface_name(&iface_name) == false) {
                UA_WIFI_ERR("interface is wrong");
+               close(arp_data->arp_id);
+               arp_data->arp_id = -1;
                return UAS_STATUS_FAIL;
        }
 
        UA_WIFI_INFO("Network interface %s", iface_name);
-       if_name_len = strlen(iface_name);
 
-       if (if_name_len < sizeof(net_ifr.ifr_name)) {
-               memcpy(net_ifr.ifr_name, iface_name, if_name_len);
-               net_ifr.ifr_name[if_name_len] = 0;
+       if (strlen(iface_name) < sizeof(net_ifr.ifr_name)) {
+               strncpy(net_ifr.ifr_name, iface_name, strlen(iface_name));
+               net_ifr.ifr_name[strlen(iface_name)] = 0;
        } else {
                UA_WIFI_ERR("Error : Interface name is too long");
                free(iface_name);
+               close(arp_data->arp_id);
+               arp_data->arp_id = -1;
                return UAS_STATUS_FAIL;
        }
 
@@ -334,6 +338,8 @@ static int __init_arp(const char *mac)
        if (ioctl(arp_data->arp_id, SIOCGIFINDEX, &net_ifr) == -1) {
                strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
                UA_WIFI_ERR("ioctl failed. Error: %s", error_buf);
+               close(arp_data->arp_id);
+               arp_data->arp_id = -1;
                return UAS_STATUS_FAIL;
        }
 
@@ -342,7 +348,7 @@ static int __init_arp(const char *mac)
        arp_data->addr.sll_ifindex = net_ifr.ifr_ifindex;
        arp_data->addr.sll_halen = ETHER_ADDR_LEN;
        arp_data->addr.sll_protocol = htons(ETH_P_ARP);
-       memcpy(arp_data->addr.sll_addr, dest_mac, ETHER_ADDR_LEN);
+       memcpy(arp_data->addr.sll_addr, dest_mac, sizeof(arp_data->addr.sll_addr));
 
        arp_data->arp_sock_io = g_io_channel_unix_new(arp_data->arp_id);
 
@@ -388,12 +394,13 @@ gboolean __send_arp_ip_packet_timeout(gpointer user_data)
        memset(arp_target_ip, '\0', MAX_SIZE_BUFFER);
 
        source_ip = inet_addr(__nm_get_ip_address());
-       memcpy(arp_data->arp.s_IPaddr, &source_ip, IP_ADD_LENGTH); // source IP address
-       //snprintf(ip_buff, 16, "%d.%d.%d.%d",
-       //      arp.s_IPaddr[0],arp.s_IPaddr[1],arp.s_IPaddr[2],pArping->arp_send_ip_addr);
+       memcpy(arp_data->arp.s_IPaddr, &source_ip,
+               sizeof(arp_data->arp.s_IPaddr));  // source IP address
+       //snprintf(ip_buff, 16, "%d.%d.%d.%d",arp.s_IPaddr[0],arp.s_IPaddr[1],arp.s_IPaddr[2],pArping->arp_send_ip_addr);
 
        target_ip = inet_addr(arp_data->arp_source_ip);
-       memcpy(arp_data->arp.t_IPaddr, &target_ip, IP_ADD_LENGTH); // target IP address
+       memcpy(arp_data->arp.t_IPaddr, &target_ip,
+               sizeof(arp_data->arp.t_IPaddr)); // target IP address
        memcpy(arp_target_ip, arp_data->arp_source_ip , strlen(arp_data->arp_source_ip));
 
        UA_WIFI_INFO("arp_target_ip = %s ", arp_target_ip);
@@ -419,15 +426,18 @@ gboolean __send_arp_unimul_packet_timeout(gpointer user_data)
        memset(arp_target_ip, '\0', MAX_SIZE_BUFFER);
        memset(error_buf, '\0', MAX_SIZE_ERROR_BUFFER);
        memset(ip_buff, '\0', IP_ADDRESS_STRING_SIZE);
+
        source_ip = inet_addr(__nm_get_ip_address());
-       memcpy(arp_data->arp.s_IPaddr, &source_ip, IP_ADD_LENGTH); // source IP address
-       snprintf(ip_buff, IP_ADDRESS_STRING_SIZE, "%d.%d.%d.%d",
+       memcpy(arp_data->arp.s_IPaddr, &source_ip,
+               sizeof(arp_data->arp.s_IPaddr)); // source IP address
+       snprintf(ip_buff, sizeof(ip_buff), "%d.%d.%d.%d",
                arp_data->arp.s_IPaddr[0], arp_data->arp.s_IPaddr[1],
                arp_data->arp.s_IPaddr[2], arp_data->arp_send_ip_addr);
 
        target_ip = inet_addr(ip_buff);
        memcpy(arp_target_ip, ip_buff, strlen(ip_buff));
-       memcpy(arp_data->arp.t_IPaddr, &target_ip, IP_ADD_LENGTH); // target IP address
+       memcpy(arp_data->arp.t_IPaddr, &target_ip,
+               sizeof(arp_data->arp.s_IPaddr)); // target IP address
 
        if (arp_data->arp_send_ip_addr == 1 || arp_data->arp_send_ip_addr == 255)
                UA_WIFI_INFO("Arp target ip: %s", arp_target_ip);

diff --git a/src/wifi-util.c b/src/wifi-util.c
index e3fe070..6244df2 100644 (file)
--- a/src/wifi-util.c
+++ b/src/wifi-util.c
@@ -37,6 +37,7 @@ uas_wifi_info_t *_wifi_plugin_util_get_wifi_info_from_dev_info(
        wifi_info = g_new0(uas_wifi_info_t, 1);
        wifi_info->user_id = dev_info->user_id;
        wifi_info->os = dev_info->os;
+       wifi_info->discriminant = dev_info->discriminant;
        wifi_info->supported_techs = dev_info->supported_techs;
 
        g_strlcpy(wifi_info->mobile_id, dev_info->device_id, UAS_DEVICE_ID_MAX_LEN);
@@ -61,10 +62,10 @@ uas_wifi_info_t *_wifi_plugin_util_get_wifi_info_from_dev_info(
                return NULL;
        }
 
-       UA_WIFI_DBG("User Id: [0x%X], OS: [0x%X], Device Id: [%s], \
-                                       MAC Addr: [%s], IP Addr: [%s]",
+       UA_WIFI_DBG("User Id: [0x%X], OS: [0x%X], Device Id: [%s], " \
+                               "MAC Addr: [%s], IP Addr: [%s] discriminant: [%d]",
                        wifi_info->user_id, wifi_info->os, wifi_info->mobile_id,
-                       wifi_info->mac_addr, wifi_info->ip_addr);
+                       wifi_info->mac_addr, wifi_info->ip_addr, wifi_info->discriminant);
 
        FUNC_EXIT;
        return wifi_info;
@@ -83,6 +84,7 @@ uas_device_info_t *_wifi_plugin_util_get_dev_info_from_wifi_info(
        dev_info = g_new0(uas_device_info_t, 1);
        dev_info->user_id = wifi_info->user_id;
        dev_info->os = wifi_info->os;
+       dev_info->discriminant = wifi_info->discriminant;
        dev_info->supported_techs = wifi_info->supported_techs;
        dev_info->device_id = g_strdup(wifi_info->mobile_id);
 
@@ -115,9 +117,9 @@ uas_device_info_t *_wifi_plugin_util_get_dev_info_from_wifi_info(
        dev_info->num_addr = count;
 
        for (int i = 0; i < count; i++) {
-               UA_WIFI_DBG("User Id: [0x%X], OS: [0x%X], Device Id: [%s], MAC/IP Addr: [%s]",
-                               dev_info->user_id, dev_info->os, dev_info->device_id,
-                               dev_info->addr_list[i].address);
+               UA_WIFI_DBG("User Id: [0x%X], OS: [0x%X], Device Id: [%s], MAC/IP Addr: [%s], "
+                       "discriminant: [%d]", dev_info->user_id, dev_info->os, dev_info->device_id,
+                               dev_info->addr_list[i].address, dev_info->discriminant);
        }
 
        FUNC_EXIT;