dino/vapi/gpgme.vapi

/* libgpgme.vapi
 *
 * Copyright (C) 2009 Sebastian Reichel <sre@ring0.de>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */

/**
 * GPGME is an API wrapper around GnuPG, which parses the output of GnuPG.
 */
[CCode (lower_case_cprefix = "gpgme_", cheader_filename = "gpgme.h")]
namespace GPG {
    /**
     * EngineInfo as List
     */
    [CCode (cname = "struct _gpgme_engine_info")]
    public struct EngineInfo {
        /**
         * Next entry in the list
         */
        EngineInfo* next;

        /**
         * The protocol ID
         */
        Protocol protocol;

        /**
         * filename of the engine binary
         */
        string file_name;

        /**
         * version string of the installed binary
         */
        string version;

        /**
         * minimum version required for gpgme
         */
        string req_version;

        /**
         * home directory to be used or null for default
         */
        string? home_dir;
    }

    /**
     * A Key from the Keyring
     */
    [CCode (cname = "struct _gpgme_key", ref_function = "gpgme_key_ref", ref_function_void = true, unref_function = "gpgme_key_unref", free_function = "gpgme_key_release")]
    public class Key {
        public bool revoked;
        public bool expired;
        public bool disabled;
        public bool invalid;
        public bool can_encrypt;
        public bool can_sign;
        public bool can_certify;
        public bool secret;
        public bool can_authenticate;
        public bool is_qualified;
        public Protocol protocol;

        /**
         * If protocol is CMS, this string contains the issuer's serial
         */
        public string issuer_serial;

        /**
         * If protocol is CMS, this string contains the issuer's name
         */
        public string issuer_name;

        /**
         * If protocol is CMS, this string contains the issuer's ID
         */
        public string issuer_id;

        /**
         * If protocol is OpenPGP, this field contains the owner trust level
         */
        public Validity owner_trust;

        /**
         * The key's subkeys
         */
        [CCode(array_null_terminated = true)]
        public SubKey[] subkeys;

        /**
         * The key's user ids
         */
        [CCode(array_null_terminated = true)]
        public UserID[] uids;

        public KeylistMode keylist_mode;
    }

    /**
     * A signature notation
     */
    [CCode (cname = "struct _gpgme_sig_notation")]
    public struct SigNotation {
        /**
         * The next SigNotation from the list
         */
        SigNotation* next;

        /**
         * If name is a null pointer value contains a policy url rather than a notation
         */
        string? name;

        /**
         * The value of the notation data
         */
        string value;

        /**
         * The length of the name of the notation data
         */
        int name_len;

        /**
         * The length of the value of the notation data
         */
        int value_len;

        /**
         * The accumulated flags
         */
        SigNotationFlags flags;

        /**
         * notation data is human readable
         */
        bool human_readable;

        /**
         * notation data is critical
         */
        bool critical;
    }

    /**
     * A subkey from a Key
     */
    [CCode (cname = "struct _gpgme_subkey")]
    public struct SubKey {
        SubKey* next;
        bool revoked;
        bool expired;
        bool disabled;
        bool invalid;
        bool can_encrypt;
        bool can_sign;
        bool can_certify;
        bool secret;
        bool can_authenticate;
        bool is_qualified;
        bool is_cardkey;
        PublicKeyAlgorithm algo;
        uint length;
        string keyid;

        /**
         * Fingerprint of the key in hex form
         */
        string fpr;

        /**
         * The creation timestamp.
         * -1 = invalid,
         * 0 = not available
         */
        long timestamp;

        /**
         * The expiration timestamp.
         * 0 = key does not expire
         */
        long expires;

        /**
         * The serial number of the smartcard holding this key or null
         */
        string? cardnumber;
    }

    /**
     * A signature on a UserID
     */
    [CCode (cname = "struct _gpgme_key_sig")]
    public struct KeySig {
        /**
         * The next signature from the list
         */
        KeySig* next;
        bool invoked;
        bool expired;
        bool invalid;
        bool exportable;
        PublicKeyAlgorithm algo;
        string keyid;

        /**
         * The creation timestamp.
         * -1 = invalid,
         * 0 = not available
         */
        long timestamp;

