/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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 "CrashReporterMetadataShmem.h"

#include "mozilla/Attributes.h"

#include "mozilla/EnumeratedRange.h"

#include "nsISupportsImpl.h"

namespace mozilla {

namespace ipc {

using CrashReporter::Annotation;

enum class EntryType : uint8_t {

  None,

  Annotation,

};

CrashReporterMetadataShmem::CrashReporterMetadataShmem(const Shmem& aShmem)

 : mShmem(aShmem)

{

  MOZ_COUNT_CTOR(CrashReporterMetadataShmem);

}

CrashReporterMetadataShmem::~CrashReporterMetadataShmem()

{

  MOZ_COUNT_DTOR(CrashReporterMetadataShmem);

}

void

CrashReporterMetadataShmem::AnnotateCrashReport(Annotation aKey,

                                                const nsCString& aData)

{

  mAnnotations[aKey] = aData;

  SyncNotesToShmem();

}

void

CrashReporterMetadataShmem::AppendAppNotes(const nsCString& aData)

{

  mAppNotes.Append(aData);

  mAnnotations[Annotation::Notes] = mAppNotes;

  SyncNotesToShmem();

}

class MOZ_STACK_CLASS MetadataShmemWriter

{

public:

  explicit MetadataShmemWriter(const Shmem& aShmem)

   : mCursor(aShmem.get<uint8_t>()),

     mEnd(mCursor + aShmem.Size<uint8_t>())

  {

    *mCursor = uint8_t(EntryType::None);

  }

  MOZ_MUST_USE bool WriteAnnotation(Annotation aKey, const nsCString& aValue) {

    // This shouldn't happen because Commit() guarantees mCursor < mEnd. But

    // we might as well be safe.

    if (mCursor >= mEnd) {

      return false;

    }

    // Save the current position so we can write the entry type if the entire

    // entry fits.

    uint8_t* start = mCursor++;

    if (!Write(aKey) || !Write(aValue)) {

      return false;

    }

    return Commit(start, EntryType::Annotation);

  }

private:

  // On success, append a new terminal byte. On failure, rollback the cursor.

  MOZ_MUST_USE bool Commit(uint8_t* aStart, EntryType aType) {

    MOZ_ASSERT(aStart < mEnd);

    MOZ_ASSERT(EntryType(*aStart) == EntryType::None);

    if (mCursor >= mEnd) {

      // No room for a terminating byte - rollback.

      mCursor = aStart;

      return false;

    }

    // Commit the entry and write a new terminal byte.

    *aStart = uint8_t(aType);

    *mCursor = uint8_t(EntryType::None);

    return true;

  }

  MOZ_MUST_USE bool Write(const nsCString& aString) {

    // 32-bit length is okay since our shmems are very small (16K),

    // a huge write would fail anyway.

    return Write(static_cast<uint32_t>(aString.Length())) &&

           Write(aString.get(), aString.Length());

  }

  template <typename T>

  MOZ_MUST_USE bool Write(const T& aT) {

    return Write(&aT, sizeof(T));

  }

Unexecuted instantiation: bool mozilla::ipc::MetadataShmemWriter::Write<CrashReporter::Annotation>(CrashReporter::Annotation const&)

Unexecuted instantiation: bool mozilla::ipc::MetadataShmemWriter::Write<unsigned int>(unsigned int const&)

  MOZ_MUST_USE bool Write(const void* aData, size_t aLength) {

    if (size_t(mEnd - mCursor) < aLength) {

      return false;

    }

    memcpy(mCursor, aData, aLength);

    mCursor += aLength;

    return true;

  }

 private:

  // The cursor (beginning at start) always points to a single byte

  // representing the next EntryType. An EntryType is either None,

  // indicating there are no more entries, or Annotation, meaning

  // two strings follow.

  //

  // Strings are written as a 32-bit length and byte sequence. After each new

  // entry, a None entry is always appended, and a subsequent entry will

  // overwrite this byte.

  uint8_t* mCursor;

  uint8_t* mEnd;

};

void

CrashReporterMetadataShmem::SyncNotesToShmem()

{

  MetadataShmemWriter writer(mShmem);

  for (auto key : MakeEnumeratedRange(Annotation::Count)) {

    if (!mAnnotations[key].IsEmpty()) {

      if (!writer.WriteAnnotation(key, mAnnotations[key])) {

        return;

      }

    }

  }

}

// Helper class to iterate over metadata entries encoded in shmem.

class MOZ_STACK_CLASS MetadataShmemReader

{

public:

  explicit MetadataShmemReader(const Shmem& aShmem)

   : mEntryType(EntryType::None)

  {

    mCursor = aShmem.get<uint8_t>();

    mEnd = mCursor + aShmem.Size<uint8_t>();

    // Advance to the first item, if any.

    Next();

  }

  bool Done() const {

    return mCursor >= mEnd || Type() == EntryType::None;

  }

  EntryType Type() const {

    return mEntryType;

  }

  void Next() {

    if (mCursor < mEnd) {

      mEntryType = EntryType(*mCursor++);

    } else {

      mEntryType = EntryType::None;

    }

  }

  template <typename T>

  bool Read(T* aOut) {

    return Read(aOut, sizeof(T));

  }

Unexecuted instantiation: bool mozilla::ipc::MetadataShmemReader::Read<unsigned int>(unsigned int*)

Unexecuted instantiation: bool mozilla::ipc::MetadataShmemReader::Read<CrashReporter::Annotation>(CrashReporter::Annotation*)

  bool Read(nsCString& aOut) {

    uint32_t length = 0;

    if (!Read(&length)) {

      return false;

    }

    const uint8_t* src = Read(length);

    if (!src) {

      return false;

    }

    aOut.Assign((const char *)src, length);

    return true;

  }

private:

  bool Read(void* aOut, size_t aLength) {

    const uint8_t* src = Read(aLength);

    if (!src) {

      return false;

    }

    memcpy(aOut, src, aLength);

    return true;

  }

  // If buffer has |aLength| bytes, return cursor and then advance it.

  // Otherwise, return null.

  const uint8_t* Read(size_t aLength) {

    if (size_t(mEnd - mCursor) < aLength) {

      return nullptr;

    }

    const uint8_t* result = mCursor;

    mCursor += aLength;

    return result;

  }

private:

  const uint8_t* mCursor;

  const uint8_t* mEnd;

  EntryType mEntryType;

};

void

CrashReporterMetadataShmem::ReadAppNotes(const Shmem& aShmem,

                                         AnnotationTable& aNotes)

{

  for (MetadataShmemReader reader(aShmem); !reader.Done(); reader.Next()) {

    switch (reader.Type()) {

      case EntryType::Annotation: {

        Annotation key;

        nsCString value;

        if (!reader.Read(&key) || !reader.Read(value)) {

          return;

        }

        aNotes[key] = value;

        break;

      }

      default:

        NS_ASSERTION(false, "Unknown metadata entry type");

        break;

    }

  }

}

} // namespace ipc

} // namespace mozilla