basemessage.java

来自「结构非常清晰的SIP协议栈」· Java 代码 · 共 1,256 行 · 第 1/3 页

   } 
   /** Gets CallIdHeader of Message */
   public CallIdHeader getCallIdHeader()
   {  Header h=getHeader(SipHeaders.Call_ID);
      if (h==null) return null;
      else return new CallIdHeader(h);
   } 
   /** Removes CallIdHeader from Message */
   public void removeCallIdHeader() 
   {  removeHeader(SipHeaders.Call_ID);
   }


   /** Whether Message has SubjectHeader */
   public boolean hasSubjectHeader()
   {  return hasHeader(SipHeaders.Subject);
   }
   /** Sets SubjectHeader of Message */
   public void setSubjectHeader(SubjectHeader sh) 
   {  setHeader(sh);
   } 
   /** Gets SubjectHeader of Message */
   public SubjectHeader getSubjectHeader()
   {  Header h=getHeader(SipHeaders.Subject);
      if (h==null) return null;
      else return new SubjectHeader(h);
   } 
   /** Removes SubjectHeader from Message */
   public void removeSubjectHeader() 
   {  removeHeader(SipHeaders.Subject);
   }

   
   /** Whether Message has DateHeader */   
   public boolean hasDateHeader()
   {  return hasHeader(SipHeaders.Date);
   }  
   /** Gets DateHeader of Message */
   public DateHeader getDateHeader()
   {  Header h=getHeader(SipHeaders.Date);
      if (h==null) return null;
      else return new DateHeader(h);
   } 
   /** Sets DateHeader of Message */
   public void setDateHeader(DateHeader dh) 
   {  setHeader(dh);
   }  
   /** Removes DateHeader from Message (if it exists) */
   public void removeDateHeader() 
   {  removeHeader(SipHeaders.Date);
   }

   
   /** Whether has UserAgentHeader */
   public boolean hasUserAgentHeader()
   {  return hasHeader(SipHeaders.User_Agent);
   }
   /** Sets UserAgentHeader */
   public void setUserAgentHeader(UserAgentHeader h) 
   {  setHeader(h);
   } 
   /** Gets UserAgentHeader */
   public UserAgentHeader getUserAgentHeader()
   {  Header h=getHeader(SipHeaders.User_Agent);
      if (h==null) return null;
      else return new UserAgentHeader(h);
   } 
   /** Removes UserAgentHeader */
   public void removeUserAgentHeader() 
   {  removeHeader(SipHeaders.User_Agent);
   }


   /** Whether has ServerHeader */
   public boolean hasServerHeader()
   {  return hasHeader(SipHeaders.Server);
   }
   /** Sets ServerHeader */
   public void setServerHeader(ServerHeader h) 
   {  setHeader(h);
   } 
   /** Gets ServerHeader */
   public ServerHeader getServerHeader()
   {  Header h=getHeader(SipHeaders.Server);
      if (h==null) return null;
      else return new ServerHeader(h);
   } 
   /** Removes ServerHeader */
   public void removeServerHeader() 
   {  removeHeader(SipHeaders.Server);
   }


   /** Whether has AcceptHeader */
   public boolean hasAcceptHeader()
   {  return hasHeader(SipHeaders.Accept);
   }
   /** Sets AcceptHeader */
   public void setAcceptHeader(AcceptHeader h) 
   {  setHeader(h);
   } 
   /** Gets AcceptHeader */
   public AcceptHeader getAcceptHeader()
   {  Header h=getHeader(SipHeaders.Accept);
      if (h==null) return null;
      else return new AcceptHeader(h);
   } 
   /** Removes AcceptHeader */
   public void removeAcceptHeader() 
   {  removeHeader(SipHeaders.Accept);
   }


   /** Whether has AlertInfoHeader */
   public boolean hasAlertInfoHeader()
   {  return hasHeader(SipHeaders.Alert_Info);
   }
   /** Sets AlertInfoHeader */
   public void setAlertInfoHeader(AlertInfoHeader h) 
   {  setHeader(h);
   } 
   /** Gets AlertInfoHeader */
   public AlertInfoHeader getAlertInfoHeader()
   {  Header h=getHeader(SipHeaders.Alert_Info);
      if (h==null) return null;
      else return new AlertInfoHeader(h);
   } 
   /** Removes AlertInfoHeader */
   public void removeAlertInfoHeader() 
   {  removeHeader(SipHeaders.Alert_Info);
   }


   /** Whether has AllowHeader */
   public boolean hasAllowHeader()
   {  return hasHeader(SipHeaders.Allow);
   }
   /** Sets AllowHeader */
   public void setAllowHeader(AllowHeader h) 
   {  setHeader(h);
   } 
   /** Gets AllowHeader */
   public AllowHeader getAllowHeader()
   {  Header h=getHeader(SipHeaders.Allow);
      if (h==null) return null;
      else return new AllowHeader(h);
   } 
   /** Removes AllowHeader */
   public void removeAllowHeader() 
   {  removeHeader(SipHeaders.Allow);
   }


   /** Whether Message has ExpiresHeader */   
   public boolean hasExpiresHeader()
   {  return hasHeader(SipHeaders.Expires);
   }   
   /** Gets ExpiresHeader of Message */
   public ExpiresHeader getExpiresHeader()
   {  Header h=getHeader(SipHeaders.Expires);
      if (h==null) return null;
      else return new ExpiresHeader(h);
   } 
   /** Sets ExpiresHeader of Message */
   public void setExpiresHeader(ExpiresHeader eh) 
   {  setHeader(eh);
   }    
   /** Removes ExpiresHeader from Message (if it exists) */
   public void removeExpiresHeader() 
   {  removeHeader(SipHeaders.Expires);
   }   

   
   /** Whether Message has ContentTypeHeader */   
   public boolean hasContentTypeHeader()
   {  return hasHeader(SipHeaders.Content_Type);
   }   
   /** Gets ContentTypeHeader of Message */
   public ContentTypeHeader getContentTypeHeader()
   {  Header h=getHeader(SipHeaders.Content_Type);
      if (h==null) return null;
      else return new ContentTypeHeader(h);
   } 
   /** Sets ContentTypeHeader of Message */
   protected void setContentTypeHeader(ContentTypeHeader cth) 
   {  setHeader(cth);
   }    
   /** Removes ContentTypeHeader from Message (if it exists) */
   protected void removeContentTypeHeader() 
   {  removeHeader(SipHeaders.Content_Type);
   }
 
   
   /** Whether Message has ContentLengthHeader */   
   public boolean hasContentLengthHeader()
   {  return hasHeader(SipHeaders.Content_Length);
   }  
   /** Gets ContentLengthHeader of Message */
   public ContentLengthHeader getContentLengthHeader()
   {  Header h=getHeader(SipHeaders.Content_Length);
      if (h==null) return null;
      else return new ContentLengthHeader(h);
   } 
   /** Sets ContentLengthHeader of Message */
   protected void setContentLengthHeader(ContentLengthHeader clh) 
   {  setHeader(clh);
   }    
   /** Removes ContentLengthHeader from Message (if it exists) */
   protected void removeContentLengthHeader() 
   {  removeHeader(SipHeaders.Content_Length);
   }   

  
   /** Whether Message has Body */   
   public boolean hasBody()
   {  if (hasContentLengthHeader()) return getContentLengthHeader().getContentLength()>0;
      else return hasContentTypeHeader();
   }
   /** Gets body(content) type */
   public String getBodyType()
   {  return getContentTypeHeader().getContentType();
   } 
   /** Sets the message body */
   public void setBody(String content_type, String body) 
   {  removeBody();
      if (body!=null && body.length()>0)
      {  setContentTypeHeader(new ContentTypeHeader(content_type));
         setContentLengthHeader(new ContentLengthHeader(body.length()));
         message=message+"\r\n"+body;
      }
      else
      {  setContentLengthHeader(new ContentLengthHeader(0));
         message=message+"\r\n";
      }
   }          
   /** Sets sdp body */
   public void setBody(String body) 
   {  setBody("application/sdp",body);
   }            
   /** Gets message body. The end of body is evaluated
     * from the Content-Length header if present (SIP-RFC compliant),
     * or from the end of message if no Content-Length header is present (non-SIP-RFC compliant) */
   public String getBody()
   {  //if (!hasBody()) return "";
      if (!hasBody()) return null;
      int begin=(new SipParser(message)).goToBody().getPos();
      int len;
      // the following 'if' is for robustness with non SIP-compliant UAs;
      // copliant UAs must insert Content-Length header when body is present..
      if (this.hasContentLengthHeader()) len=getContentLengthHeader().getContentLength();
      else
      {  //printWarning("No Content-Length header found for the Body",3);
         len=message.length()-begin;
      }
      int end=begin+len;
      if (end>message.length())
      {  //printWarning("Found a Message Body shorter than Content-Length",3);
         end=message.length();
      }
      return message.substring(begin,end);
   }  
   /** Removes the message body (if it exists) and the final empty line */
   public void removeBody() 
   {  int pos=(new SipParser(message)).goToEndOfLastHeader().goToNextLine().getPos(); 
      message=message.substring(0,pos);
      removeContentLengthHeader();
      removeContentTypeHeader();
   }
   
   
   //**************************** Authentication ****************************/


   /** Whether has AuthenticationInfoHeader */
   public boolean hasAuthenticationInfoHeader()
   {  return hasHeader(SipHeaders.Authentication_Info);
   }
   /** Sets AuthenticationInfoHeader */
   public void setAuthenticationInfoHeader(AuthenticationInfoHeader h) 
   {  setHeader(h);
   } 
   /** Gets AuthenticationInfoHeader */
   public AuthenticationInfoHeader getAuthenticationInfoHeader()
   {  Header h=getHeader(SipHeaders.Authentication_Info);
      if (h==null) return null;
      else return new AuthenticationInfoHeader(h);
   } 
   /** Removes AuthenticationInfoHeader */
   public void removeAuthenticationInfoHeader() 
   {  removeHeader(SipHeaders.Authentication_Info);
   }


   /** Whether has AuthorizationHeader */
   public boolean hasAuthorizationHeader()
   {  return hasHeader(SipHeaders.Authorization);
   }
   /** Sets AuthorizationHeader */
   public void setAuthorizationHeader(AuthorizationHeader h) 
   {  setHeader(h);
   } 
   /** Gets AuthorizationHeader */
   public AuthorizationHeader getAuthorizationHeader()
   {  Header h=getHeader(SipHeaders.Authorization);
      if (h==null) return null;
      else return new AuthorizationHeader(h);
   } 
   /** Removes AuthorizationHeader */
   public void removeAuthorizationHeader() 
   {  removeHeader(SipHeaders.Authorization);
   }


   /** Whether has WwwAuthenticateHeader */
   public boolean hasWwwAuthenticateHeader()
   {  return hasHeader(SipHeaders.WWW_Authenticate);
   }
   /** Sets WwwAuthenticateHeader */
   public void setWwwAuthenticateHeader(WwwAuthenticateHeader h) 
   {  setHeader(h);
   } 
   /** Gets WwwAuthenticateHeader */
   public WwwAuthenticateHeader getWwwAuthenticateHeader()
   {  Header h=getHeader(SipHeaders.WWW_Authenticate);
      if (h==null) return null;
      else return new WwwAuthenticateHeader(h);
   } 
   /** Removes WwwAuthenticateHeader */
   public void removeWwwAuthenticateHeader() 
   {  removeHeader(SipHeaders.WWW_Authenticate);
   }


   /** Whether has ProxyAuthenticateHeader */
   public boolean hasProxyAuthenticateHeader()
   {  return hasHeader(SipHeaders.Proxy_Authenticate);
   }
   /** Sets ProxyAuthenticateHeader */
   public void setProxyAuthenticateHeader(ProxyAuthenticateHeader h) 
   {  setHeader(h);
   } 
   /** Gets ProxyAuthenticateHeader */
   public ProxyAuthenticateHeader getProxyAuthenticateHeader()
   {  Header h=getHeader(SipHeaders.Proxy_Authenticate);
      if (h==null) return null;
      else return new ProxyAuthenticateHeader(h);
   } 
   /** Removes ProxyAuthenticateHeader */
   public void removeProxyAuthenticateHeader() 
   {  removeHeader(SipHeaders.Proxy_Authenticate);
   }


   /** Whether has ProxyAuthorizationHeader */
   public boolean hasProxyAuthorizationHeader()
   {  return hasHeader(SipHeaders.Proxy_Authorization);
   }
   /** Sets ProxyAuthorizationHeader */
   public void setProxyAuthorizationHeader(ProxyAuthorizationHeader h) 
   {  setHeader(h);
   } 
   /** Gets ProxyAuthorizationHeader */
   public ProxyAuthorizationHeader getProxyAuthorizationHeader()
   {  Header h=getHeader(SipHeaders.Proxy_Authorization);
      if (h==null) return null;
      else return new ProxyAuthorizationHeader(h);
   } 
   /** Removes ProxyAuthorizationHeader */
   public void removeProxyAuthorizationHeader() 
   {  removeHeader(SipHeaders.Proxy_Authorization);
   }

   
   
   //**************************** RFC 2543 Legacy ****************************/


   /** Checks whether the next Route is formed according to RFC2543 Strict Route
     * and adapts the message. */
   public void rfc2543RouteAdapt() 
   {  if (hasRouteHeader())
      {  MultipleHeader mrh=getRoutes();
         RouteHeader rh=new RouteHeader(mrh.getTop());
         if (!(new RouteHeader(mrh.getTop())).getNameAddress().getAddress().hasLr())
         {  // re-format the message according to the RFC2543 Strict Route rule
            SipURL next_hop=(new RouteHeader(mrh.getTop())).getNameAddress().getAddress();
            SipURL recipient=getRequestLine().getAddress();
            mrh.removeTop();
            mrh.addBottom(new RouteHeader(new NameAddress(recipient)));
            setRoutes(mrh);
            setRequestLine(new RequestLine(getRequestLine().getMethod(),next_hop));
         }   
      }
   }
  

   /** Changes form RFC2543 Strict Route to RFC3261 Lose Route.
     * <p> The Request-URI is replaced with the last
     * value from the Route header, and that value is removed from the
     * Route header. */
   public void rfc2543toRfc3261RouteUpdate() 
   {  // the message is formed according with RFC2543 strict route
      // the next hop is the request-uri
      // the recipient of the message is the last Route value
      RequestLine request_line=getRequestLine();
      SipURL next_hop=request_line.getAddress();
      MultipleHeader mrh=getRoutes();
      SipURL target=(new RouteHeader(mrh.getBottom())).getNameAddress().getAddress();
      mrh.removeBottom();
      next_hop.addLr();
      mrh.addTop(new RouteHeader(new NameAddress(next_hop)));
      removeRoutes();
      addRoutes(mrh);
      setRequestLine(new RequestLine(request_line.getMethod(),target));
   }

}