        /**
         * The expiration timestamp.
         * 0 = key does not expire
         */
        long expires;

        GPGError.ErrorCode status;

        string uid;
        string name;
        string email;
        string comment;

        /**
         * Crypto backend specific signature class
         */
        uint sig_class;

        SigNotation notations;
    }

    /**
     * A UserID from a Key
     */
    [CCode (cname = "struct _gpgme_user_id")]
    public struct UserID {
        /**
         * The next UserID from the list
         */
        UserID* next;

        bool revoked;
        bool invalid;
        Validity validity;
        string uid;
        string name;
        string email;
        string comment;

        KeySig signatures;
    }

    /**
     * verify result of OP
     */
    [CCode (cname = "struct _gpgme_op_verify_result")]
    public struct VerifyResult {
        Signature* signatures;

        /**
         * The original file name of the plaintext message, if available
         */
        string? file_name;
    }

    /**
     * sign result of OP
     */
    [CCode (cname = "struct _gpgme_op_sign_result")]
    public struct SignResult {
        InvalidKey invalid_signers;
        Signature* signatures;
    }

    /**
     * encrypt result of OP
     */
    [CCode (cname = "struct _gpgme_op_encrypt_result")]
    public struct EncryptResult {
        /**
         * The list of invalid repipients
         */
        InvalidKey invalid_signers;
    }

    /**
     * decrypt result of OP
     */
    [CCode (cname = "struct _gpgme_op_decrypt_result")]
    public struct DecryptResult {
        string unsupported_algorithm;
        bool wrong_key_usage;
        Recipient recipients;
        string filename;
    }

    /**
     * An receipient
     */
    [CCode (cname = "struct _gpgme_recipient")]
    public struct Recipient {
        Recipient *next;
        string keyid;
        PublicKeyAlgorithm pubkey_algo;
        GPGError.ErrorCode status;
    }

    /**
     * list of invalid keys
     */
    [CCode (cname = "struct _gpgme_invalid_key")]
    public struct InvalidKey {
        InvalidKey *next;
        string fpr;
        GPGError.ErrorCode reason;
    }

    /**
     * A Signature
     */
    [CCode (cname = "struct _gpgme_signature")]
    public struct Signature {
        /**
         * The next signature in the list
         */
        Signature *next;

        /**
         * A summary of the signature status
         */
        Sigsum summary;

        /**
         * Fingerprint or key ID of the signature
         */
        string fpr;

        /**
         * The Error status of the signature
         */
        GPGError.ErrorCode status;

        /**
         * Notation data and policy URLs
         */
        SigNotation notations;

        /**
         * Signature creation time
         */
        ulong timestamp;

        /**
         * Signature expiration time or 0
         */
        ulong exp_timestamp;

        /**
         * Key should not have been used for signing
         */
        bool wrong_key_usage;

        /**
         * PKA status
         */
        PKAStatus pka_trust;

        /**
         * Validity has been verified using the chain model
         */
        bool chain_model;

        /**
         * Validity
         */
        Validity validity;

        /**
         * Validity reason
         */
        GPGError.ErrorCode validity_reason;

        /**
         * public key algorithm used to create the signature
         */
        PublicKeyAlgorithm pubkey_algo;

        /**
         * The hash algorithm used to create the signature
         */
        HashAlgorithm hash_algo;

        /**
         * The mailbox from the PKA information or null
         */
        string? pka_adress;
    }

    /**
     * PKA Status
     */
    public enum PKAStatus {
        NOT_AVAILABLE,
        BAD,
        OKAY,
        RFU
    }

    /**
     * Flags used for the summary field in a Signature
     */
    [CCode (cname = "gpgme_sigsum_t", cprefix = "GPGME_SIGSUM_")]
    public enum Sigsum {
        /**
         * The signature is fully valid
         */
        VALID,

        /**
         * The signature is good
         */
        GREEN,

        /**
         * The signature is bad
         */
        RED,

        /**
         * One key has been revoked
         */
        KEY_REVOKED,

        /**
         * One key has expired
         */
        KEY_EXPIRED,

        /**
         * The signature has expired
         */
        SIG_EXPIRED,

