callisto-debian/evolution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Changed the read and write method prototypes to return an ssize_t type

Browse Source 
2000-06-06  Jeffrey Stedfast  <fejj@helixcode.com>

	* camel-stream.[c,h]: Changed the read and write method prototypes
	to return an ssize_t type rather than an int and also changed
	the 'number of bytes' to read or write to a size_t type

	* camel-stream-fs.c: same as above

	* camel-stream-mem.c: again, same as above

	* camel-stream-buffer.c: same

	* camel-imap-stream.[c,h]: Added this new stream, cache's previously
	read data so each successive call will instead read from the cache

svn path=/trunk/; revision=3450
This commit is contained in:
Jeffrey Stedfast
2000-06-06 22:55:06 +00:00
committed by Jeffrey Stedfast
parent af805a2733
commit 4b82b86ee5
8 changed files with 372 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
camel/ChangeLog
View File

@ -5,6 +5,19 @@
so it still won't build until camel-imap-summary is finished
along with a few methods in camel-imap-folder)
* camel-stream.[c,h]: Changed the read and write method prototypes
to return an ssize_t type rather than an int and also changed
the 'number of bytes' to read or write to a size_t type
* camel-stream-fs.c: same as above
* camel-stream-mem.c: again, same as above
* camel-stream-buffer.c: same
* camel-imap-stream.[c,h]: Added this new stream, cache's previously read
data so each successive call will instead read from the cache
2000-06-05 Dan Winship <danw@helixcode.com>
* camel-mime-part.c (camel_mime_part_set_disposition): fix

208
camel/camel-imap-stream.c Normal file
View File

