status -= 0x10;
                        }
                        status = (status >> 4)*100+(status&0x0f);
                    }
                    result.setStatus(status);
                    ((IWSPUpperLayer2) upperlayer).s_methodResult_ind(result);
                    waitingResultContent.reset();
                } else {
                    waitingResult = new CWSPResult(this, headers, contentType, null);
                }
            } catch (IOException e) {
                logger.error("Oops", e);
            }
        }
    }

    public synchronized void s_methodResultData_ind(byte[] responseBody,
        boolean moreData) {
        if (version == 2) {
            try {
                waitingResultContent.write(responseBody);

                if (!moreData) {
                    waitingResultContent.flush();
                    waitingResult.setPayload(waitingResultContent.toByteArray());
                    ((IWSPUpperLayer2) upperlayer).s_methodResult_ind(waitingResult);
                    waitingResult = new CWSPResult(this, null, null, null);
                    waitingResultContent.reset();
                }
            } catch (IOException e) {
                logger.warn("IOException in s_methodResultData_ind", e);
            }
        }
    }

    /////////////////////////////////////////// from the layer below: TR-*.ind/cnf
    public void tr_process(CWTPEvent p) {
        logger.debug(CWTPEvent.types[p.getType()] + " in " + states[state]);

        switch (p.getType()) {
        case 0x03: //--------------------------------------- TR_INVOKE_CNF

            if ((session.getState() == CWSPSession.STATE_CONNECTING) ||
                    (session.getState() == CWSPSession.STATE_RESUMING)) {
                abort(CWSPSession.ABORT_PROTOERR);
            } else if (session.getState() == CWSPSession.STATE_CONNECTED) {
                if (state == STATE_REQUESTING) {
                    if (!p.getMoreData()) {
                        // entire method completed
                        setState(STATE_WAITING);
                        s_methodInvoke_cnf();
                    } else {
                        setState(STATE_REQUESTING);
                        s_methodInvoke_cnf();
                    }
                }
            }

            break;

        case 0x05: //--------------------------------------- TR_RESULT_IND

            if ((session.getState() == CWSPSession.STATE_CONNECTING) ||
                    (session.getState() == CWSPSession.STATE_RESUMING)) {
                abort(CWSPSession.ABORT_PROTOERR);
            }
            else if (session.getState() == CWSPSession.STATE_CONNECTED) {
                if (state == STATE_WAITING) {
                    try {
                        CWSPPDU pdu = CWSPPDU.getPDU(p.getUserData());

                        /*
                        if (p.getUserData().length > session.getMRU()){
                            logger.warn("over!");
                          setState(STATE_NULL);
                          wtp.abort(session.ABORT_MRUEXCEEDED);
                          s_methodAbort_ind(session.ABORT_MRUEXCEEDED);
                        }
                        else
                        */
                        if (pdu.getType() == CWSPPDU.PDU_TYPE_REPLY) {
                            CWSPReply pdu2 = (CWSPReply) pdu;

                            if (p.getMoreData()) {
                                setState(STATE_WAITING2);

                                CWTPEvent initPacket = new CWTPEvent(new byte[0],
                                        CWTPEvent.TR_RESULT_RES);

                                try {
                                    wtp.process(initPacket);
                                } catch (EWTPAbortedException e) {
                                    logger.warn("Event processing aborted", e);
                                    abort(CWSPSession.ABORT_PROTOERR);
                                }

                                s_methodResult_ind(pdu2, p.getMoreData());
                            } else {
                                setState(STATE_COMPLETING);
                                s_methodResult_ind(pdu2, p.getMoreData());
                            }
                        } else {
                            setState(STATE_NULL);
                            wtp.abort(CWSPSession.ABORT_PROTOERR);
                            s_methodAbort_ind(CWSPSession.ABORT_PROTOERR);
                        }
                    } catch (EWSPCorruptPDUException e) {
                        logger.warn("Corrupt PDU", e);
                    }
                }
            }

            break;

        case 0x0B: //--------------------------------------- TR_INVOKEDATA_CNF

            if (state == STATE_REQUESTING) {
                if (!p.getMoreData()) {
                    // entire method completed
                    setState(STATE_WAITING);
                    s_methodInvokeData_cnf();
                } else {
                    setState(STATE_REQUESTING);
                    s_methodInvokeData_cnf();
                }
            }

            break;

        case 0x0D: //--------------------------------------- TR_RESULTDATA_IND

            if (state == STATE_WAITING2) {
                // if SDU size > MRU:
                if (p.getUserData().length > session.getMRU()) {
                    setState(STATE_NULL);
                    wtp.abort(CWSPSession.ABORT_MRUEXCEEDED);
                    s_methodAbort_ind(CWSPSession.ABORT_MRUEXCEEDED);
                } else {
                    // if data fragment PDU
                    try {
                        CWSPPDU pdu = CWSPPDU.getPDU(p.getUserData());

                        if ((pdu.getType() == CWSPPDU.PDU_TYPE_DATA_FRAGMENT) &&
                                (p.getFrameBoundary() == true) &&
                                (p.getMoreData() == false)) {
                            setState(STATE_COMPLETING);

                            CWSPDataFragment pdu3 = (CWSPDataFragment) pdu;
                            s_methodInvokeData_ind(pdu3.getHeaders(),
                                pdu3.getPayload(), pdu3.getContentType(),
                                p.getMoreData());
                        }
                    }
                    // if response body
                     catch (EWSPCorruptPDUException e) {
                        if (p.getMoreData()) {
                            setState(STATE_WAITING2);

                            CWTPEvent initPacket = new CWTPEvent(new byte[0],
                                    CWTPEvent.TR_RESULTDATA_RES);

                            try {
                                wtp.process(initPacket);
                            } catch (EWTPAbortedException e2) {
                                logger.warn("Event processing aborted", e2);
                                abort(CWSPSession.ABORT_PROTOERR);
                            }

                            s_methodResultData_ind(p.getUserData(),
                                p.getMoreData());
                        } else if (p.getFrameBoundary() == false) {
                            setState(STATE_COMPLETING);
                            s_methodResultData_ind(p.getUserData(),
                                p.getMoreData());
                        }
                    }
                }
            }

            break;
        } // end of switch
    }

    /**
     * tr-abort.ind
     * used by *WTP* layer to abort
     * @param abortReason
     */
    public void tr_abort(short abortReason) {
        if ((session.getState() == CWSPSession.STATE_CONNECTING) ||
                (session.getState() == CWSPSession.STATE_CONNECTED) ||
                (session.getState() == CWSPSession.STATE_RESUMING)) {
            if (state != STATE_NULL) {
                setState(STATE_NULL);

                if (abortReason == CWSPSession.ABORT_DISCONNECT) {
                    session.disconnect();
                } else if (abortReason == CWSPSession.ABORT_SUSPEND) {
                    session.suspend();
                } else {
                    s_methodAbort_ind(abortReason);
                }
            }
        }
    }

    //////////////////////////////////////////////////////////////// pseudo events

    /**
     * used by CWSPSession - *WSP* layer
     * @param reason
     */
    public void abort(short reason) {
        if (state != STATE_NULL) {
            setState(STATE_NULL);
            wtp.abort(reason);
            s_methodAbort_ind(reason);
        }
    }

    ////////////////////////////////////////////////////////////////////// HELPERS
    private void setState(short state) {
        logger.debug(states[this.state] + " >>> " + states[state]);
        this.state = state;
    }
}