basereader.java

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

package gov.nist.examples.bps.reader;

import java.util.*;
import javax.sip.*;
import javax.sip.message.*;
import javax.sip.header.*;
import javax.sip.address.*;
import gov.nist.examples.bps.reader.presence.*;

/** Base Reader Entry point.
 *
 *@version  JAIN-SIP-1.1
 *
 *@author Olivier Deruelle <[e-mail]>  (primary)
 * M. Ranganathan <[e-mail]> (bug fixes and hacks) <br/>
 *<a href="{@docRoot}/uncopyright.html">This code is in the public domain.</a>
 *
 */
public class BaseReader implements SipListener  {
    
    protected MessageFactory messageFactory;
    protected HeaderFactory headerFactory;
    protected AddressFactory addressFactory;
    protected BaseReaderThread baseReaderThread;
    protected Configuration configuration;
    protected BaseReaderUtilities baseReaderUtilities;
    protected PresenceManager presenceManager;
    protected SipProvider defaultProvider;
    
    protected SipStack sipStack;
    
    public AddressFactory getAddressFactory() {
        return addressFactory;
    }
    
    public MessageFactory getMessageFactory() {
        return messageFactory;
    }
    
    public HeaderFactory getHeaderFactory() {
        return headerFactory;
    }
    
    public SipProvider getSipProvider() {
        return defaultProvider;
    }
    
    public BaseReaderUtilities getBaseReaderUtilities() {
        return baseReaderUtilities;
    }
    
    public BaseReaderNotificationImpl getNotifier() {
        if (baseReaderThread==null) return null;
        return baseReaderThread.getNotifier();
    }

    
    public String getBaseReaderAddress() {
        return configuration.stackIPAddress;
    }
    
    public int getBaseReaderPort() {
        Router router=sipStack.getRouter();
        Hop hop=router.getOutboundProxy();
        return hop.getPort();
    }
    
    public String getPresenceServerAddress() {
        Router router=sipStack.getRouter();
        if (router==null) return null;
        Hop hop=router.getOutboundProxy();
        if (hop==null) return null;
        return hop.getHost();
    }
    
    public int getPresenceServerPort() {
        Router router=sipStack.getRouter();
        if (router==null) return -1;
        Hop hop=router.getOutboundProxy();
        if (hop==null) return -1;
        return hop.getPort();
    }
    
    public Configuration getConfiguration() {
        return configuration;
    }
    
    public PresenceManager getPresenceManager() {
        return presenceManager;
    }
    
    /** Creates new Proxy */
    public BaseReader(String confFile) throws Exception{
        if (confFile==null) {
            System.out.println
            ("ERROR: Set the configuration file flag: " +
            "USE: -cf configuration_file_location.xml"  );
        }
        else {
            try {
                
                // First, let's parse the configuration file.
                BaseReaderConfigurationHandler handler=
                new BaseReaderConfigurationHandler(confFile);
                configuration=handler.getConfiguration();
                if (configuration==null ||
                !configuration.isValidConfiguration()) {
                    System.out.println
                    ("ERROR: the configuration file is not correct!"+
                    " Correct the errors first.");
                    throw new Exception
                    ("ERROR: the configuration file is not correct!"+
                    " Correct the errors first.");
                }
                else {
                    baseReaderUtilities=new BaseReaderUtilities(this);
                    presenceManager=new PresenceManager(this);
                 
                }
            }
            catch (Exception ex) {
                System.out.println
                ("ERROR: exception raised while initializing the base reader");
                ex.printStackTrace();
                throw new Exception
                ("ERROR: exception raised while initializing the base reader");
            }
        }
    }
    
    
    
    /** This is a listener method.
     */
    public void processRequest(RequestEvent requestEvent) {
        Request request = requestEvent.getRequest();
        SipProvider sipProvider = (SipProvider) requestEvent.getSource();
        ServerTransaction serverTransaction=requestEvent.getServerTransaction();
        try {
            
            if (BaseReaderDebug.debug)
                BaseReaderDebug.println
                ("\n***************************************************************"+
                "\n***************************************************************"+
                "\nRequest " + request.getMethod() +" received:\n"+request.toString());
            
            
            if (BaseReaderDebug.debug)
                BaseReaderUtilities.printTransaction(serverTransaction);
            
/*******************************  SUBSCRIBE  ***********************************/            
            if (request.getMethod().equals(Request.SUBSCRIBE) ) {
           
                // Method that creates dialogs, so that can generate transactions
                String method=request.getMethod();  
               
                if ( method.equals("SUBSCRIBE") ) {
                    try{
                
                        serverTransaction=sipProvider.getNewServerTransaction(request);
              
                    }
                    catch(TransactionAlreadyExistsException e) {
                        BaseReaderDebug.println("BaseReader, processRequest(), this request"+
                        " has already a server transaction.");
                    }
                }
          
                
                presenceManager.processSubscribe(sipProvider,request,serverTransaction);
           
                return;
            }
/******************************* METHODS NOT ALLOWED   **************************/             
         
                Response response=messageFactory.createResponse
                (Response.METHOD_NOT_ALLOWED,request);
                if (serverTransaction!=null)
                    serverTransaction.sendResponse(response);
                else sipProvider.sendResponse(response);
                BaseReaderDebug.println("BaseReader, processRequest(), we drop the request, "+
                "METHOD_NOT_ALLOWED replied");
                return;

        }
        catch (Exception ex){
            try{
                if (BaseReaderDebug.debug) {
                    BaseReaderDebug.println("BaseReader, processRequest(), internal error, "+
                    "exception raised:");
                    BaseReaderDebug.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 (BaseReaderDebug.debug)
                    BaseReaderDebug.println("BaseReader, processRequest(),"+
                    " 500 SERVER_INTERNAL_ERROR replied:\n"+
                    response.toString());
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    
    /** This is a listener method.
     */
    public void processResponse(ResponseEvent responseEvent) {
        try{
            
            Response response = responseEvent.getResponse();
            SipProvider sipProvider = (SipProvider) responseEvent.getSource();
            ClientTransaction clientTransaction=responseEvent.getClientTransaction();
            
            BaseReaderDebug.println
            ("\n***************************************************************"+
            "\n***************************************************************"+
            "\nResponse "+response.getStatusCode() + " "+response.getReasonPhrase()
            +" received:\n"+response.toString() );
            BaseReaderDebug.println("Processing Response in progress");
            
            if (BaseReaderDebug.debug)
                BaseReaderUtilities.printTransaction(clientTransaction);
         
            // We discard all responses except 200 OK for REGISTER and NOTIFY.
            CSeqHeader cseqHeader=(CSeqHeader)response.getHeader(CSeqHeader.NAME);
            if (    response.getStatusCode()==200 && 
                    cseqHeader.getMethod().equals(Request.REGISTER)) {
                BaseReaderDebug.println("OK related to REGISTER received");
                        return;
            }
            if (    response.getStatusCode()==200 && 
                    cseqHeader.getMethod().equals(Request.NOTIFY)) {
                BaseReaderDebug.println("OK related to NOTIFY received");   
                        return;
            }
            
            BaseReaderDebug.println("We discard the response...");