Quelle nsID.cpp Sprache: C

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

#include <limits.h>

#include "MainThreadUtils.h"
#include "mozilla/Assertions.h"
#include "mozilla/RandomNum.h"
#include "mozilla/Sprintf.h"
#include "nss.h"
#include "ScopedNSSTypes.h"

[[nodiscard]] static bool GenerateRandomBytesFromNSS(void* aBuffer,
                                                     size_t aLength) {
  MOZ_ASSERT(aBuffer);

  // Bounds check that we can safely truncate size_t `aLength` to an int.
  if (aLength == 0 || aLength > INT_MAX) {
    MOZ_ASSERT_UNREACHABLE("Bad aLength");
    return false;
  }
  int len = static_cast<int>(aLength);

  // Only try to use NSS on the main thread.
  if (!NS_IsMainThread() || !NSS_IsInitialized()) {
    return false;
  }

  mozilla::UniquePK11SlotInfo slot(PK11_GetInternalSlot());
  if (!slot) {
    MOZ_ASSERT_UNREACHABLE("Null slot");
    return false;
  }

  SECStatus srv = PK11_GenerateRandomOnSlot(
      slot.get(), static_cast<unsigned char*>(aBuffer), len);
  MOZ_ASSERT(srv == SECSuccess);
  return (srv == SECSuccess);
}

nsresult nsID::GenerateUUIDInPlace(nsID& aId) {
  // Firefox needs to generate some UUIDs before NSS has been initialized. We
  // prefer NSS's RNG, but if NSS is not available yet or returns an error, fall
  // back to MFBT's GenerateRandomBytes().
  if (!GenerateRandomBytesFromNSS(&aId, sizeof(nsID)) &&
      !mozilla::GenerateRandomBytesFromOS(&aId, sizeof(nsID))) {
    MOZ_ASSERT_UNREACHABLE("GenerateRandomBytesFromOS() failed");
    return NS_ERROR_NOT_AVAILABLE;
  }

  // Put in the version
  aId.m2 &= 0x0fff;
  aId.m2 |= 0x4000;

  // Put in the variant
  aId.m3[0] &= 0x3f;
  aId.m3[0] |= 0x80;

  return NS_OK;
}

nsID nsID::GenerateUUID() {
  nsID uuid;
  nsresult rv = GenerateUUIDInPlace(uuid);
  MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
  return uuid;
}

void nsID::Clear() {
  m0 = 0;
  m1 = 0;
  m2 = 0;
  memset(m3, 0, sizeof(m3));
}

/**
* Multiplies the_int_var with 16 (0x10) and adds the value of the
* hexadecimal digit the_char. If it fails it returns false from
* the function it's used in.
*/

#define ADD_HEX_CHAR_TO_INT_OR_RETURN_FALSE(the_char, the_int_var) \
  the_int_var = (the_int_var << 4) + the_char;                     \
  if (the_char >= '0' && the_char <= '9')                          \
    the_int_var -= '0';                                            \
  else if (the_char >= 'a' && the_char <= 'f')                     \
    the_int_var -= 'a' - 10;                                       \
  else if (the_char >= 'A' && the_char <= 'F')                     \
    the_int_var -= 'A' - 10;                                       \
  else                                                             \
    return false

/**
* Parses number_of_chars characters from the char_pointer pointer and
* puts the number in the dest_variable. The pointer is moved to point
* at the first character after the parsed ones. If it fails it returns
* false from the function the macro is used in.
*/

#define PARSE_CHARS_TO_NUM(char_pointer, dest_variable, number_of_chars) \
  do {                                                                   \
    int32_t _i = number_of_chars;                                        \
    dest_variable = 0;                                                   \
    while (_i) {                                                         \
      ADD_HEX_CHAR_TO_INT_OR_RETURN_FALSE(*char_pointer, dest_variable); \
      char_pointer++;                                                    \
      _i--;                                                              \
    }                                                                    \
  } while (0)

/**
* Parses a hyphen from the char_pointer string. If there is no hyphen there
* the function returns false from the function it's used in. The
* char_pointer is advanced one step.
*/

#define PARSE_HYPHEN(char_pointer) \
  if (*(char_pointer++) != '-') return false

/*
* Turns a {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} string into
* an nsID. It can also handle the old format without the { and }.
*/

