irc.c in jcs/wallops

irc.c

(View History)

jcs *: Support /monitor and its numerics, do better server reconnecting

Latest amendment: 129 on 2024-09-22

1	/*
2	* Copyright (c) 2021-2022 joshua stein <jcs@jcs.org>
3	*
4	* Permission to use, copy, modify, and distribute this software for any
5	* purpose with or without fee is hereby granted, provided that the above
6	* copyright notice and this permission notice appear in all copies.
7	*
8	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15	*/
16
17	#include <ctype.h>
18	#include <string.h>
19	#include <stdarg.h>
20
21	#include "chatter.h"
22	#include "irc.h"
23	#include "settings.h"
24
25	short irc_recv(struct irc_connection *conn);
26	size_t irc_send(struct irc_connection conn, char line, size_t size);
27	size_t irc_printf(struct irc_connection conn, const char format, ...);
28	char * irc_get_line(struct irc_connection conn, size_t retsize);
29	struct irc_user * irc_parse_user(char *str);
30	bool irc_can_send(struct irc_connection *conn);
31	struct irc_channel * irc_find_channel(struct irc_connection *conn,
32	char *channame);
33	void irc_register(struct irc_connection *conn);
34	bool irc_process_server(struct irc_connection *conn);
35	struct irc_channel * irc_create_channel(struct irc_connection *conn,
36	char *channame);
37	void irc_quit_with_message(struct irc_connection conn, char str);
38	void irc_dealloc_channel(struct irc_channel *channel);
39	void irc_set_active_channel(struct irc_connection conn, char channame);
40	void irc_parse_names(struct irc_channel channel, char line);
41	void irc_add_nick_to_channel(struct irc_channel channel, char nick,
42	short flags, short count_hint);
43	void irc_remove_nick_from_channel(struct irc_channel channel, char nick);
44	bool irc_nick_is_in_channel(struct irc_channel channel, char nick);
45	void irc_change_user_nick(struct irc_connection *conn,
46	struct irc_channel channel, struct irc_user user, char *nick);
47	bool irc_parse_channel_mode_change(struct irc_channel channel, char mode,
48	char *args);
49	void irc_do_mode_to_users(struct irc_connection conn, char channel_name,
50	char mode, char nicks);
51
52	#define IRC_CAN_SEND(conn) ((conn)->send_pb.ioResult <= 0)
53
54	struct irc_connections_head irc_connections_list =
55	SLIST_HEAD_INITIALIZER(irc_connections_list);
56
57	struct irc_connection *
58	irc_connect(struct chatter chatter, const char server,
59	const unsigned short port, const char password, const char nick,
60	const char ident, const char realname, bool hide_motd,
61	const char *channel)
62	{
63	struct irc_connection *conn;
64	char ip_str[] = "255.255.255.255";
65	char *retname;
66	ip_addr ip = 0, local_ip = 0;
67	ip_port local_port = 0;
68	size_t len;
69	short err;
70
71	if ((err = _TCPInit()) != 0)
72	panic("TCPInit failed (%d)", err);
73
74	conn = xmalloczero(sizeof(struct irc_connection));
75	if (conn == NULL)
76	goto conn_fail;
77	SLIST_APPEND(&irc_connections_list, conn, irc_connection, list);
78	SLIST_INIT(&conn->channels_list);
79	conn->chatter = chatter;
80	conn->state = IRC_STATE_DISCONNECTED;
81	conn->hostname = xstrdup(server);
82	if (conn->hostname == NULL)
83	goto conn_fail;
84	conn->port = port;
85	if (password && password[0]) {
86	conn->password = xstrdup(password);
87	if (conn->password == NULL)
88	goto conn_fail;
89	}
90
91	conn->nick_len = strlen(nick);
92	conn->nick = xstrdup(nick);
93	if (conn->nick == NULL)
94	goto conn_fail;
95	conn->ident = xstrdup(ident);
96	if (conn->ident == NULL)
97	goto conn_fail;
98	conn->realname = xstrdup(realname);
99	if (conn->realname == NULL)
100	goto conn_fail;
101	conn->hide_motd = hide_motd;
102	if (channel && channel[0]) {
103	conn->channel_autojoin = xstrdup(channel);
104	if (conn->channel_autojoin == NULL)
105	goto conn_fail;
106	}
107
108	chatter_printf(conn->chatter, conn, NULL,
109	"$B***$0 Connecting to $B%s$0 port $B%d$0...", conn->hostname,
110	conn->port);
111
112	if ((err = _TCPCreate(&conn->send_pb, &conn->stream, (Ptr)conn->tcp_buf,
113	sizeof(conn->tcp_buf), NULL, NULL, NULL, false)) != noErr) {
114	chatter_printf(conn->chatter, conn, NULL,
115	"$B! TCPCreate failed: %d$0", err);
116	return conn;
117	}
118
119	if ((err = DNSResolveName(conn->hostname, &ip, NULL)) != 0) {
120	chatter_printf(conn->chatter, conn, NULL,
121	"$B! Couldn't resolve host %s (%d)$0", conn->hostname, err);
122	conn->state = IRC_STATE_DEAD;
123	return conn;
124	}
125
126	long2ip(ip, ip_str);
127
128	if ((err = _TCPActiveOpen(&conn->send_pb, conn->stream, ip,
129	conn->port, &local_ip, &local_port, NULL, NULL, false)) != noErr) {
130	chatter_printf(conn->chatter, conn, NULL,
131	"$B! Failed connecting to %s (%s) port %d: %d$0",
132	conn->hostname, ip_str, conn->port, err);
133	conn->state = IRC_STATE_DEAD;
134	return conn;
135	}
136
137	chatter_printf(conn->chatter, conn, NULL,
138	"$B***$0 Connected to $B%s$0 (%s) port $B%d$0", conn->hostname,
139	ip_str, conn->port);
140
141	conn->state = IRC_STATE_UNREGISTERED;
142
143	return conn;
144
145	conn_fail:
146	warn("Out of memory for new connection");
147	if (conn != NULL)
148	irc_dealloc_connection(conn);
149	return NULL;
150	}
151
152	void
153	irc_close_connection(struct irc_connection *conn)
154	{
155	if (conn->state == IRC_STATE_CONNECTED)
156	irc_quit_with_message(conn, NULL);
157
158	if (conn->stream) {
159	_TCPAbort(&conn->close_pb, conn->stream, NULL, NULL, false);
160	_TCPRelease(&conn->close_pb, conn->stream, NULL, NULL, false);
161	conn->stream = 0;
162	}
163
164	conn->state = IRC_STATE_DISCONNECTED;
165	}
166
167	void
168	irc_dealloc_connection(struct irc_connection *conn)
169	{
170	struct irc_connection *tconn;
171	short n;
172
173	irc_close_connection(conn);
174
175	while (!SLIST_EMPTY(&conn->channels_list))
176	irc_dealloc_channel(SLIST_FIRST(&conn->channels_list));
177
178	if (conn->hostname != NULL)
179	xfree(&conn->hostname);
180	if (conn->password != NULL)
181	xfree(&conn->password);
182	if (conn->nick != NULL)
183	xfree(&conn->nick);
184	if (conn->ident != NULL)
185	xfree(&conn->ident);
186	if (conn->realname != NULL)
187	xfree(&conn->realname);
188	if (conn->channel_autojoin != NULL)
189	xfree(&conn->channel_autojoin);
190
191	SLIST_REMOVE(&irc_connections_list, conn, irc_connection, list);
192
193	xfree(&conn);
194	}
195
196	void
197	irc_process(struct irc_connection *conn)
198	{
199	if (conn->state >= IRC_STATE_UNREGISTERED)
200	irc_recv(conn);
201
202	switch (conn->state) {
203	case IRC_STATE_DISCONNECTED:
204	break;
205	case IRC_STATE_DEAD:
206	irc_close_connection(conn);
207	break;
208	case IRC_STATE_UNREGISTERED:
209	irc_register(conn);
210	break;
211	case IRC_STATE_CONNECTED:
212	irc_process_server(conn);
213	break;
214	}
215	}
216
217	short
218	irc_recv(struct irc_connection *conn)
219	{
220	unsigned short rlen;
221	short error, rerror, n;
222
223	if (conn->state < IRC_STATE_UNREGISTERED)
224	return 0;
225
226	error = _TCPStatus(&conn->rcv_pb, conn->stream, &conn->status_pb, NULL,
227	NULL, false);
228
229	if (conn->status_pb.amtUnreadData > 0 &&
230	conn->ibuflen < sizeof(conn->ibuf)) {
231	rlen = conn->status_pb.amtUnreadData;
232	if (conn->ibuflen + rlen > sizeof(conn->ibuf))
233	rlen = sizeof(conn->ibuf) - conn->ibuflen;
234
235	rerror = _TCPRcv(&conn->rcv_pb, conn->stream,
236	(Ptr)(conn->ibuf + conn->ibuflen), &rlen, NULL, NULL, false);
237	if (rerror) {
238	chatter_printf(conn->chatter, conn, NULL,
239	"$B! TCPRecv failed (%d), disconnecting$0", error);
240	conn->state = IRC_STATE_DEAD;
241	return -1;
242	}
243
244	conn->ibuflen += rlen;
245	}
246
247	if (error \|\|
248	conn->status_pb.connectionState != ConnectionStateEstablished) {
249	/* let already-consumed buffer finish processing */
250	while (irc_process_server(conn))
251	SystemTask();
252	if (error)
253	chatter_printf(conn->chatter, conn, NULL,
254	"$B! TCPStatus failed: %d$0",
255	error);
256	else
257	chatter_printf(conn->chatter, conn, NULL,
258	"$B! Connection closed$0");
259	conn->state = IRC_STATE_DEAD;
260	return -1;
261	}
262
263	return rlen;
264	}
265
266	size_t
267	irc_send(struct irc_connection conn, char line, size_t size)
268	{
269	short error;
270
271	if (size > sizeof(conn->obuf))
272	panic("irc_send: too much data (%lu)", size);
273
274	if (conn->state < IRC_STATE_UNREGISTERED)
275	return 0;
276
277	while (!IRC_CAN_SEND(conn))
278	SystemTask();
279
280	if (conn->send_pb.ioResult < 0) {
281	chatter_printf(conn->chatter, conn, NULL,
282	"$B! TCPSend failed (%d), disconnecting$0",
283	conn->send_pb.ioResult);
284	conn->state = IRC_STATE_DEAD;
285	return 0;
286	}
287
288	memcpy(&conn->obuf, line, size);
289
290	/*
291	* _TCPSend only knows how many wds pointers were passed in when it
292	* reads the next one and its pointer is zero (or size is zero?), so
293	* even though we're only sending one wds, memory after wds[0]
294	* has to be zeroed out.
295	*/
296	memset(&conn->wds, 0, sizeof(conn->wds));
297	conn->wds[0].ptr = (Ptr)&conn->obuf;
298	conn->wds[0].length = size;
299
300	error = _TCPSend(&conn->send_pb, conn->stream, conn->wds, NULL, NULL,
301	true);
302	if (error) {
303	chatter_printf(conn->chatter, conn, NULL,
304	"$B! TCPSend failed (%d), disconnecting$0", error);
305	conn->state = IRC_STATE_DEAD;
306	return 0;
307	}
308
309	return size;
310	}
311
312	size_t
313	irc_printf(struct irc_connection conn, const char format, ...)
314	{
315	static char buf[512];
316	va_list argptr;
317	size_t len = 0;
318
319	va_start(argptr, format);
320	len = vsnprintf(buf, sizeof(buf), format, argptr);
321	va_end(argptr);
322
323	if (len > sizeof(buf)) {
324	warn("irc_printf overflow!");
325	len = sizeof(buf);
326	buf[len - 1] = '\0';
327	}
328
329	irc_send(conn, buf, len);
330
331	return len;
332	}
333
334	struct irc_user *
335	irc_parse_user(char *str)
336	{
337	static struct irc_user parsed_user;
338	short ret;
339
340	memset(&parsed_user, 0, sizeof(parsed_user));
341	ret = sscanf(str, "%[^!]!%[^@]@%s", &parsed_user.nick,
342	&parsed_user.username, &parsed_user.hostname);
343	if (ret != 3) {
344	/* probably just a hostname */
345	strlcpy(parsed_user.nick, str, sizeof(parsed_user.nick));
346	strlcpy(parsed_user.username, str, sizeof(parsed_user.username));
347	strlcpy(parsed_user.hostname, str, sizeof(parsed_user.hostname));
348	}
349	return &parsed_user;
350	}
351
352	char *
353	irc_get_line(struct irc_connection conn, size_t retsize)
354	{
355	size_t n;
356
357	if (conn->ibuflen == 0) {
358	if (retsize != NULL)
359	*retsize = 0;
360	return NULL;
361	}
362
363	for (n = 0; n < conn->ibuflen - 1; n++) {
364	if (conn->ibuf[n] != '\r')
365	continue;
366	if (conn->ibuf[n + 1] != '\n')
367	continue;
368
369	if (conn->flushing_ibuf) {
370	conn->flushing_ibuf = false;
371	conn->line[0] = '\0';
372	} else if (n + 1 > sizeof(conn->line) - 1) {
373	/*
374	* Line is too long to process but we can't take part of it,
375	* so bail on it and hope it wasn't something important :(
376	*/
377	chatter_printf(conn->chatter, NULL, NULL,
378	"! Line too long to process");
379	conn->line[0] = '\0';
380	} else {
381	memcpy(conn->line, conn->ibuf, n + 1);
382	conn->line[n] = '\0';
383	if (retsize != NULL)
384	*retsize = n + 1;
385	}
386
387	if (n == conn->ibuflen - 2) {
388	conn->ibuflen = 0;
389	} else {
390	conn->ibuflen -= n + 2;
391	if (conn->ibuflen < 0)
392	panic("irc_get_line: bogus ibuflen %d", conn->ibuflen);
393	memmove(conn->ibuf, conn->ibuf + n + 2, conn->ibuflen);
394	}
395	return conn->line;
396	}
397
398	if (n >= sizeof(conn->ibuf) - 1) {
399	/*
400	* ibuf is full with no newline but we can't empty the buffer and
401	* start the next iteration in the middle of this line, so
402	* consider ibuf bogus until we see a newline.
403	*/
404	conn->flushing_ibuf = true;
405	conn->ibuflen = 0;
406	chatter_printf(conn->chatter, NULL, NULL,
407	"! ibuf with no newline, flushing");
408	}
409
410	return NULL;
411	}
412
413	struct irc_channel *
414	irc_find_channel(struct irc_connection conn, char channame)
415	{
416	struct irc_channel *channel;
417
418	if (channame == NULL \|\| channame[0] == '\0')
419	return NULL;
420
421	SLIST_FOREACH(channel, &conn->channels_list, list) {
422	if (strcasecmp(channel->name, channame) == 0)
423	return channel;
424	}
425
426	return NULL;
427	}
428
429	void
430	irc_register(struct irc_connection *conn)
431	{
432	size_t len;
433
434	if (conn->state == IRC_STATE_CONNECTED)
435	return;
436
437	if (conn->password && conn->password[0]) {
438	len = snprintf(conn->line, sizeof(conn->line),
439	"PASS %s\r\n", conn->password);
440	irc_send(conn, conn->line, len);
441	}
442
443	len = snprintf(conn->line, sizeof(conn->line),
444	"NICK %s\r\n", conn->nick);
445	irc_send(conn, conn->line, len);
446
447	len = snprintf(conn->line, sizeof(conn->line),
448	"USER %s 0 * :%s\r\n", conn->ident, conn->realname);
449	irc_send(conn, conn->line, len);
450
451	if (conn->state == IRC_STATE_UNREGISTERED)
452	conn->state = IRC_STATE_CONNECTED;
453	}
454
455	bool
456	irc_process_server(struct irc_connection *conn)
457	{
458	struct irc_msg msg;
459	struct irc_user *user;
460	struct irc_channel *channel;
461	struct chatter_tab *tab;
462	char line, word;
463	size_t size, n, lastbreak;
464	short curarg;
465
466	line = irc_get_line(conn, &size);
467	if (size == 0 \|\| line == NULL)
468	return false;
469
470	memset(&msg, 0, sizeof(msg));
471
472	word = strsep(&line, " ");
473	if (word == NULL)
474	/* server sent us a blank line? */
475	return false;
476
477	/* extract source before command */
478	if (word[0] == ':') {
479	/* ":server.name 001 jcs :Hi" -> msg.source=server.name */
480	strlcpy(msg.source, word + 1, sizeof(msg.source));
481	word = strsep(&line, " ");
482	}
483
484	/* code or a command name */
485	if (isdigit(word[0]) && isdigit(word[1]) && isdigit(word[2]))
486	/* ":server.name 001 jcs :Hi" -> msg.code=1 */
487	msg.code = atoi(word);
488	else
489	/* "PING :server.name" -> msg.cmd=PING */
490	/* ":jcs!~jcs@jcs JOIN #wallops" -> msg.cmd=JOIN */
491	strlcpy(msg.cmd, word, sizeof(msg.cmd));
492
493	/* parameters, put into args until we see one starting with : */
494	curarg = 0;
495	while (line != NULL && line[0] != '\0') {
496	if (line[0] == ':') {
497	strlcpy(msg.msg, line + 1, sizeof(msg.msg));
498
499	/* some irc servers put the first arg as the message */
500	if (curarg == 0)
501	strlcpy(msg.arg[0], line + 1, sizeof(msg.arg[0]));
502	break;
503	}
504
505	word = strsep(&line, " ");
506	if (word == NULL) {
507	strlcpy(msg.msg, line, sizeof(msg.msg));
508	break;
509	}
510
511	strlcpy(msg.arg[curarg], word, sizeof(msg.arg[curarg]));
512	curarg++;
513
514	if (curarg >= IRC_MSG_MAX_ARGS) {
515	/* just stick the rest in msg */
516	strlcpy(msg.msg, line, sizeof(msg.msg));
517	break;
518	}
519	}
520
521	if (msg.cmd[0]) {
522	/* this one will fire most often, keep at the top */
523	if (strcmp(msg.cmd, "PRIVMSG") == 0) {
524	user = irc_parse_user(msg.source);
525	size = strlen(msg.msg);
526
527	if (msg.msg[0] == '\1' && msg.msg[size - 1] == '\1') {
528	/* CTCP or a /me action */
529	msg.msg[size - 1] = '\0';
530	if (strncmp(msg.msg + 1, "ACTION", 6) == 0) {
531	chatter_printf(conn->chatter, conn, msg.arg[0],
532	"* %s$/ %s",
533	user->nick, msg.msg + 8);
534	} else if (strncmp(msg.msg + 1, "VERSION", 7) == 0) {
535	chatter_printf(conn->chatter, conn, msg.arg[0],
536	"$B*** %s ($0%s@%s$B)$0 requested CTCP $BVERSION$0 "
537	"from $B%s$0",
538	user->nick, user->username, user->hostname,
539	msg.arg[0]);
540
541	/* only respond if it was sent directly to us */
542	if (strcmp(msg.arg[0], conn->nick) == 0) {
543	irc_printf(conn,
544	"NOTICE %s :\1VERSION %s %s on a %s\1\r\n",
545	user->nick, PROGRAM_NAME, get_version(false),
546	gestalt_machine_type());
547	}
548	} else {
549	chatter_printf(conn->chatter, conn, msg.arg[0],
550	"$B*** %s ($0%s@%s$B)$0 requested unknown CTCP "
551	"$B%s$0 from $B%s$0",
552	user->nick, user->username, user->hostname,
553	msg.msg + 1, msg.arg[0]);
554	}
555	} else if (strcmp(msg.arg[0], conn->nick) == 0) {
556	/* message to us */
557	if (chatter_find_tab(conn->chatter, conn, user->nick))
558	/* query with this user open */
559	chatter_printf(conn->chatter, conn, user->nick,
560	"$/<%s> %s",
561	user->nick, msg.msg);
562	else
563	chatter_printf(conn->chatter, conn, user->nick,
564	"$B[%s($0%s@%s$B)]$0$/ %s",
565	user->nick, user->username, user->hostname, msg.msg);
566	if (!conn->chatter->focusable->visible)
567	notify();
568	} else {
569	/* message to channel we're in */
570	char *us;
571
572	us = strcasestr(msg.msg, conn->nick);
573	if (us == msg.msg \|\| us[-1] == ' ') {
574	if (us[conn->nick_len] == ' ' \|\|
575	us[conn->nick_len] == ':' \|\|
576	us[conn->nick_len] == ',' \|\|
577	us[conn->nick_len] == '!' \|\|
578	us[conn->nick_len] == '?' \|\|
579	us[conn->nick_len] == '\0') {
580	/* /^nick[ :,?!$]/ or / nick[ :,?!$]/ */
581	} else
582	us = NULL;
583	} else
584	us = NULL;
585
586	if (us) {
587	/* mention to us, highlight */
588	chatter_printf(conn->chatter, conn, msg.arg[0],
589	"<$U%s$0>$/ %s",
590	user->nick, msg.msg);
591	if (!conn->chatter->focusable->visible)
592	notify();
593	} else
594	chatter_printf(conn->chatter, conn, msg.arg[0],
595	"$/<%s> %s",
596	user->nick, msg.msg);
597	}
598	return true;
599	}
600	if (strcmp(msg.cmd, "PING") == 0) {
601	irc_printf(conn, "PONG :%s\r\n", msg.msg);
602	return true;
603	}
604
605	if (strcmp(msg.cmd, "ERROR") == 0) {
606	chatter_printf(conn->chatter, conn, NULL,
607	"$B! Disconnected$0 from $B%s$0:$/ %s",
608	conn->hostname, msg.msg);
609	conn->state = IRC_STATE_DEAD;
610	return true;
611	}
612	if (strcmp(msg.cmd, "JOIN") == 0) {
613	user = irc_parse_user(msg.source);
614	if (strcmp(user->nick, conn->nick) == 0)
615	channel = irc_create_channel(conn, msg.arg[0]);
616	else {
617	channel = irc_find_channel(conn, msg.arg[0]);
618	if (channel)
619	irc_add_nick_to_channel(channel, user->nick, 0, 0);
620	}
621	if (!(settings.ignores & IGNORE_JOINS))
622	chatter_printf(channel->chatter, conn, msg.arg[0],
623	"$B*** %s ($0%s@%s$B)$0 has joined $B%s$0",
624	user->nick, user->username, user->hostname, msg.arg[0]);
625	return true;
626	}
627	if (strcmp(msg.cmd, "KICK") == 0) {
628	user = irc_parse_user(msg.source);
629	if ((channel = irc_find_channel(conn, msg.arg[0]))) {
630	if (strcmp(msg.arg[1], conn->nick) == 0) {
631	irc_dealloc_channel(channel);
632	channel = NULL;
633	} else
634	irc_remove_nick_from_channel(channel, msg.arg[1]);
635	}
636	if (!(settings.ignores & IGNORE_QUITS))
637	chatter_printf(conn->chatter, conn, msg.arg[0],
638	"$B*** %s$0 was kicked from $B%s$0 by $B%s$0:$/ %s",
639	msg.arg[0], msg.arg[1], user->nick, msg.msg);
640	return true;
641	}
642	if (strcmp(msg.cmd, "KILL") == 0) {
643	user = irc_parse_user(msg.source);
644	if (strcmp(user->nick, conn->nick) == 0) {
645	/* we died :( */
646	warn("%s (%s@%s) has been killed: %s",
647	user->nick, user->username, user->hostname, msg.msg);
648	conn->state = IRC_STATE_DEAD;
649	return false;
650	}
651	SLIST_FOREACH(channel, &conn->channels_list, list) {
652	if (!irc_nick_is_in_channel(channel, user->nick))
653	continue;
654
655	chatter_printf(conn->chatter, conn, channel->name,
656	"$B*** %s ($0%s@%s$B)$0 has been killed:$/ %s",
657	user->nick, user->username, user->hostname, msg.msg);
658	irc_remove_nick_from_channel(channel, user->nick);
659	}
660	return true;
661	}
662	if (strcmp(msg.cmd, "MODE") == 0) {
663	if (strcmp(msg.arg[0], conn->nick) == 0)
664	chatter_printf(conn->chatter, conn, NULL,
665	"$B***$0 Mode change ($B%s$0) for user $B%s$0",
666	msg.msg, msg.arg[0]);
667	else {
668	user = irc_parse_user(msg.source);
669	channel = irc_find_channel(conn, msg.arg[0]);
670	/* concatenate nicks */
671	msg.msg[0] = '\0';
672	if (msg.arg[2][0] != '\0')
673	strlcat(msg.msg, msg.arg[2], sizeof(msg.msg));
674	if (msg.arg[3][0] != '\0') {
675	strlcat(msg.msg, " ", sizeof(msg.msg));
676	strlcat(msg.msg, msg.arg[3], sizeof(msg.msg));
677	}
678	if (msg.arg[4][0] != '\0') {
679	strlcat(msg.msg, " ", sizeof(msg.msg));
680	strlcat(msg.msg, msg.arg[4], sizeof(msg.msg));
681	}
682	if (msg.arg[5][0] != '\0') {
683	strlcat(msg.msg, " ", sizeof(msg.msg));
684	strlcat(msg.msg, msg.arg[5], sizeof(msg.msg));
685	}
686
687	if (channel && channel->mode[0] == '\0')
688	/* probably initial mode on join, wait for 324 */
689	return true;
690
691	chatter_printf(conn->chatter, conn,
692	channel ? channel->name : NULL,
693	"$B***$0 Mode change ($B%s %s$0) on $B%s$0 by $B%s$0",
694	msg.arg[1], msg.msg, msg.arg[0], user->nick);
695	if (channel) {
696	bool others = irc_parse_channel_mode_change(channel,
697	msg.arg[1], msg.msg);
698	if (others)
699	/*
700	* To simplify parsing mode changes like "+ik blah",
701	* just ask for the full mode now to get a 324
702	*/
703	irc_printf(conn, "MODE %s\r\n", channel->name);
704	}
705	}
706	return true;
707	}
708	if (strcmp(msg.cmd, "NICK") == 0) {
709	struct chatter_tab *tab;
710
711	user = irc_parse_user(msg.source);
712	if (strcasecmp(user->nick, conn->nick) == 0) {
713	chatter_printf(conn->chatter, conn, NULL,
714	"$B*** %s$0 is now known as $B%s$0",
715	user->nick, msg.msg);
716	irc_change_user_nick(conn, NULL, user, msg.msg);
717	}
718	SLIST_FOREACH(channel, &conn->channels_list, list) {
719	if (!irc_nick_is_in_channel(channel, user->nick))
720	continue;
721
722	if (!(settings.ignores & IGNORE_NICKS))
723	chatter_printf(conn->chatter, conn, channel->name,
724	"$B*** %s$0 is now known as $B%s$0",
725	user->nick, msg.msg);
726	irc_change_user_nick(conn, channel, user, msg.msg);
727	}
728	SLIST_FOREACH(tab, &conn->chatter->tabs_list, list) {
729	if (tab->query_nick[0] &&
730	strcasecmp(tab->query_nick, user->nick) == 0) {
731	strlcpy(tab->query_nick, user->nick,
732	sizeof(user->nick));
733	conn->chatter->need_tab_bar_redraw = true;
734	}
735	}
736	return true;
737	}
738	if (strcmp(msg.cmd, "NOTICE") == 0) {
739	if (strchr(msg.source, '@') == NULL) {
740	/* server notice */
741	if (strncmp(msg.msg, "*** ", 4) == 0)
742	chatter_printf(conn->chatter, conn, NULL,
743	"$B***$0 $/%s",
744	msg.msg + 4);
745	else
746	chatter_printf(conn->chatter, conn, NULL,
747	"$/%s",
748	msg.msg);
749	} else {
750	/* user notice */
751	user = irc_parse_user(msg.source);
752	chatter_printf(conn->chatter, conn, user->nick,
753	"$Bnotice:[%s($0%s@%s$B)]$0$/ %s",
754	user->nick, user->username, user->hostname, msg.msg);
755	}
756	return true;
757	}
758	if (strcmp(msg.cmd, "PART") == 0) {
759	user = irc_parse_user(msg.source);
760	if ((channel = irc_find_channel(conn, msg.arg[0]))) {
761	if (strcmp(user->nick, conn->nick) == 0) {
762	irc_dealloc_channel(channel);
763	channel = NULL;
764	/* we don't need to print anything */
765	} else {
766	irc_remove_nick_from_channel(channel, user->nick);
767	if (!(settings.ignores & IGNORE_QUITS))
768	chatter_printf(conn->chatter, conn, channel->name,
769	"$B*** %s ($0%s@%s$B)$0 has left $B%s$0",
770	user->nick, user->username, user->hostname,
771	msg.arg[0]);
772	}
773	}
774	return true;
775	}
776	if (strcmp(msg.cmd, "QUIT") == 0) {
777	user = irc_parse_user(msg.source);
778
779	SLIST_FOREACH(channel, &conn->channels_list, list) {
780	if (!irc_nick_is_in_channel(channel, user->nick))
781	continue;
782
783	irc_remove_nick_from_channel(channel, user->nick);
784	if (!(settings.ignores & IGNORE_QUITS))
785	chatter_printf(conn->chatter, conn, channel->name,
786	"$B*** %s ($0%s@%s$B)$0 has quit:$/ %s",
787	user->nick, user->username, user->hostname, msg.msg);
788	}
789
790	if (strcmp(user->nick, conn->nick) == 0) {
791	chatter_printf(conn->chatter, conn, NULL,
792	"$B*** %s ($0%s@%s$B)$0 has quit:$/ %s",
793	user->nick, user->username, user->hostname, msg.msg);
794	conn->state = IRC_STATE_DEAD;
795	return false;
796	}
797	return true;
798	}
799	if (strcmp(msg.cmd, "TOPIC") == 0) {
800	user = irc_parse_user(msg.source);
801	chatter_printf(conn->chatter, conn, msg.arg[0],
802	"$B***$0 Topic for $B%s$0 changed by $B%s$0:$/ %s",
803	msg.arg[0], user->nick, msg.msg);
804	if ((channel = irc_find_channel(conn, msg.arg[0])))
805	strlcpy(channel->topic, msg.msg, sizeof(channel->topic));
806	return true;
807	}
808	if (strcmp(msg.cmd, "WALLOPS") == 0) {
809	chatter_printf(conn->chatter, conn, NULL,
810	"$B***$0 Wallops from $B%s$0:$/ %s",
811	msg.source, msg.msg);
812	return true;
813	}
814
815	goto unknown;
816	}
817
818	switch (msg.code) {
819	case 0:
820	goto unknown;
821	case 1:
822	case 2:
823	/* welcome banners */
824	goto print_msg;
825	case 3:
826	case 4:
827	case 5:
828	case 250:
829	case 251:
830	case 252:
831	case 253:
832	case 254:
833	case 255:
834	case 265:
835	case 266:
836	/* server stats, unhelpful */
837	return true;
838	case 221:
839	/* user mode */
840	chatter_printf(conn->chatter, conn, NULL,
841	"$B***$0 Mode for $B%s$0:$/ %s",
842	msg.arg[0], msg.arg[1]);
843	return true;
844	case 307:
845	/* WHOIS regnick */
846	chatter_printf(conn->chatter, conn, conn->current_whois,
847	"$B*** \|$0 Authenticated:$/ %s",
848	msg.msg);
849	return true;
850	case 311:
851	/* WHOIS nick: "nick :ident hostname * :name" */
852	strlcpy(conn->current_whois, msg.arg[1], sizeof(conn->current_whois));
853	chatter_printf(conn->chatter, conn, conn->current_whois,
854	"$B*** %s ($0%s@%s$B)$0",
855	msg.arg[1], msg.arg[2], msg.arg[3]);
856	chatter_printf(conn->chatter, conn, conn->current_whois,
857	"$B*** \|$0 Name:$/ %s",
858	msg.msg);
859	return true;
860	case 312:
861	/* WHOIS server */
862	chatter_printf(conn->chatter, conn, conn->current_whois,
863	"$B*** \|$0 Server:$/ %s (%s)",
864	msg.arg[2], msg.msg);
865	return true;
866	case 315:
867	/* end of WHO */
868	chatter_printf(conn->chatter, conn, NULL,
869	"$B***$0$/ %s",
870	msg.msg);
871	return true;
872	case 317:
873	/* WHOIS idle */
874	chatter_printf(conn->chatter, conn, conn->current_whois,
875	"$B*** \|$0 Idle:$/ %s %s",
876	msg.arg[2], msg.msg);
877	return true;
878	case 318:
879	/* WHOIS end */
880	chatter_printf(conn->chatter, conn, conn->current_whois,
881	"$B*** `-------$0");
882	memset(conn->current_whois, 0, sizeof(conn->current_whois));
883	return true;
884	case 319:
885	/* WHOIS channels */
886	chatter_printf(conn->chatter, conn, conn->current_whois,
887	"$B*** \|$0 Channels:$/ %s",
888	msg.msg);
889	return true;
890	case 324:
891	/* channel mode, concatenate args */
892	msg.msg[0] = '\0';
893	if (msg.arg[2][0] != '\0')
894	strlcat(msg.msg, msg.arg[2], sizeof(msg.msg));
895	if (msg.arg[3][0] != '\0') {
896	strlcat(msg.msg, " ", sizeof(msg.msg));
897	strlcat(msg.msg, msg.arg[3], sizeof(msg.msg));
898	}
899	if (msg.arg[4][0] != '\0') {
900	strlcat(msg.msg, " ", sizeof(msg.msg));
901	strlcat(msg.msg, msg.arg[4], sizeof(msg.msg));
902	}
903	if (msg.arg[5][0] != '\0') {
904	strlcat(msg.msg, " ", sizeof(msg.msg));
905	strlcat(msg.msg, msg.arg[5], sizeof(msg.msg));
906	}
907	if ((channel = irc_find_channel(conn, msg.arg[1]))) {
908	if (channel->chatter && channel->mode[0] == '\0') {
909	/* initial mode set from join is unimportant */
910	tab = chatter_find_tab(conn->chatter, conn, msg.arg[1]);
911	if (tab)
912	tab->ignore_activity = true;
913	}
914	strlcpy(channel->mode, msg.msg, sizeof(channel->mode));
915	if (channel->chatter)
916	channel->chatter->need_tab_bar_redraw = true;
917	}
918	chatter_printf(conn->chatter, conn, msg.arg[1],
919	"$B***$0 Mode for $B%s$0:$/ %s",
920	msg.arg[1], msg.msg);
921	if (tab)
922	tab->ignore_activity = false;
923	return true;
924	case 328:
925	/* channel URL, we probably can't do anything with it anyway */
926	return true;
927	case 329:
928	/* channel creation timestamp */
929	return true;
930	case 330:
931	/* WHOIS account */
932	chatter_printf(conn->chatter, conn, conn->current_whois,
933	"$B*** \|$0 Account:$/ %s %s",
934	msg.msg, msg.arg[2]);
935	return true;
936	case 331:
937	/* no TOPIC */
938	chatter_printf(conn->chatter, conn, msg.arg[1],
939	"$B***$0 No topic is set for $B%s$0",
940	msg.arg[1]);
941	if ((channel = irc_find_channel(conn, msg.arg[1])))
942	channel->topic[0] = '\0';
943	return true;
944	case 332:
945	/* TOPIC */
946	chatter_printf(conn->chatter, conn, msg.arg[1],
947	"$B***$0 Topic for $B%s$0:$/ %s",
948	msg.arg[1], msg.msg);
949	if ((channel = irc_find_channel(conn, msg.arg[1])))
950	strlcpy(channel->topic, msg.msg, sizeof(channel->topic));
951	return true;
952	case 333: {
953	/* TOPIC creator */
954	unsigned long ts;
955
956	user = irc_parse_user(msg.arg[2]);
957
958	/* TODO: convert unix to mac time, strftime */
959	sscanf(msg.arg[3], "%ld", &ts);
960
961	chatter_printf(conn->chatter, conn, msg.arg[1],
962	"$B***$0 Topic set by $B%s$0",
963	user->nick);
964	return true;
965	}
966	case 338:
967	case 378:
968	/* WHOIS host */
969	chatter_printf(conn->chatter, conn, conn->current_whois,
970	"$B*** \|$0 Host:$/ %s %s",
971	msg.msg, msg.arg[2]);
972	return true;
973	case 352:
974	/* WHO output */
975	chatter_printf(conn->chatter, conn, NULL,
976	"$B***$0$/ %s %s@%s (%s)",
977	msg.arg[1], msg.arg[2], msg.arg[3], msg.msg);
978	return true;
979	case 353:
980	/* NAMES output */
981	if ((channel = irc_find_channel(conn, msg.arg[2])))
982	irc_parse_names(channel, msg.msg);
983	return true;
984	case 366:
985	/* end of NAMES output */
986	if ((channel = irc_find_channel(conn, msg.arg[1]))) {
987	channel->parsing_nicks = false;
988	chatter_sync_nick_list(channel->chatter, channel);
989	}
990	return true;
991	case 372:
992	case 375:
993	/* MOTD */
994	if (conn->hide_motd)
995	return true;
996	goto print_msg;
997	case 376:
998	/* end of MOTD */
999	if (conn->channel_autojoin && conn->channel_autojoin[0] &&
1000	!conn->did_autojoin) {
1001	irc_printf(conn, "JOIN %s\r\n", conn->channel_autojoin);
1002	conn->did_autojoin = true;
1003	}
1004	if (conn->hide_motd)
1005	return true;
1006	goto print_msg;
1007	case 396:
1008	/* Cloak */
1009	chatter_printf(conn->chatter, conn, NULL,
1010	"$B***$0$/ %s %s",
1011	msg.arg[1], msg.msg);
1012	return true;
1013	case 433: {
1014	/* Nick in use, try appending a _ */
1015	char *new_nick = xmalloc(strlen(conn->nick) + 2);
1016	size_t len;
1017
1018	chatter_printf(conn->chatter, conn, NULL,
1019	"$B***$0$/ %s: %s",
1020	msg.arg[1], msg.msg);
1021
1022	sprintf(new_nick, "%s_", conn->nick);
1023	xfree(&conn->nick);
1024	conn->nick = new_nick;
1025	chatter_update_titlebar(conn->chatter);
1026
1027	len = snprintf(conn->line, sizeof(conn->line),
1028	"NICK %s\r\n", conn->nick);
1029	irc_send(conn, conn->line, len);
1030	return true;
1031	}
1032	case 461:
1033	/* not enough args */
1034	chatter_printf(conn->chatter, conn, NULL,
1035	"$B***$0 $B%s$0$/: %s",
1036	msg.arg[1], msg.msg);
1037	return true;
1038	case 475:
1039	/* can't join channel */
1040	chatter_printf(conn->chatter, conn, NULL,
1041	"$B***$0 Can't join $B%s$0$/: %s",
1042	msg.arg[1], msg.msg);
1043	return true;
1044	case 481:
1045	/* not oper */
1046	chatter_printf(conn->chatter, conn, NULL,
1047	"$B***$0 You can't do that thing if you ain't got that "
1048	"swing:$/: %s",
1049	msg.msg);
1050	return true;
1051	case 482:
1052	/* not op */
1053	chatter_printf(conn->chatter, conn, NULL,
1054	"$B***$0 Can't do that on $B%s$0$/: %s",
1055	msg.arg[1], msg.msg);
1056	return true;
1057	case 502:
1058	/* error */
1059	chatter_printf(conn->chatter, conn, NULL,
1060	"$B***$0$/ %s",
1061	msg.msg);
1062	return true;
1063	case 671:
1064	/* WHOIS server */
1065	chatter_printf(conn->chatter, conn, conn->current_whois,
1066	"$B*** \|$0 Connection:$/ %s",
1067	msg.msg);
1068	return true;
1069	case 730:
1070	/* monitor online */
1071	chatter_printf(conn->chatter, conn, NULL,
1072	"$B***$0 $B%s$0$/ %s online",
1073	msg.msg, strstr(msg.msg, ",") ? "are" : "is");
1074	if (conn->chatter->focusable && !conn->chatter->focusable->visible)
1075	notify();
1076	return true;
1077	case 731:
1078	/* monitor offline */
1079	chatter_printf(conn->chatter, conn, NULL,
1080	"$B***$0 $B%s$0$/ %s offline",
1081	msg.msg, strstr(msg.msg, ",") ? "are" : "is");
1082	return true;
1083	case 732:
1084	/* monitor list */
1085	chatter_printf(conn->chatter, conn, NULL,
1086	"$B***$0 Monitor list: %s",
1087	msg.msg);
1088	return true;
1089	case 733:
1090	/* end of monitor list */
1091	return true;
1092	case 734:
1093	/* monitor error */
1094	chatter_printf(conn->chatter, conn, NULL,
1095	"$B***$0 Monitor error: %s",
1096	msg.msg);
1097	return true;
1098	case 900:
1099	/* nickserv login */
1100	chatter_printf(conn->chatter, conn, NULL,
1101	"$B***$0$/ %s",
1102	msg.msg);
1103	return true;
1104	default:
1105	goto unknown;
1106	}
1107
1108	print_msg:
1109	chatter_printf(conn->chatter, conn, NULL,
1110	"$B***$0$/ %s",
1111	msg.msg);
1112	return true;
1113
1114	unknown:
1115	chatter_printf(conn->chatter, conn, NULL,
1116	"$B[?]$0$/ code:%d cmd:%s source:%s arg0:%s arg1:%s arg2:%s arg3:%s "
1117	"arg4:%s msg:%s",
1118	msg.code, msg.cmd, msg.source, msg.arg[0], msg.arg[1], msg.arg[2],
1119	msg.arg[3], msg.arg[4], msg.msg);
1120	return true;
1121	}
1122
1123	void
1124	irc_process_input(struct irc_connection conn, struct irc_channel channel,
1125	char query_nick, char str)
1126	{
1127	struct chatter_tab *tab;
1128	char arg0, arg1, *channel_name;
1129	size_t n;
1130	bool say = false;
1131
1132	/* check for commands that don't require a connection */
1133	if (strcasecmp(str, "/quit") == 0 \|\|
1134	strncasecmp(str, "/quit ", 6) == 0)
1135	{
1136	str++;
1137	arg0 = strsep(&str, " ");
1138
1139	if (conn && conn->state == IRC_STATE_CONNECTED) {
1140	irc_quit_with_message(conn, str);
1141	conn->state = IRC_STATE_DEAD;
1142	}
1143	if (focusables_quit())
1144	ExitToShell();
1145	return;
1146	}
1147	if (strcasecmp(str, "/connect") == 0 \|\|
1148	strncasecmp(str, "/connect ", 9) == 0 \|\|
1149	strcasecmp(str, "/recon") == 0 \|\|
1150	strcasecmp(str, "/reconnect") == 0 \|\|
1151	strcasecmp(str, "/server") == 0 \|\|
1152	strncasecmp(str, "/server ", 8) == 0) {
1153	struct irc_connection *new;
1154	struct chatter_tab *tab;
1155	char *autojoin = NULL;
1156	size_t len;
1157
1158	str++;
1159	arg0 = strsep(&str, " ");
1160	if (strcasecmp(arg0, "server") == 0 && str == NULL)
1161	goto not_enough_params;
1162
1163	/* build a new list of autojoin channels based on what's joined */
1164	len = 0;
1165	SLIST_FOREACH(tab, &conn->chatter->tabs_list, list) {
1166	if (tab->conn == conn && tab->channel)
1167	len += strlen(tab->channel->name) + 1;
1168	}
1169	if (len) {
1170	autojoin = xmalloc(len);
1171	if (autojoin == NULL) {
1172	chatter_printf(conn->chatter, conn, NULL,
1173	"$B!$0 Can't allocate memory for autojoin");
1174	return;
1175	}
1176	autojoin[0] = '\0';
1177	SLIST_FOREACH(tab, &conn->chatter->tabs_list, list) {
1178	if (tab->conn == conn && tab->channel) {
1179	if (autojoin[0])
1180	strlcat(autojoin, ",", len);
1181	strlcat(autojoin, tab->channel->name, len);
1182	}
1183	}
1184	}
1185
1186	new = irc_connect(conn->chatter, str ? str : conn->hostname,
1187	conn->port, conn->password, conn->nick, conn->ident,
1188	conn->realname, conn->hide_motd, autojoin);
1189
1190	if (new->state == IRC_STATE_UNREGISTERED) {
1191	/* the new connection succeeded, kill the old one */
1192	if (conn->state == IRC_STATE_CONNECTED)
1193	irc_close_connection(conn);
1194
1195	SLIST_FOREACH(tab, &conn->chatter->tabs_list, list) {
1196	if (tab->conn == conn)
1197	tab->conn = new;
1198	}
1199
1200	irc_dealloc_connection(conn);
1201
1202	conn->chatter->need_tab_bar_redraw = true;
1203	} else {
1204	/* just keep the old one */
1205	irc_dealloc_connection(new);
1206	}
1207
1208	return;
1209	}
1210
1211	/* everything else requires an active connection */
1212
1213	if (conn == NULL \|\| conn->state < IRC_STATE_CONNECTED)
1214	goto not_connected;
1215
1216	if (strncasecmp(str, "/say ", 5) == 0) {
1217	say = true;
1218	strsep(&str, " ");
1219	}
1220
1221	if (say \|\| str[0] != '/') {
1222	if (channel != NULL) {
1223	irc_printf(conn, "PRIVMSG %s :%s\r\n", channel->name, str);
1224	chatter_printf(conn->chatter, conn, channel->name,
1225	"<$B%s$0>$/ %s",
1226	conn->nick, str);
1227	} else if (query_nick != NULL) {
1228	irc_printf(conn, "PRIVMSG %s :%s\r\n", query_nick, str);
1229	chatter_printf(conn->chatter, conn, query_nick,
1230	"<$B%s$0>$/ %s",
1231	conn->nick, str);
1232	} else
1233	goto not_in_channel;
1234	return;
1235	}
1236
1237	/* skip / */
1238	str++;
1239
1240	arg0 = strsep(&str, " ");
1241
1242	/* special cases: send as-is */
1243	if (strcasecmp(arg0, "quote") == 0 \|\| strcasecmp(arg0, "raw") == 0) {
1244	if (str == NULL)
1245	goto not_enough_params;
1246	irc_printf(conn, "%s\r\n", str);
1247	return;
1248	}
1249
1250	if (str && (str[0] == '#' \|\| str[0] == '&'))
1251	/* channel specified */
1252	channel_name = strsep(&str, " ");
1253	else if (channel)
1254	/* use channel of current tab */
1255	channel_name = channel->name;
1256	else
1257	channel_name = NULL;
1258
1259	if (strcasecmp(arg0, "clear") == 0) {
1260	chatter_clear_messages(conn->chatter, conn->chatter->current_tab);
1261	return;
1262	}
1263	if (strcasecmp(arg0, "close") == 0) {
1264	if (conn->chatter->current_tab->query_nick[0] \|\|
1265	conn->chatter->current_tab->channel)
1266	chatter_close_tab(conn->chatter, conn->chatter->current_tab);
1267	else
1268	chatter_printf(conn->chatter, conn, NULL,
1269	"cannot close server tab, use /disconnect",
1270	arg0);
1271	return;
1272	}
1273	if (strcasecmp(arg0, "deop") == 0) {
1274	if (channel_name == NULL)
1275	goto not_in_channel;
1276	irc_do_mode_to_users(conn, channel_name, "-o", str);
1277	return;
1278	}
1279	if (strcasecmp(arg0, "devoice") == 0) {
1280	if (channel_name == NULL)
1281	goto not_in_channel;
1282	irc_do_mode_to_users(conn, channel_name, "-v", str);
1283	return;
1284	}
1285	if (strcasecmp(arg0, "disco") == 0 \|\|
1286	strcasecmp(arg0, "discon") == 0 \|\|
1287	strcasecmp(arg0, "disconnect") == 0) {
1288	irc_quit_with_message(conn, str);
1289	return;
1290	}
1291	if (strcasecmp(arg0, "join") == 0) {
1292	if (channel_name == NULL)
1293	goto not_enough_params;
1294	/*
1295	* If we're already in this channel, we won't get any response
1296	* from the server to switch channels.
1297	*/
1298	if ((channel = irc_find_channel(conn, channel_name)))
1299	/* this won't actually create, it'll just switch for us */
1300	irc_create_channel(conn, channel_name);
1301	else
1302	irc_printf(conn, "JOIN %s%s%s\r\n", channel_name,
1303	(str ? " " : ""), (str ? str : ""));
1304	return;
1305	}
1306	if (strcasecmp(arg0, "me") == 0) {
1307	if (str == NULL)
1308	goto not_enough_params;
1309	if (query_nick == NULL && channel == NULL)
1310	goto not_in_channel;
1311	chatter_printf(conn->chatter, conn,
1312	channel ? channel->name : query_nick,
1313	"* %s$/ %s",
1314	conn->nick, str);
1315	irc_printf(conn, "PRIVMSG %s :\1ACTION %s\1\r\n",
1316	channel ? channel->name : query_nick, str);
1317	return;
1318	}
1319	if (strcasecmp(arg0, "mode") == 0) {
1320	if (channel_name == NULL)
1321	goto not_in_channel;
1322	irc_printf(conn, "MODE %s%s%s\r\n", channel_name, (str ? " " : ""),
1323	(str ? str : ""));
1324	return;
1325	}
1326	if (strcasecmp(arg0, "monitor") == 0) {
1327	if (str == NULL)
1328	goto not_enough_params;
1329	irc_printf(conn, "MONITOR %s\r\n", str);
1330	return;
1331	}
1332	if (strcasecmp(arg0, "msg") == 0) {
1333	arg1 = strsep(&str, " ");
1334	if (arg1 == NULL \|\| str == NULL)
1335	goto not_enough_params;
1336	if ((tab = chatter_find_tab(conn->chatter, conn, NULL)))
1337	tab->ignore_activity = true;
1338	chatter_printf(conn->chatter, conn, NULL,
1339	"$B[$0msg$B($0%s$B)]$0$/ %s",
1340	arg1, str);
1341	if (tab)
1342	tab->ignore_activity = false;
1343	irc_printf(conn, "PRIVMSG %s :%s\r\n", arg1, str);
1344	return;
1345	}
1346	if (strcasecmp(arg0, "nick") == 0) {
1347	if (str == NULL)
1348	goto not_enough_params;
1349	irc_printf(conn, "NICK %s\r\n", str);
1350	return;
1351	}
1352	if (strcasecmp(arg0, "op") == 0) {
1353	if (channel_name == NULL)
1354	goto not_in_channel;
1355	irc_do_mode_to_users(conn, channel_name, "+o", str);
1356	return;
1357	}
1358	if (strcasecmp(arg0, "part") == 0) {
1359	if (channel_name == NULL)
1360	goto not_in_channel;
1361	irc_printf(conn, "PART %s%s%s\r\n", channel_name,
1362	(str ? " :" : ""), (str ? str : ""));
1363	return;
1364	}
1365	if (strcasecmp(arg0, "query") == 0) {
1366	if (str == NULL)
1367	goto not_enough_params;
1368	chatter_add_tab(conn->chatter, NULL, conn, NULL, str);
1369	return;
1370	}
1371	if (strcasecmp(arg0, "topic") == 0) {
1372	if (channel_name == NULL)
1373	goto not_in_channel;
1374	if (str)
1375	irc_printf(conn, "TOPIC %s :%s\r\n", channel_name, str);
1376	else
1377	irc_printf(conn, "TOPIC %s\r\n", channel_name);
1378	return;
1379	}
1380	if (strcasecmp(arg0, "umode") == 0) {
1381	irc_printf(conn, "MODE %s%s%s\r\n", conn->nick, (str ? " :" : ""),
1382	(str ? str : ""));
1383	return;
1384	}
1385	if (strcasecmp(arg0, "voice") == 0) {
1386	if (channel_name == NULL)
1387	goto not_in_channel;
1388	irc_do_mode_to_users(conn, channel_name, "+v", str);
1389	return;
1390	}
1391	if (strcasecmp(arg0, "who") == 0) {
1392	if (channel_name == NULL)
1393	goto not_in_channel;
1394	irc_printf(conn, "WHO %s\r\n", channel_name);
1395	return;
1396	}
1397	if (strcasecmp(arg0, "whois") == 0) {
1398	if (str == NULL)
1399	goto not_enough_params;
1400	irc_printf(conn, "WHOIS %s\r\n", str);
1401	return;
1402	}
1403
1404	chatter_printf(conn->chatter, conn, NULL,
1405	"unrecognized command \"$B%s$0\"",
1406	arg0);
1407	return;
1408
1409	not_enough_params:
1410	chatter_printf(conn->chatter, conn, channel ? channel->name : NULL,
1411	"$B!$0 Not enough parameters given");
1412	return;
1413	not_connected:
1414	chatter_printf(conn->chatter, conn, channel ? channel->name : NULL,
1415	"$B!$0 Not connected");
1416	return;
1417	not_in_channel:
1418	chatter_printf(conn->chatter, conn, NULL,
1419	"$B!$0 Cannot send (not in a channel)");
1420	return;
1421	}
1422
1423	struct irc_channel *
1424	irc_create_channel(struct irc_connection conn, char channame)
1425	{
1426	struct irc_channel channel, tchannel;
1427	short n;
1428
1429	SLIST_FOREACH(channel, &conn->channels_list, list) {
1430	if (strcasecmp(channel->name, channame) == 0)
1431	return channel;
1432	}
1433
1434	channel = xmalloczero(sizeof(struct irc_channel));
1435	if (channel == NULL)
1436	panic("Out of memory for new channel");
1437	SLIST_APPEND(&conn->channels_list, channel, irc_channel, list);
1438	channel->connection = conn;
1439	strlcpy(channel->name, channame, sizeof(channel->name));
1440	channel->chatter = conn->chatter;
1441	chatter_add_tab(channel->chatter, NULL, conn, channel, NULL);
1442
1443	irc_printf(conn, "MODE %s\r\n", channel->name);
1444
1445	return channel;
1446	}
1447
1448	void
1449	irc_quit_with_message(struct irc_connection conn, char str)
1450	{
1451	if (str)
1452	irc_printf(conn, "QUIT :%s\r\n", str);
1453	else
1454	irc_printf(conn, "QUIT :%s %s on a %s\r\n",
1455	PROGRAM_NAME, get_version(false), gestalt_machine_type());
1456	}
1457
1458	void
1459	irc_part_channel(struct irc_connection conn, struct irc_channel channel)
1460	{
1461	if (conn->state >= IRC_STATE_CONNECTED)
1462	irc_printf(conn, "PART %s\r\n", channel->name);
1463	}
1464
1465	void
1466	irc_dealloc_channel(struct irc_channel *channel)
1467	{
1468	struct irc_connection *conn = channel->connection;
1469	struct chatter *chatter = channel->chatter;
1470	struct chatter_tab *tab;
1471
1472	if ((tab = chatter_find_tab(chatter, conn, channel->name))) {
1473	/* clear channel first so close_tab doesn't try to part */
1474	tab->channel = NULL;
1475	chatter_close_tab(chatter, tab);
1476	}
1477
1478	if (channel->nicks)
1479	xfree(&channel->nicks);
1480
1481	SLIST_REMOVE(&conn->channels_list, channel, irc_channel, list);
1482
1483	xfree(&channel);
1484	}
1485
1486	void
1487	irc_parse_names(struct irc_channel channel, char line)
1488	{
1489	char nick, tline;
1490	short flags, count;
1491
1492	if (!channel->parsing_nicks) {
1493	/* new names output, clear previous */
1494	if (channel->nicks_size) {
1495	memset(&channel->nicks, 0,
1496	sizeof(struct irc_channel_nick) * channel->nicks_size);
1497	}
1498
1499	channel->nnicks = 0;
1500	channel->parsing_nicks = true;
1501	}
1502
1503	/* get a count of nicks to pass as a hint to malloc */
1504	count = 1;
1505	for (tline = line; *tline != '\0'; tline++)
1506	if (*tline == ' ')
1507	count++;
1508
1509	for (;;) {
1510	nick = strsep(&line, " ");
1511
1512	if (nick[0] == '@') {
1513	flags = IRC_NICK_FLAG_OP;
1514	nick++;
1515	} else if (nick[0] == '+') {
1516	flags = IRC_NICK_FLAG_VOICE;
1517	nick++;
1518	} else if (nick[0] == '\0') {
1519	/* some servers send a trailing space */
1520	break;
1521	} else
1522	flags = 0;
1523
1524	irc_add_nick_to_channel(channel, nick, flags, count);
1525
1526	if (line == NULL)
1527	break;
1528	}
1529	}
1530
1531	void
1532	irc_add_nick_to_channel(struct irc_channel channel, char nick,
1533	short flags, short count_hint)
1534	{
1535	struct irc_channel_nick anick, cnick, *pnick;
1536	short aidx, cidx, ret;
1537
1538	if (channel->nnicks >= channel->nicks_size) {
1539	/* allocate a chunk at a time so we don't do this every iteration */
1540	if (count_hint)
1541	channel->nicks_size += count_hint;
1542	else
1543	channel->nicks_size += 5;
1544	channel->nicks = xreallocarray(channel->nicks,
1545	sizeof(struct irc_channel_nick),
1546	channel->nicks_size);
1547	if (channel->nicks == NULL)
1548	panic("Out of memory for %d nicks (%ld bytes)",
1549	channel->nnicks,
1550	sizeof(struct irc_channel_nick) * channel->nicks_size);
1551	memset(&channel->nicks[channel->nnicks], 0,
1552	sizeof(struct irc_channel_nick) *
1553	(channel->nicks_size - channel->nnicks));
1554	aidx = channel->nnicks;
1555	} else {
1556	if (channel->nicks[channel->nnicks].nick[0] == '\0')
1557	aidx = channel->nnicks;
1558	else {
1559	/* find an open slot */
1560	for (aidx = 0; aidx < channel->nicks_size; aidx++) {
1561	if (channel->nicks[aidx].nick[0] == '\0')
1562	break;
1563	}
1564	}
1565	}
1566
1567	if (aidx >= channel->nicks_size)
1568	panic("irc_add_nick_to_channel overflow");
1569
1570	channel->nnicks++;
1571	anick = &channel->nicks[aidx];
1572	strlcpy(anick->nick, nick, sizeof(anick->nick));
1573	anick->flags = flags;
1574
1575	if (channel->nnicks == 1) {
1576	anick->next_nick = -1;
1577	channel->first_nick = 0;
1578	cidx = 0;
1579	} else {
1580	/* sort it in the right place by flags descending, then by nick */
1581	cnick = &channel->nicks[channel->first_nick];
1582	pnick = NULL;
1583	cidx = 0;
1584	while (cnick) {
1585	if (cnick->nick[0] == '\0')
1586	ret = 1;
1587	if (cnick->flags == anick->flags)
1588	ret = strcasecmp(anick->nick, cnick->nick);
1589	else if (anick->flags > cnick->flags)
1590	ret = -1;
1591	else
1592	ret = 1;
1593
1594	if (ret <= 0) {
1595	/* new nick goes before this one */
1596	if (pnick) {
1597	anick->next_nick = pnick->next_nick;
1598	pnick->next_nick = aidx;
1599	} else {
1600	anick->next_nick = channel->first_nick;
1601	channel->first_nick = aidx;
1602	}
1603	break;
1604	}
1605
1606	cidx++;
1607
1608	if (cnick->next_nick == -1) {
1609	/* end of the line */
1610	cnick->next_nick = aidx;
1611	anick->next_nick = -1;
1612	break;
1613	}
1614
1615	pnick = cnick;
1616	cnick = &channel->nicks[cnick->next_nick];
1617	}
1618	}
1619
1620	if (!channel->parsing_nicks)
1621	chatter_insert_to_nick_list(channel->chatter, channel, anick,
1622	cidx);
1623	}
1624
1625	void
1626	irc_remove_nick_from_channel(struct irc_channel channel, char nick)
1627	{
1628	struct irc_channel_nick cnick, pnick;
1629	short cidx;
1630
1631	if (channel->first_nick == -1)
1632	return;
1633
1634	pnick = NULL;
1635	cnick = &channel->nicks[channel->first_nick];
1636	cidx = 0;
1637	while (cnick) {
1638	if (strcmp(cnick->nick, nick) != 0) {
1639	pnick = cnick;
1640	cidx++;
1641	if (cnick->next_nick == -1)
1642	return;
1643	cnick = &channel->nicks[cnick->next_nick];
1644	continue;
1645	}
1646
1647	/* connect the nick that pointed to this one and the one we point to */
1648	if (pnick)
1649	pnick->next_nick = cnick->next_nick;
1650	else
1651	channel->first_nick = cnick->next_nick;
1652
1653	channel->nnicks--;
1654	cnick->nick[0] = '\0';
1655	chatter_remove_from_nick_list(channel->chatter, channel,
1656	cnick, cidx);
1657	return;
1658	}
1659	}
1660
1661	bool
1662	irc_nick_is_in_channel(struct irc_channel channel, char nick)
1663	{
1664	struct irc_channel_nick cnick, pnick;
1665
1666	if (channel->first_nick == -1)
1667	return;
1668
1669	pnick = NULL;
1670	cnick = &channel->nicks[channel->first_nick];
1671	while (cnick) {
1672	if (strcmp(cnick->nick, nick) == 0)
1673	return true;
1674
1675	pnick = cnick;
1676	if (cnick->next_nick == -1)
1677	break;
1678	cnick = &channel->nicks[cnick->next_nick];
1679	}
1680
1681	return false;
1682	}
1683
1684	void
1685	irc_change_user_nick(struct irc_connection *conn,
1686	struct irc_channel channel, struct irc_user user, char *nick)
1687	{
1688	struct irc_channel_nick *cnick;
1689	short n, flags;
1690
1691	if (channel && channel->first_nick > -1) {
1692	/* preserve flags */
1693	cnick = &channel->nicks[channel->first_nick];
1694	while (cnick) {
1695	if (strcmp(cnick->nick, user->nick) == 0) {
1696	flags = cnick->flags;
1697	break;
1698	}
1699	if (cnick->next_nick == -1)
1700	break;
1701	cnick = &channel->nicks[cnick->next_nick];
1702	}
1703
1704	irc_remove_nick_from_channel(channel, user->nick);
1705	irc_add_nick_to_channel(channel, nick, flags, 0);
1706	}
1707
1708	if (strcasecmp(conn->nick, user->nick) == 0) {
1709	xfree(&conn->nick);
1710	conn->nick_len = strlen(nick);
1711	conn->nick = xstrdup(nick);
1712	if (conn->nick == NULL)
1713	panic("Out of memory changing nick");
1714	chatter_update_titlebar(conn->chatter);
1715	}
1716	}
1717
1718	bool
1719	irc_parse_channel_mode_change(struct irc_channel channel, char mode,
1720	char *args)
1721	{
1722	size_t len;
1723	struct irc_channel_nick *cnick;
1724	char *user;
1725	short n, j, flags;
1726	bool add = false;
1727	bool others = false;
1728
1729	len = strlen(mode);
1730
1731	/* mode:"+mvo-vo" args:"nick1 nick2 nick3 nick4" */
1732	for (n = 0; n < len; n++) {
1733	switch (mode[n]) {
1734	case '+':
1735	add = true;
1736	break;
1737	case '-':
1738	add = false;
1739	break;
1740	case 'v':
1741	case 'o':
1742	user = strsep(&args, " ");
1743	if (user == NULL)
1744	user = args;
1745
1746	cnick = &channel->nicks[channel->first_nick];
1747	while (cnick) {
1748	if (strcmp(cnick->nick, user) != 0) {
1749	if (cnick->next_nick == -1)
1750	break;
1751	cnick = &channel->nicks[cnick->next_nick];
1752	continue;
1753	}
1754
1755	flags = cnick->flags;
1756	if (mode[n] == 'o') {
1757	if (add)
1758	flags \|= IRC_NICK_FLAG_OP;
1759	else
1760	flags &= ~IRC_NICK_FLAG_OP;
1761	} else if (mode[n] == 'v') {
1762	if (add)
1763	flags \|= IRC_NICK_FLAG_VOICE;
1764	else
1765	flags &= ~IRC_NICK_FLAG_VOICE;
1766	}
1767
1768	irc_remove_nick_from_channel(channel, cnick->nick);
1769	/* cnick is probably invalid now */
1770	irc_add_nick_to_channel(channel, user, flags, 0);
1771	break;
1772	}
1773
1774	break;
1775	default:
1776	/* some other channel mode */
1777	others = true;
1778	break;
1779	}
1780	}
1781
1782	return others;
1783	}
1784
1785	void
1786	irc_do_mode_to_users(struct irc_connection conn, char channel_name,
1787	char mode, char nicks)
1788	{
1789	#define MAX_MODES_AT_ONCE 4
1790	/* assume we can only do 4 at a time */
1791	char modes[(2 * MAX_MODES_AT_ONCE) + 1];
1792	char mnicks[((member_size(struct irc_user, nick) + 1) *
1793	MAX_MODES_AT_ONCE) + 1];
1794	char *nick;
1795	short count;
1796
1797	/* TODO: support +b by looking up user in nick table for hostmask */
1798
1799	modes[0] = '\0';
1800	mnicks[0] = '\0';
1801	count = 0;
1802
1803	while (nicks != NULL) {
1804	strlcat(modes, mode, sizeof(modes));
1805
1806	nick = strsep(&nicks, " ");
1807	strlcat(mnicks, nick, sizeof(mnicks));
1808	count++;
1809
1810	if (nicks != NULL && count != MAX_MODES_AT_ONCE)
1811	strlcat(mnicks, " ", sizeof(mnicks));
1812
1813	if (nicks == NULL \|\| count == 4) {
1814	irc_printf(conn, "MODE %s %s %s\r\n", channel_name, modes,
1815	mnicks);
1816	mnicks[0] = '\0';
1817	modes[0] = '\0';
1818	count = 0;
1819	}
1820	}
1821	}

AmendHub

Download

jcs

wallops

irc.c

(View History)