git.y1.nz

hurl.c

#include <sys/socket.h>
#include <sys/time.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <netdb.h>
#include <locale.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include <tls.h>

#include "arg.h"

#define READ_BUF_SIZ	16384

#ifndef __OpenBSD__
#define pledge(p1,p2) 0
#define unveil(p1,p2) 0
#endif

#ifndef TLS_CA_CERT_FILE
#define TLS_CA_CERT_FILE "/etc/ssl/cert.pem"
#endif

/* URI */
struct uri {
	char proto[48];     /* scheme including ":" or "://" */
	char userinfo[256]; /* username [:password] */
	char host[256];
	char port[6];       /* numeric port */
	char path[1024];
	char query[1024];
	char fragment[1024];
};

char *argv0;

/* raw header(s) to add */
static const char *config_headers = "";
/* max response size in bytes, 0 is unlimited */
static size_t config_maxresponsesiz = 0;
/* time-out in seconds */
static long long config_timeout = 0;
/* legacy ciphers? */
static int config_legacy = 0;
/* TLS CA file */
static char *config_ca_file;
/* parsed URI */
static struct uri u;
/* socket fd */
static int sock = -1;
/* raw command-line argument */
static char *url;
/* TLS context */
static struct tls *t;
/* TLS config */
static struct tls_config *tls_config;

/* protocol handlers */
int gopher_request(void);
int http_request(void);

struct handler {
	int (*handler)(void); /* function / handler / callback */
	const char *proto; /* protocol / scheme, "gopher://" */
	const char *port; /* default port */
	int usetls; /* setup TLS (=1) or plain connection (=0) */
};

static const struct handler handlers[] = {
	{ .handler = gopher_request,  .proto = "gopher://",  .port = "70",   .usetls = 0 },
	{ .handler = gopher_request,  .proto = "gophers://", .port = "70",   .usetls = 1 },
	{ .handler = http_request,    .proto = "http://",    .port = "80",   .usetls = 0 },
	{ .handler = http_request,    .proto = "https://",   .port = "443",  .usetls = 1 },
};

ssize_t (*readbuf)(char *, size_t);
ssize_t (*writebuf)(const char *, size_t);

void
sighandler(int signo)
{
	if (signo == SIGALRM)
		 _exit(2);
}

int
parse_content_length(const char *s, size_t *length)
{
	const char *p;
	char *end;
	long long l;

	if (!(p = strcasestr(s, "\r\nContent-Length:")))
		return -1;

	p += sizeof("\r\nContent-Length:") - 1;
	p += strspn(p, " \t");

	if (!isdigit((unsigned char)*p))
		return -1;

	errno = 0;
	l = strtoll(p, &end, 10);
	if (errno || p == end || (*end != '\0' && *end != '\r') || l < 0)
		return -1;

	*length = l;

	return 0;
}

int
uri_parse(const char *s, struct uri *u)
{
	const char *p = s;
	char *endptr;
	size_t i;
	long l;

	u->proto[0] = u->userinfo[0] = u->host[0] = u->port[0] = '\0';
	u->path[0] = u->query[0] = u->fragment[0] = '\0';

	/* protocol-relative */
	if (*p == '/' && *(p + 1) == '/') {
		p += 2; /* skip "//" */
		goto parseauth;
	}

	/* scheme / protocol part */
	for (; isalpha((unsigned char)*p) || isdigit((unsigned char)*p) ||
		       *p == '+' || *p == '-' || *p == '.'; p++)
		;
	/* scheme, except if empty and starts with ":" then it is a path */
	if (*p == ':' && p != s) {
		if (*(p + 1) == '/' && *(p + 2) == '/')
			p += 3; /* skip "://" */
		else
			p++; /* skip ":" */

		if ((size_t)(p - s) >= sizeof(u->proto))
			return -1; /* protocol too long */
		memcpy(u->proto, s, p - s);
		u->proto[p - s] = '\0';

		if (*(p - 1) != '/')
			goto parsepath;
	} else {
		p = s; /* no scheme format, reset to start */
		goto parsepath;
	}

parseauth:
	/* userinfo (username:password) */
	i = strcspn(p, "@/?#");
	if (p[i] == '@') {
		if (i >= sizeof(u->userinfo))
			return -1; /* userinfo too long */
		memcpy(u->userinfo, p, i);
		u->userinfo[i] = '\0';
		p += i + 1;
	}

	/* IPv6 address */
	if (*p == '[') {
		/* bracket not found, host too short or too long */
		i = strcspn(p, "]");
		if (p[i] != ']' || i < 3)
			return -1;
		i++; /* including "]" */
	} else {
		/* domain / host part, skip until port, path or end. */
		i = strcspn(p, ":/?#");
	}
	if (i >= sizeof(u->host))
		return -1; /* host too long */
	memcpy(u->host, p, i);
	u->host[i] = '\0';
	p += i;

	/* port */
	if (*p == ':') {
		p++;
		if ((i = strcspn(p, "/?#")) >= sizeof(u->port))
			return -1; /* port too long */
		memcpy(u->port, p, i);
		u->port[i] = '\0';
		/* check for valid port: range 1 - 65535, may be empty */
		errno = 0;
		l = strtol(u->port, &endptr, 10);
		if (i && (errno || *endptr || l <= 0 || l > 65535))
			return -1;
		p += i;
	}

parsepath:
	/* path */
	if ((i = strcspn(p, "?#")) >= sizeof(u->path))
		return -1; /* path too long */
	memcpy(u->path, p, i);
	u->path[i] = '\0';
	p += i;

	/* query */
	if (*p == '?') {
		p++;
		if ((i = strcspn(p, "#")) >= sizeof(u->query))
			return -1; /* query too long */
		memcpy(u->query, p, i);
		u->query[i] = '\0';
		p += i;
	}

	/* fragment */
	if (*p == '#') {
		p++;
		if ((i = strlen(p)) >= sizeof(u->fragment))
			return -1; /* fragment too long */
		memcpy(u->fragment, p, i);
		u->fragment[i] = '\0';
	}

	return 0;
}

