/*

* LBBS -- The Lightweight Bulletin Board System

*

* Copyright (C) 2023, Naveen Albert

*

* Naveen Albert <bbs@phreaknet.org>

*

* This program is free software, distributed under the terms of

* the GNU General Public License Version 2. See the LICENSE file

* at the top of the source tree.

*/

/*! \file

*

* \brief Slack IRC relay integration

*

* \author Naveen Albert <bbs@phreaknet.org>

*/

#include "include/bbs.h"

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <signal.h>

#include <unistd.h>

#include "include/linkedlists.h"

#include "include/config.h"

#include "include/module.h"

#include "include/utils.h"

#include "include/node.h" /* use bbs_hostname */

#include "include/startup.h"

#include "include/curl.h"

#include "include/cli.h"

#include "include/json.h"

/* Needed for presence query/subscribe commands. Requires jansson support, so must come after json.h include. */

#define SLACK_EXPOSE_JSON

/* libslackrtm: https://github.com/InterLinked1/slack-rtm */

#include <slackrtm/slack.h>

#include <slackrtm/slack-client.h>

#define MIN_VERSION_REQUIRED SEMVER_VERSION(0,3,3)

#if SEMVER_VERSION(SLACK_RTM_LIB_VERSION_MAJOR, SLACK_RTM_LIB_VERSION_MINOR, SLACK_RTM_LIB_VERSION_PATCH) < MIN_VERSION_REQUIRED

#error "libslackrtm version too old"

#endif

#include "include/net_irc.h"

static int expose_members = 1;

struct slack_user {

};

RWLIST_HEAD(slack_users, slack_user);

struct member {

struct slack_user *u;

RWLIST_ENTRY(member) entry;

};

RWLIST_HEAD(members, member);

struct chan_pair {

};

RWLIST_HEAD(chan_pairs, chan_pair);

#define SLACK_TS_LENGTH 17

struct slack_relay {

};

static RWLIST_HEAD_STATIC(relays, slack_relay);

static void cp_free(struct chan_pair *cp)

{

RWLIST_WRLOCK_REMOVE_ALL(&cp->members, entry, free);

RWLIST_HEAD_DESTROY(&cp->members);

free_if(cp->topic);

bbs_mutex_destroy(&cp->sendlock);

bbs_mutex_destroy(&cp->msglock);

free(cp);

}

static void slack_user_free(struct slack_user *u)

{

free_if(u->status);

free_if(u->dmchannel);

bbs_mutex_destroy(&u->lock);

free(u);

}

static void relay_free(struct slack_relay *relay)

{

if (relay->slack) { /* Should always be true except on config parsing early abort */

if (relay->thread) {

slack_client_interrupt(relay->slack);

bbs_pthread_join(relay->thread, NULL);

}

slack_client_destroy(relay->slack);

}

RWLIST_WRLOCK_REMOVE_ALL(&relay->mappings, entry, cp_free);

RWLIST_WRLOCK_REMOVE_ALL(&relay->users, entry, slack_user_free);

RWLIST_HEAD_DESTROY(&relay->mappings);

RWLIST_HEAD_DESTROY(&relay->users);

bbs_mutex_destroy(&relay->lock);

free(relay);

}

static struct chan_pair *find_slack_channel(struct slack_relay *relay, const char *channel)

{

struct chan_pair *cp;

RWLIST_TRAVERSE(&relay->mappings, cp, entry) {

if (!strcmp(cp->slack, channel)) {

break;

}

}

return cp;

}

static struct chan_pair *find_irc_channel(const char *channel)

{

struct slack_relay *r;

/* This is a harder job than find_slack_channel, because find_slack_channel already has a relay.

* We don't know the relay, so we have to traverse everything. */

RWLIST_TRAVERSE(&relays, r, entry) {

struct chan_pair *cp;

RWLIST_TRAVERSE(&r->mappings, cp, entry) {

if (!strcmp(cp->irc, channel)) {

return cp;

}

}

}

return NULL;

}

static void add_channel_member(struct chan_pair *cp, struct slack_user *u)

