registerprocessing.java

openfire 服务器源码下载

                        .createUserAgentHeader(userAgentList);
            }
            catch (ParseException ex) {
                // throw was missing - reported by Eero Vaarnas
                throw new CommunicationsException(
                        "Could not create a To header " + "for address:"
                                + fromHeader.getAddress(), ex);
            }
            // Via Headers
            ArrayList viaHeaders = sipManCallback.getLocalViaHeaders();
            // MaxForwardsHeader
            MaxForwardsHeader maxForwardsHeader = sipManCallback
                    .getMaxForwardsHeader();
            // Request
            Request request = null;
            try {
                request = sipManCallback.messageFactory.createRequest(
                        requestURI, Request.REGISTER, callIdHeader, cSeqHeader,
                        fromHeader, toHeader, viaHeaders, maxForwardsHeader);
                request.setHeader(uaHeader);
            }
            catch (ParseException ex) {

                // throw was missing - reported by Eero Vaarnas
                throw new CommunicationsException(
                        "Could not create the register request!", ex);
            }
            // Expires Header
            ExpiresHeader expHeader = null;
            for (int retry = 0; retry < 2; retry++) {
                try {
                    expHeader = sipManCallback.headerFactory
                            .createExpiresHeader(expires);
                }
                catch (InvalidArgumentException ex) {
                    if (retry == 0) {
                        expires = 3600;
                        continue;
                    }
                    throw new CommunicationsException(
                            "Invalid registrations expiration parameter - "
                                    + expires, ex);
                }
            }
            request.addHeader(expHeader);
            // Contact Header should contain IP - bug report - Eero Vaarnas
            ContactHeader contactHeader = sipManCallback
                    .getRegistrationContactHeader();
            request.addHeader(contactHeader);
            // Transaction
            ClientTransaction regTrans = null;
            try {
                regTrans = sipManCallback.sipProvider
                        .getNewClientTransaction(request);
            }
            catch (TransactionUnavailableException ex) {
                // throw was missing - reported by Eero Vaarnas
                throw new CommunicationsException(
                        "Could not create a register transaction!\n"
                                + "Check that the Registrar address is correct!");
            }
            try {
                regTrans.sendRequest();
            }
            // we sometimes get a null pointer exception here so catch them all
            catch (Exception ex) {

                // throw was missing - reported by Eero Vaarnas
                throw new CommunicationsException(
                        "Could not send out the register request!", ex);
            }
            this.registerRequest = request;
        }
        catch (Exception e) {
            Log.error("register", e);
        }
    }

    /**
     * Synchronize because of timer tasks
     *
     * @throws CommunicationsException
     */
    synchronized void unregister() throws CommunicationsException {
        try {

            Log.debug("UNREGISTER");

            cancelPendingRegistrations();
            isRegistered = false;
            isUnregistering = true;

            Request registerRequest = getRegisterRequest();
            if (this.registerRequest == null) {

                throw new CommunicationsException(
                        "Couldn't find the initial register request");
            }
            Request unregisterRequest = (Request) registerRequest.clone();
            try {
                unregisterRequest.getExpires().setExpires(0);
                CSeqHeader cSeqHeader = (CSeqHeader) unregisterRequest
                        .getHeader(CSeqHeader.NAME);
                // [issue 1] - increment registration cseq number
                // reported by - Roberto Tealdi <[e-mail]>
                cSeqHeader
                        .setSequenceNumber(cSeqHeader.getSequenceNumber() + 1);

            }
            catch (InvalidArgumentException ex) {

                // Shouldn't happen
                throw new CommunicationsException(
                        "Unable to set Expires Header", ex);
            }
            ClientTransaction unregisterTransaction = null;
            try {
                unregisterTransaction = sipManCallback.sipProvider
                        .getNewClientTransaction(unregisterRequest);
            }
            catch (TransactionUnavailableException ex) {

                throw new CommunicationsException(
                        "Unable to create a unregister transaction", ex);
            }
            try {
                sipManCallback
                        .fireUnregistering(sipManCallback.currentlyUsedURI);
                unregisterTransaction.sendRequest();
            }
            catch (SipException ex) {

                throw new CommunicationsException(
                        "Failed to send unregister request", ex);
            }
        }
        catch (Exception e) {

            Log.error("unregister", e);

        }
    }

    public void cancelSchedules() {

        if (reRegisterTimer != null)
            reRegisterTimer.cancel();
        if (keepAliveTimer != null)
            keepAliveTimer.cancel();

        reRegisterTimer = null;
        keepAliveTimer = null;

    }

    /**
     * @return
     */
    boolean isRegistered() {
        return isRegistered;
    }

    /**
     * @return Returns the registerRequest.
     */
    private Request getRegisterRequest() {
        return registerRequest;
    }

    private class ReRegisterTask extends TimerTask {
        String registrarAddress = null;

        int registrarPort = -1;

        String transport = null;

        int expires = 0;

        public ReRegisterTask(String registrarAddress, int registrarPort,
                              String registrarTransport, int expires) {
            this.registrarAddress = registrarAddress;
            this.registrarPort = registrarPort;

            // don't do this.transport = transport ;)
            // bug report and fix by Willem Romijn (romijn at lucent.com)
            this.transport = registrarTransport;
            this.expires = expires;
        }

        public void run() {
            try {
                if (isRegistered())
                    register(registrarAddress, registrarPort, transport,
                            expires);
            }
            catch (CommunicationsException ex) {
                sipManCallback
                        .fireCommunicationsError(new CommunicationsException(
                                "Failed to reRegister", ex));
            }
        }
    }

    private void cancelPendingRegistrations() {
        try {

            if (reRegisterTimer != null)
                reRegisterTimer.cancel();
            if (keepAliveTimer != null)
                keepAliveTimer.cancel();

            reRegisterTimer = null;
            keepAliveTimer = null;

            // reRegisterTimer = new Timer();
            // keepAliveTimer = new Timer();

        }
        catch (Exception e) {
            Log.error("cancelPendingRegistrations", e);
        }
    }

    private void scheduleReRegistration(String registrarAddress,
                                        int registrarPort, String registrarTransport, int expires) {

        ReRegisterTask reRegisterTask = new ReRegisterTask(
                registrarAddress, registrarPort, registrarTransport,
                expires);

        // java.util.Timer thinks in miliseconds
        // bug report and fix by Willem Romijn (romijn at lucent.com)
        // We keep a margin of 10% when sending re-registrations (1000
        // becomes 900)
        expires = expires * 900;

        reRegisterTimer.schedule(reRegisterTask, expires);

    }
}