Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package test.unit.gov.nist.javax.sip.stack;
  
  
  import java.util.Iterator;
  import java.util.Timer;
 
 
 import  junit.framework.TestCase;
This test aims to test the fact when a 1xx is received with no to tag it was letting a dialog in the sip stack not being removed See Issue 178

Author(s):
Jean Deruelle
 
 public class NoToTagOn1xxDialogLeakTest extends TestCase {
 
     public static final int BALANCER_PORT = 5050;
 
     private static AddressFactory addressFactory;
 
     private static MessageFactory messageFactory;
 
     private static HeaderFactory headerFactory;
 
 
     Shootist shootist;
 
     Shootme shootme;
 
 
     public class Shootme implements SipListener {
 
         private AddressFactory addressFactory;
 
         private MessageFactory messageFactory;
 
         private HeaderFactory headerFactory;
 
         public SipStack sipStack;
 
         private static final String myAddress = "127.0.0.1";
 
         private static final int myPort = 5070;
 
         protected ServerTransaction inviteTid;
 
         private Response okResponse;
 
         private Request inviteRequest;
 
         private Dialog dialog;
 
         public static final boolean callerSendsBye = true;
 
         class MyTimerTask extends TimerTask {
             Shootme shootme;
 
             public MyTimerTask(Shootme shootme) {
                this. = shootme;
            }
            public void run() {
            	try {
            		.sendInviteOK();
            	} catch (Exception ex) {
            		ex.printStackTrace();
            	}
            }
        }
        public void processRequest(RequestEvent requestEvent) {
            Request request = requestEvent.getRequest();
            ServerTransaction serverTransactionId = requestEvent
                    .getServerTransaction();
            ..println("Shootme : \n\nRequest " + request.getMethod()
                    + " received at " + .getStackName()
                    + " with server transaction id " + serverTransactionId);
            if (request.getMethod().equals(.)) {
                processInvite(requestEventserverTransactionId);
            } else if (request.getMethod().equals(.)) {
                processAck(requestEventserverTransactionId);
            } else if (request.getMethod().equals(.)) {
                processBye(requestEventserverTransactionId);
            } else if (request.getMethod().equals(.)) {
                processCancel(requestEventserverTransactionId);
            } else {
                try {
                    serverTransactionId.sendResponse.createResponse( 202, request ) );
                    // send one back
                    SipProvider prov = (SipProviderrequestEvent.getSource();
                    Request refer = requestEvent.getDialog().createRequest("REFER");
                    requestEvent.getDialog().sendRequestprov.getNewClientTransaction(refer) );
                } catch (SipException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvalidArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (ParseException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        public void processResponse(ResponseEvent responseEvent) {
        }

        
Process the ACK request. Send the bye and complete the call flow.
        public void processAck(RequestEvent requestEvent,
                ServerTransaction serverTransaction) {
            try {
                ..println("shootme: got an ACK! ");
                ..println("Shootme : Dialog State = " + .getState());
                SipProvider provider = (SipProviderrequestEvent.getSource();
                if (!) {
                    Request byeRequest = .createRequest(.);
                    ClientTransaction ct = provider
                            .getNewClientTransaction(byeRequest);
                    .sendRequest(ct);
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }

        
Process the invite request.
        public void processInvite(RequestEvent requestEvent,
                ServerTransaction serverTransaction) {
            SipProvider sipProvider = (SipProviderrequestEvent.getSource();
            Request request = requestEvent.getRequest();
            try {
                ..println("shootme: got an Invite sending Trying");
                // System.out.println("shootme: " + request);
                Response response = .createResponse(.,
                        request);
                ServerTransaction st = requestEvent.getServerTransaction();
                if (st == null) {
                    st = sipProvider.getNewServerTransaction(request);
                }
                 = st.getDialog();
                st.sendResponse(response);
                this. = .createResponse(.,
                        request);
                Address address = .createAddress("Shootme <sip:"
                        +  + ":" +  + ">");
                ContactHeader contactHeader = 
                        .createContactHeader(address);
                response.addHeader(contactHeader);
                ToHeader toHeader = (ToHeader.getHeader(.);
                toHeader.setTag("4321"); // Application is supposed to set.
                .addHeader(contactHeader);
                this. = st;
                // Defer sending the OK to simulate the phone ringing.
                // Answered in 1 second ( this guy is fast at taking calls)
                this. = request;
                new Timer().schedule(new MyTimerTask(this), 1000);
            } catch (Exception ex) {
                ex.printStackTrace();
                System.exit(0);
            }
        }
        private void sendInviteOK() {
            try {
                if (.getState() != .) {
                    ..println("shootme: Dialog state before 200: "
                            + .getDialog().getState());
                    .sendResponse();
                    ..println("shootme: Dialog state after 200: "
                            + .getDialog().getState());
                }
            } catch (SipException ex) {
                ex.printStackTrace();
            } catch (InvalidArgumentException ex) {
                ex.printStackTrace();
            }
        }

        
Process the bye request.
        public void processBye(RequestEvent requestEvent,
                ServerTransaction serverTransactionId) {
            SipProvider sipProvider = (SipProviderrequestEvent.getSource();
            Request request = requestEvent.getRequest();
            Dialog dialog = requestEvent.getDialog();
            ..println("local party = " + dialog.getLocalParty());
            try {
                ..println("shootme:  got a bye sending OK.");
                Response response = .createResponse(200, request);
                serverTransactionId.sendResponse(response);
                ..println("Shootme : Dialog State is "
                        + serverTransactionId.getDialog().getState());
            } catch (Exception ex) {
                ex.printStackTrace();
                System.exit(0);
            }
        }
        public void processCancel(RequestEvent requestEvent,
                ServerTransaction serverTransactionId) {
            SipProvider sipProvider = (SipProviderrequestEvent.getSource();
            Request request = requestEvent.getRequest();
            try {
                ..println("shootme:  got a cancel.");
                if (serverTransactionId == null) {
                    ..println("shootme:  null tid.");
                    return;
                }
                Response response = .createResponse(200, request);
                serverTransactionId.sendResponse(response);
                if (.getState() != .) {
                    response = .createResponse(
                            .);
                    .sendResponse(response);
                }
            } catch (Exception ex) {
                ex.printStackTrace();
                System.exit(0);
            }
        }
        public void processTimeout(javax.sip.TimeoutEvent timeoutEvent) {
            Transaction transaction;
            if (timeoutEvent.isServerTransaction()) {
                transaction = timeoutEvent.getServerTransaction();
            } else {
                transaction = timeoutEvent.getClientTransaction();
            }
            ..println("Shootme : state = " + transaction.getState());
            ..println("Shootme : dialog = " + transaction.getDialog());
            ..println("Shootme : dialogState = "
                    + transaction.getDialog().getState());
            ..println("Shootme : Transaction Time out");
        }
        public void init() {
            SipFactory sipFactory = null;
             = null;
            sipFactory = SipFactory.getInstance();
            sipFactory.setPathName("gov.nist");
            Properties properties = new Properties();
            properties.setProperty("javax.sip.STACK_NAME""shootme");
            // You need 16 for logging traces. 32 for debug + traces.
            // Your code will limp at 32 but it is best for debugging.
            properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL""32");
            properties.setProperty("gov.nist.javax.sip.DEBUG_LOG",
                  "logs/"this.getClass().getName() +  ".shootmedebug.txt");
            properties.setProperty("gov.nist.javax.sip.SERVER_LOG",
                    "shootmelog.txt");
            try {
                // Create SipStack object
                 = sipFactory.createSipStack(properties);
                ..println("sipStack = " + );
            } catch (PeerUnavailableException e) {
                // could not find
                // gov.nist.jain.protocol.ip.sip.SipStackImpl
                // in the classpath
                e.printStackTrace();
                ..println(e.getMessage());
                if (e.getCause() != null)
                    e.getCause().printStackTrace();
                System.exit(0);
            }
            try {
                 = sipFactory.createHeaderFactory();
                 = sipFactory.createAddressFactory();
                 = sipFactory.createMessageFactory();
                ListeningPoint lp = .createListeningPoint("127.0.0.1",
                        "udp");
                Shootme listener = this;
                SipProvider sipProvider = .createSipProvider(lp);
                ..println("udp provider " + sipProvider);
                sipProvider.addSipListener(listener);
            } catch (Exception ex) {
                ..println(ex.getMessage());
                ex.printStackTrace();
            }
        }
        public void processIOException(IOExceptionEvent exceptionEvent) {
            ..println("Shootme : IOException");
        }
        public void processTransactionTerminated(
                TransactionTerminatedEvent transactionTerminatedEvent) {
            if (transactionTerminatedEvent.isServerTransaction())
                ..println("Shootme : Transaction terminated event recieved"
                        + transactionTerminatedEvent.getServerTransaction());
            else
                ..println("Shootme : Transaction terminated "
                        + transactionTerminatedEvent.getClientTransaction());
        }
        public void processDialogTerminated(
                DialogTerminatedEvent dialogTerminatedEvent) {
            ..println("Shootme : Dialog terminated event recieved");
            Dialog d = dialogTerminatedEvent.getDialog();
            ..println("Shootme : Local Party = " + d.getLocalParty());
             = null;
        }
    }
    public class Shootist implements SipListener {
        private SipProvider sipProvider;
        private AddressFactory addressFactory;
        private MessageFactory messageFactory;
        private HeaderFactory headerFactory;
        public SipStack sipStack;
        private ContactHeader contactHeader;
        private ListeningPoint udpListeningPoint;
        private ClientTransaction inviteTid;
        private Dialog dialog;
        private boolean byeTaskRunning;
        class ByeTask  extends TimerTask {
            Dialog dialog;
            public ByeTask(Dialog dialog)  {
                this. = dialog;
            }
            public void run () {
                try {
                   Request byeRequest = this..createRequest(.);
                   ClientTransaction ct = .getNewClientTransaction(byeRequest);
                   .sendRequest(ct);
                    = null;
                } catch (Exception ex) {
                    ex.printStackTrace();
                    
                }
            }
        }
        public void processRequest(RequestEvent requestReceivedEvent) {
            Request request = requestReceivedEvent.getRequest();
            ServerTransaction serverTransactionId = requestReceivedEvent
                    .getServerTransaction();
            ..println("Shootist : \n\nRequest " + request.getMethod()
                    + " received at " + .getStackName()
                    + " with server transaction id " + serverTransactionId);
            // We are the UAC so the only request we get is the BYE.
            if (request.getMethod().equals(.))
                processBye(requestserverTransactionId);
            else {
                try {
                    serverTransactionId.sendResponse.createResponse(202,request) );
                } catch (SipException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvalidArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (ParseException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        public void processBye(Request request,
                ServerTransaction serverTransactionId) {
            try {
                ..println("shootist:  got a bye .");
                if (serverTransactionId == null) {
                    ..println("shootist:  null TID.");
                    return;
                }
                Dialog dialog = serverTransactionId.getDialog();
                ..println("Shootist : Dialog State = " + dialog.getState());
                Response response = .createResponse(200, request);
                serverTransactionId.sendResponse(response);
                ..println("shootist:  Sending OK.");
                ..println("Shootist : Dialog State = " + dialog.getState());
            } catch (Exception ex) {
                ex.printStackTrace();
                System.exit(0);
            }
        }
           // Save the created ACK request, to respond to retransmitted 2xx
           private Request ackRequest;
        public void processResponse(ResponseEvent responseReceivedEvent) {
            ..println("Shootist : Got a response");
            Response response = (ResponseresponseReceivedEvent.getResponse();
            ClientTransaction tid = responseReceivedEvent.getClientTransaction();
            CSeqHeader cseq = (CSeqHeaderresponse.getHeader(.);
            ..println("Shootist : Response received : Status Code = "
                    + response.getStatusCode() + " " + cseq);
            if (tid == null) {
                // RFC3261: MUST respond to every 2xx
                if (!=null && !=null) {
                   ..println("Shootist : re-sending ACK");
                   try {
                      .sendAck();
                   } catch (SipException se) {
                      se.printStackTrace();
                   }
                }
                return;
            }
            // If the caller is supposed to send the bye
            if ( . && !) {
                 = true;
                new Timer().schedule(new ByeTask(), 4000) ;
            }
            ..println("Shootist : transaction state is " + tid.getState());
            ..println("Shootist : Dialog = " + tid.getDialog());
            ..println("Shootist : Dialog State is " + tid.getDialog().getState());
            try {
                if (response.getStatusCode() == .) {
                    if (cseq.getMethod().equals(.)) {
                        ..println("Shootist : Dialog after 200 OK  " + );
                        ..println("Shootist : Dialog State after 200 OK  " + .getState());
                         = .createAck( ((CSeqHeaderresponse.getHeader(.)).getSeqNumber() );
                        ..println("Shootist : Sending ACK");
                        .sendAck();
                        // JvB: test REFER, reported bug in tag handling
                        //dialog.sendRequest(  sipProvider.getNewClientTransaction( dialog.createRequest("REFER") ));
                    } else if (cseq.getMethod().equals(.)) {
                        if (.getState() == .) {
                            // oops cancel went in too late. Need to hang up the
                            // dialog.
                            .
                                    .println("Shootist : Sending BYE -- cancel went in too late !!");
                            Request byeRequest = .createRequest(.);
                            ClientTransaction ct = 
                                    .getNewClientTransaction(byeRequest);
                            .sendRequest(ct);
                        }
                    }
                }
            } catch (Exception ex) {
                ex.printStackTrace();
                System.exit(0);
            }
        }
        public void processTimeout(javax.sip.TimeoutEvent timeoutEvent) {
            ..println("Shootist : Transaction Time out");
        }
        public void sendCancel() {
            try {
                ..println("Shootist : Sending cancel");
                Request cancelRequest = .createCancel();
                ClientTransaction cancelTid = 
                        .getNewClientTransaction(cancelRequest);
                cancelTid.sendRequest();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        public void init() {
            SipFactory sipFactory = null;
             = null;
            sipFactory = SipFactory.getInstance();
            sipFactory.setPathName("gov.nist");
            Properties properties = new Properties();
            // If you want to try TCP transport change the following to
            String transport = "udp";
            String peerHostPort = "127.0.0.1:5070";
            // String peerHostPort = "230.0.0.1:5070";
            properties.setProperty("javax.sip.OUTBOUND_PROXY"peerHostPort + "/"
                    + transport);
            // If you want to use UDP then uncomment this.
            properties.setProperty("javax.sip.STACK_NAME""shootist");
            // The following properties are specific to nist-sip
            // and are not necessarily part of any other jain-sip
            // implementation.
            // You can set a max message size for tcp transport to
            // guard against denial of service attack.
            properties.setProperty("gov.nist.javax.sip.DEBUG_LOG",
                    "logs/" + this.getClass().getName() + ".shootistdebug.txt");
            properties.setProperty("gov.nist.javax.sip.SERVER_LOG",
                    "shootistlog.txt");
            // Drop the client connection after we are done with the transaction.
            properties.setProperty("gov.nist.javax.sip.CACHE_CLIENT_CONNECTIONS",
                    "false");
            // Set to 0 (or NONE) in your production code for max speed.
            // You need 16 (or TRACE) for logging traces. 32 (or DEBUG) for debug + traces.
            // Your code will limp at 32 but it is best for debugging.
            properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL""DEBUG");
            try {
                // Create SipStack object
                 = sipFactory.createSipStack(properties);
                ..println("Shootist : createSipStack " + );
            } catch (PeerUnavailableException e) {
                // could not find
                // gov.nist.jain.protocol.ip.sip.SipStackImpl
                // in the classpath
                e.printStackTrace();
                ..println(e.getMessage());
                System.exit(0);
            }
            try {
                 = sipFactory.createHeaderFactory();
                 = sipFactory.createAddressFactory();
                 = sipFactory.createMessageFactory();
                 = .createListeningPoint("127.0.0.1", 5060, "udp");
                 = .createSipProvider();
                Shootist listener = this;
                .addSipListener(listener);
                String fromName = "BigGuy";
                String fromSipAddress = "here.com";
                String fromDisplayName = "The Master Blaster";
                String toSipAddress = "there.com";
                String toUser = "LittleGuy";
                String toDisplayName = "The Little Blister";
                // create >From Header
                SipURI fromAddress = .createSipURI(fromName,
                        fromSipAddress);
                Address fromNameAddress = .createAddress(fromAddress);
                fromNameAddress.setDisplayName(fromDisplayName);
                FromHeader fromHeader = .createFromHeader(
                        fromNameAddress"12345");
                // create To Header
                SipURI toAddress = 
                        .createSipURI(toUsertoSipAddress);
                Address toNameAddress = .createAddress(toAddress);
                toNameAddress.setDisplayName(toDisplayName);
                ToHeader toHeader = .createToHeader(toNameAddress,
                        null);
                // create Request URI
                SipURI requestURI = .createSipURI(toUser,
                        peerHostPort);
                // Create ViaHeaders
                ArrayList viaHeaders = new ArrayList();
                String ipAddress = .getIPAddress();
                ViaHeader viaHeader = .createViaHeader(ipAddress,
                        .getListeningPoint(transport).getPort(),
                        transportnull);
                // add via headers
                viaHeaders.add(viaHeader);
                // Create ContentTypeHeader
                ContentTypeHeader contentTypeHeader = 
                        .createContentTypeHeader("application""sdp");
                // Create a new CallId header
                CallIdHeader callIdHeader = .getNewCallId();
                // Create a new Cseq header
                CSeqHeader cSeqHeader = .createCSeqHeader(1L,
                        .);
                // Create a new MaxForwardsHeader
                MaxForwardsHeader maxForwards = 
                        .createMaxForwardsHeader(70);
                // Create the request.
                Request request = .createRequest(requestURI,
                        .callIdHeadercSeqHeaderfromHeader,
                        toHeaderviaHeadersmaxForwards);
                // Create contact headers
                String host = "127.0.0.1";
                SipURI contactUrl = .createSipURI(fromNamehost);
                contactUrl.setPort(.getPort());
                contactUrl.setLrParam();
                // Create the contact name address.
                SipURI contactURI = .createSipURI(fromNamehost);
                contactURI.setPort(.getListeningPoint(transport)
                        .getPort());
                Address contactAddress = .createAddress(contactURI);
                // Add the contact address.
                contactAddress.setDisplayName(fromName);
                 = .createContactHeader(contactAddress);
                request.addHeader();
                // You can add extension headers of your own making
                // to the outgoing SIP request.
                // Add the extension header.
                Header extensionHeader = .createHeader("My-Header",
                        "my header value");
                request.addHeader(extensionHeader);
                String sdpData = "v=0\r\n"
                        + "o=4855 13760799956958020 13760799956958020"
                        + " IN IP4  129.6.55.78\r\n" + "s=mysession session\r\n"
                        + "p=+46 8 52018010\r\n" + "c=IN IP4  129.6.55.78\r\n"
                        + "t=0 0\r\n" + "m=audio 6022 RTP/AVP 0 4 18\r\n"
                        + "a=rtpmap:0 PCMU/8000\r\n" + "a=rtpmap:4 G723/8000\r\n"
                        + "a=rtpmap:18 G729A/8000\r\n" + "a=ptime:20\r\n";
                byte[] contents = sdpData.getBytes();
                request.setContent(contentscontentTypeHeader);
                // You can add as many extension headers as you
                // want.
                extensionHeader = .createHeader("My-Other-Header",
                        "my new header value ");
                request.addHeader(extensionHeader);
                Header callInfoHeader = .createHeader("Call-Info",
                        "<http://www.antd.nist.gov>");
                request.addHeader(callInfoHeader);
                // Create the client transaction.
                 = .getNewClientTransaction(request);
                // send the request out.
                .sendRequest();
                 = .getDialog();
            } catch (Exception ex) {
                ..println(ex.getMessage());
                ex.printStackTrace();
            }
        }
        public void processIOException(IOExceptionEvent exceptionEvent) {
            ..println("Shootist : IOException happened for "
                    + exceptionEvent.getHost() + " port = "
                    + exceptionEvent.getPort());
        }
        public void processTransactionTerminated(
                TransactionTerminatedEvent transactionTerminatedEvent) {
            ..println("Shootist : Transaction terminated event recieved");
        }
        public void processDialogTerminated(
                DialogTerminatedEvent dialogTerminatedEvent) {
            ..println("Shootist : dialogTerminatedEvent");
             = null;
        }
    }
    public static void stopSipStack(SipStack sipStackSipListener listener) {
        Iterator<SipProvidersipProviderIterator = sipStack.getSipProviders();
        try{
            while (sipProviderIterator.hasNext()) {
                SipProvider sipProvider = sipProviderIterator.next();
                ListeningPoint[] listeningPoints = sipProvider.getListeningPoints();
                for (ListeningPoint listeningPoint : listeningPoints) {
                    sipProvider.removeListeningPoint(listeningPoint);
                    sipStack.deleteListeningPoint(listeningPoint);
                    listeningPoints = sipProvider.getListeningPoints();
                }
                sipProvider.removeSipListener(listener);
                sipStack.deleteSipProvider(sipProvider);
                sipProviderIterator = sipStack.getSipProviders();
            }
        } catch (Exception e) {
            throw new IllegalStateException("Cant remove the listening points or sip providers"e);
        }
        sipStack.stop();
        sipStack = null;
    }
    public void testDialogIdentity() throws Exception {
         = new Shootist();
         = new Shootme();
        .init();
        .init();
        //should be enough to check for remaining dialogs
        Thread.sleep(20000);
    }
New to GrepCode? Check out our FAQ X