smppdispatcher.java

Java实现的点对点短消息发送协议开发包源码

// FrontEnd Plus for JAD
// DeCompiled : smppDispatcher.class

package sms;

import java.io.*;
import java.net.Socket;
import utils.*;

// Referenced classes of package sms:
//            smppHeader, smppEncoder, Smpp, SMSException, 
//            Receiver, smppDecoder, Message, smppRequest, 
//            smppSyncResponse, smDL, AddDLResponse, DelDLResponse, 
//            smDLModification, AddMemberResponse, modDL, DelMemberResponse, 
//            viewDLresponse, Member, GetMemberResponse, Address, 
//            listDLResponse, DLName, GetDLResponse, param, 
//            ParameterResponse, queryAllResponse, messageId, ListResponse, 
//            Binding, BindResponse, SendResponse, StatusResponse, 
//            ReplaceResponse, CancelResponse, Customer, AddCustomerResponse, 
//            DelCustomerResponse, ModCustomerResponse, GetCustomerResponse, DetailsResponse, 
//            smppCommands, Errors

class smppDispatcher
    implements Runnable, smppCommands, Errors
{

    boolean debugon;
    fifo pendingRequests;
    table pendingResponses;
    InputStream in;
    Thread dispatcherThread;
    Smpp smppSender;

    private void log(String s)
    {
        if(debugon)
            System.out.println("" + Thread.currentThread() + "  DISPATCHER: " + s);
    }

    private void queryLinkRespond(int i)
    {
        smppHeader smppheader = new smppHeader();
        smppheader.command = 0x80000015;
        smppheader.status = 0;
        smppheader.length = 16;
        smppheader.sequence = i;
        smppEncoder smppencoder = new smppEncoder();
        try
        {
            smppencoder.smppHeader(smppheader);
            smppSender.write(smppencoder.getBytes(), null);
            return;
        }
        catch(encoderException encoderexception)
        {
            if(debugon)
            {
                log("Error sending query link response " + encoderexception);
                return;
            } else
            {
                return;
            }
        }
        catch(IOException _ex)
        {
            return;
        }
        catch(SMSException _ex)
        {
            return;
        }
    }

    private void receiveRespond(int i, Message message)
    {
        try
        {
            smppEncoder smppencoder = new smppEncoder();
            smppencoder.submitResponse(message);
            smppHeader smppheader = new smppHeader();
            smppheader.command = 0x80000004;
            smppheader.status = 0;
            smppheader.length = 16 + smppencoder.getBytes().length;
            smppheader.sequence = i;
            smppEncoder smppencoder1 = new smppEncoder();
            smppencoder1.smppHeader(smppheader);
            smppSender.write(smppencoder1.getBytes(), smppencoder.getBytes());
            return;
        }
        catch(Exception exception)
        {
            smppSender.receiverTarget.receive(exception, message);
        }
    }

    public void smppDispatch(int i)
        throws SMSException, decoderException, encoderException, IOException
    {
        try
        {
            smppRequest smpprequest;
            while(smpprequest.sequenceNumber != i) 
            {
                smppDecoder smppdecoder;
                smppHeader smppheader;
                do
                {
                    if(debugon)
                        log("Waiting for smpp header");
                    smppdecoder = new smppDecoder(read(16));
                    if(debugon)
                        log("Received header " + smppdecoder);
                    smppheader = smppdecoder.smppHeader();
                    if(debugon)
                        log("Header sequence number is " + smppheader.sequence);
                    if(smppheader.length > 16)
                        smppdecoder = new smppDecoder(read(smppheader.length - 16));
                    else
                        smppdecoder = null;
                    if(debugon)
                        log("Message body " + smppdecoder);
                    if(smppheader.command == 21)
                    {
                        if(smppheader.length != 16)
                            throw new SMSException(10005);
                        queryLinkRespond(smppheader.sequence);
                        continue;
                    }
                    if(smppheader.command == 4)
                    {
                        Exception exception = null;
                        if(smppSender.receiverTarget == null)
                            System.out.println("Received a message, but there is no callback");
                        else
                        if(smppdecoder != null)
                        {
                            Message message = new Message("0");
                            try
                            {
                                smppdecoder.submit(message);
                            }
                            catch(Exception exception1)
                            {
                                exception = exception1;
                                message = null;
                            }
                            if(smppSender.receiverTarget.receive(exception, message))
                                receiveRespond(smppheader.sequence, message);
                        }
                        continue;
                    }
                    if(smppheader.command == 0x80000006)
                    {
                        if(debugon)
                            log("received unbind response");
                        return;
                    }
                    smpprequest = (smppRequest)pendingRequests.peek();
                    if(smppheader.sequence < smpprequest.sequenceNumber)
                    {
                        if(debugon)
                            log("Received an old reponse");
                        continue;
                    }
                    if(smppheader.sequence <= smpprequest.sequenceNumber)
                        break;
                    if(debugon)
                        log("Received sequence is " + smppheader.sequence + " expected " + smpprequest.sequenceNumber);
                    if(debugon)
                        log("Received an invalid sequence number in a response");
                } while(true);
                pendingRequests.pop();
                SMSException smsexception;
                if(smppheader.status != 0)
                    smsexception = new SMSException(smppheader.status);
                else
                    smsexception = null;
                if(smppheader.command == 0x80000000)
                {
                    if(smppheader.status == 0)
                        smsexception = new SMSException(10007);
                    smppheader.command = smpprequest.command | 0x80000000;
                }
                try
                {
                    smppCallback(smpprequest, smppheader.command, smsexception, smppdecoder);
                }
                catch(decoderException decoderexception)
                {
                    smppCallback(smpprequest, smppheader.command, new IOException("SMPP protocol error:" + decoderexception), null);
                }
            }
            return;
        }
        catch(InterruptedException _ex)
        {
            throw new SMSException(10011);
        }
    }

    public void run()
    {
        if(debugon)
            log("started");
        try
        {
            smppDispatch(-1);
        }
        catch(Exception exception)
        {
            finishup(exception);
            return;
        }
        finishup(null);
    }

    private void finishup(Exception exception)
    {
        if(exception != null)
        {
            if(debugon)
                log("Ungraceful finish " + exception);
        } else
        if(debugon)
            log("Graceful cleanup");
        if(exception == null)
            exception = new SMSException("Unexpected shutdown");
        if(smppSender.receiverTarget != null)
        {
            Object obj;
            if(exception != null)
                obj = exception;
            else
                obj = new SMSException(10004);
            try
            {
                smppSender.receiverTarget.receive(((Exception) (obj)), null);
            }
            catch(Exception exception1)
            {
                System.out.println("Receive callback threw exception: " + exception1);
            }
        }
        smppRequest smpprequest;
        try
        {
            while((smpprequest = (smppRequest)pendingRequests.pop()) != null) 
                smppCallback(smpprequest, smpprequest.command | 0x80000000, exception, null);
        }
        catch(Exception exception2)
        {
            if(debugon)
                log("Callback cleanup failed " + exception2);
        }
        try
        {
            in.close();
            return;
        }
        catch(IOException ioexception)
        {
            if(debugon)
                log("error closing input stream - " + ioexception);
        }
    }

    void smppCallback(smppRequest smpprequest, int i, Exception exception, smppDecoder smppdecoder)
        throws decoderException
    {
        if(debugon)
            log("Callback");
        smppSyncResponse smppsyncresponse;
        if(smpprequest.thread != null)
        {
            if(debugon)
                log("synch callback");
            smppsyncresponse = new smppSyncResponse();
            smppsyncresponse.returns = null;
            smppsyncresponse.exception = exception;
        } else
        {
            if(debugon)
                log("async callback");
            smppsyncresponse = null;
        }
        int j = 0;
        do
            try