Use camel_mime_parser_read to read internal parser data.

2002-02-04  Jeffrey Stedfast  <fejj@ximian.com>

	* camel-http-stream.c (stream_read): Use camel_mime_parser_read to
	read internal parser data.
	(camel_http_stream_get_content_type): Implemented.

	* camel-mime-utils.c (header_decode_int): Made public.

diff --git a/camel/ChangeLog b/camel/ChangeLog
index 64e6a83..7a5b6e1 100644 (file)
--- a/camel/ChangeLog
+++ b/camel/ChangeLog
@@ -1,5 +1,11 @@
 2002-02-04  Jeffrey Stedfast  <fejj@ximian.com>
 
+       * camel-http-stream.c (stream_read): Use camel_mime_parser_read to
+       read internal parser data.
+       (camel_http_stream_get_content_type): Implemented.
+
+       * camel-mime-utils.c (header_decode_int): Made public.
+
        * camel-http-stream.[c,h]: Added. New stream for HTTP requests
        (currently supported are GET and HEAD).
 

diff --git a/camel/Makefile.am b/camel/Makefile.am
index 751f293..95b45f0 100644 (file)
--- a/camel/Makefile.am
+++ b/camel/Makefile.am
@@ -37,6 +37,7 @@ libcamel_la_SOURCES =                                 \
        camel-folder-thread.c                   \
        camel-folder.c                          \
        camel-html-parser.c                     \
+       camel-http-stream.c                     \
        camel-internet-address.c                \
        camel-lock.c                            \
        camel-lock-client.c                     \
@@ -125,6 +126,7 @@ libcamelinclude_HEADERS =                   \
        camel-folder-summary.h                  \
        camel-folder-thread.h                   \
        camel-folder.h                          \
+       camel-http-stream.h                     \
        camel-internet-address.h                \
        camel-lock.h                            \
        camel-lock-client.h                     \

diff --git a/camel/camel-http-stream.c b/camel/camel-http-stream.c
index b7880df..3dbccc8 100644 (file)
--- a/camel/camel-http-stream.c
+++ b/camel/camel-http-stream.c
@@ -28,6 +28,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <ctype.h>
 #include <errno.h>
 
 #include "camel-http-stream.h"
@@ -72,21 +73,22 @@ camel_http_stream_class_init (CamelHttpStreamClass *camel_http_stream_class)
 static void
 camel_http_stream_init (gpointer object, gpointer klass)
 {
-       CamelHttpStream *stream = CAMEL_HTTP_STREAM (object);
+       CamelHttpStream *http = CAMEL_HTTP_STREAM (object);
        
-       stream->content_type = NULL;
-       stream->headers = NULL;
-       stream->service = NULL;
-       stream->url = NULL;
-       stream->raw = NULL;
+       http->parser = NULL;
+       http->content_type = NULL;
+       http->headers = NULL;
+       http->service = NULL;
+       http->url = NULL;
+       http->raw = NULL;
 }
 
 static void
