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