header.java

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

   * @throws IllegalArgumentException
   */
  public void setName(String name) throws IllegalArgumentException {
    checkAuthorization(name);
  }

  /**
   * getName
   * 
   * @return name
   */
  public String getName() {
    return m_name;
  }

  /**
   * getValue
   * 
   * @return value
   */
  public String getValue() {
    return m_value;
  }

  /**
   * getHeaderValue
   * 
   * @return headerValue
   */
  public String getHeaderValue() {
    StringBuffer stringbuffer = new StringBuffer();
    if (m_parametersContainer.hasParameter()) {
      stringbuffer.append(m_value);
      if (m_authorization)
        stringbuffer.append(" ");
      stringbuffer.append(m_parametersContainer.toString());
    }
    else {
      stringbuffer.append(m_value);
    }
    return stringbuffer.toString();
  }

  /**
   * setValue
   * 
   * @param value
   * @throws IllegalArgumentException
   */
  public void setValue(String value) throws IllegalArgumentException {
    String s1;
    s1 = null;
    if (value == null) {
      throw new NullPointerException("Value null");
    }
    value = value.trim();
    if (value.length() == 0) {
      throw new IllegalArgumentException("Empty value");
    }
    try {
      if (m_authorization) {
        Vector vector = SipHeaderParser.parseString(value);
        Cache o1 = (Cache) vector.elementAt(0);
        if (vector.size() > 2 || o1.m_ctrlState != 1 && o1.m_ctrlState != 5) {
          throw new IllegalArgumentException("Illegal auth scheme: " + value);
        }
        else {
          m_value = value;
          return;
        }
      }
      s1 = getAuthenticationValue(value);
      if (!s1.equals(((Object) (value)))) {
        throw new IllegalArgumentException(
            "Possibly trying to set value with parameters '" + value + "'");
      }
      else {
        m_value = s1;
        return;
      }
    }
    catch (SipException sipexception) {
      throw new IllegalArgumentException(sipexception.getMessage());
    }
  }

  /**
   * getParameter
   * 
   * @param name
   * @return value
   */
  public String getParameter(String name) {
    return m_parametersContainer.getParameter(name);
  }

  /**
   * getParameterNames
   * 
   * @return names
   */
  public String[] getParameterNames() {
    return m_parametersContainer.getParameterNames();
  }

  /**
   * resetParameter
   * 
   * @param name
   * @param value
   * @throws IllegalArgumentException
   */
  public void resetParameter(String name, String value)
      throws IllegalArgumentException {
    if (name == null) {
      throw new NullPointerException("Parameter name null");
    }
    name = name.trim();
    if (name.length() == 0) {
      throw new IllegalArgumentException("Empty parameter name");
    }
    checkParameterName(name);
    try {
      if (value != null) {
        checkParameterValue(value);
        if (m_parametersContainer.contains(name)) {
          removeParameter(name);
        }
        if (value.length() == 0) {
          m_parametersContainer.setParameter(name, "\"\"");
        }
        else {
          m_parametersContainer.setParameter(name, value);
        }
      }
      else {
        if (m_parametersContainer.contains(name)) {
          removeParameter(name);
        }
        m_parametersContainer.setParameter(name, "");
      }
    }
    catch (Exception exception) {
      throw new IllegalArgumentException(exception.getMessage());
    }
  }

  /**
   * removeParameter
   * 
   * @param name
   */
  public void removeParameter(String name) {
    if (name != null) {
      m_parametersContainer.removeParameter(name);
    }
  }

  /**
   * toString
   * 
   * @return String
   */
  public String toString() {
    StringBuffer stringbuffer = new StringBuffer(m_name);
    stringbuffer.append(": ");
    if (m_parametersContainer.hasParameter()) {
      stringbuffer.append(m_value);
      if (m_authorization)
        stringbuffer.append(" ");
      stringbuffer.append(m_parametersContainer.toString());
    }
    else {
      stringbuffer.append(m_value);
    }
    return stringbuffer.toString();
  }

  /**
   * getAuthenticationValue
   * 
   * @param value
   * @return authentication header value
   * @throws SipException
   */
  private String getAuthenticationValue(String value) throws SipException {
    try {
      int k;
      if (m_authorization) {
        int i = value.indexOf(' ');
        if (i <= 0) {
          throw new SipException("Invalid authentication header value",
              (byte) 0);
        }
        else {
          return value.substring(0, i).trim();
        }
      }
      int j = value.indexOf('<');
      k = value.indexOf('>');
      if (j == -1 && k == -1) {
        int l = value.indexOf(';');
        if (l > 0) {
          return value.substring(0, l).trim();
        }
        if (l == 0) {
          throw new SipException("no header value", (byte) 0);
        }
        else {
          return value.trim();
        }
      }
      return value.substring(0, k + 1).trim();
    }
    catch (StringIndexOutOfBoundsException stringindexoutofboundsexception) {
      throw new SipException("Invalid header value", (byte) 0);
    }
  }

  /**
   * parseParameters
   * 
   * @param value
   * @throws SipException
   */
  private void parseParameters(String value) throws SipException {
    value = value.trim();
    if (value.length() == 0) {
      throw new SipException("Header value empty", (byte) 0);
    }
    m_value = getAuthenticationValue(value);
    if (m_value == value) {
      return;
    }
    int i = value.indexOf('>');
    int j = -1;
    if (m_authorization) {
      m_listSeparatorChar = 44;
      j = m_value.length();
    }
    else if (i == -1) {
      j = value.indexOf(';');
    }
    else {
      j = value.indexOf(';', i);
    }
    if (j == -1) {
      return;
    }
    Vector vector = SipHeaderParser.parseString(value.substring(j));
    // Object obj = null;
    StringBuffer stringbuffer = new StringBuffer();
    _fldif = 1;
    for (short word0 = 0; word0 < vector.size(); word0++) {
      Cache o1 = (Cache) vector.elementAt(((int) (word0)));
      switch (_fldif) {
        case 3: // '\003'
        default:
          break;

        case 1: // '\001'
          switch (o1.m_ctrlState) {
            case 1: // '\001'
            case 5: // '\005'
              stringbuffer.append(o1.m_paragraph);
              break;

            case 2: // '\002'
              if (o1.m_initial == '=')
                _fldif = 2;
              else if (o1.m_initial == '>') {
                if (stringbuffer.length() > 0)
                  setParameter(stringbuffer, "");
                _fldif = 3;
              }
              else if (o1.m_initial == m_listSeparatorChar) {
                if (stringbuffer.length() > 0)
                  setParameter(stringbuffer, "");
              }
              else {
                error("Illegal parameter name '" + o1.m_paragraph + "'");
              }
              break;

            case -1:
              if (stringbuffer.length() > 0)
                setParameter(stringbuffer, "");
              _fldif = 3;
              break;

            case 0: // '\0'
            case 3: // '\003'
            case 4: // '\004'
            default:
              error("Illegal parameter name '" + o1.m_paragraph + "'");
              break;
          }
          break;

        case 2: // '\002'
          switch (o1.m_ctrlState) {
            case 1: // '\001'
            case 3: // '\003'
            case 5: // '\005'
            case 6: // '\006'
            case 7: // '\007'
              if (stringbuffer.length() == 0)
                error("Empty parameter name, for '" + o1.m_paragraph + "'");
              if (o1.m_ctrlState == 7)
                o1.m_paragraph = new String("\"" + o1.m_paragraph + "\"");
              setParameter(stringbuffer, o1.m_paragraph);
              _fldif = 1;
              break;

            case 2: // '\002'
            case 4: // '\004'
            default:
              error("Empty parameter value, for parameter '" + stringbuffer
                  + "'");
              break;
          }
          break;
      }
    }

  }

  /**
   * setParameter
   * 
   * @param nameBuf
   * @param value
   * @throws SipException
   */
  private void setParameter(StringBuffer nameBuf, String value)
      throws SipException {
    checkParameter(nameBuf.toString());
    m_parametersContainer.setParameter(nameBuf.toString(), value);
    nameBuf.setLength(0);
  }

  /**
   * error
   * 
   * @param message
   * @throws SipException
   */
  private static void error(String message) throws SipException {
    throw new SipException(message, (byte) 0);
  }

  /**
   * checkParameter
   * 
   * @param name
   * @throws SipException
   */
  private void checkParameter(String name) throws SipException {
    if (m_parametersContainer.contains(name)) {
      throw new SipException("Duplicate header parameter '" + name + "'",
          (byte) 0);
    }
  }
}