catboy/handle.c

535 lines
14 KiB
C
Raw Normal View History

2020-02-01 06:18: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-08 05:25:09 +00:00
#include <assert.h>
2020-02-06 09:18:15 +00:00
#include <ctype.h>
2020-02-01 06:18:01 +00:00
#include <err.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sysexits.h>
#include "chat.h"
2020-02-08 08:15:17 +00:00
struct Replies replies;
2020-02-01 06:18:01 +00:00
static const char *CapNames[] = {
2020-02-01 07:19:55 +00:00
#define X(name, id) [id##Bit] = name,
2020-02-01 06:18:01 +00:00
ENUM_CAP
#undef X
};
static enum Cap capParse(const char *list) {
enum Cap caps = 0;
while (*list) {
enum Cap cap = 0;
size_t len = strcspn(list, " ");
for (size_t i = 0; i < ARRAY_LEN(CapNames); ++i) {
if (len != strlen(CapNames[i])) continue;
if (strncmp(list, CapNames[i], len)) continue;
cap = 1 << i;
break;
}
caps |= cap;
list += len;
if (*list) list++;
}
return caps;
}
static const char *capList(enum Cap caps) {
static char buf[1024];
buf[0] = '\0';
for (size_t i = 0; i < ARRAY_LEN(CapNames); ++i) {
if (caps & (1 << i)) {
if (buf[0]) strlcat(buf, " ", sizeof(buf));
strlcat(buf, CapNames[i], sizeof(buf));
}
}
return buf;
}
static void require(struct Message *msg, bool origin, size_t len) {
if (origin) {
if (!msg->nick) errx(EX_PROTOCOL, "%s missing origin", msg->cmd);
if (!msg->user) msg->user = msg->nick;
if (!msg->host) msg->host = msg->user;
2020-02-01 06:18:01 +00:00
}
for (size_t i = 0; i < len; ++i) {
if (msg->params[i]) continue;
errx(EX_PROTOCOL, "%s missing parameter %zu", msg->cmd, 1 + i);
}
}
2020-02-03 23:41:52 +00:00
static const time_t *tagTime(const struct Message *msg) {
static time_t time;
struct tm tm;
2020-02-02 06:58:03 +00:00
if (!msg->tags[TagTime]) return NULL;
2020-02-03 23:41:52 +00:00
if (!strptime(msg->tags[TagTime], "%FT%T", &tm)) return NULL;
time = timegm(&tm);
return &time;
2020-02-02 06:58:03 +00:00
}
typedef void Handler(struct Message *msg);
2020-02-02 07:30:35 +00:00
static void handleErrorNicknameInUse(struct Message *msg) {
if (self.nick) return;
require(msg, false, 2);
ircFormat("NICK :%s_\r\n", msg->params[1]);
}
static void handleErrorErroneousNickname(struct Message *msg) {
require(msg, false, 3);
errx(EX_CONFIG, "%s: %s", msg->params[1], msg->params[2]);
}
2020-02-01 06:18:01 +00:00
static void handleCap(struct Message *msg) {
require(msg, false, 3);
enum Cap caps = capParse(msg->params[2]);
if (!strcmp(msg->params[1], "LS")) {
caps &= ~CapSASL;
if (caps) {
ircFormat("CAP REQ :%s\r\n", capList(caps));
} else {
if (!(self.caps & CapSASL)) ircFormat("CAP END\r\n");
}
2020-02-01 06:18:01 +00:00
} else if (!strcmp(msg->params[1], "ACK")) {
self.caps |= caps;
if (caps & CapSASL) {
ircFormat("AUTHENTICATE %s\r\n", (self.plain ? "PLAIN" : "EXTERNAL"));
}
if (!(self.caps & CapSASL)) ircFormat("CAP END\r\n");
} else if (!strcmp(msg->params[1], "NAK")) {
errx(EX_CONFIG, "server does not support %s", msg->params[2]);
}
}
static void handleAuthenticate(struct Message *msg) {
(void)msg;
if (!self.plain) {
ircFormat("AUTHENTICATE +\r\n");
return;
}
byte buf[299];
size_t len = 1 + strlen(self.plain);
if (sizeof(buf) < len) errx(EX_CONFIG, "SASL PLAIN is too long");
buf[0] = 0;
for (size_t i = 0; self.plain[i]; ++i) {
buf[1 + i] = (self.plain[i] == ':' ? 0 : self.plain[i]);
}
char b64[BASE64_SIZE(sizeof(buf))];
base64(b64, buf, len);
ircFormat("AUTHENTICATE ");
ircSend(b64, BASE64_SIZE(len));
ircFormat("\r\n");
explicit_bzero(b64, sizeof(b64));
explicit_bzero(buf, sizeof(buf));
explicit_bzero(self.plain, strlen(self.plain));
}
static void handleReplyLoggedIn(struct Message *msg) {
(void)msg;
ircFormat("CAP END\r\n");
}
static void handleErrorSASLFail(struct Message *msg) {
require(msg, false, 2);
errx(EX_CONFIG, "%s", msg->params[1]);
}
static void handleReplyWelcome(struct Message *msg) {
require(msg, false, 1);
set(&self.nick, msg->params[0]);
completeTouch(None, self.nick, Default);
2020-02-08 08:15:17 +00:00
if (self.join) {
size_t count = 1;
for (const char *ch = self.join; *ch && *ch != ' '; ++ch) {
if (*ch == ',') count++;
}
ircFormat("JOIN %s\r\n", self.join);
replies.topic += count;
replies.names += count;
}
2020-02-01 06:18:01 +00:00
}
static void handleReplyISupport(struct Message *msg) {
for (size_t i = 1; i < ParamCap; ++i) {
if (!msg->params[i]) break;
char *key = strsep(&msg->params[i], "=");
if (!msg->params[i]) continue;
if (!strcmp(key, "NETWORK")) {
set(&self.network, msg->params[i]);
2020-02-02 06:58:03 +00:00
uiFormat(
Network, Cold, tagTime(msg),
"You arrive in %s", msg->params[i]
);
} else if (!strcmp(key, "CHANTYPES")) {
set(&self.chanTypes, msg->params[i]);
} else if (!strcmp(key, "PREFIX")) {
strsep(&msg->params[i], ")");
if (!msg->params[i]) continue;
set(&self.prefixes, msg->params[i]);
}
}
}
static void handleReplyMOTD(struct Message *msg) {
require(msg, false, 2);
char *line = msg->params[1];
2020-02-08 23:29:01 +00:00
urlScan(Network, msg->nick, line);
2020-02-05 05:24:54 +00:00
if (!strncmp(line, "- ", 2)) {
uiFormat(Network, Cold, tagTime(msg), "\3%d-\3\t%s", Gray, &line[2]);
} else {
uiFormat(Network, Cold, tagTime(msg), "%s", line);
}
2020-02-02 06:58:03 +00:00
}
static void handleJoin(struct Message *msg) {
require(msg, true, 1);
size_t id = idFor(msg->params[0]);
if (self.nick && !strcmp(msg->nick, self.nick)) {
2020-02-05 05:40:24 +00:00
if (!self.user) {
set(&self.user, msg->user);
self.color = hash(msg->user);
}
2020-02-02 08:27:50 +00:00
idColors[id] = hash(msg->params[0]);
completeTouch(None, msg->params[0], idColors[id]);
uiShowID(id);
}
completeTouch(id, msg->nick, hash(msg->user));
if (msg->params[2] && !strcasecmp(msg->params[2], msg->nick)) {
msg->params[2] = NULL;
}
uiFormat(
id, Cold, tagTime(msg),
"\3%02d%s\3\t%s%s%sarrives in \3%02d%s\3",
hash(msg->user), msg->nick,
(msg->params[2] ? "(" : ""),
(msg->params[2] ? msg->params[2] : ""),
(msg->params[2] ? ") " : ""),
hash(msg->params[0]), msg->params[0]
);
}
2020-02-06 06:16:35 +00:00
static void handlePart(struct Message *msg) {
require(msg, true, 1);
size_t id = idFor(msg->params[0]);
2020-02-08 04:44:03 +00:00
if (self.nick && !strcmp(msg->nick, self.nick)) {
completeClear(id);
}
completeRemove(id, msg->nick);
2020-02-08 23:29:01 +00:00
urlScan(id, msg->nick, msg->params[1]);
2020-02-06 06:16:35 +00:00
uiFormat(
id, Cold, tagTime(msg),
2020-02-06 06:16:35 +00:00
"\3%02d%s\3\tleaves \3%02d%s\3%s%s",
2020-02-06 07:07:39 +00:00
hash(msg->user), msg->nick, hash(msg->params[0]), msg->params[0],
2020-02-06 06:16:35 +00:00
(msg->params[1] ? ": " : ""),
(msg->params[1] ? msg->params[1] : "")
);
}
static void handleKick(struct Message *msg) {
require(msg, true, 2);
size_t id = idFor(msg->params[0]);
bool kicked = self.nick && !strcmp(msg->params[1], self.nick);
completeTouch(id, msg->nick, hash(msg->user));
2020-02-08 23:29:01 +00:00
urlScan(id, msg->nick, msg->params[2]);
uiFormat(
id, (kicked ? Hot : Cold), tagTime(msg),
"%s\3%02d%s\17\tkicks \3%02d%s\3 out of \3%02d%s\3%s%s",
(kicked ? "\26" : ""),
hash(msg->user), msg->nick,
completeColor(id, msg->params[1]), msg->params[1],
hash(msg->params[0]), msg->params[0],
(msg->params[2] ? ": " : ""),
(msg->params[2] ? msg->params[2] : "")
);
completeRemove(id, msg->params[1]);
if (kicked) completeClear(id);
}
2020-02-08 05:36:23 +00:00
static void handleNick(struct Message *msg) {
require(msg, true, 1);
if (self.nick && !strcmp(msg->nick, self.nick)) {
set(&self.nick, msg->params[0]);
}
size_t id;
while (None != (id = completeID(msg->nick))) {
uiFormat(
id, Cold, tagTime(msg),
"\3%02d%s\3\tis now known as \3%02d%s\3",
hash(msg->user), msg->nick, hash(msg->user), msg->params[0]
);
}
completeReplace(None, msg->nick, msg->params[0]);
}
static void handleQuit(struct Message *msg) {
require(msg, true, 0);
size_t id;
while (None != (id = completeID(msg->nick))) {
2020-02-08 23:29:01 +00:00
urlScan(id, msg->nick, msg->params[0]);
2020-02-08 05:36:23 +00:00
uiFormat(
id, Cold, tagTime(msg),
"\3%02d%s\3\tleaves%s%s",
hash(msg->user), msg->nick,
(msg->params[0] ? ": " : ""),
(msg->params[0] ? msg->params[0] : "")
);
}
completeRemove(None, msg->nick);
}
2020-02-08 05:25:09 +00:00
static void handleReplyNames(struct Message *msg) {
require(msg, false, 4);
size_t id = idFor(msg->params[2]);
char buf[1024];
size_t len = 0;
while (msg->params[3]) {
char *name = strsep(&msg->params[3], " ");
name += strspn(name, self.prefixes);
char *nick = strsep(&name, "!");
char *user = strsep(&name, "@");
enum Color color = (user ? hash(user) : Default);
completeAdd(id, nick, color);
if (!replies.names) continue;
2020-02-08 05:25:09 +00:00
int n = snprintf(
&buf[len], sizeof(buf) - len,
"%s\3%02d%s\3", (len ? ", " : ""), color, nick
);
assert(n > 0 && len + n < sizeof(buf));
len += n;
}
if (!replies.names) return;
2020-02-08 05:25:09 +00:00
uiFormat(
id, Cold, tagTime(msg),
"In \3%02d%s\3 are %s",
hash(msg->params[2]), msg->params[2], buf
);
}
2020-02-08 08:15:17 +00:00
static void handleReplyEndOfNames(struct Message *msg) {
(void)msg;
if (replies.names) replies.names--;
}
2020-02-06 07:07:39 +00:00
static void handleReplyNoTopic(struct Message *msg) {
require(msg, false, 2);
2020-02-08 08:15:17 +00:00
if (!replies.topic) return;
replies.topic--;
2020-02-06 07:07:39 +00:00
uiFormat(
idFor(msg->params[1]), Cold, tagTime(msg),
"There is no sign in \3%02d%s\3",
hash(msg->params[1]), msg->params[1]
);
}
static void handleReplyTopic(struct Message *msg) {
require(msg, false, 3);
2020-02-08 08:15:17 +00:00
if (!replies.topic) return;
replies.topic--;
2020-02-08 23:29:01 +00:00
size_t id = idFor(msg->params[1]);
urlScan(id, NULL, msg->params[2]);
2020-02-06 07:07:39 +00:00
uiFormat(
2020-02-08 23:29:01 +00:00
id, Cold, tagTime(msg),
2020-02-06 07:07:39 +00:00
"The sign in \3%02d%s\3 reads: %s",
hash(msg->params[1]), msg->params[1], msg->params[2]
);
}
static void handleTopic(struct Message *msg) {
require(msg, true, 2);
2020-02-08 23:29:01 +00:00
size_t id = idFor(msg->params[0]);
2020-02-06 07:07:39 +00:00
if (msg->params[1][0]) {
2020-02-08 23:29:01 +00:00
urlScan(id, msg->nick, msg->params[1]);
2020-02-06 07:07:39 +00:00
uiFormat(
2020-02-08 23:29:01 +00:00
id, Warm, tagTime(msg),
2020-02-06 07:07:39 +00:00
"\3%02d%s\3\tplaces a new sign in \3%02d%s\3: %s",
hash(msg->user), msg->nick, hash(msg->params[0]), msg->params[0],
msg->params[1]
);
} else {
uiFormat(
2020-02-08 23:29:01 +00:00
id, Warm, tagTime(msg),
2020-02-06 07:07:39 +00:00
"\3%02d%s\3\tremoves the sign in \3%02d%s\3",
hash(msg->user), msg->nick, hash(msg->params[0]), msg->params[0]
);
}
}
2020-02-02 22:26:20 +00:00
static bool isAction(struct Message *msg) {
if (strncmp(msg->params[1], "\1ACTION ", 8)) return false;
msg->params[1] += 8;
size_t len = strlen(msg->params[1]);
if (msg->params[1][len - 1] == '\1') msg->params[1][len - 1] = '\0';
return true;
}
2020-02-06 09:18:15 +00:00
static bool isMention(const struct Message *msg) {
if (!self.nick) return false;
size_t len = strlen(self.nick);
const char *match = msg->params[1];
while (NULL != (match = strcasestr(match, self.nick))) {
char a = (match > msg->params[1] ? match[-1] : ' ');
char b = (match[len] ? match[len] : ' ');
if ((isspace(a) || ispunct(a)) && (isspace(b) || ispunct(b))) {
return true;
}
match = &match[len];
}
return false;
}
static const char *colorMentions(size_t id, struct Message *msg) {
char *mention;
char final;
if (strchr(msg->params[1], ':')) {
mention = strsep(&msg->params[1], ":");
final = ':';
} else if (strchr(msg->params[1], ' ')) {
mention = strsep(&msg->params[1], " ");
final = ' ';
} else {
mention = msg->params[1];
msg->params[1] = "";
final = '\0';
}
static char buf[1024];
FILE *str = fmemopen(buf, sizeof(buf), "w");
if (!str) err(EX_OSERR, "fmemopen");
while (*mention) {
size_t skip = strspn(mention, ", ");
fwrite(mention, skip, 1, str);
mention += skip;
size_t len = strcspn(mention, ", ");
char punct = mention[len];
mention[len] = '\0';
fprintf(str, "\3%02d%s\3", completeColor(id, mention), mention);
mention[len] = punct;
mention += len;
}
fputc(final, str);
fclose(str);
buf[sizeof(buf) - 1] = '\0';
return buf;
}
2020-02-02 08:43:18 +00:00
static void handlePrivmsg(struct Message *msg) {
require(msg, true, 2);
2020-02-02 22:45:19 +00:00
bool query = !strchr(self.chanTypes, msg->params[0][0]);
2020-02-06 09:01:11 +00:00
bool network = strchr(msg->nick, '.');
bool mine = self.nick && !strcmp(msg->nick, self.nick);
size_t id;
if (query && network) {
id = Network;
} else if (query && !mine) {
id = idFor(msg->nick);
idColors[id] = hash(msg->user);
} else {
id = idFor(msg->params[0]);
}
2020-02-02 22:26:20 +00:00
bool notice = (msg->cmd[0] == 'N');
bool action = isAction(msg);
2020-02-06 09:18:15 +00:00
bool mention = !mine && isMention(msg);
if (!notice && !mine) completeTouch(id, msg->nick, hash(msg->user));
2020-02-08 23:29:01 +00:00
urlScan(id, msg->nick, msg->params[1]);
2020-02-07 03:59:49 +00:00
if (notice) {
uiFormat(
id, Warm, tagTime(msg),
"%s\3%d-%s-\17\3%d\t%s",
(mention ? "\26" : ""), hash(msg->user), msg->nick,
LightGray, msg->params[1]
);
} else if (action) {
uiFormat(
id, (mention || query ? Hot : Warm), tagTime(msg),
"%s\35\3%d* %s\17\35\t%s",
(mention ? "\26" : ""), hash(msg->user), msg->nick, msg->params[1]
);
} else {
const char *mentions = colorMentions(id, msg);
2020-02-07 03:59:49 +00:00
uiFormat(
id, (mention || query ? Hot : Warm), tagTime(msg),
"%s\3%d<%s>\17\t%s%s",
(mention ? "\26" : ""), hash(msg->user), msg->nick,
mentions, msg->params[1]
2020-02-07 03:59:49 +00:00
);
}
2020-02-02 08:43:18 +00:00
}
2020-02-02 06:58:03 +00:00
static void handlePing(struct Message *msg) {
require(msg, false, 1);
ircFormat("PONG :%s\r\n", msg->params[0]);
}
2020-02-06 04:27:43 +00:00
static void handleError(struct Message *msg) {
require(msg, false, 1);
errx(EX_UNAVAILABLE, "%s", msg->params[0]);
}
2020-02-01 06:18:01 +00:00
static const struct Handler {
const char *cmd;
Handler *fn;
} Handlers[] = {
{ "001", handleReplyWelcome },
{ "005", handleReplyISupport },
2020-02-06 07:07:39 +00:00
{ "331", handleReplyNoTopic },
{ "332", handleReplyTopic },
2020-02-08 05:25:09 +00:00
{ "353", handleReplyNames },
2020-02-08 08:15:17 +00:00
{ "366", handleReplyEndOfNames },
{ "372", handleReplyMOTD },
2020-02-02 07:30:35 +00:00
{ "432", handleErrorErroneousNickname },
{ "433", handleErrorNicknameInUse },
2020-02-01 06:18:01 +00:00
{ "900", handleReplyLoggedIn },
{ "904", handleErrorSASLFail },
{ "905", handleErrorSASLFail },
{ "906", handleErrorSASLFail },
{ "AUTHENTICATE", handleAuthenticate },
{ "CAP", handleCap },
2020-02-06 04:27:43 +00:00
{ "ERROR", handleError },
{ "JOIN", handleJoin },
{ "KICK", handleKick },
2020-02-08 05:01:59 +00:00
{ "NICK", handleNick },
2020-02-02 22:26:20 +00:00
{ "NOTICE", handlePrivmsg },
2020-02-06 06:16:35 +00:00
{ "PART", handlePart },
2020-02-02 06:58:03 +00:00
{ "PING", handlePing },
2020-02-02 08:43:18 +00:00
{ "PRIVMSG", handlePrivmsg },
2020-02-08 05:36:23 +00:00
{ "QUIT", handleQuit },
2020-02-06 07:07:39 +00:00
{ "TOPIC", handleTopic },
2020-02-01 06:18:01 +00:00
};
static int compar(const void *cmd, const void *_handler) {
const struct Handler *handler = _handler;
return strcmp(cmd, handler->cmd);
}
void handle(struct Message msg) {
if (!msg.cmd) return;
const struct Handler *handler = bsearch(
msg.cmd, Handlers, ARRAY_LEN(Handlers), sizeof(*handler), compar
);
if (handler) handler->fn(&msg);
}