ruleset.java

接收网络设备上NetFlow工具导出的NetFlow数据

			return new PT_O_In();
		}

		if (ch == '|')
			if (ch1 == '|') {
				pos++;
				return new PT_O_Or();
			} else
				error("Incomplete `||' operator");

		if (ch == '&')
			if (ch1 == '&') {
				pos++;
				return new PT_O_And();
			} else
				error("Incomplete `&&' operator");

		if (ch == '<')
			if (ch1 == '=') {
				pos++;
				return new PT_O_LessEqual();
			} else
				return new PT_O_Less();

		if (ch == '>')
			if (ch1 == '=') {
				pos++;
				return new PT_O_GreatEqual();
			} else
				return new PT_O_Great();

		if (ch == '!')
			if (ch1 == '=') {
				pos++;
				return new PT_O_NotEqual();
			} else
				return new PT_O_Not();

		if (Character.isDigit(ch))
			return get_number(ch);

		if (Character.isLetter(ch))
			return get_var(ch);

		error("Unknown character");
		return null; // unreachable return
	}

	private Object get_var(char c) throws PT_Error {
		String ret = "" + c;
		char ch = ' ';

		while (pos < length) {
			ch = src[pos];

			if (Character.isLetter(ch) || Character.isDigit(ch)) {
				ret += ch;
				pos++;
			} else
				break;
		}

		if (word_delimiters.indexOf(ch) == -1) {
			pos++;
			error("Illegal character in field name");
		}

		Object o = vars.get(ret.toLowerCase());

		if (o == null)
			error("Unknown field name");

		return o;
	}

	private Object get_number(char c) throws PT_Error {
		String from = "" + c, to = "";
		char ch = ' ';
		boolean first = true;

		while (pos < length) {
			ch = src[pos];

			if ((ch == '.' || ch == '/') && first)
				return get_address(from, ch);

			if (Character.isDigit(ch)) {
				if (first)
					from += ch;
				else
					to += ch;

				pos++;
			} else if (ch == '-' && first) {
				pos++;
				first = false;
			} else
				break;
		}

		if (word_delimiters.indexOf(ch) == -1) {
			pos++;
			error("Illegal character in " + (first ? "number" : "range"));
		}

		try {
			if (first)
				return new PT_V_Number(Long.parseLong(from));
			else {
				long s = Long.parseLong(from), e = Long.parseLong(to);

				if (e < s)
					error("Reversed range is not supported");

				if (e == s)
					error("Reduced range is suboptimal and cannot be used");

				return new PT_V_Range(s, e);
			}
		} catch (NumberFormatException e) {
		}

		error("BUG: Lexer failed while parse number/range");
		return null; // unreachable return
	}

	private int check_number(int limit, int b1) throws PT_Error {
		if (b1 > limit)
			error("Number " + b1 + " is too big, maximum " + limit
					+ " is allowed");

		return b1;
	}

	private int make_number_and_check(int limit, int b1, int digit)
			throws PT_Error {
		return check_number(limit, b1 * 10 + digit);
	}

	private void may_be_order_error(char ch, char last) throws PT_Error {
		if (!Character.isDigit(last))
			error("`" + ch + "' must be after number, not after `" + last + "'");
	}

	private Object get_address(String b0s, char ch_i) throws PT_Error {
		int b0 = 0, b1 = 0, b2 = 0, b3 = 0;
		int current_word = cur_word;

		try {
			b0 = check_number(255, Integer.parseInt(b0s));
		} catch (NumberFormatException e) {
			error("BUG: Lexer failed while parse 1st byte of address/preffix");
		}

		pos++;
		cur_word = pos;

		char ch = ' ';
		int addr = -1;
		int mask = 0;

		if (ch_i == '.')
			addr = 1;
		else if (ch_i == '/')
			addr = 4;
		else
			error("BUG: Lexer failed while parse `" + ch_i
					+ "' after 1st byte of address/preffix");

		char last = ch_i;

		while (pos < length) {
			ch = src[pos];

			if (Character.isDigit(ch)) {
				int digit = Character.digit(ch, 10);

				last = ch;
				pos++;

				switch (addr) {
				case 1:
					b1 = make_number_and_check(255, b1, digit);
					break;
				case 2:
					b2 = make_number_and_check(255, b2, digit);
					break;
				case 3:
					b3 = make_number_and_check(255, b3, digit);
					break;
				case 4:
					mask = make_number_and_check(32, mask, digit);
					break;
				default:
					error("BUG: Lexer failed while parse #" + addr
							+ " byte of address/prefix");
				}
			} else if (ch == '.') {
				may_be_order_error(ch, last);

				last = ch;
				pos++;

				if (++addr > 3)
					if (addr > 4)
						error("Illegal characrter in prefix");
					else
						error("Extra period in IP address");

				cur_word = pos;
			} else if (ch == '/') {
				may_be_order_error(ch, last);

				last = ch;
				pos++;

				if (addr <= 3)
					addr = 4;
				else
					error("Illegal characrter in prefix");

				cur_word = pos;
			} else
				break;
		}

		cur_word = current_word;

		if (word_delimiters.indexOf(ch) == -1) {
			pos++;
			error("Illegal character in address or network");
		}

		if (!Character.isDigit(last))
			error((addr == 4 ? "Prefix" : "Address")
					+ " cannot be finished by `" + last + "'");

		long address = (((long) b0) << 24) | (((long) b1) << 16)
				| (((long) b2) << 8) | b3;

		if (addr <= 3)
			return new PT_V_Address(address);

		if (addr == 4)
			return new PT_V_VPrefix(address, (byte) mask);

		error("BUG: Lexer failed while parse address/prefix");
		return null; // unreachable return
	}

}

