module gpgme.gpgme;

import gpgerror.gpgerror;

import std.bitmanip;
import core.stdc.stdio;
import core.stdc.time;

/* gpgme.h - Public interface to GnuPG Made Easy.                   -*- c -*-
 * Copyright (C) 2000 Werner Koch (dd9jn)
 * Copyright (C) 2001-2015 g10 Code GmbH
 *
 * This file is part of GPGME.
 *
 * GPGME is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * GPGME 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 Lesser General Public
 * License along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Generated from gpgme.h.in for x86_64-unknown-linux-gnu.
 */

/* The version of this header should match the one of the library.  Do
   not use this symbol in your application, use gpgme_check_version
   instead.  The purpose of this macro is to let autoconf (using the
   AM_PATH_GPGME macro) check that this header matches the installed
   library.  */
static const(char*) GPGME_VERSION = "1.6.0";

/* The version number of this header.  It may be used to handle minor API incompatibilities.  */
enum GPGME_VERSION_NUMBER = 0x010600;


alias off_t = long;
alias gpgme_off_t = off_t;
alias gpgme_ssize_t = ptrdiff_t ;
/*
 * Some opaque data types used by GPGME.
 */

extern(C) nothrow @nogc {

	alias engine_status_handler_t = gpgme_error_t function(void* priv, gpgme_status_code_t code, char* args);
	alias engine_colon_line_handler_t = gpgme_error_t function(void* priv, char* line);
	alias engine_command_handler_t = gpgme_error_t function(void* priv, gpgme_status_code_t code, const(char*) keyword, int fd, int* processed);
	alias engine_assuan_result_cb_t = gpgme_error_t function(void* priv, gpgme_error_t result);

}

struct critsect_s {
	const(char*) name;
	void* priv;
};

struct engine_ops {
	
	/* Static functions.  */

	/* Return the default file name for the binary of this engine.  */
	const(char*) function() get_file_name;

	/* Return the default home dir for the binary of this engine.  If
     this function pointer is not set, the standard default home dir
     of the engine is used. */
	const(char*) function() get_home_dir;

	/* Returns a malloced string containing the version of the engine
     with the given binary file name (or the default if FILE_NAME is
     NULL.  */
	char* function(const(char*) file_name) get_version;

	/* Returns a statically allocated string containing the required version.  */
	const(char*) function() get_req_version;

	gpgme_error_t function(void** r_engine, const(char*) file_name, const(char*) home_dir) new_;

	/* Member functions.  */
	void function(void* engine) release;
	
	gpgme_error_t function(void* engine) reset;
	
	void function(void* engine, engine_status_handler_t fnc, void* fnc_value) set_status_handler;
	
	gpgme_error_t function(void* engine, engine_command_handler_t fnc, void* fnc_value, gpgme_data_t data) set_command_handler;
	gpgme_error_t function(void* engine, engine_colon_line_handler_t fnc, void* fnc_value) set_colon_line_handler;
	gpgme_error_t function(void* engine, int category, const(char*) value) set_locale;
	gpgme_error_t function(void* engine, gpgme_protocol_t protocol) set_protocol;
	gpgme_error_t function(void* engine, gpgme_data_t ciph, gpgme_data_t plain) decrypt;
	gpgme_error_t function(void* engine, gpgme_data_t ciph, gpgme_data_t plain) decrypt_verify;
	gpgme_error_t function(void* engine, gpgme_key_t key, int allow_secret) delete_;
	gpgme_error_t function(void* engine, int type, gpgme_key_t key, gpgme_data_t out_, gpgme_ctx_t ctx /* FIXME */) edit;
	gpgme_error_t function(void* engine, gpgme_key_t[] recp, gpgme_encrypt_flags_t flags, gpgme_data_t plain, gpgme_data_t ciph, int use_armor) encrypt;
	gpgme_error_t function(void* engine, gpgme_key_t[] recp, gpgme_encrypt_flags_t flags, gpgme_data_t plain, gpgme_data_t ciph, int use_armor, gpgme_ctx_t ctx /* FIXME */) encrypt_sign;
	gpgme_error_t function(void* engine, const(char*) pattern, gpgme_export_mode_t mode, gpgme_data_t keydata, int use_armor) export_;
	gpgme_error_t function(void* engine, const(char*)[] pattern, gpgme_export_mode_t mode, gpgme_data_t keydata, int use_armor) export_ext;
	gpgme_error_t function(void* engine, gpgme_data_t help_data, int use_armor, gpgme_data_t pubkey, gpgme_data_t seckey) genkey;
	gpgme_error_t function(void* engine, gpgme_data_t keydata, gpgme_key_t* keyarray) import_;
	gpgme_error_t function(void* engine, const(char*) pattern, int secret_only, gpgme_keylist_mode_t mode, int engine_flags) keylist;
	gpgme_error_t function(void* engine, const(char*)[] pattern, int secret_only, int reserved, gpgme_keylist_mode_t mode, int engine_flags) keylist_ext;
	gpgme_error_t function(void* engine, gpgme_data_t in_, gpgme_data_t out_, gpgme_sig_mode_t mode, int use_armor, int use_textmode, int include_certs, gpgme_ctx_t ctx /* FIXME */) sign;
	gpgme_error_t function(void* engine, const(char*) pattern) trustlist;
	gpgme_error_t function(void* engine, gpgme_data_t sig, gpgme_data_t signed_text, gpgme_data_t plaintext) verify;
	gpgme_error_t function(void* engine, gpgme_data_t output, uint flags) getauditlog;
	gpgme_error_t function(void* engine, const(char*) command, gpgme_assuan_data_cb_t data_cb, void* data_cb_value, gpgme_assuan_inquire_cb_t inq_cb, void* inq_cb_value, gpgme_assuan_status_cb_t status_cb, void* status_cb_value) opassuan_transact;

	gpgme_error_t function(void* engine, gpgme_conf_comp_t* conf_p) conf_load;
	gpgme_error_t function(void* engine, gpgme_conf_comp_t conf) conf_save;

	void function(void* engine, gpgme_io_cbs_t io_cbs) set_io_cbs;
	void function(void* engine, gpgme_event_io_t type, void* type_data) io_event;

	/* Cancel the whole engine session.  */
	gpgme_error_t function(void* engine) cancel;

	/* Cancel only the current operation, not the whole session.  */
	gpgme_error_t function(void* engine) cancel_op;

	/* Change the passphrase for KEY. */
	gpgme_error_t function(void* engine, gpgme_key_t key, uint flags) passwd;

	/* Set the pinentry mode.  */
	gpgme_error_t function(void* engine, gpgme_pinentry_mode_t mode) set_pinentry_mode;

	/* The spawn command.  */
	gpgme_error_t function(void* engine, const(char*) file, const(char*)[] argv, gpgme_data_t datain, gpgme_data_t dataout, gpgme_data_t dataerr, uint flags) opspawn;

}

struct engine {
	engine_ops* ops;
	void* engine;
}

alias engine_t = engine*;

enum ctx_op_data_id_t {
	OPDATA_DECRYPT, 
	OPDATA_SIGN, 
	OPDATA_ENCRYPT, 
	OPDATA_PASSPHRASE,
 	OPDATA_IMPORT, 
	OPDATA_GENKEY, 
	OPDATA_KEYLIST, 
	OPDATA_EDIT,
	OPDATA_VERIFY, 
	OPDATA_TRUSTLIST, 
	OPDATA_ASSUAN, 
	OPDATA_VFS_MOUNT
}

struct ctx_op_data {
	/* A magic word just to make sure people don't deallocate something
     that ain't a result structure.  */
	ulong magic;

	/* The next element in the linked list, or NULL if this is the last
     element.  Used by op data structures linked into a context.  */
	ctx_op_data* next;

	/* The type of the hook data, which can be used by a routine to
     lookup the hook data.  */
	ctx_op_data_id_t type;

	/* The function to release HOOK and all its associated resources.
     Can be NULL if no special deallocation routine is necessary.  */
	void function(void* hook) cleanup;

	/* The hook that points to the operation data.  */
	void* hook;

	/* The number of outstanding references.  */
	int references;
}

alias ctx_op_data_t = ctx_op_data*;

struct spawn_fd_item_s {
	int fd;
	int dup_to;
	int peer_name;
	int arg_loc;
}

struct io_select_fd_s {
	int fd;
	int for_read;
	int for_write;
	int signaled;
	void* opaque;
}

struct fd_table {
	io_select_fd_s* fds;
	size_t size;
}

alias fd_table_t = fd_table*;

/* The context holds some global state and configuration options, as well as the results of a crypto operation.  */
struct gpgme_context {
	
  	critsect_s lock;

	/* True if the context was canceled asynchronously.  */
	int canceled;
	
	/* The engine info for this context.  */
	gpgme_engine_info_t engine_info;
	
	/* The protocol used by this context.  */
	gpgme_protocol_t protocol;
	
	/* The running engine process.  */
	engine_t engine;
	
	/* Engine's sub protocol.  */
	gpgme_protocol_t sub_protocol;
	
	mixin(bitfields!(
        uint, "use_armor",    1, /* True if armor mode should be used.  */
        uint,  "use_textmode",    1, /* True if text mode should be used.  */
        uint,  "offline",    1, /* True if offline mode should be used.  */
        uint, "_unused",    29
    ));
	
	 /* Flags for keylist mode.  */
	gpgme_keylist_mode_t keylist_mode;
	
	/* The current pinnetry mode.  */
	gpgme_pinentry_mode_t pinentry_mode;
	
	/* Number of certs to be included.  */
	uint include_certs;
	
	/* The number of keys in signers.  */
	uint signers_len;
	
	/* Size of the following array.  */
	uint signers_size;
	gpgme_key_t *signers;
	
	/* The signature notations for this context.  */
	gpgme_sig_notation_t sig_notations;
	
	/* The locale for the pinentry.  */
	char* lc_ctype;
	char* lc_messages;
	
	/* The operation data hooked into the context.  */
	ctx_op_data_t op_data;
	
	/* The user provided passphrase callback and its hook value.  */
	gpgme_passphrase_cb_t passphrase_cb;
	void* passphrase_cb_value;
	
	/* The user provided progress callback and its hook value.  */
	gpgme_progress_cb_t progress_cb;
	void* progress_cb_value;
	
	/* The user provided status callback and its hook value.  */
	gpgme_status_cb_t status_cb;
	void* status_cb_value;
	
	/* A list of file descriptors in active use by the current operation.  */
	fd_table fdt;
	gpgme_io_cbs io_cbs;
}

alias gpgme_ctx_t = gpgme_context*;
	
extern(C) nothrow @nogc {

	/* Read up to SIZE bytes into buffer BUFFER from the data object with
	   the handle DH.  Return the number of characters read, 0 on EOF and
	   -1 on error.  If an error occurs, errno is set.  */
	alias gpgme_data_read_cb = ptrdiff_t function(gpgme_data_t dh, void* buffer, size_t size);
	
	/* Write up to SIZE bytes from buffer BUFFER to the data object with
	   the handle DH.  Return the number of characters written, or -1 on
	   error.  If an error occurs, errno is set.  */
	alias gpgme_data_write_cb = ptrdiff_t function(gpgme_data_t dh, const(void*) buffer, size_t size);
	
	/* Set the current position from where the next read or write starts
	   in the data object with the handle DH to OFFSET, relativ to
	   WHENCE.  */
	alias gpgme_data_seek_cb = off_t function(gpgme_data_t dh, off_t offset, int whence);
	
	/* Release the data object with the handle DH.  */
	alias gpgme_data_release_cb = void function(gpgme_data_t dh);
	
	/* Get the FD associated with the handle DH, or -1.  */
	alias gpgme_data_get_fd_cb = int function(gpgme_data_t dh);
	
}	
	
struct _gpgme_data_cbs {
	gpgme_data_read_cb read;
	gpgme_data_write_cb write;
	gpgme_data_seek_cb seek;
	gpgme_data_release_cb release;
	gpgme_data_get_fd_cb get_fd;
}
	
/* The data object is used by GPGME to exchange arbitrary data.  */
enum BUFFER_SIZE = 512;

struct gpgme_data {
	_gpgme_data_cbs* cbs;
	gpgme_data_encoding_t encoding;

	char[BUFFER_SIZE] pending;
	int pending_len;

	/* File name of the data object.  */
	char* file_name;

	union data_uni {
		/* For gpgme_data_new_from_fd.  */
		int fd;

		/* For gpgme_data_new_from_stream.  */
		FILE* stream;

		/* For gpgme_data_new_from_cbs.  */
		struct user_str {
			gpgme_data_cbs_t cbs;
			void* handle;
		}
    
		user_str user;

		/* For gpgme_data_new_from_mem.  */
		struct mem_str {
			char* buffer;
			const(char*) orig_buffer;
			/* Allocated size of BUFFER.  */
			size_t size;
			size_t length;
			gpgme_off_t offset;
		}

		mem_str mem;
	
		/* For gpgme_data_new_from_read_cb.  */
		struct old_user_str {
			int function(void*, char*, size_t, size_t*) cb;
			void* handle;
		}
		
		old_user_str old_user;
		
	}
	
	data_uni data;
}

alias gpgme_data_t = gpgme_data*;

