/**
* Creates a key for use in the ShouldLoad cache.
* Looks like: <uri>!<nsIContentPolicy::LOAD_TYPE>
*/
nsresult
CreateCacheKey_Internal(nsIURI* aContentLocation,
nsContentPolicyType aContentType,
nsACString& outCacheKey)
{
if (!aContentLocation) {
return NS_ERROR_FAILURE;
}
bool isDataScheme = false;
nsresult rv = aContentLocation->SchemeIs("data", &isDataScheme);
NS_ENSURE_SUCCESS(rv, rv);
outCacheKey.Truncate();
if (aContentType != nsIContentPolicy::TYPE_SCRIPT && isDataScheme) {
// For non-script data: URI, use ("data:", aContentType) as the cache key.
outCacheKey.Append(NS_LITERAL_CSTRING("data:"));
outCacheKey.AppendInt(aContentType);
return NS_OK;
}
nsAutoCString spec;
rv = aContentLocation->GetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
// Don't cache for a URI longer than the cutoff size.
if (spec.Length() <= CSP_CACHE_URI_CUTOFF_SIZE) {
outCacheKey.Append(spec);
outCacheKey.Append(NS_LITERAL_CSTRING("!"));
outCacheKey.AppendInt(aContentType);
}
return NS_OK;
}
void nsMsgI18NConvertRawBytesToUTF8(const nsCString& inString,
const char* charset,
nsACString& outString)
{
if (MsgIsUTF8(inString))
{
outString.Assign(inString);
return;
}
nsAutoString utf16Text;
nsresult rv = ConvertToUnicode(charset, inString, utf16Text);
if (NS_SUCCEEDED(rv))
{
CopyUTF16toUTF8(utf16Text, outString);
return;
}
// EF BF BD (UTF-8 encoding of U+FFFD)
NS_NAMED_LITERAL_CSTRING(utf8ReplacementChar, "\357\277\275");
const char* cur = inString.BeginReading();
const char* end = inString.EndReading();
outString.Truncate();
while (cur < end) {
char c = *cur++;
if (c & char(0x80))
outString.Append(utf8ReplacementChar);
else
outString.Append(c);
}
}
void
GeckoChildProcessHost::SetChildLogName(const char* varName, const char* origLogName,
nsACString &buffer)
{
// We currently have no portable way to launch child with environment
// different than parent. So temporarily change NSPR_LOG_FILE so child
// inherits value we want it to have. (NSPR only looks at NSPR_LOG_FILE at
// startup, so it's 'safe' to play with the parent's environment this way.)
buffer.Assign(varName);
#ifdef XP_WIN
// On Windows we must expand relative paths because sandboxing rules
// bound only to full paths. fopen fowards to NtCreateFile which checks
// the path against the sanboxing rules as passed to fopen (left relative).
char absPath[MAX_PATH + 2];
if (_fullpath(absPath, origLogName, sizeof(absPath))) {
buffer.Append(absPath);
} else
#endif
{
buffer.Append(origLogName);
}
// Append child-specific postfix to name
buffer.AppendLiteral(".child-");
buffer.AppendInt(mChildCounter);
// Passing temporary to PR_SetEnv is ok here if we keep the temporary
// for the time we launch the sub-process. It's copied to the new
// environment.
PR_SetEnv(buffer.BeginReading());
}
nsresult
PendingLookup::GetStrippedSpec(nsIURI* aUri, nsACString& escaped)
{
// If aURI is not an nsIURL, we do not want to check the lists or send a
// remote query.
nsresult rv;
nsCOMPtr<nsIURL> url = do_QueryInterface(aUri, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = url->GetScheme(escaped);
NS_ENSURE_SUCCESS(rv, rv);
nsCString temp;
rv = url->GetHostPort(temp);
NS_ENSURE_SUCCESS(rv, rv);
escaped.Append("://");
escaped.Append(temp);
rv = url->GetFilePath(temp);
NS_ENSURE_SUCCESS(rv, rv);
// nsIUrl.filePath starts with '/'
escaped.Append(temp);
return NS_OK;
}
nsresult
nsFTPDirListingConv::GetHeaders(nsACString& headers,
nsIURI* uri)
{
nsresult rv = NS_OK;
// build up 300 line
headers.AppendLiteral("300: ");
// Bug 111117 - don't print the password
nsCAutoString pw;
nsCAutoString spec;
uri->GetPassword(pw);
if (!pw.IsEmpty()) {
rv = uri->SetPassword(EmptyCString());
if (NS_FAILED(rv)) return rv;
rv = uri->GetAsciiSpec(spec);
if (NS_FAILED(rv)) return rv;
headers.Append(spec);
rv = uri->SetPassword(pw);
if (NS_FAILED(rv)) return rv;
} else {
rv = uri->GetAsciiSpec(spec);
if (NS_FAILED(rv)) return rv;
headers.Append(spec);
}
headers.Append(char(nsCRT::LF));
// END 300:
// build up the column heading; 200:
headers.AppendLiteral("200: filename content-length last-modified file-type\n");
// END 200:
return rv;
}
void
nsHttpRequestHead::Flatten(nsACString &buf, bool pruneProxyHeaders)
{
RecursiveMutexAutoLock mon(mRecursiveMutex);
// note: the first append is intentional.
buf.Append(mMethod);
buf.Append(' ');
buf.Append(mRequestURI);
buf.AppendLiteral(" HTTP/");
switch (mVersion) {
case NS_HTTP_VERSION_1_1:
buf.AppendLiteral("1.1");
break;
case NS_HTTP_VERSION_0_9:
buf.AppendLiteral("0.9");
break;
default:
buf.AppendLiteral("1.0");
}
buf.AppendLiteral("\r\n");
mHeaders.Flatten(buf, pruneProxyHeaders, false);
}
// This function will encode all "special" characters in typical url
// encoding, that is %hh where h is a valid hex digit. It will also fold
// any duplicated slashes.
bool
nsUrlClassifierUtils::SpecialEncode(const nsACString & url,
bool foldSlashes,
nsACString & _retval)
{
bool changed = false;
const char* curChar = url.BeginReading();
const char* end = url.EndReading();
unsigned char lastChar = '\0';
while (curChar != end) {
unsigned char c = static_cast<unsigned char>(*curChar);
if (ShouldURLEscape(c)) {
_retval.Append('%');
_retval.Append(int_to_hex_digit(c / 16));
_retval.Append(int_to_hex_digit(c % 16));
changed = true;
} else if (foldSlashes && (c == '/' && lastChar == '/')) {
// skip
} else {
_retval.Append(*curChar);
}
lastChar = c;
curChar++;
}
return changed;
}
static void SetProxyResult(const char* aType, const nsACString& aHostPort,
nsACString& aResult)
{
aResult.AssignASCII(aType);
aResult.Append(' ');
aResult.Append(aHostPort);
}
nsresult
nsHostObjectProtocolHandler::GenerateURIString(const nsACString &aScheme,
nsIPrincipal* aPrincipal,
nsACString& aUri)
{
nsresult rv;
nsCOMPtr<nsIUUIDGenerator> uuidgen =
do_GetService("@mozilla.org/uuid-generator;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsID id;
rv = uuidgen->GenerateUUIDInPlace(&id);
NS_ENSURE_SUCCESS(rv, rv);
char chars[NSID_LENGTH];
id.ToProvidedString(chars);
aUri = aScheme;
aUri.Append(':');
if (aPrincipal) {
nsAutoCString origin;
rv = nsContentUtils::GetASCIIOrigin(aPrincipal, origin);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
aUri.Append(origin);
aUri.Append('/');
}
aUri += Substring(chars + 1, chars + NSID_LENGTH - 2);
return NS_OK;
}
nsresult
ChunkSet::Serialize(nsACString& aChunkStr)
{
aChunkStr.Truncate();
uint32_t i = 0;
while (i < mChunks.Length()) {
if (i != 0) {
aChunkStr.Append(',');
}
aChunkStr.AppendInt((int32_t)mChunks[i]);
uint32_t first = i;
uint32_t last = first;
i++;
while (i < mChunks.Length() && (mChunks[i] == mChunks[i - 1] + 1 || mChunks[i] == mChunks[i - 1])) {
last = i++;
}
if (last != first) {
aChunkStr.Append('-');
aChunkStr.AppendInt((int32_t)mChunks[last]);
}
}
return NS_OK;
}
// Compute the name to pass into Histogram for the addon histogram
// 'name' from the addon 'id'. We can't use 'name' directly because it
// might conflict with other histograms in other addons or even with our
// own.
void
AddonHistogramName(const nsACString &id, const nsACString &name,
nsACString &ret)
{
ret.Append(id);
ret.Append(NS_LITERAL_CSTRING(":"));
ret.Append(name);
}
NS_IMETHODIMP
nsAbManager::GenerateUUID(const nsACString &aDirectoryId,
const nsACString &aLocalId, nsACString &uuid)
{
uuid.Assign(aDirectoryId);
uuid.Append('#');
uuid.Append(aLocalId);
return NS_OK;
}
static void SetProxyResult(const char* aType, const nsACString& aHost,
PRInt32 aPort, nsACString& aResult)
{
aResult.AssignASCII(aType);
aResult.Append(' ');
aResult.Append(aHost);
aResult.Append(':');
aResult.Append(nsPrintfCString("%d", aPort));
}
nsresult GenerateOriginKey(nsIPrincipal* aPrincipal,
nsACString& aOriginAttrSuffix,
nsACString& aOriginKey) {
if (NS_WARN_IF(!aPrincipal)) {
return NS_ERROR_UNEXPECTED;
}
aPrincipal->OriginAttributesRef().CreateSuffix(aOriginAttrSuffix);
nsCOMPtr<nsIURI> uri;
nsresult rv = aPrincipal->GetURI(getter_AddRefs(uri));
NS_ENSURE_SUCCESS(rv, rv);
if (!uri) {
return NS_ERROR_UNEXPECTED;
}
nsAutoCString domainOrigin;
rv = uri->GetAsciiHost(domainOrigin);
NS_ENSURE_SUCCESS(rv, rv);
if (domainOrigin.IsEmpty()) {
// For the file:/// protocol use the exact directory as domain.
bool isScheme = false;
if (NS_SUCCEEDED(uri->SchemeIs("file", &isScheme)) && isScheme) {
nsCOMPtr<nsIURL> url = do_QueryInterface(uri, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = url->GetDirectory(domainOrigin);
NS_ENSURE_SUCCESS(rv, rv);
}
}
// Append reversed domain
nsAutoCString reverseDomain;
rv = CreateReversedDomain(domainOrigin, reverseDomain);
if (NS_FAILED(rv)) {
return rv;
}
aOriginKey.Append(reverseDomain);
// Append scheme
nsAutoCString scheme;
rv = uri->GetScheme(scheme);
NS_ENSURE_SUCCESS(rv, rv);
aOriginKey.Append(':');
aOriginKey.Append(scheme);
// Append port if any
int32_t port = NS_GetRealPort(uri);
if (port != -1) {
aOriginKey.Append(nsPrintfCString(":%d", port));
}
return NS_OK;
}
void
BuildAlternativeDataInfo(const char *aInfo, int64_t aOffset, nsACString &_retval)
{
_retval.Truncate();
_retval.AppendInt(kAltDataVersion);
_retval.Append(';');
_retval.AppendInt(aOffset);
_retval.Append(',');
_retval.Append(aInfo);
}
NS_IMETHODIMP nsAbDirProperty::GetUuid(nsACString &uuid) {
// XXX: not all directories have a dirPrefId...
nsresult rv = GetDirPrefId(uuid);
NS_ENSURE_SUCCESS(rv, rv);
uuid.Append('&');
nsString dirName;
GetDirName(dirName);
uuid.Append(NS_ConvertUTF16toUTF8(dirName));
return rv;
}
NS_IMETHODIMP
nsLocalFile::GetRelativeDescriptor(nsIFile *fromFile, nsACString& _retval)
{
NS_ENSURE_ARG_POINTER(fromFile);
const int32_t kMaxNodesInPath = 32;
//
// _retval will be UTF-8 encoded
//
nsresult rv;
_retval.Truncate(0);
nsAutoString thisPath, fromPath;
PRUnichar *thisNodes[kMaxNodesInPath], *fromNodes[kMaxNodesInPath];
int32_t thisNodeCnt, fromNodeCnt, nodeIndex;
rv = GetPath(thisPath);
if (NS_FAILED(rv))
return rv;
rv = fromFile->GetPath(fromPath);
if (NS_FAILED(rv))
return rv;
// get raw pointer to mutable string buffer
PRUnichar *thisPathPtr; thisPath.BeginWriting(thisPathPtr);
PRUnichar *fromPathPtr; fromPath.BeginWriting(fromPathPtr);
thisNodeCnt = SplitPath(thisPathPtr, thisNodes, kMaxNodesInPath);
fromNodeCnt = SplitPath(fromPathPtr, fromNodes, kMaxNodesInPath);
if (thisNodeCnt < 0 || fromNodeCnt < 0)
return NS_ERROR_FAILURE;
for (nodeIndex = 0; nodeIndex < thisNodeCnt && nodeIndex < fromNodeCnt; ++nodeIndex) {
#ifdef XP_WIN
if (_wcsicmp(thisNodes[nodeIndex], fromNodes[nodeIndex]))
break;
#else
if (nsCRT::strcmp(thisNodes[nodeIndex], fromNodes[nodeIndex]))
break;
#endif
}
int32_t branchIndex = nodeIndex;
for (nodeIndex = branchIndex; nodeIndex < fromNodeCnt; nodeIndex++)
_retval.AppendLiteral("../");
for (nodeIndex = branchIndex; nodeIndex < thisNodeCnt; nodeIndex++) {
NS_ConvertUTF16toUTF8 nodeStr(thisNodes[nodeIndex]);
_retval.Append(nodeStr);
if (nodeIndex + 1 < thisNodeCnt)
_retval.Append('/');
}
return NS_OK;
}
static void SetProxyResult(const char* aType, const nsACString& aHost,
int32_t aPort, nsACString& aResult)
{
aResult.AppendASCII(aType);
aResult.Append(' ');
aResult.Append(aHost);
if (aPort > 0) {
aResult.Append(':');
aResult.Append(nsPrintfCString("%d", aPort));
}
}
void
URLSearchParams::DecodeString(const nsACString& aInput, nsACString& aOutput)
{
nsACString::const_iterator start, end;
aInput.BeginReading(start);
aInput.EndReading(end);
while (start != end) {
// replace '+' with U+0020
if (*start == '+') {
aOutput.Append(' ');
++start;
continue;
}
// Percent decode algorithm
if (*start == '%') {
nsACString::const_iterator first(start);
++first;
nsACString::const_iterator second(first);
++second;
#define ASCII_HEX_DIGIT( x ) \
((x >= 0x41 && x <= 0x46) || \
(x >= 0x61 && x <= 0x66) || \
(x >= 0x30 && x <= 0x39))
#define HEX_DIGIT( x ) \
(*x >= 0x30 && *x <= 0x39 \
? *x - 0x30 \
: (*x >= 0x41 && *x <= 0x46 \
? *x - 0x37 \
: *x - 0x57))
if (first != end && second != end &&
ASCII_HEX_DIGIT(*first) && ASCII_HEX_DIGIT(*second)) {
aOutput.Append(HEX_DIGIT(first) * 16 + HEX_DIGIT(second));
start = ++second;
continue;
} else {
aOutput.Append('%');
++start;
continue;
}
}
aOutput.Append(*start);
++start;
}
}
void
nsCertOverride::convertBitsToString(OverrideBits ob, nsACString &str)
{
str.Truncate();
if (ob & ob_Mismatch)
str.Append('M');
if (ob & ob_Untrusted)
str.Append('U');
if (ob & ob_Time_error)
str.Append('T');
}
void
nsHttpResponseHead::Flatten(nsACString &buf, bool pruneTransients)
{
if (mVersion == NS_HTTP_VERSION_0_9)
return;
buf.AppendLiteral("HTTP/");
if (mVersion == NS_HTTP_VERSION_1_1)
buf.AppendLiteral("1.1 ");
else
buf.AppendLiteral("1.0 ");
buf.Append(nsPrintfCString("%u", unsigned(mStatus)) +
NS_LITERAL_CSTRING(" ") +
mStatusText +
NS_LITERAL_CSTRING("\r\n"));
if (!pruneTransients) {
mHeaders.Flatten(buf, false);
return;
}
// otherwise, we need to iterate over the headers and only flatten
// those that are appropriate.
uint32_t i, count = mHeaders.Count();
for (i=0; i<count; ++i) {
nsHttpAtom header;
const char *value = mHeaders.PeekHeaderAt(i, header);
if (!value || header == nsHttp::Connection
|| header == nsHttp::Proxy_Connection
|| header == nsHttp::Keep_Alive
|| header == nsHttp::WWW_Authenticate
|| header == nsHttp::Proxy_Authenticate
|| header == nsHttp::Trailer
|| header == nsHttp::Transfer_Encoding
|| header == nsHttp::Upgrade
// XXX this will cause problems when we start honoring
// Cache-Control: no-cache="set-cookie", what to do?
|| header == nsHttp::Set_Cookie)
continue;
// otherwise, write out the "header: value\r\n" line
buf.Append(nsDependentCString(header.get()) +
NS_LITERAL_CSTRING(": ") +
nsDependentCString(value) +
NS_LITERAL_CSTRING("\r\n"));
}
}
nsresult nsIDNService::ACEtoUTF8(const nsACString & input, nsACString & _retval,
stringPrepFlag flag)
{
// RFC 3490 - 4.2 ToUnicode
// ToUnicode never fails. If any step fails, then the original input
// sequence is returned immediately in that step.
//
// Note that this refers to the decoding of a single label.
// ACEtoUTF8 may be called with a sequence of labels separated by dots;
// this test applies individually to each label.
uint32_t len = 0, offset = 0;
nsAutoCString decodedBuf;
nsACString::const_iterator start, end;
input.BeginReading(start);
input.EndReading(end);
_retval.Truncate();
// loop and decode nodes
while (start != end) {
len++;
if (*start++ == '.') {
nsDependentCSubstring origLabel(input, offset, len - 1);
if (NS_FAILED(decodeACE(origLabel, decodedBuf, flag))) {
// If decoding failed, use the original input sequence
// for this label.
_retval.Append(origLabel);
} else {
_retval.Append(decodedBuf);
}
_retval.Append('.');
offset += len;
len = 0;
}
}
// decode the last node
if (len) {
nsDependentCSubstring origLabel(input, offset, len);
if (NS_FAILED(decodeACE(origLabel, decodedBuf, flag))) {
_retval.Append(origLabel);
} else {
_retval.Append(decodedBuf);
}
}
return NS_OK;
}
/* ACString ConvertUTF8toACE (in AUTF8String input); */
NS_IMETHODIMP nsIDNService::ConvertUTF8toACE(const nsACString & input, nsACString & ace)
{
// protect against bogus input
NS_ENSURE_TRUE(IsUTF8(input), NS_ERROR_UNEXPECTED);
nsresult rv;
NS_ConvertUTF8toUCS2 ustr(input);
// map ideographic period to ASCII period etc.
normalizeFullStops(ustr);
PRUint32 len, offset;
len = 0;
offset = 0;
nsCAutoString encodedBuf;
nsAString::const_iterator start, end;
ustr.BeginReading(start);
ustr.EndReading(end);
ace.Truncate();
// encode nodes if non ASCII
while (start != end) {
len++;
if (*start++ == (PRUnichar)'.') {
rv = stringPrepAndACE(Substring(ustr, offset, len - 1), encodedBuf);
NS_ENSURE_SUCCESS(rv, rv);
ace.Append(encodedBuf);
ace.Append('.');
offset += len;
len = 0;
}
}
// add extra node for multilingual test bed
if (mMultilingualTestBed)
ace.AppendLiteral("mltbd.");
// encode the last node if non ASCII
if (len) {
rv = stringPrepAndACE(Substring(ustr, offset, len), encodedBuf);
NS_ENSURE_SUCCESS(rv, rv);
ace.Append(encodedBuf);
}
return NS_OK;
}
nsresult nsIDNService::UTF8toACE(const nsACString & input, nsACString & ace, bool allowUnassigned, bool convertAllLabels)
{
nsresult rv;
NS_ConvertUTF8toUTF16 ustr(input);
// map ideographic period to ASCII period etc.
normalizeFullStops(ustr);
uint32_t len, offset;
len = 0;
offset = 0;
nsAutoCString encodedBuf;
nsAString::const_iterator start, end;
ustr.BeginReading(start);
ustr.EndReading(end);
ace.Truncate();
// encode nodes if non ASCII
while (start != end) {
len++;
if (*start++ == (char16_t)'.') {
rv = stringPrepAndACE(Substring(ustr, offset, len - 1), encodedBuf,
allowUnassigned, convertAllLabels);
NS_ENSURE_SUCCESS(rv, rv);
ace.Append(encodedBuf);
ace.Append('.');
offset += len;
len = 0;
}
}
// add extra node for multilingual test bed
if (mMultilingualTestBed)
ace.AppendLiteral("mltbd.");
// encode the last node if non ASCII
if (len) {
rv = stringPrepAndACE(Substring(ustr, offset, len), encodedBuf,
allowUnassigned, convertAllLabels);
NS_ENSURE_SUCCESS(rv, rv);
ace.Append(encodedBuf);
}
return NS_OK;
}
static nsresult encodeToRACE(const char* prefix, const nsAString& in, nsACString& out)
{
// need maximum 20 bits to encode 16 bit Unicode character
// (include null terminator)
const uint32_t kEncodedBufSize = kMaxDNSNodeLen * 20 / 8 + 1 + 1;
// set up a work buffer for RACE encoder
char16_t temp[kMaxDNSNodeLen + 2];
temp[0] = 0xFFFF; // set a place holder (to be filled by get_compress_mode)
temp[in.Length() + 1] = (char16_t)'\0';
nsAString::const_iterator start, end;
in.BeginReading(start);
in.EndReading(end);
for (uint32_t i = 1; start != end; i++)
temp[i] = *start++;
// encode nodes if non ASCII
char encodedBuf[kEncodedBufSize];
idn_result_t result = race_compress_encode((const unsigned short *) temp,
get_compress_mode((unsigned short *) temp + 1),
encodedBuf, kEncodedBufSize);
if (idn_success != result)
return NS_ERROR_FAILURE;
out.Assign(prefix);
out.Append(encodedBuf);
return NS_OK;
}
nsresult
NS_CopyUnicodeToNative(const nsAString& aInput, nsACString& aOutput)
{
aOutput.Truncate();
nsAString::const_iterator iter, end;
aInput.BeginReading(iter);
aInput.EndReading(end);
// cannot easily avoid intermediate buffer copy.
char temp[4096];
nsNativeCharsetConverter conv;
const char16_t* buf = iter.get();
uint32_t bufLeft = Distance(iter, end);
while (bufLeft) {
char* p = temp;
uint32_t tempLeft = sizeof(temp);
nsresult rv = conv.UnicodeToNative(&buf, &bufLeft, &p, &tempLeft);
if (NS_FAILED(rv)) {
return rv;
}
if (tempLeft < sizeof(temp)) {
aOutput.Append(temp, sizeof(temp) - tempLeft);
}
}
return NS_OK;
}
NS_IMETHODIMP
nsMsgIdentity::GetDoBccList(nsACString& aValue)
{
if (!mPrefBranch)
return NS_ERROR_NOT_INITIALIZED;
nsCString val;
nsresult rv = mPrefBranch->GetCharPref("doBccList", getter_Copies(val));
aValue = val;
if (NS_SUCCEEDED(rv))
return rv;
bool bccSelf = false;
rv = GetBccSelf(&bccSelf);
NS_ENSURE_SUCCESS(rv,rv);
if (bccSelf)
GetEmail(aValue);
bool bccOthers = false;
rv = GetBccOthers(&bccOthers);
NS_ENSURE_SUCCESS(rv,rv);
nsCString others;
rv = GetBccList(others);
NS_ENSURE_SUCCESS(rv,rv);
if (bccOthers && !others.IsEmpty()) {
if (bccSelf)
aValue.AppendLiteral(",");
aValue.Append(others);
}
return SetDoBccList(aValue);
}
NS_CStringSetDataRange(nsACString& aStr,
uint32_t aCutOffset, uint32_t aCutLength,
const char* aData, uint32_t aDataLength)
{
if (aCutOffset == UINT32_MAX) {
// append case
if (aData) {
aStr.Append(aData, aDataLength);
}
return NS_OK; // XXX report errors
}
if (aCutLength == UINT32_MAX) {
aCutLength = aStr.Length() - aCutOffset;
}
if (aData) {
if (aDataLength == UINT32_MAX) {
aStr.Replace(aCutOffset, aCutLength, nsDependentCString(aData));
} else {
aStr.Replace(aCutOffset, aCutLength, Substring(aData, aDataLength));
}
} else {
aStr.Cut(aCutOffset, aCutLength);
}
return NS_OK; // XXX report errors
}
NS_IMETHODIMP
nsMozIconURI::GetFileExtension(nsACString &aFileExtension)
{
// First, try to get the extension from mIconURL if we have one
if (mIconURL)
{
nsAutoCString fileExt;
if (NS_SUCCEEDED(mIconURL->GetFileExtension(fileExt)))
{
if (!fileExt.IsEmpty())
{
// unfortunately, this code doesn't give us the required '.' in front of the extension
// so we have to do it ourselves..
aFileExtension.Assign('.');
aFileExtension.Append(fileExt);
}
}
return NS_OK;
}
if (!mFileName.IsEmpty())
{
// truncate the extension out of the file path...
const char * chFileName = mFileName.get(); // get the underlying buffer
const char * fileExt = strrchr(chFileName, '.');
if (!fileExt)
return NS_OK;
aFileExtension = fileExt;
}
return NS_OK;
}
void
nsHttpHeaderArray::Flatten(nsACString &buf, bool pruneProxyHeaders)
{
uint32_t i, count = mHeaders.Length();
for (i = 0; i < count; ++i) {
const nsEntry &entry = mHeaders[i];
// prune proxy headers if requested
if (pruneProxyHeaders && ((entry.header == nsHttp::Proxy_Authorization) ||
(entry.header == nsHttp::Proxy_Connection)))
continue;
buf.Append(entry.header);
buf.AppendLiteral(": ");
buf.Append(entry.value);
buf.AppendLiteral("\r\n");
}
}