X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=version2%2Fsrc%2FC%2FCloudComm.cc;h=4e4000fae9ee310be4836cbb3b83a021ef902005;hb=1a486d4bea2b57d36f6fc0e40193bb7812405c4f;hp=452317f42335854743b9e95cb3d1f81bc62e8858;hpb=a5f6f53f487875a39c9b27daafbde2c6743546db;p=iotcloud.git

diff --git a/version2/src/C/CloudComm.cc b/version2/src/C/CloudComm.cc
index 452317f..4e4000f 100644
--- a/version2/src/C/CloudComm.cc
+++ b/version2/src/C/CloudComm.cc
@@ -4,6 +4,13 @@
 #include "IoTString.h"
 #include "Error.h"
 #include "URL.h"
+#include "Mac.h"
+#include "Table.h"
+#include "Slot.h"
+#include "Crypto.h"
+#include "ByteBuffer.h"
+#include <sys/socket.h>
+#include <unistd.h>
 
 /**
  * Empty Constructor needed for child class.
@@ -19,10 +26,18 @@ CloudComm::CloudComm() :
 	listeningPort(-1),
 	localServerThread(NULL),
 	doEnd(false),
-	timer(TimingSingleton_getInstance())
+	timer(TimingSingleton_getInstance()),
+	getslot(new Array<char>("getslot", 7)),
+	putslot(new Array<char>("putslot", 7))
 {
 }
 
+void * threadWrapper(void * cloud) {
+	CloudComm *c = (CloudComm *) cloud;
+	c->localServerWorkerFunction();
+	return NULL;
+}
+
 /**
  * Constructor for actual use. Takes in the url and password.
  */