abstract class PT_A_Instr {
	abstract public String toString();

	abstract public String toString(int bl);

	protected String filler(int bl) {
		if (bl <= 0)
			return "";

		char[] a = new char[bl];

		for (int i = 0; i < bl; i++)
			a[i] = ' ';

		return new String(a);
	}

	public boolean exec(Flow flow) throws PT_ExecError {
		throw new PT_ExecError("BUG: Opcode `" + this.getClass().getName()
				+ "' (" + this.toString() + ") cannot be executed");
	}
}

abstract class PT_A_TwoOpsInstr extends PT_A_Instr {
	protected PT_A_Instr left, right;

	public PT_A_TwoOpsInstr(PT_A_Instr l, PT_A_Instr r) {
		left = l;
		right = r;
	}

	public String toString(int bl) {
		return filler(bl) + toString() + "\n" + left.toString(bl + 2)
				+ right.toString(bl + 2);
	}
}

class PT_A_Or extends PT_A_TwoOpsInstr {
	public PT_A_Or(PT_A_Instr l, PT_A_Instr r) {
		super(l, r);
	}

	public String toString() {
		return "||";
	}

	public boolean exec(Flow flow) throws PT_ExecError {
		if (left.exec(flow))
			return true;

		return right.exec(flow);
	}
}

class PT_A_And extends PT_A_TwoOpsInstr {
	public PT_A_And(PT_A_Instr l, PT_A_Instr r) {
		super(l, r);
	}

	public String toString() {
		return "&&";
	}

	public boolean exec(Flow flow) throws PT_ExecError {
		if (!left.exec(flow))
			return false;

		return right.exec(flow);
	}
}

class PT_A_Not extends PT_A_Instr {
	PT_A_Instr prog;

	public PT_A_Not(PT_A_Instr prog) {
		this.prog = prog;
	}

	public String toString() {
		return "!";
	}

	public String toString(int bl) {
		return filler(bl) + toString() + "\n" + prog.toString(bl + 2);
	}

	public boolean exec(Flow flow) throws PT_ExecError {
		return !prog.exec(flow);
	}
}

class PT_A_Number extends PT_A_Instr {
	public PT_V_Number num;

