commandparser

与postgresql数据库结合的数据库水印软件包

/*readRequest.java
  accepts the following commands:
  - CREATE POOL <name> ("," LOCAL <PERCENTAGE> ON "("<tableName> "," <attName>")")* ( "," GLOBAL <PERCENTAGE> ON  QUERY <STRING>)+";"
  - GET INSTANCE FOR <clientInfo> FROM <poolName>";"    
  - IDENTIFY CLIENT FROM TABLE <tableName> POOL <poolName> PRECISION <REAL>";"     

  Commands for performing the attacks:
  - MODIFY TABLESUFIX <STRING> POOL <poolName>
    DATAALTERATION PROBABILITY <FRACTION>
    VALUE <NUMBER> ";"
    
  - MODIFY TABLESUFIX <STRING> POOL <poolName>
    DATALOSS PROBABILITY <FRACTION>";"

(N'EST PAS REALISE  - MODIFY TABLESUFIX <STRING> POOL <poolName>
    OVERMARK COUNT <NUMBER> ";")
  
  Commands for making the graphics:
  - GRAPHIC TABLESUFIX <STRING> POOL <poolName> 
    DATAALTERATION VALUE <NUMBER> 
    IDCLIENT <NUMBER>";" - varies the probability of the attack, IDCLIENT-the client that we expect to identify

  - GRAPHIC TABLESUFIX <STRING> POOL <poolName> 
    DATALOSS IDCLIENT <NUMBER>";" - varies the probability of the attack, IDCLIENT-the client that we expect to identify
      
  - GRAPHIC TABLESUFIX <STRING> POOL <poolName> 
    OVERMARK IDCLIENT <NUMBER>";" -varies the number of overmarkings, expecting to identify idclient 
  
  The values for the parameters specified between '<' and '>' are of type <STRING> 
  If the local constraint on an attribute is not specified, we can choose for encoding any bit in the value.
 
  each of the anterior commands can be specified in a file, 
    in this case, the command pour execute them is:
  - EXECUTE COMMAND AS <fileName>     
  
  
*/

options
{
	LOOKAHEAD=2;
}

PARSER_BEGIN(CommandParser)

//package Watermill.io;
import java.io.*;
//import Watermill.conf.*;

public class Parser
{
    //static Watermill.io.RequestManager req;
    static ReadInput parser;

    public static void frontEndMessage(){
	System.out.println("Error connection to the psql frontend.");
	System.exit(-1);
    }
	
    public static void main(String args[]){
	boolean DEBUG = false;

	if(args.length != 0){
	    if(args[0].compareTo("--debug") != 0){
		System.out.println("Incorrect parameter!");
		System.exit(-1);
	    }
	    DEBUG = true;
	}

	Process psql=null;

	try{psql=Runtime.getRuntime().exec("psql -U "+Constant.dbuser+" "+Constant.dbname);}
	catch(IOException e){frontEndMessage();}
	
	BufferedReader psqlReader=new BufferedReader(new InputStreamReader(psql.getInputStream()));
	BufferedReader psqlErrorReader=new BufferedReader(new InputStreamReader(psql.getErrorStream()));
	BufferedWriter psqlWriter=new BufferedWriter(new OutputStreamWriter(psql.getOutputStream()));;

	BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));

	ReadInput parser = new ReadInput(new StringReader("n'importe quoi"));

	try{
	    req = new Watermill.io.RequestManager(DEBUG, Constant.secretKey);
	}catch(Exception e){
	    System.out.println("Error establishing the connections!\n\texiting...");
	    System.out.println(e.getMessage());
	    System.exit(-1);
	}
		    
	System.out.println("Welcome to Watermill-enabled psql, the PostgreSQL interactive terminal.");
	System.out.println("Type:  \\copyright for distribution terms");
	System.out.println("       \\h for help with SQL commands");
	System.out.println("       \\? for help on internal slash commands");
	System.out.println("       \\g or terminate with semicolon to execute query");
	System.out.println("       \\q to quit");
	System.out.println("");

	System.out.print("=>");

	while(true){
	    boolean stdinReady=false;
	    try{
		stdinReady=stdin.ready();
	    }catch (IOException e){
		frontEndMessage();
	    }
	    
	    if (stdinReady){
		String line=null;
		try{line=stdin.readLine();}
		catch(IOException e){frontEndMessage();}
		parser.ReInit(new StringReader(line));
		
		try{
		    parser.parseOneLine();
		    req.ReInit();
		}catch (Throwable e){	
		    //System.out.println("[Not a Watermill command...]");
		    //parser.ReInit();
		    req.ReInit();
		    
		    try{
			psqlWriter.write(line);
			psqlWriter.newLine();
			psqlWriter.flush();
		    }catch(IOException e2){frontEndMessage();}
		}
	    }
	    
	    boolean psqlReaderReady=false;
	    try{psqlReaderReady=psqlReader.ready();}catch(IOException e3){frontEndMessage();}
	    if (psqlReaderReady){
		try{System.out.println(psqlReader.readLine());}catch(IOException e5){frontEndMessage();}
	    }
	    boolean psqlErrorReaderReady=false;
	    try{psqlErrorReaderReady=psqlErrorReader.ready();}catch(IOException e4){frontEndMessage();}
	    if (psqlErrorReaderReady){
		try{System.out.println(psqlErrorReader.readLine());}catch(IOException e6){frontEndMessage();}
	    }
	    try {
		int exitValue=psql.exitValue();
		System.out.println("");
		System.exit(exitValue);
	    }catch (IllegalThreadStateException e){}
	}
    }

    public static void parseInput(){
	while (true)
	    try{
		parser.parseOneLine();
		parser.ReInit(System.in);
		req.ReInit();
	    }catch (Exception e) {
   		System.out.println("Parse error..."+e.getMessage()+"\n\texiting...");
		parser.ReInit(System.in);
		req.ReInit();
	    }
    }
    
    /*when the input for the parser is read from a file*/
    public static void changeInput(java.io.InputStream newInput){
	parser.ReInit(newInput);
	req.ReInit();
	parseInput();
    }
}

