/*
 * Copyright (C) 2015 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 android.net.apf;

import android.net.apf.ApfGenerator;
import android.net.apf.ApfGenerator.IllegalInstructionException;
import android.net.apf.ApfGenerator.Register;

import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 * BPF to APF translator.
 *
 * Note: This is for testing purposes only and is not guaranteed to support
 *       translation of all BPF programs.
 *
 * Example usage:
 *   javac net/java/android/net/apf/ApfGenerator.java \
 *         tests/servicestests/src/android/net/apf/Bpf2Apf.java
 *   sudo tcpdump -i em1 -d icmp | java -classpath tests/servicestests/src:net/java \
 *                                      android.net.apf.Bpf2Apf
 */
public class Bpf2Apf {
    private static int parseImm(String line, String arg) {
        if (!arg.startsWith("#0x")) {
            throw new IllegalArgumentException("Unhandled instruction: " + line);
        }
        final long val_long = Long.parseLong(arg.substring(3), 16);
        if (val_long < 0 || val_long > Long.parseLong("ffffffff", 16)) {
            throw new IllegalArgumentException("Unhandled instruction: " + line);
        }
        return new Long((val_long << 32) >> 32).intValue();
    }

    /**
     * Convert a single line of "tcpdump -d" (human readable BPF program dump) {@code line} into
     * APF instruction(s) and append them to {@code gen}. Here's an example line:
     * (001) jeq      #0x86dd          jt 2    jf 7
     */
    private static void convertLine(String line, ApfGenerator gen)
            throws IllegalInstructionException {
        if (line.indexOf("(") != 0 || line.indexOf(")") != 4 || line.indexOf(" ") != 5) {
            throw new IllegalArgumentException("Unhandled instruction: " + line);
        }
        int label = Integer.parseInt(line.substring(1, 4));
        gen.defineLabel(Integer.toString(label));
        String opcode = line.substring(6, 10).trim();
        String arg = line.substring(15, Math.min(32, line.length())).trim();
        switch (opcode) {
            case "ld":
            case "ldh":
            case "ldb":
            case "ldx":
            case "ldxb":
            case "ldxh":
                Register dest = opcode.contains("x") ? Register.R1 : Register.R0;
                if (arg.equals("4*([14]&0xf)")) {
                    if (!opcode.equals("ldxb")) {
                        throw new IllegalArgumentException("Unhandled instruction: " + line);
                    }
                    gen.addLoadFromMemory(dest, gen.IPV4_HEADER_SIZE_MEMORY_SLOT);
                    break;
                }
                if (arg.equals("#pktlen")) {
                    if (!opcode.equals("ld")) {
                        throw new IllegalArgumentException("Unhandled instruction: " + line);
                    }
                    gen.addLoadFromMemory(dest, gen.PACKET_SIZE_MEMORY_SLOT);
                    break;
                }
                if (arg.startsWith("#0x")) {
                    if (!opcode.equals("ld")) {
                        throw new IllegalArgumentException("Unhandled instruction: " + line);
                    }
                    gen.addLoadImmediate(dest, parseImm(line, arg));
                    break;
                }
                if (arg.startsWith("M[")) {
                    if (!opcode.startsWith("ld")) {
                        throw new IllegalArgumentException("Unhandled instruction: " + line);
                    }
                    int memory_slot = Integer.parseInt(arg.substring(2, arg.length() - 1));
                    if (memory_slot < 0 || memory_slot >= gen.MEMORY_SLOTS ||
                            // Disallow use of pre-filled slots as BPF programs might
                            // wrongfully assume they're initialized to 0.
                            (memory_slot >= gen.FIRST_PREFILLED_MEMORY_SLOT &&
                                    memory_slot <= gen.LAST_PREFILLED_MEMORY_SLOT)) {
                        throw new IllegalArgumentException("Unhandled instruction: " + line);
                    }
                    gen.addLoadFromMemory(dest, memory_slot);
                    break;
                }
                if (arg.startsWith("[x + ")) {
                    int offset = Integer.parseInt(arg.substring(5, arg.length() - 1));
                    switch (opcode) {
                        case "ld":
                        case "ldx":
                            gen.addLoad32Indexed(dest, offset);
                            break;
                        case "ldh":
                        case "ldxh":
                            gen.addLoad16Indexed(dest, offset);
                            break;
                        case "ldb":
                        case "ldxb":
                            gen.addLoad8Indexed(dest, offset);
                            break;
                    }
                } else {
                    int offset = Integer.parseInt(arg.substring(1, arg.length() - 1));
                    switch (opcode) {
                        case "ld":
                        case "ldx":
                            gen.addLoad32(dest, offset);
                            break;
                        case "ldh":
                        case "ldxh":
                            gen.addLoad16(dest, offset);
                            break;
                        case "ldb":
                        case "ldxb":
                            gen.addLoad8(dest, offset);
                            break;
                    }
                }
                break;
            case "st":
            case "stx":
                Register src = opcode.contains("x") ? Register.R1 : Register.R0;
                if (!arg.startsWith("M[")) {
                    throw new IllegalArgumentException("Unhandled instruction: " + line);
                }
                int memory_slot = Integer.parseInt(arg.substring(2, arg.length() - 1));
                if (memory_slot < 0 || memory_slot >= gen.MEMORY_SLOTS ||
                        // Disallow overwriting pre-filled slots
                        (memory_slot >= gen.FIRST_PREFILLED_MEMORY_SLOT &&
                                memory_slot <= gen.LAST_PREFILLED_MEMORY_SLOT)) {
                    throw new IllegalArgumentException("Unhandled instruction: " + line);
                }
                gen.addStoreToMemory(src, memory_slot);
                break;
            case "add":
            case "and":
            case "or":
            case "sub":
                if (arg.equals("x")) {
                    switch(opcode) {
                        case "add":
                            gen.addAddR1();
                            break;
                        case "and":
                            gen.addAndR1();
                            break;
                        case "or":
                            gen.addOrR1();
                            break;
                        case "sub":
                            gen.addNeg(Register.R1);
                            gen.addAddR1();
                            gen.addNeg(Register.R1);
                            break;
                    }
                } else {
                    int imm = parseImm(line, arg);
                    switch(opcode) {
                        case "add":
                            gen.addAdd(imm);
                            break;
                        case "and":
                            gen.addAnd(imm);
                            break;
                        case "or":
                            gen.addOr(imm);
                            break;
                        case "sub":
                            gen.addAdd(-imm);
                            break;
                    }
                }
                break;
            case "jeq":
            case "jset":
            case "jgt":
            case "jge":
                int val = 0;
                boolean reg_compare;
                if (arg.startsWith("x")) {
                    reg_compare = true;
                } else {
                    reg_compare = false;
                    val = parseImm(line, arg);
                }
                int jt_offset = line.indexOf("jt");
                int jf_offset = line.indexOf("jf");
                String true_label = line.substring(jt_offset + 2, jf_offset).trim();
                String false_label = line.substring(jf_offset + 2).trim();
                boolean true_label_is_fallthrough = Integer.parseInt(true_label) == label + 1;
                boolean false_label_is_fallthrough = Integer.parseInt(false_label) == label + 1;
                if (true_label_is_fallthrough && false_label_is_fallthrough)
                    break;
                switch (opcode) {
                    case "jeq":
                        if (!true_label_is_fallthrough) {
                            if (reg_compare) {
                                gen.addJumpIfR0EqualsR1(true_label);
                            } else {
                                gen.addJumpIfR0Equals(val, true_label);
                            }
                        }
                        if (!false_label_is_fallthrough) {
                            if (!true_label_is_fallthrough) {
                                gen.addJump(false_label);
                            } else if (reg_compare) {
                                gen.addJumpIfR0NotEqualsR1(false_label);
                            } else {
                                gen.addJumpIfR0NotEquals(val, false_label);
                            }
                        }
                        break;
                    case "jset":
                        if (reg_compare) {
                            gen.addJumpIfR0AnyBitsSetR1(true_label);
                        } else {
                            gen.addJumpIfR0AnyBitsSet(val, true_label);
                        }
                        if (!false_label_is_fallthrough) {
                            gen.addJump(false_label);
                        }
                        break;
                    case "jgt":
                        if (!true_label_is_fallthrough ||
                                // We have no less-than-or-equal-to register to register
                                // comparison instruction, so in this case we'll jump
                                // around an unconditional jump.
                                (!false_label_is_fallthrough && reg_compare)) {
                            if (reg_compare) {
                                gen.addJumpIfR0GreaterThanR1(true_label);
                            } else {
                                gen.addJumpIfR0GreaterThan(val, true_label);
                            }
                        }
                        if (!false_label_is_fallthrough) {
                            if (!true_label_is_fallthrough || reg_compare) {
                                gen.addJump(false_label);
                            } else {
                                gen.addJumpIfR0LessThan(val + 1, false_label);
                            }
                        }
                        break;
                    case "jge":
                        if (!false_label_is_fallthrough ||
                                // We have no greater-than-or-equal-to register to register
                                // comparison instruction, so in this case we'll jump
                                // around an unconditional jump.
                                (!true_label_is_fallthrough && reg_compare)) {
                            if (reg_compare) {
                                gen.addJumpIfR0LessThanR1(false_label);
                            } else {
                                gen.addJumpIfR0LessThan(val, false_label);
                            }
                        }
                        if (!true_label_is_fallthrough) {
                            if (!false_label_is_fallthrough || reg_compare) {
                                gen.addJump(true_label);
                            } else {
                                gen.addJumpIfR0GreaterThan(val - 1, true_label);
                            }
                        }
                        break;
                }
                break;
            case "ret":
                if (arg.equals("#0")) {
                    gen.addJump(gen.DROP_LABEL);
                } else {
                    gen.addJump(gen.PASS_LABEL);
                }
                break;
            case "tax":
                gen.addMove(Register.R1);
                break;
            case "txa":
                gen.addMove(Register.R0);
                break;
            default:
                throw new IllegalArgumentException("Unhandled instruction: " + line);
        }
    }

    /**
     * Convert the output of "tcpdump -d" (human readable BPF program dump) {@code bpf} into an APF
     * program and return it.
     */
    public static byte[] convert(String bpf) throws IllegalInstructionException {
        ApfGenerator gen = new ApfGenerator();
        for (String line : bpf.split("\\n")) convertLine(line, gen);
        return gen.generate();
    }

    /**
     * Convert the output of "tcpdump -d" (human readable BPF program dump) piped in stdin into an
     * APF program and output it via stdout.
     */
    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line = null;
        StringBuilder responseData = new StringBuilder();
        ApfGenerator gen = new ApfGenerator();
        while ((line = in.readLine()) != null) convertLine(line, gen);
        System.out.write(gen.generate());
    }
}