| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * Communicate with a peer using NFC-DEP, LLCP, SNEP. |
| */ |
| #include "PeerToPeer.h" |
| |
| #include <android-base/stringprintf.h> |
| #include <base/logging.h> |
| #include <nativehelper/ScopedLocalRef.h> |
| |
| #include "JavaClassConstants.h" |
| #include "NfcJniUtil.h" |
| #include "llcp_defs.h" |
| #include "nfc_config.h" |
| |
| using android::base::StringPrintf; |
| |
| /* Some older PN544-based solutions would only send the first SYMM back |
| * (as an initiator) after the full LTO (750ms). But our connect timer |
| * starts immediately, and hence we may timeout if the timer is set to |
| * 1000 ms. Worse, this causes us to immediately connect to the NPP |
| * socket, causing concurrency issues in that stack. Increase the default |
| * timeout to 2000 ms, giving us enough time to complete the first connect. |
| */ |
| #define LLCP_DATA_LINK_TIMEOUT 2000 |
| |
| using namespace android; |
| |
| namespace android { |
| extern void nativeNfcTag_registerNdefTypeHandler(); |
| extern void nativeNfcTag_deregisterNdefTypeHandler(); |
| extern void startRfDiscovery(bool isStart); |
| extern bool isDiscoveryStarted(); |
| } // namespace android |
| |
| PeerToPeer PeerToPeer::sP2p; |
| const std::string P2pServer::sSnepServiceName("urn:nfc:sn:snep"); |
| |
| extern bool nfc_debug_enabled; |
| |
| /******************************************************************************* |
| ** |
| ** Function: PeerToPeer |
| ** |
| ** Description: Initialize member variables. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| PeerToPeer::PeerToPeer() |
| : mRemoteWKS(0), |
| mIsP2pListening(false), |
| mP2pListenTechMask(NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_F | |
| NFA_TECHNOLOGY_MASK_A_ACTIVE | |
| NFA_TECHNOLOGY_MASK_F_ACTIVE), |
| mNextJniHandle(1) { |
| memset(mServers, 0, sizeof(mServers)); |
| memset(mClients, 0, sizeof(mClients)); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: ~PeerToPeer |
| ** |
| ** Description: Free all resources. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| PeerToPeer::~PeerToPeer() {} |
| |
| /******************************************************************************* |
| ** |
| ** Function: getInstance |
| ** |
| ** Description: Get the singleton PeerToPeer object. |
| ** |
| ** Returns: Singleton PeerToPeer object. |
| ** |
| *******************************************************************************/ |
| PeerToPeer& PeerToPeer::getInstance() { return sP2p; } |
| |
| /******************************************************************************* |
| ** |
| ** Function: initialize |
| ** |
| ** Description: Initialize member variables. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::initialize() { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("PeerToPeer::initialize"); |
| |
| if (NfcConfig::hasKey(NAME_P2P_LISTEN_TECH_MASK)) |
| mP2pListenTechMask = NfcConfig::getUnsigned(NAME_P2P_LISTEN_TECH_MASK); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: findServerLocked |
| ** |
| ** Description: Find a PeerToPeer object by connection handle. |
| ** Assumes mMutex is already held |
| ** nfaP2pServerHandle: Connectin handle. |
| ** |
| ** Returns: PeerToPeer object. |
| ** |
| *******************************************************************************/ |
| sp<P2pServer> PeerToPeer::findServerLocked(tNFA_HANDLE nfaP2pServerHandle) { |
| for (int i = 0; i < sMax; i++) { |
| if ((mServers[i] != NULL) && |
| (mServers[i]->mNfaP2pServerHandle == nfaP2pServerHandle)) { |
| return (mServers[i]); |
| } |
| } |
| |
| // If here, not found |
| return NULL; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: findServerLocked |
| ** |
| ** Description: Find a PeerToPeer object by connection handle. |
| ** Assumes mMutex is already held |
| ** serviceName: service name. |
| ** |
| ** Returns: PeerToPeer object. |
| ** |
| *******************************************************************************/ |
| sp<P2pServer> PeerToPeer::findServerLocked(tJNI_HANDLE jniHandle) { |
| for (int i = 0; i < sMax; i++) { |
| if ((mServers[i] != NULL) && (mServers[i]->mJniHandle == jniHandle)) { |
| return (mServers[i]); |
| } |
| } |
| |
| // If here, not found |
| return NULL; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: findServerLocked |
| ** |
| ** Description: Find a PeerToPeer object by service name |
| ** Assumes mMutex is already heldf |
| ** serviceName: service name. |
| ** |
| ** Returns: PeerToPeer object. |
| ** |
| *******************************************************************************/ |
| sp<P2pServer> PeerToPeer::findServerLocked(const char* serviceName) { |
| for (int i = 0; i < sMax; i++) { |
| if ((mServers[i] != NULL) && |
| (mServers[i]->mServiceName.compare(serviceName) == 0)) |
| return (mServers[i]); |
| } |
| |
| // If here, not found |
| return NULL; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: registerServer |
| ** |
| ** Description: Let a server start listening for peer's connection request. |
| ** jniHandle: Connection handle. |
| ** serviceName: Server's service name. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| bool PeerToPeer::registerServer(tJNI_HANDLE jniHandle, |
| const char* serviceName) { |
| static const char fn[] = "PeerToPeer::registerServer"; |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: enter; service name: %s JNI handle: %u", fn, |
| serviceName, jniHandle); |
| sp<P2pServer> pSrv = NULL; |
| |
| mMutex.lock(); |
| // Check if already registered |
| if ((pSrv = findServerLocked(serviceName)) != NULL) { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: service name=%s already registered, handle: 0x%04x", fn, |
| serviceName, pSrv->mNfaP2pServerHandle); |
| |
| // Update JNI handle |
| pSrv->mJniHandle = jniHandle; |
| mMutex.unlock(); |
| return (true); |
| } |
| |
| for (int ii = 0; ii < sMax; ii++) { |
| if (mServers[ii] == NULL) { |
| pSrv = mServers[ii] = new P2pServer(jniHandle, serviceName); |
| |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: added new p2p server index: %d handle: %u name: %s", fn, ii, |
| jniHandle, serviceName); |
| break; |
| } |
| } |
| mMutex.unlock(); |
| |
| if (pSrv == NULL) { |
| LOG(ERROR) << StringPrintf("%s: service name=%s no free entry", fn, |
| serviceName); |
| return (false); |
| } |
| |
| if (pSrv->registerWithStack()) { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: got new p2p server h=0x%X", fn, pSrv->mNfaP2pServerHandle); |
| return (true); |
| } else { |
| LOG(ERROR) << StringPrintf("%s: invalid server handle", fn); |
| removeServer(jniHandle); |
| return (false); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: removeServer |
| ** |
| ** Description: Free resources related to a server. |
| ** jniHandle: Connection handle. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::removeServer(tJNI_HANDLE jniHandle) { |
| static const char fn[] = "PeerToPeer::removeServer"; |
| |
| AutoMutex mutex(mMutex); |
| |
| for (int i = 0; i < sMax; i++) { |
| if ((mServers[i] != NULL) && (mServers[i]->mJniHandle == jniHandle)) { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: server jni_handle: %u; nfa_handle: 0x%04x; name: %s; index=%d", |
| fn, jniHandle, mServers[i]->mNfaP2pServerHandle, |
| mServers[i]->mServiceName.c_str(), i); |
| |
| mServers[i] = NULL; |
| return; |
| } |
| } |
| LOG(ERROR) << StringPrintf("%s: unknown server jni handle: %u", fn, |
| jniHandle); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: llcpActivatedHandler |
| ** |
| ** Description: Receive LLLCP-activated event from stack. |
| ** nat: JVM-related data. |
| ** activated: Event data. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::llcpActivatedHandler(nfc_jni_native_data* nat, |
| tNFA_LLCP_ACTIVATED& activated) { |
| static const char fn[] = "PeerToPeer::llcpActivatedHandler"; |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", fn); |
| |
| // no longer need to receive NDEF message from a tag |
| android::nativeNfcTag_deregisterNdefTypeHandler(); |
| |
| mRemoteWKS = activated.remote_wks; |
| |
| JNIEnv* e = NULL; |
| ScopedAttach attach(nat->vm, &e); |
| if (e == NULL) { |
| LOG(ERROR) << StringPrintf("%s: jni env is null", fn); |
| return; |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: get object class", fn); |
| ScopedLocalRef<jclass> tag_cls(e, e->GetObjectClass(nat->cached_P2pDevice)); |
| if (e->ExceptionCheck()) { |
| e->ExceptionClear(); |
| LOG(ERROR) << StringPrintf("%s: fail get p2p device", fn); |
| return; |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: instantiate", fn); |
| /* New target instance */ |
| jmethodID ctor = e->GetMethodID(tag_cls.get(), "<init>", "()V"); |
| ScopedLocalRef<jobject> tag(e, e->NewObject(tag_cls.get(), ctor)); |
| |
| /* Set P2P Target mode */ |
| jfieldID f = e->GetFieldID(tag_cls.get(), "mMode", "I"); |
| |
| if (activated.is_initiator == TRUE) { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: p2p initiator", fn); |
| e->SetIntField(tag.get(), f, (jint)MODE_P2P_INITIATOR); |
| } else { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: p2p target", fn); |
| e->SetIntField(tag.get(), f, (jint)MODE_P2P_TARGET); |
| } |
| /* Set LLCP version */ |
| f = e->GetFieldID(tag_cls.get(), "mLlcpVersion", "B"); |
| e->SetByteField(tag.get(), f, (jbyte)activated.remote_version); |
| |
| /* Set tag handle */ |
| f = e->GetFieldID(tag_cls.get(), "mHandle", "I"); |
| e->SetIntField(tag.get(), f, |
| (jint)0x1234); // ?? This handle is not used for anything |
| |
| if (nat->tag != NULL) { |
| e->DeleteGlobalRef(nat->tag); |
| } |
| nat->tag = e->NewGlobalRef(tag.get()); |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: notify nfc service", fn); |
| |
| /* Notify manager that new a P2P device was found */ |
| e->CallVoidMethod(nat->manager, |
| android::gCachedNfcManagerNotifyLlcpLinkActivation, |
| tag.get()); |
| if (e->ExceptionCheck()) { |
| e->ExceptionClear(); |
| LOG(ERROR) << StringPrintf("%s: fail notify", fn); |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", fn); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: llcpDeactivatedHandler |
| ** |
| ** Description: Receive LLLCP-deactivated event from stack. |
| ** nat: JVM-related data. |
| ** deactivated: Event data. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::llcpDeactivatedHandler( |
| nfc_jni_native_data* nat, tNFA_LLCP_DEACTIVATED& /*deactivated*/) { |
| static const char fn[] = "PeerToPeer::llcpDeactivatedHandler"; |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", fn); |
| |
| JNIEnv* e = NULL; |
| ScopedAttach attach(nat->vm, &e); |
| if (e == NULL) { |
| LOG(ERROR) << StringPrintf("%s: jni env is null", fn); |
| return; |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: notify nfc service", fn); |
| /* Notify manager that the LLCP is lost or deactivated */ |
| e->CallVoidMethod(nat->manager, |
| android::gCachedNfcManagerNotifyLlcpLinkDeactivated, |
| nat->tag); |
| if (e->ExceptionCheck()) { |
| e->ExceptionClear(); |
| LOG(ERROR) << StringPrintf("%s: fail notify", fn); |
| } |
| |
| // let the tag-reading code handle NDEF data event |
| android::nativeNfcTag_registerNdefTypeHandler(); |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", fn); |
| } |
| |
| void PeerToPeer::llcpFirstPacketHandler(nfc_jni_native_data* nat) { |
| static const char fn[] = "PeerToPeer::llcpFirstPacketHandler"; |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", fn); |
| |
| JNIEnv* e = NULL; |
| ScopedAttach attach(nat->vm, &e); |
| if (e == NULL) { |
| LOG(ERROR) << StringPrintf("%s: jni env is null", fn); |
| return; |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: notify nfc service", fn); |
| /* Notify manager that the LLCP is lost or deactivated */ |
| e->CallVoidMethod(nat->manager, |
| android::gCachedNfcManagerNotifyLlcpFirstPacketReceived, |
| nat->tag); |
| if (e->ExceptionCheck()) { |
| e->ExceptionClear(); |
| LOG(ERROR) << StringPrintf("%s: fail notify", fn); |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", fn); |
| } |
| /******************************************************************************* |
| ** |
| ** Function: accept |
| ** |
| ** Description: Accept a peer's request to connect. |
| ** serverJniHandle: Server's handle. |
| ** connJniHandle: Connection handle. |
| ** maxInfoUnit: Maximum information unit. |
| ** recvWindow: Receive window size. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| bool PeerToPeer::accept(tJNI_HANDLE serverJniHandle, tJNI_HANDLE connJniHandle, |
| int maxInfoUnit, int recvWindow) { |
| static const char fn[] = "PeerToPeer::accept"; |
| sp<P2pServer> pSrv = NULL; |
| |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: enter; server jni handle: %u; conn jni handle: %u; maxInfoUnit: %d; " |
| "recvWindow: %d", |
| fn, serverJniHandle, connJniHandle, maxInfoUnit, recvWindow); |
| |
| mMutex.lock(); |
| if ((pSrv = findServerLocked(serverJniHandle)) == NULL) { |
| LOG(ERROR) << StringPrintf("%s: unknown server jni handle: %u", fn, |
| serverJniHandle); |
| mMutex.unlock(); |
| return (false); |
| } |
| mMutex.unlock(); |
| |
| return pSrv->accept(serverJniHandle, connJniHandle, maxInfoUnit, recvWindow); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: deregisterServer |
| ** |
| ** Description: Stop a P2pServer from listening for peer. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| bool PeerToPeer::deregisterServer(tJNI_HANDLE jniHandle) { |
| static const char fn[] = "PeerToPeer::deregisterServer"; |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: enter; JNI handle: %u", fn, jniHandle); |
| tNFA_STATUS nfaStat = NFA_STATUS_FAILED; |
| sp<P2pServer> pSrv = NULL; |
| bool isPollingTempStopped = false; |
| |
| mMutex.lock(); |
| if ((pSrv = findServerLocked(jniHandle)) == NULL) { |
| LOG(ERROR) << StringPrintf("%s: unknown service handle: %u", fn, jniHandle); |
| mMutex.unlock(); |
| return (false); |
| } |
| mMutex.unlock(); |
| if (isDiscoveryStarted()) { |
| isPollingTempStopped = true; |
| startRfDiscovery(false); |
| } |
| |
| { |
| // Server does not call NFA_P2pDisconnect(), so unblock the accept() |
| SyncEventGuard guard(pSrv->mConnRequestEvent); |
| pSrv->mConnRequestEvent.notifyOne(); |
| } |
| |
| nfaStat = NFA_P2pDeregister(pSrv->mNfaP2pServerHandle); |
| if (nfaStat != NFA_STATUS_OK) { |
| LOG(ERROR) << StringPrintf("%s: deregister error=0x%X", fn, nfaStat); |
| } |
| |
| removeServer(jniHandle); |
| |
| if (isPollingTempStopped) { |
| startRfDiscovery(true); |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", fn); |
| return true; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: createClient |
| ** |
| ** Description: Create a P2pClient object for a new out-bound connection. |
| ** jniHandle: Connection handle. |
| ** miu: Maximum information unit. |
| ** rw: Receive window size. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| bool PeerToPeer::createClient(tJNI_HANDLE jniHandle, uint16_t miu, uint8_t rw) { |
| static const char fn[] = "PeerToPeer::createClient"; |
| int i = 0; |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: enter: jni h: %u miu: %u rw: %u", fn, jniHandle, miu, rw); |
| |
| mMutex.lock(); |
| sp<P2pClient> client = NULL; |
| for (i = 0; i < sMax; i++) { |
| if (mClients[i] == NULL) { |
| mClients[i] = client = new P2pClient(); |
| |
| mClients[i]->mClientConn->mJniHandle = jniHandle; |
| mClients[i]->mClientConn->mMaxInfoUnit = miu; |
| mClients[i]->mClientConn->mRecvWindow = rw; |
| break; |
| } |
| } |
| mMutex.unlock(); |
| |
| if (client == NULL) { |
| LOG(ERROR) << StringPrintf("%s: fail", fn); |
| return (false); |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: pClient: 0x%p assigned for client jniHandle: %u", |
| fn, client.get(), jniHandle); |
| |
| { |
| SyncEventGuard guard(mClients[i]->mRegisteringEvent); |
| NFA_P2pRegisterClient(NFA_P2P_DLINK_TYPE, nfaClientCallback); |
| mClients[i]->mRegisteringEvent.wait(); // wait for NFA_P2P_REG_CLIENT_EVT |
| } |
| |
| if (mClients[i]->mNfaP2pClientHandle != NFA_HANDLE_INVALID) { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: exit; new client jniHandle: %u NFA Handle: 0x%04x", fn, |
| jniHandle, client->mClientConn->mNfaConnHandle); |
| return (true); |
| } else { |
| LOG(ERROR) << StringPrintf( |
| "%s: FAILED; new client jniHandle: %u NFA Handle: 0x%04x", fn, |
| jniHandle, client->mClientConn->mNfaConnHandle); |
| removeConn(jniHandle); |
| return (false); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: removeConn |
| ** |
| ** Description: Free resources related to a connection. |
| ** jniHandle: Connection handle. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::removeConn(tJNI_HANDLE jniHandle) { |
| static const char fn[] = "PeerToPeer::removeConn"; |
| |
| AutoMutex mutex(mMutex); |
| // If the connection is a for a client, delete the client itself |
| for (int ii = 0; ii < sMax; ii++) { |
| if ((mClients[ii] != NULL) && |
| (mClients[ii]->mClientConn->mJniHandle == jniHandle)) { |
| if (mClients[ii]->mNfaP2pClientHandle != NFA_HANDLE_INVALID) |
| NFA_P2pDeregister(mClients[ii]->mNfaP2pClientHandle); |
| |
| mClients[ii] = NULL; |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: deleted client handle: %u index: %u", fn, jniHandle, ii); |
| return; |
| } |
| } |
| |
| // If the connection is for a server, just delete the connection |
| for (int ii = 0; ii < sMax; ii++) { |
| if (mServers[ii] != NULL) { |
| if (mServers[ii]->removeServerConnection(jniHandle)) { |
| return; |
| } |
| } |
| } |
| |
| LOG(ERROR) << StringPrintf("%s: could not find handle: %u", fn, jniHandle); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: connectConnOriented |
| ** |
| ** Description: Establish a connection-oriented connection to a peer. |
| ** jniHandle: Connection handle. |
| ** serviceName: Peer's service name. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| bool PeerToPeer::connectConnOriented(tJNI_HANDLE jniHandle, |
| const char* serviceName) { |
| static const char fn[] = "PeerToPeer::connectConnOriented"; |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: enter; h: %u service name=%s", fn, jniHandle, serviceName); |
| bool stat = createDataLinkConn(jniHandle, serviceName, 0); |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: exit; h: %u stat: %u", fn, jniHandle, stat); |
| return stat; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: connectConnOriented |
| ** |
| ** Description: Establish a connection-oriented connection to a peer. |
| ** jniHandle: Connection handle. |
| ** destinationSap: Peer's service access point. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| bool PeerToPeer::connectConnOriented(tJNI_HANDLE jniHandle, |
| uint8_t destinationSap) { |
| static const char fn[] = "PeerToPeer::connectConnOriented"; |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: enter; h: %u dest sap: 0x%X", fn, jniHandle, destinationSap); |
| bool stat = createDataLinkConn(jniHandle, NULL, destinationSap); |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: exit; h: %u stat: %u", fn, jniHandle, stat); |
| return stat; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: createDataLinkConn |
| ** |
| ** Description: Establish a connection-oriented connection to a peer. |
| ** jniHandle: Connection handle. |
| ** serviceName: Peer's service name. |
| ** destinationSap: Peer's service access point. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| bool PeerToPeer::createDataLinkConn(tJNI_HANDLE jniHandle, |
| const char* serviceName, |
| uint8_t destinationSap) { |
| static const char fn[] = "PeerToPeer::createDataLinkConn"; |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", fn); |
| tNFA_STATUS nfaStat = NFA_STATUS_FAILED; |
| sp<P2pClient> pClient = NULL; |
| |
| if ((pClient = findClient(jniHandle)) == NULL) { |
| LOG(ERROR) << StringPrintf("%s: can't find client, JNI handle: %u", fn, |
| jniHandle); |
| return (false); |
| } |
| |
| { |
| SyncEventGuard guard(pClient->mConnectingEvent); |
| pClient->mIsConnecting = true; |
| |
| if (serviceName) |
| nfaStat = NFA_P2pConnectByName(pClient->mNfaP2pClientHandle, |
| const_cast<char*>(serviceName), |
| pClient->mClientConn->mMaxInfoUnit, |
| pClient->mClientConn->mRecvWindow); |
| else if (destinationSap) |
| nfaStat = |
| NFA_P2pConnectBySap(pClient->mNfaP2pClientHandle, destinationSap, |
| pClient->mClientConn->mMaxInfoUnit, |
| pClient->mClientConn->mRecvWindow); |
| if (nfaStat == NFA_STATUS_OK) { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: wait for connected event mConnectingEvent: 0x%p", fn, |
| pClient.get()); |
| pClient->mConnectingEvent.wait(); |
| } |
| } |
| |
| if (nfaStat == NFA_STATUS_OK) { |
| if (pClient->mClientConn->mNfaConnHandle == NFA_HANDLE_INVALID) { |
| removeConn(jniHandle); |
| nfaStat = NFA_STATUS_FAILED; |
| } else |
| pClient->mIsConnecting = false; |
| } else { |
| removeConn(jniHandle); |
| LOG(ERROR) << StringPrintf("%s: fail; error=0x%X", fn, nfaStat); |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", fn); |
| return nfaStat == NFA_STATUS_OK; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: findClient |
| ** |
| ** Description: Find a PeerToPeer object with a client connection handle. |
| ** nfaConnHandle: Connection handle. |
| ** |
| ** Returns: PeerToPeer object. |
| ** |
| *******************************************************************************/ |
| sp<P2pClient> PeerToPeer::findClient(tNFA_HANDLE nfaConnHandle) { |
| AutoMutex mutex(mMutex); |
| for (int i = 0; i < sMax; i++) { |
| if ((mClients[i] != NULL) && |
| (mClients[i]->mNfaP2pClientHandle == nfaConnHandle)) |
| return (mClients[i]); |
| } |
| return (NULL); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: findClient |
| ** |
| ** Description: Find a PeerToPeer object with a client connection handle. |
| ** jniHandle: Connection handle. |
| ** |
| ** Returns: PeerToPeer object. |
| ** |
| *******************************************************************************/ |
| sp<P2pClient> PeerToPeer::findClient(tJNI_HANDLE jniHandle) { |
| AutoMutex mutex(mMutex); |
| for (int i = 0; i < sMax; i++) { |
| if ((mClients[i] != NULL) && |
| (mClients[i]->mClientConn->mJniHandle == jniHandle)) |
| return (mClients[i]); |
| } |
| return (NULL); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: findClientCon |
| ** |
| ** Description: Find a PeerToPeer object with a client connection handle. |
| ** nfaConnHandle: Connection handle. |
| ** |
| ** Returns: PeerToPeer object. |
| ** |
| *******************************************************************************/ |
| sp<P2pClient> PeerToPeer::findClientCon(tNFA_HANDLE nfaConnHandle) { |
| AutoMutex mutex(mMutex); |
| for (int i = 0; i < sMax; i++) { |
| if ((mClients[i] != NULL) && |
| (mClients[i]->mClientConn->mNfaConnHandle == nfaConnHandle)) |
| return (mClients[i]); |
| } |
| return (NULL); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: findConnection |
| ** |
| ** Description: Find a PeerToPeer object with a connection handle. |
| ** nfaConnHandle: Connection handle. |
| ** |
| ** Returns: PeerToPeer object. |
| ** |
| *******************************************************************************/ |
| sp<NfaConn> PeerToPeer::findConnection(tNFA_HANDLE nfaConnHandle) { |
| AutoMutex mutex(mMutex); |
| // First, look through all the client control blocks |
| for (int ii = 0; ii < sMax; ii++) { |
| if ((mClients[ii] != NULL) && |
| (mClients[ii]->mClientConn->mNfaConnHandle == nfaConnHandle)) { |
| return mClients[ii]->mClientConn; |
| } |
| } |
| |
| // Not found yet. Look through all the server control blocks |
| for (int ii = 0; ii < sMax; ii++) { |
| if (mServers[ii] != NULL) { |
| sp<NfaConn> conn = mServers[ii]->findServerConnection(nfaConnHandle); |
| if (conn != NULL) { |
| return conn; |
| } |
| } |
| } |
| |
| // Not found... |
| return NULL; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: findConnection |
| ** |
| ** Description: Find a PeerToPeer object with a connection handle. |
| ** jniHandle: Connection handle. |
| ** |
| ** Returns: PeerToPeer object. |
| ** |
| *******************************************************************************/ |
| sp<NfaConn> PeerToPeer::findConnection(tJNI_HANDLE jniHandle) { |
| AutoMutex mutex(mMutex); |
| // First, look through all the client control blocks |
| for (int ii = 0; ii < sMax; ii++) { |
| if ((mClients[ii] != NULL) && |
| (mClients[ii]->mClientConn->mJniHandle == jniHandle)) { |
| return mClients[ii]->mClientConn; |
| } |
| } |
| |
| // Not found yet. Look through all the server control blocks |
| for (int ii = 0; ii < sMax; ii++) { |
| if (mServers[ii] != NULL) { |
| sp<NfaConn> conn = mServers[ii]->findServerConnection(jniHandle); |
| if (conn != NULL) { |
| return conn; |
| } |
| } |
| } |
| |
| // Not found... |
| return NULL; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: send |
| ** |
| ** Description: Send data to peer. |
| ** jniHandle: Handle of connection. |
| ** buffer: Buffer of data. |
| ** bufferLen: Length of data. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| bool PeerToPeer::send(tJNI_HANDLE jniHandle, uint8_t* buffer, |
| uint16_t bufferLen) { |
| static const char fn[] = "PeerToPeer::send"; |
| tNFA_STATUS nfaStat = NFA_STATUS_FAILED; |
| sp<NfaConn> pConn = NULL; |
| |
| if ((pConn = findConnection(jniHandle)) == NULL) { |
| LOG(ERROR) << StringPrintf("%s: can't find connection handle: %u", fn, |
| jniHandle); |
| return (false); |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: send data; jniHandle: %u nfaHandle: 0x%04X", fn, |
| pConn->mJniHandle, pConn->mNfaConnHandle); |
| |
| while (true) { |
| SyncEventGuard guard(pConn->mCongEvent); |
| nfaStat = NFA_P2pSendData(pConn->mNfaConnHandle, bufferLen, buffer); |
| if (nfaStat == NFA_STATUS_CONGESTED) |
| pConn->mCongEvent.wait(); // wait for NFA_P2P_CONGEST_EVT |
| else |
| break; |
| |
| if (pConn->mNfaConnHandle == |
| NFA_HANDLE_INVALID) // peer already disconnected |
| { |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: peer disconnected", fn); |
| return (false); |
| } |
| } |
| |
| if (nfaStat == NFA_STATUS_OK) |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: exit OK; JNI handle: %u NFA Handle: 0x%04x", fn, |
| jniHandle, pConn->mNfaConnHandle); |
| else |
| LOG(ERROR) << StringPrintf( |
| "%s: Data not sent; JNI handle: %u NFA Handle: 0x%04x error: 0x%04x", |
| fn, jniHandle, pConn->mNfaConnHandle, nfaStat); |
| |
| return nfaStat == NFA_STATUS_OK; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: receive |
| ** |
| ** Description: Receive data from peer. |
| ** jniHandle: Handle of connection. |
| ** buffer: Buffer to store data. |
| ** bufferLen: Max length of buffer. |
| ** actualLen: Actual length received. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| bool PeerToPeer::receive(tJNI_HANDLE jniHandle, uint8_t* buffer, |
| uint16_t bufferLen, uint16_t& actualLen) { |
| static const char fn[] = "PeerToPeer::receive"; |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: enter; jniHandle: %u bufferLen: %u", fn, jniHandle, bufferLen); |
| sp<NfaConn> pConn = NULL; |
| tNFA_STATUS stat = NFA_STATUS_FAILED; |
| uint32_t actualDataLen2 = 0; |
| bool isMoreData = TRUE; |
| bool retVal = false; |
| |
| if ((pConn = findConnection(jniHandle)) == NULL) { |
| LOG(ERROR) << StringPrintf("%s: can't find connection handle: %u", fn, |
| jniHandle); |
| return (false); |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: jniHandle: %u nfaHandle: 0x%04X buf len=%u", fn, |
| pConn->mJniHandle, pConn->mNfaConnHandle, bufferLen); |
| |
| while (pConn->mNfaConnHandle != NFA_HANDLE_INVALID) { |
| // NFA_P2pReadData() is synchronous |
| stat = NFA_P2pReadData(pConn->mNfaConnHandle, bufferLen, &actualDataLen2, |
| buffer, &isMoreData); |
| if ((stat == NFA_STATUS_OK) && (actualDataLen2 > 0)) // received some data |
| { |
| actualLen = (uint16_t)actualDataLen2; |
| retVal = true; |
| break; |
| } |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: waiting for data...", fn); |
| { |
| SyncEventGuard guard(pConn->mReadEvent); |
| pConn->mReadEvent.wait(); |
| } |
| } // while |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: exit; nfa h: 0x%X ok: %u actual len: %u", fn, |
| pConn->mNfaConnHandle, retVal, actualLen); |
| return retVal; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: disconnectConnOriented |
| ** |
| ** Description: Disconnect a connection-oriented connection with peer. |
| ** jniHandle: Handle of connection. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| bool PeerToPeer::disconnectConnOriented(tJNI_HANDLE jniHandle) { |
| static const char fn[] = "PeerToPeer::disconnectConnOriented"; |
| tNFA_STATUS nfaStat = NFA_STATUS_FAILED; |
| sp<P2pClient> pClient = NULL; |
| sp<NfaConn> pConn = NULL; |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: enter; jni handle: %u", fn, jniHandle); |
| |
| if ((pConn = findConnection(jniHandle)) == NULL) { |
| LOG(ERROR) << StringPrintf("%s: can't find connection handle: %u", fn, |
| jniHandle); |
| return (false); |
| } |
| |
| // If this is a client, he may not be connected yet, so unblock him just in |
| // case |
| if (((pClient = findClient(jniHandle)) != NULL) && (pClient->mIsConnecting)) { |
| SyncEventGuard guard(pClient->mConnectingEvent); |
| pClient->mConnectingEvent.notifyOne(); |
| return (true); |
| } |
| |
| { |
| SyncEventGuard guard1(pConn->mCongEvent); |
| pConn->mCongEvent.notifyOne(); // unblock send() if congested |
| } |
| { |
| SyncEventGuard guard2(pConn->mReadEvent); |
| pConn->mReadEvent.notifyOne(); // unblock receive() |
| } |
| |
| if (pConn->mNfaConnHandle != NFA_HANDLE_INVALID) { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: try disconn nfa h=0x%04X", fn, pConn->mNfaConnHandle); |
| SyncEventGuard guard(pConn->mDisconnectingEvent); |
| nfaStat = NFA_P2pDisconnect(pConn->mNfaConnHandle, FALSE); |
| |
| if (nfaStat != NFA_STATUS_OK) |
| LOG(ERROR) << StringPrintf("%s: fail p2p disconnect", fn); |
| else |
| pConn->mDisconnectingEvent.wait(); |
| } |
| |
| mDisconnectMutex.lock(); |
| removeConn(jniHandle); |
| mDisconnectMutex.unlock(); |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: exit; jni handle: %u", fn, jniHandle); |
| return nfaStat == NFA_STATUS_OK; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: getRemoteMaxInfoUnit |
| ** |
| ** Description: Get peer's max information unit. |
| ** jniHandle: Handle of the connection. |
| ** |
| ** Returns: Peer's max information unit. |
| ** |
| *******************************************************************************/ |
| uint16_t PeerToPeer::getRemoteMaxInfoUnit(tJNI_HANDLE jniHandle) { |
| static const char fn[] = "PeerToPeer::getRemoteMaxInfoUnit"; |
| sp<NfaConn> pConn = NULL; |
| |
| if ((pConn = findConnection(jniHandle)) == NULL) { |
| LOG(ERROR) << StringPrintf("%s: can't find client jniHandle: %u", fn, |
| jniHandle); |
| return 0; |
| } |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: jniHandle: %u MIU: %u", fn, jniHandle, pConn->mRemoteMaxInfoUnit); |
| return (pConn->mRemoteMaxInfoUnit); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: getRemoteRecvWindow |
| ** |
| ** Description: Get peer's receive window size. |
| ** jniHandle: Handle of the connection. |
| ** |
| ** Returns: Peer's receive window size. |
| ** |
| *******************************************************************************/ |
| uint8_t PeerToPeer::getRemoteRecvWindow(tJNI_HANDLE jniHandle) { |
| static const char fn[] = "PeerToPeer::getRemoteRecvWindow"; |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: client jni handle: %u", fn, jniHandle); |
| sp<NfaConn> pConn = NULL; |
| |
| if ((pConn = findConnection(jniHandle)) == NULL) { |
| LOG(ERROR) << StringPrintf("%s: can't find client", fn); |
| return 0; |
| } |
| return pConn->mRemoteRecvWindow; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: setP2pListenMask |
| ** |
| ** Description: Sets the p2p listen technology mask. |
| ** p2pListenMask: the p2p listen mask to be set? |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::setP2pListenMask(tNFA_TECHNOLOGY_MASK p2pListenMask) { |
| mP2pListenTechMask = p2pListenMask; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: getP2pListenMask |
| ** |
| ** Description: Get the set of technologies that P2P is listening. |
| ** |
| ** Returns: Set of technologies. |
| ** |
| *******************************************************************************/ |
| tNFA_TECHNOLOGY_MASK PeerToPeer::getP2pListenMask() { |
| return mP2pListenTechMask; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: resetP2pListenMask |
| ** |
| ** Description: Reset the p2p listen technology mask to initial value. |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::resetP2pListenMask() { |
| mP2pListenTechMask = NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_F | |
| NFA_TECHNOLOGY_MASK_A_ACTIVE | |
| NFA_TECHNOLOGY_MASK_F_ACTIVE; |
| if (NfcConfig::hasKey("P2P_LISTEN_TECH_MASK")) |
| mP2pListenTechMask = NfcConfig::getUnsigned("P2P_LISTEN_TECH_MASK"); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: enableP2pListening |
| ** |
| ** Description: Start/stop polling/listening to peer that supports P2P. |
| ** isEnable: Is enable polling/listening? |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::enableP2pListening(bool isEnable) { |
| static const char fn[] = "PeerToPeer::enableP2pListening"; |
| tNFA_STATUS nfaStat = NFA_STATUS_FAILED; |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: enter isEnable: %u mIsP2pListening: %u", fn, |
| isEnable, mIsP2pListening); |
| |
| // If request to enable P2P listening, and we were not already listening |
| if ((isEnable == true) && (mIsP2pListening == false) && |
| (mP2pListenTechMask != 0)) { |
| SyncEventGuard guard(mSetTechEvent); |
| if ((nfaStat = NFA_SetP2pListenTech(mP2pListenTechMask)) == NFA_STATUS_OK) { |
| mSetTechEvent.wait(); |
| mIsP2pListening = true; |
| } else |
| LOG(ERROR) << StringPrintf("%s: fail enable listen; error=0x%X", fn, |
| nfaStat); |
| } else if ((isEnable == false) && (mIsP2pListening == true)) { |
| SyncEventGuard guard(mSetTechEvent); |
| // Request to disable P2P listening, check if it was enabled |
| if ((nfaStat = NFA_SetP2pListenTech(0)) == NFA_STATUS_OK) { |
| mSetTechEvent.wait(); |
| mIsP2pListening = false; |
| } else |
| LOG(ERROR) << StringPrintf("%s: fail disable listen; error=0x%X", fn, |
| nfaStat); |
| } |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: exit; mIsP2pListening: %u", fn, mIsP2pListening); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: handleNfcOnOff |
| ** |
| ** Description: Handle events related to turning NFC on/off by the user. |
| ** isOn: Is NFC turning on? |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::handleNfcOnOff(bool isOn) { |
| static const char fn[] = "PeerToPeer::handleNfcOnOff"; |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: enter; is on=%u", fn, isOn); |
| |
| mIsP2pListening = false; // In both cases, P2P will not be listening |
| |
| AutoMutex mutex(mMutex); |
| if (isOn) { |
| // Start with no clients or servers |
| memset(mServers, 0, sizeof(mServers)); |
| memset(mClients, 0, sizeof(mClients)); |
| } else { |
| // Disconnect through all the clients |
| for (int ii = 0; ii < sMax; ii++) { |
| if (mClients[ii] != NULL) { |
| if (mClients[ii]->mClientConn->mNfaConnHandle == NFA_HANDLE_INVALID) { |
| SyncEventGuard guard(mClients[ii]->mConnectingEvent); |
| mClients[ii]->mConnectingEvent.notifyOne(); |
| } else { |
| mClients[ii]->mClientConn->mNfaConnHandle = NFA_HANDLE_INVALID; |
| { |
| SyncEventGuard guard1(mClients[ii]->mClientConn->mCongEvent); |
| mClients[ii] |
| ->mClientConn->mCongEvent.notifyOne(); // unblock send() |
| } |
| { |
| SyncEventGuard guard2(mClients[ii]->mClientConn->mReadEvent); |
| mClients[ii] |
| ->mClientConn->mReadEvent.notifyOne(); // unblock receive() |
| } |
| } |
| } |
| } // loop |
| |
| // Now look through all the server control blocks |
| for (int ii = 0; ii < sMax; ii++) { |
| if (mServers[ii] != NULL) { |
| mServers[ii]->unblockAll(); |
| } |
| } // loop |
| } |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", fn); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfaServerCallback |
| ** |
| ** Description: Receive LLCP-related events from the stack. |
| ** p2pEvent: Event code. |
| ** eventData: Event data. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::nfaServerCallback(tNFA_P2P_EVT p2pEvent, |
| tNFA_P2P_EVT_DATA* eventData) { |
| static const char fn[] = "PeerToPeer::nfaServerCallback"; |
| sp<P2pServer> pSrv = NULL; |
| sp<NfaConn> pConn = NULL; |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: enter; event=0x%X", fn, p2pEvent); |
| |
| switch (p2pEvent) { |
| case NFA_P2P_REG_SERVER_EVT: // NFA_P2pRegisterServer() has started to |
| // listen |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_REG_SERVER_EVT; handle: 0x%04x; service sap=0x%02x " |
| "name: " |
| "%s", |
| fn, eventData->reg_server.server_handle, |
| eventData->reg_server.server_sap, eventData->reg_server.service_name); |
| |
| sP2p.mMutex.lock(); |
| pSrv = sP2p.findServerLocked(eventData->reg_server.service_name); |
| sP2p.mMutex.unlock(); |
| if (pSrv == NULL) { |
| LOG(ERROR) << StringPrintf( |
| "%s: NFA_P2P_REG_SERVER_EVT for unknown service: %s", fn, |
| eventData->reg_server.service_name); |
| } else { |
| SyncEventGuard guard(pSrv->mRegServerEvent); |
| pSrv->mNfaP2pServerHandle = eventData->reg_server.server_handle; |
| pSrv->mRegServerEvent.notifyOne(); // unblock registerServer() |
| } |
| break; |
| |
| case NFA_P2P_ACTIVATED_EVT: // remote device has activated |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: NFA_P2P_ACTIVATED_EVT; handle: 0x%04x", fn, |
| eventData->activated.handle); |
| break; |
| |
| case NFA_P2P_DEACTIVATED_EVT: |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: NFA_P2P_DEACTIVATED_EVT; handle: 0x%04x", fn, |
| eventData->activated.handle); |
| break; |
| |
| case NFA_P2P_CONN_REQ_EVT: |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_CONN_REQ_EVT; nfa server h=0x%04x; nfa conn h=0x%04x; " |
| "remote sap=0x%02x", |
| fn, eventData->conn_req.server_handle, |
| eventData->conn_req.conn_handle, eventData->conn_req.remote_sap); |
| |
| sP2p.mMutex.lock(); |
| pSrv = sP2p.findServerLocked(eventData->conn_req.server_handle); |
| sP2p.mMutex.unlock(); |
| if (pSrv == NULL) { |
| LOG(ERROR) << StringPrintf("%s: NFA_P2P_CONN_REQ_EVT; unknown server h", |
| fn); |
| return; |
| } |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_CONN_REQ_EVT; server jni h=%u", fn, pSrv->mJniHandle); |
| |
| // Look for a connection block that is waiting (handle invalid) |
| if ((pConn = pSrv->findServerConnection( |
| (tNFA_HANDLE)NFA_HANDLE_INVALID)) == NULL) { |
| LOG(ERROR) << StringPrintf( |
| "%s: NFA_P2P_CONN_REQ_EVT; server not listening", fn); |
| } else { |
| SyncEventGuard guard(pSrv->mConnRequestEvent); |
| pConn->mNfaConnHandle = eventData->conn_req.conn_handle; |
| pConn->mRemoteMaxInfoUnit = eventData->conn_req.remote_miu; |
| pConn->mRemoteRecvWindow = eventData->conn_req.remote_rw; |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_CONN_REQ_EVT; server jni h=%u; conn jni " |
| "h=%u; notify conn req", |
| fn, pSrv->mJniHandle, pConn->mJniHandle); |
| pSrv->mConnRequestEvent.notifyOne(); // unblock accept() |
| } |
| break; |
| |
| case NFA_P2P_CONNECTED_EVT: |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_CONNECTED_EVT; h=0x%x remote sap=0x%X", fn, |
| eventData->connected.client_handle, eventData->connected.remote_sap); |
| break; |
| |
| case NFA_P2P_DISC_EVT: |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: NFA_P2P_DISC_EVT; h=0x%04x; reason=0x%X", fn, |
| eventData->disc.handle, eventData->disc.reason); |
| // Look for the connection block |
| if ((pConn = sP2p.findConnection(eventData->disc.handle)) == NULL) { |
| LOG(ERROR) << StringPrintf( |
| "%s: NFA_P2P_DISC_EVT: can't find conn for NFA handle: 0x%04x", fn, |
| eventData->disc.handle); |
| } else { |
| sP2p.mDisconnectMutex.lock(); |
| pConn->mNfaConnHandle = NFA_HANDLE_INVALID; |
| { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_DISC_EVT; try guard disconn event", fn); |
| SyncEventGuard guard3(pConn->mDisconnectingEvent); |
| pConn->mDisconnectingEvent.notifyOne(); |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_DISC_EVT; notified disconn event", fn); |
| } |
| { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_DISC_EVT; try guard congest event", fn); |
| SyncEventGuard guard1(pConn->mCongEvent); |
| pConn->mCongEvent.notifyOne(); // unblock write (if congested) |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_DISC_EVT; notified congest event", fn); |
| } |
| { |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: NFA_P2P_DISC_EVT; try guard read event", fn); |
| SyncEventGuard guard2(pConn->mReadEvent); |
| pConn->mReadEvent.notifyOne(); // unblock receive() |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: NFA_P2P_DISC_EVT; notified read event", fn); |
| } |
| sP2p.mDisconnectMutex.unlock(); |
| } |
| break; |
| |
| case NFA_P2P_DATA_EVT: |
| // Look for the connection block |
| if ((pConn = sP2p.findConnection(eventData->data.handle)) == NULL) { |
| LOG(ERROR) << StringPrintf( |
| "%s: NFA_P2P_DATA_EVT: can't find conn for NFA handle: 0x%04x", fn, |
| eventData->data.handle); |
| } else { |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: NFA_P2P_DATA_EVT; h=0x%X; remote sap=0x%X", fn, |
| eventData->data.handle, eventData->data.remote_sap); |
| SyncEventGuard guard(pConn->mReadEvent); |
| pConn->mReadEvent.notifyOne(); |
| } |
| break; |
| |
| case NFA_P2P_CONGEST_EVT: |
| // Look for the connection block |
| if ((pConn = sP2p.findConnection(eventData->congest.handle)) == NULL) { |
| LOG(ERROR) << StringPrintf( |
| "%s: NFA_P2P_CONGEST_EVT: can't find conn for NFA handle: 0x%04x", |
| fn, eventData->congest.handle); |
| } else { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_CONGEST_EVT; nfa handle: 0x%04x congested: %u", fn, |
| eventData->congest.handle, eventData->congest.is_congested); |
| if (eventData->congest.is_congested == FALSE) { |
| SyncEventGuard guard(pConn->mCongEvent); |
| pConn->mCongEvent.notifyOne(); |
| } |
| } |
| break; |
| |
| default: |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: unknown event 0x%X ????", fn, p2pEvent); |
| break; |
| } |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", fn); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfaClientCallback |
| ** |
| ** Description: Receive LLCP-related events from the stack. |
| ** p2pEvent: Event code. |
| ** eventData: Event data. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::nfaClientCallback(tNFA_P2P_EVT p2pEvent, |
| tNFA_P2P_EVT_DATA* eventData) { |
| static const char fn[] = "PeerToPeer::nfaClientCallback"; |
| sp<NfaConn> pConn = NULL; |
| sp<P2pClient> pClient = NULL; |
| |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: enter; event=%u", fn, p2pEvent); |
| |
| switch (p2pEvent) { |
| case NFA_P2P_REG_CLIENT_EVT: |
| // Look for a client that is trying to register |
| if ((pClient = sP2p.findClient((tNFA_HANDLE)NFA_HANDLE_INVALID)) == |
| NULL) { |
| LOG(ERROR) << StringPrintf( |
| "%s: NFA_P2P_REG_CLIENT_EVT: can't find waiting client", fn); |
| } else { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_REG_CLIENT_EVT; Conn Handle: 0x%04x, pClient: 0x%p", |
| fn, eventData->reg_client.client_handle, pClient.get()); |
| |
| SyncEventGuard guard(pClient->mRegisteringEvent); |
| pClient->mNfaP2pClientHandle = eventData->reg_client.client_handle; |
| pClient->mRegisteringEvent.notifyOne(); |
| } |
| break; |
| |
| case NFA_P2P_ACTIVATED_EVT: |
| // Look for a client that is trying to register |
| if ((pClient = sP2p.findClient(eventData->activated.handle)) == NULL) { |
| LOG(ERROR) << StringPrintf( |
| "%s: NFA_P2P_ACTIVATED_EVT: can't find client", fn); |
| } else { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_ACTIVATED_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn, |
| eventData->activated.handle, pClient.get()); |
| } |
| break; |
| |
| case NFA_P2P_DEACTIVATED_EVT: |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: NFA_P2P_DEACTIVATED_EVT: conn handle: 0x%X", fn, |
| eventData->deactivated.handle); |
| break; |
| |
| case NFA_P2P_CONNECTED_EVT: |
| // Look for the client that is trying to connect |
| if ((pClient = sP2p.findClient(eventData->connected.client_handle)) == |
| NULL) { |
| LOG(ERROR) << StringPrintf( |
| "%s: NFA_P2P_CONNECTED_EVT: can't find client: 0x%04x", fn, |
| eventData->connected.client_handle); |
| } else { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_CONNECTED_EVT; client_handle=0x%04x " |
| "conn_handle: 0x%04x remote sap=0x%X pClient: 0x%p", |
| fn, eventData->connected.client_handle, |
| eventData->connected.conn_handle, eventData->connected.remote_sap, |
| pClient.get()); |
| |
| SyncEventGuard guard(pClient->mConnectingEvent); |
| pClient->mClientConn->mNfaConnHandle = eventData->connected.conn_handle; |
| pClient->mClientConn->mRemoteMaxInfoUnit = |
| eventData->connected.remote_miu; |
| pClient->mClientConn->mRemoteRecvWindow = |
| eventData->connected.remote_rw; |
| pClient->mConnectingEvent.notifyOne(); // unblock createDataLinkConn() |
| } |
| break; |
| |
| case NFA_P2P_DISC_EVT: |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: NFA_P2P_DISC_EVT; h=0x%04x; reason=0x%X", fn, |
| eventData->disc.handle, eventData->disc.reason); |
| // Look for the connection block |
| if ((pConn = sP2p.findConnection(eventData->disc.handle)) == NULL) { |
| // If no connection, may be a client that is trying to connect |
| if ((pClient = sP2p.findClient(eventData->disc.handle)) == NULL) { |
| LOG(ERROR) << StringPrintf( |
| "%s: NFA_P2P_DISC_EVT: can't find client for NFA handle: 0x%04x", |
| fn, eventData->disc.handle); |
| return; |
| } |
| // Unblock createDataLinkConn() |
| SyncEventGuard guard(pClient->mConnectingEvent); |
| pClient->mConnectingEvent.notifyOne(); |
| } else { |
| sP2p.mDisconnectMutex.lock(); |
| pConn->mNfaConnHandle = NFA_HANDLE_INVALID; |
| { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_DISC_EVT; try guard disconn event", fn); |
| SyncEventGuard guard3(pConn->mDisconnectingEvent); |
| pConn->mDisconnectingEvent.notifyOne(); |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_DISC_EVT; notified disconn event", fn); |
| } |
| { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_DISC_EVT; try guard congest event", fn); |
| SyncEventGuard guard1(pConn->mCongEvent); |
| pConn->mCongEvent.notifyOne(); // unblock write (if congested) |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_DISC_EVT; notified congest event", fn); |
| } |
| { |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: NFA_P2P_DISC_EVT; try guard read event", fn); |
| SyncEventGuard guard2(pConn->mReadEvent); |
| pConn->mReadEvent.notifyOne(); // unblock receive() |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: NFA_P2P_DISC_EVT; notified read event", fn); |
| } |
| sP2p.mDisconnectMutex.unlock(); |
| } |
| break; |
| |
| case NFA_P2P_DATA_EVT: |
| // Look for the connection block |
| if ((pConn = sP2p.findConnection(eventData->data.handle)) == NULL) { |
| LOG(ERROR) << StringPrintf( |
| "%s: NFA_P2P_DATA_EVT: can't find conn for NFA handle: 0x%04x", fn, |
| eventData->data.handle); |
| } else { |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: NFA_P2P_DATA_EVT; h=0x%X; remote sap=0x%X", fn, |
| eventData->data.handle, eventData->data.remote_sap); |
| SyncEventGuard guard(pConn->mReadEvent); |
| pConn->mReadEvent.notifyOne(); |
| } |
| break; |
| |
| case NFA_P2P_CONGEST_EVT: |
| // Look for the connection block |
| if ((pConn = sP2p.findConnection(eventData->congest.handle)) == NULL) { |
| LOG(ERROR) << StringPrintf( |
| "%s: NFA_P2P_CONGEST_EVT: can't find conn for NFA handle: 0x%04x", |
| fn, eventData->congest.handle); |
| } else { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: NFA_P2P_CONGEST_EVT; nfa handle: 0x%04x congested: %u", fn, |
| eventData->congest.handle, eventData->congest.is_congested); |
| |
| SyncEventGuard guard(pConn->mCongEvent); |
| pConn->mCongEvent.notifyOne(); |
| } |
| break; |
| |
| default: |
| LOG(ERROR) << StringPrintf("%s: unknown event 0x%X ????", fn, p2pEvent); |
| break; |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: connectionEventHandler |
| ** |
| ** Description: Receive events from the stack. |
| ** event: Event code. |
| ** eventData: Event data. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void PeerToPeer::connectionEventHandler(uint8_t event, |
| tNFA_CONN_EVT_DATA* /*eventData*/) { |
| switch (event) { |
| case NFA_SET_P2P_LISTEN_TECH_EVT: { |
| SyncEventGuard guard(mSetTechEvent); |
| mSetTechEvent.notifyOne(); // unblock NFA_SetP2pListenTech() |
| break; |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: getNextJniHandle |
| ** |
| ** Description: Get a new JNI handle. |
| ** |
| ** Returns: A new JNI handle. |
| ** |
| *******************************************************************************/ |
| PeerToPeer::tJNI_HANDLE PeerToPeer::getNewJniHandle() { |
| tJNI_HANDLE newHandle = 0; |
| |
| mNewJniHandleMutex.lock(); |
| newHandle = mNextJniHandle++; |
| mNewJniHandleMutex.unlock(); |
| return newHandle; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////// |
| |
| /******************************************************************************* |
| ** |
| ** Function: P2pServer |
| ** |
| ** Description: Initialize member variables. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| P2pServer::P2pServer(PeerToPeer::tJNI_HANDLE jniHandle, const char* serviceName) |
| : mNfaP2pServerHandle(NFA_HANDLE_INVALID), mJniHandle(jniHandle) { |
| mServiceName.assign(serviceName); |
| |
| memset(mServerConn, 0, sizeof(mServerConn)); |
| } |
| |
| bool P2pServer::registerWithStack() { |
| static const char fn[] = "P2pServer::registerWithStack"; |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: enter; service name: %s JNI handle: %u", fn, |
| mServiceName.c_str(), mJniHandle); |
| tNFA_STATUS stat = NFA_STATUS_OK; |
| uint8_t serverSap = NFA_P2P_ANY_SAP; |
| |
| /********************** |
| default values for all LLCP parameters: |
| - Local Link MIU (LLCP_MIU) |
| - Option parameter (LLCP_OPT_VALUE) |
| - Response Waiting Time Index (LLCP_WAITING_TIME) |
| - Local Link Timeout (LLCP_LTO_VALUE) |
| - Inactivity Timeout as initiator role (LLCP_INIT_INACTIVITY_TIMEOUT) |
| - Inactivity Timeout as target role (LLCP_TARGET_INACTIVITY_TIMEOUT) |
| - Delay SYMM response (LLCP_DELAY_RESP_TIME) |
| - Data link connection timeout (LLCP_DATA_LINK_CONNECTION_TOUT) |
| - Delay timeout to send first PDU as initiator |
| (LLCP_DELAY_TIME_TO_SEND_FIRST_PDU) |
| ************************/ |
| stat = NFA_P2pSetLLCPConfig(LLCP_MAX_MIU, LLCP_OPT_VALUE, LLCP_WAITING_TIME, |
| LLCP_LTO_VALUE, |
| 0, // use 0 for infinite timeout for symmetry |
| // procedure when acting as initiator |
| 0, // use 0 for infinite timeout for symmetry |
| // procedure when acting as target |
| LLCP_DELAY_RESP_TIME, LLCP_DATA_LINK_TIMEOUT, |
| LLCP_DELAY_TIME_TO_SEND_FIRST_PDU); |
| if (stat != NFA_STATUS_OK) |
| LOG(ERROR) << StringPrintf("%s: fail set LLCP config; error=0x%X", fn, |
| stat); |
| |
| if (sSnepServiceName.compare(mServiceName) == 0) |
| serverSap = 4; // LLCP_SAP_SNEP == 4 |
| |
| { |
| SyncEventGuard guard(mRegServerEvent); |
| stat = NFA_P2pRegisterServer(serverSap, NFA_P2P_DLINK_TYPE, |
| const_cast<char*>(mServiceName.c_str()), |
| PeerToPeer::nfaServerCallback); |
| if (stat != NFA_STATUS_OK) { |
| LOG(ERROR) << StringPrintf("%s: fail register p2p server; error=0x%X", fn, |
| stat); |
| return (false); |
| } |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: wait for listen-completion event", fn); |
| // Wait for NFA_P2P_REG_SERVER_EVT |
| mRegServerEvent.wait(); |
| } |
| |
| return (mNfaP2pServerHandle != NFA_HANDLE_INVALID); |
| } |
| |
| bool P2pServer::accept(PeerToPeer::tJNI_HANDLE serverJniHandle, |
| PeerToPeer::tJNI_HANDLE connJniHandle, int maxInfoUnit, |
| int recvWindow) { |
| static const char fn[] = "P2pServer::accept"; |
| tNFA_STATUS nfaStat = NFA_STATUS_OK; |
| |
| sp<NfaConn> connection = allocateConnection(connJniHandle); |
| if (connection == NULL) { |
| LOG(ERROR) << StringPrintf("%s: failed to allocate new server connection", |
| fn); |
| return false; |
| } |
| |
| { |
| // Wait for NFA_P2P_CONN_REQ_EVT or NFA_NDEF_DATA_EVT when remote device |
| // requests connection |
| SyncEventGuard guard(mConnRequestEvent); |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: serverJniHandle: %u; connJniHandle: %u; wait for " |
| "incoming connection", |
| fn, serverJniHandle, connJniHandle); |
| mConnRequestEvent.wait(); |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; got " |
| "incoming connection", |
| fn, serverJniHandle, connJniHandle, connection->mNfaConnHandle); |
| } |
| |
| if (connection->mNfaConnHandle == NFA_HANDLE_INVALID) { |
| removeServerConnection(connJniHandle); |
| DLOG_IF(INFO, nfc_debug_enabled) |
| << StringPrintf("%s: no handle assigned", fn); |
| return (false); |
| } |
| |
| if (maxInfoUnit > (int)LLCP_MIU) { |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: overriding the miu passed by the app(%d) with stack miu(%zu)", fn, |
| maxInfoUnit, LLCP_MIU); |
| maxInfoUnit = LLCP_MIU; |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; try " |
| "accept", |
| fn, serverJniHandle, connJniHandle, connection->mNfaConnHandle); |
| nfaStat = |
| NFA_P2pAcceptConn(connection->mNfaConnHandle, maxInfoUnit, recvWindow); |
| |
| if (nfaStat != NFA_STATUS_OK) { |
| LOG(ERROR) << StringPrintf("%s: fail to accept remote; error=0x%X", fn, |
| nfaStat); |
| return (false); |
| } |
| |
| DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( |
| "%s: exit; serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X", fn, |
| serverJniHandle, connJniHandle, connection->mNfaConnHandle); |
| return (true); |
| } |
| |
| void P2pServer::unblockAll() { |
| AutoMutex mutex(mMutex); |
| for (int jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) { |
| if (mServerConn[jj] != NULL) { |
| mServerConn[jj]->mNfaConnHandle = NFA_HANDLE_INVALID; |
| { |
| SyncEventGuard guard1(mServerConn[jj]->mCongEvent); |
| mServerConn[jj] |
| ->mCongEvent.notifyOne(); // unblock write (if congested) |
| } |
| { |
| SyncEventGuard guard2(mServerConn[jj]->mReadEvent); |
| mServerConn[jj]->mReadEvent.notifyOne(); // unblock receive() |
| } |
| } |
| } |
| } |
| |
| sp<NfaConn> P2pServer::allocateConnection(PeerToPeer::tJNI_HANDLE jniHandle) { |
| AutoMutex mutex(mMutex); |
| // First, find a free connection block to handle the connection |
| for (int ii = 0; ii < MAX_NFA_CONNS_PER_SERVER; ii++) { |
| if (mServerConn[ii] == NULL) { |
| mServerConn[ii] = new NfaConn; |
| mServerConn[ii]->mJniHandle = jniHandle; |
| return mServerConn[ii]; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: findServerConnection |
| ** |
| ** Description: Find a P2pServer that has the handle. |
| ** nfaConnHandle: NFA connection handle. |
| ** |
| ** Returns: P2pServer object. |
| ** |
| *******************************************************************************/ |
| sp<NfaConn> P2pServer::findServerConnection(tNFA_HANDLE nfaConnHandle) { |
| int jj = 0; |
| |
| AutoMutex mutex(mMutex); |
| for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) { |
| if ((mServerConn[jj] != NULL) && |
| (mServerConn[jj]->mNfaConnHandle == nfaConnHandle)) |
| return (mServerConn[jj]); |
| } |
| |
| // If here, not found |
| return (NULL); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: findServerConnection |
| ** |
| ** Description: Find a P2pServer that has the handle. |
| ** nfaConnHandle: NFA connection handle. |
| ** |
| ** Returns: P2pServer object. |
| ** |
| *******************************************************************************/ |
| sp<NfaConn> P2pServer::findServerConnection(PeerToPeer::tJNI_HANDLE jniHandle) { |
| int jj = 0; |
| |
| AutoMutex mutex(mMutex); |
| for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) { |
| if ((mServerConn[jj] != NULL) && (mServerConn[jj]->mJniHandle == jniHandle)) |
| return (mServerConn[jj]); |
| } |
| |
| // If here, not found |
| return (NULL); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: removeServerConnection |
| ** |
| ** Description: Find a P2pServer that has the handle. |
| ** nfaConnHandle: NFA connection handle. |
| ** |
| ** Returns: P2pServer object. |
| ** |
| *******************************************************************************/ |
| bool P2pServer::removeServerConnection(PeerToPeer::tJNI_HANDLE jniHandle) { |
| int jj = 0; |
| |
| AutoMutex mutex(mMutex); |
| for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++) { |
| if ((mServerConn[jj] != NULL) && |
| (mServerConn[jj]->mJniHandle == jniHandle)) { |
| mServerConn[jj] = NULL; |
| return true; |
| } |
| } |
| |
| // If here, not found |
| return false; |
| } |
| ///////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////// |
| |
| /******************************************************************************* |
| ** |
| ** Function: P2pClient |
| ** |
| ** Description: Initialize member variables. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| P2pClient::P2pClient() |
| : mNfaP2pClientHandle(NFA_HANDLE_INVALID), mIsConnecting(false) { |
| mClientConn = new NfaConn(); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: ~P2pClient |
| ** |
| ** Description: Free all resources. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| P2pClient::~P2pClient() {} |
| |
| ///////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////// |
| |
| /******************************************************************************* |
| ** |
| ** Function: NfaConn |
| ** |
| ** Description: Initialize member variables. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| NfaConn::NfaConn() |
| : mNfaConnHandle(NFA_HANDLE_INVALID), |
| mJniHandle(0), |
| mMaxInfoUnit(0), |
| mRecvWindow(0), |
| mRemoteMaxInfoUnit(0), |
| mRemoteRecvWindow(0) {} |