/*
 * Wrappers for the libgpg-error library.
 */

alias gpgme_error_t = gpg_error_t;
alias gpgme_err_code_t = gpg_err_code_t;
alias gpgme_err_source_t = gpg_err_source_t;

extern(C) nothrow @nogc {
	
	static gpgme_error_t gpgme_err_make(gpgme_err_source_t source, gpgme_err_code_t code) {
		return gpg_err_make(source, code);
	}

	/* The user can define GPGME_ERR_SOURCE_DEFAULT before including this file to specify a default source for gpgme_error.  */
	enum GPGME_ERR_SOURCE_DEFAULT = gpg_err_source_t.GPG_ERR_SOURCE_USER_1;
	
	static gpgme_error_t gpgme_error(gpgme_err_code_t code) {
		return gpgme_err_make(GPGME_ERR_SOURCE_DEFAULT, code);
	}
	
	static gpgme_err_code_t gpgme_err_code(gpgme_error_t err) {
		return gpg_err_code(err);
	}
	
	static gpgme_err_source_t gpgme_err_source(gpgme_error_t err) {
		return gpg_err_source(err);
	}
	/* Return a pointer to a string containing a description of the error code in the error value ERR.  This function is not thread safe.  */
	const(char*) gpgme_strerror(gpgme_error_t err);
	
	/* Return the error string for ERR in the user-supplied buffer BUF of
	   size BUFLEN.  This function is, in contrast to gpg_strerror,
	   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.  */
	int gpgme_strerror_r(gpg_error_t err, char *buf, size_t buflen);
	
	/* Return a pointer to a string containing a description of the error source in the error value ERR.  */
	const(char*) gpgme_strsource(gpgme_error_t err);
	
	/* Retrieve the error code for the system error ERR.  This returns
	   GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
	   this).  */
	gpgme_err_code_t gpgme_err_code_from_errno(int err);
	
	/* Retrieve the system error for the error code CODE.  This returns 0 if CODE is not a system error code.  */
	int gpgme_err_code_to_errno(gpgme_err_code_t code);
	
	/* Retrieve the error code directly from the ERRNO variable.  This
	   returns GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped
	   (report this) and GPG_ERR_MISSING_ERRNO if ERRNO has the value 0. */
	gpgme_err_code_t gpgme_err_code_from_syserror();
	
	/* Set the ERRNO variable.  This function is the preferred way to set ERRNO due to peculiarities on WindowsCE.  */
	void gpgme_err_set_errno(int err);
	
	/* Return an error value with the error source SOURCE and the system error ERR.  FIXME: Should be inline.  */
	gpgme_error_t gpgme_err_make_from_errno(gpgme_err_source_t source, int err);
	
	/* Return an error value with the system error ERR.  FIXME: Should be inline.  */
	gpgme_error_t gpgme_error_from_errno(int err);
	
	static gpgme_error_t gpgme_error_from_syserror() {
		return gpgme_error(gpgme_err_code_from_syserror());
	}

}

/*
 * Various constants and types
 */

/* The possible encoding mode of gpgme_data_t objects.  */
enum gpgme_data_encoding_t  {
	GPGME_DATA_ENCODING_NONE   = 0,	/* Not specified.  */
	GPGME_DATA_ENCODING_BINARY = 1,
	GPGME_DATA_ENCODING_BASE64 = 2,
	GPGME_DATA_ENCODING_ARMOR  = 3,	/* Either PEM or OpenPGP Armor.  */
	GPGME_DATA_ENCODING_URL    = 4,     /* LF delimited URL list.        */
	GPGME_DATA_ENCODING_URLESC = 5,     /* Ditto, but percent escaped.   */
	GPGME_DATA_ENCODING_URL0   = 6      /* Nul delimited URL list.       */
}

/* Known data types.  */
enum gpgme_data_type_t {
	GPGME_DATA_TYPE_INVALID      = 0,   /* Not detected.  */
	GPGME_DATA_TYPE_UNKNOWN      = 1,
	GPGME_DATA_TYPE_PGP_SIGNED   = 0x10,
	GPGME_DATA_TYPE_PGP_OTHER    = 0x12,
	GPGME_DATA_TYPE_PGP_KEY      = 0x13,
	GPGME_DATA_TYPE_CMS_SIGNED   = 0x20,
	GPGME_DATA_TYPE_CMS_ENCRYPTED= 0x21,
	GPGME_DATA_TYPE_CMS_OTHER    = 0x22,
	GPGME_DATA_TYPE_X509_CERT    = 0x23,
	GPGME_DATA_TYPE_PKCS12       = 0x24,
}

/* Public key algorithms.  */
enum gpgme_pubkey_algo_t {
	GPGME_PK_RSA   = 1,
	GPGME_PK_RSA_E = 2,
	GPGME_PK_RSA_S = 3,
	GPGME_PK_ELG_E = 16,
	GPGME_PK_DSA   = 17,
	GPGME_PK_ECC   = 18,
	GPGME_PK_ELG   = 20,
	GPGME_PK_ECDSA = 301,
	GPGME_PK_ECDH  = 302
}

/* Hash algorithms (the values match those from libgcrypt).  */
enum gpgme_hash_algo_t {
	GPGME_MD_NONE          = 0,
	GPGME_MD_MD5           = 1,
	GPGME_MD_SHA1          = 2,
	GPGME_MD_RMD160        = 3,
	GPGME_MD_MD2           = 5,
	GPGME_MD_TIGER         = 6,   /* TIGER/192. */
	GPGME_MD_HAVAL         = 7,   /* HAVAL, 5 pass, 160 bit. */
	GPGME_MD_SHA256        = 8,
	GPGME_MD_SHA384        = 9,
	GPGME_MD_SHA512        = 10,
	GPGME_MD_SHA224        = 11,
	GPGME_MD_MD4           = 301,
	GPGME_MD_CRC32	   = 302,
	GPGME_MD_CRC32_RFC1510 = 303,
	GPGME_MD_CRC24_RFC2440 = 304
}

/* The possible signature stati.  Deprecated, use error value in sig status.  */
deprecated enum _gpgme_sig_stat_t {
	GPGME_SIG_STAT_NONE  = 0,
	GPGME_SIG_STAT_GOOD  = 1,
	GPGME_SIG_STAT_BAD   = 2,
	GPGME_SIG_STAT_NOKEY = 3,
	GPGME_SIG_STAT_NOSIG = 4,
	GPGME_SIG_STAT_ERROR = 5,
	GPGME_SIG_STAT_DIFF  = 6,
	GPGME_SIG_STAT_GOOD_EXP = 7,
	GPGME_SIG_STAT_GOOD_EXPKEY = 8
}

deprecated alias gpgme_sig_stat_t = _gpgme_sig_stat_t;

/* The available signature modes.  */
enum gpgme_sig_mode_t { 
	GPGME_SIG_MODE_NORMAL = 0,
	GPGME_SIG_MODE_DETACH = 1,
	GPGME_SIG_MODE_CLEAR  = 2
}

/* The available key and signature attributes.  Deprecated, use the
   individual result structures instead.  */
deprecated enum _gpgme_attr_t {
	GPGME_ATTR_KEYID        = 1,
	GPGME_ATTR_FPR          = 2,
	GPGME_ATTR_ALGO         = 3,
	GPGME_ATTR_LEN          = 4,
	GPGME_ATTR_CREATED      = 5,
	GPGME_ATTR_EXPIRE       = 6,
	GPGME_ATTR_OTRUST       = 7,
	GPGME_ATTR_USERID       = 8,
	GPGME_ATTR_NAME         = 9,
	GPGME_ATTR_EMAIL        = 10,
	GPGME_ATTR_COMMENT      = 11,
	GPGME_ATTR_VALIDITY     = 12,
	GPGME_ATTR_LEVEL        = 13,
	GPGME_ATTR_TYPE         = 14,
	GPGME_ATTR_IS_SECRET    = 15,
	GPGME_ATTR_KEY_REVOKED  = 16,
	GPGME_ATTR_KEY_INVALID  = 17,
	GPGME_ATTR_UID_REVOKED  = 18,
	GPGME_ATTR_UID_INVALID  = 19,
	GPGME_ATTR_KEY_CAPS     = 20,
	GPGME_ATTR_CAN_ENCRYPT  = 21,
	GPGME_ATTR_CAN_SIGN     = 22,
	GPGME_ATTR_CAN_CERTIFY  = 23,
	GPGME_ATTR_KEY_EXPIRED  = 24,
	GPGME_ATTR_KEY_DISABLED = 25,
	GPGME_ATTR_SERIAL       = 26,
	GPGME_ATTR_ISSUER       = 27,
	GPGME_ATTR_CHAINID      = 28,
	GPGME_ATTR_SIG_STATUS   = 29,
	GPGME_ATTR_ERRTOK       = 30,
	GPGME_ATTR_SIG_SUMMARY  = 31,
	GPGME_ATTR_SIG_CLASS    = 32
}

deprecated alias gpgme_attr_t = _gpgme_attr_t;

/* The available validities for a trust item or key.  */
enum gpgme_validity_t {
	GPGME_VALIDITY_UNKNOWN   = 0,
	GPGME_VALIDITY_UNDEFINED = 1,
	GPGME_VALIDITY_NEVER     = 2,
	GPGME_VALIDITY_MARGINAL  = 3,
	GPGME_VALIDITY_FULL      = 4,
	GPGME_VALIDITY_ULTIMATE  = 5
}

/* The available protocols.  */
enum gpgme_protocol_t {
	GPGME_PROTOCOL_OpenPGP = 0,  /* The default mode.  */
	GPGME_PROTOCOL_OPENPGP = 0,  /* Convenience macro for the surprisingly mixed spelling.  */
	GPGME_PROTOCOL_CMS     = 1,
	GPGME_PROTOCOL_GPGCONF = 2,  /* Special code for gpgconf.  */
	GPGME_PROTOCOL_ASSUAN  = 3,  /* Low-level access to an Assuan server.  */
	GPGME_PROTOCOL_G13     = 4,
	GPGME_PROTOCOL_UISERVER= 5,
	GPGME_PROTOCOL_SPAWN   = 6,  /* Direct access to any program.  */
	GPGME_PROTOCOL_DEFAULT = 254,
	GPGME_PROTOCOL_UNKNOWN = 255
}

/* The available keylist mode flags.  */
enum gpgme_keylist_mode_t : uint {
	GPGME_KEYLIST_MODE_LOCAL 		= 1,
	GPGME_KEYLIST_MODE_EXTERN 		= 2,
	GPGME_KEYLIST_MODE_SIGS			= 4,
	GPGME_KEYLIST_MODE_SIG_NOTATIONS= 8,
	GPGME_KEYLIST_MODE_WITH_SECRET 	= 16,
	GPGME_KEYLIST_MODE_EPHEMERAL 	= 128,
	GPGME_KEYLIST_MODE_VALIDATE		= 256
}

/* The pinentry modes. */
enum gpgme_pinentry_mode_t {
	GPGME_PINENTRY_MODE_DEFAULT  = 0,
	GPGME_PINENTRY_MODE_ASK      = 1,
	GPGME_PINENTRY_MODE_CANCEL   = 2,
	GPGME_PINENTRY_MODE_ERROR    = 3,
	GPGME_PINENTRY_MODE_LOOPBACK = 4
}

/* The available export mode flags.  */
enum gpgme_export_mode_t : uint {
	GPGME_EXPORT_MODE_EXTERN 	= 2,
	GPGME_EXPORT_MODE_MINIMAL 	= 4,
	GPGME_EXPORT_MODE_SECRET 	= 16,
	GPGME_EXPORT_MODE_RAW 		= 32,
	GPGME_EXPORT_MODE_PKCS12 	= 64
}

/* Flags for the audit log functions.  */
enum {
	GPGME_AUDITLOG_HTML 	= 1,
	GPGME_AUDITLOG_WITH_HELP= 128
}

/* The possible stati for the edit operation.  */
enum gpgme_status_code_t {
	GPGME_STATUS_EOF = 0,
	/* mkstatus processing starts here */
	GPGME_STATUS_ENTER = 1,
	GPGME_STATUS_LEAVE = 2,
	GPGME_STATUS_ABORT = 3,

	GPGME_STATUS_GOODSIG = 4,
	GPGME_STATUS_BADSIG = 5,
	GPGME_STATUS_ERRSIG = 6,

	GPGME_STATUS_BADARMOR = 7,

	GPGME_STATUS_RSA_OR_IDEA = 8,      /* (legacy) */
	GPGME_STATUS_KEYEXPIRED = 9,
	GPGME_STATUS_KEYREVOKED = 10,

	GPGME_STATUS_TRUST_UNDEFINED = 11,
	GPGME_STATUS_TRUST_NEVER = 12,
	GPGME_STATUS_TRUST_MARGINAL = 13,
	GPGME_STATUS_TRUST_FULLY = 14,
	GPGME_STATUS_TRUST_ULTIMATE = 15,

	GPGME_STATUS_SHM_INFO = 16,        /* (legacy) */
	GPGME_STATUS_SHM_GET = 17,         /* (legacy) */
	GPGME_STATUS_SHM_GET_BOOL = 18,    /* (legacy) */
	GPGME_STATUS_SHM_GET_HIDDEN = 19,  /* (legacy) */