-headers_free (http->headers)
+headers_free (struct _header_raw *headers)
 {
        struct _header_raw *node, *next;
        
-       node = http->headers;
+       node = headers;
        while (node) {
                next = node->next;
                g_free (node->name);
@@ -99,22 +101,25 @@ headers_free (http->headers)
 static void
 camel_http_stream_finalize (CamelObject *object)
 {
-       CamelHttpStream *stream = CAMEL_HTTP_STREAM (object);
+       CamelHttpStream *http = CAMEL_HTTP_STREAM (object);
+       
+       if (http->parser)
+               camel_object_unref (CAMEL_OBJECT (http->parser));
        
-       if (stream->content_type)
-               header_content_type_unref (stream->content_type);
+       if (http->content_type)
+               header_content_type_unref (http->content_type);
        
-       if (stream->headers)
-               headers_free (stream->headers);
+       if (http->headers)
+               headers_free (http->headers);
        
-       if (stream->service)
-               camel_object_unref (CAMEL_OBJECT (service));
+       if (http->service)
+               camel_object_unref (CAMEL_OBJECT (http->service));
        
-       if (stream->url)
-               camel_url_free (stream->url);
+       if (http->url)
+               camel_url_free (http->url);
        
-       if (stream->raw)
-               camel_object_unref (CAMEL_OBJECT (stream->raw));
+       if (http->raw)
+               camel_object_unref (CAMEL_OBJECT (http->raw));
 }
 
 
@@ -152,7 +157,7 @@ camel_http_stream_new (CamelHttpMethod method, CamelService *service, CamelURL *
        CamelHttpStream *stream;
        char *str;
        
-       g_return_val_if_fail (!CAMEL_IS_SERVICE (service), NULL);
+       g_return_val_if_fail (CAMEL_IS_SERVICE (service), NULL);
        g_return_val_if_fail (url != NULL, NULL);
        
        stream = CAMEL_HTTP_STREAM (camel_object_new (camel_http_stream_get_type ()));
@@ -219,30 +224,29 @@ http_connect (CamelService *service, CamelURL *url)
 static const char *
 http_next_token (const unsigned char *in)
 {
-       const char *inptr = in;
+       const unsigned char *inptr = in;
        
-       while (*inptr && !is_lwsp (*inptr))
+       while (*inptr && !isspace ((int) *inptr))
                inptr++;
        
-       while (*inptr && is_lwsp (*inptr))
+       while (*inptr && isspace ((int) *inptr))
                inptr++;
        
-       return inptr;
+       return (const char *) inptr;
 }
 
 static int
 http_get_headers (CamelHttpStream *http)
 {
-       CamelMimeParser *mp;
        struct _header_raw *headers, *node, *tail;
        const char *type, *token;
+       char buffer[4096], *buf;
        int status, len, err;
-       char *buf;
        
-       if (camel_stream_buffer_gets (CAMEL_STREAM_BUFFER (http->raw), buffer, 4096) <= 0)
+       if (camel_stream_buffer_gets (CAMEL_STREAM_BUFFER (http->raw), buffer, sizeof (buffer)) <= 0)
                return -1;
        
-       if (!stncasecmp (buffer, "HTTP/", 5)) {
+       if (!strncasecmp (buffer, "HTTP/", 5)) {
                token = http_next_token (buffer);
                status = header_decode_int (&token);
                /* FIXME: don't just check for 200 */
@@ -251,15 +255,15 @@ http_get_headers (CamelHttpStream *http)
        } else
                goto exception;
        
-       mp = camel_mime_parser_new ();
-       camel_mime_parser_init_with_stream (mp, http->raw);
+       http->parser = camel_mime_parser_new ();
+       camel_mime_parser_init_with_stream (http->parser, http->raw);
        
-       switch (camel_mime_parser_step (mp, &buf, &len)) {
+       switch (camel_mime_parser_step (http->parser, &buf, &len)) {
        case HSCAN_MESSAGE:
        case HSCAN_HEADER:
        case HSCAN_MULTIPART:
                /* we have the headers, build them into 'us' */
-               headers = camel_mime_parser_headers_raw (mp);
+               headers = camel_mime_parser_headers_raw (http->parser);
                
                /* if content-type exists, process it first, set for fallback charset in headers */
                if (http->content_type)
@@ -289,14 +293,18 @@ http_get_headers (CamelHttpStream *http)
                
                break;
        default:
-               g_warning ("Invalid state encountered???: %d", camel_mime_parser_state (mp));
+               g_warning ("Invalid state encountered???: %d", camel_mime_parser_state (http->parser));
        }
        
-       err = camel_mime_parser_errno (mp);
-       camel_object_unref (CAMEL_OBJECT (mp));
+       err = camel_mime_parser_errno (http->parser);
        
-       if (err != 0)
+       if (err != 0) {
+               camel_object_unref (CAMEL_OBJECT (http->parser));
+               http->parser = NULL;
                goto exception;
+       }
+       
+       camel_mime_parser_drop_step (http->parser);
        
        return 0;
        
@@ -307,105 +315,82 @@ http_get_headers (CamelHttpStream *http)
        return -1;
 }
 
-
-static ssize_t
-stream_read (CamelStream *stream, char *buffer, size_t n)
+static int
+http_method_invoke (CamelHttpStream *http)
 {
-       CamelHttpStream *http = CAMEL_HTTP_STREAM (stream);
+       const char *method = NULL;
+       char *url;
        
-       if (http->method != CAMEL_HTTP_METHOD_GET || http->method != CAMEL_HTTP_METHOD_HEAD) {
-               errno = ENOTSUPP;
-               return -1;
+       switch (http->method) {
+       case CAMEL_HTTP_METHOD_GET:
+               method = "GET";
+               break;
+       case CAMEL_HTTP_METHOD_HEAD:
+               method = "HEAD";
+               break;
+       default:
+               g_assert_not_reached ();
        }
        
-       if (!http->raw) {
-               const char *method;
-               char *url;
-               
-               http->raw = http_connect (http->service, http->url);
-               if (!http->raw)
-                       return -1;
-               
-               switch (http->method) {
-               case CAMEL_HTTP_METHOD_GET:
-                       method = "GET";
-                       break;
-               case CAMEL_HTTP_METHOD_HEAD:
-                       method = "HEAD";
-                       break;
-               }
-               
-               url = camel_url_to_string (http->url, 0);
-               if (camel_stream_printf (http->raw, "%s %s HTTP/1.1\r\nHost: %s\r\n\r\n",
-                                        method, http->url->path ? http->url->path : "/",
-                                        http->url->host) == -1 ||
-                   camel_stream_flush (http->raw) == -1) {
-                       camel_object_unref (CAMEL_OBJECT (http->raw));
-                       http->raw = NULL;
-                       return -1;
-               }
-               g_free (url);
-               
-               if (http_get_headers (http) == -1)
-                       return -1;
+       url = camel_url_to_string (http->url, 0);
+       if (camel_stream_printf (http->raw, "%s %s HTTP/1.1\r\nHost: %s\r\n\r\n",
+                                method, http->url->path ? http->url->path : "/",
+                                http->url->host) == -1 ||
+           camel_stream_flush (http->raw) == -1) {
+               camel_object_unref (CAMEL_OBJECT (http->raw));
+               http->raw = NULL;
+               return -1;
        }
+       g_free (url);
        
-       return camel_stream_read (http->raw, buffer, n);
+       return 0;
 }
 
 static ssize_t
-stream_write (CamelStream *stream, const char *buffer, size_t n)
+stream_read (CamelStream *stream, char *buffer, size_t n)
 {
        CamelHttpStream *http = CAMEL_HTTP_STREAM (stream);
+       const char *parser_buf;
+       ssize_t nread;
        
-       if (http->method == CAMEL_HTTP_METHOD_GET || http->method == CAMEL_HTTP_METHOD_HEAD) {
-               errno = ENOTSUPP;
+       if (http->method != CAMEL_HTTP_METHOD_GET && http->method != CAMEL_HTTP_METHOD_HEAD) {
+               errno = EIO;
                return -1;
        }
        
-       return -1;
-#if 0  
        if (!http->raw) {
-               const char *method;
-               char *url;
-               
                http->raw = http_connect (http->service, http->url);
                if (!http->raw)
                        return -1;
                
-               switch (http->method) {
-               case CAMEL_HTTP_METHOD_PUT:
-                       method = "PUT";
-                       break;
-               case CAMEL_HTTP_METHOD_POST:
-                       method = "POST";
-                       break;
-               }
-               
-               url = camel_url_to_string (http->url, 0);
-               if (camel_stream_printf (http->raw, "%s %s HTTP/1.1\r\nHost: %s\r\n\r\n",
-                                        method, http->url->path ? http->url->path : "/",
-                                        http->url->host) == -1 ||
-                   camel_stream_flush (http->raw) == -1) {
-                       camel_object_unref (CAMEL_OBJECT (http->raw));
-                       http->raw = NULL;
+               if (http_method_invoke (http) == -1)
                        return -1;
-               }
-               g_free (url);
                
                if (http_get_headers (http) == -1)
                        return -1;
        }
        
-       return camel_stream_write (http->raw, buffer, n);
-#endif
+       nread = camel_mime_parser_read (http->parser, &parser_buf, n);
+       
+       if (nread > 0)
+               memcpy (buffer, parser_buf, nread);
+       
+       return nread;
+}
+
+static ssize_t
+stream_write (CamelStream *stream, const char *buffer, size_t n)
+{
+       return -1;
 }
 
 static int
 stream_flush (CamelStream *stream)
 {
-       if (stream->raw)
-               return camel_stream_flush (stream->raw);
+       CamelHttpStream *http = (CamelHttpStream *) stream;
+       
+       if (http->raw)
+               return camel_stream_flush (http->raw);
        else
                return 0;
 }
@@ -413,7 +398,7 @@ stream_flush (CamelStream *stream)
 static int
 stream_close (CamelStream *stream)
 {
-       CamelHttpStream *http = CAMEL_HTTP_STREAM (stream);
+       CamelHttpStream *http = (CamelHttpStream *) stream;
        
        if (http->raw) {
                if (camel_stream_close (http->raw) == -1)
@@ -439,3 +424,27 @@ stream_reset (CamelStream *stream)
        
        return 0;
 };
+
+
+CamelContentType *
+camel_http_stream_get_content_type (CamelHttpStream *http_stream)
+{
+       g_return_val_if_fail (CAMEL_IS_HTTP_STREAM (http_stream), NULL);
+       
+       if (!http_stream->content_type && !http_stream->raw) {
+               http_stream->raw = http_connect (http_stream->service, http_stream->url);
+               if (!http_stream->raw)
+                       return NULL;
+               
+               if (http_method_invoke (http_stream) == -1)
+                       return NULL;
+               
+               if (http_get_headers (http_stream) == -1)
+                       return NULL;
+       }
+       
+       if (http_stream->content_type)
+               header_content_type_ref (http_stream->content_type);
+       
+       return http_stream->content_type;
+}

diff --git a/camel/camel-http-stream.h b/camel/camel-http-stream.h
index 1ffa18d..ac4b2c2 100644 (file)
--- a/camel/camel-http-stream.h
+++ b/camel/camel-http-stream.h
@@ -29,6 +29,7 @@ extern "C" {
 #pragma }
 #endif /* __cplusplus */
 
+#include <camel/camel-mime-parser.h>
 #include <camel/camel-mime-utils.h>
 #include <camel/camel-service.h>
 #include <camel/camel-stream.h>
@@ -52,11 +53,12 @@ typedef enum {
 
 
 typedef struct _CamelHttpStreamClass CamelHttpStreamClass;
-typedef struct _CamelHttpStream CamelHttpStream;
 
 struct _CamelHttpStream {
        CamelStream parent_object;
        
+       CamelMimeParser *parser;
+       
        CamelContentType *content_type;
        struct _header_raw *headers;
        
@@ -79,6 +81,8 @@ CamelType camel_http_stream_get_type (void);
 /* public methods */
 CamelStream *camel_http_stream_new (CamelHttpMethod method, CamelService *service, CamelURL *url);
 
+CamelContentType *camel_http_stream_get_content_type (CamelHttpStream *http_stream);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

diff --git a/camel/camel-mime-utils.c b/camel/camel-mime-utils.c
index 9f0c5fa..660cc35 100644 (file)
--- a/camel/camel-mime-utils.c
+++ b/camel/camel-mime-utils.c
@@ -1815,8 +1815,8 @@ header_decode_value(const char **in)
        return NULL;
 }
 
-/* shoudl this return -1 for no int? */
-static int
+/* should this return -1 for no int? */
+int
 header_decode_int(const char **in)
 {
        const char *inptr = *in;

diff --git a/camel/camel-mime-utils.h b/camel/camel-mime-utils.h
index 7795741..50a3eb8 100644 (file)
--- a/camel/camel-mime-utils.h
+++ b/camel/camel-mime-utils.h
@@ -160,6 +160,8 @@ char *header_unfold (const char *in);
 /* decode a header which is a simple token */
 char *header_token_decode (const char *in);
 
+int header_decode_int (const char **in);
+
 /* decode/encode a string type, like a subject line */
 char *header_decode_string (const char *in, const char *default_charset);
 char *header_encode_string (const unsigned char *in);

diff --git a/camel/camel-types.h b/camel/camel-types.h
index 6765424..86da09c 100644 (file)
--- a/camel/camel-types.h
+++ b/camel/camel-types.h
@@ -71,6 +71,7 @@ typedef struct _CamelTcpStream CamelTcpStream;
 typedef struct _CamelTcpStreamRaw CamelTcpStreamRaw;
 typedef struct _CamelTcpStreamSSL CamelTcpStreamSSL;
 typedef struct _CamelTcpStreamOpenSSL CamelTcpStreamOpenSSL;
+typedef struct _CamelHttpStream CamelHttpStream;
 typedef struct _CamelTransport CamelTransport;
 
 #ifdef __cplusplus