* epg.el (epg-make-data-from-file): New function.

(epg-make-data-from-string): New function.
(epg-data-file): New function.
(epg-data-string): New function.
(epg-start-decrypt): Get a cipher text from a data object.
(epg-delete-output-file): New function.
(epg-decrypt-file): Add the 3rd argument PLAIN to specify where
the output goes.
(epg-start-verify): Get a signature and signed-text from a data
object.
(epg-verify-file): Added the 3rd argument PLAIN to specify where
the output goes; return the plain text if PLAIN is nil.
(epg-verify-string): Return the plain text.
(epg-start-sign): Get a plain text from a data object.
(epg-sign-file): Added the 3rd argument SIGNATURE to specify where
the output goes.
(epg-start-encrypt): Get a plain text from a data object.
(epg-encrypt-file): Added the 4th argument CIPHER to specify where
the output goes.
(epg-start-import-keys): Get keys from a data object.
(epg-import-keys-1): New function.
(epg-import-keys-from-file): Use it.
(epg-import-keys-from-string): Use it.

diff --git a/ChangeLog b/ChangeLog
index 74068e2..b89a3f0 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,29 @@
+2006-04-13  Daiki Ueno  <ueno@unixuser.org>
+
+       * epg.el (epg-make-data-from-file): New function.
+       (epg-make-data-from-string): New function.
+       (epg-data-file): New function.
+       (epg-data-string): New function.
+       (epg-start-decrypt): Get a cipher text from a data object.
+       (epg-delete-output-file): New function.
+       (epg-decrypt-file): Add the 3rd argument PLAIN to specify where
+       the output goes.
+       (epg-start-verify): Get a signature and signed-text from a data
+       object.
+       (epg-verify-file): Added the 3rd argument PLAIN to specify where
+       the output goes; return the plain text if PLAIN is nil.
+       (epg-verify-string): Return the plain text.
+       (epg-start-sign): Get a plain text from a data object.
+       (epg-sign-file): Added the 3rd argument SIGNATURE to specify where
+       the output goes.
+       (epg-start-encrypt): Get a plain text from a data object.
+       (epg-encrypt-file): Added the 4th argument CIPHER to specify where
+       the output goes.
+       (epg-start-import-keys): Get keys from a data object.
+       (epg-import-keys-1): New function.
+       (epg-import-keys-from-file): Use it.
+       (epg-import-keys-from-string): Use it.
+
 2006-04-12  Daiki Ueno  <ueno@unixuser.org>
 
        * epf.el: Renamed from epg-file.el.

diff --git a/epf.el b/epf.el
index 7205353..3dfbbcd 100644 (file)
--- a/epf.el
+++ b/epf.el
@@ -156,7 +156,8 @@ with GnuPG."
          (unwind-protect
              (progn
                (setq string (epg-decrypt-file context (or local-file
-                                                          filename))
+                                                          filename)
+                                              nil)
                      length (length string))
                (if replace
                    (goto-char (point-min)))

diff --git a/epg.el b/epg.el
index 1e53a89..5dc04d6 100644 (file)
--- a/epg.el
+++ b/epg.el
@@ -86,12 +86,28 @@ This is used by `epg-list-keys'.")
 This is used by `epg-list-keys'.")
 
 (defvar epg-prompt-alist nil)
