DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Header

Mercurial (fddffdeab170)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
/* -*- 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/. */

#if defined(XP_WIN)
#include <windows.h>
#include <objbase.h>
#elif defined(XP_MACOSX)
#include <CoreFoundation/CoreFoundation.h>
#else
#include <stdlib.h>
#include "prrng.h"
#endif

#include "nsUUIDGenerator.h"

#ifdef ANDROID
extern "C" NS_EXPORT void arc4random_buf(void*, size_t);
#endif

using namespace mozilla;

NS_IMPL_ISUPPORTS(nsUUIDGenerator, nsIUUIDGenerator)

nsUUIDGenerator::nsUUIDGenerator()
  : mLock("nsUUIDGenerator.mLock")
{
}

nsUUIDGenerator::~nsUUIDGenerator()
{
}

nsresult
nsUUIDGenerator::Init()
{
  // We're a service, so we're guaranteed that Init() is not going
  // to be reentered while we're inside Init().

#if !defined(XP_WIN) && !defined(XP_MACOSX) && !defined(HAVE_ARC4RANDOM)
  /* initialize random number generator using NSPR random noise */
  unsigned int seed;

  size_t bytes = 0;
  while (bytes < sizeof(seed)) {
    size_t nbytes = PR_GetRandomNoise(((unsigned char*)&seed) + bytes,
                                      sizeof(seed) - bytes);
    if (nbytes == 0) {
      return NS_ERROR_FAILURE;
    }
    bytes += nbytes;
  }

  /* Initialize a new RNG state, and immediately switch
   * back to the previous one -- we want to use mState
   * only for our own calls to random().
   */
  mSavedState = initstate(seed, mState, sizeof(mState));
  setstate(mSavedState);

  mRBytes = 4;
#ifdef RAND_MAX
  if ((unsigned long)RAND_MAX < 0xffffffffUL) {
    mRBytes = 3;
  }
  if ((unsigned long)RAND_MAX < 0x00ffffffUL) {
    mRBytes = 2;
  }
  if ((unsigned long)RAND_MAX < 0x0000ffffUL) {
    mRBytes = 1;
  }
  if ((unsigned long)RAND_MAX < 0x000000ffUL) {
    return NS_ERROR_FAILURE;
  }
#endif

#endif /* non XP_WIN and non XP_MACOSX and non ARC4RANDOM */

  return NS_OK;
}

NS_IMETHODIMP
nsUUIDGenerator::GenerateUUID(nsID** aRet)
{
  nsID* id = static_cast<nsID*>(moz_xmalloc(sizeof(nsID)));
  if (!id) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  nsresult rv = GenerateUUIDInPlace(id);
  if (NS_FAILED(rv)) {
    free(id);
    return rv;
  }

  *aRet = id;
  return rv;
}

NS_IMETHODIMP
nsUUIDGenerator::GenerateUUIDInPlace(nsID* aId)
{
  // The various code in this method is probably not threadsafe, so lock
  // across the whole method.
  MutexAutoLock lock(mLock);

#if defined(XP_WIN)
  HRESULT hr = CoCreateGuid((GUID*)aId);
  if (FAILED(hr)) {
    return NS_ERROR_FAILURE;
  }
#elif defined(XP_MACOSX)
  CFUUIDRef uuid = CFUUIDCreate(kCFAllocatorDefault);
  if (!uuid) {
    return NS_ERROR_FAILURE;
  }

  CFUUIDBytes bytes = CFUUIDGetUUIDBytes(uuid);
  memcpy(aId, &bytes, sizeof(nsID));

  CFRelease(uuid);
#else /* not windows or OS X; generate randomness using random(). */
  /* XXX we should be saving the return of setstate here and switching
   * back to it; instead, we use the value returned when we called
   * initstate, since older glibc's have broken setstate() return values
   */
#ifndef HAVE_ARC4RANDOM
  setstate(mState);
#endif

#ifdef HAVE_ARC4RANDOM_BUF
  arc4random_buf(aId, sizeof(nsID));
#else /* HAVE_ARC4RANDOM_BUF */
  size_t bytesLeft = sizeof(nsID);
  while (bytesLeft > 0) {
#ifdef HAVE_ARC4RANDOM
    long rval = arc4random();
    const size_t mRBytes = 4;
#else
    long rval = random();
#endif


    uint8_t* src = (uint8_t*)&rval;
    // We want to grab the mRBytes least significant bytes of rval, since
    // mRBytes less than sizeof(rval) means the high bytes are 0.
#ifdef IS_BIG_ENDIAN
    src += sizeof(rval) - mRBytes;
#endif
    uint8_t* dst = ((uint8_t*)aId) + (sizeof(nsID) - bytesLeft);
    size_t toWrite = (bytesLeft < mRBytes ? bytesLeft : mRBytes);
    for (size_t i = 0; i < toWrite; i++) {
      dst[i] = src[i];
    }

    bytesLeft -= toWrite;
  }
#endif /* HAVE_ARC4RANDOM_BUF */

  /* Put in the version */
  aId->m2 &= 0x0fff;
  aId->m2 |= 0x4000;

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

#ifndef HAVE_ARC4RANDOM
  /* Restore the previous RNG state */
  setstate(mSavedState);
#endif
#endif

  return NS_OK;
}