NS_IMETHODIMP
FileDescriptorOutputStream::Flush()
{
  if (NS_WARN_IF(!fd))
    return NS_ERROR_FAILURE;

  return PR_Sync(fd) == PR_SUCCESS ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsMsgFileStream::Flush(void)
{
    if (mFileDesc == nsnull)
        return NS_BASE_STREAM_CLOSED;

    PRInt32 cnt = PR_Sync(mFileDesc);
    if (cnt == -1)
        return NS_ErrorAccordingToNSPR();

    return NS_OK;
}
Esempio n. 3
0
NS_IMETHODIMP
nsFileOutputStream::Flush(void)
{
    if (mFD == nsnull)
        return NS_BASE_STREAM_CLOSED;

    PRInt32 cnt = PR_Sync(mFD);
    if (cnt == -1) {
        return NS_ErrorAccordingToNSPR();
    }
    return NS_OK;
}
NS_IMETHODIMP
MsgFileStream::Flush(void)
{
  if (mFileDesc == nullptr)
    return NS_BASE_STREAM_CLOSED;
  
  int32_t cnt = PR_Sync(mFileDesc);
  if (cnt == -1) 
    return ErrorAccordingToNSPR();

  return NS_OK;
}
Esempio n. 5
0
 NS_IMETHOD Flush(void) {
     PR_Sync(PR_GetSpecialFD(PR_StandardOutput));
     return NS_OK;
 }
Esempio n. 6
0
void file_flush(file_t file) {
  PR_Sync((PRFileDesc*)file);
}
Esempio n. 7
0
//----------------------------------------------------------------------------------------
static int CrudeFileCopy(const char* in, const char* out)
//----------------------------------------------------------------------------------------
{
  char buf[1024];                               // Used as buffer for the copy loop
  PRInt32 rbytes, wbytes;                       // Number of bytes read and written in copy loop
  struct stat in_stat;                          // Stores informations from the stat syscall
  int stat_result = -1, ret;                 
  PRFileDesc * pFileDescIn, * pFileDescOut;     // Src and dest pointers

  // Check if the pointers to filenames are valid
  NS_ASSERTION(in && out, "CrudeFileCopy should be called with pointers to filenames...");

  // Check if the pointers are the same, if so, no need to copy A to A
  if (in == out)
    return 0;

  // Check if content of the pointers are the sames, if so, no need to copy A to A
  if (strcmp(in,out) == 0)
    return 0;

  // Retrieve the 'in' file attributes
  stat_result = stat(in, &in_stat);
  if(stat_result != 0)
  {
    // test if stat failed, it can happen if the file does not exist, is not 
    // readable or is not available ( can happen with NFS mounts )
    return -1;                      // Return an error
  }

  // Open the input file for binary read
  pFileDescIn = PR_Open(in, PR_RDONLY, 0444);
  if (pFileDescIn == 0)
  {
    return -1;                                  // Open failed, return an error
  }  

  // Open the output file for binary write
  pFileDescOut = PR_Open(out, PR_WRONLY | PR_CREATE_FILE, 0600);
  if (pFileDescOut == 0)
  {
    // Open failed, need to close input file, then return an error
    PR_Close(pFileDescOut);                    // Close the output file
    return -1;                                 // Open failed, return an error
  }  

  // Copy the data
  if (CrudeFileCopy_DoCopy(pFileDescIn, pFileDescOut, buf, sizeof(buf)) != 0)
  {                                            // Error case
    PR_Close(pFileDescOut);                    // Close output file
    PR_Close(pFileDescIn);                     // Close input file
    PR_Delete(out);                            // Destroy output file
    return -1;                                 // Return an error
  }

  // There is no need for error handling here. This should have worked, but even
  // if it fails, the data are now copied to destination, thus there is no need 
  // for the function to fail on the input file error
  PR_Close(pFileDescIn);            

  // It is better to call fsync and test return code before exiting to be sure
  // data are actually written on disk. Data loss can happen with NFS mounts
  if (PR_Sync(pFileDescOut) != PR_SUCCESS) 
  {                                  // Test if the fsync function succeeded
    PR_Close(pFileDescOut);          // Close output file
    PR_Delete(out);                  // Destroy output file
    return -1;                       // Return an error
  }

  // Copy is done, close both file
  if (PR_Close(pFileDescOut) != PR_SUCCESS) // Close output file
  {                                  // Output file was not closed :(
    PR_Delete(out);                  // Destroy output file
    return -1;                       // Return an error
  }
    
  ret = chmod(out, in_stat.st_mode & 0777); // Set the new file file mode
  if (ret != 0)                      // Test if the chmod function succeeded
  {
    PR_Delete(out);                  // Destroy output file
    return -1;                       // Return an error
  }

  return 0;                          // Still here ? ok so it worked :)
} // nsFileSpec::CrudeFileCopy
JD_METHOD_(JDBool) CNSAdapter_NSPR::JD_Sync(void* fd)
{
  return PR_Sync((PRFileDesc*)fd);
}
Esempio n. 9
0
    GMPErr Write(const nsCString& aRecordName,
                 const nsTArray<uint8_t>& aBytes) override
    {
        if (!IsOpen(aRecordName)) {
            return GMPClosedErr;
        }

        Record* record = nullptr;
        mRecords.Get(aRecordName, &record);
        MOZ_ASSERT(record && !!record->mFileDesc); // IsOpen() guarantees this.

        // Write operations overwrite the entire record. So close it now.
        PR_Close(record->mFileDesc);
        record->mFileDesc = nullptr;

        // Writing 0 bytes means removing (deleting) the file.
        if (aBytes.Length() == 0) {
            nsresult rv = RemoveStorageFile(record->mFilename);
            if (NS_WARN_IF(NS_FAILED(rv))) {
                // Could not delete file -> Continue with trying to erase the contents.
            } else {
                return GMPNoErr;
            }
        }

        // Write operations overwrite the entire record. So re-open the file
        // in truncate mode, to clear its contents.
        if (NS_FAILED(OpenStorageFile(record->mFilename,
                                      Truncate,
                                      &record->mFileDesc))) {
            return GMPGenericErr;
        }

        // Store the length of the record name followed by the record name
        // at the start of the file.
        int32_t bytesWritten = 0;
        char buf[sizeof(uint32_t)] = {0};
        LittleEndian::writeUint32(buf, aRecordName.Length());
        bytesWritten = PR_Write(record->mFileDesc, buf, MOZ_ARRAY_LENGTH(buf));
        if (bytesWritten != MOZ_ARRAY_LENGTH(buf)) {
            NS_WARNING("Failed to write GMPStorage record name length.");
            return GMPRecordCorrupted;
        }
        bytesWritten = PR_Write(record->mFileDesc,
                                aRecordName.get(),
                                aRecordName.Length());
        if (bytesWritten != (int32_t)aRecordName.Length()) {
            NS_WARNING("Failed to write GMPStorage record name.");
            return GMPRecordCorrupted;
        }

        bytesWritten = PR_Write(record->mFileDesc, aBytes.Elements(), aBytes.Length());
        if (bytesWritten != (int32_t)aBytes.Length()) {
            NS_WARNING("Failed to write GMPStorage record data.");
            return GMPRecordCorrupted;
        }

        // Try to sync the file to disk, so that in the event of a crash,
        // the record is less likely to be corrupted.
        PR_Sync(record->mFileDesc);

        return GMPNoErr;
    }