nsresult nsNDNChannel::BeginPumpingData() { nsresult rv; nsCOMPtr<nsIInputStream> stream; nsCOMPtr<nsIChannel> channel; rv = OpenContentStream(true, getter_AddRefs(stream), getter_AddRefs(channel)); if (NS_FAILED(rv)) return rv; NS_ASSERTION(!stream || !channel, "Got both a channel and a stream?"); /* if (channel) { rv = NS_DispatchToCurrentThread(new RedirectRunnable(this, channel)); if (NS_SUCCEEDED(rv)) mWaitingOnAsyncRedirect = true; return rv; } */ rv = NS_NewInputStreamPump(getter_AddRefs(mPump), stream, -1, -1, 0, 0, true); if (NS_SUCCEEDED(rv)) rv = mPump->AsyncRead(this, nsnull); return rv; }
nsresult nsWyciwygChannel::ReadFromCache() { LOG(("nsWyciwygChannel::ReadFromCache [this=%p] ", this)); NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_FAILURE); nsresult rv; // Get the stored security info mCacheEntry->GetSecurityInfo(getter_AddRefs(mSecurityInfo)); nsAutoCString tmpStr; rv = mCacheEntry->GetMetaDataElement("inhibit-persistent-caching", getter_Copies(tmpStr)); if (NS_SUCCEEDED(rv) && tmpStr.EqualsLiteral("1")) mLoadFlags |= INHIBIT_PERSISTENT_CACHING; // Get a transport to the cached data... rv = mCacheEntry->OpenInputStream(0, getter_AddRefs(mCacheInputStream)); if (NS_FAILED(rv)) return rv; NS_ENSURE_TRUE(mCacheInputStream, NS_ERROR_UNEXPECTED); rv = NS_NewInputStreamPump(getter_AddRefs(mPump), mCacheInputStream); if (NS_FAILED(rv)) return rv; // Pump the cache data downstream return mPump->AsyncRead(this, nullptr); }
inline nsresult nsZipWriter::BeginProcessingRemoval(int32_t aPos) { // Open the zip file for reading nsCOMPtr<nsIInputStream> inputStream; nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), mFile); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIInputStreamPump> pump; rv = NS_NewInputStreamPump(getter_AddRefs(pump), inputStream, -1, -1, 0, 0, true); if (NS_FAILED(rv)) { inputStream->Close(); return rv; } nsCOMPtr<nsIStreamListener> listener; rv = NS_NewSimpleStreamListener(getter_AddRefs(listener), mStream, this); if (NS_FAILED(rv)) { inputStream->Close(); return rv; } nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(mStream); rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, mHeaders[aPos]->mOffset); if (NS_FAILED(rv)) { inputStream->Close(); return rv; } uint32_t shift = (mHeaders[aPos + 1]->mOffset - mHeaders[aPos]->mOffset); mCDSOffset -= shift; int32_t pos2 = aPos + 1; while (pos2 < mHeaders.Count()) { mEntryHash.Put(mHeaders[pos2]->mName, pos2 - 1); mHeaders[pos2]->mOffset -= shift; pos2++; } mEntryHash.Remove(mHeaders[aPos]->mName); mHeaders.RemoveObjectAt(aPos); mCDSDirty = true; rv = pump->AsyncRead(listener, nullptr); if (NS_FAILED(rv)) { inputStream->Close(); Cleanup(); return rv; } return NS_OK; }
NS_IMETHODIMP nsJARChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctx) { LOG(("nsJARChannel::AsyncOpen [this=%x]\n", this)); NS_ENSURE_ARG_POINTER(listener); NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS); mJarFile = nsnull; mIsUnsafe = PR_TRUE; // Initialize mProgressSink NS_QueryNotificationCallbacks(mCallbacks, mLoadGroup, mProgressSink); nsresult rv = EnsureJarInput(PR_FALSE); if (NS_FAILED(rv)) return rv; // These variables must only be set if we're going to trigger an // OnStartRequest, either from AsyncRead or OnDownloadComplete. mListener = listener; mListenerContext = ctx; mIsPending = PR_TRUE; if (mJarInput) { // create input stream pump and call AsyncRead as a block rv = NS_NewInputStreamPump(getter_AddRefs(mPump), mJarInput); if (NS_SUCCEEDED(rv)) rv = mPump->AsyncRead(this, nsnull); // If we failed to create the pump or initiate the AsyncRead, // then we need to clear these variables. if (NS_FAILED(rv)) { mIsPending = PR_FALSE; mListenerContext = nsnull; mListener = nsnull; return rv; } } if (mLoadGroup) mLoadGroup->AddRequest(this, nsnull); return NS_OK; }
/** * asynchronously copy file. */ static nsresult RunTest(nsIFile *file, int64_t offset, int64_t length) { nsresult rv; LOG(("RunTest\n")); nsCOMPtr<nsIInputStream> stream; rv = NS_NewLocalFileInputStream(getter_AddRefs(stream), file); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIInputStreamPump> pump; rv = NS_NewInputStreamPump(getter_AddRefs(pump), stream, offset, length); if (NS_FAILED(rv)) return rv; rv = pump->AsyncRead(new MyListener(), nullptr); if (NS_FAILED(rv)) return rv; PumpEvents(); return NS_OK; }
nsresult nsWyciwygChannel::ReadFromCache() { LOG(("nsWyciwygChannel::ReadFromCache [this=%x] ", this)); NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_FAILURE); nsresult rv; // Get the stored security info mCacheEntry->GetSecurityInfo(getter_AddRefs(mSecurityInfo)); // Get a transport to the cached data... rv = mCacheEntry->OpenInputStream(0, getter_AddRefs(mCacheInputStream)); if (NS_FAILED(rv)) return rv; NS_ENSURE_TRUE(mCacheInputStream, NS_ERROR_UNEXPECTED); rv = NS_NewInputStreamPump(getter_AddRefs(mPump), mCacheInputStream); if (NS_FAILED(rv)) return rv; // Pump the cache data downstream return mPump->AsyncRead(this, nsnull); }
NS_IMETHODIMP nsJARChannel::OnDownloadComplete(nsIDownloader *downloader, nsIRequest *request, nsISupports *context, nsresult status, nsIFile *file) { nsresult rv; nsCOMPtr<nsIChannel> channel(do_QueryInterface(request)); if (channel) { PRUint32 loadFlags; channel->GetLoadFlags(&loadFlags); if (loadFlags & LOAD_REPLACE) { mLoadFlags |= LOAD_REPLACE; if (!mOriginalURI) { SetOriginalURI(mJarURI); } nsCOMPtr<nsIURI> innerURI; rv = channel->GetURI(getter_AddRefs(innerURI)); if (NS_SUCCEEDED(rv)) { nsCOMPtr<nsIJARURI> newURI; rv = mJarURI->CloneWithJARFile(innerURI, getter_AddRefs(newURI)); if (NS_SUCCEEDED(rv)) { mJarURI = newURI; } } if (NS_SUCCEEDED(status)) { status = rv; } } } if (NS_SUCCEEDED(status) && channel) { // Grab the security info from our base channel channel->GetSecurityInfo(getter_AddRefs(mSecurityInfo)); nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel)); if (httpChannel) { // We only want to run scripts if the server really intended to // send us a JAR file. Check the server-supplied content type for // a JAR type. nsCAutoString header; httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("Content-Type"), header); nsCAutoString contentType; nsCAutoString charset; NS_ParseContentType(header, contentType, charset); nsCAutoString channelContentType; channel->GetContentType(channelContentType); mIsUnsafe = !(contentType.Equals(channelContentType) && (contentType.EqualsLiteral("application/java-archive") || contentType.EqualsLiteral("application/x-jar"))); } else { nsCOMPtr<nsIJARChannel> innerJARChannel(do_QueryInterface(channel)); if (innerJARChannel) { PRBool unsafe; innerJARChannel->GetIsUnsafe(&unsafe); mIsUnsafe = unsafe; } } channel->GetContentDisposition(mContentDisposition); } if (NS_SUCCEEDED(status) && mIsUnsafe) { PRBool allowUnpack = PR_FALSE; nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); if (prefs) { prefs->GetBoolPref("network.jar.open-unsafe-types", &allowUnpack); } if (!allowUnpack) { status = NS_ERROR_UNSAFE_CONTENT_TYPE; } } if (NS_SUCCEEDED(status)) { // Refuse to unpack view-source: jars even if open-unsafe-types is set. nsCOMPtr<nsIViewSourceChannel> viewSource = do_QueryInterface(channel); if (viewSource) { status = NS_ERROR_UNSAFE_CONTENT_TYPE; } } if (NS_SUCCEEDED(status)) { mJarFile = file; rv = CreateJarInput(nsnull); if (NS_SUCCEEDED(rv)) { // create input stream pump rv = NS_NewInputStreamPump(getter_AddRefs(mPump), mJarInput); if (NS_SUCCEEDED(rv)) rv = mPump->AsyncRead(this, nsnull); } status = rv; } if (NS_FAILED(status)) { mStatus = status; OnStartRequest(nsnull, nsnull); OnStopRequest(nsnull, nsnull, status); } return NS_OK; }
NS_IMETHODIMP nsGopherChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *ctxt) { PR_LOG(gGopherLog, PR_LOG_DEBUG, ("nsGopherChannel::AsyncOpen() called [this=%x]\n", this)); // get callback interfaces... nsresult rv; PRInt32 port; rv = mUrl->GetPort(&port); if (NS_FAILED(rv)) return rv; rv = NS_CheckPortSafety(port, "gopher"); if (NS_FAILED(rv)) return rv; // push stream converters in front of the consumer... nsCOMPtr<nsIStreamListener> converter; rv = PushStreamConverters(aListener, getter_AddRefs(converter)); if (NS_FAILED(rv)) return rv; // create socket transport nsCOMPtr<nsISocketTransportService> socketService = do_GetService(kSocketTransportServiceCID, &rv); if (NS_FAILED(rv)) return rv; rv = socketService->CreateTransport(nsnull, 0, mHost, mPort, mProxyInfo, getter_AddRefs(mTransport)); if (NS_FAILED(rv)) return rv; // setup notification callbacks... if (!(mLoadFlags & LOAD_BACKGROUND)) { nsCOMPtr<nsIEventQueue> eventQ; NS_GetCurrentEventQ(getter_AddRefs(eventQ)); if (eventQ) mTransport->SetEventSink(this, eventQ); } // open buffered, asynchronous socket input stream, and use a input stream // pump to read from it. nsCOMPtr<nsIInputStream> input; rv = mTransport->OpenInputStream(0, 0, 0, getter_AddRefs(input)); if (NS_FAILED(rv)) return rv; rv = SendRequest(); if (NS_FAILED(rv)) return rv; rv = NS_NewInputStreamPump(getter_AddRefs(mPump), input); if (NS_FAILED(rv)) return rv; rv = mPump->AsyncRead(this, nsnull); if (NS_FAILED(rv)) return rv; if (mLoadGroup) mLoadGroup->AddRequest(this, nsnull); mIsPending = PR_TRUE; if (converter) mListener = converter; else mListener = aListener; mListenerContext = ctxt; return NS_OK; }
NS_IMETHODIMP nsFingerChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *ctxt) { nsresult rv = NS_CheckPortSafety(mPort, "finger"); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIThread> thread = do_GetCurrentThread(); NS_ENSURE_STATE(thread); // // create transport // nsCOMPtr<nsISocketTransportService> sts = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv); if (NS_FAILED(rv)) return rv; rv = sts->CreateTransport(nsnull, 0, mHost, mPort, mProxyInfo, getter_AddRefs(mTransport)); if (NS_FAILED(rv)) return rv; // not fatal if this fails mTransport->SetEventSink(this, thread); rv = WriteRequest(mTransport); if (NS_FAILED(rv)) return rv; // // create TXT to HTML stream converter // nsCOMPtr<nsIStreamConverterService> scs = do_GetService(NS_STREAMCONVERTERSERVICE_CONTRACTID, &rv); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIStreamListener> convListener; rv = scs->AsyncConvertData("text/plain", "text/html", this, nsnull, getter_AddRefs(convListener)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsITXTToHTMLConv> conv = do_QueryInterface(convListener); if (conv) { nsCAutoString userHost; rv = mURI->GetPath(userHost); nsAutoString title; title.AppendLiteral("Finger information for "); AppendUTF8toUTF16(userHost, title); conv->SetTitle(title.get()); conv->PreFormatHTML(PR_TRUE); } // // open input stream, and create input stream pump... // nsCOMPtr<nsIInputStream> sockIn; rv = mTransport->OpenInputStream(0, 0, 0, getter_AddRefs(sockIn)); if (NS_FAILED(rv)) return rv; rv = NS_NewInputStreamPump(getter_AddRefs(mPump), sockIn); if (NS_FAILED(rv)) return rv; rv = mPump->AsyncRead(convListener, nsnull); if (NS_FAILED(rv)) return rv; if (mLoadGroup) mLoadGroup->AddRequest(this, nsnull); mListener = aListener; mListenerContext = ctxt; return NS_OK; }
inline nsresult nsZipWriter::BeginProcessingAddition(nsZipQueueItem* aItem, bool* complete) { if (aItem->mFile) { bool exists; nsresult rv = aItem->mFile->Exists(&exists); NS_ENSURE_SUCCESS(rv, rv); if (!exists) return NS_ERROR_FILE_NOT_FOUND; bool isdir; rv = aItem->mFile->IsDirectory(&isdir); NS_ENSURE_SUCCESS(rv, rv); rv = aItem->mFile->GetLastModifiedTime(&aItem->mModTime); NS_ENSURE_SUCCESS(rv, rv); aItem->mModTime *= PR_USEC_PER_MSEC; rv = aItem->mFile->GetPermissions(&aItem->mPermissions); NS_ENSURE_SUCCESS(rv, rv); if (!isdir) { // Set up for fall through to stream reader rv = NS_NewLocalFileInputStream(getter_AddRefs(aItem->mStream), aItem->mFile); NS_ENSURE_SUCCESS(rv, rv); } // If a dir then this will fall through to the plain dir addition } uint32_t zipAttributes = ZIP_ATTRS(aItem->mPermissions, ZIP_ATTRS_FILE); if (aItem->mStream || aItem->mChannel) { nsRefPtr<nsZipHeader> header = new nsZipHeader(); NS_ENSURE_TRUE(header, NS_ERROR_OUT_OF_MEMORY); header->Init(aItem->mZipEntry, aItem->mModTime, zipAttributes, mCDSOffset); nsresult rv = header->WriteFileHeader(mStream); NS_ENSURE_SUCCESS(rv, rv); nsRefPtr<nsZipDataStream> stream = new nsZipDataStream(); NS_ENSURE_TRUE(stream, NS_ERROR_OUT_OF_MEMORY); rv = stream->Init(this, mStream, header, aItem->mCompression); NS_ENSURE_SUCCESS(rv, rv); if (aItem->mStream) { nsCOMPtr<nsIInputStreamPump> pump; rv = NS_NewInputStreamPump(getter_AddRefs(pump), aItem->mStream, -1, -1, 0, 0, true); NS_ENSURE_SUCCESS(rv, rv); rv = pump->AsyncRead(stream, nullptr); NS_ENSURE_SUCCESS(rv, rv); } else { rv = aItem->mChannel->AsyncOpen(stream, nullptr); NS_ENSURE_SUCCESS(rv, rv); } return NS_OK; } // Must be plain directory addition *complete = true; return InternalAddEntryDirectory(aItem->mZipEntry, aItem->mModTime, aItem->mPermissions); }
// stop binding is a "notification" informing us that the stream associated with aURL is going away. NS_IMETHODIMP nsMailboxProtocol::OnStopRequest(nsIRequest *request, nsISupports *ctxt, nsresult aStatus) { nsresult rv; if (m_nextState == MAILBOX_READ_FOLDER && m_mailboxParser) { // we need to inform our mailbox parser that there is no more incoming data... m_mailboxParser->OnStopRequest(request, ctxt, aStatus); } else if (m_nextState == MAILBOX_READ_MESSAGE) { DoneReadingMessage(); } // I'm not getting cancel status - maybe the load group still has the status. PRBool stopped = PR_FALSE; if (m_runningUrl) { nsCOMPtr <nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningUrl); if (mailnewsUrl) { nsCOMPtr <nsIMsgWindow> window; mailnewsUrl->GetMsgWindow(getter_AddRefs(window)); if (window) window->GetStopped(&stopped); } if (!stopped && NS_SUCCEEDED(aStatus) && (m_mailboxAction == nsIMailboxUrl::ActionCopyMessage || m_mailboxAction == nsIMailboxUrl::ActionMoveMessage)) { PRUint32 numMoveCopyMsgs; PRUint32 curMoveCopyMsgIndex; rv = m_runningUrl->GetNumMoveCopyMsgs(&numMoveCopyMsgs); if (NS_SUCCEEDED(rv) && numMoveCopyMsgs > 0) { m_runningUrl->GetCurMoveCopyMsgIndex(&curMoveCopyMsgIndex); if (++curMoveCopyMsgIndex < numMoveCopyMsgs) { if (!mSuppressListenerNotifications && m_channelListener) { nsCOMPtr<nsICopyMessageStreamListener> listener = do_QueryInterface(m_channelListener, &rv); if (listener) { listener->EndCopy(ctxt, aStatus); listener->StartMessage(); // start next message. } } m_runningUrl->SetCurMoveCopyMsgIndex(curMoveCopyMsgIndex); nsCOMPtr <nsIMsgDBHdr> nextMsg; rv = m_runningUrl->GetMoveCopyMsgHdrForIndex(curMoveCopyMsgIndex, getter_AddRefs(nextMsg)); if (NS_SUCCEEDED(rv) && nextMsg) { PRUint32 msgSize = 0; nsMsgKey msgKey; nsCOMPtr <nsIMsgFolder> msgFolder; nextMsg->GetFolder(getter_AddRefs(msgFolder)); NS_ASSERTION(msgFolder, "couldn't get folder for next msg in multiple msg local copy"); if (msgFolder) { nsCString uri; msgFolder->GetUriForMsg(nextMsg, uri); nsCOMPtr<nsIMsgMessageUrl> msgUrl = do_QueryInterface(m_runningUrl); if (msgUrl) { msgUrl->SetOriginalSpec(uri.get()); msgUrl->SetUri(uri.get()); nextMsg->GetMessageKey(&msgKey); nextMsg->GetMessageSize(&msgSize); // now we have to seek to the right position in the file and // basically re-initialize the transport with the correct message size. // then, we have to make sure the url keeps running somehow. nsCOMPtr<nsISupports> urlSupports = do_QueryInterface(m_runningUrl); // // put us in a state where we are always notified of incoming data // m_transport = 0; // open new stream transport m_inputStream = 0; m_outputStream = 0; rv = OpenMultipleMsgTransport(msgKey, msgSize); if (NS_SUCCEEDED(rv)) { if (!m_inputStream) rv = m_transport->OpenInputStream(0, 0, 0, getter_AddRefs(m_inputStream)); if (NS_SUCCEEDED(rv)) { nsCOMPtr<nsIInputStreamPump> pump; rv = NS_NewInputStreamPump(getter_AddRefs(pump), m_inputStream); if (NS_SUCCEEDED(rv)) { rv = pump->AsyncRead(this, urlSupports); if (NS_SUCCEEDED(rv)) m_request = pump; } } } NS_ASSERTION(NS_SUCCEEDED(rv), "AsyncRead failed"); if (m_loadGroup) m_loadGroup->RemoveRequest(static_cast<nsIRequest *>(this), nsnull, aStatus); m_socketIsOpen = PR_TRUE; // mark the channel as open return aStatus; } } } } else { } } } } // and we want to mark ourselves for deletion or some how inform our protocol manager that we are // available for another url if there is one. // mscott --> maybe we should set our state to done because we don't run multiple urls in a mailbox // protocol connection.... m_nextState = MAILBOX_DONE; // the following is for smoke test purposes. QA is looking at this "Mailbox Done" string which // is printed out to the console and determining if the mail app loaded up correctly...obviously // this solution is not very good so we should look at something better, but don't remove this // line before talking to me (mscott) and mailnews QA.... PR_LOG(MAILBOX, PR_LOG_ALWAYS, ("Mailbox Done\n")); // when on stop binding is called, we as the protocol are done...let's close down the connection // releasing all of our interfaces. It's important to remember that this on stop binding call // is coming from netlib so they are never going to ping us again with on data available. This means // we'll never be going through the Process loop... if (m_multipleMsgMoveCopyStream) { m_multipleMsgMoveCopyStream->Close(); m_multipleMsgMoveCopyStream = nsnull; } nsMsgProtocol::OnStopRequest(request, ctxt, aStatus); return CloseSocket(); }