requestforwarding.java

基于JAINSIP的一个proxy源码

    
     private void forwardIMPresenceRequest(
		SipProvider sipProvider,
		ServerTransaction serverTransaction,
		Request clonedRequest, 
		Request originalRequest,
	 	Dialog	dialog) throws Exception { /*
                TransactionsMapping transactionsMapping= (TransactionsMapping) 
				serverTransaction.getDialog().
				getApplicationData();
	       CSeqHeader cseqHeader = (CSeqHeader) 
			clonedRequest.getHeader(CSeqHeader.NAME);
               if (  cseqHeader.getSequenceNumber()==1 &&
                     clonedRequest.getMethod().equals(Request.SUBSCRIBE) ){
                   if (ProxyDebug.debug)
                       ProxyDebug.println
			("RequestForwarding, forwardRequestStatefully(),"+
                       " It is a first SUBSCRIBE, so we have to"+
                       " forward the request using"+
                       " a new clientTransaction");
                   ClientTransaction clientTransaction =
                   sipProvider.getNewClientTransaction
                   (clonedRequest);
                   clientTransaction.sendRequest();
                   
                   if (ProxyDebug.debug)
                       ProxyDebug.println
                       ("RequestForwarding, forwardRequestStatefully(),"+
                       ", cloned request forwarded statefully:\n "
                       +clonedRequest);
                   
		   if (serverTransaction.getDialog() != null) {
                      transactionsMapping.addMapping
			(serverTransaction,clientTransaction);
		   }
                   return;
               } else if (clonedRequest.getMethod().equals(Request.NOTIFY)) {
				  // Forward the notify to all the watchers.
				  String url = 
				       ( (FromHeader) clonedRequest.getHeader(FromHeader.NAME)).
					getAddress().getURI().toString();
					if(url.indexOf(';')!=-1)
						url=url.substring(0,url.indexOf(';'));
				  PresenceServer ps  = proxy.getPresenceServer();
				  PresentityManager pm = ps.getPresentityManager();
				  Vector presentities = pm.getSubscriberList(url);
				  //System.out.println("GOT A NOTIFY...."  + presentities.size());                  
				  // get all the dialogs for the watchers.
				  for (int i = 0; i < presentities.size() ; i++) {
						Subscriber s = (Subscriber) presentities.elementAt(i);
						if (ProxyDebug.debug) {
			                             ProxyDebug.println
							("Forwarding request to Subscriber nb "+
								i+ " : "+s.getSubscriberURL());
						}
						Dialog d = s.getDialog();
						Request r = d.createRequest(Request.NOTIFY);
						// set the content of the outgoing request.
		                Object content=clonedRequest.getContent();
		                if(content!=null)
		                    r.setContent(content,
			       				(ContentTypeHeader) clonedRequest.getHeader
									(ContentTypeHeader.NAME));
						ClientTransaction ct = 
		                	sipProvider.getNewClientTransaction (r);
						d.sendRequest(ct);
				  }
                  return;
	       }  else if (clonedRequest.getMethod().equals(Request.MESSAGE)) {
			if (dialog != null) {
			    this.forwardRequestThroughDialog(sipProvider,
			     	serverTransaction, 
				clonedRequest,
				dialog);
			} else {

				forwardRequestStatelessly(sipProvider,
    					clonedRequest, originalRequest,
					serverTransaction);

                   		// ClientTransaction clientTransaction =
                   		// sipProvider.getNewClientTransaction
                   	        //		(clonedRequest);
                   		// clientTransaction.sendRequest();
			}
		}
               //Means that the message is not a presnece message
               else{
                    this.forwardRequestThroughDialog(
			sipProvider,
			serverTransaction,
			clonedRequest,
			dialog);	
               }
						   */     
         } 
    

 	/** Forward a request statefully through a dialog.
	*/
	private void forwardRequestThroughDialog 
	    (SipProvider sipProvider,
	    ServerTransaction  serverTransaction,
	    Request clonedRequest,
	    Dialog dialog) throws Exception {
           TransactionsMapping transactionsMapping= (TransactionsMapping) 
				serverTransaction.getDialog().
				getApplicationData();
		
           if (ProxyDebug.debug) {
              ProxyDebug.println("Printing TransactionsMappingTable...");                
            }
           
           if (ProxyDebug.debug)
                transactionsMapping.printTransactionsMapping();
           
            if ( clonedRequest.getMethod().equals("CANCEL") ) {
                 Transaction firstTransaction=dialog.getFirstTransaction();
                  if (firstTransaction==null) {
                     throw new Exception
			("ERROR, RequestForwarding, the first transaction"+
                  	" for the  dialog is null"); 
           	   }
		   if ( firstTransaction instanceof ClientTransaction ) {
			if (ProxyDebug.debug)
			   ProxyDebug.println("CANCEL IGNORED");
			return;
		   }
                   ServerTransaction firstServerTransaction=
			(ServerTransaction)firstTransaction;
                   Vector clientTransactions =
                            transactionsMapping.getClientTransactions
			    (firstServerTransaction);
                   if (clientTransactions==null || 
			clientTransactions.isEmpty()) {
                       throw new Exception
			("RequestForwarding, The peer first client " +
			" transaction(s) for the first server transaction " +
			 " is null (CANCEL)"); 
                   }
                   
                   for (Enumeration e = clientTransactions.elements(); 
			e.hasMoreElements();) {
                        ClientTransaction ct = 
				(ClientTransaction)e.nextElement();
                    
                    // check if the client transaction can be canceled.
                    if (ct.getState().equals(TransactionState.COMPLETED) ||
                    ct.getState().equals(TransactionState.TERMINATED)){
                        continue;
                    }
                    Request cancelRequest
                    =ct.createCancel();   
                    
                    ClientTransaction clientTransaction=
                    sipProvider.getNewClientTransaction
                    (cancelRequest);
                    clientTransaction.sendRequest();
                  
                    if (ProxyDebug.debug)
                        ProxyDebug.println
			("RequestForwarding, forwardRequestStatefully()"+
                        ", created CANCEL sent statefully (using a new client"+
                        " transaction):\n "+cancelRequest);
                   }
                   return;
           }
           
           if (ProxyDebug.debug) {
              ProxyDebug.println("Getting peer dialog...");                
            }

	   Dialog thisDialog = serverTransaction.getDialog();
	   Dialog peerDialog = transactionsMapping.getPeerDialog
				(serverTransaction);

	   if (peerDialog == null) {
		ClientTransaction 
			ct = sipProvider.getNewClientTransaction
				(clonedRequest);
		ct.sendRequest();
		transactionsMapping.addMapping(serverTransaction,ct);
	   } else if ( clonedRequest.getMethod().equals("ACK") ) {
                 peerDialog.sendAck(clonedRequest);
                        
                   if (ProxyDebug.debug)
                        ProxyDebug.println
		       ("RequestForwarding, forwardRequestStatefully()"+
                        ", cloned ACK forwarded statefully " +
			" (using the dialog from the"+
                        " first client transaction):\n "+clonedRequest);
                    
            } else {
                    
                    Request dialogRequest=
			peerDialog.createRequest(clonedRequest.getMethod());
                    Object content=clonedRequest.getContent();
                    if (content!=null) {
                        ContentTypeHeader contentTypeHeader=
			(ContentTypeHeader)clonedRequest.getHeader(
                        	ContentTypeHeader.NAME);
                        if (contentTypeHeader!=null)
                            dialogRequest.setContent(content,contentTypeHeader);
                    }
                     
                    // Copy all the headers from the original request to the 
                    // dialog created request:
                    try{
                        ListIterator l=clonedRequest.getHeaderNames();
                        while (l.hasNext() ) {
                             String name=(String)l.next();
                             Header header=dialogRequest.getHeader(name);
                             if (header==null  ) {
                                ListIterator li=clonedRequest.getHeaders(name);
                                if (li!=null) {
                                    while (li.hasNext() ) {
                                        Header  h=(Header)li.next();
                                        dialogRequest.addHeader(h);
                                    }
                                }
                             }
                             else {
                                 if ( header instanceof ViaHeader) {
                                     ListIterator li=
					clonedRequest.getHeaders(name);
                                     if (li!=null) {
                                         dialogRequest.removeHeader(name);
                                         Vector v=new Vector();
                                         while (li.hasNext() ) {
                                             Header  h=(Header)li.next();
                                             v.addElement(h);
                                         }
                                         for (int k=(v.size()-1);k>=0;k--) {
                                             Header  h=(Header)v.elementAt(k);
                                             dialogRequest.addHeader(h);
                                         }
                                     }
                                 }
                             }
                        }       
                    }
                    catch(Exception e) {
                        if (ProxyDebug.debug)
                        ProxyDebug.println
			("RequestForwarding, forwardRequestStatefully()"+
                        ", error trying to copy the headers from " +
			 " the original request");
                        e.printStackTrace();
                    }
                    if (ProxyDebug.debug) {
                      ProxyDebug.println("Sending request...");                
                    }
                    ClientTransaction clientTransaction =
			sipProvider.getNewClientTransaction(dialogRequest);
                    peerDialog.sendRequest(clientTransaction);
                    if (ProxyDebug.debug)
                        ProxyDebug.println
			("RequestForwarding, forwardRequestStatefully()"+
                        ", cloned request forwarded statefully " +
			"(using the dialog from the"+
                        " first client transaction):\n "+dialogRequest);
                        transactionsMapping.addMapping
				(serverTransaction,clientTransaction);
                }
	}


      private void 
	forwardRequestStatelessly(SipProvider sipProvider,
    	Request clonedRequest, Request originalRequest,
	ServerTransaction serverTransaction) {

        MessageFactory messageFactory=proxy.getMessageFactory();
        HeaderFactory headerFactory=proxy.getHeaderFactory();
        AddressFactory addressFactory=proxy.getAddressFactory();
        SipStack sipStack=proxy.getSipStack();
        
        try{
            
            // We forward statelessly:
            // It means the Request does not create dialogs...
            sipProvider.sendRequest(clonedRequest);
            if (ProxyDebug.debug)
                ProxyDebug.println
                ("RequestForwarding, forwardRequestStatelessly(), "+
                " cloned request forwarded statelessly:\n"
		+clonedRequest.toString());
        } catch (Exception ex){
            try{
                if (ProxyDebug.debug) {
                    ProxyDebug.println
		    ("RequestForwarding, forwardRequestStatelessly(), "+
                    " internal error, "+
                    "exception raised:");
                    ProxyDebug.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 (ProxyDebug.debug)
                    ProxyDebug.println(
                    "RequestForwarding, forwardRequestStatelessly(), " +
		    " 500 SERVER_INTERNAL_ERROR replied:\n"+
                    response.toString());
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    
}