?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rename accountopt.[ch] to purpleaccountoption.[ch]
[pidgin-git.git] / libpurple / protocols / irc / msgs.c
blobf50509a5612ffaac62993854410f29bc0481fa4e
1 /**
2 * purple
3 *
4 * Copyright (C) 2003, 2012 Ethan Blanton <elb@pidgin.im>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
19 */
20
21 /*
22 * Note: If you change any of these functions to use additional args you
23 * MUST ensure the arg count is correct in parse.c. Otherwise it may be
24 * possible for a malicious server or man-in-the-middle to trigger a crash.
25 */
26
27 #include "internal.h"
28 #include <purple.h>
29
30 #include "irc.h"
31
32 #include <stdio.h>
33 #include <stdlib.h>
34
35 #ifdef HAVE_CYRUS_SASL
36 #include <sasl/sasl.h>
37 #endif
38
39 static char *irc_mask_nick(const char *mask);
40 static char *irc_mask_userhost(const char *mask);
41 static void irc_chat_remove_buddy(PurpleChatConversation *chat, char *data[2]);
42 static void irc_buddy_status(char *name, struct irc_buddy *ib, struct irc_conn *irc);
43 static void irc_connected(struct irc_conn *irc, const char *nick);
44
45 static void irc_msg_handle_privmsg(struct irc_conn *irc, const char *name,
46 const char *from, const char *to,
47 const char *rawmsg, gboolean notice);
48
49 #ifdef HAVE_CYRUS_SASL
50 static void irc_sasl_finish(struct irc_conn *irc);
51 #endif
52
53 static char *irc_mask_nick(const char *mask)
54 {
55 char *end, *buf;
56
57 end = strchr(mask, '!');
58 if (!end)
59 buf = g_strdup(mask);
60 else
61 buf = g_strndup(mask, end - mask);
62
63 return buf;
64 }
65
66 static char *irc_mask_userhost(const char *mask)
67 {
68 return g_strdup(strchr(mask, '!') + 1);
69 }
70
71 static void irc_chat_remove_buddy(PurpleChatConversation *chat, char *data[2])
72 {
73 char *message, *stripped;
74
75 stripped = data[1] ? irc_mirc2txt(data[1]) : NULL;
76 message = g_strdup_printf("quit: %s", stripped);
77 g_free(stripped);
78
79 if (purple_chat_conversation_has_user(chat, data[0]))
80 purple_chat_conversation_remove_user(chat, data[0], message);
81
82 g_free(message);
83 }
84
85 static void irc_connected(struct irc_conn *irc, const char *nick)
86 {
87 PurpleConnection *gc;
88 PurpleStatus *status;
89 GSList *buddies;
90 PurpleAccount *account;
91
92 if ((gc = purple_account_get_connection(irc->account)) == NULL
93 || PURPLE_CONNECTION_IS_CONNECTED(gc))
94 return;
95
96 purple_connection_set_display_name(gc, nick);
97 purple_connection_set_state(gc, PURPLE_CONNECTION_CONNECTED);
98 account = purple_connection_get_account(gc);
99
100 /* If we're away then set our away message */
101 status = purple_account_get_active_status(irc->account);
102 if (purple_status_type_get_primitive(purple_status_get_status_type(status)) != PURPLE_STATUS_AVAILABLE) {
103 PurpleProtocol *protocol = purple_connection_get_protocol(gc);
104 purple_protocol_server_iface_set_status(protocol, irc->account, status);
105 }
106
107 /* this used to be in the core, but it's not now */
108 for (buddies = purple_blist_find_buddies(account, NULL); buddies;
109 buddies = g_slist_delete_link(buddies, buddies))
110 {
111 PurpleBuddy *b = buddies->data;
112 struct irc_buddy *ib = g_new0(struct irc_buddy, 1);
113 ib->name = g_strdup(purple_buddy_get_name(b));
114 ib->ref = 1;
115 g_hash_table_replace(irc->buddies, ib->name, ib);
116 }
117
118 irc_blist_timeout(irc);
119 if (!irc->timer)
120 irc->timer = g_timeout_add_seconds(45, (GSourceFunc)irc_blist_timeout, (gpointer)irc);
121 }
122
123 /* This function is ugly, but it's really an error handler. */
124 void irc_msg_default(struct irc_conn *irc, const char *name, const char *from, char **args)
125 {
126 int i;
127 const char *end, *cur, *numeric = NULL;
128 char *clean, *tmp, *convname;
129 PurpleConversation *convo;
130
131 for (cur = args[0], i = 0; i < 4; i++) {
132 end = strchr(cur, ' ');
133 if (end == NULL) {
134 goto undirected;
135 }
136 /* Check for 3-digit numeric in second position */
137 if (i == 1) {
138 if (end - cur != 3
139 || !isdigit(cur[0]) || !isdigit(cur[1])
140 || !isdigit(cur[2])) {
141 goto undirected;
142 }
143 /* Save the numeric for printing to the channel */
144 numeric = cur;
145 }
146 /* Don't advance cur if we're on the final iteration. */
147 if (i != 3) {
148 cur = end + 1;
149 }
150 }
151
152 /* At this point, cur is the beginning of the fourth position,
153 * end is the following space, and there are remaining
154 * arguments. We'll check to see if this argument is a
155 * currently active conversation (private message or channel,
156 * either one), and print the numeric to that conversation if it
157 * is. */
158
159 tmp = g_strndup(cur, end - cur);
160 convname = purple_utf8_salvage(tmp);
161 g_free(tmp);
162
163 /* Check for an existing conversation */
164 convo = purple_conversations_find_with_account(convname, irc->account);
165 g_free(convname);
166
167 if (convo == NULL) {
168 goto undirected;
169 }
170
171 /* end + 1 is the first argument past the target. The initial
172 * arguments we've skipped are routing info, numeric, recipient
173 * (this account's nick, most likely), and target (this
174 * channel). If end + 1 is an ASCII :, skip it, because it's
175 * meaningless in this context. This won't catch all
176 * :-arguments, but it'll catch the easy case. */
177 if (*++end == ':') {
178 end++;
179 }
180
181 /* We then print "numeric: remainder". */
182 clean = purple_utf8_salvage(end);
183 tmp = g_strdup_printf("%.3s: %s", numeric, clean);
184 g_free(clean);
185 purple_conversation_write_system_message(convo, tmp,
186 PURPLE_MESSAGE_NO_LOG | PURPLE_MESSAGE_RAW |
187 PURPLE_MESSAGE_NO_LINKIFY);
188 g_free(tmp);
189 return;
190
191 undirected:
192 /* This, too, should be escaped somehow (smarter) */
193 clean = purple_utf8_salvage(args[0]);
194 purple_debug(PURPLE_DEBUG_INFO, "irc", "Unrecognized message: %s\n", clean);
195 g_free(clean);
196 }
197
198 void irc_msg_features(struct irc_conn *irc, const char *name, const char *from, char **args)
199 {
200 gchar **features;
201 int i;
202
203 features = g_strsplit(args[1], " ", -1);
204 for (i = 0; features[i]; i++) {
205 char *val;
206 if (!strncmp(features[i], "PREFIX=", 7)) {
207 if ((val = strchr(features[i] + 7, ')')) != NULL)
208 irc->mode_chars = g_strdup(val + 1);
209 }
210 }
211
212 g_strfreev(features);
213 }
214
215 void irc_msg_luser(struct irc_conn *irc, const char *name, const char *from, char **args)
216 {
217 if (purple_strequal(name, "251")) {
218 /* 251 is required, so we pluck our nick from here and
219 * finalize connection */
220 irc_connected(irc, args[0]);
221 /* Some IRC servers seem to not send a 255 numeric, so
222 * I guess we can't require it; 251 will do. */
223 /* } else if (purple_strequal(name, "255")) { */
224 }
225 }
226
227 void irc_msg_away(struct irc_conn *irc, const char *name, const char *from, char **args)
228 {
229 PurpleConnection *gc;
230 char *msg;
231
232 if (irc->whois.nick && !purple_utf8_strcasecmp(irc->whois.nick, args[1])) {
233 /* We're doing a whois, show this in the whois dialog */
234 irc_msg_whois(irc, name, from, args);
235 return;
236 }
237
238 gc = purple_account_get_connection(irc->account);
239 if (gc) {
240 msg = g_markup_escape_text(args[2], -1);
241 purple_serv_got_im(gc, args[1], msg, PURPLE_MESSAGE_AUTO_RESP, time(NULL));
242 g_free(msg);
243 }
244 }
245
246 void irc_msg_badmode(struct irc_conn *irc, const char *name, const char *from, char **args)
247 {
248 PurpleConnection *gc = purple_account_get_connection(irc->account);
249
250 g_return_if_fail(gc);
251
252 purple_notify_error(gc, NULL, _("Bad mode"), args[1],
253 purple_request_cpar_from_connection(gc));
254 }
255
256 void irc_msg_ban(struct irc_conn *irc, const char *name, const char *from, char **args)
257 {
258 PurpleChatConversation *chat;
259
260 chat = purple_conversations_find_chat_with_account(args[1], irc->account);
261
262 if (purple_strequal(name, "367")) {
263 char *msg = NULL;
264 /* Ban list entry */
265 if (args[3] && args[4]) {
266 /* This is an extended syntax, not in RFC 1459 */
267 int t1 = atoi(args[4]);
268 time_t t2 = time(NULL);
269 char *time = purple_str_seconds_to_string(t2 - t1);
270 msg = g_strdup_printf(_("Ban on %s by %s, set %s ago"),
271 args[2], args[3], time);
272 g_free(time);
273 } else {
274 msg = g_strdup_printf(_("Ban on %s"), args[2]);
275 }
276 if (chat) {
277 purple_conversation_write_system_message(
278 PURPLE_CONVERSATION(chat), msg, PURPLE_MESSAGE_NO_LOG);
279 } else {
280 purple_debug_info("irc", "%s\n", msg);
281 }
282 g_free(msg);
283 } else if (purple_strequal(name, "368")) {
284 if (!chat)
285 return;
286 /* End of ban list */
287 purple_conversation_write_system_message(PURPLE_CONVERSATION(chat),
288 _("End of ban list"), PURPLE_MESSAGE_NO_LOG);
289 }
290 }
291
292 void irc_msg_banned(struct irc_conn *irc, const char *name, const char *from, char **args)
293 {
294 PurpleConnection *gc = purple_account_get_connection(irc->account);
295 char *buf;
296
297 g_return_if_fail(gc);
298
299 buf = g_strdup_printf(_("You are banned from %s."), args[1]);
300 purple_notify_error(gc, _("Banned"), _("Banned"), buf,
301 purple_request_cpar_from_connection(gc));
302 g_free(buf);
303 }
304
305 void irc_msg_banfull(struct irc_conn *irc, const char *name, const char *from, char **args)
306 {
307 PurpleChatConversation *chat;
308 char *buf, *nick;
309
310 chat = purple_conversations_find_chat_with_account(args[1], irc->account);
311 if (!chat)
312 return;
313
314 nick = g_markup_escape_text(args[2], -1);
315 buf = g_strdup_printf(_("Cannot ban %s: banlist is full"), nick);
316 g_free(nick);
317 purple_conversation_write_system_message(PURPLE_CONVERSATION(chat),
318 buf, PURPLE_MESSAGE_NO_LOG);
319 g_free(buf);
320 }
321
322 void irc_msg_chanmode(struct irc_conn *irc, const char *name, const char *from, char **args)
323 {
324 PurpleChatConversation *chat;
325 char *buf, *escaped;
326
327 chat = purple_conversations_find_chat_with_account(args[1], irc->account);
328 if (!chat) /* XXX punt on channels we are not in for now */
329 return;
330
331 escaped = (args[3] != NULL) ? g_markup_escape_text(args[3], -1) : NULL;
332 buf = g_strdup_printf("mode for %s: %s %s", args[1], args[2], escaped ? escaped : "");
333 purple_conversation_write_system_message(PURPLE_CONVERSATION(chat), buf, 0);
334 g_free(escaped);
335 g_free(buf);
336
337 return;
338 }
339
340 void irc_msg_whois(struct irc_conn *irc, const char *name, const char *from, char **args)
341 {
342 if (!irc->whois.nick) {
343 purple_debug(PURPLE_DEBUG_WARNING, "irc", "Unexpected %s reply for %s\n", purple_strequal(name, "314") ? "WHOWAS" : "WHOIS"
344 , args[1]);
345 return;
346 }
347
348 if (purple_utf8_strcasecmp(irc->whois.nick, args[1])) {
349 purple_debug(PURPLE_DEBUG_WARNING, "irc", "Got %s reply for %s while waiting for %s\n", purple_strequal(name, "314") ? "WHOWAS" : "WHOIS"
350 , args[1], irc->whois.nick);
351 return;
352 }
353
354 if (purple_strequal(name, "301")) {
355 irc->whois.away = g_strdup(args[2]);
356 } else if (purple_strequal(name, "311") || purple_strequal(name, "314")) {
357 irc->whois.ident = g_strdup(args[2]);
358 irc->whois.host = g_strdup(args[3]);
359 irc->whois.real = g_strdup(args[5]);
360 } else if (purple_strequal(name, "312")) {
361 irc->whois.server = g_strdup(args[2]);
362 irc->whois.serverinfo = g_strdup(args[3]);
363 } else if (purple_strequal(name, "313")) {
364 irc->whois.ircop = 1;
365 } else if (purple_strequal(name, "317")) {
366 irc->whois.idle = atoi(args[2]);
367 if (args[3])
368 irc->whois.signon = (time_t)atoi(args[3]);
369 } else if (purple_strequal(name, "319")) {
370 if (irc->whois.channels == NULL) {
371 irc->whois.channels = g_string_new(args[2]);
372 } else {
373 irc->whois.channels = g_string_append(irc->whois.channels, args[2]);
374 }
375 } else if (purple_strequal(name, "320")) {
376 irc->whois.identified = 1;
377 } else if (purple_strequal(name, "330")) {
378 purple_debug(PURPLE_DEBUG_INFO, "irc", "330 %s: 1=[%s] 2=[%s] 3=[%s]",
379 name, args[1], args[2], args[3]);
380 if (purple_strequal(args[3], "is logged in as"))
381 irc->whois.login = g_strdup(args[2]);
382 }
383 }
384
385 void irc_msg_endwhois(struct irc_conn *irc, const char *name, const char *from, char **args)
386 {
387 PurpleConnection *gc;
388 char *tmp, *tmp2;
389 PurpleNotifyUserInfo *user_info;
390
391 if (!irc->whois.nick) {
392 purple_debug(PURPLE_DEBUG_WARNING, "irc", "Unexpected End of %s for %s\n", purple_strequal(name, "369") ? "WHOWAS" : "WHOIS"
393 , args[1]);
394 return;
395 }
396 if (purple_utf8_strcasecmp(irc->whois.nick, args[1])) {
397 purple_debug(PURPLE_DEBUG_WARNING, "irc", "Received end of %s for %s, expecting %s\n", purple_strequal(name, "369") ? "WHOWAS" : "WHOIS"
398 , args[1], irc->whois.nick);
399 return;
400 }
401
402 user_info = purple_notify_user_info_new();
403
404 tmp2 = g_markup_escape_text(args[1], -1);
405 tmp = g_strdup_printf("%s%s%s", tmp2,
406 (irc->whois.ircop ? _(" <i>(ircop)</i>") : ""),
407 (irc->whois.identified ? _(" <i>(identified)</i>") : ""));
408 purple_notify_user_info_add_pair_html(user_info, _("Nick"), tmp);
409 g_free(tmp2);
410 g_free(tmp);
411
412 if (irc->whois.away) {
413 purple_notify_user_info_add_pair_plaintext(user_info, _("Away"), irc->whois.away);
414 g_free(irc->whois.away);
415 }
416 if (irc->whois.real) {
417 purple_notify_user_info_add_pair_plaintext(user_info, _("Real name"), irc->whois.real);
418 g_free(irc->whois.real);
419 }
420 if (irc->whois.login) {
421 purple_notify_user_info_add_pair_plaintext(user_info, _("Login name"), irc->whois.login);
422 g_free(irc->whois.login);
423 }
424 if (irc->whois.ident) {
425 purple_notify_user_info_add_pair_plaintext(user_info, _("Ident name"), irc->whois.ident);
426 g_free(irc->whois.ident);
427 }
428 if (irc->whois.host) {
429 purple_notify_user_info_add_pair_plaintext(user_info, _("Host name"), irc->whois.host);
430 g_free(irc->whois.host);
431 }
432 if (irc->whois.server) {
433 tmp = g_strdup_printf("%s (%s)", irc->whois.server, irc->whois.serverinfo);
434 purple_notify_user_info_add_pair_plaintext(user_info, _("Server"), tmp);
435 g_free(tmp);
436 g_free(irc->whois.server);
437 g_free(irc->whois.serverinfo);
438 }
439 if (irc->whois.channels) {
440 purple_notify_user_info_add_pair_plaintext(user_info, _("Currently on"), irc->whois.channels->str);
441 g_string_free(irc->whois.channels, TRUE);
442 }
443 if (irc->whois.idle) {
444 gchar *timex = purple_str_seconds_to_string(irc->whois.idle);
445 purple_notify_user_info_add_pair_plaintext(user_info, _("Idle for"), timex);
446 g_free(timex);
447 purple_notify_user_info_add_pair_plaintext(user_info,
448 _("Online since"), purple_date_format_full(localtime(&irc->whois.signon)));
449 }
450 if (purple_strequal(irc->whois.nick, "elb")) {
451 purple_notify_user_info_add_pair_plaintext(user_info,
452 _("<b>Defining adjective:</b>"), _("Glorious"));
453 }
454
455 gc = purple_account_get_connection(irc->account);
456
457 purple_notify_userinfo(gc, irc->whois.nick, user_info, NULL, NULL);
458 purple_notify_user_info_destroy(user_info);
459
460 g_free(irc->whois.nick);
461 memset(&irc->whois, 0, sizeof(irc->whois));
462 }
463
464 void irc_msg_who(struct irc_conn *irc, const char *name, const char *from, char **args)
465 {
466 if (purple_strequal(name, "352")) {
467 PurpleChatConversation *chat;
468 PurpleChatUser *cb;
469
470 char *cur, *userhost, *realname;
471
472 PurpleChatUserFlags flags;
473
474 chat = purple_conversations_find_chat_with_account(args[1], irc->account);
475 if (!chat) {
476 purple_debug(PURPLE_DEBUG_ERROR, "irc","Got a WHO response for %s, which doesn't exist\n", args[1]);
477 return;
478 }
479
480 cb = purple_chat_conversation_find_user(chat, args[5]);
481 if (!cb) {
482 purple_debug(PURPLE_DEBUG_ERROR, "irc", "Got a WHO response for %s who isn't a buddy.\n", args[5]);
483 return;
484 }
485
486 userhost = g_strdup_printf("%s@%s", args[2], args[3]);
487
488 /* The final argument is a :-argument, but annoyingly
489 * contains two "words", the hop count and real name. */
490 for (cur = args[7]; *cur; cur++) {
491 if (*cur == ' ') {
492 cur++;
493 break;
494 }
495 }
496 realname = g_strdup(cur);
497
498 g_object_set_data_full(G_OBJECT(cb), "userhost", userhost, (GDestroyNotify)g_free);
499 g_object_set_data_full(G_OBJECT(cb), "realname", realname, (GDestroyNotify)g_free);
500
501 flags = purple_chat_user_get_flags(cb);
502
503 /* FIXME: I'm not sure this is really a good idea, now
504 * that we no longer do periodic WHO. It seems to me
505 * like it's more likely to be confusing than not.
506 * Comments? */
507 if (args[6][0] == 'G' && !(flags & PURPLE_CHAT_USER_AWAY)) {
508 purple_chat_user_set_flags(cb, flags | PURPLE_CHAT_USER_AWAY);
509 } else if(args[6][0] == 'H' && (flags & PURPLE_CHAT_USER_AWAY)) {
510 purple_chat_user_set_flags(cb, flags & ~PURPLE_CHAT_USER_AWAY);
511 }
512 }
513 }
514
515 void irc_msg_list(struct irc_conn *irc, const char *name, const char *from, char **args)
516 {
517 if (!irc->roomlist)
518 return;
519
520 if (purple_strequal(name, "321")) {
521 purple_roomlist_set_in_progress(irc->roomlist, TRUE);
522 return;
523 }
524
525 if (purple_strequal(name, "323")) {
526 purple_roomlist_set_in_progress(irc->roomlist, FALSE);
527 g_object_unref(irc->roomlist);
528 irc->roomlist = NULL;
529 return;
530 }
531
532 if (purple_strequal(name, "322")) {
533 PurpleRoomlistRoom *room;
534 char *topic;
535
536 if (!purple_roomlist_get_in_progress(irc->roomlist)) {
537 purple_debug_warning("irc", "Buggy server didn't send RPL_LISTSTART.\n");
538 purple_roomlist_set_in_progress(irc->roomlist, TRUE);
539 }
540
541 room = purple_roomlist_room_new(PURPLE_ROOMLIST_ROOMTYPE_ROOM, args[1], NULL);
542 purple_roomlist_room_add_field(irc->roomlist, room, args[1]);
543 purple_roomlist_room_add_field(irc->roomlist, room, GINT_TO_POINTER(strtol(args[2], NULL, 10)));
544 topic = irc_mirc2txt(args[3]);
545 purple_roomlist_room_add_field(irc->roomlist, room, topic);
546 g_free(topic);
547 purple_roomlist_room_add(irc->roomlist, room);
548 }
549 }
550
551 void irc_msg_topic(struct irc_conn *irc, const char *name, const char *from, char **args)
552 {
553 char *chan, *topic, *msg, *nick, *tmp, *tmp2;
554 PurpleChatConversation *chat;
555
556 if (purple_strequal(name, "topic")) {
557 chan = args[0];
558 topic = irc_mirc2txt (args[1]);
559 } else {
560 chan = args[1];
561 topic = irc_mirc2txt (args[2]);
562 }
563
564 chat = purple_conversations_find_chat_with_account(chan, irc->account);
565 if (!chat) {
566 purple_debug(PURPLE_DEBUG_ERROR, "irc", "Got a topic for %s, which doesn't exist\n", chan);
567 g_free(topic);
568 return;
569 }
570
571 /* If this is an interactive update, print it out */
572 tmp = g_markup_escape_text(topic, -1);
573 tmp2 = purple_markup_linkify(tmp);
574 g_free(tmp);
575 if (purple_strequal(name, "topic")) {
576 const char *current_topic = purple_chat_conversation_get_topic(chat);
577 if (!(current_topic != NULL && purple_strequal(tmp2, current_topic)))
578 {
579 char *nick_esc;
580 nick = irc_mask_nick(from);
581 nick_esc = g_markup_escape_text(nick, -1);
582 purple_chat_conversation_set_topic(chat, nick, topic);
583 if (*tmp2)
584 msg = g_strdup_printf(_("%s has changed the topic to: %s"), nick_esc, tmp2);
585 else
586 msg = g_strdup_printf(_("%s has cleared the topic."), nick_esc);
587 g_free(nick_esc);
588 g_free(nick);
589 purple_conversation_write_system_message(
590 PURPLE_CONVERSATION(chat), msg, 0);
591 g_free(msg);
592 }
593 } else {
594 char *chan_esc = g_markup_escape_text(chan, -1);
595 msg = g_strdup_printf(_("The topic for %s is: %s"), chan_esc, tmp2);
596 g_free(chan_esc);
597 purple_chat_conversation_set_topic(chat, NULL, topic);
598 purple_conversation_write_system_message(PURPLE_CONVERSATION(chat), msg, 0);
599 g_free(msg);
600 }
601 g_free(tmp2);
602 g_free(topic);
603 }
604
605 void irc_msg_topicinfo(struct irc_conn *irc, const char *name, const char *from, char **args)
606 {
607 PurpleChatConversation *chat;
608 struct tm *tm;
609 time_t t;
610 char *msg, *timestamp, *datestamp;
611
612 chat = purple_conversations_find_chat_with_account(args[1], irc->account);
613 if (!chat) {
614 purple_debug(PURPLE_DEBUG_ERROR, "irc", "Got topic info for %s, which doesn't exist\n", args[1]);
615 return;
616 }
617
618 t = (time_t)atol(args[3]);
619 if (t == 0) {
620 purple_debug(PURPLE_DEBUG_ERROR, "irc", "Got apparently nonsensical topic timestamp %s\n", args[3]);
621 return;
622 }
623 tm = localtime(&t);
624
625 timestamp = g_strdup(purple_time_format(tm));
626 datestamp = g_strdup(purple_date_format_short(tm));
627 msg = g_strdup_printf(_("Topic for %s set by %s at %s on %s"), args[1], args[2], timestamp, datestamp);
628 purple_conversation_write_system_message(PURPLE_CONVERSATION(chat),
629 msg, PURPLE_MESSAGE_NO_LINKIFY);
630 g_free(timestamp);
631 g_free(datestamp);
632 g_free(msg);
633 }
634
635 void irc_msg_unknown(struct irc_conn *irc, const char *name, const char *from, char **args)
636 {
637 PurpleConnection *gc = purple_account_get_connection(irc->account);
638 char *buf;
639
640 g_return_if_fail(gc);
641
642 buf = g_strdup_printf(_("Unknown message '%s'"), args[1]);
643 purple_notify_error(gc, _("Unknown message"), buf, _("The IRC server "
644 "received a message it did not understand."),
645 purple_request_cpar_from_connection(gc));
646 g_free(buf);
647 }
648
649 void irc_msg_names(struct irc_conn *irc, const char *name, const char *from, char **args)
650 {
651 char *names, *cur, *end, *tmp, *msg;
652 PurpleConversation *convo;
653
654 if (purple_strequal(name, "366")) {
655 convo = purple_conversations_find_with_account(args[1], irc->account);
656 if (!convo) {
657 purple_debug(PURPLE_DEBUG_ERROR, "irc", "Got a NAMES list for %s, which doesn't exist\n", args[1]);
658 g_string_free(irc->names, TRUE);
659 irc->names = NULL;
660 return;
661 }
662
663 names = cur = g_string_free(irc->names, FALSE);
664 irc->names = NULL;
665 if (g_object_get_data(G_OBJECT(convo), IRC_NAMES_FLAG)) {
666 msg = g_strdup_printf(_("Users on %s: %s"), args[1], names ? names : "");
667 purple_conversation_write_system_message(convo, msg, PURPLE_MESSAGE_NO_LOG);
668 g_free(msg);
669 } else if (cur != NULL) {
670 GList *users = NULL;
671 GList *flags = NULL;
672
673 while (*cur) {
674 PurpleChatUserFlags f = PURPLE_CHAT_USER_NONE;
675 end = strchr(cur, ' ');
676 if (!end)
677 end = cur + strlen(cur);
678 if (*cur == '@') {
679 f = PURPLE_CHAT_USER_OP;
680 cur++;
681 } else if (*cur == '%') {
682 f = PURPLE_CHAT_USER_HALFOP;
683 cur++;
684 } else if(*cur == '+') {
685 f = PURPLE_CHAT_USER_VOICE;
686 cur++;
687 } else if(irc->mode_chars
688 && strchr(irc->mode_chars, *cur)) {
689 if (*cur == '~')
690 f = PURPLE_CHAT_USER_FOUNDER;
691 cur++;
692 }
693 tmp = g_strndup(cur, end - cur);
694 users = g_list_prepend(users, tmp);
695 flags = g_list_prepend(flags, GINT_TO_POINTER(f));
696 cur = end;
697 if (*cur)
698 cur++;
699 }
700
701 if (users != NULL) {
702 GList *l;
703
704 purple_chat_conversation_add_users(PURPLE_CHAT_CONVERSATION(convo), users, NULL, flags, FALSE);
705
706 for (l = users; l != NULL; l = l->next)
707 g_free(l->data);
708
709 g_list_free(users);
710 g_list_free(flags);
711 }
712
713 g_object_set_data(G_OBJECT(convo), IRC_NAMES_FLAG,
714 GINT_TO_POINTER(TRUE));
715 }
716 g_free(names);
717 } else {
718 if (!irc->names)
719 irc->names = g_string_new("");
720
721 if (irc->names->len && irc->names->str[irc->names->len - 1] != ' ')
722 irc->names = g_string_append_c(irc->names, ' ');
723 irc->names = g_string_append(irc->names, args[3]);
724 }
725 }
726
727 void irc_msg_motd(struct irc_conn *irc, const char *name, const char *from, char **args)
728 {
729 char *escaped;
730
731 if (purple_strequal(name, "375")) {
732 if (irc->motd) {
733 g_string_free(irc->motd, TRUE);
734 irc->motd = NULL;
735 }
736 irc->motd = g_string_new("");
737 return;
738 } else if (purple_strequal(name, "376")) {
739 /* dircproxy 1.0.5 does not send 251 on reconnection, so
740 * finalize the connection here if it is not already done. */
741 irc_connected(irc, args[0]);
742 return;
743 } else if (purple_strequal(name, "422")) {
744 /* in case there is no 251, and no MOTD set, finalize the connection.
745 * (and clear the motd for good measure). */
746
747 if (irc->motd) {
748 g_string_free(irc->motd, TRUE);
749 irc->motd = NULL;
750 }
751
752 irc_connected(irc, args[0]);
753 return;
754 }
755
756 if (!irc->motd) {
757 purple_debug_error("irc", "IRC server sent MOTD without STARTMOTD\n");
758 return;
759 }
760
761 if (!args[1])
762 return;
763
764 escaped = g_markup_escape_text(args[1], -1);
765 g_string_append_printf(irc->motd, "%s<br>", escaped);
766 g_free(escaped);
767 }
768
769 void irc_msg_time(struct irc_conn *irc, const char *name, const char *from, char **args)
770 {
771 PurpleConnection *gc;
772
773 gc = purple_account_get_connection(irc->account);
774
775 g_return_if_fail(gc);
776
777 purple_notify_message(gc, PURPLE_NOTIFY_MSG_INFO, _("Time Response"),
778 _("The IRC server's local time is:"), args[2], NULL, NULL,
779 purple_request_cpar_from_connection(gc));
780 }
781
782 void irc_msg_nochan(struct irc_conn *irc, const char *name, const char *from, char **args)
783 {
784 PurpleConnection *gc = purple_account_get_connection(irc->account);
785
786 g_return_if_fail(gc);
787
788 purple_notify_error(gc, NULL, _("No such channel"), args[1],
789 purple_request_cpar_from_connection(gc));
790 }
791
792 void irc_msg_nonick(struct irc_conn *irc, const char *name, const char *from, char **args)
793 {
794 PurpleConnection *gc;
795 PurpleConversation *convo;
796
797 convo = purple_conversations_find_with_account(args[1], irc->account);
798 if (convo) {
799 purple_conversation_write_system_message(convo,
800 PURPLE_IS_IM_CONVERSATION(convo) ? _("User is not logged in") : _("no such channel"),
801 PURPLE_MESSAGE_NO_LOG);
802
803 } else {
804 if ((gc = purple_account_get_connection(irc->account)) == NULL)
805 return;
806 purple_notify_error(gc, NULL, _("No such nick or channel"),
807 args[1], purple_request_cpar_from_connection(gc));
808 }
809
810 if (irc->whois.nick && !purple_utf8_strcasecmp(irc->whois.nick, args[1])) {
811 g_free(irc->whois.nick);
812 irc->whois.nick = NULL;
813 }
814 }
815
816 void irc_msg_nosend(struct irc_conn *irc, const char *name, const char *from, char **args)
817 {
818 PurpleConnection *gc;
819 PurpleChatConversation *chat;
820
821 chat = purple_conversations_find_chat_with_account(args[1], irc->account);
822 if (chat) {
823 purple_conversation_write_system_message(PURPLE_CONVERSATION(chat), args[2],
824 PURPLE_MESSAGE_NO_LOG);
825 } else {
826 if ((gc = purple_account_get_connection(irc->account)) == NULL)
827 return;
828 purple_notify_error(gc, NULL, _("Could not send"), args[2],
829 purple_request_cpar_from_connection(gc));
830 }
831 }
832
833 void irc_msg_notinchan(struct irc_conn *irc, const char *name, const char *from, char **args)
834 {
835 PurpleChatConversation *chat = purple_conversations_find_chat_with_account(args[1], irc->account);
836
837 purple_debug(PURPLE_DEBUG_INFO, "irc", "We're apparently not in %s, but tried to use it\n", args[1]);
838 if (chat) {
839 /*g_slist_remove(irc->gc->buddy_chats, chat);
840 purple_conversation_set_account(chat, NULL);*/
841 purple_conversation_write_system_message(PURPLE_CONVERSATION(chat),
842 args[2], PURPLE_MESSAGE_NO_LOG);
843 }
844 }
845
846 void irc_msg_notop(struct irc_conn *irc, const char *name, const char *from, char **args)
847 {
848 PurpleChatConversation *chat;
849
850 chat = purple_conversations_find_chat_with_account(args[1], irc->account);
851 if (!chat)
852 return;
853
854 purple_conversation_write_system_message(PURPLE_CONVERSATION(chat), args[2], 0);
855 }
856
857 void irc_msg_invite(struct irc_conn *irc, const char *name, const char *from, char **args)
858 {
859 PurpleConnection *gc = purple_account_get_connection(irc->account);
860 GHashTable *components;
861 gchar *nick;
862
863 g_return_if_fail(gc);
864
865 components = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
866 nick = irc_mask_nick(from);
867
868 g_hash_table_insert(components, g_strdup("channel"), g_strdup(args[1]));
869
870 purple_serv_got_chat_invite(gc, args[1], nick, NULL, components);
871 g_free(nick);
872 }
873
874 void irc_msg_inviteonly(struct irc_conn *irc, const char *name, const char *from, char **args)
875 {
876 PurpleConnection *gc = purple_account_get_connection(irc->account);
877 char *buf;
878
879 g_return_if_fail(gc);
880
881 buf = g_strdup_printf(_("Joining %s requires an invitation."), args[1]);
882 purple_notify_error(gc, _("Invitation only"), _("Invitation only"), buf,
883 purple_request_cpar_from_connection(gc));
884 g_free(buf);
885 }
886
887 void irc_msg_ison(struct irc_conn *irc, const char *name, const char *from, char **args)
888 {
889 char **nicks;
890 struct irc_buddy *ib;
891 int i;
892
893 nicks = g_strsplit(args[1], " ", -1);
894 for (i = 0; nicks[i]; i++) {
895 if ((ib = g_hash_table_lookup(irc->buddies, (gconstpointer)nicks[i])) == NULL) {
896 continue;
897 }
898 ib->new_online_status = TRUE;
899 }
900 g_strfreev(nicks);
901
902 if (irc->ison_outstanding)
903 irc_buddy_query(irc);
904
905 if (!irc->ison_outstanding)
906 g_hash_table_foreach(irc->buddies, (GHFunc)irc_buddy_status, (gpointer)irc);
907 }
908
909 static void irc_buddy_status(char *name, struct irc_buddy *ib, struct irc_conn *irc)
910 {
911 PurpleConnection *gc = purple_account_get_connection(irc->account);
912 PurpleBuddy *buddy = purple_blist_find_buddy(irc->account, name);
913
914 if (!gc || !buddy)
915 return;
916
917 if (ib->online && !ib->new_online_status) {
918 purple_protocol_got_user_status(irc->account, name, "offline", NULL);
919 ib->online = FALSE;
920 } else if (!ib->online && ib->new_online_status) {
921 purple_protocol_got_user_status(irc->account, name, "available", NULL);
922 ib->online = TRUE;
923 }
924 }
925
926 void irc_msg_join(struct irc_conn *irc, const char *name, const char *from, char **args)
927 {
928 PurpleConnection *gc = purple_account_get_connection(irc->account);
929 PurpleChatConversation *chat;
930 PurpleChatUser *cb;
931
932 char *nick, *userhost, *buf;
933 struct irc_buddy *ib;
934 static int id = 1;
935
936 g_return_if_fail(gc);
937
938 nick = irc_mask_nick(from);
939
940 if (!purple_utf8_strcasecmp(nick, purple_connection_get_display_name(gc))) {
941 /* We are joining a channel for the first time */
942 purple_serv_got_joined_chat(gc, id++, args[0]);
943 g_free(nick);
944 chat = purple_conversations_find_chat_with_account(args[0], irc->account);
945
946 if (chat == NULL) {
947 purple_debug_error("irc", "tried to join %s but couldn't\n", args[0]);
948 return;
949 }
950 g_object_set_data(G_OBJECT(chat), IRC_NAMES_FLAG,
951 GINT_TO_POINTER(FALSE));
952
953 // Get the real name and user host for all participants.
954 buf = irc_format(irc, "vc", "WHO", args[0]);
955 irc_send(irc, buf);
956 g_free(buf);
957
958 /* Until purple_conversation_present does something that
959 * one would expect in Pidgin, this call produces buggy
960 * behavior both for the /join and auto-join cases. */
961 /* purple_conversation_present(chat); */
962 return;
963 }
964
965 chat = purple_conversations_find_chat_with_account(args[0], irc->account);
966 if (chat == NULL) {
967 purple_debug(PURPLE_DEBUG_ERROR, "irc", "JOIN for %s failed\n", args[0]);
968 g_free(nick);
969 return;
970 }
971
972 userhost = irc_mask_userhost(from);
973
974 purple_chat_conversation_add_user(chat, nick, userhost, PURPLE_CHAT_USER_NONE, TRUE);
975
976 cb = purple_chat_conversation_find_user(chat, nick);
977
978 if (cb) {
979 g_object_set_data_full(G_OBJECT(cb), "userhost", userhost, (GDestroyNotify)g_free);
980 }
981
982 if ((ib = g_hash_table_lookup(irc->buddies, nick)) != NULL) {
983 ib->new_online_status = TRUE;
984 irc_buddy_status(nick, ib, irc);
985 }
986
987 g_free(nick);
988 }
989
990 void irc_msg_kick(struct irc_conn *irc, const char *name, const char *from, char **args)
991 {
992 PurpleConnection *gc = purple_account_get_connection(irc->account);
993 PurpleChatConversation *chat = purple_conversations_find_chat_with_account(args[0], irc->account);
994 char *nick, *buf;
995
996 g_return_if_fail(gc);
997
998 nick = irc_mask_nick(from);
999
1000 if (!chat) {
1001 purple_debug(PURPLE_DEBUG_ERROR, "irc", "Received a KICK for unknown channel %s\n", args[0]);
1002 g_free(nick);
1003 return;
1004 }
1005
1006 if (!purple_utf8_strcasecmp(purple_connection_get_display_name(gc), args[1])) {
1007 buf = g_strdup_printf(_("You have been kicked by %s: (%s)"), nick, args[2]);
1008 purple_conversation_write_system_message(PURPLE_CONVERSATION(chat), buf, 0);
1009 g_free(buf);
1010 purple_serv_got_chat_left(gc, purple_chat_conversation_get_id(chat));
1011 } else {
1012 buf = g_strdup_printf(_("Kicked by %s (%s)"), nick, args[2]);
1013 purple_chat_conversation_remove_user(chat, args[1], buf);
1014 g_free(buf);
1015 }
1016
1017 g_free(nick);
1018 return;
1019 }
1020
1021 void irc_msg_mode(struct irc_conn *irc, const char *name, const char *from, char **args)
1022 {
1023 PurpleChatConversation *chat;
1024 char *nick = irc_mask_nick(from), *buf;
1025
1026 if (*args[0] == '#' || *args[0] == '&') { /* Channel */
1027 char *escaped;
1028 chat = purple_conversations_find_chat_with_account(args[0], irc->account);
1029 if (!chat) {
1030 purple_debug(PURPLE_DEBUG_ERROR, "irc", "MODE received for %s, which we are not in\n", args[0]);
1031 g_free(nick);
1032 return;
1033 }
1034 escaped = (args[2] != NULL) ? g_markup_escape_text(args[2], -1) : NULL;
1035 buf = g_strdup_printf(_("mode (%s %s) by %s"), args[1], escaped ? escaped : "", nick);
1036 purple_conversation_write_system_message(PURPLE_CONVERSATION(chat), buf, 0);
1037 g_free(escaped);
1038 g_free(buf);
1039 if(args[2]) {
1040 PurpleChatUser *cb;
1041 PurpleChatUserFlags newflag, flags;
1042 char *mcur, *cur, *end, *user;
1043 gboolean add = FALSE;
1044 mcur = args[1];
1045 cur = args[2];
1046 while (*cur && *mcur) {
1047 if ((*mcur == '+') || (*mcur == '-')) {
1048 add = (*mcur == '+') ? TRUE : FALSE;
1049 mcur++;
1050 continue;
1051 }
1052 end = strchr(cur, ' ');
1053 if (!end)
1054 end = cur + strlen(cur);
1055 user = g_strndup(cur, end - cur);
1056 cb = purple_chat_conversation_find_user(chat, user);
1057 flags = purple_chat_user_get_flags(cb);
1058 newflag = PURPLE_CHAT_USER_NONE;
1059 if (*mcur == 'o')
1060 newflag = PURPLE_CHAT_USER_OP;
1061 else if (*mcur =='h')
1062 newflag = PURPLE_CHAT_USER_HALFOP;
1063 else if (*mcur == 'v')
1064 newflag = PURPLE_CHAT_USER_VOICE;
1065 else if(irc->mode_chars
1066 && strchr(irc->mode_chars, '~') && (*mcur == 'q'))
1067 newflag = PURPLE_CHAT_USER_FOUNDER;
1068 if (newflag) {
1069 if (add)
1070 flags |= newflag;
1071 else
1072 flags &= ~newflag;
1073 purple_chat_user_set_flags(cb, flags);
1074 }
1075 g_free(user);
1076 cur = end;
1077 if (*cur)
1078 cur++;
1079 if (*mcur)
1080 mcur++;
1081 }
1082 }
1083 } else { /* User */
1084 }
1085 g_free(nick);
1086 }
1087
1088 void irc_msg_nick(struct irc_conn *irc, const char *name, const char *from, char **args)
1089 {
1090 PurpleConnection *gc = purple_account_get_connection(irc->account);
1091 PurpleIMConversation *im;
1092 GSList *chats;
1093 char *nick = irc_mask_nick(from);
1094
1095 irc->nickused = FALSE;
1096
1097 if (!gc) {
1098 g_free(nick);
1099 return;
1100 }
1101 chats = purple_connection_get_active_chats(gc);
1102
1103 if (!purple_utf8_strcasecmp(nick, purple_connection_get_display_name(gc))) {
1104 purple_connection_set_display_name(gc, args[0]);
1105 }
1106
1107 while (chats) {
1108 PurpleChatConversation *chat = PURPLE_CHAT_CONVERSATION(chats->data);
1109 /* This is ugly ... */
1110 if (purple_chat_conversation_has_user(chat, nick))
1111 purple_chat_conversation_rename_user(chat, nick, args[0]);
1112 chats = chats->next;
1113 }
1114
1115 im = purple_conversations_find_im_with_account(nick,
1116 irc->account);
1117 if (im != NULL)
1118 purple_conversation_set_name(PURPLE_CONVERSATION(im), args[0]);
1119
1120 g_free(nick);
1121 }
1122
1123 void irc_msg_badnick(struct irc_conn *irc, const char *name, const char *from, char **args)
1124 {
1125 PurpleConnection *gc = purple_account_get_connection(irc->account);
1126 if (purple_connection_get_state(gc) == PURPLE_CONNECTION_CONNECTED) {
1127 purple_notify_error(gc, _("Invalid nickname"), _("Invalid "
1128 "nickname"), _("Your selected nickname was rejected by "
1129 "the server. It probably contains invalid characters."),
1130 purple_request_cpar_from_connection(gc));
1131
1132 } else {
1133 purple_connection_take_error(gc, g_error_new_literal(
1134 PURPLE_CONNECTION_ERROR,
1135 PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
1136 _("Your selected account name was rejected by the server. It probably contains invalid characters.")));
1137 }
1138 }
1139
1140 void irc_msg_nickused(struct irc_conn *irc, const char *name, const char *from, char **args)
1141 {
1142 char *newnick, *buf, *end;
1143 PurpleConnection *gc = purple_account_get_connection(irc->account);
1144
1145 if (gc && purple_connection_get_state(gc) == PURPLE_CONNECTION_CONNECTED) {
1146 /* We only want to do the following dance if the connection
1147 has not been successfully completed. If it has, just
1148 notify the user that their /nick command didn't go. */
1149 buf = g_strdup_printf(_("The nickname \"%s\" is already being used."),
1150 irc->reqnick);
1151 purple_notify_error(gc, _("Nickname in use"), _("Nickname in "
1152 "use"), buf, purple_request_cpar_from_connection(gc));
1153 g_free(buf);
1154 g_free(irc->reqnick);
1155 irc->reqnick = NULL;
1156 return;
1157 }
1158
1159 if (strlen(args[1]) < strlen(irc->reqnick) || irc->nickused)
1160 newnick = g_strdup(args[1]);
1161 else
1162 newnick = g_strdup_printf("%s0", args[1]);
1163 end = newnick + strlen(newnick) - 1;
1164 /* try fallbacks */
1165 if((*end < '9') && (*end >= '1')) {
1166 *end = *end + 1;
1167 } else *end = '1';
1168
1169 g_free(irc->reqnick);
1170 irc->reqnick = newnick;
1171 irc->nickused = TRUE;
1172
1173 purple_connection_set_display_name(
1174 purple_account_get_connection(irc->account), newnick);
1175
1176 buf = irc_format(irc, "vn", "NICK", newnick);
1177 irc_send(irc, buf);
1178 g_free(buf);
1179 }
1180
1181 void irc_msg_notice(struct irc_conn *irc, const char *name, const char *from, char **args)
1182 {
1183 irc_msg_handle_privmsg(irc, name, from, args[0], args[1], TRUE);
1184 }
1185
1186 void irc_msg_nochangenick(struct irc_conn *irc, const char *name, const char *from, char **args)
1187 {
1188 PurpleConnection *gc = purple_account_get_connection(irc->account);
1189
1190 g_return_if_fail(gc);
1191
1192 purple_notify_error(gc, _("Cannot change nick"),
1193 _("Could not change nick"), args[2],
1194 purple_request_cpar_from_connection(gc));
1195 }
1196
1197 void irc_msg_part(struct irc_conn *irc, const char *name, const char *from, char **args)
1198 {
1199 PurpleConnection *gc = purple_account_get_connection(irc->account);
1200 PurpleChatConversation *chat;
1201 char *nick, *msg, *channel;
1202
1203 g_return_if_fail(gc);
1204
1205 /* Undernet likes to :-quote the channel name, for no good reason
1206 * that I can see. This catches that. */
1207 channel = (args[0][0] == ':') ? &args[0][1] : args[0];
1208
1209 chat = purple_conversations_find_chat_with_account(channel, irc->account);
1210 if (!chat) {
1211 purple_debug(PURPLE_DEBUG_INFO, "irc", "Got a PART on %s, which doesn't exist -- probably closed\n", channel);
1212 return;
1213 }
1214
1215 nick = irc_mask_nick(from);
1216 if (!purple_utf8_strcasecmp(nick, purple_connection_get_display_name(gc))) {
1217 char *escaped = args[1] ? g_markup_escape_text(args[1], -1) : NULL;
1218 msg = g_strdup_printf(_("You have parted the channel%s%s"),
1219 (args[1] && *args[1]) ? ": " : "",
1220 (escaped && *escaped) ? escaped : "");
1221 g_free(escaped);
1222 purple_conversation_write_system_message(PURPLE_CONVERSATION(chat), msg, 0);
1223 g_free(msg);
1224 purple_serv_got_chat_left(gc, purple_chat_conversation_get_id(chat));
1225 } else {
1226 msg = args[1] ? irc_mirc2txt(args[1]) : NULL;
1227 purple_chat_conversation_remove_user(chat, nick, msg);
1228 g_free(msg);
1229 }
1230 g_free(nick);
1231 }
1232
1233 void irc_msg_ping(struct irc_conn *irc, const char *name, const char *from, char **args)
1234 {
1235 char *buf;
1236
1237 buf = irc_format(irc, "v:", "PONG", args[0]);
1238 irc_send(irc, buf);
1239 g_free(buf);
1240 }
1241
1242 void irc_msg_pong(struct irc_conn *irc, const char *name, const char *from, char **args)
1243 {
1244 PurpleConversation *convo;
1245 PurpleConnection *gc;
1246 char **parts, *msg;
1247 time_t oldstamp;
1248
1249 parts = g_strsplit(args[1], " ", 2);
1250
1251 if (!parts[0] || !parts[1]) {
1252 g_strfreev(parts);
1253 return;
1254 }
1255
1256 if (sscanf(parts[1], "%lu", &oldstamp) != 1) {
1257 msg = g_strdup(_("Error: invalid PONG from server"));
1258 } else {
1259 msg = g_strdup_printf(_("PING reply -- Lag: %lu seconds"), time(NULL) - oldstamp);
1260 }
1261
1262 convo = purple_conversations_find_with_account(parts[0], irc->account);
1263 g_strfreev(parts);
1264 if (convo) {
1265 purple_conversation_write_system_message(convo, msg, PURPLE_MESSAGE_NO_LOG);
1266 } else {
1267 gc = purple_account_get_connection(irc->account);
1268 if (!gc) {
1269 g_free(msg);
1270 return;
1271 }
1272 purple_notify_info(gc, NULL, "PONG", msg,
1273 purple_request_cpar_from_connection(gc));
1274 }
1275 g_free(msg);
1276 }
1277
1278 void irc_msg_privmsg(struct irc_conn *irc, const char *name, const char *from, char **args)
1279 {
1280 irc_msg_handle_privmsg(irc, name, from, args[0], args[1], FALSE);
1281 }
1282
1283 static void irc_msg_handle_privmsg(struct irc_conn *irc, const char *name, const char *from, const char *to, const char *rawmsg, gboolean notice)
1284 {
1285 PurpleConnection *gc = purple_account_get_connection(irc->account);
1286 PurpleChatConversation *chat;
1287 char *tmp;
1288 char *msg;
1289 char *nick;
1290
1291 if (!gc)
1292 return;
1293
1294 nick = irc_mask_nick(from);
1295 tmp = irc_parse_ctcp(irc, nick, to, rawmsg, notice);
1296 if (!tmp) {
1297 g_free(nick);
1298 return;
1299 }
1300
1301 msg = irc_escape_privmsg(tmp, -1);
1302 g_free(tmp);
1303
1304 tmp = irc_mirc2html(msg);
1305 g_free(msg);
1306 msg = tmp;
1307 if (notice) {
1308 tmp = g_strdup_printf("(notice) %s", msg);
1309 g_free(msg);
1310 msg = tmp;
1311 }
1312
1313 if (!purple_utf8_strcasecmp(to, purple_connection_get_display_name(gc))) {
1314 purple_serv_got_im(gc, nick, msg, 0, time(NULL));
1315 } else {
1316 chat = purple_conversations_find_chat_with_account(irc_nick_skip_mode(irc, to), irc->account);
1317 if (chat) {
1318 purple_serv_got_chat_in(gc, purple_chat_conversation_get_id(chat),
1319 nick, PURPLE_MESSAGE_RECV, msg, time(NULL));
1320 } else
1321 purple_debug_error("irc", "Got a %s on %s, which does not exist\n",
1322 notice ? "NOTICE" : "PRIVMSG", to);
1323 }
1324 g_free(msg);
1325 g_free(nick);
1326 }
1327
1328 void irc_msg_regonly(struct irc_conn *irc, const char *name, const char *from, char **args)
1329 {
1330 PurpleConnection *gc = purple_account_get_connection(irc->account);
1331 char *msg;
1332
1333 g_return_if_fail(gc);
1334
1335 if (purple_conversations_find_chat_with_account(args[1], irc->account)) {
1336 /* This is a channel we're already in; for some reason,
1337 * freenode feels the need to notify us that in some
1338 * hypothetical other situation this might not have
1339 * succeeded. Suppress that. */
1340 return;
1341 }
1342
1343 msg = g_strdup_printf(_("Cannot join %s: Registration is required."), args[1]);
1344 purple_notify_error(gc, _("Cannot join channel"), msg, args[2],
1345 purple_request_cpar_from_connection(gc));
1346 g_free(msg);
1347 }
1348
1349 void irc_msg_quit(struct irc_conn *irc, const char *name, const char *from, char **args)
1350 {
1351 PurpleConnection *gc = purple_account_get_connection(irc->account);
1352 struct irc_buddy *ib;
1353 char *data[2];
1354
1355 g_return_if_fail(gc);
1356
1357 data[0] = irc_mask_nick(from);
1358 data[1] = args[0];
1359 /* XXX this should have an API, I shouldn't grab this directly */
1360 g_slist_foreach(purple_connection_get_active_chats(gc),
1361 (GFunc)irc_chat_remove_buddy, data);
1362
1363 if ((ib = g_hash_table_lookup(irc->buddies, data[0])) != NULL) {
1364 ib->new_online_status = FALSE;
1365 irc_buddy_status(data[0], ib, irc);
1366 }
1367 g_free(data[0]);
1368
1369 return;
1370 }
1371
1372 void irc_msg_unavailable(struct irc_conn *irc, const char *name, const char *from, char **args)
1373 {
1374 PurpleConnection *gc = purple_account_get_connection(irc->account);
1375
1376 purple_notify_error(gc, NULL, _("Nick or channel is temporarily "
1377 "unavailable."), args[1],
1378 purple_request_cpar_from_connection(gc));
1379 }
1380
1381 void irc_msg_wallops(struct irc_conn *irc, const char *name, const char *from, char **args)
1382 {
1383 PurpleConnection *gc = purple_account_get_connection(irc->account);
1384 char *nick, *msg;
1385
1386 g_return_if_fail(gc);
1387
1388 nick = irc_mask_nick(from);
1389 msg = g_strdup_printf (_("Wallops from %s"), nick);
1390 g_free(nick);
1391 purple_notify_info(gc, NULL, msg, args[0],
1392 purple_request_cpar_from_connection(gc));
1393 g_free(msg);
1394 }
1395
1396 #ifdef HAVE_CYRUS_SASL
1397 static int
1398 irc_sasl_cb_secret(sasl_conn_t *conn, void *ctx, int id, sasl_secret_t **secret)
1399 {
1400 struct irc_conn *irc = ctx;
1401 sasl_secret_t *sasl_secret;
1402 const char *pw;
1403 size_t len;
1404
1405 pw = purple_connection_get_password(purple_account_get_connection(
1406 irc->account));
1407
1408 if (!conn || !secret || id != SASL_CB_PASS)
1409 return SASL_BADPARAM;
1410
1411 len = strlen(pw);
1412 /* Not an off-by-one because sasl_secret_t defines char data[1] */
1413 /* TODO: This can probably be moved to glib's allocator */
1414 sasl_secret = malloc(sizeof(sasl_secret_t) + len);
1415 if (!sasl_secret)
1416 return SASL_NOMEM;
1417
1418 sasl_secret->len = len;
1419 strcpy((char*)sasl_secret->data, pw);
1420
1421 *secret = sasl_secret;
1422 return SASL_OK;
1423 }
1424
1425 static int
1426 irc_sasl_cb_log(void *context, int level, const char *message)
1427 {
1428 if(level <= SASL_LOG_TRACE)
1429 purple_debug_info("sasl", "%s\n", message);
1430
1431 return SASL_OK;
1432 }
1433
1434 static int
1435 irc_sasl_cb_simple(void *ctx, int id, const char **res, unsigned *len)
1436 {
1437 struct irc_conn *irc = ctx;
1438 PurpleConnection *gc = purple_account_get_connection(irc->account);
1439
1440 switch(id) {
1441 case SASL_CB_AUTHNAME:
1442 *res = purple_connection_get_display_name(gc);
1443 break;
1444 case SASL_CB_USER:
1445 *res = "";
1446 break;
1447 default:
1448 return SASL_BADPARAM;
1449 }
1450 if (len) *len = strlen((char *)*res);
1451 return SASL_OK;
1452 }
1453
1454 static void
1455 irc_auth_start_cyrus(struct irc_conn *irc)
1456 {
1457 int ret = 0;
1458 char *buf;
1459 sasl_security_properties_t secprops;
1460 PurpleAccount *account = irc->account;
1461 PurpleConnection *gc = purple_account_get_connection(account);
1462
1463 gboolean again = FALSE;
1464
1465 /* Set up security properties and options */
1466 secprops.min_ssf = 0;
1467 secprops.security_flags = SASL_SEC_NOANONYMOUS;
1468
1469 if (!G_IS_TLS_CONNECTION(irc->conn)) {
1470 gboolean plaintext;
1471
1472 secprops.max_ssf = -1;
1473 secprops.maxbufsize = 4096;
1474 plaintext = purple_account_get_bool(account, "auth_plain_in_clear", FALSE);
1475 if (!plaintext)
1476 secprops.security_flags |= SASL_SEC_NOPLAINTEXT;
1477 } else {
1478 secprops.max_ssf = 0;
1479 secprops.maxbufsize = 0;
1480 }
1481
1482 secprops.property_names = 0;
1483 secprops.property_values = 0;
1484
1485 do {
1486 again = FALSE;
1487
1488 ret = sasl_client_new("irc", irc->server, NULL, NULL, irc->sasl_cb, 0, &irc->sasl_conn);
1489
1490 if (ret != SASL_OK) {
1491 purple_debug_error("irc", "sasl_client_new failed: %d\n", ret);
1492 purple_connection_take_error(gc, g_error_new(
1493 PURPLE_CONNECTION_ERROR,
1494 PURPLE_CONNECTION_ERROR_OTHER_ERROR,
1495 ("Failed to initialize SASL authentication: %s"),
1496 sasl_errdetail(irc->sasl_conn)));
1497 return;
1498 }
1499
1500 sasl_setprop(irc->sasl_conn, SASL_AUTH_EXTERNAL, purple_account_get_username(irc->account));
1501 sasl_setprop(irc->sasl_conn, SASL_SEC_PROPS, &secprops);
1502
1503 ret = sasl_client_start(irc->sasl_conn, irc->sasl_mechs->str, NULL, NULL, NULL, &irc->current_mech);
1504
1505 switch (ret) {
1506 case SASL_OK:
1507 case SASL_CONTINUE:
1508 irc->mech_works = FALSE;
1509 break;
1510 case SASL_NOMECH:
1511 purple_connection_take_error(gc,
1512 g_error_new_literal(
1513 PURPLE_CONNECTION_ERROR,
1514 PURPLE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE,
1515 _("SASL authentication failed: No worthy authentication mechanisms found.")));
1516
1517 irc_sasl_finish(irc);
1518 return;
1519 case SASL_BADPARAM:
1520 case SASL_NOMEM:
1521 purple_connection_take_error(gc, g_error_new(
1522 PURPLE_CONNECTION_ERROR,
1523 PURPLE_CONNECTION_ERROR_OTHER_ERROR,
1524 _("SASL authentication failed: %s"),
1525 sasl_errdetail(irc->sasl_conn)));
1526
1527 irc_sasl_finish(irc);
1528 return;
1529 default:
1530 purple_debug_error("irc", "sasl_client_start failed: %s\n", sasl_errdetail(irc->sasl_conn));
1531
1532 if (irc->current_mech && *irc->current_mech) {
1533 char *pos;
1534 if ((pos = strstr(irc->sasl_mechs->str, irc->current_mech))) {
1535 size_t index = pos - irc->sasl_mechs->str;
1536 g_string_erase(irc->sasl_mechs, index, strlen(irc->current_mech));
1537
1538 /* Remove space which separated this mech from the next */
1539 if ((irc->sasl_mechs->str)[index] == ' ') {
1540 g_string_erase(irc->sasl_mechs, index, 1);
1541 }
1542 }
1543
1544 again = TRUE;
1545 }
1546 irc_sasl_finish(irc);
1547 }
1548 } while (again);
1549
1550 purple_debug_info("irc", "Using SASL: %s\n", irc->current_mech);
1551
1552 buf = irc_format(irc, "vv", "AUTHENTICATE", irc->current_mech);
1553 irc_send(irc, buf);
1554 g_free(buf);
1555 }
1556
1557 /* SASL authentication */
1558 void
1559 irc_msg_cap(struct irc_conn *irc, const char *name, const char *from, char **args)
1560 {
1561 int ret = 0;
1562 int id = 0;
1563 PurpleConnection *gc = purple_account_get_connection(irc->account);
1564 const char *mech_list = NULL;
1565 char *pos;
1566 size_t index;
1567
1568 if (strncmp(g_strstrip(args[2]), "sasl", 5))
1569 return;
1570 if (strncmp(args[1], "ACK", 4)) {
1571 purple_connection_take_error(gc, g_error_new_literal(
1572 PURPLE_CONNECTION_ERROR,
1573 PURPLE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE,
1574 _("SASL authentication failed: Server does not support SASL authentication.")));
1575
1576 irc_sasl_finish(irc);
1577 return;
1578 }
1579
1580 if ((ret = sasl_client_init(NULL)) != SASL_OK) {
1581 purple_connection_take_error(gc, g_error_new_literal(
1582 PURPLE_CONNECTION_ERROR,
1583 PURPLE_CONNECTION_ERROR_OTHER_ERROR,
1584 _("SASL authentication failed: Initializing SASL failed.")));
1585 return;
1586 }
1587
1588 irc->sasl_cb = g_new0(sasl_callback_t, 5);
1589
1590 irc->sasl_cb[id].id = SASL_CB_AUTHNAME;
1591 irc->sasl_cb[id].proc = (int (*)(void))irc_sasl_cb_simple; /* sasl_getsimple_t */
1592 irc->sasl_cb[id].context = (void *)irc;
1593 id++;
1594
1595 irc->sasl_cb[id].id = SASL_CB_USER;
1596 irc->sasl_cb[id].proc = (int (*)(void))irc_sasl_cb_simple; /* sasl_getsimple_t */
1597 irc->sasl_cb[id].context = (void *)irc;
1598 id++;
1599
1600 irc->sasl_cb[id].id = SASL_CB_PASS;
1601 irc->sasl_cb[id].proc = (int (*)(void))irc_sasl_cb_secret; /* sasl_getsecret_t */
1602 irc->sasl_cb[id].context = (void *)irc;
1603 id++;
1604
1605 irc->sasl_cb[id].id = SASL_CB_LOG;
1606 irc->sasl_cb[id].proc = (int (*)(void))irc_sasl_cb_log; /* sasl_log_t */
1607 irc->sasl_cb[id].context = (void *)irc;
1608 id++;
1609
1610 irc->sasl_cb[id].id = SASL_CB_LIST_END;
1611
1612 /* We need to do this to be able to list the mechanisms. */
1613 ret = sasl_client_new("irc", irc->server, NULL, NULL, irc->sasl_cb, 0, &irc->sasl_conn);
1614
1615 sasl_listmech(irc->sasl_conn, NULL, "", " ", "", &mech_list, NULL, NULL);
1616 purple_debug_info("irc", "SASL: we have available: %s\n", mech_list);
1617
1618 if (ret != SASL_OK) {
1619 purple_debug_error("irc", "sasl_client_new failed: %d\n", ret);
1620
1621 purple_connection_take_error(gc, g_error_new(
1622 PURPLE_CONNECTION_ERROR,
1623 PURPLE_CONNECTION_ERROR_OTHER_ERROR,
1624 _("Failed to initialize SASL authentication: %s"),
1625 sasl_errdetail(irc->sasl_conn)));
1626
1627 return;
1628 }
1629
1630 irc->sasl_mechs = g_string_new(mech_list);
1631 /* Drop EXTERNAL mechanism since we don't support it */
1632 if ((pos = strstr(irc->sasl_mechs->str, "EXTERNAL"))) {
1633 index = pos - irc->sasl_mechs->str;
1634 g_string_erase(irc->sasl_mechs, index, strlen("EXTERNAL"));
1635 /* Remove space which separated this mech from the next */
1636 if ((irc->sasl_mechs->str)[index] == ' ') {
1637 g_string_erase(irc->sasl_mechs, index, 1);
1638 }
1639 }
1640
1641 irc_auth_start_cyrus(irc);
1642 }
1643
1644 void
1645 irc_msg_auth(struct irc_conn *irc, char *arg)
1646 {
1647 PurpleConnection *gc = purple_account_get_connection(irc->account);
1648 char *buf, *authinfo;
1649 char *serverin = NULL;
1650 gsize serverinlen = 0;
1651 const gchar *c_out;
1652 unsigned int clen;
1653 int ret;
1654
1655 irc->mech_works = TRUE;
1656
1657 if (!arg)
1658 return;
1659
1660 if (arg[0] != '+')
1661 serverin = (char *)g_base64_decode(arg, &serverinlen);
1662
1663 ret = sasl_client_step(irc->sasl_conn, serverin, serverinlen,
1664 NULL, &c_out, &clen);
1665
1666 if (ret != SASL_OK && ret != SASL_CONTINUE) {
1667 purple_connection_take_error(gc, g_error_new(
1668 PURPLE_CONNECTION_ERROR,
1669 PURPLE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE,
1670 _("SASL authentication failed: %s"),
1671 sasl_errdetail(irc->sasl_conn)));
1672
1673 irc_sasl_finish(irc);
1674 g_free(serverin);
1675 return;
1676 }
1677
1678 if (clen > 0)
1679 authinfo = g_base64_encode((const guchar*)c_out, clen);
1680 else
1681 authinfo = g_strdup("+");
1682
1683 buf = irc_format(irc, "vv", "AUTHENTICATE", authinfo);
1684 irc_send(irc, buf);
1685 g_free(buf);
1686 g_free(authinfo);
1687 g_free(serverin);
1688 }
1689
1690 void
1691 irc_msg_authenticate(struct irc_conn *irc, const char *name, const char *from, char **args)
1692 {
1693 irc_msg_auth(irc, args[0]);
1694 }
1695
1696 void
1697 irc_msg_authok(struct irc_conn *irc, const char *name, const char *from, char **args)
1698 {
1699 char *buf;
1700
1701 sasl_dispose(&irc->sasl_conn);
1702 irc->sasl_conn = NULL;
1703 purple_debug_info("irc", "Succesfully authenticated using SASL.\n");
1704
1705 /* Finish auth session */
1706 buf = irc_format(irc, "vv", "CAP", "END");
1707 irc_send(irc, buf);
1708 g_free(buf);
1709 }
1710
1711 void
1712 irc_msg_authtryagain(struct irc_conn *irc, const char *name, const char *from, char **args)
1713 {
1714 PurpleConnection *gc = purple_account_get_connection(irc->account);
1715
1716 /* We already received at least one AUTHENTICATE reply from the
1717 * server. This suggests it supports this mechanism, but the
1718 * password was incorrect. It would be better to abort and inform
1719 * the user than to try again with a different mechanism, so they
1720 * aren't told the server supports no worthy mechanisms.
1721 */
1722 if (irc->mech_works) {
1723 purple_connection_take_error(gc, g_error_new_literal(
1724 PURPLE_CONNECTION_ERROR,
1725 PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED,
1726 _("Incorrect Password")));
1727
1728 irc_sasl_finish(irc);
1729
1730 return;
1731 }
1732
1733 if (irc->current_mech) {
1734 char *pos;
1735 if ((pos = strstr(irc->sasl_mechs->str, irc->current_mech))) {
1736 size_t index = pos - irc->sasl_mechs->str;
1737 g_string_erase(irc->sasl_mechs, index, strlen(irc->current_mech));
1738
1739 /* Remove space which separated this mech from the next */
1740 if ((irc->sasl_mechs->str)[index] == ' ') {
1741 g_string_erase(irc->sasl_mechs, index, 1);
1742 }
1743 }
1744 }
1745 if (*irc->sasl_mechs->str) {
1746 sasl_dispose(&irc->sasl_conn);
1747
1748 purple_debug_info("irc", "Now trying with %s\n", irc->sasl_mechs->str);
1749 irc_auth_start_cyrus(irc);
1750 } else {
1751 purple_connection_take_error(gc, g_error_new_literal(
1752 PURPLE_CONNECTION_ERROR,
1753 PURPLE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE,
1754 _("SASL authentication failed: No worthy mechanisms found")));
1755
1756 irc_sasl_finish(irc);
1757 }
1758 }
1759
1760 void
1761 irc_msg_authfail(struct irc_conn *irc, const char *name, const char *from, char **args)
1762 {
1763 PurpleConnection *gc = purple_account_get_connection(irc->account);
1764
1765 /* Only show an error if we did not abort ourselves. */
1766 if (irc->sasl_conn) {
1767 purple_debug_info("irc", "SASL authentication failed: %s", sasl_errdetail(irc->sasl_conn));
1768
1769 purple_connection_take_error(gc, g_error_new_literal(
1770 PURPLE_CONNECTION_ERROR,
1771 PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED,
1772 _("Incorrect Password")));
1773 }
1774
1775 irc_sasl_finish(irc);
1776 }
1777
1778 static void
1779 irc_sasl_finish(struct irc_conn *irc)
1780 {
1781 char *buf;
1782
1783 sasl_dispose(&irc->sasl_conn);
1784 irc->sasl_conn = NULL;
1785
1786 g_free(irc->sasl_cb);
1787 irc->sasl_cb = NULL;
1788
1789 /* Auth failed, abort */
1790 buf = irc_format(irc, "vv", "CAP", "END");
1791 irc_send(irc, buf);
1792 g_free(buf);
1793 }
1794 #endif
Git mirror of Pidgin's Mercurial repository