libnfc-d

package.d (7883B)

---

 /** A D-based wrapper of some libnfc-functionality
  * 
  * Examples:
  * -------------
  * import nfc;
  * 
  * writeln("libnfc version ", nfcVersion());
  * 
  * Context c=new Context();
  * 
  * auto d = c.open();
  * d.init();
  * 
  * writeln("Device name: ", d.name);
  * 
  * Target t;
  * t.baud = t.Baud.B106;
  * auto params = &t.ISO14443A();
  * 
  * d.selectPassive(t);
  * writeln("The following ISO14443A tag was found: ", t.toString());
  * -------------
  */
 
 module nfc;
 import nfc.c;
 import std.string;
 import std.meta;
 import std.conv:to;
 import std.traits;
 import std.exception;
 import std.array : Appender;
 import core.time : Duration, dur;
 import std.algorithm.mutation:copy;
 
 
 private auto toConnString(Range)(Range r) if(isSomeString!Range){
 	nfc_connstring cs;
 	r.copy(cs[]);
 	return cs;
 }
 
 /** Return the libnfc version string
  */
 string nfcVersion(){
 	return cast(string)(nfc_version().fromStringz());
 }
 
 unittest{
 	assert(nfcVersion().length > 0);
 }
 
 class NfcException : Exception{
 	this(A...)(A a){
 		super(a);
 	}
 }
 
 /** The main class encapsulating the libnfc context
  *
  * This class needs to be instantiated before doing anything else.
  * It can split off devices by using Context.open
 */
 
 class Context{
 	nfc_context *ctx;
 	
 	this(){
 		nfc_init(&ctx);
 		if(ctx is null){
 			throw new Exception("Malloc");
 		}
 	}
 	
 	~this(){
 		nfc_exit(ctx);
 		ctx = null;
 	}
 	
 	/** Open the default device on the system
 	 */
 	Device open(){
 		return new Device(enforce!NfcException(nfc_open(ctx, cast(char*)null), "Could not open default NFC device"));
 	}
 	
 	/** Open a device given a connection string
 	 */
 	Device open(string connstring){
 		return new Device(enforce!NfcException(nfc_open(ctx, connstring.toConnString.ptr), "Could not open NFC device "~connstring));
 	}
 }
 
 unittest{
 	Context c = new Context();
 }
 
 /** The class denoting the target of a NFC device
  * 
  * This encapsulates both the modulation and target struct of libnfc.
  * The modulation can be set by the .baud property, the modulation type
  * by calling the corresponding function (e.g. for ISO14443A t.ISO14443A()).
  * This call additionally returns a reference to the configuration struct.
  * 
  * For all the possibilities, refer to the struct nfc_modulation_type
  */
 struct Target{
 	private nfc_target nt;
 	
 	alias nt this;
 	
 	static private string modulationName(string name)(){
 		return name[4..$-5].toUpper();
 	}
 	
 	static private string modulationType(string name)(){
 		return "NMT_"~modulationName!name;
 	}
 	
 	template ModulationType(string name){
 		alias ModulationType = mixin("typeof(nt.nti."~name~")");
 	}
 	
 	static private string funcDef(string name)(){
 		alias T = ModulationType!name;
 		return "ref "~modulationName!(T.stringof)~"(){
 			nt.nm.nmt = nfc_modulation_type."~modulationType!(T.stringof)~";
 			return nt.nti."~name~";
 		}";
 	}
 	
 	static foreach(T; FieldNameTuple!(typeof(nt.nti))){
 		mixin(funcDef!T);
 	}
 	
 	/**
 	 * The possible baud rates for communication
 	 */
 	enum Baud{
 	  UNDEF = nfc_baud_rate.NBR_UNDEFINED,
 	  B106 = nfc_baud_rate.NBR_106,
 	  B212 = nfc_baud_rate.NBR_212,
 	  B424 = nfc_baud_rate.NBR_424,
 	  B847 = nfc_baud_rate.NBR_847,
 	}
 	
 	/**
 	 * Returns the baud rate
 	 */
 	Baud baud() const{
 		return cast(Baud) nt.nm.nbr;
 	}
 	
 	/**
 	 * Sets the baud rate
 	 */
 	Baud baud(Baud b){
 		nt.nm.nbr = cast(nfc_baud_rate)b;
 		return baud();
 	}
 	
 	/**
 	 * Returns the modulation struct
 	 */
 	auto modulation(){
 		return nt.nm;
 	}
 	
 	/**
 	 * Returns a pointer to the c target struct
 	 */
 	auto ptr(){
 		return &nt;
 	}
 	
 	/**
 	 * Prints the internal variables independant of the modulation type
 	 */
 	void toString(scope void delegate(const(char)[]) sink) const{
 		string card = nt.nm.nmt.to!string;
 		string baud = baud().to!string;
 		sink(card[4..$]);
 		sink(", Baud ");
 		sink(baud);
 		
 		void printer(T)(T t){
 			foreach(mem; FieldNameTuple!T){
 				auto r = mixin("t."~mem);
 				sink("\n\t");
 				sink(mem);
 				sink(": ");
 				sink(r.to!string);
 			}
 			
 		}
 		
 		lbrk:switch(nt.nm.nmt){
 			static foreach(name; FieldNameTuple!(typeof(nt.nti))){
 				mixin(`case nfc_modulation_type.`~modulationType!((ModulationType!name).stringof)~`:
 					printer(nt.nti.`~name~`);
 				break lbrk;`);
 			}
 			default:
 				sink("Not implemented");
 			break;
 		}
 	}
 	
 	string toString() const{
 		Appender!string app;
 		toString(x=>app~=x);
 		return app.data;
 	}
 }
 
 /** A nfc reader/writer device
  * 
  * This is typically instantiated via the Context class, using Context.open
  */
 class Device{
 	private nfc_device *dev;
 	
 	
 	/** Exception thrown on error
 	 */
 	class NfcException : Exception{
 		this(string msg, string file=__FILE__, size_t line = __LINE__, Throwable next=null){
 			super(msg~": "~error(), file, line, next);
 		}
 	}
 	
 	private int check(int retval, string msg="Call to libnfc failed", string file=__FILE__, size_t line=__LINE__){
 		if(retval < NFC.SUCCESS){
 			throw new NfcException(msg, file, line);
 		}
 		return retval;
 	}
 	
 	package this(nfc_device *dev){
 		assert(dev !is null);
 		this.dev = dev;
 	}
 	
 	~this(){
 		nfc_close(dev);
 		dev = null;
 	}
 	
 	/** Returns the device name
 	 */
 	string name(){
 		auto s = nfc_device_get_name(dev);
 		return cast(string)(s.fromStringz());
 	}
 	
 	/** Initializes the initiator
 	 * 
 	 * Params:
 	 * 	secure = Whether to initialize a secure element or not
 	 */
 	void init(bool secure = false){
 		if(secure){
 			check(nfc_initiator_init_secure_element(dev));
 		}
 		else{
 			check(nfc_initiator_init(dev));
 		}
 	}
 	
 	/** Returns a list of at most ntargets targets found by the device
 	 */
 	Target[] listPassiveTargets(Target t, int ntargets){
 		return listPassiveTargets(t, new Target[ntargets]);
 	}
 	
 	/** Reads all targets found by the device into the given array
 	 */
 	Target[] listPassiveTargets(Target t, Target[] targets){
 		auto ret = check(nfc_initiator_list_passive_targets(dev, t.modulation, cast(nfc_target*)targets.ptr, targets.length));
 		return targets[0..ret];
 	}
 	
 	/** Checks whether a target is still present
 	 * 
 	 * The target needs to be selected prior to calling this function
 	 */
 	bool targetIsPresent(Target t){
 		auto ret = nfc_initiator_target_is_present(dev, t.ptr);
 		return ret == NFC.SUCCESS;
 	}
 	
 	/** Transmits the bytes in send and reads the bytes in receive
 	 * 
 	 * Params:
 	 * 	send    = The bytes to send, or null if none
 	 * 	receive = The bytes to receive, or null if none
 	 * 	timeout = The time to wait for the response, infinite if zero
 	 */
 	ubyte[] transceive(ubyte[] send, ubyte[] receive = null, Duration timeout=Duration.zero){
 		int ret = check(nfc_initiator_transceive_bytes(dev, 
 			send.ptr,
 			send.length,
 			receive.ptr,
 			receive.length,
 			cast(int)timeout.total!"msecs"
 		));
 		
 		return receive[0..ret];
 	}
 	
 	/** Selects a device for communication
 	 */
 	int selectPassive(ref Target t, ubyte[] initData = null){
 		int ret = check(nfc_initiator_select_passive_target(dev, t.modulation, initData.ptr, initData.length, t.ptr));
 		return ret;
 	}
 	
 	/** Polls for devices, and returns the number of devices found, as
 	 * well as one of them in t
 	 * 
 	 * Params:
 	 * 	modulations	= an array of modulations to try
 	 * 	t           = The first found target
 	 * 	polling     = specifies the number of polling (0x01 - 0xFE: 1 up to 254
 	 * 		polling, 0xFF: Endless polling) 
 	 * 	period      = indicates the polling period, 150ms - 2.25s
 	 * 
 	 * Returns:
 	 * Polled targets count
 	 */
 	int poll(nfc_modulation[] modulations, out Target t, ubyte polling=0xFF, Duration period=dur!"seconds"(1)){
 		auto period_byte = period.total!"msecs"/150;
 		assert(period_byte >= 1 && period_byte <= 0xF);
 		int ret = check(nfc_initiator_poll_target(dev, modulations.ptr, modulations.length, polling, cast(ubyte)period_byte, t.ptr));
 		return ret;
 	}
 	
 	/** Returns the last error from the device */
 	private string error() const{
 		auto s = nfc_strerror(dev);
 		return cast(string)(s.fromStringz());
 	}
 }