blob: 804d1ed57eb6beb066623a0ff503f270a93be730 [file] [log] [blame]
/*
* 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*", "");
}
}