* Add interface name #define.

  * Add new scan mode SCAN_MODE_NONE.
  * Add channel information to peer
  * Add initializing WPS mode and fix bugs
  * clean the group when group formation is failed
  * Sync some variable names with libwifi-direct

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

diff --git a/include/wifi-direct-client.h b/include/wifi-direct-client.h
index 3c7166d..7731a7f 100644 (file)
--- a/include/wifi-direct-client.h
+++ b/include/wifi-direct-client.h
@@ -32,7 +32,7 @@
 #define WFD_SERVER_SOCK_MODE (S_IRWXU | S_IRWXG | S_IRWXO)
 #define WFD_MAX_CLIENT 16
 
-#define SOCK_FD_MIN 3
+//#define SOCK_FD_MIN 3
 #define WFD_POLL_TIMEOUT 2000
 
 typedef struct {

diff --git a/include/wifi-direct-manager.h b/include/wifi-direct-manager.h
index dc13c40..b8d20d4 100644 (file)
--- a/include/wifi-direct-manager.h
+++ b/include/wifi-direct-manager.h
@@ -29,6 +29,8 @@
 #define __WIFI_DIRECT_MANAGER_H__
 
 #define DEFAULT_DEVICE_NAME "Tizen_Device"
+#define DEFAULT_IFNAME "p2p0"
+#define GROUP_IFNAME "p2p-wlan0-0"
 #define WFD_MAX_CLIENT 16
 #define WFD_MAX_STATION 8
 
@@ -65,6 +67,7 @@ typedef enum {
 } wfd_dev_role_e;
 
 typedef enum {
+       WFD_SCAN_MODE_NONE,
        WFD_SCAN_MODE_ACTIVE,
        WFD_SCAN_MODE_PASSIVE,
 } wfd_scan_mode_e;
@@ -74,6 +77,7 @@ typedef struct {
        unsigned char dev_addr[MACADDR_LEN];
        unsigned char intf_addr[MACADDR_LEN];
        unsigned char go_dev_addr[MACADDR_LEN];
+       int channel;
        int dev_role;
        int config_methods;
        int pri_dev_type;

diff --git a/include/wifi-direct-util.h b/include/wifi-direct-util.h
index d5dc4db..3dbc33d 100644 (file)
--- a/include/wifi-direct-util.h
+++ b/include/wifi-direct-util.h
@@ -39,6 +39,8 @@
 #define DHCP_DUMP_FILE "/tmp/dhcp-client-table"
 #define MAX_DHCP_DUMP_SIZE 64    // Single lease format: [99:66:dd:00:11:aa 192.168.16.20 00:00:60]
 
+#define SOCK_FD_MIN 0
+
 #ifdef USE_DLOG
 #include <dlog.h>
 

diff --git a/oem/wifi-direct-oem.h b/oem/wifi-direct-oem.h
index e26dcb7..39cf753 100644 (file)
--- a/oem/wifi-direct-oem.h
+++ b/oem/wifi-direct-oem.h
@@ -42,7 +42,7 @@ typedef enum {
        WFD_OEM_EVENT_DEACTIVATED,
        WFD_OEM_EVENT_PEER_FOUND,
        WFD_OEM_EVENT_PEER_DISAPPEARED,
-       WFD_OEM_EVENT_DISCOVER_FINISHED,
+       WFD_OEM_EVENT_DISCOVERY_FINISHED,
 
        WFD_OEM_EVENT_PROV_DISC_REQ,    // 5
        WFD_OEM_EVENT_PROV_DISC_DISPLAY,
@@ -78,10 +78,11 @@ typedef enum {
 } wfd_oem_event_e;
 
 typedef struct {
-       char dev_name[OEM_DEV_NAME_LEN];
+       char dev_name[OEM_DEV_NAME_LEN+1];
        unsigned char dev_addr[OEM_MACADDR_LEN];
        unsigned char intf_addr[OEM_MACADDR_LEN];
        unsigned char go_dev_addr[OEM_MACADDR_LEN];
+       int channel;
        int dev_role;
        int config_methods;
        int pri_dev_type;
@@ -151,7 +152,7 @@ typedef enum {
 
 typedef enum {
        WFD_OEM_SCAN_MODE_ACTIVE,
-       WFD_OEM_SCAN_MODE_PASSICE,
+       WFD_OEM_SCAN_MODE_PASSIVE,
 } wfd_oem_scan_mode_e;
 
 typedef enum {

diff --git a/packaging/wifi-direct-manager.changes b/packaging/wifi-direct-manager.changes
index 153b808..7824bd7 100644 (file)
--- a/packaging/wifi-direct-manager.changes
+++ b/packaging/wifi-direct-manager.changes
@@ -1,3 +1,11 @@
+Mon, 14 Oct 2013 Jiung Yu <jiung.yu@samaung.com> (1.0.1)
+  * Add interface name #define.
+  * Add new scan mode SCAN_MODE_NONE.
+  * Add channel information to peer
+  * Add initializing WPS mode and fix bugs
+  * clean the group when group formation is failed
+  * Sync some variable names with libwifi-direct
+
 Mon, 14 Oct 2013 Gibyoung Kim <lastkgb.kim@samaung.com> (1.0.0)
   * Premitive type of some variables were changed.
   * Some local device functions were added.

diff --git a/packaging/wifi-direct-manager.spec b/packaging/wifi-direct-manager.spec
index e979fed..40a989a 100644 (file)
--- a/packaging/wifi-direct-manager.spec
+++ b/packaging/wifi-direct-manager.spec
@@ -1,6 +1,6 @@
 Name:       wifi-direct-manager
 Summary:    Wi-Fi Direct manger
-Version:    1.0.0
+Version:    1.0.1
 Release:    1
 Group:      Network & Connectivity/Wireless
 License:    Apache-2.0
@@ -90,7 +90,7 @@ vconftool set -t string memory/private/wifi_direct_manager/dhcpc_server_ip 0.0.0
 /usr/share/license/%{name}
 
 %files -n wifi-direct-plugin-wpasupplicant
-%manifest %{name}.manifest
+%manifest wifi-direct-plugin-wpasupplicant.manifest
 %defattr(-,root,root,-)
 %{_libdir}/wifi-direct-plugin-wpasupplicant.so
 /usr/share/license/wifi-direct-plugin-wpasupplicant

diff --git a/plugin/wpasupplicant/wfd-plugin-wpasupplicant.c b/plugin/wpasupplicant/wfd-plugin-wpasupplicant.c
index 99bfbf9..9e44c1c 100644 (file)
--- a/plugin/wpasupplicant/wfd-plugin-wpasupplicant.c
+++ b/plugin/wpasupplicant/wfd-plugin-wpasupplicant.c
@@ -198,7 +198,6 @@ static gboolean ws_event_handler(GIOChannel *source,
                                                           GIOCondition condition,
                                                           gpointer data);
 
-
 int wfd_plugin_load(wfd_oem_ops_s **ops)
 {
        if (!ops) {
@@ -224,6 +223,7 @@ static int _ws_txt_to_devtype(char *txt, int *pri, int *sec)
        }
 
        *pri = (int) strtoul(txt, &txt, 0);
+       txt = strrchr(txt, '-');
        *sec = (int) strtoul(txt+1, &txt, 16);
 
        return 0;
@@ -268,6 +268,23 @@ static char *_ws_wps_to_txt(int wps_mode)
        }
 }
 
+static int _ws_freq_to_channel(int freq)
+{
+       if (freq < 2412 || freq > 5825) {
+               WDP_LOGE("Invalid parameter");
+               return -1;
+       }
+
+       if (freq >= 5180)
+               return 36 + (freq - 5180)/5;
+       else if (freq <= 2472)
+               return 1 + (freq - 2412)/5;
+       else if (freq == 2484)
+               return 14;
+       else
+               return -1;
+}
+
 static int _ws_check_socket(int sock)
 {
        struct pollfd p_fd;
@@ -334,7 +351,7 @@ static int _ws_read_sock(int sock, char *data, int data_len)
                                return -1;
                        }
                        WDP_LOGD("===== Read Data =====\n%s", data);
-
+                       data[data_len-1] = '\0';
                        __WDP_LOG_FUNC_EXIT__;
                        return rbytes;
                } else if (p_fd.revents & POLLERR) {
@@ -578,14 +595,14 @@ static int _connect_to_supplicant(char *ifname, ws_sock_data_s **sock_data)
 
        for(i = 0; i < WS_CONN_RETRY_COUNT; i++) {
                ctrl_sock = _create_ctrl_intf(ctrl_path, suppl_path);
-               if (ctrl_sock < 0) {
+               if (ctrl_sock < SOCK_FD_MIN) {
                        WDP_LOGE("Failed to create control interface socket for %s", ifname);
                        continue;
                }
                WDP_LOGD("Succeeded to create control interface socket[%d] for %s", ctrl_sock, ifname);
 
                mon_sock = _create_ctrl_intf(mon_path, suppl_path);
-               if (mon_sock < 0) {
+               if (mon_sock < SOCK_FD_MIN) {
                        WDP_LOGE("Failed to create monitor interface socket for %s", ifname);
                        close(ctrl_sock);
                        ctrl_sock = -1;
@@ -596,6 +613,10 @@ static int _connect_to_supplicant(char *ifname, ws_sock_data_s **sock_data)
                res = _attach_mon_intf(mon_sock);
                if (res < 0) {
                        WDP_LOGE("Failed to attach monitor interface for event");
+                       close(ctrl_sock);
+                       ctrl_sock = -1;
+                       close(mon_sock);
+                       mon_sock = -1;
                        continue;
                }
                WDP_LOGD("Succeeded to attach monitor interface for event");
@@ -630,6 +651,28 @@ static int _connect_to_supplicant(char *ifname, ws_sock_data_s **sock_data)
        return 0;
 }
 
+static gboolean _remove_event_source(gpointer data)
+{
+       __WDP_LOG_FUNC_ENTER__;
+       int source_id = (int) data;
+       int res = 0;
+
+       if (source_id < 0) {
+               WDP_LOGE("Invalid source ID [%d]", source_id);
+               return FALSE;
+       }
+
+       res = g_source_remove(source_id);
+       if (!res) {
+               WDP_LOGE("Failed to remove GSource");
+               return FALSE;
+       }
+       WDP_LOGD("Succeeded to remove GSource");
+
+       __WDP_LOG_FUNC_EXIT__;
+       return FALSE;
+}
+
 static int _disconnect_from_supplicant(char *ifname, ws_sock_data_s *sock_data)
 {
        __WDP_LOG_FUNC_ENTER__;
@@ -652,24 +695,27 @@ static int _disconnect_from_supplicant(char *ifname, ws_sock_data_s *sock_data)
        } else {
                if (!strncmp(reply, "FAIL", 4)) {
                        WDP_LOGE( "Failed to detach monitor sock [%d]", sock_data->mon_sock);
+                       // TODO: I think there is no need to exit
+                       __WDP_LOG_FUNC_EXIT__;
+                       return -1;
                }
                WDP_LOGD("Succeeded to detach monitor sock for %s", ifname ? ifname : "NULL");
        }
 
        if (sock_data->gsource > 0)
-               g_source_remove(sock_data->gsource);
+               g_idle_add(_remove_event_source, (gpointer) sock_data->gsource);
        sock_data->gsource = 0;
 
        // close control interface
        snprintf(ctrl_path, sizeof(ctrl_path), "/tmp/%s_control", ifname);
        snprintf(mon_path, sizeof(mon_path), "/tmp/%s_monitor", ifname);
 
-       if (sock_data->ctrl_sock >= 0)
+       if (sock_data->ctrl_sock >= SOCK_FD_MIN)
                close(sock_data->ctrl_sock);
        sock_data->ctrl_sock = -1;
        unlink(ctrl_path);
 
-       if (sock_data->mon_sock >= 0)
+       if (sock_data->mon_sock >= SOCK_FD_MIN)
                close(sock_data->mon_sock);
        sock_data->mon_sock = -1;
        unlink(mon_path);
@@ -812,6 +858,11 @@ static int _parsing_peer_info(char *msg, wfd_oem_device_s *peer)
                case WS_PEER_INFO_AGE:
                        break;
                case WS_PEER_INFO_LISTEN_FREQ:
+                       {
+                               int freq = 0;
+                               freq = (int) strtoul(infos[i].string, NULL, 10);
+                               peer->channel = _ws_freq_to_channel(freq);
+                       }
                        break;
                case WS_PEER_INFO_LEVEL:
                        break;
@@ -820,9 +871,15 @@ static int _parsing_peer_info(char *msg, wfd_oem_device_s *peer)
                case WS_PEER_INFO_INTERFACE_ADDR:
                        break;
                case WS_PEER_INFO_MEMBER_IN_GO_DEV:
-                       res = _ws_txt_to_mac(infos[i].string, peer->go_dev_addr);
-                       if (res < 0)
-                               memset(peer->go_dev_addr, 0x00, OEM_MACADDR_LEN);
+                       {
+                               res = _ws_txt_to_mac(infos[i].string, peer->go_dev_addr);
+                               if (res < 0)
+                                       memset(peer->go_dev_addr, 0x00, OEM_MACADDR_LEN);
+
+                               unsigned char null_mac[OEM_MACADDR_LEN] = {0, 0, 0, 0, 0, 0};
+                               if (memcmp(peer->go_dev_addr, null_mac, OEM_MACADDR_LEN))
+                                       peer->dev_role = WFD_OEM_DEV_ROLE_GC;
+                       }
                        break;
                case WS_PEER_INFO_MEMBER_IN_GO_IFACE:
                        break;
@@ -1316,6 +1373,7 @@ static int _parsing_event_info(char *ifname, char *msg, wfd_oem_event_s *data)
 
                }
                break;
+       case WS_EVENT_PROV_DISC_FAILURE:
        case WS_EVENT_GO_NEG_FAILURE:
        case WS_EVENT_WPS_FAIL:         // M_id(msg), error(config_error)
                break;
@@ -1526,23 +1584,19 @@ static gboolean ws_event_handler(GIOChannel *source,
                event_id = WFD_OEM_EVENT_PEER_DISAPPEARED;
                break;
        case WS_EVENT_FIND_STOPED:
-               event_id = WFD_OEM_EVENT_DISCOVER_FINISHED;
+               event_id = WFD_OEM_EVENT_DISCOVERY_FINISHED;
                break;
        case WS_EVENT_PROV_DISC_PBC_REQ:
                event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
-               ws_stop_scan();
                break;
        case WS_EVENT_PROV_DISC_PBC_RESP:
                event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
-               ws_stop_scan();
                break;
        case WS_EVENT_PROV_DISC_SHOW_PIN:
                event_id = WFD_OEM_EVENT_PROV_DISC_DISPLAY;
-               ws_stop_scan();
                break;
        case WS_EVENT_PROV_DISC_ENTER_PIN:
                event_id = WFD_OEM_EVENT_PROV_DISC_KEYPAD;
-               ws_stop_scan();
                break;
        case WS_EVENT_GO_NEG_REQUEST:
                event_id = WFD_OEM_EVENT_GO_NEG_REQ;
@@ -1566,7 +1620,12 @@ static gboolean ws_event_handler(GIOChannel *source,
                // TODO: connect to supplicant via group interface
                break;
        case WS_EVENT_CONNECTED:
-               event_id = WFD_OEM_EVENT_CONNECTED;
+               {
+                       unsigned char null_mac[OEM_MACADDR_LEN] = {0, 0, 0, 0, 0, 0};
+                       if (!memcmp(event->intf_addr, null_mac, OEM_MACADDR_LEN))
+                               goto done;
+                       event_id = WFD_OEM_EVENT_CONNECTED;
+               }
                break;
        case WS_EVENT_STA_CONNECTED:
                event_id = WFD_OEM_EVENT_STA_CONNECTED;
@@ -1583,8 +1642,10 @@ static gboolean ws_event_handler(GIOChannel *source,
                event_id = WFD_OEM_EVENT_GROUP_DESTROYED;
                if (g_pd->group) {
                        res = _disconnect_from_supplicant(GROUP_IFACE_NAME, g_pd->group);
-                       if (res < 0)
+                       if (res < 0) {
                                WDP_LOGE("Failed to disconnect from group interface of supplicant");
+                               goto done;
+                       }
                        g_pd->group = NULL;
                }
                break;
@@ -2070,7 +2131,6 @@ int ws_prov_disc_req(unsigned char *peer_addr, wfd_oem_wps_mode_e wps_mode, int
                return -1;
        }
 
-       ws_stop_scan();
 
        snprintf(cmd, sizeof(cmd), WS_CMD_P2P_PROV_DISC MACSTR "%s",
                                                        MAC2STR(peer_addr), _ws_wps_to_txt(wps_mode));
@@ -2215,7 +2275,6 @@ int ws_cancel_connection(unsigned char *peer_addr)
        __WDP_LOG_FUNC_ENTER__;
 
        _ws_cancel();
-       _ws_flush();
 
        __WDP_LOG_FUNC_EXIT__;
        return 0;
@@ -2325,6 +2384,8 @@ int ws_destroy_group(const char *ifname)
        }
        WDP_LOGD("Succeeded to remove group");
 
+       _ws_flush();
+
        __WDP_LOG_FUNC_EXIT__;
        return 0;
 }

diff --git a/src/wifi-direct-client.c b/src/wifi-direct-client.c
index 8d09367..7ab07c5 100644 (file)
--- a/src/wifi-direct-client.c
+++ b/src/wifi-direct-client.c
@@ -37,6 +37,7 @@
 #include <errno.h>
 
 #include <glib.h>
+#include <vconf.h>
 
 #include <wifi-direct.h>
 #include <wifi-direct-internal.h>
@@ -127,8 +128,8 @@ char *wfd_server_print_cmd(wifi_direct_cmd_e cmd)
                return "WIFI_DIRECT_CMD_SET_REQ_WPS_MODE";
        case WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO:
                return "WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO";
-       case WIFI_DIRECT_CMD_CANCEL_GROUP:
-               return "WIFI_DIRECT_CMD_CANCEL_GROUP";
+       case WIFI_DIRECT_CMD_DESTROY_GROUP:
+               return "WIFI_DIRECT_CMD_DESTROY_GROUP";
 
        case WIFI_DIRECT_CMD_DISCONNECT:
                return "WIFI_DIRECT_CMD_DISCONNECT";
@@ -153,8 +154,8 @@ char *wfd_server_print_cmd(wifi_direct_cmd_e cmd)
                return "WIFI_DIRECT_CMD_IS_DISCOVERABLE";
        case WIFI_DIRECT_CMD_IS_LISTENING_ONLY:
                return "WIFI_DIRECT_CMD_IS_LISTENING_ONLY";
-       case WIFI_DIRECT_CMD_GET_OWN_GROUP_CHANNEL:
-               return "WIFI_DIRECT_CMD_GET_OWN_GROUP_CHANNEL";
+       case WIFI_DIRECT_CMD_GET_OPERATING_CHANNEL:
+               return "WIFI_DIRECT_CMD_GET_OPERATING_CHANNEL";
        case WIFI_DIRECT_CMD_ACTIVATE_PERSISTENT_GROUP:
                return "WIFI_DIRECT_CMD_ACTIVATE_PERSISTENT_GROUP";
        case WIFI_DIRECT_CMD_DEACTIVATE_PERSISTENT_GROUP:
@@ -184,7 +185,7 @@ static wfd_client_s *_wfd_client_find_by_id(GList *clients, int client_id)
        __WDS_LOG_FUNC_ENTER__;
        wfd_client_s *client = NULL;
        GList *temp = NULL;
-       
+
        if (!clients || client_id < 0) {
                WDS_LOGE("Invalid parameter(client_id:%d)", client_id);
                return NULL;
@@ -339,6 +340,7 @@ int wfd_client_send_event(wfd_manager_s *manager, wifi_direct_client_noti_s *not
 
        if (!manager || !noti) {
                WDS_LOGE("Invalid parameter");
+               __WDS_LOG_FUNC_EXIT__;
                return -1;
        }
 
@@ -445,7 +447,29 @@ send_response:
        }
 done:
        __WDS_LOG_FUNC_EXIT__;
-       return 0; 
+       return 0;
+}
+
+static gboolean _wfd_remove_event_source(gpointer data)
+{
+       __WDS_LOG_FUNC_ENTER__;
+       int source_id = (int) data;
+       int res = 0;
+
+       if (source_id < 0) {
+               WDS_LOGE("Invalid source ID [%d]", source_id);
+               return FALSE;
+       }
+
+       res = g_source_remove(source_id);
+       if (!res) {
+               WDS_LOGE("Failed to remove GSource");
+               return FALSE;
+       }
+       WDS_LOGD("Succeeded to remove GSource");
+
+       __WDS_LOG_FUNC_EXIT__;
+       return FALSE;
 }
 
 static int _wfd_deregister_client(void *data, int client_id)
@@ -469,7 +493,7 @@ static int _wfd_deregister_client(void *data, int client_id)
        if (client->ssock >= SOCK_FD_MIN)
                close(client->ssock);
        client->ssock = -1;
-       g_source_remove(client->gsource_id);
+       g_idle_add((GSourceFunc) _wfd_remove_event_source, (gpointer) client->gsource_id);
        client->gsource_id = 0;
 
        if (client)
@@ -497,8 +521,10 @@ static int _wfd_create_server_socket(wfd_manager_s *manager)
 
        errno = 0;
        sock = socket(AF_UNIX, SOCK_STREAM, 0);
-       if (sock < 0) {
+       if (sock < SOCK_FD_MIN) {
                WDS_LOGE("Failed to create server socket. [%s]", strerror(errno));
+               if (sock >= 0)
+                       close(sock);
                __WDS_LOG_FUNC_EXIT__;
                return -1;
        }
@@ -597,7 +623,7 @@ int wfd_client_handler_init(wfd_manager_s *manager)
        if (res < 0) {
                WDS_LOGE("Failed to create server socket");
                return -1;
-       }       
+       }
 
        GIOChannel *gio = g_io_channel_unix_new(manager->serv_sock);
        manager->client_handle = g_io_add_watch(gio, G_IO_IN,
@@ -618,6 +644,8 @@ int wfd_client_handler_deinit(wfd_manager_s *manager)
        if (manager->serv_sock >= SOCK_FD_MIN)
                close(manager->serv_sock);
        manager->serv_sock = -1;
+       g_source_remove(manager->client_handle);
+       manager->client_handle = 0;
 
        temp = g_list_first(manager->clients);
        while(temp) {
@@ -755,10 +783,10 @@ static gboolean wfd_client_process_request(GIOChannel *source,
                wfd_state_set(manager, WIFI_DIRECT_STATE_DEACTIVATED);
                wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_DEACTIVATED);
 
+               wfd_destroy_group(manager, GROUP_IFNAME);
+               wfd_destroy_session(manager);
                wfd_peer_clear_all(manager);
                WDS_LOGD("peer count[%d], peers[%d]", manager->peer_count, manager->peers);
-               wfd_destroy_group(manager, "all");
-               wfd_destroy_session(manager);
                wfd_local_reset_data(manager);
                goto done;
                break;
@@ -777,7 +805,10 @@ static gboolean wfd_client_process_request(GIOChannel *source,
 
                        wfd_oem_scan_param_s param;
                        memset(&param, 0x0, sizeof(wfd_oem_scan_param_s));
-                       param.scan_mode = req.data.int1;        // listen_only
+                       if (req.data.int1)      // listen_only
+                               param.scan_mode = WFD_OEM_SCAN_MODE_PASSIVE;
+                       else
+                               param.scan_mode = WFD_OEM_SCAN_MODE_ACTIVE;
                        param.scan_time = req.data.int2;        // timeout
                        if (manager->local->dev_role == WFD_DEV_ROLE_GO)
                                param.scan_type = WFD_OEM_SCAN_TYPE_SOCIAL;
@@ -805,8 +836,7 @@ static gboolean wfd_client_process_request(GIOChannel *source,
                break;
        case WIFI_DIRECT_CMD_CANCEL_DISCOVERY:
                if (manager->state != WIFI_DIRECT_STATE_ACTIVATED &&
-                               manager->state != WIFI_DIRECT_STATE_DISCOVERING &&
-                               manager->state != WIFI_DIRECT_STATE_GROUP_OWNER) {
+                               manager->state != WIFI_DIRECT_STATE_DISCOVERING) {
                        rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
                        break;
                }
@@ -956,13 +986,20 @@ static gboolean wfd_client_process_request(GIOChannel *source,
                break;
        case WIFI_DIRECT_CMD_REJECT_CONNECTION:
                {
-                       wfd_session_s *session = manager->session;
+                       wfd_session_s *session = (wfd_session_s*) manager->session;
+
                        if (!session || manager->state != WIFI_DIRECT_STATE_CONNECTING) {
                                WDS_LOGE("It's not permitted with this state [%d]", manager->state);
                                rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
                                break;
                        }
 
+                       if (session->direction != SESSION_DIRECTION_INCOMING) {
+                               WDS_LOGE("Only incomming session can be rejected");
+                               rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
+                               break;
+                       }
+
                        res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
                        if (res < 0) {
                                WDS_LOGE("Failed to send response to client");
@@ -1119,8 +1156,6 @@ static gboolean wfd_client_process_request(GIOChannel *source,
                        rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
                }
                break;
-       case WIFI_DIRECT_CMD_SEND_PROVISION_DISCOVERY_REQ:
-               break;
        case WIFI_DIRECT_CMD_CREATE_GROUP:      // group
                {
                        wfd_group_s *group = manager->group;
@@ -1134,20 +1169,24 @@ static gboolean wfd_client_process_request(GIOChannel *source,
                        if (!group) {
                                WDS_LOGE("Failed to create pending group");
                                rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+                               break;
                        }
                        group->flags |= WFD_GROUP_FLAG_AUTONOMOUS;
+                       manager->group = group;
+                       WDS_LOGD("Succeeded to create pending group");
 
                        res = wfd_oem_create_group(manager->oem_ops, 0, 0);
                        if (res < 0) {
                                WDS_LOGE("Failed to create group");
+                               wfd_destroy_group(manager, GROUP_IFNAME);
                                rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
                        }
                }
                break;
-       case WIFI_DIRECT_CMD_CANCEL_GROUP:
+       case WIFI_DIRECT_CMD_DESTROY_GROUP:
                {
                        wfd_group_s *group = manager->group;
-                       if (!group || manager->state < WIFI_DIRECT_STATE_CONNECTED) {
+                       if (!group && manager->state < WIFI_DIRECT_STATE_CONNECTED) {
                                WDS_LOGE("Group not exist");
                                rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
                                break;
@@ -1159,8 +1198,17 @@ static gboolean wfd_client_process_request(GIOChannel *source,
                                rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
                                break;
                        }
+
+                       res = wfd_destroy_group(manager, group->ifname);
+                       if (res < 0)
+                               WDS_LOGE("Failed to destroy group");
+
                        wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
                        wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
+
+                       noti = (wifi_direct_client_noti_s*) calloc(1, sizeof(wifi_direct_client_noti_s));
+                       noti->event = WIFI_DIRECT_CLI_EVENT_GROUP_DESTROY_RSP;
+                       noti->error = WIFI_DIRECT_ERROR_NONE;
                }
                break;
        case WIFI_DIRECT_CMD_IS_GROUPOWNER:
@@ -1191,7 +1239,7 @@ static gboolean wfd_client_process_request(GIOChannel *source,
                        rsp.param1 = group->flags & WFD_GROUP_FLAG_PERSISTENT;
                }
                break;
-       case WIFI_DIRECT_CMD_GET_OWN_GROUP_CHANNEL:
+       case WIFI_DIRECT_CMD_GET_OPERATING_CHANNEL:
                {
                        wfd_group_s *group = manager->group;
                        if (!group) {

diff --git a/src/wifi-direct-event.c b/src/wifi-direct-event.c
index 8969ad6..e6891a9 100644 (file)
--- a/src/wifi-direct-event.c
+++ b/src/wifi-direct-event.c
@@ -222,6 +222,7 @@ int wfd_process_event(void *user_data, void *data)
 
        switch (event->event_id) {
        case WFD_OEM_EVENT_DEACTIVATED:
+               manager->req_wps_mode = WFD_WPS_MODE_PBC;
                break;
        case WFD_OEM_EVENT_PEER_FOUND:
        {
@@ -275,7 +276,7 @@ int wfd_process_event(void *user_data, void *data)
                wfd_event_notify_clients(manager, &noti);
        }
        break;
-       case WFD_OEM_EVENT_DISCOVER_FINISHED:
+       case WFD_OEM_EVENT_DISCOVERY_FINISHED:
        {
                if (manager->state != WIFI_DIRECT_STATE_DISCOVERING &&
                                manager->state != WIFI_DIRECT_STATE_ACTIVATED) {
@@ -290,6 +291,7 @@ int wfd_process_event(void *user_data, void *data)
                        wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
                        wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
                }
+               manager->scan_mode = WFD_SCAN_MODE_NONE;
 
                wifi_direct_client_noti_s noti;
                memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
@@ -302,6 +304,8 @@ int wfd_process_event(void *user_data, void *data)
        {
                wfd_device_s *peer = NULL;
                wfd_session_s *session = NULL;
+               wfd_oem_invite_data_s *edata = (wfd_oem_invite_data_s*) event->edata;
+
                peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
                if (!peer) {
                        WDS_LOGD("Invitation from unknown peer. Add new peer");
@@ -311,12 +315,11 @@ int wfd_process_event(void *user_data, void *data)
                                return -1;
                        }
                }
-               wfd_oem_invite_data_s *edata = (wfd_oem_dev_data_s*) event->edata;
                peer->dev_role = WFD_DEV_ROLE_GO;
                memcpy(peer->intf_addr, edata->bssid, MACADDR_LEN);
 
                session = wfd_create_session(manager, event->dev_addr,
-                                               manager->local->wps_mode, SESSION_DIRECTION_INCOMING);
+                                               manager->req_wps_mode, SESSION_DIRECTION_INCOMING);
                if (!session) {
                        WDS_LOGE("Failed to create session");
                        return -1;
@@ -477,6 +480,7 @@ int wfd_process_event(void *user_data, void *data)
                group->pass[PASSPHRASE_LEN] = '\0';
                group->freq = edata->freq;
                manager->group = group;
+               manager->local->dev_role = event->dev_role;
 
                wifi_direct_client_noti_s noti;
                memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
@@ -544,6 +548,7 @@ int wfd_process_event(void *user_data, void *data)
                wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
        }
        break;
+       case WFD_OEM_EVENT_PROV_DISC_FAIL:
        case WFD_OEM_EVENT_GO_NEG_FAIL:
        case WFD_OEM_EVENT_WPS_FAIL:
        case WFD_OEM_EVENT_KEY_NEG_FAIL:
@@ -575,7 +580,9 @@ int wfd_process_event(void *user_data, void *data)
                param.scan_mode = WFD_SCAN_MODE_ACTIVE;
                param.scan_time = 2;
                param.scan_type = WFD_OEM_SCAN_TYPE_SOCIAL;
-               wfd_oem_start_scan(manager->oem_ops, &param);   }
+               wfd_oem_start_scan(manager->oem_ops, &param);
+               manager->scan_mode = WFD_SCAN_MODE_ACTIVE;
+       }
        break;
        default:
                WDS_LOGE("Unknown event [event ID: %d]", event->event_id);

diff --git a/src/wifi-direct-group.c b/src/wifi-direct-group.c
index aa81d58..ee16084 100644 (file)
--- a/src/wifi-direct-group.c
+++ b/src/wifi-direct-group.c
@@ -47,12 +47,19 @@ wfd_group_s *wfd_create_group(void *data, char *ifname, int role, unsigned char
        wfd_group_s *group = NULL;
        wfd_manager_s *manager = (wfd_manager_s*) data;
 
-       if (!data || !ifname || !go_dev_addr) {
+       if (!manager || !ifname || !go_dev_addr) {
                WDS_LOGE("Invalid parameter");
                __WDS_LOG_FUNC_EXIT__;
                return NULL;
        }
 
+       group = manager->group;
+       if (group) {
+               WDS_LOGE("Group already exist");
+               __WDS_LOG_FUNC_EXIT__;
+               return NULL;
+       }
+
        errno = 0;
        group = (wfd_group_s*) calloc(1, sizeof(wfd_group_s));
        if (!group) {
@@ -67,13 +74,9 @@ wfd_group_s *wfd_create_group(void *data, char *ifname, int role, unsigned char
        memcpy(group->go_dev_addr, go_dev_addr, MACADDR_LEN);
        group->pending = 0;
 
-       if (!manager->session)
-               group->flags |= WFD_GROUP_FLAG_AUTONOMOUS;
        wfd_util_dhcps_start();
        WDS_LOGD("Role is Group Owner. DHCP Server started");
 
-       manager->local->dev_role = role;        // temporary
- 
        __WDS_LOG_FUNC_EXIT__;
        return group;
 }
@@ -85,7 +88,7 @@ wfd_group_s *wfd_create_pending_group(void *data, unsigned char * bssid)
        wfd_group_s *group = NULL;
        wfd_manager_s *manager = (wfd_manager_s*) data;
 
-       if (!data || !bssid) {
+       if (!manager || !bssid) {
                WDS_LOGE("Invalid parameter");
                __WDS_LOG_FUNC_EXIT__;
                return NULL;

diff --git a/src/wifi-direct-manager.c b/src/wifi-direct-manager.c
index 7b7f6b6..2b2ddfd 100644 (file)
--- a/src/wifi-direct-manager.c
+++ b/src/wifi-direct-manager.c
@@ -97,7 +97,7 @@ static int _wfd_local_init_device(wfd_manager_s *manager)
                WDS_LOGE("Failed to allocate memory for local device [%s]", strerror(errno));
                return -1;
        }
-       
+
        res = wfd_util_get_phone_name(local->dev_name);
        if (res < 0) {
                WDS_LOGE("Failed to get phone name of local device. Use default device name");
@@ -195,11 +195,12 @@ int wfd_local_set_dev_name(char *dev_name)
                wfd_oem_set_dev_name(g_manager->oem_ops, dev_name);
 
                wfd_oem_scan_param_s param;
-               param.scan_mode = WFD_SCAN_MODE_ACTIVE;
+               param.scan_mode = WFD_OEM_SCAN_MODE_ACTIVE;
                param.scan_type = WFD_OEM_SCAN_TYPE_FULL;
                param.scan_time = 5;
                param.refresh = TRUE;
                wfd_oem_start_scan(g_manager->oem_ops, &param);
+               g_manager->scan_mode = WFD_SCAN_MODE_ACTIVE;
                WDS_LOGD("Device name changed. Active scan started");
        }
 
@@ -539,6 +540,8 @@ int wfd_manager_deactivate(wfd_manager_s *manager)
        wfd_state_set(manager, WIFI_DIRECT_STATE_DEACTIVATED);
        wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_DEACTIVATED);
 
+       manager->req_wps_mode = WFD_WPS_MODE_PBC;
+
        __WDS_LOG_FUNC_EXIT__;
        return WIFI_DIRECT_ERROR_NONE;
 }
@@ -562,7 +565,7 @@ int wfd_manager_connect(wfd_manager_s *manager, unsigned char *peer_addr)
 
        if (!session) {
                session = wfd_create_session(manager, peer_addr,
-                                       manager->local->wps_mode, SESSION_DIRECTION_OUTGOING);
+                                       manager->req_wps_mode, SESSION_DIRECTION_OUTGOING);
                if (!session) {
                        WDS_LOGE("Failed to create new session");
                        return WIFI_DIRECT_ERROR_OPERATION_FAILED;
@@ -583,7 +586,6 @@ int wfd_manager_connect(wfd_manager_s *manager, unsigned char *peer_addr)
        }
        if (res < 0) {
                WDS_LOGE("Failed to start session");
-
                wfd_destroy_session(manager);
                return WIFI_DIRECT_ERROR_OPERATION_FAILED;
        }
@@ -687,7 +689,7 @@ int wfd_manager_get_peers(wfd_manager_s *manager, wfd_discovery_entry_s **peers_
                        strncpy(peers[count].device_name, peer->dev_name, DEV_NAME_LEN);
                        peers[count].device_name[DEV_NAME_LEN] = '\0';
                        memcpy(peers[count].mac_address, peer->dev_addr, MACADDR_LEN);
-                       memcpy(peers[count].intf_mac_address, peer->intf_addr, MACADDR_LEN);
+                       memcpy(peers[count].intf_address, peer->intf_addr, MACADDR_LEN);
                        peers[count].channel = 1;
                        peers[count].services = 0;
                        peers[count].is_group_owner = peer->dev_role == WFD_DEV_ROLE_GO;
@@ -705,6 +707,7 @@ int wfd_manager_get_peers(wfd_manager_s *manager, wfd_discovery_entry_s **peers_
                peer = NULL;
        }
        WDS_LOGD("%d peers converted", count);
+       WDS_LOGD("Final peer count is %d", manager->peer_count);
 
        *peers_data = peers;
 
@@ -753,10 +756,11 @@ int wfd_manager_get_connected_peers(wfd_manager_s *manager, wfd_connected_peer_i
                        strncpy(peers[count].device_name, peer->dev_name, DEV_NAME_LEN);
                        peers[count].device_name[DEV_NAME_LEN] = '\0';
                        memcpy(peers[count].mac_address, peer->dev_addr, MACADDR_LEN);
-                       memcpy(peers[count].intf_mac_address, peer->intf_addr, MACADDR_LEN);
+                       memcpy(peers[count].intf_address, peer->intf_addr, MACADDR_LEN);
                        memcpy(peers[count].ip_address, peer->ip_addr, IPADDR_LEN);
                        peers[count].category = peer->pri_dev_type;
-                       peers[count].channel = 1;
+                       peers[count].subcategory = peer->sec_dev_type;
+                       peers[count].channel = peer->channel;
                        peers[count].is_p2p = 1;
                        peers[count].services = 0;
                        WDS_LOGD("%dth member converted[%s]", count, peers[count].device_name);
@@ -856,7 +860,7 @@ static wfd_manager_s *wfd_manager_init()
        }
        WDS_LOGD("Succeeded to initialize local device");
 
-       manager->exit_timer = g_timeout_add(120000, 
+       manager->exit_timer = g_timeout_add(120000,
                                                (GSourceFunc) _wfd_exit_timeout_cb, manager);
        WDS_LOGD("Exit timer started");
 
@@ -892,7 +896,7 @@ static void *wfd_plugin_init(wfd_manager_s *manager)
        __WDS_LOG_FUNC_ENTER__;
        void *handle;
        struct utsname kernel_info;
-       int res;    
+       int res;
 
        if (!manager) {
                WDS_LOGE("Invalid parameter");

diff --git a/src/wifi-direct-session.c b/src/wifi-direct-session.c
index b22d37b..e939e3f 100644 (file)
--- a/src/wifi-direct-session.c
+++ b/src/wifi-direct-session.c
@@ -100,9 +100,9 @@ static int _session_timer(wfd_session_s *session, int start)
 wfd_session_s *wfd_create_session(void *data, unsigned char *peer_addr, int wps_mode, int direction)
 {
        __WDS_LOG_FUNC_ENTER__;
+       wfd_manager_s *manager = (wfd_manager_s*) data;
        wfd_session_s *session = NULL;
        wfd_device_s *peer = NULL;
-       wfd_manager_s *manager = (wfd_manager_s*) data;
 
        if (!data || !peer_addr) {
                WDS_LOGE("Invalid parameter");
@@ -110,6 +110,11 @@ wfd_session_s *wfd_create_session(void *data, unsigned char *peer_addr, int wps_
                return NULL;
        }
 
+       if (manager->session) {
+               WDS_LOGE("Session already exist");
+               return NULL;
+       }
+
        session = (wfd_session_s*) calloc(1, sizeof(wfd_session_s));
        if (!session) {
                WDS_LOGE("Failed to allocate memory for session");
@@ -125,18 +130,20 @@ wfd_session_s *wfd_create_session(void *data, unsigned char *peer_addr, int wps_
                return NULL;
        }
        session->peer = peer;
-       session->wps_mode = wps_mode;
+       session->req_wps_mode = wps_mode;
        if (wps_mode == WFD_WPS_MODE_DISPLAY)
-               session->req_wps_mode = WFD_WPS_MODE_KEYPAD;
+               session->wps_mode = WFD_WPS_MODE_KEYPAD;
        else if (wps_mode == WFD_WPS_MODE_KEYPAD)
-               session->req_wps_mode = WFD_WPS_MODE_DISPLAY;
+               session->wps_mode = WFD_WPS_MODE_DISPLAY;
        else
-               session->req_wps_mode = wps_mode;
+               session->wps_mode = wps_mode;
        session->direction = direction;
        session->state = SESSION_STATE_CREATED;
 
        manager->session = session;
-       manager->local->wps_mode = wps_mode;
+       manager->local->wps_mode = session->wps_mode;
+       if (peer->dev_role == WFD_DEV_ROLE_GO)
+               manager->local->dev_role = WFD_DEV_ROLE_GC;
 
        __WDS_LOG_FUNC_EXIT__;
        return session;
@@ -174,6 +181,9 @@ int wfd_destroy_session(void *data)
        free(session);
        manager->session = NULL;
        manager->local->wps_mode = WFD_WPS_MODE_PBC;
+       manager->autoconnection = 0;
+       if (manager->local->dev_role == WFD_DEV_ROLE_GC)
+               manager->local->dev_role = WFD_DEV_ROLE_NONE;
 
        __WDS_LOG_FUNC_EXIT__;
        return 0;
@@ -196,6 +206,8 @@ int wfd_session_start(wfd_session_s *session)
        // Check: Invitation Received in Incomming case -> send prov_disc join
        // Check: User select peer to connect with in Outgoing case -> send prov_disc wps_mdde
 
+       wfd_oem_stop_scan(manager->oem_ops);
+
        session->state = SESSION_STATE_STARTED;
        peer = session->peer;
        if (peer->dev_role == WFD_DEV_ROLE_GO || session->invitation)
@@ -555,15 +567,26 @@ int wfd_session_process_event(wfd_manager_s *manager, wfd_oem_event_s *event)
        case WFD_OEM_EVENT_PROV_DISC_KEYPAD:
        {
                if (!session) {
+                       int req_wps_mode = WFD_WPS_MODE_NONE;
+                       int wps_mode = event->wps_mode;
+
+                       if (wps_mode == WFD_WPS_MODE_DISPLAY) {
+                               req_wps_mode = WFD_WPS_MODE_KEYPAD;
+                       } else if (wps_mode == WFD_WPS_MODE_KEYPAD) {
+                               req_wps_mode = WFD_WPS_MODE_DISPLAY;
+                       } else {
+                               req_wps_mode = WFD_WPS_MODE_PBC;
+                       }
+
                        session = wfd_create_session(manager, event->dev_addr,
-                                                                               event->wps_mode, SESSION_DIRECTION_INCOMING);
+                                                                               req_wps_mode, SESSION_DIRECTION_INCOMING);
                        if (!session) {
                                WDS_LOGE("Failed to create session with peer [" MACSTR "]", MAC2STR(event->dev_addr));
                                break;
                        }
 
                        /* Update session */
-                       if (event->wps_mode == WFD_OEM_WPS_MODE_DISPLAY) {
+                       if (wps_mode == WFD_WPS_MODE_DISPLAY) {
                                strncpy(session->wps_pin, event->wps_pin, PINSTR_LEN);
                                session->wps_pin[PINSTR_LEN] = '\0';
                        }
@@ -581,7 +604,8 @@ int wfd_session_process_event(wfd_manager_s *manager, wfd_oem_event_s *event)
                        snprintf(noti.param1, sizeof(noti.param1), MACSTR, MAC2STR(event->dev_addr));
                        wfd_event_notify_clients(manager, &noti);
                } else {
-                       if (session->state > SESSION_STATE_STARTED) {
+                       if (session->state > SESSION_STATE_STARTED ||
+                                       session->direction == SESSION_DIRECTION_INCOMING) {
                                WDS_LOGE("Unexpected event. Session is already started");
                                break;
                        }
@@ -658,7 +682,6 @@ int wfd_session_process_event(wfd_manager_s *manager, wfd_oem_event_s *event)
                        if (session->direction == SESSION_DIRECTION_OUTGOING)
                                wfd_session_connect(session);
                }
-               
                break;
        case WFD_OEM_EVENT_GO_NEG_DONE:
                if (!session) {

diff --git a/src/wifi-direct-util.c b/src/wifi-direct-util.c
index da61e5c..33417ba 100644 (file)
--- a/src/wifi-direct-util.c
+++ b/src/wifi-direct-util.c
@@ -551,8 +551,10 @@ int wfd_util_dhcpc_get_ip(char *ifname, unsigned char *ip_addr, int is_IPv6)
 
        errno = 0;
        sock = socket(AF_INET, SOCK_DGRAM, 0);
-       if (sock < 0) {
+       if (sock < SOCK_FD_MIN) {
                WDS_LOGE("Failed to create socket. [%s]", strerror(errno));
+               if (sock >= 0)
+                       close(sock);
                __WDS_LOG_FUNC_EXIT__;
                return -1;
        }