about summary refs log tree commit diff
path: root/url.c
diff options
context:
space:
mode:
Diffstat (limited to 'url.c')
-rw-r--r--url.c304
1 files changed, 236 insertions, 68 deletions
diff --git a/url.c b/url.c
index 21d93e6..7da0968 100644
--- a/url.c
+++ b/url.c
@@ -1,21 +1,35 @@
-/* Copyright (C) 2018  C. McEnroe <june@causal.agency>
+/* Copyright (C) 2020  June McEnroe <june@causal.agency>
  *
  * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
+ * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Additional permission under GNU GPL version 3 section 7:
+ *
+ * If you modify this Program, or any covered work, by linking or
+ * combining it with OpenSSL (or a modified version of that library),
+ * containing parts covered by the terms of the OpenSSL License and the
+ * original SSLeay license, the licensors of this Program grant you
+ * additional permission to convey the resulting work. Corresponding
+ * Source for a non-source form of such a combination shall include the
+ * source code for the parts of OpenSSL used as well as that of the
+ * covered work.
  */
 
-#include <assert.h>
 #include <err.h>
+#include <errno.h>
+#include <limits.h>
+#include <regex.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
@@ -23,89 +37,243 @@
 
 #include "chat.h"
 
-static const char *Schemes[] = {
-	"cvs:",
-	"ftp:",
-	"git:",
-	"http:",
-	"https:",
-	"irc:",
-	"ircs:",
-	"magnet:",
-	"sftp:",
-	"ssh:",
-	"svn:",
-	"telnet:",
-	"vnc:",
+static const char *Pattern = {
+	"("
+	"cvs|"
+	"ftp|"
+	"gemini|"
+	"git|"
+	"gopher|"
+	"http|"
+	"https|"
+	"irc|"
+	"ircs|"
+	"magnet|"
+	"sftp|"
+	"ssh|"
+	"svn|"
+	"telnet|"
+	"vnc"
+	")"
+	":([^[:space:]>\"()]|[(][^)]*[)])+"
 };
-static const size_t SchemesLen = sizeof(Schemes) / sizeof(Schemes[0]);
+static regex_t Regex;
 
-struct Entry {
-	size_t tag;
+static void compile(void) {
+	static bool compiled;
+	if (compiled) return;
+	compiled = true;
+	int error = regcomp(&Regex, Pattern, REG_EXTENDED);
+	if (!error) return;
+	char buf[256];
+	regerror(error, &Regex, buf, sizeof(buf));
+	errx(EX_SOFTWARE, "regcomp: %s: %s", buf, Pattern);
+}
+
+struct URL {
+	uint id;
+	char *nick;
 	char *url;
 };
 
-enum { RingLen = 32 };
-static_assert(!(RingLen & (RingLen - 1)), "power of two RingLen");
-
+enum { Cap = 64 };
 static struct {
-	struct Entry buf[RingLen];
-	size_t end;
+	struct URL urls[Cap];
+	size_t len;
 } ring;
+_Static_assert(!(Cap & (Cap - 1)), "Cap is power of two");
 
-static void ringPush(struct Tag tag, const char *url, size_t len) {
-	free(ring.buf[ring.end].url);
-	ring.buf[ring.end].tag = tag.id;
-	ring.buf[ring.end].url = strndup(url, len);
-	if (!ring.buf[ring.end].url) err(EX_OSERR, "strndup");
-	ring.end = (ring.end + 1) & (RingLen - 1);
+static void push(uint id, const char *nick, const char *str, size_t len) {
+	struct URL *url = &ring.urls[ring.len++ % Cap];
+	free(url->nick);
+	free(url->url);
+
+	url->id = id;
+	url->nick = NULL;
+	if (nick) {
+		url->nick = strdup(nick);
+		if (!url->nick) err(EX_OSERR, "strdup");
+	}
+	url->url = malloc(len + 1);
+	if (!url->url) err(EX_OSERR, "malloc");
+
+	char buf[1024];
+	snprintf(buf, sizeof(buf), "%.*s", (int)len, str);
+	styleStrip(url->url, len + 1, buf);
 }
 
-static struct Entry ringEntry(size_t i) {
-	return ring.buf[(ring.end + i) & (RingLen - 1)];
+void urlScan(uint id, const char *nick, const char *mesg) {
+	if (!mesg) return;
+	compile();
+	regmatch_t match = {0};
+	for (const char *ptr = mesg; *ptr; ptr += match.rm_eo) {
+		if (regexec(&Regex, ptr, 1, &match, 0)) break;
+		push(id, nick, &ptr[match.rm_so], match.rm_eo - match.rm_so);
+	}
 }
 
-void urlScan(struct Tag tag, const char *str) {
-	while (str[0]) {
-		size_t len = 1;
-		for (size_t i = 0; i < SchemesLen; ++i) {
-			if (strncmp(str, Schemes[i], strlen(Schemes[i]))) continue;
-			len = strcspn(str, " >\"");
-			ringPush(tag, str, len);
+struct Util urlOpenUtil;
+static const struct Util OpenUtils[] = {
+	{ 1, { "open" } },
+	{ 1, { "xdg-open" } },
+};
+
+static void urlOpen(const char *url) {
+	pid_t pid = fork();
+	if (pid < 0) err(EX_OSERR, "fork");
+	if (pid) return;
+
+	setsid();
+	close(STDIN_FILENO);
+	dup2(utilPipe[1], STDOUT_FILENO);
+	dup2(utilPipe[1], STDERR_FILENO);
+	if (urlOpenUtil.argc) {
+		struct Util util = urlOpenUtil;
+		utilPush(&util, url);
+		execvp(util.argv[0], (char *const *)util.argv);
+		warn("%s", util.argv[0]);
+		_exit(EX_CONFIG);
+	}
+	for (size_t i = 0; i < ARRAY_LEN(OpenUtils); ++i) {
+		struct Util util = OpenUtils[i];
+		utilPush(&util, url);
+		execvp(util.argv[0], (char *const *)util.argv);
+		if (errno != ENOENT) {
+			warn("%s", util.argv[0]);
+			_exit(EX_CONFIG);
 		}
-		str = &str[len];
 	}
+	warnx("no open utility found");
+	_exit(EX_CONFIG);
 }
 
-void urlList(struct Tag tag) {
-	uiHide();
-	for (size_t i = 0; i < RingLen; ++i) {
-		struct Entry entry = ringEntry(i);
-		if (!entry.url || entry.tag != tag.id) continue;
-		printf("%s\n", entry.url);
+struct Util urlCopyUtil;
+static const struct Util CopyUtils[] = {
+	{ 1, { "pbcopy" } },
+	{ 1, { "wl-copy" } },
+	{ 3, { "xclip", "-selection", "clipboard" } },
+	{ 3, { "xsel", "-i", "-b" } },
+};
+
+static void urlCopy(const char *url) {
+	int rw[2];
+	int error = pipe(rw);
+	if (error) err(EX_OSERR, "pipe");
+
+	size_t len = strlen(url);
+	if (len > PIPE_BUF) len = PIPE_BUF;
+	ssize_t n = write(rw[1], url, len);
+	if (n < 0) err(EX_IOERR, "write");
+
+	error = close(rw[1]);
+	if (error) err(EX_IOERR, "close");
+
+	pid_t pid = fork();
+	if (pid < 0) err(EX_OSERR, "fork");
+	if (pid) {
+		close(rw[0]);
+		return;
+	}
+
+	setsid();
+	dup2(rw[0], STDIN_FILENO);
+	dup2(utilPipe[1], STDOUT_FILENO);
+	dup2(utilPipe[1], STDERR_FILENO);
+	close(rw[0]);
+	if (urlCopyUtil.argc) {
+		execvp(urlCopyUtil.argv[0], (char *const *)urlCopyUtil.argv);
+		warn("%s", urlCopyUtil.argv[0]);
+		_exit(EX_CONFIG);
+	}
+	for (size_t i = 0; i < ARRAY_LEN(CopyUtils); ++i) {
+		execvp(CopyUtils[i].argv[0], (char *const *)CopyUtils[i].argv);
+		if (errno != ENOENT) {
+			warn("%s", CopyUtils[i].argv[0]);
+			_exit(EX_CONFIG);
+		}
+	}
+	warnx("no copy utility found");
+	_exit(EX_CONFIG);
+}
+
+void urlOpenCount(uint id, uint count) {
+	for (uint i = 1; i <= Cap; ++i) {
+		const struct URL *url = &ring.urls[(ring.len - i) % Cap];
+		if (!url->url) break;
+		if (url->id != id) continue;
+		urlOpen(url->url);
+		if (!--count) break;
+	}
+}
+
+void urlOpenMatch(uint id, const char *str) {
+	for (uint i = 1; i <= Cap; ++i) {
+		const struct URL *url = &ring.urls[(ring.len - i) % Cap];
+		if (!url->url) break;
+		if (url->id != id) continue;
+		if ((url->nick && !strcmp(url->nick, str)) || strstr(url->url, str)) {
+			urlOpen(url->url);
+			break;
+		}
 	}
 }
 
-void urlOpenMatch(struct Tag tag, const char *substr) {
-	for (size_t i = RingLen - 1; i < RingLen; --i) {
-		struct Entry entry = ringEntry(i);
-		if (!entry.url || entry.tag != tag.id) continue;
-		if (!strstr(entry.url, substr)) continue;
-		eventPipe((const char *[]) { "open", entry.url, NULL });
-		break;
+void urlCopyMatch(uint id, const char *str) {
+	for (uint i = 1; i <= Cap; ++i) {
+		const struct URL *url = &ring.urls[(ring.len - i) % Cap];
+		if (!url->url) break;
+		if (url->id != id) continue;
+		if (
+			!str
+			|| (url->nick && !strcmp(url->nick, str))
+			|| strstr(url->url, str)
+		) {
+			urlCopy(url->url);
+			break;
+		}
 	}
 }
 
-void urlOpenRange(struct Tag tag, size_t at, size_t to) {
-	size_t argc = 1;
-	const char *argv[2 + RingLen] = { "open" };
-	size_t tagIndex = 0;
-	for (size_t i = RingLen - 1; i < RingLen; --i) {
-		struct Entry entry = ringEntry(i);
-		if (!entry.url || entry.tag != tag.id) continue;
-		if (tagIndex >= at && tagIndex < to) argv[argc++] = entry.url;
-		tagIndex++;
+static int writeString(FILE *file, const char *str) {
+	return (fwrite(str, strlen(str) + 1, 1, file) ? 0 : -1);
+}
+static ssize_t readString(FILE *file, char **buf, size_t *cap) {
+	ssize_t len = getdelim(buf, cap, '\0', file);
+	if (len < 0 && !feof(file)) err(EX_IOERR, "getdelim");
+	return len;
+}
+
+int urlSave(FILE *file) {
+	for (size_t i = 0; i < Cap; ++i) {
+		const struct URL *url = &ring.urls[(ring.len + i) % Cap];
+		if (!url->url) continue;
+		int error = 0
+			|| writeString(file, idNames[url->id])
+			|| writeString(file, (url->nick ?: ""))
+			|| writeString(file, url->url);
+		if (error) return error;
+	}
+	return writeString(file, "");
+}
+
+void urlLoad(FILE *file, size_t version) {
+	if (version < 5) return;
+	size_t cap = 0;
+	char *buf = NULL;
+	while (0 < readString(file, &buf, &cap) && buf[0]) {
+		struct URL *url = &ring.urls[ring.len++ % Cap];
+		free(url->nick);
+		free(url->url);
+		url->id = idFor(buf);
+		url->nick = NULL;
+		readString(file, &buf, &cap);
+		if (buf[0]) {
+			url->nick = strdup(buf);
+			if (!url->nick) err(EX_OSERR, "strdup");
+		}
+		readString(file, &buf, &cap);
+		url->url = strdup(buf);
+		if (!url->url) err(EX_OSERR, "strdup");
 	}
-	argv[argc] = NULL;
-	if (argc > 1) eventPipe(argv);
+	free(buf);
 }
generated by cgit-pink 1.4.1 (git 2.36.1) at 2024-05-16 19:07:21 +0000