source: code/icb.c@ 094a76c

/*
 * Copyright (c) 2009, 2010, 2013, 2014 Mike Belopuhov
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/queue.h>
#include <netdb.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <ctype.h>
#include <event.h>
#include <vis.h>

#include "icb.h"
#include "icbd.h"

struct icb_grplist groups;

extern int creategroups;
extern char srvname[NI_MAXHOST];

void   icb_command(struct icb_session *, char *, char *);
void   icb_groupmsg(struct icb_session *, char *);
int    icb_login(struct icb_session *, char *, char *, char *);
int    icb_dowho(struct icb_session *, struct icb_group *);

/*
 *  icb_init: initialize server name and a list of groups
 */
void
icb_init(void)
{
        LIST_INIT(&groups);

        if (strlen(srvname) == 0)
                (void)gethostname(srvname, sizeof srvname);
        /*
         * NI_MAXHOST is usually greater than what we
         * can actually send, hence truncation:
         */
        if (strlen(srvname) > 200)
                srvname[200] = '\0';
}

/*
 *  icb_start: called upon accepting a new connection, greets new client
 */
void
icb_start(struct icb_session *is)
{
        icb_sendfmt(is, "%c%c%c%s%c%s", ICB_M_PROTO, '1', ICB_M_SEP, srvname,
            ICB_M_SEP, "icbd");
        SETF(is->flags, ICB_SF_PROTOSENT);
}

/*
 *  icb_input: main input processing routine
 */
int
icb_input(struct icb_session *is)
{
        char *msg = is->buffer;
        int msglen = is->length;
        unsigned char type;
        char *wptr = NULL;
        int res = 0;

        is->last = getmonotime();
        type = msg[0];
        msg++;
        if (!ISSETF(is->flags, ICB_SF_LOGGEDIN) && type != ICB_M_LOGIN) {
                icb_error(is, "Not logged in");
                return (0);
        }
        switch (type) {
        case ICB_M_LOGIN: {
                char client[ICB_MAXNICKLEN];
                char nick[ICB_MAXNICKLEN];
                char group[ICB_MAXGRPLEN];
                char cmd[ICB_MAXCMDLEN];

                memset(client, 0, sizeof client);
                if (icb_token(msg, msglen, &wptr, client, ICB_MAXNICKLEN,
                    ICB_M_SEP, 1) < 0) {
                        icb_error(is, "Invalid client");
                        icbd_drop(is, NULL);
                        return (1);
                }
                memset(nick, 0, sizeof nick);
                if (icb_token(msg, msglen, &wptr, nick, ICB_MAXNICKLEN,
                    ICB_M_SEP, 1) <= 0) {
                        icb_error(is, "Invalid nick");
                        icbd_drop(is, NULL);
                        return (1);
                }
                memset(group, 0, sizeof group);
                if (icb_token(msg, msglen, &wptr, group, ICB_MAXGRPLEN,
                    ICB_M_SEP, 1) < 0) {
                        icb_error(is, "Invalid login group");
                        icbd_drop(is, NULL);
                        return (1);
                }
                memset(cmd, 0, sizeof cmd);
                if (icb_token(msg, msglen, &wptr, cmd, ICB_MAXCMDLEN,
                    ICB_M_SEP, 1) < 0) {
                        icb_error(is, "Invalid command");
                        icbd_drop(is, NULL);
                        return (1);
                }
                if (strlen(cmd) > 0 && cmd[0] == 'w') {
                        icb_error(is, "Command not implemented");
                        icbd_drop(is, NULL);
                        return (1);
                }
                if (strlen(cmd) == 0 || strcmp(cmd, "login") != 0) {
                        icb_error(is, "Malformed login packet");
                        icbd_drop(is, NULL);
                        return (1);
                }
                res = icb_login(is, group, nick, client);
                break;
        }
        case ICB_M_OPEN: {
                icb_groupmsg(is, msg);
                break;
        }
        case ICB_M_COMMAND: {
                char cmd[ICB_MAXCMDLEN];

                memset(cmd, 0, sizeof cmd);
                if (icb_token(msg, msglen, &wptr, cmd, ICB_MAXCMDLEN,
                    ICB_M_SEP, 1) <= 0) {
                        icb_error(is, "Invalid command");
                        icbd_drop(is, NULL);
                        return (1);
                }
                msg = wptr;
                icb_command(is, cmd, msg);
                break;
        }
        case ICB_M_PONG: {
                icb_sendfmt(is, "%c", ICB_M_PING);
                break;
        }
        case ICB_M_PROTO:
        case ICB_M_NOOP:
                /* ignore */
                break;
        default:
                /* everything else is not valid */
                icb_error(is, "Undefined message type %u", type);
        }
        return (res);
}