	GPGME_STATUS_NEED_PASSPHRASE = 20,
	GPGME_STATUS_VALIDSIG = 21,
	GPGME_STATUS_SIG_ID = 22,
	GPGME_STATUS_ENC_TO = 23,
	GPGME_STATUS_NODATA = 24,
	GPGME_STATUS_BAD_PASSPHRASE = 25,
	GPGME_STATUS_NO_PUBKEY = 26,
	GPGME_STATUS_NO_SECKEY = 27,
	GPGME_STATUS_NEED_PASSPHRASE_SYM = 28,
	GPGME_STATUS_DECRYPTION_FAILED = 29,
	GPGME_STATUS_DECRYPTION_OKAY = 30,
	GPGME_STATUS_MISSING_PASSPHRASE = 31,
	GPGME_STATUS_GOOD_PASSPHRASE = 32,
	GPGME_STATUS_GOODMDC = 33,
	GPGME_STATUS_BADMDC = 34,
	GPGME_STATUS_ERRMDC = 35,
	GPGME_STATUS_IMPORTED = 36,
	GPGME_STATUS_IMPORT_OK = 37,
	GPGME_STATUS_IMPORT_PROBLEM = 38,
	GPGME_STATUS_IMPORT_RES = 39,
	GPGME_STATUS_FILE_START = 40,
	GPGME_STATUS_FILE_DONE = 41,
	GPGME_STATUS_FILE_ERROR = 42,

	GPGME_STATUS_BEGIN_DECRYPTION = 43,
	GPGME_STATUS_END_DECRYPTION = 44,
	GPGME_STATUS_BEGIN_ENCRYPTION = 45,
	GPGME_STATUS_END_ENCRYPTION = 46,

	GPGME_STATUS_DELETE_PROBLEM = 47,
	GPGME_STATUS_GET_BOOL = 48,
	GPGME_STATUS_GET_LINE = 49,
	GPGME_STATUS_GET_HIDDEN = 50,
	GPGME_STATUS_GOT_IT = 51,
	GPGME_STATUS_PROGRESS = 52,
	GPGME_STATUS_SIG_CREATED = 53,
	GPGME_STATUS_SESSION_KEY = 54,
	GPGME_STATUS_NOTATION_NAME = 55,
	GPGME_STATUS_NOTATION_DATA = 56,
	GPGME_STATUS_POLICY_URL = 57,
	GPGME_STATUS_BEGIN_STREAM = 58,    /* (legacy) */
	GPGME_STATUS_END_STREAM = 59,      /* (legacy) */
	GPGME_STATUS_KEY_CREATED = 60,
	GPGME_STATUS_USERID_HINT = 61,
	GPGME_STATUS_UNEXPECTED = 62,
	GPGME_STATUS_INV_RECP = 63,
	GPGME_STATUS_NO_RECP = 64,
	GPGME_STATUS_ALREADY_SIGNED = 65,
	GPGME_STATUS_SIGEXPIRED = 66,      /* (legacy) */
	GPGME_STATUS_EXPSIG = 67,
	GPGME_STATUS_EXPKEYSIG = 68,
	GPGME_STATUS_TRUNCATED = 69,
	GPGME_STATUS_ERROR = 70,
	GPGME_STATUS_NEWSIG = 71,
	GPGME_STATUS_REVKEYSIG = 72,
	GPGME_STATUS_SIG_SUBPACKET = 73,
	GPGME_STATUS_NEED_PASSPHRASE_PIN = 74,
	GPGME_STATUS_SC_OP_FAILURE = 75,
	GPGME_STATUS_SC_OP_SUCCESS = 76,
	GPGME_STATUS_CARDCTRL = 77,
	GPGME_STATUS_BACKUP_KEY_CREATED = 78,
	GPGME_STATUS_PKA_TRUST_BAD = 79,
	GPGME_STATUS_PKA_TRUST_GOOD = 80,
	GPGME_STATUS_PLAINTEXT = 81,
	GPGME_STATUS_INV_SGNR = 82,
	GPGME_STATUS_NO_SGNR = 83,
	GPGME_STATUS_SUCCESS = 84,
	GPGME_STATUS_DECRYPTION_INFO = 85,
	GPGME_STATUS_PLAINTEXT_LENGTH = 86,
	GPGME_STATUS_MOUNTPOINT = 87,
	GPGME_STATUS_PINENTRY_LAUNCHED = 88,
	GPGME_STATUS_ATTRIBUTE = 89,
	GPGME_STATUS_BEGIN_SIGNING = 90,
	GPGME_STATUS_KEY_NOT_CREATED = 91,
	GPGME_STATUS_INQUIRE_MAXLEN = 92,
	GPGME_STATUS_FAILURE = 93
}

/* The available signature notation flags.  */
enum gpgme_sig_notation_flags_t : uint {
	GPGME_SIG_NOTATION_HUMAN_READABLE 	= 1,
	GPGME_SIG_NOTATION_CRITICAL 		= 2
}

struct _gpgme_sig_notation {
	_gpgme_sig_notation* next;

	/* If NAME is a null pointer, then VALUE contains a policy URL
		rather than a notation.  */
	char* name;

	/* The value of the notation data.  */
	char* 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.  */
	gpgme_sig_notation_flags_t flags;
	
	mixin(bitfields!(
        uint, "human_readable",    1, /* The accumulated flags.  */
        uint,  "critical",    1, /* Notation data is human-readable.  */
        int, "_unused",    30 /* Internal to GPGME, do not use.  */
    ));
}

alias gpgme_sig_notation_t = _gpgme_sig_notation*;


/*
 * Public structures.
 */


/* The engine information structure.  */
struct _gpgme_engine_info {
	_gpgme_engine_info* next;

	/* The protocol ID.  */
	gpgme_protocol_t protocol;

	/* The file name of the engine binary.  */
	char* file_name;

	/* The version string of the installed engine.  */
	char* version_;

	/* The minimum version required for GPGME.  */
	const char *req_version;

	/* The home directory used, or NULL if default.  */
	char *home_dir;
}

alias gpgme_engine_info_t = _gpgme_engine_info*;

/* A subkey from a key.  */
struct _gpgme_subkey {
	_gpgme_subkey* next;
	
	mixin(bitfields!(
        uint, "revoked",	1, /* True if subkey is revoked.  */
        uint,  "expired",	1, /* True if subkey is expired.  */
        uint, "disabled",	1, /* True if subkey is disabled.  */
        uint, "invalid",	1, /* True if subkey is invalid.  */
        uint, "can_encrypt",	1, /* True if subkey can be used for encryption.  */
        uint, "can_sign",		1, /* True if subkey can be used for signing.  */
        uint, "can_certify",	1, /* True if subkey can be used for certification.  */
        uint, "secret",		1, /* True if subkey is secret.  */
        uint, "can_authenticate",	1, /* True if subkey can be used for authentication.  */
        uint, "is_qualified",	1, /* True if subkey is qualified for signatures according to German law.  */
        uint, "is_cardkey",	1, /* True if the secret key is stored on a smart card.  */
        uint, "_unused",	21 /* Internal to GPGME, do not use.  */
    ));

	/* Public key algorithm supported by this subkey.  */
	gpgme_pubkey_algo_t pubkey_algo;

	/* Length of the subkey.  */
	uint length;

	/* The key ID of the subkey.  */
	char* keyid;

	/* Internal to GPGME, do not use.  */
	char[16 + 1] _keyid;

	/* The fingerprint of the subkey in hex digit form.  */
	char* fpr;

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

	/* The expiration timestamp, 0 if the subkey does not expire.  */
	long expires;

	/* The serial number of a smart card holding this key or NULL.  */
	char* card_number;

	/* The name of the curve for ECC algorithms or NULL.  */
	char* curve;
}

alias gpgme_subkey_t = _gpgme_subkey*;

/* A signature on a user ID.  */
struct _gpgme_key_sig {
	_gpgme_key_sig* next;
	
	mixin(bitfields!(
        uint, "revoked",	1, /* True if the signature is a revocation signature.  */
        uint, "expired",	1, /* True if the signature is expired.  */
        uint, "invalid",	1, /* True if the signature is invalid.  */
        uint, "exportable",	1, /* True if the signature should be exported.  */
        uint, "_unused",	28, /* Internal to GPGME, do not use.  */
    ));

	/* The public key algorithm used to create the signature.  */
	gpgme_pubkey_algo_t pubkey_algo;

	/* The key ID of key used to create the signature.  */
	char* keyid;

	/* Internal to GPGME, do not use.  */
	char[16 + 1] _keyid;

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

	/* The expiration timestamp, 0 if the subkey does not expire.  */
	long expires;

	/* Same as in gpgme_signature_t.  */
	gpgme_error_t status;
	
	deprecated uint _obsolete_class; // ???

	/* The user ID string.  */
	char* uid;

	/* The name part of the user ID.  */
	char* name;

	/* The email part of the user ID.  */
	char* email;

	/* The comment part of the user ID.  */
	char* comment;

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

	/* Notation data and policy URLs.  */
	gpgme_sig_notation_t notations;

	/* Internal to GPGME, do not use.  */
	gpgme_sig_notation_t _last_notation;
}

alias gpgme_key_sig_t = _gpgme_key_sig*;

/* An user ID from a key.  */
struct _gpgme_user_id {
	_gpgme_user_id* next;

	mixin(bitfields!(
        uint, "revoked",	1, /* True if the user ID is revoked.  */
        uint, "invalid",	1, /* True if the user ID is invalid.  */
        uint, "_unused",	30, /* Internal to GPGME, do not use.  */
    ));
	
	/* The validity of the user ID.  */
	gpgme_validity_t validity;

	/* The user ID string.  */
	char* uid;

	/* The name part of the user ID.  */
	char* name;

	/* The email part of the user ID.  */
	char* email;

	/* The comment part of the user ID.  */
	char* comment;

	/* The signatures of the user ID.  */
	gpgme_key_sig_t signatures;

	/* Internal to GPGME, do not use.  */
	gpgme_key_sig_t _last_keysig;
}

alias gpgme_user_id_t = _gpgme_user_id*;

/* A key from the keyring.  */
struct _gpgme_key {
	/* Internal to GPGME, do not use.  */
	uint _refs;
	
	mixin(bitfields!(
        uint, "revoked",	1, /* True if key is revoked.  */
        uint, "expired",	1, /* True if key is expired.  */
        uint, "disabled",	1, /* True if key is invalid.  */
        uint, "invalid",	1, /* True if key is invalid.  */
        uint, "can_encrypt",	1, /* True if key can be used for encryption.  */
        uint, "can_sign",	1, /* True if key can be used for signing.  */
        uint, "can_certify",	1, /* True if key can be used for certification.  */
        uint, "secret",		1, /* True if key is secret.  */
        uint, "can_authenticate",	1, /* True if key can be used for authentication.  */
        uint, "is_qualified",	1, /* True if subkey is qualified for signatures according to German law.  */
        uint, "_unused",	22, /* Internal to GPGME, do not use.  */
    ));

	/* This is the protocol supported by this key.  */
	gpgme_protocol_t protocol;

	/* If protocol is GPGME_PROTOCOL_CMS, this string contains the
		issuer serial.  */
	char* issuer_serial;

	/* If protocol is GPGME_PROTOCOL_CMS, this string contains the
		issuer name.  */
	char* issuer_name;

	/* If protocol is GPGME_PROTOCOL_CMS, this string contains the chain
		ID.  */
	char* chain_id;

	/* If protocol is GPGME_PROTOCOL_OpenPGP, this field contains the
		owner trust.  */
	gpgme_validity_t owner_trust;

	/* The subkeys of the key.  */
	gpgme_subkey_t subkeys;

	/* The user IDs of the key.  */
	gpgme_user_id_t uids;

	/* Internal to GPGME, do not use.  */
	gpgme_subkey_t _last_subkey;

	/* Internal to GPGME, do not use.  */
	gpgme_user_id_t _last_uid;

	/* The keylist mode that was active when listing the key.  */
	gpgme_keylist_mode_t keylist_mode;
}

alias gpgme_key_t = _gpgme_key*;

/* An invalid key object.  */
struct _gpgme_invalid_key {
	_gpgme_invalid_key* next;
	char* fpr;
	gpgme_error_t reason;
}

alias gpgme_invalid_key_t = _gpgme_invalid_key*;


/*
 * Types for callback functions.
 */

extern(C) nothrow @nogc {
	
	/* Request a passphrase from the user.  */
	alias gpgme_passphrase_cb_t = gpgme_error_t function(void* hook, const(char*) uid_hint,	const(char*) passphrase_info, int prev_was_bad, int fd);

	/* Inform the user about progress made.  */
	alias gpgme_progress_cb_t = void function(void* opaque, const(char*) what, int type, int current, int total);

	/* Status messages from gpg. */
	alias gpgme_status_cb_t = gpgme_error_t function(void* opaque, const(char*) keyword, const(char*) args);

	/* Interact with the user about an edit operation.  */
	alias gpgme_edit_cb_t = gpgme_error_t function(void* opaque, gpgme_status_code_t status, const(char*) args, int fd);

}


/*
 * Context management functions.
 */