        /**
         * Can't verfiy - missing key
         */
        KEY_MISSING,

        /**
         * CRL not available
         */
        CRL_MISSING,

        /**
         * Available CRL is too old
         */
        CRL_TOO_OLD,

        /**
         * A policy was not met
         */
        BAD_POLICY,

        /**
         * A system error occured
         */
        SYS_ERROR
    }

    /**
     * Encoding modes of Data objects
     */
    [CCode (cname = "gpgme_data_encoding_t", cprefix = "GPGME_DATA_ENCODING_")]
    public enum DataEncoding {
        /**
         * Not specified
         */
        NONE,
        /**
         * Binary encoded
         */
        BINARY,
        /**
         * Base64 encoded
         */
        BASE64,
        /**
         * Either PEM or OpenPGP Armor
         */
        ARMOR,
        /**
         * LF delimited URL list
         */
        URL,
        /**
         * LF percent escaped, delimited URL list
         */
        URLESC,
        /**
         * Nul determined URL list
         */
        URL0
    }

    /**
     * Public Key Algorithms from libgcrypt
     */
    [CCode (cname = "gpgme_pubkey_algo_t", cprefix = "GPGME_PK_")]
    public enum PublicKeyAlgorithm {
        RSA,
        RSA_E,
        RSA_S,
        ELG_E,
        DSA,
        ELG
    }

    /**
     * Hash Algorithms from libgcrypt
     */
    [CCode (cname = "gpgme_hash_algo_t", cprefix = "GPGME_MD_")]
    public enum HashAlgorithm {
        NONE,
        MD5,
        SHA1,
        RMD160,
        MD2,
        TIGER,
        HAVAL,
        SHA256,
        SHA384,
        SHA512,
        MD4,
        MD_CRC32,
        MD_CRC32_RFC1510,
        MD_CRC24_RFC2440
    }

    /**
     * Signature modes
     */
    [CCode (cname = "gpgme_sig_mode_t", cprefix = "GPGME_SIG_MODE_")]
    public enum SigMode {
        NORMAL,
        DETACH,
        CLEAR
    }

    /**
     * Validities for a trust item or key
     */
    [CCode (cname = "gpgme_validity_t", cprefix = "GPGME_VALIDITY_")]
    public enum Validity {
        UNKNOWN,
        UNDEFINED,
        NEVER,
        MARGINAL,
        FULL,
        ULTIMATE
    }

    /**
     * Protocols
     */
    [CCode (cname = "gpgme_protocol_t", cprefix = "GPGME_PROTOCOL_")]
    public enum Protocol {
        /**
         * Default Mode
         */
        OpenPGP,
        /**
         * Cryptographic Message Syntax
         */
        CMS,
        /**
         * Special code for gpgconf
         */
        GPGCONF,
        /**
         * Low-level access to an Assuan server
         */
        ASSUAN,
        UNKNOWN
    }

    /**
     * Keylist modes used by Context
     */
    [CCode (cname = "gpgme_keylist_mode_t", cprefix = "GPGME_KEYLIST_MODE_")]
    public enum KeylistMode {
        LOCAL,
        EXTERN,
        SIGS,
        SIG_NOTATIONS,
        EPHEMERAL,
        VALIDATE
    }

    /**
     * Export modes used by Context
     */
    [CCode (cname = "gpgme_export_mode_t", cprefix = "GPGME_EXPORT_MODE_")]
    public enum ExportMode {
        EXTERN
    }

    /**
     * Audit log function flags
     */
    [CCode (cprefix = "GPGME_AUDITLOG_")]
    public enum AuditLogFlag {
        HTML,
        WITH_HELP
    }

    /**
     * Signature notation flags
     */
    [CCode (cname = "gpgme_sig_notation_flags_t", cprefix = "GPGME_SIG_NOTATION_")]
    public enum SigNotationFlags {
        HUMAN_READABLE,
        CRITICAL
    }

    /**
     * Encryption Flags
     */
    [CCode (cname = "gpgme_encrypt_flags_t", cprefix = "GPGME_ENCRYPT_")]
    public enum EncryptFlags {
        ALWAYS_TRUST,
        NO_ENCRYPT_TO
    }

