X-Git-Url: http://plrg.eecs.uci.edu/git/?p=iotcloud.git;a=blobdiff_plain;f=version2%2Fsrc%2FC%2FCloudComm.cc;h=9149f2d817b562cfb112d910349d98e30502425f;hp=97a96c25520f51376ef67edbfea1e977ba231737;hb=15acb678f516190fbf7364a41a1f570e90dc09d0;hpb=b93a811befa0833e1442ec558977bbb876e61177

diff --git a/version2/src/C/CloudComm.cc b/version2/src/C/CloudComm.cc
index 97a96c2..9149f2d 100644
--- a/version2/src/C/CloudComm.cc
+++ b/version2/src/C/CloudComm.cc
@@ -4,6 +4,18 @@
 #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 "aes.h"
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/tcp.h>
+#include <unistd.h>
+#include <netdb.h>
 
 /**
  * Empty Constructor needed for child class.
@@ -17,12 +29,19 @@ CloudComm::CloudComm() :
 	salt(NULL),
 	table(NULL),
 	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.
  */
@@ -35,30 +54,31 @@ CloudComm::CloudComm(Table *_table,  IoTString *_baseurl, IoTString *_password,
 	salt(NULL),
 	table(_table),
 	listeningPort(_listeningPort),
-	localServerThread(NULL),
 	doEnd(false),
-	timer(TimingSingleton_getInstance()) {
+	timer(TimingSingleton_getInstance()),
+	getslot(new Array<char>("getslot", 7)),
+	putslot(new Array<char>("putslot", 7)) {
 	if (listeningPort > 0) {
-		localServerThread = new Thread(new Runnable() {
-			void run() {
-				localServerWorkerFunction();
-			}
-		});
-		localServerThread->start();
+		pthread_create(&localServerThread, NULL, threadWrapper, this);
 	}
 }
 
+CloudComm::~CloudComm() {
+	delete random;
+	delete getslot;
+	delete putslot;
+}
+
 /**
  * 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,15 +102,13 @@ void CloudComm::initSecurity() {
  * Inits the HMAC generator.
  */
 void CloudComm::initCrypt() {
-
 	if (password == NULL) {
 		return;
 	}
-
 	try {
 		key = initKey();
 		password = NULL;// drop password
-		mac = Mac_getInstance("HmacSHA256");
+		mac = new Mac();
 		mac->init(key);
 	} catch (Exception *e) {
 		throw new Error("Failed To Initialize Ciphers");
@@ -100,246 +118,478 @@ 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()->internalArray(), 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() {
+void loopWrite(int fd, char * array, int bytestowrite) {
+	int byteswritten = 0;
+	while (bytestowrite) {
+		int bytes = write(fd, & array[byteswritten], bytestowrite);
+		if (bytes >= 0) {
+			byteswritten += bytes;
+			bytestowrite -= bytes;
+		} else {
+			printf("Error in write\n");
+			exit(-1);
+		}
+	}
+}
 
-	if (salt != NULL) {
-		// Salt already sent to server so dont set it again
-		return;
+void loopRead(int fd, char * array, int bytestoread) {
+	int bytesread = 0;
+	while (bytestoread) {
+		int bytes = read(fd, & array[bytesread], bytestoread);
+		if (bytes >= 0) {
+			bytesread += bytes;
+			bytestoread -= bytes;
+		} else {
+			printf("Error in read\n");
+			exit(-1);
+		}
 	}
+}
 
-	try {
-		Array<char> *saltTmp = new Array<char>(CloudComm_SALT_SIZE);
-		random->nextBytes(saltTmp);
+int openURL(IoTString *url) {
+	if (url->length() < 7 || memcmp(url->internalBytes()->internalArray(), "http://", 7)) {
+		printf("BOGUS URL\n");
+		exit(-1);
+	}
+	int i = 7;
+	for(; i < url->length(); i++)
+		if (url->get(i) == '/')
+			break;
+
+	if ( i == url->length()) {
+		printf("ERROR in openURL\n");
+		exit(-1);
+	}
+	
+	char * host = (char *) malloc(i - 6);
+	memcpy(host, &url->internalBytes()->internalArray()[7], i-7);
+	host[i-7] = 0;
+	printf("%s\n", host);
+
+	char * message = (char *)malloc(sizeof("POST  HTTP/1.1\r\n") + sizeof("Host: \r\n") + 2*url->length());
+	
+	/* fill in the parameters */
+	int post = sprintf(message,"POST ");
+	/* copy data */
+	memcpy(&message[post], &url->internalBytes()->internalArray()[i], url->length()-i);
+	int endpost = sprintf(&message[post+url->length()-i], " HTTP/1.1\r\n");
+
+	int hostlen = sprintf(&message[endpost + post + url->length()-i], "Host: ");
+	memcpy(&message[endpost + post + url->length()+hostlen-i], host, i-7);
+	sprintf(&message[endpost + post + url->length()+hostlen-7], "\r\n");
+	
+	/* create the socket */
+	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
+	if (sockfd < 0) {printf("ERROR opening socket\n"); exit(-1);}
+	
+	/* lookup the ip address */
+	struct hostent *server = gethostbyname(host);
+	free(host);
+	
+	if (server == NULL) {printf("ERROR, no such host"); exit(-1);}
+	
+	/* fill in the structure */
+	struct sockaddr_in serv_addr;
+
+	memset(&serv_addr,0,sizeof(serv_addr));
+	serv_addr.sin_family = AF_INET;
+	serv_addr.sin_port = htons(80);
+	memcpy(&serv_addr.sin_addr.s_addr,server->h_addr,server->h_length);
+	
+	/* connect the socket */
+	if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0) {
+		printf("ERROR connecting");
+		exit(-1);
+	}
 
-		for (int i = 0; i < CloudComm_SALT_SIZE; i++) {
-			printf("%d\n", (int)saltTmp->get(i) & 255);
-		}
+	/* send the request */
+	int total = strlen(message);
+	loopWrite(sockfd, message, total);
+	return sockfd;
+}
 
+int createSocket(IoTString *name, int port) {
+	char * host = (char *) malloc(name->length()+1);
+	memcpy(host, name->internalBytes()->internalArray(), name->length());
+	host[name->length()] = 0;
+	printf("%s\n", host);
+	/* How big is the message? */
+	
+	/* create the socket */
+	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
+	if (sockfd < 0) {printf("ERROR opening socket\n"); exit(-1);}
+	
+	/* lookup the ip address */
+	struct hostent *server = gethostbyname(host);
+	free(host);
+	
+	if (server == NULL) {printf("ERROR, no such host"); exit(-1);}
+	
+	/* fill in the structure */
+	struct sockaddr_in serv_addr;
+
+	memset(&serv_addr,0,sizeof(serv_addr));
+	serv_addr.sin_family = AF_INET;
+	serv_addr.sin_port = htons(port);
+	memcpy(&serv_addr.sin_addr.s_addr,server->h_addr,server->h_length);
+	
+	/* connect the socket */
+	if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0) {
+		printf("ERROR connecting");
+		exit(-1);
+	}
+	
+	return sockfd;
+}
 
-		URL* url = new URL(baseurl + "?req=setsalt");
+int createSocket(int port) {
+	int fd;
+	struct sockaddr_in sin;
+
+  bzero(&sin, sizeof(sin));
+  sin.sin_family = AF_INET;
+  sin.sin_port = htons(port);
+  sin.sin_addr.s_addr = htonl(INADDR_ANY);
+  fd=socket(AF_INET, SOCK_STREAM, 0);
+	int n = 1;
+	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&n, sizeof (n)) < 0) {
+    close(fd);
+		printf("Create Socket Error\n");
+		exit(-1);
+	}
+	if (bind(fd, (struct sockaddr *) &sin, sizeof(sin))<0) {
+    close(fd);
+		exit(-1);
+	}
+  if (listen(fd, 5)<0) {
+    close(fd);
+		exit(-1);
+	}
+	return fd;
+}
 
-		timer->startTime();
-		URLConnection con = url->openConnection();
-		HttpURLConnection http = (HttpURLConnection) con;
+int acceptSocket(int socket) {
+  struct sockaddr_in sin;
+  unsigned int sinlen=sizeof(sin);
+	int newfd = accept(socket, (struct sockaddr *)&sin, &sinlen);
+	int flag = 1;
+	setsockopt(newfd, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(flag));
+	if (newfd < 0) {
+		printf("Accept Error\n");
+		exit(-1);
+	}
+	return newfd;
+}
 
-		http->setRequestMethod("POST");
-		http->setFixedLengthStreamingMode(saltTmp->length());
-		http->setDoOutput(true);
-		http->setConnectTimeout(CloudComm_TIMEOUT_MILLIS);
+void writeSocketData(int fd, Array<char> *data) {
+	loopWrite(fd, data->internalArray(), data->length());
+}
 
+void writeSocketInt(int fd, int32_t value) {
+	char array[4];
+	array[0] = value >> 24;
+	array[1] = (value >> 16) & 0xff;
+	array[2] = (value >> 8) & 0xff;
+	array[3] = (value >> 8) & 0xff;
+	loopWrite(fd, array, 4);
+}
 
-		http->connect();
+int readSocketInt(int fd) {
+	char array[4];
+	loopRead(fd, array, 4);
+	return (((int32_t) array[0]) << 24) |
+		(((int32_t) array[1]) << 16) |
+		(((int32_t) array[2]) << 8) |
+		((int32_t) array[3]);
+}
 
-		OutputStream* os = http->getOutputStream();
-		os->write(saltTmp);
-		os->flush();
+void readSocketData(int fd, Array<char> *data) {
+	loopRead(fd, data->internalArray(), data->length());
+}
 
-		int responsecode = http->getResponseCode();
-		if (responsecode != HttpURLConnection.HTTP_OK) {
-			// TODO: Remove this print
-			System.out.println(responsecode);
-			throw new Error("Invalid response");
+void writeURLDataAndClose(int fd, Array<char> *data) {
+	dprintf(fd, "Content-Length: %d\r\n\r\n", data->length());
+	loopWrite(fd, data->internalArray(), data->length());
+}
+
+void closeURLReq(int fd) {
+	dprintf(fd, "\r\n");
+}
+
+void readURLData(int fd, Array<char> *output) {
+	loopRead(fd, output->internalArray(), output->length());
+}
+
+int readURLInt(int fd) {
+	char array[4];
+	loopRead(fd, array, 4);
+	return (((int32_t) array[0]) << 24) |
+		(((int32_t) array[1]) << 16) |
+		(((int32_t) array[2]) << 8) |
+		((int32_t) array[3]);
+}
+
+int getResponseCode(int fd) {
+	char response[600];
+	int offset = 0;
+	char newchar;
+	while(true) {
+		int bytes = read(fd, &newchar, 1);
+		if (bytes <= 0)
+			break;
+		if (offset == (sizeof(response) - 1)) {
+			printf("Response too long");
+			exit(-1);
 		}
+		response[offset++] = newchar;
+		if (newchar == '\n')
+			break;
+	}
+	response[offset] = 0;
+	int ver1 = 0, ver2 = 0, respcode = 0;
+	sscanf(response, "HTTP/%d.%d %d", &ver1, &ver2, &respcode);
+	printf("Response code %d\n", respcode);
+	return respcode;
+}
 
-		timer->endTime();
+void readHeaders(int fd) {
+	int state = 2;
+	char newchar;
+
+	while(true) {
+		int bytes = read(fd, &newchar, 1);
+		if (bytes <= 0)
+			throw new Error("Headers malformed!");
+		switch (state) {
+		case 0:
+			if (newchar == '\r')
+				state = 1;
+			break;
+		case 1:
+			if (newchar == '\n')
+				state = 2;
+			else
+				state = 0;
+			break;
+		case 2:
+			if (newchar == '\r')
+				state = 3;
+			else
+				state = 0;
+			break;
+		case 3:
+			if (newchar == '\n')
+				state = 4;
+			else
+				state = 0;
+			break;
+		default:
+			printf("ERROR in readHeaders\n");
+			exit(-1);
+		}
+		if (state == 4)
+			return;
+	}
+}
+
+void CloudComm::setSalt() {
+	if (salt != NULL) {
+		// 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);
+
+		char *buffer = (char *) malloc(baseurl->length() + 100);
+		memcpy(buffer, baseurl->internalBytes()->internalArray(), baseurl->length());
+		int offset = baseurl->length();
+		offset += sprintf(&buffer[offset], "?req=setsalt");
+		IoTString *urlstr = new IoTString(buffer);
+		free(buffer);
 
+		timer->startTime();
+		fd = openURL(urlstr);
+		writeURLDataAndClose(fd, saltTmp);
+
+		int responsecode = getResponseCode(fd);
+		if (responsecode != HttpURLConnection_HTTP_OK) {
+			throw new Error("Invalid response");
+		}
+		close(fd);
+		
+		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()->internalArray(), 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);
+		closeURLReq(fd);
 		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);
+		readHeaders(fd);
+		if (responsecode != HttpURLConnection_HTTP_OK) {
 			throw new Error("Invalid response");
 		}
+		int salt_length = readURLInt(fd);
+		Array<char> *tmp = new Array<char>(salt_length);
+		readURLData(fd, tmp);
+		close(fd);
 
-		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;
-		}
+		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) {
+	Array<char> * output=new Array<char>(data->length());
+	aes_encrypt_ctr((BYTE *)data->internalArray(), data->length(), (BYTE *) output->internalArray(), (WORD *)key->getKey()->internalArray(), key->getKey()->length()/(sizeof(WORD)/sizeof(BYTE)), (BYTE *)ivBytes->internalArray());
+	return output;
+}
 
-		Array<char> *encryptedBytes = cipher->doFinal(rawData);
+Array<char> *AESDecrypt(Array<char> *ivBytes, AESKey *key, Array<char> *data) {
+	Array<char> * output=new Array<char>(data->length());
+	aes_decrypt_ctr((BYTE *)data->internalArray(), data->length(), (BYTE *)output->internalArray(), (WORD *)key->getKey()->internalArray(), key->getKey()->length()/(sizeof(WORD)/sizeof(BYTE)), (BYTE *)ivBytes->internalArray());
+	return output;
+}
 
+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);
+		writeURLDataAndClose(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 {
+		int respcode = getResponseCode(fd);
+		readHeaders(fd);
 		timer->startTime();
-		InputStream is = http->getInputStream();
-		DataInputStream * dis = new DataInputStream(is);
-		Array<char> *resptype = new char[7];
-		dis->readFully(resptype);
+		Array<char> *resptype = new Array<char>(7);
+		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)) {
+			Array<Slot *> * tmp =processSlots(fd);
+			close(fd);
+			return tmp;
+		} else if (resptype->equals(putslot)) {
+			close(fd);
 			return NULL;
-		} else
+		} else {
+			close(fd);
 			throw new Error("Bad response to putslot");
-
+		}
 	} catch (SocketTimeoutException *e) {
 		timer->endTime();
-		throw new ServerException("putSlot failed", ServerException->TypeInputTimeout);
+		close(fd);
+		throw new ServerException("putSlot failed", ServerException_TypeInputTimeout);
 	} catch (Exception *e) {
 		throw new Error("putSlot failed");
 	}