extern(C) nothrow @nogc {
	
	/* Create a new context and return it in CTX.  */
	gpgme_error_t gpgme_new(gpgme_ctx_t* ctx);
	
	/* Release the context CTX.  */
	void gpgme_release(gpgme_ctx_t ctx);
	
	/* Set the protocol to be used by CTX to PROTO.  */
	gpgme_error_t gpgme_set_protocol(gpgme_ctx_t ctx, gpgme_protocol_t proto);
	
	/* Get the protocol used with CTX */
	gpgme_protocol_t gpgme_get_protocol(gpgme_ctx_t ctx);
	
	/* Set the crypto protocol to be used by CTX to PROTO.
	   gpgme_set_protocol actually sets the backend engine.  This sets the
	   crypto protocol used in engines that support more than one crypto
	   prococol (for example, an UISERVER can support OpenPGP and CMS).
	   This is reset to the default with gpgme_set_protocol.  */
	gpgme_error_t gpgme_set_sub_protocol(gpgme_ctx_t ctx, gpgme_protocol_t proto);
	
	/* Get the sub protocol.  */
	gpgme_protocol_t gpgme_get_sub_protocol(gpgme_ctx_t ctx);
	
	/* Get the string describing protocol PROTO, or NULL if invalid.  */
	const(char*) gpgme_get_protocol_name(gpgme_protocol_t proto);
	
	/* If YES is non-zero, enable armor mode in CTX, disable it otherwise.  */
	void gpgme_set_armor(gpgme_ctx_t ctx, int yes);
	
	/* Return non-zero if armor mode is set in CTX.  */
	int gpgme_get_armor(gpgme_ctx_t ctx);
	
	/* If YES is non-zero, enable text mode in CTX, disable it otherwise.  */
	void gpgme_set_textmode(gpgme_ctx_t ctx, int yes);
	
	/* Return non-zero if text mode is set in CTX.  */
	int gpgme_get_textmode(gpgme_ctx_t ctx);
	
	/* If YES is non-zero, enable offline mode in CTX, disable it otherwise.  */
	void gpgme_set_offline(gpgme_ctx_t ctx, int yes);
	
	/* Return non-zero if offline mode is set in CTX.  */
	int gpgme_get_offline(gpgme_ctx_t ctx);
	
	/* Use whatever the default of the backend crypto engine is.  */
	enum GPGME_INCLUDE_CERTS_DEFAULT = -256;
	
	/* Include up to NR_OF_CERTS certificates in an S/MIME message.  */
	void gpgme_set_include_certs(gpgme_ctx_t ctx, int nr_of_certs);
	
	/* Return the number of certs to include in an S/MIME message.  */
	int gpgme_get_include_certs(gpgme_ctx_t ctx);
	
	/* Set keylist mode in CTX to MODE.  */
	gpgme_error_t gpgme_set_keylist_mode(gpgme_ctx_t ctx, gpgme_keylist_mode_t mode);
	
	/* Get keylist mode in CTX.  */
	gpgme_keylist_mode_t gpgme_get_keylist_mode(gpgme_ctx_t ctx);
	
	/* Set the pinentry mode for CTX to MODE. */
	gpgme_error_t gpgme_set_pinentry_mode(gpgme_ctx_t ctx, gpgme_pinentry_mode_t mode);
	
	/* Get the pinentry mode of CTX.  */
	gpgme_pinentry_mode_t gpgme_get_pinentry_mode(gpgme_ctx_t ctx);
	
	/* Set the passphrase callback function in CTX to CB.  HOOK_VALUE is passed as first argument to the passphrase callback function.  */
	void gpgme_set_passphrase_cb(gpgme_ctx_t ctx, gpgme_passphrase_cb_t cb, void* hook_value);
	
	/* Get the current passphrase callback function in *CB and the current hook value in *HOOK_VALUE.  */
	void gpgme_get_passphrase_cb(gpgme_ctx_t ctx, gpgme_passphrase_cb_t* cb, void** hook_value);
	
	/* Set the progress callback function in CTX to CB.  HOOK_VALUE is passed as first argument to the progress callback function.  */
	void gpgme_set_progress_cb(gpgme_ctx_t c, gpgme_progress_cb_t cb, void* hook_value);
	
	/* Get the current progress callback function in *CB and the current hook value in *HOOK_VALUE.  */
	void gpgme_get_progress_cb(gpgme_ctx_t ctx, gpgme_progress_cb_t *cb,
				    void **hook_value);
	
	/* Set the status callback function in CTX to CB.  HOOK_VALUE is passed as first argument to thes status callback function.  */
	void gpgme_set_status_cb(gpgme_ctx_t c, gpgme_status_cb_t cb, void* hook_value);
	
	/* Get the current status callback function in *CB and the current hook value in *HOOK_VALUE.  */
	void gpgme_get_status_cb(gpgme_ctx_t ctx, gpgme_status_cb_t *cb, void** hook_value);
	
	/* This function sets the locale for the context CTX, or the default locale if CTX is a null pointer.  */
	gpgme_error_t gpgme_set_locale(gpgme_ctx_t ctx, int category, const(char*) value);
	
	/* Get the information about the configured engines.  A pointer to the
	   first engine in the statically allocated linked list is returned.
	   The returned data is valid until the next gpgme_ctx_set_engine_info.  */
	gpgme_engine_info_t gpgme_ctx_get_engine_info(gpgme_ctx_t ctx);
	
	/* Set the engine info for the context CTX, protocol PROTO, to the file name FILE_NAME and the home directory HOME_DIR.  */
	gpgme_error_t gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, gpgme_protocol_t proto, const(char*) file_name, const(char*) home_dir);
	
	/* Delete all signers from CTX.  */
	void gpgme_signers_clear(gpgme_ctx_t ctx);
	
	/* Add KEY to list of signers in CTX.  */
	gpgme_error_t gpgme_signers_add(gpgme_ctx_t ctx, const gpgme_key_t key);
	
	/* Return the number of signers in CTX.  */
	uint gpgme_signers_count(const gpgme_ctx_t ctx);
	
	/* Return the SEQth signer's key in CTX.  */
	gpgme_key_t gpgme_signers_enum(const gpgme_ctx_t ctx, int seq);
	
	/* Retrieve the signature status of signature IDX in CTX after a
	   successful verify operation in R_STAT (if non-null).  The creation
	   time stamp of the signature is returned in R_CREATED (if non-null).
	   The function returns a string containing the fingerprint.
	   Deprecated, use verify result directly.  */
	deprecated const(char*) gpgme_get_sig_status(gpgme_ctx_t ctx, int idx, _gpgme_sig_stat_t* r_stat, time_t* r_created);
	
	/* Retrieve certain attributes of a signature.  IDX is the index
	   number of the signature after a successful verify operation.  WHAT
	   is an attribute where GPGME_ATTR_EXPIRE is probably the most useful
	   one.  WHATIDX is to be passed as 0 for most attributes . */
	deprecated ulong gpgme_get_sig_ulong_attr(gpgme_ctx_t c, int idx, _gpgme_attr_t what, int whatidx);
	
	deprecated const(char*) gpgme_get_sig_string_attr(gpgme_ctx_t c, int idx, _gpgme_attr_t what, int whatidx);
	
	/* Get the key used to create signature IDX in CTX and return it in R_KEY.  */
	deprecated gpgme_error_t gpgme_get_sig_key(gpgme_ctx_t ctx, int idx, gpgme_key_t* r_key);
	
	/* Clear all notation data from the context.  */
	void gpgme_sig_notation_clear(gpgme_ctx_t ctx);
	
	/* Add the human-readable notation data with name NAME and value VALUE
	   to the context CTX, using the flags FLAGS.  If NAME is NULL, then
	   VALUE should be a policy URL.  The flag
	   GPGME_SIG_NOTATION_HUMAN_READABLE is forced to be true for notation
	   data, and false for policy URLs.  */
	gpgme_error_t gpgme_sig_notation_add(gpgme_ctx_t ctx, const(char*) name, const(char*) value, gpgme_sig_notation_flags_t flags);
	
	/* Get the sig notations for this context.  */
	gpgme_sig_notation_t gpgme_sig_notation_get(gpgme_ctx_t ctx);

}


/*
 * Run control.
 */

enum gpgme_event_io_t {
	GPGME_EVENT_START,
	GPGME_EVENT_DONE,
	GPGME_EVENT_NEXT_KEY,
	GPGME_EVENT_NEXT_TRUSTITEM
}

struct gpgme_io_event_done_data {
	/* A fatal IPC error or an operational error in state-less protocols.  */
	gpgme_error_t err;

	/* An operational errors in session-based protocols.  */
	gpgme_error_t op_err;
}

alias gpgme_io_event_done_data_t = gpgme_io_event_done_data*;

struct gpgme_io_cbs {
	gpgme_register_io_cb_t add;
	void* add_priv;
	gpgme_remove_io_cb_t remove;
	gpgme_event_io_cb_t event;
	void* event_priv;
}

alias gpgme_io_cbs_t = gpgme_io_cbs*;

extern(C) nothrow @nogc {
	
	/* The type of an I/O callback function.  */
	alias gpgme_io_cb_t = gpgme_error_t function(void* data, int fd);

	/* The type of a function that can register FNC as the I/O callback
	   function for the file descriptor FD with direction dir (0: for writing,
	   1: for reading).  FNC_DATA should be passed as DATA to FNC.  The
	   function should return a TAG suitable for the corresponding
	   gpgme_remove_io_cb_t, and an error value.  */
	alias gpgme_register_io_cb_t = gpgme_error_t function(void* data, int fd, int dir, gpgme_io_cb_t fnc, void* fnc_data, void** tag);
	
	/* The type of a function that can remove a previously registered I/O
	   callback function given TAG as returned by the register
	   function.  */
	alias gpgme_remove_io_cb_t = void function(void* tag);
	
	/* The type of a function that is called when a context finished an peration.  */
	alias gpgme_event_io_cb_t = void function(void* data, gpgme_event_io_t type, void* type_data);
	
	/* Set the I/O callback functions in CTX to IO_CBS.  */
	void gpgme_set_io_cbs(gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs);
	
	/* Get the current I/O callback functions.  */
	void gpgme_get_io_cbs(gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs);
	
	/* Wrappers around the internal I/O functions for use with gpgme_passphrase_cb_t and gpgme_edit_cb_t.  */
	ptrdiff_t gpgme_io_read(int fd, void* buffer, size_t count);
	
	ptrdiff_t gpgme_io_write(int fd, const(void*) buffer, size_t count);
	
	int gpgme_io_writen(int fd, const(void*) buffer, size_t count);
	
	/* Process the pending operation and, if HANG is non-zero, wait for the pending operation to finish.  */
	gpgme_ctx_t gpgme_wait(gpgme_ctx_t ctx, gpgme_error_t* status, int hang);
	
	gpgme_ctx_t gpgme_wait_ext(gpgme_ctx_t ctx, gpgme_error_t* status, gpgme_error_t* op_err, int hang);
	
	/* Cancel a pending asynchronous operation.  */
	gpgme_error_t gpgme_cancel(gpgme_ctx_t ctx);
	
	/* Cancel a pending operation asynchronously.  */
	gpgme_error_t gpgme_cancel_async(gpgme_ctx_t ctx);

}


/*
 * Functions to handle data objects.
 */


struct gpgme_data_cbs {
	gpgme_data_read_cb_t read;
	gpgme_data_write_cb_t write;
	gpgme_data_seek_cb_t seek;
	gpgme_data_release_cb_t release;
}

alias gpgme_data_cbs_t = gpgme_data_cbs*;

