Suppress byte-compiler warnings.

[elisp/epg.git] / epa.el

diff --git a/epa.el b/epa.el
index 948cf8f..6a6b422 100644 (file)
--- a/epa.el
+++ b/epa.el
@@ -27,22 +27,13 @@
 (require 'font-lock)
 (require 'widget)
 (eval-when-compile (require 'wid-edit))
 (require 'font-lock)
 (require 'widget)
 (eval-when-compile (require 'wid-edit))

+(require 'derived)

 
 (defgroup epa nil
   "The EasyPG Assistant"
   :group 'epg)
 
 
 (defgroup epa nil
   "The EasyPG Assistant"
   :group 'epg)
 

-(defcustom epa-armor nil
-  "If non-nil, epa commands create ASCII armored output."
-  :type 'boolean
-  :group 'epa)
-
-(defcustom epa-textmode nil
-  "If non-nil, epa commands treat input files as text."
-  :type 'boolean
-  :group 'epa)
-
-(defcustom epa-popup-info-window nil
+(defcustom epa-popup-info-window t

   "If non-nil, status information from epa commands is displayed on
 the separate window."
   :type 'boolean
   "If non-nil, status information from epa commands is displayed on
 the separate window."
   :type 'boolean

@@ -161,16 +152,33 @@ the separate window."
     (17 . ?D)
     (20 . ?G)))
 
     (17 . ?D)
     (20 . ?G)))
 

+(defvar epa-protocol 'OpenPGP
+  "*The default protocol.
+The value can be either OpenPGP or CMS.
+
+You should bind this variable with `let', but do not set it globally.")
+
+(defvar epa-armor nil
+  "*If non-nil, epa commands create ASCII armored output.
+
+You should bind this variable with `let', but do not set it globally.")
+
+(defvar epa-textmode nil
+  "*If non-nil, epa commands treat input files as text.
+
+You should bind this variable with `let', but do not set it globally.")
+

 (defvar epa-keys-buffer nil)
 (defvar epa-key-buffer-alist nil)
 (defvar epa-key nil)
 (defvar epa-list-keys-arguments nil)
 (defvar epa-info-buffer nil)
 (defvar epa-keys-buffer nil)
 (defvar epa-key-buffer-alist nil)
 (defvar epa-key nil)
 (defvar epa-list-keys-arguments nil)
 (defvar epa-info-buffer nil)

+(defvar epa-last-coding-system-specified nil)

 
 

-(defvar epa-keys-mode-map
+(defvar epa-key-list-mode-map

   (let ((keymap (make-sparse-keymap)))
   (let ((keymap (make-sparse-keymap)))

-    (define-key keymap "m" 'epa-mark)
-    (define-key keymap "u" 'epa-unmark)
+    (define-key keymap "m" 'epa-mark-key)
+    (define-key keymap "u" 'epa-unmark-key)

     (define-key keymap "d" 'epa-decrypt-file)
     (define-key keymap "v" 'epa-verify-file)
     (define-key keymap "s" 'epa-sign-file)
     (define-key keymap "d" 'epa-decrypt-file)
     (define-key keymap "v" 'epa-verify-file)
     (define-key keymap "s" 'epa-sign-file)

@@ -178,7 +186,7 @@ the separate window."
     (define-key keymap "r" 'epa-delete-keys)
     (define-key keymap "i" 'epa-import-keys)
     (define-key keymap "o" 'epa-export-keys)
     (define-key keymap "r" 'epa-delete-keys)
     (define-key keymap "i" 'epa-import-keys)
     (define-key keymap "o" 'epa-export-keys)

-    (define-key keymap "g" 'epa-list-keys)
+    (define-key keymap "g" 'revert-buffer)

     (define-key keymap "n" 'next-line)
     (define-key keymap "p" 'previous-line)
     (define-key keymap " " 'scroll-up)
     (define-key keymap "n" 'next-line)
     (define-key keymap "p" 'previous-line)
     (define-key keymap " " 'scroll-up)

@@ -188,7 +196,7 @@ the separate window."
 
 (defvar epa-key-mode-map
   (let ((keymap (make-sparse-keymap)))
 
 (defvar epa-key-mode-map
   (let ((keymap (make-sparse-keymap)))

-    (define-key keymap "q" 'bury-buffer)
+    (define-key keymap "q" 'epa-exit-buffer)

     keymap))
 
 (defvar epa-info-mode-map
     keymap))
 
 (defvar epa-info-mode-map

@@ -220,9 +228,11 @@ the separate window."
                      ? ))
            (epg-sub-key-id primary-sub-key)
            " "
                      ? ))
            (epg-sub-key-id primary-sub-key)
            " "

-           (if (stringp (epg-user-id-string primary-user-id))
-               (epg-user-id-string primary-user-id)
-             (epg-decode-dn (epg-user-id-string primary-user-id))))))
+           (if primary-user-id
+               (if (stringp (epg-user-id-string primary-user-id))
+                   (epg-user-id-string primary-user-id)
+                 (epg-decode-dn (epg-user-id-string primary-user-id)))
+             ""))))

 
 (defun epa--key-widget-button-face-get (widget)
   (let ((validity (epg-sub-key-validity (car (epg-key-sub-key-list
 
 (defun epa--key-widget-button-face-get (widget)
   (let ((validity (epg-sub-key-validity (car (epg-key-sub-key-list

@@ -236,24 +246,34 @@ the separate window."
          (epg-sub-key-id (car (epg-key-sub-key-list
                                (widget-get widget :value))))))
 
          (epg-sub-key-id (car (epg-key-sub-key-list
                                (widget-get widget :value))))))
 

-(defun epa-keys-mode ()
+(eval-and-compile
+  (if (fboundp 'encode-coding-string)
+      (defalias 'epa--encode-coding-string 'encode-coding-string)
+    (defalias 'epa--encode-coding-string 'identity)))
+
+(eval-and-compile
+  (if (fboundp 'decode-coding-string)
+      (defalias 'epa--decode-coding-string 'decode-coding-string)
+    (defalias 'epa--decode-coding-string 'identity)))
+
+(defun epa-key-list-mode ()

   "Major mode for `epa-list-keys'."
   (kill-all-local-variables)
   (buffer-disable-undo)
   "Major mode for `epa-list-keys'."
   (kill-all-local-variables)
   (buffer-disable-undo)

-  (setq major-mode 'epa-keys-mode
+  (setq major-mode 'epa-key-list-mode

        mode-name "Keys"
        truncate-lines t
        buffer-read-only t)
        mode-name "Keys"
        truncate-lines t
        buffer-read-only t)

-  (use-local-map epa-keys-mode-map)
-  (set-keymap-parent (current-local-map) widget-keymap)
+  (use-local-map epa-key-list-mode-map)

   (make-local-variable 'font-lock-defaults)
   (setq font-lock-defaults '(epa-font-lock-keywords t))
   ;; In XEmacs, auto-initialization of font-lock is not effective
   ;; if buffer-file-name is not set.
   (font-lock-set-defaults)
   (make-local-variable 'font-lock-defaults)
   (setq font-lock-defaults '(epa-font-lock-keywords t))
   ;; In XEmacs, auto-initialization of font-lock is not effective
   ;; if buffer-file-name is not set.
   (font-lock-set-defaults)

-  (widget-setup)

   (make-local-variable 'epa-exit-buffer-function)
   (make-local-variable 'epa-exit-buffer-function)

-  (run-hooks 'epa-keys-mode-hook))
+  (make-local-variable 'revert-buffer-function)
+  (setq revert-buffer-function 'epa--key-list-revert-buffer)
+  (run-hooks 'epa-key-list-mode-hook))

 
 (defun epa-key-mode ()
   "Major mode for a key description."
 
 (defun epa-key-mode ()
   "Major mode for a key description."

@@ -283,30 +303,27 @@ the separate window."
   (use-local-map epa-info-mode-map)
   (run-hooks 'epa-info-mode-hook))
 
   (use-local-map epa-info-mode-map)
   (run-hooks 'epa-info-mode-hook))
 

-(defun epa-mark (&optional arg)
-  "Mark the current line.
-If ARG is non-nil, unmark the current line."
+(defun epa-mark-key (&optional arg)
+  "Mark a key on the current line.
+If ARG is non-nil, unmark the key."

   (interactive "P")
   (let ((inhibit-read-only t)
        buffer-read-only
        properties)
     (beginning-of-line)
   (interactive "P")
   (let ((inhibit-read-only t)
        buffer-read-only
        properties)
     (beginning-of-line)

+    (unless (get-text-property (point) 'epa-key)
+      (error "No key on this line"))

     (setq properties (text-properties-at (point)))
     (delete-char 1)
     (insert (if arg " " "*"))
     (set-text-properties (1- (point)) (point) properties)
     (forward-line)))
 
     (setq properties (text-properties-at (point)))
     (delete-char 1)
     (insert (if arg " " "*"))
     (set-text-properties (1- (point)) (point) properties)
     (forward-line)))
 

-(defun epa-unmark (&optional arg)
-  "Unmark the current line.
-If ARG is non-nil, mark the current line."
+(defun epa-unmark-key (&optional arg)
+  "Unmark a key on the current line.
+If ARG is non-nil, mark the key."

   (interactive "P")
   (interactive "P")

-  (epa-mark (not arg)))
-
-(defun epa-toggle-mark ()
-  "Toggle the mark the current line."
-  (interactive)
-  (epa-mark (eq (char-after (save-excursion (beginning-of-line) (point))) ?*)))
+  (epa-mark-key (not arg)))

 
 (defun epa-exit-buffer ()
   "Exit the current buffer.
 
 (defun epa-exit-buffer ()
   "Exit the current buffer.

@@ -314,47 +331,11 @@ If ARG is non-nil, mark the current line."
   (interactive)
   (funcall epa-exit-buffer-function))
 
   (interactive)
   (funcall epa-exit-buffer-function))
 

-;;;###autoload
-(defun epa-list-keys (&optional name mode protocol)
-  (interactive
-   (if current-prefix-arg
-       (let ((name (read-string "Pattern: "
-                               (if epa-list-keys-arguments
-                                   (car epa-list-keys-arguments)))))
-        (list (if (equal name "") nil name)
-              (y-or-n-p "Secret keys? ")
-              (intern (completing-read "Protocol? "
-                                       '(("OpenPGP") ("CMS"))
-                                       nil t))))
-     (or epa-list-keys-arguments (list nil nil nil))))
-  (unless (and epa-keys-buffer
-              (buffer-live-p epa-keys-buffer))
-    (setq epa-keys-buffer (generate-new-buffer "*Keys*")))
-  (set-buffer epa-keys-buffer)
-  (let ((inhibit-read-only t)
-       buffer-read-only
-       (point (point-min))
-       (context (epg-make-context protocol)))
-    (unless (get-text-property point 'epa-list-keys)
-      (setq point (next-single-property-change point 'epa-list-keys)))
-    (when point
-      (delete-region point
-                    (or (next-single-property-change point 'epa-list-keys)
-                        (point-max)))
-      (goto-char point))
-    (epa-insert-keys context name mode)
-    (epa-keys-mode))
-  (make-local-variable 'epa-list-keys-arguments)
-  (setq epa-list-keys-arguments (list name mode protocol))
-  (goto-char (point-min))
-  (pop-to-buffer (current-buffer)))
-
-(defun epa-insert-keys (context name mode)
+(defun epa--insert-keys (keys)

   (save-excursion
     (save-restriction
       (narrow-to-region (point) (point))
   (save-excursion
     (save-restriction
       (narrow-to-region (point) (point))

-      (let ((keys (epg-list-keys context name mode))
-           point)
+      (let (point)

        (while keys
          (setq point (point))
          (insert "  ")
        (while keys
          (setq point (point))
          (insert "  ")

@@ -374,6 +355,58 @@ If ARG is non-nil, mark the current line."
                                 'start-open t
                                 'end-open t)))))
 
                                 'start-open t
                                 'end-open t)))))
 

+(defun epa--list-keys (name secret)
+  (unless (and epa-keys-buffer
+              (buffer-live-p epa-keys-buffer))
+    (setq epa-keys-buffer (generate-new-buffer "*Keys*")))
+  (set-buffer epa-keys-buffer)
+  (epa-key-list-mode)
+  (let ((inhibit-read-only t)
+       buffer-read-only
+       (point (point-min))
+       (context (epg-make-context epa-protocol)))
+    (unless (get-text-property point 'epa-list-keys)
+      (setq point (next-single-property-change point 'epa-list-keys)))
+    (when point
+      (delete-region point
+                    (or (next-single-property-change point 'epa-list-keys)
+                        (point-max)))
+      (goto-char point))
+    (epa--insert-keys (epg-list-keys context name secret))
+    (widget-setup)
+    (set-keymap-parent (current-local-map) widget-keymap))
+  (make-local-variable 'epa-list-keys-arguments)
+  (setq epa-list-keys-arguments (list name secret))
+  (goto-char (point-min))
+  (pop-to-buffer (current-buffer)))
+
+;;;###autoload
+(defun epa-list-keys (&optional name)
+  "List all keys matched with NAME from the public keyring."
+  (interactive
+   (if current-prefix-arg
+       (let ((name (read-string "Pattern: "
+                               (if epa-list-keys-arguments
+                                   (car epa-list-keys-arguments)))))
+        (list (if (equal name "") nil name)))
+     (list nil)))
+  (epa--list-keys name nil))
+
+;;;###autoload
+(defun epa-list-secret-keys (&optional name)
+  "List all keys matched with NAME from the private keyring."
+  (interactive
+   (if current-prefix-arg
+       (let ((name (read-string "Pattern: "
+                               (if epa-list-keys-arguments
+                                   (car epa-list-keys-arguments)))))
+        (list (if (equal name "") nil name)))
+     (list nil)))
+  (epa--list-keys name t))
+
+(defun epa--key-list-revert-buffer (&optional ignore-auto noconfirm)
+  (apply #'epa--list-keys epa-list-keys-arguments))
+

 (defun epa--marked-keys ()
   (or (save-excursion
        (set-buffer epa-keys-buffer)
 (defun epa--marked-keys ()
   (or (save-excursion
        (set-buffer epa-keys-buffer)

@@ -390,23 +423,20 @@ If ARG is non-nil, mark the current line."
          (if key
              (list key))))))
 
          (if key
              (list key))))))
 

-;;;###autoload
-(defun epa-select-keys (context prompt &optional names secret)
-  "Display a user's keyring and ask him to select keys.
-CONTEXT is an epg-context.
-PROMPT is a string to prompt with.
-NAMES is a list of strings to be matched with keys.  If it is nil, all
-the keys are listed.
-If SECRET is non-nil, list secret keys instead of public keys."
+(defun epa--select-keys (prompt keys)

   (save-excursion
     (unless (and epa-keys-buffer
                 (buffer-live-p epa-keys-buffer))
       (setq epa-keys-buffer (generate-new-buffer "*Keys*")))
   (save-excursion
     (unless (and epa-keys-buffer
                 (buffer-live-p epa-keys-buffer))
       (setq epa-keys-buffer (generate-new-buffer "*Keys*")))

+    (set-buffer epa-keys-buffer)
+    (epa-key-list-mode)

     (let ((inhibit-read-only t)
          buffer-read-only)
     (let ((inhibit-read-only t)
          buffer-read-only)

-      (set-buffer epa-keys-buffer)

       (erase-buffer)
       (erase-buffer)

-      (insert prompt "\n")
+      (insert prompt "\n"
+             (substitute-command-keys "\
+- `\\[epa-mark-key]' to mark a key on the line
+- `\\[epa-unmark-key]' to unmark a key on the line\n"))

       (widget-create 'link
                     :notify (lambda (&rest ignore) (abort-recursive-edit))
                     :help-echo
       (widget-create 'link
                     :notify (lambda (&rest ignore) (abort-recursive-edit))
                     :help-echo

@@ -420,20 +450,9 @@ If SECRET is non-nil, list secret keys instead of public keys."
                      "Click here or \\[exit-recursive-edit] to finish")
                     "OK")
       (insert "\n\n")
                      "Click here or \\[exit-recursive-edit] to finish")
                     "OK")
       (insert "\n\n")

-      (if names
-         (while names
-           (epa-insert-keys context (car names) secret)
-           (if (get-text-property (point) 'epa-list-keys)
-               (epa-mark))
-           (goto-char (point-max))
-           (setq names (cdr names)))
-       (if secret
-           (progn
-             (epa-insert-keys context nil secret)
-             (if (get-text-property (point) 'epa-list-keys)
-                 (epa-mark)))
-         (epa-insert-keys context nil nil)))
-      (epa-keys-mode)
+      (epa--insert-keys keys)
+      (widget-setup)
+      (set-keymap-parent (current-local-map) widget-keymap)

       (setq epa-exit-buffer-function #'abort-recursive-edit)
       (goto-char (point-min))
       (pop-to-buffer (current-buffer)))
       (setq epa-exit-buffer-function #'abort-recursive-edit)
       (goto-char (point-min))
       (pop-to-buffer (current-buffer)))

@@ -445,6 +464,39 @@ If SECRET is non-nil, list secret keys instead of public keys."
          (delete-window (get-buffer-window epa-keys-buffer)))
       (kill-buffer epa-keys-buffer))))
 
          (delete-window (get-buffer-window epa-keys-buffer)))
       (kill-buffer epa-keys-buffer))))
 

+;;;###autoload
+(defun epa-select-keys (context prompt &optional names secret)
+  "Display a user's keyring and ask him to select keys.
+CONTEXT is an epg-context.
+PROMPT is a string to prompt with.
+NAMES is a list of strings to be matched with keys.  If it is nil, all
+the keys are listed.
+If SECRET is non-nil, list secret keys instead of public keys."
+  (let ((keys (epg-list-keys context names secret)))
+    (if (> (length keys) 1)
+       (epa--select-keys prompt keys)
+      keys)))
+
+(defun epa--format-fingerprint-1 (fingerprint unit-size block-size)
+  (let ((unit 0))
+    (with-temp-buffer
+      (insert fingerprint)
+      (goto-char (point-min))
+      (while (progn
+              (goto-char (+ (point) unit-size))
+              (not (eobp)))
+       (setq unit (1+ unit))
+       (insert (if (= (% unit block-size) 0) "  " " ")))
+      (buffer-string))))
+
+(defun epa--format-fingerprint (fingerprint)
+  (if fingerprint
+      (if (= (length fingerprint) 40)
+         ;; 1234 5678 9ABC DEF0 1234  5678 9ABC DEF0 1234 5678
+         (epa--format-fingerprint-1 fingerprint 4 5)
+       ;; 12 34 56 78 9A BC DE F0  12 34 56 78 9A BC DE F0
+       (epa--format-fingerprint-1 fingerprint 2 8))))
+

 (defun epa--show-key (key)
   (let* ((primary-sub-key (car (epg-key-sub-key-list key)))
         (entry (assoc (epg-sub-key-id primary-sub-key)
 (defun epa--show-key (key)
   (let* ((primary-sub-key (car (epg-key-sub-key-list key)))
         (entry (assoc (epg-sub-key-id primary-sub-key)

@@ -460,22 +512,24 @@ If SECRET is non-nil, list secret keys instead of public keys."
       (setcdr entry (generate-new-buffer
                     (format "*Key*%s" (epg-sub-key-id primary-sub-key)))))
     (set-buffer (cdr entry))
       (setcdr entry (generate-new-buffer
                     (format "*Key*%s" (epg-sub-key-id primary-sub-key)))))
     (set-buffer (cdr entry))

+    (epa-key-mode)

     (make-local-variable 'epa-key)
     (setq epa-key key)
     (erase-buffer)
     (setq pointer (epg-key-user-id-list key))
     (while pointer
     (make-local-variable 'epa-key)
     (setq epa-key key)
     (erase-buffer)
     (setq pointer (epg-key-user-id-list key))
     (while pointer

-      (insert " "
-             (if (epg-user-id-validity (car pointer))
-                 (char-to-string
-                  (car (rassq (epg-user-id-validity (car pointer))
-                              epg-key-validity-alist)))
-               " ")
-             " "
-             (if (stringp (epg-user-id-string (car pointer)))
-                 (epg-user-id-string (car pointer))
-               (epg-decode-dn (epg-user-id-string (car pointer))))
-             "\n")
+      (if (car pointer)
+         (insert " "
+                 (if (epg-user-id-validity (car pointer))
+                     (char-to-string
+                      (car (rassq (epg-user-id-validity (car pointer))
+                                  epg-key-validity-alist)))
+                   " ")
+                 " "
+                 (if (stringp (epg-user-id-string (car pointer)))
+                     (epg-user-id-string (car pointer))
+                   (epg-decode-dn (epg-user-id-string (car pointer))))
+                 "\n"))

       (setq pointer (cdr pointer)))
     (setq pointer (epg-key-sub-key-list key))
     (while pointer
       (setq pointer (cdr pointer)))
     (setq pointer (epg-key-sub-key-list key))
     (while pointer

@@ -507,29 +561,35 @@ If SECRET is non-nil, list secret keys instead of public keys."
                         (epg-sub-key-capability (car pointer))
                         " ")
              "\n\tFingerprint: "
                         (epg-sub-key-capability (car pointer))
                         " ")
              "\n\tFingerprint: "

-             (epg-sub-key-fingerprint (car pointer))
+             (epa--format-fingerprint (epg-sub-key-fingerprint (car pointer)))

              "\n")
       (setq pointer (cdr pointer)))
     (goto-char (point-min))
              "\n")
       (setq pointer (cdr pointer)))
     (goto-char (point-min))

-    (pop-to-buffer (current-buffer))
-    (epa-key-mode)))
+    (pop-to-buffer (current-buffer))))

 
 (defun epa-display-info (info)
   (if epa-popup-info-window
 
 (defun epa-display-info (info)
   (if epa-popup-info-window

-      (progn
-       (unless epa-info-buffer
+      (save-selected-window
+       (unless (and epa-info-buffer (buffer-live-p epa-info-buffer))

          (setq epa-info-buffer (generate-new-buffer "*Info*")))
          (setq epa-info-buffer (generate-new-buffer "*Info*")))

+       (if (get-buffer-window epa-info-buffer)
+           (delete-window (get-buffer-window epa-info-buffer)))

        (save-excursion
          (set-buffer epa-info-buffer)
          (let ((inhibit-read-only t)
                buffer-read-only)
            (erase-buffer)
            (insert info))
        (save-excursion
          (set-buffer epa-info-buffer)
          (let ((inhibit-read-only t)
                buffer-read-only)
            (erase-buffer)
            (insert info))

-         (epa-info-mode))
-       (pop-to-buffer epa-info-buffer)
-       (if (> (window-height) epa-info-window-height)
-           (shrink-window (- (window-height) epa-info-window-height)))
-       (goto-char (point-min)))
+         (epa-info-mode)
+         (goto-char (point-min)))
+       (if (> (window-height)
+              epa-info-window-height)
+           (set-window-buffer (split-window nil (- (window-height)
+                                                   epa-info-window-height))
+                              epa-info-buffer)
+         (pop-to-buffer epa-info-buffer)
+         (if (> (window-height) epa-info-window-height)
+             (shrink-window (- (window-height) epa-info-window-height)))))

     (message "%s" info)))
 
 (defun epa-display-verify-result (verify-result)
     (message "%s" info)))
 
 (defun epa-display-verify-result (verify-result)

@@ -550,7 +610,8 @@ If SECRET is non-nil, list secret keys instead of public keys."
 
 (defun epa-progress-callback-function (context what char current total
                                               handback)
 
 (defun epa-progress-callback-function (context what char current total
                                               handback)

-  (message "%s: %d%% (%d/%d)" what
+  (message "%s%d%% (%d/%d)" (or handback
+                               (concat what ": "))

           (if (> total 0) (floor (* (/ current (float total)) 100)) 0)
           current total))
 
           (if (> total 0) (floor (* (/ current (float total)) 100)) 0)
           current total))
 

@@ -558,6 +619,7 @@ If SECRET is non-nil, list secret keys instead of public keys."
 (defun epa-decrypt-file (file)
   "Decrypt FILE."
   (interactive "fFile: ")
 (defun epa-decrypt-file (file)
   "Decrypt FILE."
   (interactive "fFile: ")

+  (setq file (expand-file-name file))

   (let* ((default-name (file-name-sans-extension file))
         (plain (expand-file-name
                 (read-file-name
   (let* ((default-name (file-name-sans-extension file))
         (plain (expand-file-name
                 (read-file-name

@@ -566,14 +628,17 @@ If SECRET is non-nil, list secret keys instead of public keys."
                          ") ")
                  (file-name-directory default-name)
                  default-name)))
                          ") ")
                  (file-name-directory default-name)
                  default-name)))

-        (context (epg-make-context)))
+        (context (epg-make-context epa-protocol)))

     (epg-context-set-passphrase-callback context
                                         #'epa-passphrase-callback-function)
     (epg-context-set-progress-callback context
     (epg-context-set-passphrase-callback context
                                         #'epa-passphrase-callback-function)
     (epg-context-set-progress-callback context

-                                      #'epa-progress-callback-function)
+                                      #'epa-progress-callback-function
+                                      (format "Decrypting %s..."
+                                              (file-name-nondirectory file)))

     (message "Decrypting %s..." (file-name-nondirectory file))
     (epg-decrypt-file context file plain)
     (message "Decrypting %s..." (file-name-nondirectory file))
     (epg-decrypt-file context file plain)

-    (message "Decrypting %s...done" (file-name-nondirectory file))
+    (message "Decrypting %s...wrote %s" (file-name-nondirectory file)
+            (file-name-nondirectory plain))

     (if (epg-context-result-for context 'verify)
        (epa-display-info (epg-verify-result-to-string
                           (epg-context-result-for context 'verify))))))
     (if (epg-context-result-for context 'verify)
        (epa-display-info (epg-verify-result-to-string
                           (epg-context-result-for context 'verify))))))

@@ -582,11 +647,14 @@ If SECRET is non-nil, list secret keys instead of public keys."
 (defun epa-verify-file (file)
   "Verify FILE."
   (interactive "fFile: ")
 (defun epa-verify-file (file)
   "Verify FILE."
   (interactive "fFile: ")

-  (let* ((context (epg-make-context))
+  (setq file (expand-file-name file))
+  (let* ((context (epg-make-context epa-protocol))

         (plain (if (equal (file-name-extension file) "sig")
                    (file-name-sans-extension file))))
     (epg-context-set-progress-callback context
         (plain (if (equal (file-name-extension file) "sig")
                    (file-name-sans-extension file))))
     (epg-context-set-progress-callback context

-                                      #'epa-progress-callback-function)
+                                      #'epa-progress-callback-function
+                                      (format "Verifying %s..."
+                                              (file-name-nondirectory file)))

     (message "Verifying %s..." (file-name-nondirectory file))
     (epg-verify-file context file plain)
     (message "Verifying %s...done" (file-name-nondirectory file))
     (message "Verifying %s..." (file-name-nondirectory file))
     (epg-verify-file context file plain)
     (message "Verifying %s...done" (file-name-nondirectory file))

@@ -594,55 +662,93 @@ If SECRET is non-nil, list secret keys instead of public keys."
        (epa-display-info (epg-verify-result-to-string
                           (epg-context-result-for context 'verify))))))
 
        (epa-display-info (epg-verify-result-to-string
                           (epg-context-result-for context 'verify))))))
 

+(defun epa--read-signature-type ()
+  (let (type c)
+    (while (null type)
+      (message "Signature type (n,c,d,?) ")
+      (setq c (read-char))
+      (cond ((eq c ?c)
+            (setq type 'clear))
+           ((eq c ?d)
+            (setq type 'detached))
+           ((eq c ??)
+            (with-output-to-temp-buffer "*Help*"
+              (save-excursion
+                (set-buffer standard-output)
+                (insert "\
+n - Create a normal signature
+c - Create a cleartext signature
+d - Create a detached signature
+? - Show this help
+"))))
+           (t
+            (setq type 'normal))))))
+

 ;;;###autoload
 (defun epa-sign-file (file signers mode)
   "Sign FILE by SIGNERS keys selected."
   (interactive
 ;;;###autoload
 (defun epa-sign-file (file signers mode)
   "Sign FILE by SIGNERS keys selected."
   (interactive

-   (list (expand-file-name (read-file-name "File: "))
-        (epa-select-keys (epg-make-context) "Select keys for signing.
+   (let ((verbose current-prefix-arg))
+     (list (expand-file-name (read-file-name "File: "))
+          (if verbose
+              (epa-select-keys (epg-make-context epa-protocol)
+                               "Select keys for signing.

 If no one is selected, default secret key is used.  "
 If no one is selected, default secret key is used.  "

-                         nil t)
-        (if (y-or-n-p "Make a detached signature? ")
-            'detached
-          (if (y-or-n-p "Make a cleartext signature? ")
-              'clear))))
+                               nil t))
+          (if verbose
+              (epa--read-signature-type)
+            'clear))))

   (let ((signature (concat file
   (let ((signature (concat file

-                          (if (or epa-armor
-                                  (not (memq mode '(nil t normal detached))))
-                              ".asc"
+                          (if (eq epa-protocol 'OpenPGP)
+                              (if (or epa-armor
+                                      (not (memq mode
+                                                 '(nil t normal detached))))
+                                  ".asc"
+                                (if (memq mode '(t detached))
+                                    ".sig"
+                                  ".gpg"))

                             (if (memq mode '(t detached))
                             (if (memq mode '(t detached))

-                                ".sig"
-                              ".gpg"))))
-       (context (epg-make-context)))
+                                ".p7s"
+                              ".p7m"))))
+       (context (epg-make-context epa-protocol)))

     (epg-context-set-armor context epa-armor)
     (epg-context-set-textmode context epa-textmode)
     (epg-context-set-signers context signers)
     (epg-context-set-passphrase-callback context
                                         #'epa-passphrase-callback-function)
     (epg-context-set-progress-callback context
     (epg-context-set-armor context epa-armor)
     (epg-context-set-textmode context epa-textmode)
     (epg-context-set-signers context signers)
     (epg-context-set-passphrase-callback context
                                         #'epa-passphrase-callback-function)
     (epg-context-set-progress-callback context

-                                      #'epa-progress-callback-function)
+                                      #'epa-progress-callback-function
+                                      (format "Signing %s..."
+                                              (file-name-nondirectory file)))

     (message "Signing %s..." (file-name-nondirectory file))
     (epg-sign-file context file signature mode)
     (message "Signing %s..." (file-name-nondirectory file))
     (epg-sign-file context file signature mode)

-    (message "Signing %s...done" (file-name-nondirectory file))))
+    (message "Signing %s...wrote %s" (file-name-nondirectory file)
+            (file-name-nondirectory signature))))

 
 ;;;###autoload
 (defun epa-encrypt-file (file recipients)
   "Encrypt FILE for RECIPIENTS."
   (interactive
    (list (expand-file-name (read-file-name "File: "))
 
 ;;;###autoload
 (defun epa-encrypt-file (file recipients)
   "Encrypt FILE for RECIPIENTS."
   (interactive
    (list (expand-file-name (read-file-name "File: "))

-        (epa-select-keys (epg-make-context) "Select recipients for encryption.
+        (epa-select-keys (epg-make-context epa-protocol)
+                         "Select recipients for encryption.

 If no one is selected, symmetric encryption will be performed.  ")))
 If no one is selected, symmetric encryption will be performed.  ")))

-  (let ((cipher (concat file (if epa-armor ".asc" ".gpg")))
-       (context (epg-make-context)))
+  (let ((cipher (concat file (if (eq epa-protocol 'OpenPGP)
+                                (if epa-armor ".asc" ".gpg")
+                              ".p7m")))
+       (context (epg-make-context epa-protocol)))

     (epg-context-set-armor context epa-armor)
     (epg-context-set-textmode context epa-textmode)
     (epg-context-set-passphrase-callback context
                                         #'epa-passphrase-callback-function)
     (epg-context-set-progress-callback context
     (epg-context-set-armor context epa-armor)
     (epg-context-set-textmode context epa-textmode)
     (epg-context-set-passphrase-callback context
                                         #'epa-passphrase-callback-function)
     (epg-context-set-progress-callback context

-                                      #'epa-progress-callback-function)
+                                      #'epa-progress-callback-function
+                                      (format "Encrypting %s..."
+                                              (file-name-nondirectory file)))

     (message "Encrypting %s..." (file-name-nondirectory file))
     (epg-encrypt-file context file recipients cipher)
     (message "Encrypting %s..." (file-name-nondirectory file))
     (epg-encrypt-file context file recipients cipher)

-    (message "Encrypting %s...done" (file-name-nondirectory file))))
+    (message "Encrypting %s...wrote %s" (file-name-nondirectory file)
+            (file-name-nondirectory cipher))))

 
 ;;;###autoload
 (defun epa-decrypt-region (start end)
 
 ;;;###autoload
 (defun epa-decrypt-region (start end)

@@ -651,22 +757,45 @@ If no one is selected, symmetric encryption will be performed.  ")))
 Don't use this command in Lisp programs!"
   (interactive "r")
   (save-excursion
 Don't use this command in Lisp programs!"
   (interactive "r")
   (save-excursion

-    (let ((context (epg-make-context))
+    (let ((context (epg-make-context epa-protocol))

          plain)
       (epg-context-set-passphrase-callback context
                                           #'epa-passphrase-callback-function)
       (epg-context-set-progress-callback context
          plain)
       (epg-context-set-passphrase-callback context
                                           #'epa-passphrase-callback-function)
       (epg-context-set-progress-callback context

-                                        #'epa-progress-callback-function)
+                                        #'epa-progress-callback-function
+                                        "Decrypting...")

       (message "Decrypting...")
       (setq plain (epg-decrypt-string context (buffer-substring start end)))
       (message "Decrypting...done")
       (message "Decrypting...")
       (setq plain (epg-decrypt-string context (buffer-substring start end)))
       (message "Decrypting...done")

-      (delete-region start end)
-      (goto-char start)
-      (insert (decode-coding-string plain coding-system-for-read))
+      (setq plain (epa--decode-coding-string
+                  plain
+                  (or coding-system-for-read
+                      (get-text-property start 'epa-coding-system-used))))
+      (if (y-or-n-p "Replace the original text? ")
+         (let ((inhibit-read-only t)
+               buffer-read-only)
+           (delete-region start end)
+           (goto-char start)
+           (insert plain))
+       (with-output-to-temp-buffer "*Temp*"
+         (set-buffer standard-output)
+         (insert plain)
+         (epa-info-mode)))

       (if (epg-context-result-for context 'verify)
          (epa-display-info (epg-verify-result-to-string
                             (epg-context-result-for context 'verify)))))))
 
       (if (epg-context-result-for context 'verify)
          (epa-display-info (epg-verify-result-to-string
                             (epg-context-result-for context 'verify)))))))
 

+(defun epa--find-coding-system-for-mime-charset (mime-charset)
+  (if (featurep 'xemacs)
+      (if (fboundp 'find-coding-system)
+         (find-coding-system mime-charset))
+    (let ((pointer (coding-system-list)))
+      (while (and pointer
+                 (eq (coding-system-get (car pointer) 'mime-charset)
+                     mime-charset))
+       (setq pointer (cdr pointer)))
+      pointer)))
+

 ;;;###autoload
 (defun epa-decrypt-armor-in-region (start end)
   "Decrypt OpenPGP armors in the current region between START and END.
 ;;;###autoload
 (defun epa-decrypt-armor-in-region (start end)
   "Decrypt OpenPGP armors in the current region between START and END.

@@ -677,7 +806,7 @@ Don't use this command in Lisp programs!"
     (save-restriction
       (narrow-to-region start end)
       (goto-char start)
     (save-restriction
       (narrow-to-region start end)
       (goto-char start)

-      (let (armor-start armor-end charset coding-system)
+      (let (armor-start armor-end)

        (while (re-search-forward "-----BEGIN PGP MESSAGE-----$" nil t)
          (setq armor-start (match-beginning 0)
                armor-end (re-search-forward "^-----END PGP MESSAGE-----$"
        (while (re-search-forward "-----BEGIN PGP MESSAGE-----$" nil t)
          (setq armor-start (match-beginning 0)
                armor-end (re-search-forward "^-----END PGP MESSAGE-----$"

@@ -685,15 +814,13 @@ Don't use this command in Lisp programs!"
          (unless armor-end
            (error "No armor tail"))
          (goto-char armor-start)
          (unless armor-end
            (error "No armor tail"))
          (goto-char armor-start)

-         (if (re-search-forward "^Charset: \\(.*\\)" armor-end t)
-             (setq charset (match-string 1)))
-         (if coding-system-for-read
-             (setq coding-system coding-system-for-read)
-           (if charset
-               (setq coding-system (intern (downcase charset)))
-             (setq coding-system 'utf-8)))
-         (let ((coding-system-for-read coding-system))
-           (epa-decrypt-region start end)))))))
+         (let ((coding-system-for-read
+                (or coding-system-for-read
+                    (if (re-search-forward "^Charset: \\(.*\\)" armor-end t)
+                        (epa--find-coding-system-for-mime-charset
+                         (intern (downcase (match-string 1))))))))
+           (goto-char armor-end)
+           (epa-decrypt-region armor-start armor-end)))))))

 
 ;;;###autoload
 (defun epa-verify-region (start end)
 
 ;;;###autoload
 (defun epa-verify-region (start end)

@@ -701,13 +828,28 @@ Don't use this command in Lisp programs!"
 
 Don't use this command in Lisp programs!"
   (interactive "r")
 
 Don't use this command in Lisp programs!"
   (interactive "r")

-  (let ((context (epg-make-context)))
+  (let ((context (epg-make-context epa-protocol))
+       plain)

     (epg-context-set-progress-callback context
     (epg-context-set-progress-callback context

-                                      #'epa-progress-callback-function)
-    (epg-verify-string context
-                      (encode-coding-string
-                       (buffer-substring start end)
-                       coding-system-for-write))
+                                      #'epa-progress-callback-function
+                                      "Verifying...")
+    (setq plain (epg-verify-string
+                context
+                (epa--encode-coding-string
+                 (buffer-substring start end)
+                 (or coding-system-for-write
+                     (get-text-property start
+                                        'epa-coding-system-used)))))
+    (if (y-or-n-p "Replace the original text? ")
+       (let ((inhibit-read-only t)
+             buffer-read-only)
+         (delete-region start end)
+         (goto-char start)
+         (insert plain))
+       (with-output-to-temp-buffer "*Temp*"
+         (set-buffer standard-output)
+         (insert plain)
+         (epa-info-mode)))

     (if (epg-context-result-for context 'verify)
        (epa-display-info (epg-verify-result-to-string
                           (epg-context-result-for context 'verify))))))
     (if (epg-context-result-for context 'verify)
        (epa-display-info (epg-verify-result-to-string
                           (epg-context-result-for context 'verify))))))

@@ -723,19 +865,25 @@ Don't use this command in Lisp programs!"
     (save-restriction
       (narrow-to-region start end)
       (goto-char start)
     (save-restriction
       (narrow-to-region start end)
       (goto-char start)

-      (let (armor-start armor-end)
+      (let (cleartext-start cleartext-end)

        (while (re-search-forward "-----BEGIN PGP SIGNED MESSAGE-----$"
                                  nil t)
        (while (re-search-forward "-----BEGIN PGP SIGNED MESSAGE-----$"
                                  nil t)

-         (setq armor-start (match-beginning 0))
+         (setq cleartext-start (match-beginning 0))

          (unless (re-search-forward "^-----BEGIN PGP SIGNATURE-----$"
                                           nil t)
            (error "Invalid cleartext signed message"))
          (unless (re-search-forward "^-----BEGIN PGP SIGNATURE-----$"
                                           nil t)
            (error "Invalid cleartext signed message"))

-         (setq armor-end (re-search-forward
+         (setq cleartext-end (re-search-forward

                           "^-----END PGP SIGNATURE-----$"
                           nil t))
                           "^-----END PGP SIGNATURE-----$"
                           nil t))

-         (unless armor-end
-           (error "No armor tail"))
-         (epa-verify-region armor-start armor-end))))))
+         (unless cleartext-end
+           (error "No cleartext tail"))
+         (epa-verify-region cleartext-start cleartext-end))))))
+
+(eval-and-compile
+  (if (fboundp 'select-safe-coding-system)
+      (defalias 'epa--select-safe-coding-system 'select-safe-coding-system)
+    (defun epa--select-safe-coding-system (from to)
+      buffer-file-coding-system)))

 
 ;;;###autoload
 (defun epa-sign-region (start end signers mode)
 
 ;;;###autoload
 (defun epa-sign-region (start end signers mode)

@@ -743,61 +891,122 @@ Don't use this command in Lisp programs!"
 
 Don't use this command in Lisp programs!"
   (interactive
 
 Don't use this command in Lisp programs!"
   (interactive

-   (list (region-beginning) (region-end)
-        (epa-select-keys (epg-make-context) "Select keys for signing.
+   (let ((verbose current-prefix-arg))
+     (setq epa-last-coding-system-specified
+          (or coding-system-for-write
+              (epa--select-safe-coding-system
+               (region-beginning) (region-end))))
+     (list (region-beginning) (region-end)
+          (if verbose
+              (epa-select-keys (epg-make-context epa-protocol)
+                               "Select keys for signing.

 If no one is selected, default secret key is used.  "
 If no one is selected, default secret key is used.  "

-                         nil t)
-        (if (y-or-n-p "Make a detached signature? ")
-            'detached
-          (if (y-or-n-p "Make a cleartext signature? ")
-              'clear))))
+                               nil t))
+          (if verbose
+              (epa--read-signature-type)
+            'clear))))

   (save-excursion
   (save-excursion

-    (let ((context (epg-make-context))
+    (let ((context (epg-make-context epa-protocol))

          signature)
          signature)

-      (epg-context-set-armor context epa-armor)
-      (epg-context-set-textmode context epa-textmode)
+      ;;(epg-context-set-armor context epa-armor)
+      (epg-context-set-armor context t)
+      ;;(epg-context-set-textmode context epa-textmode)
+      (epg-context-set-textmode context t)

       (epg-context-set-signers context signers)
       (epg-context-set-passphrase-callback context
                                           #'epa-passphrase-callback-function)
       (epg-context-set-progress-callback context
       (epg-context-set-signers context signers)
       (epg-context-set-passphrase-callback context
                                           #'epa-passphrase-callback-function)
       (epg-context-set-progress-callback context

-                                        #'epa-progress-callback-function)
+                                        #'epa-progress-callback-function
+                                        "Signing...")

       (message "Signing...")
       (setq signature (epg-sign-string context
       (message "Signing...")
       (setq signature (epg-sign-string context

-                                      (encode-coding-string
+                                      (epa--encode-coding-string

                                        (buffer-substring start end)
                                        (buffer-substring start end)

-                                       coding-system-for-write)
+                                       epa-last-coding-system-specified)

                                       mode))
       (message "Signing...done")
       (delete-region start end)
                                       mode))
       (message "Signing...done")
       (delete-region start end)

-      (insert (decode-coding-string signature coding-system-for-read)))))
+      (goto-char start)
+      (add-text-properties (point)
+                          (progn
+                            (insert (epa--decode-coding-string
+                                     signature
+                                     (or coding-system-for-read
+                                         epa-last-coding-system-specified)))
+                            (point))
+                          (list 'epa-coding-system-used
+                                epa-last-coding-system-specified
+                                'front-sticky nil
+                                'rear-nonsticky t
+                                'start-open t
+                                'end-open t)))))
+
+(eval-and-compile
+  (if (fboundp 'derived-mode-p)
+      (defalias 'epa--derived-mode-p 'derived-mode-p)
+    (defun epa--derived-mode-p (&rest modes)
+      "Non-nil if the current major mode is derived from one of MODES.
+Uses the `derived-mode-parent' property of the symbol to trace backwards."
+      (let ((parent major-mode))
+       (while (and (not (memq parent modes))
+                   (setq parent (get parent 'derived-mode-parent))))
+       parent))))

 
 ;;;###autoload
 
 ;;;###autoload

-(defun epa-encrypt-region (start end recipients)
+(defun epa-encrypt-region (start end recipients sign signers)

   "Encrypt the current region between START and END for RECIPIENTS.
 
 Don't use this command in Lisp programs!"
   (interactive
   "Encrypt the current region between START and END for RECIPIENTS.
 
 Don't use this command in Lisp programs!"
   (interactive

-   (list (region-beginning) (region-end)
-        (epa-select-keys (epg-make-context) "Select recipients for encryption.
-If no one is selected, symmetric encryption will be performed.  ")))
+   (let ((verbose current-prefix-arg)
+        (context (epg-make-context epa-protocol))
+        sign)
+     (setq epa-last-coding-system-specified
+          (or coding-system-for-write
+              (epa--select-safe-coding-system
+               (region-beginning) (region-end))))
+     (list (region-beginning) (region-end)
+          (epa-select-keys context
+                           "Select recipients for encryption.
+If no one is selected, symmetric encryption will be performed.  ")
+          (setq sign (if verbose (y-or-n-p "Sign? ")))
+          (if sign
+              (epa-select-keys context
+                               "Select keys for signing.  ")))))

   (save-excursion
   (save-excursion

-    (let ((context (epg-make-context))
+    (let ((context (epg-make-context epa-protocol))

          cipher)
          cipher)

-      (epg-context-set-armor context epa-armor)
-      (epg-context-set-textmode context epa-textmode)
+      ;;(epg-context-set-armor context epa-armor)
+      (epg-context-set-armor context t)
+      ;;(epg-context-set-textmode context epa-textmode)
+      (epg-context-set-textmode context t)
+      (if sign
+         (epg-context-set-signers context signers))

       (epg-context-set-passphrase-callback context
                                           #'epa-passphrase-callback-function)
       (epg-context-set-progress-callback context
       (epg-context-set-passphrase-callback context
                                           #'epa-passphrase-callback-function)
       (epg-context-set-progress-callback context

-                                        #'epa-progress-callback-function)
+                                        #'epa-progress-callback-function
+                                        "Encrypting...")

       (message "Encrypting...")
       (setq cipher (epg-encrypt-string context
       (message "Encrypting...")
       (setq cipher (epg-encrypt-string context

-                                      (encode-coding-string
+                                      (epa--encode-coding-string

                                        (buffer-substring start end)
                                        (buffer-substring start end)

-                                       coding-system-for-write)
-                                      recipients))
+                                       epa-last-coding-system-specified)
+                                      recipients
+                                      sign))

       (message "Encrypting...done")
       (delete-region start end)
       (message "Encrypting...done")
       (delete-region start end)

-      (insert cipher))))
+      (goto-char start)
+      (add-text-properties (point)
+                          (progn
+                            (insert cipher)
+                            (point))
+                          (list 'epa-coding-system-used
+                                epa-last-coding-system-specified
+                                'front-sticky nil
+                                'rear-nonsticky t
+                                'start-open t
+                                'end-open t)))))

 
 ;;;###autoload
 (defun epa-delete-keys (keys &optional allow-secret)
 
 ;;;###autoload
 (defun epa-delete-keys (keys &optional allow-secret)

@@ -810,7 +1019,7 @@ Don't use this command in Lisp programs!"
        (error "No keys selected"))
      (list keys
           (eq (nth 1 epa-list-keys-arguments) t))))
        (error "No keys selected"))
      (list keys
           (eq (nth 1 epa-list-keys-arguments) t))))

-  (let ((context (epg-make-context)))
+  (let ((context (epg-make-context epa-protocol)))

     (message "Deleting...")
     (epg-delete-keys context keys allow-secret)
     (message "Deleting...done")
     (message "Deleting...")
     (epg-delete-keys context keys allow-secret)
     (message "Deleting...done")

@@ -822,19 +1031,63 @@ Don't use this command in Lisp programs!"
 
 Don't use this command in Lisp programs!"
   (interactive "fFile: ")
 
 Don't use this command in Lisp programs!"
   (interactive "fFile: ")

-  (let ((context (epg-make-context)))
+  (setq file (expand-file-name file))
+  (let ((context (epg-make-context epa-protocol)))

     (message "Importing %s..." (file-name-nondirectory file))
     (condition-case nil
        (progn
     (message "Importing %s..." (file-name-nondirectory file))
     (condition-case nil
        (progn

-         (epg-import-keys-from-file context (expand-file-name file))
+         (epg-import-keys-from-file context file)

          (message "Importing %s...done" (file-name-nondirectory file)))
       (error
        (message "Importing %s...failed" (file-name-nondirectory file))))
     (if (epg-context-result-for context 'import)
        (epa-display-info (epg-import-result-to-string
          (message "Importing %s...done" (file-name-nondirectory file)))
       (error
        (message "Importing %s...failed" (file-name-nondirectory file))))
     (if (epg-context-result-for context 'import)
        (epa-display-info (epg-import-result-to-string

+                          (epg-context-result-for context 'import))))
+    (if (eq major-mode 'epa-key-list-mode)
+       (apply #'epa-list-keys epa-list-keys-arguments))))
+
+;;;###autoload
+(defun epa-import-keys-region (start end)
+  "Import keys from the region.
+
+Don't use this command in Lisp programs!"
+  (interactive "r")
+  (let ((context (epg-make-context epa-protocol)))
+    (message "Importing...")
+    (condition-case nil
+       (progn
+         (epg-import-keys-from-string context (buffer-substring start end))
+         (message "Importing...done"))
+      (error
+       (message "Importing...failed")))
+    (if (epg-context-result-for context 'import)
+       (epa-display-info (epg-import-result-to-string

                           (epg-context-result-for context 'import))))))
 
 ;;;###autoload
                           (epg-context-result-for context 'import))))))
 
 ;;;###autoload

+(defun epa-import-armor-in-region (start end)
+  "Import keys in the OpenPGP armor format in the current region
+between START and END.
+
+Don't use this command in Lisp programs!"
+  (interactive "r")
+  (save-excursion
+    (save-restriction
+      (narrow-to-region start end)
+      (goto-char start)
+      (let (armor-start armor-end)
+       (while (re-search-forward
+               "-----BEGIN \\(PGP \\(PUBLIC\\|PRIVATE\\) KEY BLOCK\\)-----$"
+               nil t)
+         (setq armor-start (match-beginning 0)
+               armor-end (re-search-forward
+                          (concat "^-----END " (match-string 1) "-----$")
+                          nil t))
+         (unless armor-end
+           (error "No armor tail"))
+         (epa-import-keys-region armor-start armor-end))))))
+
+;;;###autoload

 (defun epa-export-keys (keys file)
   "Export selected KEYS to FILE.
 
 (defun epa-export-keys (keys file)
   "Export selected KEYS to FILE.
 

@@ -857,13 +1110,26 @@ Don't use this command in Lisp programs!"
                     ") ")
             (file-name-directory default-name)
             default-name)))))
                     ") ")
             (file-name-directory default-name)
             default-name)))))

-  (let ((context (epg-make-context)))
+  (let ((context (epg-make-context epa-protocol)))

     (epg-context-set-armor context epa-armor)
     (message "Exporting to %s..." (file-name-nondirectory file))
     (epg-export-keys-to-file context keys file)
     (message "Exporting to %s...done" (file-name-nondirectory file))))
 
 ;;;###autoload
     (epg-context-set-armor context epa-armor)
     (message "Exporting to %s..." (file-name-nondirectory file))
     (epg-export-keys-to-file context keys file)
     (message "Exporting to %s...done" (file-name-nondirectory file))))
 
 ;;;###autoload

+(defun epa-insert-keys (keys)
+  "Insert selected KEYS after the point.
+
+Don't use this command in Lisp programs!"
+  (interactive
+   (list (epa-select-keys (epg-make-context epa-protocol)
+                         "Select keys to export.  ")))
+  (let ((context (epg-make-context epa-protocol)))
+    ;;(epg-context-set-armor context epa-armor)
+    (epg-context-set-armor context t)
+    (insert (epg-export-keys-to-string context keys))))
+
+;;;###autoload

 (defun epa-sign-keys (keys &optional local)
   "Sign selected KEYS.
 If a prefix-arg is specified, the signature is marked as non exportable.
 (defun epa-sign-keys (keys &optional local)
   "Sign selected KEYS.
 If a prefix-arg is specified, the signature is marked as non exportable.

@@ -874,11 +1140,12 @@ Don't use this command in Lisp programs!"
      (unless keys
        (error "No keys selected"))
      (list keys current-prefix-arg)))
      (unless keys
        (error "No keys selected"))
      (list keys current-prefix-arg)))

-  (let ((context (epg-make-context)))
+  (let ((context (epg-make-context epa-protocol)))

     (epg-context-set-passphrase-callback context
                                         #'epa-passphrase-callback-function)
     (epg-context-set-progress-callback context
     (epg-context-set-passphrase-callback context
                                         #'epa-passphrase-callback-function)
     (epg-context-set-progress-callback context

-                                      #'epa-progress-callback-function)
+                                      #'epa-progress-callback-function
+                                      "Signing keys...")

     (message "Signing keys...")
     (epg-sign-keys context keys local)
     (message "Signing keys...done")))
     (message "Signing keys...")
     (epg-sign-keys context keys local)
     (message "Signing keys...done")))