#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.
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.
*/
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.");
}
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");
/*
* Builds the URL for the given request.
*/
-URL *CloudComm::buildRequest(bool isput, int64_t sequencenumber, int64_t maxentries) {
+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());
+ 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);
+ offset += sprintf(&buffer[offset], "?%s&seq=%" PRId64, reqstring, sequencenumber);
if (maxentries != 0)
sprintf(&buffer[offset], "&max=%" PRId64, maxentries);
IoTString *urlstr = new IoTString(buffer);
- free(buffer);
- return new URL(urlstr);
+ return urlstr;
+}
+
+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);
+ }
+ }
+}
+
+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);
+ }
+ }
+}
+
+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);
+ }
+
+ /* 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;
+}
+
+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;
+}
+
+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;
+}
+
+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);
+}
+
+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]);
+}
+
+void readSocketData(int fd, Array<char> *data) {
+ loopRead(fd, data->internalArray(), data->length());
+}
+
+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;
+}
+
+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() {
// 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(), baseurl->length());
+ char *buffer = (char *) malloc(baseurl->length() + 100);
+ memcpy(buffer, baseurl->internalBytes()->internalArray(), baseurl->length());
int offset = baseurl->length();
- offset+=sprintf(&buffer[offset], "?req=setsalt");
+ offset += sprintf(&buffer[offset], "?req=setsalt");
IoTString *urlstr = new IoTString(buffer);
free(buffer);
-
- URL *url = new URL(urlstr);
- 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();
+ timer->startTime();
+ fd = openURL(urlstr);
+ writeURLDataAndClose(fd, saltTmp);
- int responsecode = http->getResponseCode();
+ int responsecode = getResponseCode(fd);
if (responsecode != HttpURLConnection_HTTP_OK) {
throw new Error("Invalid response");
}
-
+ close(fd);
+
timer->endTime();
salt = saltTmp;
} catch (Exception *e) {
}
bool CloudComm::getSalt() {
- URL *url = NULL;
- URLConnection *con = NULL;
- HttpURLConnection *http = NULL;
+ int fd = -1;
+ IoTString *urlstr = NULL;
try {
- char * buffer = (char *) malloc(baseurl->length() + 100);
- memcpy(buffer, baseurl->internalBytes(), baseurl->length());
+ char *buffer = (char *) malloc(baseurl->length() + 100);
+ memcpy(buffer, baseurl->internalBytes()->internalArray(), baseurl->length());
int offset = baseurl->length();
- offset+=sprintf(&buffer[offset], "?req=getsalt");
- IoTString *urlstr = new IoTString(buffer);
+ offset += sprintf(&buffer[offset], "?req=getsalt");
+ urlstr = new IoTString(buffer);
free(buffer);
-
- url = new URL(urlstr);
} 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();
try {
timer->startTime();
- int responsecode = http->getResponseCode();
+ int responsecode = getResponseCode(fd);
+ readHeaders(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);
+ close(fd);
+
+ salt = tmp;
+ timer->endTime();
+ return true;
} catch (SocketTimeoutException *e) {
timer->endTime();
throw new ServerException("getSalt failed", ServerException_TypeInputTimeout);
return buffer->array();
}
+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> *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 {
- IvParameterSpec *ivSpec = new IvParameterSpec(ivBytes);
- Cipher *cipher = Cipher_getInstance("AES/CTR/NoPadding");
- cipher->init(Cipher_ENCRYPT_MODE, key, ivSpec);
- Array<char> *encryptedBytes = cipher->doFinal(rawData);
+ 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());
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");
}
* numbers.
*/
Array<Slot *> *CloudComm::putSlot(Slot *slot, int max) {
+ int fd = -1;
try {
if (salt == NULL) {
if (!getSalt()) {
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();
}
try {
+ int respcode = getResponseCode(fd);
+ readHeaders(fd);
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)) {
+ 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");
}
* sequencenumber or newer->
*/
Array<Slot *> *CloudComm::getSlots(int64_t sequencenumber) {
+ int fd = -1;
try {
if (salt == NULL) {
if (!getSalt()) {
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();
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"->getBytes()))
- throw new Error("Bad Response: " + new String(resptype));
+ if (!resptype->equals(getslot))
+ throw new Error("Bad Response: ");
- return processSlots(dis);
+ Array<Slot*> * tmp=processSlots(fd);
+ close(fd);
+ return tmp;
} catch (SocketTimeoutException *e) {
timer->endTime();
+ close(fd);
throw new ServerException("getSlots failed", ServerException_TypeInputTimeout);
} catch (Exception *e) {
throw new Error("getSlots failed");
* 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());
+ 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) {
+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());
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 (!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) {
}
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...");
}
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))
// 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());
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...");
- }
}
}
projects / iotcloud.git / blobdiff