im/imps/PtsPrimitiveParser.java

/*
 * Copyright (C) 2007 Esmertec AG.
 * Copyright (C) 2007 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.im.imps;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.android.im.imps.Primitive.TransactionMode;

/**
 * PTS/SMS encoded IMPS messages parser. Only response transactions and
 * server initiated requests are supported.
 */
public class PtsPrimitiveParser implements PrimitiveParser {

    // WVaaBBcccDD <parameters>
    //   aa - version number; 12 for 1.2, 13 for 1.3; "XX" for version discovery
    //   BB - message type, case insensitive
    //   ccc - transaction id in range 0-999 without preceding zero
    //   DD - multiple SMSes identifier
    private static final Pattern sPreamplePattern =
        Pattern.compile("\\AWV(\\d{2})(\\p{Alpha}{2})(\\d{1,3})(\\p{Alpha}{2})?(\\z| .*)");

    private char mReadBuf[] = new char[256];
    private StringBuilder mStringBuf = new StringBuilder();
    private int mPos;

    private static int UNCERTAIN_GROUP_SIZE = -1;

    public Primitive parse(InputStream in) throws ParserException, IOException {
        // assuming PTS data is always short
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(in, "UTF-8"), 128);
        mStringBuf.setLength(0);
        mPos = 0;
        int len;
        while ((len = reader.read(mReadBuf)) != -1) {
            mStringBuf.append(mReadBuf, 0, len);
        }
        return parsePrim();
    }

    private Primitive parsePrim() throws ParserException
    {
        Matcher m = sPreamplePattern.matcher(mStringBuf);
        if (!m.matches()) {
            throw new ParserException("Invalid PTS encoded message");
        }

        Primitive p = new Primitive();

        // TODO: handle WV version in m.group(1)

        String type = m.group(2).toUpperCase();
        String transactionType = PtsCodes.getTransaction(type);
        if (transactionType == null) {
            throw new ParserException("Unrecognized transaction code " + type);
        }
        p.setContentElement(transactionType);

        if (PtsCodes.isServerRequestCode(type)) {
            p.setTransactionMode(TransactionMode.Request);
        } else {
            p.setTransactionMode(TransactionMode.Response);
        }

        p.setTransactionId(m.group(3));
        mPos = m.start(5);

        if (mPos < mStringBuf.length()) {
            match(' ');

            HashMap<String, ParamValue> params = parseParams();
            for (Entry<String, ParamValue> param : params.entrySet()) {
                translateParam(p, param.getKey(), param.getValue());
            }
        }
        return p;
    }

    private static HashMap<String, Integer> sInfoElemTypeMap;
    private static final int ELEM_OTHER_SIMPLE         = 0;
    private static final int ELEM_SESSION_ID           = 1;
    private static final int ELEM_RESULT               = 2;
    private static final int ELEM_ALL_FUNCTIONS        = 3;
    private static final int ELEM_NOT_AVAIL_FUNCS      = 4;
    private static final int ELEM_CAPABILITY_LIST      = 5;
    private static final int ELEM_CONTACT_LIST         = 6;
    private static final int ELEM_DEFAULT_CONTACT_LIST = 7;
    private static final int ELEM_USER_NICK_LIST       = 8;
    private static final int ELEM_CONTACT_LIST_PROPS   = 9;
    private static final int ELEM_PRESENCE             = 10;

    /*
    private static final int ELEM_RESULT_CLIST  = 3;
    private static final int ELEM_RESULT_DOMAIN = 4;
    private static final int ELEM_RESULT_GROUP  = 5;
    private static final int ELEM_RESULT_MSGID  = 6;
    private static final int ELEM_RESULT_SCRNAME = 7;
    private static final int ELEM_RESULT_USER   = 8;
    */

    static {
        sInfoElemTypeMap = new HashMap<String, Integer>();
        sInfoElemTypeMap.put(PtsCodes.SessionID, ELEM_SESSION_ID);
        sInfoElemTypeMap.put(PtsCodes.Status, ELEM_RESULT);
        sInfoElemTypeMap.put(PtsCodes.NotAvailableFunctions, ELEM_NOT_AVAIL_FUNCS);
        sInfoElemTypeMap.put(PtsCodes.AllFunctions, ELEM_ALL_FUNCTIONS);
        sInfoElemTypeMap.put(PtsCodes.AgreedCapabilityList, ELEM_CAPABILITY_LIST);
        sInfoElemTypeMap.put(PtsCodes.ContactList, ELEM_CONTACT_LIST);
        sInfoElemTypeMap.put(PtsCodes.DefaultContactList, ELEM_DEFAULT_CONTACT_LIST);
        sInfoElemTypeMap.put(PtsCodes.UserNickList, ELEM_USER_NICK_LIST);
        sInfoElemTypeMap.put(PtsCodes.ContactListProps, ELEM_CONTACT_LIST_PROPS);
        sInfoElemTypeMap.put(PtsCodes.Presence, ELEM_PRESENCE);
    }

    private static void translateParam(Primitive p, String elemCode,
            ParamValue elemValue) throws ParserException {
        int type;
        elemCode = elemCode.toUpperCase();

        // FIXME: Should be refactored when we had concrete situation of the null value case
        if (elemValue == null) {
            throw new ParserException("Parameter " + elemCode + " must have value.");
        }

        if (sInfoElemTypeMap.containsKey(elemCode)) {
            type = sInfoElemTypeMap.get(elemCode);
            /*
            if (type == ELEM_RESULT_CLIST && p.getType().equals(ImpsTags.Login_Response)) {
                // Fix up DigestSchema which shares a same code with
                // ContactListID. It appears only in Login_Response.
                type = ELEM_OTHER_SIMPLE;
            }
            */
        } else {
            type = ELEM_OTHER_SIMPLE;
        }

        switch (type) {
        case ELEM_SESSION_ID:
            if (elemValue.mStrValue == null) {
                throw new ParserException("Element SessionID must have string value!");
            }

            if (p.getType().equals(ImpsTags.Login_Response)) {
                p.addElement(ImpsTags.SessionID, elemValue.mStrValue);
            } else {
                p.setSession(elemValue.mStrValue);
            }
            break;

        case ELEM_RESULT:
            // ST=<StatusCode>
            // ST=(<StatusCode>,<Description>)
            PrimitiveElement result = p.addElement(ImpsTags.Result);

            if (elemValue.mStrValue != null) {
                result.addChild(ImpsTags.Code, elemValue.mStrValue);
            } else {
                checkGroupValue(elemValue.mValueGroup, 2);

                result.addChild(ImpsTags.Code, elemValue.mValueGroup.get(0).mStrValue);
                result.addChild(ImpsTags.Description, elemValue.mValueGroup.get(1).mStrValue);
            }
            break;

        case ELEM_ALL_FUNCTIONS:
        case ELEM_NOT_AVAIL_FUNCS:
            p.addElement(translateServiceTree(elemCode, elemValue));
            break;

        case ELEM_CAPABILITY_LIST:
            p.addElement(translateCapabilityList(elemValue));
            break;

        case ELEM_CONTACT_LIST:
            if (elemValue.mStrValue != null) {
                p.addElement(ImpsTags.ContactList, elemValue.mStrValue);
            } else {
                checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);
                for (ParamValue value : elemValue.mValueGroup) {
                    p.addElement(ImpsTags.ContactList, value.mStrValue);
                }
            }
            break;

        case ELEM_DEFAULT_CONTACT_LIST:
            if (elemValue.mStrValue == null) {
                throw new ParserException("Deafult Contact List must have string value!");
            }

            p.addElement(ImpsTags.DefaultContactList, elemValue.mStrValue);
            break;

        case ELEM_USER_NICK_LIST:
        {
            checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);

            PrimitiveElement nicklistElem = p.addElement(ImpsTags.NickList);

            int groupSize = elemValue.mValueGroup.size();
            for (int i = 0; i < groupSize; i++) {
                ArrayList<ParamValue> valueGroup = elemValue.mValueGroup.get(i).mValueGroup;
                checkGroupValue(valueGroup, 2);

                String nickname = valueGroup.get(0).mStrValue;
                String address  = valueGroup.get(1).mStrValue;
                if (nickname == null || address == null) {
                    throw new ParserException("Null value found for NickName: " + nickname
                            + "-" + address);
                }

                PrimitiveElement nicknameElem = nicklistElem.addChild(ImpsTags.NickName);
                nicknameElem.addChild(ImpsTags.Name, "".equals(nickname) ? null : nickname);
                nicknameElem.addChild(ImpsTags.UserID, address);
            }
        }
            break;

        case ELEM_CONTACT_LIST_PROPS:
        {
            checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);

            PrimitiveElement propertiesElem = p.addElement(ImpsTags.ContactListProperties);

            int groupSize = elemValue.mValueGroup.size();
            for (int i = 0; i < groupSize; i++) {
                ArrayList<ParamValue> valueGroup = elemValue.mValueGroup.get(i).mValueGroup;
                checkGroupValue(valueGroup, 2);

                String name  = valueGroup.get(0).mStrValue;
                String value = valueGroup.get(1).mStrValue;
                if (name == null || value == null) {
                    throw new ParserException("Null value found for property: " + name + "-" + value);
                }

                if (PtsCodes.DisplayName.equals(name)) {
                    name = ImpsConstants.DisplayName;
                } else if (PtsCodes.Default.equals(name)) {
                    name = ImpsConstants.Default;
                } else {
                    throw new ParserException("Unrecognized property " + name);
                }

                PrimitiveElement propertyElem = propertiesElem.addChild(ImpsTags.Property);
                propertyElem.addChild(ImpsTags.Name, name);
                propertyElem.addChild(ImpsTags.Value, value);
            }
        }
            break;

        case ELEM_PRESENCE:
            //PR=(<UserID>[,<PresenceSubList>])
            //PR=((<UserID>[,<PresenceSubList>]),(<UserID>[,<PresenceSubList>]))
            checkGroupValue(elemValue.mValueGroup, UNCERTAIN_GROUP_SIZE);

            if (elemValue.mValueGroup.size() == 1) {
                // PR=(<UserID>)
                ParamValue value = elemValue.mValueGroup.get(0);
                if (value.mStrValue != null) {
                    p.addElement(ImpsTags.Presence).addChild(ImpsTags.UserID, value.mStrValue);
                } else {
                    // workaround for OZ server
                    p.addElement(translatePresence(value.mValueGroup));
                }

            } else {
                if (elemValue.mValueGroup.get(0).mStrValue == null) {
                    // PR=((<UserID>[,<PresenceSubList>]),(<UserID>[,<PresenceSubList>]))
                    int groupSize = elemValue.mValueGroup.size();
                    for (int i = 0; i < groupSize; i++) {
                        ParamValue value = elemValue.mValueGroup.get(i);
                        if (value.mStrValue != null) {
                            p.addElement(ImpsTags.Presence).addChild(ImpsTags.UserID, value.mStrValue);
                        } else {
                            p.addElement(translatePresence(value.mValueGroup));
                        }
                    }
                } else {
                    // PR=(<UserID>,<PresenceSubList>)
                    p.addElement(translatePresence(elemValue.mValueGroup));
                }
            }
            break;

        case ELEM_OTHER_SIMPLE:
            p.addElement(translateSimpleElem(elemCode, elemValue));
            break;

        default:
            throw new ParserException("Unsupported element " + elemValue);
        }
    }

    private static PrimitiveElement translatePresence(ArrayList<ParamValue> valueGroup)
            throws ParserException {
        checkGroupValue(valueGroup, UNCERTAIN_GROUP_SIZE);

        PrimitiveElement presence = new PrimitiveElement(ImpsTags.Presence);
        if (valueGroup.get(0).mStrValue == null) {
            throw new ParserException("UserID must have string value!");
        }
        presence.addChild(ImpsTags.UserID, valueGroup.get(0).mStrValue);

        if (valueGroup.size() > 1) {
            // has presence sub list
            presence.addChild(translatePresenceSubList(valueGroup.get(1)));
        }

        return presence;
    }

    private static PrimitiveElement translatePresenceSubList(ParamValue value)
            throws ParserException {
        checkGroupValue(value.mValueGroup, UNCERTAIN_GROUP_SIZE);

        PrimitiveElement presenceSubList = new PrimitiveElement(ImpsTags.PresenceSubList);

        int groupSize = value.mValueGroup.size();
        for (int i = 0; i < groupSize; i++) {
            ParamValue v = value.mValueGroup.get(i);
            if (v.mStrValue != null) {
                throw new ParserException("Unexpected string value for presence attribute");
            }

            presenceSubList.addChild(translatePresenceAttribute(v.mValueGroup));
        }

        return presenceSubList;
    }

    // <attribute>[,<qualifier>][,<value>]
    // <attribute>[,<qualifier>,<sub-attribute>]
    private static PrimitiveElement translatePresenceAttribute(
            ArrayList<ParamValue> valueGroup) throws ParserException {
        String type = valueGroup.get(0).mStrValue;
        if (type == null) {
            return null;
        }

        String tag = PtsCodes.getPresenceAttributeElement(type);
        if (tag == null) {
            return null;
        }

        PrimitiveElement paElem = new PrimitiveElement(tag);
        if (valueGroup.size() == 2) {
            // no qualifier
            translateAttributeValue(paElem, valueGroup.get(1), false);
        }else if (valueGroup.size() == 3) {
            // has qualifier, and it should has no group value
            ParamValue qualifierValue = valueGroup.get(1);
            if (qualifierValue.mStrValue == null) {
                throw new ParserException("Qualifier value can't be group value!");
            }

            if (!"".equals(qualifierValue.mStrValue)) {
                paElem.addChild(ImpsTags.Qualifier, qualifierValue.mStrValue);
            }

            translateAttributeValue(paElem, valueGroup.get(2), true);
        } else {
            return null;
        }

        return paElem;
    }

    private static void translateAttributeValue(PrimitiveElement paElem,
            ParamValue v, boolean hasQualifier) throws ParserException {
        if (v.mStrValue == null) {
            // sub-attribute as value
            checkGroupValue(v.mValueGroup, UNCERTAIN_GROUP_SIZE);
            if (v.mValueGroup.get(0).mStrValue != null) {
                paElem.addChild(translatePresenceAttribute(v.mValueGroup));
            } else {
                int groupSize = v.mValueGroup.size();
                for (int i = 0; i < groupSize; i++) {
                    ParamValue value = v.mValueGroup.get(i);
                    if (value.mStrValue != null) {
                        throw new ParserException("Presence Attribute value error!");
                    }

                    checkGroupValue(value.mValueGroup, UNCERTAIN_GROUP_SIZE);
                    paElem.addChild(translatePresenceAttribute(value.mValueGroup));
                }
            }
        } else {
            // single simple value
            if (hasQualifier) {
                paElem.addChild(ImpsTags.PresenceValue, PtsCodes.getPAValue(v.mStrValue));
            } else {
                paElem.setContents(PtsCodes.getPAValue(v.mStrValue));
            }
        }
    }

    private static void checkGroupValue(ArrayList<ParamValue> valueGroup,
            int expectedGroupSize) throws ParserException {
        if (valueGroup == null
                || (expectedGroupSize != UNCERTAIN_GROUP_SIZE
                        && valueGroup.size() != expectedGroupSize)) {
            throw new ParserException("Invalid group value!");
        }

        int groupSize = valueGroup.size();
        for (int i = 0; i < groupSize; i++) {
            if (valueGroup.get(i) == null) {
                throw new ParserException("Invalid group value!");
            }
        }
    }

    private static PrimitiveElement translateCapabilityList(ParamValue elemValue)
            throws ParserException {
        PrimitiveElement elem = new PrimitiveElement(ImpsTags.AgreedCapabilityList);
        ArrayList<ParamValue> params = elemValue.mValueGroup;
        if (params != null) {
            checkGroupValue(params, UNCERTAIN_GROUP_SIZE);
            int paramsSize = params.size();
            for (int i = 0; i < paramsSize; i++) {
                ArrayList<ParamValue> capElemGroup = params.get(i).mValueGroup;
                checkGroupValue(capElemGroup, 2);

                String capElemCode = capElemGroup.get(0).mStrValue;
                String capElemName;
                if (capElemCode == null
                        || (capElemName = PtsCodes.getCapElement(capElemCode)) == null) {
                    throw new ParserException("Unknown capability element "
                            + capElemCode);
                }
                String capElemValue = capElemGroup.get(1).mStrValue;
                if (capElemValue == null) {
                    throw new ParserException("Illegal capability value for "
                            + capElemCode);
                }
                capElemValue = PtsCodes.getCapValue(capElemValue);

                elem.addChild(capElemName, capElemValue);
            }
        }
        return elem;
    }

    private static PrimitiveElement translateServiceTree(String elemCode,
            ParamValue elemValue) throws ParserException {
        String elemName = PtsCodes.getElement(elemCode);
        PrimitiveElement elem = new PrimitiveElement(elemName);
        // TODO: translate the service tree.
        return elem;
    }

    private static PrimitiveElement translateSimpleElem(String elemCode, ParamValue value)
            throws ParserException {
        String elemName = PtsCodes.getElement(elemCode);
        if (elemName == null) {
            throw new ParserException("Unrecognized parameter " + elemCode);
        }

        PrimitiveElement elem = new PrimitiveElement(elemName);
        if (value.mStrValue != null) {
            elem.setContents(value.mStrValue);
        } else {
            throw new ParserException("Don't know how to handle parameters for "
                    + elemName);
        }

        return elem;
    }

    private HashMap<String, ParamValue> parseParams() throws ParserException {
        int pos = mPos;
        StringBuilder buf = mStringBuf;
        int len = buf.length();
        HashMap<String, ParamValue> ret = new HashMap<String, ParamValue>();

        String paramName;
        ParamValue paramValue;

        while (pos < len) {
            int nameStart = pos;
            while (pos < len) {
                char ch = buf.charAt(pos);
                if (ch == ' ' || ch == '=') {
                    break;
                }
                pos++;
            }
            if (nameStart == pos) {
                throw new ParserException("Missing parameter name near " + pos);
            }
            paramName = buf.substring(nameStart, pos);
            if (pos < len && buf.charAt(pos) == '=') {
                pos++;
                mPos = pos;
                paramValue = parseParamValue();
                pos = mPos;
            } else {
                paramValue = null;
            }
            ret.put(paramName, paramValue);

            if (pos < len) {
                // more parameters ahead
                match(' ');
                pos = mPos;
            }
        }

        return ret;
    }

    private ParamValue parseParamValue() throws ParserException {
        int pos = mPos;
        StringBuilder buf = mStringBuf;
        int len = buf.length();

        if (pos == len) {
            throw new ParserException("Missing parameter value near " + pos);
        }
        ParamValue value = new ParamValue();

        char ch = buf.charAt(pos);
        if (ch == '(') {
            // value list
            pos++;
            ArrayList<ParamValue> valueGroup = new ArrayList<ParamValue>();
            while (pos < len) {
                mPos = pos;
                valueGroup.add(parseParamValue());
                pos = mPos;
                if (pos == len) {
                    throw new ParserException("Unexpected parameter end");
                }
                if (buf.charAt(pos) != ',') {
                    break;
                }
                pos++;
            }
            mPos = pos;
            match(')');
            if (valueGroup.isEmpty()) {
                throw new ParserException("Empty value group near " + mPos);
            }
            value.mValueGroup = valueGroup;
        } else {
            // single value
            if (ch == '"') {
                // quoted value
                pos++;
                StringBuilder escapedValue = new StringBuilder();
                boolean quotedEnd = false;
                while (pos < len) {
                    ch = buf.charAt(pos);
                    pos++;
                    if (ch == '"') {
                        if (pos < len && buf.charAt(pos) == '"') {
                            // "doubled" quote
                            pos++;
                        } else {
                            quotedEnd = true;
                            break;
                        }
                    }
                    escapedValue.append(ch);
                }
                if (!quotedEnd) {
                    throw new ParserException("Unexpected quoted parameter end");
                }
                value.mStrValue = escapedValue.toString();
            } else {
                int valueStart = pos;
                while (pos < len) {
                    ch = buf.charAt(pos);
                    if (ch == ',' || ch == ')' || ch == ' ') {
                        break;
                    }
                    if ("\"(=&".indexOf(ch) != -1) {
                        throw new ParserException("Special character " + ch
                                + " must be quoted");
                    }
                    pos++;
                }
                value.mStrValue = buf.substring(valueStart, pos);
            }
            mPos = pos;
        }

        return value;
    }

    private void match(char c) throws ParserException {
        if (mStringBuf.charAt(mPos) != c) {
            throw new ParserException("Expected " + c + " at pos " + mPos);
        }
        mPos++;
    }

    /**
     * Detect if this short message is a PTS encoded WV-primitive.
     */
    public static boolean isPtsPrimitive(CharSequence msg)
    {
        if (msg == null) {
            return false;
        }
        Matcher m = sPreamplePattern.matcher(msg);
        return m.matches();
    }

    static final class ParamValue {
        public String mStrValue;
        public ArrayList<ParamValue> mValueGroup;
    }
}