src/wifi-direct-peer.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 /**
  21  * This file implements wifi direct peer functions.
  22  *
  23  * @file                wifi-direct-peer.c
  24  * @author      Gibyoung Kim (lastkgb.kim@samsung.com)
  25  * @version     0.7
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30
  31 #include <glib.h>
  32
  33 #include <wifi-direct-internal.h>
  34
  35 #include "wifi-direct-manager.h"
  36 #include "wifi-direct-oem.h"
  37 #include "wifi-direct-util.h"
  38 #include "wifi-direct-peer.h"
  39 #include "wifi-direct-session.h"
  40
  41
  42 wfd_device_s *wfd_add_peer(void *data, unsigned char *dev_addr, char *dev_name)
  43 {
  44         __WDS_LOG_FUNC_ENTER__;
  45         wfd_manager_s *manager = (wfd_manager_s*) data;
  46         wfd_device_s *peer = NULL;
  47
  48         if (!data || !dev_addr || !dev_name) {
  49                 WDS_LOGE("Invalid parameter");
  50                 __WDS_LOG_FUNC_EXIT__;
  51                 return NULL;
  52         }
  53
  54         peer = wfd_peer_find_by_dev_addr(manager, dev_addr);
  55         if (peer) {
  56                 WDS_LOGE("Peer already exist[" MACSTR "]", MAC2STR(dev_addr));
  57                 __WDS_LOG_FUNC_EXIT__;
  58                 return NULL;
  59         }
  60
  61         peer = (wfd_device_s*) calloc(1, sizeof(wfd_device_s));
  62         memcpy(peer->dev_addr, dev_addr, MACADDR_LEN);
  63         strncpy(peer->dev_name, dev_name, DEV_NAME_LEN);
  64         peer->dev_name[DEV_NAME_LEN-1] = '\0';
  65
  66         manager->peers = g_list_prepend(manager->peers, peer);
  67         manager->peer_count++;
  68         WDS_LOGD("peer_count[%d]", manager->peer_count);
  69         __WDS_LOG_FUNC_EXIT__;
  70         return peer;
  71 }
  72
  73 int wfd_remove_peer(void *data, unsigned char *dev_addr)
  74 {
  75         __WDS_LOG_FUNC_ENTER__;
  76         wfd_manager_s *manager = (wfd_manager_s*) data;
  77         wfd_device_s *peer = NULL;
  78
  79         if (!data || !dev_addr) {
  80                 WDS_LOGE("Invalid parameter");
  81                 __WDS_LOG_FUNC_EXIT__;
  82                 return -1;
  83         }
  84
  85         peer = wfd_peer_find_by_dev_addr(manager, dev_addr);
  86         if (!peer) {
  87                 WDS_LOGE("Failed to find peer device");
  88                 __WDS_LOG_FUNC_EXIT__;
  89                 return -1;
  90         }
  91
  92         manager->peers = g_list_remove(manager->peers, peer);
  93         manager->peer_count--;
  94
  95         wfd_manager_init_service(peer);
  96         if(peer->wifi_display)
  97                 free(peer->wifi_display);
  98         free(peer);
  99         __WDS_LOG_FUNC_EXIT__;
 100         return 0;
 101 }
 102
 103 int wfd_update_peer_time(void*data, unsigned char *peer_addr)
 104 {
 105         __WDS_LOG_FUNC_ENTER__;
 106         wfd_manager_s *manager = (wfd_manager_s*) data;
 107         wfd_device_s *peer = NULL;
 108
 109         if (!manager || !peer_addr) {
 110                 WDS_LOGE("Invalid parameter");
 111                 return -1;
 112         }
 113
 114         peer = wfd_peer_find_by_dev_addr(manager, peer_addr);
 115         if (!peer) {
 116                 WDS_LOGE("Peer not found [" MACSTR "]", MAC2STR(peer_addr));
 117                 return -1;
 118         }
 119
 120         struct timeval tval;
 121         gettimeofday(&tval, NULL);
 122         peer->time = tval.tv_sec;
 123
 124         __WDS_LOG_FUNC_EXIT__;
 125         return 0;
 126 }
 127
 128 int wfd_update_peer(void *data, wfd_device_s *peer)
 129 {
 130         __WDS_LOG_FUNC_ENTER__;
 131         wfd_manager_s *manager = (wfd_manager_s*) data;
 132         wfd_oem_device_s *oem_dev = NULL;
 133         int res = 0;
 134
 135         if (!peer) {
 136                 WDS_LOGE("Invalid parameter");
 137                 return -1;
 138         }
 139
 140         res = wfd_oem_get_peer_info(manager->oem_ops, peer->dev_addr, &oem_dev);
 141         if (res < 0) {
 142                 WDS_LOGE("Failed to get peer information");
 143                 return -1;
 144         }
 145
 146         if (oem_dev->age > 4 && peer->state == WFD_PEER_STATE_DISCOVERED) {
 147                 WDS_LOGE("Too old age to update peer");
 148                 return -1;
 149         }
 150         strncpy(peer->dev_name, oem_dev->dev_name, DEV_NAME_LEN);
 151         peer->dev_name[DEV_NAME_LEN] = '\0';
 152         memcpy(peer->intf_addr, oem_dev->intf_addr, MACADDR_LEN);
 153         memcpy(peer->go_dev_addr, oem_dev->go_dev_addr, MACADDR_LEN);
 154         peer->dev_role = oem_dev->dev_role;
 155         peer->config_methods = oem_dev->config_methods;
 156         peer->pri_dev_type = oem_dev->pri_dev_type;
 157         peer->sec_dev_type = oem_dev->sec_dev_type;
 158         peer->dev_flags = oem_dev->dev_flags;
 159         peer->group_flags = oem_dev->group_flags;
 160         peer->wps_mode =  oem_dev->wps_mode;
 161
 162         if(!peer->wifi_display)
 163                 peer->wifi_display = calloc(1, sizeof(wfd_display_info_s));
 164         memcpy(peer->wifi_display, &oem_dev->wifi_display, sizeof(wfd_display_info_s));
 165
 166         struct timeval tval;
 167         gettimeofday(&tval, NULL);
 168         peer->time = tval.tv_sec;
 169
 170         __WDS_LOG_FUNC_EXIT__;
 171         return 0;
 172 }
 173
 174 int wfd_peer_clear_all(void *data)
 175 {
 176         __WDS_LOG_FUNC_ENTER__;
 177         wfd_manager_s *manager = (wfd_manager_s*) data;
 178         wfd_device_s *peer = NULL;
 179         GList *temp = NULL;
 180
 181         if (manager->peer_count == 0) {
 182                 WDS_LOGD("Peer not exist");
 183                 return -1;
 184         }
 185
 186         temp = g_list_first(manager->peers);
 187         while(temp) {
 188                 peer = (wfd_device_s*) temp->data;
 189                 wfd_manager_init_service(peer);
 190                 if(peer->wifi_display)
 191                         free(peer->wifi_display);
 192                 free(peer);
 193                 temp = g_list_next(temp);
 194                 manager->peer_count--;
 195         }
 196         g_list_free(manager->peers);
 197         manager->peers = NULL;
 198
 199         if (manager->peer_count){
 200                 WDS_LOGE("Peer count is not synced. left count=%d", manager->peer_count);
 201                 manager->peer_count = 0;
 202                 return 1;
 203         }
 204
 205         __WDS_LOG_FUNC_EXIT__;
 206         return 0;
 207 }
 208
 209 wfd_device_s *wfd_peer_find_by_dev_addr(void *data, unsigned char *dev_addr)
 210 {
 211         __WDS_LOG_FUNC_ENTER__;
 212         wfd_manager_s *manager = (wfd_manager_s*) data;
 213         wfd_device_s *peer = NULL;
 214         GList *temp = NULL;
 215
 216         if (!data || !dev_addr) {
 217                 WDS_LOGE("Invalid parameter");
 218                 return NULL;
 219         }
 220
 221         if (manager->peer_count == 0) {
 222                 WDS_LOGE("There is no peer data");
 223                 return NULL;
 224         }
 225
 226         temp = g_list_first(manager->peers);
 227         while (temp) {
 228                 peer = temp->data;
 229                 if (!memcmp(peer->dev_addr, dev_addr, MACADDR_LEN)) {
 230                         WDS_LOGD("Peer device found[" MACSTR "]", MAC2STR(dev_addr));
 231                         break;
 232                 }
 233                 temp = g_list_next(temp);
 234                 peer = NULL;
 235         }
 236
 237         __WDS_LOG_FUNC_EXIT__;
 238         return peer;
 239 }
 240
 241 wfd_device_s *wfd_peer_find_by_intf_addr(void *data, unsigned char *intf_addr)
 242 {
 243         __WDS_LOG_FUNC_ENTER__;
 244         wfd_manager_s *manager = (wfd_manager_s*) data;
 245         wfd_device_s *peer = NULL;
 246         GList *temp = NULL;
 247
 248         if (!data || !intf_addr) {
 249                 WDS_LOGE("Invalid parameter");
 250                 return NULL;
 251         }
 252
 253         if (manager->peer_count == 0) {
 254                 WDS_LOGE("There is no peer data");
 255                 return NULL;
 256         }
 257
 258         temp = g_list_first(manager->peers);
 259         while (temp) {
 260                 peer = temp->data;
 261                 if (!memcmp(peer->intf_addr, intf_addr, MACADDR_LEN)) {
 262                         WDS_LOGD("Peer device found[" MACSTR "]", MAC2STR(intf_addr));
 263                         break;
 264                 }
 265                 temp = g_list_next(temp);
 266                 peer = NULL;
 267         }
 268
 269         __WDS_LOG_FUNC_EXIT__;
 270         return peer;
 271 }
 272
 273 wfd_device_s *wfd_peer_find_by_addr(void *data, unsigned char *addr)
 274 {
 275         __WDS_LOG_FUNC_ENTER__;
 276         wfd_manager_s *manager = (wfd_manager_s*) data;
 277         wfd_device_s *peer = NULL;
 278         GList *temp = NULL;
 279
 280         if (!data || !addr) {
 281                 WDS_LOGE("Invalid parameter");
 282                 return NULL;
 283         }
 284
 285         if (manager->peer_count == 0) {
 286                 WDS_LOGE("There is no peer data");
 287                 return NULL;
 288         }
 289
 290         temp = g_list_first(manager->peers);
 291         while (temp) {
 292                 peer = temp->data;
 293                 if (!memcmp(peer->dev_addr, addr, MACADDR_LEN) ||
 294                                 !memcmp(peer->intf_addr, addr, MACADDR_LEN)) {
 295                         WDS_LOGE("Peer device found[" MACSTR "]", MAC2STR(addr));
 296                         break;
 297                 }
 298                 temp = g_list_next(temp);
 299                 peer = NULL;
 300         }
 301
 302         __WDS_LOG_FUNC_EXIT__;
 303         return peer;
 304 }
 305
 306 wfd_device_s *wfd_peer_find_current_peer(void *data)
 307 {
 308         __WDS_LOG_FUNC_ENTER__;
 309         wfd_device_s *peer = NULL;
 310         wfd_manager_s *manager = (wfd_manager_s*) data;
 311         if (!manager) {
 312                 WDS_LOGE("Invalid parameter");
 313                 return NULL;
 314         }
 315
 316         wfd_session_s *session = manager->session;
 317         if (!session) {
 318                 WDS_LOGE("Session not found");
 319                 return NULL;
 320         }
 321
 322         peer = session->peer;
 323
 324         __WDS_LOG_FUNC_EXIT__;
 325         return peer;
 326 }
 327
 328 int wfd_peer_set_data(unsigned char *dev_addr, int type, int data)
 329 {
 330         __WDS_LOG_FUNC_ENTER__;
 331         __WDS_LOG_FUNC_EXIT__;
 332         return 0;
 333 }
 334
 335 int wfd_peer_get_data(unsigned char *dev_addr, int type, int data)
 336 {
 337         __WDS_LOG_FUNC_ENTER__;
 338         __WDS_LOG_FUNC_EXIT__;
 339         return 0;
 340 }
 341