Send APDU just one time

Question

My application (in delphi) send Name(string), Family(string), And children (array of string)...
then These data will convert into Hex format and will be sent to CAD via APDU...
My question is how can I send all of these data at once via on APDU command, should I send Name and Family one by one and also send every index in my array one by one ??
I wrote an applet which has a SetName, Set Family and SetChildren Methods and once call SetName and send Name via one APDU, then call SetFamily and send Family via other APDU, and the big problem is in array that I'm sending each index data of array via one APDU...
I'm sure it's a foolish way and there's a better way to send these data :)
would u please help me and guid me what can I do, this is so much urgent
Kind Regards
Hana

Answer 1

Zip_Smart_Girl wrote:
first a question about your last reply:
I add this code in my applet process method, so what can i send from JCOP, can I now send Lc in 2 bytes ??The card you have is Java Card 2.2.1 which does not support extended length APDU's. As such your only choice is to implement chaining. This is also the reason why your code does not compile in Eclipse. You are building against the JC2.2.1 libraries.
Here is some code that may help you get started. This code is not tested (apart from the fact it compiles) as I am not at work at the moment. This code comes with all the standard disclaimers and may not be fit for purpose... so use at your own risk :) There is still more validation that could go in (such as checking that the GET-RESPONSE command has the same CLA byte etc). Hopefully this code works and gets you started with command and response chaining. This may also help anyone else that needs to do something similar. If this can help just one person I will be happy.
Cheers,
Shane
package chaining;
import javacard.framework.APDU;
import javacard.framework.Applet;
import javacard.framework.ISO7816;
import javacard.framework.ISOException;
import javacard.framework.JCSystem;
import javacard.framework.Util;
* Very simple applet for chaining data to and from a card.
* @author shane
public class ChainingApplet extends Applet {
    private final static byte INS_GET_RESPONSE = (byte) 0xC0;
    private final static byte INS_PUT_DATA = 0x00;
    private final static byte INS_GET_DATA = 0x01;
    private final static byte OFFSET_SENT = 0x00;
    private final static byte OFFSET_RECV = 0x01;
    private static short[] offset;
    private static byte[] fileBuffer;
    private static short fileSize = 0;
    private final static short FILE_SIZE = 2048; // 2KB file
    private final static short MAX_APDU = 255;
     * Default constructor that initialises all memory to be used by the applet.
    public ChainingApplet() {
        offset = JCSystem.makeTransientShortArray((short) 2, JCSystem.CLEAR_ON_RESET);
        fileBuffer = new byte[FILE_SIZE];
     * {@inheritDoc}
    public static void install(byte[] bArray, short bOffset, byte bLength) {
        // GP-compliant JavaCard applet registration
        new ChainingApplet().register(bArray, (short) (bOffset + 1), bArray[bOffset]);
     * {@inheritDoc}
    public void process(APDU apdu) {
        // Good practice: Return 9000 on SELECT
        if (selectingApplet()) {
            return;
        short len = apdu.setIncomingAndReceive(); // This is the amount of data read from the OS.
        byte[] buf = apdu.getBuffer();
        byte cla = buf[ISO7816.OFFSET_CLA];
        byte ins = buf[ISO7816.OFFSET_INS];
        short lc = (short) (buf[ISO7816.OFFSET_LC] & 0x00ff); // this is the LC from the APDU.
        // get all bytes from the buffer
        while (len < lc) {
            len += apdu.receiveBytes(len);
        // validate the INS byte (basic check that tests for valid GET-RESPONSE or GET-DATA)
        if (offset[OFFSET_SENT] > 0 && ins != INS_GET_RESPONSE) {
            ISOException.throwIt(ISO7816.SW_CONDITIONS_NOT_SATISFIED);
        } else if (ins == INS_GET_RESPONSE && offset[OFFSET_SENT] == 0) {
            ISOException.throwIt(ISO7816.SW_CONDITIONS_NOT_SATISFIED);
        switch (buf[ISO7816.OFFSET_INS]) {
            case INS_PUT_DATA:
                saveData(buf, ISO7816.OFFSET_CDATA, offset[OFFSET_RECV], len);
                if ((cla & 0x10) != 0x00) {
                    offset[OFFSET_RECV] += len;
                } else {
                    // last command in the chain
                    fileSize = (short) (offset[OFFSET_RECV] + len);
                    offset[OFFSET_RECV] = 0;
                break;
            case INS_GET_DATA:
            case INS_GET_RESPONSE:
                sendData(apdu);
                break;
            default:
                // good practice: If you don't know the INStruction, say so:
                ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
     * Simple method to save the data somewhere. Add real implementation here.
     * @param source
     *            buffer containing data to copy
     * @param sourceOff
     *            offset into source buffer to the data
     * @param destOff
     *            offset into the destination buffer
     * @param len
     *            length of the data to copy.
    private static void saveData(byte[] source, short sourceOff, short destOff, short len) {
        // prevent buffer overflow
        if ((short) (destOff + len) > FILE_SIZE) {
            ISOException.throwIt(ISO7816.SW_FILE_FULL);
        Util.arrayCopy(source, sourceOff, fileBuffer, destOff, len);
     * Simple method to send chainined data to the client application (if required).
     * @param apdu
     *            current APDU
    private void sendData(APDU apdu) {
        // work out how many bytes to send this time and how many will be left
        short remain = (short) (fileSize - offset[OFFSET_SENT]);
        boolean chain = remain > MAX_APDU;
        short sendLen = chain ? MAX_APDU : remain;
        // Get ready to send
        apdu.setOutgoing();
        apdu.setOutgoingLength(sendLen);
        apdu.sendBytesLong(fileBuffer, offset[OFFSET_SENT], sendLen);
        // Check to see if there are more APDU's to send
        if (chain) {
            offset[OFFSET_SENT] += sendLen; // count the bytes sent
            ISOException.throwIt(ISO7816.SW_BYTES_REMAINING_00); // indicate there are more bytes to come
        } else {
            offset[OFFSET_SENT] = 0; // no more bytes to send
}