{

struct member *m = calloc(1, sizeof(*m));

if (ALLOC_FAILURE(m)) {

return;

}

m->u = u;

u->shared = 1;

RWLIST_INSERT_HEAD(&cp->members, m, entry);

}

static json_t *slack_curl_get(struct slack_relay *relay, const char *url)

{

char cookies[512];

json_t *json;

json_error_t jansson_error = {};

struct bbs_curl c = {

.url = url,

.forcefail = 1,

.cookies = cookies,

};

if (relay->cookie_ds) {

snprintf(cookies, sizeof(cookies), "d=%s; d-s=%s", relay->cookie_d, relay->cookie_ds);

} else {

snprintf(cookies, sizeof(cookies), "d=%s", relay->cookie_d);

}

if (bbs_curl_get(&c)) {

return NULL;

}

json = json_loads(c.response, 0, &jansson_error);

if (!json) {

bbs_warning("Failed to parse as JSON (line %d): %s\n", jansson_error.line, jansson_error.text);

bbs_curl_free(&c);

return NULL;

}

if (!json_object_bool_value(json, "ok")) {

bbs_warning("Slack API request failed: %s\n", c.response);

json_decref(json);

bbs_curl_free(&c);

return NULL;

}

bbs_curl_free(&c);

return json;

}

static struct slack_user *load_single_user(struct slack_relay *relay, json_t *jsonuser, const char *userid)

{

json_t *profile;

struct slack_user *user = NULL;

const char *realname, *name, *displayname, *status;

const char *ircusername;

char baseusername[56];

size_t useridlen, realnamelen, namelen, displaynamelen;

int tzoffset;

char *data;

if (!userid) {

bbs_warning("Missing user ID, not loading user\n");

return NULL;

}

/* In practice, most of the time it seems display name is set and real name is not set,

* but occasionally it will even be the other way around, so always ask for both. */

realname = json_object_string_value(jsonuser, "real_name");

name = json_object_string_value(jsonuser, "name");

tzoffset = (int) json_object_number_value(jsonuser, "tz_offset");

profile = json_object_get(jsonuser, "profile");

displayname = json_object_string_value(profile, "display_name");

status = json_object_string_value(profile, "status_text");

if (!name && !realname && !displayname) {

/* Either something is werid or it's a parsing error */

bbs_warning("Nameless user %s?\n", userid);

return NULL;

}

bbs_debug(5, "Fetched user %s/%s: %s/%s/%s/%d (%s)\n", relay->name, userid, name, realname, displayname, tzoffset, status);

/* displayname is likely to be realname (by default). Don't duplicate it if that's the case. */

if (displayname && realname && !strcmp(displayname, realname)) {

displayname = NULL;

}

useridlen = STRING_ALLOC_SIZE(userid);

namelen = STRING_ALLOC_SIZE(name);

realnamelen = STRING_ALLOC_SIZE(realname);

displaynamelen = STRING_ALLOC_SIZE(displayname);

user = calloc(1, sizeof(*user) + useridlen + namelen + realnamelen + displaynamelen);

if (ALLOC_FAILURE(user)) {

return NULL;

}

user->tzoffset = tzoffset;

if (!strlen_zero(status)) {

user->status = strdup(status);

}

data = user->data;

SET_FSM_STRING_VAR(user, data, userid, userid, useridlen);

SET_FSM_STRING_VAR(user, data, username, name, namelen);

SET_FSM_STRING_VAR(user, data, realname, realname, realnamelen);

SET_FSM_STRING_VAR(user, data, dispname, displayname, displaynamelen);

/* Prefer the traditional "name" (now deprecated) if set, since it's the closest to an IRC-style username */

ircusername = name ? name : displayname ? displayname : realname ? realname : userid;

bbs_strcpy_nospaces(ircusername, baseusername, sizeof(baseusername));

/* Even if it's a personal relay, we still need to prepend a prefix to make these

* usernames unique from the userspace of regular IRC user.

* Since we could have multiple Slack workspaces, with duplicate names between each,

* prefix using the configured name of the workspace. */

snprintf(user->ircusername, sizeof(user->ircusername), "%s/%s", relay->name, baseusername);

user->relay = relay;

bbs_mutex_init(&user->lock, NULL);

RWLIST_INSERT_HEAD(&relay->users, user, entry);

return user;

}