@ -0,0 +1,208 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* Authors: Jeffrey Stedfast <fejj@helixcode.com>
*
* Copyright 2000 Helix Code, Inc. (www.helixcode.com)
*
* 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., 59 Temple Street #330, Boston, MA 02111-1307, USA.
*
*/
#include <config.h>
#include "camel-imap-stream.h"
#include <sys/types.h>
#include <errno.h>
static CamelStreamClass *parent_class = NULL;
/* Returns the class for a CamelImapStream */
#define CIS_CLASS(so) CAMEL_IMAP_STREAM_CLASS (GTK_OBJECT(so)->klass)
static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n);
static int stream_reset (CamelStream *stream);
static gboolean stream_eos (CamelStream *stream);
static void finalize (GtkObject *object);
static void
camel_imap_stream_class_init (CamelImapStreamClass *camel_imap_stream_class)
{
CamelStreamClass *camel_stream_class =
CAMEL_STREAM_CLASS (camel_imap_stream_class);
GtkObjectClass *gtk_object_class =
GTK_OBJECT_CLASS (camel_imap_stream_class);
parent_class = gtk_type_class (camel_stream_get_type ());
/* virtual method overload */
camel_stream_class->read = stream_read;
/*camel_stream_class->write = stream_write;*/
camel_stream_class->reset = stream_reset;
camel_stream_class->eos = stream_eos;
gtk_object_class->finalize = finalize;
}
static void
camel_imap_stream_init (gpointer object, gpointer klass)
{
CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (object);
imap_stream->cache = NULL;
imap_stream->cache_ptr = NULL;
}
GtkType
camel_imap_stream_get_type (void)
{
static GtkType camel_imap_stream_type = 0;
if (!camel_imap_stream_type) {
GtkTypeInfo camel_imap_stream_info =
{
"CamelImapStream",
sizeof (CamelImapStream),
sizeof (CamelImapStreamClass),
(GtkClassInitFunc) camel_imap_stream_class_init,
(GtkObjectInitFunc) camel_imap_stream_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
camel_imap_stream_type = gtk_type_unique (camel_stream_get_type (), &camel_imap_stream_info);
}
return camel_imap_stream_type;
}
CamelStream *
camel_imap_stream_new (CamelImapFolder *folder, char *command)
{
CamelImapStream *imap_stream;
imap_stream = gtk_type_new (camel_imap_stream_get_type ());
imap_stream->folder = folder;
gtk_object_ref(GTK_OBJECT (imap_stream->folder));
imap_stream->command = g_strdup(command);
return CAMEL_STREAM (imap_stream);
}
static void
finalize (GtkObject *object)
{
CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (object);
g_free(imap_stream->cache);
g_free(imap_stream->command);
if (imap_stream->folder)
gtk_object_unref(imap_stream->folder);
GTK_OBJECT_CLASS (parent_class)->finalize (object);
}
static ssize_t
stream_read (CamelStream *stream, char *buffer, size_t n)
{
ssize_t nread;
/* do we want to do any IMAP specific parsing in here? If not, maybe rename to camel-stream-cache? */
CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (stream);
if (!imap_stream->cache) {
/* We need to send the IMAP command since this is our first fetch */
CamelImapStore *store = CAMEL_IMAP_STORE (imap_stream->folder->parent_store);
gint status;
status = camel_imap_command_extended(store->ostream, imap_stream->cache, "%s",
imap_stream->command);
if (status != CAMEL_IMAP_OK) {
/* we got an error, dump this stuff */
g_free(imap_stream->cache);
imap_stream->cache = NULL;
return -1;
}
/* we don't need the folder anymore... */
gtk_object_unref(GTK_OBJECT (imap_stream->folder));
imap_stream->cache_ptr = imap_stream->cache;
}
/* we've already read this stream, so return whats in the cache */
nread = MIN (n, strlen(imap_stream->cache_ptr));
if (nread > 0) {
memcpy(buffer, imap_stream->cache_ptr, nread);
imap_stream->cache_ptr += nread;
} else {
nread = -1;
}
return nread;
}
static int
stream_write (CamelStream *stream, const char *buffer, unsigned int n)
{
/* I don't think we need/want this functionality */
CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (stream);
if (!imap_stream->cache) {
imap_stream->cache = g_malloc0(n + 1);
memcpy(imap_stream->cache, buffer, n);
} else {
imap_stream->cache = g_realloc(strlen(imap_stream->cache) + n + 1);
memcpy(imap_stream->cache[strlen(imap_stream->cache)], buffer, n);
}
return n;
}
static int
stream_reset (CamelStream *stream)
{
CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (stream);
imap_stream->cache_ptr = imap_stream->cache;
return 1;
}
static gboolean
stream_eos (CamelStream *stream)
{
CamelImapStream *imap_stream = CAMEL_IMAP_STREAM (stream);
return (imap_stream->cache_ptr && strlen(imap_stream->cache_ptr));
}

70
camel/camel-imap-stream.h Normal file
View File

@ -0,0 +1,70 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* Authors: Jeffrey Stedfast <fejj@helixcode.com>
*
* Copyright 2000 Helix Code, Inc. (www.helixcode.com)
*
* 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., 59 Temple Street #330, Boston, MA 02111-1307, USA.
*
*/
#ifndef CAMEL_IMAP_STREAM_H
#define CAMEL_IMAP_STREAM_H
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus }*/
#include <camel/camel-stream.h>
#include <camel/providers/imap/camel-imap-folder.h>
#include <camel/providers/imap/camel-imap-store.h>
#include <sys/types.h>
#define CAMEL_IMAP_STREAM_TYPE (camel_imap_stream_get_type ())
#define CAMEL_IMAP_STREAM(obj) (GTK_CHECK_CAST((obj), CAMEL_IMAP_STREAM_TYPE, CamelImapStream))
#define CAMEL_IMAP_STREAM_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_IMAP_STREAM_TYPE, CamelImapStreamClass))
#define CAMEL_IS_IMAP_STREAM(o) (GTK_CHECK_TYPE((o), CAMEL_IMAP_STREAM_TYPE))
struct _CamelImapStream
{
CamelStream parent_object;
CamelImapFolder *folder;
char *command;
char *cache;
char *cache_ptr;
};
typedef struct {
CamelStreamClass parent_class;
/* Virtual methods */
} CamelImapStreamClass;
/* Standard Gtk function */
GtkType camel_imap_stream_get_type (void);
/* public methods */
CamelStream *camel_imap_stream_new (CamelImapFolder *folder, char *command);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* CAMEL_IMAP_STREAM_H */

38
camel/camel-stream-buffer.c
View File

