version2/src/server_malicious_switch_slot/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
 160                 int seqnt = seqn;
 161                 if (seqn > 30)
 162                 {
 163                         seqnt--;
 164                 }
 165
 166                 char *filename = getSlotFileName(seqnt);
 167                 if (stat(filename, &st) == 0) {
 168                         fdarray[index] = open(filename, O_RDONLY);
 169                         filesizes[index] = st.st_size;
 170                         numbytes += filesizes[index];
 171                 } else {
 172                         fdarray[index] = -1;
 173                         filesizes[index] = 0;
 174                 }
 175                 delete filename;
 176         }
 177         const char header[] = "getslot";
 178
 179         /* Size is the header + the payload + space for number of requests
 180                  plus sizes of each slot */
 181
 182         long long size = sizeof(header) - 1 + sizeof(numrequeststosend) + 4 * numrequeststosend + numbytes;
 183         char * response = new char[size];
 184         long long offset = 0;
 185         memcpy(response, header, sizeof(header) - 1);
 186         offset += sizeof(header) - 1;
 187         int numreq = htonl(numrequeststosend);
 188         memcpy(response + offset, &numreq, sizeof(numreq));
 189         offset += sizeof(numrequeststosend);
 190         for (int i = 0; i < numrequeststosend; i++) {
 191                 int filesize = htonl(filesizes[i]);
 192                 memcpy(response + offset, &filesize, sizeof(filesize));
 193                 offset += sizeof(int);
 194         }
 195
 196         /* Read the file data into the buffer */
 197         for (int i = 0; i < numrequeststosend; i++) {
 198                 if (fdarray[i] >= 0) {
 199                         doRead(fdarray[i], response + offset, filesizes[i]);
 200                         offset += filesizes[i];
 201                 }
 202         }
 203
 204         /* Send the response out to the webserver. */
 205         sendResponse(response, size);
 206
 207         /* Delete the response buffer and close the files. */
 208         delete response;
 209         for (int i = 0; i < numrequeststosend; i++) {
 210                 if (fdarray[i] >= 0)
 211                         close(fdarray[i]);
 212         }
 213 }
 214
 215 /**
 216  * The method setSalt handles a setSalt request from the client.
 217  */
 218 void IoTQuery::setSalt() {
 219         /* Write the slot data we received to a SLOT file */
 220         char *filename = getSaltFileName();
 221         int saltfd = open(filename, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
 222         doWrite(saltfd, data, length);
 223         char response[0];
 224         sendResponse(response, 0);
 225         close(saltfd);
 226         delete filename;
 227 }
 228
 229 /**
 230  * The method getSalt handles a getSalt request from the client.
 231  */
 232
 233 void IoTQuery::getSalt() {
 234         /* Write the slot data we received to a SLOT file */
 235         char *filename = getSaltFileName();
 236         int filesize = 0;
 237         struct stat st;
 238         if (stat(filename, &st) == 0) {
 239                 filesize = st.st_size;
 240         } else {
 241                 char response[0];
 242                 sendResponse(response, 0);
 243                 delete filename;
 244                 return;
 245         }
 246         int saltfd = open(filename, O_RDONLY);
 247         int responsesize = filesize + sizeof(int);
 248         char * response = new char[responsesize];
 249         doRead(saltfd, response + sizeof(int), filesize);
 250         int n_filesize = htonl(filesize);
 251         *((int*) response) = n_filesize;
 252         sendResponse(response, responsesize);
 253         close(saltfd);
 254         delete filename;
 255         delete response;
 256 }
 257
 258 /**
 259  *      The method putSlot handles a putSlot request from the client
 260  */
 261
 262 void IoTQuery::putSlot() {
 263         /* Check if the request is stale and send update in that case.  This
 264                  servers as an implicit failure of the request. */
 265         if (requestsequencenumber != (newestentry + 1)) {
 266                 getSlot();
 267                 return;
 268         }
 269
 270         /* See if we have too many slots and if so, delete the old one */
 271         int numberofliveslots = (int) ((newestentry - oldestentry) + 1);
 272         if (numberofliveslots >=  numqueueentries) {
 273                 removeOldestSlot();
 274         }
 275
 276         /* Write the slot data we received to a SLOT file */
 277         char *filename = getSlotFileName(requestsequencenumber);
 278         int slotfd = open(filename, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
 279         doWrite(slotfd, data, length);
 280         close(slotfd);
 281         delete filename;
 282         newestentry = requestsequencenumber;
 283
 284         /* Update the seuqence numbers and other status file information. */
 285         updateStatusFile();
 286
 287         /* Send response acknowledging success */
 288         char command[] = "putslot";
 289         sendResponse(command, sizeof(command) - 1);
 290 }
 291
 292 /**
 293  * Method sends response.  It wraps in appropriate headers for web
 294  * server.
 295  */
 296
 297 void IoTQuery::sendResponse(char * bytes, int len) {
 298         cout << "Accept-Ranges: bytes\r\n"
 299              << "Content-Length: " << len << "\r\n"
 300              << "\r\n";
 301         cout.write(bytes, len);
 302         cout << flush;
 303 }
 304
 305 /**
 306  *      Computes the name for a slot file for the given sequence number.
 307  */
 308
 309 char * IoTQuery::getSlotFileName(long long seqnum) {
 310         int directorylen = strlen(directory);
 311
 312         /* Size is 19 digits for ASCII representation of a long + 4
 313                  characters for SLOT string + 1 character for null termination +
 314                  directory size*/
 315
 316         char * filename = new char[25 + directorylen];
 317         snprintf(filename, 25 + directorylen, "%s/SLOT%lld", directory, seqnum);
 318         return filename;
 319 }
 320
 321 /**
 322  *      Computes the name for a salt file
 323  */
 324
 325 char * IoTQuery::getSaltFileName() {
 326         int directorylen = strlen(directory);
 327
 328         /* Size is 4 characters for SALT string + 1 character for null
 329                  termination + directory size*/
 330
 331         char * filename = new char[6 + directorylen];
 332         snprintf(filename, 6 + directorylen, "%s/SALT", directory);
 333         return filename;
 334 }
 335
 336 /**
 337  *  Removes the oldest slot file
 338  */
 339
 340 void IoTQuery::removeOldestSlot() {
 341         if (oldestentry != 0) {
 342                 char * filename = getSlotFileName(oldestentry);
 343                 unlink(filename);
 344                 delete filename;
 345         }
 346         oldestentry++;
 347 }
 348
 349 /**
 350  * Processes the query sent to the fastcgi handler.
 351  */
 352
 353 void IoTQuery::processQuery() {
 354         getQuery();
 355         getDirectory();
 356         // readData();
 357         if (!readData())
 358         {
 359                 cerr << "No Data Available" << endl;
 360                 return;
 361         }
 362
 363
 364         /* Verify that we receive a post request. */
 365         if (strncmp(method, "POST", 4) != 0) {
 366                 cerr << "Not POST Request" << endl;
 367                 return;
 368         }
 369
 370         /* Make sure the directory is okay. */
 371         if (directory == NULL ||
 372                 !checkDirectory()) {
 373                 cerr << "Directory " << directory << " does not exist" << endl;
 374                 return;
 375         }
 376
 377         /* Get queue state from the status file.  If it doesn't exist,
 378                  create it. */
 379         if (!openStatusFile()) {
 380                 cerr << "Failed to open status file" << endl;
 381                 return;
 382         }
 383
 384         /* Lock status file to keep other requests out. */
 385         flock(fd, LOCK_EX);
 386
 387         /* Decode query. */
 388         decodeQuery();
 389
 390         /* Handle request. */
 391         if (reqGetSlot)
 392                 getSlot();
 393         else if (reqPutSlot)
 394                 putSlot();
 395         else if (reqSetSalt)
 396                 setSalt();
 397         else if (reqGetSalt)
 398                 getSalt();
 399         else {
 400                 cerr << "No recognized request" << endl;
 401                 return;
 402         }
 403 }
 404
 405 /**
 406  * Reads in data for request.  This is used for the slot to be
 407  * inserted.
 408  */
 409
 410 bool IoTQuery::readData() {
 411         if (length != 0) {
 412                 data = new char[length + 1];
 413                 memset(data, 0, length + 1);
 414                 cin.read(data, length);
 415         }
 416
 417         do {
 418                 char dummy;
 419                 cin >> dummy;
 420         } while (!cin.eof());
 421
 422         if (length != 0)
 423         {
 424                 if (cin.gcount() != length)
 425                 {
 426                         return false;
 427                 }
 428         }
 429
 430         return true;
 431 }
 432
 433
 434 /**
 435  * Reads relevant environmental variables to find out the request.
 436  */
 437
 438 void IoTQuery::getQuery() {
 439         uri = FCGX_GetParam(uri_str, request->envp);
 440         query = FCGX_GetParam(query_str, request->envp);
 441         method = FCGX_GetParam(method_str, request->envp);
 442         iotcloudroot = FCGX_GetParam(iotcloudroot_str, request->envp);
 443
 444         /** We require the content-length header to be sent. */
 445         char * reqlength = FCGX_GetParam(length_str, request->envp);
 446         if (reqlength) {
 447                 length = strtoll(reqlength, NULL, 10);
 448         } else {
 449                 length = 0;
 450         }
 451 }
 452
 453 /**
 454  *  Initializes directory field from environmental variables.
 455  */
 456
 457 void IoTQuery::getDirectory() {
 458         char * split = strchr((char *)uri, '?');
 459         if (split == NULL)
 460                 return;
 461         int split_len = (int) (split - uri);
 462         int rootdir_len = strlen(iotcloudroot);
 463         int directory_len = split_len + rootdir_len + 1;
 464         directory = new char[directory_len];
 465         memcpy(directory, iotcloudroot, rootdir_len);
 466         memcpy(directory + rootdir_len, uri, split_len);
 467         directory[directory_len - 1] = 0;
 468 }
 469
 470 /**
 471  * Helper function that is used to read the status file.
 472  */
 473
 474 int doread(int fd, void *ptr, size_t count, off_t offset) {
 475         do {
 476                 size_t bytesread = pread(fd, ptr, count, offset);
 477                 if (bytesread == count) {
 478                         return 1;
 479                 } else if (bytesread == 0) {
 480                         return 0;
 481                 }
 482         } while (1);
 483 }
 484
 485
 486 /**
 487  * Writes the current state to the status file.
 488  */
 489
 490 void IoTQuery::updateStatusFile() {
 491         pwrite(fd, &numqueueentries, sizeof(numqueueentries), OFFSET_MAX);
 492         pwrite(fd, &oldestentry, sizeof(oldestentry), OFFSET_OLD);
 493         pwrite(fd, &newestentry, sizeof(newestentry), OFFSET_NEW);
 494 }
 495
 496 /**
 497  * Reads in queue state from the status file.  Returns true if
 498  * successful.
 499  */
 500
 501 bool IoTQuery::openStatusFile() {
 502         char statusfile[] = "queuestatus";
 503         int len = strlen(directory);
 504
 505         char * filename = new char[len + sizeof(statusfile) + 2];
 506         memcpy(filename, directory, len);
 507         filename[len] = '/';
 508         memcpy(filename + len + 1, statusfile, sizeof(statusfile));
 509         filename[len + sizeof(statusfile) + 1] = 0;
 510         fd = open(filename, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
 511         delete filename;
 512
 513         if (fd < 0) {
 514                 cerr << strerror(errno) << " error opening statusfile" << endl;
 515                 return false;
 516         }
 517
 518         /* Read in queue size, oldest sequence number, and newest sequence number. */
 519         int size;
 520         int needwrite = 0;
 521         if (doread(fd, &size, sizeof(size), OFFSET_MAX))
 522                 numqueueentries = size;
 523         else
 524                 needwrite = 1;
 525
 526         long long entry;
 527         if (doread(fd, &entry, sizeof(entry), OFFSET_OLD))
 528                 oldestentry = entry;
 529         else
 530                 needwrite = 1;
 531
 532         if (doread(fd, &entry, sizeof(entry), OFFSET_NEW))
 533                 newestentry = entry;
 534         else
 535                 needwrite = 1;
 536
 537         if (needwrite)
 538                 updateStatusFile();
 539
 540         return true;
 541 }
 542
 543