Annotation of ChivanetAimPidgin/oscarprpl/src/c/flap_connection.c, revision 1.1.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: #include "oscar.h"
22:
23: #include "eventloop.h"
24: #include "proxy.h"
25:
26: #ifndef _WIN32
27: #include <netdb.h>
28: #include <sys/socket.h>
29: #include <netinet/in.h>
30: #endif
31:
32: #ifdef _WIN32
33: #include "win32dep.h"
34: #endif
35:
36: /**
37: * This sends a channel 1 SNAC containing the FLAP version.
38: * The FLAP version is sent by itself at the beginning of every
39: * connection to a FLAP server. It is always the very first
40: * packet sent by both the server and the client after the SYN,
41: * SYN/ACK, ACK handshake.
42: */
43: void
44: flap_connection_send_version(OscarData *od, FlapConnection *conn)
45: {
46: FlapFrame *frame;
47:
48: frame = flap_frame_new(od, 0x01, 4);
49: byte_stream_put32(&frame->data, 0x00000001); /* FLAP Version */
50: flap_connection_send(conn, frame);
51: }
52:
53: /**
54: * This sends a channel 1 FLAP containing the FLAP version and
55: * the authentication cookie. This is sent when connecting to
56: * any FLAP server after the initial connection to the auth
57: * server. It is always the very first packet sent by both the
58: * server and the client after the SYN, SYN/ACK, ACK handshake.
59: */
60: void
61: flap_connection_send_version_with_cookie(OscarData *od, FlapConnection *conn, guint16 length, const guint8 *chipsahoy)
62: {
63: FlapFrame *frame;
64: GSList *tlvlist = NULL;
65:
66: frame = flap_frame_new(od, 0x01, 4 + 2 + 2 + length);
67: byte_stream_put32(&frame->data, 0x00000001); /* FLAP Version */
68: aim_tlvlist_add_raw(&tlvlist, 0x0006, length, chipsahoy);
69: aim_tlvlist_write(&frame->data, &tlvlist);
70: aim_tlvlist_free(tlvlist);
71:
72: flap_connection_send(conn, frame);
73: }
74:
75: void
76: flap_connection_send_version_with_cookie_and_clientinfo(OscarData *od, FlapConnection *conn, guint16 length, const guint8 *chipsahoy, ClientInfo *ci, gboolean allow_multiple_logins)
77: {
78: FlapFrame *frame;
79: GSList *tlvlist = NULL;
80:
81: frame = flap_frame_new(od, 0x01, 1152 + length);
82:
83: byte_stream_put32(&frame->data, 0x00000001); /* FLAP Version */
84: aim_tlvlist_add_raw(&tlvlist, 0x0006, length, chipsahoy);
85:
86: if (ci->clientstring != NULL)
87: aim_tlvlist_add_str(&tlvlist, 0x0003, ci->clientstring);
88: else {
89: gchar *clientstring = oscar_get_clientstring();
90: aim_tlvlist_add_str(&tlvlist, 0x0003, clientstring);
91: g_free(clientstring);
92: }
93: aim_tlvlist_add_16(&tlvlist, 0x0017, (guint16)ci->major);
94: aim_tlvlist_add_16(&tlvlist, 0x0018, (guint16)ci->minor);
95: aim_tlvlist_add_16(&tlvlist, 0x0019, (guint16)ci->point);
96: aim_tlvlist_add_16(&tlvlist, 0x001a, (guint16)ci->build);
97: aim_tlvlist_add_8(&tlvlist, 0x004a, (allow_multiple_logins ? 0x01 : 0x03));
98:
99: aim_tlvlist_write(&frame->data, &tlvlist);
100:
101: aim_tlvlist_free(tlvlist);
102:
103: flap_connection_send(conn, frame);
104: }
105:
106: static struct rateclass *
107: flap_connection_get_rateclass(FlapConnection *conn, guint16 family, guint16 subtype)
108: {
109: gconstpointer key;
110: gpointer rateclass;
111:
112: key = GUINT_TO_POINTER((family << 16) + subtype);
113: rateclass = g_hash_table_lookup(conn->rateclass_members, key);
114: if (rateclass != NULL)
115: return rateclass;
116:
117: return conn->default_rateclass;
118: }
119:
120: /*
121: * Attempt to calculate what our new current average would be if we
122: * were to send a SNAC in this rateclass at the given time.
123: */
124: static guint32
125: rateclass_get_new_current(FlapConnection *conn, struct rateclass *rateclass, struct timeval *now)
126: {
127: unsigned long timediff; /* In milliseconds */
128: guint32 current;
129:
130: /* This formula is documented at http://dev.aol.com/aim/oscar/#RATELIMIT */
131: timediff = (now->tv_sec - rateclass->last.tv_sec) * 1000 + (now->tv_usec - rateclass->last.tv_usec) / 1000;
132: current = ((rateclass->current * (rateclass->windowsize - 1)) + timediff) / rateclass->windowsize;
133:
134: return MIN(current, rateclass->max);
135: }
136:
137: /*
138: * Attempt to send the contents of a given queue
139: *
140: * @return TRUE if the queue was completely emptied or was initially
141: * empty; FALSE if rate limiting prevented it from being
142: * emptied.
143: */
144: static gboolean flap_connection_send_snac_queue(FlapConnection *conn, struct timeval now, GQueue *queue)
145: {
146: while (!g_queue_is_empty(queue))
147: {
148: QueuedSnac *queued_snac;
149: struct rateclass *rateclass;
150:
151: queued_snac = g_queue_peek_head(queue);
152:
153: rateclass = flap_connection_get_rateclass(conn, queued_snac->family, queued_snac->subtype);
154: if (rateclass != NULL)
155: {
156: guint32 new_current;
157:
158: new_current = rateclass_get_new_current(conn, rateclass, &now);
159:
160: if (rateclass->dropping_snacs || new_current <= rateclass->alert)
161: /* Not ready to send this SNAC yet--keep waiting. */
162: return FALSE;
163:
164: rateclass->current = new_current;
165: rateclass->last.tv_sec = now.tv_sec;
166: rateclass->last.tv_usec = now.tv_usec;
167: }
168:
169: flap_connection_send(conn, queued_snac->frame);
170: g_free(queued_snac);
171: g_queue_pop_head(queue);
172: }
173:
174: /* We emptied the queue */
175: return TRUE;
176: }
177:
178: static gboolean flap_connection_send_queued(gpointer data)
179: {
180: FlapConnection *conn;
181: struct timeval now;
182:
183: conn = data;
184: gettimeofday(&now, NULL);
185:
186: purple_debug_info("oscar", "Attempting to send %u queued SNACs and %u queued low-priority SNACs for %p\n",
187: (conn->queued_snacs ? conn->queued_snacs->length : 0),
188: (conn->queued_lowpriority_snacs ? conn->queued_lowpriority_snacs->length : 0),
189: conn);
190: if (!conn->queued_snacs || flap_connection_send_snac_queue(conn, now, conn->queued_snacs)) {
191: if (!conn->queued_lowpriority_snacs || flap_connection_send_snac_queue(conn, now, conn->queued_lowpriority_snacs)) {
192: /* Both queues emptied. */
193: conn->queued_timeout = 0;
194: return FALSE;
195: }
196: }
197:
198: /* We couldn't send all our SNACs. Keep trying */
199: return TRUE;
200: }
201:
202: /**
203: * This sends a channel 2 FLAP containing a SNAC. The SNAC family and
204: * subtype are looked up in the rate info for this connection, and if
205: * sending this SNAC will induce rate limiting then we delay sending
206: * of the SNAC by putting it into an outgoing holding queue.
207: *
208: * @param data The optional bytestream that makes up the data portion
209: * of this SNAC. For empty SNACs this should be NULL.
210: * @param high_priority If TRUE, the SNAC will be queued normally if
211: * needed. If FALSE, it will be queued separately, to be sent
212: * only if all high priority SNACs have been sent.
213: */
214: void
215: flap_connection_send_snac_with_priority(OscarData *od, FlapConnection *conn, guint16 family, const guint16 subtype, aim_snacid_t snacid, ByteStream *data, gboolean high_priority)
216: {
217: FlapFrame *frame;
218: guint32 length;
219: gboolean enqueue = FALSE;
220: struct rateclass *rateclass;
221:
222: length = data != NULL ? data->offset : 0;
223:
224: frame = flap_frame_new(od, 0x02, 10 + length);
225: aim_putsnac(&frame->data, family, subtype, snacid);
226:
227: if (length > 0)
228: {
229: byte_stream_rewind(data);
230: byte_stream_putbs(&frame->data, data, length);
231: }
232:
233: if (conn->queued_timeout != 0)
234: enqueue = TRUE;
235: else if ((rateclass = flap_connection_get_rateclass(conn, family, subtype)) != NULL)
236: {
237: struct timeval now;
238: guint32 new_current;
239:
240: gettimeofday(&now, NULL);
241: new_current = rateclass_get_new_current(conn, rateclass, &now);
242:
243: if (rateclass->dropping_snacs || new_current <= rateclass->alert)
244: {
245: purple_debug_info("oscar", "Current rate for conn %p would be %u, but we alert at %u; enqueueing\n", conn, new_current, rateclass->alert);
246:
247: enqueue = TRUE;
248: }
249: else
250: {
251: rateclass->current = new_current;
252: rateclass->last.tv_sec = now.tv_sec;
253: rateclass->last.tv_usec = now.tv_usec;
254: }
255: }
256:
257: if (enqueue)
258: {
259: /* We've been sending too fast, so delay this message */
260: QueuedSnac *queued_snac;
261:
262: queued_snac = g_new(QueuedSnac, 1);
263: queued_snac->family = family;
264: queued_snac->subtype = subtype;
265: queued_snac->frame = frame;
266:
267: if (high_priority) {
268: if (!conn->queued_snacs)
269: conn->queued_snacs = g_queue_new();
270: g_queue_push_tail(conn->queued_snacs, queued_snac);
271: } else {
272: if (!conn->queued_lowpriority_snacs)
273: conn->queued_lowpriority_snacs = g_queue_new();
274: g_queue_push_tail(conn->queued_lowpriority_snacs, queued_snac);
275: }
276:
277: if (conn->queued_timeout == 0)
278: conn->queued_timeout = purple_timeout_add(500, flap_connection_send_queued, conn);
279:
280: return;
281: }
282:
283: flap_connection_send(conn, frame);
284: }
285:
286: void
287: flap_connection_send_snac(OscarData *od, FlapConnection *conn, guint16 family, const guint16 subtype, aim_snacid_t snacid, ByteStream *data)
288: {
289: flap_connection_send_snac_with_priority(od, conn, family, subtype, snacid, data, TRUE);
290: }
291:
292: /**
293: * This sends an empty channel 4 FLAP. This is sent to signify
294: * that we're logging off. This shouldn't really be necessary--
295: * usually the AIM server will detect that the TCP connection has
296: * been destroyed--but it's good practice.
297: */
298: static void
299: flap_connection_send_close(OscarData *od, FlapConnection *conn)
300: {
301: FlapFrame *frame;
302:
303: frame = flap_frame_new(od, 0x04, 0);
304: flap_connection_send(conn, frame);
305: }
306:
307: /**
308: * This sends an empty channel 5 FLAP. This is used as a keepalive
309: * packet in FLAP connections. WinAIM 4.x and higher send these
310: * _every minute_ to keep the connection alive.
311: */
312: void
313: flap_connection_send_keepalive(OscarData *od, FlapConnection *conn)
314: {
315: FlapFrame *frame;
316:
317: frame = flap_frame_new(od, 0x05, 0);
318: flap_connection_send(conn, frame);
319:
320: /* clean out SNACs over 60sec old */
321: aim_cleansnacs(od, 60);
322: }
323:
324: /**
325: * Allocate a new empty connection structure.
326: *
327: * @param od The oscar session associated with this connection.
328: * @param type Type of connection to create
329: *
330: * @return Returns the new connection structure.
331: */
332: FlapConnection *
333: flap_connection_new(OscarData *od, int type)
334: {
335: FlapConnection *conn;
336:
337: conn = g_new0(FlapConnection, 1);
338: conn->od = od;
339: conn->buffer_outgoing = purple_circ_buffer_new(0);
340: conn->fd = -1;
341: conn->subtype = -1;
342: conn->type = type;
343: conn->rateclass_members = g_hash_table_new(g_direct_hash, g_direct_equal);
344:
345: od->oscar_connections = g_slist_prepend(od->oscar_connections, conn);
346:
347: return conn;
348: }
349:
350: /**
351: * Close (but not free) a connection.
352: *
353: * This cancels any currently pending connection attempt,
354: * closes any open fd and frees the auth cookie.
355: *
356: * @param conn The connection to close.
357: */
358: void
359: flap_connection_close(OscarData *od, FlapConnection *conn)
360: {
361: if (conn->connect_data != NULL)
362: {
363: purple_proxy_connect_cancel(conn->connect_data);
364: conn->connect_data = NULL;
365: }
366:
367: if (conn->gsc != NULL && conn->gsc->connect_data != NULL)
368: {
369: purple_ssl_close(conn->gsc);
370: conn->gsc = NULL;
371: }
372:
373: if (conn->new_conn_data != NULL)
374: {
375: if (conn->type == SNAC_FAMILY_CHAT)
376: {
377: oscar_chat_destroy(conn->new_conn_data);
378: conn->new_conn_data = NULL;
379: }
380: }
381:
382: if ((conn->fd >= 0 || conn->gsc != NULL)
383: && conn->type == SNAC_FAMILY_LOCATE)
384: flap_connection_send_close(od, conn);
385:
386: if (conn->watcher_incoming != 0)
387: {
388: purple_input_remove(conn->watcher_incoming);
389: conn->watcher_incoming = 0;
390: }
391:
392: if (conn->watcher_outgoing != 0)
393: {
394: purple_input_remove(conn->watcher_outgoing);
395: conn->watcher_outgoing = 0;
396: }
397:
398: if (conn->fd >= 0)
399: {
400: close(conn->fd);
401: conn->fd = -1;
402: }
403:
404: if (conn->gsc != NULL)
405: {
406: purple_ssl_close(conn->gsc);
407: conn->gsc = NULL;
408: }
409:
410: g_free(conn->buffer_incoming.data.data);
411: conn->buffer_incoming.data.data = NULL;
412:
413: purple_circ_buffer_destroy(conn->buffer_outgoing);
414: conn->buffer_outgoing = NULL;
415: }
416:
417: /**
418: * Free a FlapFrame
419: *
420: * @param frame The frame to free.
421: */
422: static void
423: flap_frame_destroy(FlapFrame *frame)
424: {
425: g_free(frame->data.data);
426: g_free(frame);
427: }
428:
429: static gboolean
430: flap_connection_destroy_cb(gpointer data)
431: {
432: FlapConnection *conn;
433: OscarData *od;
434: PurpleAccount *account;
435: aim_rxcallback_t userfunc;
436:
437: conn = data;
438: /* Explicitly added for debugging #5927. Don't re-order this, only
439: * consider removing it.
440: */
441: purple_debug_info("oscar", "Destroying FLAP connection %p\n", conn);
442:
443: od = conn->od;
444: account = purple_connection_get_account(od->gc);
445:
446: purple_debug_info("oscar", "Destroying oscar connection (%p) of "
447: "type 0x%04hx. Disconnect reason is %d\n", conn,
448: conn->type, conn->disconnect_reason);
449:
450: od->oscar_connections = g_slist_remove(od->oscar_connections, conn);
451:
452: if ((userfunc = aim_callhandler(od, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR)))
453: userfunc(od, conn, NULL, conn->disconnect_code, conn->error_message);
454:
455: /*
456: * TODO: If we don't have a SNAC_FAMILY_LOCATE connection then
457: * we should try to request one instead of disconnecting.
458: */
459: if (!account->disconnecting && ((od->oscar_connections == NULL)
460: || (!flap_connection_getbytype(od, SNAC_FAMILY_LOCATE))))
461: {
462: /* No more FLAP connections! Sign off this PurpleConnection! */
463: gchar *tmp;
464: PurpleConnectionError reason = PURPLE_CONNECTION_ERROR_NETWORK_ERROR;
465:
466: if (conn->disconnect_code == 0x0001) {
467: reason = PURPLE_CONNECTION_ERROR_NAME_IN_USE;
468: tmp = g_strdup(_("You have signed on from another location"));
469: if (!purple_account_get_remember_password(account))
470: purple_account_set_password(account, NULL);
471: } else if (conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_CLOSED)
472: tmp = g_strdup(_("Server closed the connection"));
473: else if (conn->disconnect_reason == OSCAR_DISCONNECT_LOST_CONNECTION)
474: tmp = g_strdup_printf(_("Lost connection with server: %s"),
475: conn->error_message);
476: else if (conn->disconnect_reason == OSCAR_DISCONNECT_INVALID_DATA)
477: tmp = g_strdup(_("Received invalid data on connection with server"));
478: else if (conn->disconnect_reason == OSCAR_DISCONNECT_COULD_NOT_CONNECT)
479: tmp = g_strdup_printf(_("Unable to connect: %s"),
480: conn->error_message);
481: else
482: /*
483: * We shouldn't print a message for some disconnect_reasons.
484: * Like OSCAR_DISCONNECT_LOCAL_CLOSED.
485: */
486: tmp = NULL;
487:
488: if (tmp != NULL)
489: {
490: purple_connection_error_reason(od->gc, reason, tmp);
491: g_free(tmp);
492: }
493: }
494:
495: flap_connection_close(od, conn);
496:
497: g_free(conn->error_message);
498: g_free(conn->cookie);
499:
500: /*
501: * Free conn->internal, if necessary
502: */
503: if (conn->type == SNAC_FAMILY_CHAT)
504: flap_connection_destroy_chat(od, conn);
505:
506: g_slist_free(conn->groups);
507: while (conn->rateclasses != NULL)
508: {
509: g_free(conn->rateclasses->data);
510: conn->rateclasses = g_slist_delete_link(conn->rateclasses, conn->rateclasses);
511: }
512:
513: g_hash_table_destroy(conn->rateclass_members);
514:
515: if (conn->queued_snacs) {
516: while (!g_queue_is_empty(conn->queued_snacs))
517: {
518: QueuedSnac *queued_snac;
519: queued_snac = g_queue_pop_head(conn->queued_snacs);
520: flap_frame_destroy(queued_snac->frame);
521: g_free(queued_snac);
522: }
523: g_queue_free(conn->queued_snacs);
524: }
525:
526: if (conn->queued_lowpriority_snacs) {
527: while (!g_queue_is_empty(conn->queued_lowpriority_snacs))
528: {
529: QueuedSnac *queued_snac;
530: queued_snac = g_queue_pop_head(conn->queued_lowpriority_snacs);
531: flap_frame_destroy(queued_snac->frame);
532: g_free(queued_snac);
533: }
534: g_queue_free(conn->queued_lowpriority_snacs);
535: }
536:
537: if (conn->queued_timeout > 0)
538: purple_timeout_remove(conn->queued_timeout);
539:
540: g_free(conn);
541:
542: return FALSE;
543: }
544:
545: /**
546: * See the comments for the parameters of
547: * flap_connection_schedule_destroy().
548: */
549: void
550: flap_connection_destroy(FlapConnection *conn, OscarDisconnectReason reason, const gchar *error_message)
551: {
552: if (conn->destroy_timeout != 0)
553: purple_timeout_remove(conn->destroy_timeout);
554: conn->disconnect_reason = reason;
555: g_free(conn->error_message);
556: conn->error_message = g_strdup(error_message);
557: flap_connection_destroy_cb(conn);
558: }
559:
560: /**
561: * Schedule Purple to destroy the given FlapConnection as soon as we
562: * return control back to the program's main loop. We must do this
563: * if we want to destroy the connection but we are still using it
564: * for some reason.
565: *
566: * @param reason The reason for the disconnection.
567: * @param error_message A brief error message that gives more detail
568: * regarding the reason for the disconnecting. This should
569: * be NULL for everything except OSCAR_DISCONNECT_LOST_CONNECTION,
570: * in which case it should contain the value of g_strerror(errno),
571: * and OSCAR_DISCONNECT_COULD_NOT_CONNECT, in which case it
572: * should contain the error_message passed back from the call
573: * to purple_proxy_connect().
574: */
575: void
576: flap_connection_schedule_destroy(FlapConnection *conn, OscarDisconnectReason reason, const gchar *error_message)
577: {
578: if (conn->destroy_timeout != 0)
579: /* Already taken care of */
580: return;
581:
582: purple_debug_info("oscar", "Scheduling destruction of FLAP "
583: "connection %p of type 0x%04hx\n", conn, conn->type);
584: conn->disconnect_reason = reason;
585: g_free(conn->error_message);
586: conn->error_message = g_strdup(error_message);
587: conn->destroy_timeout = purple_timeout_add(0, flap_connection_destroy_cb, conn);
588: }
589:
590: /**
591: * In OSCAR, every connection has a set of SNAC groups associated
592: * with it. These are the groups that you can send over this connection
593: * without being guaranteed a "Not supported" SNAC error.
594: *
595: * The grand theory of things says that these associations transcend
596: * what libfaim calls "connection types" (conn->type). You can probably
597: * see the elegance here, but since I want to revel in it for a bit, you
598: * get to hear it all spelled out.
599: *
600: * So let us say that you have your core BOS connection running. One
601: * of your modules has just given you a SNAC of the group 0x0004 to send
602: * you. Maybe an IM destined for some twit in Greenland. So you start
603: * at the top of your connection list, looking for a connection that
604: * claims to support group 0x0004. You find one. Why, that neat BOS
605: * connection of yours can do that. So you send it on its way.
606: *
607: * Now, say, that fellow from Greenland has friends and they all want to
608: * meet up with you in a lame chat room. This has landed you a SNAC
609: * in the family 0x000e and you have to admit you're a bit lost. You've
610: * searched your connection list for someone who wants to make your life
611: * easy and deliver this SNAC for you, but there isn't one there.
612: *
613: * Here comes the good bit. Without even letting anyone know, particularly
614: * the module that decided to send this SNAC, and definitely not that twit
615: * in Greenland, you send out a service request. In this request, you have
616: * marked the need for a connection supporting group 0x000e. A few seconds
617: * later, you receive a service redirect with an IP address and a cookie in
618: * it. Great, you say. Now I have something to do. Off you go, making
619: * that connection. One of the first things you get from this new server
620: * is a message saying that indeed it does support the group you were looking
621: * for. So you continue and send rate confirmation and all that.
622: *
623: * Then you remember you had that SNAC to send, and now you have a means to
624: * do it, and you do, and everyone is happy. Except the Greenlander, who is
625: * still stuck in the bitter cold.
626: *
627: * Oh, and this is useful for building the Migration SNACs, too. In the
628: * future, this may help convince me to implement rate limit mitigation
629: * for real. We'll see.
630: *
631: * Just to make me look better, I'll say that I've known about this great
632: * scheme for quite some time now. But I still haven't convinced myself
633: * to make libfaim work that way. It would take a fair amount of effort,
634: * and probably some client API changes as well. (Whenever I don't want
635: * to do something, I just say it would change the client API. Then I
636: * instantly have a couple of supporters of not doing it.)
637: *
638: * Generally, addgroup is only called by the internal handling of the
639: * server ready SNAC. So if you want to do something before that, you'll
640: * have to be more creative. That is done rather early, though, so I don't
641: * think you have to worry about it. Unless you're me. I care deeply
642: * about such inane things.
643: *
644: */
645:
646: /**
647: * Find a FlapConnection that supports the given oscar
648: * family.
649: */
650: FlapConnection *
651: flap_connection_findbygroup(OscarData *od, guint16 group)
652: {
653: GSList *cur;
654:
655: for (cur = od->oscar_connections; cur != NULL; cur = cur->next)
656: {
657: FlapConnection *conn;
658: GSList *l;
659:
660: conn = cur->data;
661:
662: for (l = conn->groups; l != NULL; l = l->next)
663: {
664: if (GPOINTER_TO_UINT(l->data) == group)
665: return conn;
666: }
667: }
668:
669: return NULL;
670: }
671:
672: /**
673: * Locates a connection of the specified type in the
674: * specified session.
675: *
676: * TODO: Use flap_connection_findbygroup everywhere and get rid of this.
677: *
678: * @param od The session to search.
679: * @param type The type of connection to look for.
680: *
681: * @return Returns the first connection found of the given target type,
682: * or NULL if none could be found.
683: */
684: FlapConnection *
685: flap_connection_getbytype(OscarData *od, int type)
686: {
687: GSList *cur;
688:
689: for (cur = od->oscar_connections; cur != NULL; cur = cur->next)
690: {
691: FlapConnection *conn;
692: conn = cur->data;
693: if ((conn->type == type) && (conn->connected))
694: return conn;
695: }
696:
697: return NULL;
698: }
699:
700: FlapConnection *
701: flap_connection_getbytype_all(OscarData *od, int type)
702: {
703: GSList *cur;
704:
705: for (cur = od->oscar_connections; cur; cur = cur->next)
706: {
707: FlapConnection *conn;
708: conn = cur->data;
709: if (conn->type == type)
710: return conn;
711: }
712:
713: return NULL;
714: }
715:
716: /**
717: * Allocate a new FLAP frame.
718: *
719: * @param channel The FLAP channel. This is almost always 2.
720: */
721: FlapFrame *
722: flap_frame_new(OscarData *od, guint16 channel, int datalen)
723: {
724: FlapFrame *frame;
725:
726: frame = g_new0(FlapFrame, 1);
727: frame->channel = channel;
728:
729: if (datalen > 0)
730: byte_stream_new(&frame->data, datalen);
731:
732: return frame;
733: }
734:
735: static void
736: parse_snac(OscarData *od, FlapConnection *conn, FlapFrame *frame)
737: {
738: aim_module_t *cur;
739: aim_modsnac_t snac;
740:
741: if (byte_stream_bytes_left(&frame->data) < 10)
742: return;
743:
744: snac.family = byte_stream_get16(&frame->data);
745: snac.subtype = byte_stream_get16(&frame->data);
746: snac.flags = byte_stream_get16(&frame->data);
747: snac.id = byte_stream_get32(&frame->data);
748:
749: /* SNAC flags are apparently uniform across all SNACs, so we handle them here */
750: if (snac.flags & 0x0001) {
751: /*
752: * This means the SNAC will be followed by another SNAC with
753: * related information. We don't need to do anything about
754: * this here.
755: */
756: }
757: if (snac.flags & 0x8000) {
758: /*
759: * This packet contains the version of the family that this SNAC is
760: * in. You get this when your SSI module is version 2 or higher.
761: * For now we have no need for this, but you could always save
762: * it as a part of aim_modnsac_t, or something. The format is...
763: * 2 byte length of total mini-header (which is 6 bytes), then TLV
764: * of type 0x0001, length 0x0002, value is the 2 byte version
765: * number
766: */
767: byte_stream_advance(&frame->data, byte_stream_get16(&frame->data));
768: }
769:
770: for (cur = (aim_module_t *)od->modlistv; cur; cur = cur->next) {
771:
772: if (!(cur->flags & AIM_MODFLAG_MULTIFAMILY) &&
773: (cur->family != snac.family))
774: continue;
775:
776: if (cur->snachandler(od, conn, cur, frame, &snac, &frame->data))
777: return;
778: }
779: }
780:
781: static void
782: parse_fakesnac(OscarData *od, FlapConnection *conn, FlapFrame *frame, guint16 family, guint16 subtype)
783: {
784: aim_module_t *cur;
785: aim_modsnac_t snac;
786:
787: snac.family = family;
788: snac.subtype = subtype;
789: snac.flags = snac.id = 0;
790:
791: for (cur = (aim_module_t *)od->modlistv; cur; cur = cur->next) {
792:
793: if (!(cur->flags & AIM_MODFLAG_MULTIFAMILY) &&
794: (cur->family != snac.family))
795: continue;
796:
797: if (cur->snachandler(od, conn, cur, frame, &snac, &frame->data))
798: return;
799: }
800: }
801:
802: static void
803: parse_flap_ch4(OscarData *od, FlapConnection *conn, FlapFrame *frame)
804: {
805: GSList *tlvlist;
806: char *msg = NULL;
807:
808: if (byte_stream_bytes_left(&frame->data) == 0) {
809: /* XXX should do something with this */
810: return;
811: }
812:
813: /* An ICQ account is logging in */
814: if (conn->type == SNAC_FAMILY_AUTH)
815: {
816: parse_fakesnac(od, conn, frame, 0x0017, 0x0003);
817: return;
818: }
819:
820: tlvlist = aim_tlvlist_read(&frame->data);
821:
822: if (aim_tlv_gettlv(tlvlist, 0x0009, 1))
823: conn->disconnect_code = aim_tlv_get16(tlvlist, 0x0009, 1);
824:
825: if (aim_tlv_gettlv(tlvlist, 0x000b, 1))
826: msg = aim_tlv_getstr(tlvlist, 0x000b, 1);
827:
828: /*
829: * The server ended this FLAP connnection, so let's be nice and
830: * close the physical TCP connection
831: */
832: flap_connection_schedule_destroy(conn,
833: OSCAR_DISCONNECT_REMOTE_CLOSED, msg);
834:
835: aim_tlvlist_free(tlvlist);
836:
837: g_free(msg);
838: }
839:
840: /**
841: * Takes a new incoming FLAP frame and sends it to the appropriate
842: * handler function to be parsed.
843: */
844: static void
845: parse_flap(OscarData *od, FlapConnection *conn, FlapFrame *frame)
846: {
847: if (frame->channel == 0x01) {
848: guint32 flap_version = byte_stream_get32(&frame->data);
849: if (flap_version != 0x00000001)
850: {
851: /* Error! */
852: purple_debug_warning("oscar", "Expecting FLAP version "
853: "0x00000001 but received FLAP version %08x. Closing connection.\n",
854: flap_version);
855: flap_connection_schedule_destroy(conn,
856: OSCAR_DISCONNECT_INVALID_DATA, NULL);
857: }
858: else
859: conn->connected = TRUE;
860:
861: } else if (frame->channel == 0x02) {
862: parse_snac(od, conn, frame);
863:
864: } else if (frame->channel == 0x04) {
865: parse_flap_ch4(od, conn, frame);
866:
867: } else if (frame->channel == 0x05) {
868: /* TODO: Reset our keepalive watchdog? */
869:
870: }
871: }
872:
873: /**
874: * Read in all available data on the socket for a given connection.
875: * All complete FLAPs handled immedate after they're received.
876: * Incomplete FLAP data is stored locally and appended to the next
877: * time this callback is triggered.
878: *
879: * This is called by flap_connection_recv_cb and
880: * flap_connection_recv_cb_ssl for unencrypted/encrypted connections.
881: */
882: static void
883: flap_connection_recv(FlapConnection *conn)
884: {
885: gpointer buf;
886: gsize buflen;
887: gssize read;
888:
889: /* Read data until we run out of data and break out of the loop */
890: while (TRUE)
891: {
892: /* Start reading a new FLAP */
893: if (conn->buffer_incoming.data.data == NULL)
894: {
895: buf = conn->header + conn->header_received;
896: buflen = 6 - conn->header_received;
897:
898: /* Read the first 6 bytes (the FLAP header) */
899: if (conn->gsc)
900: read = purple_ssl_read(conn->gsc, buf, buflen);
901: else
902: read = recv(conn->fd, buf, buflen, 0);
903:
904: /* Check if the FLAP server closed the connection */
905: if (read == 0)
906: {
907: flap_connection_schedule_destroy(conn,
908: OSCAR_DISCONNECT_REMOTE_CLOSED, NULL);
909: break;
910: }
911:
912: /* If there was an error then close the connection */
913: if (read < 0)
914: {
915: if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
916: /* No worries */
917: break;
918:
919: /* Error! */
920: flap_connection_schedule_destroy(conn,
921: OSCAR_DISCONNECT_LOST_CONNECTION, g_strerror(errno));
922: break;
923: }
924: conn->od->gc->last_received = time(NULL);
925:
926: /* If we don't even have a complete FLAP header then do nothing */
927: conn->header_received += read;
928: if (conn->header_received < 6)
929: break;
930:
931: /* All FLAP frames must start with the byte 0x2a */
932: if (aimutil_get8(&conn->header[0]) != 0x2a)
933: {
934: flap_connection_schedule_destroy(conn,
935: OSCAR_DISCONNECT_INVALID_DATA, NULL);
936: break;
937: }
938:
939: /* Initialize a new temporary FlapFrame for incoming data */
940: conn->buffer_incoming.channel = aimutil_get8(&conn->header[1]);
941: conn->buffer_incoming.seqnum = aimutil_get16(&conn->header[2]);
942: conn->buffer_incoming.data.len = aimutil_get16(&conn->header[4]);
943: conn->buffer_incoming.data.data = g_new(guint8, conn->buffer_incoming.data.len);
944: conn->buffer_incoming.data.offset = 0;
945: }
946:
947: buflen = conn->buffer_incoming.data.len - conn->buffer_incoming.data.offset;
948: if (buflen)
949: {
950: buf = &conn->buffer_incoming.data.data[conn->buffer_incoming.data.offset];
951: /* Read data into the temporary FlapFrame until it is complete */
952: if (conn->gsc)
953: read = purple_ssl_read(conn->gsc, buf, buflen);
954: else
955: read = recv(conn->fd, buf, buflen, 0);
956:
957: /* Check if the FLAP server closed the connection */
958: if (read == 0)
959: {
960: flap_connection_schedule_destroy(conn,
961: OSCAR_DISCONNECT_REMOTE_CLOSED, NULL);
962: break;
963: }
964:
965: if (read < 0)
966: {
967: if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
968: /* No worries */
969: break;
970:
971: /* Error! */
972: flap_connection_schedule_destroy(conn,
973: OSCAR_DISCONNECT_LOST_CONNECTION, g_strerror(errno));
974: break;
975: }
976:
977: conn->buffer_incoming.data.offset += read;
978: if (conn->buffer_incoming.data.offset < conn->buffer_incoming.data.len)
979: /* Waiting for more data to arrive */
980: break;
981: }
982:
983: /* We have a complete FLAP! Handle it and continue reading */
984: byte_stream_rewind(&conn->buffer_incoming.data);
985: parse_flap(conn->od, conn, &conn->buffer_incoming);
986: conn->lastactivity = time(NULL);
987:
988: g_free(conn->buffer_incoming.data.data);
989: conn->buffer_incoming.data.data = NULL;
990:
991: conn->header_received = 0;
992: }
993: }
994:
995: void
996: flap_connection_recv_cb(gpointer data, gint source, PurpleInputCondition cond)
997: {
998: FlapConnection *conn = data;
999:
1000: flap_connection_recv(conn);
1001: }
1002:
1003: void
1004: flap_connection_recv_cb_ssl(gpointer data, PurpleSslConnection *gsc, PurpleInputCondition cond)
1005: {
1006: FlapConnection *conn = data;
1007:
1008: flap_connection_recv(conn);
1009: }
1010:
1011: /**
1012: * @param source When this function is called as a callback source is
1013: * set to the fd that triggered the callback. But this function
1014: * is also called directly from flap_connection_send_byte_stream(),
1015: * in which case source will be -1. So don't use source--use
1016: * conn->gsc or conn->fd instead.
1017: */
1018: static void
1019: send_cb(gpointer data, gint source, PurpleInputCondition cond)
1020: {
1021: FlapConnection *conn;
1022: int writelen, ret;
1023:
1024: conn = data;
1025: writelen = purple_circ_buffer_get_max_read(conn->buffer_outgoing);
1026:
1027: if (writelen == 0)
1028: {
1029: purple_input_remove(conn->watcher_outgoing);
1030: conn->watcher_outgoing = 0;
1031: return;
1032: }
1033:
1034: if (conn->gsc)
1035: ret = purple_ssl_write(conn->gsc, conn->buffer_outgoing->outptr,
1036: writelen);
1037: else
1038: ret = send(conn->fd, conn->buffer_outgoing->outptr, writelen, 0);
1039: if (ret <= 0)
1040: {
1041: if (ret < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))
1042: /* No worries */
1043: return;
1044:
1045: /* Error! */
1046: purple_input_remove(conn->watcher_outgoing);
1047: conn->watcher_outgoing = 0;
1048: if (conn->gsc) {
1049: purple_ssl_close(conn->gsc);
1050: conn->gsc = NULL;
1051: } else {
1052: close(conn->fd);
1053: conn->fd = -1;
1054: }
1055: flap_connection_schedule_destroy(conn,
1056: OSCAR_DISCONNECT_LOST_CONNECTION, g_strerror(errno));
1057: return;
1058: }
1059:
1060: purple_circ_buffer_mark_read(conn->buffer_outgoing, ret);
1061: }
1062:
1063: static void
1064: flap_connection_send_byte_stream(ByteStream *bs, FlapConnection *conn, size_t count)
1065: {
1066: if (conn == NULL)
1067: return;
1068:
1069: /* Make sure we don't send past the end of the bs */
1070: if (count > byte_stream_bytes_left(bs))
1071: count = byte_stream_bytes_left(bs); /* truncate to remaining space */
1072:
1073: if (count == 0)
1074: return;
1075:
1076: /* Add everything to our outgoing buffer */
1077: purple_circ_buffer_append(conn->buffer_outgoing, bs->data, count);
1078:
1079: /* If we haven't already started writing stuff, then start the cycle */
1080: if (conn->watcher_outgoing == 0)
1081: {
1082: if (conn->gsc) {
1083: conn->watcher_outgoing = purple_input_add(conn->gsc->fd,
1084: PURPLE_INPUT_WRITE, send_cb, conn);
1085: send_cb(conn, -1, 0);
1086: } else if (conn->fd >= 0) {
1087: conn->watcher_outgoing = purple_input_add(conn->fd,
1088: PURPLE_INPUT_WRITE, send_cb, conn);
1089: send_cb(conn, -1, 0);
1090: }
1091: }
1092: }
1093:
1094: static void
1095: sendframe_flap(FlapConnection *conn, FlapFrame *frame)
1096: {
1097: ByteStream bs;
1098: int payloadlen, bslen;
1099:
1100: payloadlen = byte_stream_curpos(&frame->data);
1101:
1102: byte_stream_new(&bs, 6 + payloadlen);
1103:
1104: /* FLAP header */
1105: byte_stream_put8(&bs, 0x2a);
1106: byte_stream_put8(&bs, frame->channel);
1107: byte_stream_put16(&bs, frame->seqnum);
1108: byte_stream_put16(&bs, payloadlen);
1109:
1110: /* Payload */
1111: byte_stream_rewind(&frame->data);
1112: byte_stream_putbs(&bs, &frame->data, payloadlen);
1113:
1114: bslen = byte_stream_curpos(&bs);
1115: byte_stream_rewind(&bs);
1116: flap_connection_send_byte_stream(&bs, conn, bslen);
1117:
1118: byte_stream_destroy(&bs);
1119: }
1120:
1121: void
1122: flap_connection_send(FlapConnection *conn, FlapFrame *frame)
1123: {
1124: frame->seqnum = ++(conn->seqnum_out);
1125: sendframe_flap(conn, frame);
1126: flap_frame_destroy(frame);
1127: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to flap_connection.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