Mercurial > pidgin
annotate src/protocols/jabber/message.c @ 7258:d1974612b994
[gaim-migrate @ 7835]
this mostly works (add/remove button is quirky) but is the RightWay(TM) to do things
committer: Tailor Script <tailor@pidgin.im>
author | Nathan Walp <nwalp@pidgin.im> |
---|---|
date | Tue, 14 Oct 2003 03:46:00 +0000 |
parents | 04e80607aff2 |
children | 1930e3d00ecd |
rev | line source |
---|---|
7014 | 1 /* |
2 * gaim - Jabber Protocol Plugin | |
3 * | |
4 * Copyright (C) 2003, Nathan Walp <faceprint@faceprint.com> | |
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
19 * | |
20 */ | |
21 #include "internal.h" | |
22 | |
23 #include "debug.h" | |
24 #include "notify.h" | |
25 #include "server.h" | |
7095
c8bf2da398e3
[gaim-migrate @ 7660]
Christian Hammond <chipx86@chipx86.com>
parents:
7014
diff
changeset
|
26 #include "util.h" |
7014 | 27 |
28 #include "buddy.h" | |
29 #include "chat.h" | |
30 #include "message.h" | |
31 #include "xmlnode.h" | |
32 | |
33 #define JABBER_TYPING_NOTIFY_INT 15 | |
34 | |
35 void jabber_message_free(JabberMessage *jm) | |
36 { | |
37 if(jm->from) | |
38 g_free(jm->from); | |
39 if(jm->to) | |
40 g_free(jm->to); | |
41 if(jm->subject) | |
42 g_free(jm->subject); | |
43 if(jm->body) | |
44 g_free(jm->body); | |
45 if(jm->xhtml) | |
46 g_free(jm->xhtml); | |
47 if(jm->password) | |
48 g_free(jm->password); | |
7145 | 49 if(jm->etc) |
50 g_list_free(jm->etc); | |
7014 | 51 |
52 g_free(jm); | |
53 } | |
54 | |
7145 | 55 static void handle_chat(JabberMessage *jm) |
7014 | 56 { |
57 JabberID *jid = jabber_id_new(jm->from); | |
58 char *from; | |
59 | |
60 JabberBuddy *jb; | |
61 JabberBuddyResource *jbr; | |
62 | |
63 jb = jabber_buddy_find(jm->js, jm->from, TRUE); | |
64 jbr = jabber_buddy_find_resource(jb, jabber_get_resource(jm->from)); | |
65 | |
7258 | 66 if(gaim_find_conversation_with_account(jm->from, jm->js->gc->account)) { |
7014 | 67 from = g_strdup(jm->from); |
7258 | 68 } else if(jid->node) { |
69 GaimConversation *conv; | |
70 | |
7014 | 71 from = g_strdup_printf("%s@%s", jid->node, jid->domain); |
7258 | 72 conv = gaim_find_conversation_with_account(from, jm->js->gc->account); |
73 if(conv) | |
74 gaim_conversation_set_name(conv, jm->from); | |
75 g_free(from); | |
76 from = g_strdup(jm->from); | |
77 } else { | |
7014 | 78 from = g_strdup(jid->domain); |
7258 | 79 } |
7014 | 80 |
81 if(!jm->xhtml && !jm->body) { | |
82 if(jm->events & JABBER_MESSAGE_EVENT_COMPOSING) | |
83 serv_got_typing(jm->js->gc, from, 0, GAIM_TYPING); | |
84 else | |
85 serv_got_typing_stopped(jm->js->gc, from); | |
86 } else { | |
87 if(jbr && jm->events & JABBER_MESSAGE_EVENT_COMPOSING) | |
88 jbr->capabilities |= JABBER_CAP_COMPOSING; | |
89 serv_got_im(jm->js->gc, from, jm->xhtml ? jm->xhtml : jm->body, 0, | |
90 jm->sent); | |
91 } | |
92 | |
93 g_free(from); | |
94 jabber_id_free(jid); | |
95 } | |
96 | |
7145 | 97 static void handle_headline(JabberMessage *jm) |
98 { | |
99 char *title; | |
100 GString *body = g_string_new(""); | |
101 GList *etc; | |
102 | |
103 title = g_strdup_printf(_("Message from %s"), jm->from); | |
104 | |
105 if(jm->xhtml) | |
106 g_string_append(body, jm->xhtml); | |
107 else if(jm->body) | |
108 g_string_append(body, jm->body); | |
109 | |
110 for(etc = jm->etc; etc; etc = etc->next) { | |
111 xmlnode *x = etc->data; | |
112 const char *xmlns = xmlnode_get_attrib(x, "xmlns"); | |
113 if(xmlns && !strcmp(xmlns, "jabber:x:oob")) { | |
114 xmlnode *url, *desc; | |
115 char *urltxt, *desctxt; | |
116 | |
117 url = xmlnode_get_child(x, "url"); | |
118 desc = xmlnode_get_child(x, "desc"); | |
119 | |
120 if(!url || !desc) | |
121 continue; | |
122 | |
123 urltxt = xmlnode_get_data(url); | |
124 desctxt = xmlnode_get_data(desc); | |
125 | |
126 /* I'm all about ugly hacks */ | |
127 if(body->len && !strcmp(body->str, jm->body)) | |
128 g_string_printf(body, "<a href='%s'>%s</a>", | |
129 urltxt, desctxt); | |
130 else | |
131 g_string_append_printf(body, "<br/><a href='%s'>%s</a>", | |
132 urltxt, desctxt); | |
133 | |
134 g_free(urltxt); | |
135 g_free(desctxt); | |
136 } | |
137 } | |
138 | |
139 gaim_notify_formatted(jm->js->gc, title, jm->subject ? jm->subject : title, | |
140 NULL, body->str, NULL, NULL); | |
141 | |
142 g_free(title); | |
143 g_string_free(body, TRUE); | |
144 } | |
145 | |
146 static void handle_groupchat(JabberMessage *jm) | |
7014 | 147 { |
148 JabberID *jid = jabber_id_new(jm->from); | |
149 JabberChat *chat = jabber_chat_find(jm->js, jid->node, jid->domain); | |
150 | |
151 if(!chat) | |
152 return; | |
153 | |
154 if(jm->subject) | |
7183 | 155 gaim_conv_chat_set_topic(GAIM_CONV_CHAT(chat->conv), jid->resource, |
156 jm->subject); | |
7014 | 157 |
7183 | 158 if(jm->xhtml || jm->body) |
159 serv_got_chat_in(jm->js->gc, chat->id, jabber_get_resource(jm->from), | |
160 0, jm->xhtml ? jm->xhtml : jm->body, jm->sent); | |
7014 | 161 jabber_id_free(jid); |
162 } | |
163 | |
7145 | 164 static void handle_groupchat_invite(JabberMessage *jm) |
7014 | 165 { |
166 GHashTable *components = g_hash_table_new_full(g_str_hash, g_str_equal, | |
167 g_free, g_free); | |
168 JabberID *jid = jabber_id_new(jm->to); | |
169 | |
170 g_hash_table_replace(components, g_strdup("room"), jid->node); | |
171 g_hash_table_replace(components, g_strdup("server"), jid->node); | |
172 g_hash_table_replace(components, g_strdup("handle"), jm->js->user->node); | |
173 g_hash_table_replace(components, g_strdup("password"), jm->password); | |
174 | |
175 jabber_id_free(jid); | |
176 serv_got_chat_invite(jm->js->gc, jm->to, jm->from, jm->body, components); | |
177 } | |
178 | |
7145 | 179 static void handle_error(JabberMessage *jm) |
7014 | 180 { |
181 char *buf; | |
182 | |
183 if(!jm->body) | |
184 return; | |
185 | |
186 buf = g_strdup_printf(_("Message delivery to %s failed: %s"), | |
187 jm->from, jm->error); | |
188 | |
189 gaim_notify_error(jm->js->gc, _("Jabber Message Error"), buf, jm->body); | |
190 | |
191 g_free(buf); | |
192 } | |
193 | |
194 void jabber_message_parse(JabberStream *js, xmlnode *packet) | |
195 { | |
196 JabberMessage *jm; | |
197 const char *type; | |
198 xmlnode *child; | |
199 | |
200 if(strcmp(packet->name, "message")) | |
201 return; | |
202 | |
203 jm = g_new0(JabberMessage, 1); | |
204 jm->js = js; | |
205 jm->sent = time(NULL); | |
206 | |
207 type = xmlnode_get_attrib(packet, "type"); | |
208 | |
209 if(type) { | |
210 if(!strcmp(type, "normal")) | |
211 jm->type = JABBER_MESSAGE_NORMAL; | |
212 else if(!strcmp(type, "chat")) | |
213 jm->type = JABBER_MESSAGE_CHAT; | |
214 else if(!strcmp(type, "groupchat")) | |
215 jm->type = JABBER_MESSAGE_GROUPCHAT; | |
216 else if(!strcmp(type, "headline")) | |
217 jm->type = JABBER_MESSAGE_HEADLINE; | |
218 else if(!strcmp(type, "error")) | |
219 jm->type = JABBER_MESSAGE_ERROR; | |
220 else | |
221 jm->type = JABBER_MESSAGE_OTHER; | |
222 } else { | |
223 jm->type = JABBER_MESSAGE_NORMAL; | |
224 } | |
225 | |
226 jm->from = g_strdup(xmlnode_get_attrib(packet, "from")); | |
227 jm->to = g_strdup(xmlnode_get_attrib(packet, "to")); | |
228 | |
229 for(child = packet->child; child; child = child->next) { | |
230 if(child->type != NODE_TYPE_TAG) | |
231 continue; | |
232 | |
233 if(!strcmp(child->name, "subject")) { | |
234 if(!jm->subject) | |
235 jm->subject = xmlnode_get_data(child); | |
236 } else if(!strcmp(child->name, "body")) { | |
237 if(!jm->body) | |
238 jm->body = xmlnode_get_data(child); | |
7241 | 239 } else if(!strcmp(child->name, "html")) { |
240 if(!jm->xhtml) | |
7014 | 241 jm->xhtml = xmlnode_to_str(child); |
242 } else if(!strcmp(child->name, "error")) { | |
243 const char *code = xmlnode_get_attrib(child, "code"); | |
244 char *code_txt = NULL; | |
245 char *text = xmlnode_get_data(child); | |
246 | |
247 if(code) | |
248 code_txt = g_strdup_printf(_(" (Code %s)"), code); | |
249 | |
250 if(!jm->error) | |
251 jm->error = g_strdup_printf("%s%s", text ? text : "", | |
252 code_txt ? code_txt : ""); | |
253 | |
254 g_free(code_txt); | |
255 g_free(text); | |
256 } else if(!strcmp(child->name, "x")) { | |
257 const char *xmlns = xmlnode_get_attrib(child, "xmlns"); | |
258 if(xmlns && !strcmp(xmlns, "jabber:x:event")) { | |
259 if(xmlnode_get_child(child, "composing")) | |
260 jm->events |= JABBER_MESSAGE_EVENT_COMPOSING; | |
261 } else if(xmlns && !strcmp(xmlns, "jabber:x:delay")) { | |
262 const char *timestamp = xmlnode_get_attrib(child, "stamp"); | |
263 if(timestamp) | |
264 jm->sent = str_to_time(timestamp); | |
265 } else if(xmlns && !strcmp(xmlns, "jabber:x:conference") && | |
266 jm->type != JABBER_MESSAGE_GROUPCHAT_INVITE) { | |
267 const char *jid = xmlnode_get_attrib(child, "jid"); | |
268 if(jid) { | |
269 jm->type = JABBER_MESSAGE_GROUPCHAT_INVITE; | |
270 g_free(jm->to); | |
271 jm->to = g_strdup(jid); | |
272 } | |
273 } else if(xmlns && !strcmp(xmlns, | |
274 "http://jabber.org/protocol/muc#user")) { | |
275 xmlnode *invite = xmlnode_get_child(child, "invite"); | |
276 if(invite) { | |
277 xmlnode *reason, *password; | |
278 const char *jid = xmlnode_get_attrib(child, "from"); | |
279 g_free(jm->to); | |
280 jm->to = jm->from; | |
281 jm->from = g_strdup(jid); | |
282 if((reason = xmlnode_get_child(invite, "reason"))) { | |
283 g_free(jm->body); | |
284 jm->body = xmlnode_get_data(reason); | |
285 } | |
286 if((password = xmlnode_get_child(invite, "password"))) | |
287 jm->password = xmlnode_get_data(password); | |
288 | |
289 jm->type = JABBER_MESSAGE_GROUPCHAT_INVITE; | |
290 } | |
7145 | 291 } else { |
292 jm->etc = g_list_append(jm->etc, child); | |
7014 | 293 } |
294 } | |
295 } | |
296 | |
297 switch(jm->type) { | |
298 case JABBER_MESSAGE_NORMAL: | |
299 case JABBER_MESSAGE_CHAT: | |
7145 | 300 handle_chat(jm); |
301 break; | |
7014 | 302 case JABBER_MESSAGE_HEADLINE: |
7145 | 303 handle_headline(jm); |
7014 | 304 break; |
305 case JABBER_MESSAGE_GROUPCHAT: | |
306 handle_groupchat(jm); | |
307 break; | |
308 case JABBER_MESSAGE_GROUPCHAT_INVITE: | |
309 handle_groupchat_invite(jm); | |
310 break; | |
311 case JABBER_MESSAGE_ERROR: | |
312 handle_error(jm); | |
313 break; | |
314 case JABBER_MESSAGE_OTHER: | |
315 gaim_debug(GAIM_DEBUG_INFO, "jabber", | |
316 "Received message of unknown type: %s\n", type); | |
317 break; | |
318 } | |
319 jabber_message_free(jm); | |
320 } | |
321 | |
322 void jabber_message_send(JabberMessage *jm) | |
323 { | |
324 xmlnode *message, *child; | |
325 const char *type = NULL; | |
326 | |
327 message = xmlnode_new("message"); | |
328 | |
329 switch(jm->type) { | |
330 case JABBER_MESSAGE_NORMAL: | |
331 type = "normal"; | |
332 break; | |
333 case JABBER_MESSAGE_CHAT: | |
334 case JABBER_MESSAGE_GROUPCHAT_INVITE: | |
335 type = "chat"; | |
336 break; | |
337 case JABBER_MESSAGE_HEADLINE: | |
338 type = "headline"; | |
339 break; | |
340 case JABBER_MESSAGE_GROUPCHAT: | |
341 type = "groupchat"; | |
342 break; | |
343 case JABBER_MESSAGE_ERROR: | |
344 type = "error"; | |
345 break; | |
346 case JABBER_MESSAGE_OTHER: | |
347 type = NULL; | |
348 break; | |
349 } | |
350 | |
351 if(type) | |
352 xmlnode_set_attrib(message, "type", type); | |
353 | |
354 xmlnode_set_attrib(message, "to", jm->to); | |
355 | |
356 if(jm->events || (!jm->body && !jm->xhtml)) { | |
357 child = xmlnode_new_child(message, "x"); | |
358 xmlnode_set_attrib(child, "xmlns", "jabber:x:event"); | |
359 if(jm->events & JABBER_MESSAGE_EVENT_COMPOSING) | |
360 xmlnode_new_child(child, "composing"); | |
361 } | |
362 | |
363 if(jm->subject) { | |
364 child = xmlnode_new_child(message, "subject"); | |
365 xmlnode_insert_data(child, jm->subject, -1); | |
366 } | |
367 | |
368 if(jm->body) { | |
369 child = xmlnode_new_child(message, "body"); | |
370 xmlnode_insert_data(child, jm->body, -1); | |
371 } | |
372 | |
373 if(jm->xhtml) { | |
374 child = xmlnode_from_str(jm->xhtml, -1); | |
375 if(child) { | |
376 xmlnode_insert_child(message, child); | |
377 } else { | |
378 gaim_debug(GAIM_DEBUG_ERROR, "jabber", | |
379 "XHTML translation/validation failed, returning: %s\n", | |
380 jm->xhtml); | |
381 } | |
382 } | |
383 | |
384 jabber_send(jm->js, message); | |
385 | |
386 xmlnode_free(message); | |
387 } | |
388 | |
389 int jabber_message_send_im(GaimConnection *gc, const char *who, const char *msg, | |
7118
bf630f7dfdcd
[gaim-migrate @ 7685]
Christian Hammond <chipx86@chipx86.com>
parents:
7095
diff
changeset
|
390 GaimConvImFlags flags) |
7014 | 391 { |
392 JabberMessage *jm; | |
393 JabberBuddy *jb; | |
394 JabberBuddyResource *jbr; | |
395 char *buf; | |
7135 | 396 char *xhtml; |
7014 | 397 |
398 if(!who || !msg) | |
399 return 0; | |
400 | |
401 jb = jabber_buddy_find(gc->proto_data, who, TRUE); | |
402 jbr = jabber_buddy_find_resource(jb, jabber_get_resource(who)); | |
403 | |
404 jm = g_new0(JabberMessage, 1); | |
405 jm->js = gc->proto_data; | |
406 jm->type = JABBER_MESSAGE_CHAT; | |
407 jm->events = JABBER_MESSAGE_EVENT_COMPOSING; | |
408 jm->to = g_strdup(who); | |
409 | |
410 buf = g_strdup_printf("<html xmlns='http://jabber.org/protocol/xhtml-im'><body>%s</body></html>", msg); | |
411 | |
7135 | 412 gaim_markup_html_to_xhtml(buf, &xhtml, &jm->body); |
7014 | 413 g_free(buf); |
414 | |
415 if(!jbr || jbr->capabilities & JABBER_CAP_XHTML) | |
416 jm->xhtml = xhtml; | |
417 else | |
418 g_free(xhtml); | |
419 | |
420 jabber_message_send(jm); | |
421 jabber_message_free(jm); | |
422 return 1; | |
423 } | |
424 | |
425 int jabber_message_send_chat(GaimConnection *gc, int id, const char *message) | |
426 { | |
427 JabberChat *chat; | |
428 JabberMessage *jm; | |
429 JabberStream *js = gc->proto_data; | |
430 | |
431 if(!message) | |
432 return 0; | |
433 | |
434 chat = jabber_chat_find_by_id(js, id); | |
435 | |
436 jm = g_new0(JabberMessage, 1); | |
437 jm->js = gc->proto_data; | |
438 jm->type = JABBER_MESSAGE_CHAT; | |
439 jm->to = g_strdup_printf("%s@%s", chat->room, chat->server); | |
440 | |
7135 | 441 gaim_markup_html_to_xhtml(message, &jm->xhtml, &jm->body); |
7014 | 442 |
443 jabber_message_send(jm); | |
444 jabber_message_free(jm); | |
445 return 1; | |
446 } | |
447 | |
448 int jabber_send_typing(GaimConnection *gc, const char *who, int typing) | |
449 { | |
450 JabberMessage *jm; | |
451 JabberBuddy *jb; | |
452 JabberBuddyResource *jbr; | |
453 | |
454 jb = jabber_buddy_find(gc->proto_data, who, TRUE); | |
455 jbr = jabber_buddy_find_resource(jb, jabber_get_resource(who)); | |
456 | |
7187 | 457 if(!jbr || !(jbr->capabilities & JABBER_CAP_COMPOSING)) |
7014 | 458 return 0; |
459 | |
460 jm = g_new0(JabberMessage, 1); | |
461 jm->js = gc->proto_data; | |
462 jm->type = JABBER_MESSAGE_CHAT; | |
463 jm->to = g_strdup(who); | |
464 | |
465 if(typing == GAIM_TYPING) | |
466 jm->events = JABBER_MESSAGE_EVENT_COMPOSING; | |
467 | |
468 jabber_message_send(jm); | |
469 jabber_message_free(jm); | |
470 | |
471 return JABBER_TYPING_NOTIFY_INT; | |
472 } | |
473 |