Changeset 3ce68b7 in mainline

Timestamp:

2013-09-26T09:01:36Z (11 years ago)

Author:

Martin Sucha <sucha14@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

b623b68

Parents:

c17469e

Message:

libhttp: receive headers correctly

Location:

uspace/lib/http

Files:

• headers.c (modified) (2 diffs)
• http-ctype.h (added)
• http.h (modified) (1 diff)
• receive-buffer.c (modified) (6 diffs)
• receive-buffer.h (modified) (2 diffs)
• response.c (modified) (2 diffs)

uspace/lib/http/headers.c

@@ -40 +40 @@
 
 #include "http.h"
+#include "http-ctype.h"
 
 #define HTTP_HEADER_LINE "%s: %s\r\n"
-
-static char *cut_str(const char *start, const char *end)
-{
-        size_t size = end - start;
-        return str_ndup(start, size);
-}
 
 void http_header_init(http_header_t *header)
@@ -98 +93 @@
 }
 
-int http_header_parse(const char *line, http_header_t *header)
-{
-        const char *pos = line;
-        while (*pos != 0 && *pos != ':') pos++;
-        if (*pos != ':')
+int http_header_receive_name(receive_buffer_t *rb, char **out_name)
+{
+        receive_buffer_mark_t name_start;
+        receive_buffer_mark_t name_end;
+        
+        recv_mark(rb, &name_start);
+        recv_mark(rb, &name_end);
+        
+        char c = 0;
+        do {
+                recv_mark_update(rb, &name_end);
+                
+                int rc = recv_char(rb, &c, true);
+                if (rc != EOK) {
+                        recv_unmark(rb, &name_start);
+                        recv_unmark(rb, &name_end);
+                        return rc;
+                }
+        } while (is_token(c));
+        
+        if (c != ':') {
+                recv_unmark(rb, &name_start);
+                recv_unmark(rb, &name_end);
                 return EINVAL;
-        
-        char *name = cut_str(line, pos);
-        if (name == NULL)
-                return ENOMEM;
-        
-        pos++;
-        
-        while (*pos == ' ') pos++;
-        
-        char *value = str_dup(pos);
-        if (value == NULL) {
+        }
+        
+        char *name = NULL;
+        int rc = recv_cut_str(rb, &name_start, &name_end, &name);
+        recv_unmark(rb, &name_start);
+        recv_unmark(rb, &name_end);
+        if (rc != EOK)
+                return rc;
+        
+        *out_name = name;
+        return EOK;
+}
+
+int http_header_receive_value(receive_buffer_t *rb, char **out_value)
+{
+        int rc = EOK;
+        char c = 0;
+        
+        receive_buffer_mark_t value_start;
+        recv_mark(rb, &value_start);
+        
+        /* Ignore any inline LWS */
+        while (true) {
+                recv_mark_update(rb, &value_start);
+                rc = recv_char(rb, &c, false);
+                if (rc != EOK)
+                        goto error;
+                
+                if (c != ' ' && c != '\t')
+                        break;
+                
+                rc = recv_char(rb, &c, true);
+                if (rc != EOK)
+                        goto error;
+        }
+        
+        receive_buffer_mark_t value_end;
+        recv_mark(rb, &value_end);
+        
+        while (true) {
+                recv_mark_update(rb, &value_end);
+                
+                rc = recv_char(rb, &c, true);
+                if (rc != EOK)
+                        goto error_end;
+                
+                if (c != '\r' && c != '\n')
+                        continue;
+                
+                rc = recv_discard(rb, (c == '\r' ? '\n' : '\r'));
+                if (rc < 0)
+                        goto error_end;
+                
+                rc = recv_char(rb, &c, false);
+                if (rc != EOK)
+                        goto error_end;
+                
+                if (c != ' ' && c != '\t')
+                        break;
+                
+                /* Ignore the char */
+                rc = recv_char(rb, &c, true);
+                if (rc != EOK)
+                        goto error_end;
+        }
+        
+        char *value = NULL;
+        rc = recv_cut_str(rb, &value_start, &value_end, &value);
+        recv_unmark(rb, &value_start);
+        recv_unmark(rb, &value_end);
+        if (rc != EOK)
+                return rc;
+        
+        *out_value = value;
+        return EOK;
+error_end:
+        recv_unmark(rb, &value_end);
+error:
+        recv_unmark(rb, &value_start);
+        return rc;
+}
+
+int http_header_receive(receive_buffer_t *rb, http_header_t *header)
+{
+        char *name = NULL;
+        int rc = http_header_receive_name(rb, &name);
+        if (rc != EOK) {
+                printf("Failed receiving header name\n");
+                return rc;
+        }
+        
+        char *value = NULL;
+        rc = http_header_receive_value(rb, &value);
+        if (rc != EOK) {
                 free(name);
-                return ENOMEM;
+                return rc;
         }
         
         header->name = name;
         header->value = value;
-        
         return EOK;
 }
 
+/** Normalize HTTP header value
+ *
+ * @see RFC2616 section 4.2
+ */
+void http_header_normalize_value(char *value)
+{
+        size_t read_index = 0;
+        size_t write_index = 0;
+        
+        while (is_lws(value[read_index])) read_index++;
+        
+        while (value[read_index] != 0) {
+                if (is_lws(value[read_index])) {
+                        while (is_lws(value[read_index])) read_index++;
+                        
+                        if (value[read_index] != 0)
+                                value[write_index++] = ' ';
+                        
+                        continue;
+                }
+                
+                value[write_index++] = value[read_index++];
+        }
+        
+        value[write_index] = 0;
+}
+
 /** @}
  */

uspace/lib/http/http.h

@@ -84 +84 @@
 extern void http_header_init(http_header_t *);
 extern http_header_t *http_header_create(const char *, const char *);
-extern int http_header_parse(const char *, http_header_t *);
+extern int http_header_receive_name(receive_buffer_t *, char **);
+extern int http_header_receive_value(receive_buffer_t *, char **);
+extern int http_header_receive(receive_buffer_t *, http_header_t *);
+extern void http_header_normalize_value(char *);
 ssize_t http_header_encode(http_header_t *, char *, size_t);
 extern void http_header_destroy(http_header_t *);

uspace/lib/http/receive-buffer.c

@@ -39 +39 @@
 #include <errno.h>
 #include <macros.h>
+#include <adt/list.h>
 
 #include "receive-buffer.h"
@@ -51 +52 @@
         rb->out = 0;
         rb->size = buffer_size;
+        
+        list_initialize(&rb->marks);
+        
         rb->buffer = malloc(buffer_size);
         if (rb->buffer == NULL)
@@ -57 +61 @@
 }
 
+static ssize_t dummy_receive(void *unused, void *buf, size_t buf_size)
+{
+        return 0;
+}
+
+int recv_buffer_init_const(receive_buffer_t *rb, void *buf, size_t size)
+{
+        int rc = recv_buffer_init(rb, size, dummy_receive, NULL);
+        if (rc != EOK)
+                return rc;
+        
+        memcpy(rb->buffer, buf, size);
+        rb->in = size;
+        return EOK;
+}
+
 void recv_buffer_fini(receive_buffer_t *rb)
 {
@@ -68 +88 @@
 }
 
+void recv_mark(receive_buffer_t *rb, receive_buffer_mark_t *mark)
+{
+        link_initialize(&mark->link);
+        list_append(&mark->link, &rb->marks);
+        recv_mark_update(rb, mark);
+}
+
+void recv_unmark(receive_buffer_t *rb, receive_buffer_mark_t *mark)
+{
+        list_remove(&mark->link);
+}
+
+void recv_mark_update(receive_buffer_t *rb, receive_buffer_mark_t *mark)
+{
+        mark->offset = rb->out;
+}
+
+int recv_cut(receive_buffer_t *rb, receive_buffer_mark_t *a, receive_buffer_mark_t *b, void **out_buf, size_t *out_size)
+{
+        if (a->offset > b->offset)
+                return EINVAL;
+        
+        size_t size = b->offset - a->offset;
+        void *buf = malloc(size);
+        if (buf == NULL)
+                return ENOMEM;
+        
+        memcpy(buf, rb->buffer + a->offset, size);
+        *out_buf = buf;
+        *out_size = size;
+        return EOK;
+}
+
+int recv_cut_str(receive_buffer_t *rb, receive_buffer_mark_t *a, receive_buffer_mark_t *b, char **out_buf)
+{
+        if (a->offset > b->offset)
+                return EINVAL;
+        
+        size_t size = b->offset - a->offset;
+        char *buf = malloc(size + 1);
+        if (buf == NULL)
+                return ENOMEM;
+        
+        memcpy(buf, rb->buffer + a->offset, size);
+        buf[size] = 0;
+        for (size_t i = 0; i < size; i++) {
+                if (buf[i] == 0) {
+                        free(buf);
+                        return EIO;
+                }
+        }
+        *out_buf = buf;
+        return EOK;
+}
+
+
 /** Receive one character (with buffering) */
 int recv_char(receive_buffer_t *rb, char *c, bool consume)
 {
         if (rb->out == rb->in) {
-                recv_reset(rb);
+                size_t free = rb->size - rb->in;
+                if (free == 0) {
+                        size_t min_mark = rb->size;
+                        list_foreach(rb->marks, link, receive_buffer_mark_t, mark) {
+                                min_mark = min(min_mark, mark->offset);
+                        }
+                        
+                        if (min_mark == 0)
+                                return ELIMIT;
+                        
+                        size_t new_in = rb->in - min_mark;
+                        memmove(rb->buffer, rb->buffer + min_mark, new_in);
+                        rb->out = rb->in = new_in;
+                        free = rb->size - rb->in;
+                        list_foreach(rb->marks, link, receive_buffer_mark_t, mark) {
+                                mark->offset -= min_mark;
+                        }
+                }
                 
-                ssize_t rc = rb->receive(rb->client_data, rb->buffer, rb->size);
+                ssize_t rc = rb->receive(rb->client_data, rb->buffer + rb->in, free);
                 if (rc <= 0)
                         return rc;
@@ -100 +193 @@
 }
 
-/** Receive a character and if it is c, discard it from input buffer */
-int recv_discard(receive_buffer_t *rb, char discard)
+/** Receive a character and if it is c, discard it from input buffer
+ * @return number of characters discarded (0 or 1) or negative error code
+ */
+ssize_t recv_discard(receive_buffer_t *rb, char discard)
 {
         char c = 0;
@@ -108 +203 @@
                 return rc;
         if (c != discard)
-                return EOK;
-        return recv_char(rb, &c, true);
+                return 0;
+        rc = recv_char(rb, &c, true);
+        if (rc != EOK)
+                return rc;
+        return 1;
+}
+
+/** Receive an end of line, either CR, LF, CRLF or LFCR
+ *
+ * @return number of bytes read (0 if no newline is present in the stream)
+ *         or negative error code
+ */
+ssize_t recv_eol(receive_buffer_t *rb)
+{
+        char c = 0;
+        int rc = recv_char(rb, &c, false);
+        if (rc != EOK)
+                return rc;
+        
+        if (c != '\r' && c != '\n')
+                return 0;
+        
+        rc = recv_char(rb, &c, true);
+        if (rc != EOK)
+                return rc;
+        
+        ssize_t rc2 = recv_discard(rb, (c == '\r' ? '\n' : '\r'));
+        if (rc2 < 0)
+                return rc2;
+        
+        return 1 + rc2;
 }
 

uspace/lib/http/receive-buffer.h

@@ -37 +37 @@
 #define HTTP_RECEIVE_BUFFER_H_
 
+#include <adt/list.h>
 
 /** Receive data.
@@ -55 +56 @@
         void *client_data;
         receive_func_t receive;
+        
+        list_t marks;
 } receive_buffer_t;
 
+typedef struct {
+        link_t link;
+        size_t offset;
+} receive_buffer_mark_t;
+
 extern int recv_buffer_init(receive_buffer_t *, size_t, receive_func_t, void *);
+extern int recv_buffer_init_const(receive_buffer_t *, void *, size_t);
 extern void recv_buffer_fini(receive_buffer_t *);
 extern void recv_reset(receive_buffer_t *);
+extern void recv_mark(receive_buffer_t *, receive_buffer_mark_t *);
+extern void recv_unmark(receive_buffer_t *, receive_buffer_mark_t *);
+extern void recv_mark_update(receive_buffer_t *, receive_buffer_mark_t *);
+extern int recv_cut(receive_buffer_t *, receive_buffer_mark_t *,
+    receive_buffer_mark_t *, void **, size_t *);
+extern int recv_cut_str(receive_buffer_t *, receive_buffer_mark_t *,
+    receive_buffer_mark_t *, char **);
 extern int recv_char(receive_buffer_t *, char *, bool);
 extern ssize_t recv_buffer(receive_buffer_t *, char *, size_t);
-extern int recv_discard(receive_buffer_t *, char);
+extern ssize_t recv_discard(receive_buffer_t *, char);
+extern ssize_t recv_eol(receive_buffer_t *);
 extern ssize_t recv_line(receive_buffer_t *, char *, size_t);
 

uspace/lib/http/response.c

@@ -116 +116 @@
         
         while (true) {
-                rc = recv_line(&http->recv_buffer, line, http->buffer_size);
+                rc = recv_eol(&http->recv_buffer);
                 if (rc < 0)
                         goto error;
-                if (*line == 0)
+                
+                /* Empty line ends header part */
+                if (rc > 0)
                         break;
                 
@@ -129 +131 @@
                 http_header_init(header);
                 
-                rc = http_header_parse(line, header);
-                if (rc != EOK)
+                rc = http_header_receive(&http->recv_buffer, header);
+                if (rc != EOK) {
+                        free(header);
                         goto error;
+                }
                 
                 list_append(&header->link, &resp->headers);