Merge pull request #1 from yiwenshao/foreignKey

Foreign key

.gitignore

@@ -12,3 +12,8 @@ reset.sql
 startMM.sh
 test
 tutorial-basic.lua
+cscope.files
+cscope.out
+cscope.files
+cscope.out
+tags

README.md

-# CryptdbModify
+# Newcryptdb
 
 Cryptdb originated from MIT. This is a modified version try to add new features and fix bugs we meet in our environment. 
 Introduction to the features included will be posted at yiwenshao.github.io.
@@ -22,3 +22,16 @@ make
 
 If you meet any problems installing it, contact me via shaoyiwenetATgmailDotcom.
 
+
+
+new features added
+
++ set user variable
++ timestamp
++ show create table
+
+
+obselete functions deleted
+
++ annotation
+

buildtag

+find . | grep '\.cc$\|\.c$\|\.h$\|\.hh$' | xargs ctags
+rm cscope*
+find . | grep '\.cc$\|\.c$\|\.h$\|\.hh$' > cscope.files
+cscope -R -b -i cscope.files

crypto/BasicCrypto.cc

@@ -454,6 +454,9 @@ getLayerKey(const AES_KEY * const mKey, string uniqueFieldName,
     if (l == SECLEVEL::DETJOIN) {
         return getKey(mKey, "joinjoin", l);
     }
+    if (l == SECLEVEL::OPEFOREIGN){
+        return getKey(mKey,"foreignjoin",l);
+    }
     return getKey(mKey, uniqueFieldName, l);
 }
 

crypto/Makefrag

@@ -7,7 +7,7 @@ CRYPTOOBJ   := $(patsubst %.cc,$(OBJDIR)/crypto/%.o,$(CRYPTOSRC))
 all:	$(OBJDIR)/libedbcrypto.a $(OBJDIR)/libedbcrypto.so
 
 $(OBJDIR)/libedbcrypto.so: $(CRYPTOOBJ) $(OBJDIR)/libedbutil.so
-	$(CXX) -shared -o $@ $(CRYPTOOBJ) $(LDFLAGS) $(LDRPATH) \
+	$(CXX) -fPIC -shared -o $@ $(CRYPTOOBJ) $(LDFLAGS) $(LDRPATH) \
 	       -ledbutil -lcrypto -lntl
 
 $(OBJDIR)/libedbcrypto.a: $(CRYPTOOBJ)

crypto/all

+BasicCrypto.cc
+paillier.cc
+urandom.cc
+arc4.cc
+hgd.cc
+pbkdf2.cc
+ecjoin.cc
+ECJoin.cc
+search.cc
+skip32.cc
+ffx.cc
+online_ope.cc
+mont.cc
+prng.cc
+ope.cc
+SWPSearch.cc

crypto/gfe.hh

 #pragma once
 
 #include <vector>
+#include <crypto/hmac.hh>
 #include <crypto/arc4.hh>
 
