NS_IMETHODIMP
sbLocalDatabaseMediaListBase::LastIndexOf(sbIMediaItem* aMediaItem,
PRUint32 aStartFrom,
PRUint32* _retval)
{
NS_ENSURE_ARG_POINTER(aMediaItem);
NS_ENSURE_ARG_POINTER(_retval);
mozilla::MonitorAutoLock mon(mFullArrayMonitor);
PRUint32 count;
nsresult rv = mFullArray->GetLength(&count);
NS_ENSURE_SUCCESS(rv, rv);
// Do some sanity checking.
NS_ENSURE_TRUE(count > 0, NS_ERROR_UNEXPECTED);
NS_ENSURE_ARG_MAX(aStartFrom, count - 1);
nsAutoString testGUID;
rv = aMediaItem->GetGuid(testGUID);
NS_ENSURE_SUCCESS(rv, rv);
for (PRUint32 index = count - 1; index >= aStartFrom; index--) {
nsAutoString itemGUID;
rv = mFullArray->GetGuidByIndex(index, itemGUID);
SB_CONTINUE_IF_FAILED(rv);
if (testGUID.Equals(itemGUID)) {
*_retval = index;
return NS_OK;
}
}
return NS_ERROR_NOT_AVAILABLE;
}
NS_IMETHODIMP
nsGNOMEShellService::SetDesktopBackgroundColor(uint32_t aColor)
{
NS_ENSURE_ARG_MAX(aColor, 0xFFFFFF);
uint8_t red = aColor >> 16;
uint8_t green = aColor >> 8;
uint8_t blue = aColor;
char colorString[14];
sprintf(colorString, "#%04x%04x%04x", COLOR_8_TO_16_BIT(red),
COLOR_8_TO_16_BIT(green), COLOR_8_TO_16_BIT(blue));
nsCOMPtr<nsIGSettingsService> gsettings(do_GetService(NS_GSETTINGSSERVICE_CONTRACTID));
if (gsettings) {
nsCOMPtr<nsIGSettingsCollection> background_settings;
gsettings->GetCollectionForSchema(NS_LITERAL_CSTRING(OGDB_SCHEMA),
getter_AddRefs(background_settings));
if (background_settings) {
background_settings->SetString(NS_LITERAL_CSTRING(OGDB_COLOR),
nsDependentCString(colorString));
return NS_OK;
}
}
nsCOMPtr<nsIGConfService> gconf = do_GetService(NS_GCONFSERVICE_CONTRACTID);
if (gconf)
gconf->SetString(NS_LITERAL_CSTRING(DGB_COLOR), nsDependentCString(colorString));
return NS_OK;
}
static
nsresult
GenerateRandomBytes(uint32_t aSize,
uint8_t* _buffer)
{
// On Windows, we'll use its built-in cryptographic API.
#if defined(XP_WIN)
HCRYPTPROV cryptoProvider;
BOOL rc = CryptAcquireContext(&cryptoProvider, 0, 0, PROV_RSA_FULL,
CRYPT_VERIFYCONTEXT | CRYPT_SILENT);
if (rc) {
rc = CryptGenRandom(cryptoProvider, aSize, _buffer);
(void)CryptReleaseContext(cryptoProvider, 0);
}
return rc ? NS_OK : NS_ERROR_FAILURE;
// On Unix, we'll just read in from /dev/urandom.
#elif defined(XP_UNIX)
NS_ENSURE_ARG_MAX(aSize, INT32_MAX);
PRFileDesc* urandom = PR_Open("/dev/urandom", PR_RDONLY, 0);
nsresult rv = NS_ERROR_FAILURE;
if (urandom) {
int32_t bytesRead = PR_Read(urandom, _buffer, aSize);
if (bytesRead == static_cast<int32_t>(aSize)) {
rv = NS_OK;
}
(void)PR_Close(urandom);
}
return rv;
#endif
}
/**
* See nsIMutableArray
*/
NS_IMETHODIMP
sbPropertyArray::InsertElementAt(nsISupports* aElement,
PRUint32 aIndex,
bool aWeak)
{
NS_ENSURE_ARG_POINTER(aElement);
NS_ENSURE_ARG_MAX((PRInt32)aIndex, mArray.Count());
// No support for weak references here
NS_ENSURE_FALSE(aWeak, NS_ERROR_FAILURE);
nsresult rv;
nsCOMPtr<sbIProperty> property = do_QueryInterface(aElement, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoLock lock(mArrayLock);
if (mStrict) {
bool valid;
rv = PropertyIsValid(property, &valid);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(valid, NS_ERROR_ILLEGAL_VALUE);
}
bool success = mArray.InsertObjectAt(property, aIndex);
NS_ENSURE_STATE(success);
return NS_OK;
}
NS_IMETHODIMP
nsCommandLine::Init(int32_t argc, const char* const* argv, nsIFile* aWorkingDir,
uint32_t aState)
{
NS_ENSURE_ARG_MAX(aState, 2);
int32_t i;
mWorkingDir = aWorkingDir;
// skip argv[0], we don't want it
for (i = 1; i < argc; ++i) {
const char* curarg = argv[i];
#ifdef DEBUG_COMMANDLINE
printf("Testing native arg %i: '%s'\n", i, curarg);
#endif
#if defined(XP_WIN)
if (*curarg == '/') {
char* dup = PL_strdup(curarg);
if (!dup) return NS_ERROR_OUT_OF_MEMORY;
*dup = '-';
char* colon = PL_strchr(dup, ':');
if (colon) {
*colon = '\0';
appendArg(dup);
appendArg(colon+1);
} else {
appendArg(dup);
}
PL_strfree(dup);
continue;
}
#endif
if (*curarg == '-') {
if (*(curarg+1) == '-') ++curarg;
char* dup = PL_strdup(curarg);
if (!dup) return NS_ERROR_OUT_OF_MEMORY;
char* eq = PL_strchr(dup, '=');
if (eq) {
*eq = '\0';
appendArg(dup);
appendArg(eq + 1);
} else {
appendArg(dup);
}
PL_strfree(dup);
continue;
}
appendArg(curarg);
}
mState = aState;
return NS_OK;
}
NS_IMETHODIMP
nsCommandLine::GetArgument(int32_t aIndex, nsAString& aResult)
{
NS_ENSURE_ARG_MIN(aIndex, 0);
NS_ENSURE_ARG_MAX(aIndex, int32_t(mArgs.Length() - 1));
aResult = mArgs[aIndex];
return NS_OK;
}
NS_IMETHODIMP
nsCommandLine::RemoveArguments(int32_t aStart, int32_t aEnd)
{
NS_ENSURE_ARG_MIN(aStart, 0);
NS_ENSURE_ARG_MAX(uint32_t(aEnd) + 1, mArgs.Length());
for (int32_t i = aEnd; i >= aStart; --i) {
mArgs.RemoveElementAt(i);
}
return NS_OK;
}
NS_IMETHODIMP
BindingParams::BindAdoptedBlobByIndex(uint32_t aIndex,
uint8_t *aValue,
uint32_t aValueSize)
{
NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
std::pair<uint8_t *, int> data(
static_cast<uint8_t *>(aValue),
int(aValueSize)
);
nsCOMPtr<nsIVariant> value(new AdoptedBlobVariant(data));
return BindByIndex(aIndex, value);
}
NS_IMETHODIMP
BindingParams::BindAdoptedBlobByName(const nsACString &aName,
uint8_t *aValue,
uint32_t aValueSize)
{
NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
std::pair<uint8_t *, int> data(
aValue,
int(aValueSize)
);
nsCOMPtr<nsIVariant> value(new AdoptedBlobVariant(data));
return BindByName(aName, value);
}
NS_IMETHODIMP
BindingParams::BindBlobByIndex(uint32_t aIndex,
const uint8_t *aValue,
uint32_t aValueSize)
{
NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
std::pair<const void *, int> data(
static_cast<const void *>(aValue),
int(aValueSize)
);
nsCOMPtr<nsIVariant> value(new BlobVariant(data));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByIndex(aIndex, value);
}
NS_IMETHODIMP
BindingParams::BindBlobByName(const nsACString &aName,
const PRUint8 *aValue,
PRUint32 aValueSize)
{
NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
std::pair<const void *, int> data(
static_cast<const void *>(aValue),
int(aValueSize)
);
nsCOMPtr<nsIVariant> value(new BlobVariant(data));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByName(aName, value);
}
NS_IMETHODIMP
nsIOService::EscapeString(const nsACString& aString,
uint32_t aEscapeType,
nsACString& aResult)
{
NS_ENSURE_ARG_MAX(aEscapeType, 4);
nsAutoCString stringCopy(aString);
nsCString result;
if (!NS_Escape(stringCopy, result, (nsEscapeMask) aEscapeType))
return NS_ERROR_OUT_OF_MEMORY;
aResult.Assign(result);
return NS_OK;
}
static
nsresult
GenerateRandomBytes(PRUint32 aSize,
PRUint8* _buffer)
{
// On Windows, we'll use its built-in cryptographic API.
#if defined(XP_WIN)
HCRYPTPROV cryptoProvider;
BOOL rc = CryptAcquireContext(&cryptoProvider, 0, 0, PROV_RSA_FULL,
CRYPT_VERIFYCONTEXT | CRYPT_SILENT);
if (rc) {
rc = CryptGenRandom(cryptoProvider, aSize, _buffer);
(void)CryptReleaseContext(cryptoProvider, 0);
}
return rc ? NS_OK : NS_ERROR_FAILURE;
// On Unix, we'll just read in from /dev/urandom.
#elif defined(XP_UNIX)
NS_ENSURE_ARG_MAX(aSize, PR_INT32_MAX);
PRFileDesc* urandom = PR_Open("/dev/urandom", PR_RDONLY, 0);
nsresult rv = NS_ERROR_FAILURE;
if (urandom) {
PRInt32 bytesRead = PR_Read(urandom, _buffer, aSize);
if (bytesRead == static_cast<PRInt32>(aSize)) {
rv = NS_OK;
}
(void)PR_Close(urandom);
}
return rv;
#elif defined(XP_OS2)
nsCOMPtr<nsIRandomGenerator> rg =
do_GetService("@mozilla.org/security/random-generator;1");
NS_ENSURE_STATE(rg);
PRUint8* temp;
nsresult rv = rg->GenerateRandomBytes(aSize, &temp);
NS_ENSURE_SUCCESS(rv, rv);
memcpy(_buffer, temp, aSize);
NS_Free(temp);
return NS_OK;
#endif
}
