14192
|
1 /*
|
|
2 * Gaim'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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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
|
14538
|
59 #include "util.h"
|
|
60
|
14192
|
61 /**
|
|
62 * Calculate oft checksum of buffer
|
|
63 *
|
|
64 * Prevcheck should be 0xFFFF0000 when starting a checksum of a file. The
|
|
65 * checksum is kind of a rolling checksum thing, so each time you get bytes
|
|
66 * of a file you just call this puppy and it updates the checksum. You can
|
|
67 * calculate the checksum of an entire file by calling this in a while or a
|
|
68 * for loop, or something.
|
|
69 *
|
|
70 * Thanks to Graham Booker for providing this improved checksum routine,
|
|
71 * which is simpler and should be more accurate than Josh Myer's original
|
|
72 * code. -- wtm
|
|
73 *
|
|
74 * This algorithm works every time I have tried it. The other fails
|
|
75 * sometimes. So, AOL who thought this up? It has got to be the weirdest
|
|
76 * checksum I have ever seen.
|
|
77 *
|
|
78 * @param buffer Buffer of data to checksum. Man I'd like to buff her...
|
|
79 * @param bufsize Size of buffer.
|
|
80 * @param prevchecksum Previous checksum.
|
|
81 */
|
|
82 static guint32
|
|
83 peer_oft_checksum_chunk(const guint8 *buffer, int bufferlen, guint32 prevchecksum)
|
|
84 {
|
|
85 guint32 checksum, oldchecksum;
|
|
86 int i;
|
|
87 unsigned short val;
|
|
88
|
|
89 checksum = (prevchecksum >> 16) & 0xffff;
|
|
90 for (i = 0; i < bufferlen; i++)
|
|
91 {
|
|
92 oldchecksum = checksum;
|
|
93 if (i & 1)
|
|
94 val = buffer[i];
|
|
95 else
|
|
96 val = buffer[i] << 8;
|
|
97 checksum -= val;
|
|
98 /*
|
|
99 * The following appears to be necessary.... It happens
|
|
100 * every once in a while and the checksum doesn't fail.
|
|
101 */
|
|
102 if (checksum > oldchecksum)
|
|
103 checksum--;
|
|
104 }
|
|
105 checksum = ((checksum & 0x0000ffff) + (checksum >> 16));
|
|
106 checksum = ((checksum & 0x0000ffff) + (checksum >> 16));
|
|
107 return checksum << 16;
|
|
108 }
|
|
109
|
|
110 static guint32
|
|
111 peer_oft_checksum_file(char *filename)
|
|
112 {
|
|
113 FILE *fd;
|
|
114 guint32 checksum = 0xffff0000;
|
|
115
|
|
116 if ((fd = fopen(filename, "rb")))
|
|
117 {
|
|
118 int bytes;
|
|
119 guint8 buffer[1024];
|
|
120
|
|
121 while ((bytes = fread(buffer, 1, 1024, fd)) != 0)
|
|
122 checksum = peer_oft_checksum_chunk(buffer, bytes, checksum);
|
|
123 fclose(fd);
|
|
124 }
|
|
125
|
|
126 return checksum;
|
|
127 }
|
|
128
|
|
129 /**
|
|
130 * Free any OFT related data.
|
|
131 */
|
|
132 void
|
|
133 peer_oft_close(PeerConnection *conn)
|
|
134 {
|
|
135 /*
|
|
136 * If canceled by local user, and we're receiving a file, and
|
|
137 * we're not connected/ready then send an ICBM cancel message.
|
|
138 */
|
|
139 if ((gaim_xfer_get_status(conn->xfer) == GAIM_XFER_STATUS_CANCEL_LOCAL) &&
|
|
140 !conn->ready)
|
|
141 {
|
|
142 aim_im_sendch2_cancel(conn);
|
|
143 }
|
|
144
|
|
145 if (conn->sending_data_timer != 0)
|
|
146 {
|
|
147 gaim_timeout_remove(conn->sending_data_timer);
|
|
148 conn->sending_data_timer = 0;
|
|
149 }
|
|
150 }
|
|
151
|
|
152 /**
|
|
153 * Write the given OftFrame to a ByteStream and send it out
|
|
154 * on the established PeerConnection.
|
|
155 */
|
|
156 static void
|
|
157 peer_oft_send(PeerConnection *conn, OftFrame *frame)
|
|
158 {
|
|
159 size_t length;
|
|
160 ByteStream bs;
|
|
161
|
|
162 length = 192 + MAX(64, frame->name_length + 1);
|
|
163 byte_stream_init(&bs, malloc(length), length);
|
|
164 byte_stream_putraw(&bs, conn->magic, 4);
|
|
165 byte_stream_put16(&bs, length);
|
|
166 byte_stream_put16(&bs, frame->type);
|
|
167 byte_stream_putraw(&bs, frame->cookie, 8);
|
|
168 byte_stream_put16(&bs, frame->encrypt);
|
|
169 byte_stream_put16(&bs, frame->compress);
|
|
170 byte_stream_put16(&bs, frame->totfiles);
|
|
171 byte_stream_put16(&bs, frame->filesleft);
|
|
172 byte_stream_put16(&bs, frame->totparts);
|
|
173 byte_stream_put16(&bs, frame->partsleft);
|
|
174 byte_stream_put32(&bs, frame->totsize);
|
|
175 byte_stream_put32(&bs, frame->size);
|
|
176 byte_stream_put32(&bs, frame->modtime);
|
|
177 byte_stream_put32(&bs, frame->checksum);
|
|
178 byte_stream_put32(&bs, frame->rfrcsum);
|
|
179 byte_stream_put32(&bs, frame->rfsize);
|
|
180 byte_stream_put32(&bs, frame->cretime);
|
|
181 byte_stream_put32(&bs, frame->rfcsum);
|
|
182 byte_stream_put32(&bs, frame->nrecvd);
|
|
183 byte_stream_put32(&bs, frame->recvcsum);
|
|
184 byte_stream_putraw(&bs, frame->idstring, 32);
|
|
185 byte_stream_put8(&bs, frame->flags);
|
|
186 byte_stream_put8(&bs, frame->lnameoffset);
|
|
187 byte_stream_put8(&bs, frame->lsizeoffset);
|
|
188 byte_stream_putraw(&bs, frame->dummy, 69);
|
|
189 byte_stream_putraw(&bs, frame->macfileinfo, 16);
|
|
190 byte_stream_put16(&bs, frame->nencode);
|
|
191 byte_stream_put16(&bs, frame->nlanguage);
|
|
192 /*
|
|
193 * The name can be more than 64 characters, but if it is less than
|
|
194 * 64 characters it is padded with NULLs.
|
|
195 */
|
|
196 byte_stream_putraw(&bs, frame->name, MAX(64, frame->name_length + 1));
|
|
197
|
|
198 peer_connection_send(conn, &bs);
|
|
199
|
|
200 free(bs.data);
|
|
201 }
|
|
202
|
|
203 void
|
|
204 peer_oft_send_prompt(PeerConnection *conn)
|
|
205 {
|
|
206 conn->xferdata.type = PEER_TYPE_PROMPT;
|
|
207 peer_oft_send(conn, &conn->xferdata);
|
|
208 }
|
|
209
|
|
210 static void
|
|
211 peer_oft_send_ack(PeerConnection *conn)
|
|
212 {
|
|
213 conn->xferdata.type = PEER_TYPE_ACK;
|
|
214
|
|
215 /* Fill in the cookie */
|
|
216 memcpy(conn->xferdata.cookie, conn->cookie, 8);
|
|
217
|
|
218 peer_oft_send(conn, &conn->xferdata);
|
|
219 }
|
|
220
|
|
221 static void
|
|
222 peer_oft_send_done(PeerConnection *conn)
|
|
223 {
|
|
224 conn->xferdata.type = PEER_TYPE_DONE;
|
|
225 conn->xferdata.filesleft = 0;
|
|
226 conn->xferdata.partsleft = 0;
|
|
227 conn->xferdata.nrecvd = gaim_xfer_get_bytes_sent(conn->xfer);
|
|
228 peer_oft_send(conn, &conn->xferdata);
|
|
229 }
|
|
230
|
|
231 /**
|
|
232 * This function exists so that we don't remove the outgoing
|
|
233 * data watcher while we're still sending data. In most cases
|
|
234 * any data we're sending will be instantly wisked away to a TCP
|
|
235 * buffer maintained by our operating system... but we want to
|
|
236 * make sure the core doesn't start sending file data while
|
|
237 * we're still sending OFT frame data. That would be bad.
|
|
238 */
|
|
239 static gboolean
|
|
240 start_transfer_when_done_sending_data(gpointer data)
|
|
241 {
|
|
242 PeerConnection *conn;
|
|
243
|
|
244 conn = data;
|
|
245
|
|
246 if (gaim_circ_buffer_get_max_read(conn->buffer_outgoing) == 0)
|
|
247 {
|
|
248 conn->sending_data_timer = 0;
|
|
249 conn->xfer->fd = conn->fd;
|
|
250 conn->fd = -1;
|
|
251 gaim_xfer_start(conn->xfer, conn->xfer->fd, NULL, 0);
|
|
252 return FALSE;
|
|
253 }
|
|
254
|
|
255 return TRUE;
|
|
256 }
|
|
257
|
|
258 /**
|
|
259 * This function is similar to the above function, except instead
|
|
260 * of starting the xfer it will destroy the connection. This is
|
|
261 * used when you want to send one final message across the peer
|
|
262 * connection, and then close everything.
|
|
263 */
|
|
264 static gboolean
|
|
265 destroy_connection_when_done_sending_data(gpointer data)
|
|
266 {
|
|
267 PeerConnection *conn;
|
|
268
|
|
269 conn = data;
|
|
270
|
|
271 if (gaim_circ_buffer_get_max_read(conn->buffer_outgoing) == 0)
|
|
272 {
|
|
273 conn->sending_data_timer = 0;
|
14402
|
274 peer_connection_destroy(conn, conn->disconnect_reason, NULL);
|
14192
|
275 return FALSE;
|
|
276 }
|
|
277
|
|
278 return TRUE;
|
|
279 }
|
|
280
|
|
281 /*
|
|
282 * This is called when a buddy sends us some file info. This happens when they
|
|
283 * are sending a file to you, and you have just established a connection to them.
|
|
284 * You should send them the exact same info except use the real cookie. We also
|
|
285 * get like totally ready to like, receive the file, kay?
|
|
286 */
|
|
287 static void
|
|
288 peer_oft_recv_frame_prompt(PeerConnection *conn, OftFrame *frame)
|
|
289 {
|
|
290 /* Record the file information and send an ack */
|
|
291 memcpy(&conn->xferdata, frame, sizeof(OftFrame));
|
|
292 peer_oft_send_ack(conn);
|
|
293
|
|
294 /* Remove our watchers and use the file transfer watchers in the core */
|
|
295 gaim_input_remove(conn->watcher_incoming);
|
|
296 conn->watcher_incoming = 0;
|
|
297 conn->sending_data_timer = gaim_timeout_add(100,
|
|
298 start_transfer_when_done_sending_data, conn);
|
|
299 }
|
|
300
|
|
301 /**
|
|
302 * We are sending a file to someone else. They have just acknowledged our
|
|
303 * prompt, so we want to start sending data like there's no tomorrow.
|
|
304 */
|
|
305 static void
|
|
306 peer_oft_recv_frame_ack(PeerConnection *conn, OftFrame *frame)
|
|
307 {
|
|
308 if (memcmp(conn->cookie, frame->cookie, 8))
|
|
309 {
|
|
310 gaim_debug_info("oscar", "Received an incorrect cookie. "
|
|
311 "Closing connection.\n");
|
14402
|
312 peer_connection_destroy(conn, OSCAR_DISCONNECT_INVALID_DATA, NULL);
|
14192
|
313 return;
|
|
314 }
|
|
315
|
|
316 /* Remove our watchers and use the file transfer watchers in the core */
|
|
317 gaim_input_remove(conn->watcher_incoming);
|
|
318 conn->watcher_incoming = 0;
|
|
319 conn->sending_data_timer = gaim_timeout_add(100,
|
|
320 start_transfer_when_done_sending_data, conn);
|
|
321 }
|
|
322
|
|
323 /*
|
|
324 * We just sent a file to someone. They said they got it and everything,
|
|
325 * so we can close our direct connection and what not.
|
|
326 */
|
|
327 static void
|
|
328 peer_oft_recv_frame_done(PeerConnection *conn, OftFrame *frame)
|
|
329 {
|
|
330 gaim_input_remove(conn->watcher_incoming);
|
|
331 conn->watcher_incoming = 0;
|
|
332 conn->xfer->fd = conn->fd;
|
|
333 conn->fd = -1;
|
|
334 gaim_xfer_end(conn->xfer);
|
|
335 }
|
|
336
|
|
337 /**
|
|
338 * Handle an incoming OftFrame. If there is a payload associated
|
|
339 * with this frame, then we remove the old watcher and add the
|
|
340 * OFT watcher to read in the payload.
|
|
341 */
|
|
342 void
|
|
343 peer_oft_recv_frame(PeerConnection *conn, ByteStream *bs)
|
|
344 {
|
|
345 OftFrame frame;
|
|
346
|
|
347 frame.type = byte_stream_get16(bs);
|
|
348 byte_stream_getrawbuf(bs, frame.cookie, 8);
|
|
349 frame.encrypt = byte_stream_get16(bs);
|
|
350 frame.compress = byte_stream_get16(bs);
|
|
351 frame.totfiles = byte_stream_get16(bs);
|
|
352 frame.filesleft = byte_stream_get16(bs);
|
|
353 frame.totparts = byte_stream_get16(bs);
|
|
354 frame.partsleft = byte_stream_get16(bs);
|
|
355 frame.totsize = byte_stream_get32(bs);
|
|
356 frame.size = byte_stream_get32(bs);
|
|
357 frame.modtime = byte_stream_get32(bs);
|
|
358 frame.checksum = byte_stream_get32(bs);
|
|
359 frame.rfrcsum = byte_stream_get32(bs);
|
|
360 frame.rfsize = byte_stream_get32(bs);
|
|
361 frame.cretime = byte_stream_get32(bs);
|
|
362 frame.rfcsum = byte_stream_get32(bs);
|
|
363 frame.nrecvd = byte_stream_get32(bs);
|
|
364 frame.recvcsum = byte_stream_get32(bs);
|
|
365 byte_stream_getrawbuf(bs, frame.idstring, 32);
|
|
366 frame.flags = byte_stream_get8(bs);
|
|
367 frame.lnameoffset = byte_stream_get8(bs);
|
|
368 frame.lsizeoffset = byte_stream_get8(bs);
|
|
369 byte_stream_getrawbuf(bs, frame.dummy, 69);
|
|
370 byte_stream_getrawbuf(bs, frame.macfileinfo, 16);
|
|
371 frame.nencode = byte_stream_get16(bs);
|
|
372 frame.nlanguage = byte_stream_get16(bs);
|
|
373 frame.name_length = bs->len - 186;
|
|
374 frame.name = byte_stream_getraw(bs, frame.name_length);
|
|
375
|
|
376 gaim_debug_info("oscar", "Incoming OFT frame from %s with "
|
|
377 "type=0x%04x\n", conn->sn, frame.type);
|
|
378
|
|
379 /* TODOFT: peer_oft_dirconvert_fromstupid(frame->name); */
|
|
380
|
|
381 if (frame.type == PEER_TYPE_PROMPT)
|
|
382 peer_oft_recv_frame_prompt(conn, &frame);
|
|
383 else if (frame.type == PEER_TYPE_ACK)
|
|
384 peer_oft_recv_frame_ack(conn, &frame);
|
|
385 else if (frame.type == PEER_TYPE_DONE)
|
|
386 peer_oft_recv_frame_done(conn, &frame);
|
|
387
|
|
388 free(frame.name);
|
|
389 }
|
|
390
|
|
391 /*******************************************************************/
|
|
392 /* Begin GaimXfer callbacks for use when receiving a file */
|
|
393 /*******************************************************************/
|
|
394
|
|
395 void
|
|
396 peer_oft_recvcb_init(GaimXfer *xfer)
|
|
397 {
|
|
398 PeerConnection *conn;
|
|
399
|
|
400 conn = xfer->data;
|
|
401 conn->flags |= PEER_CONNECTION_FLAG_APPROVED;
|
|
402 peer_connection_trynext(conn);
|
|
403 }
|
|
404
|
|
405 void
|
|
406 peer_oft_recvcb_end(GaimXfer *xfer)
|
|
407 {
|
|
408 PeerConnection *conn;
|
|
409
|
|
410 conn = xfer->data;
|
|
411
|
|
412 /* Tell the other person that we've received everything */
|
|
413 conn->fd = conn->xfer->fd;
|
|
414 conn->xfer->fd = -1;
|
|
415 peer_oft_send_done(conn);
|
|
416
|
|
417 conn->disconnect_reason = OSCAR_DISCONNECT_DONE;
|
|
418 conn->sending_data_timer = gaim_timeout_add(100,
|
|
419 destroy_connection_when_done_sending_data, conn);
|
|
420 }
|
|
421
|
|
422 void
|
|
423 peer_oft_recvcb_ack_recv(GaimXfer *xfer, const guchar *buffer, size_t size)
|
|
424 {
|
|
425 PeerConnection *conn;
|
|
426
|
|
427 /* Update our rolling checksum. Like Walmart, yo. */
|
|
428 conn = xfer->data;
|
|
429 conn->xferdata.recvcsum = peer_oft_checksum_chunk(buffer,
|
|
430 size, conn->xferdata.recvcsum);
|
|
431 }
|
|
432
|
|
433 /*******************************************************************/
|
|
434 /* End GaimXfer callbacks for use when receiving a file */
|
|
435 /*******************************************************************/
|
|
436
|
|
437 /*******************************************************************/
|
|
438 /* Begin GaimXfer callbacks for use when sending a file */
|
|
439 /*******************************************************************/
|
|
440
|
|
441 void
|
|
442 peer_oft_sendcb_init(GaimXfer *xfer)
|
|
443 {
|
|
444 PeerConnection *conn;
|
14538
|
445 size_t size;
|
14192
|
446
|
|
447 conn = xfer->data;
|
|
448 conn->flags |= PEER_CONNECTION_FLAG_APPROVED;
|
|
449
|
14538
|
450 /* Make sure the file size can be represented in 32 bits */
|
|
451 size = gaim_xfer_get_size(xfer);
|
|
452 if (size > G_MAXUINT32)
|
|
453 {
|
|
454 gchar *tmp, *size1, *size2;
|
|
455 size1 = gaim_str_size_to_units(size);
|
|
456 size2 = gaim_str_size_to_units(G_MAXUINT32);
|
|
457 tmp = g_strdup_printf(_("File %s is %s, which is larger than "
|
|
458 "the maximum size of %s."),
|
|
459 xfer->local_filename, size1, size2);
|
|
460 gaim_xfer_error(gaim_xfer_get_type(xfer),
|
|
461 gaim_xfer_get_account(xfer), xfer->who, tmp);
|
|
462 g_free(size1);
|
|
463 g_free(size2);
|
|
464 g_free(tmp);
|
|
465 peer_connection_destroy(conn, OSCAR_DISCONNECT_LOCAL_CLOSED, NULL);
|
|
466 return;
|
|
467 }
|
|
468
|
14192
|
469 /* Keep track of file transfer info */
|
|
470 conn->xferdata.totfiles = 1;
|
|
471 conn->xferdata.filesleft = 1;
|
|
472 conn->xferdata.totparts = 1;
|
|
473 conn->xferdata.partsleft = 1;
|
14538
|
474 conn->xferdata.totsize = size;
|
|
475 conn->xferdata.size = size;
|
14192
|
476 conn->xferdata.checksum = 0xffff0000;
|
|
477 conn->xferdata.rfrcsum = 0xffff0000;
|
|
478 conn->xferdata.rfcsum = 0xffff0000;
|
|
479 conn->xferdata.recvcsum = 0xffff0000;
|
|
480 strncpy((gchar *)conn->xferdata.idstring, "OFT_Windows ICBMFT V1.1 32", 31);
|
|
481 conn->xferdata.modtime = 0;
|
|
482 conn->xferdata.cretime = 0;
|
|
483 xfer->filename = g_path_get_basename(xfer->local_filename);
|
|
484 conn->xferdata.name = (guchar *)g_strdup(xfer->filename);
|
|
485 conn->xferdata.name_length = strlen(xfer->filename);
|
|
486
|
|
487 /* Calculating the checksum can take a very long time for large files */
|
|
488 gaim_debug_info("oscar","calculating file checksum\n");
|
|
489 conn->xferdata.checksum = peer_oft_checksum_file(xfer->local_filename);
|
|
490 gaim_debug_info("oscar","checksum calculated\n");
|
|
491
|
|
492 /* Start the connection process */
|
|
493 peer_connection_trynext(conn);
|
|
494 }
|
|
495
|
|
496 /*
|
|
497 * AIM file transfers aren't really meant to be thought
|
|
498 * of as a transferring just a single file. The rendezvous
|
|
499 * establishes a connection between two computers, and then
|
|
500 * those computers can use the same connection for transferring
|
|
501 * multiple files. So we don't want the Gaim core up and closing
|
|
502 * the socket all willy-nilly. We want to do that in the oscar
|
|
503 * prpl, whenever one side or the other says they're finished
|
|
504 * using the connection. There might be a better way to intercept
|
|
505 * the socket from the core...
|
|
506 */
|
|
507 void
|
|
508 peer_oft_sendcb_ack(GaimXfer *xfer, const guchar *buffer, size_t size)
|
|
509 {
|
|
510 PeerConnection *conn;
|
|
511
|
|
512 conn = xfer->data;
|
|
513
|
|
514 /*
|
|
515 * If we're done sending, intercept the socket from the core ft code
|
|
516 * and wait for the other guy to send the "done" OFT packet.
|
|
517 */
|
|
518 if (gaim_xfer_get_bytes_remaining(xfer) <= 0)
|
|
519 {
|
|
520 gaim_input_remove(xfer->watcher);
|
|
521 conn->fd = xfer->fd;
|
|
522 xfer->fd = -1;
|
|
523 conn->watcher_incoming = gaim_input_add(conn->fd,
|
|
524 GAIM_INPUT_READ, peer_connection_recv_cb, conn);
|
|
525 }
|
|
526 }
|
|
527
|
|
528 /*******************************************************************/
|
|
529 /* End GaimXfer callbacks for use when sending a file */
|
|
530 /*******************************************************************/
|
|
531
|
|
532 /*******************************************************************/
|
|
533 /* Begin GaimXfer callbacks for use when sending and receiving */
|
|
534 /*******************************************************************/
|
|
535
|
|
536 void
|
|
537 peer_oft_cb_generic_cancel(GaimXfer *xfer)
|
|
538 {
|
|
539 PeerConnection *conn;
|
|
540
|
|
541 conn = xfer->data;
|
|
542
|
|
543 if (conn == NULL)
|
|
544 return;
|
|
545
|
14402
|
546 peer_connection_destroy(conn, OSCAR_DISCONNECT_LOCAL_CLOSED, NULL);
|
14192
|
547 }
|
|
548
|
|
549 /*******************************************************************/
|
|
550 /* End GaimXfer callbacks for use when sending and receiving */
|
|
551 /*******************************************************************/
|
|
552
|
|
553 #if 0
|
|
554 /*
|
|
555 * This little area in oscar.c is the nexus of file transfer code,
|
|
556 * so I wrote a little explanation of what happens. I am such a
|
|
557 * ninja.
|
|
558 *
|
|
559 * The series of events for a file send is:
|
|
560 * -Create xfer and call gaim_xfer_request (this happens in oscar_ask_sendfile)
|
|
561 * -User chooses a file and oscar_xfer_init is called. It establishes a
|
|
562 * listening socket, then asks the remote user to connect to us (and
|
|
563 * gives them the file name, port, IP, etc.)
|
|
564 * -They connect to us and we send them an PEER_TYPE_PROMPT (this happens
|
|
565 * in peer_oft_recv_frame_established)
|
|
566 * -They send us an PEER_TYPE_ACK and then we start sending data
|
|
567 * -When we finish, they send us an PEER_TYPE_DONE and they close the
|
|
568 * connection.
|
|
569 * -We get drunk because file transfer kicks ass.
|
|
570 *
|
|
571 * The series of events for a file receive is:
|
|
572 * -Create xfer and call gaim_xfer request (this happens in incomingim_chan2)
|
|
573 * -Gaim user selects file to name and location to save file to and
|
|
574 * oscar_xfer_init is called
|
|
575 * -It connects to the remote user using the IP they gave us earlier
|
|
576 * -After connecting, they send us an PEER_TYPE_PROMPT. In reply, we send
|
|
577 * them an PEER_TYPE_ACK.
|
|
578 * -They begin to send us lots of raw data.
|
|
579 * -When they finish sending data we send an PEER_TYPE_DONE and then close
|
|
580 * the connection.
|
|
581 *
|
|
582 * Update August 2005:
|
|
583 * The series of events for transfers has been seriously complicated by the addition
|
|
584 * of transfer redirects and proxied connections. I could throw a whole lot of words
|
|
585 * at trying to explain things here, but it probably wouldn't do much good. To get
|
|
586 * a better idea of what happens, take a look at the diagrams and documentation
|
|
587 * from my Summer of Code project. -- Jonathan Clark
|
|
588 */
|
|
589
|
|
590 /**
|
|
591 * Convert the directory separator from / (0x2f) to ^A (0x01)
|
|
592 *
|
|
593 * @param name The filename to convert.
|
|
594 */
|
|
595 static void
|
|
596 peer_oft_dirconvert_tostupid(char *name)
|
|
597 {
|
|
598 while (name[0]) {
|
|
599 if (name[0] == 0x01)
|
|
600 name[0] = G_DIR_SEPARATOR;
|
|
601 name++;
|
|
602 }
|
|
603 }
|
|
604
|
|
605 /**
|
|
606 * Convert the directory separator from ^A (0x01) to / (0x2f)
|
|
607 *
|
|
608 * @param name The filename to convert.
|
|
609 */
|
|
610 static void
|
|
611 peer_oft_dirconvert_fromstupid(char *name)
|
|
612 {
|
|
613 while (name[0]) {
|
|
614 if (name[0] == G_DIR_SEPARATOR)
|
|
615 name[0] = 0x01;
|
|
616 name++;
|
|
617 }
|
|
618 }
|
|
619 #endif
|