Adding test for encrypted cloud storage; Adding preparation timing test for Fidelius...
[iotcloud.git] / version2 / src / server / iotquery.cpp
1 #include "iotquery.h"
2 #include <string.h>
3 #include <sys/stat.h>
4 #include <sys/types.h>
5 #include <sys/file.h>
6 #include <fcntl.h>
7 #include <unistd.h>
8 #include <stdlib.h>
9 #include <errno.h>
10 #include <netinet/in.h>
11
12 using namespace std;
13
14 const char * query_str = "QUERY_STRING";
15 const char * uri_str = "REQUEST_URI";
16 const char * method_str = "REQUEST_METHOD";
17 const char * iotcloudroot_str = "IOTCLOUD_ROOT";
18 const char * length_str = "CONTENT_LENGTH";
19
20 IoTQuery::IoTQuery(FCGX_Request *request) :
21         request(request),
22         data(NULL),
23         directory(NULL),
24         uri(NULL),
25         query(NULL),
26         method(NULL),
27         iotcloudroot(NULL),
28         length(0),
29         oldestentry(0),
30         newestentry(0),
31         requestsequencenumber(0),
32         numqueueentries(DEFAULT_SIZE),
33         fd(-1),
34         reqGetSlot(false),
35         reqPutSlot(false),
36         reqSetSalt(false),
37         reqGetSalt(false) {
38 }
39
40 IoTQuery::~IoTQuery() {
41         if (fd >= 0)
42                 close(fd);
43         if (directory)
44                 delete directory;
45         if (data)
46                 delete data;
47 }
48
49 /**
50  *  Returns true if the account directory exists.
51  */
52
53 bool IoTQuery::checkDirectory() {
54         struct stat s;
55         int err = stat(directory, &s);
56         if (-1 == err)
57                 return false;
58         return S_ISDIR(s.st_mode);
59 }
60
61 /**
62  * Decodes query string from client. Extracts type of request,
63  * sequence number, and whether the request changes the number of
64  * slots.
65  */
66
67 void IoTQuery::decodeQuery() {
68         int len = strlen(query);
69         char * str = new char[len + 1];
70         memcpy(str, query, len + 1);
71         char *tok_ptr = str;
72
73         /* Parse commands */
74         char *command = strsep(&tok_ptr, "&");
75         if (strncmp(command, "req=putslot", 11) == 0)
76                 reqPutSlot = true;
77         else if (strncmp(command, "req=getslot", 11) == 0)
78                 reqGetSlot = true;
79         else if (strncmp(command, "req=setsalt", 11) == 0)
80                 reqSetSalt = true;
81         else if (strncmp(command, "req=getsalt", 11) == 0)
82                 reqGetSalt = true;
83
84         /* Load Sequence Number for request */
85         char *sequencenumber_str = strsep(&tok_ptr, "&");
86         if (sequencenumber_str != NULL &&
87                 strncmp(sequencenumber_str, "seq=", 4) == 0) {
88                 sequencenumber_str = strchr(sequencenumber_str, '=');
89                 if (sequencenumber_str != NULL) {
90                         requestsequencenumber = strtoll(sequencenumber_str + 1, NULL, 10);
91                 }
92         }
93
94         /* don't allow a really old sequence number */
95         if (requestsequencenumber < oldestentry)
96                 requestsequencenumber = oldestentry;
97
98         /* Update size if we get request */
99         char * numqueueentries_str = tok_ptr;
100         if (numqueueentries_str != NULL &&
101                 strncmp(numqueueentries_str, "max=", 4) == 0) {
102                 numqueueentries_str = strchr(numqueueentries_str, '=') + 1;
103                 numqueueentries = strtoll(numqueueentries_str, NULL, 10);
104         }
105
106         delete str;
107 }
108
109 /**
110  * Helper function to write data to file.
111  */
112
113 void doWrite(int fd, char *data, long long length) {
114         long long offset = 0;
115         do {
116                 long long byteswritten = write(fd, &data[offset], length);
117                 if (byteswritten > 0) {
118                         length -= byteswritten;
119                         offset += byteswritten;
120                 } else {
121                         cerr << "Bytes not written" << endl;
122                         if (byteswritten < 0) {
123                                 cerr << strerror(errno) << " error writing slot file" << endl;
124                         }
125                         return;
126                 }
127         } while (length != 0);
128 }
129
130 /** Helper function to read data from file. */
131 bool doRead(int fd, void *buf, int numbytes) {
132         int offset = 0;
133         char *ptr = (char *)buf;
134         do {
135                 int bytesread = read(fd, ptr + offset, numbytes);
136                 if (bytesread > 0) {
137                         offset += bytesread;
138                         numbytes -= bytesread;
139                 } else
140                         return false;
141         } while (numbytes != 0);
142         return true;
143 }
144
145 /**
146  * Function that handles a getSlot request.
147  */
148
149 void IoTQuery::getSlot() {
150         int numrequeststosend = (int)((newestentry - requestsequencenumber) + 1);
151         if (numrequeststosend < 0)
152                 numrequeststosend = 0;
153         long long numbytes = 0;
154         int filesizes[numrequeststosend];
155         int fdarray[numrequeststosend];
156         int index = 0;
157         for (long long seqn = requestsequencenumber; seqn <= newestentry; seqn++, index++) {
158                 struct stat st;
159                 char *filename = getSlotFileName(seqn);
160                 if (stat(filename, &st) == 0) {
161                         fdarray[index] = open(filename, O_RDONLY);
162                         filesizes[index] = st.st_size;
163                         numbytes += filesizes[index];
164                 } else {
165                         fdarray[index] = -1;
166                         filesizes[index] = 0;
167                 }
168                 delete filename;
169         }
170         const char header[] = "getslot";
171
172         /* Size is the header + the payload + space for number of requests
173                  plus sizes of each slot */
174
175         long long size = sizeof(header) - 1 + sizeof(numrequeststosend) + 4 * numrequeststosend + numbytes;
176         char * response = new char[size];
177         long long offset = 0;
178         memcpy(response, header, sizeof(header) - 1);
179         offset += sizeof(header) - 1;
180         int numreq = htonl(numrequeststosend);
181         memcpy(response + offset, &numreq, sizeof(numreq));
182         offset += sizeof(numrequeststosend);
183         for (int i = 0; i < numrequeststosend; i++) {
184                 int filesize = htonl(filesizes[i]);
185                 memcpy(response + offset, &filesize, sizeof(filesize));
186                 offset += sizeof(int);
187         }
188
189         /* Read the file data into the buffer */
190         for (int i = 0; i < numrequeststosend; i++) {
191                 if (fdarray[i] >= 0) {
192                         doRead(fdarray[i], response + offset, filesizes[i]);
193                         offset += filesizes[i];
194                 }
195         }
196
197         /* Send the response out to the webserver. */
198         sendResponse(response, size);
199
200         /* Delete the response buffer and close the files. */
201         delete response;
202         for (int i = 0; i < numrequeststosend; i++) {
203                 if (fdarray[i] >= 0)
204                         close(fdarray[i]);
205         }
206 }
207
208 /**
209  * The method setSalt handles a setSalt request from the client.
210  */
211 void IoTQuery::setSalt() {
212         /* Write the slot data we received to a SLOT file */
213         char *filename = getSaltFileName();
214         int saltfd = open(filename, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
215         doWrite(saltfd, data, length);
216         char response[0];
217         sendResponse(response, 0);
218         close(saltfd);
219         delete filename;
220 }
221
222 /**
223  * The method getSalt handles a getSalt request from the client.
224  */
225
226 void IoTQuery::getSalt() {
227         /* Write the slot data we received to a SLOT file */
228         char *filename = getSaltFileName();
229         int filesize = 0;
230         struct stat st;
231         if (stat(filename, &st) == 0) {
232                 filesize = st.st_size;
233         } else {
234                 char response[0];
235                 sendResponse(response, 0);
236                 delete filename;
237                 return;
238         }
239         int saltfd = open(filename, O_RDONLY);
240         int responsesize = filesize + sizeof(int);
241         char * response = new char[responsesize];
242         doRead(saltfd, response + sizeof(int), filesize);
243         int n_filesize = htonl(filesize);
244         *((int*) response) = n_filesize;
245         sendResponse(response, responsesize);
246         close(saltfd);
247         delete filename;
248         delete response;
249 }
250
251 /**
252  *      The method putSlot handles a putSlot request from the client
253  */
254
255 void IoTQuery::putSlot() {
256         /* Check if the request is stale and send update in that case.  This
257                  servers as an implicit failure of the request. */
258         if (requestsequencenumber != (newestentry + 1)) {
259                 getSlot();
260                 return;
261         }
262
263         /* See if we have too many slots and if so, delete the old one */
264         int numberofliveslots = (int) ((newestentry - oldestentry) + 1);
265         if (numberofliveslots >=  numqueueentries) {
266                 removeOldestSlot();
267         }
268
269         /* Write the slot data we received to a SLOT file */
270         char *filename = getSlotFileName(requestsequencenumber);
271         int slotfd = open(filename, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
272         doWrite(slotfd, data, length);
273         close(slotfd);
274         delete filename;
275         newestentry = requestsequencenumber;
276
277         /* Update the seuqence numbers and other status file information. */
278         updateStatusFile();
279
280         /* Send response acknowledging success */
281         char command[] = "putslot";
282         sendResponse(command, sizeof(command) - 1);
283 }
284
285 /**
286  * Method sends response.  It wraps in appropriate headers for web
287  * server.
288  */
289
290 void IoTQuery::sendResponse(char * bytes, int len) {
291         cout << "Accept-Ranges: bytes\r\n"
292              << "Content-Length: " << len << "\r\n"
293              << "\r\n";
294         cout.write(bytes, len);
295         cout << flush;
296 }
297
298 /**
299  *      Computes the name for a slot file for the given sequence number.
300  */
301
302 char * IoTQuery::getSlotFileName(long long seqnum) {
303         int directorylen = strlen(directory);
304
305         /* Size is 19 digits for ASCII representation of a long + 4
306                  characters for SLOT string + 1 character for null termination +
307                  directory size*/
308
309         char * filename = new char[25 + directorylen];
310         snprintf(filename, 25 + directorylen, "%s/SLOT%lld", directory, seqnum);
311         return filename;
312 }
313
314 /**
315  *      Computes the name for a salt file
316  */
317
318 char * IoTQuery::getSaltFileName() {
319         int directorylen = strlen(directory);
320
321         /* Size is 4 characters for SALT string + 1 character for null
322                  termination + directory size*/
323
324         char * filename = new char[6 + directorylen];
325         snprintf(filename, 6 + directorylen, "%s/SALT", directory);
326         return filename;
327 }
328
329 /**
330  *  Removes the oldest slot file
331  */
332
333 void IoTQuery::removeOldestSlot() {
334         if (oldestentry != 0) {
335                 char * filename = getSlotFileName(oldestentry);
336                 unlink(filename);
337                 delete filename;
338         }
339         oldestentry++;
340 }
341
342 /**
343  * Processes the query sent to the fastcgi handler.
344  */
345
346 void IoTQuery::processQuery() {
347         getQuery();
348         getDirectory();
349         // readData();
350         if (!readData())
351         {
352                 cerr << "No Data Available" << endl;
353                 return;
354         }
355
356
357         /* Verify that we receive a post request. */
358         if (strncmp(method, "POST", 4) != 0) {
359                 cerr << "Not POST Request" << endl;
360                 return;
361         }
362
363         /* Make sure the directory is okay. */
364         if (directory == NULL ||
365                 !checkDirectory()) {
366                 cerr << "Directory " << directory << " does not exist" << endl;
367                 return;
368         }
369
370         /* Get queue state from the status file.  If it doesn't exist,
371                  create it. */
372         if (!openStatusFile()) {
373                 cerr << "Failed to open status file" << endl;
374                 return;
375         }
376
377         /* Lock status file to keep other requests out. */
378         flock(fd, LOCK_EX);
379
380         /* Decode query. */
381         decodeQuery();
382
383         /* Handle request. */
384         if (reqGetSlot)
385                 getSlot();
386         else if (reqPutSlot)
387                 putSlot();
388         else if (reqSetSalt)
389                 setSalt();
390         else if (reqGetSalt)
391                 getSalt();
392         else {
393                 cerr << "No recognized request" << endl;
394                 return;
395         }
396 }
397
398 /**
399  * Reads in data for request.  This is used for the slot to be
400  * inserted.
401  */
402
403 bool IoTQuery::readData() {
404         if (length != 0) {
405                 data = new char[length + 1];
406                 memset(data, 0, length + 1);
407                 cin.read(data, length);
408         }
409
410         do {
411                 char dummy;
412                 cin >> dummy;
413         } while (!cin.eof());
414
415         if (length != 0)
416         {
417                 if (cin.gcount() != length)
418                 {
419                         return false;
420                 }
421         }
422
423         return true;
424 }
425
426
427 /**
428  * Reads relevant environmental variables to find out the request.
429  */
430
431 void IoTQuery::getQuery() {
432         uri = FCGX_GetParam(uri_str, request->envp);
433         query = FCGX_GetParam(query_str, request->envp);
434         method = FCGX_GetParam(method_str, request->envp);
435         iotcloudroot = FCGX_GetParam(iotcloudroot_str, request->envp);
436
437         /** We require the content-length header to be sent. */
438         char * reqlength = FCGX_GetParam(length_str, request->envp);
439         if (reqlength) {
440                 length = strtoll(reqlength, NULL, 10);
441         } else {
442                 length = 0;
443         }
444 }
445
446 /**
447  *  Initializes directory field from environmental variables.
448  */
449
450 void IoTQuery::getDirectory() {
451         char * split = strchr((char *)uri, '?');
452         if (split == NULL)
453                 return;
454         int split_len = (int) (split - uri);
455         int rootdir_len = strlen(iotcloudroot);
456         int directory_len = split_len + rootdir_len + 1;
457         directory = new char[directory_len];
458         memcpy(directory, iotcloudroot, rootdir_len);
459         memcpy(directory + rootdir_len, uri, split_len);
460         directory[directory_len - 1] = 0;
461 }
462
463 /**
464  * Helper function that is used to read the status file.
465  */
466
467 int doread(int fd, void *ptr, size_t count, off_t offset) {
468         do {
469                 size_t bytesread = pread(fd, ptr, count, offset);
470                 if (bytesread == count) {
471                         return 1;
472                 } else if (bytesread == 0) {
473                         return 0;
474                 }
475         } while (1);
476 }
477
478
479 /**
480  * Writes the current state to the status file.
481  */
482
483 void IoTQuery::updateStatusFile() {
484         pwrite(fd, &numqueueentries, sizeof(numqueueentries), OFFSET_MAX);
485         pwrite(fd, &oldestentry, sizeof(oldestentry), OFFSET_OLD);
486         pwrite(fd, &newestentry, sizeof(newestentry), OFFSET_NEW);
487 }
488
489 /**
490  * Reads in queue state from the status file.  Returns true if
491  * successful.
492  */
493
494 bool IoTQuery::openStatusFile() {
495         char statusfile[] = "queuestatus";
496         int len = strlen(directory);
497
498         char * filename = new char[len + sizeof(statusfile) + 2];
499         memcpy(filename, directory, len);
500         filename[len] = '/';
501         memcpy(filename + len + 1, statusfile, sizeof(statusfile));
502         filename[len + sizeof(statusfile) + 1] = 0;
503         fd = open(filename, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
504         delete filename;
505
506         if (fd < 0) {
507                 cerr << strerror(errno) << " error opening statusfile" << endl;
508                 return false;
509         }
510
511         /* Read in queue size, oldest sequence number, and newest sequence number. */
512         int size;
513         int needwrite = 0;
514         if (doread(fd, &size, sizeof(size), OFFSET_MAX))
515                 numqueueentries = size;
516         else
517                 needwrite = 1;
518
519         long long entry;
520         if (doread(fd, &entry, sizeof(entry), OFFSET_OLD))
521                 oldestentry = entry;
522         else
523                 needwrite = 1;
524
525         if (doread(fd, &entry, sizeof(entry), OFFSET_NEW))
526                 newestentry = entry;
527         else
528                 needwrite = 1;
529
530         if (needwrite)
531                 updateStatusFile();
532
533         return true;
534 }
535
536