static void gmime_callback(SIPE_UNUSED_PARAMETER GMimeObject *parent,
GMimeObject *part,
gpointer user_data)
{
GMimeDataWrapper *data = g_mime_part_get_content_object((GMimePart *)part);
if (data) {
GMimeStream *stream = g_mime_data_wrapper_get_stream(data);
if (stream) {
ssize_t length = g_mime_stream_length(stream);
if (length != -1) {
gchar *content = g_malloc(length + 1);
if (g_mime_stream_read(stream, content, length) == length) {
struct gmime_callback_data *cd = user_data;
GSList *fields = gmime_fields_to_nameval(part);
(*(cd->callback))(cd->user_data, fields, content, length);
sipe_utils_nameval_free(fields);
}
g_free(content);
}
}
}
}
static GMimeStream*
get_mime_stream (GMimeObject *obj, GError **err)
{
GMimeStream *mstream;
GMimeDataWrapper *wrapper;
if (!GMIME_IS_PART(obj)) {
char *str;
GByteArray *ar;
str = g_mime_object_to_string (obj);
ar = g_byte_array_new_take ((guchar*)str, strlen(str));
mstream = g_mime_stream_mem_new_with_byte_array (ar);
g_mime_stream_mem_set_owner (
GMIME_STREAM_MEM(mstream), TRUE);
return mstream;
}
wrapper = get_data_wrapper (obj, err);
if (!wrapper)
return NULL;
mstream = g_mime_data_wrapper_get_stream (wrapper);
if (!mstream || g_mime_stream_reset (mstream) != 0) {
g_set_error (err, G_IO_ERROR, G_IO_ERROR_FAILED,
"invalid mime-stream");
return NULL;
}
return mstream;
}
/* note: this will return -1 in case of error or if the size is
* unknown */
static ssize_t
get_part_size (GMimePart *part)
{
GMimeDataWrapper *wrapper;
GMimeStream *stream;
wrapper = g_mime_part_get_content_object (part);
if (!GMIME_IS_DATA_WRAPPER(wrapper))
return -1;
stream = g_mime_data_wrapper_get_stream (wrapper);
if (!stream)
return -1; /* no stream -> size is 0 */
else
return g_mime_stream_length (stream);
/* NOTE: stream/wrapper are owned by gmime, no unreffing */
}
static void
print_body (GMimeMessage *msg)
{
GMimeObject *body;
GMimeDataWrapper *wrapper;
GMimeStream *stream;
body = g_mime_message_get_body (msg);
if (GMIME_IS_MULTIPART(body))
body = g_mime_multipart_get_part (GMIME_MULTIPART(body), 0);
if (!GMIME_IS_PART(body))
return;
wrapper = g_mime_part_get_content_object (GMIME_PART(body));
if (!GMIME_IS_DATA_WRAPPER(wrapper))
return;
stream = g_mime_data_wrapper_get_stream (wrapper);
if (!GMIME_IS_STREAM(stream))
return;
do {
char buf[512];
ssize_t len;
len = g_mime_stream_read (stream, buf, sizeof(buf));
if (len == -1)
break;
if (write (fileno(stdout), buf, len) == -1)
break;
if (len < (int)sizeof(buf))
break;
} while (1);
}
static void
format_omitted_part_meta_sprinter (sprinter_t *sp, GMimeObject *meta, GMimePart *part)
{
const char *content_charset = g_mime_object_get_content_type_parameter (meta, "charset");
const char *cte = g_mime_object_get_header (meta, "content-transfer-encoding");
GMimeDataWrapper *wrapper = g_mime_part_get_content_object (part);
GMimeStream *stream = g_mime_data_wrapper_get_stream (wrapper);
ssize_t content_length = g_mime_stream_length (stream);
if (content_charset != NULL) {
sp->map_key (sp, "content-charset");
sp->string (sp, content_charset);
}
if (cte != NULL) {
sp->map_key (sp, "content-transfer-encoding");
sp->string (sp, cte);
}
if (content_length >= 0) {
sp->map_key (sp, "content-length");
sp->integer (sp, content_length);
}
}
void AnalyseMessageParse(GMimePart * mime_part)
{
int ichar=0,iencode =0;
if( NULL==mime_part )
{
printf("empty part\n");
return ;
}
GMimeContentEncoding ReEncoding = g_mime_part_get_content_encoding(mime_part);
char* szCharset = (char*)g_mime_object_get_content_type_parameter((GMimeObject*)mime_part,"charset");
printf("charset %s\n",szCharset);
{
char* szCharset = (char*)g_mime_object_get_content_type_parameter((GMimeObject*)mime_part,"name");
printf("name %s\n",szCharset);
GMimeContentType* pContentType = g_mime_object_get_content_type((GMimeObject*)mime_part) ;
printf("The content type is: (%s/%s)\n",pContentType->type,pContentType->subtype);
const char * ppp= g_mime_object_get_disposition((GMimeObject*)mime_part);
if(!ppp)
{
goto exits;
}
const char * qqq=g_mime_object_get_content_disposition_parameter((GMimeObject*)mime_part,"filename");
printf("get disposition\t%s\n%s\n",ppp,qqq);
if(qqq)
{
FILE * ps=fopen(qqq,"w+b");
printf("\n=======write to file================\n" );
GMimeStream *stream = g_mime_stream_file_new (ps);
GMimeDataWrapper * content=g_mime_part_get_content_object(mime_part);
g_mime_data_wrapper_write_to_stream(content,stream);
fclose(ps);
printf("finish writing\n");
getchar();
return ;
}
}
exits:{}
/*decode for text/plain or html*/
GMimeDataWrapper *dataWrap = g_mime_part_get_content_object(mime_part);
if(!dataWrap)
printf("error in dataWrap\n" );
GMimeStream * gmime_stream= g_mime_data_wrapper_get_stream(dataWrap);
//encoding转码
GMimeFilter * pAttFilter = g_mime_filter_basic_new(ReEncoding,FALSE);
GMimeStream* pFilterStream = g_mime_stream_filter_new(gmime_stream);
iencode = g_mime_stream_filter_add (GMIME_STREAM_FILTER (pFilterStream), pAttFilter);
/*create a filter convert the charset into local type*/
GMimeFilter * secondPtr = g_mime_filter_charset_new(szCharset,g_mime_charset_locale_name());
ichar = g_mime_stream_filter_add (GMIME_STREAM_FILTER (pFilterStream), secondPtr);
/*convert stream into stdout*/
GMimeStream *stream = g_mime_stream_file_new (stdout);
g_mime_stream_write_to_stream(pFilterStream,stream);
#if 0
/*get data from stream load into char* */
char pp[10000]= {0};
int tt=g_mime_stream_read(pFilterStream,pp,10000);
printf("%d\t%s\n",tt,pp);
#endif
g_object_unref ( pAttFilter );
g_object_unref ( secondPtr );
g_mime_stream_filter_remove((GMimeStreamFilter*)pFilterStream,ichar);
g_mime_stream_filter_remove((GMimeStreamFilter*)pFilterStream,iencode);
g_object_unref (pFilterStream);
//g_object_unref (gmime_stream);
//g_object_unref (stream);
//if(NULL==szCharset)
{
printf("\n====>>>>====>>>>====>>>>Finish decoding this part<<<<====<<<<====<<<<====\n");
getchar();
//return ;
}
return ;
}
static ssize_t
write_content (GMimePart *part, GMimeStream *stream)
{
ssize_t nwritten, total = 0;
if (!part->content)
return 0;
/* Evil Genius's "slight" optimization: Since GMimeDataWrapper::write_to_stream()
* decodes its content stream to the raw format, we can cheat by requesting its
* content stream and not doing any encoding on the data if the source and
* destination encodings are identical.
*/
if (part->encoding != g_mime_data_wrapper_get_encoding (part->content)) {
GMimeStream *filtered_stream;
const char *filename;
GMimeFilter *filter;
switch (part->encoding) {
case GMIME_CONTENT_ENCODING_UUENCODE:
filename = g_mime_part_get_filename (part);
nwritten = g_mime_stream_printf (stream, "begin 0644 %s\n",
filename ? filename : "unknown");
if (nwritten == -1)
return -1;
total += nwritten;
/* fall thru... */
case GMIME_CONTENT_ENCODING_QUOTEDPRINTABLE:
case GMIME_CONTENT_ENCODING_BASE64:
filtered_stream = g_mime_stream_filter_new (stream);
filter = g_mime_filter_basic_new (part->encoding, TRUE);
g_mime_stream_filter_add (GMIME_STREAM_FILTER (filtered_stream), filter);
g_object_unref (filter);
break;
default:
filtered_stream = stream;
g_object_ref (stream);
break;
}
nwritten = g_mime_data_wrapper_write_to_stream (part->content, filtered_stream);
g_mime_stream_flush (filtered_stream);
g_object_unref (filtered_stream);
if (nwritten == -1)
return -1;
total += nwritten;
if (part->encoding == GMIME_CONTENT_ENCODING_UUENCODE) {
/* FIXME: get rid of this special-case x-uuencode crap */
nwritten = g_mime_stream_write (stream, "end\n", 4);
if (nwritten == -1)
return -1;
total += nwritten;
}
} else {
GMimeStream *content_stream;
content_stream = g_mime_data_wrapper_get_stream (part->content);
g_mime_stream_reset (content_stream);
nwritten = g_mime_stream_write_to_stream (content_stream, stream);
g_mime_stream_reset (content_stream);
if (nwritten == -1)
return -1;
total += nwritten;
}
return total;
}