extern(C) nothrow @nogc {
	
	/* Read up to SIZE bytes into buffer BUFFER from the data object with
   		the handle HANDLE.  Return the number of characters read, 0 on EOF
   		and -1 on error.  If an error occurs, errno is set.  */
	alias gpgme_data_read_cb_t = ptrdiff_t function(void* handle, void* buffer, size_t size);
	
	/* Write up to SIZE bytes from buffer BUFFER to the data object with
	   the handle HANDLE.  Return the number of characters written, or -1
	   on error.  If an error occurs, errno is set.  */
	alias gpgme_data_write_cb_t = ptrdiff_t function(void* handle, const(void*) buffer, size_t size);
	
	/* Set the current position from where the next read or write starts
	   in the data object with the handle HANDLE to OFFSET, relativ to
	   WHENCE.  */
	alias gpgme_data_seek_cb_t = off_t function(void* handle, off_t offset, int whence);
	
	/* Close the data object with the handle DL.  */
	alias gpgme_data_release_cb_t = void function(void* handle);

	/* Read up to SIZE bytes into buffer BUFFER from the data object with
	   the handle DH.  Return the number of characters read, 0 on EOF and
	   -1 on error.  If an error occurs, errno is set.  */
	ptrdiff_t gpgme_data_read(gpgme_data_t dh, void* buffer, size_t size);
	
	/* Write up to SIZE bytes from buffer BUFFER to the data object with
	   the handle DH.  Return the number of characters written, or -1 on
	   error.  If an error occurs, errno is set.  */
	ptrdiff_t gpgme_data_write(gpgme_data_t dh, const(void*) buffer, size_t size);
	
	/* Set the current position from where the next read or write starts
	   in the data object with the handle DH to OFFSET, relativ to
	   WHENCE.  */
	off_t gpgme_data_seek(gpgme_data_t dh, off_t offset, int whence);
	
	/* Create a new data buffer and return it in R_DH.  */
	gpgme_error_t gpgme_data_new(gpgme_data_t* r_dh);
	
	/* Destroy the data buffer DH.  */
	void gpgme_data_release(gpgme_data_t dh);
	
	/* Create a new data buffer filled with SIZE bytes starting from
	   BUFFER.  If COPY is zero, copying is delayed until necessary, and
	   the data is taken from the original location when needed.  */
	gpgme_error_t gpgme_data_new_from_mem(gpgme_data_t* r_dh, const(char*) buffer, size_t size, int copy);
	
	/* Destroy the data buffer DH and return a pointer to its content.
	   The memory has be to released with gpgme_free() by the user.  It's
	   size is returned in R_LEN.  */
	char* gpgme_data_release_and_get_mem(gpgme_data_t dh, size_t* r_len);
	
	/* Release the memory returned by gpgme_data_release_and_get_mem().  */
	void gpgme_free(void* buffer);
	
	gpgme_error_t gpgme_data_new_from_cbs(gpgme_data_t* dh, gpgme_data_cbs_t cbs, void* handle);
	
	gpgme_error_t gpgme_data_new_from_fd(gpgme_data_t* dh, int fd);
	
	gpgme_error_t gpgme_data_new_from_stream(gpgme_data_t* dh, FILE* stream);
	
	/* Return the encoding attribute of the data buffer DH */
	gpgme_data_encoding_t gpgme_data_get_encoding(gpgme_data_t dh);
	
	/* Set the encoding attribute of data buffer DH to ENC */
	gpgme_error_t gpgme_data_set_encoding(gpgme_data_t dh, gpgme_data_encoding_t enc);
	
	/* Get the file name associated with the data object with handle DH, or NULL if there is none.  */
	char* gpgme_data_get_file_name(gpgme_data_t dh);
	
	/* Set the file name associated with the data object with handle DH to FILE_NAME.  */
	gpgme_error_t gpgme_data_set_file_name(gpgme_data_t dh, const(char*) file_name);
	
	/* Try to identify the type of the data in DH.  */
	gpgme_data_type_t gpgme_data_identify(gpgme_data_t dh, int reserved);
	
	/* Create a new data buffer which retrieves the data from the callback
	   function READ_CB.  Deprecated, please use gpgme_data_new_from_cbs
	   instead.  */
	gpgme_error_t gpgme_data_new_with_read_cb(gpgme_data_t* r_dh, int function(void*, char*, size_t, size_t*) read_cb, void* read_cb_value);
	
	/* Create a new data buffer filled with the content of file FNAME.
	   COPY must be non-zero.  For delayed read, please use
	   gpgme_data_new_from_fd or gpgme_data_new_from stream instead.  */
	gpgme_error_t gpgme_data_new_from_file(gpgme_data_t* r_dh, const(char*) fname, int copy);
	
	/* Create a new data buffer filled with LENGTH bytes starting from
	   OFFSET within the file FNAME or stream FP (exactly one must be
	   non-zero).  */
	gpgme_error_t gpgme_data_new_from_filepart(gpgme_data_t* r_dh, const(char*) fname, FILE* fp, off_t offset, size_t length);
	
	/* Reset the read pointer in DH.  Deprecated, please use gpgme_data_seek instead.  */
	deprecated gpgme_error_t gpgme_data_rewind(gpgme_data_t dh);

}

/*
 * Key and trust functions.
 */


extern(C) nothrow @nogc {
	
	/* Get the key with the fingerprint FPR from the crypto backend.  If
	   SECRET is true, get the secret key.  */
	gpgme_error_t gpgme_get_key(gpgme_ctx_t ctx, const(char*) fpr, gpgme_key_t* r_key, int secret);
	
	/* Create a dummy key to specify an email address.  */
	gpgme_error_t gpgme_key_from_uid(gpgme_key_t* key, const(char*) name);
	
	/* Acquire a reference to KEY.  */
	void gpgme_key_ref(gpgme_key_t key);
	
	/* Release a reference to KEY.  If this was the last one the key is destroyed.  */
	void gpgme_key_unref(gpgme_key_t key);
	void gpgme_key_release(gpgme_key_t key);
	
	/* Return the value of the attribute WHAT of KEY, which has to be
	   representable by a string.  IDX specifies the sub key or user ID
	   for attributes related to sub keys or user IDs.  Deprecated, use
	   key structure directly instead. */
	deprecated const(char*) gpgme_key_get_string_attr(gpgme_key_t key, _gpgme_attr_t what, const(void*) reserved, int idx);
	
	/* Return the value of the attribute WHAT of KEY, which has to be
	   representable by an unsigned integer.  IDX specifies the sub key or
	   user ID for attributes related to sub keys or user IDs.
	   Deprecated, use key structure directly instead.  */
	deprecated ulong gpgme_key_get_ulong_attr(gpgme_key_t key, _gpgme_attr_t what, const(void*) reserved, int idx);
	
	/* Return the value of the attribute WHAT of a signature on user ID
	   UID_IDX in KEY, which has to be representable by a string.  IDX
	   specifies the signature.  Deprecated, use key structure directly
	   instead.  */
	deprecated const(char*) gpgme_key_sig_get_string_attr(gpgme_key_t key, int uid_idx, _gpgme_attr_t what, const(void*) reserved, int idx);
	
	/* Return the value of the attribute WHAT of a signature on user ID
	   UID_IDX in KEY, which has to be representable by an unsigned
	   integer string.  IDX specifies the signature.  Deprecated, use key
	   structure directly instead.  */
	deprecated ulong gpgme_key_sig_get_ulong_attr(gpgme_key_t key, int uid_idx, _gpgme_attr_t what, const(void*) reserved, int idx);

}


/*
 * Encryption.
 */


struct _gpgme_op_encrypt_result {
	/* The list of invalid recipients.  */
	gpgme_invalid_key_t invalid_recipients;
}

alias gpgme_encrypt_result_t = _gpgme_op_encrypt_result*;

/* The valid encryption flags.  */
enum gpgme_encrypt_flags_t {
	GPGME_ENCRYPT_ALWAYS_TRUST = 1,
	GPGME_ENCRYPT_NO_ENCRYPT_TO = 2,
	GPGME_ENCRYPT_PREPARE = 4,
	GPGME_ENCRYPT_EXPECT_SIGN = 8,
	GPGME_ENCRYPT_NO_COMPRESS = 16
}

extern(C) nothrow @nogc {
	
	/* Retrieve a pointer to the result of the encrypt operation.  */
	gpgme_encrypt_result_t gpgme_op_encrypt_result(gpgme_ctx_t ctx);
	
	/* Encrypt plaintext PLAIN within CTX for the recipients RECP and store the resulting ciphertext in CIPHER.  */
	gpgme_error_t gpgme_op_encrypt_start(gpgme_ctx_t ctx, gpgme_key_t[] recp, gpgme_encrypt_flags_t flags, gpgme_data_t plain, gpgme_data_t cipher);
	
	gpgme_error_t gpgme_op_encrypt(gpgme_ctx_t ctx, gpgme_key_t[] recp, gpgme_encrypt_flags_t flags, gpgme_data_t plain, gpgme_data_t cipher);
	
	/* Encrypt plaintext PLAIN within CTX for the recipients RECP and
	   store the resulting ciphertext in CIPHER.  Also sign the ciphertext
	   with the signers in CTX.  */
	gpgme_error_t gpgme_op_encrypt_sign_start(gpgme_ctx_t ctx, gpgme_key_t[] recp, gpgme_encrypt_flags_t flags, gpgme_data_t plain, gpgme_data_t cipher);
	
	gpgme_error_t gpgme_op_encrypt_sign (gpgme_ctx_t ctx, gpgme_key_t[] recp, gpgme_encrypt_flags_t flags, gpgme_data_t plain, gpgme_data_t cipher);

}


/*
 * Decryption.
 */

struct _gpgme_recipient {
	
	_gpgme_recipient* next;

	/* The key ID of key for which the text was encrypted.  */
	char* keyid;

	/* Internal to GPGME, do not use.  */
	char[16 + 1] _keyid;

	/* The public key algorithm of the recipient key.  */
	gpgme_pubkey_algo_t pubkey_algo;

	/* The status of the recipient.  */
	gpgme_error_t status;
}

alias gpgme_recipient_t = _gpgme_recipient*;

struct _gpgme_op_decrypt_result {
	
	char* unsupported_algorithm;

	mixin(bitfields!(
        uint, "wrong_key_usage",	1, /* Key should not have been used for encryption.  */
        int, "_unused",	31, /* Internal to GPGME, do not use.  */
    ));

	gpgme_recipient_t recipients;

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

alias gpgme_decrypt_result_t = _gpgme_op_decrypt_result*;

extern(C) nothrow @nogc {
	
	/* Retrieve a pointer to the result of the decrypt operation.  */
	gpgme_decrypt_result_t gpgme_op_decrypt_result(gpgme_ctx_t ctx);
	
	/* Decrypt ciphertext CIPHER within CTX and store the resulting plaintext in PLAIN.  */
	gpgme_error_t gpgme_op_decrypt_start(gpgme_ctx_t ctx, gpgme_data_t cipher, gpgme_data_t plain);
	
	gpgme_error_t gpgme_op_decrypt(gpgme_ctx_t ctx, gpgme_data_t cipher, gpgme_data_t plain);
	
	/* Decrypt ciphertext CIPHER and make a signature verification within CTX and store the resulting plaintext in PLAIN.  */
	gpgme_error_t gpgme_op_decrypt_verify_start(gpgme_ctx_t ctx, gpgme_data_t cipher, gpgme_data_t plain);
	
	gpgme_error_t gpgme_op_decrypt_verify(gpgme_ctx_t ctx, gpgme_data_t cipher, gpgme_data_t plain);
	
}


/*
 * Signing.
 */


struct _gpgme_new_signature {
	
	_gpgme_new_signature* next;

	/* The type of the signature.  */
	gpgme_sig_mode_t type;

	/* The public key algorithm used to create the signature.  */
	gpgme_pubkey_algo_t pubkey_algo;

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

	/* Internal to GPGME, do not use.  Must be set to the same value as CLASS below.  */
	ulong _obsolete_class;

	/* Signature creation time.  */
	long timestamp;

	/* The fingerprint of the signature.  */
	char* fpr;

	uint _obsolete_class_2;

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

alias gpgme_new_signature_t = _gpgme_new_signature*;

struct _gpgme_op_sign_result {
	/* The list of invalid signers.  */
	gpgme_invalid_key_t invalid_signers;
	gpgme_new_signature_t signatures;
}

alias gpgme_sign_result_t = _gpgme_op_sign_result*;

extern(C) nothrow @nogc {
	
	/* Retrieve a pointer to the result of the signing operation.  */
	gpgme_sign_result_t gpgme_op_sign_result (gpgme_ctx_t ctx);
	
	/* Sign the plaintext PLAIN and store the signature in SIG.  */
	gpgme_error_t gpgme_op_sign_start (gpgme_ctx_t ctx, gpgme_data_t plain, gpgme_data_t sig, gpgme_sig_mode_t mode);
	
	gpgme_error_t gpgme_op_sign (gpgme_ctx_t ctx, gpgme_data_t plain, gpgme_data_t sig, gpgme_sig_mode_t mode);

}


/*
 * Verify.
 */


/* Flags used for the SUMMARY field in a gpgme_signature_t.  */
enum gpgme_sigsum_t {
	GPGME_SIGSUM_VALID       = 0x0001,  /* The signature is fully valid.  */
	GPGME_SIGSUM_GREEN       = 0x0002,  /* The signature is good.  */
	GPGME_SIGSUM_RED         = 0x0004,  /* The signature is bad.  */
	GPGME_SIGSUM_KEY_REVOKED = 0x0010,  /* One key has been revoked.  */
	GPGME_SIGSUM_KEY_EXPIRED = 0x0020,  /* One key has expired.  */
	GPGME_SIGSUM_SIG_EXPIRED = 0x0040,  /* The signature has expired.  */
	GPGME_SIGSUM_KEY_MISSING = 0x0080,  /* Can't verify: key missing.  */
	GPGME_SIGSUM_CRL_MISSING = 0x0100,  /* CRL not available.  */
	GPGME_SIGSUM_CRL_TOO_OLD = 0x0200,  /* Available CRL is too old.  */
	GPGME_SIGSUM_BAD_POLICY  = 0x0400,  /* A policy was not met.  */
	GPGME_SIGSUM_SYS_ERROR   = 0x0800   /* A system error occured.  */
}

struct _gpgme_signature {
	
	_gpgme_signature* next;

	/* A summary of the signature status.  */
	gpgme_sigsum_t summary;

	/* The fingerprint or key ID of the signature.  */
	char* fpr;

	/* The status of the signature.  */
	gpgme_error_t status;

	/* Notation data and policy URLs.  */
	gpgme_sig_notation_t notations;

	/* Signature creation time.  */
	ulong timestamp;

	/* Signature exipration time or 0.  */
	ulong exp_timestamp;
	
