NS_IMETHODIMP nsSmtpServer::GetServerURI(nsACString &aResult) { nsCAutoString uri(NS_LITERAL_CSTRING("smtp://")); nsCString username; nsresult rv = GetUsername(username); if (NS_SUCCEEDED(rv) && !username.IsEmpty()) { nsCString escapedUsername; MsgEscapeString(username, nsINetUtil::ESCAPE_XALPHAS, escapedUsername); // not all servers have a username uri.Append(escapedUsername); uri.AppendLiteral("@"); } nsCString hostname; rv = GetHostname(hostname); if (NS_SUCCEEDED(rv) && !hostname.IsEmpty()) { nsCString escapedHostname; *((char **)getter_Copies(escapedHostname)) = nsEscape(hostname.get(), url_Path); // not all servers have a hostname uri.Append(escapedHostname); } aResult = uri; return NS_OK; }
NS_IMETHODIMP nsSmtpServer::ForgetPassword() { nsresult rv; nsCOMPtr<nsILoginManager> loginMgr = do_GetService(NS_LOGINMANAGER_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); // Get the current server URI without the username nsCAutoString serverUri(NS_LITERAL_CSTRING("smtp://")); nsCString hostname; rv = GetHostname(hostname); if (NS_SUCCEEDED(rv) && !hostname.IsEmpty()) { nsCString escapedHostname; *((char **)getter_Copies(escapedHostname)) = nsEscape(hostname.get(), url_Path); // not all servers have a hostname serverUri.Append(escapedHostname); } PRUint32 count; nsILoginInfo** logins; NS_ConvertUTF8toUTF16 currServer(serverUri); nsCString serverCUsername; rv = GetUsername(serverCUsername); NS_ENSURE_SUCCESS(rv, rv); NS_ConvertUTF8toUTF16 serverUsername(serverCUsername); rv = loginMgr->FindLogins(&count, currServer, EmptyString(), currServer, &logins); NS_ENSURE_SUCCESS(rv, rv); // There should only be one-login stored for this url, however just in case // there isn't. nsString username; for (PRUint32 i = 0; i < count; ++i) { if (NS_SUCCEEDED(logins[i]->GetUsername(username)) && username.Equals(serverUsername)) { // If this fails, just continue, we'll still want to remove the password // from our local cache. loginMgr->RemoveLogin(logins[i]); } } NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(count, logins); rv = SetPassword(EmptyCString()); m_logonFailed = PR_TRUE; return rv; }
//---------------------------------------------------------------------------------------- void nsFileURL::operator +=(const char* inRelativeUnixPath) //---------------------------------------------------------------------------------------- { char* escapedPath = nsEscape(inRelativeUnixPath, url_Path); mURL += escapedPath; nsCRT::free(escapedPath); #if defined(XP_MAC) mFileSpec += inRelativeUnixPath; #endif } // nsFileURL::operator +=
NS_IMETHODIMP nsTextToSubURI::ConvertAndEscape( const char *charset, const PRUnichar *text, char **_retval) { if(nullptr == _retval) return NS_ERROR_NULL_POINTER; *_retval = nullptr; nsresult rv = NS_OK; // Get Charset, get the encoder. nsICharsetConverterManager *ccm; rv = CallGetService(kCharsetConverterManagerCID, &ccm); if(NS_SUCCEEDED(rv)) { nsIUnicodeEncoder *encoder; rv = ccm->GetUnicodeEncoder(charset, &encoder); NS_RELEASE(ccm); if (NS_SUCCEEDED(rv)) { rv = encoder->SetOutputErrorBehavior(nsIUnicodeEncoder::kOnError_Replace, nullptr, (PRUnichar)'?'); if(NS_SUCCEEDED(rv)) { char buf[256]; char *pBuf = buf; int32_t ulen = text ? NS_strlen(text) : 0; int32_t outlen = 0; if(NS_SUCCEEDED(rv = encoder->GetMaxLength(text, ulen, &outlen))) { if(outlen >= 256) { pBuf = (char*)NS_Alloc(outlen+1); } if(nullptr == pBuf) { outlen = 255; pBuf = buf; } int32_t bufLen = outlen; if(NS_SUCCEEDED(rv = encoder->Convert(text,&ulen, pBuf, &outlen))) { // put termination characters (e.g. ESC(B of ISO-2022-JP) if necessary int32_t finLen = bufLen - outlen; if (finLen > 0) { if (NS_SUCCEEDED(encoder->Finish((char *)(pBuf+outlen), &finLen))) outlen += finLen; } pBuf[outlen] = '\0'; *_retval = nsEscape(pBuf, url_XPAlphas); if(nullptr == *_retval) rv = NS_ERROR_OUT_OF_MEMORY; } } if(pBuf != buf) NS_Free(pBuf); } NS_RELEASE(encoder); } } return rv; }
//---------------------------------------------------------------------------------------- void nsFileURL::operator = (const nsFilePath& inOther) //---------------------------------------------------------------------------------------- { mURL = kFileURLPrefix; char* original = (char*)(const char*)inOther; // we shall modify, but restore. if (!original || !*original) return; #if defined(XP_WIN) || defined(XP_OS2) // because we don't want to escape the '|' character, change it to a letter. // Note that a UNC path will not have a '|' character. char oldchar = original[2]; original[2] = 'x'; char* escapedPath = nsEscape(original, url_Path); original[2] = escapedPath[2] = oldchar; // restore it #else char* escapedPath = nsEscape(original, url_Path); #endif if (escapedPath) mURL += escapedPath; nsCRT::free(escapedPath); } // nsFileURL::operator =
//---------------------------------------------------------------------------------------- void nsFilePath::operator +=(const char* inRelativeUnixPath) //---------------------------------------------------------------------------------------- { NS_ASSERTION(inRelativeUnixPath, "Attempt append relative path with null path"); char* escapedPath = nsEscape(inRelativeUnixPath, url_Path); mPath += escapedPath; nsCRT::free(escapedPath); #if defined(XP_MAC) mFileSpec += inRelativeUnixPath; #endif } // nsFilePath::operator +=
static nsresult MangleKeywordIntoURI(const char *aKeyword, const char *aURL, nsCString& query) { query = (*aKeyword == '?') ? (aKeyword + 1) : aKeyword; query.Trim(" "); // pull leading/trailing spaces. // encode char * encQuery = nsEscape(query.get(), url_XPAlphas); if (!encQuery) return NS_ERROR_OUT_OF_MEMORY; query.Adopt(encQuery); // prepend the query with the keyword url // XXX this url should come from somewhere else query.Insert(aURL, 0); return NS_OK; }
// XXX i18n helper routines void nsIsIndexFrame::URLEncode(const nsString& aString, nsIUnicodeEncoder* encoder, nsString& oString) { char* inBuf = nsnull; if(encoder) inBuf = UnicodeToNewBytes(aString.get(), aString.Length(), encoder); if(nsnull == inBuf) inBuf = ToNewCString(aString); // convert to CRLF breaks char* convertedBuf = nsLinebreakConverter::ConvertLineBreaks(inBuf, nsLinebreakConverter::eLinebreakAny, nsLinebreakConverter::eLinebreakNet); delete [] inBuf; char* outBuf = nsEscape(convertedBuf, url_XPAlphas); oString.AssignASCII(outBuf); nsMemory::Free(outBuf); nsMemory::Free(convertedBuf); }
NS_IMETHODIMP nsPop3Service::NewURI(const nsACString &aSpec, const char *aOriginCharset, // ignored nsIURI *aBaseURI, nsIURI **_retval) { nsresult rv = NS_ERROR_FAILURE; if (!_retval) return rv; nsCAutoString folderUri(aSpec); nsCOMPtr<nsIRDFResource> resource; PRInt32 offset = folderUri.Find("?"); if (offset != -1) folderUri.Truncate(offset); const nsCString &flatSpec = PromiseFlatCString(aSpec); const char *uidl = PL_strstr(flatSpec.get(), "uidl="); if (!uidl) return NS_ERROR_FAILURE; nsCOMPtr<nsIRDFService> rdfService(do_GetService(kRDFServiceCID, &rv)); if (NS_FAILED(rv)) return rv; rv = rdfService->GetResource(folderUri, getter_AddRefs(resource)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(resource, &rv); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIMsgIncomingServer> server; nsLocalFolderScanState folderScanState; nsCOMPtr<nsIMsgLocalMailFolder> localFolder = do_QueryInterface(folder); nsCOMPtr <nsIMailboxUrl> mailboxUrl = do_QueryInterface(aBaseURI); nsCOMPtr<nsIFileSpec> path; rv = folder->GetPath(getter_AddRefs(path)); if (NS_FAILED(rv)) return rv; nsFileSpec fileSpec; path->GetFileSpec(&fileSpec); folderScanState.m_fileSpec = &fileSpec; if (mailboxUrl && localFolder) { rv = localFolder->GetFolderScanState(&folderScanState); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr <nsIMsgDBHdr> msgHdr; nsCOMPtr<nsIMsgMessageUrl> msgUrl = do_QueryInterface(mailboxUrl, &rv); NS_ENSURE_SUCCESS(rv,rv); msgUrl->GetMessageHeader(getter_AddRefs(msgHdr)); // we do this to get the account key if (msgHdr) localFolder->GetUidlFromFolder(&folderScanState, msgHdr); if (!folderScanState.m_accountKey.IsEmpty()) { nsCOMPtr<nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv); if (accountManager) { nsCOMPtr <nsIMsgAccount> account; accountManager->GetAccount(folderScanState.m_accountKey.get(), getter_AddRefs(account)); if (account) account->GetIncomingServer(getter_AddRefs(server)); } } } if (!server) rv = folder->GetServer(getter_AddRefs(server)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIPop3IncomingServer> popServer = do_QueryInterface(server,&rv); if (NS_FAILED(rv)) return rv; nsXPIDLCString hostname; nsXPIDLCString username; server->GetHostName(getter_Copies(hostname)); server->GetUsername(getter_Copies(username)); PRInt32 port; server->GetPort(&port); if (port == -1) port = POP3_PORT; // we need to escape the username because it may contain // characters like / % or @ nsXPIDLCString escapedUsername; *((char **)getter_Copies(escapedUsername)) = nsEscape(username, url_XAlphas); nsCAutoString popSpec("pop://"); popSpec += escapedUsername; popSpec += "@"; popSpec += hostname; popSpec += ":"; popSpec.AppendInt(port); popSpec += "?"; popSpec += uidl; nsCOMPtr<nsIUrlListener> urlListener = do_QueryInterface(folder, &rv); if (NS_FAILED(rv)) return rv; rv = BuildPop3Url(popSpec.get(), folder, popServer, urlListener, _retval, nsnull); if (NS_SUCCEEDED(rv)) { nsCOMPtr<nsIMsgMailNewsUrl> mailnewsurl = do_QueryInterface(*_retval, &rv); if (NS_SUCCEEDED(rv)) { // escape the username before we call SetUsername(). we do this because GetUsername() // will unescape the username mailnewsurl->SetUsername(escapedUsername); } nsCOMPtr<nsIPop3URL> popurl = do_QueryInterface(mailnewsurl, &rv); if (NS_SUCCEEDED(rv)) { nsCAutoString messageUri (aSpec); messageUri.ReplaceSubstring("mailbox:", "mailbox-message:"); messageUri.ReplaceSubstring("?number=", "#"); offset = messageUri.Find("&"); if (offset != -1) messageUri.Truncate(offset); popurl->SetMessageUri(messageUri.get()); nsCOMPtr<nsIPop3Sink> pop3Sink; rv = popurl->GetPop3Sink(getter_AddRefs(pop3Sink)); if (NS_SUCCEEDED(rv)) pop3Sink->SetBuildMessageUri(PR_TRUE); } } return rv; }
nsresult nsPop3Service::GetMail(PRBool downloadNewMail, nsIMsgWindow* aMsgWindow, nsIUrlListener * aUrlListener, nsIMsgFolder *aInbox, nsIPop3IncomingServer *aPopServer, nsIURI ** aURL) { NS_ENSURE_ARG_POINTER(aInbox); nsXPIDLCString popHost; nsXPIDLCString popUser; PRInt32 popPort = -1; nsCOMPtr<nsIMsgIncomingServer> server; nsCOMPtr<nsIURI> url; server = do_QueryInterface(aPopServer); nsCOMPtr <nsIMsgLocalMailFolder> destLocalFolder = do_QueryInterface(aInbox); if (destLocalFolder) { PRBool destFolderTooBig; destLocalFolder->WarnIfLocalFileTooBig(aMsgWindow, &destFolderTooBig); if (destFolderTooBig) return NS_MSG_ERROR_WRITING_MAIL_FOLDER; } if (!server) return NS_MSG_INVALID_OR_MISSING_SERVER; nsresult rv = server->GetHostName(getter_Copies(popHost)); NS_ENSURE_SUCCESS(rv, rv); if (!((const char *)popHost)) return NS_MSG_INVALID_OR_MISSING_SERVER; rv = server->GetPort(&popPort); NS_ENSURE_SUCCESS(rv, rv); rv = server->GetUsername(getter_Copies(popUser)); NS_ENSURE_SUCCESS(rv, rv); if (!((const char *)popUser)) return NS_MSG_SERVER_USERNAME_MISSING; nsXPIDLCString escapedUsername; *((char**)getter_Copies(escapedUsername)) = nsEscape(popUser, url_XAlphas); if (NS_SUCCEEDED(rv) && aPopServer) { // now construct a pop3 url... // we need to escape the username because it may contain // characters like / % or @ char * urlSpec = (downloadNewMail) ? PR_smprintf("pop3://%s@%s:%d", (const char *)escapedUsername, (const char *)popHost, popPort) : PR_smprintf("pop3://%s@%s:%d/?check", (const char *)escapedUsername, (const char *)popHost, popPort); rv = BuildPop3Url(urlSpec, aInbox, aPopServer, aUrlListener, getter_AddRefs(url), aMsgWindow); PR_Free(urlSpec); } if (NS_SUCCEEDED(rv) && url) rv = RunPopUrl(server, url); if (aURL && url) // we already have a ref count on pop3url... NS_IF_ADDREF(*aURL = url); return rv; }
NS_IMETHODIMP nsDirectoryIndexStream::Read(char* aBuf, PRUint32 aCount, PRUint32* aReadCount) { if (mStatus == NS_BASE_STREAM_CLOSED) { *aReadCount = 0; return NS_OK; } if (NS_FAILED(mStatus)) return mStatus; PRUint32 nread = 0; // If anything is enqueued (or left-over) in mBuf, then feed it to // the reader first. while (mOffset < (PRInt32)mBuf.Length() && aCount != 0) { *(aBuf++) = char(mBuf.CharAt(mOffset++)); --aCount; ++nread; } // Room left? if (aCount > 0) { mOffset = 0; mBuf.Truncate(); // Okay, now we'll suck stuff off of our iterator into the mBuf... while (PRUint32(mBuf.Length()) < aCount) { bool more = mPos < mArray.Count(); if (!more) break; // don't addref, for speed - an addref happened when it // was placed in the array, so it's not going to go stale nsIFile* current = mArray.ObjectAt(mPos); ++mPos; #ifdef PR_LOGGING if (PR_LOG_TEST(gLog, PR_LOG_DEBUG)) { nsCAutoString path; current->GetNativePath(path); PR_LOG(gLog, PR_LOG_DEBUG, ("nsDirectoryIndexStream[%p]: iterated %s", this, path.get())); } #endif // rjc: don't return hidden files/directories! // bbaetz: why not? nsresult rv; #ifndef XP_UNIX bool hidden = false; current->IsHidden(&hidden); if (hidden) { PR_LOG(gLog, PR_LOG_DEBUG, ("nsDirectoryIndexStream[%p]: skipping hidden file/directory", this)); continue; } #endif PRInt64 fileSize = 0; current->GetFileSize( &fileSize ); PRInt64 fileInfoModifyTime = 0; current->GetLastModifiedTime( &fileInfoModifyTime ); fileInfoModifyTime *= PR_USEC_PER_MSEC; mBuf.AppendLiteral("201: "); // The "filename" field char* escaped = nsnull; if (!NS_IsNativeUTF8()) { nsAutoString leafname; rv = current->GetLeafName(leafname); if (NS_FAILED(rv)) return rv; if (!leafname.IsEmpty()) escaped = nsEscape(NS_ConvertUTF16toUTF8(leafname).get(), url_Path); } else { nsCAutoString leafname; rv = current->GetNativeLeafName(leafname); if (NS_FAILED(rv)) return rv; if (!leafname.IsEmpty()) escaped = nsEscape(leafname.get(), url_Path); } if (escaped) { mBuf += escaped; mBuf.Append(' '); nsMemory::Free(escaped); } // The "content-length" field mBuf.AppendInt(fileSize, 10); mBuf.Append(' '); // The "last-modified" field PRExplodedTime tm; PR_ExplodeTime(fileInfoModifyTime, PR_GMTParameters, &tm); { char buf[64]; PR_FormatTimeUSEnglish(buf, sizeof(buf), "%a,%%20%d%%20%b%%20%Y%%20%H:%M:%S%%20GMT ", &tm); mBuf.Append(buf); } // The "file-type" field bool isFile = true; current->IsFile(&isFile); if (isFile) { mBuf.AppendLiteral("FILE "); } else { bool isDir; rv = current->IsDirectory(&isDir); if (NS_FAILED(rv)) return rv; if (isDir) { mBuf.AppendLiteral("DIRECTORY "); } else { bool isLink; rv = current->IsSymlink(&isLink); if (NS_FAILED(rv)) return rv; if (isLink) { mBuf.AppendLiteral("SYMBOLIC-LINK "); } } } mBuf.Append('\n'); } // ...and once we've either run out of directory entries, or // filled up the buffer, then we'll push it to the reader. while (mOffset < (PRInt32)mBuf.Length() && aCount != 0) { *(aBuf++) = char(mBuf.CharAt(mOffset++)); --aCount; ++nread; } } *aReadCount = nread; return NS_OK; }
char * nsFTPDirListingConv::DigestBufferLines(char *aBuffer, nsCString &aString) { char *line = aBuffer; char *eol; bool cr = false; list_state state; state.magic = 0; // while we have new lines, parse 'em into application/http-index-format. while ( line && (eol = PL_strchr(line, nsCRT::LF)) ) { // yank any carriage returns too. if (eol > line && *(eol-1) == nsCRT::CR) { eol--; *eol = '\0'; cr = true; } else { *eol = '\0'; cr = false; } list_result result; int type = ParseFTPList(line, &state, &result ); // if it is other than a directory, file, or link -OR- if it is a // directory named . or .., skip over this line. if ((type != 'd' && type != 'f' && type != 'l') || (result.fe_type == 'd' && result.fe_fname[0] == '.' && (result.fe_fnlen == 1 || (result.fe_fnlen == 2 && result.fe_fname[1] == '.'))) ) { if (cr) line = eol+2; else line = eol+1; continue; } // blast the index entry into the indexFormat buffer as a 201: line. aString.AppendLiteral("201: "); // FILENAME // parsers for styles 'U' and 'W' handle sequence " -> " themself if (state.lstyle != 'U' && state.lstyle != 'W') { const char* offset = strstr(result.fe_fname, " -> "); if (offset) { result.fe_fnlen = offset - result.fe_fname; } } nsCAutoString buf; aString.Append('\"'); aString.Append(NS_EscapeURL(Substring(result.fe_fname, result.fe_fname+result.fe_fnlen), esc_Minimal|esc_OnlyASCII|esc_Forced,buf)); aString.AppendLiteral("\" "); // CONTENT LENGTH if (type != 'd') { for (int i = 0; i < int(sizeof(result.fe_size)); ++i) { if (result.fe_size[i] != '\0') aString.Append((const char*)&result.fe_size[i], 1); } aString.Append(' '); } else aString.AppendLiteral("0 "); // MODIFIED DATE char buffer[256] = ""; // Note: The below is the RFC822/1123 format, as required by // the application/http-index-format specs // viewers of such a format can then reformat this into the // current locale (or anything else they choose) PR_FormatTimeUSEnglish(buffer, sizeof(buffer), "%a, %d %b %Y %H:%M:%S", &result.fe_time ); char *escapedDate = nsEscape(buffer, url_Path); aString.Append(escapedDate); nsMemory::Free(escapedDate); aString.Append(' '); // ENTRY TYPE if (type == 'd') aString.AppendLiteral("DIRECTORY"); else if (type == 'l') aString.AppendLiteral("SYMBOLIC-LINK"); else aString.AppendLiteral("FILE"); aString.Append(' '); aString.Append(char(nsCRT::LF)); // complete this line // END 201: if (cr) line = eol+2; else line = eol+1; } // end while(eol) return line; }
nsresult nsXHTMLContentSerializer::EscapeURI(nsIContent* aContent, const nsAString& aURI, nsAString& aEscapedURI) { // URL escape %xx cannot be used in JS. // No escaping if the scheme is 'javascript'. if (IsJavaScript(aContent, nsGkAtoms::href, kNameSpaceID_None, aURI)) { aEscapedURI = aURI; return NS_OK; } // nsITextToSubURI does charset convert plus uri escape // This is needed to convert to a document charset which is needed to support existing browsers. // But we eventually want to use UTF-8 instead of a document charset, then the code would be much simpler. // See HTML 4.01 spec, "Appendix B.2.1 Non-ASCII characters in URI attribute values" nsCOMPtr<nsITextToSubURI> textToSubURI; nsAutoString uri(aURI); // in order to use FindCharInSet() nsresult rv = NS_OK; if (!mCharset.IsEmpty() && !IsASCII(uri)) { textToSubURI = do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); } PRInt32 start = 0; PRInt32 end; nsAutoString part; nsXPIDLCString escapedURI; aEscapedURI.Truncate(0); // Loop and escape parts by avoiding escaping reserved characters // (and '%', '#', as well as '[' and ']' for IPv6 address literals). while ((end = uri.FindCharInSet("%#;/?:@&=+$,[]", start)) != -1) { part = Substring(aURI, start, (end-start)); if (textToSubURI && !IsASCII(part)) { rv = textToSubURI->ConvertAndEscape(mCharset.get(), part.get(), getter_Copies(escapedURI)); NS_ENSURE_SUCCESS(rv, rv); } else { escapedURI.Adopt(nsEscape(NS_ConvertUTF16toUTF8(part).get(), url_Path)); } AppendASCIItoUTF16(escapedURI, aEscapedURI); // Append a reserved character without escaping. part = Substring(aURI, end, 1); aEscapedURI.Append(part); start = end + 1; } if (start < (PRInt32) aURI.Length()) { // Escape the remaining part. part = Substring(aURI, start, aURI.Length()-start); if (textToSubURI) { rv = textToSubURI->ConvertAndEscape(mCharset.get(), part.get(), getter_Copies(escapedURI)); NS_ENSURE_SUCCESS(rv, rv); } else { escapedURI.Adopt(nsEscape(NS_ConvertUTF16toUTF8(part).get(), url_Path)); } AppendASCIItoUTF16(escapedURI, aEscapedURI); } return rv; }
nsresult FileSystemDataSource::GetFolderList(nsIRDFResource *source, bool allowHidden, bool onlyFirst, nsISimpleEnumerator** aResult) { if (!isDirURI(source)) return(NS_RDF_NO_VALUE); nsresult rv; const char *parentURI = nullptr; rv = source->GetValueConst(&parentURI); if (NS_FAILED(rv)) return(rv); if (!parentURI) return(NS_ERROR_UNEXPECTED); nsCOMPtr<nsIURI> aIURI; if (NS_FAILED(rv = NS_NewURI(getter_AddRefs(aIURI), nsDependentCString(parentURI)))) return(rv); nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(aIURI); if (!fileURL) return NS_OK; nsCOMPtr<nsIFile> aDir; if (NS_FAILED(rv = fileURL->GetFile(getter_AddRefs(aDir)))) return(rv); // ensure that we DO NOT resolve aliases aDir->SetFollowLinks(false); nsCOMPtr<nsISimpleEnumerator> dirContents; if (NS_FAILED(rv = aDir->GetDirectoryEntries(getter_AddRefs(dirContents)))) return(rv); if (!dirContents) return(NS_ERROR_UNEXPECTED); nsCOMArray<nsIRDFResource> resources; bool hasMore; while(NS_SUCCEEDED(rv = dirContents->HasMoreElements(&hasMore)) && hasMore) { nsCOMPtr<nsISupports> isupports; if (NS_FAILED(rv = dirContents->GetNext(getter_AddRefs(isupports)))) break; nsCOMPtr<nsIFile> aFile = do_QueryInterface(isupports); if (!aFile) break; if (!allowHidden) { bool hiddenFlag = false; if (NS_FAILED(rv = aFile->IsHidden(&hiddenFlag))) break; if (hiddenFlag) continue; } nsAutoString leafStr; if (NS_FAILED(rv = aFile->GetLeafName(leafStr))) break; if (leafStr.IsEmpty()) continue; nsAutoCString fullURI; fullURI.Assign(parentURI); if (fullURI.Last() != '/') { fullURI.Append('/'); } char *escLeafStr = nsEscape(NS_ConvertUTF16toUTF8(leafStr).get(), url_Path); leafStr.Truncate(); if (!escLeafStr) continue; nsAutoCString leaf(escLeafStr); free(escLeafStr); escLeafStr = nullptr; // using nsEscape() [above] doesn't escape slashes, so do that by hand int32_t aOffset; while ((aOffset = leaf.FindChar('/')) >= 0) { leaf.Cut((uint32_t)aOffset, 1); leaf.Insert("%2F", (uint32_t)aOffset); } // append the encoded name fullURI.Append(leaf); bool dirFlag = false; rv = aFile->IsDirectory(&dirFlag); if (NS_SUCCEEDED(rv) && dirFlag) { fullURI.Append('/'); } nsCOMPtr<nsIRDFResource> fileRes; mRDFService->GetResource(fullURI, getter_AddRefs(fileRes)); resources.AppendObject(fileRes); if (onlyFirst) break; } return NS_NewArrayEnumerator(aResult, resources); }