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 
65 static const int MAX_NUM_EE = 5;
66 // SCBR from host works only when App is in foreground
67 static const uint8_t SYS_CODE_PWR_STATE_HOST = 0x01;
68 static const uint16_t DEFAULT_SYS_CODE = 0xFEFE;
69 
70 static const uint8_t AID_ROUTE_QUAL_PREFIX = 0x10;
71 
RoutingManager()72 RoutingManager::RoutingManager()
73     : mSecureNfcEnabled(false),
74       mNativeData(NULL),
75       mAidRoutingConfigured(false) {
76   static const char fn[] = "RoutingManager::RoutingManager()";
77 
78   mDefaultOffHostRoute =
79       NfcConfig::getUnsigned(NAME_DEFAULT_OFFHOST_ROUTE, 0x00);
80 
81   if (NfcConfig::hasKey(NAME_OFFHOST_ROUTE_UICC)) {
82     mOffHostRouteUicc = NfcConfig::getBytes(NAME_OFFHOST_ROUTE_UICC);
83   }
84 
85   if (NfcConfig::hasKey(NAME_OFFHOST_ROUTE_ESE)) {
86     mOffHostRouteEse = NfcConfig::getBytes(NAME_OFFHOST_ROUTE_ESE);
87   }
88 
89   mDefaultFelicaRoute = NfcConfig::getUnsigned(NAME_DEFAULT_NFCF_ROUTE, 0x00);
90   LOG(DEBUG) << StringPrintf("%s: Active SE for Nfc-F is 0x%02X", fn,
91                              mDefaultFelicaRoute);
92 
93   mDefaultEe = NfcConfig::getUnsigned(NAME_DEFAULT_ROUTE, 0x00);
94   LOG(DEBUG) << StringPrintf("%s: default route is 0x%02X", fn, mDefaultEe);
95 
96   mAidMatchingMode =
97       NfcConfig::getUnsigned(NAME_AID_MATCHING_MODE, AID_MATCHING_EXACT_ONLY);
98 
99   mDefaultSysCodeRoute =
100       NfcConfig::getUnsigned(NAME_DEFAULT_SYS_CODE_ROUTE, 0xC0);
101 
102   mDefaultSysCodePowerstate =
103       NfcConfig::getUnsigned(NAME_DEFAULT_SYS_CODE_PWR_STATE, 0x19);
104 
105   mDefaultSysCode = DEFAULT_SYS_CODE;
106   if (NfcConfig::hasKey(NAME_DEFAULT_SYS_CODE)) {
107     std::vector<uint8_t> pSysCode = NfcConfig::getBytes(NAME_DEFAULT_SYS_CODE);
108     if (pSysCode.size() == 0x02) {
109       mDefaultSysCode = ((pSysCode[0] << 8) | ((int)pSysCode[1] << 0));
110       LOG(DEBUG) << StringPrintf("%s: DEFAULT_SYS_CODE: 0x%02X", __func__,
111                                  mDefaultSysCode);
112     }
113   }
114 
115   mOffHostAidRoutingPowerState =
116       NfcConfig::getUnsigned(NAME_OFFHOST_AID_ROUTE_PWR_STATE, 0x01);
117 
118   mDefaultIsoDepRoute = NfcConfig::getUnsigned(NAME_DEFAULT_ISODEP_ROUTE, 0x0);
119 
120   mHostListenTechMask =
121       NfcConfig::getUnsigned(NAME_HOST_LISTEN_TECH_MASK,
122                              NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_F);
123 
124   mOffHostListenTechMask = NfcConfig::getUnsigned(
125       NAME_OFFHOST_LISTEN_TECH_MASK,
126       NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B | NFA_TECHNOLOGY_MASK_F);
127 
128   memset(&mEeInfo, 0, sizeof(mEeInfo));
129   mReceivedEeInfo = false;
130   mSeTechMask = 0x00;
131   mIsScbrSupported = false;
132 
133   mNfcFOnDhHandle = NFA_HANDLE_INVALID;
134 
135   mDeinitializing = false;
136   mEeInfoChanged = false;
137 }
138 
~RoutingManager()139 RoutingManager::~RoutingManager() {}
140 
initialize(nfc_jni_native_data * native)141 bool RoutingManager::initialize(nfc_jni_native_data* native) {
142   static const char fn[] = "RoutingManager::initialize()";
143   mNativeData = native;
144   mRxDataBuffer.clear();
145 
146   {
147     SyncEventGuard guard(mEeRegisterEvent);
148     LOG(DEBUG) << fn << ": try ee register";
149     tNFA_STATUS nfaStat = NFA_EeRegister(nfaEeCallback);
150     if (nfaStat != NFA_STATUS_OK) {
151       LOG(ERROR) << StringPrintf("%s: fail ee register; error=0x%X", fn,
152                                  nfaStat);
153       return false;
154     }
155     mEeRegisterEvent.wait();
156   }
157 
158   if ((mDefaultOffHostRoute != 0) || (mDefaultFelicaRoute != 0)) {
159     // Wait for EE info if needed
160     SyncEventGuard guard(mEeInfoEvent);
161     if (!mReceivedEeInfo) {
162       LOG(INFO) << fn << "Waiting for EE info";
163       mEeInfoEvent.wait();
164     }
165   }
166   mSeTechMask = updateEeTechRouteSetting();
167 
168   // Set the host-routing Tech
169   tNFA_STATUS nfaStat = NFA_CeSetIsoDepListenTech(
170       mHostListenTechMask & (NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B));
171 
172   if (nfaStat != NFA_STATUS_OK)
173     LOG(ERROR) << StringPrintf("Failed to configure CE IsoDep technologies");
174 
175   // Register a wild-card for AIDs routed to the host
176   nfaStat = NFA_CeRegisterAidOnDH(NULL, 0, stackCallback);
177   if (nfaStat != NFA_STATUS_OK)
178     LOG(ERROR) << fn << "Failed to register wildcard AID for DH";
179 
180   updateDefaultRoute();
181   updateDefaultProtocolRoute();
182 
183   // For startup case with NFC secure enabled.
184   if (mSecureNfcEnabled) {
185     NFA_SetNfcSecure(mSecureNfcEnabled);
186   }
187 
188   return true;
189 }
190 
getInstance()191 RoutingManager& RoutingManager::getInstance() {
192   static RoutingManager manager;
193   return manager;
194 }
195 
enableRoutingToHost()196 void RoutingManager::enableRoutingToHost() {
197   static const char fn[] = "RoutingManager::enableRoutingToHost()";
198   tNFA_STATUS nfaStat;
199   SyncEventGuard guard(mRoutingEvent);
200 
201   // Default routing for T3T protocol
202   if (!mIsScbrSupported && mDefaultEe == NFC_DH_ID) {
203     nfaStat = NFA_EeSetDefaultProtoRouting(NFC_DH_ID, NFA_PROTOCOL_MASK_T3T, 0,
204                                            0, 0, 0, 0);
205     if (nfaStat == NFA_STATUS_OK)
206       mRoutingEvent.wait();
207     else
208       LOG(ERROR) << fn << "Fail to set default proto routing for T3T";
209   }
210 
211   // Default routing for IsoDep protocol
212   tNFA_PROTOCOL_MASK protoMask = NFA_PROTOCOL_MASK_ISO_DEP;
213   if (mDefaultIsoDepRoute == NFC_DH_ID) {
214     nfaStat = NFA_EeSetDefaultProtoRouting(
215         NFC_DH_ID, protoMask, 0, 0, mSecureNfcEnabled ? 0 : protoMask, 0, 0);
216     if (nfaStat == NFA_STATUS_OK)
217       mRoutingEvent.wait();
218     else
219       LOG(ERROR) << fn << "Fail to set default proto routing for IsoDep";
220   }
221 
222   // Route Nfc-A to host if we don't have a SE
223   tNFA_TECHNOLOGY_MASK techMask = NFA_TECHNOLOGY_MASK_A;
224   if ((mHostListenTechMask & NFA_TECHNOLOGY_MASK_A) &&
225       (mSeTechMask & NFA_TECHNOLOGY_MASK_A) == 0) {
226     nfaStat = NFA_EeSetDefaultTechRouting(
227         NFC_DH_ID, techMask, 0, 0, mSecureNfcEnabled ? 0 : techMask,
228         mSecureNfcEnabled ? 0 : techMask, mSecureNfcEnabled ? 0 : techMask);
229     if (nfaStat == NFA_STATUS_OK)
230       mRoutingEvent.wait();
231     else
232       LOG(ERROR) << fn << "Fail to set default tech routing for Nfc-A";
233   }
234 
235   // Route Nfc-B to host if we don't have a SE
236   techMask = NFA_TECHNOLOGY_MASK_B;
237   if ((mHostListenTechMask & NFA_TECHNOLOGY_MASK_B) &&
238       (mSeTechMask & NFA_TECHNOLOGY_MASK_B) == 0) {
239     nfaStat = NFA_EeSetDefaultTechRouting(
240         NFC_DH_ID, techMask, 0, 0, mSecureNfcEnabled ? 0 : techMask,
241         mSecureNfcEnabled ? 0 : techMask, mSecureNfcEnabled ? 0 : techMask);
242     if (nfaStat == NFA_STATUS_OK)
243       mRoutingEvent.wait();
244     else
245       LOG(ERROR) << fn << "Fail to set default tech routing for Nfc-B";
246   }
247 
248   // Route Nfc-F to host if we don't have a SE
249   techMask = NFA_TECHNOLOGY_MASK_F;
250   if ((mHostListenTechMask & NFA_TECHNOLOGY_MASK_F) &&
251       (mSeTechMask & NFA_TECHNOLOGY_MASK_F) == 0) {
252     nfaStat = NFA_EeSetDefaultTechRouting(
253         NFC_DH_ID, techMask, 0, 0, mSecureNfcEnabled ? 0 : techMask,
254         mSecureNfcEnabled ? 0 : techMask, mSecureNfcEnabled ? 0 : techMask);
255     if (nfaStat == NFA_STATUS_OK)
256       mRoutingEvent.wait();
257     else
258       LOG(ERROR) << fn << "Fail to set default tech routing for Nfc-F";
259   }
260 }
261 
disableRoutingToHost()262 void RoutingManager::disableRoutingToHost() {
263   static const char fn[] = "RoutingManager::disableRoutingToHost()";
264   tNFA_STATUS nfaStat;
265   SyncEventGuard guard(mRoutingEvent);
266 
267   // Clear default routing for IsoDep protocol
268   if (mDefaultIsoDepRoute == NFC_DH_ID) {
269     nfaStat =
270         NFA_EeClearDefaultProtoRouting(NFC_DH_ID, NFA_PROTOCOL_MASK_ISO_DEP);
271     if (nfaStat == NFA_STATUS_OK)
272       mRoutingEvent.wait();
273     else
274       LOG(ERROR) << fn << "Fail to clear default proto routing for IsoDep";
275   }
276 
277   // Clear default routing for Nfc-A technology if we don't have a SE
278   if ((mHostListenTechMask & NFA_TECHNOLOGY_MASK_A) &&
279       (mSeTechMask & NFA_TECHNOLOGY_MASK_A) == 0) {
280     nfaStat = NFA_EeClearDefaultTechRouting(NFC_DH_ID, NFA_TECHNOLOGY_MASK_A);
281     if (nfaStat == NFA_STATUS_OK)
282       mRoutingEvent.wait();
283     else
284       LOG(ERROR) << fn << "Fail to clear default tech routing for Nfc-A";
285   }
286 
287   // Clear default routing for Nfc-B technology if we don't have a SE
288   if ((mHostListenTechMask & NFA_TECHNOLOGY_MASK_B) &&
289       (mSeTechMask & NFA_TECHNOLOGY_MASK_B) == 0) {
290     nfaStat = NFA_EeClearDefaultTechRouting(NFC_DH_ID, NFA_TECHNOLOGY_MASK_B);
291     if (nfaStat == NFA_STATUS_OK)
292       mRoutingEvent.wait();
293     else
294       LOG(ERROR) << fn << "Fail to clear default tech routing for Nfc-B";
295   }
296 
297   // Clear default routing for Nfc-F technology if we don't have a SE
298   if ((mHostListenTechMask & NFA_TECHNOLOGY_MASK_F) &&
299       (mSeTechMask & NFA_TECHNOLOGY_MASK_F) == 0) {
300     nfaStat = NFA_EeClearDefaultTechRouting(NFC_DH_ID, NFA_TECHNOLOGY_MASK_F);
301     if (nfaStat == NFA_STATUS_OK)
302       mRoutingEvent.wait();
303     else
304       LOG(ERROR) << fn << "Fail to clear default tech routing for Nfc-F";
305   }
306 
307   // Clear default routing for T3T protocol
308   if (!mIsScbrSupported && mDefaultEe == NFC_DH_ID) {
309     nfaStat = NFA_EeClearDefaultProtoRouting(NFC_DH_ID, NFA_PROTOCOL_MASK_T3T);
310     if (nfaStat == NFA_STATUS_OK)
311       mRoutingEvent.wait();
312     else
313       LOG(ERROR) << fn << "Fail to clear default proto routing for T3T";
314   }
315 }
316 
317 /*******************************************************************************
318  **
319  ** Function:        isTypeATypeBTechSupportedInEe
320  **
321  ** Description:     receive eeHandle
322  **
323  ** Returns:         true  : if EE support protocol type A/B
324  **                  false : if EE doesn't protocol type A/B
325  **
326  *******************************************************************************/
isTypeATypeBTechSupportedInEe(tNFA_HANDLE eeHandle)327 bool RoutingManager::isTypeATypeBTechSupportedInEe(tNFA_HANDLE eeHandle) {
328   static const char fn[] = "RoutingManager::isTypeATypeBTechSupportedInEe";
329   bool status = false;
330   uint8_t mActualNumEe = MAX_NUM_EE;
331   tNFA_EE_INFO eeInfo[mActualNumEe];
332   memset(&eeInfo, 0, mActualNumEe * sizeof(tNFA_EE_INFO));
333   tNFA_STATUS nfaStat = NFA_EeGetInfo(&mActualNumEe, eeInfo);
334   LOG(DEBUG) << fn;
335   if (nfaStat != NFA_STATUS_OK) {
336     return status;
337   }
338   for (auto i = 0; i < mActualNumEe; i++) {
339     if (eeHandle == eeInfo[i].ee_handle) {
340       if (eeInfo[i].la_protocol || eeInfo[i].lb_protocol) {
341         status = true;
342         break;
343       }
344     }
345   }
346   return status;
347 }
348 
addAidRouting(const uint8_t * aid,uint8_t aidLen,int route,int aidInfo,int power)349 bool RoutingManager::addAidRouting(const uint8_t* aid, uint8_t aidLen,
350                                    int route, int aidInfo, int power) {
351   static const char fn[] = "RoutingManager::addAidRouting";
352   LOG(DEBUG) << fn << ": enter";
353   uint8_t powerState = 0x01;
354   if (!mSecureNfcEnabled) {
355     if (power == 0x00) {
356       powerState = (route != 0x00) ? mOffHostAidRoutingPowerState : 0x11;
357     } else {
358       powerState =
359           (route != 0x00) ? mOffHostAidRoutingPowerState & power : power;
360     }
361   }
362   SyncEventGuard guard(mAidAddRemoveEvent);
363   mAidRoutingConfigured = false;
364   tNFA_STATUS nfaStat =
365       NFA_EeAddAidRouting(route, aidLen, (uint8_t*)aid, powerState, aidInfo);
366   if (nfaStat == NFA_STATUS_OK) {
367     mAidAddRemoveEvent.wait();
368   }
369   if (mAidRoutingConfigured) {
370     LOG(DEBUG) << fn << ": routed AID";
371     return true;
372   } else {
373     LOG(ERROR) << fn << ": failed to route AID";
374     return false;
375   }
376 }
377 
removeAidRouting(const uint8_t * aid,uint8_t aidLen)378 bool RoutingManager::removeAidRouting(const uint8_t* aid, uint8_t aidLen) {
379   static const char fn[] = "RoutingManager::removeAidRouting";
380   LOG(DEBUG) << fn << ": enter";
381 
382   if (aidLen != 0) {
383     LOG(DEBUG) << StringPrintf("%s : len=%d, 0x%x 0x%x 0x%x 0x%x 0x%x", fn,
384                                aidLen, *(aid), *(aid + 1), *(aid + 2),
385                                *(aid + 3), *(aid + 4));
386   } else {
387     LOG(DEBUG) << fn << "Remove Empty aid";
388   }
389 
390   SyncEventGuard guard(mAidAddRemoveEvent);
391   mAidRoutingConfigured = false;
392   tNFA_STATUS nfaStat = NFA_EeRemoveAidRouting(aidLen, (uint8_t*)aid);
393   if (nfaStat == NFA_STATUS_OK) {
394     mAidAddRemoveEvent.wait();
395   }
396   if (mAidRoutingConfigured) {
397     LOG(DEBUG) << fn << ": removed AID";
398     return true;
399   } else {
400     LOG(WARNING) << fn << ": failed to remove AID";
401     return false;
402   }
403 }
404 
commitRouting()405 tNFA_STATUS RoutingManager::commitRouting() {
406   static const char fn[] = "RoutingManager::commitRouting";
407   tNFA_STATUS nfaStat = 0;
408   LOG(DEBUG) << fn;
409   if(mEeInfoChanged) {
410     mSeTechMask = updateEeTechRouteSetting();
411     mEeInfoChanged = false;
412   }
413   {
414     SyncEventGuard guard(mEeUpdateEvent);
415     nfaStat = NFA_EeUpdateNow();
416     if (nfaStat == NFA_STATUS_OK) {
417       mEeUpdateEvent.wait();  // wait for NFA_EE_UPDATED_EVT
418     }
419   }
420   return nfaStat;
421 }
422 
onNfccShutdown()423 void RoutingManager::onNfccShutdown() {
424   static const char fn[] = "RoutingManager:onNfccShutdown";
425   if (mDefaultOffHostRoute == 0x00 && mDefaultFelicaRoute == 0x00) return;
426 
427   tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
428   uint8_t actualNumEe = MAX_NUM_EE;
429   tNFA_EE_INFO eeInfo[MAX_NUM_EE];
430   mDeinitializing = true;
431 
432   memset(&eeInfo, 0, sizeof(eeInfo));
433   if ((nfaStat = NFA_EeGetInfo(&actualNumEe, eeInfo)) != NFA_STATUS_OK) {
434     LOG(ERROR) << StringPrintf("%s: fail get info; error=0x%X", fn, nfaStat);
435     return;
436   }
437   if (actualNumEe != 0) {
438     for (uint8_t xx = 0; xx < actualNumEe; xx++) {
439       bool bIsOffHostEEPresent =
440           (NFC_GetNCIVersion() < NCI_VERSION_2_0)
441               ? (eeInfo[xx].num_interface != 0)
442               : (eeInfo[xx].ee_interface[0] !=
443                  NCI_NFCEE_INTERFACE_HCI_ACCESS) &&
444                     (eeInfo[xx].ee_status == NFA_EE_STATUS_ACTIVE);
445       if (bIsOffHostEEPresent) {
446         LOG(DEBUG) << StringPrintf(
447             "%s: Handle: 0x%04x Change Status Active to Inactive", fn,
448             eeInfo[xx].ee_handle);
449         SyncEventGuard guard(mEeSetModeEvent);
450         if ((nfaStat = NFA_EeModeSet(eeInfo[xx].ee_handle,
451                                      NFA_EE_MD_DEACTIVATE)) == NFA_STATUS_OK) {
452           mEeSetModeEvent.wait();  // wait for NFA_EE_MODE_SET_EVT
453         } else {
454           LOG(ERROR) << fn << "Failed to set EE inactive";
455         }
456       }
457     }
458   } else {
459     LOG(DEBUG) << fn << ": No active EEs found";
460   }
461 }
462 
notifyActivated(uint8_t technology)463 void RoutingManager::notifyActivated(uint8_t technology) {
464   JNIEnv* e = NULL;
465   ScopedAttach attach(mNativeData->vm, &e);
466   if (e == NULL) {
467     LOG(ERROR) << "jni env is null";
468     return;
469   }
470 
471   e->CallVoidMethod(mNativeData->manager,
472                     android::gCachedNfcManagerNotifyHostEmuActivated,
473                     (int)technology);
474   if (e->ExceptionCheck()) {
475     e->ExceptionClear();
476     LOG(ERROR) << "fail notify";
477   }
478 }
479 
getNameOfEe(tNFA_HANDLE ee_handle,std::string & eeName)480 bool RoutingManager::getNameOfEe(tNFA_HANDLE ee_handle, std::string& eeName) {
481   if (mOffHostRouteEse.size() == 0) {
482     return false;
483   }
484   ee_handle &= ~NFA_HANDLE_GROUP_EE;
485 
486   for (uint8_t i = 0; i < mOffHostRouteEse.size(); i++) {
487     if (ee_handle == mOffHostRouteEse[i]) {
488       eeName = "eSE" + std::to_string(i + 1);
489       return true;
490     }
491   }
492   for (uint8_t i = 0; i < mOffHostRouteUicc.size(); i++) {
493     if (ee_handle == mOffHostRouteUicc[i]) {
494       eeName = "SIM" + std::to_string(i + 1);
495       return true;
496     }
497   }
498 
499   LOG(WARNING) << "Incorrect EE Id";
500   return false;
501 }
502 
notifyEeAidSelected(tNFC_AID & nfcaid,tNFA_HANDLE ee_handle)503 void RoutingManager::notifyEeAidSelected(tNFC_AID& nfcaid,
504                                          tNFA_HANDLE ee_handle) {
505   std::vector<uint8_t> aid(nfcaid.aid, nfcaid.aid + nfcaid.len_aid);
506   if (aid.empty()) {
507     return;
508   }
509 
510   JNIEnv* e = NULL;
511   ScopedAttach attach(mNativeData->vm, &e);
512   CHECK(e);
513 
514   ScopedLocalRef<jobject> aidJavaArray(e, e->NewByteArray(aid.size()));
515   CHECK(aidJavaArray.get());
516   e->SetByteArrayRegion((jbyteArray)aidJavaArray.get(), 0, aid.size(),
517                         (jbyte*)&aid[0]);
518   CHECK(!e->ExceptionCheck());
519 
520   std::string evtSrc;
521   if (!getNameOfEe(ee_handle, evtSrc)) {
522     return;
523   }
524 
525   ScopedLocalRef<jobject> srcJavaString(e, e->NewStringUTF(evtSrc.c_str()));
526   CHECK(srcJavaString.get());
527   e->CallVoidMethod(mNativeData->manager,
528                     android::gCachedNfcManagerNotifyEeAidSelected,
529                     aidJavaArray.get(), srcJavaString.get());
530 }
531 
notifyEeProtocolSelected(uint8_t protocol,tNFA_HANDLE ee_handle)532 void RoutingManager::notifyEeProtocolSelected(uint8_t protocol,
533                                               tNFA_HANDLE ee_handle) {
534   JNIEnv* e = NULL;
535   ScopedAttach attach(mNativeData->vm, &e);
536   CHECK(e);
537 
538   std::string evtSrc;
539   if (!getNameOfEe(ee_handle, evtSrc)) {
540     return;
541   }
542 
543   ScopedLocalRef<jobject> srcJavaString(e, e->NewStringUTF(evtSrc.c_str()));
544   CHECK(srcJavaString.get());
545   e->CallVoidMethod(mNativeData->manager,
546                     android::gCachedNfcManagerNotifyEeProtocolSelected,
547                     protocol, srcJavaString.get());
548 }
549 
notifyEeTechSelected(uint8_t tech,tNFA_HANDLE ee_handle)550 void RoutingManager::notifyEeTechSelected(uint8_t tech, tNFA_HANDLE ee_handle) {
551   JNIEnv* e = NULL;
552   ScopedAttach attach(mNativeData->vm, &e);
553   CHECK(e);
554 
555   std::string evtSrc;
556   if (!getNameOfEe(ee_handle, evtSrc)) {
557     return;
558   }
559 
560   ScopedLocalRef<jobject> srcJavaString(e, e->NewStringUTF(evtSrc.c_str()));
561   CHECK(srcJavaString.get());
562   e->CallVoidMethod(mNativeData->manager,
563                     android::gCachedNfcManagerNotifyEeTechSelected, tech,
564                     srcJavaString.get());
565 }
566 
notifyDeactivated(uint8_t technology)567 void RoutingManager::notifyDeactivated(uint8_t technology) {
568   mRxDataBuffer.clear();
569   JNIEnv* e = NULL;
570   ScopedAttach attach(mNativeData->vm, &e);
571   if (e == NULL) {
572     LOG(ERROR) << "jni env is null";
573     return;
574   }
575 
576   e->CallVoidMethod(mNativeData->manager,
577                     android::gCachedNfcManagerNotifyEeListenActivated,
578                     JNI_FALSE);
579   if (e->ExceptionCheck()) {
580     e->ExceptionClear();
581     LOG(ERROR) << StringPrintf("Fail to notify Ee listen active status.");
582   }
583 
584   e->CallVoidMethod(mNativeData->manager,
585                     android::gCachedNfcManagerNotifyHostEmuDeactivated,
586                     (int)technology);
587   if (e->ExceptionCheck()) {
588     e->ExceptionClear();
589     LOG(ERROR) << StringPrintf("fail notify");
590   }
591 }
592 
handleData(uint8_t technology,const uint8_t * data,uint32_t dataLen,tNFA_STATUS status)593 void RoutingManager::handleData(uint8_t technology, const uint8_t* data,
594                                 uint32_t dataLen, tNFA_STATUS status) {
595   if (status == NFC_STATUS_CONTINUE) {
596     if (dataLen > 0) {
597       mRxDataBuffer.insert(mRxDataBuffer.end(), &data[0],
598                            &data[dataLen]);  // append data; more to come
599     }
600     return;  // expect another NFA_CE_DATA_EVT to come
601   } else if (status == NFA_STATUS_OK) {
602     if (dataLen > 0) {
603       mRxDataBuffer.insert(mRxDataBuffer.end(), &data[0],
604                            &data[dataLen]);  // append data
605     }
606     // entire data packet has been received; no more NFA_CE_DATA_EVT
607   } else if (status == NFA_STATUS_FAILED) {
608     LOG(ERROR) << "RoutingManager::handleData: read data fail";
609     goto TheEnd;
610   }
611 
612   {
613     JNIEnv* e = NULL;
614     ScopedAttach attach(mNativeData->vm, &e);
615     if (e == NULL) {
616       LOG(ERROR) << "jni env is null";
617       goto TheEnd;
618     }
619 
620     ScopedLocalRef<jobject> dataJavaArray(
621         e, e->NewByteArray(mRxDataBuffer.size()));
622     if (dataJavaArray.get() == NULL) {
623       LOG(ERROR) << "fail allocate array";
624       goto TheEnd;
625     }
626 
627     e->SetByteArrayRegion((jbyteArray)dataJavaArray.get(), 0,
628                           mRxDataBuffer.size(), (jbyte*)(&mRxDataBuffer[0]));
629     if (e->ExceptionCheck()) {
630       e->ExceptionClear();
631       LOG(ERROR) << "fail fill array";
632       goto TheEnd;
633     }
634 
635     e->CallVoidMethod(mNativeData->manager,
636                       android::gCachedNfcManagerNotifyHostEmuData,
637                       (int)technology, dataJavaArray.get());
638     if (e->ExceptionCheck()) {
639       e->ExceptionClear();
640       LOG(ERROR) << "fail notify";
641     }
642   }
643 TheEnd:
644   mRxDataBuffer.clear();
645 }
646 
notifyEeUpdated()647 void RoutingManager::notifyEeUpdated() {
648   JNIEnv* e = NULL;
649   ScopedAttach attach(mNativeData->vm, &e);
650   if (e == NULL) {
651     LOG(ERROR) << "jni env is null";
652     return;
653   }
654 
655   e->CallVoidMethod(mNativeData->manager,
656                     android::gCachedNfcManagerNotifyEeUpdated);
657   if (e->ExceptionCheck()) {
658     e->ExceptionClear();
659     LOG(ERROR) << "fail notify";
660   }
661 }
662 
stackCallback(uint8_t event,tNFA_CONN_EVT_DATA * eventData)663 void RoutingManager::stackCallback(uint8_t event,
664                                    tNFA_CONN_EVT_DATA* eventData) {
665   static const char fn[] = "RoutingManager::stackCallback";
666   LOG(DEBUG) << StringPrintf("%s: event=0x%X", fn, event);
667   RoutingManager& routingManager = RoutingManager::getInstance();
668 
669   switch (event) {
670     case NFA_CE_REGISTERED_EVT: {
671       tNFA_CE_REGISTERED& ce_registered = eventData->ce_registered;
672       LOG(DEBUG) << StringPrintf(
673           "%s: NFA_CE_REGISTERED_EVT; status=0x%X; h=0x%X", fn,
674           ce_registered.status, ce_registered.handle);
675     } break;
676 
677     case NFA_CE_DEREGISTERED_EVT: {
678       tNFA_CE_DEREGISTERED& ce_deregistered = eventData->ce_deregistered;
679       LOG(DEBUG) << StringPrintf("%s: NFA_CE_DEREGISTERED_EVT; h=0x%X", fn,
680                                  ce_deregistered.handle);
681     } break;
682 
683     case NFA_CE_ACTIVATED_EVT: {
684       routingManager.notifyActivated(NFA_TECHNOLOGY_MASK_A);
685     } break;
686 
687     case NFA_DEACTIVATED_EVT:
688     case NFA_CE_DEACTIVATED_EVT: {
689       LOG(DEBUG) << StringPrintf(
690           "%s: NFA_DEACTIVATED_EVT, NFA_CE_DEACTIVATED_EVT", fn);
691       routingManager.notifyDeactivated(NFA_TECHNOLOGY_MASK_A);
692       SyncEventGuard g(gDeactivatedEvent);
693       gActivated = false;  // guard this variable from multi-threaded access
694       gDeactivatedEvent.notifyOne();
695     } break;
696 
697     case NFA_CE_DATA_EVT: {
698       tNFA_CE_DATA& ce_data = eventData->ce_data;
699       LOG(DEBUG) << StringPrintf(
700           "%s: NFA_CE_DATA_EVT; stat=0x%X; h=0x%X; data len=%u", fn,
701           ce_data.status, ce_data.handle, ce_data.len);
702       getInstance().handleData(NFA_TECHNOLOGY_MASK_A, ce_data.p_data,
703                                ce_data.len, ce_data.status);
704     } break;
705   }
706 }
707 
updateRoutingTable()708 void RoutingManager::updateRoutingTable() {
709   updateEeTechRouteSetting();
710   updateDefaultProtocolRoute();
711   updateDefaultRoute();
712 }
713 
updateIsoDepProtocolRoute(int route)714 void RoutingManager::updateIsoDepProtocolRoute(int route) {
715   static const char fn[] = "RoutingManager::updateIsoDepProtocolRoute";
716   tNFA_PROTOCOL_MASK protoMask = NFA_PROTOCOL_MASK_ISO_DEP;
717   tNFA_STATUS nfaStat;
718 
719   SyncEventGuard guard(mRoutingEvent);
720   nfaStat = NFA_EeClearDefaultProtoRouting(mDefaultIsoDepRoute, protoMask);
721   if (nfaStat == NFA_STATUS_OK)
722     mRoutingEvent.wait();
723   else
724     LOG(ERROR) << fn << "Fail to clear IsoDep route";
725 
726   mDefaultIsoDepRoute = route;
727   updateDefaultProtocolRoute();
728 }
729 
730 /*******************************************************************************
731 **
732 ** Function:        updateSystemCodeRoute
733 **
734 ** Description:     Updates the route for System Code
735 **
736 ** Returns:         None
737 **
738 *******************************************************************************/
updateSystemCodeRoute(int route)739 void RoutingManager::updateSystemCodeRoute(int route) {
740   static const char fn[] = "RoutingManager::updateSystemCodeRoute";
741   LOG(DEBUG) << StringPrintf("%s; New default SC route: 0x%x", fn,
742                              route);
743   mEeInfoChanged = true;
744   mDefaultSysCodeRoute = route;
745   updateDefaultRoute();
746 }
747 
updateDefaultProtocolRoute()748 void RoutingManager::updateDefaultProtocolRoute() {
749   static const char fn[] = "RoutingManager::updateDefaultProtocolRoute";
750 
751   // Default Routing for ISO-DEP
752   tNFA_PROTOCOL_MASK protoMask = NFA_PROTOCOL_MASK_ISO_DEP;
753   tNFA_STATUS nfaStat;
754   if (mDefaultIsoDepRoute != NFC_DH_ID &&
755       isTypeATypeBTechSupportedInEe(mDefaultIsoDepRoute |
756                                     NFA_HANDLE_GROUP_EE)) {
757     nfaStat = NFA_EeClearDefaultProtoRouting(mDefaultIsoDepRoute, protoMask);
758     nfaStat = NFA_EeSetDefaultProtoRouting(
759         mDefaultIsoDepRoute, protoMask, mSecureNfcEnabled ? 0 : protoMask, 0,
760         mSecureNfcEnabled ? 0 : protoMask, mSecureNfcEnabled ? 0 : protoMask,
761         mSecureNfcEnabled ? 0 : protoMask);
762   } else {
763     nfaStat = NFA_EeClearDefaultProtoRouting(NFC_DH_ID, protoMask);
764     nfaStat = NFA_EeSetDefaultProtoRouting(
765         NFC_DH_ID, protoMask, 0, 0, mSecureNfcEnabled ? 0 : protoMask, 0, 0);
766   }
767   if (nfaStat == NFA_STATUS_OK)
768     LOG(DEBUG) << fn << ": Succeed to register default ISO-DEP route";
769   else
770     LOG(ERROR) << fn << ": failed to register default ISO-DEP route";
771 
772   // Default routing for T3T protocol
773   if (!mIsScbrSupported) {
774     SyncEventGuard guard(mRoutingEvent);
775     tNFA_PROTOCOL_MASK protoMask = NFA_PROTOCOL_MASK_T3T;
776     if (mDefaultEe == NFC_DH_ID) {
777       nfaStat =
778           NFA_EeSetDefaultProtoRouting(NFC_DH_ID, protoMask, 0, 0, 0, 0, 0);
779     } else {
780       nfaStat = NFA_EeClearDefaultProtoRouting(mDefaultEe, protoMask);
781       nfaStat = NFA_EeSetDefaultProtoRouting(
782           mDefaultEe, protoMask, 0, 0, mSecureNfcEnabled ? 0 : protoMask,
783           mSecureNfcEnabled ? 0 : protoMask, mSecureNfcEnabled ? 0 : protoMask);
784     }
785     if (nfaStat == NFA_STATUS_OK)
786       mRoutingEvent.wait();
787     else
788       LOG(ERROR) << fn << "Fail to set default proto routing for T3T";
789   }
790 }
791 
updateDefaultRoute()792 void RoutingManager::updateDefaultRoute() {
793   static const char fn[] = "RoutingManager::updateDefaultRoute";
794   if (NFC_GetNCIVersion() != NCI_VERSION_2_0) return;
795 
796   // Register System Code for routing
797   SyncEventGuard guard(mRoutingEvent);
798   tNFA_STATUS nfaStat = NFA_EeAddSystemCodeRouting(
799       mDefaultSysCode, mDefaultSysCodeRoute,
800       mSecureNfcEnabled ? 0x01 : mDefaultSysCodePowerstate);
801   if (nfaStat == NFA_STATUS_NOT_SUPPORTED) {
802     mIsScbrSupported = false;
803     LOG(ERROR) << fn << ": SCBR not supported";
804   } else if (nfaStat == NFA_STATUS_OK) {
805     mIsScbrSupported = true;
806     mRoutingEvent.wait();
807     LOG(DEBUG) << fn << ": Succeed to register system code";
808   } else {
809     LOG(ERROR) << fn << ": Fail to register system code";
810     // still support SCBR routing for other NFCEEs
811     mIsScbrSupported = true;
812   }
813 
814   // Register zero lengthy Aid for default Aid Routing
815   if (mDefaultEe != mDefaultIsoDepRoute) {
816     if ((mDefaultEe != NFC_DH_ID) &&
817         (!isTypeATypeBTechSupportedInEe(mDefaultEe | NFA_HANDLE_GROUP_EE))) {
818       LOG(DEBUG)
819           << fn << ": mDefaultEE Doesn't support either Tech A/B. Returning...";
820       return;
821     }
822     uint8_t powerState = 0x01;
823     if (!mSecureNfcEnabled)
824       powerState = (mDefaultEe != 0x00) ? mOffHostAidRoutingPowerState : 0x11;
825     nfaStat = NFA_EeAddAidRouting(mDefaultEe, 0, NULL, powerState,
826                                   AID_ROUTE_QUAL_PREFIX);
827     if (nfaStat == NFA_STATUS_OK)
828       LOG(DEBUG) << fn << ": Succeed to register zero length AID";
829     else
830       LOG(ERROR) << fn << ": failed to register zero length AID";
831   }
832 }
833 
updateTechnologyABFRoute(int route,int felicaRoute)834 tNFA_TECHNOLOGY_MASK RoutingManager::updateTechnologyABFRoute(int route,
835                                                               int felicaRoute) {
836   static const char fn[] = "RoutingManager::updateTechnologyABFRoute";
837 
838   tNFA_STATUS nfaStat;
839 
840   SyncEventGuard guard(mRoutingEvent);
841   nfaStat = NFA_EeClearDefaultTechRouting(
842       mDefaultOffHostRoute,
843       NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B | NFA_TECHNOLOGY_MASK_F);
844   if (nfaStat == NFA_STATUS_OK)
845     mRoutingEvent.wait();
846   else
847     LOG(ERROR) << fn << "Fail to clear Tech route";
848 
849   nfaStat =
850       NFA_EeClearDefaultTechRouting(mDefaultFelicaRoute, NFA_TECHNOLOGY_MASK_F);
851   if (nfaStat == NFA_STATUS_OK)
852     mRoutingEvent.wait();
853   else
854     LOG(ERROR) << fn << "Fail to clear Default Felica route";
855 
856   mDefaultFelicaRoute = felicaRoute;
857   mDefaultOffHostRoute = route;
858   return updateEeTechRouteSetting();
859 }
860 
updateEeTechRouteSetting()861 tNFA_TECHNOLOGY_MASK RoutingManager::updateEeTechRouteSetting() {
862   static const char fn[] = "RoutingManager::updateEeTechRouteSetting";
863   tNFA_TECHNOLOGY_MASK allSeTechMask = 0x00;
864 
865   LOG(DEBUG) << fn << ": Number of EE is " << (int)mEeInfo.num_ee;
866 
867   tNFA_STATUS nfaStat;
868 
869   bool offHostRouteFound = false;
870   bool felicaRouteFound = false;
871 
872   int defaultFelicaRoute = mDefaultFelicaRoute;
873   int defaultOffHostRoute = mDefaultOffHostRoute;
874 
875   for (uint8_t i = 0; i < mEeInfo.num_ee; i++) {
876     tNFA_HANDLE eeHandle = mEeInfo.ee_disc_info[i].ee_handle;
877     tNFA_TECHNOLOGY_MASK seTechMask = 0;
878 
879     LOG(DEBUG) << StringPrintf(
880         "%s   EE[%u] Handle: 0x%04x  techA: 0x%02x  techB: "
881         "0x%02x  techF: 0x%02x  techBprime: 0x%02x",
882         fn, i, eeHandle, mEeInfo.ee_disc_info[i].la_protocol,
883         mEeInfo.ee_disc_info[i].lb_protocol,
884         mEeInfo.ee_disc_info[i].lf_protocol,
885         mEeInfo.ee_disc_info[i].lbp_protocol);
886 
887     if ((mDefaultOffHostRoute != 0) &&
888         (eeHandle == (mDefaultOffHostRoute | NFA_HANDLE_GROUP_EE))) {
889       offHostRouteFound = true;
890       if (mEeInfo.ee_disc_info[i].la_protocol != 0)
891         seTechMask |= NFA_TECHNOLOGY_MASK_A;
892       if (mEeInfo.ee_disc_info[i].lb_protocol != 0)
893         seTechMask |= NFA_TECHNOLOGY_MASK_B;
894     }
895     if ((mDefaultFelicaRoute != 0) &&
896         (eeHandle == (mDefaultFelicaRoute | NFA_HANDLE_GROUP_EE))) {
897       felicaRouteFound = true;
898       if (mEeInfo.ee_disc_info[i].lf_protocol != 0)
899         seTechMask |= NFA_TECHNOLOGY_MASK_F;
900       else
901         defaultFelicaRoute = NFC_DH_ID;
902     }
903 
904     // If OFFHOST_LISTEN_TECH_MASK exists,
905     // filter out the unspecified technologies
906     seTechMask &= mOffHostListenTechMask;
907 
908     LOG(DEBUG) << StringPrintf("%s: seTechMask[%u]=0x%02x", fn, i, seTechMask);
909     if (seTechMask != 0x00) {
910       LOG(DEBUG) << StringPrintf("Configuring tech mask 0x%02x on EE 0x%04x",
911                                  seTechMask, eeHandle);
912 
913       nfaStat = NFA_CeConfigureUiccListenTech(eeHandle, seTechMask);
914       if (nfaStat != NFA_STATUS_OK)
915         LOG(ERROR) << fn << "Failed to configure UICC listen technologies.";
916 
917       // clear previous before setting new power state
918       nfaStat = NFA_EeClearDefaultTechRouting(eeHandle, seTechMask);
919       if (nfaStat != NFA_STATUS_OK)
920         LOG(ERROR) << fn << "Failed to clear EE technology routing.";
921 
922       nfaStat = NFA_EeSetDefaultTechRouting(
923           eeHandle, seTechMask, mSecureNfcEnabled ? 0 : seTechMask, 0,
924           mSecureNfcEnabled ? 0 : seTechMask,
925           mSecureNfcEnabled ? 0 : seTechMask,
926           mSecureNfcEnabled ? 0 : seTechMask);
927       if (nfaStat != NFA_STATUS_OK)
928         LOG(ERROR) << fn << "Failed to configure UICC technology routing.";
929 
930       allSeTechMask |= seTechMask;
931     }
932   }
933 
934   if (!offHostRouteFound) {
935     defaultOffHostRoute = NFC_DH_ID;
936   }
937   if (!felicaRouteFound) {
938     defaultFelicaRoute = NFC_DH_ID;
939   }
940 
941   tNFA_TECHNOLOGY_MASK hostTechMask = 0;
942   if (defaultOffHostRoute == NFC_DH_ID || defaultFelicaRoute == NFC_DH_ID) {
943     if (defaultOffHostRoute == NFC_DH_ID) {
944       LOG(DEBUG) << StringPrintf(
945           "%s: Setting technology route to host with A,B type", fn);
946       hostTechMask |= NFA_TECHNOLOGY_MASK_A;
947       hostTechMask |= NFA_TECHNOLOGY_MASK_B;
948     }
949     if (defaultFelicaRoute == NFC_DH_ID) {
950       LOG(DEBUG) << StringPrintf(
951           "%s: Setting technology route to host with F type", fn);
952       hostTechMask |= NFA_TECHNOLOGY_MASK_F;
953     }
954     hostTechMask &= mHostListenTechMask;
955     nfaStat = NFA_EeSetDefaultTechRouting(NFC_DH_ID, hostTechMask, 0, 0,
956                                           mSecureNfcEnabled ? 0 : hostTechMask,
957                                           mSecureNfcEnabled ? 0 : hostTechMask,
958                                           mSecureNfcEnabled ? 0 : hostTechMask);
959     if (nfaStat != NFA_STATUS_OK)
960       LOG(ERROR) << fn << "Failed to configure DH technology routing.";
961     nfaStat = NFA_CeConfigureUiccListenTech(NFC_DH_ID, hostTechMask);
962     if (nfaStat != NFA_STATUS_OK)
963       LOG(ERROR) << fn << "Failed to configure DH UICC listen technologies.";
964   }
965 
966   // Clear DH technology route on NFC-A
967   if ((mHostListenTechMask & NFA_TECHNOLOGY_MASK_A) &&
968       (allSeTechMask & NFA_TECHNOLOGY_MASK_A) != 0) {
969     nfaStat = NFA_EeClearDefaultTechRouting(NFC_DH_ID, NFA_TECHNOLOGY_MASK_A);
970     if (nfaStat != NFA_STATUS_OK)
971       LOG(ERROR) << "Failed to clear DH technology routing on NFC-A.";
972   }
973 
974   // Clear DH technology route on NFC-B
975   if ((mHostListenTechMask & NFA_TECHNOLOGY_MASK_B) &&
976       (allSeTechMask & NFA_TECHNOLOGY_MASK_B) != 0) {
977     nfaStat = NFA_EeClearDefaultTechRouting(NFC_DH_ID, NFA_TECHNOLOGY_MASK_B);
978     if (nfaStat != NFA_STATUS_OK)
979       LOG(ERROR) << "Failed to clear DH technology routing on NFC-B.";
980   }
981 
982   // Clear DH technology route on NFC-F
983   if ((mHostListenTechMask & NFA_TECHNOLOGY_MASK_F) &&
984       (allSeTechMask & NFA_TECHNOLOGY_MASK_F) != 0) {
985     nfaStat = NFA_EeClearDefaultTechRouting(NFC_DH_ID, NFA_TECHNOLOGY_MASK_F);
986     if (nfaStat != NFA_STATUS_OK)
987       LOG(ERROR) << "Failed to clear DH technology routing on NFC-F.";
988   }
989   return allSeTechMask;
990 }
991 
992 /*******************************************************************************
993 **
994 ** Function:        nfaEeCallback
995 **
996 ** Description:     Receive execution environment-related events from stack.
997 **                  event: Event code.
998 **                  eventData: Event data.
999 **
1000 ** Returns:         None
1001 **
1002 *******************************************************************************/
nfaEeCallback(tNFA_EE_EVT event,tNFA_EE_CBACK_DATA * eventData)1003 void RoutingManager::nfaEeCallback(tNFA_EE_EVT event,
1004                                    tNFA_EE_CBACK_DATA* eventData) {
1005   static const char fn[] = "RoutingManager::nfaEeCallback";
1006 
1007   RoutingManager& routingManager = RoutingManager::getInstance();
1008   if (!eventData) {
1009     LOG(ERROR) << "eventData is null";
1010     return;
1011   }
1012   routingManager.mCbEventData = *eventData;
1013   switch (event) {
1014     case NFA_EE_REGISTER_EVT: {
1015       SyncEventGuard guard(routingManager.mEeRegisterEvent);
1016       LOG(DEBUG) << StringPrintf("%s: NFA_EE_REGISTER_EVT; status=%u", fn,
1017                                  eventData->ee_register);
1018       routingManager.mEeRegisterEvent.notifyOne();
1019     } break;
1020 
1021     case NFA_EE_DEREGISTER_EVT: {
1022       LOG(DEBUG) << StringPrintf("%s: NFA_EE_DEREGISTER_EVT; status=0x%X", fn,
1023                                  eventData->status);
1024       routingManager.mReceivedEeInfo = false;
1025       routingManager.mDeinitializing = false;
1026     } break;
1027 
1028     case NFA_EE_MODE_SET_EVT: {
1029       SyncEventGuard guard(routingManager.mEeSetModeEvent);
1030       LOG(DEBUG) << StringPrintf(
1031           "%s: NFA_EE_MODE_SET_EVT; status: 0x%04X  handle: 0x%04X  ", fn,
1032           eventData->mode_set.status, eventData->mode_set.ee_handle);
1033       routingManager.mEeSetModeEvent.notifyOne();
1034     } break;
1035 
1036     case NFA_EE_SET_TECH_CFG_EVT: {
1037       LOG(DEBUG) << StringPrintf("%s: NFA_EE_SET_TECH_CFG_EVT; status=0x%X", fn,
1038                                  eventData->status);
1039       SyncEventGuard guard(routingManager.mRoutingEvent);
1040       routingManager.mRoutingEvent.notifyOne();
1041     } break;
1042 
1043     case NFA_EE_CLEAR_TECH_CFG_EVT: {
1044       LOG(DEBUG) << StringPrintf("%s: NFA_EE_CLEAR_TECH_CFG_EVT; status=0x%X",
1045                                  fn, eventData->status);
1046       SyncEventGuard guard(routingManager.mRoutingEvent);
1047       routingManager.mRoutingEvent.notifyOne();
1048     } break;
1049 
1050     case NFA_EE_SET_PROTO_CFG_EVT: {
1051       LOG(DEBUG) << StringPrintf("%s: NFA_EE_SET_PROTO_CFG_EVT; status=0x%X",
1052                                  fn, eventData->status);
1053       SyncEventGuard guard(routingManager.mRoutingEvent);
1054       routingManager.mRoutingEvent.notifyOne();
1055     } break;
1056 
1057     case NFA_EE_CLEAR_PROTO_CFG_EVT: {
1058       LOG(DEBUG) << StringPrintf("%s: NFA_EE_CLEAR_PROTO_CFG_EVT; status=0x%X",
1059                                  fn, eventData->status);
1060       SyncEventGuard guard(routingManager.mRoutingEvent);
1061       routingManager.mRoutingEvent.notifyOne();
1062     } break;
1063 
1064     case NFA_EE_ACTION_EVT: {
1065       tNFA_EE_ACTION& action = eventData->action;
1066       if (action.trigger == NFC_EE_TRIG_SELECT) {
1067         tNFC_AID& aid = action.param.aid;
1068         LOG(DEBUG) << StringPrintf(
1069             "%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=select (0x%X)", fn,
1070             action.ee_handle, action.trigger);
1071         routingManager.notifyEeAidSelected(aid, action.ee_handle);
1072       } else if (action.trigger == NFC_EE_TRIG_APP_INIT) {
1073         tNFC_APP_INIT& app_init = action.param.app_init;
1074         LOG(DEBUG) << StringPrintf(
1075             "%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=app-init "
1076             "(0x%X); aid len=%u; data len=%u",
1077             fn, action.ee_handle, action.trigger, app_init.len_aid,
1078             app_init.len_data);
1079       } else if (action.trigger == NFC_EE_TRIG_RF_PROTOCOL) {
1080         LOG(DEBUG) << StringPrintf(
1081             "%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=rf protocol (0x%X)", fn,
1082             action.ee_handle, action.trigger);
1083         routingManager.notifyEeProtocolSelected(action.param.protocol,
1084                                                   action.ee_handle);
1085       } else if (action.trigger == NFC_EE_TRIG_RF_TECHNOLOGY) {
1086         LOG(DEBUG) << StringPrintf(
1087             "%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=rf tech (0x%X)", fn,
1088             action.ee_handle, action.trigger);
1089         routingManager.notifyEeTechSelected(action.param.technology,
1090                                               action.ee_handle);
1091       } else
1092         LOG(DEBUG) << StringPrintf(
1093             "%s: NFA_EE_ACTION_EVT; h=0x%X; unknown trigger (0x%X)", fn,
1094             action.ee_handle, action.trigger);
1095     } break;
1096 
1097     case NFA_EE_DISCOVER_REQ_EVT: {
1098       LOG(DEBUG) << StringPrintf(
1099           "%s: NFA_EE_DISCOVER_REQ_EVT; status=0x%X; num ee=%u", __func__,
1100           eventData->discover_req.status, eventData->discover_req.num_ee);
1101       SyncEventGuard guard(routingManager.mEeInfoEvent);
1102       memcpy(&routingManager.mEeInfo, &eventData->discover_req,
1103              sizeof(routingManager.mEeInfo));
1104       if (routingManager.mReceivedEeInfo && !routingManager.mDeinitializing) {
1105         routingManager.mEeInfoChanged = true;
1106         routingManager.notifyEeUpdated();
1107       }
1108       routingManager.mReceivedEeInfo = true;
1109       routingManager.mEeInfoEvent.notifyOne();
1110     } break;
1111 
1112     case NFA_EE_NO_CB_ERR_EVT:
1113       LOG(DEBUG) << StringPrintf("%s: NFA_EE_NO_CB_ERR_EVT  status=%u", fn,
1114                                  eventData->status);
1115       break;
1116 
1117     case NFA_EE_ADD_AID_EVT: {
1118       LOG(DEBUG) << StringPrintf("%s: NFA_EE_ADD_AID_EVT  status=%u", fn,
1119                                  eventData->status);
1120       SyncEventGuard guard(routingManager.mAidAddRemoveEvent);
1121       routingManager.mAidRoutingConfigured =
1122           (eventData->status == NFA_STATUS_OK);
1123       routingManager.mAidAddRemoveEvent.notifyOne();
1124     } break;
1125 
1126     case NFA_EE_ADD_SYSCODE_EVT: {
1127       SyncEventGuard guard(routingManager.mRoutingEvent);
1128       routingManager.mRoutingEvent.notifyOne();
1129       LOG(DEBUG) << StringPrintf("%s: NFA_EE_ADD_SYSCODE_EVT  status=%u", fn,
1130                                  eventData->status);
1131     } break;
1132 
1133     case NFA_EE_REMOVE_SYSCODE_EVT: {
1134       SyncEventGuard guard(routingManager.mRoutingEvent);
1135       routingManager.mRoutingEvent.notifyOne();
1136       LOG(DEBUG) << StringPrintf("%s: NFA_EE_REMOVE_SYSCODE_EVT  status=%u", fn,
1137                                  eventData->status);
1138     } break;
1139 
1140     case NFA_EE_REMOVE_AID_EVT: {
1141       LOG(DEBUG) << StringPrintf("%s: NFA_EE_REMOVE_AID_EVT  status=%u", fn,
1142                                  eventData->status);
1143       SyncEventGuard guard(routingManager.mAidAddRemoveEvent);
1144       routingManager.mAidRoutingConfigured =
1145           (eventData->status == NFA_STATUS_OK);
1146       routingManager.mAidAddRemoveEvent.notifyOne();
1147     } break;
1148 
1149     case NFA_EE_NEW_EE_EVT: {
1150       LOG(DEBUG) << StringPrintf("%s: NFA_EE_NEW_EE_EVT  h=0x%X; status=%u", fn,
1151                                  eventData->new_ee.ee_handle,
1152                                  eventData->new_ee.ee_status);
1153     } break;
1154 
1155     case NFA_EE_UPDATED_EVT: {
1156       LOG(DEBUG) << StringPrintf("%s: NFA_EE_UPDATED_EVT", fn);
1157       SyncEventGuard guard(routingManager.mEeUpdateEvent);
1158       routingManager.mEeUpdateEvent.notifyOne();
1159     } break;
1160 
1161     case NFA_EE_PWR_AND_LINK_CTRL_EVT: {
1162       LOG(DEBUG) << StringPrintf("%s: NFA_EE_PWR_AND_LINK_CTRL_EVT", fn);
1163       SyncEventGuard guard(routingManager.mEePwrAndLinkCtrlEvent);
1164       routingManager.mEePwrAndLinkCtrlEvent.notifyOne();
1165     } break;
1166 
1167     default:
1168       LOG(DEBUG) << StringPrintf("%s: unknown event=%u ????", fn, event);
1169       break;
1170   }
1171 }
1172 
registerT3tIdentifier(uint8_t * t3tId,uint8_t t3tIdLen)1173 int RoutingManager::registerT3tIdentifier(uint8_t* t3tId, uint8_t t3tIdLen) {
1174   static const char fn[] = "RoutingManager::registerT3tIdentifier";
1175 
1176   LOG(DEBUG) << fn << ": Start to register NFC-F system on DH";
1177 
1178   if (t3tIdLen != (2 + NCI_RF_F_UID_LEN + NCI_T3T_PMM_LEN)) {
1179     LOG(ERROR) << fn << ": Invalid length of T3T Identifier";
1180     return NFA_HANDLE_INVALID;
1181   }
1182 
1183   mNfcFOnDhHandle = NFA_HANDLE_INVALID;
1184 
1185   uint16_t systemCode;
1186   uint8_t nfcid2[NCI_RF_F_UID_LEN];
1187   uint8_t t3tPmm[NCI_T3T_PMM_LEN];
1188 
1189   systemCode = (((int)t3tId[0] << 8) | ((int)t3tId[1] << 0));
1190   memcpy(nfcid2, t3tId + 2, NCI_RF_F_UID_LEN);
1191   memcpy(t3tPmm, t3tId + 10, NCI_T3T_PMM_LEN);
1192   {
1193     SyncEventGuard guard(mRoutingEvent);
1194     tNFA_STATUS nfaStat = NFA_CeRegisterFelicaSystemCodeOnDH(
1195         systemCode, nfcid2, t3tPmm, nfcFCeCallback);
1196     if (nfaStat == NFA_STATUS_OK) {
1197       mRoutingEvent.wait();
1198     } else {
1199       LOG(ERROR) << fn << ": Fail to register NFC-F system on DH";
1200       return NFA_HANDLE_INVALID;
1201     }
1202   }
1203   LOG(DEBUG) << fn << ": Succeed to register NFC-F system on DH";
1204 
1205   // Register System Code for routing
1206   if (mIsScbrSupported) {
1207     SyncEventGuard guard(mRoutingEvent);
1208     tNFA_STATUS nfaStat = NFA_EeAddSystemCodeRouting(systemCode, NCI_DH_ID,
1209                                                      SYS_CODE_PWR_STATE_HOST);
1210     if (nfaStat == NFA_STATUS_OK) {
1211       mRoutingEvent.wait();
1212     }
1213     if ((nfaStat != NFA_STATUS_OK) || (mCbEventData.status != NFA_STATUS_OK)) {
1214       LOG(ERROR) << StringPrintf("%s: Fail to register system code on DH", fn);
1215       return NFA_HANDLE_INVALID;
1216     }
1217     LOG(DEBUG) << StringPrintf("%s: Succeed to register system code on DH", fn);
1218     // add handle and system code pair to the map
1219     mMapScbrHandle.emplace(mNfcFOnDhHandle, systemCode);
1220   } else {
1221     LOG(ERROR) << StringPrintf("%s: SCBR Not supported", fn);
1222   }
1223 
1224   return mNfcFOnDhHandle;
1225 }
1226 
deregisterT3tIdentifier(int handle)1227 void RoutingManager::deregisterT3tIdentifier(int handle) {
1228   static const char fn[] = "RoutingManager::deregisterT3tIdentifier";
1229 
1230   LOG(DEBUG) << StringPrintf("%s: Start to deregister NFC-F system on DH", fn);
1231   {
1232     SyncEventGuard guard(mRoutingEvent);
1233     tNFA_STATUS nfaStat = NFA_CeDeregisterFelicaSystemCodeOnDH(handle);
1234     if (nfaStat == NFA_STATUS_OK) {
1235       mRoutingEvent.wait();
1236       LOG(DEBUG) << StringPrintf(
1237           "%s: Succeeded in deregistering NFC-F system on DH", fn);
1238     } else {
1239       LOG(ERROR) << StringPrintf("%s: Fail to deregister NFC-F system on DH",
1240                                  fn);
1241     }
1242   }
1243   if (mIsScbrSupported) {
1244     map<int, uint16_t>::iterator it = mMapScbrHandle.find(handle);
1245     // find system code for given handle
1246     if (it != mMapScbrHandle.end()) {
1247       uint16_t systemCode = it->second;
1248       mMapScbrHandle.erase(handle);
1249       if (systemCode != 0) {
1250         SyncEventGuard guard(mRoutingEvent);
1251         tNFA_STATUS nfaStat = NFA_EeRemoveSystemCodeRouting(systemCode);
1252         if (nfaStat == NFA_STATUS_OK) {
1253           mRoutingEvent.wait();
1254           LOG(DEBUG) << StringPrintf(
1255               "%s: Succeeded in deregistering system Code on DH", fn);
1256         } else {
1257           LOG(ERROR) << StringPrintf("%s: Fail to deregister system Code on DH",
1258                                      fn);
1259         }
1260       }
1261     }
1262   }
1263 }
1264 
nfcFCeCallback(uint8_t event,tNFA_CONN_EVT_DATA * eventData)1265 void RoutingManager::nfcFCeCallback(uint8_t event,
1266                                     tNFA_CONN_EVT_DATA* eventData) {
1267   static const char fn[] = "RoutingManager::nfcFCeCallback";
1268   RoutingManager& routingManager = RoutingManager::getInstance();
1269 
1270   LOG(DEBUG) << StringPrintf("%s: 0x%x", __func__, event);
1271 
1272   switch (event) {
1273     case NFA_CE_REGISTERED_EVT: {
1274       LOG(DEBUG) << StringPrintf("%s: registered event notified", fn);
1275       routingManager.mNfcFOnDhHandle = eventData->ce_registered.handle;
1276       SyncEventGuard guard(routingManager.mRoutingEvent);
1277       routingManager.mRoutingEvent.notifyOne();
1278     } break;
1279     case NFA_CE_DEREGISTERED_EVT: {
1280       LOG(DEBUG) << StringPrintf("%s: deregistered event notified", fn);
1281       SyncEventGuard guard(routingManager.mRoutingEvent);
1282       routingManager.mRoutingEvent.notifyOne();
1283     } break;
1284     case NFA_CE_ACTIVATED_EVT: {
1285       LOG(DEBUG) << StringPrintf("%s: activated event notified", fn);
1286       routingManager.notifyActivated(NFA_TECHNOLOGY_MASK_F);
1287     } break;
1288     case NFA_CE_DEACTIVATED_EVT: {
1289       LOG(DEBUG) << StringPrintf("%s: deactivated event notified", fn);
1290       routingManager.notifyDeactivated(NFA_TECHNOLOGY_MASK_F);
1291     } break;
1292     case NFA_CE_DATA_EVT: {
1293       LOG(DEBUG) << StringPrintf("%s: data event notified", fn);
1294       tNFA_CE_DATA& ce_data = eventData->ce_data;
1295       routingManager.handleData(NFA_TECHNOLOGY_MASK_F, ce_data.p_data,
1296                                 ce_data.len, ce_data.status);
1297     } break;
1298     default: {
1299       LOG(DEBUG) << StringPrintf("%s: unknown event=%u ????", fn, event);
1300     } break;
1301   }
1302 }
1303 
1304 /*******************************************************************************
1305 **
1306 ** Function:        setNfcSecure
1307 **
1308 ** Description:     get the NFC secure status
1309 **
1310 ** Returns:         true
1311 **
1312 *******************************************************************************/
setNfcSecure(bool enable)1313 bool RoutingManager::setNfcSecure(bool enable) {
1314   mSecureNfcEnabled = enable;
1315   LOG(INFO) << "setNfcSecure NfcService " << enable;
1316   NFA_SetNfcSecure(enable);
1317   return true;
1318 }
1319 
1320 /*******************************************************************************
1321 **
1322 ** Function:        eeSetPwrAndLinkCtrl
1323 **
1324 ** Description:     Programs the NCI command NFCEE_POWER_AND_LINK_CTRL_CMD
1325 **
1326 ** Returns:         None
1327 **
1328 *******************************************************************************/
eeSetPwrAndLinkCtrl(uint8_t config)1329 void RoutingManager::eeSetPwrAndLinkCtrl(uint8_t config) {
1330   static const char fn[] = "RoutingManager::eeSetPwrAndLinkCtrl";
1331   tNFA_STATUS status = NFA_STATUS_OK;
1332 
1333   if (mOffHostRouteEse.size() > 0) {
1334     LOG(DEBUG) << StringPrintf("%s - nfceeId: 0x%02X, config: 0x%02X", fn,
1335                                mOffHostRouteEse[0], config);
1336 
1337     SyncEventGuard guard(mEePwrAndLinkCtrlEvent);
1338     status =
1339         NFA_EePowerAndLinkCtrl(
1340             ((uint8_t)mOffHostRouteEse[0] | NFA_HANDLE_GROUP_EE), config);
1341     if (status != NFA_STATUS_OK) {
1342       LOG(ERROR) << StringPrintf("%s: fail NFA_EePowerAndLinkCtrl; error=0x%X",
1343                                  __FUNCTION__, status);
1344       return;
1345     } else {
1346       mEePwrAndLinkCtrlEvent.wait();
1347     }
1348   } else {
1349     LOG(ERROR) << StringPrintf("%s: No ESE specified", __FUNCTION__);
1350   }
1351 }
1352 
clearRoutingEntry(int clearFlags)1353 void RoutingManager::clearRoutingEntry(int clearFlags) {
1354   static const char fn[] = "RoutingManager::clearRoutingEntry";
1355 
1356   LOG(DEBUG) << StringPrintf("%s: Enter . Clear flags = %d", fn, clearFlags);
1357   tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
1358 
1359   if (clearFlags & CLEAR_AID_ENTRIES) {
1360     LOG(DEBUG) << StringPrintf("clear all of aid based routing");
1361     uint8_t clearAID[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
1362     uint8_t aidLen = 0x08;
1363     RoutingManager::getInstance().removeAidRouting(clearAID, aidLen);
1364   }
1365 
1366   if (clearFlags & CLEAR_PROTOCOL_ENTRIES) {
1367     for (uint8_t i = 0; i < mEeInfo.num_ee; i++) {
1368       tNFA_HANDLE eeHandle = mEeInfo.ee_disc_info[i].ee_handle;
1369       {
1370         SyncEventGuard guard(mRoutingEvent);
1371         nfaStat =
1372             NFA_EeClearDefaultProtoRouting(eeHandle, NFA_PROTOCOL_MASK_ISO_DEP);
1373         if (nfaStat == NFA_STATUS_OK) {
1374           mRoutingEvent.wait();
1375         }
1376       }
1377     }
1378 
1379     {
1380       SyncEventGuard guard(mRoutingEvent);
1381       nfaStat =
1382           NFA_EeClearDefaultProtoRouting(NFC_DH_ID, NFA_PROTOCOL_MASK_ISO_DEP);
1383       if (nfaStat == NFA_STATUS_OK) {
1384         mRoutingEvent.wait();
1385       }
1386     }
1387   }
1388 
1389   if (clearFlags & CLEAR_TECHNOLOGY_ENTRIES) {
1390     for (uint8_t i = 0; i < mEeInfo.num_ee; i++) {
1391       tNFA_HANDLE eeHandle = mEeInfo.ee_disc_info[i].ee_handle;
1392       {
1393         SyncEventGuard guard(mRoutingEvent);
1394         nfaStat = NFA_EeClearDefaultTechRouting(
1395             eeHandle, (NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B |
1396                        NFA_TECHNOLOGY_MASK_F));
1397         if (nfaStat == NFA_STATUS_OK) {
1398           mRoutingEvent.wait();
1399         }
1400       }
1401     }
1402 
1403     {
1404       SyncEventGuard guard(mRoutingEvent);
1405       nfaStat = NFA_EeClearDefaultTechRouting(
1406           NFC_DH_ID, (NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B |
1407                       NFA_TECHNOLOGY_MASK_F));
1408       if (nfaStat == NFA_STATUS_OK) {
1409         mRoutingEvent.wait();
1410       }
1411     }
1412   }
1413 }
1414 
1415 /*******************************************************************************
1416 **
1417 ** Function:        setEeTechRouteUpdateRequired
1418 **
1419 ** Description:     Set flag EeInfoChanged so that tech route will be updated
1420 **                  when applying route table.
1421 **
1422 ** Returns:         None
1423 **
1424 *******************************************************************************/
setEeTechRouteUpdateRequired()1425 void RoutingManager::setEeTechRouteUpdateRequired() {
1426   static const char fn[] = "RoutingManager::setEeTechRouteUpdateRequired";
1427 
1428   LOG(DEBUG) << StringPrintf("%s", fn);
1429 
1430   // Setting flag for Ee info changed so that
1431   // routing table can be updated
1432   mEeInfoChanged = true;
1433 }
1434 
deinitialize()1435 void RoutingManager::deinitialize() {
1436   onNfccShutdown();
1437   NFA_EeDeregister(nfaEeCallback);
1438 }
1439 
registerJniFunctions(JNIEnv * e)1440 int RoutingManager::registerJniFunctions(JNIEnv* e) {
1441   static const char fn[] = "RoutingManager::registerJniFunctions";
1442   LOG(DEBUG) << StringPrintf("%s", fn);
1443   return jniRegisterNativeMethods(
1444       e, "com/android/nfc/cardemulation/RoutingOptionManager", sMethods,
1445       NELEM(sMethods));
1446 }
1447 
com_android_nfc_cardemulation_doGetDefaultRouteDestination(JNIEnv *)1448 int RoutingManager::com_android_nfc_cardemulation_doGetDefaultRouteDestination(
1449     JNIEnv*) {
1450   return getInstance().mDefaultEe;
1451 }
1452 
1453 int RoutingManager::
com_android_nfc_cardemulation_doGetDefaultOffHostRouteDestination(JNIEnv *)1454     com_android_nfc_cardemulation_doGetDefaultOffHostRouteDestination(JNIEnv*) {
1455   return getInstance().mDefaultOffHostRoute;
1456 }
1457 
1458 int RoutingManager::
com_android_nfc_cardemulation_doGetDefaultFelicaRouteDestination(JNIEnv *)1459     com_android_nfc_cardemulation_doGetDefaultFelicaRouteDestination(JNIEnv*) {
1460   return getInstance().mDefaultFelicaRoute;
1461 }
1462 
1463 jbyteArray
com_android_nfc_cardemulation_doGetOffHostUiccDestination(JNIEnv * e)1464 RoutingManager::com_android_nfc_cardemulation_doGetOffHostUiccDestination(
1465     JNIEnv* e) {
1466   std::vector<uint8_t> uicc = getInstance().mOffHostRouteUicc;
1467   if (uicc.size() == 0) {
1468     return NULL;
1469   }
1470   CHECK(e);
1471   jbyteArray uiccJavaArray = e->NewByteArray(uicc.size());
1472   CHECK(uiccJavaArray);
1473   e->SetByteArrayRegion(uiccJavaArray, 0, uicc.size(), (jbyte*)&uicc[0]);
1474   return uiccJavaArray;
1475 }
1476 
1477 jbyteArray
com_android_nfc_cardemulation_doGetOffHostEseDestination(JNIEnv * e)1478 RoutingManager::com_android_nfc_cardemulation_doGetOffHostEseDestination(
1479     JNIEnv* e) {
1480   std::vector<uint8_t> ese = getInstance().mOffHostRouteEse;
1481   if (ese.size() == 0) {
1482     return NULL;
1483   }
1484   CHECK(e);
1485   jbyteArray eseJavaArray = e->NewByteArray(ese.size());
1486   CHECK(eseJavaArray);
1487   e->SetByteArrayRegion(eseJavaArray, 0, ese.size(), (jbyte*)&ese[0]);
1488   return eseJavaArray;
1489 }
1490 
com_android_nfc_cardemulation_doGetAidMatchingMode(JNIEnv *)1491 int RoutingManager::com_android_nfc_cardemulation_doGetAidMatchingMode(
1492     JNIEnv*) {
1493   return getInstance().mAidMatchingMode;
1494 }
1495 
1496 int RoutingManager::
com_android_nfc_cardemulation_doGetDefaultIsoDepRouteDestination(JNIEnv *)1497     com_android_nfc_cardemulation_doGetDefaultIsoDepRouteDestination(JNIEnv*) {
1498   return getInstance().mDefaultIsoDepRoute;
1499 }
1500 
1501 /*******************************************************************************
1502 **
1503 ** Function:        com_android_nfc_cardemulation_doGetDefaultScRouteDestination
1504 **
1505 ** Description:     Retrieves the default NFCEE route
1506 **
1507 ** Returns:         default NFCEE route
1508 **
1509 *******************************************************************************/
com_android_nfc_cardemulation_doGetDefaultScRouteDestination(JNIEnv *)1510 int RoutingManager::com_android_nfc_cardemulation_doGetDefaultScRouteDestination(
1511     JNIEnv*) {
1512   return getInstance().mDefaultSysCodeRoute;
1513 }
1514