src/net_nfc_client_tag_mifare.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 #include <glib.h>
  17 #include <string.h>
  18
  19 #include "net_nfc_client_transceive.h"
  20 #include "net_nfc_client_tag_internal.h"
  21
  22 #include "net_nfc_tag_mifare.h"
  23
  24 #include "net_nfc_data.h"
  25 #include "net_nfc_typedef_internal.h"
  26 #include "net_nfc_debug_internal.h"
  27 #include "net_nfc_target_info.h"
  28 #include "net_nfc_util_internal.h"
  29
  30 #ifndef NET_NFC_EXPORT_API
  31 #define NET_NFC_EXPORT_API __attribute__((visibility("default")))
  32 #endif
  33
  34 /* LCOV_EXCL_START */
  35
  36 #define MIFARE_CMD_RAW                  0x00U
  37 #define MIFARE_CMD_AUTH_A               0x60U /**< authenticate with key A */
  38 #define MIFARE_CMD_AUTH_B               0x61U /**< authenticate with key B */
  39 #define MIFARE_CMD_READ                 0x30U /**< read 16 bytes */
  40 #define MIFARE_CMD_WRITE_BLOCK          0xA0U /**< write 16 bytes */
  41 #define MIFARE_CMD_WRITE_PAGE           0xA2U /**< write 4 bytes */
  42 #define MIFARE_CMD_INCREMENT            0xC1U /**< Increment. */
  43 #define MIFARE_CMD_DECREMENT            0xC0U /**< Decrement. */
  44 #define MIFARE_CMD_TRANSFER             0xB0U /**< Tranfer.   */
  45 #define MIFARE_CMD_RESTORE              0xC2U /**< Restore.   */
  46 #define MIFARE_TAG_KEY  "UID"
  47
  48 #define MIFARE_CMD_READ_SECTOR  0x38U /* read sector */
  49 #define MIFARE_CMD_WRITE_SECTOR 0xA8U /* write sector */
  50
  51 static uint8_t default_key[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
  52 static uint8_t mad_key[6] = { 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5 };
  53 static uint8_t net_nfc_forum_key[6] = { 0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7 };
  54
  55 #define MIFARE_BLOCK_4 4
  56 #define MIFARE_BLOCK_16 16
  57
  58 #define MIFARE_MINI_SECTORS 5
  59 #define MIFARE_1K_SECTORS 16
  60 #define MIFARE_4K_SECTORS 40
  61
  62 #define MIFARE_BLOCK_SIZE 16    /* 1 block is 16 byte */
  63 #define MIFARE_PAGE_SIZE 4      /* 1 page is 4 byte */
  64
  65
  66 NET_NFC_EXPORT_API
  67 net_nfc_error_e net_nfc_client_mifare_authenticate_with_keyA(
  68                                                 net_nfc_target_handle_h handle,
  69                                                 uint8_t sector,
  70                                                 data_h auth_key,
  71                                                 void *callback,
  72                                                 void *user_data)
  73 {
  74         net_nfc_target_info_s* target_info = NULL;
  75
  76         data_s *key;
  77         data_s rawdata;
  78
  79         data_h UID = NULL;
  80
  81         uint8_t* send_buffer = NULL;
  82         uint8_t* temp = NULL;
  83
  84         int send_buffer_length = 0;
  85
  86         uint8_t sector_to_block = 0;
  87
  88
  89         if (handle == NULL || auth_key == NULL)
  90                 return NET_NFC_NULL_PARAMETER;
  91
  92         if (net_nfc_client_tag_is_connected() == FALSE)
  93                 return NET_NFC_OPERATION_FAIL;
  94
  95         key = (data_s *)auth_key;
  96
  97         if (key->length != 6)
  98                 return NET_NFC_OUT_OF_BOUND;
  99
 100         target_info = net_nfc_client_tag_get_client_target_info();
 101
 102         if (target_info) {
 103                 if (target_info->devType < NET_NFC_MIFARE_MINI_PICC ||
 104                                 target_info->devType > NET_NFC_MIFARE_4K_PICC) {
 105                         DEBUG_CLIENT_MSG("not a MIFARE Classic TAG");
 106                         return NET_NFC_NOT_SUPPORTED;
 107                 }
 108         } else {
 109                 return NET_NFC_NO_DATA_FOUND;
 110         }
 111
 112         if (net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
 113                                         MIFARE_TAG_KEY,
 114                                         &UID) != NET_NFC_OK) {
 115                 return NET_NFC_NO_DATA_FOUND;
 116         }
 117
 118         switch (target_info->devType) {
 119         case NET_NFC_MIFARE_MINI_PICC:
 120                 {
 121                         /* 0 ~ 4 : 5 sector and 4 block with 16 bytes */
 122                         if (sector > MIFARE_MINI_SECTORS - 1)
 123                                 return NET_NFC_OUT_OF_BOUND;
 124
 125                         sector_to_block = sector * MIFARE_BLOCK_4 + 3;
 126                 }
 127                 break;
 128         case NET_NFC_MIFARE_1K_PICC:
 129                 {
 130                         /* 0 ~ 15 : 16 sector and 4 block with 16 bytes */
 131                         if (sector > MIFARE_1K_SECTORS)
 132                                 return NET_NFC_OUT_OF_BOUND;
 133
 134                         sector_to_block = sector * MIFARE_BLOCK_4 + 3;
 135                 }
 136                 break;
 137         case NET_NFC_MIFARE_4K_PICC:
 138                 {
 139                         /* 0 ~ 31 : 32 sector and 4 block with 16 bytes
 140                          * 32 ~ 39 : 8 sector and 16 block with 16 bytes
 141                          */
 142                         if (sector > MIFARE_4K_SECTORS)
 143                                 return NET_NFC_OUT_OF_BOUND;
 144
 145                         if (sector < 32)
 146                                 sector_to_block = sector * MIFARE_BLOCK_4 + 3;
 147                         else {
 148                                 sector_to_block = (31 * MIFARE_BLOCK_4 + 3)
 149                                                 + (sector - 32)
 150                                                 * MIFARE_BLOCK_16 + 15;
 151                         }
 152                 }
 153                 break;
 154         default:
 155                 break;
 156         }
 157
 158
 159         /* cmd + addr + UID + AUTH_KEY + CRC_A */
 160         send_buffer_length = 1 + 1 + ((data_s*)UID)->length
 161                         + key->length + 2;
 162
 163         _net_nfc_util_alloc_mem(send_buffer,
 164                         send_buffer_length * sizeof(uint8_t));
 165         if (send_buffer == NULL) {
 166                 net_nfc_free_data(UID);
 167                 return NET_NFC_ALLOC_FAIL;
 168         }
 169
 170         temp = send_buffer;
 171
 172         *temp = MIFARE_CMD_AUTH_A;
 173         temp++;
 174
 175         *temp = sector_to_block;
 176         temp++;
 177
 178         memcpy(temp, ((data_s*)UID)->buffer, ((data_s*)UID)->length);
 179         temp = temp + ((data_s*)UID)->length;
 180
 181         memcpy(temp, key->buffer, key->length);
 182
 183         net_nfc_util_compute_CRC(CRC_A, send_buffer, send_buffer_length);
 184
 185
 186         rawdata.buffer = send_buffer;
 187         rawdata.length = send_buffer_length;
 188
 189         net_nfc_error_e result = net_nfc_client_transceive(handle,
 190                                                         (data_h)&rawdata,
 191                                                         callback,
 192                                                         user_data);
 193
 194         if (send_buffer != NULL)
 195                 _net_nfc_util_free_mem(send_buffer);
 196
 197         return result;
 198 }
 199
 200 NET_NFC_EXPORT_API
 201 net_nfc_error_e net_nfc_client_mifare_authenticate_with_keyB(
 202                                                 net_nfc_target_handle_h handle,
 203                                                 uint8_t sector,
 204                                                 data_h auth_key,
 205                                                 void *callback,
 206                                                 void *user_data)
 207 {
 208         net_nfc_target_info_s* target_info = NULL;
 209
 210         data_s *key;
 211         data_s rawdata;
 212
 213         data_h UID = NULL;
 214
 215         uint8_t* send_buffer = NULL;
 216         uint8_t* temp = NULL;
 217
 218         int send_buffer_length = 0;
 219
 220         uint8_t sector_to_block = 0;
 221
 222
 223         if (handle == NULL || auth_key == NULL)
 224                 return NET_NFC_NULL_PARAMETER;
 225
 226         if (net_nfc_client_tag_is_connected() == FALSE)
 227                 return NET_NFC_OPERATION_FAIL;
 228
 229         key = (data_s *)auth_key;
 230
 231         if (key->length != 6)
 232                 return NET_NFC_OUT_OF_BOUND;
 233
 234         target_info = net_nfc_client_tag_get_client_target_info();
 235
 236         if (target_info != NULL) {
 237                 if (target_info->devType < NET_NFC_MIFARE_MINI_PICC ||
 238                                 target_info->devType > NET_NFC_MIFARE_4K_PICC) {
 239                         DEBUG_CLIENT_MSG("not a MIFARE Classic TAG");
 240                         return NET_NFC_NOT_SUPPORTED;
 241                 }
 242         } else {
 243                 return NET_NFC_NO_DATA_FOUND;
 244         }
 245
 246         if (net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
 247                                         MIFARE_TAG_KEY,
 248                                         &UID) != NET_NFC_OK) {
 249                 return NET_NFC_NO_DATA_FOUND;
 250         }
 251
 252         switch (target_info->devType) {
 253         case NET_NFC_MIFARE_MINI_PICC:
 254                 {
 255                         /* 0 ~ 4 : 5 sector and 4 block with 16 bytes */
 256                         if (sector > MIFARE_MINI_SECTORS)
 257                                 return NET_NFC_OUT_OF_BOUND;
 258
 259                         sector_to_block = sector * MIFARE_BLOCK_4 + 3;
 260                 }
 261                 break;
 262         case NET_NFC_MIFARE_1K_PICC:
 263                 {
 264                         /* 0 ~ 15 : 16 sector and 4 block with 16 bytes */
 265                         if (sector > MIFARE_1K_SECTORS)
 266                                 return NET_NFC_OUT_OF_BOUND;
 267
 268                         sector_to_block = sector * MIFARE_BLOCK_4 + 3;
 269                 }
 270                 break;
 271         case NET_NFC_MIFARE_4K_PICC:
 272                 {
 273                         /* 0 ~ 31 : 32 sector and 4 block with 16 bytes
 274                          * 32 ~ 39 : 8 sector and 16 block with 16 bytes
 275                          */
 276                         if (sector > MIFARE_4K_SECTORS)
 277                                 return NET_NFC_OUT_OF_BOUND;
 278
 279                         if (sector < 32)
 280                                 sector_to_block = sector * MIFARE_BLOCK_4 + 3;
 281                         else {
 282                                 sector_to_block = (31 * MIFARE_BLOCK_4 + 3)
 283                                                 + (sector - 32)
 284                                                 * MIFARE_BLOCK_16 + 15;
 285                         }
 286                 }
 287                 break;
 288         default:
 289                 break;
 290         }
 291
 292         send_buffer_length = 1 + 1 + ((data_s*)UID)->length
 293                 + key->length + 2; /* cmd + addr + UID + AUTH_KEY + CRC_A */
 294
 295         _net_nfc_util_alloc_mem(send_buffer, send_buffer_length
 296                                 * sizeof(uint8_t));
 297         if (send_buffer == NULL) {
 298                 net_nfc_free_data(UID);
 299                 return NET_NFC_ALLOC_FAIL;
 300         }
 301
 302         temp = send_buffer;
 303
 304         *temp = MIFARE_CMD_AUTH_B;
 305         temp++;
 306
 307         *temp = sector_to_block;
 308         temp++;
 309
 310         memcpy(temp, ((data_s*)UID)->buffer, ((data_s*)UID)->length);
 311         temp = temp + ((data_s*)UID)->length;
 312
 313         memcpy(temp, key->buffer, key->length);
 314
 315         net_nfc_util_compute_CRC(CRC_A, send_buffer, send_buffer_length);
 316
 317         rawdata.buffer = send_buffer;
 318         rawdata.length = send_buffer_length;
 319
 320         net_nfc_error_e result = net_nfc_client_transceive(handle,
 321                                                         (data_h)&rawdata,
 322                                                         callback,
 323                                                         user_data);
 324
 325         if (send_buffer != NULL)
 326                 _net_nfc_util_free_mem(send_buffer);
 327
 328         return result;
 329 }
 330
 331 NET_NFC_EXPORT_API
 332 net_nfc_error_e net_nfc_client_mifare_read(net_nfc_target_handle_h handle,
 333                                         uint8_t addr,
 334                                         void *callback,
 335                                         void *user_data)
 336 {
 337         net_nfc_target_info_s* target_info = NULL;
 338
 339         data_s rawdata;
 340
 341         uint8_t send_buffer[2] = { 0 };
 342
 343
 344         if (handle == NULL)
 345                 return NET_NFC_NULL_PARAMETER;
 346
 347         if (net_nfc_client_tag_is_connected() == FALSE)
 348                 return NET_NFC_OPERATION_FAIL;
 349
 350         target_info = net_nfc_client_tag_get_client_target_info();
 351
 352         if (target_info != NULL) {
 353                 if (target_info->devType < NET_NFC_MIFARE_MINI_PICC ||
 354                         target_info->devType > NET_NFC_MIFARE_ULTRA_PICC) {
 355                         DEBUG_CLIENT_MSG("not a MIFARE TAG = [%d]",
 356                                                 target_info->devType);
 357                         return NET_NFC_NOT_SUPPORTED;
 358                 }
 359
 360                 if (target_info->devType == NET_NFC_MIFARE_ULTRA_PICC) {
 361                         if (addr > 7)
 362                                 return NET_NFC_OUT_OF_BOUND;
 363                 }
 364         }
 365
 366
 367         send_buffer[0] = MIFARE_CMD_READ;
 368         send_buffer[1] = addr;
 369
 370
 371         rawdata.buffer = send_buffer;
 372         rawdata.length = 2;
 373
 374         return net_nfc_client_transceive_data(handle,
 375                                         (data_h)&rawdata,
 376                                         callback,
 377                                         user_data);
 378 }
 379
 380 NET_NFC_EXPORT_API
 381 net_nfc_error_e net_nfc_client_mifare_write_block(
 382                                                 net_nfc_target_handle_h handle,
 383                                                 uint8_t addr,
 384                                                 data_h data,
 385                                                 void *callback,
 386                                                 void *user_data)
 387 {
 388         net_nfc_target_info_s* target_info = NULL;
 389
 390         data_s rawdata;
 391
 392         uint8_t* send_buffer = NULL;
 393
 394         uint32_t send_buffer_length = 0;
 395
 396
 397         if (handle == NULL)
 398                 return NET_NFC_NULL_PARAMETER;
 399
 400         if (net_nfc_client_tag_is_connected() == FALSE)
 401                 return NET_NFC_OPERATION_FAIL;
 402
 403
 404         target_info = net_nfc_client_tag_get_client_target_info();
 405
 406         if (target_info == NULL)
 407                 return NET_NFC_NOT_INITIALIZED;
 408
 409         if (target_info->devType < NET_NFC_MIFARE_MINI_PICC ||
 410                         target_info->devType > NET_NFC_MIFARE_ULTRA_PICC) {
 411                 DEBUG_CLIENT_MSG("not a MIFARE TAG = [%d] ",
 412                                         target_info->devType);
 413                 return NET_NFC_NOT_SUPPORTED;
 414         }
 415
 416         if (target_info->devType == NET_NFC_MIFARE_ULTRA_PICC) {
 417                 if (addr > 7)
 418                         return NET_NFC_OUT_OF_BOUND;
 419         }
 420
 421         if (target_info->devType == NET_NFC_MIFARE_ULTRA_PICC) {
 422                 if (((data_s *)data)->length > MIFARE_PAGE_SIZE) {
 423                         uint8_t* temp = NULL;
 424
 425                         /* cmd + addr + page */
 426                         send_buffer_length = 1 + 1 + MIFARE_PAGE_SIZE;
 427
 428                         _net_nfc_util_alloc_mem(send_buffer,
 429                                         send_buffer_length * sizeof(uint8_t));
 430                         if (send_buffer == NULL)
 431                                 return NET_NFC_ALLOC_FAIL;
 432
 433                         temp = send_buffer;
 434
 435                         *temp = MIFARE_CMD_WRITE_PAGE;
 436                         temp++;
 437
 438                         *temp = addr;
 439                         temp++;
 440
 441                         memcpy(temp,
 442                                 ((data_s*)data)->buffer,
 443                                 MIFARE_PAGE_SIZE);
 444
 445                 } else {
 446                         uint8_t* temp = NULL;
 447
 448                         /* cmd + addr + page */
 449                         send_buffer_length = 1 + 1 +
 450                                         ((data_s*)data)->length;
 451
 452                         _net_nfc_util_alloc_mem(send_buffer,
 453                                         send_buffer_length * sizeof(uint8_t));
 454                         if (send_buffer == NULL)
 455                                 return NET_NFC_ALLOC_FAIL;
 456
 457                         temp = send_buffer;
 458
 459                         *temp = MIFARE_CMD_WRITE_PAGE;
 460                         temp++;
 461
 462                         *temp = addr;
 463                         temp++;
 464
 465                         memcpy(temp,
 466                                 ((data_s*)data)->buffer,
 467                                 ((data_s*)data)->length);
 468                 }
 469
 470         } else {
 471                 if (((data_s*)data)->length > MIFARE_BLOCK_SIZE) {
 472                         uint8_t* temp = NULL;
 473
 474                         /* cmd + addr + page*/
 475                         send_buffer_length = 1 + 1 + MIFARE_BLOCK_SIZE;
 476
 477                         _net_nfc_util_alloc_mem(send_buffer,
 478                                         send_buffer_length * sizeof(uint8_t));
 479                         if (send_buffer == NULL)
 480                                 return NET_NFC_ALLOC_FAIL;
 481
 482                         temp = send_buffer;
 483
 484                         *temp = MIFARE_CMD_WRITE_BLOCK;
 485                         temp++;
 486
 487                         *temp = addr;
 488                         temp++;
 489
 490                         memcpy(temp,
 491                                 ((data_s*)data)->buffer,
 492                                 MIFARE_BLOCK_SIZE);
 493                 } else {
 494                         uint8_t* temp = NULL;
 495
 496                         /* cmd + addr + page  */
 497                         send_buffer_length = 1 + 1 + ((data_s*)data)->length;
 498
 499                         _net_nfc_util_alloc_mem(send_buffer,
 500                                         send_buffer_length * sizeof(uint8_t));
 501                         if (send_buffer == NULL)
 502                                 return NET_NFC_ALLOC_FAIL;
 503
 504                         temp = send_buffer;
 505
 506                         *temp = MIFARE_CMD_WRITE_BLOCK;
 507                         temp++;
 508
 509                         *temp = addr;
 510                         temp++;
 511
 512                         memcpy(temp,
 513                                 ((data_s*)data)->buffer,
 514                                 ((data_s*)data)->length);
 515                 }
 516         }
 517
 518
 519         rawdata.buffer = send_buffer;
 520         rawdata.length = send_buffer_length;
 521
 522         net_nfc_error_e result = net_nfc_client_transceive(handle,
 523                                                         (data_h)&rawdata,
 524                                                         callback,
 525                                                         user_data);
 526
 527         if (send_buffer != NULL)
 528                 _net_nfc_util_free_mem(send_buffer);
 529
 530         return result;
 531 }
 532
 533 NET_NFC_EXPORT_API
 534 net_nfc_error_e net_nfc_client_mifare_write_page(
 535                                                 net_nfc_target_handle_h handle,
 536                                                 uint8_t addr,
 537                                                 data_h data,
 538                                                 void *callback,
 539                                                 void *user_data)
 540 {
 541         net_nfc_target_info_s* target_info = NULL;
 542
 543         uint8_t* send_buffer = NULL;
 544
 545         uint32_t send_buffer_length = 0;
 546
 547         if (handle == NULL)
 548                 return NET_NFC_NULL_PARAMETER;
 549
 550         if (net_nfc_client_tag_is_connected() == FALSE)
 551                 return NET_NFC_OPERATION_FAIL;
 552
 553         target_info = net_nfc_client_tag_get_client_target_info();
 554
 555         if (target_info == NULL)
 556                 return NET_NFC_NOT_INITIALIZED;
 557
 558         if (target_info->devType < NET_NFC_MIFARE_MINI_PICC ||
 559                         target_info->devType > NET_NFC_MIFARE_ULTRA_PICC) {
 560                 DEBUG_CLIENT_MSG("not a MIFARE TAG = [%d] ",
 561                                 target_info->devType);
 562                 return NET_NFC_NOT_SUPPORTED;
 563         }
 564
 565         if (target_info->devType == NET_NFC_MIFARE_ULTRA_PICC) {
 566                 if (addr > 7)
 567                         return NET_NFC_OUT_OF_BOUND;
 568         }
 569
 570         if (target_info->devType == NET_NFC_MIFARE_ULTRA_PICC) {
 571                 if (((data_s*)data)->length > MIFARE_PAGE_SIZE) {
 572                         uint8_t* temp = NULL;
 573
 574                         /* cmd + addr + page  */
 575                         send_buffer_length = 1 + 1 + MIFARE_PAGE_SIZE;
 576
 577                         _net_nfc_util_alloc_mem(send_buffer,
 578                                         send_buffer_length * sizeof(uint8_t));
 579                         if (send_buffer == NULL)
 580                                 return NET_NFC_ALLOC_FAIL;
 581
 582                         temp = send_buffer;
 583
 584                         *temp = MIFARE_CMD_WRITE_PAGE;
 585                         temp++;
 586
 587                         *temp = addr;
 588                         temp++;
 589
 590                         memcpy(temp,
 591                                 ((data_s*)data)->buffer,
 592                                 MIFARE_PAGE_SIZE);
 593                 } else {
 594                         uint8_t* temp = NULL;
 595
 596                         /* cmd + addr + page */
 597                         send_buffer_length = 1 + 1 + ((data_s*)data)->length;
 598
 599                         _net_nfc_util_alloc_mem(send_buffer,
 600                                         send_buffer_length * sizeof(uint8_t));
 601                         if (send_buffer == NULL)
 602                                 return NET_NFC_ALLOC_FAIL;
 603
 604                         temp = send_buffer;
 605
 606                         *temp = MIFARE_CMD_WRITE_PAGE;
 607                         temp++;
 608
 609                         *temp = addr;
 610                         temp++;
 611
 612                         memcpy(temp,
 613                                 ((data_s*)data)->buffer,
 614                                 ((data_s*)data)->length);
 615                 }
 616
 617         } else {
 618                 if (((data_s*)data)->length > MIFARE_PAGE_SIZE) {
 619                         uint8_t* temp = NULL;
 620
 621                         /* cmd + addr + page */
 622                         send_buffer_length = 1 + 1 + MIFARE_PAGE_SIZE;
 623
 624                         _net_nfc_util_alloc_mem(send_buffer,
 625                                         send_buffer_length * sizeof(uint8_t));
 626                         if (send_buffer == NULL)
 627                                 return NET_NFC_ALLOC_FAIL;
 628
 629                         temp = send_buffer;
 630
 631                         *temp = MIFARE_CMD_WRITE_BLOCK;
 632                         temp++;
 633
 634                         *temp = addr;
 635                         temp++;
 636
 637                         memcpy(temp,
 638                                 ((data_s*)data)->buffer,
 639                                 MIFARE_PAGE_SIZE);
 640
 641                 } else {
 642                         uint8_t* temp = NULL;
 643
 644                         /* cmd + addr + page */
 645                         send_buffer_length = 1 + 1 + ((data_s*)data)->length;
 646
 647                         _net_nfc_util_alloc_mem(send_buffer,
 648                                         send_buffer_length * sizeof(uint8_t));
 649                         if (send_buffer == NULL)
 650                                 return NET_NFC_ALLOC_FAIL;
 651
 652                         temp = send_buffer;
 653
 654                         *temp = MIFARE_CMD_WRITE_BLOCK;
 655                         temp++;
 656
 657                         *temp = addr;
 658                         temp++;
 659
 660                         memcpy(temp,
 661                                 ((data_s*)data)->buffer,
 662                                 ((data_s*)data)->length);
 663                 }
 664
 665         }
 666
 667
 668         data_s rawdata;
 669
 670         rawdata.buffer = send_buffer;
 671         rawdata.length = send_buffer_length;
 672
 673         net_nfc_error_e result = net_nfc_client_transceive(handle,
 674                                                         (data_h)&rawdata,
 675                                                         callback,
 676                                                         user_data);
 677
 678         if (send_buffer != NULL)
 679                 _net_nfc_util_free_mem(send_buffer);
 680
 681         return result;
 682 }
 683
 684 NET_NFC_EXPORT_API
 685 net_nfc_error_e net_nfc_client_mifare_increment(net_nfc_target_handle_h handle,
 686                                                 uint8_t addr,
 687                                                 int value,
 688                                                 void *callback,
 689                                                 void *user_data)
 690 {
 691         net_nfc_target_info_s* target_info = NULL;
 692
 693         data_s rawdata;
 694
 695         uint8_t send_buffer[8] = { 0 };
 696
 697
 698         if (handle == NULL)
 699                 return NET_NFC_NULL_PARAMETER;
 700
 701         if (net_nfc_client_tag_is_connected() == FALSE)
 702                 return NET_NFC_OPERATION_FAIL;
 703
 704         target_info = net_nfc_client_tag_get_client_target_info();
 705
 706         if (target_info) {
 707                 if (target_info->devType < NET_NFC_MIFARE_MINI_PICC ||
 708                                 target_info->devType > NET_NFC_MIFARE_4K_PICC) {
 709                         DEBUG_CLIENT_MSG(
 710                                         "not a MIFARE Classic TAG = [%d]",
 711                                         target_info->devType);
 712                         return NET_NFC_NOT_SUPPORTED;
 713                 }
 714         }
 715
 716
 717         send_buffer[0] = MIFARE_CMD_INCREMENT;
 718         send_buffer[1] = addr;
 719
 720         /* little endian.
 721            little value of byte array will be saved first in memory */
 722         send_buffer[5] = (value & 0xFF000000) >> 24;
 723         send_buffer[4] = (value & 0x00FF0000) >> 16;
 724         send_buffer[3] = (value & 0x0000FF00) >> 8;
 725         send_buffer[2] = (value & 0x000000FF);
 726
 727         net_nfc_util_compute_CRC(CRC_A, send_buffer, 8);
 728
 729         rawdata.buffer = send_buffer;
 730         rawdata.length = 8;
 731
 732         return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
 733                                         user_data);
 734 }
 735
 736 NET_NFC_EXPORT_API
 737 net_nfc_error_e net_nfc_client_mifare_decrement(net_nfc_target_handle_h handle,
 738                                                 uint8_t addr,
 739                                                 int value,
 740                                                 void *callback,
 741                                                 void *user_data)
 742 {
 743         net_nfc_target_info_s* target_info = NULL;
 744
 745         data_s rawdata;
 746
 747         uint8_t send_buffer[8] = { 0 };
 748
 749         if (handle == NULL)
 750                 return NET_NFC_NULL_PARAMETER;
 751
 752         if (net_nfc_client_tag_is_connected() == FALSE)
 753                 return NET_NFC_OPERATION_FAIL;
 754
 755         target_info = net_nfc_client_tag_get_client_target_info();
 756
 757         if (target_info) {
 758
 759                 if (target_info->devType < NET_NFC_MIFARE_MINI_PICC ||
 760                                 target_info->devType > NET_NFC_MIFARE_4K_PICC) {
 761                         DEBUG_CLIENT_MSG("not a MIFARE Classic TAG = [%d] ",
 762                                         target_info->devType);
 763                         return NET_NFC_NOT_SUPPORTED;
 764                 }
 765         }
 766
 767         send_buffer[0] = MIFARE_CMD_DECREMENT;
 768         send_buffer[1] = addr;
 769
 770         /* little endian.
 771            little value of byte array will be saved first in memory */
 772         send_buffer[5] = (value & 0xFF000000) >> 24;
 773         send_buffer[4] = (value & 0x00FF0000) >> 16;
 774         send_buffer[3] = (value & 0x0000FF00) >> 8;
 775         send_buffer[2] = (value & 0x000000FF);
 776
 777         net_nfc_util_compute_CRC(CRC_A, send_buffer, 8);
 778
 779         DEBUG_MSG_PRINT_BUFFER(send_buffer, 8);
 780
 781         rawdata.buffer = send_buffer;
 782         rawdata.length = 8;
 783
 784         return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
 785                                         user_data);
 786 }
 787
 788 NET_NFC_EXPORT_API
 789 net_nfc_error_e net_nfc_client_mifare_transfer(net_nfc_target_handle_h handle,
 790                                         uint8_t addr,
 791                                         void *callback,
 792                                         void *user_data)
 793 {
 794         net_nfc_target_info_s* target_info = NULL;
 795
 796         data_s rawdata;
 797
 798         uint8_t send_buffer[4] = { 0 };
 799
 800         if (handle == NULL)
 801                 return NET_NFC_NULL_PARAMETER;
 802
 803         if (net_nfc_client_tag_is_connected() == FALSE)
 804                 return NET_NFC_OPERATION_FAIL;
 805
 806         target_info = net_nfc_client_tag_get_client_target_info();
 807
 808         if (target_info) {
 809                 if (target_info->devType < NET_NFC_MIFARE_MINI_PICC ||
 810                                 target_info->devType > NET_NFC_MIFARE_4K_PICC) {
 811                         DEBUG_CLIENT_MSG("not a MIFARE Classic TAG = [%d]",
 812                                         target_info->devType);
 813                         return NET_NFC_NOT_SUPPORTED;
 814                 }
 815         }
 816
 817         send_buffer[0] = MIFARE_CMD_TRANSFER;
 818         send_buffer[1] = addr;
 819
 820         net_nfc_util_compute_CRC(CRC_A, send_buffer, 4);
 821
 822         rawdata.buffer = send_buffer;
 823         rawdata.length = 4;
 824
 825         return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
 826                                         user_data);
 827 }
 828
 829 NET_NFC_EXPORT_API
 830 net_nfc_error_e net_nfc_client_mifare_restore(net_nfc_target_handle_h handle,
 831                                         uint8_t addr,
 832                                         void *callback,
 833                                         void *user_data)
 834 {
 835         net_nfc_target_info_s* target_info = NULL;
 836
 837         data_s rawdata;
 838
 839         uint8_t send_buffer[4] = { 0 };
 840
 841         if (handle == NULL)
 842                 return NET_NFC_NULL_PARAMETER;
 843
 844         if (net_nfc_client_tag_is_connected() == FALSE)
 845                 return NET_NFC_OPERATION_FAIL;
 846
 847         target_info = net_nfc_client_tag_get_client_target_info();
 848
 849         if (target_info) {
 850                 if (target_info->devType < NET_NFC_MIFARE_MINI_PICC ||
 851                                 target_info->devType > NET_NFC_MIFARE_4K_PICC) {
 852                         DEBUG_CLIENT_MSG("not a MIFARE Classic TAG = [%d]",
 853                                         target_info->devType);
 854                         return NET_NFC_NOT_SUPPORTED;
 855                 }
 856         }
 857
 858         send_buffer[0] = MIFARE_CMD_RESTORE;
 859         send_buffer[1] = addr;
 860
 861         net_nfc_util_compute_CRC(CRC_A, send_buffer, 4);
 862
 863         rawdata.buffer = send_buffer;
 864         rawdata.length = 4;
 865
 866         return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
 867                                         user_data);
 868 }
 869
 870 NET_NFC_EXPORT_API
 871 net_nfc_error_e net_nfc_client_mifare_create_default_key(data_h* key)
 872 {
 873         if (key == NULL)
 874                 return NET_NFC_NULL_PARAMETER;
 875
 876         return net_nfc_create_data(key, default_key, 6);
 877 }
 878
 879 NET_NFC_EXPORT_API
 880 net_nfc_error_e net_nfc_client_mifare_create_application_directory_key(
 881                                                                 data_h* key)
 882 {
 883         if (key == NULL)
 884                 return NET_NFC_NULL_PARAMETER;
 885
 886         return net_nfc_create_data(key, mad_key, 6);
 887 }
 888
 889 NET_NFC_EXPORT_API
 890 net_nfc_error_e net_nfc_client_mifare_create_net_nfc_forum_key(data_h* key)
 891 {
 892         if (key == NULL)
 893                 return NET_NFC_NULL_PARAMETER;
 894
 895         return net_nfc_create_data(key, net_nfc_forum_key, 6);
 896 }
 897
 898 /* LCOV_EXCL_STOP */
 899