/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "CacheHashUtils.h"

#include "mozilla/BasePrincipal.h"

#include "plstr.h"

namespace mozilla {

namespace net {

/**

 *  CacheHash::Hash(const char * key, uint32_t initval)

 *

 *  See http://burtleburtle.net/bob/hash/evahash.html for more information

 *  about this hash function.

 *

 *  This algorithm is used to check the data integrity.

 */

static inline void hashmix(uint32_t &a, uint32_t &b, uint32_t &c) {

  a -= b;

  a -= c;

  a ^= (c >> 13);

  b -= c;

  b -= a;

  b ^= (a << 8);

  c -= a;

  c -= b;

  c ^= (b >> 13);

  a -= b;

  a -= c;

  a ^= (c >> 12);

  b -= c;

  b -= a;

  b ^= (a << 16);

  c -= a;

  c -= b;

  c ^= (b >> 5);

  a -= b;

  a -= c;

  a ^= (c >> 3);

  b -= c;

  b -= a;

  b ^= (a << 10);

  c -= a;

  c -= b;

  c ^= (b >> 15);

}

CacheHash::Hash32_t CacheHash::Hash(const char *aData, uint32_t aSize,

                                    uint32_t aInitval) {

  const uint8_t *k = reinterpret_cast<const uint8_t *>(aData);

  uint32_t a, b, c, len;

  /* Set up the internal state */

  len = aSize;

  a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */

  c = aInitval;       /* variable initialization of internal state */

  /*---------------------------------------- handle most of the key */

  while (len >= 12) {

    a += k[0] + (uint32_t(k[1]) << 8) + (uint32_t(k[2]) << 16) +

         (uint32_t(k[3]) << 24);

    b += k[4] + (uint32_t(k[5]) << 8) + (uint32_t(k[6]) << 16) +

         (uint32_t(k[7]) << 24);

    c += k[8] + (uint32_t(k[9]) << 8) + (uint32_t(k[10]) << 16) +

         (uint32_t(k[11]) << 24);

    hashmix(a, b, c);

    k += 12;

    len -= 12;

  }

  /*------------------------------------- handle the last 11 bytes */

  c += aSize;

  switch (len) { /* all the case statements fall through */

    case 11:

      c += (uint32_t(k[10]) << 24);

      MOZ_FALLTHROUGH;

    case 10:

      c += (uint32_t(k[9]) << 16);

      MOZ_FALLTHROUGH;

    case 9:

      c += (uint32_t(k[8]) << 8);

      MOZ_FALLTHROUGH;

    /* the low-order byte of c is reserved for the length */

    case 8:

      b += (uint32_t(k[7]) << 24);

      MOZ_FALLTHROUGH;

    case 7:

      b += (uint32_t(k[6]) << 16);

      MOZ_FALLTHROUGH;

    case 6:

      b += (uint32_t(k[5]) << 8);

      MOZ_FALLTHROUGH;

    case 5:

      b += k[4];

      MOZ_FALLTHROUGH;

    case 4:

      a += (uint32_t(k[3]) << 24);

      MOZ_FALLTHROUGH;

    case 3:

      a += (uint32_t(k[2]) << 16);

      MOZ_FALLTHROUGH;

    case 2:

      a += (uint32_t(k[1]) << 8);

      MOZ_FALLTHROUGH;

    case 1:

      a += k[0];

      /* case 0: nothing left to add */

  }

  hashmix(a, b, c);

  return c;

}

CacheHash::Hash16_t CacheHash::Hash16(const char *aData, uint32_t aSize,

                                      uint32_t aInitval) {

  Hash32_t hash = Hash(aData, aSize, aInitval);

  return (hash & 0xFFFF);

}

NS_IMPL_ISUPPORTS0(CacheHash)

CacheHash::CacheHash(uint32_t aInitval)

    : mA(0x9e3779b9),

      mB(0x9e3779b9),

      mC(aInitval),

      mPos(0),

      mBuf(0),

      mBufPos(0),

      mLength(0),

      mFinalized(false) {}

void CacheHash::Feed(uint32_t aVal, uint8_t aLen) {

  switch (mPos) {

    case 0:

      mA += aVal;

      mPos++;

      break;

    case 1:

      mB += aVal;

      mPos++;

      break;

    case 2:

      mPos = 0;

      if (aLen == 4) {

        mC += aVal;

        hashmix(mA, mB, mC);

      } else {

        mC += aVal << 8;

      }

  }

  mLength += aLen;

}

void CacheHash::Update(const char *aData, uint32_t aLen) {

  const uint8_t *data = reinterpret_cast<const uint8_t *>(aData);

  MOZ_ASSERT(!mFinalized);

  if (mBufPos) {

    while (mBufPos != 4 && aLen) {

      mBuf += uint32_t(*data) << 8 * mBufPos;

      data++;

      mBufPos++;

      aLen--;

    }

    if (mBufPos == 4) {

      mBufPos = 0;

      Feed(mBuf);

      mBuf = 0;

    }

  }

  if (!aLen) return;

  while (aLen >= 4) {

    Feed(data[0] + (uint32_t(data[1]) << 8) + (uint32_t(data[2]) << 16) +

         (uint32_t(data[3]) << 24));

    data += 4;

    aLen -= 4;

  }

  switch (aLen) {

    case 3:

      mBuf += data[2] << 16;

      MOZ_FALLTHROUGH;

    case 2:

      mBuf += data[1] << 8;

      MOZ_FALLTHROUGH;

    case 1:

      mBuf += data[0];

  }

  mBufPos = aLen;

}

CacheHash::Hash32_t CacheHash::GetHash() {

  if (!mFinalized) {

    if (mBufPos) {

      Feed(mBuf, mBufPos);

    }

    mC += mLength;

    hashmix(mA, mB, mC);

    mFinalized = true;

  }

  return mC;

}

CacheHash::Hash16_t CacheHash::GetHash16() {

  Hash32_t hash = GetHash();

  return (hash & 0xFFFF);

}

OriginAttrsHash GetOriginAttrsHash(const mozilla::OriginAttributes &aOA) {

  nsAutoCString suffix;

  aOA.CreateSuffix(suffix);

  SHA1Sum sum;

  SHA1Sum::Hash hash;

  sum.update(suffix.BeginReading(), suffix.Length());

  sum.finish(hash);

  return BigEndian::readUint64(&hash);

}

}  // namespace net

}  // namespace mozilla