package test.load.subsnotify;
import java.util.ArrayList;
import java.util.Properties;
import java.util.Random;
import javax.sip.ClientTransaction;
import javax.sip.Dialog;
import javax.sip.DialogTerminatedEvent;
import javax.sip.IOExceptionEvent;
import javax.sip.ListeningPoint;
import javax.sip.PeerUnavailableException;
import javax.sip.RequestEvent;
import javax.sip.ResponseEvent;
import javax.sip.ServerTransaction;
import javax.sip.SipFactory;
import javax.sip.SipListener;
import javax.sip.SipProvider;
import javax.sip.SipStack;
import javax.sip.TransactionTerminatedEvent;
import javax.sip.address.Address;
import javax.sip.address.AddressFactory;
import javax.sip.address.SipURI;
import javax.sip.header.CSeqHeader;
import javax.sip.header.CallIdHeader;
import javax.sip.header.ContactHeader;
import javax.sip.header.ContentTypeHeader;
import javax.sip.header.EventHeader;
import javax.sip.header.ExpiresHeader;
import javax.sip.header.FromHeader;
import javax.sip.header.HeaderFactory;
import javax.sip.header.MaxForwardsHeader;
import javax.sip.header.ToHeader;
import javax.sip.header.ViaHeader;
import javax.sip.message.MessageFactory;
import javax.sip.message.Request;
import javax.sip.message.Response;
/**
* This class is a UAC template.
*
* @author M. Ranganathan
*/
public class Subscriber 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 SipFactory sipFactory = null;
private int seq_num = 1;
protected static final String usageString = "java "
+ "examples.subscriber.Shootist \n"
+ ">>>> is your class path set to the root?";
private static void usage() {
System.out.println(usageString);
System.exit(0);
}
public void processRequest(RequestEvent requestReceivedEvent) {
Request request = requestReceivedEvent.getRequest();
ServerTransaction serverTransactionId = requestReceivedEvent
.getServerTransaction();
System.out.println("\n\nRequest " + request.getMethod()
+ " received at " + sipStack.getStackName()
+ " with server transaction id " + serverTransactionId);
// We are the UAC so the only request we get is the BYE.
if (request.getMethod().equals(Request.NOTIFY))
processNotify(request, serverTransactionId);
}
public void processNotify(Request request,
ServerTransaction serverTransactionId) {
try {
System.out.println("subsciber: got a notify .");
if (serverTransactionId == null) {
System.out.println("subsciber: null TID.");
return;
}
Dialog dialog = serverTransactionId.getDialog();
System.out.println("Dialog State = " + dialog.getState());
Response response = messageFactory.createResponse(200, request);
serverTransactionId.sendResponse(response);
System.out.println("subsciber: Sending OK.");
System.out.println("Dialog State = " + dialog.getState());
// Unsubscribe to the Subscription. Note that if you do not unsubscribe the dialog will
// live on and eventually you will run out of memory.
Request unsub = dialog.createRequest(Request.SUBSCRIBE);
ExpiresHeader expiresHeader = headerFactory
.createExpiresHeader(0);
unsub.addHeader(expiresHeader);
EventHeader eventHeader = null;
eventHeader = headerFactory.createEventHeader("reg");
unsub.addHeader(eventHeader);
ClientTransaction ct = sipProvider.getNewClientTransaction(unsub);
ct.sendRequest();
dialog.delete();
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
public void processResponse(ResponseEvent responseReceivedEvent) {
System.out.println("Got a response");
Response response = (Response) responseReceivedEvent.getResponse();
ClientTransaction tid = responseReceivedEvent.getClientTransaction();
CSeqHeader cseq = (CSeqHeader) response.getHeader(CSeqHeader.NAME);
System.out.println("Response received : Status Code = "
+ response.getStatusCode() + " " + cseq);
if (tid == null) {
System.out.println("Stray response -- dropping ");
return;
}
System.out.println("transaction state is " + tid.getState());
System.out.println("Dialog = " + tid.getDialog());
System.out.println("Dialog State is " + tid.getDialog().getState());
// responses are OKs for SUBSCRIBE. Do nothing
}
public void processTimeout(javax.sip.TimeoutEvent timeoutEvent) {
System.out.println("Transaction Time out");
}
public void init() {
sipStack = 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.OUTBOUND_PROXY", peerHostPort + "/"
+ transport);
// If you want to use UDP then uncomment this.
properties.setProperty("javax.sip.STACK_NAME", "subscriber");
// 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",
"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", "NONE");
properties.setProperty("gov.nist.javax.sip.MAX_LISTENER_RESPONSE_TIME",
"20");
try {
// Create SipStack object
sipStack = sipFactory.createSipStack(properties);
System.out.println("createSipStack " + sipStack);
} catch (PeerUnavailableException e) {
// could not find
// gov.nist.jain.protocol.ip.sip.SipStackImpl
// in the classpath
e.printStackTrace();
System.err.println(e.getMessage());
System.exit(0);
}
try {
headerFactory = sipFactory.createHeaderFactory();
addressFactory = sipFactory.createAddressFactory();
messageFactory = sipFactory.createMessageFactory();
udpListeningPoint = sipStack.createListeningPoint("127.0.0.1",
5060, "udp");
sipProvider = sipStack.createSipProvider(udpListeningPoint);
Subscriber listener = this;
sipProvider.addSipListener(listener);
// Now we want to start sending out subscribes on this thread.
while (true) {
CreateSubscribeRequest();
java.lang.Thread.sleep(200);
}
} catch (Exception ex) {
System.out.println(ex.getMessage());
ex.printStackTrace();
usage();
}
}
public void CreateSubscribeRequest() {
try {
String transport = "udp";
String peerHostPort = "127.0.0.1:5070";
String fromName = "subscriber";
String fromSipAddress = "10.10.10.10";
String fromDisplayName = "Mr. subscriber";
String toSipAddress = "notifier";
String toUser = "8000@10.10.10.10";
String toDisplayName = "Mr. notifier";
// create >From Header
SipURI fromAddress = addressFactory.createSipURI(fromName,
fromSipAddress);
// Create a new CallId header
CallIdHeader callIdHeader = sipProvider.getNewCallId();// headerFactory.createCallIdHeader("8000dlg");
Address fromNameAddress = addressFactory.createAddress(fromAddress);
fromNameAddress.setDisplayName(fromDisplayName);
FromHeader fromHeader = headerFactory.createFromHeader(
fromNameAddress, new Long(new Random().nextLong())
.toString());
// create To Header
SipURI toAddress = addressFactory
.createSipURI(toUser, toSipAddress);
Address toNameAddress = addressFactory.createAddress(toAddress);
toNameAddress.setDisplayName(toDisplayName);
ToHeader toHeader = headerFactory.createToHeader(toNameAddress,
null);
// create Request URI
SipURI requestURI = addressFactory.createSipURI(toUser,
peerHostPort);
// Create ViaHeaders
ArrayList viaHeaders = new ArrayList();
ViaHeader viaHeader = headerFactory.createViaHeader("127.0.0.1",
sipProvider.getListeningPoint(transport).getPort(),
transport, null);
// add via headers
viaHeaders.add(viaHeader);
// Create a new Cseq header
CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(
(long) seq_num, Request.SUBSCRIBE);
seq_num++;
// Create a new MaxForwardsHeader
MaxForwardsHeader maxForwards = headerFactory
.createMaxForwardsHeader(70);
// Create the request.
Request request = messageFactory.createRequest(requestURI,
Request.SUBSCRIBE, callIdHeader, cSeqHeader, fromHeader,
toHeader, viaHeaders, maxForwards);
// Create contact headers
String host = "127.0.0.1";
SipURI contactUrl = addressFactory.createSipURI(fromName, host);
contactUrl.setPort(udpListeningPoint.getPort());
contactUrl.setLrParam();
// Create the contact name address.
SipURI contactURI = addressFactory.createSipURI(fromName, host);
contactURI.setPort(sipProvider.getListeningPoint(transport)
.getPort());
Address contactAddress = addressFactory.createAddress(contactURI);
// Add the contact address.
contactAddress.setDisplayName(fromName);
contactHeader = headerFactory.createContactHeader(contactAddress);
request.addHeader(contactHeader);
ExpiresHeader expires_header = headerFactory
.createExpiresHeader(200);
request.addHeader(expires_header);
EventHeader event_header = null;
event_header = headerFactory.createEventHeader("reg");
request.addHeader(event_header);
ClientTransaction ct = sipProvider.getNewClientTransaction(request);
ct.sendRequest();
// send the request out.
} catch (Exception ex) {
System.out.println(ex.getMessage());
ex.printStackTrace();
usage();
}
}
public static void main(String args[]) {
new Subscriber().init();
}
public void processIOException(IOExceptionEvent exceptionEvent) {
System.out.println("IOException happened for "
+ exceptionEvent.getHost() + " port = "
+ exceptionEvent.getPort());
}
public void processTransactionTerminated(
TransactionTerminatedEvent transactionTerminatedEvent) {
System.out.println("Transaction terminated event recieved");
}
public void processDialogTerminated(
DialogTerminatedEvent dialogTerminatedEvent) {
System.out.println("dialogTerminatedEvent");
}
}