Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   package test.unit.gov.nist.javax.sip.stack;
   
   
   import java.io.IOException;
  import java.util.Timer;
  
  import javax.sip.Dialog;
  
  import  junit.framework.TestCase;
This test aims to test jain sip failover recovery. Shootist on port 5060 shoots at a stateless proxy on prt 5050 (scaled down version of a balancer) Stateless proxy redirect to Shootme on port 5070 on ACK, the Shootme stop itself and start the other shootme node on port 5080 and pass to him its current dialogs on BYE or other in-dialog requests, the stateless proxy forwards to recovery shootme on port 5080 Shootme recovery sends OK to BYE.

Author(s):
Jean Deruelle
  
  public class SimpleDialogRecoveryTest 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;
  
  
      Balancer balancer;
  
      class Balancer implements SipListener {
  
          private String myHost;
  
          private int myPort;
  
          private SipStack sipStack;
  
          private SipProvider sipProvider;
  
         public Balancer(String hostint port) {
             this. = host;
             this. = port;
         }
 
         public void start() throws IllegalStateException {
 
             SipFactory sipFactory = null;
              = null;
 
             Properties properties = new Properties();
             properties.setProperty("javax.sip.RETRANSMISSION_FILTER""true");
             properties.setProperty("javax.sip.STACK_NAME""StatelessForwarder");
             properties.setProperty("javax.sip.AUTOMATIC_DIALOG_SUPPORT""off");
             // 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/statelessforwarderdebug.txt");
             properties.setProperty("gov.nist.javax.sip.SERVER_LOG""logs/statelessforwarderlog.xml");
 
             try {
                 // Create SipStack object
                 sipFactory = SipFactory.getInstance();
                 sipFactory.setPathName("gov.nist");
                  = sipFactory.createSipStack(properties);
 
                  = sipFactory.createHeaderFactory();
                  = sipFactory.createAddressFactory();
                  = sipFactory.createMessageFactory();
 
                 ListeningPoint lp = .createListeningPoint(.);
                  = .createSipProvider(lp);
                 .addSipListener(this);
 
                 .start();
             } catch (Exception ex) {
                 throw new IllegalStateException("Cant create sip objects and lps due to["+ex.getMessage()+"]"ex);
             }
         }
 
         public void processDialogTerminated(
                 DialogTerminatedEvent dialogTerminatedEvent) {
             // TODO Auto-generated method stub
 
         }
 
         public void processIOException(IOExceptionEvent exceptionEvent) {
             // TODO Auto-generated method stub
 
         }
 
         public void processRequest(RequestEvent requestEvent) {
             try {
                 Request request = requestEvent.getRequest();
 
                 ViaHeader viaHeader = .createViaHeader(
                         this.this.."z9hG4bK"+Math.random()*31+""+System.currentTimeMillis());
                 //Decreasing the Max Forward Header
                 MaxForwardsHeader maxForwardsHeader = (MaxForwardsHeaderrequest.getHeader(.);
                 if (maxForwardsHeader == null) {
                     maxForwardsHeader = .createMaxForwardsHeader(70);
                     request.addHeader(maxForwardsHeader);
                 } else {
                     maxForwardsHeader.setMaxForwards(maxForwardsHeader.getMaxForwards() - 1);
                 }
                 // Add the via header to the top of the header list.
                 request.addHeader(viaHeader);
                 //Removing first routeHeader if it is for us
                 RouteHeader routeHeader = (RouteHeaderrequest.getHeader(.);
                 if(routeHeader != null) {
                     SipURI routeUri = (SipURI)routeHeader.getAddress().getURI();
                     if(routeUri.getHost().equalsIgnoreCase() && routeUri.getPort() == ) {
                         request.removeFirst(.);
                     }
                 }
 
                 // Record route the invite so the bye comes to me.
                 if (request.getMethod().equals(.) || request.getMethod().equals(.)) {
                     SipURI sipUri = 
                             .createSipURI(null.getListeningPoint(
                                     .).getIPAddress());
                     sipUri.setPort(.getListeningPoint(.).getPort());
                     //See RFC 3261 19.1.1 for lr parameter
                     sipUri.setLrParam();
                     Address address = .createAddress(sipUri);
                     address.setURI(sipUri);
                     RecordRouteHeader recordRoute = 
                             .createRecordRouteHeader(address);
                     request.addHeader(recordRoute);
 
                     //Adding Route Header
                     SipURI routeSipUri = 
                         .createSipURI(null"127.0.0.1");
                     routeSipUri.setPort(5070);
                     routeSipUri.setLrParam();
                     RouteHeader route = .createRouteHeader(.createAddress(routeSipUri));
                     request.addFirst(route);
                 }
                 else if (!..equals(request.getMethod())) {
                     //Adding Route Header
                     if(((SipURI)request.getRequestURI()).getPort() == 5070) {
                         SipURI routeSipUri = 
                             .createSipURI(null"127.0.0.1");
                         routeSipUri.setPort(5080);
                         routeSipUri.setLrParam();
                         RouteHeader route = .createRouteHeader(.createAddress(routeSipUri));
                         request.addFirst(route);
                     }
                 }
                 //sending request
                 .sendRequest(request);
             } catch (Exception ex) {
                 ex.printStackTrace();
             }
         }
 
         public void processResponse(ResponseEvent responseEvent) {
             try {
                 Response response = responseEvent.getResponse();
                 SipProvider sender=null;
 
                  // Topmost via header is me. As it is reposne to external reqeust
                 response.removeFirst(.);
 
                 sender=this.;
                 sender.sendResponse(response);
             } catch (Exception ex) {
                 ex.printStackTrace();
             }
         }
 
         public void processTimeout(TimeoutEvent timeoutEvent) {
             // TODO Auto-generated method stub
 
         }
 
         public void processTransactionTerminated(
                 TransactionTerminatedEvent transactionTerminatedEvent) {
             // TODO Auto-generated method stub
 
         }
 
     }
 
     class Shootme implements SipListener {
 
 
         private SipStack sipStack;
 
         private static final String myAddress = "127.0.0.1";
 
         private String stackName;
 
         public int myPort = 5070;
 
         protected ServerTransaction inviteTid;
 
         private Response okResponse;
 
         private Request inviteRequest;
 
         private Dialog dialog;
 
         public boolean callerSendsBye = true;
 
         private  SipProvider sipProvider;
 
         private boolean byeTaskRunning;
 
         public Shootme(String stackNameint myPortboolean callerSendsBye) {
             this. = stackName;
             this. = myPort;
             this. = callerSendsBye;
         }
 
         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);
                 } catch (Exception ex) {
                     ex.printStackTrace();
                     fail("Unexpected exception ");
                 }
 
             }
 
         }
 
         class MyTimerTask extends TimerTask {
             Shootme shootme;
 
             public MyTimerTask(Shootme shootme) {
                 this. = shootme;
 
             }
 
             public void run() {
                 .sendInviteOK();
             }
 
         }
 
         protected static final String usageString = "java "
                 + "examples.shootist.Shootist \n"
                 + ">>>> is your class path set to the root?";
 
 
 
         public void processRequest(RequestEvent requestEvent) {
             Request request = requestEvent.getRequest();
             ServerTransaction serverTransactionId = requestEvent
                     .getServerTransaction();
 
             ..println("\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("Dialog State = " + .getState());
                 SipProvider provider = (SipProviderrequestEvent.getSource();
                 //stopping the node and starting the recovery
                 Collection<Dialogdialogs=((SipStackImpl)).getDialogs(.);
                 stop();
                 .init(dialogs);
 
                 //if (!callerSendsBye && !byeTaskRunning) {
                     //byeTaskRunning = true;
                     //new Timer().schedule(new ByeTask(dialog), 4000) ;
                 //}
             } 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("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("state = " + transaction.getState());
             ..println("dialog = " + transaction.getDialog());
             ..println("dialogState = "
                     + transaction.getDialog().getState());
             ..println("Transaction Time out");
         }
 
         public void init(Collection<Dialogdialogs) {
             SipFactory sipFactory = null;
              = null;
             sipFactory = SipFactory.getInstance();
             sipFactory.setPathName("gov.nist");
             Properties properties = new Properties();
             properties.setProperty("javax.sip.STACK_NAME");
             //properties.setProperty("javax.sip.OUTBOUND_PROXY", Integer
             //                .toString(BALANCER_PORT));
             // 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/" +
                      + "debug.txt");
             properties.setProperty("gov.nist.javax.sip.SERVER_LOG""logs/" +
                      + "log.xml");
 
             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(,
                         .);
 
                 Shootme listener = this;
 
                  = .createSipProvider(lp);
                 ..println("udp provider " + );
                 .addSipListener(listener);
                 if(dialogs != null) {
                     Collection<DialogserializedDialogs = simulateDialogSerialization(dialogs);
                     for (Dialog dialog : serializedDialogs) {
                         ((SIPDialog)dialog).setSipProvider((SipProviderImpl));
                         ((SipStackImpl)).putDialog((SIPDialog)dialog);
                     }
                     this. = (SIPDialog)serializedDialogs.iterator().next();
                 }
                 if(! && this. != null) {
                     try {
                        Request byeRequest = this..createRequest(.);
                        ClientTransaction ct = .getNewClientTransaction(byeRequest);
                        ..println("sending BYE " + byeRequest);
                        .sendRequest(ct);
                     } catch (Exception ex) {
                         ex.printStackTrace();
                         fail("Unexpected exception ");
                     }
                 }
             } catch (Exception ex) {
                 ..println(ex.getMessage());
                 ex.printStackTrace();
                 fail("Unexpected exception");
             }
         }
 
 
         private Collection<DialogsimulateDialogSerialization(
                 Collection<Dialogdialogs) {
             Collection<DialogserializedDialogs = new ArrayList<Dialog>();
             for (Dialog dialog : dialogs) {
                 try{
                     ByteArrayOutputStream baos = new ByteArrayOutputStream();
                     ObjectOutputStream out = new ObjectOutputStream(baos);
                     out.writeObject(dialog);
                     ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
                     ObjectInputStream in =new ObjectInputStream(bais);
                     SIPDialog serializedDialog = (SIPDialog)in.readObject();
                     serializedDialogs.add(serializedDialog);
                     out.close();
                     in.close();
                     baos.close();
                     bais.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 } catch (ClassNotFoundException e) {
                     e.printStackTrace();
                 }
             }
             return serializedDialogs;
         }
 
         public void processIOException(IOExceptionEvent exceptionEvent) {
             ..println("IOException");
 
         }
 
         public void processTransactionTerminated(
                 TransactionTerminatedEvent transactionTerminatedEvent) {
             if (transactionTerminatedEvent.isServerTransaction())
                 ..println("Transaction terminated event recieved"
                         + transactionTerminatedEvent.getServerTransaction());
             else
                 ..println("Transaction terminated "
                         + transactionTerminatedEvent.getClientTransaction());
 
         }
 
         public void processDialogTerminated(
                 DialogTerminatedEvent dialogTerminatedEvent) {
             ..println("Dialog terminated event recieved");
             Dialog d = dialogTerminatedEvent.getDialog();
             ..println("Local Party = " + d.getLocalParty());
 
         }
 
         public void stop() {
             stopSipStack(this);
         }
 
     }
     class Shootist implements SipListener {
 
         private  SipProvider sipProvider;
 
         private SipStack sipStack;
 
         private ContactHeader contactHeader;
 
         private ListeningPoint udpListeningPoint;
 
         private ClientTransaction inviteTid;
 
         private Dialog dialog;
 
         private boolean byeTaskRunning;
 
         public boolean callerSendsBye = true;
 
         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);
                 } catch (Exception ex) {
                     ex.printStackTrace();
                     fail("Unexpected exception ");
                 }
 
             }
 
         }
 
         public Shootist(boolean callerSendsBye) {
             this. = callerSendsBye;
         }
 
         public void processRequest(RequestEvent requestReceivedEvent) {
             Request request = requestReceivedEvent.getRequest();
             ServerTransaction serverTransactionId = requestReceivedEvent
                     .getServerTransaction();
 
             ..println("\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 (Exception e) {
                     e.printStackTrace();
                     fail("Unxepcted exception ");
                 }
             }
 
         }
 
         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("Dialog State = " + dialog.getState());
                 Response response = .createResponse(200, request);
                 serverTransactionId.sendResponse(response);
                 ..println("shootist:  Sending OK.");
                 ..println("Dialog State = " + dialog.getState());
 
             } catch (Exception ex) {
                 fail("Unexpected exception");
 
             }
         }
 
            // Save the created ACK request, to respond to retransmitted 2xx
            private Request ackRequest;
 
         public void processResponse(ResponseEvent responseReceivedEvent) {
             ..println("Got a response");
             Response response = (ResponseresponseReceivedEvent.getResponse();
             ClientTransaction tid = responseReceivedEvent.getClientTransaction();
             CSeqHeader cseq = (CSeqHeaderresponse.getHeader(.);
 
             ..println("Response received : Status Code = "
                     + response.getStatusCode() + " " + cseq);
 
 
             if (tid == null) {
 
                 // RFC3261: MUST respond to every 2xx
                 if (!=null && !=null) {
                    ..println("re-sending ACK");
                    try {
                       .sendAck();
                    } catch (SipException se) {
                       se.printStackTrace();
                       fail("Unxpected exception ");
                    }
                 }
                 return;
             }
             // If the caller is supposed to send the bye
             if (  && !) {
                  = true;
                 new Timer().schedule(new ByeTask(), 4000) ;
             }
             ..println("transaction state is " + tid.getState());
             ..println("Dialog = " + tid.getDialog());
             ..println("Dialog State is " + tid.getDialog().getState());
 
             assertSame("Checking dialog identity",tid.getDialog(), this.);
 
             try {
                 if (response.getStatusCode() == .) {
                     if (cseq.getMethod().equals(.)) {
                         ..println("Dialog after 200 OK  " + );
                         ..println("Dialog State after 200 OK  " + .getState());
                         Request ackRequest = .createAck(cseq.getSeqNumber());
                         ..println("Sending ACK");
                         .sendAck(ackRequest);
 
                         // JvB: test REFER, reported bug in tag handling
 //                      Request referRequest = dialog.createRequest("REFER");
 //                      //simulating a balancer that will forward the request to the recovery node
 //                      SipURI referRequestURI = addressFactory.createSipURI(null, "127.0.0.1:5080");
 //                      referRequest.setRequestURI(referRequestURI);
 //                      dialog.sendRequest(  sipProvider.getNewClientTransaction(referRequest));
 //
                     } else if (cseq.getMethod().equals(.)) {
                         if (.getState() == .) {
                             // oops cancel went in too late. Need to hang up the
                             // dialog.
                             .
                                     .println("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("Transaction Time out");
         }
 
         public void sendCancel() {
             try {
                 ..println("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:" + ;
             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/shootistdebug.txt");
             properties.setProperty("gov.nist.javax.sip.SERVER_LOG",
                     "logs/shootistlog.xml");
 
             // 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("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();
                 fail("Unxpected exception ");
             }
         }
 
 
 
         public void