1: /*
2: * Purple's oscar protocol plugin
3: * This file is the legal property of its developers.
4: * Please see the AUTHORS file distributed alongside this file.
5: *
6: * This library is free software; you can redistribute it and/or
7: * modify it under the terms of the GNU Lesser General Public
8: * License as published by the Free Software Foundation; either
9: * version 2 of the License, or (at your option) any later version.
10: *
11: * This library 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 GNU
14: * Lesser General Public License for more details.
15: *
16: * You should have received a copy of the GNU Lesser General Public
17: * License along with this library; if not, write to the Free Software
18: * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
19: */
20:
21: /* From the oscar PRPL */
22: #include "encoding.h"
23: #include "oscar.h"
24: #include "peer.h"
25:
26: /* From Purple */
27: #include "conversation.h"
28: #include "imgstore.h"
29: #include "util.h"
30:
31: #define DIRECTIM_MAX_FILESIZE 52428800
32:
33: /**
34: * Free any ODC related data and print a message to the conversation
35: * window based on conn->disconnect_reason.
36: */
37: void
38: peer_odc_close(PeerConnection *conn)
39: {
40: gchar *tmp;
41:
42: if (conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_CLOSED)
43: tmp = g_strdup(_("The remote user has closed the connection."));
44: else if (conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_REFUSED)
45: tmp = g_strdup(_("The remote user has declined your request."));
46: else if (conn->disconnect_reason == OSCAR_DISCONNECT_LOST_CONNECTION)
47: tmp = g_strdup_printf(_("Lost connection with the remote user:<br>%s"),
48: conn->error_message);
49: else if (conn->disconnect_reason == OSCAR_DISCONNECT_INVALID_DATA)
50: tmp = g_strdup(_("Received invalid data on connection with remote user."));
51: else if (conn->disconnect_reason == OSCAR_DISCONNECT_COULD_NOT_CONNECT)
52: tmp = g_strdup(_("Unable to establish a connection with the remote user."));
53: else
54: /*
55: * We shouldn't print a message for some disconnect_reasons.
56: * Like OSCAR_DISCONNECT_LOCAL_CLOSED.
57: */
58: tmp = NULL;
59:
60: if (tmp != NULL)
61: {
62: PurpleAccount *account;
63: PurpleConversation *conv;
64:
65: account = purple_connection_get_account(conn->od->gc);
66: conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, conn->bn);
67: purple_conversation_write(conv, NULL, tmp, PURPLE_MESSAGE_SYSTEM, time(NULL));
68: g_free(tmp);
69: }
70:
71: if (conn->frame != NULL)
72: {
73: OdcFrame *frame;
74: frame = conn->frame;
75: g_free(frame->payload.data);
76: g_free(frame);
77: }
78: }
79:
80: /**
81: * Write the given OdcFrame to a ByteStream and send it out
82: * on the established PeerConnection.
83: */
84: static void
85: peer_odc_send(PeerConnection *conn, OdcFrame *frame)
86: {
87: PurpleAccount *account;
88: const char *username;
89: size_t length;
90: ByteStream bs;
91:
92: purple_debug_info("oscar", "Outgoing ODC frame to %s with "
93: "type=0x%04x, flags=0x%04x, payload length=%" G_GSIZE_FORMAT "\n",
94: conn->bn, frame->type, frame->flags, frame->payload.len);
95:
96: account = purple_connection_get_account(conn->od->gc);
97: username = purple_account_get_username(account);
98: memcpy(frame->bn, username, strlen(username));
99: memcpy(frame->cookie, conn->cookie, 8);
100:
101: length = 76;
102: byte_stream_new(&bs, length + frame->payload.len);
103: byte_stream_putraw(&bs, conn->magic, 4);
104: byte_stream_put16(&bs, length);
105: byte_stream_put16(&bs, frame->type);
106: byte_stream_put16(&bs, frame->subtype);
107: byte_stream_put16(&bs, 0x0000);
108: byte_stream_putraw(&bs, frame->cookie, 8);
109: byte_stream_put16(&bs, 0x0000);
110: byte_stream_put16(&bs, 0x0000);
111: byte_stream_put16(&bs, 0x0000);
112: byte_stream_put16(&bs, 0x0000);
113: byte_stream_put32(&bs, frame->payload.len);
114: byte_stream_put16(&bs, frame->encoding);
115: byte_stream_put16(&bs, 0x0000);
116: byte_stream_put16(&bs, 0x0000);
117: byte_stream_put16(&bs, frame->flags);
118: byte_stream_put16(&bs, 0x0000);
119: byte_stream_put16(&bs, 0x0000);
120: byte_stream_putraw(&bs, frame->bn, 32);
121: byte_stream_putraw(&bs, frame->payload.data, frame->payload.len);
122:
123: peer_connection_send(conn, &bs);
124:
125: byte_stream_destroy(&bs);
126: }
127:
128: /**
129: * Send a very basic ODC frame (which contains the cookie) so that the
130: * remote user can verify that we are the person they were expecting.
131: * If we made an outgoing connection to then remote user, then we send
132: * this immediately. If the remote user connected to us, then we wait
133: * for the other person to send this to us, then we send one to them.
134: */
135: void
136: peer_odc_send_cookie(PeerConnection *conn)
137: {
138: OdcFrame frame;
139:
140: memset(&frame, 0, sizeof(OdcFrame));
141: frame.type = 0x0001;
142: frame.subtype = 0x0006;
143: frame.flags = 0x0060; /* Maybe this means "we're sending the cookie"? */
144:
145: peer_odc_send(conn, &frame);
146: }
147:
148: /**
149: * Send client-to-client typing notification over an established direct connection.
150: */
151: void
152: peer_odc_send_typing(PeerConnection *conn, PurpleTypingState typing)
153: {
154: OdcFrame frame;
155:
156: memset(&frame, 0, sizeof(OdcFrame));
157: frame.type = 0x0001;
158: frame.subtype = 0x0006;
159: if (typing == PURPLE_TYPING)
160: frame.flags = 0x0002 | 0x0008;
161: else if (typing == PURPLE_TYPED)
162: frame.flags = 0x0002 | 0x0004;
163: else
164: frame.flags = 0x0002;
165:
166: peer_odc_send(conn, &frame);
167: }
168:
169: /**
170: * Send client-to-client IM over an established direct connection.
171: * To send a direct IM, call this just like you would aim_send_im.
172: *
173: * @param conn The already-connected ODC connection.
174: * @param msg Null-terminated string to send.
175: * @param len The length of the message to send, including binary data.
176: * @param encoding See the AIM_CHARSET_* defines in oscar.h
177: * @param autoreply TRUE if this is any auto-reply.
178: */
179: void
180: peer_odc_send_im(PeerConnection *conn, const char *msg, int len, int encoding, gboolean autoreply)
181: {
182: OdcFrame frame;
183:
184: g_return_if_fail(msg != NULL);
185: g_return_if_fail(len > 0);
186:
187: memset(&frame, 0, sizeof(OdcFrame));
188: frame.type = 0x0001;
189: frame.subtype = 0x0006;
190: frame.payload.len = len;
191: frame.encoding = encoding;
192: frame.flags = autoreply;
193: byte_stream_new(&frame.payload, len);
194: byte_stream_putraw(&frame.payload, (guint8 *)msg, len);
195:
196: peer_odc_send(conn, &frame);
197:
198: g_free(frame.payload.data);
199: }
200:
201: struct embedded_data
202: {
203: size_t size;
204: const guint8 *data;
205: };
206:
207: /**
208: * This is called after a direct IM has been received in its entirety. This
209: * function is passed a long chunk of data which contains the IM with any
210: * data chunks (images) appended to it.
211: *
212: * This function rips out all the data chunks and creates an imgstore for
213: * each one. In order to do this, it first goes through the IM and takes
214: * out all the IMG tags. When doing so, it rewrites the original IMG tag
215: * with one compatible with the imgstore Purple core code. For each one, we
216: * then read in chunks of data from the end of the message and actually
217: * create the img store using the given data.
218: *
219: * For somewhat easy reference, here's a sample message
220: * (with added whitespace):
221: *
222: * <HTML><BODY BGCOLOR="#ffffff">
223: * <FONT LANG="0">
224: * This is a really stupid picture:<BR>
225: * <IMG SRC="Sample.jpg" ID="1" WIDTH="283" HEIGHT="212" DATASIZE="9894"><BR>
226: * Yeah it is<BR>
227: * Here is another one:<BR>
228: * <IMG SRC="Soap Bubbles.bmp" ID="2" WIDTH="256" HEIGHT="256" DATASIZE="65978">
229: * </FONT>
230: * </BODY></HTML>
231: * <BINARY>
232: * <DATA ID="1" SIZE="9894">datadatadatadata</DATA>
233: * <DATA ID="2" SIZE="65978">datadatadatadata</DATA>
234: * </BINARY>
235: */
236: static void
237: peer_odc_handle_payload(PeerConnection *conn, const char *msg, size_t len, int encoding, gboolean autoreply)
238: {
239: PurpleConnection *gc;
240: PurpleAccount *account;
241: const char *msgend, *binary_start, *dataend;
242: const char *tmp, *start, *end, *idstr, *src, *sizestr;
243: GData *attributes;
244: GHashTable *embedded_datas;
245: struct embedded_data *embedded_data;
246: GSList *images;
247: gchar *utf8;
248: GString *newmsg;
249: PurpleMessageFlags imflags;
250:
251: gc = conn->od->gc;
252: account = purple_connection_get_account(gc);
253:
254: dataend = msg + len;
255:
256: /*
257: * Create a hash table containing references to each embedded
258: * data chunk. The key is the "ID" and the value is an
259: * embedded_data struct.
260: */
261: embedded_datas = g_hash_table_new_full(g_direct_hash,
262: g_direct_equal, NULL, g_free);
263:
264: /*
265: * Create an index of any binary chunks. If we run into any
266: * problems while parsing the binary data section then we stop
267: * parsing it, and the local user will see broken image icons.
268: */
269: binary_start = purple_strcasestr(msg, "<binary>");
270: if (binary_start == NULL)
271: msgend = dataend;
272: else
273: {
274: msgend = binary_start;
275:
276: /* Move our pointer to immediately after the <binary> tag */
277: tmp = binary_start + 8;
278:
279: /* The embedded binary markup has a mimimum length of 29 bytes */
280: while ((tmp + 29 <= dataend) &&
281: purple_markup_find_tag("data", tmp, &start, &tmp, &attributes))
282: {
283: unsigned int id;
284: size_t size;
285:
286: /* Move the binary pointer from ">" to the start of the data */
287: tmp++;
288:
289: /* Get the ID */
290: idstr = g_datalist_get_data(&attributes, "id");
291: if (idstr == NULL)
292: {
293: g_datalist_clear(&attributes);
294: break;
295: }
296: id = atoi(idstr);
297:
298: /* Get the size */
299: sizestr = g_datalist_get_data(&attributes, "size");
300: if (sizestr == NULL)
301: {
302: g_datalist_clear(&attributes);
303: break;
304: }
305: size = atol(sizestr);
306:
307: g_datalist_clear(&attributes);
308:
309: if ((size > 0) && (tmp + size > dataend))
310: break;
311:
312: embedded_data = g_new(struct embedded_data, 1);
313: embedded_data->size = size;
314: embedded_data->data = (const guint8 *)tmp;
315: tmp += size;
316:
317: /* Skip past the closing </data> tag */
318: if (g_ascii_strncasecmp(tmp, "</data>", 7))
319: {
320: g_free(embedded_data);
321: break;
322: }
323: tmp += 7;
324:
325: g_hash_table_insert(embedded_datas,
326: GINT_TO_POINTER(id), embedded_data);
327: }
328: }
329:
330: /*
331: * Loop through the message, replacing OSCAR img tags with the
332: * equivalent Purple img tag.
333: */
334: images = NULL;
335: newmsg = g_string_new("");
336: tmp = msg;
337: while (purple_markup_find_tag("img", tmp, &start, &end, &attributes))
338: {
339: int imgid = 0;
340:
341: idstr = g_datalist_get_data(&attributes, "id");
342: src = g_datalist_get_data(&attributes, "src");
343: sizestr = g_datalist_get_data(&attributes, "datasize");
344:
345: if ((idstr != NULL) && (src != NULL) && (sizestr!= NULL))
346: {
347: unsigned int id;
348: size_t size;
349:
350: id = atoi(idstr);
351: size = atol(sizestr);
352: embedded_data = g_hash_table_lookup(embedded_datas,
353: GINT_TO_POINTER(id));
354:
355: if ((embedded_data != NULL) && (embedded_data->size == size))
356: {
357: imgid = purple_imgstore_add_with_id(g_memdup(embedded_data->data, size), size, src);
358:
359: /* Record the image number */
360: images = g_slist_append(images, GINT_TO_POINTER(imgid));
361: }
362: }
363:
364: /* Delete the attribute list */
365: g_datalist_clear(&attributes);
366:
367: /* Append the message up to the tag */
368: utf8 = oscar_decode_im(account, conn->bn, encoding, tmp, start - tmp);
369: if (utf8 != NULL) {
370: g_string_append(newmsg, utf8);
371: g_free(utf8);
372: }
373:
374: if (imgid != 0)
375: {
376: /* Write the new image tag */
377: g_string_append_printf(newmsg, "<IMG ID=\"%d\">", imgid);
378: }
379:
380: /* Continue from the end of the tag */
381: tmp = end + 1;
382: }
383:
384: /* Append any remaining message data */
385: if (tmp <= msgend)
386: {
387: utf8 = oscar_decode_im(account, conn->bn, encoding, tmp, msgend - tmp);
388: if (utf8 != NULL) {
389: g_string_append(newmsg, utf8);
390: g_free(utf8);
391: }
392: }
393:
394: /* Display the message we received */
395: imflags = 0;
396: if (images != NULL)
397: imflags |= PURPLE_MESSAGE_IMAGES;
398: if (autoreply)
399: imflags |= PURPLE_MESSAGE_AUTO_RESP;
400: serv_got_im(gc, conn->bn, newmsg->str, imflags, time(NULL));
401: g_string_free(newmsg, TRUE);
402:
403: /* unref any images we allocated */
404: if (images)
405: {
406: GSList *l;
407: for (l = images; l != NULL; l = l->next)
408: purple_imgstore_unref_by_id(GPOINTER_TO_INT(l->data));
409: g_slist_free(images);
410: }
411:
412: /* Delete our list of pointers to embedded images */
413: g_hash_table_destroy(embedded_datas);
414: }
415:
416: /**
417: * This is a purple_input_add() watcher callback function for reading
418: * direct IM payload data. "Payload data" is always an IM and
419: * maybe some embedded images or files or something. The actual
420: * ODC frame is read using peer_connection_recv_cb(). We temporarily
421: * switch to this watcher callback ONLY to read the payload, and we
422: * switch back once we're done.
423: */
424: static void
425: peer_odc_recv_cb(gpointer data, gint source, PurpleInputCondition cond)
426: {
427: PeerConnection *conn;
428: OdcFrame *frame;
429: ByteStream *bs;
430: gssize read;
431:
432: conn = data;
433: frame = conn->frame;
434: bs = &frame->payload;
435:
436: /* Read data into the temporary buffer until it is complete */
437: read = recv(conn->fd,
438: &bs->data[bs->offset],
439: bs->len - bs->offset,
440: 0);
441:
442: /* Check if the remote user closed the connection */
443: if (read == 0)
444: {
445: peer_connection_destroy(conn, OSCAR_DISCONNECT_REMOTE_CLOSED, NULL);
446: return;
447: }
448:
449: if (read < 0)
450: {
451: if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
452: /* No worries */
453: return;
454:
455: peer_connection_destroy(conn,
456: OSCAR_DISCONNECT_LOST_CONNECTION, g_strerror(errno));
457: return;
458: }
459:
460: bs->offset += read;
461: if (bs->offset < bs->len)
462: /* Waiting for more data to arrive */
463: return;
464: /* TODO: Instead of null-terminating this, it would be better if we just
465: respected the length of the buffer when parsing it. But it doesn't
466: really matter and this is easy. */
467: bs->data[bs->len] = '\0';
468:
469: /* We have a complete ODC/OFT frame! Handle it and continue reading */
470: byte_stream_rewind(bs);
471: peer_odc_handle_payload(conn, (const char *)bs->data,
472: bs->len, frame->encoding, frame->flags & 0x0001);
473: g_free(bs->data);
474: bs->data = NULL;
475: g_free(frame);
476: conn->frame = NULL;
477:
478: purple_input_remove(conn->watcher_incoming);
479: conn->watcher_incoming = purple_input_add(conn->fd,
480: PURPLE_INPUT_READ, peer_connection_recv_cb, conn);
481: }
482:
483: /**
484: * Handle an incoming OdcFrame. If there is a payload associated
485: * with this frame, then we remove the old watcher and add the
486: * ODC watcher to read in the payload.
487: */
488: void
489: peer_odc_recv_frame(PeerConnection *conn, ByteStream *bs)
490: {
491: PurpleConnection *gc;
492: OdcFrame *frame;
493:
494: gc = conn->od->gc;
495:
496: frame = g_new0(OdcFrame, 1);
497: frame->type = byte_stream_get16(bs);
498: frame->subtype = byte_stream_get16(bs);
499: byte_stream_advance(bs, 2);
500: byte_stream_getrawbuf(bs, frame->cookie, 8);
501: byte_stream_advance(bs, 8);
502: frame->payload.len = byte_stream_get32(bs);
503: frame->encoding = byte_stream_get16(bs);
504: byte_stream_advance(bs, 4);
505: frame->flags = byte_stream_get16(bs);
506: byte_stream_advance(bs, 4);
507: byte_stream_getrawbuf(bs, frame->bn, 32);
508:
509: purple_debug_info("oscar", "Incoming ODC frame from %s with "
510: "type=0x%04x, flags=0x%04x, payload length=%" G_GSIZE_FORMAT "\n",
511: frame->bn, frame->type, frame->flags, frame->payload.len);
512:
513: if (!conn->ready)
514: {
515: /*
516: * We need to verify the cookie so that we know we are
517: * connected to our friend and not a malicious middle man.
518: */
519:
520: PurpleAccount *account;
521: PurpleConversation *conv;
522:
523: if (conn->flags & PEER_CONNECTION_FLAG_IS_INCOMING)
524: {
525: if (memcmp(conn->cookie, frame->cookie, 8))
526: {
527: /*
528: * Oh no! The user that connected to us did not send
529: * the correct cookie! They are not our friend. Go try
530: * to accept another connection?
531: */
532: purple_debug_info("oscar", "Received an incorrect cookie. "
533: "Closing connection.\n");
534: peer_connection_destroy(conn,
535: OSCAR_DISCONNECT_INVALID_DATA, NULL);
536: g_free(frame);
537: return;
538: }
539:
540: /*
541: * Ok, we know they are legit. Now be courteous and
542: * send them our cookie. Note: This doesn't seem
543: * to be necessary, but it also doesn't seem to hurt.
544: */
545: peer_odc_send_cookie(conn);
546: }
547:
548: conn->ready = TRUE;
549:
550: /*
551: * If they connected to us then close the listener socket
552: * and send them our cookie.
553: */
554: if (conn->listenerfd != -1)
555: {
556: close(conn->listenerfd);
557: conn->listenerfd = -1;
558: }
559:
560: /* Tell the local user that we are connected */
561: account = purple_connection_get_account(gc);
562: conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, conn->bn);
563: purple_conversation_write(conv, NULL, _("Direct IM established"),
564: PURPLE_MESSAGE_SYSTEM, time(NULL));
565: }
566:
567: if ((frame->type != 0x0001) && (frame->subtype != 0x0006))
568: {
569: purple_debug_info("oscar", "Unknown ODC frame type 0x%04hx, "
570: "subtype 0x%04hx.\n", frame->type, frame->subtype);
571: g_free(frame);
572: return;
573: }
574:
575: if (frame->flags & 0x0008)
576: {
577: /* I had to leave this. It's just too funny. It reminds me of my sister. */
578: purple_debug_info("oscar", "ohmigod! %s has started typing "
579: "(DirectIM). He's going to send you a message! "
580: "*squeal*\n", conn->bn);
581: serv_got_typing(gc, conn->bn, 0, PURPLE_TYPING);
582: }
583: else if (frame->flags & 0x0004)
584: {
585: serv_got_typing(gc, conn->bn, 0, PURPLE_TYPED);
586: }
587: else
588: {
589: serv_got_typing_stopped(gc, conn->bn);
590: }
591:
592: if (frame->payload.len > 0)
593: {
594: if (frame->payload.len > DIRECTIM_MAX_FILESIZE)
595: {
596: gchar *tmp, *size1, *size2;
597: PurpleAccount *account;
598: PurpleConversation *conv;
599:
600: size1 = purple_str_size_to_units(frame->payload.len);
601: size2 = purple_str_size_to_units(DIRECTIM_MAX_FILESIZE);
602: tmp = g_strdup_printf(_("%s tried to send you a %s file, but we only allow files up to %s over Direct IM. Try using file transfer instead.\n"), conn->bn, size1, size2);
603: g_free(size1);
604: g_free(size2);
605:
606: account = purple_connection_get_account(conn->od->gc);
607: conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, conn->bn);
608: purple_conversation_write(conv, NULL, tmp, PURPLE_MESSAGE_SYSTEM, time(NULL));
609: g_free(tmp);
610:
611: peer_connection_destroy(conn, OSCAR_DISCONNECT_LOCAL_CLOSED, NULL);
612: g_free(frame);
613: return;
614: }
615:
616: /* We have payload data! Switch to the ODC watcher to read it. */
617: frame->payload.data = g_new(guint8, frame->payload.len + 1);
618: frame->payload.offset = 0;
619: conn->frame = frame;
620: purple_input_remove(conn->watcher_incoming);
621: conn->watcher_incoming = purple_input_add(conn->fd,
622: PURPLE_INPUT_READ, peer_odc_recv_cb, conn);
623: return;
624: }
625:
626: g_free(frame);
627: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to odc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / ChivanetAimPidgin / oscarprpl / src / c