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 }