8 files changed, 507 insertions, 0 deletions
diff --git a/libs/libnet/Makefile b/libs/libnet/Makefile
new file mode 100644
index 0000000..85c8fab
--- /dev/null
+++ b/libs/libnet/Makefile
@@ -0,0 +1,20 @@
+# MIT License, Copyright (c) 2020 Marvin Borner
+
+COBJS = dns.o http.o ip.o
+CC = ccache ../../cross/opt/bin/i686-elf-gcc
+LD = ccache ../../cross/opt/bin/i686-elf-ld
+AR = ccache ../../cross/opt/bin/i686-elf-ar
+
+CFLAGS = $(CFLAGS_DEFAULT) -I../ -I../libc/inc/ -Duserspace
+
+all: libtxt
+
+%.o: %.c
+	@$(CC) -c $(CFLAGS) $< -o $@
+
+libtxt: $(COBJS)
+	@mkdir -p ../../build/
+	@$(AR) rcs ../../build/libnet.a $+
+
+clean:
+	@find . -name "*.o" -type f -delete
diff --git a/libs/libnet/dns.c b/libs/libnet/dns.c
new file mode 100644
index 0000000..f20f33a
--- /dev/null
+++ b/libs/libnet/dns.c
@@ -0,0 +1,116 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+// TODO: Less magic, auto xld splitting
+// TODO: DNS cache
+
+#include <def.h>
+#include <libnet/net.h>
+#include <libnet/socket.h>
+#include <mem.h>
+#include <print.h>
+#include <random.h>
+#include <str.h>
+
+static u32 dns_ip_addr = ip(1, 1, 1, 1);
+
+struct dns_packet {
+	u16 qid;
+	u16 flags;
+	u16 questions;
+	u16 answers;
+	u16 authorities;
+	u16 additional;
+	u8 data[];
+} __attribute__((packed));
+
+static u32 part_count(const char *name)
+{
+	u32 cnt = 0;
+	for (u32 i = 0; i < strlen(name); i++) {
+		if (name[i] == '.')
+			cnt++;
+	}
+	return cnt + 1;
+}
+
+static u32 part_len(const char *name, u32 index)
+{
+	const char *data = name;
+
+	u32 cnt = 0;
+	for (u32 i = 0; i < strlen(name); i++) {
+		if (cnt == index) {
+			data += i;
+			break;
+		}
+
+		if (name[i] == '.')
+			cnt++;
+	}
+
+	for (cnt = 0; cnt < strlen(data); cnt++) {
+		if (data[cnt] == '.' || data[cnt] == '\0')
+			break;
+	}
+
+	return cnt;
+}
+
+static void dns_make_packet(struct dns_packet *packet, const char *name)
+{
+	packet->qid = htons(rand());
+	packet->flags = htons(0x0100); // Standard query
+	packet->questions = htons(1);
+	packet->answers = htons(0);
+	packet->authorities = htons(0);
+	packet->additional = htons(0);
+
+	u8 *data = packet->data;
+	u32 cnt = 0;
+	for (u32 i = 0; i < part_count(name) * 2; i += 2) {
+		data[cnt] = part_len(name, i / 2);
+		memcpy(&data[cnt + 1], &name[cnt], data[cnt]);
+		cnt += data[cnt] + 1;
+	}
+
+	packet->data[cnt + 0] = 0x00; // Name end
+	packet->data[cnt + 2] = 0x01; // A
+	packet->data[cnt + 4] = 0x01; // IN
+}
+
+static u32 dns_handle_packet(struct dns_packet *packet)
+{
+	u16 flags = htons(packet->flags);
+	u8 reply_code = flags & 0xf;
+	if (reply_code != DNS_NOERROR) {
+		printf("DNS error: %d\n", reply_code);
+		return 0;
+	}
+
+	u8 *start = &packet->data[1] + strlen((char *)&packet->data[1]);
+	printf("TTL of %s: %ds\n", &packet->data[1], (u32)start[14]);
+	u8 *ip = &start[17];
+	printf("IP: %d.%d.%d.%d\n", ip[0], ip[1], ip[2], ip[3]);
+	return ip(ip[0], ip[1], ip[2], ip[3]);
+}
+
+u32 dns_request(const char *name)
+{
+	struct socket *socket = net_open(S_UDP);
+	if (!socket || !net_connect(socket, dns_ip_addr, 53, NET_TIMEOUT) || part_count(name) == 1)
+		return 0;
+
+	u32 length = sizeof(struct dns_packet) + strlen(name) + part_count(name) + 4;
+	struct dns_packet *packet = malloc(length);
+	memset(packet, 0, length);
+	dns_make_packet(packet, name);
+	net_send(socket, packet, length);
+	free(packet);
+
+	u8 buf[1024] = { 0 };
+	int l = net_receive(socket, buf, 1024, NET_TIMEOUT);
+	net_close(socket);
+	if (l > 0)
+		return dns_handle_packet((void *)buf);
+	else
+		return 0;
+}
diff --git a/libs/libnet/dns.h b/libs/libnet/dns.h
new file mode 100644
index 0000000..d6673e6
--- /dev/null
+++ b/libs/libnet/dns.h
@@ -0,0 +1,21 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef DNS_H
+#define DNS_H
+
+#include <def.h>
+
+#define DNS_NOERROR 0
+#define DNS_FORMERR 1
+#define DNS_SERVFAIL 2
+#define DNS_NXDOMAIN 3
+#define DNS_NOTIMP 4
+#define DNS_REFUSED 5
+#define DNS_YXDOMAIN 6
+#define DNS_XRRSET 7
+#define DNS_NOTAUTH 8
+#define DNS_NOTZONE 9
+
+u32 dns_request(const char *name);
+
+#endif
diff --git a/libs/libnet/http.c b/libs/libnet/http.c
new file mode 100644
index 0000000..808d4c2
--- /dev/null
+++ b/libs/libnet/http.c
@@ -0,0 +1,134 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#include <assert.h>
+#include <conv.h>
+#include <def.h>
+#include <libnet/http.h>
+#include <libnet/net.h>
+#include <libnet/socket.h>
+#include <mem.h>
+#include <print.h>
+#include <str.h>
+
+char *http_data(char *r)
+{
+	char *h = NULL;
+	for (u32 i = 0; i < strlen(r); ++i) {
+		if (r[i] == '\r' && r[i + 1] == '\n' && r[i + 2] == '\r' && r[i + 3] == '\n') {
+			h = &r[i + 4];
+			break;
+		}
+	}
+	return h;
+}
+
+char *http_header_key(char *r, const char *key)
+{
+	char *res = NULL;
+	for (char *p = r; *p; p++) {
+		/* printf("'%c%c%c' vs '%c%c%c'\n", p[0], p[1], p[2], key[0], key[1], key[2]); */
+		if (strlen(p) >= strlen(key) && !memcmp(p, key, strlen(key))) {
+			char *start = p + strlen(key) + 2;
+			char *end = start;
+			for (; *end != '\n'; end++)
+				;
+			res = malloc(end - start);
+			memcpy(res, start, end - start - 1);
+			res[end - start] = '\0';
+			break;
+		}
+	}
+	return res;
+}
+
+u32 http_content_length(char *r)
+{
+	char *value = http_header_key(r, "Content-Length");
+	int length = value ? atoi(value) : 0;
+	free(value);
+	return length;
+}
+
+char *http_code(char *r)
+{
+	char *code = malloc(4);
+	char tmp = r[12];
+	r[12] = '\0';
+	memcpy(code, r + 9, 3);
+	code[3] = '\0';
+	r[12] = tmp;
+	return code;
+}
+
+u32 http_response(const char *http_code, u32 content_length, const char *data, char *resp)
+{
+	char buf[16] = { 0 };
+
+	resp[0] = '\0';
+	strcat(resp, "HTTP/1.1 ");
+	strcat(resp, buf);
+	strcat(resp, http_code);
+	strcat(resp, "\r\n");
+	strcat(resp, "Content-Length: ");
+	strcat(resp, conv_base(content_length, buf, 10, 0));
+	strcat(resp, "\r\n");
+	strcat(resp, "Server: Melvix\r\n");
+	strcat(resp, "Content-Type: text/html\r\n");
+	strcat(resp, "Connection: close\r\n\r\n");
+	u32 len = strlen(resp);
+	memcpy(&resp[len], data, content_length);
+
+	return len + content_length;
+}
+
+char *http_query_get(const char *url, const char *path)
+{
+	char *query = malloc(27 + strlen(url)); // TODO: Dynamic http length etc
+	query[0] = '\0';
+	strcat(query, "GET ");
+	if (path[0] != '/')
+		strcat(query, "/");
+	strcat(query, path);
+	strcat(query, " HTTP/1.1\r\nHost: ");
+	strcat(query, url);
+	strcat(query, "\r\n\r\n");
+	return query;
+}
+
+char *http_query_path(const char *query, char *path)
+{
+	u8 b = 0;
+	u32 s = 0;
+	u32 e = 0;
+
+	while (1) {
+		if (!b && query[e] == ' ' && query[++e]) {
+			s = e;
+			b = 1;
+		} else if (b && query[e] == ' ') {
+			strncat(path, &query[s], e - s);
+			break;
+		} else if (query[e] == '\0') {
+			return NULL;
+		}
+		e++;
+	}
+
+	return path;
+}
+
+char *http_receive(struct socket *socket)
+{
+	char buf[4096] = { 0 };
+	if (!net_receive(socket, buf, 4096, NET_TIMEOUT))
+		return NULL;
+
+	u32 length = http_content_length(buf);
+	char *data = malloc(strlen(buf) + length);
+	memcpy(data, buf, strlen(buf));
+	while (strlen(http_data(data)) != length) {
+		if (!net_receive(socket, data, length, NET_TIMEOUT))
+			break;
+	}
+	return data;
+}
diff --git a/libs/libnet/http.h b/libs/libnet/http.h
new file mode 100644
index 0000000..b9160ad
--- /dev/null
+++ b/libs/libnet/http.h
@@ -0,0 +1,82 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef HTTP_H
+#define HTTP_H
+
+#include <def.h>
+#include <libnet/socket.h>
+
+char *http_data(char *response);
+char *http_header_key(char *r, const char *key);
+u32 http_content_length(char *r);
+char *http_code(char *r);
+u32 http_response(const char *http_code, u32 content_length, const char *data, char *resp);
+char *http_query_get(const char *url, const char *path);
+char *http_query_path(const char *query, char *path);
+char *http_receive(struct socket *socket);
+
+#define HTTP_100 "100 Continue"
+#define HTTP_101 "101 Switching Protocol"
+#define HTTP_102 "102 Processing"
+#define HTTP_103 "103 Early Hints"
+#define HTTP_200 "200 OK"
+#define HTTP_201 "201 Created"
+#define HTTP_202 "202 Accepted"
+#define HTTP_203 "203 Non-Authoritative Information"
+#define HTTP_204 "204 No Content"
+#define HTTP_205 "205 Reset Content"
+#define HTTP_206 "206 Partial Content"
+#define HTTP_207 "207 Multi-Status"
+#define HTTP_208 "208 Already Reported"
+#define HTTP_226 "226 IM Used"
+#define HTTP_300 "300 Multiple Choice"
+#define HTTP_301 "301 Moved Permanently"
+#define HTTP_302 "302 Found"
+#define HTTP_303 "303 See Other"
+#define HTTP_304 "304 Not Modified"
+#define HTTP_305 "305 Use Proxy"
+#define HTTP_306 "306 Unused"
+#define HTTP_307 "307 Temporary Redirect"
+#define HTTP_308 "308 Permanent Redirect"
+#define HTTP_400 "400 Bad Request"
+#define HTTP_401 "401 Unauthorized"
+#define HTTP_402 "402 Payment Required"
+#define HTTP_403 "403 Forbidden"
+#define HTTP_404 "404 Not Found"
+#define HTTP_405 "405 Method Not Allowed"
+#define HTTP_406 "406 Not Acceptable"
+#define HTTP_407 "407 Proxy Authentication Required"
+#define HTTP_408 "408 Request Timeout"
+#define HTTP_409 "409 Conflict"
+#define HTTP_410 "410 Gone"
+#define HTTP_411 "411 Length Required"
+#define HTTP_412 "412 Precondition Failed"
+#define HTTP_413 "413 Payload Too Large"
+#define HTTP_414 "414 URI Too Long"
+#define HTTP_415 "415 Unsupported Media Type"
+#define HTTP_416 "416 Range Not Satisfiable"
+#define HTTP_417 "417 Expectation Failed"
+#define HTTP_418 "418 I'm a teapot"
+#define HTTP_421 "421 Misdirected Request"
+#define HTTP_422 "422 Unprocessable Entity"
+#define HTTP_423 "423 Locked"
+#define HTTP_424 "424 Failed Dependency"
+#define HTTP_425 "425 Too Early"
+#define HTTP_426 "426 Upgrade Required"
+#define HTTP_428 "428 Precondition Required"
+#define HTTP_429 "429 Too Many Request"
+#define HTTP_431 "431 Request Header Fields Too Large"
+#define HTTP_451 "451 Unavailable For Legal Reasons"
+#define HTTP_500 "500 Internal Server Error"
+#define HTTP_501 "501 Not Implemented"
+#define HTTP_502 "502 Bad Gateway"
+#define HTTP_503 "503 Service Unavailable"
+#define HTTP_504 "504 Gateway Timeout"
+#define HTTP_505 "505 HTTP Version Not Supported"
+#define HTTP_506 "506 Variant Also Negotiates"
+#define HTTP_507 "507 Insufficient Storage"
+#define HTTP_508 "508 Loop Detected"
+#define HTTP_510 "510 Not Extended"
+#define HTTP_511 "511 Network Authentication Required"
+
+#endif
diff --git a/libs/libnet/ip.c b/libs/libnet/ip.c
new file mode 100644
index 0000000..20e1a38
--- /dev/null
+++ b/libs/libnet/ip.c
@@ -0,0 +1,49 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+// Most net/ip handlers are in the kernel space
+// This is a userspace wrapper for some things
+
+#include <def.h>
+#include <libnet/net.h>
+#include <mem.h>
+#include <str.h>
+
+// Inspired by Paul Vixie, 1996
+int ip_pton(const char *src, u32 *dst)
+{
+	const char *end = src + strlen(src);
+	u8 tmp[4], *tp;
+	int ch = 0;
+	int saw_digit = 0;
+	int octets = 0;
+	*(tp = tmp) = 0;
+
+	while (src < end) {
+		ch = *src++;
+		if (ch >= '0' && ch <= '9') {
+			u32 new = *tp * 10 + (ch - '0');
+
+			if ((saw_digit && *tp == 0) || new > 255)
+				return 0;
+
+			*tp = new;
+			if (!saw_digit) {
+				if (++octets > 4)
+					return 0;
+				saw_digit = 1;
+			}
+		} else if (ch == '.' && saw_digit) {
+			if (octets == 4)
+				return 0;
+			*++tp = 0;
+			saw_digit = 0;
+		} else {
+			return 0;
+		}
+	}
+
+	if (octets < 4)
+		return 0;
+
+	*dst = htonl(*(u32 *)tmp);
+	return 1;
+}
diff --git a/libs/libnet/ip.h b/libs/libnet/ip.h
new file mode 100644
index 0000000..e06aba2
--- /dev/null
+++ b/libs/libnet/ip.h
@@ -0,0 +1,12 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+// Most net/ip handlers are in the kernel space
+// This is a userspace wrapper for some things
+
+#ifndef IP_H
+#define IP_H
+
+#include <def.h>
+
+int ip_pton(const char *src, u32 *dst);
+
+#endif
diff --git a/libs/libnet/net.h b/libs/libnet/net.h
new file mode 100644
index 0000000..4bfda2b
--- /dev/null
+++ b/libs/libnet/net.h
@@ -0,0 +1,73 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef NET_H
+#define NET_H
+
+#include <libnet/dns.h>
+#include <libnet/ip.h>
+#include <libnet/socket.h>
+#include <print.h>
+#include <sys.h>
+
+#define htonl(l)                                                                                   \
+	((((l)&0xff) << 24) | (((l)&0xff00) << 8) | (((l)&0xff0000) >> 8) |                        \
+	 (((l)&0xff000000) >> 24))
+#define htons(s) ((((s)&0xff) << 8) | (((s)&0xff00) >> 8))
+#define ntohl(l) htonl((l))
+#define ntohs(s) htons((s))
+#define ip(a, b, c, d)                                                                             \
+	((((a)&0xff) << 24) | (((b)&0xff) << 16) | (((c)&0xff) << 8) | (((d)&0xff) << 0))
+
+#define NET_TIMEOUT 2000
+#define NET_NO_TIMEOUT 0
+
+static inline int net_data_available(struct socket *socket)
+{
+	return (socket && socket->packets && socket->packets->head && socket->packets->head->data &&
+		((struct socket_data *)socket->packets->head->data)->length > 0);
+}
+
+#define net_open(type) (void *)sys1(SYS_NET_OPEN, (int)(type))
+#define net_send(socket, data, len) (void)sys3(SYS_NET_SEND, (int)(socket), (int)(data), (int)(len))
+
+static inline int net_connect(struct socket *socket, u32 ip_addr, u16 dst_port, u32 timeout)
+{
+	if (!socket || !ip_addr || !dst_port)
+		return 0;
+	sys3(SYS_NET_CONNECT, (int)(socket), (int)(ip_addr), (int)(dst_port));
+	int time = time();
+	while (socket->state != S_CONNECTED) {
+		if (socket->state == S_FAILED || (timeout && time() - time >= timeout))
+			return 0;
+		yield();
+	}
+	return 1;
+}
+
+static inline int net_close(struct socket *socket)
+{
+	if (!socket)
+		return 0;
+	int res = 0;
+	while (socket->state == S_CLOSING || !(res = (int)sys1(SYS_NET_CLOSE, (int)(socket))))
+		yield();
+	return res;
+}
+
+static inline int net_receive(struct socket *socket, void *buf, u32 len, u32 timeout)
+{
+	if (!socket || !buf || !len)
+		return 0;
+
+	int time = time();
+	while (!net_data_available(socket)) {
+		if (socket->state == S_FAILED || (timeout && time() - time >= timeout))
+			return 0;
+		yield();
+	}
+
+	// TODO: Only return once all segments are received?
+	return (int)sys3(SYS_NET_RECEIVE, (int)(socket), (int)(buf), (int)(len));
+}
+
+#endif