/*! \note relay->users must be WRLOCK'd when calling */

static struct slack_user *load_user(struct slack_relay *relay, const char *userid)

{

char url[256];

json_t *json;

struct slack_user *user;

snprintf(url, sizeof(url), "https://slack.com/api/users.info?token=%s&user=%s", relay->token, userid);

json = slack_curl_get(relay, url);

if (!json) {

return NULL;

}

user = load_single_user(relay, json_object_get(json, "user"), userid);

json_decref(json);

return user;

}

static int load_users(struct slack_relay *relay, int limit)

{

char url[256];

size_t index;

json_t *json, *members, *value;

snprintf(url, sizeof(url), "https://slack.com/api/users.list?token=%s&limit=%d", relay->token, limit);

json = slack_curl_get(relay, url);

if (!json) {

return -1;

}

RWLIST_WRLOCK(&relay->users);

members = json_object_get(json, "members");

json_array_foreach(members, index, value) {

load_single_user(relay, value, json_object_string_value(value, "id"));

}

RWLIST_UNLOCK(&relay->users);

json_decref(json);

return 0;

}

static void load_members(struct slack_relay *relay, struct chan_pair *cp, const char *channelid, int limit)

{

char url[256];

size_t index;

json_t *json, *members, *value;

int c = 0;

/* Get all (or the first N) members in the channel */

snprintf(url, sizeof(url), "https://slack.com/api/conversations.members?token=%s&channel=%s&limit=%d", relay->token, channelid, limit);

json = slack_curl_get(relay, url);

if (!json) {

return;

}

members = json_object_get(json, "members");

/* relay->users is already WRLOCK'd */

RWLIST_WRLOCK(&cp->members);

json_array_foreach(members, index, value) {

const char *userid = json_string_value(value);

/* Hopefully already loaded, due to calling load_users previously to fetch members en masse */

struct slack_user *u = load_user(relay, userid);

if (!u) {

bbs_warning("Couldn't load user %s (while loading channel %s)\n", userid, channelid);

continue;

}

/* Keep track of the user:channel relationship that exists here */

add_channel_member(cp, u);

c++;

}

RWLIST_UNLOCK(&cp->members);

json_decref(json);

bbs_debug(5, "Added %d user%s to channel %s\n", c, ESS(c), channelid);

}

static int load_channels(struct slack_relay *relay, int limit)

{

char url[256];

size_t index;

json_t *json, *channels, *value;

/* Get all the channels we're in (not all in the workspace): https://api.slack.com/methods/users.conversations */

snprintf(url, sizeof(url), "https://slack.com/api/users.conversations?token=%s&exclude_archived=true&types=public_channel,private_channel", relay->token);

json = slack_curl_get(relay, url);

if (!json) {

return -1;

}

channels = json_object_get(json, "channels");

RWLIST_WRLOCK(&relay->users);

json_array_foreach(channels, index, value) {

const char *channelid = json_object_string_value(value, "id");

const char *name = json_object_string_value(value, "name");

const char *topic = json_object_string_value(json_object_get(value, "topic"), "value");

struct chan_pair *cp = find_slack_channel(relay, channelid);

if (!cp) {

bbs_debug(6, "Ignoring out of scope channel %s (%s)\n", channelid, name);

continue; /* This isn't a channel within scope of the relay */

}

bbs_mutex_lock(&cp->msglock);

REPLACE(cp->name, name);

REPLACE(cp->topic, topic);

bbs_mutex_unlock(&cp->msglock);

/* Load all the members of the channel, so we can later answer the question:

* If user U in channel C? (without having to make any API calls) */

load_members(relay, cp, channelid, limit);

}

RWLIST_UNLOCK(&relay->users);

json_decref(json);

return 0;

}

static int load_presence(struct slack_relay *relay, int limit)

