Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package examples.authorization;
  
  import javax.sip.*;
  import javax.sip.header.*;
  import java.util.*;
This class is a UAC template. Shootist is the guy that shoots and shootme is the guy that gets shot.

Author(s):
M. Ranganathan
Kathleen McCallum
 
 
 public class ShootistAuth implements SipListener {
 
     private static SipProvider sipProvider;
     private static AddressFactory addressFactory;
     private static MessageFactory messageFactory;
     private static HeaderFactory headerFactory;
     private static SipStack sipStack;
     private ContactHeader contactHeader;
     private ListeningPoint udpListeningPoint;
     private ClientTransaction inviteTid;
     private Dialog dialog;
     long invco = 1;
     String peerHostPort = "127.0.0.1:5070";
     String transport = "udp";
     String USER_AUTH = "auth";
     String PASS_AUTH = "pass";
     String realm = "nist.gov";
 
     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());
 
         } catch (Exception ex) {
             ex.printStackTrace();
             System.exit(0);
 
         }
     }
 
     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) {
             ..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() == .) {
                 if (cseq.getMethod().equals(.)) {
                     Dialog dialog = .getDialog();
                     Request ackRequest = dialog.createAckcseq.getSeqNumber() );
                     ..println("Sending ACK");
                     dialog.sendAck(ackRequest);
                 } 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);
                    }
                }
            } else if (response.getStatusCode() == .
                    || response.getStatusCode() == .) {
                URI uriReq = tid.getRequest().getRequestURI();
                Request authrequest = this.processResponseAuthorization(
                        responseuriReq);
                 = .getNewClientTransaction(authrequest);
                .sendRequest();
                .
                        .println("INVITE AUTHORIZATION sent:\n" + authrequest);
                ++;
            }
        } 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 Request processResponseAuthorization(Response responseURI uriReq) {
        Request requestauth = null;
        try {
            ..println("processResponseAuthorization()");
            String schema = ((ProxyAuthenticate) (response
                    .getHeader(.))).getScheme();
            String nonce = ((ProxyAuthenticate) (response
                    .getHeader(.))).getNonce();
            ProxyAuthorizationHeader proxyAuthheader = 
                    .createProxyAuthorizationHeader(schema);
            proxyAuthheader.setRealm();
            proxyAuthheader.setNonce(nonce);
            proxyAuthheader.setAlgorithm("MD5");
            proxyAuthheader.setUsername();
            proxyAuthheader.setURI(uriReq);
            DigestClientAuthenticationMethod digest = new DigestClientAuthenticationMethod();
            String callId = ((CallIdHeaderresponse
                    .getHeader(.)).getCallId();
            requestauth = this.createInvite(callId);
            digest.initialize(uriReq.toString(), nonce,
                    , ((CSeqHeaderresponse
                            .getHeader(.)).getMethod(), null,
                    "MD5");
            ..println("Proxy Response antes de modificarlo : "
                    + proxyAuthheader.getResponse());
            String respuestaM = digest.generateResponse();
            proxyAuthheader.setResponse(respuestaM);
            requestauth.addHeader(proxyAuthheader);
        } catch (ParseException pa) {
            .
                    .println("processResponseAuthorization() ParseException:");
            ..println(pa.getMessage());
            pa.printStackTrace();
        } catch (Exception ex) {
            ..println("processResponseAuthorization() Exception:");
            ..println(ex.getMessage());
            ex.printStackTrace();
        }
        return requestauth;
    }
    public Request createInvite(String callIdthrows ParseException,
            InvalidArgumentException {
        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(toNameAddressnull);
        // create Request URI
        SipURI requestURI = .createSipURI(toUser);
        // Create ViaHeaders
        ArrayList<ViaHeaderviaHeaders = new ArrayList<ViaHeader>();
        ViaHeader viaHeader = .createViaHeader("127.0.0.1",
                .getListeningPoint().getPort(), ,
                null);
        // add via headers
        viaHeaders.add(viaHeader);
        // Create ContentTypeHeader
        ContentTypeHeader contentTypeHeader = 
                .createContentTypeHeader("application""sdp");
        // Create a new CallId header
        CallIdHeader callIdHeader;
        callIdHeader = .getNewCallId();
        if (callId.trim().length() > 0)
            callIdHeader.setCallId(callId);
        // Create a new Cseq header
        CSeqHeader cSeqHeader = .createCSeqHeader(,
                .);
        // Create a new MaxForwardsHeader
        MaxForwardsHeader maxForwards = 
                .createMaxForwardsHeader(70);
        // Create the request.
        Request request = .createRequest(requestURI,
                .callIdHeadercSeqHeaderfromHeadertoHeader,
                viaHeadersmaxForwards);
        // Create contact headers
        String host = "127.0.0.1";
        SipURI contactUrl = .createSipURI(fromNamehost);
        contactUrl.setPort(.getPort());
        // Create the contact name address.
        SipURI contactURI = .createSipURI(fromNamehost);
        contactURI.setPort(.getListeningPoint().getPort());
        Address contactAddress = .createAddress(contactURI);
        // Add the contact address.
        contactAddress.setDisplayName(fromName);
         = .createContactHeader(contactAddress);
        request.addHeader();
        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);
        Header callInfoHeader = .createHeader("Call-Info",
                "<http://www.antd.nist.gov>");
        request.addHeader(callInfoHeader);
        return request;
    }
    public void init() {
        SipFactory sipFactory = null;
         = null;
        sipFactory = SipFactory.getInstance();
        sipFactory.setPathName("gov.nist");
        Properties properties = new Properties();
        properties.setProperty("javax.sip.OUTBOUND_PROXY" + "/"
                + );
        properties.setProperty("javax.sip.STACK_NAME""shootistAuth");
        properties
                .setProperty("gov.nist.javax.sip.MAX_MESSAGE_SIZE""1048576");
        properties.setProperty("gov.nist.javax.sip.DEBUG_LOG",
                "shootistAuthdebug.txt");
        properties.setProperty("gov.nist.javax.sip.SERVER_LOG",
                "shootistAuthlog.txt");
        properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL""16");
        // Drop the client connection after we are done with the transaction.
        properties.setProperty("gov.nist.javax.sip.CACHE_CLIENT_CONNECTIONS",
                "false");
        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");
            ShootistAuth listener = this;
            .addSipListener(listener);
        } catch (PeerUnavailableException e) {
            e.printStackTrace();
            ..println(e.getMessage());
            System.exit(0);
        } catch (Exception e) {
            ..println("Creating Listener Points");
            ..println(e.getMessage());
            e.printStackTrace();
        }
        try {
            ..println("ShootistAuth Process ");
            Request request = this.createInvite("");
            // Create the client transaction.
             = .getNewClientTransaction(request);
            // send the request out.
            .sendRequest();
            .
                    .println("INVITE with no Authorization sent:\n" + request);
             = .getDialog();
        } catch (Exception e) {
            ..println("Creating call CreateInvite()");
            ..println(e.getMessage());
            e.printStackTrace();
        }
    }
    public static void main(String args[]) {
        new ShootistAuth().init();
    }
    public void processIOException(IOExceptionEvent exceptionEvent) {
        ..println("IOException happened for "
                + exceptionEvent.getHost() + " port = "
                + exceptionEvent.getPort());
    }
    public void processTransactionTerminated(
            TransactionTerminatedEvent transactionTerminatedEvent) {
        ..println("Transaction terminated event recieved");
    }
    public void processDialogTerminated(
            DialogTerminatedEvent dialogTerminatedEvent) {
        ..println("dialogTerminatedEvent");
    }
New to GrepCode? Check out our FAQ X