PARSER_END(ReadInput)

SKIP :
{
    " "
|   "\r"
|   "\t"
}

TOKEN:
{
     
    < NUMBER: (<DIGIT>)+ >
|   < DIGIT: ["0"-"9"] >
|   < REAL: <NUMBER>("."(<NUMBER>)+)?>
|   < PERCENTAGE: <REAL>"%" >
|   < FRACTION: <NUMBER>"/"<NUMBER> >
|   < STRING: ("\"") (~["\""])*("\"")>
|   < EOL: "\n" >
|   < LPAR: "(" >
|   < RPAR: ")" >
|   < COMMA: "," >
|   < SEMICOLON: ";" >
|   < LSET: "{">	
|   < CREATE: ("C"|"c")("R"|"r")("E"|"e")("A"|"a")("T"|"t")("E"|"e") >
|   < POOL: ("P"|"p")("O"|"o")("O"|"o")("L"|"l") >
|   < GLOBAL: ("G"|"g")("L"|"l")("O"|"o")("B"|"b")("A"|"a")("L"|"l")>
|   < LOCAL: ("L"|"l")("O"|"o")("C"|"c")("A"|"a")("L"|"l")>
|   < ON: ("O"|"o")("N"|"n")>
|   < QUERY: ("Q"|"q")("U"|"u")("E"|"e")("R"|"r")("Y"|"y")>
|   < AS: ("A"|"a")("S"|"s") >

|   < GET: ("G"|"g")("E"|"e")("T"|"t") >
|   < INSTANCE: ("I"|"i")("N"|"n")("S"|"s")("T"|"t")("A"|"a")("N"|"n")("C"|"c")("E"|"e")>
|   < FOR: ("F"|"f")("O"|"o")("R"|"r") >
|   < CLIENT: ("C"|"c")("L"|"l")("I"|"i")("E"|"e")("N"|"n")("T"|"t")> 
|   < FROM: ("F"|"f")("R"|"r")("O"|"o")("M"|"m") >

|   < IDENTIFY: ("I"|"i")("D"|"d")("E"|"e")("N"|"n")("T"|"t")("I"|"i")("F"|"f")("Y"|"y")>
|   < TABLE: ("T"|"t")("A"|"a")("B"|"b")("L"|"l")("E"|"e")>
|   < PRECISION: ("P"|"p")("R"|"r")("E"|"e")("C"|"c")("I"|"i")("S"|"s")("I"|"i")("O"|"o")("N"|"n")>

|   < MODIFY: ("M"|"m")("O"|"o")("D"|"d")("I"|"i")("F"|"f")("Y"|"y")>
|   < TABLESUFIX: ("T"|"t")("A"|"a")("B"|"b")("L"|"l")("E"|"e")("S"|"s")("U"|"u")("F"|"f")("I"|"i")("X"|"x") >
|   < DATAALTERATION: ("D"|"d")("A"|"a")("T"|"t")("A"|"a")("A"|"a")("L"|"l")("T"|"t")("E"|"e")("R"|"r")("A"|"a")("T"|"t")("I"|"i")("O"|"o")("N"|"n")>
|   < DATALOSS: ("D"|"d")("A"|"a")("T"|"t")("A"|"a")("L"|"l")("O"|"o")("S"|"s")("S"|"s")>
|   < OVERMARK: ("O"|"o")("V"|"v")("E"|"e")("R"|"r")("M"|"m")("A"|"a")("R"|"r")("K"|"k")>
|   < PROBABILITY: ("P"|"p")("R"|"r")("O"|"o")("B"|"b")("A"|"a")("B"|"b")("I"|"i")("L"|"l")("I"|"i")("T"|"t")("Y"|"y")>
|   < VALUE: ("V"|"v")("A"|"a")("L"|"l")("U"|"u")("E"|"e")>
|   < COUNT: ("C"|"c")("O"|"o")("U"|"u")("N"|"n")("T"|"t")>

|   < GRAPHIC: ("G"|"g")("R"|"r")("A"|"a")("P"|"p")("H"|"h")("I"|"i")("C"|"c")>
|   < IDCLIENT: ("I"|"i")("D"|"d")("C"|"c")("L"|"l")("I"|"i")("E"|"e")("N"|"n")("T"|"t")>

|   < EXECUTE: ("E"|"e")("X"|"x")("E"|"e")("C"|"c")("U"|"u")("T"|"t")("E"|"e")>
|   < COMMAND: ("C"|"c")("O"|"o")("M"|"m")("M"|"m")("A"|"a")("N"|"n")("D"|"d")>

|   < PARAMETERS: ("P"|"p")("A"|"a")("R"|"r")("A"|"a")("M"|"m")("E"|"e")("T"|"t")("E"|"e")("R"|"r")("S"|"s")>
|   < SELECT: ("S"|"s")("E"|"e")("L"|"l")("E"|"e")("C"|"c")("T"|"t")>
|   < WHERE: ("W"|"w")("H"|"h")("E"|"e")("R"|"r")("E"|"e")>
|   < TOTAL: ("T"|"t")("O"|"o")("T"|"t")("A"|"a")("L"|"l")>
|   < ID: ["a"-"z","A"-"Z","_"] ( ["a"-"z","A"-"Z","_","0"-"9"] )* >
}

