Mercurial > pidgin
comparison libpurple/protocols/bonjour/jabber.c @ 15373:5fe8042783c1
Rename gtk/ and libgaim/ to pidgin/ and libpurple/
author | Sean Egan <seanegan@gmail.com> |
---|---|
date | Sat, 20 Jan 2007 02:32:10 +0000 |
parents | |
children | 71b017348c39 |
comparison
equal
deleted
inserted
replaced
15372:f79e0f4df793 | 15373:5fe8042783c1 |
---|---|
1 /* | |
2 * gaim - Bonjour Protocol Plugin | |
3 * | |
4 * Gaim is the legal property of its developers, whose names are too numerous | |
5 * to list here. Please refer to the COPYRIGHT file distributed with this | |
6 * source distribution. | |
7 * | |
8 * This program is free software; you can redistribute it and/or modify | |
9 * it under the terms of the GNU General Public License as published by | |
10 * the Free Software Foundation; either version 2 of the License, or | |
11 * (at your option) any later version. | |
12 * | |
13 * This program is distributed in the hope that it will be useful, | |
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 * GNU General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU General Public License | |
19 * along with this program; if not, write to the Free Software | |
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
21 */ | |
22 #ifndef _WIN32 | |
23 #include <sys/socket.h> | |
24 #include <netinet/in.h> | |
25 #include <arpa/inet.h> | |
26 #else | |
27 #include "libc_interface.h" | |
28 #endif | |
29 #include <sys/types.h> | |
30 #include <glib.h> | |
31 #include <glib/gprintf.h> | |
32 #include <unistd.h> | |
33 #include <fcntl.h> | |
34 | |
35 #include "network.h" | |
36 #include "eventloop.h" | |
37 #include "connection.h" | |
38 #include "blist.h" | |
39 #include "xmlnode.h" | |
40 #include "debug.h" | |
41 #include "notify.h" | |
42 #include "util.h" | |
43 | |
44 #include "jabber.h" | |
45 #include "bonjour.h" | |
46 #include "buddy.h" | |
47 | |
48 static gint | |
49 _connect_to_buddy(GaimBuddy *gb) | |
50 { | |
51 gint socket_fd; | |
52 gint retorno = 0; | |
53 struct sockaddr_in buddy_address; | |
54 | |
55 /* Create a socket and make it non-blocking */ | |
56 socket_fd = socket(PF_INET, SOCK_STREAM, 0); | |
57 | |
58 buddy_address.sin_family = PF_INET; | |
59 buddy_address.sin_port = htons(((BonjourBuddy*)(gb->proto_data))->port_p2pj); | |
60 inet_aton(((BonjourBuddy*)(gb->proto_data))->ip, &(buddy_address.sin_addr)); | |
61 memset(&(buddy_address.sin_zero), '\0', 8); | |
62 | |
63 retorno = connect(socket_fd, (struct sockaddr*)&buddy_address, sizeof(struct sockaddr)); | |
64 if (retorno == -1) { | |
65 gaim_debug_warning("bonjour", "connect error: %s\n", strerror(errno)); | |
66 } | |
67 fcntl(socket_fd, F_SETFL, O_NONBLOCK); | |
68 | |
69 return socket_fd; | |
70 } | |
71 | |
72 #if 0 /* this isn't used anywhere... */ | |
73 static const char * | |
74 _font_size_gaim_to_ichat(int size) | |
75 { | |
76 switch (size) { | |
77 case 1: | |
78 return "8"; | |
79 case 2: | |
80 return "10"; | |
81 case 3: | |
82 return "12"; | |
83 case 4: | |
84 return "14"; | |
85 case 5: | |
86 return "17"; | |
87 case 6: | |
88 return "21"; | |
89 case 7: | |
90 return "24"; | |
91 } | |
92 | |
93 return "12"; | |
94 } | |
95 #endif | |
96 | |
97 static const char * | |
98 _font_size_ichat_to_gaim(int size) | |
99 { | |
100 if (size > 24) { | |
101 return "7"; | |
102 } else if (size >= 21) { | |
103 return "6"; | |
104 } else if (size >= 17) { | |
105 return "5"; | |
106 } else if (size >= 14) { | |
107 return "4"; | |
108 } else if (size >= 12) { | |
109 return "3"; | |
110 } else if (size >= 10) { | |
111 return "2"; | |
112 } | |
113 | |
114 return "1"; | |
115 } | |
116 static void | |
117 _jabber_parse_and_write_message_to_ui(char *message, GaimConnection *connection, GaimBuddy *gb) | |
118 { | |
119 xmlnode *body_node = NULL; | |
120 char *body = NULL; | |
121 xmlnode *html_node = NULL; | |
122 gboolean isHTML = FALSE; | |
123 xmlnode *html_body_node = NULL; | |
124 const char *ichat_balloon_color = NULL; | |
125 const char *ichat_text_color = NULL; | |
126 xmlnode *html_body_font_node = NULL; | |
127 const char *font_face = NULL; | |
128 const char *font_size = NULL; | |
129 const char *font_color = NULL; | |
130 char *html_body = NULL; | |
131 xmlnode *events_node = NULL; | |
132 gboolean composing_event = FALSE; | |
133 gint garbage = -1; | |
134 xmlnode *message_node = NULL; | |
135 | |
136 /* Parsing of the message */ | |
137 message_node = xmlnode_from_str(message, strlen(message)); | |
138 if (message_node == NULL) { | |
139 return; | |
140 } | |
141 | |
142 body_node = xmlnode_get_child(message_node, "body"); | |
143 if (body_node != NULL) { | |
144 body = xmlnode_get_data(body_node); | |
145 } else { | |
146 return; | |
147 } | |
148 | |
149 html_node = xmlnode_get_child(message_node, "html"); | |
150 if (html_node != NULL) | |
151 { | |
152 isHTML = TRUE; | |
153 html_body_node = xmlnode_get_child(html_node, "body"); | |
154 if (html_body_node != NULL) | |
155 { | |
156 ichat_balloon_color = xmlnode_get_attrib(html_body_node, "ichatballooncolor"); | |
157 ichat_text_color = xmlnode_get_attrib(html_body_node, "ichattextcolor"); | |
158 html_body_font_node = xmlnode_get_child(html_body_node, "font"); | |
159 if (html_body_font_node != NULL) | |
160 { /* Types of messages sent by iChat */ | |
161 font_face = xmlnode_get_attrib(html_body_font_node, "face"); | |
162 /* The absolute iChat font sizes should be converted to 1..7 range */ | |
163 font_size = xmlnode_get_attrib(html_body_font_node, "ABSZ"); | |
164 if (font_size != NULL) | |
165 { | |
166 font_size = _font_size_ichat_to_gaim(atoi(font_size)); | |
167 } | |
168 font_color = xmlnode_get_attrib(html_body_font_node, "color"); | |
169 html_body = xmlnode_get_data(html_body_font_node); | |
170 if (html_body == NULL) | |
171 { | |
172 /* This is the kind of formated messages that Gaim creates */ | |
173 html_body = xmlnode_to_str(html_body_font_node, &garbage); | |
174 } | |
175 } else { | |
176 isHTML = FALSE; | |
177 } | |
178 } else { | |
179 isHTML = FALSE; | |
180 } | |
181 | |
182 } | |
183 | |
184 events_node = xmlnode_get_child_with_namespace(message_node, "x", "jabber:x:event"); | |
185 if (events_node != NULL) | |
186 { | |
187 if (xmlnode_get_child(events_node, "composing") != NULL) | |
188 { | |
189 composing_event = TRUE; | |
190 } | |
191 if (xmlnode_get_child(events_node, "id") != NULL) | |
192 { | |
193 /* The user is just typing */ | |
194 xmlnode_free(message_node); | |
195 g_free(body); | |
196 g_free(html_body); | |
197 return; | |
198 } | |
199 } | |
200 | |
201 /* Compose the message */ | |
202 if (isHTML) | |
203 { | |
204 if (font_face == NULL) font_face = "Helvetica"; | |
205 if (font_size == NULL) font_size = "3"; | |
206 if (ichat_text_color == NULL) ichat_text_color = "#000000"; | |
207 if (ichat_balloon_color == NULL) ichat_balloon_color = "#FFFFFF"; | |
208 body = g_strconcat("<font face='", font_face, "' size='", font_size, "' color='", ichat_text_color, | |
209 "' back='", ichat_balloon_color, "'>", html_body, "</font>", NULL); | |
210 } | |
211 | |
212 /* Send the message to the UI */ | |
213 serv_got_im(connection, gb->name, body, 0, time(NULL)); | |
214 | |
215 /* Free all the strings and nodes (the attributes are freed with their nodes) */ | |
216 xmlnode_free(message_node); | |
217 g_free(body); | |
218 g_free(html_body); | |
219 } | |
220 | |
221 struct _check_buddy_by_address_t { | |
222 char *address; | |
223 GaimBuddy **gb; | |
224 BonjourJabber *bj; | |
225 }; | |
226 | |
227 static void | |
228 _check_buddy_by_address(gpointer key, gpointer value, gpointer data) | |
229 { | |
230 GaimBuddy *gb = (GaimBuddy*)value; | |
231 BonjourBuddy *bb; | |
232 struct _check_buddy_by_address_t *cbba; | |
233 | |
234 gb = value; | |
235 cbba = data; | |
236 | |
237 /* | |
238 * If the current GaimBuddy's data is not null and the GaimBuddy's account | |
239 * is the same as the account requesting the check then continue to determine | |
240 * whether the buddies IP matches the target IP. | |
241 */ | |
242 if (cbba->bj->account == gb->account) | |
243 { | |
244 bb = gb->proto_data; | |
245 if ((bb != NULL) && (g_strcasecmp(bb->ip, cbba->address) == 0)) | |
246 *(cbba->gb) = gb; | |
247 } | |
248 } | |
249 | |
250 static gint | |
251 _read_data(gint socket, char **message) | |
252 { | |
253 GString *data = g_string_new(""); | |
254 char partial_data[512]; | |
255 gint total_message_length = 0; | |
256 gint partial_message_length = 0; | |
257 | |
258 /* Read chunks of 512 bytes till the end of the data */ | |
259 while ((partial_message_length = recv(socket, partial_data, 512, 0)) > 0) | |
260 { | |
261 g_string_append_len(data, partial_data, partial_message_length); | |
262 total_message_length += partial_message_length; | |
263 } | |
264 | |
265 if (partial_message_length == -1) | |
266 { | |
267 gaim_debug_warning("bonjour", "receive error: %s\n", strerror(errno)); | |
268 if (total_message_length == 0) { | |
269 return -1; | |
270 } | |
271 } | |
272 | |
273 *message = data->str; | |
274 g_string_free(data, FALSE); | |
275 if (total_message_length != 0) | |
276 gaim_debug_info("bonjour", "Receive: -%s- %d bytes\n", *message, total_message_length); | |
277 | |
278 return total_message_length; | |
279 } | |
280 | |
281 static gint | |
282 _send_data(gint socket, char *message) | |
283 { | |
284 gint message_len = strlen(message); | |
285 gint partial_sent = 0; | |
286 gchar *partial_message = message; | |
287 | |
288 while ((partial_sent = send(socket, partial_message, message_len, 0)) < message_len) | |
289 { | |
290 if (partial_sent != -1) { | |
291 partial_message += partial_sent; | |
292 message_len -= partial_sent; | |
293 } else { | |
294 return -1; | |
295 } | |
296 } | |
297 | |
298 return strlen(message); | |
299 } | |
300 | |
301 static void | |
302 _client_socket_handler(gpointer data, gint socket, GaimInputCondition condition) | |
303 { | |
304 char *message = NULL; | |
305 gint message_length; | |
306 GaimBuddy *gb = (GaimBuddy*)data; | |
307 GaimAccount *account = gb->account; | |
308 GaimConversation *conversation; | |
309 char *closed_conv_message; | |
310 BonjourBuddy *bb = (BonjourBuddy*)gb->proto_data; | |
311 gboolean closed_conversation = FALSE; | |
312 xmlnode *message_node = NULL; | |
313 | |
314 /* Read the data from the socket */ | |
315 if ((message_length = _read_data(socket, &message)) == -1) { | |
316 /* There have been an error reading from the socket */ | |
317 return; | |
318 } else if (message_length == 0) { /* The other end has closed the socket */ | |
319 closed_conversation = TRUE; | |
320 } else { | |
321 message[message_length] = '\0'; | |
322 | |
323 while (g_ascii_iscntrl(message[message_length - 1])) { | |
324 message[message_length - 1] = '\0'; | |
325 message_length--; | |
326 } | |
327 } | |
328 | |
329 /* Parse the message into an XMLnode for analysis */ | |
330 message_node = xmlnode_from_str(message, strlen(message)); | |
331 | |
332 /* Check if the start of the stream has been received, if not check that the current */ | |
333 /* data is the start of the stream */ | |
334 if (!(bb->conversation->stream_started)) | |
335 { | |
336 /* Check if this is the start of the stream */ | |
337 if ((message_node != NULL) && | |
338 g_ascii_strcasecmp(xmlnode_get_attrib(message_node, "xmlns"), "jabber:client") && | |
339 (xmlnode_get_attrib(message_node,"xmlns:stream") != NULL)) | |
340 { | |
341 bb->conversation->stream_started = TRUE; | |
342 } | |
343 else | |
344 { | |
345 /* TODO: This needs to be nonblocking! */ | |
346 if (send(bb->conversation->socket, DOCTYPE, strlen(DOCTYPE), 0) == -1) | |
347 { | |
348 gaim_debug_error("bonjour", "Unable to start a conversation with %s\n", bb->name); | |
349 } | |
350 else | |
351 { | |
352 bb->conversation->stream_started = TRUE; | |
353 } | |
354 } | |
355 } | |
356 | |
357 /* | |
358 * Check that this is not the end of the conversation. This is | |
359 * using a magic string, but xmlnode won't play nice when just | |
360 * parsing an end tag | |
361 */ | |
362 if (gaim_str_has_prefix(message, STREAM_END) || (closed_conversation == TRUE)) { | |
363 /* Close the socket, clear the watcher and free memory */ | |
364 if (bb->conversation != NULL) { | |
365 close(bb->conversation->socket); | |
366 gaim_input_remove(bb->conversation->watcher_id); | |
367 g_free(bb->conversation->buddy_name); | |
368 g_free(bb->conversation); | |
369 bb->conversation = NULL; | |
370 } | |
371 | |
372 /* Inform the user that the conversation has been closed */ | |
373 conversation = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, gb->name, account); | |
374 closed_conv_message = g_strdup_printf(_("%s has closed the conversation."), gb->name); | |
375 gaim_conversation_write(conversation, NULL, closed_conv_message, GAIM_MESSAGE_SYSTEM, time(NULL)); | |
376 g_free(closed_conv_message); | |
377 } else { | |
378 /* Parse the message to get the data and send to the ui */ | |
379 _jabber_parse_and_write_message_to_ui(message, account->gc, gb); | |
380 } | |
381 | |
382 if (message_node != NULL) | |
383 xmlnode_free(message_node); | |
384 } | |
385 | |
386 static void | |
387 _server_socket_handler(gpointer data, int server_socket, GaimInputCondition condition) | |
388 { | |
389 GaimBuddy *gb = NULL; | |
390 struct sockaddr_in their_addr; /* connector's address information */ | |
391 socklen_t sin_size = sizeof(struct sockaddr); | |
392 int client_socket; | |
393 BonjourBuddy *bb = NULL; | |
394 BonjourJabber *bj = data; | |
395 char *address_text = NULL; | |
396 GaimBuddyList *bl = gaim_get_blist(); | |
397 struct _check_buddy_by_address_t *cbba; | |
398 | |
399 /* Check that it is a read condition */ | |
400 if (condition != GAIM_INPUT_READ) { | |
401 return; | |
402 } | |
403 | |
404 if ((client_socket = accept(server_socket, (struct sockaddr *)&their_addr, &sin_size)) == -1) | |
405 { | |
406 return; | |
407 } | |
408 fcntl(client_socket, F_SETFL, O_NONBLOCK); | |
409 | |
410 /* Look for the buddy that has opened the conversation and fill information */ | |
411 address_text = inet_ntoa(their_addr.sin_addr); | |
412 cbba = g_new0(struct _check_buddy_by_address_t, 1); | |
413 cbba->address = address_text; | |
414 cbba->gb = &gb; | |
415 cbba->bj = bj; | |
416 g_hash_table_foreach(bl->buddies, _check_buddy_by_address, cbba); | |
417 g_free(cbba); | |
418 if (gb == NULL) | |
419 { | |
420 gaim_debug_info("bonjour", "We don't like invisible buddies, this is not a superheros comic\n"); | |
421 close(client_socket); | |
422 return; | |
423 } | |
424 bb = (BonjourBuddy*)gb->proto_data; | |
425 | |
426 /* Check if the conversation has been previously started */ | |
427 if (bb->conversation == NULL) | |
428 { | |
429 bb->conversation = g_new(BonjourJabberConversation, 1); | |
430 bb->conversation->socket = client_socket; | |
431 bb->conversation->stream_started = FALSE; | |
432 bb->conversation->buddy_name = g_strdup(gb->name); | |
433 bb->conversation->message_id = 1; | |
434 | |
435 if (bb->conversation->stream_started == FALSE) { | |
436 /* Start the stream */ | |
437 send(bb->conversation->socket, DOCTYPE, strlen(DOCTYPE), 0); | |
438 bb->conversation->stream_started = TRUE; | |
439 } | |
440 | |
441 /* Open a watcher for the client socket */ | |
442 bb->conversation->watcher_id = gaim_input_add(client_socket, GAIM_INPUT_READ, | |
443 _client_socket_handler, gb); | |
444 } else { | |
445 close(client_socket); | |
446 } | |
447 } | |
448 | |
449 gint | |
450 bonjour_jabber_start(BonjourJabber *data) | |
451 { | |
452 struct sockaddr_in my_addr; | |
453 int yes = 1; | |
454 int i; | |
455 gboolean bind_successful; | |
456 | |
457 /* Open a listening socket for incoming conversations */ | |
458 if ((data->socket = socket(PF_INET, SOCK_STREAM, 0)) < 0) | |
459 { | |
460 gaim_debug_error("bonjour", "Cannot open socket: %s\n", strerror(errno)); | |
461 gaim_connection_error(data->account->gc, _("Cannot open socket")); | |
462 return -1; | |
463 } | |
464 | |
465 /* Make the socket reusable */ | |
466 if (setsockopt(data->socket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) != 0) | |
467 { | |
468 gaim_debug_error("bonjour", "Error setting socket options: %s\n", strerror(errno)); | |
469 gaim_connection_error(data->account->gc, _("Error setting socket options")); | |
470 return -1; | |
471 } | |
472 | |
473 memset(&my_addr, 0, sizeof(struct sockaddr_in)); | |
474 my_addr.sin_family = PF_INET; | |
475 | |
476 /* Attempt to find a free port */ | |
477 bind_successful = FALSE; | |
478 for (i = 0; i < 10; i++) | |
479 { | |
480 my_addr.sin_port = htons(data->port); | |
481 if (bind(data->socket, (struct sockaddr*)&my_addr, sizeof(struct sockaddr)) == 0) | |
482 { | |
483 bind_successful = TRUE; | |
484 break; | |
485 } | |
486 data->port++; | |
487 } | |
488 | |
489 /* On no! We tried 10 ports and could not bind to ANY of them */ | |
490 if (!bind_successful) | |
491 { | |
492 gaim_debug_error("bonjour", "Cannot bind socket: %s\n", strerror(errno)); | |
493 gaim_connection_error(data->account->gc, _("Could not bind socket to port")); | |
494 return -1; | |
495 } | |
496 | |
497 /* Attempt to listen on the bound socket */ | |
498 if (listen(data->socket, 10) != 0) | |
499 { | |
500 gaim_debug_error("bonjour", "Cannot listen on socket: %s\n", strerror(errno)); | |
501 gaim_connection_error(data->account->gc, _("Could not listen on socket")); | |
502 return -1; | |
503 } | |
504 | |
505 #if 0 | |
506 /* TODO: Why isn't this being used? */ | |
507 data->socket = gaim_network_listen(data->port, SOCK_STREAM); | |
508 | |
509 if (data->socket == -1) | |
510 { | |
511 gaim_debug_error("bonjour", "No se ha podido crear el socket\n"); | |
512 } | |
513 #endif | |
514 | |
515 /* Open a watcher in the socket we have just opened */ | |
516 data->watcher_id = gaim_input_add(data->socket, GAIM_INPUT_READ, _server_socket_handler, data); | |
517 | |
518 return data->port; | |
519 } | |
520 | |
521 int | |
522 bonjour_jabber_send_message(BonjourJabber *data, const gchar *to, const gchar *body) | |
523 { | |
524 xmlnode *message_node = NULL; | |
525 gchar *message = NULL; | |
526 gint message_length = -1; | |
527 xmlnode *message_body_node = NULL; | |
528 xmlnode *message_html_node = NULL; | |
529 xmlnode *message_html_body_node = NULL; | |
530 xmlnode *message_html_body_font_node = NULL; | |
531 xmlnode *message_x_node = NULL; | |
532 GaimBuddy *gb = NULL; | |
533 BonjourBuddy *bb = NULL; | |
534 char *conv_message = NULL; | |
535 GaimConversation *conversation = NULL; | |
536 char *message_from_ui = NULL; | |
537 char *stripped_message = NULL; | |
538 | |
539 gb = gaim_find_buddy(data->account, to); | |
540 if (gb == NULL) | |
541 /* You can not send a message to an offline buddy */ | |
542 return -10000; | |
543 | |
544 bb = (BonjourBuddy *)gb->proto_data; | |
545 | |
546 /* Enclose the message from the UI within a "font" node */ | |
547 message_body_node = xmlnode_new("body"); | |
548 stripped_message = gaim_markup_strip_html(body); | |
549 xmlnode_insert_data(message_body_node, stripped_message, strlen(stripped_message)); | |
550 | |
551 message_from_ui = g_strconcat("<font>", body, "</font>", NULL); | |
552 message_html_body_font_node = xmlnode_from_str(message_from_ui, strlen(message_from_ui)); | |
553 | |
554 message_html_body_node = xmlnode_new("body"); | |
555 xmlnode_insert_child(message_html_body_node, message_html_body_font_node); | |
556 | |
557 message_html_node = xmlnode_new("html"); | |
558 xmlnode_set_attrib(message_html_node, "xmlns", "http://www.w3.org/1999/xhtml"); | |
559 xmlnode_insert_child(message_html_node, message_html_body_node); | |
560 | |
561 message_x_node = xmlnode_new("x"); | |
562 xmlnode_set_attrib(message_x_node, "xmlns", "jabber:x:event"); | |
563 xmlnode_insert_child(message_x_node, xmlnode_new("composing")); | |
564 | |
565 message_node = xmlnode_new("message"); | |
566 xmlnode_set_attrib(message_node, "to", ((BonjourBuddy*)(gb->proto_data))->name); | |
567 xmlnode_set_attrib(message_node, "from", data->account->username); | |
568 xmlnode_set_attrib(message_node, "type", "chat"); | |
569 xmlnode_insert_child(message_node, message_body_node); | |
570 xmlnode_insert_child(message_node, message_html_node); | |
571 xmlnode_insert_child(message_node, message_x_node); | |
572 | |
573 message = xmlnode_to_str(message_node, &message_length); | |
574 | |
575 /* Check if there is a previously open conversation */ | |
576 if (bb->conversation == NULL) | |
577 { | |
578 bb->conversation = g_new(BonjourJabberConversation, 1); | |
579 bb->conversation->socket = _connect_to_buddy(gb); | |
580 bb->conversation->stream_started = FALSE; | |
581 bb->conversation->buddy_name = g_strdup(gb->name); | |
582 bb->conversation->watcher_id = gaim_input_add(bb->conversation->socket, | |
583 GAIM_INPUT_READ, _client_socket_handler, gb); | |
584 } | |
585 | |
586 /* Check if the stream for the conversation has been started */ | |
587 if (bb->conversation->stream_started == FALSE) | |
588 { | |
589 /* Start the stream */ | |
590 if (send(bb->conversation->socket, DOCTYPE, strlen(DOCTYPE), 0) == -1) | |
591 { | |
592 gaim_debug_error("bonjour", "Unable to start a conversation\n"); | |
593 gaim_debug_warning("bonjour", "send error: %s\n", strerror(errno)); | |
594 conv_message = g_strdup(_("Unable to send the message, the conversation couldn't be started.")); | |
595 conversation = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, bb->name, data->account); | |
596 gaim_conversation_write(conversation, NULL, conv_message, GAIM_MESSAGE_SYSTEM, time(NULL)); | |
597 close(bb->conversation->socket); | |
598 gaim_input_remove(bb->conversation->watcher_id); | |
599 | |
600 /* Free all the data related to the conversation */ | |
601 g_free(bb->conversation->buddy_name); | |
602 g_free(bb->conversation); | |
603 bb->conversation = NULL; | |
604 return 0; | |
605 } | |
606 | |
607 bb->conversation->stream_started = TRUE; | |
608 } | |
609 | |
610 /* Send the message */ | |
611 if (_send_data(bb->conversation->socket, message) == -1) | |
612 return -10000; | |
613 | |
614 return 1; | |
615 } | |
616 | |
617 void | |
618 bonjour_jabber_close_conversation(BonjourJabber *data, GaimBuddy *gb) | |
619 { | |
620 BonjourBuddy *bb = (BonjourBuddy*)gb->proto_data; | |
621 | |
622 if (bb->conversation != NULL) | |
623 { | |
624 /* Send the end of the stream to the other end of the conversation */ | |
625 send(bb->conversation->socket, STREAM_END, strlen(STREAM_END), 0); | |
626 | |
627 /* Close the socket and remove the watcher */ | |
628 close(bb->conversation->socket); | |
629 gaim_input_remove(bb->conversation->watcher_id); | |
630 | |
631 /* Free all the data related to the conversation */ | |
632 g_free(bb->conversation->buddy_name); | |
633 g_free(bb->conversation); | |
634 bb->conversation = NULL; | |
635 } | |
636 } | |
637 | |
638 void | |
639 bonjour_jabber_stop(BonjourJabber *data) | |
640 { | |
641 GaimBuddy *gb = NULL; | |
642 BonjourBuddy *bb = NULL; | |
643 GSList *buddies; | |
644 GSList *l; | |
645 | |
646 /* Close the server socket and remove all the watcher */ | |
647 close(data->socket); | |
648 gaim_input_remove(data->watcher_id); | |
649 | |
650 /* Close all the sockets and remove all the watchers after sending end streams */ | |
651 if (data->account->gc != NULL) | |
652 { | |
653 buddies = gaim_find_buddies(data->account, data->account->username); | |
654 for (l = buddies; l; l = l->next) | |
655 { | |
656 gb = (GaimBuddy*)l->data; | |
657 bb = (BonjourBuddy*)gb->proto_data; | |
658 if (bb->conversation != NULL) | |
659 { | |
660 send(bb->conversation->socket, STREAM_END, strlen(STREAM_END), 0); | |
661 close(bb->conversation->socket); | |
662 gaim_input_remove(bb->conversation->watcher_id); | |
663 } | |
664 } | |
665 g_slist_free(buddies); | |
666 } | |
667 } |