requestforwarding.java

基于JAINSIP的一个proxy源码

/*
 * RequestForwarding.java
 *
 * Created on April 16, 2003, 11:08 AM
 */

package gov.nist.sip.proxy;
import java.util.*;
import javax.sip.*;
import javax.sip.message.*;
import javax.sip.header.*;
import javax.sip.address.*;
import gov.nist.sip.proxy.presenceserver.*;
/**
 *
 * @author Deruelle
 */
public class RequestForwarding {
    
    protected Proxy proxy;
    
    
    /** Creates a new instance of RequestForwarding */
    public RequestForwarding(Proxy proxy) {
       this.proxy=proxy;
    }
    
    public void forwardRequest
	(Vector targetsURIList,
	SipProvider sipProvider,
        Request request,
	ServerTransaction serverTransaction,
	boolean statefullForwarding) {
        /* RFC 3261: 16.6. Request Forwarding
         * For each target, the proxy forwards the request following these steps:
         *
         * 1.  Make a copy of the received request
         *
         * 2.  Update the Request-URI
         *
         * 3.  Update the Max-Forwards header field
         *
         * 4.  Optionally add a Record-route header field value
         *
         * 5.  Optionally add additional header fields
         *
         * 6.  Postprocess routing information
         *
         * 7.  Determine the next-hop address, port, and transport
         *
         * 8.  Add a Via header field value
         *
         * 9.  Add a Content-Length header field if necessary
         *
         * 10. Forward the new request
         *
         * 11. Set timer C
         */
        MessageFactory messageFactory=proxy.getMessageFactory();
        HeaderFactory headerFactory=proxy.getHeaderFactory();
        SipStack sipStack=proxy.getSipStack();
        AddressFactory addressFactory=proxy.getAddressFactory();
        //Get the parameters and the transport of the request URI
        URI requestURI=request.getRequestURI();
        Iterator parametersNames=null;
        String transport=null;
        System.out.println(requestURI.toString());
        if(requestURI.isSipURI()){
        	parametersNames=((SipURI)requestURI).getParameterNames();
        	transport=((SipURI)requestURI).getTransportParam();
        }        
        
        try{
            
            for (int i=0;i<targetsURIList.size();i++) {
                
                URI targetURI=(URI)targetsURIList.elementAt(i);
                //Copy the parameters and the transport in the new Request URI 
                //of the cloned Request
/**************************************************************************/
/************** 1.  Make a of received request                   **********/
/**************************************************************************/				
                Request clonedRequest = (Request) request.clone();
                if (ProxyDebug.debug)
                   ProxyDebug.println
		   ("RequestForwarding, forwardRequest() (STEP 1),"+
                   " the request is cloned");
/***************************************************************************/
/************** 2.  Update the Request-URI                        **********/
/***************************************************************************/
                
                /*
                The Request-URI in the copy's start line MUST be replaced with
                the URI for this target.  If the URI contains any parameters
                not allowed in a Request-URI, they MUST be removed.

		This is the essence of a proxy's role.  This is the mechanism
         	through which a proxy routes a request toward its destination.

         	In some circumstances, the received Request-URI is placed into
         	the target set without being modified.  For that target, the
         	replacement above is effectively a no-op.
		
		Note -- this should only be done if the target domain is
		managed by the proxy server.
		Bug fix by Daniel Martinez.
                 */
                // All the targets URI are already canonicalized

		if (requestURI.isSipURI()) {
			if ( proxy.managesDomain(((SipURI)requestURI).getHost())) {
				clonedRequest.setRequestURI(targetURI);
                		if (ProxyDebug.debug) {
                   			ProxyDebug.println
		    			("RequestForwarding, forwardRequest() (STEP 2),"+
                   			" The Request-URI in the copy's start line is replaced with"+
                   			" the URI for this target");
				}
			} else {
                		if (ProxyDebug.debug) {
                   			ProxyDebug.println
		    			("RequestForwarding, forwardRequest() (STEP 2),"+
					"the proxy does not manage the domain " + 
					((SipURI)targetURI).getHost());
				}
			}
		}
                
/**************************************************************************/
/************** 3. Max-Forwards                                  **********/
/**************************************************************************/
                /*
                If the copy contains a Max-Forwards header field, the proxy
                MUST decrement its value by one (1).
                If the copy does not contain a Max-Forwards header field, the
                proxy MUST add one with a field value, which SHOULD be 70.
                 */
                
                // RequestValidation took already care 
	        // to check if the header has
                // reached 0.
                MaxForwardsHeader mf = 
			(MaxForwardsHeader) clonedRequest.getHeader
                (MaxForwardsHeader.NAME);
                if (mf == null) {
                    if (ProxyDebug.debug)
                        ProxyDebug.println
			("RequestForwarding, forwardRequest() "+
                        " (STEP 3), MaxForwardHeader "+
                        " created and added to the cloned request");
                    mf=headerFactory.createMaxForwardsHeader(70);
                    clonedRequest.addHeader(mf);
                }
                else  {
                    if (ProxyDebug.debug)
                        ProxyDebug.println
			("RequestForwarding, forwardRequest(), "+
                        " (STEP 3) MaxForwardHeader "+
                        " decremented by one.");
                    mf.setMaxForwards(mf.getMaxForwards() - 1);
                }
                
/***************************************************************************/
/************** 4. Record-Route                                   **********/
/***************************************************************************/
                
                /*
                The URI placed in the Record-Route header field value MUST be a
                SIP or SIPS URI.  This URI MUST contain an lr parameter (see
                Section 19.1.1).  This URI MAY be different for each
                destination the request is forwarded to.
                The URI SHOULD NOT contain the transport parameter.
                 */
                
                // Only in statefull forwarding
                // We add our proxy RecordRoute header to the top of the list
                // We take the first listening point.
               
                String stackIPAddress=sipStack.getIPAddress();
                /* Iterator lps=sipStack.getListeningPoints();
                ListeningPoint lp=(ListeningPoint)lps.next();
		*/
	     	ListeningPoint lp=sipProvider.getListeningPoint();
                 if (statefullForwarding) {
               	SipURI sipURI=addressFactory.createSipURI(null,stackIPAddress);
                sipURI.setPort(lp.getPort());
                
                Address address=addressFactory.createAddress(null,sipURI);
                RecordRouteHeader recordRouteHeader=
                headerFactory.createRecordRouteHeader(address);
                
                // lr parameter to add:
                
                ListIterator recordRouteHeaders=clonedRequest.getHeaders
                (RecordRouteHeader.NAME);
                clonedRequest.removeHeader(RecordRouteHeader.NAME);
                Vector v=new Vector();
                v.addElement(recordRouteHeader);
                // add the other record route headers.
                while( recordRouteHeaders!=null 
			&& recordRouteHeaders.hasNext()) {
                    recordRouteHeader=
			(RecordRouteHeader)recordRouteHeaders.next();
                    v.addElement(recordRouteHeader);
                }
                for (int j=0;j<v.size();j++) {
                    recordRouteHeader=(RecordRouteHeader)v.elementAt(j);
                    clonedRequest.addHeader(recordRouteHeader);
                }
                
                if (ProxyDebug.debug)
                    ProxyDebug.println
		    ("RequestForwarding, forwardRequest(), (STEP 4)"+
                    " record-route header created and added to the " +
		    " cloned request");
                }
                else {
                    if (ProxyDebug.debug)
                    ProxyDebug.println
		    ("RequestForwarding, forwardRequest(), (STEP 4)"+
                    " record-route header not added to the cloned request " +
		    " (stateless)");
                }
                
/****************************************************************************/
/************** 5. Add Additional Header Fields                     **********/
/*****************************************************************************/
                
                // No Additional headers to add...
                if (ProxyDebug.debug)
                    ProxyDebug.println
		    ("RequestForwarding, forwardRequest(), (STEP 5)"+
                    " No Additional headers to add...");
                
/***************************************************************************/
/************** 6. Postprocess routing information                **********/
/***************************************************************************/
                
                /* If the copy contains a Route header field, 
		   the proxy MUST inspect the URI in its first value.  
		   If that URI does not
                   contain an lr parameter, the proxy MUST modify the copy as
                   follows:
                 
                   -  The proxy MUST place the Request-URI into the 
			Route header field as the last value.
                 
                   -  The proxy MUST then place the first Route header 
		      field value into the Request-URI and remove that 
		      value from the Route header field.
                 */
              
                // Strip first route if it is the proxy UIR adn lr parameter
                
                ListIterator routes = 
		    clonedRequest.getHeaders(RouteHeader.NAME);
                if (routes!=null && routes.hasNext() ) {
                
                    RouteHeader  routeHeader = (RouteHeader) routes.next();
                    Address routeAddress=routeHeader.getAddress();
                    URI routeURI=routeAddress.getURI();
                
                    if (  routeURI.isSipURI() && 
			((SipURI)routeURI).hasLrParam() ) {
                        
                        String host=((SipURI)routeURI).getHost();
                        
                        if ( stackIPAddress.equals(host)) {
                            routes.remove();
                            
                            if (ProxyDebug.debug)
                                ProxyDebug.println
				("Proxy, forwardRequest(), (STEP 6) we removed"+
                                " the first Route header field value: it contained"+
                                " the proxy address and a lr parameter");
                        }
                        else {
             
                            if (ProxyDebug.debug)
                                ProxyDebug.println
			       ("RequestForwarding, forwardRequest(), (STEP 6)"+
                                "lr parameter detected but no match...");
                        }
                    }
                    else
                          if (ProxyDebug.debug)
                    	ProxyDebug.println
			("RequestForwarding, forwardRequest(), (STEP 6)"+
                    	" no Postprocess routing information to do " + 
			"(the route has no lr parameter)...");
                }
                else {
             
                 if (ProxyDebug.debug)
                    ProxyDebug.println("RequestForwarding, forwardRequest(), (STEP 6)"+
                    " no Postprocess routing information to do (No routes detected)...");
                }
/*******************************************************************************/
/************** 7. Determine Next-Hop Address, Port, and Transport    **********/
/*******************************************************************************/
                
         /* the proxy
         applies the procedures listed in [4] as follows to determine
         where to send the request.  If the proxy has reformatted the
         request to send to a strict-routing element as described in
         step 6 above, the proxy MUST apply those procedures to the
         Request-URI of the request.  Otherwise, the proxy MUST apply
         the procedures to the first value in the Route header field, if
         present, else the Request-URI.  The procedures will produce an
         ordered set of (address, port, transport) tuples.
         Independently of which URI is being used as input to the
         procedures of [4], if the Request-URI specifies a SIPS
         resource, the proxy MUST follow the procedures of [4] as if the
         input URI were a SIPS URI.
          */
               if (ProxyDebug.debug)
                ProxyDebug.println("RequestForwarding, forwardRequest(), (STEP 7)"+
                " Determine Next-Hop Address, Port, and Transport will be done by the stack...");
                
/*******************************************************************************/