daemon/net_nfc_server_process_handover.c

   1 /*
   2  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *                               http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "net_nfc_server_handover.h"
  18 #include "net_nfc_debug_internal.h"
  19 #include "net_nfc_util_internal.h"
  20 #include "net_nfc_util_ndef_message.h"
  21 #include "net_nfc_util_ndef_record.h"
  22 #include "net_nfc_util_handover.h"
  23 #include "net_nfc_server_controller.h"
  24 #include "net_nfc_server_llcp.h"
  25 #include "net_nfc_server_process_handover.h"
  26 #include "net_nfc_server_process_snep.h"
  27 #include "net_nfc_util_gdbus_internal.h"
  28 #include "net_nfc_server_handover_bss.h"
  29 //#include "net_nfc_server_handover_bt.h"
  30
  31 typedef void (*_net_nfc_server_handover_create_carrier_msg_cb)(
  32                 net_nfc_error_e result,
  33                 ndef_message_s *selector,
  34                 void *user_param);
  35
  36 typedef struct _net_nfc_handover_context_t
  37 {
  38         net_nfc_target_handle_s *handle;
  39         net_nfc_error_e result;
  40         net_nfc_llcp_socket_t socket;
  41         uint32_t state;
  42         net_nfc_conn_handover_carrier_type_e type;
  43         data_s data;
  44         ndef_record_s *record;
  45         void *user_param;
  46 }
  47 net_nfc_handover_context_t;
  48
  49 #define NET_NFC_CH_CONTEXT \
  50         net_nfc_target_handle_s *handle;\
  51         net_nfc_llcp_socket_t socket;\
  52         net_nfc_error_e result;\
  53         int step;\
  54         net_nfc_conn_handover_carrier_type_e type;\
  55         void *user_param;
  56
  57 typedef struct _net_nfc_server_handover_create_config_context_t
  58 {
  59         net_nfc_target_handle_s *handle;
  60         net_nfc_llcp_socket_t socket;
  61         net_nfc_error_e result;
  62         int step;
  63         net_nfc_conn_handover_carrier_type_e type;
  64         void *user_param;
  65         // TODO: above value MUST be same with NET_NFC_CH_CONTEXT
  66
  67         _net_nfc_server_handover_create_carrier_msg_cb cb;
  68         net_nfc_conn_handover_carrier_type_e current_type;
  69         ndef_message_s *ndef_message;
  70         ndef_message_s *requester; /* for low power selector */
  71
  72         ndef_record_s *record;
  73 }
  74 net_nfc_server_handover_create_config_context_t;
  75
  76 typedef struct _net_nfc_server_handover_process_config_context_t
  77 {
  78         net_nfc_target_handle_s *handle;
  79         net_nfc_llcp_socket_t socket;
  80         net_nfc_error_e result;
  81         int step;
  82         net_nfc_conn_handover_carrier_type_e type;
  83         void *user_param;
  84         // TODO: above value MUST be same with NET_NFC_CH_CONTEXT */
  85
  86         net_nfc_server_handover_process_carrier_record_cb cb;
  87 }net_nfc_server_handover_process_config_context_t;
  88
  89
  90 static void _net_nfc_server_handover_send_response(net_nfc_error_e result,
  91                 net_nfc_conn_handover_carrier_type_e carrier,
  92                 data_s *ac_data,
  93                 void *user_param);
  94
  95 static void _net_nfc_server_handover_client_process(
  96                 net_nfc_handover_context_t *context);
  97
  98 static void _net_nfc_server_handover_client_error_cb(
  99                 net_nfc_error_e result,
 100                 net_nfc_target_handle_s *handle,
 101                 net_nfc_llcp_socket_t socket,
 102                 data_s *data,
 103                 void *user_param);
 104
 105 static void _net_nfc_server_handover_client_connected_cb(
 106                 net_nfc_error_e result,
 107                 net_nfc_target_handle_s *handle,
 108                 net_nfc_llcp_socket_t socket,
 109                 data_s *data,
 110                 void *user_param);
 111
 112 static void _net_nfc_server_handover_bss_get_carrier_record_cb(
 113                 net_nfc_error_e result,
 114                 net_nfc_conn_handover_carrier_state_e cps,
 115                 ndef_record_s *carrier,
 116                 uint32_t aux_data_count,
 117                 ndef_record_s *aux_data,
 118                 void *user_param);
 119
 120 static void _net_nfc_server_handover_bss_process_carrier_record_cb(
 121                 net_nfc_error_e result,
 122                 net_nfc_conn_handover_carrier_type_e type,
 123                 data_s *data,
 124                 void *user_param);
 125 static void _net_nfc_server_handover_get_response_process(
 126                 net_nfc_handover_context_t *context);
 127
 128 static net_nfc_error_e
 129 _net_nfc_server_handover_create_requester_from_rawdata(
 130                 ndef_message_s **requestor,
 131                 data_s *data);
 132
 133 static net_nfc_error_e
 134 _net_nfc_server_handover_create_requester_carrier_configs(
 135                 net_nfc_conn_handover_carrier_type_e type,
 136                 void *cb,
 137                 void *user_param);
 138
 139 static bool _net_nfc_server_handover_check_hr_record_validation(
 140                 ndef_message_s *message);
 141
 142 static bool _net_nfc_server_handover_check_hs_record_validation(
 143                 ndef_message_s *message);
 144
 145 static net_nfc_error_e
 146 _net_nfc_server_handover_create_selector_carrier_configs(
 147                 net_nfc_conn_handover_carrier_type_e type,
 148                 void *cb,
 149                 void *user_param);
 150
 151 static int _net_nfc_server_handover_iterate_create_carrier_configs(
 152                 net_nfc_server_handover_create_config_context_t *context);
 153
 154 static int _net_nfc_server_handover_iterate_carrier_configs_to_next(
 155                 net_nfc_server_handover_create_config_context_t *context);
 156
 157 static int _net_nfc_server_handover_iterate_carrier_configs_step(
 158                 net_nfc_server_handover_create_config_context_t *context);
 159
 160 static void _net_nfc_server_handover_server_process(
 161                 net_nfc_handover_context_t *context);
 162
 163 ////////////////////////////////////////////////////////////////////////////
 164
 165 static void _net_nfc_server_handover_send_response(
 166                 net_nfc_error_e result,
 167                 net_nfc_conn_handover_carrier_type_e carrier,
 168                 data_s *ac_data,
 169                 void *user_param)
 170 {
 171         HandoverRequestData *handover_data = user_param;
 172
 173         g_assert(handover_data != NULL);
 174         g_assert(handover_data->invocation != NULL);
 175         g_assert(handover_data->handoverobj != NULL);
 176
 177         net_nfc_gdbus_handover_complete_request(
 178                         handover_data->handoverobj,
 179                         handover_data->invocation,
 180                         result,
 181                         carrier,
 182                         net_nfc_util_gdbus_data_to_variant(ac_data));
 183
 184         if (handover_data->data)
 185         {
 186                 g_free(handover_data->data->buffer);
 187                 g_free(handover_data->data);
 188         }
 189
 190         g_object_unref(handover_data->invocation);
 191         g_object_unref(handover_data->handoverobj);
 192
 193         g_free(handover_data);
 194 }
 195
 196 static net_nfc_error_e _net_nfc_server_handover_convert_ndef_message_to_data(
 197                 ndef_message_s *msg, data_s *data)
 198 {
 199         uint32_t length;
 200         net_nfc_error_e result;
 201
 202         RETV_IF(NULL == msg, NET_NFC_INVALID_PARAM);
 203         RETV_IF(NULL == data, NET_NFC_INVALID_PARAM);
 204
 205         length = net_nfc_util_get_ndef_message_length(msg);
 206         if (length > 0)
 207         {
 208                 net_nfc_util_alloc_data(data, length);
 209                 result = net_nfc_util_convert_ndef_message_to_rawdata(msg, data);
 210         }
 211         else
 212         {
 213                 result = NET_NFC_INVALID_PARAM;
 214         }
 215
 216         return result;
 217 }
 218
 219 static void _net_nfc_server_handover_bss_get_carrier_record_cb(
 220                 net_nfc_error_e result,
 221                 net_nfc_conn_handover_carrier_state_e cps,
 222                 ndef_record_s *carrier,
 223                 uint32_t aux_data_count,
 224                 ndef_record_s *aux_data,
 225                 void *user_param)
 226 {
 227         net_nfc_server_handover_create_config_context_t *context = user_param;
 228
 229         /* append record to ndef message */
 230         if (NET_NFC_OK == result)
 231         {
 232                 ndef_record_s *record;
 233
 234                 net_nfc_util_create_record(carrier->TNF, &carrier->type_s, &carrier->id_s,
 235                                 &carrier->payload_s, &record);
 236
 237                 result = net_nfc_util_append_carrier_config_record(context->ndef_message,
 238                                                 record, cps);
 239                 if (NET_NFC_OK == result)
 240                 {
 241                         NFC_DBG("net_nfc_util_append_carrier_config_record success");
 242                 }
 243                 else
 244                 {
 245                         NFC_ERR("net_nfc_util_append_carrier_config_record failed [%d]", result);
 246                         net_nfc_util_free_record(record);
 247                 }
 248
 249                 g_idle_add((GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_to_next,
 250                                 (gpointer)context);
 251         }
 252
 253         /* don't free context */
 254 }
 255
 256 static void _net_nfc_server_handover_bss_process_carrier_record_cb(
 257                 net_nfc_error_e result,
 258                 net_nfc_conn_handover_carrier_type_e type,
 259                 data_s *data,
 260                 void *user_param)
 261 {
 262         net_nfc_server_handover_process_config_context_t *context = user_param;
 263
 264         if(context)
 265         {
 266                 if (context->cb != NULL)
 267                         context->cb(result, type, data, context->user_param);
 268                 else
 269                         NFC_ERR("Invalid Callback");
 270
 271                 _net_nfc_util_free_mem(context);
 272         }
 273 }
 274
 275 net_nfc_error_e
 276 net_nfc_server_handover_get_carrier_record_by_priority_order(
 277                 ndef_message_s *request,
 278                 ndef_record_s **record)
 279 {
 280         net_nfc_error_e result;
 281         unsigned int carrier_count = 0;
 282
 283         LOGD("[%s] START", __func__);
 284
 285         RETV_IF(NULL == request, NET_NFC_NULL_PARAMETER);
 286         RETV_IF(NULL == record, NET_NFC_NULL_PARAMETER);
 287
 288         *record = NULL;
 289
 290         result = net_nfc_util_get_alternative_carrier_record_count(request, &carrier_count);
 291         if (NET_NFC_OK == result)
 292         {
 293                 int idx, priority;
 294                 net_nfc_conn_handover_carrier_type_e carrier_type =
 295                         NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
 296
 297                 for (priority = NET_NFC_CONN_HANDOVER_CARRIER_BT;*record == NULL
 298                                 && priority < NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;priority++)
 299                 {
 300                         /* check each carrier record and create matched record */
 301                         for (idx = 0; idx < carrier_count; idx++)
 302                         {
 303                                 result = net_nfc_util_get_alternative_carrier_type(request, idx,
 304                                                                 &carrier_type);
 305
 306                                 if ((NET_NFC_OK == result) && (carrier_type == priority))
 307                                 {
 308                                         NFC_DBG("selected carrier type = [%d]", carrier_type);
 309                                         net_nfc_util_get_carrier_config_record(request, idx, record);
 310                                         result = NET_NFC_OK;
 311                                         break;
 312                                 }
 313                         }
 314                 }
 315         }
 316         else
 317         {
 318                 NFC_ERR("net_nfc_util_get_alternative_carrier_record_count failed");
 319         }
 320
 321         LOGD("[%s] END", __func__);
 322
 323         return result;
 324 }
 325
 326 static net_nfc_error_e _net_nfc_server_handover_create_requester_from_rawdata(
 327                 ndef_message_s **requestor, data_s *data)
 328 {
 329         net_nfc_error_e result;
 330
 331         if (NULL == requestor)
 332                 return NET_NFC_NULL_PARAMETER;
 333
 334         *requestor = NULL;
 335
 336         result = net_nfc_util_create_ndef_message(requestor);
 337         if (result == NET_NFC_OK)
 338         {
 339                 result = net_nfc_util_convert_rawdata_to_ndef_message(data, *requestor);
 340
 341                 if (result == NET_NFC_OK)
 342                 {
 343                         if (_net_nfc_server_handover_check_hr_record_validation(*requestor) == true)
 344                         {
 345                                 result = NET_NFC_OK;
 346                         }
 347                         else
 348                         {
 349                                 NFC_ERR("record is not valid or is not available");
 350                                 net_nfc_util_free_ndef_message(*requestor);
 351                                 result = NET_NFC_INVALID_PARAM;
 352                         }
 353                 }
 354                 else
 355                 {
 356                         NFC_ERR("_net_nfc_ndef_rawdata_to_ndef failed [%d]",result);
 357                 }
 358         } else {
 359                 NFC_ERR("net_nfc_util_create_ndef_message failed [%d]", result);
 360         }
 361
 362         return result;
 363 }
 364
 365 net_nfc_error_e net_nfc_server_handover_create_selector_from_rawdata(
 366                 ndef_message_s **selector, data_s *data)
 367 {
 368         net_nfc_error_e result;
 369
 370         if (NULL == selector)
 371                 return NET_NFC_NULL_PARAMETER;
 372
 373         *selector = NULL;
 374
 375         if ((result = net_nfc_util_create_ndef_message(selector)) == NET_NFC_OK)
 376         {
 377                 result = net_nfc_util_convert_rawdata_to_ndef_message(data, *selector);
 378                 if (NET_NFC_OK == result)
 379                 {
 380                         /* if record is not Hs record, then */
 381                         if (_net_nfc_server_handover_check_hs_record_validation(*selector) == true)
 382                         {
 383                                 result = NET_NFC_OK;
 384                         }
 385                         else
 386                         {
 387                                 NFC_ERR("record is not valid or is not available");
 388                                 net_nfc_util_free_ndef_message(*selector);
 389                                 result = NET_NFC_INVALID_PARAM;
 390                         }
 391                 }
 392                 else
 393                 {
 394                         NFC_ERR("_net_nfc_ndef_rawdata_to_ndef failed [%d]",result);
 395                 }
 396         }
 397         else
 398         {
 399                 NFC_ERR("_net_nfc_util_create_ndef_message failed [%d]",result);
 400         }
 401
 402         return result;
 403 }
 404
 405 static bool _net_nfc_server_handover_check_hr_record_validation(
 406                 ndef_message_s *message)
 407 {
 408         ndef_record_s *rec;
 409         unsigned int count;
 410         net_nfc_error_e ret;
 411
 412         LOGD("[%s] START", __func__);
 413
 414         if (NULL == message)
 415                 return false;
 416
 417         rec = (ndef_record_s *)message->records;
 418
 419         if (memcmp(rec->type_s.buffer, CH_REQ_RECORD_TYPE, rec->type_s.length) != 0)
 420         {
 421                 NFC_ERR("This is not connection handover request message");
 422                 goto ERROR;
 423         }
 424
 425         if (rec->payload_s.buffer[0] != CH_VERSION)
 426         {
 427                 NFC_ERR("connection handover version is not matched");
 428                 goto ERROR;
 429         }
 430
 431         ret = net_nfc_util_get_alternative_carrier_record_count(message, &count);
 432         if (ret != NET_NFC_OK || 0 == count)
 433         {
 434                 NFC_ERR("there is no carrier reference");
 435                 goto ERROR;
 436         }
 437
 438         LOGD("[%s] END", __func__);
 439
 440         return true;
 441
 442 ERROR :
 443         LOGD("[%s] END", __func__);
 444
 445         return false;
 446 }
 447
 448 static bool _net_nfc_server_handover_check_hs_record_validation(
 449                 ndef_message_s *message)
 450 {
 451         ndef_record_s *rec;
 452         unsigned int count;
 453         net_nfc_error_e ret;
 454
 455         LOGD("[%s] START", __func__);
 456
 457         if (NULL == message)
 458                 return false;
 459
 460         rec = (ndef_record_s *)message->records;
 461
 462         if (memcmp(rec->type_s.buffer, CH_SEL_RECORD_TYPE, rec->type_s.length) != 0)
 463         {
 464                 NFC_ERR("This is not connection handover request message");
 465                 goto ERROR;
 466         }
 467
 468         ret = net_nfc_util_get_alternative_carrier_record_count(message,&count);
 469         if (ret != NET_NFC_OK || 0 == count)
 470         {
 471                 NFC_ERR("there is no carrrier reference");
 472                 goto ERROR;
 473         }
 474
 475         /*      check version */
 476         if (rec->payload_s.buffer[0] != CH_VERSION)
 477         {
 478                 NFC_ERR("connection handover version is not matched");
 479                 goto ERROR;
 480         }
 481
 482         LOGD("[%s] END", __func__);
 483
 484         return true;
 485
 486 ERROR :
 487         LOGD("[%s] END", __func__);
 488
 489         return false;
 490 }
 491
 492 static int _net_nfc_server_handover_iterate_carrier_configs_step(
 493                 net_nfc_server_handover_create_config_context_t *context)
 494 {
 495         LOGD("[%s:%d] START", __func__, __LINE__);
 496
 497         RETV_IF(NULL == context, 0);
 498
 499         if (context->cb != NULL)
 500                 context->cb(NET_NFC_OK, context->ndef_message, context->user_param);
 501
 502         if (context->ndef_message != NULL)
 503                 net_nfc_util_free_ndef_message(context->ndef_message);
 504
 505         _net_nfc_util_free_mem(context);
 506
 507         LOGD("[%s:%d] END", __func__, __LINE__);
 508
 509         return 0;
 510 }
 511
 512 static int _net_nfc_server_handover_iterate_carrier_configs_to_next(
 513                 net_nfc_server_handover_create_config_context_t *context)
 514 {
 515         if (context->result == NET_NFC_OK || context->result == NET_NFC_BUSY)
 516         {
 517                 if (context->type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
 518                 {
 519                         if (context->current_type < NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
 520                                 context->current_type++;
 521                 }
 522                 else
 523                 {
 524                         context->current_type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
 525                 }
 526
 527                 g_idle_add((GSourceFunc)_net_nfc_server_handover_iterate_create_carrier_configs,
 528                                 (gpointer)context);
 529         }
 530         else
 531         {
 532                 NFC_ERR("context->result is error [%d]", context->result);
 533
 534                 g_idle_add((GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_step,
 535                                 (gpointer)context);
 536         }
 537
 538         return 0;
 539 }
 540
 541 static int _net_nfc_server_handover_iterate_create_carrier_configs(
 542                 net_nfc_server_handover_create_config_context_t *context)
 543 {
 544         LOGD("[%s:%d] START", __func__, __LINE__);
 545         net_nfc_error_e result = NET_NFC_OK;
 546
 547         switch (context->current_type)
 548         {
 549 /*
 550         case NET_NFC_CONN_HANDOVER_CARRIER_BT :
 551                 NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_BT]");
 552                 net_nfc_server_handover_bt_get_carrier_record(
 553                                 _net_nfc_server_handover_bt_get_carrier_record_cb, context);
 554                 break;
 555 */
 556         case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS :
 557                 NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
 558
 559 #ifdef TARGET
 560                 if(memcmp(context->ndef_message->records->type_s.buffer ,CH_SEL_RECORD_TYPE,
 561                                         context->ndef_message->records->type_s.length)==0)
 562                 {
 563                         result = net_nfc_server_handover_bss_wfd_get_carrier_record(
 564                                         _net_nfc_server_handover_bss_get_carrier_record_cb, context);
 565                 }
 566                 else
 567 #endif
 568                 {
 569                         result = net_nfc_server_handover_bss_get_carrier_record(
 570                                         _net_nfc_server_handover_bss_get_carrier_record_cb, context);
 571                 }
 572                 NFC_DBG("[%d]",result);
 573                 break;
 574
 575                 //      case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS :
 576                 //              NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
 577                 //              g_idle_add(
 578                 //              (GSourceFunc)_net_nfc_server_handover_append_wifi_carrier_config,
 579                 //                      context);
 580                 //              break;
 581
 582         case NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN :
 583                 NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN]");
 584                 g_idle_add((GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_step,
 585                                 (gpointer)context);
 586                 break;
 587
 588         default :
 589                 NFC_DBG("[unknown : %d]", context->current_type);
 590                 g_idle_add((GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_step,
 591                                 (gpointer)context);
 592                 break;
 593         }
 594
 595         LOGD("[%s:%d] END", __func__, __LINE__);
 596
 597         return 0;
 598 }
 599
 600 static net_nfc_error_e
 601 _net_nfc_server_handover_create_requester_carrier_configs(
 602                 net_nfc_conn_handover_carrier_type_e type, void *cb, void *user_param)
 603 {
 604         net_nfc_error_e result = NET_NFC_OK;
 605         net_nfc_server_handover_create_config_context_t *context = NULL;
 606
 607         LOGD("[%s:%d] START", __func__, __LINE__);
 608
 609         _net_nfc_util_alloc_mem(context, sizeof(*context));
 610         if (context != NULL)
 611         {
 612                 context->type = type;
 613                 if (type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
 614                         context->current_type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
 615                 else
 616                         context->current_type = context->type;
 617
 618                 context->cb = cb;
 619                 context->user_param = user_param;
 620                 net_nfc_util_create_handover_request_message(&context->ndef_message);
 621
 622                 /* append carrier record */
 623                 g_idle_add((GSourceFunc)_net_nfc_server_handover_iterate_create_carrier_configs,
 624                                 (gpointer)context);
 625         }
 626         else
 627         {
 628                 NFC_ERR("alloc failed");
 629                 result = NET_NFC_ALLOC_FAIL;
 630         }
 631
 632         LOGD("[%s:%d] END", __func__, __LINE__);
 633
 634         return result;
 635 }
 636
 637 static net_nfc_error_e
 638 _net_nfc_server_handover_create_selector_carrier_configs(
 639                 net_nfc_conn_handover_carrier_type_e type, void *cb, void *user_param)
 640 {
 641         net_nfc_error_e result = NET_NFC_OK;
 642         net_nfc_server_handover_create_config_context_t *context = NULL;
 643
 644         LOGD("[%s:%d] START", __func__, __LINE__);
 645
 646         _net_nfc_util_alloc_mem(context, sizeof(*context));
 647         if (context != NULL)
 648         {
 649                 context->type = type;
 650                 if (type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
 651                         context->current_type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
 652                 else
 653                         context->current_type = context->type;
 654
 655                 context->cb = cb;
 656                 context->user_param = user_param;
 657                 net_nfc_util_create_handover_select_message(&context->ndef_message);
 658
 659                 /* append carrier record */
 660                 g_idle_add((GSourceFunc)_net_nfc_server_handover_iterate_create_carrier_configs,
 661                                 (gpointer)context);
 662         }
 663         else
 664         {
 665                 NFC_ERR("alloc failed");
 666                 result = NET_NFC_ALLOC_FAIL;
 667         }
 668
 669         LOGD("[%s:%d] END", __func__, __LINE__);
 670
 671         return result;
 672 }
 673
 674 net_nfc_error_e net_nfc_server_handover_process_carrier_record(
 675                 ndef_record_s *carrier, void *cb, void *user_param)
 676 {
 677         net_nfc_error_e result = NET_NFC_OK;
 678         net_nfc_server_handover_process_config_context_t *context = NULL;
 679
 680         LOGD("[%s:%d] START", __func__, __LINE__);
 681
 682         _net_nfc_util_alloc_mem(context, sizeof(*context));
 683         if (context != NULL)
 684         {
 685                 net_nfc_conn_handover_carrier_type_e type;
 686
 687                 net_nfc_util_get_alternative_carrier_type_from_record(carrier, &type);
 688
 689                 context->type = type;
 690                 context->user_param = user_param;
 691                 context->cb = cb;
 692                 context->step = NET_NFC_LLCP_STEP_01;
 693
 694                 /* process carrier record */
 695                 switch (type)
 696                 {
 697                 /*
 698                 case NET_NFC_CONN_HANDOVER_CARRIER_BT :
 699                         NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_BT]");
 700                         net_nfc_server_handover_bt_process_carrier_record(carrier,
 701                                         _net_nfc_server_handover_bt_process_carrier_record_cb, context);
 702                         break;
 703                 */
 704
 705                 case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS :
 706                         NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
 707                         net_nfc_server_handover_bss_process_carrier_record(carrier,
 708                                         _net_nfc_server_handover_bss_process_carrier_record_cb, context);
 709                         break;
 710
 711                 case NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN :
 712                         NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN]");
 713                         _net_nfc_util_free_mem(context);
 714                         break;
 715
 716                 default :
 717                         NFC_DBG("[unknown]");
 718                         _net_nfc_util_free_mem(context);
 719                         break;
 720                 }
 721         }
 722         else
 723         {
 724                 NFC_ERR("alloc failed");
 725                 result = NET_NFC_ALLOC_FAIL;
 726         }
 727
 728         LOGD("[%s:%d] END", __func__, __LINE__);
 729
 730         return result;
 731 }
 732
 733 static net_nfc_error_e _net_nfc_server_handover_select_carrier_record(
 734                 ndef_message_s *request,
 735                 net_nfc_conn_handover_carrier_type_e *type,
 736                 ndef_record_s **record)
 737 {
 738         uint32_t count;
 739         net_nfc_error_e result;
 740
 741         *record = NULL;
 742         *type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
 743
 744         /* get requester message */
 745         result = net_nfc_util_get_alternative_carrier_record_count(request, &count);
 746         if (NET_NFC_OK == result)
 747         {
 748                 if (1/* power state */ || 1 == count)
 749                 {
 750                         ndef_record_s *temp;
 751
 752                         /* fill alternative carrier information */
 753                         result = net_nfc_server_handover_get_carrier_record_by_priority_order(
 754                                                         request, &temp);
 755                         if (NET_NFC_OK == result)
 756                         {
 757                                 result = net_nfc_util_get_alternative_carrier_type_from_record(temp, type);
 758                                 if (NET_NFC_OK == result)
 759                                 {
 760                                         net_nfc_util_create_record(temp->TNF, &temp->type_s, &temp->id_s,
 761                                                         &temp->payload_s, record);
 762                                 }
 763                                 else
 764                                 {
 765                                         NFC_ERR("net_nfc_util_get_alternative"
 766                                                         "_carrier_type_from_record failed [%d]", result);
 767                                 }
 768                         }
 769                         else
 770                         {
 771                                 NFC_ERR("_handover_get_carrier_record_by_priority_order failed [%d]", result);
 772                         }
 773                 }
 774                 else /* low power && count > 1 */
 775                 {
 776                         result = NET_NFC_INVALID_STATE;
 777                 }
 778         }
 779         else
 780         {
 781                 NFC_ERR("net_nfc_util_get_alternative_carrier_record_count failed [%d]", result);
 782         }
 783
 784         return result;
 785 }
 786
 787 static void _net_nfc_server_handover_create_carrier_configs_2_cb(
 788                 net_nfc_error_e result, ndef_message_s *selector, void *user_param)
 789 {
 790         net_nfc_handover_context_t *context = user_param;
 791
 792         RET_IF(NULL == context);
 793
 794         NFC_DBG("_net_nfc_server_handover_server_create_carrier_config_cb result [%d]",
 795                         result);
 796
 797         context->result = result;
 798
 799         if (NET_NFC_OK == result)
 800         {
 801                 result = _net_nfc_server_handover_convert_ndef_message_to_data(
 802                                 selector, &context->data);
 803
 804                 NFC_DBG("selector message created, length [%d]", context->data.length);
 805
 806                 context->state = NET_NFC_LLCP_STEP_03;
 807         }
 808         else
 809         {
 810                 NFC_ERR("_net_nfc_server_handover_create_selector_msg failed [%d]", result);
 811                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
 812         }
 813
 814         _net_nfc_server_handover_get_response_process(context);
 815 }
 816
 817 static void _net_nfc_server_handover_process_carrier_record_2_cb(
 818                 net_nfc_error_e result,
 819                 net_nfc_conn_handover_carrier_type_e type,
 820                 data_s *data,
 821                 void *user_param)
 822 {
 823         net_nfc_handover_context_t *context = (net_nfc_handover_context_t *)user_param;
 824
 825         NFC_DBG("_net_nfc_server_handover_server_process_carrier_record_cb result [%d]",
 826                         result);
 827
 828         context->result = result;
 829         if (NET_NFC_OK == result)
 830                 context->state = NET_NFC_LLCP_STEP_04;
 831         else
 832                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
 833
 834         context->data.length = data->length;
 835         _net_nfc_util_alloc_mem(context->data.buffer, context->data.length);
 836         memcpy(context->data.buffer, data->buffer, context->data.length);
 837
 838
 839         _net_nfc_server_handover_server_process(context);
 840 }
 841
 842 static void _net_nfc_server_handover_get_response_process(
 843                 net_nfc_handover_context_t *context)
 844 {
 845         net_nfc_error_e result;
 846
 847         RET_IF(NULL == context);
 848
 849         switch (context->state)
 850         {
 851         case NET_NFC_LLCP_STEP_02 :
 852                 NFC_DBG("NET_NFC_LLCP_STEP_02");
 853
 854                 result = _net_nfc_server_handover_create_selector_carrier_configs(
 855                                 context->type, _net_nfc_server_handover_create_carrier_configs_2_cb, context);
 856
 857                 if (result != NET_NFC_OK)
 858                 {
 859                         NFC_ERR("_net_nfc_server_handover_create_"
 860                                         "selector_carrier_config failed [%d]",result);
 861                 }
 862                 break;
 863
 864         case NET_NFC_LLCP_STEP_03 :
 865                 NFC_DBG("NET_NFC_LLCP_STEP_03");
 866
 867                 result = net_nfc_server_handover_process_carrier_record(
 868                                 context->record,
 869                                 _net_nfc_server_handover_process_carrier_record_2_cb,
 870                                 context);
 871
 872                 if (result != NET_NFC_OK)
 873                 {
 874                         NFC_ERR("net_nfc_server_handover_process_carrier_record failed [%d]",result);
 875                 }
 876                 break;
 877
 878         case NET_NFC_LLCP_STEP_04 :
 879                 NFC_DBG("NET_NFC_LLCP_STEP_04");
 880
 881                 /* response select message */
 882                 // TODO: context->handle may is not valid type. we should find a right function or parameter
 883                 result = net_nfc_server_snep_server_send_get_response(
 884                                 (net_nfc_snep_handle_h)context->handle, &context->data);
 885                 break;
 886
 887         case NET_NFC_STATE_ERROR :
 888                 NFC_DBG("NET_NFC_STATE_ERROR");
 889                 break;
 890
 891         default :
 892                 NFC_ERR("NET_NFC_LLCP_STEP_??");
 893                 /* TODO */
 894                 break;
 895         }
 896 }
 897
 898 static bool _net_nfc_server_handover_get_response_cb(
 899                 net_nfc_snep_handle_h handle,
 900                 uint32_t type,
 901                 uint32_t max_len,
 902                 data_s *data,
 903                 void *user_param)
 904 {
 905         net_nfc_error_e result;
 906         ndef_message_s *request;
 907
 908         RETV_IF(NULL == data, false);
 909         RETV_IF(NULL == data->buffer, false);
 910
 911         NFC_DBG("type [%d], data [%p], user_param [%p]", type, data, user_param);
 912
 913         /* TODO : send select response to requester */
 914         result = _net_nfc_server_handover_create_requester_from_rawdata(&request, data);
 915
 916         if (NET_NFC_OK == result)
 917         {
 918                 ndef_record_s *record;
 919                 net_nfc_conn_handover_carrier_type_e type;
 920
 921                 result = _net_nfc_server_handover_select_carrier_record(request, &type, &record);
 922                 if (NET_NFC_OK == result)
 923                 {
 924                         net_nfc_handover_context_t *context = NULL;
 925
 926                         _net_nfc_util_alloc_mem(context, sizeof(*context));
 927
 928                         if (context != NULL)
 929                         {
 930                                 context->handle = (void *)handle;
 931                                 context->type = type;
 932                                 context->user_param = user_param;
 933                                 context->state = NET_NFC_LLCP_STEP_02;
 934
 935                                 net_nfc_util_create_record(record->TNF, &record->type_s, &record->id_s,
 936                                                 &record->payload_s, &context->record);
 937
 938                                 _net_nfc_server_handover_get_response_process(context);
 939                         }
 940                         else
 941                         {
 942                                 NFC_ERR("_net_nfc_util_alloc_mem failed");
 943                                 result = NET_NFC_ALLOC_FAIL;
 944                         }
 945                 }
 946                 else
 947                 {
 948                         /* low power */
 949                 }
 950
 951                 net_nfc_util_free_ndef_message(request);
 952         }
 953         else
 954         {
 955                 NFC_ERR("it is not handover requester message, [%d]", result);
 956         }
 957
 958         return (NET_NFC_OK == result);
 959 }
 960
 961 ////////////////////////////////////////////////////////////////////////////////
 962 static void _net_nfc_server_handover_server_process_carrier_record_cb(
 963                 net_nfc_error_e result,
 964                 net_nfc_conn_handover_carrier_type_e type,
 965                 data_s *data,
 966                 void *user_param)
 967 {
 968         net_nfc_handover_context_t *context = user_param;
 969
 970         NFC_DBG("_net_nfc_server_handover_server_process_carrier_record_cb result [%d]",
 971                         result);
 972
 973         context->result = result;
 974
 975         if (NET_NFC_OK == result)
 976                 context->state = NET_NFC_LLCP_STEP_04;
 977         else
 978                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
 979
 980         _net_nfc_server_handover_server_process(context);
 981 }
 982
 983 static void _net_nfc_server_handover_server_create_carrier_config_cb(
 984                 net_nfc_error_e result, ndef_message_s *selector, void *user_param)
 985 {
 986         net_nfc_conn_handover_carrier_type_e type;
 987         net_nfc_handover_context_t *context = user_param;
 988
 989         RET_IF(NULL == context);
 990
 991         NFC_DBG("_net_nfc_server_handover_server_create_carrier_config_cb,result [%d]",
 992                         result);
 993
 994         context->result = result;
 995
 996         net_nfc_util_get_alternative_carrier_type_from_record(context->record, &type);
 997         if (NET_NFC_OK == result)
 998         {
 999                 result = _net_nfc_server_handover_convert_ndef_message_to_data(
1000                                 selector, &context->data);
1001                 NFC_DBG("selector message created, length [%d]", context->data.length);
1002                 if(type == NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS)
1003                         context->state = NET_NFC_LLCP_STEP_04;
1004                 else
1005                         context->state = NET_NFC_LLCP_STEP_03;
1006         }
1007         else
1008         {
1009                 NFC_ERR("_net_nfc_server_handover_create_selector_msg failed [%d]", result);
1010                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1011         }
1012
1013         _net_nfc_server_handover_server_process(context);
1014 }
1015
1016 static void _net_nfc_server_handover_server_recv_cb(
1017                 net_nfc_error_e result,
1018                 net_nfc_target_handle_s *handle,
1019                 net_nfc_llcp_socket_t socket,
1020                 data_s *data,
1021                 void *user_param)
1022 {
1023         net_nfc_error_e ret;
1024         ndef_message_s *request;
1025         net_nfc_handover_context_t *context = user_param;
1026
1027         NFC_DBG("_net_nfc_server_handover_server_recv_cb, socket [%x], result [%d]",
1028                         socket, result);
1029
1030         context->result = result;
1031
1032         if (NET_NFC_OK == result)
1033         {
1034                 result = _net_nfc_server_handover_create_requester_from_rawdata(&request, data);
1035
1036                 if (NET_NFC_OK == result)
1037                 {
1038                         ndef_record_s *record;
1039
1040                         ret = _net_nfc_server_handover_select_carrier_record(request,
1041                                                 &context->type, &record);
1042
1043                         if (NET_NFC_OK == ret)
1044                         {
1045                                 net_nfc_util_create_record(record->TNF, &record->type_s, &record->id_s,
1046                                                 &record->payload_s, &context->record);
1047
1048                                 context->state = NET_NFC_LLCP_STEP_02;
1049                         }
1050                         else
1051                         {
1052                                 /* low power */
1053                                 context->state = NET_NFC_LLCP_STEP_06;
1054                         }
1055
1056                         net_nfc_util_free_ndef_message(request);
1057                 }
1058                 else
1059                 {
1060                         NFC_ERR("_net_nfc_server_handover_create"
1061                                         "_requester_from_rawdata failed [%d]",result);
1062                         context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1063                 }
1064         }
1065         else
1066         {
1067                 NFC_ERR("net_nfc_server_llcp_simple_receive failed [%d]", result);
1068                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1069         }
1070
1071         _net_nfc_server_handover_server_process(context);
1072 }
1073
1074 static void _net_nfc_server_handover_server_send_cb(net_nfc_error_e result,
1075                 net_nfc_target_handle_s *handle,
1076                 net_nfc_llcp_socket_t socket,
1077                 data_s *data,
1078                 void *user_param)
1079 {
1080         net_nfc_handover_context_t *context = user_param;
1081
1082         NFC_DBG("_net_nfc_server_handover_server_send_cb socket[%x], result[%d]",
1083                         socket, result);
1084
1085         context->result = result;
1086
1087         if (NET_NFC_OK == result)
1088         {
1089                 context->state = NET_NFC_LLCP_STEP_01;
1090                 net_nfc_util_free_data(&context->data);
1091                 net_nfc_util_free_record(context->record);
1092                 context->record = NULL;
1093         }
1094         else
1095         {
1096                 NFC_ERR("net_nfc_server_llcp_simple_send failed [%d]", result);
1097                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1098         }
1099
1100         _net_nfc_server_handover_server_process(context);
1101 }
1102
1103 static void _net_nfc_server_handover_server_process(
1104                 net_nfc_handover_context_t *context)
1105 {
1106         RET_IF(NULL == context);
1107
1108         switch (context->state)
1109         {
1110         case NET_NFC_LLCP_STEP_01 :
1111                 NFC_DBG("NET_NFC_LLCP_STEP_01");
1112
1113                 /* receive request message */
1114                 net_nfc_server_llcp_simple_receive(context->handle, context->socket,
1115                                 _net_nfc_server_handover_server_recv_cb, context);
1116                 break;
1117
1118         case NET_NFC_LLCP_STEP_02 :
1119                 NFC_DBG("NET_NFC_LLCP_STEP_02");
1120
1121                 context->result = _net_nfc_server_handover_create_selector_carrier_configs(
1122                                 context->type,
1123                                 _net_nfc_server_handover_server_create_carrier_config_cb,
1124                                 context);
1125
1126                 if (context->result != NET_NFC_OK)
1127                 {
1128                         NFC_ERR("_net_nfc_server_handover_create_selector"
1129                                         "_carrier_configs failed [%d]", context->result);
1130                 }
1131                 break;
1132
1133         case NET_NFC_LLCP_STEP_03 :
1134                 NFC_DBG("NET_NFC_LLCP_STEP_03");
1135
1136                 context->result = net_nfc_server_handover_process_carrier_record(
1137                                 context->record,
1138                                 _net_nfc_server_handover_server_process_carrier_record_cb,
1139                                 context);
1140
1141                 if (context->result != NET_NFC_OK)
1142                 {
1143                         NFC_ERR("_net_nfc_server_handover_process_carrier_"
1144                                         "record failed [%d]",context->result);
1145                 }
1146                 break;
1147
1148         case NET_NFC_LLCP_STEP_04 :
1149                 NFC_DBG("NET_NFC_LLCP_STEP_04");
1150
1151                 /* send select message */
1152                 net_nfc_server_llcp_simple_send(context->handle, context->socket, &context->data,
1153                                 _net_nfc_server_handover_server_send_cb, context);
1154                 break;
1155
1156         case NET_NFC_STATE_ERROR :
1157                 NFC_DBG("NET_NFC_STATE_ERROR");
1158
1159                 /* error, invoke callback */
1160                 NFC_ERR("handover_server failed, [%d]", context->result);
1161
1162                 /* restart?? */
1163                 break;
1164
1165         default :
1166                 NFC_ERR("NET_NFC_LLCP_STEP_??");
1167                 /* TODO */
1168                 break;
1169         }
1170 }
1171
1172 static void _net_nfc_server_handover_server_error_cb(
1173                 net_nfc_error_e result,
1174                 net_nfc_target_handle_s *handle,
1175                 net_nfc_llcp_socket_t socket,
1176                 data_s *data,
1177                 void *user_param)
1178 {
1179         net_nfc_handover_context_t *context = user_param;
1180
1181         NFC_ERR("result [%d], socket [%x], user_param [%p]", result, socket, user_param);
1182
1183         RET_IF(NULL == context);
1184
1185         net_nfc_controller_llcp_socket_close(socket, &result);
1186
1187         net_nfc_util_free_record(context->record);
1188         net_nfc_util_free_data(&context->data);
1189         _net_nfc_util_free_mem(user_param);
1190 }
1191
1192 static void _net_nfc_server_handover_server_incomming_cb(
1193                 net_nfc_error_e result,
1194                 net_nfc_target_handle_s *handle,
1195                 net_nfc_llcp_socket_t socket,
1196                 data_s *data,
1197                 void *user_param)
1198 {
1199         net_nfc_handover_context_t *accept_context = NULL;
1200
1201         NFC_DBG("result[%d], socket[%x], user_param[%p]", result, socket, user_param);
1202
1203         _net_nfc_util_alloc_mem(accept_context, sizeof(*accept_context));
1204         if (NULL == accept_context)
1205         {
1206                 NFC_ERR("_net_nfc_util_alloc_mem failed");
1207
1208                 result = NET_NFC_ALLOC_FAIL;
1209                 goto ERROR;
1210         }
1211
1212         accept_context->handle = handle;
1213         accept_context->socket = socket;
1214         accept_context->state = NET_NFC_LLCP_STEP_01;
1215
1216         result = net_nfc_server_llcp_simple_accept(handle, socket,
1217                         _net_nfc_server_handover_server_error_cb, accept_context);
1218
1219         if (result != NET_NFC_OK)
1220         {
1221                 NFC_ERR("net_nfc_server_llcp_simple_accept failed, [%d]", result);
1222
1223                 goto ERROR;
1224         }
1225
1226         _net_nfc_server_handover_server_process(accept_context);
1227
1228         return;
1229
1230 ERROR :
1231         if (accept_context != NULL)
1232                 _net_nfc_util_free_mem(accept_context);
1233
1234         net_nfc_controller_llcp_socket_close(socket, &result);
1235
1236         /* TODO : restart ?? */
1237 }
1238
1239 net_nfc_error_e net_nfc_server_handover_default_server_start(
1240                 net_nfc_target_handle_s *handle)
1241 {
1242         net_nfc_error_e result;
1243
1244         /* start default handover server using snep */
1245         result = net_nfc_server_snep_default_server_register_get_response_cb(
1246                                         _net_nfc_server_handover_get_response_cb, NULL);
1247
1248         /* start default handover server */
1249         result = net_nfc_server_llcp_simple_server(
1250                         handle,
1251                         CH_SAN,
1252                         CH_SAP,
1253                         _net_nfc_server_handover_server_incomming_cb,
1254                         _net_nfc_server_handover_server_error_cb,
1255                         NULL);
1256
1257         if (NET_NFC_OK == result)
1258                 NFC_DBG("start handover server, san[%s], sap[%d]", CH_SAN, CH_SAP);
1259         else
1260                 NFC_ERR("net_nfc_server_llcp_simple_server failed, [%d]", result);
1261
1262         return result;
1263 }
1264
1265 static void _handover_default_activate_cb(int event,
1266                 net_nfc_target_handle_s *handle,uint32_t sap, const char *san, void *user_param)
1267 {
1268         net_nfc_error_e result;
1269
1270         NFC_DBG("event [%d], handle [%p], sap [%d], san [%s]", event, handle, sap, san);
1271
1272         if (NET_NFC_LLCP_START == event)
1273         {
1274                 /* start default handover server using snep */
1275                 result = net_nfc_server_snep_default_server_register_get_response_cb(
1276                                 _net_nfc_server_handover_get_response_cb, NULL);
1277
1278                 /* start default handover server */
1279                 result = net_nfc_server_llcp_simple_server(handle,
1280                                 CH_SAN, CH_SAP,
1281                                 _net_nfc_server_handover_server_incomming_cb,
1282                                 _net_nfc_server_handover_server_error_cb, NULL);
1283
1284                 if (NET_NFC_OK == result)
1285                         NFC_DBG("start handover server, san [%s], sap [%d]", CH_SAN, CH_SAP);
1286                 else
1287                         NFC_ERR("net_nfc_service_llcp_server failed, [%d]", result);
1288
1289         }
1290         else if (NET_NFC_LLCP_UNREGISTERED == event)
1291         {
1292                 /* unregister server, do nothing */
1293         }
1294 }
1295
1296 net_nfc_error_e net_nfc_server_handover_default_server_register()
1297 {
1298         char id[20];
1299
1300         /* TODO : make id, */
1301         snprintf(id, sizeof(id), "%d", getpid());
1302
1303         /* start default snep server */
1304         return net_nfc_server_llcp_register_service(id, CH_SAP, CH_SAN,
1305                         _handover_default_activate_cb, NULL);
1306 }
1307
1308 net_nfc_error_e net_nfc_server_handover_default_server_unregister()
1309 {
1310         char id[20];
1311
1312         /* TODO : make id, */
1313         snprintf(id, sizeof(id), "%d", getpid());
1314
1315         /* start default snep server */
1316         return net_nfc_server_llcp_unregister_service(id, CH_SAP, CH_SAN);
1317 }
1318
1319 ////////////////////////////////////////////////////////////////////////////////
1320
1321 static void _net_nfc_server_handover_client_process_carrier_record_cb(
1322                 net_nfc_error_e result,
1323                 net_nfc_conn_handover_carrier_type_e type,
1324                 data_s *data,
1325                 void *user_param)
1326 {
1327         net_nfc_handover_context_t *context = user_param;
1328
1329         NFC_DBG("_net_nfc_server_handover_server_process_carrier_record_cb, result[%d]",
1330                         result);
1331
1332         context->result = result;
1333
1334         net_nfc_util_free_data(&context->data);
1335
1336         if (NET_NFC_OK == result)
1337         {
1338                 if(context->type == NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS)
1339                 {
1340                         context->state = NET_NFC_LLCP_STEP_RETURN;
1341                 }
1342                 else
1343                 {
1344                         net_nfc_util_alloc_data(&context->data, data->length);
1345                         memcpy(context->data.buffer, data->buffer, data->length);
1346
1347                         context->state = NET_NFC_LLCP_STEP_05;
1348                 }
1349         }
1350         else
1351         {
1352                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1353         }
1354
1355         _net_nfc_server_handover_client_process(context);
1356 }
1357
1358 static void _net_nfc_server_handover_client_recv_cb(net_nfc_error_e result,
1359                 net_nfc_target_handle_s *handle,
1360                 net_nfc_llcp_socket_t socket,
1361                 data_s *data,
1362                 void *user_param)
1363 {
1364         net_nfc_handover_context_t *context = user_param;
1365
1366         RET_IF(NULL == context);
1367
1368         context->result = result;
1369
1370         if (NET_NFC_OK == result)
1371         {
1372                 ndef_record_s *record;
1373                 ndef_message_s *selector;
1374
1375                 result = net_nfc_server_handover_create_selector_from_rawdata(&selector, data);
1376
1377                 if (NET_NFC_OK == result)
1378                 {
1379                         result = net_nfc_server_handover_get_carrier_record_by_priority_order(
1380                                                 selector, &record);
1381
1382                         if (NET_NFC_OK == result)
1383                         {
1384                                 net_nfc_util_create_record(record->TNF, &record->type_s, &record->id_s,
1385                                                 &record->payload_s, &context->record);
1386
1387                                 context->state = NET_NFC_LLCP_STEP_04;
1388                         }
1389                         else
1390                         {
1391                                 NFC_ERR("_get_carrier_record_by_priority_order failed, [%d]",result);
1392                                 context->state = NET_NFC_STATE_ERROR;
1393                         }
1394                 }
1395                 else
1396                 {
1397                         NFC_ERR("_net_nfc_server_handover_create"
1398                                         "_selector_from_rawdata failed, [%d]",result);
1399                         context->state = NET_NFC_STATE_ERROR;
1400                 }
1401         }
1402         else
1403         {
1404                 NFC_ERR("net_nfc_server_llcp_simple_receive failed, [%d]", result);
1405                 context->state = NET_NFC_STATE_ERROR;
1406         }
1407
1408         _net_nfc_server_handover_client_process(context);
1409 }
1410
1411 static void _net_nfc_server_handover_client_send_cb(net_nfc_error_e result,
1412                 net_nfc_target_handle_s *handle,
1413                 net_nfc_llcp_socket_t socket,
1414                 data_s *data,
1415                 void *user_param)
1416 {
1417         net_nfc_handover_context_t *context = user_param;
1418
1419         RET_IF(NULL == context);
1420
1421         context->result = result;
1422
1423         net_nfc_util_free_data(&context->data);
1424
1425         if (NET_NFC_OK == result)
1426         {
1427                 context->state = NET_NFC_LLCP_STEP_03;
1428         }
1429         else
1430         {
1431                 NFC_ERR("net_nfc_server_llcp_simple_client failed, [%d]", result);
1432                 context->state = NET_NFC_STATE_ERROR;
1433         }
1434
1435         _net_nfc_server_handover_client_process(context);
1436 }
1437
1438 static void _net_nfc_server_handover_client_create_carrier_configs_cb(
1439                 net_nfc_error_e result, ndef_message_s *msg, void *user_param)
1440 {
1441         net_nfc_handover_context_t *context = user_param;
1442
1443         RET_IF(NULL == context);
1444
1445         context->result = result;
1446
1447         if (msg != NULL)
1448         {
1449                 result = _net_nfc_server_handover_convert_ndef_message_to_data(msg, &context->data);
1450                 if (NET_NFC_OK == result)
1451                 {
1452                         context->state = NET_NFC_LLCP_STEP_02;
1453                 }
1454                 else
1455                 {
1456                         NFC_ERR("_net_nfc_server_handover_convert_ndef_"
1457                                         "message_to_data failed [%d]",result);
1458                         context->state = NET_NFC_STATE_ERROR;
1459                         context->result = result;
1460                 }
1461         }
1462         else
1463         {
1464                 NFC_ERR("null param, [%d]", result);
1465                 context->state = NET_NFC_STATE_ERROR;
1466                 context->result = result;
1467         }
1468
1469         _net_nfc_server_handover_client_process(context);
1470 }
1471
1472
1473 ////////////////////////////////////////////////////////////////////////////////
1474 static void _net_nfc_server_handover_client_process(
1475                 net_nfc_handover_context_t *context)
1476 {
1477         net_nfc_error_e result;
1478
1479         RET_IF(NULL == context);
1480
1481         switch (context->state)
1482         {
1483         case NET_NFC_LLCP_STEP_01 :
1484                 NFC_DBG("NET_NFC_LLCP_STEP_01");
1485
1486                 result = _net_nfc_server_handover_create_requester_carrier_configs(
1487                                                 context->type,
1488                                                 _net_nfc_server_handover_client_create_carrier_configs_cb,
1489                                                 context);
1490                 if (result != NET_NFC_OK)
1491                 {
1492                         NFC_ERR("_net_nfc_server_handover_create_requester"
1493                                         "_carrier_configs failed [%d]",result);
1494                 }
1495                 break;
1496
1497         case NET_NFC_LLCP_STEP_02 :
1498                 NFC_DBG("NET_NFC_LLCP_STEP_02");
1499
1500                 /* send request */
1501                 net_nfc_server_llcp_simple_send(context->handle, context->socket, &context->data,
1502                                 _net_nfc_server_handover_client_send_cb, context);
1503                 break;
1504
1505         case NET_NFC_LLCP_STEP_03 :
1506                 NFC_DBG("NET_NFC_LLCP_STEP_03");
1507
1508                 /* receive response */
1509                 net_nfc_server_llcp_simple_receive(context->handle, context->socket,
1510                                 _net_nfc_server_handover_client_recv_cb, context);
1511                 break;
1512
1513         case NET_NFC_LLCP_STEP_04 :
1514                 NFC_DBG("NET_NFC_LLCP_STEP_04");
1515
1516                 result = net_nfc_server_handover_process_carrier_record(context->record,
1517                                 _net_nfc_server_handover_client_process_carrier_record_cb, context);
1518
1519                 if (result != NET_NFC_OK)
1520                         NFC_ERR("net_nfc_server_handover_process_carrier_record failed [%d]",result);
1521                 break;
1522
1523         case NET_NFC_LLCP_STEP_05 :
1524                 NFC_DBG("NET_NFC_LLCP_STEP_05");
1525
1526                 /* start post process */
1527                 if (NET_NFC_CONN_HANDOVER_CARRIER_BT == context->type)
1528                 {
1529                         /*
1530                         net_nfc_server_handover_bt_post_process(&context->data,
1531                                         _net_nfc_server_handover_client_post_process_cb, context);
1532                         */
1533                 }
1534                 else
1535                 {
1536                         NFC_ERR("not supported...");
1537                 }
1538                 break;
1539
1540         case NET_NFC_LLCP_STEP_RETURN :
1541                 NFC_DBG("NET_NFC_LLCP_STEP_RETURN");
1542
1543                 /* complete and invoke callback */
1544                 _net_nfc_server_handover_send_response(context->result, context->type,
1545                                 &context->data, context->user_param);
1546
1547                 net_nfc_util_free_data(&context->data);
1548                 net_nfc_util_free_record(context->record);
1549                 _net_nfc_util_free_mem(context);
1550                 break;
1551
1552         case NET_NFC_STATE_ERROR :
1553         default :
1554                 NFC_ERR("NET_NFC_STATE_ERROR");
1555
1556                 _net_nfc_server_handover_send_response(context->result, context->type,
1557                                 NULL, context->user_param);
1558                 break;
1559         }
1560 }
1561
1562
1563
1564 static void _net_nfc_server_handover_client_connected_cb(
1565                 net_nfc_error_e result,
1566                 net_nfc_target_handle_s *handle,
1567                 net_nfc_llcp_socket_t socket,
1568                 data_s *data,
1569                 void *user_param)
1570 {
1571         NFC_DBG("result [%d], socket [%x], user_param [%p]", result, socket, user_param);
1572
1573         HandoverRequestData *handover_data = NULL;
1574         handover_data = (HandoverRequestData *)user_param;
1575         if (NET_NFC_OK == result)
1576         {
1577                 net_nfc_handover_context_t *context = NULL;
1578                 _net_nfc_util_alloc_mem(context, sizeof(*context));
1579
1580                 if (context != NULL)
1581                 {
1582                         context->handle = handle;
1583                         context->socket = socket;
1584                         context->state = NET_NFC_LLCP_STEP_01;
1585                         context->type = handover_data->type;
1586                         context->user_param = user_param;
1587                         _net_nfc_server_handover_client_process(context);
1588                 }
1589                 else
1590                 {
1591                         NFC_ERR("_net_nfc_util_alloc_mem failed");
1592                         result = NET_NFC_ALLOC_FAIL;
1593                 }
1594         }
1595         else
1596         {
1597                 NFC_ERR("net_nfc_server_llcp_simple_client"
1598                                 " failed, [%d]", result);
1599         }
1600 }
1601
1602 static void _net_nfc_server_handover_client_error_cb(
1603                 net_nfc_error_e result,
1604                 net_nfc_target_handle_s *handle,
1605                 net_nfc_llcp_socket_t socket,
1606                 data_s *data,
1607                 void *user_param)
1608 {
1609         NFC_ERR("result [%d], socket [%x], user_param [%p]", result, socket, user_param);
1610
1611         if (false)
1612         {
1613                 _net_nfc_server_handover_send_response(result,
1614                                 NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN, NULL, user_param);
1615         }
1616
1617         net_nfc_controller_llcp_socket_close(socket, &result);
1618 }
1619
1620
1621 net_nfc_error_e net_nfc_server_handover_default_client_start(
1622                 net_nfc_target_handle_s *handle, void *user_data)
1623 {
1624         net_nfc_error_e result;
1625
1626         result = net_nfc_server_llcp_simple_client(
1627                         handle,
1628                         CH_SAN,
1629                         CH_SAP,
1630                         _net_nfc_server_handover_client_connected_cb,
1631                         _net_nfc_server_handover_client_error_cb,
1632                         user_data);
1633
1634         if (result != NET_NFC_OK)
1635                 NFC_ERR("net_nfc_server_llcp_simple_client failed, [%d]",result);
1636
1637         return result;
1638 }