int
edial(const char *host, const char *port)
{
	struct addrinfo hints, *res, *res0;
	int error, save_errno, s;
	const char *cause = NULL;

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_NUMERICSERV; /* numeric port only */
	if ((error = getaddrinfo(host, port, &hints, &res0)))
		errx(1, "%s: %s: %s:%s", __func__, gai_strerror(error), host, port);
	s = -1;
	for (res = res0; res; res = res->ai_next) {
		s = socket(res->ai_family, res->ai_socktype,
		           res->ai_protocol);
		if (s == -1) {
			cause = "socket";
			continue;
		}

		if (connect(s, res->ai_addr, res->ai_addrlen) == -1) {
			cause = "connect";
			save_errno = errno;
			close(s);
			errno = save_errno;
			s = -1;
			continue;
		}
		break;
	}
	if (s == -1)
		errx(1, "%s: %s: %s:%s", __func__, cause, host, port);
	freeaddrinfo(res0);

	return s;
}

void
setup_plain(void)
{
	if (pledge("stdio dns inet", NULL) == -1)
		err(1, "pledge");

	sock = edial(u.host, u.port);
}

void
setup_tls(void)
{
	if (tls_init())
		errx(1, "tls_init failed");
	if (!(tls_config = tls_config_new()))
		errx(1, "tls config failed");
	if (config_legacy) {
		/* enable legacy cipher and negotiation. */
		if (tls_config_set_ciphers(tls_config, "legacy"))
			errx(1, "tls_config_set_ciphers: %s",
			     tls_config_error(tls_config));
	}
	if (config_ca_file) {
		if (unveil(config_ca_file, "r") == -1)
			err(1, "unveil: %s", config_ca_file);
		if (tls_config_set_ca_file(tls_config, config_ca_file) == -1)
			errx(1, "tls_config_set_ca_file: %s: %s", config_ca_file,
			     tls_config_error(tls_config));
	} else {
		if (unveil(TLS_CA_CERT_FILE, "r") == -1)
			err(1, "unveil: %s", TLS_CA_CERT_FILE);
	}

	if (pledge("stdio dns inet rpath", NULL) == -1)
		err(1, "pledge");

	if (!(t = tls_client()))
		errx(1, "tls_client: %s", tls_error(t));
	if (tls_configure(t, tls_config))
		errx(1, "tls_configure: %s", tls_error(t));

	sock = edial(u.host, u.port);
	if (tls_connect_socket(t, sock, u.host) == -1)
		errx(1, "tls_connect: %s", tls_error(t));
}

ssize_t
tls_writebuf(const char *buf, size_t buflen)
{
	const char *errstr;
	const char *p;
	size_t len;
	ssize_t r, written = 0;

	for (len = buflen, p = buf; len > 0; ) {
		r = tls_write(t, p, len);
		if (r == TLS_WANT_POLLIN || r == TLS_WANT_POLLOUT) {
			continue;
		} else if (r == -1) {
			errstr = tls_error(t);
			fprintf(stderr, "tls_write: %s\n", errstr ? errstr : "");
			return -1;
		}
		p += r;
		len -= r;
		written += r;
	}
	return written;
}

