1 /*
2  * Copyright (C) 2012 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  *  Communicate with a peer using NFC-DEP, LLCP, SNEP.
19  */
20 #include "OverrideLog.h"
21 #include "PeerToPeer.h"
22 #include "NfcJniUtil.h"
23 #include "llcp_defs.h"
24 #include "config.h"
25 #include "JavaClassConstants.h"
26 #include <ScopedLocalRef.h>
27 
28 /* Some older PN544-based solutions would only send the first SYMM back
29  * (as an initiator) after the full LTO (750ms). But our connect timer
30  * starts immediately, and hence we may timeout if the timer is set to
31  * 1000 ms. Worse, this causes us to immediately connect to the NPP
32  * socket, causing concurrency issues in that stack. Increase the default
33  * timeout to 2000 ms, giving us enough time to complete the first connect.
34  */
35 #define LLCP_DATA_LINK_TIMEOUT    2000
36 
37 using namespace android;
38 
39 namespace android
40 {
41     extern void nativeNfcTag_registerNdefTypeHandler ();
42     extern void nativeNfcTag_deregisterNdefTypeHandler ();
43     extern void startRfDiscovery (bool isStart);
44     extern bool isDiscoveryStarted ();
45 }
46 
47 
48 PeerToPeer PeerToPeer::sP2p;
49 const std::string P2pServer::sSnepServiceName ("urn:nfc:sn:snep");
50 
51 
52 /*******************************************************************************
53 **
54 ** Function:        PeerToPeer
55 **
56 ** Description:     Initialize member variables.
57 **
58 ** Returns:         None
59 **
60 *******************************************************************************/
PeerToPeer()61 PeerToPeer::PeerToPeer ()
62 :   mRemoteWKS (0),
63     mIsP2pListening (false),
64     mP2pListenTechMask (NFA_TECHNOLOGY_MASK_A
65                         | NFA_TECHNOLOGY_MASK_F
66                         | NFA_TECHNOLOGY_MASK_A_ACTIVE
67                         | NFA_TECHNOLOGY_MASK_F_ACTIVE),
68     mNextJniHandle (1)
69 {
70     memset (mServers, 0, sizeof(mServers));
71     memset (mClients, 0, sizeof(mClients));
72 }
73 
74 
75 /*******************************************************************************
76 **
77 ** Function:        ~PeerToPeer
78 **
79 ** Description:     Free all resources.
80 **
81 ** Returns:         None
82 **
83 *******************************************************************************/
~PeerToPeer()84 PeerToPeer::~PeerToPeer ()
85 {
86 }
87 
88 
89 /*******************************************************************************
90 **
91 ** Function:        getInstance
92 **
93 ** Description:     Get the singleton PeerToPeer object.
94 **
95 ** Returns:         Singleton PeerToPeer object.
96 **
97 *******************************************************************************/
getInstance()98 PeerToPeer& PeerToPeer::getInstance ()
99 {
100     return sP2p;
101 }
102 
103 
104 /*******************************************************************************
105 **
106 ** Function:        initialize
107 **
108 ** Description:     Initialize member variables.
109 **
110 ** Returns:         None
111 **
112 *******************************************************************************/
initialize()113 void PeerToPeer::initialize ()
114 {
115     ALOGD ("PeerToPeer::initialize");
116     unsigned long num = 0;
117 
118     if (GetNumValue ("P2P_LISTEN_TECH_MASK", &num, sizeof (num)))
119         mP2pListenTechMask = num;
120 }
121 
122 
123 /*******************************************************************************
124 **
125 ** Function:        findServerLocked
126 **
127 ** Description:     Find a PeerToPeer object by connection handle.
128 **                  Assumes mMutex is already held
129 **                  nfaP2pServerHandle: Connectin handle.
130 **
131 ** Returns:         PeerToPeer object.
132 **
133 *******************************************************************************/
findServerLocked(tNFA_HANDLE nfaP2pServerHandle)134 sp<P2pServer> PeerToPeer::findServerLocked (tNFA_HANDLE nfaP2pServerHandle)
135 {
136     for (int i = 0; i < sMax; i++)
137     {
138         if ( (mServers[i] != NULL)
139           && (mServers[i]->mNfaP2pServerHandle == nfaP2pServerHandle) )
140         {
141             return (mServers [i]);
142         }
143     }
144 
145     // If here, not found
146     return NULL;
147 }
148 
149 
150 /*******************************************************************************
151 **
152 ** Function:        findServerLocked
153 **
154 ** Description:     Find a PeerToPeer object by connection handle.
155 **                  Assumes mMutex is already held
156 **                  serviceName: service name.
157 **
158 ** Returns:         PeerToPeer object.
159 **
160 *******************************************************************************/
findServerLocked(tJNI_HANDLE jniHandle)161 sp<P2pServer> PeerToPeer::findServerLocked (tJNI_HANDLE jniHandle)
162 {
163     for (int i = 0; i < sMax; i++)
164     {
165         if ( (mServers[i] != NULL)
166           && (mServers[i]->mJniHandle == jniHandle) )
167         {
168             return (mServers [i]);
169         }
170     }
171 
172     // If here, not found
173     return NULL;
174 }
175 
176 
177 /*******************************************************************************
178 **
179 ** Function:        findServerLocked
180 **
181 ** Description:     Find a PeerToPeer object by service name
182 **                  Assumes mMutex is already heldf
183 **                  serviceName: service name.
184 **
185 ** Returns:         PeerToPeer object.
186 **
187 *******************************************************************************/
findServerLocked(const char * serviceName)188 sp<P2pServer> PeerToPeer::findServerLocked (const char *serviceName)
189 {
190     for (int i = 0; i < sMax; i++)
191     {
192         if ( (mServers[i] != NULL) && (mServers[i]->mServiceName.compare(serviceName) == 0) )
193             return (mServers [i]);
194     }
195 
196     // If here, not found
197     return NULL;
198 }
199 
200 
201 /*******************************************************************************
202 **
203 ** Function:        registerServer
204 **
205 ** Description:     Let a server start listening for peer's connection request.
206 **                  jniHandle: Connection handle.
207 **                  serviceName: Server's service name.
208 **
209 ** Returns:         True if ok.
210 **
211 *******************************************************************************/
registerServer(tJNI_HANDLE jniHandle,const char * serviceName)212 bool PeerToPeer::registerServer (tJNI_HANDLE jniHandle, const char *serviceName)
213 {
214     static const char fn [] = "PeerToPeer::registerServer";
215     ALOGD ("%s: enter; service name: %s  JNI handle: %u", fn, serviceName, jniHandle);
216     sp<P2pServer>   pSrv = NULL;
217 
218     mMutex.lock();
219     // Check if already registered
220     if ((pSrv = findServerLocked(serviceName)) != NULL)
221     {
222         ALOGD ("%s: service name=%s  already registered, handle: 0x%04x", fn, serviceName, pSrv->mNfaP2pServerHandle);
223 
224         // Update JNI handle
225         pSrv->mJniHandle = jniHandle;
226         mMutex.unlock();
227         return (true);
228     }
229 
230     for (int ii = 0; ii < sMax; ii++)
231     {
232         if (mServers[ii] == NULL)
233         {
234             pSrv = mServers[ii] = new P2pServer(jniHandle, serviceName);
235 
236             ALOGD ("%s: added new p2p server  index: %d  handle: %u  name: %s", fn, ii, jniHandle, serviceName);
237             break;
238         }
239     }
240     mMutex.unlock();
241 
242     if (pSrv == NULL)
243     {
244         ALOGE ("%s: service name=%s  no free entry", fn, serviceName);
245         return (false);
246     }
247 
248     if (pSrv->registerWithStack()) {
249         ALOGD ("%s: got new p2p server h=0x%X", fn, pSrv->mNfaP2pServerHandle);
250         return (true);
251     } else {
252         ALOGE ("%s: invalid server handle", fn);
253         removeServer (jniHandle);
254         return (false);
255     }
256 }
257 
258 
259 /*******************************************************************************
260 **
261 ** Function:        removeServer
262 **
263 ** Description:     Free resources related to a server.
264 **                  jniHandle: Connection handle.
265 **
266 ** Returns:         None
267 **
268 *******************************************************************************/
removeServer(tJNI_HANDLE jniHandle)269 void PeerToPeer::removeServer (tJNI_HANDLE jniHandle)
270 {
271     static const char fn [] = "PeerToPeer::removeServer";
272 
273     AutoMutex mutex(mMutex);
274 
275     for (int i = 0; i < sMax; i++)
276     {
277         if ( (mServers[i] != NULL) && (mServers[i]->mJniHandle == jniHandle) )
278         {
279             ALOGD ("%s: server jni_handle: %u;  nfa_handle: 0x%04x; name: %s; index=%d",
280                     fn, jniHandle, mServers[i]->mNfaP2pServerHandle, mServers[i]->mServiceName.c_str(), i);
281 
282             mServers [i] = NULL;
283             return;
284         }
285     }
286     ALOGE ("%s: unknown server jni handle: %u", fn, jniHandle);
287 }
288 
289 
290 /*******************************************************************************
291 **
292 ** Function:        llcpActivatedHandler
293 **
294 ** Description:     Receive LLLCP-activated event from stack.
295 **                  nat: JVM-related data.
296 **                  activated: Event data.
297 **
298 ** Returns:         None
299 **
300 *******************************************************************************/
llcpActivatedHandler(nfc_jni_native_data * nat,tNFA_LLCP_ACTIVATED & activated)301 void PeerToPeer::llcpActivatedHandler (nfc_jni_native_data* nat, tNFA_LLCP_ACTIVATED& activated)
302 {
303     static const char fn [] = "PeerToPeer::llcpActivatedHandler";
304     ALOGD ("%s: enter", fn);
305 
306     //no longer need to receive NDEF message from a tag
307     android::nativeNfcTag_deregisterNdefTypeHandler ();
308 
309     mRemoteWKS = activated.remote_wks;
310 
311     JNIEnv* e = NULL;
312     ScopedAttach attach(nat->vm, &e);
313     if (e == NULL)
314     {
315         ALOGE ("%s: jni env is null", fn);
316         return;
317     }
318 
319     ALOGD ("%s: get object class", fn);
320     ScopedLocalRef<jclass> tag_cls(e, e->GetObjectClass(nat->cached_P2pDevice));
321     if (e->ExceptionCheck()) {
322         e->ExceptionClear();
323         ALOGE ("%s: fail get p2p device", fn);
324         return;
325     }
326 
327     ALOGD ("%s: instantiate", fn);
328     /* New target instance */
329     jmethodID ctor = e->GetMethodID(tag_cls.get(), "<init>", "()V");
330     ScopedLocalRef<jobject> tag(e, e->NewObject(tag_cls.get(), ctor));
331 
332     /* Set P2P Target mode */
333     jfieldID f = e->GetFieldID(tag_cls.get(), "mMode", "I");
334 
335     if (activated.is_initiator == TRUE) {
336         ALOGD ("%s: p2p initiator", fn);
337         e->SetIntField(tag.get(), f, (jint) MODE_P2P_INITIATOR);
338     } else {
339         ALOGD ("%s: p2p target", fn);
340         e->SetIntField(tag.get(), f, (jint) MODE_P2P_TARGET);
341     }
342     /* Set LLCP version */
343     f = e->GetFieldID(tag_cls.get(), "mLlcpVersion", "B");
344     e->SetByteField(tag.get(), f, (jbyte) activated.remote_version);
345 
346     /* Set tag handle */
347     f = e->GetFieldID(tag_cls.get(), "mHandle", "I");
348     e->SetIntField(tag.get(), f, (jint) 0x1234); // ?? This handle is not used for anything
349 
350     if (nat->tag != NULL) {
351         e->DeleteGlobalRef(nat->tag);
352     }
353     nat->tag = e->NewGlobalRef(tag.get());
354 
355     ALOGD ("%s: notify nfc service", fn);
356 
357     /* Notify manager that new a P2P device was found */
358     e->CallVoidMethod(nat->manager, android::gCachedNfcManagerNotifyLlcpLinkActivation, tag.get());
359     if (e->ExceptionCheck()) {
360         e->ExceptionClear();
361         ALOGE ("%s: fail notify", fn);
362     }
363 
364     ALOGD ("%s: exit", fn);
365 }
366 
367 
368 /*******************************************************************************
369 **
370 ** Function:        llcpDeactivatedHandler
371 **
372 ** Description:     Receive LLLCP-deactivated event from stack.
373 **                  nat: JVM-related data.
374 **                  deactivated: Event data.
375 **
376 ** Returns:         None
377 **
378 *******************************************************************************/
llcpDeactivatedHandler(nfc_jni_native_data * nat,tNFA_LLCP_DEACTIVATED &)379 void PeerToPeer::llcpDeactivatedHandler (nfc_jni_native_data* nat, tNFA_LLCP_DEACTIVATED& /*deactivated*/)
380 {
381     static const char fn [] = "PeerToPeer::llcpDeactivatedHandler";
382     ALOGD ("%s: enter", fn);
383 
384     JNIEnv* e = NULL;
385     ScopedAttach attach(nat->vm, &e);
386     if (e == NULL)
387     {
388         ALOGE ("%s: jni env is null", fn);
389         return;
390     }
391 
392     ALOGD ("%s: notify nfc service", fn);
393     /* Notify manager that the LLCP is lost or deactivated */
394     e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyLlcpLinkDeactivated, nat->tag);
395     if (e->ExceptionCheck())
396     {
397         e->ExceptionClear();
398         ALOGE ("%s: fail notify", fn);
399     }
400 
401     //let the tag-reading code handle NDEF data event
402     android::nativeNfcTag_registerNdefTypeHandler ();
403     ALOGD ("%s: exit", fn);
404 }
405 
llcpFirstPacketHandler(nfc_jni_native_data * nat)406 void PeerToPeer::llcpFirstPacketHandler (nfc_jni_native_data* nat)
407 {
408     static const char fn [] = "PeerToPeer::llcpFirstPacketHandler";
409     ALOGD ("%s: enter", fn);
410 
411     JNIEnv* e = NULL;
412     ScopedAttach attach(nat->vm, &e);
413     if (e == NULL)
414     {
415         ALOGE ("%s: jni env is null", fn);
416         return;
417     }
418 
419     ALOGD ("%s: notify nfc service", fn);
420     /* Notify manager that the LLCP is lost or deactivated */
421     e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyLlcpFirstPacketReceived, nat->tag);
422     if (e->ExceptionCheck())
423     {
424         e->ExceptionClear();
425         ALOGE ("%s: fail notify", fn);
426     }
427 
428     ALOGD ("%s: exit", fn);
429 
430 }
431 /*******************************************************************************
432 **
433 ** Function:        accept
434 **
435 ** Description:     Accept a peer's request to connect.
436 **                  serverJniHandle: Server's handle.
437 **                  connJniHandle: Connection handle.
438 **                  maxInfoUnit: Maximum information unit.
439 **                  recvWindow: Receive window size.
440 **
441 ** Returns:         True if ok.
442 **
443 *******************************************************************************/
accept(tJNI_HANDLE serverJniHandle,tJNI_HANDLE connJniHandle,int maxInfoUnit,int recvWindow)444 bool PeerToPeer::accept (tJNI_HANDLE serverJniHandle, tJNI_HANDLE connJniHandle, int maxInfoUnit, int recvWindow)
445 {
446     static const char fn [] = "PeerToPeer::accept";
447     sp<P2pServer> pSrv = NULL;
448 
449     ALOGD ("%s: enter; server jni handle: %u; conn jni handle: %u; maxInfoUnit: %d; recvWindow: %d", fn,
450             serverJniHandle, connJniHandle, maxInfoUnit, recvWindow);
451 
452     mMutex.lock();
453     if ((pSrv = findServerLocked (serverJniHandle)) == NULL)
454     {
455         ALOGE ("%s: unknown server jni handle: %u", fn, serverJniHandle);
456         mMutex.unlock();
457         return (false);
458     }
459     mMutex.unlock();
460 
461     return pSrv->accept(serverJniHandle, connJniHandle, maxInfoUnit, recvWindow);
462 }
463 
464 
465 /*******************************************************************************
466 **
467 ** Function:        deregisterServer
468 **
469 ** Description:     Stop a P2pServer from listening for peer.
470 **
471 ** Returns:         True if ok.
472 **
473 *******************************************************************************/
deregisterServer(tJNI_HANDLE jniHandle)474 bool PeerToPeer::deregisterServer (tJNI_HANDLE jniHandle)
475 {
476     static const char fn [] = "PeerToPeer::deregisterServer";
477     ALOGD ("%s: enter; JNI handle: %u", fn, jniHandle);
478     tNFA_STATUS     nfaStat = NFA_STATUS_FAILED;
479     sp<P2pServer>   pSrv = NULL;
480     bool            isPollingTempStopped = false;
481 
482     mMutex.lock();
483     if ((pSrv = findServerLocked (jniHandle)) == NULL)
484     {
485         ALOGE ("%s: unknown service handle: %u", fn, jniHandle);
486         mMutex.unlock();
487         return (false);
488     }
489     mMutex.unlock();
490     if (isDiscoveryStarted ())
491     {
492         isPollingTempStopped = true;
493         startRfDiscovery (false);
494     }
495 
496     {
497         // Server does not call NFA_P2pDisconnect(), so unblock the accept()
498         SyncEventGuard guard (pSrv->mConnRequestEvent);
499         pSrv->mConnRequestEvent.notifyOne();
500     }
501 
502     nfaStat = NFA_P2pDeregister (pSrv->mNfaP2pServerHandle);
503     if (nfaStat != NFA_STATUS_OK)
504     {
505         ALOGE ("%s: deregister error=0x%X", fn, nfaStat);
506     }
507 
508     removeServer (jniHandle);
509 
510     if (isPollingTempStopped)
511     {
512         startRfDiscovery (true);
513     }
514 
515     ALOGD ("%s: exit", fn);
516     return true;
517 }
518 
519 
520 /*******************************************************************************
521 **
522 ** Function:        createClient
523 **
524 ** Description:     Create a P2pClient object for a new out-bound connection.
525 **                  jniHandle: Connection handle.
526 **                  miu: Maximum information unit.
527 **                  rw: Receive window size.
528 **
529 ** Returns:         True if ok.
530 **
531 *******************************************************************************/
createClient(tJNI_HANDLE jniHandle,UINT16 miu,UINT8 rw)532 bool PeerToPeer::createClient (tJNI_HANDLE jniHandle, UINT16 miu, UINT8 rw)
533 {
534     static const char fn [] = "PeerToPeer::createClient";
535     int i = 0;
536     ALOGD ("%s: enter: jni h: %u  miu: %u  rw: %u", fn, jniHandle, miu, rw);
537 
538     mMutex.lock();
539     sp<P2pClient> client = NULL;
540     for (i = 0; i < sMax; i++)
541     {
542         if (mClients[i] == NULL)
543         {
544             mClients [i] = client = new P2pClient();
545 
546             mClients [i]->mClientConn->mJniHandle   = jniHandle;
547             mClients [i]->mClientConn->mMaxInfoUnit = miu;
548             mClients [i]->mClientConn->mRecvWindow  = rw;
549             break;
550         }
551     }
552     mMutex.unlock();
553 
554     if (client == NULL)
555     {
556         ALOGE ("%s: fail", fn);
557         return (false);
558     }
559 
560     ALOGD ("%s: pClient: 0x%p  assigned for client jniHandle: %u", fn, client.get(), jniHandle);
561 
562     {
563         SyncEventGuard guard (mClients[i]->mRegisteringEvent);
564         NFA_P2pRegisterClient (NFA_P2P_DLINK_TYPE, nfaClientCallback);
565         mClients[i]->mRegisteringEvent.wait(); //wait for NFA_P2P_REG_CLIENT_EVT
566     }
567 
568     if (mClients[i]->mNfaP2pClientHandle != NFA_HANDLE_INVALID)
569     {
570         ALOGD ("%s: exit; new client jniHandle: %u   NFA Handle: 0x%04x", fn, jniHandle, client->mClientConn->mNfaConnHandle);
571         return (true);
572     }
573     else
574     {
575         ALOGE ("%s: FAILED; new client jniHandle: %u   NFA Handle: 0x%04x", fn, jniHandle, client->mClientConn->mNfaConnHandle);
576         removeConn (jniHandle);
577         return (false);
578     }
579 }
580 
581 
582 /*******************************************************************************
583 **
584 ** Function:        removeConn
585 **
586 ** Description:     Free resources related to a connection.
587 **                  jniHandle: Connection handle.
588 **
589 ** Returns:         None
590 **
591 *******************************************************************************/
removeConn(tJNI_HANDLE jniHandle)592 void PeerToPeer::removeConn(tJNI_HANDLE jniHandle)
593 {
594     static const char fn[] = "PeerToPeer::removeConn";
595 
596     AutoMutex mutex(mMutex);
597     // If the connection is a for a client, delete the client itself
598     for (int ii = 0; ii < sMax; ii++)
599     {
600         if ((mClients[ii] != NULL) && (mClients[ii]->mClientConn->mJniHandle == jniHandle))
601         {
602             if (mClients[ii]->mNfaP2pClientHandle != NFA_HANDLE_INVALID)
603                 NFA_P2pDeregister (mClients[ii]->mNfaP2pClientHandle);
604 
605             mClients[ii] = NULL;
606             ALOGD ("%s: deleted client handle: %u  index: %u", fn, jniHandle, ii);
607             return;
608         }
609     }
610 
611     // If the connection is for a server, just delete the connection
612     for (int ii = 0; ii < sMax; ii++)
613     {
614         if (mServers[ii] != NULL)
615         {
616             if (mServers[ii]->removeServerConnection(jniHandle)) {
617                 return;
618             }
619         }
620     }
621 
622     ALOGE ("%s: could not find handle: %u", fn, jniHandle);
623 }
624 
625 
626 /*******************************************************************************
627 **
628 ** Function:        connectConnOriented
629 **
630 ** Description:     Establish a connection-oriented connection to a peer.
631 **                  jniHandle: Connection handle.
632 **                  serviceName: Peer's service name.
633 **
634 ** Returns:         True if ok.
635 **
636 *******************************************************************************/
connectConnOriented(tJNI_HANDLE jniHandle,const char * serviceName)637 bool PeerToPeer::connectConnOriented (tJNI_HANDLE jniHandle, const char* serviceName)
638 {
639     static const char fn [] = "PeerToPeer::connectConnOriented";
640     ALOGD ("%s: enter; h: %u  service name=%s", fn, jniHandle, serviceName);
641     bool stat = createDataLinkConn (jniHandle, serviceName, 0);
642     ALOGD ("%s: exit; h: %u  stat: %u", fn, jniHandle, stat);
643     return stat;
644 }
645 
646 
647 /*******************************************************************************
648 **
649 ** Function:        connectConnOriented
650 **
651 ** Description:     Establish a connection-oriented connection to a peer.
652 **                  jniHandle: Connection handle.
653 **                  destinationSap: Peer's service access point.
654 **
655 ** Returns:         True if ok.
656 **
657 *******************************************************************************/
connectConnOriented(tJNI_HANDLE jniHandle,UINT8 destinationSap)658 bool PeerToPeer::connectConnOriented (tJNI_HANDLE jniHandle, UINT8 destinationSap)
659 {
660     static const char fn [] = "PeerToPeer::connectConnOriented";
661     ALOGD ("%s: enter; h: %u  dest sap: 0x%X", fn, jniHandle, destinationSap);
662     bool stat = createDataLinkConn (jniHandle, NULL, destinationSap);
663     ALOGD ("%s: exit; h: %u  stat: %u", fn, jniHandle, stat);
664     return stat;
665 }
666 
667 
668 /*******************************************************************************
669 **
670 ** Function:        createDataLinkConn
671 **
672 ** Description:     Establish a connection-oriented connection to a peer.
673 **                  jniHandle: Connection handle.
674 **                  serviceName: Peer's service name.
675 **                  destinationSap: Peer's service access point.
676 **
677 ** Returns:         True if ok.
678 **
679 *******************************************************************************/
createDataLinkConn(tJNI_HANDLE jniHandle,const char * serviceName,UINT8 destinationSap)680 bool PeerToPeer::createDataLinkConn (tJNI_HANDLE jniHandle, const char* serviceName, UINT8 destinationSap)
681 {
682     static const char fn [] = "PeerToPeer::createDataLinkConn";
683     ALOGD ("%s: enter", fn);
684     tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
685     sp<P2pClient>   pClient = NULL;
686 
687     if ((pClient = findClient (jniHandle)) == NULL)
688     {
689         ALOGE ("%s: can't find client, JNI handle: %u", fn, jniHandle);
690         return (false);
691     }
692 
693     {
694         SyncEventGuard guard (pClient->mConnectingEvent);
695         pClient->mIsConnecting = true;
696 
697         if (serviceName)
698             nfaStat = NFA_P2pConnectByName (pClient->mNfaP2pClientHandle,
699                     const_cast<char*>(serviceName), pClient->mClientConn->mMaxInfoUnit,
700                     pClient->mClientConn->mRecvWindow);
701         else if (destinationSap)
702             nfaStat = NFA_P2pConnectBySap (pClient->mNfaP2pClientHandle, destinationSap,
703                     pClient->mClientConn->mMaxInfoUnit, pClient->mClientConn->mRecvWindow);
704         if (nfaStat == NFA_STATUS_OK)
705         {
706             ALOGD ("%s: wait for connected event  mConnectingEvent: 0x%p", fn, pClient.get());
707             pClient->mConnectingEvent.wait();
708         }
709     }
710 
711     if (nfaStat == NFA_STATUS_OK)
712     {
713         if (pClient->mClientConn->mNfaConnHandle == NFA_HANDLE_INVALID)
714         {
715             removeConn (jniHandle);
716             nfaStat = NFA_STATUS_FAILED;
717         }
718         else
719             pClient->mIsConnecting = false;
720     }
721     else
722     {
723         removeConn (jniHandle);
724         ALOGE ("%s: fail; error=0x%X", fn, nfaStat);
725     }
726 
727     ALOGD ("%s: exit", fn);
728     return nfaStat == NFA_STATUS_OK;
729 }
730 
731 
732 /*******************************************************************************
733 **
734 ** Function:        findClient
735 **
736 ** Description:     Find a PeerToPeer object with a client connection handle.
737 **                  nfaConnHandle: Connection handle.
738 **
739 ** Returns:         PeerToPeer object.
740 **
741 *******************************************************************************/
findClient(tNFA_HANDLE nfaConnHandle)742 sp<P2pClient> PeerToPeer::findClient (tNFA_HANDLE nfaConnHandle)
743 {
744     AutoMutex mutex(mMutex);
745     for (int i = 0; i < sMax; i++)
746     {
747         if ((mClients[i] != NULL) && (mClients[i]->mNfaP2pClientHandle == nfaConnHandle))
748             return (mClients[i]);
749     }
750     return (NULL);
751 }
752 
753 
754 /*******************************************************************************
755 **
756 ** Function:        findClient
757 **
758 ** Description:     Find a PeerToPeer object with a client connection handle.
759 **                  jniHandle: Connection handle.
760 **
761 ** Returns:         PeerToPeer object.
762 **
763 *******************************************************************************/
findClient(tJNI_HANDLE jniHandle)764 sp<P2pClient> PeerToPeer::findClient (tJNI_HANDLE jniHandle)
765 {
766     AutoMutex mutex(mMutex);
767     for (int i = 0; i < sMax; i++)
768     {
769         if ((mClients[i] != NULL) && (mClients[i]->mClientConn->mJniHandle == jniHandle))
770             return (mClients[i]);
771     }
772     return (NULL);
773 }
774 
775 
776 /*******************************************************************************
777 **
778 ** Function:        findClientCon
779 **
780 ** Description:     Find a PeerToPeer object with a client connection handle.
781 **                  nfaConnHandle: Connection handle.
782 **
783 ** Returns:         PeerToPeer object.
784 **
785 *******************************************************************************/
findClientCon(tNFA_HANDLE nfaConnHandle)786 sp<P2pClient> PeerToPeer::findClientCon (tNFA_HANDLE nfaConnHandle)
787 {
788     AutoMutex mutex(mMutex);
789     for (int i = 0; i < sMax; i++)
790     {
791         if ((mClients[i] != NULL) && (mClients[i]->mClientConn->mNfaConnHandle == nfaConnHandle))
792             return (mClients[i]);
793     }
794     return (NULL);
795 }
796 
797 
798 /*******************************************************************************
799 **
800 ** Function:        findConnection
801 **
802 ** Description:     Find a PeerToPeer object with a connection handle.
803 **                  nfaConnHandle: Connection handle.
804 **
805 ** Returns:         PeerToPeer object.
806 **
807 *******************************************************************************/
findConnection(tNFA_HANDLE nfaConnHandle)808 sp<NfaConn> PeerToPeer::findConnection (tNFA_HANDLE nfaConnHandle)
809 {
810     AutoMutex mutex(mMutex);
811     // First, look through all the client control blocks
812     for (int ii = 0; ii < sMax; ii++)
813     {
814         if ( (mClients[ii] != NULL)
815            && (mClients[ii]->mClientConn->mNfaConnHandle == nfaConnHandle) ) {
816             return mClients[ii]->mClientConn;
817         }
818     }
819 
820     // Not found yet. Look through all the server control blocks
821     for (int ii = 0; ii < sMax; ii++)
822     {
823         if (mServers[ii] != NULL)
824         {
825             sp<NfaConn> conn = mServers[ii]->findServerConnection(nfaConnHandle);
826             if (conn != NULL) {
827                 return conn;
828             }
829         }
830     }
831 
832     // Not found...
833     return NULL;
834 }
835 
836 
837 /*******************************************************************************
838 **
839 ** Function:        findConnection
840 **
841 ** Description:     Find a PeerToPeer object with a connection handle.
842 **                  jniHandle: Connection handle.
843 **
844 ** Returns:         PeerToPeer object.
845 **
846 *******************************************************************************/
findConnection(tJNI_HANDLE jniHandle)847 sp<NfaConn> PeerToPeer::findConnection (tJNI_HANDLE jniHandle)
848 {
849     AutoMutex mutex(mMutex);
850     // First, look through all the client control blocks
851     for (int ii = 0; ii < sMax; ii++)
852     {
853         if ( (mClients[ii] != NULL)
854           && (mClients[ii]->mClientConn->mJniHandle == jniHandle) ) {
855             return mClients[ii]->mClientConn;
856         }
857     }
858 
859     // Not found yet. Look through all the server control blocks
860     for (int ii = 0; ii < sMax; ii++)
861     {
862         if (mServers[ii] != NULL)
863         {
864             sp<NfaConn> conn = mServers[ii]->findServerConnection(jniHandle);
865             if (conn != NULL) {
866                 return conn;
867             }
868         }
869     }
870 
871     // Not found...
872     return NULL;
873 }
874 
875 
876 /*******************************************************************************
877 **
878 ** Function:        send
879 **
880 ** Description:     Send data to peer.
881 **                  jniHandle: Handle of connection.
882 **                  buffer: Buffer of data.
883 **                  bufferLen: Length of data.
884 **
885 ** Returns:         True if ok.
886 **
887 *******************************************************************************/
send(tJNI_HANDLE jniHandle,UINT8 * buffer,UINT16 bufferLen)888 bool PeerToPeer::send (tJNI_HANDLE jniHandle, UINT8 *buffer, UINT16 bufferLen)
889 {
890     static const char fn [] = "PeerToPeer::send";
891     tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
892     sp<NfaConn>     pConn =  NULL;
893 
894     if ((pConn = findConnection (jniHandle)) == NULL)
895     {
896         ALOGE ("%s: can't find connection handle: %u", fn, jniHandle);
897         return (false);
898     }
899 
900     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: send data; jniHandle: %u  nfaHandle: 0x%04X",
901             fn, pConn->mJniHandle, pConn->mNfaConnHandle);
902 
903     while (true)
904     {
905         SyncEventGuard guard (pConn->mCongEvent);
906         nfaStat = NFA_P2pSendData (pConn->mNfaConnHandle, bufferLen, buffer);
907         if (nfaStat == NFA_STATUS_CONGESTED)
908             pConn->mCongEvent.wait (); //wait for NFA_P2P_CONGEST_EVT
909         else
910             break;
911 
912         if (pConn->mNfaConnHandle == NFA_HANDLE_INVALID) //peer already disconnected
913         {
914             ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: peer disconnected", fn);
915             return (false);
916         }
917     }
918 
919     if (nfaStat == NFA_STATUS_OK)
920         ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit OK; JNI handle: %u  NFA Handle: 0x%04x", fn, jniHandle, pConn->mNfaConnHandle);
921     else
922         ALOGE ("%s: Data not sent; JNI handle: %u  NFA Handle: 0x%04x  error: 0x%04x",
923               fn, jniHandle, pConn->mNfaConnHandle, nfaStat);
924 
925     return nfaStat == NFA_STATUS_OK;
926 }
927 
928 
929 /*******************************************************************************
930 **
931 ** Function:        receive
932 **
933 ** Description:     Receive data from peer.
934 **                  jniHandle: Handle of connection.
935 **                  buffer: Buffer to store data.
936 **                  bufferLen: Max length of buffer.
937 **                  actualLen: Actual length received.
938 **
939 ** Returns:         True if ok.
940 **
941 *******************************************************************************/
receive(tJNI_HANDLE jniHandle,UINT8 * buffer,UINT16 bufferLen,UINT16 & actualLen)942 bool PeerToPeer::receive (tJNI_HANDLE jniHandle, UINT8* buffer, UINT16 bufferLen, UINT16& actualLen)
943 {
944     static const char fn [] = "PeerToPeer::receive";
945     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; jniHandle: %u  bufferLen: %u", fn, jniHandle, bufferLen);
946     sp<NfaConn> pConn = NULL;
947     tNFA_STATUS stat = NFA_STATUS_FAILED;
948     UINT32 actualDataLen2 = 0;
949     BOOLEAN isMoreData = TRUE;
950     bool retVal = false;
951 
952     if ((pConn = findConnection (jniHandle)) == NULL)
953     {
954         ALOGE ("%s: can't find connection handle: %u", fn, jniHandle);
955         return (false);
956     }
957 
958     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: jniHandle: %u  nfaHandle: 0x%04X  buf len=%u", fn, pConn->mJniHandle, pConn->mNfaConnHandle, bufferLen);
959 
960     while (pConn->mNfaConnHandle != NFA_HANDLE_INVALID)
961     {
962         //NFA_P2pReadData() is synchronous
963         stat = NFA_P2pReadData (pConn->mNfaConnHandle, bufferLen, &actualDataLen2, buffer, &isMoreData);
964         if ((stat == NFA_STATUS_OK) && (actualDataLen2 > 0)) //received some data
965         {
966             actualLen = (UINT16) actualDataLen2;
967             retVal = true;
968             break;
969         }
970         ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: waiting for data...", fn);
971         {
972             SyncEventGuard guard (pConn->mReadEvent);
973             pConn->mReadEvent.wait();
974         }
975     } //while
976 
977     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit; nfa h: 0x%X  ok: %u  actual len: %u", fn, pConn->mNfaConnHandle, retVal, actualLen);
978     return retVal;
979 }
980 
981 
982 /*******************************************************************************
983 **
984 ** Function:        disconnectConnOriented
985 **
986 ** Description:     Disconnect a connection-oriented connection with peer.
987 **                  jniHandle: Handle of connection.
988 **
989 ** Returns:         True if ok.
990 **
991 *******************************************************************************/
disconnectConnOriented(tJNI_HANDLE jniHandle)992 bool PeerToPeer::disconnectConnOriented (tJNI_HANDLE jniHandle)
993 {
994     static const char fn [] = "PeerToPeer::disconnectConnOriented";
995     tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
996     sp<P2pClient>   pClient = NULL;
997     sp<NfaConn>     pConn = NULL;
998 
999     ALOGD ("%s: enter; jni handle: %u", fn, jniHandle);
1000 
1001     if ((pConn = findConnection(jniHandle)) == NULL)
1002     {
1003         ALOGE ("%s: can't find connection handle: %u", fn, jniHandle);
1004         return (false);
1005     }
1006 
1007     // If this is a client, he may not be connected yet, so unblock him just in case
1008     if ( ((pClient = findClient(jniHandle)) != NULL) && (pClient->mIsConnecting) )
1009     {
1010         SyncEventGuard guard (pClient->mConnectingEvent);
1011         pClient->mConnectingEvent.notifyOne();
1012         return (true);
1013     }
1014 
1015     {
1016         SyncEventGuard guard1 (pConn->mCongEvent);
1017         pConn->mCongEvent.notifyOne (); //unblock send() if congested
1018     }
1019     {
1020         SyncEventGuard guard2 (pConn->mReadEvent);
1021         pConn->mReadEvent.notifyOne (); //unblock receive()
1022     }
1023 
1024     if (pConn->mNfaConnHandle != NFA_HANDLE_INVALID)
1025     {
1026         ALOGD ("%s: try disconn nfa h=0x%04X", fn, pConn->mNfaConnHandle);
1027         SyncEventGuard guard (pConn->mDisconnectingEvent);
1028         nfaStat = NFA_P2pDisconnect (pConn->mNfaConnHandle, FALSE);
1029 
1030         if (nfaStat != NFA_STATUS_OK)
1031             ALOGE ("%s: fail p2p disconnect", fn);
1032         else
1033             pConn->mDisconnectingEvent.wait();
1034     }
1035 
1036     mDisconnectMutex.lock ();
1037     removeConn (jniHandle);
1038     mDisconnectMutex.unlock ();
1039 
1040     ALOGD ("%s: exit; jni handle: %u", fn, jniHandle);
1041     return nfaStat == NFA_STATUS_OK;
1042 }
1043 
1044 
1045 /*******************************************************************************
1046 **
1047 ** Function:        getRemoteMaxInfoUnit
1048 **
1049 ** Description:     Get peer's max information unit.
1050 **                  jniHandle: Handle of the connection.
1051 **
1052 ** Returns:         Peer's max information unit.
1053 **
1054 *******************************************************************************/
getRemoteMaxInfoUnit(tJNI_HANDLE jniHandle)1055 UINT16 PeerToPeer::getRemoteMaxInfoUnit (tJNI_HANDLE jniHandle)
1056 {
1057     static const char fn [] = "PeerToPeer::getRemoteMaxInfoUnit";
1058     sp<NfaConn> pConn = NULL;
1059 
1060     if ((pConn = findConnection(jniHandle)) == NULL)
1061     {
1062         ALOGE ("%s: can't find client  jniHandle: %u", fn, jniHandle);
1063         return 0;
1064     }
1065     ALOGD ("%s: jniHandle: %u   MIU: %u", fn, jniHandle, pConn->mRemoteMaxInfoUnit);
1066     return (pConn->mRemoteMaxInfoUnit);
1067 }
1068 
1069 
1070 /*******************************************************************************
1071 **
1072 ** Function:        getRemoteRecvWindow
1073 **
1074 ** Description:     Get peer's receive window size.
1075 **                  jniHandle: Handle of the connection.
1076 **
1077 ** Returns:         Peer's receive window size.
1078 **
1079 *******************************************************************************/
getRemoteRecvWindow(tJNI_HANDLE jniHandle)1080 UINT8 PeerToPeer::getRemoteRecvWindow (tJNI_HANDLE jniHandle)
1081 {
1082     static const char fn [] = "PeerToPeer::getRemoteRecvWindow";
1083     ALOGD ("%s: client jni handle: %u", fn, jniHandle);
1084     sp<NfaConn> pConn = NULL;
1085 
1086     if ((pConn = findConnection(jniHandle)) == NULL)
1087     {
1088         ALOGE ("%s: can't find client", fn);
1089         return 0;
1090     }
1091     return pConn->mRemoteRecvWindow;
1092 }
1093 
1094 /*******************************************************************************
1095 **
1096 ** Function:        setP2pListenMask
1097 **
1098 ** Description:     Sets the p2p listen technology mask.
1099 **                  p2pListenMask: the p2p listen mask to be set?
1100 **
1101 ** Returns:         None
1102 **
1103 *******************************************************************************/
setP2pListenMask(tNFA_TECHNOLOGY_MASK p2pListenMask)1104 void PeerToPeer::setP2pListenMask (tNFA_TECHNOLOGY_MASK p2pListenMask) {
1105     mP2pListenTechMask = p2pListenMask;
1106 }
1107 
1108 
1109 /*******************************************************************************
1110 **
1111 ** Function:        getP2pListenMask
1112 **
1113 ** Description:     Get the set of technologies that P2P is listening.
1114 **
1115 ** Returns:         Set of technologies.
1116 **
1117 *******************************************************************************/
getP2pListenMask()1118 tNFA_TECHNOLOGY_MASK PeerToPeer::getP2pListenMask ()
1119 {
1120     return mP2pListenTechMask;
1121 }
1122 
1123 
1124 /*******************************************************************************
1125 **
1126 ** Function:        resetP2pListenMask
1127 **
1128 ** Description:     Reset the p2p listen technology mask to initial value.
1129 **
1130 ** Returns:         None.
1131 **
1132 *******************************************************************************/
resetP2pListenMask()1133 void PeerToPeer::resetP2pListenMask ()
1134 {
1135     unsigned long num = 0;
1136     mP2pListenTechMask = NFA_TECHNOLOGY_MASK_A
1137                         | NFA_TECHNOLOGY_MASK_F
1138                         | NFA_TECHNOLOGY_MASK_A_ACTIVE
1139                         | NFA_TECHNOLOGY_MASK_F_ACTIVE;
1140     if (GetNumValue ("P2P_LISTEN_TECH_MASK", &num, sizeof (num)))
1141         mP2pListenTechMask = num;
1142 }
1143 
1144 
1145 /*******************************************************************************
1146 **
1147 ** Function:        enableP2pListening
1148 **
1149 ** Description:     Start/stop polling/listening to peer that supports P2P.
1150 **                  isEnable: Is enable polling/listening?
1151 **
1152 ** Returns:         None
1153 **
1154 *******************************************************************************/
enableP2pListening(bool isEnable)1155 void PeerToPeer::enableP2pListening (bool isEnable)
1156 {
1157     static const char    fn []   = "PeerToPeer::enableP2pListening";
1158     tNFA_STATUS          nfaStat = NFA_STATUS_FAILED;
1159 
1160     ALOGD ("%s: enter isEnable: %u  mIsP2pListening: %u", fn, isEnable, mIsP2pListening);
1161 
1162     // If request to enable P2P listening, and we were not already listening
1163     if ( (isEnable == true) && (mIsP2pListening == false) && (mP2pListenTechMask != 0) )
1164     {
1165         SyncEventGuard guard (mSetTechEvent);
1166         if ((nfaStat = NFA_SetP2pListenTech (mP2pListenTechMask)) == NFA_STATUS_OK)
1167         {
1168             mSetTechEvent.wait ();
1169             mIsP2pListening = true;
1170         }
1171         else
1172             ALOGE ("%s: fail enable listen; error=0x%X", fn, nfaStat);
1173     }
1174     else if ( (isEnable == false) && (mIsP2pListening == true) )
1175     {
1176         SyncEventGuard guard (mSetTechEvent);
1177         // Request to disable P2P listening, check if it was enabled
1178         if ((nfaStat = NFA_SetP2pListenTech(0)) == NFA_STATUS_OK)
1179         {
1180             mSetTechEvent.wait ();
1181             mIsP2pListening = false;
1182         }
1183         else
1184             ALOGE ("%s: fail disable listen; error=0x%X", fn, nfaStat);
1185     }
1186     ALOGD ("%s: exit; mIsP2pListening: %u", fn, mIsP2pListening);
1187 }
1188 
1189 
1190 /*******************************************************************************
1191 **
1192 ** Function:        handleNfcOnOff
1193 **
1194 ** Description:     Handle events related to turning NFC on/off by the user.
1195 **                  isOn: Is NFC turning on?
1196 **
1197 ** Returns:         None
1198 **
1199 *******************************************************************************/
handleNfcOnOff(bool isOn)1200 void PeerToPeer::handleNfcOnOff (bool isOn)
1201 {
1202     static const char fn [] = "PeerToPeer::handleNfcOnOff";
1203     ALOGD ("%s: enter; is on=%u", fn, isOn);
1204 
1205     mIsP2pListening = false;            // In both cases, P2P will not be listening
1206 
1207     AutoMutex mutex(mMutex);
1208     if (isOn)
1209     {
1210         // Start with no clients or servers
1211         memset (mServers, 0, sizeof(mServers));
1212         memset (mClients, 0, sizeof(mClients));
1213     }
1214     else
1215     {
1216         // Disconnect through all the clients
1217         for (int ii = 0; ii < sMax; ii++)
1218         {
1219             if (mClients[ii] != NULL)
1220             {
1221                 if (mClients[ii]->mClientConn->mNfaConnHandle == NFA_HANDLE_INVALID)
1222                 {
1223                     SyncEventGuard guard (mClients[ii]->mConnectingEvent);
1224                     mClients[ii]->mConnectingEvent.notifyOne();
1225                 }
1226                 else
1227                 {
1228                     mClients[ii]->mClientConn->mNfaConnHandle = NFA_HANDLE_INVALID;
1229                     {
1230                         SyncEventGuard guard1 (mClients[ii]->mClientConn->mCongEvent);
1231                         mClients[ii]->mClientConn->mCongEvent.notifyOne (); //unblock send()
1232                     }
1233                     {
1234                         SyncEventGuard guard2 (mClients[ii]->mClientConn->mReadEvent);
1235                         mClients[ii]->mClientConn->mReadEvent.notifyOne (); //unblock receive()
1236                     }
1237                 }
1238             }
1239         } //loop
1240 
1241         // Now look through all the server control blocks
1242         for (int ii = 0; ii < sMax; ii++)
1243         {
1244             if (mServers[ii] != NULL)
1245             {
1246                 mServers[ii]->unblockAll();
1247             }
1248         } //loop
1249 
1250     }
1251     ALOGD ("%s: exit", fn);
1252 }
1253 
1254 
1255 /*******************************************************************************
1256 **
1257 ** Function:        nfaServerCallback
1258 **
1259 ** Description:     Receive LLCP-related events from the stack.
1260 **                  p2pEvent: Event code.
1261 **                  eventData: Event data.
1262 **
1263 ** Returns:         None
1264 **
1265 *******************************************************************************/
nfaServerCallback(tNFA_P2P_EVT p2pEvent,tNFA_P2P_EVT_DATA * eventData)1266 void PeerToPeer::nfaServerCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* eventData)
1267 {
1268     static const char fn [] = "PeerToPeer::nfaServerCallback";
1269     sp<P2pServer>   pSrv = NULL;
1270     sp<NfaConn>     pConn = NULL;
1271 
1272     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; event=0x%X", fn, p2pEvent);
1273 
1274     switch (p2pEvent)
1275     {
1276     case NFA_P2P_REG_SERVER_EVT:  // NFA_P2pRegisterServer() has started to listen
1277         ALOGD ("%s: NFA_P2P_REG_SERVER_EVT; handle: 0x%04x; service sap=0x%02x  name: %s", fn,
1278               eventData->reg_server.server_handle, eventData->reg_server.server_sap, eventData->reg_server.service_name);
1279 
1280         sP2p.mMutex.lock();
1281         pSrv = sP2p.findServerLocked(eventData->reg_server.service_name);
1282         sP2p.mMutex.unlock();
1283         if (pSrv == NULL)
1284         {
1285             ALOGE ("%s: NFA_P2P_REG_SERVER_EVT for unknown service: %s", fn, eventData->reg_server.service_name);
1286         }
1287         else
1288         {
1289             SyncEventGuard guard (pSrv->mRegServerEvent);
1290             pSrv->mNfaP2pServerHandle = eventData->reg_server.server_handle;
1291             pSrv->mRegServerEvent.notifyOne(); //unblock registerServer()
1292         }
1293         break;
1294 
1295     case NFA_P2P_ACTIVATED_EVT: //remote device has activated
1296         ALOGD ("%s: NFA_P2P_ACTIVATED_EVT; handle: 0x%04x", fn, eventData->activated.handle);
1297         break;
1298 
1299     case NFA_P2P_DEACTIVATED_EVT:
1300         ALOGD ("%s: NFA_P2P_DEACTIVATED_EVT; handle: 0x%04x", fn, eventData->activated.handle);
1301         break;
1302 
1303     case NFA_P2P_CONN_REQ_EVT:
1304         ALOGD ("%s: NFA_P2P_CONN_REQ_EVT; nfa server h=0x%04x; nfa conn h=0x%04x; remote sap=0x%02x", fn,
1305                 eventData->conn_req.server_handle, eventData->conn_req.conn_handle, eventData->conn_req.remote_sap);
1306 
1307         sP2p.mMutex.lock();
1308         pSrv = sP2p.findServerLocked(eventData->conn_req.server_handle);
1309         sP2p.mMutex.unlock();
1310         if (pSrv == NULL)
1311         {
1312             ALOGE ("%s: NFA_P2P_CONN_REQ_EVT; unknown server h", fn);
1313             return;
1314         }
1315         ALOGD ("%s: NFA_P2P_CONN_REQ_EVT; server jni h=%u", fn, pSrv->mJniHandle);
1316 
1317         // Look for a connection block that is waiting (handle invalid)
1318         if ((pConn = pSrv->findServerConnection((tNFA_HANDLE) NFA_HANDLE_INVALID)) == NULL)
1319         {
1320             ALOGE ("%s: NFA_P2P_CONN_REQ_EVT; server not listening", fn);
1321         }
1322         else
1323         {
1324             SyncEventGuard guard (pSrv->mConnRequestEvent);
1325             pConn->mNfaConnHandle = eventData->conn_req.conn_handle;
1326             pConn->mRemoteMaxInfoUnit = eventData->conn_req.remote_miu;
1327             pConn->mRemoteRecvWindow = eventData->conn_req.remote_rw;
1328             ALOGD ("%s: NFA_P2P_CONN_REQ_EVT; server jni h=%u; conn jni h=%u; notify conn req", fn, pSrv->mJniHandle, pConn->mJniHandle);
1329             pSrv->mConnRequestEvent.notifyOne(); //unblock accept()
1330         }
1331         break;
1332 
1333     case NFA_P2P_CONNECTED_EVT:
1334         ALOGD ("%s: NFA_P2P_CONNECTED_EVT; h=0x%x  remote sap=0x%X", fn,
1335                 eventData->connected.client_handle, eventData->connected.remote_sap);
1336         break;
1337 
1338     case NFA_P2P_DISC_EVT:
1339         ALOGD ("%s: NFA_P2P_DISC_EVT; h=0x%04x; reason=0x%X", fn, eventData->disc.handle, eventData->disc.reason);
1340         // Look for the connection block
1341         if ((pConn = sP2p.findConnection(eventData->disc.handle)) == NULL)
1342         {
1343             ALOGE ("%s: NFA_P2P_DISC_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->disc.handle);
1344         }
1345         else
1346         {
1347             sP2p.mDisconnectMutex.lock ();
1348             pConn->mNfaConnHandle = NFA_HANDLE_INVALID;
1349             {
1350                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard disconn event", fn);
1351                 SyncEventGuard guard3 (pConn->mDisconnectingEvent);
1352                 pConn->mDisconnectingEvent.notifyOne ();
1353                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified disconn event", fn);
1354             }
1355             {
1356                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard congest event", fn);
1357                 SyncEventGuard guard1 (pConn->mCongEvent);
1358                 pConn->mCongEvent.notifyOne (); //unblock write (if congested)
1359                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified congest event", fn);
1360             }
1361             {
1362                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard read event", fn);
1363                 SyncEventGuard guard2 (pConn->mReadEvent);
1364                 pConn->mReadEvent.notifyOne (); //unblock receive()
1365                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified read event", fn);
1366             }
1367             sP2p.mDisconnectMutex.unlock ();
1368         }
1369         break;
1370 
1371     case NFA_P2P_DATA_EVT:
1372         // Look for the connection block
1373         if ((pConn = sP2p.findConnection(eventData->data.handle)) == NULL)
1374         {
1375             ALOGE ("%s: NFA_P2P_DATA_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->data.handle);
1376         }
1377         else
1378         {
1379             ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: NFA_P2P_DATA_EVT; h=0x%X; remote sap=0x%X", fn,
1380                     eventData->data.handle, eventData->data.remote_sap);
1381             SyncEventGuard guard (pConn->mReadEvent);
1382             pConn->mReadEvent.notifyOne();
1383         }
1384         break;
1385 
1386     case NFA_P2P_CONGEST_EVT:
1387         // Look for the connection block
1388         if ((pConn = sP2p.findConnection(eventData->congest.handle)) == NULL)
1389         {
1390             ALOGE ("%s: NFA_P2P_CONGEST_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->congest.handle);
1391         }
1392         else
1393         {
1394             ALOGD ("%s: NFA_P2P_CONGEST_EVT; nfa handle: 0x%04x  congested: %u", fn,
1395                     eventData->congest.handle, eventData->congest.is_congested);
1396             if (eventData->congest.is_congested == FALSE)
1397             {
1398                 SyncEventGuard guard (pConn->mCongEvent);
1399                 pConn->mCongEvent.notifyOne();
1400             }
1401         }
1402         break;
1403 
1404     default:
1405         ALOGE ("%s: unknown event 0x%X ????", fn, p2pEvent);
1406         break;
1407     }
1408     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: exit", fn);
1409 }
1410 
1411 
1412 /*******************************************************************************
1413 **
1414 ** Function:        nfaClientCallback
1415 **
1416 ** Description:     Receive LLCP-related events from the stack.
1417 **                  p2pEvent: Event code.
1418 **                  eventData: Event data.
1419 **
1420 ** Returns:         None
1421 **
1422 *******************************************************************************/
nfaClientCallback(tNFA_P2P_EVT p2pEvent,tNFA_P2P_EVT_DATA * eventData)1423 void PeerToPeer::nfaClientCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* eventData)
1424 {
1425     static const char fn [] = "PeerToPeer::nfaClientCallback";
1426     sp<NfaConn>     pConn = NULL;
1427     sp<P2pClient>   pClient = NULL;
1428 
1429     ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: enter; event=%u", fn, p2pEvent);
1430 
1431     switch (p2pEvent)
1432     {
1433     case NFA_P2P_REG_CLIENT_EVT:
1434         // Look for a client that is trying to register
1435         if ((pClient = sP2p.findClient ((tNFA_HANDLE)NFA_HANDLE_INVALID)) == NULL)
1436         {
1437             ALOGE ("%s: NFA_P2P_REG_CLIENT_EVT: can't find waiting client", fn);
1438         }
1439         else
1440         {
1441             ALOGD ("%s: NFA_P2P_REG_CLIENT_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn, eventData->reg_client.client_handle, pClient.get());
1442 
1443             SyncEventGuard guard (pClient->mRegisteringEvent);
1444             pClient->mNfaP2pClientHandle = eventData->reg_client.client_handle;
1445             pClient->mRegisteringEvent.notifyOne();
1446         }
1447         break;
1448 
1449     case NFA_P2P_ACTIVATED_EVT:
1450         // Look for a client that is trying to register
1451         if ((pClient = sP2p.findClient (eventData->activated.handle)) == NULL)
1452         {
1453             ALOGE ("%s: NFA_P2P_ACTIVATED_EVT: can't find client", fn);
1454         }
1455         else
1456         {
1457             ALOGD ("%s: NFA_P2P_ACTIVATED_EVT; Conn Handle: 0x%04x, pClient: 0x%p", fn, eventData->activated.handle, pClient.get());
1458         }
1459         break;
1460 
1461     case NFA_P2P_DEACTIVATED_EVT:
1462         ALOGD ("%s: NFA_P2P_DEACTIVATED_EVT: conn handle: 0x%X", fn, eventData->deactivated.handle);
1463         break;
1464 
1465     case NFA_P2P_CONNECTED_EVT:
1466         // Look for the client that is trying to connect
1467         if ((pClient = sP2p.findClient (eventData->connected.client_handle)) == NULL)
1468         {
1469             ALOGE ("%s: NFA_P2P_CONNECTED_EVT: can't find client: 0x%04x", fn, eventData->connected.client_handle);
1470         }
1471         else
1472         {
1473             ALOGD ("%s: NFA_P2P_CONNECTED_EVT; client_handle=0x%04x  conn_handle: 0x%04x  remote sap=0x%X  pClient: 0x%p", fn,
1474                     eventData->connected.client_handle, eventData->connected.conn_handle, eventData->connected.remote_sap, pClient.get());
1475 
1476             SyncEventGuard guard (pClient->mConnectingEvent);
1477             pClient->mClientConn->mNfaConnHandle     = eventData->connected.conn_handle;
1478             pClient->mClientConn->mRemoteMaxInfoUnit = eventData->connected.remote_miu;
1479             pClient->mClientConn->mRemoteRecvWindow  = eventData->connected.remote_rw;
1480             pClient->mConnectingEvent.notifyOne(); //unblock createDataLinkConn()
1481         }
1482         break;
1483 
1484     case NFA_P2P_DISC_EVT:
1485         ALOGD ("%s: NFA_P2P_DISC_EVT; h=0x%04x; reason=0x%X", fn, eventData->disc.handle, eventData->disc.reason);
1486         // Look for the connection block
1487         if ((pConn = sP2p.findConnection(eventData->disc.handle)) == NULL)
1488         {
1489             // If no connection, may be a client that is trying to connect
1490             if ((pClient = sP2p.findClient (eventData->disc.handle)) == NULL)
1491             {
1492                 ALOGE ("%s: NFA_P2P_DISC_EVT: can't find client for NFA handle: 0x%04x", fn, eventData->disc.handle);
1493                 return;
1494             }
1495             // Unblock createDataLinkConn()
1496             SyncEventGuard guard (pClient->mConnectingEvent);
1497             pClient->mConnectingEvent.notifyOne();
1498         }
1499         else
1500         {
1501             sP2p.mDisconnectMutex.lock ();
1502             pConn->mNfaConnHandle = NFA_HANDLE_INVALID;
1503             {
1504                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard disconn event", fn);
1505                 SyncEventGuard guard3 (pConn->mDisconnectingEvent);
1506                 pConn->mDisconnectingEvent.notifyOne ();
1507                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified disconn event", fn);
1508             }
1509             {
1510                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard congest event", fn);
1511                 SyncEventGuard guard1 (pConn->mCongEvent);
1512                 pConn->mCongEvent.notifyOne(); //unblock write (if congested)
1513                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified congest event", fn);
1514             }
1515             {
1516                 ALOGD ("%s: NFA_P2P_DISC_EVT; try guard read event", fn);
1517                 SyncEventGuard guard2 (pConn->mReadEvent);
1518                 pConn->mReadEvent.notifyOne(); //unblock receive()
1519                 ALOGD ("%s: NFA_P2P_DISC_EVT; notified read event", fn);
1520             }
1521             sP2p.mDisconnectMutex.unlock ();
1522         }
1523         break;
1524 
1525     case NFA_P2P_DATA_EVT:
1526         // Look for the connection block
1527         if ((pConn = sP2p.findConnection(eventData->data.handle)) == NULL)
1528         {
1529             ALOGE ("%s: NFA_P2P_DATA_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->data.handle);
1530         }
1531         else
1532         {
1533             ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: NFA_P2P_DATA_EVT; h=0x%X; remote sap=0x%X", fn,
1534                     eventData->data.handle, eventData->data.remote_sap);
1535             SyncEventGuard guard (pConn->mReadEvent);
1536             pConn->mReadEvent.notifyOne();
1537         }
1538         break;
1539 
1540     case NFA_P2P_CONGEST_EVT:
1541         // Look for the connection block
1542         if ((pConn = sP2p.findConnection(eventData->congest.handle)) == NULL)
1543         {
1544             ALOGE ("%s: NFA_P2P_CONGEST_EVT: can't find conn for NFA handle: 0x%04x", fn, eventData->congest.handle);
1545         }
1546         else
1547         {
1548             ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: NFA_P2P_CONGEST_EVT; nfa handle: 0x%04x  congested: %u", fn,
1549                     eventData->congest.handle, eventData->congest.is_congested);
1550 
1551             SyncEventGuard guard (pConn->mCongEvent);
1552             pConn->mCongEvent.notifyOne();
1553         }
1554         break;
1555 
1556     default:
1557         ALOGE ("%s: unknown event 0x%X ????", fn, p2pEvent);
1558         break;
1559     }
1560 }
1561 
1562 
1563 /*******************************************************************************
1564 **
1565 ** Function:        connectionEventHandler
1566 **
1567 ** Description:     Receive events from the stack.
1568 **                  event: Event code.
1569 **                  eventData: Event data.
1570 **
1571 ** Returns:         None
1572 **
1573 *******************************************************************************/
connectionEventHandler(UINT8 event,tNFA_CONN_EVT_DATA *)1574 void PeerToPeer::connectionEventHandler (UINT8 event, tNFA_CONN_EVT_DATA* /*eventData*/)
1575 {
1576     switch (event)
1577     {
1578     case NFA_SET_P2P_LISTEN_TECH_EVT:
1579         {
1580             SyncEventGuard guard (mSetTechEvent);
1581             mSetTechEvent.notifyOne(); //unblock NFA_SetP2pListenTech()
1582             break;
1583         }
1584     }
1585 }
1586 
1587 
1588 /*******************************************************************************
1589 **
1590 ** Function:        getNextJniHandle
1591 **
1592 ** Description:     Get a new JNI handle.
1593 **
1594 ** Returns:         A new JNI handle.
1595 **
1596 *******************************************************************************/
getNewJniHandle()1597 PeerToPeer::tJNI_HANDLE PeerToPeer::getNewJniHandle ()
1598 {
1599     tJNI_HANDLE newHandle = 0;
1600 
1601     mNewJniHandleMutex.lock ();
1602     newHandle = mNextJniHandle++;
1603     mNewJniHandleMutex.unlock ();
1604     return newHandle;
1605 }
1606 
1607 
1608 /////////////////////////////////////////////////////////////////////////
1609 /////////////////////////////////////////////////////////////////////////
1610 
1611 
1612 /*******************************************************************************
1613 **
1614 ** Function:        P2pServer
1615 **
1616 ** Description:     Initialize member variables.
1617 **
1618 ** Returns:         None
1619 **
1620 *******************************************************************************/
P2pServer(PeerToPeer::tJNI_HANDLE jniHandle,const char * serviceName)1621 P2pServer::P2pServer(PeerToPeer::tJNI_HANDLE jniHandle, const char* serviceName)
1622 :   mNfaP2pServerHandle (NFA_HANDLE_INVALID),
1623     mJniHandle (jniHandle)
1624 {
1625     mServiceName.assign (serviceName);
1626 
1627     memset (mServerConn, 0, sizeof(mServerConn));
1628 }
1629 
registerWithStack()1630 bool P2pServer::registerWithStack()
1631 {
1632     static const char fn [] = "P2pServer::registerWithStack";
1633     ALOGD ("%s: enter; service name: %s  JNI handle: %u", fn, mServiceName.c_str(), mJniHandle);
1634     tNFA_STATUS     stat  = NFA_STATUS_OK;
1635     UINT8           serverSap = NFA_P2P_ANY_SAP;
1636 
1637     /**********************
1638    default values for all LLCP parameters:
1639    - Local Link MIU (LLCP_MIU)
1640    - Option parameter (LLCP_OPT_VALUE)
1641    - Response Waiting Time Index (LLCP_WAITING_TIME)
1642    - Local Link Timeout (LLCP_LTO_VALUE)
1643    - Inactivity Timeout as initiator role (LLCP_INIT_INACTIVITY_TIMEOUT)
1644    - Inactivity Timeout as target role (LLCP_TARGET_INACTIVITY_TIMEOUT)
1645    - Delay SYMM response (LLCP_DELAY_RESP_TIME)
1646    - Data link connection timeout (LLCP_DATA_LINK_CONNECTION_TOUT)
1647    - Delay timeout to send first PDU as initiator (LLCP_DELAY_TIME_TO_SEND_FIRST_PDU)
1648    ************************/
1649    stat = NFA_P2pSetLLCPConfig (LLCP_MAX_MIU,
1650            LLCP_OPT_VALUE,
1651            LLCP_WAITING_TIME,
1652            LLCP_LTO_VALUE,
1653            0, //use 0 for infinite timeout for symmetry procedure when acting as initiator
1654            0, //use 0 for infinite timeout for symmetry procedure when acting as target
1655            LLCP_DELAY_RESP_TIME,
1656            LLCP_DATA_LINK_TIMEOUT,
1657            LLCP_DELAY_TIME_TO_SEND_FIRST_PDU);
1658    if (stat != NFA_STATUS_OK)
1659        ALOGE ("%s: fail set LLCP config; error=0x%X", fn, stat);
1660 
1661    if (sSnepServiceName.compare(mServiceName) == 0)
1662        serverSap = LLCP_SAP_SNEP; //LLCP_SAP_SNEP == 4
1663 
1664    {
1665        SyncEventGuard guard (mRegServerEvent);
1666        stat = NFA_P2pRegisterServer (serverSap, NFA_P2P_DLINK_TYPE, const_cast<char*>(mServiceName.c_str()),
1667                PeerToPeer::nfaServerCallback);
1668        if (stat != NFA_STATUS_OK)
1669        {
1670            ALOGE ("%s: fail register p2p server; error=0x%X", fn, stat);
1671            return (false);
1672        }
1673        ALOGD ("%s: wait for listen-completion event", fn);
1674        // Wait for NFA_P2P_REG_SERVER_EVT
1675        mRegServerEvent.wait ();
1676    }
1677 
1678    return (mNfaP2pServerHandle != NFA_HANDLE_INVALID);
1679 }
1680 
accept(PeerToPeer::tJNI_HANDLE serverJniHandle,PeerToPeer::tJNI_HANDLE connJniHandle,int maxInfoUnit,int recvWindow)1681 bool P2pServer::accept(PeerToPeer::tJNI_HANDLE serverJniHandle, PeerToPeer::tJNI_HANDLE connJniHandle,
1682         int maxInfoUnit, int recvWindow)
1683 {
1684     static const char fn [] = "P2pServer::accept";
1685     tNFA_STATUS     nfaStat  = NFA_STATUS_OK;
1686 
1687     sp<NfaConn> connection = allocateConnection(connJniHandle);
1688     if (connection == NULL) {
1689         ALOGE ("%s: failed to allocate new server connection", fn);
1690         return false;
1691     }
1692 
1693     {
1694         // Wait for NFA_P2P_CONN_REQ_EVT or NFA_NDEF_DATA_EVT when remote device requests connection
1695         SyncEventGuard guard (mConnRequestEvent);
1696         ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; wait for incoming connection", fn,
1697                 serverJniHandle, connJniHandle);
1698         mConnRequestEvent.wait();
1699         ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; got incoming connection", fn,
1700                 serverJniHandle, connJniHandle, connection->mNfaConnHandle);
1701     }
1702 
1703     if (connection->mNfaConnHandle == NFA_HANDLE_INVALID)
1704     {
1705         removeServerConnection(connJniHandle);
1706         ALOGD ("%s: no handle assigned", fn);
1707         return (false);
1708     }
1709 
1710     if (maxInfoUnit > (int)LLCP_MIU)
1711     {
1712         ALOGD ("%s: overriding the miu passed by the app(%d) with stack miu(%zu)", fn, maxInfoUnit, LLCP_MIU);
1713         maxInfoUnit = LLCP_MIU;
1714     }
1715 
1716     ALOGD ("%s: serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X; try accept", fn,
1717             serverJniHandle, connJniHandle, connection->mNfaConnHandle);
1718     nfaStat = NFA_P2pAcceptConn (connection->mNfaConnHandle, maxInfoUnit, recvWindow);
1719 
1720     if (nfaStat != NFA_STATUS_OK)
1721     {
1722         ALOGE ("%s: fail to accept remote; error=0x%X", fn, nfaStat);
1723         return (false);
1724     }
1725 
1726     ALOGD ("%s: exit; serverJniHandle: %u; connJniHandle: %u; nfa conn h: 0x%X", fn,
1727             serverJniHandle, connJniHandle, connection->mNfaConnHandle);
1728     return (true);
1729 }
1730 
unblockAll()1731 void P2pServer::unblockAll()
1732 {
1733     AutoMutex mutex(mMutex);
1734     for (int jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
1735     {
1736         if (mServerConn[jj] != NULL)
1737         {
1738             mServerConn[jj]->mNfaConnHandle = NFA_HANDLE_INVALID;
1739             {
1740                 SyncEventGuard guard1 (mServerConn[jj]->mCongEvent);
1741                 mServerConn[jj]->mCongEvent.notifyOne (); //unblock write (if congested)
1742             }
1743             {
1744                 SyncEventGuard guard2 (mServerConn[jj]->mReadEvent);
1745                 mServerConn[jj]->mReadEvent.notifyOne (); //unblock receive()
1746             }
1747         }
1748     }
1749 }
1750 
allocateConnection(PeerToPeer::tJNI_HANDLE jniHandle)1751 sp<NfaConn> P2pServer::allocateConnection (PeerToPeer::tJNI_HANDLE jniHandle)
1752 {
1753     AutoMutex mutex(mMutex);
1754     // First, find a free connection block to handle the connection
1755     for (int ii = 0; ii < MAX_NFA_CONNS_PER_SERVER; ii++)
1756     {
1757         if (mServerConn[ii] == NULL)
1758         {
1759             mServerConn[ii] = new NfaConn;
1760             mServerConn[ii]->mJniHandle = jniHandle;
1761             return mServerConn[ii];
1762         }
1763     }
1764 
1765     return NULL;
1766 }
1767 
1768 
1769 /*******************************************************************************
1770 **
1771 ** Function:        findServerConnection
1772 **
1773 ** Description:     Find a P2pServer that has the handle.
1774 **                  nfaConnHandle: NFA connection handle.
1775 **
1776 ** Returns:         P2pServer object.
1777 **
1778 *******************************************************************************/
findServerConnection(tNFA_HANDLE nfaConnHandle)1779 sp<NfaConn> P2pServer::findServerConnection (tNFA_HANDLE nfaConnHandle)
1780 {
1781     int jj = 0;
1782 
1783     AutoMutex mutex(mMutex);
1784     for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
1785     {
1786         if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mNfaConnHandle == nfaConnHandle) )
1787             return (mServerConn[jj]);
1788     }
1789 
1790     // If here, not found
1791     return (NULL);
1792 }
1793 
1794 /*******************************************************************************
1795 **
1796 ** Function:        findServerConnection
1797 **
1798 ** Description:     Find a P2pServer that has the handle.
1799 **                  nfaConnHandle: NFA connection handle.
1800 **
1801 ** Returns:         P2pServer object.
1802 **
1803 *******************************************************************************/
findServerConnection(PeerToPeer::tJNI_HANDLE jniHandle)1804 sp<NfaConn> P2pServer::findServerConnection (PeerToPeer::tJNI_HANDLE jniHandle)
1805 {
1806     int jj = 0;
1807 
1808     AutoMutex mutex(mMutex);
1809     for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
1810     {
1811         if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mJniHandle == jniHandle) )
1812             return (mServerConn[jj]);
1813     }
1814 
1815     // If here, not found
1816     return (NULL);
1817 }
1818 
1819 /*******************************************************************************
1820 **
1821 ** Function:        removeServerConnection
1822 **
1823 ** Description:     Find a P2pServer that has the handle.
1824 **                  nfaConnHandle: NFA connection handle.
1825 **
1826 ** Returns:         P2pServer object.
1827 **
1828 *******************************************************************************/
removeServerConnection(PeerToPeer::tJNI_HANDLE jniHandle)1829 bool P2pServer::removeServerConnection (PeerToPeer::tJNI_HANDLE jniHandle)
1830 {
1831     int jj = 0;
1832 
1833     AutoMutex mutex(mMutex);
1834     for (jj = 0; jj < MAX_NFA_CONNS_PER_SERVER; jj++)
1835     {
1836         if ( (mServerConn[jj] != NULL) && (mServerConn[jj]->mJniHandle == jniHandle) ) {
1837             mServerConn[jj] = NULL;
1838             return true;
1839         }
1840     }
1841 
1842     // If here, not found
1843     return false;
1844 }
1845 /////////////////////////////////////////////////////////////////////////
1846 /////////////////////////////////////////////////////////////////////////
1847 
1848 
1849 /*******************************************************************************
1850 **
1851 ** Function:        P2pClient
1852 **
1853 ** Description:     Initialize member variables.
1854 **
1855 ** Returns:         None
1856 **
1857 *******************************************************************************/
P2pClient()1858 P2pClient::P2pClient ()
1859 :   mNfaP2pClientHandle (NFA_HANDLE_INVALID),
1860     mIsConnecting (false)
1861 {
1862     mClientConn = new NfaConn();
1863 }
1864 
1865 
1866 /*******************************************************************************
1867 **
1868 ** Function:        ~P2pClient
1869 **
1870 ** Description:     Free all resources.
1871 **
1872 ** Returns:         None
1873 **
1874 *******************************************************************************/
~P2pClient()1875 P2pClient::~P2pClient ()
1876 {
1877 }
1878 
1879 
1880 /////////////////////////////////////////////////////////////////////////
1881 /////////////////////////////////////////////////////////////////////////
1882 
1883 
1884 /*******************************************************************************
1885 **
1886 ** Function:        NfaConn
1887 **
1888 ** Description:     Initialize member variables.
1889 **
1890 ** Returns:         None
1891 **
1892 *******************************************************************************/
NfaConn()1893 NfaConn::NfaConn()
1894 :   mNfaConnHandle (NFA_HANDLE_INVALID),
1895     mJniHandle (0),
1896     mMaxInfoUnit (0),
1897     mRecvWindow (0),
1898     mRemoteMaxInfoUnit (0),
1899     mRemoteRecvWindow (0)
1900 {
1901 }
1902