bool nsID::Parse(const char* aIDStr) {
  /* Optimized for speed */
  if (!aIDStr) {
    return false;
  }

  bool expectFormat1 = (aIDStr[0] == '{');
  if (expectFormat1) {
    ++aIDStr;
  }

  PARSE_CHARS_TO_NUM(aIDStr, m0, 8);
  PARSE_HYPHEN(aIDStr);
  PARSE_CHARS_TO_NUM(aIDStr, m1, 4);
  PARSE_HYPHEN(aIDStr);
  PARSE_CHARS_TO_NUM(aIDStr, m2, 4);
  PARSE_HYPHEN(aIDStr);
  int i;
  for (i = 0; i < 2; ++i) {
    PARSE_CHARS_TO_NUM(aIDStr, m3[i], 2);
  }
  PARSE_HYPHEN(aIDStr);
  while (i < 8) {
    PARSE_CHARS_TO_NUM(aIDStr, m3[i], 2);
    i++;
  }

  return expectFormat1 ? *aIDStr == '}' : true;
}

#ifndef XPCOM_GLUE_AVOID_NSPR

/*
* Returns a managed string in {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
* format.
*/
nsIDToCString nsID::ToString() const { return nsIDToCString(*this); }

static const char sHexChars[256 * 2 + 1] =
    "000102030405060708090a0b0c0d0e0f"
    "101112131415161718191a1b1c1d1e1f"
    "202122232425262728292a2b2c2d2e2f"
    "303132333435363738393a3b3c3d3e3f"
    "404142434445464748494a4b4c4d4e4f"
    "505152535455565758595a5b5c5d5e5f"
    "606162636465666768696a6b6c6d6e6f"
    "707172737475767778797a7b7c7d7e7f"
    "808182838485868788898a8b8c8d8e8f"
    "909192939495969798999a9b9c9d9e9f"
    "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
    "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
    "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
    "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
    "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
    "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";

// Writes a zero-padded 8-bit integer as lowercase hex into aDest[0..2]
static void ToHex8Bit(uint8_t aValue, char* aDest) {
  aDest[0] = sHexChars[2 * aValue];
  aDest[1] = sHexChars[2 * aValue + 1];
}

// Writes a zero-padded 16-bit integer as lowercase hex into aDest[0..4]
static void ToHex16Bit(uint16_t aValue, char* aDest) {
  const uint8_t hi = (aValue >> 8);
  const uint8_t lo = aValue;
  ToHex8Bit(hi, &aDest[0]);
  ToHex8Bit(lo, &aDest[2]);
}

// Writes a zero-padded 32-bit integer as lowercase hex into aDest[0..8]
static void ToHex32Bit(uint32_t aValue, char* aDest) {
  const uint16_t hi = (aValue >> 16);
  const uint16_t lo = aValue;
  ToHex16Bit(hi, &aDest[0]);
  ToHex16Bit(lo, &aDest[4]);
}

void nsID::ToProvidedString(char (&aDest)[NSID_LENGTH]) const {
  // Stringify manually, for best performance.
  //
  // "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}"
  // "{ecc35fd2-9029-4287-a826-b0a241d48d31}"
  aDest[0] = '{';
  ToHex32Bit(m0, &aDest[1]);
  aDest[9] = '-';
  ToHex16Bit(m1, &aDest[10]);
  aDest[14] = '-';
  ToHex16Bit(m2, &aDest[15]);
  aDest[19] = '-';
  ToHex8Bit(m3[0], &aDest[20]);
  ToHex8Bit(m3[1], &aDest[22]);
  aDest[24] = '-';
  ToHex8Bit(m3[2], &aDest[25]);
  ToHex8Bit(m3[3], &aDest[27]);
  ToHex8Bit(m3[4], &aDest[29]);
  ToHex8Bit(m3[5], &aDest[31]);
  ToHex8Bit(m3[6], &aDest[33]);
  ToHex8Bit(m3[7], &aDest[35]);
  aDest[37] = '}';
  aDest[38] = '\0';
}

#endif  // XPCOM_GLUE_AVOID_NSPR

nsID* nsID::Clone() const {
  auto id = static_cast<nsID*>(moz_xmalloc(sizeof(nsID)));
  *id = *this;
  return id;
}

quality88%

¤ Dauer der Verarbeitung: 0.28 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.