4 * The routines for sending/receiving Instant Messages.
12 * Send an ICBM (instant message).
16 * AIM_IMFLAGS_AWAY -- Marks the message as an autoresponse
17 * AIM_IMFLAGS_ACK -- Requests that the server send an ack
18 * when the message is received (of type 0x0004/0x000c)
21 faim_export unsigned long aim_send_im(struct aim_session_t *sess,
22 struct aim_conn_t *conn,
23 char *destsn, u_int flags, char *msg)
27 struct command_tx_struct *newpacket;
29 if (strlen(msg) >= MAXMSGLEN)
32 if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, strlen(msg)+256)))
35 newpacket->lock = 1; /* lock struct */
38 curbyte += aim_putsnac(newpacket->data+curbyte,
39 0x0004, 0x0006, 0x0000, sess->snac_nextid);
42 * Generate a random message cookie
44 * We could cache these like we do SNAC IDs. (In fact, it
45 * might be a good idea.) In the message error functions,
46 * the 8byte message cookie is returned as well as the
51 curbyte += aimutil_put8(newpacket->data+curbyte, (u_char) rand());
56 curbyte += aimutil_put16(newpacket->data+curbyte,0x0001);
59 * Destination SN (prepended with byte length)
61 curbyte += aimutil_put8(newpacket->data+curbyte,strlen(destsn));
62 curbyte += aimutil_putstr(newpacket->data+curbyte, destsn, strlen(destsn));
67 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
68 curbyte += aimutil_put16(newpacket->data+curbyte, strlen(msg) + 0x10);
71 * Flag data / ICBM Parameters?
73 curbyte += aimutil_put8(newpacket->data+curbyte, 0x05);
74 curbyte += aimutil_put8(newpacket->data+curbyte, 0x01);
76 /* number of bytes to follow */
77 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0004);
78 curbyte += aimutil_put8(newpacket->data+curbyte, 0x01);
79 curbyte += aimutil_put8(newpacket->data+curbyte, 0x01);
80 curbyte += aimutil_put8(newpacket->data+curbyte, 0x01);
81 curbyte += aimutil_put8(newpacket->data+curbyte, 0x02);
83 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0101);
86 * Message block length.
88 curbyte += aimutil_put16(newpacket->data+curbyte, strlen(msg) + 0x04);
93 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
94 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
97 * Message. Not terminated.
99 curbyte += aimutil_putstr(newpacket->data+curbyte,msg, strlen(msg));
102 * Set the Request Acknowledge flag.
104 if (flags & AIM_IMFLAGS_ACK) {
105 curbyte += aimutil_put16(newpacket->data+curbyte,0x0003);
106 curbyte += aimutil_put16(newpacket->data+curbyte,0x0000);
110 * Set the Autoresponse flag.
112 if (flags & AIM_IMFLAGS_AWAY) {
113 curbyte += aimutil_put16(newpacket->data+curbyte,0x0004);
114 curbyte += aimutil_put16(newpacket->data+curbyte,0x0000);
117 newpacket->commandlen = curbyte;
120 aim_tx_enqueue(sess, newpacket);
122 aim_cachesnac(sess, 0x0004, 0x0006, 0x0000, destsn, strlen(destsn)+1);
123 aim_cleansnacs(sess, 60); /* clean out all SNACs over 60sec old */
125 return sess->snac_nextid;
128 faim_internal int aim_parse_outgoing_im_middle(struct aim_session_t *sess,
129 struct command_rx_struct *command)
131 unsigned int i = 0, z;
132 rxcallback_t userfunc = NULL;
133 unsigned char cookie[8];
135 struct aim_tlvlist_t *tlvlist;
137 unsigned short icbmflags = 0;
138 unsigned char flag1 = 0, flag2 = 0;
139 unsigned char *msgblock = NULL, *msg = NULL;
144 for (z=0; z<8; z++,i++)
145 cookie[z] = command->data[i];
148 channel = aimutil_get16(command->data+i);
151 if (channel != 0x01) {
152 printf("faim: icbm: ICBM recieved on unsupported channel. Ignoring. (chan = %04x)\n", channel);
156 strncpy(sn, (char *) command->data+i+1, (int) *(command->data+i));
157 i += 1 + (int) *(command->data+i);
159 tlvlist = aim_readtlvchain(command->data+i, command->commandlen-i);
161 if (aim_gettlv(tlvlist, 0x0003, 1))
162 icbmflags |= AIM_IMFLAGS_ACK;
163 if (aim_gettlv(tlvlist, 0x0004, 1))
164 icbmflags |= AIM_IMFLAGS_AWAY;
166 if (aim_gettlv(tlvlist, 0x0002, 1)) {
169 msgblock = (unsigned char *)aim_gettlv_str(tlvlist, 0x0002, 1);
171 /* no, this really is correct. I'm not high or anything either. */
173 j += 2 + aimutil_get16(msgblock+j);
176 j += 2; /* final block length */
178 flag1 = aimutil_get16(msgblock);
180 flag2 = aimutil_get16(msgblock);
186 if ((userfunc = aim_callhandler(command->conn, 0x0004, 0x0006)) || (i = 0))
187 i = userfunc(sess, command, channel, sn, msg, icbmflags, flag1, flag2);
191 aim_freetlvchain(&tlvlist);
197 * It can easily be said that parsing ICBMs is THE single
198 * most difficult thing to do in the in AIM protocol. In
199 * fact, I think I just did say that.
201 * Below is the best damned solution I've come up with
202 * over the past sixteen months of battling with it. This
203 * can parse both away and normal messages from every client
204 * I have access to. Its not fast, its not clean. But it works.
206 * We should also support at least minimal parsing of
207 * Channel 2, so that we can at least know the name of the
208 * room we're invited to, but obviously can't attend...
211 faim_internal int aim_parse_incoming_im_middle(struct aim_session_t *sess,
212 struct command_rx_struct *command)
215 rxcallback_t userfunc = NULL;
218 struct aim_tlvlist_t *tlvlist;
219 struct aim_userinfo_s userinfo;
222 memset(&userinfo, 0x00, sizeof(struct aim_userinfo_s));
224 i = 10; /* Skip SNAC header */
227 * Read ICBM Cookie. And throw away.
229 for (z=0; z<8; z++,i++)
230 cookie[z] = command->data[i];
235 * Channel 0x0001 is the message channel. There are
236 * other channels for things called "rendevous"
237 * which represent chat and some of the other new
238 * features of AIM2/3/3.5.
240 * Channel 0x0002 is the Rendevous channel, which
241 * is where Chat Invitiations and various client-client
242 * connection negotiations come from.
245 channel = aimutil_get16(command->data+i);
251 if ((channel != 0x01) && (channel != 0x02))
253 printf("faim: icbm: ICBM received on an unsupported channel. Ignoring.\n (chan = %04x)", channel);
258 * Extract the standard user info block.
260 * Note that although this contains TLVs that appear contiguous
261 * with the TLVs read below, they are two different pieces. The
262 * userinfo block contains the number of TLVs that contain user
263 * information, the rest are not even though there is no seperation.
264 * aim_extractuserinfo() returns the number of bytes used by the
265 * userinfo tlvs, so you can start reading the rest of them right
268 * That also means that TLV types can be duplicated between the
269 * userinfo block and the rest of the message, however there should
270 * never be two TLVs of the same type in one block.
273 i += aim_extractuserinfo(command->data+i, &userinfo);
276 * Read block of TLVs (not including the userinfo data). All
277 * further data is derived from what is parsed here.
279 tlvlist = aim_readtlvchain(command->data+i, command->commandlen-i);
282 * From here on, its depends on what channel we're on.
286 u_int j = 0, y = 0, z = 0;
289 struct aim_tlv_t *msgblocktlv;
294 * Check Autoresponse status. If it is an autoresponse,
295 * it will contain a type 0x0004 TLV, with zero length.
297 if (aim_gettlv(tlvlist, 0x0004, 1))
298 icbmflags |= AIM_IMFLAGS_AWAY;
301 * Check Ack Request status.
303 if (aim_gettlv(tlvlist, 0x0003, 1))
304 icbmflags |= AIM_IMFLAGS_ACK;
309 msgblocktlv = aim_gettlv(tlvlist, 0x0002, 1);
310 if (!msgblocktlv || !msgblocktlv->value) {
311 printf("faim: icbm: major error! no message block TLV found!\n");
312 aim_freetlvchain(&tlvlist);
317 * Extracting the message from the unknown cruft.
319 * This is a bit messy, and I'm not really qualified,
320 * even as the author, to comment on it. At least
321 * its not as bad as a while loop shooting into infinity.
323 * "Do you believe in magic?"
326 msgblock = msgblocktlv->value;
329 wastebits = aimutil_get8(msgblock+j++);
330 wastebits = aimutil_get8(msgblock+j++);
332 y = aimutil_get16(msgblock+j);
334 for (z = 0; z < y; z++)
335 wastebits = aimutil_get8(msgblock+j++);
336 wastebits = aimutil_get8(msgblock+j++);
337 wastebits = aimutil_get8(msgblock+j++);
340 * Message string length, including flag words.
342 i = aimutil_get16(msgblock+j);
348 * Its rumored that these can kick in some funky
349 * 16bit-wide char stuff that used to really kill
350 * libfaim. Hopefully the latter is no longer true.
352 * Though someone should investiagte the former.
355 flag1 = aimutil_get16(msgblock+j);
357 flag2 = aimutil_get16(msgblock+j);
361 printf("faim: icbm: **warning: encoding flags are being used! {%04x, %04x}\n", flag1, flag2);
367 msg = (char *)malloc(i+1);
368 memcpy(msg, msgblock+j, i);
374 userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
376 i = userfunc(sess, command, channel, &userinfo, msg, icbmflags, flag1, flag2);
382 else if (channel == 0x0002)
384 struct aim_tlv_t *block1;
385 struct aim_tlvlist_t *list2;
386 unsigned short reqclass = 0;
387 unsigned short status = 0;
390 * There's another block of TLVs embedded in the type 5 here.
392 block1 = aim_gettlv(tlvlist, 0x0005, 1);
394 printf("faim: no tlv 0x0005 in rendezvous transaction!\n");
395 aim_freetlvchain(&tlvlist);
396 return 1; /* major problem */
400 * First two bytes represent the status of the connection.
402 * 0 is a request, 2 is an accept
404 status = aimutil_get16(block1->value+0);
407 * Next comes the cookie. Should match the ICBM cookie.
409 if (memcmp(block1->value+2, cookie, 8) != 0)
410 printf("faim: rend: warning cookies don't match!\n");
413 * The next 16bytes are a capability block so we can
414 * identify what type of rendezvous this is.
416 * Thanks to Eric Warmenhoven <warmenhoven@linux.com> (of GAIM)
417 * for pointing some of this out to me. In fact, a lot of
418 * the client-to-client info comes from the work of the GAIM
419 * developers. Thanks!
421 * Read off one capability string and we should have it ID'd.
424 reqclass = aim_getcap(block1->value+2+8, 0x10);
425 if (reqclass == 0x0000) {
426 printf("faim: rend: no ID block\n");
427 aim_freetlvchain(&tlvlist);
432 * What follows may be TLVs or nothing, depending on the
433 * purpose of the message.
435 * Ack packets for instance have nothing more to them.
437 list2 = aim_readtlvchain(block1->value+2+8+16, block1->length-2-8-16);
439 if (!list2 || ((reqclass != AIM_CAPS_IMIMAGE) && !(aim_gettlv(list2, 0x2711, 1)))) {
440 struct aim_msgcookie_t *cook;
443 type = aim_msgcookie_gettype(reqclass); /* XXX: fix this shitty code */
446 if ((cook = aim_uncachecookie(sess, cookie, type)) == NULL) {
447 printf("faim: non-data rendezvous thats not in cache!\n");
448 aim_freetlvchain(&list2);
449 aim_freetlvchain(&tlvlist);
454 if (cook->type == AIM_COOKIETYPE_OFTGET) {
455 struct aim_filetransfer_priv *ft;
458 int errorcode = -1; /* XXX shouldnt this be 0? */
460 ft = (struct aim_filetransfer_priv *)cook->data;
462 if(status != 0x0002) {
463 if (aim_gettlv(list2, 0x000b, 1))
464 errorcode = aim_gettlv16(list2, 0x000b, 1);
467 printf("faim: transfer from %s (%s) for %s cancelled (error code %d)\n", ft->sn, ft->ip, ft->fh.name, errorcode);
470 printf("faim: no data attached to file transfer\n");
472 } else if (cook->type == AIM_CAPS_VOICE) {
473 printf("faim: voice request cancelled\n");
475 printf("faim: unknown cookie cache type %d\n", cook->type);
479 aim_freetlvchain(&list2);
480 aim_freetlvchain(&tlvlist);
485 * The rest of the handling depends on what type it is.
487 if (reqclass & AIM_CAPS_BUDDYICON) {
493 userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
494 if (userfunc || (i = 0))
504 } else if (reqclass & AIM_CAPS_VOICE) {
505 struct aim_msgcookie_t *cachedcook;
507 printf("faim: rend: voice!\n");
509 if(!(cachedcook = (struct aim_msgcookie_t*)calloc(1, sizeof(struct aim_msgcookie_t))))
512 memcpy(cachedcook->cookie, cookie, 8);
513 cachedcook->type = AIM_COOKIETYPE_OFTVOICE;
514 cachedcook->data = NULL;
516 if (aim_cachecookie(sess, cachedcook) != 0)
517 printf("faim: ERROR caching message cookie\n");
519 /* XXX: implement all this */
524 userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
525 if (userfunc || (i = 0)) {
526 i = userfunc(sess, command, channel, reqclass, &userinfo);
528 } else if ((reqclass & AIM_CAPS_IMIMAGE) || (reqclass & AIM_CAPS_BUDDYICON)) {
530 struct aim_directim_priv *priv;
534 if (aim_gettlv(list2, 0x0003, 1) && aim_gettlv(list2, 0x0005, 1)) {
535 struct aim_tlv_t *iptlv, *porttlv;
537 iptlv = aim_gettlv(list2, 0x0003, 1);
538 porttlv = aim_gettlv(list2, 0x0005, 1);
540 snprintf(ip, 30, "%d.%d.%d.%d:%d",
541 aimutil_get8(iptlv->value+0),
542 aimutil_get8(iptlv->value+1),
543 aimutil_get8(iptlv->value+2),
544 aimutil_get8(iptlv->value+3),
545 4443 /*aimutil_get16(porttlv->value)*/);
548 printf("faim: rend: directIM request from %s (%s)\n",
552 /* XXX: there are a couple of different request packets for
553 * different things */
555 priv = (struct aim_directim_priv *)calloc(1, sizeof(struct aim_directim_priv));
556 memcpy(priv->ip, ip, sizeof(priv->ip));
557 memcpy(priv->sn, userinfo.sn, sizeof(priv->sn));
558 memcpy(priv->cookie, cookie, sizeof(priv->cookie));
563 userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
564 if (userfunc || (i = 0))
571 } else if (reqclass & AIM_CAPS_CHAT) {
572 struct aim_tlv_t *miscinfo;
573 struct aim_chat_roominfo roominfo;
574 char *msg=NULL,*encoding=NULL,*lang=NULL;
576 miscinfo = aim_gettlv(list2, 0x2711, 1);
577 aim_chat_readroominfo(miscinfo->value, &roominfo);
579 if (aim_gettlv(list2, 0x000c, 1))
580 msg = aim_gettlv_str(list2, 0x000c, 1);
582 if (aim_gettlv(list2, 0x000d, 1))
583 encoding = aim_gettlv_str(list2, 0x000d, 1);
585 if (aim_gettlv(list2, 0x000e, 1))
586 lang = aim_gettlv_str(list2, 0x000e, 1);
591 userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
592 if (userfunc || (i = 0))
600 encoding?encoding+1:NULL,
606 } else if (reqclass & AIM_CAPS_GETFILE) {
608 struct aim_msgcookie_t *cachedcook;
609 struct aim_tlv_t *miscinfo;
611 if (!(cachedcook = calloc(1, sizeof(struct aim_msgcookie_t))))
616 if (!(miscinfo = aim_gettlv(list2, 0x2711, 1))) {
621 if (aim_gettlv(list2, 0x0003, 1) && aim_gettlv(list2, 0x0005, 1)) {
622 struct aim_tlv_t *iptlv, *porttlv;
624 if (!(iptlv = aim_gettlv(list2, 0x0003, 1)) || !(porttlv = aim_gettlv(list2, 0x0005, 1))) {
629 snprintf(ip, 30, "%d.%d.%d.%d:%d",
630 aimutil_get8(iptlv->value+0),
631 aimutil_get8(iptlv->value+1),
632 aimutil_get8(iptlv->value+2),
633 aimutil_get8(iptlv->value+3),
634 aimutil_get16(porttlv->value));
637 printf("faim: rend: file get request from %s (%s)\n", userinfo.sn, ip);
642 userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
643 if (userfunc || (i = 0))
652 } else if (reqclass & AIM_CAPS_SENDFILE) {
656 struct aim_msgcookie_t *cachedcook;
657 struct aim_filetransfer_priv *ft;
658 struct aim_tlv_t *miscinfo;
660 memset(ip, 0, sizeof(ip));
662 if (!(miscinfo = aim_gettlv(list2, 0x2711, 1)))
665 if (aim_gettlv(list2, 0x0003, 1) && aim_gettlv(list2, 0x0003, 1)) {
666 struct aim_tlv_t *iptlv, *porttlv;
668 iptlv = aim_gettlv(list2, 0x0003, 1);
669 porttlv = aim_gettlv(list2, 0x0005, 1);
671 snprintf(ip, sizeof(ip)-1, "%d.%d.%d.%d:%d",
672 aimutil_get8(iptlv->value+0),
673 aimutil_get8(iptlv->value+1),
674 aimutil_get8(iptlv->value+2),
675 aimutil_get8(iptlv->value+3),
676 aimutil_get16(porttlv->value));
679 if (aim_gettlv(list2, 0x000c, 1)) {
680 desc = aim_gettlv_str(list2, 0x000c, 1);
683 printf("faim: rend: file transfer request from %s for %s: %s (%s)\n",
689 memcpy(cachedcook->cookie, cookie, 8);
691 ft = malloc(sizeof(struct aim_filetransfer_priv));
692 strncpy(ft->sn, userinfo.sn, sizeof(ft->sn));
693 strncpy(ft->ip, ip, sizeof(ft->ip));
694 strncpy(ft->fh.name, miscinfo->value+8, sizeof(ft->fh.name));
695 cachedcook->type = AIM_COOKIETYPE_OFTSEND;
696 cachedcook->data = ft;
698 if (aim_cachecookie(sess, cachedcook) != 0)
699 printf("faim: ERROR caching message cookie\n");
702 aim_accepttransfer(sess, command->conn, ft->sn, cookie, AIM_CAPS_SENDFILE);
710 userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
711 if (userfunc || (i = 0))
718 printf("faim: rend: unknown rendezvous 0x%04x\n", reqclass);
721 aim_freetlvchain(&list2);
725 * Free up the TLV chain.
727 aim_freetlvchain(&tlvlist);
735 * AIM_TRANSFER_DENY_NOTSUPPORTED -- "client does not support"
736 * AIM_TRANSFER_DENY_DECLINE -- "client has declined transfer"
737 * AIM_TRANSFER_DENY_NOTACCEPTING -- "client is not accepting transfers"
740 faim_export unsigned long aim_denytransfer(struct aim_session_t *sess,
741 struct aim_conn_t *conn,
746 struct command_tx_struct *newpacket;
749 if(!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 10+8+2+1+strlen(sender)+6)))
754 curbyte = aim_putsnac(newpacket->data, 0x0004, 0x000b, 0x0000, sess->snac_nextid);
755 for (i = 0; i < 8; i++)
756 curbyte += aimutil_put8(newpacket->data+curbyte, cookie[i]);
757 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
758 curbyte += aimutil_put8(newpacket->data+curbyte, strlen(sender));
759 curbyte += aimutil_putstr(newpacket->data+curbyte, sender, strlen(sender));
760 curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x0003, code);
763 aim_tx_enqueue(sess, newpacket);
765 return (sess->snac_nextid++);
769 * Not real sure what this does, nor does anyone I've talk to.
771 * Didn't use to send it. But now I think it might be a good
775 faim_export unsigned long aim_seticbmparam(struct aim_session_t *sess,
776 struct aim_conn_t *conn)
778 struct command_tx_struct *newpacket;
781 if(!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 10+16)))
786 curbyte = aim_putsnac(newpacket->data, 0x0004, 0x0002, 0x0000, sess->snac_nextid);
787 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
788 curbyte += aimutil_put32(newpacket->data+curbyte, 0x00000003);
789 curbyte += aimutil_put8(newpacket->data+curbyte, 0x1f);
790 curbyte += aimutil_put8(newpacket->data+curbyte, 0x40);
791 curbyte += aimutil_put8(newpacket->data+curbyte, 0x03);
792 curbyte += aimutil_put8(newpacket->data+curbyte, 0xe7);
793 curbyte += aimutil_put8(newpacket->data+curbyte, 0x03);
794 curbyte += aimutil_put8(newpacket->data+curbyte, 0xe7);
795 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
796 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
799 aim_tx_enqueue(sess, newpacket);
801 return (sess->snac_nextid++);
804 faim_internal int aim_parse_msgerror_middle(struct aim_session_t *sess,
805 struct command_rx_struct *command)
807 u_long snacid = 0x000000000;
808 struct aim_snac_t *snac = NULL;
810 rxcallback_t userfunc = NULL;
812 unsigned short reason = 0;
815 * Get SNAC from packet and look it up
816 * the list of unrepliedto/outstanding
819 * After its looked up, the SN that the
820 * message should've gone to will be
821 * in the ->data element of the snac struct.
824 snacid = aimutil_get32(command->data+6);
825 snac = aim_remsnac(sess, snacid);
828 printf("faim: msgerr: got an ICBM-failed error on an unknown SNAC ID! (%08lx)\n", snacid);
833 reason = aimutil_get16(command->data+10);
838 userfunc = aim_callhandler(command->conn, 0x0004, 0x0001);
840 ret = userfunc(sess, command, dest, reason);
853 faim_internal int aim_parse_missedcall(struct aim_session_t *sess,
854 struct command_rx_struct *command)
857 rxcallback_t userfunc = NULL;
858 unsigned short channel, nummissed, reason;
859 struct aim_userinfo_s userinfo;
861 i = 10; /* Skip SNAC header */
865 * XXX: supposedly, this entire packet can repeat as many times
866 * as necessary. Should implement that.
872 channel = aimutil_get16(command->data+i);
876 * Extract the standard user info block.
878 i += aim_extractuserinfo(command->data+i, &userinfo);
880 nummissed = aimutil_get16(command->data+i);
883 reason = aimutil_get16(command->data+i);
889 userfunc = aim_callhandler(command->conn, 0x0004, 0x000a);
891 ret = userfunc(sess, command, channel, &userinfo, nummissed, reason);