ssize_t
tls_readbuf(char *buf, size_t bufsiz)
{
	const char *errstr;
	ssize_t r, len;

	for (len = 0; bufsiz > 0;) {
		r = tls_read(t, buf + len, bufsiz);
		if (r == TLS_WANT_POLLIN || r == TLS_WANT_POLLOUT) {
			continue;
		} else if (r == 0) {
			break;
		} else if (r == -1) {
			errstr = tls_error(t);
			fprintf(stderr, "tls_read: %s\n", errstr ? errstr : "");
			return -1;
		}
		len += r;
		bufsiz -= r;
	}
	return len;
}

ssize_t
plain_writebuf(const char *buf, size_t buflen)
{
	ssize_t r;

	if ((r = write(sock, buf, buflen)) == -1)
		fprintf(stderr, "write: %s\n", strerror(errno));
	return r;
}

ssize_t
plain_readbuf(char *buf, size_t bufsiz)
{
	ssize_t r, len;

	for (len = 0; bufsiz > 0;) {
		r = read(sock, buf + len, bufsiz);
		if (r == 0) {
			break;
		} else if (r == -1) {
			fprintf(stderr, "read: %s\n", strerror(errno));
			return -1;
		}
		len += r;
		bufsiz -= r;
	}
	return len;
}

int
http_request(void)
{
	char buf[READ_BUF_SIZ], *p;
	size_t bodylen, expectedlen, n, len;
	ssize_t r;
	int cs, httpok = 0, ret = 1, stdport;

	stdport = u.port[0] == '\0' || strcmp(u.port, t ? "443" : "80") == 0;

	/* create and send HTTP header */
	r = snprintf(buf, sizeof(buf),
		"GET %s%s%s HTTP/1.0\r\n"
		"Host: %s%s%s\r\n"
		"Connection: close\r\n"
		"%s%s"
		"\r\n",
		u.path[0] ? u.path : "/",
		u.query[0] ? "?" : "", u.query,
		u.host,
		stdport ? "" : ":",
		stdport ? "" : u.port,
		config_headers, config_headers[0] ? "\r\n" : "");
	if (r < 0 || (size_t)r >= sizeof(buf)) {
		fprintf(stderr, "not writing header because it is truncated");
		goto err;
	}

	if ((r = writebuf(buf, r)) == -1)
		goto err;

	/* NOTE: HTTP header must fit in the buffer, buffer size is -1 to NUL
	         terminate the buffer for a string comparison. */
	if ((r = readbuf(buf, sizeof(buf) - 1)) == -1)
		goto err;
	len = r;
	buf[len] = '\0'; /* NUL terminate buffer */

	if (!strncmp(buf, "HTTP/1.0 200 ", sizeof("HTTP/1.0 200 ") - 1) ||
	    !strncmp(buf, "HTTP/1.1 200 ", sizeof("HTTP/1.1 200 ") - 1))
		httpok = 1;

	if (!(p = strstr(buf, "\r\n\r\n"))) {
		fprintf(stderr, "no HTTP header found or header too big\n");
		goto err;
	}
	*p = '\0'; /* NUL terminate header part */
	cs = parse_content_length(buf, &expectedlen);
	p += strlen("\r\n\r\n");
	bodylen = len - (p - buf); /* (partial) body after header */

	if (httpok) {
		n = len - (p - buf);
		fwrite(p, 1, n, stdout);
		if (ferror(stdout)) {
			fprintf(stderr, "fwrite: stdout: %s\n", strerror(errno));
			goto err;
		}
	} else {
		/* if not 200 OK print header */
		fputs(buf, stderr);
		fputs("\r\n\r\n", stderr);
		/* NOTE: we are nice and keep reading (not closing) until the server is done. */
	}

	while ((r = readbuf(buf, sizeof(buf))) > 0) {
		len += r;
		bodylen += r;

		if (httpok) {
			fwrite(buf, 1, r, stdout);
			if (ferror(stdout)) {
				fprintf(stderr, "fwrite: stdout: %s\n", strerror(errno));
				goto err;
			}
		}

		if (config_maxresponsesiz && len >= config_maxresponsesiz)
			break;
	}
	if (r == -1)
		goto err;
	if (config_maxresponsesiz && len >= config_maxresponsesiz) {
		fprintf(stderr, "response too big: %zu >= %zu\n",
		        len, config_maxresponsesiz);
		goto err;
	}
	if (cs != -1 && expectedlen != bodylen) {
		fprintf(stderr, "Content-Length mismatch: %zu expected != %zu received\n",
		        expectedlen, bodylen);
		goto err;
	}
	ret = 0;

err:
	return httpok ? ret : 2;
}

