chibipub

main.c (10628B)

---

 
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <netdb.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <ctype.h>
 #include <assert.h>
 #include <base64.h>
 
 #include "http.h"
 #include "ap_json.h"
 #include "inbox.h"
 #include "outbox.h"
 #include "json.h"
 #include "sigcheck.h"
 #include "env.h"
 #include "post.h"
 
 #define BUF_SIZE 1048576
 #define ARENA_SIZE 134217728 /* 128 MB virtual mem arena */
 #define streq(a,b) (!strcmp(a,b))
 #define patheq(req, x) (streq(x, req->path) || streq(x "/", req->path))
 
 struct webfinger {
 	const char *acct;
 	const char *alias;
 	const char *profile_page;
 	const char *self;
 };
 
 static void error(char *msg)
 {
 	perror(msg);
 	exit(1);
 }
 
 
 #define SCHEMA "https://"
 
 static void init_test_webfinger(struct webfinger *finger)
 {
 	static unsigned char buf[512];
 	struct cursor c;
 	make_cursor(buf, buf+sizeof(buf), &c);
 
 	const char *host = get_hostname();
 	const char *id = get_id();
 	assert(host);
 
 	finger->acct = (char*)c.p;
 
 	assert(
 		push_str(&c, "jb55@") && push_c_str(&c, id)
 	);
 
 	finger->alias = (char*)c.p;
 
 	assert(
 		push_str(&c, SCHEMA) && push_str(&c, id) &&
 		push_c_str(&c, "/")
 	);
 
 	finger->profile_page = (char*)c.p;
 
 	assert(
 		push_str(&c, SCHEMA) && push_str(&c, host) &&
 		push_c_str(&c, "/profile")
 	);
 
 	finger->self = (char*)c.p;
 
 	assert(
 		push_str(&c, SCHEMA) && push_str(&c, id) &&
 		push_c_str(&c, "/")
 	);
 }
 
 static int handle_webfinger(struct http_req *req)
 {
 	struct webfinger finger;
 
 	init_test_webfinger(&finger);
 
 	http_write_header(req, "200 OK");
 
 	fprintf(req->client.socket_file,
 	  "{\"subject\": \"acct:%s\","
 	  " \"aliases\": [\"%s\"],"
 	  " \"links\": [{"
 	  "   \"rel\": \"http://webfinger.net/rel/profile-page\","
 	  "   \"type\": \"text/html\","
 	  "   \"href\": \"%s\""
 	  " },{"
 	  "   \"rel\":\"self\","
 	  "   \"type\": \"application/activity+json\","
 	  "   \"href\": \"%s\""
 	  " }]}\r\n",
 		finger.acct,
 		finger.alias,
 		finger.profile_page,
 		finger.self);
 
 	return 1;
 }
 
 
 static inline int starts_with(const char *str, const char *prefix)
 {
 	unsigned int prefix_size;
 	prefix_size = strlen(prefix);
 
 	if (prefix_size > strlen(str)) {
 		return 0;
 	}
 
 	return !memcmp(str, prefix, prefix_size);
 }
 
 static void http_log(struct http_req *req)
 {
 	printf("%s - \"%s %s %s\"\n",
 		req->client.addr_str,
 		req->method,
 		req->path,
 		req->ver);
 }
 
 static int handle_inbox_request(struct http_req *req, struct cursor *arena)
 {
 	const char *signature;
 	unsigned char *start;
 	FILE *out;
 	int len;
 	struct sig_header sig;
 	struct json_parser pull;
 	struct json_pusher push;
 	struct ap_json apjson;
 
 	struct json_handlers compact;
 	struct json_handlers ap_handler;
 
 	make_compact_handlers(&compact, &push);
 	make_ap_json_pusher(&ap_handler, &apjson);
 	init_ap_json(&apjson, &compact);
 
 	memset(&sig, 0, sizeof(sig));
 
 	if (!get_header(req->headers, "signature", &signature)) {
 		note_error(&req->errs, "signature");
 		return 0;
 	}
 
 	printf("signature: %s\n", signature);
 
 	if (!parse_signature_header(&req->errs, arena, signature, strlen(signature), &sig)) {
 		note_error(&req->errs, "parse signature header");
 		return 0;
 	}
 
 	apjson.sig = &sig;
 	apjson.req = req;
 
 	start = arena->p;
 	init_json_pusher_with(&push, arena);
 
 	init_json_parser(&pull, req->body, req->body_len, &ap_handler);
 	if (!parse_json(&pull)) {
 		note_error(&req->errs, "json parse failed");
 		return 0;
 	}
 
 	if (!(out = fopen("activities.json", "a"))) {
 		note_error(&req->errs, "could not open activities.json");
 		return 0;
 	}
 
 	len = push.cur.p - start;
 
 	// 128 KB
 	if (len >= 131072) {
 		note_error(&req->errs, "ActivityPub message too big");
 		return 0;
 	}
 
 	fwrite(start, len, 1, out);
 	fwrite("\n", 1, 1, out);
 	fclose(out);
 
 	http_write_header(req, "200 OK");
 	return 1;
 }
 
 static inline int is_get(struct http_req *req)
 {
 	return streq(req->method, "GET");
 }
 
 static inline int is_post(struct http_req *req)
 {
 	return streq(req->method, "POST");
 }
 
 
 static inline int is_accept_activity(struct http_req *req)
 {
 	const char *accept;
 
 	if (!get_header(req->headers, "accept", &accept)) {
 		note_error(&req->errs, "accept");
 		return 0;
 	}
 
 	if (!(strstr(accept, "application/activity+json") ||
 	      strstr(accept, "application/ld+json"))) {
 		note_error(&req->errs, "not accept: '%s'", accept);
 		return 0;
 	}
 
 	return 1;
 }
 
 struct profile
 {
 	const char *id;
 	const char *type;
 	const char *username;
 	const char *name;
 	const char *summary;
 	const char *url;
 	int manually_approves_followers;
 	const char *image_mime_type;
 	const char *image_url;
 	const char *key_id;
 	const char *pubkey_pem;
 };
 
 static void test_profile(struct profile *p)
 {
 	static unsigned char buf[128];
 	struct cursor c;
 	make_cursor(buf, buf + sizeof(buf), &c);
 
 	const char *host = get_hostname();
 	const char *id = get_id();
 
 	assert(host);
 
 	p->id = (char*)c.p;
 	assert(
 		push_str(&c, SCHEMA) && push_str(&c, id) && push_c_str(&c, "/")
 	);
 
 	p->url = (char*)c.p;
 	assert(
 		push_str(&c, SCHEMA) && push_str(&c, host) && push_c_str(&c, "/")
 	);
 
 	p->type = "Person";
 	p->username = "jb55";
 	p->name = "William Casarin";
 	p->summary = "chibipub prototype";
 	p->manually_approves_followers = 0;
 	p->image_mime_type = "image/jpeg";
 	p->image_url = "https://jb55.com/s/blue-me.jpg";
 	p->key_id = "main-key";
 	p->pubkey_pem = get_pubkey();
 }
 
 static int handle_self(struct http_req *req)
 {
 	struct profile profile;
 	test_profile(&profile);
 
 	http_write_header(req, "200 OK");
 
 	fprintf(req->client.socket_file,
 	"{"
 	  "\"@context\": ["
 	    "\"https://www.w3.org/ns/activitystreams\""
 	  "],"
 	  "\"inbox\": \"%sinbox\","
 	  "\"id\": \"%s\","
 	  "\"type\": \"%s\","
 	  "\"preferredUsername\": \"%s\","
 	  "\"name\": \"%s\","
 	  "\"summary\": \"%s\","
 	  "\"url\": \"%s\","
 	  "\"manuallyApprovesFollowers\": %s,"
 	  "\"icon\": {"
 	    "\"type\": \"Image\","
 	    "\"mediaType\": \"%s\","
 	    "\"url\": \"%s\""
 	  "},"
 	  "\"publicKey\": {"
 	    "\"id\": \"%s#%s\","
 	    "\"owner\": \"%s\","
 	    "\"publicKeyPem\": \"%s\""
 	  "}"
 	"}\n",
 	profile.url,
 	profile.id,
 	profile.type,
 	profile.username,
 	profile.name,
 	profile.summary,
 	profile.url,
 	profile.manually_approves_followers ? "true" : "false",
 	profile.image_mime_type,
 	profile.image_url,
 	profile.id, profile.key_id,
 	profile.id,
 	profile.pubkey_pem);
 
 	return 1;
 }
 
 static int handle_request(struct http_req *req, struct cursor *arena)
 {
 	http_log(req);
 
 	if (starts_with(req->path, "/.well-known/webfinger?resource=acct:") ||
 	    starts_with(req->path, "/?resource=acct:")) {
 		return handle_webfinger(req);
 	} else if (is_post(req) && patheq(req, "/inbox")) {
 		return handle_inbox_request(req, arena);
 	} else if (is_get(req) && patheq(req, "/outbox")) {
 		return handle_outbox_request(req);
 	} else if (is_get(req) && patheq(req, "/outbox?page=true")) {
 		return handle_outbox_page_request(req, "outbox.json");
 	} else if (is_get(req) &&
 	           is_accept_activity(req) &&
 	           streq(req->path, "/")) {
 		return handle_self(req);
 	}
 
 	return 0;
 }
 
 static int http_accept_client(struct http_req *req, int parent)
 {
 	struct sockaddr_in *addr;
 	socklen_t client_len;
 	struct hostent *client_host;
 
 	client_len = sizeof(addr);
 
 	addr = &req->client.sockaddr;
 
 	req->client.socket =
 		accept(parent, (struct sockaddr *) &req->client.sockaddr,
 				&client_len);
 
 	if (req->client.socket < 0) {
 		note_error(&req->errs, "bad socket");
 		return 0;
 	}
 
 	req->client.socket_file = fdopen(req->client.socket, "wb");
 
 	client_host = gethostbyaddr((const char *)&addr->sin_addr.s_addr,
 			sizeof(addr->sin_addr.s_addr), AF_INET);
 
 	if (!client_host) {
 		note_error(&req->errs, "gethostbyaddr");
 		return 0;
 	}
 
 	req->client.addr_str = inet_ntoa(addr->sin_addr);
 
 	if (!req->client.addr_str) {
 		note_error(&req->errs, "inet_htoa");
 		return 0;
 	}
 
 	return 1;
 }
 
 void run_http_server()
 {
 	static unsigned char buffer[BUF_SIZE];
 	unsigned char *arena;
 
 	ssize_t len, size;
 
 	int parent;
 	struct sockaddr_in server_addr;
 	int optval;
 
 	struct http_req req;
 
 	struct parser parser;
 
 	const int port = 5188;
 	arena = malloc(ARENA_SIZE);
 	assert(arena);
 
 	if ((parent = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 		error("socket");
 	}
 
 	optval = 1;
 	setsockopt(parent, SOL_SOCKET, SO_REUSEADDR, (const void *)&optval,
 			sizeof(optval));
 
 	memset(&server_addr, 0, sizeof(server_addr));
 	server_addr.sin_family = AF_INET;
 	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 	server_addr.sin_port = htons(port);
 
 	if (bind(parent, (struct sockaddr *)&server_addr,
 				sizeof(server_addr)) < 0) {
 		error("bind");
 	}
 
 	printf("listening for activities on 0.0.0.0:%d\n", port);
 
 	if (listen(parent, 5) < 0) {
 		error("listen");
 	}
 
 	while (1) {
 		init_http_req(&req);
 		make_cursor(buffer, buffer + BUF_SIZE, &parser.cur);
 		make_cursor(arena, arena + ARENA_SIZE, &parser.arena);
 
 		http_accept_client(&req, parent);
 
 		for(size = 0;1;) {
 			len = read(req.client.socket, (void*)(buffer+size), BUF_SIZE-size);
 			size += len;
 			if (len == 0) {
 				break;
 			}
 
 			if (len != (BUF_SIZE-size)) {
 				break;
 			}
 		}
 
 		if (parse_http_request(&req, &parser, size)) {
 			handle_request(&req, &parser.arena);
 		}
 
 		fclose(req.client.socket_file);
 		close(req.client.socket);
 	}
 
 	free(arena);
 }
 
 static int load_config()
 {
 	if (!get_hostname()) {
 		printf("CHIBIPUB_HOST env not set\n");
 		return 0;
 	}
 	return 1;
 }
 
 static int checksigs()
 {
 	struct sigcheck check;
 	check.activity_file = "activities.json";
 	if (!sigcheck(&check)) {
 		printf("sigcheck failed\n");
 		return 0;
 	}
 	printf("ok\n");
 	return 1;
 }
 
 int usage()
 {
 	printf(
 	"usage: chibipub [OPTION]... <command>\n"
 	"\n"
 	"commands\n"
 	"\n"
 	"help          show this help\n"
 	"serve         run the server\n"
 	"post          post a new message\n"
 	"checksigs     check inbox signatures\n"
 	);
 
 	return 0;
 }
 
 static int serve()
 {
 	if (!load_config())
 		return usage();
 	run_http_server();
 	return 0;
 }
 
 static int mkpost(struct chibipub *pub, int argc, char **argv)
 {
 	struct post post;
 
 	if (argc != 1)
 		return 1;
 
 	post.content = argv[0];
 
 	return !create_post(pub, &post);
 }
 
 int main(int argc, char *argv[])
 {
 	struct chibipub pub;
 
 	if (argc < 2) {
 		return usage();
 	}
 
 	// early cmds
 	if (!strcmp(argv[1], "help") || !strcmp(argv[1], "--help")) {
 		return usage();
 	} 
 
 	if (!init_chibipub(&pub))
 		return 1;
 
 	if (!strcmp(argv[1], "serve")) {
 		return serve();
 	} else if (!strcmp(argv[1], "post")) {
 		if (argc - 2 < 1) return usage();
 		return mkpost(&pub, argc - 2, &argv[2]);
 	} else if (!strcmp(argv[1], "checksigs")) {
 		return checksigs();
 	} else {
 		return usage();
 	}
 }