Home | History | Annotate | Download | only in src 
      1 /*
      2  * Copyright (C) 2010 NXP Semiconductors
      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 #include <phNfcTypes.h>
     18 #include <phLibNfc.h>
     19 #include <phLibNfc_Internal.h>
     20 #include <phFriNfc_Llcp.h>
     21 #include <phFriNfc_LlcpTransport.h>
     22 
     23 /* ---------------------------- Internal macros -------------------------------- */
     24 
     25 #ifndef STATIC_DISABLE
     26 #define STATIC static
     27 #else
     28 #define STATIC
     29 #endif
     30 
     31 /* ----------------------- Internal functions headers -------------------------- */
     32 
     33 STATIC
     34 NFCSTATUS static_CheckState();
     35 
     36 STATIC
     37 NFCSTATUS static_CheckDevice(phLibNfc_Handle hRemoteDevice);
     38 
     39 STATIC
     40 void phLibNfc_Llcp_CheckLlcp_Cb(void *pContext,NFCSTATUS status);
     41 
     42 STATIC
     43 void phLibNfc_Llcp_Link_Cb(void *pContext,phLibNfc_Llcp_eLinkStatus_t status);
     44 
     45 /* --------------------------- Internal functions ------------------------------ */
     46 
     47 STATIC NFCSTATUS static_CheckState()
     48 {
     49    /* Check if the global context is set */
     50    if(gpphLibContext == NULL)
     51    {
     52       return NFCSTATUS_NOT_INITIALISED;
     53    }
     54 
     55    /* Check if initialized */
     56    if(gpphLibContext->LibNfcState.cur_state == eLibNfcHalStateShutdown)
     57    {
     58       return NFCSTATUS_NOT_INITIALISED;
     59    }
     60 
     61    /* Check if shutting down */
     62    if(gpphLibContext->LibNfcState.next_state == eLibNfcHalStateShutdown)
     63    {
     64       return NFCSTATUS_SHUTDOWN;
     65    }
     66 
     67    return NFCSTATUS_SUCCESS;
     68 }
     69 
     70 STATIC NFCSTATUS static_CheckDevice(phLibNfc_Handle hRemoteDevice)
     71 {
     72    phLibNfc_sRemoteDevInformation_t*   psRemoteDevInfo = (phLibNfc_sRemoteDevInformation_t*)hRemoteDevice;
     73 
     74    if (hRemoteDevice == NULL)
     75    {
     76       return NFCSTATUS_INVALID_PARAMETER;
     77    }
     78 
     79    /* If local device is the Initiator (remote is Target),
     80     * check if connection is correct
     81     */
     82    if (psRemoteDevInfo->RemDevType == phHal_eNfcIP1_Target)
     83    {
     84       /* Check if any device connected */
     85       if(gpphLibContext->Connected_handle == 0)
     86       {
     87          return NFCSTATUS_TARGET_NOT_CONNECTED;
     88       }
     89 
     90       /* Check if handle corresponds to connected one */
     91       if(hRemoteDevice != gpphLibContext->Connected_handle)
     92       {
     93          return NFCSTATUS_INVALID_HANDLE;
     94       }
     95    }
     96 
     97    /* Check if previous callback is pending or if remote peer is not LLCP compliant */
     98    if ((gpphLibContext->status.GenCb_pending_status == TRUE) ||
     99             (gpphLibContext->llcp_cntx.bIsLlcp == FALSE))
    100    {
    101       return NFCSTATUS_REJECTED;
    102    }
    103 
    104    return NFCSTATUS_SUCCESS;
    105 }
    106 
    107 /* ---------------------------- Public functions ------------------------------- */
    108 
    109 NFCSTATUS phLibNfc_Mgt_SetLlcp_ConfigParams( phLibNfc_Llcp_sLinkParameters_t* pConfigInfo,
    110                                             pphLibNfc_RspCb_t                pConfigRspCb,
    111                                             void*                            pContext
    112                                             )
    113 {
    114    NFCSTATUS      result;
    115    phNfc_sData_t  sGeneralBytesBuffer;
    116    phLibNfc_sNfcIPCfg_t sNfcIPCfg;
    117    const uint8_t  pMagicBuffer[] = { 0x46, 0x66, 0x6D };
    118 
    119    /* State checking */
    120    result = static_CheckState();
    121    if (result != NFCSTATUS_SUCCESS)
    122    {
    123       return result;
    124    }
    125 
    126    /* Parameters checking */
    127    if ((pConfigInfo == NULL) || (pConfigRspCb == NULL))
    128    {
    129       return NFCSTATUS_INVALID_PARAMETER;
    130    }
    131 
    132    /* Save the config for later use */
    133    memcpy( &gpphLibContext->llcp_cntx.sLocalParams,
    134            pConfigInfo,
    135            sizeof(phLibNfc_Llcp_sLinkParameters_t) );
    136 
    137    /* Copy magic number in NFCIP General Bytes */
    138    memcpy(sNfcIPCfg.generalBytes, pMagicBuffer, sizeof(pMagicBuffer));
    139    sNfcIPCfg.generalBytesLength = sizeof(pMagicBuffer);
    140 
    141    /* Encode link parameters in TLV to configure P2P General Bytes */
    142    sGeneralBytesBuffer.buffer = sNfcIPCfg.generalBytes + sizeof(pMagicBuffer);
    143    sGeneralBytesBuffer.length = sizeof(sNfcIPCfg.generalBytes) - sizeof(pMagicBuffer);
    144    result = phFriNfc_Llcp_EncodeLinkParams( &sGeneralBytesBuffer,
    145                                             pConfigInfo,
    146                                             PHFRINFC_LLCP_VERSION);
    147    if (result != NFCSTATUS_SUCCESS)
    148    {
    149       return PHNFCSTATUS(result);
    150    }
    151    sNfcIPCfg.generalBytesLength += (uint8_t)sGeneralBytesBuffer.length;
    152 
    153    /* Set the P2P general bytes */
    154    result = phLibNfc_Mgt_SetP2P_ConfigParams(&sNfcIPCfg, pConfigRspCb, pContext);
    155    if (result != NFCSTATUS_PENDING)
    156    {
    157       return PHNFCSTATUS(result);
    158    }
    159 
    160    /* Resets the LLCP LLC component */
    161    result = phFriNfc_Llcp_Reset( &gpphLibContext->llcp_cntx.sLlcpContext,
    162                                  gpphLibContext->psOverHalCtxt,
    163                                  pConfigInfo,
    164                                  gpphLibContext->llcp_cntx.pRxBuffer,
    165                                  sizeof(gpphLibContext->llcp_cntx.pRxBuffer),
    166                                  gpphLibContext->llcp_cntx.pTxBuffer,
    167                                  sizeof(gpphLibContext->llcp_cntx.pTxBuffer),
    168                                  phLibNfc_Llcp_Link_Cb,
    169                                  gpphLibContext);
    170    if (result != NFCSTATUS_SUCCESS)
    171    {
    172       return PHNFCSTATUS(result);
    173    }
    174 
    175    /* Resets the LLCP Transport component */
    176    result = phFriNfc_LlcpTransport_Reset( &gpphLibContext->llcp_cntx.sLlcpTransportContext,
    177                                           &gpphLibContext->llcp_cntx.sLlcpContext );
    178    if (result != NFCSTATUS_SUCCESS)
    179    {
    180       return PHNFCSTATUS(result);
    181    }
    182 
    183    return NFCSTATUS_PENDING;
    184 }
    185 
    186 NFCSTATUS phLibNfc_Llcp_CheckLlcp( phLibNfc_Handle              hRemoteDevice,
    187                                    pphLibNfc_ChkLlcpRspCb_t     pCheckLlcp_RspCb,
    188                                    pphLibNfc_LlcpLinkStatusCb_t pLink_Cb,
    189                                    void*                        pContext
    190                                    )
    191 {
    192    NFCSTATUS                           result;
    193    phLibNfc_sRemoteDevInformation_t*   psRemoteDevInfo = (phLibNfc_sRemoteDevInformation_t*)hRemoteDevice;
    194 
    195    /* State checking */
    196    result = static_CheckState();
    197    if (result != NFCSTATUS_SUCCESS)
    198    {
    199       return result;
    200    }
    201 
    202    /* Parameters checking */
    203    if ((hRemoteDevice == 0)       ||
    204        (pCheckLlcp_RspCb == NULL) ||
    205        (pLink_Cb == NULL))
    206    {
    207       return NFCSTATUS_INVALID_PARAMETER;
    208    }
    209 
    210    /* If local device is the Initiator (remote is Target),
    211     * check if connection is correct
    212     */
    213    if (psRemoteDevInfo->RemDevType == phHal_eNfcIP1_Target)
    214    {
    215       /* Check if any device connected */
    216       if(gpphLibContext->Connected_handle == 0)
    217       {
    218          return NFCSTATUS_TARGET_NOT_CONNECTED;
    219       }
    220 
    221       /* Check if handle corresponds to connected one */
    222       if(hRemoteDevice != gpphLibContext->Connected_handle)
    223       {
    224          return NFCSTATUS_INVALID_HANDLE;
    225       }
    226    }
    227 
    228    /* Prepare callback */
    229    gpphLibContext->CBInfo.pClientLlcpLinkCb = pLink_Cb;
    230    gpphLibContext->CBInfo.pClientLlcpLinkCntx = pContext;
    231 
    232    // DEBUG: Reset at least the state
    233    gpphLibContext->llcp_cntx.sLlcpContext.state = 0;
    234 
    235    /* Prepare callback */
    236    gpphLibContext->CBInfo.pClientLlcpCheckRespCb = pCheckLlcp_RspCb;
    237    gpphLibContext->CBInfo.pClientLlcpCheckRespCntx = pContext;
    238 
    239    /* Update state */
    240    result = phLibNfc_UpdateNextState(gpphLibContext, eLibNfcHalStateTransaction);
    241    if (result != NFCSTATUS_SUCCESS)
    242    {
    243       return result;
    244    }
    245 
    246    /* Call the component function */
    247    result = phFriNfc_Llcp_ChkLlcp( &gpphLibContext->llcp_cntx.sLlcpContext,
    248                                    psRemoteDevInfo,
    249                                    phLibNfc_Llcp_CheckLlcp_Cb,
    250                                    gpphLibContext
    251                                    );
    252    result = PHNFCSTATUS(result);
    253    if (result == NFCSTATUS_PENDING)
    254    {
    255       gpphLibContext->status.GenCb_pending_status = TRUE;
    256    }
    257    else if (result == NFCSTATUS_SUCCESS)
    258    {
    259       /* Nothing to do */
    260    }
    261    else if (result != NFCSTATUS_FAILED)
    262    {
    263       result = NFCSTATUS_TARGET_LOST;
    264    }
    265 
    266    return result;
    267 }
    268 
    269 /* LLCP link callback */
    270 STATIC
    271 void phLibNfc_Llcp_Link_Cb(void *pContext, phLibNfc_Llcp_eLinkStatus_t status)
    272 {
    273    phLibNfc_LibContext_t         *pLibNfc_Ctxt = (phLibNfc_LibContext_t *)pContext;
    274    pphLibNfc_LlcpLinkStatusCb_t  pClientCb = NULL;
    275    void                          *pClientContext = NULL;
    276 
    277    if(pLibNfc_Ctxt != gpphLibContext)
    278    {
    279       /*wrong context returned from below layer*/
    280       phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1);
    281    }
    282    else
    283    {
    284       /* Close all sockets */
    285       phFriNfc_LlcpTransport_CloseAll(&gpphLibContext->llcp_cntx.sLlcpTransportContext);
    286 
    287       /* Copy callback details */
    288       pClientCb = gpphLibContext->CBInfo.pClientLlcpLinkCb;
    289       pClientContext = gpphLibContext->CBInfo.pClientLlcpLinkCntx;
    290 
    291       /* Trigger the callback */
    292       if(pClientCb != NULL)
    293       {
    294          pClientCb(pClientContext, status);
    295       }
    296    }
    297 }
    298 
    299 /* Response callback for phLibNfc_Ndef_CheckNdef */
    300 STATIC
    301 void phLibNfc_Llcp_CheckLlcp_Cb(void *pContext, NFCSTATUS status)
    302 {
    303    phLibNfc_LibContext_t      *pLibNfc_Ctxt = (phLibNfc_LibContext_t *)pContext;
    304    NFCSTATUS                  RetStatus = NFCSTATUS_SUCCESS;
    305    pphLibNfc_ChkLlcpRspCb_t   pClientCb = NULL;
    306    void                       *pClientContext = NULL;
    307 
    308    if(pLibNfc_Ctxt != gpphLibContext)
    309    {
    310       /*wrong context returned from below layer*/
    311       phOsalNfc_RaiseException(phOsalNfc_e_InternalErr,1);
    312    }
    313    else
    314    {
    315       if(gpphLibContext->LibNfcState.next_state == eLibNfcHalStateShutdown)
    316       {
    317          /*shutdown called before completion of check Ndef, allow shutdown to happen */
    318          phLibNfc_Pending_Shutdown();
    319          RetStatus = NFCSTATUS_SHUTDOWN;
    320       }
    321       else if(gpphLibContext->LibNfcState.next_state == eLibNfcHalStateRelease)
    322       {
    323          RetStatus = NFCSTATUS_ABORTED;
    324       }
    325       else
    326       {
    327          if(status == NFCSTATUS_SUCCESS)
    328          {
    329             /* Remote peer is LLCP compliant */
    330             gpphLibContext->llcp_cntx.bIsLlcp = TRUE;
    331          }
    332          else if(PHNFCSTATUS(status)== NFCSTATUS_FAILED)
    333          {
    334             RetStatus = NFCSTATUS_FAILED;
    335             gpphLibContext->llcp_cntx.bIsLlcp = FALSE;
    336          }
    337          else
    338          {
    339             RetStatus = NFCSTATUS_TARGET_LOST;
    340          }
    341       }
    342 
    343       /* Update the current state */
    344       gpphLibContext->status.GenCb_pending_status = FALSE;
    345       phLibNfc_UpdateCurState(RetStatus,gpphLibContext);
    346 
    347       /* Copy callback details */
    348       pClientCb = gpphLibContext->CBInfo.pClientLlcpCheckRespCb;
    349       pClientContext = gpphLibContext->CBInfo.pClientLlcpCheckRespCntx;
    350 
    351       /* Reset saved callback */
    352       gpphLibContext->CBInfo.pClientCkNdefCb = NULL;
    353       gpphLibContext->CBInfo.pClientCkNdefCntx = NULL;
    354 
    355       /* Trigger the callback */
    356       if(pClientCb != NULL)
    357       {
    358          pClientCb(pClientContext,RetStatus);
    359       }
    360    }
    361 }
    362 
    363 NFCSTATUS phLibNfc_Llcp_Activate( phLibNfc_Handle hRemoteDevice )
    364 {
    365    NFCSTATUS result;
    366 
    367    /* State checking */
    368    result = static_CheckState();
    369    if (result != NFCSTATUS_SUCCESS)
    370    {
    371       return result;
    372    }
    373 
    374    /* Parameters checking */
    375    if (hRemoteDevice == 0)
    376    {
    377       return NFCSTATUS_INVALID_PARAMETER;
    378    }
    379 
    380    /* Check device */
    381    result = static_CheckDevice(hRemoteDevice);
    382    if (result != NFCSTATUS_SUCCESS)
    383    {
    384       return result;
    385    }
    386 
    387    /* Start activation */
    388    result = phFriNfc_Llcp_Activate(&gpphLibContext->llcp_cntx.sLlcpContext);
    389 
    390    return PHNFCSTATUS(result);
    391 }
    392 
    393 NFCSTATUS phLibNfc_Llcp_Deactivate( phLibNfc_Handle  hRemoteDevice )
    394 {
    395    NFCSTATUS result;
    396 
    397    /* State checking */
    398    result = static_CheckState();
    399    if (result != NFCSTATUS_SUCCESS)
    400    {
    401       return result;
    402    }
    403 
    404    /* Parameters checking */
    405    if (hRemoteDevice == 0)
    406    {
    407       return NFCSTATUS_INVALID_PARAMETER;
    408    }
    409 
    410    /* Check device */
    411    result = static_CheckDevice(hRemoteDevice);
    412    if (result != NFCSTATUS_SUCCESS)
    413    {
    414       return result;
    415    }
    416 
    417    /* Start deactivation */
    418    result = phFriNfc_Llcp_Deactivate(&gpphLibContext->llcp_cntx.sLlcpContext);
    419 
    420    return PHNFCSTATUS(result);
    421 }
    422 
    423 NFCSTATUS phLibNfc_Llcp_GetLocalInfo( phLibNfc_Handle                  hRemoteDevice,
    424                                       phLibNfc_Llcp_sLinkParameters_t* pConfigInfo
    425                                       )
    426 {
    427    NFCSTATUS result;
    428 
    429    /* State checking */
    430    result = static_CheckState();
    431    if (result != NFCSTATUS_SUCCESS)
    432    {
    433       return result;
    434    }
    435 
    436    /* Parameters checking */
    437    if (pConfigInfo == NULL)
    438    {
    439       return NFCSTATUS_INVALID_PARAMETER;
    440    }
    441 
    442    /* Get local infos */
    443    result = phFriNfc_Llcp_GetLocalInfo(&gpphLibContext->llcp_cntx.sLlcpContext, pConfigInfo);
    444 
    445    return PHNFCSTATUS(result);
    446 }
    447 
    448 NFCSTATUS phLibNfc_Llcp_GetRemoteInfo( phLibNfc_Handle                    hRemoteDevice,
    449                                        phLibNfc_Llcp_sLinkParameters_t*   pConfigInfo
    450                                        )
    451 {
    452    NFCSTATUS result;
    453 
    454    /* State checking */
    455    result = static_CheckState();
    456    if (result != NFCSTATUS_SUCCESS)
    457    {
    458       return result;
    459    }
    460 
    461    /* Parameters checking */
    462    if ((hRemoteDevice == 0) ||
    463        (pConfigInfo == NULL))
    464    {
    465       return NFCSTATUS_INVALID_PARAMETER;
    466    }
    467 
    468    /* Check device */
    469    result = static_CheckDevice(hRemoteDevice);
    470    if (result != NFCSTATUS_SUCCESS)
    471    {
    472       return result;
    473    }
    474 
    475    /* Get local infos */
    476    result = phFriNfc_Llcp_GetRemoteInfo(&gpphLibContext->llcp_cntx.sLlcpContext, pConfigInfo);
    477 
    478    return PHNFCSTATUS(result);
    479 }
    480 
    481 NFCSTATUS phLibNfc_Llcp_Socket( phLibNfc_Llcp_eSocketType_t      eType,
    482                                 phLibNfc_Llcp_sSocketOptions_t*  psOptions,
    483                                 phNfc_sData_t*                   psWorkingBuffer,
    484                                 phLibNfc_Handle*                 phSocket,
    485                                 pphLibNfc_LlcpSocketErrCb_t      pErr_Cb,
    486                                 void*                            pContext
    487                                 )
    488 {
    489    NFCSTATUS                        result;
    490    phFriNfc_LlcpTransport_Socket_t  *psSocket;
    491 
    492    /* State checking */
    493    result = static_CheckState();
    494    if (result != NFCSTATUS_SUCCESS)
    495    {
    496       return result;
    497    }
    498 
    499    /* Parameters checking */
    500    /* NOTE: Transport Layer test psOption and psWorkingBuffer value */
    501    if ((phSocket == NULL)        ||
    502        (pErr_Cb == NULL))
    503    {
    504       return NFCSTATUS_INVALID_PARAMETER;
    505    }
    506 
    507    /* Get local infos */
    508    result = phFriNfc_LlcpTransport_Socket(&gpphLibContext->llcp_cntx.sLlcpTransportContext,
    509                                           eType,
    510                                           psOptions,
    511                                           psWorkingBuffer,
    512                                           &psSocket,
    513                                           pErr_Cb,
    514                                           pContext);
    515 
    516    /* Send back the socket handle */
    517    *phSocket = (phLibNfc_Handle)psSocket;
    518 
    519    return PHNFCSTATUS(result);
    520 }
    521 
    522 NFCSTATUS phLibNfc_Llcp_Close( phLibNfc_Handle hSocket )
    523 {
    524    NFCSTATUS                        result;
    525    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    526 
    527    /* State checking */
    528    result = static_CheckState();
    529    if (result != NFCSTATUS_SUCCESS)
    530    {
    531       return result;
    532    }
    533 
    534    /* Parameters checking */
    535    if (hSocket == 0)
    536    {
    537       return NFCSTATUS_INVALID_PARAMETER;
    538    }
    539 
    540    /* Get local infos */
    541    /* TODO: if connected abort and close else close only */
    542    result = phFriNfc_LlcpTransport_Close(psSocket);
    543 
    544    return PHNFCSTATUS(result);
    545 }
    546 
    547 NFCSTATUS phLibNfc_Llcp_SocketGetLocalOptions( phLibNfc_Handle                  hSocket,
    548                                                phLibNfc_Llcp_sSocketOptions_t*  psLocalOptions
    549                                                )
    550 {
    551    NFCSTATUS                        result;
    552    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    553 
    554    /* State checking */
    555    result = static_CheckState();
    556    if (result != NFCSTATUS_SUCCESS)
    557    {
    558       return result;
    559    }
    560 
    561    /* Parameters checking */
    562    if ((hSocket == 0) ||
    563        (psLocalOptions == NULL))
    564    {
    565       return NFCSTATUS_INVALID_PARAMETER;
    566    }
    567 
    568    /* Get local options */
    569    result = phFriNfc_LlcpTransport_SocketGetLocalOptions(psSocket, psLocalOptions);
    570 
    571    return PHNFCSTATUS(result);
    572 }
    573 
    574 NFCSTATUS phLibNfc_Llcp_SocketGetRemoteOptions( phLibNfc_Handle                  hRemoteDevice,
    575                                                 phLibNfc_Handle                  hSocket,
    576                                                 phLibNfc_Llcp_sSocketOptions_t*  psRemoteOptions
    577                                                 )
    578 {
    579    NFCSTATUS                        result;
    580    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    581 
    582    LLCP_PRINT("phLibNfc_Llcp_SocketGetRemoteOptions");
    583 
    584    /* State checking */
    585    result = static_CheckState();
    586    if (result != NFCSTATUS_SUCCESS)
    587    {
    588       return result;
    589    }
    590 
    591    /* Parameters checking */
    592    if ((hRemoteDevice == 0) ||
    593        (hSocket == 0)       ||
    594        (psRemoteOptions == NULL))
    595    {
    596       return NFCSTATUS_INVALID_PARAMETER;
    597    }
    598 
    599    /* Check device */
    600    result = static_CheckDevice(hRemoteDevice);
    601    if (result != NFCSTATUS_SUCCESS)
    602    {
    603       return result;
    604    }
    605 
    606    /* Get remote infos */
    607    result = phFriNfc_LlcpTransport_SocketGetRemoteOptions(psSocket, psRemoteOptions);
    608 
    609    return PHNFCSTATUS(result);
    610 }
    611 
    612 NFCSTATUS phLibNfc_Llcp_Bind( phLibNfc_Handle hSocket,
    613                               uint8_t         nSap
    614                               )
    615 {
    616    NFCSTATUS                        result;
    617    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    618 
    619    LLCP_PRINT("phLibNfc_Llcp_Bind");
    620 
    621    /* State checking */
    622    result = static_CheckState();
    623    if (result != NFCSTATUS_SUCCESS)
    624    {
    625       return result;
    626    }
    627 
    628    /* Parameters checking */
    629    if (hSocket == 0)
    630    {
    631       return NFCSTATUS_INVALID_PARAMETER;
    632    }
    633 
    634    /* Bind the socket to the designated port */
    635    result = phFriNfc_LlcpTransport_Bind(psSocket, nSap);
    636 
    637    return PHNFCSTATUS(result);
    638 }
    639 
    640 NFCSTATUS phLibNfc_Llcp_Listen( phLibNfc_Handle                  hSocket,
    641                                 phNfc_sData_t                    *psServiceName,
    642                                 pphLibNfc_LlcpSocketListenCb_t   pListen_Cb,
    643                                 void*                            pContext
    644                                 )
    645 {
    646    NFCSTATUS                        result;
    647    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    648 
    649    LLCP_PRINT("phLibNfc_Llcp_Listen");
    650 
    651    /* State checking */
    652    result = static_CheckState();
    653    if (result != NFCSTATUS_SUCCESS)
    654    {
    655       return result;
    656    }
    657 
    658    /* Parameters checking */
    659    /* NOTE : psServiceName may be NULL, do not test it ! */
    660    if ((hSocket == 0) ||
    661        (pListen_Cb == NULL))
    662    {
    663       return NFCSTATUS_INVALID_PARAMETER;
    664    }
    665 
    666    /* Start listening for incoming connections */
    667    result = phFriNfc_LlcpTransport_Listen( psSocket,
    668                                            psServiceName,
    669                                            (pphFriNfc_LlcpTransportSocketListenCb_t)pListen_Cb,
    670                                            pContext );
    671 
    672    return PHNFCSTATUS(result);
    673 }
    674 
    675 NFCSTATUS phLibNfc_Llcp_Accept( phLibNfc_Handle                  hSocket,
    676                                 phLibNfc_Llcp_sSocketOptions_t*  psOptions,
    677                                 phNfc_sData_t*                   psWorkingBuffer,
    678                                 pphLibNfc_LlcpSocketErrCb_t      pErr_Cb,
    679                                 pphLibNfc_LlcpSocketAcceptCb_t   pAccept_RspCb,
    680                                 void*                            pContext
    681                                 )
    682 {
    683    NFCSTATUS                        result;
    684    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    685 
    686    LLCP_PRINT("phLibNfc_Llcp_Accept");
    687 
    688    /* State checking */
    689    result = static_CheckState();
    690    if (result != NFCSTATUS_SUCCESS)
    691    {
    692       return result;
    693    }
    694 
    695    /* Parameters checking */
    696    if ((hSocket == 0)            ||
    697        (psOptions == NULL)       ||
    698        (psWorkingBuffer == NULL) ||
    699        (pErr_Cb == NULL)         ||
    700        (pAccept_RspCb == NULL))
    701    {
    702       return NFCSTATUS_INVALID_PARAMETER;
    703    }
    704 
    705    /* Accept incoming connection */
    706    result = phFriNfc_LlcpTransport_Accept( psSocket,
    707                                            psOptions,
    708                                            psWorkingBuffer,
    709                                            pErr_Cb,
    710                                            pAccept_RspCb,
    711                                            pContext );
    712 
    713    return PHNFCSTATUS(result);
    714 }
    715 
    716 NFCSTATUS phLibNfc_Llcp_Reject( phLibNfc_Handle                  hRemoteDevice,
    717                                 phLibNfc_Handle                  hSocket,
    718                                 pphLibNfc_LlcpSocketRejectCb_t   pReject_RspCb,
    719                                 void*                            pContext
    720                                 )
    721 {
    722    NFCSTATUS                        result;
    723    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    724 
    725    LLCP_PRINT("phLibNfc_Llcp_Reject");
    726 
    727    /* State checking */
    728    result = static_CheckState();
    729    if (result != NFCSTATUS_SUCCESS)
    730    {
    731       return result;
    732    }
    733 
    734    /* Parameters checking */
    735    if ((hRemoteDevice == 0)      ||
    736        (hSocket == 0)            ||
    737        (pReject_RspCb == NULL))
    738    {
    739       return NFCSTATUS_INVALID_PARAMETER;
    740    }
    741 
    742    /* Check device */
    743    result = static_CheckDevice(hRemoteDevice);
    744    if (result != NFCSTATUS_SUCCESS)
    745    {
    746       return result;
    747    }
    748 
    749    /* Reject incoming connection */
    750    result = phFriNfc_LlcpTransport_Reject( psSocket,
    751                                            pReject_RspCb,
    752                                            pContext );
    753 
    754    return PHNFCSTATUS(result);
    755 }
    756 
    757 NFCSTATUS phLibNfc_Llcp_Connect( phLibNfc_Handle                 hRemoteDevice,
    758                                  phLibNfc_Handle                 hSocket,
    759                                  uint8_t                         nSap,
    760                                  pphLibNfc_LlcpSocketConnectCb_t pConnect_RspCb,
    761                                  void*                           pContext
    762                                  )
    763 {
    764    NFCSTATUS                        result;
    765    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    766 
    767    LLCP_PRINT("phLibNfc_Llcp_Connect");
    768 
    769    /* State checking */
    770    result = static_CheckState();
    771    if (result != NFCSTATUS_SUCCESS)
    772    {
    773       return result;
    774    }
    775 
    776    /* Parameters checking */
    777    if ((hRemoteDevice == 0)      ||
    778 	   (hSocket == 0)            ||
    779        (pConnect_RspCb == NULL))
    780    {
    781       LLCP_PRINT("phLibNfc_Llcp_Connect NFCSTATUS_INVALID_PARAMETER");
    782       return NFCSTATUS_INVALID_PARAMETER;
    783    }
    784 
    785    /* Check device */
    786    result = static_CheckDevice(hRemoteDevice);
    787    if (result != NFCSTATUS_SUCCESS)
    788    {
    789       return result;
    790    }
    791 
    792    /* Try to connect on a remote service, given its SAP */
    793    result = phFriNfc_LlcpTransport_Connect( psSocket,
    794                                             nSap,
    795                                             pConnect_RspCb,
    796                                             pContext );
    797 
    798    return PHNFCSTATUS(result);
    799 }
    800 
    801 NFCSTATUS phLibNfc_Llcp_ConnectByUri( phLibNfc_Handle                 hRemoteDevice,
    802                                       phLibNfc_Handle                 hSocket,
    803                                       phNfc_sData_t*                  psUri,
    804                                       pphLibNfc_LlcpSocketConnectCb_t pConnect_RspCb,
    805                                       void*                           pContext
    806                                       )
    807 {
    808    NFCSTATUS                        result;
    809    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    810 
    811    LLCP_PRINT("phLibNfc_Llcp_ConnectByUri");
    812 
    813    /* State checking */
    814    result = static_CheckState();
    815    if (result != NFCSTATUS_SUCCESS)
    816    {
    817       return result;
    818    }
    819 
    820    /* Parameters checking */
    821    if ((hRemoteDevice == 0)      ||
    822        (hSocket == 0)            ||
    823        (psUri   == NULL)         ||
    824        (pConnect_RspCb == NULL))
    825    {
    826       LLCP_PRINT("phLibNfc_Llcp_ConnectByUri NFCSTATUS_INVALID_PARAMETER");
    827       return NFCSTATUS_INVALID_PARAMETER;
    828    }
    829 
    830    /* Check device */
    831    result = static_CheckDevice(hRemoteDevice);
    832    if (result != NFCSTATUS_SUCCESS)
    833    {
    834       return result;
    835    }
    836 
    837    /* Try to connect on a remote service, using SDP */
    838    result = phFriNfc_LlcpTransport_ConnectByUri( psSocket,
    839                                                  psUri,
    840                                                  pConnect_RspCb,
    841                                                  pContext );
    842 
    843    return PHNFCSTATUS(result);
    844 }
    845 
    846 NFCSTATUS phLibNfc_Llcp_Disconnect( phLibNfc_Handle                    hRemoteDevice,
    847                                     phLibNfc_Handle                    hSocket,
    848                                     pphLibNfc_LlcpSocketDisconnectCb_t pDisconnect_RspCb,
    849                                     void*                              pContext
    850                                     )
    851 {
    852    NFCSTATUS                        result;
    853    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    854 
    855    LLCP_PRINT("phLibNfc_Llcp_Disconnect");
    856 
    857    /* State checking */
    858    result = static_CheckState();
    859    if (result != NFCSTATUS_SUCCESS)
    860    {
    861       return result;
    862    }
    863 
    864    /* Parameters checking */
    865    if ((hRemoteDevice == 0) ||
    866        (hSocket == 0)       ||
    867        (pDisconnect_RspCb == NULL))
    868    {
    869       return NFCSTATUS_INVALID_PARAMETER;
    870    }
    871 
    872    /* Check device */
    873    result = static_CheckDevice(hRemoteDevice);
    874    if (result != NFCSTATUS_SUCCESS)
    875    {
    876       return result;
    877    }
    878 
    879    /* Disconnect a logical link */
    880    result = phFriNfc_LlcpTransport_Disconnect( psSocket,
    881                                                pDisconnect_RspCb,
    882                                                pContext );
    883 
    884    return PHNFCSTATUS(result);
    885 }
    886 
    887 NFCSTATUS phLibNfc_Llcp_Recv( phLibNfc_Handle              hRemoteDevice,
    888                               phLibNfc_Handle              hSocket,
    889                               phNfc_sData_t*               psBuffer,
    890                               pphLibNfc_LlcpSocketRecvCb_t pRecv_RspCb,
    891                               void*                        pContext
    892                               )
    893 {
    894    NFCSTATUS                        result;
    895    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    896 
    897    LLCP_PRINT("phLibNfc_Llcp_Recv");
    898 
    899    /* State checking */
    900    result = static_CheckState();
    901    if (result != NFCSTATUS_SUCCESS)
    902    {
    903       return result;
    904    }
    905 
    906    /* Parameters checking */
    907    if ((hRemoteDevice == 0)   ||
    908        (hSocket == 0)         ||
    909        (psBuffer == NULL)     ||
    910        (pRecv_RspCb == NULL))
    911    {
    912       return NFCSTATUS_INVALID_PARAMETER;
    913    }
    914 
    915    /* Check device */
    916    result = static_CheckDevice(hRemoteDevice);
    917    if (result != NFCSTATUS_SUCCESS)
    918    {
    919       return result;
    920    }
    921 
    922    /* Receive data from the logical link */
    923    result = phFriNfc_LlcpTransport_Recv( psSocket,
    924                                          psBuffer,
    925                                          pRecv_RspCb,
    926                                          pContext );
    927 
    928    return PHNFCSTATUS(result);
    929 }
    930 
    931 NFCSTATUS phLibNfc_Llcp_RecvFrom( phLibNfc_Handle                   hRemoteDevice,
    932                                   phLibNfc_Handle                   hSocket,
    933                                   phNfc_sData_t*                    psBuffer,
    934                                   pphLibNfc_LlcpSocketRecvFromCb_t  pRecv_Cb,
    935                                   void*                             pContext
    936                                   )
    937 {
    938    NFCSTATUS                        result;
    939    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    940 
    941    LLCP_PRINT("phLibNfc_Llcp_RecvFrom");
    942 
    943    /* State checking */
    944    result = static_CheckState();
    945    if (result != NFCSTATUS_SUCCESS)
    946    {
    947       return result;
    948    }
    949 
    950    /* Parameters checking */
    951    if ((hRemoteDevice == 0)   ||
    952        (hSocket == 0)         ||
    953        (psBuffer == NULL)     ||
    954        (pRecv_Cb == NULL))
    955    {
    956       return NFCSTATUS_INVALID_PARAMETER;
    957    }
    958 
    959    /* Check device */
    960    result = static_CheckDevice(hRemoteDevice);
    961    if (result != NFCSTATUS_SUCCESS)
    962    {
    963       return result;
    964    }
    965 
    966    /* Receive data from the logical link */
    967    result = phFriNfc_LlcpTransport_RecvFrom( psSocket,
    968                                              psBuffer,
    969                                              pRecv_Cb,
    970                                              pContext );
    971 
    972    return PHNFCSTATUS(result);
    973 }
    974 
    975 NFCSTATUS phLibNfc_Llcp_Send( phLibNfc_Handle              hRemoteDevice,
    976                               phLibNfc_Handle              hSocket,
    977                               phNfc_sData_t*               psBuffer,
    978                               pphLibNfc_LlcpSocketSendCb_t pSend_RspCb,
    979                               void*                        pContext
    980                               )
    981 {
    982    NFCSTATUS                        result;
    983    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
    984 
    985    LLCP_PRINT("phLibNfc_Llcp_Send");
    986 
    987    /* State checking */
    988    result = static_CheckState();
    989    if (result != NFCSTATUS_SUCCESS)
    990    {
    991       return result;
    992    }
    993 
    994    /* Parameters checking */
    995    if ((hRemoteDevice == 0)   ||
    996        (hSocket == 0)         ||
    997        (psBuffer == NULL)     ||
    998        (pSend_RspCb == NULL))
    999    {
   1000       return NFCSTATUS_INVALID_PARAMETER;
   1001    }
   1002 
   1003    /* Check device */
   1004    result = static_CheckDevice(hRemoteDevice);
   1005    if (result != NFCSTATUS_SUCCESS)
   1006    {
   1007       return result;
   1008    }
   1009 
   1010    /* Send data to the logical link */
   1011    result = phFriNfc_LlcpTransport_Send( psSocket,
   1012                                          psBuffer,
   1013                                          pSend_RspCb,
   1014                                          pContext );
   1015 
   1016    return PHNFCSTATUS(result);
   1017 }
   1018 
   1019 NFCSTATUS phLibNfc_Llcp_SendTo( phLibNfc_Handle               hRemoteDevice,
   1020                                 phLibNfc_Handle               hSocket,
   1021                                 uint8_t                       nSap,
   1022                                 phNfc_sData_t*                psBuffer,
   1023                                 pphLibNfc_LlcpSocketSendCb_t  pSend_RspCb,
   1024                                 void*                         pContext
   1025                                 )
   1026 {
   1027    NFCSTATUS                        result;
   1028    phFriNfc_LlcpTransport_Socket_t  *psSocket = (phFriNfc_LlcpTransport_Socket_t*)hSocket;
   1029 
   1030    LLCP_PRINT("phLibNfc_Llcp_SendTo");
   1031 
   1032    /* State checking */
   1033    result = static_CheckState();
   1034    if (result != NFCSTATUS_SUCCESS)
   1035    {
   1036       return result;
   1037    }
   1038 
   1039    /* Parameters checking */
   1040    if ((hRemoteDevice == 0)   ||
   1041        (hSocket == 0)         ||
   1042        (psBuffer == NULL)     ||
   1043        (pSend_RspCb == NULL))
   1044    {
   1045       return NFCSTATUS_INVALID_PARAMETER;
   1046    }
   1047 
   1048    /* Check device */
   1049    result = static_CheckDevice(hRemoteDevice);
   1050    if (result != NFCSTATUS_SUCCESS)
   1051    {
   1052       return result;
   1053    }
   1054 
   1055    /* Send data to the logical link */
   1056    result = phFriNfc_LlcpTransport_SendTo( psSocket,
   1057                                            nSap,
   1058                                            psBuffer,
   1059                                            pSend_RspCb,
   1060                                            pContext );
   1061 
   1062    return PHNFCSTATUS(result);
   1063 }
   1064