{

struct slack_user *u;

int c = 0;

int res = 0;

json_t *userids = json_array();

if (!userids) {

return -1;

}

RWLIST_RDLOCK(&relay->users);

RWLIST_TRAVERSE(&relay->users, u, entry) {

if (!u->shared) {

continue; /* If we don't share any channels with this user, we don't care about his/her presence status */

}

if (++c >= limit) {

bbs_warning("Maximum presence limit reached, results will be incomplete\n");

break;

}

json_array_append_new(userids, json_string(u->userid));

}

RWLIST_UNLOCK(&relay->users);

if (slack_users_presence_query(relay->slack, userids)) {

bbs_warning("Failed to send presence query request\n");

res = -1;

} else if (slack_users_presence_subscribe(relay->slack, userids)) {

bbs_warning("Failed to send presence subscribe request\n");

res = -1;

}

json_decref(userids);

return res;

}

static struct slack_user *slack_user_by_irc_username(const char *ircusername)

{

struct slack_relay *relay;

struct slack_user *u = NULL;

RWLIST_RDLOCK(&relays);

RWLIST_TRAVERSE(&relays, relay, entry) {

RWLIST_RDLOCK(&relay->users);

RWLIST_TRAVERSE(&relay->users, u, entry) {

if (!strcmp(u->ircusername, ircusername)) {

/* In a double loop, can't break */

RWLIST_UNLOCK(&relay->users);

RWLIST_UNLOCK(&relays);

return u;

}

}

RWLIST_UNLOCK(&relay->users);

}

RWLIST_UNLOCK(&relays);

/* This operation is used when issuing a WHOIS.

* We should not try to lookup a user live if it doesn't exist,

* because it most likely doesn't. */

return NULL;

}

static struct slack_user *slack_user_by_userid(struct slack_relay *relay, const char *userid, int reorder)

{

struct slack_user *u;

int index = 0;

/* Since some workspaces might have a lot of users,

* an optimization made here is we move the most recently used users to the front of the linked list,

* since they will probably be used again soon (e.g. currently active in a conversation)

* This should make this lookup operation amortized constant time for typical activity.

*/

RWLIST_WRLOCK(&relay->users);

RWLIST_TRAVERSE_SAFE_BEGIN(&relay->users, u, entry) {

if (!strcmp(u->userid, userid)) {

if (reorder && index > 4) { /* If it's not near the front, move it there. Allow some leeway so we're not constantly reordering. */

RWLIST_REMOVE_CURRENT(entry);

RWLIST_INSERT_HEAD(&relay->users, u, entry);

}

RWLIST_UNLOCK(&relay->users);

return u;

}

index++;

}

RWLIST_TRAVERSE_SAFE_END;

/* Doesn't exist yet. Ask for this user, specifically.

* For large workspaces, we may never be able to store all users (nor should we try to). */

u = load_user(relay, userid);

RWLIST_UNLOCK(&relay->users);

if (!u) {

bbs_warning("Couldn't fetch user for user ID %s\n", userid);

}

return u;

}

/*! \brief Get the channel ID for a direct message with a user */

static const char *slack_user_dm_id(struct slack_user *u)

