Changeset 102195 in vbox

Timestamp:

Nov 21, 2023 12:43:15 PM (12 months ago)

Author:

vboxsync

Message:

libs/xpcom/xpcom: Get rid of nsprpub based file I/O and convert to IPRT, bugref:10545

Location:

trunk/src/libs/xpcom18a4/xpcom/io

Files:

• nsILocalFile.idl (modified) (2 diffs)
• nsLocalFile.h (modified) (3 diffs)
• nsLocalFileUnix.cpp (modified) (12 diffs)
• nsLocalFileUnix.h (modified) (2 diffs)

trunk/src/libs/xpcom18a4/xpcom/io/nsILocalFile.idl

@@ -42 +42 @@
 
 %{C++
-#include "prio.h"
-#include <stdio.h>
-
 #include <iprt/ldr.h>
 %}
 
-[ptr] native PRFileDescStar(PRFileDesc);
 [ptr] native RTLDRMOD(RTLDRMODINTERNAL);
 [ptr] native FILE(FILE);
@@ -102 +98 @@
      */
     attribute PRBool followLinks;  
-
-    [noscript] PRFileDescStar openNSPRFileDesc(in long flags, in long mode);
-    [noscript] FILE           openANSIFileDesc(in string mode);
 
     [noscript] RTLDRMOD       load();

trunk/src/libs/xpcom18a4/xpcom/io/nsLocalFile.h

@@ -66 +66 @@
 // on this.
 
+#include <iprt/err.h>
+
 #include <errno.h>
+
 #include "nsILocalFile.h"
 
@@ -77 +80 @@
 #endif
 
-#define NSRESULT_FOR_RETURN(ret) (((ret) < 0) ? NSRESULT_FOR_ERRNO() : NS_OK)
+
+#define NSRESULT_FOR_IPRT(ret) (RT_FAILURE((ret)) ? nsresultForIprt(ret) : NS_OK)
 
 inline nsresult
