/**
* crypt_smime_application_handler - Wrapper for CryptModuleSpecs::application_handler()
*
* Implements ::handler_t
*/
int crypt_smime_application_handler(struct Body *m, struct State *s)
{
if (CRYPT_MOD_CALL_CHECK(SMIME, application_handler))
return CRYPT_MOD_CALL(SMIME, application_handler)(m, s);
return -1;
}
/* fixme: Needs documentation. */
BODY *crypt_smime_sign_message (BODY *a)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, sign_message))
return (CRYPT_MOD_CALL (SMIME, sign_message)) (a);
return NULL;
}
/* fixme: needs documentation */
int crypt_smime_verify_one (BODY *sigbdy, STATE *s, const char *tempf)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, verify_one))
return (CRYPT_MOD_CALL (SMIME, verify_one)) (sigbdy, s, tempf);
return -1;
}
/* Decrypt am S/MIME message. */
int crypt_smime_decrypt_mime (FILE *a, FILE **b, BODY *c, BODY **d)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, decrypt_mime))
return (CRYPT_MOD_CALL (SMIME, decrypt_mime)) (a, b, c, d);
return -1;
}
/* Check that the sender matches. */
int crypt_smime_verify_sender(HEADER *h)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, smime_verify_sender))
return (CRYPT_MOD_CALL (SMIME, smime_verify_sender)) (h);
return 1;
}
/* Create a new body with a PGP signed message from A. */
BODY *crypt_pgp_sign_message (BODY *a)
{
if (CRYPT_MOD_CALL_CHECK (PGP, sign_message))
return (CRYPT_MOD_CALL (PGP, sign_message)) (a);
return NULL;
}
int crypt_pgp_send_menu (HEADER *msg, int *redraw)
{
if (CRYPT_MOD_CALL_CHECK (PGP, send_menu))
return (CRYPT_MOD_CALL (PGP, send_menu)) (msg, redraw);
return 0;
}
/**
* crypt_smime_send_menu - Wrapper for CryptModuleSpecs::send_menu()
*/
int crypt_smime_send_menu(struct Email *msg)
{
if (CRYPT_MOD_CALL_CHECK(SMIME, send_menu))
return CRYPT_MOD_CALL(SMIME, send_menu)(msg);
return 0;
}
/* This routine attempts to find the keyids of the recipients of a
message. It returns NULL if any of the keys can not be found. */
char *crypt_pgp_findkeys (ADDRESS *to, ADDRESS *cc, ADDRESS *bcc)
{
if (CRYPT_MOD_CALL_CHECK (PGP, findkeys))
return (CRYPT_MOD_CALL (PGP, findkeys)) (to, cc, bcc);
return NULL;
}
/**
* crypt_smime_build_smime_entity - Wrapper for CryptModuleSpecs::smime_build_smime_entity()
*/
struct Body *crypt_smime_build_smime_entity(struct Body *a, char *certlist)
{
if (CRYPT_MOD_CALL_CHECK(SMIME, smime_build_smime_entity))
return CRYPT_MOD_CALL(SMIME, smime_build_smime_entity)(a, certlist);
return NULL;
}
/**
* crypt_smime_verify_one - Wrapper for CryptModuleSpecs::verify_one()
*/
int crypt_smime_verify_one(struct Body *sigbdy, struct State *s, const char *tempf)
{
if (CRYPT_MOD_CALL_CHECK(SMIME, verify_one))
return CRYPT_MOD_CALL(SMIME, verify_one)(sigbdy, s, tempf);
return -1;
}
/**
* crypt_smime_sign_message - Wrapper for CryptModuleSpecs::sign_message()
*/
struct Body *crypt_smime_sign_message(struct Body *a)
{
if (CRYPT_MOD_CALL_CHECK(SMIME, sign_message))
return CRYPT_MOD_CALL(SMIME, sign_message)(a);
return NULL;
}
/**
* crypt_smime_find_keys - Wrapper for CryptModuleSpecs::find_keys()
*/
char *crypt_smime_find_keys(struct Address *addrlist, bool oppenc_mode)
{
if (CRYPT_MOD_CALL_CHECK(SMIME, find_keys))
return CRYPT_MOD_CALL(SMIME, find_keys)(addrlist, oppenc_mode);
return NULL;
}
/**
* crypt_smime_verify_sender - Wrapper for CryptModuleSpecs::smime_verify_sender()
*/
int crypt_smime_verify_sender(struct Email *e)
{
if (CRYPT_MOD_CALL_CHECK(SMIME, smime_verify_sender))
return CRYPT_MOD_CALL(SMIME, smime_verify_sender)(e);
return 1;
}
/* Generate a PGP public key attachment. */
BODY *crypt_pgp_make_key_attachment (char *tempf)
{
if (CRYPT_MOD_CALL_CHECK (PGP, pgp_make_key_attachment))
return (CRYPT_MOD_CALL (PGP, pgp_make_key_attachment)) (tempf);
return NULL;
}
/* This routine attempts to find the keyids of the recipients of a
message. It returns NULL if any of the keys can not be found. */
char *crypt_smime_findkeys (ADDRESS *to, ADDRESS *cc, ADDRESS *bcc)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, findkeys))
return (CRYPT_MOD_CALL (SMIME, findkeys)) (to, cc, bcc);
return NULL;
}
/* This routine attempts to find the keyids of the recipients of a
message. It returns NULL if any of the keys can not be found.
If oppenc_mode is true, only keys that can be determined without
prompting will be used. */
char *crypt_pgp_findkeys (ADDRESS *adrlist, int oppenc_mode)
{
if (CRYPT_MOD_CALL_CHECK (PGP, findkeys))
return (CRYPT_MOD_CALL (PGP, findkeys)) (adrlist, oppenc_mode);
return NULL;
}
int crypt_pgp_valid_passphrase (void)
{
if (CRYPT_MOD_CALL_CHECK (PGP, valid_passphrase))
return (CRYPT_MOD_CALL (PGP, valid_passphrase)) ();
return 0;
}
/* Warning: A is no longer freed in this routine, you need to free it
later. This is necessary for $fcc_attach. */
BODY *crypt_pgp_encrypt_message (BODY *a, char *keylist, int sign)
{
if (CRYPT_MOD_CALL_CHECK (PGP, pgp_encrypt_message))
return (CRYPT_MOD_CALL (PGP, pgp_encrypt_message)) (a, keylist, sign);
return NULL;
}
/* Decrypt a PGP/MIME message. */
int crypt_pgp_decrypt_mime (FILE *a, FILE **b, BODY *c, BODY **d)
{
if (CRYPT_MOD_CALL_CHECK (PGP, decrypt_mime))
return (CRYPT_MOD_CALL (PGP, decrypt_mime)) (a, b, c, d);
return -1;
}
int crypt_smime_valid_passphrase (void)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, valid_passphrase))
return (CRYPT_MOD_CALL (SMIME, valid_passphrase)) ();
return 0;
}
/* MIME handler for the application/pgp content-type. */
int crypt_pgp_application_pgp_handler (BODY *m, STATE *s)
{
if (CRYPT_MOD_CALL_CHECK (PGP, application_handler))
return (CRYPT_MOD_CALL (PGP, application_handler)) (m, s);
return -1;
}
/* MIME handler for the application/smime content-type. */
int crypt_smime_application_smime_handler (BODY *m, STATE *s)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, application_handler))
return (CRYPT_MOD_CALL (SMIME, application_handler)) (m, s);
return -1;
}
/* MIME handler for an PGP/MIME encrypted message. */
int crypt_pgp_encrypted_handler (BODY *a, STATE *s)
{
if (CRYPT_MOD_CALL_CHECK (PGP, encrypted_handler))
return (CRYPT_MOD_CALL (PGP, encrypted_handler)) (a, s);
return -1;
}
/* This routine attempts to find the keyids of the recipients of a
message. It returns NULL if any of the keys can not be found.
If oppenc_mode is true, only keys that can be determined without
prompting will be used. */
char *crypt_smime_findkeys (ADDRESS *adrlist, int oppenc_mode)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, findkeys))
return (CRYPT_MOD_CALL (SMIME, findkeys)) (adrlist, oppenc_mode);
return NULL;
}
/* Check for a traditional PGP message in body B. */
int crypt_pgp_check_traditional (FILE *fp, BODY *b, int tagged_only)
{
if (CRYPT_MOD_CALL_CHECK (PGP, pgp_check_traditional))
return (CRYPT_MOD_CALL (PGP, pgp_check_traditional)) (fp, b, tagged_only);
return 0;
}
/* fixme: needs documentation. */
BODY *crypt_smime_build_smime_entity (BODY *a, char *certlist)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, smime_build_smime_entity))
return (CRYPT_MOD_CALL (SMIME, smime_build_smime_entity)) (a, certlist);
return NULL;
}
/* fixme: needs documentation. */
BODY *crypt_pgp_traditional_encryptsign (BODY *a, int flags, char *keylist)
{
if (CRYPT_MOD_CALL_CHECK (PGP, pgp_traditional_encryptsign))
return (CRYPT_MOD_CALL (PGP, pgp_traditional_encryptsign)) (a, flags, keylist);
return NULL;
}
int crypt_smime_send_menu (HEADER *msg, int *redraw)
{
if (CRYPT_MOD_CALL_CHECK (SMIME, send_menu))
return (CRYPT_MOD_CALL (SMIME, send_menu)) (msg, redraw);
return 0;
}
/**
* crypt_smime_decrypt_mime - Wrapper for CryptModuleSpecs::decrypt_mime()
*/
int crypt_smime_decrypt_mime(FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **cur)
{
if (CRYPT_MOD_CALL_CHECK(SMIME, decrypt_mime))
return CRYPT_MOD_CALL(SMIME, decrypt_mime)(fp_in, fp_out, b, cur);
return -1;
}