/**
* Find the transaction corresponding to a given request.
*
* @param sipMessage request for which to retrieve the transaction.
* @param isServer search the server transaction table if true.
* @return the transaction object corresponding to the request or null if no such mapping exists.
*/
public SIPTransaction findTransaction(SIPMessage sipMessage, boolean isServer) {
SIPTransaction retval = null;
if (isServer) {
Via via = sipMessage.getTopmostVia();
if (via.getBranch() != null) {
String key = sipMessage.getTransactionId();
synchronized (this.serverTransactionTable) {
retval = (SIPTransaction) serverTransactionTable.get(key);
if (LogWriter.needsLogging) logMessage("looking for key " + key);
if (retval != null && retval.isMessagePartOfTransaction(sipMessage)) return retval;
}
}
// Need to scan the table for old style transactions (RFC 2543
// style)
synchronized (this.serverTransactions) {
Iterator<SIPServerTransaction> it = serverTransactions.iterator();
while (it.hasNext()) {
SIPServerTransaction sipServerTransaction = (SIPServerTransaction) it.next();
if (sipServerTransaction.isMessagePartOfTransaction(sipMessage))
return sipServerTransaction;
}
}
} else {
Via via = sipMessage.getTopmostVia();
if (via.getBranch() != null) {
String key = sipMessage.getTransactionId();
synchronized (this.clientTransactionTable) {
retval = (SIPTransaction) clientTransactionTable.get(key);
if (retval != null && retval.isMessagePartOfTransaction(sipMessage)) return retval;
}
}
// Need to scan the table for old style transactions (RFC 2543
// style)
synchronized (this.clientTransactions) {
Iterator<SIPClientTransaction> it = clientTransactions.iterator();
while (it.hasNext()) {
SIPClientTransaction clientTransaction = (SIPClientTransaction) it.next();
if (clientTransaction.isMessagePartOfTransaction(sipMessage)) return clientTransaction;
}
}
}
return null;
}
/**
* Return a formatted message to the client. We try to re-connect with the peer on the other end
* if possible.
*
* @param sipMessage Message to send.
* @throws IOException If there is an error sending the message
*/
public void sendMessage(SIPMessage sipMessage) throws IOException {
byte[] msg = sipMessage.encodeAsBytes();
long time = System.currentTimeMillis();
this.sendMessage(msg, sipMessage instanceof SIPRequest);
if (this.stack.serverLog.needsLogging(ServerLog.TRACE_MESSAGES))
logMessage(sipMessage, peerAddress, peerPort, time);
}
/**
* Return a reply from a pre-constructed reply. This sends the message back to the entity who
* caused us to create this channel in the first place.
*
* @param sipMessage Message string to send.
* @throws IOException If there is a problem with sending the message.
*/
public void sendMessage(SIPMessage sipMessage) throws IOException {
if (sipStack.isLoggingEnabled() && this.sipStack.logStackTraceOnMessageSend) {
if (sipMessage instanceof SIPRequest && ((SIPRequest) sipMessage).getRequestLine() != null) {
/*
* We dont want to log empty trace messages.
*/
this.sipStack.logWriter.logStackTrace(LogWriter.TRACE_MESSAGES);
} else {
this.sipStack.logWriter.logStackTrace(LogWriter.TRACE_MESSAGES);
}
}
// Test and see where we are going to send the messsage. If the message
// is sent back to oursleves, just
// shortcircuit processing.
long time = System.currentTimeMillis();
try {
for (MessageProcessor messageProcessor : sipStack.getMessageProcessors()) {
if (messageProcessor.getIpAddress().equals(this.peerAddress)
&& messageProcessor.getPort() == this.peerPort
&& messageProcessor.getTransport().equals(this.peerProtocol)) {
MessageChannel messageChannel =
messageProcessor.createMessageChannel(this.peerAddress, this.peerPort);
if (messageChannel instanceof RawMessageChannel) {
((RawMessageChannel) messageChannel).processMessage(sipMessage);
sipStack.logWriter.logDebug("Self routing message");
return;
}
}
}
byte[] msg = sipMessage.encodeAsBytes(this.getTransport());
sendMessage(msg, peerAddress, peerPort, peerProtocol, sipMessage instanceof SIPRequest);
} catch (IOException ex) {
throw ex;
} catch (Exception ex) {
sipStack.logWriter.logError("An exception occured while sending message", ex);
throw new IOException("An exception occured while sending message");
} finally {
if (sipStack.logWriter.isLoggingEnabled(ServerLog.TRACE_MESSAGES))
logMessage(sipMessage, peerAddress, peerPort, time);
}
}
/**
* Exception processor for exceptions detected from the parser. (This is invoked by the parser
* when an error is detected).
*
* @param sipMessage -- the message that incurred the error.
* @param ex -- parse exception detected by the parser.
* @param header -- header that caused the error.
* @throws ParseException Thrown if we want to reject the message.
*/
public void handleException(
ParseException ex, SIPMessage sipMessage, Class hdrClass, String header, String message)
throws ParseException {
if (LogWriter.needsLogging) stack.logWriter.logException(ex);
// Log the bad message for later reference.
if ((hdrClass != null)
&& (hdrClass.equals(From.class)
|| hdrClass.equals(To.class)
|| hdrClass.equals(CSeq.class)
|| hdrClass.equals(Via.class)
|| hdrClass.equals(CallID.class)
|| hdrClass.equals(RequestLine.class)
|| hdrClass.equals(StatusLine.class))) {
stack.logBadMessage(message);
throw ex;
} else {
sipMessage.addUnparsed(header);
}
}
/**
* Implementation of the ParseExceptionListener interface.
*
* @param ex Exception that is given to us by the parser.
* @throws ParseException If we choose to reject the header or message.
*/
public void handleException(
ParseException ex, SIPMessage sipMessage, Class hdrClass, String header, String message)
throws ParseException {
if (sipStack.isLoggingEnabled()) this.sipStack.logWriter.logException(ex);
// Log the bad message for later reference.
if ((hdrClass != null)
&& (hdrClass.equals(From.class)
|| hdrClass.equals(To.class)
|| hdrClass.equals(CSeq.class)
|| hdrClass.equals(Via.class)
|| hdrClass.equals(CallID.class)
|| hdrClass.equals(RequestLine.class)
|| hdrClass.equals(StatusLine.class))) {
sipStack.logWriter.logError("BAD MESSAGE!");
sipStack.logWriter.logError(message);
throw ex;
} else {
sipMessage.addUnparsed(header);
}
}
/**
* This is input reading thread for the pipelined parser. You feed it input through the input
* stream (see the constructor) and it calls back an event listener interface for message
* processing or error. It cleans up the input - dealing with things like line continuation
*/
public void run() {
Pipeline inputStream = this.rawInputStream;
// inputStream = new MyFilterInputStream(this.rawInputStream);
// I cannot use buffered reader here because we may need to switch
// encodings to read the message body.
try {
while (true) {
this.sizeCounter = this.maxMessageSize;
// this.messageSize = 0;
StringBuffer inputBuffer = new StringBuffer();
if (Debug.parserDebug) Debug.println("Starting parse!");
String line1;
String line2 = null;
while (true) {
try {
line1 = readLine(inputStream);
// ignore blank lines.
if (line1.equals("\n")) {
if (Debug.parserDebug) Debug.println("Discarding " + line1);
continue;
} else break;
} catch (IOException ex) {
Debug.printStackTrace(ex);
this.rawInputStream.stopTimer();
return;
}
}
inputBuffer.append(line1);
// Guard against bad guys.
this.rawInputStream.startTimer();
while (true) {
try {
line2 = readLine(inputStream);
inputBuffer.append(line2);
if (line2.trim().equals("")) break;
} catch (IOException ex) {
this.rawInputStream.stopTimer();
Debug.printStackTrace(ex);
return;
}
}
// Stop the timer that will kill the read.
this.rawInputStream.stopTimer();
inputBuffer.append(line2);
StringMsgParser smp = new StringMsgParser(sipMessageListener);
smp.readBody = false;
SIPMessage sipMessage = null;
try {
sipMessage = smp.parseSIPMessage(inputBuffer.toString());
if (sipMessage == null) {
this.rawInputStream.stopTimer();
continue;
}
} catch (ParseException ex) {
// Just ignore the parse exception.
continue;
}
if (Debug.parserDebug) Debug.println("Completed parsing message");
ContentLength cl = (ContentLength) sipMessage.getContentLength();
int contentLength = 0;
if (cl != null) {
contentLength = cl.getContentLength();
} else {
contentLength = 0;
}
if (Debug.parserDebug) {
Debug.println("contentLength " + contentLength);
Debug.println("sizeCounter " + this.sizeCounter);
Debug.println("maxMessageSize " + this.maxMessageSize);
}
if (contentLength == 0) {
sipMessage.removeContent();
} else if (maxMessageSize == 0 || contentLength < this.sizeCounter) {
byte[] message_body = new byte[contentLength];
int nread = 0;
while (nread < contentLength) {
// Start my starvation timer.
// This ensures that the other end
// writes at least some data in
// or we will close the pipe from
// him. This prevents DOS attack
// that takes up all our connections.
this.rawInputStream.startTimer();
try {
int readlength = inputStream.read(message_body, nread, contentLength - nread);
if (readlength > 0) {
nread += readlength;
} else {
break;
}
} catch (IOException ex) {
ex.printStackTrace();
break;
} finally {
// Stop my starvation timer.
this.rawInputStream.stopTimer();
}
}
sipMessage.setMessageContent(message_body);
}
// Content length too large - process the message and
// return error from there.
if (sipMessageListener != null) {
try {
sipMessageListener.processMessage(sipMessage);
} catch (Exception ex) {
// fatal error in processing - close the
// connection.
break;
}
}
}
} finally {
try {
inputStream.close();
} catch (IOException e) {
InternalErrorHandler.handleException(e);
}
}
}
/**
* Gets invoked by the parser as a callback on successful message parsing (i.e. no parser errors).
*
* @param sipMessage Mesage to process (this calls the application for processing the message).
*/
public void processMessage(SIPMessage sipMessage) throws Exception {
try {
if (sipMessage.getFrom() == null
|| // sipMessage.getFrom().getTag() == null ||
sipMessage.getTo() == null
|| sipMessage.getCallId() == null
|| sipMessage.getCSeq() == null
|| sipMessage.getViaHeaders() == null) {
String badmsg = sipMessage.encode();
if (LogWriter.needsLogging) {
stack.logWriter.logMessage("bad message " + badmsg);
stack.logWriter.logMessage(">>> Dropped Bad Msg");
}
stack.logBadMessage(badmsg);
return;
}
ViaList viaList = sipMessage.getViaHeaders();
// For a request
// first via header tells where the message is coming from.
// For response, this has already been recorded in the outgoing
// message.
if (sipMessage instanceof SIPRequest) {
Via v = (Via) viaList.first();
if (v.hasPort()) {
this.peerPort = v.getPort();
} else this.peerPort = 5061;
this.peerProtocol = v.getTransport();
try {
this.peerAddress = mySock.getInetAddress();
// Check to see if the received parameter matches
// the peer address and tag it appropriately.
// Bug fix by [email protected]
// Should record host address not host name
// bug fix by Joost Yervante Damand
if (!v.getSentBy().getInetAddress().equals(this.peerAddress)) {
v.setParameter(Via.RECEIVED, this.peerAddress.getHostAddress());
// @@@ hagai
v.setParameter(Via.RPORT, new Integer(this.peerPort).toString());
}
} catch (java.net.UnknownHostException ex) {
// Could not resolve the sender address.
if (LogWriter.needsLogging) {
stack.logWriter.logMessage("Rejecting message -- could not resolve Via Address");
}
return;
} catch (java.text.ParseException ex) {
InternalErrorHandler.handleException(ex);
}
// Use this for outgoing messages as well.
if (!this.isCached) {
((TLSMessageProcessor) this.messageProcessor).cacheMessageChannel(this);
this.isCached = true;
String key = IOHandler.makeKey(mySock.getInetAddress(), this.peerPort);
stack.ioHandler.putSocket(key, mySock);
}
}
// Foreach part of the request header, fetch it and process it
long receptionTime = System.currentTimeMillis();
//
if (sipMessage instanceof SIPRequest) {
// This is a request - process the request.
SIPRequest sipRequest = (SIPRequest) sipMessage;
// Create a new sever side request processor for this
// message and let it handle the rest.
if (LogWriter.needsLogging) {
stack.logWriter.logMessage("----Processing Message---");
}
// Check for reasonable size - reject message
// if it is too long.
if (stack.getMaxMessageSize() > 0
&& sipRequest.getSize()
+ (sipRequest.getContentLength() == null
? 0
: sipRequest.getContentLength().getContentLength())
> stack.getMaxMessageSize()) {
SIPResponse sipResponse = sipRequest.createResponse(SIPResponse.MESSAGE_TOO_LARGE);
byte[] resp = sipResponse.encodeAsBytes();
this.sendMessage(resp, false);
throw new Exception("Message size exceeded");
}
ServerRequestInterface sipServerRequest = stack.newSIPServerRequest(sipRequest, this);
sipServerRequest.processRequest(sipRequest, this);
if (this.stack.serverLog.needsLogging(ServerLog.TRACE_MESSAGES)) {
if (sipServerRequest.getProcessingInfo() == null) {
stack.serverLog.logMessage(
sipMessage,
sipRequest.getViaHost() + ":" + sipRequest.getViaPort(),
stack.getHostAddress() + ":" + stack.getPort(this.getTransport()),
false,
receptionTime);
} else {
this.stack.serverLog.logMessage(
sipMessage,
sipRequest.getViaHost() + ":" + sipRequest.getViaPort(),
stack.getHostAddress() + ":" + stack.getPort(this.getTransport()),
sipServerRequest.getProcessingInfo(),
false,
receptionTime);
}
}
} else {
SIPResponse sipResponse = (SIPResponse) sipMessage;
// This is a response message - process it.
// Check the size of the response.
// If it is too large dump it silently.
if (stack.getMaxMessageSize() > 0
&& sipResponse.getSize()
+ (sipResponse.getContentLength() == null
? 0
: sipResponse.getContentLength().getContentLength())
> stack.getMaxMessageSize()) {
if (LogWriter.needsLogging) this.stack.logWriter.logMessage("Message size exceeded");
return;
}
ServerResponseInterface sipServerResponse = stack.newSIPServerResponse(sipResponse, this);
sipServerResponse.processResponse(sipResponse, this);
}
} finally {
}
}
/**
* Process an incoming datagram
*
* @param packet is the incoming datagram packet.
*/
private void processIncomingDataPacket(DatagramPacket packet) throws Exception {
this.peerAddress = packet.getAddress();
int packetLength = packet.getLength();
// Read bytes and put it in a eueue.
byte[] bytes = packet.getData();
byte[] msgBytes = new byte[packetLength];
System.arraycopy(bytes, 0, msgBytes, 0, packetLength);
// Do debug logging.
if (sipStack.isLoggingEnabled()) {
this.sipStack.logWriter.logDebug(
"UDPMessageChannel: processIncomingDataPacket : peerAddress = "
+ peerAddress.getHostAddress()
+ "/"
+ packet.getPort()
+ " Length = "
+ packetLength);
}
SIPMessage sipMessage = null;
try {
this.receptionTime = System.currentTimeMillis();
sipMessage = myParser.parseSIPMessage(msgBytes);
myParser = null;
} catch (ParseException ex) {
myParser = null; // let go of the parser reference.
if (sipStack.isLoggingEnabled()) {
this.sipStack.logWriter.logDebug("Rejecting message ! " + new String(msgBytes));
this.sipStack.logWriter.logDebug("error message " + ex.getMessage());
this.sipStack.logWriter.logException(ex);
}
// JvB: send a 400 response for requests (except ACK)
// Currently only UDP, @todo also other transports
String msgString = new String(msgBytes, 0, packetLength);
if (!msgString.startsWith("SIP/") && !msgString.startsWith("ACK ")) {
String badReqRes = createBadReqRes(msgString, ex);
if (badReqRes != null) {
if (sipStack.isLoggingEnabled()) {
sipStack.getLogWriter().logDebug("Sending automatic 400 Bad Request:");
sipStack.getLogWriter().logDebug(badReqRes);
}
try {
this.sendMessage(badReqRes.getBytes(), peerAddress, packet.getPort(), "UDP", false);
} catch (IOException e) {
this.sipStack.logWriter.logException(e);
}
} else {
if (sipStack.isLoggingEnabled()) {
sipStack.getLogWriter().logDebug("Could not formulate automatic 400 Bad Request");
}
}
}
return;
}
// No parse exception but null message - reject it and
// march on (or return).
// exit this message processor if the message did not parse.
if (sipMessage == null) {
if (sipStack.isLoggingEnabled()) {
this.sipStack.logWriter.logDebug("Rejecting message ! + Null message parsed.");
}
return;
}
ViaList viaList = sipMessage.getViaHeaders();
// Check for the required headers.
if (sipMessage.getFrom() == null
|| sipMessage.getTo() == null
|| sipMessage.getCallId() == null
|| sipMessage.getCSeq() == null
|| sipMessage.getViaHeaders() == null) {
String badmsg = new String(msgBytes);
if (sipStack.isLoggingEnabled()) {
this.sipStack.logWriter.logError("bad message " + badmsg);
this.sipStack.logWriter.logError(
">>> Dropped Bad Msg "
+ "From = "
+ sipMessage.getFrom()
+ "To = "
+ sipMessage.getTo()
+ "CallId = "
+ sipMessage.getCallId()
+ "CSeq = "
+ sipMessage.getCSeq()
+ "Via = "
+ sipMessage.getViaHeaders());
}
sipStack.logWriter.logError("BAD MESSAGE!");
return;
}
// For a request first via header tells where the message
// is coming from.
// For response, just get the port from the packet.
if (sipMessage instanceof SIPRequest) {
Via v = (Via) viaList.getFirst();
Hop hop = sipStack.addressResolver.resolveAddress(v.getHop());
this.peerPort = hop.getPort();
this.peerProtocol = v.getTransport();
this.peerPacketSourceAddress = packet.getAddress();
this.peerPacketSourcePort = packet.getPort();
try {
this.peerAddress = packet.getAddress();
// Check to see if the received parameter matches
// the peer address and tag it appropriately.
boolean hasRPort = v.hasParameter(Via.RPORT);
if (hasRPort || !hop.getHost().equals(this.peerAddress.getHostAddress())) {
v.setParameter(Via.RECEIVED, this.peerAddress.getHostAddress());
}
if (hasRPort) {
v.setParameter(Via.RPORT, Integer.toString(this.peerPacketSourcePort));
}
} catch (java.text.ParseException ex1) {
InternalErrorHandler.handleException(ex1);
}
} else {
this.peerPacketSourceAddress = packet.getAddress();
this.peerPacketSourcePort = packet.getPort();
this.peerAddress = packet.getAddress();
this.peerPort = packet.getPort();
this.peerProtocol = ((Via) viaList.getFirst()).getTransport();
}
this.processMessage(sipMessage);
}