@@ -39,26 +54,20 @@ CloudComm::CloudComm(Table *_table,  IoTString *_baseurl, IoTString *_password,
 	doEnd(false),
 	timer(TimingSingleton_getInstance()) {
 	if (listeningPort > 0) {
-		localServerThread = new Thread(new Runnable() {
-			void run() {
-				localServerWorkerFunction();
-			}
-		});
-		localServerThread->start();
+		pthread_create(&localServerThread, NULL, threadWrapper, this);
 	}
 }
 
 /**
  * Generates Key from password.
  */
-SecretKeySpec *CloudComm::initKey() {
+AESKey *CloudComm::initKey() {
 	try {
-		PBEKeySpec keyspec = new PBEKeySpec(password->internalBytes(),
-																				salt,
-																				65536,
-																				128);
-		SecretKey tmpkey = SecretKeyFactory_getInstance("PBKDF2WithHmacSHA256")->generateSecret(keyspec);
-		return new SecretKeySpec(tmpkey->getEncoded(), "AES");
+		AESKey * key = new AESKey(password->internalBytes(),
+															salt,
+															65536,
+															128);
+		return key;
 	} catch (Exception *e) {
 		throw new Error("Failed generating key.");
 	}
@@ -82,11 +91,9 @@ void CloudComm::initSecurity() {
  * Inits the HMAC generator.
  */
 void CloudComm::initCrypt() {
-
 	if (password == NULL) {
 		return;
 	}
-
 	try {
 		key = initKey();
 		password = NULL;// drop password
@@ -100,246 +107,225 @@ void CloudComm::initCrypt() {
 /*
  * 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;
+IoTString *CloudComm::buildRequest(bool isput, int64_t sequencenumber, int64_t maxentries) {
+	const char *reqstring = isput ? "req=putslot" : "req=getslot";
+	char *buffer = (char *) malloc(baseurl->length() + 200);
+	memcpy(buffer, baseurl->internalBytes(), baseurl->length());
+	int offset = baseurl->length();
+	offset += sprintf(&buffer[offset], "?%s&seq=%" PRId64, reqstring, sequencenumber);
 	if (maxentries != 0)
-		urlstr += "&max=" + maxentries;
-	return new URL(urlstr);
+		sprintf(&buffer[offset], "&max=%" PRId64, maxentries);
+	IoTString *urlstr = new IoTString(buffer);
+	return urlstr;
 }
 
-void CloudComm::setSalt() {
+int openURL(IoTString *url, bool isPost) {
+	return 0;
+}
+
+int createSocket(IoTString *host, int port) {
+	return 0;
+}
+
+int createSocket(int port) {
+	return 0;
+}
+
+int acceptSocket(int socket) {
+	return 0;
+}
 
+void writeSocketData(int fd, Array<char> *data) {}
+
+void writeSocketInt(int fd, int value) {}
+
+int readSocketInt(int fd) {return 0;}
+
+void readSocketData(int fd, Array<char> *data) {}
+
+void writeURLData(int fd, Array<char> *data) {
+}
+
+void readURLData(int fd, Array<char> * output) {
+}
+
+int readURLInt(int fd) {
+	return 0;
+}
+
+int getResponseCode(int fd) {
+	return 0;
+}
+
+void CloudComm::setSalt() {
 	if (salt != NULL) {
-		// Salt already sent to server so dont set it again
+		// Salt already sent to server so don't set it again
 		return;
 	}
 
+	int fd = -1;
 	try {
 		Array<char> *saltTmp = new Array<char>(CloudComm_SALT_SIZE);
 		random->nextBytes(saltTmp);
 
-		for (int i = 0; i < CloudComm_SALT_SIZE; i++) {
-			printf("%d\n", (int)saltTmp->get(i) & 255);
-		}
-
-
-		URL *url = new URL(baseurl + "?req=setsalt");
+		char *buffer = (char *) malloc(baseurl->length() + 100);
+		memcpy(buffer, baseurl->internalBytes(), baseurl->length());
+		int offset = baseurl->length();
+		offset += sprintf(&buffer[offset], "?req=setsalt");
+		IoTString *urlstr = new IoTString(buffer);
+		free(buffer);
 
 		timer->startTime();
-		URLConnection con = url->openConnection();
-		HttpURLConnection http = (HttpURLConnection) con;
-
-		http->setRequestMethod("POST");
-		http->setFixedLengthStreamingMode(saltTmp->length());
-		http->setDoOutput(true);
-		http->setConnectTimeout(CloudComm_TIMEOUT_MILLIS);
-
-
-		http->connect();
-
-		OutputStream *os = http->getOutputStream();
-		os->write(saltTmp);
-		os->flush();
+		fd = openURL(urlstr, true);
+		writeURLData(fd, saltTmp);
 
-		int responsecode = http->getResponseCode();
-		if (responsecode != HttpURLConnection.HTTP_OK) {
-			// TODO: Remove this print
-			System.out.println(responsecode);
+		int responsecode = getResponseCode(fd);
+		if (responsecode != HttpURLConnection_HTTP_OK) {
 			throw new Error("Invalid response");
 		}
 
 		timer->endTime();
-
 		salt = saltTmp;
 	} catch (Exception *e) {
 		timer->endTime();
-		throw new ServerException("Failed setting salt", ServerException.TypeConnectTimeout);
+		throw new ServerException("Failed setting salt", ServerException_TypeConnectTimeout);
 	}
 }
 
 bool CloudComm::getSalt() {
-	URL *url = NULL;
-	URLConnection *con = NULL;
-	HttpURLConnection *http = NULL;
-
+	int fd = -1;
+	IoTString *urlstr = NULL;
+	
 	try {
-		url = new URL(baseurl + "?req=getsalt");
+		char *buffer = (char *) malloc(baseurl->length() + 100);
+		memcpy(buffer, baseurl->internalBytes(), baseurl->length());
+		int offset = baseurl->length();
+		offset += sprintf(&buffer[offset], "?req=getsalt");
+		urlstr = new IoTString(buffer);
+		free(buffer);
 	} catch (Exception *e) {
 		throw new Error("getSlot failed");
 	}
 	try {
-
 		timer->startTime();
-		con = url->openConnection();
-		http = (HttpURLConnection) con;
-		http->setRequestMethod("POST");
-		http->setConnectTimeout(CloudComm_TIMEOUT_MILLIS);
-		http->setReadTimeout(CloudComm_TIMEOUT_MILLIS);
-
-
-		http->connect();
+		fd = openURL(urlstr, true);
 		timer->endTime();
 	} catch (SocketTimeoutException *e) {
 		timer->endTime();
-		throw new ServerException("getSalt failed", ServerException.TypeConnectTimeout);
+		throw new ServerException("getSalt failed", ServerException_TypeConnectTimeout);
 	} catch (Exception *e) {
 		throw new Error("getSlot failed");
 	}
 
 	try {
-
 		timer->startTime();
-
-		int responsecode = http.getResponseCode();
-		if (responsecode != HttpURLConnection.HTTP_OK) {
-			// TODO: Remove this print
-			// System.out.println(responsecode);
+		int responsecode = getResponseCode(fd);
+		if (responsecode != HttpURLConnection_HTTP_OK) {
 			throw new Error("Invalid response");
 		}
-
-		InputStream is = http->getInputStream();
-		if (is->available() > 0) {
-			DataInputStream *dis = new DataInputStream(is);
-			int salt_length = dis->readInt();
-			Array<char> *tmp = new Array<char>(salt_length);
-			dis->readFully(tmp);
-			salt = tmp;
-			timer->endTime();
-
-			return true;
-		} else {
-			timer->endTime();
-
-			return false;
-		}
+		int salt_length = readURLInt(fd);
+		Array<char> *tmp = new Array<char>(salt_length);
+		readURLData(fd, tmp);
+		salt = tmp;
+		timer->endTime();
+		return true;
 	} catch (SocketTimeoutException *e) {
 		timer->endTime();
-
-		throw new ServerException("getSalt failed", ServerException.TypeInputTimeout);
+		throw new ServerException("getSalt failed", ServerException_TypeInputTimeout);
 	} catch (Exception *e) {
 		throw new Error("getSlot failed");
 	}
 }
 
 Array<char> *CloudComm::createIV(int64_t machineId, int64_t localSequenceNumber) {
-	ByteBuffer buffer = ByteBuffer.allocate(CloudComm_IV_SIZE);
+	ByteBuffer *buffer = ByteBuffer_allocate(CloudComm_IV_SIZE);
 	buffer->putLong(machineId);
 	int64_t localSequenceNumberShifted = localSequenceNumber << 16;
 	buffer->putLong(localSequenceNumberShifted);
 	return buffer->array();
 }
 
-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);
+Array<char> *AESEncrypt(Array<char> * ivBytes, AESKey * key, Array<char> * data) {
+	return NULL;
+}
 
-		Array<char> *encryptedBytes = cipher->doFinal(rawData);
+Array<char> *AESDecrypt(Array<char> * ivBytes, AESKey * key, Array<char> * data) {
+	return NULL;
+}
 
+Array<char> *CloudComm::encryptSlotAndPrependIV(Array<char> *rawData, Array<char> *ivBytes) {
+	try {
+		Array<char> *encryptedBytes = AESEncrypt(ivBytes, key, rawData);
 		Array<char> *chars = new Array<char>(encryptedBytes->length() + CloudComm_IV_SIZE);
-		System_arraycopy(ivBytes, 0, chars, 0, ivBytes.length());
-		System_arraycopy(encryptedBytes, 0, chars, CloudComm_IV_SIZE, encryptedBytes.length);
+		System_arraycopy(ivBytes, 0, chars, 0, ivBytes->length());
+		System_arraycopy(encryptedBytes, 0, chars, CloudComm_IV_SIZE, encryptedBytes->length());
 
 		return chars;
-
 	} catch (Exception *e) {
 		throw new Error("Failed To Encrypt");
 	}
 }
 
-
 Array<char> *CloudComm::stripIVAndDecryptSlot(Array<char> *rawData) {
 	try {
 		Array<char> *ivBytes = new Array<char>(CloudComm_IV_SIZE);
 		Array<char> *encryptedBytes = new Array<char>(rawData->length() - CloudComm_IV_SIZE);
 		System_arraycopy(rawData, 0, ivBytes, 0, CloudComm_IV_SIZE);
-		System_arraycopy(rawData, CloudComm_IV_SIZE, encryptedBytes, 0, encryptedBytes->length);
-
-		IvParameterSpec *ivSpec = new IvParameterSpec(ivBytes);
-
-		Cipher *cipher = Cipher_getInstance("AES/CTR/NoPadding");
-		cipher->init(Cipher_DECRYPT_MODE, key, ivSpec);
-		return cipher->doFinal(encryptedBytes);
-
+		System_arraycopy(rawData, CloudComm_IV_SIZE, encryptedBytes, 0, encryptedBytes->length());
+		return AESDecrypt(ivBytes, key, encryptedBytes);
 	} catch (Exception *e) {
 		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.
  */
 Array<Slot *> *CloudComm::putSlot(Slot *slot, int max) {
+	int fd = -1;
 	try {
 		if (salt == NULL) {
 			if (!getSalt()) {
-				throw new ServerException("putSlot failed", ServerException.TypeSalt);
+				throw new ServerException("putSlot failed", ServerException_TypeSalt);
 			}
 			initCrypt();
 		}
 
 		int64_t sequencenumber = slot->getSequenceNumber();
 		Array<char> *slotBytes = slot->encode(mac);
-
 		Array<char> *chars = encryptSlotAndPrependIV(slotBytes, slot->getSlotCryptIV());
-
-		URL *url = buildRequest(true, sequencenumber, max);
-
+		IoTString *url = buildRequest(true, sequencenumber, max);
 		timer->startTime();
-		URLConnection *con = url->openConnection();
-		HttpURLConnection *http = (HttpURLConnection *) con;
-
-		http->setRequestMethod("POST");
-		http->setFixedLengthStreamingMode(chars->length);
-		http->setDoOutput(true);
-		http->setConnectTimeout(CloudComm_TIMEOUT_MILLIS);
-		http->setReadTimeout(CloudComm_TIMEOUT_MILLIS);
-		http->connect();
-
-		OutputStream *os = http->getOutputStream();
-		os->write(chars);
-		os->flush();
-
+		fd = openURL(url, true);
+		writeURLData(fd, chars);
 		timer->endTime();
-
-
 	} catch (ServerException *e) {
 		timer->endTime();
-
 		throw e;
 	} catch (SocketTimeoutException *e) {
 		timer->endTime();
-
-		throw new ServerException("putSlot failed", ServerException.TypeConnectTimeout);
+		throw new ServerException("putSlot failed", ServerException_TypeConnectTimeout);
 	} catch (Exception *e) {
 		throw new Error("putSlot failed");
 	}
 
-
-
 	try {
 		timer->startTime();
-		InputStream is = http->getInputStream();
-		DataInputStream *dis = new DataInputStream(is);
 		Array<char> *resptype = new Array<char>(7);
-		dis->readFully(resptype);
+		readURLData(fd, resptype);
 		timer->endTime();
 
-		if (Arrays->equals(resptype, "getslot"->getBytes())) {
-			return processSlots(dis);
-		} else if (Arrays->equals(resptype, "putslot"->getBytes())) {
+		if (resptype->equals(getslot)) {
+			return processSlots(fd);
+		} else if (resptype->equals(putslot)) {
 			return NULL;
 		} else
 			throw new Error("Bad response to putslot");
-
 	} catch (SocketTimeoutException *e) {
 		timer->endTime();
-		throw new ServerException("putSlot failed", ServerException->TypeInputTimeout);
+		throw new ServerException("putSlot failed", ServerException_TypeInputTimeout);
 	} catch (Exception *e) {
 		throw new Error("putSlot failed");
 	}
@@ -350,31 +336,22 @@ Array<Slot *> *CloudComm::putSlot(Slot *slot, int max) {
  * sequencenumber or newer->
  */
 Array<Slot *> *CloudComm::getSlots(int64_t sequencenumber) {
+	int fd = -1;
 	try {
 		if (salt == NULL) {
 			if (!getSalt()) {
-				throw new ServerException("getSlots failed", ServerException.TypeSalt);
+				throw new ServerException("getSlots failed", ServerException_TypeSalt);
 			}
 			initCrypt();
 		}
 
-		URL *url = buildRequest(false, sequencenumber, 0);
+		IoTString *url = buildRequest(false, sequencenumber, 0);
 		timer->startTime();
-		URLConnection *con = url->openConnection();
-		HttpURLConnection *http = (HttpURLConnection) con;
-		http->setRequestMethod("POST");
-		http->setConnectTimeout(CloudComm_TIMEOUT_MILLIS);
-		http->setReadTimeout(CloudComm_TIMEOUT_MILLIS);
-
-
-
-		http->connect();
+		fd = openURL(url, true);
 		timer->endTime();
-
 	} catch (SocketTimeoutException *e) {
 		timer->endTime();
-
-		throw new ServerException("getSlots failed", ServerException.TypeConnectTimeout);
+		throw new ServerException("getSlots failed", ServerException_TypeConnectTimeout);
 	} catch (ServerException *e) {
 		timer->endTime();
 
@@ -384,23 +361,17 @@ Array<Slot *> *CloudComm::getSlots(int64_t sequencenumber) {
 	}
 
 	try {
-
 		timer->startTime();
-		InputStream *is = http->getInputStream();
-		DataInputStream *dis = new DataInputStream(is);
 		Array<char> *resptype = new Array<char>(7);
-
-		dis->readFully(resptype);
+		readURLData(fd, resptype);
 		timer->endTime();
+		if (!resptype->equals(getslot))
+			throw new Error("Bad Response: ");
 
-		if (!resptype->equals("getslot".getBytes()))
-			throw new Error("Bad Response: " + new String(resptype));
-
-		return processSlots(dis);
+		return processSlots(fd);
 	} catch (SocketTimeoutException *e) {
 		timer->endTime();
-
-		throw new ServerException("getSlots failed", ServerException.TypeInputTimeout);
+		throw new ServerException("getSlots failed", ServerException_TypeInputTimeout);
 	} catch (Exception *e) {
 		throw new Error("getSlots failed");
 	}
@@ -410,75 +381,63 @@ Array<Slot *> *CloudComm::getSlots(int64_t sequencenumber) {
  * 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();
+Array<Slot *> *CloudComm::processSlots(int fd) {
+	int numberofslots = readURLInt(fd);
 	Array<int> *sizesofslots = new Array<int>(numberofslots);
-
 	Array<Slot *> *slots = new Array<Slot *>(numberofslots);
-	for (int i = 0; i < numberofslots; i++)
-		sizesofslots->set(i, dis->readInt());
 
+	for (int i = 0; i < numberofslots; i++)
+		sizesofslots->set(i, readURLInt(fd));
 	for (int i = 0; i < numberofslots; i++) {
 		Array<char> *rawData = new Array<char>(sizesofslots->get(i));
-		dis->readFully(rawData);
-
+		readURLData(fd, rawData);
 		Array<char> *data = stripIVAndDecryptSlot(rawData);
 		slots->set(i, Slot_decode(table, data, mac));
 	}
-	dis->close();
 	return slots;
 }
 
-Array<char> *sendLocalData(Array<char> *sendData, int64_t localSequenceNumber, String host, int port) {
-	if (salt == NULL) {
+Array<char> *CloudComm::sendLocalData(Array<char> *sendData, int64_t localSequenceNumber, IoTString * host, int port) {
+	if (salt == NULL)
 		return NULL;
-	}
 	try {
 		printf("Passing Locally\n");
-
-		mac->update(sendData);
+		mac->update(sendData, 0, sendData->length());
 		Array<char> *genmac = mac->doFinal();
 		Array<char> *totalData = new Array<char>(sendData->length() + genmac->length());
-		System_arraycopy(sendData, 0, totalData, 0, sendData.length());
-		System - arraycopy(genmac, 0, totalData, 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
 		Array<char> *iv = createIV(table->getMachineId(), table->getLocalSequenceNumber());
 		Array<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());
+		int socket = createSocket(host, port);
 
 		timer->startTime();
 		// Send data to output (length of data, the data)
-		output->writeInt(encryptedData->length);
-		output->write(encryptedData, 0, encryptedData->length);
-		output->flush();
+		writeSocketInt(socket, encryptedData->length());
+		writeSocketData(socket, encryptedData);
 
-		int lengthOfReturnData = input->readInt();
+		int lengthOfReturnData = readSocketInt(socket);
 		Array<char> *returnData = new Array<char>(lengthOfReturnData);
-		input->readFully(returnData);
-
+		readSocketData(socket, returnData);
 		timer->endTime();
-
 		returnData = stripIVAndDecryptSlot(returnData);
 
 		// We are done with this socket
-		socket->close();
-
-		mac->update(returnData, 0, returnData->length - HMAC_SIZE);
+		close(socket);
+		mac->update(returnData, 0, returnData->length() - CloudComm_HMAC_SIZE);
 		Array<char> *realmac = mac->doFinal();
-		Array<char> *recmac = new Array<char>(HMAC_SIZE);
-		System_arraycopy(returnData, returnData->length - realmac->length, recmac, 0, realmac->length);
+		Array<char> *recmac = new Array<char>(CloudComm_HMAC_SIZE);
+		System_arraycopy(returnData, returnData->length() - realmac->length(), recmac, 0, realmac->length());
 
-		if (!Arrays->equals(recmac, realmac))
+		if (!recmac->equals(realmac))
 			throw new Error("Local Error: Invalid HMAC!  Potential Attack!");
 
 		Array<char> *returnData2 = new Array<char>(lengthOfReturnData - recmac->length());
-		System_arraycopy(returnData, 0, returnData2, 0, returnData2->length);
+		System_arraycopy(returnData, 0, returnData2, 0, returnData2->length());
 
 		return returnData2;
 	} catch (Exception *e) {
@@ -489,13 +448,11 @@ Array<char> *sendLocalData(Array<char> *sendData, int64_t localSequenceNumber, S
 }
 
 void CloudComm::localServerWorkerFunction() {
-	ServerSocket *inputSocket = NULL;
+	int inputSocket = -1;
 
 	try {
 		// Local server socket
-		inputSocket = new ServerSocket(listeningPort);
-		inputSocket->setReuseAddress(true);
-		inputSocket->setSoTimeout(CloudComm_TIMEOUT_MILLIS);
+		inputSocket = createSocket(listeningPort);
 	} catch (Exception *e) {
 		throw new Error("Local server setup failure...");
 	}
@@ -503,24 +460,19 @@ void CloudComm::localServerWorkerFunction() {
 	while (!doEnd) {
 		try {
 			// Accept incoming socket
-			Socket *socket = inputSocket->accept();
-
-			DataInputStream *input = new DataInputStream(socket->getInputStream());
-			DataOutputStream *output = new DataOutputStream(socket->getOutputStream());
+			int socket = acceptSocket(inputSocket);
 
 			// Get the encrypted data from the server
-			int dataSize = input->readInt();
+			int dataSize = readSocketInt(socket);
 			Array<char> *readData = new Array<char>(dataSize);
-			input->readFully(readData);
-
+			readSocketData(socket, readData);
 			timer->endTime();
 
 			// Decrypt the data
 			readData = stripIVAndDecryptSlot(readData);
-
-			mac->update(readData, 0, readData->length - HMAC_SIZE);
+			mac->update(readData, 0, readData->length() - CloudComm_HMAC_SIZE);
 			Array<char> *genmac = mac->doFinal();
-			Array<char> *recmac = new Array<char>(HMAC_SIZE);
+			Array<char> *recmac = new Array<char>(CloudComm_HMAC_SIZE);
 			System_arraycopy(readData, readData->length() - recmac->length(), recmac, 0, recmac->length());
 
 			if (!recmac->equals(genmac))
@@ -531,9 +483,7 @@ void CloudComm::localServerWorkerFunction() {
 
 			// Process the data
 			Array<char> *sendData = table->acceptDataFromLocal(returnData);
-
-
-			mac->update(sendData);
+			mac->update(sendData, 0, sendData->length());
 			Array<char> *realmac = mac->doFinal();
 			Array<char> *totalData = new Array<char>(sendData->length() + realmac->length());
 			System_arraycopy(sendData, 0, totalData, 0, sendData->length());
@@ -543,37 +493,29 @@ void CloudComm::localServerWorkerFunction() {
 			Array<char> *iv = createIV(table->getMachineId(), table->getLocalSequenceNumber());
 			Array<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();
+			writeSocketInt(socket, encryptedData->length());
+			writeSocketData(socket, encryptedData);
+			close(socket);
 		} catch (Exception *e) {
 		}
 	}
 
-	if (inputSocket != NULL) {
+	if (inputSocket != -1) {
 		try {
-			inputSocket->close();
+			close(inputSocket);
 		} catch (Exception *e) {
 			throw new Error("Local server close failure...");
 		}
 	}
 }
 
-void CloudComm::close() {
+void CloudComm::closeCloud() {
 	doEnd = true;
 
 	if (localServerThread != NULL) {
-		try {
-			localServerThread->join();
-		} catch (Exception *e) {
+		if (pthread_join(localServerThread, NULL) != 0)
 			throw new Error("Local Server thread join issue...");
-		}
 	}
 }
-