cwspsession.java

WAP Stack implementation jwap.sourceforge.net

                    }

                    break;

                case STATE_RESUMING:

                    if ((p.getTransaction().getClassType() == IWTPTransaction.CLASS_TYPE_0) &&
                            (pdu.getType() == CWSPPDU.PDU_TYPE_DISCONNECT)) {
                        wtp.abort(ABORT_DISCONNECT);
                        abortAllMethods(ABORT_DISCONNECT);
                        s_disconnect_ind(ABORT_DISCONNECT);
                        setState(STATE_NULL);
                    } else if ((p.getTransaction().getClassType() == IWTPTransaction.CLASS_TYPE_1) &&
                            (pdu.getType() == CWSPPDU.PDU_TYPE_CONFIRMEDPUSH)) {
                        p.getTransaction().abort(ABORT_PROTOERR);
                    }
                }

                break;

            case 0x03: //--------------------------------------------- TR-INVOKE.CNF

                switch (state) {
                case STATE_CONNECTING:

                    //ignore
                    break;

                case STATE_CONNECTED:
                    break;

                case STATE_SUSPENDED:

                    // ignore
                    break;

                case STATE_RESUMING:
                    // ignore
                }

                break;

            case 0x05: //--------------------------------------------- TR-RESULT.IND

                switch (state) {
                case STATE_CONNECTING:

                    if (p.getUserData().length > MRU) {
                        wtp.abort(ABORT_MRUEXCEEDED);
                        abortAllMethods(ABORT_CONNECTERR);
                        s_disconnect_ind(ABORT_MRUEXCEEDED);
                        setState(STATE_NULL);
                    } else if (pdu.getType() == CWSPPDU.PDU_TYPE_CONNECTREPLY) {
                        CWSPConnectReply pdu2 = (CWSPConnectReply) pdu;
                        setState(STATE_CONNECTED);

                        CWTPEvent initPacket = new CWTPEvent(new byte[0],
                                CWTPEvent.TR_RESULT_RES);
                        wtp.process(initPacket);
                        session_id = pdu2.getServerSessionID();
                        s_connect_cnf();
                    } else if (pdu.getType() == CWSPPDU.PDU_TYPE_REDIRECT) {
                        CWTPEvent initPacket = new CWTPEvent(new byte[0],
                                CWTPEvent.TR_RESULT_RES);
                        wtp.process(initPacket);
                        abortAllMethods(ABORT_CONNECTERR);

                        CWSPRedirect pdu2 = (CWSPRedirect) pdu;
                        if (version == 2){
                            s_disconnect_ind(pdu2.getSocketAddresses());
                        } else{
                            s_disconnect_ind(pdu2.getInetAddresses());
                        }
                        setState(STATE_NULL);
                    } else if (pdu.getType() == CWSPPDU.PDU_TYPE_REPLY) {
                        CWTPEvent initPacket = new CWTPEvent(new byte[0],
                                CWTPEvent.TR_RESULT_RES);
                        wtp.process(initPacket);
                        abortAllMethods(ABORT_CONNECTERR);

                        CWSPReply pdu2 = (CWSPReply) pdu;
                        s_disconnect_ind(pdu2.getStatus());
                        setState(STATE_NULL);
                    } else {
                        wtp.abort(ABORT_PROTOERR);
                        abortAllMethods(ABORT_CONNECTERR);
                        s_disconnect_ind(ABORT_PROTOERR);
                        setState(STATE_NULL);
                    }

                    break;

                case STATE_CONNECTED:
                    break;

                case STATE_SUSPENDED:
                    break;

                case STATE_RESUMING:

                    if (p.getUserData().length > MRU) {
                        wtp.abort(ABORT_MRUEXCEEDED);
                        abortAllMethods(ABORT_SUSPEND);
                        s_suspend_ind(ABORT_MRUEXCEEDED);
                        setState(STATE_SUSPENDED);
                    } else if (pdu.getType() == CWSPPDU.PDU_TYPE_REPLY) {
                        CWSPReply pdu2 = (CWSPReply) pdu;

                        if (pdu2.getStatus() == CWSPReply._200_OK_Success) {
                            CWTPEvent initPacket = new CWTPEvent(new byte[0],
                                    CWTPEvent.TR_RESULT_RES);
                            wtp.process(initPacket);
                            s_resume_cnf();
                            setState(STATE_CONNECTED);
                        } else {
                            CWTPEvent initPacket = new CWTPEvent(new byte[0],
                                    CWTPEvent.TR_RESULT_RES);
                            wtp.process(initPacket);
                            abortAllMethods(ABORT_DISCONNECT);

                            CWSPReply pdu3 = (CWSPReply) pdu;
                            s_disconnect_ind(pdu3.getStatus());
                            setState(STATE_NULL);
                        }
                    } else {
                        wtp.abort(ABORT_PROTOERR);
                        abortAllMethods(ABORT_SUSPEND);
                        s_suspend_ind(ABORT_PROTOERR);
                        setState(STATE_SUSPENDED);
                    }
                }

                break;

            case 0x07: //--------------------------------------------- TR-RESULT.CNF

                switch (state) {
                case STATE_CONNECTING:
                    break;

                case STATE_CONNECTED:
                    break;

                case STATE_SUSPENDED:
                    break;

                case STATE_RESUMING:}

                break;
            }
        } catch (EWSPCorruptPDUException e) {
            logger.error("Corrupt PDU", e);
        } catch (EWTPAbortedException e2) {
            logger.error("Aborted", e2);
        }
    }

    /**
     * TR-Abort.ind
     * @param abortReason The abort reason
     */
    public void tr_abort(short abortReason) {
        if (logger.isDebugEnabled()) {
            logger.debug("WSP Session: TR-ABORT.REQ in " + states[state]);
        }

        if (state == STATE_CONNECTING) {
            abortAllMethods(ABORT_CONNECTERR);
            s_disconnect_ind(abortReason);
            setState(STATE_NULL);
        } else if (state == STATE_SUSPENDED) {
            // ignore
        } else if (state == STATE_RESUMING) {
            if (abortReason == ABORT_DISCONNECT) {
                abortAllMethods(ABORT_DISCONNECT);
                s_disconnect_ind(ABORT_DISCONNECT);
                setState(STATE_NULL);
            } else {
                abortAllMethods(ABORT_SUSPEND);
                s_suspend_ind(abortReason);
                setState(STATE_SUSPENDED);
            }
        }
    }

    //////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////// WSP pseudo events
    public void disconnect() {
        socket.close();

        if (state == STATE_CONNECTING) {
            wtp.abort(ABORT_DISCONNECT);
            abortAllMethods(ABORT_DISCONNECT);
            s_disconnect_ind(ABORT_DISCONNECT);
            setState(STATE_NULL);
        } else if (state == STATE_CONNECTED) {
            abortAllMethods(ABORT_DISCONNECT);
            abortAllPushes(ABORT_DISCONNECT);
            s_disconnect_ind(ABORT_DISCONNECT);
            setState(STATE_NULL);
        } else if (state == STATE_SUSPENDED) {
            s_disconnect_ind(ABORT_DISCONNECT);
            setState(STATE_NULL);
        } else if (state == STATE_RESUMING) {
            wtp.abort(ABORT_DISCONNECT);
            abortAllMethods(ABORT_DISCONNECT);
            s_disconnect_ind(ABORT_DISCONNECT);
            setState(STATE_NULL);
        }
    }

    public void suspend() {
        if (state == STATE_CONNECTING) {
            wtp.abort(ABORT_DISCONNECT);
            abortAllMethods(ABORT_DISCONNECT);
            s_disconnect_ind(ABORT_SUSPEND);
            setState(STATE_NULL);
        } else if (state == STATE_CONNECTED) {
            // resume facility enabled!
            abortAllMethods(ABORT_SUSPEND);
            abortAllPushes(ABORT_SUSPEND);
            s_disconnect_ind(ABORT_SUSPEND);
            setState(STATE_SUSPENDED);
        } else if (state == STATE_RESUMING) {
            wtp.abort(ABORT_SUSPEND);
            abortAllMethods(ABORT_SUSPEND);
            s_suspend_ind(ABORT_SUSPEND);
            setState(STATE_SUSPENDED);
        }
    }

    //////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////// HELPERS
    private void abortAllMethods(short reason) {
        while( methods.size() > 0 ) {
            ((CWSPMethodManager) methods.elementAt(0)).abort(reason);
            methods.remove(0);
        }
    }

    private void abortAllPushes(short reason) {
        while( pushes.size() > 0 ) {
            ((CWSPPushManager) pushes.elementAt(0)).abort(reason);
            pushes.remove(0);
        }
    }

    /**
     * sets the state of the state machine
     * @param state the state to set
     */
    private void setState(short state) {
        if (logger.isDebugEnabled()) {
            logger.debug(states[this.state] + " >>> " + states[state]);
        }

        this.state = state;
    }

    public short getState() {
        return state;
    }

    public int getMRU() {
        return MRU;
    }

    public boolean isSuspended() {
        return isSuspended;
    }

    public short getSuspendedCode() {
        return suspendCode;
    }

    public boolean isDisonnected() {
        return isDisconnected;
    }

    public short getDisconnectCode() {
        return disconnectCode;
    }

    public CWTPSocket getWTPSocket() {
        return socket;
    }
}