java/gov/nist/javax/sip/stack/MessageProcessor.java - fp2-dev/platform/external/nist-sip - Gitiles

 /*
 * 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
 *
 * .
 *
 */
 package gov.nist.javax.sip.stack;

 import gov.nist.core.Host;
 import gov.nist.core.HostPort;
 import gov.nist.core.InternalErrorHandler;
 import gov.nist.javax.sip.ListeningPointImpl;
 import gov.nist.javax.sip.header.Via;

 import java.io.IOException;
 import java.net.InetAddress;
 import java.text.ParseException;

 import javax.sip.InvalidArgumentException;

 /**
  * This is the Stack abstraction for the active object that waits for messages
  * to appear on the wire and processes these messages by calling the
  * MessageFactory interface to create a ServerRequest or ServerResponse object.
  * The main job of the message processor is to instantiate message channels for
  * the given transport.
  *
  * @version 1.2 $Revision: 1.18 $ $Date: 2009/10/16 22:58:41 $
  *
  * @author M. Ranganathan <br/>
  *
  */
 public abstract class MessageProcessor implements Runnable {
     /**
      * A string containing the 0.0.0.0 IPv4 ANY address.
      */
     protected static final String IN_ADDR_ANY = "0.0.0.0";

     /**
      * A string containing the ::0 IPv6 ANY address.
      */
     protected static final String IN6_ADDR_ANY = "::0";
     /**
      * My Sent by string ( which I use to set the outgoing via header)
      */
     private  String sentBy;

     private HostPort sentByHostPort;

     /*
      * The IP Address that was originally assigned ( Can be ANY )
      */

     private String savedIpAddress;

     /**
      * The IP address where I am listening.
      */
     private InetAddress ipAddress;

     /**
      * The port where I am listening
      */
     private int port;

     /**
      * The transport where I am listening
      */
     protected String transport;

     /**
      * The Listening Point to which I am assigned.
      */
     private ListeningPointImpl listeningPoint;

     private boolean sentBySet;

     /**
      * Our stack (that created us).
      */
     protected SIPTransactionStack sipStack;

     protected MessageProcessor( String transport ) {
     	this.transport = transport;
     }

     /**
      * Constructor
      *
      * @param ipAddress -- ip address where I am listening for incoming requests.
      * @param port -- port where i am listening for incoming requests.
      * @param transport -- transport to use for the message processor (UDP/TCP/TLS).
      */
     protected MessageProcessor( InetAddress ipAddress, int port, String transport,
     							SIPTransactionStack transactionStack ) {
     	this( transport );
     	this.initialize(ipAddress, port, transactionStack);
     }

     /**
      * Initializes this MessageProcessor. Needed for extensions
      * that use classloading
      *
      * @param ipAddress2
      * @param transactionStack
      * @param port2
      */
 	public final void initialize( InetAddress ipAddress, int port,
 			SIPTransactionStack transactionStack ) {

 		this.sipStack = transactionStack;
         this.savedIpAddress = ipAddress.getHostAddress();
         this.ipAddress = ipAddress;
         this.port = port;
         this.sentByHostPort = new HostPort();
         this.sentByHostPort.setHost(new Host(ipAddress.getHostAddress()));
         this.sentByHostPort.setPort(port);
 	}

     /**
      * Get the transport string.
      *
      * @return A string that indicates the transport. (i.e. "tcp" or "udp")
      */
     public String getTransport() {
         return this.transport;
     }

     /**
      * Get the port identifier.
      *
      * @return the port for this message processor. This is where you receive
      *         messages.
      */
     public int getPort() {
         return this.port;
     }

     /**
      * Get the Via header to assign for this message processor. The topmost via
      * header of the outoging messages use this.
      *
      * @return the ViaHeader to be used by the messages sent via this message processor.
      */
     public Via getViaHeader() {
         try {
             Via via = new Via();
             if (this.sentByHostPort != null) {
                 via.setSentBy(sentByHostPort);
                 via.setTransport(this.getTransport());
             } else {
                 Host host = new Host();
                 host.setHostname(this.getIpAddress().getHostAddress());
                 via.setHost(host);
                 via.setPort(this.getPort());
                 via.setTransport(this.getTransport());
             }
             return via;
         } catch (ParseException ex) {
             ex.printStackTrace();
             return null;
         } catch (InvalidArgumentException ex) {
             ex.printStackTrace();
             return null;
         }
     }
     public ListeningPointImpl getListeningPoint() {
         if ( listeningPoint == null )  {
             if ( this.getSIPStack().isLoggingEnabled()) {
                 this.getSIPStack().getStackLogger().logError("getListeningPoint" + this +
                         " returning null listeningpoint");

             }
         }
         return listeningPoint;
     }

     public void setListeningPoint(ListeningPointImpl lp) {
         if ( this.getSIPStack().isLoggingEnabled()) {
             this.getSIPStack().getStackLogger().logDebug("setListeningPoint" + this +
                     " listeningPoint = " + lp);

         }
         if ( lp.getPort() != this.getPort())
             InternalErrorHandler.handleException
             ("lp mismatch with provider",getSIPStack().getStackLogger());
         this.listeningPoint = lp;

     }

     /**
      * Get the saved IP Address.
      */
     public String getSavedIpAddress() {
         return this.savedIpAddress;
     }
     /**
      * @return the ip address for this message processor.
      */
     public InetAddress getIpAddress() {
           return this.ipAddress;
     }
     /**
      * @param ipAddress the ipAddress to set
      */
     protected void setIpAddress(InetAddress ipAddress) {
         this.sentByHostPort.setHost( new Host(ipAddress.getHostAddress()));
         this.ipAddress = ipAddress;
     }

     /**
      * Set the sentby string. This is used for stamping outgoing messages sent
      * from this listening point.
      *
      * @param sentBy
      */
     public void setSentBy(String sentBy) throws ParseException {

         int ind = sentBy.indexOf(":");
         if (ind == -1) {
             this.sentByHostPort = new HostPort();
             this.sentByHostPort.setHost(new Host(sentBy));
         } else {
             this.sentByHostPort = new HostPort();
             this.sentByHostPort.setHost(new Host(sentBy.substring(0, ind)));
             String portStr = sentBy.substring(ind + 1);
             try {
                 int port = Integer.parseInt(portStr);
                 this.sentByHostPort.setPort(port);
             } catch (NumberFormatException ex) {
                 throw new ParseException("Bad format encountered at ", ind);
             }
         }
         this.sentBySet = true;
         this.sentBy = sentBy;

     }

     /**
      * Get the sentby string.
      *
      */
     public String getSentBy() {
         if ( this.sentBy == null && this.sentByHostPort != null) {
             this.sentBy = this.sentByHostPort.toString();
         }
         return this.sentBy;
     }

     ////////////////////////////////////////////////////////////////////////////////////////
     // Abstract methods
     ///////////////////////////////////////////////////////////////////////////////////////
     /**
      * Get the SIP Stack.
      *
      * @return the sip stack.
      */
     public abstract SIPTransactionStack getSIPStack();

     /**
      * Create a message channel for the specified host/port.
      *
      * @return New MessageChannel for this processor.
      */
     public abstract MessageChannel createMessageChannel(HostPort targetHostPort)
             throws IOException;

     /**
      * Create a message channel for the specified host/port.
      *
      * @return New MessageChannel for this processor.
      */
     public abstract MessageChannel createMessageChannel(InetAddress targetHost,
             int port) throws IOException;


     /**
      * Start our thread.
      */
     public abstract void start() throws IOException;

     /**
      * Stop method.
      */
     public abstract void stop();

     /**
      * Default target port used by this processor. This is 5060 for TCP / UDP
      */
     public abstract int getDefaultTargetPort();

     /**
      * Flags whether this processor is secure or not.
      */
     public abstract boolean isSecure();

     /**
      * Maximum number of bytes that this processor can handle.
      */
     public abstract int getMaximumMessageSize();

     /**
      * Return true if there are pending messages to be processed (which prevents
      * the message channel from being closed).
      */
     public abstract boolean inUse();


     /**
      * Run method.
      */
     public abstract void run();

     /**
      * @return Returns the sentBySet.
      */
     public boolean isSentBySet() {
         return sentBySet;
     }


     /**
      * Get the defalt port for the message processor.
      *
      * @param transport
      * @return -- the default port for the message processor.
      */

     public static int getDefaultPort(String transport) {

         return transport.equalsIgnoreCase("TLS")?5061:5060;
     }


 }
	/*
	* 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
	*
	* .
	*
	*/
	package gov.nist.javax.sip.stack;

	import gov.nist.core.Host;
	import gov.nist.core.HostPort;
	import gov.nist.core.InternalErrorHandler;
	import gov.nist.javax.sip.ListeningPointImpl;
	import gov.nist.javax.sip.header.Via;

	import java.io.IOException;
	import java.net.InetAddress;
	import java.text.ParseException;

	import javax.sip.InvalidArgumentException;

	/**
	* This is the Stack abstraction for the active object that waits for messages
	* to appear on the wire and processes these messages by calling the
	* MessageFactory interface to create a ServerRequest or ServerResponse object.
	* The main job of the message processor is to instantiate message channels for
	* the given transport.
	*
	* @version 1.2 $Revision: 1.18 $ $Date: 2009/10/16 22:58:41 $
	*
	* @author M. Ranganathan <br/>
	*
	*/
	public abstract class MessageProcessor implements Runnable {
	/**
	* A string containing the 0.0.0.0 IPv4 ANY address.
	*/
	protected static final String IN_ADDR_ANY = "0.0.0.0";

	/**
	* A string containing the ::0 IPv6 ANY address.
	*/
	protected static final String IN6_ADDR_ANY = "::0";
	/**
	* My Sent by string ( which I use to set the outgoing via header)
	*/
	private String sentBy;

	private HostPort sentByHostPort;

	/*
	* The IP Address that was originally assigned ( Can be ANY )
	*/

	private String savedIpAddress;

	/**
	* The IP address where I am listening.
	*/
	private InetAddress ipAddress;

	/**
	* The port where I am listening
	*/
	private int port;

	/**
	* The transport where I am listening
	*/
	protected String transport;

	/**
	* The Listening Point to which I am assigned.
	*/
	private ListeningPointImpl listeningPoint;

	private boolean sentBySet;

	/**
	* Our stack (that created us).
	*/
	protected SIPTransactionStack sipStack;

	protected MessageProcessor( String transport ) {
	this.transport = transport;
	}

	/**
	* Constructor
	*
	* @param ipAddress -- ip address where I am listening for incoming requests.
	* @param port -- port where i am listening for incoming requests.
	* @param transport -- transport to use for the message processor (UDP/TCP/TLS).
	*/
	protected MessageProcessor( InetAddress ipAddress, int port, String transport,
	SIPTransactionStack transactionStack ) {
	this( transport );
	this.initialize(ipAddress, port, transactionStack);
	}

	/**
	* Initializes this MessageProcessor. Needed for extensions
	* that use classloading
	*
	* @param ipAddress2
	* @param transactionStack
	* @param port2
	*/
	public final void initialize( InetAddress ipAddress, int port,
	SIPTransactionStack transactionStack ) {

	this.sipStack = transactionStack;
	this.savedIpAddress = ipAddress.getHostAddress();
	this.ipAddress = ipAddress;
	this.port = port;
	this.sentByHostPort = new HostPort();
	this.sentByHostPort.setHost(new Host(ipAddress.getHostAddress()));
	this.sentByHostPort.setPort(port);
	}

	/**
	* Get the transport string.
	*
	* @return A string that indicates the transport. (i.e. "tcp" or "udp")
	*/
	public String getTransport() {
	return this.transport;
	}

	/**
	* Get the port identifier.
	*
	* @return the port for this message processor. This is where you receive
	* messages.
	*/
	public int getPort() {
	return this.port;
	}

	/**
	* Get the Via header to assign for this message processor. The topmost via
	* header of the outoging messages use this.
	*
	* @return the ViaHeader to be used by the messages sent via this message processor.
	*/
	public Via getViaHeader() {
	try {
	Via via = new Via();
	if (this.sentByHostPort != null) {
	via.setSentBy(sentByHostPort);
	via.setTransport(this.getTransport());
	} else {
	Host host = new Host();
	host.setHostname(this.getIpAddress().getHostAddress());
	via.setHost(host);
	via.setPort(this.getPort());
	via.setTransport(this.getTransport());
	}
	return via;
	} catch (ParseException ex) {
	ex.printStackTrace();
	return null;
	} catch (InvalidArgumentException ex) {
	ex.printStackTrace();
	return null;
	}
	}
	public ListeningPointImpl getListeningPoint() {
	if ( listeningPoint == null ) {
	if ( this.getSIPStack().isLoggingEnabled()) {
	this.getSIPStack().getStackLogger().logError("getListeningPoint" + this +
	" returning null listeningpoint");

	}
	}
	return listeningPoint;
	}

	public void setListeningPoint(ListeningPointImpl lp) {
	if ( this.getSIPStack().isLoggingEnabled()) {
	this.getSIPStack().getStackLogger().logDebug("setListeningPoint" + this +
	" listeningPoint = " + lp);

	}
	if ( lp.getPort() != this.getPort())
	InternalErrorHandler.handleException
	("lp mismatch with provider",getSIPStack().getStackLogger());
	this.listeningPoint = lp;

	}

	/**
	* Get the saved IP Address.
	*/
	public String getSavedIpAddress() {
	return this.savedIpAddress;
	}
	/**
	* @return the ip address for this message processor.
	*/
	public InetAddress getIpAddress() {
	return this.ipAddress;
	}
	/**
	* @param ipAddress the ipAddress to set
	*/
	protected void setIpAddress(InetAddress ipAddress) {
	this.sentByHostPort.setHost( new Host(ipAddress.getHostAddress()));
	this.ipAddress = ipAddress;
	}

	/**
	* Set the sentby string. This is used for stamping outgoing messages sent
	* from this listening point.
	*
	* @param sentBy
	*/
	public void setSentBy(String sentBy) throws ParseException {

	int ind = sentBy.indexOf(":");
	if (ind == -1) {
	this.sentByHostPort = new HostPort();
	this.sentByHostPort.setHost(new Host(sentBy));
	} else {
	this.sentByHostPort = new HostPort();
	this.sentByHostPort.setHost(new Host(sentBy.substring(0, ind)));
	String portStr = sentBy.substring(ind + 1);
	try {
	int port = Integer.parseInt(portStr);
	this.sentByHostPort.setPort(port);
	} catch (NumberFormatException ex) {
	throw new ParseException("Bad format encountered at ", ind);
	}
	}
	this.sentBySet = true;
	this.sentBy = sentBy;

	}

	/**
	* Get the sentby string.
	*
	*/
	public String getSentBy() {
	if ( this.sentBy == null && this.sentByHostPort != null) {
	this.sentBy = this.sentByHostPort.toString();
	}
	return this.sentBy;
	}

	////////////////////////////////////////////////////////////////////////////////////////
	// Abstract methods
	///////////////////////////////////////////////////////////////////////////////////////
	/**
	* Get the SIP Stack.
	*
	* @return the sip stack.
	*/
	public abstract SIPTransactionStack getSIPStack();

	/**
	* Create a message channel for the specified host/port.
	*
	* @return New MessageChannel for this processor.
	*/
	public abstract MessageChannel createMessageChannel(HostPort targetHostPort)
	throws IOException;

	/**
	* Create a message channel for the specified host/port.
	*
	* @return New MessageChannel for this processor.
	*/
	public abstract MessageChannel createMessageChannel(InetAddress targetHost,
	int port) throws IOException;


	/**
	* Start our thread.
	*/
	public abstract void start() throws IOException;

	/**
	* Stop method.
	*/
	public abstract void stop();

	/**
	* Default target port used by this processor. This is 5060 for TCP / UDP
	*/
	public abstract int getDefaultTargetPort();

	/**
	* Flags whether this processor is secure or not.
	*/
	public abstract boolean isSecure();

	/**
	* Maximum number of bytes that this processor can handle.
	*/
	public abstract int getMaximumMessageSize();

	/**
	* Return true if there are pending messages to be processed (which prevents
	* the message channel from being closed).
	*/
	public abstract boolean inUse();



	/**
	* Run method.
	*/
	public abstract void run();

	/**
	* @return Returns the sentBySet.
	*/
	public boolean isSentBySet() {
	return sentBySet;
	}


	/**
	* Get the defalt port for the message processor.
	*
	* @param transport
	* @return -- the default port for the message processor.
	*/

	public static int getDefaultPort(String transport) {

	return transport.equalsIgnoreCase("TLS")?5061:5060;
	}



	}