/** Close the message channel. */
  public void close() {
    try {
      if (LogWriter.needsLogging) LogWriter.logMessage("Closing message Channel " + this);

      if (mySock != null) {
        try {
          String addr = mySock.getAddress();
          int port = mySock.getPort();
          stack.ioHandler.removeAndCloseSocket(stack.ioHandler.makeKey(addr, port));
        } catch (IOException e) {
          if (LogWriter.needsLogging) LogWriter.logMessage("Socket was already closed for " + this);
        }
        mySock = null;
      } else {
        if (LogWriter.needsLogging) LogWriter.logMessage("Socket was already null for " + this);
      }

    } catch (Exception ex) {
      if (LogWriter.needsLogging) {
        LogWriter.logMessage("Exception closing message Channel " + this);
        LogWriter.logException(ex);
      }
    } finally {
      this.isRunning = false;
      uncache();
    }
  }
 /**
  * Exception processor for exceptions detected from the application.
  *
  * @param ex The exception that was generated.
  */
 public void handleException(SIPServerException ex) {
   // Return a parse error message to the client on the other end
   // if he is still alive.
   int rc = ex.getRC();
   String msgString = ex.getMessage();
   if (rc != 0) {
     // Do we have a valid Return code ? --
     // in this case format the message.
     Request request = (Request) ex.getSIPMessage();
     Response response = request.createResponse(rc);
     try {
       sendMessage(response);
     } catch (IOException ioex) {
       if (LogWriter.needsLogging) LogWriter.logException(ioex);
     }
   } else {
     // Otherwise, message is already formatted --
     // just return it
     try {
       sendMessage(msgString.getBytes(), false);
     } catch (IOException ioex) {
       if (LogWriter.needsLogging) LogWriter.logException(ioex);
     }
   }
 }
  /** Run method specified by runnable. */
  public void run() {

    while (true) {
      // Create a new string message parser to parse the list of messages.
      if (myParser == null) {
        myParser = new StringMsgParser();
        myParser.setParseExceptionListener(this);
      }

      // messages that we write out to the peer.
      Datagram packet;

      if (stack.threadPoolSize != -1) {
        synchronized (((UDPMessageProcessor) messageProcessor).messageQueue) {
          while (((UDPMessageProcessor) messageProcessor).messageQueue.isEmpty()) {

            // Check to see if we need to exit.
            if (!((UDPMessageProcessor) messageProcessor).running) return;

            try {
              // Wait for packets
              ((UDPMessageProcessor) messageProcessor).messageQueue.wait();
            } catch (InterruptedException ex) {
              if (!((UDPMessageProcessor) messageProcessor).running) return;
            }
          }
          packet = (Datagram) ((UDPMessageProcessor) messageProcessor).messageQueue.firstElement();
          ((UDPMessageProcessor) messageProcessor).messageQueue.removeElementAt(0);
        }
        incomingPacket = packet;
      } else {
        packet = incomingPacket;
      }

      if (LogWriter.needsLogging) {
        LogWriter.logMessage(
            LogWriter.TRACE_DEBUG, "Processing new incoming datagram " + packet.getLength());
      }
      // Process the packet. Catch and log any exception we may throw.
      try {
        processIncomingDataPacket(packet);
      } catch (Throwable e) {
        if (LogWriter.needsLogging) {
          LogWriter.logMessage(
              LogWriter.TRACE_EXCEPTION, "Exception processing incoming UDP packet");
          LogWriter.logException((Exception) e);
        }
      }

      if (stack.threadPoolSize == -1) {
        return;
      }
    }
  }
  /**
   * This gets invoked when thread.start is called from the constructor. Implements a message loop -
   * reading the tcp connection and processing messages until we are done or the other end has
   * closed.
   */
  public void run() {
    if (LogWriter.needsLogging)
      LogWriter.logMessage(
          LogWriter.TRACE_DEBUG,
          "New TCP Message Channel Thread started " + this + " " + Thread.currentThread());
    // Removed by ArnauVP: in MIDP it's not reliable to read in blocks
    // from inputstreams; thus the Pipe was useless for byte-to-byte reads,
    // and was giving sync problems when reading from the pipe (duplicate bytes).
    // Create a pipeline to connect to our message parser.
    //        Pipeline hispipe = null;
    //        hispipe = new Pipeline(myClientInputStream, stack.readTimeout,
    //                ((SIPTransactionStack) stack).getTimer());

    // Create a pipelined message parser to read from inputStream
    // and parse SIP messages from the bytes.
    myParser =
        new PipelinedMsgParser(
            this, myClientInputStream, this.messageProcessor.getMaximumMessageSize());
    myParser.setMessageChannel(this);
    // Start running the parser thread.
    myParser.processInput();
    // Changed by ArnauVP: using a buffer in some implementations of MIDP,
    // the call to read(msg) would not return from until BUFFER_SIZE bytes were available,
    // thus delaying the processing of the responses by the application and causing timeout.
    // bug fix by Emmanuel Proulx
    //        int bufferSize = 4096;
    this.tcpMessageProcessor.useCount++;
    this.isRunning = true;
  }
  /**
   * Constructor - gets called from the SIPMessageStack class with a socket on accepting a new
   * client. All the processing of the message is done here with the stack being freed up to handle
   * new connections. The sock input is the socket that is returned from the accept. Global data
   * that is shared by all threads is accessible in the Server structure.
   *
   * @param sock Socket from which to read and write messages. The socket is already connected (was
   *     created as a result of an accept).
   * @param sipStack the SIP Stack
   * @param channelNotifier Notifier (optional) that gets called when the channel is opened or
   *     closed.
   */
  protected TCPMessageChannel(
      SocketConnection sock, SIPMessageStack sipStack, TCPMessageProcessor msgProcessor)
      throws IOException {

    stack = sipStack;
    mySock = sock;
    myAddress = sipStack.getHostAddress();
    peerAddress = sock.getAddress();
    myClientInputStream = sock.openInputStream();
    myClientOutputStream = sock.openOutputStream();
    if (LogWriter.needsLogging) {
      LogWriter.logMessage("Creating new TCPMessageChannel " + this);
      LogWriter.logMessage(
          LogWriter.TRACE_DEBUG,
          "Channel parameters: "
              + "stack: "
              + stack
              + "\n"
              + "processor: "
              + msgProcessor
              + "\n"
              + "localAddress: "
              + myAddress
              + "\n"
              + "peerAddress: "
              + peerAddress
              + "\n"
              + "IS "
              + myClientInputStream
              + " Socket "
              + mySock);
    }
    stack.ioHandler.putSocket(
        stack.ioHandler.makeKey(mySock.getAddress(), mySock.getPort()),
        mySock,
        myClientOutputStream,
        myClientInputStream);

    mythread = new Thread(this, "TCPMessageChannel - incoming connection");

    this.tcpMessageProcessor = msgProcessor;
    this.myPort = this.tcpMessageProcessor.getPort();
    // Bug report by Vishwashanti Raj Kadiayl
    super.messageProcessor = msgProcessor;
    mythread.start();
  }
  public void closeFromParser() {
    try {
      if (LogWriter.needsLogging)
        LogWriter.logMessage("Closing message Channel " + this + " from Parser");

      if (mySock != null) {
        try {
          String addr = mySock.getAddress();
          int port = mySock.getPort();
          stack.ioHandler.removeAndCloseSocket(stack.ioHandler.makeKey(addr, port));
        } catch (IOException e) {
          if (LogWriter.needsLogging) LogWriter.logMessage("Socket was already closed for " + this);
        }
        mySock = null;
      } else {
        if (LogWriter.needsLogging) LogWriter.logMessage("Socket was already null for " + this);
      }

    } catch (Exception ex) {
      if (LogWriter.needsLogging && !stack.toExit) {
        LogWriter.logMessage(
            LogWriter.TRACE_EXCEPTION, "Exception closing message Channel " + this);
        LogWriter.logException(ex);
      }
    } finally {
      this.isRunning = false;
      uncache();
      this.tcpMessageProcessor.useCount--;
      if (LogWriter.needsLogging)
        LogWriter.logMessage("TCP Message Processor use count: " + tcpMessageProcessor.useCount);
    }
  }
  /**
   * 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, Message sipMessage, Class hdrClass, String header, String message)
      throws ParseException {
    if (LogWriter.needsLogging) LogWriter.logException(ex);
    // Log the bad message for later reference.

    if (hdrClass.equals(FromHeader.clazz)
        || hdrClass.equals(ToHeader.clazz)
        || hdrClass.equals(CSeqHeader.clazz)
        || hdrClass.equals(ViaHeader.clazz)
        || hdrClass.equals(CallIdHeader.clazz)
        || hdrClass.equals(RequestLine.clazz)
        || hdrClass.equals(StatusLine.clazz)) {
      stack.logBadMessage(message);
      throw ex;
    } else {
      sipMessage.addUnparsed(header);
    }
  }
  /**
   * Constructor. We create one of these when we send out a message.
   *
   * @param targetAddr internet address of the place where we want to send messages.
   * @param port target port (where we want to send the message).
   * @param stack our SIP Stack.
   */
  public UDPMessageChannel(
      String targetAddr, int port, SIPMessageStack sipStack, UDPMessageProcessor processor) {
    if (LogWriter.needsLogging)
      LogWriter.logMessage(
          LogWriter.TRACE_DEBUG,
          "DEBUG, UDPMessageChannel, UDPMessageChannel(),"
              + " Creating message channel on "
              + targetAddr
              + "/"
              + port);

    stack = sipStack;
    this.peerPort = port;
    this.peerAddress = targetAddr;
    this.messageProcessor = processor;
    this.myPort = processor.getPort();
    this.myAddress = sipStack.getHostAddress();
    this.peerProtocol = "UDP";
  }
  /**
   * Send a message to a specified receiver address.
   *
   * @param msg message string to send.
   * @param receiverAddress Address of the place to send it to.
   * @param receiverPort the port to send it to.
   * @throws IOException If there is trouble sending this message.
   */
  protected void sendMessage(
      byte[] msg, String receiverAddress, int receiverPort, boolean reconnect) throws IOException {
    // msg += "\r\n\r\n";
    // Via is not included in the request so silently drop the reply.
    if (receiverPort == -1) {
      if (LogWriter.needsLogging)
        LogWriter.logMessage(
            "DEBUG, UDPMessageChannel, sendMessage(),"
                + " The message is not sent: the receiverPort=-1");
      throw new IOException("Receiver port not set ");
    }

    try {
      DatagramConnection socket;
      boolean created = false;

      if (stack.udpFlag) {
        // Use the socket from the message processor (for firewall
        // support use the same socket as the message processor
        // socket -- feature request # 18 from java.net). This also
        // makes the whole thing run faster!
        socket = ((UDPMessageProcessor) messageProcessor).dc;

      } else {
        // bind to any interface and port.
        // format: datagram://address:port
        String url = "datagram://" + peerAddress + ":" + peerPort;
        socket = (DatagramConnection) Connector.open(url);
        created = true;
      }

      Datagram reply = socket.newDatagram(msg, msg.length);
      socket.send(reply);
      if (created) socket.close();
    } catch (IOException ex) {
      throw ex;
    } catch (Exception ex) {
      InternalErrorHandler.handleException(ex);
    }
  }
