[irc/evilnet/x3.git] / src / global.c

/* global.c - Global notice service
 * Copyright 2000-2004 srvx Development Team
 *
 * This file is part of srvx.
 *
 * srvx 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 2 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 srvx; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */

#include "conf.h"
#include "global.h"
#include "modcmd.h"
#include "nickserv.h"
#include "saxdb.h"
#include "timeq.h"

#define GLOBAL_CONF_NAME	"services/global"

#define GLOBAL_DB		"global.db"
#define GLOBAL_TEMP_DB		"global.db.new"

/* Global options */
#define KEY_DB_BACKUP_FREQ	"db_backup_freq"
#define KEY_ANNOUNCEMENTS_DEFAULT "announcements_default"
#define KEY_NICK		"nick"

/* Message data */
#define KEY_FLAGS		"flags"
#define KEY_POSTED		"posted"
#define KEY_DURATION		"duration"
#define KEY_FROM		"from"
#define KEY_MESSAGE		"message"

/* Clarification: Notices are immediate, they are sent to matching users
   _once_, then forgotten. Messages are stored in Global's database and
   continually sent to users as they match the target specification until
   they are deleted. */
static const struct message_entry msgtab[] = {
    { "GMSG_INVALID_TARGET", "$b%s$b is an invalid message target." },
    { "GMSG_MESSAGE_REQUIRED", "You $bmust$b provide a message to send." },
    { "GMSG_MESSAGE_SENT", "Message to $b%s$b sent." },
    { "GMSG_MESSAGE_ADDED", "Message to $b%s$b with ID %ld added." },
    { "GMSG_MESSAGE_DELETED", "Message $b%s$b deleted." },
    { "GMSG_ID_INVALID", "$b%s$b is an invalid message ID." },
    { "GMSG_MESSAGE_COUNT", "$b%d$b messages found." },
    { "GMSG_NO_MESSAGES", "There are no messages for you." },
    { "GMSG_NOTICE_SOURCE", "[$b%s$b] Notice from %s:" },
    { "GMSG_MESSAGE_SOURCE", "[$b%s$b] Notice from %s, posted %s:" },
    { "GMSG_MOTD_HEADER", "$b------------- MESSAGE(S) OF THE DAY --------------$b" },
    { "GMSG_MOTD_FOOTER", "$b---------- END OF MESSAGE(S) OF THE DAY ----------$b" },
    { NULL, NULL }
};

#define GLOBAL_SYNTAX()   svccmd_send_help(user, global, cmd)
#define GLOBAL_FUNC(NAME) MODCMD_FUNC(NAME)

struct userNode *global;

static struct module *global_module;
static struct service *global_service;
static struct globalMessage *messageList;
static long messageCount;
static time_t last_max_alert;
static struct log_type *G_LOG;

static struct
{
    unsigned long db_backup_frequency;
    unsigned int announcements_default : 1;
} global_conf;

#define global_notice(target, format...) send_message(target , global , ## format)

void message_expire(void *data);

static struct globalMessage*
message_add(long flags, time_t posted, unsigned long duration, char *from, const char *msg)
{
    struct globalMessage *message;

    message = malloc(sizeof(struct globalMessage));

    if(!message)
    {
	return NULL;
    }

    message->id = messageCount++;
    message->flags = flags;
    message->posted = posted;
    message->duration = duration;
    message->from = strdup(from);
    message->message = strdup(msg);

    if(messageList)
    {
	messageList->prev = message;
    }

    message->prev = NULL;
    message->next = messageList;

    messageList = message;

    if(duration)
    {
	timeq_add(now + duration, message_expire, message);
    }

    return message;
}

static void
message_del(struct globalMessage *message)
{
    if(message->duration)
    {
	timeq_del(0, NULL, message, TIMEQ_IGNORE_FUNC | TIMEQ_IGNORE_WHEN);
    }

    if(message->prev) message->prev->next = message->next;
    else messageList = message->next;

    if(message->next) message->next->prev = message->prev;

    free(message->from);
    free(message->message);
    free(message);
}

void message_expire(void *data)
{
    struct globalMessage *message = data;

    message->duration = 0;
    message_del(message);
}

static struct globalMessage*
message_create(struct userNode *user, unsigned int argc, char *argv[])
{
    unsigned long duration = 0;
    char *text = NULL;
    long flags = 0;
    unsigned int i;

    for(i = 0; i < argc; i++)
    {
	if((i + 1) > argc)
	{
	    global_notice(user, "MSG_MISSING_PARAMS", argv[argc]);
	    return NULL;
	}

	if(!irccasecmp(argv[i], "text"))
	{
	    i++;
	    text = unsplit_string(argv + i, argc - i, NULL);
	    break;
	} else if (!irccasecmp(argv[i], "sourceless")) {
	    i++;
	    flags |= MESSAGE_OPTION_SOURCELESS;
	} else if (!irccasecmp(argv[i], "target")) {
	    i++;

	    if(!irccasecmp(argv[i], "all")) {
		flags |= MESSAGE_RECIPIENT_ALL;
	    } else if(!irccasecmp(argv[i], "users")) {
		flags |= MESSAGE_RECIPIENT_LUSERS;
	    } else if(!irccasecmp(argv[i], "helpers")) {
		flags |= MESSAGE_RECIPIENT_HELPERS;
	    } else if(!irccasecmp(argv[i], "opers")) {
		flags |= MESSAGE_RECIPIENT_OPERS;
	    } else if(!irccasecmp(argv[i], "staff") || !irccasecmp(argv[i], "privileged")) {
		flags |= MESSAGE_RECIPIENT_STAFF;
	    } else if(!irccasecmp(argv[i], "channels")) {
		flags |= MESSAGE_RECIPIENT_CHANNELS;
            } else if(!irccasecmp(argv[i], "announcement") || !irccasecmp(argv[i], "announce")) {
                flags |= MESSAGE_RECIPIENT_ANNOUNCE;
	    } else {
		global_notice(user, "GMSG_INVALID_TARGET", argv[i]);
		return NULL;
	    }
	} else if (irccasecmp(argv[i], "duration") == 0) {
	    duration = ParseInterval(argv[++i]);
	} else {
	    global_notice(user, "MSG_INVALID_CRITERIA", argv[i]);
	    return NULL;
	}
    }

    if(!flags)
    {
	flags = MESSAGE_RECIPIENT_LUSERS;
    }

    if(!text) {
	global_notice(user, "GMSG_MESSAGE_REQUIRED");
	return NULL;
    }

    return message_add(flags, now, duration, user->handle_info->handle, text);
}

