;; popen emulation, for non-stdio based ports. ;;;; Copyright (C) 1998-2001, 2003, 2006, 2010-2013, 2019 ;;;; Free Software Foundation, Inc. ;;;; ;;;; This library is free software; you can redistribute it and/or ;;;; modify it under the terms of the GNU Lesser General Public ;;;; License as published by the Free Software Foundation; either ;;;; version 3 of the License, or (at your option) any later version. ;;;; ;;;; This library is distributed in the hope that it will be useful, ;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ;;;; Lesser General Public License for more details. ;;;; ;;;; You should have received a copy of the GNU Lesser General Public ;;;; License along with this library; if not, write to the Free Software ;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ;;;; (define-module (ice-9 popen) #:use-module (rnrs bytevectors) #:use-module (ice-9 binary-ports) #:use-module (ice-9 threads) #:use-module (srfi srfi-1) #:use-module (srfi srfi-9) #:export (port/pid-table open-pipe* open-pipe close-pipe open-input-pipe open-output-pipe open-input-output-pipe pipeline)) (eval-when (expand load eval) (load-extension (string-append "libguile-" (effective-version)) "scm_init_popen")) (define-record-type (make-pipe-info pid) pipe-info? (pid pipe-info-pid set-pipe-info-pid!)) (define (make-rw-port read-port write-port) (define (read! bv start count) (let ((result (get-bytevector-some! read-port bv start count))) (if (eof-object? result) 0 result))) (define (write! bv start count) (put-bytevector write-port bv start count) count) (define (close) (close-port read-port) (close-port write-port)) (define rw-port (make-custom-binary-input/output-port "ice-9-popen-rw-port" read! write! #f ;get-position #f ;set-position! close)) ;; Enable buffering on 'read-port' so that 'get-bytevector-some' will ;; return non-trivial blocks. (setvbuf read-port 'block 16384) ;; Inherit the port-encoding from the read-port. (set-port-encoding! rw-port (port-encoding read-port)) ;; Reset the port encoding on the underlying ports to inhibit BOM ;; handling there. Instead, the BOM handling (if any) will be handled ;; in the rw-port. In the current implementation of Guile ports, ;; using binary I/O primitives alone is not enough to reliably inhibit ;; BOM handling, if the port encoding is set to UTF-{8,16,32}. (set-port-encoding! read-port "ISO-8859-1") (set-port-encoding! write-port "ISO-8859-1") rw-port) ;; a guardian to ensure the cleanup is done correctly when ;; an open pipe is gc'd or a close-port is used. (define pipe-guardian (make-guardian)) ;; a weak hash-table to store the process ids. ;; XXX use of this table is deprecated. It is no longer used here, and ;; is populated for backward compatibility only (since it is exported). (define port/pid-table (make-weak-key-hash-table)) (define port/pid-table-mutex (make-mutex)) (define (pipe->fdes) (let ((p (pipe))) (cons (port->fdes (car p)) (port->fdes (cdr p))))) (define (open-process mode command . args) "Backwards compatible implementation of the former procedure in libguile/posix.c (scm_open_process) replaced by scm_piped_process. Executes the program @var{command} with optional arguments @var{args} (all strings) in a subprocess. A port to the process (based on pipes) is created and returned. @var{mode} specifies whether an input, an output or an input-output port to the process is created: it should be the value of @code{OPEN_READ}, @code{OPEN_WRITE} or @code{OPEN_BOTH}." (define (unbuffered port) (setvbuf port 'none) port) (define (fdes-pair ports) (and ports (cons (port->fdes (car ports)) (port->fdes (cdr ports))))) (let* ((from (and (or (string=? mode OPEN_READ) (string=? mode OPEN_BOTH)) (pipe))) (to (and (or (string=? mode OPEN_WRITE) (string=? mode OPEN_BOTH)) (pipe))) (pid (piped-process command args (fdes-pair from) (fdes-pair to)))) ;; The original 'open-process' procedure would return unbuffered ;; ports; do the same here. (values (and from (unbuffered (car from))) (and to (unbuffered (cdr to))) pid))) (define (open-pipe* mode command . args) "Executes the program @var{command} with optional arguments @var{args} (all strings) in a subprocess. A port to the process (based on pipes) is created and returned. @var{mode} specifies whether an input, an output or an input-output port to the process is created: it should be the value of @code{OPEN_READ}, @code{OPEN_WRITE} or @code{OPEN_BOTH}." (call-with-values (lambda () (apply open-process mode command args)) (lambda (read-port write-port pid) (let ((port (or (and read-port write-port (make-rw-port read-port write-port)) read-port write-port (%make-void-port mode))) (pipe-info (make-pipe-info pid))) ;; Guard the pipe-info instead of the port, so that we can still ;; call 'waitpid' even if 'close-port' is called (which clears ;; the port entry). (pipe-guardian pipe-info) (%set-port-property! port 'popen-pipe-info pipe-info) ;; XXX populate port/pid-table for backward compatibility. (with-mutex port/pid-table-mutex (hashq-set! port/pid-table port pid)) port)))) (define (open-pipe command mode) "Executes the shell command @var{command} (a string) in a subprocess. A port to the process (based on pipes) is created and returned. @var{mode} specifies whether an input, an output or an input-output port to the process is created: it should be the value of @code{OPEN_READ}, @code{OPEN_WRITE} or @code{OPEN_BOTH}." (open-pipe* mode "/bin/sh" "-c" command)) (define (fetch-pipe-info port) (%port-property port 'popen-pipe-info)) (define (close-process port pid) (close-port port) (cdr (waitpid pid))) (define (close-pipe p) "Closes the pipe created by @code{open-pipe}, then waits for the process to terminate and returns its status value, @xref{Processes, waitpid}, for information on how to interpret this value." (let ((pipe-info (fetch-pipe-info p))) (unless pipe-info (error "close-pipe: port not created by (ice-9 popen)")) (let ((pid (pipe-info-pid pipe-info))) (unless pid (error "close-pipe: pid has already been cleared")) ;; clear the pid to avoid repeated calls to 'waitpid'. (set-pipe-info-pid! pipe-info #f) (close-process p pid)))) (define (reap-pipes) (let loop () (let ((pipe-info (pipe-guardian))) (when pipe-info (let ((pid (pipe-info-pid pipe-info))) ;; maybe 'close-pipe' was already called. (when pid ;; clean up without reporting errors. also avoids blocking ;; the process: if the child isn't ready to be collected, ;; puts it back into the guardian's live list so it can be ;; tried again the next time the cleanup runs. (catch 'system-error (lambda () (let ((pid/status (waitpid pid WNOHANG))) (if (zero? (car pid/status)) (pipe-guardian pipe-info) ; not ready for collection (set-pipe-info-pid! pipe-info #f)))) (lambda args #f)))) (loop))))) (add-hook! after-gc-hook reap-pipes) (define (open-input-pipe command) "Equivalent to @code{open-pipe} with mode @code{OPEN_READ}" (open-pipe command OPEN_READ)) (define (open-output-pipe command) "Equivalent to @code{open-pipe} with mode @code{OPEN_WRITE}" (open-pipe command OPEN_WRITE)) (define (open-input-output-pipe command) "Equivalent to @code{open-pipe} with mode @code{OPEN_BOTH}" (open-pipe command OPEN_BOTH)) (define (pipeline commands) "Execute a pipeline of @var{commands}, where each command is a list of a program and its arguments as strings, returning an input port to the end of the pipeline, an output port to the beginning of the pipeline and a list of PIDs of the processes executing the @var{commands}." (let* ((to (pipe->fdes)) (pipes (map (lambda _ (pipe->fdes)) commands)) (pipeline (fold (lambda (from proc prev) (let* ((to (car prev)) (pids (cdr prev)) (pid (piped-process (car proc) (cdr proc) from to))) (cons from (cons pid pids)))) `(,to) pipes commands)) (from (car pipeline)) (pids (cdr pipeline))) (values (fdes->inport (car from)) (fdes->outport (cdr to)) pids)))