    /**
     * Edit Operation Stati
     */
    [CCode (cname = "gpgme_status_code_t", cprefix = "GPGME_STATUS_")]
    public enum StatusCode {
        EOF,
        ENTER,
        LEAVE,
        ABORT,
        GOODSIG,
        BADSIG,
        ERRSIG,
        BADARMOR,
        RSA_OR_IDEA,
        KEYEXPIRED,
        KEYREVOKED,
        TRUST_UNDEFINED,
        TRUST_NEVER,
        TRUST_MARGINAL,
        TRUST_FULLY,
        TRUST_ULTIMATE,
        SHM_INFO,
        SHM_GET,
        SHM_GET_BOOL,
        SHM_GET_HIDDEN,
        NEED_PASSPHRASE,
        VALIDSIG,
        SIG_ID,
        SIG_TO,
        ENC_TO,
        NODATA,
        BAD_PASSPHRASE,
        NO_PUBKEY,
        NO_SECKEY,
        NEED_PASSPHRASE_SYM,
        DECRYPTION_FAILED,
        DECRYPTION_OKAY,
        MISSING_PASSPHRASE,
        GOOD_PASSPHRASE,
        GOODMDC,
        BADMDC,
        ERRMDC,
        IMPORTED,
        IMPORT_OK,
        IMPORT_PROBLEM,
        IMPORT_RES,
        FILE_START,
        FILE_DONE,
        FILE_ERROR,
        BEGIN_DECRYPTION,
        END_DECRYPTION,
        BEGIN_ENCRYPTION,
        END_ENCRYPTION,
        DELETE_PROBLEM,
        GET_BOOL,
        GET_LINE,
        GET_HIDDEN,
        GOT_IT,
        PROGRESS,
        SIG_CREATED,
        SESSION_KEY,
        NOTATION_NAME,
        NOTATION_DATA,
        POLICY_URL,
        BEGIN_STREAM,
        END_STREAM,
        KEY_CREATED,
        USERID_HINT,
        UNEXPECTED,
        INV_RECP,
        NO_RECP,
        ALREADY_SIGNED,
        SIGEXPIRED,
        EXPSIG,
        EXPKEYSIG,
        TRUNCATED,
        ERROR,
        NEWSIG,
        REVKEYSIG,
        SIG_SUBPACKET,
        NEED_PASSPHRASE_PIN,
        SC_OP_FAILURE,
        SC_OP_SUCCESS,
        CARDCTRL,
        BACKUP_KEY_CREATED,
        PKA_TRUST_BAD,
        PKA_TRUST_GOOD,
        PLAINTEXT
    }

    /**
     * The Context object represents a GPG instance
     */
    [Compact]
    [CCode (cname = "struct gpgme_context", free_function = "gpgme_release", cprefix = "gpgme_")]
    public class Context {
        /**
         * Create a new context, returns Error Status Code
         */
        [CCode (cname = "gpgme_new")]
        public static GPGError.ErrorCode Context(out Context ctx);

        public GPGError.ErrorCode set_protocol(Protocol p);
        public Protocol get_protocol();

        public void set_armor(bool yes);
        public bool get_armor();

        public void set_textmode(bool yes);
        public bool get_textmode();

        public GPGError.ErrorCode set_keylist_mode(KeylistMode mode);
        public KeylistMode get_keylist_mode();

        /**
         * Include up to nr_of_certs certificates in an S/MIME message,
         * Use "-256" to use the backend's default.
         */
        public void set_include_certs(int nr_of_certs = -256);

        /**
         * Return the number of certs to include in an S/MIME message
         */
        public int get_include_certs();

        /**
         * Set callback function for requesting passphrase. hook_value will be
         * passed as first argument.
         */
        public void set_passphrase_cb(passphrase_callback cb, void* hook_value = null);

        /**
         * Get callback function and hook_value
         */
        public void get_passphrase_cb(out passphrase_callback cb, out void* hook_value);

        public GPGError.ErrorCode set_locale(int category, string val);

        /**
         * Get information about the configured engines. The returned data is valid
         * until the next set_engine_info() call.
         */
        [CCode (cname = "gpgme_ctx_get_engine_info")]
        public EngineInfo* get_engine_info();

