Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Conditions Of Use 
   * 
   * This software was developed by employees of the National Institute of
   * Standards and Technology (NIST), an agency of the Federal Government.
   * Pursuant to title 15 Untied States Code Section 105, works of NIST
   * employees are not subject to copyright protection in the United States
   * and are considered to be in the public domain.  As a result, a formal
   * license is not needed to use the software.
  * 
  * This software is provided by NIST as a service and is expressly
  * provided "AS IS."  NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
  * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
  * AND DATA ACCURACY.  NIST does not warrant or make any representations
  * regarding the use of the software or the results thereof, including but
  * not limited to the correctness, accuracy, reliability or usefulness of
  * the software.
  * 
  * Permission to use this software is contingent upon your acceptance
  * of the terms of this agreement
  *  
  * .
  * 
  */
Product of NIST/ITL Advanced Networking Technologies Division (ANTD). * /
 
 package gov.nist.javax.sip.stack;
 
 import java.net.*;
 import java.util.*;
 
 /*
  * Acknowledgement: Jeff Keyser suggested that a Stop mechanism be added to this. Niklas Uhrberg
  * suggested that a means to limit the number of simultaneous active connections should be added.
  * Mike Andrews suggested that the thread be accessible so as to implement clean stop using
  * Thread.join(). Roger M. Persson contributed a bug fix for cleanup on stop().
  * 
  */

Sit in a loop waiting for incoming tcp connections and start a new thread to handle each new connection. This is the active object that creates new TCP MessageChannels (one for each new accept socket).

Author(s):
M. Ranganathan
Version:
1.2 $Revision: 1.31 $ $Date: 2009/08/31 16:18:00 $
 
 public class TCPMessageProcessor extends MessageProcessor {
 
     protected int nConnections;
 
     private boolean isRunning;
 
     private Hashtable tcpMessageChannels;
 
 
     private ServerSocket sock;
 
     protected int useCount;

    
Constructor.

Parameters:
sipStack SIPStack structure.
port port where this message processor listens.
 
     protected TCPMessageProcessor(InetAddress ipAddressSIPTransactionStack sipStackint port) {
         super(ipAddressport"tcp",sipStack);
 
         this. = sipStack;
 
         this. = new Hashtable();
         this. = new ArrayList<TCPMessageChannel>();
     }

    
Start the processor.
 
     public void start() throws IOException {
         Thread thread = new Thread(this);
         thread.setName("TCPMessageProcessorThread");
         thread.setPriority(.);
         thread.setDaemon(true);
         this. = .getNetworkLayer().createServerSocket(getPort(), 0, getIpAddress());
         if (getIpAddress().getHostAddress().equals()
                 || getIpAddress().getHostAddress().equals()) {
             // Store the address to which we are actually bound
             super.setIpAddress(.getInetAddress());
        }
        this. = true;
        thread.start();
    }

    
Run method for the thread that gets created for each accept socket.
    public void run() {
        // Accept new connectins on our socket.
        while (this.) {
            try {
                synchronized (this) {
                    // sipStack.maxConnections == -1 means we are
                    // willing to handle an "infinite" number of
                    // simultaneous connections (no resource limitation).
                    // This is the default behavior.
                    while (. != -1
                            && this. >= .) {
                        try {
                            this.wait();
                            if (!this.)
                                return;
                        } catch (InterruptedException ex) {
                            break;
                        }
                    }
                    this.++;
                }
                Socket newsock = .accept();
                if (.isLoggingEnabled()) {
                    getSIPStack().getStackLogger().logDebug("Accepting new connection!");
                }
                // Note that for an incoming message channel, the
                // thread is already running
               
                .add(new TCPMessageChannel(newsockthis));
            } catch (SocketException ex) {
                this. = false;
            } catch (IOException ex) {
                // Problem accepting connection.
                if (.isLoggingEnabled())
                    getSIPStack().getStackLogger().logException(ex);
                continue;
            } catch (Exception ex) {
                InternalErrorHandler.handleException(ex);
            }
        }
    }

    
Return the transport string.

Returns:
the transport string
    public String getTransport() {
        return "tcp";
    }

    
Returns the stack.

Returns:
my sip stack.
    public SIPTransactionStack getSIPStack() {
        return ;
    }

    
Stop the message processor. Feature suggested by Jeff Keyser.
    public synchronized void stop() {
         = false;
        // this.listeningPoint = null;
        try {
            .close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        Collection en = .values();
        for (Iterator it = en.iterator(); it.hasNext();) {
            TCPMessageChannel next = (TCPMessageChannelit.next();
            next.close();
        }
        // RRPN: fix
        for (Iterator incomingMCIterator = .iterator(); incomingMCIterator
                .hasNext();) {
            TCPMessageChannel next = (TCPMessageChannelincomingMCIterator.next();
            next.close();
        }
        this.notify();
    }
    protected synchronized void remove(TCPMessageChannel tcpMessageChannel) {
        String key = tcpMessageChannel.getKey();
        if (.isLoggingEnabled()) {
            .getStackLogger().logDebug(Thread.currentThread() + " removing " + key);
        }

        
May have been removed already
        if (.get(key) == tcpMessageChannel) {
            this..remove(key);
        }
        .remove(tcpMessageChannel);
    }
    public synchronized MessageChannel createMessageChannel(HostPort targetHostPort)
            throws IOException {
        String key = MessageChannel.getKey(targetHostPort"TCP");
        if (.get(key) != null) {
            return (TCPMessageChannelthis..get(key);
        } else {
            TCPMessageChannel retval = new TCPMessageChannel(targetHostPort.getInetAddress(),
                    targetHostPort.getPort(), this);
            this..put(keyretval);
            retval.isCached = true;
            if (.isLoggingEnabled()) {
                .getStackLogger().logDebug("key " + key);
                .getStackLogger().logDebug("Creating " + retval);
            }
            return retval;
        }
    }
    protected synchronized void cacheMessageChannel(TCPMessageChannel messageChannel) {
        String key = messageChannel.getKey();
        TCPMessageChannel currentChannel = (TCPMessageChannel.get(key);
        if (currentChannel != null) {
            if (.isLoggingEnabled())
                .getStackLogger().logDebug("Closing " + key);
            currentChannel.close();
        }
        if (.isLoggingEnabled())
            .getStackLogger().logDebug("Caching " + key);
        this..put(keymessageChannel);
    }
    public synchronized MessageChannel createMessageChannel(InetAddress hostint port)
            throws IOException {
        try {
            String key = MessageChannel.getKey(hostport"TCP");
            if (.get(key) != null) {
                return (TCPMessageChannelthis..get(key);
            } else {
                TCPMessageChannel retval = new TCPMessageChannel(hostportthis);
                this..put(keyretval);
                retval.isCached = true;
                if (.isLoggingEnabled()) {
                    .getStackLogger().logDebug("key " + key);
                    .getStackLogger().logDebug("Creating " + retval);
                }
                return retval;
            }
        } catch (UnknownHostException ex) {
            throw new IOException(ex.getMessage());
        }
    }

    
TCP can handle an unlimited number of bytes.
    public int getMaximumMessageSize() {
        return .;
    }
    public boolean inUse() {
        return this. != 0;
    }

    
Default target port for TCP
    public int getDefaultTargetPort() {
        return 5060;
    }

    
TCP is not a secure protocol.
    public boolean isSecure() {
        return false;
    }
New to GrepCode? Check out our FAQ X