11477
|
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
|
|
23 #include <sys/socket.h>
|
|
24 #include <sys/types.h>
|
|
25 #include <netinet/in.h>
|
|
26 #include <arpa/inet.h>
|
|
27 #include <glib.h>
|
|
28 #include <glib/gprintf.h>
|
|
29 #include <unistd.h>
|
|
30 #include <fcntl.h>
|
|
31
|
|
32 #include "network.h"
|
|
33 #include "eventloop.h"
|
|
34 #include "connection.h"
|
|
35 #include "blist.h"
|
|
36 #include "xmlnode.h"
|
|
37 #include "debug.h"
|
|
38 #include "notify.h"
|
|
39 #include "util.h"
|
|
40
|
|
41 #include "jabber.h"
|
|
42 #include "bonjour.h"
|
|
43 #include "buddy.h"
|
|
44
|
|
45 gint _connect_to_buddy(GaimBuddy* gb)
|
|
46 {
|
|
47 gint socket_fd;
|
|
48 gint retorno = 0;
|
|
49 struct sockaddr_in buddy_address;
|
|
50
|
|
51 // Create a socket and make it non-blocking
|
|
52 socket_fd = socket(PF_INET, SOCK_STREAM, 0);
|
|
53
|
|
54 buddy_address.sin_family = PF_INET;
|
|
55 buddy_address.sin_port = htons(((BonjourBuddy*)(gb->proto_data))->port_p2pj);
|
|
56 inet_aton(((BonjourBuddy*)(gb->proto_data))->ip, &(buddy_address.sin_addr));
|
|
57 memset(&(buddy_address.sin_zero), '\0', 8);
|
|
58
|
|
59 retorno = connect(socket_fd, (struct sockaddr*)&buddy_address, sizeof(struct sockaddr));
|
|
60 if (retorno == -1) {
|
|
61 perror("connect");
|
|
62 }
|
|
63 fcntl(socket_fd, F_SETFL, O_NONBLOCK);
|
|
64
|
|
65 return socket_fd;
|
|
66 }
|
|
67
|
|
68 char* _font_size_gaim_to_ichat(int size)
|
|
69 {
|
|
70 GString* result = NULL;
|
|
71
|
|
72 switch(size){
|
|
73 case 1 :
|
|
74 result = g_string_new("8");
|
|
75 break;
|
|
76 case 2 :
|
|
77 result = g_string_new("10");
|
|
78 break;
|
|
79 case 3 :
|
|
80 result = g_string_new("12");
|
|
81 break;
|
|
82 case 4 :
|
|
83 result = g_string_new("14");
|
|
84 break;
|
|
85 case 5 :
|
|
86 result = g_string_new("17");
|
|
87 break;
|
|
88 case 6 :
|
|
89 result = g_string_new("21");
|
|
90 break;
|
|
91 case 7 :
|
|
92 result = g_string_new("24");
|
|
93 break;
|
|
94 default:
|
|
95 result = g_string_new("12");
|
|
96 }
|
|
97
|
|
98 return g_string_free(result, FALSE);
|
|
99 }
|
|
100
|
|
101 char* _font_size_ichat_to_gaim(int size)
|
|
102 {
|
|
103 GString* result = NULL;
|
|
104
|
|
105 if (size > 24) {
|
|
106 result = g_string_new("7");
|
|
107 } else if(size >= 21) {
|
|
108 result = g_string_new("6");
|
|
109 } else if(size >= 17) {
|
|
110 result = g_string_new("5");
|
|
111 } else if(size >= 14) {
|
|
112 result = g_string_new("4");
|
|
113 } else if(size >= 12) {
|
|
114 result = g_string_new("3");
|
|
115 } else if(size >= 10) {
|
|
116 result = g_string_new("2");
|
|
117 } else {
|
|
118 result = g_string_new("1");
|
|
119 }
|
|
120
|
|
121 return g_string_free(result, FALSE);
|
|
122 }
|
|
123 void _jabber_parse_and_write_message_to_ui(char* message, GaimConnection* connection, GaimBuddy* gb)
|
|
124 {
|
|
125 xmlnode* body_node = NULL;
|
|
126 char* body = NULL;
|
|
127 xmlnode* html_node = NULL;
|
|
128 gboolean isHTML = FALSE;
|
|
129 xmlnode* html_body_node = NULL;
|
11498
|
130 const char* ichat_balloon_color = NULL;
|
|
131 const char* ichat_text_color = NULL;
|
11477
|
132 xmlnode* html_body_font_node = NULL;
|
11498
|
133 const char* font_face = NULL;
|
|
134 const char* font_size = NULL;
|
|
135 const char* font_color = NULL;
|
11477
|
136 char* html_body = NULL;
|
|
137 xmlnode* events_node = NULL;
|
|
138 gboolean composing_event = FALSE;
|
|
139 gint garbage = -1;
|
|
140 xmlnode* message_node = NULL;
|
|
141
|
|
142 // Parsing of the message
|
|
143 message_node = xmlnode_from_str(message, strlen(message));
|
|
144 if (message_node == NULL) {
|
|
145 return;
|
|
146 }
|
|
147
|
|
148 body_node = xmlnode_get_child(message_node, "body");
|
|
149 if (body_node != NULL) {
|
|
150 body = xmlnode_get_data(body_node);
|
|
151 } else {
|
|
152 return;
|
|
153 }
|
|
154
|
|
155 html_node = xmlnode_get_child(message_node, "html");
|
|
156 if (html_node != NULL) {
|
|
157 isHTML = TRUE;
|
|
158 html_body_node = xmlnode_get_child(html_node, "body");
|
|
159 if (html_body_node != NULL) {
|
|
160 ichat_balloon_color = xmlnode_get_attrib(html_body_node, "ichatballooncolor");
|
|
161 ichat_text_color = xmlnode_get_attrib(html_body_node, "ichattextcolor");
|
|
162 html_body_font_node = xmlnode_get_child(html_body_node, "font");
|
|
163 if (html_body_font_node != NULL) { // Types of messages sent by iChat
|
|
164 font_face = xmlnode_get_attrib(html_body_font_node, "face");
|
|
165 // The absolute iChat font sizes should be converted to 1..7 range
|
|
166 font_size = xmlnode_get_attrib(html_body_font_node, "ABSZ");
|
|
167 if (font_size != NULL) {
|
|
168 font_size = _font_size_ichat_to_gaim(atoi(font_size)); //<-- This call will probably leak memory
|
|
169 }
|
|
170 font_color = xmlnode_get_attrib(html_body_font_node, "color");
|
|
171 html_body = xmlnode_get_data(html_body_font_node);
|
|
172 if (html_body == NULL) { // 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 if (xmlnode_get_child(events_node, "composing") != NULL) {
|
|
187 composing_event = TRUE;
|
|
188 }
|
|
189 if (xmlnode_get_child(events_node, "id") != NULL) { // The user is just typing
|
|
190 xmlnode_free(message_node);
|
|
191 g_free(body);
|
|
192 g_free(html_body);
|
|
193 return;
|
|
194 }
|
|
195 }
|
|
196
|
|
197 // Compose the message
|
|
198 if (isHTML) {
|
|
199 if (font_face == NULL) font_face = "Helvetica";
|
|
200 if (font_size == NULL) font_size = "3";
|
|
201 if (ichat_text_color == NULL) ichat_text_color = "#000000";
|
|
202 if (ichat_balloon_color == NULL) ichat_balloon_color = "#FFFFFF";
|
|
203 body = g_strconcat("<font face='", font_face, "' size='", font_size, "' color='", ichat_text_color,
|
|
204 "' back='", ichat_balloon_color, "'>", html_body, "</font>", NULL);
|
|
205 }
|
|
206
|
|
207 // Send the message to the UI
|
|
208 serv_got_im(connection, gb->name, body, 0, time(NULL));
|
|
209
|
|
210 // Free all the strings and nodes (the attributes are freed with their nodes)
|
|
211 xmlnode_free(message_node);
|
|
212 g_free(body);
|
|
213 g_free(html_body);
|
|
214 }
|
|
215
|
|
216 gboolean _check_buddy_by_address(gpointer key, gpointer value, gpointer address)
|
|
217 {
|
|
218 GaimBuddy* gb = (GaimBuddy*)value;
|
|
219 BonjourBuddy* bb = (BonjourBuddy*)gb->proto_data;
|
|
220
|
|
221 if (bb != NULL) {
|
|
222 if (g_strcasecmp(bb->ip, (char*)address) == 0) {
|
|
223 return TRUE;
|
|
224 } else {
|
|
225 return FALSE;
|
|
226 }
|
|
227 } else {
|
|
228 return FALSE;
|
|
229 }
|
|
230 }
|
|
231
|
|
232 gint _read_data(gint socket, char** message)
|
|
233 {
|
|
234 GString* data = g_string_new("");
|
|
235 char parcial_data[512];
|
|
236 gint total_message_length = 0;
|
|
237 gint parcial_message_length = 0;
|
|
238
|
|
239 // Read chunks of 512 bytes till the end of the data
|
|
240 while ((parcial_message_length = recv(socket, parcial_data, 512, 0)) > 0) {
|
|
241 g_string_append_len(data, parcial_data, parcial_message_length);
|
|
242 total_message_length += parcial_message_length;
|
|
243 }
|
|
244
|
|
245 if (parcial_message_length == -1) {
|
|
246 perror("recv");
|
|
247 if (total_message_length == 0) {
|
|
248 return -1;
|
|
249 }
|
|
250 }
|
|
251
|
|
252 *message = data->str;
|
|
253 g_string_free(data, FALSE);
|
|
254 if (total_message_length != 0) gaim_debug_info("bonjour", "Receive: -%s- %d bytes\n", *message, total_message_length);
|
|
255 return total_message_length;
|
|
256 }
|
|
257
|
|
258 gint _send_data(gint socket, char* message)
|
|
259 {
|
|
260 gint message_len = strlen(message);
|
|
261 gint parcial_sent = 0;
|
|
262 gchar* parcial_message = message;
|
|
263
|
|
264 while ((parcial_sent = send(socket, parcial_message, message_len, 0)) < message_len) {
|
|
265 if (parcial_sent != -1) {
|
|
266 parcial_message += parcial_sent;
|
|
267 message_len -= parcial_sent;
|
|
268 } else {
|
|
269 return -1;
|
|
270 }
|
|
271 }
|
|
272
|
|
273 return strlen(message);
|
|
274 }
|
|
275
|
|
276 void _client_socket_handler(gpointer data, gint socket, GaimInputCondition condition)
|
|
277 {
|
|
278 char* message = NULL;
|
|
279 gint message_length;
|
|
280 GaimBuddy* gb = (GaimBuddy*)data;
|
|
281 GaimAccount* account = gb->account;
|
|
282 GaimConversation* conversation;
|
|
283 char* closed_conv_message;
|
|
284 BonjourBuddy* bb = (BonjourBuddy*)gb->proto_data;
|
|
285 gboolean closed_conversation = FALSE;
|
|
286
|
|
287 // Read the data from the socket
|
|
288 if ((message_length = _read_data(socket, &message)) == -1) {
|
|
289 // There have been an error reading from the socket
|
|
290 return;
|
|
291 } else if (message_length == 0) { // The other end has closed the socket
|
|
292 closed_conversation = TRUE;
|
|
293 } else {
|
|
294 message[message_length] = '\0';
|
|
295
|
|
296 while (g_ascii_iscntrl(message[message_length - 1])) {
|
|
297 message[message_length - 1] = '\0';
|
|
298 message_length--;
|
|
299 }
|
|
300 }
|
|
301
|
|
302 // Check if the start of the doctype has been received, if not check that the current
|
|
303 // data is the doctype
|
|
304 if (!(bb->conversation->start_step_one)) {
|
|
305 if (g_str_has_prefix(message, DOCTYPE_DECLARATION)){
|
|
306 bb->conversation->start_step_one = TRUE;
|
|
307 }
|
|
308 }
|
|
309
|
|
310 // Check if the start of the stream has been received, if not check that the current
|
|
311 // data is the start of the stream
|
|
312 if (!(bb->conversation->start_step_two)) {
|
|
313 if (g_str_has_suffix(message, STREAM_START)) {
|
|
314 bb->conversation->start_step_two = TRUE;
|
|
315
|
|
316 // If we haven't done it yet, we have to sent the start of the stream to the other buddy
|
|
317 if (!(bb->conversation->stream_started)) {
|
|
318 if (send(bb->conversation->socket, DOCTYPE, strlen(DOCTYPE), 0) == -1) {
|
|
319 gaim_debug_error("bonjour", "Unable to start a conversation with %s\n", bb->name);
|
|
320 }
|
|
321 }
|
|
322 }
|
|
323 return;
|
|
324 }
|
|
325
|
|
326 // Check that this is not the end of the conversation
|
|
327 if (g_str_has_prefix(message, STREAM_END) || (closed_conversation == TRUE)) {
|
|
328 // Close the socket, clear the watcher and free memory
|
|
329 if (bb->conversation != NULL) {
|
|
330 close(bb->conversation->socket);
|
|
331 gaim_input_remove(bb->conversation->watcher_id);
|
|
332 g_free(bb->conversation->buddy_name);
|
|
333 g_free(bb->conversation);
|
|
334 bb->conversation = NULL;
|
|
335 }
|
|
336
|
|
337 // Inform the user that the conversation has been closed
|
11498
|
338 conversation = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, gb->name, account);
|
11477
|
339 closed_conv_message = g_strconcat(gb->name, " has closed the conversation.", NULL);
|
|
340 gaim_conversation_write(conversation, NULL, closed_conv_message, GAIM_MESSAGE_SYSTEM, time(NULL));
|
|
341 } else {
|
|
342 // Parse the message to get the data and send to the ui
|
|
343 _jabber_parse_and_write_message_to_ui(message, account->gc, gb);
|
|
344 }
|
|
345 }
|
|
346
|
|
347 void _server_socket_handler(gpointer data, int server_socket, GaimInputCondition condition)
|
|
348 {
|
|
349 GaimBuddy* gb = NULL;
|
|
350 struct sockaddr_in their_addr; // connector's address information
|
11515
|
351 socklen_t sin_size = sizeof(struct sockaddr);
|
11477
|
352 int client_socket;
|
|
353 BonjourBuddy* bb = NULL;
|
|
354 char* address_text = NULL;
|
|
355 GaimBuddyList* bl = gaim_get_blist();
|
|
356
|
|
357 //Check that it is a read condition
|
|
358 if (condition != GAIM_INPUT_READ) {
|
|
359 return;
|
|
360 }
|
|
361
|
|
362 if ((client_socket = accept(server_socket, (struct sockaddr *)&their_addr, &sin_size)) == -1) {
|
|
363 return;
|
|
364 }
|
|
365 fcntl(client_socket, F_SETFL, O_NONBLOCK);
|
|
366
|
|
367 // Look for the buddy that has open the conversation and fill information
|
|
368 address_text = inet_ntoa(their_addr.sin_addr);
|
|
369 gb = (GaimBuddy*)g_hash_table_find(bl->buddies, _check_buddy_by_address, address_text);
|
|
370 if (gb == NULL) {
|
|
371 gaim_debug_info("bonjour", "We don't like invisible buddies, this is not a superheros comic\n");
|
|
372 close(client_socket);
|
|
373 return;
|
|
374 }
|
|
375 bb = (BonjourBuddy*)gb->proto_data;
|
|
376
|
|
377 // Check if the conversation has been previously started
|
|
378 if (bb->conversation == NULL) {
|
|
379 bb->conversation = g_new(BonjourJabberConversation, 1);
|
|
380 bb->conversation->socket = client_socket;
|
|
381 bb->conversation->start_step_one = FALSE;
|
|
382 bb->conversation->start_step_two = FALSE;
|
|
383 bb->conversation->stream_started = FALSE;
|
|
384 bb->conversation->buddy_name = g_strdup(gb->name);
|
|
385 bb->conversation->message_id = 1;
|
|
386
|
|
387 if (bb->conversation->stream_started == FALSE) {
|
|
388 // Start the stream
|
|
389 send(bb->conversation->socket, DOCTYPE, strlen(DOCTYPE), 0);
|
|
390 bb->conversation->stream_started = TRUE;
|
|
391 }
|
|
392
|
|
393 // Open a watcher for the client socket
|
|
394 bb->conversation->watcher_id = gaim_input_add(client_socket, GAIM_INPUT_READ,
|
|
395 _client_socket_handler, gb);
|
|
396 } else {
|
|
397 close(client_socket);
|
|
398 }
|
|
399 }
|
|
400
|
|
401 gint bonjour_jabber_start(BonjourJabber* data)
|
|
402 {
|
|
403 struct sockaddr_in my_addr;
|
|
404 int yes = 1;
|
|
405 char* error_message = NULL;
|
|
406
|
|
407
|
|
408 // Open a listening socket for incoming conversations
|
|
409 if ((data->socket = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
|
|
410 gaim_debug_error("bonjour", "Cannot get socket\n");
|
|
411 error_message = strerror(errno);
|
|
412 gaim_debug_error("bonjour", "%s\n", error_message);
|
|
413 gaim_connection_error(data->account->gc, "Cannot open socket");
|
|
414 return -1;
|
|
415 }
|
|
416
|
|
417 // Make the socket reusable
|
|
418 if (setsockopt(data->socket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) != 0) {
|
|
419 gaim_debug_error("bonjour", "Cannot make socket reusable\n");
|
|
420 error_message = strerror(errno);
|
|
421 gaim_debug_error("bonjour", "%s\n", error_message);
|
|
422 gaim_connection_error(data->account->gc, "Error setting socket options");
|
|
423 return -1;
|
|
424 }
|
|
425
|
|
426 memset(&my_addr, 0, sizeof(struct sockaddr_in));
|
|
427 my_addr.sin_family = PF_INET;
|
|
428 my_addr.sin_port = htons(data->port);
|
|
429
|
|
430 if (bind(data->socket, (struct sockaddr*)&my_addr, sizeof(struct sockaddr)) != 0) {
|
|
431 gaim_debug_error("bonjour", "Cannot bind socket\n");
|
|
432 error_message = strerror(errno);
|
|
433 gaim_debug_error("bonjour", "%s\n", error_message);
|
|
434 gaim_connection_error(data->account->gc, "Cannot bind socket to port");
|
|
435 return -1;
|
|
436 }
|
|
437
|
|
438 if (listen(data->socket, 10) != 0) {
|
|
439 gaim_debug_error("bonjour", "Cannot listen to socket\n");
|
|
440 error_message = strerror(errno);
|
|
441 gaim_debug_error("bonjour", "%s\n", error_message);
|
|
442 gaim_connection_error(data->account->gc, "Cannot listen to socket");
|
|
443 return -1;
|
|
444 }
|
|
445
|
|
446 //data->socket = gaim_network_listen(data->port);
|
|
447
|
|
448 //if (data->socket == -1) {
|
|
449 // gaim_debug_error("bonjour", "No se ha podido crear el socket\n");
|
|
450 //}
|
|
451
|
|
452 // Open a watcher in the socket we have just opened
|
|
453 data->watcher_id = gaim_input_add(data->socket, GAIM_INPUT_READ, _server_socket_handler, data);
|
|
454
|
|
455 return 0;
|
|
456 }
|
|
457
|
|
458 void bonjour_jabber_send_message(BonjourJabber* data, const gchar* to, const gchar* body)
|
|
459 {
|
|
460 xmlnode* message_node = NULL;
|
|
461 gchar* message = NULL;
|
|
462 gint message_length = -1;
|
|
463 xmlnode* message_body_node = NULL;
|
|
464 xmlnode* message_html_node = NULL;
|
|
465 xmlnode* message_html_body_node = NULL;
|
|
466 xmlnode* message_html_body_font_node = NULL;
|
|
467 xmlnode* message_x_node = NULL;
|
|
468 GaimBuddy* gb = gaim_find_buddy(data->account, to);
|
|
469 BonjourBuddy* bb = (BonjourBuddy*)gb->proto_data;
|
|
470 char* conv_message = NULL;
|
|
471 GaimConversation* conversation = NULL;
|
|
472 char* message_from_ui = NULL;
|
|
473 char* stripped_message = NULL;
|
|
474
|
|
475 // Enclose the message from the UI within a "font" node
|
|
476 message_body_node = xmlnode_new("body");
|
|
477 stripped_message = gaim_markup_strip_html(body);
|
|
478 xmlnode_insert_data(message_body_node, stripped_message, strlen(stripped_message));
|
|
479
|
|
480 message_from_ui = g_strconcat("<font>", body, "</font>", NULL);
|
|
481 message_html_body_font_node = xmlnode_from_str(message_from_ui, strlen(message_from_ui));
|
|
482
|
|
483 message_html_body_node = xmlnode_new("body");
|
|
484 xmlnode_insert_child(message_html_body_node, message_html_body_font_node);
|
|
485
|
|
486 message_html_node = xmlnode_new("html");
|
|
487 xmlnode_set_attrib(message_html_node, "xmlns", "http://www.w3.org/1999/xhtml");
|
|
488 xmlnode_insert_child(message_html_node, message_html_body_node);
|
|
489
|
|
490 message_x_node = xmlnode_new("x");
|
|
491 xmlnode_set_attrib(message_x_node, "xmlns", "jabber:x:event");
|
|
492 xmlnode_insert_child(message_x_node, xmlnode_new("composing"));
|
|
493
|
|
494 message_node = xmlnode_new("message");
|
|
495 xmlnode_set_attrib(message_node, "to", ((BonjourBuddy*)(gb->proto_data))->name);
|
|
496 xmlnode_set_attrib(message_node, "type", "chat");
|
|
497 xmlnode_insert_child(message_node, message_body_node);
|
|
498 xmlnode_insert_child(message_node, message_html_node);
|
|
499 xmlnode_insert_child(message_node, message_x_node);
|
|
500
|
|
501 message = xmlnode_to_str(message_node, &message_length);
|
|
502
|
|
503 // Check if there is a previously open conversation
|
|
504 if (bb->conversation == NULL) {
|
|
505 bb->conversation = g_new(BonjourJabberConversation, 1);
|
|
506 bb->conversation->socket = _connect_to_buddy(gb);;
|
|
507 bb->conversation->start_step_one = FALSE;
|
|
508 bb->conversation->start_step_two = FALSE;
|
|
509 bb->conversation->stream_started = FALSE;
|
|
510 bb->conversation->buddy_name = g_strdup(gb->name);
|
|
511 bb->conversation->watcher_id = gaim_input_add(bb->conversation->socket,
|
|
512 GAIM_INPUT_READ, _client_socket_handler, gb);
|
|
513 }
|
|
514
|
|
515 // Check if the stream for the conversation has been started
|
|
516 if (bb->conversation->stream_started == FALSE) {
|
|
517 // Start the stream
|
|
518 if (send(bb->conversation->socket, DOCTYPE, strlen(DOCTYPE), 0) == -1) {
|
|
519 gaim_debug_error("bonjour", "Unable to start a conversation\n");
|
|
520 perror("send");
|
|
521 conv_message = g_strdup("Unable to send the message, the conversation couldn't be started.");
|
11498
|
522 conversation = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, bb->name, data->account);
|
11477
|
523 gaim_conversation_write(conversation, NULL, conv_message, GAIM_MESSAGE_SYSTEM, time(NULL));
|
|
524 close(bb->conversation->socket);
|
|
525 gaim_input_remove(bb->conversation->watcher_id);
|
|
526
|
|
527 // Free all the data related to the conversation
|
|
528 g_free(bb->conversation->buddy_name);
|
|
529 g_free(bb->conversation);
|
|
530 bb->conversation = NULL;
|
|
531 return;
|
|
532 }
|
|
533
|
|
534 bb->conversation->stream_started = TRUE;
|
|
535 }
|
|
536
|
|
537 // Send the message
|
|
538 if (_send_data(bb->conversation->socket, message) == -1) {
|
|
539 gaim_debug_error("bonjour", "Unable to send the message\n");
|
|
540 conv_message = g_strdup("Unable to send the message.");
|
11498
|
541 conversation = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, bb->name, data->account);
|
11477
|
542 gaim_conversation_write(conversation, NULL, conv_message, GAIM_MESSAGE_SYSTEM, time(NULL));
|
|
543 }
|
|
544 }
|
|
545
|
|
546 void bonjour_jabber_close_conversation(BonjourJabber* data, GaimBuddy* gb)
|
|
547 {
|
|
548 BonjourBuddy* bb = (BonjourBuddy*)gb->proto_data;
|
|
549
|
|
550 if (bb->conversation != NULL) {
|
|
551 // Send the end of the stream to the other end of the conversation
|
|
552 send(bb->conversation->socket, STREAM_END, strlen(STREAM_END), 0);
|
|
553
|
|
554 // Close the socket and remove the watcher
|
|
555 close(bb->conversation->socket);
|
|
556 gaim_input_remove(bb->conversation->watcher_id);
|
|
557
|
|
558 // Free all the data related to the conversation
|
|
559 g_free(bb->conversation->buddy_name);
|
|
560 g_free(bb->conversation);
|
|
561 bb->conversation = NULL;
|
|
562 }
|
|
563 }
|
|
564
|
|
565 void bonjour_jabber_stop(BonjourJabber* data)
|
|
566 {
|
|
567 GaimBuddy* gb = NULL;
|
|
568 BonjourBuddy* bb = NULL;
|
|
569 GSList* buddies;
|
|
570 GSList* l;
|
|
571
|
|
572 // Close the server socket and remove all the watcher
|
|
573 close(data->socket);
|
|
574 gaim_input_remove(data->watcher_id);
|
|
575
|
|
576 // Close all the sockets and remove all the watchers after sending end streams
|
|
577 if(data->account->gc != NULL){
|
|
578 buddies = gaim_find_buddies(data->account, data->account->username);
|
|
579 for(l = buddies; l; l = l->next){
|
|
580 gb = (GaimBuddy*)l->data;
|
|
581 bb = (BonjourBuddy*)gb->proto_data;
|
|
582 if (bb->conversation != NULL) {
|
|
583 send(bb->conversation->socket, STREAM_END, strlen(STREAM_END), 0);
|
|
584 close(bb->conversation->socket);
|
|
585 gaim_input_remove(bb->conversation->watcher_id);
|
|
586 }
|
|
587 }
|
|
588 g_slist_free(buddies);
|
|
589 }
|
|
590 }
|