tests/net_nfc_test_llcp.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 "net_nfc_test_util.h"
  18 #include "net_nfc_client_llcp.h"
  19 #include "net_nfc_test_llcp.h"
  20 #include "net_nfc_data.h"
  21 #include "net_nfc_target_info.h"
  22 #include "net_nfc_typedef_internal.h"
  23
  24
  25 static net_nfc_llcp_socket_t server_test_socket;
  26 static net_nfc_llcp_socket_t client_test_socket;
  27
  28 static net_nfc_llcp_config_info_h llcp_config = NULL;
  29 static net_nfc_llcp_config_info_h llcp_config_sync = NULL;
  30 static net_nfc_llcp_config_info_h llcp_config_default = NULL;
  31 static net_nfc_llcp_config_info_h llcp_config_default_sync = NULL;
  32
  33
  34 /*********************************** utility Calls *************************************/
  35
  36 static void run_next_callback(gpointer user_data);
  37
  38 static void run_next_callback(gpointer user_data)
  39 {
  40         if (user_data)
  41         {
  42                 GCallback callback;
  43
  44                 callback = (GCallback)(user_data);
  45                 callback();
  46         }
  47 }
  48
  49 /*********************************** Callbacks *************************************/
  50
  51 static void llcp_default_config_cb(net_nfc_error_e result,
  52                 void *user_data)
  53 {
  54         g_print(" llcp_default_config_cb Completed %d\n", result);
  55
  56         run_next_callback(user_data);
  57 }
  58
  59 static void llcp_custom_config_cb(net_nfc_error_e result,
  60                 void *user_data)
  61 {
  62         g_print("llcp_custom_config_cb Completed %d\n", result);
  63
  64         run_next_callback(user_data);
  65 }
  66
  67 static void llcp_listen_socket_cb(net_nfc_error_e result,
  68                 net_nfc_llcp_socket_t client_socket,
  69                 void *user_data)
  70 {
  71
  72         g_print("llcp_listen_socket_cb  Completed %d\n", client_socket);
  73         g_print("llcp_listen_socket_cb  Completed %d\n", result);
  74
  75         run_next_callback(user_data);
  76 }
  77
  78 static void llcp_receive_socket_cb(net_nfc_error_e result,
  79                 data_h data,
  80                 void *user_data)
  81 {
  82         data_h received_data = data;
  83
  84         print_received_data(received_data);
  85
  86         g_print("llcp_listen_socket_cb  Completed %d\n", result);
  87
  88         run_next_callback(user_data);
  89 }
  90
  91 static void llcp_receive_from_socket_cb(net_nfc_error_e result,
  92                 sap_t sap,
  93                 data_h data,
  94                 void *user_data)
  95 {
  96         data_h received_data = data;
  97
  98         print_received_data(received_data);
  99
 100         g_print("llcp_receive_from_socket_cb    Completed %d\n", sap);
 101
 102         g_print("llcp_receive_from_socket_cb    Completed %d\n", result);
 103
 104         run_next_callback(user_data);
 105 }
 106
 107
 108 static void llcp_connect_socket_cb(net_nfc_error_e result,
 109                 net_nfc_llcp_socket_t client_socket,
 110                 void *user_data)
 111 {
 112         g_print("llcp_connect_socket_cb Completed %d\n", client_socket);
 113         g_print("llcp_connect_socket_cb Completed %d\n", result);
 114
 115         run_next_callback(user_data);
 116 }
 117
 118
 119 static void llcp_connect_sap_cb(net_nfc_error_e result,
 120                 net_nfc_llcp_socket_t client_socket,
 121                 void *user_data)
 122 {
 123         g_print("llcp_connect_socket_cb Completed %d\n", client_socket);
 124         g_print("llcp_connect_socket_cb Completed %d\n", result);
 125
 126         run_next_callback(user_data);
 127 }
 128
 129
 130 static void llcp_send_socket_cb(net_nfc_error_e result,
 131                 void *user_data)
 132 {
 133         g_print("llcp_send_socket_cb    Completed %d\n", result);
 134
 135         run_next_callback(user_data);
 136
 137 }
 138
 139 static void llcp_send_to_socket_cb(net_nfc_error_e result,
 140                 void *user_data)
 141 {
 142         g_print("llcp_send_to_socket_cb Completed %d\n", result);
 143
 144         run_next_callback(user_data);
 145
 146 }
 147
 148 static void llcp_disconnect_socket_cb(net_nfc_error_e result,
 149                 void *user_data)
 150 {
 151         g_print("llcp_send_to_socket_cb Completed %d\n", result);
 152
 153         run_next_callback(user_data);
 154
 155 }
 156
 157
 158 /*********************************** Function Calls *************************************/
 159
 160 void net_nfc_test_llcp_default_config(gpointer data,
 161                 gpointer user_data)
 162 {
 163         net_nfc_error_e result;
 164
 165         result = net_nfc_client_llcp_create_config_default(&llcp_config_default);
 166
 167         if(result != NET_NFC_OK)
 168         {
 169                 g_print(" llcp create default config failed: %d\n", result);
 170                 run_next_callback(user_data);
 171                 return;
 172
 173         }
 174         result = net_nfc_client_llcp_config(llcp_config_default,
 175                         llcp_default_config_cb,
 176                         user_data);
 177
 178 }
 179
 180 void net_nfc_test_llcp_default_config_sync(gpointer data,
 181                 gpointer user_data)
 182 {
 183         net_nfc_error_e result;
 184
 185         result = net_nfc_client_llcp_create_config_default(&llcp_config_default_sync);
 186
 187         if(result != NET_NFC_OK)
 188         {
 189                 g_print(" llcp create default config failed: %d\n", result);
 190                 run_next_callback(user_data);
 191                 return;
 192
 193         }
 194
 195         result = net_nfc_client_llcp_config_sync(llcp_config_default_sync);
 196         if(result == NET_NFC_OK)
 197         {
 198                 g_print(" llcp create default config (sync) success: %d\n", result);
 199         }
 200
 201 }
 202
 203
 204 void net_nfc_test_llcp_custom_config(gpointer data,
 205                 gpointer user_data)
 206 {
 207
 208         net_nfc_error_e result;
 209
 210         result = net_nfc_client_llcp_create_config(&llcp_config,128, 1, 10, 0);
 211
 212         if(result != NET_NFC_OK)
 213         {
 214                 g_print(" llcp create custom config failed: %d\n", result);
 215                 run_next_callback(user_data);
 216                 return;
 217
 218         }
 219         result = net_nfc_client_llcp_config(llcp_config,
 220                         llcp_custom_config_cb,
 221                         user_data);
 222
 223 }
 224
 225
 226
 227 void net_nfc_test_llcp_custom_config_sync(gpointer data,
 228                 gpointer user_data)
 229 {
 230
 231         net_nfc_error_e result;
 232
 233         result = net_nfc_client_llcp_create_config(&llcp_config_sync,128, 1, 10, 0);
 234
 235         if(result != NET_NFC_OK)
 236         {
 237                 g_print(" net_nfc_test_llcp_custom_config_sync failed: %d\n", result);
 238                 run_next_callback(user_data);
 239                 return;
 240
 241         }
 242         result = net_nfc_client_llcp_config_sync(llcp_config_sync);
 243
 244         if(result == NET_NFC_OK)
 245         {
 246                 g_print(" net_nfc_test_llcp_custom_config_sync (sync) success: %d\n", result);
 247         }
 248
 249 }
 250
 251 void net_nfc_test_llcp_get_local_config(gpointer data,
 252                 gpointer user_data)
 253 {
 254         net_nfc_llcp_config_info_h local_config;
 255         net_nfc_error_e result;
 256
 257         result = net_nfc_client_llcp_get_local_config(&local_config);
 258
 259         if(result != NET_NFC_OK)
 260         {
 261                 g_print(" llcp create custom config failed: %d\n", result);
 262                 run_next_callback(user_data);
 263                 return;
 264
 265         }
 266
 267         g_print(" net_nfc_test_llcp_get_local_config: %d\n", local_config->miu);
 268         g_print("net_nfc_test_llcp_get_local_config: %d\n", local_config->wks);
 269         g_print(" net_nfc_test_llcp_get_local_config: %d\n", local_config->lto);
 270         g_print("net_nfc_test_llcp_get_local_config: %d\n", local_config->option);
 271
 272 }
 273
 274
 275 /*commented because remote config API is not available*/
 276 /*
 277    void net_nfc_test_llcp_get_remote_config(gpointer data,
 278    gpointer user_data)
 279    {
 280    net_nfc_llcp_config_info_h local_config;
 281    net_nfc_error_e result;
 282
 283    result = net_nfc_client_llcp_get_local_config(&local_config);
 284
 285    if(result != NET_NFC_OK)
 286    {
 287    g_print(" llcp create custom config failed: %d\n", result);
 288    run_next_callback(user_data);
 289    return;
 290
 291    }
 292
 293    g_print(" net_nfc_test_llcp_get_local_config: %d\n", local_config->miu);
 294    g_print("net_nfc_test_llcp_get_local_config: %d\n", local_config->wks);
 295    g_print(" net_nfc_test_llcp_get_local_config: %d\n", local_config->lto);
 296    g_print("net_nfc_test_llcp_get_local_config: %d\n", local_config->option);
 297
 298    }
 299  */
 300
 301 void net_nfc_test_llcp_get_config_miu(gpointer data,
 302                 gpointer user_data)
 303 {
 304
 305         net_nfc_error_e result;
 306         uint16_t miu;
 307
 308         result = net_nfc_client_llcp_get_config_miu(llcp_config,&miu);
 309
 310         if(result != NET_NFC_OK)
 311         {
 312                 g_print(" net_nfc_test_llcp_get_config_miu failed: %d\n", result);
 313                 run_next_callback(user_data);
 314                 return;
 315         }
 316
 317         if(result == NET_NFC_OK)
 318         {
 319                 g_print(" net_nfc_test_llcp_get_config_miu ->: %d\n", miu);
 320         }
 321
 322         run_next_callback(user_data);
 323
 324 }
 325
 326
 327 void net_nfc_test_llcp_get_config_wks(gpointer data,
 328                 gpointer user_data)
 329 {
 330         net_nfc_error_e result;
 331         uint16_t wks;
 332
 333         result = net_nfc_client_llcp_get_config_wks(llcp_config,&wks);
 334
 335         if(result != NET_NFC_OK)
 336         {
 337                 g_print(" net_nfc_test_llcp_get_config_wks failed: %d\n", result);
 338                 run_next_callback(user_data);
 339                 return;
 340         }
 341
 342         if(result == NET_NFC_OK)
 343         {
 344                 g_print(" net_nfc_test_llcp_get_config_wks -> %d\n",wks);
 345         }
 346
 347         run_next_callback(user_data);
 348 }
 349
 350 void net_nfc_test_llcp_get_config_lto(gpointer data,
 351                 gpointer user_data)
 352 {
 353         net_nfc_error_e result;
 354         uint8_t lto;
 355
 356         result = net_nfc_client_llcp_get_config_lto(llcp_config,&lto);
 357
 358         if(result != NET_NFC_OK)
 359         {
 360                 g_print(" net_nfc_client_llcp_get_config_lto failed: %d\n", result);
 361                 run_next_callback(user_data);
 362                 return;
 363         }
 364
 365         if(result == NET_NFC_OK)
 366         {
 367                 g_print(" net_nfc_client_llcp_get_config_lto -> %d\n",lto);
 368         }
 369
 370         run_next_callback(user_data);
 371
 372 }
 373
 374
 375 void net_nfc_test_llcp_get_config_option(gpointer data,
 376                 gpointer user_data)
 377 {
 378         net_nfc_error_e result;
 379         uint8_t option;
 380
 381         result = net_nfc_client_llcp_get_config_option(llcp_config,&option);
 382
 383         if(result != NET_NFC_OK)
 384         {
 385                 g_print(" net_nfc_test_llcp_get_config_option failed: %d\n", result);
 386                 run_next_callback(user_data);
 387                 return;
 388         }
 389
 390         if(result == NET_NFC_OK)
 391         {
 392                 g_print(" net_nfc_test_llcp_get_config_option -> %d\n",option);
 393         }
 394
 395         run_next_callback(user_data);
 396
 397 }
 398
 399
 400 void net_nfc_test_llcp_set_config_miu(gpointer data,
 401                 gpointer user_data)
 402 {
 403         net_nfc_error_e result;
 404         uint16_t miu = 128;
 405
 406         result = net_nfc_client_llcp_set_config_miu(llcp_config,miu);
 407
 408         if(result != NET_NFC_OK)
 409         {
 410                 g_print(" net_nfc_test_llcp_get_config_miu failed: %d\n", result);
 411                 run_next_callback(user_data);
 412                 return;
 413         }
 414
 415         if(result == NET_NFC_OK)
 416         {
 417                 g_print(" net_nfc_test_llcp_set_config_miu successfull \n");
 418         }
 419
 420         run_next_callback(user_data);
 421
 422 }
 423
 424
 425 void net_nfc_test_llcp_set_config_wks(gpointer data,
 426                 gpointer user_data)
 427 {
 428         net_nfc_error_e result;
 429         uint16_t wks = 1;
 430
 431         result = net_nfc_client_llcp_set_config_wks(llcp_config,wks);
 432
 433         if(result != NET_NFC_OK)
 434         {
 435                 g_print(" net_nfc_test_llcp_set_config_wks failed: %d\n", result);
 436                 run_next_callback(user_data);
 437                 return;
 438         }
 439
 440         if(result == NET_NFC_OK)
 441         {
 442                 g_print(" net_nfc_test_llcp_set_config_wks successfull \n");
 443         }
 444
 445         run_next_callback(user_data);
 446
 447 }
 448
 449
 450 void net_nfc_test_llcp_set_config_lto(gpointer data,
 451                 gpointer user_data)
 452 {
 453         net_nfc_error_e result;
 454         uint16_t lto = 10;
 455
 456         result = net_nfc_client_llcp_set_config_lto(llcp_config,lto);
 457
 458         if(result != NET_NFC_OK)
 459         {
 460                 g_print(" net_nfc_test_llcp_set_config_lto failed: %d\n", result);
 461                 run_next_callback(user_data);
 462                 return;
 463         }
 464
 465         if(result == NET_NFC_OK)
 466         {
 467                 g_print(" net_nfc_test_llcp_set_config_lto successfull \n");
 468         }
 469         run_next_callback(user_data);
 470
 471 }
 472
 473
 474 void net_nfc_test_llcp_set_config_option(gpointer data,
 475                 gpointer user_data)
 476 {
 477
 478         net_nfc_error_e result;
 479         uint8_t option = 0;
 480
 481         result = net_nfc_client_llcp_set_config_lto(llcp_config,option);
 482
 483         if(result != NET_NFC_OK)
 484         {
 485                 g_print(" net_nfc_test_llcp_set_config_option failed: %d\n", result);
 486                 run_next_callback(user_data);
 487                 return;
 488         }
 489
 490         if(result == NET_NFC_OK)
 491         {
 492                 g_print(" net_nfc_test_llcp_set_config_option successfull \n");
 493         }
 494         run_next_callback(user_data);
 495 }
 496
 497
 498 void net_nfc_test_llcp_free_config(gpointer data,
 499                 gpointer user_data)
 500 {
 501         net_nfc_error_e result;
 502
 503         result = net_nfc_client_llcp_free_config(llcp_config);
 504
 505         if(result != NET_NFC_OK)
 506         {
 507                 g_print(" net_nfc_test_llcp_free_config failed: %d\n", result);
 508                 run_next_callback(user_data);
 509                 return;
 510         }
 511
 512         if(result == NET_NFC_OK)
 513         {
 514                 g_print(" net_nfc_test_llcp_free_config successfull \n");
 515         }
 516         run_next_callback(user_data);
 517 }
 518
 519
 520 void net_nfc_test_llcp_create_custom_socket_option(gpointer data,
 521                 gpointer user_data)
 522 {
 523         net_nfc_llcp_socket_option_h option;
 524         net_nfc_error_e result;
 525
 526         result = net_nfc_client_llcp_create_socket_option(&option,
 527                         128,
 528                         1,
 529                         NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED);
 530
 531         if(result != NET_NFC_OK)
 532         {
 533                 g_print(" net_nfc_client_llcp_create_socket_option failed: %d\n", result);
 534                 run_next_callback(user_data);
 535
 536                 return;
 537         }
 538
 539         g_print(" net_nfc_client_llcp_create_socket_option : %d\n", result);
 540         run_next_callback(user_data);
 541
 542 }
 543
 544 void net_nfc_test_llcp_create_default_socket_option(gpointer data,
 545                 gpointer user_data)
 546 {
 547         net_nfc_llcp_socket_option_h option;
 548         net_nfc_error_e result;
 549
 550         result = net_nfc_client_llcp_create_socket_option_default(&option);
 551
 552         if(result != NET_NFC_OK)
 553         {
 554                 g_print(" net_nfc_test_llcp_create_default_socket_option failed: %d\n", result);
 555                 run_next_callback(user_data);
 556                 return;
 557         }
 558
 559         g_print(" net_nfc_test_llcp_create_default_socket_option : %d\n", result);
 560         run_next_callback(user_data);
 561
 562 }
 563
 564 void net_nfc_test_llcp_get_local_socket_option(gpointer data,
 565                 gpointer user_data)
 566 {
 567         net_nfc_error_e result;
 568         net_nfc_llcp_socket_option_h option;
 569
 570         result = net_nfc_client_llcp_get_local_socket_option(client_test_socket,&option);
 571
 572         if(result != NET_NFC_OK)
 573         {
 574                 g_print(" net_nfc_test_llcp_get_local_socket_option failed: %d\n", result);
 575                 run_next_callback(user_data);
 576                 return;
 577         }
 578
 579         g_print(" net_nfc_test_llcp_get_local_socket_option: %d\n", option->miu);
 580         g_print("net_nfc_test_llcp_get_local_socket_option: %d\n", option->rw);
 581         g_print(" net_nfc_test_llcp_get_local_socket_option: %d\n", option->type);
 582
 583         run_next_callback(user_data);
 584 }
 585
 586 void net_nfc_test_llcp_get_socket_option_miu(gpointer data,
 587                 gpointer user_data)
 588 {
 589         net_nfc_llcp_socket_option_s option;
 590         net_nfc_error_e result;
 591         uint16_t miu;
 592
 593         result = net_nfc_client_llcp_get_socket_option_miu(&option,&miu);
 594
 595         if(result != NET_NFC_OK)
 596         {
 597                 g_print(" net_nfc_client_llcp_get_socket_option_miu failed: %d\n", result);
 598                 run_next_callback(user_data);
 599
 600                 return;
 601         }
 602
 603         g_print(" net_nfc_test_llcp_get_socket_option_miu : %d\n", miu);
 604         run_next_callback(user_data);
 605 }
 606
 607
 608 void net_nfc_test_llcp_set_socket_option_miu(gpointer data,
 609                 gpointer user_data)
 610 {
 611         net_nfc_llcp_socket_option_s option;
 612         net_nfc_error_e result;
 613         uint16_t miu = 128;
 614
 615         result = net_nfc_client_llcp_set_socket_option_miu(&option,miu);
 616
 617         if(result != NET_NFC_OK)
 618         {
 619                 g_print(" net_nfc_test_llcp_set_socket_option_miu failed: %d\n", result);
 620                 run_next_callback(user_data);
 621                 return;
 622         }
 623
 624         g_print(" net_nfc_test_llcp_set_socket_option_miu : %d\n", miu);
 625         run_next_callback(user_data);
 626 }
 627
 628 void net_nfc_test_llcp_get_socket_option_rw(gpointer data,
 629                 gpointer user_data)
 630 {
 631         net_nfc_llcp_socket_option_s option;
 632         net_nfc_error_e result;
 633         uint8_t rw;
 634
 635         result = net_nfc_client_llcp_get_socket_option_rw(&option,&rw);
 636
 637         if(result != NET_NFC_OK)
 638         {
 639                 g_print(" net_nfc_test_llcp_get_socket_option_rw failed: %d\n", result);
 640                 run_next_callback(user_data);
 641                 return;
 642         }
 643
 644         g_print(" net_nfc_test_llcp_get_socket_option_rw : %d\n", rw);
 645         run_next_callback(user_data);
 646 }
 647
 648
 649 void net_nfc_test_llcp_set_socket_option_rw(gpointer data,
 650                 gpointer user_data)
 651 {
 652         net_nfc_llcp_socket_option_s option;
 653         net_nfc_error_e result;
 654         uint8_t rw = 1;
 655
 656         result = net_nfc_client_llcp_set_socket_option_rw(&option,rw);
 657
 658         if(result != NET_NFC_OK)
 659         {
 660                 g_print(" net_nfc_test_llcp_set_socket_option_rw failed: %d\n", result);
 661                 run_next_callback(user_data);
 662                 return;
 663         }
 664
 665         g_print(" net_nfc_test_llcp_set_socket_option_rw : %d\n", rw);
 666         run_next_callback(user_data);
 667 }
 668
 669 void net_nfc_test_llcp_get_socket_option_type(gpointer data,
 670                 gpointer user_data)
 671 {
 672         net_nfc_llcp_socket_option_s option;
 673         net_nfc_error_e result;
 674         net_nfc_socket_type_e type;
 675
 676         result = net_nfc_client_llcp_get_socket_option_type(&option,&type);
 677
 678         if(result != NET_NFC_OK)
 679         {
 680                 g_print(" net_nfc_test_llcp_get_socket_option_type failed: %d\n", result);
 681                 run_next_callback(user_data);
 682                 return;
 683         }
 684
 685         g_print(" net_nfc_test_llcp_get_socket_option_type : %d\n", type);
 686         run_next_callback(user_data);
 687 }
 688
 689
 690 void net_nfc_test_llcp_set_socket_option_type(gpointer data,
 691                 gpointer user_data)
 692 {
 693         net_nfc_llcp_socket_option_s option;
 694         net_nfc_error_e result;
 695         net_nfc_socket_type_e type = NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED;
 696
 697         result = net_nfc_client_llcp_set_socket_option_type(&option,type);
 698
 699         if(result != NET_NFC_OK)
 700         {
 701                 g_print(" net_nfc_test_llcp_set_socket_option_type failed: %d\n", result);
 702                 run_next_callback(user_data);
 703                 return;
 704         }
 705
 706         g_print(" net_nfc_test_llcp_set_socket_option_type : %d\n", type);
 707         run_next_callback(user_data);
 708 }
 709
 710 void net_nfc_test_llcp_free_socket_option(gpointer data,
 711                 gpointer user_data)
 712 {
 713         net_nfc_llcp_socket_option_s option;
 714         net_nfc_error_e result;
 715
 716         result = net_nfc_client_llcp_free_socket_option(&option);
 717
 718         if(result != NET_NFC_OK)
 719         {
 720                 g_print(" net_nfc_test_llcp_free_socket_option failed: %d\n", result);
 721                 run_next_callback(user_data);
 722                 return;
 723         }
 724
 725         g_print(" net_nfc_test_llcp_free_socket_option : %d\n", result);
 726         run_next_callback(user_data);
 727 }
 728
 729
 730 void net_nfc_test_llcp_listen(gpointer data,
 731                 gpointer user_data)
 732 {
 733         net_nfc_error_e result;
 734
 735         net_nfc_client_llcp_create_socket(&server_test_socket,NULL);
 736
 737         result = net_nfc_client_llcp_listen(server_test_socket,
 738                         "urn:nfc:xsn:samsung.com:testllcp" ,
 739                         16 ,
 740                         llcp_listen_socket_cb,
 741                         NULL);
 742
 743         if(result != NET_NFC_OK)
 744         {
 745                 g_print(" net_nfc_client_llcp_listen failed: %d\n", result);
 746                 return;
 747         }
 748 }
 749
 750 void net_nfc_test_llcp_listen_sync(gpointer data,
 751                 gpointer user_data)
 752 {
 753         net_nfc_error_e result;
 754         net_nfc_llcp_socket_t out_socket;
 755
 756         net_nfc_client_llcp_create_socket(&server_test_socket,NULL);
 757
 758         result = net_nfc_client_llcp_listen_sync(server_test_socket,
 759                         "urn:nfc:xsn:samsung.com:testllcp" ,
 760                         16 ,
 761                         &out_socket);
 762
 763         if(result != NET_NFC_OK)
 764         {
 765                 g_print(" net_nfc_test_llcp_listen_sync failed: %d\n", result);
 766                 run_next_callback(user_data);
 767                 return;
 768         }
 769
 770         g_print(" net_nfc_test_llcp_listen_sync : out_socket %d\n", out_socket);
 771         run_next_callback(user_data);
 772
 773 }
 774
 775
 776 void net_nfc_test_llcp_receive(gpointer data,
 777                 gpointer user_data)
 778 {
 779
 780         net_nfc_error_e result;
 781
 782
 783         result = net_nfc_client_llcp_receive(server_test_socket,
 784                         512,
 785                         llcp_receive_socket_cb,
 786                         NULL);
 787
 788         if(result != NET_NFC_OK)
 789         {
 790                 g_print(" net_nfc_client_llcp_listen failed: %d\n", result);
 791                 return;
 792         }
 793 }
 794
 795
 796 void net_nfc_test_llcp_receive_sync(gpointer data,
 797                 gpointer user_data)
 798 {
 799         net_nfc_error_e result;
 800         data_h out_data;
 801
 802
 803         result = net_nfc_client_llcp_receive_sync(server_test_socket,
 804                         512,
 805                         &out_data);
 806
 807         if(result != NET_NFC_OK)
 808         {
 809                 g_print(" net_nfc_client_llcp_listen failed: %d\n", result);
 810                 run_next_callback(user_data);
 811                 return;
 812         }
 813
 814         print_received_data(out_data);
 815         run_next_callback(user_data);
 816 }
 817
 818
 819
 820 void net_nfc_test_llcp_receive_from(gpointer data,
 821                 gpointer user_data)
 822 {
 823         net_nfc_error_e result;
 824
 825
 826         result = net_nfc_client_llcp_receive_from(server_test_socket,
 827                         512,
 828                         llcp_receive_from_socket_cb,
 829                         NULL);
 830
 831         if(result != NET_NFC_OK)
 832         {
 833                 g_print(" net_nfc_test_llcp_receive_from failed: %d\n", result);
 834                 return;
 835         }
 836 }
 837
 838 void net_nfc_test_llcp_receive_from_sync(gpointer data,
 839                 gpointer user_data)
 840 {
 841         net_nfc_error_e result;
 842         data_h out_data = NULL;
 843         sap_t sap_data = 0;
 844
 845         result = net_nfc_client_llcp_receive_from_sync(server_test_socket,
 846                         512,
 847                         &sap_data,
 848                         &out_data);
 849
 850         if(result != NET_NFC_OK)
 851         {
 852                 g_print(" net_nfc_client_llcp_listen failed: %d\n", result);
 853                 return;
 854         }
 855
 856         print_received_data(out_data);
 857         g_print(" net_nfc_test_llcp_receive_from_sync : %d\n", result);
 858         g_print(" net_nfc_test_llcp_receive_from_sync : %d\n", sap_data);
 859         run_next_callback(user_data);
 860 }
 861
 862
 863
 864 void net_nfc_test_llcp_connect(gpointer data,
 865                 gpointer user_data)
 866 {
 867         net_nfc_error_e result;
 868
 869         net_nfc_client_llcp_create_socket(&client_test_socket, NULL);
 870
 871         result = net_nfc_client_llcp_connect(client_test_socket,
 872                         "urn:nfc:xsn:samsung.com:testllcp",
 873                         llcp_connect_socket_cb,
 874                         user_data);
 875
 876         if(result != NET_NFC_OK)
 877         {
 878                 g_print(" net_nfc_test_llcp_connect failed: %d\n", result);
 879                 return;
 880         }
 881
 882 }
 883
 884 void net_nfc_test_llcp_connect_sync(gpointer data,
 885                 gpointer user_data)
 886 {
 887         net_nfc_error_e result;
 888         net_nfc_llcp_socket_t out_socket;
 889
 890         net_nfc_client_llcp_create_socket(&client_test_socket, NULL);
 891
 892         result = net_nfc_client_llcp_connect_sync(client_test_socket,
 893                         "urn:nfc:xsn:samsung.com:testllcp",
 894                         &out_socket);
 895
 896         if(result != NET_NFC_OK)
 897         {
 898                 g_print(" net_nfc_test_llcp_connect_sync failed: %d\n", result);
 899                 run_next_callback(user_data);
 900                 return;
 901         }
 902
 903         g_print(" net_nfc_test_llcp_connect_sync : out_socket %d\n", out_socket);
 904         run_next_callback(user_data);
 905 }
 906
 907 void net_nfc_test_llcp_connect_sap(gpointer data,
 908                 gpointer user_data)
 909 {
 910         net_nfc_error_e result;
 911
 912         net_nfc_client_llcp_create_socket(&client_test_socket, NULL);
 913
 914         result = net_nfc_client_llcp_connect_sap(client_test_socket,
 915                         16,
 916                         llcp_connect_sap_cb,
 917                         user_data);
 918
 919         if(result != NET_NFC_OK)
 920         {
 921                 g_print(" net_nfc_test_llcp_connect_sap failed: %d\n", result);
 922                 return;
 923         }
 924
 925 }
 926
 927 void net_nfc_test_llcp_connect_sap_sync(gpointer data,
 928                 gpointer user_data)
 929 {
 930         net_nfc_error_e result;
 931         net_nfc_llcp_socket_t out_socket;
 932
 933         net_nfc_client_llcp_create_socket(&client_test_socket, NULL);
 934
 935         result = net_nfc_client_llcp_connect_sap_sync(client_test_socket,
 936                         16,
 937                         &out_socket);
 938
 939         if(result != NET_NFC_OK)
 940         {
 941                 g_print(" net_nfc_test_llcp_connect_sap_sync failed: %d\n", result);
 942                 run_next_callback(user_data);
 943                 return;
 944         }
 945
 946         g_print(" net_nfc_test_llcp_connect_sap_sync : out_socket %d\n", out_socket);
 947         run_next_callback(user_data);
 948 }
 949
 950
 951
 952 void net_nfc_test_llcp_send(gpointer func_data,
 953                 gpointer user_data)
 954 {
 955         net_nfc_error_e result;
 956         data_h data;
 957         char * str = "Client message: Hello, server!";
 958
 959         net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
 960
 961         result = net_nfc_client_llcp_send(client_test_socket,
 962                         data,
 963                         llcp_send_socket_cb,
 964                         user_data);
 965
 966         if(result != NET_NFC_OK)
 967         {
 968                 g_print(" net_nfc_test_llcp_send failed: %d\n", result);
 969                 return;
 970         }
 971
 972 }
 973
 974 void net_nfc_test_llcp_send_sync(gpointer func_data,
 975                 gpointer user_data)
 976 {
 977         net_nfc_error_e result;
 978         data_h data;
 979         char * str = "Client message: Hello, server!";
 980
 981         net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
 982
 983         result = net_nfc_client_llcp_send_sync(client_test_socket,
 984                         data);
 985
 986         if(result != NET_NFC_OK)
 987         {
 988                 g_print(" net_nfc_test_llcp_connect failed: %d\n", result);
 989                 run_next_callback(user_data);
 990                 return;
 991         }
 992
 993         g_print(" net_nfc_test_llcp_send_sync success\n");
 994         run_next_callback(user_data);
 995
 996 }
 997
 998
 999 void net_nfc_test_llcp_send_to(gpointer func_data,
1000                 gpointer user_data)
1001 {
1002         net_nfc_error_e result;
1003         data_h data;
1004         char * str = "Client message: Hello, server!";
1005
1006         net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
1007
1008         result = net_nfc_client_llcp_send_to(client_test_socket,
1009                         16,
1010                         data,
1011                         llcp_send_to_socket_cb,
1012                         user_data);
1013
1014         if(result != NET_NFC_OK)
1015         {
1016                 g_print(" net_nfc_test_llcp_send_to failed: %d\n", result);
1017                 return;
1018         }
1019
1020 }
1021
1022
1023 void net_nfc_test_llcp_send_to_sync(gpointer func_data,
1024                 gpointer user_data)
1025 {
1026         net_nfc_error_e result;
1027         data_h data;
1028         char * str = "Client message: Hello, server!";
1029
1030         net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
1031
1032         result = net_nfc_client_llcp_send_to_sync(client_test_socket,
1033                         16,
1034                         data);
1035
1036         if(result != NET_NFC_OK)
1037         {
1038                 g_print(" net_nfc_test_llcp_send_to_sync failed: %d\n", result);
1039                 run_next_callback(user_data);
1040                 return;
1041         }
1042
1043         g_print(" net_nfc_test_llcp_send_to_sync success\n");
1044         run_next_callback(user_data);
1045
1046 }
1047
1048
1049 void net_nfc_test_llcp_disconnect(gpointer func_data,
1050                 gpointer user_data)
1051 {
1052         net_nfc_error_e result;
1053
1054         result = net_nfc_client_llcp_disconnect(client_test_socket,
1055                         llcp_disconnect_socket_cb,
1056                         user_data);
1057
1058         if(result != NET_NFC_OK)
1059         {
1060                 g_print(" net_nfc_test_llcp_disconnect failed: %d\n", result);
1061                 return;
1062         }
1063
1064 }
1065
1066 void net_nfc_test_llcp_disconnect_server(gpointer func_data,
1067                 gpointer user_data)
1068 {
1069         net_nfc_error_e result;
1070
1071         result = net_nfc_client_llcp_disconnect(server_test_socket,
1072                         llcp_disconnect_socket_cb,
1073                         user_data);
1074
1075         if(result != NET_NFC_OK)
1076         {
1077                 g_print(" net_nfc_test_llcp_disconnect accepted_socket failed: %d\n", result);
1078                 return;
1079         }
1080 }
1081
1082
1083 void net_nfc_test_llcp_disconnect_sync(gpointer func_data,
1084                 gpointer user_data)
1085 {
1086         net_nfc_error_e result;
1087
1088         result = net_nfc_client_llcp_disconnect_sync(client_test_socket);
1089
1090         if(result != NET_NFC_OK)
1091         {
1092                 g_print(" net_nfc_test_llcp_disconnect_sync failed: %d\n", result);
1093                 run_next_callback(user_data);
1094                 return;
1095         }
1096
1097         g_print(" net_nfc_test_llcp_disconnect_sync success\n");
1098         run_next_callback(user_data);
1099 }