{

char cookies[512];

char url[128];

char postdata[128];

json_t *json;

const char *chan;

json_error_t jansson_error = {};

struct slack_relay *relay;

struct bbs_curl c = {

.url = url,

.forcefail = 1,

.postfields = postdata,

.cookies = cookies,

};

if (u->dmchannel) {

return u->dmchannel;

}

relay = u->relay;

if (relay->cookie_ds) {

snprintf(cookies, sizeof(cookies), "d=%s; d-s=%s", relay->cookie_d, relay->cookie_ds);

} else {

snprintf(cookies, sizeof(cookies), "d=%s", relay->cookie_d);

}

/* This API is really convoluted. For one, the reference and test pages contradict each other:

* https://api.slack.com/methods/conversations.open

* https://api.slack.com/methods/conversations.open/test

* Even though we make a POST response, the users argument still needs to be sent as a query parameter.

*/

snprintf(url, sizeof(url), "https://slack.com/api/conversations.open?users=%s", u->userid);

snprintf(postdata, sizeof(postdata), "token=%s", relay->token);

if (bbs_curl_post(&c)) {

return NULL;

}

json = json_loads(c.response, 0, &jansson_error);

if (!json) {

bbs_warning("Failed to parse as JSON (line %d): %s\n", jansson_error.line, jansson_error.text);

bbs_curl_free(&c);

return NULL;

}

if (!json_object_bool_value(json, "ok")) {

bbs_warning("Slack API request failed for user %s: %s\n", u->userid, c.response);

bbs_curl_free(&c);

json_decref(json);

return NULL;

}

bbs_curl_free(&c);

chan = json_object_string_value(json_object_get(json, "channel"), "id");

if (!chan) {

json_decref(json);

return NULL;

}

bbs_mutex_lock(&u->lock);

REPLACE(u->dmchannel, chan);

bbs_mutex_unlock(&u->lock);

json_decref(json);

return u->dmchannel;

}

static struct slack_user *find_username_all_channels(const char *userid)

{

struct slack_relay *r;

RWLIST_RDLOCK(&relays);

RWLIST_TRAVERSE(&relays, r, entry) {

struct slack_user *u;

RWLIST_RDLOCK(&r->users);

RWLIST_TRAVERSE(&r->users, u, entry) {

if (!strcmp(u->userid, userid)) {

RWLIST_UNLOCK(&r->users);

RWLIST_UNLOCK(&relays);

return u;

}

}

RWLIST_UNLOCK(&r->users);

}

RWLIST_UNLOCK(&relays);

return NULL;

}

static int substitute_mentions(const char *line, char *buf, size_t len)

{

char *pos = buf;

size_t left = len - 1;

const char *start = NULL, *c = line;

/* Need to substitute stuff like <@UA1BCDEF2> to @jsmith

* We don't substitute channels for a couple reasons:

* - They're more ambiguous, and do we use the Slack name or the IRC name?

* - Not everyone has access to all channels. Slack will mask a channel name

* if a recipient of a message doesn't have access to it.

* We can only send one thing to IRC, so decoding channel names

* risks breaching privacy of the channel. */

while (*c) {

if (left <= 0) {

bbs_warning("Buffer exhaustion when substituting nicks\n");

buf[len - 1] = '\0';

return -1;

}

if (!start && *c == '<' && *(c + 1) == '@' && *(c + 2) && strchr(c + 2, '>')) {

start = c + 2;

} else if (start && *c == '>') {

/* User IDs are 9 characters (excluding the @ symbol) and start with U. */

char userid[10];

struct slack_user *u;

safe_strncpy(userid, start, sizeof(userid));

bbs_debug(3, "Searching for username to replace '%s'\n", userid);

/* XXX This is not ideal,

* but since this callback function doesn't receive any private callback data,

* we don't know which relay this is for, so we have to search them all.

* This is still correct, since user IDs are unique across all workspaces,

* but it's not as efficient.

* To make this faster, we could have irc_relay_send_multiline accept private callback data

* (which would be the relay), and then just check the users in that relay here. */

u = find_username_all_channels(userid);

bbs_debug(5, "Substituted %s -> %s\n", userid, u ? u->username : "");

if (u) {

size_t bytes = (size_t) snprintf(pos, left, "@%s", u->username);

pos += bytes;

left -= bytes;

} else {

/* Couldn't resolve this, just keep it as was */

size_t bytes = (size_t) (c - start + 1);

if (bytes > left) {

memcpy(pos, start, bytes);

pos += bytes;

left -= bytes;

}

}

start = NULL;

} else if (!start) {

*pos++ = *c;

left--;

}

c++;

}

*pos = '\0';

return 0;

}

static int on_message(struct slack_event *event, const char *channel, const char *thread_ts, const char *ts, const char *user, const char *text)

