VpnProfileParser.java

/*
 * Copyright (C) 2013 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.settings.vpn2;

import android.util.Log;

import com.android.internal.net.VpnProfile;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

/**
 * Parse VPN profiles from an XML file
 */
public class VpnProfileParser {
    private final static String TAG = "VpnProfileParser";
    private static Map<Integer, VpnInfo> mVpnPool = new HashMap<Integer, VpnInfo>();

    static DefaultHandler mHandler = new DefaultHandler() {
        boolean name;
        boolean type;
        boolean server;
        boolean username;
        boolean password;
        boolean dnsServers;
        boolean searchDomains;
        boolean routes;
        boolean mppe;
        boolean l2tpSecret;
        boolean ipsecIdentifier;
        boolean ipsecSecret;
        boolean ipsecUserCert;
        boolean ipsecCaCert;
        boolean ipsecServerCert;
        boolean certFile;
        boolean certFilePassword;
        VpnProfile profile = null;
        VpnInfo vpnInfo = null;


        @Override
        public void startElement(String uri, String localName, String tagName,
                Attributes attributes) throws SAXException {
            if (tagName.equalsIgnoreCase("vpn")) {
                //create a new VPN profile
                profile = new VpnProfile(Long.toHexString(System.currentTimeMillis()));
                vpnInfo = new VpnInfo(profile);
            }
            if (tagName.equalsIgnoreCase("name")) {
                name = true;
            }
            if (tagName.equalsIgnoreCase("type")) {
                type = true;
            }
            if (tagName.equalsIgnoreCase("server")) {
                server = true;
            }
            if (tagName.equalsIgnoreCase("username")) {
                username = true;
            }
            if (tagName.equalsIgnoreCase("password")) {
                password = true;
            }
            if (tagName.equalsIgnoreCase("dnsServers")) {
                dnsServers = true;
            }
            if (tagName.equalsIgnoreCase("searchDomains")) {
                searchDomains = true;
            }
            if (tagName.equalsIgnoreCase("mppe")) {
                mppe = true;
            }
            if (tagName.equalsIgnoreCase("l2tpSecret")) {
                l2tpSecret = true;
            }
            if (tagName.equalsIgnoreCase("ipsecIdentifier")) {
                ipsecIdentifier = true;
            }
            if (tagName.equalsIgnoreCase("ipsecSecret")) {
                ipsecSecret = true;
            }
            if (tagName.equalsIgnoreCase("ipsecUserCert")) {
                ipsecUserCert = true;
            }
            if (tagName.equalsIgnoreCase("ipsecCaCert")) {
                ipsecCaCert = true;
            }
            if (tagName.equalsIgnoreCase("ipsecServerCert")) {
                ipsecServerCert = true;
            }
            if (tagName.equalsIgnoreCase("routes")) {
                routes = true;
            }
            if (tagName.equalsIgnoreCase("cert-file")) {
                certFile = true;
            }
            if (tagName.equalsIgnoreCase("cert-file-password")) {
                certFilePassword = true;
            }
        }

        @Override
        public void endElement(String uri, String localName, String tagName) throws SAXException {
            if (tagName.equalsIgnoreCase("vpn")) {
                mVpnPool.put(profile.type, vpnInfo);
            }
        }

        @Override
        public void characters(char ch[], int start, int length) throws SAXException {
            String strValue = new String(ch, start, length);
            if (name) {
                profile.name = strValue;
                name = false;
            }
            if (type) {
                int t = getVpnProfileType(strValue);
                if (t < 0) {
                    throw new SAXException("not a valid VPN type");
                } else {
                    profile.type = t;
                }
                type = false;
            }
            if (server) {
                profile.server = strValue;
                server = false;
            }
            if (username) {
                profile.username = strValue;
                username = false;
            }
            if (password) {
                profile.password = strValue;
                password = false;
            }
            if (dnsServers) {
                profile.dnsServers = strValue;
                dnsServers = false;
            }
            if (searchDomains) {
                profile.searchDomains = strValue;
                searchDomains = false;
            }
            if (mppe) {
                profile.mppe = Boolean.valueOf(strValue);
                mppe = false;
            }
            if (l2tpSecret) {
                profile.l2tpSecret = strValue;
                l2tpSecret = false;
            }
            if (ipsecIdentifier) {
                profile.ipsecIdentifier = strValue;
                ipsecIdentifier = false;
            }
            if (ipsecSecret) {
                profile.ipsecSecret = strValue;
                ipsecSecret = false;
            }
            if (ipsecUserCert) {
                profile.ipsecUserCert = strValue;
                ipsecUserCert = false;
            }
            if (ipsecCaCert) {
                profile.ipsecCaCert = strValue;
                ipsecCaCert = false;
            }
            if (ipsecServerCert) {
                profile.ipsecServerCert = strValue;
                ipsecServerCert = false;
            }
            if (routes) {
                profile.routes = strValue;
                routes = false;
            }
            if (certFile) {
                vpnInfo.setCertificateFile(strValue);
                certFile = false;
            }
            if (certFilePassword) {
                vpnInfo.setPassword(strValue);
                certFilePassword = false;
            }
        }

        private int getVpnProfileType(String type) {
            if (type.equalsIgnoreCase("TYPE_PPTP")) {
                return VpnProfile.TYPE_PPTP;
            } else if (type.equalsIgnoreCase("TYPE_L2TP_IPSEC_PSK")) {
                return VpnProfile.TYPE_L2TP_IPSEC_PSK;
            } else if (type.equalsIgnoreCase("TYPE_L2TP_IPSEC_RSA")) {
                return VpnProfile.TYPE_L2TP_IPSEC_RSA;
            } else if (type.equalsIgnoreCase("TYPE_IPSEC_XAUTH_PSK")) {
                return VpnProfile.TYPE_IPSEC_XAUTH_PSK;
            } else if (type.equalsIgnoreCase("TYPE_IPSEC_XAUTH_RSA")) {
                return VpnProfile.TYPE_IPSEC_XAUTH_RSA;
            } else if (type.equalsIgnoreCase("TYPE_IPSEC_HYBRID_RSA")) {
                return VpnProfile.TYPE_IPSEC_HYBRID_RSA;
            } else {
                Log.v(TAG, "Invalid VPN type: " + type);
                return -1;
            }
        }
    };

    public static Map<Integer, VpnInfo> parse(InputStream in) {
        try {
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser saxParser = factory.newSAXParser();
            saxParser.parse(in, mHandler);
        } catch (SAXException e) {
            Log.e(TAG, "Parse vpn profile exception: " + e.toString());
        } catch (IOException e) {
            Log.e(TAG, "Parse vpn profile exception: " + e.toString());
        } catch (ParserConfigurationException e) {
            Log.e(TAG, "Parse vpn profile exception: " + e.toString());
        } finally {
            return mVpnPool;
        }
    }
}