/*
 *  icb_login: handles login ('a') packets
 */
int
icb_login(struct icb_session *is, char *grp, char *nick, char *client)
{
        const char *defgrp = "1";
        struct icb_group *ig;
        struct icb_session *s;
        char group[ICB_MAXGRPLEN];

        if (!nick || strlen(nick) == 0 ||
            icb_vis(is->nick, nick, ICB_MAXNICKLEN, VIS_SP)) {
                icb_error(is, "Invalid nick");
                icbd_drop(is, NULL);
                return (1);
        }
        if (!grp || strlen(grp) == 0)
                strlcpy(group, defgrp, ICB_MAXGRPLEN);
        else
                icb_vis(group, grp, ICB_MAXGRPLEN, VIS_SP);
        LIST_FOREACH(ig, &groups, entry) {
                if (strcmp(ig->name, group) == 0)
                        break;
        }
        if (ig == NULL) {
                if (!creategroups) {
                        icb_error(is, "Can't create new groups", group);
                        icbd_drop(is, NULL);
                        return (1);
                } else {
                        if ((ig = icb_addgroup(is, group)) == NULL) {
                                icb_error(is, "Can't create group %s", group);
                                return (0);
                        }
                        icbd_log(NULL, LOG_DEBUG, "%s created group %s",
                            is->nick, group);
                }
        }
        LIST_FOREACH(s, &ig->sess, entry) {
                if (strcmp(s->nick, is->nick) == 0) {
                        icb_error(is, "Nick is already in use");
                        icbd_drop(is, NULL);
                        return (1);
                }
        }

        if (client && strlen(client) > 0)
                icb_vis(is->client, client, sizeof is->client, VIS_SP);
        else
                strlcpy(is->client, is->nick, sizeof is->client);
        is->group = ig;
        is->login = time(NULL);
        is->last = getmonotime();

        /* notify group */
        icb_status_group(ig, NULL, STATUS_SIGNON, "%s (%s@%s) entered group",
            is->nick, is->client, is->host);

        CLRF(is->flags, ICB_SF_PROTOSENT);
        SETF(is->flags, ICB_SF_LOGGEDIN);

        LIST_INSERT_HEAD(&ig->sess, is, entry);

        /* acknowledge successful login */
        icb_sendfmt(is, "%c", ICB_M_LOGIN);

        /* notify user */
        icb_status(is, STATUS_STATUS, "You are now in group %s%s", ig->name,
            icb_ismod(ig, is) ? " as moderator" : "");

        /* send user a topic name */
        if (strlen(ig->topic) > 0)
                icb_status(is, STATUS_TOPIC, "Topic for %s is \"%s\"",
                    ig->name, ig->topic);
        return (0);
}

/*
 *  icb_groupmsg: handles open message ('b') packets
 */
void
icb_groupmsg(struct icb_session *is, char *msg)
{
        char buf[ICB_MSGSIZE];
        struct icb_group *ig = is->group;
        struct icb_session *s;
        int res, buflen;

        if (strlen(msg) == 0) {
                icb_error(is, "Empty message");
                return;
        }

        do {
                res = snprintf(&buf[1], sizeof buf - 1, "%c%s%c%s", ICB_M_OPEN,
                    is->nick, ICB_M_SEP, msg);
                if (res < 0) {
                        icbd_log(is, LOG_ERR, "Format error in %s", __func__);
                        return;
                }
                /* res doesn't include the terminating NUL*/
                buflen = MIN((size_t)res + 1, sizeof buf - 1);
                buf[0] = buflen;

                logger(ig->name, is->nick, msg);

                LIST_FOREACH(s, &ig->sess, entry) {
                        if (s == is)
                                continue;
                        icbd_send(s, buf, buflen + 1);
                }

                msg += buflen - 1;
        } while (res > buflen - 1);
}

