Replace ReadFile/WriteFile usages with stdio

src/coreclr/dlls/mscorpe/pewriter.cpp

@@ -4,6 +4,7 @@
 
 #include "blobfetcher.h"
 #include "pedecoder.h"
+#include <dn-stdio.h>
 
 #ifdef _DEBUG
 #define LOGGING
@@ -547,7 +548,7 @@ HRESULT PEWriter::Init(PESectionMan *pFrom, DWORD createFlags)
     headers = NULL;
     headersEnd = NULL;
 
-    m_file = INVALID_HANDLE_VALUE;
+    m_file = NULL;
 
     return S_OK;
 }
@@ -626,32 +627,26 @@ HRESULT PEWriter::setDirectoryEntry(PEWriterSection *section, ULONG entry, ULONG
     return S_OK;
 }
 
-//-----------------------------------------------------------------------------
-// These 2 write functions must be implemented here so that they're in the same
-// .obj file as whoever creates the FILE struct. We can't pass a FILE struct
-// across a dll boundary and use it.
-//-----------------------------------------------------------------------------
-
-HRESULT PEWriterSection::write(HANDLE file)
+HRESULT PEWriterSection::write(FILE* file)
 {
     return m_blobFetcher.Write(file);
 }
 
 //-----------------------------------------------------------------------------
-// Write out the section to the stream
+// Write out the section to the file
 //-----------------------------------------------------------------------------
