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 #ifndef CTRL_IFACE_DBUS
 163         memcpy(peer->intf_addr, oem_dev->intf_addr, MACADDR_LEN);
 164 #endif /* CTRL_IFACE_DBUS */
 165         memcpy(peer->go_dev_addr, oem_dev->go_dev_addr, MACADDR_LEN);
 166         peer->channel = oem_dev->channel;
 167         peer->dev_role = oem_dev->dev_role;
 168         peer->config_methods = oem_dev->config_methods;
 169         peer->pri_dev_type = oem_dev->pri_dev_type;
 170         peer->sec_dev_type = oem_dev->sec_dev_type;
 171         peer->dev_flags = oem_dev->dev_flags;
 172         peer->group_flags = oem_dev->group_flags;
 173         peer->wps_mode =  oem_dev->wps_mode;
 174
 175 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 176         memcpy(&(peer->display), &(oem_dev->display), sizeof(wfd_display_s));
 177 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 178
 179         g_free(oem_dev);
 180
 181 #if !(__GNUC__ <= 4 && __GNUC_MINOR__ < 8)
 182         wfd_util_get_current_time(&peer->time);
 183 #else
 184         struct timeval tval;
 185         gettimeofday(&tval, NULL);
 186         peer->time = tval.tv_sec;
 187 #endif
 188
 189         __WDS_LOG_FUNC_EXIT__;
 190         return 0;
 191 }
 192
 193 int wfd_peer_clear_all(void *data)
 194 {
 195         __WDS_LOG_FUNC_ENTER__;
 196         wfd_manager_s *manager = (wfd_manager_s*) data;
 197         wfd_device_s *peer = NULL;
 198         GList *temp = NULL;
 199
 200         if (manager->peer_count == 0) {
 201                 WDS_LOGD("Peer not exist");
 202                 return -1;
 203         }
 204
 205         temp = g_list_first(manager->peers);
 206         while (temp) {
 207                 peer = (wfd_device_s*) temp->data;
 208                 g_free(peer);
 209                 temp = g_list_next(temp);
 210                 manager->peer_count--;
 211         }
 212
 213         if (manager->peers) {
 214                 g_list_free(manager->peers);
 215                 manager->peers = NULL;
 216         }
 217
 218         if (manager->peer_count) {
 219                 WDS_LOGE("Peer count is not synced. left count=%d", manager->peer_count);
 220                 manager->peer_count = 0;
 221                 return 1;
 222         }
 223
 224         __WDS_LOG_FUNC_EXIT__;
 225         return 0;
 226 }
 227
 228 wfd_device_s *wfd_peer_find_by_dev_addr(void *data, unsigned char *dev_addr)
 229 {
 230         __WDS_LOG_FUNC_ENTER__;
 231         wfd_manager_s *manager = (wfd_manager_s*) data;
 232         wfd_device_s *peer = NULL;
 233         GList *temp = NULL;
 234
 235         if (!data || !dev_addr) {
 236                 WDS_LOGE("Invalid parameter");
 237                 return NULL;
 238         }
 239
 240         if (manager->peer_count == 0) {
 241                 WDS_LOGE("There is no peer data");
 242                 return NULL;
 243         }
 244
 245         temp = g_list_first(manager->peers);
 246         while (temp) {
 247                 peer = temp->data;
 248                 if (!memcmp(peer->dev_addr, dev_addr, MACADDR_LEN)) {
 249                         WDS_LOGD("Peer device found[" MACSECSTR "]", MAC2SECSTR(dev_addr));
 250                         break;
 251                 }
 252                 temp = g_list_next(temp);
 253                 peer = NULL;
 254         }
 255
 256         __WDS_LOG_FUNC_EXIT__;
 257         return peer;
 258 }
 259
 260 #if 0
 261 wfd_device_s *wfd_peer_find_by_intf_addr(void *data, unsigned char *intf_addr)
 262 {
 263         __WDS_LOG_FUNC_ENTER__;
 264         wfd_manager_s *manager = (wfd_manager_s*) data;
 265         wfd_device_s *peer = NULL;
 266         GList *temp = NULL;
 267
 268         if (!data || !intf_addr) {
 269                 WDS_LOGE("Invalid parameter");
 270                 return NULL;
 271         }
 272
 273         if (manager->peer_count == 0) {
 274                 WDS_LOGE("There is no peer data");
 275                 return NULL;
 276         }
 277
 278         temp = g_list_first(manager->peers);
 279         while (temp) {
 280                 peer = temp->data;
 281                 if (!memcmp(peer->intf_addr, intf_addr, MACADDR_LEN)) {
 282                         WDS_LOGD("Peer device found[" MACSECSTR "]", MAC2SECSTR(intf_addr));
 283                         break;
 284                 }
 285                 temp = g_list_next(temp);
 286                 peer = NULL;
 287         }
 288
 289         __WDS_LOG_FUNC_EXIT__;
 290         return peer;
 291 }
 292 #endif
 293
 294 wfd_device_s *wfd_peer_find_by_addr(void *data, unsigned char *addr)
 295 {
 296         __WDS_LOG_FUNC_ENTER__;
 297         wfd_manager_s *manager = (wfd_manager_s*) data;
 298         wfd_device_s *peer = NULL;
 299         GList *temp = NULL;
 300
 301         if (!data || !addr) {
 302                 WDS_LOGE("Invalid parameter");
 303                 return NULL;
 304         }
 305
 306         if (manager->peer_count == 0) {
 307                 WDS_LOGE("There is no peer data");
 308                 return NULL;
 309         }
 310
 311         temp = g_list_first(manager->peers);
 312         while (temp) {
 313                 peer = temp->data;
 314                 if (!memcmp(peer->dev_addr, addr, MACADDR_LEN) ||
 315                                 !memcmp(peer->intf_addr, addr, MACADDR_LEN)) {
 316                         WDS_LOGD("Peer device found[" MACSECSTR "]", MAC2SECSTR(addr));
 317                         break;
 318                 }
 319                 temp = g_list_next(temp);
 320                 peer = NULL;
 321         }
 322
 323         __WDS_LOG_FUNC_EXIT__;
 324         return peer;
 325 }
 326
 327 #if 0
 328 wfd_device_s *wfd_peer_find_current_peer(void *data)
 329 {
 330         __WDS_LOG_FUNC_ENTER__;
 331         wfd_manager_s *manager = (wfd_manager_s*) data;
 332         if (!manager) {
 333                 WDS_LOGE("Invalid parameter");
 334                 return NULL;
 335         }
 336
 337         wfd_session_s *session = manager->session;
 338         if (!session) {
 339                 WDS_LOGE("Session not found");
 340                 return NULL;
 341         }
 342
 343         if (!session->peer) {
 344                 WDS_LOGE("Peer not found");
 345                 return NULL;
 346         }
 347
 348         __WDS_LOG_FUNC_EXIT__;
 349         return session->peer;
 350 }
 351
 352 int wfd_peer_set_data(unsigned char *dev_addr, int type, int data)
 353 {
 354         __WDS_LOG_FUNC_ENTER__;
 355         __WDS_LOG_FUNC_EXIT__;
 356         return 0;
 357 }
 358
 359 int wfd_peer_get_data(unsigned char *dev_addr, int type, int data)
 360 {
 361         __WDS_LOG_FUNC_ENTER__;
 362         __WDS_LOG_FUNC_EXIT__;
 363         return 0;
 364 }
 365 #endif