static void
pump_data_through_filter (GMimeFilter *filter, const char *path, GMimeStream *ostream, gboolean is_text, gboolean inc)
{
GMimeStream *onebyte, *filtered, *stream;
GMimeFilter *dos2unix;
filtered = g_mime_stream_filter_new (ostream);
if (is_text) {
/* canonicalize text input */
dos2unix = g_mime_filter_dos2unix_new (FALSE);
g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, dos2unix);
g_object_unref (dos2unix);
}
g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, filter);
if (inc) {
onebyte = test_stream_onebyte_new (filtered);
g_object_unref (filtered);
} else {
onebyte = filtered;
}
stream = g_mime_stream_fs_open (path, O_RDONLY, 0644, NULL);
g_mime_stream_write_to_stream (stream, onebyte);
g_mime_stream_flush (onebyte);
g_object_unref (onebyte);
g_object_unref (stream);
}
static void
pump_data_through_filter (GMimeFilter *filter, const char *path, GMimeStream *ostream)
{
GMimeStream *onebyte, *filtered, *stream;
GMimeFilter *unix2dos, *dos2unix;
filtered = g_mime_stream_filter_new (ostream);
/* convert to DOS format before piping through the OpenPGP filter to maximize testing area */
unix2dos = g_mime_filter_unix2dos_new (FALSE);
g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, unix2dos);
g_object_unref (unix2dos);
g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, filter);
/* convert back to UNIX format after filtering */
dos2unix = g_mime_filter_dos2unix_new (FALSE);
g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, dos2unix);
g_object_unref (dos2unix);
onebyte = test_stream_onebyte_new (filtered);
g_object_unref (filtered);
stream = g_mime_stream_fs_open (path, O_RDONLY, 0644, NULL);
g_mime_stream_write_to_stream (stream, onebyte);
g_mime_stream_flush (onebyte);
g_object_unref (onebyte);
g_object_unref (stream);
}
static GByteArray *
read_all_bytes (const char *path, gboolean is_text)
{
GMimeStream *filtered, *stream, *mem;
GMimeFilter *filter;
GByteArray *buffer;
buffer = g_byte_array_new ();
stream = g_mime_stream_fs_open (path, O_RDONLY, 0644, NULL);
mem = g_mime_stream_mem_new_with_byte_array (buffer);
g_mime_stream_mem_set_owner ((GMimeStreamMem *) mem, FALSE);
if (is_text) {
filtered = g_mime_stream_filter_new (mem);
filter = g_mime_filter_dos2unix_new (FALSE);
g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, filter);
g_object_unref (filter);
g_object_unref (mem);
} else {
filtered = mem;
}
g_mime_stream_write_to_stream (stream, filtered);
g_mime_stream_flush (filtered);
g_object_unref (filtered);
g_object_unref (stream);
return buffer;
}
/**
* g_mime_header_list_to_string:
* @headers: a #GMimeHeaderList
*
* Allocates a string buffer containing the raw rfc822 headers
* contained in @headers.
*
* Returns: a string containing the header block.
**/
char *
g_mime_header_list_to_string (const GMimeHeaderList *headers)
{
GMimeStream *stream;
GByteArray *array;
char *str;
g_return_val_if_fail (headers != NULL, NULL);
array = g_byte_array_new ();
stream = g_mime_stream_mem_new ();
g_mime_stream_mem_set_byte_array (GMIME_STREAM_MEM (stream), array);
if (headers->stream) {
g_mime_stream_reset (headers->stream);
g_mime_stream_write_to_stream (headers->stream, stream);
} else {
g_mime_header_list_write_to_stream (headers, stream);
}
g_object_unref (stream);
g_byte_array_append (array, (unsigned char *) "", 1);
str = (char *) array->data;
g_byte_array_free (array, FALSE);
return str;
}
/**
* g_mime_header_list_write_to_stream:
* @headers: a #GMimeHeaderList
* @stream: output stream
*
* Write the headers to a stream.
*
* Returns: the number of bytes written or %-1 on fail.
**/
ssize_t
g_mime_header_list_write_to_stream (const GMimeHeaderList *headers, GMimeStream *stream)
{
ssize_t nwritten, total = 0;
GMimeHeaderWriter writer;
GHashTable *writers;
GMimeHeader *header;
g_return_val_if_fail (headers != NULL, -1);
g_return_val_if_fail (stream != NULL, -1);
if (headers->stream) {
g_mime_stream_reset (headers->stream);
return g_mime_stream_write_to_stream (headers->stream, stream);
}
header = (GMimeHeader *) headers->list.head;
writers = headers->writers;
while (header->next) {
if (header->value) {
if (!(writer = g_hash_table_lookup (writers, header->name)))
writer = default_writer;
if ((nwritten = writer (stream, header->name, header->value)) == -1)
return -1;
total += nwritten;
}
header = header->next;
}
return total;
}
gboolean
mux_message_part_write (MuxMessagePart *self, GMimeStream *ostream,
GError **err)
{
ssize_t bytes;
g_return_val_if_fail (MUX_IS_MESSAGE_PART(self), FALSE);
g_return_val_if_fail (GMIME_IS_STREAM(ostream), FALSE);
if (GMIME_IS_PART(self->mime_object)) {
GMimeDataWrapper *wrapper;
wrapper = get_data_wrapper (self->mime_object, err);
if (!wrapper)
return FALSE;
bytes = g_mime_data_wrapper_write_to_stream (
wrapper, ostream);
} else {
GMimeStream *istream;
istream = get_mime_stream (self->mime_object, err);
if (!istream)
return FALSE;
bytes = g_mime_stream_write_to_stream (istream, ostream);
}
if (bytes == -1) {
g_set_error (err, G_IO_ERROR, G_IO_ERROR_FAILED,
"failed to write part to stream");
return FALSE;
}
bytes = g_mime_stream_flush (ostream);
if (bytes == -1) {
g_set_error (err, G_IO_ERROR, G_IO_ERROR_FAILED,
"failed to flush stream");
return FALSE;
}
return TRUE;
}
static void
test_stream_mem (const char *filename)
{
/* Note: this also tests g_mime_stream_write_to_stream */
GMimeStream *stream, *fstream;
int fd;
if ((fd = open (filename, O_RDONLY, 0)) == -1) {
v(fprintf (stderr, "failed to open %s: %s\n", filename, g_strerror (errno)));
return;
}
testsuite_start ("GMimeStreamMem");
fstream = g_mime_stream_fs_new (fd);
stream = g_mime_stream_mem_new ();
testsuite_check ("GMimeStreamMem::read()");
try {
if (g_mime_stream_write_to_stream (fstream, stream) == -1)
throw (exception_new ("g_mime_stream_write_to_stream() failed"));
if (g_mime_stream_length (stream) != g_mime_stream_length (fstream))
throw (exception_new ("stream lengths didn't match"));
test_stream_read (stream, filename);
testsuite_check_passed ();
} catch (ex) {
testsuite_check_failed ("GMimeStreamMem::read() failed: %s",
ex->message);
} finally;
g_object_unref (fstream);
g_object_unref (stream);
testsuite_end ();
}
static void
lsv_escape_change_state(GSimpleAction * action,
GVariant * state,
gpointer user_data)
{
LibBalsaSourceViewerInfo *lsvi =
g_object_get_data(G_OBJECT(user_data), "lsvi");
LibBalsaMessage *msg = lsvi->msg;
GMimeStream *msg_stream;
GMimeStream *mem_stream;
char *raw_message;
if (!msg->mailbox) {
libbalsa_information(LIBBALSA_INFORMATION_WARNING,
_("Mailbox closed"));
return;
}
msg_stream = libbalsa_mailbox_get_message_stream(msg->mailbox, msg->msgno,
TRUE);
if (msg_stream == NULL)
return;
mem_stream = g_mime_stream_mem_new();
libbalsa_mailbox_lock_store(msg->mailbox);
g_mime_stream_write_to_stream(msg_stream, mem_stream);
libbalsa_mailbox_unlock_store(msg->mailbox);
g_mime_stream_write(mem_stream, "", 1); /* close string */
raw_message = (char *) GMIME_STREAM_MEM(mem_stream)->buffer->data;
*(lsvi->escape_specials) = g_variant_get_boolean(state);
lsv_show_message(raw_message, lsvi, *(lsvi->escape_specials));
g_object_unref(msg_stream);
g_object_unref(mem_stream);
g_simple_action_set_state(action, state);
}
static int
gen_test_data (const char *datadir, char **stream_name)
{
GMimeStream *istream, *ostream, *stream;
char input[256], output[256], *name, *p;
gint64 start, end, len, size;
int fd, i;
srand (time (NULL));
name = g_stpcpy (input, datadir);
*name++ = G_DIR_SEPARATOR;
name = g_stpcpy (name, "input");
p = g_stpcpy (output, datadir);
*p++ = G_DIR_SEPARATOR;
p = g_stpcpy (p, "output");
g_mkdir_with_parents (input, 0755);
g_mkdir_with_parents (output, 0755);
*name++ = G_DIR_SEPARATOR;
strcpy (name, "streamXXXXXX");
if ((fd = g_mkstemp (input)) == -1)
return -1;
*stream_name = g_strdup (name);
*p++ = G_DIR_SEPARATOR;
p = g_stpcpy (p, name);
*p++ = '_';
istream = g_mime_stream_fs_new (fd);
size = gen_random_stream (istream);
for (i = 0; i < 64; i++) {
retry:
start = (gint64) (size * (rand () / (RAND_MAX + 1.0)));
len = (gint64) (size * (rand () / (RAND_MAX + 1.0)));
if (start + len > size) {
len = size - start;
end = -1;
} else {
end = start + len;
}
sprintf (p, "%" G_GINT64_FORMAT ",%" G_GINT64_FORMAT, start, end);
if ((fd = open (output, O_CREAT | O_EXCL | O_TRUNC | O_WRONLY, 0666)) == -1)
goto retry;
ostream = g_mime_stream_fs_new (fd);
stream = g_mime_stream_substream (istream, start, end);
g_mime_stream_write_to_stream (stream, ostream);
g_mime_stream_flush (ostream);
g_object_unref (ostream);
g_object_unref (stream);
}
return 0;
}
static void
test_cat_write (GMimeStream *whole, struct _StreamPart *parts, int bounded)
{
struct _StreamPart *part = parts;
GMimeStream *stream, *sub, *cat;
Exception *ex;
int fd;
cat = g_mime_stream_cat_new ();
while (part != NULL) {
d(fprintf (stderr, "adding %s start=%lld, end=%lld...\n",
part->filename, part->pstart, part->pend));
if ((fd = open (part->filename, O_CREAT | O_TRUNC | O_WRONLY, 0666)) == -1) {
ex = exception_new ("could not create `%s': %s", part->filename, g_strerror (errno));
throw (ex);
}
stream = g_mime_stream_fs_new_with_bounds (fd, part->pstart, part->pend);
g_mime_stream_cat_add_source ((GMimeStreamCat *) cat, stream);
g_object_unref (stream);
part = part->next;
}
g_mime_stream_reset (whole);
if (g_mime_stream_write_to_stream (whole, (GMimeStream *) cat) == -1) {
ex = exception_new ("%s", g_strerror (errno));
g_object_unref (cat);
throw (ex);
}
g_object_unref (cat);
/* now lets check that the content matches */
d(fprintf (stderr, "checking all part streams have correct data...\n"));
part = parts;
while (part != NULL) {
d(fprintf (stderr, "checking substream %s\n", part->filename));
if ((fd = open (part->filename, O_RDONLY, 0)) == -1) {
ex = exception_new ("could not open `%s': %s", part->filename, g_strerror (errno));
throw (ex);
}
if (!(sub = g_mime_stream_substream (whole, part->wstart, part->wend))) {
ex = exception_new ("could not substream original stream");
close (fd);
throw (ex);
}
if (!(stream = g_mime_stream_fs_new_with_bounds (fd, part->pstart, -1))) {
ex = exception_new ("could not instantiate stream for `%s'", part->filename);
close (fd);
throw (ex);
}
d(fprintf (stderr, "checking substream %s matches...\n", part->filename));
if (check_streams_match (sub, stream, part->filename, TRUE) == -1) {
ex = exception_new ("streams did not match");
g_object_unref (stream);
g_object_unref (sub);
throw (ex);
}
g_object_unref (stream);
g_object_unref (sub);
part = part->next;
}
}
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 void
test_openpgp_filter (GMimeFilterOpenPGP *filter, const char *path, GMimeOpenPGPData data_type, gint64 begin, gint64 end)
{
GMimeStream *filtered, *stream, *expected, *ostream;
GMimeFilter *dos2unix;
GMimeOpenPGPData type;
Exception *ex = NULL;
GByteArray *buf[2];
char *filename;
struct stat st;
gint64 offset;
ostream = g_mime_stream_mem_new ();
pump_data_through_filter ((GMimeFilter *) filter, path, ostream);
if ((type = g_mime_filter_openpgp_get_data_type (filter)) != data_type) {
g_object_unref (ostream);
throw (exception_new ("Incorrect OpenPGP data type detected: %s", openpgp_data_types[type]));
}
if ((offset = g_mime_filter_openpgp_get_begin_offset (filter)) != begin) {
g_object_unref (ostream);
throw (exception_new ("Incorrect begin offset: %ld", (long) offset));
}
if ((offset = g_mime_filter_openpgp_get_end_offset (filter)) != end) {
g_object_unref (ostream);
throw (exception_new ("Incorrect end offset: %ld", (long) offset));
}
filename = g_strdup_printf ("%s.openpgp-block", path);
if (stat (filename, &st) == -1) {
stream = g_mime_stream_fs_open (filename, O_RDWR | O_CREAT, 0644, NULL);
g_mime_stream_reset (ostream);
g_mime_stream_write_to_stream (ostream, stream);
g_mime_stream_flush (stream);
g_mime_stream_reset (stream);
} else {
stream = g_mime_stream_fs_open (filename, O_RDONLY, 0644, NULL);
}
g_free (filename);
/* make sure the data is in UNIX format before comparing (might be running tests on Windows) */
expected = g_mime_stream_mem_new ();
filtered = g_mime_stream_filter_new (expected);
dos2unix = g_mime_filter_dos2unix_new (FALSE);
g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, dos2unix);
g_object_unref (dos2unix);
g_mime_stream_write_to_stream (stream, filtered);
g_mime_stream_flush (filtered);
g_object_unref (filtered);
g_object_unref (stream);
buf[0] = GMIME_STREAM_MEM (expected)->buffer;
buf[1] = GMIME_STREAM_MEM (ostream)->buffer;
if (buf[0]->len != buf[1]->len || memcmp (buf[0]->data, buf[1]->data, buf[0]->len) != 0)
ex = exception_new ("filtered data does not match the expected result");
g_object_unref (expected);
g_object_unref (ostream);
if (ex != NULL)
throw (ex);
}
static void
test_export (GMimeCryptoContext *ctx, const char *path)
{
GMimeStream *istream, *ostream;
register const char *inptr;
const char *inbuf, *outbuf;
size_t inlen, outlen;
Exception *ex = NULL;
const char *keys[2];
GError *err = NULL;
int fd;
if ((fd = open (path, O_RDONLY, 0)) == -1)
throw (exception_new ("open() failed: %s", g_strerror (errno)));
ostream = g_mime_stream_fs_new (fd);
istream = g_mime_stream_mem_new ();
g_mime_stream_write_to_stream (ostream, istream);
g_mime_stream_reset (istream);
g_object_unref (ostream);
keys[0] = "*****@*****.**";
keys[1] = NULL;
ostream = g_mime_stream_mem_new ();
g_mime_crypto_context_export_keys (ctx, keys, ostream, &err);
if (err != NULL) {
ex = exception_new ("%s", err->message);
g_object_unref (istream);
g_object_unref (ostream);
g_error_free (err);
throw (ex);
}
inbuf = (const char *) GMIME_STREAM_MEM (istream)->buffer->data;
inlen = GMIME_STREAM_MEM (istream)->buffer->len;
if ((inptr = strstr (inbuf, "\n\n"))) {
/* skip past the headers which may have different version numbers */
inptr += 2;
inlen -= (inptr - inbuf);
inbuf = inptr;
}
outbuf = (const char *) GMIME_STREAM_MEM (ostream)->buffer->data;
outlen = GMIME_STREAM_MEM (ostream)->buffer->len;
if ((inptr = strstr (outbuf, "\n\n"))) {
/* skip past the headers which may have different version numbers */
inptr += 2;
outlen -= (inptr - outbuf);
outbuf = inptr;
}
if (outlen != inlen || memcmp (outbuf, inbuf, inlen) != 0)
ex = exception_new ("exported key does not match original key");
g_object_unref (istream);
g_object_unref (ostream);
if (ex != NULL)
throw (ex);
}
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;
}
