Changeset 4d4f656 in mainline

Timestamp:

2013-09-26T20:50:52Z (11 years ago)

Author:

Martin Sucha <sucha14@…>

Branches:

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

Children:

408424e

Parents:

b623b68

Message:

libhttp: Add higher-level API for working with headers

Location:

uspace

Files:

• app/download/main.c (modified) (2 diffs)
• lib/http/include/http/errno.h (added)
• lib/http/include/http/http.h (modified) (3 diffs)
• lib/http/src/headers.c (modified) (3 diffs)
• lib/http/src/request.c (modified) (4 diffs)
• lib/http/src/response.c (modified) (4 diffs)

uspace/app/download/main.c

@@ -135 +135 @@
         }
         
-        http_header_t *header_host = http_header_create("Host", uri->host);
-        if (header_host == NULL) {
-                fprintf(stderr, "Failed creating Host header\n");
-                uri_destroy(uri);
-                return 3;
-        }
-        list_append(&header_host->link, &req->headers);
-        
-        http_header_t *header_ua = http_header_create("User-Agent", USER_AGENT);
-        if (header_ua == NULL) {
-                fprintf(stderr, "Failed creating User-Agent header\n");
-                uri_destroy(uri);
-                return 3;
-        }
-        list_append(&header_ua->link, &req->headers);
+        int rc = http_headers_append(&req->headers, "Host", uri->host);
+        if (rc != EOK) {
+                fprintf(stderr, "Failed setting Host header: %s\n", str_error(rc));
+                uri_destroy(uri);
+                return rc;
+        }
+        
+        rc = http_headers_append(&req->headers, "User-Agent", USER_AGENT);
+        if (rc != EOK) {
+                fprintf(stderr, "Failed creating User-Agent header: %s\n", str_error(rc));
+                uri_destroy(uri);
+                return rc;
+        }
         
         http_t *http = http_create(uri->host, port);
@@ -158 +156 @@
         }
         
-        int rc = http_connect(http);
+        rc = http_connect(http);
         if (rc != EOK) {
                 fprintf(stderr, "Failed connecting: %s\n", str_error(rc));

uspace/lib/http/include/http/http.h

@@ -67 +67 @@
 
 typedef struct {
+        list_t list;
+} http_headers_t;
+
+typedef struct {
         char *method;
         char *path;
-        list_t headers;
+        http_headers_t headers;
 } http_request_t;
 
@@ -76 +80 @@
         uint16_t status;
         char *message;
-        list_t headers;
+        http_headers_t headers;
 } http_response_t;
 
@@ -88 +92 @@
 extern int http_header_receive(receive_buffer_t *, http_header_t *);
 extern void http_header_normalize_value(char *);
+extern bool http_header_name_match(const char *, const char *);
 ssize_t http_header_encode(http_header_t *, char *, size_t);
 extern void http_header_destroy(http_header_t *);
+
+extern void http_headers_init(http_headers_t *);
+extern int http_headers_find_single(http_headers_t *, const char *,
+    http_header_t **);
+extern int http_headers_append(http_headers_t *, const char *, const char *);
+extern int http_headers_set(http_headers_t *, const char *, const char *);
+extern int http_headers_get(http_headers_t *, const char *, char **);
+extern int http_headers_receive(receive_buffer_t *, http_headers_t *);
+extern void http_headers_clear(http_headers_t *);
+
+#define http_headers_foreach(headers, iter) \
+    list_foreach((headers).list, link, http_header_t, (iter))
+
+static inline void http_headers_remove(http_headers_t *headers,
+    http_header_t *header)
+{
+        list_remove(&header->link);
+}
+
+static inline void http_headers_append_header(http_headers_t *headers,
+    http_header_t *header)
+{
+        list_append(&header->link, &headers->list);
+}
 
 extern http_request_t *http_request_create(const char *, const char *);

uspace/lib/http/src/headers.c

@@ -41 +41 @@
 #include <http/http.h>
 #include <http/ctype.h>
+#include <http/errno.h>
 
 #define HTTP_HEADER_LINE "%s: %s\r\n"
@@ -204 +205 @@
         int rc = http_header_receive_name(rb, &name);
         if (rc != EOK) {
-                printf("Failed receiving header name\n");
                 return rc;
         }
@@ -247 +247 @@
 }
 
