Remove old NPP->SNEP redirect code.

This code was used when Android did not support
SNEP natively yet. The current Android behavior
is to automatically try SNEP first, then fall back
to NPP.

Change-Id: Ifb1df3a5439cc1a7b939b4ae1dc70135d9c63a25

2 files changed, 4 insertions, 451 deletions

diff --git a/nci/jni/PeerToPeer.cpp b/nci/jni/PeerToPeer.cpp
index fdfa30c..bf18df5 100644
--- a/nci/jni/PeerToPeer.cpp
+++ b/nci/jni/PeerToPeer.cpp
@@ -24,7 +24,6 @@ namespace android
 
 PeerToPeer PeerToPeer::sP2p;
 const std::string PeerToPeer::sSnepServiceName ("urn:nfc:sn:snep");
-const std::string PeerToPeer::sNppServiceName ("com.android.npp");
 
 
 /*******************************************************************************
@@ -43,13 +42,6 @@ PeerToPeer::PeerToPeer ()
                         | NFA_TECHNOLOGY_MASK_F
                         | NFA_TECHNOLOGY_MASK_A_ACTIVE
                         | NFA_TECHNOLOGY_MASK_F_ACTIVE),
-    mJniHandleSendingNppViaSnep (0),
-    mSnepRegHandle (NFA_HANDLE_INVALID),
-    mRcvFakeNppJniHandle (0),
-    mNppFakeOutBuffer (NULL),
-    mNppTotalLen (0),
-    mNppReadSoFar (0),
-    mNdefTypeHandlerHandle (NFA_HANDLE_INVALID),
     mNextJniHandle (1)
 {
     unsigned long num = 0;
@@ -338,10 +330,6 @@ void PeerToPeer::llcpActivatedHandler (nfc_jni_native_data* nat, tNFA_LLCP_ACTIV
     //no longer need to receive NDEF message from a tag
     android::nativeNfcTag_deregisterNdefTypeHandler ();
 
-    //register a type handler in case we need to send NDEF messages received from SNEP through NPP
-    mNdefTypeHandlerHandle = NFA_HANDLE_INVALID;
-    NFA_RegisterNDefTypeHandler (TRUE, NFA_TNF_DEFAULT, (UINT8 *)"", 0, ndefTypeCallback);
-
     mRemoteWKS = activated.remote_wks;
 
     nat->vm->AttachCurrentThread (&e, NULL);
@@ -442,10 +430,6 @@ void PeerToPeer::llcpDeactivatedHandler (nfc_jni_native_data* nat, tNFA_LLCP_DEA
 
     nat->vm->DetachCurrentThread ();
 
-    //PeerToPeer no longer needs to handle NDEF data event
-    NFA_DeregisterNDefTypeHandler (mNdefTypeHandlerHandle);
-    mNdefTypeHandlerHandle = NFA_HANDLE_INVALID;
-
     //let the tag-reading code handle NDEF data event
     android::nativeNfcTag_registerNdefTypeHandler ();
     ALOGD ("%s: exit", fn);
@@ -512,16 +496,6 @@ bool PeerToPeer::accept (tJNI_HANDLE serverJniHandle, tJNI_HANDLE connJniHandle,
                 serverJniHandle, connJniHandle, ii, pSrv->mServerConn[ii]->mNfaConnHandle);
     }
 
-    // If we had gotten a message via SNEP, fake it out to be for NPP
-    if (mRcvFakeNppJniHandle == serverJniHandle)
-    {
-        ALOGD ("%s:  server jni handle %u diverted to NPP fake receive on conn jni handle %u", fn, serverJniHandle, connJniHandle);
-        delete (pSrv->mServerConn[ii]);
-        pSrv->mServerConn[ii] = NULL;
-        mRcvFakeNppJniHandle = connJniHandle;
-        return (true);
-    }
-
     if (pSrv->mServerConn[ii]->mNfaConnHandle == NFA_HANDLE_INVALID)
     {
         delete (pSrv->mServerConn[ii]);
@@ -694,18 +668,7 @@ void PeerToPeer::removeConn(tJNI_HANDLE jniHandle)
         }
     }
 
-    if (jniHandle == mRcvFakeNppJniHandle)
-    {
-        ALOGD ("%s: Reset mRcvFakeNppJniHandle: %u", fn, jniHandle);
-        mRcvFakeNppJniHandle = 0;
-        if (mNppFakeOutBuffer != NULL)
-        {
-            free (mNppFakeOutBuffer);
-            mNppFakeOutBuffer = NULL;
-        }
-    }
-    else
-        ALOGE ("%s: could not find handle: %u", fn, jniHandle);
+    ALOGE ("%s: could not find handle: %u", fn, jniHandle);
 }
 
 
@@ -724,46 +687,6 @@ bool PeerToPeer::connectConnOriented (tJNI_HANDLE jniHandle, const char* service
 {
     static const char fn [] = "PeerToPeer::connectConnOriented";
     ALOGD ("%s: enter; h: %u  service name=%s", fn, jniHandle, serviceName);
-
-    // If we are connecting to NPP and the other side supports SNEP, use SNEP
-    if ( (sNppServiceName.compare(serviceName)==0) && (mSnepRegHandle != NFA_HANDLE_INVALID) )
-    {
-        P2pClient   *pClient = NULL;
-
-        if ((pClient = findClient (jniHandle)) == NULL)
-        {
-            ALOGE ("%s: can't find client, JNI handle: %u", fn, jniHandle);
-            return (false);
-        }
-
-        if (mJniHandleSendingNppViaSnep != 0)
-        {
-            ALOGE ("%s: SNEP already active, SNEP JNI handle: %u  new JNI handle: %u", fn, mJniHandleSendingNppViaSnep, jniHandle);
-            return (false);
-        }
-
-        // Save JNI Handle and try to connect to SNEP
-        mJniHandleSendingNppViaSnep = jniHandle;
-        {
-            SyncEventGuard guard (pClient->mSnepEvent);
-            if (NFA_SnepConnect (mSnepRegHandle, const_cast<char*>("urn:nfc:sn:snep")) == NFA_STATUS_OK)
-            {
-                pClient->mSnepEvent.wait();
-
-                // If the connect attempt failed, connection handle is invalid
-                if (pClient->mSnepConnHandle != NFA_HANDLE_INVALID)
-                {
-                    // return true, as if we were connected.
-                    pClient->mClientConn.mRemoteMaxInfoUnit = 248;
-                    pClient->mClientConn.mRemoteRecvWindow  = 1;
-                    return (true);
-                }
-            }
-        }
-        mJniHandleSendingNppViaSnep = 0;
-    }
-
-    // If here, we did not establish a SNEP connection
     bool stat = createDataLinkConn (jniHandle, serviceName, 0);
     ALOGD ("%s: exit; h: %u  stat: %u", fn, jniHandle, stat);
     return stat;
@@ -1024,14 +947,8 @@ bool PeerToPeer::send (tJNI_HANDLE jniHandle, UINT8 *buffer, UINT16 bufferLen)
         return (false);
     }
 
-    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: send data; jniHandle: %u  nfaHandle: 0x%04X  mJniHandleSendingNppViaSnep: %u",
-            fn, pConn->mJniHandle, pConn->mNfaConnHandle, mJniHandleSendingNppViaSnep);
-
-    // Is this a SNEP fake-out
-    if (jniHandle == mJniHandleSendingNppViaSnep)
-    {
-        return (sendViaSnep(jniHandle, buffer, bufferLen));
-    }
+    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: send data; jniHandle: %u  nfaHandle: 0x%04X",
+            fn, pConn->mJniHandle, pConn->mNfaConnHandle);
 
     while (true)
     {
@@ -1061,89 +978,6 @@ bool PeerToPeer::send (tJNI_HANDLE jniHandle, UINT8 *buffer, UINT16 bufferLen)
 
 /*******************************************************************************
 **
-** Function:        sendViaSnep
-**
-** Description:     Send out-bound data to the stack's SNEP protocol.
-**                  jniHandle: Handle of connection.
-**                  buffer: Buffer of data.
-**                  dataLen: Length of data.
-**
-** Returns:         True if ok.
-**
-*******************************************************************************/
-bool PeerToPeer::sendViaSnep (tJNI_HANDLE jniHandle, UINT8 *buffer, UINT16 dataLen)
-{
-    static const char fn [] = "PeerToPeer::sendViaSnep";
-    tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
-    P2pClient   *pClient = NULL;
-
-    if ((pClient = findClient (jniHandle)) == NULL)
-    {
-        ALOGE ("%s: can't find client, JNI handle: %u", fn, jniHandle);
-        mJniHandleSendingNppViaSnep = 0;
-        return (false);
-    }
-
-    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: send data; jniHandle: %u  mSnepNdefMsgLen: %lu  mSnepNdefBufLen: %lu  dataLen: %d",
-          fn, jniHandle, pClient->mSnepNdefMsgLen, pClient->mSnepNdefBufLen, dataLen);
-
-    if (pClient->mSnepNdefMsgLen == 0)
-    {
-        pClient->mSnepNdefMsgLen = (buffer[6] << 24) | (buffer[7] << 16) | (buffer[8] << 8) | buffer[9];
-        if ((pClient->mSnepNdefBuf = (UINT8 *)malloc (pClient->mSnepNdefMsgLen + 1000)) == NULL)
-        {
-            ALOGE ("%s: can't malloc len: %lu", fn, pClient->mSnepNdefMsgLen);
-            mJniHandleSendingNppViaSnep = 0;
-            return (false);
-        }
-        buffer += 10;
-        dataLen -= 10;
-    }
-
-    if ((pClient->mSnepNdefBufLen + dataLen) > pClient->mSnepNdefMsgLen)
-    {
-        ALOGE ("%s: len error mSnepNdefBufLen: %lu  dataLen: %u  mSnepNdefMsgLen: %lu", fn,
-              pClient->mSnepNdefBufLen, dataLen, pClient->mSnepNdefMsgLen);
-        mJniHandleSendingNppViaSnep = 0;
-        free (pClient->mSnepNdefBuf);
-        pClient->mSnepNdefBuf = NULL;
-        return (false);
-    }
-
-    // Save the data in the buffer
-    memcpy (pClient->mSnepNdefBuf + pClient->mSnepNdefBufLen, buffer, dataLen);
-
-    pClient->mSnepNdefBufLen += dataLen;
-
-    // If we got all the data, send it via SNEP
-    if (pClient->mSnepNdefBufLen == pClient->mSnepNdefMsgLen)
-    {
-        ALOGD ("%s  GKI_poolcount(2): %u   GKI_poolfreecount(2): %u", fn, GKI_poolcount(2), GKI_poolfreecount(2));
-
-        SyncEventGuard guard (pClient->mSnepEvent);
-        nfaStat = NFA_SnepPut (pClient->mSnepConnHandle, pClient->mSnepNdefBufLen, pClient->mSnepNdefBuf);
-
-        if (nfaStat != NFA_STATUS_OK)
-        {
-            ALOGE ("%s: NFA_SnepPut failed, code: 0x%04x", fn, nfaStat);
-            mJniHandleSendingNppViaSnep = 0;
-            free (pClient->mSnepNdefBuf);
-            pClient->mSnepNdefBuf = NULL;
-            return (false);
-        }
-        pClient->mSnepEvent.wait ();
-
-        free (pClient->mSnepNdefBuf);
-        pClient->mSnepNdefBuf = NULL;
-        mJniHandleSendingNppViaSnep = 0;
-        return (pClient->mIsSnepSentOk);
-    }
-    return (true);
-}
-
-
-/*******************************************************************************
-**
 ** Function:        receive
 **
 ** Description:     Receive data from peer.
@@ -1165,9 +999,6 @@ bool PeerToPeer::receive (tJNI_HANDLE jniHandle, UINT8* buffer, UINT16 bufferLen
     BOOLEAN isMoreData = TRUE;
     bool retVal = false;
 
-    if (jniHandle == mRcvFakeNppJniHandle)
-        return (feedNppFromSnep(buffer, bufferLen, actualLen));
-
     if ((pConn = findConnection (jniHandle)) == NULL)
     {
         ALOGE ("%s: can't find connection handle: %u", fn, jniHandle);
@@ -1200,44 +1031,6 @@ bool PeerToPeer::receive (tJNI_HANDLE jniHandle, UINT8* buffer, UINT16 bufferLen
 
 /*******************************************************************************
 **
-** Function:        feedNppFromSnep
-**
-** Description:     Send incomming data to the NFC service's NDEF Push Protocol.
-**                  buffer: Buffer of data to send.
-**                  bufferLen: Length of data in buffer.
-**                  actualLen: Actual length sent.
-**
-** Returns:         True if ok.
-**
-*******************************************************************************/
-bool PeerToPeer::feedNppFromSnep (UINT8* buffer, UINT16 bufferLen, UINT16& actualLen)
-{
-    static const char fn [] = "PeerToPeer::feedNppFromSnep";
-
-    ALOGD_IF ((appl_trace_level>=BT_TRACE_LEVEL_DEBUG), "%s: mNppTotalLen: %lu  mNppReadSoFar: %lu  bufferLen: %u",
-            fn, mNppTotalLen, mNppReadSoFar, bufferLen);
-
-    if (bufferLen > (mNppTotalLen - mNppReadSoFar))
-        bufferLen = mNppTotalLen - mNppReadSoFar;
-
-    memcpy (buffer, mNppFakeOutBuffer + mNppReadSoFar, bufferLen);
-
-    mNppReadSoFar += bufferLen;
-    actualLen      = bufferLen;
-
-    if (mNppReadSoFar == mNppTotalLen)
-    {
-        ALOGD ("%s: entire message consumed", fn);
-        free (mNppFakeOutBuffer);
-        mNppFakeOutBuffer   = NULL;
-        mRcvFakeNppJniHandle = 0;
-    }
-    return (true);
-}
-
-
-/*******************************************************************************
-**
 ** Function:        disconnectConnOriented
 **
 ** Description:     Disconnect a connection-oriented connection with peer.
@@ -1483,15 +1276,6 @@ void PeerToPeer::handleNfcOnOff (bool isOn)
             }
         } //loop
 
-        mJniHandleSendingNppViaSnep = 0;
-        mRcvFakeNppJniHandle        = 0;
-        mSnepRegHandle              = NFA_HANDLE_INVALID;
-
-        if (mNppFakeOutBuffer != NULL)
-        {
-            free (mNppFakeOutBuffer);
-            mNppFakeOutBuffer = NULL;
-        }
     }
     ALOGD ("%s: exit", fn);
 }
@@ -1801,188 +1585,6 @@ void PeerToPeer::nfaClientCallback (tNFA_P2P_EVT p2pEvent, tNFA_P2P_EVT_DATA* ev
 
 /*******************************************************************************
 **
-** Function:        snepClientCallback
-**
-** Description:     Receive SNEP-related events from the stack.
-**                  snepEvent: Event code.
-**                  eventData: Event data.
-**
-** Returns:         None
-**
-*******************************************************************************/
-void PeerToPeer::snepClientCallback (tNFA_SNEP_EVT snepEvent, tNFA_SNEP_EVT_DATA *eventData)
-{
-    static const char fn [] = "PeerToPeer::snepClientCallback";
-    P2pClient   *pClient;
-
-    switch (snepEvent)
-    {
-    case NFA_SNEP_REG_EVT:
-        {
-            ALOGD ("%s  NFA_SNEP_REG_EVT  Status: %u  Handle: 0x%X", fn, eventData->reg.status, eventData->reg.reg_handle);
-            SyncEventGuard guard (sP2p.mSnepRegisterEvent);
-            if (eventData->reg.status == NFA_STATUS_OK)
-                sP2p.mSnepRegHandle = eventData->reg.reg_handle;
-            sP2p.mSnepRegisterEvent.notifyOne ();
-            break;
-        }
-
-    case NFA_SNEP_ACTIVATED_EVT:
-        ALOGD ("%s  NFA_SNEP_ACTIVATED_EVT  mJniHandleSendingNppViaSnep: %u", fn, sP2p.mJniHandleSendingNppViaSnep);
-        break;
-
-    case NFA_SNEP_DEACTIVATED_EVT:
-        ALOGD ("%s  NFA_SNEP_ACTIVATED_EVT  mJniHandleSendingNppViaSnep: %u", fn, sP2p.mJniHandleSendingNppViaSnep);
-        break;
-
-    case NFA_SNEP_CONNECTED_EVT:
-        if ((pClient = sP2p.findClient (sP2p.mJniHandleSendingNppViaSnep)) == NULL)
-        {
-            ALOGE ("%s: NFA_SNEP_CONNECTED_EVT - can't find SNEP client, mJniHandleSendingNppViaSnep: %u", fn, sP2p.mJniHandleSendingNppViaSnep);
-        }
-        else
-        {
-            ALOGD ("%s  NFA_SNEP_CONNECTED_EVT  mJniHandleSendingNppViaSnep: %u  ConnHandle: 0x%04x", fn, sP2p.mJniHandleSendingNppViaSnep, eventData->connect.conn_handle);
-
-            SyncEventGuard guard (pClient->mSnepEvent);
-            pClient->mSnepConnHandle = eventData->connect.conn_handle;
-            pClient->mSnepEvent.notifyOne();
-        }
-        break;
-
-    case NFA_SNEP_PUT_RESP_EVT:
-        if ((pClient = sP2p.findClient (sP2p.mJniHandleSendingNppViaSnep)) == NULL)
-        {
-            ALOGE ("%s: NFA_SNEP_PUT_RESP_EVT - can't find SNEP client, mJniHandleSendingNppViaSnep: %u", fn, sP2p.mJniHandleSendingNppViaSnep);
-        }
-        else
-        {
-            ALOGD ("%s  NFA_SNEP_PUT_RESP_EVT  mJniHandleSendingNppViaSnep: %u  Result: 0x%X", fn, sP2p.mJniHandleSendingNppViaSnep, eventData->put_resp.resp_code);
-
-            pClient->mIsSnepSentOk = (eventData->put_resp.resp_code == NFA_SNEP_RESP_CODE_SUCCESS);
-
-            NFA_SnepDisconnect (eventData->put_resp.conn_handle, FALSE);
-
-            SyncEventGuard guard (pClient->mSnepEvent);
-            pClient->mSnepEvent.notifyOne();
-        }
-        break;
-
-    case NFA_SNEP_DISC_EVT:
-        if ((pClient = sP2p.findClient (sP2p.mJniHandleSendingNppViaSnep)) == NULL)
-        {
-            ALOGE ("%s: NFA_SNEP_DISC_EVT - can't find SNEP client, mJniHandleSendingNppViaSnep: %u", fn, sP2p.mJniHandleSendingNppViaSnep);
-        }
-        else
-        {
-            ALOGD ("%s  NFA_SNEP_DISC_EVT  mJniHandleSendingNppViaSnep: %u", fn, sP2p.mJniHandleSendingNppViaSnep);
-            SyncEventGuard guard (pClient->mSnepEvent);
-            pClient->mSnepConnHandle = NFA_HANDLE_INVALID;
-            pClient->mSnepEvent.notifyOne();
-        }
-        break;
-
-    case NFA_SNEP_DEFAULT_SERVER_STARTED_EVT:
-        {
-            ALOGE ("%s: NFA_SNEP_DEFAULT_SERVER_STARTED_EVT", fn);
-            SyncEventGuard guard (sP2p.mSnepDefaultServerStartStopEvent);
-            sP2p.mSnepDefaultServerStartStopEvent.notifyOne(); //unblock NFA_SnepStartDefaultServer()
-            break;
-        }
-
-    case NFA_SNEP_DEFAULT_SERVER_STOPPED_EVT:
-        {
-            ALOGE ("%s: NFA_SNEP_DEFAULT_SERVER_STOPPED_EVT", fn);
-            SyncEventGuard guard (sP2p.mSnepDefaultServerStartStopEvent);
-            sP2p.mSnepDefaultServerStartStopEvent.notifyOne(); //unblock NFA_SnepStopDefaultServer()
-            break;
-        }
-        break;
-
-    default:
-        ALOGE ("%s UNKNOWN EVENT: 0x%04x  mJniHandleSendingNppViaSnep: %u", fn, snepEvent, sP2p.mJniHandleSendingNppViaSnep);
-        break;
-    }
-}
-
-
-/*******************************************************************************
-**
-** Function:        ndefTypeCallback
-**
-** Description:     Receive NDEF-related events from the stack.
-**                  ndefEvent: Event code.
-**                  eventData: Event data.
-**
-** Returns:         None
-**
-*******************************************************************************/
-void PeerToPeer::ndefTypeCallback (tNFA_NDEF_EVT ndefEvent, tNFA_NDEF_EVT_DATA *eventData)
-{
-    static const char fn [] = "PeerToPeer::ndefTypeCallback";
-    P2pServer *pSvr = NULL;
-
-    if (ndefEvent == NFA_NDEF_REGISTER_EVT)
-    {
-        tNFA_NDEF_REGISTER& ndef_reg = eventData->ndef_reg;
-        ALOGD ("%s  NFA_NDEF_REGISTER_EVT  Status: %u; h=0x%X", fn, ndef_reg.status, ndef_reg.ndef_type_handle);
-        sP2p.mNdefTypeHandlerHandle = ndef_reg.ndef_type_handle;
-    }
-    else if (ndefEvent == NFA_NDEF_DATA_EVT)
-    {
-        ALOGD ("%s  NFA_NDEF_DATA_EVT  Len: %lu", fn, eventData->ndef_data.len);
-
-        if (sP2p.mRcvFakeNppJniHandle != 0)
-        {
-            ALOGE ("%s  Got NDEF Data while busy, mRcvFakeNppJniHandle: %u", fn, sP2p.mRcvFakeNppJniHandle);
-            return;
-        }
-
-        if ((pSvr = sP2p.findServer ("com.android.npp")) == NULL)
-        {
-            ALOGE ("%s  Got NDEF Data but no NPP server listening", fn);
-            return;
-        }
-
-        if ((sP2p.mNppFakeOutBuffer = (UINT8 *)malloc(eventData->ndef_data.len + 10)) == NULL)
-        {
-            ALOGE ("%s  failed to malloc: %lu bytes", fn, eventData->ndef_data.len + 10);
-            return;
-        }
-
-        sP2p.mNppFakeOutBuffer[0] = 0x01;
-        sP2p.mNppFakeOutBuffer[1] = 0x00;
-        sP2p.mNppFakeOutBuffer[2] = 0x00;
-        sP2p.mNppFakeOutBuffer[3] = 0x00;
-        sP2p.mNppFakeOutBuffer[4] = 0x01;
-        sP2p.mNppFakeOutBuffer[5] = 0x01;
-        sP2p.mNppFakeOutBuffer[6] = (UINT8)(eventData->ndef_data.len >> 24);
-        sP2p.mNppFakeOutBuffer[7] = (UINT8)(eventData->ndef_data.len >> 16);
-        sP2p.mNppFakeOutBuffer[8] = (UINT8)(eventData->ndef_data.len >> 8);
-        sP2p.mNppFakeOutBuffer[9] = (UINT8)(eventData->ndef_data.len);
-
-        memcpy (&sP2p.mNppFakeOutBuffer[10], eventData->ndef_data.p_data, eventData->ndef_data.len);
-
-        ALOGD ("%s  NFA_NDEF_DATA_EVT  Faking NPP on Server Handle: %u", fn, pSvr->mJniHandle);
-
-        sP2p.mRcvFakeNppJniHandle = pSvr->mJniHandle;
-        sP2p.mNppTotalLen         = eventData->ndef_data.len + 10;
-        sP2p.mNppReadSoFar        = 0;
-        {
-            SyncEventGuard guard (pSvr->mConnRequestEvent);
-            pSvr->mConnRequestEvent.notifyOne();
-        }
-    }
-    else
-    {
-        ALOGE ("%s UNKNOWN EVENT: 0x%X", fn, ndefEvent);
-    }
-
-}
-
-
-/*******************************************************************************
-**
 ** Function:        connectionEventHandler
 **
 ** Description:     Receive events from the stack.
@@ -2087,12 +1689,7 @@ NfaConn *P2pServer::findServerConnection (tNFA_HANDLE nfaConnHandle)
 *******************************************************************************/
 P2pClient::P2pClient ()
 :   mNfaP2pClientHandle (NFA_HANDLE_INVALID),
