android-15.0.0_r3/s

/*
 * 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*", "");
    }
}