nfc.c

Go to the documentation of this file.

/*-
 * Public platform independent Near Field Communication (NFC) library
 * 
 * Copyright (C) 2009, Roel Verdult, Romuald Conty
 * Copyright (C) 2010, Roel Verdult, Romuald Conty, Romain Tartière
 * 
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif // HAVE_CONFIG_H

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>

#include <nfc/nfc.h>

#ifdef _WIN32
#  include "../contrib/windows.h"
#endif

#include "chips.h"
#include "drivers.h"

#include <nfc/nfc-messages.h>

nfc_device_desc_t *nfc_pick_device (void);

nfc_device_t *
nfc_connect (nfc_device_desc_t * pndd)
{
  nfc_device_t *pnd = NULL;
  uint32_t uiDriver;

  // Search through the device list for an available device
  for (uiDriver = 0; uiDriver < sizeof (drivers_callbacks_list) / sizeof (drivers_callbacks_list[0]); uiDriver++) {
    if (pndd == NULL) {
      // No device description specified: try to automatically claim a device
      if (drivers_callbacks_list[uiDriver].pick_device != NULL) {
        DBG ("Autodetecting available devices using %s driver.", drivers_callbacks_list[uiDriver].acDriver);
        pndd = drivers_callbacks_list[uiDriver].pick_device ();

        if (pndd != NULL) {
          DBG ("Auto-connecting to %s using %s driver", pndd->acDevice, drivers_callbacks_list[uiDriver].acDriver);
          pnd = drivers_callbacks_list[uiDriver].connect (pndd);
          if (pnd == NULL) {
            DBG ("No device available using %s driver", drivers_callbacks_list[uiDriver].acDriver);
            pndd = NULL;
          }

          free (pndd);
        }
      }
    } else {
      // Specific device is requested: using device description pndd
      if (0 != strcmp (drivers_callbacks_list[uiDriver].acDriver, pndd->pcDriver)) {
        continue;
      } else {
        pnd = drivers_callbacks_list[uiDriver].connect (pndd);
      }
    }

    // Test if the connection was successful
    if (pnd != NULL) {
      DBG ("[%s] has been claimed.", pnd->acName);
      // Great we have claimed a device
      pnd->pdc = &(drivers_callbacks_list[uiDriver]);

      if (!pn53x_init (pnd))
        return NULL;

      // Set default configuration options
      // Make sure we reset the CRC and parity to chip handling.
      if (!nfc_configure (pnd, NDO_HANDLE_CRC, true))
        return NULL;
      if (!nfc_configure (pnd, NDO_HANDLE_PARITY, true))
        return NULL;

      // Deactivate the CRYPTO1 cipher, it may could cause problems when still active
      if (!nfc_configure (pnd, NDO_ACTIVATE_CRYPTO1, false))
        return NULL;

      // Activate "easy framing" feature by default
      if (!nfc_configure (pnd, NDO_EASY_FRAMING, true))
        return NULL;

      // Activate auto ISO14443-4 switching by default
      if (!nfc_configure (pnd, NDO_AUTO_ISO14443_4, true))
        return NULL;

      // Disallow invalid frame
      if (!nfc_configure (pnd, NDO_ACCEPT_INVALID_FRAMES, false))
        return NULL;

      // Disallow multiple frames
      if (!nfc_configure (pnd, NDO_ACCEPT_MULTIPLE_FRAMES, false))
        return NULL;

      return pnd;
    } else {
      DBG ("No device found using driver: %s", drivers_callbacks_list[uiDriver].acDriver);
    }
  }
  // Too bad, no reader is ready to be claimed
  return NULL;
}

void
nfc_disconnect (nfc_device_t * pnd)
{
  if (pnd) {
    // Release and deselect all active communications
    nfc_initiator_deselect_target (pnd);
    // Disable RF field to avoid heating
    nfc_configure (pnd, NDO_ACTIVATE_FIELD, false);
    // Disconnect, clean up and release the device 
    pnd->pdc->disconnect (pnd);
  }
}

nfc_device_desc_t *
nfc_pick_device (void)
{
  uint32_t uiDriver;
  nfc_device_desc_t *nddRes;

  for (uiDriver = 0; uiDriver < sizeof (drivers_callbacks_list) / sizeof (drivers_callbacks_list[0]); uiDriver++) {
    if (drivers_callbacks_list[uiDriver].pick_device != NULL) {
      nddRes = drivers_callbacks_list[uiDriver].pick_device ();
      if (nddRes != NULL)
        return nddRes;
    }
  }

  return NULL;
}

void
nfc_list_devices (nfc_device_desc_t pnddDevices[], size_t szDevices, size_t * pszDeviceFound)
{
  uint32_t uiDriver;
  size_t  szN;

  *pszDeviceFound = 0;

  for (uiDriver = 0; uiDriver < sizeof (drivers_callbacks_list) / sizeof (drivers_callbacks_list[0]); uiDriver++) {
    if (drivers_callbacks_list[uiDriver].list_devices != NULL) {
      szN = 0;
      if (drivers_callbacks_list[uiDriver].list_devices
          (pnddDevices + (*pszDeviceFound), szDevices - (*pszDeviceFound), &szN)) {
        *pszDeviceFound += szN;
        DBG ("%ld device(s) found using %s driver", (unsigned long) szN, drivers_callbacks_list[uiDriver].acDriver);
      }
    } else {
      DBG ("No listing function avaible for %s driver", drivers_callbacks_list[uiDriver].acDriver);
    }
  }
}

bool
nfc_configure (nfc_device_t * pnd, const nfc_device_option_t ndo, const bool bEnable)
{
  pnd->iLastError = 0;

  return pn53x_configure (pnd, ndo, bEnable);
}

bool
nfc_initiator_init (nfc_device_t * pnd)
{
  pnd->iLastError = 0;

  // Make sure we are dealing with a active device
  if (!pnd->bActive)
    return false;

  // Set the PN53X to force 100% ASK Modified miller decoding (default for 14443A cards)
  if (!pn53x_set_reg (pnd, REG_CIU_TX_AUTO, SYMBOL_FORCE_100_ASK, 0x40))
    return false;

  // Configure the PN53X to be an Initiator or Reader/Writer
  if (!pn53x_set_reg (pnd, REG_CIU_CONTROL, SYMBOL_INITIATOR, 0x10))
    return false;

  return true;
}

bool
nfc_initiator_select_passive_target (nfc_device_t * pnd,
                                     const nfc_modulation_t nm,
                                     const byte_t * pbtInitData, const size_t szInitData,
                                     nfc_target_t * pnt)
{
  byte_t  abtInit[MAX_FRAME_LEN];
  size_t  szInit;

  pnd->iLastError = 0;

  // Make sure we are dealing with a active device
  if (!pnd->bActive)
    return false;
  // TODO Put this in a function: this part is defined by ISO14443-3 (UID and Cascade levels)
  switch (nm.nmt) {
  case NMT_ISO14443A:
    switch (szInitData) {
    case 7:
      abtInit[0] = 0x88;
      memcpy (abtInit + 1, pbtInitData, 7);
      szInit = 8;
      break;

    case 10:
      abtInit[0] = 0x88;
      memcpy (abtInit + 1, pbtInitData, 3);
      abtInit[4] = 0x88;
      memcpy (abtInit + 5, pbtInitData + 3, 7);
      szInit = 12;
      break;

    case 4:
    default:
      memcpy (abtInit, pbtInitData, szInitData);
      szInit = szInitData;
      break;
    }
    break;

  default:
    memcpy (abtInit, pbtInitData, szInitData);
    szInit = szInitData;
    break;
  }

  return pn53x_initiator_select_passive_target (pnd, nm, abtInit, szInit, pnt);
}

bool
nfc_initiator_list_passive_targets (nfc_device_t * pnd,
                                    const nfc_modulation_t nm,
                                    nfc_target_t ant[], const size_t szTargets, size_t * pszTargetFound)
{
  nfc_target_t nt;
  size_t  szTargetFound = 0;
  byte_t *pbtInitData = NULL;
  size_t  szInitDataLen = 0;

  pnd->iLastError = 0;

  // Drop the field for a while
  if (!nfc_configure (pnd, NDO_ACTIVATE_FIELD, false)) {
    return false;
  }
  // Let the reader only try once to find a tag
  if (!nfc_configure (pnd, NDO_INFINITE_SELECT, false)) {
    return false;
  }
  // Enable field so more power consuming cards can power themselves up
  if (!nfc_configure (pnd, NDO_ACTIVATE_FIELD, true)) {
    return false;
  }

  switch (nm.nmt) {
    case NMT_ISO14443B: {
      // Application Family Identifier (AFI) must equals 0x00 in order to wakeup all ISO14443-B PICCs (see ISO/IEC 14443-3)
      pbtInitData = (byte_t *) "\x00";
      szInitDataLen = 1;
    }
    break;
    case NMT_FELICA: {
      // polling payload must be present (see ISO/IEC 18092 11.2.2.5)
      pbtInitData = (byte_t *) "\x00\xff\xff\x01\x00";
      szInitDataLen = 5;
    }
    break;
    default:
      // nothing to do
    break;
  }

  while (nfc_initiator_select_passive_target (pnd, nm, pbtInitData, szInitDataLen, &nt)) {
    nfc_initiator_deselect_target (pnd);

    if (szTargets > szTargetFound) {
      memcpy (&(ant[szTargetFound]), &nt, sizeof (nfc_target_t));
    } else {
      break;
    }
    szTargetFound++;
    // deselect has no effect on FeliCa and Jewel cards so we'll stop after one...
    if ((nm.nmt == NMT_FELICA) || (nm.nmt == NMT_JEWEL)) {
        break;
    }
  }
  *pszTargetFound = szTargetFound;

  return true;
}

bool
nfc_initiator_poll_targets (nfc_device_t * pnd,
                            const nfc_modulation_t * pnmModulations, const size_t szModulations,
                            const byte_t btPollNr, const byte_t btPeriod,
                            nfc_target_t * pntTargets, size_t * pszTargetFound)
{
  pnd->iLastError = 0;

  return pn53x_initiator_poll_targets (pnd, pnmModulations, szModulations, btPollNr, btPeriod, pntTargets, pszTargetFound);
}


bool
nfc_initiator_select_dep_target (nfc_device_t * pnd, 
                                 const nfc_dep_mode_t ndm, const nfc_baud_rate_t nbr,
                                 const nfc_dep_info_t * pndiInitiator, nfc_target_t * pnt)
{
  pnd->iLastError = 0;

  return pn53x_initiator_select_dep_target (pnd, ndm, nbr, pndiInitiator, pnt);
}

bool
nfc_initiator_deselect_target (nfc_device_t * pnd)
{
  pnd->iLastError = 0;

  return (pn53x_InDeselect (pnd, 0));   // 0 mean deselect all selected targets
}

bool
nfc_initiator_transceive_bytes (nfc_device_t * pnd, const byte_t * pbtTx, const size_t szTx, byte_t * pbtRx,
                                size_t * pszRx)
{
  pnd->iLastError = 0;

  return pn53x_initiator_transceive_bytes (pnd, pbtTx, szTx, pbtRx, pszRx);
}

bool
nfc_initiator_transceive_bits (nfc_device_t * pnd, const byte_t * pbtTx, const size_t szTxBits, const byte_t * pbtTxPar,
                               byte_t * pbtRx, size_t * pszRxBits, byte_t * pbtRxPar)
{
  pnd->iLastError = 0;

  return pn53x_initiator_transceive_bits (pnd, pbtTx, szTxBits, pbtTxPar, pbtRx, pszRxBits, pbtRxPar);
}

bool
nfc_target_init (nfc_device_t * pnd, nfc_target_t * pnt, byte_t * pbtRx, size_t * pszRx)
{
  pnd->iLastError = 0;

  return pn53x_target_init (pnd, pnt, pbtRx, pszRx);
}

bool
nfc_target_send_bytes (nfc_device_t * pnd, const byte_t * pbtTx, const size_t szTx)
{
  pnd->iLastError = 0;

  return pn53x_target_send_bytes (pnd, pbtTx, szTx);
}

bool
nfc_target_receive_bytes (nfc_device_t * pnd, byte_t * pbtRx, size_t * pszRx)
{
  pnd->iLastError = 0;

  return pn53x_target_receive_bytes (pnd, pbtRx, pszRx);
}

bool
nfc_target_send_bits (nfc_device_t * pnd, const byte_t * pbtTx, const size_t szTxBits, const byte_t * pbtTxPar)
{
  pnd->iLastError = 0;

  return pn53x_target_send_bits (pnd, pbtTx, szTxBits, pbtTxPar);
}

bool
nfc_target_receive_bits (nfc_device_t * pnd, byte_t * pbtRx, size_t * pszRxBits, byte_t * pbtRxPar)
{
  pnd->iLastError = 0;

  return pn53x_target_receive_bits (pnd, pbtRx, pszRxBits, pbtRxPar);
}

const char *
nfc_strerror (const nfc_device_t * pnd)
{
  return pnd->pdc->pcc->strerror (pnd);
}

int
nfc_strerror_r (const nfc_device_t * pnd, char *pcStrErrBuf, size_t szBufLen)
{
  return (snprintf (pcStrErrBuf, szBufLen, "%s", nfc_strerror (pnd)) < 0) ? -1 : 0;
}

void
nfc_perror (const nfc_device_t * pnd, const char *pcString)
{
  fprintf (stderr, "%s: %s\n", pcString, nfc_strerror (pnd));
}

/* Special data accessors */

const char *
nfc_device_name (nfc_device_t * pnd)
{
  return pnd->acName;
}

/* Misc. functions */

const char *
nfc_version (void)
{
#ifdef SVN_REVISION
  return PACKAGE_VERSION " (r" SVN_REVISION ")";
#else
  return PACKAGE_VERSION;
#endif // SVN_REVISION
}