Exemplo n.º 10
0
  /**
   * Constructor - connects to the given inet address. Acknowledgement -- Lamine Brahimi (IBM
   * Zurich) sent in a bug fix for this method. A thread was being unnecessarily created.
   *
   * @param inetAddr inet address to connect to.
   * @param sipStack is the sip stack from which we are created.
   * @param messageProcessor to whom a parsed message is passed
   * @throws IOException if we cannot connect.
   */
  protected TCPMessageChannel(
      String inetAddr, int port, SIPMessageStack sipStack, TCPMessageProcessor messageProcessor)
      throws IOException {

    this.peerAddress = inetAddr;
    this.peerPort = port;
    this.myPort = messageProcessor.getPort();
    this.peerProtocol = "TCP";
    this.stack = sipStack;
    this.tcpMessageProcessor = messageProcessor;
    this.myAddress = sipStack.getHostAddress();
    // Bug report by Vishwashanti Raj Kadiayl
    super.messageProcessor = messageProcessor;
    this.key = "TCP" + ":" + stack.ioHandler.makeKey(peerAddress, peerPort);

    if (LogWriter.needsLogging)
      LogWriter.logMessage(
          "Created new TCP Message Channel "
              + this
              + " with key "
              + key
              + "\nprocessor: "
              + messageProcessor);
  }
