public void run() {
Request request = requestEvent.getRequest();
try {
// System.out.println("shootme: got an Invite sending OK");
Response response = messageFactory.createResponse(180, request);
ToHeader toHeader = (ToHeader) response.getHeader(ToHeader.NAME);
Address address =
addressFactory.createAddress("Shootme <sip:" + myAddress + ":" + myPort + ">");
ContactHeader contactHeader = headerFactory.createContactHeader(address);
response.addHeader(contactHeader);
// System.out.println("got a server tranasaction " + st);
Dialog dialog = st.getDialog();
/*
* if (dialog != null) { System.out.println("Dialog " + dialog);
* System.out.println("Dialog state " + dialog.getState()); }
*/
st.sendResponse(response); // send 180(RING)
response = messageFactory.createResponse(200, request);
toHeader = (ToHeader) response.getHeader(ToHeader.NAME);
String toTag = new Integer((int) (Math.random() * 1000)).toString();
toHeader.setTag(toTag); // Application is supposed to set.
response.addHeader(contactHeader);
st.sendResponse(response); // send 200(OK)
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
/** Process the invite request. */
public void processInvite(RequestEvent requestEvent, ServerTransaction serverTransaction) {
SipProvider sipProvider = (SipProvider) requestEvent.getSource();
Request request = requestEvent.getRequest();
try {
System.out.println("shootme: got an Invite sending Trying");
// System.out.println("shootme: " + request);
Response response = messageFactory.createResponse(Response.TRYING, request);
ServerTransaction st = requestEvent.getServerTransaction();
if (st == null) {
st = sipProvider.getNewServerTransaction(request);
}
dialog = st.getDialog();
st.sendResponse(response);
this.okResponse = messageFactory.createResponse(Response.BUSY_HERE, request);
ToHeader toHeader = (ToHeader) okResponse.getHeader(ToHeader.NAME);
toHeader.setTag("4321"); // Application is supposed to set.
this.inviteTid = st;
// Defer sending the OK to simulate the phone ringing.
this.inviteRequest = request;
new Timer().schedule(new MyTimerTask(this), 100);
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
/** Process the invite request. */
public void processInvite(RequestEvent requestEvent, ServerTransaction serverTransaction) {
SipProvider sipProvider = (SipProvider) requestEvent.getSource();
Request request = requestEvent.getRequest();
try {
System.out.println("b2bua: got an Invite sending Trying");
ServerTransaction st = requestEvent.getServerTransaction();
if (st == null) {
st = sipProvider.getNewServerTransaction(request);
}
Dialog dialog = st.getDialog();
ToHeader to = (ToHeader) request.getHeader(ToHeader.NAME);
SipURI toUri = (SipURI) to.getAddress().getURI();
SipURI target = registrar.get(toUri.getUser());
if (target == null) {
System.out.println("User " + toUri + " is not registered.");
throw new RuntimeException("User not registered " + toUri);
} else {
ClientTransaction otherLeg = call(target);
otherLeg.setApplicationData(st);
st.setApplicationData(otherLeg);
dialog.setApplicationData(otherLeg.getDialog());
otherLeg.getDialog().setApplicationData(dialog);
}
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
/** Process the invite request. */
public void processInvite(RequestEvent requestEvent, ServerTransaction serverTransaction) {
SipProvider sipProvider = (SipProvider) requestEvent.getSource();
Request request = requestEvent.getRequest();
try {
logger.info("shootme: got an Invite sending Trying");
// logger.info("shootme: " + request);
ServerTransaction st = requestEvent.getServerTransaction();
if (st == null) {
logger.info("null server tx -- getting a new one");
st = sipProvider.getNewServerTransaction(request);
}
logger.info("getNewServerTransaction : " + st);
String txId = ((ViaHeader) request.getHeader(ViaHeader.NAME)).getBranch();
this.serverTxTable.put(txId, st);
// Create the 100 Trying response.
Response response = protocolObjects.messageFactory.createResponse(Response.TRYING, request);
ListeningPoint lp = sipProvider.getListeningPoint(protocolObjects.transport);
int myPort = lp.getPort();
Address address =
protocolObjects.addressFactory.createAddress(
"Shootme <sip:" + myAddress + ":" + myPort + ">");
// Add a random sleep to stagger the two OK's for the benifit of implementations
// that may not be too good about handling re-entrancy.
int timeToSleep = (int) (Math.random() * 1000);
Thread.sleep(timeToSleep);
st.sendResponse(response);
Response ringingResponse =
protocolObjects.messageFactory.createResponse(Response.RINGING, request);
ContactHeader contactHeader = protocolObjects.headerFactory.createContactHeader(address);
response.addHeader(contactHeader);
ToHeader toHeader = (ToHeader) ringingResponse.getHeader(ToHeader.NAME);
String toTag =
actAsNonRFC3261UAS ? null : new Integer((int) (Math.random() * 10000)).toString();
if (!actAsNonRFC3261UAS) toHeader.setTag(toTag); // Application is supposed to set.
ringingResponse.addHeader(contactHeader);
st.sendResponse(ringingResponse);
Dialog dialog = st.getDialog();
dialog.setApplicationData(st);
this.inviteSeen = true;
new Timer().schedule(new MyTimerTask(requestEvent, st /*,toTag*/), 1000);
} catch (Exception ex) {
ex.printStackTrace();
System.exit(0);
}
}
public void processResponse(ResponseEvent responseEvent) {
ClientTransaction ct = responseEvent.getClientTransaction();
Response response = responseEvent.getResponse();
ServerTransaction st = (ServerTransaction) ct.getApplicationData();
try {
Response otherResponse =
messageFactory.createResponse(response.getStatusCode(), st.getRequest());
if (response.getStatusCode() == 200 && ct.getRequest().getMethod().equals("INVITE")) {
Address address =
addressFactory.createAddress("B2BUA <sip:" + myAddress + ":" + myPort + ">");
ContactHeader contactHeader = headerFactory.createContactHeader(address);
response.addHeader(contactHeader);
ToHeader toHeader = (ToHeader) otherResponse.getHeader(ToHeader.NAME);
if (toHeader.getTag() == null)
toHeader.setTag(new Long(counter.getAndIncrement()).toString());
otherResponse.addHeader(contactHeader);
}
st.sendResponse(otherResponse);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void processSubscribe(Request request, ServerTransaction serverTransaction) {
logger.debug("Processing SUBSCRIBE in progress ");
try {
MessageFactory messageFactory = imUA.getMessageFactory();
HeaderFactory headerFactory = imUA.getHeaderFactory();
AddressFactory addressFactory = imUA.getAddressFactory();
Dialog dialog = serverTransaction.getDialog();
// ********** Terminating subscriptions **********
ExpiresHeader expiresHeader = (ExpiresHeader) request.getHeader(ExpiresHeader.NAME);
if (expiresHeader != null && expiresHeader.getExpires() == 0) {
if (dialog != null) {
// Terminating an existing subscription
Response response = messageFactory.createResponse(Response.OK, request);
serverTransaction.sendResponse(response);
IMNotifyProcessing imNotifyProcessing = imUA.getIMNotifyProcessing();
imNotifyProcessing.sendNotify(response, null, dialog);
return;
} else {
// Terminating an non existing subscription
Response response =
messageFactory.createResponse(Response.CALL_OR_TRANSACTION_DOES_NOT_EXIST, request);
serverTransaction.sendResponse(response);
return;
}
}
// ********** Non-terminating subscriptions ************
// send a 202 Accepted while waiting for authorization from user
Response response = messageFactory.createResponse(Response.ACCEPTED, request);
// Tag:
ToHeader toHeader = (ToHeader) response.getHeader(ToHeader.NAME);
if (toHeader.getTag() == null)
toHeader.setTag(new Integer((int) (Math.random() * 10000)).toString());
serverTransaction.sendResponse(response);
logger.debug(response.toString());
// We have to ask the user to authorize the guy to be in his buddy
// list
String presentityURL = IMUtilities.getKey(request, "From");
SipProvider sipProvider = imUA.getSipProvider();
InstantMessagingGUI imGUI = imUA.getInstantMessagingGUI();
boolean authorization = imGUI.getAuthorizationForBuddy(presentityURL);
if (authorization) {
logger.debug(
"DEBUG: SubscribeProcessing, processSubscribe(), " + " Response 202 Accepted sent.");
// We have to create or update the subscriber!
PresenceManager presenceManager = imUA.getPresenceManager();
String subscriberURL = IMUtilities.getKey(request, "From");
if (dialog != null) presenceManager.addSubscriber(subscriberURL, response, dialog);
else {
logger.debug(
"ERROR, IMSubscribeProcessing, processSubscribe(), the"
+ " dialog for the SUBSCRIBE we received is null!!! No subscriber added....");
return;
}
// Let's see if this buddy is in our buddy list
// if not let's ask to add him!
BuddyList buddyList = imGUI.getBuddyList();
ListenerInstantMessaging listenerIM = imGUI.getListenerInstantMessaging();
if (!buddyList.hasBuddy(subscriberURL)) {
// Let's ask:
listenerIM.addContact(subscriberURL);
}
/** ********************** send NOTIFY ************************* */
// We send a NOTIFY for any of our status but offline
String localStatus = listenerIM.getLocalStatus();
if (!localStatus.equals("offline")) {
IMNotifyProcessing imNotifyProcessing = imUA.getIMNotifyProcessing();
Subscriber subscriber = presenceManager.getSubscriber(subscriberURL);
// Response okSent=subscriber.getOkSent();
subscriberURL = subscriber.getSubscriberName();
String contactAddress = imUA.getIMAddress() + ":" + imUA.getIMPort();
String subStatus = listenerIM.getLocalStatus();
String status = null;
if (subStatus.equals("offline")) status = "closed";
else status = "open";
String xmlBody =
imNotifyProcessing.xmlPidfParser.createXMLBody(
status, subStatus, subscriberURL, contactAddress);
imNotifyProcessing.sendNotify(response, xmlBody, dialog);
}
} else {
// User did not authorize subscription. Terminate it!
logger.debug(
"DEBUG, IMSubsribeProcessing, processSubscribe(), " + " Subscription declined!");
logger.debug(
"DEBUG, IMSubsribeProcessing, processSubscribe(), "
+ " Sending a Notify with Subscribe-state=terminated");
IMNotifyProcessing imNotifyProcessing = imUA.getIMNotifyProcessing();
if (dialog != null) {
imNotifyProcessing.sendNotify(response, null, dialog);
logger.debug(
"DEBUG, IMSubsribeProcessing, processSubscribe(), "
+ " Sending a Notify with Subscribe-state=terminated");
} else {
logger.debug(
"ERROR, IMSubscribeProcessing, processSubscribe(), the"
+ " dialog for the SUBSCRIBE we received is null!!! \n"
+ " No terminating Notify sent");
}
imNotifyProcessing.sendNotify(response, null, dialog);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
@Override
public void run() {
try {
logger.logEntry();
// From
FromHeader fromHeader = null;
try {
// this keep alive task only makes sense in case we have
// a registrar so we deliberately use our AOR and do not
// use the getOurSipAddress() method.
fromHeader =
provider
.getHeaderFactory()
.createFromHeader(
provider.getRegistrarConnection().getAddressOfRecord(),
SipMessageFactory.generateLocalTag());
} catch (ParseException ex) {
// this should never happen so let's just log and bail.
logger.error("Failed to generate a from header for " + "our register request.", ex);
return;
}
// Call ID Header
CallIdHeader callIdHeader = provider.getDefaultJainSipProvider().getNewCallId();
// CSeq Header
CSeqHeader cSeqHeader = null;
try {
cSeqHeader =
provider.getHeaderFactory().createCSeqHeader(getNextCSeqValue(), Request.OPTIONS);
} catch (ParseException ex) {
// Should never happen
logger.error("Corrupt Sip Stack", ex);
return;
} catch (InvalidArgumentException ex) {
// Should never happen
logger.error("The application is corrupt", ex);
return;
}
// To Header
ToHeader toHeader = null;
try {
// this request isn't really going anywhere so we put our
// own address in the To Header.
toHeader = provider.getHeaderFactory().createToHeader(fromHeader.getAddress(), null);
} catch (ParseException ex) {
logger.error("Could not create a To header for address:" + fromHeader.getAddress(), ex);
return;
}
// MaxForwardsHeader
MaxForwardsHeader maxForwardsHeader = provider.getMaxForwardsHeader();
// Request
Request request = null;
try {
// create a host-only uri for the request uri header.
String domain = ((SipURI) toHeader.getAddress().getURI()).getHost();
// request URI
SipURI requestURI = provider.getAddressFactory().createSipURI(null, domain);
// Via Headers
ArrayList<ViaHeader> viaHeaders = provider.getLocalViaHeaders(requestURI);
request =
provider
.getMessageFactory()
.createRequest(
requestURI,
Request.OPTIONS,
callIdHeader,
cSeqHeader,
fromHeader,
toHeader,
viaHeaders,
maxForwardsHeader);
if (logger.isDebugEnabled()) logger.debug("Created OPTIONS request " + request);
} catch (ParseException ex) {
logger.error("Could not create an OPTIONS request!", ex);
return;
}
Iterator<String> supportedMethods = provider.getSupportedMethods().iterator();
// add to the allows header all methods that we support
while (supportedMethods.hasNext()) {
String method = supportedMethods.next();
// don't support REGISTERs
if (method.equals(Request.REGISTER)) continue;
request.addHeader(provider.getHeaderFactory().createAllowHeader(method));
}
Iterator<String> events = provider.getKnownEventsList().iterator();
synchronized (provider.getKnownEventsList()) {
while (events.hasNext()) {
String event = events.next();
request.addHeader(provider.getHeaderFactory().createAllowEventsHeader(event));
}
}
// Transaction
ClientTransaction optionsTrans = null;
try {
optionsTrans = provider.getDefaultJainSipProvider().getNewClientTransaction(request);
} catch (TransactionUnavailableException ex) {
logger.error("Could not create options transaction!\n", ex);
return;
}
try {
optionsTrans.sendRequest();
if (logger.isDebugEnabled()) logger.debug("sent request= " + request);
} catch (SipException ex) {
logger.error("Could not send out the options request!", ex);
if (ex.getCause() instanceof IOException) {
// IOException problem with network
disconnect();
}
return;
}
} catch (Exception ex) {
logger.error("Cannot send OPTIONS keep alive", ex);
}
}
/**
* Process a response from a distant contact.
*
* @param responseEvent the <tt>ResponseEvent</tt> containing the newly received SIP response.
* @return <tt>true</tt> if the specified event has been handled by this processor and shouldn't
* be offered to other processors registered for the same method; <tt>false</tt>, otherwise
*/
@Override
public boolean processResponse(ResponseEvent responseEvent) {
synchronized (messageProcessors) {
for (SipMessageProcessor listener : messageProcessors)
if (!listener.processResponse(responseEvent, sentMsg)) return true;
}
Request req = responseEvent.getClientTransaction().getRequest();
int status = responseEvent.getResponse().getStatusCode();
// content of the response
String content = null;
try {
content = new String(req.getRawContent(), getCharset(req));
} catch (UnsupportedEncodingException exc) {
if (logger.isDebugEnabled()) logger.debug("failed to convert the message charset", exc);
content = new String(req.getRawContent());
}
// to who did we send the original message ?
ToHeader toHeader = (ToHeader) req.getHeader(ToHeader.NAME);
if (toHeader == null) {
// should never happen
logger.error("send a request without a to header");
return false;
}
Contact to = opSetPersPresence.resolveContactID(toHeader.getAddress().getURI().toString());
if (to == null) {
logger.error(
"Error received a response from an unknown contact : "
+ toHeader.getAddress().getURI().toString()
+ " : "
+ responseEvent.getResponse().getStatusCode()
+ " "
+ responseEvent.getResponse().getReasonPhrase());
// error for delivering the message
fireMessageDeliveryFailed(
// we don't know what message it concerns
createMessage(content), to, MessageDeliveryFailedEvent.INTERNAL_ERROR);
return false;
}
// we retrieve the original message
String key = ((CallIdHeader) req.getHeader(CallIdHeader.NAME)).getCallId();
Message newMessage = sentMsg.get(key);
if (newMessage == null) {
// should never happen
logger.error("Couldn't find the message sent");
// error for delivering the message
fireMessageDeliveryFailed(
// we don't know what message it is
createMessage(content), to, MessageDeliveryFailedEvent.INTERNAL_ERROR);
return true;
}
// status 401/407 = proxy authentification
if (status >= 400 && status != 401 && status != 407) {
if (logger.isInfoEnabled())
logger.info(
responseEvent.getResponse().getStatusCode()
+ " "
+ responseEvent.getResponse().getReasonPhrase());
// error for delivering the message
MessageDeliveryFailedEvent evt =
new MessageDeliveryFailedEvent(
newMessage,
to,
MessageDeliveryFailedEvent.NETWORK_FAILURE,
System.currentTimeMillis(),
responseEvent.getResponse().getStatusCode()
+ " "
+ responseEvent.getResponse().getReasonPhrase());
fireMessageEvent(evt);
sentMsg.remove(key);
} else if (status == 401 || status == 407) {
// proxy ask for authentification
if (logger.isDebugEnabled())
logger.debug(
"proxy asks authentication : "
+ responseEvent.getResponse().getStatusCode()
+ " "
+ responseEvent.getResponse().getReasonPhrase());
ClientTransaction clientTransaction = responseEvent.getClientTransaction();
SipProvider sourceProvider = (SipProvider) responseEvent.getSource();
try {
processAuthenticationChallenge(
clientTransaction, responseEvent.getResponse(), sourceProvider);
} catch (OperationFailedException ex) {
logger.error("can't solve the challenge", ex);
// error for delivering the message
MessageDeliveryFailedEvent evt =
new MessageDeliveryFailedEvent(
newMessage,
to,
MessageDeliveryFailedEvent.NETWORK_FAILURE,
System.currentTimeMillis(),
ex.getMessage());
fireMessageEvent(evt);
sentMsg.remove(key);
}
} else if (status >= 200) {
if (logger.isDebugEnabled())
logger.debug(
"Ack received from the network : "
+ responseEvent.getResponse().getStatusCode()
+ " "
+ responseEvent.getResponse().getReasonPhrase());
// we delivered the message
MessageDeliveredEvent msgDeliveredEvt =
new MessageDeliveredEvent(newMessage, to, System.currentTimeMillis());
fireMessageEvent(msgDeliveredEvt);
// we don't need this message anymore
sentMsg.remove(key);
}
return true;
}
@Override
public boolean processTimeout(TimeoutEvent timeoutEvent) {
synchronized (messageProcessors) {
for (SipMessageProcessor listener : messageProcessors)
if (!listener.processTimeout(timeoutEvent, sentMsg)) return true;
}
// this is normaly handled by the SIP stack
logger.error("Timeout event thrown : " + timeoutEvent.toString());
if (timeoutEvent.isServerTransaction()) {
logger.warn("The sender has probably not received our OK");
return false;
}
Request req = timeoutEvent.getClientTransaction().getRequest();
// get the content
String content = null;
try {
content = new String(req.getRawContent(), getCharset(req));
} catch (UnsupportedEncodingException ex) {
logger.warn("failed to convert the message charset", ex);
content = new String(req.getRawContent());
}
// to who this request has been sent ?
ToHeader toHeader = (ToHeader) req.getHeader(ToHeader.NAME);
if (toHeader == null) {
logger.error("received a request without a to header");
return false;
}
Contact to = opSetPersPresence.resolveContactID(toHeader.getAddress().getURI().toString());
Message failedMessage = null;
if (to == null) {
logger.error(
"timeout on a message sent to an unknown contact : "
+ toHeader.getAddress().getURI().toString());
// we don't know what message it concerns, so create a new
// one
failedMessage = createMessage(content);
} else {
// try to retrieve the original message
String key = ((CallIdHeader) req.getHeader(CallIdHeader.NAME)).getCallId();
failedMessage = sentMsg.get(key);
if (failedMessage == null) {
// should never happen
logger.error("Couldn't find the sent message.");
// we don't know what the message is so create a new one
// based on the content of the failed request.
failedMessage = createMessage(content);
}
}
// error for delivering the message
fireMessageDeliveryFailed(
// we don't know what message it concerns
failedMessage, to, MessageDeliveryFailedEvent.INTERNAL_ERROR);
return true;
}
/**
* Construct a <tt>Request</tt> represent a new message.
*
* @param to the <tt>Contact</tt> to send <tt>message</tt> to
* @param message the <tt>Message</tt> to send.
* @return a Message Request destined to the contact
* @throws OperationFailedException if an error occurred during the creation of the request
*/
Request createMessageRequest(Contact to, Message message) throws OperationFailedException {
Address toAddress = null;
try {
toAddress = sipProvider.parseAddressString(to.getAddress());
} catch (ParseException exc) {
// Shouldn't happen
logger.error("An unexpected error occurred while" + "constructing the address", exc);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the address",
OperationFailedException.INTERNAL_ERROR,
exc);
}
// Call ID
CallIdHeader callIdHeader = this.sipProvider.getDefaultJainSipProvider().getNewCallId();
// CSeq
CSeqHeader cSeqHeader = null;
try {
// protect seqN
synchronized (this) {
cSeqHeader = this.sipProvider.getHeaderFactory().createCSeqHeader(seqN++, Request.MESSAGE);
}
} catch (InvalidArgumentException ex) {
// Shouldn't happen
logger.error("An unexpected error occurred while" + "constructing the CSeqHeadder", ex);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the CSeqHeadder",
OperationFailedException.INTERNAL_ERROR,
ex);
} catch (ParseException exc) {
// shouldn't happen
logger.error("An unexpected error occurred while" + "constructing the CSeqHeadder", exc);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the CSeqHeadder",
OperationFailedException.INTERNAL_ERROR,
exc);
}
// FromHeader and ToHeader
String localTag = SipMessageFactory.generateLocalTag();
FromHeader fromHeader = null;
ToHeader toHeader = null;
try {
// FromHeader
fromHeader =
this.sipProvider
.getHeaderFactory()
.createFromHeader(sipProvider.getOurSipAddress(toAddress), localTag);
// ToHeader
toHeader = this.sipProvider.getHeaderFactory().createToHeader(toAddress, null);
} catch (ParseException ex) {
// these two should never happen.
logger.error(
"An unexpected error occurred while" + "constructing the FromHeader or ToHeader", ex);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the FromHeader or ToHeader",
OperationFailedException.INTERNAL_ERROR,
ex);
}
// ViaHeaders
ArrayList<ViaHeader> viaHeaders = this.sipProvider.getLocalViaHeaders(toAddress);
// MaxForwards
MaxForwardsHeader maxForwards = this.sipProvider.getMaxForwardsHeader();
// Content params
ContentTypeHeader contTypeHeader;
ContentLengthHeader contLengthHeader;
try {
contTypeHeader =
this.sipProvider
.getHeaderFactory()
.createContentTypeHeader(getType(message), getSubType(message));
if (!DEFAULT_MIME_ENCODING.equalsIgnoreCase(message.getEncoding()))
contTypeHeader.setParameter("charset", message.getEncoding());
contLengthHeader =
this.sipProvider.getHeaderFactory().createContentLengthHeader(message.getSize());
} catch (ParseException ex) {
// these two should never happen.
logger.error("An unexpected error occurred while" + "constructing the content headers", ex);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the content headers",
OperationFailedException.INTERNAL_ERROR,
ex);
} catch (InvalidArgumentException exc) {
// these two should never happen.
logger.error(
"An unexpected error occurred while" + "constructing the content length header", exc);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the content length header",
OperationFailedException.INTERNAL_ERROR,
exc);
}
Request req;
try {
req =
this.sipProvider
.getMessageFactory()
.createRequest(
toHeader.getAddress().getURI(),
Request.MESSAGE,
callIdHeader,
cSeqHeader,
fromHeader,
toHeader,
viaHeaders,
maxForwards,
contTypeHeader,
message.getRawData());
} catch (ParseException ex) {
// shouldn't happen
logger.error("Failed to create message Request!", ex);
throw new OperationFailedException(
"Failed to create message Request!", OperationFailedException.INTERNAL_ERROR, ex);
}
req.addHeader(contLengthHeader);
return req;
}
/**
* Creates a new SUBSCRIBE request in the form of a <tt>ClientTransaction</tt> with the parameters
* of a specific <tt>Subscription</tt>.
*
* @param subscription the <tt>Subscription</tt> to be described in a SUBSCRIBE request
* @param expires the subscription duration of the SUBSCRIBE request to be created
* @return a new <tt>ClientTransaction</tt> initialized with a new SUBSCRIBE request which matches
* the parameters of the specified <tt>Subscription</tt>
* @throws OperationFailedException if the request could not be generated
*/
private ClientTransaction createSubscription(Subscription subscription, int expires)
throws OperationFailedException {
Address toAddress = subscription.getAddress();
HeaderFactory headerFactory = protocolProvider.getHeaderFactory();
// Call ID
CallIdHeader callIdHeader = protocolProvider.getDefaultJainSipProvider().getNewCallId();
// CSeq
CSeqHeader cSeqHeader;
try {
cSeqHeader = headerFactory.createCSeqHeader(1l, Request.SUBSCRIBE);
} catch (InvalidArgumentException ex) {
// Shouldn't happen
logger.error("An unexpected error occurred while" + "constructing the CSeqHeader", ex);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the CSeqHeader",
OperationFailedException.INTERNAL_ERROR,
ex);
} catch (ParseException ex) {
// shouldn't happen
logger.error("An unexpected error occurred while" + "constructing the CSeqHeader", ex);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the CSeqHeader",
OperationFailedException.INTERNAL_ERROR,
ex);
}
// FromHeader and ToHeader
String localTag = SipMessageFactory.generateLocalTag();
FromHeader fromHeader;
ToHeader toHeader;
try {
// FromHeader
fromHeader =
headerFactory.createFromHeader(protocolProvider.getOurSipAddress(toAddress), localTag);
// ToHeader
toHeader = headerFactory.createToHeader(toAddress, null);
} catch (ParseException ex) {
// these two should never happen.
logger.error(
"An unexpected error occurred while" + "constructing the FromHeader or ToHeader", ex);
throw new OperationFailedException(
"An unexpected error occurred while" + "constructing the FromHeader or ToHeader",
OperationFailedException.INTERNAL_ERROR,
ex);
}
// ViaHeaders
ArrayList<ViaHeader> viaHeaders = protocolProvider.getLocalViaHeaders(toAddress);
// MaxForwards
MaxForwardsHeader maxForwards = protocolProvider.getMaxForwardsHeader();
Request req;
try {
req =
protocolProvider
.getMessageFactory()
.createRequest(
toHeader.getAddress().getURI(),
Request.SUBSCRIBE,
callIdHeader,
cSeqHeader,
fromHeader,
toHeader,
viaHeaders,
maxForwards);
} catch (ParseException ex) {
// shouldn't happen
logger.error("Failed to create message Request!", ex);
throw new OperationFailedException(
"Failed to create message Request!", OperationFailedException.INTERNAL_ERROR, ex);
}
populateSubscribeRequest(req, subscription, expires);
// Transaction
ClientTransaction subscribeTransaction;
try {
subscribeTransaction =
protocolProvider.getDefaultJainSipProvider().getNewClientTransaction(req);
} catch (TransactionUnavailableException ex) {
logger.error(
"Failed to create subscribe transaction.\n"
+ "This is most probably a network connection error.",
ex);
throw new OperationFailedException(
"Failed to create the subscription transaction",
OperationFailedException.NETWORK_FAILURE);
}
return subscribeTransaction;
}