tests/net_nfc_test_tag_mifare.c

   1 /*
   2  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *                               http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18
  19 #include "net_nfc_client_tag_mifare.h"
  20 #include "net_nfc_test_tag_mifare.h"
  21 #include "net_nfc_target_info.h"
  22 #include "net_nfc_typedef_internal.h"
  23 #include "net_nfc_test_tag.h"
  24 #include "net_nfc_test_util.h"
  25
  26
  27 static net_nfc_target_handle_s* tag_get_handle(void);
  28
  29 static void mifare_read_cb(net_nfc_error_e result, data_s *resp_data, void *user_data);
  30
  31 static void mifare_write_block_cb(net_nfc_error_e result, void* user_data);
  32
  33 static void mifare_write_page_cb(net_nfc_error_e result, void* user_data);
  34
  35 static void mifare_write_mifare_incr_cb(net_nfc_error_e result, void* user_data);
  36
  37 static void mifare_write_mifare_decr_cb(net_nfc_error_e result, void* user_data);
  38
  39 static void mifare_write_mifare_transfer_cb(net_nfc_error_e result, void* user_data);
  40
  41 static void mifare_write_mifare_restore_cb(net_nfc_error_e result, void* user_data);
  42
  43 static void mifare_write_auth_keyA_cb(net_nfc_error_e result, void* user_data);
  44
  45 static void mifare_write_auth_keyB_cb(net_nfc_error_e result, void* user_data);
  46
  47
  48 static net_nfc_target_handle_s* tag_get_handle(void)
  49 {
  50         net_nfc_target_info_s *info = NULL;
  51         net_nfc_target_handle_s *handle = NULL;
  52
  53         info = net_nfc_test_tag_get_target_info();
  54
  55         net_nfc_get_tag_handle(info, &handle);
  56
  57         return handle;
  58 }
  59
  60 static void run_next_callback(gpointer user_data)
  61 {
  62         if (user_data)
  63         {
  64                 GCallback callback;
  65
  66                 callback = (GCallback)(user_data);
  67                 callback();
  68         }
  69 }
  70
  71 static void mifare_read_cb(net_nfc_error_e result,
  72                 data_s *resp_data,
  73                 void *user_data)
  74 {
  75         g_print("mifare_read_cb Completed %d\n", result);
  76         print_received_data(resp_data);
  77
  78         run_next_callback(user_data);
  79 }
  80
  81 static void mifare_write_block_cb(net_nfc_error_e result, void* user_data)
  82 {
  83         g_print("mifare_write_block_cb Completed %d\n", result);
  84
  85         run_next_callback(user_data);
  86 }
  87
  88 static void mifare_write_page_cb(net_nfc_error_e result, void* user_data)
  89 {
  90         g_print("mifare_write_page_cb Completed %d\n", result);
  91
  92         run_next_callback(user_data);
  93 }
  94
  95 static void mifare_write_mifare_incr_cb(net_nfc_error_e result, void* user_data)
  96 {
  97         g_print("mifare_write_mifare_incr_cb Completed %d\n", result);
  98
  99         run_next_callback(user_data);
 100 }
 101
 102 static void mifare_write_mifare_decr_cb(net_nfc_error_e result, void* user_data)
 103 {
 104         g_print("mifare_write_mifare_decr_cb Completed %d\n", result);
 105
 106         run_next_callback(user_data);
 107 }
 108
 109 static void mifare_write_mifare_transfer_cb(net_nfc_error_e result, void* user_data)
 110 {
 111         g_print("mifare_write_mifare_transfer_cb Completed %d\n", result);
 112
 113         run_next_callback(user_data);
 114 }
 115
 116 static void mifare_write_mifare_restore_cb(net_nfc_error_e result, void* user_data)
 117 {
 118         g_print("mifare_write_mifare_restore_cb Completed %d\n", result);
 119
 120         run_next_callback(user_data);
 121 }
 122
 123 static void mifare_write_auth_keyA_cb(net_nfc_error_e result, void* user_data)
 124 {
 125         g_print("mifare_write_auth_keyA_cb Completed %d\n", result);
 126
 127         run_next_callback(user_data);
 128 }
 129
 130 static void mifare_write_auth_keyB_cb(net_nfc_error_e result, void* user_data)
 131 {
 132         g_print("mifare_write_auth_keyB_cb Completed %d\n", result);
 133
 134         run_next_callback(user_data);
 135 }
 136
 137
 138 void net_nfc_test_tag_mifare_read(gpointer data, gpointer user_data)
 139 {
 140         net_nfc_error_e  result  = NET_NFC_OK;
 141         net_nfc_target_handle_s *handle = NULL;
 142         uint8_t block_index = 0x0;
 143
 144         handle = tag_get_handle();
 145         if (handle == NULL)
 146         {
 147                 g_printerr("Handle is NULL\n");
 148
 149                 run_next_callback(user_data);
 150                 return;
 151         }
 152         g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
 153
 154         result = net_nfc_client_mifare_read(handle, block_index, mifare_read_cb, user_data);
 155
 156         g_print("net_nfc_client_mifare_read() : %d\n", result);
 157 }
 158
 159 void net_nfc_test_tag_mifare_write_block(gpointer data, gpointer user_data)
 160 {
 161         net_nfc_error_e  result = NET_NFC_OK;
 162         net_nfc_target_handle_s *handle = NULL;
 163         data_s *write_data = NULL;
 164         // create 4 bytes data  mifare page size is 4 bytes
 165         uint8_t buffer_data [17] = "aaaabbbbccccdddd";
 166
 167         net_nfc_create_data(&write_data, buffer_data, 16);
 168
 169         uint8_t block_index = 0x04;
 170
 171         handle = tag_get_handle();
 172         if (handle == NULL)
 173         {
 174                 g_printerr("Handle is NULL\n");
 175
 176                 run_next_callback(user_data);
 177                 return;
 178         }
 179         g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
 180
 181         result = net_nfc_client_mifare_write_block(handle,
 182                         block_index,
 183                         write_data,
 184                         mifare_write_block_cb,
 185                         user_data);
 186
 187         g_print("net_nfc_client_mifare_write_block() : %d\n", result);
 188 }
 189
 190 void net_nfc_test_tag_mifare_write_page(gpointer data, gpointer user_data)
 191 {
 192         net_nfc_error_e  result = NET_NFC_OK;
 193         net_nfc_target_handle_s *handle = NULL;
 194         data_s *write_data = NULL;
 195         // create 4 bytes data  mifare page size is 4 bytes
 196         uint8_t buffer_data [5] = "aaaa";
 197
 198         net_nfc_create_data(&write_data, buffer_data, 4);
 199
 200         uint8_t block_index = 0x04;
 201
 202         handle = tag_get_handle();
 203         if (handle == NULL)
 204         {
 205                 g_printerr("Handle is NULL\n");
 206
 207                 run_next_callback(user_data);
 208                 return;
 209         }
 210         g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
 211
 212         result = net_nfc_client_mifare_write_page(handle,
 213                         block_index,
 214                         write_data,
 215                         mifare_write_page_cb,
 216                         user_data);
 217
 218         g_print("net_nfc_client_mifare_write_page() : %d\n", result);
 219 }
 220
 221 void net_nfc_test_tag_mifare_increment(gpointer data, gpointer user_data)
 222 {
 223         net_nfc_error_e  result = NET_NFC_OK;
 224         net_nfc_target_handle_s *handle = NULL;
 225         int value = 1;
 226         uint8_t block_index = 0x05;
 227
 228         handle = tag_get_handle();
 229         if (handle == NULL)
 230         {
 231                 g_printerr("Handle is NULL\n");
 232
 233                 run_next_callback(user_data);
 234                 return;
 235         }
 236         g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
 237
 238         result = net_nfc_client_mifare_increment(handle,
 239                         block_index,
 240                         value,
 241                         mifare_write_mifare_incr_cb,
 242                         user_data);
 243
 244         g_print("net_nfc_client_mifare_increment() : %d\n", result);
 245 }
 246
 247 void net_nfc_test_tag_mifare_decrement(gpointer data, gpointer user_data)
 248 {
 249         net_nfc_error_e  result = NET_NFC_OK;
 250         net_nfc_target_handle_s *handle = NULL;
 251         int value = 1;
 252         uint8_t block_index = 0x05;
 253
 254         handle = tag_get_handle();
 255         if (handle == NULL)
 256         {
 257                 g_printerr("Handle is NULL\n");
 258
 259                 run_next_callback(user_data);
 260                 return;
 261         }
 262         g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
 263
 264         result = net_nfc_client_mifare_decrement(handle,
 265                         block_index,
 266                         value,
 267                         mifare_write_mifare_decr_cb,
 268                         user_data);
 269
 270         g_print("net_nfc_client_mifare_decrement() : %d\n", result);
 271 }
 272
 273 void net_nfc_test_tag_mifare_transfer(gpointer data, gpointer user_data)
 274 {
 275         net_nfc_error_e  result = NET_NFC_OK;
 276         net_nfc_target_handle_s *handle = NULL;
 277         uint8_t block_index = 0x08;
 278
 279         handle = tag_get_handle();
 280         if (handle == NULL)
 281         {
 282                 g_printerr("Handle is NULL\n");
 283
 284                 run_next_callback(user_data);
 285                 return;
 286         }
 287         g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
 288
 289         result = net_nfc_client_mifare_transfer(handle,
 290                         block_index,
 291                         mifare_write_mifare_transfer_cb,
 292                         user_data);
 293
 294         g_print("net_nfc_client_mifare_transfer() : %d\n", result);
 295 }
 296
 297 void net_nfc_test_tag_mifare_restore(gpointer data, gpointer user_data)
 298 {
 299         net_nfc_error_e  result = NET_NFC_OK;
 300         net_nfc_target_handle_s *handle = NULL;
 301         uint8_t block_index = 0x08;
 302
 303         handle = tag_get_handle();
 304         if (handle == NULL)
 305         {
 306                 g_printerr("Handle is NULL\n");
 307
 308                 run_next_callback(user_data);
 309                 return;
 310         }
 311         g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
 312
 313         result = net_nfc_client_mifare_restore(handle,
 314                         block_index,
 315                         mifare_write_mifare_restore_cb,
 316                         user_data);
 317
 318         g_print("net_nfc_client_mifare_restore() : %d\n", result);
 319 }
 320
 321 void net_nfc_test_tag_mifare_authenticate_with_keyA(gpointer data,
 322                 gpointer user_data)
 323 {
 324         net_nfc_error_e  result = NET_NFC_OK;
 325         net_nfc_target_handle_s *handle = NULL;
 326         data_s *auth_key  = NULL;
 327         uint8_t sector_index = 0x02;
 328
 329         handle = tag_get_handle();
 330         if (handle == NULL)
 331         {
 332                 g_printerr("Handle is NULL\n");
 333
 334                 run_next_callback(user_data);
 335                 return;
 336         }
 337         g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
 338
 339         result = net_nfc_client_mifare_create_default_key(&auth_key);
 340         g_print("default key create %d", result);
 341
 342         result = net_nfc_client_mifare_authenticate_with_keyA(
 343                         handle,
 344                         sector_index,
 345                         auth_key,
 346                         mifare_write_auth_keyA_cb,
 347                         user_data);
 348
 349         g_print("net_nfc_client_mifare_authenticate_with_keyA() : %d\n", result);
 350 }
 351
 352 void net_nfc_test_tag_mifare_authenticate_with_keyB(gpointer data,
 353                 gpointer user_data)
 354 {
 355         net_nfc_error_e result = NET_NFC_OK;
 356         net_nfc_target_handle_s *handle = NULL;
 357         data_s *auth_key = NULL;
 358         uint8_t sector_index = 0x02;
 359
 360         handle = tag_get_handle();
 361         if (handle == NULL)
 362         {
 363                 g_printerr("Handle is NULL\n");
 364
 365                 run_next_callback(user_data);
 366                 return;
 367         }
 368         g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
 369
 370         result = net_nfc_client_mifare_create_default_key(&auth_key);
 371         g_print("default key create %d", result);
 372
 373         result = net_nfc_client_mifare_authenticate_with_keyB(
 374                         handle,
 375                         sector_index,
 376                         auth_key,
 377                         mifare_write_auth_keyB_cb,
 378                         user_data);
 379
 380         g_print("net_nfc_client_mifare_authenticate_with_keyB() : %d\n", result);
 381 }