sipmessageparser.java

jsr-180 (SIP) 实现源码。可以在真实手机上使用

              byte1 = 10;
              byte0 = 9;
              break;

            default:
              k = addByteData(i, k);
              break;
          }
          break;
      }
    }
    while (!flag2);
    if (k != 0) {
      k = addHeader(headers, k);
    }
  }

  /**
   * getContent
   * 
   * @param sipMessage
   * @param headers
   * @param header
   * @return content
   * @throws IOException
   * @throws SipException
   */
  public byte[] getContent(InputStream sipMessage, Vector headers,
      PairStructure header) throws IOException, SipException {
    PairStructure t2 = removeHeader(headers, "Content-Length");
    if (t2 == null) {
      t2 = new PairStructure("Content-Length", "0");
    }
    byte abyte0[] = parseSipMessageBody(sipMessage);
    int i = 0;
    if (abyte0 == null) {
      i = 0;
    }
    else {
      i = abyte0.length;
    }
    int k = Integer.parseInt(t2.getValue());
    if (k >= 0 && k <= i) {
      if (abyte0 != null && k != 0 && k < i) {
        byte abyte1[] = new byte[k];
        System.arraycopy(((Object) (abyte0)), 0, ((Object) (abyte1)), 0, k);
        abyte0 = abyte1;
      }
      else if (header != null && header.getValue().equals("text/lpidf")) {
        t2.setValue("0");
      }
      else if (header != null && t2.getValue().equals("0")) {
        t2.setValue(Integer.toString(i));
      }
    }
    else {
      m_correct = false;
      m_errorMessage = "Size of the payload is wrong Content-Length=" + k
          + " buffer=" + sipMessage.available();
      t2.setValue("0");
    }
    addHeader(headers, t2.getName(), t2.getValue());
    if (t2.getValue().equals("0")) {
      abyte0 = null;
    }
    return abyte0;
  }

  /**
   * parseSipMessageBody
   * 
   * @param sipMessage
   * @return sipMessageBodys
   * @throws IOException
   */
  private byte[] parseSipMessageBody(InputStream sipMessage) throws IOException {
    byte abyte0[] = new byte[sipMessage.available()];
    int i = 0;
    byte byte0 = 11;
    boolean flag = false;
    do {
      int k;
      if ((k = sipMessage.read()) == -1) {
        break;
      }
      switch (byte0) {
        default:
          break;

        case 11: // '\013'
          switch (k) {
            case 13: // '\r'
              byte0 = 12;
              break;

            case 10: // '\n'
              byte0 = 13;
              break;
          }
          break;

        case 12: // '\f'
          switch (k) {
            case 10: // '\n'
              byte0 = 13;
              break;

            default:
              byte0 = 11;
              break;

            case 13: // '\r'
              break;
          }
          break;

        case 13: // '\r'
          switch (k) {
            case 10: // '\n'
              flag = true;
              break;

            default:
              byte0 = 11;
              break;

            case 13: // '\r'
              break;
          }
          break;
      }
      abyte0[i++] = (byte) k;
    }
    while (!flag);
    if (i != 0) {
      byte abyte1[] = new byte[i];
      System.arraycopy(((Object) (abyte0)), 0, ((Object) (abyte1)), 0, i);
      return abyte1;
    }
    else {
      return null;
    }
  }

  /**
   * assembledSipMessage
   * 
   * @param firstLine
   * @param headers
   * @param content
   * @param contentType
   * @return SipMessage
   * @throws IOException
   * @throws SipException
   */
  private SipMessage assembledSipMessage(Vector firstLine, Vector headers,
      byte content[], PairStructure contentType) throws IOException,
      SipException {
    String s = ((String) firstLine.elementAt(0)).trim();
    PairStructure t2 = getRemovedOnlyHeader(headers, "From");
    PairStructure t3 = getRemovedOnlyHeader(headers, "To");
    PairStructure t4 = getRemovedOnlyHeader(headers, "CSeq");
    PairStructure t5 = getRemovedOnlyHeader(headers, "Call-ID");
    Vector vector2 = removeAllHeader(headers, "Via");
    if (t5 == null || t4 == null || t2 == null || t3 == null
        || vector2.isEmpty()) {
      m_correct = false;
      m_errorMessage = "From = " + t2 + " To = " + t3 + " CallID = " + t5
          + " CSeq = " + t4 + " Via = " + vector2
          + " headers not allowed to be null";
      throw new SipException(m_errorMessage, (byte) 0);
    }
    if (s.startsWith("SIP")) {
      int i = Integer.parseInt((String) firstLine.elementAt(1));
      if (contentType != null)
        headers.insertElementAt(((Object) (contentType)), 0);
      if (vector2 != null) {
        for (int k = vector2.size() - 1; k >= 0; k--)
          headers.insertElementAt(vector2.elementAt(k), 0);

      }
      if (t5 != null)
        headers.insertElementAt(((Object) (t5)), 0);
      if (t4 != null)
        headers.insertElementAt(((Object) (t4)), 0);
      if (t2 != null)
        headers.insertElementAt(((Object) (t2)), 0);
      if (t3 != null)
        headers.insertElementAt(((Object) (t3)), 0);
      SipResponse c1 = new SipResponse(firstLine, headers, content);
      ((SipResponse) c1).setStatusCode(i);
      return ((SipMessage) (c1));
    }
    s = ((String) firstLine.elementAt(2)).trim();
    if (s.startsWith("SIP")) {
      String s1 = (String) firstLine.elementAt(0);
      // Object obj = null;
      // Object obj1 = null;
      SipRequest u1;
      try {
        SipAddress sipaddress = new SipAddress((String) firstLine.elementAt(1));
        if (contentType != null)
          headers.insertElementAt(((Object) (contentType)), 0);
        if (vector2 != null) {
          for (int l = vector2.size() - 1; l >= 0; l--)
            headers.insertElementAt(vector2.elementAt(l), 0);

        }
        if (t5 != null)
          headers.insertElementAt(((Object) (t5)), 0);
        if (t4 != null)
          headers.insertElementAt(((Object) (t4)), 0);
        if (t2 != null)
          headers.insertElementAt(((Object) (t2)), 0);
        if (t3 != null)
          headers.insertElementAt(((Object) (t3)), 0);
        u1 = new SipRequest(firstLine, headers, content);
      }
      catch (Exception exception) {
        m_correct = false;
        m_errorMessage = "SIP Request URI is not valid";
        SipAddress sipaddress1 = new SipAddress((String) firstLine.elementAt(1));
        u1 = new SipRequest(firstLine, headers, content);
      }
      return ((SipMessage) (u1));
    }
    else {
      throw new SipException(
          "Not Request and not Response: Request URI or SIP version is illegal ",
          (byte) 0);
    }
  }

  /**
   * validate, check SIP Version and Request Method and Cseq Method
   * 
   * @param sipRequest
   * @param s
   * @return result
   */
  private boolean validate(SipRequest sipRequest, String s) {
    if (!s.equals("SIP/2.0")) {
      m_correct = false;
      m_errorMessage = "SIP Version should be SIP/2.0 and not " + s;
      return false;
    }
    String s1 = sipRequest.getHeaderValue("CSeq");
    if (s1.indexOf(sipRequest.getMethod()) < 0) {
      m_correct = false;
      m_errorMessage = "Request Method and Cseq Method should match";
    }
    return true;
  }

  /**
   * addByteData
   * 
   * @param data
   * @param pos
   * @return new pos
   */
  private int addByteData(int data, int pos) {
    if (pos >= m_buf.length)
      m_buf = extendDoubleSpace();
    m_buf[pos++] = (byte) data;
    return pos;
  }

  /**
   * extendDoubleSpace
   * 
   * @return bytes
   */
  private byte[] extendDoubleSpace() {
    byte abyte0[] = new byte[m_buf.length * 2];
    System.arraycopy(((Object) (m_buf)), 0, ((Object) (abyte0)), 0,
        m_buf.length);
    return abyte0;
  }

  /**
   * addFirstLinePart
   * 
   * @param firstLine
   * @param pos
   * @return 0
   */
  private int addFirstLinePart(Vector firstLine, int pos) {
    byte abyte0[] = new byte[pos];
    System.arraycopy(((Object) (m_buf)), 0, ((Object) (abyte0)), 0, pos);
    String s = new String(abyte0);
    firstLine.addElement(((Object) (s)));
    m_buf = new byte[120];
    return 0;
  }

  /**
   * parseHeaderNamePart
   * 
   * @param pos
   * @return 0
   */
  private int parseHeaderNamePart(int pos) {
    byte abyte0[] = new byte[pos];
    System.arraycopy(((Object) (m_buf)), 0, ((Object) (abyte0)), 0, pos);
    m_headerName = new String(abyte0);
    m_headerName = m_headerName.trim();
    m_buf = new byte[120];
    return 0;
  }

  /**
   * addHeader
   * 
   * @param headers
   * @param pos
   * @return 0
   */
  private int addHeader(Vector headers, int pos) {
    byte abyte0[] = new byte[pos];
    System.arraycopy(((Object) (m_buf)), 0, ((Object) (abyte0)), 0, pos);
    String s = (new String(abyte0)).trim();
    addHeader(headers, m_headerName, s);
    m_buf = new byte[120];
    return 0;
  }

  /**
   * addHeader
   * 
   * @param headers
   * @param name
   * @param value
   */
  private void addHeader(Vector headers, String name, String value) {
    try {
      headers.addElement(((Object) (new PairStructure(name, value))));
    }
    catch (Exception exception) {
      m_correct = false;
      m_errorMessage = exception.getMessage();
    }
  }

  /**
   * assembledHex
   * 
   * @param high
   * @param low
   * @return hex, error return -1
   */
  public int assembledHex(int high, int low) {
    low -= 48;
    high -= 48;
    if (9 < low || low < 0)
      return -1;
    if (9 < high || high < 0)
      return -1;
    else
      return low + high * 16;
  }

  /**
   * getHeader
   * 
   * @param headers
   * @param name
   * @return header
   */
  private PairStructure getHeader(Vector headers, String name) {
    Enumeration enumeration = headers.elements();
    Object obj = null;
    while (enumeration.hasMoreElements()) {
      PairStructure t1 = (PairStructure) enumeration.nextElement();
      if (t1.getName().equals(((Object) (name)))
          || t1.getName().equals(
              ((Object) (SipConstants.switchShortName(name)))))
        return t1;
    }
    return null;
  }

  /**
   * removeHeader
   * 
   * @param headers
   * @param header
   */
  private void removeHeader(Vector headers, PairStructure header) {
    if (header != null) {
      headers.removeElement(((Object) (header)));
    }
  }

  /**
   * removeHeader
   * 
   * @param headers
   * @param name
   * @return removedHeader
   */
  private PairStructure removeHeader(Vector headers, String name) {
    PairStructure t1 = getHeader(headers, name);
    removeHeader(headers, t1);
    return t1;
  }

  /**
   * removeAllHeader
   * 
   * @param headers
   * @param name
   * @return type of headers
   */
  private Vector removeAllHeader(Vector headers, String name) {
    boolean flag = true;
    Vector vector1 = new Vector();
    Object obj = null;
    while (flag) {
      PairStructure t1 = getHeader(headers, name);
      if (t1 != null) {
        vector1.addElement(((Object) (t1)));
        removeHeader(headers, t1);
      }
      else {
        flag = false;
      }
    }
    return vector1;
  }

  /**
   * getRemovedOnlyHeader
   * 
   * @param headers
   * @param name
   * @return header
   */
  private PairStructure getRemovedOnlyHeader(Vector headers, String name) {
    Vector vector1 = removeAllHeader(headers, name);
    if (vector1.isEmpty()) {
      m_correct = false;
      m_errorMessage = "Header " + name + "in missing";
      return null;
    }
    if (vector1.size() > 1) {
      m_correct = false;
      m_errorMessage = "More than 1 header " + name + "in the message";
    }
    return (PairStructure) vector1.elementAt(0);
  }
}