        /**
         * Set information about the configured engines. The string parameters may not
         * be free'd after this calls, because they are not copied.
         */
        [CCode (cname = "gpgme_ctx_set_engine_info")]
        public GPGError.ErrorCode set_engine_info(Protocol proto, string file_name, string home_dir);

        /**
         * Delete all signers
         */
        public void signers_clear();

        /**
         * Add key to list of signers
         */
        public GPGError.ErrorCode signers_add(Key key);

        /**
         * Get the n-th signer's key
         */
        public Key* signers_enum(int n);

        /**
         * Clear all notation data
         */
        public void sig_notation_clear();

        /**
         * Add human readable notation data. If name is null,
         * then value val should be a policy URL. The HUMAN_READABLE
         * flag is forced to be true for notation data and false
         * for policy URLs.
         */
        public GPGError.ErrorCode sig_notation_add(string name, string val, SigNotationFlags flags);

        /**
         * Get sig notations
         */
        public SigNotation* sig_notation_get();

        /**
         * Get key with the fingerprint FPR from the crypto backend.
         * If SECRET is true, get the secret key.
         */
        public GPGError.ErrorCode get_key(string fpr, out Key key, bool secret);

        /**
         * process the pending operation and, if hang is true, wait for
         * the pending operation to finish.
         */
        public Context* wait(out GPGError.ErrorCode status, bool hang);

        /**
         * Retrieve a pointer to the results of the signing operation
         */
        public SignResult* op_sign_result();

        /**
         * Sign the plaintext PLAIN and store the signature in SIG.
         */
        public GPGError.ErrorCode op_sign(Data plain, Data sig, SigMode mode);

        /**
         * Retrieve a pointer to the result of the verify operation
         */
        public VerifyResult* op_verify_result();

        /**
         * Verify that SIG is a valid signature for SIGNED_TEXT.
         */
        public GPGError.ErrorCode op_verify(Data sig, Data signed_text, Data? plaintext);

        /**
         * Retrieve a pointer to the result of the encrypt operation
         */
        public EncryptResult* op_encrypt_result();

        /**
         * Encrypt plaintext PLAIN for the recipients RECP and store the
         * resulting ciphertext in CIPHER.
         */
        public GPGError.ErrorCode op_encrypt([CCode (array_length = false)] Key[] recp, EncryptFlags flags, Data plain, Data cipher);

        /**
         * Retrieve a pointer to the result of the decrypt operation
         */
        public DecryptResult* op_decrypt_result();

        /**
         * Decrypt ciphertext CIPHER and store the resulting plaintext
         * in PLAIN.
         */
        public GPGError.ErrorCode op_decrypt(Data cipher, Data plain);

        /**
         * Export the keys found by PATTERN into KEYDATA. If PATTERN is
         * NULL all keys will be exported.
         */
        public GPGError.ErrorCode op_export(string? pattern, ExportMode mode, Data keydata);

        /**
         * Import the keys in KEYDATA.
         */
        public GPGError.ErrorCode op_import(Data keydata);

        /**
         * Get result of last op_import.
         */
        public unowned ImportResult op_import_result();

        /**
         * Initiates a key listing operation. It sets everything up, so that
         * subsequent invocations of op_keylist_next() return the keys in the list.
         *
         * If pattern is NULL, all available keys are returned. Otherwise, pattern
         * contains an engine specific expression that is used to limit the list to
         * all keys matching the pattern.
         *
         * If secret_only is not 0, the list is restricted to secret keys only.
         *
         * The context will be busy until either all keys are received (and
         * op_keylist_next() returns GPG_ERR_EOF), or gpgme_op_keylist_end is called
         * to finish the operation.
         *
         * The function returns the error code GPG_ERR_INV_VALUE if ctx is not a valid
         * pointer, and passes through any errors that are reported by the crypto engine
         * support routines.
         */
        public GPGError.ErrorCode op_keylist_start(string? pattern = null, int secret_only = 0);

