GpgmeCtx ctx;
};
-PGPMIME pgpmime_system;
+static PrivacySystem pgpmime_system;
+
+static gint pgpmime_check_signature(MimeInfo *mimeinfo);
static PrivacyDataPGP *pgpmime_new_privacydata()
{
return data;
}
-PGPMIME::PGPMIME()
-{
-}
-
-const gchar *PGPMIME::getId()
-{
- return "pgpmime";
-}
-
-const gchar *PGPMIME::getName()
-{
- return "PGP/MIME";
-}
-
-void PGPMIME::freePrivacyData(PrivacyData *_data)
+static void pgpmime_free_privacydata(PrivacyData *_data)
{
PrivacyDataPGP *data = (PrivacyDataPGP *) _data;
gpgme_release(data->ctx);
-
- PrivacySystem::freePrivacyData(_data);
+ g_free(data);
}
-gboolean PGPMIME::isSigned(MimeInfo *mimeinfo)
+static gboolean pgpmime_is_signed(MimeInfo *mimeinfo)
{
MimeInfo *parent;
MimeInfo *signature;
return ret;
}
-gint PGPMIME::checkSignature(MimeInfo *mimeinfo)
+static gint pgpmime_check_signature(MimeInfo *mimeinfo)
{
PrivacyDataPGP *data;
MimeInfo *parent, *signature;
fp = fopen(parent->data.filename, "rb");
g_return_val_if_fail(fp != NULL, SIGNATURE_INVALID);
- boundary = (gchar *) g_hash_table_lookup(parent->typeparameters, "boundary");
+ boundary = g_hash_table_lookup(parent->typeparameters, "boundary");
if (!boundary)
return 0;
return 0;
}
-SignatureStatus PGPMIME::getSigStatus(MimeInfo *mimeinfo)
+static SignatureStatus pgpmime_get_sig_status(MimeInfo *mimeinfo)
{
PrivacyDataPGP *data = (PrivacyDataPGP *) mimeinfo->privacy;
if (data->sigstatus == GPGME_SIG_STAT_NONE &&
prefs_gpg_get_config()->auto_check_signatures)
- checkSignature(mimeinfo);
+ pgpmime_check_signature(mimeinfo);
return sgpgme_sigstat_gpgme_to_privacy(data->ctx, data->sigstatus);
}
-gchar *PGPMIME::getSigInfoShort(MimeInfo *mimeinfo)
+static gchar *pgpmime_get_sig_info_short(MimeInfo *mimeinfo)
{
PrivacyDataPGP *data = (PrivacyDataPGP *) mimeinfo->privacy;
if (data->sigstatus == GPGME_SIG_STAT_NONE &&
prefs_gpg_get_config()->auto_check_signatures)
- checkSignature(mimeinfo);
+ pgpmime_check_signature(mimeinfo);
return sgpgme_sigstat_info_short(data->ctx, data->sigstatus);
}
-gchar *PGPMIME::getSigInfoFull(MimeInfo *mimeinfo)
+static gchar *pgpmime_get_sig_info_full(MimeInfo *mimeinfo)
{
PrivacyDataPGP *data = (PrivacyDataPGP *) mimeinfo->privacy;
if (data->sigstatus == GPGME_SIG_STAT_NONE &&
prefs_gpg_get_config()->auto_check_signatures)
- checkSignature(mimeinfo);
+ pgpmime_check_signature(mimeinfo);
return sgpgme_sigstat_info_full(data->ctx, data->sigstatus);
}
-gboolean PGPMIME::isEncrypted(MimeInfo *mimeinfo)
+static gboolean pgpmime_is_encrypted(MimeInfo *mimeinfo)
{
MimeInfo *tmpinfo;
const gchar *tmpstr;
return TRUE;
}
-MimeInfo *PGPMIME::decrypt(MimeInfo *mimeinfo)
+static MimeInfo *pgpmime_decrypt(MimeInfo *mimeinfo)
{
MimeInfo *encinfo, *decinfo, *parseinfo;
GpgmeData cipher, plain;
static gint id = 0;
FILE *dstfp;
- size_t nread;
+ gint nread;
gchar *fname;
gchar buf[BUFFSIZE];
- GpgmeSigStat sigstat = GPGME_SIG_STAT_NONE;
+ GpgmeSigStat sigstat = 0;
PrivacyDataPGP *data = NULL;
GpgmeCtx ctx;
return NULL;
- g_return_val_if_fail(isEncrypted(mimeinfo), NULL);
+ g_return_val_if_fail(pgpmime_is_encrypted(mimeinfo), NULL);
encinfo = (MimeInfo *) g_node_nth_child(mimeinfo->node, 1)->data;
return NULL;
}
decinfo = g_node_first_child(parseinfo->node) != NULL ?
- (MimeInfo *) g_node_first_child(parseinfo->node)->data : NULL;
+ g_node_first_child(parseinfo->node)->data : NULL;
if (decinfo == NULL) {
gpgme_release(ctx);
return NULL;
return decinfo;
}
-#if 0
/*
* Find TAG in XML and return a pointer into xml set just behind the
* closing angle. Return NULL if not found.
if (s && s < s_end2) {
s_end = strchr (s, '<');
if (s_end) {
- char *p = (gchar *) g_malloc (s_end - s + 1);
+ char *p = g_malloc (s_end - s + 1);
memcpy (p, s, s_end - s);
p[s_end-s] = 0;
return p;
return NULL;
}
-gboolean PGPMIME::sign(MimeInfo *mimeinfo, PrefsAccount *account)
+gboolean pgpmime_sign(MimeInfo *mimeinfo, PrefsAccount *account)
{
MimeInfo *msgcontent, *sigmultipart, *newinfo;
gchar *textstr, *opinfo, *micalg;
return TRUE;
}
-gchar *PGPMIME::getEncryptData(GSList *recp_names)
+gchar *pgpmime_get_encrypt_data(GSList *recp_names)
{
return sgpgme_get_encrypt_data(recp_names);
}
-gboolean PGPMIME::encrypt(MimeInfo *mimeinfo, const gchar *encrypt_data)
+gboolean pgpmime_encrypt(MimeInfo *mimeinfo, const gchar *encrypt_data)
{
MimeInfo *msgcontent, *encmultipart, *newinfo;
FILE *fp;
return TRUE;
}
-#endif
+static PrivacySystem pgpmime_system = {
+ "pgpmime", /* id */
+ "PGP/MIME", /* name */
+
+ pgpmime_free_privacydata, /* free_privacydata */
+
+ pgpmime_is_signed, /* is_signed(MimeInfo *) */
+ pgpmime_check_signature, /* check_signature(MimeInfo *) */
+ pgpmime_get_sig_status, /* get_sig_status(MimeInfo *) */
+ pgpmime_get_sig_info_short, /* get_sig_info_short(MimeInfo *) */
+ pgpmime_get_sig_info_full, /* get_sig_info_full(MimeInfo *) */
+
+ pgpmime_is_encrypted, /* is_encrypted(MimeInfo *) */
+ pgpmime_decrypt, /* decrypt(MimeInfo *) */
+
+ TRUE,
+ pgpmime_sign,
+
+ TRUE,
+ pgpmime_get_encrypt_data,
+ pgpmime_encrypt,
+};
void pgpmime_init()
{