ircd/m_relay.c

   1 /*
   2  * IRC - Internet Relay Chat, ircd/m_relay.c
   3  * Written by David Herrmann.
   4  */
   5
   6 #include "config.h"
   7
   8 #include "channel.h"
   9 #include "client.h"
  10 #include "handlers.h"
  11 #include "hash.h"
  12 #include "parse.h"
  13 #include "ircd.h"
  14 #include "ircd_chattr.h"
  15 #include "ircd_features.h"
  16 #include "ircd_reply.h"
  17 #include "ircd_string.h"
  18 #include "msg.h"
  19 #include "numeric.h"
  20 #include "numnicks.h"
  21 #include "s_auth.h"
  22 #include "s_debug.h"
  23 #include "s_user.h"
  24 #include "send.h"
  25 #include "sys.h"
  26
  27 #include <string.h>
  28 #include <ctype.h>
  29 #include <stdlib.h>
  30
  31 static void loc_handler_LR(const char *num, char *parv[], signed int parc) {
  32     if(num[0] != '!') return;
  33         if(parc > 0)
  34                 auth_loc_reply(&num[3], NULL, NULL, NULL, 0);
  35         else
  36                 auth_loc_reply(&num[3], NULL, NULL, &parv[0] , parc);
  37 }
  38
  39 static void loc_handler_LA(const char *num, char *parv[], signed int parc) {
  40     if(num[0] != '!' || parc < 1) return;
  41         char *fakehost = NULL;
  42         if (parc > 1 && parv[1] != "0")
  43                 fakehost=parv[1];
  44
  45     if(parc > 2)
  46         auth_loc_reply(&num[3], parv[0], fakehost, &parv[2] , parc - 2);
  47     else if(parc > 1)
  48         auth_loc_reply(&num[3], parv[0], fakehost, NULL, 0);
  49     else
  50         auth_loc_reply(&num[3], parv[0], NULL, NULL, 0);
  51 }
  52
  53
  54 static void mode_a_join(struct Client* cptr, char *channel, int flags) {
  55     struct Channel *chptr;
  56     if (!(chptr = FindChannel(channel))) {
  57         if (((channel[0] == '&') && !feature_bool(FEAT_LOCAL_CHANNELS)) || strlen(channel) > IRCD_MIN(CHANNELLEN, feature_int(FEAT_CHANNELLEN))) {
  58          //we don't send an error message here - that would be very strange for the user, because they normaly don't know that mode +F is set
  59         } else if ((chptr = get_channel(cptr, channel, CGT_CREATE))) {
  60            struct JoinBuf create;
  61            joinbuf_init(&create, cptr, cptr, JOINBUF_TYPE_CREATE, 0, TStime());
  62            joinbuf_join(&create, chptr, CHFL_CHANOP | CHFL_CHANNEL_MANAGER);
  63                    do_names(cptr, chptr, NAMES_ALL|NAMES_EON);
  64            joinbuf_flush(&create);
  65                 }
  66         } else {
  67         struct JoinBuf join;
  68         joinbuf_init(&join, cptr, cptr, JOINBUF_TYPE_JOIN, 0, 0);
  69                 joinbuf_join(&join, chptr, flags);
  70                 del_invite(cptr, chptr);
  71         if (chptr->topic[0]) {
  72             send_reply(cptr, RPL_TOPIC, chptr->chname, chptr->topic);
  73             send_reply(cptr, RPL_TOPICWHOTIME, chptr->chname, chptr->topic_nick, chptr->topic_time);
  74         }
  75         do_names(cptr, chptr, NAMES_ALL|NAMES_EON); /* send /names list */
  76         joinbuf_flush(&join);
  77         }
  78 }
  79
  80
  81 static void mode_a_check_altchan(struct Client* cptr, char *channel) {
  82     struct Channel *chptr;
  83     if (!(chptr = FindChannel(channel)))
  84         return;
  85
  86     if(chptr->mode.altchan && IsChannelName(chptr->mode.altchan) && strIsIrcCh(chptr->mode.altchan)) {
  87                 mode_a_join(cptr,chptr->mode.altchan,CHFL_DEOPPED);
  88         }
  89 }
  90
  91 /** RELAY
  92  * The RELAY command has a special purpose. It is always built the following way:
  93  *  <sender> RELAY <destination> <command>[ <list of parameters>]
  94  * The <sender> is a single numeric nick of a server or user. <destination> can be:
  95  * - a numeric-nick of a server (2 characters long): eg., AD
  96  * - a numeric-nick of a user (5 characters long): eg., ADAAB
  97  * - a numeric-nick of an unregistered user (6 characters long): eg., !ADAAB
  98  * <command> is a subcommdn of RELAY.
  99  *
 100  * If we receive such a message, we relay the message to the server of <destination>.
 101  * If we are the target, we check <command> and call the related subcommand handler.
 102  *
 103  * Therefore, this interface can be used to relay messages through the network without
 104  * specifying new commands.
 105  */
 106 /* ms_relay - server message handler
 107  *
 108  * parv[0] = sender prefix
 109  * parv[1] = target
 110  * parv[2] = subcommand
 111  * parv[3-X] = NULL or a list of parameters.
 112  */
 113 signed int ms_relay(struct Client* cptr, struct Client* sptr, signed int parc, char* parv[]) {
 114     struct Client *server;
 115     unsigned int len, i;
 116     char buf[3], *act, *m, buffer[513];
 117
 118     if(parc < 3) {
 119         return protocol_violation(cptr, "Too few arguments for RELAY");
 120     }
 121
 122     /* Check <destination>. */
 123     len = strlen(parv[1]);
 124     buf[2] = 0;
 125     switch(len) {
 126         case 2:
 127             server = FindNServer(parv[1]);
 128             break;
 129         case 5:
 130             buf[0] = parv[1][0];
 131             buf[1] = parv[1][1];
 132             server = FindNServer(buf);
 133             break;
 134         case 6:
 135             buf[0] = parv[1][1];
 136             buf[1] = parv[1][2];
 137             server = FindNServer(buf);
 138             break;
 139         default:
 140             /* Invalid destination. Ignore. */
 141             return 0;
 142     }
 143
 144     if(server != &me) {
 145         if(parc > 3) {
 146             act = buffer;
 147             for(i = 3; i < (parc - 1); ++i) {
 148                 m = parv[i];
 149                 while((*act++ = *m++)) /* empty loop */ ;
 150                 *(act - 1) = ' ';
 151             }
 152             m = parv[i];
 153             *act++ = ':';
 154             while((*act++ = *m++)) /* empty loop */ ;
 155             sendcmdto_one(sptr, CMD_RELAY, server, "%s %s %s", parv[1], parv[2], buffer);
 156         }
 157         else sendcmdto_one(sptr, CMD_RELAY, server, "%s %s", parv[1], parv[2]);
 158         return 0;
 159     }
 160
 161     /* Call subcommand handler. */
 162     if(strcmp("LR", parv[2]) == 0) loc_handler_LR(parv[1], &parv[3], parc - 3);
 163     else if(strcmp("LA", parv[2]) == 0 && parc > 3) loc_handler_LA(parv[1], &parv[3], parc - 3);
 164         else if(strcmp("SM", parv[2]) == 0 && parc > 3) {
 165      #ifndef UNRESTRICTED_SERV
 166          struct Client *acptr;
 167          if(acptr = findNUser(parv[3])) {
 168           if (IsChannelPrefix(*parv[4])) {
 169        relay_channel_message(acptr, parv[4], parv[parc - 1], 1);
 170       } else {
 171            relay_private_message(acptr, parv[4], parv[parc - 1]);
 172           }
 173          }
 174      #endif
 175         } else if(strcmp("UC", parv[2]) == 0 && parc > 3) {
 176          struct Client *acptr;
 177          if(acptr = findNUser(parv[3])) {
 178           send_reply(acptr, ERR_UNKNOWNCOMMAND, parv[4]);
 179          }
 180         } else if(strcmp("SI", parv[2]) == 0 && parc > 3) {
 181      #ifndef UNRESTRICTED_SERV
 182          struct Client *acptr;
 183          if(acptr = findNUser(parv[3])) {
 184           parse_simul_client(acptr, parv[parc - 1]);
 185          }
 186      #endif
 187         } else if(strcmp("JAA", parv[2]) == 0 && parc > 2) {
 188          struct Client *acptr;
 189          if(acptr = findNUser(parv[1])) {
 190           mode_a_join(acptr,parv[3],strtoul(parv[4], 0, 10));
 191          }
 192         } else if(strcmp("JAR", parv[2]) == 0 && parc > 2) {
 193          struct Client *acptr;
 194          if(acptr = findNUser(parv[1])) {
 195       mode_a_check_altchan(acptr,parv[3]);
 196           send_reply(acptr, ERR_JOINACCESS, parv[3]);
 197          }
 198         }
 199
 200     return 0;
 201 }
 202