basemessage.java

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

   protected void addHeaders(String str, boolean top) 
   {  int i,aux;
      if (top)
      {  if (this.hasRequestLine() || this.hasStatusLine())
         {  SipParser par=new SipParser(message);
            par.goToNextHeader();
            i=par.getPos();
         }
         else i=0;   
      }
      else
      {  SipParser par=new SipParser(message);
         // index the end of headers
         i=par.goToEndOfLastHeader().goToNextLine().getPos();         
         par=new SipParser(message);
         // if Content_Length is present, jump before
         aux=par.indexOfHeader(SipHeaders.Content_Length);
         if (aux<i) i=aux;
         // if Content_Type is present, jump before
         aux=par.indexOfHeader(SipHeaders.Content_Type);
         if (aux<i) i=aux; 
      }            
      String head=message.substring(0,i);
      String tail=message.substring(i);
      String new_message=head.concat(str);
      new_message=new_message.concat(tail);
      message=new_message;
   }

   /** Adds Headers on position <i>index</i> within the Message */
   protected void addHeaders(String str, int index) 
   {  if (index>message.length()) index=message.length();
      message=message.substring(0,index)+str+message.substring(index);
   }

   /** Adds Header before the first header <i>refer_header</i>
     * . <p>If there is no header of such type, it is added at top */
   public void addHeaderBefore(Header new_header, String refer_header) 
   {  addHeadersBefore(new_header.toString(),refer_header);
   }

   /** Adds MultipleHeader(s) before the first header <i>refer_header</i>
     * . <p>If there is no header of such type, they are added at top */
   public void addHeadersBefore(MultipleHeader mheader, String refer_header) 
   {  addHeadersBefore(mheader.toString(),refer_header);
   }

   /** Adds Headers before the first header <i>refer_header</i>
     * . <p>If there is no header of such type, they are added at top */
   protected void addHeadersBefore(String str, String refer_header) 
   {  if (!hasHeader(refer_header)) addHeaders(str,true);
      else
      {  SipParser par=new SipParser(message);
         par.goTo(refer_header);
         int here=par.getPos();
         message=message.substring(0,here)+str+message.substring(here);
      }
   }

   /** Adds Header after the first header <i>refer_header</i>
     * . <p>If there is no header of such type, it is added at bottom */
   public void addHeaderAfter(Header new_header, String refer_header) 
   {  addHeadersAfter(new_header.toString(),refer_header);
   }

   /** Adds MultipleHeader(s) after the first header <i>refer_header</i>
     * . <p>If there is no header of such type, they are added at bottom */
   public void addHeadersAfter(MultipleHeader mheader, String refer_header) 
   {  addHeadersAfter(mheader.toString(),refer_header);
   }

   /** Adds Headers after the first header <i>refer_header</i>
     * . <p>If there is no header of such type, they are added at bottom */
   protected void addHeadersAfter(String str, String refer_header) 
   {  if (!hasHeader(refer_header)) addHeaders(str,false);
      else
      {  SipParser par=new SipParser(message);
         par.goTo(refer_header);
         int here=par.indexOfNextHeader();
         message=message.substring(0,here)+str+message.substring(here);
      }
   }

   /** Removes first Header of specified name */
   public void removeHeader(String hname)
   {  removeHeader(hname,true);
   }

   /** Removes first (or last) Header of specified name */
   public void removeHeader(String hname, boolean first)
   {  String[] target={'\n'+hname, '\r'+hname};
      SipParser par=new SipParser(message);
      par.goTo(target);
      if (!par.hasMore()) return;
      if (!first)
         while(true)
         {  int next=par.indexOf(target);
            if (next<0) break;
            par.setPos(next);
         }
      par.skipChar();
      String head=message.substring(0,par.getPos());
      par.goToNextHeader();
      String tail=message.substring(par.getPos());
      message=head.concat(tail);
   }
   
   /** Sets the new Header (removing any previous headers of the same name) */
   /*public void setHeader(Header hd) 
   {  if (hasHeader(hd.getName())) removeAllHeaders(hd.getName());
      addHeader(hd,false);               
   }*/          

   /** Sets the Header <i>hd</i> removing any previous headers of the same type */
   public void setHeader(Header hd) 
   {  String hname=hd.getName();
      if (hasHeader(hname))
      {  int index=(new SipParser(message)).indexOfHeader(hname);
         removeAllHeaders(hname);
         addHeaders(hd.toString(),index);
      }
      else
         addHeader(hd,false);               
   }          

   /** Removes all Headers of specified name */
   public void removeAllHeaders(String hname) 
   {  String[] target={'\n'+hname, '\r'+hname};
      SipParser par=new SipParser(message);
      par.goTo(target);
      while (par.hasMore())
      {  par.skipChar();
         String head=message.substring(0,par.getPos());
         String tail=message.substring(par.indexOfNextHeader());
         message=head.concat(tail);
         par=new SipParser(message,par.getPos()-1);
         par.goTo(target);
      }         
   }
   
   /** Sets MultipleHeader <i>mheader</i> */
   /*public void setHeaders(MultipleHeader mheader) 
   {  if (hasHeader(mheader.getName())) removeAllHeaders(mheader.getName());
      addHeaders(mheader,false);            
   }*/          

   /** Sets MultipleHeader <i>mheader</i> */
   public void setHeaders(MultipleHeader mheader) 
   {  String hname=mheader.getName();
      if (hasHeader(hname))
      {  int index=(new SipParser(message)).indexOfHeader(hname);
         removeAllHeaders(hname);
         addHeaders(mheader.toString(),index);
      }
      else
         addHeaders(mheader,false);            
   }          


   //**************************** Specific Headers ****************************/

   /** Whether Message has MaxForwardsHeader */
   public boolean hasMaxForwardsHeader()
   {  return hasHeader(SipHeaders.Max_Forwards);
   }  
   /** Gets MaxForwardsHeader of Message */
   public MaxForwardsHeader getMaxForwardsHeader()
   {  Header h=getHeader(SipHeaders.Max_Forwards);
      if (h==null) return null;
      else return new MaxForwardsHeader(h);
   } 
   /** Sets MaxForwardsHeader of Message */
   public void setMaxForwardsHeader(MaxForwardsHeader mfh)
   {  setHeader(mfh);
   }  
   /** Removes MaxForwardsHeader from Message */
   public void removeMaxForwardsHeader() 
   {  removeHeader(SipHeaders.Max_Forwards);
   }

     
   /** Whether Message has FromHeader */
   public boolean hasFromHeader()
   {  return hasHeader(SipHeaders.From);
   }  
   /** Gets FromHeader of Message */
   public FromHeader getFromHeader()
   {  Header h=getHeader(SipHeaders.From);
      if (h==null) return null;
      else return new FromHeader(h);
   } 
   /** Sets FromHeader of Message */
   public void setFromHeader(FromHeader fh) 
   {  setHeader(fh);
   }  
   /** Removes FromHeader from Message */
   public void removeFromHeader() 
   {  removeHeader(SipHeaders.From);
   }

   /** Whether Message has ToHeader */
   public boolean hasToHeader()
   {  return hasHeader(SipHeaders.To);
   } 
   /** Gets ToHeader of Message */
   public ToHeader getToHeader()
   {  Header h=getHeader(SipHeaders.To);
      if (h==null) return null;
      else return new ToHeader(h);
   } 
   /** Sets ToHeader of Message */
   public void setToHeader(ToHeader th) 
   {  setHeader(th);
   } 
   /** Removes ToHeader from Message */
   public void removeToHeader() 
   {  removeHeader(SipHeaders.To);
   }

   
   /** Whether Message has ContactHeader */
   public boolean hasContactHeader()
   {  return hasHeader(SipHeaders.Contact);
   }
   /** <b>Deprecated</b>. Gets ContactHeader of Message. Use getContacts instead. */  
   public ContactHeader getContactHeader()
   {  //Header h=getHeader(SipHeaders.Contact);
      //if (h==null) return null; else return new ContactHeader(h);
      MultipleHeader mh=getContacts();
      if (mh==null) return null; return new ContactHeader(mh.getTop());
   } 
   /** Adds ContactHeader */
   public void addContactHeader(ContactHeader ch, boolean top) 
   {  addHeader(ch,top);
   }   
   /** Sets ContactHeader */
   public void setContactHeader(ContactHeader ch) 
   {  if (hasContactHeader()) removeContacts();
      addHeader(ch,false);
   }
   /** Gets a MultipleHeader of Contacts */
   public MultipleHeader getContacts()
   {  Vector v=getHeaders(SipHeaders.Contact);
      if (v.size()>0) return new MultipleHeader(v);
      else return null;
   }   
   /** Adds Contacts */
   public void addContacts(MultipleHeader contacts, boolean top) 
   {  addHeaders(contacts,top);
   }   
   /** Sets Contacts */
   public void setContacts(MultipleHeader contacts) 
   {  if (hasContactHeader()) removeContacts();
      addContacts(contacts,false);
   }    
   /** Removes ContactHeaders from Message */
   public void removeContacts() 
   {  removeAllHeaders(SipHeaders.Contact);
   }
 
   
   /** Whether Message has ViaHeaders */
   public boolean hasViaHeader()
   {  return hasHeader(SipHeaders.Via);
   }      
   /** Adds ViaHeader at the top */
   public void addViaHeader(ViaHeader vh) 
   {  addHeader(vh,true);
   } 
   /** Gets the first ViaHeader */
   public ViaHeader getViaHeader()
   {  //Header h=getHeader(SipHeaders.Via);
      //if (h==null) return null; else return new ViaHeader(h);
      MultipleHeader mh=getVias();
      if (mh==null) return null; return new ViaHeader(mh.getTop());
   } 
   /** Removes the top ViaHeader */
   public void removeViaHeader() 
   {  //removeHeader(SipHeaders.Via);
      MultipleHeader mh=getVias();
      mh.removeTop();
      setVias(mh);
   }  
   /** Gets all Vias */
   public MultipleHeader getVias()
   {  Vector v=getHeaders(SipHeaders.Via);
      if (v.size()>0) return new MultipleHeader(v);
      else return null;
   }
   /** Adds Vias */
   public void addVias(MultipleHeader vias, boolean top) 
   {  addHeaders(vias,top);
   }   
   /** Sets Vias */
   public void setVias(MultipleHeader vias) 
   {  if (hasViaHeader()) removeVias();
      addContacts(vias,true);
   }    
   /** Removes ViaHeaders from Message (if any exists) */
   public void removeVias() 
   {  removeAllHeaders(SipHeaders.Via);
   }
   
      
   /** Whether Message has RouteHeader */
   public boolean hasRouteHeader()
   {  return hasHeader(SipHeaders.Route);
   }      
   /** Adds RouteHeader at the top */
   public void addRouteHeader(RouteHeader h) 
   {  addHeaderAfter(h,SipHeaders.Via);
   } 
   /** Adds multiple Route headers at the top */
   public void addRoutes(MultipleHeader routes) 
   {  addHeadersAfter(routes,SipHeaders.Via);
   } 
   /** Gets the top RouteHeader */
   public RouteHeader getRouteHeader()
   {  //Header h=getHeader(SipHeaders.Route);
      //if (h==null) return null; else return new RouteHeader(h);
      MultipleHeader mh=getRoutes();
      if (mh==null) return null; return new RouteHeader(mh.getTop());
   } 
   /** Gets the whole route */
   public MultipleHeader getRoutes()
   {  Vector v=getHeaders(SipHeaders.Route);
      if (v.size()>0) return new MultipleHeader(v);
      else return null;
   }
   /** Removes the top RouteHeader */
   public void removeRouteHeader() 
   {  //removeHeader(SipHeaders.Route);
      MultipleHeader mh=getRoutes();
      mh.removeTop();
      setRoutes(mh);
   }  
   /** Removes all RouteHeaders from Message (if any exists) */
   public void removeRoutes() 
   {  removeAllHeaders(SipHeaders.Route);
   }
   /** Sets the whole route */
   public void setRoutes(MultipleHeader routes) 
   {  if (hasRouteHeader()) removeRoutes();
      addRoutes(routes);
   }    
   

   /** Whether Message has RecordRouteHeader */
   public boolean hasRecordRouteHeader()
   {  return hasHeader(SipHeaders.Record_Route);
   }      
   /** Adds RecordRouteHeader at the top */
   public void addRecordRouteHeader(RecordRouteHeader rr) 
   {  //addHeaderAfter(rr,SipHeaders.Via);
      addHeaderAfter(rr,SipHeaders.CSeq);
   } 
   /** Adds multiple RecordRoute headers at the top */
   public void addRecordRoutes(MultipleHeader routes) 
   {  //addHeadersAfter(routes,SipHeaders.Via);
      addHeadersAfter(routes,SipHeaders.CSeq);
   } 
   /** Gets the top RecordRouteHeader */
   public RecordRouteHeader getRecordRouteHeader()
   {  //Header h=getHeader(SipHeaders.Record_Route);
      //if (h==null) return null; else return new RecordRouteHeader(h);
      MultipleHeader mh=getRecordRoutes();
      if (mh==null) return null; return new RecordRouteHeader(mh.getTop());
   } 
   /** Gets the whole RecordRoute headers */
   public MultipleHeader getRecordRoutes()
   {  Vector v=getHeaders(SipHeaders.Record_Route);
      if (v.size()>0) return new MultipleHeader(v);
      else return null;
   }
   /** Removes the top RecordRouteHeader */
   public void removeRecordRouteHeader() 
   {  //removeHeader(SipHeaders.Record_Route);
      MultipleHeader mh=getRecordRoutes();
      mh.removeTop();
      setRecordRoutes(mh);
   }  
   /** Removes all RecordRouteHeader from Message (if any exists) */
   public void removeRecordRoutes() 
   {  removeAllHeaders(SipHeaders.Record_Route);
   }
   /** Sets the whole RecordRoute headers */
   public void setRecordRoutes(MultipleHeader routes) 
   {  if (hasRecordRouteHeader()) removeRecordRoutes();
      addRecordRoutes(routes);
   }


   /** Whether Message has CSeqHeader */
   public boolean hasCSeqHeader()
   {  return hasHeader(SipHeaders.CSeq);
   }  
   /** Gets CSeqHeader of Message */
   public CSeqHeader getCSeqHeader()
   {  Header h=getHeader(SipHeaders.CSeq);
      if (h==null) return null;
      else return new CSeqHeader(h);
   } 
   /** Sets CSeqHeader of Message */
   public void setCSeqHeader(CSeqHeader csh) 
   {  setHeader(csh);
   } 
   /** Removes CSeqHeader from Message */
   public void removeCSeqHeader() 
   {  removeHeader(SipHeaders.CSeq);
   }
   
      
   /** Whether has CallIdHeader */
   public boolean hasCallIdHeader()
   {  return hasHeader(SipHeaders.Call_ID);
   }
   /** Sets CallIdHeader of Message */
   public void setCallIdHeader(CallIdHeader cih) 
   {  setHeader(cih);