1 /*
2 * Copyright (C) 2013 The Android Open Source Project
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 * Manage the listen-mode routing table.
19 */
20
21 #include "RoutingManager.h"
22 // Redefined by android-base headers.
23 #undef ATTRIBUTE_UNUSED
24
25 #include <android-base/logging.h>
26 #include <android-base/stringprintf.h>
27 #include <nativehelper/JNIHelp.h>
28 #include <nativehelper/ScopedLocalRef.h>
29
30 #include "JavaClassConstants.h"
31 #include "nfa_ce_api.h"
32 #include "nfa_ee_api.h"
33 #include "nfc_config.h"
34
35 using android::base::StringPrintf;
36
37 extern bool gActivated;
38 extern SyncEvent gDeactivatedEvent;
39
40 const JNINativeMethod RoutingManager::sMethods[] = {
41 {"doGetDefaultRouteDestination", "()I",
42 (void*)RoutingManager::
43 com_android_nfc_cardemulation_doGetDefaultRouteDestination},
44 {"doGetDefaultOffHostRouteDestination", "()I",
45 (void*)RoutingManager::
46 com_android_nfc_cardemulation_doGetDefaultOffHostRouteDestination},
47 {"doGetDefaultFelicaRouteDestination", "()I",
48 (void*)RoutingManager::
49 com_android_nfc_cardemulation_doGetDefaultFelicaRouteDestination},
50 {"doGetOffHostUiccDestination", "()[B",
51 (void*)RoutingManager::
52 com_android_nfc_cardemulation_doGetOffHostUiccDestination},
53 {"doGetOffHostEseDestination", "()[B",
54 (void*)RoutingManager::
55 com_android_nfc_cardemulation_doGetOffHostEseDestination},
56 {"doGetAidMatchingMode", "()I",
57 (void*)RoutingManager::com_android_nfc_cardemulation_doGetAidMatchingMode},
58 {"doGetDefaultIsoDepRouteDestination", "()I",
59 (void*)RoutingManager::
60 com_android_nfc_cardemulation_doGetDefaultIsoDepRouteDestination},
61 {"doGetDefaultScRouteDestination", "()I",
62 (void*)RoutingManager::
63 com_android_nfc_cardemulation_doGetDefaultScRouteDestination},
64 {"doGetEuiccMepMode", "()I",
65 (void*)RoutingManager::com_android_nfc_cardemulation_doGetEuiccMepMode}};
66
67 static const int MAX_NUM_EE = 5;
68 // SCBR from host works only when App is in foreground
69 static const uint8_t SYS_CODE_PWR_STATE_HOST = 0x01;
70 static const uint16_t DEFAULT_SYS_CODE = 0xFEFE;
71
72 static const uint8_t AID_ROUTE_QUAL_PREFIX = 0x10;
73
74 static Mutex sEeInfoMutex;
75 static Mutex sEeInfoChangedMutex;
76
77 /*******************************************************************************
78 **
79 ** Function: RoutingManager
80 **
81 ** Description: Constructor
82 **
83 ** Returns: None
84 **
85 *******************************************************************************/
RoutingManager()86 RoutingManager::RoutingManager()
87 : mSecureNfcEnabled(false),
88 mNativeData(NULL),
89 mAidRoutingConfigured(false) {
90 static const char fn[] = "RoutingManager::RoutingManager()";
91
92 mDefaultOffHostRoute =
93 NfcConfig::getUnsigned(NAME_DEFAULT_OFFHOST_ROUTE, 0x00);
94
95 if (NfcConfig::hasKey(NAME_OFFHOST_ROUTE_UICC)) {
96 mOffHostRouteUicc = NfcConfig::getBytes(NAME_OFFHOST_ROUTE_UICC);
97 }
98
99 if (NfcConfig::hasKey(NAME_OFFHOST_ROUTE_ESE)) {
100 mOffHostRouteEse = NfcConfig::getBytes(NAME_OFFHOST_ROUTE_ESE);
101 }
102
103 mDefaultFelicaRoute = NfcConfig::getUnsigned(NAME_DEFAULT_NFCF_ROUTE, 0x00);
104 LOG(DEBUG) << StringPrintf("%s: Active SE for Nfc-F is 0x%02X", fn,
105 mDefaultFelicaRoute);
106
107 mDefaultEe = NfcConfig::getUnsigned(NAME_DEFAULT_ROUTE, 0x00);
108 LOG(DEBUG) << StringPrintf("%s: default route is 0x%02X", fn, mDefaultEe);
109
110 mAidMatchingMode =
111 NfcConfig::getUnsigned(NAME_AID_MATCHING_MODE, AID_MATCHING_EXACT_ONLY);
112
113 mDefaultSysCodeRoute =
114 NfcConfig::getUnsigned(NAME_DEFAULT_SYS_CODE_ROUTE, 0xC0);
115
116 mDefaultSysCodePowerstate =
117 NfcConfig::getUnsigned(NAME_DEFAULT_SYS_CODE_PWR_STATE, 0x19);
118
119 mDefaultSysCode = DEFAULT_SYS_CODE;
120 if (NfcConfig::hasKey(NAME_DEFAULT_SYS_CODE)) {
121 std::vector<uint8_t> pSysCode = NfcConfig::getBytes(NAME_DEFAULT_SYS_CODE);
122 if (pSysCode.size() == 0x02) {
123 mDefaultSysCode = ((pSysCode[0] << 8) | ((int)pSysCode[1] << 0));
124 LOG(DEBUG) << StringPrintf("%s: DEFAULT_SYS_CODE=0x%02X", __func__,
125 mDefaultSysCode);
126 }
127 }
128
129 mOffHostAidRoutingPowerState =
130 NfcConfig::getUnsigned(NAME_OFFHOST_AID_ROUTE_PWR_STATE, 0x01);
131
132 mDefaultIsoDepRoute = NfcConfig::getUnsigned(NAME_DEFAULT_ISODEP_ROUTE, 0x0);
133
134 mHostListenTechMask =
135 NfcConfig::getUnsigned(NAME_HOST_LISTEN_TECH_MASK,
136 NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_F);
137
138 mOffHostListenTechMask = NfcConfig::getUnsigned(
139 NAME_OFFHOST_LISTEN_TECH_MASK,
140 NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B | NFA_TECHNOLOGY_MASK_F);
141
142 mEuiccMepMode= NfcConfig::getUnsigned(NAME_EUICC_MEP_MODE, 0x0);
143
144 if (NfcConfig::hasKey(NAME_NFCEE_EVENT_RF_DISCOVERY_OPTION)) {
145 mIsRFDiscoveryOptimized =
146 (NfcConfig::getUnsigned(NAME_NFCEE_EVENT_RF_DISCOVERY_OPTION) == 0x01
147 ? true
148 : false);
149 LOG(VERBOSE) << StringPrintf(
150 "%s: NAME_NFCEE_EVENT_RF_DISCOVERY_OPTION found=%d", fn,
151 mIsRFDiscoveryOptimized);
152 } else {
153 mIsRFDiscoveryOptimized = false;
154 LOG(VERBOSE) << StringPrintf(
155 "%s: NAME_NFCEE_EVENT_RF_DISCOVERY_OPTION not found=%d", fn,
156 mIsRFDiscoveryOptimized);
157 }
158
159 memset(&mEeInfo, 0, sizeof(mEeInfo));
160 mReceivedEeInfo = false;
161 mSeTechMask = 0x00;
162 mIsScbrSupported = false;
163
164 mNfcFOnDhHandle = NFA_HANDLE_INVALID;
165
166 mDeinitializing = false;
167 }
168
169 /*******************************************************************************
170 **
171 ** Function: RoutingManager
172 **
173 ** Description: Destructor
174 **
175 ** Returns: None
176 **
177 *******************************************************************************/
~RoutingManager()178 RoutingManager::~RoutingManager() {}
179
180 /*******************************************************************************
181 **
182 ** Function: initialize
183 **
184 ** Description: Initialize the object
185 **
186 ** Returns: true if OK
187 ** false if failed
188 **
189 *******************************************************************************/
initialize(nfc_jni_native_data * native)190 bool RoutingManager::initialize(nfc_jni_native_data* native) {
191 static const char fn[] = "RoutingManager::initialize()";
192 mNativeData = native;
193 mRxDataBuffer.clear();
194
195 {
196 SyncEventGuard guard(mEeRegisterEvent);
197 LOG(DEBUG) << fn << ": try ee register";
198 tNFA_STATUS nfaStat = NFA_EeRegister(nfaEeCallback);
199 if (nfaStat != NFA_STATUS_OK) {
200 LOG(ERROR) << StringPrintf("%s: fail ee register; error=0x%X", fn,
201 nfaStat);
202 return false;
203 }
204 mEeRegisterEvent.wait();
205 }
206
207 if ((mDefaultOffHostRoute != 0) || (mDefaultFelicaRoute != 0)) {
208 // Wait for EE info if needed
209 SyncEventGuard guard(mEeInfoEvent);
210 if (!mReceivedEeInfo) {
211 LOG(INFO) << fn << ": Waiting for EE info";
212 mEeInfoEvent.wait();
213 }
214 }
215
216 // Set the host-routing Tech
217 tNFA_STATUS nfaStat = NFA_CeSetIsoDepListenTech(
218 mHostListenTechMask & (NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B));
219
220 if (nfaStat != NFA_STATUS_OK)
221 LOG(ERROR) << StringPrintf("%s: Failed to configure CE IsoDep technologies",
222 fn);
223
224 // Register a wild-card for AIDs routed to the host
225 nfaStat = NFA_CeRegisterAidOnDH(NULL, 0, stackCallback);
226 if (nfaStat != NFA_STATUS_OK)
227 LOG(ERROR) << fn << ": Failed to register wildcard AID for DH";
228
229 // Trigger RT update
230 setEeInfoChangedFlag();
231 mDefaultAidRouteAdded = false;
232
233 return true;
234 }
235
236 /*******************************************************************************
237 **
238 ** Function: getInstance
239 **
240 ** Description: Get an instance of RoutingManager object
241 **
242 ** Returns: handle to object
243 **
244 *******************************************************************************/
getInstance()245 RoutingManager& RoutingManager::getInstance() {
246 static RoutingManager manager;
247 return manager;
248 }
249
250 /*******************************************************************************
251 **
252 ** Function: isTypeATypeBTechSupportedInEe
253 **
254 ** Description: receive eeHandle
255 **
256 ** Returns: true : if EE support protocol type A/B
257 ** false : if EE doesn't protocol type A/B
258 **
259 *******************************************************************************/
isTypeATypeBTechSupportedInEe(tNFA_HANDLE eeHandle)260 bool RoutingManager::isTypeATypeBTechSupportedInEe(tNFA_HANDLE eeHandle) {
261 static const char fn[] = "RoutingManager::isTypeATypeBTechSupportedInEe";
262 uint8_t actualNbEe = MAX_NUM_EE;
263 tNFA_EE_INFO eeInfo[actualNbEe];
264
265 memset(&eeInfo, 0, actualNbEe * sizeof(tNFA_EE_INFO));
266 tNFA_STATUS nfaStat = NFA_EeGetInfo(&actualNbEe, eeInfo);
267 if (nfaStat != NFA_STATUS_OK) {
268 return false;
269 }
270 for (auto i = 0; i < actualNbEe; i++) {
271 if (eeHandle == eeInfo[i].ee_handle) {
272 if (eeInfo[i].la_protocol || eeInfo[i].lb_protocol) {
273 return true;
274 }
275 }
276 }
277
278 if (mEuiccMepMode) {
279 memset(&eeInfo, 0, MAX_NUM_EE * sizeof(tNFA_EE_INFO));
280 nfaStat = NFA_EeGetMepInfo(&actualNbEe, eeInfo);
281 if (nfaStat != NFA_STATUS_OK) {
282 return false;
283 }
284 for (auto i = 0; i < actualNbEe; i++) {
285 if (eeHandle == eeInfo[i].ee_handle) {
286 if (eeInfo[i].la_protocol || eeInfo[i].lb_protocol) {
287 return true;
288 }
289 }
290 }
291 }
292
293 LOG(WARNING) << StringPrintf(
294 "%s: Route does not support A/B, using DH as default", fn);
295 return false;
296 }
297
298 /*******************************************************************************
299 **
300 ** Function: addAidRouting
301 **
302 ** Description: Add an AID to be programmed in routing table.
303 **
304 ** Returns: true if procedure OK
305 ** false if procedure failed
306 **
307 *******************************************************************************/
addAidRouting(const uint8_t * aid,uint8_t aidLen,int route,int aidInfo,int power)308 bool RoutingManager::addAidRouting(const uint8_t* aid, uint8_t aidLen,
309 int route, int aidInfo, int power) {
310 static const char fn[] = "RoutingManager::addAidRouting";
311 uint8_t powerState = 0x01;
312
313 if (route != NFC_DH_ID &&
314 !isTypeATypeBTechSupportedInEe(route | NFA_HANDLE_GROUP_EE)) {
315 route = NFC_DH_ID;
316 }
317
318 if (!mSecureNfcEnabled) {
319 if (power == 0x00) {
320 powerState = (route != 0x00) ? mOffHostAidRoutingPowerState : 0x11;
321 } else {
322 powerState =
323 (route != 0x00) ? mOffHostAidRoutingPowerState & power : power;
324 }
325 }
326
327 if (aidLen == 0) {
328 LOG(DEBUG) << StringPrintf(
329 "%s: default AID on route=%02x, aidInfo=%02x, power=%02x", fn, route,
330 aidInfo, power);
331 mDefaultAidRouteAdded = true;
332 } else {
333 LOG(DEBUG) << StringPrintf(
334 "%s: aidLen =%02X, route=%02x, aidInfo=%02x, power=%02x", fn, aidLen,
335 route, aidInfo, power);
336 }
337
338 SyncEventGuard guard(mAidAddRemoveEvent);
339 mAidRoutingConfigured = false;
340 tNFA_STATUS nfaStat =
341 NFA_EeAddAidRouting(route, aidLen, (uint8_t*)aid, powerState, aidInfo);
342 if (nfaStat == NFA_STATUS_OK) {
343 mAidAddRemoveEvent.wait();
344 }
345 if (mAidRoutingConfigured) {
346 return true;
347 } else {
348 LOG(ERROR) << fn << ": failed to route AID";
349 return false;
350 }
351 }
352
353 /*******************************************************************************
354 **
355 ** Function: removeAidRouting
356 **
357 ** Description: Removes an AID from the routing table
358 **
359 ** Returns: true if procedure OK
360 ** false if procedure failed
361 **
362 *******************************************************************************/
removeAidRouting(const uint8_t * aid,uint8_t aidLen)363 bool RoutingManager::removeAidRouting(const uint8_t* aid, uint8_t aidLen) {
364 static const char fn[] = "RoutingManager::removeAidRouting";
365
366 if (aidLen != 0) {
367 LOG(DEBUG) << StringPrintf("%s: len=%d, 0x%x 0x%x 0x%x 0x%x 0x%x", __func__,
368 aidLen, *(aid), *(aid + 1), *(aid + 2),
369 *(aid + 3), *(aid + 4));
370 } else {
371 LOG(DEBUG) << fn << ": Remove Empty aid";
372 }
373
374 SyncEventGuard guard(mAidAddRemoveEvent);
375 mAidRoutingConfigured = false;
376 tNFA_STATUS nfaStat = NFA_EeRemoveAidRouting(aidLen, (uint8_t*)aid);
377 if (nfaStat == NFA_STATUS_OK) {
378 mAidAddRemoveEvent.wait();
379 }
380 if (mAidRoutingConfigured) {
381 return true;
382 } else {
383 LOG(WARNING) << fn << ": failed to remove AID";
384 return false;
385 }
386 }
387
388 /*******************************************************************************
389 **
390 ** Function: commitRouting
391 **
392 ** Description: Ask for routing table update
393 **
394 ** Returns: true if procedure OK
395 ** false if procedure failed
396 **
397 *******************************************************************************/
commitRouting()398 tNFA_STATUS RoutingManager::commitRouting() {
399 static const char fn[] = "RoutingManager::commitRouting";
400 tNFA_STATUS nfaStat = 0;
401 sEeInfoChangedMutex.lock();
402 bool eeChanged = mEeInfoChanged;
403 mEeInfoChanged = false;
404 sEeInfoChangedMutex.unlock();
405 if (eeChanged) {
406 clearRoutingEntry(CLEAR_PROTOCOL_ENTRIES | CLEAR_TECHNOLOGY_ENTRIES);
407 updateRoutingTable();
408 }
409 if (mAidRoutingConfigured || eeChanged) {
410 LOG(DEBUG) << StringPrintf("%s: RT update needed", fn);
411 {
412 SyncEventGuard guard(mEeUpdateEvent);
413 nfaStat = NFA_EeUpdateNow();
414 if (nfaStat == NFA_STATUS_OK) {
415 mEeUpdateEvent.wait(); // wait for NFA_EE_UPDATED_EVT
416 }
417 }
418 }
419 return nfaStat;
420 }
421
422 /*******************************************************************************
423 **
424 ** Function: onNfccShutdown
425 **
426 ** Description: performs tasks for NFC shutdown
427 **
428 ** Returns: None
429 **
430 *******************************************************************************/
onNfccShutdown()431 void RoutingManager::onNfccShutdown() {
432 static const char fn[] = "RoutingManager:onNfccShutdown";
433 if (mDefaultOffHostRoute == 0x00 && mDefaultFelicaRoute == 0x00) return;
434
435 tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
436 uint8_t actualNumEe = MAX_NUM_EE;
437 tNFA_EE_INFO eeInfo[MAX_NUM_EE];
438 mDeinitializing = true;
439
440 memset(&eeInfo, 0, sizeof(eeInfo));
441 if ((nfaStat = NFA_EeGetInfo(&actualNumEe, eeInfo)) != NFA_STATUS_OK) {
442 LOG(ERROR) << StringPrintf("%s: fail get info; error=0x%X", fn, nfaStat);
443 return;
444 }
445 if (actualNumEe != 0) {
446 for (uint8_t xx = 0; xx < actualNumEe; xx++) {
447 bool bIsOffHostEEPresent =
448 (NFC_GetNCIVersion() < NCI_VERSION_2_0)
449 ? (eeInfo[xx].num_interface != 0)
450 : (eeInfo[xx].ee_interface[0] !=
451 NCI_NFCEE_INTERFACE_HCI_ACCESS) &&
452 (eeInfo[xx].ee_status == NFA_EE_STATUS_ACTIVE);
453 if (bIsOffHostEEPresent) {
454 LOG(DEBUG) << StringPrintf(
455 "%s: Handle=0x%04x Change Status Active to Inactive", fn,
456 eeInfo[xx].ee_handle);
457 SyncEventGuard guard(mEeSetModeEvent);
458 if ((nfaStat = NFA_EeModeSet(eeInfo[xx].ee_handle,
459 NFA_EE_MD_DEACTIVATE)) == NFA_STATUS_OK) {
460 mEeSetModeEvent.wait(); // wait for NFA_EE_MODE_SET_EVT
461 } else {
462 LOG(ERROR) << fn << ": Failed to set EE inactive";
463 }
464 }
465 }
466 } else {
467 LOG(DEBUG) << fn << ": No active EEs found";
468 }
469 //release waits
470 {
471 SyncEventGuard guard(mEeRegisterEvent);
472 mEeRegisterEvent.notifyOne();
473 }
474 {
475 SyncEventGuard guard(mRoutingEvent);
476 mRoutingEvent.notifyOne();
477 }
478 {
479 SyncEventGuard guard(mEeSetModeEvent);
480 mEeSetModeEvent.notifyOne();
481 }
482 {
483 SyncEventGuard guard(mEePwrAndLinkCtrlEvent);
484 mEePwrAndLinkCtrlEvent.notifyOne();
485 }
486 {
487 SyncEventGuard guard(mAidAddRemoveEvent);
488 mAidAddRemoveEvent.notifyOne();
489 }
490 }
491
492 /*******************************************************************************
493 **
494 ** Function: notifyActivated
495 **
496 ** Description: Notify upper layers of CE activation
497 **
498 ** Returns: None
499 **
500 *******************************************************************************/
notifyActivated(uint8_t technology)501 void RoutingManager::notifyActivated(uint8_t technology) {
502 JNIEnv* e = NULL;
503 ScopedAttach attach(mNativeData->vm, &e);
504 if (e == NULL) {
505 LOG(ERROR) << __func__ << ": jni env is null";
506 return;
507 }
508
509 e->CallVoidMethod(mNativeData->manager,
510 android::gCachedNfcManagerNotifyHostEmuActivated,
511 (int)technology);
512 if (e->ExceptionCheck()) {
513 e->ExceptionClear();
514 LOG(ERROR) << __func__ << ": fail notify";
515 }
516 }
517
518 /*******************************************************************************
519 **
520 ** Function: getNameOfEe
521 **
522 ** Description: Translates NFCEE Id into string name, if it exists
523 **
524 ** Returns: true if handle was found
525 ** false if not
526 **
527 *******************************************************************************/
getNameOfEe(tNFA_HANDLE ee_handle,std::string & eeName)528 bool RoutingManager::getNameOfEe(tNFA_HANDLE ee_handle, std::string& eeName) {
529 if (mOffHostRouteEse.size() == 0) {
530 return false;
531 }
532 ee_handle &= ~NFA_HANDLE_GROUP_EE;
533
534 for (uint8_t i = 0; i < mOffHostRouteEse.size(); i++) {
535 if (ee_handle == mOffHostRouteEse[i]) {
536 eeName = "eSE" + std::to_string(i + 1);
537 return true;
538 }
539 }
540 for (uint8_t i = 0; i < mOffHostRouteUicc.size(); i++) {
541 if (ee_handle == mOffHostRouteUicc[i]) {
542 eeName = "SIM" + std::to_string(i + 1);
543 return true;
544 }
545 }
546
547 LOG(WARNING) << __func__ << ": Incorrect EE Id";
548 return false;
549 }
550
551 /*******************************************************************************
552 **
553 ** Function: notifyEeAidSelected
554 **
555 ** Description: Notify upper layers of RF_NFCEE_ACTION_NTF with trigger
556 ** AID
557 **
558 ** Returns: None
559 **
560 *******************************************************************************/
notifyEeAidSelected(tNFC_AID & nfcaid,tNFA_HANDLE ee_handle)561 void RoutingManager::notifyEeAidSelected(tNFC_AID& nfcaid,
562 tNFA_HANDLE ee_handle) {
563 std::vector<uint8_t> aid(nfcaid.aid, nfcaid.aid + nfcaid.len_aid);
564 if (aid.empty()) {
565 return;
566 }
567
568 JNIEnv* e = NULL;
569 ScopedAttach attach(mNativeData->vm, &e);
570 CHECK(e);
571
572 ScopedLocalRef<jobject> aidJavaArray(e, e->NewByteArray(aid.size()));
573 CHECK(aidJavaArray.get());
574 e->SetByteArrayRegion((jbyteArray)aidJavaArray.get(), 0, aid.size(),
575 (jbyte*)&aid[0]);
576 CHECK(!e->ExceptionCheck());
577
578 std::string evtSrc;
579 if (!getNameOfEe(ee_handle, evtSrc)) {
580 return;
581 }
582
583 ScopedLocalRef<jobject> srcJavaString(e, e->NewStringUTF(evtSrc.c_str()));
584 CHECK(srcJavaString.get());
585 e->CallVoidMethod(mNativeData->manager,
586 android::gCachedNfcManagerNotifyEeAidSelected,
587 aidJavaArray.get(), srcJavaString.get());
588 }
589
590 /*******************************************************************************
591 **
592 ** Function: notifyEeProtocolSelected
593 **
594 ** Description: Notify upper layers of RF_NFCEE_ACTION_NTF with trigger
595 ** protocol
596 **
597 ** Returns: None
598 **
599 *******************************************************************************/
notifyEeProtocolSelected(uint8_t protocol,tNFA_HANDLE ee_handle)600 void RoutingManager::notifyEeProtocolSelected(uint8_t protocol,
601 tNFA_HANDLE ee_handle) {
602 JNIEnv* e = NULL;
603 ScopedAttach attach(mNativeData->vm, &e);
604 CHECK(e);
605
606 std::string evtSrc;
607 if (!getNameOfEe(ee_handle, evtSrc)) {
608 return;
609 }
610
611 ScopedLocalRef<jobject> srcJavaString(e, e->NewStringUTF(evtSrc.c_str()));
612 CHECK(srcJavaString.get());
613 e->CallVoidMethod(mNativeData->manager,
614 android::gCachedNfcManagerNotifyEeProtocolSelected,
615 protocol, srcJavaString.get());
616 }
617
618 /*******************************************************************************
619 **
620 ** Function: notifyEeTechSelected
621 **
622 ** Description: Notify upper layers of RF_NFCEE_ACTION_NTF with trigger
623 ** technology
624 **
625 ** Returns: None
626 **
627 *******************************************************************************/
notifyEeTechSelected(uint8_t tech,tNFA_HANDLE ee_handle)628 void RoutingManager::notifyEeTechSelected(uint8_t tech, tNFA_HANDLE ee_handle) {
629 JNIEnv* e = NULL;
630 ScopedAttach attach(mNativeData->vm, &e);
631 CHECK(e);
632
633 std::string evtSrc;
634 if (!getNameOfEe(ee_handle, evtSrc)) {
635 return;
636 }
637
638 ScopedLocalRef<jobject> srcJavaString(e, e->NewStringUTF(evtSrc.c_str()));
639 CHECK(srcJavaString.get());
640 e->CallVoidMethod(mNativeData->manager,
641 android::gCachedNfcManagerNotifyEeTechSelected, tech,
642 srcJavaString.get());
643 }
644
645 /*******************************************************************************
646 **
647 ** Function: notifyDeactivated
648 **
649 ** Description: Notify upper layers for CE deactivation
650 **
651 ** Returns: None
652 **
653 *******************************************************************************/
notifyDeactivated(uint8_t technology)654 void RoutingManager::notifyDeactivated(uint8_t technology) {
655 mRxDataBuffer.clear();
656 JNIEnv* e = NULL;
657 ScopedAttach attach(mNativeData->vm, &e);
658 if (e == NULL) {
659 LOG(ERROR) << __func__ << ": jni env is null";
660 return;
661 }
662
663 e->CallVoidMethod(mNativeData->manager,
664 android::gCachedNfcManagerNotifyEeListenActivated,
665 JNI_FALSE);
666 if (e->ExceptionCheck()) {
667 e->ExceptionClear();
668 LOG(ERROR) << StringPrintf("%s: Fail to notify Ee listen active status",
669 __func__);
670 }
671
672 e->CallVoidMethod(mNativeData->manager,
673 android::gCachedNfcManagerNotifyHostEmuDeactivated,
674 (int)technology);
675 if (e->ExceptionCheck()) {
676 e->ExceptionClear();
677 LOG(ERROR) << StringPrintf("%s: fail notify", __func__);
678 }
679 }
680
681 /*******************************************************************************
682 **
683 ** Function: handleData
684 **
685 ** Description: Notify upper layers of received HCE data
686 **
687 ** Returns: None
688 **
689 *******************************************************************************/
handleData(uint8_t technology,const uint8_t * data,uint32_t dataLen,tNFA_STATUS status)690 void RoutingManager::handleData(uint8_t technology, const uint8_t* data,
691 uint32_t dataLen, tNFA_STATUS status) {
692 if (status == NFC_STATUS_CONTINUE) {
693 if (dataLen > 0) {
694 mRxDataBuffer.insert(mRxDataBuffer.end(), &data[0],
695 &data[dataLen]); // append data; more to come
696 }
697 return; // expect another NFA_CE_DATA_EVT to come
698 } else if (status == NFA_STATUS_OK) {
699 if (dataLen > 0) {
700 mRxDataBuffer.insert(mRxDataBuffer.end(), &data[0],
701 &data[dataLen]); // append data
702 }
703 // entire data packet has been received; no more NFA_CE_DATA_EVT
704 } else if (status == NFA_STATUS_FAILED) {
705 LOG(ERROR) << __func__ << ": read data fail";
706 goto TheEnd;
707 }
708
709 {
710 JNIEnv* e = NULL;
711 ScopedAttach attach(mNativeData->vm, &e);
712 if (e == NULL) {
713 LOG(ERROR) << __func__ << ": jni env is null";
714 goto TheEnd;
715 }
716
717 ScopedLocalRef<jobject> dataJavaArray(
718 e, e->NewByteArray(mRxDataBuffer.size()));
719 if (dataJavaArray.get() == NULL) {
720 LOG(ERROR) << __func__ << ": fail allocate array";
721 goto TheEnd;
722 }
723
724 e->SetByteArrayRegion((jbyteArray)dataJavaArray.get(), 0,
725 mRxDataBuffer.size(), (jbyte*)(&mRxDataBuffer[0]));
726 if (e->ExceptionCheck()) {
727 e->ExceptionClear();
728 LOG(ERROR) << __func__ << ": fail fill array";
729 goto TheEnd;
730 }
731
732 e->CallVoidMethod(mNativeData->manager,
733 android::gCachedNfcManagerNotifyHostEmuData,
734 (int)technology, dataJavaArray.get());
735 if (e->ExceptionCheck()) {
736 e->ExceptionClear();
737 LOG(ERROR) << __func__ << ": fail notify";
738 }
739 }
740 TheEnd:
741 mRxDataBuffer.clear();
742 }
743
744 /*******************************************************************************
745 **
746 ** Function: notifyEeUpdated
747 **
748 ** Description: notify upper layers of NFCEE RF capabilities update
749 **
750 ** Returns: None
751 **
752 *******************************************************************************/
notifyEeUpdated()753 void RoutingManager::notifyEeUpdated() {
754 JNIEnv* e = NULL;
755 ScopedAttach attach(mNativeData->vm, &e);
756 if (e == NULL) {
757 LOG(ERROR) << __func__ << ": jni env is null";
758 return;
759 }
760
761 e->CallVoidMethod(mNativeData->manager,
762 android::gCachedNfcManagerNotifyEeUpdated);
763 if (e->ExceptionCheck()) {
764 e->ExceptionClear();
765 LOG(ERROR) << __func__ << ": fail notify";
766 }
767 }
768
769 /*******************************************************************************
770 **
771 ** Function: stackCallback
772 **
773 ** Description: Handles callback for completion of calls to NFA APIs
774 **
775 ** Returns: None
776 **
777 *******************************************************************************/
stackCallback(uint8_t event,tNFA_CONN_EVT_DATA * eventData)778 void RoutingManager::stackCallback(uint8_t event,
779 tNFA_CONN_EVT_DATA* eventData) {
780 static const char fn[] = "RoutingManager::stackCallback";
781 RoutingManager& routingManager = RoutingManager::getInstance();
782
783 switch (event) {
784 case NFA_CE_REGISTERED_EVT: {
785 tNFA_CE_REGISTERED& ce_registered = eventData->ce_registered;
786 LOG(DEBUG) << StringPrintf(
787 "%s: NFA_CE_REGISTERED_EVT; status=0x%X; h=0x%X", fn,
788 ce_registered.status, ce_registered.handle);
789 } break;
790
791 case NFA_CE_DEREGISTERED_EVT: {
792 tNFA_CE_DEREGISTERED& ce_deregistered = eventData->ce_deregistered;
793 LOG(DEBUG) << StringPrintf("%s: NFA_CE_DEREGISTERED_EVT; h=0x%X", fn,
794 ce_deregistered.handle);
795 } break;
796
797 case NFA_CE_ACTIVATED_EVT: {
798 LOG(DEBUG) << StringPrintf("%s: NFA_CE_ACTIVATED_EVT;", fn);
799 routingManager.notifyActivated(NFA_TECHNOLOGY_MASK_A);
800 } break;
801
802 case NFA_DEACTIVATED_EVT:
803 case NFA_CE_DEACTIVATED_EVT: {
804 if (event == NFA_DEACTIVATED_EVT) {
805 LOG(DEBUG) << StringPrintf("%s: NFA_DEACTIVATED_EVT", fn);
806 } else {
807 LOG(DEBUG) << StringPrintf("%s: NFA_CE_DEACTIVATED_EVT", fn);
808 }
809 routingManager.notifyDeactivated(NFA_TECHNOLOGY_MASK_A);
810 SyncEventGuard g(gDeactivatedEvent);
811 gActivated = false; // guard this variable from multi-threaded access
812 gDeactivatedEvent.notifyOne();
813 } break;
814
815 case NFA_CE_DATA_EVT: {
816 tNFA_CE_DATA& ce_data = eventData->ce_data;
817 LOG(DEBUG) << StringPrintf(
818 "%s: NFA_CE_DATA_EVT; stat=0x%X; h=0x%X; data len=%u", fn,
819 ce_data.status, ce_data.handle, ce_data.len);
820 getInstance().handleData(NFA_TECHNOLOGY_MASK_A, ce_data.p_data,
821 ce_data.len, ce_data.status);
822 } break;
823 }
824 }
825
826 /*******************************************************************************
827 **
828 ** Function: updateRoutingTable
829 **
830 ** Description: Receive execution environment-related events from stack.
831 ** event: Event code.
832 ** eventData: Event data.
833 **
834 ** Returns: None
835 **
836 *******************************************************************************/
updateRoutingTable()837 void RoutingManager::updateRoutingTable() {
838 static const char fn[] = "RoutingManager::updateRoutingTable";
839 LOG(DEBUG) << fn << ":(enter)";
840 mSeTechMask = updateEeTechRouteSetting();
841 updateDefaultRoute();
842 updateDefaultProtocolRoute();
843 LOG(DEBUG) << fn << ":(exit)";
844 }
845
846 /*******************************************************************************
847 **
848 ** Function: updateIsoDepProtocolRoute
849 **
850 ** Description: Updates the route for ISO-DEP protocol
851 **
852 ** Returns: None
853 **
854 *******************************************************************************/
updateIsoDepProtocolRoute(int route)855 void RoutingManager::updateIsoDepProtocolRoute(int route) {
856 static const char fn[] = "RoutingManager::updateIsoDepProtocolRoute";
857 LOG(DEBUG) << StringPrintf("%s: New default ISO-DEP route=0x%x", fn, route);
858 setEeInfoChangedFlag();
859 mDefaultIsoDepRoute = route;
860 }
861
862 /*******************************************************************************
863 **
864 ** Function: updateSystemCodeRoute
865 **
866 ** Description: Updates the route for System Code
867 **
868 ** Returns: None
869 **
870 *******************************************************************************/
updateSystemCodeRoute(int route)871 void RoutingManager::updateSystemCodeRoute(int route) {
872 static const char fn[] = "RoutingManager::updateSystemCodeRoute";
873 LOG(DEBUG) << StringPrintf("%s: New default SC route=0x%x", fn, route);
874 setEeInfoChangedFlag();
875 mDefaultSysCodeRoute = route;
876 updateDefaultRoute();
877 }
878
879 /*******************************************************************************
880 **
881 ** Function: updateDefaultProtocolRoute
882 **
883 ** Description: Updates the default protocol routes
884 **
885 ** Returns:
886 **
887 *******************************************************************************/
updateDefaultProtocolRoute()888 void RoutingManager::updateDefaultProtocolRoute() {
889 static const char fn[] = "RoutingManager::updateDefaultProtocolRoute";
890
891 LOG(DEBUG) << StringPrintf("%s: Default ISO-DEP route=0x%x", fn,
892 mDefaultIsoDepRoute);
893 // Default Routing for ISO-DEP
894 tNFA_PROTOCOL_MASK protoMask = NFA_PROTOCOL_MASK_ISO_DEP;
895 tNFA_STATUS nfaStat;
896 if (mDefaultIsoDepRoute != NFC_DH_ID &&
897 isTypeATypeBTechSupportedInEe(mDefaultIsoDepRoute |
898 NFA_HANDLE_GROUP_EE)) {
899 nfaStat = NFA_EeSetDefaultProtoRouting(
900 mDefaultIsoDepRoute, protoMask, mSecureNfcEnabled ? 0 : protoMask, 0,
901 mSecureNfcEnabled ? 0 : protoMask, mSecureNfcEnabled ? 0 : protoMask,
902 mSecureNfcEnabled ? 0 : protoMask);
903 } else {
904 nfaStat = NFA_EeSetDefaultProtoRouting(
905 NFC_DH_ID, protoMask, 0, 0, mSecureNfcEnabled ? 0 : protoMask, 0, 0);
906 mDefaultIsoDepRoute = NFC_DH_ID;
907 }
908 if (nfaStat != NFA_STATUS_OK)
909 LOG(ERROR) << fn << ": failed to register default ISO-DEP route";
910
911 // Default routing for T3T protocol
912 if (!mIsScbrSupported) {
913 SyncEventGuard guard(mRoutingEvent);
914 tNFA_PROTOCOL_MASK protoMask = NFA_PROTOCOL_MASK_T3T;
915 if (mDefaultEe == NFC_DH_ID) {
916 nfaStat =
917 NFA_EeSetDefaultProtoRouting(NFC_DH_ID, protoMask, 0, 0, 0, 0, 0);
918 } else {
919 nfaStat = NFA_EeSetDefaultProtoRouting(
920 mDefaultEe, protoMask, 0, 0, mSecureNfcEnabled ? 0 : protoMask,
921 mSecureNfcEnabled ? 0 : protoMask, mSecureNfcEnabled ? 0 : protoMask);
922 }
923 if (nfaStat == NFA_STATUS_OK)
924 mRoutingEvent.wait();
925 else
926 LOG(ERROR) << fn << ": Fail to set default proto routing for T3T";
927 }
928 }
929
930 /*******************************************************************************
931 **
932 ** Function: updateDefaultRoute
933 **
934 ** Description: Updating default AID and SC (T3T) routes
935 **
936 ** Returns: None
937 **
938 *******************************************************************************/
updateDefaultRoute()939 void RoutingManager::updateDefaultRoute() {
940 static const char fn[] = "RoutingManager::updateDefaultRoute";
941 int defaultAidRoute = mDefaultEe;
942
943 if (NFC_GetNCIVersion() != NCI_VERSION_2_0) return;
944
945 LOG(DEBUG) << StringPrintf("%s: Default SC route=0x%x", fn,
946 mDefaultSysCodeRoute);
947
948 // Register System Code for routing
949 SyncEventGuard guard(mRoutingEvent);
950 tNFA_STATUS nfaStat = NFA_EeAddSystemCodeRouting(
951 mDefaultSysCode, mDefaultSysCodeRoute,
952 mSecureNfcEnabled ? 0x01 : mDefaultSysCodePowerstate);
953 if (nfaStat == NFA_STATUS_NOT_SUPPORTED) {
954 mIsScbrSupported = false;
955 LOG(ERROR) << fn << ": SCBR not supported";
956 } else if (nfaStat == NFA_STATUS_OK) {
957 mIsScbrSupported = true;
958 mRoutingEvent.wait();
959 } else {
960 LOG(ERROR) << fn << ": Fail to register system code";
961 // still support SCBR routing for other NFCEEs
962 mIsScbrSupported = true;
963 }
964
965 // Check if default AID was already added or not
966 if (!mDefaultAidRouteAdded) {
967 LOG(DEBUG) << StringPrintf("%s: Default AID route=0x%x", fn,
968 defaultAidRoute);
969
970 // Register zero lengthy Aid for default Aid Routing
971 if ((defaultAidRoute != NFC_DH_ID) &&
972 (!isTypeATypeBTechSupportedInEe(defaultAidRoute |
973 NFA_HANDLE_GROUP_EE))) {
974 defaultAidRoute = NFC_DH_ID;
975 }
976
977 removeAidRouting(nullptr, 0);
978 uint8_t powerState = 0x01;
979 if (!mSecureNfcEnabled) {
980 powerState =
981 (defaultAidRoute != 0x00) ? mOffHostAidRoutingPowerState : 0x11;
982 }
983 nfaStat = NFA_EeAddAidRouting(defaultAidRoute, 0, NULL, powerState,
984 AID_ROUTE_QUAL_PREFIX);
985 if (nfaStat != NFA_STATUS_OK) {
986 LOG(ERROR) << fn << ": failed to register zero length AID";
987 } else {
988 mDefaultAidRouteAdded = true;
989 }
990 }
991 }
992
993 /*******************************************************************************
994 **
995 ** Function: updateTechnologyABFRoute
996 **
997 ** Description: Updating default A/B/F routes
998 **
999 ** Returns: bitmask of routed technologies
1000 **
1001 *******************************************************************************/
updateTechnologyABFRoute(int route,int felicaRoute)1002 tNFA_TECHNOLOGY_MASK RoutingManager::updateTechnologyABFRoute(int route,
1003 int felicaRoute) {
1004 static const char fn[] = "RoutingManager::updateTechnologyABFRoute";
1005 LOG(DEBUG) << StringPrintf("%s: New default A/B route=0x%x", fn, route);
1006 LOG(DEBUG) << StringPrintf("%s: New default F route=0x%x", fn, felicaRoute);
1007 mEeInfoChanged = true;
1008 mDefaultFelicaRoute = felicaRoute;
1009 mDefaultOffHostRoute = route;
1010 return mSeTechMask;
1011 }
1012
1013 /*******************************************************************************
1014 **
1015 ** Function: updateEeTechRouteSetting
1016 **
1017 ** Description: Update the route of listen A/B/F technologies
1018 **
1019 ** Returns: None
1020 **
1021 *******************************************************************************/
updateEeTechRouteSetting()1022 tNFA_TECHNOLOGY_MASK RoutingManager::updateEeTechRouteSetting() {
1023 static const char fn[] = "RoutingManager::updateEeTechRouteSetting";
1024 tNFA_TECHNOLOGY_MASK allSeTechMask = 0x00, hostTechMask = 0x00;
1025
1026 // Get content of mEeInfo as it can change if a NTF is received during update
1027 // of RT
1028 sEeInfoMutex.lock();
1029 tNFA_EE_DISCOVER_REQ localEeInfo;
1030 memcpy(&localEeInfo, &mEeInfo, sizeof(mEeInfo));
1031 sEeInfoMutex.unlock();
1032 LOG(DEBUG) << StringPrintf("%s: Default route A/B: 0x%x", fn,
1033 mDefaultOffHostRoute);
1034 LOG(DEBUG) << StringPrintf("%s: Default route F=0x%x", fn,
1035 mDefaultFelicaRoute);
1036
1037 LOG(DEBUG) << StringPrintf("%s: Nb NFCEE=%d", fn, mEeInfo.num_ee);
1038
1039 tNFA_STATUS nfaStat;
1040
1041 for (uint8_t i = 0; i < localEeInfo.num_ee; i++) {
1042 tNFA_HANDLE eeHandle = localEeInfo.ee_disc_info[i].ee_handle;
1043 tNFA_TECHNOLOGY_MASK seTechMask = 0;
1044
1045 LOG(DEBUG) << StringPrintf(
1046 "%s: EE[%u] Handle=0x%04x techA=0x%02x techB="
1047 "0x%02x techF=0x%02x techBprime=0x%02x",
1048 fn, i, eeHandle, localEeInfo.ee_disc_info[i].la_protocol,
1049 localEeInfo.ee_disc_info[i].lb_protocol,
1050 localEeInfo.ee_disc_info[i].lf_protocol,
1051 localEeInfo.ee_disc_info[i].lbp_protocol);
1052
1053 if ((mDefaultOffHostRoute != NFC_DH_ID) &&
1054 (eeHandle == (mDefaultOffHostRoute | NFA_HANDLE_GROUP_EE))) {
1055 if (localEeInfo.ee_disc_info[i].la_protocol != 0) {
1056 seTechMask |= NFA_TECHNOLOGY_MASK_A;
1057 }
1058 if (localEeInfo.ee_disc_info[i].lb_protocol != 0) {
1059 seTechMask |= NFA_TECHNOLOGY_MASK_B;
1060 }
1061 }
1062
1063 if ((mDefaultFelicaRoute != NFC_DH_ID) &&
1064 (eeHandle == (mDefaultFelicaRoute | NFA_HANDLE_GROUP_EE))) {
1065 if (localEeInfo.ee_disc_info[i].lf_protocol != 0) {
1066 seTechMask |= NFA_TECHNOLOGY_MASK_F;
1067 }
1068 }
1069
1070 // If OFFHOST_LISTEN_TECH_MASK exists,
1071 // filter out the unspecified technologies
1072 seTechMask &= mOffHostListenTechMask;
1073
1074 LOG(DEBUG) << StringPrintf("%s: seTechMask[%u]=0x%02x", fn, i, seTechMask);
1075 if (seTechMask != 0x00) {
1076 LOG(DEBUG) << StringPrintf(
1077 "%s: Configuring tech mask 0x%02x on EE 0x%04x", fn, seTechMask,
1078 eeHandle);
1079
1080 nfaStat = NFA_CeConfigureUiccListenTech(eeHandle, seTechMask);
1081 if (nfaStat != NFA_STATUS_OK)
1082 LOG(ERROR) << fn << ": Failed to configure UICC listen technologies.";
1083
1084 nfaStat = NFA_EeSetDefaultTechRouting(
1085 eeHandle, seTechMask, mSecureNfcEnabled ? 0 : seTechMask, 0,
1086 mSecureNfcEnabled ? 0 : seTechMask,
1087 mSecureNfcEnabled ? 0 : seTechMask,
1088 mSecureNfcEnabled ? 0 : seTechMask);
1089 if (nfaStat != NFA_STATUS_OK)
1090 LOG(ERROR) << StringPrintf(
1091 "%s: Failed to configure 0x%x technology routing", fn, eeHandle);
1092
1093 allSeTechMask |= seTechMask;
1094 }
1095 }
1096
1097 // Check if some tech should be routed to DH
1098 if (!(allSeTechMask & NFA_TECHNOLOGY_MASK_A) &&
1099 (mHostListenTechMask & NFA_TECHNOLOGY_MASK_A)) {
1100 hostTechMask |= NFA_TECHNOLOGY_MASK_A;
1101 }
1102 // Check if some tech should be routed to DH
1103 if (!(allSeTechMask & NFA_TECHNOLOGY_MASK_B) &&
1104 (mHostListenTechMask & NFA_TECHNOLOGY_MASK_B)) {
1105 hostTechMask |= NFA_TECHNOLOGY_MASK_B;
1106 }
1107 // Check if some tech should be routed to DH
1108 if (!(allSeTechMask & NFA_TECHNOLOGY_MASK_F) &&
1109 (mHostListenTechMask & NFA_TECHNOLOGY_MASK_F)) {
1110 hostTechMask |= NFA_TECHNOLOGY_MASK_F;
1111 }
1112
1113 if (hostTechMask) {
1114 nfaStat = NFA_EeSetDefaultTechRouting(NFC_DH_ID, hostTechMask, 0, 0,
1115 mSecureNfcEnabled ? 0 : hostTechMask,
1116 mSecureNfcEnabled ? 0 : hostTechMask,
1117 mSecureNfcEnabled ? 0 : hostTechMask);
1118 if (nfaStat != NFA_STATUS_OK)
1119 LOG(ERROR) << fn << ": Failed to configure DH technology routing.";
1120 }
1121
1122 return allSeTechMask;
1123 }
1124
1125 /*******************************************************************************
1126 **
1127 ** Function: nfaEeCallback
1128 **
1129 ** Description: Receive execution environment-related events from stack.
1130 ** event: Event code.
1131 ** eventData: Event data.
1132 **
1133 ** Returns: None
1134 **
1135 *******************************************************************************/
nfaEeCallback(tNFA_EE_EVT event,tNFA_EE_CBACK_DATA * eventData)1136 void RoutingManager::nfaEeCallback(tNFA_EE_EVT event,
1137 tNFA_EE_CBACK_DATA* eventData) {
1138 static const char fn[] = "RoutingManager::nfaEeCallback";
1139
1140 RoutingManager& routingManager = RoutingManager::getInstance();
1141 if (!eventData) {
1142 LOG(ERROR) << fn << ": eventData is null";
1143 return;
1144 }
1145 routingManager.mCbEventData = *eventData;
1146 switch (event) {
1147 case NFA_EE_REGISTER_EVT: {
1148 SyncEventGuard guard(routingManager.mEeRegisterEvent);
1149 LOG(DEBUG) << StringPrintf("%s: NFA_EE_REGISTER_EVT; status=%u", fn,
1150 eventData->ee_register);
1151 routingManager.mEeRegisterEvent.notifyOne();
1152 } break;
1153
1154 case NFA_EE_DEREGISTER_EVT: {
1155 LOG(DEBUG) << StringPrintf("%s: NFA_EE_DEREGISTER_EVT; status=0x%X", fn,
1156 eventData->status);
1157 routingManager.mReceivedEeInfo = false;
1158 routingManager.mDeinitializing = false;
1159 } break;
1160
1161 case NFA_EE_MODE_SET_EVT: {
1162 SyncEventGuard guard(routingManager.mEeSetModeEvent);
1163 LOG(DEBUG) << StringPrintf(
1164 "%s: NFA_EE_MODE_SET_EVT; status=0x%04X handle=0x%04X ", fn,
1165 eventData->mode_set.status, eventData->mode_set.ee_handle);
1166 routingManager.mEeSetModeEvent.notifyOne();
1167 } break;
1168
1169 case NFA_EE_SET_TECH_CFG_EVT: {
1170 LOG(DEBUG) << StringPrintf("%s: NFA_EE_SET_TECH_CFG_EVT; status=0x%X", fn,
1171 eventData->status);
1172 } break;
1173
1174 case NFA_EE_CLEAR_TECH_CFG_EVT: {
1175 LOG(DEBUG) << StringPrintf("%s: NFA_EE_CLEAR_TECH_CFG_EVT; status=0x%X",
1176 fn, eventData->status);
1177 } break;
1178
1179 case NFA_EE_SET_PROTO_CFG_EVT: {
1180 LOG(DEBUG) << StringPrintf("%s: NFA_EE_SET_PROTO_CFG_EVT; status=0x%X",
1181 fn, eventData->status);
1182 if (!routingManager.mIsScbrSupported) {
1183 SyncEventGuard guard(routingManager.mRoutingEvent);
1184 routingManager.mRoutingEvent.notifyOne();
1185 }
1186 } break;
1187
1188 case NFA_EE_CLEAR_PROTO_CFG_EVT: {
1189 LOG(DEBUG) << StringPrintf("%s: NFA_EE_CLEAR_PROTO_CFG_EVT; status=0x%X",
1190 fn, eventData->status);
1191 } break;
1192
1193 case NFA_EE_ACTION_EVT: {
1194 tNFA_EE_ACTION& action = eventData->action;
1195 if (action.trigger == NFC_EE_TRIG_SELECT) {
1196 tNFC_AID& aid = action.param.aid;
1197 LOG(DEBUG) << StringPrintf(
1198 "%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=select (0x%X)", fn,
1199 action.ee_handle, action.trigger);
1200 routingManager.notifyEeAidSelected(aid, action.ee_handle);
1201 } else if (action.trigger == NFC_EE_TRIG_APP_INIT) {
1202 tNFC_APP_INIT& app_init = action.param.app_init;
1203 LOG(DEBUG) << StringPrintf(
1204 "%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=app-init "
1205 "(0x%X); aid len=%u; data len=%u",
1206 fn, action.ee_handle, action.trigger, app_init.len_aid,
1207 app_init.len_data);
1208 } else if (action.trigger == NFC_EE_TRIG_RF_PROTOCOL) {
1209 LOG(DEBUG) << StringPrintf(
1210 "%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=rf protocol (0x%X)", fn,
1211 action.ee_handle, action.trigger);
1212 routingManager.notifyEeProtocolSelected(action.param.protocol,
1213 action.ee_handle);
1214 } else if (action.trigger == NFC_EE_TRIG_RF_TECHNOLOGY) {
1215 LOG(DEBUG) << StringPrintf(
1216 "%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=rf tech (0x%X)", fn,
1217 action.ee_handle, action.trigger);
1218 routingManager.notifyEeTechSelected(action.param.technology,
1219 action.ee_handle);
1220 } else
1221 LOG(DEBUG) << StringPrintf(
1222 "%s: NFA_EE_ACTION_EVT; h=0x%X; unknown trigger (0x%X)", fn,
1223 action.ee_handle, action.trigger);
1224 } break;
1225
1226 case NFA_EE_DISCOVER_REQ_EVT: {
1227 SyncEventGuard guard(routingManager.mEeInfoEvent);
1228 sEeInfoMutex.lock();
1229 memcpy(&routingManager.mEeInfo, &eventData->discover_req,
1230 sizeof(routingManager.mEeInfo));
1231 for (int i = 0; i < eventData->discover_req.num_ee; i++) {
1232 LOG(DEBUG) << StringPrintf(
1233 "%s: NFA_EE_DISCOVER_REQ_EVT; nfceeId=0x%X; la_proto=0x%X, "
1234 "lb_proto=0x%x, lf_proto=0x%x",
1235 fn, eventData->discover_req.ee_disc_info[i].ee_handle,
1236 eventData->discover_req.ee_disc_info[i].la_protocol,
1237 eventData->discover_req.ee_disc_info[i].lb_protocol,
1238 eventData->discover_req.ee_disc_info[i].lf_protocol);
1239 }
1240 sEeInfoMutex.unlock();
1241 if (!routingManager.mIsRFDiscoveryOptimized) {
1242 if (routingManager.mReceivedEeInfo && !routingManager.mDeinitializing) {
1243 routingManager.setEeInfoChangedFlag();
1244 routingManager.notifyEeUpdated();
1245 }
1246 }
1247 routingManager.mReceivedEeInfo = true;
1248 routingManager.mEeInfoEvent.notifyOne();
1249 } break;
1250
1251 case NFA_EE_ENABLED_EVT: {
1252 LOG(DEBUG) << StringPrintf(
1253 "%s: NFA_EE_ENABLED_EVT; status=0x%X; num ee=%u", __func__,
1254 eventData->discover_req.status, eventData->discover_req.num_ee);
1255 if (routingManager.mIsRFDiscoveryOptimized) {
1256 if (routingManager.mReceivedEeInfo && !routingManager.mDeinitializing) {
1257 routingManager.setEeInfoChangedFlag();
1258 routingManager.notifyEeUpdated();
1259 }
1260 }
1261 } break;
1262
1263 case NFA_EE_NO_CB_ERR_EVT:
1264 LOG(DEBUG) << StringPrintf("%s: NFA_EE_NO_CB_ERR_EVT status=%u", fn,
1265 eventData->status);
1266 break;
1267
1268 case NFA_EE_ADD_AID_EVT: {
1269 LOG(DEBUG) << StringPrintf("%s: NFA_EE_ADD_AID_EVT status=%u", fn,
1270 eventData->status);
1271 SyncEventGuard guard(routingManager.mAidAddRemoveEvent);
1272 routingManager.mAidRoutingConfigured =
1273 (eventData->status == NFA_STATUS_OK);
1274 routingManager.mAidAddRemoveEvent.notifyOne();
1275 } break;
1276
1277 case NFA_EE_ADD_SYSCODE_EVT: {
1278 SyncEventGuard guard(routingManager.mRoutingEvent);
1279 routingManager.mRoutingEvent.notifyOne();
1280 LOG(DEBUG) << StringPrintf("%s: NFA_EE_ADD_SYSCODE_EVT status=%u", fn,
1281 eventData->status);
1282 } break;
1283
1284 case NFA_EE_REMOVE_SYSCODE_EVT: {
1285 SyncEventGuard guard(routingManager.mRoutingEvent);
1286 routingManager.mRoutingEvent.notifyOne();
1287 LOG(DEBUG) << StringPrintf("%s: NFA_EE_REMOVE_SYSCODE_EVT status=%u", fn,
1288 eventData->status);
1289 } break;
1290
1291 case NFA_EE_REMOVE_AID_EVT: {
1292 LOG(DEBUG) << StringPrintf("%s: NFA_EE_REMOVE_AID_EVT status=%u", fn,
1293 eventData->status);
1294 SyncEventGuard guard(routingManager.mAidAddRemoveEvent);
1295 routingManager.mAidRoutingConfigured =
1296 (eventData->status == NFA_STATUS_OK);
1297 routingManager.mAidAddRemoveEvent.notifyOne();
1298 } break;
1299
1300 case NFA_EE_NEW_EE_EVT: {
1301 LOG(DEBUG) << StringPrintf("%s: NFA_EE_NEW_EE_EVT h=0x%X; status=%u", fn,
1302 eventData->new_ee.ee_handle,
1303 eventData->new_ee.ee_status);
1304 } break;
1305
1306 case NFA_EE_UPDATED_EVT: {
1307 LOG(DEBUG) << StringPrintf("%s: NFA_EE_UPDATED_EVT", fn);
1308 routingManager.mAidRoutingConfigured = false;
1309 SyncEventGuard guard(routingManager.mEeUpdateEvent);
1310 routingManager.mEeUpdateEvent.notifyOne();
1311 } break;
1312
1313 case NFA_EE_PWR_AND_LINK_CTRL_EVT: {
1314 LOG(DEBUG) << StringPrintf("%s: NFA_EE_PWR_AND_LINK_CTRL_EVT", fn);
1315 SyncEventGuard guard(routingManager.mEePwrAndLinkCtrlEvent);
1316 routingManager.mEePwrAndLinkCtrlEvent.notifyOne();
1317 } break;
1318
1319 default:
1320 LOG(DEBUG) << StringPrintf("%s: unknown event=%u ????", fn, event);
1321 break;
1322 }
1323 }
1324
1325 /*******************************************************************************
1326 **
1327 ** Function: registerT3tIdentifier
1328 **
1329 ** Description: register a t3T identifier for HCE-F purposes
1330 **
1331 ** Returns: None
1332 **
1333 *******************************************************************************/
registerT3tIdentifier(uint8_t * t3tId,uint8_t t3tIdLen)1334 int RoutingManager::registerT3tIdentifier(uint8_t* t3tId, uint8_t t3tIdLen) {
1335 static const char fn[] = "RoutingManager::registerT3tIdentifier";
1336
1337 LOG(DEBUG) << fn << ": Start to register NFC-F system on DH";
1338
1339 if (t3tIdLen != (2 + NCI_RF_F_UID_LEN + NCI_T3T_PMM_LEN)) {
1340 LOG(ERROR) << fn << ": Invalid length of T3T Identifier";
1341 return NFA_HANDLE_INVALID;
1342 }
1343
1344 mNfcFOnDhHandle = NFA_HANDLE_INVALID;
1345
1346 uint16_t systemCode;
1347 uint8_t nfcid2[NCI_RF_F_UID_LEN];
1348 uint8_t t3tPmm[NCI_T3T_PMM_LEN];
1349
1350 systemCode = (((int)t3tId[0] << 8) | ((int)t3tId[1] << 0));
1351 memcpy(nfcid2, t3tId + 2, NCI_RF_F_UID_LEN);
1352 memcpy(t3tPmm, t3tId + 10, NCI_T3T_PMM_LEN);
1353 {
1354 SyncEventGuard guard(mRoutingEvent);
1355 tNFA_STATUS nfaStat = NFA_CeRegisterFelicaSystemCodeOnDH(
1356 systemCode, nfcid2, t3tPmm, nfcFCeCallback);
1357 if (nfaStat == NFA_STATUS_OK) {
1358 mRoutingEvent.wait();
1359 } else {
1360 LOG(ERROR) << fn << ": Fail to register NFC-F system on DH";
1361 return NFA_HANDLE_INVALID;
1362 }
1363 }
1364 LOG(DEBUG) << fn << ": Succeed to register NFC-F system on DH";
1365
1366 // Register System Code for routing
1367 if (mIsScbrSupported) {
1368 SyncEventGuard guard(mRoutingEvent);
1369 tNFA_STATUS nfaStat = NFA_EeAddSystemCodeRouting(systemCode, NCI_DH_ID,
1370 SYS_CODE_PWR_STATE_HOST);
1371 if (nfaStat == NFA_STATUS_OK) {
1372 mRoutingEvent.wait();
1373 }
1374 if ((nfaStat != NFA_STATUS_OK) || (mCbEventData.status != NFA_STATUS_OK)) {
1375 LOG(ERROR) << StringPrintf("%s: Fail to register system code on DH", fn);
1376 return NFA_HANDLE_INVALID;
1377 }
1378 LOG(DEBUG) << StringPrintf("%s: Succeed to register system code on DH", fn);
1379 setEeInfoChangedFlag();
1380 // add handle and system code pair to the map
1381 mMapScbrHandle.emplace(mNfcFOnDhHandle, systemCode);
1382 } else {
1383 LOG(ERROR) << StringPrintf("%s: SCBR Not supported", fn);
1384 }
1385
1386 return mNfcFOnDhHandle;
1387 }
1388
1389 /*******************************************************************************
1390 **
1391 ** Function: deregisterT3tIdentifier
1392 **
1393 ** Description: Deregisters the T3T identifier used for HCE-F purposes
1394 **
1395 ** Returns: None
1396 **
1397 *******************************************************************************/
deregisterT3tIdentifier(int handle)1398 void RoutingManager::deregisterT3tIdentifier(int handle) {
1399 static const char fn[] = "RoutingManager::deregisterT3tIdentifier";
1400
1401 LOG(DEBUG) << StringPrintf("%s: Start to deregister NFC-F system on DH", fn);
1402 {
1403 SyncEventGuard guard(mRoutingEvent);
1404 tNFA_STATUS nfaStat = NFA_CeDeregisterFelicaSystemCodeOnDH(handle);
1405 if (nfaStat == NFA_STATUS_OK) {
1406 mRoutingEvent.wait();
1407 LOG(DEBUG) << StringPrintf(
1408 "%s: Succeeded in deregistering NFC-F system on DH", fn);
1409 } else {
1410 LOG(ERROR) << StringPrintf("%s: Fail to deregister NFC-F system on DH",
1411 fn);
1412 }
1413 }
1414 if (mIsScbrSupported) {
1415 map<int, uint16_t>::iterator it = mMapScbrHandle.find(handle);
1416 // find system code for given handle
1417 if (it != mMapScbrHandle.end()) {
1418 uint16_t systemCode = it->second;
1419 mMapScbrHandle.erase(handle);
1420 if (systemCode != 0) {
1421 SyncEventGuard guard(mRoutingEvent);
1422 tNFA_STATUS nfaStat = NFA_EeRemoveSystemCodeRouting(systemCode);
1423 if (nfaStat == NFA_STATUS_OK) {
1424 mRoutingEvent.wait();
1425 setEeInfoChangedFlag();
1426 LOG(DEBUG) << StringPrintf(
1427 "%s: Succeeded in deregistering system Code on DH", fn);
1428 } else {
1429 LOG(ERROR) << StringPrintf("%s: Fail to deregister system Code on DH",
1430 fn);
1431 }
1432 }
1433 }
1434 }
1435 }
1436
1437 /*******************************************************************************
1438 **
1439 ** Function: nfcFCeCallback
1440 **
1441 ** Description: Receive execution environment-related events from stack.
1442 ** event: Event code.
1443 ** eventData: Event data.
1444 **
1445 ** Returns: None
1446 **
1447 *******************************************************************************/
nfcFCeCallback(uint8_t event,tNFA_CONN_EVT_DATA * eventData)1448 void RoutingManager::nfcFCeCallback(uint8_t event,
1449 tNFA_CONN_EVT_DATA* eventData) {
1450 static const char fn[] = "RoutingManager::nfcFCeCallback";
1451 RoutingManager& routingManager = RoutingManager::getInstance();
1452
1453 switch (event) {
1454 case NFA_CE_REGISTERED_EVT: {
1455 LOG(DEBUG) << StringPrintf("%s: NFA_CE_REGISTERED_EVT", fn);
1456 routingManager.mNfcFOnDhHandle = eventData->ce_registered.handle;
1457 SyncEventGuard guard(routingManager.mRoutingEvent);
1458 routingManager.mRoutingEvent.notifyOne();
1459 } break;
1460 case NFA_CE_DEREGISTERED_EVT: {
1461 LOG(DEBUG) << StringPrintf("%s: NFA_CE_DEREGISTERED_EVT", fn);
1462 SyncEventGuard guard(routingManager.mRoutingEvent);
1463 routingManager.mRoutingEvent.notifyOne();
1464 } break;
1465 case NFA_CE_ACTIVATED_EVT: {
1466 LOG(DEBUG) << StringPrintf("%s: NFA_CE_ACTIVATED_EVT", fn);
1467 routingManager.notifyActivated(NFA_TECHNOLOGY_MASK_F);
1468 } break;
1469 case NFA_CE_DEACTIVATED_EVT: {
1470 LOG(DEBUG) << StringPrintf("%s: NFA_CE_DEACTIVATED_EVT", fn);
1471 routingManager.notifyDeactivated(NFA_TECHNOLOGY_MASK_F);
1472 } break;
1473 case NFA_CE_DATA_EVT: {
1474 LOG(DEBUG) << StringPrintf("%s: NFA_CE_DATA_EVT", fn);
1475 tNFA_CE_DATA& ce_data = eventData->ce_data;
1476 routingManager.handleData(NFA_TECHNOLOGY_MASK_F, ce_data.p_data,
1477 ce_data.len, ce_data.status);
1478 } break;
1479 default: {
1480 LOG(DEBUG) << StringPrintf("%s: unknown event=%u ????", fn, event);
1481 } break;
1482 }
1483 }
1484
1485 /*******************************************************************************
1486 **
1487 ** Function: setNfcSecure
1488 **
1489 ** Description: set the NFC secure status
1490 **
1491 ** Returns: true
1492 **
1493 *******************************************************************************/
setNfcSecure(bool enable)1494 bool RoutingManager::setNfcSecure(bool enable) {
1495 mSecureNfcEnabled = enable;
1496 LOG(INFO) << __func__ << ": enable= " << enable;
1497 NFA_SetNfcSecure(enable);
1498 return true;
1499 }
1500
1501 /*******************************************************************************
1502 **
1503 ** Function: eeSetPwrAndLinkCtrl
1504 **
1505 ** Description: Programs the NCI command NFCEE_POWER_AND_LINK_CTRL_CMD
1506 **
1507 ** Returns: None
1508 **
1509 *******************************************************************************/
eeSetPwrAndLinkCtrl(uint8_t config)1510 void RoutingManager::eeSetPwrAndLinkCtrl(uint8_t config) {
1511 static const char fn[] = "RoutingManager::eeSetPwrAndLinkCtrl";
1512 tNFA_STATUS status = NFA_STATUS_OK;
1513
1514 if (mOffHostRouteEse.size() > 0) {
1515 LOG(DEBUG) << StringPrintf("%s: nfceeId=0x%02X, config=0x%02X", fn,
1516 mOffHostRouteEse[0], config);
1517
1518 SyncEventGuard guard(mEePwrAndLinkCtrlEvent);
1519 status =
1520 NFA_EePowerAndLinkCtrl(
1521 ((uint8_t)mOffHostRouteEse[0] | NFA_HANDLE_GROUP_EE), config);
1522 if (status != NFA_STATUS_OK) {
1523 LOG(ERROR) << StringPrintf("%s: fail NFA_EePowerAndLinkCtrl; error=0x%X",
1524 fn, status);
1525 return;
1526 } else {
1527 mEePwrAndLinkCtrlEvent.wait();
1528 }
1529 } else {
1530 LOG(ERROR) << StringPrintf("%s: No ESE specified", fn);
1531 }
1532 }
1533
1534 /*******************************************************************************
1535 **
1536 ** Function: clearRoutingEntry
1537 **
1538 ** Description: Receive execution environment-related events from stack.
1539 ** event: Event code.
1540 ** eventData: Event data.
1541 **
1542 ** Returns: None
1543 **
1544 *******************************************************************************/
clearRoutingEntry(int clearFlags)1545 void RoutingManager::clearRoutingEntry(int clearFlags) {
1546 static const char fn[] = "RoutingManager::clearRoutingEntry";
1547
1548 LOG(DEBUG) << StringPrintf("%s: clearFlags = %x", fn, clearFlags);
1549 tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
1550 bool clear_tech = false, clear_proto = false, clear_sc = false;
1551
1552 if (clearFlags & CLEAR_AID_ENTRIES) {
1553 LOG(DEBUG) << StringPrintf("%s: clear all of aid based routing", fn);
1554 RoutingManager::getInstance().removeAidRouting((uint8_t*)NFA_REMOVE_ALL_AID,
1555 NFA_REMOVE_ALL_AID_LEN);
1556 mDefaultAidRouteAdded = false;
1557 }
1558
1559 if (clearFlags & CLEAR_PROTOCOL_ENTRIES) {
1560 clear_proto = true;
1561 }
1562
1563 if (clearFlags & CLEAR_TECHNOLOGY_ENTRIES) {
1564 clear_tech = true;
1565 }
1566
1567 if (clearFlags & CLEAR_SC_ENTRIES) {
1568 clear_sc = true;
1569 }
1570
1571 if (clearFlags > CLEAR_AID_ENTRIES) {
1572 NFA_EeClearRoutingTable(clear_tech, clear_proto, clear_sc);
1573 }
1574 }
1575
1576 /*******************************************************************************
1577 **
1578 ** Function: setEeTechRouteUpdateRequired
1579 **
1580 ** Description: Set flag EeInfoChanged so that tech route will be updated
1581 ** when applying route table.
1582 **
1583 ** Returns: None
1584 **
1585 *******************************************************************************/
setEeTechRouteUpdateRequired()1586 void RoutingManager::setEeTechRouteUpdateRequired() {
1587 static const char fn[] = "RoutingManager::setEeTechRouteUpdateRequired";
1588
1589 LOG(DEBUG) << StringPrintf("%s", fn);
1590
1591 // Setting flag for Ee info changed so that
1592 // routing table can be updated
1593 setEeInfoChangedFlag();
1594 }
1595
1596 /*******************************************************************************
1597 **
1598 ** Function: deinitialize
1599 **
1600 ** Description: Called for NFC disable
1601 **
1602 ** Returns: None
1603 **
1604 *******************************************************************************/
deinitialize()1605 void RoutingManager::deinitialize() {
1606 onNfccShutdown();
1607 NFA_EeDeregister(nfaEeCallback);
1608 }
1609
1610 /*******************************************************************************
1611 **
1612 ** Function: setEeInfoChangedFlag
1613 **
1614 ** Description: .
1615 **
1616 ** Returns: None
1617 **
1618 *******************************************************************************/
setEeInfoChangedFlag()1619 void RoutingManager::setEeInfoChangedFlag() {
1620 static const char fn[] = "RoutingManager::setEeInfoChangedFlag";
1621 LOG(DEBUG) << StringPrintf("%s", fn);
1622 sEeInfoChangedMutex.lock();
1623 mEeInfoChanged = true;
1624 sEeInfoChangedMutex.unlock();
1625 }
1626
1627 /*******************************************************************************
1628 **
1629 ** Function: registerJniFunctions
1630 **
1631 ** Description: called at object creation to register JNI function
1632 **
1633 ** Returns: None
1634 **
1635 *******************************************************************************/
registerJniFunctions(JNIEnv * e)1636 int RoutingManager::registerJniFunctions(JNIEnv* e) {
1637 static const char fn[] = "RoutingManager::registerJniFunctions";
1638 LOG(DEBUG) << StringPrintf("%s", fn);
1639 return jniRegisterNativeMethods(
1640 e, "com/android/nfc/cardemulation/RoutingOptionManager", sMethods,
1641 NELEM(sMethods));
1642 }
1643
1644 /*******************************************************************************
1645 **
1646 ** Function: com_android_nfc_cardemulation_doGetDefaultRouteDestination
1647 **
1648 ** Description: Retrieves the default NFCEE route
1649 **
1650 ** Returns: default NFCEE route
1651 **
1652 *******************************************************************************/
com_android_nfc_cardemulation_doGetDefaultRouteDestination(JNIEnv *)1653 int RoutingManager::com_android_nfc_cardemulation_doGetDefaultRouteDestination(
1654 JNIEnv*) {
1655 return getInstance().mDefaultEe;
1656 }
1657
1658 /*******************************************************************************
1659 **
1660 ** Function: com_android_nfc_cardemulation_doGetDefaultOffHostRouteDestination
1661 **
1662 ** Description: retrieves the default off host route
1663 **
1664 ** Returns: off host route
1665 **
1666 *******************************************************************************/
1667 int RoutingManager::
com_android_nfc_cardemulation_doGetDefaultOffHostRouteDestination(JNIEnv *)1668 com_android_nfc_cardemulation_doGetDefaultOffHostRouteDestination(JNIEnv*) {
1669 return getInstance().mDefaultOffHostRoute;
1670 }
1671
1672 /*******************************************************************************
1673 **
1674 ** Function: com_android_nfc_cardemulation_doGetDefaultFelicaRouteDestination
1675 **
1676 ** Description: retrieves the default Felica route
1677 **
1678 ** Returns: felica route
1679 **
1680 *******************************************************************************/
1681 int RoutingManager::
com_android_nfc_cardemulation_doGetDefaultFelicaRouteDestination(JNIEnv *)1682 com_android_nfc_cardemulation_doGetDefaultFelicaRouteDestination(JNIEnv*) {
1683 return getInstance().mDefaultFelicaRoute;
1684 }
1685
1686 /*******************************************************************************
1687 **
1688 ** Function: com_android_nfc_cardemulation_doGetEuiccMepMode
1689 **
1690 ** Description: retrieves mep mode of euicc
1691 **
1692 ** Returns: mep mode
1693 **
1694 *******************************************************************************/
1695
com_android_nfc_cardemulation_doGetEuiccMepMode(JNIEnv *)1696 int RoutingManager::com_android_nfc_cardemulation_doGetEuiccMepMode(JNIEnv*) {
1697 return getInstance().mEuiccMepMode;
1698 }
1699
1700 /*******************************************************************************
1701 **
1702 ** Function: com_android_nfc_cardemulation_doGetOffHostUiccDestination
1703 **
1704 ** Description: retrieves the default UICC NFCEE-ID
1705 **
1706 ** Returns: areay of NFCEE Id for UICC
1707 **
1708 *******************************************************************************/
1709 jbyteArray
com_android_nfc_cardemulation_doGetOffHostUiccDestination(JNIEnv * e)1710 RoutingManager::com_android_nfc_cardemulation_doGetOffHostUiccDestination(
1711 JNIEnv* e) {
1712 std::vector<uint8_t> uicc = getInstance().mOffHostRouteUicc;
1713 if (uicc.size() == 0) {
1714 return NULL;
1715 }
1716 CHECK(e);
1717 jbyteArray uiccJavaArray = e->NewByteArray(uicc.size());
1718 CHECK(uiccJavaArray);
1719 e->SetByteArrayRegion(uiccJavaArray, 0, uicc.size(), (jbyte*)&uicc[0]);
1720 return uiccJavaArray;
1721 }
1722
1723 /*******************************************************************************
1724 **
1725 ** Function: com_android_nfc_cardemulation_doGetOffHostEseDestination
1726 **
1727 ** Description: Retrieves the NFCEE id for eSE
1728 **
1729 ** Returns: array of NFCEE Ids
1730
1731 **
1732 *******************************************************************************/
1733 jbyteArray
com_android_nfc_cardemulation_doGetOffHostEseDestination(JNIEnv * e)1734 RoutingManager::com_android_nfc_cardemulation_doGetOffHostEseDestination(
1735 JNIEnv * e) {
1736 std::vector<uint8_t> ese = getInstance().mOffHostRouteEse;
1737 if (ese.size() == 0) {
1738 return NULL;
1739 }
1740 CHECK(e);
1741 jbyteArray eseJavaArray = e->NewByteArray(ese.size());
1742 CHECK(eseJavaArray);
1743 e->SetByteArrayRegion(eseJavaArray, 0, ese.size(), (jbyte*)&ese[0]);
1744 return eseJavaArray;
1745 }
1746
1747 /*******************************************************************************
1748 **
1749 ** Function: com_android_nfc_cardemulation_doGetAidMatchingMode
1750 **
1751 ** Description: Retrieves the AID matching mode
1752 **
1753 ** Returns: matching mode
1754 **
1755 *******************************************************************************/
com_android_nfc_cardemulation_doGetAidMatchingMode(JNIEnv *)1756 int RoutingManager::com_android_nfc_cardemulation_doGetAidMatchingMode(
1757 JNIEnv*) {
1758 return getInstance().mAidMatchingMode;
1759 }
1760
1761 /*******************************************************************************
1762 **
1763 ** Function: com_android_nfc_cardemulation_doGetDefaultIsoDepRouteDestination
1764 **
1765 ** Description: Retrieves the route for ISO-DEP
1766 **
1767 ** Returns: ISO-DEP route
1768
1769 **
1770 *******************************************************************************/
1771 int RoutingManager::
com_android_nfc_cardemulation_doGetDefaultIsoDepRouteDestination(JNIEnv *)1772 com_android_nfc_cardemulation_doGetDefaultIsoDepRouteDestination(JNIEnv*) {
1773 return getInstance().mDefaultIsoDepRoute;
1774 }
1775
1776 /*******************************************************************************
1777 **
1778 ** Function: com_android_nfc_cardemulation_doGetDefaultScRouteDestination
1779 **
1780 ** Description: Retrieves the default NFCEE route
1781 **
1782 ** Returns: default NFCEE route
1783 **
1784 *******************************************************************************/
com_android_nfc_cardemulation_doGetDefaultScRouteDestination(JNIEnv *)1785 int RoutingManager::com_android_nfc_cardemulation_doGetDefaultScRouteDestination(
1786 JNIEnv*) {
1787 return getInstance().mDefaultSysCodeRoute;
1788 }
1789