version2/src/C/Slot.cc

   1 #include "Slot.h"
   2
   3 Slot::Slot(Table *_table, int64_t _seqnum, int64_t _machineid, char* _prevhmac, char* _hmac, int64_t _localSequenceNumber) {
   4   seqnum = _seqnum;
   5   machineid = _machineid;
   6   prevhmac = _prevhmac;
   7   hmac = _hmac;
   8   entries = new Vector<Entry*>();
   9   livecount = 1;
  10   seqnumlive = true;
  11   freespace = SLOT_SIZE - getBaseSize();
  12   table = _table;
  13   localSequenceNumber = _localSequenceNumber;
  14 }
  15
  16 Slot::Slot(Table *_table, int64_t _seqnum, int64_t _machineid, char* _prevhmac, int64_t _localSequenceNumber) {
  17   this(_table, _seqnum, _machineid, _prevhmac, NULL, _localSequenceNumber);
  18 }
  19
  20 Slot::Slot(Table *_table, int64_t _seqnum, int64_t _machineid, int64_t _localSequenceNumber) {
  21   this(_table, _seqnum, _machineid, new char[HMAC_SIZE], NULL, _localSequenceNumber);
  22 }
  23
  24 Entry * Slot::addEntry(Entry * e) {
  25   e = e->getCopy(this);
  26   entries->add(e);
  27   livecount++;
  28   freespace -= e->getSize();
  29   return e;
  30 }
  31
  32 void Slot::removeEntry(Entry *e) {
  33   entries->remove(e);
  34   livecount--;
  35   freespace += e->getSize();
  36 }
  37
  38 void Slot::addShallowEntry(Entry *e) {
  39   entries->add(e);
  40   livecount++;
  41   freespace -= e->getSize();
  42 }
  43
  44 /**
  45  * Returns true if the slot has free space to hold the entry without
  46  * using its reserved space. */
  47
  48 bool Slot::hasSpace(Entry *e) {
  49   int newfreespace = freespace - e->getSize();
  50   return newfreespace >= 0;
  51 }
  52
  53 Vector<Entry*> * Slot::getEntries() {
  54   return entries;
  55 }
  56
  57 Slot * Slotdecode(Table * table, char* array, Mac * mac) {
  58   mac->update(array, HMAC_SIZE, array.length - HMAC_SIZE);
  59   char* realmac = mac->doFinal();
  60
  61   ByteBuffer * bb = ByteBuffer_wrap(array);
  62   char* hmac = new char[HMAC_SIZE];
  63   char* prevhmac = new char[HMAC_SIZE];
  64   bb->get(hmac);
  65   bb->get(prevhmac);
  66   if (!Arrays.equals(realmac, hmac))
  67     throw new Error("Server Error: Invalid HMAC!  Potential Attack!");
  68
  69   int64_t seqnum = bb->getLong();
  70   int64_t machineid = bb->getLong();
  71   int numentries = bb->getInt();
  72   Slot slot = new Slot(table, seqnum, machineid, prevhmac, hmac, -1);
  73
  74   for (int i = 0; i < numentries; i++) {
  75     slot->addShallowEntry(Entry->decode(slot, bb));
  76   }
  77
  78   return slot;
  79 }
  80
  81 char* Slot::encode(Mac mac) {
  82   char* array = new char[SLOT_SIZE];
  83   ByteBuffer * bb = ByteBuffer_wrap(array);
  84   /* Leave space for the slot HMAC.  */
  85   bb->position(HMAC_SIZE);
  86   bb->put(prevhmac);
  87   bb->putLong(seqnum);
  88   bb->putLong(machineid);
  89   bb->putInt(entries->size());
  90   for (Entry entry : entries) {
  91     entry->encode(bb);
  92   }
  93   /* Compute our HMAC */
  94   mac->update(array, HMAC_SIZE, array.length - HMAC_SIZE);
  95   char* realmac = mac->doFinal();
  96   hmac = realmac;
  97   bb->position(0);
  98   bb->put(realmac);
  99   return array;
 100 }
 101
 102
 103 /**
 104  * Returns the live set of entries for this Slot.  Generates a fake
 105  * LastMessage entry to represent the information stored by the slot
 106  * itself.
 107  */
 108
 109 Vector<Entry*> *Slot::getLiveEntries(bool resize) {
 110   Vector<Entry*> *liveEntries = new Vector<Entry*>();
 111   for (Entry *entry : entries) {
 112     if (entry->isLive()) {
 113       if (!resize || entry->getType() != Entry->TypeTableStatus)
 114         liveEntries->add(entry);
 115     }
 116   }
 117
 118   if (seqnumlive && !resize)
 119     liveEntries->add(new LastMessage(this, machineid, seqnum));
 120
 121   return liveEntries;
 122 }
 123
 124
 125 /**
 126  * Records that a newer slot records the fact that this slot was
 127  * sent by the relevant machine.
 128  */
 129
 130 void Slot::setDead() {
 131   seqnumlive = false;
 132   decrementLiveCount();
 133 }
 134
 135 /**
 136  * Update the count of live entries.
 137  */
 138
 139 void Slot::decrementLiveCount() {
 140   livecount--;
 141   if (livecount == 0) {
 142     table->decrementLiveCount();
 143   }
 144 }
 145
 146 char* Slot::getSlotCryptIV() {
 147   ByteBuffer * buffer = ByteBuffer_allocate(CloudComm.IV_SIZE);
 148   buffer->putLong(machineid);
 149   int64_t localSequenceNumberShift = localSequenceNumber << 16;
 150   buffer->putLong(localSequenceNumberShift);
 151   return buffer->array();
 152 }