private void UpdateFromMem(IntPtr uidPtr)
{
_gpgme_user_id userid = (_gpgme_user_id)
Marshal.PtrToStructure(uidPtr, typeof(_gpgme_user_id));
revoked = userid.revoked;
invalid = userid.invalid;
validity = (Validity)userid.validity;
uid = Gpgme.PtrToStringUTF8(userid.uid);
name = Gpgme.PtrToStringUTF8(userid.name);
comment = Gpgme.PtrToStringUTF8(userid.comment);
email = Gpgme.PtrToStringUTF8(userid.email);
if (userid.signatures != (IntPtr)0)
{
signatures = new KeySignature(userid.signatures);
}
else
{
signatures = null;
}
if (userid.next != (IntPtr)0)
{
next = new UserId(userid.next);
}
else
{
next = null;
}
}
private void UpdateFromMem(IntPtr itemPtr)
{
var titem = new _gpgme_trust_item();
Marshal.PtrToStructure(itemPtr, titem);
KeyId = Gpgme.PtrToStringAnsi(titem.keyid);
switch (titem.type)
{
case 1:
Type = TrustItemType.Key;
break;
case 2:
Type = TrustItemType.UserId;
break;
default:
throw new GeneralErrorException("Unknown trust item type value of " + titem.type);
}
Level = titem.level;
OwnerTrust = Gpgme.PtrToStringUTF8(titem.owner_trust);
Validity = Gpgme.PtrToStringAnsi(titem.validity);
Name = Gpgme.PtrToStringUTF8(titem.name);
}
internal void UpdateFromMem(IntPtr keyPtr)
{
var key = (_gpgme_key)Marshal.PtrToStructure(keyPtr, typeof(_gpgme_key));
_key_ptr = keyPtr;
Revoked = key.revoked;
Expired = key.expired;
Disabled = key.disabled;
Invalid = key.invalid;
CanEncrypt = key.can_encrypt;
CanSign = key.can_sign;
CanCertify = key.can_certify;
CanAuthenticate = key.can_authenticate;
IsQualified = key.is_qualified;
Secret = key.secret;
Protocol = (Protocol)key.protocol;
OwnerTrust = (Validity)key.owner_trust;
KeylistMode = (KeylistMode)key.keylist_mode;
IssuerName = Gpgme.PtrToStringUTF8(key.issuer_name);
IssuerSerial = Gpgme.PtrToStringAnsi(key.issuer_serial);
ChainId = Gpgme.PtrToStringAnsi(key.chain_id);
if (key.subkeys != IntPtr.Zero)
{
Subkeys = new Subkey(key.subkeys);
}
if (key.uids != IntPtr.Zero)
{
Uids = new UserId(key.uids);
}
}
private void UpdateFromMem(IntPtr signotPtr)
{
int len;
var signot = (_gpgme_sig_notation)Marshal.PtrToStructure(signotPtr,
typeof(_gpgme_sig_notation));
if (signot.value != IntPtr.Zero)
{
len = signot.value_len;
_value = Gpgme.PtrToStringUTF8(signot.value,
len);
}
if (signot.name != IntPtr.Zero)
{
len = signot.name_len;
Name = Gpgme.PtrToStringUTF8(signot.name,
len);
}
Flags = (SignatureNotationFlags)signot.flags;
Critical = signot.critical;
HumanReadable = signot.human_readable;
if (signot.next != IntPtr.Zero)
{
_next = new SignatureNotation(signot.next);
}
}
private int _passphrase_cb(IntPtr Hook, IntPtr uid_hint, IntPtr passphrase_info,
int prev_was_bad, int fd)
{
bool prevbad;
string hint, info;
char[] passwd = null;
hint = Gpgme.PtrToStringUTF8(uid_hint);
info = Gpgme.PtrToStringUTF8(passphrase_info);
if (prev_was_bad > 0)
{
prevbad = true;
}
else
{
prevbad = false;
}
PassphraseResult result;
try
{
PassphraseInfo pinfo = new PassphraseInfo(Hook, hint, info, prevbad);
result = passphraseFunc(this, pinfo, ref passwd);
}
catch (Exception ex)
{
LastCallbackException = ex;
passwd = "".ToCharArray();
result = PassphraseResult.Canceled;
}
if (fd > 0)
{
byte[] utf8passwd = Gpgme.ConvertCharArrayToUTF8(passwd, 0);
Stream fdstream = Gpgme.ConvertToStream(fd, FileAccess.Write);
fdstream.Write(utf8passwd, 0, utf8passwd.Length);
fdstream.Flush();
fdstream.WriteByte((byte)'\n');
fdstream.Flush();
// try to wipe the passwords
int i;
for (i = 0; i < utf8passwd.Length; i++)
{
utf8passwd[i] = 0;
}
}
return((int)result);
}
private void UpdateFromMem(IntPtr sigPtr)
{
_gpgme_op_verify_result ver = new _gpgme_op_verify_result();
Marshal.PtrToStructure(sigPtr, ver);
file_name = Gpgme.PtrToStringUTF8(ver.file_name);
if (ver.signature != IntPtr.Zero)
{
signature = new Signature(ver.signature);
}
}
private void UpdateFromMem(IntPtr rstPtr)
{
var rst = new _gpgme_op_decrypt_result();
Marshal.PtrToStructure(rstPtr, rst);
_file_name = Gpgme.PtrToStringUTF8(rst.file_name);
_wrong_key_usage = rst.wrong_key_usage;
_unsupported_algorithm = Gpgme.PtrToStringUTF8(rst.unsupported_algorithm);
if (rst.recipients != IntPtr.Zero)
{
_recipients = new Recipient(rst.recipients);
}
}
private void UpdateFromMem(IntPtr recpPtr)
{
var recp = new _gpgme_recipient();
Marshal.PtrToStructure(recpPtr, recp);
_keyid = Gpgme.PtrToStringUTF8(recp.keyid);
_pubkey_algo = (KeyAlgorithm)recp.pubkey_algo;
_status = recp.status;
if (recp.next != IntPtr.Zero)
{
_next = new Recipient(recp.next);
}
}
private void UpdateFromMem(IntPtr sigPtr)
{
var newsig = new _gpgme_new_signature();
Marshal.PtrToStructure(sigPtr, newsig);
Type = (SignatureMode)newsig.type;
PubkeyAlgorithm = (KeyAlgorithm)newsig.pubkey_algo;
HashAlgorithm = (HashAlgorithm)newsig.hash_algo;
Fingerprint = Gpgme.PtrToStringUTF8(newsig.fpr);
SignatureClass = newsig.sig_class;
_timestamp = (long)newsig.timestamp;
if (!newsig.next.Equals(IntPtr.Zero))
{
Next = new NewSignature(newsig.next);
}
}
private void UpdateFromMem(IntPtr sigPtr)
{
_gpgme_new_signature newsig = new _gpgme_new_signature();
Marshal.PtrToStructure(sigPtr, newsig);
type = (SignatureMode)newsig.type;
pubkey_algo = (KeyAlgorithm)newsig.pubkey_algo;
hash_algo = (HashAlgorithm)newsig.hash_algo;
fpr = Gpgme.PtrToStringUTF8(newsig.fpr);
sig_class = (long)newsig.sig_class;
timestamp = (long)newsig.timestamp;
if (!newsig.next.Equals(IntPtr.Zero))
{
next = new NewSignature(newsig.next);
}
}
private void UpdateFromMem(IntPtr uidPtr)
{
var userid = (_gpgme_user_id)
Marshal.PtrToStructure(uidPtr, typeof(_gpgme_user_id));
Revoked = userid.revoked;
Invalid = userid.invalid;
Validity = (Validity)userid.validity;
Uid = Gpgme.PtrToStringUTF8(userid.uid);
Name = Gpgme.PtrToStringUTF8(userid.name);
Comment = Gpgme.PtrToStringUTF8(userid.comment);
Email = Gpgme.PtrToStringUTF8(userid.email);
Signatures = userid.signatures != IntPtr.Zero
? new KeySignature(userid.signatures)
: null;
Next = userid.next != IntPtr.Zero
? new UserId(userid.next)
: null;
}
private int PassphraseCb(IntPtr hook, IntPtr uid_hint, IntPtr passphrase_info,
int prev_was_bad, int fd)
{
char[] passwd = null;
string hint = Gpgme.PtrToStringUTF8(uid_hint);
string info = Gpgme.PtrToStringUTF8(passphrase_info);
bool prevbad = prev_was_bad > 0;
PassphraseResult result;
try {
var pinfo = new PassphraseInfo(hook, hint, info, prevbad);
result = _passphrase_delegate(this, pinfo, ref passwd);
} catch (Exception ex) {
_last_callback_exception = ex;
passwd = "".ToCharArray();
result = PassphraseResult.Canceled;
}
if (fd > 0)
{
byte[] utf8_passwd = Gpgme.ConvertCharArrayToUTF8(passwd, 0);
libgpgme.gpgme_io_write(fd, utf8_passwd, (UIntPtr)utf8_passwd.Length);
libgpgme.gpgme_io_write(fd, new[] { (byte)0 }, (UIntPtr)1);
// try to wipe the passwords
int i;
for (i = 0; i < utf8_passwd.Length; i++)
{
utf8_passwd[i] = 0;
}
}
return((int)result);
}
internal void UpdateFromMem(IntPtr keyPtr)
{
_gpgme_key key = (_gpgme_key)
Marshal.PtrToStructure(keyPtr,
typeof(_gpgme_key));
this.keyPtr = keyPtr;
revoked = key.revoked;
expired = key.expired;
disabled = key.disabled;
invalid = key.invalid;
can_encrypt = key.can_encrypt;
can_sign = key.can_sign;
can_certify = key.can_certify;
can_authenticate = key.can_authenticate;
is_qualified = key.is_qualified;
secret = key.secret;
protocol = (Protocol)key.protocol;
owner_trust = (Validity)key.owner_trust;
keylistmode = (KeylistMode)key.keylist_mode;
issuer_name = Gpgme.PtrToStringUTF8(key.issuer_name);
issuer_serial = Gpgme.PtrToStringAnsi(key.issuer_serial);
chain_id = Gpgme.PtrToStringAnsi(key.chain_id);
if (key.subkeys != (IntPtr)0)
{
subkeys = new Subkey(key.subkeys);
}
if (key.uids != (IntPtr)0)
{
uids = new UserId(key.uids);
}
}
// internal callback function
private int _edit_cb(
IntPtr opaque,
int status,
IntPtr args,
int fd)
{
gpgme_status_code_t statuscode = (gpgme_status_code_t)status;
string cmdargs = Gpgme.PtrToStringUTF8(args);
Stream fdstream;
if (fd > 0)
{
fdstream = Gpgme.ConvertToStream(fd, FileAccess.Write);
}
else
{
fdstream = null;
}
int result = 0;
try
{
// call user callback function.
result = KeyEditCallback(
opaque,
(KeyEditStatusCode)statuscode,
cmdargs,
fdstream);
}
catch (Exception ex)
{
LastCallbackException = ex;
}
return(result);
}
// internal callback function
private int KeyEditCallback(
IntPtr opaque,
int status,
IntPtr args,
int fd)
{
var statuscode = (gpgme_status_code_t)status;
string cmdargs = Gpgme.PtrToStringUTF8(args);
int result = 0;
try {
// call user callback function.
result = KeyEditCallback(
opaque,
(KeyEditStatusCode)statuscode,
cmdargs,
fd);
} catch (Exception ex) {
LastCallbackException = ex;
}
return(result);
}
private void UpdateFromMem(IntPtr sigPtr)
{
/* Work around memory layout problem (bug?) on Windows systems
* with libgpgme <= 1.1.8
* //_gpgme_signature sig = new _gpgme_signature();
*
*/
if (!libgpgme.IsWindows ||
(Gpgme.Version.Major >= 1 &&
Gpgme.Version.Minor >= 2)
)
{
_gpgme_signature unixsig = new _gpgme_signature();
Marshal.PtrToStructure(sigPtr, unixsig);
summary = (SignatureSummary)unixsig.summary;
fpr = Gpgme.PtrToStringUTF8(unixsig.fpr);
status = unixsig.status;
timestamp = unixsig.timestamp;
exp_timestamp = unixsig.exp_timestamp;
validity = (Validity)unixsig.validity;
validity_reason = unixsig.validity_reason;
pubkey_algo = (KeyAlgorithm)unixsig.pubkey_algo;
hash_algo = (HashAlgorithm)unixsig.hash_algo;
pka_address = Gpgme.PtrToStringUTF8(unixsig.pka_address);
wrong_key_usage = unixsig.wrong_key_usage;
pka_trust = (PkaStatus)unixsig.pka_trust;
chain_model = unixsig.chain_model;
if (unixsig.notations != IntPtr.Zero)
{
notations = new SignatureNotation(unixsig.notations);
}
if (unixsig.next != IntPtr.Zero)
{
next = new Signature(unixsig.next);
}
}
else
{
_gpgme_signature_windows winsig = new _gpgme_signature_windows();
Marshal.PtrToStructure(sigPtr, winsig);
summary = (SignatureSummary)winsig.summary;
fpr = Gpgme.PtrToStringUTF8(winsig.fpr);
status = winsig.status;
timestamp = winsig.timestamp;
exp_timestamp = winsig.exp_timestamp;
validity = (Validity)winsig.validity;
validity_reason = winsig.validity_reason;
pubkey_algo = (KeyAlgorithm)winsig.pubkey_algo;
hash_algo = (HashAlgorithm)winsig.hash_algo;
pka_address = Gpgme.PtrToStringUTF8(winsig.pka_address);
wrong_key_usage = winsig.wrong_key_usage;
pka_trust = (PkaStatus)winsig.pka_trust;
chain_model = winsig.chain_model;
if (winsig.notations != IntPtr.Zero)
{
notations = new SignatureNotation(winsig.notations);
}
if (winsig.next != IntPtr.Zero)
{
next = new Signature(winsig.next);
}
}
}
private void UpdateFromMem(IntPtr sigPtr)
{
/* Work around memory layout problem (bug?) on Windows systems
* with libgpgme <= 1.1.8
* //_gpgme_signature sig = new _gpgme_signature();
*
*/
if (!libgpgme.IsWindows ||
(Gpgme.Version.Major >= 1 &&
Gpgme.Version.Minor >= 2)
)
{
var unixsig = new _gpgme_signature();
Marshal.PtrToStructure(sigPtr, unixsig);
Summary = (SignatureSummary)unixsig.summary;
Fingerprint = Gpgme.PtrToStringUTF8(unixsig.fpr);
_status = unixsig.status;
_timestamp = unixsig.timestamp;
_exp_timestamp = unixsig.exp_timestamp;
Validity = (Validity)unixsig.validity;
_validity_reason = unixsig.validity_reason;
PubkeyAlgorithm = (KeyAlgorithm)unixsig.pubkey_algo;
HashAlgorithm = (HashAlgorithm)unixsig.hash_algo;
PKAAddress = Gpgme.PtrToStringUTF8(unixsig.pka_address);
WrongKeyUsage = unixsig.wrong_key_usage;
PKATrust = unixsig.pka_trust;
ChainModel = unixsig.chain_model;
if (unixsig.notations != IntPtr.Zero)
{
Notations = new SignatureNotation(unixsig.notations);
}
if (unixsig.next != IntPtr.Zero)
{
Next = new Signature(unixsig.next);
}
}
else
{
var winsig = new _gpgme_signature_windows();
Marshal.PtrToStructure(sigPtr, winsig);
Summary = (SignatureSummary)winsig.summary;
Fingerprint = Gpgme.PtrToStringUTF8(winsig.fpr);
_status = winsig.status;
_timestamp = winsig.timestamp;
_exp_timestamp = winsig.exp_timestamp;
Validity = (Validity)winsig.validity;
_validity_reason = winsig.validity_reason;
PubkeyAlgorithm = (KeyAlgorithm)winsig.pubkey_algo;
HashAlgorithm = (HashAlgorithm)winsig.hash_algo;
PKAAddress = Gpgme.PtrToStringUTF8(winsig.pka_address);
WrongKeyUsage = winsig.wrong_key_usage;
PKATrust = winsig.pka_trust;
ChainModel = winsig.chain_model;
if (winsig.notations != IntPtr.Zero)
{
Notations = new SignatureNotation(winsig.notations);
}
if (winsig.next != IntPtr.Zero)
{
Next = new Signature(winsig.next);
}
}
}
