tests: Add test for issue 2959.
[gnupg.git] / tests / openpgp / defs.scm
index 3280d7c..7c8e10a 100644 (file)
@@ -1,6 +1,6 @@
 ;; Common definitions for the OpenPGP test scripts.
 ;;
-;; Copyright (C) 2016 g10 Code GmbH
+;; Copyright (C) 2016, 2017 g10 Code GmbH
 ;;
 ;; This file is part of GnuPG.
 ;;
@@ -29,7 +29,7 @@
 (define usrpass3 "")
 
 (define dsa-usrname1 "pgp5")
-;; we use the sub key because we do not yet have the logic to to derive
+;; we use the sub key because we do not yet have the logic to derive
 ;; the first encryption key from a keyblock (I guess) (Well of course
 ;; we have this by now and the notation below will lookup the primary
 ;; first and then search for the encryption subkey.)
        default
        value)))
 
+(define (percent-decode s)
+  (define (decode c)
+    (if (and (> (length c) 2) (char=? #\% (car c)))
+       (integer->char (string->number (string #\# #\x (cadr c) (caddr c))))
+       #f))
+  (let loop ((i 0) (c (string->list s)) (r (make-string (string-length s))))
+    (if (null? c)
+       (substring r 0 i)
+       (let ((decoded (decode c)))
+         (string-set! r i (if decoded decoded (car c)))
+         (loop (+ 1 i) (if decoded (cdddr c) (cdr c)) r)))))
+(assert (equal? (percent-decode "") ""))
+(assert (equal? (percent-decode "%61") "a"))
+(assert (equal? (percent-decode "foob%61r") "foobar"))
+
+(define (percent-encode s)
+  (define (encode c)
+    `(#\% ,@(string->list (number->string (char->integer c) 16))))
+  (let loop ((acc '()) (cs (reverse (string->list s))))
+    (if (null? cs)
+       (list->string acc)
+       (case (car cs)
+         ((#\: #\%)
+          (loop (append (encode (car cs)) acc) (cdr cs)))
+         (else
+          (loop (cons (car cs) acc) (cdr cs)))))))
+(assert (equal? (percent-encode "") ""))
+(assert (equal? (percent-encode "%61") "%2561"))
+(assert (equal? (percent-encode "foob%61r") "foob%2561r"))
+
 (define tools
   '((gpgv "GPGV" "g10/gpgv")
     (gpg-connect-agent "GPG_CONNECT_AGENT" "tools/gpg-connect-agent")
     (gpg-zip "GPGZIP" "tools/gpg-zip")
     (pinentry "PINENTRY" "tests/openpgp/fake-pinentry")))
 
+(define bin-prefix (getenv "BIN_PREFIX"))
+(define installed? (not (string=? "" bin-prefix)))
+
 (define (tool-hardcoded which)
-  (let ((t (assoc which tools))
-       (prefix (getenv "BIN_PREFIX")))
+  (let ((t (assoc which tools)))
     (getenv' (cadr t)
-            (qualify (if (string=? prefix "")
-                         (string-append (getenv "objdir") "/" (caddr t))
-                         (string-append prefix "/" (basename (caddr t))))))))
+            (qualify (if installed?
+                         (string-append bin-prefix "/" (basename (caddr t)))
+                         (string-append (getenv "objdir") "/" (caddr t)))))))
+
+;; You can splice VALGRIND into your argument vector to run programs
+;; under valgrind.  For example, to run valgrind on gpg, you may want
+;; to redefine gpg:
+;;
+;; (set! gpg `(,@valgrind ,@gpg))
+;;
+(define valgrind
+  '("/usr/bin/valgrind" --leak-check=full --error-exitcode=154))
+
+(unless installed?
+       (setenv "GNUPG_BUILDDIR" (getenv "objdir") #t))
 
 (define (gpg-conf . args)
-  (let ((s (call-popen `(,(tool-hardcoded 'gpgconf) ,@args) "")))
-    (map (lambda (line) (string-split line #\:))
+  (gpg-conf' "" args))
+(define (gpg-conf' input args)
+  (let ((s (call-popen `(,(tool-hardcoded 'gpgconf)
+                        ,@(if installed? '()
+                              (list '--build-prefix (getenv "objdir")))
+                        ,@args) input)))
+    (map (lambda (line) (map percent-decode (string-split line #\:)))
         (string-split-newlines s))))
 (define :gc:c:name car)
 (define :gc:c:description cadr)
 (define :gc:c:pgmname caddr)
-
-(setenv "GNUPG_BUILDDIR" (getenv "objdir") #t)
-(define gpg-components (gpg-conf '--build-prefix (getenv "objdir")
-                                '--list-components))
+(define (:gc:o:name x)             (list-ref x 0))
+(define (:gc:o:flags x)            (string->number (list-ref x 1)))
+(define (:gc:o:level x)            (string->number (list-ref x 2)))
+(define (:gc:o:description x)      (list-ref x 3))
+(define (:gc:o:type x)             (string->number (list-ref x 4)))
+(define (:gc:o:alternate-type x)   (string->number (list-ref x 5)))
+(define (:gc:o:argument-name x)    (list-ref x 6))
+(define (:gc:o:default-value x)    (list-ref x 7))
+(define (:gc:o:default-argument x) (list-ref x 8))
+(define (:gc:o:value x)            (if (< (length x) 10) "" (list-ref x 9)))
+
+(define (gpg-config component key)
+  (package
+   (define (value)
+     (let* ((conf (assoc key (gpg-conf '--list-options component)))
+           (type (:gc:o:type conf))
+           (value (:gc:o:value conf)))
+       (case type
+        ((0 2 3) (string->number value))
+        ((1 32) (substring value 1 (string-length value))))))
+   (define (update value)
+     (let ((value' (cond
+                   ((string? value) (string-append "\"" value))
+                   ((number? value) (number->string value))
+                   (else (throw "Unsupported value" value)))))
+       (gpg-conf' (string-append key ":0:" (percent-encode value'))
+                 `(--change-options ,component))))
+   (define (clear)
+     (gpg-conf' (string-append key ":16:")
+               `(--change-options ,component)))))
+
+(define gpg-components (apply gpg-conf '(--list-components)))
 
 (define (tool which)
   (case which
 
 (setenv "GPG_AGENT_INFO" "" #t)
 (setenv "GNUPGHOME" (getcwd) #t)
+(define GNUPGHOME (getcwd))
 
 ;;
 ;; GnuPG helper.
 ;;
 
+;; Evaluate a sequence of expressions with the given home directory.
+(define-macro (with-home-directory gnupghome . expressions)
+  (let ((original-home-directory (gensym)))
+    `(let ((,original-home-directory (getenv "GNUPGHOME")))
+       (dynamic-wind
+          (lambda () (setenv "GNUPGHOME" ,gnupghome #t))
+          (lambda () ,@expressions)
+          (lambda () (setenv "GNUPGHOME" ,original-home-directory #t))))))
+
 ;; Evaluate a sequence of expressions with an ephemeral home
 ;; directory.
-(macro (with-ephemeral-home-directory form)
-  `(let ((original-home-directory (getenv "GNUPGHOME")))
-     (with-temporary-working-directory
-      (define ephemeral-home-directory (getcwd))
-      (dynamic-wind
-         (lambda () (setenv "GNUPGHOME" ephemeral-home-directory #t))
-         (lambda () ,@(cdr form))
-         (lambda () (setenv "GNUPGHOME" original-home-directory #t))))))
+(define-macro (with-ephemeral-home-directory . expressions)
+  (let ((original-home-directory (gensym))
+       (ephemeral-home-directory (gensym)))
+    `(let ((,original-home-directory (getenv "GNUPGHOME"))
+          (,ephemeral-home-directory (mkdtemp)))
+       (finally (unlink-recursively ,ephemeral-home-directory)
+        (dynamic-wind
+            (lambda () (setenv "GNUPGHOME" ,ephemeral-home-directory #t))
+            (lambda () ,@expressions)
+            (lambda () (setenv "GNUPGHOME" ,original-home-directory #t)))))))
 
 ;; Call GPG to obtain the hash sums.  Either specify an input file in
 ;; ARGS, or an string in INPUT.  Returns a list of (<algo>
 
 (define (create-legacy-gpghome)
   (create-sample-files)
-  (mkdir "private-keys-v1.d" "-rwx")
 
   (log "Storing private keys")
   (for-each
 ;; Create the socket dir and start the agent.
 (define (start-agent)
   (log "Starting gpg-agent...")
-  (atexit stop-agent)
+  (let ((gnupghome (getenv "GNUPGHOME")))
+    (atexit (lambda ()
+             (with-home-directory gnupghome
+                                  (stop-agent)))))
   (catch (log "Warning: Creating socket directory failed:" (car *error*))
         (call-popen `(,(tool 'gpgconf) --create-socketdir) ""))
   (call-check `(,(tool 'gpg-connect-agent) --verbose