@ -38,8 +38,8 @@ enum {
#define BUF_SIZE 1024
static int stream_read (CamelStream *stream, char *buffer, unsigned int n);
static int stream_write (CamelStream *stream, const char *buffer, unsigned int n);
static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n);
static ssize_t stream_write (CamelStream *stream, const char *buffer, size_t n);
static int stream_flush (CamelStream *stream);
static int stream_close (CamelStream *stream);
static gboolean stream_eos (CamelStream *stream);
@ -75,7 +75,7 @@ camel_stream_buffer_class_init (CamelStreamBufferClass *camel_stream_buffer_clas
}
static void
camel_stream_buffer_init (gpointer object, gpointer klass)
camel_stream_buffer_init (gpointer object, gpointer klass)
{
CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (object);
@ -246,12 +246,12 @@ CamelStream *camel_stream_buffer_new_with_vbuf (CamelStream *stream, CamelStream
return CAMEL_STREAM (sbf);
}
static int
stream_read (CamelStream *stream, char *buffer, unsigned int n)
static ssize_t
stream_read (CamelStream *stream, char *buffer, size_t n)
{
CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (stream);
int bytes_read = 1;
int bytes_left;
ssize_t bytes_read = 1;
ssize_t bytes_left;
char *bptr = buffer;
g_return_val_if_fail( (sbf->mode & CAMEL_STREAM_BUFFER_MODE) == CAMEL_STREAM_BUFFER_READ, 0);
@ -291,17 +291,17 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n)
}
}
return bptr-buffer;
return (ssize_t)(bptr - buffer);
}
static int
stream_write (CamelStream *stream, const char *buffer, unsigned int n)
static ssize_t
stream_write (CamelStream *stream, const char *buffer, size_t n)
{
CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (stream);
const char *bptr = buffer;
int bytes_written = 1;
int bytes_left;
int total = n;
ssize_t bytes_written = 1;
ssize_t bytes_left;
ssize_t total = n;
g_return_val_if_fail( (sbf->mode & CAMEL_STREAM_BUFFER_MODE) == CAMEL_STREAM_BUFFER_WRITE, 0);
@ -336,6 +336,7 @@ stream_write (CamelStream *stream, const char *buffer, unsigned int n)
}
if (bytes_written == -1)
return -1;
return total;
}
@ -405,7 +406,7 @@ int camel_stream_buffer_gets(CamelStreamBuffer *sbf, char *buf, unsigned int max
while (inptr<inend && outptr<outend) {
c = *inptr++;
*outptr++ = c;
if (c=='\n') {
if (c == '\n') {
*outptr = 0;
sbf->ptr = inptr;
return outptr-buf;
@ -422,10 +423,10 @@ int camel_stream_buffer_gets(CamelStreamBuffer *sbf, char *buf, unsigned int max
} while (bytes_read>0);
sbf->ptr = inptr;
if (outptr<=outend)
if (outptr <= outend)
*outptr = 0;
return outptr-buf;
return (int)(outptr - buf);
}
/**
@ -473,3 +474,8 @@ camel_stream_buffer_read_line (CamelStreamBuffer *sbf)
return g_strdup(sbf->linebuf);
}

28
camel/camel-stream-filter.c
View File

@ -48,8 +48,8 @@ struct _CamelStreamFilterPrivate {
static void camel_stream_filter_class_init (CamelStreamFilterClass *klass);
static void camel_stream_filter_init (CamelStreamFilter *obj);
static int do_read (CamelStream *stream, char *buffer, unsigned int n);
static int do_write (CamelStream *stream, const char *buffer, unsigned int n);
static ssize_t do_read (CamelStream *stream, char *buffer, size_t n);
static ssize_t do_write (CamelStream *stream, const char *buffer, size_t n);
static int do_flush (CamelStream *stream);
static int do_close (CamelStream *stream);
static gboolean do_eos (CamelStream *stream);
@ -215,12 +215,12 @@ camel_stream_filter_remove(CamelStreamFilter *filter, int id)
}
}
static int
do_read (CamelStream *stream, char *buffer, unsigned int n)
static ssize_t
do_read (CamelStream *stream, char *buffer, size_t n)
{
CamelStreamFilter *filter = (CamelStreamFilter *)stream;
struct _CamelStreamFilterPrivate *p = _PRIVATE(filter);
int size;
ssize_t size;
struct _filter *f;
p->last_was_read = TRUE;
@ -229,26 +229,28 @@ do_read (CamelStream *stream, char *buffer, unsigned int n)
int presize = READ_SIZE;
size = camel_stream_read(filter->source, p->buffer, READ_SIZE);
if (size<=0) {
if (size <= 0) {
/* this is somewhat untested */
if (camel_stream_eos(filter->source)) {
f = p->filters;
p->filtered = p->buffer;
p->filteredlen = 0;
while (f) {
camel_mime_filter_complete(f->filter, p->filtered, p->filteredlen, presize, &p->filtered, &p->filteredlen, &presize);
camel_mime_filter_complete(f->filter, p->filtered, p->filteredlen,
presize, &p->filtered, &p->filteredlen, &presize);
f = f->next;
}
size = p->filteredlen;
}
if (size<=0)
if (size <= 0)
return size;
} else {
f = p->filters;
p->filtered = p->buffer;
p->filteredlen = size;
while (f) {
camel_mime_filter_filter(f->filter, p->filtered, p->filteredlen, presize, &p->filtered, &p->filteredlen, &presize);
camel_mime_filter_filter(f->filter, p->filtered, p->filteredlen, presize,
&p->filtered, &p->filteredlen, &presize);
f = f->next;
}
}
@ -262,8 +264,8 @@ do_read (CamelStream *stream, char *buffer, unsigned int n)
return size;
}
static int
do_write (CamelStream *stream, const char *buf, unsigned int n)
static ssize_t
do_write (CamelStream *stream, const char *buf, size_t n)
{
CamelStreamFilter *filter = (CamelStreamFilter *)stream;
struct _CamelStreamFilterPrivate *p = _PRIVATE(filter);
@ -305,7 +307,7 @@ do_flush (CamelStream *stream)
camel_mime_filter_complete(f->filter, buffer, len, presize, &buffer, &len, &presize);
f = f->next;
}
if (len>0 && camel_stream_write(filter->source, buffer, len) == -1)
if (len > 0 && camel_stream_write(filter->source, buffer, len) == -1)
return -1;
return camel_stream_flush(filter->source);
}
@ -328,7 +330,7 @@ do_eos (CamelStream *stream)
CamelStreamFilter *filter = (CamelStreamFilter *)stream;
struct _CamelStreamFilterPrivate *p = _PRIVATE(filter);
if (p->filteredlen >0)
if (p->filteredlen > 0)
return FALSE;
return camel_stream_eos(filter->source);

