Annotation of ChivanetAimPidgin/oscarprpl/src/c/family_icbm.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: * Family 0x0004 - Routines for sending/receiving Instant Messages.
! 23: *
! 24: * Note the term ICBM (Inter-Client Basic Message) which blankets
! 25: * all types of generically routed through-server messages. Within
! 26: * the ICBM types (family 4), a channel is defined. Each channel
! 27: * represents a different type of message. Channel 1 is used for
! 28: * what would commonly be called an "instant message". Channel 2
! 29: * is used for negotiating "rendezvous". These transactions end in
! 30: * something more complex happening, such as a chat invitation, or
! 31: * a file transfer. Channel 3 is used for chat messages (not in
! 32: * the same family as these channels). Channel 4 is used for
! 33: * various ICQ messages. Examples are normal messages, URLs, and
! 34: * old-style authorization.
! 35: *
! 36: * In addition to the channel, every ICBM contains a cookie. For
! 37: * standard IMs, these are only used for error messages. However,
! 38: * the more complex rendezvous messages make suitably more complex
! 39: * use of this field.
! 40: *
! 41: * TODO: Split this up into an im.c file an an icbm.c file. It
! 42: * will be beautiful, you'll see.
! 43: *
! 44: * Make sure flap_connection_findbygroup is used by all functions.
! 45: */
! 46:
! 47: #include "encoding.h"
! 48: #include "oscar.h"
! 49: #include "peer.h"
! 50:
! 51: #ifdef _WIN32
! 52: #include "win32dep.h"
! 53: #endif
! 54:
! 55: #include "util.h"
! 56:
! 57: static const char * const errcodereason[] = {
! 58: N_("Invalid error"),
! 59: N_("Not logged in"),
! 60: N_("Cannot receive IM due to parental controls"),
! 61: N_("Cannot send SMS without accepting terms"),
! 62: N_("Cannot send SMS"), /* SMS_WITHOUT_DISCLAIMER is weird */
! 63: N_("Cannot send SMS to this country"),
! 64: N_("Unknown error"), /* Undocumented */
! 65: N_("Unknown error"), /* Undocumented */
! 66: N_("Cannot send SMS to unknown country"),
! 67: N_("Bot accounts cannot initiate IMs"),
! 68: N_("Bot account cannot IM this user"),
! 69: N_("Bot account reached IM limit"),
! 70: N_("Bot account reached daily IM limit"),
! 71: N_("Bot account reached monthly IM limit"),
! 72: N_("Unable to receive offline messages"),
! 73: N_("Offline message store full")
! 74: };
! 75: static const int errcodereasonlen = G_N_ELEMENTS(errcodereason);
! 76:
! 77: /**
! 78: * Add a standard ICBM header to the given bstream with the given
! 79: * information.
! 80: *
! 81: * @param bs The bstream to write the ICBM header to.
! 82: * @param c c is for cookie, and cookie is for me.
! 83: * @param channel The ICBM channel (1 through 4).
! 84: * @param bn Null-terminated scrizeen nizame.
! 85: * @return The number of bytes written. It's really not useful.
! 86: */
! 87: static int aim_im_puticbm(ByteStream *bs, const guchar *c, guint16 channel, const char *bn)
! 88: {
! 89: byte_stream_putraw(bs, c, 8);
! 90: byte_stream_put16(bs, channel);
! 91: byte_stream_put8(bs, strlen(bn));
! 92: byte_stream_putstr(bs, bn);
! 93: return 8+2+1+strlen(bn);
! 94: }
! 95:
! 96: /**
! 97: * Generates a random ICBM cookie in a character array of length 8
! 98: * and copies it into the variable passed as cookie
! 99: * TODO: Maybe we should stop limiting our characters to the visible range?
! 100: */
! 101: void aim_icbm_makecookie(guchar *cookie)
! 102: {
! 103: int i;
! 104:
! 105: /* Should be like "21CBF95" and null terminated */
! 106: for (i = 0; i < 7; i++)
! 107: cookie[i] = 0x30 + ((guchar)rand() % 10);
! 108: cookie[7] = '\0';
! 109: }
! 110:
! 111: /*
! 112: * Subtype 0x0001 - Error
! 113: */
! 114: static int
! 115: error(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 116: {
! 117: aim_snac_t *snac2;
! 118: guint16 reason, errcode = 0;
! 119: const char *bn;
! 120: GSList *tlvlist;
! 121: PurpleConnection *gc = od->gc;
! 122: #ifdef TODOFT
! 123: PurpleXfer *xfer;
! 124: #endif
! 125: const char *reason_str;
! 126: char *buf;
! 127:
! 128: snac2 = aim_remsnac(od, snac->id);
! 129: if (!snac2) {
! 130: purple_debug_misc("oscar", "icbm error: received response from unknown request!\n");
! 131: return 1;
! 132: }
! 133:
! 134: if (snac2->family != SNAC_FAMILY_ICBM) {
! 135: purple_debug_misc("oscar", "icbm error: received response from invalid request! %d\n", snac2->family);
! 136: g_free(snac2->data);
! 137: g_free(snac2);
! 138: return 1;
! 139: }
! 140:
! 141: /* Data is assumed to be the destination bn */
! 142: bn = snac2->data;
! 143: if (!bn || bn[0] == '\0') {
! 144: purple_debug_misc("oscar", "icbm error: received response from request without a buddy name!\n");
! 145: g_free(snac2->data);
! 146: g_free(snac2);
! 147: return 1;
! 148: }
! 149:
! 150: reason = byte_stream_get16(bs);
! 151:
! 152: tlvlist = aim_tlvlist_read(bs);
! 153: if (aim_tlv_gettlv(tlvlist, 0x0008, 1))
! 154: errcode = aim_tlv_get16(tlvlist, 0x0008, 1);
! 155: aim_tlvlist_free(tlvlist);
! 156:
! 157: purple_debug_error("oscar",
! 158: "Message error with bn %s and reason %hu and errcode %hu\n",
! 159: bn, reason, errcode);
! 160:
! 161: #ifdef TODOFT
! 162: /* If this was a file transfer request, bn is a cookie */
! 163: if ((xfer = oscar_find_xfer_by_cookie(od->file_transfers, bn))) {
! 164: purple_xfer_cancel_remote(xfer);
! 165: return 1;
! 166: }
! 167: #endif
! 168:
! 169: /* Notify the user that the message wasn't delivered */
! 170: reason_str = oscar_get_msgerr_reason(reason);
! 171: if (errcode != 0 && errcode < errcodereasonlen)
! 172: buf = g_strdup_printf(_("Unable to send message: %s (%s)"), reason_str,
! 173: _(errcodereason[errcode]));
! 174: else
! 175: buf = g_strdup_printf(_("Unable to send message: %s"), reason_str);
! 176:
! 177: if (!purple_conv_present_error(bn, purple_connection_get_account(gc), buf)) {
! 178: g_free(buf);
! 179: if (errcode != 0 && errcode < errcodereasonlen)
! 180: buf = g_strdup_printf(_("Unable to send message to %s: %s (%s)"),
! 181: bn ? bn : "(unknown)", reason_str,
! 182: _(errcodereason[errcode]));
! 183: else
! 184: buf = g_strdup_printf(_("Unable to send message to %s: %s"),
! 185: bn ? bn : "(unknown)", reason_str);
! 186: purple_notify_error(od->gc, NULL, buf, reason_str);
! 187: }
! 188: g_free(buf);
! 189:
! 190: g_free(snac2->data);
! 191: g_free(snac2);
! 192:
! 193: return 1;
! 194: }
! 195:
! 196: /**
! 197: * Subtype 0x0002 - Set ICBM parameters.
! 198: *
! 199: * I definitely recommend sending this. If you don't, you'll be stuck
! 200: * with the rather unreasonable defaults.
! 201: *
! 202: */
! 203: int aim_im_setparams(OscarData *od, struct aim_icbmparameters *params)
! 204: {
! 205: FlapConnection *conn;
! 206: ByteStream bs;
! 207: aim_snacid_t snacid;
! 208:
! 209: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM)))
! 210: return -EINVAL;
! 211:
! 212: if (!params)
! 213: return -EINVAL;
! 214:
! 215: byte_stream_new(&bs, 16);
! 216:
! 217: /* This is read-only (see Parameter Reply). Must be set to zero here. */
! 218: byte_stream_put16(&bs, 0x0000);
! 219:
! 220: /* These are all read-write */
! 221: byte_stream_put32(&bs, params->flags);
! 222: byte_stream_put16(&bs, params->maxmsglen);
! 223: byte_stream_put16(&bs, params->maxsenderwarn);
! 224: byte_stream_put16(&bs, params->maxrecverwarn);
! 225: byte_stream_put32(&bs, params->minmsginterval);
! 226:
! 227: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x0002, 0x0000, NULL, 0);
! 228: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x0002, snacid, &bs);
! 229:
! 230: byte_stream_destroy(&bs);
! 231:
! 232: return 0;
! 233: }
! 234:
! 235: /**
! 236: * Subtype 0x0004 - Request ICBM parameter information.
! 237: *
! 238: */
! 239: int aim_im_reqparams(OscarData *od)
! 240: {
! 241: FlapConnection *conn;
! 242:
! 243: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM)))
! 244: return -EINVAL;
! 245:
! 246: aim_genericreq_n_snacid(od, conn, SNAC_FAMILY_ICBM, 0x0004);
! 247:
! 248: return 0;
! 249: }
! 250:
! 251: /**
! 252: * Subtype 0x0005 - Receive parameter information.
! 253: *
! 254: */
! 255: static int aim_im_paraminfo(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 256: {
! 257: struct aim_icbmparameters params;
! 258:
! 259: params.maxchan = byte_stream_get16(bs);
! 260: params.flags = byte_stream_get32(bs);
! 261: params.maxmsglen = byte_stream_get16(bs);
! 262: params.maxsenderwarn = byte_stream_get16(bs);
! 263: params.maxrecverwarn = byte_stream_get16(bs);
! 264: params.minmsginterval = byte_stream_get32(bs);
! 265:
! 266: params.flags = AIM_IMPARAM_FLAG_CHANNEL_MSGS_ALLOWED
! 267: | AIM_IMPARAM_FLAG_MISSED_CALLS_ENABLED
! 268: | AIM_IMPARAM_FLAG_EVENTS_ALLOWED
! 269: | AIM_IMPARAM_FLAG_SMS_SUPPORTED
! 270: | AIM_IMPARAM_FLAG_OFFLINE_MSGS_ALLOWED
! 271: | AIM_IMPARAM_FLAG_USE_HTML_FOR_ICQ;
! 272: params.maxmsglen = 8000;
! 273: params.minmsginterval = 0;
! 274:
! 275: aim_im_setparams(od, ¶ms);
! 276:
! 277: return 0;
! 278: }
! 279:
! 280: /**
! 281: * Subtype 0x0006 - Send an ICBM (instant message).
! 282: *
! 283: *
! 284: * Possible flags:
! 285: * AIM_IMFLAGS_AWAY -- Marks the message as an autoresponse
! 286: * AIM_IMFLAGS_OFFLINE--If destination is offline, store it until they are
! 287: * online (probably ICQ only).
! 288: *
! 289: * Implementation note: Since this is one of the most-used functions
! 290: * in all of libfaim, it is written with performance in mind. As such,
! 291: * it is not as clear as it could be in respect to how this message is
! 292: * supposed to be layed out. Most obviously, tlvlists should be used
! 293: * instead of writing out the bytes manually.
! 294: */
! 295: int aim_im_sendch1_ext(OscarData *od, struct aim_sendimext_args *args)
! 296: {
! 297: FlapConnection *conn;
! 298: aim_snacid_t snacid;
! 299: ByteStream data;
! 300: guchar cookie[8];
! 301: int msgtlvlen;
! 302:
! 303: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM)))
! 304: return -EINVAL;
! 305:
! 306: if (!args)
! 307: return -EINVAL;
! 308:
! 309: if (!args->msg || (args->msglen <= 0))
! 310: return -EINVAL;
! 311:
! 312: if (args->msglen > MAXMSGLEN)
! 313: return -E2BIG;
! 314:
! 315: /* Painfully calculate the size of the message TLV */
! 316: msgtlvlen = 1 + 1; /* 0501 */
! 317: msgtlvlen += 2 + args->featureslen;
! 318: msgtlvlen += 2 /* 0101 */ + 2 /* block len */;
! 319: msgtlvlen += 4 /* charset */ + args->msglen;
! 320:
! 321: byte_stream_new(&data, msgtlvlen + 128);
! 322:
! 323: /* Generate an ICBM cookie */
! 324: aim_icbm_makecookie(cookie);
! 325:
! 326: /* ICBM header */
! 327: aim_im_puticbm(&data, cookie, 0x0001, args->destbn);
! 328:
! 329: /* Message TLV (type 0x0002) */
! 330: byte_stream_put16(&data, 0x0002);
! 331: byte_stream_put16(&data, msgtlvlen);
! 332:
! 333: /* Features TLV (type 0x0501) */
! 334: byte_stream_put16(&data, 0x0501);
! 335: byte_stream_put16(&data, args->featureslen);
! 336: byte_stream_putraw(&data, args->features, args->featureslen);
! 337:
! 338: /* Insert message text in a TLV (type 0x0101) */
! 339: byte_stream_put16(&data, 0x0101);
! 340:
! 341: /* Message block length */
! 342: byte_stream_put16(&data, args->msglen + 0x04);
! 343:
! 344: /* Character set */
! 345: byte_stream_put16(&data, args->charset);
! 346: /* Character subset -- we always use 0 here */
! 347: byte_stream_put16(&data, 0x0);
! 348:
! 349: /* Message. Not terminated */
! 350: byte_stream_putraw(&data, (guchar *)args->msg, args->msglen);
! 351:
! 352: /* Set the Autoresponse flag */
! 353: if (args->flags & AIM_IMFLAGS_AWAY) {
! 354: byte_stream_put16(&data, 0x0004);
! 355: byte_stream_put16(&data, 0x0000);
! 356: } else {
! 357: /* Set the Request Acknowledge flag */
! 358: byte_stream_put16(&data, 0x0003);
! 359: byte_stream_put16(&data, 0x0000);
! 360:
! 361: if (args->flags & AIM_IMFLAGS_OFFLINE) {
! 362: /* Allow this message to be queued as an offline message */
! 363: byte_stream_put16(&data, 0x0006);
! 364: byte_stream_put16(&data, 0x0000);
! 365: }
! 366: }
! 367:
! 368: /*
! 369: * Set the I HAVE A REALLY PURTY ICON flag.
! 370: * XXX - This should really only be sent on initial
! 371: * IMs and when you change your icon.
! 372: */
! 373: if (args->flags & AIM_IMFLAGS_HASICON) {
! 374: byte_stream_put16(&data, 0x0008);
! 375: byte_stream_put16(&data, 0x000c);
! 376: byte_stream_put32(&data, args->iconlen);
! 377: byte_stream_put16(&data, 0x0001);
! 378: byte_stream_put16(&data, args->iconsum);
! 379: byte_stream_put32(&data, args->iconstamp);
! 380: }
! 381:
! 382: /*
! 383: * Set the Buddy Icon Requested flag.
! 384: * XXX - Every time? Surely not...
! 385: */
! 386: if (args->flags & AIM_IMFLAGS_BUDDYREQ) {
! 387: byte_stream_put16(&data, 0x0009);
! 388: byte_stream_put16(&data, 0x0000);
! 389: }
! 390:
! 391: /* XXX - should be optional */
! 392: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x0006, 0x0000, args->destbn, strlen(args->destbn)+1);
! 393:
! 394: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x0006, snacid, &data);
! 395: byte_stream_destroy(&data);
! 396:
! 397: /* clean out SNACs over 60sec old */
! 398: aim_cleansnacs(od, 60);
! 399:
! 400: return 0;
! 401: }
! 402:
! 403: /*
! 404: * Subtype 0x0006 - Send a chat invitation.
! 405: */
! 406: int aim_im_sendch2_chatinvite(OscarData *od, const char *bn, const char *msg, guint16 exchange, const char *roomname, guint16 instance)
! 407: {
! 408: FlapConnection *conn;
! 409: ByteStream bs;
! 410: aim_snacid_t snacid;
! 411: IcbmCookie *msgcookie;
! 412: struct aim_invite_priv *priv;
! 413: guchar cookie[8];
! 414: GSList *outer_tlvlist = NULL, *inner_tlvlist = NULL;
! 415: ByteStream hdrbs;
! 416:
! 417: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM)))
! 418: return -EINVAL;
! 419:
! 420: if (!bn || !msg || !roomname)
! 421: return -EINVAL;
! 422:
! 423: aim_icbm_makecookie(cookie);
! 424:
! 425: byte_stream_new(&bs, 1142+strlen(bn)+strlen(roomname)+strlen(msg));
! 426:
! 427: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x0006, 0x0000, bn, strlen(bn)+1);
! 428:
! 429: /* XXX should be uncached by an unwritten 'invite accept' handler */
! 430: priv = g_malloc(sizeof(struct aim_invite_priv));
! 431: priv->bn = g_strdup(bn);
! 432: priv->roomname = g_strdup(roomname);
! 433: priv->exchange = exchange;
! 434: priv->instance = instance;
! 435:
! 436: if ((msgcookie = aim_mkcookie(cookie, AIM_COOKIETYPE_INVITE, priv)))
! 437: aim_cachecookie(od, msgcookie);
! 438: else
! 439: g_free(priv);
! 440:
! 441: /* ICBM Header */
! 442: aim_im_puticbm(&bs, cookie, 0x0002, bn);
! 443:
! 444: /*
! 445: * TLV t(0005)
! 446: *
! 447: * Everything else is inside this TLV.
! 448: *
! 449: * Sigh. AOL was rather inconsistent right here. So we have
! 450: * to play some minor tricks. Right inside the type 5 is some
! 451: * raw data, followed by a series of TLVs.
! 452: *
! 453: */
! 454: byte_stream_new(&hdrbs, 2+8+16+6+4+4+strlen(msg)+4+2+1+strlen(roomname)+2);
! 455:
! 456: byte_stream_put16(&hdrbs, 0x0000); /* Unknown! */
! 457: byte_stream_putraw(&hdrbs, cookie, sizeof(cookie)); /* I think... */
! 458: byte_stream_putcaps(&hdrbs, OSCAR_CAPABILITY_CHAT);
! 459:
! 460: aim_tlvlist_add_16(&inner_tlvlist, 0x000a, 0x0001);
! 461: aim_tlvlist_add_noval(&inner_tlvlist, 0x000f);
! 462: aim_tlvlist_add_str(&inner_tlvlist, 0x000c, msg);
! 463: aim_tlvlist_add_chatroom(&inner_tlvlist, 0x2711, exchange, roomname, instance);
! 464: aim_tlvlist_write(&hdrbs, &inner_tlvlist);
! 465:
! 466: aim_tlvlist_add_raw(&outer_tlvlist, 0x0005, byte_stream_curpos(&hdrbs), hdrbs.data);
! 467: byte_stream_destroy(&hdrbs);
! 468:
! 469: aim_tlvlist_write(&bs, &outer_tlvlist);
! 470:
! 471: aim_tlvlist_free(inner_tlvlist);
! 472: aim_tlvlist_free(outer_tlvlist);
! 473:
! 474: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x0006, snacid, &bs);
! 475:
! 476: byte_stream_destroy(&bs);
! 477:
! 478: return 0;
! 479: }
! 480:
! 481: /**
! 482: * Subtype 0x0006 - Send your icon to a given user.
! 483: *
! 484: * This is also performance sensitive. (If you can believe it...)
! 485: *
! 486: */
! 487: int aim_im_sendch2_icon(OscarData *od, const char *bn, const guint8 *icon, int iconlen, time_t stamp, guint16 iconsum)
! 488: {
! 489: FlapConnection *conn;
! 490: ByteStream bs;
! 491: aim_snacid_t snacid;
! 492: guchar cookie[8];
! 493:
! 494: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM)))
! 495: return -EINVAL;
! 496:
! 497: if (!bn || !icon || (iconlen <= 0) || (iconlen >= MAXICONLEN))
! 498: return -EINVAL;
! 499:
! 500: aim_icbm_makecookie(cookie);
! 501:
! 502: byte_stream_new(&bs, 8+2+1+strlen(bn)+2+2+2+8+16+2+2+2+2+2+2+2+4+4+4+iconlen+strlen(AIM_ICONIDENT)+2+2);
! 503:
! 504: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x0006, 0x0000, NULL, 0);
! 505:
! 506: /* ICBM header */
! 507: aim_im_puticbm(&bs, cookie, 0x0002, bn);
! 508:
! 509: /*
! 510: * TLV t(0005)
! 511: *
! 512: * Encompasses everything below.
! 513: */
! 514: byte_stream_put16(&bs, 0x0005);
! 515: byte_stream_put16(&bs, 2+8+16+6+4+4+iconlen+4+4+4+strlen(AIM_ICONIDENT));
! 516:
! 517: byte_stream_put16(&bs, 0x0000);
! 518: byte_stream_putraw(&bs, cookie, 8);
! 519: byte_stream_putcaps(&bs, OSCAR_CAPABILITY_BUDDYICON);
! 520:
! 521: /* TLV t(000a) */
! 522: byte_stream_put16(&bs, 0x000a);
! 523: byte_stream_put16(&bs, 0x0002);
! 524: byte_stream_put16(&bs, 0x0001);
! 525:
! 526: /* TLV t(000f) */
! 527: byte_stream_put16(&bs, 0x000f);
! 528: byte_stream_put16(&bs, 0x0000);
! 529:
! 530: /* TLV t(2711) */
! 531: byte_stream_put16(&bs, 0x2711);
! 532: byte_stream_put16(&bs, 4+4+4+iconlen+strlen(AIM_ICONIDENT));
! 533: byte_stream_put16(&bs, 0x0000);
! 534: byte_stream_put16(&bs, iconsum);
! 535: byte_stream_put32(&bs, iconlen);
! 536: byte_stream_put32(&bs, stamp);
! 537: byte_stream_putraw(&bs, icon, iconlen);
! 538: byte_stream_putstr(&bs, AIM_ICONIDENT);
! 539:
! 540: /* TLV t(0003) */
! 541: byte_stream_put16(&bs, 0x0003);
! 542: byte_stream_put16(&bs, 0x0000);
! 543:
! 544: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x0006, snacid, &bs);
! 545:
! 546: byte_stream_destroy(&bs);
! 547:
! 548: return 0;
! 549: }
! 550:
! 551: /**
! 552: * Cancel a rendezvous invitation. It could be an invitation to
! 553: * establish a direct connection, or a file-send, or a chat invite.
! 554: */
! 555: void
! 556: aim_im_sendch2_cancel(PeerConnection *peer_conn)
! 557: {
! 558: OscarData *od;
! 559: FlapConnection *conn;
! 560: ByteStream bs;
! 561: aim_snacid_t snacid;
! 562: GSList *outer_tlvlist = NULL, *inner_tlvlist = NULL;
! 563: ByteStream hdrbs;
! 564:
! 565: od = peer_conn->od;
! 566: conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM);
! 567: if (conn == NULL)
! 568: return;
! 569:
! 570: byte_stream_new(&bs, 118+strlen(peer_conn->bn));
! 571:
! 572: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x0006, 0x0000, NULL, 0);
! 573:
! 574: /* ICBM header */
! 575: aim_im_puticbm(&bs, peer_conn->cookie, 0x0002, peer_conn->bn);
! 576:
! 577: aim_tlvlist_add_noval(&outer_tlvlist, 0x0003);
! 578:
! 579: byte_stream_new(&hdrbs, 64);
! 580:
! 581: byte_stream_put16(&hdrbs, AIM_RENDEZVOUS_CANCEL);
! 582: byte_stream_putraw(&hdrbs, peer_conn->cookie, 8);
! 583: byte_stream_putcaps(&hdrbs, peer_conn->type);
! 584:
! 585: /* This TLV means "cancel!" */
! 586: aim_tlvlist_add_16(&inner_tlvlist, 0x000b, 0x0001);
! 587: aim_tlvlist_write(&hdrbs, &inner_tlvlist);
! 588:
! 589: aim_tlvlist_add_raw(&outer_tlvlist, 0x0005, byte_stream_curpos(&hdrbs), hdrbs.data);
! 590: byte_stream_destroy(&hdrbs);
! 591:
! 592: aim_tlvlist_write(&bs, &outer_tlvlist);
! 593:
! 594: aim_tlvlist_free(inner_tlvlist);
! 595: aim_tlvlist_free(outer_tlvlist);
! 596:
! 597: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x0006, snacid, &bs);
! 598:
! 599: byte_stream_destroy(&bs);
! 600: }
! 601:
! 602: /**
! 603: * Subtype 0x0006 - Send an "I accept and I've connected to
! 604: * you" message.
! 605: */
! 606: void
! 607: aim_im_sendch2_connected(PeerConnection *peer_conn)
! 608: {
! 609: OscarData *od;
! 610: FlapConnection *conn;
! 611: ByteStream bs;
! 612: aim_snacid_t snacid;
! 613:
! 614: od = peer_conn->od;
! 615: conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM);
! 616: if (conn == NULL)
! 617: return;
! 618:
! 619: byte_stream_new(&bs, 11+strlen(peer_conn->bn) + 4+2+8+16);
! 620:
! 621: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x0006, 0x0000, NULL, 0);
! 622:
! 623: /* ICBM header */
! 624: aim_im_puticbm(&bs, peer_conn->cookie, 0x0002, peer_conn->bn);
! 625:
! 626: byte_stream_put16(&bs, 0x0005);
! 627: byte_stream_put16(&bs, 0x001a);
! 628: byte_stream_put16(&bs, AIM_RENDEZVOUS_CONNECTED);
! 629: byte_stream_putraw(&bs, peer_conn->cookie, 8);
! 630: byte_stream_putcaps(&bs, peer_conn->type);
! 631:
! 632: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x0006, snacid, &bs);
! 633:
! 634: byte_stream_destroy(&bs);
! 635: }
! 636:
! 637: /**
! 638: * Subtype 0x0006 - Send a direct connect rendezvous ICBM. This
! 639: * could have a number of meanings, depending on the content:
! 640: * "I want you to connect to me"
! 641: * "I want to connect to you"
! 642: * "I want to connect through a proxy server"
! 643: */
! 644: void
! 645: aim_im_sendch2_odc_requestdirect(OscarData *od, guchar *cookie, const char *bn, const guint8 *ip, guint16 port, guint16 requestnumber)
! 646: {
! 647: FlapConnection *conn;
! 648: ByteStream bs;
! 649: aim_snacid_t snacid;
! 650: GSList *outer_tlvlist = NULL, *inner_tlvlist = NULL;
! 651: ByteStream hdrbs;
! 652:
! 653: conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM);
! 654: if (conn == NULL)
! 655: return;
! 656:
! 657: byte_stream_new(&bs, 246+strlen(bn));
! 658:
! 659: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x0006, 0x0000, NULL, 0);
! 660:
! 661: /* ICBM header */
! 662: aim_im_puticbm(&bs, cookie, 0x0002, bn);
! 663:
! 664: aim_tlvlist_add_noval(&outer_tlvlist, 0x0003);
! 665:
! 666: byte_stream_new(&hdrbs, 128);
! 667:
! 668: byte_stream_put16(&hdrbs, AIM_RENDEZVOUS_PROPOSE);
! 669: byte_stream_putraw(&hdrbs, cookie, 8);
! 670: byte_stream_putcaps(&hdrbs, OSCAR_CAPABILITY_DIRECTIM);
! 671:
! 672: aim_tlvlist_add_raw(&inner_tlvlist, 0x0002, 4, ip);
! 673: aim_tlvlist_add_raw(&inner_tlvlist, 0x0003, 4, ip);
! 674: aim_tlvlist_add_16(&inner_tlvlist, 0x0005, port);
! 675: aim_tlvlist_add_16(&inner_tlvlist, 0x000a, requestnumber);
! 676: aim_tlvlist_add_noval(&inner_tlvlist, 0x000f);
! 677: aim_tlvlist_write(&hdrbs, &inner_tlvlist);
! 678:
! 679: aim_tlvlist_add_raw(&outer_tlvlist, 0x0005, byte_stream_curpos(&hdrbs), hdrbs.data);
! 680: byte_stream_destroy(&hdrbs);
! 681:
! 682: aim_tlvlist_write(&bs, &outer_tlvlist);
! 683:
! 684: aim_tlvlist_free(inner_tlvlist);
! 685: aim_tlvlist_free(outer_tlvlist);
! 686:
! 687: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x0006, snacid, &bs);
! 688:
! 689: byte_stream_destroy(&bs);
! 690: }
! 691:
! 692: /**
! 693: * Subtype 0x0006 - Send a direct connect rendezvous ICBM asking the
! 694: * remote user to connect to us via a proxy server.
! 695: */
! 696: void
! 697: aim_im_sendch2_odc_requestproxy(OscarData *od, guchar *cookie, const char *bn, const guint8 *ip, guint16 pin, guint16 requestnumber)
! 698: {
! 699: FlapConnection *conn;
! 700: ByteStream bs;
! 701: aim_snacid_t snacid;
! 702: GSList *outer_tlvlist = NULL, *inner_tlvlist = NULL;
! 703: ByteStream hdrbs;
! 704: guint8 ip_comp[4];
! 705:
! 706: conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM);
! 707: if (conn == NULL)
! 708: return;
! 709:
! 710: byte_stream_new(&bs, 246+strlen(bn));
! 711:
! 712: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x0006, 0x0000, NULL, 0);
! 713:
! 714: /* ICBM header */
! 715: aim_im_puticbm(&bs, cookie, 0x0002, bn);
! 716:
! 717: aim_tlvlist_add_noval(&outer_tlvlist, 0x0003);
! 718:
! 719: byte_stream_new(&hdrbs, 128);
! 720:
! 721: byte_stream_put16(&hdrbs, AIM_RENDEZVOUS_PROPOSE);
! 722: byte_stream_putraw(&hdrbs, cookie, 8);
! 723: byte_stream_putcaps(&hdrbs, OSCAR_CAPABILITY_DIRECTIM);
! 724:
! 725: aim_tlvlist_add_raw(&inner_tlvlist, 0x0002, 4, ip);
! 726: aim_tlvlist_add_raw(&inner_tlvlist, 0x0003, 4, ip);
! 727: aim_tlvlist_add_16(&inner_tlvlist, 0x0005, pin);
! 728: aim_tlvlist_add_16(&inner_tlvlist, 0x000a, requestnumber);
! 729: aim_tlvlist_add_noval(&inner_tlvlist, 0x000f);
! 730: aim_tlvlist_add_noval(&inner_tlvlist, 0x0010);
! 731:
! 732: /* Send the bitwise complement of the port and ip. As a check? */
! 733: ip_comp[0] = ~ip[0];
! 734: ip_comp[1] = ~ip[1];
! 735: ip_comp[2] = ~ip[2];
! 736: ip_comp[3] = ~ip[3];
! 737: aim_tlvlist_add_raw(&inner_tlvlist, 0x0016, 4, ip_comp);
! 738: aim_tlvlist_add_16(&inner_tlvlist, 0x0017, ~pin);
! 739:
! 740: aim_tlvlist_write(&hdrbs, &inner_tlvlist);
! 741:
! 742: aim_tlvlist_add_raw(&outer_tlvlist, 0x0005, byte_stream_curpos(&hdrbs), hdrbs.data);
! 743: byte_stream_destroy(&hdrbs);
! 744:
! 745: aim_tlvlist_write(&bs, &outer_tlvlist);
! 746:
! 747: aim_tlvlist_free(inner_tlvlist);
! 748: aim_tlvlist_free(outer_tlvlist);
! 749:
! 750: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x0006, snacid, &bs);
! 751:
! 752: byte_stream_destroy(&bs);
! 753: }
! 754:
! 755: /**
! 756: * Subtype 0x0006 - Send an "I want to send you this file" message
! 757: *
! 758: */
! 759: void
! 760: aim_im_sendch2_sendfile_requestdirect(OscarData *od, guchar *cookie, const char *bn, const guint8 *ip, guint16 port, guint16 requestnumber, const gchar *filename, guint32 size, guint16 numfiles)
! 761: {
! 762: FlapConnection *conn;
! 763: ByteStream bs;
! 764: aim_snacid_t snacid;
! 765: GSList *outer_tlvlist = NULL, *inner_tlvlist = NULL;
! 766: ByteStream hdrbs;
! 767:
! 768: g_return_if_fail(bn != NULL);
! 769: g_return_if_fail(ip != NULL);
! 770:
! 771: conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM);
! 772: if (conn == NULL)
! 773: return;
! 774:
! 775: byte_stream_new(&bs, 1014);
! 776:
! 777: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x0006, 0x0000, NULL, 0);
! 778:
! 779: /* ICBM header */
! 780: aim_im_puticbm(&bs, cookie, 0x0002, bn);
! 781:
! 782: aim_tlvlist_add_noval(&outer_tlvlist, 0x0003);
! 783:
! 784: byte_stream_new(&hdrbs, 512);
! 785:
! 786: byte_stream_put16(&hdrbs, AIM_RENDEZVOUS_PROPOSE);
! 787: byte_stream_putraw(&hdrbs, cookie, 8);
! 788: byte_stream_putcaps(&hdrbs, OSCAR_CAPABILITY_SENDFILE);
! 789:
! 790: aim_tlvlist_add_raw(&inner_tlvlist, 0x0002, 4, ip);
! 791: aim_tlvlist_add_raw(&inner_tlvlist, 0x0003, 4, ip);
! 792: aim_tlvlist_add_16(&inner_tlvlist, 0x0005, port);
! 793: aim_tlvlist_add_16(&inner_tlvlist, 0x000a, requestnumber);
! 794: aim_tlvlist_add_noval(&inner_tlvlist, 0x000f);
! 795: /* TODO: Send 0x0016 and 0x0017 */
! 796:
! 797: if (filename != NULL)
! 798: {
! 799: ByteStream inner_bs;
! 800:
! 801: /* Begin TLV t(2711) */
! 802: byte_stream_new(&inner_bs, 2+2+4+strlen(filename)+1);
! 803: byte_stream_put16(&inner_bs, (numfiles > 1) ? 0x0002 : 0x0001);
! 804: byte_stream_put16(&inner_bs, numfiles);
! 805: byte_stream_put32(&inner_bs, size);
! 806:
! 807: /* Filename - NULL terminated, for some odd reason */
! 808: byte_stream_putstr(&inner_bs, filename);
! 809: byte_stream_put8(&inner_bs, 0x00);
! 810:
! 811: aim_tlvlist_add_raw(&inner_tlvlist, 0x2711, inner_bs.len, inner_bs.data);
! 812: byte_stream_destroy(&inner_bs);
! 813: /* End TLV t(2711) */
! 814: }
! 815:
! 816: aim_tlvlist_write(&hdrbs, &inner_tlvlist);
! 817: aim_tlvlist_add_raw(&outer_tlvlist, 0x0005, byte_stream_curpos(&hdrbs), hdrbs.data);
! 818: byte_stream_destroy(&hdrbs);
! 819:
! 820: aim_tlvlist_write(&bs, &outer_tlvlist);
! 821:
! 822: aim_tlvlist_free(inner_tlvlist);
! 823: aim_tlvlist_free(outer_tlvlist);
! 824:
! 825: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x0006, snacid, &bs);
! 826:
! 827: byte_stream_destroy(&bs);
! 828: }
! 829:
! 830: /**
! 831: * Subtype 0x0006 - Send a sendfile connect rendezvous ICBM asking the
! 832: * remote user to connect to us via a proxy server.
! 833: */
! 834: void
! 835: aim_im_sendch2_sendfile_requestproxy(OscarData *od, guchar *cookie, const char *bn, const guint8 *ip, guint16 pin, guint16 requestnumber, const gchar *filename, guint32 size, guint16 numfiles)
! 836: {
! 837: FlapConnection *conn;
! 838: ByteStream bs;
! 839: aim_snacid_t snacid;
! 840: GSList *outer_tlvlist = NULL, *inner_tlvlist = NULL;
! 841: ByteStream hdrbs;
! 842: guint8 ip_comp[4];
! 843:
! 844: conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM);
! 845: if (conn == NULL)
! 846: return;
! 847:
! 848: byte_stream_new(&bs, 1014);
! 849:
! 850: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x0006, 0x0000, NULL, 0);
! 851:
! 852: /* ICBM header */
! 853: aim_im_puticbm(&bs, cookie, 0x0002, bn);
! 854:
! 855: aim_tlvlist_add_noval(&outer_tlvlist, 0x0003);
! 856:
! 857: byte_stream_new(&hdrbs, 512);
! 858:
! 859: byte_stream_put16(&hdrbs, AIM_RENDEZVOUS_PROPOSE);
! 860: byte_stream_putraw(&hdrbs, cookie, 8);
! 861: byte_stream_putcaps(&hdrbs, OSCAR_CAPABILITY_SENDFILE);
! 862:
! 863: aim_tlvlist_add_raw(&inner_tlvlist, 0x0002, 4, ip);
! 864: aim_tlvlist_add_raw(&inner_tlvlist, 0x0003, 4, ip);
! 865: aim_tlvlist_add_16(&inner_tlvlist, 0x0005, pin);
! 866: aim_tlvlist_add_16(&inner_tlvlist, 0x000a, requestnumber);
! 867: aim_tlvlist_add_noval(&inner_tlvlist, 0x000f);
! 868: aim_tlvlist_add_noval(&inner_tlvlist, 0x0010);
! 869:
! 870: /* Send the bitwise complement of the port and ip. As a check? */
! 871: ip_comp[0] = ~ip[0];
! 872: ip_comp[1] = ~ip[1];
! 873: ip_comp[2] = ~ip[2];
! 874: ip_comp[3] = ~ip[3];
! 875: aim_tlvlist_add_raw(&inner_tlvlist, 0x0016, 4, ip_comp);
! 876: aim_tlvlist_add_16(&inner_tlvlist, 0x0017, ~pin);
! 877:
! 878: if (filename != NULL)
! 879: {
! 880: ByteStream filename_bs;
! 881:
! 882: /* Begin TLV t(2711) */
! 883: byte_stream_new(&filename_bs, 2+2+4+strlen(filename)+1);
! 884: byte_stream_put16(&filename_bs, (numfiles > 1) ? 0x0002 : 0x0001);
! 885: byte_stream_put16(&filename_bs, numfiles);
! 886: byte_stream_put32(&filename_bs, size);
! 887:
! 888: /* Filename - NULL terminated, for some odd reason */
! 889: byte_stream_putstr(&filename_bs, filename);
! 890: byte_stream_put8(&filename_bs, 0x00);
! 891:
! 892: aim_tlvlist_add_raw(&inner_tlvlist, 0x2711, filename_bs.len, filename_bs.data);
! 893: byte_stream_destroy(&filename_bs);
! 894: /* End TLV t(2711) */
! 895: }
! 896:
! 897: aim_tlvlist_write(&hdrbs, &inner_tlvlist);
! 898:
! 899: aim_tlvlist_add_raw(&outer_tlvlist, 0x0005, byte_stream_curpos(&hdrbs), hdrbs.data);
! 900: byte_stream_destroy(&hdrbs);
! 901:
! 902: aim_tlvlist_write(&bs, &outer_tlvlist);
! 903:
! 904: aim_tlvlist_free(inner_tlvlist);
! 905: aim_tlvlist_free(outer_tlvlist);
! 906:
! 907: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x0006, snacid, &bs);
! 908:
! 909: byte_stream_destroy(&bs);
! 910: }
! 911:
! 912: static void
! 913: incomingim_ch1_parsemsg(OscarData *od, aim_userinfo_t *userinfo, ByteStream *message, struct aim_incomingim_ch1_args *args)
! 914: {
! 915: PurpleAccount *account = purple_connection_get_account(od->gc);
! 916: /*
! 917: * We're interested in the inner TLV 0x101, which contains precious, precious message.
! 918: */
! 919: while (byte_stream_bytes_left(message) >= 4) {
! 920: guint16 type = byte_stream_get16(message);
! 921: guint16 length = byte_stream_get16(message);
! 922: if (type == 0x101) {
! 923: gchar *msg;
! 924: guint16 msglen = length - 4; /* charset + charsubset */
! 925: guint16 charset = byte_stream_get16(message);
! 926: byte_stream_advance(message, 2); /* charsubset */
! 927:
! 928: msg = byte_stream_getstr(message, msglen);
! 929: args->msg = oscar_decode_im(account, userinfo->bn, charset, msg, msglen);
! 930: g_free(msg);
! 931: } else {
! 932: byte_stream_advance(message, length);
! 933: }
! 934: }
! 935: }
! 936:
! 937: static int
! 938: incomingim_ch1(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, guint16 channel, aim_userinfo_t *userinfo, ByteStream *bs, guint8 *cookie)
! 939: {
! 940: guint16 type, length;
! 941: aim_rxcallback_t userfunc;
! 942: int ret = 0;
! 943: struct aim_incomingim_ch1_args args;
! 944: unsigned int endpos;
! 945:
! 946: memset(&args, 0, sizeof(args));
! 947:
! 948: /*
! 949: * This used to be done using tlvchains. For performance reasons,
! 950: * I've changed it to process the TLVs in-place. This avoids lots
! 951: * of per-IM memory allocations.
! 952: */
! 953: while (byte_stream_bytes_left(bs) >= 4)
! 954: {
! 955: type = byte_stream_get16(bs);
! 956: length = byte_stream_get16(bs);
! 957:
! 958: if (length > byte_stream_bytes_left(bs))
! 959: {
! 960: purple_debug_misc("oscar", "Received an IM containing an invalid message part from %s. They are probably trying to do something malicious.\n", userinfo->bn);
! 961: break;
! 962: }
! 963:
! 964: endpos = byte_stream_curpos(bs) + length;
! 965:
! 966: if (type == 0x0002) { /* Message Block */
! 967: ByteStream tlv02;
! 968: byte_stream_init(&tlv02, bs->data + bs->offset, length);
! 969: incomingim_ch1_parsemsg(od, userinfo, &tlv02, &args);
! 970: } else if (type == 0x0003) { /* Server Ack Requested */
! 971: args.icbmflags |= AIM_IMFLAGS_ACK;
! 972: } else if (type == 0x0004) { /* Message is Auto Response */
! 973: args.icbmflags |= AIM_IMFLAGS_AWAY;
! 974: } else if (type == 0x0006) { /* Message was received offline. */
! 975: /*
! 976: * This flag is set on incoming offline messages for both
! 977: * AIM and ICQ accounts.
! 978: */
! 979: args.icbmflags |= AIM_IMFLAGS_OFFLINE;
! 980: } else if (type == 0x0008) { /* I-HAVE-A-REALLY-PURTY-ICON Flag */
! 981: args.iconlen = byte_stream_get32(bs);
! 982: byte_stream_get16(bs); /* 0x0001 */
! 983: args.iconsum = byte_stream_get16(bs);
! 984: args.iconstamp = byte_stream_get32(bs);
! 985:
! 986: /*
! 987: * This looks to be a client bug. MacAIM 4.3 will
! 988: * send this tag, but with all zero values, in the
! 989: * first message of a conversation. This makes no
! 990: * sense whatsoever, so I'm going to say its a bug.
! 991: *
! 992: * You really shouldn't advertise a zero-length icon
! 993: * anyway.
! 994: *
! 995: */
! 996: if (args.iconlen)
! 997: args.icbmflags |= AIM_IMFLAGS_HASICON;
! 998: } else if (type == 0x0009) {
! 999: args.icbmflags |= AIM_IMFLAGS_BUDDYREQ;
! 1000: } else if (type == 0x000b) { /* Non-direct connect typing notification */
! 1001: args.icbmflags |= AIM_IMFLAGS_TYPINGNOT;
! 1002: } else if (type == 0x0016) {
! 1003: /*
! 1004: * UTC timestamp for when the message was sent. Only
! 1005: * provided for offline messages.
! 1006: */
! 1007: args.timestamp = byte_stream_get32(bs);
! 1008: }
! 1009:
! 1010: /*
! 1011: * This is here to protect ourselves from ourselves. That
! 1012: * is, if something above doesn't completely parse its value
! 1013: * section, or, worse, overparses it, this will set the
! 1014: * stream where it needs to be in order to land on the next
! 1015: * TLV when the loop continues.
! 1016: *
! 1017: */
! 1018: byte_stream_setpos(bs, endpos);
! 1019: }
! 1020:
! 1021:
! 1022: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1023: ret = userfunc(od, conn, frame, channel, userinfo, &args);
! 1024:
! 1025: g_free(args.msg);
! 1026: return ret;
! 1027: }
! 1028:
! 1029: static void
! 1030: incomingim_ch2_buddylist(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, aim_userinfo_t *userinfo, IcbmArgsCh2 *args, ByteStream *servdata)
! 1031: {
! 1032: /*
! 1033: * This goes like this...
! 1034: *
! 1035: * group name length
! 1036: * group name
! 1037: * num of buddies in group
! 1038: * buddy name length
! 1039: * buddy name
! 1040: * buddy name length
! 1041: * buddy name
! 1042: * ...
! 1043: * group name length
! 1044: * group name
! 1045: * num of buddies in group
! 1046: * buddy name length
! 1047: * buddy name
! 1048: * ...
! 1049: * ...
! 1050: */
! 1051: while (byte_stream_bytes_left(servdata))
! 1052: {
! 1053: guint16 gnlen, numb;
! 1054: int i;
! 1055: char *gn;
! 1056:
! 1057: gnlen = byte_stream_get16(servdata);
! 1058: gn = byte_stream_getstr(servdata, gnlen);
! 1059: numb = byte_stream_get16(servdata);
! 1060:
! 1061: for (i = 0; i < numb; i++) {
! 1062: guint16 bnlen;
! 1063: char *bn;
! 1064:
! 1065: bnlen = byte_stream_get16(servdata);
! 1066: bn = byte_stream_getstr(servdata, bnlen);
! 1067:
! 1068: purple_debug_misc("oscar", "got a buddy list from %s: group %s, buddy %s\n", userinfo->bn, gn, bn);
! 1069:
! 1070: g_free(bn);
! 1071: }
! 1072:
! 1073: g_free(gn);
! 1074: }
! 1075:
! 1076: return;
! 1077: }
! 1078:
! 1079: static void
! 1080: incomingim_ch2_buddyicon_free(OscarData *od, IcbmArgsCh2 *args)
! 1081: {
! 1082: g_free(args->info.icon.icon);
! 1083:
! 1084: return;
! 1085: }
! 1086:
! 1087: static void
! 1088: incomingim_ch2_buddyicon(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, aim_userinfo_t *userinfo, IcbmArgsCh2 *args, ByteStream *servdata)
! 1089: {
! 1090: args->info.icon.checksum = byte_stream_get32(servdata);
! 1091: args->info.icon.length = byte_stream_get32(servdata);
! 1092: args->info.icon.timestamp = byte_stream_get32(servdata);
! 1093: args->info.icon.icon = byte_stream_getraw(servdata, args->info.icon.length);
! 1094:
! 1095: args->destructor = (void *)incomingim_ch2_buddyicon_free;
! 1096:
! 1097: return;
! 1098: }
! 1099:
! 1100: static void
! 1101: incomingim_ch2_chat_free(OscarData *od, IcbmArgsCh2 *args)
! 1102: {
! 1103: /* XXX - aim_chat_roominfo_free() */
! 1104: g_free(args->info.chat.roominfo.name);
! 1105:
! 1106: return;
! 1107: }
! 1108:
! 1109: static void
! 1110: incomingim_ch2_chat(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, aim_userinfo_t *userinfo, IcbmArgsCh2 *args, ByteStream *servdata)
! 1111: {
! 1112: /*
! 1113: * Chat room info.
! 1114: */
! 1115: aim_chat_readroominfo(servdata, &args->info.chat.roominfo);
! 1116:
! 1117: args->destructor = (void *)incomingim_ch2_chat_free;
! 1118: }
! 1119:
! 1120: static void
! 1121: incomingim_ch2_icqserverrelay_free(OscarData *od, IcbmArgsCh2 *args)
! 1122: {
! 1123: g_free((char *)args->info.rtfmsg.msg);
! 1124: }
! 1125:
! 1126: /*
! 1127: * The relationship between OSCAR_CAPABILITY_ICQSERVERRELAY and OSCAR_CAPABILITY_ICQRTF is
! 1128: * kind of odd. This sends the client ICQRTF since that is all that I've seen
! 1129: * SERVERRELAY used for.
! 1130: *
! 1131: * Note that this is all little-endian. Cringe.
! 1132: *
! 1133: */
! 1134: static void
! 1135: incomingim_ch2_icqserverrelay(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, aim_userinfo_t *userinfo, IcbmArgsCh2 *args, ByteStream *servdata)
! 1136: {
! 1137: guint16 hdrlen, msglen;
! 1138:
! 1139: args->destructor = (void *)incomingim_ch2_icqserverrelay_free;
! 1140:
! 1141: #define SKIP_HEADER(expected_hdrlen) \
! 1142: hdrlen = byte_stream_getle16(servdata); \
! 1143: if (hdrlen != expected_hdrlen) { \
! 1144: purple_debug_warning("oscar", "Expected to find a header with length " #expected_hdrlen "; ignoring message"); \
! 1145: return; \
! 1146: } \
! 1147: byte_stream_advance(servdata, hdrlen);
! 1148:
! 1149: SKIP_HEADER(0x001b);
! 1150: SKIP_HEADER(0x000e);
! 1151:
! 1152: args->info.rtfmsg.msgtype = byte_stream_get8(servdata);
! 1153: /*
! 1154: * Copied from http://iserverd.khstu.ru/oscar/message.html:
! 1155: * xx byte message flags
! 1156: * xx xx word (LE) status code
! 1157: * xx xx word (LE) priority code
! 1158: *
! 1159: * We don't need any of these, so just skip them.
! 1160: */
! 1161: byte_stream_advance(servdata, 1 + 2 + 2);
! 1162:
! 1163: msglen = byte_stream_getle16(servdata);
! 1164: args->info.rtfmsg.msg = byte_stream_getstr(servdata, msglen);
! 1165: }
! 1166:
! 1167: static void
! 1168: incomingim_ch2_sendfile_free(OscarData *od, IcbmArgsCh2 *args)
! 1169: {
! 1170: g_free(args->info.sendfile.filename);
! 1171: }
! 1172:
! 1173: /* Someone is sending us a file */
! 1174: static void
! 1175: incomingim_ch2_sendfile(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, aim_userinfo_t *userinfo, IcbmArgsCh2 *args, ByteStream *servdata)
! 1176: {
! 1177: int flen;
! 1178:
! 1179: args->destructor = (void *)incomingim_ch2_sendfile_free;
! 1180:
! 1181: /* Maybe there is a better way to tell what kind of sendfile
! 1182: * this is? Maybe TLV t(000a)? */
! 1183:
! 1184: /* subtype is one of AIM_OFT_SUBTYPE_* */
! 1185: args->info.sendfile.subtype = byte_stream_get16(servdata);
! 1186: args->info.sendfile.totfiles = byte_stream_get16(servdata);
! 1187: args->info.sendfile.totsize = byte_stream_get32(servdata);
! 1188:
! 1189: /*
! 1190: * I hope to God I'm right when I guess that there is a
! 1191: * 32 char max filename length for single files. I think
! 1192: * OFT tends to do that. Gotta love inconsistency. I saw
! 1193: * a 26 byte filename?
! 1194: */
! 1195: /* AAA - create an byte_stream_getnullstr function (don't anymore)(maybe) */
! 1196: /* Use an inelegant way of getting the null-terminated filename,
! 1197: * since there's no easy bstream routine. */
! 1198: for (flen = 0; byte_stream_get8(servdata); flen++);
! 1199: byte_stream_advance(servdata, -flen -1);
! 1200: args->info.sendfile.filename = byte_stream_getstr(servdata, flen);
! 1201:
! 1202: /* There is sometimes more after the null-terminated filename,
! 1203: * but I'm unsure of its format. */
! 1204: /* I don't believe him. */
! 1205: /* There is sometimes a null byte inside a unicode filename,
! 1206: * but as far as I can tell the filename is the last
! 1207: * piece of data that will be in this message. --Jonathan */
! 1208: }
! 1209:
! 1210: typedef void (*ch2_args_destructor_t)(OscarData *od, IcbmArgsCh2 *args);
! 1211:
! 1212: static int incomingim_ch2(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, guint16 channel, aim_userinfo_t *userinfo, GSList *tlvlist, guint8 *cookie)
! 1213: {
! 1214: aim_rxcallback_t userfunc;
! 1215: aim_tlv_t *block1, *servdatatlv;
! 1216: GSList *list2;
! 1217: aim_tlv_t *tlv;
! 1218: IcbmArgsCh2 args;
! 1219: ByteStream bbs, sdbs, *sdbsptr = NULL;
! 1220: guint8 *cookie2;
! 1221: int ret = 0;
! 1222:
! 1223: char proxyip[30] = {""};
! 1224: char clientip[30] = {""};
! 1225: char verifiedip[30] = {""};
! 1226:
! 1227: memset(&args, 0, sizeof(args));
! 1228:
! 1229: /*
! 1230: * There's another block of TLVs embedded in the type 5 here.
! 1231: */
! 1232: block1 = aim_tlv_gettlv(tlvlist, 0x0005, 1);
! 1233: if (block1 == NULL)
! 1234: {
! 1235: /* The server sent us ch2 ICBM without ch2 info? Weird. */
! 1236: return 1;
! 1237: }
! 1238: byte_stream_init(&bbs, block1->value, block1->length);
! 1239:
! 1240: /*
! 1241: * First two bytes represent the status of the connection.
! 1242: * One of the AIM_RENDEZVOUS_ defines.
! 1243: *
! 1244: * 0 is a request, 1 is a cancel, 2 is an accept
! 1245: */
! 1246: args.status = byte_stream_get16(&bbs);
! 1247:
! 1248: /*
! 1249: * Next comes the cookie. Should match the ICBM cookie.
! 1250: */
! 1251: cookie2 = byte_stream_getraw(&bbs, 8);
! 1252: if (memcmp(cookie, cookie2, 8) != 0)
! 1253: {
! 1254: purple_debug_warning("oscar",
! 1255: "Cookies don't match in rendezvous ICBM, bailing out.\n");
! 1256: g_free(cookie2);
! 1257: return 1;
! 1258: }
! 1259: memcpy(args.cookie, cookie2, 8);
! 1260: g_free(cookie2);
! 1261:
! 1262: /*
! 1263: * The next 16bytes are a capability block so we can
! 1264: * identify what type of rendezvous this is.
! 1265: */
! 1266: args.type = aim_locate_getcaps(od, &bbs, 0x10);
! 1267:
! 1268: /*
! 1269: * What follows may be TLVs or nothing, depending on the
! 1270: * purpose of the message.
! 1271: *
! 1272: * Ack packets for instance have nothing more to them.
! 1273: */
! 1274: list2 = aim_tlvlist_read(&bbs);
! 1275:
! 1276: /*
! 1277: * IP address to proxy the file transfer through.
! 1278: *
! 1279: * TODO: I don't like this. Maybe just read in an int? Or inet_ntoa...
! 1280: */
! 1281: tlv = aim_tlv_gettlv(list2, 0x0002, 1);
! 1282: if ((tlv != NULL) && (tlv->length == 4))
! 1283: snprintf(proxyip, sizeof(proxyip), "%hhu.%hhu.%hhu.%hhu",
! 1284: tlv->value[0], tlv->value[1],
! 1285: tlv->value[2], tlv->value[3]);
! 1286:
! 1287: /*
! 1288: * IP address from the perspective of the client.
! 1289: */
! 1290: tlv = aim_tlv_gettlv(list2, 0x0003, 1);
! 1291: if ((tlv != NULL) && (tlv->length == 4))
! 1292: snprintf(clientip, sizeof(clientip), "%hhu.%hhu.%hhu.%hhu",
! 1293: tlv->value[0], tlv->value[1],
! 1294: tlv->value[2], tlv->value[3]);
! 1295:
! 1296: /*
! 1297: * Verified IP address (from the perspective of Oscar).
! 1298: *
! 1299: * This is added by the server.
! 1300: */
! 1301: tlv = aim_tlv_gettlv(list2, 0x0004, 1);
! 1302: if ((tlv != NULL) && (tlv->length == 4))
! 1303: snprintf(verifiedip, sizeof(verifiedip), "%hhu.%hhu.%hhu.%hhu",
! 1304: tlv->value[0], tlv->value[1],
! 1305: tlv->value[2], tlv->value[3]);
! 1306:
! 1307: /*
! 1308: * Port number for something.
! 1309: */
! 1310: if (aim_tlv_gettlv(list2, 0x0005, 1))
! 1311: args.port = aim_tlv_get16(list2, 0x0005, 1);
! 1312:
! 1313: /*
! 1314: * File transfer "request number":
! 1315: * 0x0001 - Initial file transfer request for no proxy or stage 1 proxy
! 1316: * 0x0002 - "Reply request" for a stage 2 proxy (receiver wants to use proxy)
! 1317: * 0x0003 - A third request has been sent; applies only to stage 3 proxied transfers
! 1318: */
! 1319: if (aim_tlv_gettlv(list2, 0x000a, 1))
! 1320: args.requestnumber = aim_tlv_get16(list2, 0x000a, 1);
! 1321:
! 1322: /*
! 1323: * Terminate connection/error code. 0x0001 means the other user
! 1324: * cancelled the connection.
! 1325: */
! 1326: if (aim_tlv_gettlv(list2, 0x000b, 1))
! 1327: args.errorcode = aim_tlv_get16(list2, 0x000b, 1);
! 1328:
! 1329: /*
! 1330: * Invitation message / chat description.
! 1331: */
! 1332: if (aim_tlv_gettlv(list2, 0x000c, 1)) {
! 1333: args.msg = aim_tlv_getstr(list2, 0x000c, 1);
! 1334: args.msglen = aim_tlv_getlength(list2, 0x000c, 1);
! 1335: }
! 1336:
! 1337: /*
! 1338: * Character set.
! 1339: */
! 1340: if (aim_tlv_gettlv(list2, 0x000d, 1))
! 1341: args.encoding = aim_tlv_getstr(list2, 0x000d, 1);
! 1342:
! 1343: /*
! 1344: * Language.
! 1345: */
! 1346: if (aim_tlv_gettlv(list2, 0x000e, 1))
! 1347: args.language = aim_tlv_getstr(list2, 0x000e, 1);
! 1348:
! 1349: /*
! 1350: * Flag meaning we should proxy the file transfer through an AIM server
! 1351: */
! 1352: if (aim_tlv_gettlv(list2, 0x0010, 1))
! 1353: args.use_proxy = TRUE;
! 1354:
! 1355: if (strlen(proxyip))
! 1356: args.proxyip = (char *)proxyip;
! 1357: if (strlen(clientip))
! 1358: args.clientip = (char *)clientip;
! 1359: if (strlen(verifiedip))
! 1360: args.verifiedip = (char *)verifiedip;
! 1361:
! 1362: /*
! 1363: * This must be present in PROPOSALs, but will probably not
! 1364: * exist in CANCELs and ACCEPTs. Also exists in ICQ Lite
! 1365: * Beta 4.0 URLs (OSCAR_CAPABILITY_ICQSERVERRELAY).
! 1366: *
! 1367: * Service Data blocks are module-specific in format.
! 1368: */
! 1369: if ((servdatatlv = aim_tlv_gettlv(list2, 0x2711 /* 10001 */, 1))) {
! 1370:
! 1371: byte_stream_init(&sdbs, servdatatlv->value, servdatatlv->length);
! 1372: sdbsptr = &sdbs;
! 1373:
! 1374: /*
! 1375: * The rest of the handling depends on what type it is.
! 1376: *
! 1377: * Not all of them have special handling (yet).
! 1378: */
! 1379: if (args.type & OSCAR_CAPABILITY_BUDDYICON)
! 1380: incomingim_ch2_buddyicon(od, conn, mod, frame, snac, userinfo, &args, sdbsptr);
! 1381: else if (args.type & OSCAR_CAPABILITY_SENDBUDDYLIST)
! 1382: incomingim_ch2_buddylist(od, conn, mod, frame, snac, userinfo, &args, sdbsptr);
! 1383: else if (args.type & OSCAR_CAPABILITY_CHAT)
! 1384: incomingim_ch2_chat(od, conn, mod, frame, snac, userinfo, &args, sdbsptr);
! 1385: else if (args.type & OSCAR_CAPABILITY_ICQSERVERRELAY)
! 1386: incomingim_ch2_icqserverrelay(od, conn, mod, frame, snac, userinfo, &args, sdbsptr);
! 1387: else if (args.type & OSCAR_CAPABILITY_SENDFILE)
! 1388: incomingim_ch2_sendfile(od, conn, mod, frame, snac, userinfo, &args, sdbsptr);
! 1389: }
! 1390:
! 1391: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1392: ret = userfunc(od, conn, frame, channel, userinfo, &args);
! 1393:
! 1394:
! 1395: if (args.destructor)
! 1396: ((ch2_args_destructor_t)args.destructor)(od, &args);
! 1397:
! 1398: g_free((char *)args.msg);
! 1399: g_free((char *)args.encoding);
! 1400: g_free((char *)args.language);
! 1401:
! 1402: aim_tlvlist_free(list2);
! 1403:
! 1404: return ret;
! 1405: }
! 1406:
! 1407: static int incomingim_ch4(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, guint16 channel, aim_userinfo_t *userinfo, GSList *tlvlist, guint8 *cookie)
! 1408: {
! 1409: ByteStream meat;
! 1410: aim_rxcallback_t userfunc;
! 1411: aim_tlv_t *block;
! 1412: struct aim_incomingim_ch4_args args;
! 1413: int ret = 0;
! 1414:
! 1415: /*
! 1416: * Make a bstream for the meaty part. Yum. Meat.
! 1417: */
! 1418: if (!(block = aim_tlv_gettlv(tlvlist, 0x0005, 1)))
! 1419: return -1;
! 1420: byte_stream_init(&meat, block->value, block->length);
! 1421:
! 1422: args.uin = byte_stream_getle32(&meat);
! 1423: args.type = byte_stream_getle8(&meat);
! 1424: args.flags = byte_stream_getle8(&meat);
! 1425: if (args.type == 0x1a)
! 1426: /* There seems to be a problem with the length in SMS msgs from server, this fixed it */
! 1427: args.msglen = block->length - 6;
! 1428: else
! 1429: args.msglen = byte_stream_getle16(&meat);
! 1430: args.msg = (gchar *)byte_stream_getraw(&meat, args.msglen);
! 1431:
! 1432: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1433: ret = userfunc(od, conn, frame, channel, userinfo, &args);
! 1434:
! 1435: g_free(args.msg);
! 1436:
! 1437: return ret;
! 1438: }
! 1439:
! 1440: /*
! 1441: * Subtype 0x0007
! 1442: *
! 1443: * It can easily be said that parsing ICBMs is THE single
! 1444: * most difficult thing to do in the in AIM protocol. In
! 1445: * fact, I think I just did say that.
! 1446: *
! 1447: * Below is the best damned solution I've come up with
! 1448: * over the past sixteen months of battling with it. This
! 1449: * can parse both away and normal messages from every client
! 1450: * I have access to. Its not fast, its not clean. But it works.
! 1451: *
! 1452: */
! 1453: static int incomingim(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1454: {
! 1455: int ret = 0;
! 1456: guchar *cookie;
! 1457: guint16 channel;
! 1458: aim_userinfo_t userinfo;
! 1459:
! 1460: memset(&userinfo, 0x00, sizeof(aim_userinfo_t));
! 1461:
! 1462: /*
! 1463: * Read ICBM Cookie.
! 1464: */
! 1465: cookie = byte_stream_getraw(bs, 8);
! 1466:
! 1467: /*
! 1468: * Channel ID.
! 1469: *
! 1470: * Channel 0x0001 is the message channel. It is
! 1471: * used to send basic ICBMs.
! 1472: *
! 1473: * Channel 0x0002 is the Rendezvous channel, which
! 1474: * is where Chat Invitiations and various client-client
! 1475: * connection negotiations come from.
! 1476: *
! 1477: * Channel 0x0003 is used for chat messages.
! 1478: *
! 1479: * Channel 0x0004 is used for ICQ authorization, or
! 1480: * possibly any system notice.
! 1481: *
! 1482: */
! 1483: channel = byte_stream_get16(bs);
! 1484:
! 1485: /*
! 1486: * Extract the standard user info block.
! 1487: *
! 1488: * Note that although this contains TLVs that appear contiguous
! 1489: * with the TLVs read below, they are two different pieces. The
! 1490: * userinfo block contains the number of TLVs that contain user
! 1491: * information, the rest are not even though there is no separation.
! 1492: * You can start reading the message TLVs after aim_info_extract()
! 1493: * parses out the standard userinfo block.
! 1494: *
! 1495: * That also means that TLV types can be duplicated between the
! 1496: * userinfo block and the rest of the message, however there should
! 1497: * never be two TLVs of the same type in one block.
! 1498: *
! 1499: */
! 1500: aim_info_extract(od, bs, &userinfo);
! 1501:
! 1502: /*
! 1503: * From here on, its depends on what channel we're on.
! 1504: *
! 1505: * Technically all channels have a TLV list have this, however,
! 1506: * for the common channel 1 case, in-place parsing is used for
! 1507: * performance reasons (less memory allocation).
! 1508: */
! 1509: if (channel == 1) {
! 1510:
! 1511: ret = incomingim_ch1(od, conn, mod, frame, snac, channel, &userinfo, bs, cookie);
! 1512:
! 1513: } else if (channel == 2) {
! 1514: GSList *tlvlist;
! 1515:
! 1516: /*
! 1517: * Read block of TLVs (not including the userinfo data). All
! 1518: * further data is derived from what is parsed here.
! 1519: */
! 1520: tlvlist = aim_tlvlist_read(bs);
! 1521:
! 1522: ret = incomingim_ch2(od, conn, mod, frame, snac, channel, &userinfo, tlvlist, cookie);
! 1523:
! 1524: aim_tlvlist_free(tlvlist);
! 1525:
! 1526: } else if (channel == 4) {
! 1527: GSList *tlvlist;
! 1528:
! 1529: tlvlist = aim_tlvlist_read(bs);
! 1530: ret = incomingim_ch4(od, conn, mod, frame, snac, channel, &userinfo, tlvlist, cookie);
! 1531: aim_tlvlist_free(tlvlist);
! 1532:
! 1533: } else {
! 1534: purple_debug_misc("oscar", "icbm: ICBM received on an unsupported channel. Ignoring. (chan = %04x)\n", channel);
! 1535: }
! 1536:
! 1537: aim_info_free(&userinfo);
! 1538: g_free(cookie);
! 1539:
! 1540: return ret;
! 1541: }
! 1542:
! 1543: /* Subtype 0x000a */
! 1544: static int missedcall(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1545: {
! 1546: int ret = 0;
! 1547: aim_rxcallback_t userfunc;
! 1548: guint16 channel, nummissed, reason;
! 1549: aim_userinfo_t userinfo;
! 1550:
! 1551: while (byte_stream_bytes_left(bs)) {
! 1552:
! 1553: channel = byte_stream_get16(bs);
! 1554: aim_info_extract(od, bs, &userinfo);
! 1555: nummissed = byte_stream_get16(bs);
! 1556: reason = byte_stream_get16(bs);
! 1557:
! 1558: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1559: ret = userfunc(od, conn, frame, channel, &userinfo, nummissed, reason);
! 1560:
! 1561: aim_info_free(&userinfo);
! 1562: }
! 1563:
! 1564: return ret;
! 1565: }
! 1566:
! 1567: /*
! 1568: * Subtype 0x000b
! 1569: *
! 1570: * Possible codes:
! 1571: * AIM_TRANSFER_DENY_DECLINE -- "client has declined transfer"
! 1572: *
! 1573: */
! 1574: int aim_im_denytransfer(OscarData *od, const char *bn, const guchar *cookie, guint16 code)
! 1575: {
! 1576: FlapConnection *conn;
! 1577: ByteStream bs;
! 1578: aim_snacid_t snacid;
! 1579: GSList *tlvlist = NULL;
! 1580:
! 1581: if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM)))
! 1582: return -EINVAL;
! 1583:
! 1584: byte_stream_new(&bs, 8+2+1+strlen(bn)+6);
! 1585:
! 1586: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x000b, 0x0000, NULL, 0);
! 1587:
! 1588: byte_stream_putraw(&bs, cookie, 8);
! 1589:
! 1590: byte_stream_put16(&bs, 0x0002); /* channel */
! 1591: byte_stream_put8(&bs, strlen(bn));
! 1592: byte_stream_putstr(&bs, bn);
! 1593:
! 1594: aim_tlvlist_add_16(&tlvlist, 0x0003, code);
! 1595: aim_tlvlist_write(&bs, &tlvlist);
! 1596: aim_tlvlist_free(tlvlist);
! 1597:
! 1598: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x000b, snacid, &bs);
! 1599:
! 1600: byte_stream_destroy(&bs);
! 1601:
! 1602: return 0;
! 1603: }
! 1604:
! 1605: /*
! 1606: * Subtype 0x000b.
! 1607: * Send confirmation for a channel 2 message (Miranda wants it by default).
! 1608: */
! 1609: void
! 1610: aim_im_send_icq_confirmation(OscarData *od, const char *bn, const guchar *cookie)
! 1611: {
! 1612: FlapConnection *conn;
! 1613: ByteStream bs;
! 1614: aim_snacid_t snacid;
! 1615: guint32 header_size, data_size;
! 1616: guint16 cookie2 = (guint16)g_random_int();
! 1617:
! 1618: purple_debug_misc("oscar", "Sending message ack to %s\n", bn);
! 1619:
! 1620: header_size = 8 + 2 + 1 + strlen(bn) + 2;
! 1621: data_size = 2 + 1 + 16 + 4*2 + 2*3 + 4*3 + 1*2 + 2*3 + 1;
! 1622: byte_stream_new(&bs, header_size + data_size);
! 1623:
! 1624: /* The message header. */
! 1625: aim_im_puticbm(&bs, cookie, 0x0002, bn);
! 1626: byte_stream_put16(&bs, 0x0003); /* reason */
! 1627:
! 1628: /* The actual message. */
! 1629: byte_stream_putle16(&bs, 0x1b); /* subheader #1 length */
! 1630: byte_stream_put8(&bs, 0x08); /* protocol version */
! 1631: byte_stream_putcaps(&bs, OSCAR_CAPABILITY_EMPTY);
! 1632: byte_stream_put32(&bs, 0x3); /* client features */
! 1633: byte_stream_put32(&bs, 0x0004); /* DC type */
! 1634: byte_stream_put16(&bs, cookie2); /* a cookie, chosen by fair dice roll */
! 1635: byte_stream_putle16(&bs, 0x0e); /* header #2 len? */
! 1636: byte_stream_put16(&bs, cookie2); /* the same cookie again */
! 1637: byte_stream_put32(&bs, 0); /* unknown */
! 1638: byte_stream_put32(&bs, 0); /* unknown */
! 1639: byte_stream_put32(&bs, 0); /* unknown */
! 1640: byte_stream_put8(&bs, 0x01); /* plain text message */
! 1641: byte_stream_put8(&bs, 0x00); /* no message flags */
! 1642: byte_stream_put16(&bs, 0x0000); /* no icq status */
! 1643: byte_stream_put16(&bs, 0x0100); /* priority */
! 1644: byte_stream_putle16(&bs, 1); /* query message len */
! 1645: byte_stream_put8(&bs, 0x00); /* empty query message */
! 1646:
! 1647: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x000b, 0x0000, NULL, 0);
! 1648: conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM);
! 1649: g_warn_if_fail(conn);
! 1650: if (conn) {
! 1651: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x000b,
! 1652: snacid, &bs);
! 1653: }
! 1654: byte_stream_destroy(&bs);
! 1655: }
! 1656:
! 1657: /*
! 1658: * Subtype 0x000b - Receive the response from an ICQ status message
! 1659: * request (in which case this contains the ICQ status message) or
! 1660: * a file transfer or direct IM request was declined.
! 1661: */
! 1662: static int clientautoresp(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1663: {
! 1664: int ret = 0;
! 1665: aim_rxcallback_t userfunc;
! 1666: guint16 channel, reason;
! 1667: char *bn;
! 1668: guchar *cookie;
! 1669: guint8 bnlen;
! 1670: char *xml = NULL;
! 1671: guint16 hdrlen;
! 1672: int curpos;
! 1673: guint16 num1, num2;
! 1674: PurpleAccount *account;
! 1675: PurpleBuddy *buddy;
! 1676: PurplePresence *presence;
! 1677: PurpleStatus *status;
! 1678:
! 1679: cookie = byte_stream_getraw(bs, 8);
! 1680: channel = byte_stream_get16(bs);
! 1681: bnlen = byte_stream_get8(bs);
! 1682: bn = byte_stream_getstr(bs, bnlen);
! 1683: reason = byte_stream_get16(bs);
! 1684:
! 1685: if (channel == 0x0002)
! 1686: {
! 1687: hdrlen = byte_stream_getle16(bs);
! 1688: if (hdrlen == 27 && bs->len > (27 + 51)) {
! 1689: byte_stream_advance(bs, 51);
! 1690: num1 = byte_stream_getle16(bs);
! 1691: num2 = byte_stream_getle16(bs);
! 1692: purple_debug_misc("oscar", "X-Status: num1 %hu, num2 %hu\n", num1, num2);
! 1693:
! 1694: if (num1 == 0x4f00 && num2 == 0x3b00) {
! 1695: byte_stream_advance(bs, 86);
! 1696: curpos = byte_stream_curpos(bs);
! 1697: xml = byte_stream_getstr(bs, bs->len - curpos);
! 1698: purple_debug_misc("oscar", "X-Status: Received XML reply\n");
! 1699: if (xml) {
! 1700: GString *xstatus;
! 1701: char *tmp1, *tmp2, *unescaped_xstatus;
! 1702:
! 1703: /* purple_debug_misc("oscar", "X-Status: XML reply: %s\n", xml); */
! 1704:
! 1705: xstatus = g_string_new(NULL);
! 1706:
! 1707: tmp1 = strstr(xml, "<title>");
! 1708: if (tmp1 != NULL) {
! 1709: tmp1 += 13;
! 1710: tmp2 = strstr(tmp1, "</title>");
! 1711: if (tmp2 != NULL)
! 1712: g_string_append_len(xstatus, tmp1, tmp2 - tmp1);
! 1713: }
! 1714: tmp1 = strstr(xml, "<desc>");
! 1715: if (tmp1 != NULL) {
! 1716: tmp1 += 12;
! 1717: tmp2 = strstr(tmp1, "</desc>");
! 1718: if (tmp2 != NULL) {
! 1719: if (xstatus->len > 0 && tmp2 > tmp1)
! 1720: g_string_append(xstatus, " - ");
! 1721: g_string_append_len(xstatus, tmp1, tmp2 - tmp1);
! 1722: }
! 1723: }
! 1724: unescaped_xstatus = purple_unescape_text(xstatus->str);
! 1725: g_string_free(xstatus, TRUE);
! 1726: if (*unescaped_xstatus) {
! 1727: purple_debug_misc("oscar", "X-Status reply: %s\n", unescaped_xstatus);
! 1728: account = purple_connection_get_account(od->gc);
! 1729: buddy = purple_find_buddy(account, bn);
! 1730: presence = purple_buddy_get_presence(buddy);
! 1731: status = purple_presence_get_status(presence, "mood");
! 1732: if (status) {
! 1733: purple_prpl_got_user_status(account, bn,
! 1734: "mood",
! 1735: PURPLE_MOOD_NAME, purple_status_get_attr_string(status, PURPLE_MOOD_NAME),
! 1736: PURPLE_MOOD_COMMENT, unescaped_xstatus, NULL);
! 1737: }
! 1738: }
! 1739: g_free(unescaped_xstatus);
! 1740: } else {
! 1741: purple_debug_misc("oscar", "X-Status: Can't get XML reply string\n");
! 1742: }
! 1743: } else {
! 1744: purple_debug_misc("oscar", "X-Status: 0x0004, 0x000b not an xstatus reply\n");
! 1745: }
! 1746:
! 1747: }
! 1748:
! 1749: } else if (channel == 0x0004) { /* ICQ message */
! 1750: switch (reason) {
! 1751: case 0x0003: { /* ICQ status message. Maybe other stuff too, you never know with these people. */
! 1752: guint8 statusmsgtype, *msg;
! 1753: guint16 len;
! 1754: guint32 state;
! 1755:
! 1756: len = byte_stream_getle16(bs); /* Should be 0x001b */
! 1757: byte_stream_advance(bs, len); /* Unknown */
! 1758:
! 1759: len = byte_stream_getle16(bs); /* Should be 0x000e */
! 1760: byte_stream_advance(bs, len); /* Unknown */
! 1761:
! 1762: statusmsgtype = byte_stream_getle8(bs);
! 1763: switch (statusmsgtype) {
! 1764: case 0xe8:
! 1765: state = AIM_ICQ_STATE_AWAY;
! 1766: break;
! 1767: case 0xe9:
! 1768: state = AIM_ICQ_STATE_AWAY | AIM_ICQ_STATE_BUSY;
! 1769: break;
! 1770: case 0xea:
! 1771: state = AIM_ICQ_STATE_AWAY | AIM_ICQ_STATE_OUT;
! 1772: break;
! 1773: case 0xeb:
! 1774: state = AIM_ICQ_STATE_AWAY | AIM_ICQ_STATE_DND | AIM_ICQ_STATE_BUSY;
! 1775: break;
! 1776: case 0xec:
! 1777: state = AIM_ICQ_STATE_CHAT;
! 1778: break;
! 1779: default:
! 1780: state = 0;
! 1781: break;
! 1782: }
! 1783:
! 1784: byte_stream_getle8(bs); /* Unknown - 0x03 Maybe this means this is an auto-reply */
! 1785: byte_stream_getle16(bs); /* Unknown - 0x0000 */
! 1786: byte_stream_getle16(bs); /* Unknown - 0x0000 */
! 1787:
! 1788: len = byte_stream_getle16(bs);
! 1789: msg = byte_stream_getraw(bs, len);
! 1790:
! 1791: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1792: ret = userfunc(od, conn, frame, channel, bn, reason, state, msg);
! 1793:
! 1794: g_free(msg);
! 1795: } break;
! 1796:
! 1797: default: {
! 1798: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 1799: ret = userfunc(od, conn, frame, channel, bn, reason);
! 1800: } break;
! 1801: } /* end switch */
! 1802: }
! 1803:
! 1804: g_free(cookie);
! 1805: g_free(bn);
! 1806: g_free(xml);
! 1807:
! 1808: return ret;
! 1809: }
! 1810:
! 1811: /*
! 1812: * Subtype 0x000c - Receive an ack after sending an ICBM. The ack contains the ICBM header of the message you sent.
! 1813: */
! 1814: static int msgack(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 1815: {
! 1816: guchar *cookie;
! 1817: char *bn;
! 1818: int ret = 0;
! 1819:
! 1820: cookie = byte_stream_getraw(bs, 8);
! 1821: byte_stream_get16(bs); /* ch */
! 1822: bn = byte_stream_getstr(bs, byte_stream_get8(bs));
! 1823:
! 1824: purple_debug_info("oscar", "Sent message to %s.\n", bn);
! 1825:
! 1826: g_free(bn);
! 1827: g_free(cookie);
! 1828:
! 1829: return ret;
! 1830: }
! 1831:
! 1832: /*
! 1833: * Subtype 0x0010 - Request any offline messages that are waiting for
! 1834: * us. This is the "new" way of handling offline messages which is
! 1835: * used for both AIM and ICQ. The old way is to use the ugly
! 1836: * aim_icq_reqofflinemsgs() function, but that is no longer necessary.
! 1837: *
! 1838: * We set the 0x00000100 flag on the ICBM message parameters, which
! 1839: * tells the oscar servers that we support offline messages. When we
! 1840: * set that flag the servers do not automatically send us offline
! 1841: * messages. Instead we must request them using this function. This
! 1842: * should happen after sending the 0x0001/0x0002 "client online" SNAC.
! 1843: */
! 1844: int aim_im_reqofflinemsgs(OscarData *od)
! 1845: {
! 1846: FlapConnection *conn;
! 1847:
! 1848: if (!od || !(conn = flap_connection_findbygroup(od, 0x0002)))
! 1849: return -EINVAL;
! 1850:
! 1851: aim_genericreq_n(od, conn, SNAC_FAMILY_ICBM, 0x0010);
! 1852:
! 1853: return 0;
! 1854: }
! 1855:
! 1856: /*
! 1857: * Subtype 0x0014 - Send a mini typing notification (mtn) packet.
! 1858: *
! 1859: * This is supported by winaim5 and newer, MacAIM bleh and newer, iChat bleh and newer,
! 1860: * and Purple 0.60 and newer.
! 1861: *
! 1862: */
! 1863: int aim_im_sendmtn(OscarData *od, guint16 channel, const char *bn, guint16 event)
! 1864: {
! 1865: FlapConnection *conn;
! 1866: ByteStream bs;
! 1867: aim_snacid_t snacid;
! 1868:
! 1869: if (!od || !(conn = flap_connection_findbygroup(od, 0x0002)))
! 1870: return -EINVAL;
! 1871:
! 1872: if (!bn)
! 1873: return -EINVAL;
! 1874:
! 1875: byte_stream_new(&bs, 11 + strlen(bn) + 2);
! 1876:
! 1877: snacid = aim_cachesnac(od, SNAC_FAMILY_ICBM, 0x0014, 0x0000, NULL, 0);
! 1878:
! 1879: /* ICBM cookie */
! 1880: byte_stream_put32(&bs, 0x00000000);
! 1881: byte_stream_put32(&bs, 0x00000000);
! 1882:
! 1883: /*
! 1884: * Channel (should be 0x0001 for mtn)
! 1885: */
! 1886: byte_stream_put16(&bs, channel);
! 1887:
! 1888: /*
! 1889: * Dest buddy name
! 1890: */
! 1891: byte_stream_put8(&bs, strlen(bn));
! 1892: byte_stream_putstr(&bs, bn);
! 1893:
! 1894: /*
! 1895: * Event (should be 0x0000, 0x0001, or 0x0002 for mtn)
! 1896: */
! 1897: byte_stream_put16(&bs, event);
! 1898:
! 1899: flap_connection_send_snac(od, conn, SNAC_FAMILY_ICBM, 0x0014, snacid, &bs);
! 1900:
! 1901: byte_stream_destroy(&bs);
! 1902:
! 1903: return 0;
! 1904: }
! 1905:
! 1906: /*
! 1907: * Subtype 0x0006 - Send eXtra Status request
! 1908: */
! 1909: int icq_im_xstatus_request(OscarData *od, const char *sn)
! 1910: {
! 1911: FlapConnection *conn;
! 1912: aim_snacid_t snacid;
! 1913: guchar cookie[8];
! 1914: GSList *outer_tlvlist = NULL, *inner_tlvlist = NULL;
! 1915: ByteStream bs, header, plugindata;
! 1916: PurpleAccount *account;
! 1917: const char *fmt;
! 1918: char *statxml;
! 1919: int xmllen;
! 1920:
! 1921: static const guint8 pluginid[] = {
! 1922: 0x09, 0x46, 0x13, 0x49, 0x4C, 0x7F, 0x11, 0xD1,
! 1923: 0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00
! 1924: };
! 1925:
! 1926: static const guint8 c_plugindata[] = {
! 1927: 0x1B, 0x00, 0x0A,
! 1928: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 1929: 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0xF9, 0xD1, 0x0E, 0x00, 0xF9, 0xD1, 0x00, 0x00,
! 1930: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x01, 0x00,
! 1931: 0x01, 0x00, 0x00, 0x4F, 0x00, 0x3B, 0x60, 0xB3, 0xEF, 0xD8, 0x2A, 0x6C, 0x45, 0xA4, 0xE0, 0x9C,
! 1932: 0x5A, 0x5E, 0x67, 0xE8, 0x65, 0x08, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x53, 0x63, 0x72, 0x69, 0x70,
! 1933: 0x74, 0x20, 0x50, 0x6C, 0x75, 0x67, 0x2D, 0x69, 0x6E, 0x3A, 0x20, 0x52, 0x65, 0x6D, 0x6F, 0x74,
! 1934: 0x65, 0x20, 0x4E, 0x6F, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x41,
! 1935: 0x72, 0x72, 0x69, 0x76, 0x65, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 1936: 0x00, 0x00, 0x00, 0x00, 0x14, 0x01, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00
! 1937: };
! 1938:
! 1939: if (!od || !(conn = flap_connection_findbygroup(od, 0x0004)))
! 1940: return -EINVAL;
! 1941:
! 1942: if (!sn)
! 1943: return -EINVAL;
! 1944:
! 1945: fmt = "<N><QUERY><Q><PluginID>srvMng</PluginID></Q></QUERY><NOTIFY><srv><id>cAwaySrv</id><req><id>AwayStat</id><trans>2</trans><senderId>%s</senderId></req></srv></NOTIFY></N>\r\n";
! 1946:
! 1947: account = purple_connection_get_account(od->gc);
! 1948:
! 1949: statxml = g_strdup_printf(fmt, account->username);
! 1950: xmllen = strlen(statxml);
! 1951:
! 1952: aim_icbm_makecookie(cookie);
! 1953:
! 1954: byte_stream_new(&bs, 10 + 8 + 2 + 1 + strlen(sn) + 2
! 1955: + 2 + 2 + 8 + 16 + 2 + 2 + 2 + 2 + 2
! 1956: + 2 + 2 + sizeof(c_plugindata) + xmllen
! 1957: + 2 + 2);
! 1958:
! 1959: snacid = aim_cachesnac(od, 0x0004, 0x0006, 0x0000, NULL, 0);
! 1960: aim_im_puticbm(&bs, cookie, 0x0002, sn);
! 1961:
! 1962: byte_stream_new(&header, (7*2) + 16 + 8 + 2 + sizeof(c_plugindata) + xmllen); /* TLV 0x0005 Stream + Size */
! 1963: byte_stream_put16(&header, 0x0000); /* Message Type: Request */
! 1964: byte_stream_putraw(&header, cookie, sizeof(cookie)); /* Message ID */
! 1965: byte_stream_putraw(&header, pluginid, sizeof(pluginid)); /* Plugin ID */
! 1966:
! 1967: aim_tlvlist_add_16(&inner_tlvlist, 0x000a, 0x0001);
! 1968: aim_tlvlist_add_noval(&inner_tlvlist, 0x000f);
! 1969:
! 1970: /* Add Plugin Specific Data */
! 1971: byte_stream_new(&plugindata, (sizeof(c_plugindata) + xmllen));
! 1972: byte_stream_putraw(&plugindata, c_plugindata, sizeof(c_plugindata)); /* Content of TLV 0x2711 */
! 1973: byte_stream_putraw(&plugindata, (const guint8*)statxml, xmllen);
! 1974:
! 1975: aim_tlvlist_add_raw(&inner_tlvlist, 0x2711, (sizeof(c_plugindata) + xmllen), plugindata.data);
! 1976:
! 1977: aim_tlvlist_write(&header, &inner_tlvlist);
! 1978: aim_tlvlist_free(inner_tlvlist);
! 1979:
! 1980: aim_tlvlist_add_raw(&outer_tlvlist, 0x0005, byte_stream_curpos(&header), header.data);
! 1981: aim_tlvlist_add_noval(&outer_tlvlist, 0x0003); /* Empty TLV 0x0003 */
! 1982:
! 1983: aim_tlvlist_write(&bs, &outer_tlvlist);
! 1984:
! 1985: purple_debug_misc("oscar", "X-Status Request\n");
! 1986: flap_connection_send_snac_with_priority(od, conn, 0x0004, 0x0006, snacid, &bs, TRUE);
! 1987:
! 1988: aim_tlvlist_free(outer_tlvlist);
! 1989: byte_stream_destroy(&header);
! 1990: byte_stream_destroy(&plugindata);
! 1991: byte_stream_destroy(&bs);
! 1992: g_free(statxml);
! 1993:
! 1994: return 0;
! 1995: }
! 1996:
! 1997: int icq_relay_xstatus(OscarData *od, const char *sn, const guchar *cookie)
! 1998: {
! 1999: FlapConnection *conn;
! 2000: ByteStream bs;
! 2001: aim_snacid_t snacid;
! 2002: PurpleAccount *account;
! 2003: PurpleStatus *status;
! 2004: const char *fmt;
! 2005: const char *formatted_msg;
! 2006: char *msg;
! 2007: char *statxml;
! 2008: const char *title;
! 2009: int len;
! 2010:
! 2011: static const guint8 plugindata[] = {
! 2012: 0x1B, 0x00,
! 2013: 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 2014: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 2015: 0x01, 0x00, 0x00, 0x00, 0x00, 0xF9, 0xD1, 0x0E, 0x00, 0xF9, 0xD1,
! 2016: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 2017: 0x00, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x4F,
! 2018: 0x00, 0x3B, 0x60, 0xB3, 0xEF, 0xD8, 0x2A, 0x6C, 0x45, 0xA4, 0xE0,
! 2019: 0x9C, 0x5A, 0x5E, 0x67, 0xE8, 0x65, 0x08, 0x00, 0x2A, 0x00, 0x00,
! 2020: 0x00, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, 0x50, 0x6C, 0x75,
! 2021: 0x67, 0x2D, 0x69, 0x6E, 0x3A, 0x20, 0x52, 0x65, 0x6D, 0x6F, 0x74,
! 2022: 0x65, 0x20, 0x4E, 0x6F, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74,
! 2023: 0x69, 0x6F, 0x6E, 0x20, 0x41, 0x72, 0x72, 0x69, 0x76, 0x65, 0x00,
! 2024: 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 2025: 0x00, 0x00, 0x00, 0xF3, 0x01, 0x00, 0x00, 0xEF, 0x01, 0x00, 0x00
! 2026: };
! 2027:
! 2028: fmt = "<NR><RES><ret event='OnRemoteNotification'><srv><id>cAwaySrv</id><val srv_id='cAwaySrv'><Root><CASXtraSetAwayMessage></CASXtraSetAwayMessage>&l t;uin>%s</uin><index>1</index><title>%s</title><desc>%s</desc></Root></val></srv><srv><id>cRandomizerSrv</id><val srv_id='cRandomizerSrv'>undefined</val></srv></ret></RES></NR>\r\n";
! 2029:
! 2030: if (!od || !(conn = flap_connection_findbygroup(od, 0x0002)))
! 2031: return -EINVAL;
! 2032:
! 2033: if (!sn)
! 2034: return -EINVAL;
! 2035:
! 2036: account = purple_connection_get_account(od->gc);
! 2037: if (!account)
! 2038: return -EINVAL;
! 2039:
! 2040: /* if (purple_strequal(account->username, sn))
! 2041: icq_im_xstatus_request(od, sn); */
! 2042:
! 2043: status = purple_presence_get_active_status(account->presence);
! 2044: if (!status)
! 2045: return -EINVAL;
! 2046:
! 2047: title = purple_status_get_name(status);
! 2048: if (!title)
! 2049: return -EINVAL;
! 2050:
! 2051: formatted_msg = purple_status_get_attr_string(status, "message");
! 2052: if (!formatted_msg)
! 2053: return -EINVAL;
! 2054:
! 2055: msg = purple_markup_strip_html(formatted_msg);
! 2056: if (!msg)
! 2057: return -EINVAL;
! 2058:
! 2059: statxml = g_strdup_printf(fmt, account->username, title, msg);
! 2060: len = strlen(statxml);
! 2061:
! 2062: purple_debug_misc("oscar", "X-Status AutoReply: %s, %s\n", formatted_msg, msg);
! 2063:
! 2064: byte_stream_new(&bs, 10 + 8 + 2 + 1 + strlen(sn) + 2 + sizeof(plugindata) + len); /* 16 extra */
! 2065:
! 2066: snacid = aim_cachesnac(od, 0x0004, 0x000b, 0x0000, NULL, 0);
! 2067: aim_im_puticbm(&bs, cookie, 0x0002, sn);
! 2068: byte_stream_put16(&bs, 0x0003);
! 2069: byte_stream_putraw(&bs, plugindata, sizeof(plugindata));
! 2070: byte_stream_putraw(&bs, (const guint8*)statxml, len);
! 2071:
! 2072: flap_connection_send_snac_with_priority(od, conn, 0x0004, 0x000b, snacid, &bs, TRUE);
! 2073:
! 2074: g_free(statxml);
! 2075: g_free(msg);
! 2076: byte_stream_destroy(&bs);
! 2077:
! 2078: return 0;
! 2079: }
! 2080:
! 2081: /*
! 2082: * Subtype 0x0014 - Receive a mini typing notification (mtn) packet.
! 2083: *
! 2084: * This is supported by winaim5 and newer, MacAIM bleh and newer, iChat bleh and newer,
! 2085: * and Purple 0.60 and newer.
! 2086: *
! 2087: */
! 2088: static int mtn_receive(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 2089: {
! 2090: int ret = 0;
! 2091: aim_rxcallback_t userfunc;
! 2092: char *bn;
! 2093: guint8 bnlen;
! 2094: guint16 channel, event;
! 2095:
! 2096: byte_stream_advance(bs, 8); /* ICBM cookie */
! 2097: channel = byte_stream_get16(bs);
! 2098: bnlen = byte_stream_get8(bs);
! 2099: bn = byte_stream_getstr(bs, bnlen);
! 2100: event = byte_stream_get16(bs);
! 2101:
! 2102: if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
! 2103: ret = userfunc(od, conn, frame, channel, bn, event);
! 2104:
! 2105: g_free(bn);
! 2106:
! 2107: return ret;
! 2108: }
! 2109:
! 2110: static int
! 2111: snachandler(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
! 2112: {
! 2113: if (snac->subtype == 0x0001)
! 2114: return error(od, conn, mod, frame, snac, bs);
! 2115: else if (snac->subtype == 0x0005)
! 2116: return aim_im_paraminfo(od, conn, mod, frame, snac, bs);
! 2117: else if (snac->subtype == 0x0007)
! 2118: return incomingim(od, conn, mod, frame, snac, bs);
! 2119: else if (snac->subtype == 0x000a)
! 2120: return missedcall(od, conn, mod, frame, snac, bs);
! 2121: else if (snac->subtype == 0x000b)
! 2122: return clientautoresp(od, conn, mod, frame, snac, bs);
! 2123: else if (snac->subtype == 0x000c)
! 2124: return msgack(od, conn, mod, frame, snac, bs);
! 2125: else if (snac->subtype == 0x0014)
! 2126: return mtn_receive(od, conn, mod, frame, snac, bs);
! 2127:
! 2128: return 0;
! 2129: }
! 2130:
! 2131: int
! 2132: msg_modfirst(OscarData *od, aim_module_t *mod)
! 2133: {
! 2134: mod->family = SNAC_FAMILY_ICBM;
! 2135: mod->version = 0x0001;
! 2136: mod->toolid = 0x0110;
! 2137: mod->toolversion = 0x0629;
! 2138: mod->flags = 0;
! 2139: strncpy(mod->name, "messaging", sizeof(mod->name));
! 2140: mod->snachandler = snachandler;
! 2141:
! 2142: return 0;
! 2143: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to family_icbm.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