X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=epg.el;h=d73645a543f162f78c3c5a0c5a8414ff9903d05a;hb=7e34f6c54d7278efffd75772c7adad853ab879d3;hp=fb1f1830194efa2576ce78ec786bdecafbcd5293;hpb=6d964a04c19d37d2d4ec51c2ea66c8e1608c6568;p=elisp%2Fepg.git

diff --git a/epg.el b/epg.el
index fb1f183..d73645a 100644
--- a/epg.el
+++ b/epg.el
@@ -26,7 +26,8 @@
 ;;; Code:
 
 (defgroup epg ()
-  "The EasyPG Library")
+  "The EasyPG Library"
+  :group 'emacs)
 
 (defcustom epg-gpg-program "gpg"
   "The `gpg' executable."
@@ -38,7 +39,7 @@
   :group 'epg
   :type 'string)
 
-(defconst epg-version-number "0.0.0")
+(defconst epg-version-number "0.0.2")
 
 (defvar epg-user-id nil
   "GnuPG ID of your default identity.")
@@ -91,7 +92,7 @@
     (2 . "ZLIB")
     (3 . "BZIP2")))
 
-(defconst epg-invalid-recipients-alist
+(defconst epg-invalid-recipients-reason-alist
   '((0 . "No specific reason given")
     (1 . "Not Found")
     (2 . "Ambigious specification")
@@ -104,11 +105,34 @@
     (9 . "Not a secret key")
     (10 . "Key not trusted")))
 
-(defconst epg-delete-problem-alist
+(defconst epg-delete-problem-reason-alist
   '((1 . "No such key")
     (2 . "Must delete secret key first")
     (3 . "Ambigious specification")))
 
+(defconst epg-import-ok-reason-alist
+  '((0 . "Not actually changed")
+    (1 . "Entirely new key")
+    (2 . "New user IDs")
+    (4 . "New signatures")
+    (8 . "New subkeys")
+    (16 . "Contains private key")))
+
+(defconst epg-import-problem-reason-alist
+  '((0 . "No specific reason given")
+    (1 . "Invalid Certificate")
+    (2 . "Issuer Certificate missing")
+    (3 . "Certificate Chain too long")
+    (4 . "Error storing certificate")))
+
+(defconst epg-no-data-reason-alist
+  '((1 . "No armored data")
+    (2 . "Expected a packet but did not found one")
+    (3 . "Invalid packet found, this may indicate a non OpenPGP message")
+    (4 . "Signature expected but not found")))
+
+(defconst epg-unexpected-reason-alist nil)
+
 (defvar epg-key-validity-alist
   '((?o . unknown)
     (?i . invalid)
@@ -128,6 +152,11 @@
     (?c . certify)
     (?a . authentication)))
 
+(defvar epg-new-signature-type-alist
+  '((?D . detached)
+    (?C . clear)
+    (?S . normal)))
+
 (defvar epg-dn-type-alist
   '(("1.2.840.113549.1.9.1" . "EMail")
     ("2.5.4.12" . "T")
@@ -145,279 +174,567 @@
 
 (defun epg-make-data-from-file (file)
   "Make a data object from FILE."
-  (vector file nil))
+  (cons 'epg-data (vector file nil)))
 
 (defun epg-make-data-from-string (string)
   "Make a data object from STRING."
-  (vector nil string))
+  (cons 'epg-data (vector nil string)))
 
 (defun epg-data-file (data)
   "Return the file of DATA."
-  (aref data 0))
+  (unless (eq (car data) 'epg-data)
+    (signal 'wrong-type-argument (list 'epg-data-p data)))
+  (aref (cdr data) 0))
 
 (defun epg-data-string (data)
   "Return the string of DATA."
-  (aref data 1))
+  (unless (eq (car data) 'epg-data)
+    (signal 'wrong-type-argument (list 'epg-data-p data)))
+  (aref (cdr data) 1))
 
 (defun epg-make-context (&optional protocol armor textmode include-certs
 				   cipher-algorithm digest-algorithm
 				   compress-algorithm)
   "Return a context object."
-  (vector protocol armor textmode include-certs
-	  cipher-algorithm digest-algorithm compress-algorithm
-	  #'epg-passphrase-callback-function
-	  #'epg-progress-callback-function
-	  nil nil nil nil))
+  (cons 'epg-context
+	(vector (or protocol 'OpenPGP) armor textmode include-certs
+		cipher-algorithm digest-algorithm compress-algorithm
+		#'epg-passphrase-callback-function
+		#'epg-progress-callback-function
+		nil nil nil nil nil)))
 
 (defun epg-context-protocol (context)
   "Return the protocol used within CONTEXT."
-  (aref context 0))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 0))
 
 (defun epg-context-armor (context)
   "Return t if the output shouled be ASCII armored in CONTEXT."
-  (aref context 1))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 1))
 
 (defun epg-context-textmode (context)
   "Return t if canonical text mode should be used in CONTEXT."
-  (aref context 2))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 2))
 
 (defun epg-context-include-certs (context)
   "Return how many certificates should be included in an S/MIME signed
 message."
-  (aref context 3))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 3))
 
 (defun epg-context-cipher-algorithm (context)
   "Return the cipher algorithm in CONTEXT."
-  (aref context 4))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 4))
 
 (defun epg-context-digest-algorithm (context)
   "Return the digest algorithm in CONTEXT."
-  (aref context 5))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 5))
 
 (defun epg-context-compress-algorithm (context)
   "Return the compress algorithm in CONTEXT."
-  (aref context 6))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 6))
 
 (defun epg-context-passphrase-callback (context)
   "Return the function used to query passphrase."
-  (aref context 7))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 7))
 
 (defun epg-context-progress-callback (context)
   "Return the function which handles progress update."
-  (aref context 8))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 8))
 
 (defun epg-context-signers (context)
   "Return the list of key-id for singning."
-  (aref context 9))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 9))
 
 (defun epg-context-process (context)
   "Return the process object of `epg-gpg-program'.
 This function is for internal use only."
-  (aref context 10))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 10))
 
 (defun epg-context-output-file (context)
   "Return the output file of `epg-gpg-program'.
 This function is for internal use only."
-  (aref context 11))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 11))
 
 (defun epg-context-result (context)
   "Return the result of the previous cryptographic operation."
-  (aref context 12))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 12))
+
+(defun epg-context-operation (context)
+  "Return the name of the current cryptographic operation."
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aref (cdr context) 13))
 
 (defun epg-context-set-protocol (context protocol)
   "Set the protocol used within CONTEXT."
-  (aset context 0 protocol))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 0 protocol))
 
 (defun epg-context-set-armor (context armor)
   "Specify if the output shouled be ASCII armored in CONTEXT."
-  (aset context 1 armor))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 1 armor))
 
 (defun epg-context-set-textmode (context textmode)
   "Specify if canonical text mode should be used in CONTEXT."
-  (aset context 2 textmode))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 2 textmode))
 
 (defun epg-context-set-include-certs (context include-certs)
  "Set how many certificates should be included in an S/MIME signed message."
-  (aset context 3 include-certs))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 3 include-certs))
 
 (defun epg-context-set-cipher-algorithm (context cipher-algorithm)
  "Set the cipher algorithm in CONTEXT."
-  (aset context 4 cipher-algorithm))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 4 cipher-algorithm))
 
 (defun epg-context-set-digest-algorithm (context digest-algorithm)
  "Set the digest algorithm in CONTEXT."
-  (aset context 5 digest-algorithm))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 5 digest-algorithm))
 
 (defun epg-context-set-compress-algorithm (context compress-algorithm)
  "Set the compress algorithm in CONTEXT."
-  (aset context 6 compress-algorithm))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 6 compress-algorithm))
 
 (defun epg-context-set-passphrase-callback (context
 						 passphrase-callback)
   "Set the function used to query passphrase."
-  (aset context 7 passphrase-callback))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 7 passphrase-callback))
 
 (defun epg-context-set-progress-callback (context progress-callback)
   "Set the function which handles progress update."
-  (aset context 8 progress-callback))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 8 progress-callback))
 
 (defun epg-context-set-signers (context signers)
  "Set the list of key-id for singning."
-  (aset context 9 signers))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 9 signers))
 
 (defun epg-context-set-process (context process)
   "Set the process object of `epg-gpg-program'.
 This function is for internal use only."
-  (aset context 10 process))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 10 process))
 
 (defun epg-context-set-output-file (context output-file)
   "Set the output file of `epg-gpg-program'.
 This function is for internal use only."
-  (aset context 11 output-file))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 11 output-file))
 
 (defun epg-context-set-result (context result)
   "Set the result of the previous cryptographic operation."
-  (aset context 12 result))
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 12 result))
 
-(defun epg-make-signature (status key-id user-id)
+(defun epg-context-set-operation (context operation)
+  "Set the name of the current cryptographic operation."
+  (unless (eq (car context) 'epg-context)
+    (signal 'wrong-type-argument (list 'epg-context-p context)))
+  (aset (cdr context) 13 operation))
+
+(defun epg-make-signature (status &optional key-id)
   "Return a signature object."
-  (vector status key-id user-id nil nil))
+  (cons 'epg-signature (vector status key-id nil nil nil nil nil nil nil nil)))
 
 (defun epg-signature-status (signature)
   "Return the status code of SIGNATURE."
-  (aref signature 0))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 0))
 
 (defun epg-signature-key-id (signature)
   "Return the key-id of SIGNATURE."
-  (aref signature 1))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 1))
 