+/** Test if two header names are equivalent
+ *
+ */
+bool http_header_name_match(const char *name_a, const char *name_b)
+{
+        return stricmp(name_a, name_b) == 0;
+}
+
+void http_headers_init(http_headers_t *headers) {
+        list_initialize(&headers->list);
+}
+
+int http_headers_find_single(http_headers_t *headers, const char *name,
+    http_header_t **out_header)
+{
+        http_header_t *found = NULL;
+        http_headers_foreach(*headers, header) {
+                if (!http_header_name_match(header->name, name))
+                        continue;
+                
+                if (found == NULL) {
+                        found = header;
+                }
+                else {
+                        return HTTP_EMULTIPLE_HEADERS;
+                }
+        }
+        
+        if (found == NULL)
+                return HTTP_EMISSING_HEADER;
+        
+        *out_header = found;
+        return EOK;
+}
+
+int http_headers_append(http_headers_t *headers, const char *name,
+    const char *value)
+{
+        http_header_t *header = http_header_create(name, value);
+        if (header == NULL)
+                return ENOMEM;
+        
+        http_headers_append_header(headers, header);
+        return EOK;
+}
+
+int http_headers_set(http_headers_t *headers, const char *name,
+    const char *value)
+{
+        http_header_t *header = NULL;
+        int rc = http_headers_find_single(headers, name, &header);
+        if (rc != EOK && rc != HTTP_EMISSING_HEADER)
+                return rc;
+        
+        if (rc == HTTP_EMISSING_HEADER)
+                return http_headers_append(headers, name, value);
+        
+        char *new_value = str_dup(value);
+        if (new_value == NULL)
+                return ENOMEM;
+        
+        free(header->value);
+        header->value = new_value;
+        return EOK;
+}
+
+int http_headers_get(http_headers_t *headers, const char *name, char **value)
+{
+        http_header_t *header = NULL;
+        int rc = http_headers_find_single(headers, name, &header);
+        if (rc != EOK)
+                return rc;
+        
+        *value = header->value;
+        return EOK;
+}
+
+int http_headers_receive(receive_buffer_t *rb, http_headers_t *headers)
+{
+        int rc = EOK;
+        unsigned added = 0;
+        
+        while (true) {
+                char c = 0;
+                rc = recv_char(rb, &c, false);
+                if (rc != EOK)
+                        goto error;
+                
+                if (c == '\n' || c == '\r')
+                        break;
+                
+                http_header_t *header = malloc(sizeof(http_header_t));
+                if (header == NULL) {
+                        rc = ENOMEM;
+                        goto error;
+                }
+                http_header_init(header);
+                
+                rc = http_header_receive(rb, header);
+                if (rc != EOK) {
+                        free(header);
+                        goto error;
+                }
+                
+                http_headers_append_header(headers, header);
+                added++;
+        }
+        
+        return EOK;
+error:
+        while (added-- > 0) {
+                link_t *link = list_last(&headers->list);
+                http_header_t *header = list_get_instance(link, http_header_t, link);
+                http_headers_remove(headers, header);
+                http_header_destroy(header);
+        }
+        return rc;
+}
+
+void http_headers_clear(http_headers_t *headers)
+{
+        link_t *link = list_first(&headers->list);
+        while (link != NULL) {
+                link_t *next = list_next(link, &headers->list);
+                http_header_t *header = list_get_instance(link, http_header_t, link);
+                list_remove(link);
+                http_header_destroy(header);
+                link = next;
+        }
+}
+
 /** @}
  */

uspace/lib/http/src/request.c

@@ -65 +65 @@
         }
         
-        list_initialize(&req->headers);
+        http_headers_init(&req->headers);
         
         return req;
@@ -74 +74 @@
         free(req->method);
         free(req->path);
-        link_t *link = req->headers.head.next;
-        while (link != &req->headers.head) {
-                link_t *next = link->next;
-                http_header_t *header = list_get_instance(link, http_header_t, link);
-                http_header_destroy(header);
-                link = next;
-        }
+        http_headers_clear(&req->headers);
         free(req);
 }
@@ -104 +98 @@
         size_t size = meth_size;
         
-        list_foreach(req->headers, link, http_header_t, header) {
+        http_headers_foreach(req->headers, header) {
                 ssize_t header_size = http_header_encode(header, NULL, 0);
                 if (header_size < 0)
@@ -126 +120 @@
         pos_size -= written;
         
-        list_foreach(req->headers, link, http_header_t, header) {
+        http_headers_foreach(req->headers, header) {
                 written = http_header_encode(header, pos, pos_size);
                 if (written < 0) {

uspace/lib/http/src/response.c

@@ -40 +40 @@
 
 #include <http/http.h>
+#include <http/errno.h>
 
 int http_parse_status(const char *line, http_version_t *out_version,
@@ -98 +99 @@
                 return ENOMEM;
         memset(resp, 0, sizeof(http_response_t));
-        list_initialize(&resp->headers);
+        http_headers_init(&resp->headers);
         
         char *line = malloc(http->buffer_size);
@@ -115 +116 @@
                 goto error;
         
-        while (true) {
-                rc = recv_eol(&http->recv_buffer);
-                if (rc < 0)
-                        goto error;
-                
-                /* Empty line ends header part */
-                if (rc > 0)
-                        break;
-                
-                http_header_t *header = malloc(sizeof(http_header_t));
-                if (header == NULL) {
-                        rc = ENOMEM;
-                        goto error;
-                }
-                http_header_init(header);
-                
-                rc = http_header_receive(&http->recv_buffer, header);
-                if (rc != EOK) {
-                        free(header);
-                        goto error;
-                }
-                
-                list_append(&header->link, &resp->headers);
-        }
+        rc = http_headers_receive(&http->recv_buffer, &resp->headers);
+        if (rc != EOK)
+                goto error;
+        
+        rc = recv_eol(&http->recv_buffer);
+        if (rc == 0)
+                rc = HTTP_EPARSE;
+        if (rc < 0)
+                goto error;
         
         *out_response = resp;
@@ -157 +143 @@
 {
         free(resp->message);
-        link_t *link = resp->headers.head.next;
-        while (link != &resp->headers.head) {
-                link_t *next = link->next;
-                http_header_t *header = list_get_instance(link, http_header_t, link);
-                http_header_destroy(header);
-                link = next;
-        }
+        http_headers_clear(&resp->headers);
         free(resp);
 }