static const char *
messageType(const struct globalMessage *message)
{
    if((message->flags & MESSAGE_RECIPIENT_ALL) == MESSAGE_RECIPIENT_ALL)
    {
	return "all";
    }
    if((message->flags & MESSAGE_RECIPIENT_STAFF) == MESSAGE_RECIPIENT_STAFF)
    {
	return "staff";
    }
    else if(message->flags & MESSAGE_RECIPIENT_ANNOUNCE)
    {
        return "announcement";
    }
    else if(message->flags & MESSAGE_RECIPIENT_OPERS)
    {
	return "opers";
    }
    else if(message->flags & MESSAGE_RECIPIENT_HELPERS)
    {
	return "helpers";
    }
    else if(message->flags & MESSAGE_RECIPIENT_LUSERS)
    {
	return "users";
    }
    else
    {
	return "channels";
    }
}

static void
notice_target(const char *target, struct globalMessage *message)
{
    if(!(message->flags & MESSAGE_OPTION_SOURCELESS))
    {
	if(message->flags & MESSAGE_OPTION_IMMEDIATE)
	{
	    send_target_message(0, target, global, "GMSG_NOTICE_SOURCE", messageType(message), message->from);
	}
	else
	{
	    char posted[24];
	    struct tm tm;

	    localtime_r(&message->posted, &tm);
	    strftime(posted, sizeof(posted), "%I:%M %p, %m/%d/%Y", &tm);
	    send_target_message(0, target, global, "GMSG_MESSAGE_SOURCE", messageType(message), message->from, posted);
	}
    }

    send_target_message(4, target, global, "%s", message->message);
}

static int
notice_channel(const char *key, void *data, void *extra)
{
    struct chanNode *channel = data;
    /* It should be safe to assume channel is not NULL. */
    if(channel->channel_info)
 	notice_target(key, extra);
    return 0;
}

static void
message_send(struct globalMessage *message)
{
    struct userNode *user;
    unsigned long n;
    dict_iterator_t it;

    if(message->flags & MESSAGE_RECIPIENT_CHANNELS)
    {
	dict_foreach(channels, notice_channel, message);
    }

    if(message->flags & MESSAGE_RECIPIENT_LUSERS)
    {
	notice_target("$*", message);
	return;
    }

    if(message->flags & MESSAGE_RECIPIENT_ANNOUNCE)
    {
        char announce;

        for (it = dict_first(clients); it; it = iter_next(it)) {
            user = iter_data(it);
            if (user->uplink == self) continue;
            announce = user->handle_info ? user->handle_info->announcements : '?';
            if (announce == 'n') continue;
            if ((announce == '?') && !global_conf.announcements_default) continue;
            notice_target(user->nick, message);
        }
    }

    if(message->flags & MESSAGE_RECIPIENT_OPERS)
    {
	for(n = 0; n < curr_opers.used; n++)
	{
	    user = curr_opers.list[n];

	    if(user->uplink != self)
	    {
		notice_target(user->nick, message);
	    }
	}
    }

    if(message->flags & MESSAGE_RECIPIENT_HELPERS)
    {
	for(n = 0; n < curr_helpers.used; n++)
	{
	    user = curr_helpers.list[n];
            if (IsOper(user))
                continue;
	    notice_target(user->nick, message);
	}
    }
}

void
global_message(long targets, char *text)
{
    struct globalMessage *message;

    if(!targets || !global)
	return;

    message = message_add(targets | MESSAGE_OPTION_SOURCELESS, now, 0, "", text);
    if(!message)
	return;

    message_send(message);
    message_del(message);
}

static GLOBAL_FUNC(cmd_notice)
{
    struct globalMessage *message = NULL;
    const char *recipient = NULL, *text;
    long target = 0;

    assert(argc >= 3);
    if(!irccasecmp(argv[1], "all")) {
	target = MESSAGE_RECIPIENT_ALL;
    } else if(!irccasecmp(argv[1], "users")) {
	target = MESSAGE_RECIPIENT_LUSERS;
    } else if(!irccasecmp(argv[1], "helpers")) {
	target = MESSAGE_RECIPIENT_HELPERS;
    } else if(!irccasecmp(argv[1], "opers")) {
	target = MESSAGE_RECIPIENT_OPERS;
    } else if(!irccasecmp(argv[1], "staff") || !irccasecmp(argv[1], "privileged")) {
	target |= MESSAGE_RECIPIENT_HELPERS | MESSAGE_RECIPIENT_OPERS;
    } else if(!irccasecmp(argv[1], "announcement") || !irccasecmp(argv[1], "announce")) {
        target |= MESSAGE_RECIPIENT_ANNOUNCE;
    } else if(!irccasecmp(argv[1], "channels")) {
	target = MESSAGE_RECIPIENT_CHANNELS;
    } else {
	global_notice(user, "GMSG_INVALID_TARGET", argv[1]);
	return 0;
    }

    text = unsplit_string(argv + 2, argc - 2, NULL);
    message = message_add(target | MESSAGE_OPTION_IMMEDIATE, now, 0, user->handle_info->handle, text);

    if(!message)
    {
	return 0;
    }

    recipient = messageType(message);

    message_send(message);
    message_del(message);

    global_notice(user, "GMSG_MESSAGE_SENT", recipient);
    return 1;
}

