modules/m_cap.c

   1 /* modules/m_cap.c
   2  *
   3  *  Copyright (C) 2005 Lee Hardy <lee@leeh.co.uk>
   4  *  Copyright (C) 2005 ircd-ratbox development team
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met:
   9  *
  10  * 1.Redistributions of source code must retain the above copyright notice,
  11  *   this list of conditions and the following disclaimer.
  12  * 2.Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in the
  14  *   documentation and/or other materials provided with the distribution.
  15  * 3.The name of the author may not be used to endorse or promote products
  16  *   derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  22  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  24  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  26  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  27  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * $Id: m_cap.c 676 2006-02-03 20:05:09Z gxti $
  31  */
  32
  33 #include "stdinc.h"
  34 #include "class.h"
  35 #include "client.h"
  36 #include "match.h"
  37 #include "ircd.h"
  38 #include "numeric.h"
  39 #include "msg.h"
  40 #include "parse.h"
  41 #include "modules.h"
  42 #include "s_serv.h"
  43 #include "s_user.h"
  44 #include "send.h"
  45 #include "s_conf.h"
  46 #include "hash.h"
  47
  48 typedef int (*bqcmp)(const void *, const void *);
  49
  50 static int m_cap(struct Client *, struct Client *, int, const char **);
  51 static int modinit(void);
  52
  53 struct Message cap_msgtab = {
  54         "CAP", 0, 0, 0, MFLG_SLOW,
  55         {{m_cap, 2}, {m_cap, 2}, mg_ignore, mg_ignore, mg_ignore, {m_cap, 2}}
  56 };
  57
  58 mapi_clist_av1 cap_clist[] = { &cap_msgtab, NULL };
  59 DECLARE_MODULE_AV1(cap, modinit, NULL, cap_clist, NULL, NULL, "$Revision: 676 $");
  60
  61 #define _CLICAP(name, capserv, capclient, caprequired, flags)   \
  62         { (name), (capserv), (capclient), (caprequired), (flags), sizeof(name) - 1 }
  63
  64 #define CLICAP_FLAGS_STICKY     0x001
  65
  66 static struct clicap
  67 {
  68         const char *name;
  69         int cap_serv;           /* for altering s->c */
  70         int cap_cli;            /* for altering c->s */
  71         int cap_required_serv;  /* required dependency cap */
  72         int flags;
  73         int namelen;
  74 } clicap_list[] = {
  75         _CLICAP("multi-prefix", CLICAP_MULTI_PREFIX, 0, 0, 0),
  76         _CLICAP("sasl", CLICAP_SASL, 0, 0, CLICAP_FLAGS_STICKY),
  77         _CLICAP("account-notify", CLICAP_ACCOUNT_NOTIFY, 0, 0, 0),
  78         _CLICAP("extended-join", CLICAP_EXTENDED_JOIN, 0, 0, 0),
  79         _CLICAP("away-notify", CLICAP_AWAY_NOTIFY, 0, 0, 0),
  80         _CLICAP("tls", CLICAP_TLS, 0, 0, 0),
  81         _CLICAP("userhost-in-names", CLICAP_USERHOST_IN_NAMES, 0, 0, 0),
  82         _CLICAP("cap-notify", CLICAP_CAP_NOTIFY, 0, 0, 0),
  83 };
  84
  85 #define CLICAP_LIST_LEN (sizeof(clicap_list) / sizeof(struct clicap))
  86
  87 static int clicap_sort(struct clicap *, struct clicap *);
  88
  89 static int
  90 modinit(void)
  91 {
  92         qsort(clicap_list, CLICAP_LIST_LEN, sizeof(struct clicap),
  93                 (bqcmp) clicap_sort);
  94         return 0;
  95 }
  96
  97 static int
  98 clicap_sort(struct clicap *one, struct clicap *two)
  99 {
 100         return irccmp(one->name, two->name);
 101 }
 102
 103 static int
 104 clicap_compare(const char *name, struct clicap *cap)
 105 {
 106         return irccmp(name, cap->name);
 107 }
 108
 109 /* clicap_find()
 110  *   Used iteratively over a buffer, extracts individual cap tokens.
 111  *
 112  * Inputs: buffer to start iterating over (NULL to iterate over existing buf)
 113  *         int pointer to whether the cap token is negated
 114  *         int pointer to whether we finish with success
 115  * Ouputs: Cap entry if found, NULL otherwise.
 116  */
 117 static struct clicap *
 118 clicap_find(const char *data, int *negate, int *finished)
 119 {
 120         static char buf[BUFSIZE];
 121         static char *p;
 122         struct clicap *cap;
 123         char *s;
 124
 125         *negate = 0;
 126
 127         if(data)
 128         {
 129                 rb_strlcpy(buf, data, sizeof(buf));
 130                 p = buf;
 131         }
 132
 133         if(*finished)
 134                 return NULL;
 135
 136         /* skip any whitespace */
 137         while(*p && IsSpace(*p))
 138                 p++;
 139
 140         if(EmptyString(p))
 141         {
 142                 *finished = 1;
 143                 return NULL;
 144         }
 145
 146         if(*p == '-')
 147         {
 148                 *negate = 1;
 149                 p++;
 150
 151                 /* someone sent a '-' without a parameter.. */
 152                 if(*p == '\0')
 153                         return NULL;
 154         }
 155
 156         if((s = strchr(p, ' ')))
 157                 *s++ = '\0';
 158
 159         if((cap = bsearch(p, clicap_list, CLICAP_LIST_LEN,
 160                                 sizeof(struct clicap), (bqcmp) clicap_compare)))
 161         {
 162                 if(s)
 163                         p = s;
 164                 else
 165                         *finished = 1;
 166         }
 167
 168         return cap;
 169 }
 170
 171 /* clicap_generate()
 172  *   Generates a list of capabilities.
 173  *
 174  * Inputs: client to send to, subcmd to send,
 175  *         flags to match against: 0 to do none, -1 if client has no flags,
 176  *         int to whether we are doing CAP CLEAR
 177  * Outputs: None
 178  */
 179 static void
 180 clicap_generate(struct Client *source_p, const char *subcmd, int flags, int clear)
 181 {
 182         char buf[BUFSIZE];
 183         char capbuf[BUFSIZE];
 184         char *p;
 185         int buflen = 0;
 186         int curlen, mlen;
 187         size_t i;
 188
 189         mlen = rb_sprintf(buf, ":%s CAP %s %s",
 190                         me.name,
 191                         EmptyString(source_p->name) ? "*" : source_p->name,
 192                         subcmd);
 193
 194         p = capbuf;
 195         buflen = mlen;
 196
 197         /* shortcut, nothing to do */
 198         if(flags == -1)
 199         {
 200                 sendto_one(source_p, "%s :", buf);
 201                 return;
 202         }
 203
 204         for(i = 0; i < CLICAP_LIST_LEN; i++)
 205         {
 206                 if(flags)
 207                 {
 208                         if(!IsCapable(source_p, clicap_list[i].cap_serv))
 209                                 continue;
 210                         /* they are capable of this, check sticky */
 211                         else if(clear && clicap_list[i].flags & CLICAP_FLAGS_STICKY)
 212                                 continue;
 213                 }
 214
 215                 if (clicap_list[i].cap_serv == CLICAP_SASL)
 216                 {
 217                         struct Client *agent_p = NULL;
 218
 219                         if (!ConfigFileEntry.sasl_service)
 220                                 continue;
 221
 222                         agent_p = find_named_client(ConfigFileEntry.sasl_service);
 223                         if (agent_p == NULL || !IsService(agent_p))
 224                                 continue;
 225                 }
 226
 227                 /* \r\n\0, possible "-~=", space, " *" */
 228                 if(buflen + clicap_list[i].namelen >= BUFSIZE - 10)
 229                 {
 230                         /* remove our trailing space -- if buflen == mlen
 231                          * here, we didnt even succeed in adding one.
 232                          */
 233                         if(buflen != mlen)
 234                                 *(p - 1) = '\0';
 235                         else
 236                                 *p = '\0';
 237
 238                         sendto_one(source_p, "%s * :%s", buf, capbuf);
 239                         p = capbuf;
 240                         buflen = mlen;
 241                 }
 242
 243                 if(clear)
 244                 {
 245                         *p++ = '-';
 246                         buflen++;
 247                 }
 248
 249                 curlen = rb_sprintf(p, "%s ", clicap_list[i].name);
 250                 p += curlen;
 251                 buflen += curlen;
 252         }
 253
 254         /* remove trailing space */
 255         if(buflen != mlen)
 256                 *(p - 1) = '\0';
 257         else
 258                 *p = '\0';
 259
 260         sendto_one(source_p, "%s :%s", buf, capbuf);
 261 }
 262
 263 static void
 264 cap_ack(struct Client *source_p, const char *arg)
 265 {
 266         struct clicap *cap;
 267         int capadd = 0, capdel = 0;
 268         int finished = 0, negate;
 269
 270         if(EmptyString(arg))
 271                 return;
 272
 273         for(cap = clicap_find(arg, &negate, &finished); cap;
 274             cap = clicap_find(NULL, &negate, &finished))
 275         {
 276                 /* sent an ACK for something they havent REQd */
 277                 if(!IsCapable(source_p, cap->cap_serv))
 278                         continue;
 279
 280                 if(negate)
 281                 {
 282                         /* dont let them ack something sticky off */
 283                         if(cap->flags & CLICAP_FLAGS_STICKY)
 284                                 continue;
 285
 286                         capdel |= cap->cap_cli;
 287                 }
 288                 else
 289                         capadd |= cap->cap_cli;
 290         }
 291
 292         source_p->localClient->caps |= capadd;
 293         source_p->localClient->caps &= ~capdel;
 294 }
 295
 296 static void
 297 cap_clear(struct Client *source_p, const char *arg)
 298 {
 299         clicap_generate(source_p, "ACK",
 300                         source_p->localClient->caps ? source_p->localClient->caps : -1, 1);
 301
 302         /* XXX - sticky capabs */
 303 #ifdef CLICAP_STICKY
 304         source_p->localClient->caps = source_p->localClient->caps & CLICAP_STICKY;
 305 #else
 306         source_p->localClient->caps = 0;
 307 #endif
 308 }
 309
 310 static void
 311 cap_end(struct Client *source_p, const char *arg)
 312 {
 313         if(IsRegistered(source_p))
 314                 return;
 315
 316         source_p->flags &= ~FLAGS_CLICAP;
 317
 318         if(source_p->name[0] && source_p->flags & FLAGS_SENTUSER)
 319         {
 320                 register_local_user(source_p, source_p);
 321         }
 322 }
 323
 324 static void
 325 cap_list(struct Client *source_p, const char *arg)
 326 {
 327         /* list of what theyre currently using */
 328         clicap_generate(source_p, "LIST",
 329                         source_p->localClient->caps ? source_p->localClient->caps : -1, 0);
 330 }
 331
 332 static void
 333 cap_ls(struct Client *source_p, const char *arg)
 334 {
 335         if(!IsRegistered(source_p))
 336                 source_p->flags |= FLAGS_CLICAP;
 337
 338         /* list of what we support */
 339         clicap_generate(source_p, "LS", 0, 0);
 340 }
 341
 342 static void
 343 cap_req(struct Client *source_p, const char *arg)
 344 {
 345         char buf[BUFSIZE];
 346         char pbuf[2][BUFSIZE];
 347         struct clicap *cap;
 348         int buflen, plen;
 349         int i = 0;
 350         int capadd = 0, capdel = 0;
 351         int finished = 0, negate;
 352
 353         if(!IsRegistered(source_p))
 354                 source_p->flags |= FLAGS_CLICAP;
 355
 356         if(EmptyString(arg))
 357                 return;
 358
 359         buflen = rb_snprintf(buf, sizeof(buf), ":%s CAP %s ACK",
 360                         me.name, EmptyString(source_p->name) ? "*" : source_p->name);
 361
 362         pbuf[0][0] = '\0';
 363         plen = 0;
 364
 365         for(cap = clicap_find(arg, &negate, &finished); cap;
 366             cap = clicap_find(NULL, &negate, &finished))
 367         {
 368                 /* filled the first array, but cant send it in case the
 369                  * request fails.  one REQ should never fill more than two
 370                  * buffers --fl
 371                  */
 372                 if(buflen + plen + cap->namelen + 6 >= BUFSIZE)
 373                 {
 374                         pbuf[1][0] = '\0';
 375                         plen = 0;
 376                         i = 1;
 377                 }
 378
 379                 if(negate)
 380                 {
 381                         if(cap->flags & CLICAP_FLAGS_STICKY)
 382                         {
 383                                 finished = 0;
 384                                 break;
 385                         }
 386
 387                         strcat(pbuf[i], "-");
 388                         plen++;
 389
 390                         capdel |= cap->cap_serv;
 391                 }
 392                 else
 393                 {
 394                         if(cap->cap_required_serv && !((capadd & cap->cap_required_serv) == cap->cap_required_serv || IsCapable(source_p, cap->cap_required_serv)))
 395                         {
 396                                 finished = 0;
 397                                 break;
 398                         }
 399
 400                         if (cap->cap_serv == CLICAP_SASL)
 401                         {
 402                                 struct Client *agent_p = NULL;
 403
 404                                 if (!ConfigFileEntry.sasl_service)
 405                                 {
 406                                         finished = 0;
 407                                         break;
 408                                 }
 409
 410                                 agent_p = find_named_client(ConfigFileEntry.sasl_service);
 411                                 if (agent_p == NULL || !IsService(agent_p))
 412                                 {
 413                                         finished = 0;
 414                                         break;
 415                                 }
 416                         }
 417
 418                         capadd |= cap->cap_serv;
 419                 }
 420
 421                 if(cap->cap_cli)
 422                 {
 423                         strcat(pbuf[i], "~");
 424                         plen++;
 425                 }
 426
 427                 strcat(pbuf[i], cap->name);
 428                 strcat(pbuf[i], " ");
 429                 plen += (cap->namelen + 1);
 430         }
 431
 432         if(!finished)
 433         {
 434                 sendto_one(source_p, ":%s CAP %s NAK :%s",
 435                         me.name, EmptyString(source_p->name) ? "*" : source_p->name, arg);
 436                 return;
 437         }
 438
 439         if(i)
 440         {
 441                 sendto_one(source_p, "%s * :%s", buf, pbuf[0]);
 442                 sendto_one(source_p, "%s :%s", buf, pbuf[1]);
 443         }
 444         else
 445                 sendto_one(source_p, "%s :%s", buf, pbuf[0]);
 446
 447         source_p->localClient->caps |= capadd;
 448         source_p->localClient->caps &= ~capdel;
 449 }
 450
 451 static struct clicap_cmd
 452 {
 453         const char *cmd;
 454         void (*func)(struct Client *source_p, const char *arg);
 455 } clicap_cmdlist[] = {
 456         /* This list *MUST* be in alphabetical order */
 457         { "ACK",        cap_ack         },
 458         { "CLEAR",      cap_clear       },
 459         { "END",        cap_end         },
 460         { "LIST",       cap_list        },
 461         { "LS",         cap_ls          },
 462         { "REQ",        cap_req         },
 463 };
 464
 465 static int
 466 clicap_cmd_search(const char *command, struct clicap_cmd *entry)
 467 {
 468         return irccmp(command, entry->cmd);
 469 }
 470
 471 static int
 472 m_cap(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 473 {
 474         struct clicap_cmd *cmd;
 475
 476         if(!(cmd = bsearch(parv[1], clicap_cmdlist,
 477                                 sizeof(clicap_cmdlist) / sizeof(struct clicap_cmd),
 478                                 sizeof(struct clicap_cmd), (bqcmp) clicap_cmd_search)))
 479         {
 480                 sendto_one(source_p, form_str(ERR_INVALIDCAPCMD),
 481                                 me.name, EmptyString(source_p->name) ? "*" : source_p->name,
 482                                 parv[1]);
 483                 return 0;
 484         }
 485
 486         (cmd->func)(source_p, parv[2]);
 487         return 0;
 488 }