Merge pull request JuliaLang#13638 from hessammehr/master

More efficient fix for JuliaLang#13559.

src/sys.c

@@ -310,9 +310,13 @@ static void NORETURN throw_eof_error(void)
 DLLEXPORT uint64_t jl_ios_get_nbyte_int(ios_t *s, const size_t n)
 {
  assert(n <= 8);
- size_t ret = ios_readprep(s, n);
- if (ret < n)
- throw_eof_error();
+ size_t space, ret;
+ do {
+ space = s->size - s->bpos;
+ ret = ios_readprep(s, n);
+ if (space == ret && ret < n)
+ throw_eof_error();
+ } while(ret < n);
  uint64_t x = 0;
  uint8_t *buf = (uint8_t*)&s->buf[s->bpos];
  if (n == 8) {

test/file.jl

@@ -922,3 +922,71 @@ test_12992()
 test2_12992()
 test2_12992()
 test2_12992()
+
+# issue 13559
+
+function test_13559()
+ fn = tempname()
+ run(`mkfifo $fn`)
+ # use subprocess to write 127 bytes to FIFO
+ writer_cmds = "x=open(\"$fn\", \"w\"); for i=1:127 write(x,0xaa); flush(x); sleep(0.1) end; close(x); quit()"
+ open(`$(Base.julia_cmd()) -e $writer_cmds`)
+ #quickly read FIFO, draining it and blocking but not failing with EOFError yet
+ r = open(fn, "r")
+ # 15 proper reads
+ for i=1:15
+ @test read(r, Int64) == -6148914691236517206
+ end
+ # last read should throw EOFError when FIFO closes, since there are only 7 bytes available.
+ @test_throws EOFError read(r, Int64)
+ close(r)
+ rm(fn)
+end
+@unix_only test_13559()
+
+function test_read_nbyte()
+ fn = tempname()
+ # Write one byte. One byte read should work once
+ # but 2-byte read should throw EOFError.
+ f = open(fn, "w+") do f
+ write(f, 0x55)
+ flush(f)
+ seek(f, 0)
+ @test read(f, UInt8) == 0x55
+ @test_throws EOFError read(f, UInt8)
+ seek(f, 0)
+ @test_throws EOFError read(f, UInt16)
+ end
+ # Write 2 more bytes. Now 2-byte read should work once
+ # but 4-byte read should fail with EOFError.
+ open(fn, "a+") do f
+ write(f, 0x4444)
+ flush(f)
+ seek(f, 0)
+ @test read(f, UInt16) == 0x4455
+ @test_throws EOFError read(f, UInt16)
+ seek(f,0)
+ @test_throws EOFError read(f, UInt32)
+ end
+ # Write 4 more bytes. Now 4-byte read should work once
+ # but 8-byte read should fail with EOFError.
+ open(fn, "a+") do f
+ write(f, 0x33333333)
+ flush(f)
+ seek(f, 0)
+ @test read(f, UInt32) == 0x33444455
+ @test_throws EOFError read(f, UInt32)
+ seek(f,0)
+ @test_throws EOFError read(f, UInt64)
+ end
+ # Writing one more byte should allow an 8-byte
+ # read to proceed.
+ open(fn, "a+") do f
+ write(f, 0x22)
+ flush(f)
+ seek(f, 0)
+ @test read(f, UInt64) == 0x2233333333444455
+ end
+ rm(fn)
+end
+test_read_nbyte()