+using std::make_pair;
+
 template<typename T>
 class gfe {
  public:

gdbctest

+sudo gdb ./obj/main/cdb_test `ps aux| grep cdb_test|grep -v grep|awk '{print $2}'`

gdbs

+###start gdb
+sudo gdb `which mysql-proxy` `ps aux | grep 'mysql-proxy.cnf' |grep -v  grep | awk '{print $2}'`

main/Analysis.hh

@@ -300,15 +300,24 @@ public:
     OnionMeta &getOnionMeta(const std::string &db,
                             const std::string &table,
                             const std::string &field, onion o) const;
+
+    OnionMeta* getOnionMeta2(const std::string &db,
+                            const std::string &table,
+                            const std::string &field, onion o) const;
+
     OnionMeta &getOnionMeta(const FieldMeta &fm, onion o) const;
+    OnionMeta* getOnionMeta2(const FieldMeta &fm, onion o) const;
+
     FieldMeta &getFieldMeta(const std::string &db,
                             const std::string &table,
                             const std::string &field) const;
     FieldMeta &getFieldMeta(const TableMeta &tm,
                             const std::string &field) const;
+
     TableMeta &getTableMeta(const std::string &db,
                             const std::string &table) const;
     DatabaseMeta &getDatabaseMeta(const std::string &db) const;
+
     bool tableMetaExists(const std::string &db,
                          const std::string &table) const;
     bool nonAliasTableMetaExists(const std::string &db,
@@ -317,10 +326,12 @@ public:
     std::string getAnonTableName(const std::string &db,
                                  const std::string &table,
                                  bool *const is_alias=NULL) const;
+
     std::string
         translateNonAliasPlainToAnonTableName(const std::string &db,
                                               const std::string &table)
         const;
+
     std::string getAnonIndexName(const std::string &db,
                                  const std::string &table,
                                  const std::string &index_name,
@@ -328,16 +339,20 @@ public:
     std::string getAnonIndexName(const TableMeta &tm,
                                  const std::string &index_name,
                                  onion o) const;
+
     static const EncLayer &getBackEncLayer(const OnionMeta &om);
     static SECLEVEL getOnionLevel(const OnionMeta &om);
     SECLEVEL getOnionLevel(const FieldMeta &fm, onion o);
+
     static const std::vector<std::unique_ptr<EncLayer> > &
         getEncLayers(const OnionMeta &om);
+
     const SchemaInfo &getSchema() const {return schema;}
 
     std::vector<std::unique_ptr<Delta> > deltas;
 
     std::string getDatabaseName() const {return db_name;}
+
     const std::unique_ptr<AES_KEY> &getMasterKey() const {return master_key;}
     SECURITY_RATING getDefaultSecurityRating() const
         {return default_sec_rating;}

main/CryptoHandlers.cc

@@ -111,6 +111,17 @@ public:
         deserialize(unsigned int id, const SerialLayer &serial);
 };
 
+class OPEFOREIGNFactory : public LayerFactory {
+public:
+    static std::unique_ptr<EncLayer>
+        create(const Create_field &cf, const std::string &key);
+    static std::unique_ptr<EncLayer>
+        deserialize(unsigned int id, const SerialLayer &serial);
+};
+
+
+
+
 
 class HOMFactory : public LayerFactory {
 public:
@@ -158,6 +169,7 @@ EncLayerFactory::encLayer(onion o, SECLEVEL sl, const Create_field &cf,
         case SECLEVEL::DET: {return DETFactory::create(cf, key);}
         case SECLEVEL::DETJOIN: {return DETJOINFactory::create(cf, key);}
         case SECLEVEL::OPE:{return OPEFactory::create(cf, key);}
+        case SECLEVEL::OPEFOREIGN:{return OPEFOREIGNFactory::create(cf,key);}
         case SECLEVEL::HOM: {return HOMFactory::create(cf, key);}
         case SECLEVEL::SEARCH: {
             return std::unique_ptr<EncLayer>(new Search(cf, key));
@@ -171,6 +183,7 @@ EncLayerFactory::encLayer(onion o, SECLEVEL sl, const Create_field &cf,
     FAIL_TextMessageError("unknown or unimplemented security level");
 }
 
+//recover from the database using lambda.
 std::unique_ptr<EncLayer>
 EncLayerFactory::deserializeLayer(unsigned int id,
                                   const std::string &serial)
@@ -188,6 +201,9 @@ EncLayerFactory::deserializeLayer(unsigned int id,
         case SECLEVEL::DETJOIN:
             return DETJOINFactory::deserialize(id, li);
 
+        case SECLEVEL::OPEFOREIGN:
+            return OPEFOREIGNFactory::deserialize(id,li);
+
         case SECLEVEL::OPE:
             return OPEFactory::deserialize(id, li);
 
@@ -312,6 +328,8 @@ private:
     const std::pair<int64_t, uint64_t> inclusiveRange;
 };
 
+
+
 static CryptedInteger
 overrideCreateFieldCryptedIntegerFactory(const Create_field &cf,
                                          const std::string &key,
@@ -1036,6 +1054,18 @@ private:
     mutable OPE ope;                      // HACK
 };
 
+class OPEFOREIGN_int:public OPE_int{
+public:
+    OPEFOREIGN_int(const Create_field &cf, const std::string &seed_key):OPE_int(cf,seed_key){}
+    OPEFOREIGN_int(unsigned int id, const CryptedInteger &cinteger,
+            size_t plain_size, size_t ciph_size):OPE_int(id,cinteger,plain_size,ciph_size){}
+    SECLEVEL level() const {return SECLEVEL::OPEFOREIGN;}
+    std::string name() const {return "OPEFOREIGN_int";}
+    static std::unique_ptr<OPEFOREIGN_int>
+        deserialize(unsigned int id, const std::string &serial);
+};
+
+
 class OPE_str : public EncLayer {
 public:
     OPE_str(const Create_field &cf, const std::string &seed_key);
@@ -1063,6 +1093,17 @@ private:
     static const size_t ciph_size = 8;
 };
 
+class OPEFOREIGN_str: public OPE_str{
+public:
+    OPEFOREIGN_str(const Create_field &cf, const std::string &seed_key):OPE_str(cf,seed_key){}
+    OPEFOREIGN_str(unsigned int id, const std::string &serial):OPE_str(id,serial){}
+
+    SECLEVEL level() const {return SECLEVEL::OPEFOREIGN;}
+    std::string name() const {return "OPEFOREIGN_str";}
+
+};
+
+
 std::unique_ptr<EncLayer>
 OPEFactory::create(const Create_field &cf, const std::string &key)
 {
@@ -1088,6 +1129,35 @@ OPEFactory::deserialize(unsigned int id, const SerialLayer &sl)
     }
 }
 
+
+std::unique_ptr<EncLayer>
+OPEFOREIGNFactory::create(const Create_field &cf, const std::string &key) {
+    if (isMySQLTypeNumeric(cf)) {
+        if (cf.sql_type == MYSQL_TYPE_DECIMAL
+            || cf.sql_type ==  MYSQL_TYPE_NEWDECIMAL) {
+            FAIL_TextMessageError("decimal support is broken");
+        }
+        return std::unique_ptr<EncLayer>(new OPEFOREIGN_int(cf, key));
+    }
+    return std::unique_ptr<EncLayer>(new OPEFOREIGN_str(cf, key));
+}
+
+std::unique_ptr<EncLayer>
+OPEFOREIGNFactory::deserialize(unsigned int id, const SerialLayer &sl)
+{
+    if (sl.name == "OPEFOREIGN_int") {
+        return OPEFOREIGN_int::deserialize(id, sl.layer_info);
+    } else if (sl.name == "OPEFOREIGN_str") {
+        return std::unique_ptr<EncLayer>(new OPEFOREIGN_str(id, sl.layer_info));
+    } else {
+        FAIL_TextMessageError("decimal support broken");
+    }
+}
+
+
+
+
+
 static size_t
 toMultiple(size_t n, size_t multiple)
 {
@@ -1171,9 +1241,22 @@ OPE_int::deserialize(unsigned int id, const std::string &serial)
     const size_t ciph_bytes  = strtoul_(vec[1]);
     const CryptedInteger cint = CryptedInteger::deserialize(vec[2]);
     return std::unique_ptr<OPE_int>(new OPE_int(id, cint, plain_bytes,
+                                                ciph_bytes) );
+}
+
+
+std::unique_ptr<OPEFOREIGN_int>
+OPEFOREIGN_int::deserialize(unsigned int id, const std::string &serial)
+{
+    const std::vector<std::string> vec = unserialize_string(serial);
+    const size_t plain_bytes = strtoul_(vec[0]);
+    const size_t ciph_bytes  = strtoul_(vec[1]);
+    const CryptedInteger cint = CryptedInteger::deserialize(vec[2]);
+    return std::unique_ptr<OPEFOREIGN_int>(new OPEFOREIGN_int(id, cint, plain_bytes,
                                                 ciph_bytes));
 }
 
+
 std::string
 OPE_int::doSerialize() const
 {
@@ -1375,9 +1458,10 @@ HOM::newCreateField(const Create_field &cf,
                                   &my_charset_bin);
 }
 
+//if first, use seed key to generate 
+
 void
-HOM::unwait() const
-{
+HOM::unwait() const {
     const std::unique_ptr<streamrng<arc4>>
         prng(new streamrng<arc4>(seed_key));
     sk = new Paillier_priv(Paillier_priv::keygen(prng.get(), nbits));

main/CryptoHandlers.hh

@@ -177,3 +177,10 @@ public:
     std::string doSerialize() const;
 };
 
+
+
+
+
+
+
+

main/Makefrag

@@ -7,7 +7,7 @@ CRYPTDB_SRCS := schema.cc Translator.cc Connect.cc \
 		rewrite_func.cc rewrite_sum.cc metadata_tables.cc \
 		error.cc stored_procedures.cc rewrite_ds.cc rewrite_main.cc
 
-CRYPTDB_PROGS:= cdb_test MyBack
+CRYPTDB_PROGS:= 
 
 
 CRYPTDBPROGOBJS	:= $(patsubst %,$(OBJDIR)/main/%,$(CRYPTDB_PROGS))
@@ -27,7 +27,7 @@ $(OBJDIR)/libcryptdb.so: $(CRYPTDB_OBJS) \
 			 $(OBJDIR)/libedbcrypto.so \
 			 $(OBJDIR)/libedbutil.so \
 			 $(OBJDIR)/libedbparser.so 
-	$(CXX) -shared -o $@ $(CRYPTDB_OBJS) $(LDFLAGS) $(LDRPATH) \
+	$(CXX) -shared -g -o $@ $(CRYPTDB_OBJS) $(LDFLAGS) $(LDRPATH) \
 	       -ledbcrypto -ledbutil -ledbparser -lntl -lcrypto
 
 install: install_main

main/alter_sub_handler.cc

@@ -108,28 +108,125 @@ class ChangeColumnSubHandler : public AlterSubHandler {
     }
 };
 
-class ForeignKeySubHandler : public AlterSubHandler {
-    virtual LEX *
-        rewriteAndUpdate(Analysis &a, LEX *lex, const Preamble &preamble)
-            const
-    {
-        FAIL_TextMessageError("implement ForeignKeySubHandler");
-    }
-};
+LEX * ForeignKeySubHandler::rewriteAndUpdate(Analysis &a, LEX *lex, const Preamble &preamble)
+            const{
+//       LEX *const new_lex = copyWithTHD(lex);
+       TableMeta const &ctm =
+            a.getTableMeta(preamble.dbname, preamble.table);
+       
+        //find essential information from froeign key
+       auto it =
+             List_iterator<Key>(lex->alter_info.key_list);
+
+       while(auto cur = it++){
+           if(cur->type==Key::FOREIGN_KEY){
+                   Table_ident* ref_table = ((Foreign_key*)cur)->ref_table;
+                   std::string ref_table_name = convert_lex_str(ref_table->table);
+                   TableMeta const &reftm =
+                        a.getTableMeta(preamble.dbname, ref_table_name);
+                   auto it_ref_columns = List_iterator<Key_part_spec>(((Foreign_key*)cur)->ref_columns);
+                   //should find Only ope, and adjust it to OPEFOREIGN  
+                   while(auto cur_ref_columns=it_ref_columns++){
+                        std::string ref_column_name = convert_lex_str(cur_ref_columns->field_name);
+                        OnionMeta *om = a.getOnionMeta2(preamble.dbname,ref_table_name,ref_column_name,oOPE);
+                        FieldMeta &reffm = a.getFieldMeta(reftm,ref_column_name);
+                        assert(om!=NULL);
+                        if(om->getLayerBack()->level()==SECLEVEL::RND||
+                           om->getLayerBack()->level()==SECLEVEL::OPE){                           
+                           OnionAdjustExcept oje(reftm,reffm,oOPE,SECLEVEL::OPEFOREIGN);
+                           throw oje; 
+                        }else if(om->getLayerBack()->level()==SECLEVEL::OPEFOREIGN){
+                           //nothing here
+                        }else{
+                            assert(0);
+                        }
+                   }
+          }else if(cur->type==Key::MULTIPLE){//adjust to OPEFROEIGN
+              auto it_columns = List_iterator<Key_part_spec>(cur->columns);
+              while(auto go = it_columns++){
+                  std::string current_field_name = convert_lex_str(go->field_name);
+                  OnionMeta *om = a.getOnionMeta2(preamble.dbname, preamble.table, current_field_name, oOPE);
+                  if(om!=NULL){ 
+                      if(om->getLayerBack()->level()==SECLEVEL::RND||
+                        om->getLayerBack()->level()==SECLEVEL::OPE){
+                          const FieldMeta &fm = a.getFieldMeta(ctm,current_field_name);
+                          OnionAdjustExcept oje(ctm,fm,oOPE,SECLEVEL::OPEFOREIGN);
+                          throw oje;
+                      }else if(om->getLayerBack()->level()==SECLEVEL::OPEFOREIGN){
+                          //nothing
+                      }else{
+                         assert(0);
+                      }
+                  }
+             }
+          }else{
+              assert(0);
+              return NULL;
+          }
+       }
+       highLevelRewriteKey(ctm, *lex, lex, a);
+       highLevelRewriteForeignKey(ctm,*lex,lex,a,preamble.table);
+
+       return lex;
+}
 
-class AddIndexSubHandler : public AlterSubHandler {
-    virtual LEX *
-        rewriteAndUpdate(Analysis &a, LEX *lex, const Preamble &preamble)
-            const
-    {
+
+LEX * AddIndexSubHandler::rewriteAndUpdate(Analysis &a, LEX *lex, const Preamble &preamble)const{
+    
+        if(lex->alter_info.flags & ALTER_FOREIGN_KEY) return lex;
+        //LEX *const new_lex = copyWithTHD(lex);
         TableMeta const &tm =
             a.getTableMeta(preamble.dbname, preamble.table);
-
+        //before rewriting key, we should check the layers of the onions for each field
+        auto it =
+             List_iterator<Key>(lex->alter_info.key_list);
+        while(auto cur = it++){
+            //for each key, find the columns
+            switch(cur->type){
+                case Key::PRIMARY:
+                case Key::UNIQUE:
+                case Key::MULTIPLE:
+                case Key::FULLTEXT:
+                case Key::SPATIAL:{
+                    //for each column, find the 
+                    auto it_columns = List_iterator<Key_part_spec>(cur->columns);
+                    while(auto go = it_columns++){
+                        std::string current_field_name = convert_lex_str(go->field_name);
+                        OnionMeta *om = a.getOnionMeta2(preamble.dbname, preamble.table, current_field_name, oDET);
+                        if(om!=NULL){
+                            //Remove RND here(reference rewrite_field.cc)
+                           if(om->getLayerBack()->level()==SECLEVEL::RND){
+                                const TableMeta &tm = a.getTableMeta(preamble.dbname,preamble.table);
+                                const FieldMeta &fm = a.getFieldMeta(tm,current_field_name);
+                                OnionAdjustExcept oje(tm,fm,oDET,SECLEVEL::DET);
+                                throw oje;
+                           }
+                        }
+                        om = a.getOnionMeta2(preamble.dbname,preamble.table,convert_lex_str(go->field_name),oOPE);
+                        if(om!=NULL){
+                            //Still remove RND here
+                            if(om->getLayerBack()->level()==SECLEVEL::RND){
+                                const TableMeta &tm = a.getTableMeta(preamble.dbname,preamble.table);
+                                const FieldMeta &fm = a.getFieldMeta(tm,current_field_name);
+                                OnionAdjustExcept oje(tm,fm,oOPE,SECLEVEL::OPE);
+                                throw oje;
+                            }
+                        }
+                    }
+                    break;
+                }
+                case Key::FOREIGN_KEY:{
+                    
+                    //assert(0);
+                    //do nothing here
+                }
+            }
+        }
+        //if we have foreign, then no need to rewrite here
         highLevelRewriteKey(tm, *lex, lex, a);
-
         return lex;
-    }
-};
+}
+
 
 class DropIndexSubHandler : public AlterSubHandler {
     virtual LEX *
@@ -214,7 +311,6 @@ class DisableOrEnableKeys : public AlterSubHandler {
 LEX *AlterSubHandler::
 transformLex(Analysis &a, LEX *const lex) const
 {
-    std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
     const std::string &db = lex->select_lex.table_list.first->db;
     TEST_DatabaseDiscrepancy(db, a.getDatabaseName());
     const Preamble preamble(db,

main/alter_sub_handler.hh

@@ -21,5 +21,24 @@ protected:
     AlterSubHandler() {;}
 };
 
+
+class AddIndexSubHandler : public AlterSubHandler {
+    virtual LEX *
+        rewriteAndUpdate(Analysis &a, LEX *lex, const Preamble &preamble)const;
+
+};
+
+class ForeignKeySubHandler : public AlterSubHandler{
+    virtual LEX *
+        rewriteAndUpdate(Analysis &a, LEX *lex, const Preamble &preamble)const;
+};
+
+
+
 class AlterDispatcher;
+
 AlterDispatcher *buildAlterSubDispatcher();
+
+
+
+

main/cdb_test.cc

@@ -46,6 +46,8 @@
 
 FILE* fr,*fw;
 
+
+
 static std::string embeddedDir="/t/cryt/shadow";
 
 //My WrapperState.
@@ -94,6 +96,7 @@ struct rawReturnValue{
 };
 
 
+
 struct backupOnionSelection {
     int numOfFields;
     std::vector<int> fieldSize;
@@ -375,7 +378,6 @@ static void processTableMeta(const TableMeta &table){
 static void processDatabaseMeta(const DatabaseMeta & db) {
     std::cout<<GREEN_BEGIN<<"PRINT DatabaseMeta"<<COLOR_END<<std::endl;
     for(const auto & table: db.getChildren()){
-//        std::cout<<table.second->getDatabaseID()<<":"<<table.first.getValue()<<std::endl;
         processTableMeta(*(table.second));
     }
 }
@@ -889,17 +891,24 @@ main() {
             std::getline(std::cin,curQuery);            
             continue;
         }
-	if(curQuery=="back"){
-	    startBack();
-	}else{	
-	    std::cout<<GREEN_BEGIN<<"curQuery: "<<curQuery<<"\n"<<COLOR_END<<std::endl;
-       	    batchTogether(client,curQuery,_thread_id);
-	}
+
+        /*
+        if(curQuery=="back"){
+            startBack();
+        }else{	
+            std::cout<<GREEN_BEGIN<<"curQuery: "<<curQuery<<"\n"<<COLOR_END<<std::endl;
+            batchTogether(client,curQuery,_thread_id);
+        }*/
+
+        std::unique_ptr<SchemaInfo> schema =  myLoadSchemaInfo();
+        processSchemaInfo(*schema);
+
+
+
         std::cout<<GREEN_BEGIN<<"\nplease input a new query:#######"<<COLOR_END<<std::endl;
         std::getline(std::cin,curQuery);
     }
 
-
     fclose(fr);
     fclose(fw);
     return 0;

main/ddl_handler.cc

@@ -11,9 +11,12 @@
 
 #include <util/yield.hpp>
 
-class CreateTableHandler : public DDLHandler {
-    virtual AbstractQueryExecutor *
-        rewriteAndUpdate(Analysis &a, LEX *lex, const Preamble &pre) const
+
+//a list of ddl handlers, buildddlhandler, and ddlexecutor
+
+//################################################################Create table handler#########################################################################################
+AbstractQueryExecutor *
+        CreateTableHandler::rewriteAndUpdate(Analysis &a, LEX *lex, const Preamble &pre) const
     {
         assert(a.deltas.size() == 0);
 
@@ -60,7 +63,7 @@ class CreateTableHandler : public DDLHandler {
             TABLE_LIST *const tbl =
                 rewrite_table_list(new_lex->select_lex.table_list.first,
                                    tm->getAnonTableName());
-
+            //new table_list only contain one element
             new_lex->select_lex.table_list =
                 *oneElemListWithTHD<TABLE_LIST>(tbl);
 
@@ -75,6 +78,7 @@ class CreateTableHandler : public DDLHandler {
 	    //对现有的每个field, 如id,name, 都在内部通过createAndRewriteField函数扩展成多个洋葱+salt.
 	    //其中洋葱有多个层, 其通过newCreateField函数, 决定了类型, 而新的field的名字, 就是洋葱的名字传过去的.
             //扩展以后, 就是新的Create_field类型了, 这了返回的list是被继续传到引用参数里面的, 很奇怪的用法.
+            //key data在这里的作用是, 决定是不是unique, 从而选择和是的洋葱层次.
             new_lex->alter_info.create_list =
                 accumList<Create_field>(it,
                     [&a, &tm, &key_data] (List<Create_field> out_list,
@@ -82,12 +86,11 @@ class CreateTableHandler : public DDLHandler {
                         return createAndRewriteField(a, cf, tm.get(),
                                                      true, key_data, out_list);
                 });
-
             // -----------------------------
             //         Rewrite INDEX
             // -----------------------------
             highLevelRewriteKey(*tm.get(), *lex, new_lex, a);
-
+            highLevelRewriteForeignKey(*tm.get(), *lex, new_lex, a,pre.table);
             // -----------------------------
             //         Update TABLE
             // -----------------------------
@@ -97,37 +100,23 @@ class CreateTableHandler : public DDLHandler {
                                             a.getDatabaseMeta(pre.dbname),
                                             IdentityMetaKey(pre.table))));
         } else { // Table already exists.
-
-            // Make sure we aren't trying to create a table that
             // already exists.
             const bool test =
                 lex->create_info.options & HA_LEX_CREATE_IF_NOT_EXISTS;
             TEST_TextMessageError(test,
                                 "Table " + pre.table + " already exists!");
             //why still rewrite here???
-            // -----------------------------
-            //         Rewrite TABLE
-            // -----------------------------
-            //这部分在exists的时候, 没有被执行!!!,但是如何抛出一场返回给客户端信息呢? 
-            new_lex->select_lex.table_list =
-                rewrite_table_list(lex->select_lex.table_list, a);
-            // > We do not rewrite the fields because presumably the caller
-            // can do a CREATE TABLE IF NOT EXISTS for a table that already
-            // exists, but with fields that do not actually exist.
-            // > This would cause problems when trying to look up FieldMeta
-            // for these non-existant fields.
-            // > We may want to do some additional non-deterministic
-            // anonymization of the fieldnames to prevent information leaks.
-            // (ie, server gets compromised, server logged all sql queries,
-            // attacker can see that the admin creates the account table
-            // with the credit card field every time the server boots)
         }
 	//在handler的第一阶段, 通过analysis搜集delta以及执行计划等内容, 然后在第二阶段, 实行delta以及
         //执行计划, 新的lex里面包含了改写以后的语句, 直接转化成string就可以用了.
         return new DDLQueryExecutor(*new_lex, std::move(a.deltas));
     }
-};
 
+
+
+
+
+//################################################################Alter table handler#########################################################################################
 // mysql does not support indiscriminate add-drops
 // ie,
 //      mysql> create table pk (x integer);
@@ -176,6 +165,11 @@ public:
     AlterTableHandler() : sub_dispatcher(buildAlterSubDispatcher()) {}
 };
 
+
+
+//################################################################drop table handler#########################################################################################
+
+
 class DropTableHandler : public DDLHandler {
     virtual AbstractQueryExecutor *
         rewriteAndUpdate(Analysis &a, LEX *lex, const Preamble &pre) const
@@ -219,6 +213,9 @@ class DropTableHandler : public DDLHandler {
     }
 };
 
+
+//################################################################Create db handler#########################################################################################
+
 class CreateDBHandler : public DDLHandler {
     virtual AbstractQueryExecutor *
         rewriteAndUpdate(Analysis &a, LEX *const lex, const Preamble &pre)
@@ -248,6 +245,9 @@ class CreateDBHandler : public DDLHandler {
     }
 };
 
+
+//################################################################change db handler#########################################################################################
+
 class ChangeDBHandler : public DDLHandler {
     virtual AbstractQueryExecutor *
         rewriteAndUpdate(Analysis &a, LEX *const lex, const Preamble &pre)
@@ -258,6 +258,8 @@ class ChangeDBHandler : public DDLHandler {
     }
 };
 
+
+//################################################################drop db handler#########################################################################################
 class DropDBHandler : public DDLHandler {
     virtual AbstractQueryExecutor *
         rewriteAndUpdate(Analysis &a, LEX *const lex, const Preamble &pre)
@@ -274,6 +276,8 @@ class DropDBHandler : public DDLHandler {
     }
 };
 
+
+//################################################################lock table handler#########################################################################################
 class LockTablesHandler : public DDLHandler {
     virtual AbstractQueryExecutor *
         rewriteAndUpdate(Analysis &a, LEX *const lex, const Preamble &pre)
@@ -289,6 +293,8 @@ class LockTablesHandler : public DDLHandler {
     }
 };
 
+
+//################################################################Create index handler#########################################################################################
 class CreateIndexHandler : public DDLHandler {
     virtual AbstractQueryExecutor *
         rewriteAndUpdate(Analysis &a, LEX *const lex, const Preamble &pre)
@@ -311,6 +317,7 @@ class CreateIndexHandler : public DDLHandler {
     }
 };
 
+
 static std::string
 empty_if_null(const char *const p)
 {
@@ -323,7 +330,6 @@ AbstractQueryExecutor *DDLHandler::
 transformLex(Analysis &a, LEX *lex) const
 {
 
-    std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
     assert(a.deltas.size() == 0);
 
     AssignOnce<std::string> db;
@@ -393,7 +399,6 @@ nextImpl(const ResType &res, const NextParams &nparams)
                     "deltaOutputBeforeQuery failed for DDL");
                 this->embedded_completion_id = embedded_completion_id;
             }
-            std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl;
 	    std::cout<<RED_BEGIN<<"rewritten DDL: "<<this->new_query<<COLOR_END<<std::endl;
             return CR_QUERY_AGAIN(this->new_query);
         }
@@ -402,7 +407,6 @@ nextImpl(const ResType &res, const NextParams &nparams)
         this->ddl_res = res;
 
         yield {
-            std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
             return CR_QUERY_AGAIN(
                 " INSERT INTO " + MetaData::Table::remoteQueryCompletion() +
                 "   (embedded_completion_id, completion_type) VALUES"
@@ -421,7 +425,7 @@ nextImpl(const ResType &res, const NextParams &nparams)
         TEST_ErrPkt(deltaOutputAfterQuery(nparams.ps.getEConn(), this->deltas,
                                           this->embedded_completion_id.get()),
                    "deltaOuputAfterQuery failed for DDL");
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
+//        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         yield return CR_RESULTS(this->ddl_res.get());
     }
 

main/ddl_handler.hh

@@ -9,13 +9,14 @@
 #include <sql_lex.h>
 
 class DDLQueryExecutor : public AbstractQueryExecutor {
-    const std::string new_query;
-    const std::vector<std::unique_ptr<Delta> > deltas;
+
+
 
     AssignOnce<ResType> ddl_res;
     AssignOnce<uint64_t> embedded_completion_id;
 
 public:
+    const std::string new_query;
     DDLQueryExecutor(const LEX &new_lex,
                      std::vector<std::unique_ptr<Delta> > &&deltas)
         : new_query(lexToQuery(new_lex)), deltas(std::move(deltas)) {}
@@ -24,6 +25,7 @@ public:
         nextImpl(const ResType &res, const NextParams &nparams);
 
 private:
+    const std::vector<std::unique_ptr<Delta> > deltas;
     bool stales() const {return true;}
     bool usesEmbedded() const {return true;}
 };
@@ -37,11 +39,20 @@ public:
 private:
     virtual AbstractQueryExecutor *
         rewriteAndUpdate(Analysis &a, LEX *lex, const Preamble &pre) const = 0;
-
 protected:
     DDLHandler() {;}
     virtual ~DDLHandler() {;}
 };
 
+
+class CreateTableHandler : public DDLHandler {
+    //must rewrite the header here or we get pure virtual function
+    virtual AbstractQueryExecutor *
+        rewriteAndUpdate(Analysis &a, LEX *lex, const Preamble &pre) const;
+};
+
+
+
+
 SQLDispatcher *buildDDLDispatcher();
 

main/dispatcher.cc

 #include <main/dispatcher.hh>
 
+/*
+This file contains functions for SQLDispatcher and 
+AlterDispatcher
+*/
+//########################SQLDispatcher#########################
 bool
 SQLDispatcher::canDo(LEX *const lex) const
 {
@@ -22,6 +27,9 @@ SQLDispatcher::extract(LEX *const lex) const
     return lex->sql_command;
 }
 
+
+
+//#####################AlterDispatcher##########################
 bool
 AlterDispatcher::canDo(LEX *const lex) const
 {

main/dml_handler.cc

@@ -424,7 +424,6 @@ class MultiDeleteHandler : public DMLHandler {
 class SelectHandler : public DMLHandler {
     virtual void gather(Analysis &a, LEX *const lex)
         const{
-        std::cout<<RED_BEGIN<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<COLOR_END<<std::endl<<std::endl;
         //处理了选择域, 以及为having等field 设置了rewriteplain, 也就是encset, 不同的洋葱层次需要这个东西.
         process_select_lex(lex->select_lex, a);
     }
@@ -1289,11 +1288,40 @@ class ShowTablesHandlers : public DMLHandler {
 
     virtual AbstractQueryExecutor *rewrite(Analysis &a, LEX *lex) const
     {
-         std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         return new ShowTablesExecutor();
     }
 };
 
+
+//add show create table handler
+class ShowCreateTableHandler: public DMLHandler{
+    virtual void gather(Analysis &a, LEX *const lex) const
+    {
+
+    }
+    virtual AbstractQueryExecutor *rewrite(Analysis &a, LEX *lex) const
+    {
+
+        int elements = lex->select_lex.table_list.elements;
+        assert(elements==1);
+
+        TABLE_LIST *tbl = lex->select_lex.table_list.first;
+        std::string db(tbl->db);
+        std::string tbn(tbl->table_name);
+
+        TableMeta &tbm = a.getTableMeta(db,tbn);
+
+        //rewrite the table list here        
+        LEX *const new_lex = copyWithTHD(lex);
+        tbl =  rewrite_table_list(new_lex->select_lex.table_list.first,tbm.getAnonTableName());
+        new_lex->select_lex.table_list = *oneElemListWithTHD<TABLE_LIST>(tbl);        
+
+        return new ShowCreateTableExecutor(*new_lex);
+    }
+};
+
+
+
 // FIXME: Add test to make sure handlers added successfully.
 SQLDispatcher *buildDMLDispatcher()
 {
@@ -1324,6 +1352,11 @@ SQLDispatcher *buildDMLDispatcher()
     h = new ShowTablesHandlers;
     dispatcher->addHandler(SQLCOM_SHOW_TABLES, h);
 
+    //added
+    h = new ShowCreateTableHandler;
+    dispatcher->addHandler(SQLCOM_SHOW_CREATE,h);
+
+
     return dispatcher;
 }
 
@@ -1332,13 +1365,9 @@ DMLQueryExecutor::
 nextImpl(const ResType &res, const NextParams &nparams)
 {
     reenter(this->corot) {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;      
         std::cout<<RED_BEGIN<<"rewritten DML: "<<this->query<<COLOR_END<<std::endl;
         yield return CR_QUERY_AGAIN(this->query);
         TEST_ErrPkt(res.success(), "DML query failed against remote database");
-
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
-
         yield {
             try {
                 return CR_RESULTS(Rewriter::decryptResults(res, this->rmeta));
@@ -1701,12 +1730,10 @@ ShowTablesExecutor::
 nextImpl(const ResType &res, const NextParams &nparams)
 {
     reenter(this->corot) {
-//     std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         yield return CR_QUERY_AGAIN(nparams.original_query);
         TEST_ErrPkt(res.success(), "show tables failed");
 
         yield {
-//     std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
             const std::shared_ptr<const SchemaInfo> &schema =
                 nparams.ps.getSchemaInfo();
             const DatabaseMeta *const dm =
@@ -1716,10 +1743,8 @@ nextImpl(const ResType &res, const NextParams &nparams)
             std::vector<std::vector<Item *> > new_rows;
 
             for (const auto &it : res.rows) {
-//                std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;                
                 assert(1 == it.size());
                 for (const auto &table : dm->getChildren()) {    
-//                    std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
                     assert(table.second);
                     if (table.second->getAnonTableName()
                         == ItemToString(*it.front())) {
@@ -1731,10 +1756,54 @@ nextImpl(const ResType &res, const NextParams &nparams)
                     }
                 }
             }
-
             return CR_RESULTS(ResType(res, new_rows));
         }
     }
+    assert(false);
+}
+
+
 
+
+std::pair<AbstractQueryExecutor::ResultType, AbstractAnything *>
+ShowCreateTableExecutor::
+nextImpl(const ResType &res, const NextParams &nparams){
+    std::cout<<"showCreateTableExecutor"<<std::endl;
+    //return CR_QUERY_AGAIN(nparams.original_query);
+    reenter(this->corot) {
+        yield return CR_QUERY_AGAIN(this->query);
+        TEST_ErrPkt(res.success(), "show create table tables failed");
+
+        yield {
+            //how to find schemaInfo?? we can get it directly
+            const std::shared_ptr<const SchemaInfo> &schema =
+                nparams.ps.getSchemaInfo();
+            const DatabaseMeta *const dm =
+                schema->getChild(IdentityMetaKey(nparams.default_db));
+            TEST_ErrPkt(dm, "failed to find the database '"
+                            + nparams.default_db + "'");
+            
+            std::vector<std::vector<Item *> > new_rows;
+
+            //adapted from show tables;
+            /*for (const auto &it : res.rows) {
+                assert(1 == it.size());
+                for (const auto &table : dm->getChildren()) {    
+                    assert(table.second);
+                    if (table.second->getAnonTableName()
+                        == ItemToString(*it.front())) {
+
+                        const IdentityMetaKey &plain_table_name
+                            = dm->getKey(*table.second.get());
+                        new_rows.push_back(std::vector<Item *>
+                            {make_item_string(plain_table_name.getValue())});
+                    }
+                }
+            }*/
+
+            return CR_RESULTS(ResType(res, new_rows));
+        }
+    }
+    //avoid reach the end
     assert(false);
 }

main/dml_handler.hh

@@ -96,15 +96,30 @@ private:
 
 class ShowTablesExecutor : public AbstractQueryExecutor {
     const std::vector<std::unique_ptr<Delta> > deltas;
-
+    std::string query;
 public:
-    ShowTablesExecutor() {}
+    ShowTablesExecutor(){}
     ~ShowTablesExecutor() {}
 
     std::pair<ResultType, AbstractAnything *>
         nextImpl(const ResType &res, const NextParams &nparams);
+
 };
 
+
+//added
+class ShowCreateTableExecutor: public AbstractQueryExecutor{
+    std::string query;
+public:
+    ShowCreateTableExecutor(const LEX &lex):query(lexToQuery(lex)){}
+    ~ShowCreateTableExecutor(){}
+
+    std::pair<ResultType, AbstractAnything *>
+        nextImpl(const ResType &res, const NextParams &nparams);
+};
+
+
+
 // Abstract base class for query handler.
 class DMLHandler : public SQLHandler {
 public:

main/rewrite_const.cc

@@ -29,7 +29,6 @@
 static Item *
 encrypt_item(const Item &i, const OLK &olk, Analysis &a)
 {
-    std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
     assert(!RiboldMYSQL::is_null(i));
 
     FieldMeta * const fm = olk.key;
@@ -55,7 +54,6 @@ static class ANON : public CItemSubtypeIT<Item_string,
     virtual RewritePlan *
     do_gather_type(const Item_string &i, Analysis &a) const
     {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         LOG(cdb_v) << " String item do_gather " << i << std::endl;
         const std::string why = "is a string constant";
         reason rsn(FULL_EncSet_Str, why, i);
@@ -63,7 +61,6 @@ static class ANON : public CItemSubtypeIT<Item_string,
     }
 
     virtual Item * do_optimize_type(Item_string *i, Analysis & a) const {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         return i;
     }
 
@@ -71,7 +68,6 @@ static class ANON : public CItemSubtypeIT<Item_string,
     do_rewrite_type(const Item_string &i, const OLK &constr,
                     const RewritePlan &rp, Analysis &a) const
     {
-         std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         LOG(cdb_v) << "do_rewrite_type String item " << i << std::endl;
         return encrypt_item(i, constr, a);
     }
@@ -80,7 +76,6 @@ static class ANON : public CItemSubtypeIT<Item_string,
     do_rewrite_insert_type(const Item_string &i, const FieldMeta &fm,
                            Analysis &a, std::vector<Item *> *l) const
     {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         typical_rewrite_insert_type(i, fm, a, l);
     }
 } ANON;
@@ -90,7 +85,6 @@ static class ANON : public CItemSubtypeIT<Item_float,
     virtual RewritePlan *
     do_gather_type(const Item_float &i, Analysis &a) const
     {
-         std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         LOG(cdb_v) << " Float item do_gather " << i << std::endl;
         const std::string why = "is a float constant";
         reason rsn(PLAIN_EncSet, why, i);
@@ -101,7 +95,6 @@ static class ANON : public CItemSubtypeIT<Item_float,
     do_rewrite_type(const Item_float &i, const OLK &constr,
                     const RewritePlan &rp, Analysis &a) const
     {
-         std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         LOG(cdb_v) << "do_rewrite_type Float item " << i << std::endl;
         return encrypt_item(i, constr, a);
     }
@@ -110,7 +103,6 @@ static class ANON : public CItemSubtypeIT<Item_float,
     do_rewrite_insert_type(const Item_float &i, const FieldMeta &fm,
                            Analysis &a, std::vector<Item *> *l) const
     {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         typical_rewrite_insert_type(i, fm, a, l);
     }
 } ANON;
@@ -120,7 +112,6 @@ static class ANON : public CItemSubtypeIT<Item_int, Item::Type::INT_ITEM> {
     virtual RewritePlan *
     do_gather_type(const Item_int &i, Analysis &a) const
     {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         LOG(cdb_v) << "CItemSubtypeIT (L966) num do_gather " << i
                    << std::endl;
         const std::string why = "is an int constant";
@@ -130,7 +121,6 @@ static class ANON : public CItemSubtypeIT<Item_int, Item::Type::INT_ITEM> {
 
     virtual Item * do_optimize_type(Item_int *i, Analysis & a) const
     {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         return i;
     }
 
@@ -138,7 +128,6 @@ static class ANON : public CItemSubtypeIT<Item_int, Item::Type::INT_ITEM> {
     do_rewrite_type(const Item_int &i, const OLK &constr,
                     const RewritePlan &rp, Analysis &a) const
     {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         LOG(cdb_v) << "do_rewrite_type " << i << std::endl;
 
         return encrypt_item(i, constr, a);
@@ -148,7 +137,6 @@ static class ANON : public CItemSubtypeIT<Item_int, Item::Type::INT_ITEM> {
     do_rewrite_insert_type(const Item_int &i, const FieldMeta &fm,
                            Analysis &a, std::vector<Item *> *l) const
     {
-         std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         typical_rewrite_insert_type(i, fm, a, l);
     }
 } ANON;
@@ -158,7 +146,6 @@ static class ANON : public CItemSubtypeIT<Item_decimal,
     virtual RewritePlan *
     do_gather_type(const Item_decimal &i, Analysis &a) const
     {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         LOG(cdb_v) << "CItemSubtypeIT decimal do_gather " << i
                    << std::endl;
 
@@ -169,7 +156,6 @@ static class ANON : public CItemSubtypeIT<Item_decimal,
 
     virtual Item * do_optimize_type(Item_decimal *i, Analysis & a) const
     {
-         std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         return i;
     }
 
@@ -177,7 +163,6 @@ static class ANON : public CItemSubtypeIT<Item_decimal,
     do_rewrite_type(const Item_decimal &i, const OLK &constr,
                     const RewritePlan &rp, Analysis &a) const
     {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         LOG(cdb_v) << "do_rewrite_type " << i << std::endl;
 
         return encrypt_item(i, constr, a);
@@ -187,7 +172,6 @@ static class ANON : public CItemSubtypeIT<Item_decimal,
     do_rewrite_insert_type(const Item_decimal &i, const FieldMeta &fm,
                            Analysis &a, std::vector<Item *> *l) const
     {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
         typical_rewrite_insert_type(i, fm, a, l);
     }
 } ANON;

main/rewrite_ds.hh

@@ -191,8 +191,6 @@ public:
     RewritePlan(const EncSet &es, reason r) : r(r), es_out(es) {};
     virtual ~RewritePlan() {}
     reason getReason() const {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<std::endl;
-        std::cout<<"reson why: "<<r.why<<"reason item: "<<r.string_item<<std::endl;
         return r;
     }
 

main/rewrite_field.cc

@@ -66,7 +66,6 @@ class ANON : public CItemSubtypeIT<Item_field, Item::Type::FIELD_ITEM> {
     virtual RewritePlan *
     do_gather_type(const Item_field &i, Analysis &a) const
     {
-        std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<"AAAAAAAAAAAA"<<std::endl;
         const std::string fieldname = i.field_name;
         const std::string table =
             i.table_name ? i.table_name :

main/rewrite_func.cc

@@ -298,6 +298,7 @@ class CItemCompare : public CItemSubtypeFT<Item_func, FT> {
                 return ORD_EncSet;          /* lambda */
             }
         };
+
         const EncSet my_es = getEncSet();
 
         TEST_BadItemArgumentCount(i.type(), 2, i.argument_count());

main/rewrite_main.hh

@@ -370,3 +370,14 @@ private:
     bool stales() const {return true;}
     bool usesEmbedded() const {return true;}
 };
+
+
+
+
+
+
+std::pair<std::vector<std::unique_ptr<Delta> >,
+                 std::list<std::string>>
+adjustOnion(const Analysis &a, onion o, const TableMeta &tm,
+            const FieldMeta &fm, SECLEVEL tolevel);
+

main/rewrite_util.hh

@@ -53,6 +53,12 @@ void
 highLevelRewriteKey(const TableMeta &tm, const LEX &seed_lex,
                     LEX *const out_lex, const Analysis &a);
 
+//added
+void 
+highLevelRewriteForeignKey(const TableMeta &tm, const LEX &seed_lex,
+                    LEX *const out_lex, const Analysis &a,std::string tbname);
+
+
 std::string
 bool_to_string(bool b);
 

main/schema.cc

@@ -28,8 +28,6 @@ DBMeta::doFetchChildren(const std::unique_ptr<Connect> &e_conn,
     std::unique_ptr<DBResult> db_res;
     //这个id来自于dbobject.
     const std::string parent_id = std::to_string(this->getDatabaseID());
-    std::cout<<"parent id: "<<parent_id<<std::endl;
-
     const std::string serials_query =
         " SELECT " + table_name + ".serial_object,"
         "        " + table_name + ".serial_key,"
@@ -37,7 +35,8 @@ DBMeta::doFetchChildren(const std::unique_ptr<Connect> &e_conn,
         " FROM " + table_name +
         " WHERE " + table_name + ".parent_id"
         "   = " + parent_id + ";";
-    std::cout<<serials_query<<"serial query:"<<std::endl;
+    //all the metadata are fetched here.
+    //std::cout<<serials_query<<"serial query:"<<std::endl;
     TEST_TextMessageError(e_conn->execute(serials_query, &db_res),
                           "doFetchChildren query failed");
     MYSQL_ROW row;
@@ -92,7 +91,7 @@ std::unique_ptr<OnionMeta>
 OnionMeta::deserialize(unsigned int id, const std::string &serial)
 {
     assert(id != 0);
-    std::cout<<"string before unserialize: "<<serial<<std::endl;
+    //std::cout<<"string before unserialize: "<<serial<<std::endl;
     const auto vec = unserialize_string(serial);
     //OnionMeta序列化的结果有三个.
     assert(3 == vec.size());
@@ -270,6 +269,10 @@ determineSecLevelData(onion o, std::vector<SECLEVEL> levels, bool unique)
                || SECLEVEL::RND == levels.back());
     } else if (oOPE == o) {
         assert(SECLEVEL::RND == levels.back());
+        levels.pop_back();
+        assert(SECLEVEL::OPE == levels.back());
+        levels.pop_back();
+        assert(SECLEVEL::OPEFOREIGN==levels.back());
     } else if (oAGG == o) {
         assert(SECLEVEL::HOM == levels.back());
     } else {
@@ -286,10 +289,12 @@ init_onions_layout(const AES_KEY *const m_key, FieldMeta *const fm,
     const onionlayout onion_layout = fm->getOnionLayout();
     if (fm->getHasSalt() != (static_cast<bool>(m_key)
                              && PLAIN_ONION_LAYOUT != onion_layout)) {
+        std::cout<<"unable to get salt?"<<std::endl;
         return false;
     }
 
     if (0 != fm->getChildren().size()) {
+        std::cout<<"already has children"<<std::endl;
         return false;
     }
 
@@ -331,6 +336,7 @@ FieldMeta::FieldMeta(const Create_field &field,
       sec_rating(sec_rating), uniq_count(uniq_count), counter(0),
       has_default(determineHasDefault(field)),
       default_value(determineDefaultValue(has_default, field)) {
+
     TEST_TextMessageError(init_onions_layout(m_key, this, field, unique),
                           "Failed to build onions for new FieldMeta!");
 }
@@ -409,10 +415,8 @@ onionlayout FieldMeta::determineOnionLayout(const AES_KEY *const m_key,
         // assert(!m_key);
         return PLAIN_ONION_LAYOUT;
     }
-
     TEST_TextMessageError(m_key,
                           "Should be using SECURITY_RATING::PLAIN!");
-
     if (false == encryptionSupported(f)) {
 	std::cout<<"encryption not supported for this field, remain plain"<<std::endl;
         //TEST_TextMessageError(SECURITY_RATING::SENSITIVE != sec_rating,
@@ -425,7 +429,6 @@ onionlayout FieldMeta::determineOnionLayout(const AES_KEY *const m_key,
     if (Field::NEXT_NUMBER == f.unireg_check) {
         return PLAIN_ONION_LAYOUT;
     }
-
     if (SECURITY_RATING::SENSITIVE == sec_rating) {
         if (true == isMySQLTypeNumeric(f)) {
             return NUM_ONION_LAYOUT;

mysqlproxy/ConnectWrapper.cc

@@ -363,7 +363,7 @@ void parseResType(const ResType &rd) {
 }
 */
 
-
+/*
 static
 void parseResType2(const ResType &rd) {
     std::cout<<RED_BEGIN<<"rd.affected_rows: "<<rd.affected_rows<<COLOR_END<<std::endl;
@@ -377,12 +377,14 @@ void parseResType2(const ResType &rd) {
 	}
     }
 }
+*/
+
 
 static ResType
 getResTypeFromLuaTable(lua_State *const L, int fields_index,
                        int rows_index, int affected_rows_index,
                        int insert_id_index, int status_index) {
-    std::cout<<"decide to show luaTable to ResType:"<<std::endl;
+    //std::cout<<"decide to show luaTable to ResType:"<<std::endl;
     const bool status = lua_toboolean(L, status_index);
     if (false == status) {
         return ResType(false, 0, 0);
@@ -479,7 +481,6 @@ parseReturnMeta(const ReturnMeta & rtm){
 
 static int
 next(lua_State *const L) {
-    std::cout<<__PRETTY_FUNCTION__<<":"<<__LINE__<<":"<<__FILE__<<":"<<__LINE__<<std::endl<<std::endl;
 //    ANON_REGION(__func__, &perf_cg);
     scoped_lock l(&big_lock);
     assert(0 == mysql_thread_init());
@@ -494,6 +495,7 @@ next(lua_State *const L) {
         nilBuffer(L, 1);
         return 5;
     }
+
     WrapperState *const c_wrapper = clients[client];
 
     assert(EXECUTE_QUERIES);
@@ -503,11 +505,8 @@ next(lua_State *const L) {
     ps->safeCreateEmbeddedTHD();
 
     const ResType &res = getResTypeFromLuaTable(L, 2, 3, 4, 5, 6);
-    parseResType2(res);
-
+    //parseResType2(res);
 
-    std::cout<<"************************************************"<<std::endl;
-    printRes(res);
     const std::unique_ptr<QueryRewrite> &qr = c_wrapper->getQueryRewrite();
     parseReturnMeta(qr->rmeta);
     try {

mysqlproxy/wrp.lua

-assert(package.loadlib(os.getenv("EDBDIR").."/obj/libexecute.so",
-                       "lua_cryptdb_init"))()
+assert(package.loadlib("/t/cryt/obj/libexecute.so","lua_cryptdb_init"))()
+
 local proto = assert(require("mysql.proto"))
 
 local g_want_interim    = nil
@@ -20,7 +20,7 @@ function read_auth()
                     proxy.connection.server.dst.port,
                     os.getenv("CRYPTDB_USER") or "root",
                     os.getenv("CRYPTDB_PASS") or "letmein",
-            os.getenv("CRYPTDB_SHADOW") or os.getenv("EDBDIR").."/shadow")
+            os.getenv("CRYPTDB_SHADOW") or "/t/cryt/shadow")
     -- EDBClient uses its own connection to the SQL server to set up UDFs
     -- and to manipulate multi-principal state.  (And, in the future, to
     -- store its schema state for single- and multi-principal operation.)
@@ -32,16 +32,17 @@ function disconnect_client()
 end
 
 function read_query(packet)
+    printred("read_query========================================================================================")
     local status, err = pcall(read_query_real, packet)
     if status then
         return err
     else
-        print("read_query: " .. err)
         return proxy.PROXY_SEND_QUERY
     end
 end
 
 function read_query_result(inj)
+    printred("read_query_result========================================================================================")
     local status, err = pcall(read_query_result_real, inj)
     if status then
         return err
@@ -52,6 +53,28 @@ function read_query_result(inj)
 end
 
 
+
+function split(pString, pPattern)
+   local Table = {}  -- NOTE: use {n = 0} in Lua-5.0
+   local fpat = "(.-)" .. pPattern
+   local last_end = 1
+   local s, e, cap = pString:find(fpat, 1)
+   while s do
+      if s ~= 1 or cap ~= "" then
+     table.insert(Table,cap)
+      end
+      last_end = e+1
+      s, e, cap = pString:find(fpat, last_end)
+   end
+   if last_end <= #pString then
+      cap = pString:sub(last_end)
+      table.insert(Table, cap)
+   end
+   return Table
+end
+
+
+
 --
 -- Pretty printing
 --
@@ -77,6 +100,8 @@ function printred(x)
 end
 
 function printline(n)
+    print("#######n==")
+    print(n)
     -- pretty printing
     if (n) then
        io.write("+")
@@ -114,8 +139,14 @@ function prettyNewQuery(q)
             return
         end
     end
- 
-    print(greentext("NEW QUERY: ")..makePrintable(q))
+
+    list = split(q,',') 
+    for i=1,#list do
+            io.write(string.sub(list[i],1,40))
+            print("")
+    end
+
+    --print(greentext("NEW QUERY: ")..makePrintable(q))
 end
 
 --
@@ -130,8 +161,7 @@ end
 
 function read_query_real(packet)
     local query = string.sub(packet, 2)
-    print("================================================")
-    printred("QUERY: ".. query)
+    --printred("QUERY: ".. query)
 
     if string.byte(packet) == proxy.COM_INIT_DB then
         query = "USE `" .. query .. "`"
@@ -156,6 +186,12 @@ function read_query_real(packet)
     end
 end
 
+function printRowsAndFields(inj)
+    local resultset = inj.resultset
+
+
+end
+
 function read_query_result_real(inj)
     local query = inj.query:sub(2)
     prettyNewQuery(query)
@@ -192,12 +228,9 @@ function read_query_result_real(inj)
             interim_fields[i] =
                 { type = resfields[i].type,
                   name = resfields[i].name }
-            io.write(string.format("%-20s|",rfi.name))
+            io.write(string.format("%-10s|",rfi.name))
         end
 
-        print()
-        printline(#resfields)
-
         local resrows = resultset.rows
         if resrows then
             for row in resrows do
@@ -209,10 +242,11 @@ function read_query_result_real(inj)
                 print()
             end
         end
-
-        printline(#resfields)
+        --printline(#resfields)
     end
 
+    print(greentext("ENCRYPTED RESULTS END"))
+
     return next_handler("results", true, client, interim_fields, interim_rows,
                         resultset.affected_rows, resultset.insert_id)
 end
@@ -278,5 +312,3 @@ function next_handler(from, status, client, fields, rows, affected_rows,
 
     assert(nil)
 end
-
-print("hehe")

parser/stringify.hh

@@ -126,10 +126,9 @@ std::string ListJoin(List<T> lst, std::string delim,
     auto it = List_iterator<T>(lst);
     for (T *element = it++; element; element = it++) {
         std::string finalized_element = finalize(*element);
-        accum << finalized_element;
-        accum << delim;
+            accum << finalized_element;
+            accum << delim;
     }
-
     std::string output, str_accum = accum.str();
     if (str_accum.length() > 0) {
         output = str_accum.substr(0, str_accum.length() - delim.length());
@@ -530,10 +529,28 @@ prefix_add_index(Key key)
     key_output << ListJoin<Key_part_spec>(key.columns, ",",
                                           do_prefix_add_index())
                << ")";
+    return key_output.str();
+}
+
+static std::string
+prefix_add_foreign(Key *key){
+    const std::string index_name = convert_lex_str(key->name);
+    std::ostringstream key_output;
+    key_output << " ADD constraint "<<" FOREIGN KEY "<<index_name<<" (";
+    key_output << ListJoin<Key_part_spec>(key->columns, ",",
+                                          do_prefix_add_index())
+               << ")";
+    
+    Table_ident* ref_table = ((Foreign_key*)key)->ref_table;
+    std::string ref_table_name = convert_lex_str(ref_table->table);
+    
+    key_output <<" REFERENCES "<< ref_table_name<<" (";
+    key_output<<ListJoin<Key_part_spec>( ((Foreign_key*)key)->ref_columns,",",do_prefix_add_index())<<" )";    
 
     return key_output.str();
 }
 
+
 static std::string
 enableOrDisableKeysOutput(const LEX &lex)
 {
@@ -565,6 +582,71 @@ prettyLockType(enum thr_lock_type lock_type)
 }
 */
 
+
+//process normal key in alter table command, do not process foreign key
+static std::string process_normal_key(LEX &lex){
+    std::ostringstream key_output;
+    auto it =
+             List_iterator<Key>(lex.alter_info.key_list);
+    while(auto cur = it++){
+        switch(cur->type){
+            case Key::PRIMARY:{
+                key_output<<prefix_add_index(*cur)<<",";
+                break;
+            }
+            case Key::UNIQUE:
+            case Key::MULTIPLE:
+            case Key::FULLTEXT:
+            case Key::SPATIAL:{
+                key_output<<prefix_add_index(*cur)<<",";               
+                break;
+            }
+            case Key::FOREIGN_KEY:{
+                break;
+            }
+            default:{
+                break;
+            }
+        }
+    } 
+    std::string orig = key_output.str();
+    std::string res = orig.substr(0,orig.length()-1);
+    return res;
+}
+
+static std::string process_foreign_key(LEX &lex){
+    std::ostringstream key_output;
+    auto it =
+             List_iterator<Key>(lex.alter_info.key_list);
+    while(auto cur = it++){
+        switch(cur->type){
+            case Key::PRIMARY:{
+                break;
+            }
+            case Key::UNIQUE:
+            case Key::MULTIPLE:
+            case Key::FULLTEXT:
+            case Key::SPATIAL:{
+                break;
+            }
+            case Key::FOREIGN_KEY:{
+                key_output<<prefix_add_foreign(cur)<<",";
+                break;
+            }
+            default:{
+                break;
+            }
+        }
+    } 
+    std::string orig = key_output.str();
+    std::string res = orig.substr(0,orig.length()-1);
+    return res;
+}
+
+
+
+
+
 static inline std::ostream&
 operator<<(std::ostream &out, LEX &lex)
 {
@@ -886,16 +968,31 @@ operator<<(std::ostream &out, LEX &lex)
                                                  ",", prefix_add_column);
             prev = true;
         }
-
+    
+        if(lex.alter_info.flags & ALTER_FOREIGN_KEY){
+            if (true == prev) {
+                out << ", ";
+            }
+            std::string keys;
+            keys = process_foreign_key(lex);
+            out<<" "<<keys;
+            prev = true;           
+        }
         if (lex.alter_info.flags & ALTER_ADD_INDEX) {
             if (true == prev) {
                 out << ", ";
             }
-            out << " " << ListJoin<Key>(lex.alter_info.key_list, ",",
-                                        prefix_add_index);
+            //process primary and index here
+            //out << " " << ListJoin<Key>(lex.alter_info.key_list, ",",
+            //                            prefix_add_index);
+            //get a vector of key type, key name, and key columns
+            std::string keys;
+            keys = process_normal_key(lex);
+            out<<" "<<keys;
             prev = true;
         }
 
+
         if (lex.alter_info.flags & ALTER_DROP_INDEX) {
             if (true == prev) {
                 out << ", ";
@@ -940,7 +1037,19 @@ operator<<(std::ostream &out, LEX &lex)
         /* placeholders to make analysis work.. */
         out << ".. type " << lex.sql_command << " query ..";
         break;
-
+    //ADDED
+    case SQLCOM_SHOW_CREATE:{
+        int elements = lex.select_lex.table_list.elements;
+        if(elements==1){
+            TABLE_LIST *tbl = lex.select_lex.table_list.first;
+            std::string db(tbl->db);
+            std::string tbn(tbl->table_name);
+            out<< "SHOW CREATE TABLE "+db+"."+tbn;
+        }else{
+            out<<"ONLY SUPPORT ONE TABLE";
+        }
+        break;
+    }
     default:
         thrower() << "unhandled sql command " << lex.sql_command;
     }
@@ -948,3 +1057,5 @@ operator<<(std::ostream &out, LEX &lex)
     return out;
 }
 
+
+

start/curMysql

-/t/mysql-src/build/client/mysql -uroot -pletmein -h 127.0.0.1 -P3399

start/mysql-proxy.cnf

-[mysql-proxy]
-plugins = proxy
-event-threads = 4
-proxy-lua-script = /t/cryt/mysqlproxy/wrapper.lua
-proxy-address = 127.0.0.1:3399
-
-proxy-backen-addresses = 127.0.0.1:3306

start/mysql-proxy1.cnf

-[mysql-proxy]
-plugins = proxy
-event-threads = 4
-proxy-lua-script = /t/cryt/tutorial-basic.lua
-proxy-address = 127.0.0.1:3399
-proxy-backen-addresses = 127.0.0.1:3306

start/normal.sh

-mysql-proxy --defaults-file=./mysql-proxy2.cnf
-

start/reset.sh

-rm -rf ./shadow/* ./shadowtest/*
-mysql -uroot -pletmein < reset.sql

start/reset.sql

-drop database if exists tf;
-drop database if exists tdb;
-drop database if exists tdb2;
-drop database if exists tdb3;
-drop database if exists remote_db;
-drop database if exists cryptdb_udf;

start/startMM.sh

-mysql-proxy --defaults-file=/t/cryt/mysql-proxy.cnf
-

start/test

-./obj/main/cdb_test

start/tutorial-basic.lua

-COLOR_END = '\027[00m'
-
-function redtext(x)
-    return '\027[1;31m' .. x .. COLOR_END
-end
-
-function greentext(x)
-    return '\027[1;92m'.. x .. COLOR_END
-end
-
-function orangetext(x)
-    return '\027[01;33m'.. x .. COLOR_END
-end
-
-g=1
-
-queryType = {}
-queryType[proxy.COM_SLEEP] = "COM_SLEEP"
-queryType[proxy.COM_QUIT] = "COM_QUIT"
-queryType[proxy.COM_INIT_DB] = "COM_INIT_DB"
-queryType[proxy.COM_QUERY] = "COM_QUERY"
-queryType[proxy.COM_FIELD_LIST]= "COM_FIELD_LIST"
-queryType[proxy.COM_CREATE_DB]= "COM_CREATE_DB"
-queryType[proxy.COM_DROP_DB]= "COM_DROP_DB"
-queryType[proxy.COM_REFRESH]= "COM_REFRESH"
-queryType[proxy.COM_SHUTDOWN] = "COM_SHUTDOWN"
-queryType[proxy.COM_STATISTICS] = "COM_STATISTICS"
-queryType[proxy.COM_PROCESS_INFO] = "COM_PROCESS_INFO"
-queryType[proxy.COM_CONNECT] = "COM_CONNECT"
-queryType[proxy.COM_PROCESS_KILL] = "COM_PROCESS_KILL"
-queryType[proxy.COM_DEBUG] = "COM_DEBUG"
-queryType[proxy.COM_PING] = "COM_PING"
-queryType[proxy.COM_TIME] = "COM_TIME"
-queryType[proxy.COM_DELAYED_INSERT] = "COM_DELAYED_INSERT"
-queryType[proxy.COM_CHANGE_USER] = "COM_CHANGE_USER"
-queryType[proxy.COM_BINLOG_DUMP] = "COM_BINLOG_DUMP"
-queryType[proxy.COM_TABLE_DUMP] = "COM_TABLE_DUMP"
-queryType[proxy.COM_CONNECT_OUT] = "COM_CONNECT_OUT"
-queryType[proxy.COM_REGISTER_SLAVE] = "COM_REGISTER_SLAVE"
-queryType[proxy.COM_STMT_PREPARE] = "COM_STMT_PREPARE"
-queryType[proxy.COM_STMT_EXECUTE] = "COM_STMT_EXECUTE"
-queryType[proxy.COM_STMT_SEND_LONG_DATA] = "COM_STMT_SEND_LONG_DATA"
-queryType[proxy.COM_STMT_CLOSE] = "COM_STMT_CLOSE"
-queryType[proxy.COM_STMT_RESET] = "COM_STMT_RESET"
-queryType[proxy.COM_SET_OPTION] = "COM_SET_OPTION"
-queryType[proxy.COM_STMT_FETCH] = "COM_STMT_FETCH"
-queryType[proxy.COM_DAEMON] = "COM_DAEMON"
-
-
-
-
-
-
-function printCS()
-    server = nil
-    client = nil
-    sp = nil
-    if proxy.connection.client ~= nil then
-        client = proxy.connection.client.src.name
-    end
-    
-    if proxy.connection.server ~= nil then
-        server = proxy.connection.server.dst.address
-        sp = proxy.connection.server.dst.port
-    end
-    if client~= nil then
-        print(redtext("clientName:"..client))
-    else
-        print(redtext("clientName=nil"))
-    end
-
-    if server ~= nil then
-        print(redtext(server))
-    else 
-        print(redtext("server=nil"))
-    end
-    if sp ~= nil then
-        print(redtext(sp))
-    else
-        print(redtext("sp = nil"))
-    end
-end
-
-
-function connect_server()
-    print(orangetext("connect_server"))
-    printCS()
-    if g == 1 then 
-        g = 0
-    else g = 1
-    end
-    print("g "..g)
-    print("ndx "..proxy.connection.backend_ndx.."get: "..#proxy.global.backends)
-
-end
-
-function read_handshake()
-    print(orangetext("read_handshake"))
-    printCS()
-end
-
-function read_auth()
-    print(orangetext("read_auth"))
-    printCS()
-end
-
-function read_auth_result()
-    print(orangetext("read_auth_result"))
-    printCS()
-end
-
-function read_query( packet )
-    print(orangetext("read_query"))
-    print(redtext("query type: "..queryType[string.byte(packet)]))
-    printCS()
-    
-    if string.byte(packet) == proxy.COM_QUERY then
-	print("we got a normal query: " .. string.sub(packet, 2))
-        proxy.queries:append(1, packet, {resultset_is_needed = true})
-        return proxy.PROXY_SEND_QUERY
-   else
- 	print("we got a abnormal query: " .. string.sub(packet, 2))
-    end
-end
-
-
-function print_fields(infields)
-    local resfields = infields
-    local interim_fields = {}
-    --store fileds in interim_fields
-    if (#resfields) then
-           io.write("|")
-    end
-    for i = 1, #resfields do
-        rfi = resfields[i]
-        interim_fields[i] ={ type = resfields[i].type,name = resfields[i].name }
-        io.write(string.format("%-20s|",rfi.name))
-    end
-end
-
-
-function print_rows(inrows)
-    local resrows = inrows
-    local interim_rows = {}
-    for row in resrows do
-        table.insert(interim_rows, row)
-        io.write("|")
---        for key,value in pairs(row) do
---            io.write(string.format("%-20s|", value))
---        end
-         for k,v in pairs(row) do
-               if v ~= nil then
-                   io.write(string.format("%-20s|", v))
-		   io.write("size = "..string.len(v))
-               else
-                   io.write(string.format("%-20s|", "nil"))
-               end
-         end
-         print()
-    end
-end
-
-function read_query_result(inj)
-    print(orangetext("read_query_result"))
-    printCS()
-    print("ROWS: "..type(inj.resultset.rows))
-    if inj.resultset.rows ~= nil then
-        print_fields(inj.resultset.fields)
-        print("finish fields")
-        print_rows(inj.resultset.rows)
-    end
-end

stopgdbs

+###stop gdb 
+ps aux|grep gdb|grep -v grep|awk '{print $2}'| while read line;do sudo kill -9 $line;done

util/Makefrag

@@ -4,7 +4,7 @@ UTILSRC := onions.cc cryptdb_log.cc ctr.cc util.cc version.cc
 all:    $(OBJDIR)/libedbutil.so $(OBJDIR)/libedbutil.a
 
 $(OBJDIR)/libedbutil.so: $(patsubst %.cc,$(OBJDIR)/util/%.o,$(UTILSRC))
-	$(CXX) -shared -o $@ $^ $(LDFLAGS) -lntl -lcrypto -lgmp
+	$(CXX) -fPIC -shared -o $@ $^ $(LDFLAGS) -lntl -lcrypto -lgmp
 
 $(OBJDIR)/libedbutil.a: $(patsubst %.cc,$(OBJDIR)/util/%.o,$(UTILSRC))
 	$(AR) r $@ $^

util/hello.cc

+#include<stdio.h>
+
+void help(){
+    printf("help\n");
+}
+

util/onions.hh

@@ -25,6 +25,7 @@ typedef enum onion {
 enum class SECLEVEL {
     INVALID,
     PLAINVAL,
+    OPEFOREIGN,
     OPE,
     DETJOIN,
     DET,
@@ -43,14 +44,14 @@ static onionlayout PLAIN_ONION_LAYOUT = {
 static onionlayout NUM_ONION_LAYOUT = {
     {oDET, std::vector<SECLEVEL>({SECLEVEL::DETJOIN, SECLEVEL::DET,
                                   SECLEVEL::RND})},
-    {oOPE, std::vector<SECLEVEL>({SECLEVEL::OPE, SECLEVEL::RND})},
+    {oOPE, std::vector<SECLEVEL>({SECLEVEL::OPEFOREIGN,SECLEVEL::OPE, SECLEVEL::RND})},
     {oAGG, std::vector<SECLEVEL>({SECLEVEL::HOM})}
 };
 
 static onionlayout BEST_EFFORT_NUM_ONION_LAYOUT = {
     {oDET, std::vector<SECLEVEL>({SECLEVEL::DETJOIN, SECLEVEL::DET,
                                   SECLEVEL::RND})},
-    {oOPE, std::vector<SECLEVEL>({SECLEVEL::OPE, SECLEVEL::RND})},
+    {oOPE, std::vector<SECLEVEL>({SECLEVEL::OPEFOREIGN,SECLEVEL::OPE, SECLEVEL::RND})},
     {oAGG, std::vector<SECLEVEL>({SECLEVEL::HOM})},
     // Requires SECLEVEL::DET, otherwise you will have to implement
     // encoding for negative numbers in SECLEVEL::RND.
@@ -61,7 +62,7 @@ static onionlayout BEST_EFFORT_NUM_ONION_LAYOUT = {
 static onionlayout STR_ONION_LAYOUT = {
     {oDET, std::vector<SECLEVEL>({SECLEVEL::DETJOIN, SECLEVEL::DET,
                                   SECLEVEL::RND})},
-    {oOPE, std::vector<SECLEVEL>({SECLEVEL::OPE, SECLEVEL::RND})},
+    {oOPE, std::vector<SECLEVEL>({SECLEVEL::OPEFOREIGN,SECLEVEL::OPE, SECLEVEL::RND})},
     // {oSWP, std::vector<SECLEVEL>({SECLEVEL::SEARCH})}
     // {oSWP, std::vector<SECLEVEL>({SECLEVEL::PLAINVAL, SECLEVEL::DET,
                                   // SECLEVEL::RND})}
@@ -70,7 +71,7 @@ static onionlayout STR_ONION_LAYOUT = {
 static onionlayout BEST_EFFORT_STR_ONION_LAYOUT = {
     {oDET, std::vector<SECLEVEL>({SECLEVEL::DETJOIN, SECLEVEL::DET,
                                   SECLEVEL::RND})},
-    {oOPE, std::vector<SECLEVEL>({SECLEVEL::OPE, SECLEVEL::RND})},
+    {oOPE, std::vector<SECLEVEL>({SECLEVEL::OPEFOREIGN,SECLEVEL::OPE, SECLEVEL::RND})},
     // {oSWP, std::vector<SECLEVEL>({SECLEVEL::SEARCH})},
     // {oSWP, std::vector<SECLEVEL>({SECLEVEL::PLAINVAL, SECLEVEL::DET,
     //                              SECLEVEL::RND})},

mysqlproxy/wrapper.lua → wrapper.lua

-assert(package.loadlib("/t/cryt/obj/libexecute.so","lua_cryptdb_init"))()
-
+local handle = io.popen('pwd')
+local result = handle:read("*a")
+handle:close()
+prefix = result:gsub("\n$", "")
+libpath = prefix.."/obj/libexecute.so"
+assert(package.loadlib(libpath,
+                       "lua_cryptdb_init"))()
 local proto = assert(require("mysql.proto"))
 
 local g_want_interim    = nil
@@ -20,7 +25,7 @@ function read_auth()
                     proxy.connection.server.dst.port,
                     os.getenv("CRYPTDB_USER") or "root",
                     os.getenv("CRYPTDB_PASS") or "letmein",
-            os.getenv("CRYPTDB_SHADOW") or "/t/cryt/shadow")
+            os.getenv("CRYPTDB_SHADOW") or prefix.."/shadow")
     -- EDBClient uses its own connection to the SQL server to set up UDFs
     -- and to manipulate multi-principal state.  (And, in the future, to
     -- store its schema state for single- and multi-principal operation.)
@@ -32,17 +37,16 @@ function disconnect_client()
 end
 
 function read_query(packet)
-    printred("read_query========================================================================================")
     local status, err = pcall(read_query_real, packet)
     if status then
         return err
     else
+        print("read_query: " .. err)
         return proxy.PROXY_SEND_QUERY
     end
 end
 
 function read_query_result(inj)
-    printred("read_query_result========================================================================================")
     local status, err = pcall(read_query_result_real, inj)
     if status then
         return err
@@ -53,28 +57,6 @@ function read_query_result(inj)
 end
 
 
-
-function split(pString, pPattern)
-   local Table = {}  -- NOTE: use {n = 0} in Lua-5.0
-   local fpat = "(.-)" .. pPattern
-   local last_end = 1
-   local s, e, cap = pString:find(fpat, 1)
-   while s do
-      if s ~= 1 or cap ~= "" then
-     table.insert(Table,cap)
-      end
-      last_end = e+1
-      s, e, cap = pString:find(fpat, last_end)
-   end
-   if last_end <= #pString then
-      cap = pString:sub(last_end)
-      table.insert(Table, cap)
-   end
-   return Table
-end
-
-
-
 --
 -- Pretty printing
 --
@@ -100,8 +82,6 @@ function printred(x)
 end
 
 function printline(n)
-    print("#######n==")
-    print(n)
     -- pretty printing
     if (n) then
        io.write("+")
@@ -139,14 +119,8 @@ function prettyNewQuery(q)
             return
         end
     end
-
-    list = split(q,',') 
-    for i=1,#list do
-            io.write(string.sub(list[i],1,40))
-            print("")
-    end
-
-    --print(greentext("NEW QUERY: ")..makePrintable(q))
+ 
+    print(greentext("NEW QUERY: ")..makePrintable(q))
 end
 
 --
@@ -161,7 +135,8 @@ end
 
 function read_query_real(packet)
     local query = string.sub(packet, 2)
-    --printred("QUERY: ".. query)
+    print("================================================")
+    printred("QUERY: ".. query)
 
     if string.byte(packet) == proxy.COM_INIT_DB then
         query = "USE `" .. query .. "`"
@@ -186,12 +161,6 @@ function read_query_real(packet)
     end
 end
 
-function printRowsAndFields(inj)
-    local resultset = inj.resultset
-
-
-end
-
 function read_query_result_real(inj)
     local query = inj.query:sub(2)
     prettyNewQuery(query)
@@ -228,9 +197,12 @@ function read_query_result_real(inj)
             interim_fields[i] =
                 { type = resfields[i].type,
                   name = resfields[i].name }
-            io.write(string.format("%-10s|",rfi.name))
+            io.write(string.format("%-20s|",rfi.name))
         end
 
+        print()
+        printline(#resfields)
+
         local resrows = resultset.rows
         if resrows then
             for row in resrows do
@@ -242,10 +214,9 @@ function read_query_result_real(inj)
                 print()
             end
         end
-        --printline(#resfields)
-    end
 
-    print(greentext("ENCRYPTED RESULTS END"))
+        printline(#resfields)
+    end
 
     return next_handler("results", true, client, interim_fields, interim_rows,
                         resultset.affected_rows, resultset.insert_id)