catgirl/url.c

203 lines
4.6 KiB
C
Raw Normal View History

2020-02-08 23:29:01 +00:00
/* Copyright (C) 2020 C. McEnroe <june@causal.agency>
*
* This program is free software: you can redistribute it and/or modify
* 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
2020-02-09 00:04:25 +00:00
#include <assert.h>
2020-02-08 23:29:01 +00:00
#include <err.h>
2020-02-09 00:04:25 +00:00
#include <errno.h>
2020-02-08 23:29:01 +00:00
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sysexits.h>
2020-02-09 00:04:25 +00:00
#include <unistd.h>
2020-02-08 23:29:01 +00:00
#include "chat.h"
static const char *Pattern = {
"("
"cvs|"
"ftp|"
"git|"
"gopher|"
"http|"
"https|"
"irc|"
"ircs|"
"magnet|"
"sftp|"
"ssh|"
"svn|"
"telnet|"
"vnc"
")"
":([^[:space:]>\"()]|[(][^)]*[)])+"
2020-02-08 23:29:01 +00:00
};
static regex_t Regex;
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);
}
2020-02-09 00:04:25 +00:00
struct URL {
size_t id;
char *nick;
char *url;
};
2020-02-08 23:29:01 +00:00
enum { Cap = 32 };
static struct {
2020-02-09 00:04:25 +00:00
struct URL urls[Cap];
2020-02-08 23:29:01 +00:00
size_t len;
} ring;
2020-02-09 00:04:25 +00:00
static_assert(!(Cap & (Cap - 1)), "Cap is power of two");
2020-02-08 23:29:01 +00:00
2020-02-09 00:04:25 +00:00
static void push(size_t 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;
2020-02-08 23:29:01 +00:00
if (nick) {
2020-02-09 00:04:25 +00:00
url->nick = strdup(nick);
if (!url->nick) err(EX_OSERR, "strdup");
2020-02-08 23:29:01 +00:00
}
2020-02-09 00:04:25 +00:00
url->url = strndup(str, len);
if (!url->url) err(EX_OSERR, "strndup");
2020-02-08 23:29:01 +00:00
}
void urlScan(size_t 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);
}
}
2020-02-09 02:21:21 +00:00
const char *urlOpenUtil;
static const char *OpenUtils[] = { "open", "xdg-open" };
2020-02-09 00:04:25 +00:00
static void urlOpen(const char *url) {
pid_t pid = fork();
if (pid < 0) err(EX_OSERR, "fork");
if (pid) return;
close(STDIN_FILENO);
dup2(procPipe[1], STDOUT_FILENO);
dup2(procPipe[1], STDERR_FILENO);
2020-02-09 02:21:21 +00:00
if (urlOpenUtil) {
execlp(urlOpenUtil, urlOpenUtil, url, NULL);
warn("%s", urlOpenUtil);
_exit(EX_CONFIG);
}
for (size_t i = 0; i < ARRAY_LEN(OpenUtils); ++i) {
execlp(OpenUtils[i], OpenUtils[i], url, NULL);
2020-02-09 00:04:25 +00:00
if (errno != ENOENT) {
2020-02-09 02:21:21 +00:00
warn("%s", OpenUtils[i]);
2020-02-09 00:04:25 +00:00
_exit(EX_CONFIG);
}
}
warnx("no open utility found");
_exit(EX_CONFIG);
}
2020-02-09 02:44:50 +00:00
const char *urlCopyUtil;
static const char *CopyUtils[] = { "pbcopy", "wl-copy", "xclip", "xsel" };
static void urlCopy(const char *url) {
int rw[2];
int error = pipe(rw);
if (error) err(EX_OSERR, "pipe");
ssize_t len = write(rw[1], url, strlen(url));
if (len < 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;
}
dup2(rw[0], STDIN_FILENO);
dup2(procPipe[1], STDOUT_FILENO);
dup2(procPipe[1], STDERR_FILENO);
close(rw[0]);
if (urlCopyUtil) {
execlp(urlCopyUtil, urlCopyUtil, NULL);
warn("%s", urlCopyUtil);
_exit(EX_CONFIG);
}
for (size_t i = 0; i < ARRAY_LEN(CopyUtils); ++i) {
execlp(CopyUtils[i], CopyUtils[i], NULL);
if (errno != ENOENT) {
warn("%s", CopyUtils[i]);
_exit(EX_CONFIG);
}
}
warnx("no copy utility found");
_exit(EX_CONFIG);
}
2020-02-08 23:29:01 +00:00
void urlOpenCount(size_t id, size_t count) {
2020-02-09 00:04:25 +00:00
for (size_t 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;
}
2020-02-08 23:29:01 +00:00
}
void urlOpenMatch(size_t id, const char *str) {
2020-02-09 00:04:25 +00:00
for (size_t 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;
}
}
2020-02-08 23:29:01 +00:00
}
2020-02-09 02:44:50 +00:00
void urlCopyMatch(size_t id, const char *str) {
for (size_t 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;
}
}
}