-    mIsConnecting (false),
-    mSnepConnHandle (NFA_HANDLE_INVALID),
-    mSnepNdefMsgLen (0),
-    mSnepNdefBufLen (0),
-    mSnepNdefBuf (NULL),
-    mIsSnepSentOk (false)
+    mIsConnecting (false)
 {
 }
 
@@ -2108,8 +1705,6 @@ P2pClient::P2pClient ()
 *******************************************************************************/
 P2pClient::~P2pClient ()
 {
-    if (mSnepNdefBuf)
-        free (mSnepNdefBuf);
 }
 
 
diff --git a/nci/jni/PeerToPeer.h b/nci/jni/PeerToPeer.h
index 2921492..040ca78 100644
--- a/nci/jni/PeerToPeer.h
+++ b/nci/jni/PeerToPeer.h
@@ -340,13 +340,6 @@ private:
     UINT16          mRemoteWKS;                 // Peer's well known services
     bool            mIsP2pListening;            // If P2P listening is enabled or not
     tNFA_TECHNOLOGY_MASK    mP2pListenTechMask; // P2P Listen mask
-    tJNI_HANDLE     mJniHandleSendingNppViaSnep;
-    tNFA_HANDLE     mSnepRegHandle;
-    tJNI_HANDLE     mRcvFakeNppJniHandle;
-    UINT8           *mNppFakeOutBuffer;
-    UINT32          mNppTotalLen;
-    UINT32          mNppReadSoFar;
-    tNFA_HANDLE     mNdefTypeHandlerHandle;
     tJNI_HANDLE     mNextJniHandle;
 
     P2pServer       *mServers [sMax];
