common/net_nfc_util_handover.c

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