modules/um_callerid.c

   1 /*
   2  * modules/um_callerid.c
   3  * Copyright (c) 2020 Ariadne Conill <ariadne@dereferenced.org>
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright notice,
  10  *    this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  21  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  23  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  25  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  26  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27  * POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "stdinc.h"
  31 #include "modules.h"
  32 #include "hook.h"
  33 #include "client.h"
  34 #include "ircd.h"
  35 #include "send.h"
  36 #include "hash.h"
  37 #include "s_conf.h"
  38 #include "s_user.h"
  39 #include "s_serv.h"
  40 #include "numeric.h"
  41 #include "privilege.h"
  42 #include "s_newconf.h"
  43 #include "hook.h"
  44 #include "supported.h"
  45 #include "logger.h"
  46
  47 static int
  48 um_callerid_modinit(void)
  49 {
  50         user_modes['g'] = find_umode_slot();
  51         if (!user_modes['g'])
  52         {
  53                 ierror("um_callerid: unable to allocate usermode slot for +g; unloading module.");
  54                 return -1;
  55         }
  56
  57         user_modes['G'] = find_umode_slot();
  58         if (!user_modes['G'])
  59         {
  60                 user_modes['g'] = 0;
  61
  62                 ierror("um_callerid: unable to allocate usermode slot for +G; unloading module.");
  63                 return -1;
  64         }
  65
  66         construct_umodebuf();
  67
  68         add_isupport("CALLERID", isupport_umode, "g");
  69
  70         return 0;
  71 }
  72
  73 static void
  74 um_callerid_moddeinit(void)
  75 {
  76         user_modes['g'] = 0;
  77         user_modes['G'] = 0;
  78         construct_umodebuf();
  79
  80         delete_isupport("CALLERID");
  81 }
  82
  83 #define IsSetStrictCallerID(c)  ((c->umodes & user_modes['g']) == user_modes['g'])
  84 #define IsSetRelaxedCallerID(c) ((c->umodes & user_modes['G']) == user_modes['G'])
  85 #define IsSetAnyCallerID(c)     (IsSetStrictCallerID(c) || IsSetRelaxedCallerID(c))
  86
  87 static const char um_callerid_desc[] =
  88         "Provides usermodes +g and +G which restrict messages from unauthorized users.";
  89
  90 static bool
  91 has_common_channel(struct Client *source_p, struct Client *target_p)
  92 {
  93         rb_dlink_node *ps, *pt;
  94         struct membership *ms, *mt;
  95         struct Channel *chptr;
  96
  97         ITER_COMM_CHANNELS(ps, pt, source_p->user->channel.head, target_p->user->channel.head, ms, mt, chptr)
  98         {
  99                 if (ms != NULL && mt != NULL)
 100                         return true;
 101         }
 102
 103         return false;
 104 }
 105
 106 static bool
 107 allow_message(struct Client *source_p, struct Client *target_p)
 108 {
 109         if (!MyClient(target_p))
 110                 return true;
 111
 112         if (!IsSetAnyCallerID(target_p))
 113                 return true;
 114
 115         if (IsSetRelaxedCallerID(target_p) && has_common_channel(source_p, target_p) && !IsSetStrictCallerID(target_p))
 116                 return true;
 117
 118         if (IsServer(source_p))
 119                 return true;
 120
 121         /* XXX: controversial?  allow opers to send through +g */
 122         if (IsOperGeneral(source_p))
 123                 return true;
 124
 125         if (accept_message(source_p, target_p))
 126                 return true;
 127
 128         return false;
 129 }
 130
 131 static void
 132 send_callerid_notice(enum message_type msgtype, struct Client *source_p, struct Client *target_p)
 133 {
 134         if (!MyClient(target_p))
 135                 return;
 136
 137         if (msgtype == MESSAGE_TYPE_NOTICE)
 138                 return;
 139
 140         sendto_one_numeric(source_p, ERR_TARGUMODEG, form_str(ERR_TARGUMODEG),
 141                 target_p->name, IsSetStrictCallerID(target_p) ? "+g" : "+G");
 142
 143         if ((target_p->localClient->last_caller_id_time + ConfigFileEntry.caller_id_wait) < rb_current_time())
 144         {
 145                 sendto_one_numeric(source_p, RPL_TARGNOTIFY, form_str(RPL_TARGNOTIFY),
 146                         target_p->name);
 147
 148                 sendto_one(target_p, form_str(RPL_UMODEGMSG),
 149                            me.name, target_p->name, source_p->name,
 150                            source_p->username, source_p->host, IsSetStrictCallerID(target_p) ? "+g" : "+G");
 151
 152                 target_p->localClient->last_caller_id_time = rb_current_time();
 153         }
 154 }
 155
 156 static bool
 157 add_callerid_accept_for_source(enum message_type msgtype, struct Client *source_p, struct Client *target_p)
 158 {
 159         /* only do this on source_p's server */
 160         if (!MyClient(source_p))
 161                 return true;
 162
 163         /*
 164          * XXX: Controversial? Allow target users to send replies
 165          * through a +g.  Rationale is that people can presently use +g
 166          * as a way to taunt users, e.g. harass them and hide behind +g
 167          * as a way of griefing.  --nenolod
 168          */
 169         if(msgtype != MESSAGE_TYPE_NOTICE &&
 170                 IsSetAnyCallerID(source_p) &&
 171                 !accept_message(target_p, source_p) &&
 172                 !IsOperGeneral(target_p))
 173         {
 174                 if(rb_dlink_list_length(&source_p->localClient->allow_list) <
 175                                 (unsigned long)ConfigFileEntry.max_accept)
 176                 {
 177                         rb_dlinkAddAlloc(target_p, &source_p->localClient->allow_list);
 178                         rb_dlinkAddAlloc(source_p, &target_p->on_allow_list);
 179                 }
 180                 else
 181                 {
 182                         sendto_one_numeric(source_p, ERR_OWNMODE,
 183                                         form_str(ERR_OWNMODE),
 184                                         target_p->name, IsSetStrictCallerID(target_p) ? "+g" : "+G");
 185                         return false;
 186                 }
 187         }
 188
 189         return true;
 190 }
 191
 192 static void
 193 h_hdl_invite(void *vdata)
 194 {
 195         hook_data_channel_approval *data = vdata;
 196         struct Client *source_p = data->client;
 197         struct Client *target_p = data->target;
 198         static char errorbuf[BUFSIZE];
 199
 200         if (data->approved)
 201                 return;
 202
 203         if (!add_callerid_accept_for_source(MESSAGE_TYPE_PRIVMSG, source_p, target_p))
 204         {
 205                 data->approved = ERR_TARGUMODEG;
 206                 return;
 207         }
 208
 209         if (allow_message(source_p, target_p))
 210                 return;
 211
 212         snprintf(errorbuf, sizeof errorbuf, form_str(ERR_TARGUMODEG),
 213                  target_p->name, IsSetStrictCallerID(target_p) ? "+g" : "+G");
 214
 215         data->approved = ERR_TARGUMODEG;
 216         data->error = errorbuf;
 217 }
 218
 219 static void
 220 h_hdl_privmsg_user(void *vdata)
 221 {
 222         hook_data_privmsg_user *data = vdata;
 223         enum message_type msgtype = data->msgtype;
 224         struct Client *source_p = data->source_p;
 225         struct Client *target_p = data->target_p;
 226
 227         if (data->approved)
 228                 return;
 229
 230         if (!add_callerid_accept_for_source(msgtype, source_p, target_p))
 231         {
 232                 data->approved = ERR_TARGUMODEG;
 233                 return;
 234         }
 235
 236         if (allow_message(source_p, target_p))
 237                 return;
 238
 239         send_callerid_notice(msgtype, source_p, target_p);
 240
 241         data->approved = ERR_TARGUMODEG;
 242 }
 243
 244 static mapi_hfn_list_av1 um_callerid_hfnlist[] = {
 245         { "invite", h_hdl_invite },
 246         { "privmsg_user", h_hdl_privmsg_user },
 247         { NULL, NULL }
 248 };
 249
 250 DECLARE_MODULE_AV2(um_callerid, um_callerid_modinit, um_callerid_moddeinit,
 251                    NULL, NULL, um_callerid_hfnlist, NULL, NULL, um_callerid_desc);