void parseOneLine()throws Exception:
{
    boolean ret;
}
{
   ret = expr()                                      { if(!ret) return;}
(  <EOL>|<EOF>)                                      { return;}
| <EOL>                                              { return;}
| <EOF>                                              { return;System.exit(-1); }
}

boolean expr()throws Exception:
{
	Token read, read1, prob;
	Token client, prec, value;
	boolean ret;
}
{
(	<CREATE><POOL>
	read=<STRING>                                { if(req.verifyPoolName(read.toString()) == false) return false;}
	(ret = getLocal()                            { if(ret == false) return false; } )*
	(ret = getGlobal()                           { if(ret == false) return false; } )+
	";"                                          { req.createPool(); return true;}

|       <GET><INSTANCE><FOR>
	client=<STRING>
	<FROM> read=<STRING>";"                      { if(req.verifyClientPool(client.toString(), read.toString()) == false)
							    return false;
						       req.getInstance();
						       return true;
						     }
|       <IDENTIFY><CLIENT><FROM>
        <TABLESUFIX> read = <STRING>
	<POOL> read1 = <STRING>
	<PRECISION> prec=<REAL>";"                   { return req.identifyMark(read1.toString(), read.toString(), prec.toString());}


|	<MODIFY><TABLESUFIX> read=<STRING> 
        <POOL> read1 = <STRING>
(	<DATAALTERATION><PROBABILITY> 
	prob = <FRACTION>
	<VALUE> value = <PERCENTAGE> ";"    	     { return req.DataAlteration(read1.toString(), read.toString(), prob.toString(), value.toString());}

|       <DATALOSS><PROBABILITY>  
	prob = <FRACTION> ";"                        { return req.DataLoss(read1.toString(), read.toString(), prob.toString());} 

|       <OVERMARK><COUNT>
        value = <NUMBER> ";"                         { return req.Overmark(read1.toString(), read.toString(), value.toString());}
)
|       <GRAPHIC><TABLESUFIX> read=<STRING> 
        <POOL> read1 = <STRING>
(	<DATAALTERATION> 
	<VALUE> value = <PERCENTAGE>
	<IDCLIENT> client = <NUMBER>";"              { return req.TestDataAlteration(read1.toString(), read.toString(), value.toString(), client.toString());}     

|       <DATALOSS>
	<IDCLIENT> client = <NUMBER>";"              { return req.TestDataLoss(read1.toString(), read.toString(), client.toString());}           

|       <OVERMARK>
	<IDCLIENT> client = <NUMBER>";"              { return req.TestOvermark(read1.toString(), read.toString(), client.toString());}           
)
)
|       <EXECUTE><COMMAND>  
        <AS> read = <STRING>";"                      { String newInput = read.toString();
						       newInput = newInput.substring(1, newInput.length()-1);
						       changeInput(new java.io.FileInputStream(newInput));
					               return true;
						     }

}

boolean getGlobal()throws Exception:
{
	Token read1, read2,read3,read4,read5;
}
{
    "," <GLOBAL> read2 = <PERCENTAGE> <ON>
	<QUERY> "{" <SELECT> read3 = <ID> "," read4 = <ID> <FROM> read5= <ID> <WHERE> 
	read1 = <STRING> "}"                          
    { 
	String keyAttribute=read3.toString();
	String weightAttribute=read4.toString();
	String tableName=read5.toString();
	String condition=read1.toString();
	condition=condition.substring(1,condition.length()-1); // escaping double quotes
	return req.addGlobal(keyAttribute,weightAttribute,tableName,condition, read2.toString());
    }
}

boolean getLocal()throws Exception:
{
	Token read1, read2, read3;
}
{
    "," <LOCAL> read1 = <PERCENTAGE> <ON>
    "("read2 = <STRING> "," read3 = <STRING>")"       { return req.addLocal(read1.toString(), read2.toString(), read3.toString());}
}