Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package test.load.leakcheck.busy;
  
  import javax.sip.*;
  import javax.sip.header.*;
  
  import java.util.*;

This class is a UAC template.

Author(s):
M. Ranganathan
 
 
 public class Shootist implements SipListener {
 
     private static SipProvider tcpProvider;
 
     private static SipProvider udpProvider;
 
     private static AddressFactory addressFactory;
 
     private static MessageFactory messageFactory;
 
     private static HeaderFactory headerFactory;
 
     private static SipStack sipStack;
 
     private int reInviteCount;
 
     private ContactHeader contactHeader;
 
     private ListeningPoint tcpListeningPoint;
 
     private ListeningPoint udpListeningPoint;
 
     private int counter;
 
     protected static final String usageString = "java "
             + "examples.shootist.Shootist \n"
             + ">>>> is your class path set to the root?";
 
     private static void usage() {
         ..println();
         System.exit(0);
 
     }
 
     private void shutDown() {
         try {
             try {
                 Thread.sleep(2000);
             } catch (InterruptedException e) {
             }
             ..println("nulling reference");
             // This will close down the stack and exit all threads
             .removeSipListener(this);
             .removeSipListener(this);
             while (true) {
                 try {
                     .deleteSipProvider();
                     .deleteSipProvider();
                     break;
                 } catch (ObjectInUseException ex) {
                     try {
                         Thread.sleep(2000);
                     } catch (InterruptedException e) {
                         continue;
                     }
                 }
             }
              = null;
              = null;
              = null;
             this. = null;
              = null;
              = null;
              = null;
             this. = null;
             this. = null;
             this. = 0;
             System.gc();
             //Redo this from the start.
             if ( < 10)
                 this.init();
             else
                 ++;
         } catch (Exception ex) {
             ex.printStackTrace();
         }
     }
 
     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);
    }
    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());
            this.shutDown();
        } catch (Exception ex) {
            ex.printStackTrace();
            System.exit(0);
        }
    }
    public void processResponse(ResponseEvent responseReceivedEvent) {
        ..println("Got a response");
        Response response = (ResponseresponseReceivedEvent.getResponse();
        Transaction tid = responseReceivedEvent.getClientTransaction();
        ..println("Response received with client transaction id "
                + tid + ":\n" + response.getStatusCode());
        if (tid == null) {
            ..println("Stray response -- dropping ");
            return;
        }
        ..println("transaction state is " + tid.getState());
        ..println("Dialog = " + tid.getDialog());
        ..println("Dialog State is " + tid.getDialog().getState());
        try {
            if (response.getStatusCode() == .
                    && ((CSeqHeaderresponse.getHeader(.))
                            .getMethod().equals(.)) {
                // Request cancel = inviteTid.createCancel();
                // ClientTransaction ct =
                //  sipProvider.getNewClientTransaction(cancel);
                // ct.sendRequest();
                Dialog dialog = tid.getDialog();
                CSeqHeader cseq = (CSeqHeaderresponse.getHeader(.);
                Request ackRequest = dialog.createAck(cseq.getSeqNumber());
                ..println("Sending ACK");
                dialog.sendAck(ackRequest);
                // Send a Re INVITE but this time force it
                // to use UDP as the transport. Else, it will
                // Use whatever transport was used to create
                // the dialog.
                if ( == 0) {
                    Request inviteRequest = dialog
                            .createRequest(.);
                    ((SipURIinviteRequest.getRequestURI())
                            .removeParameter("transport");
                    ((ViaHeaderinviteRequest.getHeader(.))
                            .setTransport("udp");
                    inviteRequest.addHeader();
                    try {
                        Thread.sleep(100);
                    } catch (Exception ex) {
                    }
                    ClientTransaction ct = 
                            .getNewClientTransaction(inviteRequest);
                    dialog.sendRequest(ct);
                    ++;
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            System.exit(0);
        }
    }
    public void processTimeout(javax.sip.TimeoutEvent timeoutEvent) {
        ..println("Transaction Time out");
    }
    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";
        properties.setProperty("javax.sip.IP_ADDRESS""127.0.0.1");
        properties.setProperty("javax.sip.OUTBOUND_PROXY"peerHostPort + "/"
                + transport);
        properties.setProperty("javax.sip.STACK_NAME""shootist");
        properties.setProperty("javax.sip.RETRANSMISSION_FILTER""on");
        // 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.MAX_MESSAGE_SIZE""1048576");
        properties.setProperty("gov.nist.javax.sip.DEBUG_LOG",
                "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 in your production code for max speed.
        // 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""0");
        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(.getIPAddress(), 5060, "udp");
            Shootist listener = this;
            .addSipListener(listener);
             = .createListeningPoint(.getIPAddress(), 5060, "tcp");
            .addSipListener(listener);
            SipProvider sipProvider = transport.equalsIgnoreCase("udp") ? 
                    : ;
            String fromName = "BigGuy";
            String fromSipAddress = "here.com";
            String fromDisplayName = "The Master Blaster";
            String toSipAddress = "there.com";
            String toUser = "LittleGuy";
            String toDisplayName = "The Little Blister";
            // send the request out.
            for (int i = 0; i < 100; i++) {
                // create >From Header
                SipURI fromAddress = .createSipURI(fromName,
                        fromSipAddress);
                Address fromNameAddress = 
                        .createAddress(fromAddress);
                fromNameAddress.setDisplayName(fromDisplayName);
                FromHeader fromHeader = .createFromHeader(
                        fromNameAddress"12345" + i);
                // create To Header
                SipURI toAddress = .createSipURI(toUser,
                        toSipAddress);
                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();
                int port = sipProvider.getListeningPoint(transport).getPort();
                ViaHeader viaHeader = .createViaHeader(
                        .getIPAddress(), porttransportnull);
                // add via headers
                viaHeaders.add(viaHeader);
                // Create ContentTypeHeader
                ContentTypeHeader contentTypeHeader = 
                        .createContentTypeHeader("application""sdp");
                // Create a new CallId header
                CallIdHeader callIdHeader = sipProvider.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 = .getIPAddress();
                SipURI contactUrl = .createSipURI(fromNamehost);
                contactUrl.setPort(.getPort());
                // Create the contact name address.
                SipURI contactURI = .createSipURI(fromNamehost);
                contactURI.setPort(sipProvider.getListeningPoint(transport).getPort());
                Address contactAddress = 
                        .createAddress(contactURI);
                // Add the contact address.
                contactAddress.setDisplayName(fromName);
                 = 
                        .createContactHeader(contactAddress);
                request.addHeader();
                // 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);
                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.
                ClientTransaction inviteTid = sipProvider
                        .getNewClientTransaction(request);
                inviteTid.sendRequest();
            }
        } catch (Exception ex) {
            ..println(ex.getMessage());
            ex.printStackTrace();
            usage();
        }
    }
    public void processIOException(IOExceptionEvent exceptionEvent) {
        ..println("IOException occured while retransmitting requests:" + exceptionEvent);
    }
    public void processTransactionTerminated(TransactionTerminatedEvent transactionTerminatedEvent) {
        ..println("Transaction Terminated event: " + transactionTerminatedEvent );
    }
    public void processDialogTerminated(DialogTerminatedEvent dialogTerminatedEvent) {
        ..println("Dialog Terminated event: " + dialogTerminatedEvent);
    }
    public static void main(String args[]) {
        new Shootist().init();
    }
New to GrepCode? Check out our FAQ X