ircd/supported.c

   1 /*
   2  *  Solanum: a slightly advanced ircd
   3  *  supported.c: isupport (005) numeric
   4  *
   5  * Copyright (C) 2006 Jilles Tjoelker
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are
   9  * met:
  10  *
  11  * 1.Redistributions of source code must retain the above copyright notice,
  12  *   this list of conditions and the following disclaimer.
  13  * 2.Redistributions in binary form must reproduce the above copyright
  14  *   notice, this list of conditions and the following disclaimer in the
  15  *   documentation and/or other materials provided with the distribution.
  16  * 3.The name of the author may not be used to endorse or promote products
  17  *   derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  23  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  27  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  28  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /* From the old supported.h which is
  33  *  Copyright (C) 1996-2002 Hybrid Development Team
  34  *  Copyright (C) 2002-2004 ircd-ratbox development team
  35  */
  36 /*
  37  * - from mirc's versions.txt
  38  *
  39  *  mIRC now supports the numeric 005 tokens: CHANTYPES=# and
  40  *  PREFIX=(ohv)@%+ and can handle a dynamic set of channel and
  41  *  nick prefixes.
  42  *
  43  *  mIRC assumes that @ is supported on all networks, any mode
  44  *  left of @ is assumed to have at least equal power to @, and
  45  *  any mode right of @ has less power.
  46  *
  47  *  mIRC has internal support for @%+ modes.
  48  *
  49  *  $nick() can now handle all mode letters listed in PREFIX.
  50  *
  51  *  Also added support for CHANMODES=A,B,C,D token (not currently
  52  *  supported by any servers), which lists all modes supported
  53  *  by a channel, where:
  54  *
  55  *    A = modes that take a parameter, and add or remove nicks
  56  *        or addresses to a list, such as +bIe for the ban,
  57  *        invite, and exception lists.
  58  *
  59  *    B = modes that change channel settings, but which take
  60  *        a parameter when they are set and unset, such as
  61  *        +k key, and -k key.
  62  *
  63  *    C = modes that change channel settings, but which take
  64  *        a parameter only when they are set, such as +l N,
  65  *        and -l.
  66  *
  67  *    D = modes that change channel settings, such as +imnpst
  68  *        and take no parameters.
  69  *
  70  *  All unknown/unlisted modes are treated as type D.
  71  */
  72
  73 #include "stdinc.h"
  74 #include "client.h"
  75 #include "numeric.h"
  76 #include "ircd.h"
  77 #include "s_conf.h"
  78 #include "s_user.h"
  79 #include "supported.h"
  80 #include "chmode.h"
  81 #include "send.h"
  82
  83 static char allowed_chantypes[BUFSIZE];
  84 rb_dlink_list isupportlist;
  85
  86 struct isupportitem
  87 {
  88         const char *name;
  89         const char *(*func)(const void *);
  90         const void *param;
  91         rb_dlink_node node;
  92 };
  93
  94 void
  95 add_isupport(const char *name, const char *(*func)(const void *), const void *param)
  96 {
  97         struct isupportitem *item;
  98
  99         item = rb_malloc(sizeof(struct isupportitem));
 100         item->name = name;
 101         item->func = func;
 102         item->param = param;
 103         rb_dlinkAddTail(item, &item->node, &isupportlist);
 104 }
 105
 106 const void *
 107 change_isupport(const char *name, const char *(*func)(const void *), const void *param)
 108 {
 109         rb_dlink_node *ptr;
 110         struct isupportitem *item;
 111         const void *oldvalue = NULL;
 112
 113         RB_DLINK_FOREACH(ptr, isupportlist.head)
 114         {
 115                 item = ptr->data;
 116
 117                 if (!strcmp(item->name, name))
 118                 {
 119                         oldvalue = item->param;
 120
 121                         // item->name = name;
 122                         item->func = func;
 123                         item->param = param;
 124
 125                         break;
 126                 }
 127         }
 128
 129         return oldvalue;
 130 }
 131
 132 void
 133 delete_isupport(const char *name)
 134 {
 135         rb_dlink_node *ptr, *next_ptr;
 136         struct isupportitem *item;
 137
 138         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, isupportlist.head)
 139         {
 140                 item = ptr->data;
 141
 142                 if (!strcmp(item->name, name))
 143                 {
 144                         rb_dlinkDelete(ptr, &isupportlist);
 145                         rb_free(item);
 146                 }
 147         }
 148 }
 149
 150 /* XXX caching? */
 151 void
 152 show_isupport(struct Client *client_p)
 153 {
 154         rb_dlink_node *ptr;
 155         struct isupportitem *item;
 156         const char *value;
 157         char buf[512];
 158         int extra_space;
 159         unsigned int nchars, nparams;
 160         int l;
 161
 162         extra_space = strlen(client_p->name);
 163         /* UID */
 164         if (!MyClient(client_p) && extra_space < 9)
 165                 extra_space = 9;
 166         /* :<me.name> 005 <nick> <params> :are supported by this server */
 167         /* form_str(RPL_ISUPPORT) is %s :are supported by this server */
 168         extra_space += strlen(me.name) + 1 + strlen(form_str(RPL_ISUPPORT));
 169
 170         nchars = extra_space, nparams = 0, buf[0] = '\0';
 171         RB_DLINK_FOREACH(ptr, isupportlist.head)
 172         {
 173                 item = ptr->data;
 174                 value = (*item->func)(item->param);
 175                 if (value == NULL)
 176                         continue;
 177                 l = strlen(item->name) + (EmptyString(value) ? 0 : 1 + strlen(value));
 178                 if (nchars + l + (nparams > 0) >= sizeof buf || nparams + 1 > 12)
 179                 {
 180                         sendto_one_numeric(client_p, RPL_ISUPPORT, form_str(RPL_ISUPPORT), buf);
 181                         nchars = extra_space, nparams = 0, buf[0] = '\0';
 182                 }
 183                 if (nparams > 0)
 184                         rb_strlcat(buf, " ", sizeof buf), nchars++;
 185                 rb_strlcat(buf, item->name, sizeof buf);
 186                 if (!EmptyString(value))
 187                 {
 188                         rb_strlcat(buf, "=", sizeof buf);
 189                         rb_strlcat(buf, value, sizeof buf);
 190                 }
 191                 nchars += l;
 192                 nparams++;
 193         }
 194         if (nparams > 0)
 195                 sendto_one_numeric(client_p, RPL_ISUPPORT, form_str(RPL_ISUPPORT), buf);
 196 }
 197
 198 const char *
 199 isupport_intptr(const void *ptr)
 200 {
 201         static char buf[15];
 202         snprintf(buf, sizeof buf, "%d", *(const int *)ptr);
 203         return buf;
 204 }
 205
 206 const char *
 207 isupport_boolean(const void *ptr)
 208 {
 209
 210         return *(const int *)ptr ? "" : NULL;
 211 }
 212
 213 const char *
 214 isupport_string(const void *ptr)
 215 {
 216
 217         return (const char *)ptr;
 218 }
 219
 220 const char *
 221 isupport_stringptr(const void *ptr)
 222 {
 223         return *(char * const *)ptr;
 224 }
 225
 226 const char *
 227 isupport_umode(const void *ptr)
 228 {
 229         const char *str;
 230
 231         str = ptr;
 232         return ConfigFileEntry.oper_only_umodes &
 233                 user_modes[(unsigned char)*str] ? NULL : str;
 234 }
 235
 236 static const char *
 237 isupport_chanmodes(const void *ptr)
 238 {
 239         static char result[300];
 240
 241         snprintf(result, sizeof result, "%s%sbq,k,%slj,%s",
 242                         ConfigChannel.use_except ? "e" : "",
 243                         ConfigChannel.use_invex ? "I" : "",
 244                         ConfigChannel.use_forward ? "f" : "",
 245                         cflagsbuf);
 246         return result;
 247 }
 248
 249 static const char *
 250 isupport_chanlimit(const void *ptr)
 251 {
 252         static char result[BUFSIZE + 30];
 253
 254         snprintf(result, sizeof result, "%s:%i", allowed_chantypes, ConfigChannel.max_chans_per_user);
 255         return result;
 256 }
 257
 258 static const char *
 259 isupport_maxlist(const void *ptr)
 260 {
 261         static char result[30];
 262
 263         snprintf(result, sizeof result, "bq%s%s:%i",
 264                         ConfigChannel.use_except ? "e" : "",
 265                         ConfigChannel.use_invex ? "I" : "",
 266                         ConfigChannel.max_bans);
 267         return result;
 268 }
 269
 270 static const char *
 271 isupport_targmax(const void *ptr)
 272 {
 273         static char result[200];
 274
 275         snprintf(result, sizeof result, "NAMES:1,LIST:1,KICK:1,WHOIS:1,PRIVMSG:%d,NOTICE:%d,ACCEPT:,MONITOR:",
 276                         ConfigFileEntry.max_targets,
 277                         ConfigFileEntry.max_targets);
 278         return result;
 279 }
 280
 281 static const char *
 282 isupport_extban(const void *ptr)
 283 {
 284         const char *p;
 285         static char result[200];
 286
 287         p = get_extban_string();
 288         if (EmptyString(p))
 289                 return NULL;
 290         snprintf(result, sizeof result, "$,%s", p);
 291         return result;
 292 }
 293
 294 static const char *
 295 isupport_nicklen(const void *ptr)
 296 {
 297         static char result[200];
 298
 299         snprintf(result, sizeof result, "%u", ConfigFileEntry.nicklen - 1);
 300         return result;
 301 }
 302
 303 void
 304 init_isupport(void)
 305 {
 306         static int maxmodes = MAXMODEPARAMS;
 307         static int channellen = LOC_CHANNELLEN;
 308         static int topiclen = TOPICLEN;
 309         static int maxnicklen = NICKLEN - 1;
 310
 311         add_isupport("CHANTYPES", isupport_string, allowed_chantypes);
 312         add_isupport("EXCEPTS", isupport_boolean, &ConfigChannel.use_except);
 313         add_isupport("INVEX", isupport_boolean, &ConfigChannel.use_invex);
 314         add_isupport("CHANMODES", isupport_chanmodes, NULL);
 315         add_isupport("CHANLIMIT", isupport_chanlimit, NULL);
 316         add_isupport("PREFIX", isupport_string, "(ov)@+");
 317         add_isupport("MAXLIST", isupport_maxlist, NULL);
 318         add_isupport("MODES", isupport_intptr, &maxmodes);
 319         add_isupport("NETWORK", isupport_stringptr, &ServerInfo.network_name);
 320         add_isupport("STATUSMSG", isupport_string, "@+");
 321         add_isupport("CASEMAPPING", isupport_string, "rfc1459");
 322         add_isupport("NICKLEN", isupport_nicklen, NULL);
 323         add_isupport("MAXNICKLEN", isupport_intptr, &maxnicklen);
 324         add_isupport("CHANNELLEN", isupport_intptr, &channellen);
 325         add_isupport("TOPICLEN", isupport_intptr, &topiclen);
 326         add_isupport("DEAF", isupport_umode, "D");
 327         add_isupport("TARGMAX", isupport_targmax, NULL);
 328         add_isupport("EXTBAN", isupport_extban, NULL);
 329         add_isupport("CLIENTVER", isupport_string, "3.0");
 330 }
 331
 332 void
 333 chantypes_update(void)
 334 {
 335         unsigned char *p;
 336         memset(allowed_chantypes, '\0', sizeof allowed_chantypes);
 337
 338         p = (unsigned char *) allowed_chantypes;
 339
 340         for (unsigned int i = 0; i < 256; i++)
 341         {
 342                 if (IsChanPrefix(i))
 343                         *p++ = (unsigned char) i;
 344         }
 345 }