Lectura de la salida binaria de un programa externo en Common Lisp

Question

Estoy intentando ejecutar un programa externo en SBCL y capturar su salida. El resultado es datos binarios (una imagen png), mientras que SBCL insiste en interpretarlo como cadenas.

He intentado un número de maneras, como

(trivial-shell:shell-command "/path/to/png-generator" :input "some input") 

(with-input-from-string (input "some input") 
    (with-output-to-string (output) 
    (run-program "/path/to/png-generator"() :input input :output output)) 


(with-input-from-string (input "some input") 
    (flexi-streams:with-output-to-sequence (output) 
    (run-program "/path/to/png-generator"() :input input :output output)) 

Pero tengo errores como

Illegal :UTF-8 character starting at byte position 0. 

Me parece que SBCL está tratando de interpretar los datos binarios como texto y decodificarlo . ¿Cómo cambio este comportamiento? Estoy interesado solo en obtener un vector de octetos.

Editar: Dado que no está claro en el texto anterior, me gustaría añadir que al menos en el caso de flexi-stream, el elemento-tipo de la secuencia es un flexi-streams:octect (que es un (unsigned-byte 8)). Esperaría que al menos en este caso run-program lea los bytes sin procesar sin muchos problemas. En cambio me sale un mensaje como Don't know how to copy to stream of element-type (UNSIGNED-BYTE 8)

Answer 1

Editar: Me enojé por no poder hacer esta tarea muy simple y resolvió el problema.

Funcionalmente, la posibilidad de enviar un flujo de tipo UNSIGNED-BYTE al programa de ejecución y hacer que funcione correctamente está severamente limitada, por razones que no entiendo. Intenté flujos de grises, flexi-streams, fd streams y algunos otros mecanismos, como usted.

Sin embargo, examinando la fuente del programa de ejecución (por quinta o sexta vez), noté que hay una opción: STREAM que puede pasar a la salida. Dado eso, me pregunté si el byte de lectura funcionaría ... y lo hizo. Para un trabajo más eficiente, uno puede determinar cómo obtener la longitud de una secuencia que no sea de archivo y ejecute READ-SEQUENCE en ella.

(let* 
     ;; Get random bytes 
     ((proc-var (sb-ext:run-program "head" '("-c" "10" "/dev/urandom") 
            :search t 
     ;; let SBCL figure out the storage type. This is what solved the problem. 
            :output :stream)) 
     ;; Obtain the streams from the process object. 
     (output (process-output proc-var)) 
     (err (process-error proc-var))) 
    (values 
    ;;return both stdout and stderr, just for polish. 
    ;; do a byte read and turn it into a vector. 
    (concatenate 'vector 
       ;; A byte with value 0 is *not* value nil. Yay for Lisp! 
       (loop for byte = (read-byte output nil) 
        while byte 
        collect byte)) 
    ;; repeat for stderr 
    (concatenate 'vector 
       (loop for byte = (read-byte err nil) 
        while byte 
        collect byte)))) 

Answer 2

Si está dispuesto a utilizar algunas bibliotecas externas, esto se puede hacer con babel-streams. Esta es una función que uso para obtener contenido de manera segura de un programa. Uso: latin-1 porque mapea los primeros 256 bytes solo para los personajes. Puede eliminar los octetos a la cadena y tener el vector.

Si también quería stderr, podría utilizar 'anidado-salida-a-secuencia' anidado para obtener ambos.

(defun safe-shell (command &rest args)                           
    (octets-to-string                                
    (with-output-to-sequence (stream :external-format :latin-1)                     
    (let ((proc (sb-ext:run-program command args :search t :wait t :output stream)))                
     (case (sb-ext:process-status proc)                           
     (:exited (unless (zerop (sb-ext:process-exit-code proc))                     
        (error "Error in command")))                         
     (t (error "Unable to terminate process")))))                        
    :encoding :latin-1))                               

Answer 3

Paul Nathan ya se dio una respuesta bastante completa en cuanto a cómo para leer E/S de un programa como binarios, por lo que voy a añadir qué su código no funcionó: porque explícitamente se le solicitó SBCL para interpretar la E/S como una cadena de caracteres UTF-8, usando with-{in,out}put-to-string.

Además, me gustaría señalar que no necesita llegar al código fuente run-program para llegar a la solución. Está claramente documentado en SBCL's manual.