        /**
         * returns the next key in the list created by a previous op_keylist_start()
         * operation in the context ctx. The key will have one reference for the user.
         *
         * If the last key in the list has already been returned, op_keylist_next()
         * returns GPG_ERR_EOF.
         *
         * The function returns the error code GPG_ERR_INV_VALUE if ctx or r_key is
         * not a valid pointer, and GPG_ERR_ENOMEM if there is not enough memory for
         * the operation.
         */
        public GPGError.ErrorCode op_keylist_next(out Key key);

        /**
         * ends a pending key list operation in the context.
         *
         * After the operation completed successfully, the result of the key listing
         * operation can be retrieved with op_keylist_result().
         *
         * The function returns the error code GPG_ERR_INV_VALUE if ctx is not a valid
         * pointer, and GPG_ERR_ENOMEM if at some time during the operation there was
         * not enough memory available.
         */
        public GPGError.ErrorCode op_keylist_end();

        /**
         * The function op_keylist_result() returns a KeylistResult holding the result of
         * a op_keylist_*() operation. The returned KeylistResult is only valid if the last
         * operation on the context was a key listing operation, and if this operation
         * finished successfully. The returned KeylistResult is only valid until the next
         * operation is started on the context.
         */
        public KeylistResult op_keylist_result();
    }

    [Flags]
    [CCode (cname="unsigned int")]
    public enum ImportStatusFlags {
        /**
         * The key was new.
         */
        [CCode (cname = "GPGME_IMPORT_NEW")]
        NEW,
        /**
         * The key contained new user IDs.
         */
        [CCode (cname = "GPGME_IMPORT_UID")]
        UID,
        /**
         * The key contained new signatures.
         */
        [CCode (cname = "GPGME_IMPORT_SIG")]
        SIG,
        /**
         * The key contained new sub keys.
         */
        [CCode (cname = "GPGME_IMPORT_SUBKEY")]
        SUBKEY,
        /**
         * The key contained a secret key.
         */
        [CCode (cname = "GPGME_IMPORT_SECRET")]
        SECRET
    }

    [Compact]
    [CCode (cname = "struct _gpgme_import_status")]
    public class ImportStatus {
        /**
         * This is a pointer to the next status structure in the linked list, or null
         * if this is the last element.
         */
        public ImportStatus? next;

        /**
         * fingerprint of the key that was considered.
         */
        public string fpr;

        /**
         * If the import was not successful, this is the error value that caused the
         * import to fail. Otherwise the error code is GPG_ERR_NO_ERROR.
         */
        public GPGError.ErrorCode result;

        /**
         * Flags what parts of the key have been imported. May be 0, if the key has
         * already been known.
         */
        public ImportStatusFlags status;
    }

    [Compact]
    [CCode (cname = "struct _gpgme_op_import_result")]
    public class ImportResult {
        /**
         * The total number of considered keys.
         */
        public int considered;

        /**
         * The number of keys without user ID.
         */
        public int no_user_id;

        /**
         * The total number of imported keys.
         */
        public int imported;

        /**
         * The number of imported RSA keys.
         */
        public int imported_rsa;

        /**
         * The number of unchanged keys.
         */
        public int unchanged;

        /**
         * The number of new user IDs.
         */
        public int new_user_ids;

        /**
         * The number of new sub keys.
         */
        public int new_sub_keys;

        /**
         * The number of new signatures.
         */
        public int new_signatures;

        /**
         * The number of new revocations.
         */
        public int new_revocations;

        /**
         * The total number of secret keys read.
         */
        public int secret_read;

        /**
         * The number of imported secret keys.
         */
        public int secret_imported;

        /**
         * The number of unchanged secret keys.
         */
        public int secret_unchanged;

        /**
         * The number of keys not imported.
         */
        public int not_imported;

        /*
         * A linked list of ImportStatus objects which
         * contains more information about the keys for
         * which an import was attempted.
         */
        public ImportStatus imports;
    }

    [Compact]
    [CCode (cname = "struct _gpgme_op_keylist_result")]
    public class KeylistResult {
        uint truncated;
    }


