/**
* 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 dialog the <tt>Dialog</tt> with which this request should be associated
* @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> and is associated with the specified
* <tt>Dialog</tt>
* @throws OperationFailedException if the message could not be generated
*/
private ClientTransaction createSubscription(
Subscription subscription, Dialog dialog, int expires) throws OperationFailedException {
Request req = messageFactory.createRequest(dialog, Request.SUBSCRIBE);
// Address
Address toAddress = dialog.getRemoteTarget();
// no Contact field
if (toAddress == null) toAddress = dialog.getRemoteParty();
// MaxForwards
MaxForwardsHeader maxForwards = protocolProvider.getMaxForwardsHeader();
req.setHeader(maxForwards);
/*
* Create the transaction and then add the via header as recommended by
* the jain-sip documentation at
* http://snad.ncsl.nist.gov/proj/iptel/jain-sip-1.2/javadoc
* /javax/sip/Dialog.html#createRequest(String).
*/
ClientTransaction transac = null;
try {
transac = protocolProvider.getDefaultJainSipProvider().getNewClientTransaction(req);
} catch (TransactionUnavailableException ex) {
logger.error(
"Failed to create subscriptionTransaction.\n"
+ "This is most probably a network connection error.",
ex);
throw new OperationFailedException(
"Failed to create the subscription transaction",
OperationFailedException.NETWORK_FAILURE);
}
populateSubscribeRequest(req, subscription, expires);
return transac;
}
@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);
}
}
/**
* 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;
}