diff options
Diffstat (limited to 'camel')
30 files changed, 562 insertions, 485 deletions
diff --git a/camel/ChangeLog b/camel/ChangeLog index a2a09c9e05..504b95bf7a 100644 --- a/camel/ChangeLog +++ b/camel/ChangeLog @@ -1,3 +1,61 @@ +2000-05-19 NotZed <NotZed@HelixCode.com> + + * camel-simple-data-wrapper.c (construct_from_stream): If we + already have been constructed, unref our content. + (write_to_stream): Check we've been constructued, and change for + stream api changes. + + * camel-mime-parser.c: Removed exception stuff. + + * md5-utils.c (md5_get_digest_from_stream): repaired. + + * camel-mime-message.c: Remove exception from write_to_stream, and + fix, and fix formatting. + + * providers/sendmail/camel-sendmail-transport.c (_send_internal): + Fix for stream changes. + + * providers/pop3/camel-pop3-store.c (camel_pop3_command): Fixes + for stream changes. + + * providers/mbox/camel-mbox-folder.c, and elsewhere, fix all + stream api changes. + (mbox_append_message): Use stream_close() now its back. + (mbox_append_message): unref the from filter. + + * camel-stream-mem.c: And here. + + * camel-stream-fs.[ch]: Here too. + + * camel-stream-filter.c: Likewise. This is getting tedious. + + * camel-stream-buffer.c (stream_write): Fix a few little problems. + (stream_close): Reimplmeent. + (camel_stream_buffer_read_line): Slightly more efficient version, + that also only allocates the right amount of memory for strings. + + * camel-seekable-substream.c: Likewise. + + * camel-seekable-stream.[ch]: Remove exceptions, fix formatting, + changes for stream (re)fixes. set_bounds returns an error. + + * camel-stream.[ch]: Remove exceptions. Make flush and reset return + an error code, repair all the screwed up formatting, and put back + close. + + * camel-mime-part-utils.c + (camel_mime_part_construct_content_from_parser): And here. + + * camel-mime-part.c (camel_mime_part_set_content): And this too. + (write_to_stream): Fixed for stream changes. + + * camel.h: Fixed. + + * providers/vee/camel-vee-folder.c (vee_search_by_expression): + Implement. Performs an intersection of the two searches. + (camel_vee_folder_finalise): Unref search folders. + (vee_append_message): Implement append. + 2000-05-18 Dan Winship <danw@helixcode.com> * camel-folder.c: remove message_number_capability and require uid diff --git a/camel/camel-data-wrapper.c b/camel/camel-data-wrapper.c index 61cee59a51..fe9f8bf78b 100644 --- a/camel/camel-data-wrapper.c +++ b/camel/camel-data-wrapper.c @@ -1,4 +1,4 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; fill-column: 160 -*- */ /* camel-data-wrapper.c : Abstract class for a data_wrapper */ /* @@ -37,14 +37,11 @@ static CamelObjectClass *parent_class = NULL; static int construct_from_stream(CamelDataWrapper *, CamelStream *); -static int write_to_stream (CamelDataWrapper *data_wrapper, - CamelStream *stream, CamelException *ex); -static void set_mime_type (CamelDataWrapper *data_wrapper, - const gchar *mime_type); +static int write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream); +static void set_mime_type (CamelDataWrapper *data_wrapper, const gchar *mime_type); static gchar *get_mime_type (CamelDataWrapper *data_wrapper); static GMimeContentField *get_mime_type_field (CamelDataWrapper *data_wrapper); -static void set_mime_type_field (CamelDataWrapper *data_wrapper, - GMimeContentField *mime_type); +static void set_mime_type_field (CamelDataWrapper *data_wrapper, GMimeContentField *mime_type); static void finalize (GtkObject *object); static void @@ -115,12 +112,22 @@ finalize (GtkObject *object) } static int -write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, - CamelException *ex) +write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream) { - g_warning ("CamelDataWrapper::write_to_stream not implemented for " - "`%s'", gtk_type_name (GTK_OBJECT_TYPE (data_wrapper))); - return -1; + if (data_wrapper->stream == NULL) { + return -1; + } + + if (camel_stream_reset (data_wrapper->stream) == -1) + return -1; + + return camel_stream_write_to_stream (data_wrapper->stream, stream); +} + +CamelDataWrapper * +camel_data_wrapper_new(void) +{ + return (CamelDataWrapper *)gtk_type_new(camel_data_wrapper_get_type()); } /** @@ -138,20 +145,17 @@ write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, **/ int camel_data_wrapper_write_to_stream (CamelDataWrapper *data_wrapper, - CamelStream *stream, CamelException *ex) + CamelStream *stream) { g_return_val_if_fail (CAMEL_IS_DATA_WRAPPER (data_wrapper), -1); g_return_val_if_fail (CAMEL_IS_STREAM (stream), -1); - return CDW_CLASS (data_wrapper)->write_to_stream (data_wrapper, - stream, ex); + return CDW_CLASS (data_wrapper)->write_to_stream (data_wrapper, stream); } static int construct_from_stream (CamelDataWrapper *data_wrapper, CamelStream *stream) { - g_warning ("CamelDataWrapper::construct_from_stream not implemented " - "for `%s'", gtk_type_name (GTK_OBJECT_TYPE (data_wrapper))); return -1; } @@ -163,9 +167,7 @@ construct_from_stream (CamelDataWrapper *data_wrapper, CamelStream *stream) * Constructs the content of the data wrapper from the * supplied @stream. * - * This could fail, but you can't know if it did. - * - * Return value: Who knows. FIXME + * Return value: -1 on error. **/ int camel_data_wrapper_construct_from_stream (CamelDataWrapper *data_wrapper, @@ -274,6 +276,5 @@ void camel_data_wrapper_set_mime_type_field (CamelDataWrapper *data_wrapper, GMimeContentField *mime_type) { - CDW_CLASS (data_wrapper)->set_mime_type_field (data_wrapper, - mime_type); + CDW_CLASS (data_wrapper)->set_mime_type_field (data_wrapper, mime_type); } diff --git a/camel/camel-data-wrapper.h b/camel/camel-data-wrapper.h index d6e9e754cf..8df09fa848 100644 --- a/camel/camel-data-wrapper.h +++ b/camel/camel-data-wrapper.h @@ -42,16 +42,14 @@ extern "C" { #define CAMEL_DATA_WRAPPER_CLASS(k) (GTK_CHECK_CLASS_CAST ((k), CAMEL_DATA_WRAPPER_TYPE, CamelDataWrapperClass)) #define CAMEL_IS_DATA_WRAPPER(o) (GTK_CHECK_TYPE((o), CAMEL_DATA_WRAPPER_TYPE)) - struct _CamelDataWrapper { CamelObject parent_object; GMimeContentField *mime_type; + CamelStream *stream; }; - - typedef struct { CamelObjectClass parent_class; @@ -68,23 +66,19 @@ typedef struct { GMimeContentField *mime_type_field); int (*write_to_stream) (CamelDataWrapper *data_wrapper, - CamelStream *stream, - CamelException *ex); + CamelStream *stream); int (*construct_from_stream) (CamelDataWrapper *data_wrapper, CamelStream *); } CamelDataWrapperClass; - - /* Standard Gtk function */ GtkType camel_data_wrapper_get_type (void); - /* public methods */ +CamelDataWrapper * camel_data_wrapper_new(void); int camel_data_wrapper_write_to_stream (CamelDataWrapper *data_wrapper, - CamelStream *stream, - CamelException *ex); + CamelStream *stream); void camel_data_wrapper_set_mime_type (CamelDataWrapper *data_wrapper, const gchar *mime_type); gchar * camel_data_wrapper_get_mime_type (CamelDataWrapper *data_wrapper); diff --git a/camel/camel-folder-search.c b/camel/camel-folder-search.c index b6332c5656..fa07fc819f 100644 --- a/camel/camel-folder-search.c +++ b/camel/camel-folder-search.c @@ -472,7 +472,7 @@ static ESExpResult *search_user_flag(struct _ESExp *f, int argc, struct _ESExpRe ESExpResult *r; int i; - r(printf("executing header-contains\n")); + r(printf("executing user-flag\n")); /* are we inside a match-all? */ if (search->current) { diff --git a/camel/camel-folder.c b/camel/camel-folder.c index 2c6e04d73b..34b830f564 100644 --- a/camel/camel-folder.c +++ b/camel/camel-folder.c @@ -1,4 +1,4 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; fill-column: 160 -*- */ /* camel-folder.c: Abstract class for an email folder */ /* diff --git a/camel/camel-mime-message.c b/camel/camel-mime-message.c index f65691909f..8fca516fd0 100644 --- a/camel/camel-mime-message.c +++ b/camel/camel-mime-message.c @@ -1,4 +1,4 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; fill-column: 160 -*- */ /* camelMimeMessage.c : class for a mime_message */ /* @@ -66,8 +66,7 @@ static guint signals[LAST_SIGNAL] = { 0 }; static void set_message_number (CamelMimeMessage *mime_message, guint number); static guint get_message_number (CamelMimeMessage *mime_message); -static int write_to_stream (CamelDataWrapper *data_wrapper, - CamelStream *stream, CamelException *ex); +static int write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream); static void finalize (GtkObject *object); static void add_header (CamelMedium *medium, const char *header_name, const void *header_value); static void set_header (CamelMedium *medium, const char *header_name, const void *header_value); @@ -592,8 +591,7 @@ construct_from_parser(CamelMimePart *dw, CamelMimeParser *mp) } static int -write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, - CamelException *ex) +write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream) { CamelMimeMessage *mm = CAMEL_MIME_MESSAGE (data_wrapper); @@ -615,7 +613,7 @@ write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, camel_medium_set_header((CamelMedium *)mm, "Mime-Version", "1.0"); - return CAMEL_DATA_WRAPPER_CLASS (parent_class)->write_to_stream (data_wrapper, stream, ex); + return CAMEL_DATA_WRAPPER_CLASS (parent_class)->write_to_stream (data_wrapper, stream); } static char * diff --git a/camel/camel-mime-parser.c b/camel/camel-mime-parser.c index 3db6adfe83..74c7653df3 100644 --- a/camel/camel-mime-parser.c +++ b/camel/camel-mime-parser.c @@ -41,7 +41,6 @@ #include "camel-mime-filter.h" #include "camel-stream.h" #include "camel-seekable-stream.h" -#include "camel-exception.h" #define r(x) #define h(x) @@ -209,7 +208,6 @@ struct _header_scan_state { int fd; /* input for a fd input */ CamelStream *stream; /* or for a stream */ - CamelException *ex; /* exception for the stream */ /* for scanning input buffers */ char *realbuf; /* the real buffer, SCAN_HEAD*2 + SCAN_BUF bytes */ @@ -826,8 +824,7 @@ folder_read(struct _header_scan_state *s) memcpy(s->inbuf, s->inptr, inoffset); } if (s->stream) { - len = camel_stream_read(s->stream, s->inbuf+inoffset, - SCAN_BUF-inoffset, s->ex); + len = camel_stream_read(s->stream, s->inbuf+inoffset, SCAN_BUF-inoffset); } else { len = read(s->fd, s->inbuf+inoffset, SCAN_BUF-inoffset); } @@ -872,7 +869,7 @@ folder_seek(struct _header_scan_state *s, off_t offset, int whence) if (CAMEL_IS_SEEKABLE_STREAM(s->stream)) { /* NOTE: assumes whence seekable stream == whence libc, which is probably the case (or bloody well should've been) */ - newoffset = camel_seekable_stream_seek((CamelSeekableStream *)s->stream, offset, whence, s->ex); + newoffset = camel_seekable_stream_seek((CamelSeekableStream *)s->stream, offset, whence); } else { newoffset = -1; errno = EINVAL; @@ -889,7 +886,7 @@ folder_seek(struct _header_scan_state *s, off_t offset, int whence) s->inptr = s->inbuf; s->inend = s->inbuf; if (s->stream) - len = camel_stream_read(s->stream, s->inbuf, SCAN_BUF, s->ex); + len = camel_stream_read(s->stream, s->inbuf, SCAN_BUF); else len = read(s->fd, s->inbuf, SCAN_BUF); if (len>=0) { @@ -1358,7 +1355,6 @@ folder_scan_close(struct _header_scan_state *s) close(s->fd); if (s->stream) { gtk_object_unref((GtkObject *)s->stream); - camel_exception_free(s->ex); } g_free(s); } @@ -1373,7 +1369,6 @@ folder_scan_init(void) s->fd = -1; s->stream = NULL; - s->ex = NULL; s->outbuf = g_malloc(1024); s->outptr = s->outbuf; @@ -1421,8 +1416,6 @@ folder_scan_init_with_fd(struct _header_scan_state *s, int fd) if (s->stream) { gtk_object_unref((GtkObject *)s->stream); s->stream = NULL; - camel_exception_free(s->ex); - s->ex = NULL; } return 0; } else { @@ -1434,11 +1427,9 @@ static int folder_scan_init_with_stream(struct _header_scan_state *s, CamelStream *stream) { int len; - CamelException *ex; - ex = camel_exception_new(); - len = camel_stream_read(stream, s->inbuf, SCAN_BUF, ex); - if (!camel_exception_is_set (ex)) { + len = camel_stream_read(stream, s->inbuf, SCAN_BUF); + if (len >= 0) { s->inend = s->inbuf+len; s->inptr = s->inbuf; s->inend[0] = '\n'; @@ -1446,16 +1437,12 @@ folder_scan_init_with_stream(struct _header_scan_state *s, CamelStream *stream) gtk_object_unref((GtkObject *)s->stream); s->stream = stream; gtk_object_ref((GtkObject *)stream); - if (s->ex) - camel_exception_free(s->ex); - s->ex = ex; if (s->fd != -1) { close(s->fd); s->fd = -1; } return 0; } else { - camel_exception_free (ex); return -1; } } diff --git a/camel/camel-mime-part.c b/camel/camel-mime-part.c index e79edaa3dd..d727c98811 100644 --- a/camel/camel-mime-part.c +++ b/camel/camel-mime-part.c @@ -66,9 +66,7 @@ static CamelMediumClass *parent_class=NULL; static void finalize (GtkObject *object); /* from CamelDataWrapper */ -static int write_to_stream (CamelDataWrapper *data_wrapper, - CamelStream *stream, - CamelException *ex); +static int write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream); static int construct_from_stream (CamelDataWrapper *dw, CamelStream *s); /* from CamelMedia */ @@ -480,13 +478,13 @@ set_content_object (CamelMedium *medium, CamelDataWrapper *content) /**********************************************************************/ static int -write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, - CamelException *ex) +write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream) { CamelMimePart *mp = CAMEL_MIME_PART (data_wrapper); CamelMedium *medium = CAMEL_MEDIUM (data_wrapper); CamelDataWrapper *content; int total = 0; + int count; d(printf("mime_part::write_to_stream\n")); @@ -497,19 +495,18 @@ write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, if (mp->headers) { struct _header_raw *h = mp->headers; while (h) { - total += camel_stream_printf (stream, ex, "%s%s%s\n", - h->name, - isspace(h->value[0]) ? ":" : ": ", - h->value); - if (camel_exception_is_set (ex)) + count = camel_stream_printf(stream, "%s%s%s\n", h->name, isspace(h->value[0]) ? ":" : ": ", h->value); + if (count == -1) return -1; + total += count; h = h->next; } } - total += camel_stream_write (stream, "\n", 1, ex); - if (camel_exception_is_set (ex)) + count = camel_stream_write (stream, "\n", 1); + if (count == -1) return -1; + total += count; content = camel_medium_get_content_object (medium); if (content) { @@ -537,11 +534,12 @@ write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, } #endif - total += camel_data_wrapper_write_to_stream (content, stream, ex); + count = camel_data_wrapper_write_to_stream (content, stream); if (filter_stream) gtk_object_unref((GtkObject *)filter_stream); - if (camel_exception_is_set (ex)) + if (count == -1) return -1; + total += count; } else { g_warning("No content for medium, nothing to write"); } @@ -692,7 +690,7 @@ camel_mime_part_set_content (CamelMimePart *camel_mime_part, CamelDataWrapper *dw; CamelStream *stream; - dw = camel_simple_data_wrapper_new (); + dw = camel_data_wrapper_new (); camel_data_wrapper_set_mime_type (dw, type); stream = camel_stream_mem_new_with_buffer (data, length); camel_data_wrapper_construct_from_stream (dw, stream); diff --git a/camel/camel-multipart.c b/camel/camel-multipart.c index 8155ce1229..ea1f7d356f 100644 --- a/camel/camel-multipart.c +++ b/camel/camel-multipart.c @@ -51,8 +51,7 @@ static void set_boundary (CamelMultipart *multipart, gchar *boundary); static const gchar * get_boundary (CamelMultipart *multipart); static int write_to_stream (CamelDataWrapper *data_wrapper, - CamelStream *stream, - CamelException *ex); + CamelStream *stream); static void finalize (GtkObject *object); static CamelDataWrapperClass *parent_class = NULL; @@ -406,12 +405,12 @@ camel_multipart_get_boundary (CamelMultipart *multipart) /* this is MIME specific, doesn't belong here really */ static int -write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, - CamelException *ex) +write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream) { CamelMultipart *multipart = CAMEL_MULTIPART (data_wrapper); const gchar *boundary; int total = 0; + int count; GList *node; /* get the bundary text */ @@ -426,10 +425,10 @@ write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, * your mail client probably doesn't support ...." */ if (multipart->preface) { - total += camel_stream_write_string (stream, - multipart->preface, ex); - if (camel_exception_is_set (ex)) + count = camel_stream_write_string (stream, multipart->preface); + if (count == -1) return -1; + total += count; } /* @@ -438,28 +437,30 @@ write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, */ node = multipart->parts; while (node) { - total += camel_stream_printf (stream, ex, "\n--%s\n", - boundary); - if (camel_exception_is_set (ex)) + count = camel_stream_printf (stream, "\n--%s\n", boundary); + if (count == -1) return -1; + total += count; - total += camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (node->data), stream, ex); - if (camel_exception_is_set (ex)) + count = camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (node->data), stream); + if (count == -1) return -1; + total += count; node = node->next; } /* write the terminating boudary delimiter */ - total += camel_stream_printf (stream, ex, "\n--%s--\n", boundary); - if (camel_exception_is_set (ex)) + count = camel_stream_printf (stream, "\n--%s--\n", boundary); + if (count == -1) return -1; + total += count; /* and finally the postface */ if (multipart->postface) { - total += camel_stream_write_string (stream, - multipart->postface, ex); - if (camel_exception_is_set (ex)) + count = camel_stream_write_string (stream, multipart->postface); + if (count == -1) return -1; + total += count; } return total; diff --git a/camel/camel-seekable-stream.c b/camel/camel-seekable-stream.c index a62ae9544f..507c69dd48 100644 --- a/camel/camel-seekable-stream.c +++ b/camel/camel-seekable-stream.c @@ -32,13 +32,10 @@ static CamelStreamClass *parent_class = NULL; #define CSS_CLASS(so) CAMEL_SEEKABLE_STREAM_CLASS (GTK_OBJECT(so)->klass) static off_t seek (CamelSeekableStream *stream, off_t offset, - CamelStreamSeekPolicy policy, - CamelException *ex); + CamelStreamSeekPolicy policy); static off_t stream_tell (CamelSeekableStream *stream); -static void reset (CamelStream *stream, CamelException *ex); -static void set_bounds (CamelSeekableStream *stream, off_t start, off_t end, - CamelException *ex); - +static int reset (CamelStream *stream); +static int set_bounds (CamelSeekableStream *stream, off_t start, off_t end); static void camel_seekable_stream_class_init (CamelSeekableStreamClass *camel_seekable_stream_class) @@ -93,7 +90,7 @@ camel_seekable_stream_get_type (void) static off_t seek (CamelSeekableStream *stream, off_t offset, - CamelStreamSeekPolicy policy, CamelException *ex) + CamelStreamSeekPolicy policy) { g_warning ("CamelSeekableStream::seek called on default " "implementation\n"); @@ -105,7 +102,6 @@ seek (CamelSeekableStream *stream, off_t offset, * @stream: a CamelStream object. * @offset: offset value * @policy: what to do with the offset - * @ex: a CamelException * * Seek to the specified position in @stream. * @@ -125,12 +121,11 @@ seek (CamelSeekableStream *stream, off_t offset, **/ off_t camel_seekable_stream_seek (CamelSeekableStream *stream, off_t offset, - CamelStreamSeekPolicy policy, - CamelException *ex) + CamelStreamSeekPolicy policy) { g_return_val_if_fail (CAMEL_IS_SEEKABLE_STREAM (stream), -1); - return CSS_CLASS (stream)->seek (stream, offset, policy, ex); + return CSS_CLASS (stream)->seek (stream, offset, policy); } @@ -156,17 +151,17 @@ camel_seekable_stream_tell (CamelSeekableStream *stream) return CSS_CLASS (stream)->tell (stream); } - -static void -set_bounds (CamelSeekableStream *stream, off_t start, off_t end, - CamelException *ex) +static int +set_bounds (CamelSeekableStream *stream, off_t start, off_t end) { /* store the bounds */ stream->bound_start = start; stream->bound_end = end; if (start > stream->position) - camel_seekable_stream_seek (stream, start, CAMEL_STREAM_SET, ex); + return camel_seekable_stream_seek (stream, start, CAMEL_STREAM_SET); + + return 0; } /** @@ -178,28 +173,30 @@ set_bounds (CamelSeekableStream *stream, off_t start, off_t end, * Set the range of valid data this stream is allowed to cover. If * there is to be no @end value, then @end should be set to * #CAMEL_STREAM_UNBOUND. + * + * Return value: -1 on error. **/ -void +int camel_seekable_stream_set_bounds (CamelSeekableStream *stream, - off_t start, off_t end, CamelException *ex) + off_t start, off_t end) { - g_return_if_fail (CAMEL_IS_SEEKABLE_STREAM (stream)); - g_return_if_fail (end == CAMEL_STREAM_UNBOUND || end >= start); + g_return_val_if_fail (CAMEL_IS_SEEKABLE_STREAM (stream), -1); + g_return_val_if_fail (end == CAMEL_STREAM_UNBOUND || end >= start, -1); - CSS_CLASS (stream)->set_bounds (stream, start, end, ex); + return CSS_CLASS (stream)->set_bounds (stream, start, end); } /* a default implementation of reset for seekable streams */ -static void -reset (CamelStream *stream, CamelException *ex) +static int +reset (CamelStream *stream) { CamelSeekableStream *seekable_stream; seekable_stream = CAMEL_SEEKABLE_STREAM (stream); - camel_seekable_stream_seek (seekable_stream, - seekable_stream->bound_start, - CAMEL_STREAM_SET, ex); + return camel_seekable_stream_seek (seekable_stream, + seekable_stream->bound_start, + CAMEL_STREAM_SET); } diff --git a/camel/camel-seekable-stream.h b/camel/camel-seekable-stream.h index 24333bcfa0..f1cd5cdbca 100644 --- a/camel/camel-seekable-stream.h +++ b/camel/camel-seekable-stream.h @@ -66,25 +66,20 @@ typedef struct { /* Virtual methods */ off_t (*seek) (CamelSeekableStream *stream, off_t offset, - CamelStreamSeekPolicy policy, - CamelException *ex); + CamelStreamSeekPolicy policy); off_t (*tell) (CamelSeekableStream *stream); - void (*set_bounds) (CamelSeekableStream *stream, - off_t start, off_t end, CamelException *ex); + int (*set_bounds) (CamelSeekableStream *stream, + off_t start, off_t end); } CamelSeekableStreamClass; /* Standard Gtk function */ GtkType camel_seekable_stream_get_type (void); /* public methods */ -off_t camel_seekable_stream_seek (CamelSeekableStream *stream, - off_t offset, - CamelStreamSeekPolicy policy, - CamelException *ex); +off_t camel_seekable_stream_seek (CamelSeekableStream *stream, off_t offset, + CamelStreamSeekPolicy policy); off_t camel_seekable_stream_tell (CamelSeekableStream *stream); -void camel_seekable_stream_set_bounds (CamelSeekableStream *, - off_t, off_t, - CamelException *); +int camel_seekable_stream_set_bounds (CamelSeekableStream *, off_t start, off_t end); #ifdef __cplusplus } diff --git a/camel/camel-seekable-substream.c b/camel/camel-seekable-substream.c index 5c9ea6ebe7..4fc5b5d853 100644 --- a/camel/camel-seekable-substream.c +++ b/camel/camel-seekable-substream.c @@ -23,28 +23,20 @@ */ #include <config.h> #include "camel-seekable-substream.h" -#include "camel-exception.h" static CamelSeekableStreamClass *parent_class = NULL; /* Returns the class for a CamelSeekableSubStream */ #define CSS_CLASS(so) CAMEL_SEEKABLE_SUBSTREAM_CLASS (GTK_OBJECT(so)->klass) -static int stream_read (CamelStream *stream, - char *buffer, unsigned int n, - CamelException *ex); -static int stream_write (CamelStream *stream, - const char *buffer, - unsigned int n, - CamelException *ex); -static void stream_flush (CamelStream *stream, - CamelException *ex); -static gboolean eos (CamelStream *stream); -static off_t stream_seek (CamelSeekableStream *stream, - off_t offset, - CamelStreamSeekPolicy policy, - CamelException *ex); -static void finalize (GtkObject *object); +static int stream_read (CamelStream *stream, char *buffer, unsigned int n); +static int stream_write (CamelStream *stream, const char *buffer, unsigned int n); +static int stream_flush (CamelStream *stream); +static int stream_close (CamelStream *stream); +static gboolean eos (CamelStream *stream); +static off_t stream_seek (CamelSeekableStream *stream, off_t offset, + CamelStreamSeekPolicy policy); +static void finalize (GtkObject *object); static void @@ -65,6 +57,7 @@ camel_seekable_substream_class_init (CamelSeekableSubstreamClass *camel_seekable camel_stream_class->read = stream_read; camel_stream_class->write = stream_write; camel_stream_class->flush = stream_flush; + camel_stream_class->close = stream_close; camel_stream_class->eos = eos; camel_seekable_stream_class->seek = stream_seek; @@ -131,7 +124,6 @@ camel_seekable_substream_new_with_seekable_stream_and_bounds (CamelSeekableStrea off_t start, off_t end) { CamelSeekableSubstream *seekable_substream; - CamelException ex; g_return_val_if_fail (CAMEL_IS_SEEKABLE_STREAM (parent_stream), NULL); @@ -145,16 +137,13 @@ camel_seekable_substream_new_with_seekable_stream_and_bounds (CamelSeekableStrea /* Set the bound of the substream. We can ignore any possible error * here, because if we fail to seek now, it will try again later. */ - camel_exception_init (&ex); - camel_seekable_stream_set_bounds ((CamelSeekableStream *)seekable_substream, start, end, &ex); - camel_exception_clear (&ex); + camel_seekable_stream_set_bounds ((CamelSeekableStream *)seekable_substream, start, end); return CAMEL_STREAM (seekable_substream); } static gboolean -parent_reset (CamelSeekableSubstream *seekable_substream, - CamelSeekableStream *parent, CamelException *ex) +parent_reset (CamelSeekableSubstream *seekable_substream, CamelSeekableStream *parent) { CamelSeekableStream *seekable_stream = CAMEL_SEEKABLE_STREAM (seekable_substream); @@ -162,14 +151,12 @@ parent_reset (CamelSeekableSubstream *seekable_substream, if (camel_seekable_stream_tell (parent) == seekable_stream->position) return TRUE; - camel_seekable_stream_seek (parent, seekable_stream->position, - CAMEL_STREAM_SET, ex); - return !camel_exception_is_set (ex); + return camel_seekable_stream_seek (parent, seekable_stream->position, CAMEL_STREAM_SET) + == seekable_stream->position; } static int -stream_read (CamelStream *stream, char *buffer, unsigned int n, - CamelException *ex) +stream_read (CamelStream *stream, char *buffer, unsigned int n) { CamelSeekableStream *parent; CamelSeekableStream *seekable_stream = CAMEL_SEEKABLE_STREAM (stream); @@ -183,7 +170,7 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n, parent = seekable_substream->parent_stream; /* Go to our position in the parent stream. */ - if (!parent_reset (seekable_substream, parent, ex)) { + if (!parent_reset (seekable_substream, parent)) { stream->eos = TRUE; return 0; } @@ -197,7 +184,7 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n, return 0; } - v = camel_stream_read (CAMEL_STREAM (parent), buffer, n, ex); + v = camel_stream_read (CAMEL_STREAM (parent), buffer, n); /* ignore <0 - its an error, let the caller deal */ if (v > 0) @@ -207,22 +194,29 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n, } static int -stream_write (CamelStream *stream, const char *buffer, unsigned int n, - CamelException *ex) +stream_write (CamelStream *stream, const char *buffer, unsigned int n) { /* NOT VALID ON SEEKABLE SUBSTREAM */ /* Well, its entirely valid, just not implemented */ g_warning ("CamelSeekableSubstream:: seekable substream doesn't " - "have a write method\n"); + "have a write method yet?\n"); return -1; } -static void -stream_flush (CamelStream *stream, CamelException *ex) +static int +stream_flush (CamelStream *stream) { /* NOT VALID ON SEEKABLE SUBSTREAM */ g_warning ("CamelSeekableSubstream:: seekable substream doesn't " "have a flush method\n"); + return -1; +} + +static int +stream_close (CamelStream *stream) +{ + /* we dont really want to close the substream ... */ + return 0; } static gboolean @@ -232,19 +226,14 @@ eos (CamelStream *stream) CAMEL_SEEKABLE_SUBSTREAM (stream); CamelSeekableStream *seekable_stream = CAMEL_SEEKABLE_STREAM (stream); CamelSeekableStream *parent; - CamelException ex; gboolean eos; if (stream->eos) eos = TRUE; else { parent = seekable_substream->parent_stream; - camel_exception_init (&ex); - parent_reset (seekable_substream, parent, &ex); - if (camel_exception_is_set (&ex)) { - camel_exception_clear (&ex); + if (!parent_reset (seekable_substream, parent)) return TRUE; - } eos = camel_stream_eos (CAMEL_STREAM (parent)); if (!eos && (seekable_stream->bound_end != CAMEL_STREAM_UNBOUND)) { @@ -257,7 +246,7 @@ eos (CamelStream *stream) static off_t stream_seek (CamelSeekableStream *seekable_stream, off_t offset, - CamelStreamSeekPolicy policy, CamelException *ex) + CamelStreamSeekPolicy policy) { CamelSeekableSubstream *seekable_substream = CAMEL_SEEKABLE_SUBSTREAM (seekable_stream); @@ -278,9 +267,8 @@ stream_seek (CamelSeekableStream *seekable_stream, off_t offset, case CAMEL_STREAM_END: real_offset = camel_seekable_stream_seek (seekable_substream->parent_stream, offset, - CAMEL_STREAM_END, - ex); - if (camel_exception_is_set (ex)) + CAMEL_STREAM_END); + if (real_offset == -1) return -1; break; } diff --git a/camel/camel-simple-data-wrapper.c b/camel/camel-simple-data-wrapper.c index cc6bbc6771..f091211e3c 100644 --- a/camel/camel-simple-data-wrapper.c +++ b/camel/camel-simple-data-wrapper.c @@ -37,7 +37,7 @@ static CamelDataWrapperClass *parent_class = NULL; static int construct_from_stream (CamelDataWrapper *, CamelStream *); static int write_to_stream (CamelDataWrapper *data_wrapper, - CamelStream *stream, CamelException *ex); + CamelStream *stream); static void finalize (GtkObject *object); @@ -116,6 +116,9 @@ construct_from_stream (CamelDataWrapper *wrapper, CamelStream *stream) CamelSimpleDataWrapper *simple_data_wrapper = CAMEL_SIMPLE_DATA_WRAPPER (wrapper); + if (simple_data_wrapper->content) + gtk_object_unref((GtkObject *)simple_data_wrapper->content); + simple_data_wrapper->content = stream; gtk_object_ref (GTK_OBJECT (stream)); return 0; @@ -123,15 +126,16 @@ construct_from_stream (CamelDataWrapper *wrapper, CamelStream *stream) static int -write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, - CamelException *ex) +write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream) { CamelSimpleDataWrapper *simple_data_wrapper = CAMEL_SIMPLE_DATA_WRAPPER (data_wrapper); - camel_stream_reset (simple_data_wrapper->content, ex); - if (camel_exception_is_set (ex)) + if (simple_data_wrapper->content == NULL) return -1; - return camel_stream_write_to_stream (simple_data_wrapper->content, - stream, ex); + + if (camel_stream_reset (simple_data_wrapper->content) == -1) + return -1; + + return camel_stream_write_to_stream (simple_data_wrapper->content, stream); } diff --git a/camel/camel-stream-buffer.c b/camel/camel-stream-buffer.c index 8475cab2c0..68dcc7ad21 100644 --- a/camel/camel-stream-buffer.c +++ b/camel/camel-stream-buffer.c @@ -1,4 +1,4 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; fill-column: 160 -*- */ /* camel-stream-buffer.c : Buffer any other other stream * @@ -25,7 +25,6 @@ #include <config.h> #include "camel-stream-buffer.h" -#include "camel-exception.h" #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> @@ -39,11 +38,10 @@ enum { #define BUF_SIZE 1024 -static int stream_read (CamelStream *stream, char *buffer, - unsigned int n, CamelException *ex); -static int stream_write (CamelStream *stream, const char *buffer, - unsigned int n, CamelException *ex); -static void stream_flush (CamelStream *stream, CamelException *ex); +static int stream_read (CamelStream *stream, char *buffer, unsigned int n); +static int stream_write (CamelStream *stream, const char *buffer, unsigned int n); +static int stream_flush (CamelStream *stream); +static int stream_close (CamelStream *stream); static gboolean stream_eos (CamelStream *stream); static void finalize (GtkObject *object); @@ -68,6 +66,7 @@ camel_stream_buffer_class_init (CamelStreamBufferClass *camel_stream_buffer_clas camel_stream_class->read = stream_read; camel_stream_class->write = stream_write; camel_stream_class->flush = stream_flush; + camel_stream_class->close = stream_close; camel_stream_class->eos = stream_eos; gtk_object_class->finalize = finalize; @@ -87,6 +86,8 @@ camel_stream_buffer_init (gpointer object, gpointer klass) sbf->end = sbf->buf; sbf->mode = CAMEL_STREAM_BUFFER_READ | CAMEL_STREAM_BUFFER_BUFFER; sbf->stream = 0; + sbf->linesize = 80; + sbf->linebuf = g_malloc(sbf->linesize); } GtkType @@ -138,6 +139,8 @@ finalize (GtkObject *object) if (sbf->stream) gtk_object_unref(GTK_OBJECT(sbf->stream)); + g_free(sbf->linebuf); + GTK_OBJECT_CLASS (parent_class)->finalize (object); } @@ -244,8 +247,7 @@ CamelStream *camel_stream_buffer_new_with_vbuf (CamelStream *stream, CamelStream } static int -stream_read (CamelStream *stream, char *buffer, unsigned int n, - CamelException *ex) +stream_read (CamelStream *stream, char *buffer, unsigned int n) { CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (stream); int bytes_read = 1; @@ -265,13 +267,13 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n, } /* if we are reading a lot, then read directly to the destination buffer */ if (n >= sbf->size/3) { - bytes_read = camel_stream_read(sbf->stream, bptr, n, ex); + bytes_read = camel_stream_read(sbf->stream, bptr, n); if (bytes_read>0) { n -= bytes_read; bptr += bytes_read; } } else { - bytes_read = camel_stream_read(sbf->stream, sbf->buf, sbf->size, ex); + bytes_read = camel_stream_read(sbf->stream, sbf->buf, sbf->size); if (bytes_read>0) { sbf->ptr = sbf->buf; sbf->end = sbf->buf+bytes_read; @@ -281,8 +283,6 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n, n -= bytes_read; } } - if (camel_exception_is_set (ex)) - return -1; } else { memcpy(bptr, sbf->ptr, bytes_left); sbf->ptr += n; @@ -294,15 +294,14 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n, return bptr-buffer; } - static int -stream_write (CamelStream *stream, const char *buffer, - unsigned int n, CamelException *ex) +stream_write (CamelStream *stream, const char *buffer, unsigned int n) { CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (stream); const char *bptr = buffer; int bytes_written = 1; int bytes_left; + int total = n; g_return_val_if_fail( (sbf->mode & CAMEL_STREAM_BUFFER_MODE) == CAMEL_STREAM_BUFFER_WRITE, 0); @@ -312,22 +311,22 @@ stream_write (CamelStream *stream, const char *buffer, memcpy(sbf->ptr, bptr, bytes_left); n -= bytes_left; bptr += bytes_left; - bytes_written = camel_stream_write(sbf->stream, sbf->buf, sbf->size, ex); + bytes_written = camel_stream_write(sbf->stream, sbf->buf, sbf->size); sbf->ptr = sbf->buf; /* if we are writing a lot, write directly to the stream */ if (n >= sbf->size/3) { - bytes_written = camel_stream_write(sbf->stream, bptr, n, ex); - bytes_written = n; - n -= bytes_written; - bptr += bytes_written; + bytes_written = camel_stream_write(sbf->stream, bptr, n); + if (bytes_written >0) { + bytes_written = n; + n -= bytes_written; + bptr += bytes_written; + } } else { memcpy(sbf->ptr, bptr, n); sbf->ptr += n; bptr += n; n = 0; } - if (camel_exception_is_set (ex)) - return -1; } else { memcpy(sbf->ptr, bptr, n); sbf->ptr += n; @@ -335,27 +334,38 @@ stream_write (CamelStream *stream, const char *buffer, n = 0; } } - return 0; + if (bytes_written == -1) + return -1; + return total; } - - -static void -stream_flush (CamelStream *stream, CamelException *ex) +static int +stream_flush (CamelStream *stream) { CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (stream); if ((sbf->mode & CAMEL_STREAM_BUFFER_MODE) == CAMEL_STREAM_BUFFER_WRITE) { - int written = camel_stream_write(sbf->stream, sbf->buf, sbf->ptr-sbf->buf, ex); - if (written > 0) { + int len = sbf->ptr-sbf->buf; + int written = camel_stream_write(sbf->stream, sbf->buf, len); + if (written > 0) sbf->ptr += written; - } + if (written != len) + return -1; } else { /* nothing to do for read mode 'flush' */ } - if (!camel_exception_is_set (ex)) - camel_stream_flush(sbf->stream, ex); + return camel_stream_flush(sbf->stream); +} + +static int +stream_close (CamelStream *stream) +{ + CamelStreamBuffer *sbf = CAMEL_STREAM_BUFFER (stream); + + if (stream_flush(stream) == -1) + return -1; + return camel_stream_close(sbf->stream); } static gboolean @@ -371,7 +381,6 @@ stream_eos (CamelStream *stream) * @sbf: A CamelStreamBuffer. * @buf: Memory to write the string to. * @max: Maxmimum number of characters to store. - * @ex: a CamelException * * Read a line of characters up to the next newline character or * @max characters. @@ -379,11 +388,10 @@ stream_eos (CamelStream *stream) * If the newline character is encountered, then it will be * included in the buffer @buf. The buffer will be #NUL terminated. * - * Return value: The number of characters read, or 0 for end of file. - * If an error occurs, @ex will be set. + * Return value: The number of characters read, or 0 for end of file, + * and -1 on error. **/ -int camel_stream_buffer_gets(CamelStreamBuffer *sbf, char *buf, - unsigned int max, CamelException *ex) +int camel_stream_buffer_gets(CamelStreamBuffer *sbf, char *buf, unsigned int max) { register char *outptr, *inptr, *inend, c, *outend; int bytes_read; @@ -406,13 +414,12 @@ int camel_stream_buffer_gets(CamelStreamBuffer *sbf, char *buf, if (outptr == outend) break; - bytes_read = camel_stream_read(sbf->stream, sbf->buf, - sbf->size, ex); - if (bytes_read>0) { - inptr = sbf->ptr = sbf->buf; - inend = sbf->end = sbf->buf + bytes_read; - } - } while (bytes_read>0 && !camel_exception_is_set (ex)); + bytes_read = camel_stream_read(sbf->stream, sbf->buf, sbf->size); + if (bytes_read == -1) + return -1; + inptr = sbf->ptr = sbf->buf; + inend = sbf->end = sbf->buf + bytes_read; + } while (bytes_read>0); sbf->ptr = inptr; if (outptr<=outend) @@ -424,7 +431,6 @@ int camel_stream_buffer_gets(CamelStreamBuffer *sbf, char *buf, /** * camel_stream_buffer_read_line: read a complete line from the stream * @sbf: A CamelStreamBuffer - * @ex: a CamelException * * This function reads a complete newline-terminated line from the stream * and returns it in allocated memory. The trailing newline (and carriage @@ -434,34 +440,36 @@ int camel_stream_buffer_gets(CamelStreamBuffer *sbf, char *buf, * or NULL on eof. If an error occurs, @ex will be set. **/ char * -camel_stream_buffer_read_line (CamelStreamBuffer *sbf, CamelException *ex) +camel_stream_buffer_read_line (CamelStreamBuffer *sbf) { - char *buf, *p; - int bufsiz, nread; + unsigned char *p; + int nread; - bufsiz = 80; - p = buf = g_malloc (bufsiz); + p = sbf->linebuf; while (1) { - nread = camel_stream_buffer_gets (sbf, p, - bufsiz - (p - buf), ex); - if (nread == 0 || camel_exception_is_set (ex)) { - g_free (buf); + nread = camel_stream_buffer_gets (sbf, p, sbf->linesize - (p - sbf->linebuf)); + if (nread <=0) { + if (p > sbf->linebuf) + break; return NULL; } p += nread; - if (*(p - 1) == '\n') + if (p[-1] == '\n') break; - nread = p - buf; - bufsiz *= 2; - buf = g_realloc (buf, bufsiz); - p = buf + nread; + nread = p - sbf->linebuf; + sbf->linesize *= 2; + sbf->linebuf = g_realloc (sbf->linebuf, sbf->linesize); + p = sbf->linebuf + nread; } - *--p = '\0'; - if (*(p - 1) == '\r') - *--p = '\0'; - return buf; + p--; + if (p[-1] == '\r') + p--; + p[0] = 0; + + return g_strdup(sbf->linebuf); } + diff --git a/camel/camel-stream-buffer.h b/camel/camel-stream-buffer.h index 33132e39a4..367735e4e1 100644 --- a/camel/camel-stream-buffer.h +++ b/camel/camel-stream-buffer.h @@ -62,6 +62,9 @@ struct _CamelStreamBuffer unsigned char *buf, *ptr, *end; int size; + unsigned char *linebuf; /* for reading lines at a time */ + int linesize; + CamelStreamBufferMode mode; unsigned int flags; /* internal flags */ }; @@ -95,11 +98,9 @@ CamelStream *camel_stream_buffer_new_with_vbuf (CamelStream *s, CamelStream *camel_stream_buffer_set_vbuf (CamelStreamBuffer *b, CamelStreamBufferMode mode, char *buf, guint32 size); */ /* read a line of characters */ -int camel_stream_buffer_gets (CamelStreamBuffer *b, char *buf, - unsigned int max, CamelException *ex); +int camel_stream_buffer_gets (CamelStreamBuffer *b, char *buf, unsigned int max); -char *camel_stream_buffer_read_line (CamelStreamBuffer *sbf, - CamelException *ex); +char *camel_stream_buffer_read_line (CamelStreamBuffer *sbf); #ifdef __cplusplus } diff --git a/camel/camel-stream-filter.c b/camel/camel-stream-filter.c index 389390caaf..3aaa1a20ed 100644 --- a/camel/camel-stream-filter.c +++ b/camel/camel-stream-filter.c @@ -1,3 +1,4 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; fill-column: 160 -*- */ /* * Copyright (C) 2000 Helix Code Inc. * @@ -19,7 +20,6 @@ */ #include "camel-stream-filter.h" -#include "camel-exception.h" struct _filter { struct _filter *next; @@ -48,13 +48,12 @@ 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, CamelException *ex); -static int do_write (CamelStream *stream, const char *buffer, - unsigned int n, CamelException *ex); -static void do_flush (CamelStream *stream, CamelException *ex); +static int do_read (CamelStream *stream, char *buffer, unsigned int n); +static int do_write (CamelStream *stream, const char *buffer, unsigned int n); +static int do_flush (CamelStream *stream); +static int do_close (CamelStream *stream); static gboolean do_eos (CamelStream *stream); -static void do_reset (CamelStream *stream, CamelException *ex); +static int do_reset (CamelStream *stream); static CamelStreamClass *camel_stream_filter_parent; @@ -121,6 +120,7 @@ camel_stream_filter_class_init (CamelStreamFilterClass *klass) camel_stream_class->read = do_read; camel_stream_class->write = do_write; camel_stream_class->flush = do_flush; + camel_stream_class->flush = do_close; camel_stream_class->eos = do_eos; camel_stream_class->reset = do_reset; @@ -216,7 +216,7 @@ camel_stream_filter_remove(CamelStreamFilter *filter, int id) } static int -do_read (CamelStream *stream, char *buffer, unsigned int n, CamelException *ex) +do_read (CamelStream *stream, char *buffer, unsigned int n) { CamelStreamFilter *filter = (CamelStreamFilter *)stream; struct _CamelStreamFilterPrivate *p = _PRIVATE(filter); @@ -228,7 +228,7 @@ do_read (CamelStream *stream, char *buffer, unsigned int n, CamelException *ex) if (p->filteredlen<=0) { int presize = READ_SIZE; - size = camel_stream_read(filter->source, p->buffer, READ_SIZE, ex); + size = camel_stream_read(filter->source, p->buffer, READ_SIZE); if (size<=0) { /* this is somewhat untested */ if (camel_stream_eos(filter->source)) { @@ -263,7 +263,7 @@ do_read (CamelStream *stream, char *buffer, unsigned int n, CamelException *ex) } static int -do_write (CamelStream *stream, const char *buf, unsigned int n, CamelException *ex) +do_write (CamelStream *stream, const char *buf, unsigned int n) { CamelStreamFilter *filter = (CamelStreamFilter *)stream; struct _CamelStreamFilterPrivate *p = _PRIVATE(filter); @@ -280,11 +280,11 @@ do_write (CamelStream *stream, const char *buf, unsigned int n, CamelException * f = f->next; } - return camel_stream_write(filter->source, buffer, n, ex); + return camel_stream_write(filter->source, buffer, n); } -static void -do_flush (CamelStream *stream, CamelException *ex) +static int +do_flush (CamelStream *stream) { CamelStreamFilter *filter = (CamelStreamFilter *)stream; struct _CamelStreamFilterPrivate *p = _PRIVATE(filter); @@ -294,7 +294,7 @@ do_flush (CamelStream *stream, CamelException *ex) if (p->last_was_read) { g_warning("Flushing a filter stream without writing to it"); - return; + return 0; } buffer = ""; @@ -305,9 +305,21 @@ do_flush (CamelStream *stream, CamelException *ex) camel_mime_filter_complete(f->filter, buffer, len, presize, &buffer, &len, &presize); f = f->next; } - camel_stream_write(filter->source, buffer, len, ex); - if (!camel_exception_is_set(ex)) - camel_stream_flush(filter->source, ex); + if (len>0 && camel_stream_write(filter->source, buffer, len) == -1) + return -1; + return camel_stream_flush(filter->source); +} + +static int +do_close (CamelStream *stream) +{ + CamelStreamFilter *filter = (CamelStreamFilter *)stream; + struct _CamelStreamFilterPrivate *p = _PRIVATE(filter); + + if (!p->last_was_read) { + do_flush(stream); + } + return camel_stream_close(filter->source); } static gboolean @@ -322,15 +334,14 @@ do_eos (CamelStream *stream) return camel_stream_eos(filter->source); } -static void -do_reset (CamelStream *stream, CamelException *ex) +static int +do_reset (CamelStream *stream) { CamelStreamFilter *filter = (CamelStreamFilter *)stream; struct _CamelStreamFilterPrivate *p = _PRIVATE(filter); struct _filter *f; p->filteredlen = 0; - camel_stream_reset(filter->source, ex); /* and reset filters */ f = p->filters; @@ -338,5 +349,7 @@ do_reset (CamelStream *stream, CamelException *ex) camel_mime_filter_reset(f->filter); f = f->next; } + + return camel_stream_reset(filter->source); } diff --git a/camel/camel-stream-fs.c b/camel/camel-stream-fs.c index 3f53b5907a..4b5a6015a4 100644 --- a/camel/camel-stream-fs.c +++ b/camel/camel-stream-fs.c @@ -1,4 +1,4 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; fill-column: 160 -*- */ /* camel-stream-fs.c : file system based stream */ /* @@ -25,7 +25,6 @@ #include <config.h> #include "camel-stream-fs.h" -#include "camel-exception.h" #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> @@ -38,15 +37,12 @@ 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, - CamelException *ex); -static int stream_write (CamelStream *stream, const char *buffer, - unsigned int n, CamelException *ex); -static void stream_flush (CamelStream *stream, CamelException *ex); +static int stream_read (CamelStream *stream, char *buffer, unsigned int n); +static int stream_write (CamelStream *stream, const char *buffer, unsigned int n); +static int stream_flush (CamelStream *stream); +static int stream_close (CamelStream *stream); static off_t stream_seek (CamelSeekableStream *stream, off_t offset, - CamelStreamSeekPolicy policy, - CamelException *ex); - + CamelStreamSeekPolicy policy); static void finalize (GtkObject *object); static void @@ -65,6 +61,7 @@ camel_stream_fs_class_init (CamelStreamFsClass *camel_stream_fs_class) camel_stream_class->read = stream_read; camel_stream_class->write = stream_write; camel_stream_class->flush = stream_flush; + camel_stream_class->close = stream_close; camel_seekable_stream_class->seek = stream_seek; @@ -151,14 +148,12 @@ camel_stream_fs_new_with_fd (int fd) * Return value: the stream **/ CamelStream * -camel_stream_fs_new_with_fd_and_bounds (int fd, off_t start, off_t end, - CamelException *ex) +camel_stream_fs_new_with_fd_and_bounds (int fd, off_t start, off_t end) { CamelStream *stream; stream = camel_stream_fs_new_with_fd (fd); - camel_seekable_stream_set_bounds (CAMEL_SEEKABLE_STREAM (stream), - start, end, ex); + camel_seekable_stream_set_bounds (CAMEL_SEEKABLE_STREAM (stream), start, end); return stream; } @@ -168,31 +163,23 @@ camel_stream_fs_new_with_fd_and_bounds (int fd, off_t start, off_t end, * @name: a local filename * @flags: flags as in open(2) * @mode: a file mode - * @ex: a CamelException. * * Creates a new CamelStream corresponding to the named file, flags, - * and mode. If an error occurs, @ex will be set. + * and mode. * - * Return value: the stream + * Return value: the stream, or #NULL on error. **/ CamelStream * -camel_stream_fs_new_with_name (const char *name, int flags, mode_t mode, - CamelException *ex) +camel_stream_fs_new_with_name (const char *name, int flags, mode_t mode) { - CamelStream *stream; int fd; fd = open (name, flags, mode); if (fd == -1) { - camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, - "Could not open file %s: %s.", - name, g_strerror (errno)); return NULL; } - stream = camel_stream_fs_new_with_fd (fd); - - return stream; + return camel_stream_fs_new_with_fd (fd); } /** @@ -202,38 +189,30 @@ camel_stream_fs_new_with_name (const char *name, int flags, mode_t mode, * @mode: a file mode * @start: the first valid position in the file * @end: the first invalid position in the file, or CAMEL_STREAM_UNBOUND - * @ex: a CamelException. * - * Creates a new CamelStream corresponding to the given arguments. If - * an error occurs, @ex will be set. + * Creates a new CamelStream corresponding to the given arguments. * - * Return value: the stream + * Return value: the stream, or NULL on error. **/ CamelStream * camel_stream_fs_new_with_name_and_bounds (const char *name, int flags, - mode_t mode, off_t start, off_t end, - CamelException *ex) + mode_t mode, off_t start, off_t end) { CamelStream *stream; - stream = camel_stream_fs_new_with_name (name, flags, mode, ex); - if (camel_exception_is_set (ex)) + stream = camel_stream_fs_new_with_name (name, flags, mode); + if (stream == NULL) return NULL; camel_seekable_stream_set_bounds (CAMEL_SEEKABLE_STREAM (stream), - start, end, ex); - if (camel_exception_is_set (ex)) { - gtk_object_unref (GTK_OBJECT (stream)); - return NULL; - } + start, end); return stream; } static int -stream_read (CamelStream *stream, char *buffer, unsigned int n, - CamelException *ex) +stream_read (CamelStream *stream, char *buffer, unsigned int n) { CamelStreamFs *stream_fs = CAMEL_STREAM_FS (stream); CamelSeekableStream *seekable = CAMEL_SEEKABLE_STREAM (stream); @@ -250,18 +229,12 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n, seekable->position += nread; else if (nread == 0) stream->eos = TRUE; - else { - camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, - "Could not read from stream: %s", - g_strerror (errno)); - } return nread; } static int -stream_write (CamelStream *stream, const char *buffer, unsigned int n, - CamelException *ex) +stream_write (CamelStream *stream, const char *buffer, unsigned int n) { CamelStreamFs *stream_fs = CAMEL_STREAM_FS (stream); CamelSeekableStream *seekable = CAMEL_SEEKABLE_STREAM (stream); @@ -278,33 +251,31 @@ stream_write (CamelStream *stream, const char *buffer, unsigned int n, if (written > 0) seekable->position += written; - else if (v == -1) { - camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, - "Could not write to stream: %s", - g_strerror (errno)); - } + else if (v == -1) + return -1; return written; } -static void -stream_flush (CamelStream *stream, CamelException *ex) +static int +stream_flush (CamelStream *stream) { - if (fsync (CAMEL_STREAM_FS (stream)->fd) == -1) { - camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, - "Could not flush stream data: %s", - g_strerror (errno)); - } + return fsync(((CamelStreamFs *)stream)->fd); +} + +static int +stream_close (CamelStream *stream) +{ + return close(((CamelStreamFs *)stream)->fd); } static off_t -stream_seek (CamelSeekableStream *stream, off_t offset, - CamelStreamSeekPolicy policy, CamelException *ex) +stream_seek (CamelSeekableStream *stream, off_t offset, CamelStreamSeekPolicy policy) { CamelStreamFs *stream_fs = CAMEL_STREAM_FS (stream); off_t real = 0; - switch (policy) { + switch (policy) { case CAMEL_STREAM_SET: real = offset; break; @@ -316,12 +287,6 @@ stream_seek (CamelSeekableStream *stream, off_t offset, real = lseek(stream_fs->fd, offset, SEEK_END); if (real != -1) stream->position = real; - else { - camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, - "Could not seek to " - "given offset: %s", - g_strerror (errno)); - } return real; } real = stream->bound_end + offset; @@ -333,12 +298,8 @@ stream_seek (CamelSeekableStream *stream, off_t offset, real = MAX (real, stream->bound_start); real = lseek(stream_fs->fd, real, SEEK_SET); - if (real == -1) { - camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, - "Could not seek to given offset: %s", - g_strerror (errno)); + if (real == -1) return -1; - } if (real != stream->position && ((CamelStream *)stream)->eos) ((CamelStream *)stream)->eos = FALSE; diff --git a/camel/camel-stream-fs.h b/camel/camel-stream-fs.h index 1c40855143..08ae49bddf 100644 --- a/camel/camel-stream-fs.h +++ b/camel/camel-stream-fs.h @@ -60,22 +60,13 @@ typedef struct { /* Standard Gtk function */ GtkType camel_stream_fs_get_type (void); - /* public methods */ -CamelStream * camel_stream_fs_new_with_name (const char *name, - int flags, - mode_t mode, - CamelException *ex); -CamelStream * camel_stream_fs_new_with_name_and_bounds (const char *name, - int flags, mode_t mode, - off_t start, - off_t end, - CamelException *ex); +CamelStream * camel_stream_fs_new_with_name (const char *name, int flags, mode_t mode); +CamelStream * camel_stream_fs_new_with_name_and_bounds (const char *name, int flags, mode_t mode, + off_t start, off_t end); CamelStream * camel_stream_fs_new_with_fd (int fd); -CamelStream * camel_stream_fs_new_with_fd_and_bounds (int fd, off_t start, - off_t end, - CamelException *ex); +CamelStream * camel_stream_fs_new_with_fd_and_bounds (int fd, off_t start, off_t end); #ifdef __cplusplus } diff --git a/camel/camel-stream-mem.c b/camel/camel-stream-mem.c index 2c6357b12b..ca384485b6 100644 --- a/camel/camel-stream-mem.c +++ b/camel/camel-stream-mem.c @@ -35,14 +35,11 @@ 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, - CamelException *ex); -static int stream_write (CamelStream *stream, const char *buffer, - unsigned int n, CamelException *ex); +static int stream_read (CamelStream *stream, char *buffer, unsigned int n); +static int stream_write (CamelStream *stream, const char *buffer, unsigned int n); static gboolean stream_eos (CamelStream *stream); static off_t stream_seek (CamelSeekableStream *stream, off_t offset, - CamelStreamSeekPolicy policy, - CamelException *ex); + CamelStreamSeekPolicy policy); static void finalize (GtkObject *object); @@ -161,8 +158,7 @@ finalize (GtkObject *object) } static int -stream_read (CamelStream *stream, char *buffer, unsigned int n, - CamelException *ex) +stream_read (CamelStream *stream, char *buffer, unsigned int n) { CamelStreamMem *camel_stream_mem = CAMEL_STREAM_MEM (stream); CamelSeekableStream *seekable = CAMEL_SEEKABLE_STREAM (stream); @@ -182,8 +178,7 @@ stream_read (CamelStream *stream, char *buffer, unsigned int n, } static int -stream_write (CamelStream *stream, const char *buffer, unsigned int n, - CamelException *ex) +stream_write (CamelStream *stream, const char *buffer, unsigned int n) { CamelStreamMem *stream_mem = CAMEL_STREAM_MEM (stream); CamelSeekableStream *seekable = CAMEL_SEEKABLE_STREAM (stream); @@ -194,13 +189,11 @@ stream_write (CamelStream *stream, const char *buffer, unsigned int 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, n); } else { g_byte_array_set_size (stream_mem->buffer, n+stream_mem->buffer->len); - memcpy (stream_mem->buffer->data + seekable->position, - buffer, n); + memcpy (stream_mem->buffer->data + seekable->position, buffer, n); } seekable->position += n; @@ -218,7 +211,7 @@ stream_eos (CamelStream *stream) static off_t stream_seek (CamelSeekableStream *stream, off_t offset, - CamelStreamSeekPolicy policy, CamelException *ex) + CamelStreamSeekPolicy policy) { off_t position; CamelStreamMem *stream_mem = CAMEL_STREAM_MEM (stream); diff --git a/camel/camel-stream-mem.h b/camel/camel-stream-mem.h index 21f9a62e29..e508644e6b 100644 --- a/camel/camel-stream-mem.h +++ b/camel/camel-stream-mem.h @@ -65,8 +65,7 @@ CamelStream *camel_stream_mem_new_with_buffer (const char *buffer, size_t len); /* these are really only here for implementing classes */ void camel_stream_mem_set_byte_array (CamelStreamMem *, GByteArray *buffer); -void camel_stream_mem_set_buffer (CamelStreamMem *, const char *buffer, - size_t len); +void camel_stream_mem_set_buffer (CamelStreamMem *, const char *buffer, size_t len); #ifdef __cplusplus } diff --git a/camel/camel-stream.c b/camel/camel-stream.c index 07578a7848..244b6cf9d8 100644 --- a/camel/camel-stream.c +++ b/camel/camel-stream.c @@ -1,4 +1,4 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; fill-column: 160 -*- */ /* camel-stream.c : abstract class for a stream */ /* @@ -31,7 +31,8 @@ static CamelObjectClass *parent_class = NULL; /* Returns the class for a CamelStream */ #define CS_CLASS(so) CAMEL_STREAM_CLASS (GTK_OBJECT(so)->klass) -static void stream_flush (CamelStream *stream, CamelException *ex); +static int stream_flush (CamelStream *stream); +static int stream_close (CamelStream *stream); static gboolean stream_eos (CamelStream *stream); @@ -42,6 +43,7 @@ camel_stream_class_init (CamelStreamClass *camel_stream_class) /* virtual method definition */ camel_stream_class->flush = stream_flush; + camel_stream_class->close = stream_close; camel_stream_class->eos = stream_eos; } @@ -75,22 +77,20 @@ camel_stream_get_type (void) * @stream: a CamelStream. * @buffer: buffer where bytes pulled from the stream are stored. * @n: max number of bytes to read. - * @ex: a CamelException * * Read at most @n bytes from the @stream object and stores them * in the buffer pointed at by @buffer. * - * Return value: number of bytes actually read. If an error occurs, - * @ex will contain a description of the error. + * Return value: number of bytes actually read, or -1 on error and + * set errno. **/ int -camel_stream_read (CamelStream *stream, char *buffer, unsigned int n, - CamelException *ex) +camel_stream_read (CamelStream *stream, char *buffer, unsigned int n) { g_return_val_if_fail (CAMEL_IS_STREAM (stream), -1); g_return_val_if_fail (n == 0 || buffer, -1); - return CS_CLASS (stream)->read (stream, buffer, n, ex); + return CS_CLASS (stream)->read (stream, buffer, n); } /** @@ -98,44 +98,68 @@ camel_stream_read (CamelStream *stream, char *buffer, unsigned int n, * @stream: a CamelStream object. * @buffer: buffer to write. * @n: number of bytes to write - * @ex: a CamelException * * Write @n bytes from the buffer pointed at by @buffer into @stream. * - * Return value: the number of bytes actually written to the stream. If - * an error occurs, @ex will contain a description of the error. + * Return value: the number of bytes actually written to the stream, + * or -1 on error. **/ int -camel_stream_write (CamelStream *stream, const char *buffer, unsigned int n, - CamelException *ex) +camel_stream_write (CamelStream *stream, const char *buffer, unsigned int n) { g_return_val_if_fail (CAMEL_IS_STREAM (stream), -1); g_return_val_if_fail (n == 0 || buffer, -1); - return CS_CLASS (stream)->write (stream, buffer, n, ex); + return CS_CLASS (stream)->write (stream, buffer, n); } -static void -stream_flush (CamelStream *stream, CamelException *ex) +static int +stream_flush (CamelStream *stream) { /* nothing */ + return 0; } /** * camel_stream_flush: * @stream: a CamelStream object - * @ex: a CamelException * * Flushes the contents of the stream to its backing store. Only meaningful - * on writable streams. If an error occurs, @ex will be set. + * on writable streams. + * + * Return value: -1 on error. + **/ +int +camel_stream_flush (CamelStream *stream) +{ + g_return_val_if_fail (CAMEL_IS_STREAM (stream), -1); + + return CS_CLASS (stream)->flush (stream); +} + + +static int +stream_close (CamelStream *stream) +{ + /* nothing */ + return 0; +} + +/** + * camel_stream_close: + * @stream: + * + * Close a stream. + * + * Return value: -1 on error. **/ -void -camel_stream_flush (CamelStream *stream, CamelException *ex) +int +camel_stream_close (CamelStream *stream) { - g_return_if_fail (CAMEL_IS_STREAM (stream)); + g_return_val_if_fail (CAMEL_IS_STREAM (stream), -1); - CS_CLASS (stream)->flush (stream, ex); + return CS_CLASS (stream)->close (stream); } @@ -166,18 +190,19 @@ camel_stream_eos (CamelStream *stream) /** * camel_stream_reset: reset a stream * @stream: the stream object - * @ex: a CamelException * * Reset a stream. That is, put it in a state where it can be read * from the beginning again. Not all streams in Camel are seekable, * but they must all be resettable. + * + * Return value: -1 on error. **/ -void -camel_stream_reset (CamelStream *stream, CamelException *ex) +int +camel_stream_reset (CamelStream *stream) { - g_return_if_fail (CAMEL_IS_STREAM (stream)); + g_return_val_if_fail (CAMEL_IS_STREAM (stream), -1); - CS_CLASS (stream)->reset (stream, ex); + return CS_CLASS (stream)->reset (stream); } /***************** Utility functions ********************/ @@ -186,33 +211,28 @@ camel_stream_reset (CamelStream *stream, CamelException *ex) * camel_stream_write_string: * @stream: a stream object * @string: a string - * @ex: a CamelException * * Writes the string to the stream. * - * Return value: the number of characters output. + * Return value: the number of characters output, -1 on error. **/ int -camel_stream_write_string (CamelStream *stream, const char *string, - CamelException *ex) +camel_stream_write_string (CamelStream *stream, const char *string) { - return camel_stream_write (stream, string, strlen (string), ex); + return camel_stream_write (stream, string, strlen (string)); } /** * camel_stream_printf: * @stream: a stream object - * @ex: a CamelException * @fmt: a printf-style format string * - * This printfs the given data to @stream. If an error occurs, @ex - * will be set. + * This printfs the given data to @stream. * - * Return value: the number of characters output. + * Return value: the number of characters output, -1 on error. **/ int -camel_stream_printf (CamelStream *stream, CamelException *ex, - const char *fmt, ... ) +camel_stream_printf (CamelStream *stream, const char *fmt, ... ) { va_list args; char *string; @@ -227,7 +247,7 @@ camel_stream_printf (CamelStream *stream, CamelException *ex, if (!string) return -1; - ret = camel_stream_write (stream, string, strlen (string), ex); + ret = camel_stream_write (stream, string, strlen (string)); g_free (string); return ret; } @@ -236,7 +256,6 @@ camel_stream_printf (CamelStream *stream, CamelException *ex, * camel_stream_write_to_stream: * @stream: Source CamelStream. * @output_stream: Destination CamelStream. - * @ex: a CamelException. * * Write all of a stream (until eos) into another stream, in a blocking * fashion. @@ -245,8 +264,7 @@ camel_stream_printf (CamelStream *stream, CamelException *ex, * copied across streams. **/ int -camel_stream_write_to_stream (CamelStream *stream, CamelStream *output_stream, - CamelException *ex) +camel_stream_write_to_stream (CamelStream *stream, CamelStream *output_stream) { char tmp_buf[4096]; int total = 0; @@ -257,15 +275,14 @@ camel_stream_write_to_stream (CamelStream *stream, CamelStream *output_stream, g_return_val_if_fail (CAMEL_IS_STREAM (output_stream), -1); while (!camel_stream_eos (stream)) { - nb_read = camel_stream_read (stream, tmp_buf, - sizeof (tmp_buf), ex); + nb_read = camel_stream_read (stream, tmp_buf, sizeof (tmp_buf)); if (nb_read < 0) return -1; else if (nb_read > 0) { nb_written = 0; while (nb_written < nb_read) { - int len = camel_stream_write (output_stream, tmp_buf + nb_written, nb_read - nb_written, ex); + int len = camel_stream_write (output_stream, tmp_buf + nb_written, nb_read - nb_written); if (len < 0) return -1; nb_written += len; diff --git a/camel/camel-stream.h b/camel/camel-stream.h index c1a044e68f..44562b3321 100644 --- a/camel/camel-stream.h +++ b/camel/camel-stream.h @@ -1,4 +1,4 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; fill-column: 160 -*- */ /* camel-stream.h : class for an abstract stream */ /* @@ -53,13 +53,12 @@ typedef struct { /* Virtual methods */ - int (*read) (CamelStream *stream, char *buffer, - unsigned int n, CamelException *ex); - int (*write) (CamelStream *stream, const char *buffer, - unsigned int n, CamelException *ex); - void (*flush) (CamelStream *stream, CamelException *ex); + int (*read) (CamelStream *stream, char *buffer, unsigned int n); + int (*write) (CamelStream *stream, const char *buffer, unsigned int n); + int (*close) (CamelStream *stream); + int (*flush) (CamelStream *stream); gboolean (*eos) (CamelStream *stream); - void (*reset) (CamelStream *stream, CamelException *ex); + int (*reset) (CamelStream *stream); } CamelStreamClass; @@ -67,28 +66,22 @@ typedef struct { GtkType camel_stream_get_type (void); /* public methods */ -int camel_stream_read (CamelStream *stream, char *buffer, - unsigned int n, CamelException *ex); -int camel_stream_write (CamelStream *stream, const char *buffer, - unsigned int n, CamelException *ex); -void camel_stream_flush (CamelStream *stream, CamelException *ex); +int camel_stream_read (CamelStream *stream, char *buffer, unsigned int n); +int camel_stream_write (CamelStream *stream, const char *buffer, unsigned int n); +int camel_stream_flush (CamelStream *stream); +int camel_stream_close (CamelStream *stream); gboolean camel_stream_eos (CamelStream *stream); -void camel_stream_reset (CamelStream *stream, CamelException *ex); +int camel_stream_reset (CamelStream *stream); /* utility macros and funcs */ -int camel_stream_write_string (CamelStream *stream, const char *string, - CamelException *ex); -int camel_stream_printf (CamelStream *stream, CamelException *ex, - const char *fmt, ... ) G_GNUC_PRINTF (3, 4); -int camel_stream_vprintf (CamelStream *stream, CamelException *ex, - const char *fmt, va_list ap); +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); /* 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, - CamelException *ex); +int camel_stream_write_to_stream (CamelStream *stream, CamelStream *output_stream); #ifdef __cplusplus } diff --git a/camel/camel.h b/camel/camel.h index ac314ac656..d3a65b1312 100644 --- a/camel/camel.h +++ b/camel/camel.h @@ -54,7 +54,6 @@ extern "C" { #include <camel/camel-seekable-substream.h> #include <camel/camel-service.h> #include <camel/camel-session.h> -#include <camel/camel-simple-data-wrapper.h> #include <camel/camel-store.h> #include <camel/camel-stream-buffer.h> #include <camel/camel-stream-filter.h> diff --git a/camel/gmime-content-field.c b/camel/gmime-content-field.c index ce61cf2a84..4d38314873 100644 --- a/camel/gmime-content-field.c +++ b/camel/gmime-content-field.c @@ -130,8 +130,7 @@ gmime_content_field_write_to_stream (GMimeContentField *content_field, CamelStre txt = header_content_type_format(content_field->content_type); if (txt) { - /* FIXME. Shouldn't pass NULL for CamelException. */ - camel_stream_printf (stream, NULL, "Content-Type: %s\n", txt); + camel_stream_printf (stream, "Content-Type: %s\n", txt); g_free(txt); } } diff --git a/camel/md5-utils.c b/camel/md5-utils.c index 382aadffec..7363eaec40 100644 --- a/camel/md5-utils.c +++ b/camel/md5-utils.c @@ -335,11 +335,10 @@ md5_get_digest_from_stream (CamelStream *stream, guchar digest[16]) md5_init (&ctx); - /* FIXME (the NULL) */ - nb_bytes_read = camel_stream_read (stream, tmp_buf, 1024, NULL); + nb_bytes_read = camel_stream_read (stream, tmp_buf, 1024); while (nb_bytes_read) { md5_update (&ctx, tmp_buf, nb_bytes_read); - nb_bytes_read = camel_stream_read (stream, tmp_buf, 1024, NULL); + nb_bytes_read = camel_stream_read (stream, tmp_buf, 1024); } md5_final (&ctx, digest); diff --git a/camel/providers/mbox/camel-mbox-folder.c b/camel/providers/mbox/camel-mbox-folder.c index 707fea1206..ccf57f02b7 100644 --- a/camel/providers/mbox/camel-mbox-folder.c +++ b/camel/providers/mbox/camel-mbox-folder.c @@ -602,11 +602,11 @@ mbox_append_message (CamelFolder *folder, CamelMimeMessage *message, CamelExcept if (stat(mbox_folder->folder_file_path, &st) != 0) goto fail; - output_stream = camel_stream_fs_new_with_name (mbox_folder->folder_file_path, O_RDWR, 0600, ex); + output_stream = camel_stream_fs_new_with_name (mbox_folder->folder_file_path, O_RDWR, 0600); if (output_stream == NULL) goto fail; - seek = camel_seekable_stream_seek((CamelSeekableStream *)output_stream, st.st_size, SEEK_SET, ex); + seek = camel_seekable_stream_seek((CamelSeekableStream *)output_stream, st.st_size, SEEK_SET); if (seek != st.st_size) goto fail; @@ -618,19 +618,17 @@ mbox_append_message (CamelFolder *folder, CamelMimeMessage *message, CamelExcept g_free(xev); /* we must write this to the non-filtered stream ... */ - if (camel_stream_write_string (output_stream, "From - \n", ex) == -1) + if (camel_stream_write_string (output_stream, "From - \n") == -1) goto fail; /* and write the content to the filtering stream, that translated '\nFrom' into '\n>From' */ filter_stream = (CamelStream *)camel_stream_filter_new_with_stream(output_stream); filter_from = (CamelMimeFilter *)camel_mime_filter_from_new(); camel_stream_filter_add((CamelStreamFilter *)filter_stream, filter_from); - camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (message), filter_stream, ex); -#warning "we still need stream_close() for this" - if (!camel_exception_is_set (ex)) - camel_stream_flush (filter_stream, ex); + if (camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (message), filter_stream) == -1) + goto fail; - if (camel_exception_is_set (ex)) + if (camel_stream_close (filter_stream) == -1) goto fail; /* filter stream ref's the output stream itself, so we need to unref it too */ @@ -659,6 +657,9 @@ fail: if (output_stream) gtk_object_unref ((GtkObject *)output_stream); + if (filter_from) + gtk_object_unref ((GtkObject *)filter_from); + /* make sure the file isn't munged by us */ if (seek != -1) { int fd = open(mbox_folder->folder_file_path, O_WRONLY, 0600); @@ -760,7 +761,7 @@ mbox_get_message_by_uid (CamelFolder *folder, const gchar *uid, CamelException * g_assert(info->frompos != -1); /* where we read from */ - message_stream = camel_stream_fs_new_with_name (mbox_folder->folder_file_path, O_RDONLY, 0, ex); + message_stream = camel_stream_fs_new_with_name (mbox_folder->folder_file_path, O_RDONLY, 0); if (message_stream == NULL) goto fail; @@ -800,15 +801,10 @@ mbox_get_message_by_uid (CamelFolder *folder, const gchar *uid, CamelException * return message; fail: - if (camel_exception_is_set (ex)) { - camel_exception_setv (ex, camel_exception_get_id (ex), - "Cannot get message: %s", - camel_exception_get_description (ex)); - } else { - camel_exception_setv (ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, - "Cannot get message: %s", - g_strerror(errno)); - } + camel_exception_setv (ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, + "Cannot get message: %s", + g_strerror(errno)); + if (parser) gtk_object_unref((GtkObject *)parser); if (message) diff --git a/camel/providers/pop3/camel-pop3-store.c b/camel/providers/pop3/camel-pop3-store.c index ddddf9f59f..bc39d4ab2b 100644 --- a/camel/providers/pop3/camel-pop3-store.c +++ b/camel/providers/pop3/camel-pop3-store.c @@ -33,6 +33,7 @@ #include <stdlib.h> #include <string.h> #include <unistd.h> +#include <errno.h> #include "camel-pop3-store.h" #include "camel-pop3-folder.h" @@ -376,7 +377,7 @@ pop3_connect (CamelService *service, CamelException *ex) CAMEL_STREAM_BUFFER_READ); /* Read the greeting, note APOP timestamp, if any. */ - buf = camel_stream_buffer_read_line (CAMEL_STREAM_BUFFER (store->istream), ex); + buf = camel_stream_buffer_read_line (CAMEL_STREAM_BUFFER (store->istream)); if (!buf) { camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE, "Could not read greeting from POP " @@ -513,28 +514,25 @@ camel_pop3_command (CamelPop3Store *store, char **ret, char *fmt, ...) char *cmdbuf, *respbuf; va_list ap; int status; - CamelException *ex = camel_exception_new (); va_start (ap, fmt); cmdbuf = g_strdup_vprintf (fmt, ap); va_end (ap); /* Send the command */ - camel_stream_printf (store->ostream, ex, "%s\r\n", cmdbuf); - g_free (cmdbuf); - if (camel_exception_is_set (ex)) { + if (camel_stream_printf (store->ostream, "%s\r\n", cmdbuf) == -1) { + g_free (cmdbuf); if (*ret) - *ret = g_strdup (camel_exception_get_description (ex)); - camel_exception_free (ex); + *ret = g_strdup(strerror(errno)); return CAMEL_POP3_FAIL; } + g_free (cmdbuf); /* Read the response */ - respbuf = camel_stream_buffer_read_line (CAMEL_STREAM_BUFFER (store->istream), ex); - if (camel_exception_is_set (ex)) { + respbuf = camel_stream_buffer_read_line (CAMEL_STREAM_BUFFER (store->istream)); + if (respbuf == NULL) { if (*ret) - *ret = g_strdup (camel_exception_get_description (ex)); - camel_exception_free (ex); + *ret = g_strdup(strerror(errno)); return CAMEL_POP3_FAIL; } if (!strncmp (respbuf, "+OK", 3)) @@ -582,7 +580,7 @@ camel_pop3_command_get_additional_data (CamelPop3Store *store, data = g_ptr_array_new (); while (1) { - buf = camel_stream_buffer_read_line (stream, ex); + buf = camel_stream_buffer_read_line (stream); if (!buf) { status = CAMEL_POP3_FAIL; break; diff --git a/camel/providers/sendmail/camel-sendmail-transport.c b/camel/providers/sendmail/camel-sendmail-transport.c index a5eeff1a25..3b84d5cb90 100644 --- a/camel/providers/sendmail/camel-sendmail-transport.c +++ b/camel/providers/sendmail/camel-sendmail-transport.c @@ -31,6 +31,7 @@ #include <signal.h> #include <sys/wait.h> #include <unistd.h> +#include <string.h> #include "camel-sendmail-transport.h" #include "camel-mime-message.h" @@ -139,15 +140,15 @@ _send_internal (CamelMedium *message, char **argv, CamelException *ex) /* Parent process. Write the message out. */ close (fd[0]); out = camel_stream_fs_new_with_fd (fd[1]); - camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (message), - out, ex); - gtk_object_unref (GTK_OBJECT (out)); - if (camel_exception_is_set (ex)) { - camel_exception_setv (ex, camel_exception_get_id (ex), + if (camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (message), out) == -1 + || camel_stream_close(out) == -1) { + gtk_object_unref (GTK_OBJECT (out)); + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, "Could not send message: %s", - camel_exception_get_description (ex)); + strerror(errno)); return FALSE; } + gtk_object_unref (GTK_OBJECT (out)); /* Wait for sendmail to exit. */ while (waitpid (pid, &wstat, 0) == -1 && errno == EINTR) diff --git a/camel/providers/vee/camel-vee-folder.c b/camel/providers/vee/camel-vee-folder.c index 88e48134a3..3d4050cf19 100644 --- a/camel/providers/vee/camel-vee-folder.c +++ b/camel/providers/vee/camel-vee-folder.c @@ -53,7 +53,10 @@ void vee_free_summary (CamelFolder *folder, GPtrArray *array); static gint vee_get_message_count (CamelFolder *folder, CamelException *ex); static CamelMimeMessage *vee_get_message_by_uid (CamelFolder *folder, const gchar *uid, CamelException *ex); +static void vee_append_message (CamelFolder *folder, CamelMimeMessage *message, CamelException *ex); + static const CamelMessageInfo *vee_summary_get_by_uid(CamelFolder *f, const char *uid); +static GList *vee_search_by_expression(CamelFolder *folder, const char *expression, CamelException *ex); static void camel_vee_folder_class_init (CamelVeeFolderClass *klass); @@ -111,10 +114,12 @@ camel_vee_folder_class_init (CamelVeeFolderClass *klass) folder_class->get_summary = vee_get_summary; folder_class->free_summary = vee_free_summary; folder_class->get_message_by_uid = vee_get_message_by_uid; + folder_class->append_message = vee_append_message; folder_class->summary_get_by_uid = vee_summary_get_by_uid; folder_class->get_message_count = vee_get_message_count; + folder_class->search_by_expression = vee_search_by_expression; object_class->finalize = camel_vee_folder_finalise; @@ -134,6 +139,17 @@ camel_vee_folder_init (CamelVeeFolder *obj) static void camel_vee_folder_finalise (GtkObject *obj) { + CamelVeeFolder *vf = (CamelVeeFolder *)obj; + struct _CamelVeeFolderPrivate *p = _PRIVATE(vf); + GList *node; + + node = p->folders; + while (node) { + CamelFolder *f = node->data; + gtk_object_unref((GtkObject *)f); + node = g_list_next(node); + } + ((GtkObjectClass *)(camel_vee_folder_parent))->finalize((GtkObject *)obj); } @@ -152,11 +168,31 @@ camel_vee_folder_new (void) } +void +camel_vee_folder_add_folder(CamelVeeFolder *vf, CamelFolder *sub) +{ + struct _CamelVeeFolderPrivate *p = _PRIVATE(vf); + + gtk_object_ref((GtkObject *)sub); + p->folders = g_list_append(p->folders, sub); +} + + static void vee_init (CamelFolder *folder, CamelStore *parent_store, CamelFolder *parent_folder, const gchar *name, gchar separator, CamelException *ex) { CamelVeeFolder *vf = (CamelVeeFolder *)folder; + char *namepart, *searchpart; + + namepart = g_strdup(name); + searchpart = strchr(namepart, '?'); + if (searchpart == NULL) { + /* no search, no result! */ + searchpart = "(body-contains \"=some-invalid_string-sequence=xx\")"; + } else { + *searchpart++ = 0; + } camel_vee_folder_parent->init (folder, parent_store, parent_folder, name, separator, ex); if (camel_exception_get_id (ex)) @@ -177,7 +213,13 @@ static void vee_init (CamelFolder *folder, CamelStore *parent_store, vf->messages = g_ptr_array_new(); vf->messages_uid = g_hash_table_new(g_str_hash, g_str_equal); - vf->expression = g_strdup(folder->name); + vf->expression = g_strdup_printf("(or\n (match-all (user-flag \"%s\"))\n %s\n)", namepart, searchpart); + vf->vname = g_strdup(namepart); + + printf("VFolder expression is %s\n", vf->expression); + printf("VFolder full name = %s\n", camel_folder_get_full_name(folder)); + + g_free(namepart); } static void vee_open (CamelFolder *folder, CamelFolderOpenMode mode, CamelException *ex) @@ -205,6 +247,19 @@ static gboolean vee_exists (CamelFolder *folder, CamelException *ex) return TRUE; } +static void vee_append_message (CamelFolder *folder, CamelMimeMessage *message, CamelException *ex) +{ + CamelVeeFolder *vf = (CamelVeeFolder *)folder; + + if (message->folder && message->folder->permanent_flags & CAMEL_MESSAGE_USER) { + /* set the flag on the message ... */ + camel_mime_message_set_user_flag(message, vf->vname, TRUE); + } else { + /* FIXME: error code */ + camel_exception_setv(ex, 1, "Cannot append this message to virtual folder"); + } +} + static gint vee_get_message_count (CamelFolder *folder, CamelException *ex) { CamelVeeFolder *vf = (CamelVeeFolder *)folder; @@ -259,13 +314,30 @@ static GPtrArray *vee_get_uids (CamelFolder *folder, CamelException *ex) return result; } -void -camel_vee_folder_add_folder(CamelVeeFolder *vf, CamelFolder *sub) +static GList * +vee_search_by_expression(CamelFolder *folder, const char *expression, CamelException *ex) { + GList *result = NULL, *node; + char *expr; + CamelVeeFolder *vf = (CamelVeeFolder *)folder; struct _CamelVeeFolderPrivate *p = _PRIVATE(vf); - gtk_object_ref((GtkObject *)sub); - p->folders = g_list_append(p->folders, sub); + expr = g_strdup_printf("(and %s %s)", vf->expression, expression); + node = p->folders; + while (node) { + CamelFolder *f = node->data; + GList *matches, *match; + matches = camel_folder_search_by_expression(f, vf->expression, ex); + match = matches; + while (match) { + char *uid = match->data; + result = g_list_prepend(result, g_strdup_printf("%p:%s", f, uid)); + match = g_list_next(match); + } + g_list_free(matches); + node = g_list_next(node); + } + return result; } /* @@ -283,6 +355,19 @@ vee_folder_build(CamelVeeFolder *vf, CamelException *ex) GPtrArray *messages; GHashTable *messages_uid; + { + int i; + + for (i=0;i<vf->messages->len;i++) { + CamelVeeMessageInfo *mi = g_ptr_array_index(vf->messages, i); + g_free(mi->info.subject); + g_free(mi->info.to); + g_free(mi->info.from); + g_free(mi->info.uid); + camel_flag_list_free(&mi->info.user_flags); + } + } + messages = g_ptr_array_new(); messages_uid = g_hash_table_new(g_str_hash, g_str_equal); @@ -324,8 +409,9 @@ vee_folder_build(CamelVeeFolder *vf, CamelException *ex) node = g_list_next(node); } -#warning "free messages on query update" + g_ptr_array_free(vf->messages, TRUE); vf->messages = messages; + g_hash_table_destroy(vf->messages_uid); vf->messages_uid = messages_uid; } diff --git a/camel/providers/vee/camel-vee-folder.h b/camel/providers/vee/camel-vee-folder.h index 4d82c842ea..ea2a82a25b 100644 --- a/camel/providers/vee/camel-vee-folder.h +++ b/camel/providers/vee/camel-vee-folder.h @@ -38,6 +38,8 @@ struct _CamelVeeFolder { struct _CamelVeeFolderPrivate *priv; char *expression; /* query expression */ + char *vname; /* local name */ + CamelFolder *local; /* local storage for folder */ /* FIXME: Move this to a summary object??? */ GPtrArray *messages; /* message info's */ |