daemon/net_nfc_server_process_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 #include "bluetooth-api.h"
  18 #include "net_nfc_server_handover.h"
  19 #include "net_nfc_debug_internal.h"
  20 #include "net_nfc_util_internal.h"
  21 #include "net_nfc_util_ndef_message.h"
  22 #include "net_nfc_util_ndef_record.h"
  23 #include "net_nfc_util_handover.h"
  24 #include "net_nfc_server_controller.h"
  25 #include "net_nfc_server_llcp.h"
  26 #include "net_nfc_server_process_handover.h"
  27 #include "net_nfc_server_process_snep.h"
  28 #include "net_nfc_util_gdbus_internal.h"
  29 #include "net_nfc_server_handover_bss.h"
  30 #include "net_nfc_server_handover_bt.h"
  31
  32 typedef void (*_net_nfc_server_handover_create_carrier_msg_cb)(
  33                 net_nfc_error_e result,
  34                 ndef_message_s *selector,
  35                 void *user_param);
  36
  37 typedef struct _net_nfc_handover_context_t
  38 {
  39         net_nfc_target_handle_s *handle;
  40         net_nfc_error_e result;
  41         net_nfc_llcp_socket_t socket;
  42         uint32_t state;
  43         net_nfc_conn_handover_carrier_type_e type;
  44         data_s data;
  45         ndef_record_s *record;
  46         void *user_param;
  47 }
  48 net_nfc_handover_context_t;
  49
  50 #define NET_NFC_CH_CONTEXT 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_CH_CONTEXT;
  60
  61         _net_nfc_server_handover_create_carrier_msg_cb cb;
  62         net_nfc_conn_handover_carrier_type_e current_type;
  63         ndef_message_s *ndef_message;
  64         ndef_message_s *requester; /* for low power selector */
  65
  66         ndef_record_s *record;
  67 }
  68 net_nfc_server_handover_create_config_context_t;
  69
  70 typedef struct _net_nfc_server_handover_process_config_context_t
  71 {
  72         NET_NFC_CH_CONTEXT;
  73
  74         net_nfc_server_handover_process_carrier_record_cb cb;
  75 }net_nfc_server_handover_process_config_context_t;
  76
  77
  78
  79 static void _net_nfc_server_handover_send_response(void *user_param,
  80                 data_h ac_data,
  81                 net_nfc_error_e result);
  82
  83 static void _net_nfc_server_handover_client_process(
  84                 net_nfc_handover_context_t *context);
  85
  86 static void _net_nfc_server_handover_client_error_cb(
  87                 net_nfc_error_e result,
  88                 net_nfc_target_handle_s *handle,
  89                 net_nfc_llcp_socket_t socket,
  90                 data_s *data,
  91                 void *user_param);
  92
  93 static void _net_nfc_server_handover_client_connected_cb(
  94                 net_nfc_error_e result,
  95                 net_nfc_target_handle_s *handle,
  96                 net_nfc_llcp_socket_t socket,
  97                 data_s *data,
  98                 void *user_param);
  99
 100 static void _net_nfc_server_handover_get_response_process(
 101                 net_nfc_handover_context_t *context);
 102
 103 static net_nfc_error_e
 104 _net_nfc_server_handover_create_requester_from_rawdata(
 105                 ndef_message_s **requestor,
 106                 data_s *data);
 107
 108 static net_nfc_error_e
 109 _net_nfc_server_handover_create_requester_carrier_configs(
 110                 net_nfc_conn_handover_carrier_type_e type,
 111                 void *cb,
 112                 void *user_param);
 113
 114 static bool _net_nfc_server_handover_check_hr_record_validation(
 115                 ndef_message_s *message);
 116
 117 static bool _net_nfc_server_handover_check_hs_record_validation(
 118                 ndef_message_s *message);
 119
 120 static net_nfc_error_e
 121 _net_nfc_server_handover_create_selector_carrier_configs(
 122                 net_nfc_conn_handover_carrier_type_e type,
 123                 void *cb,
 124                 void *user_param);
 125
 126 static int _net_nfc_server_handover_iterate_create_carrier_configs(
 127                 net_nfc_server_handover_create_config_context_t *context);
 128
 129 static int _net_nfc_server_handover_iterate_carrier_configs_to_next(
 130                 net_nfc_server_handover_create_config_context_t *context);
 131
 132 static int _net_nfc_server_handover_iterate_carrier_configs_step(
 133                 net_nfc_server_handover_create_config_context_t *context);
 134
 135 static void _net_nfc_server_handover_server_process(
 136                 net_nfc_handover_context_t *context);
 137
 138 ////////////////////////////////////////////////////////////////////////////
 139
 140 static void _net_nfc_server_handover_send_response(
 141                 void *user_param,
 142                 data_h ac_data,
 143                 net_nfc_error_e result)
 144 {
 145         HandoverRequestData *handover_data = NULL;
 146         guint32 resp_event;
 147         guint32 resp_type;
 148         GVariant* data = NULL;
 149
 150         handover_data = (HandoverRequestData*)user_param;
 151
 152         data = net_nfc_util_gdbus_data_to_variant(ac_data);
 153
 154         resp_type = NET_NFC_MESSAGE_CONNECTION_HANDOVER;
 155
 156         if (result == NET_NFC_OK)
 157                 resp_event = NET_NFC_EXCHANGER_TRANSFER_COMPLETED;
 158         else
 159                 resp_event = NET_NFC_EXCHANGER_TRANSFER_FAILED;
 160
 161         if (handover_data->invocation)
 162         {
 163                 net_nfc_gdbus_handover_complete_request(
 164                                 handover_data->handoverobj,
 165                                 handover_data->invocation,
 166                                 resp_event,
 167                                 resp_type,
 168                                 data);
 169
 170                 g_object_unref(handover_data->invocation);
 171         }
 172
 173         if (handover_data->data)
 174         {
 175                 g_free(handover_data->data->buffer);
 176                 g_free(handover_data->data);
 177         }
 178
 179         g_object_unref(handover_data->handoverobj);
 180
 181         g_free(handover_data);
 182 }
 183
 184 static net_nfc_error_e _net_nfc_server_handover_convert_ndef_message_to_data(
 185                 ndef_message_s *msg,
 186                 data_s *data)
 187 {
 188         net_nfc_error_e result;
 189         uint32_t length;
 190
 191         if (msg == NULL || data == NULL)
 192         {
 193                 return NET_NFC_INVALID_PARAM;
 194         }
 195
 196         length = net_nfc_util_get_ndef_message_length(msg);
 197         if (length > 0)
 198         {
 199                 net_nfc_util_alloc_data(data, length);
 200                 result = net_nfc_util_convert_ndef_message_to_rawdata(msg, data);
 201         }
 202         else
 203         {
 204                 result = NET_NFC_INVALID_PARAM;
 205         }
 206
 207         return result;
 208 }
 209
 210 static void _net_nfc_server_handover_bt_get_carrier_record_cb(
 211                 net_nfc_error_e result,
 212                 net_nfc_conn_handover_carrier_state_e cps,
 213                 ndef_record_s *carrier,
 214                 uint32_t aux_data_count,
 215                 ndef_record_s *aux_data,
 216                 void *user_param)
 217 {
 218         net_nfc_server_handover_create_config_context_t *context =
 219                 (net_nfc_server_handover_create_config_context_t *)user_param;
 220
 221         /* append record to ndef message */
 222         if (result == NET_NFC_OK)
 223         {
 224                 ndef_record_s *record;
 225
 226                 /* FIXME : copy record and append */
 227                 net_nfc_util_create_record(carrier->TNF,
 228                                 &carrier->type_s,
 229                                 &carrier->id_s,
 230                                 &carrier->payload_s,
 231                                 &record);
 232
 233                 if ((result = net_nfc_util_append_carrier_config_record(
 234                                                 context->ndef_message,
 235                                                 record,
 236                                                 cps)) == NET_NFC_OK)
 237                 {
 238                         DEBUG_SERVER_MSG("net_nfc_util_append_carrier"
 239                                         "_config_record success");
 240                 }
 241                 else
 242                 {
 243                         DEBUG_ERR_MSG("net_nfc_util_append_carrier"
 244                                         "_config_record failed [%d]",
 245                                         result);
 246                         net_nfc_util_free_record(record);
 247                 }
 248
 249                 g_idle_add(
 250                                 (GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_to_next,
 251                                 (gpointer)context);
 252         }
 253
 254         /* don't free context */
 255 }
 256
 257 static void _net_nfc_server_handover_bt_process_carrier_record_cb(
 258                 net_nfc_error_e result,
 259                 net_nfc_conn_handover_carrier_type_e type,
 260                 data_s *data,
 261                 void *user_param)
 262 {
 263         net_nfc_server_handover_process_config_context_t *context =
 264                 (net_nfc_server_handover_process_config_context_t *)user_param;
 265
 266         if (result == NET_NFC_OK)
 267         {
 268                 if (context->cb != NULL)
 269                 {
 270                         context->cb(result, type, data, context->user_param);
 271                 }
 272         }
 273         else
 274         {
 275                 DEBUG_ERR_MSG("_handover_bt_process_carrier_record failed [%d]",
 276                                 result);
 277         }
 278
 279         _net_nfc_util_free_mem(context);
 280 }
 281
 282
 283 net_nfc_error_e net_nfc_server_handover_get_carrier_record_by_priority_order(
 284                 ndef_message_s *request, ndef_record_s **record)
 285 {
 286         net_nfc_error_e result;
 287         unsigned int carrier_count = 0;
 288
 289         LOGD("[%s] START", __func__);
 290
 291         if (request == NULL || record == NULL)
 292         {
 293                 return NET_NFC_NULL_PARAMETER;
 294         }
 295
 296         *record = NULL;
 297
 298         if ((result = net_nfc_util_get_alternative_carrier_record_count(
 299                                         request,
 300                                         &carrier_count)) == NET_NFC_OK)
 301         {
 302                 int idx, priority;
 303                 net_nfc_conn_handover_carrier_type_e carrier_type =
 304                         NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
 305
 306                 for (priority = NET_NFC_CONN_HANDOVER_CARRIER_BT;*record == NULL
 307                                 && priority < NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;priority++)
 308                 {
 309                         /* check each carrier record and create matched record */
 310                         for (idx = 0; idx < carrier_count; idx++)
 311                         {
 312                                 if ((net_nfc_util_get_alternative_carrier_type(
 313                                                                 request,
 314                                                                 idx,
 315                                                                 &carrier_type)== NET_NFC_OK)
 316                                                 && (carrier_type == priority))
 317                                 {
 318                                         DEBUG_SERVER_MSG("selected carrier type"
 319                                                         " = [%d]", carrier_type);
 320                                         net_nfc_util_get_carrier_config_record(
 321                                                         request,
 322                                                         idx,
 323                                                         record);
 324                                         result = NET_NFC_OK;
 325                                         break;
 326                                 }
 327                         }
 328                 }
 329         }
 330         else
 331         {
 332                 DEBUG_ERR_MSG("net_nfc_util_get_alternative_carrier"
 333                                 "_record_count failed");
 334         }
 335
 336         LOGD("[%s] END", __func__);
 337
 338         return result;
 339 }
 340
 341 static net_nfc_error_e _net_nfc_server_handover_create_requester_from_rawdata(
 342                 ndef_message_s **requestor,
 343                 data_s *data)
 344 {
 345         net_nfc_error_e result;
 346
 347         if (requestor == NULL)
 348                 return NET_NFC_NULL_PARAMETER;
 349
 350         *requestor = NULL;
 351
 352         result = net_nfc_util_create_ndef_message(requestor);
 353         if (result == NET_NFC_OK)
 354         {
 355                 result = net_nfc_util_convert_rawdata_to_ndef_message(data,
 356                                 *requestor);
 357
 358                 if (result == NET_NFC_OK)
 359                 {
 360                         if (_net_nfc_server_handover_check_hr_record_validation(
 361                                                 *requestor) == true)
 362                         {
 363                                 result = NET_NFC_OK;
 364                         }
 365                         else
 366                         {
 367                                 DEBUG_ERR_MSG("record is not valid or"
 368                                                 " is not available");
 369                                 net_nfc_util_free_ndef_message(*requestor);
 370                                 result = NET_NFC_INVALID_PARAM;
 371                         }
 372                 }
 373                 else
 374                 {
 375                         DEBUG_ERR_MSG("_net_nfc_ndef_rawdata_to_ndef"
 376                                         "failed [%d]",result);
 377                 }
 378         } else {
 379                 DEBUG_ERR_MSG("net_nfc_util_create_ndef_message failed [%d]",
 380                                 result);
 381         }
 382
 383         return result;
 384 }
 385
 386 net_nfc_error_e net_nfc_server_handover_create_selector_from_rawdata(
 387                 ndef_message_s **selector, data_s *data)
 388 {
 389         net_nfc_error_e result;
 390
 391         if (selector == NULL)
 392                 return NET_NFC_NULL_PARAMETER;
 393
 394         *selector = NULL;
 395
 396         if ((result = net_nfc_util_create_ndef_message(selector))
 397                         == NET_NFC_OK)
 398         {
 399                 if ((result = net_nfc_util_convert_rawdata_to_ndef_message(data,
 400                                                 *selector)) == NET_NFC_OK)
 401                 {
 402
 403                         /* if record is not Hs record, then */
 404                         if (_net_nfc_server_handover_check_hs_record_validation(
 405                                                 *selector) == true)
 406                         {
 407                                 result = NET_NFC_OK;
 408                         }
 409                         else
 410                         {
 411                                 DEBUG_ERR_MSG("record is not valid or is "
 412                                                 "not available");
 413                                 net_nfc_util_free_ndef_message(*selector);
 414                                 result = NET_NFC_INVALID_PARAM;
 415                         }
 416                 }
 417                 else
 418                 {
 419                         DEBUG_ERR_MSG("_net_nfc_ndef_rawdata_to_ndef"
 420                                         " failed [%d]",result);
 421                 }
 422         }
 423         else
 424         {
 425                 DEBUG_ERR_MSG("_net_nfc_util_create_ndef_message"
 426                                 " failed [%d]",result);
 427         }
 428
 429         return result;
 430 }
 431
 432 static bool _net_nfc_server_handover_check_hr_record_validation(
 433                 ndef_message_s *message)
 434 {
 435         unsigned int count;
 436         ndef_record_s *rec;
 437
 438         LOGD("[%s] START", __func__);
 439
 440         if (message == NULL)
 441                 return false;
 442
 443         rec = (ndef_record_s *)message->records;
 444
 445         if (memcmp(rec->type_s.buffer, CH_REQ_RECORD_TYPE,
 446                                 rec->type_s.length) != 0)
 447         {
 448                 DEBUG_ERR_MSG("This is not connection handover"
 449                                 " request message");
 450                 goto ERROR;
 451         }
 452
 453         if (rec->payload_s.buffer[0] != CH_VERSION)
 454         {
 455                 DEBUG_ERR_MSG("connection handover version is not matched");
 456                 goto ERROR;
 457         }
 458
 459         if (net_nfc_util_get_alternative_carrier_record_count(message, &count)
 460                         != NET_NFC_OK || count == 0)
 461         {
 462                 DEBUG_ERR_MSG("there is no carrier reference");
 463                 goto ERROR;
 464         }
 465
 466         LOGD("[%s] END", __func__);
 467
 468         return true;
 469
 470 ERROR :
 471         LOGD("[%s] END", __func__);
 472
 473         return false;
 474 }
 475
 476 static bool _net_nfc_server_handover_check_hs_record_validation(
 477                 ndef_message_s *message)
 478 {
 479         unsigned int count;
 480         ndef_record_s *rec;
 481
 482         LOGD("[%s] START", __func__);
 483
 484         if (message == NULL)
 485                 return false;
 486
 487         rec = (ndef_record_s *)message->records;
 488
 489         if (memcmp(rec->type_s.buffer, CH_SEL_RECORD_TYPE,
 490                                 rec->type_s.length) != 0)
 491         {
 492                 DEBUG_ERR_MSG("This is not connection handover"
 493                                 " request message");
 494                 goto ERROR;
 495         }
 496
 497         if (net_nfc_util_get_alternative_carrier_record_count(
 498                                 message,&count)!= NET_NFC_OK || count == 0)
 499         {
 500                 DEBUG_ERR_MSG("there is no carrrier reference");
 501                 goto ERROR;
 502         }
 503
 504         /*      check version */
 505         if (rec->payload_s.buffer[0] != CH_VERSION)
 506         {
 507                 DEBUG_ERR_MSG("connection handover version"
 508                                 " is not matched");
 509                 goto ERROR;
 510         }
 511
 512         LOGD("[%s] END", __func__);
 513
 514         return true;
 515
 516 ERROR :
 517         LOGD("[%s] END", __func__);
 518
 519         return false;
 520 }
 521
 522 static int _net_nfc_server_handover_iterate_carrier_configs_step(
 523                 net_nfc_server_handover_create_config_context_t *context)
 524 {
 525         LOGD("[%s:%d] START", __func__, __LINE__);
 526
 527         if (context == NULL)
 528         {
 529                 return 0;
 530         }
 531
 532         if (context->cb != NULL)
 533         {
 534                 context->cb(NET_NFC_OK, context->ndef_message,
 535                                 context->user_param);
 536         }
 537
 538         if (context->ndef_message != NULL)
 539         {
 540                 net_nfc_util_free_ndef_message(context->ndef_message);
 541         }
 542
 543         _net_nfc_util_free_mem(context);
 544
 545         LOGD("[%s:%d] END", __func__, __LINE__);
 546
 547         return 0;
 548 }
 549
 550 static int _net_nfc_server_handover_iterate_carrier_configs_to_next(
 551                 net_nfc_server_handover_create_config_context_t *context)
 552 {
 553         if (context->result == NET_NFC_OK || context->result == NET_NFC_BUSY)
 554         {
 555                 if (context->type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
 556                 {
 557                         if (context->current_type <
 558                                         NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
 559                         {
 560                                 context->current_type++;
 561                         }
 562                 }
 563                 else
 564                 {
 565                         context->current_type =
 566                                 NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
 567                 }
 568
 569                 g_idle_add(
 570                                 (GSourceFunc)_net_nfc_server_handover_iterate_create_carrier_configs,
 571                                 (gpointer)context);
 572         }
 573         else
 574         {
 575                 DEBUG_ERR_MSG("context->result is error [%d]", context->result);
 576
 577                 g_idle_add(
 578                                 (GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_step,
 579                                 (gpointer)context);
 580         }
 581
 582         return 0;
 583 }
 584
 585 static int _net_nfc_server_handover_iterate_create_carrier_configs(
 586                 net_nfc_server_handover_create_config_context_t *context)
 587 {
 588         LOGD("[%s:%d] START", __func__, __LINE__);
 589
 590         switch (context->current_type)
 591         {
 592         case NET_NFC_CONN_HANDOVER_CARRIER_BT :
 593                 DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_BT]");
 594                 net_nfc_server_handover_bt_get_carrier_record(
 595                                 _net_nfc_server_handover_bt_get_carrier_record_cb,
 596                                 context);
 597                 break;
 598
 599                 //      case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS :
 600                 //              DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
 601                 //              g_idle_add(
 602                 //              (GSourceFunc)net_nfc_service_llcp_handover_append_wifi_carrier_config,
 603                 //                              context);
 604                 //              break;
 605
 606                 //      case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS :
 607                 //              DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
 608                 //              g_idle_add(
 609                 //              (GSourceFunc)_net_nfc_server_handover_append_wifi_carrier_config,
 610                 //                      context);
 611                 //              break;
 612
 613         case NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN :
 614                 DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN]");
 615                 g_idle_add(
 616                                 (GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_step,
 617                                 (gpointer)context);
 618                 break;
 619
 620         default :
 621                 DEBUG_MSG("[unknown : %d]", context->current_type);
 622                 g_idle_add(
 623                                 (GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_step,
 624                                 (gpointer)context);
 625                 break;
 626         }
 627
 628         LOGD("[%s:%d] END", __func__, __LINE__);
 629
 630         return 0;
 631 }
 632
 633 static net_nfc_error_e _net_nfc_server_handover_create_requester_carrier_configs(
 634                 net_nfc_conn_handover_carrier_type_e type,
 635                 void *cb,
 636                 void *user_param)
 637 {
 638         net_nfc_error_e result = NET_NFC_OK;
 639         net_nfc_server_handover_create_config_context_t *context = NULL;
 640
 641         LOGD("[%s:%d] START", __func__, __LINE__);
 642
 643         _net_nfc_util_alloc_mem(context, sizeof(*context));
 644         if (context != NULL)
 645         {
 646                 context->type = type;
 647                 if (type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
 648                 {
 649                         context->current_type =
 650                                 NET_NFC_CONN_HANDOVER_CARRIER_BT;
 651                 }
 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_request_message(
 658                                 &context->ndef_message);
 659
 660                 /* append carrier record */
 661                 g_idle_add(
 662                                 (GSourceFunc)_net_nfc_server_handover_iterate_create_carrier_configs,
 663                                 (gpointer)context);
 664         }
 665         else
 666         {
 667                 DEBUG_ERR_MSG("alloc failed");
 668                 result = NET_NFC_ALLOC_FAIL;
 669         }
 670
 671         LOGD("[%s:%d] END", __func__, __LINE__);
 672
 673         return result;
 674 }
 675
 676 static net_nfc_error_e _net_nfc_server_handover_create_selector_carrier_configs(
 677                 net_nfc_conn_handover_carrier_type_e type,
 678                 void *cb,
 679                 void *user_param)
 680 {
 681         net_nfc_error_e result = NET_NFC_OK;
 682         net_nfc_server_handover_create_config_context_t *context = NULL;
 683
 684         LOGD("[%s:%d] START", __func__, __LINE__);
 685
 686         _net_nfc_util_alloc_mem(context, sizeof(*context));
 687         if (context != NULL)
 688         {
 689                 context->type = type;
 690                 if (type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
 691                         context->current_type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
 692                 else
 693                         context->current_type = context->type;
 694
 695                 context->cb = cb;
 696                 context->user_param = user_param;
 697                 net_nfc_util_create_handover_select_message(
 698                                 &context->ndef_message);
 699
 700                 /* append carrier record */
 701                 g_idle_add(
 702                                 (GSourceFunc)_net_nfc_server_handover_iterate_create_carrier_configs,
 703                                 (gpointer)context);
 704         }
 705         else
 706         {
 707                 DEBUG_ERR_MSG("alloc failed");
 708                 result = NET_NFC_ALLOC_FAIL;
 709         }
 710
 711         LOGD("[%s:%d] END", __func__, __LINE__);
 712
 713         return result;
 714 }
 715
 716 net_nfc_error_e net_nfc_server_handover_process_carrier_record(
 717                 ndef_record_s *carrier, void *cb, void *user_param)
 718 {
 719         net_nfc_error_e result = NET_NFC_OK;
 720         net_nfc_server_handover_process_config_context_t *context = NULL;
 721
 722         LOGD("[%s:%d] START", __func__, __LINE__);
 723
 724         _net_nfc_util_alloc_mem(context, sizeof(*context));
 725         if (context != NULL)
 726         {
 727                 net_nfc_conn_handover_carrier_type_e type;
 728
 729                 net_nfc_util_get_alternative_carrier_type_from_record(
 730                                 carrier,
 731                                 &type);
 732
 733                 context->type = type;
 734                 context->user_param = user_param;
 735                 context->cb = cb;
 736                 context->step = NET_NFC_LLCP_STEP_01;
 737
 738                 /* process carrier record */
 739                 switch (type)
 740                 {
 741                 case NET_NFC_CONN_HANDOVER_CARRIER_BT :
 742                         DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_BT]");
 743                         net_nfc_server_handover_bt_process_carrier_record(
 744                                         carrier,
 745                                         _net_nfc_server_handover_bt_process_carrier_record_cb,
 746                                         context);
 747                         break;
 748
 749                 case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS :
 750                         DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
 751                         net_nfc_server_handover_bss_process_carrier_record(
 752                                         carrier,
 753                                         NULL,
 754                                         NULL);
 755                         _net_nfc_util_free_mem(context);
 756                         break;
 757
 758                 case NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN :
 759                         DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN]");
 760                         _net_nfc_util_free_mem(context);
 761                         break;
 762
 763                 default :
 764                         DEBUG_MSG("[unknown]");
 765                         _net_nfc_util_free_mem(context);
 766                         break;
 767                 }
 768         }
 769         else
 770         {
 771                 DEBUG_ERR_MSG("alloc failed");
 772                 result = NET_NFC_ALLOC_FAIL;
 773         }
 774
 775         LOGD("[%s:%d] END", __func__, __LINE__);
 776
 777         return result;
 778 }
 779
 780 #if 0
 781 static net_nfc_error_e _net_nfc_server_handover_snep_client_cb(
 782                 net_nfc_snep_handle_h handle,
 783                 net_nfc_error_e result,
 784                 uint32_t type,
 785                 data_s *data,
 786                 void *user_param)
 787 {
 788         _net_nfc_server_handover_client_context_t *context =
 789                 (_net_nfc_server_handover_client_context_t *)user_param;
 790
 791         DEBUG_SERVER_MSG("type [%d], result [%d], data [%p], user_param [%p]",
 792                         type, result, data, user_param);
 793
 794         switch (type) {
 795         case SNEP_RESP_SUCCESS :
 796                 {
 797                         ndef_message_s *selector;
 798
 799                         result = net_nfc_server_handover_create_selector_from_rawdata(
 800                                         &selector,
 801                                         data);
 802                         if (result == NET_NFC_OK) {
 803                                 if (false /* is low power ??? */) {
 804                                         result =
 805                                                 _net_nfc_server_handover_process_selector_msg(
 806                                                                 selector,
 807                                                                 user_param);
 808                                 } else {
 809                                         result =
 810                                                 _net_nfc_server_handover_process_selector_msg(
 811                                                                 selector,
 812                                                                 user_param);
 813                                 }
 814
 815                                 if (result != NET_NFC_OK) {
 816                                         DEBUG_ERR_MSG("_net_nfc_server_handover_process"
 817                                                         "_selector_msg failed [%d]",result);
 818                                         if (context->cb != NULL) {
 819                                                 context->cb(result,
 820                                                                 context->type,
 821                                                                 NULL,
 822                                                                 context->user_param);
 823                                         }
 824                                         _net_nfc_util_free_mem(context);
 825                                 }
 826
 827                                 net_nfc_util_free_ndef_message(selector);
 828                         } else {
 829                                 DEBUG_ERR_MSG("_net_nfc_server_handover_create"
 830                                                 "_selector_from_rawdata failed [%d]",result);
 831                                 if (context->cb != NULL) {
 832                                         context->cb(result,
 833                                                         context->type,
 834                                                         NULL,
 835                                                         context->user_param);
 836                                 }
 837                                 _net_nfc_util_free_mem(context);
 838                         }
 839                 }
 840                 break;
 841
 842         case SNEP_RESP_BAD_REQ :
 843         case SNEP_RESP_EXCESS_DATA :
 844         case SNEP_RESP_NOT_FOUND :
 845         case SNEP_RESP_NOT_IMPLEMENT :
 846         case SNEP_RESP_REJECT :
 847         case SNEP_RESP_UNSUPPORTED_VER :
 848         default :
 849                 {
 850                         DEBUG_ERR_MSG("error response [0x%02x]", type);
 851                         if (context->cb != NULL) {
 852                                 context->cb(result, context->type, NULL,
 853                                                 context->user_param);
 854                         }
 855                         _net_nfc_util_free_mem(context);
 856                 }
 857                 break;
 858         }
 859
 860         return result;
 861 }
 862
 863
 864 static void _net_nfc_server_handover_create_requester_carrier_configs_cb(
 865                 net_nfc_error_e result,
 866                 ndef_message_s *msg,
 867                 void *user_param)
 868 {
 869         _net_nfc_server_handover_client_context_t *context =
 870                 (_net_nfc_server_handover_client_context_t *)user_param;
 871         data_s data;
 872
 873         if (context == NULL)
 874         {
 875                 return;
 876         }
 877
 878         if (msg != NULL) {
 879                 /* convert ndef message */
 880                 if ((result = _net_nfc_server_handover_convert_ndef_message_to_data(msg,
 881                                                 &data)) == NET_NFC_OK) {
 882                         net_nfc_service_snep_client(context->handle,
 883                                         SNEP_SAN,
 884                                         0,
 885                                         SNEP_REQ_GET,
 886                                         &data,
 887                                         _net_nfc_server_handover_snep_client_cb,
 888                                         context);
 889
 890                         net_nfc_util_free_data(&data);
 891                 }
 892                 else
 893                 {
 894                         DEBUG_ERR_MSG("_net_nfc_server_handover_convert"
 895                                         "_ndef_message_to_datafailed [%d]",result);
 896                         if (context->cb != NULL)
 897                         {
 898                                 context->cb(result,
 899                                                 context->type,
 900                                                 NULL,
 901                                                 context->user_param);
 902                         }
 903                         _net_nfc_util_free_mem(context);
 904                 }
 905         }
 906         else
 907         {
 908                 DEBUG_ERR_MSG("null param, [%d]", result);
 909                 if (context->cb != NULL)
 910                 {
 911                         context->cb(result,
 912                                         context->type,
 913                                         NULL,
 914                                         context->user_param);
 915                 }
 916                 _net_nfc_util_free_mem(context);
 917         }
 918 }
 919 #endif
 920
 921
 922 #if 0
 923
 924 static void _net_nfc_server_handover_server_create_carrier_configs_cb(
 925                 net_nfc_error_e result,
 926                 ndef_message_s *selector,
 927                 void *user_param)
 928 {
 929         _net_nfc_server_handover_create_config_context_t *context =
 930                 (_net_nfc_server_handover_create_config_context_t *)user_param;
 931         data_s data;
 932
 933         if (context == NULL)
 934         {
 935                 return;
 936         }
 937
 938         if (result == NET_NFC_OK)
 939         {
 940                 result = _net_nfc_server_handover_convert_ndef_message_to_data(
 941                                 selector,
 942                                 &data);
 943
 944                 if (result == NET_NFC_OK)
 945                 {
 946                         /* process message */
 947                         net_nfc_server_handover_process_carrier_record(
 948                                         context->record,
 949                                         NULL,
 950                                         NULL);
 951
 952                         result = net_nfc_service_snep_server_send_get_response(
 953                                         context->user_param,
 954                                         &data);
 955                         if (result != NET_NFC_OK)
 956                         {
 957                                 DEBUG_ERR_MSG("net_nfc_service_snep_server"
 958                                                 "_send_get_response failed [%d]",result);
 959                         }
 960                         net_nfc_util_free_data(&data);
 961                 }
 962                 else
 963                 {
 964                         DEBUG_ERR_MSG("_net_nfc_server_handover_convert_ndef_message_to_data"
 965                                         "failed [%d]",result);
 966                 }
 967         }
 968         else
 969         {
 970                 DEBUG_ERR_MSG("_net_nfc_server_handover_create_selector_msg"
 971                                 "failed [%d]",result);
 972         }
 973
 974         _net_nfc_util_free_mem(context);
 975 }
 976
 977 static net_nfc_error_e _net_nfc_server_handover_create_selector_msg(
 978                 net_nfc_snep_handle_h handle,
 979                 ndef_message_s *request,
 980                 void *user_param)
 981 {
 982         net_nfc_error_e result;
 983         uint32_t count;
 984
 985         net_nfc_manager_util_play_sound(NET_NFC_TASK_END);
 986
 987         /* get requester message */
 988         if ((result = net_nfc_util_get_alternative_carrier_record_count(
 989                                         request,
 990                                         &count)) == NET_NFC_OK)
 991         {
 992                 if (1/* power state */ || count == 1)
 993                 {
 994                         ndef_record_s *record = NULL;
 995
 996                         /* fill alternative carrier information */
 997                         if ((result =
 998                                                 net_nfc_server_handover_get_carrier_record_by_priority_order(
 999                                                         request,
1000                                                         &record)) == NET_NFC_OK)
1001                         {
1002                                 net_nfc_conn_handover_carrier_type_e type =
1003                                         NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
1004
1005                                 if ((result = net_nfc_util_get_alternative_carrier_type_from_record(
1006                                                                 record,
1007                                                                 &type)) == NET_NFC_OK)
1008                                 {
1009                                         _net_nfc_server_handover_create_config_context_t *context = NULL;
1010
1011                                         _net_nfc_util_alloc_mem(context, sizeof(*context));
1012
1013                                         context->user_param = handle;
1014
1015                                         net_nfc_util_create_record(record->TNF,
1016                                                         &record->type_s, &record->id_s,
1017                                                         &record->payload_s,
1018                                                         &context->record);
1019
1020                                         if ((result = _net_nfc_server_handover_create_selector_carrier_configs(
1021                                                                         type,
1022                                                                         _net_nfc_server_handover_server_create_carrier_configs_cb,
1023                                                                         context)) != NET_NFC_OK)
1024                                         {
1025                                                 DEBUG_ERR_MSG("_create_selector_carrier_configs "
1026                                                                 "failed [%d]", result);
1027                                         }
1028                                 }
1029                                 else
1030                                 {
1031                                         DEBUG_ERR_MSG("get_alternative_carrier_type_from_record "
1032                                                         "failed [%d]", result);
1033                                 }
1034                         }
1035                         else
1036                         {
1037                                 DEBUG_ERR_MSG("r_get_carrier_record_by_priority_order"
1038                                                 " failed [%d]", result);
1039                         }
1040                 }
1041                 else /* low power && count > 1 */
1042                 {
1043                         ndef_message_s selector;
1044
1045                         if ((result = _net_nfc_server_handover_create_low_power_selector_message(
1046                                                         request,
1047                                                         &selector)) == NET_NFC_OK)
1048                         {
1049                                 _net_nfc_server_handover_server_create_carrier_configs_cb(
1050                                                 NET_NFC_OK,
1051                                                 &selector,
1052                                                 user_param);
1053
1054                                 net_nfc_util_free_ndef_message(&selector);
1055                         }
1056                         else
1057                         {
1058                                 DEBUG_ERR_MSG("_create_low_power_selector_message"
1059                                                 "failed [%d]", result);
1060                         }
1061                 }
1062         }
1063         else
1064         {
1065                 DEBUG_ERR_MSG("net_nfc_util_get_alternative_carrier_record_count"
1066                                 "failed [%d]", result);
1067         }
1068
1069         return result;
1070 }
1071
1072
1073 static net_nfc_error_e _net_nfc_server_handover_create_server_cb(
1074                 net_nfc_snep_handle_h handle,
1075                 net_nfc_error_e result,
1076                 uint32_t type,
1077                 data_s *data,
1078                 void *user_param)
1079 {
1080         DEBUG_SERVER_MSG("type [0x%02x], result [%d], data [%p], user_param [%p]",
1081                         type, result, data, user_param);
1082
1083         if (result != NET_NFC_OK || data == NULL || data->buffer == NULL)
1084         {
1085                 /* restart */
1086                 return NET_NFC_NULL_PARAMETER;
1087         }
1088
1089         switch (type)
1090         {
1091         case SNEP_REQ_GET :
1092                 {
1093                         ndef_message_s *request;
1094
1095                         /* TODO : send select response to requester */
1096                         result =
1097                                 _net_nfc_server_handover_create_requester_from_rawdata(
1098                                                 &request,
1099                                                 data);
1100                         if (result == NET_NFC_OK) {
1101                                 if (1/* TODO : check version */)
1102                                 {
1103                                         _net_nfc_server_handover_create_selector_msg(
1104                                                         handle,
1105                                                         request,
1106                                                         user_param);
1107                                 }
1108                                 else
1109                                 {
1110                                         DEBUG_ERR_MSG("not supported version [0x%x]",
1111                                                         result);
1112
1113                                         result = NET_NFC_NOT_SUPPORTED;
1114                                 }
1115
1116                                 net_nfc_util_free_ndef_message(request);
1117                         }
1118                         else
1119                         {
1120                                 DEBUG_ERR_MSG("_net_nfc_server_handover_create"
1121                                                 "_requester_from_rawdata failed [%d]",result);
1122                         }
1123                 }
1124                 break;
1125
1126         case SNEP_REQ_PUT :
1127                 DEBUG_ERR_MSG("PUT request doesn't supported");
1128                 result = NET_NFC_NOT_SUPPORTED;
1129                 break;
1130
1131         default :
1132                 DEBUG_ERR_MSG("error [%d]", result);
1133                 break;
1134         }
1135
1136         return result;
1137 }
1138 #else
1139
1140
1141
1142 static net_nfc_error_e _net_nfc_server_handover_select_carrier_record(
1143                 ndef_message_s *request,
1144                 net_nfc_conn_handover_carrier_type_e *type,
1145                 ndef_record_s **record)
1146 {
1147         net_nfc_error_e result;
1148         uint32_t count;
1149
1150         *record = NULL;
1151         *type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
1152
1153         /* get requester message */
1154         if ((result = net_nfc_util_get_alternative_carrier_record_count(request,
1155                                         &count)) == NET_NFC_OK)
1156         {
1157                 if (1/* power state */ || count == 1)
1158                 {
1159                         ndef_record_s *temp;
1160
1161                         /* fill alternative carrier information */
1162                         if ((result =
1163                                                 net_nfc_server_handover_get_carrier_record_by_priority_order(
1164                                                         request,
1165                                                         &temp)) == NET_NFC_OK)
1166                         {
1167                                 if ((result =
1168                                                         net_nfc_util_get_alternative_carrier_type_from_record(
1169                                                                 temp,
1170                                                                 type)) == NET_NFC_OK)
1171                                 {
1172                                         net_nfc_util_create_record(temp->TNF,
1173                                                         &temp->type_s, &temp->id_s,
1174                                                         &temp->payload_s,
1175                                                         record);
1176                                 }
1177                                 else
1178                                 {
1179                                         DEBUG_ERR_MSG("net_nfc_util_get_alternative"
1180                                                         "_carrier_type_from_record failed [%d]", result);
1181                                 }
1182                         }
1183                         else
1184                         {
1185                                 DEBUG_ERR_MSG("_handover_get_carrier_record"
1186                                                 "_by_priority_order failed [%d]", result);
1187                         }
1188                 }
1189                 else /* low power && count > 1 */
1190                 {
1191                         result = NET_NFC_INVALID_STATE;
1192                 }
1193         }
1194         else
1195         {
1196                 DEBUG_ERR_MSG("net_nfc_util_get_alternative_carrier_record_count "
1197                                 "failed [%d]", result);
1198         }
1199
1200         return result;
1201 }
1202
1203 #endif
1204
1205 static void _net_nfc_server_handover_create_carrier_configs_2_cb(
1206                 net_nfc_error_e result,
1207                 ndef_message_s *selector,
1208                 void *user_param)
1209 {
1210         net_nfc_handover_context_t *context =
1211                 (net_nfc_handover_context_t *)user_param;
1212
1213         DEBUG_SERVER_MSG("_net_nfc_server_handover_server_create_carrier_config_cb"
1214                         "result [%d]",result);
1215
1216         if (context == NULL)
1217         {
1218                 return;
1219         }
1220
1221         context->result = result;
1222
1223         if (result == NET_NFC_OK) {
1224                 result = _net_nfc_server_handover_convert_ndef_message_to_data(
1225                                 selector,
1226                                 &context->data);
1227
1228                 DEBUG_SERVER_MSG("selector message created, length [%d]",
1229                                 context->data.length);
1230
1231                 context->state = NET_NFC_LLCP_STEP_03;
1232         }
1233         else
1234         {
1235                 DEBUG_ERR_MSG("_net_nfc_server_handover_create_selector_msg failed [%d]",
1236                                 result);
1237                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1238         }
1239
1240         _net_nfc_server_handover_get_response_process(context);
1241 }
1242
1243 static void _net_nfc_server_handover_process_carrier_record_2_cb(
1244                 net_nfc_error_e result,
1245                 net_nfc_conn_handover_carrier_type_e type,
1246                 data_s *data,
1247                 void *user_param)
1248 {
1249         net_nfc_handover_context_t *context =
1250                 (net_nfc_handover_context_t *)user_param;
1251
1252         DEBUG_SERVER_MSG("_net_nfc_server_handover_server_process_carrier_record_cb"
1253                         "result [%d]",result);
1254
1255         context->result = result;
1256         if (result == NET_NFC_OK)
1257         {
1258                 context->state = NET_NFC_LLCP_STEP_04;
1259         }
1260         else
1261         {
1262                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1263         }
1264
1265         context->data.length = data->length;
1266         _net_nfc_util_alloc_mem(context->data.buffer, context->data.length);
1267         memcpy(context->data.buffer, data->buffer, context->data.length);
1268
1269
1270         _net_nfc_server_handover_server_process(context);
1271 }
1272
1273 static void _net_nfc_server_handover_get_response_process(
1274                 net_nfc_handover_context_t *context)
1275 {
1276         net_nfc_error_e result;
1277
1278         if (context == NULL)
1279         {
1280                 return;
1281         }
1282
1283         switch (context->state)
1284         {
1285         case NET_NFC_LLCP_STEP_02 :
1286                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_02");
1287
1288                 result = _net_nfc_server_handover_create_selector_carrier_configs(
1289                                 context->type,
1290                                 _net_nfc_server_handover_create_carrier_configs_2_cb,
1291                                 context);
1292
1293                 if (result != NET_NFC_OK)
1294                 {
1295                         DEBUG_ERR_MSG("_net_nfc_server_handover_create_"
1296                                         "selector_carrier_config failed [%d]",result);
1297                 }
1298                 break;
1299
1300         case NET_NFC_LLCP_STEP_03 :
1301                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_03");
1302
1303                 result = net_nfc_server_handover_process_carrier_record(
1304                                 context->record,
1305                                 _net_nfc_server_handover_process_carrier_record_2_cb,
1306                                 context);
1307
1308                 if (result != NET_NFC_OK)
1309                 {
1310                         DEBUG_ERR_MSG("net_nfc_server_handover_process_carrier_record"
1311                                         "failed [%d]",result);
1312                 }
1313                 break;
1314
1315         case NET_NFC_LLCP_STEP_04 :
1316                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_04");
1317
1318                 /* response select message */
1319                 result = net_nfc_server_snep_server_send_get_response(
1320                                 (net_nfc_snep_handle_h)context->handle,
1321                                 &context->data);
1322                 break;
1323
1324         case NET_NFC_STATE_ERROR :
1325                 DEBUG_SERVER_MSG("NET_NFC_STATE_ERROR");
1326                 break;
1327
1328         default :
1329                 DEBUG_ERR_MSG("NET_NFC_LLCP_STEP_??");
1330                 /* TODO */
1331                 break;
1332         }
1333 }
1334
1335 static bool _net_nfc_server_handover_get_response_cb(
1336                 net_nfc_snep_handle_h handle,
1337                 uint32_t type,
1338                 uint32_t max_len,
1339                 data_s *data,
1340                 void *user_param)
1341 {
1342         net_nfc_error_e result;
1343         ndef_message_s *request;
1344
1345         DEBUG_SERVER_MSG("type [%d], data [%p], user_param [%p]",
1346                         type, data, user_param);
1347
1348         if (data == NULL || data->buffer == NULL)
1349         {
1350                 /* restart */
1351                 return false;
1352         }
1353
1354         /* TODO : send select response to requester */
1355         result = _net_nfc_server_handover_create_requester_from_rawdata(
1356                         &request,
1357                         data);
1358
1359         if (result == NET_NFC_OK)
1360         {
1361                 net_nfc_conn_handover_carrier_type_e type;
1362                 ndef_record_s *record;
1363
1364                 if (_net_nfc_server_handover_select_carrier_record(
1365                                         request,
1366                                         &type,
1367                                         &record) == NET_NFC_OK)
1368                 {
1369                         net_nfc_handover_context_t *context = NULL;
1370
1371                         _net_nfc_util_alloc_mem(context, sizeof(*context));
1372
1373                         if (context != NULL)
1374                         {
1375                                 context->handle = (void *)handle;
1376                                 context->type = type;
1377                                 context->user_param = user_param;
1378                                 context->state = NET_NFC_LLCP_STEP_02;
1379
1380                                 net_nfc_util_create_record(record->TNF,
1381                                                 &record->type_s,
1382                                                 &record->id_s,
1383                                                 &record->payload_s,
1384                                                 &context->record);
1385
1386                                 _net_nfc_server_handover_get_response_process(context);
1387                         }
1388                         else
1389                         {
1390                                 DEBUG_ERR_MSG("_net_nfc_util_alloc_mem failed");
1391                                 result = NET_NFC_ALLOC_FAIL;
1392                         }
1393                 }
1394                 else
1395                 {
1396                         /* low power */
1397                 }
1398
1399                 net_nfc_util_free_ndef_message(request);
1400         }
1401         else
1402         {
1403                 DEBUG_SERVER_MSG("it is not handover requester message, [%d]",
1404                                 result);
1405         }
1406
1407         return (result == NET_NFC_OK);
1408 }
1409
1410 ////////////////////////////////////////////////////////////////////////////////
1411 static void _net_nfc_server_handover_server_process_carrier_record_cb(
1412                 net_nfc_error_e result,
1413                 net_nfc_conn_handover_carrier_type_e type,
1414                 data_s *data,
1415                 void *user_param)
1416 {
1417         net_nfc_handover_context_t *context =
1418                 (net_nfc_handover_context_t *)user_param;
1419
1420         DEBUG_SERVER_MSG("_net_nfc_server_handover_server_process"
1421                         "_carrier_record_cb result [%d]",result);
1422
1423         context->result = result;
1424         if (result == NET_NFC_OK)
1425         {
1426                 context->state = NET_NFC_LLCP_STEP_04;
1427         }
1428         else
1429         {
1430                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1431         }
1432
1433         _net_nfc_server_handover_server_process(context);
1434 }
1435
1436 static void _net_nfc_server_handover_server_create_carrier_config_cb(
1437                 net_nfc_error_e result,
1438                 ndef_message_s *selector,
1439                 void *user_param)
1440 {
1441         net_nfc_handover_context_t *context =
1442                 (net_nfc_handover_context_t *)user_param;
1443
1444         DEBUG_SERVER_MSG("_net_nfc_server_handover_server_create"
1445                         "_carrier_config_cb,result [%d]",result);
1446
1447         if (context == NULL)
1448         {
1449                 return;
1450         }
1451
1452         context->result = result;
1453
1454         if (result == NET_NFC_OK)
1455         {
1456                 result = _net_nfc_server_handover_convert_ndef_message_to_data(
1457                                 selector,
1458                                 &context->data);
1459                 DEBUG_SERVER_MSG("selector message created, length [%d]",
1460                                 context->data.length);
1461                 context->state = NET_NFC_LLCP_STEP_03;
1462         }
1463         else
1464         {
1465                 DEBUG_ERR_MSG("_net_nfc_server_handover_create_selector_msg"
1466                                 " failed [%d]", result);
1467                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1468         }
1469
1470         _net_nfc_server_handover_server_process(context);
1471 }
1472
1473 static void _net_nfc_server_handover_server_recv_cb(
1474                 net_nfc_error_e result,
1475                 net_nfc_target_handle_s *handle,
1476                 net_nfc_llcp_socket_t socket,
1477                 data_s *data,
1478                 void *user_param)
1479 {
1480         net_nfc_handover_context_t *context =
1481                 (net_nfc_handover_context_t *)user_param;
1482         ndef_message_s *request;
1483
1484         DEBUG_SERVER_MSG("_net_nfc_server_handover_server_recv_cb,"
1485                         " socket [%x], result [%d]", socket, result);
1486
1487         context->result = result;
1488
1489         if (result == NET_NFC_OK)
1490         {
1491                 result = _net_nfc_server_handover_create_requester_from_rawdata(
1492                                 &request,
1493                                 data);
1494
1495                 if (result == NET_NFC_OK)
1496                 {
1497                         ndef_record_s *record;
1498
1499                         if (_net_nfc_server_handover_select_carrier_record(
1500                                                 request,
1501                                                 &context->type,
1502                                                 &record) == NET_NFC_OK)
1503                         {
1504                                 net_nfc_util_create_record(record->TNF,
1505                                                 &record->type_s, &record->id_s,
1506                                                 &record->payload_s,
1507                                                 &context->record);
1508
1509                                 context->state = NET_NFC_LLCP_STEP_02;
1510                         }
1511                         else
1512                         {
1513                                 /* low power */
1514                                 context->state = NET_NFC_LLCP_STEP_06;
1515                         }
1516
1517                         net_nfc_util_free_ndef_message(request);
1518                 }
1519                 else
1520                 {
1521                         DEBUG_ERR_MSG("_net_nfc_server_handover_create"
1522                                         "_requester_from_rawdata failed [%d]",result);
1523                         context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1524                 }
1525         }
1526         else
1527         {
1528                 DEBUG_ERR_MSG("net_nfc_server_llcp_simple_receive failed [%d]",
1529                                 result);
1530                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1531         }
1532
1533         _net_nfc_server_handover_server_process(context);
1534 }
1535
1536 static void _net_nfc_server_handover_server_send_cb(net_nfc_error_e result,
1537                 net_nfc_target_handle_s *handle,
1538                 net_nfc_llcp_socket_t socket,
1539                 data_s *data,
1540                 void *user_param)
1541 {
1542         net_nfc_handover_context_t *context =
1543                 (net_nfc_handover_context_t *)user_param;
1544
1545         DEBUG_SERVER_MSG("_net_nfc_server_handover_server_send_cb"
1546                         " socket [%x], result [%d]", socket, result);
1547
1548         context->result = result;
1549
1550         if (result == NET_NFC_OK)
1551         {
1552                 context->state = NET_NFC_LLCP_STEP_01;
1553                 net_nfc_util_free_data(&context->data);
1554                 net_nfc_util_free_record(context->record);
1555                 context->record = NULL;
1556         }
1557         else
1558         {
1559                 DEBUG_ERR_MSG("net_nfc_server_llcp_simple_send failed [%d]",
1560                                 result);
1561                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1562         }
1563
1564         _net_nfc_server_handover_server_process(context);
1565 }
1566
1567 static void _net_nfc_server_handover_server_process(
1568                 net_nfc_handover_context_t *context)
1569 {
1570         if (context == NULL)
1571         {
1572                 return;
1573         }
1574
1575         switch (context->state)
1576         {
1577         case NET_NFC_LLCP_STEP_01 :
1578                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_01");
1579
1580                 /* receive request message */
1581                 net_nfc_server_llcp_simple_receive(context->handle,
1582                                 context->socket,
1583                                 _net_nfc_server_handover_server_recv_cb,
1584                                 context);
1585                 break;
1586
1587         case NET_NFC_LLCP_STEP_02 :
1588                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_02");
1589
1590                 context->result = _net_nfc_server_handover_create_selector_carrier_configs(
1591                                 context->type,
1592                                 _net_nfc_server_handover_server_create_carrier_config_cb,
1593                                 context);
1594
1595                 if (context->result != NET_NFC_OK)
1596                 {
1597                         DEBUG_ERR_MSG("_net_nfc_server_handover_create_selector"
1598                                         "_carrier_configs failed [%d]", context->result);
1599                 }
1600                 break;
1601
1602         case NET_NFC_LLCP_STEP_03 :
1603                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_03");
1604
1605                 context->result = net_nfc_server_handover_process_carrier_record(
1606                                 context->record,
1607                                 _net_nfc_server_handover_server_process_carrier_record_cb,
1608                                 context);
1609                 if (context->result != NET_NFC_OK)
1610                 {
1611                         DEBUG_ERR_MSG("_net_nfc_server_handover_process_carrier_"
1612                                         "record failed [%d]",context->result);
1613                 }
1614                 break;
1615
1616         case NET_NFC_LLCP_STEP_04 :
1617                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_04");
1618
1619                 /* send select message */
1620                 net_nfc_server_llcp_simple_send(
1621                                 context->handle,
1622                                 context->socket,
1623                                 &context->data,
1624                                 _net_nfc_server_handover_server_send_cb,
1625                                 context);
1626                 break;
1627
1628         case NET_NFC_STATE_ERROR :
1629                 DEBUG_SERVER_MSG("NET_NFC_STATE_ERROR");
1630
1631                 /* error, invoke callback */
1632                 DEBUG_ERR_MSG("handover_server failed, [%d]",
1633                                 context->result);
1634
1635                 /* restart?? */
1636                 break;
1637
1638         default :
1639                 DEBUG_ERR_MSG("NET_NFC_LLCP_STEP_??");
1640                 /* TODO */
1641                 break;
1642         }
1643 }
1644
1645 static void _net_nfc_server_handover_server_error_cb(
1646                 net_nfc_error_e result,
1647                 net_nfc_target_handle_s *handle,
1648                 net_nfc_llcp_socket_t socket,
1649                 data_s *data,
1650                 void *user_param)
1651 {
1652         net_nfc_handover_context_t *context =
1653                 (net_nfc_handover_context_t *)user_param;
1654
1655         DEBUG_ERR_MSG("result [%d], socket [%x], user_param [%p]",
1656                         result, socket, user_param);
1657
1658         if (context == NULL)
1659         {
1660                 return;
1661         }
1662
1663         net_nfc_controller_llcp_socket_close(socket, &result);
1664
1665         net_nfc_util_free_record(context->record);
1666         net_nfc_util_free_data(&context->data);
1667         _net_nfc_util_free_mem(user_param);
1668 }
1669
1670 static void _net_nfc_server_handover_server_incomming_cb(
1671                 net_nfc_error_e result,
1672                 net_nfc_target_handle_s *handle,
1673                 net_nfc_llcp_socket_t socket,
1674                 data_s *data,
1675                 void *user_param)
1676 {
1677         DEBUG_SERVER_MSG("result [%d], socket [%x], user_param [%p]",
1678                         result, socket, user_param);
1679
1680         net_nfc_handover_context_t *accept_context = NULL;
1681
1682         _net_nfc_util_alloc_mem(accept_context, sizeof(*accept_context));
1683         if (accept_context == NULL)
1684         {
1685                 DEBUG_ERR_MSG("_net_nfc_util_alloc_mem failed");
1686
1687                 result = NET_NFC_ALLOC_FAIL;
1688                 goto ERROR;
1689         }
1690
1691         accept_context->handle = handle;
1692         accept_context->socket = socket;
1693         accept_context->state = NET_NFC_LLCP_STEP_01;
1694
1695         result = net_nfc_server_llcp_simple_accept(
1696                         handle,
1697                         socket,
1698                         _net_nfc_server_handover_server_error_cb,
1699                         accept_context);
1700
1701         if (result != NET_NFC_OK)
1702         {
1703                 DEBUG_ERR_MSG("net_nfc_server_llcp_simple_accept failed, [%d]",
1704                                 result);
1705
1706                 goto ERROR;
1707         }
1708
1709         _net_nfc_server_handover_server_process(accept_context);
1710
1711         return;
1712
1713 ERROR :
1714         if (accept_context != NULL)
1715         {
1716                 _net_nfc_util_free_mem(accept_context);
1717         }
1718
1719         net_nfc_controller_llcp_socket_close(socket, &result);
1720
1721         /* TODO : restart ?? */
1722 }
1723
1724 net_nfc_error_e net_nfc_server_handover_default_server_start(
1725                 net_nfc_target_handle_s *handle)
1726 {
1727         net_nfc_error_e result;
1728
1729         /* start default handover server using snep */
1730         result =
1731                 net_nfc_server_snep_default_server_register_get_response_cb(
1732                                 _net_nfc_server_handover_get_response_cb,
1733                                 NULL);
1734
1735         /* start default handover server */
1736         result = net_nfc_server_llcp_simple_server(
1737                         handle,
1738                         CH_SAN,
1739                         CH_SAP,
1740                         _net_nfc_server_handover_server_incomming_cb,
1741                         _net_nfc_server_handover_server_error_cb,
1742                         NULL);
1743
1744         if (result == NET_NFC_OK)
1745         {
1746                 DEBUG_SERVER_MSG("start handover server, san [%s], sap [%d]",
1747                                 CH_SAN,CH_SAP);
1748         }
1749         else
1750         {
1751                 DEBUG_ERR_MSG("net_nfc_server_llcp_simple_server failed, [%d]",
1752                                 result);
1753         }
1754
1755         return result;
1756 }
1757
1758 static void _handover_default_activate_cb(int event,
1759                 net_nfc_target_handle_s *handle, uint32_t sap, const char *san, void *user_param)
1760 {
1761         net_nfc_error_e result;
1762
1763         DEBUG_SERVER_MSG("event [%d], handle [%p], sap [%d], san [%s]",
1764                         event, handle, sap, san);
1765
1766         if (event == NET_NFC_LLCP_START) {
1767                 /* start default handover server using snep */
1768                 result = net_nfc_server_snep_default_server_register_get_response_cb(
1769                                 _net_nfc_server_handover_get_response_cb, NULL);
1770
1771                 /* start default handover server */
1772                 result = net_nfc_server_llcp_simple_server(handle,
1773                                 CH_SAN, CH_SAP,
1774                                 _net_nfc_server_handover_server_incomming_cb,
1775                                 _net_nfc_server_handover_server_error_cb, NULL);
1776
1777                 if (result == NET_NFC_OK) {
1778                         DEBUG_SERVER_MSG("start handover server, san [%s], sap [%d]",
1779                                         CH_SAN, CH_SAP);
1780                 } else {
1781                         DEBUG_ERR_MSG("net_nfc_service_llcp_server failed, [%d]",
1782                                         result);
1783                 }
1784         } else if (event == NET_NFC_LLCP_UNREGISTERED) {
1785                 /* unregister server, do nothing */
1786         }
1787 }
1788
1789 net_nfc_error_e net_nfc_server_handover_default_server_register()
1790 {
1791         char id[20];
1792
1793         /* TODO : make id, */
1794         snprintf(id, sizeof(id), "%d", getpid());
1795
1796         /* start default snep server */
1797         return net_nfc_server_llcp_register_service(id,
1798                         CH_SAP,
1799                         CH_SAN,
1800                         _handover_default_activate_cb,
1801                         NULL);
1802 }
1803
1804 net_nfc_error_e net_nfc_server_handover_default_server_unregister()
1805 {
1806         char id[20];
1807
1808         /* TODO : make id, */
1809         snprintf(id, sizeof(id), "%d", getpid());
1810
1811         /* start default snep server */
1812         return net_nfc_server_llcp_unregister_service(id,
1813                         CH_SAP,
1814                         CH_SAN);
1815 }
1816
1817 ////////////////////////////////////////////////////////////////////////////////
1818
1819 static void _net_nfc_server_handover_client_post_process_cb(
1820                 net_nfc_error_e result,
1821                 net_nfc_conn_handover_carrier_type_e type,
1822                 data_s *data,
1823                 void *user_param)
1824 {
1825         net_nfc_handover_context_t *context =
1826                 (net_nfc_handover_context_t *)user_param;
1827
1828         if (context == NULL)
1829         {
1830                 return;
1831         }
1832
1833         context->state = NET_NFC_LLCP_STEP_RETURN;
1834
1835         _net_nfc_server_handover_client_process(context);
1836 }
1837
1838 static void _net_nfc_server_handover_client_process_carrier_record_cb(
1839                 net_nfc_error_e result,
1840                 net_nfc_conn_handover_carrier_type_e type,
1841                 data_s *data,
1842                 void *user_param)
1843 {
1844         net_nfc_handover_context_t *context =
1845                 (net_nfc_handover_context_t *)user_param;
1846
1847         DEBUG_SERVER_MSG("_net_nfc_server_handover_server_process"
1848                         "_carrier_record_cb,result [%d]",result);
1849
1850         context->result = result;
1851
1852         net_nfc_util_free_data(&context->data);
1853
1854         if (result == NET_NFC_OK)
1855         {
1856                 net_nfc_util_alloc_data(&context->data, data->length);
1857                 memcpy(context->data.buffer, data->buffer, data->length);
1858
1859                 context->state = NET_NFC_LLCP_STEP_05;
1860         }
1861         else
1862         {
1863                 context->state = NET_NFC_MESSAGE_LLCP_ERROR;
1864         }
1865
1866         _net_nfc_server_handover_client_process(context);
1867 }
1868
1869 static void _net_nfc_server_handover_client_recv_cb(net_nfc_error_e result,
1870                 net_nfc_target_handle_s *handle,
1871                 net_nfc_llcp_socket_t socket,
1872                 data_s *data,
1873                 void *user_param)
1874 {
1875         net_nfc_handover_context_t *context =
1876                 (net_nfc_handover_context_t *)user_param;
1877
1878         if (context == NULL)
1879         {
1880                 return;
1881         }
1882
1883         context->result = result;
1884
1885         if (result == NET_NFC_OK)
1886         {
1887                 ndef_message_s *selector;
1888                 ndef_record_s *record;
1889
1890                 result = net_nfc_server_handover_create_selector_from_rawdata(
1891                                 &selector,
1892                                 data);
1893
1894                 if (result == NET_NFC_OK)
1895                 {
1896                         result =
1897                                 net_nfc_server_handover_get_carrier_record_by_priority_order(
1898                                                 selector,
1899                                                 &record);
1900
1901                         if (result == NET_NFC_OK)
1902                         {
1903                                 net_nfc_util_create_record(
1904                                                 record->TNF,
1905                                                 &record->type_s, &record->id_s,
1906                                                 &record->payload_s,
1907                                                 &context->record);
1908
1909                                 context->state = NET_NFC_LLCP_STEP_04;
1910                         }
1911                         else
1912                         {
1913                                 DEBUG_ERR_MSG("_get_carrier_record_by_priority_order"
1914                                                 " failed, [%d]",result);
1915                                 context->state = NET_NFC_STATE_ERROR;
1916                         }
1917                 }
1918                 else
1919                 {
1920                         DEBUG_ERR_MSG("_net_nfc_server_handover_create"
1921                                         "_selector_from_rawdata failed, [%d]",result);
1922                         context->state = NET_NFC_STATE_ERROR;
1923                 }
1924         }
1925         else
1926         {
1927                 DEBUG_ERR_MSG("net_nfc_server_llcp_simple_receive failed, [%d]",
1928                                 result);
1929                 context->state = NET_NFC_STATE_ERROR;
1930         }
1931
1932         _net_nfc_server_handover_client_process(context);
1933 }
1934
1935 static void _net_nfc_server_handover_client_send_cb(net_nfc_error_e result,
1936                 net_nfc_target_handle_s *handle,
1937                 net_nfc_llcp_socket_t socket,
1938                 data_s *data,
1939                 void *user_param)
1940 {
1941         net_nfc_handover_context_t *context =
1942                 (net_nfc_handover_context_t *)user_param;
1943
1944         if (context == NULL)
1945         {
1946                 return;
1947         }
1948
1949         context->result = result;
1950
1951         net_nfc_util_free_data(&context->data);
1952
1953         if (result == NET_NFC_OK)
1954         {
1955                 context->state = NET_NFC_LLCP_STEP_03;
1956         }
1957         else
1958         {
1959                 DEBUG_ERR_MSG("net_nfc_server_llcp_simple_client failed, [%d]",
1960                                 result);
1961                 context->state = NET_NFC_STATE_ERROR;
1962         }
1963
1964         _net_nfc_server_handover_client_process(context);
1965 }
1966
1967 static void _net_nfc_server_handover_client_create_carrier_configs_cb(
1968                 net_nfc_error_e result,
1969                 ndef_message_s *msg,
1970                 void *user_param)
1971 {
1972         net_nfc_handover_context_t *context =
1973                 (net_nfc_handover_context_t *)user_param;
1974
1975         if (context == NULL) {
1976                 return;
1977         }
1978
1979         context->result = result;
1980
1981         if (msg != NULL)
1982         {
1983                 if ((result =
1984                                         _net_nfc_server_handover_convert_ndef_message_to_data(
1985                                                 msg,
1986                                                 &context->data)) == NET_NFC_OK)
1987                 {
1988                         context->state = NET_NFC_LLCP_STEP_02;
1989                 }
1990                 else
1991                 {
1992                         DEBUG_ERR_MSG("_net_nfc_server_handover_convert_ndef_"
1993                                         "message_to_data failed [%d]",result);
1994                         context->state = NET_NFC_STATE_ERROR;
1995                         context->result = result;
1996                 }
1997         }
1998         else
1999         {
2000                 DEBUG_ERR_MSG("null param, [%d]", result);
2001                 context->state = NET_NFC_STATE_ERROR;
2002                 context->result = result;
2003         }
2004
2005         _net_nfc_server_handover_client_process(context);
2006 }
2007
2008
2009 ////////////////////////////////////////////////////////////////////////////////
2010 static void _net_nfc_server_handover_client_process(
2011                 net_nfc_handover_context_t *context)
2012 {
2013         net_nfc_error_e result;
2014
2015         if (context == NULL)
2016         {
2017                 return;
2018         }
2019
2020         switch (context->state)
2021         {
2022         case NET_NFC_LLCP_STEP_01 :
2023                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_01");
2024
2025                 if ((result = _net_nfc_server_handover_create_requester_carrier_configs(
2026                                                 context->type,
2027                                                 _net_nfc_server_handover_client_create_carrier_configs_cb,
2028                                                 context)) != NET_NFC_OK)
2029                 {
2030                         DEBUG_ERR_MSG("_net_nfc_server_handover_create_requester"
2031                                         "_carrier_configs failed [%d]",result);
2032                 }
2033                 break;
2034
2035         case NET_NFC_LLCP_STEP_02 :
2036                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_02");
2037
2038                 /* send request */
2039                 net_nfc_server_llcp_simple_send(
2040                                 context->handle,
2041                                 context->socket,
2042                                 &context->data,
2043                                 _net_nfc_server_handover_client_send_cb,
2044                                 context);
2045                 break;
2046
2047         case NET_NFC_LLCP_STEP_03 :
2048                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_03");
2049
2050                 /* receive response */
2051                 net_nfc_server_llcp_simple_receive(context->handle,
2052                                 context->socket,
2053                                 _net_nfc_server_handover_client_recv_cb,
2054                                 context);
2055                 break;
2056
2057         case NET_NFC_LLCP_STEP_04 :
2058                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_04");
2059
2060                 result = net_nfc_server_handover_process_carrier_record(
2061                                 context->record,
2062                                 _net_nfc_server_handover_client_process_carrier_record_cb,
2063                                 context);
2064
2065                 if (result != NET_NFC_OK)
2066                 {
2067                         DEBUG_ERR_MSG("net_nfc_server_handover_process_carrier_record failed [%d]",result);
2068                 }
2069                 break;
2070
2071         case NET_NFC_LLCP_STEP_05 :
2072                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_05");
2073
2074                 /* start post process */
2075                 if (context->type == NET_NFC_CONN_HANDOVER_CARRIER_BT)
2076                 {
2077                         net_nfc_server_handover_bt_post_process(
2078                                         &context->data,
2079                                         _net_nfc_server_handover_client_post_process_cb,
2080                                         context);
2081                 }
2082                 else
2083                 {
2084                         DEBUG_ERR_MSG("not supported...");
2085                 }
2086                 break;
2087
2088         case NET_NFC_LLCP_STEP_RETURN :
2089                 DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_RETURN");
2090
2091                 /* complete and invoke callback */
2092                 _net_nfc_server_handover_send_response(
2093                                 context->user_param,
2094                                 &context->data,
2095                                 context->result);
2096
2097                 net_nfc_util_free_data(&context->data);
2098                 net_nfc_util_free_record(context->record);
2099                 _net_nfc_util_free_mem(context);
2100                 break;
2101
2102         case NET_NFC_STATE_ERROR :
2103         default :
2104                 DEBUG_ERR_MSG("NET_NFC_STATE_ERROR");
2105
2106                 _net_nfc_server_handover_send_response(
2107                                 context->user_param,
2108                                 NULL,
2109                                 context->result);
2110                 break;
2111         }
2112 }
2113
2114
2115
2116 static void _net_nfc_server_handover_client_connected_cb(
2117                 net_nfc_error_e result,
2118                 net_nfc_target_handle_s *handle,
2119                 net_nfc_llcp_socket_t socket,
2120                 data_s *data,
2121                 void *user_param)
2122 {
2123         DEBUG_SERVER_MSG("result [%d], socket [%x], user_param [%p]",
2124                         result, socket, user_param);
2125
2126         if (result == NET_NFC_OK)
2127         {
2128                 net_nfc_handover_context_t *context = NULL;
2129                 _net_nfc_util_alloc_mem(context, sizeof(*context));
2130
2131                 if (context != NULL)
2132                 {
2133                         context->handle = handle;
2134                         context->socket = socket;
2135                         context->state = NET_NFC_LLCP_STEP_01;
2136                         context->user_param = user_param;
2137                         _net_nfc_server_handover_client_process(context);
2138                 }
2139                 else
2140                 {
2141                         DEBUG_ERR_MSG("_net_nfc_util_alloc_mem failed");
2142                         result = NET_NFC_ALLOC_FAIL;
2143                 }
2144         }
2145         else
2146         {
2147                 DEBUG_ERR_MSG("net_nfc_server_llcp_simple_client"
2148                                 " failed, [%d]", result);
2149         }
2150 }
2151
2152 static void _net_nfc_server_handover_client_error_cb(net_nfc_error_e result,
2153                 net_nfc_target_handle_s *handle,
2154                 net_nfc_llcp_socket_t socket,
2155                 data_s *data,
2156                 void *user_param)
2157 {
2158
2159         DEBUG_ERR_MSG("result [%d], socket [%x], user_param [%p]",
2160                         result, socket, user_param);
2161
2162         if (false)
2163         {
2164                 _net_nfc_server_handover_send_response(user_param, NULL, result);
2165         }
2166
2167         net_nfc_controller_llcp_socket_close(socket, &result);
2168 }
2169
2170
2171 net_nfc_error_e net_nfc_server_handover_default_client_start(
2172                 net_nfc_target_handle_s *handle, void *user_data)
2173 {
2174         net_nfc_error_e result;
2175
2176         result = net_nfc_server_llcp_simple_client(
2177                         handle,
2178                         CH_SAN,
2179                         CH_SAP,
2180                         _net_nfc_server_handover_client_connected_cb,
2181                         _net_nfc_server_handover_client_error_cb,
2182                         user_data);
2183
2184         if (result != NET_NFC_OK)
2185         {
2186                 DEBUG_ERR_MSG("net_nfc_server_llcp_simple_client"
2187                                 " failed, [%d]",result);
2188         }
2189
2190         return result;
2191 }