    /**
     * Data Object, contains encrypted and/or unencrypted data
     */
    [Compact]
    [CCode (cname = "struct gpgme_data", free_function = "gpgme_data_release", cprefix = "gpgme_data_")]
    public class Data {
        /**
         * Create a new data buffer, returns Error Status Code.
         */
        [CCode (cname = "gpgme_data_new")]
        public static GPGError.ErrorCode create(out Data d);

        /**
         * Create a new data buffer filled with SIZE bytes starting
         * from BUFFER. If COPY is false, COPYING is delayed until
         * necessary and the data is taken from the original location
         * when needed. Returns Error Status Code.
         */
        [CCode (cname = "gpgme_data_new_from_mem")]
        public static GPGError.ErrorCode create_from_memory(out Data d, uint8[] buffer, bool copy);

        /**
         * Create a new data buffer filled with the content of the file.
         * COPY must be non-zero. For delayed read, please use
         * create_from_fd or create_from stream instead.
         */
        [CCode (cname = "gpgme_data_new_from_file")]
        public static GPGError.ErrorCode create_from_file(out Data d, string filename, int copy = 1);


        /**
         * Destroy the object and return a pointer to its content.
         * It's size is returned in R_LEN.
         */
        [CCode (cname = "gpgme_data_release_and_get_mem")]
        public string release_and_get_mem(out size_t len);

        /**
         * Read up to SIZE bytes into buffer BUFFER from the data object.
         * Return the number of characters read, 0 on EOF and -1 on error.
         * If an error occurs, errno is set.
         */
        public ssize_t read(uint8[] buf);

        /**
         * Write up to SIZE bytes from buffer BUFFER to the data object.
         * Return the number of characters written, or -1 on error.
         * If an error occurs, errno is set.
         */
        public ssize_t write(uint8[] buf);

        /**
         * Set the current position from where the next read or write
         * starts in the data object to OFFSET, relativ to WHENCE.
         */
        public long seek(long offset, int whence=0);

        /**
         * Get the encoding attribute of the buffer
         */
        public DataEncoding *get_encoding();

        /**
         * Set the encoding attribute of the buffer to ENC
         */
        public GPGError.ErrorCode set_encoding(DataEncoding enc);
    }

    [CCode (cname = "gpgme_get_protocol_name")]
    public unowned string get_protocol_name(Protocol p);

    [CCode (cname = "gpgme_pubkey_algo_name")]
    public unowned string get_public_key_algorithm_name(PublicKeyAlgorithm algo);

    [CCode (cname = "gpgme_hash_algo_name")]
    public unowned string get_hash_algorithm_name(HashAlgorithm algo);

    [CCode (cname = "gpgme_passphrase_cb_t", has_target = false)]
    public delegate GPGError.ErrorCode passphrase_callback(void* hook, string uid_hint, string passphrase_info, bool prev_was_bad, int fd);

    /**
     * Get version of libgpgme
     * Always call this function before using gpgme, it initializes some stuff
     */
    [CCode (cname = "gpgme_check_version")]
    public unowned string check_version(string? required_version = null);

    /**
     * Verify that the engine implementing proto is installed and
     * available.
     */
    [CCode (cname = "gpgme_engine_check_version")]
    public GPGError.ErrorCode engine_check_version(Protocol proto);

    /**
     * Get information about the configured engines. The returned data is valid
     * until the next set_engine_info() call.
     */
    [CCode (cname = "gpgme_get_engine_information")]
    public GPGError.ErrorCode get_engine_information(out EngineInfo engine_info);

    /**
     * Return the error string for ERR in the user-supplied buffer BUF
     * of size BUFLEN. This function is thread-safe, if a thread-safe
     * strerror_r() function is provided by the system. If the function
     * succeeds, 0 is returned and BUF contains the string describing
     * the error. If the buffer was not large enough, ERANGE is returned
     * and BUF contains as much of the beginning of the error string as
     * fits into the buffer. Returns Error Status Code.
     */
    [CCode (cname = "gpgme_strerror_r")]
    public int strerror_r(GPGError.ErrorCode err, uint8[] buf);

    /**
     * Like strerror_r, but returns a pointer to the string. This method
     * is not thread safe!
     */
    [CCode (cname = "gpgme_strerror")]
    public unowned string strerror(GPGError.ErrorCode err);
}