-nsresultForErrno(int err)
+nsresultForIprt(int err)
 {
     switch (err) {
-      case 0:
+      case VINF_SUCCESS:
         return NS_OK;
-      case ENOENT:
+      case VERR_NOT_FOUND:
+      case VERR_FILE_NOT_FOUND:
+      case VERR_PATH_NOT_FOUND:
         return NS_ERROR_FILE_TARGET_DOES_NOT_EXIST;
-      case ENOTDIR:
+      case VERR_NOT_A_DIRECTORY:
         return NS_ERROR_FILE_DESTINATION_NOT_DIR;
-#ifdef ENOLINK
-      case ENOLINK:
+      case VERR_NOT_SYMLINK:
         return NS_ERROR_FILE_UNRESOLVABLE_SYMLINK;
-#endif /* ENOLINK */
-      case EEXIST:
+      case VERR_ALREADY_EXISTS:
         return NS_ERROR_FILE_ALREADY_EXISTS;
-#ifdef EPERM
-      case EPERM:
-#endif /* EPERM */
-      case EACCES:
+      case VERR_ACCESS_DENIED:
         return NS_ERROR_FILE_ACCESS_DENIED;
       default:
@@ -105 +106 @@
 }
 
-#define NSRESULT_FOR_ERRNO() nsresultForErrno(errno)
+#define NSRESULT_FOR_ERRNO() nsresultForIprt(RTErrConvertFromErrno(errno))
 
 void NS_StartupLocalFile();

trunk/src/libs/xpcom18a4/xpcom/io/nsLocalFileUnix.cpp

@@ -76 +76 @@
 #include "prerr.h"
 
-#include <iprt/errcore.h>
+#include <iprt/err.h>
+#include <iprt/dir.h>
+#include <iprt/file.h>
+#include <iprt/path.h>
+#include <iprt/time.h>
 
 #define FILE_STRCMP strcmp
@@ -97 +101 @@
 
 NS_COM nsresult
-NS_ErrorAccordingToNSPR()
-{
-    PRErrorCode err = PR_GetError();
-    switch (err) {
-      case PR_OUT_OF_MEMORY_ERROR:              return NS_ERROR_OUT_OF_MEMORY;
-      case PR_WOULD_BLOCK_ERROR:                return NS_BASE_STREAM_WOULD_BLOCK;
-      case PR_FILE_NOT_FOUND_ERROR:             return NS_ERROR_FILE_NOT_FOUND;
-      case PR_READ_ONLY_FILESYSTEM_ERROR:       return NS_ERROR_FILE_READ_ONLY;
-      case PR_NOT_DIRECTORY_ERROR:              return NS_ERROR_FILE_NOT_DIRECTORY;
-      case PR_IS_DIRECTORY_ERROR:               return NS_ERROR_FILE_IS_DIRECTORY;
-      case PR_LOOP_ERROR:                       return NS_ERROR_FILE_UNRESOLVABLE_SYMLINK;
-      case PR_FILE_EXISTS_ERROR:                return NS_ERROR_FILE_ALREADY_EXISTS;
-      case PR_FILE_IS_LOCKED_ERROR:             return NS_ERROR_FILE_IS_LOCKED;
-      case PR_FILE_TOO_BIG_ERROR:               return NS_ERROR_FILE_TOO_BIG;
-      case PR_NO_DEVICE_SPACE_ERROR:            return NS_ERROR_FILE_NO_DEVICE_SPACE;
-      case PR_NAME_TOO_LONG_ERROR:              return NS_ERROR_FILE_NAME_TOO_LONG;
-      case PR_DIRECTORY_NOT_EMPTY_ERROR:        return NS_ERROR_FILE_DIR_NOT_EMPTY;
-      case PR_NO_ACCESS_RIGHTS_ERROR:           return NS_ERROR_FILE_ACCESS_DENIED;
+NS_ErrorAccordingToIPRT(int vrc)
+{
+    switch (vrc) {
+      case VERR_NO_MEMORY:                      return NS_ERROR_OUT_OF_MEMORY;
+      case VERR_FILE_NOT_FOUND:                 return NS_ERROR_FILE_NOT_FOUND;
+      case VERR_PATH_NOT_FOUND:                 return NS_ERROR_FILE_NOT_FOUND;
+      case VERR_NOT_A_DIRECTORY:                return NS_ERROR_FILE_NOT_DIRECTORY;
+      case VERR_IS_A_DIRECTORY:                 return NS_ERROR_FILE_IS_DIRECTORY;
+      case VERR_ALREADY_EXISTS:                 return NS_ERROR_FILE_ALREADY_EXISTS;
+      case VERR_FILE_LOCK_VIOLATION:            return NS_ERROR_FILE_IS_LOCKED;
+      case VERR_FILE_TOO_BIG:                   return NS_ERROR_FILE_TOO_BIG;
+      case VERR_FILENAME_TOO_LONG:              return NS_ERROR_FILE_NAME_TOO_LONG;
+      case VERR_DIR_NOT_EMPTY:                  return NS_ERROR_FILE_DIR_NOT_EMPTY;
+      case VERR_ACCESS_DENIED:                  return NS_ERROR_FILE_ACCESS_DENIED;
+      case VERR_WRITE_PROTECT:                  return NS_ERROR_FILE_READ_ONLY;
+      case VERR_DISK_FULL:                      return NS_ERROR_FILE_NO_DEVICE_SPACE;
+
+      /** @todo: No IPRT equivalent right now (but shouldn't be important). */
+      //case PR_WOULD_BLOCK_ERROR:                return NS_BASE_STREAM_WOULD_BLOCK;
       default:                                  return NS_ERROR_FAILURE;
     }
@@ -370 +375 @@
          */
         if (mkdir_result == -1 && mkdir_errno != EEXIST)
-            return nsresultForErrno(mkdir_errno);
+            return nsresultForIprt(RTErrConvertFromErrno(mkdir_errno));
     }
 
@@ -380 +385 @@
 }
 
-NS_IMETHODIMP
-nsLocalFile::OpenNSPRFileDesc(PRInt32 flags, PRInt32 mode, PRFileDesc **_retval)
-{
-    *_retval = PR_Open(mPath.get(), flags, mode);
-    if (! *_retval)
-        return NS_ErrorAccordingToNSPR();
-
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsLocalFile::OpenANSIFileDesc(const char *mode, FILE **_retval)
-{
-    *_retval = fopen(mPath.get(), mode);
-    if (! *_retval)
-        return NS_ERROR_FAILURE;
-
-    return NS_OK;
-}
-
 static int
-do_create(const char *path, PRIntn flags, mode_t mode, PRFileDesc **_retval)
-{
-    *_retval = PR_Open(path, flags, mode);
-    return *_retval ? 0 : -1;
+do_create(const char *path, uint32_t flags, mode_t mode, RTFILE *_retval)
+{
+    return RTFileOpen(_retval, path, flags | (mode << RTFILE_O_CREATE_MODE_SHIFT));
 }
 
 static int
-do_mkdir(const char *path, PRIntn flags, mode_t mode, PRFileDesc **_retval)
-{
-    *_retval = nsnull;
-    return mkdir(path, mode);
+do_mkdir(const char *path, uint32_t flags, mode_t mode, RTFILE *_retval)
+{
+    *_retval = NULL;
+    return RTDirCreate(path, mode, 0 /* fCreate*/);
 }
 
 nsresult
-nsLocalFile::CreateAndKeepOpen(PRUint32 type, PRIntn flags,
-                               PRUint32 permissions, PRFileDesc **_retval)
+nsLocalFile::CreateAndKeepOpen(PRUint32 type, uint32_t flags,
+                               PRUint32 permissions, RTFILE *_retval)
 {
     if (type != NORMAL_FILE_TYPE && type != DIRECTORY_TYPE)
         return NS_ERROR_FILE_UNKNOWN_TYPE;
 
-    int result;
-    int (*createFunc)(const char *, PRIntn, mode_t, PRFileDesc **) =
+    int (*createFunc)(const char *, uint32_t, mode_t, RTFILE *) =
         (type == NORMAL_FILE_TYPE) ? do_create : do_mkdir;
 
-    result = createFunc(mPath.get(), flags, permissions, _retval);
-    if (result == -1 && errno == ENOENT) {
+    int vrc = createFunc(mPath.get(), flags, permissions, _retval);
+    if (vrc == VERR_PATH_NOT_FOUND || vrc == VERR_FILE_NOT_FOUND || vrc == VERR_NOT_FOUND) {
         /*
          * If we failed because of missing ancestor components, try to create
@@ -455 +438 @@
         fprintf(stderr, "nsIFile: Create(\"%s\") again\n", mPath.get());
 #endif
-        result = createFunc(mPath.get(), flags, permissions, _retval);
-    }
-
-    return NSRESULT_FOR_RETURN(result);
+        vrc = createFunc(mPath.get(), flags, permissions, _retval);
+    }
+
+    return NSRESULT_FOR_IPRT(vrc);
 }
 
@@ -464 +447 @@
 nsLocalFile::Create(PRUint32 type, PRUint32 permissions)
 {
-    PRFileDesc *junk = nsnull;
+    RTFILE junk = NULL;
     nsresult rv = CreateAndKeepOpen(type,
-                                    PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE |
-                                    PR_EXCL,
+                                    RTFILE_O_WRITE | RTFILE_O_CREATE | RTFILE_O_TRUNCATE |
+                                    RTFILE_O_DENY_ALL,
                                     permissions,
                                     &junk);
     if (junk)
-        PR_Close(junk);
+        RTFileClose(junk);
     return rv;
 }
@@ -793 +776 @@
         // open it successfully for writing.
 
-        PRFileDesc *newFD;
+        RTFILE newFD;
         rv = newFile->CreateAndKeepOpen(NORMAL_FILE_TYPE,
-                                        PR_WRONLY|PR_CREATE_FILE|PR_TRUNCATE,
+                                        RTFILE_O_WRITE | RTFILE_O_CREATE | RTFILE_O_TRUNCATE | RTFILE_O_DENY_NONE,
                                         myPerms,
                                         &newFD);
@@ -804 +787 @@
         PRBool specialFile;
         if (NS_FAILED(rv = IsSpecial(&specialFile))) {
-            PR_Close(newFD);
+            RTFileClose(newFD);
             return rv;
         }
@@ -812 +795 @@
 #endif
             // make sure to clean up properly
-            PR_Close(newFD);
+            RTFileClose(newFD);
             return NS_OK;
         }
                
-        PRFileDesc *oldFD;
-        rv = OpenNSPRFileDesc(PR_RDONLY, myPerms, &oldFD);
+        RTFILE oldFD = NIL_RTFILE;
+        int vrc = RTFileOpen(&oldFD, mPath.get(), RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE);
+        if (RT_FAILURE(vrc))
+            rv = NS_ErrorAccordingToIPRT(vrc);
         if (NS_FAILED(rv)) {
             // make sure to clean up properly
-            PR_Close(newFD);
+            RTFileClose(newFD);
             return rv;
         }
 
-#ifdef DEBUG_blizzard
-        PRInt32 totalRead = 0;
-        PRInt32 totalWritten = 0;
-#endif
-        char buf[BUFSIZ];
-        PRInt32 bytesRead;
-        
-        while ((bytesRead = PR_Read(oldFD, buf, BUFSIZ)) > 0) {
-#ifdef DEBUG_blizzard
-            totalRead += bytesRead;
-#endif
-
-            // PR_Write promises never to do a short write
-            PRInt32 bytesWritten = PR_Write(newFD, buf, bytesRead);
-            if (bytesWritten < 0) {
-                bytesRead = -1;
-                break;
-            }
-            NS_ASSERTION(bytesWritten == bytesRead, "short PR_Write?");
-
-#ifdef DEBUG_blizzard
-            totalWritten += bytesWritten;
-#endif
-        }
-
-#ifdef DEBUG_blizzard
-        printf("read %d bytes, wrote %d bytes\n",
-                 totalRead, totalWritten);
-#endif
+        vrc = RTFileCopyByHandles(oldFD, newFD);
 
         // close the files
-        PR_Close(newFD);
-        PR_Close(oldFD);
+        RTFileClose(newFD);
+        RTFileClose(oldFD);
 
         // check for read (or write) error after cleaning up
-        if (bytesRead < 0) 
+        if (RT_FAILURE(vrc)) 
             return NS_ERROR_OUT_OF_MEMORY;
     }
@@ -915 +872 @@
 
     if (!recursive && isSymLink)
-        return NSRESULT_FOR_RETURN(unlink(mPath.get()));
+        return NSRESULT_FOR_IPRT(RTErrConvertFromErrno(unlink(mPath.get())));
     
     isDir = S_ISDIR(mCachedStat.st_mode);
@@ -962 +919 @@
     NS_ENSURE_ARG(aLastModTime);
 
-    PRFileInfo64 info;
-    if (PR_GetFileInfo64(mPath.get(), &info) != PR_SUCCESS)
-        return NSRESULT_FOR_ERRNO();
-
-    // PRTime is a 64 bit value
+    RTFSOBJINFO info;
+    int vrc = RTPathQueryInfo(mPath.get(), &info, RTFSOBJATTRADD_NOTHING);
+    if (RT_FAILURE(vrc))
+        return NSRESULT_FOR_IPRT(vrc);
+
     // microseconds -> milliseconds
-    PRInt64 usecPerMsec;
-    LL_I2L(usecPerMsec, PR_USEC_PER_MSEC);
-    LL_DIV(*aLastModTime, info.modifyTime, usecPerMsec);
+    *aLastModTime = RTTimeSpecGetMilli(&info.ModificationTime);
     return NS_OK;
 }
@@ -994 +949 @@
     }
     InvalidateCache();
-    return NSRESULT_FOR_RETURN(result);
+    return NSRESULT_FOR_IPRT(RTErrConvertFromErrno(result));
 }
 

trunk/src/libs/xpcom18a4/xpcom/io/nsLocalFileUnix.h

@@ -44 +44 @@
 #ifndef _nsLocalFileUNIX_H_
 #define _nsLocalFileUNIX_H_
+
+#include <iprt/file.h>
 
 #include <sys/stat.h>
@@ -126 +128 @@
     nsresult FillStatCache();
 
-    nsresult CreateAndKeepOpen(PRUint32 type, PRIntn flags,
-                               PRUint32 permissions, PRFileDesc **_retval);
+    nsresult CreateAndKeepOpen(PRUint32 type, uint32_t flags,
+                               PRUint32 permissions, RTFILE *_retval);
 };