4 * The routines for sending/receiving Instant Messages.
11 * Send an ICBM (instant message).
15 * AIM_IMFLAGS_AWAY -- Marks the message as an autoresponse
16 * AIM_IMFLAGS_ACK -- Requests that the server send an ack
17 * when the message is received (of type 0x0004/0x000c)
20 faim_export unsigned long aim_send_im(struct aim_session_t *sess,
21 struct aim_conn_t *conn,
22 char *destsn, u_int flags, char *msg)
26 struct command_tx_struct *newpacket;
28 if (strlen(msg) >= MAXMSGLEN)
31 if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, strlen(msg)+256)))
34 newpacket->lock = 1; /* lock struct */
37 curbyte += aim_putsnac(newpacket->data+curbyte,
38 0x0004, 0x0006, 0x0000, sess->snac_nextid);
41 * Generate a random message cookie
43 * We could cache these like we do SNAC IDs. (In fact, it
44 * might be a good idea.) In the message error functions,
45 * the 8byte message cookie is returned as well as the
50 curbyte += aimutil_put8(newpacket->data+curbyte, (u_char) rand());
55 curbyte += aimutil_put16(newpacket->data+curbyte,0x0001);
58 * Destination SN (prepended with byte length)
60 curbyte += aimutil_put8(newpacket->data+curbyte,strlen(destsn));
61 curbyte += aimutil_putstr(newpacket->data+curbyte, destsn, strlen(destsn));
66 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
67 curbyte += aimutil_put16(newpacket->data+curbyte, strlen(msg) + 0x10);
70 * Flag data / ICBM Parameters?
72 curbyte += aimutil_put8(newpacket->data+curbyte, 0x05);
73 curbyte += aimutil_put8(newpacket->data+curbyte, 0x01);
75 /* number of bytes to follow */
76 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0004);
77 curbyte += aimutil_put8(newpacket->data+curbyte, 0x01);
78 curbyte += aimutil_put8(newpacket->data+curbyte, 0x01);
79 curbyte += aimutil_put8(newpacket->data+curbyte, 0x01);
80 curbyte += aimutil_put8(newpacket->data+curbyte, 0x02);
82 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0101);
85 * Message block length.
87 curbyte += aimutil_put16(newpacket->data+curbyte, strlen(msg) + 0x04);
92 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
93 curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
96 * Message. Not terminated.
98 curbyte += aimutil_putstr(newpacket->data+curbyte,msg, strlen(msg));
101 * Set the Request Acknowledge flag.
103 if (flags & AIM_IMFLAGS_ACK) {
104 curbyte += aimutil_put16(newpacket->data+curbyte,0x0003);
105 curbyte += aimutil_put16(newpacket->data+curbyte,0x0000);
109 * Set the Autoresponse flag.
111 if (flags & AIM_IMFLAGS_AWAY) {
112 curbyte += aimutil_put16(newpacket->data+curbyte,0x0004);
113 curbyte += aimutil_put16(newpacket->data+curbyte,0x0000);
116 newpacket->commandlen = curbyte;
119 aim_tx_enqueue(sess, newpacket);
121 aim_cachesnac(sess, 0x0004, 0x0006, 0x0000, destsn, strlen(destsn)+1);
122 aim_cleansnacs(sess, 60); /* clean out all SNACs over 60sec old */
124 return sess->snac_nextid;
127 faim_internal int aim_parse_outgoing_im_middle(struct aim_session_t *sess,
128 struct command_rx_struct *command)
130 unsigned int i = 0, z;
131 rxcallback_t userfunc = NULL;
132 unsigned char cookie[8];
134 struct aim_tlvlist_t *tlvlist;
136 unsigned short icbmflags = 0;
137 unsigned char flag1 = 0, flag2 = 0;
138 unsigned char *msgblock = NULL, *msg = NULL;
143 for (z=0; z<8; z++,i++)
144 cookie[z] = command->data[i];
147 channel = aimutil_get16(command->data+i);
150 if (channel != 0x01) {
151 printf("faim: icbm: ICBM recieved on unsupported channel. Ignoring. (chan = %04x)\n", channel);
155 strncpy(sn, (char *) command->data+i+1, (int) *(command->data+i));
156 i += 1 + (int) *(command->data+i);
158 tlvlist = aim_readtlvchain(command->data+i, command->commandlen-i);
160 if (aim_gettlv(tlvlist, 0x0003, 1))
161 icbmflags |= AIM_IMFLAGS_ACK;
162 if (aim_gettlv(tlvlist, 0x0004, 1))
163 icbmflags |= AIM_IMFLAGS_AWAY;
165 if (aim_gettlv(tlvlist, 0x0002, 1)) {
168 msgblock = (unsigned char *)aim_gettlv_str(tlvlist, 0x0002, 1);
170 /* no, this really is correct. I'm not high or anything either. */
172 j += 2 + aimutil_get16(msgblock+j);
175 j += 2; /* final block length */
177 flag1 = aimutil_get16(msgblock);
179 flag2 = aimutil_get16(msgblock);
185 if ((userfunc = aim_callhandler(command->conn, 0x0004, 0x0006)) || (i = 0))
186 i = userfunc(sess, command, channel, sn, msg, icbmflags, flag1, flag2);
190 aim_freetlvchain(&tlvlist);
196 * It can easily be said that parsing ICBMs is THE single
197 * most difficult thing to do in the in AIM protocol. In
198 * fact, I think I just did say that.
200 * Below is the best damned solution I've come up with
201 * over the past sixteen months of battling with it. This
202 * can parse both away and normal messages from every client
203 * I have access to. Its not fast, its not clean. But it works.
205 * We should also support at least minimal parsing of
206 * Channel 2, so that we can at least know the name of the
207 * room we're invited to, but obviously can't attend...
210 faim_internal int aim_parse_incoming_im_middle(struct aim_session_t *sess,
211 struct command_rx_struct *command)
214 rxcallback_t userfunc = NULL;
217 struct aim_tlvlist_t *tlvlist;
218 struct aim_userinfo_s userinfo;
221 memset(&userinfo, 0x00, sizeof(struct aim_userinfo_s));
223 i = 10; /* Skip SNAC header */
226 * Read ICBM Cookie. And throw away.
228 for (z=0; z<8; z++,i++)
229 cookie[z] = command->data[i];
234 * Channel 0x0001 is the message channel. There are
235 * other channels for things called "rendevous"
236 * which represent chat and some of the other new
237 * features of AIM2/3/3.5.
239 * Channel 0x0002 is the Rendevous channel, which
240 * is where Chat Invitiations and various client-client
241 * connection negotiations come from.
244 channel = aimutil_get16(command->data+i);
250 if ((channel != 0x01) && (channel != 0x02))
252 printf("faim: icbm: ICBM received on an unsupported channel. Ignoring.\n (chan = %04x)", channel);
257 * Extract the standard user info block.
259 * Note that although this contains TLVs that appear contiguous
260 * with the TLVs read below, they are two different pieces. The
261 * userinfo block contains the number of TLVs that contain user
262 * information, the rest are not even though there is no seperation.
263 * aim_extractuserinfo() returns the number of bytes used by the
264 * userinfo tlvs, so you can start reading the rest of them right
267 * That also means that TLV types can be duplicated between the
268 * userinfo block and the rest of the message, however there should
269 * never be two TLVs of the same type in one block.
272 i += aim_extractuserinfo(command->data+i, &userinfo);
275 * Read block of TLVs (not including the userinfo data). All
276 * further data is derived from what is parsed here.
278 tlvlist = aim_readtlvchain(command->data+i, command->commandlen-i);
281 * From here on, its depends on what channel we're on.
285 u_int j = 0, y = 0, z = 0;
288 struct aim_tlv_t *msgblocktlv;
293 * Check Autoresponse status. If it is an autoresponse,
294 * it will contain a type 0x0004 TLV, with zero length.
296 if (aim_gettlv(tlvlist, 0x0004, 1))
297 icbmflags |= AIM_IMFLAGS_AWAY;
300 * Check Ack Request status.
302 if (aim_gettlv(tlvlist, 0x0003, 1))
303 icbmflags |= AIM_IMFLAGS_ACK;
308 msgblocktlv = aim_gettlv(tlvlist, 0x0002, 1);
309 if (!msgblocktlv || !msgblocktlv->value) {
310 printf("faim: icbm: major error! no message block TLV found!\n");
311 aim_freetlvchain(&tlvlist);
316 * Extracting the message from the unknown cruft.
318 * This is a bit messy, and I'm not really qualified,
319 * even as the author, to comment on it. At least
320 * its not as bad as a while loop shooting into infinity.
322 * "Do you believe in magic?"
325 msgblock = msgblocktlv->value;
328 wastebits = aimutil_get8(msgblock+j++);
329 wastebits = aimutil_get8(msgblock+j++);
331 y = aimutil_get16(msgblock+j);
333 for (z = 0; z < y; z++)
334 wastebits = aimutil_get8(msgblock+j++);
335 wastebits = aimutil_get8(msgblock+j++);
336 wastebits = aimutil_get8(msgblock+j++);
339 * Message string length, including flag words.
341 i = aimutil_get16(msgblock+j);
347 * Its rumored that these can kick in some funky
348 * 16bit-wide char stuff that used to really kill
349 * libfaim. Hopefully the latter is no longer true.
351 * Though someone should investiagte the former.
354 flag1 = aimutil_get16(msgblock+j);
356 flag2 = aimutil_get16(msgblock+j);
360 printf("faim: icbm: **warning: encoding flags are being used! {%04x, %04x}\n", flag1, flag2);
366 msg = (char *)malloc(i+1);
367 memcpy(msg, msgblock+j, i);
373 userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
375 i = userfunc(sess, command, channel, &userinfo, msg, icbmflags, flag1, flag2);
381 else if (channel == 0x0002)
383 struct aim_tlv_t *block1;
384 struct aim_tlvlist_t *list2;
385 unsigned short reqclass = 0;
386 unsigned short status = 0;
389 * There's another block of TLVs embedded in the type 5 here.
391 block1 = aim_gettlv(tlvlist, 0x0005, 1);
393 printf("faim: no tlv 0x0005 in rendezvous transaction!\n");
394 aim_freetlvchain(&tlvlist);
395 return 1; /* major problem */
399 * First two bytes represent the status of the connection.
401 * 0 is a request, 2 is an accept
403 status = aimutil_get16(block1->value+0);
406 * Next comes the cookie. Should match the ICBM cookie.
408 if (memcmp(block1->value+2, cookie, 8) != 0)
409 printf("faim: rend: warning cookies don't match!\n");
412 * The next 16bytes are a capability block so we can
413 * identify what type of rendezvous this is.
415 * Thanks to Eric Warmenhoven <warmenhoven@linux.com> (of GAIM)
416 * for pointing some of this out to me. In fact, a lot of
417 * the client-to-client info comes from the work of the GAIM
418 * developers. Thanks!
420 * Read off one capability string and we should have it ID'd.
423 reqclass = aim_getcap(block1->value+2+8, 0x10);
424 if (reqclass == 0x0000) {
425 printf("faim: rend: no ID block\n");
426 aim_freetlvchain(&tlvlist);
431 * What follows may be TLVs or nothing, depending on the
432 * purpose of the message.
434 * Ack packets for instance have nothing more to them.
436 list2 = aim_readtlvchain(block1->value+2+8+16, block1->length-2-8-16);
438 if (!list2 || ((reqclass != AIM_CAPS_IMIMAGE) && !(aim_gettlv(list2, 0x2711, 1)))) {
439 struct aim_msgcookie_t *cook;
442 type = aim_msgcookie_gettype(reqclass); /* XXX: fix this shitty code */
444 if ((cook = aim_uncachecookie(sess, cookie, type)) == NULL) {
445 printf("faim: non-data rendezvous thats not in cache!\n");
446 aim_freetlvchain(&list2);
447 aim_freetlvchain(&tlvlist);
451 if (cook->type == AIM_CAPS_SENDFILE) {
452 struct aim_filetransfer_priv *ft;
455 int errorcode = -1; /* XXX shouldnt this be 0? */
457 ft = (struct aim_filetransfer_priv *)cook->data;
459 if (aim_gettlv(list2, 0x000b, 1))
460 errorcode = aim_gettlv16(list2, 0x000b, 1);
463 printf("faim: transfer from %s (%s) for %s cancelled (error code %d)\n", ft->sn, ft->ip, ft->fh.name, errorcode);
464 } else if (status == 0x0002) { /* connection accepted */
465 printf("faim: transfer from %s (%s) for %s accepted\n", ft->sn, ft->ip, ft->fh.name);
469 printf("faim: not data attached to file transfer\n");
471 } else if (cook->type == AIM_CAPS_VOICE) {
472 printf("faim: voice request cancelled\n");
474 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);