/**
* Retrieves and returns that ProtocolProviderService that this transaction belongs to, or
* <tt>null</tt> if we couldn't associate it with a provider based on neither the request nor the
* transaction itself.
*
* @param transaction the transaction that we'd like to determine a provider for.
* @return a reference to the <tt>ProtocolProviderServiceSipImpl</tt> that <tt>transaction</tt>
* was associated with or <tt>null</tt> if we couldn't determine which one it is.
*/
private ProtocolProviderServiceSipImpl getServiceData(Transaction transaction) {
ProtocolProviderServiceSipImpl service =
(ProtocolProviderServiceSipImpl)
SipApplicationData.getApplicationData(
transaction.getRequest(), SipApplicationData.KEY_SERVICE);
if (service != null) {
if (logger.isTraceEnabled()) logger.trace("service was found in request data");
return service;
}
service =
(ProtocolProviderServiceSipImpl)
SipApplicationData.getApplicationData(
transaction.getDialog(), SipApplicationData.KEY_SERVICE);
if (service != null) {
if (logger.isTraceEnabled()) logger.trace("service was found in dialog data");
}
return service;
}
/**
* Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate
* recipient" listeners.
*
* @param event the event received for a <tt>SipProvider</tt>.
*/
public void processResponse(ResponseEvent event) {
try {
// we don't have to accept the transaction since we
// created the request
ClientTransaction transaction = event.getClientTransaction();
if (logger.isTraceEnabled())
logger.trace(
"received response: "
+ event.getResponse().getStatusCode()
+ " "
+ event.getResponse().getReasonPhrase());
if (transaction == null) {
logger.warn("Transaction is null, probably already expired!");
return;
}
ProtocolProviderServiceSipImpl service = getServiceData(transaction);
if (service != null) {
// Mark the dialog for the dispatching of later in-dialog
// responses. If there is no dialog then the initial request
// sure is marked otherwise we won't have found the service with
// getServiceData(). The request has to be marked in case we
// receive one more response in an out-of-dialog transaction.
if (event.getDialog() != null) {
SipApplicationData.setApplicationData(
event.getDialog(), SipApplicationData.KEY_SERVICE, service);
}
service.processResponse(event);
} else {
logger.error(
"We received a response which "
+ "wasn't marked, please report this to "
+ "*****@*****.**");
}
} catch (Throwable exc) {
// any exception thrown within our code should be caught here
// so that we could log it rather than interrupt stack activity with
// it.
this.logApplicationException(DialogTerminatedEvent.class, exc);
}
}
/**
* Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate
* recipient" listeners.
*
* @param event the event received for a <tt>SipProvider</tt>.
*/
public void processDialogTerminated(DialogTerminatedEvent event) {
try {
ProtocolProviderServiceSipImpl recipient =
(ProtocolProviderServiceSipImpl)
SipApplicationData.getApplicationData(
event.getDialog(), SipApplicationData.KEY_SERVICE);
if (recipient == null) {
logger.error(
"Dialog wasn't marked, please report this to " + "*****@*****.**");
} else {
if (logger.isTraceEnabled()) logger.trace("service was found with dialog data");
recipient.processDialogTerminated(event);
}
} catch (Throwable exc) {
// any exception thrown within our code should be caught here
// so that we could log it rather than interrupt stack activity with
// it.
this.logApplicationException(DialogTerminatedEvent.class, exc);
}
}
/**
* Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate
* recipient" listeners.
*
* @param event the event received for a <tt>SipProvider</tt>.
*/
public void processRequest(RequestEvent event) {
try {
Request request = event.getRequest();
if (logger.isTraceEnabled()) logger.trace("received request: " + request.getMethod());
/*
* Create the transaction if it doesn't exist yet. If it is a
* dialog-creating request, the dialog will also be automatically
* created by the stack.
*/
if (event.getServerTransaction() == null) {
try {
// apply some hacks if needed on incoming request
// to be compliant with some servers/clients
// if needed stop further processing.
if (applyNonConformanceHacks(event)) return;
SipProvider source = (SipProvider) event.getSource();
ServerTransaction transaction = source.getNewServerTransaction(request);
/*
* Update the event, otherwise getServerTransaction() and
* getDialog() will still return their previous value.
*/
event = new RequestEvent(source, transaction, transaction.getDialog(), request);
} catch (SipException ex) {
logger.error(
"couldn't create transaction, please report "
+ "this to [email protected]",
ex);
}
}
ProtocolProviderServiceSipImpl service = getServiceData(event.getServerTransaction());
if (service != null) {
service.processRequest(event);
} else {
service = findTargetFor(request);
if (service == null) {
logger.error("couldn't find a ProtocolProviderServiceSipImpl " + "to dispatch to");
if (event.getServerTransaction() != null) event.getServerTransaction().terminate();
} else {
/*
* Mark the dialog for the dispatching of later in-dialog
* requests. If there is no dialog, we need to mark the
* request to dispatch a possible timeout when sending the
* response.
*/
Object container = event.getDialog();
if (container == null) container = request;
SipApplicationData.setApplicationData(container, SipApplicationData.KEY_SERVICE, service);
service.processRequest(event);
}
}
} catch (Throwable exc) {
/*
* Any exception thrown within our code should be caught here so
* that we could log it rather than interrupt stack activity with
* it.
*/
this.logApplicationException(DialogTerminatedEvent.class, exc);
// Unfortunately, death can hardly be ignored.
if (exc instanceof ThreadDeath) throw (ThreadDeath) exc;
}
}