(define (open-input-fd fd)
  (make-input-port
   (lambda ()
     (thread-wait-for-i/o! fd #:input)
     (string-ref (car (file-read fd 1)) 0))
   (lambda ()
     (nth-value 0 (file-select fd #f 0)))
   (lambda ()
     (file-close fd))))

(define (open-output-fd fd)
  (let ((port (open-output-file* fd)))
    (make-output-port
     (lambda (buffer)
       (let loop ((buffer buffer) (len (string-length buffer)))
         (thread-wait-for-i/o! fd #:output)
         (let ((written (file-write fd buffer)))
           (unless (= written len)
             (loop (substring written len) (- len written))))))
     (lambda ()
       (close-output-port port))
     (lambda ()
       (flush-output port)))))

(define (open-output-fd fd)
  (let ((port (open-output-file* fd)))
    (make-output-port
     (lambda (buffer)
       (let loop ((buffer buffer) (len (string-length buffer)))
         (thread-wait-for-i/o! fd #:output)
         (let ((written (file-write fd buffer)))
           (unless (= written len)
             (loop (substring buffer written len) (- len written))))))
     (lambda ()
       (close-output-port port))
     (lambda ()
       (flush-output port)))))

(define (open-output-fd fd)
  (let ((port (open-output-file* fd)))
    (make-output-port
     (lambda (buffer)
       (let loop ((buffer buffer) (len (string-length buffer)))
         (thread-wait-for-i/o! fd #:output)
         (let ((written (file-write fd buffer)))
           (if (negative? written)
               (case (errno)
                 ((errno/intr errno/again)
                  (loop buffer len))
                 (else (error "Error writing to fd" fd (errno))))
               (unless (= written len)
                 (loop (substring buffer written len) (- len written)))))))
     (lambda ()
       (close-output-port port))
     (lambda ()
       (flush-output port)))))

(define (open-output-fd fd)
  (let ((port (open-output-file* fd)))
    (make-output-port
     (lambda (buffer)
       (let loop ((buffer buffer) (len (string-length buffer)))
         (thread-wait-for-i/o! fd #:output)
         (let ((written (file-write fd buffer)))
           (if (negative? written)
               (select (errno)
                 ((errno/intr errno/again)
                  (loop buffer len))
                 (else (error "Error writing to fd" fd (errno))))
               (unless (= written len)
                 (loop (substring buffer written len) (- len written)))))))
     (lambda ()
       (close-output-port port))
     (lambda ()
       (flush-output port)))))

(define (open-input-fd fd)
  (make-input-port
   (lambda ()
     (let loop ()
       (thread-wait-for-i/o! fd #:input)
       (or (condition-case
               (string-ref (car (file-read fd 1)) 0)
             (exn (exn i/o file)
                  (select (errno)
                    ((errno/intr errno/again errno/wouldblock)
                     #f)
                    (else (signal exn)))))
           (loop buffer len))))
   (lambda ()
     (nth-value 0 (file-select fd #f 0)))
   (lambda ()
     (file-close fd))))

(define (open-output-fd fd)
  (let ((port (open-output-file* fd)))
    (make-output-port
     (lambda (buffer)
       (let loop ((buffer buffer) (len (string-length buffer)))
         (thread-wait-for-i/o! fd #:output)
         (let ((written (condition-case
                            (file-write fd buffer)
                          (exn (exn i/o file)
                               (select (errno)
                                 ((errno/intr errno/again errno/wouldblock)
                                  #f)
                                 (else (signal exn)))))))
           (if written
               (unless (= written len)
                 (loop (substring buffer written len) (- len written)))
               (loop buffer len)))))
     (lambda ()
       (close-output-port port))
     (lambda ()
       (flush-output port)))))