common/net_nfc_util_handover.c

   1 /*
   2  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *                               http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18
  19 #include <glib.h>
  20
  21 #include "net_nfc_typedef_internal.h"
  22 #include "net_nfc_debug_internal.h"
  23 #include "net_nfc_util_defines.h"
  24 #include "net_nfc_util_internal.h"
  25 #include "net_nfc_util_ndef_record.h"
  26 #include "net_nfc_util_ndef_message.h"
  27 #include "net_nfc_util_handover.h"
  28
  29 typedef struct _search_index
  30 {
  31         int target;
  32         int current;
  33         void *found;
  34 } search_index;
  35
  36 void net_nfc_convert_byte_order(unsigned char *array, int size)
  37 {
  38         int i;
  39         unsigned char tmp_char;
  40
  41         for ( i = 0; i < size/2; i++)
  42         {
  43                 tmp_char = array[i];
  44                 array[i] = array[size-1-i];
  45                 array[size-1-i] = tmp_char;
  46         }
  47 }
  48
  49
  50 static int __property_equal_to(gconstpointer key1, gconstpointer key2)
  51 {
  52         const net_nfc_carrier_property_s *arg1 = key1;
  53         const net_nfc_carrier_property_s *arg2 = key2;
  54
  55         if (arg1->attribute < arg2->attribute)
  56                 return -1;
  57         else if (arg1->attribute > arg2->attribute)
  58                 return 1;
  59         else
  60                 return 0;
  61 }
  62
  63 static net_nfc_carrier_property_s *__find_property_by_attrubute(GList *list,
  64                 uint16_t attribute)
  65 {
  66         GList *found = NULL;
  67         net_nfc_carrier_property_s temp;
  68
  69         temp.attribute = attribute;
  70         found = g_list_find_custom(list, &temp, __property_equal_to);
  71
  72         if (NULL == found)
  73                 return NULL;
  74
  75         return (net_nfc_carrier_property_s *)found->data;
  76 }
  77
  78 static void __find_nth_group(gpointer data, gpointer user_data)
  79 {
  80         search_index *nth = user_data;
  81         net_nfc_carrier_property_s *info = data;
  82
  83         RET_IF(NULL == info);
  84         RET_IF(NULL == user_data);
  85
  86         if (info->is_group)
  87         {
  88                 if (nth->current == nth->target)
  89                         nth->found = data;
  90
  91                 nth->current++;
  92         }
  93 }
  94
  95 static void __free_all_data(gpointer data, gpointer user_data)
  96 {
  97         net_nfc_carrier_property_s *info = data;
  98
  99         RET_IF(NULL == info);
 100
 101         if (info->is_group)
 102         {
 103                 NFC_DBG("FREE: group is found");
 104                 net_nfc_util_free_carrier_group(info);
 105         }
 106         else
 107         {
 108                 NFC_DBG("FREE: element is found ATTRIB:0x%X length:%d",
 109                                 info->attribute, info->length);
 110                 _net_nfc_util_free_mem(info->data);
 111                 _net_nfc_util_free_mem(info);
 112         }
 113 }
 114
 115 static net_nfc_error_e
 116         __net_nfc_util_create_connection_handover_collsion_resolution_record(
 117         ndef_record_s **record)
 118 {
 119
 120         uint32_t state = 0;
 121         uint16_t random_num;
 122         data_s payload = { 0 };
 123         data_s typeName = { 0 };
 124         uint8_t rand_buffer[2] = { 0, 0 };
 125
 126         RETV_IF(NULL == record, NET_NFC_NULL_PARAMETER);
 127
 128         state = (uint32_t)time(NULL);
 129         random_num = (unsigned short)rand_r(&state);
 130
 131         typeName.buffer = (uint8_t *)COLLISION_DETECT_RECORD_TYPE;
 132         typeName.length = strlen(COLLISION_DETECT_RECORD_TYPE);
 133
 134         rand_buffer[0] = (random_num & 0xff00) >> 8;    // MSB
 135         rand_buffer[1] = (random_num & 0x00ff); // LSB
 136
 137         payload.buffer = rand_buffer;
 138         payload.length = 2;
 139
 140         NFC_DBG("rand number = [0x%x] [0x%x] => [0x%x]",
 141                 payload.buffer[0], payload.buffer[1], random_num);
 142
 143         return net_nfc_util_create_record(NET_NFC_RECORD_WELL_KNOWN_TYPE,
 144                 &typeName, NULL, &payload, record);
 145 }
 146
 147 static int __net_nfc_get_size_of_attribute(int attribute)
 148 {
 149         switch (attribute)
 150         {
 151         case NET_NFC_BT_ATTRIBUTE_UUID16_PART :
 152         case NET_NFC_BT_ATTRIBUTE_UUID16 :
 153         case NET_NFC_BT_ATTRIBUTE_UUID32_PART :
 154         case NET_NFC_BT_ATTRIBUTE_UUID32 :
 155         case NET_NFC_BT_ATTRIBUTE_UUID128_PART :
 156         case NET_NFC_BT_ATTRIBUTE_UUID128 :
 157         case NET_NFC_BT_ATTRIBUTE_NAME_PART :
 158         case NET_NFC_BT_ATTRIBUTE_NAME :
 159         case NET_NFC_BT_ATTRIBUTE_TXPOWER :
 160         case NET_NFC_BT_ATTRIBUTE_OOB_COD :
 161         case NET_NFC_BT_ATTRIBUTE_OOB_HASH_C :
 162         case NET_NFC_BT_ATTRIBUTE_OOB_HASH_R :
 163         case NET_NFC_BT_ATTRIBUTE_ID :
 164         case NET_NFC_BT_ATTRIBUTE_MANUFACTURER :
 165         case NET_NFC_BT_ATTRIBUTE_ADDRESS :
 166                 //              case NET_NFC_WIFI_ATTRIBUTE_VERSION2:
 167                 return 1;
 168
 169         default :
 170                 return 2;
 171         }
 172 }
 173
 174 net_nfc_error_e net_nfc_util_create_carrier_config(
 175         net_nfc_carrier_config_s **config, net_nfc_conn_handover_carrier_type_e type)
 176 {
 177         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
 178         RETV_IF(type < 0, NET_NFC_OUT_OF_BOUND);
 179         RETV_IF(type >= NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN, NET_NFC_OUT_OF_BOUND);
 180
 181         _net_nfc_util_alloc_mem(*config, sizeof(net_nfc_carrier_config_s));
 182         if (NULL == *config)
 183                 return NET_NFC_ALLOC_FAIL;
 184
 185         (*config)->type = type;
 186         (*config)->length = 0;
 187
 188         return NET_NFC_OK;
 189 }
 190
 191 net_nfc_error_e net_nfc_util_add_carrier_config_property(
 192                 net_nfc_carrier_config_s *config, uint16_t attribute, uint16_t size, uint8_t *data)
 193 {
 194         net_nfc_carrier_property_s *elem = NULL;
 195
 196         NFC_DBG("ADD property: [ATTRIB:0x%X, SIZE:%d]", attribute, size);
 197
 198         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
 199         RETV_IF(NULL == data, NET_NFC_NULL_PARAMETER);
 200
 201         if (__find_property_by_attrubute(config->data, attribute) != NULL)
 202                 return NET_NFC_ALREADY_REGISTERED;
 203
 204         _net_nfc_util_alloc_mem(elem, sizeof (net_nfc_carrier_property_s));
 205         if (NULL == elem)
 206                 return NET_NFC_ALLOC_FAIL;
 207
 208         elem->attribute = attribute;
 209         elem->length = size;
 210         elem->is_group = false;
 211
 212         _net_nfc_util_alloc_mem(elem->data, size);
 213         if (NULL == elem->data)
 214         {
 215                 _net_nfc_util_free_mem(elem);
 216                 return NET_NFC_ALLOC_FAIL;
 217         }
 218         memcpy(elem->data, data, size);
 219
 220         config->data = g_list_append(config->data, elem);
 221         config->length += size + 2 * __net_nfc_get_size_of_attribute(attribute);
 222
 223         NFC_DBG("ADD completed total length %d", config->length);
 224
 225         return NET_NFC_OK;
 226 }
 227
 228 net_nfc_error_e net_nfc_util_remove_carrier_config_property(
 229                 net_nfc_carrier_config_s *config, uint16_t attribute)
 230 {
 231         net_nfc_carrier_property_s *elem = NULL;
 232
 233         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
 234
 235         elem = __find_property_by_attrubute(config->data, attribute);
 236         if (NULL == elem)
 237                 return NET_NFC_NO_DATA_FOUND;
 238
 239         config->data = g_list_remove(config->data, elem);
 240         config->length -= (elem->length + 2 * __net_nfc_get_size_of_attribute(attribute));
 241
 242         if (elem->is_group)
 243         {
 244                 net_nfc_util_free_carrier_group(elem);
 245         }
 246         else
 247         {
 248                 _net_nfc_util_free_mem(elem->data);
 249                 _net_nfc_util_free_mem(elem);
 250         }
 251
 252         return NET_NFC_OK;
 253 }
 254
 255 net_nfc_error_e net_nfc_util_get_carrier_config_property(
 256                 net_nfc_carrier_config_s *config,
 257                 uint16_t attribute,
 258                 uint16_t *size,
 259                 uint8_t **data)
 260 {
 261         net_nfc_carrier_property_s *elem = NULL;
 262
 263         RETV_IF(NULL == size, NET_NFC_NULL_PARAMETER);
 264         RETV_IF(NULL == data, NET_NFC_NULL_PARAMETER);
 265         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
 266
 267         elem = __find_property_by_attrubute(config->data, attribute);
 268         if (NULL == elem)
 269         {
 270                 *size = 0;
 271                 *data = NULL;
 272                 return NET_NFC_NO_DATA_FOUND;
 273         }
 274
 275         *size = elem->length;
 276         if (elem->is_group)
 277                 *data = NULL;
 278         else
 279                 *data = elem->data;
 280
 281         return NET_NFC_OK;
 282 }
 283
 284 net_nfc_error_e net_nfc_util_append_carrier_config_group(
 285                 net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group)
 286 {
 287         RETV_IF(NULL == group, NET_NFC_NULL_PARAMETER);
 288         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
 289
 290         if (g_list_find(config->data, group) != NULL)
 291                 return NET_NFC_ALREADY_REGISTERED;
 292
 293         config->data = g_list_append(config->data, group);
 294         config->length += group->length+4;
 295
 296         return NET_NFC_OK;
 297 }
 298
 299 net_nfc_error_e net_nfc_util_remove_carrier_config_group(
 300                 net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group)
 301 {
 302         RETV_IF(NULL == group, NET_NFC_NULL_PARAMETER);
 303         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
 304
 305         if (g_list_find(config->data, group) != NULL)
 306                 return NET_NFC_NO_DATA_FOUND;
 307
 308         config->length -= group->length;
 309         config->data = g_list_remove(config->data, group);
 310
 311         net_nfc_util_free_carrier_group(group);
 312
 313         return NET_NFC_OK;
 314 }
 315
 316 net_nfc_error_e net_nfc_util_get_carrier_config_group(
 317                 net_nfc_carrier_config_s *config, int index, net_nfc_carrier_property_s **group)
 318 {
 319         search_index result;
 320
 321         RETV_IF(NULL == group, NET_NFC_NULL_PARAMETER);
 322         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
 323         RETV_IF(index < 0, NET_NFC_OUT_OF_BOUND);
 324
 325         result.current = 0;
 326         result.target = index;
 327         result.found = NULL;
 328
 329         g_list_foreach(config->data, __find_nth_group, &result);
 330
 331         if (NULL == result.found)
 332                 return NET_NFC_NO_DATA_FOUND;
 333
 334         *group = (net_nfc_carrier_property_s *)result.found;
 335
 336         return NET_NFC_OK;
 337 }
 338
 339 net_nfc_error_e net_nfc_util_free_carrier_config(net_nfc_carrier_config_s *config)
 340 {
 341         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
 342
 343         g_list_foreach(config->data, __free_all_data, NULL);
 344         g_list_free(config->data);
 345
 346         _net_nfc_util_free_mem(config);
 347
 348         return NET_NFC_OK;
 349 }
 350
 351 net_nfc_error_e net_nfc_util_create_carrier_config_group(
 352                 net_nfc_carrier_property_s **group, uint16_t attribute)
 353 {
 354         RETV_IF(NULL == group, NET_NFC_NULL_PARAMETER);
 355
 356         _net_nfc_util_alloc_mem(*group, sizeof(net_nfc_carrier_property_s));
 357         if (NULL == *group)
 358                 return NET_NFC_ALLOC_FAIL;
 359
 360         (*group)->attribute = attribute;
 361         (*group)->is_group = true;
 362
 363         return NET_NFC_OK;
 364 }
 365
 366 net_nfc_error_e net_nfc_util_add_carrier_config_group_property(
 367                 net_nfc_carrier_property_s *group, uint16_t attribute, uint16_t size, uint8_t *data)
 368 {
 369         net_nfc_carrier_property_s *elem = NULL;
 370
 371         NFC_DBG("ADD group property: [ATTRIB:0x%X, SIZE:%d]", attribute, size);
 372
 373         RETV_IF(NULL == group, NET_NFC_NULL_PARAMETER);
 374         RETV_IF(NULL == data, NET_NFC_NULL_PARAMETER);
 375
 376         if (__find_property_by_attrubute((GList *)group->data, attribute) != NULL)
 377                 return NET_NFC_ALREADY_REGISTERED;
 378
 379         _net_nfc_util_alloc_mem(elem, sizeof (net_nfc_carrier_property_s));
 380         if (NULL == elem)
 381                 return NET_NFC_ALLOC_FAIL;
 382
 383         elem->attribute = attribute;
 384         elem->length = size;
 385         elem->is_group = false;
 386
 387         _net_nfc_util_alloc_mem(elem->data, size);
 388         if (NULL == elem->data)
 389         {
 390                 _net_nfc_util_free_mem(elem);
 391                 return NET_NFC_ALLOC_FAIL;
 392         }
 393         memcpy(elem->data, data, size);
 394         group->length += size + 2 * __net_nfc_get_size_of_attribute(attribute);
 395         group->data = g_list_append((GList *)(group->data), elem);
 396
 397         NFC_DBG("ADD group completed total length %d", group->length);
 398
 399         return NET_NFC_OK;
 400 }
 401
 402 net_nfc_error_e net_nfc_util_get_carrier_config_group_property(
 403                 net_nfc_carrier_property_s *group,
 404                 uint16_t attribute,
 405                 uint16_t *size,
 406                 uint8_t **data)
 407 {
 408         net_nfc_carrier_property_s *elem = NULL;
 409
 410         RETV_IF(NULL == size, NET_NFC_NULL_PARAMETER);
 411         RETV_IF(NULL == data, NET_NFC_NULL_PARAMETER);
 412         RETV_IF(NULL == group, NET_NFC_NULL_PARAMETER);
 413
 414         elem = __find_property_by_attrubute((GList*)(group->data), attribute);
 415         if (NULL == elem)
 416         {
 417                 *size = 0;
 418                 *data = NULL;
 419                 return NET_NFC_NO_DATA_FOUND;
 420         }
 421
 422         *size = elem->length;
 423         *data = elem->data;
 424
 425         return NET_NFC_OK;
 426 }
 427
 428 net_nfc_error_e net_nfc_util_remove_carrier_config_group_property(
 429                 net_nfc_carrier_property_s *group, uint16_t attribute)
 430 {
 431         net_nfc_carrier_property_s *elem = NULL;
 432
 433         RETV_IF(NULL == group, NET_NFC_NULL_PARAMETER);
 434
 435         elem = __find_property_by_attrubute((GList*)(group->data), attribute);
 436         if (NULL == elem)
 437                 return NET_NFC_NO_DATA_FOUND;
 438
 439         group->length -= elem->length;
 440         group->data = g_list_remove((GList*)(group->data), elem);
 441
 442         _net_nfc_util_free_mem(elem->data);
 443         _net_nfc_util_free_mem(elem);
 444
 445         return NET_NFC_OK;
 446
 447 }
 448
 449 net_nfc_error_e net_nfc_util_free_carrier_group(net_nfc_carrier_property_s *group)
 450 {
 451         RETV_IF(NULL == group, NET_NFC_NULL_PARAMETER);
 452
 453         g_list_foreach((GList*)(group->data), __free_all_data, NULL);
 454         g_list_free((GList*)(group->data));
 455
 456         _net_nfc_util_free_mem(group);
 457
 458         return NET_NFC_OK;
 459 }
 460
 461 static void __make_serial_wifi(gpointer data, gpointer user_data)
 462 {
 463         int inc = 0;
 464         uint8_t *current;
 465         data_s *payload = user_data;
 466         net_nfc_carrier_property_s *info = data;
 467
 468         RET_IF(NULL == info);
 469         RET_IF(NULL == user_data);
 470
 471         current = payload->buffer + payload->length;
 472         inc = __net_nfc_get_size_of_attribute(info->attribute);
 473
 474         if (info->is_group)
 475         {
 476                 NFC_DBG("[WIFI]Found Group make recursive");
 477                 *(uint16_t *)current = info->attribute;
 478                 net_nfc_convert_byte_order(current,2);
 479                 *(uint16_t *)(current + inc) = info->length;
 480                 net_nfc_convert_byte_order((current + inc),2);
 481                 payload->length += (inc + inc);
 482                 g_list_foreach((GList *)info->data, __make_serial_wifi, payload);
 483         }
 484         else
 485         {
 486                 NFC_DBG("[WIFI]Element is found attrib:0x%X length:%d current:%d",
 487                                 info->attribute, info->length, payload->length);
 488                 *(uint16_t *)current = info->attribute;
 489                 net_nfc_convert_byte_order(current,2);
 490                 *(uint16_t *)(current + inc) = info->length;
 491                 net_nfc_convert_byte_order((current + inc),2);
 492                 memcpy(current + inc + inc, info->data, info->length);
 493                 payload->length += (inc + inc + info->length);
 494         }
 495 }
 496
 497 static void __make_serial_bt(gpointer data, gpointer user_data)
 498 {
 499         int inc = 0;
 500         uint8_t *current;
 501         data_s *payload = user_data;
 502         net_nfc_carrier_property_s *info = data;
 503
 504         RET_IF(NULL == info);
 505         RET_IF(NULL == user_data);
 506
 507         current = payload->buffer + payload->length; /* payload->length is zero */
 508
 509         if (info->is_group)
 510         {
 511                 NFC_DBG("[BT]Found Group. call recursive");
 512                 g_list_foreach((GList *)info->data, __make_serial_bt, payload);
 513         }
 514         else
 515         {
 516                 if (info->attribute != NET_NFC_BT_ATTRIBUTE_ADDRESS)
 517                 {
 518                         NFC_DBG("[BT]Element is found attrib:0x%X length:%d current:%d",
 519                                         info->attribute, info->length, payload->length);
 520                         inc = __net_nfc_get_size_of_attribute(info->attribute);
 521                         *current = info->length + 1;
 522                         *(current + inc) = info->attribute;
 523                         memcpy(current + inc + inc, info->data, info->length);
 524                         payload->length += (inc + inc + info->length);
 525                 }
 526                 else
 527                 {
 528                         NFC_DBG("[BT]BT address is found length:%d", info->length);
 529                         memcpy(current, info->data, info->length);
 530                         payload->length += (info->length);
 531                 }
 532         }
 533 }
 534
 535 net_nfc_error_e net_nfc_util_create_ndef_record_with_carrier_config(
 536                 ndef_record_s **record, net_nfc_carrier_config_s *config)
 537 {
 538         data_s payload = { NULL, 0 };
 539         data_s record_type = { NULL, 0 };
 540
 541         RETV_IF(NULL == record, NET_NFC_NULL_PARAMETER);
 542         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
 543
 544         _net_nfc_util_alloc_mem(payload.buffer, config->length);
 545         if (NULL == payload.buffer)
 546                 return NET_NFC_ALLOC_FAIL;
 547
 548         payload.length = 0; /* this should be zero because this will be used as current position of data written */
 549
 550         if (NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS == config->type)
 551         {
 552                 record_type.buffer = (uint8_t *)CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME;
 553                 record_type.length = strlen(CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME);
 554                 g_list_foreach(config->data, __make_serial_wifi, &payload);
 555         }
 556         else if (NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS == config->type)
 557         {
 558                 record_type.buffer = (uint8_t *)CONN_HANDOVER_WIFI_IBSS_CARRIER_MIME_NAME;
 559                 record_type.length = strlen(CONN_HANDOVER_WIFI_IBSS_CARRIER_MIME_NAME);
 560                 g_list_foreach(config->data, __make_serial_wifi, &payload);
 561         }
 562         else if (NET_NFC_CONN_HANDOVER_CARRIER_BT == config->type)
 563         {
 564                 record_type.buffer = (uint8_t *)CONN_HANDOVER_BT_CARRIER_MIME_NAME;
 565                 record_type.length = strlen(CONN_HANDOVER_BT_CARRIER_MIME_NAME);
 566                 payload.buffer += 2; /* OOB total length */
 567                 g_list_foreach(config->data, __make_serial_bt, &payload);
 568                 payload.buffer -= 2; /* return to original */
 569                 payload.length += 2;
 570                 payload.buffer[0] = payload.length & 0xFF;
 571                 payload.buffer[1] = (payload.length >> 8) & 0xFF;
 572         }
 573         else
 574         {
 575                 return NET_NFC_NOT_SUPPORTED;
 576         }
 577
 578         NFC_DBG("payload length = %d", payload.length);
 579
 580         return net_nfc_util_create_record(NET_NFC_RECORD_MIME_TYPE, &record_type, NULL,
 581                         &payload, record);
 582 }
 583
 584 static net_nfc_error_e __net_nfc_get_list_from_serial_for_wifi(
 585                 GList **list, uint8_t *data, uint32_t length)
 586 {
 587         uint8_t *current = data;
 588         uint8_t *last = current + length;
 589
 590         while (current < last)
 591         {
 592                 net_nfc_carrier_property_s *elem = NULL;
 593                 _net_nfc_util_alloc_mem(elem, sizeof(net_nfc_carrier_property_s));
 594                 if (NULL == elem)
 595                         return NET_NFC_ALLOC_FAIL;
 596
 597                 elem->attribute = current[0]<<8|current[1];
 598                 elem->length = current[2]<<8|current[3];
 599
 600                 if (elem->attribute == NET_NFC_WIFI_ATTRIBUTE_CREDENTIAL)
 601                 {
 602                         __net_nfc_get_list_from_serial_for_wifi(list, (current + 4), elem->length);
 603                         elem->is_group = true;
 604                 }
 605                 else
 606                 {
 607                         _net_nfc_util_alloc_mem(elem->data, elem->length);
 608                         if (NULL == elem->data)
 609                         {
 610                                 _net_nfc_util_free_mem(elem);
 611                                 return NET_NFC_ALLOC_FAIL;
 612                         }
 613                         memcpy(elem->data, (current + 4), elem->length);
 614                         elem->is_group = false;
 615                 }
 616                 *list = g_list_append(*list, elem);
 617                 current += (4 + elem->length);
 618         }
 619
 620         return NET_NFC_OK;
 621 }
 622
 623 net_nfc_error_e __net_nfc_get_list_from_serial_for_bt(GList **list, uint8_t *data, uint32_t length)
 624 {
 625         uint8_t *last = NULL;
 626         uint8_t *current = data;
 627         net_nfc_carrier_property_s *elem = NULL;
 628
 629         current += 2; /* remove oob data length  two bytes length*/
 630         length -= 2;
 631
 632         _net_nfc_util_alloc_mem(elem, sizeof(net_nfc_carrier_property_s));
 633         if (NULL == elem)
 634                 return NET_NFC_ALLOC_FAIL;
 635
 636         elem->attribute = (uint16_t)NET_NFC_BT_ATTRIBUTE_ADDRESS;
 637         elem->length = 6; /* BT address length is always 6 */
 638
 639         _net_nfc_util_alloc_mem(elem->data, elem->length);
 640         if (NULL == elem->data)
 641         {
 642                 _net_nfc_util_free_mem(elem);
 643                 return NET_NFC_ALLOC_FAIL;
 644         }
 645         memcpy(elem->data, current, elem->length);
 646         elem->is_group = false;
 647
 648         current += 6; /* BT address length is always 6 */
 649         length -= 6; /* substracted by 6 (Address length)*/
 650         *list = g_list_append(*list, elem);
 651
 652         last = current + length;
 653
 654         while (current < last)
 655         {
 656                 _net_nfc_util_alloc_mem(elem, sizeof(net_nfc_carrier_property_s));
 657                 if (NULL == elem)
 658                         return NET_NFC_ALLOC_FAIL;
 659
 660                 elem->length = *((uint8_t *)current) - 1;
 661                 elem->attribute = *((uint8_t *)(++current));
 662
 663                 _net_nfc_util_alloc_mem(elem->data, elem->length);
 664                 if (NULL == elem->data)
 665                 {
 666                         _net_nfc_util_free_mem(elem);
 667                         return NET_NFC_ALLOC_FAIL;
 668                 }
 669                 memcpy(elem->data, (++current), elem->length);
 670                 elem->is_group = false;
 671
 672                 current += elem->length;
 673                 *list = g_list_append(*list, elem);
 674         }
 675
 676         return NET_NFC_OK;
 677 }
 678
 679 net_nfc_error_e net_nfc_util_create_carrier_config_from_config_record(
 680                 net_nfc_carrier_config_s **config, ndef_record_s *record)
 681 {
 682         net_nfc_error_e result = NET_NFC_OK;
 683         net_nfc_conn_handover_carrier_type_e type;
 684
 685         if (record == NULL || config == NULL)
 686         {
 687                 return NET_NFC_NULL_PARAMETER;
 688         }
 689
 690         if (strncmp((char *)record->type_s.buffer, CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME, record->type_s.length) == 0)
 691         {
 692                 type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS;
 693         }
 694         else if (strncmp((char *)record->type_s.buffer, CONN_HANDOVER_WIFI_IBSS_CARRIER_MIME_NAME, record->type_s.length) == 0)
 695         {
 696                 type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS;
 697         }
 698         else if (strncmp((char *)record->type_s.buffer, CONN_HANDOVER_BT_CARRIER_MIME_NAME, record->type_s.length) == 0)
 699         {
 700                 type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
 701         }
 702         else
 703         {
 704                 NFC_DBG("Record type is not config type");
 705                 return NET_NFC_INVALID_FORMAT;
 706         }
 707
 708         result = net_nfc_util_create_carrier_config(config, type);
 709         if (*config == NULL)
 710         {
 711                 return NET_NFC_ALLOC_FAIL;
 712         }
 713
 714         switch ((*config)->type)
 715         {
 716         case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS :
 717         case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS :
 718                 result = __net_nfc_get_list_from_serial_for_wifi((GList **)&((*config)->data), record->payload_s.buffer, record->payload_s.length);
 719                 break;
 720         case NET_NFC_CONN_HANDOVER_CARRIER_BT :
 721                 result = __net_nfc_get_list_from_serial_for_bt((GList **)&((*config)->data), record->payload_s.buffer, record->payload_s.length);
 722                 break;
 723         case NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN :
 724                 result = NET_NFC_NOT_SUPPORTED;
 725                 break;
 726         }
 727
 728         if (result != NET_NFC_OK)
 729         {
 730                 net_nfc_util_free_carrier_config((net_nfc_carrier_config_s *)*config);
 731         }
 732
 733         return result;
 734 }
 735
 736 net_nfc_error_e net_nfc_util_create_handover_request_message(ndef_message_s **message)
 737 {
 738         ndef_message_s *inner_message = NULL;
 739         net_nfc_error_e error;
 740         ndef_record_s *record = NULL;
 741         data_s type = { NULL, 0 };
 742         data_s payload = { NULL, 0 };
 743         int size = 0;
 744
 745         if (message == NULL)
 746         {
 747                 return NET_NFC_NULL_PARAMETER;
 748         }
 749
 750         error = net_nfc_util_create_ndef_message(message);
 751         if (error != NET_NFC_OK)
 752         {
 753                 return error;
 754         }
 755
 756         error = net_nfc_util_create_ndef_message(&inner_message);
 757         if (error != NET_NFC_OK)
 758         {
 759                 net_nfc_util_free_ndef_message(*message);
 760                 *message = NULL;
 761
 762                 return error;
 763         }
 764
 765         __net_nfc_util_create_connection_handover_collsion_resolution_record(&record);
 766         net_nfc_util_append_record(inner_message, record);
 767
 768         size = net_nfc_util_get_ndef_message_length(inner_message) + 1;
 769         _net_nfc_util_alloc_mem(payload.buffer, size);
 770         if (payload.buffer == NULL)
 771         {
 772                 net_nfc_util_free_ndef_message(inner_message);
 773                 net_nfc_util_free_ndef_message(*message);
 774                 *message = NULL;
 775
 776                 return NET_NFC_ALLOC_FAIL;
 777         }
 778         payload.length = size;
 779
 780         uint8_t version = CH_VERSION;
 781
 782         (payload.buffer)[0] = version;
 783         (payload.buffer)++;
 784         (payload.length)--;
 785
 786         error = net_nfc_util_convert_ndef_message_to_rawdata(inner_message, &payload);
 787         if (error != NET_NFC_OK)
 788         {
 789                 _net_nfc_util_free_mem(payload.buffer);
 790                 net_nfc_util_free_ndef_message(inner_message);
 791                 net_nfc_util_free_ndef_message(*message);
 792                 *message = NULL;
 793
 794                 return error;
 795         }
 796
 797         net_nfc_util_free_ndef_message(inner_message);
 798         (payload.buffer)--;
 799         (payload.length)++;
 800
 801         type.buffer = (uint8_t *)CH_REQ_RECORD_TYPE;
 802         type.length = strlen(CH_REQ_RECORD_TYPE);
 803
 804         net_nfc_util_create_record(NET_NFC_RECORD_WELL_KNOWN_TYPE, &type, NULL, &payload, &record);
 805         net_nfc_util_append_record(*message, record);
 806
 807         _net_nfc_util_free_mem(payload.buffer);
 808
 809         return NET_NFC_OK;
 810 }
 811
 812 net_nfc_error_e net_nfc_util_create_handover_select_message(ndef_message_s **message)
 813 {
 814         net_nfc_error_e error = NET_NFC_OK;
 815         ndef_record_s *record = NULL;
 816         data_s type = { NULL, 0 };
 817         data_s payload = { NULL, 0 };
 818
 819         if (message == NULL)
 820         {
 821                 return NET_NFC_NULL_PARAMETER;
 822         }
 823
 824         error = net_nfc_util_create_ndef_message(message);
 825         if (error != NET_NFC_OK)
 826         {
 827                 return error;
 828         }
 829
 830         _net_nfc_util_alloc_mem(payload.buffer, 1);
 831         if (payload.buffer == NULL)
 832         {
 833                 net_nfc_util_free_ndef_message(*message);
 834                 return NET_NFC_ALLOC_FAIL;
 835         }
 836         payload.length = (uint32_t)1;
 837
 838         (payload.buffer)[0] = CH_VERSION;
 839
 840         type.buffer = (uint8_t*)CH_SEL_RECORD_TYPE;
 841         type.length = strlen(CH_SEL_RECORD_TYPE);
 842
 843         net_nfc_util_create_record(NET_NFC_RECORD_WELL_KNOWN_TYPE, &type, NULL, &payload, &record);
 844         net_nfc_util_append_record(*message, record);
 845
 846         _net_nfc_util_free_mem(payload.buffer);
 847
 848         return NET_NFC_OK;
 849 }
 850
 851 net_nfc_error_e net_nfc_util_create_handover_carrier_record(ndef_record_s ** record)
 852 {
 853         data_s payload = {NULL,0};
 854
 855         data_s type = { NULL, 0 };
 856         uint8_t *buffer_ptr = NULL;
 857
 858         _net_nfc_util_alloc_mem(payload.buffer,26);//hardcoded as of now
 859         if (payload.buffer == NULL)
 860                 return NET_NFC_ALLOC_FAIL;
 861
 862         buffer_ptr = payload.buffer;
 863
 864         //copy ctf
 865         buffer_ptr[0]= NET_NFC_RECORD_MIME_TYPE;
 866
 867         //copy the MIME type length
 868         buffer_ptr[1] = strlen(CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME);
 869
 870         //copy the MIME
 871         memcpy(&buffer_ptr[2],CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME,(payload.buffer)[1]);
 872         payload.buffer[25] = '\0';
 873
 874         payload.length =26;
 875         type.buffer = (uint8_t *)CH_CAR_RECORD_TYPE;
 876         type.length = strlen(CH_CAR_RECORD_TYPE);
 877
 878         net_nfc_util_create_record(NET_NFC_RECORD_WELL_KNOWN_TYPE,
 879                         &type,
 880                         NULL,
 881                         &payload,
 882                         (ndef_record_s **)record);
 883
 884         _net_nfc_util_free_mem(payload.buffer);
 885
 886         return NET_NFC_OK;
 887 }
 888 net_nfc_error_e net_nfc_util_create_handover_error_record(ndef_record_s **record, uint8_t reason, uint32_t data)
 889 {
 890         data_s type;
 891         data_s payload;
 892         int size = 1;
 893
 894         switch (reason)
 895         {
 896         case 0x01 :
 897                 size += 1;
 898                 break;
 899         case 0x02 :
 900                 size += 4;
 901                 break;
 902         case 0x03 :
 903                 size += 1;
 904                 break;
 905         }
 906
 907         _net_nfc_util_alloc_mem(payload.buffer, size);
 908         if (payload.buffer == NULL)
 909         {
 910                 return NET_NFC_ALLOC_FAIL;
 911         }
 912         payload.length = size;
 913
 914         type.buffer = (uint8_t *)ERROR_RECORD_TYPE;
 915         type.length = strlen(ERROR_RECORD_TYPE);
 916
 917         net_nfc_util_create_record(NET_NFC_RECORD_WELL_KNOWN_TYPE, &type, NULL, &payload, (ndef_record_s **)record);
 918
 919         _net_nfc_util_free_mem(payload.buffer);
 920
 921         return NET_NFC_OK;
 922 }
 923
 924 /*      inner_msg should be freed after using   */
 925
 926 static net_nfc_error_e __net_nfc_get_inner_message(ndef_message_s *message, ndef_message_s *inner_msg)
 927 {
 928         net_nfc_error_e error;
 929         ndef_record_s *inner_record = NULL;
 930
 931         if (message == NULL || inner_msg == NULL)
 932         {
 933                 return NET_NFC_NULL_PARAMETER;
 934         }
 935
 936         inner_record = message->records;
 937         if (inner_record == NULL)
 938         {
 939                 // This message is not connection handover message
 940                 return NET_NFC_INVALID_FORMAT;
 941         }
 942
 943         if (strncmp((char*)(inner_record->type_s.buffer), CH_REQ_RECORD_TYPE, (size_t)(inner_record->type_s.length)) != 0
 944                         && strncmp((char*)(inner_record->type_s.buffer), CH_SEL_RECORD_TYPE, (size_t)(inner_record->type_s.length)) != 0)
 945         {
 946                 // This message is not connection handover message
 947                 return NET_NFC_INVALID_FORMAT;
 948         }
 949
 950         if (inner_record->payload_s.length > 1)
 951         {
 952                 /* There is Alternative Carrier Record or Collision Res. Rec. */
 953                 (inner_record->payload_s.buffer)++; /* version */
 954                 (inner_record->payload_s.length)--;
 955                 error = net_nfc_util_convert_rawdata_to_ndef_message(&(inner_record->payload_s), inner_msg);
 956                 (inner_record->payload_s.buffer)--;
 957                 (inner_record->payload_s.length)++;
 958         }
 959         else
 960         {
 961                 error = NET_NFC_NO_DATA_FOUND;
 962         }
 963
 964         return error;
 965 }
 966
 967 static net_nfc_error_e __net_nfc_replace_inner_message(ndef_message_s *message, ndef_message_s *inner_msg)
 968 {
 969         net_nfc_error_e error;
 970         ndef_record_s *inner_record = NULL;
 971
 972         if (message == NULL || inner_msg == NULL)
 973         {
 974                 return NET_NFC_NULL_PARAMETER;
 975         }
 976
 977         inner_record = message->records;
 978         if (inner_record == NULL)
 979         {
 980                 // This message is not connection handover message
 981                 NFC_ERR("inner_record == NULL");
 982                 return NET_NFC_INVALID_FORMAT;
 983         }
 984
 985         if (strncmp((char *)(inner_record->type_s.buffer), CH_REQ_RECORD_TYPE, (size_t)(inner_record->type_s.length)) != 0
 986                         && strncmp((char *)(inner_record->type_s.buffer), CH_SEL_RECORD_TYPE, (size_t)(inner_record->type_s.length)) != 0)
 987         {
 988                 // This message is not connection handover message
 989                 NFC_ERR("unknown type [%s]", inner_record->type_s.buffer);
 990                 return NET_NFC_INVALID_FORMAT;
 991         }
 992
 993         if (inner_record->payload_s.length >= 1)
 994         {
 995                 /* There is Alternative Carrier Record or Collision Res. Rec. */
 996                 data_s tdata = { NULL, 0 };
 997                 int inner_length;
 998
 999                 inner_length = net_nfc_util_get_ndef_message_length(inner_msg);
1000
1001                 _net_nfc_util_alloc_mem(tdata.buffer, inner_length + 1);
1002                 if (tdata.buffer == NULL)
1003                 {
1004                         return NET_NFC_ALLOC_FAIL;
1005                 }
1006
1007                 (tdata.buffer)++;
1008                 tdata.length = inner_length;
1009                 error = net_nfc_util_convert_ndef_message_to_rawdata(inner_msg, &tdata);
1010                 if (error == NET_NFC_OK)
1011                 {
1012                         (tdata.buffer)--;
1013                         (tdata.length)++;
1014                         (tdata.buffer)[0] = (inner_record->payload_s.buffer)[0];
1015                         _net_nfc_util_free_mem(inner_record->payload_s.buffer);
1016                         inner_record->payload_s.buffer = tdata.buffer;
1017                         inner_record->payload_s.length = tdata.length;
1018                 }
1019                 else
1020                 {
1021                         NFC_ERR("net_nfc_util_convert_ndef_message_to_rawdata failed [%d]", error);
1022                         _net_nfc_util_free_mem(tdata.buffer);
1023                 }
1024         }
1025         else
1026         {
1027                 NFC_ERR("inner_record->payload_s.length(%d) < 1 ", inner_record->payload_s.length);
1028                 error = NET_NFC_INVALID_FORMAT;
1029         }
1030
1031         return error;
1032 }
1033
1034 net_nfc_error_e net_nfc_util_append_carrier_config_record(ndef_message_s *message, ndef_record_s *record, net_nfc_conn_handover_carrier_state_e power_status)
1035 {
1036         ndef_message_s *inner_msg = NULL;
1037         ndef_record_s *carrier_rec = NULL;
1038         data_s payload = { NULL, 0 };
1039         data_s type = { NULL, 0 };
1040         int config_ref_count = 0;
1041         net_nfc_error_e error;
1042         uint8_t buffer[256] = { 0, };
1043 #if 0
1044         int i;
1045 #endif
1046         int offset;
1047         uint8_t id;
1048
1049         if (message == NULL || record == NULL)
1050         {
1051                 return NET_NFC_NULL_PARAMETER;
1052         }
1053
1054         if ((error = net_nfc_util_create_ndef_message(&inner_msg)) != NET_NFC_OK)
1055         {
1056                 NFC_ERR("net_nfc_util_create_ndef_message failed [%d]", error);
1057
1058                 return error;
1059         }
1060
1061         if ((error = __net_nfc_get_inner_message(message, inner_msg)) == NET_NFC_OK)
1062         {
1063                 int idx = 1;
1064                 ndef_record_s *last_rec = inner_msg->records;
1065
1066                 for (; idx < inner_msg->recordCount; idx++)
1067                 {
1068                         last_rec = last_rec->next;
1069                 }
1070
1071                 if (strncmp((char *)last_rec->type_s.buffer, COLLISION_DETECT_RECORD_TYPE, (size_t)last_rec->type_s.length) == 0)
1072                 {
1073                         config_ref_count = 0;
1074                 }
1075                 else if (strncmp((char *)last_rec->type_s.buffer, ALTERNATIVE_RECORD_TYPE, (size_t)last_rec->type_s.length) == 0)
1076                 {
1077                         memcpy(buffer, last_rec->payload_s.buffer, last_rec->payload_s.length);
1078                         config_ref_count = last_rec->payload_s.buffer[1];
1079                 }
1080         }
1081         else
1082         {
1083                 /* selector record type can include empty inner message. so that case, we will continue */
1084                 if (message->records != NULL &&
1085                                 memcmp((char *)message->records->type_s.buffer, CH_SEL_RECORD_TYPE, (size_t)message->records->type_s.length) != 0)
1086                 {
1087                         NFC_ERR("ERROR [%d]", error);
1088
1089                         net_nfc_util_free_ndef_message(inner_msg);
1090
1091                         return error;
1092                 }
1093         }
1094
1095         type.buffer = (uint8_t *)ALTERNATIVE_RECORD_TYPE;
1096         type.length = strlen(ALTERNATIVE_RECORD_TYPE);
1097
1098         config_ref_count++;
1099         offset = 0;
1100         //      id = '0' + config_ref_count;
1101         id = 'b';
1102
1103         /* carrier flag */
1104         buffer[offset++] = (uint8_t)(power_status & 0x3);       /* first byte, power status */
1105
1106         /* carrier data ref. len */
1107         buffer[offset++] = config_ref_count;
1108
1109         /* carrier data ref. */
1110         offset += (config_ref_count - 1);
1111         buffer[offset++] = id;
1112
1113         /* FIXME */
1114         /* aux data ref. len */
1115         buffer[offset++] = 0;
1116 #if 0 /* FIXME */
1117         /* carrier data ref. */
1118         for (i = 0; i < 0; i++)
1119         {
1120                 buffer[offset++] = 0;
1121         }
1122 #endif
1123         payload.buffer = buffer;
1124         payload.length = offset;
1125
1126         error = net_nfc_util_create_record(NET_NFC_RECORD_WELL_KNOWN_TYPE, &type, NULL, &payload, &carrier_rec);
1127         if (error != NET_NFC_OK)
1128         {
1129                 NFC_ERR("net_nfc_util_create_record failed [%d]", error);
1130
1131                 net_nfc_util_free_ndef_message(inner_msg);
1132
1133                 return error;
1134         }
1135
1136         error = net_nfc_util_append_record(inner_msg, carrier_rec);
1137         if (error != NET_NFC_OK)
1138         {
1139                 NFC_ERR("net_nfc_util_create_record failed [%d]", error);
1140
1141                 net_nfc_util_free_record(carrier_rec);
1142                 net_nfc_util_free_ndef_message(inner_msg);
1143
1144                 return error;
1145         }
1146
1147         error = __net_nfc_replace_inner_message(message, inner_msg);
1148         net_nfc_util_free_ndef_message(inner_msg);
1149         if (error != NET_NFC_OK)
1150         {
1151                 NFC_ERR("__net_nfc_replace_inner_message failed [%d]", error);
1152
1153                 return error;
1154         }
1155
1156         /* set record id to record that will be appended to ndef message */
1157         error = net_nfc_util_set_record_id((ndef_record_s *)record, &id, sizeof(id));
1158         if (error != NET_NFC_OK)
1159         {
1160                 NFC_ERR("net_nfc_util_set_record_id failed [%d]", error);
1161
1162                 return error;
1163         }
1164
1165         error = net_nfc_util_append_record(message, (ndef_record_s *)record);
1166         if (error != NET_NFC_OK)
1167         {
1168                 NFC_ERR("net_nfc_util_append_record failed [%d]", error);
1169
1170                 return error;
1171         }
1172
1173         return NET_NFC_OK;
1174 }
1175
1176 net_nfc_error_e net_nfc_util_remove_carrier_config_record(ndef_message_s *message, ndef_record_s *record)
1177 {
1178         ndef_message_s *inner_msg = NULL;
1179         int idx = 0;
1180         int saved_idx = 0;
1181         net_nfc_error_e error;
1182         ndef_record_s *current = NULL;
1183         ndef_record_s *record_priv = (ndef_record_s *)record;
1184
1185         if (message == NULL || record == NULL)
1186         {
1187                 return NET_NFC_NULL_PARAMETER;
1188         }
1189
1190         current = message->records;
1191
1192         for (idx = 0; idx < message->recordCount; idx++)
1193         {
1194                 if (current == record)
1195                 {
1196                         break;
1197                 }
1198                 current = current->next;
1199         }
1200
1201         if (current == NULL || idx == message->recordCount)
1202         {
1203                 NFC_DBG("The reference is not found in config records");
1204
1205                 return NET_NFC_NO_DATA_FOUND;
1206         }
1207         saved_idx = idx;
1208
1209         if ((error = net_nfc_util_create_ndef_message(&inner_msg)) != NET_NFC_OK)
1210         {
1211                 NFC_DBG("net_nfc_util_create_ndef_message failed [%d]", error);
1212
1213                 return error;
1214         }
1215
1216         if ((error = __net_nfc_get_inner_message(message, inner_msg)) == NET_NFC_OK)
1217         {
1218                 current = inner_msg->records;
1219
1220                 for (idx = 0; idx < inner_msg->recordCount; idx++, current = current->next)
1221                 {
1222                         if (strncmp((char *)current->type_s.buffer, ALTERNATIVE_RECORD_TYPE, (size_t)current->type_s.length) == 0)
1223                         {
1224                                 if ((uint32_t)(current->payload_s.buffer[1]) == record_priv->id_s.length &&
1225                                                 strncmp((char *)(current->payload_s.buffer + 2), (char*)(record_priv->id_s.buffer), (size_t)current->payload_s.buffer[1]) == 0)
1226                                 {
1227                                         // comparing the instance
1228                                         break;
1229                                 }
1230                         }
1231                 }
1232
1233                 if (current == NULL || idx == message->recordCount)
1234                 {
1235                         NFC_DBG("The reference is not found in inner message");
1236
1237                         error = NET_NFC_NO_DATA_FOUND;
1238                 }
1239                 else
1240                 {
1241                         net_nfc_util_remove_record_by_index(inner_msg, idx);
1242                         __net_nfc_replace_inner_message(message, inner_msg);
1243
1244                         // remove the record only if the inner record is found.
1245                         net_nfc_util_remove_record_by_index(message, saved_idx);
1246                 }
1247         }
1248
1249         net_nfc_util_free_ndef_message(inner_msg);
1250
1251         return error;
1252 }
1253
1254 net_nfc_error_e net_nfc_util_get_carrier_config_record(ndef_message_s *message, int index, ndef_record_s** record)
1255 {
1256         ndef_message_s *inner_msg = NULL;
1257         data_s id;
1258         net_nfc_error_e error;
1259         ndef_record_s *current = NULL;
1260         int idx = 0;
1261         int current_idx = 0;
1262
1263         if (message == NULL || record == NULL)
1264         {
1265                 return NET_NFC_NULL_PARAMETER;
1266         }
1267
1268         if ((error = net_nfc_util_create_ndef_message(&inner_msg)) != NET_NFC_OK)
1269         {
1270                 NFC_DBG("net_nfc_util_create_ndef_message failed [%d]", error);
1271
1272                 return error;
1273         }
1274
1275         if ((error = __net_nfc_get_inner_message(message, inner_msg)) == NET_NFC_OK)
1276         {
1277                 current = inner_msg->records;
1278                 for (idx = 0; idx < inner_msg->recordCount; idx++)
1279                 {
1280                         if (strncmp((char*)current->type_s.buffer, ALTERNATIVE_RECORD_TYPE, (size_t)current->type_s.length) == 0)
1281                         {
1282                                 if (current_idx == index)
1283                                         break;
1284                                 current_idx++;
1285                         }
1286                         current = current->next;
1287                 }
1288
1289                 if (current == NULL || idx == message->recordCount)
1290                 {
1291                         NFC_DBG("The reference is not found in inner message");
1292
1293                         error = NET_NFC_NO_DATA_FOUND;
1294                 }
1295                 else
1296                 {
1297                         id.buffer = (current->payload_s.buffer) + 2;
1298                         id.length = current->payload_s.buffer[1];
1299
1300                         error = net_nfc_util_search_record_by_id(message, &id, record);
1301                 }
1302         }
1303
1304         net_nfc_util_free_ndef_message(inner_msg);
1305
1306         return error;
1307 }
1308
1309 net_nfc_error_e net_nfc_util_get_handover_random_number(ndef_message_s *message, unsigned short *random_number)
1310 {
1311         net_nfc_error_e error;
1312         ndef_message_s *inner_msg = NULL;
1313         ndef_record_s *cr_record = NULL;
1314
1315         if (message == NULL)
1316         {
1317                 return NET_NFC_NULL_PARAMETER;
1318         }
1319
1320         if ((error = net_nfc_util_create_ndef_message(&inner_msg)) != NET_NFC_OK)
1321         {
1322                 NFC_DBG("net_nfc_util_create_ndef_message failed [%d]", error);
1323
1324                 return error;
1325         }
1326
1327         if ((error = __net_nfc_get_inner_message(message, inner_msg)) == NET_NFC_OK)
1328         {
1329                 cr_record = inner_msg->records;
1330                 if (strncmp((char*)cr_record->type_s.buffer, COLLISION_DETECT_RECORD_TYPE, (size_t)cr_record->type_s.length) != 0
1331                                 || cr_record->payload_s.length < 2)
1332                 {
1333                         NFC_DBG("There is no Collision resolution record");
1334
1335                         error = NET_NFC_INVALID_FORMAT;
1336                 }
1337                 else
1338                 {
1339                         *random_number = ((unsigned short)cr_record->payload_s.buffer[0] << 8) | (unsigned short)(cr_record->payload_s.buffer[1]);
1340                 }
1341         }
1342
1343         net_nfc_util_free_ndef_message(inner_msg);
1344
1345         return error;
1346 }
1347
1348 net_nfc_error_e net_nfc_util_get_alternative_carrier_record_count(ndef_message_s *message, unsigned int *count)
1349 {
1350         net_nfc_error_e error;
1351         ndef_message_s *inner_msg = NULL;
1352         ndef_record_s *current = NULL;
1353         int idx;
1354
1355         if (message == NULL || count == 0)
1356         {
1357                 return NET_NFC_NULL_PARAMETER;
1358         }
1359
1360         if ((error = net_nfc_util_create_ndef_message(&inner_msg)) != NET_NFC_OK)
1361         {
1362                 NFC_DBG("net_nfc_util_create_ndef_message failed [%d]", error);
1363
1364                 return error;
1365         }
1366
1367         *count = 0;
1368
1369         if ((error = __net_nfc_get_inner_message(message, inner_msg)) == NET_NFC_OK)
1370         {
1371                 current = inner_msg->records;
1372                 for (idx = 0; idx < inner_msg->recordCount; idx++)
1373                 {
1374                         if (strncmp((char *)current->type_s.buffer, ALTERNATIVE_RECORD_TYPE, (size_t)current->type_s.length) == 0)
1375                         {
1376                                 (*count)++;
1377                         }
1378                         current = current->next;
1379                 }
1380         }
1381
1382         net_nfc_util_free_ndef_message(inner_msg);
1383
1384         return error;
1385 }
1386
1387 net_nfc_error_e net_nfc_util_get_alternative_carrier_power_status(ndef_message_s *message, int index, net_nfc_conn_handover_carrier_state_e *power_state)
1388 {
1389         net_nfc_error_e error;
1390         ndef_message_s *inner_msg = NULL;
1391         ndef_record_s *current = NULL;
1392         int idx;
1393         int idx_count = 0;
1394
1395         if (message == NULL)
1396         {
1397                 return NET_NFC_NULL_PARAMETER;
1398         }
1399
1400         if (index < 0)
1401         {
1402                 return NET_NFC_OUT_OF_BOUND;
1403         }
1404
1405         if ((error = net_nfc_util_create_ndef_message(&inner_msg)) != NET_NFC_OK)
1406         {
1407                 NFC_DBG("net_nfc_util_create_ndef_message failed [%d]", error);
1408
1409                 return error;
1410         }
1411
1412         if ((error = __net_nfc_get_inner_message(message, inner_msg)) == NET_NFC_OK)
1413         {
1414                 error = NET_NFC_OUT_OF_BOUND;
1415                 current = inner_msg->records;
1416                 for (idx = 0; idx < inner_msg->recordCount; idx++)
1417                 {
1418                         if (strncmp((char *)current->type_s.buffer, ALTERNATIVE_RECORD_TYPE, (size_t)current->type_s.length) == 0)
1419                         {
1420                                 if (idx_count == index)
1421                                 {
1422                                         *power_state = current->payload_s.buffer[0] & 0x3;
1423                                         error = NET_NFC_OK;
1424                                         break;
1425                                 }
1426                                 idx_count++;
1427                         }
1428                         current = current->next;
1429                 }
1430         }
1431
1432         net_nfc_util_free_ndef_message(inner_msg);
1433
1434         return error;
1435 }
1436
1437 net_nfc_error_e net_nfc_util_set_alternative_carrier_power_status(ndef_message_s *message, int index, net_nfc_conn_handover_carrier_state_e power_status)
1438 {
1439         net_nfc_error_e error;
1440         ndef_message_s *inner_msg = NULL;
1441
1442         if (message == NULL)
1443         {
1444                 return NET_NFC_NULL_PARAMETER;
1445         }
1446         if (index < 0)
1447         {
1448                 return NET_NFC_OUT_OF_BOUND;
1449         }
1450
1451         if ((error = net_nfc_util_create_ndef_message(&inner_msg)) != NET_NFC_OK)
1452         {
1453                 NFC_DBG("net_nfc_util_create_ndef_message failed [%d]", error);
1454
1455                 return error;
1456         }
1457
1458         if ((error = __net_nfc_get_inner_message(message, inner_msg)) == NET_NFC_OK)
1459         {
1460                 int idx;
1461                 int idx_count = 0;
1462                 ndef_record_s *current = inner_msg->records;
1463
1464                 error = NET_NFC_OUT_OF_BOUND;
1465                 for (idx = 0; idx < inner_msg->recordCount; idx++, current = current->next)
1466                 {
1467                         if (strncmp((char *)current->type_s.buffer, ALTERNATIVE_RECORD_TYPE, (size_t)current->type_s.length) == 0)
1468                         {
1469                                 if (idx_count == index)
1470                                 {
1471                                         current->payload_s.buffer[0] = (power_status & 0x3) | (current->payload_s.buffer[0] & 0xFC);
1472
1473                                         __net_nfc_replace_inner_message(message, inner_msg);
1474                                         error = NET_NFC_OK;
1475                                         break;
1476                                 }
1477                                 idx_count++;
1478                         }
1479                 }
1480         }
1481
1482         net_nfc_util_free_ndef_message(inner_msg);
1483
1484         return error;
1485 }
1486
1487 net_nfc_error_e net_nfc_util_get_alternative_carrier_type_from_record(ndef_record_s *record, net_nfc_conn_handover_carrier_type_e *type)
1488 {
1489         if(strncmp((char*)record->type_s.buffer, CH_CAR_RECORD_TYPE, (size_t)record->type_s.length) == 0)
1490         {
1491                 NFC_DBG("CH_CAR_RECORD_TYPE");
1492
1493                 char ctf = record->payload_s.buffer[0] & 0x07;
1494                 char ctype_length = record->payload_s.buffer[1];
1495                 switch(ctf)
1496                 {
1497                 case NET_NFC_RECORD_MIME_TYPE:          /* Media Type as defined in [RFC 2046] */
1498                         if (strncmp((char *)&record->payload_s.buffer[2],
1499                                                 CONN_HANDOVER_BT_CARRIER_MIME_NAME,
1500                                                 (size_t)ctype_length) == 0)
1501                         {
1502                                 *type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
1503                         }
1504                         else if (strncmp((char *)&record->payload_s.buffer[2],
1505                                                 CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME,
1506                                                 (size_t)ctype_length) == 0)
1507                         {
1508                                 *type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS;
1509                         }
1510                         else if (strncmp((char *)&record->payload_s.buffer[2],
1511                                                 CONN_HANDOVER_WIFI_IBSS_CARRIER_MIME_NAME,
1512                                                 (size_t)ctype_length) == 0)
1513                         {
1514                                 *type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS;
1515                         }
1516                         else
1517                         {
1518                                 *type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
1519                         }
1520                         break;
1521                 case NET_NFC_RECORD_WELL_KNOWN_TYPE:    /* NFC Forum Well-known Type*/
1522                 case NET_NFC_RECORD_URI:                                /* Absolute URIs as defined in [RFC 3986] */
1523                 case NET_NFC_RECORD_EXTERNAL_RTD:               /* NFC Forum external type */
1524                 default:
1525                         *type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
1526                         break;
1527                 }
1528
1529         }
1530         else
1531         {
1532                 NFC_DBG("Other record type");
1533                 if (strncmp((char *)record->type_s.buffer, CONN_HANDOVER_BT_CARRIER_MIME_NAME,
1534                                         (size_t)record->type_s.length) == 0)
1535                 {
1536                         *type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
1537                 }
1538                 else if (strncmp((char *)record->type_s.buffer,
1539                                         CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME,
1540                                         (size_t)record->type_s.length) == 0)
1541                 {
1542                         *type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS;
1543                 }
1544                 else if (strncmp((char *)record->type_s.buffer,
1545                                         CONN_HANDOVER_WIFI_IBSS_CARRIER_MIME_NAME,
1546                                         (size_t)record->type_s.length) == 0)
1547                 {
1548                         *type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS;
1549                 }
1550                 else
1551                 {
1552                         *type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
1553                 }
1554         }
1555         return NET_NFC_OK;
1556 }
1557
1558 net_nfc_error_e net_nfc_util_get_alternative_carrier_type(ndef_message_s *message,
1559                 int index, net_nfc_conn_handover_carrier_type_e *type)
1560 {
1561         ndef_record_s *record = NULL;
1562         net_nfc_error_e ret;
1563
1564         ret = net_nfc_util_get_carrier_config_record(message, index, &record);
1565         if (ret != NET_NFC_OK)
1566                 return ret;
1567
1568         return net_nfc_util_get_alternative_carrier_type_from_record(record, type);
1569 }
1570
1571 net_nfc_error_e net_nfc_util_get_selector_power_status(ndef_message_s *message,
1572                 net_nfc_conn_handover_carrier_state_e *power_state)
1573 {
1574         net_nfc_error_e error;
1575         ndef_message_s *inner_msg = NULL;
1576         ndef_record_s *current = NULL;
1577         int idx;
1578         net_nfc_conn_handover_carrier_state_e selector_state;
1579
1580         selector_state = NET_NFC_CONN_HANDOVER_CARRIER_INACTIVATE;
1581
1582         if (message == NULL)
1583         {
1584                 return NET_NFC_NULL_PARAMETER;
1585         }
1586
1587         if ((error = net_nfc_util_create_ndef_message(&inner_msg)) == NET_NFC_OK)
1588         {
1589                 if ((error = __net_nfc_get_inner_message(message, inner_msg)) == NET_NFC_OK)
1590                 {
1591                         if (inner_msg->recordCount > 1)
1592                         {
1593                                 current = inner_msg->records;
1594                                 for (idx = 0; idx < inner_msg->recordCount; idx++)
1595                                 {
1596                                         if (strncmp((char *)current->type_s.buffer, ALTERNATIVE_RECORD_TYPE,
1597                                                                 (size_t)current->type_s.length) == 0)
1598                                         {
1599                                                 if (((current->payload_s.buffer[0] & 0x3) == NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATE) || ((current->payload_s.buffer[0] & 0x3) == NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATING))
1600                                                 {
1601                                                         selector_state = NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATE;
1602                                                         break;
1603                                                 }
1604                                         }
1605                                         current = current->next;
1606                                 }
1607                         }
1608                         else
1609                         {
1610                                 /* always activate when ac is only one */
1611                                 selector_state = NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATE;
1612                         }
1613
1614                         *power_state = selector_state;
1615                 }
1616                 else
1617                 {
1618                         NFC_ERR("_net_nfc_util_create_ndef_message failed [%d]", error);
1619                 }
1620
1621                 net_nfc_util_free_ndef_message(inner_msg);
1622         }
1623         else
1624         {
1625                 NFC_ERR("_net_nfc_util_create_ndef_message failed [%d]", error);
1626                 error = NET_NFC_ALLOC_FAIL;
1627         }
1628
1629         return error;
1630 }
1631