/*
 *  icb_privmsg: handles personal message ('c') packets
 */
void
icb_privmsg(struct icb_session *is, char *to, char *msg)
{
        struct icb_group *ig = is->group;
        struct icb_session *s;
        char buf[ICB_MSGSIZE];
        char whom[ICB_MAXNICKLEN];
        int res, buflen;

        icb_vis(whom, to, ICB_MAXNICKLEN, VIS_SP);

        /* try home group first */
        LIST_FOREACH(s, &ig->sess, entry) {
                if (strcmp(s->nick, whom) == 0)
                        break;
        }
        if (!s) {
                /* try all groups until the first match */
                LIST_FOREACH(ig, &groups, entry) {
                        LIST_FOREACH(s, &ig->sess, entry) {
                                if (strcmp(s->nick, whom) == 0)
                                        break;
                        }
                        if (s)
                                break;
                }
                if (!s) {
                        icb_error(is, "No such user %s", whom);
                        return;
                }
        }

        do {
                res = snprintf(&buf[1], sizeof buf - 1, "%c%s%c%s",
                    ICB_M_PERSONAL, is->nick, ICB_M_SEP, msg);
                if (res < 0) {
                        icbd_log(is, LOG_ERR, "Format error in %s", __func__);
                        return;
                }
                /* res doesn't include the terminating NUL*/
                buflen = MIN((size_t)res + 1, sizeof buf - 1);
                buf[0] = buflen;

                icbd_send(s, buf, buflen + 1);

                msg += buflen - 1;
        } while (res > buflen - 1);
}

/*
 *  icb_command: handles command ('h') packets
 */
void
icb_command(struct icb_session *is, char *cmd, char *arg)
{
        void (*handler)(struct icb_session *, char *);
        char command[ICB_MAXCMDLEN];

        icb_vis(command, cmd, sizeof command, VIS_SP);

        if ((handler = icb_cmd_lookup(command)) == NULL) {
                icb_error(is, "Unsupported command: %s", command);
                return;
        }
        handler(is, arg);
}

/*
 *  icb_cmdout: sends out command output ('i') packets, called from the
 *              command handlers
 */
void
icb_cmdout(struct icb_session *is, int type, char *outmsg)
{
        char *otype = NULL;

        switch (type) {
        case CMDOUT_CO:
                otype = "co";
                break;
        case CMDOUT_EC:
                otype = "ec";
                break;
        case CMDOUT_WG:
                otype = "wg";
                break;
        case CMDOUT_WH:
                otype = "wh";
                break;
        case CMDOUT_WL:
                otype = "wl";
                break;
        default:
                icbd_log(is, LOG_ERR, "unknown cmdout type %d", type);
                return;
        }
        if (outmsg)
                icb_sendfmt(is, "%c%s%c%s", ICB_M_CMDOUT, otype, ICB_M_SEP,
                    outmsg);
        else
                icb_sendfmt(is, "%c%s", ICB_M_CMDOUT, otype);
}

/*
 *  icb_status: sends a status message ('d') to the client
 */
