/* 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