tests/bandwidthenforcement/BandwidthEnforcementTestService.java

/*
 * Copyright (C) 2011 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.tests.bandwidthenforcement;

import android.app.IntentService;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.SntpClient;
import android.os.Environment;
import android.util.Log;

import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.URL;
import java.util.Random;

import libcore.io.Streams;

/*
 * Test Service that tries to connect to the web via different methods and outputs the results to
 * the log and a output file.
 */
public class BandwidthEnforcementTestService extends IntentService {
    private static final String TAG = "BandwidthEnforcementTestService";
    private static final String OUTPUT_FILE = "BandwidthEnforcementTestServiceOutputFile";

    public BandwidthEnforcementTestService() {
        super(TAG);
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        Log.d(TAG, "Trying to establish a connection.");
        // Read output file path from intent.
        String outputFile = intent.getStringExtra(OUTPUT_FILE);
        dumpResult("testUrlConnection", testUrlConnection(), outputFile);
        dumpResult("testUrlConnectionv6", testUrlConnectionv6(), outputFile);
        dumpResult("testSntp", testSntp(getApplicationContext()), outputFile);
        dumpResult("testDns", testDns(), outputFile);
    }

    public static void dumpResult(String tag, boolean result, String outputFile) {
        Log.d(TAG, "Test output file: " + outputFile);
        try {
            if (outputFile != null){
                File extStorage = Environment.getExternalStorageDirectory();
                File outFile = new File(extStorage, outputFile);
                FileWriter writer = new FileWriter(outFile, true);
                BufferedWriter out = new BufferedWriter(writer);
                if (result) {
                    out.append(tag + ":fail\n");
                } else {
                    out.append(tag + ":pass\n");
                }
                out.close();
            }
            if (result) {
                Log.e(TAG, tag + " FAILURE ====================");
                Log.e(TAG, tag + " FAILURE was able to use data");
                Log.e(TAG, tag + " FAILURE ====================");
            } else {
                Log.d(TAG, tag + " success; unable to use data");
            }
        } catch (IOException e) {
            Log.e(TAG, "Could not write file " + e.getMessage());
        }
    }

    /**
     * Tests a normal http url connection.
     * @return true if it was able to connect, false otherwise.
     */
    public static boolean testUrlConnection() {
        try {
            final HttpURLConnection conn = (HttpURLConnection) new URL("http://www.google.com/")
            .openConnection();
            try {
                conn.connect();
                final String content = Streams.readFully(
                        new InputStreamReader(conn.getInputStream()));
                if (content.contains("Google")) {
                    return true;
                }
            } finally {
                conn.disconnect();
            }
        } catch (IOException e) {
            Log.d(TAG, "error: " + e);
        }
        return false;
    }

    /**
     * Tests a ipv6 http url connection.
     * @return true if it was able to connect, false otherwise.
     */
    public static boolean testUrlConnectionv6() {
        try {
            final HttpURLConnection conn = (HttpURLConnection) new URL("http://ipv6.google.com/")
            .openConnection();
            try {
                conn.connect();
                final String content = Streams.readFully(
                        new InputStreamReader(conn.getInputStream()));
                if (content.contains("Google")) {
                    return true;
                }
            } finally {
                conn.disconnect();
            }
        } catch (IOException e) {
            Log.d(TAG, "error: " + e);
        }
        return false;
    }

    /**
     * Tests to connect via sntp.
     * @return true if it was able to connect, false otherwise.
     */
    public static boolean testSntp(Context context) {
        final SntpClient client = new SntpClient();
        final ConnectivityManager mCM = context.getSystemService(ConnectivityManager.class);
        final Network network = mCM.getActiveNetwork();

        if (client.requestTime("0.pool.ntp.org", 10000, network)) {
            return true;
        }
        return false;
    }

    /**
     * Tests dns query.
     * @return true if it was able to connect, false otherwise.
     */
    public static boolean testDns() {
        try {
            final DatagramSocket socket = new DatagramSocket();
            try {
                socket.setSoTimeout(10000);

                final byte[] query = buildDnsQuery("www", "android", "com");
                final DatagramPacket queryPacket = new DatagramPacket(
                        query, query.length, InetAddress.parseNumericAddress("8.8.8.8"), 53);
                socket.send(queryPacket);

                final byte[] reply = new byte[query.length];
                final DatagramPacket replyPacket = new DatagramPacket(reply, reply.length);
                socket.receive(replyPacket);
                return true;

            } finally {
                socket.close();
            }
        } catch (IOException e) {
            Log.d(TAG, "error: " + e);
        }
        return false;
    }

    /**
     * Helper method to build a dns query
     * @param query the dns strings of the server
     * @return the byte array of the dns query to send
     * @throws IOException
     */
    private static byte[] buildDnsQuery(String... query) throws IOException {
        final Random random = new Random();
        final ByteArrayOutputStream out = new ByteArrayOutputStream();

        final byte[] id = new byte[2];
        random.nextBytes(id);

        out.write(id);
        out.write(new byte[] { 0x01, 0x00 });
        out.write(new byte[] { 0x00, 0x01 });
        out.write(new byte[] { 0x00, 0x00 });
        out.write(new byte[] { 0x00, 0x00 });
        out.write(new byte[] { 0x00, 0x00 });

        for (String phrase : query) {
            final byte[] bytes = phrase.getBytes("US-ASCII");
            out.write(bytes.length);
            out.write(bytes);
        }
        out.write(0x00);

        out.write(new byte[] { 0x00, 0x01 });
        out.write(new byte[] { 0x00, 0x01 });

        return out.toByteArray();
    }
}