void
icb_status(struct icb_session *is, int type, const char *fmt, ...)
{
        va_list ap;
        char buf[ICB_MSGSIZE];
        int res, buflen = 1;
        static const struct {
                int              type;
                const char      *msg;
        } msgtab[] = {
                { STATUS_ARRIVE,        "Arrive" },
                { STATUS_BOOT,          "Boot" },
                { STATUS_DEPART,        "Depart" },
                { STATUS_HELP,          "Help" },
                { STATUS_NAME,          "Name" },
                { STATUS_NOBEEP,        "No-Beep" },
                { STATUS_NOTIFY,        "Notify" },
                { STATUS_SIGNON,        "Sign-on" },
                { STATUS_SIGNOFF,       "Sign-off" },
                { STATUS_STATUS,        "Status" },
                { STATUS_TOPIC,         "Topic" },
                { STATUS_WARNING,       "Warning" },
                { 0,                    NULL }
        };

        if (type < 0 || type > (int)nitems(msgtab) - 1)
                return;
        res = snprintf(&buf[1], sizeof buf - 1, "%c%s%c", ICB_M_STATUS,
            msgtab[type].msg, ICB_M_SEP);
        if (res < 0) {
                icbd_log(NULL, LOG_ERR, "Format error in %s", __func__);
                return;
        }
        buflen += MIN((size_t)res, sizeof buf - 1);
        if ((size_t)buflen >= sizeof buf) {
                icbd_log(NULL, LOG_ERR, "Status buffer too small");
                return;
        }
        va_start(ap, fmt);
        res = vsnprintf(&buf[buflen], sizeof buf - buflen, fmt, ap);
        va_end(ap);
        if (res < 0) {
                icbd_log(NULL, LOG_ERR, "Format error in %s", __func__);
                return;
        }
        buflen += MIN((size_t)res, sizeof buf - buflen);
        buf[0] = buflen;
        icbd_send(is, buf, buflen + 1);
}

/*
 *  icb_status: sends a status message ('d') to the group except of the
 *              "ex" if it's not NULL
 */
void
icb_status_group(struct icb_group *ig, struct icb_session *ex, int type,
    const char *fmt, ...)
{
        char buf[ICB_MSGSIZE - 10]; /* truncate to make sure all fits */
        va_list ap;
        struct icb_session *s;

        va_start(ap, fmt);
        (void)vsnprintf(buf, sizeof buf, fmt, ap);
        LIST_FOREACH(s, &ig->sess, entry) {
                if (ex && s == ex)
                        continue;
                icb_status(s, type, buf);
        }
        logger(ig->name, "", buf);
        icbd_log(NULL, LOG_DEBUG, "%s", buf);
        va_end(ap);
}

/*
 *  icb_error: sends an error message ('e') to the client
 */
void
icb_error(struct icb_session *is, const char *fmt, ...)
{
        char buf[ICB_MSGSIZE];
        va_list ap;
        int res, buflen = 1;

        va_start(ap, fmt);
        res = vsnprintf(&buf[2], sizeof buf - 2, fmt, ap);
        va_end(ap);
        if (res < 0) {
                icbd_log(NULL, LOG_ERR, "Format error");
                return;
        }
        buflen += MIN((size_t)res, sizeof buf - 2);
        buf[0] = ++buflen; /* account for ICB_M_ERROR */
        buf[1] = ICB_M_ERROR;
        icbd_send(is, buf, buflen + 1);
        icbd_log(is, LOG_DEBUG, "%s", buf + 2);
}

/*
 *  icb_remove: removes a session from the associated group
 */
void
icb_remove(struct icb_session *is, char *reason)
{
        if (is->group) {
                if (icb_ismod(is->group, is))
                        (void)icb_pass(is->group, is, NULL);
                LIST_REMOVE(is, entry);
                if (reason)
                        icb_status_group(is->group, NULL, STATUS_SIGNOFF,
                            "%s (%s@%s) just left: %s", is->nick, is->client,
                            is->host, reason);
                else
                        icb_status_group(is->group, NULL, STATUS_SIGNOFF,
                            "%s (%s@%s) just left", is->nick, is->client,
                            is->host);
                is->group = NULL;
        }
}

/*
 *  icb_addgroup: adds a new group to the list
 */
struct icb_group *
icb_addgroup(struct icb_session *is, char *name)
{
        struct icb_group *ig;

        if ((ig = calloc(1, sizeof *ig)) == NULL)
                return (NULL);
        strlcpy(ig->name, name, sizeof ig->name);
        if (is)
                ig->mod = is;
        LIST_INIT(&ig->sess);
        LIST_INSERT_HEAD(&groups, ig, entry);
        return (ig);
}

