anotherim/anotherim-desktop
2
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
anotherim-desktop/vapi/gpgme.vapi

1225 lines
31 KiB
Vala
Raw Normal View History

Initial commit
2017-03-02 14:37:32 +00:00
/* 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);
}
Reference in a new issue Copy permalink