/** * JWAP - A Java Implementation of the WAP Protocols * Copyright (C) 2001-2004 Niko Bender * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */package net.sourceforge.jwap.wtp;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.util.Random;import net.sourceforge.jwap.util.Logger;import net.sourceforge.jwap.wtp.pdu.CWTPAbort;import net.sourceforge.jwap.wtp.pdu.CWTPAck;import net.sourceforge.jwap.wtp.pdu.CWTPInvoke;import net.sourceforge.jwap.wtp.pdu.CWTPPDU;import net.sourceforge.jwap.wtp.pdu.CWTPResult;import net.sourceforge.jwap.wtp.pdu.CWTPSegmResult;import net.sourceforge.jwap.wtp.pdu.EWTPCorruptPDUException;/** * This class implements a WTP state machine of one transaction according * to the WTP specification by the WAP Forum. It uses CWTPManagement to send * the PDUs. CWTPManagement receives PDUs from the remote, decodes them and * calls #process(CWTPPDU pdu) of the corresponding tranaction (this class). * <p> * To be informed of thrown service primitives by this layer, you should * implement the interface IWTPUpperLayer and give it with the constructor. * </p><p> * To construct a service primitive to be processed by this WTP-socket, * use objects of the class CWTPEvent, that implement service primitives. * </p><p> * To Use a whole WAP Stack besides you need the WSP layer, implemented * in package mmsjua.wap.wsp. * </p><p> * <b>Notice</b>, that development is actually in progress. * Most features are implemented but only for Initiator, not for a responder! * (for a definition of these terms refer to the spec, section 3.2.) * </p><p> * <b>Section descriptions</b> used in this class refer to * WTP Specification WAP-224-WTP-20010710-a * by the <a href="http://www.wapforum.org">WAP Forum</a> * </p> * */public class CWTPInitiator implements IWTPTransaction {    private static final byte STATE_NULL = 0x00;    private static final byte STATE_RESULT_WAIT = 0x01;    private static final byte STATE_RESULT_RESP_WAIT = 0x02;    private static final byte STATE_WAIT_TIMEOUT = 0x03;    private static final byte STATE_WAIT_ACK = 0x04;    private static final String[] states = {        "NULL", "RESULT WAIT", "RESULT RESP WAIT", "WAIT TIMEOUT", "WAIT ACK"    };    protected static Logger logger = Logger.getLogger(CWTPInitiator.class);    public static final int RCR_MAX = 3;    public static final int AEC_MAX = 3;    /**     * 9.4.3     * counter to generate unique TIDs     * uint16     */    private static int genTID = -1;    private byte state = 0x00;    // which session does this transaction belong to?    private IWTPUpperLayer upperLayer;    // used to send and receive    private CWTPSocket wtpSocket;    // is this transaction aborted?    private boolean aborted = false;    private short abortCode;    /**     * 5.3.1.7     * Class Type 1, 2 or 3     */    private byte classType;    /**     * 9.4.1     * ack interval     * this sets a bound for the amount of time to wait before sending an acknowledgement.     */    private javax.swing.Timer a_timer;    private int a = 5000;    /**     * 9.4.1     * retry interval     * This sets a bound for the amount of time to wait before re-transmitting a PDU.     */    private javax.swing.Timer r_timer;    private int r = 10000;    /**     * 9.4.1     * wait timeout interval (only class 2 initiator and class 1 responder)     * This sets a bound for the amount of time to wait before state information     * about a transaction is released.     */    private javax.swing.Timer w_timer;    private int w = 5000;    /**     * 7.14.3     * While segmentation each segment has to be acknowledged. This timer     * waits before resending a segment.     */    private javax.swing.Timer s_timer;    private int s = 5000;    private CWTPPDU segment;    private int segment_sended = 1;    private final int segment_sended_max = 4;    /**     * 9.4.2     * re-transmission counter     * acknowledgement expireation counter     */    private int rcr = 0;    private int aec = 0;    /**     * uint16     */    private int sendTID;    private int rcvTID;    private int lastTID;    /**     * recently sent PDU - hold it for retransmission     */    private CWTPPDU sentPDU;    private boolean holdOn = false;    private boolean uack = false;    /**     * next segment to send while in STATE_WAIT_ACK     */    private int segmentIndex = 0;    private ByteArrayOutputStream segdata;    private int segend;    private short seglast;    private int segTID;    //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    //XXXXXXXXXXXXXXXXXXXXXXX CONSTRUCTOR XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    /**     * Constructs a CWTPSocket using a DatagramSocket (UDP).     * Even implementing all parameters belonging to according to     * TR-Invoke service primitive (section 5.3.1),     * which are not temporary for one transaction.     * This socket can be used several times by service primitives.     * After all it has to be closed by calling <code>close()</code>     *     * @see #close(short)     * @param to destination address (section 5.3.1.3)     * @param port destination port (section 5.3.1.4)     * @param ackType Ack Type (section 5.3.1.5)     * @param classType Class Type (0, 1 or 2) (section 5.3.1.8)     * @throws IllegalArgumentException     * @throws SocketException     */    public CWTPInitiator(CWTPSocket wtp_Socket, IWTPUpperLayer upper_Layer,        CWTPEvent initPacket, boolean ackType, byte classType) {        init(wtp_Socket, upper_Layer, ackType, classType);        sendTID = CWTPInitiator.generateNewTID();        rcvTID = sendTID - 32768; // rcvTID = sendTID XOR 0x8000        // process the init service primitive        try {            process(initPacket);        } catch (EWTPAbortedException e) {            logger.warn("Event processing aborted", e);        }    }    private void init(CWTPSocket wtp_Socket, IWTPUpperLayer upper_Layer,        boolean ackType, byte classType) throws IllegalArgumentException {        this.upperLayer = upper_Layer;        this.wtpSocket = wtp_Socket;        uack = ackType;        setClassType(classType);        // initialize timer and add actionListener        // see declaration of a_timer above        a_timer = new javax.swing.Timer(a,                new ActionListener() {                    public void actionPerformed(ActionEvent e) {                        a_timer.stop();                        if (state == STATE_RESULT_RESP_WAIT) {                            // check acknowledgement counter                            if (!uack) { // if user acknowledgement is turned off                                // unfortunately I do not remember why I have coded this branch like this.                                logger.error("acknowledgement timer: exceeded " +                                    (aec + 1) + " time(s) --> cancel");                                CWTPAck send = new CWTPAck(sendTID);                                wtpSocket.send(send);                                w_timer.restart();                                setState(STATE_WAIT_TIMEOUT);                            } else if (aec < AEC_MAX) {                                if(logger.isDebugEnabled()) {                                    logger.debug("acknowledgement timer: exceeded " +                                        (aec + 1) + " time(s).");                                }                                aec++;                                a_timer.restart();                                setState(STATE_RESULT_RESP_WAIT);                            } else if (aec == AEC_MAX) {                                //abort if acknowledgement counter exceeds the maximum                                logger.error("acknowledgement timer: exceeded " +                                    (aec + 1) + " time(s) --> cancel");                                CWTPAbort send = new CWTPAbort(sendTID);                                send.setAbortReason(CWTPAbort.ABORT_REASON_NORESPONSE);                                wtpSocket.send(send);                                close(CWTPAbort.ABORT_REASON_NORESPONSE);                                aec = 0;                                setState(STATE_NULL);                            }                        }                    }                });        // see declaration of r_timer above        r_timer = new javax.swing.Timer(r,                new ActionListener() {                    public void actionPerformed(ActionEvent e) {                        r_timer.stop();                        if (state == STATE_RESULT_WAIT) {                            // check retransmission counter                            if (rcr < RCR_MAX) {                                /** @todo Ack(TIDok) already sent? Page 53 */                                if(logger.isDebugEnabled()) {                                    logger.debug("retransmission timer: exceeded " +                                    (rcr + 1) + " time(s) --> re-send");                                }                                rcr++;                                r_timer.restart();                                // re-send recent Invoke                                sentPDU.setRID(true);                                wtpSocket.send(sentPDU);                                setState(STATE_RESULT_WAIT);                            } else if (rcr == RCR_MAX) {                                logger.error("retransmission timer: exceeded " +                                    (rcr + 1) + " time(s) --> cancel");                                // abort                                close(CWTPAbort.ABORT_REASON_UNKNOWN);                                upperLayer.tr_abort(CWTPAbort.ABORT_REASON_UNKNOWN);                                rcr = 0;                                setState(STATE_NULL);                            }                        }                    }                });        // see declaration of w_timer above        w_timer = new javax.swing.Timer(w,                new ActionListener() {                    public void actionPerformed(ActionEvent e) {                        w_timer.stop();                        if (state == STATE_WAIT_TIMEOUT) {                            logger.debug("wait timeout");                            setState(STATE_NULL);                            close((short) 0x00);                        }                    }                });        // see declaration of w_timer above        s_timer = new javax.swing.Timer(s,                new ActionListener() {                    public void actionPerformed(ActionEvent e) {                        s_timer.stop();                        if (segment_sended > segment_sended_max) {                            if(logger.isDebugEnabled()) {                                logger.debug("wait_ack timeout (" + segment_sended +                                    "), abort.");                            }                            segment_sended = 1;                            setState(STATE_NULL);                            close((short) 0x00);                        } else {                            if (state == STATE_WAIT_ACK) {                                if(logger.isDebugEnabled()) {                                    logger.debug("wait_ack timeout (" +                                        segment_sended + "), re-sending segment.");                                }                                segment.setRID(true);                                wtpSocket.send(segment);                                segment_sended++;                                s_timer.restart();                            }                        }                    }                });    }    //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX    /**     * Invoked by the run()-Method of the Management-Entity CWTPManagement.     * Processes given protocol data units     * according to state machine described in section 9.5     * <b>Notice:</b> Only WTP Initiator is implemented!     *     * @param pdu the pdu to be processed in the state machine     */    public synchronized void process(CWTPPDU pdu) throws EWTPAbortedException {        if (aborted) {            throw new EWTPAbortedException(abortCode);        }        if (logger.isDebugEnabled()) {            logger.debug("process(CWTPPDU pdu)  " + sendTID + ": " + CWTPPDU.types[pdu.getPDUType()] +                " in " + states[state] + " class " + classType + " holdOn " +                holdOn);        }        switch (state) {        ///////////////////// NULL //////////////////////////////////////////////        case 0x00:            // because only initiator is implemented,            // we do not need to react on pdu-events in NULL state            break;        ///////////////////// RESULT WAIT ///////////////////////////////////////        case 0x01:            // RcvAck in RESULT WAIT            if (pdu.getPDUType() == CWTPPDU.PDU_TYPE_ACK) {                if (((CWTPAck) pdu).getTve_tok() &&                        ((classType == 1) || (classType == 2)) &&                        (rcr < RCR_MAX)) {                    CWTPAck send = new CWTPAck(((CWTPAck) pdu).getTID() &                            0x7fff);                    send.setTve_tok(true);                    wtpSocket.send(send);                    rcr++;                    r_timer.restart();                    setState(STATE_RESULT_WAIT);                } else if (((CWTPAck) pdu).getTve_tok() &&                        ((classType == 1) || (classType == 2))) {                    setState(STATE_RESULT_WAIT);                } else if ((classType == 2) && !holdOn) {                    r_timer.stop();                    upperLayer.tr_process(new CWTPEvent(pdu.getPayload(),                            CWTPEvent.TR_INVOKE_CNF));                    this.holdOn = true;                    setState(CWTPInitiator.STATE_RESULT_WAIT);                } else if ((classType == 2) && holdOn) {                    setState(STATE_RESULT_WAIT);                } else if (classType == 1) {                    r_timer.stop();                    upperLayer.tr_process(new CWTPEvent(pdu.getPayload(),                            CWTPEvent.TR_INVOKE_CNF));                    setState(STATE_NULL);                }            }            // RcvAbort in RESULT WAIT            else if (pdu.getPDUType() == CWTPPDU.PDU_TYPE_ABORT) {                short abortReason = ((CWTPAbort) pdu).getAbortReason();                close(abortReason);                upperLayer.tr_abort(abortReason);                setState(STATE_NULL);            }            // RcvResult in RESULT WAIT            else if (pdu.getPDUType() == CWTPPDU.PDU_TYPE_RESULT && classType == 2) {              CWTPResult res = (CWTPResult) pdu;              byte nextState=STATE_RESULT_RESP_WAIT;              // Stop timer              r_timer.stop();              // Check for segmentation indication              if( !res.getTTR() )              {                logger.debug("Not last packet");                segend = 0; seglast = 0;                segdata = new  ByteArrayOutputStream(64*1024); // 64kbyte segs                segTID = pdu.getTID();                try {