static GLOBAL_FUNC(cmd_message)
{
    struct globalMessage *message = NULL;
    const char *recipient = NULL;

    assert(argc >= 3);
    message = message_create(user, argc - 1, argv + 1);
    if(!message)
        return 0;
    recipient = messageType(message);
    global_notice(user, "GMSG_MESSAGE_ADDED", recipient, message->id);
    return 1;
}

static GLOBAL_FUNC(cmd_list)
{
    struct globalMessage *message;
    struct helpfile_table table;
    unsigned int length, nn;

    if(!messageList)
    {
	global_notice(user, "GMSG_NO_MESSAGES");
        return 1;
    }

    for(nn=0, message = messageList; message; nn++, message=message->next) ;
    table.length = nn+1;
    table.width = 5;
    table.flags = TABLE_NO_FREE;
    table.contents = calloc(table.length, sizeof(char**));
    table.contents[0] = calloc(table.width, sizeof(char*));
    table.contents[0][0] = "ID";
    table.contents[0][1] = "Target";
    table.contents[0][2] = "Expires";
    table.contents[0][3] = "From";
    table.contents[0][4] = "Message";

    for(nn=1, message = messageList; message; nn++, message = message->next)
    {
        char buffer[64];

        table.contents[nn] = calloc(table.width, sizeof(char*));
        snprintf(buffer, sizeof(buffer), "%lu", message->id);
        table.contents[nn][0] = strdup(buffer);
        table.contents[nn][1] = messageType(message);
        if(message->duration)
            intervalString(buffer, message->posted + message->duration - now, user->handle_info);
        else
            strcpy(buffer, "Never.");
        table.contents[nn][2] = strdup(buffer);
        table.contents[nn][3] = message->from;
	length = strlen(message->message);
	safestrncpy(buffer, message->message, sizeof(buffer));
	if(length > (sizeof(buffer) - 4))
	{
	    buffer[sizeof(buffer) - 1] = 0;
	    buffer[sizeof(buffer) - 2] = buffer[sizeof(buffer) - 3] = buffer[sizeof(buffer) - 4] = '.';
	}
        table.contents[nn][4] = strdup(buffer);
    }
    table_send(global, user->nick, 0, NULL, table);
    for (nn=1; nn<table.length; nn++)
    {
        free((char*)table.contents[nn][0]);
        free((char*)table.contents[nn][2]);
        free((char*)table.contents[nn][4]);
        free(table.contents[nn]);
    }
    free(table.contents[0]);
    free(table.contents);

    return 1;
}

static GLOBAL_FUNC(cmd_remove)
{
    struct globalMessage *message = NULL;
    unsigned long id;

    assert(argc >= 2);
    id = strtoul(argv[1], NULL, 0);

    for(message = messageList; message; message = message->next)
    {
	if(message->id == id)
	{
	    message_del(message);
	    global_notice(user, "GMSG_MESSAGE_DELETED", argv[1]);
	    return 1;
	}
    }

    global_notice(user, "GMSG_ID_INVALID", argv[1]);
    return 0;
}

static unsigned int
send_messages(struct userNode *user, long mask, int obstreperize)
{
    struct globalMessage *message = messageList;
    unsigned int count = 0;

    while(message)
    {
	if(message->flags & mask)
	{
            if (obstreperize && !count)
                send_target_message(0, user->nick, global, "GMSG_MOTD_HEADER");
	    notice_target(user->nick, message);
	    count++;
	}

	message = message->next;
    }
    if (obstreperize && count)
        send_target_message(0, user->nick, global, "GMSG_MOTD_FOOTER");
    return count;
}

static GLOBAL_FUNC(cmd_messages)
{
    long mask = MESSAGE_RECIPIENT_LUSERS | MESSAGE_RECIPIENT_CHANNELS;
    unsigned int count;

    if(IsOper(user))
	mask |= MESSAGE_RECIPIENT_OPERS;

    if(IsHelper(user))
	mask |= MESSAGE_RECIPIENT_HELPERS;

    count = send_messages(user, mask, 0);
    if(count)
	global_notice(user, "GMSG_MESSAGE_COUNT", count);
    else
	global_notice(user, "GMSG_NO_MESSAGES");

    return 1;
}

static int
global_process_user(struct userNode *user)
{
    if(IsLocal(user) || self->uplink->burst || user->uplink->burst)
        return 0;
    send_messages(user, MESSAGE_RECIPIENT_LUSERS, 1);

    /* only alert on new usercount if the record was broken in the last
     * 30 seconds, and no alert had been sent in that time.
     */
    if((now - max_clients_time) <= 30 && (now - last_max_alert) > 30)
    {
	char *message;
	message = alloca(36);
	sprintf(message, "New user count record: %d", max_clients);
	global_message(MESSAGE_RECIPIENT_OPERS, message);
	last_max_alert = now;
    }

    return 0;
}

static void
global_process_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle))
{
    if(IsHelper(user))
	send_messages(user, MESSAGE_RECIPIENT_HELPERS, 0);
}

