src/modules/NeonServ.mod/cmd_neonserv_invite.c

   1 /* cmd_neonserv_invite.c - NeonServ v5.4
   2  * Copyright (C) 2011-2012  Philipp Kreil (pk910)
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "cmd_neonserv.h"
  19
  20 /*
  21 * argv[0] - nick / *auth
  22 */
  23 static USERAUTH_CALLBACK(neonserv_cmd_invite_nick_lookup);
  24 static void neonserv_cmd_invite_async1(struct ClientSocket *client, struct ClientSocket *textclient, struct UserNode *user, struct ChanNode *chan, struct Event *event, char *nick, char *auth);
  25 static TIMEQ_CALLBACK(neonserv_cmd_invite_timeout_timeout);
  26 static struct neonserv_cmd_invite_timeout* neonserv_cmd_invite_add_timeout(char *nick, char *chan);
  27 static int neonserv_cmd_invite_is_timeout(char *nick, char *chan);
  28 static void neonserv_cmd_invite_del_timeout(struct neonserv_cmd_invite_timeout *timeout);
  29
  30
  31 struct neonserv_cmd_invite_cache {
  32     struct ClientSocket *client, *textclient;
  33     struct UserNode *user;
  34     struct ChanNode *chan;
  35     struct Event *event;
  36     char *nick;
  37 };
  38
  39 struct neonserv_cmd_invite_timeout {
  40     char *nick;
  41     char *chan;
  42
  43     struct neonserv_cmd_invite_timeout *next;
  44 };
  45
  46 static struct neonserv_cmd_invite_timeout *first_timeout = NULL, *last_timeout = NULL;
  47
  48 CMD_BIND(neonserv_cmd_invite) {
  49     if(neonserv_cmd_invite_is_timeout(argv[0], chan->name)) {
  50         reply(getTextBot(), user, "NS_INVITE_TIMEOUT", argv[0], chan->name);
  51         return;
  52     }
  53     struct UserNode *cuser = getUserByNick(argv[0]);
  54     if(!cuser) {
  55         cuser = createTempUser(argv[0]);
  56                 if(!cuser) {
  57             reply(getTextBot(), user, "NS_USER_UNKNOWN", argv[0]);
  58             return;
  59         }
  60         cuser->flags |= USERFLAG_ISTMPUSER;
  61     } else if(getChanUser(cuser, chan)) {
  62         reply(getTextBot(), user, "NS_INVITE_ON_CHAN", cuser->nick, chan->name);
  63         /* BUG
  64          This check does not work if the user is invisible (CHMODE +D/+d)
  65          to fix this we'd need to request the full userlist...
  66          this is really senseless to invite a simple user so we simply mark this bug as unsolvable.
  67         */
  68         return;
  69     }
  70     if(cuser->flags & USERFLAG_ISAUTHED) {
  71         neonserv_cmd_invite_async1(client, getTextBot(), user, chan, event, argv[0], cuser->auth);
  72     } else {
  73         struct neonserv_cmd_invite_cache *cache = malloc(sizeof(*cache));
  74         if (!cache) {
  75             perror("malloc() failed");
  76             return;
  77         }
  78         cache->client = client;
  79         cache->textclient = getTextBot();
  80         cache->user = user;
  81         cache->chan = chan;
  82         cache->event = event;
  83         cache->nick = strdup(argv[0]);
  84         get_userauth(cuser, module_id, neonserv_cmd_invite_nick_lookup, cache);
  85     }
  86 }
  87
  88 static USERAUTH_CALLBACK(neonserv_cmd_invite_nick_lookup) {
  89     struct neonserv_cmd_invite_cache *cache = data;
  90     if(!user) {
  91         //USER_DOES_NOT_EXIST
  92         reply(cache->textclient, cache->user, "NS_USER_UNKNOWN", cache->nick);
  93     } else
  94         neonserv_cmd_invite_async1(cache->client, cache->textclient, cache->user, cache->chan, cache->event, user->nick, ((user->flags & USERFLAG_ISAUTHED) ? user->auth : NULL));
  95     free(cache->nick);
  96     free(cache);
  97 }
  98
  99 static void neonserv_cmd_invite_async1(struct ClientSocket *client, struct ClientSocket *textclient, struct UserNode *user, struct ChanNode *chan, struct Event *event, char *nick, char *auth) {
 100     if(auth) {
 101         MYSQL_RES *res;
 102         MYSQL_ROW row;
 103         printf_mysql_query("SELECT `user_id`, `user_block_invites` FROM `users` WHERE `user_user` = '%s'", escape_string(auth));
 104         res = mysql_use();
 105         if ((row = mysql_fetch_row(res)) != NULL) {
 106             //check if the user has blocked invites globally
 107             if(!strcmp(row[1], "1")) {
 108                 reply(textclient, user, "NS_INVITE_GLOBALLY_BLOCKED", nick);
 109                 return;
 110             }
 111             //check if the user has set noinvite
 112             printf_mysql_query("SELECT `id` FROM `noinvite` WHERE `uid` = '%s' AND `cid` = '%d'", row[0], chan->channel_id);
 113             res = mysql_use();
 114             if ((row = mysql_fetch_row(res)) != NULL) {
 115                 reply(textclient, user, "NS_INVITE_RESTRICTION", nick, chan->name);
 116                 return;
 117             }
 118         }
 119     }
 120     struct neonserv_cmd_invite_timeout *timeout = neonserv_cmd_invite_add_timeout(nick, chan->name);
 121     timeq_add(INVITE_TIMEOUT, module_id, neonserv_cmd_invite_timeout_timeout, timeout);
 122     putsock(client, "INVITE %s %s", nick, chan->name);
 123     struct UserNode *tmpu = getUserByNick(nick);
 124     if(!tmpu) {
 125         tmpu = createTempUser(nick);
 126         tmpu->flags |= USERFLAG_ISTMPUSER | (auth ? USERFLAG_ISAUTHED : 0);
 127         if(auth)
 128             strcpy(tmpu->auth, auth);
 129     }
 130     reply(textclient, tmpu, "NS_INVITE_DONE_USER", chan->name, user->nick, client->user->nick);
 131     reply(textclient, user, "NS_INVITE_DONE", nick, chan->name);
 132 }
 133
 134 static TIMEQ_CALLBACK(neonserv_cmd_invite_timeout_timeout) {
 135     struct neonserv_cmd_invite_timeout *entry = data;
 136     neonserv_cmd_invite_del_timeout(entry);
 137 }
 138
 139 static struct neonserv_cmd_invite_timeout* neonserv_cmd_invite_add_timeout(char *nick, char *chan) {
 140     struct neonserv_cmd_invite_timeout *entry = malloc(sizeof(*entry));
 141     if (!entry) {
 142         perror("malloc() failed");
 143         return NULL;
 144     }
 145     entry->next = NULL;
 146     entry->nick = strdup(nick);
 147     entry->chan = strdup(chan);
 148     if(last_timeout) {
 149         last_timeout->next = entry;
 150         last_timeout = entry;
 151     } else {
 152         last_timeout = entry;
 153         first_timeout = entry;
 154     }
 155     return entry;
 156 }
 157
 158 static int neonserv_cmd_invite_is_timeout(char *nick, char *chan) {
 159     if(!first_timeout) return 0;
 160     struct neonserv_cmd_invite_timeout *entry;
 161     for(entry = first_timeout; entry; entry = entry->next) {
 162         if(!stricmp(entry->nick, nick) && !stricmp(entry->chan, chan))
 163             return 1;
 164     }
 165     return 0;
 166 }
 167
 168 static void neonserv_cmd_invite_del_timeout(struct neonserv_cmd_invite_timeout *timeout) {
 169     struct neonserv_cmd_invite_timeout *entry, *prev = NULL;
 170     for(entry = first_timeout; entry; entry = entry->next) {
 171         if(entry == timeout) {
 172             if(prev)
 173                 prev->next = entry->next;
 174             else
 175                 first_timeout = entry->next;
 176             break;
 177         } else
 178             prev = entry;
 179     }
 180     if(last_timeout == timeout)
 181         last_timeout = prev;
 182     free(timeout->nick);
 183     free(timeout->chan);
 184     free(timeout);
 185 }