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 #include <time.h>
  31
  32 #include <glib.h>
  33
  34 #include <wifi-direct.h>
  35
  36 #include "wifi-direct-ipc.h"
  37 #include "wifi-direct-manager.h"
  38 #include "wifi-direct-oem.h"
  39 #include "wifi-direct-util.h"
  40 #include "wifi-direct-peer.h"
  41 #include "wifi-direct-session.h"
  42 #include "wifi-direct-log.h"
  43
  44
  45 wfd_device_s *wfd_add_peer(void *data, unsigned char *dev_addr, char *dev_name)
  46 {
  47         __WDS_LOG_FUNC_ENTER__;
  48         wfd_manager_s *manager = (wfd_manager_s*) data;
  49         wfd_device_s *peer = NULL;
  50
  51         if (!data || !dev_addr || !dev_name) {
  52                 WDS_LOGE("Invalid parameter");
  53                 __WDS_LOG_FUNC_EXIT__;
  54                 return NULL;
  55         }
  56
  57         peer = wfd_peer_find_by_dev_addr(manager, dev_addr);
  58         if (peer) {
  59                 WDS_LOGD("Peer already exist[" MACSECSTR "]", MAC2SECSTR(dev_addr));
  60                 __WDS_LOG_FUNC_EXIT__;
  61                 return peer;
  62         }
  63
  64         peer = (wfd_device_s*) g_try_malloc0(sizeof(wfd_device_s));
  65         if (peer == NULL) {
  66                 WDS_LOGE("Failed to allocate memory for peer[" MACSTR "]", MAC2STR(dev_addr));
  67                 __WDS_LOG_FUNC_EXIT__;
  68                 return NULL;
  69         }
  70         memcpy(peer->dev_addr, dev_addr, MACADDR_LEN);
  71         g_strlcpy(peer->dev_name, dev_name, DEV_NAME_LEN + 1);
  72         peer->is_legacy = FALSE;
  73
  74         manager->peers = g_list_prepend(manager->peers, peer);
  75         manager->peer_count++;
  76         WDS_LOGD("peer_count[%d]", manager->peer_count);
  77         __WDS_LOG_FUNC_EXIT__;
  78         return peer;
  79 }
  80
  81 int wfd_remove_peer(void *data, unsigned char *dev_addr)
  82 {
  83         __WDS_LOG_FUNC_ENTER__;
  84         wfd_manager_s *manager = (wfd_manager_s*) data;
  85         wfd_device_s *peer = NULL;
  86
  87         if (!data || !dev_addr) {
  88                 WDS_LOGE("Invalid parameter");
  89                 __WDS_LOG_FUNC_EXIT__;
  90                 return -1;
  91         }
  92
  93         peer = wfd_peer_find_by_dev_addr(manager, dev_addr);
  94         if (!peer) {
  95                 WDS_LOGE("Failed to find peer device");
  96                 __WDS_LOG_FUNC_EXIT__;
  97                 return -1;
  98         }
  99
 100         manager->peers = g_list_remove(manager->peers, peer);
 101         manager->peer_count--;
 102
 103         g_free(peer);
 104
 105         __WDS_LOG_FUNC_EXIT__;
 106         return 0;
 107 }
 108
 109 int wfd_update_peer_time(void*data, unsigned char *peer_addr)
 110 {
 111         __WDS_LOG_FUNC_ENTER__;
 112         wfd_manager_s *manager = (wfd_manager_s*) data;
 113         wfd_device_s *peer = NULL;
 114
 115         if (!manager || !peer_addr) {
 116                 WDS_LOGE("Invalid parameter");
 117                 return -1;
 118         }
 119
 120         peer = wfd_peer_find_by_dev_addr(manager, peer_addr);
 121         if (!peer) {
 122                 WDS_LOGD("Peer not found [" MACSECSTR "]", MAC2SECSTR(peer_addr));
 123                 return -1;
 124         }
 125
 126 #if !(__GNUC__ <= 4 && __GNUC_MINOR__ < 8)
 127         wfd_util_get_current_time(&peer->time);
 128 #else
 129         struct timeval tval;
 130         gettimeofday(&tval, NULL);
 131         peer->time = tval.tv_sec;
 132 #endif
 133
 134         __WDS_LOG_FUNC_EXIT__;
 135         return 0;
 136 }
 137
 138 int wfd_update_peer(void *data, wfd_device_s *peer)
 139 {
 140         __WDS_LOG_FUNC_ENTER__;
 141         wfd_manager_s *manager = (wfd_manager_s*) data;
 142         wfd_oem_device_s *oem_dev = NULL;
 143         int res = 0;
 144
 145         if (!peer) {
 146                 WDS_LOGE("Invalid parameter");
 147                 return -1;
 148         }
 149
 150         res = wfd_oem_get_peer_info(manager->oem_ops, peer->dev_addr, &oem_dev);
 151         if (res < 0 || !oem_dev) {
 152                 WDS_LOGE("Failed to get peer information");
 153                 return -1;
 154         }
 155
 156         if (oem_dev->age > 30 && peer->state == WFD_PEER_STATE_DISCOVERED) {
 157                 WDS_LOGE("Too old age to update peer");
 158                 g_free(oem_dev);
 159                 return -1;
 160         }
 161         g_strlcpy(peer->dev_name, oem_dev->dev_name, DEV_NAME_LEN + 1);
 162         if (!ISZEROMACADDR(oem_dev->intf_addr))
 163                 memcpy(peer->intf_addr, oem_dev->intf_addr, MACADDR_LEN);
 164         memcpy(peer->go_dev_addr, oem_dev->go_dev_addr, MACADDR_LEN);
 165         peer->channel = oem_dev->channel;
 166         peer->dev_role = oem_dev->dev_role;
 167         peer->config_methods = oem_dev->config_methods;
 168         peer->pri_dev_type = oem_dev->pri_dev_type;
 169         peer->sec_dev_type = oem_dev->sec_dev_type;
 170         peer->dev_flags = oem_dev->dev_flags;
 171         peer->group_flags = oem_dev->group_flags;
 172         peer->wps_mode =  oem_dev->wps_mode;
 173
 174 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 175         memcpy(&(peer->display), &(oem_dev->display), sizeof(wfd_display_s));
 176 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 177
 178         g_free(oem_dev);
 179
 180 #if !(__GNUC__ <= 4 && __GNUC_MINOR__ < 8)
 181         wfd_util_get_current_time(&peer->time);
 182 #else
 183         struct timeval tval;
 184         gettimeofday(&tval, NULL);
 185         peer->time = tval.tv_sec;
 186 #endif
 187
 188         __WDS_LOG_FUNC_EXIT__;
 189         return 0;
 190 }
 191
 192 int wfd_peer_clear_all(void *data)
 193 {
 194         __WDS_LOG_FUNC_ENTER__;
 195         wfd_manager_s *manager = (wfd_manager_s*) data;
 196         wfd_device_s *peer = NULL;
 197         GList *temp = NULL;
 198
 199         if (manager->peer_count == 0) {
 200                 WDS_LOGD("Peer not exist");
 201                 return -1;
 202         }
 203
 204         temp = g_list_first(manager->peers);
 205         while (temp) {
 206                 peer = (wfd_device_s*) temp->data;
 207                 g_free(peer);
 208                 temp = g_list_next(temp);
 209                 manager->peer_count--;
 210         }
 211
 212         if (manager->peers) {
 213                 g_list_free(manager->peers);
 214                 manager->peers = NULL;
 215         }
 216
 217         if (manager->peer_count) {
 218                 WDS_LOGE("Peer count is not synced. left count=%d", manager->peer_count);
 219                 manager->peer_count = 0;
 220                 return 1;
 221         }
 222
 223         __WDS_LOG_FUNC_EXIT__;
 224         return 0;
 225 }
 226
 227 wfd_device_s *wfd_peer_find_by_dev_addr(void *data, unsigned char *dev_addr)
 228 {
 229         __WDS_LOG_FUNC_ENTER__;
 230         wfd_manager_s *manager = (wfd_manager_s*) data;
 231         wfd_device_s *peer = NULL;
 232         GList *temp = NULL;
 233
 234         if (!data || !dev_addr) {
 235                 WDS_LOGE("Invalid parameter");
 236                 return NULL;
 237         }
 238
 239         if (manager->peer_count == 0) {
 240                 WDS_LOGE("There is no peer data");
 241                 return NULL;
 242         }
 243
 244         temp = g_list_first(manager->peers);
 245         while (temp) {
 246                 peer = temp->data;
 247                 if (!memcmp(peer->dev_addr, dev_addr, MACADDR_LEN)) {
 248                         WDS_LOGD("Peer device found[" MACSECSTR "]", MAC2SECSTR(dev_addr));
 249                         break;
 250                 }
 251                 temp = g_list_next(temp);
 252                 peer = NULL;
 253         }
 254
 255         __WDS_LOG_FUNC_EXIT__;
 256         return peer;
 257 }
 258
 259 #if 0
 260 wfd_device_s *wfd_peer_find_by_intf_addr(void *data, unsigned char *intf_addr)
 261 {
 262         __WDS_LOG_FUNC_ENTER__;
 263         wfd_manager_s *manager = (wfd_manager_s*) data;
 264         wfd_device_s *peer = NULL;
 265         GList *temp = NULL;
 266
 267         if (!data || !intf_addr) {
 268                 WDS_LOGE("Invalid parameter");
 269                 return NULL;
 270         }
 271
 272         if (manager->peer_count == 0) {
 273                 WDS_LOGE("There is no peer data");
 274                 return NULL;
 275         }
 276
 277         temp = g_list_first(manager->peers);
 278         while (temp) {
 279                 peer = temp->data;
 280                 if (!memcmp(peer->intf_addr, intf_addr, MACADDR_LEN)) {
 281                         WDS_LOGD("Peer device found[" MACSECSTR "]", MAC2SECSTR(intf_addr));
 282                         break;
 283                 }
 284                 temp = g_list_next(temp);
 285                 peer = NULL;
 286         }
 287
 288         __WDS_LOG_FUNC_EXIT__;
 289         return peer;
 290 }
 291 #endif
 292
 293 wfd_device_s *wfd_peer_find_by_addr(void *data, unsigned char *addr)
 294 {
 295         __WDS_LOG_FUNC_ENTER__;
 296         wfd_manager_s *manager = (wfd_manager_s*) data;
 297         wfd_device_s *peer = NULL;
 298         GList *temp = NULL;
 299
 300         if (!data || !addr) {
 301                 WDS_LOGE("Invalid parameter");
 302                 return NULL;
 303         }
 304
 305         if (manager->peer_count == 0) {
 306                 WDS_LOGE("There is no peer data");
 307                 return NULL;
 308         }
 309
 310         temp = g_list_first(manager->peers);
 311         while (temp) {
 312                 peer = temp->data;
 313                 if (!memcmp(peer->dev_addr, addr, MACADDR_LEN) ||
 314                                 !memcmp(peer->intf_addr, addr, MACADDR_LEN)) {
 315                         WDS_LOGD("Peer device found[" MACSECSTR "]", MAC2SECSTR(addr));
 316                         break;
 317                 }
 318                 temp = g_list_next(temp);
 319                 peer = NULL;
 320         }
 321
 322         __WDS_LOG_FUNC_EXIT__;
 323         return peer;
 324 }
 325
 326 #if 0
 327 wfd_device_s *wfd_peer_find_current_peer(void *data)
 328 {
 329         __WDS_LOG_FUNC_ENTER__;
 330         wfd_manager_s *manager = (wfd_manager_s*) data;
 331         if (!manager) {
 332                 WDS_LOGE("Invalid parameter");
 333                 return NULL;
 334         }
 335
 336         wfd_session_s *session = manager->session;
 337         if (!session) {
 338                 WDS_LOGE("Session not found");
 339                 return NULL;
 340         }
 341
 342         if (!session->peer) {
 343                 WDS_LOGE("Peer not found");
 344                 return NULL;
 345         }
 346
 347         __WDS_LOG_FUNC_EXIT__;
 348         return session->peer;
 349 }
 350
 351 int wfd_peer_set_data(unsigned char *dev_addr, int type, int data)
 352 {
 353         __WDS_LOG_FUNC_ENTER__;
 354         __WDS_LOG_FUNC_EXIT__;
 355         return 0;
 356 }
 357
 358 int wfd_peer_get_data(unsigned char *dev_addr, int type, int data)
 359 {
 360         __WDS_LOG_FUNC_ENTER__;
 361         __WDS_LOG_FUNC_EXIT__;
 362         return 0;
 363 }
 364 #endif