-(defun epg-signature-user-id (signature)
-  "Return the user-id of SIGNATURE."
-  (aref signature 2))
-  
 (defun epg-signature-validity (signature)
   "Return the validity of SIGNATURE."
-  (aref signature 3))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 2))
 
 (defun epg-signature-fingerprint (signature)
   "Return the fingerprint of SIGNATURE."
-  (aref signature 4))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 3))
+
+(defun epg-signature-creation-time (signature)
+  "Return the creation time of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 4))
+
+(defun epg-signature-expiration-time (signature)
+  "Return the expiration time of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 5))
+
+(defun epg-signature-pubkey-algorithm (signature)
+  "Return the public key algorithm of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 6))
+
+(defun epg-signature-digest-algorithm (signature)
+  "Return the digest algorithm of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 7))
+
+(defun epg-signature-class (signature)
+  "Return the class of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 8))
+
+(defun epg-signature-version (signature)
+  "Return the version of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aref (cdr signature) 9))
 
 (defun epg-signature-set-status (signature status)
  "Set the status code of SIGNATURE."
-  (aset signature 0 status))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 0 status))
 
 (defun epg-signature-set-key-id (signature key-id)
  "Set the key-id of SIGNATURE."
-  (aset signature 1 key-id))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 1 key-id))
 
-(defun epg-signature-set-user-id (signature user-id)
- "Set the user-id of SIGNATURE."
-  (aset signature 2 user-id))
-  
 (defun epg-signature-set-validity (signature validity)
  "Set the validity of SIGNATURE."
-  (aset signature 3 validity))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 2 validity))
 
 (defun epg-signature-set-fingerprint (signature fingerprint)
  "Set the fingerprint of SIGNATURE."
-  (aset signature 4 fingerprint))
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 3 fingerprint))
+
+(defun epg-signature-set-creation-time (signature creation-time)
+  "Set the creation time of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 4 creation-time))
+
+(defun epg-signature-set-expiration-time (signature expiration-time)
+  "Set the expiration time of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 5 expiration-time))
+
+(defun epg-signature-set-pubkey-algorithm (signature pubkey-algorithm)
+  "Set the public key algorithm of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 6 pubkey-algorithm))
+
+(defun epg-signature-set-digest-algorithm (signature digest-algorithm)
+  "Set the digest algorithm of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 7 digest-algorithm))
+
+(defun epg-signature-set-class (signature class)
+  "Set the class of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 8 class))
+
+(defun epg-signature-set-version (signature version)
+  "Set the version of SIGNATURE."
+  (unless (eq (car signature) 'epg-signature)
+    (signal 'wrong-type-argument (list 'epg-signature-p signature)))
+  (aset (cdr signature) 9 version))
+
+(defun epg-make-new-signature (type pubkey-algorithm digest-algorithm
+				    class creation-time fingerprint)
+  "Return a new signature object."
+  (cons 'epg-new-signature (vector type pubkey-algorithm digest-algorithm
+				   class creation-time fingerprint)))
+
+(defun epg-new-signature-type (new-signature)
+  "Return the type of NEW-SIGNATURE."
+  (unless (eq (car new-signature) 'epg-new-signature)
+    (signal 'wrong-type-argument (list 'epg-new-signature-p new-signature)))
+  (aref (cdr new-signature) 0))
+
+(defun epg-new-signature-pubkey-algorithm (new-signature)
+  "Return the public key algorithm of NEW-SIGNATURE."
+  (unless (eq (car new-signature) 'epg-new-signature)
+    (signal 'wrong-type-argument (list 'epg-new-signature-p new-signature)))
+  (aref (cdr new-signature) 1))
+
+(defun epg-new-signature-digest-algorithm (new-signature)
+  "Return the digest algorithm of NEW-SIGNATURE."
+  (unless (eq (car new-signature) 'epg-new-signature)
+    (signal 'wrong-type-argument (list 'epg-new-signature-p new-signature)))
+  (aref (cdr new-signature) 2))
+
+(defun epg-new-signature-class (new-signature)
+  "Return the class of NEW-SIGNATURE."
+  (unless (eq (car new-signature) 'epg-new-signature)
+    (signal 'wrong-type-argument (list 'epg-new-signature-p new-signature)))
+  (aref (cdr new-signature) 3))
+
+(defun epg-new-signature-creation-time (new-signature)
+  "Return the creation time of NEW-SIGNATURE."
+  (unless (eq (car new-signature) 'epg-new-signature)
+    (signal 'wrong-type-argument (list 'epg-new-signature-p new-signature)))
+  (aref (cdr new-signature) 4))
+
+(defun epg-new-signature-fingerprint (new-signature)
+  "Return the fingerprint of NEW-SIGNATURE."
+  (unless (eq (car new-signature) 'epg-new-signature)
+    (signal 'wrong-type-argument (list 'epg-new-signature-p new-signature)))
+  (aref (cdr new-signature) 5))
 
 (defun epg-make-key (owner-trust)
   "Return a key object."
-  (vector owner-trust nil nil))
+  (cons 'epg-key (vector owner-trust nil nil)))
 
 (defun epg-key-owner-trust (key)
   "Return the owner trust of KEY."
-  (aref key 0))
+  (unless (eq (car key) 'epg-key)
+    (signal 'wrong-type-argument (list 'epg-key-p key)))
+  (aref (cdr key) 0))
 
 (defun epg-key-sub-key-list (key)
   "Return the sub key list of KEY."
-  (aref key 1))
+  (unless (eq (car key) 'epg-key)
+    (signal 'wrong-type-argument (list 'epg-key-p key)))
+  (aref (cdr key) 1))
 
 (defun epg-key-user-id-list (key)
   "Return the user ID list of KEY."
-  (aref key 2))
+  (unless (eq (car key) 'epg-key)
+    (signal 'wrong-type-argument (list 'epg-key-p key)))
+  (aref (cdr key) 2))
 
 (defun epg-key-set-sub-key-list (key sub-key-list)
   "Set the sub key list of KEY."
-  (aset key 1 sub-key-list))
+  (unless (eq (car key) 'epg-key)
+    (signal 'wrong-type-argument (list 'epg-key-p key)))
+  (aset (cdr key) 1 sub-key-list))
 
 (defun epg-key-set-user-id-list (key user-id-list)
   "Set the user ID list of KEY."
-  (aset key 2 user-id-list))
+  (unless (eq (car key) 'epg-key)
+    (signal 'wrong-type-argument (list 'epg-key-p key)))
+  (aset (cdr key) 2 user-id-list))
 
-(defun epg-make-sub-key (validity capability secret algorithm length id
+(defun epg-make-sub-key (validity capability secret-p algorithm length id
 				  creation-time expiration-time)
   "Return a sub key object."
-  (vector validity capability secret algorithm length id creation-time
-	  expiration-time nil))
+  (cons 'epg-sub-key
+	(vector validity capability secret-p algorithm length id creation-time
+		expiration-time nil)))
 
 (defun epg-sub-key-validity (sub-key)
   "Return the validity of SUB-KEY."
-  (aref sub-key 0))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 0))
 
 (defun epg-sub-key-capability (sub-key)
   "Return the capability of SUB-KEY."
-  (aref sub-key 1))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 1))
 
-(defun epg-sub-key-secret (sub-key)
+(defun epg-sub-key-secret-p (sub-key)
   "Return non-nil if SUB-KEY is a secret key."
-  (aref sub-key 2))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 2))
 
 (defun epg-sub-key-algorithm (sub-key)
   "Return the algorithm of SUB-KEY."
-  (aref sub-key 3))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 3))
 
 (defun epg-sub-key-length (sub-key)
   "Return the length of SUB-KEY."
-  (aref sub-key 4))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 4))
 
 (defun epg-sub-key-id (sub-key)
   "Return the ID of SUB-KEY."
-  (aref sub-key 5))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 5))
 
 (defun epg-sub-key-creation-time (sub-key)
   "Return the creation time of SUB-KEY."
-  (aref sub-key 6))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 6))
 
 (defun epg-sub-key-expiration-time (sub-key)
   "Return the expiration time of SUB-KEY."
-  (aref sub-key 7))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 7))
 
 (defun epg-sub-key-fingerprint (sub-key)
   "Return the fingerprint of SUB-KEY."
-  (aref sub-key 8))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aref (cdr sub-key) 8))
 
 (defun epg-sub-key-set-fingerprint (sub-key fingerprint)
   "Set the fingerprint of SUB-KEY.
 This function is for internal use only."
-  (aset sub-key 8 fingerprint))
+  (unless (eq (car sub-key) 'epg-sub-key)
+    (signal 'wrong-type-argument (list 'epg-sub-key-p sub-key)))
+  (aset (cdr sub-key) 8 fingerprint))
 