16
camel/camel-stream-fs.c
View File

@ -37,8 +37,8 @@ static CamelSeekableStreamClass *parent_class = NULL;
/* Returns the class for a CamelStreamFS */
#define CSFS_CLASS(so) CAMEL_STREAM_FS_CLASS (GTK_OBJECT(so)->klass)
static int stream_read (CamelStream *stream, char *buffer, unsigned int n);
static int stream_write (CamelStream *stream, const char *buffer, unsigned int n);
static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n);
static ssize_t stream_write (CamelStream *stream, const char *buffer, size_t n);
static int stream_flush (CamelStream *stream);
static int stream_close (CamelStream *stream);
static off_t stream_seek (CamelSeekableStream *stream, off_t offset,
@ -211,12 +211,12 @@ camel_stream_fs_new_with_name_and_bounds (const char *name, int flags,
}
static int
stream_read (CamelStream *stream, char *buffer, unsigned int n)
static ssize_t
stream_read (CamelStream *stream, char *buffer, size_t n)
{
CamelStreamFs *stream_fs = CAMEL_STREAM_FS (stream);
CamelSeekableStream *seekable = CAMEL_SEEKABLE_STREAM (stream);
int nread;
ssize_t nread;
if (seekable->bound_end != CAMEL_STREAM_UNBOUND)
n = MIN (seekable->bound_end - seekable->position, n);
@ -233,12 +233,12 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n)
return nread;
}
static int
stream_write (CamelStream *stream, const char *buffer, unsigned int n)
static ssize_t
stream_write (CamelStream *stream, const char *buffer, size_t n)
{
CamelStreamFs *stream_fs = CAMEL_STREAM_FS (stream);
CamelSeekableStream *seekable = CAMEL_SEEKABLE_STREAM (stream);
int v, written = 0;
ssize_t v, written = 0;
if (seekable->bound_end != CAMEL_STREAM_UNBOUND)
n = MIN (seekable->bound_end - seekable->position, n);

46
camel/camel-stream-mem.c
View File

@ -35,8 +35,8 @@ static CamelStreamClass *parent_class = NULL;
/* Returns the class for a CamelStreamMem */
#define CSM_CLASS(so) CAMEL_STREAM_MEM_CLASS (GTK_OBJECT(so)->klass)
static int stream_read (CamelStream *stream, char *buffer, unsigned int n);
static int stream_write (CamelStream *stream, const char *buffer, unsigned int n);
static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n);
static ssize_t stream_write (CamelStream *stream, const char *buffer, size_t n);
static gboolean stream_eos (CamelStream *stream);
static off_t stream_seek (CamelSeekableStream *stream, off_t offset,
CamelStreamSeekPolicy policy);
@ -157,47 +157,49 @@ finalize (GtkObject *object)
GTK_OBJECT_CLASS (parent_class)->finalize (object);
}
static int
stream_read (CamelStream *stream, char *buffer, unsigned int n)
static ssize_t
stream_read (CamelStream *stream, char *buffer, size_t n)
{
CamelStreamMem *camel_stream_mem = CAMEL_STREAM_MEM (stream);
CamelSeekableStream *seekable = CAMEL_SEEKABLE_STREAM (stream);
ssize_t nread;
if (seekable->bound_end != CAMEL_STREAM_UNBOUND)
n = MIN(seekable->bound_end - seekable->position, n);
n = MIN (n, camel_stream_mem->buffer->len - seekable->position);
if (n > 0) {
nread = MIN (n, camel_stream_mem->buffer->len - seekable->position);
if (nread > 0) {
memcpy (buffer, camel_stream_mem->buffer->data +
seekable->position, n);
seekable->position += n;
seekable->position, nread);
seekable->position += nread;
} else
n = -1;
nread = -1;
return n;
return nread;
}
static int
stream_write (CamelStream *stream, const char *buffer, unsigned int n)
static ssize_t
stream_write (CamelStream *stream, const char *buffer, size_t n)
{
CamelStreamMem *stream_mem = CAMEL_STREAM_MEM (stream);
CamelSeekableStream *seekable = CAMEL_SEEKABLE_STREAM (stream);
ssize_t nwrite = n;
if (seekable->bound_end != CAMEL_STREAM_UNBOUND)
n = MIN(seekable->bound_end - seekable->position, n);
nwrite = MIN(seekable->bound_end - seekable->position, n);
#warning "g_byte_arrays use g_malloc and so are totally unsuitable for this object"
if (seekable->position == stream_mem->buffer->len) {
stream_mem->buffer =
g_byte_array_append (stream_mem->buffer, (const guint8 *)buffer, n);
g_byte_array_append (stream_mem->buffer, (const guint8 *)buffer, nwrite);
} else {
g_byte_array_set_size (stream_mem->buffer,
n+stream_mem->buffer->len);
memcpy (stream_mem->buffer->data + seekable->position, buffer, n);
nwrite + stream_mem->buffer->len);
memcpy (stream_mem->buffer->data + seekable->position, buffer, nwrite);
}
seekable->position += n;
seekable->position += nwrite;
return n;
return nwrite;
}
static gboolean
@ -226,6 +228,9 @@ stream_seek (CamelSeekableStream *stream, off_t offset,
case CAMEL_STREAM_END:
position = (stream_mem->buffer)->len + offset;
break;
default:
position = offset;
break;
}
if (stream->bound_end == CAMEL_STREAM_UNBOUND)
@ -246,3 +251,6 @@ stream_seek (CamelSeekableStream *stream, off_t offset,
return position;
}