-HRESULT CBlobFetcher::Write(HANDLE file)
+HRESULT CBlobFetcher::Write(FILE* file)
 {
 // Must write out each pillar (including idx = m_nIndexUsed), one after the other
     unsigned idx;
     for(idx = 0; idx <= m_nIndexUsed; idx ++) {
         if (m_pIndex[idx].GetDataLen() > 0)
         {
             ULONG length = m_pIndex[idx].GetDataLen();
-            DWORD dwWritten = 0;
-            if (!WriteFile(file, m_pIndex[idx].GetRawDataStart(), length, &dwWritten, NULL))
+            size_t dwWritten = 0;
+            if ((dwWritten = fwrite(m_pIndex[idx].GetRawDataStart(), 1, length, file)) <= 0)
             {
-                return HRESULT_FROM_GetLastError();
+                return HRESULTFromErrno();
             }
             _ASSERTE(dwWritten == length);
         }
@@ -1336,37 +1331,32 @@ HRESULT PEWriter::fixup(CeeGenTokenMapper *pMapper)
 
 HRESULT PEWriter::Open(_In_ LPCWSTR fileName)
 {
-    _ASSERTE(m_file == INVALID_HANDLE_VALUE);
+    _ASSERTE(m_file == NULL);
     HRESULT hr = NOERROR;
 
-    m_file = WszCreateFile(fileName,
-                           GENERIC_WRITE,
-                           0, // No sharing.  Was: FILE_SHARE_READ | FILE_SHARE_WRITE,
-                           NULL,
-                           CREATE_ALWAYS,
-                           FILE_ATTRIBUTE_NORMAL,
-                           NULL );
-    if (m_file == INVALID_HANDLE_VALUE)
-        hr = HRESULT_FROM_GetLastErrorNA();
+    int err = fopen_lp(&m_file, fileName, W("wb"));
+
+    if (err != 0)
+        hr = HRESULTFromErrno();
 
     return hr;
 }
 
 HRESULT PEWriter::Seek(int offset)
 {
-    _ASSERTE(m_file != INVALID_HANDLE_VALUE);
-    if (SetFilePointer(m_file, offset, 0, FILE_BEGIN))
+    _ASSERTE(m_file != NULL);
+    if (fseek(m_file, offset, SEEK_SET) == 0)
         return S_OK;
     else
-        return HRESULT_FROM_GetLastError();
+        return HRESULTFromErrno();
 }
 
 HRESULT PEWriter::Write(const void *data, int size)
 {
-    _ASSERTE(m_file != INVALID_HANDLE_VALUE);
+    _ASSERTE(m_file != NULL);
 
     HRESULT hr = S_OK;
-    DWORD dwWritten = 0;
+    size_t dwWritten = 0;
     if (size)
     {
         CQuickBytes zero;
@@ -1379,21 +1369,21 @@ HRESULT PEWriter::Write(const void *data, int size)
                 data = zero.Ptr();
             }
         }
-
-        if (WriteFile(m_file, data, size, &dwWritten, NULL))
+        _ASSERTE(data != NULL);
+        if ((dwWritten = fwrite(data, 1, size, m_file)) >= 0)
         {
-            _ASSERTE(dwWritten == (DWORD)size);
+            _ASSERTE(dwWritten == (size_t)size);
         }
         else
-            hr = HRESULT_FROM_GetLastError();
+            hr = HRESULTFromErrno();
     }
 
     return hr;
 }
 
 HRESULT PEWriter::Pad(int align)
 {
-    DWORD offset = SetFilePointer(m_file, 0, NULL, FILE_CURRENT);
+    DWORD offset = (DWORD)ftell(m_file);
     int pad = padLen(offset, align);
     if (pad > 0)
         return Write(NULL, pad);
@@ -1403,16 +1393,17 @@ HRESULT PEWriter::Pad(int align)
 
 HRESULT PEWriter::Close()
 {
-    if (m_file == INVALID_HANDLE_VALUE)
+    if (m_file == NULL)
         return S_OK;
 
+    int err = fclose(m_file);
     HRESULT hr;
-    if (CloseHandle(m_file))
+    if (err == 0)
         hr = S_OK;
     else
-        hr = HRESULT_FROM_GetLastError();
+        hr = HRESULTFromErrno();
 
-    m_file = INVALID_HANDLE_VALUE;
+    m_file = NULL;
 
     return hr;
 }

src/coreclr/dlls/mscorpe/pewriter.h

@@ -111,7 +111,7 @@ class PEWriter : public PESectionMan
     ULONG  m_codeRvaBase;
     DWORD  m_peFileTimeStamp;
 
-    HANDLE   m_file;
+    FILE*   m_file;
 
     PEWriterSection **getSectStart() {
         return (PEWriterSection**)sectStart;
@@ -203,7 +203,7 @@ class PEWriterSection : public PESection {
                          DWORD               dataRvaBase,
                          DWORD               textRvaBase);
 
-    virtual HRESULT  write      (HANDLE file);
+    virtual HRESULT  write      (FILE* file);
     virtual unsigned writeMem   (void ** pMem);
 };
 

src/coreclr/ilasm/asmman.cpp

@@ -10,6 +10,7 @@
 #include "assembler.h"
 #include "strongnameinternal.h"
 #include <limits.h>
+#include <dn-stdio.h>
 
 extern WCHAR*   pwzInputFiles[];
 
@@ -404,52 +405,48 @@ void    AsmMan::EndAssembly()
                 else
                 {
                     // Read public key or key pair from file.
-                    HANDLE hFile = WszCreateFile(((Assembler*)m_pAssembler)->m_wzKeySourceName,
-                                                 GENERIC_READ,
-                                                 FILE_SHARE_READ,
-                                                 NULL,
-                                                 OPEN_EXISTING,
-                                                 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
-                                                 NULL);
-                    if(hFile == INVALID_HANDLE_VALUE)
+                    FILE* fp;
+                    int err = fopen_lp(&fp, ((Assembler*)m_pAssembler)->m_wzKeySourceName, W("rb"));
+                    if (err != 0)
                     {
-                        hr = GetLastError();
                         MAKE_UTF8PTR_FROMWIDE(keySourceNameUtf8, ((Assembler*)m_pAssembler)->m_wzKeySourceName);
-                        report->error("Failed to open key file '%s': 0x%08X\n",keySourceNameUtf8,hr);
+                        report->error("Failed to open key file '%s': 0x%08X\n",keySourceNameUtf8,err);
                         m_pCurAsmRef = NULL;
                         return;
                     }
 
                     // Determine file size and allocate an appropriate buffer.
-                    m_sStrongName.m_cbPublicKey = SafeGetFileSize(hFile, NULL);
-                    if (m_sStrongName.m_cbPublicKey == 0xffffffff) {
+                    int64_t fSize = fgetsize(fp);
+                    m_sStrongName.m_cbPublicKey = (DWORD)fSize;
+                    if (fSize > UINT32_MAX) {
                         report->error("File size too large\n");
                         m_pCurAsmRef = NULL;
-                        CloseHandle(hFile);
+                        fclose(fp);
                         return;
                     }
 
                     m_sStrongName.m_pbPublicKey = new BYTE[m_sStrongName.m_cbPublicKey];
                     if (m_sStrongName.m_pbPublicKey == NULL) {
                         report->error("Failed to allocate key buffer\n");
                         m_pCurAsmRef = NULL;
-                        CloseHandle(hFile);
+                        fclose(fp);
                         return;
                     }
                     m_sStrongName.m_dwPublicKeyAllocated = AsmManStrongName::AllocatedByNew;
 
                     // Read the file into the buffer.
-                    DWORD dwBytesRead;
-                    if (!ReadFile(hFile, m_sStrongName.m_pbPublicKey, m_sStrongName.m_cbPublicKey, &dwBytesRead, NULL)) {
-                        hr = GetLastError();
+                    size_t dwBytesRead;
+
+                    if ((dwBytesRead = fread(m_sStrongName.m_pbPublicKey, 1, m_sStrongName.m_cbPublicKey, fp)) <= m_sStrongName.m_cbPublicKey) {
+                        HRESULT hr = HRESULTFromErrno();
                         MAKE_UTF8PTR_FROMWIDE(keySourceNameUtf8, ((Assembler*)m_pAssembler)->m_wzKeySourceName);
-                        report->error("Failed to read key file '%s': 0x%08X\n",keySourceNameUtf8,hr);
+                        report->error("Failed to read key file '%s': 0x%d\n",keySourceNameUtf8,hr);
                         m_pCurAsmRef = NULL;
-                        CloseHandle(hFile);
+                        fclose(fp);
                         return;
                     }
 
-                    CloseHandle(hFile);
+                    fclose(fp);
 
                     // Guess whether we're full or delay signing based on
                     // whether the blob passed to us looks like a public
@@ -954,13 +951,13 @@ HRESULT AsmMan::EmitManifest()
             }
             else // embedded mgd.resource, go after the file
             {
-                HANDLE hFile = INVALID_HANDLE_VALUE;
+                FILE* fp = NULL;
                 int j;
                 WCHAR   wzFileName[2048];
                 WCHAR*  pwz;
 
                 pManRes->ulOffset = m_dwMResSizeTotal;
-                for(j=0; (hFile == INVALID_HANDLE_VALUE)&&(pwzInputFiles[j] != NULL); j++)
+                for(j=0; (fp == NULL)&&(pwzInputFiles[j] != NULL); j++)
                 {
                     wcscpy_s(wzFileName,2048,pwzInputFiles[j]);
                     pwz = (WCHAR*)u16_strrchr(wzFileName,DIRECTORY_SEPARATOR_CHAR_A);
@@ -970,10 +967,10 @@ HRESULT AsmMan::EmitManifest()
                     if(pwz == NULL) pwz = &wzFileName[0];
                     else pwz++;
                     wcscpy_s(pwz,2048-(pwz-wzFileName),wzUniBuf);
-                    hFile = WszCreateFile(wzFileName, GENERIC_READ, FILE_SHARE_READ,
-                             0, OPEN_EXISTING, 0, 0);
+                    if (fopen_lp(&fp, wzFileName, W("rb")) != 0)
+                        fp = NULL;
                 }
-                if (hFile == INVALID_HANDLE_VALUE)
+                if (fp == NULL)
                 {
                     report->error("Failed to open managed resource file '%s'\n",pManRes->szAlias);
                     fOK = FALSE;
@@ -987,14 +984,16 @@ HRESULT AsmMan::EmitManifest()
                     }
                     else
                     {
-                        m_dwMResSize[m_dwMResNum] = SafeGetFileSize(hFile,NULL);
-                        if(m_dwMResSize[m_dwMResNum] == 0xFFFFFFFF)
+                        uint64_t fSize = fgetsize(fp);
+                        if(fSize >= 0xFFFFFFFF)
                         {
+                            m_dwMResSize[m_dwMResNum] = 0xFFFFFFFF;
                             report->error("Failed to get size of managed resource file '%s'\n",pManRes->szAlias);
                             fOK = FALSE;
                         }
                         else
                         {
+                            m_dwMResSize[m_dwMResNum] = (DWORD)fSize;
                             m_dwMResSizeTotal += m_dwMResSize[m_dwMResNum]+sizeof(DWORD);
                             m_wzMResName[m_dwMResNum] = new WCHAR[u16_strlen(wzFileName)+1];
                             wcscpy_s(m_wzMResName[m_dwMResNum],u16_strlen(wzFileName)+1,wzFileName);
@@ -1003,7 +1002,7 @@ HRESULT AsmMan::EmitManifest()
                         }
                     }
 
-                    CloseHandle(hFile);
+                    fclose(fp);
                 }
             }
             if(fOK || ((Assembler*)m_pAssembler)->OnErrGo)