	mixin(bitfields!(
        uint, "wrong_key_usage",	1, /* Key should not have been used for signing.  */
        uint, "pka_trust",	2, /* PKA status: 0 = not available, 1 = bad, 2 = okay, 3 = RFU. */
        uint, "chain_model",	1, /* Validity has been verified using the chain model. */
        int, "_unused",	28, /* Internal to GPGME, do not use.  */
    ));

	gpgme_validity_t validity;
	gpgme_error_t validity_reason;

	/* The public key algorithm used to create the signature.  */
	gpgme_pubkey_algo_t pubkey_algo;

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

	/* The mailbox from the PKA information or NULL. */
	char* pka_address;
}

alias gpgme_signature_t = _gpgme_signature*;

struct _gpgme_op_verify_result {
	gpgme_signature_t signatures;

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

alias gpgme_verify_result_t = _gpgme_op_verify_result*;

extern(C) nothrow @nogc {
	
	/* Retrieve a pointer to the result of the verify operation.  */
	gpgme_verify_result_t gpgme_op_verify_result(gpgme_ctx_t ctx);
	
	/* Verify within CTX that SIG is a valid signature for TEXT.  */
	gpgme_error_t gpgme_op_verify_start(gpgme_ctx_t ctx, gpgme_data_t sig, gpgme_data_t signed_text, gpgme_data_t plaintext);
	
	gpgme_error_t gpgme_op_verify (gpgme_ctx_t ctx, gpgme_data_t sig, gpgme_data_t signed_text, gpgme_data_t plaintext);

}


/*
 * Import/Export
 */

enum {
	GPGME_IMPORT_NEW = 1,  /* The key was new.  */
	GPGME_IMPORT_UID = 2,  /* The key contained new user IDs.  */
	GPGME_IMPORT_SIG = 4,  /* The key contained new signatures.  */
	GPGME_IMPORT_SUBKEY = 8,  /* The key contained new sub keys.  */
	GPGME_IMPORT_SECRET = 16  /* The key contained a secret key.  */
}

struct _gpgme_import_status {

	_gpgme_import_status* next;

	/* Fingerprint.  */
	char* fpr;

	/* If a problem occured, the reason why the key could not be
		imported.  Otherwise GPGME_No_Error.  */
	gpgme_error_t result;

	/* The result of the import, the GPGME_IMPORT_* values bit-wise
     ORed.  0 means the key was already known and no new components
     have been added.  */
	uint status;
}

alias gpgme_import_status_t = _gpgme_import_status*;

/* Import result object.  */
struct _gpgme_op_import_result {
	
	/* Number of considered keys.  */
	int considered;

	/* Keys without user ID.  */
	int no_user_id;

	/* Imported keys.  */
	int imported;

	/* Imported RSA keys.  */
	int imported_rsa;

	/* Unchanged keys.  */
	int unchanged;

	/* Number of new user ids.  */
	int new_user_ids;

	/* Number of new sub keys.  */
	int new_sub_keys;

	/* Number of new signatures.  */
	int new_signatures;

	/* Number of new revocations.  */
	int new_revocations;

	/* Number of secret keys read.  */
	int secret_read;

	/* Number of secret keys imported.  */
	int secret_imported;

	/* Number of secret keys unchanged.  */
	int secret_unchanged;

	/* Number of new keys skipped.  */
	int skipped_new_keys;

	/* Number of keys not imported.  */
	int not_imported;

	/* List of keys for which an import was attempted.  */
	gpgme_import_status_t imports;
}

alias gpgme_import_result_t = _gpgme_op_import_result*;

extern(C) nothrow @nogc {
	
	/* Retrieve a pointer to the result of the import operation.  */
	gpgme_import_result_t gpgme_op_import_result(gpgme_ctx_t ctx);
	
	/* Import the key in KEYDATA into the keyring.  */
	gpgme_error_t gpgme_op_import_start(gpgme_ctx_t ctx, gpgme_data_t keydata);
	
	gpgme_error_t gpgme_op_import(gpgme_ctx_t ctx, gpgme_data_t keydata);
	
	deprecated gpgme_error_t gpgme_op_import_ext(gpgme_ctx_t ctx, gpgme_data_t keydata, int* nr);
	
	/* Import the keys from the array KEYS into the keyring.  */
	gpgme_error_t gpgme_op_import_keys_start(gpgme_ctx_t ctx, gpgme_key_t[] keys);
	
	gpgme_error_t gpgme_op_import_keys(gpgme_ctx_t ctx, gpgme_key_t[] keys);
	
	/* Export the keys found by PATTERN into KEYDATA.  */
	gpgme_error_t gpgme_op_export_start(gpgme_ctx_t ctx, const(char*) pattern, gpgme_export_mode_t mode, gpgme_data_t keydata);
	
	gpgme_error_t gpgme_op_export(gpgme_ctx_t ctx, const(char*) pattern, gpgme_export_mode_t mode, gpgme_data_t keydata);
	
	gpgme_error_t gpgme_op_export_ext_start(gpgme_ctx_t ctx, const(char*)[] pattern, gpgme_export_mode_t mode, gpgme_data_t keydata);
	
	gpgme_error_t gpgme_op_export_ext(gpgme_ctx_t ctx, const(char*)[] pattern, gpgme_export_mode_t mode, gpgme_data_t keydata);
	
	/* Export the keys from the array KEYS into KEYDATA.  */
	gpgme_error_t gpgme_op_export_keys_start(gpgme_ctx_t ctx, gpgme_key_t[] keys, gpgme_export_mode_t mode, gpgme_data_t keydata);
	
	gpgme_error_t gpgme_op_export_keys(gpgme_ctx_t ctx, gpgme_key_t[] keys, gpgme_export_mode_t mode, gpgme_data_t keydata);

}


/*
 * Key generation.
 */


struct _gpgme_op_genkey_result {
	
	mixin(bitfields!(
        uint, "primary",	1, /* A primary key was generated.  */
        uint, "sub",	1, /* A sub key was generated.  */
        int, "_unused",	30, /* Internal to GPGME, do not use.  */
    ));
	
	/* The fingerprint of the generated key.  */
	char* fpr;
}

alias gpgme_genkey_result_t = _gpgme_op_genkey_result*;

extern(C) nothrow @nogc {

	/* Generate a new keypair and add it to the keyring.  PUBKEY and
	   SECKEY should be null for now.  PARMS specifies what keys should be
	   generated.  */
	gpgme_error_t gpgme_op_genkey_start(gpgme_ctx_t ctx, const(char*) parms, gpgme_data_t pubkey, gpgme_data_t seckey);
	
	gpgme_error_t gpgme_op_genkey(gpgme_ctx_t ctx, const(char*) parms, gpgme_data_t pubkey, gpgme_data_t seckey);
	
	/* Retrieve a pointer to the result of the genkey operation.  */
	gpgme_genkey_result_t gpgme_op_genkey_result(gpgme_ctx_t ctx);
	
	/* Delete KEY from the keyring.  If ALLOW_SECRET is non-zero, secret keys are also deleted.  */
	gpgme_error_t gpgme_op_delete_start(gpgme_ctx_t ctx, const gpgme_key_t key, int allow_secret);
	
	gpgme_error_t gpgme_op_delete(gpgme_ctx_t ctx, const gpgme_key_t key, int allow_secret);

}


/*
 * Key Edit interface
 */


extern(C) nothrow @nogc {
	
	/* Edit the key KEY.  Send status and command requests to FNC and output of edit commands to OUT.  */
	gpgme_error_t gpgme_op_edit_start(gpgme_ctx_t ctx, gpgme_key_t key, gpgme_edit_cb_t fnc, void* fnc_value, gpgme_data_t out_);
	
	gpgme_error_t gpgme_op_edit(gpgme_ctx_t ctx, gpgme_key_t key, gpgme_edit_cb_t fnc, void* fnc_value, gpgme_data_t out_);
	
	/* Edit the card for the key KEY.  Send status and command requests to FNC and output of edit commands to OUT.  */
	gpgme_error_t gpgme_op_card_edit_start(gpgme_ctx_t ctx, gpgme_key_t key, gpgme_edit_cb_t fnc, void* fnc_value, gpgme_data_t out_);
	
	gpgme_error_t gpgme_op_card_edit(gpgme_ctx_t ctx, gpgme_key_t key, gpgme_edit_cb_t fnc, void* fnc_value, gpgme_data_t out_);

}

/*
 * Key listing
 */

struct _gpgme_op_keylist_result {
	mixin(bitfields!(
        uint, "truncated",	1,
        uint, "_unused",	31, /* Internal to GPGME, do not use.  */
    ));
}

alias gpgme_keylist_result_t = _gpgme_op_keylist_result*;

extern(C) nothrow @nogc {
	
	/* Retrieve a pointer to the result of the key listing operation.  */
	gpgme_keylist_result_t gpgme_op_keylist_result(gpgme_ctx_t ctx);
	
	/* Start a keylist operation within CTX, searching for keys which
	   match PATTERN.  If SECRET_ONLY is true, only secret keys are
	   returned.  */
	gpgme_error_t gpgme_op_keylist_start(gpgme_ctx_t ctx, const(char*) pattern, int secret_only);
	
	gpgme_error_t gpgme_op_keylist_ext_start(gpgme_ctx_t ctx, const(char*)[] pattern, int secret_only, int reserved);
	
	/* Return the next key from the keylist in R_KEY.  */
	gpgme_error_t gpgme_op_keylist_next(gpgme_ctx_t ctx, gpgme_key_t* r_key);
	
	/* Terminate a pending keylist operation within CTX.  */
	gpgme_error_t gpgme_op_keylist_end(gpgme_ctx_t ctx);
	
	/* Change the passphrase for KEY.  FLAGS is reserved for future use and must be passed as 0.  */
	gpgme_error_t gpgme_op_passwd_start(gpgme_ctx_t ctx, gpgme_key_t key, uint flags);
	
	gpgme_error_t gpgme_op_passwd(gpgme_ctx_t ctx, gpgme_key_t key, uint flags);

}


/*
 * Trust items and operations.
 */


struct _gpgme_trust_item {
	/* Internal to GPGME, do not use.  */
	uint _refs;

	/* The key ID to which the trust item belongs.  */
	char* keyid;

	/* Internal to GPGME, do not use.  */
	char[16 + 1] _keyid;

	/* The type of the trust item, 1 refers to a key, 2 to a user ID.  */
	int type;

	/* The trust level.  */
	int level;

	/* The owner trust if TYPE is 1.  */
	char* owner_trust;

	/* Internal to GPGME, do not use.  */
	char[2] _owner_trust;

	/* The calculated validity.  */
	char* validity;

	/* Internal to GPGME, do not use.  */
	char[2] _validity;