17
camel/camel-stream.h
View File

@ -35,6 +35,7 @@ extern "C" {
#include <camel/camel-object.h>
#include <stdarg.h>
#include <unistd.h>
#define CAMEL_STREAM_TYPE (camel_stream_get_type ())
#define CAMEL_STREAM(obj) (GTK_CHECK_CAST((obj), CAMEL_STREAM_TYPE, CamelStream))
@ -53,8 +54,8 @@ typedef struct {
/* Virtual methods */
int (*read) (CamelStream *stream, char *buffer, unsigned int n);
int (*write) (CamelStream *stream, const char *buffer, unsigned int n);
ssize_t (*read) (CamelStream *stream, char *buffer, size_t n);
ssize_t (*write) (CamelStream *stream, const char *buffer, size_t n);
int (*close) (CamelStream *stream);
int (*flush) (CamelStream *stream);
gboolean (*eos) (CamelStream *stream);
@ -66,22 +67,22 @@ typedef struct {
GtkType camel_stream_get_type (void);
/* public methods */
int camel_stream_read (CamelStream *stream, char *buffer, unsigned int n);
int camel_stream_write (CamelStream *stream, const char *buffer, unsigned int n);
ssize_t camel_stream_read (CamelStream *stream, char *buffer, size_t n);
ssize_t camel_stream_write (CamelStream *stream, const char *buffer, size_t n);
int camel_stream_flush (CamelStream *stream);
int camel_stream_close (CamelStream *stream);
gboolean camel_stream_eos (CamelStream *stream);
int camel_stream_reset (CamelStream *stream);
/* utility macros and funcs */
int camel_stream_write_string (CamelStream *stream, const char *string);
int camel_stream_printf (CamelStream *stream, const char *fmt, ... ) G_GNUC_PRINTF (2, 3);
int camel_stream_vprintf (CamelStream *stream, const char *fmt, va_list ap);
ssize_t camel_stream_write_string (CamelStream *stream, const char *string);
ssize_t camel_stream_printf (CamelStream *stream, const char *fmt, ... ) G_GNUC_PRINTF (2, 3);
ssize_t camel_stream_vprintf (CamelStream *stream, const char *fmt, va_list ap);
/* Write a whole stream to another stream, until eof or error on
* either stream.
*/
int camel_stream_write_to_stream (CamelStream *stream, CamelStream *output_stream);
ssize_t camel_stream_write_to_stream (CamelStream *stream, CamelStream *output_stream);
#ifdef __cplusplus
}