-(defun epg-make-user-id (validity name)
+(defun epg-make-user-id (validity string)
   "Return a user ID object."
-  (vector validity name nil))
+  (cons 'epg-user-id (vector validity string nil)))
 
 (defun epg-user-id-validity (user-id)
   "Return the validity of USER-ID."
-  (aref user-id 0))
+  (unless (eq (car user-id) 'epg-user-id)
+    (signal 'wrong-type-argument (list 'epg-user-id-p user-id)))
+  (aref (cdr user-id) 0))
 
-(defun epg-user-id-name (user-id)
+(defun epg-user-id-string (user-id)
   "Return the name of USER-ID."
-  (aref user-id 1))
+  (unless (eq (car user-id) 'epg-user-id)
+    (signal 'wrong-type-argument (list 'epg-user-id-p user-id)))
+  (aref (cdr user-id) 1))
 
 (defun epg-user-id-signature-list (user-id)
   "Return the signature list of USER-ID."
-  (aref user-id 2))
+  (unless (eq (car user-id) 'epg-user-id)
+    (signal 'wrong-type-argument (list 'epg-user-id-p user-id)))
+  (aref (cdr user-id) 2))
 
 (defun epg-user-id-set-signature-list (user-id signature-list)
   "Set the signature list of USER-ID."
-  (aset user-id 2 signature-list))
+  (unless (eq (car user-id) 'epg-user-id)
+    (signal 'wrong-type-argument (list 'epg-user-id-p user-id)))
+  (aset (cdr user-id) 2 signature-list))
+
+(defun epg-make-key-signature (validity pubkey-algorithm key-id creation-time
+					expiration-time	user-id class
+					exportable-p)
+  "Return a key signature object."
+  (cons 'epg-key-signature
+	(vector validity pubkey-algorithm key-id creation-time expiration-time
+		user-id class exportable-p)))
+
+(defun epg-key-signature-validity (key-signature)
+  "Return the validity of KEY-SIGNATURE."
+  (unless (eq (car key-signature) 'epg-key-signature)
+    (signal 'wrong-type-argument (list 'epg-key-signature-p key-signature)))
+  (aref (cdr key-signature) 0))
+
+(defun epg-key-signature-pubkey-algorithm (key-signature)
+  "Return the public key algorithm of KEY-SIGNATURE."
+  (unless (eq (car key-signature) 'epg-key-signature)
+    (signal 'wrong-type-argument (list 'epg-key-signature-p key-signature)))
+  (aref (cdr key-signature) 1))
+
+(defun epg-key-signature-key-id (key-signature)
+  "Return the key-id of KEY-SIGNATURE."
+  (unless (eq (car key-signature) 'epg-key-signature)
+    (signal 'wrong-type-argument (list 'epg-key-signature-p key-signature)))
+  (aref (cdr key-signature) 2))
+
+(defun epg-key-signature-creation-time (key-signature)
+  "Return the creation time of KEY-SIGNATURE."
+  (unless (eq (car key-signature) 'epg-key-signature)
+    (signal 'wrong-type-argument (list 'epg-key-signature-p key-signature)))
+  (aref (cdr key-signature) 3))
+
+(defun epg-key-signature-expiration-time (key-signature)
+  "Return the expiration time of KEY-SIGNATURE."
+  (unless (eq (car key-signature) 'epg-key-signature)
+    (signal 'wrong-type-argument (list 'epg-key-signature-p key-signature)))
+  (aref (cdr key-signature) 4))
+
+(defun epg-key-signature-user-id (key-signature)
+  "Return the user-id of KEY-SIGNATURE."
+  (unless (eq (car key-signature) 'epg-key-signature)
+    (signal 'wrong-type-argument (list 'epg-key-signature-p key-signature)))
+  (aref (cdr key-signature) 5))
+
+(defun epg-key-signature-class (key-signature)
+  "Return the class of KEY-SIGNATURE."
+  (unless (eq (car key-signature) 'epg-key-signature)
+    (signal 'wrong-type-argument (list 'epg-key-signature-p key-signature)))
+  (aref (cdr key-signature) 6))
+
+(defun epg-key-signature-exportable-p (key-signature)
+  "Return t if KEY-SIGNATURE is exportable."
+  (unless (eq (car key-signature) 'epg-key-signature)
+    (signal 'wrong-type-argument (list 'epg-key-signature-p key-signature)))
+  (aref (cdr key-signature) 7))
 
 (defun epg-context-result-for (context name)
+  "Return the result of CONTEXT associated with NAME."
   (cdr (assq name (epg-context-result context))))
 
 (defun epg-context-set-result-for (context name value)
+  "Set the result of CONTEXT associated with NAME to VALUE."
   (let* ((result (epg-context-result context))
 	 (entry (assq name result)))
     (if entry
@@ -425,20 +742,64 @@ This function is for internal use only."
       (epg-context-set-result context (cons (cons name value) result)))))
 
 (defun epg-signature-to-string (signature)
-  (format "%s signature from %s %s%s"
-	  (capitalize (symbol-name (epg-signature-status signature)))
-	  (epg-signature-key-id signature)
-	  (epg-signature-user-id signature)
-	  (if (epg-signature-validity signature)
-	      (format " (trust %s)"
-		      (epg-signature-validity signature))
-	    "")))
+  "Convert SIGNATURE to a human readable string."
+  (let ((user-id (cdr (assoc (epg-signature-key-id signature)
+			     epg-user-id-alist))))
+    (concat
+     (cond ((eq (epg-signature-status signature) 'good)
+	    "Good signature from ")
+	   ((eq (epg-signature-status signature) 'bad)
+	    "Bad signature from ")
+	   ((eq (epg-signature-status signature) 'expired)
+	    "Expired signature from ")
+	   ((eq (epg-signature-status signature) 'expired-key)
+	    "Signature made by expired key ")
+	   ((eq (epg-signature-status signature) 'revoked-key)
+	    "Signature made by revoked key ")
+	   ((eq (epg-signature-status signature) 'no-pubkey)
+	    "No public key for "))
+     (epg-signature-key-id signature)
+     " "
+     (if user-id
+	 (concat (if (stringp user-id)
+		     user-id
+		   (epg-decode-dn user-id))
+		 " ")
+       "")
+     (if (epg-signature-validity signature)
+	 (format "(trust %s)"  (epg-signature-validity signature))
+       ""))))
 
 (defun epg-verify-result-to-string (verify-result)
+  "Convert VERIFY-RESULT to a human readable string."
   (mapconcat #'epg-signature-to-string verify-result "\n"))
 
-(defun epg-start (context args)
+(defun epg-new-signature-to-string (new-signature)
+  "Convert NEW-SIGNATURE to a human readable string."
+  (concat
+   (cond ((eq (epg-new-signature-type new-signature) 'detached)
+	  "Detached signature ")
+	 ((eq (epg-new-signature-type new-signature) 'clear)
+	  "Clear text signature ")
+	 (t
+	  "Signature "))
+   (cdr (assq (epg-new-signature-pubkey-algorithm new-signature)
+	      epg-pubkey-algorithm-alist))
+   "/"
+   (cdr (assq (epg-new-signature-digest-algorithm new-signature)
+	      epg-digest-algorithm-alist))
+   " "
+   (format "%02X " (epg-new-signature-class new-signature))
+   (epg-new-signature-fingerprint new-signature)))
+
+(defun epg--start (context args)
   "Start `epg-gpg-program' in a subprocess with given ARGS."
+  (if (and (epg-context-process context)
+	   (eq (process-status (epg-context-process context)) 'run))
+      (error "%s is already running in this context"
+	     (if (eq (epg-context-protocol context) 'CMS)
+		 epg-gpgsm-program
+	       epg-gpg-program)))
   (let* ((args (append (list "--no-tty"
 			     "--status-fd" "1"
 			     "--yes")
@@ -484,11 +845,10 @@ This function is for internal use only."
 			 epg-gpg-program)
 		       args)))
       (set-default-file-modes orig-mode))
-    (set-process-filter process #'epg-process-filter)
-    (set-process-sentinel process #'epg-process-sentinel)
+    (set-process-filter process #'epg--process-filter)
     (epg-context-set-process context process)))
 
-(defun epg-process-filter (process input)
+(defun epg--process-filter (process input)
   (if epg-debug
       (save-excursion
 	(unless epg-debug-buffer
@@ -508,42 +868,27 @@ This function is for internal use only."
 	    (if (looking-at "\\[GNUPG:] \\([A-Z_]+\\) ?\\(.*\\)")
 		(let* ((status (match-string 1))
 		       (string (match-string 2))
-		       (symbol (intern-soft (concat "epg-status-" status))))
+		       (symbol (intern-soft (concat "epg--status-" status))))
 		  (if (member status epg-pending-status-list)
 		      (setq epg-pending-status-list nil))
 		  (if (and symbol
 			   (fboundp symbol))
-		      (funcall symbol process string)))))
+		      (funcall symbol epg-context string)))))
 	  (forward-line))
 	(setq epg-read-point (point)))))
 
-(defun epg-process-sentinel (process status)
-  (if (and (buffer-live-p (process-buffer process))
-	   (not (equal status "finished\n")))
-      (save-excursion
-	(set-buffer (process-buffer process))
-	;; gpg process exited abnormally, but we have not received an
-	;; error response from it.  Set it here.
-	(unless (epg-context-result-for epg-context 'error)
-	  (if (string-match "\\`exited abnormally with code \\(.*\\)\n" status)
-	      (epg-context-set-result-for
-	       epg-context 'error
-	       (list (cons 'exit (string-to-number (match-string 1 status)))))
-	    (epg-context-set-result-for epg-context 'error
-				    (list (cons 'signal status))))))))
-
 (defun epg-read-output (context)
+  "Read the output file CONTEXT and return the content as a string."
   (with-temp-buffer
     (if (fboundp 'set-buffer-multibyte)
 	(set-buffer-multibyte nil))
     (if (file-exists-p (epg-context-output-file context))
-	(let ((coding-system-for-read (if (epg-context-textmode context)
-					  'raw-text
-					'binary)))
+	(let ((coding-system-for-read 'binary))
 	  (insert-file-contents (epg-context-output-file context))
 	  (buffer-string)))))
 
 (defun epg-wait-for-status (context status-list)
+  "Wait until one of elements in STATUS-LIST arrives."
   (with-current-buffer (process-buffer (epg-context-process context))
     (setq epg-pending-status-list status-list)
     (while (and (eq (process-status (epg-context-process context)) 'run)
@@ -551,27 +896,24 @@ This function is for internal use only."
       (accept-process-output (epg-context-process context) 1))))
 
 (defun epg-wait-for-completion (context)
+  "Wait until the `epg-gpg-program' process completes."
   (while (eq (process-status (epg-context-process context)) 'run)
-    ;; We can't use accept-process-output instead of sit-for here
-    ;; because it may cause an interrupt during the sentinel execution.
-    (sit-for 0.1)))
-
-(defun epg-flush (context)
-  (if (eq (process-status (epg-context-process context)) 'run)
-      (process-send-eof (epg-context-process context))))
+    (accept-process-output (epg-context-process context) 1)))
 
 (defun epg-reset (context)
+  "Reset the CONTEXT."
   (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))
 
 (defun epg-delete-output-file (context)
+  "Delete the output file of 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)
+(defun epg--status-USERID_HINT (context string)
   (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
       (let* ((key-id (match-string 1 string))
 	     (user-id (match-string 2 string))
@@ -581,17 +923,17 @@ This function is for internal use only."
 	  (setq epg-user-id-alist (cons (cons key-id user-id)
 					epg-user-id-alist))))))
 
-(defun epg-status-NEED_PASSPHRASE (process string)
+(defun epg--status-NEED_PASSPHRASE (context string)
   (if (string-match "\\`\\([^ ]+\\)" string)
       (setq epg-key-id (match-string 1 string))))
 
-(defun epg-status-NEED_PASSPHRASE_SYM (process string)
+(defun epg--status-NEED_PASSPHRASE_SYM (context string)
   (setq epg-key-id 'SYM))
 
-(defun epg-status-NEED_PASSPHRASE_PIN (process string)
+(defun epg--status-NEED_PASSPHRASE_PIN (context string)
   (setq epg-key-id 'PIN))
 
-(defun epg-status-GET_HIDDEN (process string)
+(defun epg--status-GET_HIDDEN (context string)
   (if (and epg-key-id
 	   (string-match "\\`passphrase\\." string))
       (let (inhibit-quit
@@ -602,267 +944,347 @@ This function is for internal use only."
 		(progn
 		  (setq passphrase
 			(funcall
-			 (if (consp (epg-context-passphrase-callback
-				     epg-context))
-			     (car (epg-context-passphrase-callback
-				   epg-context))
-			   (epg-context-passphrase-callback epg-context))
-			 epg-context
+			 (if (consp (epg-context-passphrase-callback context))
+			     (car (epg-context-passphrase-callback context))
+			   (epg-context-passphrase-callback context))
+			 context
 			 epg-key-id
-			 (if (consp (epg-context-passphrase-callback
-				     epg-context))
-			     (cdr (epg-context-passphrase-callback
-				   epg-context)))))
+			 (if (consp (epg-context-passphrase-callback context))
+			     (cdr (epg-context-passphrase-callback context)))))
 		  (when passphrase
 		    (setq passphrase-with-new-line (concat passphrase "\n"))
 		    (fillarray passphrase 0)
 		    (setq passphrase nil)
-		    (process-send-string process passphrase-with-new-line)))
+		    (process-send-string (epg-context-process context)
+					 passphrase-with-new-line)))
 	      (quit
 	       (epg-context-set-result-for
-		epg-context 'error
-		(cons 'quit
-		      (epg-context-result-for epg-context 'error)))
-	       (delete-process process)))
+		context 'error
+		(cons '(quit)
+		      (epg-context-result-for context 'error)))
+	       (delete-process (epg-context-process context))))
 	  (if passphrase
 	      (fillarray passphrase 0))
 	  (if passphrase-with-new-line
 	      (fillarray passphrase-with-new-line 0))))))
 
-(defun epg-status-GET_BOOL (process string)
+(defun epg--status-GET_BOOL (context string)
   (let ((entry (assoc string epg-prompt-alist))
 	inhibit-quit)
     (condition-case nil
       (if (y-or-n-p (if entry (cdr entry) (concat string "? ")))
-	  (process-send-string process "y\n")
-	(process-send-string process "n\n"))
+	  (process-send-string (epg-context-process context) "y\n")
+	(process-send-string (epg-context-process context) "n\n"))
       (quit
        (epg-context-set-result-for
-	epg-context 'error
-	(cons 'quit
-	      (epg-context-result-for epg-context 'error)))
-       (delete-process process)))))
+	context 'error
+	(cons '(quit)
+	      (epg-context-result-for context 'error)))
+       (delete-process (epg-context-process context))))))
 
-(defun epg-status-GET_LINE (process string)
+(defun epg--status-GET_LINE (context string)
   (let ((entry (assoc string epg-prompt-alist))
 	inhibit-quit)
     (condition-case nil
-	(process-send-string
-	 process
-	 (concat (read-string (if entry (cdr entry) (concat string ": ")))
-		 "\n"))
+	(process-send-string (epg-context-process context)
+			     (concat (read-string
+				      (if entry
+					  (cdr entry)
+					(concat string ": ")))
+				     "\n"))
       (quit
        (epg-context-set-result-for
-	epg-context 'error
-	(cons 'quit
-	      (epg-context-result-for epg-context 'error)))
-       (delete-process process)))))
+	context 'error
+	(cons '(quit)
+	      (epg-context-result-for context 'error)))
+       (delete-process (epg-context-process context))))))
 
-(defun epg-status-GOODSIG (process string)
-  (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
-      (epg-context-set-result-for
-       epg-context
-       'verify
-       (cons (epg-make-signature
-	      'good
-	      (match-string 1 string)
-	      (if (eq (epg-context-protocol epg-context) 'CMS)
-		  (condition-case nil
-		      (epg-dn-from-string (match-string 2 string))
-		    (error (match-string 2 string)))
-		(match-string 2 string)))
-	     (epg-context-result-for epg-context 'verify)))))
-
-(defun epg-status-EXPSIG (process string)
+(defun epg--status-*SIG (context status string)
   (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
-      (epg-context-set-result-for
-       epg-context
-       'verify
-       (cons (epg-make-signature
-	      'expired
-	      (match-string 1 string)
-	      (if (eq (epg-context-protocol epg-context) 'CMS)
-		  (condition-case nil
-		      (epg-dn-from-string (match-string 2 string))
-		    (error (match-string 2 string)))
-		(match-string 2 string)))
-	     (epg-context-result-for epg-context 'verify)))))
-
-(defun epg-status-EXPKEYSIG (process string)
-  (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
-      (epg-context-set-result-for
-       epg-context
-       'verify
-       (cons (epg-make-signature
-	      'expired-key
-	      (match-string 1 string)
-	      (if (eq (epg-context-protocol epg-context) 'CMS)
-		  (condition-case nil
-		      (epg-dn-from-string (match-string 2 string))
-		    (error (match-string 2 string)))
-		(match-string 2 string)))
-	     (epg-context-result-for epg-context 'verify)))))
-
-(defun epg-status-REVKEYSIG (process string)
-  (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
-      (epg-context-set-result-for
-       epg-context
-       'verify
-       (cons (epg-make-signature
-	      'revoked-key
-	      (match-string 1 string)
-	      (if (eq (epg-context-protocol epg-context) 'CMS)
-		  (condition-case nil
-		      (epg-dn-from-string (match-string 2 string))
-		    (error (match-string 2 string)))
-		(match-string 2 string)))
-	     (epg-context-result-for epg-context 'verify)))))
-
-(defun epg-status-BADSIG (process string)
-  (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
-      (epg-context-set-result-for
-       epg-context
-       'verify
-       (cons (epg-make-signature
-	      'bad
-	      (match-string 1 string)
-	      (if (eq (epg-context-protocol epg-context) 'CMS)
-		  (condition-case nil
-		      (epg-dn-from-string (match-string 2 string))
-		    (error (match-string 2 string)))
-		(match-string 2 string)))
-	     (epg-context-result-for epg-context 'verify)))))
-
-(defun epg-status-VALIDSIG (process string)
-  (let ((signature (car (epg-context-result-for epg-context 'verify))))
-    (if (and signature
-	     (eq (epg-signature-status signature) 'good)
-	     (string-match "\\`\\([^ ]+\\) " string))
-	(epg-signature-set-fingerprint signature (match-string 1 string)))))
+      (let* ((key-id (match-string 1 string))
+	     (user-id (match-string 2 string))
+	     (entry (assoc key-id epg-user-id-alist)))
+	(epg-context-set-result-for
+	 context
+	 'verify
+	 (cons (epg-make-signature status key-id)
+	       (epg-context-result-for context 'verify)))
+	(if (eq (epg-context-protocol context) 'CMS)
+	    (condition-case nil
+		(setq user-id (epg-dn-from-string user-id))
+	      (error)))
+	(if entry
+	    (setcdr entry user-id)
+	  (setq epg-user-id-alist
+		(cons (cons key-id user-id) epg-user-id-alist))))
+    (epg-context-set-result-for
+     context
+     'verify
+     (cons (epg-make-signature status)
+	   (epg-context-result-for context 'verify)))))
 
-(defun epg-status-TRUST_UNDEFINED (process string)
-  (let ((signature (car (epg-context-result-for epg-context 'verify))))
+(defun epg--status-GOODSIG (context string)
+  (epg--status-*SIG context 'good string))
+
+(defun epg--status-EXPSIG (context string)
+  (epg--status-*SIG context 'expired string))
+
+(defun epg--status-EXPKEYSIG (context string)
+  (epg--status-*SIG context 'expired-key string))
+
+(defun epg--status-REVKEYSIG (context string)
+  (epg--status-*SIG context 'revoked-key string))
+
+(defun epg--status-BADSIG (context string)
+  (epg--status-*SIG context 'bad string))
+
+(defun epg--status-NO_PUBKEY (context string)
+  (let ((signature (car (epg-context-result-for context 'verify))))
+    (if (and signature
+	     (eq (epg-signature-status signature) 'error)
+	     (equal (epg-signature-key-id signature) string))
+	(epg-signature-set-status signature 'no-pubkey))))
+
+(defun epg--time-from-seconds (seconds)
+  (let ((number-seconds (string-to-number (concat seconds ".0"))))
+    (cons (floor (/ number-seconds 65536))
+	  (floor (mod number-seconds 65536)))))
+
+(defun epg--status-ERRSIG (context string)
+  (if (string-match "\\`\\([^ ]+\\) \\([0-9]+\\) \\([0-9]+\\) \
+\\([0-9A-Fa-f][0-9A-Fa-f]\\) \\([^ ]+\\) \\([0-9]+\\)"
+		    string)
+      (let ((signature (epg-make-signature 'error)))
+	(epg-context-set-result-for context 'verify (list signature))
+	(epg-signature-set-key-id
+	 signature
+	 (match-string 1 string))
+	(epg-signature-set-pubkey-algorithm
+	 signature
+	 (string-to-number (match-string 2 string)))
+	(epg-signature-set-digest-algorithm
+	 signature
+	 (string-to-number (match-string 3 string)))
+	(epg-signature-set-class
+	 signature
+	 (string-to-number (match-string 4 string) 16))
+	(epg-signature-set-creation-time
+	 signature
+	 (epg--time-from-seconds (match-string 5 string))))))
+
+(defun epg--status-VALIDSIG (context string)
+  (let ((signature (car (epg-context-result-for context 'verify))))
+    (when (and signature
+	       (eq (epg-signature-status signature) 'good)
+	       (string-match "\\`\\([^ ]+\\) [^ ]+ \\([^ ]+\\) \\([^ ]+\\) \
+\\([0-9]+\\) [^ ]+ \\([0-9]+\\) \\([0-9]+\\) \\([0-9A-Fa-f][0-9A-Fa-f]\\) \
+\\(.*\\)"
+			   string))
+      (epg-signature-set-fingerprint
+       signature
+       (match-string 1 string))
+      (epg-signature-set-creation-time
+       signature
+       (epg--time-from-seconds (match-string 2 string)))
+      (epg-signature-set-expiration-time
+       signature
+       (epg--time-from-seconds (match-string 3 string)))
+      (epg-signature-set-version
+       signature
+       (string-to-number (match-string 4 string)))
+      (epg-signature-set-pubkey-algorithm
+       signature 
+       (string-to-number (match-string 5 string)))
+      (epg-signature-set-digest-algorithm
+       signature
+       (string-to-number (match-string 6 string)))
+      (epg-signature-set-class
+       signature
+       (string-to-number (match-string 7 string) 16)))))
+
+(defun epg--status-TRUST_UNDEFINED (context string)
+  (let ((signature (car (epg-context-result-for context 'verify))))
     (if (and signature
 	     (eq (epg-signature-status signature) 'good))
 	(epg-signature-set-validity signature 'undefined))))
 
-(defun epg-status-TRUST_NEVER (process string)
-  (let ((signature (car (epg-context-result-for epg-context 'verify))))
+(defun epg--status-TRUST_NEVER (context string)
+  (let ((signature (car (epg-context-result-for context 'verify))))
     (if (and signature
 	     (eq (epg-signature-status signature) 'good))
 	(epg-signature-set-validity signature 'never))))
 
-(defun epg-status-TRUST_MARGINAL (process string)
-  (let ((signature (car (epg-context-result-for epg-context 'verify))))
+(defun epg--status-TRUST_MARGINAL (context string)
+  (let ((signature (car (epg-context-result-for context 'verify))))
     (if (and signature
 	     (eq (epg-signature-status signature) 'marginal))
 	(epg-signature-set-validity signature 'marginal))))
 
-(defun epg-status-TRUST_FULLY (process string)
-  (let ((signature (car (epg-context-result-for epg-context 'verify))))
+(defun epg--status-TRUST_FULLY (context string)
+  (let ((signature (car (epg-context-result-for context 'verify))))
     (if (and signature
 	     (eq (epg-signature-status signature) 'good))
 	(epg-signature-set-validity signature 'full))))
 
-(defun epg-status-TRUST_ULTIMATE (process string)
-  (let ((signature (car (epg-context-result-for epg-context 'verify))))
+(defun epg--status-TRUST_ULTIMATE (context string)
+  (let ((signature (car (epg-context-result-for context 'verify))))
     (if (and signature
 	     (eq (epg-signature-status signature) 'good))
 	(epg-signature-set-validity signature 'ultimate))))
 
-(defun epg-status-PROGRESS (process string)
+(defun epg--status-PROGRESS (context string)
   (if (string-match "\\`\\([^ ]+\\) \\([^ ]\\) \\([0-9]+\\) \\([0-9]+\\)"
 		    string)
-      (funcall (if (consp (epg-context-progress-callback epg-context))
-		   (car (epg-context-progress-callback epg-context))
-		 (epg-context-progress-callback epg-context))
-	       epg-context
+      (funcall (if (consp (epg-context-progress-callback context))
+		   (car (epg-context-progress-callback context))
+		 (epg-context-progress-callback context))
+	       context
 	       (match-string 1 string)
 	       (match-string 2 string)
 	       (string-to-number (match-string 3 string))
 	       (string-to-number (match-string 4 string))
-	       (if (consp (epg-context-progress-callback epg-context))
-		   (cdr (epg-context-progress-callback epg-context))))))
+	       (if (consp (epg-context-progress-callback context))
+		   (cdr (epg-context-progress-callback context))))))
 
-(defun epg-status-DECRYPTION_FAILED (process string)
+(defun epg--status-DECRYPTION_FAILED (context string)
   (epg-context-set-result-for
-   epg-context 'error
-   (cons 'decryption-failed
-	 (epg-context-result-for epg-context 'error))))
+   context 'error
+   (cons '(decryption-failed)
+	 (epg-context-result-for context 'error))))
 
-(defun epg-status-NODATA (process string)
+(defun epg--status-NODATA (context string)
   (epg-context-set-result-for
-   epg-context 'error
-   (cons (cons 'no-data (string-to-number string))
-	 (epg-context-result-for epg-context 'error))))
+   context 'error
+   (cons (list 'no-data (cons 'reason (string-to-number string)))
+	 (epg-context-result-for context 'error))))
 
-(defun epg-status-UNEXPECTED (process string)
+(defun epg--status-UNEXPECTED (context string)
   (epg-context-set-result-for
-   epg-context 'error
-   (cons (cons 'unexpected (string-to-number string))
-	 (epg-context-result-for epg-context 'error))))
+   context 'error
+   (cons (list 'unexpected (cons 'reason (string-to-number string)))
+	 (epg-context-result-for context 'error))))
 
-(defun epg-status-KEYEXPIRED (process string)
+(defun epg--status-KEYEXPIRED (context string)
   (epg-context-set-result-for
-   epg-context 'error
-   (cons (cons 'key-expired string)
-	 (epg-context-result-for epg-context 'error))))
+   context 'error
+   (cons (list 'key-expired (cons 'expiration-time
+				  (epg--time-from-seconds string)))
+	 (epg-context-result-for context 'error))))
 
-(defun epg-status-KEYREVOKED (process string)
+(defun epg--status-KEYREVOKED (context string)
   (epg-context-set-result-for
-   epg-context 'error
-   (cons 'key-revoked
-	 (epg-context-result-for epg-context 'error))))
+   context 'error
+   (cons '(key-revoked)
+	 (epg-context-result-for context 'error))))
 
-(defun epg-status-BADARMOR (process string)
+(defun epg--status-BADARMOR (context string)
   (epg-context-set-result-for
-   epg-context 'error
-   (cons 'bad-armor
-	 (epg-context-result-for epg-context 'error))))
+   context 'error
+   (cons '(bad-armor)
+	 (epg-context-result-for context 'error))))
 
-(defun epg-status-INV_RECP (process string)
+(defun epg--status-INV_RECP (context string)
   (if (string-match "\\`\\([0-9]+\\) \\(.*\\)" string)
       (epg-context-set-result-for
-       epg-context 'error
+       context 'error
        (cons (list 'invalid-recipient
-		   (string-to-number (match-string 1 string))
-		   (match-string 2 string))
-	     (epg-context-result-for epg-context 'error)))))
+		   (cons 'reason
+			 (string-to-number (match-string 1 string)))
+		   (cons 'requested-recipient
+			 (match-string 2 string)))
+	     (epg-context-result-for context 'error)))))
 
-(defun epg-status-NO_RECP (process string)
+(defun epg--status-NO_RECP (context string)
   (epg-context-set-result-for
-   epg-context 'error
-   (cons 'no-recipients
-	 (epg-context-result-for epg-context 'error))))
+   context 'error
+   (cons '(no-recipients)
+	 (epg-context-result-for context 'error))))
 
-(defun epg-status-DELETE_PROBLEM (process string)
+(defun epg--status-DELETE_PROBLEM (context string)
   (if (string-match "\\`\\([0-9]+\\)" string)
       (epg-context-set-result-for
-       epg-context 'error
-       (cons (cons 'delete-problem (string-to-number (match-string 1 string)))
-	     (epg-context-result-for epg-context 'error)))))
+       context 'error
+       (cons (list 'delete-problem
+		   (cons 'reason (string-to-number (match-string 1 string))))
+	     (epg-context-result-for context 'error)))))
 
-(defun epg-status-SIG_CREATED (process string)
+(defun epg--status-SIG_CREATED (context string)
   (if (string-match "\\`\\([DCS]\\) \\([0-9]+\\) \\([0-9]+\\) \
 \\([0-9A-Fa-F][0-9A-Fa-F]\\) \\(.*\\) " string)
       (epg-context-set-result-for
-       epg-context 'sign
+       context 'sign
+       (cons (epg-make-new-signature
+	      (cdr (assq (aref (match-string 1 string) 0)
+			 epg-new-signature-type-alist))
+	      (string-to-number (match-string 2 string))
+	      (string-to-number (match-string 3 string))
+	      (string-to-number (match-string 4 string) 16)
+	      (epg--time-from-seconds (match-string 5 string))
+	      (substring string (match-end 0)))
+	     (epg-context-result-for context 'sign)))))
+
+(defun epg--status-KEY_CREATED (context string)
+  (if (string-match "\\`\\([BPS]\\) \\([^ ]+\\)" string)
+      (epg-context-set-result-for
+       context 'generate-key
        (cons (list (cons 'type (string-to-char (match-string 1 string)))
-		   (cons 'pubkey-algorithm
-			 (string-to-number (match-string 2 string)))
-		   (cons 'digest-algorithm
-			 (string-to-number (match-string 3 string)))
-		   (cons 'class (string-to-number (match-string 4 string) 16))
-		   (cons 'creation-time (match-string 5 string))
-		   (cons 'fingerprint (substring string (match-end 0))))
-	     (epg-context-result-for epg-context 'sign)))))
+		   (cons 'fingerprint (match-string 2 string)))
+	     (epg-context-result-for context 'generate-key)))))
+
+(defun epg--status-KEY_NOT_CREATED (context string)
+  (epg-context-set-result-for
+   context 'error
+   (cons '(key-not-created)
+	 (epg-context-result-for context 'error))))
+
+(defun epg--status-IMPORTED (context string)
+  (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
+      (let* ((key-id (match-string 1 string))
+	     (user-id (match-string 2 string))
+	     (entry (assoc key-id epg-user-id-alist)))
+	(if entry
+	    (setcdr entry user-id)
+	  (setq epg-user-id-alist (cons (cons key-id user-id)
+					epg-user-id-alist)))
+	(epg-context-set-result-for
+	 context 'import
+	 (cons (list (cons 'key-id key-id)
+		     (cons 'user-id user-id))
+	       (epg-context-result-for context 'import))))))
+
+(defun epg--status-IMPORT_OK (context string)
+  (let ((result (epg-context-result-for context 'import)))
+    (if (and result
+	     (string-match "\\`\\([0-9]+\\)\\( \\(.+\\)\\)?" string))
+	(setcar result
+		(append (list (cons 'reason
+				    (string-to-number
+				     (match-string 1 string))))
+			(if (match-beginning 2)
+			    (list (cons 'fingerprint
+					(match-string 3 string))))
+			(car result))))))
+
+(defun epg--status-IMPORT_PROBLEM (context string)
+  (if (string-match "\\`\\([0-9]+\\)\\( \\(.+\\)\\)?" string)
+      (epg-context-set-result-for
+       context 'error
+       (cons (cons 'import-problem
+		   (append (list (cons 'reason
+				       (string-to-number
+					(match-string 1 string))))
+			   (if (match-beginning 2)
+			       (list (cons 'fingerprint
+					   (match-string 3 string))))))
+	     (epg-context-result-for context 'error)))))
 
 (defun epg-passphrase-callback-function (context key-id handback)
-  (read-passwd
-   (if (eq key-id 'SYM)
-       "Passphrase for symmetric encryption: "
+  (if (eq key-id 'SYM)
+      (read-passwd "Passphrase for symmetric encryption: "
+		   (eq (epg-context-operation context) 'encrypt))
+    (read-passwd
      (if (eq key-id 'PIN)
-	 "Passphrase for PIN: "
+	"Passphrase for PIN: "
        (let ((entry (assoc key-id epg-user-id-alist)))
 	 (if entry
 	     (format "Passphrase for %s %s: " key-id (cdr entry))
@@ -892,15 +1314,15 @@ This function is for internal use only."
 			   config))))
     config))
 
-(defun epg-list-keys-1 (context name mode)
+(defun epg--list-keys-1 (context name mode)
   (let ((args (append (list "--with-colons" "--no-greeting" "--batch"
 			    "--with-fingerprint"
 			    "--with-fingerprint"
-			    (if (or (eq mode t) (eq mode 'secret))
+			    (if (memq mode '(t secret))
 				"--list-secret-keys"
-			      (if mode
-				  "--list-sigs"
-				"--list-keys")))
+			      (if (memq mode '(nil public))
+				  "--list-keys"
+				"--list-sigs")))
 		      (unless (eq (epg-context-protocol context) 'CMS)
 			'("--fixed-list-mode"))
 		      (if name (list name))))
@@ -924,7 +1346,7 @@ This function is for internal use only."
 	  (setq field (1+ field))))
       (nreverse keys))))
 
-(defun epg-make-sub-key-1 (line)
+(defun epg--make-sub-key-1 (line)
   (epg-make-sub-key
    (if (aref line 1)
        (cdr (assq (string-to-char (aref line 1)) epg-key-validity-alist)))
@@ -935,27 +1357,21 @@ This function is for internal use only."
    (string-to-number (aref line 3))
    (string-to-number (aref line 2))
    (aref line 4)
-   (aref line 5)
-   (aref line 6)))
+   (epg--time-from-seconds (aref line 5))
+   (epg--time-from-seconds (aref line 6))))
 
+;;;###autoload
 (defun epg-list-keys (context &optional name mode)
   "Return a list of epg-key objects matched with NAME.
-If MODE is nil, only public keyring should be searched.
+If MODE is nil or 'public, only public keyring should be searched.
 If MODE is t or 'secret, only secret keyring should be searched. 
 Otherwise, only public keyring should be searched and the key
 signatures should be included."
-  (let ((lines (epg-list-keys-1 context name mode))
-	keys cert)
+  (let ((lines (epg--list-keys-1 context name mode))
+	keys cert pointer pointer-1)
     (while lines
       (cond
        ((member (aref (car lines) 0) '("pub" "sec" "crt" "crs"))
-	(when (car keys)
-	  (epg-key-set-sub-key-list
-	   (car keys)
-	   (nreverse (epg-key-sub-key-list (car keys))))
-	  (epg-key-set-user-id-list
-	   (car keys)
-	   (nreverse (epg-key-user-id-list (car keys)))))
 	(setq cert (member (aref (car lines) 0) '("crt" "crs"))
 	      keys (cons (epg-make-key
 			  (if (aref (car lines) 8)
@@ -964,12 +1380,12 @@ signatures should be included."
 			 keys))
 	(epg-key-set-sub-key-list
 	 (car keys)
-	 (cons (epg-make-sub-key-1 (car lines))
+	 (cons (epg--make-sub-key-1 (car lines))
 	       (epg-key-sub-key-list (car keys)))))
        ((member (aref (car lines) 0) '("sub" "ssb"))
 	(epg-key-set-sub-key-list
 	 (car keys)
-	 (cons (epg-make-sub-key-1 (car lines))
+	 (cons (epg--make-sub-key-1 (car lines))
 	       (epg-key-sub-key-list (car keys)))))
        ((equal (aref (car lines) 0) "uid")
 	(epg-key-set-user-id-list
@@ -986,27 +1402,57 @@ signatures should be included."
 	       (epg-key-user-id-list (car keys)))))
        ((equal (aref (car lines) 0) "fpr")
 	(epg-sub-key-set-fingerprint (car (epg-key-sub-key-list (car keys)))
-				     (aref (car lines) 9))))
+				     (aref (car lines) 9)))
+       ((equal (aref (car lines) 0) "sig")
+	(epg-user-id-set-signature-list
+	 (car (epg-key-user-id-list (car keys)))
+	 (cons
+	  (epg-make-key-signature
+	   (if (aref (car lines) 1)
+	       (cdr (assq (string-to-char (aref (car lines) 1))
+			  epg-key-validity-alist)))
+	   (string-to-number (aref (car lines) 3))
+	   (aref (car lines) 4)
+	   (epg--time-from-seconds (aref (car lines) 5))
+	   (epg--time-from-seconds (aref (car lines) 6))
+	   (aref (car lines) 9)
+	   (string-to-number (aref (car lines) 10) 16)
+	   (eq (aref (aref (car lines) 10) 2) ?x))
+	  (epg-user-id-signature-list
+	   (car (epg-key-user-id-list (car keys))))))))
       (setq lines (cdr lines)))
-    (when (car keys)
+    (setq keys (nreverse keys)
+	  pointer keys)
+    (while pointer
       (epg-key-set-sub-key-list
-       (car keys)
-       (nreverse (epg-key-sub-key-list (car keys))))
-      (epg-key-set-user-id-list
-       (car keys)
-       (nreverse (epg-key-user-id-list (car keys)))))
-    (nreverse keys)))
+       (car pointer)
+       (nreverse (epg-key-sub-key-list (car pointer))))
+      (setq pointer-1 (epg-key-set-user-id-list
+			  (car pointer)
+			  (nreverse (epg-key-user-id-list (car pointer)))))
+      (while pointer-1
+	(epg-user-id-set-signature-list
+	 (car pointer-1)
+	 (nreverse (epg-user-id-signature-list (car pointer-1))))
+	(setq pointer-1 (cdr pointer-1)))
+      (setq pointer (cdr pointer)))
+    keys))
 
 (if (fboundp 'make-temp-file)
-    (defalias 'epg-make-temp-file 'make-temp-file)
+    (defalias 'epg--make-temp-file 'make-temp-file)
+  (defvar temporary-file-directory)
   ;; stolen from poe.el.
-  (defun epg-make-temp-file (prefix)
+  (defun epg--make-temp-file (prefix)
     "Create a temporary file.
 The returned file name (created by appending some random characters at the end
 of PREFIX, and expanding against `temporary-file-directory' if necessary),
 is guaranteed to point to a newly created empty file.
 You can then use `write-region' to write new data into the file."
     (let (tempdir tempfile)
+      (setq prefix (expand-file-name prefix
+				     (if (featurep 'xemacs)
+					 (temp-directory)
+				       temporary-file-directory)))
       (unwind-protect
 	  (let (file)
 	    ;; First, create a temporary directory.
@@ -1048,6 +1494,13 @@ You can then use `write-region' to write new data into the file."
 
 ;;;###autoload
 (defun epg-cancel (context)
+  (if (buffer-live-p (process-buffer (epg-context-process context)))
+      (save-excursion
+	(set-buffer (process-buffer (epg-context-process context)))
+	(epg-context-set-result-for
+	 epg-context 'error
+	 (cons '(quit)
+	       (epg-context-result-for epg-context 'error)))))
   (if (eq (process-status (epg-context-process context)) 'run)
       (delete-process (epg-context-process context))))
   
@@ -1063,8 +1516,9 @@ If you are unsure, use synchronous version of this function
 `epg-decrypt-file' or `epg-decrypt-string' instead."
   (unless (epg-data-file cipher)
     (error "Not a file"))
+  (epg-context-set-operation context 'decrypt)
   (epg-context-set-result context nil)
-  (epg-start context (list "--decrypt" (epg-data-file cipher)))
+  (epg--start context (list "--decrypt" (epg-data-file cipher)))
   ;; `gpgsm' does not read passphrase from stdin, so waiting is not needed.
   (unless (eq (epg-context-protocol context) 'CMS)
     (epg-wait-for-status context '("BEGIN_DECRYPTION"))))
@@ -1078,7 +1532,7 @@ If PLAIN is nil, it returns the result as a string."
 	(if plain
 	    (epg-context-set-output-file context plain)
 	  (epg-context-set-output-file context
-				       (epg-make-temp-file "epg-output")))
+				       (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)
@@ -1093,15 +1547,14 @@ If PLAIN is nil, it returns the result as a string."
 ;;;###autoload
 (defun epg-decrypt-string (context cipher)
   "Decrypt a string CIPHER and return the plain text."
-  (let ((input-file (epg-make-temp-file "epg-input"))
+  (let ((input-file (epg--make-temp-file "epg-input"))
 	(coding-system-for-write 'binary))
     (unwind-protect
 	(progn
 	  (write-region cipher nil input-file nil 'quiet)
 	  (epg-context-set-output-file context
-				       (epg-make-temp-file "epg-output"))
+				       (epg--make-temp-file "epg-output"))
 	  (epg-start-decrypt context (epg-make-data-from-file input-file))
-	  (epg-flush context)
 	  (epg-wait-for-completion context)
 	  (if (epg-context-result-for context 'error)
 	      (error "Decrypt failed: %S"
@@ -1125,23 +1578,28 @@ If you use this function, you will need to wait for the completion of
 `epg-reset' to clear a temporaly output file.
 If you are unsure, use synchronous version of this function
 `epg-verify-file' or `epg-verify-string' instead."
+  (epg-context-set-operation context 'verify)
   (epg-context-set-result context nil)
   (if signed-text
       ;; Detached signature.
       (if (epg-data-file signed-text)
-	  (epg-start context (list "--verify" (epg-data-file signature)
+	  (epg--start context (list "--verify" (epg-data-file signature)
 				   (epg-data-file signed-text)))
-	(epg-start context (list "--verify" (epg-data-file signature) "-"))
+	(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)
-				 (epg-data-string signed-text))))
+				 (epg-data-string signed-text)))
+	(if (eq (process-status (epg-context-process context)) 'run)
+	    (process-send-eof (epg-context-process context))))
     ;; Normal (or cleartext) signature.
     (if (epg-data-file signature)
-	(epg-start context (list "--verify" (epg-data-file signature)))
-      (epg-start context (list "--verify"))
+	(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))))))
+			       (epg-data-string signature)))
+      (if (eq (process-status (epg-context-process context)) 'run)
+	  (process-send-eof (epg-context-process context))))))
 
 ;;;###autoload
 (defun epg-verify-file (context signature &optional signed-text plain)
@@ -1155,7 +1613,7 @@ For a normal or a clear text signature, SIGNED-TEXT should be nil."
 	(if plain
 	    (epg-context-set-output-file context plain)
 	  (epg-context-set-output-file context
-				       (epg-make-temp-file "epg-output")))
+				       (epg--make-temp-file "epg-output")))
 	(if signed-text
 	    (epg-start-verify context
 			      (epg-make-data-from-file signature)
@@ -1163,6 +1621,9 @@ For a normal or a clear text signature, SIGNED-TEXT should be nil."
 	  (epg-start-verify context
 			    (epg-make-data-from-file signature)))
 	(epg-wait-for-completion context)
+;	(if (epg-context-result-for context 'error)
+;	    (error "Verify failed: %S"
+;		   (epg-context-result-for context 'error)))
 	(unless plain
 	  (epg-read-output context)))
     (unless plain
@@ -1181,17 +1642,19 @@ For a normal or a clear text signature, SIGNED-TEXT should be nil."
     (unwind-protect
 	(progn
 	  (epg-context-set-output-file context
-				       (epg-make-temp-file "epg-output"))
+				       (epg--make-temp-file "epg-output"))
 	  (if signed-text
 	      (progn
-		(setq input-file (epg-make-temp-file "epg-signature"))
+		(setq input-file (epg--make-temp-file "epg-signature"))
 		(write-region signature nil input-file nil 'quiet)
 		(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-flush context)
 	  (epg-wait-for-completion context)
+;	  (if (epg-context-result-for context 'error)
+;	      (error "Verify failed: %S"
+;		     (epg-context-result-for context 'error)))
 	  (epg-read-output context))
       (epg-delete-output-file context)
       (if (and input-file
@@ -1204,22 +1667,23 @@ For a normal or a clear text signature, SIGNED-TEXT should be nil."
   "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.
-Otherwise, it makes a normal signature.
+If optional 3rd argument MODE is t or 'detached, it makes a detached signature.
+If it is nil or 'normal, it makes a normal signature.
+Otherwise, it makes a clear text signature.
 
 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-file' or `epg-sign-string' instead."
+  (epg-context-set-operation context 'sign)
   (epg-context-set-result context nil)
-  (epg-start context
-	     (append (list (if (eq mode 'clearsign)
-			       "--clearsign"
-			     (if (or (eq mode t) (eq mode 'detached))
-				 "--detach-sign"
-			       "--sign")))
+  (epg--start context
+	     (append (list (if (memq mode '(t detached))
+			       "--detach-sign"
+			     (if (memq mode '(nil normal))
+				 "--sign"
+			       "--clearsign")))
 		     (apply #'nconc
 			    (mapcar
 			     (lambda (signer)
@@ -1232,30 +1696,29 @@ If you are unsure, use synchronous version of this function
   ;; `gpgsm' does not read passphrase from stdin, so waiting is not needed.
   (unless (eq (epg-context-protocol context) 'CMS)
     (epg-wait-for-status context '("BEGIN_SIGNING")))
-  (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))))
+  (when (epg-data-string plain)
+    (if (eq (process-status (epg-context-process context)) 'run)
+	(process-send-string (epg-context-process context)
+			     (epg-data-string plain)))
+    (if (eq (process-status (epg-context-process context)) 'run)
+	(process-send-eof (epg-context-process context)))))
 
 ;;;###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."
+If optional 3rd argument MODE is t or 'detached, it makes a detached signature.
+If it is nil or 'normal, it makes a normal signature.
+Otherwise, it makes a clear text 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--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 'sign)
-	    (if (epg-context-result-for context 'error)
-		(message "Sign warning: %S"
-			 (epg-context-result-for context 'error)))
+	(unless (epg-context-result-for context 'sign)
 	  (if (epg-context-result-for context 'error)
 	      (error "Sign failed: %S"
 		     (epg-context-result-for context 'error))
@@ -1269,20 +1732,16 @@ Otherwise, it makes a normal signature."
 ;;;###autoload
 (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."
+If optional 3rd argument MODE is t or 'detached, it makes a detached signature.
+If it is nil or 'normal, it makes a normal signature.
+Otherwise, it makes a clear text signature."
   (unwind-protect
       (progn
 	(epg-context-set-output-file context
-				     (epg-make-temp-file "epg-output"))
+				     (epg--make-temp-file "epg-output"))
 	(epg-start-sign context (epg-make-data-from-string plain) mode)
-	(epg-flush context)
 	(epg-wait-for-completion context)
-	(if (epg-context-result-for context 'sign)
-	    (if (epg-context-result-for context 'error)
-		(message "Sign warning: %S"
-			 (epg-context-result-for context 'error)))
+	(unless (epg-context-result-for context 'sign)
 	  (if (epg-context-result-for context 'error)
 	      (error "Sign failed: %S"
 		     (epg-context-result-for context 'error))
@@ -1303,8 +1762,9 @@ If you use this function, you will need to wait for the completion of
 `epg-reset' to clear a temporaly output file.
 If you are unsure, use synchronous version of this function
 `epg-encrypt-file' or `epg-encrypt-string' instead."
+  (epg-context-set-operation context 'encrypt)
   (epg-context-set-result context nil)
-  (epg-start context
+  (epg--start context
 	     (append (if always-trust '("--always-trust"))
 		     (if recipients '("--encrypt") '("--symmetric"))
 		     (if sign
@@ -1327,10 +1787,12 @@ If you are unsure, use synchronous version of this function
     (if sign
 	(epg-wait-for-status context '("BEGIN_SIGNING"))
       (epg-wait-for-status context '("BEGIN_ENCRYPTION"))))
-  (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))))
+  (when (epg-data-string plain)
+    (if (eq (process-status (epg-context-process context)) 'run)
+	(process-send-string (epg-context-process context)
+			     (epg-data-string plain)))
+    (if (eq (process-status (epg-context-process context)) 'run)
+	(process-send-eof (epg-context-process context)))))
 
 ;;;###autoload
 (defun epg-encrypt-file (context plain recipients
@@ -1343,19 +1805,16 @@ If RECIPIENTS is nil, it performs symmetric encryption."
 	(if cipher
 	    (epg-context-set-output-file context cipher)
 	  (epg-context-set-output-file context
-				       (epg-make-temp-file "epg-output")))
+				       (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 sign
-	    (if (epg-context-result-for context 'sign)
-		(if (epg-context-result-for context 'error)
-		    (message "Sign warning: %S"
-			     (epg-context-result-for context 'error)))
-	      (if (epg-context-result-for context 'error)
-		  (error "Sign failed: %S"
-			 (epg-context-result-for context 'error))
-		(error "Sign failed"))))
+	(if (and sign
+		 (not (epg-context-result-for context 'sign)))
+	    (if (epg-context-result-for context 'error)
+		(error "Sign failed: %S"
+		       (epg-context-result-for context 'error))
+		(error "Sign failed")))
 	(if (epg-context-result-for context 'error)
 	    (error "Encrypt failed: %S"
 		   (epg-context-result-for context 'error)))
@@ -1373,20 +1832,16 @@ If RECIPIENTS is nil, it performs symmetric encryption."
   (unwind-protect
       (progn
 	(epg-context-set-output-file context
-				     (epg-make-temp-file "epg-output"))
+				     (epg--make-temp-file "epg-output"))
 	(epg-start-encrypt context (epg-make-data-from-string plain)
 			   recipients sign always-trust)
-	(epg-flush context)
 	(epg-wait-for-completion context)
-	(if sign
-	    (if (epg-context-result-for context 'sign)
-		(if (epg-context-result-for context 'error)
-		    (message "Sign warning: %S"
-			     (epg-context-result-for context 'error)))
-	      (if (epg-context-result-for context 'error)
-		  (error "Sign failed: %S"
-			 (epg-context-result-for context 'error))
-		(error "Sign failed"))))
+	(if (and sign
+		 (not (epg-context-result-for context 'sign)))
+	    (if (epg-context-result-for context 'error)
+		(error "Sign failed: %S"
+		       (epg-context-result-for context 'error))
+	      (error "Sign failed")))
 	(if (epg-context-result-for context 'error)
 	    (error "Encrypt failed: %S"
 		   (epg-context-result-for context 'error)))
@@ -1403,8 +1858,9 @@ If you use this function, you will need to wait for the completion of
 `epg-reset' to clear a temporaly output file.
 If you are unsure, use synchronous version of this function
 `epg-export-keys-to-file' or `epg-export-keys-to-string' instead."
+  (epg-context-set-operation context 'export-keys)
   (epg-context-set-result context nil)
-  (epg-start context (cons "--export"
+  (epg--start context (cons "--export"
 			   (mapcar
 			    (lambda (key)
 			      (epg-sub-key-id
@@ -1419,7 +1875,7 @@ If you are unsure, use synchronous version of this function
 	(if keys
 	    (epg-context-set-output-file context file)
 	  (epg-context-set-output-file context
-				       (epg-make-temp-file "epg-output")))
+				       (epg--make-temp-file "epg-output")))
 	(epg-start-export-keys context keys)
 	(epg-wait-for-completion context)
 	(if (epg-context-result-for context 'error)
@@ -1446,36 +1902,67 @@ If you use this function, you will need to wait for the completion of
 `epg-reset' to clear a temporaly output file.
 If you are unsure, use synchronous version of this function
 `epg-import-keys-from-file' or `epg-import-keys-from-string' instead."
+  (epg-context-set-operation context 'import-keys)
   (epg-context-set-result context nil)
-  (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
-  (epg-start context (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)
+  (epg--start context (if (epg-data-file keys)
+			  (list "--import" (epg-data-file keys))
+			(list "--import")))
+  (when (epg-data-string keys)
+    (if (eq (process-status (epg-context-process context)) 'run)
+	(process-send-string (epg-context-process context)
+			     (epg-data-string keys)))
+    (if (eq (process-status (epg-context-process context)) 'run)
+	(process-send-eof (epg-context-process context)))))
+
+(defun epg--import-keys-1 (context keys)
   (unwind-protect
       (progn
 	(epg-start-import-keys context keys)
-	(if (epg-data-file keys)
-	    (epg-flush context))
 	(epg-wait-for-completion context)
 	(if (epg-context-result-for context 'error)
 	    (error "Import keys failed: %S"
-		   (epg-context-result-for context 'error)))
-	(epg-read-output context))
+		   (epg-context-result-for context 'error))))
     (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)))
+  (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)))
+  (epg--import-keys-1 context (epg-make-data-from-string keys)))
+
+;;;###autoload
+(defun epg-start-receive-keys (context key-id-list)
+  "Initiate a receive key operation.
+KEY-ID-LIST is a list of key IDs.
+
+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-generate-key-from-file' or `epg-generate-key-from-string' instead."
+  (epg-context-set-operation context 'receive-keys)
+  (epg-context-set-result context nil)
+  (epg--start context (cons "--recv-keys" key-id-list)))
+
+;;;###autoload
+(defun epg-receive-keys (context keys)
+  "Add keys from server.
+KEYS is a list of key IDs"
+  (unwind-protect
+      (progn
+	(epg-start-receive-keys context keys)
+	(epg-wait-for-completion context)
+	(if (epg-context-result-for context 'error)
+	    (error "Receive keys failed: %S"
+		   (epg-context-result-for context 'error))))
+    (epg-reset context)))
+
+;;;###autoload
+(defalias 'epg-import-keys-from-server 'epg-receive-keys)
 
 ;;;###autoload
 (defun epg-start-delete-keys (context keys &optional allow-secret)
@@ -1486,8 +1973,9 @@ If you use this function, you will need to wait for the completion of
 `epg-reset' to clear a temporaly output file.
 If you are unsure, use synchronous version of this function
 `epg-delete-keys' instead."
+  (epg-context-set-operation context 'delete-keys)
   (epg-context-set-result context nil)
-  (epg-start context (cons (if allow-secret
+  (epg--start context (cons (if allow-secret
 			       "--delete-secret-key"
 			     "--delete-key")
 			   (mapcar
@@ -1517,8 +2005,9 @@ If you use this function, you will need to wait for the completion of
 `epg-reset' to clear a temporaly output file.
 If you are unsure, use synchronous version of this function
 `epg-sign-keys' instead."
+  (epg-context-set-operation context 'sign-keys)
   (epg-context-set-result context nil)
-  (epg-start context (cons (if local
+  (epg--start context (cons (if local
 			       "--lsign-key"
 			     "--sign-key")
 			   (mapcar
@@ -1539,14 +2028,62 @@ If you are unsure, use synchronous version of this function
 		   (epg-context-result-for context 'error))))
     (epg-reset context)))
 
-(defun epg-decode-hexstring (string)
+;;;###autoload
+(defun epg-start-generate-key (context parameters)
+  "Initiate a key generation.
+PARAMETERS specifies parameters for the key.
+
+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-generate-key-from-file' or `epg-generate-key-from-string' instead."
+  (epg-context-set-operation context 'generate-key)
+  (epg-context-set-result context nil)
+  (if (epg-data-file parameters)
+      (epg--start context (list "--batch" "--genkey"
+			       (epg-data-file parameters)))
+    (epg--start context '("--batch" "--genkey"))
+    (if (eq (process-status (epg-context-process context)) 'run)
+	(process-send-string (epg-context-process context)
+			     (epg-data-string parameters)))
+    (if (eq (process-status (epg-context-process context)) 'run)
+	(process-send-eof (epg-context-process context)))))
+
+;;;###autoload
+(defun epg-generate-key-from-file (context parameters)
+  "Generate a new key pair.
+PARAMETERS is a file which tells how to create the key."
+  (unwind-protect
+      (progn
+	(epg-start-generate-key context (epg-make-data-from-file parameters))
+	(epg-wait-for-completion context)
+	(if (epg-context-result-for context 'error)
+	    (error "Generate key failed: %S"
+		   (epg-context-result-for context 'error))))
+    (epg-reset context)))
+
+;;;###autoload
+(defun epg-generate-key-from-string (context parameters)
+  "Generate a new key pair.
+PARAMETERS is a string which tells how to create the key."
+  (unwind-protect
+      (progn
+	(epg-start-generate-key context (epg-make-data-from-string parameters))
+	(epg-wait-for-completion context)
+	(if (epg-context-result-for context 'error)
+	    (error "Generate key failed: %S"
+		   (epg-context-result-for context 'error))))
+    (epg-reset context)))
+
+(defun epg--decode-hexstring (string)
   (let ((index 0))
     (while (eq index (string-match "[0-9A-Fa-f][0-9A-Fa-f]" string index))
       (setq string (replace-match "\\x\\&" t nil string)
 	    index (+ index 4)))
     (car (read-from-string (concat "\"" string "\"")))))
 
-(defun epg-decode-quotedstring (string)
+(defun epg--decode-quotedstring (string)
   (let ((index 0))
     (while (string-match "\\\\\\(\\([,=+<>#;\\\"]\\)\\|\
 \\([0-9A-Fa-f][0-9A-Fa-f]\\)\\|\\(.\\)\\)"
@@ -1585,14 +2122,15 @@ The return value is an alist mapping from types to values."
 		     "\\([^,=+<>#;\\\"]\\|\\\\.\\)+"
 		     string index))
 	  (setq index (match-end 0)
-		value (epg-decode-quotedstring (match-string 0 string)))
+		value (epg--decode-quotedstring (match-string 0 string)))
 	(if (eq index (string-match "#\\([0-9A-Fa-f]+\\)" string index))
 	    (setq index (match-end 0)
-		  value (epg-decode-hexstring (match-string 1 string)))
+		  value (epg--decode-hexstring (match-string 1 string)))
 	  (if (eq index (string-match "\"\\([^\\\"]\\|\\\\.\\)*\""
 				      string index))
 	      (setq index (match-end 0)
-		    value (epg-decode-quotedstring (match-string 0 string))))))
+		    value (epg--decode-quotedstring
+			   (match-string 0 string))))))
       (if group
 	  (if (stringp (car (car alist)))
 	      (setcar alist (list (cons type value) (car alist)))