388 lines
16 KiB
Java
388 lines
16 KiB
Java
/*
|
|
* Copyright (C) 2020 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.internal.telephony;
|
|
|
|
import android.net.Uri;
|
|
import android.util.ArraySet;
|
|
import android.util.Log;
|
|
import android.util.Pair;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.stream.Collectors;
|
|
|
|
/**
|
|
* Utility methods for parsing parts of {@link android.telephony.ims.SipMessage}s.
|
|
* See RFC 3261 for more information.
|
|
* @hide
|
|
*/
|
|
// Note: This is lightweight in order to avoid a full SIP stack import in frameworks/base.
|
|
public class SipMessageParsingUtils {
|
|
private static final String TAG = "SipMessageParsingUtils";
|
|
// "Method" in request-line
|
|
// Request-Line = Method SP Request-URI SP SIP-Version CRLF
|
|
private static final String[] SIP_REQUEST_METHODS = new String[] {"INVITE", "ACK", "OPTIONS",
|
|
"BYE", "CANCEL", "REGISTER", "PRACK", "SUBSCRIBE", "NOTIFY", "PUBLISH", "INFO", "REFER",
|
|
"MESSAGE", "UPDATE"};
|
|
|
|
// SIP Version 2.0 (corresponding to RCS 3261), set in "SIP-Version" of Status-Line and
|
|
// Request-Line
|
|
//
|
|
// Request-Line = Method SP Request-URI SP SIP-Version CRLF
|
|
// Status-Line = SIP-Version SP Status-Code SP Reason-Phrase CRLF
|
|
private static final String SIP_VERSION_2 = "SIP/2.0";
|
|
|
|
// headers are formatted Key:Value
|
|
private static final String HEADER_KEY_VALUE_SEPARATOR = ":";
|
|
// Multiple of the same header can be concatenated and put into one header Key:Value pair, for
|
|
// example "v: XX1;branch=YY1,XX2;branch=YY2". This needs to be treated as two "v:" headers.
|
|
private static final String SUBHEADER_VALUE_SEPARATOR = ",";
|
|
|
|
// SIP header parameters have the format ";paramName=paramValue"
|
|
private static final String PARAM_SEPARATOR = ";";
|
|
// parameters are formatted paramName=ParamValue
|
|
private static final String PARAM_KEY_VALUE_SEPARATOR = "=";
|
|
|
|
// The via branch parameter definition
|
|
private static final String BRANCH_PARAM_KEY = "branch";
|
|
|
|
// via header key
|
|
private static final String VIA_SIP_HEADER_KEY = "via";
|
|
// compact form of the via header key
|
|
private static final String VIA_SIP_HEADER_KEY_COMPACT = "v";
|
|
|
|
// call-id header key
|
|
private static final String CALL_ID_SIP_HEADER_KEY = "call-id";
|
|
// compact form of the call-id header key
|
|
private static final String CALL_ID_SIP_HEADER_KEY_COMPACT = "i";
|
|
|
|
// from header key
|
|
private static final String FROM_HEADER_KEY = "from";
|
|
// compact form of the from header key
|
|
private static final String FROM_HEADER_KEY_COMPACT = "f";
|
|
|
|
// to header key
|
|
private static final String TO_HEADER_KEY = "to";
|
|
// compact form of the to header key
|
|
private static final String TO_HEADER_KEY_COMPACT = "t";
|
|
|
|
// The tag parameter found in both the from and to headers
|
|
private static final String TAG_PARAM_KEY = "tag";
|
|
|
|
// accept-contact header key
|
|
private static final String ACCEPT_CONTACT_HEADER_KEY = "accept-contact";
|
|
// compact form of the accept-contact header key
|
|
private static final String ACCEPT_CONTACT_HEADER_KEY_COMPACT = "a";
|
|
|
|
/**
|
|
* @return true if the SIP message start line is considered a request (based on known request
|
|
* methods).
|
|
*/
|
|
public static boolean isSipRequest(String startLine) {
|
|
String[] splitLine = splitStartLineAndVerify(startLine);
|
|
if (splitLine == null) return false;
|
|
return verifySipRequest(splitLine);
|
|
}
|
|
|
|
/**
|
|
* @return true if the SIP message start line is considered a response.
|
|
*/
|
|
public static boolean isSipResponse(String startLine) {
|
|
String[] splitLine = splitStartLineAndVerify(startLine);
|
|
if (splitLine == null) return false;
|
|
return verifySipResponse(splitLine);
|
|
}
|
|
|
|
/**
|
|
* Return the via branch parameter, which is used to identify the transaction ID (request and
|
|
* response pair) in a SIP transaction.
|
|
* @param headerString The string containing the headers of the SIP message.
|
|
*/
|
|
public static String getTransactionId(String headerString) {
|
|
// search for Via: or v: parameter, we only care about the first one.
|
|
List<Pair<String, String>> headers = parseHeaders(headerString, true,
|
|
VIA_SIP_HEADER_KEY, VIA_SIP_HEADER_KEY_COMPACT);
|
|
for (Pair<String, String> header : headers) {
|
|
// Headers can also be concatenated together using a "," between each header value.
|
|
// format becomes v: XX1;branch=YY1,XX2;branch=YY2. Need to extract only the first ID's
|
|
// branch param YY1.
|
|
String[] subHeaders = header.second.split(SUBHEADER_VALUE_SEPARATOR);
|
|
for (String subHeader : subHeaders) {
|
|
String paramValue = getParameterValue(subHeader, BRANCH_PARAM_KEY);
|
|
if (paramValue == null) continue;
|
|
return paramValue;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Search a header's value for a specific parameter.
|
|
* @param headerValue The header key's value.
|
|
* @param parameterKey The parameter key we are looking for.
|
|
* @return The value associated with the specified parameter key or {@link null} if that key is
|
|
* not found.
|
|
*/
|
|
private static String getParameterValue(String headerValue, String parameterKey) {
|
|
String[] params = headerValue.split(PARAM_SEPARATOR);
|
|
if (params.length < 2) {
|
|
return null;
|
|
}
|
|
// by spec, each param can only appear once in a header.
|
|
for (String param : params) {
|
|
String[] pair = param.split(PARAM_KEY_VALUE_SEPARATOR);
|
|
if (pair.length < 2) {
|
|
// ignore info before the first parameter
|
|
continue;
|
|
}
|
|
if (pair.length > 2) {
|
|
Log.w(TAG,
|
|
"getParameterValue: unexpected parameter" + Arrays.toString(pair));
|
|
}
|
|
// Trim whitespace in parameter
|
|
pair[0] = pair[0].trim();
|
|
pair[1] = pair[1].trim();
|
|
if (parameterKey.equalsIgnoreCase(pair[0])) {
|
|
return pair[1];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Return the call-id header key's associated value.
|
|
* @param headerString The string containing the headers of the SIP message.
|
|
*/
|
|
public static String getCallId(String headerString) {
|
|
// search for the call-Id header, there should only be one in the headers.
|
|
List<Pair<String, String>> headers = parseHeaders(headerString, true,
|
|
CALL_ID_SIP_HEADER_KEY, CALL_ID_SIP_HEADER_KEY_COMPACT);
|
|
return !headers.isEmpty() ? headers.get(0).second : null;
|
|
}
|
|
|
|
/**
|
|
* @return Return the from header's tag parameter or {@code null} if it doesn't exist.
|
|
*/
|
|
public static String getFromTag(String headerString) {
|
|
// search for the from header, there should only be one in the headers.
|
|
List<Pair<String, String>> headers = parseHeaders(headerString, true,
|
|
FROM_HEADER_KEY, FROM_HEADER_KEY_COMPACT);
|
|
if (headers.isEmpty()) {
|
|
return null;
|
|
}
|
|
// There should only be one from header in the SIP message
|
|
return getParameterValue(headers.get(0).second, TAG_PARAM_KEY);
|
|
}
|
|
|
|
/**
|
|
* @return Return the to header's tag parameter or {@code null} if it doesn't exist.
|
|
*/
|
|
public static String getToTag(String headerString) {
|
|
// search for the to header, there should only be one in the headers.
|
|
List<Pair<String, String>> headers = parseHeaders(headerString, true,
|
|
TO_HEADER_KEY, TO_HEADER_KEY_COMPACT);
|
|
if (headers.isEmpty()) {
|
|
return null;
|
|
}
|
|
// There should only be one from header in the SIP message
|
|
return getParameterValue(headers.get(0).second, TAG_PARAM_KEY);
|
|
}
|
|
|
|
/**
|
|
* Validate that the start line is correct and split into its three segments.
|
|
* @param startLine The start line to verify and split.
|
|
* @return The split start line, which will always have three segments.
|
|
*/
|
|
public static String[] splitStartLineAndVerify(String startLine) {
|
|
String[] splitLine = startLine.split(" ", 3);
|
|
if (isStartLineMalformed(splitLine)) return null;
|
|
return splitLine;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return All feature tags starting with "+" in the Accept-Contact header.
|
|
*/
|
|
public static Set<String> getAcceptContactFeatureTags(String headerString) {
|
|
List<Pair<String, String>> headers = SipMessageParsingUtils.parseHeaders(headerString,
|
|
false, ACCEPT_CONTACT_HEADER_KEY, ACCEPT_CONTACT_HEADER_KEY_COMPACT);
|
|
if (headerString.isEmpty()) {
|
|
return Collections.emptySet();
|
|
}
|
|
Set<String> featureTags = new ArraySet<>();
|
|
for (Pair<String, String> header : headers) {
|
|
String[] splitParams = header.second.split(PARAM_SEPARATOR);
|
|
if (splitParams.length < 2) {
|
|
continue;
|
|
}
|
|
// Start at 1 here, since the first entry is the header value and not params.
|
|
// We only care about IMS feature tags here, so filter tags with a "+"
|
|
Set<String> fts = Arrays.asList(splitParams).subList(1, splitParams.length).stream()
|
|
.map(String::trim).filter(p -> p.startsWith("+")).collect(Collectors.toSet());
|
|
for (String ft : fts) {
|
|
String[] paramKeyValue = ft.split(PARAM_KEY_VALUE_SEPARATOR, 2);
|
|
if (paramKeyValue.length < 2) {
|
|
featureTags.add(ft);
|
|
continue;
|
|
}
|
|
// Splits keys like +a="b,c" into +a="b" and +a="c"
|
|
String[] splitValue = splitParamValue(paramKeyValue[1]);
|
|
for (String value : splitValue) {
|
|
featureTags.add(paramKeyValue[0] + PARAM_KEY_VALUE_SEPARATOR + value);
|
|
}
|
|
}
|
|
}
|
|
return featureTags;
|
|
}
|
|
|
|
/**
|
|
* Takes a string such as "\"a,b,c,d\"" and splits it by "," into a String array of
|
|
* [\"a\", \"b\", \"c\", \"d\"]
|
|
*/
|
|
private static String[] splitParamValue(String paramValue) {
|
|
if (!paramValue.startsWith("\"") && !paramValue.endsWith("\"")) {
|
|
return new String[] {paramValue};
|
|
}
|
|
// Remove quotes on outside
|
|
paramValue = paramValue.substring(1, paramValue.length() - 1);
|
|
String[] splitValues = paramValue.split(",");
|
|
for (int i = 0; i < splitValues.length; i++) {
|
|
// Encapsulate each split value in its own quotations.
|
|
splitValues[i] = "\"" + splitValues[i] + "\"";
|
|
}
|
|
return splitValues;
|
|
}
|
|
|
|
private static boolean isStartLineMalformed(String[] startLine) {
|
|
if (startLine == null || startLine.length == 0) {
|
|
return true;
|
|
}
|
|
// start lines contain three segments separated by spaces (SP):
|
|
// Request-Line = Method SP Request-URI SP SIP-Version CRLF
|
|
// Status-Line = SIP-Version SP Status-Code SP Reason-Phrase CRLF
|
|
return (startLine.length != 3);
|
|
}
|
|
|
|
private static boolean verifySipRequest(String[] request) {
|
|
// Request-Line = Method SP Request-URI SP SIP-Version CRLF
|
|
if (!request[2].contains(SIP_VERSION_2)) return false;
|
|
boolean verified;
|
|
try {
|
|
verified = (Uri.parse(request[1]).getScheme() != null);
|
|
} catch (NumberFormatException e) {
|
|
return false;
|
|
}
|
|
verified &= Arrays.stream(SIP_REQUEST_METHODS).anyMatch(s -> request[0].contains(s));
|
|
return verified;
|
|
}
|
|
|
|
private static boolean verifySipResponse(String[] response) {
|
|
// Status-Line = SIP-Version SP Status-Code SP Reason-Phrase CRLF
|
|
if (!response[0].contains(SIP_VERSION_2)) return false;
|
|
int statusCode;
|
|
try {
|
|
statusCode = Integer.parseInt(response[1]);
|
|
} catch (NumberFormatException e) {
|
|
return false;
|
|
}
|
|
return (statusCode >= 100 && statusCode < 700);
|
|
}
|
|
|
|
/**
|
|
* Parse a String representation of the Header portion of the SIP Message and re-structure it
|
|
* into a List of key->value pairs representing each header in the order that they appeared in
|
|
* the message.
|
|
*
|
|
* @param headerString The raw string containing all headers
|
|
* @param stopAtFirstMatch Return early when the first match is found from matching header keys.
|
|
* @param matchingHeaderKeys An optional list of Strings containing header keys that should be
|
|
* returned if they exist. If none exist, all keys will be returned.
|
|
* (This is internally an equalsIgnoreMatch comparison).
|
|
* @return the matched header keys and values.
|
|
*/
|
|
public static List<Pair<String, String>> parseHeaders(String headerString,
|
|
boolean stopAtFirstMatch, String... matchingHeaderKeys) {
|
|
// Ensure there is no leading whitespace
|
|
headerString = removeLeadingWhitespace(headerString);
|
|
|
|
List<Pair<String, String>> result = new ArrayList<>();
|
|
// Split the string line-by-line.
|
|
String[] headerLines = headerString.split("\\r?\\n");
|
|
if (headerLines.length == 0) {
|
|
return Collections.emptyList();
|
|
}
|
|
|
|
String headerKey = null;
|
|
StringBuilder headerValueSegment = new StringBuilder();
|
|
// loop through each line, either parsing a "key: value" pair or appending values that span
|
|
// multiple lines.
|
|
for (String line : headerLines) {
|
|
// This line is a continuation of the last line if it starts with whitespace or tab
|
|
if (line.startsWith("\t") || line.startsWith(" ")) {
|
|
headerValueSegment.append(removeLeadingWhitespace(line));
|
|
continue;
|
|
}
|
|
// This line is the start of a new key, If headerKey/value is already populated from a
|
|
// previous key/value pair, add it to list of parsed header pairs.
|
|
if (headerKey != null) {
|
|
final String key = headerKey;
|
|
if (matchingHeaderKeys == null || matchingHeaderKeys.length == 0
|
|
|| Arrays.stream(matchingHeaderKeys).anyMatch(
|
|
(s) -> s.equalsIgnoreCase(key))) {
|
|
result.add(new Pair<>(key, headerValueSegment.toString()));
|
|
if (stopAtFirstMatch) {
|
|
return result;
|
|
}
|
|
}
|
|
headerKey = null;
|
|
headerValueSegment = new StringBuilder();
|
|
}
|
|
|
|
// Format is "Key:Value", ignore any ":" after the first.
|
|
String[] pair = line.split(HEADER_KEY_VALUE_SEPARATOR, 2);
|
|
if (pair.length < 2) {
|
|
// malformed line, skip
|
|
Log.w(TAG, "parseHeaders - received malformed line: " + line);
|
|
continue;
|
|
}
|
|
|
|
headerKey = pair[0].trim();
|
|
for (int i = 1; i < pair.length; i++) {
|
|
headerValueSegment.append(removeLeadingWhitespace(pair[i]));
|
|
}
|
|
}
|
|
// Pick up the last pending header being parsed, if it exists.
|
|
if (headerKey != null) {
|
|
final String key = headerKey;
|
|
if (matchingHeaderKeys == null || matchingHeaderKeys.length == 0
|
|
|| Arrays.stream(matchingHeaderKeys).anyMatch(
|
|
(s) -> s.equalsIgnoreCase(key))) {
|
|
result.add(new Pair<>(key, headerValueSegment.toString()));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static String removeLeadingWhitespace(String line) {
|
|
return line.replaceFirst("^\\s*", "");
|
|
}
|
|
}
|