Exemplo n.º 11
0
  /**
   * 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(Message sipMessage) {

    if (!stack.isAlive()) {
      if (LogWriter.needsLogging)
        LogWriter.logMessage(
            LogWriter.TRACE_DEBUG,
            "MsgChannel " + this + " is dropping message as the stack is closing");
      return; // drop messages when closing, avoid Exceptions
    }

    try {
      if (LogWriter.needsLogging)
        LogWriter.logMessage(
            "[TCPMessageChannel]-> Processing incoming message: " + sipMessage.getFirstLine());
      if (sipMessage.getFromHeader() == null
          || sipMessage.getTo() == null
          || sipMessage.getCallId() == null
          || sipMessage.getCSeqHeader() == null
          || sipMessage.getViaHeaders() == null) {
        String badmsg = sipMessage.encode();
        if (LogWriter.needsLogging) {
          ServerLog.logMessage("bad message " + badmsg);
          ServerLog.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 Request) {
        ViaHeader v = (ViaHeader) viaList.first();
        if (v.hasPort()) {
          viaPort = v.getPort();
        } else {
          viaPort = SIPMessageStack.DEFAULT_PORT;
        }
        this.peerProtocol = v.getTransport();
        try {
          if (peerPort == -1) peerPort = mySock.getPort();
          this.peerAddress = mySock.getAddress();

          // Log this because it happens when the remote host identifies
          // as a FQDN but this is not resolvable to an IP by the OS.
          // S40 doesn't have DNS settings, for instance, so if the APN
          // is not able to resolve all the addresses of the SIP/IMS core,
          // this problem will appear.
          if (peerAddress == null && LogWriter.needsLogging)
            LogWriter.logMessage(
                LogWriter.TRACE_EXCEPTION, "WARNING! Socket.getAddress() returned 'null'!!!");

          // Be warned, the host comparison may fail if socket.getAddress()
          // returns a domain name as the Via Host will be a numeric IP.
          // FIXME: No idea. Doing a DNS lookup or reverse DNS lookup
          // can be misleading because they can be non-matching, that is,
          // DNS(peerAddressName) != ReverseDNS(peerAddressIP)
          if (v.hasParameter(ViaHeader.RPORT) || !v.getHost().equals(this.peerAddress)) {
            if (LogWriter.needsLogging)
              LogWriter.logMessage(
                  LogWriter.TRACE_MESSAGES,
                  "WARNING! \"Received\" parameter "
                      + "has been temporarily disabled. Response will be sent to topmost Via Host: "
                      + v.getHost());
            this.peerAddress = v.getHost();
            //		                if (LogWriter.needsLogging)
            //			                   LogWriter.logMessage(LogWriter.TRACE_MESSAGES, "Adding
            // \"received\" parameter" +
            //			                   		" to incoming request with value: " + peerAddress +
            //			                   		" because it doesn't match the Via host " + v.getHost());
            //						v.setParameter(ViaHeader.RECEIVED, this.peerAddress);

          }

          if (v.hasParameter(ViaHeader.RPORT))
            v.setParameter(ViaHeader.RPORT, Integer.toString(this.peerPort));

          /*
           * If socket is invalid, close it because it is useless and dangerous.
           * Also if we ran out of slots for new sockets, as this could prevent
           * incoming connections from being accepted.
           */
          if (mySock.getAddress() == null
              || (stack.maxConnections != -1
                  && tcpMessageProcessor.getNumConnections() >= stack.maxConnections)) {
            stack.ioHandler.disposeSocket(mySock, myClientInputStream, myClientOutputStream);
            mySock = null;
            myClientInputStream = null;
            myClientOutputStream = null;
            if (stack.maxConnections != -1) {
              synchronized (tcpMessageProcessor) {
                tcpMessageProcessor.decreaseNumConnections();
                tcpMessageProcessor.notify();
              }
            }
          }
          // reuse socket even for outgoing requests
          else if (!this.isCached) {
            ((TCPMessageProcessor) this.messageProcessor).cacheMessageChannel(this);
            String key = "TCP" + ":" + stack.ioHandler.makeKey(peerAddress, peerPort);
            stack.ioHandler.putSocket(key, mySock, myClientOutputStream, myClientInputStream);
          }

        } catch (IOException e) {
          e.printStackTrace();
        }
      }

      // System.out.println("receiver address = " + receiverAddress);

      // For each part of the request header, fetch it and process it
      long receptionTime = System.currentTimeMillis();

      if (sipMessage instanceof Request) {
        // This is a request - process the request.
        Request sipRequest = (Request) sipMessage;
        // Create a new sever side request processor for this
        // message and let it handle the rest.

        if (LogWriter.needsLogging) {
          LogWriter.logMessage("----Processing Message---");
        }

        // TODO: check maximum size of request

        SIPServerRequestInterface sipServerRequest = stack.newSIPServerRequest(sipRequest, this);

        if (sipServerRequest != null) {
          try {
            sipServerRequest.processRequest(sipRequest, this);

            ServerLog.logMessage(
                sipMessage,
                sipRequest.getViaHost() + ":" + sipRequest.getViaPort(),
                stack.getHostAddress() + ":" + stack.getPort(this.getTransport()),
                false,
                receptionTime);
          } catch (SIPServerException ex) {
            ServerLog.logMessage(
                sipMessage,
                sipRequest.getViaHost() + ":" + sipRequest.getViaPort(),
                stack.getHostAddress() + ":" + stack.getPort(this.getTransport()),
                ex.getMessage(),
                false,
                receptionTime);
            handleException(ex);
          }

        } else {
          if (LogWriter.needsLogging)
            LogWriter.logMessage("Dropping request -- null sipServerRequest");
        }

      } else {
        // This is a response message - process it.
        Response sipResponse = (Response) sipMessage;

        // TODO: check maximum size of the response

        SIPServerResponseInterface sipServerResponse =
            stack.newSIPServerResponse(sipResponse, this);

        if (LogWriter.needsLogging)
          LogWriter.logMessage("got a response interface " + sipServerResponse);

        try {
          // Responses with no ClienTransaction associated will not be processed
          // as they may cause a NPE in the EventScanner thread.
          if (sipServerResponse != null) sipServerResponse.processResponse(sipResponse, this);
          else {
            if (LogWriter.needsLogging) {
              LogWriter.logMessage("null sipServerResponse!");
            }
          }
        } catch (SIPServerException ex) {
          // An error occured processing the message -- just log it.
          ServerLog.logMessage(
              sipMessage,
              getPeerAddress().toString() + ":" + getPeerPort(),
              stack.getHostAddress() + ":" + stack.getPort(this.getTransport()),
              ex.getMessage(),
              false,
              receptionTime);
          // Ignore errors while processing responses??
        }
      }
    } catch (Exception ee) {
      if (stack.isAlive()) {
        throw new RuntimeException(ee.getClass() + ":" + ee.getMessage());
      }
      // else ignore exceptions
    } finally {
      //            this.tcpMessageProcessor.useCount --;
    }
  }
