Annotation of ChivanetAimPidgin/oscarprpl/src/c/peer.c, revision 1.1
1.1 ! snw 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: * Functions dealing with peer connections. This includes the code
! 23: * used to establish a peer connection for both Oscar File transfer
! 24: * (OFT) and Oscar Direct Connect (ODC). (ODC is also referred to
! 25: * as DirectIM and IM Image.)
! 26: */
! 27:
! 28: #ifdef HAVE_CONFIG_H
! 29: #include <config.h>
! 30: #endif
! 31:
! 32: /* From the oscar PRPL */
! 33: #include "oscar.h"
! 34: #include "peer.h"
! 35:
! 36: /* From Purple */
! 37: #include "conversation.h"
! 38: #include "ft.h"
! 39: #include "network.h"
! 40: #include "notify.h"
! 41: #include "request.h"
! 42: #include "util.h"
! 43:
! 44: #ifndef _WIN32
! 45: #include <stdio.h>
! 46: #include <netdb.h>
! 47: #include <sys/socket.h>
! 48: #include <netinet/in.h>
! 49: #include <arpa/inet.h> /* for inet_ntoa */
! 50: #include <limits.h> /* for UINT_MAX */
! 51: #endif
! 52:
! 53: #ifdef _WIN32
! 54: #include "win32dep.h"
! 55: #endif
! 56:
! 57: /*
! 58: * I really want to switch all our networking code to using IPv6 only,
! 59: * but that really isn't a good idea at all. Evan S. of Adium says
! 60: * OS X sets all connections as "AF_INET6/PF_INET6," even if there is
! 61: * nothing inherently IPv6 about them. And I feel like Linux kernel
! 62: * 2.6.5 is doing the same thing. So we REALLY should accept
! 63: * connections if they're showing up as IPv6. Old OSes (Solaris?)
! 64: * that might not have full IPv6 support yet will fail if we try
! 65: * to use PF_INET6 but it isn't defined. --Mark Doliner
! 66: */
! 67: #ifndef PF_INET6
! 68: #define PF_INET6 PF_INET
! 69: #endif
! 70:
! 71: PeerConnection *
! 72: peer_connection_find_by_type(OscarData *od, const char *bn, guint64 type)
! 73: {
! 74: GSList *cur;
! 75: PeerConnection *conn;
! 76:
! 77: for (cur = od->peer_connections; cur != NULL; cur = cur->next)
! 78: {
! 79: conn = cur->data;
! 80: if ((conn->type == type) && !oscar_util_name_compare(conn->bn, bn))
! 81: return conn;
! 82: }
! 83:
! 84: return NULL;
! 85: }
! 86:
! 87: /**
! 88: * @param cookie This must be exactly 8 characters.
! 89: */
! 90: PeerConnection *
! 91: peer_connection_find_by_cookie(OscarData *od, const char *bn, const guchar *cookie)
! 92: {
! 93: GSList *cur;
! 94: PeerConnection *conn;
! 95:
! 96: for (cur = od->peer_connections; cur != NULL; cur = cur->next)
! 97: {
! 98: conn = cur->data;
! 99: if (!memcmp(conn->cookie, cookie, 8) && !oscar_util_name_compare(conn->bn, bn))
! 100: return conn;
! 101: }
! 102:
! 103: return NULL;
! 104: }
! 105:
! 106: PeerConnection *
! 107: peer_connection_new(OscarData *od, guint64 type, const char *bn)
! 108: {
! 109: PeerConnection *conn;
! 110: PurpleAccount *account;
! 111:
! 112: account = purple_connection_get_account(od->gc);
! 113:
! 114: conn = g_new0(PeerConnection, 1);
! 115: conn->od = od;
! 116: conn->type = type;
! 117: conn->bn = g_strdup(bn);
! 118: conn->buffer_outgoing = purple_circ_buffer_new(0);
! 119: conn->listenerfd = -1;
! 120: conn->fd = -1;
! 121: conn->lastactivity = time(NULL);
! 122: conn->use_proxy |= purple_account_get_bool(account, "always_use_rv_proxy", FALSE);
! 123:
! 124: if (type == OSCAR_CAPABILITY_DIRECTIM)
! 125: memcpy(conn->magic, "ODC2", 4);
! 126: else if (type == OSCAR_CAPABILITY_SENDFILE)
! 127: memcpy(conn->magic, "OFT2", 4);
! 128:
! 129: od->peer_connections = g_slist_prepend(od->peer_connections, conn);
! 130:
! 131: return conn;
! 132: }
! 133:
! 134: static void
! 135: peer_connection_close(PeerConnection *conn)
! 136: {
! 137: if (conn->type == OSCAR_CAPABILITY_DIRECTIM)
! 138: peer_odc_close(conn);
! 139: else if (conn->type == OSCAR_CAPABILITY_SENDFILE)
! 140: peer_oft_close(conn);
! 141:
! 142: if (conn->verified_connect_data != NULL)
! 143: {
! 144: purple_proxy_connect_cancel(conn->verified_connect_data);
! 145: conn->verified_connect_data = NULL;
! 146: }
! 147:
! 148: if (conn->client_connect_data != NULL)
! 149: {
! 150: purple_proxy_connect_cancel(conn->client_connect_data);
! 151: conn->client_connect_data = NULL;
! 152: }
! 153:
! 154: if (conn->listen_data != NULL)
! 155: {
! 156: purple_network_listen_cancel(conn->listen_data);
! 157: conn->listen_data = NULL;
! 158: }
! 159:
! 160: if (conn->connect_timeout_timer != 0)
! 161: {
! 162: purple_timeout_remove(conn->connect_timeout_timer);
! 163: conn->connect_timeout_timer = 0;
! 164: }
! 165:
! 166: if (conn->watcher_incoming != 0)
! 167: {
! 168: purple_input_remove(conn->watcher_incoming);
! 169: conn->watcher_incoming = 0;
! 170: }
! 171: if (conn->watcher_outgoing != 0)
! 172: {
! 173: purple_input_remove(conn->watcher_outgoing);
! 174: conn->watcher_outgoing = 0;
! 175: }
! 176: if (conn->listenerfd >= 0)
! 177: {
! 178: close(conn->listenerfd);
! 179: conn->listenerfd = -1;
! 180: }
! 181: if (conn->fd >= 0)
! 182: {
! 183: close(conn->fd);
! 184: conn->fd = -1;
! 185: }
! 186:
! 187: g_free(conn->buffer_incoming.data);
! 188: conn->buffer_incoming.data = NULL;
! 189: conn->buffer_incoming.len = 0;
! 190: conn->buffer_incoming.offset = 0;
! 191:
! 192: purple_circ_buffer_destroy(conn->buffer_outgoing);
! 193: conn->buffer_outgoing = purple_circ_buffer_new(0);
! 194:
! 195: conn->flags &= ~PEER_CONNECTION_FLAG_IS_INCOMING;
! 196: }
! 197:
! 198: static gboolean
! 199: peer_connection_destroy_cb(gpointer data)
! 200: {
! 201: PeerConnection *conn;
! 202:
! 203: conn = data;
! 204:
! 205: purple_request_close_with_handle(conn);
! 206:
! 207: peer_connection_close(conn);
! 208:
! 209: if (conn->checksum_data != NULL)
! 210: peer_oft_checksum_destroy(conn->checksum_data);
! 211:
! 212: if (conn->xfer != NULL)
! 213: {
! 214: PurpleXferStatusType status;
! 215: conn->xfer->data = NULL;
! 216: status = purple_xfer_get_status(conn->xfer);
! 217: if ((status != PURPLE_XFER_STATUS_DONE) &&
! 218: (status != PURPLE_XFER_STATUS_CANCEL_LOCAL) &&
! 219: (status != PURPLE_XFER_STATUS_CANCEL_REMOTE))
! 220: {
! 221: if ((conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_CLOSED) ||
! 222: (conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_REFUSED))
! 223: purple_xfer_cancel_remote(conn->xfer);
! 224: else
! 225: purple_xfer_cancel_local(conn->xfer);
! 226: }
! 227: purple_xfer_unref(conn->xfer);
! 228: conn->xfer = NULL;
! 229: }
! 230:
! 231: g_free(conn->bn);
! 232: g_free(conn->error_message);
! 233: g_free(conn->proxyip);
! 234: g_free(conn->clientip);
! 235: g_free(conn->verifiedip);
! 236: g_free(conn->xferdata.name);
! 237: purple_circ_buffer_destroy(conn->buffer_outgoing);
! 238:
! 239: conn->od->peer_connections = g_slist_remove(conn->od->peer_connections, conn);
! 240:
! 241: g_free(conn);
! 242:
! 243: return FALSE;
! 244: }
! 245:
! 246: void
! 247: peer_connection_destroy(PeerConnection *conn, OscarDisconnectReason reason, const gchar *error_message)
! 248: {
! 249: if (conn->destroy_timeout != 0)
! 250: purple_timeout_remove(conn->destroy_timeout);
! 251: conn->disconnect_reason = reason;
! 252: g_free(conn->error_message);
! 253: conn->error_message = g_strdup(error_message);
! 254: peer_connection_destroy_cb(conn);
! 255: }
! 256:
! 257: void
! 258: peer_connection_schedule_destroy(PeerConnection *conn, OscarDisconnectReason reason, const gchar *error_message)
! 259: {
! 260: if (conn->destroy_timeout != 0)
! 261: /* Already taken care of */
! 262: return;
! 263:
! 264: purple_debug_info("oscar", "Scheduling destruction of peer connection\n");
! 265: conn->disconnect_reason = reason;
! 266: g_free(conn->error_message);
! 267: conn->error_message = g_strdup(error_message);
! 268: conn->destroy_timeout = purple_timeout_add(0, peer_connection_destroy_cb, conn);
! 269: }
! 270:
! 271: /*******************************************************************/
! 272: /* Begin code for receiving data on a peer connection */
! 273: /*******************************************************************/
! 274:
! 275: /**
! 276: * This should be used to read ODC and OFT framing info. It should
! 277: * NOT be used to read the payload sent across the connection (IMs,
! 278: * file data, etc), and it should NOT be used to read proxy negotiation
! 279: * headers.
! 280: *
! 281: * Unlike flap_connection_recv_cb(), this only reads one frame at a
! 282: * time. This is done so that the watcher can be changed during the
! 283: * handling of the frame. If the watcher is changed then this
! 284: * function will not read in any more data. This happens when
! 285: * reading the payload of a direct IM frame, or when we're
! 286: * receiving a file from the remote user. Once the data has been
! 287: * read, the watcher will be switched back to this function to
! 288: * continue reading the next frame.
! 289: */
! 290: void
! 291: peer_connection_recv_cb(gpointer data, gint source, PurpleInputCondition cond)
! 292: {
! 293: PeerConnection *conn;
! 294: gssize read;
! 295:
! 296: conn = data;
! 297:
! 298: /* Start reading a new ODC/OFT frame */
! 299: if (conn->buffer_incoming.data == NULL)
! 300: {
! 301: /* Read the first 6 bytes (magic string and frame length) */
! 302: read = recv(conn->fd, conn->header + conn->header_received,
! 303: 6 - conn->header_received, 0);
! 304:
! 305: /* Check if the remote user closed the connection */
! 306: if (read == 0)
! 307: {
! 308: peer_connection_destroy(conn, OSCAR_DISCONNECT_REMOTE_CLOSED, NULL);
! 309: return;
! 310: }
! 311:
! 312: /* If there was an error then close the connection */
! 313: if (read < 0)
! 314: {
! 315: if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
! 316: /* No worries */
! 317: return;
! 318:
! 319: peer_connection_destroy(conn,
! 320: OSCAR_DISCONNECT_LOST_CONNECTION, g_strerror(errno));
! 321: return;
! 322: }
! 323:
! 324: conn->lastactivity = time(NULL);
! 325:
! 326: /* If we don't even have the first 6 bytes then do nothing */
! 327: conn->header_received += read;
! 328: if (conn->header_received < 6)
! 329: return;
! 330:
! 331: /* All ODC/OFT frames must start with a magic string */
! 332: if (memcmp(conn->magic, conn->header, 4))
! 333: {
! 334: purple_debug_warning("oscar", "Expecting magic string to "
! 335: "be %c%c%c%c but received magic string %c%c%c%c. "
! 336: "Closing connection.\n",
! 337: conn->magic[0], conn->magic[1], conn->magic[2],
! 338: conn->magic[3], conn->header[0], conn->header[1],
! 339: conn->header[2], conn->header[3]);
! 340: peer_connection_destroy(conn, OSCAR_DISCONNECT_INVALID_DATA, NULL);
! 341: return;
! 342: }
! 343:
! 344: /* Initialize a new temporary ByteStream for incoming data */
! 345: conn->buffer_incoming.len = aimutil_get16(&conn->header[4]) - 6;
! 346: conn->buffer_incoming.data = g_new(guint8, conn->buffer_incoming.len);
! 347: conn->buffer_incoming.offset = 0;
! 348: }
! 349:
! 350: /* Read data into the temporary buffer until it is complete */
! 351: read = recv(conn->fd,
! 352: &conn->buffer_incoming.data[conn->buffer_incoming.offset],
! 353: conn->buffer_incoming.len - conn->buffer_incoming.offset,
! 354: 0);
! 355:
! 356: /* Check if the remote user closed the connection */
! 357: if (read == 0)
! 358: {
! 359: peer_connection_destroy(conn, OSCAR_DISCONNECT_REMOTE_CLOSED, NULL);
! 360: return;
! 361: }
! 362:
! 363: if (read < 0)
! 364: {
! 365: if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
! 366: /* No worries */
! 367: return;
! 368:
! 369: peer_connection_destroy(conn,
! 370: OSCAR_DISCONNECT_LOST_CONNECTION, g_strerror(errno));
! 371: return;
! 372: }
! 373:
! 374: conn->lastactivity = time(NULL);
! 375: conn->buffer_incoming.offset += read;
! 376: if (conn->buffer_incoming.offset < conn->buffer_incoming.len)
! 377: /* Waiting for more data to arrive */
! 378: return;
! 379:
! 380: /* We have a complete ODC/OFT frame! Handle it and continue reading */
! 381: byte_stream_rewind(&conn->buffer_incoming);
! 382: if (conn->type == OSCAR_CAPABILITY_DIRECTIM)
! 383: {
! 384: peer_odc_recv_frame(conn, &conn->buffer_incoming);
! 385: }
! 386: else if (conn->type == OSCAR_CAPABILITY_SENDFILE)
! 387: {
! 388: peer_oft_recv_frame(conn, &conn->buffer_incoming);
! 389: }
! 390:
! 391: g_free(conn->buffer_incoming.data);
! 392: conn->buffer_incoming.data = NULL;
! 393:
! 394: conn->header_received = 0;
! 395: }
! 396:
! 397: /*******************************************************************/
! 398: /* End code for receiving data on a peer connection */
! 399: /*******************************************************************/
! 400:
! 401: /*******************************************************************/
! 402: /* Begin code for sending data on a peer connection */
! 403: /*******************************************************************/
! 404:
! 405: static void
! 406: send_cb(gpointer data, gint source, PurpleInputCondition cond)
! 407: {
! 408: PeerConnection *conn;
! 409: gsize writelen;
! 410: gssize wrotelen;
! 411:
! 412: conn = data;
! 413: writelen = purple_circ_buffer_get_max_read(conn->buffer_outgoing);
! 414:
! 415: if (writelen == 0)
! 416: {
! 417: purple_input_remove(conn->watcher_outgoing);
! 418: conn->watcher_outgoing = 0;
! 419: /*
! 420: * The buffer is currently empty, so reset the current input
! 421: * and output positions to the start of the buffer. We do
! 422: * this so that the next chunk of data that we put into the
! 423: * buffer can be read back out of the buffer in one fell swoop.
! 424: * Otherwise it gets fragmented and we have to read from the
! 425: * second half of the buffer than go back and read the rest of
! 426: * the chunk from the first half.
! 427: *
! 428: * We're using TCP, which is a stream based protocol, so this
! 429: * isn't supposed to matter. However, experience has shown
! 430: * that at least the proxy file transfer code in AIM 6.1.41.2
! 431: * requires that the entire OFT frame arrive all at once. If
! 432: * the frame is fragmented then AIM freaks out and aborts the
! 433: * file transfer. Somebody should teach those guys how to
! 434: * write good TCP code.
! 435: */
! 436: conn->buffer_outgoing->inptr = conn->buffer_outgoing->buffer;
! 437: conn->buffer_outgoing->outptr = conn->buffer_outgoing->buffer;
! 438: return;
! 439: }
! 440:
! 441: wrotelen = send(conn->fd, conn->buffer_outgoing->outptr, writelen, 0);
! 442: if (wrotelen <= 0)
! 443: {
! 444: if (wrotelen < 0 && ((errno == EAGAIN) || (errno == EWOULDBLOCK)))
! 445: /* No worries */
! 446: return;
! 447:
! 448: if (conn->ready)
! 449: {
! 450: purple_input_remove(conn->watcher_outgoing);
! 451: conn->watcher_outgoing = 0;
! 452: close(conn->fd);
! 453: conn->fd = -1;
! 454: peer_connection_schedule_destroy(conn,
! 455: OSCAR_DISCONNECT_LOST_CONNECTION, NULL);
! 456: }
! 457: else
! 458: {
! 459: /*
! 460: * This could happen when unable to send a negotiation
! 461: * frame to a peer proxy server.
! 462: */
! 463: peer_connection_trynext(conn);
! 464: }
! 465: return;
! 466: }
! 467:
! 468: purple_circ_buffer_mark_read(conn->buffer_outgoing, wrotelen);
! 469: conn->lastactivity = time(NULL);
! 470: }
! 471:
! 472: /**
! 473: * This should be called by OFT/ODC code to send a standard OFT or ODC
! 474: * frame across the peer connection along with some payload data. Or
! 475: * maybe a file. Anything, really.
! 476: */
! 477: void
! 478: peer_connection_send(PeerConnection *conn, ByteStream *bs)
! 479: {
! 480: /* Add everything to our outgoing buffer */
! 481: purple_circ_buffer_append(conn->buffer_outgoing, bs->data, bs->len);
! 482:
! 483: /* If we haven't already started writing stuff, then start the cycle */
! 484: if ((conn->watcher_outgoing == 0) && (conn->fd >= 0))
! 485: {
! 486: conn->watcher_outgoing = purple_input_add(conn->fd,
! 487: PURPLE_INPUT_WRITE, send_cb, conn);
! 488: send_cb(conn, conn->fd, 0);
! 489: }
! 490: }
! 491:
! 492: /*******************************************************************/
! 493: /* End code for sending data on a peer connection */
! 494: /*******************************************************************/
! 495:
! 496: /*******************************************************************/
! 497: /* Begin code for establishing a peer connection */
! 498: /*******************************************************************/
! 499:
! 500: void
! 501: peer_connection_finalize_connection(PeerConnection *conn)
! 502: {
! 503: conn->watcher_incoming = purple_input_add(conn->fd,
! 504: PURPLE_INPUT_READ, peer_connection_recv_cb, conn);
! 505:
! 506: if (conn->type == OSCAR_CAPABILITY_DIRECTIM)
! 507: {
! 508: /*
! 509: * If we are connecting to them then send our cookie so they
! 510: * can verify who we are. Note: This doesn't seem to be
! 511: * necessary, but it also doesn't seem to hurt.
! 512: */
! 513: if (!(conn->flags & PEER_CONNECTION_FLAG_IS_INCOMING))
! 514: peer_odc_send_cookie(conn);
! 515: }
! 516: else if (conn->type == OSCAR_CAPABILITY_SENDFILE)
! 517: {
! 518: if (purple_xfer_get_type(conn->xfer) == PURPLE_XFER_SEND)
! 519: {
! 520: peer_oft_send_prompt(conn);
! 521: }
! 522: }
! 523:
! 524: /*
! 525: * Tell the remote user that we're connected (which may also imply
! 526: * that we've accepted their request).
! 527: */
! 528: if (!(conn->flags & PEER_CONNECTION_FLAG_IS_INCOMING))
! 529: aim_im_sendch2_connected(conn);
! 530: }
! 531:
! 532: /**
! 533: * We tried to make an outgoing connection to a remote user. It
! 534: * either connected or failed to connect.
! 535: */
! 536: static void
! 537: peer_connection_common_established_cb(gpointer data, gint source, const gchar *error_message, gboolean verified)
! 538: {
! 539: PeerConnection *conn;
! 540:
! 541: conn = data;
! 542:
! 543: if (verified)
! 544: conn->verified_connect_data = NULL;
! 545: else
! 546: conn->client_connect_data = NULL;
! 547:
! 548: if (source < 0)
! 549: {
! 550: if ((conn->verified_connect_data == NULL) &&
! 551: (conn->client_connect_data == NULL))
! 552: {
! 553: /* Our parallel connection attemps have both failed. */
! 554: peer_connection_trynext(conn);
! 555: }
! 556: return;
! 557: }
! 558:
! 559: purple_timeout_remove(conn->connect_timeout_timer);
! 560: conn->connect_timeout_timer = 0;
! 561:
! 562: if (conn->client_connect_data != NULL)
! 563: {
! 564: purple_proxy_connect_cancel(conn->client_connect_data);
! 565: conn->client_connect_data = NULL;
! 566: }
! 567:
! 568: if (conn->verified_connect_data != NULL)
! 569: {
! 570: purple_proxy_connect_cancel(conn->verified_connect_data);
! 571: conn->verified_connect_data = NULL;
! 572: }
! 573:
! 574: conn->fd = source;
! 575:
! 576: peer_connection_finalize_connection(conn);
! 577: }
! 578:
! 579: static void
! 580: peer_connection_verified_established_cb(gpointer data, gint source, const gchar *error_message)
! 581: {
! 582: peer_connection_common_established_cb(data, source, error_message, TRUE);
! 583: }
! 584:
! 585: static void
! 586: peer_connection_client_established_cb(gpointer data, gint source, const gchar *error_message)
! 587: {
! 588: peer_connection_common_established_cb(data, source, error_message, FALSE);
! 589: }
! 590:
! 591: /**
! 592: * This is the watcher callback for any listening socket that is
! 593: * waiting for a peer to connect. When a peer connects we set the
! 594: * input watcher to start reading data from the peer.
! 595: *
! 596: * To make sure that the connection is with the intended person and
! 597: * not with a malicious middle man, we don't send anything until we've
! 598: * received a peer frame from the remote user and have verified that
! 599: * the cookie in the peer frame matches the cookie that was exchanged
! 600: * in the channel 2 ICBM.
! 601: */
! 602: void
! 603: peer_connection_listen_cb(gpointer data, gint source, PurpleInputCondition cond)
! 604: {
! 605: PeerConnection *conn;
! 606: struct sockaddr addr;
! 607: socklen_t addrlen = sizeof(addr);
! 608:
! 609: conn = data;
! 610:
! 611: purple_debug_info("oscar", "Accepting connection on listener socket.\n");
! 612:
! 613: conn->fd = accept(conn->listenerfd, &addr, &addrlen);
! 614: if (conn->fd < 0)
! 615: {
! 616: if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
! 617: /* No connection yet--no worries */
! 618: /* TODO: Hmm, but they SHOULD be connected if we're here, right? */
! 619: return;
! 620:
! 621: peer_connection_trynext(conn);
! 622: return;
! 623: }
! 624:
! 625: if ((addr.sa_family != PF_INET) && (addr.sa_family != PF_INET6))
! 626: {
! 627: /* Invalid connection type?! Continue waiting. */
! 628: close(conn->fd);
! 629: return;
! 630: }
! 631:
! 632: //_purple_network_set_common_socket_flags(conn->fd); // TODO: Not public? Check
! 633:
! 634: purple_input_remove(conn->watcher_incoming);
! 635:
! 636: peer_connection_finalize_connection(conn);
! 637: }
! 638:
! 639: /**
! 640: * We've just opened a listener socket, so we send the remote
! 641: * user an ICBM and ask them to connect to us.
! 642: */
! 643: static void
! 644: peer_connection_establish_listener_cb(int listenerfd, gpointer data)
! 645: {
! 646: PeerConnection *conn;
! 647: OscarData *od;
! 648: PurpleConnection *gc;
! 649: PurpleAccount *account;
! 650: PurpleConversation *conv;
! 651: char *tmp;
! 652: FlapConnection *bos_conn;
! 653: const char *listener_ip;
! 654: const guchar *ip_atoi;
! 655: unsigned short listener_port;
! 656:
! 657: conn = data;
! 658: conn->listen_data = NULL;
! 659:
! 660: if (listenerfd < 0)
! 661: {
! 662: /* Could not open listener socket */
! 663: peer_connection_trynext(conn);
! 664: return;
! 665: }
! 666:
! 667: od = conn->od;
! 668: gc = od->gc;
! 669: account = purple_connection_get_account(gc);
! 670: conn->listenerfd = listenerfd;
! 671:
! 672: /* Watch for new connections on our listener socket */
! 673: conn->watcher_incoming = purple_input_add(conn->listenerfd,
! 674: PURPLE_INPUT_READ, peer_connection_listen_cb, conn);
! 675:
! 676: /* Send the "please connect to me!" ICBM */
! 677: bos_conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM);
! 678: if (bos_conn == NULL)
! 679: {
! 680: /* Not good */
! 681: peer_connection_trynext(conn);
! 682: return;
! 683: }
! 684:
! 685: if (bos_conn->gsc)
! 686: listener_ip = purple_network_get_my_ip(bos_conn->gsc->fd);
! 687: else
! 688: listener_ip = purple_network_get_my_ip(bos_conn->fd);
! 689:
! 690: ip_atoi = purple_network_ip_atoi(listener_ip);
! 691: if (ip_atoi == NULL) {
! 692: /* Could not convert IP to 4 byte array--weird, but this does
! 693: happen for some users (#4829, Adium #15839). Maybe they're
! 694: connecting with IPv6...? Maybe through a proxy? */
! 695: purple_debug_error("oscar", "Can't ask peer to connect to us "
! 696: "because purple_network_ip_atoi(%s) returned NULL. "
! 697: "fd=%d. is_ssl=%d\n",
! 698: listener_ip ? listener_ip : "(null)",
! 699: bos_conn->gsc ? bos_conn->gsc->fd : bos_conn->fd,
! 700: bos_conn->gsc ? 1 : 0);
! 701: peer_connection_trynext(conn);
! 702: return;
! 703: }
! 704:
! 705: listener_port = purple_network_get_port_from_fd(conn->listenerfd);
! 706:
! 707: if (conn->type == OSCAR_CAPABILITY_DIRECTIM)
! 708: {
! 709: aim_im_sendch2_odc_requestdirect(od,
! 710: conn->cookie, conn->bn, ip_atoi,
! 711: listener_port, ++conn->lastrequestnumber);
! 712:
! 713: /* Print a message to a local conversation window */
! 714: conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, conn->bn);
! 715: tmp = g_strdup_printf(_("Asking %s to connect to us at %s:%hu for "
! 716: "Direct IM."), conn->bn, listener_ip, listener_port);
! 717: purple_conversation_write(conv, NULL, tmp, PURPLE_MESSAGE_SYSTEM, time(NULL));
! 718: g_free(tmp);
! 719: }
! 720: else if (conn->type == OSCAR_CAPABILITY_SENDFILE)
! 721: {
! 722: aim_im_sendch2_sendfile_requestdirect(od,
! 723: conn->cookie, conn->bn,
! 724: ip_atoi,
! 725: listener_port, ++conn->lastrequestnumber,
! 726: (const gchar *)conn->xferdata.name,
! 727: conn->xferdata.size, conn->xferdata.totfiles);
! 728: }
! 729: }
! 730:
! 731: /**
! 732: * This is a callback function used when we're connecting to a peer
! 733: * using either the client IP or the verified IP and the connection
! 734: * took longer than 5 seconds to complete. We do this because
! 735: * waiting for the OS to time out the connection attempt is not
! 736: * practical--the default timeout on many OSes can be 3 minutes or
! 737: * more, and users are impatient.
! 738: *
! 739: * Worst case scenario: the user is connected to the Internet using
! 740: * a modem with severe lag. The peer connections fail and Purple falls
! 741: * back to using a proxied connection. The lower bandwidth
! 742: * limitations imposed by the proxied connection won't matter because
! 743: * the user is using a modem.
! 744: *
! 745: * I suppose this line of thinking is discriminatory against people
! 746: * with very high lag but decent throughput who are transferring
! 747: * large files. But we don't care about those people.
! 748: *
! 749: * I (Sean) changed the timeout from 15 to 5 seconds, as 60 seconds is
! 750: * too long for a user to wait to send a file. I'm also parallelizing
! 751: * requests when possible. The longest we should have to wait now is 10
! 752: * seconds. We shouldn't make it shorter than this.
! 753: */
! 754: static gboolean
! 755: peer_connection_tooktoolong(gpointer data)
! 756: {
! 757: PeerConnection *conn;
! 758:
! 759: conn = data;
! 760:
! 761: purple_debug_info("oscar", "Peer connection timed out after 5 seconds. "
! 762: "Trying next method...\n");
! 763:
! 764: peer_connection_trynext(conn);
! 765:
! 766: /* Cancel this timer. It'll be added again, if needed. */
! 767: return FALSE;
! 768: }
! 769:
! 770: /**
! 771: * Try to establish the given PeerConnection using a defined
! 772: * sequence of steps.
! 773: */
! 774: void
! 775: peer_connection_trynext(PeerConnection *conn)
! 776: {
! 777: PurpleAccount *account;
! 778:
! 779: account = purple_connection_get_account(conn->od->gc);
! 780:
! 781: /*
! 782: * Close any remnants of a previous failed connection attempt.
! 783: */
! 784: peer_connection_close(conn);
! 785:
! 786: /*
! 787: * 1. Attempt to connect to the remote user using their verifiedip and clientip.
! 788: * We try these at the same time and use whichever succeeds first, so we don't
! 789: * have to wait for a timeout.
! 790: */
! 791: if (!(conn->flags & PEER_CONNECTION_FLAG_TRIED_DIRECT) &&
! 792: (conn->verifiedip != NULL) && (conn->port != 0) && (!conn->use_proxy))
! 793: {
! 794: conn->flags |= PEER_CONNECTION_FLAG_TRIED_DIRECT;
! 795:
! 796: if (conn->type == OSCAR_CAPABILITY_DIRECTIM)
! 797: {
! 798: gchar *tmp;
! 799: PurpleConversation *conv;
! 800: tmp = g_strdup_printf(_("Attempting to connect to %s:%hu."),
! 801: conn->verifiedip, conn->port);
! 802: conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, conn->bn);
! 803: purple_conversation_write(conv, NULL, tmp,
! 804: PURPLE_MESSAGE_SYSTEM, time(NULL));
! 805: g_free(tmp);
! 806: }
! 807:
! 808: conn->verified_connect_data = purple_proxy_connect(NULL, account,
! 809: conn->verifiedip, conn->port,
! 810: peer_connection_verified_established_cb, conn);
! 811:
! 812: if ((conn->verifiedip == NULL) ||
! 813: !purple_strequal(conn->verifiedip, conn->clientip))
! 814: {
! 815: conn->client_connect_data = purple_proxy_connect(NULL, account,
! 816: conn->clientip, conn->port,
! 817: peer_connection_client_established_cb, conn);
! 818: }
! 819:
! 820: if ((conn->verified_connect_data != NULL) ||
! 821: (conn->client_connect_data != NULL))
! 822: {
! 823: /* Connecting... */
! 824: conn->connect_timeout_timer = purple_timeout_add_seconds(5,
! 825: peer_connection_tooktoolong, conn);
! 826: return;
! 827: }
! 828: }
! 829:
! 830: /*
! 831: * 2. Attempt to have the remote user connect to us (using both
! 832: * our verifiedip and our clientip).
! 833: */
! 834: if (!(conn->flags & PEER_CONNECTION_FLAG_TRIED_INCOMING) &&
! 835: (!conn->use_proxy))
! 836: {
! 837: conn->flags |= PEER_CONNECTION_FLAG_TRIED_INCOMING;
! 838:
! 839: /*
! 840: * Remote user is connecting to us, so we'll need to verify
! 841: * that the user who connected is our friend.
! 842: */
! 843: conn->flags |= PEER_CONNECTION_FLAG_IS_INCOMING;
! 844:
! 845: conn->listen_data = purple_network_listen_range(5190, 5290, SOCK_STREAM,
! 846: peer_connection_establish_listener_cb, conn);
! 847: if (conn->listen_data != NULL)
! 848: {
! 849: /* Opening listener socket... */
! 850: return;
! 851: }
! 852: }
! 853:
! 854: /*
! 855: * 3. Attempt to have both users connect to an intermediate proxy
! 856: * server.
! 857: */
! 858: if (!(conn->flags & PEER_CONNECTION_FLAG_TRIED_PROXY))
! 859: {
! 860: conn->flags |= PEER_CONNECTION_FLAG_TRIED_PROXY;
! 861:
! 862: /*
! 863: * If we initiate the proxy connection, then the remote user
! 864: * could be anyone, so we need to verify that the user who
! 865: * connected is our friend.
! 866: */
! 867: if (!conn->use_proxy)
! 868: conn->flags |= PEER_CONNECTION_FLAG_IS_INCOMING;
! 869:
! 870: if (conn->type == OSCAR_CAPABILITY_DIRECTIM)
! 871: {
! 872: gchar *tmp;
! 873: PurpleConversation *conv;
! 874: tmp = g_strdup(_("Attempting to connect via proxy server."));
! 875: conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, conn->bn);
! 876: purple_conversation_write(conv, NULL, tmp,
! 877: PURPLE_MESSAGE_SYSTEM, time(NULL));
! 878: g_free(tmp);
! 879: }
! 880:
! 881: conn->verified_connect_data = purple_proxy_connect(NULL, account,
! 882: (conn->proxyip != NULL)
! 883: ? conn->proxyip
! 884: : (conn->od->icq ? ICQ_PEER_PROXY_SERVER : AIM_PEER_PROXY_SERVER),
! 885: PEER_PROXY_PORT,
! 886: peer_proxy_connection_established_cb, conn);
! 887: if (conn->verified_connect_data != NULL)
! 888: {
! 889: /* Connecting... */
! 890: return;
! 891: }
! 892: }
! 893:
! 894: /* Give up! */
! 895: peer_connection_destroy(conn, OSCAR_DISCONNECT_COULD_NOT_CONNECT, NULL);
! 896: }
! 897:
! 898: /**
! 899: * Initiate a peer connection with someone.
! 900: */
! 901: void
! 902: peer_connection_propose(OscarData *od, guint64 type, const char *bn)
! 903: {
! 904: PeerConnection *conn;
! 905:
! 906: if (type == OSCAR_CAPABILITY_DIRECTIM)
! 907: {
! 908: conn = peer_connection_find_by_type(od, bn, type);
! 909: if (conn != NULL)
! 910: {
! 911: if (conn->ready)
! 912: {
! 913: PurpleAccount *account;
! 914: PurpleConversation *conv;
! 915:
! 916: purple_debug_info("oscar", "Already have a direct IM "
! 917: "session with %s.\n", bn);
! 918: account = purple_connection_get_account(od->gc);
! 919: conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM,
! 920: bn, account);
! 921: if (conv != NULL)
! 922: purple_conversation_present(conv);
! 923: return;
! 924: }
! 925:
! 926: /* Cancel the old connection and try again */
! 927: peer_connection_destroy(conn, OSCAR_DISCONNECT_RETRYING, NULL);
! 928: }
! 929: }
! 930:
! 931: conn = peer_connection_new(od, type, bn);
! 932: conn->flags |= PEER_CONNECTION_FLAG_INITIATED_BY_ME;
! 933: conn->flags |= PEER_CONNECTION_FLAG_APPROVED;
! 934: aim_icbm_makecookie(conn->cookie);
! 935:
! 936: peer_connection_trynext(conn);
! 937: }
! 938:
! 939: /**
! 940: * Someone else wants to establish a peer connection with us,
! 941: * and we said yes.
! 942: */
! 943: static void
! 944: peer_connection_got_proposition_yes_cb(gpointer data, gint id)
! 945: {
! 946: PeerConnection *conn;
! 947:
! 948: conn = data;
! 949:
! 950: conn->flags |= PEER_CONNECTION_FLAG_APPROVED;
! 951: peer_connection_trynext(conn);
! 952: }
! 953:
! 954: /**
! 955: * Someone else wants to establish a peer connection with us,
! 956: * and we said no.
! 957: *
! 958: * "Well, one time my friend asked me if I wanted to play the
! 959: * piccolo. But I said no."
! 960: */
! 961: static void
! 962: peer_connection_got_proposition_no_cb(gpointer data, gint id)
! 963: {
! 964: PeerConnection *conn;
! 965:
! 966: conn = data;
! 967:
! 968: aim_im_denytransfer(conn->od, conn->bn, conn->cookie,
! 969: AIM_TRANSFER_DENY_DECLINE);
! 970: peer_connection_destroy(conn, OSCAR_DISCONNECT_LOCAL_CLOSED, NULL);
! 971: }
! 972:
! 973: /**
! 974: * Someone else wants to establish a peer connection with us.
! 975: */
! 976: void
! 977: peer_connection_got_proposition(OscarData *od, const gchar *bn, const gchar *message, IcbmArgsCh2 *args)
! 978: {
! 979: PurpleConnection *gc;
! 980: PurpleAccount *account;
! 981: PeerConnection *conn;
! 982: gchar *buf;
! 983:
! 984: gc = od->gc;
! 985: account = purple_connection_get_account(gc);
! 986:
! 987: /*
! 988: * If we have a connection with this same cookie then they are
! 989: * probably just telling us they weren't able to connect to us
! 990: * and we should try connecting to them, instead. Or they want
! 991: * to go through a proxy.
! 992: */
! 993: conn = peer_connection_find_by_cookie(od, bn, args->cookie);
! 994: if ((conn != NULL) && (conn->type == args->type))
! 995: {
! 996: purple_debug_info("oscar", "Remote user wants to try a "
! 997: "different connection method\n");
! 998: g_free(conn->proxyip);
! 999: g_free(conn->clientip);
! 1000: g_free(conn->verifiedip);
! 1001: if (args->use_proxy)
! 1002: conn->proxyip = g_strdup(args->proxyip);
! 1003: else
! 1004: conn->proxyip = NULL;
! 1005: conn->verifiedip = g_strdup(args->verifiedip);
! 1006: conn->clientip = g_strdup(args->clientip);
! 1007: conn->port = args->port;
! 1008: conn->use_proxy |= args->use_proxy;
! 1009: conn->lastrequestnumber++;
! 1010: peer_connection_trynext(conn);
! 1011: return;
! 1012: }
! 1013:
! 1014: /* If this is a direct IM, then close any existing session */
! 1015: if (args->type == OSCAR_CAPABILITY_DIRECTIM)
! 1016: {
! 1017: conn = peer_connection_find_by_type(od, bn, args->type);
! 1018: if (conn != NULL)
! 1019: {
! 1020: /* Close the old direct IM and start a new one */
! 1021: purple_debug_info("oscar", "Received new direct IM request "
! 1022: "from %s. Destroying old connection.\n", bn);
! 1023: peer_connection_destroy(conn, OSCAR_DISCONNECT_REMOTE_CLOSED, NULL);
! 1024: }
! 1025: }
! 1026:
! 1027: /* Check for proper arguments */
! 1028: if (args->type == OSCAR_CAPABILITY_SENDFILE)
! 1029: {
! 1030: if ((args->info.sendfile.filename == NULL) ||
! 1031: (args->info.sendfile.totsize == 0) ||
! 1032: (args->info.sendfile.totfiles == 0))
! 1033: {
! 1034: purple_debug_warning("oscar",
! 1035: "%s tried to send you a file with incomplete "
! 1036: "information.\n", bn);
! 1037: return;
! 1038: }
! 1039: }
! 1040:
! 1041: conn = peer_connection_new(od, args->type, bn);
! 1042: memcpy(conn->cookie, args->cookie, 8);
! 1043: if (args->use_proxy)
! 1044: conn->proxyip = g_strdup(args->proxyip);
! 1045: conn->clientip = g_strdup(args->clientip);
! 1046: conn->verifiedip = g_strdup(args->verifiedip);
! 1047: conn->port = args->port;
! 1048: conn->use_proxy |= args->use_proxy;
! 1049: conn->lastrequestnumber++;
! 1050:
! 1051: if (args->type == OSCAR_CAPABILITY_DIRECTIM)
! 1052: {
! 1053: buf = g_strdup_printf(_("%s has just asked to directly connect to %s"),
! 1054: bn, purple_account_get_username(account));
! 1055:
! 1056: purple_request_action(conn, NULL, buf,
! 1057: _("This requires a direct connection between "
! 1058: "the two computers and is necessary for IM "
! 1059: "Images. Because your IP address will be "
! 1060: "revealed, this may be considered a privacy "
! 1061: "risk."),
! 1062: PURPLE_DEFAULT_ACTION_NONE,
! 1063: account, bn, NULL,
! 1064: conn, 2,
! 1065: _("C_onnect"), G_CALLBACK(peer_connection_got_proposition_yes_cb),
! 1066: _("Cancel"), G_CALLBACK(peer_connection_got_proposition_no_cb));
! 1067: }
! 1068: else if (args->type == OSCAR_CAPABILITY_SENDFILE)
! 1069: {
! 1070: gchar *filename;
! 1071:
! 1072: conn->xfer = purple_xfer_new(account, PURPLE_XFER_RECEIVE, bn);
! 1073: if (conn->xfer)
! 1074: {
! 1075: conn->xfer->data = conn;
! 1076: purple_xfer_ref(conn->xfer);
! 1077: purple_xfer_set_size(conn->xfer, args->info.sendfile.totsize);
! 1078:
! 1079: /* Set the file name */
! 1080: if (g_utf8_validate(args->info.sendfile.filename, -1, NULL))
! 1081: filename = g_strdup(args->info.sendfile.filename);
! 1082: else
! 1083: filename = purple_utf8_salvage(args->info.sendfile.filename);
! 1084:
! 1085: if (args->info.sendfile.subtype == AIM_OFT_SUBTYPE_SEND_DIR)
! 1086: {
! 1087: /*
! 1088: * If they are sending us a directory then the last character
! 1089: * of the file name will be an asterisk. We don't want to
! 1090: * save stuff to a directory named "*" so we remove the
! 1091: * asterisk from the file name.
! 1092: */
! 1093: char *tmp = strrchr(filename, '\\');
! 1094: if ((tmp != NULL) && (tmp[1] == '*'))
! 1095: tmp[0] = '\0';
! 1096: }
! 1097: purple_xfer_set_filename(conn->xfer, filename);
! 1098: g_free(filename);
! 1099:
! 1100: /*
! 1101: * Set the message, unless this is the dummy message from an
! 1102: * ICQ client or an empty message from an AIM client.
! 1103: * TODO: Maybe we should strip HTML and then see if strlen>0?
! 1104: */
! 1105: if ((message != NULL) &&
! 1106: (g_ascii_strncasecmp(message, "<ICQ_COOL_FT>", 13) != 0) &&
! 1107: (g_ascii_strcasecmp(message, "<HTML>") != 0))
! 1108: {
! 1109: purple_xfer_set_message(conn->xfer, message);
! 1110: }
! 1111:
! 1112: /* Setup our I/O op functions */
! 1113: purple_xfer_set_init_fnc(conn->xfer, peer_oft_recvcb_init);
! 1114: purple_xfer_set_end_fnc(conn->xfer, peer_oft_recvcb_end);
! 1115: purple_xfer_set_request_denied_fnc(conn->xfer, peer_oft_cb_generic_cancel);
! 1116: purple_xfer_set_cancel_recv_fnc(conn->xfer, peer_oft_cb_generic_cancel);
! 1117: purple_xfer_set_ack_fnc(conn->xfer, peer_oft_recvcb_ack_recv);
! 1118:
! 1119: /* Now perform the request */
! 1120: purple_xfer_request(conn->xfer);
! 1121: }
! 1122: }
! 1123: }
! 1124:
! 1125: /*******************************************************************/
! 1126: /* End code for establishing a peer connection */
! 1127: /*******************************************************************/
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to peer.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