Mercurial > pidgin3 / file comparison

comparison: libgaim/protocols/bonjour/jabber.c

libgaim/protocols/bonjour/jabber.c

branch
gaim
changeset 20470
77693555855f
parent 13006
2e2ca7e0c716
parent 14254
77edc7a6191a
child 20471
1966704b3e42
equal deleted inserted replaced
13071:b98e72d4089a 20470:77693555855f
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 }

Mercurial Repository: pidgin3

mercurial