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