	public PT_A_Number(PT_V_Number n) {
		num = n;
	}

	public String toString() {
		return num.toString();
	}

	public String toString(int bl) {
		return filler(bl) + toString() + "\n";
	}
}

class PT_A_VPrefix extends PT_A_Instr {
	public PT_V_VPrefix prefix;

	public PT_A_VPrefix(PT_V_VPrefix p) {
		prefix = p;
	}

	public String toString() {
		return prefix.toString();
	}

	public String toString(int bl) {
		return filler(bl) + toString() + "\n";
	}
}

class PT_A_Address extends PT_A_Instr {
	public PT_V_Address address;

	public PT_A_Address(PT_V_Address a) {
		address = a;
	}

	public String toString() {
		return address.toString();
	}

	public String toString(int bl) {
		return filler(bl) + toString() + "\n";
	}
}

abstract class PT_A_Field extends PT_A_Instr {
	public PT_Var var;

	public PT_A_Field(PT_Var v) {
		var = v;
	}

	public String toString() {
		return var.toString();
	}

	public String toString(int bl) {
		return filler(bl) + toString() + "\n";
	}

	public abstract Object getValue(Flow flow);
}

class PT_A_Port extends PT_A_Field {
	public PT_A_Port(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		Vector a = new Vector(2);

		a.add(flow.getSrcPort());
		a.add(flow.getDstPort());

		return a;
	}
}

class PT_A_SrcPort extends PT_A_Field {
	public PT_A_SrcPort(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getSrcPort();
	}
}

class PT_A_DstPort extends PT_A_Field {
	public PT_A_DstPort(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getDstPort();
	}
}

class PT_A_Proto extends PT_A_Field {
	public PT_A_Proto(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getProto();
	}
}

class PT_A_TOS extends PT_A_Field {
	public PT_A_TOS(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getTOS();
	}
}

class PT_A_AS extends PT_A_Field {
	public PT_A_AS(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		Vector a = new Vector(2);

		a.add(flow.getSrcAS());
		a.add(flow.getDstAS());

		return a;
	}
}

class PT_A_SrcAS extends PT_A_Field {
	public PT_A_SrcAS(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getSrcAS();
	}
}

class PT_A_DstAS extends PT_A_Field {
	public PT_A_DstAS(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getDstAS();
	}
}

class PT_A_Addr extends PT_A_Field {
	public PT_A_Addr(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		Vector a = new Vector(2);

		a.add(flow.getSrcAddr());
		a.add(flow.getDstAddr());

		return a;
	}
}

class PT_A_SrcAddr extends PT_A_Field {
	public PT_A_SrcAddr(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getSrcAddr();
	}
}

class PT_A_DstAddr extends PT_A_Field {
	public PT_A_DstAddr(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getDstAddr();
	}
}

class PT_A_NextHop extends PT_A_Field {
	public PT_A_NextHop(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getNextHop();
	}
}

class PT_A_If extends PT_A_Field {
	public PT_A_If(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		Vector a = new Vector(2);

		a.add(flow.getInIf());
		a.add(flow.getOutIf());

		return a;
	}
}

class PT_A_InIf extends PT_A_Field {
	public PT_A_InIf(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getInIf();
	}
}

class PT_A_OutIf extends PT_A_Field {
	public PT_A_OutIf(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getOutIf();
	}
}

class PT_A_Prefix extends PT_A_Field {
	public PT_A_Prefix(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		Vector a = new Vector(2);

		a.add(flow.getSrcPrefix());
		a.add(flow.getDstPrefix());

		return a;
	}
}

class PT_A_SrcPrefix extends PT_A_Field {
	public PT_A_SrcPrefix(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getSrcPrefix();
	}
}

class PT_A_DstPrefix extends PT_A_Field {
	public PT_A_DstPrefix(PT_Var f) {
		super(f);
	}

	public Object getValue(Flow flow) {
		return flow.getDstPrefix();