CamelMimePart *
mail_tool_make_message_attachment (CamelMimeMessage *message)
{
CamelMimePart *part;
const char *subject;
struct _camel_header_raw *xev;
char *desc;
subject = camel_mime_message_get_subject (message);
if (subject)
desc = g_strdup_printf (_("Forwarded message - %s"), subject);
else
desc = g_strdup (_("Forwarded message"));
/* rip off the X-Evolution headers */
xev = mail_tool_remove_xevolution_headers (message);
camel_header_raw_clear(&xev);
/* remove Bcc headers */
camel_medium_remove_header (CAMEL_MEDIUM (message), "Bcc");
part = camel_mime_part_new ();
camel_mime_part_set_disposition (part, "inline");
camel_mime_part_set_description (part, desc);
camel_medium_set_content_object (CAMEL_MEDIUM (part),
CAMEL_DATA_WRAPPER (message));
camel_mime_part_set_content_type (part, "message/rfc822");
g_free (desc);
return part;
}
CamelMimeMessage *
scalix_appointment_to_mime_message (ScalixObject * object)
{
CamelMimeMessage *message;
CamelMultipart *multipart;
CamelMimePart *part;
CamelMedium *medium;
CamelStream *stream;
CamelDataWrapper *wrapper;
ECalComponentDateTime dtstart, dtend;
ECalComponent *comp;
ECalComponentText text;
icalcomponent_kind kind;
icalcomponent *icalcomp, *toplevel_comp;
icaltimezone *zone = NULL;
GSList *attachment_list = NULL;
GSList *attachment_list_new = NULL;
GSList *siter = NULL;
GList *part_list = NULL;
GList *iter = NULL;
char *msgid;
char *str, *meeting_status;
const char *ouid = NULL;
char *file_contents = NULL;
char *full_path, *filename, *mime_filename;
char *cid;
int size;
g_object_get (SCALIX_APPOINTMENT (object), "timezone", &zone, NULL);
comp = E_CAL_COMPONENT (scalix_object_clone (object));
message = camel_mime_message_new ();
medium = CAMEL_MEDIUM (message);
camel_medium_add_header (medium, "X-Scalix-Class", "IPM.Appointment");
/* Preserve msg id if there is already one */
if (scalix_appointment_get (SCALIX_APPOINTMENT (comp),
X_SCALIX_MSG_ID, &msgid)) {
scalix_appointment_unset (SCALIX_APPOINTMENT (comp), X_SCALIX_MSG_ID);
} else {
msgid = camel_header_msgid_generate ();
}
camel_mime_message_set_message_id (message, msgid);
/* subject */
e_cal_component_get_summary (comp, &text);
if (text.value != NULL) {
camel_mime_message_set_subject (message, text.value);
}
/* start day */
e_cal_component_get_dtstart (comp, &dtstart);
if (!icaltime_get_timezone (*dtstart.value))
icaltime_set_timezone (dtstart.value,
icaltimezone_get_builtin_timezone_from_tzid
(dtstart.tzid));
/* end day */
e_cal_component_get_dtend (comp, &dtend);
if (!icaltime_get_timezone (*dtend.value))
icaltime_set_timezone (dtend.value,
icaltimezone_get_builtin_timezone_from_tzid
(dtend.tzid));
/* set From: and Sender: */
if (e_cal_component_has_organizer (comp)) {
ECalComponentOrganizer organizer;
e_cal_component_get_organizer (comp, &organizer);
if (!strncasecmp (organizer.value, "MAILTO:", 7)) {
camel_medium_add_header (medium, "Sender", organizer.value + 7);
camel_medium_add_header (medium, "From", organizer.value + 7);
}
}
/* set the appropriate recipient headers from the recipient table */
if (e_cal_component_has_attendees (comp)
&& e_cal_component_has_organizer (comp)) {
GSList *iter, *attendees = NULL;
CamelInternetAddress *recipients_to = NULL;
CamelInternetAddress *recipients_cc = NULL;
meeting_status = "1";
e_cal_component_get_attendee_list (comp, &attendees);
for (iter = attendees; iter; iter = iter->next) {
ECalComponentAttendee *attendee = iter->data;
const char *mail = NULL;
/* attendee entries must start with MAILTO: */
if (strncasecmp (attendee->value, "MAILTO:", 7)) {
continue;
}
mail = attendee->value + 7;
if (attendee->role == ICAL_ROLE_REQPARTICIPANT) {
if (recipients_to == NULL) {
recipients_to = camel_internet_address_new ();
}
camel_internet_address_add (recipients_to, attendee->cn, mail);
} else if (attendee->role == ICAL_ROLE_OPTPARTICIPANT) {
if (recipients_cc == NULL) {
recipients_cc = camel_internet_address_new ();
}
camel_internet_address_add (recipients_cc, attendee->cn, mail);
} else {
continue;
}
}
if (recipients_to != NULL) {
camel_mime_message_set_recipients (message, "To", recipients_to);
camel_object_unref (recipients_to);
}
if (recipients_cc != NULL) {
camel_mime_message_set_recipients (message, "Cc", recipients_cc);
camel_object_unref (recipients_cc);
}
} else {
meeting_status = "0";
}
/* Clear properties */
scalix_appointment_unset (SCALIX_APPOINTMENT (comp), X_SCALIX_IMAP_UID);
/* Render the text/calendar */
e_cal_component_commit_sequence (comp);
icalcomp = e_cal_component_get_icalcomponent (comp);
kind = icalcomponent_isa (icalcomp);
if (kind != ICAL_VCALENDAR_COMPONENT) {
/* If its not a VCALENDAR, make it one to simplify below */
toplevel_comp = e_cal_util_new_top_level ();
icalcomponent_add_component (toplevel_comp, icalcomp);
icalcomp = toplevel_comp;
}
/* set METHOD to PUSBLISH */
icalcomponent_set_method (icalcomp, ICAL_METHOD_PUBLISH);
/* Add the VTIMEZONE components for start- and/or end-times */
if (zone) {
icalcomponent_add_component (icalcomp,
icaltimezone_get_component (zone));
} else if (dtstart.tzid) {
icalcomponent_add_component (icalcomp,
icaltimezone_get_component
(icaltimezone_get_builtin_timezone_from_tzid
(dtstart.tzid)));
}
if (dtstart.tzid && dtend.tzid && strcmp (dtstart.tzid, dtend.tzid) != 0) {
icalcomponent_add_component (icalcomp,
icaltimezone_get_component
(icaltimezone_get_builtin_timezone_from_tzid
(dtend.tzid)));
}
/* FIXME: do we leek icalcomponents here? */
if (e_cal_component_has_attachments (comp)) {
multipart = camel_multipart_new ();
camel_multipart_set_boundary (multipart, NULL);
e_cal_component_get_uid (comp, &ouid);
e_cal_component_get_attachment_list (comp, &attachment_list);
for (siter = attachment_list; siter; siter = siter->next) {
if (siter->data == NULL)
continue;
if (strstr (siter->data, "file://") != siter->data)
continue;
full_path = ((char *) siter->data) + strlen ("file://");
filename = g_strrstr (full_path, "/") + 1;
mime_filename = filename + strlen (ouid) + 1;
size = 0;
file_contents = get_file_contents (full_path, &size);
if (file_contents == NULL)
continue;
stream = camel_stream_mem_new_with_buffer (file_contents, size);
wrapper = camel_data_wrapper_new ();
camel_data_wrapper_construct_from_stream (wrapper, stream);
camel_object_unref (stream);
part = camel_mime_part_new ();
camel_medium_set_content_object (CAMEL_MEDIUM (part), wrapper);
camel_mime_part_set_filename (part, mime_filename);
camel_mime_part_set_encoding (part, CAMEL_TRANSFER_ENCODING_BASE64);
cid = camel_header_msgid_generate ();
camel_mime_part_set_content_id (part, cid);
camel_mime_part_set_description (part, mime_filename);
camel_mime_part_set_disposition (part, "attachment");
part_list = g_list_append (part_list, part);
attachment_list_new = g_slist_append (attachment_list_new,
g_strdup_printf ("CID:%s",
cid));
g_free (cid);
}
e_cal_component_set_attachment_list (comp, attachment_list_new);
str = icalcomponent_as_ical_string (icalcomp);
part = camel_mime_part_new ();
camel_mime_part_set_content (part,
str,
strlen (str),
"text/calendar; method=PUBLISH; charset=UTF-8");
part_list = g_list_prepend (part_list, part);
for (iter = part_list; iter; iter = iter->next) {
part = (CamelMimePart *) iter->data;
camel_multipart_add_part (multipart, part);
camel_object_unref (part);
}
camel_medium_set_content_object (CAMEL_MEDIUM (message),
CAMEL_DATA_WRAPPER (multipart));
camel_object_unref (multipart);
g_slist_free (attachment_list);
g_slist_free (attachment_list_new);
g_list_free (part_list);
} else {
str = icalcomponent_as_ical_string (icalcomp);
camel_mime_part_set_content (CAMEL_MIME_PART (message),
str,
strlen (str),
"text/calendar; method=PUBLISH; charset=UTF-8");
}
scalix_appointment_set (SCALIX_APPOINTMENT (object),
X_SCALIX_MSG_ID, msgid);
return message;
}
static void
eab_composer_created_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
CreateComposerData *ccd = user_data;
EComposerHeaderTable *table;
EMsgComposer *composer;
GError *error = NULL;
g_return_if_fail (ccd != NULL);
composer = e_msg_composer_new_finish (result, &error);
if (error) {
g_warning ("%s: Failed to create msg composer: %s", G_STRFUNC, error->message);
g_clear_error (&error);
} else {
table = e_msg_composer_get_header_table (composer);
if (ccd->to_destinations)
e_composer_header_table_set_destinations_to (table, ccd->to_destinations);
if (ccd->bcc_destinations)
e_composer_header_table_set_destinations_bcc (table, ccd->bcc_destinations);
if (ccd->attachment_destinations) {
CamelMimePart *attachment;
GSList *contacts, *iter;
gchar *data;
attachment = camel_mime_part_new ();
contacts = g_slist_copy (ccd->attachment_destinations);
for (iter = contacts; iter != NULL; iter = iter->next)
iter->data = e_destination_get_contact (iter->data);
data = eab_contact_list_to_string (contacts);
g_slist_free (contacts);
camel_mime_part_set_content (attachment, data, strlen (data), "text/x-vcard");
if (ccd->attachment_destinations->next != NULL) {
camel_mime_part_set_description (attachment, _("Multiple vCards"));
} else {
EContact *contact;
const gchar *file_as;
gchar *description;
contact = e_destination_get_contact (ccd->attachment_destinations->data);
file_as = e_contact_get_const (contact, E_CONTACT_FILE_AS);
description = g_strdup_printf (_("vCard for %s"), file_as);
camel_mime_part_set_description (attachment, description);
g_free (description);
}
camel_mime_part_set_disposition (attachment, "attachment");
e_msg_composer_attach (composer, attachment);
g_object_unref (attachment);
if (ccd->attachment_destinations->next != NULL) {
e_composer_header_table_set_subject (table, _("Contact information"));
} else {
EContact *contact;
gchar *tempstr;
const gchar *tempstr2;
gchar *tempfree = NULL;
contact = e_destination_get_contact (ccd->attachment_destinations->data);
tempstr2 = e_contact_get_const (contact, E_CONTACT_FILE_AS);
if (!tempstr2 || !*tempstr2)
tempstr2 = e_contact_get_const (contact, E_CONTACT_FULL_NAME);
if (!tempstr2 || !*tempstr2)
tempstr2 = e_contact_get_const (contact, E_CONTACT_ORG);
if (!tempstr2 || !*tempstr2) {
g_free (tempfree);
tempstr2 = get_email (contact, E_CONTACT_EMAIL_1, &tempfree);
}
if (!tempstr2 || !*tempstr2) {
g_free (tempfree);
tempstr2 = get_email (contact, E_CONTACT_EMAIL_2, &tempfree);
}
if (!tempstr2 || !*tempstr2) {
g_free (tempfree);
tempstr2 = get_email (contact, E_CONTACT_EMAIL_3, &tempfree);
}
if (!tempstr2 || !*tempstr2)
tempstr = g_strdup_printf (_("Contact information"));
else
tempstr = g_strdup_printf (_("Contact information for %s"), tempstr2);
e_composer_header_table_set_subject (table, tempstr);
g_free (tempstr);
g_free (tempfree);
}
}
gtk_widget_show (GTK_WIDGET (composer));
}
if (ccd->to_destinations)
e_destination_freev (ccd->to_destinations);
if (ccd->bcc_destinations)
e_destination_freev (ccd->bcc_destinations);
g_slist_free_full (ccd->attachment_destinations, g_object_unref);
g_free (ccd);
}
static int
sm_encrypt(CamelCipherContext *context, const char *userid, GPtrArray *recipients, CamelMimePart *ipart, CamelMimePart *opart, CamelException *ex)
{
struct _CamelSMIMEContextPrivate *p = ((CamelSMIMEContext *)context)->priv;
/*NSSCMSRecipientInfo **recipient_infos;*/
CERTCertificate **recipient_certs = NULL;
NSSCMSContentInfo *cinfo;
PK11SymKey *bulkkey = NULL;
SECOidTag bulkalgtag;
int bulkkeysize, i;
CK_MECHANISM_TYPE type;
PK11SlotInfo *slot;
PLArenaPool *poolp;
NSSCMSMessage *cmsg = NULL;
NSSCMSEnvelopedData *envd;
NSSCMSEncoderContext *enc = NULL;
CamelStreamMem *mem;
CamelStream *ostream = NULL;
CamelDataWrapper *dw;
CamelContentType *ct;
poolp = PORT_NewArena(1024);
if (poolp == NULL) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, g_strerror (ENOMEM));
return -1;
}
/* Lookup all recipients certs, for later working */
recipient_certs = (CERTCertificate **)PORT_ArenaZAlloc(poolp, sizeof(*recipient_certs[0])*(recipients->len + 1));
if (recipient_certs == NULL) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, g_strerror (ENOMEM));
goto fail;
}
for (i=0;i<recipients->len;i++) {
recipient_certs[i] = CERT_FindCertByNicknameOrEmailAddr(p->certdb, recipients->pdata[i]);
if (recipient_certs[i] == NULL) {
camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot find certificate for `%s'"), recipients->pdata[i]);
goto fail;
}
}
/* Find a common algorithm, probably 3DES anyway ... */
if (NSS_SMIMEUtil_FindBulkAlgForRecipients(recipient_certs, &bulkalgtag, &bulkkeysize) != SECSuccess) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot find common bulk encryption algorithm"));
goto fail;
}
/* Generate a new bulk key based on the common algorithm - expensive */
type = PK11_AlgtagToMechanism(bulkalgtag);
slot = PK11_GetBestSlot(type, context);
if (slot == NULL) {
/* PORT_GetError(); ?? */
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot allocate slot for encryption bulk key"));
goto fail;
}
bulkkey = PK11_KeyGen(slot, type, NULL, bulkkeysize/8, context);
PK11_FreeSlot(slot);
/* Now we can start building the message */
/* msg->envelopedData->data */
cmsg = NSS_CMSMessage_Create(NULL);
if (cmsg == NULL) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot create CMS Message"));
goto fail;
}
envd = NSS_CMSEnvelopedData_Create(cmsg, bulkalgtag, bulkkeysize);
if (envd == NULL) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot create CMS Enveloped data"));
goto fail;
}
cinfo = NSS_CMSMessage_GetContentInfo(cmsg);
if (NSS_CMSContentInfo_SetContent_EnvelopedData(cmsg, cinfo, envd) != SECSuccess) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot attach CMS Enveloped data"));
goto fail;
}
cinfo = NSS_CMSEnvelopedData_GetContentInfo(envd);
if (NSS_CMSContentInfo_SetContent_Data(cmsg, cinfo, NULL, PR_FALSE) != SECSuccess) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot attach CMS data object"));
goto fail;
}
/* add recipient certs */
for (i=0;recipient_certs[i];i++) {
NSSCMSRecipientInfo *ri = NSS_CMSRecipientInfo_Create(cmsg, recipient_certs[i]);
if (ri == NULL) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot create CMS Recipient information"));
goto fail;
}
if (NSS_CMSEnvelopedData_AddRecipient(envd, ri) != SECSuccess) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot add CMS Recipient information"));
goto fail;
}
}
/* dump it out */
ostream = camel_stream_mem_new();
enc = NSS_CMSEncoder_Start(cmsg,
sm_write_stream, ostream,
NULL, NULL,
NULL, NULL,
sm_decrypt_key, bulkkey,
NULL, NULL);
if (enc == NULL) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot create encoder context"));
goto fail;
}
/* FIXME: Stream the input */
/* FIXME: Canonicalise the input? */
mem = (CamelStreamMem *)camel_stream_mem_new();
camel_data_wrapper_write_to_stream((CamelDataWrapper *)ipart, (CamelStream *)mem);
if (NSS_CMSEncoder_Update(enc, (char *) mem->buffer->data, mem->buffer->len) != SECSuccess) {
NSS_CMSEncoder_Cancel(enc);
camel_object_unref(mem);
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Failed to add data to encoder"));
goto fail;
}
camel_object_unref(mem);
if (NSS_CMSEncoder_Finish(enc) != SECSuccess) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Failed to encode data"));
goto fail;
}
PK11_FreeSymKey(bulkkey);
NSS_CMSMessage_Destroy(cmsg);
for (i=0;recipient_certs[i];i++)
CERT_DestroyCertificate(recipient_certs[i]);
PORT_FreeArena(poolp, PR_FALSE);
dw = camel_data_wrapper_new();
camel_data_wrapper_construct_from_stream(dw, ostream);
camel_object_unref(ostream);
dw->encoding = CAMEL_TRANSFER_ENCODING_BINARY;
ct = camel_content_type_new("application", "x-pkcs7-mime");
camel_content_type_set_param(ct, "name", "smime.p7m");
camel_content_type_set_param(ct, "smime-type", "enveloped-data");
camel_data_wrapper_set_mime_type_field(dw, ct);
camel_content_type_unref(ct);
camel_medium_set_content_object((CamelMedium *)opart, dw);
camel_object_unref(dw);
camel_mime_part_set_disposition(opart, "attachment");
camel_mime_part_set_filename(opart, "smime.p7m");
camel_mime_part_set_description(opart, "S/MIME Encrypted Message");
camel_mime_part_set_encoding(opart, CAMEL_TRANSFER_ENCODING_BASE64);
return 0;
fail:
if (ostream)
camel_object_unref(ostream);
if (cmsg)
NSS_CMSMessage_Destroy(cmsg);
if (bulkkey)
PK11_FreeSymKey(bulkkey);
if (recipient_certs) {
for (i=0;recipient_certs[i];i++)
CERT_DestroyCertificate(recipient_certs[i]);
}
PORT_FreeArena(poolp, PR_FALSE);
return -1;
}
static int
sm_sign(CamelCipherContext *context, const char *userid, CamelCipherHash hash, CamelMimePart *ipart, CamelMimePart *opart, CamelException *ex)
{
int res = -1;
NSSCMSMessage *cmsg;
CamelStream *ostream, *istream;
SECOidTag sechash;
NSSCMSEncoderContext *enc;
CamelDataWrapper *dw;
CamelContentType *ct;
switch (hash) {
case CAMEL_CIPHER_HASH_SHA1:
case CAMEL_CIPHER_HASH_DEFAULT:
default:
sechash = SEC_OID_SHA1;
break;
case CAMEL_CIPHER_HASH_MD5:
sechash = SEC_OID_MD5;
break;
}
cmsg = sm_signing_cmsmessage((CamelSMIMEContext *)context, userid, sechash,
((CamelSMIMEContext *)context)->priv->sign_mode == CAMEL_SMIME_SIGN_CLEARSIGN, ex);
if (cmsg == NULL)
return -1;
ostream = camel_stream_mem_new();
/* FIXME: stream this, we stream output at least */
istream = camel_stream_mem_new();
if (camel_cipher_canonical_to_stream(ipart,
CAMEL_MIME_FILTER_CANON_STRIP
|CAMEL_MIME_FILTER_CANON_CRLF
|CAMEL_MIME_FILTER_CANON_FROM, istream) == -1) {
camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
_("Could not generate signing data: %s"), g_strerror(errno));
goto fail;
}
enc = NSS_CMSEncoder_Start(cmsg,
sm_write_stream, ostream, /* DER output callback */
NULL, NULL, /* destination storage */
NULL, NULL, /* password callback */
NULL, NULL, /* decrypt key callback */
NULL, NULL ); /* detached digests */
if (!enc) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot create encoder context"));
goto fail;
}
if (NSS_CMSEncoder_Update(enc, (char *) ((CamelStreamMem *)istream)->buffer->data, ((CamelStreamMem *)istream)->buffer->len) != SECSuccess) {
NSS_CMSEncoder_Cancel(enc);
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Failed to add data to CMS encoder"));
goto fail;
}
if (NSS_CMSEncoder_Finish(enc) != SECSuccess) {
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Failed to encode data"));
goto fail;
}
res = 0;
dw = camel_data_wrapper_new();
camel_stream_reset(ostream);
camel_data_wrapper_construct_from_stream(dw, ostream);
dw->encoding = CAMEL_TRANSFER_ENCODING_BINARY;
if (((CamelSMIMEContext *)context)->priv->sign_mode == CAMEL_SMIME_SIGN_CLEARSIGN) {
CamelMultipartSigned *mps;
CamelMimePart *sigpart;
sigpart = camel_mime_part_new();
ct = camel_content_type_new("application", "x-pkcs7-signature");
camel_content_type_set_param(ct, "name", "smime.p7s");
camel_data_wrapper_set_mime_type_field(dw, ct);
camel_content_type_unref(ct);
camel_medium_set_content_object((CamelMedium *)sigpart, dw);
camel_mime_part_set_filename(sigpart, "smime.p7s");
camel_mime_part_set_disposition(sigpart, "attachment");
camel_mime_part_set_encoding(sigpart, CAMEL_TRANSFER_ENCODING_BASE64);
mps = camel_multipart_signed_new();
ct = camel_content_type_new("multipart", "signed");
camel_content_type_set_param(ct, "micalg", camel_cipher_hash_to_id(context, hash));
camel_content_type_set_param(ct, "protocol", context->sign_protocol);
camel_data_wrapper_set_mime_type_field((CamelDataWrapper *)mps, ct);
camel_content_type_unref(ct);
camel_multipart_set_boundary((CamelMultipart *)mps, NULL);
mps->signature = sigpart;
mps->contentraw = istream;
camel_stream_reset(istream);
camel_object_ref(istream);
camel_medium_set_content_object((CamelMedium *)opart, (CamelDataWrapper *)mps);
} else {
ct = camel_content_type_new("application", "x-pkcs7-mime");
camel_content_type_set_param(ct, "name", "smime.p7m");
camel_content_type_set_param(ct, "smime-type", "signed-data");
camel_data_wrapper_set_mime_type_field(dw, ct);
camel_content_type_unref(ct);
camel_medium_set_content_object((CamelMedium *)opart, dw);
camel_mime_part_set_filename(opart, "smime.p7m");
camel_mime_part_set_description(opart, "S/MIME Signed Message");
camel_mime_part_set_disposition(opart, "attachment");
camel_mime_part_set_encoding(opart, CAMEL_TRANSFER_ENCODING_BASE64);
}
camel_object_unref(dw);
fail:
camel_object_unref(ostream);
camel_object_unref(istream);
return res;
}
gint main (gint argc, gchar **argv)
{
CamelSession *session;
CamelCipherContext *ctx;
GError **error;
CamelCipherValidity *valid;
CamelMimePart *mime_part;
CamelMultipartSigned *mps;
CamelMultipartEncrypted *mpe;
GPtrArray *recipients;
gint ret;
camel_test_init (argc, argv);
/* clear out any camel-test data */
system ("/bin/rm -rf /tmp/camel-test");
system ("/bin/mkdir /tmp/camel-test");
setenv ("GNUPGHOME", "/tmp/camel-test/.gnupg", 1);
/* import the gpg keys */
if ((ret = system ("gpg < /dev/null > /dev/null 2>&1")) == -1)
return 77;
else if (WEXITSTATUS (ret) == 127)
return 77;
system ("gpg --import ../data/camel-test.gpg.pub > /dev/null 2>&1");
system ("gpg --import ../data/camel-test.gpg.sec > /dev/null 2>&1");
session = camel_pgp_session_new ("/tmp/camel-test");
ex = camel_exception_new ();
ctx = camel_gpg_context_new (session);
camel_gpg_context_set_always_trust (CAMEL_GPG_CONTEXT (ctx), TRUE);
camel_test_start ("Test of PGP/MIME functions");
mime_part = camel_mime_part_new ();
camel_mime_part_set_content (mime_part, test_msg, strlen (test_msg), "text/plain");
camel_mime_part_set_description (mime_part, "Test of PGP/MIME multipart/signed stuff");
camel_test_push ("PGP/MIME signing");
mps = camel_multipart_signed_new ();
camel_multipart_signed_sign (mps, ctx, mime_part, "*****@*****.**", CAMEL_CIPHER_HASH_SHA1, ex);
check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex));
camel_test_pull ();
g_object_unref (mime_part);
camel_exception_clear (ex);
camel_test_push ("PGP/MIME verify");
valid = camel_multipart_signed_verify (mps, ctx, ex);
check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex));
check_msg (camel_cipher_validity_get_valid (valid), "%s", camel_cipher_validity_get_description (valid));
camel_cipher_validity_free (valid);
camel_test_pull ();
g_object_unref (mps);
camel_exception_clear (ex);
mime_part = camel_mime_part_new ();
camel_mime_part_set_content (mime_part, test_msg, strlen (test_msg), "text/plain");
camel_mime_part_set_description (mime_part, "Test of PGP/MIME multipart/encrypted stuff");
camel_test_push ("PGP/MIME encrypt");
recipients = g_ptr_array_new ();
g_ptr_array_add (recipients, "*****@*****.**");
mpe = camel_multipart_encrypted_new ();
camel_multipart_encrypted_encrypt (mpe, mime_part, ctx, "*****@*****.**", recipients, ex);
check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex));
g_ptr_array_free (recipients, TRUE);
camel_test_pull ();
camel_exception_clear (ex);
g_object_unref (mime_part);
camel_test_push ("PGP/MIME decrypt");
mime_part = camel_multipart_encrypted_decrypt (mpe, ctx, ex);
check_msg (!camel_exception_is_set (ex), "%s", camel_exception_get_description (ex));
g_object_unref (mime_part);
g_object_unref (mpe);
camel_test_pull ();
g_object_unref (ctx);
g_object_unref (session);
camel_test_end ();
return 0;
}
static void
mail_attachment_handler_x_uid_list (EAttachmentView *view,
GdkDragContext *drag_context,
gint x,
gint y,
GtkSelectionData *selection_data,
guint info,
guint time,
EAttachmentHandler *handler)
{
static GdkAtom atom = GDK_NONE;
EMailAttachmentHandlerPrivate *priv;
CamelDataWrapper *wrapper;
CamelMimeMessage *message;
CamelMultipart *multipart;
CamelMimePart *mime_part;
CamelFolder *folder = NULL;
EAttachment *attachment;
EAttachmentStore *store;
EMailSession *session;
GPtrArray *uids;
const gchar *data;
const gchar *cp, *end;
gchar *description;
gpointer parent;
gint length;
guint ii;
GError *local_error = NULL;
if (G_UNLIKELY (atom == GDK_NONE))
atom = gdk_atom_intern_static_string ("x-uid-list");
if (gtk_selection_data_get_target (selection_data) != atom)
return;
store = e_attachment_view_get_store (view);
priv = E_MAIL_ATTACHMENT_HANDLER_GET_PRIVATE (handler);
parent = gtk_widget_get_toplevel (GTK_WIDGET (view));
parent = gtk_widget_is_toplevel (parent) ? parent : NULL;
uids = g_ptr_array_new ();
data = (const gchar *) gtk_selection_data_get_data (selection_data);
length = gtk_selection_data_get_length (selection_data);
/* The UID list is delimited by NUL characters.
* Brilliant. So we can't use g_strsplit(). */
cp = data;
end = data + length;
while (cp < end) {
const gchar *start = cp;
while (cp < end && *cp != '\0')
cp++;
/* Skip the first string. */
if (start > data)
g_ptr_array_add (uids, g_strndup (start, cp - start));
cp++;
}
if (uids->len == 0)
goto exit;
session = e_mail_backend_get_session (priv->backend);
/* The first string is the folder URI. */
/* FIXME Not passing a GCancellable here. */
folder = e_mail_session_uri_to_folder_sync (
session, data, 0, NULL, &local_error);
if (folder == NULL)
goto exit;
/* Handle one message. */
if (uids->len == 1) {
const gchar *message_uid;
message_uid = g_ptr_array_index (uids, 0);
/* FIXME Not passing a GCancellable here. */
message = camel_folder_get_message_sync (
folder, message_uid, NULL, &local_error);
if (message == NULL)
goto exit;
attachment = e_attachment_new_for_message (message);
e_attachment_store_add_attachment (store, attachment);
e_attachment_load_async (
attachment, (GAsyncReadyCallback)
call_attachment_load_handle_error, parent ? g_object_ref (parent) : NULL);
g_object_unref (attachment);
g_object_unref (message);
goto exit;
}
/* Build a multipart/digest message out of the UIDs. */
multipart = camel_multipart_new ();
wrapper = CAMEL_DATA_WRAPPER (multipart);
camel_data_wrapper_set_mime_type (wrapper, "multipart/digest");
camel_multipart_set_boundary (multipart, NULL);
for (ii = 0; ii < uids->len; ii++) {
/* FIXME Not passing a GCancellable here. */
message = camel_folder_get_message_sync (
folder, uids->pdata[ii], NULL, &local_error);
if (message == NULL) {
g_object_unref (multipart);
goto exit;
}
mime_part = camel_mime_part_new ();
wrapper = CAMEL_DATA_WRAPPER (message);
camel_mime_part_set_disposition (mime_part, "inline");
camel_medium_set_content (
CAMEL_MEDIUM (mime_part), wrapper);
camel_mime_part_set_content_type (mime_part, "message/rfc822");
camel_multipart_add_part (multipart, mime_part);
g_object_unref (mime_part);
g_object_unref (message);
}
mime_part = camel_mime_part_new ();
wrapper = CAMEL_DATA_WRAPPER (multipart);
camel_medium_set_content (CAMEL_MEDIUM (mime_part), wrapper);
description = g_strdup_printf (
ngettext (
"%d attached message",
"%d attached messages",
uids->len),
uids->len);
camel_mime_part_set_description (mime_part, description);
g_free (description);
attachment = e_attachment_new ();
e_attachment_set_mime_part (attachment, mime_part);
e_attachment_store_add_attachment (store, attachment);
e_attachment_load_async (
attachment, (GAsyncReadyCallback)
call_attachment_load_handle_error, parent ? g_object_ref (parent) : NULL);
g_object_unref (attachment);
g_object_unref (mime_part);
g_object_unref (multipart);
exit:
if (local_error != NULL) {
const gchar *folder_name = data;
if (folder != NULL)
folder_name = camel_folder_get_display_name (folder);
e_alert_run_dialog_for_args (
parent, "mail-composer:attach-nomessages",
folder_name, local_error->message, NULL);
g_clear_error (&local_error);
}
if (folder != NULL)
g_object_unref (folder);
g_ptr_array_free (uids, TRUE);
g_signal_stop_emission_by_name (view, "drag-data-received");
}
void
eab_send_as_attachment (EShell *shell,
GSList *destinations)
{
EMsgComposer *composer;
EComposerHeaderTable *table;
CamelMimePart *attachment;
GSList *contacts, *iter;
gchar *data;
g_return_if_fail (E_IS_SHELL (shell));
if (destinations == NULL)
return;
composer = e_msg_composer_new (shell);
table = e_msg_composer_get_header_table (composer);
attachment = camel_mime_part_new ();
contacts = g_slist_copy (destinations);
for (iter = contacts; iter != NULL; iter = iter->next)
iter->data = e_destination_get_contact (iter->data);
data = eab_contact_list_to_string (contacts);
g_slist_free (contacts);
camel_mime_part_set_content (
attachment, data, strlen (data), "text/x-vcard");
if (destinations->next != NULL)
camel_mime_part_set_description (
attachment, _("Multiple vCards"));
else {
EContact *contact;
const gchar *file_as;
gchar *description;
contact = e_destination_get_contact (destinations->data);
file_as = e_contact_get_const (contact, E_CONTACT_FILE_AS);
description = g_strdup_printf (_("vCard for %s"), file_as);
camel_mime_part_set_description (attachment, description);
g_free (description);
}
camel_mime_part_set_disposition (attachment, "attachment");
e_msg_composer_attach (composer, attachment);
g_object_unref (attachment);
if (destinations->next != NULL)
e_composer_header_table_set_subject (
table, _("Contact information"));
else {
EContact *contact;
gchar *tempstr;
const gchar *tempstr2;
gchar *tempfree = NULL;
contact = e_destination_get_contact (destinations->data);
tempstr2 = e_contact_get_const (contact, E_CONTACT_FILE_AS);
if (!tempstr2 || !*tempstr2)
tempstr2 = e_contact_get_const (contact, E_CONTACT_FULL_NAME);
if (!tempstr2 || !*tempstr2)
tempstr2 = e_contact_get_const (contact, E_CONTACT_ORG);
if (!tempstr2 || !*tempstr2) {
g_free (tempfree);
tempstr2 = get_email (contact, E_CONTACT_EMAIL_1, &tempfree);
}
if (!tempstr2 || !*tempstr2) {
g_free (tempfree);
tempstr2 = get_email (contact, E_CONTACT_EMAIL_2, &tempfree);
}
if (!tempstr2 || !*tempstr2) {
g_free (tempfree);
tempstr2 = get_email (contact, E_CONTACT_EMAIL_3, &tempfree);
}
if (!tempstr2 || !*tempstr2)
tempstr = g_strdup_printf (_("Contact information"));
else
tempstr = g_strdup_printf (_("Contact information for %s"), tempstr2);
e_composer_header_table_set_subject (table, tempstr);
g_free (tempstr);
g_free (tempfree);
}
gtk_widget_show (GTK_WIDGET (composer));
}