@@ -557,36 +550,6 @@ private:
     **
     *******************************************************************************/
     NfaConn     *findConnection (tJNI_HANDLE jniHandle);
-
-
-    /*******************************************************************************
-    **
-    ** Function:        sendViaSnep
-    **
-    ** Description:     Send out-bound data to the stack's SNEP protocol.
-    **                  jniHandle: Handle of connection.
-    **                  buffer: Buffer of data.
-    **                  dataLen: Length of data.
-    **
-    ** Returns:         True if ok.
-    **
-    *******************************************************************************/
-    bool        sendViaSnep (tJNI_HANDLE jniHandle, UINT8 *buffer, UINT16 bufferLen);
-
-
-    /*******************************************************************************
-    **
-    ** Function:        feedNppFromSnep
-    **
-    ** Description:     Send incomming data to the NFC service's NDEF Push Protocol.
-    **                  buffer: Buffer of data to send.
-    **                  bufferLen: Length of data in buffer.
-    **                  actualLen: Actual length sent.
-    **
-    ** Returns:         True if ok.
-    **
-    *******************************************************************************/
-    bool        feedNppFromSnep (UINT8* buffer, UINT16 bufferLen, UINT16& actualLen);
 };
 
 
@@ -679,11 +642,6 @@ class P2pClient
 public:
     tNFA_HANDLE         mNfaP2pClientHandle;    // NFA p2p handle of client
     bool                mIsConnecting;          // Set true while connecting
-    tNFA_HANDLE         mSnepConnHandle;
-    UINT32              mSnepNdefMsgLen;        // SNEP total NDEF message length
-    UINT32              mSnepNdefBufLen;        // SNEP NDEF buffer length
-    UINT8              *mSnepNdefBuf;           // SNEP NDEF Message
-    bool                mIsSnepSentOk;          // SNEP transmission status
     NfaConn             mClientConn;
     SyncEvent           mRegisteringEvent;      // For client registration
     SyncEvent           mConnectingEvent;       // for NFA_P2pConnectByName or Sap()