Author: Kev <klmitch@mit.edu>
[ircu2.10.12-pk.git] / ircd / m_names.c
1 /*
2  * IRC - Internet Relay Chat, ircd/m_names.c
3  * Copyright (C) 1990 Jarkko Oikarinen and
4  *                    University of Oulu, Computing Center
5  *
6  * See file AUTHORS in IRC package for additional names of
7  * the programmers.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 1, or (at your option)
12  * any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  *
23  * $Id$
24  */
25
26 /*
27  * m_functions execute protocol messages on this server:
28  *
29  *    cptr    is always NON-NULL, pointing to a *LOCAL* client
30  *            structure (with an open socket connected!). This
31  *            identifies the physical socket where the message
32  *            originated (or which caused the m_function to be
33  *            executed--some m_functions may call others...).
34  *
35  *    sptr    is the source of the message, defined by the
36  *            prefix part of the message if present. If not
37  *            or prefix not found, then sptr==cptr.
38  *
39  *            (!IsServer(cptr)) => (cptr == sptr), because
40  *            prefixes are taken *only* from servers...
41  *
42  *            (IsServer(cptr))
43  *                    (sptr == cptr) => the message didn't
44  *                    have the prefix.
45  *
46  *                    (sptr != cptr && IsServer(sptr) means
47  *                    the prefix specified servername. (?)
48  *
49  *                    (sptr != cptr && !IsServer(sptr) means
50  *                    that message originated from a remote
51  *                    user (not local).
52  *
53  *            combining
54  *
55  *            (!IsServer(sptr)) means that, sptr can safely
56  *            taken as defining the target structure of the
57  *            message in this server.
58  *
59  *    *Always* true (if 'parse' and others are working correct):
60  *
61  *    1)      sptr->from == cptr  (note: cptr->from == cptr)
62  *
63  *    2)      MyConnect(sptr) <=> sptr == cptr (e.g. sptr
64  *            *cannot* be a local connection, unless it's
65  *            actually cptr!). [MyConnect(x) should probably
66  *            be defined as (x == x->from) --msa ]
67  *
68  *    parc    number of variable parameter strings (if zero,
69  *            parv is allowed to be NULL)
70  *
71  *    parv    a NULL terminated list of parameter pointers,
72  *
73  *                    parv[0], sender (prefix string), if not present
74  *                            this points to an empty string.
75  *                    parv[1]...parv[parc-1]
76  *                            pointers to additional parameters
77  *                    parv[parc] == NULL, *always*
78  *
79  *            note:   it is guaranteed that parv[0]..parv[parc-1] are all
80  *                    non-NULL pointers.
81  */
82 #include "config.h"
83
84 #include "channel.h"
85 #include "client.h"
86 #include "hash.h"
87 #include "ircd.h"
88 #include "ircd_reply.h"
89 #include "ircd_string.h"
90 #include "msg.h"
91 #include "numeric.h"
92 #include "numnicks.h"
93 #include "s_user.h"
94 #include "send.h"
95  
96 #include <assert.h>
97 #include <string.h>
98
99 /*
100  *  Sends a suitably formatted 'names' reply to 'sptr' consisting of nicks within
101  *  'chptr', depending on 'filter'.
102  *
103  *  NAMES_ALL - Lists all users on channel.
104  *  NAMES_VIS - Only list visible (-i) users. --Gte (04/06/2000).
105  *  NAMES_EON - When OR'd with the other two, adds an 'End of Names' numeric
106  *              used by m_join
107  *
108  */
109
110 void do_names(struct Client* sptr, struct Channel* chptr, int filter)
111
112   int mlen;
113   int idx;
114   int flag;
115   int needs_space; 
116   int len; 
117   char buf[BUFSIZE];
118   struct Client *c2ptr;
119   struct Membership* member;
120   
121   assert(chptr);
122   assert(sptr);
123   assert((filter&NAMES_ALL) != (filter&NAMES_VIS));
124
125   /* Tag Pub/Secret channels accordingly. */
126
127   strcpy(buf, "* ");
128   if (PubChannel(chptr))
129     *buf = '=';
130   else if (SecretChannel(chptr))
131     *buf = '@';
132  
133   len = strlen(chptr->chname);
134   strcpy(buf + 2, chptr->chname);
135   strcpy(buf + 2 + len, " :");
136
137   idx = len + 4;
138   flag = 1;
139   needs_space = 0;
140
141   if (!ShowChannel(sptr, chptr)) /* Don't list private channels unless we are on them. */
142     return;
143
144   /* Iterate over all channel members, and build up the list. */
145
146   mlen = strlen(cli_name(&me)) + 10 + strlen(cli_name(sptr));
147   
148   for (member = chptr->members; member; member = member->next_member)
149   {
150     c2ptr = member->user;
151
152     if (((filter&NAMES_VIS)!=0) && IsInvisible(c2ptr))
153       continue;
154
155     if (IsZombie(member) && member->user != sptr)
156       continue;
157
158     if (needs_space) {
159         strcat(buf, " ");
160       idx++;
161     }
162     needs_space=1;
163     if (IsZombie(member))
164     {
165       strcat(buf, "!");
166       idx++;
167     }
168     else if (IsChanOp(member))
169     {
170       strcat(buf, "@");
171       idx++;
172     }
173     else if (HasVoice(member))
174     {
175       strcat(buf, "+");
176       idx++;
177     }
178     strcat(buf, cli_name(c2ptr));
179     idx += strlen(cli_name(c2ptr)) + 1;
180     flag = 1;
181     if (mlen + idx + NICKLEN + 5 > BUFSIZE)
182       /* space, modifier, nick, \r \n \0 */
183     { 
184       send_reply(sptr, RPL_NAMREPLY, buf);
185       strcpy(buf, "* ");
186       ircd_strncpy(buf + 2, chptr->chname, len + 1);
187       buf[len + 2] = 0;
188       strcat(buf, " :");
189       if (PubChannel(chptr))
190         *buf = '=';
191       else if (SecretChannel(chptr))
192         *buf = '@';
193       idx = len + 4;
194       flag = 0;
195       needs_space=0;
196     }
197   }
198   if (flag)
199     send_reply(sptr, RPL_NAMREPLY, buf); 
200   if (filter&NAMES_EON)
201     send_reply(sptr, RPL_ENDOFNAMES, chptr->chname);
202 }
203
204 /*
205  * m_names - generic message handler
206  *
207  * parv[0] = sender prefix
208  * parv[1] = channel
209  */
210
211 int m_names(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
212 {
213   struct Channel *chptr; 
214   struct Channel *ch2ptr; 
215   struct Client *c2ptr;
216   struct Membership* member; 
217   char* s;
218   char* para = parc > 1 ? parv[1] : 0; 
219
220   if (parc > 2 && hunt_server_cmd(sptr, CMD_NAMES, cptr, 1, "%s %C", 2, parc, parv))
221     return 0; 
222
223   if (EmptyString(para)) {
224     send_reply(sptr, RPL_ENDOFNAMES, "*");
225     return 0;
226   }
227   else if (*para == '0')
228     *para = '\0';
229   
230   s = strchr(para, ','); /* Recursively call m_names for each comma-seperated channel. Eww. */
231   if (s) {
232     parv[1] = ++s;
233     m_names(cptr, sptr, parc, parv);
234   }
235  
236   /*
237    * Special Case 1: "/names 0". 
238    * Full list as per RFC. 
239    */
240
241   if (!*para) { 
242     int idx; 
243     int mlen;
244     int flag;
245     struct Channel *ch3ptr;
246     char buf[BUFSIZE]; 
247
248     mlen = strlen(cli_name(&me)) + 10 + strlen(cli_name(sptr));
249
250     /* List all visible channels/visible members */ 
251
252     for (ch2ptr = GlobalChannelList; ch2ptr; ch2ptr = ch2ptr->next)
253     { 
254       if (!ShowChannel(sptr, ch2ptr))
255         continue;                 /* Don't show secret chans. */ 
256
257       if (find_channel_member(sptr, ch2ptr))
258       {
259         do_names(sptr, ch2ptr, NAMES_ALL); /* Full list if we're in this chan. */
260       } else { 
261         do_names(sptr, ch2ptr, NAMES_VIS);
262       }
263     } 
264
265     /* List all remaining users on channel '*' */
266
267     strcpy(buf, "* * :");
268     idx = 5;
269     flag = 0;
270
271     for (c2ptr = GlobalClientList; c2ptr; c2ptr = cli_next(c2ptr))
272     {
273       int showflag = 0;
274
275       if (!IsUser(c2ptr) || (sptr != c2ptr && IsInvisible(c2ptr)))
276         continue;
277
278       member = cli_user(c2ptr)->channel;
279
280       while (member)
281       {
282         ch3ptr = member->channel;
283   
284         if (PubChannel(ch3ptr) || find_channel_member(sptr, ch3ptr))
285           showflag = 1;
286  
287         member = member->next_channel;
288       }
289
290       if (showflag)               /* Have we already shown them? */
291         continue;
292  
293       strcat(buf, cli_name(c2ptr));
294       strcat(buf, " ");
295       idx += strlen(cli_name(c2ptr)) + 1;
296       flag = 1;
297
298       if (mlen + idx + NICKLEN + 3 > BUFSIZE)     /* space, \r\n\0 */
299       {
300         send_reply(sptr, RPL_NAMREPLY, buf);
301         strcpy(buf, "* * :");
302         idx = 5;
303         flag = 0;
304       }
305     }
306     if (flag)
307       send_reply(sptr, RPL_NAMREPLY, buf);
308     send_reply(sptr, RPL_ENDOFNAMES, "*");
309     return 1; 
310   } 
311
312   /*
313    *  Special Case 2: User is on this channel, requesting full names list.
314    *  (As performed with each /join) - ** High frequency usage **
315    */
316
317   clean_channelname(para);
318   chptr = FindChannel(para); 
319
320   if (chptr) {
321     member = find_member_link(chptr, sptr);
322     if (member)
323     { 
324       do_names(sptr, chptr, NAMES_ALL);
325       if (!EmptyString(para))
326       {
327         send_reply(sptr, RPL_ENDOFNAMES, chptr ? chptr->chname : para);
328         return 1;
329       }
330     }
331       else 
332     {
333       /*
334        *  Special Case 3: User isn't on this channel, show all visible users, in 
335        *  non secret channels.
336        */ 
337       do_names(sptr, chptr, NAMES_VIS);
338     } 
339   } else { /* Channel doesn't exist. */ 
340       send_reply(sptr, RPL_ENDOFNAMES, para); 
341   }
342   return 1;
343 }
344
345  
346 /*
347  * ms_names - server message handler
348  *
349  * parv[0] = sender prefix
350  * parv[1] = channel
351  */
352 int ms_names(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
353 {
354   struct Channel *chptr; 
355   struct Channel *ch2ptr; 
356   struct Client *c2ptr;
357   struct Membership* member; 
358   char* s;
359   char* para = parc > 1 ? parv[1] : 0; 
360
361   if (parc > 2 && hunt_server_cmd(sptr, CMD_NAMES, cptr, 1, "%s %C", 2, parc, parv))
362     return 0; 
363
364   if (EmptyString(para)) {
365     send_reply(sptr, RPL_ENDOFNAMES, "*");
366     return 0;
367   }
368   else if (*para == '0')
369     *para = '\0';
370   
371   s = strchr(para, ','); /* Recursively call m_names for each comma-seperated channel. */
372   if (s) {
373     parv[1] = ++s;
374     m_names(cptr, sptr, parc, parv);
375   }
376  
377   /*
378    * Special Case 1: "/names 0".
379    * Full list as per RFC. 
380    */
381
382   if (!*para) { 
383     int idx; 
384     int mlen;
385     int flag;
386     struct Channel *ch3ptr;
387     char buf[BUFSIZE]; 
388
389     mlen = strlen(cli_name(&me)) + 10 + strlen(cli_name(sptr));
390
391     /* List all visible channels/visible members */ 
392
393     for (ch2ptr = GlobalChannelList; ch2ptr; ch2ptr = ch2ptr->next)
394     { 
395       if (!ShowChannel(sptr, ch2ptr))
396         continue;                 /* Don't show secret chans. */ 
397
398       if (find_channel_member(sptr, ch2ptr))
399       {
400         do_names(sptr, ch2ptr, NAMES_ALL); /* Full list if we're in this chan. */
401       } else { 
402         do_names(sptr, ch2ptr, NAMES_VIS);
403       }
404     } 
405  
406     /* List all remaining users on channel '*' */
407
408     strcpy(buf, "* * :");
409     idx = 5;
410     flag = 0;
411
412     for (c2ptr = GlobalClientList; c2ptr; c2ptr = cli_next(c2ptr))
413     {
414       int showflag = 0;
415
416       if (!IsUser(c2ptr) || (sptr != c2ptr && IsInvisible(c2ptr)))
417         continue;
418
419       member = cli_user(c2ptr)->channel; 
420
421       while (member)
422       {
423         ch3ptr = member->channel;
424   
425         if (PubChannel(ch3ptr) || find_channel_member(sptr, ch3ptr))
426           showflag = 1;
427  
428         member = member->next_channel;
429       }
430
431       if (showflag)               /* Have we already shown them? */
432         continue;
433  
434       strcat(buf, cli_name(c2ptr));
435       strcat(buf, " ");
436       idx += strlen(cli_name(c2ptr)) + 1;
437       flag = 1;
438
439       if (mlen + idx + NICKLEN + 3 > BUFSIZE)     /* space, \r\n\0 */
440       {
441         send_reply(sptr, RPL_NAMREPLY, buf);
442         strcpy(buf, "* * :");
443         idx = 5;
444         flag = 0;
445       }
446     }
447     if (flag)
448       send_reply(sptr, RPL_NAMREPLY, buf);
449     send_reply(sptr, RPL_ENDOFNAMES, "*");
450     return 1; 
451   } 
452
453   /*
454    *  Special Case 2: User is on this channel, requesting full names list.
455    *  (As performed with each /join) - ** High frequency usage **
456    */
457
458   clean_channelname(para);
459   chptr = FindChannel(para); 
460
461   if (chptr) {
462     member = find_member_link(chptr, sptr);
463     if (member)
464     { 
465       do_names(sptr, chptr, NAMES_ALL);
466       if (!EmptyString(para))
467       {
468         send_reply(sptr, RPL_ENDOFNAMES, chptr ? chptr->chname : para);
469         return 1;
470       }
471     }
472       else 
473     {
474       /*
475        *  Special Case 3: User isn't on this channel, show all visible users, in 
476        *  non secret channels.
477        */ 
478       do_names(sptr, chptr, NAMES_VIS);
479     } 
480   } else { /* Channel doesn't exist. */ 
481       send_reply(sptr, RPL_ENDOFNAMES, para); 
482   }
483   return 1;
484 }