Rearrange memory ownership of found device

Description: The plugin'll handle the peer device memory in event
and manager'll handle the peer device memory in requesting method.

Change-Id: I29cdce4bd9ece87a44e90448b92c82cb1ab644df
Signed-off-by: Yu jiung <jiung.yu@samsung.com>

diff --git a/packaging/wifi-direct-manager.spec b/packaging/wifi-direct-manager.spec
index 0a3a1d9..03c6ec8 100644 (file)
--- a/packaging/wifi-direct-manager.spec
+++ b/packaging/wifi-direct-manager.spec
@@ -6,7 +6,7 @@
 
 Name:          wifi-direct-manager
 Summary:       Wi-Fi Direct manger
-Version:       1.3.5
+Version:       1.3.6
 Release:       1
 Group:      Network & Connectivity/Wireless
 License:    Apache-2.0

diff --git a/plugin/wpasupplicant/ctrl_iface_dbus/wfd-plugin-wpasupplicant.c b/plugin/wpasupplicant/ctrl_iface_dbus/wfd-plugin-wpasupplicant.c
index 84049a1..266bf04 100644 (file)
--- a/plugin/wpasupplicant/ctrl_iface_dbus/wfd-plugin-wpasupplicant.c
+++ b/plugin/wpasupplicant/ctrl_iface_dbus/wfd-plugin-wpasupplicant.c
@@ -416,25 +416,34 @@ static int __ws_segment_to_service(char *segment, wfd_oem_new_service_s **servic
        return 0;
 }
 
+static void __extract_addr_from_path(char *peer_path, unsigned char *dev_addr)
+{
+       static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
+       char *loc = NULL;
+
+       if (!peer_path || !dev_addr)
+               return;
+
+       loc = strrchr(peer_path, '/');
+       if (loc != NULL)
+               __ws_mac_compact_to_normal(loc + 1, peer_dev);
+
+       __ws_txt_to_mac(peer_dev, dev_addr);
+       WDP_LOGD("dev addr [" MACSTR "]", MAC2STR(dev_addr));
+}
+
 static void __ws_path_to_addr(char *peer_path,
                unsigned char *dev_addr, GVariant *parameter)
 {
        __WDP_LOG_FUNC_ENTER__;
 
-       static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
        const char *path = NULL;
-       char *loc = NULL;
 
        g_variant_get(parameter, "(&o)", &path);
        g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
        WDP_LOGD("Retrive Added path [%s]", peer_path);
 
-       loc = strrchr(peer_path, '/');
-       if (loc != NULL)
-               __ws_mac_compact_to_normal(loc + 1, peer_dev);
-
-       __ws_txt_to_mac(peer_dev, dev_addr);
-       WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(dev_addr));
+       __extract_addr_from_path(peer_path, dev_addr);
 
        __WDP_LOG_FUNC_EXIT__;
        return;
@@ -1032,20 +1041,15 @@ static void __ws_parse_peer_joined(char *peer_path,
 
        GVariantIter *iter;
        gboolean iter_res = TRUE;
-       static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
        const char *path = NULL;
-       char *loc = NULL;
        int i = 0;
 
        g_variant_get(parameter, "(&oay)", &path, &iter);
        g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
        WDP_LOGD("Retrive Added path [%s]", peer_path);
 
-       loc = strrchr(peer_path, '/');
-       if (loc != NULL)
-               __ws_mac_compact_to_normal(loc + 1, peer_dev);
-       __ws_txt_to_mac(peer_dev, dev_addr);
-       WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(dev_addr));
+       __extract_addr_from_path(peer_path, dev_addr);
+
        for (i = 0; iter_res &&  i < OEM_IPADDR_LEN; i++)
                iter_res = g_variant_iter_loop(iter, "y", &ip_addr[i]);
        g_variant_iter_free(iter);
@@ -1056,37 +1060,78 @@ static void __ws_parse_peer_joined(char *peer_path,
        return;
 }
 
