HGKeeper

* purple - Sametime Protocol Plugin

* Purple is the legal property of its developers, whose names are too numerous

* to list here. Please refer to the COPYRIGHT file distributed with this

* source distribution.

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA

#include <glib.h>

#include <gmime/gmime.h>

#include <purple.h>

/* plugin includes */

#include "sametime.h"

#include "im_mime.h"

/** generate "cid:908@20582notesbuddy" from "<908@20582notesbuddy>" */

static char *

make_cid(const char *cid)

{

g_return_val_if_fail(cid != NULL, NULL);

return g_strdup_printf("cid:%s", cid);

}

/* Create a MIME parser from some input data. */

static GMimeParser *

create_parser(const char *data)

{

GMimeStream *stream;

GMimeFilter *filter;

GMimeStream *filtered_stream;

GMimeParser *parser;

stream = g_mime_stream_mem_new_with_buffer(data, strlen(data));

filtered_stream = g_mime_stream_filter_new(stream);

g_object_unref(G_OBJECT(stream));

/* Add a dos2unix filter so in-message newlines are simplified. */

filter = g_mime_filter_dos2unix_new(FALSE);

g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_stream), filter);

g_object_unref(G_OBJECT(filter));

parser = g_mime_parser_new_with_stream(filtered_stream);

g_object_unref(G_OBJECT(filtered_stream));

return parser;

}

/* Replace each IMG tag's SRC attribute with an ID attribute. This

actually modifies the contents of str */

static void

replace_img_src_by_id(GString *str, GHashTable *img_by_cid)