int
gopher_request(void)
{
	char buf[READ_BUF_SIZ];
	const char *path;
	size_t len = 0;
	ssize_t r;
	int ret = 1;

	/* create and send path, skip type part, empty path is allowed,
	   see RFC 4266 The gopher URI Scheme - section 2.1 */
	path = u.path;
	if (*path == '/') {
		path++;
		if (*path)
			path++; /* skip type */
	}

	r = snprintf(buf, sizeof(buf), "%s%s%s\r\n",
		path, u.query[0] ? "?" : "", u.query);
	if (r < 0 || (size_t)r >= sizeof(buf)) {
		fprintf(stderr, "not writing header because it is truncated");
		goto err;
	}

	if ((r = writebuf(buf, r)) == -1)
		goto err;

	while ((r = readbuf(buf, sizeof(buf))) > 0) {
		len += r;

		fwrite(buf, 1, r, stdout);
		if (ferror(stdout)) {
			fprintf(stderr, "fwrite: stdout: %s\n", strerror(errno));
			goto err;
		}

		if (config_maxresponsesiz && len >= config_maxresponsesiz)
			break;
	}
	if (r == -1)
		goto err;

	if (config_maxresponsesiz && len >= config_maxresponsesiz) {
		fprintf(stderr, "response too big: %zu >= %zu\n",
		        len, config_maxresponsesiz);
		goto err;
	}
	ret = 0;

err:
	return ret;
}

void
usage(void)
{
	fprintf(stderr, "usage: %s [-c ca_file] [-H headers] [-l] "
	        "[-m maxresponse] [-t timeout] url\n", argv0);
	exit(1);
}

int
main(int argc, char **argv)
{
	char *end;
	size_t i;
	int statuscode;
	long long l;

	ARGBEGIN {
	case 'c':
		config_ca_file = EARGF(usage());
		break;
	case 'H': /* header(s) */
		config_headers = EARGF(usage());
		break;
	case 'l': /* legacy ciphers */
		config_legacy = 1;
		break;
	case 'm': /* max filesize */
		errno = 0;
		l = strtoll(EARGF(usage()), &end, 10);
		if (errno || *end != '\0' || l < 0)
			usage();
		config_maxresponsesiz = l;
		break;
	case 't': /* timeout */
		errno = 0;
		l = strtoll(EARGF(usage()), &end, 10);
		if (errno || *end != '\0' || l < 0 || l >= 65535)
			usage();
		config_timeout = l;
		break;
	default:
		usage();
	} ARGEND

	if (argc != 1)
		usage();

	url = argv[0];
	if (uri_parse(url, &u) == -1)
		errx(1, "invalid URL: %s", url);
	if (u.userinfo[0])
		errx(1, "userinfo field not supported in the URL: %s", url);

	if (config_timeout > 0) {
		signal(SIGALRM, sighandler);
		alarm(config_timeout);
	}

	/* match a protocol handler */
	for (i = 0; i < sizeof(handlers) / sizeof(*handlers); i++) {
		if (strcmp(u.proto, handlers[i].proto))
			continue;
		if (!u.port[0])
			strcpy(u.port, handlers[i].port); /* default port if unset */

		/* setup TLS or plain connection */
		if (handlers[i].usetls) {
			setup_tls();
			readbuf = tls_readbuf;
			writebuf = tls_writebuf;
		} else {
			setup_plain();
			readbuf = plain_readbuf;
			writebuf = plain_writebuf;
		}

		if (pledge("stdio", NULL) == -1)
			err(1, "pledge");

		statuscode = handlers[i].handler();

		/* cleanup TLS and plain connection */
		if (t) {
			tls_close(t);
			tls_free(t);
		}
		if (sock != -1)
			close(sock);

		return statuscode;
	}
	if (u.proto[0])
		errx(1, "unsupported protocol specified: %s", u.proto);
	else
		errx(1, "no protocol specified");

	return 1;
}

This webpage is intended to be an accessible preview of this repository. To get a fuller picture, clone it and use the git CLI.