;;;; gpgme.lisp

;;; Copyright (C) 2006 g10 Code GmbH

;;;

;;; This file is part of GPGME-CL.

;;;

;;; GPGME-CL is free software; you can redistribute it and/or modify it

;;; under the terms of the GNU General Public License as published by

;;; the Free Software Foundation; either version 2 of the License, or

;;; (at your option) any later version.

;;;

;;; GPGME-CL is distributed in the hope that it will be useful, but

;;; WITHOUT ANY WARRANTY; without even the implied warranty of

;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

;;; Lesser General Public License for more details.

;;;

;;; You should have received a copy of the GNU General Public License

;;; along with GPGME; if not, write to the Free Software Foundation,

;;; Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

;;; TODO

;;; Set up the library.

(in-package :gpgme)

(deftype byte-array ()

  '(simple-array (unsigned-byte 8) (*)))

(deftype character-array ()

  '(simple-array character (*)))

;;; Debugging.

(defvar *debug* nil "If debugging output should be given or not.")

;;; Load the foreign library.

(define-foreign-library libgpgme

  (:unix "libgpgme.so")

  (t (:default "libgpgme")))

(use-foreign-library libgpgme)

;;; System dependencies.

; Access to ERRNO.

(defcfun ("strerror" c-strerror) :string

  (err :int))

(defun get-errno ()

  *errno*)

(defun set-errno (errno)

  (setf *errno* errno))

(define-condition system-error (error)

  ((errno :initarg :errno :reader system-error-errno))

  (:report (lambda (c stream)

	     (format stream "System error: ~A: ~A"

		     (system-error-errno c)

		     (c-strerror (system-error-errno c)))))

  (:documentation "Signalled when an errno is encountered."))

; Needed to write passphrases.

(defcfun ("write" c-write) ssize-t

  (fd :int)

  (buffer :string) ; Actually :pointer, but we only need string.

  (size size-t))

(defun system-write (fd buffer size)

  (let ((res (c-write fd buffer size)))

    (when (< res 0) (error 'system-error :errno (get-errno)))

    res))

;;;

;;; C Interface Definitions

;;;

;;; Data Type Interface

;;; Some new data types used for easier translation.

;;; The number of include certs.  Translates to NIL for default.

(defctype cert-int-t

    (:wrapper :int

     :from-c translate-cert-int-t-from-foreign

     :to-c translate-cert-int-t-to-foreign))

;;; A string that may be NIL to indicate a null pointer.

(defctype string-or-nil-t

    (:wrapper :string

     :to-c translate-string-or-nil-t-to-foreign))

;;; Some opaque data types used by GPGME.

(defctype gpgme-ctx-t

    (:wrapper :pointer

     :to-c translate-gpgme-ctx-t-to-foreign)

  "The GPGME context type.")

(defctype gpgme-data-t

    (:wrapper :pointer

     :to-c translate-gpgme-data-t-to-foreign)

  "The GPGME data object type.")

;;; Wrappers for the libgpg-error library.

(defctype gpgme-error-t

    (:wrapper gpg-error::gpg-error-t

     :from-c translate-gpgme-error-t-from-foreign

     :to-c translate-gpgme-error-t-to-foreign)

  "The GPGME error type.")

(defctype gpgme-error-no-signal-t

    (:wrapper gpg-error::gpg-error-t

     :from-c translate-gpgme-error-no-signal-t-from-foreign)

  "The GPGME error type (this version does not signal conditions in translation.")

(defctype gpgme-err-code-t gpg-error::gpg-err-code-t

  "The GPGME error code type.")

(defctype gpgme-err-source-t gpg-error::gpg-err-source-t

  "The GPGME error source type.")

(defun gpgme-err-make (source code)

  "Construct an error value from an error code and source."

  (gpg-err-make source code))

(defun gpgme-error (code)

  "Construct an error value from an error code."

  (gpgme-err-make :gpg-err-source-gpgme code))

(defun gpgme-err-code (err)

  "Retrieve an error code from the error value ERR."

  (gpg-err-code err))

(defun gpgme-err-source (err)

  "Retrieve an error source from the error value ERR."

  (gpg-err-source err))

(defun gpgme-strerror (err)

  "Return a string containing a description of the error code."

  (gpg-strerror err))

(defun gpgme-strsource (err)

  "Return a string containing a description of the error source."

  (gpg-strsource err))

(defun gpgme-err-code-from-errno (err)

  "Retrieve the error code for the system error.  If the system error

   is not mapped, :gpg-err-unknown-errno is returned."

  (gpg-err-code-from-errno err))

(defun gpgme-err-code-to-errno (code)

  "Retrieve the system error for the error code.  If this is not a

   system error, 0 is returned."

  (gpg-err-code-to-errno code))

(defun gpgme-err-make-from-errno (source err)

  (gpg-err-make-from-errno source err))

(defun gpgme-error-from-errno (err)

  (gpg-error-from-errno err))

;;;

(defcenum gpgme-data-encoding-t

  "The possible encoding mode of gpgme-data-t objects."

  (:none 0)

  (:binary 1)

  (:base64 2)

  (:armor 3)

  (:url 4)

  (:urlesc 5)

  (:url0 6)

  (:mime 7))

;;;

(defcenum gpgme-pubkey-algo-t

  "Public key algorithms from libgcrypt."

  (:rsa 1)

  (:rsa-e 2)

  (:rsa-s 3)

  (:elg-e 16)

  (:dsa 17)

  (:ecc 18)

  (:elg 20)

  (:ecdsa 301)

  (:ecdh 302)

  (:eddsa 303))

(defcenum gpgme-hash-algo-t

  "Hash algorithms from libgcrypt."

  (:none 0)

  (:md5 1)

  (:sha1 2)

  (:rmd160 3)

  (:md2 5)

  (:tiger 6)

  (:haval 7)

  (:sha256 8)

  (:sha384 9)

  (:sha512 10)

  (:sha224 11)

  (:md4 301)

  (:crc32 302)

  (:crc32-rfc1510 303)

  (:crc24-rfc2440 304))

;;;

(defcenum gpgme-sig-mode-t

  "The available signature modes."

  (:none 0)

  (:detach 1)

  (:clear 2))

;;;

(defcenum gpgme-validity-t

  "The available validities for a trust item or key."

  (:unknown 0)

  (:undefined 1)

  (:never 2)

  (:marginal 3)

  (:full 4)

  (:ultimate 5))

;;;

(defcenum gpgme-protocol-t

  "The available protocols."

  (:openpgp 0)

  (:cms 1)

  (:gpgconf 2)

  (:assuan 3)

  (:g13 4)

  (:uiserver 5)

  (:spawn 6)

  (:default 254)

  (:unknown 255))

;;;

(defbitfield (gpgme-keylist-mode-t :unsigned-int)

  "The available keylist mode flags."

  (:local 1)

  (:extern 2)

  (:sigs 4)

  (:sig-notations)

  (:with-secret 16)

  (:with-tofu 32)

  (:ephemeral 128)

  (:validate 256))

;;;

(defbitfield (gpgme-sig-notation-flags-t :unsigned-int)

  "The available signature notation flags."

  (:human-readable 1)

  (:critical 2))

(defctype gpgme-sig-notation-t

    (:wrapper :pointer

     :from-c translate-gpgme-sig-notation-t-from-foreign)

  "Signature notation pointer type.")

;; FIXME: Doesn't this depend on endianness?

(defbitfield (gpgme-sig-notation-bitfield :unsigned-int)

  (:human-readable 1)

  (:critical 2))

(defcstruct gpgme-sig-notation

  "Signature notations."

  (next gpgme-sig-notation-t)

  (name :pointer)

  (value :pointer)

  (name-len :int)

  (value-len :int)

  (flags gpgme-sig-notation-flags-t)

  (bitfield gpgme-sig-notation-bitfield))

;;;

(defcenum gpgme-status-code-t

  "The possible status codes for the edit operation."

  (:eof 0)

  (:enter 1)

  (:leave 2)

  (:abort 3)

  (:goodsig 4)

  (:badsig 5)

  (:errsig 6)

  (:badarmor 7)

  (:rsa-or-idea 8)

  (:keyexpired 9)

  (:keyrevoked 10)

  (:trust-undefined 11)

  (:trust-never 12)

  (:trust-marginal 13)

  (:trust-fully 14)

  (:trust-ultimate 15)

  (:shm-info 16)

  (:shm-get 17)

  (:shm-get-bool 18)

  (:shm-get-hidden 19)

  (:need-passphrase 20)

  (:validsig 21)

  (:sig-id 22)

  (:enc-to 23)

  (:nodata 24)

  (:bad-passphrase 25)

  (:no-pubkey 26)

  (:no-seckey 27)

  (:need-passphrase-sym 28)

  (:decryption-failed 29)

  (:decryption-okay 30)

  (:missing-passphrase 31)

  (:good-passphrase 32)

  (:goodmdc 33)

  (:badmdc 34)

  (:errmdc 35)

  (:imported 36)

  (:import-ok 37)

  (:import-problem 38)

  (:import-res 39)

  (:file-start 40)

  (:file-done 41)

  (:file-error 42)

  (:begin-decryption 43)

  (:end-decryption 44)

  (:begin-encryption 45)

  (:end-encryption 46)

  (:delete-problem 47)

  (:get-bool 48)

  (:get-line 49)

  (:get-hidden 50)

  (:got-it 51)

  (:progress 52)

  (:sig-created 53)

  (:session-key 54)

  (:notation-name 55)

  (:notation-data 56)

  (:policy-url 57)

  (:begin-stream 58)

  (:end-stream 59)

  (:key-created 60)

  (:userid-hint 61)

  (:unexpected 62)

  (:inv-recp 63)

  (:no-recp 64)

  (:already-signed 65)

  (:sigexpired 66)

  (:expsig 67)

  (:expkeysig 68)

  (:truncated 69)

  (:error 70)

  (:newsig 71)

  (:revkeysig 72)

  (:sig-subpacket 73)

  (:need-passphrase-pin 74)

  (:sc-op-failure 75)

  (:sc-op-success 76)

  (:cardctrl 77)

  (:backup-key-created 78)

  (:pka-trust-bad 79)

  (:pka-trust-good 80)

  (:plaintext 81)

  (:inv-sgnr 82)

  (:no-sgnr 83)

  (:success 84)

  (:decryption-info 85)

  (:plaintext-length 86)

  (:mountpoint 87)

  (:pinentry-launched 88)

  (:attribute 89)

  (:begin-signing 90)

  (:key-not-created 91)

  (:inquire-maxlen 92)

  (:failure 93)

  (:key-considered 94)

  (:tofu-user 95)

  (:tofu-stats 96)

  (:tofu-stats-long 97)

  (:notation-flags 98)

  (:decryption-compliance-mode 99)

  (:verification-compliance-mode 100))

;;;

(defctype gpgme-engine-info-t

    (:wrapper :pointer

     :from-c translate-gpgme-engine-info-t-to-foreign)

  "The engine information structure pointer type.")

(defcstruct gpgme-engine-info

  "Engine information."

  (next gpgme-engine-info-t)

  (protocol gpgme-protocol-t)

  (file-name :string)

  (version :string)

  (req-version :string)

  (home-dir :string))

;;;

(defctype gpgme-subkey-t

    (:wrapper :pointer

     :from-c translate-gpgme-subkey-t-from-foreign)

  "A subkey from a key.")

;; FIXME: Doesn't this depend on endianness?

(defbitfield (gpgme-subkey-bitfield :unsigned-int)

  "The subkey bitfield."

  (:revoked 1)

  (:expired 2)

  (:disabled 4)

  (:invalid 8)

  (:can-encrypt 16)

  (:can-sign 32)

  (:can-certify 64)

  (:secret 128)

  (:can-authenticate 256)

  (:is-qualified 512)

  (:is-cardkey 1024)

  (:is-de-vs 2048))

(defcstruct gpgme-subkey

  "Subkey from a key."

  (next gpgme-subkey-t)

  (bitfield gpgme-subkey-bitfield)

  (pubkey-algo gpgme-pubkey-algo-t)

  (length :unsigned-int)

  (keyid :string)

  (-keyid :char :count 17)

  (fpr :string)

  (timestamp :long)

  (expires :long))

(defctype gpgme-key-sig-t

    (:wrapper :pointer

     :from-c translate-gpgme-key-sig-t-from-foreign)

  "A signature on a user ID.")

;; FIXME: Doesn't this depend on endianness?

(defbitfield (gpgme-key-sig-bitfield :unsigned-int)

  "The key signature bitfield."

  (:revoked 1)

  (:expired 2)

  (:invalid 4)

  (:exportable 16))

(defcstruct gpgme-key-sig

  "A signature on a user ID."

  (next gpgme-key-sig-t)

  (bitfield gpgme-key-sig-bitfield)

  (pubkey-algo gpgme-pubkey-algo-t)

  (keyid :string)

  (-keyid :char :count 17)

  (timestamp :long)

  (expires :long)

  (status gpgme-error-no-signal-t)

  (-class :unsigned-int)

  (uid :string)

  (name :string)

  (email :string)

  (comment :string)

  (sig-class :unsigned-int))

(defctype gpgme-user-id-t

    (:wrapper :pointer

     :from-c translate-gpgme-user-id-t-from-foreign)

  "A user ID from a key.")

;; FIXME: Doesn't this depend on endianness?

(defbitfield (gpgme-user-id-bitfield :unsigned-int)

  "The user ID bitfield."

  (:revoked 1)

  (:invalid 2))

(defcstruct gpgme-user-id

  "A user ID from a key."

  (next gpgme-user-id-t)

  (bitfield gpgme-user-id-bitfield)

  (validity gpgme-validity-t)

  (uid :string)

  (name :string)

  (email :string)

  (comment :string)

  (signatures gpgme-key-sig-t)

  (-last-keysig gpgme-key-sig-t))

(defctype gpgme-key-t

    (:wrapper :pointer

     :from-c translate-gpgme-key-t-from-foreign

     :to-c translate-gpgme-key-t-to-foreign)

  "A key from the keyring.")

;; FIXME: Doesn't this depend on endianness?

(defbitfield (gpgme-key-bitfield :unsigned-int)

  "The key bitfield."

  (:revoked 1)

  (:expired 2)

  (:disabled 4)

  (:invalid 8)

  (:can-encrypt 16)

  (:can-sign 32)

  (:can-certify 64)

  (:secret 128)

  (:can-authenticate 256)

  (:is-qualified 512))

(defcstruct gpgme-key

  "A signature on a user ID."

  (-refs :unsigned-int)

  (bitfield gpgme-key-bitfield)

  (protocol gpgme-protocol-t)

  (issuer-serial :string)

  (issuer-name :string)

  (chain-id :string)

  (owner-trust gpgme-validity-t)

  (subkeys gpgme-subkey-t)

  (uids gpgme-user-id-t)

  (-last-subkey gpgme-subkey-t)

  (-last-uid gpgme-user-id-t)

  (keylist-mode gpgme-keylist-mode-t))

;;;

;;; There is no support in CFFI to define callback C types and have

;;; automatic type checking with the callback definition.

(defctype gpgme-passphrase-cb-t :pointer)

(defctype gpgme-progress-cb-t :pointer)

(defctype gpgme-edit-cb-t :pointer)

;;;

;;; Function Interface

;;;

;;; Context management functions.

(defcfun ("gpgme_new" c-gpgme-new) gpgme-error-t

  (ctx :pointer))

(defcfun ("gpgme_release" c-gpgme-release) :void

  (ctx gpgme-ctx-t))

(defcfun ("gpgme_set_protocol" c-gpgme-set-protocol) gpgme-error-t

  (ctx gpgme-ctx-t)

  (proto gpgme-protocol-t))

(defcfun ("gpgme_get_protocol" c-gpgme-get-protocol) gpgme-protocol-t

  (ctx gpgme-ctx-t))

(defcfun ("gpgme_get_protocol_name" c-gpgme-get-protocol-name) :string

  (proto gpgme-protocol-t))

(defcfun ("gpgme_set_armor" c-gpgme-set-armor) :void

  (ctx gpgme-ctx-t)

  (yes :boolean))

(defcfun ("gpgme_get_armor" c-gpgme-get-armor) :boolean

  (ctx gpgme-ctx-t))

(defcfun ("gpgme_set_textmode" c-gpgme-set-textmode) :void

  (ctx gpgme-ctx-t)

  (yes :boolean))

(defcfun ("gpgme_get_textmode" c-gpgme-get-textmode) :boolean

  (ctx gpgme-ctx-t))

(defconstant +include-certs-default+ -256)

(defcfun ("gpgme_set_include_certs" c-gpgme-set-include-certs) :void

  (ctx gpgme-ctx-t)

  (nr-of-certs cert-int-t))

(defcfun ("gpgme_get_include_certs" c-gpgme-get-include-certs) cert-int-t

  (ctx gpgme-ctx-t))

(defcfun ("gpgme_set_keylist_mode" c-gpgme-set-keylist-mode) gpgme-error-t

  (ctx gpgme-ctx-t)

  (mode gpgme-keylist-mode-t))

(defcfun ("gpgme_get_keylist_mode" c-gpgme-get-keylist-mode)

    gpgme-keylist-mode-t

  (ctx gpgme-ctx-t))

(defcfun ("gpgme_set_passphrase_cb" c-gpgme-set-passphrase-cb) :void

  (ctx gpgme-ctx-t)

  (cb gpgme-passphrase-cb-t)

  (hook-value :pointer))

(defcfun ("gpgme_get_passphrase_cb" c-gpgme-get-passphrase-cb) :void

  (ctx gpgme-ctx-t)

  (cb-p :pointer)

  (hook-value-p :pointer))

(defcfun ("gpgme_set_progress_cb" c-gpgme-set-progress-cb) :void

  (ctx gpgme-ctx-t)

  (cb gpgme-progress-cb-t)

  (hook-value :pointer))

(defcfun ("gpgme_get_progress_cb" c-gpgme-get-progress-cb) :void

  (ctx gpgme-ctx-t)

  (cb-p :pointer)

  (hook-value-p :pointer))

(defcfun ("gpgme_set_locale" c-gpgme-set-locale) gpgme-error-t

  (ctx gpgme-ctx-t)

  (category :int)

  (value string-or-nil-t))

(defcfun ("gpgme_ctx_get_engine_info" c-gpgme-ctx-get-engine-info)

    gpgme-engine-info-t

  (ctx gpgme-ctx-t))

(defcfun ("gpgme_ctx_set_engine_info" c-gpgme-ctx-set-engine-info)

    gpgme-error-t

  (ctx gpgme-ctx-t)

  (proto gpgme-protocol-t)

  (file-name string-or-nil-t)

  (home-dir string-or-nil-t))

;;;

(defcfun ("gpgme_pubkey_algo_name" c-gpgme-pubkey-algo-name) :string

  (algo gpgme-pubkey-algo-t))

(defcfun ("gpgme_hash_algo_name" c-gpgme-hash-algo-name) :string

  (algo gpgme-hash-algo-t))

;;;

(defcfun ("gpgme_signers_clear" c-gpgme-signers-clear) :void

  (ctx gpgme-ctx-t))

(defcfun ("gpgme_signers_add" c-gpgme-signers-add) gpgme-error-t

  (ctx gpgme-ctx-t)

  (key gpgme-key-t))

(defcfun ("gpgme_signers_enum" c-gpgme-signers-enum) gpgme-key-t

  (ctx gpgme-ctx-t)

  (seq :int))

;;;

(defcfun ("gpgme_sig_notation_clear" c-gpgme-sig-notation-clear) :void

  (ctx gpgme-ctx-t))

(defcfun ("gpgme_sig_notation_add" c-gpgme-sig-notation-add) gpgme-error-t

  (ctx gpgme-ctx-t)

  (name :string)

  (value string-or-nil-t)

  (flags gpgme-sig-notation-flags-t))

(defcfun ("gpgme_sig_notation_get" c-gpgme-sig-notation-get)

    gpgme-sig-notation-t

  (ctx gpgme-ctx-t))

;;; Run Control.

;;; There is no support in CFFI to define callback C types and have

;;; automatic type checking with the callback definition.

(defctype gpgme-io-cb-t :pointer)

(defctype gpgme-register-io-cb-t :pointer)

(defctype gpgme-remove-io-cb-t :pointer)

(defcenum gpgme-event-io-t

  "The possible events on I/O event callbacks."

  (:start 0)

  (:done 1)

  (:next-key 2)

  (:next-trustitem 3))

(defctype gpgme-event-io-cb-t :pointer)

(defcstruct gpgme-io-cbs

  "I/O callbacks."

  (add gpgme-register-io-cb-t)

  (add-priv :pointer)

  (remove gpgme-remove-io-cb-t)

  (event gpgme-event-io-cb-t)

  (event-priv :pointer))

(defctype gpgme-io-cbs-t :pointer)

(defcfun ("gpgme_set_io_cbs" c-gpgme-set-io-cbs) :void

  (ctx gpgme-ctx-t)

  (io-cbs gpgme-io-cbs-t))

(defcfun ("gpgme_get_io_cbs" c-gpgme-get-io-cbs) :void

  (ctx gpgme-ctx-t)

  (io-cbs gpgme-io-cbs-t))

(defcfun ("gpgme_wait" c-gpgme-wait) gpgme-ctx-t

  (ctx gpgme-ctx-t)

  (status-p :pointer)

  (hang :int))

;;; Functions to handle data objects.

;;; There is no support in CFFI to define callback C types and have

;;; automatic type checking with the callback definition.

(defctype gpgme-data-read-cb-t :pointer)

(defctype gpgme-data-write-cb-t :pointer)

(defctype gpgme-data-seek-cb-t :pointer)

(defctype gpgme-data-release-cb-t :pointer)

(defcstruct gpgme-data-cbs

  "Data callbacks."

  (read gpgme-data-read-cb-t)

  (write gpgme-data-write-cb-t)

  (seek gpgme-data-seek-cb-t)

  (release gpgme-data-release-cb-t))

(defctype gpgme-data-cbs-t :pointer

  "Data callbacks pointer.")

(defcfun ("gpgme_data_read" c-gpgme-data-read) ssize-t

  (dh gpgme-data-t)

  (buffer :pointer)

  (size size-t))

(defcfun ("gpgme_data_write" c-gpgme-data-write) ssize-t

  (dh gpgme-data-t)

  (buffer :pointer)

  (size size-t))

(defcfun ("gpgme_data_seek" c-gpgme-data-seek) off-t

  (dh gpgme-data-t)

  (offset off-t)

  (whence :int))

(defcfun ("gpgme_data_new" c-gpgme-data-new) gpgme-error-t

  (dh-p :pointer))

(defcfun ("gpgme_data_release" c-gpgme-data-release) :void

  (dh gpgme-data-t))

(defcfun ("gpgme_data_new_from_mem" c-gpgme-data-new-from-mem) gpgme-error-t

  (dh-p :pointer)

  (buffer :pointer)

  (size size-t)

  (copy :int))

(defcfun ("gpgme_data_release_and_get_mem" c-gpgme-data-release-and-get-mem)

    :pointer

  (dh gpgme-data-t)

  (len-p :pointer))

(defcfun ("gpgme_data_new_from_cbs" c-gpgme-data-new-from-cbs) gpgme-error-t

  (dh-p :pointer)

  (cbs gpgme-data-cbs-t)

  (handle :pointer))

(defcfun ("gpgme_data_new_from_fd" c-gpgme-data-new-from-fd) gpgme-error-t

  (dh-p :pointer)

  (fd :int))

(defcfun ("gpgme_data_new_from_stream" c-gpgme-data-new-from-stream)

    gpgme-error-t

  (dh-p :pointer)

  (stream :pointer))

(defcfun ("gpgme_data_get_encoding" c-gpgme-data-get-encoding)

    gpgme-data-encoding-t

  (dh gpgme-data-t))

(defcfun ("gpgme_data_set_encoding" c-gpgme-data-set-encoding)

    gpgme-error-t

  (dh gpgme-data-t)

  (enc gpgme-data-encoding-t))

(defcfun ("gpgme_data_get_file_name" c-gpgme-data-get-file-name) :string

  (dh gpgme-data-t))

(defcfun ("gpgme_data_set_file_name" c-gpgme-data-set-file-name) gpgme-error-t

  (dh gpgme-data-t)

  (file-name string-or-nil-t))

(defcfun ("gpgme_data_new_from_file" c-gpgme-data-new-from-file) gpgme-error-t

  (dh-p :pointer)

  (fname :string)

  (copy :int))

(defcfun ("gpgme_data_new_from_filepart" c-gpgme-data-new-from-filepart)

    gpgme-error-t

  (dh-p :pointer)

  (fname :string)

  (fp :pointer)

  (offset off-t)

  (length size-t))

;;; Key and trust functions.

(defcfun ("gpgme_get_key" c-gpgme-get-key) gpgme-error-t

  (ctx gpgme-ctx-t)

  (fpr :string)

  (key-p :pointer)

  (secret :boolean))

(defcfun ("gpgme_key_ref" c-gpgme-key-ref) :void

  (key gpgme-key-t))

(defcfun ("gpgme_key_unref" c-gpgme-key-unref) :void

  (key gpgme-key-t))

;;; Crypto operations.

(defcfun ("gpgme_cancel" c-gpgme-cancel) gpgme-error-t

  (ctx gpgme-ctx-t))

;;;

(defctype gpgme-invalid-key-t

    (:wrapper :pointer

     :from-c translate-gpgme-invalid-key-t-from-foreign)

  "An invalid key structure.")

(defcstruct gpgme-invalid-key

  "An invalid key structure."

  (next gpgme-invalid-key-t)

  (fpr :string)

  (reason gpgme-error-no-signal-t))

;;; Encryption.

(defcstruct gpgme-op-encrypt-result

  "Encryption result structure."

  (invalid-recipients gpgme-invalid-key-t))

(defctype gpgme-op-encrypt-result-t

    (:wrapper :pointer

     :from-c translate-gpgme-op-encrypt-result-t-from-foreign)

  "An encryption result structure.")

(defcfun ("gpgme_op_encrypt_result" c-gpgme-op-encrypt-result)

    gpgme-op-encrypt-result-t

  (ctx gpgme-ctx-t))

(defbitfield gpgme-encrypt-flags-t

  (:always-trust 1)

  (:no-encrypt-to 2)

  (:prepare 4)

  (:expect-sign 8)

  (:no-compress 16)

  (:symmetric 32)

  (:throw-keyids 64)

  (:wrap 128)

  (:want-address 256))

(defcfun ("gpgme_op_encrypt_start" c-gpgme-op-encrypt-start) gpgme-error-t

  (ctx gpgme-ctx-t)

  (recp :pointer) ; Key array.

  (flags gpgme-encrypt-flags-t)

  (plain gpgme-data-t)

  (cipher gpgme-data-t))

(defcfun ("gpgme_op_encrypt" c-gpgme-op-encrypt) gpgme-error-t

  (ctx gpgme-ctx-t)

  (recp :pointer) ; Key array.

  (flags gpgme-encrypt-flags-t)

  (plain gpgme-data-t)

  (cipher gpgme-data-t))

(defcfun ("gpgme_op_encrypt_sign_start" c-gpgme-op-encrypt-sign-start)