#ifdef notused
/*
 *  icb_delgroup: removes a group from the list
 */
void
icb_delgroup(struct icb_group *ig)
{
        struct icb_session *s;

        /* well, i guess we should kick out participants! ;-) */
        LIST_FOREACH(s, &ig->sess, entry) {
                icb_status(s, STATUS_WARNING, "Group dismissed");
                s->group = NULL;
        }
        LIST_REMOVE(ig, entry);
        bzero(ig, sizeof ig);   /* paranoic thing, obviously */
        free(ig);
}
#endif

/*
 *  icb_dowho: a helper function that sends out a group header as a command
 *             output and user information in the "wl" format
 */
int
icb_dowho(struct icb_session *is, struct icb_group *ig)
{
        char buf[ICB_MSGSIZE - 10]; /* truncate to make sure all fits */
        struct icb_session *s;
        time_t now;
        int nusers = 0;

        now = getmonotime();
        icb_cmdout(is, CMDOUT_CO, " ");
        snprintf(buf, sizeof buf, "Group: %-8s (%cvl) Mod: %-13s Topic: %s",
            ig->name, ig->mod ? 'm' : 'p', ig->mod ? ig->mod->nick : "(None)",
            strlen(ig->topic) > 0 ? ig->topic : "(None)");
        icb_cmdout(is, CMDOUT_CO, buf);
        LIST_FOREACH(s, &ig->sess, entry) {
                (void)snprintf(buf, sizeof buf,
                    "%c%c%s%c%lld%c0%c%lld%c%s%c%s%c%s",
                    icb_ismod(ig, s) ? 'm' : ' ', ICB_M_SEP,
                    s->nick, ICB_M_SEP, now - s->last,
                    ICB_M_SEP, ICB_M_SEP, s->login, ICB_M_SEP,
                    s->client, ICB_M_SEP, s->host, ICB_M_SEP, " ");
                icb_cmdout(is, CMDOUT_WL, buf);
                nusers++;
        }
        return (nusers);
}

/*
 *  icb_who: sends a list of users of either the specified group or all
 *           groups found on the server
 */
void
icb_who(struct icb_session *is, struct icb_group *ig)
{
        char buf[ICB_MSGSIZE - 10]; /* truncate to make sure all fits */
        struct icb_group *g;

        if (!ig) {
                int nusers = 0, ngroups = 0;

                LIST_FOREACH(g, &groups, entry) {
                        nusers += icb_dowho(is, g);
                        ngroups++;
                }
                if (nusers > 0) {
                        (void)snprintf(buf, sizeof buf,
                            "Total: %d %s in %d %s",
                            nusers, nusers > 1 ? "users" : "user",
                            ngroups, ngroups > 1 ? "groups" : "group");
                } else
                        (void)snprintf(buf, sizeof buf, "No users found.");
                icb_cmdout(is, CMDOUT_CO, buf);
        } else
                (void)icb_dowho(is, ig);
}

/*
 *  icb_ismod: checks whether group is moderated by "is"
 */
int
icb_ismod(struct icb_group *ig, struct icb_session *is)
{
        return (ig->mod == is);
}

/*
 *  icb_modpermit: checks user against the moderators table if it has
 *                 been populated
 */
int
icb_modpermit(struct icb_session *is, int enforce)
{
        extern char modtab[ICB_MTABLEN][ICB_MAXNICKLEN];
        extern int modtabcnt;

        icbd_modupdate();
        if ((enforce ? 0 : modtabcnt == 0) ||
            bsearch(is->nick, modtab, modtabcnt, ICB_MAXNICKLEN,
            (int (*)(const void *, const void *))strcmp))
                return (1);
        return (0);
}

/*
 *  icb_pass: passes moderation of group "ig" from "from" to "to",
 *            returns -1 if "from" is not a moderator, 1 if passed
 *            to "to" and 0 otherwise (no moderator or passed to the
 *            internal bot)
 */