@@ -350,31 +600,23 @@ 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);
+		closeURLReq(fd);
 		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 +626,22 @@ Array<Slot *> *CloudComm::getSlots(int64_t sequencenumber) {
 	}
 
 	try {
-
 		timer->startTime();
-		InputStream *is = http->getInputStream();
-		DataInputStream *dis = new DataInputStream(is);
+		int responsecode = getResponseCode(fd);
+		readHeaders(fd);
 		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);
+		Array<Slot*> * tmp=processSlots(fd);
+		close(fd);
+		return tmp;
 	} catch (SocketTimeoutException *e) {
 		timer->endTime();
-
-		throw new ServerException("getSlots failed", ServerException.TypeInputTimeout);
+		close(fd);
+		throw new ServerException("getSlots failed", ServerException_TypeInputTimeout);
 	} catch (Exception *e) {
 		throw new Error("getSlots failed");
 	}
@@ -410,84 +651,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<int> * sizesofslots = new Array<int>(numberofslots);
+Array<Slot *> *CloudComm::processSlots(int fd) {
+	int numberofslots = readURLInt(fd);
+	Array<int> *sizesofslots = new Array<int>(numberofslots);
+	Array<Slot *> *slots = new Array<Slot *>(numberofslots);
 
-	Array<Slot*> * slots = new Array<Slot*>(numberofslots);
 	for (int i = 0; i < numberofslots; i++)
-		sizesofslots->set(i], dis->readInt());
-
+		sizesofslots->set(i, readURLInt(fd));
 	for (int i = 0; i < numberofslots; i++) {
-
 		Array<char> *rawData = new Array<char>(sizesofslots->get(i));
-		dis->readFully(rawData);
-
-
-		// Array<char> * data = new char[rawData.length - IV_SIZE];
-		// System.arraycopy(rawData, IV_SIZE, data, 0, data.length);
-
-
+		readURLData(fd, rawData);
 		Array<char> *data = stripIVAndDecryptSlot(rawData);
-
-		// data = decryptCipher.doFinal(data);
-		
 		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"\m);
-
-		mac->update(sendData);
+		printf("Passing Locally\n");
+		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) {
@@ -498,13 +718,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...");
 	}
@@ -512,24 +730,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))
@@ -540,9 +753,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());
@@ -552,37 +763,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 (listeningPort > 0) {
+		if (pthread_join(localServerThread, NULL) != 0)
 			throw new Error("Local Server thread join issue...");
-		}
 	}
 }
-