{

char dup[4000];

char prefixed[4096];

struct slack_user *u;

const char *ircusername;

struct slack_client *slack = slack_event_get_userdata(event);

struct slack_relay *relay = slack_client_get_userdata(slack);

struct chan_pair *cp;

const char *destination;

UNUSED(ts);

UNUSED(thread_ts);

if (strlen_zero(text)) {

bbs_debug(2, "Ignoring message with no text\n"); /* Probably just an attachment */

return 0;

}

/* See if there are any mappings for this Slack channel */

cp = find_slack_channel(relay, channel);

if (!cp) {

bbs_debug(5, "Ignoring message from Slack channel %s (no mapping for relay %p)\n", channel, relay);

return 0;

}

u = slack_user_by_userid(relay, user, 1);

ircusername = u ? u->ircusername : user;

destination = cp->irc;

/* Don't echo something we just posted */

if (*channel == 'D') { /* Direct message */

if (u) {

bbs_mutex_lock(&u->lock);

if (!strcmp(u->lastmsg, text)) {

bbs_mutex_unlock(&u->lock);

bbs_debug(4, "Not echoing our own direct message post...\n");

return 0;

}

bbs_mutex_unlock(&u->lock);

}

if (relay->ircuser) {

/* Relay direct messages directly to a specific user, if this is a personal relay.

* If it's not, then see if the message includes a username at the beginning.

* If not, then not really sure what we can do with this... */

destination = relay->ircuser;

} else {

char *message, *recipient, *colon;

safe_strncpy(dup, text, sizeof(dup));

message = dup;

recipient = strsep(&message, " ");

destination = strsep(&message, " ");

if (strlen_zero(recipient) || strlen_zero(message)) {

bbs_debug(8, "Private message is not properly addressed, ignoring\n");

/* Don't send an autoresponse saying "please use this messaging format", since there may be other consumers */

return -1;

}

colon = strchr(recipient, ':');

if (!colon) {

return -1; /* Not a private message */

}

destination = recipient;

text = message;

}

} else {

/* We use a mutex that is separate from that

* used for serializing sent messages,

* since the process of sending a message

* can cause the on_message callback to be invoked.

* If we were to have locked cp->lock before sending

* and lock it again here, that will deadlock

* the sending thread until it gives up, at which

* point it will read the reply confirming the sent message

* only after we give up. */

bbs_mutex_lock(&cp->msglock);

if (!strcmp(cp->lastmsg, text)) { /* For most messages (except our own posts), this should be near constant time since they'll diverge quickly */

bbs_mutex_unlock(&cp->msglock);

bbs_debug(4, "Not echoing our own post...\n");

return 0;

}

bbs_mutex_unlock(&cp->msglock);

}

bbs_debug(4, "Relaying message from channel %s by %s (%s) to %s: %s\n", channel, user, ircusername, cp->irc, text);

/* XXX ircusername is not guaranteed to be unique in the workspace. Only user IDs are unique,

* no other attributes are. However, this is what will be most natural to use for the "IRC username".

* In most small workspaces, this should not pose an issue; however, if a collision occurs

* (and we don't check for this), then unexpected behavior may occur. */

if (relay->prefixthread) {

/* If this is the first message in a thread, just include the ts.

* If it's a reply to a message in a thread, prefix the ts with a '>',

* which allows recipients on IRC to distinguish replies from top-level messages. */

const char *eff_ts = S_OR(thread_ts, ts);

if (!strlen_zero(eff_ts)) {

snprintf(prefixed, sizeof(prefixed), "%s%s: %s", thread_ts ? ">" : "", eff_ts, text);

text = prefixed;

/* Also keep track of the last active ts.

* on_message can only be called once per relay at a time since there's a single thread dispatching events,

* but multiple threads could try sending messages (using this variable) simultaneously,

* so this needs to be atomic with that. */

bbs_mutex_lock(&relay->lock);

safe_strncpy(relay->last_ts, eff_ts, sizeof(relay->last_ts));

bbs_mutex_unlock(&relay->lock);

}

}

irc_relay_send_multiline(destination, CHANNEL_USER_MODE_NONE, "Slack", ircusername, user, text, substitute_mentions, relay->ircuser);

return 0;

}