+static gboolean __is_valid_plugin(void)
+{
+       gboolean is_valid = (g_pd && g_pd->callback);
+
+       if (!is_valid)
+               WDP_LOGD("Ignoring event");
+
+       return is_valid;
+}
+
+static wfd_oem_dev_data_s *__create_dev_data(void)
+{
+       wfd_oem_dev_data_s *dev_data =
+                       (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
+       if (!dev_data) {
+               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
+               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+               WDP_LOGF("Failed to allocate memory for event. [%s]",
+                               error_buf);
+       }
+
+       return dev_data;
+}
+
+static void __set_event_data(int event_id, int edata_type, void *data, wfd_oem_event_s *event)
+{
+       if (!event)
+               return;
+
+       memset(event, 0x0, sizeof(wfd_oem_event_s));
+
+       event->edata = data;
+       event->edata_type = edata_type;
+       event->event_id = event_id;
+
+       return;
+}
+
+static void __destroy_dev_data(wfd_oem_dev_data_s *dev_data)
+{
+       if (!dev_data)
+               return;
+
+       if (dev_data->vsie)
+               g_free(dev_data->vsie);
+       g_free(dev_data);
+}
+
 static void _ws_process_peer_joined(GDBusConnection *connection,
                const gchar *sender, const gchar *object_path, const gchar *interface,
                const gchar *signal, GVariant *parameters, gpointer user_data)
 {
        __WDP_LOG_FUNC_ENTER__;
        wfd_oem_event_s event;
-       wfd_oem_dev_data_s *edata = NULL;
+       wfd_oem_dev_data_s *dev_data = NULL;
        static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 
        DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
 
-       if (!g_pd || !g_pd->callback) {
-               WDP_LOGD("Ignoring event");
-               __WDP_LOG_FUNC_EXIT__;
+       if (!__is_valid_plugin())
                return;
-       }
 
-       edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
-       if (!edata) {
-               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
-               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
-               WDP_LOGF("Failed to allocate memory for event. [%s]",
-                               error_buf);
+       dev_data = __create_dev_data();
+       if (!dev_data) {
                __WDP_LOG_FUNC_EXIT__;
                return;
        }
-       memset(&event, 0x0, sizeof(wfd_oem_event_s));
 
-       event.edata = (void*) edata;
-       event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
-       event.event_id = WFD_OEM_EVENT_STA_CONNECTED;
+       __set_event_data(WFD_OEM_EVENT_STA_CONNECTED,
+                       WFD_OEM_EDATA_TYPE_DEVICE,
+                       (void *)dev_data,
+                       &event);
 
        __ws_parse_peer_joined(peer_path, event.dev_addr, event.ip_addr_peer, parameters);
 
@@ -1098,7 +1143,8 @@ static void _ws_process_peer_joined(GDBusConnection *connection,
 
        is_peer_joined_notified = 1;
 
-       g_free(edata);
+       __destroy_dev_data(dev_data);
+
        __WDP_LOG_FUNC_EXIT__;
 }
 
@@ -2072,45 +2118,32 @@ static void _ws_process_device_found_properties(GDBusConnection *connection,
 {
        __WDP_LOG_FUNC_ENTER__;
        wfd_oem_event_s event;
-       wfd_oem_dev_data_s *edata = NULL;
+       wfd_oem_dev_data_s *dev_data = NULL;
        static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
-       static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
-       char *loc = NULL;
        GVariantIter *iter = NULL;
        const char *path = NULL;
 
        DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
 
-       if (!g_pd || !g_pd->callback) {
-               WDP_LOGD("Ignoring event");
-               __WDP_LOG_FUNC_EXIT__;
+       if (!__is_valid_plugin())
                return;
-       }
 
-       edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
-       if (!edata) {
-               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
-               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
-               WDP_LOGF("Failed to allocate memory for event. [%s]",
-                               error_buf);
+       dev_data = __create_dev_data();
+       if (!dev_data) {
                __WDP_LOG_FUNC_EXIT__;
                return;
        }
-       memset(&event, 0x0, sizeof(wfd_oem_event_s));
 
-       event.edata = (void*) edata;
-       event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
-       event.event_id = WFD_OEM_EVENT_PEER_FOUND;
+       __set_event_data(WFD_OEM_EVENT_PEER_FOUND,
+                       WFD_OEM_EDATA_TYPE_DEVICE,
+                       (void *)dev_data,
+                       &event);
 
        g_variant_get(parameters, "(&oa{sv})", &path, &iter);
        g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
        WDP_LOGD("Retrive Added path [%s]", peer_path);
 
-       loc = strrchr(peer_path, '/');
-       if (loc != NULL)
-               __ws_mac_compact_to_normal(loc + 1, peer_dev);
-       __ws_txt_to_mac(peer_dev, event.dev_addr);
-       WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+       __extract_addr_from_path(peer_path, event.dev_addr);
 
        if (iter != NULL) {
                gchar *key = NULL;
@@ -2119,14 +2152,14 @@ static void _ws_process_device_found_properties(GDBusConnection *connection,
                while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
                        CHECK_KEY_VALUE(key, value);
 
-                       __ws_peer_property(key, value, (void *) event.edata);
+                       __ws_peer_property(key, value, (void *)event.edata);
                }
                g_variant_iter_free(iter);
        }
 
-       if (edata->has_asp_services)
+       if (dev_data->has_asp_services)
                ws_get_advertise_service(peer_path, (GList **)&(event.asp_services));
-       if (edata->has_asp2_services)
+       if (dev_data->has_asp2_services)
                ws_get_advertise_asp_service(peer_path, (GList **)&(event.asp2_services));
 
        if (g_pd->callback->peer_found_cb)
@@ -2153,7 +2186,8 @@ static void _ws_process_device_found_properties(GDBusConnection *connection,
                        g_free(service);
                }
        }
-       g_free(event.edata);
+
+       __destroy_dev_data(dev_data);
 
        __WDP_LOG_FUNC_EXIT__;
 }
@@ -2220,46 +2254,32 @@ static void _ws_process_prov_disc_req_display_pin(GDBusConnection *connection,
 {
        __WDP_LOG_FUNC_ENTER__;
        wfd_oem_event_s event;
-       wfd_oem_dev_data_s *edata = NULL;
+       wfd_oem_dev_data_s *dev_data = NULL;
        static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
-       static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
        const char *path = NULL;
        const char *pin = NULL;
-       char *loc = NULL;
-
        DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
 
-       if (!g_pd || !g_pd->callback) {
-               WDP_LOGD("Ignoring event");
-               __WDP_LOG_FUNC_EXIT__;
+       if (!__is_valid_plugin())
                return;
-       }
 
-       edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
-       if (!edata) {
-               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
-               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
-               WDP_LOGF("Failed to allocate memory for event. [%s]",
-                               error_buf);
+       dev_data = __create_dev_data();
+       if (!dev_data) {
                __WDP_LOG_FUNC_EXIT__;
                return;
        }
-       memset(&event, 0x0, sizeof(wfd_oem_event_s));
 
-       event.edata = (void*) edata;
-       event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
-       event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
+       __set_event_data(WFD_OEM_EVENT_PROV_DISC_REQ,
+                       WFD_OEM_EDATA_TYPE_DEVICE,
+                       (void *)dev_data,
+                       &event);
        event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
 
        g_variant_get(parameters, "(&o&s)", &path, &pin);
        g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
        WDP_LOGD("Retrive Added path [%s]", peer_path);
 
-       loc = strrchr(peer_path, '/');
-       if (loc != NULL)
-               __ws_mac_compact_to_normal(loc + 1, peer_dev);
-       __ws_txt_to_mac(peer_dev, event.dev_addr);
-       WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+       __extract_addr_from_path(peer_path, event.dev_addr);
 
        g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
        WDP_LOGD("Retrive pin [%s]", event.wps_pin);
@@ -2270,7 +2290,7 @@ static void _ws_process_prov_disc_req_display_pin(GDBusConnection *connection,
        if (g_pd->callback->prov_disc_req_cb)
                g_pd->callback->prov_disc_req_cb(&event);
 
-       g_free(event.edata);
+       __destroy_dev_data(dev_data);
 
        __WDP_LOG_FUNC_EXIT__;
 }
@@ -2281,46 +2301,33 @@ static void _ws_process_prov_disc_resp_display_pin(GDBusConnection *connection,
 {
        __WDP_LOG_FUNC_ENTER__;
        wfd_oem_event_s event;
-       wfd_oem_dev_data_s *edata = NULL;
+       wfd_oem_dev_data_s *dev_data = NULL;
        static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
-       static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
        const char *path = NULL;
        const char *pin = NULL;
-       char *loc = NULL;
 
        DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
 
-       if (!g_pd || !g_pd->callback) {
-               WDP_LOGD("Ignoring event");
-               __WDP_LOG_FUNC_EXIT__;
+       if (!__is_valid_plugin())
                return;
-       }
 
-       edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
-       if (!edata) {
-               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
-               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
-               WDP_LOGF("Failed to allocate memory for event. [%s]",
-                               error_buf);
+       dev_data = __create_dev_data();
+       if (!dev_data) {
                __WDP_LOG_FUNC_EXIT__;
                return;
        }
-       memset(&event, 0x0, sizeof(wfd_oem_event_s));
 
-       event.edata = (void*) edata;
-       event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
-       event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
+       __set_event_data(WFD_OEM_EVENT_PROV_DISC_RESP,
+                       WFD_OEM_EDATA_TYPE_DEVICE,
+                       (void *)dev_data,
+                       &event);
        event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
 
        g_variant_get(parameters, "(&o&s)", &path, &pin);
        g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
        WDP_LOGD("Retrive Added path [%s]", peer_path);
 
-       loc = strrchr(peer_path, '/');
-       if (loc != NULL)
-               __ws_mac_compact_to_normal(loc + 1, peer_dev);
-       __ws_txt_to_mac(peer_dev, event.dev_addr);
-       WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+       __extract_addr_from_path(peer_path, event.dev_addr);
 
        g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
        WDP_LOGD("Retrive pin [%s]", event.wps_pin);
@@ -2331,7 +2338,7 @@ static void _ws_process_prov_disc_resp_display_pin(GDBusConnection *connection,
        if (g_pd->callback->prov_disc_resp_cb)
                g_pd->callback->prov_disc_resp_cb(&event);
 
-       g_free(event.edata);
+       __destroy_dev_data(dev_data);
 
        __WDP_LOG_FUNC_EXIT__;
 }
@@ -2342,31 +2349,23 @@ static void _ws_process_prov_disc_req_enter_pin(GDBusConnection *connection,
 {
        __WDP_LOG_FUNC_ENTER__;
        wfd_oem_event_s event;
-       wfd_oem_dev_data_s *edata = NULL;
+       wfd_oem_dev_data_s *dev_data = NULL;
        static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 
        DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
-
-       if (!g_pd || !g_pd->callback) {
-               WDP_LOGD("Ignoring event");
-               __WDP_LOG_FUNC_EXIT__;
+       if (!__is_valid_plugin())
                return;
-       }
 
-       edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
-       if (!edata) {
-               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
-               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
-               WDP_LOGF("Failed to allocate memory for event. [%s]",
-                               error_buf);
+       dev_data = __create_dev_data();
+       if (!dev_data) {
                __WDP_LOG_FUNC_EXIT__;
                return;
        }
-       memset(&event, 0x0, sizeof(wfd_oem_event_s));
 
-       event.edata = (void*) edata;
-       event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
-       event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
+       __set_event_data(WFD_OEM_EVENT_PROV_DISC_REQ,
+                       WFD_OEM_EDATA_TYPE_DEVICE,
+                       (void *)dev_data,
+                       &event);
        event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
 
        __ws_path_to_addr(peer_path, event.dev_addr, parameters);
@@ -2377,7 +2376,7 @@ static void _ws_process_prov_disc_req_enter_pin(GDBusConnection *connection,
        if (g_pd->callback->prov_disc_req_cb)
                g_pd->callback->prov_disc_req_cb(&event);
 
-       g_free(event.edata);
+       __destroy_dev_data(dev_data);
 
        __WDP_LOG_FUNC_EXIT__;
 }
@@ -2388,31 +2387,25 @@ static void _ws_process_prov_disc_resp_enter_pin(GDBusConnection *connection,
 {
        __WDP_LOG_FUNC_ENTER__;
        wfd_oem_event_s event;
-       wfd_oem_dev_data_s *edata = NULL;
+       wfd_oem_dev_data_s *dev_data = NULL;
        static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 
        DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
 
-       if (!g_pd || !g_pd->callback) {
-               WDP_LOGD("Ignoring event");
-               __WDP_LOG_FUNC_EXIT__;
+       if (!__is_valid_plugin())
                return;
-       }
 
-       edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
-       if (!edata) {
-               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
-               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
-               WDP_LOGF("Failed to allocate memory for event. [%s]",
-                               error_buf);
+       dev_data = __create_dev_data();
+       if (!dev_data) {
                __WDP_LOG_FUNC_EXIT__;
                return;
        }
-       memset(&event, 0x0, sizeof(wfd_oem_event_s));
 
-       event.edata = (void*) edata;
-       event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
-       event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
+       __set_event_data(WFD_OEM_EVENT_PROV_DISC_RESP,
+                       WFD_OEM_EDATA_TYPE_DEVICE,
+                       (void *)dev_data,
+                       &event);
+
        event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
 
        __ws_path_to_addr(peer_path, event.dev_addr, parameters);
@@ -2423,7 +2416,7 @@ static void _ws_process_prov_disc_resp_enter_pin(GDBusConnection *connection,
        if (g_pd->callback->prov_disc_resp_cb)
                g_pd->callback->prov_disc_resp_cb(&event);
 
-       g_free(event.edata);
+       __destroy_dev_data(dev_data);
 
        __WDP_LOG_FUNC_EXIT__;
 }
@@ -2434,31 +2427,23 @@ static void _ws_process_prov_disc_pbc_req(GDBusConnection *connection,
 {
        __WDP_LOG_FUNC_ENTER__;
        wfd_oem_event_s event;
-       wfd_oem_dev_data_s *edata = NULL;
+       wfd_oem_dev_data_s *dev_data = NULL;
        static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 
        DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
 
-       if (!g_pd || !g_pd->callback) {
-               WDP_LOGD("Ignoring event");
-               __WDP_LOG_FUNC_EXIT__;
+       if (!__is_valid_plugin())
                return;
-       }
 
-       edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
-       if (!edata) {
-               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
-               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
-               WDP_LOGF("Failed to allocate memory for event. [%s]",
-                               error_buf);
+       dev_data = __create_dev_data();
+       if (!dev_data) {
                __WDP_LOG_FUNC_EXIT__;
                return;
        }
-       memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
-       event.edata = (void*) edata;
-       event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
-       event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
+       __set_event_data(WFD_OEM_EVENT_PROV_DISC_REQ,
+                       WFD_OEM_EDATA_TYPE_DEVICE,
+                       (void *)dev_data,
+                       &event);
        event.wps_mode = WFD_OEM_WPS_MODE_PBC;
 
        __ws_path_to_addr(peer_path, event.dev_addr, parameters);
@@ -2469,7 +2454,7 @@ static void _ws_process_prov_disc_pbc_req(GDBusConnection *connection,
        if (g_pd->callback->prov_disc_req_cb)
                g_pd->callback->prov_disc_req_cb(&event);
 
-       g_free(event.edata);
+       __destroy_dev_data(dev_data);
 
        __WDP_LOG_FUNC_EXIT__;
 }
@@ -2480,31 +2465,23 @@ static void _ws_process_prov_disc_pbc_resp(GDBusConnection *connection,
 {
        __WDP_LOG_FUNC_ENTER__;
        wfd_oem_event_s event;
-       wfd_oem_dev_data_s *edata = NULL;
+       wfd_oem_dev_data_s *dev_data = NULL;
        static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 
        DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
 
-       if (!g_pd || !g_pd->callback) {
-               WDP_LOGD("Ignoring event");
-               __WDP_LOG_FUNC_EXIT__;
+       if (!__is_valid_plugin())
                return;
-       }
 
-       edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
-       if (!edata) {
-               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
-               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
-               WDP_LOGF("Failed to allocate memory for event. [%s]",
-                               error_buf);
+       dev_data = __create_dev_data();
+       if (!dev_data) {
                __WDP_LOG_FUNC_EXIT__;
                return;
        }
-       memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
-       event.edata = (void*) edata;
-       event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
-       event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
+       __set_event_data(WFD_OEM_EVENT_PROV_DISC_RESP,
+                       WFD_OEM_EDATA_TYPE_DEVICE,
+                       (void *)dev_data,
+                       &event);
        event.wps_mode = WFD_OEM_WPS_MODE_PBC;
 
        __ws_path_to_addr(peer_path, event.dev_addr, parameters);
@@ -2515,7 +2492,7 @@ static void _ws_process_prov_disc_pbc_resp(GDBusConnection *connection,
        if (g_pd->callback->prov_disc_resp_cb)
                g_pd->callback->prov_disc_resp_cb(&event);
 
-       g_free(event.edata);
+       __destroy_dev_data(dev_data);
 
        __WDP_LOG_FUNC_EXIT__;
 }
@@ -2725,65 +2702,59 @@ static void _ws_process_go_neg_failure(GDBusConnection *connection,
        __WDP_LOG_FUNC_EXIT__;
 }
 
+static void __set_wps_mode_for_event(int dev_passwd_id, wfd_oem_event_s *event)
+{
+       if (!event)
+               return;
+
+       WDP_LOGD("Retrive dev_passwd_id [%d]", dev_passwd_id);
+
+       if (dev_passwd_id == WS_DEV_PASSWD_ID_PUSH_BUTTON)
+               event->wps_mode = WFD_OEM_WPS_MODE_PBC;
+       else if (dev_passwd_id == WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED)
+               event->wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
+       else if (dev_passwd_id == WS_DEV_PASSWD_ID_USER_SPECIFIED)
+               event->wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
+       else
+               event->wps_mode = WFD_OEM_WPS_MODE_NONE;
+}
+
 static void _ws_process_go_neg_request(GDBusConnection *connection,
                const gchar *sender, const gchar *object_path, const gchar *interface,
                const gchar *signal, GVariant *parameters, gpointer user_data)
 {
        __WDP_LOG_FUNC_ENTER__;
        wfd_oem_event_s event;
-       wfd_oem_dev_data_s *edata = NULL;
+       wfd_oem_dev_data_s *dev_data = NULL;
        static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
-       static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
        const char *path = NULL;
-       char * loc = NULL;
        int dev_passwd_id = 0;
        int device_go_intent = 0;
 
        DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
 
-       if (!g_pd || !g_pd->callback) {
-               WDP_LOGD("Ignoring event");
-               __WDP_LOG_FUNC_EXIT__;
+       if (!__is_valid_plugin())
                return;
-       }
 
-       edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
-       if (!edata) {
-               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
-               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
-               WDP_LOGF("Failed to allocate memory for event. [%s]",
-                               error_buf);
+       dev_data = __create_dev_data();
+       if (!dev_data) {
                __WDP_LOG_FUNC_EXIT__;
                return;
        }
-       memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
-       event.edata = (void*) edata;
-       event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
-       event.event_id = WFD_OEM_EVENT_GO_NEG_REQ;
+       __set_event_data(WFD_OEM_EVENT_GO_NEG_REQ,
+                       WFD_OEM_EDATA_TYPE_DEVICE,
+                       (void *)dev_data,
+                       &event);
 
        g_variant_get(parameters, "(&oqy)", &path, &dev_passwd_id, &device_go_intent);
        g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
 
        WDP_LOGD("Retrive peer path [%s]", peer_path);
-       WDP_LOGD("Retrive dev_passwd_id [%d]", dev_passwd_id);
+       __set_wps_mode_for_event(dev_passwd_id, &event);
        WDP_LOGD("Retrive device_go_intent [%d]", device_go_intent);
+       dev_data->device_go_intent = device_go_intent;
 
-       if (dev_passwd_id == WS_DEV_PASSWD_ID_PUSH_BUTTON)
-               event.wps_mode = WFD_OEM_WPS_MODE_PBC;
-       else if (dev_passwd_id == WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED)
-               event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
-       else if (dev_passwd_id == WS_DEV_PASSWD_ID_USER_SPECIFIED)
-               event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
-       else
-               event.wps_mode = WFD_OEM_WPS_MODE_NONE;
-       edata->device_go_intent = device_go_intent;
-
-       loc = strrchr(peer_path, '/');
-       if (loc != NULL)
-               __ws_mac_compact_to_normal(loc + 1, peer_dev);
-       __ws_txt_to_mac(peer_dev, event.dev_addr);
-       WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+       __extract_addr_from_path(peer_path, event.dev_addr);
 
        dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
                        __ws_peer_property, event.edata);
@@ -2791,7 +2762,7 @@ static void _ws_process_go_neg_request(GDBusConnection *connection,
        if (g_pd->callback->go_neg_req_cb)
                g_pd->callback->go_neg_req_cb(&event);
 
-       g_free(event.edata);
+       __destroy_dev_data(dev_data);
 
        __WDP_LOG_FUNC_EXIT__;
 }
@@ -4663,12 +4634,25 @@ int ws_get_scan_result(GList **peers, int *peer_count)
        __WDP_LOG_FUNC_EXIT__;
        return 0;
 }
+static wfd_oem_device_s *__create_oem_device(void)
+{
+       wfd_oem_device_s *device =
+                       (wfd_oem_device_s *) g_try_malloc0(sizeof(wfd_oem_device_s));
+       if (!device) {
+               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
+               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+               WDP_LOGF("Failed to allocate memory for event. [%s]",
+                          error_buf);
+       }
+
+       return device;
+}
 
 int ws_get_peer_info(unsigned char *peer_addr, wfd_oem_device_s **peer)
 {
        __WDP_LOG_FUNC_ENTER__;
        GDBusConnection *g_dbus = NULL;
-       wfd_oem_device_s *ws_dev = NULL;
+       wfd_oem_device_s *device = NULL;
        static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
        int res = 0;
 
@@ -4691,12 +4675,8 @@ int ws_get_peer_info(unsigned char *peer_addr, wfd_oem_device_s **peer)
                return -1;
        }
 
-       ws_dev = (wfd_oem_device_s *) g_try_malloc0(sizeof(wfd_oem_device_s));
-       if (!ws_dev) {
-               char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
-               strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
-               WDP_LOGF("Failed to allocate memory device. [%s]",
-                               error_buf);
+       device = __create_oem_device();
+       if (!device) {
                __WDP_LOG_FUNC_EXIT__;
                return -1;
        }
@@ -4707,17 +4687,23 @@ int ws_get_peer_info(unsigned char *peer_addr, wfd_oem_device_s **peer)
        WDP_LOGD("get peer path [%s]", peer_path);
 
        res = dbus_property_get_all(peer_path, g_dbus, SUPPLICANT_P2P_PEER,
-                               __ws_get_peer_property, ws_dev);
+                               __ws_get_peer_property, device);
 
        if (res < 0) {
                WDP_LOGE("Failed to send command to wpa_supplicant");
-               g_free(ws_dev);
+               if (device->vsie)
+                       g_free(device->vsie);
+               g_free(device);
                __WDP_LOG_FUNC_EXIT__;
                return -1;
        } else {
                WDP_LOGD("succeeded to get peer info");
-               *peer = ws_dev;
+               *peer = device;
        }
+
+       //Memory ownership of dev_data is transferred to method handler
+       //which uses this function.
+
        __WDP_LOG_FUNC_EXIT__;
        return 0;
 }

diff --git a/src/wifi-direct-event.c b/src/wifi-direct-event.c
index 2783b4e..53cb24c 100755 (executable)
--- a/src/wifi-direct-event.c
+++ b/src/wifi-direct-event.c
@@ -108,8 +108,6 @@ static int _wfd_event_update_peer(wfd_manager_s *manager, wfd_oem_dev_data_s *da
                if (peer->vsie)
                        g_free(peer->vsie);
                peer->vsie = g_strdup(data->vsie);
-               g_free(data->vsie);
-               data->vsie = NULL;
        }
        WDS_LOGD("Peer name: [%s], vsie: [%s]", peer->dev_name, peer->vsie);
 
@@ -122,6 +120,8 @@ static int _wfd_event_update_peer(wfd_manager_s *manager, wfd_oem_dev_data_s *da
 #endif
        WDS_LOGI("Update time [%s - %ld]", peer->dev_name, peer->time);
 
+       //We don't free data memory or memory in it.
+       //They're handled by plugin
        __WDS_LOG_FUNC_EXIT__;//LCOV_EXCL_LINE
        return 0;
 }

diff --git a/src/wifi-direct-manager.c b/src/wifi-direct-manager.c
index e23f972..497b536 100644 (file)
--- a/src/wifi-direct-manager.c
+++ b/src/wifi-direct-manager.c
@@ -1241,6 +1241,7 @@ int wfd_manager_get_peer_info(wfd_manager_s *manager, unsigned char *addr, wfd_d
 #endif
        WDS_LOGI("Current time [%ld]", time);
 //LCOV_EXCL_START
+       //wfd_manager_get_peer_info takes responsibility of the oem_dev' memory ownership.
        res = wfd_oem_get_peer_info(manager->oem_ops, addr, &oem_dev);
        if (res < 0 || !oem_dev) {
                WDS_LOGE("Failed to get peer information");//LCOV_EXCL_LINE
@@ -1253,7 +1254,9 @@ int wfd_manager_get_peer_info(wfd_manager_s *manager, unsigned char *addr, wfd_d
                if (!peer_dev) {
                        strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
                        WDS_LOGE("Failed to allocate memory for peer device. [%s]", error_buf);
-                       free(oem_dev);
+                       if (oem_dev->vsie)
+                               g_free(oem_dev->vsie);
+                       g_free(oem_dev);
                        return -1;
                }
                memcpy(peer_dev->dev_addr, addr, MACADDR_LEN);
@@ -1264,7 +1267,9 @@ int wfd_manager_get_peer_info(wfd_manager_s *manager, unsigned char *addr, wfd_d
        } else {
                if (oem_dev->age > 30 && peer_dev->state == WFD_PEER_STATE_DISCOVERED) {
                        WDS_LOGE("Too old age to update peer");//LCOV_EXCL_LINE
-                       free(oem_dev);
+                       if (oem_dev->vsie)
+                               g_free(oem_dev->vsie);
+                       g_free(oem_dev);
                        return -1;
                }
        }

diff --git a/src/wifi-direct-peer.c b/src/wifi-direct-peer.c
index 1f86067..0541792 100644 (file)
--- a/src/wifi-direct-peer.c
+++ b/src/wifi-direct-peer.c
@@ -162,6 +162,7 @@ int wfd_update_peer(void *data, wfd_device_s *peer)
        }
 
 //LCOV_EXCL_START
+       //wfd_update_peer takes responsibility of the oem_dev' memory ownership.
        res = wfd_oem_get_peer_info(manager->oem_ops, peer->dev_addr, &oem_dev);
        if (res < 0 || !oem_dev) {
                WDS_LOGE("Failed to get peer information");//LCOV_EXCL_LINE
@@ -170,6 +171,8 @@ int wfd_update_peer(void *data, wfd_device_s *peer)
 
        if (oem_dev->age > 30 && peer->state == WFD_PEER_STATE_DISCOVERED) {
                WDS_LOGE("Too old age to update peer");//LCOV_EXCL_LINE
+               if (oem_dev->vsie)
+                       g_free(oem_dev->vsie);
                g_free(oem_dev);
                return -1;
        }
@@ -189,6 +192,9 @@ int wfd_update_peer(void *data, wfd_device_s *peer)
        if (manager->is_wifi_display_supported)
                memcpy(&(peer->display), &(oem_dev->display), sizeof(wfd_display_s));
 
+       if (oem_dev->vsie)
+               g_free(oem_dev->vsie);
+
        g_free(oem_dev);
 
 #if !(__GNUC__ <= 4 && __GNUC_MINOR__ < 8)