Exemplo n.º 12
0
  /**
   * Send message to whoever is connected to us. Uses the topmost via address to send to.
   *
   * @param message is the message to send.
   */
  private void sendMessage(byte[] msg, boolean retry) throws IOException {

    int portToUse;
    if (viaPort != -1) portToUse = viaPort;
    else portToUse = peerPort;

    if (!this.isRunning && !this.isCached) {
      if (LogWriter.needsLogging)
        LogWriter.logMessage(
            LogWriter.TRACE_MESSAGES,
            "Tried to send message through a Message Channel that is no longer running. Create a new one.");

      TCPMessageChannel newChannel =
          (TCPMessageChannel)
              this.tcpMessageProcessor.createMessageChannel(this.peerAddress, portToUse);
      newChannel.sendMessage(msg, retry);
      return;
    }

    SocketConnection sock =
        stack.ioHandler.sendBytes(this.peerAddress, portToUse, this.peerProtocol, msg, retry);

    /*Fix: don't replace the original socket (where the incoming
    request came from) with the one created to send the response
    to the port specified by the VIA header. This would cause a
    NPE later, as the 'via socket' will be closed shortly after
    sending the response. Thanks to Janos Vig (Genaker) for
    detecting this. */
    if (sock != null
        && (mySock == null || (sock != mySock && sock.getPort() == mySock.getPort()))) {
      try {
        if (mySock != null) {
          if (LogWriter.needsLogging)
            LogWriter.logMessage(
                LogWriter.TRACE_MESSAGES,
                "Closing socket on TCPMessageChannel and replacing with new one");

          // Closing the IO streams will also stop the parser reading from them
          if (myClientOutputStream != null) myClientOutputStream.close();
          if (myClientInputStream != null) myClientInputStream.close();
          mySock.close();

        } else {
          if (LogWriter.needsLogging)
            LogWriter.logMessage(
                LogWriter.TRACE_DEBUG, "TCP Msg channel " + this + " socket was null!");
        }
      } catch (IOException ex) {
        ex.printStackTrace();
      }

      // replace the old references of socket and IO streams
      // to the ones pointing to the newly created socket.
      mySock = sock;
      myClientOutputStream = stack.ioHandler.getSocketOutputStream(mySock);
      myClientInputStream = stack.ioHandler.getSocketInputStream(mySock);

      if (LogWriter.needsLogging)
        LogWriter.logMessage(
            LogWriter.TRACE_DEBUG,
            "Creating new Thread from Message Channel "
                + this
                + " and new socket "
                + sock
                + " IS "
                + myClientInputStream);
      Thread thread = new Thread(this);
      thread.start();
    }
  }
  /**
   * Send a message to a specified receiver address.
   *
   * @param msg message string to send.
   * @param receiverAddress Address of the place to send it to.
   * @param receiverPort the port to send it to.
   * @param receiverProtocol protocol to use to send.
   * @param retry try if connection was not successful at fi
   * @throws IOException If there is trouble sending this message.
   */
  protected void sendMessage(
      byte[] msg, String receiverAddress, int receiverPort, String receiverProtocol, boolean retry)
      throws IOException {
    if (LogWriter.needsLogging)
      LogWriter.logMessage(
          "Sending message to ["
              + receiverAddress
              + ":"
              + receiverPort
              + "/"
              + receiverProtocol
              + "]\n"
              + new String(msg)
              + "  to be sent to  ");

    // msg += "\r\n\r\n";
    // Via is not included in the request so silently drop the reply.
    if (receiverPort == -1) {
      if (LogWriter.needsLogging)
        LogWriter.logMessage(
            "DEBUG, UDPMessageChannel, sendMessage(),"
                + " The message is not sent: the receiverPort=-1");
      throw new IOException("Receiver port not set ");
    }
    if (Utils.compareToIgnoreCase(receiverProtocol, "UDP") == 0) {

      try {
        DatagramConnection socket;
        Datagram reply;
        boolean created = false;

        if (stack.udpFlag) {
          // Use the socket from the message processor (for firewall
          // support use the same socket as the message processor
          // socket -- feature request # 18 from java.net). This also
          // makes the whole thing run faster!
          socket = ((UDPMessageProcessor) messageProcessor).dc;

          // ArnauVP: this has the problem that the datagram created from this (inbound) connection
          // doesn't have an address assigned. Let's do it.
          reply = socket.newDatagram(msg, msg.length);
          reply.setAddress("datagram://" + peerAddress + ":" + peerPort);

        } else {
          // bind to any interface and port.
          // format: datagram://address:port
          socket = stack.getNetworkLayer().createDatagramSocket(peerAddress, peerPort);
          reply = socket.newDatagram(msg, msg.length);
          created = true;
        }
        if (LogWriter.needsLogging)
          LogWriter.logMessage(
              LogWriter.TRACE_DEBUG,
              "UDPMessageChannel, sendMessage(),"
                  + " Sending message over UDP, using socket "
                  + socket
                  + " created "
                  + created
                  + " destination "
                  + reply.getAddress());
        socket.send(reply);
        if (created) socket.close();
      } catch (IOException ex) {
        throw ex;
      } catch (Exception ex) {
        InternalErrorHandler.handleException(ex);
      }

    } else {
      // Use TCP to talk back to the sender.
      SocketConnection outputSocket =
          stack.ioHandler.sendBytes(peerAddress, peerPort, "tcp", msg, retry);
      OutputStream myOutputStream = stack.ioHandler.getSocketOutputStream(outputSocket);
      myOutputStream.write(msg, 0, msg.length);
      myOutputStream.flush();
      // The socket is cached (don't close it!);
    }
  }
  /**
   * Actually process the parsed SIP message.
   *
   * @param sipMessage
   */
  public void processMessage(Message sipMessage) {

    if (sipMessage instanceof Request) {
      Request sipRequest = (Request) sipMessage;

      // This is a request - process it.
      SIPServerRequestInterface sipServerRequest = stack.newSIPServerRequest(sipRequest, this);
      // Drop it if there is no request returned
      if (sipServerRequest == null) {
        if (LogWriter.needsLogging) {
          LogWriter.logMessage("Null request interface returned");
        }
        return;
      }
      try {
        if (LogWriter.needsLogging)
          LogWriter.logMessage(
              "About to process " + sipRequest.getFirstLine() + "/" + sipServerRequest);
        sipServerRequest.processRequest(sipRequest, this);
        if (LogWriter.needsLogging)
          LogWriter.logMessage(
              "Done processing " + sipRequest.getFirstLine() + "/" + sipServerRequest);

        // So far so good -- we will commit this message if
        // all processing is OK.
        if (ServerLog.needsLogging(ServerLog.TRACE_MESSAGES)) {
          if (sipServerRequest.getProcessingInfo() == null) {
            ServerLog.logMessage(
                sipMessage,
                sipRequest.getViaHost() + ":" + sipRequest.getViaPort(),
                stack.getHostAddress() + ":" + stack.getPort(this.getTransport()),
                false,
                new Long(receptionTime).toString());
          } else {
            ServerLog.logMessage(
                sipMessage,
                sipRequest.getViaHost() + ":" + sipRequest.getViaPort(),
                stack.getHostAddress() + ":" + stack.getPort(this.getTransport()),
                sipServerRequest.getProcessingInfo(),
                false,
                new Long(receptionTime).toString());
          }
        }
      } catch (SIPServerException ex) {

        if (ServerLog.needsLogging(ServerLog.TRACE_MESSAGES)) {
          ServerLog.logMessage(
              sipMessage,
              sipRequest.getViaHost() + ":" + sipRequest.getViaPort(),
              stack.getHostAddress() + ":" + stack.getPort(this.getTransport()),
              ex.getMessage(),
              false,
              new Long(receptionTime).toString());
        }
        handleException(ex);
      }

    } else {

      // Handle a SIP Response message.
      Response sipResponse = (Response) sipMessage;
      SIPServerResponseInterface sipServerResponse = stack.newSIPServerResponse(sipResponse, this);
      try {
        if (sipServerResponse != null) {
          sipServerResponse.processResponse(sipResponse, this);
          // Normal processing of message.
        } else {
          if (LogWriter.needsLogging) {
            LogWriter.logMessage("null sipServerResponse!");
          }
        }

      } catch (SIPServerException ex) {
        if (ServerLog.needsLogging(ServerLog.TRACE_MESSAGES)) {
          this.logResponse(sipResponse, receptionTime, ex.getMessage() + "-- Dropped!");
        }

        ServerLog.logException(ex);
      }
    }
  }
  /**
   * Process an incoming datagram
   *
   * @param packet is the incoming datagram packet.
   */
  private void processIncomingDataPacket(Datagram packet) throws Exception {

    // For a request first via header tells where the message
    // is coming from.
    // For response, just get the port from the packet.
    // format: address:port
    String address = packet.getAddress();
    try {
      int firstColon = address.indexOf("//");
      int secondColon = address.indexOf(":", firstColon + 1);
      this.peerAddress = address.substring(firstColon + 2, secondColon);
      if (LogWriter.needsLogging)
        LogWriter.logMessage(
            LogWriter.TRACE_DEBUG, "UDPMessageChannel, run(), sender address:" + peerAddress);
      String senderPortString = address.substring(address.indexOf(";") + 1, address.indexOf("|"));
      this.peerPacketSourcePort = Integer.parseInt(senderPortString);
      if (LogWriter.needsLogging)
        LogWriter.logMessage(
            LogWriter.TRACE_DEBUG, "UDPMessageChannel, run(), sender port:" + peerPacketSourcePort);
    } catch (NumberFormatException e) {

      if (LogWriter.needsLogging)
        LogWriter.logMessage(
            LogWriter.TRACE_EXCEPTION,
            "UDPMessageChannel, run(), exception raised: " + e.getMessage());
      e.printStackTrace();
      peerPacketSourcePort = -1;
    }

    int packetLength = packet.getLength();
    // Read bytes and put it in a queue.
    byte[] msgBytes = packet.getData();

    // Do debug logging.
    if (LogWriter.needsLogging) {
      LogWriter.logMessage(
          LogWriter.TRACE_DEBUG,
          "UDPMessageChannel: processIncomingDataPacket : peerAddress = "
              + peerAddress
              + "/"
              + peerPacketSourcePort
              + " Length = "
              + packetLength
              + " msgBytes "
              + msgBytes);
    }

    Message sipMessage = null;
    try {
      receptionTime = System.currentTimeMillis();
      sipMessage = myParser.parseSIPMessage(msgBytes);
      myParser = null;
    } catch (ParseException ex) {
      myParser = null; // let go of the parser reference.
      if (LogWriter.needsLogging) {
        LogWriter.logMessage(LogWriter.TRACE_DEBUG, "Rejecting message !  " + new String(msgBytes));
        LogWriter.logMessage(LogWriter.TRACE_DEBUG, "error message " + ex.getMessage());
        LogWriter.logException(ex);
      }

      // TODO: do this on TCP too
      // JvB: send a 400 response for requests (except ACK)
      String msgString = new String(msgBytes, 0, packetLength);
      if (!msgString.startsWith("SIP/") && !msgString.startsWith("ACK ")) {

        String badReqRes = create400Response(msgString, ex);
        if (badReqRes != null) {
          if (LogWriter.needsLogging)
            LogWriter.logMessage(
                LogWriter.TRACE_DEBUG, "Sending automatic 400 Bad Request: " + badReqRes);
          try {
            this.sendMessage(badReqRes.getBytes(), peerAddress, peerPacketSourcePort, "UDP", false);
          } catch (IOException e) {
            LogWriter.logException(e);
          }
        } else {
          if (LogWriter.needsLogging)
            LogWriter.logMessage(
                LogWriter.TRACE_DEBUG, "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 (LogWriter.needsLogging)
        LogWriter.logMessage(LogWriter.TRACE_DEBUG, "Rejecting message !  + Null message parsed.");
      return;
    }

    ViaList viaList = sipMessage.getViaHeaders();

    // Check for the required headers.
    if (sipMessage.getFromHeader() == null
        ||
        // sipMessage.getFromHeader().getTag() == null  ||
        sipMessage.getTo() == null
        || sipMessage.getCallId() == null
        || sipMessage.getCSeqHeader() == null
        || sipMessage.getViaHeaders() == null) {
      String badmsg = new String(msgBytes);
      if (LogWriter.needsLogging) {
        LogWriter.logMessage("bad message " + badmsg);
        LogWriter.logMessage(
            ">>> Dropped Bad Msg "
                + "FromHeader = "
                + sipMessage.getFromHeader()
                + "ToHeader = "
                + sipMessage.getTo()
                + "CallId = "
                + sipMessage.getCallId()
                + "CSeqHeader = "
                + sipMessage.getCSeqHeader()
                + "Via = "
                + sipMessage.getViaHeaders());
      }

      stack.logBadMessage(badmsg);
      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 Request) {

      ViaHeader v = (ViaHeader) viaList.first();
      if (v.hasPort()) this.peerPort = v.getPort();
      else this.peerPort = SIPMessageStack.DEFAULT_PORT;

      this.peerProtocol = v.getTransport();

      boolean hasRPort = v.hasParameter(ViaHeader.RPORT);
      // Be warned, the host comparison may fail if socket.getAddress()
      // returns a domain name as the Via Host will be a numeric IP.
      // FIXME: No idea. Doing a DNS lookup or reverse DNS lookup
      // can be misleading because they can be non-matching, that is,
      // DNS(peerAddressName) != ReverseDNS(peerAddressIP)
      if (hasRPort || !this.peerAddress.equals(v.getHost())) {
        if (LogWriter.needsLogging)
          LogWriter.logMessage(
              LogWriter.TRACE_MESSAGES,
              "WARNING! \"Received\" parameter "
                  + "has been temporarily disabled. Response will be sent to topmost Via Host: "
                  + v.getHost());
        this.peerAddress = v.getHost();
        //                if (LogWriter.needsLogging)
        //	                   LogWriter.logMessage(LogWriter.TRACE_MESSAGES, "Adding \"received\"
        // parameter" +
        //	                   		" to incoming request with value: " + peerAddress +
        //	                   		" because it doesn't match the Via host " + v.getHost());
        //				v.setParameter(ViaHeader.RECEIVED, this.peerAddress);
      }

      if (hasRPort) {
        v.setParameter(ViaHeader.RPORT, Integer.toString(peerPacketSourcePort));
        this.peerPort = peerPacketSourcePort;
      }

    } else {
      this.peerPort = this.peerPacketSourcePort;
      this.peerProtocol = ((ViaHeader) viaList.getFirst()).getTransport();
    }

    processMessage(sipMessage);
  }