private void handleReInvite(Request request, ServerTransaction st) {
Logger.println("Call " + cp + " Re-INVITE\n" + request);
if (request.getRawContent() == null) {
Logger.error("Call " + cp + " no SDP in INVITE Request!");
return;
}
String sdpBody = new String(request.getRawContent());
SdpInfo sdpInfo;
try {
sdpInfo = sipUtil.getSdpInfo(sdpBody);
} catch (ParseException e) {
Logger.error("Call " + cp + " invalid SDP in re-INVITE Request! " + e.getMessage());
return;
}
MediaInfo mediaInfo = sdpInfo.getMediaInfo();
InetSocketAddress isa = new InetSocketAddress(sdpInfo.getRemoteHost(), sdpInfo.getRemotePort());
InetSocketAddress rtcpAddress = sdpInfo.getRtcpAddress();
setEndpointAddress(
isa,
mediaInfo.getPayload(),
sdpInfo.getTransmitMediaInfo().getPayload(),
sdpInfo.getTelephoneEventPayload(),
rtcpAddress);
isa = callHandler.getReceiveAddress();
try {
sipUtil.sendOkWithSdp(request, st, isa, sdpInfo);
} catch (Exception e) {
Logger.println("Call " + cp + " Failed to send ok with sdp for re-invite " + e.getMessage());
return;
}
}
/**
* 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;
}
/**
* Process a request from a distant contact
*
* @param requestEvent the <tt>RequestEvent</tt> containing the newly received request.
* @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 processRequest(RequestEvent requestEvent) {
synchronized (messageProcessors) {
for (SipMessageProcessor listener : messageProcessors)
if (!listener.processMessage(requestEvent)) return true;
}
// get the content
String content = null;
Request req = requestEvent.getRequest();
try {
content = new String(req.getRawContent(), getCharset(req));
} catch (UnsupportedEncodingException ex) {
if (logger.isDebugEnabled()) logger.debug("failed to convert the message charset");
content = new String(requestEvent.getRequest().getRawContent());
}
// who sent this request ?
FromHeader fromHeader = (FromHeader) requestEvent.getRequest().getHeader(FromHeader.NAME);
if (fromHeader == null) {
logger.error("received a request without a from header");
return false;
}
Contact from =
opSetPersPresence.resolveContactID(fromHeader.getAddress().getURI().toString());
ContentTypeHeader ctheader = (ContentTypeHeader) req.getHeader(ContentTypeHeader.NAME);
String ctype = null;
String cencoding = null;
if (ctheader == null) {
ctype = DEFAULT_MIME_TYPE;
} else {
ctype = ctheader.getContentType() + "/" + ctheader.getContentSubType();
cencoding = ctheader.getParameter("charset");
}
if (cencoding == null) cencoding = DEFAULT_MIME_ENCODING;
Message newMessage = createMessage(content, ctype, cencoding, null);
if (from == null) {
if (logger.isDebugEnabled())
logger.debug(
"received a message from an unknown contact: "
+ fromHeader.getAddress().getURI().toString());
// create the volatile contact
from = opSetPersPresence.createVolatileContact(fromHeader.getAddress().getURI().toString());
}
// answer ok
try {
Response ok =
sipProvider.getMessageFactory().createResponse(Response.OK, requestEvent.getRequest());
SipStackSharing.getOrCreateServerTransaction(requestEvent).sendResponse(ok);
} catch (ParseException exc) {
logger.error("failed to build the response", exc);
} catch (SipException exc) {
logger.error("failed to send the response : " + exc.getMessage(), exc);
} catch (InvalidArgumentException exc) {
if (logger.isDebugEnabled())
logger.debug("Invalid argument for createResponse : " + exc.getMessage(), exc);
}
// fire an event
MessageReceivedEvent msgReceivedEvt =
new MessageReceivedEvent(newMessage, from, System.currentTimeMillis());
fireMessageEvent(msgReceivedEvt);
return true;
}
/**
* Implements {@link MethodProcessor#processRequest(RequestEvent)}. Handles only NOTIFY requests
* because they are the only requests concerning event package subscribers and if the processing
* of a given request requires event package-specific handling, delivers the request to the
* matching Subscription instance. Examples of such event package-specific handling include
* handling the termination of an existing Subscription and processing the bodies of the NOTIFY
* requests for active Subscriptions.
*
* @param requestEvent a <tt>RequestEvent</tt> specifying the SIP <tt>Request</tt> to be processed
* @return <tt>true</tt> if the SIP <tt>Request</tt> specified by <tt>requestEvent</tt> was
* processed; otherwise, <tt>false</tt>
*/
@Override
public boolean processRequest(RequestEvent requestEvent) {
Request request = requestEvent.getRequest();
EventHeader eventHeader = (EventHeader) request.getHeader(EventHeader.NAME);
if ((eventHeader == null) || !eventPackage.equalsIgnoreCase(eventHeader.getEventType())) {
/*
* We are not concerned by this request, perhaps another listener
* is. So don't send a 489 / Bad event answer here.
*/
return false;
}
if (!Request.NOTIFY.equals(request.getMethod())) return false;
if (logger.isDebugEnabled()) logger.debug("notify received");
SubscriptionStateHeader sstateHeader =
(SubscriptionStateHeader) request.getHeader(SubscriptionStateHeader.NAME);
// notify must contain one (rfc3265)
if (sstateHeader == null) {
logger.error("no subscription state in this request");
return false;
}
String sstate = sstateHeader.getState();
ServerTransaction serverTransaction = getOrCreateServerTransaction(requestEvent);
// first handle the case of a contact still pending
// it's possible if the NOTIFY arrives before the OK
CallIdHeader callIdHeader = (CallIdHeader) request.getHeader(CallIdHeader.NAME);
String callId = callIdHeader.getCallId();
Subscription subscription = getSubscription(callId);
// see if the notify correspond to an existing subscription
if ((subscription == null) && !SubscriptionStateHeader.TERMINATED.equalsIgnoreCase(sstate)) {
if (logger.isDebugEnabled()) logger.debug("subscription not found for callId " + callId);
// send a 481 response (rfc3625)
Response response;
try {
response =
protocolProvider
.getMessageFactory()
.createResponse(Response.CALL_OR_TRANSACTION_DOES_NOT_EXIST, request);
} catch (ParseException e) {
logger.error("failed to create the 481 response", e);
return false;
}
try {
serverTransaction.sendResponse(response);
} catch (SipException e) {
logger.error("failed to send the response", e);
} catch (InvalidArgumentException e) {
// should not happen
logger.error("invalid argument provided while trying to send the response", e);
}
return true;
}
// if we don't understand the content
ContentTypeHeader ctheader = (ContentTypeHeader) request.getHeader(ContentTypeHeader.NAME);
if ((ctheader != null) && !ctheader.getContentSubType().equalsIgnoreCase(contentSubType)) {
// send a 415 response (rfc3261)
Response response;
try {
response =
protocolProvider
.getMessageFactory()
.createResponse(Response.UNSUPPORTED_MEDIA_TYPE, request);
} catch (ParseException e) {
logger.error("failed to create the OK response", e);
return false;
}
// we want PIDF
AcceptHeader acceptHeader;
try {
acceptHeader =
protocolProvider.getHeaderFactory().createAcceptHeader("application", contentSubType);
} catch (ParseException e) {
// should not happen
logger.error("failed to create the accept header", e);
return false;
}
response.setHeader(acceptHeader);
try {
serverTransaction.sendResponse(response);
} catch (SipException e) {
logger.error("failed to send the response", e);
} catch (InvalidArgumentException e) {
// should not happen
logger.error("invalid argument provided while trying" + " to send the response", e);
}
}
// if the presentity doesn't want of us anymore
if (SubscriptionStateHeader.TERMINATED.equalsIgnoreCase(sstate)) {
// if we requested this end of subscription, subscription == null
if (subscription != null) {
removeSubscription(callId, subscription);
subscription.processTerminatedRequest(requestEvent, sstateHeader.getReasonCode());
}
}
// send an OK response
Response response;
try {
response = protocolProvider.getMessageFactory().createResponse(Response.OK, request);
} catch (ParseException e) {
logger.error("failed to create the OK response", e);
return false;
}
try {
serverTransaction.sendResponse(response);
} catch (SipException e) {
logger.error("failed to send the response", e);
} catch (InvalidArgumentException e) {
// should not happen
logger.error("invalid argument provided while trying to send the response", e);
}
// transform the presence document in new presence status
if (subscription != null)
subscription.processActiveRequest(requestEvent, request.getRawContent());
return true;
}
