module CCID_Emulation {

/* This module implements multiplexing/demultiplexing of USB CCID, enabling different
 * TTCN-3 test components to talk to different CCID slots
 *
 * (C) 2019 by Harald Welte <laforge@gnumonks.org>
 * All rights reserved.
 */


import from General_Types all;
import from Osmocom_Types all;
import from Misc_Helpers all;

import from USB_Types all;
import from USB_Templates all;
import from USB_PortType all;
import from USB_PortTypes all;
import from USB_Component all;

import from CCID_Types all;
import from CCID_Templates all;

modulepar {
	boolean mp_quirk_resetpar_returns_slotsts := false;
};

type enumerated CCID_Emulation_Event_UpDown {
	CCID_EVENT_UP,
	CCID_EVENT_DOWN
};

type union CCID_Emulation_Event {
	CCID_Emulation_Event_UpDown up_down
};

type port CCID_SLOT_PT message {
	inout CCID_PDU, CCID_Emulation_Event;
} with { extension "internal" }

type record CCID_Emulation_Params {
	USB_Device_Match usb_dev_match
};

type component CCID_Emulation_CT extends USB_CT {
	var integer g_interface;
	var integer g_ep_in;
	var integer g_ep_out;
	var integer g_ep_irq;
	var CCID_Emulation_Params g_pars;

	var integer g_next_bseq := 0;

	/* ports to the test components; one for each theoretically possible slot */
	port CCID_SLOT_PT SLOT[256];
}

private const octetstring c_oct268 := '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'O;

private function f_usb_submit_xfer(USB_endpoint ep, octetstring data := c_oct268,
				   USB_transfer_type ttype := USB_TRANSFER_TYPE_BULK,
				   integer tout_ms := 30000) runs on CCID_Emulation_CT
{
	var integer req_hdl := f_usb_get_req_hdl();
	var USB_transfer xfer := {
		device_hdl := g_dev_hdl,
		transfer_hdl := req_hdl,
		endpoint := ep,
		ttype := ttype,
		data := data,
		timeout_msec := tout_ms
	};
	USB.send(xfer);
}

function main(CCID_Emulation_Params pars) runs on CCID_Emulation_CT {
	var USB_transfer_compl tc;
	var CCID_PDU ccid_in, ccid_out;
	var integer i, v_i;

	g_pars := pars;

	f_usb_init(g_pars.usb_dev_match);

	f_usb_set_configuration(g_dev_hdl, 1);

	var integer i_config := f_usb_get_config();
	var USB_Descriptor_Node root;
	log("USB Configuration: ", i_config);
	root := f_usb_get_desc_tree();
	log(root);

	/* iterate over list of interfaces in current configuration */
	for (i := 0; i < lengthof(root.children[i_config].children); i:=i+1) {
		var USB_Descriptor_Node ifn := root.children[i_config].children[i];
		var USB_InterfaceDescriptor ifd := ifn.desc.interface;
		/* Search for CCID interface */
		if (ifd.bInterfaceClass == '0B'O and
		    ifd.bInterfaceSubClass == '00'O and ifd.bInterfaceProtocol == '00'O) {
			g_interface := ifd.bInterfaceNumber;
			var integer j;
			/* determine endpoints inside interface */
			for (j := 0; j < lengthof(ifn.children); j:=j+1) {
				log("Iterating over ", ifn.children[j]);
				if (ischosen(ifn.children[j].desc.endpoint)) {
					var USB_EndpointDescriptor epd := ifn.children[j].desc.endpoint;
					select (epd.bmAttributes.TranferType) {
					case (USB_EpTransfer_BULK) {
						if (epd.bEndpointAddress and4b '80'O == '80'O) {
							g_ep_in := oct2int(epd.bEndpointAddress);
						} else {
							g_ep_out := oct2int(epd.bEndpointAddress);
						}
						}
					case (USB_EpTransfer_INTERRUPT) {
						g_ep_irq := oct2int(epd.bEndpointAddress);
						}
					}
				}
			}
			break;
		}
	}

	log("USB Endpoints found: IN: ", int2oct(g_ep_in, 1), ", OUT: ", int2oct(g_ep_out, 1),
		" IRQ: ", int2oct(g_ep_irq, 1));

	f_usb_claim_interface(g_dev_hdl, g_interface);

	/* submit xfer fro IN and IRQ endpoints */
	f_usb_submit_xfer(g_ep_in);
	f_usb_submit_xfer(g_ep_irq, ttype := USB_TRANSFER_TYPE_INTERRUPT);

	/* let everyone know we're alive and kicking */
	for (i := 0; i < 256; i := i+1) {
		if (SLOT[i].checkstate("Connected")) {
			SLOT[i].send(CCID_Emulation_Event:{up_down:=CCID_EVENT_UP});
		}
	}

	while (true) {

	alt {
	[] USB.receive(tr_UsbXfer_compl(g_ep_out, USB_TRANSFER_TYPE_BULK, USB_TRANSFER_COMPLETED,
					     g_dev_hdl, ?)) -> value tc {
		/* do nothing; normal completion of OUT transfer */
		}
	[] USB.receive(tr_UsbXfer_compl(g_ep_in, USB_TRANSFER_TYPE_BULK, USB_TRANSFER_COMPLETED,
					     g_dev_hdl, ?)) -> value tc {
		/* Submit another IN transfer */
		f_usb_submit_xfer(g_ep_in);
		/* forward to slot-specific port */
		ccid_in := dec_CCID_PDU(tc.data);
		if (SLOT[ccid_in.hdr.bSlot].checkstate("Connected")) {
		SLOT[ccid_in.hdr.bSlot].send(ccid_in);
		}
		}
	[] USB.receive(tr_UsbXfer_compl(g_ep_irq, USB_TRANSFER_TYPE_INTERRUPT,
					     USB_TRANSFER_COMPLETED, g_dev_hdl, ?)) -> value tc {
		/* Submit another IRQ transfer */
		f_usb_submit_xfer(g_ep_irq, ttype := USB_TRANSFER_TYPE_INTERRUPT);
		/* forward to all slot-specific ports with connected components */
/*
		ccid_in := dec_CCID_PDU(tc.data);
		for (i := 0; i < 256; i := i+1) {
			if (SLOT[i].checkstate("Connected")) {
				SLOT[i].send(ccid_in);
			}
		}
*/
		}
	[] USB.receive(tr_UsbXfer_compl(g_ep_irq, USB_TRANSFER_TYPE_INTERRUPT,
					     USB_TRANSFER_TIMED_OUT, g_dev_hdl, ?)) -> value tc {
		/* Submit another IRQ transfer */
		f_usb_submit_xfer(g_ep_irq, ttype := USB_TRANSFER_TYPE_INTERRUPT);
		}
	[] USB.receive(tr_UsbXfer_compl(0, USB_TRANSFER_TYPE_CONTROL,
					     USB_TRANSFER_COMPLETED, g_dev_hdl, ?)) -> value tc {
		}
	[] USB.receive(tr_UsbXfer_compl(?, ?, USB_TRANSFER_ERROR, g_dev_hdl, ?)) -> value tc {
		setverdict(fail, "Unexpected USB_TRANSFER_ERROR on EP ", int2hex(tc.endpoint, 2));
		mtc.stop;
		}
	[] USB.receive(tr_UsbXfer_compl(?, ?, USB_TRANSFER_TIMED_OUT, g_dev_hdl, ?)) -> value tc {
		setverdict(fail, "Unexpected USB_TRANSFER_TIMED_OUT on EP ", int2hex(tc.endpoint, 2));
		mtc.stop;
		}
	[] USB.receive(tr_UsbXfer_compl(?, ?, USB_TRANSFER_OVERFLOW, g_dev_hdl, ?)) -> value tc {
		setverdict(fail, "Unexpected USB_TRANSFER_OVERFLOW on EP ", int2hex(tc.endpoint, 2));
		mtc.stop;
		}
	[] USB.receive(tr_UsbXfer_compl(?, ?, ?, g_dev_hdl, ?)) -> value tc {
		setverdict(fail, "Unexpected USB Endpoint ", int2hex(tc.endpoint, 2));
		mtc.stop;
		}
	[] USB.receive(tr_UsbXfer_compl(?, ?, ?, ?, ?)) -> value tc {
		setverdict(fail, "Unexpected USB Device ", tc.device_hdl);
		mtc.stop;
		}
	[] USB.receive {
		setverdict(fail, "Unexpected Message from USB");
		mtc.stop;
		}

	[] any from SLOT.receive(CCID_PDU:?) -> value ccid_out @index value v_i {
		var octetstring bin;
		ccid_out.hdr.bSlot := v_i;
		ccid_out.hdr.bSeq := g_next_bseq;
		g_next_bseq := (g_next_bseq + 1) mod 256;
		bin := enc_CCID_PDU(ccid_out);
		/* 5.3.1 Send Abort message to Control pipe first (same bSeq). */
		if (ccid_out.hdr.bMessageType == PC_to_RDR_Abort) {
			var octetstring v_abort_setup;
			v_abort_setup := enc_USB_DeviceRequest({
				req_type := {
					direction := Host_to_Device,
					req_type := RequestType_Class,
					recipient := RequestRecipient_Interface
				},
				bRequest := '01'O,
				wValue := ccid_out.hdr.bSeq * 256 + v_i,
				wIndex:= 0,
				wLength := 0
			});
			f_usb_submit_xfer(0, v_abort_setup, ttype := USB_TRANSFER_TYPE_CONTROL, tout_ms := 3000);
			f_sleep(0.2);
		}
		f_usb_submit_xfer(g_ep_out, bin, tout_ms := 3000);
		}


	} /* alt */
	} /* while (true) */
}




/* per-slot test component; manages one slot */
type component Slot_CT {
	var uint8_t g_slot_nr;
	port CCID_SLOT_PT CCID;
	timer g_Tguard := 120.0;
};

/* altstep running on the per-slot test component */
altstep as_Tguard() runs on Slot_CT {
	[] g_Tguard.timeout {
		Misc_Helpers.f_shutdown(__BFILE__, __LINE__, fail, "Tguard timeout");
		}
}

altstep as_ccid_any() runs on Slot_CT {
	var CCID_PDU pdu;
	[] CCID.receive(CCID_PDU:?) -> value pdu {
		setverdict(fail, "Received unexpected CCID ", pdu);
		self.stop;
		}
	[] CCID.receive {
		setverdict(fail, "Received unexpected non-CCID");
		self.stop;
		}
}

/* transceive a CCID command (send 'tx' on OUT; expect 'rx' on IN) */
private function f_ccid_xceive(template (value) CCID_PDU tx, template (present) CCID_PDU exp_rx,
			       template (omit) float p_timeout := omit)
runs on Slot_CT return CCID_PDU {
	var CCID_PDU pdu;
	timer T;

	tx.hdr.bSlot := g_slot_nr;
	exp_rx.hdr.bSlot := g_slot_nr;

	if (ispresent(p_timeout)) {
		T.start(valueof(p_timeout));
	}
	CCID.send(tx);
	alt {
	[] CCID.receive(exp_rx) -> value pdu {
		return pdu;
		}
	[] as_ccid_any();
	[ispresent(p_timeout)] T.timeout {
		log("Resend CCID PDU...");
		T.start(valueof(p_timeout));
		CCID.send(tx);
		repeat;
		}
	}
	return pdu;
}

private template (present) CCID_Header_IN tr_inact :=
	tr_CCID_HeaderIN_OK(icc_status := (CCID_ICC_STATUS_PRES_INACT, CCID_ICC_STATUS_NO_ICC));

private template (present) CCID_Header_IN tr_act :=
	tr_CCID_HeaderIN_OK(icc_status := CCID_ICC_STATUS_PRES_ACT);

/* Send IccPowerOn on OUT; expect DataBlock in retunr */
function f_ccid_power_on(CCID_PowerSelect psel := CCID_PWRSEL_AUTO,
			 template (present) CCID_Header_IN hdr_in := tr_act)
runs on Slot_CT return CCID_PDU {
	var CCID_PDU pdu;

	/* Flush pending messages before powering on. */
	timer T := 0.5;
	T.start;
	alt {
	[] CCID.receive {
		repeat;
		}
	[] T.timeout { }
	}

	pdu := f_ccid_xceive(ts_CCID_IccPowerOn(g_slot_nr, psel),
			     tr_CCID_DataBlock(g_slot_nr, hdr_in := hdr_in),
			     p_timeout := 3.0);
	return pdu;
}

/* Send IccPowerOn on OUT; expect SlotStatus in return */
function f_ccid_power_off(template (present) CCID_Header_IN hdr_in := tr_inact)
runs on Slot_CT return CCID_PDU {
	var CCID_PDU pdu;

	pdu := f_ccid_xceive(ts_CCID_IccPowerOff(g_slot_nr),
			     tr_CCID_SlotStatus(slot := g_slot_nr, hdr_in := hdr_in) );
	return pdu;
}

/* Send IccClockCommand on OUT; expect SlotStatus in return */
function f_ccid_clock_cmd(CCID_ClockCommand cmd,
			  template (present) CCID_Header_IN hdr_in := tr_CCID_HeaderIN_OK)
runs on Slot_CT return CCID_PDU {
	var CCID_PDU pdu;

	pdu := f_ccid_xceive(ts_CCID_ClockCommand(g_slot_nr, cmd),
			     tr_CCID_SlotStatus(slot := g_slot_nr, hdr_in := hdr_in));
	return pdu;
}

/* Send XfrBlock on OUT; expect DataBlock in return */
function f_ccid_xfr(octetstring tx, template (present) octetstring rx) runs on Slot_CT return octetstring {
	var CCID_PDU pdu;

	pdu := f_ccid_xceive(ts_CCID_XfrBlock(g_slot_nr, tx, 0),
			     tr_CCID_DataBlock(g_slot_nr, ?, ?, rx) );
	return pdu.u.DataBlock.abData;
}

/* Send XfrBlock on OUT; expect DataBlock in return */
function f_ccid_xfr_pdu(octetstring tx, template (present) octetstring rx) runs on Slot_CT return CCID_PDU {
	var CCID_PDU pdu;

	pdu := f_ccid_xceive(ts_CCID_XfrBlock(g_slot_nr, tx, 0),
			     tr_CCID_DataBlock(g_slot_nr, ?, ?, rx) );
	return pdu;
}

/* Send SetParameters on OUT; expect Parameters on IN */
function f_ccid_set_par(template (value) CCID_ProtocolData par,
			template (present) CCID_Header_IN hdr_in := tr_CCID_HeaderIN_OK)
runs on Slot_CT return CCID_PDU {
	var CCID_PDU pdu;

	pdu := f_ccid_xceive(ts_CCID_SetParameters(g_slot_nr, par),
			     tr_CCID_Parameters(g_slot_nr, hdr_in := hdr_in));
	return pdu;
}

/* Send GetParameters on OUT; expect Parameters on IN */
function f_ccid_get_par(template (present) CCID_Header_IN hdr_in := tr_CCID_HeaderIN_OK)
runs on Slot_CT return CCID_PDU {
	var CCID_PDU pdu;

	pdu := f_ccid_xceive(ts_CCID_GetParameters(g_slot_nr),
			     tr_CCID_Parameters(g_slot_nr, hdr_in := hdr_in));
	return pdu;
}

/* Send ResetParameters on OUT; expect Parameters on IN */
function f_ccid_reset_par(template (present) CCID_Header_IN hdr_in := tr_CCID_HeaderIN_OK)
runs on Slot_CT return CCID_PDU {
	var CCID_PDU pdu;

	/* [at least] Omnikey seems to have failed to follow the CCID spec here :/ */
	if (mp_quirk_resetpar_returns_slotsts) {
		pdu := f_ccid_xceive(ts_CCID_ResetParameters(g_slot_nr),
				     tr_CCID_SlotStatus(g_slot_nr, hdr_in := hdr_in));
	} else {
		pdu := f_ccid_xceive(ts_CCID_ResetParameters(g_slot_nr),
				     tr_CCID_Parameters(g_slot_nr, hdr_in := hdr_in));
	}
	return pdu;
}

/* Send Escape on OUT; expect Escape on IN */
function f_ccid_escape(template (value) octetstring data,
			template (present) CCID_Header_IN hdr_in := tr_CCID_HeaderIN_OK)
runs on Slot_CT return CCID_PDU {
	var CCID_PDU pdu;

	pdu := f_ccid_xceive(ts_CCID_Escape(g_slot_nr, data),
			     tr_CCID_EscapeIN(g_slot_nr, hdr_in := hdr_in));
	return pdu;
}

function f_ccid_get_slotstatus(template (present) CCID_Header_IN hdr_in := tr_CCID_HeaderIN_OK)
runs on Slot_CT return CCID_PDU {
	var CCID_PDU pdu;

	pdu := f_ccid_xceive(ts_CCID_GetSlotStatus(g_slot_nr),
			     tr_CCID_SlotStatus(g_slot_nr, hdr_in := hdr_in));
	return pdu;
}




}