static void process_presence_change(struct slack_relay *relay, const char *userid, int active)

{

struct slack_user *u = slack_user_by_userid(relay, userid, 0); /* Do not reorder */

if (!u) {

/* Should never happen */

bbs_warning("Got presence update for user %s we don't have?\n", userid);

return;

}

bbs_debug(5, "Presence change: %s (%s) => %s\n", userid, u->ircusername, active ? "active" : "offline");

SET_BITFIELD(u->active, active);

}

static int on_presence_change_multi(struct slack_event *event, json_t *userids, const char *presence)

{

struct slack_client *slack = slack_event_get_userdata(event);

struct slack_relay *relay = slack_client_get_userdata(slack);

size_t index;

json_t *value;

/* There is only "active" and "away". So we only need the first 2 letters to differentiate. */

if (!strncmp(presence, "ac", 2)) {

json_array_foreach(userids, index, value) {

const char *userid = json_string_value(value);

process_presence_change(relay, userid, 1);

}

} else if (!strncmp(presence, "aw", 2)) {

json_array_foreach(userids, index, value) {

const char *userid = json_string_value(value);

process_presence_change(relay, userid, 0);

}

} else {

bbs_warning("Unexpected presence value: %s\n", presence);

}

return 0;

}

static int on_presence_change(struct slack_event *event, const char *userid, const char *presence)

{

struct slack_client *slack = slack_event_get_userdata(event);

struct slack_relay *relay = slack_client_get_userdata(slack);

/* There is only "active" and "away". So we only need the first 2 letters to differentiate. */

if (!strncmp(presence, "ac", 2)) {

process_presence_change(relay, userid, 1);

} else if (!strncmp(presence, "aw", 2)) {

process_presence_change(relay, userid, 0);

} else {

bbs_warning("Unexpected presence value for %s: %s\n", userid, presence);

}

return 0;

}

static void notify_unauthorized(const char *sender, const char *channel, const char *ircuser)

{

/* Right channel, wrong permissions */

char notice[256];

/* Could log to either the auth or warning levels... nothing is wrong with the system,

* this is just something possibly malicious. */

bbs_warning("Dropped attempt by %s to access/post to %s, since this is a personal relay for %s\n", sender, channel, ircuser);

/* Notify the sender, since someone could genuinely join a channel and think they're alone,

* and begin posting, because the NAMES reply came back empty.

* Privacy is preserved since the message is NOT relayed,

* but we need to notify the sender that this is somebody else's relay channel.

* Hopefully s/he will leave voluntarily, but if not, things are still good. */

/* XXX Doesn't really make sense to send as the sender? But we don't have access to MessageServ here... */

snprintf(notice, sizeof(notice), "You do not have permission to relay messages in %s", channel); /* Don't disclose who does, either */

irc_relay_send_notice(sender, CHANNEL_USER_MODE_NONE, "Slack", sender, NULL, notice, NULL);

}

static inline void parse_parent_thread(struct slack_relay *relay, char *restrict ts, const char **restrict thread_ts, char const **restrict msg)

{

const char *word2;

long word1len, tsl;

if (!relay->preservethreading || strlen_zero(*msg)) {

/* Do nothing */

return;

}

if (*(*msg) == '>') {

(*msg)++;

if (strlen_zero(*msg)) {

return;

}

/* If it starts with >,

* that's short hand for "reply in thread in the last active thread" */

bbs_mutex_lock(&relay->lock);

if (!strlen_zero(relay->last_ts)) {

safe_strncpy(ts, relay->last_ts, SLACK_TS_LENGTH + 2);

bbs_mutex_unlock(&relay->lock);

*thread_ts = ts;

bbs_debug(5, "Replying to last active thread: %s\n", ts);

} else {

bbs_mutex_unlock(&relay->lock);

bbs_debug(3, "No last ts on file, can't reply in thread\n");

/* Just post a top level message */

}

return;

}

safe_strncpy(ts, *msg, SLACK_TS_LENGTH + 2);

tsl = atol(ts); /* Parse timestamp, at least up until period */

if (tsl <= 0) {

return; /* Can't be a valid ts */

}

word2 = strchr(*msg, ' ');

if (!word2) {

return; /* Only one word? */

}

word1len = word2 - *msg;

/* Accept ts rest of message and ts: rest of message */

if (word1len != SLACK_TS_LENGTH && (word1len != SLACK_TS_LENGTH + 1 || *(*msg + SLACK_TS_LENGTH) != ':')) {

bbs_debug(5, "Not prefixed with a ts after all\n");

return; /* More afterwards, so can't be just a timestamp */

}

if (word1len == SLACK_TS_LENGTH + 1) {

/* Ditch the trailing : */

*(ts + SLACK_TS_LENGTH) = '\0';

}

/* Assume that it's a valid timestamp. */

bbs_debug(7, "Message seems to be prefixed with a Slack ts (%s)\n", ts);

*thread_ts = ts;

*msg = word2 + 1;

}