	/* The user name if TYPE is 2.  */
	char* name;
}

alias gpgme_trust_item_t = _gpgme_trust_item*;

extern(C) nothrow @nogc {
	
	/* Start a trustlist operation within CTX, searching for trust items which match PATTERN.  */
	gpgme_error_t gpgme_op_trustlist_start(gpgme_ctx_t ctx, const(char*) pattern, int max_level);
	
	/* Return the next trust item from the trustlist in R_ITEM.  */
	gpgme_error_t gpgme_op_trustlist_next(gpgme_ctx_t ctx, gpgme_trust_item_t* r_item);
	
	/* Terminate a pending trustlist operation within CTX.  */
	gpgme_error_t gpgme_op_trustlist_end(gpgme_ctx_t ctx);
	
	/* Acquire a reference to ITEM.  */
	void gpgme_trust_item_ref(gpgme_trust_item_t item);
	
	/* Release a reference to ITEM.  If this was the last one the trust item is destroyed.  */
	void gpgme_trust_item_unref(gpgme_trust_item_t item);
	
	/* Release the trust item ITEM.  Deprecated, use gpgme_trust_item_unref.  */
	deprecated void gpgme_trust_item_release(gpgme_trust_item_t item);
	
	/* Return the value of the attribute WHAT of ITEM, which has to be
	   representable by a string.  Deprecated, use trust item structure
	   directly.  */
	deprecated const(char*) gpgme_trust_item_get_string_attr(gpgme_trust_item_t item, _gpgme_attr_t what, const(void*) reserved, int idx);
	
	/* Return the value of the attribute WHAT of KEY, which has to be
	   representable by an integer.  IDX specifies a running index if the
	   attribute appears more than once in the key.  Deprecated, use trust
	   item structure directly.  */
	deprecated int gpgme_trust_item_get_int_attr(gpgme_trust_item_t item, _gpgme_attr_t what, const(void*) reserved, int idx);

}


/*
 * Audit log
 */


extern(C) nothrow @nogc {

	/* Return the auditlog for the current session.  This may be called
	   after a successful or failed operation.  If no audit log is
	   available GPG_ERR_NO_DATA is returned.  */
	gpgme_error_t gpgme_op_getauditlog_start(gpgme_ctx_t ctx, gpgme_data_t output, uint flags);
	
	gpgme_error_t gpgme_op_getauditlog(gpgme_ctx_t ctx, gpgme_data_t output, uint flags);

}


/*
 * Spawn interface
 */


/* Flags for the spawn operations.  */
enum {
	GPGME_SPAWN_DETACHED = 1,
	GPGME_SPAWN_ALLOW_SET_FG = 2
}

extern(C) nothrow @nogc {
	
	/* Run the command FILE with the arguments in ARGV.  Connect stdin to
	   DATAIN, stdout to DATAOUT, and STDERR to DATAERR.  If one the data
	   streams is NULL, connect to /dev/null instead.  */
	gpgme_error_t gpgme_op_spawn_start(gpgme_ctx_t ctx, const(char*) file, const(char*)[] argv, gpgme_data_t datain, gpgme_data_t dataout, gpgme_data_t dataerr, uint flags);
	
	gpgme_error_t gpgme_op_spawn(gpgme_ctx_t ctx, const(char*) file, const(char*)[] argv, gpgme_data_t datain, gpgme_data_t dataout, gpgme_data_t dataerr, uint flags);

}


/*
 * Low-level Assuan protocol access.
 */

/* Compat.  */
struct _gpgme_op_assuan_result {
	/* Deprecated.  Use the second value in a DONE event or the
     synchronous variant gpgme_op_assuan_transact_ext.  */
	deprecated gpgme_error_t err;
}

alias gpgme_assuan_result_t = _gpgme_op_assuan_result*;
	
extern(C) nothrow @nogc {

	alias gpgme_assuan_data_cb_t = gpgme_error_t function(void* opaque, const(void*) data, size_t datalen);
	
	alias gpgme_assuan_inquire_cb_t = gpgme_error_t function(void* opaque, const(char*) name, const(char*) args, gpgme_data_t* r_data);
	
	alias gpgme_assuan_status_cb_t = gpgme_error_t function(void* opaque, const(char*) status, const(char*) args);
	
	/* Send the Assuan COMMAND and return results via the callbacks. Asynchronous variant. */
	gpgme_error_t gpgme_op_assuan_transact_start(gpgme_ctx_t ctx, const(char*) command, gpgme_assuan_data_cb_t data_cb, void* data_cb_value, gpgme_assuan_inquire_cb_t inq_cb, void* inq_cb_value, gpgme_assuan_status_cb_t stat_cb, void* stat_cb_value);
	
	/* Send the Assuan COMMAND and return results via the callbacks. Synchronous variant. */
	gpgme_error_t gpgme_op_assuan_transact_ext(gpgme_ctx_t ctx, const(char*) command, gpgme_assuan_data_cb_t data_cb, void* data_cb_value, gpgme_assuan_inquire_cb_t inq_cb, void* inq_cb_value, gpgme_assuan_status_cb_t stat_cb, void* stat_cb_value, gpgme_error_t* op_err);
	
	/* Return the result of the last Assuan command. */
	deprecated gpgme_assuan_result_t gpgme_op_assuan_result(gpgme_ctx_t ctx);
	
	deprecated gpgme_error_t gpgme_op_assuan_transact(gpgme_ctx_t ctx, const(char*) command, gpgme_assuan_data_cb_t data_cb, void* data_cb_value, gpgme_assuan_inquire_cb_t inq_cb, void* inq_cb_value, gpgme_assuan_status_cb_t status_cb, void* status_cb_value);

}

/*
 * Crypto container support.
 */

struct _gpgme_op_vfs_mount_result {
	char* mount_dir;
}

alias gpgme_vfs_mount_result_t = _gpgme_op_vfs_mount_result*;

extern(C) nothrow @nogc {
	
	gpgme_vfs_mount_result_t gpgme_op_vfs_mount_result(gpgme_ctx_t ctx);
	
	/* The container is automatically unmounted when the context is reset
	   or destroyed.  Transmission errors are returned directly,
	   operational errors are returned in OP_ERR.  */
	gpgme_error_t gpgme_op_vfs_mount(gpgme_ctx_t ctx, const(char*) container_file, const(char*) mount_dir, uint flags, gpgme_error_t* op_err);
	
	gpgme_error_t gpgme_op_vfs_create(gpgme_ctx_t ctx, gpgme_key_t[] recp, const(char*) container_file, uint flags, gpgme_error_t* op_err);

}


/*
 * Interface to gpgconf(1).
 */


/* The expert level at which a configuration option or group of
   options should be displayed.  See the gpgconf(1) documentation for
   more details.  */
 enum gpgme_conf_level_t {
	GPGME_CONF_BASIC = 0,
	GPGME_CONF_ADVANCED = 1,
	GPGME_CONF_EXPERT = 2,
	GPGME_CONF_INVISIBLE = 3,
	GPGME_CONF_INTERNAL = 4
}

/* The data type of a configuration option argument.  See the gpgconf(1) documentation for more details.  */
enum gpgme_conf_type_t {
	/* Basic types.  */
	GPGME_CONF_NONE = 0,
	GPGME_CONF_STRING = 1,
	GPGME_CONF_INT32 = 2,
	GPGME_CONF_UINT32 = 3,

	/* Complex types.  */
	GPGME_CONF_FILENAME = 32,
	GPGME_CONF_LDAP_SERVER = 33,
	GPGME_CONF_KEY_FPR = 34,
	GPGME_CONF_PUB_KEY = 35,
	GPGME_CONF_SEC_KEY = 36,
	GPGME_CONF_ALIAS_LIST = 37
}

/* For now, compatibility.  */
enum GPGME_CONF_PATHNAME = gpgme_conf_type_t.GPGME_CONF_FILENAME;

/* This represents a single argument for a configuration option. Which of the members of value is used depends on the ALT_TYPE.  */
struct gpgme_conf_arg {
	
	gpgme_conf_arg* next;
	
	/* True if the option appears without an (optional) argument.  */
	uint no_arg;
	
	union value_uni {
    	uint count;
    	uint uint32;
    	int int32;
    	char* string;
	} 
	value_uni value;
}

alias gpgme_conf_arg_t = gpgme_conf_arg*;

/* The flags of a configuration option.  See the gpg-conf  documentation for details.  */
enum {
	GPGME_CONF_GROUP = (1 << 0),
	GPGME_CONF_OPTIONAL = (1 << 1),
	GPGME_CONF_LIST = (1 << 2),
	GPGME_CONF_RUNTIME = (1 << 3),
	GPGME_CONF_DEFAULT = (1 << 4),
	GPGME_CONF_DEFAULT_DESC = (1 << 5),
	GPGME_CONF_NO_ARG_DESC = (1 << 6),
	GPGME_CONF_NO_CHANGE = (1 << 7)
}

/* The representation of a single configuration option.  See the gpg-conf documentation for details.  */
struct gpgme_conf_opt {
	
	gpgme_conf_opt* next;

	/* The option name.  */
	char* name;

	/* The flags for this option.  */
	uint flags;

	/* The level of this option.  */
	gpgme_conf_level_t level;

	/* The localized description of this option.  */
	char* description;

	/* The type and alternate type of this option.  */
	gpgme_conf_type_t type;
	gpgme_conf_type_t alt_type;

	/* The localized (short) name of the argument, if any.  */
	char* argname;

	/* The default value.  */
	gpgme_conf_arg_t default_value;
	char* default_description;

	/* The default value if the option is not set.  */
	gpgme_conf_arg_t no_arg_value;
	char* no_arg_description;

	/* The current value if the option is set.  */
	gpgme_conf_arg_t value;

	/* The new value, if any.  NULL means reset to default.  */
	int change_value;
	gpgme_conf_arg_t new_value;

	/* Free for application use.  */
	void* user_data;
}

alias gpgme_conf_opt_t = gpgme_conf_opt*;

/* The representation of a component that can be configured.  See the gpg-conf documentation for details.  */
struct gpgme_conf_comp {
	
	gpgme_conf_comp* next;

	/* Internal to GPGME, do not use!  */
	gpgme_conf_opt_t* _last_opt_p;

	/* The component name.  */
	char* name;

	/* A human-readable description for the component.  */
	char* description;

	/* The program name (an absolute path to the program).  */
	char* program_name;

