tabbing
[iotcloud.git] / version2 / src / C / CloudComm.cc
index 1a60c7ed55dae48d073788b9f637e5cb33f03cb8..c5da91a1b5d43166373797fc5c1af215aa300450 100644 (file)
-
-
-
+#include "CloudComm.h"
 
 /**
- * This class provides a communication API to the webserver.  It also
- * validates the HMACs on the slots and handles encryption.
- * @author Brian Demsky <bdemsky@uci.edu>
- * @version 1.0
+ * Empty Constructor needed for child class.
  */
+CloudComm::CloudComm() :
+       baseurl(NULL),
+       key(NULL),
+       mac(NULL),
+       password(NULL),
+       random(NULL),
+       salt(NULL),
+       table(NULL),
+       listeningPort(-1),
+       localServerThread(NULL),
+       doEnd(false)
+       timer(TimingSingleton.getInstance())
+{
+}
 
-
-class CloudComm {
-       static final int SALT_SIZE = 8;
-       static final int TIMEOUT_MILLIS = 5000; // 100
-       static final int IV_SIZE = 16;
-
-       /** Sets the size for the HMAC. */
-       static final int HMAC_SIZE = 32;
-
-       String baseurl;
-       SecretKeySpec key;
-       Mac mac;
-       String password;
-       SecureRandom random;
-       char salt[];
-       Table table;
-       int listeningPort = -1;
-       Thread localServerThread = NULL;
-       bool doEnd = false;
-
-       TimingSingleton timer = NULL;
-
-       /**
-        * Empty Constructor needed for child class.
-        */
-       CloudComm() {
-               timer = TimingSingleton.getInstance();
-       }
-
-       /**
-        * Constructor for actual use. Takes in the url and password.
-        */
-       CloudComm(Table _table,  String _baseurl, String _password, int _listeningPort) {
-               timer = TimingSingleton.getInstance();
-               this.table = _table;
-               this.baseurl = _baseurl;
-               this.password = _password;
-               this.random = new SecureRandom();
-               this.listeningPort = _listeningPort;
-
-               if (this.listeningPort > 0) {
-                       localServerThread = new Thread(new Runnable() {
-                               void run() {
-                                       localServerWorkerFunction();
-                               }
-                       });
-                       localServerThread.start();
-               }
+/**
+ * Constructor for actual use. Takes in the url and password.
+ */
+CloudComm::CloudComm(Table _table,  String _baseurl, String _password, int _listeningPort) :
+       baseurl(_baseurl),
+       key(NULL),
+       mac(NULL),
+       password(_password),
+       random(new SecureRandom()),
+       salt(NULL),
+       table(_table),
+       listeningPort(_listeningPort),
+       localServerThread(NULL),
+       doEnd(false)
+       timer(TimingSingleton.getInstance()) {
+       if (this.listeningPort > 0) {
+               localServerThread = new Thread(new Runnable() {
+                       void run() {
+                               localServerWorkerFunction();
+                       }
+               });
+               localServerThread.start();
        }
+}
 
-       /**
-        * Generates Key from password.
-        */
-       SecretKeySpec initKey() {
-               try {
-                       PBEKeySpec keyspec = new PBEKeySpec(password.toCharArray(),
-                                                           salt,
-                                                           65536,
-                                                           128);
-                       SecretKey tmpkey = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256").generateSecret(keyspec);
-                       return new SecretKeySpec(tmpkey.getEncoded(), "AES");
-               } catch (Exception e) {
-                       e.printStackTrace();
-                       throw new Error("Failed generating key.");
-               }
+/**
+ * Generates Key from password.
+ */
+SecretKeySpec *CloudComm::initKey() {
+       try {
+               PBEKeySpec keyspec = new PBEKeySpec(password.toCharArray(),
+                                                                                                                                                               salt,
+                                                                                                                                                               65536,
+                                                                                                                                                               128);
+               SecretKey tmpkey = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256").generateSecret(keyspec);
+               return new SecretKeySpec(tmpkey.getEncoded(), "AES");
+       } catch (Exception e) {
+               e.printStackTrace();
+               throw new Error("Failed generating key.");
        }
+}
 
-       /**
-        * Inits all the security stuff
-        */
-       void initSecurity() throws ServerException {
-               // try to get the salt and if one does not exist set one
-               if (!getSalt()) {
-                       //Set the salt
-                       setSalt();
-               }
+/**
+ * Inits all the security stuff
+ */
 
-               initCrypt();
+void CloudComm::initSecurity() {
+       // try to get the salt and if one does not exist set one
+       if (!getSalt()) {
+               //Set the salt
+               setSalt();
        }
 
-       /**
-        * Inits the HMAC generator.
-        */
-       void initCrypt() {
+       initCrypt();
+}
 
-               if (password == NULL) {
-                       return;
-               }
+/**
+ * Inits the HMAC generator.
+ */
+void CloudComm::initCrypt() {
 
-               try {
-                       key = initKey();
-                       password = NULL; // drop password
-                       mac = Mac.getInstance("HmacSHA256");
-                       mac.init(key);
-               } catch (Exception e) {
-                       e.printStackTrace();
-                       throw new Error("Failed To Initialize Ciphers");
-               }
+       if (password == NULL) {
+               return;
        }
 
-       /*
-        * Builds the URL for the given request.
-        */
-       URL buildRequest(bool isput, int64_t sequencenumber, int64_t maxentries) throws IOException {
-               String reqstring = isput ? "req=putslot" : "req=getslot";
-               String urlstr = baseurl + "?" + reqstring + "&seq=" + sequencenumber;
-               if (maxentries != 0)
-                       urlstr += "&max=" + maxentries;
-               return new URL(urlstr);
+       try {
+               key = initKey();
+               password = NULL;// drop password
+               mac = Mac.getInstance("HmacSHA256");
+               mac.init(key);
+       } catch (Exception e) {
+               e.printStackTrace();
+               throw new Error("Failed To Initialize Ciphers");
        }
+}
 
-       void setSalt() throws ServerException {
-
-               if (salt != NULL) {
-                       // Salt already sent to server so dont set it again
-                       return;
-               }
-
-               try {
-                       char[] saltTmp = new char[SALT_SIZE];
-                       random.nextBytes(saltTmp);
-
-                       for (int i = 0; i < SALT_SIZE; i++) {
-                               System.out.println((int)saltTmp[i] & 255);
-                       }
+/*
+ * Builds the URL for the given request.
+ */
+URL *CloudComm::buildRequest(bool isput, int64_t sequencenumber, int64_t maxentries) {
+       IoTString *reqstring = isput ? "req=putslot" : "req=getslot";
+       IoTString *urlstr = baseurl + "?" + reqstring + "&seq=" + sequencenumber;
+       if (maxentries != 0)
+               urlstr += "&max=" + maxentries;
+       return new URL(urlstr);
+}
 
+void CloudComm::setSalt() {
 
-                       URL url = new URL(baseurl + "?req=setsalt");
+       if (salt != NULL) {
+               // Salt already sent to server so dont set it again
+               return;
+       }
 
-                       timer.startTime();
-                       URLConnection con = url.openConnection();
-                       HttpURLConnection http = (HttpURLConnection) con;
+       try {
+               char[] saltTmp = new char[SALT_SIZE];
+               random.nextBytes(saltTmp);
 
-                       http.setRequestMethod("POST");
-                       http.setFixedLengthStreamingMode(saltTmp.length);
-                       http.setDoOutput(true);
-                       http.setConnectTimeout(TIMEOUT_MILLIS);
+               for (int i = 0; i < SALT_SIZE; i++) {
+                       System.out.println((int)saltTmp[i] & 255);
+               }
 
 
-                       http.connect();
+               URL url = new URL(baseurl + "?req=setsalt");
 
-                       OutputStream os = http.getOutputStream();
-                       os.write(saltTmp);
-                       os.flush();
+               timer.startTime();
+               URLConnection con = url.openConnection();
+               HttpURLConnection http = (HttpURLConnection) con;
 
-                       int responsecode = http.getResponseCode();
-                       if (responsecode != HttpURLConnection.HTTP_OK) {
-                               // TODO: Remove this print
-                               System.out.println(responsecode);
-                               throw new Error("Invalid response");
-                       }
+               http.setRequestMethod("POST");
+               http.setFixedLengthStreamingMode(saltTmp.length);
+               http.setDoOutput(true);
+               http.setConnectTimeout(TIMEOUT_MILLIS);
 
-                       timer.endTime();
 
-                       salt = saltTmp;
-               } catch (Exception e) {
-                       // e.printStackTrace();
-                       timer.endTime();
-                       throw new ServerException("Failed setting salt", ServerException.TypeConnectTimeout);
-               }
-       }
+               http.connect();
 
-       bool getSalt() throws ServerException {
-               URL url = NULL;
-               URLConnection con = NULL;
-               HttpURLConnection http = NULL;
+               OutputStream os = http.getOutputStream();
+               os.write(saltTmp);
+               os.flush();
 
-               try {
-                       url = new URL(baseurl + "?req=getsalt");
-               } catch (Exception e) {
-                       // e.printStackTrace();
-                       throw new Error("getSlot failed");
+               int responsecode = http.getResponseCode();
+               if (responsecode != HttpURLConnection.HTTP_OK) {
+                       // TODO: Remove this print
+                       System.out.println(responsecode);
+                       throw new Error("Invalid response");
                }
-               try {
 
-                       timer.startTime();
-                       con = url.openConnection();
-                       http = (HttpURLConnection) con;
-                       http.setRequestMethod("POST");
-                       http.setConnectTimeout(TIMEOUT_MILLIS);
-                       http.setReadTimeout(TIMEOUT_MILLIS);
+               timer.endTime();
 
+               salt = saltTmp;
+       } catch (Exception e) {
+               // e.printStackTrace();
+               timer.endTime();
+               throw new ServerException("Failed setting salt", ServerException.TypeConnectTimeout);
+       }
+}
 
-                       http.connect();
-                       timer.endTime();
-               } catch (SocketTimeoutException e) {
-                       timer.endTime();
-                       throw new ServerException("getSalt failed", ServerException.TypeConnectTimeout);
-               } catch (Exception e) {
-                       // e.printStackTrace();
-                       throw new Error("getSlot failed");
-               }
+bool CloudComm::getSalt() {
+       URL *url = NULL;
+       URLConnection *con = NULL;
+       HttpURLConnection *http = NULL;
 
-               try {
+       try {
+               url = new URL(baseurl + "?req=getsalt");
+       } catch (Exception e) {
+               // e.printStackTrace();
+               throw new Error("getSlot failed");
+       }
+       try {
+
+               timer.startTime();
+               con = url.openConnection();
+               http = (HttpURLConnection) con;
+               http.setRequestMethod("POST");
+               http.setConnectTimeout(TIMEOUT_MILLIS);
+               http.setReadTimeout(TIMEOUT_MILLIS);
+
+
+               http.connect();
+               timer.endTime();
+       } catch (SocketTimeoutException e) {
+               timer.endTime();
+               throw new ServerException("getSalt failed", ServerException.TypeConnectTimeout);
+       } catch (Exception e) {
+               // e.printStackTrace();
+               throw new Error("getSlot failed");
+       }
 
-                       timer.startTime();
+       try {
 
-                       int responsecode = http.getResponseCode();
-                       if (responsecode != HttpURLConnection.HTTP_OK) {
-                               // TODO: Remove this print
-                               // System.out.println(responsecode);
-                               throw new Error("Invalid response");
-                       }
+               timer.startTime();
 
-                       InputStream is = http.getInputStream();
-                       if (is.available() > 0) {
-                               DataInputStream dis = new DataInputStream(is);
-                               int salt_length = dis.readInt();
-                               char [] tmp = new char[salt_length];
-                               dis.readFully(tmp);
-                               salt = tmp;
-                               timer.endTime();
+               int responsecode = http.getResponseCode();
+               if (responsecode != HttpURLConnection.HTTP_OK) {
+                       // TODO: Remove this print
+                       // System.out.println(responsecode);
+                       throw new Error("Invalid response");
+               }
 
-                               return true;
-                       } else {
-                               timer.endTime();
+               InputStream is = http.getInputStream();
+               if (is.available() > 0) {
+                       DataInputStream dis = new DataInputStream(is);
+                       int salt_length = dis.readInt();
+                       char [] tmp = new char[salt_length];
+                       dis.readFully(tmp);
+                       salt = tmp;
+                       timer.endTime();
 
-                               return false;
-                       }
-               } catch (SocketTimeoutException e) {
+                       return true;
+               } else {
                        timer.endTime();
 
-                       throw new ServerException("getSalt failed", ServerException.TypeInputTimeout);
-               } catch (Exception e) {
-                       // e.printStackTrace();
-                       throw new Error("getSlot failed");
+                       return false;
                }
-       }
-
-       char[] createIV(int64_t machineId, int64_t localSequenceNumber) {
-               ByteBuffer buffer = ByteBuffer.allocate(IV_SIZE);
-               buffer.putLong(machineId);
-               int64_t localSequenceNumberShifted = localSequenceNumber << 16;
-               buffer.putLong(localSequenceNumberShifted);
-               return buffer.array();
+       } catch (SocketTimeoutException e) {
+               timer.endTime();
 
+               throw new ServerException("getSalt failed", ServerException.TypeInputTimeout);
+       } catch (Exception e) {
+               // e.printStackTrace();
+               throw new Error("getSlot failed");
        }
+}
 
-       char[] encryptSlotAndPrependIV(char[] rawData, char[] ivBytes) {
-               try {
-                       IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);
-                       Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding");
-                       cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
+Array<char> *CloudComm::createIV(int64_t machineId, int64_t localSequenceNumber) {
+       ByteBuffer buffer = ByteBuffer.allocate(IV_SIZE);
+       buffer.putLong(machineId);
+       int64_t localSequenceNumberShifted = localSequenceNumber << 16;
+       buffer.putLong(localSequenceNumberShifted);
+       return buffer.array();
+}
 
-                       char[] encryptedBytes = cipher.doFinal(rawData);
+Array<char> *CloudComm::encryptSlotAndPrependIV(Array<char> *rawData, Array<char> *ivBytes) {
+       try {
+               IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);
+               Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding");
+               cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
 
-                       char[] chars = new char[encryptedBytes.length + IV_SIZE];
-                       System.arraycopy(ivBytes, 0, chars, 0, ivBytes.length);
-                       System.arraycopy(encryptedBytes, 0, chars, IV_SIZE, encryptedBytes.length);
+               char[] encryptedBytes = cipher.doFinal(rawData);
 
-                       return chars;
+               char[] chars = new char[encryptedBytes.length + IV_SIZE];
+               System.arraycopy(ivBytes, 0, chars, 0, ivBytes.length);
+               System.arraycopy(encryptedBytes, 0, chars, IV_SIZE, encryptedBytes.length);
 
-               } catch (Exception e) {
-                       e.printStackTrace();
-                       throw new Error("Failed To Encrypt");
-               }
+               return chars;
+
+       } catch (Exception e) {
+               e.printStackTrace();
+               throw new Error("Failed To Encrypt");
        }
+}
 
 
-       char[] stripIVAndDecryptSlot(char[] rawData) {
-               try {
-                       char[] ivBytes = new char[IV_SIZE];
-                       char[] encryptedBytes = new char[rawData.length - IV_SIZE];
-                       System.arraycopy(rawData, 0, ivBytes, 0, IV_SIZE);
-                       System.arraycopy(rawData, IV_SIZE, encryptedBytes, 0 , encryptedBytes.length);
+Array<char> *CloudComm::stripIVAndDecryptSlot(Array<char> *rawData) {
+       try {
+               Array<char> *ivBytes = new char[IV_SIZE];
+               Array<char> *encryptedBytes = new char[rawData.length - IV_SIZE];
+               System.arraycopy(rawData, 0, ivBytes, 0, IV_SIZE);
+               System.arraycopy(rawData, IV_SIZE, encryptedBytes, 0, encryptedBytes.length);
 
-                       IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);
+               IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);
 
-                       Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding");
-                       cipher.init(Cipher.DECRYPT_MODE, key, ivSpec);
-                       return cipher.doFinal(encryptedBytes);
+               Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding");
+               cipher.init(Cipher.DECRYPT_MODE, key, ivSpec);
+               return cipher.doFinal(encryptedBytes);
 
-               } catch (Exception e) {
-                       e.printStackTrace();
-                       throw new Error("Failed To Decrypt");
-               }
+       } catch (Exception e) {
+               e.printStackTrace();
+               throw new Error("Failed To Decrypt");
        }
+}
 
 
-       /*
       * API for putting a slot into the queue.  Returns NULL on success.
       * On failure, the server will send slots with newer sequence
       * numbers.
       */
-       Slot[] putSlot(Slot slot, int max) throws ServerException {
-               URL url = NULL;
-               URLConnection con = NULL;
-               HttpURLConnection http = NULL;
+/*
+ * API for putting a slot into the queue.  Returns NULL on success.
+ * On failure, the server will send slots with newer sequence
+ * numbers.
+ */
+Array<Slot *> *CloudComm::putSlot(Slot *slot, int max) {
+       URL url = NULL;
+       URLConnection con = NULL;
+       HttpURLConnection http = NULL;
 
-               try {
-                       if (salt == NULL) {
-                               if (!getSalt()) {
-                                       throw new ServerException("putSlot failed", ServerException.TypeSalt);
-                               }
-                               initCrypt();
+       try {
+               if (salt == NULL) {
+                       if (!getSalt()) {
+                               throw new ServerException("putSlot failed", ServerException.TypeSalt);
                        }
+                       initCrypt();
+               }
 
-                       int64_t sequencenumber = slot.getSequenceNumber();
-                       char[] slotBytes = slot.encode(mac);
-                       // slotBytes = encryptCipher.doFinal(slotBytes);
+               int64_t sequencenumber = slot.getSequenceNumber();
+               char[] slotBytes = slot.encode(mac);
+               // slotBytes = encryptCipher.doFinal(slotBytes);
 
-                       // char[] iVBytes = slot.getSlotCryptIV();
+               // char[] iVBytes = slot.getSlotCryptIV();
 
-                       // char[] chars = new char[slotBytes.length + IV_SIZE];
-                       // System.arraycopy(iVBytes, 0, chars, 0, iVBytes.length);
-                       // System.arraycopy(slotBytes, 0, chars, IV_SIZE, slotBytes.length);
+               // char[] chars = new char[slotBytes.length + IV_SIZE];
+               // System.arraycopy(iVBytes, 0, chars, 0, iVBytes.length);
+               // System.arraycopy(slotBytes, 0, chars, IV_SIZE, slotBytes.length);
 
 
-                       char[] chars = encryptSlotAndPrependIV(slotBytes, slot.getSlotCryptIV());
+               char[] chars = encryptSlotAndPrependIV(slotBytes, slot.getSlotCryptIV());
 
-                       url = buildRequest(true, sequencenumber, max);
+               url = buildRequest(true, sequencenumber, max);
 
-                       timer.startTime();
-                       con = url.openConnection();
-                       http = (HttpURLConnection) con;
+               timer.startTime();
+               con = url.openConnection();
+               http = (HttpURLConnection) con;
 
-                       http.setRequestMethod("POST");
-                       http.setFixedLengthStreamingMode(chars.length);
-                       http.setDoOutput(true);
-                       http.setConnectTimeout(TIMEOUT_MILLIS);
-                       http.setReadTimeout(TIMEOUT_MILLIS);
-                       http.connect();
+               http.setRequestMethod("POST");
+               http.setFixedLengthStreamingMode(chars.length);
+               http.setDoOutput(true);
+               http.setConnectTimeout(TIMEOUT_MILLIS);
+               http.setReadTimeout(TIMEOUT_MILLIS);
+               http.connect();
 
-                       OutputStream os = http.getOutputStream();
-                       os.write(chars);
-                       os.flush();
+               OutputStream os = http.getOutputStream();
+               os.write(chars);
+               os.flush();
 
-                       timer.endTime();
+               timer.endTime();
 
 
-                       // System.out.println("Bytes Sent: " + chars.length);
-               } catch (ServerException e) {
-                       timer.endTime();
+               // System.out.println("Bytes Sent: " + chars.length);
+       } catch (ServerException e) {
+               timer.endTime();
 
-                       throw e;
-               } catch (SocketTimeoutException e) {
-                       timer.endTime();
-
-                       throw new ServerException("putSlot failed", ServerException.TypeConnectTimeout);
-               } catch (Exception e) {
-                       // e.printStackTrace();
-                       throw new Error("putSlot failed");
-               }
+               throw e;
+       } catch (SocketTimeoutException e) {
+               timer.endTime();
 
+               throw new ServerException("putSlot failed", ServerException.TypeConnectTimeout);
+       } catch (Exception e) {
+               // e.printStackTrace();
+               throw new Error("putSlot failed");
+       }
 
 
-               try {
-                       timer.startTime();
-                       InputStream is = http.getInputStream();
-                       DataInputStream dis = new DataInputStream(is);
-                       char[] resptype = new char[7];
-                       dis.readFully(resptype);
-                       timer.endTime();
 
-                       if (Arrays.equals(resptype, "getslot".getBytes())) {
-                               return processSlots(dis);
-                       } else if (Arrays.equals(resptype, "putslot".getBytes())) {
-                               return NULL;
-                       } else
-                               throw new Error("Bad response to putslot");
+       try {
+               timer.startTime();
+               InputStream is = http.getInputStream();
+               DataInputStream dis = new DataInputStream(is);
+               char[] resptype = new char[7];
+               dis.readFully(resptype);
+               timer.endTime();
 
-               } catch (SocketTimeoutException e) {
-                       timer.endTime();
-                       throw new ServerException("putSlot failed", ServerException.TypeInputTimeout);
-               } catch (Exception e) {
-                       // e.printStackTrace();
-                       throw new Error("putSlot failed");
-               }
+               if (Arrays.equals(resptype, "getslot".getBytes())) {
+                       return processSlots(dis);
+               } else if (Arrays.equals(resptype, "putslot".getBytes())) {
+                       return NULL;
+               } else
+                       throw new Error("Bad response to putslot");
+
+       } catch (SocketTimeoutException e) {
+               timer.endTime();
+               throw new ServerException("putSlot failed", ServerException.TypeInputTimeout);
+       } catch (Exception e) {
+               // e.printStackTrace();
+               throw new Error("putSlot failed");
        }
+}
 
-       /**
       * Request the server to send all slots with the given
       * sequencenumber or newer.
       */
-       Slot[] getSlots(int64_t sequencenumber) throws ServerException {
-               URL url = NULL;
-               URLConnection con = NULL;
-               HttpURLConnection http = NULL;
+/**
+ * Request the server to send all slots with the given
+ * sequencenumber or newer.
+ */
+Array<Slot *> *CloudComm::getSlots(int64_t sequencenumber) {
+       URL url = NULL;
+       URLConnection con = NULL;
+       HttpURLConnection http = NULL;
 
-               try {
-                       if (salt == NULL) {
-                               if (!getSalt()) {
-                                       throw new ServerException("getSlots failed", ServerException.TypeSalt);
-                               }
-                               initCrypt();
+       try {
+               if (salt == NULL) {
+                       if (!getSalt()) {
+                               throw new ServerException("getSlots failed", ServerException.TypeSalt);
                        }
+                       initCrypt();
+               }
 
-                       url = buildRequest(false, sequencenumber, 0);
-                       timer.startTime();
-                       con = url.openConnection();
-                       http = (HttpURLConnection) con;
-                       http.setRequestMethod("POST");
-                       http.setConnectTimeout(TIMEOUT_MILLIS);
-                       http.setReadTimeout(TIMEOUT_MILLIS);
+               url = buildRequest(false, sequencenumber, 0);
+               timer.startTime();
+               con = url.openConnection();
+               http = (HttpURLConnection) con;
+               http.setRequestMethod("POST");
+               http.setConnectTimeout(TIMEOUT_MILLIS);
+               http.setReadTimeout(TIMEOUT_MILLIS);
 
 
 
-                       http.connect();
-                       timer.endTime();
+               http.connect();
+               timer.endTime();
 
-               } catch (SocketTimeoutException e) {
-                       timer.endTime();
+       } catch (SocketTimeoutException e) {
+               timer.endTime();
 
-                       throw new ServerException("getSlots failed", ServerException.TypeConnectTimeout);
-               } catch (ServerException e) {
-                       timer.endTime();
+               throw new ServerException("getSlots failed", ServerException.TypeConnectTimeout);
+       } catch (ServerException e) {
+               timer.endTime();
 
-                       throw e;
-               } catch (Exception e) {
-                       // e.printStackTrace();
-                       throw new Error("getSlots failed");
-               }
+               throw e;
+       } catch (Exception e) {
+               // e.printStackTrace();
+               throw new Error("getSlots failed");
+       }
 
-               try {
+       try {
 
-                       timer.startTime();
-                       InputStream is = http.getInputStream();
-                       DataInputStream dis = new DataInputStream(is);
-                       char[] resptype = new char[7];
+               timer.startTime();
+               InputStream is = http.getInputStream();
+               DataInputStream dis = new DataInputStream(is);
+               char[] resptype = new char[7];
 
-                       dis.readFully(resptype);
-                       timer.endTime();
+               dis.readFully(resptype);
+               timer.endTime();
 
-                       if (!Arrays.equals(resptype, "getslot".getBytes()))
-                               throw new Error("Bad Response: " + new String(resptype));
+               if (!Arrays.equals(resptype, "getslot".getBytes()))
+                       throw new Error("Bad Response: " + new String(resptype));
 
-                       return processSlots(dis);
-               } catch (SocketTimeoutException e) {
-                       timer.endTime();
+               return processSlots(dis);
+       } catch (SocketTimeoutException e) {
+               timer.endTime();
 
-                       throw new ServerException("getSlots failed", ServerException.TypeInputTimeout);
-               } catch (Exception e) {
-                       // e.printStackTrace();
-                       throw new Error("getSlots failed");
-               }
+               throw new ServerException("getSlots failed", ServerException.TypeInputTimeout);
+       } catch (Exception e) {
+               // e.printStackTrace();
+               throw new Error("getSlots failed");
        }
+}
 
-       /**
       * Method that actually handles building Slot objects from the
       * server response.  Shared by both putSlot and getSlots.
       */
-       Slot[] processSlots(DataInputStream dis) throws Exception {
-               int numberofslots = dis.readInt();
-               int[] sizesofslots = new int[numberofslots];
+/**
+ * Method that actually handles building Slot objects from the
+ * server response.  Shared by both putSlot and getSlots.
+ */
+Array<Slot *> *CloudComm::processSlots(DataInputStream dis) {
+       int numberofslots = dis.readInt();
+       int[] sizesofslots = new int[numberofslots];
 
-               Slot[] slots = new Slot[numberofslots];
-               for (int i = 0; i < numberofslots; i++)
-                       sizesofslots[i] = dis.readInt();
+       Slot[] slots = new Slot[numberofslots];
+       for (int i = 0; i < numberofslots; i++)
+               sizesofslots[i] = dis.readInt();
 
-               for (int i = 0; i < numberofslots; i++) {
+       for (int i = 0; i < numberofslots; i++) {
 
-                       char[] rawData = new char[sizesofslots[i]];
-                       dis.readFully(rawData);
+               char[] rawData = new char[sizesofslots[i]];
+               dis.readFully(rawData);
 
 
-                       // char[] data = new char[rawData.length - IV_SIZE];
-                       // System.arraycopy(rawData, IV_SIZE, data, 0, data.length);
+               // char[] data = new char[rawData.length - IV_SIZE];
+               // System.arraycopy(rawData, IV_SIZE, data, 0, data.length);
 
 
-                       char[] data = stripIVAndDecryptSlot(rawData);
+               char[] data = stripIVAndDecryptSlot(rawData);
 
-                       // data = decryptCipher.doFinal(data);
+               // data = decryptCipher.doFinal(data);
 
-                       slots[i] = Slot.decode(table, data, mac);
-               }
-               dis.close();
-               return slots;
+               slots[i] = Slot.decode(table, data, mac);
        }
+       dis.close();
+       return slots;
+}
 
-       char[] sendLocalData(char[] sendData, int64_t localSequenceNumber, String host, int port) {
+Array<char> *sendLocalData(Array<char> *sendData, int64_t localSequenceNumber, String host, int port) {
 
-               if (salt == NULL) {
-                       return NULL;
-               }
-               try {
-                       System.out.println("Passing Locally");
+       if (salt == NULL) {
+               return NULL;
+       }
+       try {
+               System.out.println("Passing Locally");
 
-                       mac.update(sendData);
-                       char[] genmac = mac.doFinal();
-                       char[] totalData = new char[sendData.length + genmac.length];
-                       System.arraycopy(sendData, 0, totalData, 0, sendData.length);
-                       System.arraycopy(genmac, 0, totalData, sendData.length, genmac.length);
+               mac.update(sendData);
+               char[] genmac = mac.doFinal();
+               char[] totalData = new char[sendData.length + genmac.length];
+               System.arraycopy(sendData, 0, totalData, 0, sendData.length);
+               System.arraycopy(genmac, 0, totalData, sendData.length, genmac.length);
 
-                       // Encrypt the data for sending
-                       // char[] encryptedData = encryptCipher.doFinal(totalData);
-                       // char[] encryptedData = encryptCipher.doFinal(totalData);
-                       char[] iv = createIV(table.getMachineId(), table.getLocalSequenceNumber());
-                       char[] encryptedData = encryptSlotAndPrependIV(totalData, iv);
+               // Encrypt the data for sending
+               // char[] encryptedData = encryptCipher.doFinal(totalData);
+               // char[] encryptedData = encryptCipher.doFinal(totalData);
+               char[] iv = createIV(table.getMachineId(), table.getLocalSequenceNumber());
+               char[] encryptedData = encryptSlotAndPrependIV(totalData, iv);
 
-                       // Open a TCP socket connection to a local device
-                       Socket socket = new Socket(host, port);
-                       socket.setReuseAddress(true);
-                       DataOutputStream output = new DataOutputStream(socket.getOutputStream());
-                       DataInputStream input = new DataInputStream(socket.getInputStream());
+               // Open a TCP socket connection to a local device
+               Socket socket = new Socket(host, port);
+               socket.setReuseAddress(true);
+               DataOutputStream output = new DataOutputStream(socket.getOutputStream());
+               DataInputStream input = new DataInputStream(socket.getInputStream());
 
 
-                       timer.startTime();
-                       // Send data to output (length of data, the data)
-                       output.writeInt(encryptedData.length);
-                       output.write(encryptedData, 0, encryptedData.length);
-                       output.flush();
+               timer.startTime();
+               // Send data to output (length of data, the data)
+               output.writeInt(encryptedData.length);
+               output.write(encryptedData, 0, encryptedData.length);
+               output.flush();
 
-                       int lengthOfReturnData = input.readInt();
-                       char[] returnData = new char[lengthOfReturnData];
-                       input.readFully(returnData);
+               int lengthOfReturnData = input.readInt();
+               char[] returnData = new char[lengthOfReturnData];
+               input.readFully(returnData);
 
-                       timer.endTime();
+               timer.endTime();
 
-                       // returnData = decryptCipher.doFinal(returnData);
-                       returnData = stripIVAndDecryptSlot(returnData);
-                       // returnData = decryptCipher.doFinal(returnData);
+               // returnData = decryptCipher.doFinal(returnData);
+               returnData = stripIVAndDecryptSlot(returnData);
+               // returnData = decryptCipher.doFinal(returnData);
 
-                       // We are done with this socket
-                       socket.close();
+               // We are done with this socket
+               socket.close();
 
-                       mac.update(returnData, 0, returnData.length - HMAC_SIZE);
-                       char[] realmac = mac.doFinal();
-                       char[] recmac = new char[HMAC_SIZE];
-                       System.arraycopy(returnData, returnData.length - realmac.length, recmac, 0, realmac.length);
+               mac.update(returnData, 0, returnData.length - HMAC_SIZE);
+               char[] realmac = mac.doFinal();
+               char[] recmac = new char[HMAC_SIZE];
+               System.arraycopy(returnData, returnData.length - realmac.length, recmac, 0, realmac.length);
 
-                       if (!Arrays.equals(recmac, realmac))
-                               throw new Error("Local Error: Invalid HMAC!  Potential Attack!");
+               if (!Arrays.equals(recmac, realmac))
+                       throw new Error("Local Error: Invalid HMAC!  Potential Attack!");
 
-                       char[] returnData2 = new char[lengthOfReturnData - recmac.length];
-                       System.arraycopy(returnData, 0, returnData2, 0, returnData2.length);
+               char[] returnData2 = new char[lengthOfReturnData - recmac.length];
+               System.arraycopy(returnData, 0, returnData2, 0, returnData2.length);
 
-                       return returnData2;
-               } catch (Exception e) {
-                       e.printStackTrace();
-                       // throw new Error("Local comms failure...");
-
-               }
+               return returnData2;
+       } catch (Exception e) {
+               e.printStackTrace();
+               // throw new Error("Local comms failure...");
 
-               return NULL;
        }
 
-       void localServerWorkerFunction() {
+       return NULL;
+}
 
-               ServerSocket inputSocket = NULL;
+void CloudComm::localServerWorkerFunction() {
 
-               try {
-                       // Local server socket
-                       inputSocket = new ServerSocket(listeningPort);
-                       inputSocket.setReuseAddress(true);
-                       inputSocket.setSoTimeout(TIMEOUT_MILLIS);
-               } catch (Exception e) {
-                       e.printStackTrace();
-                       throw new Error("Local server setup failure...");
-               }
+       ServerSocket inputSocket = NULL;
 
-               while (!doEnd) {
+       try {
+               // Local server socket
+               inputSocket = new ServerSocket(listeningPort);
+               inputSocket.setReuseAddress(true);
+               inputSocket.setSoTimeout(TIMEOUT_MILLIS);
+       } catch (Exception e) {
+               e.printStackTrace();
+               throw new Error("Local server setup failure...");
+       }
 
-                       try {
-                               // Accept incoming socket
-                               Socket socket = inputSocket.accept();
+       while (!doEnd) {
 
-                               DataInputStream input = new DataInputStream(socket.getInputStream());
-                               DataOutputStream output = new DataOutputStream(socket.getOutputStream());
+               try {
+                       // Accept incoming socket
+                       Socket socket = inputSocket.accept();
 
-                               // Get the encrypted data from the server
-                               int dataSize = input.readInt();
-                               char[] readData = new char[dataSize];
-                               input.readFully(readData);
+                       DataInputStream input = new DataInputStream(socket.getInputStream());
+                       DataOutputStream output = new DataOutputStream(socket.getOutputStream());
 
-                               timer.endTime();
+                       // Get the encrypted data from the server
+                       int dataSize = input.readInt();
+                       char[] readData = new char[dataSize];
+                       input.readFully(readData);
 
-                               // Decrypt the data
-                               // readData = decryptCipher.doFinal(readData);
-                               readData = stripIVAndDecryptSlot(readData);
+                       timer.endTime();
 
-                               mac.update(readData, 0, readData.length - HMAC_SIZE);
-                               char[] genmac = mac.doFinal();
-                               char[] recmac = new char[HMAC_SIZE];
-                               System.arraycopy(readData, readData.length - recmac.length, recmac, 0, recmac.length);
+                       // Decrypt the data
+                       // readData = decryptCipher.doFinal(readData);
+                       readData = stripIVAndDecryptSlot(readData);
 
-                               if (!Arrays.equals(recmac, genmac))
-                                       throw new Error("Local Error: Invalid HMAC!  Potential Attack!");
+                       mac.update(readData, 0, readData.length - HMAC_SIZE);
+                       char[] genmac = mac.doFinal();
+                       char[] recmac = new char[HMAC_SIZE];
+                       System.arraycopy(readData, readData.length - recmac.length, recmac, 0, recmac.length);
 
-                               char[] returnData = new char[readData.length - recmac.length];
-                               System.arraycopy(readData, 0, returnData, 0, returnData.length);
+                       if (!Arrays.equals(recmac, genmac))
+                               throw new Error("Local Error: Invalid HMAC!  Potential Attack!");
 
-                               // Process the data
-                               // char[] sendData = table.acceptDataFromLocal(readData);
-                               char[] sendData = table.acceptDataFromLocal(returnData);
+                       char[] returnData = new char[readData.length - recmac.length];
+                       System.arraycopy(readData, 0, returnData, 0, returnData.length);
 
+                       // Process the data
+                       // char[] sendData = table.acceptDataFromLocal(readData);
+                       char[] sendData = table.acceptDataFromLocal(returnData);
 
-                               mac.update(sendData);
-                               char[] realmac = mac.doFinal();
-                               char[] totalData = new char[sendData.length + realmac.length];
-                               System.arraycopy(sendData, 0, totalData, 0, sendData.length);
-                               System.arraycopy(realmac, 0, totalData, sendData.length, realmac.length);
 
-                               // Encrypt the data for sending
-                               // char[] encryptedData = encryptCipher.doFinal(totalData);
-                               char[] iv = createIV(table.getMachineId(), table.getLocalSequenceNumber());
-                               char[] encryptedData = encryptSlotAndPrependIV(totalData, iv);
+                       mac.update(sendData);
+                       char[] realmac = mac.doFinal();
+                       char[] totalData = new char[sendData.length + realmac.length];
+                       System.arraycopy(sendData, 0, totalData, 0, sendData.length);
+                       System.arraycopy(realmac, 0, totalData, sendData.length, realmac.length);
 
+                       // Encrypt the data for sending
+                       // char[] encryptedData = encryptCipher.doFinal(totalData);
+                       char[] iv = createIV(table.getMachineId(), table.getLocalSequenceNumber());
+                       char[] encryptedData = encryptSlotAndPrependIV(totalData, iv);
 
-                               timer.startTime();
-                               // Send data to output (length of data, the data)
-                               output.writeInt(encryptedData.length);
-                               output.write(encryptedData, 0, encryptedData.length);
-                               output.flush();
 
-                               // close the socket
-                               socket.close();
-                       } catch (Exception e) {
+                       timer.startTime();
+                       // Send data to output (length of data, the data)
+                       output.writeInt(encryptedData.length);
+                       output.write(encryptedData, 0, encryptedData.length);
+                       output.flush();
 
-                       }
-               }
+                       // close the socket
+                       socket.close();
+               } catch (Exception e) {
 
-               if (inputSocket != NULL) {
-                       try {
-                               inputSocket.close();
-                       } catch (Exception e) {
-                               e.printStackTrace();
-                               throw new Error("Local server close failure...");
-                       }
                }
        }
 
-       void close() {
-               doEnd = true;
-
-               if (localServerThread != NULL) {
-                       try {
-                               localServerThread.join();
-                       } catch (Exception e) {
-                               e.printStackTrace();
-                               throw new Error("Local Server thread join issue...");
-                       }
+       if (inputSocket != NULL) {
+               try {
+                       inputSocket.close();
+               } catch (Exception e) {
+                       e.printStackTrace();
+                       throw new Error("Local server close failure...");
                }
-
-               // System.out.println("Done Closing Cloud Comm");
        }
+}
+
+void CloudComm::close() {
+       doEnd = true;
 
-       protected void finalize() throws Throwable {
+       if (localServerThread != NULL) {
                try {
-                       close();        // close open files
-               } finally {
-                       super.finalize();
+                       localServerThread.join();
+               } catch (Exception e) {
+                       e.printStackTrace();
+                       throw new Error("Local Server thread join issue...");
                }
        }
+
+       // System.out.println("Done Closing Cloud Comm");
 }
+