cwtpresponder.java

WAP Stack implementation jwap.sourceforge.net

              // TID OK
              a_timer.restart();
              CWTPEvent initPacket = new CWTPEvent(pdu.getPayload(),
                                                     CWTPEvent.TR_INVOKE_IND);
              initPacket.setTransaction(this);
              upperLayer.tr_process(initPacket);
              setState(STATE_INVOKE_RESP_WAIT);
            }
            else {
              // TID not OK
              CWTPAck ack = new CWTPAck(sendTID);
              ack.setTve_tok(true);
              wtpSocket.send(ack);
              setState(STATE_TIDOK_WAIT);
            }
          }
          else if (classType == CLASS_TYPE_0){
            CWTPEvent initPacket = new CWTPEvent(pdu.getPayload(),
                                                   CWTPEvent.TR_INVOKE_IND);
            initPacket.setTransaction(this);
            upperLayer.tr_process(initPacket);
            setState(STATE_LISTEN);
          }
        }// end invoke PDU in listen
        break;

      //////////////////// STATE TIDOK WAIT ////////////////////////////////////
      case 0x01:
        if (pdu.getPDUType() == CWTPPDU.PDU_TYPE_ACK &&
            (classType == CLASS_TYPE_1 || classType == CLASS_TYPE_2) &&
            (true) /** @todo TID ok? */){
          CWTPEvent initPacket = new CWTPEvent(pdu.getPayload(),
                                                     CWTPEvent.TR_INVOKE_IND);
          initPacket.setTransaction(this);
          upperLayer.tr_process(initPacket);
          a_timer.restart();
          setState(STATE_INVOKE_RESP_WAIT);
        }
        else if(pdu.getPDUType() == CWTPPDU.PDU_TYPE_ABORT){
          short abortReason = ((CWTPAbort)pdu).getAbortReason();
          close(abortReason);
          upperLayer.tr_abort(abortReason);
          setState(STATE_LISTEN);
        }
        else if(pdu.getPDUType() == CWTPPDU.PDU_TYPE_INVOKE){
          if(pdu.getRID()){
            CWTPAck ack = new CWTPAck(sendTID);
            ack.setTve_tok(true);
            wtpSocket.send(ack);
            setState(STATE_TIDOK_WAIT);
          }
          else {
            // ignore
            setState(STATE_TIDOK_WAIT);
          }
        }
        break;

      ///////////////////// STATE INVOKE RESP WAIT /////////////////////////////
      case 0x02:
        if (pdu.getPDUType() == CWTPPDU.PDU_TYPE_ABORT){
          short abortReason = ((CWTPAbort)pdu).getAbortReason();
          close(abortReason);
          upperLayer.tr_abort(abortReason);
          setState(STATE_LISTEN);
        }
        else if (pdu.getPDUType() == CWTPPDU.PDU_TYPE_INVOKE){
          // ignore
          setState(STATE_INVOKE_RESP_WAIT);
        }
        break;

      ///////////////////// STATE RESULT WAIT //////////////////////////////////
      case 0x03:
        if(pdu.getPDUType() == CWTPPDU.PDU_TYPE_INVOKE){
          if(pdu.getRID()){
            if(true/** @todo ack pdu already sent? */){
              // resend Ack PDU
              setState(STATE_RESULT_WAIT);
            }
            else{
              // ignore
              setState(STATE_RESULT_WAIT);
            }
          }
          else{
            // ignore
            setState(STATE_RESULT_WAIT);
          }
        }
        else if(pdu.getPDUType() == CWTPPDU.PDU_TYPE_ABORT){
          short abortReason = ((CWTPAbort)pdu).getAbortReason();
          close(abortReason);
          upperLayer.tr_abort(abortReason);
          setState(STATE_LISTEN);
        }
        break;
      ///////////////////// STATE RESULT RESP WAIT /////////////////////////////
      case 0x04:
        if(pdu.getPDUType() == CWTPPDU.PDU_TYPE_ABORT){
          short abortReason = ((CWTPAbort)pdu).getAbortReason();
          close(abortReason);
          upperLayer.tr_abort(abortReason);
          setState(STATE_LISTEN);
        }
        else if(pdu.getPDUType() == CWTPPDU.PDU_TYPE_ACK){
          CWTPAck pduAck = (CWTPAck)pdu;
          if(pduAck.getTve_tok()){
            // ignore
            setState(STATE_RESULT_RESP_WAIT);
          } else{
            CWTPEvent p = new CWTPEvent(pdu.getPayload(), CWTPEvent.TR_RESULT_CNF);
            upperLayer.tr_process(p);
            setState(STATE_LISTEN);
          }
        }
        break;
      ///////////////////// STATE WAIT TIMEOUT /////////////////////////////////
      case 0x05:
        if(pdu.getPDUType() == CWTPPDU.PDU_TYPE_INVOKE){
          CWTPInvoke invokepdu = (CWTPInvoke)pdu;
          if(invokepdu.getRID()){
            CWTPAck ackpdu = new CWTPAck(sendTID);
            /** @todo input exitInfo TPI if available seite 56 */
            wtpSocket.send(ackpdu);
            setState(STATE_WAIT_TIMEOUT);
          }
          else {
            // ignore
            setState(STATE_WAIT_TIMEOUT);
          }
        }
        else if(pdu.getPDUType() == CWTPPDU.PDU_TYPE_ACK){
          CWTPAck acki = (CWTPAck)pdu;
          if(acki.getTve_tok() &&
             acki.getRID()){
            CWTPAck ackpdu = new CWTPAck(sendTID);
            /** @todo input exitInfo TPI if available seite 56 */
            wtpSocket.send(ackpdu);
            setState(STATE_WAIT_TIMEOUT);
          }
        }
        else if(pdu.getPDUType() == CWTPPDU.PDU_TYPE_ABORT){
          short abortReason = ((CWTPAbort)pdu).getAbortReason();
          close(abortReason);
          upperLayer.tr_abort(abortReason);
          setState(STATE_LISTEN);
        }
        break;
    }
  }


  /**
   * Invoked by higher layers to process given service primitives
   * according to state machine described in section 9.5.<br>
   * <b>Notice:</b> Only WTP Initiator is implemented!
   *
   * @param p the Service Primitive to be processed
   */
  public synchronized void process(CWTPEvent p) throws EWTPAbortedException{
    if (aborted){
      throw new EWTPAbortedException(abortCode);
    }
    switch (state){
      ///////////////////// STATE LISTEN ///////////////////////////////////////
      //case 0x00:
      //not possible
      //////////////////// STATE TIDOK WAIT ////////////////////////////////////
      //case 0x01:
      //not possible
      ///////////////////// STATE INVOKE RESP WAIT /////////////////////////////
      case 0x02:
        if(p.getType() == CWTPEvent.TR_INVOKE_RES){
          if (classType == CLASS_TYPE_1){
            /** @todo input exitinfo tpi if availabe */
            CWTPAck ack = new CWTPAck(sendTID);
            wtpSocket.send(ack);
            w_timer.restart();
            setState(STATE_WAIT_TIMEOUT);
          }
          else if(classType == CLASS_TYPE_2){
            a_timer.restart();
            setState(STATE_RESULT_WAIT);
          }
        }
        else if(p.getType() == CWTPEvent.TR_RESULT_REQ){
          rcr = 0;
          sentPDU = new CWTPResult(p.getUserData(), sendTID);
          wtpSocket.send(sentPDU);
          r_timer.restart();
          setState(STATE_RESULT_RESP_WAIT);
        }
        break;
      ///////////////////// STATE RESULT WAIT //////////////////////////////////
      case 0x03:
        if(p.getType() == CWTPEvent.TR_RESULT_REQ){
          rcr = 0;
          sentPDU = new CWTPResult(p.getUserData(), sendTID);
          wtpSocket.send(sentPDU);
          r_timer.restart();
          setState(STATE_RESULT_RESP_WAIT);
        }
        break;
      ///////////////////// STATE RESULT RESP WAIT /////////////////////////////
      //case 0x04:
      //not possible
      ///////////////////// STATE WAIT TIMEOUT /////////////////////////////////
      //case 0x05:
      //not possible
    }
  }

  /**
   * RcvErrorPDU
   * @param e exception thrown by CWTPFactory
   */
  public void process(EWTPCorruptPDUException e){
    CWTPAbort abort = new CWTPAbort(sendTID);
    abort.setAbortReason(CWTPAbort.ABORT_REASON_PROTOERR);
    wtpSocket.send(abort);
    if (state != STATE_LISTEN){
      if (state != STATE_TIDOK_WAIT){
        upperLayer.tr_abort(CWTPAbort.ABORT_REASON_PROTOERR);
      }
      close(CWTPAbort.ABORT_REASON_PROTOERR);
      setState(STATE_LISTEN);
    }
  }

  /**
   * use this method to invoke a TR-ABORT.REQ by the upper Layer
   */
  public void abort(){
    abort(CWTPAbort.ABORT_REASON_UNKNOWN);
  }

  /**
   * use this method to invoke a TR-ABORT.REQ by the upper Layer
   */
  public void abort(short abortReason){
    if (state == STATE_INVOKE_RESP_WAIT ||
        state == STATE_RESULT_WAIT ||
        state == STATE_RESULT_RESP_WAIT ||
        state == STATE_WAIT_TIMEOUT){
      close(abortReason);
      CWTPAbort abort = new CWTPAbort(sendTID);
      abort.setAbortReason(abortReason);
      setState(STATE_LISTEN);
    }
  }

  public void close(short reasonCode){
    abortCode = reasonCode;
    aborted = true;
    r_timer.stop();
    w_timer.stop();
    a_timer.stop();
    setState(STATE_LISTEN);
    wtpSocket.removeTransaction(this);
  }

  //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  //XXXXXXXXXXXXXXXXXXXXXX SET/GET XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

  public int getTID(){
    return sendTID;
  }

  public void setClassType(byte classType) throws IllegalArgumentException{
    if (classType == 1 |classType == 2 | classType == 0){
      this.classType = classType;
      return;
    } else{
      throw new IllegalArgumentException("Class Type has to be 1, 2 or 3");
    }
  }

  public byte getClassType(){
    return classType;
  }

  private void setState(byte state){
    logger.debug(">>> WTP Responder: " + states[state] + "<<<");
  }

  public boolean isAborted(){
    return aborted;
  }

  public short getAbortCode(){
    return abortCode;
  }
}