	/* A linked list of options for this component.  */
	gpgme_conf_opt* options;
}

alias gpgme_conf_comp_t = gpgme_conf_comp*;

extern(C) nothrow @nogc {

	/* Allocate a new gpgme_conf_arg_t.  If VALUE is NULL, a "no arg
	   default" is prepared.  If type is a string type, VALUE should point
	   to the string.  Else, it should point to an unsigned or signed
	   integer respectively.  */
	gpgme_error_t gpgme_conf_arg_new(gpgme_conf_arg_t* arg_p, gpgme_conf_type_t type, const(void*) value);
	
	/* This also releases all chained argument structures!  */
	void gpgme_conf_arg_release(gpgme_conf_arg_t arg, gpgme_conf_type_t type);
	
	/* Register a change for the value of OPT to ARG.  If RESET is 1 (do
	   not use any values but 0 or 1), ARG is ignored and the option is
	   not changed (reverting a previous change).  Otherwise, if ARG is
	   NULL, the option is cleared or reset to its default.  */
	gpgme_error_t gpgme_conf_opt_change(gpgme_conf_opt_t opt, int reset, gpgme_conf_arg_t arg);
	
	/* Release a set of configurations.  */
	void gpgme_conf_release(gpgme_conf_comp_t conf);
	
	/* Retrieve the current configurations.  */
	gpgme_error_t gpgme_op_conf_load(gpgme_ctx_t ctx, gpgme_conf_comp_t* conf_p);
	
	/* Save the configuration of component comp.  This function does not follow chained components!  */
	gpgme_error_t gpgme_op_conf_save(gpgme_ctx_t ctx, gpgme_conf_comp_t comp);

}


/*
 * Various functions.
 */

extern(C) nothrow @nogc {
	
	/* Set special global flags; consult the manual before use.  */
	int gpgme_set_global_flag(const(char*) name, const(char*) value);
	
	/* Check that the library fulfills the version requirement.  Note:
	   This is here only for the case where a user takes a pointer from
	   the old version of this function.  The new version and macro for
	   run-time checks are below.  */
	const(char*) gpgme_check_version(const(char*) req_version);
	
	/* Check that the library fulfills the version requirement and check for struct layout mismatch involving bitfields.  */
	const(char*) gpgme_check_version_internal(const(char*) req_version, size_t offset_sig_validity);
	
	const(char*) gpgme_check_version_new(const(char*) req_version) {
		return gpgme_check_version_internal(req_version, _gpgme_signature.validity.offsetof);
	}
		
	/* Return the default values for various directories.  */
	const(char*) gpgme_get_dirinfo(const(char*) what);
	
	/* Get the information about the configured and installed engines.  A
	   pointer to the first engine in the statically allocated linked list
	   is returned in *INFO.  If an error occurs, it is returned.  The
	   returned data is valid until the next gpgme_set_engine_info.  */
	gpgme_error_t gpgme_get_engine_info(gpgme_engine_info_t* engine_info);
	
	/* Set the default engine info for the protocol PROTO to the file name FILE_NAME and the home directory HOME_DIR.  */
	gpgme_error_t gpgme_set_engine_info(gpgme_protocol_t proto, const(char*) file_name, const(char*) home_dir);
	
	/* Verify that the engine implementing PROTO is installed and available.  */
	gpgme_error_t gpgme_engine_check_version(gpgme_protocol_t proto);
	
	/* Reference counting for result objects.  */
	void gpgme_result_ref(void* result);
	
	void gpgme_result_unref(void* result);
	
	/* Return a statically allocated string with the name of the public key algorithm ALGO, or NULL if that name is not known.  */
	const(char*) gpgme_pubkey_algo_name(gpgme_pubkey_algo_t algo);
	
	/* Return a statically allocated string with the name of the hash algorithm ALGO, or NULL if that name is not known.  */
	const(char*) gpgme_hash_algo_name(gpgme_hash_algo_t algo);

}


/*
 * Deprecated types.
 */

deprecated {
	alias GpgmeCtx = gpgme_ctx_t;
	alias GpgmeData = gpgme_data_t;
	alias GpgmeError = gpgme_error_t;
	alias GpgmeDataEncoding = gpgme_data_encoding_t;
	alias GpgmePubKeyAlgo = gpgme_pubkey_algo_t;
	alias GpgmeHashAlgo = gpgme_hash_algo_t;
	alias GpgmeSigStat = gpgme_sig_stat_t;
	alias GpgmeSigMode = gpgme_sig_mode_t;
	alias GpgmeAttr = gpgme_attr_t;
	alias GpgmeValidity = gpgme_validity_t;
	alias GpgmeProtocol = gpgme_protocol_t;
	alias GpgmeEngineInfo = gpgme_engine_info_t;
	alias GpgmeSubkey = gpgme_subkey_t;
	alias GpgmeKeySig = gpgme_key_sig_t;
	alias GpgmeUserID = gpgme_user_id_t;
	alias GpgmeKey = gpgme_key_t;
	alias GpgmePassphraseCb = gpgme_passphrase_cb_t;
	alias GpgmeProgressCb = gpgme_progress_cb_t;
	alias GpgmeIOCb = gpgme_io_cb_t;
	alias GpgmeRegisterIOCb = gpgme_register_io_cb_t;
	alias GpgmeRemoveIOCb = gpgme_remove_io_cb_t;
	alias GpgmeEventIO = gpgme_event_io_t;
	alias GpgmeEventIOCb = gpgme_event_io_cb_t;
	alias GpgmeIOCbs = gpgme_io_cbs;
	alias GpgmeDataReadCb = gpgme_data_read_cb_t;
	alias GpgmeDataWriteCb = gpgme_data_write_cb_t;
	alias GpgmeDataSeekCb = gpgme_data_seek_cb_t;
	alias GpgmeDataReleaseCb = gpgme_data_release_cb_t;
	alias GpgmeDataCbs = gpgme_data_cbs;
	alias GpgmeEncryptResult = gpgme_encrypt_result_t;
	alias GpgmeSigNotation = gpgme_sig_notation_t;
	alias GpgmeSignature = gpgme_signature_t;
	alias GpgmeVerifyResult = gpgme_verify_result_t;
	alias GpgmeImportStatus = gpgme_import_status_t;
	alias GpgmeImportResult = gpgme_import_result_t;
	alias GpgmeGenKeyResult = gpgme_genkey_result_t;
	alias GpgmeTrustItem = gpgme_trust_item_t;
	alias GpgmeStatusCode = gpgme_status_code_t;
}



version(unittest) {
	import std.stdio : printf, write, writeln;
	import std.conv;
	import core.stdc.string : strcmp, strchr;
	import core.stdc.locale;
	import core.stdc.stdlib : getenv;
	import core.stdc.stdio : SEEK_SET;
	
	void check_result_verify(gpgme_verify_result_t result, uint summary, string fpr, gpgme_error_t status, int notation) {
		gpgme_signature_t sig;
		
		sig = result.signatures;
		
		assert(sig && !sig.next); // Unexpected number of signatures
		assert(sig.summary == summary); // Unexpected signature summary
		assert(!strcmp(sig.fpr, fpr.ptr)); // Unexpected fingerprint
		assert(gpgme_err_code(sig.status) == status); // Unexpected signature status
		
		if(notation) {
			struct expected_notations_str {
				const(char*) name;
				const(char*) value;
				int seen = 0;
			} 
			
			expected_notations_str[] expected_notations = [
				expected_notations_str("bar", "\xc3\xb6\xc3\xa4\xc3\xbc\xc3\x9f das waren Umlaute und jetzt ein prozent%-Zeichen"),
				expected_notations_str("foobar.1",  "this is a notation data with 2 lines"),
				expected_notations_str(null, "http://www.gu.org/policy/")
			];
			
			int i;
			gpgme_sig_notation_t r;

			for(r = sig.notations; r; r = r.next) {
				int any = 0;
				for(i=0; i < expected_notations.length; i++) {
					if(((r.name && expected_notations[i].name && !strcmp(r.name, expected_notations[i].name) && r.name_len == to!string(expected_notations[i].name).length) || (!r.name && !expected_notations[i].name && r.name_len == 0)) && r.value && !strcmp(r.value, expected_notations[i].value) && r.value_len == to!string(expected_notations[i].value).length) {
						expected_notations[i].seen++;
						any++;
					}
				}
				assert(any); // Unexpected notation data
			}
			
			for(i=0; i < expected_notations.length; i++) {
				assert(expected_notations[i].seen == 1); // Missing or duplicate notation data
			}
		}

		assert(!sig.wrong_key_usage); // Unexpectedly wrong key usage
		assert(sig.validity == gpgme_validity_t.GPGME_VALIDITY_UNKNOWN); // Unexpected validity
		assert(gpgme_err_code(sig.validity_reason) == gpg_err_code_t.GPG_ERR_NO_ERROR); // Unexpected validity reason
	}
	
	void check_result_sign(gpgme_sign_result_t result, gpgme_sig_mode_t type) {
		
		assert(!result.invalid_signers); // Invalid signer found
		assert(result.signatures && !result.signatures.next); // Unexpected number of signatures created
		assert(result.signatures.type == type); // Wrong type of signature created
		assert(result.signatures.pubkey_algo == gpgme_pubkey_algo_t.GPGME_PK_DSA); // Wrong pubkey algorithm reported
		
		assert(result.signatures.hash_algo == gpgme_hash_algo_t.GPGME_MD_SHA1); // Wrong hash algorithm reported
		assert(result.signatures.sig_class == 1); // Wrong signature class reported
		assert(!strcmp("A0FF4590BB6122EDEF6E3C542D727CC768697734", result.signatures.fpr)); // Wrong fingerprint reported
	}
}

unittest {
	
	// ----------------- GPGME basic
	
	// version test
	
	printf("Version from header: %s (0x%06x)\n", GPGME_VERSION, GPGME_VERSION_NUMBER);
    printf("Version from binary: %s\n", gpgme_check_version_new(null));
	
	write("Test: version ... ");
	
	assert(gpgme_check_version_new(GPGME_VERSION) != null);
	assert(gpgme_check_version_new("15") == null);
	
	writeln("SUCCESS"); 
	
	// engine info test
	
	write("Test: engine info ... ");
	
	gpgme_engine_info_t info;
	gpgme_error_t err;
	err = gpgme_get_engine_info(&info);
	
	assert(err == 0);
	
	writeln("SUCCESS"); 
	
	// data test
	
	// TODO: add data test
	
}


unittest {
	
	// ----------------- GPG
	
	// verify test
	
	write("Test: verify ... ");
	
	string test_text1 = "Just GNU it!\n";
	string test_text1f = "Just GNU it?\n";
	string test_sig1 = q"EOS
-----BEGIN PGP SIGNATURE-----

iN0EABECAJ0FAjoS+i9FFIAAAAAAAwA5YmFyw7bDpMO8w58gZGFzIHdhcmVuIFVt
bGF1dGUgdW5kIGpldHp0IGVpbiBwcm96ZW50JS1aZWljaGVuNRSAAAAAAAgAJGZv
b2Jhci4xdGhpcyBpcyBhIG5vdGF0aW9uIGRhdGEgd2l0aCAyIGxpbmVzGhpodHRw
Oi8vd3d3Lmd1Lm9yZy9wb2xpY3kvAAoJEC1yfMdoaXc0JBIAoIiLlUsvpMDOyGEc
dADGKXF/Hcb+AKCJWPphZCphduxSvrzH0hgzHdeQaA==
=nts1
-----END PGP SIGNATURE-----
EOS";

	string test_sig2 = q"EOS
-----BEGIN PGP MESSAGE-----

owGbwMvMwCSoW1RzPCOz3IRxjXQSR0lqcYleSUWJTZOvjVdpcYmCu1+oQmaJIleH
GwuDIBMDGysTSIqBi1MApi+nlGGuwDeHao53HBr+FoVGP3xX+kvuu9fCMJvl6IOf
y1kvP4y+8D5a11ang0udywsA
=Crq6
-----END PGP MESSAGE-----
EOS";
	/* A message with a prepended but unsigned plaintext packet. */
	string double_plaintext_sig = q"EOS
-----BEGIN PGP MESSAGE-----

rDRiCmZvb2Jhci50eHRF4pxNVGhpcyBpcyBteSBzbmVha3kgcGxhaW50ZXh0IG1l
c3NhZ2UKowGbwMvMwCSoW1RzPCOz3IRxTWISa6JebnG666MFD1wzSzJSixQ81XMV
UlITUxTyixRyKxXKE0uSMxQyEosVikvyCwpSU/S4FNCArq6Ce1F+aXJGvoJvYlGF
erFCTmJxiUJ5flFKMVeHGwuDIBMDGysTyA4GLk4BmO036xgWzMgzt9V85jCtfDFn
UqVooWlGXHwNw/xg/fVzt9VNbtjtJ/fhUqYo0/LyCGEA
=6+AK
-----END PGP MESSAGE-----
EOS";

	
	gpgme_ctx_t ctx;
	gpgme_error_t err;
	gpgme_data_t sig, text;
	gpgme_verify_result_t result;
	
	setlocale(LC_ALL, "");
	
	gpgme_set_locale(null, LC_CTYPE, setlocale(LC_CTYPE, null));
	
	err = gpgme_engine_check_version(gpgme_protocol_t.GPGME_PROTOCOL_OpenPGP);
	assert(err == 0);
	
	err = gpgme_new(&ctx);
	assert(err == 0);
	
	/* Checking a valid message.  */
	err = gpgme_data_new_from_mem(&text, test_text1.ptr, test_text1.length, 0);
	assert(err == 0);
	err = gpgme_data_new_from_mem(&sig, test_sig1.ptr, test_sig1.length, 0);
	assert(err == 0);
	err = gpgme_op_verify(ctx, sig, text, null);
	assert(err == 0);
	result = gpgme_op_verify_result(ctx);
	check_result_verify(result, 0, "A0FF4590BB6122EDEF6E3C542D727CC768697734", gpg_err_code_t.GPG_ERR_NO_ERROR, 1);
	
	write("1 ... ");
	
	/* Checking a manipulated message.  */
	gpgme_data_release(text);
	err = gpgme_data_new_from_mem (&text, test_text1f.ptr, test_text1f.length, 0);
	assert(err == 0);
	gpgme_data_seek(sig, 0, SEEK_SET);
	err = gpgme_op_verify(ctx, sig, text, null);
	assert(err == 0);
	result = gpgme_op_verify_result(ctx);
	check_result_verify(result, gpgme_sigsum_t.GPGME_SIGSUM_RED, "2D727CC768697734", gpg_err_code_t.GPG_ERR_BAD_SIGNATURE, 0);
	
	write("2 ... ");
	
	/* Checking a normal signature.  */
	gpgme_data_release(sig);
	gpgme_data_release(text);
	err = gpgme_data_new_from_mem(&sig, test_sig2.ptr, test_sig2.length, 0);
	assert(err == 0);
	err = gpgme_data_new(&text);
	assert(err == 0);
	err = gpgme_op_verify(ctx, sig, null, text);
	assert(err == 0);
	result = gpgme_op_verify_result(ctx);
	check_result_verify(result, 0, "A0FF4590BB6122EDEF6E3C542D727CC768697734", gpg_err_code_t.GPG_ERR_NO_ERROR, 0);
	
	write("3 ... ");
	
	/* Checking an invalid message.  */
	gpgme_data_release(sig);
	gpgme_data_release(text);
	err = gpgme_data_new_from_mem(&sig, double_plaintext_sig.ptr, double_plaintext_sig.length, 0);
	assert(err == 0);
	err = gpgme_data_new(&text);
	assert(err == 0);
	err = gpgme_op_verify(ctx, sig, null, text);
	assert(gpgme_err_code(err) == gpg_err_code_t.GPG_ERR_BAD_DATA); // Double plaintext message not detected

	write("4 ... ");

	gpgme_data_release(sig);
	gpgme_data_release(text);
	gpgme_release(ctx);
	
	writeln("SUCCESS");
	
	// sign test
	
	write("Test: sign ... ");
	
	gpgme_sign_result_t result2;
	gpgme_data_t in_, out_;
	char* agent_info;
	
	err = gpgme_new(&ctx);
	assert(err == 0);
	
	agent_info = getenv("GPG_AGENT_INFO");
	assert(agent_info && strchr(agent_info, ':'));

	gpgme_set_textmode(ctx, 1);
	gpgme_set_armor(ctx, 1);
	
	gpgme_key_t akey;
    err = gpgme_get_key(ctx, "0x68697734", &akey, 0);
    assert(err == 0);
    gpgme_signers_clear(ctx);
    err = gpgme_signers_add(ctx, akey);
    assert(err == 0);
    gpgme_key_unref(akey);
	
	err = gpgme_data_new_from_mem(&in_, "Hallo Leute\n", 12, 0);
	assert(err == 0);
	
	/* First a normal signature.  */
	err = gpgme_data_new(&out_);
	assert(err == 0);
	err = gpgme_op_sign(ctx, in_, out_, gpgme_sig_mode_t.GPGME_SIG_MODE_NORMAL);
	assert(err == 0);
	result2 = gpgme_op_sign_result(ctx);
	check_result_sign(result2, gpgme_sig_mode_t.GPGME_SIG_MODE_NORMAL);
	gpgme_data_release(out_);
	
	write("1 ... ");
	
	/* Now a detached signature.  */ 
	gpgme_data_seek(in_, 0, SEEK_SET);
	err = gpgme_data_new(&out_);
	assert(err == 0);
	err = gpgme_op_sign(ctx, in_, out_, gpgme_sig_mode_t.GPGME_SIG_MODE_DETACH);
	assert(err == 0);
	result2 = gpgme_op_sign_result(ctx);
	check_result_sign(result2, gpgme_sig_mode_t.GPGME_SIG_MODE_DETACH);
	gpgme_data_release (out_);
	
	write("2 ... ");

	/* And finally a cleartext signature.  */
	gpgme_data_seek(in_, 0, SEEK_SET);
	err = gpgme_data_new(&out_);
	assert(err == 0);
	err = gpgme_op_sign(ctx, in_, out_, gpgme_sig_mode_t.GPGME_SIG_MODE_CLEAR);
	assert(err == 0);
	result2 = gpgme_op_sign_result(ctx);
	check_result_sign(result2, gpgme_sig_mode_t.GPGME_SIG_MODE_CLEAR);
	gpgme_data_release(out_);

	write("3 ... ");

	gpgme_data_release(in_);
	gpgme_release(ctx);
	
	
	
	writeln("SUCCESS");
	
}