Fixed message record id autoincrementation;

new database heleper methods to fetch: sync devices, message records, network records, attack records;
refactored database helper;
added sync record;
database helper can save and fetch sync records;
added synchronizer;

src/de/tudarmstadt/informatik/hostage/Handler.java

@@ -49,7 +49,7 @@ public class Handler implements Runnable {
 	SharedPreferences pref; 
 
 	private int attack_id;
-	private int message_id = 0;
+	//private int message_id = 0;
 	private String externalIP;
 	private String BSSID;
 	private String SSID;
@@ -193,8 +193,8 @@ public class Handler implements Runnable {
 	 * @return The Record representing the communication message.
 	 */
 	protected MessageRecord createMessageRecord(TYPE type, String packet) {
-		MessageRecord record = new MessageRecord();
-		record.setId(message_id++);
+		MessageRecord record = new MessageRecord(true);
+		//record.setId(message_id++); // autoincrement
 		record.setAttack_id(attack_id);		
 		record.setType(type);
 		record.setTimestamp(System.currentTimeMillis());

src/de/tudarmstadt/informatik/hostage/logging/Logger.java

@@ -117,9 +117,9 @@ public class Logger extends IntentService {
 			}else if(ACTION_LOG_PORTSCAN.equals(action)){
 				final AttackRecord attackRecord = intent.getParcelableExtra(EXTRA_RECORD);
 				final NetworkRecord networkRecord = intent.getParcelableExtra(EXTRA_RECORD2);
-				MessageRecord messageRecord = new MessageRecord();
+				MessageRecord messageRecord = new MessageRecord(true);
 				messageRecord.setAttack_id(attackRecord.getAttack_id());
-				messageRecord.setId(0);
+				//messageRecord.setId(0);
 				messageRecord.setPacket("");
 				messageRecord.setTimestamp(intent.getLongExtra(EXTRA_TIMESTAMP, 0));
 				messageRecord.setType(TYPE.RECEIVE);

src/de/tudarmstadt/informatik/hostage/logging/MessageRecord.java

@@ -2,8 +2,12 @@ package de.tudarmstadt.informatik.hostage.logging;
 
 import java.io.Serializable;
 
+import android.content.SharedPreferences;
 import android.os.Parcel;
 import android.os.Parcelable;
+import android.preference.PreferenceManager;
+
+import de.tudarmstadt.informatik.hostage.ui.activity.MainActivity;
 
 /**
  * Holds all necessary information about a single message exchanged during an attack.
@@ -40,6 +44,17 @@ public class MessageRecord implements Parcelable, Serializable{
 
     }
 
+    public MessageRecord(boolean autoincrement){
+        if (autoincrement){
+            SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(MainActivity.getContext());
+
+            SharedPreferences.Editor editor = pref.edit();
+            int message_id = pref.getInt("MESSAGE_ID_COUNTER", 0);
+            editor.putInt("MESSAGE_ID_COUNTER", message_id + 1);
+            editor.commit();
+            this.id = message_id;
+        }
+    }
 
     public MessageRecord(Parcel source) {
             this.id = source.readInt();

src/de/tudarmstadt/informatik/hostage/logging/NetworkRecord.java

@@ -36,6 +36,7 @@ public class NetworkRecord implements Parcelable, Serializable {
 	}
 
 	public NetworkRecord(Parcel source) {
+        super();
 		this.bssid = source.readString();
 		this.ssid = source.readString();
 		this.timestampLocation = source.readLong();

src/de/tudarmstadt/informatik/hostage/logging/SyncInfoRecord.java

@@ -6,10 +6,10 @@ import java.io.Serializable;
  * Holds the Information a specific device gathered about a network identified by its BSSID.
  * @author Lars Pandikow
  */
-public class SyncInfoRecord implements Serializable{	
+public class SyncInfoRecord implements Serializable{
 
 	private static final long serialVersionUID = 7156818788190434192L;
-	
+
 	private String deviceID;
 	private String BSSID;
 	private long number_of_attacks;

src/de/tudarmstadt/informatik/hostage/logging/SyncRecord.java

@@ -0,0 +1,353 @@
+package de.tudarmstadt.informatik.hostage.logging;
+
+/**
+ * Created by Julien on 08.12.2014.
+ */
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.io.Serializable;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.io.Serializable;
+import java.util.zip.Deflater;
+
+public class SyncRecord implements Parcelable, Serializable {
+
+    private static final long serialVersionUID = 7106818788090434192L;
+
+
+    private long attack_id;
+    private long sync_id;
+    private String bssid;
+    private String device;
+    private String protocol;
+    private String localIP;
+    private int localPort;
+    private String remoteIP;
+    private int remotePort;
+    private String externalIP;
+    private int wasInternalAttack; // 1 if attacker ip and local ip were in same subnet, else 0
+
+    // attack
+    private int id;
+    private long timestamp;
+    private MessageRecord.TYPE type;
+    private String packet;
+
+    public static final Parcelable.Creator<SyncRecord> CREATOR = new Parcelable.Creator<SyncRecord>() {
+        @Override
+        public SyncRecord createFromParcel(Parcel source) {
+            return new SyncRecord(source);
+        }
+
+        @Override
+        public SyncRecord[] newArray(int size) {
+            return new SyncRecord[size];
+        }
+    };
+
+    public SyncRecord() {
+
+    }
+
+    public SyncRecord(Parcel source) {
+        super();
+        this.attack_id = source.readLong();
+        this.protocol = source.readString();
+        this.localIP = source.readString();
+        this.localPort = source.readInt();
+        this.remoteIP = source.readString();
+        this.remotePort = source.readInt();
+        this.externalIP = source.readString();
+        this.wasInternalAttack = source.readInt();
+        this.bssid = source.readString();
+        this.device = source.readString();
+        this.sync_id = source.readLong();
+
+        this.id = source.readInt();
+        this.timestamp = source.readLong();
+        this.type = MessageRecord.TYPE.valueOf(source.readString());
+        this.packet = source.readString();
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeLong(attack_id);
+        dest.writeString(protocol);
+        dest.writeString(localIP);
+        dest.writeInt(localPort);
+        dest.writeString(remoteIP);
+        dest.writeInt(remotePort);
+        dest.writeString(externalIP);
+        dest.writeInt(wasInternalAttack);
+        dest.writeString(bssid);
+        dest.writeString(device);
+        dest.writeLong(sync_id);
+
+        dest.writeInt(id);
+        dest.writeLong(timestamp);
+        dest.writeString(type.name());
+        dest.writeString(packet);
+    }
+
+
+    public AttackRecord getAttackRecord(){
+        boolean autoincrement = !this.device.equals(SyncDevice.currentDevice().getDeviceID());
+        AttackRecord record = new AttackRecord(autoincrement);
+
+        if (!autoincrement)
+            record.setAttack_id(this.attack_id);
+
+        this.attack_id = record.getAttack_id();
+        record.setProtocol(this.protocol);
+        record.setSync_id(this.sync_id);
+        record.setLocalIP(this.localIP);
+        record.setLocalPort(this.localPort);
+        record.setBssid(this.bssid);
+        record.setDevice(this.device);
+        record.setExternalIP(this.externalIP);
+        record.setWasInternalAttack(this.getWasInternalAttack());
+        record.setRemoteIP(this.remoteIP);
+        record.setRemotePort(this.remotePort);
+
+        return record;
+    }
+
+    public MessageRecord getMessageRecord(){
+        MessageRecord record = new MessageRecord();
+        record.setAttack_id(this.attack_id);
+        record.setPacket(this.packet);
+        record.setTimestamp(this.timestamp);
+        record.setType(this.type);
+        return record;
+    }
+
+    /**
+     * @return the attack_id
+     */
+    public long getAttack_id() {
+        return attack_id;
+    }
+
+    /**
+     * @param attack_id
+     *            the attack_id to set
+     */
+    public void setAttack_id(long attack_id) {
+        this.attack_id = attack_id;
+    }
+
+    /**
+     * @return the bssid
+     */
+    public String getBssid() {
+        return bssid;
+    }
+
+    /**
+     * @param bssid
+     *            the bssid to set
+     */
+    public void setBssid(String bssid) {
+        this.bssid = bssid;
+    }
+
+    /**
+     * @return the protocol
+     */
+    public String getProtocol() {
+        return protocol;
+    }
+
+    /**
+     * @param protocol
+     *            the protocol to set
+     */
+    public void setProtocol(String protocol) {
+        this.protocol = protocol;
+    }
+
+    /**
+     * @return the localIP
+     */
+    public String getLocalIP() {
+        return localIP;
+    }
+
+    /**
+     * @param localIP
+     *            the localIP to set
+     */
+    public void setLocalIP(String localIP) {
+        this.localIP = localIP;
+    }
+
+    /**
+     * @return the localPort
+     */
+    public int getLocalPort() {
+        return localPort;
+    }
+
+    /**
+     * @param localPort
+     *            the localPort to set
+     */
+    public void setLocalPort(int localPort) {
+        this.localPort = localPort;
+    }
+
+    /**
+     * @return the remoteIP
+     */
+    public String getRemoteIP() {
+        return remoteIP;
+    }
+
+    /**
+     * @param remoteIP
+     *            the remoteIP to set
+     */
+    public void setRemoteIP(String remoteIP) {
+        this.remoteIP = remoteIP;
+    }
+
+    /**
+     * @return the remotePort
+     */
+    public int getRemotePort() {
+        return remotePort;
+    }
+
+    public long getSync_id(){return sync_id;}
+    public String getDevice(){return device;}
+    public void setDevice(String d){this.device = d;}
+    public void setSync_id(long i){this.sync_id = i;}
+    /**
+     * @param remotePort
+     *            the remotePort to set
+     */
+    public void setRemotePort(int remotePort) {
+        this.remotePort = remotePort;
+    }
+
+    /**
+     * @return the externalIP
+     */
+    public String getExternalIP() {
+        return externalIP;
+    }
+
+    /**
+     * @param externalIP
+     *            the externalIP to set
+     */
+    public void setExternalIP(String externalIP) {
+        this.externalIP = externalIP;
+    }
+
+    public boolean getWasInternalAttack() {return wasInternalAttack == 1;}
+    public void setWasInternalAttack(boolean b) {wasInternalAttack = b ? 1 : 0;}
+
+
+
+    /*
+    *
+    *
+    *  MESSAGE RECORD
+    *
+    *
+    */
+    /**
+     * @return the id
+     */
+    public int getId() {
+        return id;
+    }
+    /**
+     * @param id the id to set
+     */
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    /**
+     * @return the timestamp
+     */
+    public long getTimestamp() {
+        return timestamp;
+    }
+    /**
+     * @param timestamp the timestamp to set
+     */
+    public void setTimestamp(long timestamp) {
+        this.timestamp = timestamp;
+    }
+    /**
+     * @return the type
+     */
+    public MessageRecord.TYPE getType() {
+        return type;
+    }
+    /**
+     * @param type the type to set
+     */
+    public void setType(MessageRecord.TYPE type) {
+        this.type = type;
+    }
+    /**
+     * @return the packet
+     */
+    public String getPacket() {
+        return packet;
+    }
+    /**
+     * @param packet the packet to set
+     */
+    public void setPacket(String packet) {
+        this.packet = packet;
+    }
+
+    /**
+     * @return the number_of_attacks
+     */
+    @Deprecated
+    public long getNumber_of_attacks() {
+        return number_of_attacks;
+    }
+    /**
+     * @param number_of_attacks the number_of_attacks to set
+     */
+    @Deprecated
+    public void setNumber_of_attacks(long number_of_attacks) {
+        this.number_of_attacks = number_of_attacks;
+    }
+    /**
+     * @return the number_of_portscans
+     */
+    @Deprecated
+    public long getNumber_of_portscans() {
+        return number_of_portscans;
+    }
+    /**
+     * @param number_of_portscans the number_of_portscans to set
+     */
+    @Deprecated
+    public void setNumber_of_portscans(long number_of_portscans) {
+        this.number_of_portscans = number_of_portscans;
+    }
+
+    private long number_of_attacks;
+    private long number_of_portscans;
+
+}
+

src/de/tudarmstadt/informatik/hostage/persistence/HostageDBOpenHelper.java

@@ -1,23 +1,17 @@
 package de.tudarmstadt.informatik.hostage.persistence;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
 
 import android.content.ContentValues;
 import android.content.Context;
-import android.content.SharedPreferences;
 import android.database.Cursor;
+import android.database.CursorIndexOutOfBoundsException;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteOpenHelper;
-import android.preference.PreferenceManager;
 import android.util.Log;
-import de.tudarmstadt.informatik.hostage.commons.HelperUtils;
 import de.tudarmstadt.informatik.hostage.logging.AttackRecord;
 import de.tudarmstadt.informatik.hostage.logging.MessageRecord;
 import de.tudarmstadt.informatik.hostage.logging.NetworkRecord;
@@ -25,6 +19,7 @@ import de.tudarmstadt.informatik.hostage.logging.Record;
 import de.tudarmstadt.informatik.hostage.logging.SyncDevice;
 import de.tudarmstadt.informatik.hostage.logging.SyncInfoRecord;
 import de.tudarmstadt.informatik.hostage.logging.MessageRecord.TYPE;
+import de.tudarmstadt.informatik.hostage.logging.SyncRecord;
 import de.tudarmstadt.informatik.hostage.model.Profile;
 import de.tudarmstadt.informatik.hostage.persistence.HostageDBContract.AttackEntry;
 import de.tudarmstadt.informatik.hostage.persistence.HostageDBContract.NetworkEntry;
@@ -32,7 +27,6 @@ import de.tudarmstadt.informatik.hostage.persistence.HostageDBContract.PacketEnt
 import de.tudarmstadt.informatik.hostage.persistence.HostageDBContract.ProfileEntry;
 import de.tudarmstadt.informatik.hostage.persistence.HostageDBContract.SyncDeviceEntry;
 import de.tudarmstadt.informatik.hostage.persistence.HostageDBContract.SyncInfoEntry;
-import de.tudarmstadt.informatik.hostage.ui.activity.MainActivity;
 import de.tudarmstadt.informatik.hostage.ui.helper.ColorSequenceGenerator;
 import de.tudarmstadt.informatik.hostage.ui.model.LogFilter;
 import de.tudarmstadt.informatik.hostage.ui.model.PlotComparisonItem;
@@ -176,18 +170,43 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 	public void addMessageRecord(MessageRecord record) {
 		SQLiteDatabase db = this.getWritableDatabase();
 
-		ContentValues recordValues = new ContentValues();
-		recordValues.put(PacketEntry.COLUMN_NAME_ID, record.getId()); // Log Message Number
-		recordValues.put(PacketEntry.COLUMN_NAME_ATTACK_ID, record.getAttack_id()); // Log Attack ID
-		recordValues.put(PacketEntry.COLUMN_NAME_TYPE, record.getType().name()); // Log Type
-		recordValues.put(PacketEntry.COLUMN_NAME_PACKET_TIMESTAMP, record.getTimestamp()); // Log Timestamp
-		recordValues.put(PacketEntry.COLUMN_NAME_PACKET, record.getPacket()); // Log Packet
-
-		// Inserting Rows
-		db.insert(PacketEntry.TABLE_NAME, null, recordValues);
+		this.insertMessageRecordWithOnConflict(record, db);
 		db.close(); // Closing database connection
 	}
-	
+
+    /**
+     * Adds a given {@link de.tudarmstadt.informatik.hostage.logging.MessageRecord}s to the database.
+     *
+     * @param records {@link List}<MessageRecord>
+     *            The added {@link de.tudarmstadt.informatik.hostage.logging.MessageRecord}s .
+     */
+    public void insertMessageRecords(List<MessageRecord> records){
+        SQLiteDatabase db = this.getWritableDatabase();
+        db.beginTransaction();
+
+        try {
+            for (MessageRecord record : records){
+                this.insertMessageRecordWithOnConflict(record,db);
+            }
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+        db.close();
+    }
+
+    private void insertMessageRecordWithOnConflict(MessageRecord record, SQLiteDatabase db){
+        ContentValues recordValues = new ContentValues();
+        //recordValues.put(PacketEntry.COLUMN_NAME_ID, record.getId()); // Log Message Number
+        recordValues.put(PacketEntry.COLUMN_NAME_ATTACK_ID, record.getAttack_id()); // Log Attack ID
+        recordValues.put(PacketEntry.COLUMN_NAME_TYPE, record.getType().name()); // Log Type
+        recordValues.put(PacketEntry.COLUMN_NAME_PACKET_TIMESTAMP, record.getTimestamp()); // Log Timestamp
+        recordValues.put(PacketEntry.COLUMN_NAME_PACKET, record.getPacket()); // Log Packet
+
+        // Inserting Rows
+        db.insertWithOnConflict(PacketEntry.TABLE_NAME, null, recordValues, SQLiteDatabase.CONFLICT_REPLACE);
+    }
+
 	/**
 	 * Adds a given {@link AttackRecord} to the database.
 	 *
@@ -197,28 +216,14 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 	public void addAttackRecord(AttackRecord record) {
 		//Log.i("DBHelper", "Add Attack Record with id: " + record.getAttack_id());
 		SQLiteDatabase db = this.getWritableDatabase();
-
-		ContentValues attackValues = new ContentValues();
-		attackValues.put(AttackEntry.COLUMN_NAME_ATTACK_ID, record.getAttack_id()); // Log Attack ID
-		attackValues.put(AttackEntry.COLUMN_NAME_PROTOCOL, record.getProtocol().toString());
-		attackValues.put(AttackEntry.COLUMN_NAME_EXTERNAL_IP, record.getExternalIP());
-		attackValues.put(AttackEntry.COLUMN_NAME_LOCAL_IP, record.getLocalIP()); // Log Local IP
-		attackValues.put(AttackEntry.COLUMN_NAME_LOCAL_PORT, record.getLocalPort());
-		attackValues.put(AttackEntry.COLUMN_NAME_REMOTE_IP, record.getRemoteIP()); // Log Remote IP
-		attackValues.put(AttackEntry.COLUMN_NAME_REMOTE_PORT, record.getRemotePort()); // Log Remote Port
-		attackValues.put(AttackEntry.COLUMN_NAME_INTERNAL_ATTACK, record.getWasInternalAttack());
-		attackValues.put(AttackEntry.COLUMN_NAME_BSSID, record.getBssid());
-		
-
-		// Inserting Rows
-		db.insertWithOnConflict(AttackEntry.TABLE_NAME, null, attackValues, SQLiteDatabase.CONFLICT_REPLACE);
+		this.insertAttackRecordWithOnConflict(record,db);
 		db.close(); // Closing database connection
 	}
 
     /**
      * Adds a given {@link AttackRecord}s to the database.
      *
-     * @param {@link List}<AttackRecord>
+     * @param records {@link List}<AttackRecord>
      *            The added {@link AttackRecord}s .
      */
     public void insertAttackRecords(List<AttackRecord> records) {
@@ -230,19 +235,46 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 
         try {
             for (AttackRecord record : records){
-                ContentValues attackValues = new ContentValues();
-                attackValues.put(AttackEntry.COLUMN_NAME_ATTACK_ID, record.getAttack_id()); // Log Attack ID
-                attackValues.put(AttackEntry.COLUMN_NAME_PROTOCOL, record.getProtocol().toString());
-                attackValues.put(AttackEntry.COLUMN_NAME_EXTERNAL_IP, record.getExternalIP());
-                attackValues.put(AttackEntry.COLUMN_NAME_LOCAL_IP, record.getLocalIP()); // Log Local IP
-                attackValues.put(AttackEntry.COLUMN_NAME_LOCAL_PORT, record.getLocalPort());
-                attackValues.put(AttackEntry.COLUMN_NAME_REMOTE_IP, record.getRemoteIP()); // Log Remote IP
-                attackValues.put(AttackEntry.COLUMN_NAME_REMOTE_PORT, record.getRemotePort()); // Log Remote Port
-                attackValues.put(AttackEntry.COLUMN_NAME_INTERNAL_ATTACK, record.getWasInternalAttack());
-                attackValues.put(AttackEntry.COLUMN_NAME_BSSID, record.getBssid());
-
-                // Inserting Rows
-                db.insertWithOnConflict(AttackEntry.TABLE_NAME, null, attackValues, SQLiteDatabase.CONFLICT_REPLACE);
+                this.insertAttackRecordWithOnConflict(record,db);
+            }
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+        db.close(); // Closing database connection
+    }
+
+    private void insertAttackRecordWithOnConflict(AttackRecord record, SQLiteDatabase db){
+        ContentValues attackValues = new ContentValues();
+        attackValues.put(AttackEntry.COLUMN_NAME_ATTACK_ID, record.getAttack_id()); // Log Attack ID
+        attackValues.put(AttackEntry.COLUMN_NAME_PROTOCOL, record.getProtocol().toString());
+        attackValues.put(AttackEntry.COLUMN_NAME_EXTERNAL_IP, record.getExternalIP());
+        attackValues.put(AttackEntry.COLUMN_NAME_LOCAL_IP, record.getLocalIP()); // Log Local IP
+        attackValues.put(AttackEntry.COLUMN_NAME_LOCAL_PORT, record.getLocalPort());
+        attackValues.put(AttackEntry.COLUMN_NAME_REMOTE_IP, record.getRemoteIP()); // Log Remote IP
+        attackValues.put(AttackEntry.COLUMN_NAME_REMOTE_PORT, record.getRemotePort()); // Log Remote Port
+        attackValues.put(AttackEntry.COLUMN_NAME_INTERNAL_ATTACK, record.getWasInternalAttack());
+        attackValues.put(AttackEntry.COLUMN_NAME_BSSID, record.getBssid());
+
+        // Inserting Rows
+        db.insertWithOnConflict(AttackEntry.TABLE_NAME, null, attackValues, SQLiteDatabase.CONFLICT_REPLACE);
+    }
+
+    /**
+     * Adds a given {@link SyncRecord}s to the database.
+     *
+     * @param records {@link List}<AttackRecord>
+     *            The added {@link SyncRecord}s .
+     */
+    public void insertSyncRecords(List<SyncRecord> records) {
+        //Log.i("DBHelper", "Add Attack Record with id: " + record.getAttack_id());
+        SQLiteDatabase db = this.getWritableDatabase();
+        db.beginTransaction();
+
+        try {
+            for (SyncRecord record : records){
+                this.insertAttackRecordWithOnConflict(record.getAttackRecord(), db);
+                this.insertMessageRecordWithOnConflict(record.getMessageRecord(), db);
             }
             db.setTransactionSuccessful();
         } finally {
@@ -365,19 +397,18 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 	/**
 	 * Returns a String array with all BSSIDs stored in the database.
 	 * 
-	 * @return String[] of all recorded BSSIDs.
+	 * @return ArrayList<String> of all recorded BSSIDs.
 	 */
-	public synchronized String[] getAllBSSIDS() {
-		String selectQuery = "SELECT  * FROM " + NetworkEntry.TABLE_NAME;
+	public synchronized ArrayList<String> getAllBSSIDS() {
+		String selectQuery = "SELECT "+NetworkEntry.COLUMN_NAME_BSSID+" FROM " + NetworkEntry.TABLE_NAME;
 		SQLiteDatabase db = this.getReadableDatabase();
 		Cursor cursor = db.rawQuery(selectQuery, null);
-		String[] bssidList = new String[cursor.getCount()];
-		int counter = 0;
+        ArrayList<String> bssidList = new ArrayList<String>();
 		// looping through all rows and adding to list
 		if (cursor.moveToFirst()) {
 			do {
-				bssidList[counter] = cursor.getString(0);
-				counter++;
+				String s = cursor.getString(0);
+                bssidList.add(s);
 			} while (cursor.moveToNext());
 		}
 		cursor.close();
@@ -385,6 +416,28 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 		return bssidList;
 	}
 
+    /**
+     * Returns all missing network records.
+     *
+     * @return a list of missing network records.
+     */
+    public synchronized ArrayList<NetworkRecord> getMissingNetworkRecords(ArrayList<String> otherBSSIDs) {
+        String selectQuery = "SELECT * FROM " + NetworkEntry.TABLE_NAME + " N WHERE " + "N."+NetworkEntry.COLUMN_NAME_BSSID + " NOT IN " + otherBSSIDs;
+        SQLiteDatabase db = this.getReadableDatabase();
+        Cursor cursor = db.rawQuery(selectQuery, null);
+        ArrayList<NetworkRecord> networkInformation = new ArrayList<NetworkRecord>();
+        // looping through all rows and adding to list
+        if (cursor.moveToFirst()) {
+            do {
+                NetworkRecord record = this.createNetworkRecord(cursor);
+                networkInformation.add(record);
+            } while (cursor.moveToNext());
+        }
+        cursor.close();
+        db.close();
+        return networkInformation;
+    }
+
 	/**
 	 * Determines the number of different attacks in the database.
 	 * 
@@ -705,13 +758,7 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 		// looping through all rows and adding to list
 		if (cursor.moveToFirst()) {
 			do {
-				NetworkRecord record = new NetworkRecord();
-				record.setBssid(cursor.getString(0));
-				record.setSsid(cursor.getString(1));
-				record.setLatitude(Double.parseDouble(cursor.getString(2)));
-				record.setLongitude(Double.parseDouble(cursor.getString(3)));
-				record.setAccuracy(Float.parseFloat(cursor.getString(4)));
-				record.setTimestampLocation(cursor.getLong(5));
+				NetworkRecord record = this.createNetworkRecord(cursor);
 				networkInformation.add(record);
 			} while (cursor.moveToNext());
 		}
@@ -721,6 +768,17 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 		return networkInformation;
 	}
 
+    private NetworkRecord createNetworkRecord(Cursor cursor){
+        NetworkRecord record = new NetworkRecord();
+        record.setBssid(cursor.getString(0));
+        record.setSsid(cursor.getString(1));
+        record.setLatitude(Double.parseDouble(cursor.getString(2)));
+        record.setLongitude(Double.parseDouble(cursor.getString(3)));
+        record.setAccuracy(Float.parseFloat(cursor.getString(4)));
+        record.setTimestampLocation(cursor.getLong(5));
+        return record;
+    }
+
 	/**
 	 * Updates the network table with the information contained in the parameter.
 	 * @param networkInformation ArrayList of {@link NetworkRecord NetworkRecords}
@@ -818,12 +876,32 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 
 		db.close();
 	}
+
+    public void updateSyncDevices(ArrayList<SyncDevice> devices){
+        SQLiteDatabase db = this.getReadableDatabase();
+        db.beginTransaction();
+
+        try {
+            for(SyncDevice device : devices){
+                ContentValues deviceValues = new ContentValues();
+                deviceValues.put(SyncDeviceEntry.COLUMN_NAME_DEVICE_ID, device.getDeviceID());
+                deviceValues.put(SyncDeviceEntry.COLUMN_NAME_DEVICE_TIMESTAMP, device.getLast_sync_timestamp());
+                deviceValues.put(SyncDeviceEntry.COLUMN_NAME_HIGHEST_ATTACK_ID, device.getHighest_attack_id());
+                db.insertWithOnConflict(SyncDeviceEntry.TABLE_NAME, null, deviceValues, SQLiteDatabase.CONFLICT_REPLACE);
+            }
+            db.setTransactionSuccessful();
+        } finally {
+            db.endTransaction();
+        }
+
+        db.close();
+    }
 	
 	/**
 	 * Returns a HashMap of all devices that were previously synchronized with.
 	 * @return HashMap containing device id's and the last synchronization timestamp.
 	 */
-	public synchronized HashMap<String, Long> getSyncDevices(){
+	public synchronized HashMap<String, Long> getSyncDeviceHashMap(){
 		SQLiteDatabase db = this.getReadableDatabase();
 		HashMap<String, Long> devices = new HashMap<String, Long>();
 		
@@ -839,6 +917,28 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 		db.close();
 		return devices;
 	}
+
+    /**
+     * Returns a HashMap of all devices that were previously synchronized with.
+     * @return HashMap containing device id's and the last synchronization timestamp.
+     */
+    public synchronized ArrayList<SyncDevice> getSyncDevices(){
+        SQLiteDatabase db = this.getReadableDatabase();
+        ArrayList<SyncDevice> devices = new ArrayList<SyncDevice>();
+
+        String query = "SELECT  * FROM " + SyncDeviceEntry.TABLE_NAME;
+        Cursor cursor = db.rawQuery(query, null);
+
+        if (cursor.moveToFirst()) {
+            do {
+                SyncDevice device = this.createSyncDevice(cursor);
+                devices.add(device);
+            } while (cursor.moveToNext());
+        }
+        cursor.close();
+        db.close();
+        return devices;
+    }
 	
 	/**
 	 * Returns a ArrayList containing all information stored in the SyncInfo table.
@@ -973,11 +1073,11 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 	}
 
 	/**
-	 * Creates a {@link Record} from a Cursor. If the cursor does not show to a
+	 * Creates a {@link MessageRecord} from a Cursor. If the cursor does not show to a
 	 * valid data structure a runtime exception is thrown.
 	 * 
 	 * @param cursor
-	 * @return Returns the created {@link Record} .
+	 * @return Returns the created {@link MessageRecord} .
 	 */
 	private synchronized MessageRecord createMessageRecord(Cursor cursor) {
 		MessageRecord record = new MessageRecord();
@@ -995,7 +1095,7 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
 	 * valid data structure a runtime exception is thrown.
 	 * 
 	 * @param cursor
-	 * @return Returns the created {@link Record} .
+	 * @return Returns the created {@link AttackRecord} .
 	 */
 	private synchronized AttackRecord createAttackRecord(Cursor cursor) {
 		AttackRecord record = new AttackRecord();
@@ -1012,6 +1112,36 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
         record.setDevice(cursor.getString(10));
 		return record;
 	}
+
+    /**
+     * Creates a {@link SyncRecord} from a Cursor. If the cursor does not show to a
+     * valid data structure a runtime exception is thrown.
+     *
+     * @param cursor
+     * @return Returns the created {@link SyncRecord} .
+     */
+    private synchronized SyncRecord createSyncRecord(Cursor cursor){
+        SyncRecord record = new SyncRecord();
+        record.setAttack_id(cursor.getLong(0));
+        record.setProtocol(cursor.getString(1));
+        record.setExternalIP(cursor.getString(2));
+        record.setLocalIP(cursor.getString(3));
+        record.setLocalPort(Integer.parseInt(cursor.getString(4)));
+        record.setRemoteIP(cursor.getString(5));
+        record.setRemotePort(Integer.parseInt(cursor.getString(6)));
+        record.setWasInternalAttack(cursor.getInt(7) == 1);
+        record.setBssid(cursor.getString(8));
+        record.setSync_id(cursor.getLong(9));
+        record.setDevice(cursor.getString(10));
+
+        record.setId(Integer.parseInt(cursor.getString(11)));
+        //record.setAttack_id(cursor.getLong(12));
+        record.setType(MessageRecord.TYPE.valueOf(cursor.getString(13)));
+        record.setTimestamp(cursor.getLong(14));
+        record.setPacket(cursor.getString(15));
+
+        return record;
+    }
 	
 	/**
 	 * Creates a {@link Record} from a Cursor. If the cursor does not show to a
@@ -1562,25 +1692,74 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
         return recordList;
     }
 
+    /**
+     * Returns all device ids.
+     * @return list of all device ids.
+     */
+    public ArrayList<String> getAllDevicesIds(){
+
+        String selectQuery = "SELECT "+ SyncDeviceEntry.COLUMN_NAME_DEVICE_ID+" FROM " + SyncDeviceEntry.TABLE_NAME;
+        SQLiteDatabase db = this.getReadableDatabase();
+        Cursor cursor = db.rawQuery(selectQuery, null);
+
+        ArrayList<String> ids = new ArrayList<String>();
+        // looping through all rows and adding to list
+        if (cursor.moveToFirst()) {
+            do {
+                String s = cursor.getString(0);
+                ids.add(s);
+            } while (cursor.moveToNext());
+        }
+        cursor.close();
+
+        // return record list
+        db.close();
+        return ids;
+    }
+
+    /***
+     * Returns all missing devices ids
+     * @param devices owned device ids
+     * @return list of missing devices ids
+     */
+    public ArrayList<String> getMissingDeviceIds(ArrayList<String> devices){
+        ArrayList<String> ids = new ArrayList<String>();
+        String selectQuery = "SELECT "+ SyncDeviceEntry.COLUMN_NAME_DEVICE_ID +" FROM " + SyncDeviceEntry.TABLE_NAME + " D WHERE D." + SyncDeviceEntry.COLUMN_NAME_DEVICE_ID + " NOT IN " + devices;
+        SQLiteDatabase db = this.getReadableDatabase();
+        Cursor cursor = db.rawQuery(selectQuery, null);
+
+        if (cursor.moveToFirst()) {
+            do {
+                String deviceID = cursor.getString(0);
+                ids.add(deviceID);
+            } while (cursor.moveToNext());
+        }
+        cursor.close();
+
+        db.close();
+        return ids;
+    }
+
     /**
      * Returns all new {@link de.tudarmstadt.informatik.hostage.logging.AttackRecord}s for the given devices (including all missing devices).
      * @param devices {@link de.tudarmstadt.informatik.hostage.logging.SyncDevice}
      * @param includeMissingDevices boolean
      * @return list of {@link de.tudarmstadt.informatik.hostage.logging.AttackRecord}s
      */
-    public ArrayList<AttackRecord> getUnsyncedAttacksFor(List<SyncDevice> devices, boolean includeMissingDevices){
+    public ArrayList<SyncRecord> getUnsyncedAttacksFor(List<SyncDevice> devices, boolean includeMissingDevices){
 
         ArrayList<SyncDevice> updatedDevices = this.getUpdatedDevicesFor(devices, includeMissingDevices);
 
-        ArrayList<AttackRecord> recordList = new ArrayList<AttackRecord>();
+        ArrayList<SyncRecord> recordList = new ArrayList<SyncRecord>();
 
         SQLiteDatabase db = this.getReadableDatabase();
 
         for (SyncDevice sDevice : updatedDevices){
-            String selectQuery = "SELECT * FROM " + AttackEntry.TABLE_NAME + " A "
+            String selectQuery = "SELECT * FROM " + AttackEntry.TABLE_NAME + " A " + " NATURAL JOIN " + PacketEntry.TABLE_NAME + " P "
                     + " WHERE "
                     +" ( "
-                    + " A." + AttackEntry.COLUMN_NAME_DEVICE + " = " + "'" + sDevice.getDeviceID() + "'"
+                    + "A." + AttackEntry.COLUMN_NAME_ATTACK_ID + " = " + " P."+ PacketEntry.COLUMN_NAME_ATTACK_ID
+                    + " AND " + " A." + AttackEntry.COLUMN_NAME_DEVICE + " = " + "'" + sDevice.getDeviceID() + "'"
                     + " AND " + " A." + AttackEntry.COLUMN_NAME_SYNC_ID + " > " + sDevice.getHighest_attack_id()
                     + " ) "
                     //+ " GROUP BY " + AttackEntry.TABLE_NAME + "." + AttackEntry.COLUMN_NAME_DEVICE
@@ -1591,7 +1770,7 @@ public class HostageDBOpenHelper extends SQLiteOpenHelper {
             if (cursor != null){
                 if (cursor.moveToFirst()) {
                     do {
-                        AttackRecord record = createAttackRecord(cursor);
+                        SyncRecord record = createSyncRecord(cursor);
                         recordList.add(record);
                     } while (cursor.moveToNext());
                 }

src/de/tudarmstadt/informatik/hostage/sync/Synchronizer.java

@@ -0,0 +1,124 @@
+package de.tudarmstadt.informatik.hostage.sync;
+
+/**
+ * Created by Julien on 08.12.2014.
+ */
+
+import java.net.ServerSocket;
+import java.util.ArrayList;
+import java.util.List;
+
+import de.tudarmstadt.informatik.hostage.logging.NetworkRecord;
+import de.tudarmstadt.informatik.hostage.logging.SyncDevice;
+import de.tudarmstadt.informatik.hostage.logging.SyncRecord;
+import de.tudarmstadt.informatik.hostage.persistence.HostageDBOpenHelper;
+import de.tudarmstadt.informatik.hostage.system.Device;
+
+
+public class Synchronizer {
+
+    private HostageDBOpenHelper  dbh;
+
+    public Synchronizer(HostageDBOpenHelper dbh){
+        super();
+        this.dbh = dbh;
+    }
+
+    public void pullNetworks(ServerSocket serverSocket){
+        ArrayList<String> myNetworks = this.dbh.getAllBSSIDS();
+
+        ArrayList<NetworkRecord> others = this.getOtherNetworkInformation(serverSocket, myNetworks);
+        if (others != null && others.size() > 0){
+            this.dbh.updateNetworkInformation(others);
+        }
+    }
+
+    public void pullNewDevices(ServerSocket serverSocket){
+        ArrayList<String> myDevices = this.dbh.getAllDevicesIds();
+        ArrayList<String> otherDeviceIds = this.getOtherDevies(serverSocket, myDevices);
+
+        ArrayList<SyncDevice> otherDevices = new ArrayList<SyncDevice>();
+
+        for (String deviceId : otherDeviceIds){
+            SyncDevice device = new SyncDevice();
+            device.setDeviceID(deviceId);
+            device.setHighest_attack_id(-1);
+            device.setLast_sync_timestamp(0);
+            otherDevices.add(device);
+        }
+
+        if (otherDevices != null && otherDevices.size() > 0)
+            this.dbh.updateSyncDevices(otherDevices);
+
+    }
+
+    public void pullAttacks(ServerSocket serverSocket){
+        ArrayList<SyncDevice> myState = this.dbh.getSyncDevices();
+
+        ArrayList<SyncRecord> updates = this.getChanges(serverSocket, myState);
+
+        if (updates != null && updates.size() > 0)
+            this.dbh.insertSyncRecords(updates);
+    }
+
+    public void pushNetworkInformation(ServerSocket serverSocket){
+
+        ArrayList<String> otherIDs = null;
+
+
+        if (otherIDs != null){
+            ArrayList<String> missingIds = this.dbh.getMissingDeviceIds(otherIDs);
+            this.sendMissingDeviceIds(serverSocket, missingIds);
+        }
+    }
+
+    public void pushUnsyncedRecords(ServerSocket serverSocket){
+
+        ArrayList<SyncDevice> otherDeviceState = null;
+
+        if (otherDeviceState != null){
+            ArrayList<SyncRecord> unsynced = this.dbh.getUnsyncedAttacksFor(otherDeviceState, false);
+            this.sendUnsyncedRecords(serverSocket, unsynced);
+        }
+    }
+
+    public void pushDeviceIds(ServerSocket serverSocket){
+        ArrayList<String> otherBSSIDs = null;
+
+
+        if (otherBSSIDs != null){
+            ArrayList<NetworkRecord> missings = this.dbh.getMissingNetworkRecords(otherBSSIDs);
+            this.sendMissingNetworkRecords(serverSocket, missings);
+        }
+    }
+
+    private ArrayList<String> getOtherDevies(ServerSocket serverSocket, ArrayList<String> ownDevices){
+
+        return null;
+    }
+
+    private ArrayList<NetworkRecord> getOtherNetworkInformation(ServerSocket serverSocket, List<String> records){
+
+        return null;
+    }
+
+    private ArrayList<SyncRecord> getChanges(ServerSocket serverSocket, ArrayList<SyncDevice> ownState){
+
+        return null;
+    }
+
+
+    private void sendMissingNetworkRecords(ServerSocket serverSocket, ArrayList<NetworkRecord> m){
+
+    }
+
+    private void sendMissingDeviceIds(ServerSocket serverSocket, ArrayList<String> missingIds){
+
+    }
+
+    private void sendUnsyncedRecords(ServerSocket serverSocket, ArrayList<SyncRecord> unsynced){
+
+    }
+
+
+}

src/de/tudarmstadt/informatik/hostage/sync/bluetooth/CommunicationThread.java

@@ -67,7 +67,7 @@ public class CommunicationThread extends Thread {
 
 	@Override
 	public void run() {	
-		HashMap<String, Long> devices = mdbh.getSyncDevices();
+		HashMap<String, Long> devices = mdbh.getSyncDeviceHashMap();
 		write(new SyncMessage(SyncMessage.SYNC_REQUEST, devices));
 		// Keep listening to the InputStream until an exception occurs
 		while (true) {
@@ -95,7 +95,7 @@ public class CommunicationThread extends Thread {
 		switch(message.getMessage_code()){
 			case SyncMessage.SYNC_REQUEST:
 				HashMap<String, Long> devices_remote = (HashMap<String, Long>) message.getPayload();
-				HashMap<String, Long> devices_local = mdbh.getSyncDevices();
+				HashMap<String, Long> devices_local = mdbh.getSyncDeviceHashMap();
 				ArrayList<SyncInfoRecord> syncInfo = mdbh.getSyncInfo();
 
 				long tracing_timestamp = 0;

src/de/tudarmstadt/informatik/hostage/sync/nfc/NFCSyncActivity.java

@@ -110,7 +110,7 @@ public class NFCSyncActivity extends Activity implements CreateNdefMessageCallba
 		// Get Networkdata
 		HostageDBOpenHelper dbh = new HostageDBOpenHelper(this);
 		ArrayList<NetworkRecord> localNetworkInformation = dbh.getNetworkInformation();
-		HashMap<String, Long> devices_local = dbh.getSyncDevices();
+		HashMap<String, Long> devices_local = dbh.getSyncDeviceHashMap();
 		ArrayList<SyncInfoRecord> syncInfo = dbh.getSyncInfo();
 		
 		NdefMessage msg = null;
@@ -191,7 +191,7 @@ public class NFCSyncActivity extends Activity implements CreateNdefMessageCallba
 
 			ArrayList<NetworkRecord> remoteNetworkInformation = (ArrayList<NetworkRecord>) deserialize(msg.getRecords()[0].getPayload());
 			HashMap<String, Long> devices_remote = (HashMap<String, Long>) deserialize(msg.getRecords()[1].getPayload());
-			HashMap<String, Long> devices_local = dbh.getSyncDevices();
+			HashMap<String, Long> devices_local = dbh.getSyncDeviceHashMap();
 			ArrayList<SyncInfoRecord> syncInfo = (ArrayList<SyncInfoRecord>) deserialize(msg.getRecords()[2].getPayload());
 			
 			long tracing_timestamp = 0;

src/de/tudarmstadt/informatik/hostage/ui/fragment/RecordOverviewFragment.java

@@ -1344,6 +1344,7 @@ public class RecordOverviewFragment extends UpNavigatibleFragment implements Che
 
         ArrayList<NetworkRecord> networkRecords = new ArrayList<NetworkRecord>();
         ArrayList<AttackRecord> attackRecords = new ArrayList<AttackRecord>();
+        ArrayList<MessageRecord> messageRecords = new ArrayList<MessageRecord>();
 
 
         for (int numOfNetworks = 0; numOfNetworks < createNetworks; numOfNetworks++){
@@ -1394,8 +1395,8 @@ public class RecordOverviewFragment extends UpNavigatibleFragment implements Che
 
                 // MESSAGE PER ATTACK
                 for (int messageID = attackId; messageID < attackId + numRecordsPerAttack; messageID++) {
-                    MessageRecord message = new MessageRecord();
-                    message.setId(messageID);
+                    MessageRecord message = new MessageRecord(true);
+                    //message.setId(messageID);
                     message.setAttack_id(attackId);
 
                     // GO BACK IN TIME
@@ -1409,7 +1410,8 @@ public class RecordOverviewFragment extends UpNavigatibleFragment implements Che
                     }
                     message.setPacket("");
 
-                    dbh.addMessageRecord(message);
+                    //dbh.addMessageRecord(message);
+                    messageRecords.add(message);
                 }
 
                 attackId+=numRecordsPerAttack;
@@ -1419,7 +1421,7 @@ public class RecordOverviewFragment extends UpNavigatibleFragment implements Che
 
         dbh.updateNetworkInformation(networkRecords);
         dbh.insertAttackRecords(attackRecords);
-
+        dbh.insertMessageRecords(messageRecords);
 //        int countAllLogs = dbh.getAllRecords().size();
 //        int countRecords = dbh.getRecordCount();
 //        int countAttacks = dbh.getAttackCount();