modules/m_capab.c

   1 /* {{{ irc-seven: Cows like it.
   2  *
   3  * Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center.
   4  * Copyright (C) 1996-2002 Hybrid Development Team.
   5  * Copyright (C) 2002-2005 ircd-ratbox development team.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to:
  19  *
  20  *      Free Software Foundation, Inc.
  21  *      51 Franklin St - Fifth Floor
  22  *      Boston, MA 02110-1301
  23  *      USA
  24  *
  25  * }}} */
  26
  27 /* {{{ Includes. */
  28 #include "stdinc.h"
  29 #include "client.h"
  30 #include "irc_string.h"
  31 #include "s_serv.h"
  32 #include "s_conf.h"
  33 #include "msg.h"
  34 #include "parse.h"
  35 #include "modules.h"
  36 /* }}} */
  37
  38 static int mr_capab (struct Client *, struct Client *, int, const char **);
  39 static int me_gcap (struct Client *, struct Client *, int, const char **);
  40
  41 /* {{{ static struct Message capab_msgtab = { ... } */
  42 static struct Message capab_msgtab =
  43 {
  44         "CAPAB", 0, 0, 0, MFLG_SLOW | MFLG_UNREG,
  45         {
  46                 {mr_capab, 0}, mg_ignore, mg_ignore,
  47                 mg_ignore, mg_ignore, mg_ignore,
  48         },
  49 };
  50 /* }}} */
  51
  52 /* {{{ static struct Message gcap_msgtab = { ... } */
  53 static struct Message gcap_msgtab =
  54 {
  55         "GCAP", 0, 0, 0, MFLG_SLOW,
  56         {
  57                 mg_ignore, mg_ignore, mg_ignore,
  58                 mg_ignore, {me_gcap, 2}, mg_ignore,
  59         },
  60 };
  61 /* }}} */
  62
  63 /* {{{ static mapi_clist_av1 capab_clist[] = { ... } */
  64 static mapi_clist_av1 capab_clist[] =
  65 {
  66         &capab_msgtab,
  67         &gcap_msgtab,
  68         NULL
  69 };
  70 /* }}} */
  71
  72 /* {{{ DECLARE_MODULE_AV1(...) */
  73 DECLARE_MODULE_AV1
  74 (
  75         capab,
  76         NULL,
  77         NULL,
  78         capab_clist,
  79         NULL,
  80         NULL,
  81         "1.1"
  82 );
  83 /* }}} */
  84
  85 /* {{{ static int mr_capab()
  86  *
  87  * CAPAB message handler.
  88  *
  89  * Usage:
  90  *      CAPAB <capabs>
  91  *
  92  * parv[0] - prefix
  93  * parv[1] - capabs
  94  */
  95 static int
  96 mr_capab (struct Client *client_p, struct Client *source_p, int parc, const char **parv)
  97 {
  98         struct Capability       *cap = NULL;
  99         int                     i;
 100         char                    *p = NULL;
 101         char                    *s = NULL;
 102
 103         if (!client_p->localClient || client_p->user)
 104                 return 0;
 105
 106         if ((client_p->localClient->caps & ~CAP_TS6) != 0)
 107         {
 108                 exit_client(client_p, client_p, client_p,
 109                         "CAPAB TS6 is specified via PASS not CAPAB");
 110                 return 0;
 111         }
 112
 113         client_p->localClient->caps |= CAP_CAP;
 114         MyFree(client_p->localClient->fullcaps);
 115         DupString(client_p->localClient->fullcaps, parv[1]);
 116
 117         for (i = 1; i < parc; ++i)
 118         {
 119                 char *t = LOCAL_COPY(parv[i]);
 120                 for (s = strtoken(&p, t, " "); s; s = strtoken(&p, NULL, " "))
 121                 {
 122                         for (cap = captab; cap->name; cap++)
 123                         {
 124                                 if (!irccmp(cap->name, s))
 125                                 {
 126                                         client_p->localClient->caps |= cap->cap;
 127                                         break;
 128                                 }
 129                         }
 130                 }
 131         }
 132
 133         return 0;
 134 }
 135 /* }}} */
 136
 137 /* {{{ static int me_gcap()
 138  *
 139  * GCAP ENCAP message handler.
 140  *
 141  * Usage:
 142  *      GCAP <capabs>
 143  *
 144  * parv[0] - prefix
 145  * parv[1] - capabs
 146  */
 147 static int
 148 me_gcap (struct Client *client_p, struct Client *source_p, int parc, const char **parv)
 149 {
 150         struct Capability       *cap = NULL;
 151         char                    *t = LOCAL_COPY(parv[1]);
 152         char                    *s = NULL;
 153         char                    *p = NULL;
 154
 155         if (!IsServer(source_p) || !EmptyString(source_p->serv->fullcaps))
 156                 return 0;
 157
 158         DupString(source_p->serv->fullcaps, parv[1]);
 159         for (s = strtoken(&p, t, " "); s; s = strtoken(&p, NULL, " "))
 160         {
 161                 for (cap = captab; cap->name; cap++)
 162                 {
 163                         if (!irccmp(cap->name, s))
 164                         {
 165                                 source_p->serv->caps |= cap->cap;
 166                                 break;
 167                         }
 168                 }
 169         }
 170
 171         return 0;
 172 }
 173 /* }}} */
 174
 175 /*
 176  * vim: ts=8 sw=8 noet fdm=marker tw=80
 177  */