static void
global_process_oper(struct userNode *user)
{
    if(user->uplink->burst)
        return;
    send_messages(user, MESSAGE_RECIPIENT_OPERS, 0);
}

static void
global_conf_read(void)
{
    dict_t conf_node;
    const char *str;

    if (!(conf_node = conf_get_data(GLOBAL_CONF_NAME, RECDB_OBJECT))) {
	log_module(G_LOG, LOG_ERROR, "config node `%s' is missing or has wrong type.", GLOBAL_CONF_NAME);
	return;
    }

    str = database_get_data(conf_node, KEY_DB_BACKUP_FREQ, RECDB_QSTRING);
    global_conf.db_backup_frequency = str ? ParseInterval(str) : 7200;
    str = database_get_data(conf_node, KEY_ANNOUNCEMENTS_DEFAULT, RECDB_QSTRING);
    global_conf.announcements_default = str ? enabled_string(str) : 1;

    str = database_get_data(conf_node, KEY_NICK, RECDB_QSTRING);
    if(global && str)
        NickChange(global, str, 0);
}

static int
global_saxdb_read(struct dict *db)
{
    struct record_data *hir;
    time_t posted;
    long flags;
    unsigned long duration;
    char *str, *from, *message;
    dict_iterator_t it;

    for(it=dict_first(db); it; it=iter_next(it))
    {
        hir = iter_data(it);
	if(hir->type != RECDB_OBJECT)
	{
	    log_module(G_LOG, LOG_WARNING, "Unexpected rectype %d for %s.", hir->type, iter_key(it));
            continue;
	}

        str = database_get_data(hir->d.object, KEY_FLAGS, RECDB_QSTRING);
        flags = str ? strtoul(str, NULL, 0) : 0;

        str = database_get_data(hir->d.object, KEY_POSTED, RECDB_QSTRING);
        posted = str ? strtoul(str, NULL, 0) : 0;

        str = database_get_data(hir->d.object, KEY_DURATION, RECDB_QSTRING);
        duration = str ? strtoul(str, NULL, 0) : 0;

        from = database_get_data(hir->d.object, KEY_FROM, RECDB_QSTRING);
        message = database_get_data(hir->d.object, KEY_MESSAGE, RECDB_QSTRING);

	message_add(flags, posted, duration, from, message);
    }
    return 0;
}

static int
global_saxdb_write(struct saxdb_context *ctx)
{
    struct globalMessage *message;
    char str[16];

    for(message = messageList; message; message = message->next) {
        snprintf(str, sizeof(str), "%li", message->id);
        saxdb_start_record(ctx, str, 0);
        saxdb_write_int(ctx, KEY_FLAGS, message->flags);
        saxdb_write_int(ctx, KEY_POSTED, message->posted);
        saxdb_write_int(ctx, KEY_DURATION, message->duration);
        saxdb_write_string(ctx, KEY_FROM, message->from);
        saxdb_write_string(ctx, KEY_MESSAGE, message->message);
        saxdb_end_record(ctx);
    }
    return 0;
}

static void
global_db_cleanup(void)
{
    while(messageList)
        message_del(messageList);
}

void
init_global(const char *nick)
{
    G_LOG = log_register_type("Global", "file:global.log");
    reg_new_user_func(global_process_user);
    reg_auth_func(global_process_auth);
    reg_oper_func(global_process_oper);

    conf_register_reload(global_conf_read);

    global_module = module_register("Global", G_LOG, "global.help", NULL);
    modcmd_register(global_module, "LIST", cmd_list, 1, 0, "flags", "+oper", NULL);
    modcmd_register(global_module, "MESSAGE", cmd_message, 3, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);
    modcmd_register(global_module, "MESSAGES", cmd_messages, 1, 0, NULL);
    modcmd_register(global_module, "NOTICE", cmd_notice, 3, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);
    modcmd_register(global_module, "REMOVE", cmd_remove, 2, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);

    if(nick)
    {
        const char *modes = conf_get_data("services/global/modes", RECDB_QSTRING);
        global = AddService(nick, modes ? modes : NULL, "Global Services", NULL);
        global_service = service_register(global);
    }
    saxdb_register("Global", global_saxdb_read, global_saxdb_write);
    reg_exit_func(global_db_cleanup);
    message_register_table(msgtab);
}
Commit	Line	Data
d76ed9a9	1	/* global.c - Global notice service
	2	* Copyright 2000-2004 srvx Development Team
	3	*
	4	* This file is part of srvx.
	5	*
	6	* srvx is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with srvx; if not, write to the Free Software Foundation,
	18	* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
	19	*/
	20
	21	#include "conf.h"
	22	#include "global.h"
	23	#include "modcmd.h"
	24	#include "nickserv.h"
	25	#include "saxdb.h"
	26	#include "timeq.h"
	27
	28	#define GLOBAL_CONF_NAME "services/global"
	29
	30	#define GLOBAL_DB "global.db"
	31	#define GLOBAL_TEMP_DB "global.db.new"
	32
	33	/* Global options */
	34	#define KEY_DB_BACKUP_FREQ "db_backup_freq"
	35	#define KEY_ANNOUNCEMENTS_DEFAULT "announcements_default"
	36	#define KEY_NICK "nick"
	37
	38	/* Message data */
	39	#define KEY_FLAGS "flags"
	40	#define KEY_POSTED "posted"
	41	#define KEY_DURATION "duration"
	42	#define KEY_FROM "from"
	43	#define KEY_MESSAGE "message"
	44
	45	/* Clarification: Notices are immediate, they are sent to matching users
	46	_once_, then forgotten. Messages are stored in Global's database and
	47	continually sent to users as they match the target specification until
	48	they are deleted. */
	49	static const struct message_entry msgtab[] = {
	50	{ "GMSG_INVALID_TARGET", "$b%s$b is an invalid message target." },
	51	{ "GMSG_MESSAGE_REQUIRED", "You $bmust$b provide a message to send." },
	52	{ "GMSG_MESSAGE_SENT", "Message to $b%s$b sent." },
	53	{ "GMSG_MESSAGE_ADDED", "Message to $b%s$b with ID %ld added." },
	54	{ "GMSG_MESSAGE_DELETED", "Message $b%s$b deleted." },
	55	{ "GMSG_ID_INVALID", "$b%s$b is an invalid message ID." },
	56	{ "GMSG_MESSAGE_COUNT", "$b%d$b messages found." },
	57	{ "GMSG_NO_MESSAGES", "There are no messages for you." },
	58	{ "GMSG_NOTICE_SOURCE", "[$b%s$b] Notice from %s:" },
	59	{ "GMSG_MESSAGE_SOURCE", "[$b%s$b] Notice from %s, posted %s:" },
	60	{ "GMSG_MOTD_HEADER", "$b------------- MESSAGE(S) OF THE DAY --------------$b" },
	61	{ "GMSG_MOTD_FOOTER", "$b---------- END OF MESSAGE(S) OF THE DAY ----------$b" },
	62	{ NULL, NULL }
	63	};
	64
