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: /*
22: * I feel like this is a good place to explain OFT, so I'm going to
23: * do just that. Each OFT packet has a header type. I guess this
24: * is pretty similar to the subtype of a SNAC packet. The type
25: * basically tells the other client the meaning of the OFT packet.
26: * There are two distinct types of file transfer, which I usually
27: * call "sendfile" and "getfile." Sendfile is when you send a file
28: * to another AIM user. Getfile is when you share a group of files,
29: * and other users request that you send them the files.
30: *
31: * A typical sendfile file transfer goes like this:
32: * 1) Sender sends a channel 2 ICBM telling the other user that
33: * we want to send them a file. At the same time, we open a
34: * listener socket (this should be done before sending the
35: * ICBM) on some port, and wait for them to connect to us.
36: * The ICBM we sent should contain our IP address and the port
37: * number that we're listening on.
38: * 2) The receiver connects to the sender on the given IP address
39: * and port. After the connection is established, the receiver
40: * sends an ICBM signifying that we are ready and waiting.
41: * 3) The sender sends an OFT PROMPT message over the OFT
42: * connection.
43: * 4) The receiver of the file sends back an exact copy of this
44: * OFT packet, except the cookie is filled in with the cookie
45: * from the ICBM. I think this might be an attempt to verify
46: * that the user that is connected is actually the guy that
47: * we sent the ICBM to. Oh, I've been calling this the ACK.
48: * 5) The sender starts sending raw data across the connection
49: * until the entire file has been sent.
50: * 6) The receiver knows the file is finished because the sender
51: * sent the file size in an earlier OFT packet. So then the
52: * receiver sends the DONE thingy (after filling in the
53: * "received" checksum and size) and closes the connection.
54: */
55:
56: #include "oscar.h"
57: #include "peer.h"
58: #include <glib/gstdio.h>
59: #include "util.h"
60:
61: #define CHECKSUM_BUFFER_SIZE 256 * 1024
62:
63: struct _ChecksumData
64: {
65: PeerConnection *conn;
66: PurpleXfer *xfer;
67: GSourceFunc callback;
68: size_t size;
69: guint32 checksum;
70: size_t total;
71: FILE *file;
72: guint8 buffer[CHECKSUM_BUFFER_SIZE];
73: guint timer;
74: };
75:
76: void
77: peer_oft_checksum_destroy(ChecksumData *checksum_data)
78: {
79: checksum_data->conn->checksum_data = NULL;
80: fclose(checksum_data->file);
81: if (checksum_data->timer > 0)
82: purple_timeout_remove(checksum_data->timer);
83: g_free(checksum_data);
84: }
85:
86: /**
87: * Calculate oft checksum of buffer
88: *
89: * Prevcheck should be 0xFFFF0000 when starting a checksum of a file. The
90: * checksum is kind of a rolling checksum thing, so each time you get bytes
91: * of a file you just call this puppy and it updates the checksum. You can
92: * calculate the checksum of an entire file by calling this in a while or a
93: * for loop, or something.
94: *
95: * Thanks to Graham Booker for providing this improved checksum routine,
96: * which is simpler and should be more accurate than Josh Myer's original
97: * code. -- wtm
98: *
99: * This algorithm works every time I have tried it. The other fails
100: * sometimes. So, AOL who thought this up? It has got to be the weirdest
101: * checksum I have ever seen.
102: *
103: * @param buffer Buffer of data to checksum. Man I'd like to buff her...
104: * @param bufsize Size of buffer.
105: * @param prevchecksum Previous checksum.
106: * @param odd Whether an odd number of bytes have been processed before this call
107: */
108: static guint32
109: peer_oft_checksum_chunk(const guint8 *buffer, int bufferlen, guint32 prevchecksum, int odd)
110: {
111: guint32 checksum, oldchecksum;
112: int i = 0;
113: unsigned short val;
114:
115: checksum = (prevchecksum >> 16) & 0xffff;
116: if (odd)
117: {
118: /*
119: * This is one hell of a hack, but it should always work.
120: * Essentially, I am reindexing the array so that index 1
121: * is the first element. Since the odd and even bytes are
122: * detected by the index number.
123: */
124: i = 1;
125: bufferlen++;
126: buffer--;
127: }
128: for (; i < bufferlen; i++)
129: {
130: oldchecksum = checksum;
131: if (i & 1)
132: val = buffer[i];
133: else
134: val = buffer[i] << 8;
135: checksum -= val;
136: /*
137: * The following appears to be necessary.... It happens
138: * every once in a while and the checksum doesn't fail.
139: */
140: if (checksum > oldchecksum)
141: checksum--;
142: }
143: checksum = ((checksum & 0x0000ffff) + (checksum >> 16));
144: checksum = ((checksum & 0x0000ffff) + (checksum >> 16));
145: return checksum << 16;
146: }
147:
148: static gboolean
149: peer_oft_checksum_file_piece(gpointer data)
150: {
151: ChecksumData *checksum_data;
152: gboolean repeat;
153:
154: checksum_data = data;
155: repeat = FALSE;
156:
157: if (checksum_data->total < checksum_data->size)
158: {
159: size_t bytes = MIN(CHECKSUM_BUFFER_SIZE,
160: checksum_data->size - checksum_data->total);
161:
162: bytes = fread(checksum_data->buffer, 1, bytes, checksum_data->file);
163: if (bytes != 0)
164: {
165: checksum_data->checksum = peer_oft_checksum_chunk(checksum_data->buffer, bytes, checksum_data->checksum, checksum_data->total & 1);
166: checksum_data->total += bytes;
167: repeat = TRUE;
168: }
169: }
170:
171: if (!repeat)
172: {
173: purple_debug_info("oscar", "Checksum of %s calculated\n",
174: purple_xfer_get_local_filename(checksum_data->xfer));
175: if (checksum_data->callback != NULL)
176: checksum_data->callback(checksum_data);
177: peer_oft_checksum_destroy(checksum_data);
178: }
179:
180: return repeat;
181: }
182:
183: /**
184: * Calculate oft checksum of a file in a series of calls to
185: * peer_oft_checksum_file_piece(). We do it this way because
186: * calculating the checksum on large files can take a long time,
187: * and we want to return control to the UI so that the application
188: * doesn't appear completely frozen.
189: *
190: * @param conn The connection used for this file transfer.
191: * @param xfer The file transfer needing this checksum.
192: * @param callback The function to call upon calculation of the checksum.
193: * @param size The maximum size to check.
194: */
195:
196: static void
197: peer_oft_checksum_file(PeerConnection *conn, PurpleXfer *xfer, GSourceFunc callback, size_t size)
198: {
199: ChecksumData *checksum_data;
200:
201: purple_debug_info("oscar", "Calculating checksum of %s\n",
202: purple_xfer_get_local_filename(xfer));
203:
204: checksum_data = g_malloc0(sizeof(ChecksumData));
205: checksum_data->conn = conn;
206: checksum_data->xfer = xfer;
207: checksum_data->callback = callback;
208: checksum_data->size = size;
209: checksum_data->checksum = 0xffff0000;
210: checksum_data->file = g_fopen(purple_xfer_get_local_filename(xfer), "rb");
211:
212: if (checksum_data->file == NULL)
213: {
214: purple_debug_error("oscar", "Unable to open %s for checksumming: %s\n",
215: purple_xfer_get_local_filename(xfer), g_strerror(errno));
216: callback(checksum_data);
217: g_free(checksum_data);
218: }
219: else
220: {
221: checksum_data->timer = purple_timeout_add(10,
222: peer_oft_checksum_file_piece, checksum_data);
223: conn->checksum_data = checksum_data;
224: }
225: }
226:
227: static void
228: peer_oft_copy_xfer_data(PeerConnection *conn, OftFrame *frame)
229: {
230: g_free(conn->xferdata.name);
231:
232: memcpy(&(conn->xferdata), frame, sizeof(OftFrame));
233: conn->xferdata.name = g_memdup(frame->name, frame->name_length);
234: }
235:
236: /**
237: * Free any OFT related data.
238: */
239: void
240: peer_oft_close(PeerConnection *conn)
241: {
242: /*
243: * If cancelled by local user, and we're receiving a file, and
244: * we're not connected/ready then send an ICBM cancel message.
245: */
246: if ((purple_xfer_get_status(conn->xfer) == PURPLE_XFER_STATUS_CANCEL_LOCAL) &&
247: !conn->ready)
248: {
249: aim_im_sendch2_cancel(conn);
250: }
251:
252: if (conn->sending_data_timer != 0)
253: {
254: purple_timeout_remove(conn->sending_data_timer);
255: conn->sending_data_timer = 0;
256: }
257: }
258:
259: /**
260: * Write the given OftFrame to a ByteStream and send it out
261: * on the established PeerConnection.
262: */
263: static void
264: peer_oft_send(PeerConnection *conn, OftFrame *frame)
265: {
266: size_t length;
267: ByteStream bs;
268:
269: length = 192 + frame->name_length;
270: byte_stream_new(&bs, length);
271: byte_stream_putraw(&bs, conn->magic, 4);
272: byte_stream_put16(&bs, length);
273: byte_stream_put16(&bs, frame->type);
274: byte_stream_putraw(&bs, frame->cookie, 8);
275: byte_stream_put16(&bs, frame->encrypt);
276: byte_stream_put16(&bs, frame->compress);
277: byte_stream_put16(&bs, frame->totfiles);
278: byte_stream_put16(&bs, frame->filesleft);
279: byte_stream_put16(&bs, frame->totparts);
280: byte_stream_put16(&bs, frame->partsleft);
281: byte_stream_put32(&bs, frame->totsize);
282: byte_stream_put32(&bs, frame->size);
283: byte_stream_put32(&bs, frame->modtime);
284: byte_stream_put32(&bs, frame->checksum);
285: byte_stream_put32(&bs, frame->rfrcsum);
286: byte_stream_put32(&bs, frame->rfsize);
287: byte_stream_put32(&bs, frame->cretime);
288: byte_stream_put32(&bs, frame->rfcsum);
289: byte_stream_put32(&bs, frame->nrecvd);
290: byte_stream_put32(&bs, frame->recvcsum);
291: byte_stream_putraw(&bs, frame->idstring, 32);
292: byte_stream_put8(&bs, frame->flags);
293: byte_stream_put8(&bs, frame->lnameoffset);
294: byte_stream_put8(&bs, frame->lsizeoffset);
295: byte_stream_putraw(&bs, frame->dummy, 69);
296: byte_stream_putraw(&bs, frame->macfileinfo, 16);
297: byte_stream_put16(&bs, frame->nencode);
298: byte_stream_put16(&bs, frame->nlanguage);
299: /*
300: * The name can be more than 64 characters, but if it is less than
301: * 64 characters it is padded with NULLs.
302: */
303: byte_stream_putraw(&bs, frame->name, frame->name_length);
304:
305: peer_connection_send(conn, &bs);
306:
307: byte_stream_destroy(&bs);
308: }
309:
310: void
311: peer_oft_send_prompt(PeerConnection *conn)
312: {
313: conn->xferdata.type = PEER_TYPE_PROMPT;
314: peer_oft_send(conn, &conn->xferdata);
315: }
316:
317: static void
318: peer_oft_send_ack(PeerConnection *conn)
319: {
320: conn->xferdata.type = PEER_TYPE_ACK;
321:
322: /* Fill in the cookie */
323: memcpy(conn->xferdata.cookie, conn->cookie, 8);
324:
325: peer_oft_send(conn, &conn->xferdata);
326: }
327:
328: static void
329: peer_oft_send_resume_accept(PeerConnection *conn)
330: {
331: conn->xferdata.type = PEER_TYPE_RESUMEACCEPT;
332:
333: /* Fill in the cookie */
334: memcpy(conn->xferdata.cookie, conn->cookie, 8);
335:
336: peer_oft_send(conn, &conn->xferdata);
337: }
338:
339: static void
340: peer_oft_send_done(PeerConnection *conn)
341: {
342: conn->xferdata.type = PEER_TYPE_DONE;
343: conn->xferdata.rfrcsum = 0xffff0000;
344: conn->xferdata.nrecvd = purple_xfer_get_bytes_sent(conn->xfer);
345: peer_oft_send(conn, &conn->xferdata);
346: }
347:
348: /**
349: * This function exists so that we don't remove the outgoing
350: * data watcher while we're still sending data. In most cases
351: * any data we're sending will be instantly wisked away to a TCP
352: * buffer maintained by our operating system... but we want to
353: * make sure the core doesn't start sending file data while
354: * we're still sending OFT frame data. That would be bad.
355: */
356: static gboolean
357: start_transfer_when_done_sending_data(gpointer data)
358: {
359: PeerConnection *conn;
360:
361: conn = data;
362:
363: if (purple_circ_buffer_get_max_read(conn->buffer_outgoing) == 0)
364: {
365: conn->sending_data_timer = 0;
366: conn->xfer->fd = conn->fd;
367: conn->fd = -1;
368: purple_xfer_start(conn->xfer, conn->xfer->fd, NULL, 0);
369: return FALSE;
370: }
371:
372: return TRUE;
373: }
374:
375: /**
376: * This function is similar to the above function, except instead
377: * of starting the xfer it will destroy the connection. This is
378: * used when you want to send one final message across the peer
379: * connection, and then close everything.
380: */
381: static gboolean
382: destroy_connection_when_done_sending_data(gpointer data)
383: {
384: PeerConnection *conn;
385:
386: conn = data;
387:
388: if (purple_circ_buffer_get_max_read(conn->buffer_outgoing) == 0)
389: {
390: conn->sending_data_timer = 0;
391: peer_connection_destroy(conn, conn->disconnect_reason, NULL);
392: return FALSE;
393: }
394:
395: return TRUE;
396: }
397:
398: /*
399: * This is called when a buddy sends us some file info. This happens when they
400: * are sending a file to you, and you have just established a connection to them.
401: * You should send them the exact same info except use the real cookie. We also
402: * get like totally ready to like, receive the file, kay?
403: */
404: static void
405: peer_oft_recv_frame_prompt(PeerConnection *conn, OftFrame *frame)
406: {
407: /* Record the file information and send an ack */
408: peer_oft_copy_xfer_data(conn, frame);
409: peer_oft_send_ack(conn);
410:
411: /* Remove our watchers and use the file transfer watchers in the core */
412: purple_input_remove(conn->watcher_incoming);
413: conn->watcher_incoming = 0;
414: conn->sending_data_timer = purple_timeout_add(100,
415: start_transfer_when_done_sending_data, conn);
416: }
417:
418: /**
419: * We are sending a file to someone else. They have just acknowledged our
420: * prompt, so we want to start sending data like there's no tomorrow.
421: */
422: static void
423: peer_oft_recv_frame_ack(PeerConnection *conn, OftFrame *frame)
424: {
425: if (memcmp(conn->cookie, frame->cookie, 8) != 0)
426: {
427: purple_debug_info("oscar", "Received an incorrect cookie. "
428: "Closing connection.\n");
429: peer_connection_destroy(conn, OSCAR_DISCONNECT_INVALID_DATA, NULL);
430: return;
431: }
432:
433: /* Remove our watchers and use the file transfer watchers in the core */
434: purple_input_remove(conn->watcher_incoming);
435: conn->watcher_incoming = 0;
436: conn->sending_data_timer = purple_timeout_add(100,
437: start_transfer_when_done_sending_data, conn);
438: }
439:
440: static gboolean
441: peer_oft_recv_frame_resume_checksum_calculated_cb(gpointer data)
442: {
443: ChecksumData *checksum_data;
444: PeerConnection *conn;
445:
446: checksum_data = data;
447: conn = checksum_data->conn;
448:
449: /* Check the checksums here. If not match, don't allow resume */
450: if (checksum_data->checksum != conn->xferdata.recvcsum || checksum_data->total != conn->xferdata.nrecvd)
451: {
452: /* Reset internal structure */
453: conn->xferdata.recvcsum = 0xffff0000;
454: conn->xferdata.rfrcsum = 0xffff0000;
455: conn->xferdata.nrecvd = 0;
456: }
457: else
458: /* Accept the change */
459: purple_xfer_set_bytes_sent(checksum_data->xfer, conn->xferdata.nrecvd);
460:
461: peer_oft_send_resume_accept(conn);
462:
463: return FALSE;
464: }
465:
466: /**
467: * We are sending a file to someone else. They have just acknowledged our
468: * prompt and are asking to resume, so we accept their resume and await
469: * a resume ack.
470: */
471: static void
472: peer_oft_recv_frame_resume(PeerConnection *conn, OftFrame *frame)
473: {
474: if (memcmp(conn->cookie, frame->cookie, 8) != 0)
475: {
476: purple_debug_info("oscar", "Received an incorrect cookie. "
477: "Closing connection.\n");
478: peer_connection_destroy(conn, OSCAR_DISCONNECT_INVALID_DATA, NULL);
479: return;
480: }
481:
482: /* Copy resume data into internal structure */
483: conn->xferdata.recvcsum = frame->recvcsum;
484: conn->xferdata.rfrcsum = frame->rfrcsum;
485: conn->xferdata.nrecvd = frame->nrecvd;
486:
487: peer_oft_checksum_file(conn, conn->xfer,
488: peer_oft_recv_frame_resume_checksum_calculated_cb,
489: frame->nrecvd);
490: }
491:
492: /*
493: * We just sent a file to someone. They said they got it and everything,
494: * so we can close our direct connection and what not.
495: */
496: static void
497: peer_oft_recv_frame_done(PeerConnection *conn, OftFrame *frame)
498: {
499: /*
500: * The core ft code sets the xfer to completed automatically if we've
501: * sent all bytes to the other user. But this function can be called
502: * even if we haven't sent all bytes to the other user (in the case
503: * where the user already has this file on their computer and the
504: * checksum matches).
505: */
506: if (!purple_xfer_is_completed(conn->xfer))
507: purple_xfer_set_completed(conn->xfer, TRUE);
508:
509: purple_input_remove(conn->watcher_incoming);
510: conn->watcher_incoming = 0;
511: conn->xfer->fd = conn->fd;
512: conn->fd = -1;
513: conn->disconnect_reason = OSCAR_DISCONNECT_DONE;
514: peer_connection_schedule_destroy(conn, conn->disconnect_reason, NULL);
515: }
516:
517: /**
518: * Handle an incoming OftFrame. If there is a payload associated
519: * with this frame, then we remove the old watcher and add the
520: * OFT watcher to read in the payload.
521: */
522: void
523: peer_oft_recv_frame(PeerConnection *conn, ByteStream *bs)
524: {
525: OftFrame frame;
526:
527: frame.type = byte_stream_get16(bs);
528: byte_stream_getrawbuf(bs, frame.cookie, 8);
529: frame.encrypt = byte_stream_get16(bs);
530: frame.compress = byte_stream_get16(bs);
531: frame.totfiles = byte_stream_get16(bs);
532: frame.filesleft = byte_stream_get16(bs);
533: frame.totparts = byte_stream_get16(bs);
534: frame.partsleft = byte_stream_get16(bs);
535: frame.totsize = byte_stream_get32(bs);
536: frame.size = byte_stream_get32(bs);
537: frame.modtime = byte_stream_get32(bs);
538: frame.checksum = byte_stream_get32(bs);
539: frame.rfrcsum = byte_stream_get32(bs);
540: frame.rfsize = byte_stream_get32(bs);
541: frame.cretime = byte_stream_get32(bs);
542: frame.rfcsum = byte_stream_get32(bs);
543: frame.nrecvd = byte_stream_get32(bs);
544: frame.recvcsum = byte_stream_get32(bs);
545: byte_stream_getrawbuf(bs, frame.idstring, 32);
546: frame.flags = byte_stream_get8(bs);
547: frame.lnameoffset = byte_stream_get8(bs);
548: frame.lsizeoffset = byte_stream_get8(bs);
549: byte_stream_getrawbuf(bs, frame.dummy, 69);
550: byte_stream_getrawbuf(bs, frame.macfileinfo, 16);
551: frame.nencode = byte_stream_get16(bs);
552: frame.nlanguage = byte_stream_get16(bs);
553: frame.name_length = bs->len - 186;
554: frame.name = byte_stream_getraw(bs, frame.name_length);
555:
556: purple_debug_info("oscar", "Incoming OFT frame from %s with "
557: "type=0x%04x\n", conn->bn, frame.type);
558:
559: /* TODOFT: peer_oft_dirconvert_fromstupid(frame->name); */
560:
561: switch(frame.type)
562: {
563: case PEER_TYPE_PROMPT:
564: peer_oft_recv_frame_prompt(conn, &frame);
565: break;
566: case PEER_TYPE_ACK:
567: case PEER_TYPE_RESUMEACK:
568: peer_oft_recv_frame_ack(conn, &frame);
569: break;
570: case PEER_TYPE_RESUME:
571: peer_oft_recv_frame_resume(conn, &frame);
572: break;
573: case PEER_TYPE_DONE:
574: peer_oft_recv_frame_done(conn, &frame);
575: break;
576: default:
577: break;
578: }
579:
580: g_free(frame.name);
581: }
582:
583: /*******************************************************************/
584: /* Begin PurpleXfer callbacks for use when receiving a file */
585: /*******************************************************************/
586:
587: void
588: peer_oft_recvcb_init(PurpleXfer *xfer)
589: {
590: PeerConnection *conn;
591:
592: conn = xfer->data;
593: conn->flags |= PEER_CONNECTION_FLAG_APPROVED;
594: peer_connection_trynext(conn);
595: }
596:
597: void
598: peer_oft_recvcb_end(PurpleXfer *xfer)
599: {
600: PeerConnection *conn;
601:
602: conn = xfer->data;
603:
604: /* Tell the other person that we've received everything */
605: conn->fd = conn->xfer->fd;
606: conn->xfer->fd = -1;
607: peer_oft_send_done(conn);
608:
609: conn->disconnect_reason = OSCAR_DISCONNECT_DONE;
610: conn->sending_data_timer = purple_timeout_add(100,
611: destroy_connection_when_done_sending_data, conn);
612: }
613:
614: void
615: peer_oft_recvcb_ack_recv(PurpleXfer *xfer, const guchar *buffer, size_t size)
616: {
617: PeerConnection *conn;
618:
619: /* Update our rolling checksum. Like Walmart, yo. */
620: conn = xfer->data;
621: conn->xferdata.recvcsum = peer_oft_checksum_chunk(buffer,
622: size, conn->xferdata.recvcsum, purple_xfer_get_bytes_sent(xfer) & 1);
623: }
624:
625: /*******************************************************************/
626: /* End PurpleXfer callbacks for use when receiving a file */
627: /*******************************************************************/
628:
629: /*******************************************************************/
630: /* Begin PurpleXfer callbacks for use when sending a file */
631: /*******************************************************************/
632:
633: static gboolean
634: peer_oft_checksum_calculated_cb(gpointer data)
635: {
636: ChecksumData *checksum_data;
637: PeerConnection *conn;
638:
639: checksum_data = data;
640: conn = checksum_data->conn;
641:
642: conn->xferdata.checksum = checksum_data->checksum;
643:
644: /* Start the connection process */
645: peer_connection_trynext(checksum_data->conn);
646:
647: return FALSE;
648: }
649:
650: void
651: peer_oft_sendcb_init(PurpleXfer *xfer)
652: {
653: PeerConnection *conn;
654: size_t size;
655:
656: conn = xfer->data;
657: conn->flags |= PEER_CONNECTION_FLAG_APPROVED;
658:
659: /* Make sure the file size can be represented in 32 bits */
660: size = purple_xfer_get_size(xfer);
661: if (size > G_MAXUINT32)
662: {
663: gchar *tmp, *size1, *size2;
664: size1 = purple_str_size_to_units(size);
665: size2 = purple_str_size_to_units(G_MAXUINT32);
666: tmp = g_strdup_printf(_("File %s is %s, which is larger than "
667: "the maximum size of %s."),
668: xfer->local_filename, size1, size2);
669: purple_xfer_error(purple_xfer_get_type(xfer),
670: purple_xfer_get_account(xfer), xfer->who, tmp);
671: g_free(size1);
672: g_free(size2);
673: g_free(tmp);
674: peer_connection_destroy(conn, OSCAR_DISCONNECT_LOCAL_CLOSED, NULL);
675: return;
676: }
677:
678: /* Keep track of file transfer info */
679: conn->xferdata.totfiles = 1;
680: conn->xferdata.filesleft = 1;
681: conn->xferdata.totparts = 1;
682: conn->xferdata.partsleft = 1;
683: conn->xferdata.totsize = size;
684: conn->xferdata.size = size;
685: conn->xferdata.checksum = 0xffff0000;
686: conn->xferdata.rfrcsum = 0xffff0000;
687: conn->xferdata.rfcsum = 0xffff0000;
688: conn->xferdata.recvcsum = 0xffff0000;
689: strncpy((gchar *)conn->xferdata.idstring, "Cool FileXfer", 31);
690: conn->xferdata.modtime = 0;
691: conn->xferdata.cretime = 0;
692: xfer->filename = g_path_get_basename(xfer->local_filename);
693: conn->xferdata.name_length = MAX(64, strlen(xfer->filename) + 1);
694: conn->xferdata.name = (guchar *)g_strndup(xfer->filename, conn->xferdata.name_length - 1);
695:
696: peer_oft_checksum_file(conn, xfer,
697: peer_oft_checksum_calculated_cb, G_MAXUINT32);
698: }
699:
700: /*
701: * AIM file transfers aren't really meant to be thought
702: * of as a transferring just a single file. The rendezvous
703: * establishes a connection between two computers, and then
704: * those computers can use the same connection for transferring
705: * multiple files. So we don't want the Purple core up and closing
706: * the socket all willy-nilly. We want to do that in the oscar
707: * prpl, whenever one side or the other says they're finished
708: * using the connection. There might be a better way to intercept
709: * the socket from the core...
710: */
711: void
712: peer_oft_sendcb_ack(PurpleXfer *xfer, const guchar *buffer, size_t size)
713: {
714: PeerConnection *conn;
715:
716: conn = xfer->data;
717:
718: /*
719: * If we're done sending, intercept the socket from the core ft code
720: * and wait for the other guy to send the "done" OFT packet.
721: */
722: if (purple_xfer_get_bytes_remaining(xfer) <= 0)
723: {
724: purple_input_remove(xfer->watcher);
725: conn->fd = xfer->fd;
726: xfer->fd = -1;
727: conn->watcher_incoming = purple_input_add(conn->fd,
728: PURPLE_INPUT_READ, peer_connection_recv_cb, conn);
729: }
730: }
731:
732: /*******************************************************************/
733: /* End PurpleXfer callbacks for use when sending a file */
734: /*******************************************************************/
735:
736: /*******************************************************************/
737: /* Begin PurpleXfer callbacks for use when sending and receiving */
738: /*******************************************************************/
739:
740: void
741: peer_oft_cb_generic_cancel(PurpleXfer *xfer)
742: {
743: PeerConnection *conn;
744:
745: conn = xfer->data;
746:
747: if (conn == NULL)
748: return;
749:
750: peer_connection_destroy(conn, OSCAR_DISCONNECT_LOCAL_CLOSED, NULL);
751: }
752:
753: /*******************************************************************/
754: /* End PurpleXfer callbacks for use when sending and receiving */
755: /*******************************************************************/
756:
757: #ifdef TODOFT
758: /*
759: * This little area in oscar.c is the nexus of file transfer code,
760: * so I wrote a little explanation of what happens. I am such a
761: * ninja.
762: *
763: * The series of events for a file send is:
764: * -Create xfer and call purple_xfer_request (this happens in oscar_ask_sendfile)
765: * -User chooses a file and oscar_xfer_init is called. It establishes a
766: * listening socket, then asks the remote user to connect to us (and
767: * gives them the file name, port, IP, etc.)
768: * -They connect to us and we send them an PEER_TYPE_PROMPT (this happens
769: * in peer_oft_recv_frame_established)
770: * -They send us an PEER_TYPE_ACK and then we start sending data
771: * -When we finish, they send us an PEER_TYPE_DONE and they close the
772: * connection.
773: * -We get drunk because file transfer kicks ass.
774: *
775: * The series of events for a file receive is:
776: * -Create xfer and call purple_xfer request (this happens in incomingim_chan2)
777: * -Purple user selects file to name and location to save file to and
778: * oscar_xfer_init is called
779: * -It connects to the remote user using the IP they gave us earlier
780: * -After connecting, they send us an PEER_TYPE_PROMPT. In reply, we send
781: * them an PEER_TYPE_ACK.
782: * -They begin to send us lots of raw data.
783: * -When they finish sending data we send an PEER_TYPE_DONE and then close
784: * the connection.
785: *
786: * Update August 2005:
787: * The series of events for transfers has been seriously complicated by the addition
788: * of transfer redirects and proxied connections. I could throw a whole lot of words
789: * at trying to explain things here, but it probably wouldn't do much good. To get
790: * a better idea of what happens, take a look at the diagrams and documentation
791: * from my Summer of Code project. -- Jonathan Clark
792: */
793:
794: /**
795: * Convert the directory separator from / (0x2f) to ^A (0x01)
796: *
797: * @param name The filename to convert.
798: */
799: static void
800: peer_oft_dirconvert_tostupid(char *name)
801: {
802: while (name[0]) {
803: if (name[0] == 0x01)
804: name[0] = G_DIR_SEPARATOR;
805: name++;
806: }
807: }
808:
809: /**
810: * Convert the directory separator from ^A (0x01) to / (0x2f)
811: *
812: * @param name The filename to convert.
813: */
814: static void
815: peer_oft_dirconvert_fromstupid(char *name)
816: {
817: while (name[0]) {
818: if (name[0] == G_DIR_SEPARATOR)
819: name[0] = 0x01;
820: name++;
821: }
822: }
823: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to oft.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