Documentation ¶
Overview ¶
This package wraps the libnfc to provide an API for Go. Most documentation was taken unchanged from the documentation inside the libnfc. Some functions and names have been altered to fit the conventions and idioms used in Go.
This package is licensed under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, version 3.
Index ¶
- Constants
- func AppendISO14443aCRC(data []byte) []byte
- func AppendISO14443bCRC(data []byte) []byte
- func ISO14443CascadeUID(uid []byte) (cascadedUID []byte)
- func ISO14443aCRC(data []byte) [2]byte
- func ISO14443aLocateHistoricalBytes(ats []byte) []byte
- func ISO14443bCRC(data []byte) [2]byte
- func ListDevices() ([]string, error)
- func TargetString(t Target, verbose bool) (string, error)
- func Version() string
- type DEPTarget
- type Device
- func (d Device) AbortCommand() error
- func (d Device) Close() error
- func (d Device) Connection() string
- func (d Device) GoString() string
- func (d Device) Idle() error
- func (d Device) Information() (string, error)
- func (d Device) InitiatorDeselectTarget() error
- func (d Device) InitiatorInit() error
- func (d Device) InitiatorInitSecureElement() error
- func (d Device) InitiatorListPassiveTargets(m Modulation) ([]Target, error)
- func (d Device) InitiatorSelectPassiveTarget(m Modulation, initData []byte) (Target, error)
- func (d Device) InitiatorTargetIsPresent(t Target) error
- func (d Device) InitiatorTransceiveBits(tx, txPar []byte, txLength uint, rx, rxPar []byte) (n int, err error)
- func (d Device) InitiatorTransceiveBitsTimed(tx, txPar []byte, txLength uint, rx, rxPar []byte, cycles uint32) (n int, c uint32, err error)
- func (d Device) InitiatorTransceiveBytes(tx, rx []byte, timeout int) (n int, err error)
- func (d Device) InitiatorTransceiveBytesTimed(tx, rx []byte, cycles uint32) (n int, c uint32, err error)
- func (d Device) LastError() error
- func (d Device) Pointer() uintptr
- func (d Device) SetPropertyBool(property int, value bool) error
- func (d Device) SetPropertyInt(property, value int) error
- func (d Device) String() string
- func (d Device) SupportedBaudRates(modulationType int) ([]int, error)
- func (d Device) SupportedModulations(mode int) ([]int, error)
- func (d Device) TargetInit(t Target, rx []byte, timeout int) (n int, tt Target, err error)
- func (d Device) TargetReceiveBytes(rx []byte, timeout int) (n int, err error)
- func (d Device) TargetSendBits(tx []byte, txPar []byte, txLength uint) (n int, err error)
- func (d Device) TargetSendBytes(tx []byte, timeout int) (n int, err error)
- func (d Device) TargetTransceiveBits(rx []byte, rxPar []byte, rxLength uint) (n int, err error)
- type Error
- type FelicaTarget
- type ISO14443aTarget
- type ISO14443b2ctTarget
- type ISO14443b2srTarget
- type ISO14443bTarget
- type ISO14443biTarget
- type JewelTarget
- type Modulation
- type Target
Constants ¶
const ( // Default command processing timeout // Property value's (duration) unit is ms and 0 means no timeout (infinite). // Default value is set by driver layer TimeoutCommand = iota // Timeout between ATR_REQ and ATR_RES // When the device is in initiator mode, a target is considered as mute // if no valid ATR_RES is received within this timeout value. // Default value for this property is 103 ms on PN53x based devices. TimeoutATR // Timeout value to give up reception from the target in case of no answer. // Default value for this property is 52 ms). TimeoutCom // Let the PN53X chip handle the CRC bytes. This means that the chip // appends the CRC bytes to the frames that are transmitted. It will // parse the last bytes from received frames as incoming CRC bytes. They // will be verified against the used modulation and protocol. If a frame // is expected with incorrect CRC bytes this option should be disabled. // Example frames where this is useful are the ATQA and UID+BCC that are // transmitted without CRC bytes during the anti-collision phase of the // ISO14443-A protocol. HandleCRC // Parity bits in the network layer of ISO14443-A are by default // generated and validated in the PN53X chip. This is a very convenient // feature. On certain times though it is useful to get full control of // the transmitted data. The proprietary MIFARE Classic protocol uses // for example custom (encrypted) parity bits. For interoperability it // is required to be completely compatible, including the arbitrary // parity bits. When this option is disabled, the functions to // communicating bits should be used. HandleParity // This option can be used to enable or disable the electronic field of // the NFC device. ActivateField // The internal CRYPTO1 co-processor can be used to transmit messages // encrypted. This option is automatically activated after a successful // MIFARE Classic authentication. ActivateCrypto1 // The default configuration defines that the PN53X chip will try // indefinitely to invite a tag in the field to respond. This could be // desired when it is certain a tag will enter the field. On the other // hand, when this is uncertain, it will block the application. This // option could best be compared to the (NON)BLOCKING option used by // (socket)network programming. InfiniteSelect // If this option is enabled, frames that carry less than 4 bits are // allowed. According to the standards these frames should normally be // handles as invalid frames. AcceptInvalidFrames // If the NFC device should only listen to frames, it could be useful to // let it gather multiple frames in a sequence. They will be stored in // the internal FIFO of the PN53X chip. This could be retrieved by using // the receive data functions. Note that if the chip runs out of bytes // (FIFO = 64 bytes long), it will overwrite the first received frames, // so quick retrieving of the received data is desirable. AcceptMultipleFrames // This option can be used to enable or disable the auto-switching mode // to ISO14443-4 is device is compliant. // In initiator mode, it means that NFC chip will send RATS // automatically when select and it will automatically poll for // ISO14443-4 card when ISO14443A is requested. // In target mode, with a NFC chip compliant (ie. PN532), the chip will // emulate a 14443-4 PICC using hardware capability. AutoISO14443_4 // Use automatic frames encapsulation and chaining. EasyFraming // Force the chip to switch in ISO14443-A ForceISO14443a // Force the chip to switch in ISO14443-B ForceISO14443b // Force the chip to run at 106 kbps ForceSpeed106 )
Properties for (*Device).SetPropertyInt() and (*Device).SetPropertyBool().
const ( ISO14443a = iota + 1 Jewel ISO14443b ISO14443bi // pre-ISO14443B aka ISO/IEC 14443 B' or Type B' ISO14443b2sr // ISO14443-2B ST SRx ISO14443b2ct // ISO14443-2B ASK CTx Felica DEP )
NFC modulation types
const ( Nbr106 = iota + 1 Nbr212 Nbr424 Nbr847 )
NFC baud rates. UNDEFINED is also a valid baud rate, albeit defined further below.
const ( TargetMode = iota InitiatorMode )
NFC modes. An NFC device can either be a target or an initiator.
const ( SUCCESS = 0 // Success (no error) EIO = -1 // Input / output error, device may not be usable anymore without re-open it EINVARG = -2 // Invalid argument(s) EDEVNOTSUPP = -3 // Operation not supported by device ENOTSUCHDEV = -4 // No such device EOVFLOW = -5 // Buffer overflow ETIMEOUT = -6 // Operation timed out EOPABORTED = -7 // Operation aborted (by user) ENOTIMPL = -8 // Not (yet) implemented ETGRELEASED = -10 // Target released ERFTRANS = -20 // Error during RF transmission EMFCAUTHFAIL = -30 // MIFARE Classic: authentication failed ESOFT = -80 // Software error (allocation, file/pipe creation, etc.) ECHIP = -90 // Device's internal chip error )
Error codes. Casted to Error, these yield all possible errors this package provides. Use nfc.Error(errorcode).Error() to get a descriptive string for an error code.
const ( Undefined = iota Passive Active )
NFC D.E.P. (Data Exchange Protocol) active/passive mode
const BufsizeConnstring = 1024
Maximum length for an NFC connection string
Variables ¶
This section is empty.
Functions ¶
func AppendISO14443aCRC ¶
Calculate an ISO 14443a CRC and append it to the supplied slice.
func AppendISO14443bCRC ¶
Calculate an ISO 14443b CRC and append it to the supplied slice.
func ISO14443CascadeUID ¶
Add cascade tags (0x88) in UID. See ISO/IEC 14443-3 sec. 6.4.4.
func ISO14443aCRC ¶
Calculate an ISO 14443a CRC. Code translated from the code in iso14443a_crc().
func ISO14443aLocateHistoricalBytes ¶
Locate historical bytes according to ISO/IEC 14443-4 sec. 5.2.7. Return nil if that fails.
func ISO14443bCRC ¶
Calculate an ISO 14443b CRC. Code translated from the code in iso14443b_crc().
func ListDevices ¶
Scan for discoverable supported devices (ie. only available for some drivers. Returns a slice of strings that can be passed to Open() to open the devices found.
func TargetString ¶
Make a string from a target with proper error reporting. This is a wrapper around str_nfc_target.
Types ¶
type DEPTarget ¶
type DEPTarget struct { NFCID3 [10]byte // NFCID3 DID byte // DID BS byte // supported send-bit rate BR byte // supported receive-bit rate TO byte // timeout value PP byte // PP parameters GB [48]byte // general bytes GBLen int // length of the GB field DepMode int // DEP mode Baud int // Baud rate }
NFC target information in D.E.P. (Data Exchange Protocol) see ISO/IEC 18092 (NFCIP-1). DEPTarget mirrors nfc_dep_info.
func (*DEPTarget) Marshall ¶
Marshall() returns a pointer to an nfc_target allocated with C.malloc() that contains the same data as the Target. Don't forget to C.free() the result of Marshall() afterwards. A runtime panic may occur if any slice referenced by a Target has been made larger than the maximum length mentioned in the respective comments.
type Device ¶
type Device struct {
// contains filtered or unexported fields
}
NFC device
func Open ¶
open a connection to an NFC device. If conn is "", the first available device will be used. If this operation fails, check the log on stderr for more details as the libnfc is not particulary verbose to us.
Depending on the desired operation mode, the device needs to be configured by using InitiatorInit() or TargetInit(), optionally followed by manual tuning of the parameters if the default parameters are not suiting your goals.
func (Device) AbortCommand ¶
Abort current running command. Some commands (ie. TargetInit()) are blocking functions and will return only in particular conditions (ie. external initiator request). This function attempt to abort the current running command.
func (Device) Connection ¶
Returns the device's connection string. If the device has been closed before, this function returns the empty string.
func (Device) Idle ¶
Turn NFC device in idle mode. In initiator mode, the RF field is turned off and the device is set to low power mode (if avaible); In target mode, the emulation is stoped (no target available from external initiator) and the device is set to low power mode (if avaible).
func (Device) Information ¶
Print information about an NFC device.
func (Device) InitiatorDeselectTarget ¶
Deselect a selected passive or emulated tag. After selecting and communicating with a passive tag, this function could be used to deactivate and release the tag. This is very useful when there are multiple tags available in the field. It is possible to use the InitiatorSelectPassiveTarget() method to select the first available tag, test it for the available features and support, deselect it and skip to the next tag until the correct tag is found.
func (Device) InitiatorInit ¶
Initialize NFC device as initiator (reader). After initialization it can be used to communicate to passive RFID tags and active NFC devices. The reader will act as initiator to communicate peer 2 peer (NFCIP) to other active NFC devices. The NFC device will be initialized with the following properties:
- CRC is handled by the device (NP_HANDLE_CRC = true)
- Parity is handled the device (NP_HANDLE_PARITY = true)
- Cryto1 cipher is disabled (NP_ACTIVATE_CRYPTO1 = false)
- Easy framing is enabled (NP_EASY_FRAMING = true)
- Auto-switching in ISO14443-4 mode is enabled (NP_AUTO_ISO14443_4 = true)
- Invalid frames are not accepted (NP_ACCEPT_INVALID_FRAMES = false)
- Multiple frames are not accepted (NP_ACCEPT_MULTIPLE_FRAMES = false)
- 14443-A mode is activated (NP_FORCE_ISO14443_A = true)
- speed is set to 106 kbps (NP_FORCE_SPEED_106 = true)
- Let the device try forever to find a target (NP_INFINITE_SELECT = true)
- RF field is shortly dropped (if it was enabled) then activated again
func (Device) InitiatorInitSecureElement ¶
Initialize NFC device as initiator with its secure element initiator (reader). After initialization it can be used to communicate with the secure element. The RF field is deactivated in order to save power.
func (Device) InitiatorListPassiveTargets ¶
func (d Device) InitiatorListPassiveTargets(m Modulation) ([]Target, error)
List passive or emulated tags. The NFC device will try to find the available passive tags. Some NFC devices are capable to emulate passive tags. The standards (ISO18092 and ECMA-340) describe the modulation that can be used for reader to passive communications. The chip needs to know with what kind of tag it is dealing with, therefore the initial modulation and speed (106, 212 or 424 kbps) should be supplied.
func (Device) InitiatorSelectPassiveTarget ¶
func (d Device) InitiatorSelectPassiveTarget(m Modulation, initData []byte) (Target, error)
Select a passive or emulated tag. initData is used with different kind of data depending on modulation type:
- for an ISO/IEC 14443 type A modulation, initData contains the UID you want to select;
- for an ISO/IEC 14443 type B modulation, initData contains Application Family Identifier (AFI) (see ISO/IEC 14443-3) and optionally a second byte = 0x01 if you want to use probabilistic approach instead of timeslot approach;
- for a FeliCa modulation, initData contains a 5-byte polling payload (see ISO/IEC 18092 11.2.2.5).
- for ISO14443B', ASK CTx and ST SRx, see corresponding standards
if nil, default values adequate for the chosen modulation will be used.
func (Device) InitiatorTargetIsPresent ¶
Check target presence. Returns nil on success, an error otherwise. The target has to be selected before you can check its presence. To run the test, one or more commands will be sent to the target.
func (Device) InitiatorTransceiveBits ¶
func (d Device) InitiatorTransceiveBits(tx, txPar []byte, txLength uint, rx, rxPar []byte) (n int, err error)
Transceive raw bit-frame to a target. n contains the received byte count on success, or is meaningless on error. The current implementation will return the libnfc error code in case of error, but this is subject to change. If txLength is longer than the supplied slice, an error will occur. txPar has to have the same length as tx, dito for rxPar and rx. An error will occur if any of these invariants do not hold.
tx contains a byte slice of the frame that needs to be transmitted. txLength contains its length in bits.
For example the REQA (0x26) command (the first anti-collision command of ISO14443-A) must be precise 7 bits long. This is not possible using Device.InitiatorTransceiveBytes(). With that function you can only communicate frames that consist of full bytes. When you send a full byte (8 bits + 1 parity) with the value of REQA (0x26), a tag will simply not respond.
txPar contains a byte slice of the corresponding parity bits needed to send per byte.
For example if you send the SELECT_ALL (0x93, 0x20) = [ 10010011, 00100000 ] command, you have to supply the following parity bytes (0x01, 0x00) to define the correct odd parity bits. This is only an example to explain how it works, if you just are sending two bytes with ISO14443-A compliant parity bits you better can use the Device.InitiatorTransceiveBytes() method.
rx will contain the response from the target. This function will return EOVFLOW if more bytes are received than the length of rx. rxPar contains a byte slice of the corresponding parity bits.
The NFC device (configured as initiator) will transmit low-level messages where only the modulation is handled by the PN53x chip. Construction of the frame (data, CRC and parity) is completely done by libnfc. This can be very useful for testing purposes. Some protocols (e.g. MIFARE Classic) require to violate the ISO14443-A standard by sending incorrect parity and CRC bytes. Using this feature you are able to simulate these frames.
func (Device) InitiatorTransceiveBitsTimed ¶
func (d Device) InitiatorTransceiveBitsTimed(tx, txPar []byte, txLength uint, rx, rxPar []byte, cycles uint32) (n int, c uint32, err error)
Transceive raw bit-frames to a target. n contains the received byte count on success, or is meaningless on error. c will contain the actual number of cycles waited. The current implementation will return the libnfc error code in case of error, but this is subject to change. If txLength is longer than the supplied slice, an error will occur. txPar has to have the same length as tx, dito for rxPar and rx. An error will occur if any of these invariants do not hold.
This function is similar to Device.InitiatorTransceiveBits() with the following differences:
- A precise cycles counter will indicate the number of cycles between emission & reception of frames.
- Only modes with EASY_FRAMING option disabled are supported and CRC must be handled manually.
- Overall communication with the host is heavier and slower.
By default the timer configuration tries to maximize the precision, which also limits the maximum cycle count before saturation / timeout. E.g. with PN53x it can count up to 65535 cycles, avout 4.8ms with a precision of about 73ns. If you're ok with the defaults, call this function with cycles = 0. If you need to count more cycles, set cycles to the maximum you exprect, but don't forget you'll loose in precision and it'll take more time before timeout, so don't abuse!
Warning: The configuration option EASY_FRAMING must be set to false; the configuration option HANDLE_CRC must be set to false; the configuration option HANDLE_PARITY must be set to true (the default value).
func (Device) InitiatorTransceiveBytes ¶
Send data to target then retrieve data from target. n contains received bytes count on success, or is meaningless on error. The current implementation will return the libnfc error code in case of error, but this is subject to change. This function will return EOVFLOW if more bytes are being received than the length of rx.
The NFC device (configured as initiator) will transmit the supplied bytes (tx) to the target. It waits for the response and stores the received bytes in rx. If the received bytes exceed rx, the error status will be NFC_EOVFLOW and rx will contain len(rx) received bytes.
If EASY_FRAMING option is disabled the frames will sent and received in raw mode: PN53x will not handle input neither output data.
The parity bits are handled by the PN53x chip. The CRC can be generated automatically or handled manually. Using this function, frames can be communicated very fast via the NFC initiator to the tag.
Tests show that on average this way of communicating is much faster than using the regular driver/middle-ware (often supplied by manufacturers).
Warning: The configuration option HANDLE_PARITY must be set to true (the default value).
If timeout equals to 0, the function blocks indefinitely (until an error is raised or function is completed). If timeout equals to -1, the default timeout will be used.
func (Device) InitiatorTransceiveBytesTimed ¶
func (d Device) InitiatorTransceiveBytesTimed(tx, rx []byte, cycles uint32) (n int, c uint32, err error)
Send data to target then retrieve data from target with timing control. n contains the received byte count on success, or is meaningless on error. c will contain the actual number of cycles waited. The current implementation will return the libnfc error code in case of error, but this is subject to change. This function will return EOVFLOW if more bytes are being received than the length of rx.
This function is similar to Device.InitiatorTransceiveBytes() with the following differences:
- A precise cycles counter will indicate the number of cycles between emission & reception of frames.
- Only modes with EASY_FRAMING option disabled are supported.
- Overall communication with the host is heavier and slower.
By default, the timer configuration tries to maximize the precision, which also limits the maximum cycle count before saturation / timeout. E.g. with PN53x it can count up to 65535 cycles, avout 4.8ms with a precision of about 73ns. If you're ok with the defaults, call this function with cycles = 0. If you need to count more cycles, set cycles to the maximum you exprect, but don't forget you'll loose in precision and it'll take more time before timeout, so don't abuse!
Warning: The configuration option EASY_FRAMING must be set to false; the configuration option HANDLE_PARITY must be set to true (default value).
func (Device) LastError ¶
the error returned by the last operation on d. Every function that wraps some functions operating on an nfc_device should call this function and return the result. This wraps nfc_device_get_last_error.
func (Device) Pointer ¶
Return a pointer to the wrapped nfc_device. This is useful if you try to use this wrapper to wrap other C code that builds onto the libnfc.
func (Device) SetPropertyBool ¶
Set a device's boolean-property value. Returns nil on success, otherwise an error. See integer constants in this package for possible properties.
func (Device) SetPropertyInt ¶
Set a device's integer-property value. Returns nil on success, otherwise an error. See integer constants in this package for possible properties.
func (Device) String ¶
Returns the device's name. This information is not enough to uniquely determine the device.
func (Device) SupportedBaudRates ¶
Get suported baud rates. Returns either a slice of supported baud rates or an error. This function wraps nfc_device_get_supported_baud_rate().
func (Device) SupportedModulations ¶
Get supported modulations. Returns a slice of supported modulations or an error. Pass either TARGET or INITIATOR as mode. This function wraps nfc_device_get_supported_modulation()
func (Device) TargetInit ¶
Initialize NFC device as an emulated tag. n contains the received byte count on success, or is meaningless on error. The current implementation will return the libnfc error code in case of error, but this is subject to change. The returned target tt will be the result of the modifications nfc_target_init() applies to t. Such modifications might happen if you set an Baud or DepMode to UNDEFINED. The fields will be updated with concrete values. timeout contains a timeout in milliseconds.
This function initializes NFC device in target mode in order to emulate a tag as the specified target t.
- Crc is handled by the device (HANDLE_CRC = true)
- Parity is handled the device (HANDLE_PARITY = true)
- Cryto1 cipher is disabled (ACTIVATE_CRYPTO1 = false)
- Auto-switching in ISO14443-4 mode is enabled (AUTO_ISO14443_4 = true)
- Easy framing is disabled (EASY_FRAMING = false)
- Invalid frames are not accepted (ACCEPT_INVALID_FRAMES = false)
- Multiple frames are not accepted (ACCEPT_MULTIPLE_FRAMES = false)
- RF field is dropped
Warning: Be aware that this function will wait (hang) until a command is received that is not part of the anti-collision. The RATS command for example would wake up the emulator. After this is received, the send and receive functions can be used.
If timeout equals to 0, the function blocks indefinitely (until an error is raised or function is completed). If timeout equals to -1, the default timeout will be used.
func (Device) TargetReceiveBytes ¶
Receive bytes and APDU frames. n contains the received byte count on success, or is meaningless on error. The current implementation will return the libnfc error code in case of error, but this is subject to change. timeout contains a timeout in milliseconds.
This function retrieves bytes frames (e.g. ADPU) sent by the initiator to the NFC device (configured as target).
If timeout equals to 0, the function blocks indefinitely (until an error is raised or function is completed). If timeout equals to -1, the default timeout will be used.
func (Device) TargetSendBits ¶
Send raw bit-frames. Returns sent bits count on success, n contains the sent bit count on success, or is meaningless on error. The current implementation will return the libnfc error code in case of error, but this is subject to change. txPar has to have the same length as tx, an error will occur if this invariant does not hold.
tx contains a byte slice of the frame that needs to be transmitted. txLength contains its length in bits. txPar contains a byte slice of the corresponding parity bits needed to send per byte.
his function can be used to transmit (raw) bit-frames to the initiator using the specified NFC device (configured as target).
func (Device) TargetSendBytes ¶
Send bytes and APDU frames. n contains the sent byte count on success, or is meaningless on error. The current implementation will return the libnfc error code in case of error, but this is subject to change. timeout contains a timeout in milliseconds.
This function make the NFC device (configured as target) send byte frames (e.g. APDU responses) to the initiator.
If timeout equals to 0, the function blocks indefinitely (until an error is raised or function is completed). If timeout equals to -1, the default timeout will be used.
func (Device) TargetTransceiveBits ¶
Receive bit-frames. Returns received bits count on success, n contains the received bit count on success, or is meaningless on error. The current implementation will return the libnfc error code in case of error, but this is subject to change. rxPar has to have the same length as rx, an error will occur if this invariant does not hold.
rx contains a byte slice of the frame that you want to receive. rxLength contains its length in bits. rxPar contains a byte slice of the corresponding parity bits received per byte.
This function makes it possible to receive (raw) bit-frames. It returns all the messages that are stored in the FIFO buffer of the PN53x chip. It does not require to send any frame and thereby could be used to snoop frames that are transmitted by a nearby initiator. Check out the ACCEPT_MULTIPLE_FRAMES configuration option to avoid losing transmitted frames.
type Error ¶
type Error int
An error as reported by various methods of Device. If device returns an error that is not castable to Error, something outside on the Go side went wrong.
type FelicaTarget ¶
NFC FeLiCa tag information
func (*FelicaTarget) Marshall ¶
func (d *FelicaTarget) Marshall() uintptr
Marshall() returns a pointer to an nfc_target allocated with C.malloc() that contains the same data as the Target. Don't forget to C.free() the result of Marshall() afterwards. A runtime panic may occur if any slice referenced by a Target has been made larger than the maximum length mentioned in the respective comments.
func (*FelicaTarget) Modulation ¶
func (t *FelicaTarget) Modulation() Modulation
Type is always FELICA
func (*FelicaTarget) String ¶
func (t *FelicaTarget) String() string
type ISO14443aTarget ¶
type ISO14443aTarget struct { Atqa [2]byte Sak byte UIDLen int // length of the Uid field UID [10]byte AtsLen int // length of the ATS field // Maximal theoretical ATS is FSD-2, FSD=256 for FSDI=8 in RATS Ats [254]byte // up to 254 bytes Baud int // Baud rate }
NFC ISO14443A tag (MIFARE) information. ISO14443aTarget mirrors nfc_iso14443a_info.
func (*ISO14443aTarget) Marshall ¶
func (d *ISO14443aTarget) Marshall() uintptr
Marshall() returns a pointer to an nfc_target allocated with C.malloc() that contains the same data as the Target. Don't forget to C.free() the result of Marshall() afterwards. A runtime panic may occur if any slice referenced by a Target has been made larger than the maximum length mentioned in the respective comments.
func (*ISO14443aTarget) Modulation ¶
func (t *ISO14443aTarget) Modulation() Modulation
Type is always ISO14443A
func (*ISO14443aTarget) String ¶
func (t *ISO14443aTarget) String() string
type ISO14443b2ctTarget ¶
NFC ISO14443-2B ASK CTx tag information
func (*ISO14443b2ctTarget) Marshall ¶
func (d *ISO14443b2ctTarget) Marshall() uintptr
Marshall() returns a pointer to an nfc_target allocated with C.malloc() that contains the same data as the Target. Don't forget to C.free() the result of Marshall() afterwards. A runtime panic may occur if any slice referenced by a Target has been made larger than the maximum length mentioned in the respective comments.
func (*ISO14443b2ctTarget) Modulation ¶
func (t *ISO14443b2ctTarget) Modulation() Modulation
Type is always ISO1444B2CT
func (*ISO14443b2ctTarget) String ¶
func (t *ISO14443b2ctTarget) String() string
type ISO14443b2srTarget ¶
NFC ISO14443-2B ST SRx tag information
func (*ISO14443b2srTarget) Marshall ¶
func (d *ISO14443b2srTarget) Marshall() uintptr
Marshall() returns a pointer to an nfc_target allocated with C.malloc() that contains the same data as the Target. Don't forget to C.free() the result of Marshall() afterwards. A runtime panic may occur if any slice referenced by a Target has been made larger than the maximum length mentioned in the respective comments.
func (*ISO14443b2srTarget) Modulation ¶
func (t *ISO14443b2srTarget) Modulation() Modulation
Type is always ISO14443B2SR
func (*ISO14443b2srTarget) String ¶
func (t *ISO14443b2srTarget) String() string
type ISO14443bTarget ¶
type ISO14443bTarget struct { Pupi [4]byte // stores PUPI contained in ATQB (Answer To reQuest of type B) ApplicationData [4]byte // stores Application Data contained in ATQB ProtocolInfo [3]byte // stores Protocol Info contained in ATQB CardIdentifier byte // store CID (Card Identifier) attributted by PCD to the PICC Baud int }
NFC ISO14443B tag information. See ISO14443-3 for more details.
func (*ISO14443bTarget) Marshall ¶
func (d *ISO14443bTarget) Marshall() uintptr
Marshall() returns a pointer to an nfc_target allocated with C.malloc() that contains the same data as the Target. Don't forget to C.free() the result of Marshall() afterwards. A runtime panic may occur if any slice referenced by a Target has been made larger than the maximum length mentioned in the respective comments.
func (*ISO14443bTarget) Modulation ¶
func (t *ISO14443bTarget) Modulation() Modulation
Type is always ISO14443B
func (*ISO14443bTarget) String ¶
func (t *ISO14443bTarget) String() string
type ISO14443biTarget ¶
type ISO14443biTarget struct { DIV [4]byte // 4 LSBytes of tag serial number VerLog byte // Software version & type of REPGEN Config byte // Config Byte, present if long REPGEN AtrLen int // length of the Atr field Atr [33]byte // ATR, if any. At most 33 bytes Baud int }
NFC ISO14443B' tag information
func (*ISO14443biTarget) Marshall ¶
func (d *ISO14443biTarget) Marshall() uintptr
Marshall() returns a pointer to an nfc_target allocated with C.malloc() that contains the same data as the Target. Don't forget to C.free() the result of Marshall() afterwards. A runtime panic may occur if any slice referenced by a Target has been made larger than the maximum length mentioned in the respective comments.
func (*ISO14443biTarget) Modulation ¶
func (t *ISO14443biTarget) Modulation() Modulation
Type is always ISO14443BI
func (*ISO14443biTarget) String ¶
func (t *ISO14443biTarget) String() string
type JewelTarget ¶
NFC Jewel tag information
func (*JewelTarget) Marshall ¶
func (d *JewelTarget) Marshall() uintptr
Marshall() returns a pointer to an nfc_target allocated with C.malloc() that contains the same data as the Target. Don't forget to C.free() the result of Marshall() afterwards. A runtime panic may occur if any slice referenced by a Target has been made larger than the maximum length mentioned in the respective comments.
func (*JewelTarget) String ¶
func (t *JewelTarget) String() string
type Modulation ¶
NFC modulation structure. Use the supplied constants.
type Target ¶
type Target interface { Modulation() Modulation Marshall() uintptr String() string // uses TargetString() with verbose = true }
Go wrapper for nfc_target. Since the nfc_target structure contains a union, we cannot directly map it to a Go type. Modulation() can be used to figure out what kind of modulation was used for this Target and what type an interface can be casted into.
Marshall() returns a pointer to an nfc_target allocated with C.malloc() that contains the same data as the Target. Don't forget to C.free() the result of Marshall() afterwards. A runtime panic may occur if any slice referenced by a Target has been made larger than the maximum length mentioned in the respective comments.
func UnmarshallTarget ¶
Make a target from a pointer to an nfc_target. If the object you pass it not an nfc_target, undefined behavior occurs and your program is likely to blow up.