cwtpinitiator.java

WAP Gateway source code in JAVA：WAP网关的java源码

                    setState(STATE_WAIT_TIMEOUT);
                }
            }

            break;

        ///////////////////// WAIT ACK WHILE SEGMENTATION SENDING ////////////////
        case 0x04:

            // rcvAck in STATE_WAIT_ACK
            if (pdu.getPDUType() == CWTPPDU.PDU_TYPE_ACK) {
                //re-initialize re-sending counter
                s_timer.stop();
                segment_sended = 1;
                segment = null;

                // send next segment
                pdu = (CWTPPDU) (sentPDU.getSegments().elementAt(segmentIndex));
                wtpSocket.send(pdu);

                segmentIndex++;

                // last segment sent
                if (sentPDU.getSegments().size() == segmentIndex) {
                    segmentIndex = 0;

                    if ((classType == 1) | (classType == 2)) {
                        // start timer to re-send whole message
                        r_timer.restart();
                        setState(STATE_RESULT_WAIT);
                    } else if (classType == 0) {
                        setState(STATE_NULL);
                        close((short) 0x00);
                    }
                }
                // not last segment
                else {
                    // save segment for re-sending
                    segment = pdu;

                    // start timer to re-send segment
                    s_timer.restart();
                }
            }

            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);
        }

        if (logger.isDebugEnabled()) {
            logger.debug("" + sendTID + ": " + CWTPEvent.types[p.getType()] +
                " in " + states[state]);
        }

        switch (state) {
        ///////////////////// STATE NULL /////////////////////////////////////////
        case 0x00:

            // TR-INVOKE.REQ
            // some things do do when receiving a TR-Invoke
            // were already done in the constructor - so please see there!
            if (p.getType() == CWTPEvent.TR_INVOKE_REQ) {
                if (((classType == 1) | (classType == 2)) && uack) {
                    CWTPInvoke send = new CWTPInvoke(p.getUserData(), sendTID,
                            classType);
                    wtpSocket.addTransaction(this);
                    wtpSocket.send(send);
                    sentPDU = send;
                    this.rcr = 0;
                    r_timer.restart();
                    setState(STATE_RESULT_WAIT);
                } else if (((classType == 1) | (classType == 2)) && !uack) {
                    CWTPInvoke send = new CWTPInvoke(p.getUserData(), sendTID,
                            classType);
                    wtpSocket.addTransaction(this);
                    wtpSocket.send(send);
                    sentPDU = send;
                    this.rcr = 0;

                    // do we have to segmentate?
                    if (!send.getTTR()) {
                        setState(STATE_WAIT_ACK);
                    } else {
                        r_timer.restart();
                        setState(STATE_RESULT_WAIT);
                    }
                } else if (classType == 0) {
                    CWTPInvoke send = new CWTPInvoke(p.getUserData(), sendTID,
                            classType);
                    wtpSocket.addTransaction(this);
                    wtpSocket.send(send);

                    // do we have to segmentate?
                    if (!send.getTTR()) {
                        sentPDU = send;
                        setState(STATE_WAIT_ACK);
                    } else {
                        setState(STATE_NULL);
                        close((short) 0x00);
                    }
                }
            }
             //end TR-INVOKE.REQ

            break;

        //////////////////// STATE RESULT WAIT ///////////////////////////////////
        case 0x01:
            break;

        ///////////////////// STATE RESULT RESP WAIT /////////////////////////////
        case 0x02:

            // TR-Result.res
            if (p.getType() == CWTPEvent.TR_RESULT_RES) {
                if (p.getExitInfo().length != 0) {
                    CWTPAck send = new CWTPAck(sendTID);

                    /** @todo input TPI exitinfo into "send" - page 54 top **/
                    wtpSocket.send(send);

                    w_timer.restart();
                    setState(STATE_WAIT_TIMEOUT);
                } else {
                    CWTPAck send = new CWTPAck(sendTID);
                    wtpSocket.send(send);

                    w_timer.restart();
                    setState(STATE_WAIT_TIMEOUT);
                }
            }
             // end TR-Result.res

            break;

        ///////////////////// STATE WAIT TIMEOUT /////////////////////////////////
        case 0x03:
            break;
        }
    }

    public void process(EWTPCorruptPDUException e) {
        if (state != STATE_NULL) {
            CWTPAbort send = new CWTPAbort(e.getTid());
            send.setAbortReason(CWTPAbort.ABORT_REASON_PROTOERR);
            wtpSocket.send(send);
            close(CWTPAbort.ABORT_REASON_PROTOERR);
            upperLayer.tr_abort(CWTPAbort.ABORT_REASON_PROTOERR);
            setState(STATE_NULL);
        }
    }

    /**
     * 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) {
        // TR-ABORT.REQ
        if ((state == 0x01) || (state == 0x02) || (state == 0x03)) {
            if(logger.isDebugEnabled()) {
                logger.debug("" + sendTID + ": TR-ABORT.REQ Reason: " +
                    abortReason);
            }

            CWTPAbort send = new CWTPAbort(sendTID);
            send.setAbortReason(abortReason);
            wtpSocket.send(send);
            close(abortReason);
        }
    }

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

    //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    //XXXXXXXXXXXXXXXXXXXXXX SET/GET XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    /*
      public boolean getAckType(){
        return uack;
      }
      public void setAckType(boolean ackType){
        uack = ackType;
      }


      public IWTPUpperLayer getUpperLayer(){
        return upperLayer;
      }
    */
    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) {
        //if (debug){
        //  log.log(0, this, "" + sendTID + ": " + states[this.state] + " >>> " + states[state]);
        //}
        this.state = state;
    }

    public boolean isAborted() {
        return aborted;
    }

    public short getAbortCode() {
        return abortCode;
    }

    //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    /**
     * Static method, that generates a new (unique) Transaction ID
     * by incrementing genTID
     *
     * @return A new unique Transaction ID
     */
    private static synchronized int generateNewTID() {
        if (genTID == -1) {
            Random r = new Random();
            genTID = Math.abs(r.nextInt() % 255);
        }

        int result = genTID;

        if (genTID == 255) {
            genTID = 0;
        } else {
            ++genTID;
        }

        return result;
    }
}