65	#define GLOBAL_SYNTAX() svccmd_send_help(user, global, cmd)
66	#define GLOBAL_FUNC(NAME) MODCMD_FUNC(NAME)
67
68	struct userNode *global;
69
70	static struct module *global_module;
71	static struct service *global_service;
72	static struct globalMessage *messageList;
73	static long messageCount;
74	static time_t last_max_alert;
75	static struct log_type *G_LOG;
76
77	static struct
78	{
79	unsigned long db_backup_frequency;
80	unsigned int announcements_default : 1;
81	} global_conf;
82
83	#define global_notice(target, format...) send_message(target , global , ## format)
84
85	void message_expire(void *data);
86
87	static struct globalMessage*
88	message_add(long flags, time_t posted, unsigned long duration, char from, const char msg)
89	{
90	struct globalMessage *message;
91
92	message = malloc(sizeof(struct globalMessage));
93
94	if(!message)
95	{
96	return NULL;
97	}
98
99	message->id = messageCount++;
100	message->flags = flags;
101	message->posted = posted;
102	message->duration = duration;
103	message->from = strdup(from);
104	message->message = strdup(msg);
105
106	if(messageList)
107	{
108	messageList->prev = message;
109	}
110
111	message->prev = NULL;
112	message->next = messageList;
113
114	messageList = message;
115
116	if(duration)
117	{
118	timeq_add(now + duration, message_expire, message);
119	}
120
121	return message;
122	}
123
124	static void
125	message_del(struct globalMessage *message)
126	{
127	if(message->duration)
128	{
129	timeq_del(0, NULL, message, TIMEQ_IGNORE_FUNC \| TIMEQ_IGNORE_WHEN);
130	}
131
132	if(message->prev) message->prev->next = message->next;
133	else messageList = message->next;
134
135	if(message->next) message->next->prev = message->prev;
136
137	free(message->from);
138	free(message->message);
139	free(message);
140	}
141
142	void message_expire(void *data)
143	{
144	struct globalMessage *message = data;
145
146	message->duration = 0;
147	message_del(message);
148	}
149
150	static struct globalMessage*
151	message_create(struct userNode user, unsigned int argc, char argv[])
152	{
153	unsigned long duration = 0;
154	char *text = NULL;
155	long flags = 0;
156	unsigned int i;
157
158	for(i = 0; i < argc; i++)
159	{
160	if((i + 1) > argc)
161	{
162	global_notice(user, "MSG_MISSING_PARAMS", argv[argc]);
163	return NULL;
164	}
165
166	if(!irccasecmp(argv[i], "text"))
167	{
168	i++;
169	text = unsplit_string(argv + i, argc - i, NULL);
170	break;
171	} else if (!irccasecmp(argv[i], "sourceless")) {
172	i++;
173	flags \|= MESSAGE_OPTION_SOURCELESS;
174	} else if (!irccasecmp(argv[i], "target")) {
175	i++;
176
177	if(!irccasecmp(argv[i], "all")) {
178	flags \|= MESSAGE_RECIPIENT_ALL;
179	} else if(!irccasecmp(argv[i], "users")) {
180	flags \|= MESSAGE_RECIPIENT_LUSERS;
181	} else if(!irccasecmp(argv[i], "helpers")) {
182	flags \|= MESSAGE_RECIPIENT_HELPERS;
183	} else if(!irccasecmp(argv[i], "opers")) {
184	flags \|= MESSAGE_RECIPIENT_OPERS;
185	} else if(!irccasecmp(argv[i], "staff") \|\| !irccasecmp(argv[i], "privileged")) {
186	flags \|= MESSAGE_RECIPIENT_STAFF;
187	} else if(!irccasecmp(argv[i], "channels")) {
188	flags \|= MESSAGE_RECIPIENT_CHANNELS;
189	} else if(!irccasecmp(argv[i], "announcement") \|\| !irccasecmp(argv[i], "announce")) {
190	flags \|= MESSAGE_RECIPIENT_ANNOUNCE;
191	} else {
192	global_notice(user, "GMSG_INVALID_TARGET", argv[i]);
193	return NULL;
194	}
195	} else if (irccasecmp(argv[i], "duration") == 0) {
196	duration = ParseInterval(argv[++i]);
197	} else {
198	global_notice(user, "MSG_INVALID_CRITERIA", argv[i]);
199	return NULL;
200	}
201	}
202
203	if(!flags)
204	{
205	flags = MESSAGE_RECIPIENT_LUSERS;
206	}
207
208	if(!text) {
209	global_notice(user, "GMSG_MESSAGE_REQUIRED");
210	return NULL;
211	}
212
213	return message_add(flags, now, duration, user->handle_info->handle, text);
214	}
215
216	static const char *
217	messageType(const struct globalMessage *message)
218	{
219	if((message->flags & MESSAGE_RECIPIENT_ALL) == MESSAGE_RECIPIENT_ALL)
220	{
221	return "all";
222	}
223	if((message->flags & MESSAGE_RECIPIENT_STAFF) == MESSAGE_RECIPIENT_STAFF)
224	{
225	return "staff";
226	}
227	else if(message->flags & MESSAGE_RECIPIENT_ANNOUNCE)
228	{
229	return "announcement";
230	}
231	else if(message->flags & MESSAGE_RECIPIENT_OPERS)
232	{
233	return "opers";
234	}
235	else if(message->flags & MESSAGE_RECIPIENT_HELPERS)
236	{
237	return "helpers";
238	}
239	else if(message->flags & MESSAGE_RECIPIENT_LUSERS)
240	{
241	return "users";
242	}
243	else
244	{
245	return "channels";
246	}
247	}
248
249	static void
250	notice_target(const char target, struct globalMessage message)
251	{
252	if(!(message->flags & MESSAGE_OPTION_SOURCELESS))
253	{
254	if(message->flags & MESSAGE_OPTION_IMMEDIATE)
255	{
256	send_target_message(0, target, global, "GMSG_NOTICE_SOURCE", messageType(message), message->from);
257	}
258	else
259	{
260	char posted[24];
261	struct tm tm;
262
263	localtime_r(&message->posted, &tm);
264	strftime(posted, sizeof(posted), "%I:%M %p, %m/%d/%Y", &tm);
265	send_target_message(0, target, global, "GMSG_MESSAGE_SOURCE", messageType(message), message->from, posted);
266	}
267	}
268
269	send_target_message(4, target, global, "%s", message->message);
270	}
271
272	static int
273	notice_channel(const char key, void data, void *extra)
274	{
275	struct chanNode *channel = data;
276	/* It should be safe to assume channel is not NULL. */
277	if(channel->channel_info)
278	notice_target(key, extra);
279	return 0;
280	}
281
282	static void
283	message_send(struct globalMessage *message)
284	{
285	struct userNode *user;
286	unsigned long n;
287	dict_iterator_t it;
288
289	if(message->flags & MESSAGE_RECIPIENT_CHANNELS)
290	{
291	dict_foreach(channels, notice_channel, message);
292	}
293
294	if(message->flags & MESSAGE_RECIPIENT_LUSERS)
295	{
296	notice_target("$*", message);
297	return;
298	}
299
300	if(message->flags & MESSAGE_RECIPIENT_ANNOUNCE)
301	{
302	char announce;
303
304	for (it = dict_first(clients); it; it = iter_next(it)) {
305	user = iter_data(it);
306	if (user->uplink == self) continue;
307	announce = user->handle_info ? user->handle_info->announcements : '?';
308	if (announce == 'n') continue;
309	if ((announce == '?') && !global_conf.announcements_default) continue;
310	notice_target(user->nick, message);
311	}
312	}
313
314	if(message->flags & MESSAGE_RECIPIENT_OPERS)
315	{
316	for(n = 0; n < curr_opers.used; n++)
317	{
318	user = curr_opers.list[n];
319
320	if(user->uplink != self)
321	{
322	notice_target(user->nick, message);
323	}
324	}
325	}
326
327	if(message->flags & MESSAGE_RECIPIENT_HELPERS)
328	{
329	for(n = 0; n < curr_helpers.used; n++)
330	{
331	user = curr_helpers.list[n];
332	if (IsOper(user))
333	continue;
334	notice_target(user->nick, message);
335	}
336	}
337	}
338
339	void
340	global_message(long targets, char *text)
341	{
342	struct globalMessage *message;
343
344	if(!targets \|\| !global)
345	return;
346
347	message = message_add(targets \| MESSAGE_OPTION_SOURCELESS, now, 0, "", text);
348	if(!message)
349	return;
350
351	message_send(message);
352	message_del(message);
353	}
354
355	static GLOBAL_FUNC(cmd_notice)
356	{
357	struct globalMessage *message = NULL;
358	const char recipient = NULL, text;
359	long target = 0;
360
361	assert(argc >= 3);
362	if(!irccasecmp(argv[1], "all")) {
363	target = MESSAGE_RECIPIENT_ALL;
364	} else if(!irccasecmp(argv[1], "users")) {
365	target = MESSAGE_RECIPIENT_LUSERS;
366	} else if(!irccasecmp(argv[1], "helpers")) {
367	target = MESSAGE_RECIPIENT_HELPERS;
368	} else if(!irccasecmp(argv[1], "opers")) {
369	target = MESSAGE_RECIPIENT_OPERS;
370	} else if(!irccasecmp(argv[1], "staff") \|\| !irccasecmp(argv[1], "privileged")) {
371	target \|= MESSAGE_RECIPIENT_HELPERS \| MESSAGE_RECIPIENT_OPERS;
372	} else if(!irccasecmp(argv[1], "announcement") \|\| !irccasecmp(argv[1], "announce")) {
373	target \|= MESSAGE_RECIPIENT_ANNOUNCE;
374	} else if(!irccasecmp(argv[1], "channels")) {
375	target = MESSAGE_RECIPIENT_CHANNELS;
376	} else {
377	global_notice(user, "GMSG_INVALID_TARGET", argv[1]);
378	return 0;
379	}
380
381	text = unsplit_string(argv + 2, argc - 2, NULL);
382	message = message_add(target \| MESSAGE_OPTION_IMMEDIATE, now, 0, user->handle_info->handle, text);
383
384	if(!message)
385	{
386	return 0;
387	}
388
389	recipient = messageType(message);
390
391	message_send(message);
392	message_del(message);
393
394	global_notice(user, "GMSG_MESSAGE_SENT", recipient);
395	return 1;
396	}
397
398	static GLOBAL_FUNC(cmd_message)
399	{
400	struct globalMessage *message = NULL;
401	const char *recipient = NULL;
402
403	assert(argc >= 3);
404	message = message_create(user, argc - 1, argv + 1);
405	if(!message)
406	return 0;
407	recipient = messageType(message);
408	global_notice(user, "GMSG_MESSAGE_ADDED", recipient, message->id);
409	return 1;
410	}
411
412	static GLOBAL_FUNC(cmd_list)
413	{
414	struct globalMessage *message;
415	struct helpfile_table table;
416	unsigned int length, nn;
417
418	if(!messageList)
419	{
420	global_notice(user, "GMSG_NO_MESSAGES");
421	return 1;
422	}
423
424	for(nn=0, message = messageList; message; nn++, message=message->next) ;
425	table.length = nn+1;
426	table.width = 5;
427	table.flags = TABLE_NO_FREE;
428	table.contents = calloc(table.length, sizeof(char**));
429	table.contents[0] = calloc(table.width, sizeof(char*));
430	table.contents[0][0] = "ID";
431	table.contents[0][1] = "Target";
432	table.contents[0][2] = "Expires";
433	table.contents[0][3] = "From";
434	table.contents[0][4] = "Message";
435
436	for(nn=1, message = messageList; message; nn++, message = message->next)
437	{
438	char buffer[64];
439
440	table.contents[nn] = calloc(table.width, sizeof(char*));
441	snprintf(buffer, sizeof(buffer), "%lu", message->id);
442	table.contents[nn][0] = strdup(buffer);
443	table.contents[nn][1] = messageType(message);
444	if(message->duration)
445	intervalString(buffer, message->posted + message->duration - now, user->handle_info);
446	else
447	strcpy(buffer, "Never.");
448	table.contents[nn][2] = strdup(buffer);
449	table.contents[nn][3] = message->from;
450	length = strlen(message->message);
451	safestrncpy(buffer, message->message, sizeof(buffer));
452	if(length > (sizeof(buffer) - 4))
453	{
454	buffer[sizeof(buffer) - 1] = 0;
455	buffer[sizeof(buffer) - 2] = buffer[sizeof(buffer) - 3] = buffer[sizeof(buffer) - 4] = '.';
456	}
457	table.contents[nn][4] = strdup(buffer);
458	}
459	table_send(global, user->nick, 0, NULL, table);
460	for (nn=1; nn<table.length; nn++)
461	{
462	free((char*)table.contents[nn][0]);
463	free((char*)table.contents[nn][2]);
464	free((char*)table.contents[nn][4]);
465	free(table.contents[nn]);
466	}
467	free(table.contents[0]);
468	free(table.contents);
469
470	return 1;
471	}
472
473	static GLOBAL_FUNC(cmd_remove)
474	{
475	struct globalMessage *message = NULL;
476	unsigned long id;
477
478	assert(argc >= 2);
479	id = strtoul(argv[1], NULL, 0);
480
481	for(message = messageList; message; message = message->next)
482	{
483	if(message->id == id)
484	{
485	message_del(message);
486	global_notice(user, "GMSG_MESSAGE_DELETED", argv[1]);
487	return 1;
488	}
489	}
490
491	global_notice(user, "GMSG_ID_INVALID", argv[1]);
492	return 0;
493	}
494
495	static unsigned int
496	send_messages(struct userNode *user, long mask, int obstreperize)
497	{
498	struct globalMessage *message = messageList;
499	unsigned int count = 0;
500
501	while(message)
502	{
503	if(message->flags & mask)
504	{
505	if (obstreperize && !count)
506	send_target_message(0, user->nick, global, "GMSG_MOTD_HEADER");
507	notice_target(user->nick, message);
508	count++;
509	}
510
511	message = message->next;
512	}
513	if (obstreperize && count)
514	send_target_message(0, user->nick, global, "GMSG_MOTD_FOOTER");
515	return count;
516	}
517
518	static GLOBAL_FUNC(cmd_messages)
519	{
520	long mask = MESSAGE_RECIPIENT_LUSERS \| MESSAGE_RECIPIENT_CHANNELS;
521	unsigned int count;
522
523	if(IsOper(user))
524	mask \|= MESSAGE_RECIPIENT_OPERS;
525
526	if(IsHelper(user))
527	mask \|= MESSAGE_RECIPIENT_HELPERS;
528
529	count = send_messages(user, mask, 0);
530	if(count)
531	global_notice(user, "GMSG_MESSAGE_COUNT", count);
532	else
533	global_notice(user, "GMSG_NO_MESSAGES");
534
535	return 1;
536	}
537
538	static int
539	global_process_user(struct userNode *user)
540	{
541	if(IsLocal(user) \|\| self->uplink->burst \|\| user->uplink->burst)
542	return 0;
543	send_messages(user, MESSAGE_RECIPIENT_LUSERS, 1);
544
545	/* only alert on new usercount if the record was broken in the last
546	* 30 seconds, and no alert had been sent in that time.
547	*/
548	if((now - max_clients_time) <= 30 && (now - last_max_alert) > 30)
549	{
550	char *message;
551	message = alloca(36);
552	sprintf(message, "New user count record: %d", max_clients);
553	global_message(MESSAGE_RECIPIENT_OPERS, message);
554	last_max_alert = now;
555	}
556
557	return 0;
558	}
559
560	static void
561	global_process_auth(struct userNode user, UNUSED_ARG(struct handle_info old_handle))
562	{
563	if(IsHelper(user))
564	send_messages(user, MESSAGE_RECIPIENT_HELPERS, 0);
565	}
566
567	static void
568	global_process_oper(struct userNode *user)
569	{
570	if(user->uplink->burst)
571	return;
572	send_messages(user, MESSAGE_RECIPIENT_OPERS, 0);
573	}
574
575	static void
576	global_conf_read(void)
577	{
578	dict_t conf_node;
579	const char *str;
580
581	if (!(conf_node = conf_get_data(GLOBAL_CONF_NAME, RECDB_OBJECT))) {
582	log_module(G_LOG, LOG_ERROR, "config node `%s' is missing or has wrong type.", GLOBAL_CONF_NAME);
583	return;
584	}
585
586	str = database_get_data(conf_node, KEY_DB_BACKUP_FREQ, RECDB_QSTRING);
587	global_conf.db_backup_frequency = str ? ParseInterval(str) : 7200;
588	str = database_get_data(conf_node, KEY_ANNOUNCEMENTS_DEFAULT, RECDB_QSTRING);
589	global_conf.announcements_default = str ? enabled_string(str) : 1;
590
591	str = database_get_data(conf_node, KEY_NICK, RECDB_QSTRING);
592	if(global && str)
593	NickChange(global, str, 0);
594	}
595
596	static int
597	global_saxdb_read(struct dict *db)
598	{
599	struct record_data *hir;
600	time_t posted;
601	long flags;
602	unsigned long duration;
603	char str, from, *message;
604	dict_iterator_t it;
605
606	for(it=dict_first(db); it; it=iter_next(it))
607	{
608	hir = iter_data(it);
609	if(hir->type != RECDB_OBJECT)
610	{
611	log_module(G_LOG, LOG_WARNING, "Unexpected rectype %d for %s.", hir->type, iter_key(it));
612	continue;
613	}
614
615	str = database_get_data(hir->d.object, KEY_FLAGS, RECDB_QSTRING);
616	flags = str ? strtoul(str, NULL, 0) : 0;
617
618	str = database_get_data(hir->d.object, KEY_POSTED, RECDB_QSTRING);
619	posted = str ? strtoul(str, NULL, 0) : 0;
620
621	str = database_get_data(hir->d.object, KEY_DURATION, RECDB_QSTRING);
622	duration = str ? strtoul(str, NULL, 0) : 0;
623
624	from = database_get_data(hir->d.object, KEY_FROM, RECDB_QSTRING);
625	message = database_get_data(hir->d.object, KEY_MESSAGE, RECDB_QSTRING);
626
627	message_add(flags, posted, duration, from, message);
628	}
629	return 0;
630	}
631
632	static int
633	global_saxdb_write(struct saxdb_context *ctx)
634	{
635	struct globalMessage *message;
636	char str[16];
637
638	for(message = messageList; message; message = message->next) {
639	snprintf(str, sizeof(str), "%li", message->id);
640	saxdb_start_record(ctx, str, 0);
641	saxdb_write_int(ctx, KEY_FLAGS, message->flags);
642	saxdb_write_int(ctx, KEY_POSTED, message->posted);
643	saxdb_write_int(ctx, KEY_DURATION, message->duration);
644	saxdb_write_string(ctx, KEY_FROM, message->from);
645	saxdb_write_string(ctx, KEY_MESSAGE, message->message);
646	saxdb_end_record(ctx);
647	}
648	return 0;
649	}
650
651	static void
652	global_db_cleanup(void)
653	{
654	while(messageList)
655	message_del(messageList);
656	}
657
658	void
659	init_global(const char *nick)
660	{
661	G_LOG = log_register_type("Global", "file:global.log");
662	reg_new_user_func(global_process_user);
663	reg_auth_func(global_process_auth);
664	reg_oper_func(global_process_oper);
665
666	conf_register_reload(global_conf_read);
667
668	global_module = module_register("Global", G_LOG, "global.help", NULL);
669	modcmd_register(global_module, "LIST", cmd_list, 1, 0, "flags", "+oper", NULL);
670	modcmd_register(global_module, "MESSAGE", cmd_message, 3, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);
671	modcmd_register(global_module, "MESSAGES", cmd_messages, 1, 0, NULL);
672	modcmd_register(global_module, "NOTICE", cmd_notice, 3, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);
673	modcmd_register(global_module, "REMOVE", cmd_remove, 2, MODCMD_REQUIRE_AUTHED, "flags", "+oper", NULL);
674
675	if(nick)
676	{
a32da4c7	677	const char *modes = conf_get_data("services/global/modes", RECDB_QSTRING);
a32da4c7	678	global = AddService(nick, modes ? modes : NULL, "Global Services", NULL);
d76ed9a9	679	global_service = service_register(global);
	680	}
	681	saxdb_register("Global", global_saxdb_read, global_saxdb_write);
	682	reg_exit_func(global_db_cleanup);
	683	message_register_table(msgtab);
	684	}