static int slack_send(struct irc_relay_message *rmsg)

{

char buf[532];

char ts[SLACK_TS_LENGTH + 2];

struct slack_relay *relay;

const char *thread_ts = NULL;

const char *channel = rmsg->channel;

const char *sender = rmsg->sender;

const char *msg = rmsg->msg;

struct chan_pair *cp = find_irc_channel(channel);

if (!cp) {

return 0; /* No relay exists for this channel */

}

relay = cp->relay;

if (sender && relay->ircuser && strcasecmp(relay->ircuser, sender)) {

notify_unauthorized(sender, channel, relay->ircuser);

return 0;

}

if (!sender) {

if (!cp->used) { /* This is the first time anybody on IRC has joined the channel */

if (!strlen_zero(cp->topic)) { /* The first time anybody joins, set the channel topic */

cp->used = 1; /* Only need to do this once */

/* XXX Note: Since anyone can join the channel, the channel topic may "leak" */

irc_relay_set_topic(channel, cp->topic, relay->ircuser);

}

}

if (!relay->relaysystem) {

bbs_debug(3, "Dropping system-generated message since relaysystem=no\n");

return 0;

}

}

parse_parent_thread(relay, ts, &thread_ts, &msg);

if (!relay->ircuser) {

/* Many:many relay, identify the user */

if (sender) {

/* With Slack, it's *bold*, not **bold** - but we also need to format properly */

snprintf(buf, sizeof(buf), "*&lt;%s&gt;* %s", sender, msg);

msg = buf;

}

} /* else, it's a personal relay, don't prepend the IRC username */

bbs_debug(4, "Relaying message to Slack channel %s: %s\n", channel, msg);

/* Currently, we don't have a better way of preventing us from echoing our own messages back to ourself

* (we don't know our Slack user ID, and even if we did, this user could have posted a message

* from elsewhere, we don't necessarily know it came from IRC */

bbs_mutex_lock(&cp->msglock);

safe_strncpy(cp->lastmsg, msg, sizeof(cp->lastmsg));

/* We have to unlock msglock before calling slack_channel_post...

* since that is not safe to hold. We instead use sendlock

* to ensure serialization of sent messages. */

bbs_mutex_unlock(&cp->msglock);

/* slack_channel_post_message is not threadsafe, so we surround it with the channel lock */

bbs_mutex_lock(&cp->sendlock);

if (slack_channel_post_message(relay->slack, cp->slack, thread_ts, msg)) {

bbs_error("Failed to post message to channel %s\n", channel);

relay->error = 1;

}

bbs_mutex_unlock(&cp->sendlock);

return 0;

}

static int privmsg(const char *recipient, const char *sender, const char *msg)

{

char buf[532];

char ts[SLACK_TS_LENGTH + 2];

const char *dmchannel;

struct slack_relay *relay;

const char *thread_ts = NULL;

struct slack_user *u = slack_user_by_irc_username(recipient);

if (!u) {

return 0;

}

dmchannel = slack_user_dm_id(u);

if (!dmchannel) {

bbs_warning("Unable to get DM channel for %s\n", u->userid);

return -1; /* It exists, but we failed */

}