Add hyper_str, headers_iter

Author: seanmonstar

hyper-capi/examples/client.c

@@ -1,7 +1,14 @@
 #include <stdlib.h>
+#include <stdio.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sys/select.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <string.h>
+
 #include "../include/hyper.h"
 
 
@@ -64,31 +71,76 @@ static size_t write_cb(void *userdata, hyper_waker *waker, const uint8_t *buf, s
 	}
 }
 
-int main() {
+static int connect_to(char *host, char *port) {
+	struct addrinfo hints;
+	memset(&hints, 0, sizeof(struct addrinfo));
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+
+	struct addrinfo *result, *rp;
+	if (getaddrinfo(host, port, &hints, &result) != 0) {
+		return -1;
+	}
+
+	int sfd;
+	for (rp = result; rp != NULL; rp = rp->ai_next) {
+		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+		if (sfd == -1) {
+			continue;
+		}
+
+		if (connect(sfd, rp->ai_addr, rp->ai_addrlen) != -1) {
+			break;
+		} else {
+			close(sfd);
+		}
+	}
+
+	freeaddrinfo(result);
+
+	// no address succeeded
+	if (rp == NULL) {
+		return -1;
+	}
+
+	return sfd;
+}
+
+static hyper_iter_step print_each_header(void *userdata, hyper_str name, hyper_str value) {
+	printf("%.*s: %.*s", (int) name.len, name.buf, (int) value.len, value.buf);
+	return HYPER_IT_CONTINUE;
+}
+
+int main(int argc, char *argv[]) {
+
+	int fd = connect_to("httpbin.org", "80");
+	if (fd < 0) {
+		return 1;
+	}
+
 
 	struct conn_fds *all_fds = malloc(sizeof(struct conn_fds));
 
+	FD_ZERO(&all_fds->read);
+	FD_ZERO(&all_fds->write);
+	FD_ZERO(&all_fds->excep);
+
 	struct conn_data *conn = malloc(sizeof(struct conn_data));
-	//TODO: YIKES
-	// should do a connect() instead
-	conn->fd = 3;
+
+	conn->fd = fd;
 	conn->all_fds = all_fds;
 	conn->read_waker = NULL;
 	conn->write_waker = NULL;
 
 
-	FD_ZERO(&all_fds->read);
-	FD_ZERO(&all_fds->write);
-	FD_ZERO(&all_fds->excep);
-
 	// Hookup the IO
 	hyper_io *io = hyper_io_new();
 	hyper_io_set_data(io, (void *)conn);
 	hyper_io_set_read(io, read_cb);
 	hyper_io_set_write(io, write_cb);
 
 	// Prepare client options
-	hyper_clientconn_options *opts = hyper_clientconn_options_new();
+	hyper_clientconn_options *opts = NULL;//hyper_clientconn_options_new();
 
 	hyper_task *handshake = hyper_clientconn_handshake(io, opts);
 
@@ -124,8 +176,8 @@ int main() {
 
 	hyper_executor_push(exec, task);
 
-	// TODO: NEXT
-	/*
+	hyper_response *resp;
+
 	while (1) {
 		hyper_executor_poll(exec);
 		while (1) {
@@ -134,18 +186,31 @@ int main() {
 				break;
 			}
 			switch (hyper_task_type(task)) {
-			case HYPER_TASK_CLIENTCONN_HANDSHAKE:
+			case HYPER_TASK_CLIENT_SEND:
 				// Take the results
-				client = hyper_task_value(task);
-				break;
+				resp = hyper_task_value(task);
+				// fall through
 			default:
 				hyper_task_free(task);
 				break;
 			}
 		}
 
+		// If the response is ready, break out for now...
+		if (resp != NULL) {
+			break;
+		}
+
 		select(1, &all_fds->read, &all_fds->write, &all_fds->excep, NULL);
 
 	}
-	*/
+
+	uint16_t http_status = hyper_response_status(resp);
+	
+	printf("HTTP Status: %d", http_status);
+
+	hyper_headers *headers = hyper_response_headers(resp);
+	hyper_headers_iter(headers, print_each_header, NULL);
+
+	return 0;
 }

hyper-capi/include/hyper.h

@@ -20,17 +20,29 @@ typedef struct hyper_request hyper_request;
 
 typedef struct hyper_response hyper_response;
 
+typedef struct hyper_headers hyper_headers;
+
 typedef struct hyper_task hyper_task;
 
 typedef struct hyper_waker hyper_waker;
 
 typedef struct hyper_executor hyper_executor;
 
+typedef struct hyper_str {
+	const uint8_t *buf;
+	size_t len;
+} hyper_str;
+
 typedef enum {
     HYPERE_OK,
     HYPERE_KABOOM,
 } hyper_error;
 
+typedef enum {
+	HYPER_IT_CONTINUE,
+	HYPER_IT_BREAK,
+} hyper_iter_step;
+
 // HTTP ClientConn
 
 // Starts an HTTP client connection handshake using the provided IO transport
@@ -67,8 +79,8 @@ hyper_io *hyper_io_new();
 // This value is passed as an argument to the read and write callbacks.
 void hyper_io_set_data(hyper_io *io, void *userdata);
 
-#define HYPER_IO_PENDING -2
-#define HYPER_IO_ERROR -3
+#define HYPER_IO_PENDING 0xFFFFFFFF
+#define HYPER_IO_ERROR 0xFFFFFFFE
 
 // Set the read function for this IO transport.
 //
@@ -115,13 +127,44 @@ hyper_error hyper_request_add_header(hyper_request *request, uint8_t *name, size
 
 // HTTP Responses
 
+// Free an HTTP response after using it.
 void hyper_response_free(hyper_response *response);
 
-uint16_t hyper_response_get_status(hyper_response *response);
+// Get the HTTP-Status code of this response.
+//
+// It will always be within the range of 100-599.
+uint16_t hyper_response_status(hyper_response *response);
+
+// Gets a reference to the HTTP headers of this response.
+//
+// This is not an owned reference, so it should not be accessed after the
+// `hyper_response` has been freed.
+hyper_headers *hyper_response_headers(hyper_response *response);
 
-size_t hyper_response_headers_len(hyper_response *response);
+// HTTP Headers
 
-TODO hyper_response_headers_get(hyper_response *response, uint8_t *name, size_t name_len);
+// Sets the header with the provided name to the provided value.
+//
+// This overwrites any previous value set for the header.
+void hyper_headers_set(hyper_headers *headers, hyper_str name, hyper_str value);
+
+// Adds the provided value to the list of the provided name.
+//
+// If there were already existing values for the name, this will append the
+// new value to the internal list.
+void hyper_headers_add(hyper_headers *headers, hyper_str name, hyper_str value);
+
+// Iterates the headers passing each name and value pair to the callback.
+//
+// The `userdata` pointer is also passed to the callback.
+//
+// The callback should return `HYPER_IT_CONTINUE` to keep iterating, or
+// `HYPER_IT_BREAK` to stop.
+void hyper_headers_iter(hyper_headers *headers,
+                        hyper_iter_step (*func)(void *userdata,
+                                                hyper_str name,
+                                                hyper_str value),
+                        void *userdata);
 
 // Futures and Executors