requestforwarding.java

First of all, the Applet-phone is a SIP User-Agent with audio and text messaging capabilities. But

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

package gov.nist.examples.bps.gateway;
import java.util.*;
import javax.sip.*;
import javax.sip.message.*;
import javax.sip.header.*;
import javax.sip.address.*;
import tools.rtpgateway.*;
/**
 *
 * @author Deruelle
 */
public class RequestForwarding {
    
    protected Gateway gateway;
    
    
    /** Creates a new instance of RequestForwarding */
    public RequestForwarding(Gateway gateway) {
       this.gateway=gateway;
    }
    
   
    public void forwardRequest(URI targetURI,SipProvider sipProvider,Request request,
    ServerTransaction serverTransaction) {
       
        MessageFactory messageFactory=gateway.getMessageFactory();
        HeaderFactory headerFactory=gateway.getHeaderFactory();
        AddressFactory addressFactory=gateway.getAddressFactory();
        Configuration configuration=gateway.getConfiguration();
        try{
                
/*******************************************************************************/
/************** 1.  Make a copy of the received request               **********/
/*******************************************************************************/
                Request clonedRequest = (Request) request.clone();
                if (GatewayDebug.debug)
                   GatewayDebug.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.
                 */
                // All the targets URI are already canonicalized
                clonedRequest.setRequestURI(targetURI);
                if (GatewayDebug.debug)
                   GatewayDebug.println("RequestForwarding, forwardRequest() (STEP 2),"+
                   " The Request-URI in the copy's start line is replaced with"+
                   " the URI for this target");
                

/*******************************************************************************/
/************** 8. Add a Via header field value                      **********/
/*******************************************************************************/
                
         /* The gateway MUST insert a Via header field value into the copy
            before the existing Via header field values.
          */
                
                SipStack sipStack=sipProvider.getSipStack();
                String stackIPAddress=sipStack.getIPAddress();
                SipStack oppositeSipStack=gateway.getOppositeSipStack(stackIPAddress);
                ViaHeader viaHeader=gateway.getStackViaHeader(oppositeSipStack);
                
                if (viaHeader!=null)
                    clonedRequest.addHeader(viaHeader);
                
                Iterator lps=oppositeSipStack.getListeningPoints();
                ListeningPoint lp=(ListeningPoint)lps.next();
                SipURI sipURI=gateway.addressFactory.createSipURI(null,sipStack.getIPAddress());
                sipURI.setPort(lp.getPort());
                Address address=gateway.addressFactory.createAddress(null,sipURI);
                RecordRouteHeader recordRouteHeader=
                gateway.headerFactory.createRecordRouteHeader(address);
                
                
                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 ( clonedRequest.getMethod().equals("BYE") && configuration.enableRTPGateway  ) {
                    try{
                        CallIdHeader callIdHeader=(CallIdHeader)clonedRequest.
                            getHeader(CallIdHeader.NAME);
                        gateway.rtpHolesManager.closeRTPHoles( callIdHeader.getCallId() );
                    }
                    catch(Exception e){}
                }
                
                // We have to open a hole
                if ( clonedRequest.getMethod().equals("INVITE") && configuration.enableRTPGateway ) {
                    try{
                        // Let's create the first hole for RTP:
                        Object content=clonedRequest.getContent();
                        String text=null;
                        if (content instanceof String)
                            text=(String)content;
                        else
                            if (content instanceof byte[] ) {
                                text=new String(  (byte[])content  );
                            }
                        
                        if (text!=null) {
                            // The first SDP is received let's open a hole:
                            // Content-Type:
                            ContentTypeHeader contentTypeHeader=gateway.
                            headerFactory.createContentTypeHeader(
                            "application","sdp");
                            
                            CallIdHeader callIdHeader=(CallIdHeader)clonedRequest.
                            getHeader(CallIdHeader.NAME);
                            
                            /*if (gateway.rtpHolesManager.hasRTPHole(callIdHeader.getCallId() ) ){
                                // This is a retransmission...
                                GatewayDebug.println("RequestForwarding, forwardRequest(), "+
                                "retransmission dropped...");
                                return;
                            }*/
                            
                            RTPHole firstRTPHole=gateway.rtpHolesManager.createRTPHole(
                            callIdHeader.getCallId(),
                            text,
                            oppositeSipStack.getIPAddress(),
                            stackIPAddress);
                           
                            String generatedSDPHole=firstRTPHole.getGeneratedSDPHole();
                            clonedRequest.setContent(generatedSDPHole,contentTypeHeader);
                            
                            firstRTPHole.open();
                        }
                    }
                    catch(Exception e){
                        e.printStackTrace();
                         GatewayDebug.println("ERROR, RequestForwarding, forwardRequest(), "+
                                "Unable to open a hole, the request is forwarded as it was"+
                                " received!");
                    }
                }
                
                forwardRequestStatelessly(sipProvider,
                clonedRequest,request,serverTransaction,oppositeSipStack);
        }
        catch (Exception ex){
            try{
                if (GatewayDebug.debug) {
                    GatewayDebug.println("RequestForwarding, forwardRequest(), "+
                    " internal error, "+
                    "exception raised:");
                    GatewayDebug.logException(ex);
                }
                // This is an internal error:
                // Let's return a 500 SERVER_INTERNAL_ERROR
                Response response=messageFactory.createResponse
                (Response.SERVER_INTERNAL_ERROR,request);
                if (serverTransaction!=null)
                    serverTransaction.sendResponse(response);
                else sipProvider.sendResponse(response);
                
                if (GatewayDebug.debug)
                    GatewayDebug.println(
                    "RequestForwarding, forwardRequest(), 500 SERVER_INTERNAL_ERROR replied:\n"+
                    response.toString());
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    
    
    public void forwardRequestStatelessly(SipProvider sipProvider,
    Request clonedRequest,Request originalRequest,ServerTransaction serverTransaction,
    SipStack sipStack) {
        MessageFactory messageFactory=gateway.getMessageFactory();
        HeaderFactory headerFactory=gateway.getHeaderFactory();
        AddressFactory addressFactory=gateway.getAddressFactory();
    
        try{
            
            // We forward statelessly:
            // It means the Request does not create dialogs...
            Iterator iter=sipStack.getSipProviders();
            //ClientTransaction clientTransaction=((SipProvider)iter.next()).getNewClientTransaction(request);
            ((SipProvider)iter.next()).sendRequest(clonedRequest);
            if (GatewayDebug.debug)
                GatewayDebug.println
                ("RequestForwarding, forwardRequestStatelessly(), "+
                " cloned request forwarded statelessly:\n"+clonedRequest.toString());
        }
        catch (Exception ex){
            try{
                if (GatewayDebug.debug) {
                    GatewayDebug.println("RequestForwarding, forwardRequestStatelessly(), "+
                    " internal error, "+
                    "exception raised:");
                    GatewayDebug.logException(ex);
                }
                // This is an internal error:
                // Let's return a 500 SERVER_INTERNAL_ERROR
                Response response=messageFactory.createResponse
                (Response.SERVER_INTERNAL_ERROR,originalRequest);
                if (serverTransaction!=null)
                    serverTransaction.sendResponse(response);
                else sipProvider.sendResponse(response);
                
                if (GatewayDebug.debug)
                    GatewayDebug.println(
                    "RequestForwarding, forwardRequestStatelessly(), 500 SERVER_INTERNAL_ERROR replied:\n"+
                    response.toString());
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    
}