{

GData *attribs;

char *start, *end;

char *tmp = str->str;

while (*tmp &&

purple_markup_find_tag("img", tmp,

(const char **) &start, (const char **) &end,

&attribs)) {

char *alt, *align, *border, *src;

guint img = 0;

alt = g_datalist_get_data(&attribs, "alt");

align = g_datalist_get_data(&attribs, "align");

border = g_datalist_get_data(&attribs, "border");

src = g_datalist_get_data(&attribs, "src");

if (src) {

img = GPOINTER_TO_UINT(g_hash_table_lookup(img_by_cid, src));

}

if (img) {

GString *atstr;

gsize len = (end - start);

gsize mov;

atstr = g_string_new("");

if (alt) {

g_string_append_printf(atstr, " alt=\"%s\"", alt);

}

if (align) {

g_string_append_printf(atstr, " align=\"%s\"", align);

}

if (border) {

g_string_append_printf(atstr, " border=\"%s\"", border);

}

mov = g_snprintf(start, len,

"<img src=\"" PURPLE_IMAGE_STORE_PROTOCOL

"%u\"%s", img, atstr->str);

while (mov < len) start[mov++] = ' ';

g_string_free(atstr, TRUE);

}

g_datalist_clear(&attribs);

tmp = end + 1;

}

gchar *

im_mime_parse(const char *data)

{

GHashTable *img_by_cid;

GString *str;

GMimeParser *parser;

GMimeObject *doc;

int i, count;

img_by_cid = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);

/* don't want the contained string to ever be NULL */

str = g_string_new("");

parser = create_parser(data);

doc = g_mime_parser_construct_part(parser, NULL);

if (!GMIME_IS_MULTIPART(doc)) {

g_object_unref(G_OBJECT(doc));

g_object_unref(G_OBJECT(parser));

return g_string_free(str, FALSE);

}

/* handle all the MIME parts */

count = g_mime_multipart_get_count(GMIME_MULTIPART(doc));

for (i = 0; i < count; i++) {

GMimeObject *obj = g_mime_multipart_get_part(GMIME_MULTIPART(doc), i);

GMimeContentType *type = g_mime_object_get_content_type(obj);

if (!type) {

; /* feh */

} else if (g_mime_content_type_is_type(type, "image", "*")) {

/* put images into the image store */

GMimePart *part = GMIME_PART(obj);

GMimeDataWrapper *wrapper;

GMimeStream *stream;

GByteArray *bytearray;

GBytes *data;

char *cid;

PurpleImage *image;

guint imgid;

/* obtain and unencode the data */

bytearray = g_byte_array_new();

stream = g_mime_stream_mem_new_with_byte_array(bytearray);

g_mime_stream_mem_set_owner(GMIME_STREAM_MEM(stream), FALSE);

wrapper = g_mime_part_get_content(part);

g_mime_data_wrapper_write_to_stream(wrapper, stream);

data = g_byte_array_free_to_bytes(bytearray);

g_clear_object(&stream);

/* look up the content id */

cid = make_cid(g_mime_part_get_content_id(part));

/* add image to the purple image store */

image = purple_image_new_from_bytes(data);

purple_image_set_friendly_filename(image, cid);

g_bytes_unref(data);

/* map the cid to the image store identifier */

imgid = purple_image_store_add(image);

g_hash_table_insert(img_by_cid, cid, GUINT_TO_POINTER(imgid));

} else if (GMIME_IS_TEXT_PART(obj)) {

/* concatenate all the text parts together */

char *data;

data = g_mime_text_part_get_text(GMIME_TEXT_PART(obj));

g_string_append(str, data);

g_free(data);

}

g_object_unref(G_OBJECT(doc));

g_object_unref(G_OBJECT(parser));

replace_img_src_by_id(str, img_by_cid);

/* clean up the cid table */

g_hash_table_destroy(img_by_cid);

return g_string_free(str, FALSE);

}

/** generates a random-ish content id string */

static char *

im_mime_content_id(void)

{

gint id = g_random_int();

return g_strdup_printf("%03x@%05xmeanwhile", (id & 0xfff00000) >> 20,

id & 0xfffff);

}

/** generates a random-ish boundary value */

static char *

im_mime_boundary(void)

{

gint id = g_random_int();

return g_strdup_printf("related_MW%03x_%04x", (id & 0xfff0000) >> 16,

id & 0xffff);

}

/** create MIME image from purple image */

static GMimePart *

im_mime_img_to_part(PurpleImage *img)

{

const gchar *mimetype;

GMimePart *part;

GByteArray *data;

GMimeStream *stream;

GMimeDataWrapper *wrapper;

mimetype = purple_image_get_mimetype(img);

if (mimetype && g_str_has_prefix(mimetype, "image/")) {

mimetype += sizeof("image/") - 1;

}

part = g_mime_part_new_with_type("image", mimetype);

g_mime_object_set_disposition(GMIME_OBJECT(part),

GMIME_DISPOSITION_ATTACHMENT);

g_mime_part_set_content_encoding(part, GMIME_CONTENT_ENCODING_BASE64);

g_mime_part_set_filename(part, purple_image_get_friendly_filename(img));

data = g_bytes_unref_to_array(purple_image_get_contents(img));

stream = g_mime_stream_mem_new_with_byte_array(data);

wrapper = g_mime_data_wrapper_new_with_stream(stream,

GMIME_CONTENT_ENCODING_BINARY);

g_object_unref(G_OBJECT(stream));

g_mime_part_set_content(part, wrapper);

g_object_unref(G_OBJECT(wrapper));

return part;

}

gchar *

im_mime_generate(const char *message)

{

GString *str;

GMimeMultipart *doc;

GMimeFormatOptions *opts;

GMimeTextPart *text;

GData *attr;

char *tmp, *start, *end;

str = g_string_new(NULL);

doc = g_mime_multipart_new_with_subtype("related");

g_mime_object_set_header(GMIME_OBJECT(doc), "Mime-Version", "1.0", NULL);

g_mime_object_set_disposition(GMIME_OBJECT(doc), GMIME_DISPOSITION_INLINE);

tmp = im_mime_boundary();

g_mime_multipart_set_boundary(doc, tmp);

g_free(tmp);

tmp = (char *)message;

while (*tmp &&

purple_markup_find_tag("img", tmp, (const char **) &start,

(const char **) &end, &attr)) {

gchar *uri;

PurpleImage *img = NULL;

gsize len = (start - tmp);

/* append the in-between-tags text */

if (len) {

g_string_append_len(str, tmp, len);

}

uri = g_datalist_get_data(&attr, "src");

if (uri) {

img = purple_image_store_get_from_uri(uri);

}

if (img) {

GMimePart *part;

char *cid;

cid = im_mime_content_id();

part = im_mime_img_to_part(img);

g_mime_part_set_content_id(part, cid);

g_mime_multipart_add(doc, GMIME_OBJECT(part));

g_object_unref(G_OBJECT(part));

/* append the modified tag */

g_string_append_printf(str, "<img src=\"cid:%s\">", cid);

g_free(cid);

} else {

/* append the literal image tag, since we couldn't find

a relative PurpleImage object */

gsize len = (end - start) + 1;

g_string_append_len(str, start, len);

}

g_datalist_clear(&attr);

tmp = end + 1;

}

/* append left-overs */

g_string_append(str, tmp);

/* add the text/html part */

text = g_mime_text_part_new_with_subtype("html");

g_mime_object_set_disposition(GMIME_OBJECT(text),

GMIME_DISPOSITION_INLINE);

tmp = purple_utf8_ncr_encode(str->str);

g_mime_text_part_set_text(text, tmp);

g_free(tmp);

g_mime_multipart_insert(doc, 0, GMIME_OBJECT(text));

g_object_unref(G_OBJECT(text));

g_string_free(str, TRUE);

opts = g_mime_format_options_new();

g_mime_format_options_set_newline_format(opts, GMIME_NEWLINE_FORMAT_DOS);

tmp = g_mime_object_to_string(GMIME_OBJECT(doc), opts);

g_mime_format_options_free(opts);

g_object_unref(G_OBJECT(doc));

return tmp;

}

pidgin/pidgin