responseforwarding.java

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

/*
 * ResponseForwarding.java
 *
 * Created on April 16, 2003, 11:09 AM
 */

package gov.nist.examples.mail;
import java.util.*;
import javax.sip.*;
import javax.sip.message.*;
import javax.sip.header.*;
import javax.sip.address.*;
import  javax.sdp.*;
/**
 *
 * @author  deruelle
 */
public class ResponseForwarding {
    
    protected Controller controller;
    
    /** Creates a new instance of ResponseForwarding */
    public ResponseForwarding(Controller controller) {
        this.controller=controller;
    }
    
    public void forwardResponse(SipProvider sipProvider,
    Response response,ClientTransaction clientTransaction) {
        MessageFactory messageFactory=controller.getMessageFactory();
        HeaderFactory headerFactory=controller.getHeaderFactory();
        AddressFactory addressFactory=controller.getAddressFactory();
        StackConfiguration stackConfiguration=controller.getStackConfiguration();
        try{
            
/*******************************************************************************/
/***********************  controller BEHAVIOR    ************************************/
/*******************************************************************************/
        
            
            Response clonedResponse = (Response) response.clone(); 
            Object sdpObjectContent=clonedResponse.getContent();
            String sdpContent=null;
            if (sdpObjectContent instanceof String)
                sdpContent=(String)sdpObjectContent;
            else
                if (sdpObjectContent instanceof byte[] ) {
                    sdpContent=new String(  (byte[])sdpObjectContent);
                }
            
            SessionDescription sd=null;
            int sdpPort=-1;
            String sdpAddress=null;
            try{
                SdpFactory factory=SdpFactory.getInstance();
                if(sdpContent!=null){
                    sd=factory.createSessionDescription(sdpContent);
                    Vector timeDescriptions=sd.getTimeDescriptions(false);                
                    if(timeDescriptions.size()<1){
                        Time time=factory.createTime();
                        timeDescriptions=new Vector();
                        timeDescriptions.addElement(time);
                        sd.setTimeDescriptions(timeDescriptions);                
                        ContentTypeHeader newContentTypeHeader=headerFactory.createContentTypeHeader(
                                    "application","sdp");
                        clonedResponse.setContent(sd.toString(),newContentTypeHeader);
                    }
                }
            }
            catch(Exception e) {
                e.printStackTrace();
                //throw new RTPHoleException("ResponseForwarding exception, the SDP content"+
                //" parameter parsing has failed.");
            }                              
           
             
               
                System.out.println
                ("ResponseForwarding, forwardResponse(), the client transaction"+
                " does not exist, we"+
                " will forward the response statelessly!");

                    ListIterator viaList=clonedResponse.getHeaders(ViaHeader.NAME);
                    clonedResponse.removeHeader(ViaHeader.NAME);
                    Vector v=new Vector();
                    viaList.next();
                    while (viaList!=null && viaList.hasNext()) {
                        ViaHeader viaHeader=(ViaHeader) viaList.next();
                        v.addElement(viaHeader);
                    }
                    for (int j=0;j<v.size();j++) {
                        ViaHeader viaHeader=(ViaHeader) v.elementAt(j);
                        clonedResponse.addHeader(viaHeader);
                    }
                    
                    viaList=clonedResponse.getHeaders(ViaHeader.NAME);
                    if (viaList==null || !viaList.hasNext()) {
                        System.out.println
                        ("ResponseForwarding, forwardResponse(), the response (Via header)does"+
                        " not have any Via header, the response is silently discarded");
                    }
                    else {
                        // let's hope the sipProvider will take the Viaheader to
                        // forward the response...
                        
                        // We have to open a hole
                        CSeqHeader cseqHeader=(CSeqHeader)clonedResponse.getHeader(CSeqHeader.NAME);
                        /*if ( clonedResponse.getStatusCode() == 200 &&
                        cseqHeader.getMethod().equals("INVITE") && stackConfiguration.enableRTPGateway) {
                            try{
                               
                                Object content=clonedResponse.getContent();
                                String text=null;
                                if (content instanceof String)
                                    text=(String)content;
                                else
                                    if (content instanceof byte[] ) {
                                        text=new String(  (byte[])content  );
                                    }
                                
                                System.out.println
                                ("ResponseForwarding, forwardResponse(), SDP text:"+text);
                                if (text!=null) {
                                     ContentTypeHeader contentTypeHeader=controller.
                                        headerFactory.createContentTypeHeader(
                                        "application","sdp");
                                    // The SDP is received let's open a hole:
                                    SipStack sipStack=sipProvider.getSipStack();
                                    SipStack opp=controller.getOppositeSipStack(sipStack.getIPAddress());
                                    
                                    CallIdHeader callIdHeader=(CallIdHeader)clonedResponse.
                                    getHeader(CallIdHeader.NAME);
                            
                                    
                                    RTPHole secondRTPHole=controller.rtpHolesManager.createRTPHole(
                                    callIdHeader.getCallId(),
                                    text,
                                    opp.getIPAddress(),
                                    sipStack.getIPAddress());
                                    
                                    System.out.println
                                    ("ResponseForwarding, forwardResponse(), we open this hole...");
                                    
                                    secondRTPHole.open();
                                    
                                    
                                    String generatedSDPHole=secondRTPHole.getGeneratedSDPHole();
                                    clonedResponse.setContent(generatedSDPHole,contentTypeHeader);
                                    clonedResponse.removeHeader(ContactHeader.NAME);
                                    
                                }
                            }
                            catch(Exception e){
                                e.printStackTrace();
                                System.out.println
                                    ("ResponseForwarding, forwardResponse(), problem"+
                                    " to open the RTP hole...");
                                    
                            }
                        }*/
            
                        sipProvider.sendResponse(clonedResponse);             

                        System.out.println
                        ("ResponseForwarding, forwardResponse(), the response statelessly forwarded:\n"+
                        clonedResponse.toString());
                    }
                    return;
                
 
        }
        catch (Exception ex) {
            System.out.println("ResponseForwarding, forwardResponse(), internal error, "+
            "exception raised:");
            ex.printStackTrace();            
        }
    }

}