* What is Conaxe/Nonaxe?
	They emulate a small subset of the CAS7 card protocol over a serial port.
* Conaxe and Nonaxe. What's the difference?
	Conaxe was the first project. It's a little bit more hackish and probably 
	less resilient towards non-ideal conditions. The reason for this is that I tested
	Conaxe with a reliable serial and network connection while Nonaxe had to survive on
	wifi with signal quality below 10% on an unreliable target device that corrupted 
	serial comms randomly.		
	Conaxe is written in Java and depends on the RXTX library. It also has a bolted-together 
	horrible quality wrapper/launcher/console app for Android which it has also been
	tested on using the RXTX Android port from http://v-lad.org/projects/gnu.io.android/
	Nonaxe on the other hand is a small footprint native project meant for low-performance 
	devices such as routers. (though there is nothing keeping it from running on a PC)

* Emulator is for educational purposes only
	Make sure you don't violate local laws or your service contract. 
	I take no responsibility for anything resulting	from the use of this source code.
* Emulator does not support pairing
	Implementing TypeA pairing should be possible at least but I'm not going to do it.
	TypeB pairing on the other hand has never been reverse engineered
* Emulator is released under the GPLv3 license
	Feel free to modify but make sure you share.
	http://www.gnu.org/licenses/gpl-3.0.html
* Emulator is unsupported
	Also highly incomplete and generally just a kludge.
* Timings are evil (sometimes)
	CAS7 cards take their time processing ECMs (probably a deliberate delay)
	When two clients are watching different channels and the ecm timing of those drift
	and converge then one of those ECMs can take average response time * 2 to process.
	You don't have very long to respond to an ECM command. Around 1 second is it.
	If your card processes a request in 500ms+ then it's obvious that one of your clients 
	will be over limit and skip and that's with only 2 clients.
	This is probably provider and technology (DVB-S/T/C) dependent but keep it in mind.
* Fine tune OSCAM for best results
	When AU is enabled, the first ECM request may get discarded as OSCAM sends two 
	EMM_REQUESTs to the new AU-enabled client connection before processing ECMs.
	This can lead to the first channel open after power-on taking 30+ seconds.
		Solution: Set the AU user account's session time-out to a large number.
	EMMs take longer to process than ECMs, hogging precious card time.
		Solution: Enable EMM caching with a low rewrite count.
	Etc..
		Experiment!		
* Event-driven/polled
	People diving into the code may find that the non-android main class is polling
	while the one used by the Android launcher is event-driven.
	There are several good reasons for this:
	It increases the educational value of the project by providing an example of both approaches.
	Just kidding, I'm simply too lazy to change it. The Event-driven class is preferrable.		

* Access to an OSCAM or other card server instance that supports the camd35 UDP protocol
* Some type of Season interface connected to something you want to run the emu on
* _UNPAIRED_ target device (CAM or Set-top-box)

0. Satisfy RXTX dependency and compile the emu 

	Non-Android:
		Take a binary release of the jar and native lib from http://rxtx.qbang.org
		Install the native lib (see rxtx documentation)
		Copy RXTXcomm.jar to src/
		Copy assets/default.ini to src/conaxe.ini
		Compile (from src dir do javac -cp RXTXcomm.jar io/conaxe/*.java)
		Jump ahead to step 1 and finish configuration.
		Launch emu from the src dir (java -cp RXTXcomm.jar:. io.conaxe.Conaxe)
		Optional: Package according to taste

	Android: 
		DL everything from https://github.com/vladistan/gnu.io.android

		Copy gnu.io/src/* into the project's src dir

		For best results you need to modify and recompile the ported native library
    		I've provided a patch file in /lib 
		You'll need the Android NDK.

    		Steps:
			copy jni.patch to librxtxSerial/ 
			run patch -i -p0 jni.patch
			build using ndk
			copy resulting librxtxSerial.so into /lib
			build source tree as android project (using IDE of choice)			

		Start the emu once, it will drop the default config into 
		/data/data/io.droidAxe/files
		Continue with steps below.
		If something goes wrong logcat is your friend.

1. Edit config. Fill in your card info (ATR, IDs, serials)
	Hint: OSCAM can show you most of them, STB info menus may show you the rest.
	Don't change the length of IDs and serials in the example config. 
	Prepend with 00s instead if shorter
	ATR length is arbitrary
2. Configure the reset according to your interface
3. Configure the port and speed (I have no idea if unstandard bauds are handled.
   I think RXTX may support them but I haven't tried.
   A simple no hassle solution for unstandard baud is to buy a CP2102 based interface 
   (less than $5 shipped) and use the manufacturer tool to modify the baud rate table.
   It works great, no headaches.) See the Wiki page on how to hook it up.
4. Fill in your card server access details (emu has been tested with OSCAM only)
5. Deploy and run