-    
+
+(defun epg-make-data-from-file (file)
+  "Make a data object from FILE."
+  (vector file nil))
+
+(defun epg-make-data-from-string (string)
+  "Make a data object from STRING."
+  (vector nil string))
+
+(defun epg-data-file (data)
+  "Return the file of DATA."
+  (aref data 0))
+
+(defun epg-data-string (data)
+  "Return the string of DATA."
+  (aref data 1))
+
 (defun epg-make-context (&optional protocol armor textmode include-certs)
   "Return a context object."
   (vector protocol armor textmode include-certs
-         (cons #'epg-passphrase-callback-function nil)
-         (cons #'epg-progress-callback-function nil)
+         #'epg-passphrase-callback-function
+         #'epg-progress-callback-function
          nil nil nil nil))
 
 (defun epg-context-protocol (context)
@@ -111,11 +127,11 @@ This is used by `epg-list-keys'.")
 message."
   (aref context 3))
 
-(defun epg-context-passphrase-callback-info (context)
+(defun epg-context-passphrase-callback (context)
   "Return the function used to query passphrase."
   (aref context 4))
 
-(defun epg-context-progress-callback-info (context)
+(defun epg-context-progress-callback (context)
   "Return the function which handles progress update."
   (aref context 5))
 
@@ -153,14 +169,14 @@ This function is for internal use only."
  "Set how many certificates should be included in an S/MIME signed message."
   (aset context 3 include-certs))
 
-(defun epg-context-set-passphrase-callback-info (context
-                                                passphrase-callback-info)
+(defun epg-context-set-passphrase-callback (context
+                                                passphrase-callback)
   "Set the function used to query passphrase."
-  (aset context 4 passphrase-callback-info))
+  (aset context 4 passphrase-callback))
 
-(defun epg-context-set-progress-callback-info (context progress-callback-info)
+(defun epg-context-set-progress-callback (context progress-callback)
   "Set the function which handles progress update."
-  (aset context 5 progress-callback-info))
+  (aset context 5 progress-callback))
 
 (defun epg-context-set-signers (context signers)
  "Set the list of key-id for singning."
@@ -325,8 +341,11 @@ This function is for internal use only."
   (if (and (epg-context-process context)
           (buffer-live-p (process-buffer (epg-context-process context))))
       (kill-buffer (process-buffer (epg-context-process context))))
-  (epg-context-set-process context nil)
-  (if (file-exists-p (epg-context-output-file context))
+  (epg-context-set-process context nil))
+
+(defun epg-delete-output-file (context)
+  (if (and (epg-context-output-file context)
+          (file-exists-p (epg-context-output-file context)))
       (delete-file (epg-context-output-file context))))
 
 (defun epg-status-USERID_HINT (process string)
@@ -351,9 +370,12 @@ This function is for internal use only."
 
 (defun epg-status-GET_HIDDEN (process string)
   (let ((passphrase
-        (funcall (car (epg-context-passphrase-callback-info epg-context))
+        (funcall (if (consp (epg-context-passphrase-callback epg-context))
+                     (car (epg-context-passphrase-callback epg-context))
+                   (epg-context-passphrase-callback epg-context))
                  epg-key-id
-                 (cdr (epg-context-passphrase-callback-info epg-context))))
+                 (if (consp (epg-context-passphrase-callback epg-context))
+                     (cdr (epg-context-passphrase-callback epg-context)))))
        string)
     (if passphrase
        (unwind-protect
@@ -466,12 +488,15 @@ This function is for internal use only."
 (defun epg-status-PROGRESS (process string)
   (if (string-match "\\`\\([^ ]+\\) \\([^ ]\\) \\([0-9]+\\) \\([0-9]+\\)"
                    string)
-      (funcall (car (epg-context-progress-callback-info epg-context))
+      (funcall (if (consp (epg-context-progress-callback epg-context))
+                  (car (epg-context-progress-callback epg-context))
+                (epg-context-progress-callback epg-context))
               (match-string 1 string)
               (match-string 2 string)
               (string-to-number (match-string 3 string))
               (string-to-number (match-string 4 string))
-              (cdr (epg-context-progress-callback-info epg-context)))))
+              (if (consp (epg-context-progress-callback epg-context))
+                  (cdr (epg-context-progress-callback epg-context))))))
 
 (defun epg-status-DECRYPTION_FAILED (process string)
   (epg-context-set-result-for
@@ -626,103 +651,151 @@ You can then use `write-region' to write new data into the file."
             (delete-directory tempdir))))))
 
 ;;;###autoload
-(defun epg-start-decrypt (context input-file)
-  "Initiate a decrypt operation on INPUT-FILE.
+(defun epg-start-decrypt (context cipher)
+  "Initiate a decrypt operation on CIPHER.
+CIPHER is a data object.
 
 If you use this function, you will need to wait for the completion of
 `epg-gpg-program' by using `epg-wait-for-completion' and call
 `epg-reset' to clear a temporaly output file.
 If you are unsure, use synchronous version of this function
-`epg-decrypt-string' instead."
+`epg-decrypt-file' or `epg-decrypt-string' instead."
+  (unless (epg-data-file cipher)
+    (error "Not a file"))
   (epg-context-set-result context nil)
-  (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
-  (epg-start context
-            (list "--decrypt" input-file))
+  (epg-start context (list "--decrypt" (epg-data-file cipher)))
   (epg-wait-for-status context '("BEGIN_DECRYPTION")))
 
 ;;;###autoload
-(defun epg-decrypt-file (context input-file)
-  "Decrypt INPUT-FILE and return the plain text."
+(defun epg-decrypt-file (context cipher plain)
+  "Decrypt a file CIPHER and store the result to a file PLAIN.
+If PLAIN is nil, it returns the result as a string."
   (unwind-protect
       (progn
-       (epg-start-decrypt context input-file)
+       (if plain
+           (epg-context-set-output-file context plain)
+         (epg-context-set-output-file context
+                                      (epg-make-temp-file "epg-output")))
+       (epg-start-decrypt context (epg-make-data-from-file cipher))
        (epg-wait-for-completion context)
        (if (epg-context-result-for context 'error)
            (error "Decryption failed"))
-       (epg-read-output context))
+       (unless plain
+         (epg-read-output context)))
+    (unless plain
+      (epg-delete-output-file context))
     (epg-reset context)))
 
 ;;;###autoload
-(defun epg-decrypt-string (context string)
-  "Decrypt STRING and return the plain text."
+(defun epg-decrypt-string (context cipher)
+  "Decrypt a string CIPHER and return the plain text."
   (let ((input-file (epg-make-temp-file "epg-input"))
        (coding-system-for-write 'binary))
     (unwind-protect
        (progn
-         (write-region string nil input-file)
-         (epg-decrypt-file context input-file))
+         (write-region cipher nil input-file)
+         (epg-context-set-output-file context
+                                      (epg-make-temp-file "epg-output"))
+         (epg-start-decrypt context (epg-make-data-from-file input-file))
+         (epg-wait-for-completion context)
+         (if (epg-context-result-for context 'error)
+             (error "Decryption failed"))
+         (epg-read-output context))
+      (epg-delete-output-file context)
       (if (file-exists-p input-file)
-         (delete-file input-file)))))
+         (delete-file input-file))
+      (epg-reset context))))
 
 ;;;###autoload
-(defun epg-start-verify (context signature &optional string)
+(defun epg-start-verify (context signature &optional signed-text)
   "Initiate a verify operation on SIGNATURE.
+SIGNATURE and SIGNED-TEXT are a data object if they are specified.
 
-For a detached signature, both SIGNATURE and STRING should be string.
-For a normal or a clear text signature, STRING should be nil.
+For a detached signature, both SIGNATURE and SIGNED-TEXT should be set.
+For a normal or a clear text signature, SIGNED-TEXT should be nil.
 
 If you use this function, you will need to wait for the completion of
 `epg-gpg-program' by using `epg-wait-for-completion' and call
 `epg-reset' to clear a temporaly output file.
 If you are unsure, use synchronous version of this function
-`epg-verify-string' instead."
+`epg-verify-file' or `epg-verify-string' instead."
   (epg-context-set-result context nil)
-  (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
-  (if string
+  (if signed-text
       ;; Detached signature.
-      (progn
-       (epg-start context
-                  (append (list "--verify")
-                          (list signature "-")))
+      (if (epg-data-file signed-text)
+         (epg-start context (list "--verify" (epg-data-file signature)
+                                  (epg-data-file signed-text)))
+       (epg-start context (list "--verify" (epg-data-file signature) "-"))
        (if (eq (process-status (epg-context-process context)) 'run)
-           (process-send-string (epg-context-process context) string)))
+           (process-send-string (epg-context-process context)
+                                (epg-data-string signed-text))))
     ;; Normal (or cleartext) signature.
-    (epg-start context (list "--verify"))
-    (if (eq (process-status (epg-context-process context)) 'run)
-       (process-send-string (epg-context-process context) signature))))
+    (if (epg-data-file signature)
+       (epg-start context (list "--verify" (epg-data-file signature)))
+      (epg-start context (list "--verify"))
+      (if (eq (process-status (epg-context-process context)) 'run)
+         (process-send-string (epg-context-process context)
+                              (epg-data-string signature))))))
 
 ;;;###autoload
-(defun epg-verify-file (context input-file &optional string)
-  "Verify INPUT-FILE.
+(defun epg-verify-file (context signature &optional signed-text plain)
+  "Verify a file SIGNATURE.
+SIGNED-TEXT and PLAIN are also a file if they are specified.
 
-For a detached signature, both INPUT-FILE and STRING should be string.
-For a normal or a clear text signature, STRING should be nil."
+For a detached signature, both SIGNATURE and SIGNED-TEXT should be string.
+For a normal or a clear text signature, SIGNED-TEXT should be nil."
   (unwind-protect
       (progn
-       (epg-start-verify context input-file string)
+       (if plain
+           (epg-context-set-output-file context plain)
+         (epg-context-set-output-file context
+                                      (epg-make-temp-file "epg-output")))
+       (if signed-text
+           (epg-start-verify context
+                             (epg-make-data-from-file signature)
+                             (epg-make-data-from-file signed-text))
+         (epg-start-verify context
+                           (epg-make-data-from-file signature)))
        (epg-wait-for-completion context)
-       (epg-context-result-for context 'verify))
+       (unless plain
+         (epg-read-output context)))
+    (unless plain
+      (epg-delete-output-file context))
     (epg-reset context)))
 
 ;;;###autoload
-(defun epg-verify-string (context signature &optional string)
-  "Verify SIGNATURE.
-
-For a detached signature, both SIGNATURE and STRING should be string.
-For a normal or a clear text signature, STRING should be nil."
-  (let ((input-file (epg-make-temp-file "epg-input"))
-       (coding-system-for-write 'binary))
+(defun epg-verify-string (context signature &optional signed-text)
+  "Verify a string SIGNATURE.
+SIGNED-TEXT is a string if it is specified.
+
+For a detached signature, both SIGNATURE and SIGNED-TEXT should be string.
+For a normal or a clear text signature, SIGNED-TEXT should be nil."
+  (let ((coding-system-for-write 'binary)
+       input-file)
     (unwind-protect
        (progn
-         (if string
-             (write-region signature nil input-file))
-         (epg-verify-file context input-file string))
-      (if (file-exists-p input-file)
-         (delete-file input-file)))))
+         (epg-context-set-output-file context
+                                      (epg-make-temp-file "epg-output"))
+         (if signed-text
+             (progn
+               (setq input-file (epg-make-temp-file "epg-signature"))
+               (write-region signature nil input-file)
+               (epg-start-verify context
+                                 (epg-make-data-from-file input-file)
+                                 (epg-make-data-from-string signed-text)))
+           (epg-start-verify context (epg-make-data-from-string signature)))
+         (epg-wait-for-completion context)
+         (epg-read-output context))
+      (epg-delete-output-file context)
+      (if (and input-file
+              (file-exists-p input-file))
+         (delete-file input-file))
+      (epg-reset context))))
 
 ;;;###autoload
-(defun epg-start-sign (context string &optional mode)
-  "Initiate a sign operation on STRING.
+(defun epg-start-sign (context plain &optional mode)
+  "Initiate a sign operation on PLAIN.
+PLAIN is a data object.
 
 If optional 3rd argument MODE is 'clearsign, it makes a clear text signature.
 If MODE is t or 'detached, it makes a detached signature.
@@ -732,9 +805,8 @@ If you use this function, you will need to wait for the completion of
 `epg-gpg-program' by using `epg-wait-for-completion' and call
 `epg-reset' to clear a temporaly output file.
 If you are unsure, use synchronous version of this function
-`epg-sign-string' instead."
+`epg-sign-file' or `epg-sign-string' instead."
   (epg-context-set-result context nil)
-  (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
   (epg-start context
             (append (list (if (eq mode 'clearsign)
                               "--clearsign"
@@ -744,39 +816,69 @@ If you are unsure, use synchronous version of this function
                     (apply #'nconc
                            (mapcar (lambda (signer)
                                      (list "-u" signer))
-                                   (epg-context-signers context)))))
+                                   (epg-context-signers context)))
+                    (if (epg-data-file plain)
+                        (list (epg-data-file plain)))))
   (epg-wait-for-status context '("BEGIN_SIGNING"))
-  (if (eq (process-status (epg-context-process context)) 'run)
-      (process-send-string (epg-context-process context) string)))
+  (if (and (epg-data-string plain)
+          (eq (process-status (epg-context-process context)) 'run))
+      (process-send-string (epg-context-process context)
+                          (epg-data-string plain))))
+
+;;;###autoload
+(defun epg-sign-file (context plain signature &optional mode)
+  "Sign a file PLAIN and store the result to a file SIGNATURE.
+If SIGNATURE is nil, it returns the result as a string.
+If optional 3rd argument MODE is 'clearsign, it makes a clear text signature.
+If MODE is t or 'detached, it makes a detached signature.
+Otherwise, it makes a normal signature."
+  (unwind-protect
+      (progn
+       (if signature
+           (epg-context-set-output-file context signature)
+         (epg-context-set-output-file context
+                                      (epg-make-temp-file "epg-output")))
+       (epg-start-sign context (epg-make-data-from-file plain) mode)
+       (epg-wait-for-completion context)
+       (if (epg-context-result-for context 'error)
+           (error "Sign failed"))
+       (unless signature
+         (epg-read-output context)))
+    (unless signature
+      (epg-delete-output-file context))
+    (epg-reset context)))
 
 ;;;###autoload
-(defun epg-sign-string (context string &optional mode)
-  "Sign STRING and return the output as string.
+(defun epg-sign-string (context plain &optional mode)
+  "Sign a string PLAIN and return the output as string.
 If optional 3rd argument MODE is 'clearsign, it makes a clear text signature.
 If MODE is t or 'detached, it makes a detached signature.
 Otherwise, it makes a normal signature."
   (unwind-protect
       (progn
-       (epg-start-sign context string mode)
+       (epg-context-set-output-file context
+                                    (epg-make-temp-file "epg-output"))
+       (epg-start-sign context (epg-make-data-from-string plain) mode)
        (epg-wait-for-completion context)
        (if (epg-context-result-for context 'error)
            (error "Sign failed"))
        (epg-read-output context))
+    (epg-delete-output-file context)
     (epg-reset context)))
 
 ;;;###autoload
-(defun epg-start-encrypt (context string recipients
+(defun epg-start-encrypt (context plain recipients
                                  &optional sign always-trust)
-  "Initiate an encrypt operation on STRING.
+  "Initiate an encrypt operation on PLAIN.
+PLAIN is a data object.
 If RECIPIENTS is nil, it performs symmetric encryption.
 
 If you use this function, you will need to wait for the completion of
 `epg-gpg-program' by using `epg-wait-for-completion' and call
 `epg-reset' to clear a temporaly output file.
 If you are unsure, use synchronous version of this function
-`epg-encrypt-string' instead."
+`epg-encrypt-file' or `epg-encrypt-string' instead."
   (epg-context-set-result context nil)
-  (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
   (epg-start context
             (append (if always-trust '("--always-trust"))
                     (if recipients '("--encrypt") '("--symmetric"))
@@ -789,26 +891,57 @@ If you are unsure, use synchronous version of this function
                     (apply #'nconc
                            (mapcar (lambda (recipient)
                                      (list "-r" recipient))
-                                   recipients))))
+                                   recipients))
+                    (if (epg-data-file plain)
+                        (list (epg-data-file plain)))))
   (if sign
       (epg-wait-for-status context '("BEGIN_SIGNING"))
     (if (null recipients)
        (epg-wait-for-status context '("BEGIN_ENCRYPTION"))))
-  (if (eq (process-status (epg-context-process context)) 'run)
-      (process-send-string (epg-context-process context) string)))
+  (if (and (epg-data-string plain)
+          (eq (process-status (epg-context-process context)) 'run))
+      (process-send-string (epg-context-process context)
+                          (epg-data-string plain))))
+
+;;;###autoload
+(defun epg-encrypt-file (context plain recipients
+                                cipher &optional sign always-trust)
+  "Encrypt a file PLAIN and store the result to a file CIPHER.
+If CIPHER is nil, it returns the result as a string.
+If RECIPIENTS is nil, it performs symmetric encryption."
+  (unwind-protect
+      (progn
+       (if cipher
+           (epg-context-set-output-file context cipher)
+         (epg-context-set-output-file context
+                                      (epg-make-temp-file "epg-output")))
+       (epg-start-encrypt context (epg-make-data-from-file plain)
+                          recipients sign always-trust)
+       (epg-wait-for-completion context)
+       (if (epg-context-result-for context 'error)
+           (error "Encrypt failed"))
+       (unless cipher
+         (epg-read-output context)))
+    (unless cipher
+      (epg-delete-output-file context))
+    (epg-reset context)))
 
 ;;;###autoload
-(defun epg-encrypt-string (context string recipients
+(defun epg-encrypt-string (context plain recipients
                                   &optional sign always-trust)
-  "Encrypt STRING.
+  "Encrypt a string PLAIN.
 If RECIPIENTS is nil, it performs symmetric encryption."
   (unwind-protect
       (progn
-       (epg-start-encrypt context string recipients sign always-trust)
+       (epg-context-set-output-file context
+                                    (epg-make-temp-file "epg-output"))
+       (epg-start-encrypt context (epg-make-data-from-string plain)
+                          recipients sign always-trust)
        (epg-wait-for-completion context)
        (if (epg-context-result-for context 'error)
            (error "Encrypt failed"))
        (epg-read-output context))
+    (epg-delete-output-file context)
     (epg-reset context)))
 
 ;;;###autoload
@@ -838,22 +971,23 @@ If you are unsure, use synchronous version of this function
 
 ;;;###autoload
 (defun epg-start-import-keys (context keys)
-  "Initiate an import key operation.
+  "Initiate an import keys operation.
+KEYS is a data object.
 
 If you use this function, you will need to wait for the completion of
 `epg-gpg-program' by using `epg-wait-for-completion' and call
 `epg-reset' to clear a temporaly output file.
 If you are unsure, use synchronous version of this function
-`epg-import-keys' instead."
+`epg-import-keys-from-file' or `epg-import-keys-from-string' instead."
   (epg-context-set-result context nil)
   (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
-  (epg-start context (list "--import"))
-  (if (eq (process-status (epg-context-process context)) 'run)
-      (process-send-string (epg-context-process context) keys)))
-
-;;;###autoload
-(defun epg-import-keys (context keys)
-  "Add KEYS."
+  (epg-start context (append (list "--import") (epg-data-file keys)))
+  (if (and (epg-data-string keys)
+          (eq (process-status (epg-context-process context)) 'run))
+      (process-send-string (epg-context-process context)
+                          (epg-data-string keys))))
+  
+(defun epg-import-keys-1 (context keys)
   (unwind-protect
       (progn
        (epg-start-import-keys context keys)
@@ -863,6 +997,16 @@ If you are unsure, use synchronous version of this function
        (epg-read-output context))
     (epg-reset context)))
 
+;;;###autoload
+(defun epg-import-keys-from-file (context keys)
+  "Add keys from a file KEYS."
+  (epg-import-keys-1 context (epg-make-data-from-file keys)))
+
+;;;###autoload
+(defun epg-import-keys-from-string (context keys)
+  "Add keys from a string KEYS."
+  (epg-import-keys-1 context (epg-make-data-from-string keys)))
+
 (provide 'epg)
 
 ;;; epg.el ends here

diff --git a/pgg-epg.el b/pgg-epg.el
index b30038a..1c8a133 100644 (file)
--- a/pgg-epg.el
+++ b/pgg-epg.el
@@ -110,7 +110,7 @@ Verify region between START and END as the detached signature SIGNATURE."
     (epg-context-set-armor context t)
     (epg-context-set-textmode context pgg-text-mode)
     (if signature
-       (epg-verify-file context signature (buffer-substring start end))
+       (epg-verify-file context signature (buffer-substring start end) nil)
       (epg-verify-string context (buffer-substring start end)))
     (setq signature (reverse (epg-context-result-for context 'verify))
          pointer signature)