src/nfc/nfc_util.cc

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   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 #include "nfc/nfc_util.h"
  18
  19 #include "common/assert.h"
  20 #include "common/logger.h"
  21 #include "common/platform_exception.h"
  22 #include "nfc/defs.h"
  23
  24 using namespace common;
  25
  26 namespace extension {
  27 namespace nfc {
  28
  29 UCharVector NFCUtil::ToVector(const unsigned char* ch, const int size) {
  30   ScopeLogger();
  31   UCharVector vec(ch, ch + size / sizeof(char));
  32   return vec;
  33 }
  34
  35 PlatformResult NFCUtil::CodeToResult(const int errorCode, const std::string& message,
  36                                      const bool newAPIVersion) {
  37   ScopeLogger();
  38   switch (errorCode) {
  39     case NFC_ERROR_INVALID_PARAMETER:
  40     case NFC_ERROR_INVALID_NDEF_MESSAGE:
  41     case NFC_ERROR_INVALID_RECORD_TYPE:
  42     case NFC_ERROR_NOT_NDEF_FORMAT:
  43       return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, message);
  44     case NFC_ERROR_SECURITY_RESTRICTED:
  45     case NFC_ERROR_PERMISSION_DENIED:
  46       return LogAndCreateResult(ErrorCode::SECURITY_ERR, message);
  47     case NFC_ERROR_NOT_SUPPORTED:
  48       return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, message);
  49     case NFC_ERROR_NOT_ACTIVATED:
  50       return LogAndCreateResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, message);
  51     case NFC_ERROR_OPERATION_FAILED:
  52     case NFC_ERROR_DEVICE_BUSY:
  53     case NFC_ERROR_NO_DEVICE:
  54     case NFC_ERROR_TIMED_OUT:
  55     case NFC_ERROR_OUT_OF_MEMORY:
  56     case NFC_ERROR_NOT_INITIALIZED:
  57     default:
  58       if (newAPIVersion) {
  59         return LogAndCreateResult(ErrorCode::ABORT_ERR, message);
  60       } else {
  61         return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, message);
  62       }
  63   }
  64 }
  65
  66 std::string NFCUtil::getNFCErrorString(const int error_code) {
  67   ScopeLogger("Error code : %d", error_code);
  68   switch (error_code) {
  69     case NFC_ERROR_ALREADY_ACTIVATED:
  70     case NFC_ERROR_ALREADY_DEACTIVATED:
  71       return "";
  72     case NFC_ERROR_INVALID_PARAMETER:
  73     case NFC_ERROR_INVALID_NDEF_MESSAGE:
  74     case NFC_ERROR_INVALID_RECORD_TYPE:
  75     case NFC_ERROR_NOT_NDEF_FORMAT:
  76       return INVALID_VALUES_ERROR_NAME_STR;
  77     case NFC_ERROR_NO_DEVICE:
  78     case NFC_ERROR_OUT_OF_MEMORY:
  79     case NFC_ERROR_OPERATION_FAILED:
  80     case NFC_ERROR_DEVICE_BUSY:
  81       return UNKNOWN_ERROR_NAME_STR;
  82     case NFC_ERROR_NOT_ACTIVATED:
  83       return SERVICE_NOT_AVAILABLE_ERROR_NAME_STR;
  84     case NFC_ERROR_NOT_SUPPORTED:
  85       return NOT_SUPPORTED_ERROR_NAME_STR;
  86     case NFC_ERROR_TIMED_OUT:
  87       return TIMEOUT_ERROR_NAME_STR;
  88   }
  89   return UNKNOWN_ERROR_NAME_STR;
  90 }
  91
  92 const std::string NFCUtil::getNFCErrorMessage(const int error_code) {
  93   ScopeLogger("Error code : %d", error_code);
  94   switch (error_code) {
  95     case NFC_ERROR_ALREADY_ACTIVATED:
  96     case NFC_ERROR_ALREADY_DEACTIVATED:
  97       return "";
  98     case NFC_ERROR_INVALID_PARAMETER:
  99       return "Invalid Parameter";
 100     case NFC_ERROR_INVALID_NDEF_MESSAGE:
 101       return "Invalid NDEF Message";
 102     case NFC_ERROR_INVALID_RECORD_TYPE:
 103       return "Invalid Record Type";
 104     case NFC_ERROR_NO_DEVICE:
 105       return "No Device";
 106     case NFC_ERROR_OUT_OF_MEMORY:
 107       return "Out Of Memory";
 108     case NFC_ERROR_NOT_SUPPORTED:
 109       return "NFC Not Supported";
 110     case NFC_ERROR_OPERATION_FAILED:
 111       return "Operation Failed";
 112     case NFC_ERROR_DEVICE_BUSY:
 113       return "Device Busy";
 114     case NFC_ERROR_NOT_ACTIVATED:
 115       return "NFC Not Activated";
 116     case NFC_ERROR_TIMED_OUT:
 117       return "Time Out";
 118     case NFC_ERROR_READ_ONLY_NDEF:
 119       return "Read Only NDEF";
 120     case NFC_ERROR_NO_SPACE_ON_NDEF:
 121       return "No Space On NDEF";
 122     case NFC_ERROR_NO_NDEF_MESSAGE:
 123       return "No NDEF Message";
 124     case NFC_ERROR_NOT_NDEF_FORMAT:
 125       return "Not NDEF Format";
 126     case NFC_ERROR_SECURITY_RESTRICTED:
 127       return "Security Restricted";
 128     default:
 129       return "UnknownError";
 130   }
 131 }
 132
 133 std::string NFCUtil::ToStringNFCTag(nfc_tag_type_e tag_type) {
 134   ScopeLogger();
 135   switch (tag_type) {
 136     case NFC_GENERIC_PICC:
 137       return GENERIC_TARGET;
 138     case NFC_ISO14443_A_PICC:
 139       return ISO14443_A;
 140     case NFC_ISO14443_4A_PICC:
 141       return ISO14443_4A;
 142     case NFC_ISO14443_3A_PICC:
 143       return ISO14443_3A;
 144     case NFC_MIFARE_MINI_PICC:
 145       return MIFARE_MINI;
 146     case NFC_MIFARE_1K_PICC:
 147       return MIFARE_1K;
 148     case NFC_MIFARE_4K_PICC:
 149       return MIFARE_4K;
 150     case NFC_MIFARE_ULTRA_PICC:
 151       return MIFARE_ULTRA;
 152     case NFC_MIFARE_DESFIRE_PICC:
 153       return MIFARE_DESFIRE;
 154     case NFC_ISO14443_B_PICC:
 155       return ISO14443_B;
 156     case NFC_ISO14443_4B_PICC:
 157       return ISO14443_4B;
 158     case NFC_ISO14443_BPRIME_PICC:
 159       return ISO14443_BPRIME;
 160     case NFC_FELICA_PICC:
 161       return FELICA;
 162     case NFC_JEWEL_PICC:
 163       return JEWEL;
 164     case NFC_ISO15693_PICC:
 165       return ISO15693;
 166     case NFC_UNKNOWN_TARGET:
 167     default:
 168       return UNKNOWN_TARGET;
 169   }
 170 }
 171
 172 PlatformResult NFCUtil::ToNfcTagString(const std::string& type_string, nfc_tag_type_e* tag_type) {
 173   ScopeLogger();
 174   if (GENERIC_TARGET == type_string) {
 175     *tag_type = NFC_GENERIC_PICC;
 176   } else if (ISO14443_A == type_string) {
 177     *tag_type = NFC_ISO14443_A_PICC;
 178   } else if (ISO14443_4A == type_string) {
 179     *tag_type = NFC_ISO14443_4A_PICC;
 180   } else if (ISO14443_3A == type_string) {
 181     *tag_type = NFC_ISO14443_3A_PICC;
 182   } else if (MIFARE_MINI == type_string) {
 183     *tag_type = NFC_MIFARE_MINI_PICC;
 184   } else if (MIFARE_1K == type_string) {
 185     *tag_type = NFC_MIFARE_1K_PICC;
 186   } else if (MIFARE_4K == type_string) {
 187     *tag_type = NFC_MIFARE_4K_PICC;
 188   } else if (MIFARE_ULTRA == type_string) {
 189     *tag_type = NFC_MIFARE_ULTRA_PICC;
 190   } else if (MIFARE_DESFIRE == type_string) {
 191     *tag_type = NFC_MIFARE_DESFIRE_PICC;
 192   } else if (ISO14443_B == type_string) {
 193     *tag_type = NFC_ISO14443_B_PICC;
 194   } else if (ISO14443_4B == type_string) {
 195     *tag_type = NFC_ISO14443_4B_PICC;
 196   } else if (ISO14443_BPRIME == type_string) {
 197     *tag_type = NFC_ISO14443_BPRIME_PICC;
 198   } else if (FELICA == type_string) {
 199     *tag_type = NFC_FELICA_PICC;
 200   } else if (JEWEL == type_string) {
 201     *tag_type = NFC_JEWEL_PICC;
 202   } else if (ISO15693 == type_string) {
 203     *tag_type = NFC_ISO15693_PICC;
 204   } else if (UNKNOWN_TARGET == type_string) {
 205     *tag_type = NFC_UNKNOWN_TARGET;
 206   } else {
 207     return LogAndCreateResult(ErrorCode::TYPE_MISMATCH_ERR, "No Match Tag Type");
 208   }
 209   return PlatformResult(ErrorCode::NO_ERROR);
 210 }
 211
 212 PlatformResult NFCUtil::ToStringCardEmulationMode(const nfc_se_card_emulation_mode_type_e card_mode,
 213                                                   std::string* mode) {
 214   ScopeLogger();
 215   switch (card_mode) {
 216     case NFC_SE_CARD_EMULATION_MODE_OFF:
 217       *mode = OFF;
 218       break;
 219     case NFC_SE_CARD_EMULATION_MODE_ON:
 220       *mode = ALWAYS_ON;
 221       break;
 222     default:
 223       return LogAndCreateResult(ErrorCode::TYPE_MISMATCH_ERR, "No Match Card Emulation mode",
 224                                 ("No Match Card Emulation mode: %x", card_mode));
 225   }
 226   return PlatformResult(ErrorCode::NO_ERROR);
 227 }
 228
 229 PlatformResult NFCUtil::ToCardEmulationMode(const std::string& mode_string,
 230                                             nfc_se_card_emulation_mode_type_e* mode) {
 231   ScopeLogger();
 232   if (mode_string == ALWAYS_ON) {
 233     *mode = NFC_SE_CARD_EMULATION_MODE_ON;
 234   } else if (mode_string == OFF) {
 235     *mode = NFC_SE_CARD_EMULATION_MODE_OFF;
 236   } else {
 237     return LogAndCreateResult(ErrorCode::TYPE_MISMATCH_ERR, "No Match Card Emulation mode",
 238                               ("No Match Card Emulation mode: %s", mode_string.c_str()));
 239   }
 240   return PlatformResult(ErrorCode::NO_ERROR);
 241 }
 242
 243 PlatformResult NFCUtil::ToStringSecureElementType(const nfc_se_type_e se_type, std::string* type) {
 244   ScopeLogger();
 245   switch (se_type) {
 246     case NFC_SE_TYPE_ESE:
 247       *type = DATA_NFC_SE_TYPE_ESE;
 248       break;
 249     case NFC_SE_TYPE_UICC:
 250       *type = DATA_NFC_SE_TYPE_UICC;
 251       break;
 252     case NFC_SE_TYPE_HCE:
 253       *type = DATA_NFC_SE_TYPE_HCE;
 254       break;
 255     default:
 256       return LogAndCreateResult(ErrorCode::TYPE_MISMATCH_ERR, "No Match Secure Element Type",
 257                                 ("No Match Secure Element Type: %x", se_type));
 258   }
 259   return PlatformResult(ErrorCode::NO_ERROR);
 260 }
 261
 262 PlatformResult NFCUtil::ToSecureElementType(const std::string& type_string, nfc_se_type_e* type) {
 263   ScopeLogger();
 264   if (type_string == DATA_NFC_SE_TYPE_ESE) {
 265     *type = NFC_SE_TYPE_ESE;
 266   } else if (type_string == DATA_NFC_SE_TYPE_UICC) {
 267     *type = NFC_SE_TYPE_UICC;
 268   } else if (type_string == DATA_NFC_SE_TYPE_HCE) {
 269     *type = NFC_SE_TYPE_HCE;
 270   } else {
 271     return LogAndCreateResult(ErrorCode::TYPE_MISMATCH_ERR, "No Match Secure Element Type",
 272                               ("No Match Secure Element Type: %s", type_string.c_str()));
 273   }
 274   return PlatformResult(ErrorCode::NO_ERROR);
 275 }
 276
 277 void NFCUtil::setDefaultFilterValues(std::vector<nfc_tag_type_e>& filter) {
 278   ScopeLogger();
 279   filter.push_back(NFC_GENERIC_PICC);
 280   filter.push_back(NFC_ISO14443_A_PICC);
 281   filter.push_back(NFC_ISO14443_3A_PICC);
 282   filter.push_back(NFC_ISO14443_3A_PICC);
 283   filter.push_back(NFC_MIFARE_MINI_PICC);
 284   filter.push_back(NFC_MIFARE_1K_PICC);
 285   filter.push_back(NFC_MIFARE_4K_PICC);
 286   filter.push_back(NFC_MIFARE_ULTRA_PICC);
 287   filter.push_back(NFC_MIFARE_DESFIRE_PICC);
 288   filter.push_back(NFC_ISO14443_B_PICC);
 289   filter.push_back(NFC_ISO14443_4B_PICC);
 290   filter.push_back(NFC_ISO14443_BPRIME_PICC);
 291   filter.push_back(NFC_FELICA_PICC);
 292   filter.push_back(NFC_JEWEL_PICC);
 293   filter.push_back(NFC_ISO15693_PICC);
 294   filter.push_back(NFC_UNKNOWN_TARGET);
 295 }
 296
 297 // Convertion of enum to HCEEventType(characters sequence).
 298 PlatformResult NFCUtil::ToStr(nfc_hce_event_type_e event_type, std::string* result_type) {
 299   ScopeLogger();
 300   switch (event_type) {
 301     case NFC_HCE_EVENT_DEACTIVATED:
 302       *result_type = "DEACTIVATED";
 303       break;
 304     case NFC_HCE_EVENT_ACTIVATED:
 305       *result_type = "ACTIVATED";
 306       break;
 307     case NFC_HCE_EVENT_APDU_RECEIVED:
 308       *result_type = "APDU_RECEIVED";
 309       break;
 310     default:
 311       return LogAndCreateResult(
 312           ErrorCode::UNKNOWN_ERR, "That event type is incorrect.",
 313           ("Event has not an expected value. Passed value is %d", (int)event_type));
 314   }
 315   return PlatformResult(ErrorCode::NO_ERROR);
 316 }
 317
 318 // Convertion of enum to SecureElementType(characters sequence).
 319 // Warning! DISABLE and SDCARD are not mentioned at widl spec.
 320 PlatformResult NFCUtil::ToStr(nfc_se_type_e se_type, std::string* result_type) {
 321   ScopeLogger();
 322   switch (se_type) {
 323     case NFC_SE_TYPE_DISABLE:
 324       *result_type = "DISABLE";
 325       break;
 326     case NFC_SE_TYPE_ESE:
 327       *result_type = "ESE";
 328       break;
 329     case NFC_SE_TYPE_UICC:
 330       *result_type = "UICC";
 331       break;
 332     case NFC_SE_TYPE_SDCARD:
 333       *result_type = "SDCARD";
 334       break;
 335     case NFC_SE_TYPE_HCE:
 336       *result_type = "HCE";
 337       break;
 338     default:
 339       return LogAndCreateResult(
 340           ErrorCode::UNKNOWN_ERR, "That event type is incorrect.",
 341           ("Event has not an expected value. Passed value is %d", (int)se_type));
 342   }
 343   return PlatformResult(ErrorCode::NO_ERROR);
 344 }
 345
 346 // Convertion CardEmulationCategoryType(characters sequence) to enum.
 347 PlatformResult NFCUtil::StringToCategory(const std::string& category_type,
 348                                          nfc_card_emulation_category_type_e* result_type) {
 349   ScopeLogger();
 350   if (category_type == "PAYMENT") {
 351     *result_type = NFC_CARD_EMULATION_CATEGORY_PAYMENT;
 352   } else if (category_type == "OTHER") {
 353     *result_type = NFC_CARD_EMULATION_CATEGORY_OTHER;
 354   } else {
 355     return LogAndCreateResult(
 356         ErrorCode::UNKNOWN_ERR, "That category type is incorrect.",
 357         ("Category has not an expected value. Passed value is %s", category_type.c_str()));
 358   }
 359   return PlatformResult(ErrorCode::NO_ERROR);
 360 }
 361
 362 unsigned char* NFCUtil::DoubleArrayToUCharArray(const picojson::array& array_in) {
 363   ScopeLogger();
 364   unsigned char* result_array = new unsigned char[array_in.size()];
 365   for (std::size_t i = 0; i < array_in.size(); ++i) {
 366     result_array[i] = (int) array_in.at(i).get<double>();
 367   }
 368   return result_array;
 369 }
 370
 371 UCharVector NFCUtil::DoubleArrayToUCharVector(const picojson::array& array_in) {
 372   ScopeLogger();
 373   return ToVector(NFCUtil::DoubleArrayToUCharArray(array_in), array_in.size());
 374 }
 375
 376 picojson::array NFCUtil::FromUCharArray(unsigned char* array, unsigned int apdu_len) {
 377   ScopeLogger();
 378   picojson::array apdu_array;
 379   apdu_array.reserve(apdu_len);
 380   for (unsigned int i = 0; i < apdu_len; ++i)
 381     apdu_array.push_back(picojson::value(static_cast<double>(array[i])));
 382   return apdu_array;
 383 }
 384
 385 }  // nfc
 386 }  // extension