mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-20 00:35:44 +00:00
f9bdfe10bb
Backed out changeset 7c0ec55b44dc (bug 1339710) Backed out changeset cbb4e1c2aada (bug 1339710) Backed out changeset c685dca493f5 (bug 1339710) Backed out changeset 4761a15d45fd (bug 1339710) Backed out changeset 7561692c1bc7 (bug 1339710)
1151 lines
31 KiB
C++
1151 lines
31 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "ipc/IPCMessageUtils.h"
|
|
|
|
#if defined(XP_UNIX) || defined(XP_BEOS)
|
|
#include <unistd.h>
|
|
#elif defined(XP_WIN)
|
|
#include <windows.h>
|
|
#include "nsILocalFileWin.h"
|
|
#else
|
|
// XXX add necessary include file for ftruncate (or equivalent)
|
|
#endif
|
|
|
|
#include "private/pprio.h"
|
|
|
|
#include "nsFileStreams.h"
|
|
#include "nsIFile.h"
|
|
#include "nsReadLine.h"
|
|
#include "nsIClassInfoImpl.h"
|
|
#include "mozilla/ipc/InputStreamUtils.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "mozilla/FileUtils.h"
|
|
#include "nsNetCID.h"
|
|
#include "nsXULAppAPI.h"
|
|
|
|
#define NS_NO_INPUT_BUFFERING 1 // see http://bugzilla.mozilla.org/show_bug.cgi?id=41067
|
|
|
|
typedef mozilla::ipc::FileDescriptor::PlatformHandleType FileHandleType;
|
|
|
|
using namespace mozilla::ipc;
|
|
using mozilla::DebugOnly;
|
|
using mozilla::Maybe;
|
|
using mozilla::Nothing;
|
|
using mozilla::Some;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// nsFileStreamBase
|
|
|
|
nsFileStreamBase::nsFileStreamBase()
|
|
: mFD(nullptr)
|
|
, mBehaviorFlags(0)
|
|
, mDeferredOpen(false)
|
|
{
|
|
}
|
|
|
|
nsFileStreamBase::~nsFileStreamBase()
|
|
{
|
|
Close();
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS(nsFileStreamBase,
|
|
nsISeekableStream,
|
|
nsIFileMetadata)
|
|
|
|
NS_IMETHODIMP
|
|
nsFileStreamBase::Seek(int32_t whence, int64_t offset)
|
|
{
|
|
nsresult rv = DoPendingOpen();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (mFD == nullptr)
|
|
return NS_BASE_STREAM_CLOSED;
|
|
|
|
int64_t cnt = PR_Seek64(mFD, offset, (PRSeekWhence)whence);
|
|
if (cnt == int64_t(-1)) {
|
|
return NS_ErrorAccordingToNSPR();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileStreamBase::Tell(int64_t *result)
|
|
{
|
|
nsresult rv = DoPendingOpen();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (mFD == nullptr)
|
|
return NS_BASE_STREAM_CLOSED;
|
|
|
|
int64_t cnt = PR_Seek64(mFD, 0, PR_SEEK_CUR);
|
|
if (cnt == int64_t(-1)) {
|
|
return NS_ErrorAccordingToNSPR();
|
|
}
|
|
*result = cnt;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileStreamBase::SetEOF()
|
|
{
|
|
nsresult rv = DoPendingOpen();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (mFD == nullptr)
|
|
return NS_BASE_STREAM_CLOSED;
|
|
|
|
#if defined(XP_UNIX) || defined(XP_BEOS)
|
|
// Some system calls require an EOF offset.
|
|
int64_t offset;
|
|
rv = Tell(&offset);
|
|
if (NS_FAILED(rv)) return rv;
|
|
#endif
|
|
|
|
#if defined(XP_UNIX) || defined(XP_BEOS)
|
|
if (ftruncate(PR_FileDesc2NativeHandle(mFD), offset) != 0) {
|
|
NS_ERROR("ftruncate failed");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
#elif defined(XP_WIN)
|
|
if (!SetEndOfFile((HANDLE) PR_FileDesc2NativeHandle(mFD))) {
|
|
NS_ERROR("SetEndOfFile failed");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
#else
|
|
// XXX not implemented
|
|
#endif
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileStreamBase::GetSize(int64_t* _retval)
|
|
{
|
|
nsresult rv = DoPendingOpen();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (!mFD) {
|
|
return NS_BASE_STREAM_CLOSED;
|
|
}
|
|
|
|
PRFileInfo64 info;
|
|
if (PR_GetOpenFileInfo64(mFD, &info) == PR_FAILURE) {
|
|
return NS_BASE_STREAM_OSERROR;
|
|
}
|
|
|
|
*_retval = int64_t(info.size);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileStreamBase::GetLastModified(int64_t* _retval)
|
|
{
|
|
nsresult rv = DoPendingOpen();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (!mFD) {
|
|
return NS_BASE_STREAM_CLOSED;
|
|
}
|
|
|
|
PRFileInfo64 info;
|
|
if (PR_GetOpenFileInfo64(mFD, &info) == PR_FAILURE) {
|
|
return NS_BASE_STREAM_OSERROR;
|
|
}
|
|
|
|
int64_t modTime = int64_t(info.modifyTime);
|
|
if (modTime == 0) {
|
|
*_retval = 0;
|
|
}
|
|
else {
|
|
*_retval = modTime / int64_t(PR_USEC_PER_MSEC);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileStreamBase::GetFileDescriptor(PRFileDesc** _retval)
|
|
{
|
|
nsresult rv = DoPendingOpen();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
if (!mFD) {
|
|
return NS_BASE_STREAM_CLOSED;
|
|
}
|
|
|
|
*_retval = mFD;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::Close()
|
|
{
|
|
CleanUpOpen();
|
|
|
|
nsresult rv = NS_OK;
|
|
if (mFD) {
|
|
if (PR_Close(mFD) == PR_FAILURE)
|
|
rv = NS_BASE_STREAM_OSERROR;
|
|
mFD = nullptr;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::Available(uint64_t* aResult)
|
|
{
|
|
nsresult rv = DoPendingOpen();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (!mFD) {
|
|
return NS_BASE_STREAM_CLOSED;
|
|
}
|
|
|
|
// PR_Available with files over 4GB returns an error, so we have to
|
|
// use the 64-bit version of PR_Available.
|
|
int64_t avail = PR_Available64(mFD);
|
|
if (avail == -1) {
|
|
return NS_ErrorAccordingToNSPR();
|
|
}
|
|
|
|
// If available is greater than 4GB, return 4GB
|
|
*aResult = (uint64_t)avail;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::Read(char* aBuf, uint32_t aCount, uint32_t* aResult)
|
|
{
|
|
nsresult rv = DoPendingOpen();
|
|
if (rv == NS_ERROR_FILE_NOT_FOUND) {
|
|
// Don't warn if this is just a deferred file not found.
|
|
return rv;
|
|
}
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (!mFD) {
|
|
*aResult = 0;
|
|
return NS_OK;
|
|
}
|
|
|
|
int32_t bytesRead = PR_Read(mFD, aBuf, aCount);
|
|
if (bytesRead == -1) {
|
|
return NS_ErrorAccordingToNSPR();
|
|
}
|
|
|
|
*aResult = bytesRead;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::ReadSegments(nsWriteSegmentFun aWriter, void* aClosure,
|
|
uint32_t aCount, uint32_t* aResult)
|
|
{
|
|
// ReadSegments is not implemented because it would be inefficient when
|
|
// the writer does not consume all data. If you want to call ReadSegments,
|
|
// wrap a BufferedInputStream around the file stream. That will call
|
|
// Read().
|
|
|
|
// If this is ever implemented you might need to modify
|
|
// nsPartialFileInputStream::ReadSegments
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::IsNonBlocking(bool *aNonBlocking)
|
|
{
|
|
*aNonBlocking = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::Flush(void)
|
|
{
|
|
nsresult rv = DoPendingOpen();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (mFD == nullptr)
|
|
return NS_BASE_STREAM_CLOSED;
|
|
|
|
int32_t cnt = PR_Sync(mFD);
|
|
if (cnt == -1) {
|
|
return NS_ErrorAccordingToNSPR();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::Write(const char *buf, uint32_t count, uint32_t *result)
|
|
{
|
|
nsresult rv = DoPendingOpen();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (mFD == nullptr)
|
|
return NS_BASE_STREAM_CLOSED;
|
|
|
|
int32_t cnt = PR_Write(mFD, buf, count);
|
|
if (cnt == -1) {
|
|
return NS_ErrorAccordingToNSPR();
|
|
}
|
|
*result = cnt;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::WriteFrom(nsIInputStream *inStr, uint32_t count, uint32_t *_retval)
|
|
{
|
|
NS_NOTREACHED("WriteFrom (see source comment)");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
// File streams intentionally do not support this method.
|
|
// If you need something like this, then you should wrap
|
|
// the file stream using nsIBufferedOutputStream
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::WriteSegments(nsReadSegmentFun reader, void * closure, uint32_t count, uint32_t *_retval)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
// File streams intentionally do not support this method.
|
|
// If you need something like this, then you should wrap
|
|
// the file stream using nsIBufferedOutputStream
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::MaybeOpen(nsIFile* aFile, int32_t aIoFlags,
|
|
int32_t aPerm, bool aDeferred)
|
|
{
|
|
NS_ENSURE_STATE(aFile);
|
|
|
|
mOpenParams.ioFlags = aIoFlags;
|
|
mOpenParams.perm = aPerm;
|
|
|
|
if (aDeferred) {
|
|
// Clone the file, as it may change between now and the deferred open
|
|
nsCOMPtr<nsIFile> file;
|
|
nsresult rv = aFile->Clone(getter_AddRefs(file));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
mOpenParams.localFile = do_QueryInterface(file);
|
|
NS_ENSURE_TRUE(mOpenParams.localFile, NS_ERROR_UNEXPECTED);
|
|
|
|
mDeferredOpen = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
mOpenParams.localFile = aFile;
|
|
|
|
// Following call open() at main thread.
|
|
// Main thread might be blocked, while open a remote file.
|
|
return DoOpen();
|
|
}
|
|
|
|
void
|
|
nsFileStreamBase::CleanUpOpen()
|
|
{
|
|
mOpenParams.localFile = nullptr;
|
|
mDeferredOpen = false;
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::DoOpen()
|
|
{
|
|
NS_ASSERTION(!mFD, "Already have a file descriptor!");
|
|
NS_ASSERTION(mOpenParams.localFile, "Must have a file to open");
|
|
|
|
PRFileDesc* fd;
|
|
nsresult rv;
|
|
|
|
#ifdef XP_WIN
|
|
if (mBehaviorFlags & nsIFileInputStream::SHARE_DELETE) {
|
|
nsCOMPtr<nsILocalFileWin> file = do_QueryInterface(mOpenParams.localFile);
|
|
MOZ_ASSERT(file);
|
|
|
|
rv = file->OpenNSPRFileDescShareDelete(mOpenParams.ioFlags,
|
|
mOpenParams.perm,
|
|
&fd);
|
|
} else
|
|
#endif // XP_WIN
|
|
{
|
|
rv = mOpenParams.localFile->OpenNSPRFileDesc(mOpenParams.ioFlags,
|
|
mOpenParams.perm,
|
|
&fd);
|
|
}
|
|
|
|
CleanUpOpen();
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
mFD = fd;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsFileStreamBase::DoPendingOpen()
|
|
{
|
|
if (!mDeferredOpen) {
|
|
return NS_OK;
|
|
}
|
|
|
|
return DoOpen();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// nsFileInputStream
|
|
|
|
NS_IMPL_ADDREF_INHERITED(nsFileInputStream, nsFileStreamBase)
|
|
NS_IMPL_RELEASE_INHERITED(nsFileInputStream, nsFileStreamBase)
|
|
|
|
NS_IMPL_CLASSINFO(nsFileInputStream, nullptr, nsIClassInfo::THREADSAFE,
|
|
NS_LOCALFILEINPUTSTREAM_CID)
|
|
|
|
NS_INTERFACE_MAP_BEGIN(nsFileInputStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsIInputStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsIFileInputStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsILineInputStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsIIPCSerializableInputStream)
|
|
NS_IMPL_QUERY_CLASSINFO(nsFileInputStream)
|
|
NS_INTERFACE_MAP_END_INHERITING(nsFileStreamBase)
|
|
|
|
NS_IMPL_CI_INTERFACE_GETTER(nsFileInputStream,
|
|
nsIInputStream,
|
|
nsIFileInputStream,
|
|
nsISeekableStream,
|
|
nsILineInputStream)
|
|
|
|
nsresult
|
|
nsFileInputStream::Create(nsISupports *aOuter, REFNSIID aIID, void **aResult)
|
|
{
|
|
NS_ENSURE_NO_AGGREGATION(aOuter);
|
|
|
|
nsFileInputStream* stream = new nsFileInputStream();
|
|
if (stream == nullptr)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
NS_ADDREF(stream);
|
|
nsresult rv = stream->QueryInterface(aIID, aResult);
|
|
NS_RELEASE(stream);
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsFileInputStream::Open(nsIFile* aFile, int32_t aIOFlags, int32_t aPerm)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
// If the previous file is open, close it
|
|
if (mFD) {
|
|
rv = Close();
|
|
if (NS_FAILED(rv)) return rv;
|
|
}
|
|
|
|
// Open the file
|
|
if (aIOFlags == -1)
|
|
aIOFlags = PR_RDONLY;
|
|
if (aPerm == -1)
|
|
aPerm = 0;
|
|
|
|
rv = MaybeOpen(aFile, aIOFlags, aPerm,
|
|
mBehaviorFlags & nsIFileInputStream::DEFER_OPEN);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
// if defer open is set, do not remove the file here.
|
|
// remove the file while Close() is called.
|
|
if ((mBehaviorFlags & DELETE_ON_CLOSE) &&
|
|
!(mBehaviorFlags & nsIFileInputStream::DEFER_OPEN)) {
|
|
// POSIX compatible filesystems allow a file to be unlinked while a
|
|
// file descriptor is still referencing the file. since we've already
|
|
// opened the file descriptor, we'll try to remove the file. if that
|
|
// fails, then we'll just remember the nsIFile and remove it after we
|
|
// close the file descriptor.
|
|
rv = aFile->Remove(false);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
// No need to remove it later. Clear the flag.
|
|
mBehaviorFlags &= ~DELETE_ON_CLOSE;
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileInputStream::Init(nsIFile* aFile, int32_t aIOFlags, int32_t aPerm,
|
|
int32_t aBehaviorFlags)
|
|
{
|
|
NS_ENSURE_TRUE(!mFD, NS_ERROR_ALREADY_INITIALIZED);
|
|
NS_ENSURE_TRUE(!mDeferredOpen, NS_ERROR_ALREADY_INITIALIZED);
|
|
|
|
mBehaviorFlags = aBehaviorFlags;
|
|
|
|
mFile = aFile;
|
|
mIOFlags = aIOFlags;
|
|
mPerm = aPerm;
|
|
|
|
return Open(aFile, aIOFlags, aPerm);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileInputStream::Close()
|
|
{
|
|
// Get the cache position at the time the file was close. This allows
|
|
// NS_SEEK_CUR on a closed file that has been opened with
|
|
// REOPEN_ON_REWIND.
|
|
if (mBehaviorFlags & REOPEN_ON_REWIND) {
|
|
// Get actual position. Not one modified by subclasses
|
|
nsFileStreamBase::Tell(&mCachedPosition);
|
|
}
|
|
|
|
// null out mLineBuffer in case Close() is called again after failing
|
|
mLineBuffer = nullptr;
|
|
nsresult rv = nsFileStreamBase::Close();
|
|
if (NS_FAILED(rv)) return rv;
|
|
if (mFile && (mBehaviorFlags & DELETE_ON_CLOSE)) {
|
|
rv = mFile->Remove(false);
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to delete file");
|
|
// If we don't need to save the file for reopening, free it up
|
|
if (!(mBehaviorFlags & REOPEN_ON_REWIND)) {
|
|
mFile = nullptr;
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileInputStream::Read(char* aBuf, uint32_t aCount, uint32_t* _retval)
|
|
{
|
|
nsresult rv = nsFileStreamBase::Read(aBuf, aCount, _retval);
|
|
if (rv == NS_ERROR_FILE_NOT_FOUND) {
|
|
// Don't warn if this is a deffered file not found.
|
|
return rv;
|
|
}
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Check if we're at the end of file and need to close
|
|
if (mBehaviorFlags & CLOSE_ON_EOF && *_retval == 0) {
|
|
Close();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileInputStream::ReadLine(nsACString& aLine, bool* aResult)
|
|
{
|
|
if (!mLineBuffer) {
|
|
mLineBuffer = new nsLineBuffer<char>;
|
|
}
|
|
return NS_ReadLine(this, mLineBuffer.get(), aLine, aResult);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileInputStream::Seek(int32_t aWhence, int64_t aOffset)
|
|
{
|
|
return SeekInternal(aWhence, aOffset);
|
|
}
|
|
|
|
nsresult
|
|
nsFileInputStream::SeekInternal(int32_t aWhence, int64_t aOffset, bool aClearBuf)
|
|
{
|
|
nsresult rv = DoPendingOpen();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (aClearBuf) {
|
|
mLineBuffer = nullptr;
|
|
}
|
|
if (!mFD) {
|
|
if (mBehaviorFlags & REOPEN_ON_REWIND) {
|
|
rv = Open(mFile, mIOFlags, mPerm);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// If the file was closed, and we do a relative seek, use the
|
|
// position we cached when we closed the file to seek to the right
|
|
// location.
|
|
if (aWhence == NS_SEEK_CUR) {
|
|
aWhence = NS_SEEK_SET;
|
|
aOffset += mCachedPosition;
|
|
}
|
|
} else {
|
|
return NS_BASE_STREAM_CLOSED;
|
|
}
|
|
}
|
|
|
|
return nsFileStreamBase::Seek(aWhence, aOffset);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileInputStream::Tell(int64_t *aResult)
|
|
{
|
|
return nsFileStreamBase::Tell(aResult);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileInputStream::Available(uint64_t *aResult)
|
|
{
|
|
return nsFileStreamBase::Available(aResult);
|
|
}
|
|
|
|
void
|
|
nsFileInputStream::Serialize(InputStreamParams& aParams,
|
|
FileDescriptorArray& aFileDescriptors)
|
|
{
|
|
FileInputStreamParams params;
|
|
|
|
if (NS_SUCCEEDED(DoPendingOpen()) && mFD) {
|
|
FileHandleType fd = FileHandleType(PR_FileDesc2NativeHandle(mFD));
|
|
NS_ASSERTION(fd, "This should never be null!");
|
|
|
|
DebugOnly<FileDescriptor*> dbgFD = aFileDescriptors.AppendElement(fd);
|
|
NS_ASSERTION(dbgFD->IsValid(), "Sending an invalid file descriptor!");
|
|
|
|
params.fileDescriptorIndex() = aFileDescriptors.Length() - 1;
|
|
|
|
Close();
|
|
} else {
|
|
NS_WARNING("This file has not been opened (or could not be opened). "
|
|
"Sending an invalid file descriptor to the other process!");
|
|
|
|
params.fileDescriptorIndex() = UINT32_MAX;
|
|
}
|
|
|
|
int32_t behaviorFlags = mBehaviorFlags;
|
|
|
|
// The receiving process (or thread) is going to have an open file
|
|
// descriptor automatically so transferring this flag is meaningless.
|
|
behaviorFlags &= ~nsIFileInputStream::DEFER_OPEN;
|
|
|
|
params.behaviorFlags() = behaviorFlags;
|
|
params.ioFlags() = mIOFlags;
|
|
|
|
aParams = params;
|
|
}
|
|
|
|
bool
|
|
nsFileInputStream::Deserialize(const InputStreamParams& aParams,
|
|
const FileDescriptorArray& aFileDescriptors)
|
|
{
|
|
NS_ASSERTION(!mFD, "Already have a file descriptor?!");
|
|
NS_ASSERTION(!mDeferredOpen, "Deferring open?!");
|
|
NS_ASSERTION(!mFile, "Should never have a file here!");
|
|
NS_ASSERTION(!mPerm, "This should always be 0!");
|
|
|
|
if (aParams.type() != InputStreamParams::TFileInputStreamParams) {
|
|
NS_WARNING("Received unknown parameters from the other process!");
|
|
return false;
|
|
}
|
|
|
|
const FileInputStreamParams& params = aParams.get_FileInputStreamParams();
|
|
|
|
uint32_t fileDescriptorIndex = params.fileDescriptorIndex();
|
|
|
|
FileDescriptor fd;
|
|
if (fileDescriptorIndex < aFileDescriptors.Length()) {
|
|
fd = aFileDescriptors[fileDescriptorIndex];
|
|
NS_WARNING_ASSERTION(fd.IsValid(),
|
|
"Received an invalid file descriptor!");
|
|
} else {
|
|
NS_WARNING("Received a bad file descriptor index!");
|
|
}
|
|
|
|
if (fd.IsValid()) {
|
|
auto rawFD = fd.ClonePlatformHandle();
|
|
PRFileDesc* fileDesc = PR_ImportFile(PROsfd(rawFD.release()));
|
|
if (!fileDesc) {
|
|
NS_WARNING("Failed to import file handle!");
|
|
return false;
|
|
}
|
|
mFD = fileDesc;
|
|
}
|
|
|
|
mBehaviorFlags = params.behaviorFlags();
|
|
|
|
if (!XRE_IsParentProcess()) {
|
|
// A child process shouldn't close when it reads the end because it will
|
|
// not be able to reopen the file later.
|
|
mBehaviorFlags &= ~nsIFileInputStream::CLOSE_ON_EOF;
|
|
|
|
// A child process will not be able to reopen the file so this flag is
|
|
// meaningless.
|
|
mBehaviorFlags &= ~nsIFileInputStream::REOPEN_ON_REWIND;
|
|
}
|
|
|
|
mIOFlags = params.ioFlags();
|
|
|
|
return true;
|
|
}
|
|
|
|
Maybe<uint64_t>
|
|
nsFileInputStream::ExpectedSerializedLength()
|
|
{
|
|
return Nothing();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// nsPartialFileInputStream
|
|
|
|
NS_IMPL_ADDREF_INHERITED(nsPartialFileInputStream, nsFileStreamBase)
|
|
NS_IMPL_RELEASE_INHERITED(nsPartialFileInputStream, nsFileStreamBase)
|
|
|
|
NS_IMPL_CLASSINFO(nsPartialFileInputStream, nullptr, nsIClassInfo::THREADSAFE,
|
|
NS_PARTIALLOCALFILEINPUTSTREAM_CID)
|
|
|
|
// Don't forward to nsFileInputStream as we don't want to QI to
|
|
// nsIFileInputStream
|
|
NS_INTERFACE_MAP_BEGIN(nsPartialFileInputStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsIInputStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsIPartialFileInputStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsILineInputStream)
|
|
NS_INTERFACE_MAP_ENTRY(nsIIPCSerializableInputStream)
|
|
NS_IMPL_QUERY_CLASSINFO(nsPartialFileInputStream)
|
|
NS_INTERFACE_MAP_END_INHERITING(nsFileStreamBase)
|
|
|
|
NS_IMPL_CI_INTERFACE_GETTER(nsPartialFileInputStream,
|
|
nsIInputStream,
|
|
nsIPartialFileInputStream,
|
|
nsISeekableStream,
|
|
nsILineInputStream)
|
|
|
|
nsresult
|
|
nsPartialFileInputStream::Create(nsISupports *aOuter, REFNSIID aIID,
|
|
void **aResult)
|
|
{
|
|
NS_ENSURE_NO_AGGREGATION(aOuter);
|
|
|
|
nsPartialFileInputStream* stream = new nsPartialFileInputStream();
|
|
|
|
NS_ADDREF(stream);
|
|
nsresult rv = stream->QueryInterface(aIID, aResult);
|
|
NS_RELEASE(stream);
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPartialFileInputStream::Init(nsIFile* aFile, uint64_t aStart,
|
|
uint64_t aLength, int32_t aIOFlags,
|
|
int32_t aPerm, int32_t aBehaviorFlags)
|
|
{
|
|
mStart = aStart;
|
|
mLength = aLength;
|
|
mPosition = 0;
|
|
|
|
nsresult rv = nsFileInputStream::Init(aFile, aIOFlags, aPerm,
|
|
aBehaviorFlags);
|
|
|
|
// aFile is a partial file, it must exist.
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
mDeferredSeek = true;
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPartialFileInputStream::Tell(int64_t *aResult)
|
|
{
|
|
int64_t tell = 0;
|
|
|
|
nsresult rv = DoPendingSeek();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = nsFileInputStream::Tell(&tell);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
*aResult = tell - mStart;
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPartialFileInputStream::Available(uint64_t* aResult)
|
|
{
|
|
uint64_t available = 0;
|
|
|
|
nsresult rv = DoPendingSeek();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = nsFileInputStream::Available(&available);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
*aResult = TruncateSize(available);
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPartialFileInputStream::Read(char* aBuf, uint32_t aCount, uint32_t* aResult)
|
|
{
|
|
nsresult rv = DoPendingSeek();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
uint32_t readsize = (uint32_t) TruncateSize(aCount);
|
|
if (readsize == 0 && mBehaviorFlags & CLOSE_ON_EOF) {
|
|
Close();
|
|
*aResult = 0;
|
|
return NS_OK;
|
|
}
|
|
|
|
rv = nsFileInputStream::Read(aBuf, readsize, aResult);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
mPosition += readsize;
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPartialFileInputStream::Seek(int32_t aWhence, int64_t aOffset)
|
|
{
|
|
nsresult rv = DoPendingSeek();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
int64_t offset;
|
|
switch (aWhence) {
|
|
case NS_SEEK_SET:
|
|
offset = mStart + aOffset;
|
|
break;
|
|
case NS_SEEK_CUR:
|
|
offset = mStart + mPosition + aOffset;
|
|
break;
|
|
case NS_SEEK_END:
|
|
offset = mStart + mLength + aOffset;
|
|
break;
|
|
default:
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
}
|
|
|
|
if (offset < (int64_t)mStart || offset > (int64_t)(mStart + mLength)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
rv = nsFileInputStream::Seek(NS_SEEK_SET, offset);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
mPosition = offset - mStart;
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
nsPartialFileInputStream::Serialize(InputStreamParams& aParams,
|
|
FileDescriptorArray& aFileDescriptors)
|
|
{
|
|
// Serialize the base class first.
|
|
InputStreamParams fileParams;
|
|
nsFileInputStream::Serialize(fileParams, aFileDescriptors);
|
|
|
|
PartialFileInputStreamParams params;
|
|
|
|
params.fileStreamParams() = fileParams.get_FileInputStreamParams();
|
|
params.begin() = mStart;
|
|
params.length() = mLength;
|
|
|
|
aParams = params;
|
|
}
|
|
|
|
bool
|
|
nsPartialFileInputStream::Deserialize(
|
|
const InputStreamParams& aParams,
|
|
const FileDescriptorArray& aFileDescriptors)
|
|
{
|
|
NS_ASSERTION(!mFD, "Already have a file descriptor?!");
|
|
NS_ASSERTION(!mStart, "Already have a start?!");
|
|
NS_ASSERTION(!mLength, "Already have a length?!");
|
|
NS_ASSERTION(!mPosition, "Already have a position?!");
|
|
|
|
if (aParams.type() != InputStreamParams::TPartialFileInputStreamParams) {
|
|
NS_WARNING("Received unknown parameters from the other process!");
|
|
return false;
|
|
}
|
|
|
|
const PartialFileInputStreamParams& params =
|
|
aParams.get_PartialFileInputStreamParams();
|
|
|
|
// Deserialize the base class first.
|
|
InputStreamParams fileParams(params.fileStreamParams());
|
|
if (!nsFileInputStream::Deserialize(fileParams, aFileDescriptors)) {
|
|
NS_WARNING("Base class deserialize failed!");
|
|
return false;
|
|
}
|
|
|
|
NS_ASSERTION(mFD, "Must have a file descriptor now!");
|
|
|
|
mStart = params.begin();
|
|
mLength = params.length();
|
|
mPosition = 0;
|
|
|
|
if (!mStart) {
|
|
return true;
|
|
}
|
|
|
|
// XXX This is so broken. Main thread IO alert.
|
|
return NS_SUCCEEDED(nsFileInputStream::Seek(NS_SEEK_SET, mStart));
|
|
}
|
|
|
|
Maybe<uint64_t>
|
|
nsPartialFileInputStream::ExpectedSerializedLength()
|
|
{
|
|
return Some(mLength);
|
|
}
|
|
|
|
|
|
nsresult
|
|
nsPartialFileInputStream::DoPendingSeek()
|
|
{
|
|
if (!mDeferredSeek) {
|
|
return NS_OK;
|
|
}
|
|
|
|
mDeferredSeek = false;
|
|
|
|
// This is the first time to open the file, don't clear mLinebuffer.
|
|
// mLineBuffer might be already initialized by ReadLine().
|
|
return nsFileInputStream::SeekInternal(NS_SEEK_SET, mStart, false);
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// nsFileOutputStream
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED(nsFileOutputStream,
|
|
nsFileStreamBase,
|
|
nsIOutputStream,
|
|
nsIFileOutputStream)
|
|
|
|
nsresult
|
|
nsFileOutputStream::Create(nsISupports *aOuter, REFNSIID aIID, void **aResult)
|
|
{
|
|
NS_ENSURE_NO_AGGREGATION(aOuter);
|
|
|
|
nsFileOutputStream* stream = new nsFileOutputStream();
|
|
if (stream == nullptr)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
NS_ADDREF(stream);
|
|
nsresult rv = stream->QueryInterface(aIID, aResult);
|
|
NS_RELEASE(stream);
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileOutputStream::Init(nsIFile* file, int32_t ioFlags, int32_t perm,
|
|
int32_t behaviorFlags)
|
|
{
|
|
NS_ENSURE_TRUE(mFD == nullptr, NS_ERROR_ALREADY_INITIALIZED);
|
|
NS_ENSURE_TRUE(!mDeferredOpen, NS_ERROR_ALREADY_INITIALIZED);
|
|
|
|
mBehaviorFlags = behaviorFlags;
|
|
|
|
if (ioFlags == -1)
|
|
ioFlags = PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE;
|
|
if (perm <= 0)
|
|
perm = 0664;
|
|
|
|
return MaybeOpen(file, ioFlags, perm,
|
|
mBehaviorFlags & nsIFileOutputStream::DEFER_OPEN);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsFileOutputStream::Preallocate(int64_t aLength)
|
|
{
|
|
if (!mFD) {
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
}
|
|
|
|
if (!mozilla::fallocate(mFD, aLength)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// nsAtomicFileOutputStream
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED(nsAtomicFileOutputStream,
|
|
nsFileOutputStream,
|
|
nsISafeOutputStream,
|
|
nsIOutputStream,
|
|
nsIFileOutputStream)
|
|
|
|
NS_IMETHODIMP
|
|
nsAtomicFileOutputStream::Init(nsIFile* file, int32_t ioFlags, int32_t perm,
|
|
int32_t behaviorFlags)
|
|
{
|
|
// While `PR_APPEND` is not supported, `-1` is used as `ioFlags` parameter
|
|
// in some places, and `PR_APPEND | PR_TRUNCATE` does not require appending
|
|
// to existing file. So, throw an exception only if `PR_APPEND` is
|
|
// explicitly specified without `PR_TRUNCATE`.
|
|
if ((ioFlags & PR_APPEND) && !(ioFlags & PR_TRUNCATE)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
return nsFileOutputStream::Init(file, ioFlags, perm, behaviorFlags);
|
|
}
|
|
|
|
nsresult
|
|
nsAtomicFileOutputStream::DoOpen()
|
|
{
|
|
// Make sure mOpenParams.localFile will be empty if we bail somewhere in
|
|
// this function
|
|
nsCOMPtr<nsIFile> file;
|
|
file.swap(mOpenParams.localFile);
|
|
|
|
nsresult rv = file->Exists(&mTargetFileExists);
|
|
if (NS_FAILED(rv)) {
|
|
NS_ERROR("Can't tell if target file exists");
|
|
mTargetFileExists = true; // Safer to assume it exists - we just do more work.
|
|
}
|
|
|
|
// follow symlinks, for two reasons:
|
|
// 1) if a user has deliberately set up a profile file as a symlink, we honor it
|
|
// 2) to make the MoveToNative() in Finish() an atomic operation (which may not
|
|
// be the case if moving across directories on different filesystems).
|
|
nsCOMPtr<nsIFile> tempResult;
|
|
rv = file->Clone(getter_AddRefs(tempResult));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
tempResult->SetFollowLinks(true);
|
|
|
|
// XP_UNIX ignores SetFollowLinks(), so we have to normalize.
|
|
if (mTargetFileExists) {
|
|
tempResult->Normalize();
|
|
}
|
|
}
|
|
|
|
if (NS_SUCCEEDED(rv) && mTargetFileExists) {
|
|
uint32_t origPerm;
|
|
if (NS_FAILED(file->GetPermissions(&origPerm))) {
|
|
NS_ERROR("Can't get permissions of target file");
|
|
origPerm = mOpenParams.perm;
|
|
}
|
|
// XXX What if |perm| is more restrictive then |origPerm|?
|
|
// This leaves the user supplied permissions as they were.
|
|
rv = tempResult->CreateUnique(nsIFile::NORMAL_FILE_TYPE, origPerm);
|
|
}
|
|
if (NS_SUCCEEDED(rv)) {
|
|
// nsFileOutputStream::DoOpen will work on the temporary file, so we
|
|
// prepare it and place it in mOpenParams.localFile.
|
|
mOpenParams.localFile = tempResult;
|
|
mTempFile = tempResult;
|
|
mTargetFile = file;
|
|
rv = nsFileOutputStream::DoOpen();
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsAtomicFileOutputStream::Close()
|
|
{
|
|
nsresult rv = nsFileOutputStream::Close();
|
|
|
|
// the consumer doesn't want the original file overwritten -
|
|
// so clean up by removing the temp file.
|
|
if (mTempFile) {
|
|
mTempFile->Remove(false);
|
|
mTempFile = nullptr;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsAtomicFileOutputStream::Finish()
|
|
{
|
|
nsresult rv = nsFileOutputStream::Close();
|
|
|
|
// if there is no temp file, don't try to move it over the original target.
|
|
// It would destroy the targetfile if close() is called twice.
|
|
if (!mTempFile)
|
|
return rv;
|
|
|
|
// Only overwrite if everything was ok, and the temp file could be closed.
|
|
if (NS_SUCCEEDED(mWriteResult) && NS_SUCCEEDED(rv)) {
|
|
NS_ENSURE_STATE(mTargetFile);
|
|
|
|
if (!mTargetFileExists) {
|
|
// If the target file did not exist when we were initialized, then the
|
|
// temp file we gave out was actually a reference to the target file.
|
|
// since we succeeded in writing to the temp file (and hence succeeded
|
|
// in writing to the target file), there is nothing more to do.
|
|
#ifdef DEBUG
|
|
bool equal;
|
|
if (NS_FAILED(mTargetFile->Equals(mTempFile, &equal)) || !equal)
|
|
NS_WARNING("mTempFile not equal to mTargetFile");
|
|
#endif
|
|
}
|
|
else {
|
|
nsAutoString targetFilename;
|
|
rv = mTargetFile->GetLeafName(targetFilename);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
// This will replace target.
|
|
rv = mTempFile->MoveTo(nullptr, targetFilename);
|
|
if (NS_FAILED(rv))
|
|
mTempFile->Remove(false);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
mTempFile->Remove(false);
|
|
|
|
// if writing failed, propagate the failure code to the caller.
|
|
if (NS_FAILED(mWriteResult))
|
|
rv = mWriteResult;
|
|
}
|
|
mTempFile = nullptr;
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsAtomicFileOutputStream::Write(const char *buf, uint32_t count, uint32_t *result)
|
|
{
|
|
nsresult rv = nsFileOutputStream::Write(buf, count, result);
|
|
if (NS_SUCCEEDED(mWriteResult)) {
|
|
if (NS_FAILED(rv))
|
|
mWriteResult = rv;
|
|
else if (count != *result)
|
|
mWriteResult = NS_ERROR_LOSS_OF_SIGNIFICANT_DATA;
|
|
|
|
if (NS_FAILED(mWriteResult) && count > 0)
|
|
NS_WARNING("writing to output stream failed! data may be lost");
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// nsSafeFileOutputStream
|
|
|
|
NS_IMETHODIMP
|
|
nsSafeFileOutputStream::Finish()
|
|
{
|
|
(void) Flush();
|
|
return nsAtomicFileOutputStream::Finish();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// nsFileStream
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED(nsFileStream,
|
|
nsFileStreamBase,
|
|
nsIInputStream,
|
|
nsIOutputStream,
|
|
nsIFileStream)
|
|
|
|
NS_IMETHODIMP
|
|
nsFileStream::Init(nsIFile* file, int32_t ioFlags, int32_t perm,
|
|
int32_t behaviorFlags)
|
|
{
|
|
NS_ENSURE_TRUE(mFD == nullptr, NS_ERROR_ALREADY_INITIALIZED);
|
|
NS_ENSURE_TRUE(!mDeferredOpen, NS_ERROR_ALREADY_INITIALIZED);
|
|
|
|
mBehaviorFlags = behaviorFlags;
|
|
|
|
if (ioFlags == -1)
|
|
ioFlags = PR_RDWR;
|
|
if (perm <= 0)
|
|
perm = 0;
|
|
|
|
return MaybeOpen(file, ioFlags, perm,
|
|
mBehaviorFlags & nsIFileStream::DEFER_OPEN);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|