hash: Add `open-sha256-port'.

* guix/hash.scm (GCRY_MD_SHA256): New macro.
  (sha256): Use it.
  (open-sha256-md, md-write, md-read, md-close, open-sha256-port,
  port-sha256): New procedures.
* tests/hash.scm: New file.
* Makefile.am (SCM_TESTS): Add it.

Makefile.am

@@ -84,6 +84,7 @@ nobase_nodist_guilemodule_DATA = $(GOBJECTS) guix/config.scm
 
 SCM_TESTS =					\
   tests/base32.scm				\
+  tests/hash.scm				\
   tests/builders.scm				\
   tests/derivations.scm				\
   tests/ui.scm					\

guix/hash.scm

@@ -19,8 +19,13 @@
 (define-module (guix hash)
   #:use-module (guix config)
   #:use-module (rnrs bytevectors)
+  #:use-module (rnrs io ports)
   #:use-module (system foreign)
-  #:export (sha256))
+  #:use-module ((guix build utils) #:select (dump-port))
+  #:use-module (srfi srfi-11)
+  #:export (sha256
+            open-sha256-port
+            port-sha256))
 
 ;;; Commentary:
 ;;;
@@ -33,17 +38,94 @@ (define-module (guix hash)
 ;;; Hash.
 ;;;
 
+(define-syntax GCRY_MD_SHA256
+  ;; Value as of Libgcrypt 1.5.2.
+  (identifier-syntax 8))
+
 (define sha256
-  (let ((hash   (pointer->procedure void
-                                    (dynamic-func "gcry_md_hash_buffer"
-                                                  (dynamic-link %libgcrypt))
-                                    `(,int * * ,size_t)))
-        (sha256 8))                        ; GCRY_MD_SHA256, as of 1.5.0
+  (let ((hash (pointer->procedure void
+                                  (dynamic-func "gcry_md_hash_buffer"
+                                                (dynamic-link %libgcrypt))
+                                  `(,int * * ,size_t))))
     (lambda (bv)
       "Return the SHA256 of BV as a bytevector."
       (let ((digest (make-bytevector (/ 256 8))))
-        (hash sha256 (bytevector->pointer digest)
+        (hash GCRY_MD_SHA256 (bytevector->pointer digest)
               (bytevector->pointer bv) (bytevector-length bv))
         digest))))
 
+(define open-sha256-md
+  (let ((open (pointer->procedure int
+                                  (dynamic-func "gcry_md_open"
+                                                (dynamic-link %libgcrypt))
+                                  `(* ,int ,unsigned-int))))
+    (lambda ()
+      (let* ((md  (bytevector->pointer (make-bytevector (sizeof '*))))
+             (err (open md GCRY_MD_SHA256 0)))
+        (if (zero? err)
+            (dereference-pointer md)
+            (throw 'gcrypt-error err))))))
+
+(define md-write
+  (pointer->procedure void
+                      (dynamic-func "gcry_md_write"
+                                    (dynamic-link %libgcrypt))
+                      `(* * ,size_t)))
+
+(define md-read
+  (pointer->procedure '*
+                      (dynamic-func "gcry_md_read"
+                                    (dynamic-link %libgcrypt))
+                      `(* ,int)))
+
+(define md-close
+  (pointer->procedure void
+                      (dynamic-func "gcry_md_close"
+                                    (dynamic-link %libgcrypt))
+                      '(*)))
+
+
+(define (open-sha256-port)
+  "Return two values: an output port, and a thunk.  When the thunk is called,
+it returns the SHA256 hash (a bytevector) of all the data written to the
+output port."
+  (define sha256-md
+    (open-sha256-md))
+
+  (define digest #f)
+
+  (define (finalize!)
+    (let ((ptr (md-read sha256-md 0)))
+      (set! digest (bytevector-copy (pointer->bytevector ptr 32)))
+      (md-close sha256-md)))
+
+  (define (write! bv offset len)
+    (if (zero? len)
+        (begin
+          (finalize!)
+          0)
+        (let ((ptr (bytevector->pointer bv offset)))
+          (md-write sha256-md ptr len)
+          len)))
+
+  (define (close)
+    (unless digest
+      (finalize!)))
+
+  (values (make-custom-binary-output-port "sha256"
+                                          write! #f #f
+                                          close)
+          (lambda ()
+            (unless digest
+              (finalize!))
+            digest)))
+
+(define (port-sha256 port)
+  "Return the SHA256 hash (a bytevector) of all the data drained from PORT."
+  (let-values (((out get)
+                (open-sha256-port)))
+    (dump-port port out)
+    (close-port out)
+    (get)))
+
 ;;; hash.scm ends here

tests/hash.scm

+;;; GNU Guix --- Functional package management for GNU
+;;; Copyright © 2013 Ludovic Courtès <ludo@gnu.org>
+;;;
+;;; This file is part of GNU Guix.
+;;;
+;;; GNU Guix is free software; you can redistribute it and/or modify it
+;;; under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation; either version 3 of the License, or (at
+;;; your option) any later version.
+;;;
+;;; GNU Guix 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 General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
+
+(define-module (test-hash)
+  #:use-module (guix hash)
+  #:use-module (guix utils)
+  #:use-module (srfi srfi-1)
+  #:use-module (srfi srfi-11)
+  #:use-module (srfi srfi-64)
+  #:use-module (rnrs bytevectors)
+  #:use-module (rnrs io ports))
+
+;; Test the (guix hash) module.
+
+(define %empty-sha256
+  ;; SHA256 hash of the empty string.
+  (base16-string->bytevector
+   "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"))
+
+(define %hello-sha256
+  ;; SHA256 hash of "hello world"
+  (base16-string->bytevector
+   "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"))
+
+(test-begin "hash")
+
+(test-equal "sha256, empty"
+  %empty-sha256
+  (sha256 #vu8()))
+
+(test-equal "sha256, hello"
+  %hello-sha256
+  (sha256 (string->utf8 "hello world")))
+
+(test-equal "open-sha256-port, empty"
+  %empty-sha256
+  (let-values (((port get)
+                (open-sha256-port)))
+    (close-port port)
+    (get)))
+
+(test-equal "open-sha256-port, hello"
+  %hello-sha256
+  (let-values (((port get)
+                (open-sha256-port)))
+    (put-bytevector port (string->utf8 "hello world"))
+    (get)))
+
+(test-assert "port-sha256"
+  (let* ((file     (search-path %load-path "ice-9/psyntax.scm"))
+         (size     (stat:size (stat file)))
+         (contents (call-with-input-file file get-bytevector-all)))
+    (equal? (sha256 contents)
+            (call-with-input-file file port-sha256))))
+
+(test-end)
+
+
+(exit (= (test-runner-fail-count (test-runner-current)) 0))