cwtpresponder.java

WAP Stack implementation jwap.sourceforge.net

/**
 * 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 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.EWTPCorruptPDUException;


public class CWTPResponder implements IWTPTransaction{

  private static final byte STATE_LISTEN = 0x00;
  private static final byte STATE_TIDOK_WAIT = 0x01;
  private static final byte STATE_INVOKE_RESP_WAIT = 0x02;
  private static final byte STATE_RESULT_WAIT = 0x03;
  private static final byte STATE_RESULT_RESP_WAIT = 0x04;
  private static final byte STATE_WAIT_TIMEOUT = 0x05;

  private static final String[] states = {"LISTEN",
                                          "TIDOK WAIT",
                                          "INVOKE RESP WAIT",
                                          "RESULT WAIT",
                                          "RESLUT RESP WAIT",
                                          "WAIT TIMEOUT"};

  static Logger logger = Logger.getLogger(CWTPResponder.class);

  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;

  /**
   * 9.4.2
   * re-transmission counter
   * acknowledgement expireation counter
   */
  private int rcr = 0;
  private int aec = 0;

  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 = 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;


  //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 CWTPResponder(CWTPSocket wtp_Socket,
                        IWTPUpperLayer upper_Layer,
                        CWTPInvoke initPDU,
                        boolean ackType,
                        byte classtype
                        ){
    init(wtp_Socket, upperLayer, ackType, classtype);

    rcvTID = initPDU.getTID();
    sendTID = rcvTID - 32768; // sendTID = rcvTID XOR 0x8000

    // process the invoke pdu
    try{
      process(initPDU);
    } catch (EWTPAbortedException e){
      logger.error("PDU 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;
    wtpSocket.addTransaction(this);
    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_INVOKE_RESP_WAIT){
            // check acknowledgement counter
            if (aec < AEC_MAX){
              logger.debug("acknowledgement timer abgelaufen: aec < AEC_MAX");

              aec++;
              a_timer.restart();
              setState(STATE_RESULT_RESP_WAIT);
            } else if (aec == AEC_MAX){
              //abort if acknowledgement counter exceeds the maximum
              logger.debug("acknowledgement timer abgelaufen: aec == AEC_MAX");


              CWTPAbort send = new CWTPAbort(sendTID);
              send.setAbortReason(CWTPAbort.ABORT_REASON_NORESPONSE);
              wtpSocket.send(send);
              close(CWTPAbort.ABORT_REASON_NORESPONSE);
              aec = 0;
              upperLayer.tr_abort(CWTPAbort.ABORT_REASON_NORESPONSE);
              setState(STATE_LISTEN);
            } else if (!uack && classType == CLASS_TYPE_1){
              logger.debug("acknowledgement timer abgelaufen: uack == false classtype 1");

              CWTPAck send = new CWTPAck(sendTID);
              wtpSocket.send(send);
              w_timer.restart();
              setState(STATE_WAIT_TIMEOUT);
            } else if (!uack && classType == CLASS_TYPE_2){
              logger.debug("acknowledgement timer abgelaufen: uack == false classtype 2");

              CWTPAck ack = new CWTPAck(sendTID);
              wtpSocket.send(ack);
              setState(STATE_RESULT_WAIT);
            }
          }
          else if (state == STATE_RESULT_WAIT){
            logger.debug("acknowledgement timer abgelaufen.");

            CWTPAck ack = new CWTPAck(sendTID);
            wtpSocket.send(ack);
            setState(STATE_RESULT_WAIT);
          }
        }
      }
    );

    // 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_RESP_WAIT){
            // check retransmission counter
            if (rcr < RCR_MAX){
              logger.debug("retransmission timer "+ rcr
                            + " mal abgelaufen. Re-sending Result.");

              rcr++;
              r_timer.restart();
              // re-send recent Result
              wtpSocket.send(sentPDU);
              setState(STATE_RESULT_RESP_WAIT);
            } else if (rcr == RCR_MAX){
              logger.debug("retransmission timer " + rcr
                            + " mal abgelaufen. Abbruch!");

              // abort
              close(CWTPAbort.ABORT_REASON_UNKNOWN);
              upperLayer.tr_abort(CWTPAbort.ABORT_REASON_UNKNOWN);
              rcr = 0;
              setState(STATE_LISTEN);
            }
          }
        }
      }
    );

    // 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_LISTEN);
            close((short)0x00);
          }
        }
      }
    );
  }

  //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);
    }
    switch (state){
      ///////////////////// STATE LISTEN ///////////////////////////////////////
      case 0x00:
        // invoke pdu in state listen
        if(pdu.getPDUType() == CWTPPDU.PDU_TYPE_INVOKE){
          if (this.classType == IWTPTransaction.CLASS_TYPE_1 ||
              this.classType == IWTPTransaction.CLASS_TYPE_2){
            if (true/** @todo is tid ok? */){