static GMimeStream *
g_mime_data_wrapper_get_decoded_stream(GMimeDataWrapper * wrapper)
{
GMimeStream *decoded_stream;
GMimeFilter *decoder;
g_mime_stream_reset(wrapper->stream);
switch (wrapper->encoding) {
case GMIME_CONTENT_ENCODING_BASE64:
case GMIME_CONTENT_ENCODING_QUOTEDPRINTABLE:
case GMIME_CONTENT_ENCODING_UUENCODE:
decoder = g_mime_filter_basic_new(wrapper->encoding, FALSE);
decoded_stream = g_mime_stream_filter_new(wrapper->stream);
g_mime_stream_filter_add(GMIME_STREAM_FILTER(decoded_stream),
decoder);
g_object_unref(decoder);
break;
default:
decoded_stream = wrapper->stream;
g_object_ref(wrapper->stream);
break;
}
return decoded_stream;
}
static GMimeStream* create_stream(GMimeContentEncoding en, const gchar* fn)
{
GMimeStream* rv = NULL;
FILE* f = fopen(fn, "r");
GMimeStream* fst = NULL;
if ( f ) {
fst = g_mime_stream_file_new(f);
}
if ( fst ) {
switch (en) {
case GMIME_CONTENT_ENCODING_DEFAULT:
{
rv = fst;
}
break;
default:
{
GMimeFilter* flt = g_mime_filter_basic_new(en, TRUE);
rv = g_mime_stream_filter_new(fst);
g_mime_stream_filter_add(GMIME_STREAM_FILTER(rv), flt);
g_object_unref(flt);
g_object_unref(fst);
}
break;
}
} else {
g_warning("failed to open '%s'", fn);
}
return rv;
}
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;
}
static int
uuencode (const char *progname, int argc, char **argv)
{
GMimeStream *istream, *ostream, *fstream;
GMimeContentEncoding encoding;
const char *filename, *name;
GMimeFilter *filter;
gboolean base64;
struct stat st;
int fd, opt;
base64 = FALSE;
encoding = GMIME_CONTENT_ENCODING_UUENCODE;
while ((opt = getopt_long (argc, argv, "hvm", longopts, NULL)) != -1) {
switch (opt) {
case 'h':
usage (progname);
return 0;
case 'v':
version (progname);
return 0;
case 'm':
base64 = TRUE;
encoding = GMIME_CONTENT_ENCODING_BASE64;
break;
default:
printf ("Try `%s --help' for more information.\n", progname);
return -1;
}
}
if (optind >= argc) {
printf ("Try `%s --help' for more information.\n", progname);
return -1;
}
if (optind + 1 < argc)
filename = argv[optind++];
else
filename = NULL;
name = argv[optind];
/* open our input file... */
if ((fd = filename ? open (filename, O_RDONLY, 0) : dup (0)) == -1) {
fprintf (stderr, "%s: %s: %s\n", progname,
filename ? filename : "stdin",
g_strerror (errno));
return -1;
}
/* stat() our input file for file mode permissions */
if (fstat (fd, &st) == -1) {
fprintf (stderr, "%s: %s: %s\n", progname,
filename ? filename : "stdin",
g_strerror (errno));
close (fd);
return -1;
}
printf ("begin%s %.3o %s\n", base64 ? "-base64" : "", st.st_mode & 0777, name);
fflush (stdout);
istream = g_mime_stream_fs_new (fd);
/* open our output stream */
ostream = g_mime_stream_fs_new (1);
g_mime_stream_fs_set_owner ((GMimeStreamFs *) ostream, FALSE);
fstream = g_mime_stream_filter_new (ostream);
/* attach an encode filter */
filter = g_mime_filter_basic_new (encoding, TRUE);
g_mime_stream_filter_add ((GMimeStreamFilter *) fstream, filter);
g_object_unref (filter);
if (g_mime_stream_write_to_stream (istream, fstream) == -1) {
fprintf (stderr, "%s: %s\n", progname, g_strerror (errno));
g_object_unref (fstream);
g_object_unref (istream);
g_object_unref (ostream);
return -1;
}
g_mime_stream_flush (fstream);
g_object_unref (fstream);
g_object_unref (istream);
if (g_mime_stream_write_string (ostream, base64 ? "====\n" : "end\n") == -1) {
fprintf (stderr, "%s: %s\n", progname, g_strerror (errno));
g_object_unref (ostream);
return -1;
}
g_object_unref (ostream);
return 0;
}
