Update third_party/nss to NSS 3.15.4.

nss/lib/freebl/unix_rand.c

 /* 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 <stdio.h>
 #include <string.h>
 #include <signal.h>
 #include <unistd.h>
 #include <limits.h>
 #include <errno.h>
@@ skipping 952 matching lines @@
     }
 #endif
 
 }
 
 #define TOTAL_FILE_LIMIT 1000000        /* one million */
 
 size_t RNG_FileUpdate(const char *fileName, size_t limit)
 {
     FILE *        file;
-    size_t        bytes;
+    int           fd;
+    int           bytes;
     size_t        fileBytes = 0;
     struct stat   stat_buf;
     unsigned char buffer[BUFSIZ];
     static size_t totalFileBytes = 0;
     
     /* suppress valgrind warnings due to holes in struct stat */
     memset(&stat_buf, 0, sizeof(stat_buf));
 
     if (stat((char *)fileName, &stat_buf) < 0)
         return fileBytes;
     RNG_RandomUpdate(&stat_buf, sizeof(stat_buf));
     
-    file = fopen((char *)fileName, "r");
+    file = fopen(fileName, "r");
     if (file != NULL) {
+        /* Read from the underlying file descriptor directly to bypass stdio
+         * buffering and avoid reading more bytes than we need from
+         * /dev/urandom. NOTE: we can't use fread with unbuffered I/O because
+         * fread may return EOF in unbuffered I/O mode on Android.
+         *
+         * Moreover, we read into a buffer of size BUFSIZ, so buffered I/O
+         * has no performance advantage. */
+        fd = fileno(file);
+        /* 'file' was just opened, so this should not fail. */
+        PORT_Assert(fd != -1);
         while (limit > fileBytes) {
             bytes = PR_MIN(sizeof buffer, limit - fileBytes);
-            bytes = fread(buffer, 1, bytes, file);
-            if (bytes == 0) 
+            bytes = read(fd, buffer, bytes);
+            if (bytes <= 0)
                 break;
             RNG_RandomUpdate(buffer, bytes);
             fileBytes      += bytes;
             totalFileBytes += bytes;
             /* after TOTAL_FILE_LIMIT has been reached, only read in first
             ** buffer of data from each subsequent file.
             */
             if (totalFileBytes > TOTAL_FILE_LIMIT) 
                 break;
         }
@@ skipping 11 matching lines @@
 void RNG_FileForRNG(const char *fileName)
 {
     RNG_FileUpdate(fileName, TOTAL_FILE_LIMIT);
 }
 
 void ReadSingleFile(const char *fileName)
 {
     FILE *        file;
     unsigned char buffer[BUFSIZ];
     
-    file = fopen((char *)fileName, "rb");
+    file = fopen(fileName, "rb");
     if (file != NULL) {
         while (fread(buffer, 1, sizeof(buffer), file) > 0)
             ;
         fclose(file);
     } 
 }
 
 #define _POSIX_PTHREAD_SEMANTICS
 #include <dirent.h>
 
@@ skipping 101 matching lines @@
 }
 
 /*
  * Modified to abort the process if it failed to read from /dev/urandom.
  *
  * See crbug.com/244661 for details.
  */
 size_t RNG_SystemRNG(void *dest, size_t maxLen)
 {
     FILE *file;
-    size_t bytes;
+    int fd;
+    int bytes;
     size_t fileBytes = 0;
     unsigned char *buffer = dest;
 
     file = fopen("/dev/urandom", "r");
     if (file == NULL) {
         fprintf(stderr, "[ERROR:%s(%d)] NSS failed to read from /dev/urandom. "
                 "Abort process.\n", __FILE__, __LINE__);
         fflush(stderr);
         abort();
     }
+    /* Read from the underlying file descriptor directly to bypass stdio
+     * buffering and avoid reading more bytes than we need from /dev/urandom.
+     * NOTE: we can't use fread with unbuffered I/O because fread may return
+     * EOF in unbuffered I/O mode on Android.
+     */
+    fd = fileno(file);
+    /* 'file' was just opened, so this should not fail. */
+    PORT_Assert(fd != -1);
     while (maxLen > fileBytes) {
         bytes = maxLen - fileBytes;
-        bytes = fread(buffer, 1, bytes, file);
-        if (bytes == 0) 
+        bytes = read(fd, buffer, bytes);
+        if (bytes <= 0)
             break;
         fileBytes += bytes;
         buffer += bytes;
     }
     fclose(file);
     if (fileBytes != maxLen) {
         fprintf(stderr, "[ERROR:%s(%d)] NSS failed to read from /dev/urandom. "
                 "Abort process.\n", __FILE__, __LINE__);
         fflush(stderr);
         abort();
     }
     return fileBytes;
 }