int
icb_pass(struct icb_group *ig, struct icb_session *from,
    struct icb_session *to)
{
        if (ig->mod && ig->mod != from)
                return (-1);
        if (!from && !to)
                return (-1);
        ig->mod = to;
        if (to)
                icb_status(to, STATUS_NOTIFY, "%s just passed you moderation"
                    " of %s", from ? from->nick : "server", ig->name);
        icb_status_group(ig, to, STATUS_NOTIFY, "%s has passed moderation "
            "to %s", from ? from->nick : "server", to ? to->nick : "server");
        return (1);
}

/*
 *  icb_sendfmt: formats a string and sends it over
 */
void
icb_sendfmt(struct icb_session *is, const char *fmt, ...)
{
        char buf[ICB_MSGSIZE];
        va_list ap;
        int res, buflen = 1;

        va_start(ap, fmt);
        res = vsnprintf(&buf[1], sizeof buf - 1, fmt, ap);
        va_end(ap);
        if (res < 0) {
                icbd_log(NULL, LOG_ERR, "Format error in %s", __func__);
                return;
        }
        buflen += MIN((size_t)res + 1, sizeof buf - 1);
        buf[0] = buflen;
        icbd_send(is, buf, buflen + 1);
}

/*
 *  icb_token: copies a sequence of characters delimited by the 'sep' character
 *             from the source buffer 'buf' at offset indicated by 'bufptr' to
 *             the destination buffer 'dst' and sets 'bufptr' to the next byte
 *             after 'sep'.
 */
int
icb_token(char *buf, int len, char **bufptr, char *dst, int dstlen, int sep,
    int trim)
{
        char *start;
        int i, ret;

        if (buf == NULL || len <= 0 || dst == NULL || dstlen <= 0)
                return (0);
        if (*bufptr == NULL)
                *bufptr = buf;
        start = *bufptr;
        for (i = *bufptr - buf; i < len; i++, (*bufptr)++) {
                if (**bufptr == sep || **bufptr == '\0') {
                        /* copy and null terminate the token */
                        ret = strlcpy(dst, start,
                            MIN(*bufptr - start + 1, dstlen));
                        if (**bufptr != '\0')
                                (*bufptr)++;
                        if (ret > 0 && trim)
                                ret = icb_trim(dst, dstlen);
                        return (ret);
                }
        }
        /*
         * Reached the end of the buffer without finding a field separator
         * nor the end of line character.  If we have advanced our pointer
         * we should copy the resulting single field out.
         */
        if (*bufptr - start > 0) {
                ret = strlcpy(dst, start, MIN(*bufptr - start + 1, dstlen));
                if (ret > 0 && trim)
                        ret = icb_trim(dst, dstlen);
                return (ret);
        }
        return (0);
}

/*
 *  icb_trim: trims trailing whitespace
 */
int
icb_trim(char *buf, int len)
{
        char *p = buf;
        int i;

        for (i = 0; i < len && *p != '\0'; i++)
                p++;
        if (*p == '\0' && p - buf > 0)
                p--;
        while (p >= buf && isspace(*p)) {
                *p = '\0';
                i--;
                if (p > buf)
                        p--;
        }
        return (i);
}

/*
 *  icb_vis: strnvis-like function that escapes percentages as well
 */
int
icb_vis(char *dst, const char *src, size_t dstsize, int flags)
{
        int si = 0, di = 0, td;

        while ((size_t)di < dstsize - 1 && src[si] != '\0') {
                if (src[si] == '%') {
                        if ((size_t)di + 1 >= dstsize - 1)
                                break;
                        dst[di++] = '%', dst[di] = '%';
                } else if (src[si] == ' ' && flags & VIS_SP)
                        dst[di] = '_';
                else if (isgraph(src[si]) || src[si] == ' ')
                        dst[di] = src[si];
                else {
                        td = snprintf(&dst[di], dstsize - di,
                            "\\%03o", (unsigned char)src[si]);
                        if (td == -1 || (size_t)td >= dstsize - di)
                                break;
                        di += td - 1;
                }
                si++, di++;
        }
        dst[MIN((size_t)di, dstsize - 1)] = '\0';
        return (0);
}