From: mid Date: Tue, 11 Sep 2001 12:03:35 +0000 (+0000) Subject: - Tue Sep 11 04:42:28 PDT 2001 X-Git-Tag: rel_0_99_2~7 X-Git-Url: http://andersk.mit.edu/gitweb/libfaim.git/commitdiff_plain/603fdcaa0ebee8c92ec9f50d6d0610a70909fdcc - Tue Sep 11 04:42:28 PDT 2001 - Fix faim_internal/export confusion for the TLV functions - Add aim_addtlvtochain_userinfo() (used by AP) - Clean up ICBM Channel 1 parsing ever so slightly - Add multipart message support in both directions, and some fun examples of it in faimtest. - Yes, I'm insane. --- diff --git a/CHANGES b/CHANGES index d1bc81e..ae834f8 100644 --- a/CHANGES +++ b/CHANGES @@ -1,6 +1,14 @@ No release numbers ------------------ + - Tue Sep 11 04:42:28 PDT 2001 + - Fix faim_internal/export confusion for the TLV functions + - Add aim_addtlvtochain_userinfo() (used by AP) + - Clean up ICBM Channel 1 parsing ever so slightly + - Add multipart message support in both directions, and some + fun examples of it in faimtest. + - Yes, I'm insane. + - Mon Sep 10 06:15:43 PDT 2001 - Remove $Id line from md5.h. I really really hate those things. - Remove all that locking crap. It never worked right anyway. diff --git a/include/aim.h b/include/aim.h index 2bc4c34..32fa713 100644 --- a/include/aim.h +++ b/include/aim.h @@ -445,9 +445,10 @@ faim_internal int aim_addtlvtochain32(aim_tlvlist_t **list, const fu16_t type, c faim_internal int aim_addtlvtochain_raw(aim_tlvlist_t **list, const fu16_t t, const fu16_t l, const fu8_t *v); faim_internal int aim_addtlvtochain_caps(aim_tlvlist_t **list, const fu16_t t, const fu16_t caps); faim_internal int aim_addtlvtochain_noval(aim_tlvlist_t **list, const fu16_t type); +faim_internal int aim_addtlvtochain_userinfo(aim_tlvlist_t **list, fu16_t type, struct aim_userinfo_s *ui); faim_internal int aim_addtlvtochain_frozentlvlist(aim_tlvlist_t **list, fu16_t type, aim_tlvlist_t **tl); faim_internal int aim_counttlvchain(aim_tlvlist_t **list); -faim_export int aim_sizetlvchain(aim_tlvlist_t **list); +faim_internal int aim_sizetlvchain(aim_tlvlist_t **list); #endif /* FAIM_INTERNAL */ /* @@ -630,15 +631,50 @@ struct aim_chat_roominfo { #define AIM_IMFLAGS_SUBENC_MACINTOSH 0x0040 /* damn that Steve Jobs! */ #define AIM_IMFLAGS_CUSTOMFEATURES 0x0080 /* features field present */ #define AIM_IMFLAGS_EXTDATA 0x0100 +#define AIM_IMFLAGS_CUSTOMCHARSET 0x0200 /* charset fields set */ +#define AIM_IMFLAGS_MULTIPART 0x0400 /* ->mpmsg section valid */ +/* + * Multipart message structures. + */ +typedef struct aim_mpmsg_section_s { + fu16_t charset; + fu16_t charsubset; + fu8_t *data; + fu16_t datalen; + struct aim_mpmsg_section_s *next; +} aim_mpmsg_section_t; + +typedef struct aim_mpmsg_s { + int numparts; + aim_mpmsg_section_t *parts; +} aim_mpmsg_t; + +faim_export int aim_mpmsg_init(aim_session_t *sess, aim_mpmsg_t *mpm); +faim_export int aim_mpmsg_addraw(aim_session_t *sess, aim_mpmsg_t *mpm, fu16_t charset, fu16_t charsubset, const fu8_t *data, fu16_t datalen); +faim_export int aim_mpmsg_addascii(aim_session_t *sess, aim_mpmsg_t *mpm, const char *ascii); +faim_export int aim_mpmsg_addunicode(aim_session_t *sess, aim_mpmsg_t *mpm, const fu16_t *unicode, fu16_t unicodelen); +faim_export void aim_mpmsg_free(aim_session_t *sess, aim_mpmsg_t *mpm); + +/* + * Arguments to aim_send_im_ext(). + * + * This is really complicated. But immensely versatile. + * + */ struct aim_sendimext_args { /* These are _required_ */ const char *destsn; - fu32_t flags; + fu32_t flags; /* often 0 */ + + /* Only required if not using multipart messages */ const char *msg; int msglen; + /* Required if ->msg is not provided */ + aim_mpmsg_t *mpmsg; + /* Only used if AIM_IMFLAGS_HASICON is set */ fu32_t iconlen; time_t iconstamp; @@ -647,16 +683,34 @@ struct aim_sendimext_args { /* Only used if AIM_IMFLAGS_CUSTOMFEATURES is set */ fu8_t *features; fu8_t featureslen; + + /* Only used if AIM_IMFLAGS_CUSTOMCHARSET is set and mpmsg not used */ + fu16_t charset; + fu16_t charsubset; }; +/* + * This information is provided in the Incoming ICBM callback for + * Channel 1 ICBM's. + * + * Note that although CUSTOMFEATURES and CUSTOMCHARSET say they + * are optional, both are always set by the current libfaim code. + * That may or may not change in the future. It is mainly for + * consistency with aim_sendimext_args. + * + * Multipart messages require some explanation. If you want to use them, + * I suggest you read all the comments in im.c. + * + */ struct aim_incomingim_ch1_args { /* Always provided */ + aim_mpmsg_t mpmsg; + fu32_t icbmflags; /* some flags apply only to ->msg, not all mpmsg */ + + /* Only provided if message has a human-readable section */ char *msg; int msglen; - fu32_t icbmflags; - fu16_t flag1; - fu16_t flag2; /* Only provided if AIM_IMFLAGS_HASICON is set */ time_t iconstamp; @@ -670,6 +724,10 @@ struct aim_incomingim_ch1_args { /* Only provided if AIM_IMFLAGS_EXTDATA is set */ fu8_t extdatalen; fu8_t *extdata; + + /* Only used if AIM_IMFLAGS_CUSTOMCHARSET is set */ + fu16_t charset; + fu16_t charsubset; }; struct aim_incomingim_ch2_args { diff --git a/src/im.c b/src/im.c index a025bc1..d77474f 100644 --- a/src/im.c +++ b/src/im.c @@ -138,7 +138,8 @@ faim_export fu32_t aim_iconsum(const fu8_t *buf, int buflen) * supposed to be layed out. Most obviously, tlvlists should be used * instead of writing out the bytes manually. * - * XXX support multipart + * XXX more precise verification that we never send SNACs larger than 8192 + * XXX check SNAC size for multipart * */ faim_export int aim_send_im_ext(aim_session_t *sess, aim_conn_t *conn, struct aim_sendimext_args *args) @@ -153,19 +154,40 @@ faim_export int aim_send_im_ext(aim_session_t *sess, aim_conn_t *conn, struct ai if (!sess || !conn || !args) return -EINVAL; - if (!args->msg || (args->msglen <= 0)) - return -EINVAL; + if (args->flags & AIM_IMFLAGS_MULTIPART) { + if (args->mpmsg->numparts <= 0) + return -EINVAL; + } else { + if (!args->msg || (args->msglen <= 0)) + return -EINVAL; + + if (args->msglen >= MAXMSGLEN) + return -E2BIG; + } - if (args->msglen >= MAXMSGLEN) - return -E2BIG; + /* Painfully calculate the size of the message TLV */ + msgtlvlen = 1 + 1; /* 0501 */ - msgtlvlen = 12 + args->msglen; if (args->flags & AIM_IMFLAGS_CUSTOMFEATURES) - msgtlvlen += args->featureslen; + msgtlvlen += 2 + args->featureslen; else - msgtlvlen += sizeof(deffeatures); - - if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, args->msglen+512))) + msgtlvlen += 2 + sizeof(deffeatures); + + if (args->flags & AIM_IMFLAGS_MULTIPART) { + aim_mpmsg_section_t *sec; + + for (sec = args->mpmsg->parts; sec; sec = sec->next) { + msgtlvlen += 2 /* 0101 */ + 2 /* block len */; + msgtlvlen += 4 /* charset */ + sec->datalen; + } + + } else { + msgtlvlen += 2 /* 0101 */ + 2 /* block len */; + msgtlvlen += 4 /* charset */ + args->msglen; + } + + + if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, msgtlvlen+128))) return -ENOMEM; /* XXX should be optional */ @@ -216,29 +238,50 @@ faim_export int aim_send_im_ext(aim_session_t *sess, aim_conn_t *conn, struct ai aimbs_putraw(&fr->data, deffeatures, sizeof(deffeatures)); } - aimbs_put16(&fr->data, 0x0101); + if (args->flags & AIM_IMFLAGS_MULTIPART) { + aim_mpmsg_section_t *sec; - /* - * Message block length. - */ - aimbs_put16(&fr->data, args->msglen + 0x04); + for (sec = args->mpmsg->parts; sec; sec = sec->next) { + aimbs_put16(&fr->data, 0x0101); + aimbs_put16(&fr->data, sec->datalen + 4); + aimbs_put16(&fr->data, sec->charset); + aimbs_put16(&fr->data, sec->charsubset); + aimbs_putraw(&fr->data, sec->data, sec->datalen); + } - /* - * Character set. - */ - if (args->flags & AIM_IMFLAGS_UNICODE) - aimbs_put16(&fr->data, 0x0002); - else if (args->flags & AIM_IMFLAGS_ISO_8859_1) - aimbs_put16(&fr->data, 0x0003); - else - aimbs_put16(&fr->data, 0x0000); + } else { - aimbs_put16(&fr->data, 0x0000); + aimbs_put16(&fr->data, 0x0101); - /* - * Message. Not terminated. - */ - aimbs_putraw(&fr->data, args->msg, args->msglen); + /* + * Message block length. + */ + aimbs_put16(&fr->data, args->msglen + 0x04); + + /* + * Character set. + */ + if (args->flags & AIM_IMFLAGS_CUSTOMCHARSET) { + + aimbs_put16(&fr->data, args->charset); + aimbs_put16(&fr->data, args->charsubset); + + } else { + if (args->flags & AIM_IMFLAGS_UNICODE) + aimbs_put16(&fr->data, 0x0002); + else if (args->flags & AIM_IMFLAGS_ISO_8859_1) + aimbs_put16(&fr->data, 0x0003); + else + aimbs_put16(&fr->data, 0x0000); + + aimbs_put16(&fr->data, 0x0000); + } + + /* + * Message. Not terminated. + */ + aimbs_putraw(&fr->data, args->msg, args->msglen); + } /* * Set the Request Acknowledge flag. @@ -304,13 +347,13 @@ faim_export int aim_send_im(aim_session_t *sess, aim_conn_t *conn, const char *d args.msglen = strlen(msg); /* Make these don't get set by accident -- they need aim_send_im_ext */ - args.flags &= ~(AIM_IMFLAGS_CUSTOMFEATURES | AIM_IMFLAGS_HASICON); + args.flags &= ~(AIM_IMFLAGS_CUSTOMFEATURES | AIM_IMFLAGS_HASICON | AIM_IMFLAGS_MULTIPART); return aim_send_im_ext(sess, conn, &args); } /* - * This is also performance sensative. (If you can believe it...) + * This is also performance sensitive. (If you can believe it...) * */ faim_export int aim_send_icon(aim_session_t *sess, aim_conn_t *conn, const char *sn, const fu8_t *icon, int iconlen, time_t stamp, fu32_t iconsum) @@ -456,6 +499,277 @@ static int outgoingim(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, a return ret; } +/* + * Ahh, the joys of nearly ridiculous over-engineering. + * + * Not only do AIM ICBM's support multiple channels. Not only do they + * support multiple character sets. But they support multiple character + * sets / encodings within the same ICBM. + * + * These multipart messages allow for complex space savings techniques, which + * seem utterly unnecessary by today's standards. In fact, there is only + * one client still in popular use that still uses this method: AOL for the + * Macintosh, Version 5.0. Obscure, yes, I know. + * + * In modern (non-"legacy") clients, if the user tries to send a character + * that is not ISO-8859-1 or ASCII, the client will send the entire message + * as UNICODE, meaning that every character in the message will occupy the + * full 16 bit UNICODE field, even if the high order byte would be zero. + * Multipart messages prevent this wasted space by allowing the client to + * only send the characters in UNICODE that need to be sent that way, and + * the rest of the message can be sent in whatever the native character + * set is (probably ASCII). + * + * An important note is that sections will be displayed in the order that + * they appear in the ICBM. There is no facility for merging or rearranging + * sections at run time. So if you have, say, ASCII then UNICODE then ASCII, + * you must supply two ASCII sections with a UNICODE in the middle, and incur + * the associated overhead. + * + * Normally I would have laughed and given a firm 'no' to supporting this + * seldom-used feature, but something is attracting me to it. In the future, + * it may be possible to abuse this to send mixed-media messages to other + * open source clients (like encryption or something) -- see faimtest for + * examples of how to do this. + * + * I would definitly recommend avoiding this feature unless you really + * know what you are doing, and/or you have something neat to do with it. + * + */ +faim_export int aim_mpmsg_init(aim_session_t *sess, aim_mpmsg_t *mpm) +{ + + memset(mpm, 0, sizeof(aim_mpmsg_t)); + + return 0; +} + +static int mpmsg_addsection(aim_session_t *sess, aim_mpmsg_t *mpm, fu16_t charset, fu16_t charsubset, fu8_t *data, fu16_t datalen) +{ + aim_mpmsg_section_t *sec; + + if (!(sec = malloc(sizeof(aim_mpmsg_section_t)))) + return -1; + + sec->charset = charset; + sec->charsubset = charsubset; + sec->data = data; + sec->datalen = datalen; + sec->next = NULL; + + if (!mpm->parts) + mpm->parts = sec; + else { + aim_mpmsg_section_t *cur; + + for (cur = mpm->parts; cur->next; cur = cur->next) + ; + cur->next = sec; + } + + mpm->numparts++; + + return 0; +} + +faim_export int aim_mpmsg_addraw(aim_session_t *sess, aim_mpmsg_t *mpm, fu16_t charset, fu16_t charsubset, const fu8_t *data, fu16_t datalen) +{ + fu8_t *dup; + + if (!(dup = malloc(datalen))) + return -1; + memcpy(dup, data, datalen); + + if (mpmsg_addsection(sess, mpm, charset, charsubset, dup, datalen) == -1) { + free(dup); + return -1; + } + + return 0; +} + +/* XXX should provide a way of saying ISO-8859-1 specifically */ +faim_export int aim_mpmsg_addascii(aim_session_t *sess, aim_mpmsg_t *mpm, const char *ascii) +{ + fu8_t *dup; + + if (!(dup = strdup(ascii))) + return -1; + + if (mpmsg_addsection(sess, mpm, 0x0000, 0x0000, dup, strlen(ascii)) == -1) { + free(dup); + return -1; + } + + return 0; +} + +faim_export int aim_mpmsg_addunicode(aim_session_t *sess, aim_mpmsg_t *mpm, const fu16_t *unicode, fu16_t unicodelen) +{ + fu8_t *buf; + aim_bstream_t bs; + int i; + + if (!(buf = malloc(unicodelen * 2))) + return -1; + + aim_bstream_init(&bs, buf, unicodelen * 2); + + /* We assume unicode is in /host/ byte order -- convert to network */ + for (i = 0; i < unicodelen; i++) + aimbs_put16(&bs, unicode[i]); + + if (mpmsg_addsection(sess, mpm, 0x0002, 0x0000, buf, aim_bstream_curpos(&bs)) == -1) { + free(buf); + return -1; + } + + return 0; +} + +faim_export void aim_mpmsg_free(aim_session_t *sess, aim_mpmsg_t *mpm) +{ + aim_mpmsg_section_t *cur; + + for (cur = mpm->parts; cur; ) { + aim_mpmsg_section_t *tmp; + + tmp = cur->next; + free(cur->data); + free(cur); + cur = tmp; + } + + mpm->numparts = 0; + mpm->parts = NULL; + + return; +} + +/* + * Start by building the multipart structures, then pick the first + * human-readable section and stuff it into args->msg so no one gets + * suspicious. + * + */ +static int incomingim_ch1_parsemsgs(aim_session_t *sess, fu8_t *data, int len, struct aim_incomingim_ch1_args *args) +{ + static const fu16_t charsetpri[] = { + 0x0000, /* ASCII first */ + 0x0003, /* then ISO-8859-1 */ + 0x0002, /* UNICODE as last resort */ + }; + static const int charsetpricount = 3; + int i; + aim_bstream_t mbs; + aim_mpmsg_section_t *sec; + + aim_bstream_init(&mbs, data, len); + + while (aim_bstream_empty(&mbs)) { + fu16_t msglen, flag1, flag2; + fu8_t *msgbuf; + + aimbs_get8(&mbs); /* 01 */ + aimbs_get8(&mbs); /* 01 */ + + /* Message string length, including character set info. */ + msglen = aimbs_get16(&mbs); + + /* Character set info */ + flag1 = aimbs_get16(&mbs); + flag2 = aimbs_get16(&mbs); + + /* Message. */ + msglen -= 4; + + /* + * For now, we don't care what the encoding is. Just copy + * it into a multipart struct and deal with it later. However, + * always pad the ending with a NULL. This makes it easier + * to treat ASCII sections as strings. It won't matter for + * UNICODE or binary data, as you should never read past + * the specified data length, which will not include the pad. + * + * XXX There's an API bug here. For sending, the UNICODE is + * given in host byte order (aim_mpmsg_addunicode), but here + * the received messages are given in network byte order. + * + */ + msgbuf = aimbs_getstr(&mbs, msglen); + mpmsg_addsection(sess, &args->mpmsg, flag1, flag2, msgbuf, msglen); + + } /* while */ + + args->icbmflags |= AIM_IMFLAGS_MULTIPART; /* always set */ + + /* + * Clients that support multiparts should never use args->msg, as it + * will point to an arbitrary section. + * + * Here, we attempt to provide clients that do not support multipart + * messages with something to look at -- hopefully a human-readable + * string. But, failing that, a UNICODE message, or nothing at all. + * + * Which means that even if args->msg is NULL, it does not mean the + * message was blank. + * + */ + for (i = 0; i < charsetpricount; i++) { + for (sec = args->mpmsg.parts; sec; sec = sec->next) { + + if (sec->charset != charsetpri[i]) + continue; + + /* Great. We found one. Fill it in. */ + args->charset = sec->charset; + args->charsubset = sec->charsubset; + args->icbmflags |= AIM_IMFLAGS_CUSTOMCHARSET; + + /* Set up the simple flags */ + if (args->charset == 0x0000) + ; /* ASCII */ + else if (args->charset == 0x0002) + args->icbmflags |= AIM_IMFLAGS_UNICODE; + else if (args->charset == 0x0003) + args->icbmflags |= AIM_IMFLAGS_ISO_8859_1; + else if (args->charset == 0xffff) + ; /* no encoding (yeep!) */ + + if (args->charsubset == 0x0000) + ; /* standard subencoding? */ + else if (args->charsubset == 0x000b) + args->icbmflags |= AIM_IMFLAGS_SUBENC_MACINTOSH; + else if (args->charsubset == 0xffff) + ; /* no subencoding */ +#if 0 + /* XXX this isn't really necesary... */ + if ( ((args.flag1 != 0x0000) && + (args.flag1 != 0x0002) && + (args.flag1 != 0x0003) && + (args.flag1 != 0xffff)) || + ((args.flag2 != 0x0000) && + (args.flag2 != 0x000b) && + (args.flag2 != 0xffff))) { + faimdprintf(sess, 0, "icbm: **warning: encoding flags are being used! {%04x, %04x}\n", args.flag1, args.flag2); + } +#endif + + args->msg = sec->data; + args->msglen = sec->datalen; + + return 0; + } + } + + /* No human-readable sections found. Oh well. */ + args->charset = args->charsubset = 0xffff; + args->msg = NULL; + args->msglen = 0; + + return 0; +} + /* * * This should use tlvlists, but doesn't for performance reasons. @@ -490,6 +804,8 @@ static int incomingim_ch1(aim_session_t *sess, aim_module_t *mod, aim_frame_t *r memset(&args, 0, sizeof(args)); + aim_mpmsg_init(sess, &args.mpmsg); + /* * This used to be done using tlvchains. For performance reasons, * I've changed it to process the TLVs in-place. This avoids lots @@ -522,58 +838,11 @@ static int incomingim_ch1(aim_session_t *sess, aim_module_t *mod, aim_frame_t *r aim_bstream_advance(bs, args.featureslen); args.icbmflags |= AIM_IMFLAGS_CUSTOMFEATURES; - aimbs_get8(bs); /* 01 */ - aimbs_get8(bs); /* 01 */ - - /* Message string length, including flag words. */ - args.msglen = aimbs_get16(bs); - - /* Flag words. */ - args.flag1 = aimbs_get16(bs); - if (args.flag1 == 0x0000) - ; /* ASCII */ - else if (args.flag1 == 0x0002) - args.icbmflags |= AIM_IMFLAGS_UNICODE; - else if (args.flag1 == 0x0003) - args.icbmflags |= AIM_IMFLAGS_ISO_8859_1; - else if (args.flag1 == 0xffff) - ; /* no encoding (yeep!) */ - - args.flag2 = aimbs_get16(bs); - if (args.flag2 == 0x0000) - ; /* standard subencoding? */ - else if (args.flag2 == 0x000b) - args.icbmflags |= AIM_IMFLAGS_SUBENC_MACINTOSH; - else if (args.flag2 == 0xffff) - ; /* no subencoding */ - - /* XXX this isn't really necesary... */ - if ( ((args.flag1 != 0x0000) && - (args.flag1 != 0x0002) && - (args.flag1 != 0x0003) && - (args.flag1 != 0xffff)) || - ((args.flag2 != 0x0000) && - (args.flag2 != 0x000b) && - (args.flag2 != 0xffff))) { - faimdprintf(sess, 0, "icbm: **warning: encoding flags are being used! {%04x, %04x}\n", args.flag1, args.flag2); - } - - /* Message. */ - args.msglen -= 4; - if (args.icbmflags & AIM_IMFLAGS_UNICODE) { - fu8_t *umsg; - - /* Can't use getstr because of wide null */ - umsg = aimbs_getraw(bs, args.msglen); - args.msg = malloc(args.msglen+2); - memcpy(args.msg, umsg, args.msglen); - args.msg[args.msglen] = '\0'; /* wide NULL */ - args.msg[args.msglen+1] = '\0'; - - free(umsg); - - } else - args.msg = aimbs_getstr(bs, args.msglen); + /* + * The rest of the TLV contains one or more message + * blocks... + */ + incomingim_ch1_parsemsgs(sess, bs->data + bs->offset /* XXX evil!!! */, length - 2 - 2 - args.featureslen, &args); } else if (type == 0x0003) { /* Server Ack Requested */ @@ -618,8 +887,8 @@ static int incomingim_ch1(aim_session_t *sess, aim_module_t *mod, aim_frame_t *r if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) ret = userfunc(sess, rx, channel, userinfo, &args); + aim_mpmsg_free(sess, &args.mpmsg); free(args.extdata); - free(args.msg); return ret; } diff --git a/src/tlv.c b/src/tlv.c index e7d27ab..f751005 100644 --- a/src/tlv.c +++ b/src/tlv.c @@ -43,7 +43,7 @@ static void freetlv(aim_tlv_t **oldtlv) * in libfaim. * */ -faim_export aim_tlvlist_t *aim_readtlvchain(aim_bstream_t *bs) +faim_internal aim_tlvlist_t *aim_readtlvchain(aim_bstream_t *bs) { aim_tlvlist_t *list = NULL, *cur; fu16_t type, length; @@ -95,7 +95,7 @@ faim_export aim_tlvlist_t *aim_readtlvchain(aim_bstream_t *bs) * should be removed before calling this. * */ -faim_export void aim_freetlvchain(aim_tlvlist_t **list) +faim_internal void aim_freetlvchain(aim_tlvlist_t **list) { aim_tlvlist_t *cur; @@ -124,7 +124,7 @@ faim_export void aim_freetlvchain(aim_tlvlist_t **list) * Returns the number of TLVs stored in the passed chain. * */ -faim_export int aim_counttlvchain(aim_tlvlist_t **list) +faim_internal int aim_counttlvchain(aim_tlvlist_t **list) { aim_tlvlist_t *cur; int count; @@ -146,7 +146,7 @@ faim_export int aim_counttlvchain(aim_tlvlist_t **list) * write the passed TLV chain to a data buffer. * */ -faim_export int aim_sizetlvchain(aim_tlvlist_t **list) +faim_internal int aim_sizetlvchain(aim_tlvlist_t **list) { aim_tlvlist_t *cur; int size; @@ -171,7 +171,7 @@ faim_export int aim_sizetlvchain(aim_tlvlist_t **list) * to the TLV chain. * */ -faim_export int aim_addtlvtochain_raw(aim_tlvlist_t **list, const fu16_t t, const fu16_t l, const fu8_t *v) +faim_internal int aim_addtlvtochain_raw(aim_tlvlist_t **list, const fu16_t t, const fu16_t l, const fu8_t *v) { aim_tlvlist_t *newtlv, *cur; @@ -212,7 +212,7 @@ faim_export int aim_addtlvtochain_raw(aim_tlvlist_t **list, const fu16_t t, cons * Adds a two-byte unsigned integer to a TLV chain. * */ -faim_export int aim_addtlvtochain16(aim_tlvlist_t **list, const fu16_t t, const fu16_t v) +faim_internal int aim_addtlvtochain16(aim_tlvlist_t **list, const fu16_t t, const fu16_t v) { fu8_t v16[2]; @@ -230,7 +230,7 @@ faim_export int aim_addtlvtochain16(aim_tlvlist_t **list, const fu16_t t, const * Adds a four-byte unsigned integer to a TLV chain. * */ -faim_export int aim_addtlvtochain32(aim_tlvlist_t **list, const fu16_t t, const fu32_t v) +faim_internal int aim_addtlvtochain32(aim_tlvlist_t **list, const fu16_t t, const fu32_t v) { fu8_t v32[4]; @@ -261,7 +261,7 @@ faim_export int aim_addtlvtochain32(aim_tlvlist_t **list, const fu16_t t, const * %AIM_CAPS_SENDFILE Supports Send File functions * */ -faim_export int aim_addtlvtochain_caps(aim_tlvlist_t **list, const fu16_t t, const fu16_t caps) +faim_internal int aim_addtlvtochain_caps(aim_tlvlist_t **list, const fu16_t t, const fu16_t caps) { fu8_t buf[16*16]; /* icky fixed length buffer */ aim_bstream_t bs; @@ -273,6 +273,18 @@ faim_export int aim_addtlvtochain_caps(aim_tlvlist_t **list, const fu16_t t, con return aim_addtlvtochain_raw(list, t, aim_bstream_curpos(&bs), buf); } +faim_internal int aim_addtlvtochain_userinfo(aim_tlvlist_t **list, fu16_t type, struct aim_userinfo_s *ui) +{ + fu8_t buf[1024]; /* bleh */ + aim_bstream_t bs; + + aim_bstream_init(&bs, buf, sizeof(buf)); + + aim_putuserinfo(&bs, ui); + + return aim_addtlvtochain_raw(list, type, aim_bstream_curpos(&bs), buf); +} + /** * aim_addtlvtochain_noval - Add a blank TLV to a TLV chain * @list: Destination chain @@ -334,7 +346,7 @@ faim_internal int aim_addtlvtochain_frozentlvlist(aim_tlvlist_t **list, fu16_t t * * XXX clean this up, make better use of bstreams */ -faim_export int aim_writetlvchain(aim_bstream_t *bs, aim_tlvlist_t **list) +faim_internal int aim_writetlvchain(aim_bstream_t *bs, aim_tlvlist_t **list) { int goodbuflen; aim_tlvlist_t *cur; @@ -372,7 +384,7 @@ faim_export int aim_writetlvchain(aim_bstream_t *bs, aim_tlvlist_t **list) * in a chain. * */ -faim_export aim_tlv_t *aim_gettlv(aim_tlvlist_t *list, const fu16_t t, const int n) +faim_internal aim_tlv_t *aim_gettlv(aim_tlvlist_t *list, const fu16_t t, const int n) { aim_tlvlist_t *cur; int i; @@ -400,7 +412,7 @@ faim_export aim_tlv_t *aim_gettlv(aim_tlvlist_t *list, const fu16_t t, const int * dynamic buffer and must be freed by the caller. * */ -faim_export char *aim_gettlv_str(aim_tlvlist_t *list, const fu16_t t, const int n) +faim_internal char *aim_gettlv_str(aim_tlvlist_t *list, const fu16_t t, const int n) { aim_tlv_t *tlv; char *newstr; diff --git a/utils/faimtest/faimtest.c b/utils/faimtest/faimtest.c index f9ee277..6130f7c 100644 --- a/utils/faimtest/faimtest.c +++ b/utils/faimtest/faimtest.c @@ -995,6 +995,107 @@ static int faimtest_handlecmd(aim_session_t *sess, aim_conn_t *conn, struct aim_ aim_send_im_ext(sess, conn, &args); + } else if (strstr(tmpstr, "sendbin")) { + struct aim_sendimext_args args; + static const unsigned char data[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, + 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + }; + + /* + * I put this here as a demonstration of how to send + * arbitrary binary data via OSCAR ICBM's without the need + * for escape or baseN encoding of any sort. + * + * Apparently if you set the charset to something WinAIM + * doesn't recognize, it will completly ignore the message. + * That is, it will not display anything in the conversation + * window for the user that recieved it. + * + * HOWEVER, if they do not have a conversation window open + * for you, a new one will be created, but it will not have + * any messages in it. Therefore sending these things could + * be a great way to seemingly subliminally convince people + * to talk to you... + * + */ + args.destsn = userinfo->sn; + args.flags = AIM_IMFLAGS_CUSTOMCHARSET; + args.charset = args.charsubset = 0x4242; + args.msg = data; + args.msglen = sizeof(data); + + aim_send_im_ext(sess, conn, &args); + + } else if (strstr(tmpstr, "sendmulti")) { + struct aim_sendimext_args args; + aim_mpmsg_t mpm; + static const fu16_t unidata[] = { /* "UNICODE." */ + 0x0055, 0x004e, 0x0049, 0x0043, + 0x004f, 0x0044, 0x0045, 0x002e, + }; + static const int unidatalen = 8; + + /* + * This is how multipart messages should be sent. + * + * This should render as: + * "Part 1, ASCII. UNICODE.Part 3, ASCII. " + */ + + aim_mpmsg_init(sess, &mpm); + + aim_mpmsg_addascii(sess, &mpm, "Part 1, ASCII. "); + aim_mpmsg_addunicode(sess, &mpm, unidata, unidatalen); + aim_mpmsg_addascii(sess, &mpm, "Part 3, ASCII. "); + + args.destsn = userinfo->sn; + args.flags = AIM_IMFLAGS_MULTIPART; + args.mpmsg = &mpm; + + aim_send_im_ext(sess, conn, &args); + + aim_mpmsg_free(sess, &mpm); + + } else if (strstr(tmpstr, "sendprebin")) { + static const unsigned char data[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, + 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + }; + struct aim_sendimext_args args; + aim_mpmsg_t mpm; + + /* + * This demonstrates sending a human-readable preamble, + * and then arbitrary binary data. + * + * This means that you can very inconspicuously send binary + * attachments to other users. In WinAIM, this appears as + * though it only had the ASCII portion. + * + */ + + aim_mpmsg_init(sess, &mpm); + + aim_mpmsg_addascii(sess, &mpm, "This message has binary data."); + aim_mpmsg_addraw(sess, &mpm, 0x4242, 0x4242, data, sizeof(data)); + + args.destsn = userinfo->sn; + args.flags = AIM_IMFLAGS_MULTIPART; + args.mpmsg = &mpm; + + aim_send_im_ext(sess, conn, &args); + + aim_mpmsg_free(sess, &mpm); + } else if (strstr(tmpstr, "havefeat")) { struct aim_sendimext_args args; static const char featmsg[] = {"I have nifty features."}; @@ -1168,7 +1269,8 @@ static int faimtest_parse_incoming_im_chan1(aim_session_t *sess, aim_conn_t *con dinlineprintf("hasicon "); dinlineprintf("\n"); - dvprintf("faimtest: icbm: encoding flags = {%04x, %04x}\n", args->flag1, args->flag2); + if (args->icbmflags & AIM_IMFLAGS_CUSTOMCHARSET) + dvprintf("faimtest: icbm: encoding flags = {%04x, %04x}\n", args->charset, args->charsubset); /* * Quickly convert it to eight bit format, replacing non-ASCII UNICODE @@ -1220,6 +1322,21 @@ static int faimtest_parse_incoming_im_chan1(aim_session_t *sess, aim_conn_t *con dvprintf("faimtest: icbm: message: %s\n", realmsg); + if (args->icbmflags & AIM_IMFLAGS_MULTIPART) { + aim_mpmsg_section_t *sec; + int z; + + dvprintf("faimtest: icbm: multipart: this message has %d parts\n", args->mpmsg.numparts); + + for (sec = args->mpmsg.parts, z = 0; sec; sec = sec->next, z++) { + if ((sec->charset == 0x0000) || (sec->charset == 0x0003) || (sec->charset == 0xffff)) { + dvprintf("faimtest: icbm: multipart: part %d: charset 0x%04x, subset 0x%04x, msg = %s\n", z, sec->charset, sec->charsubset, sec->data); + } else { + dvprintf("faimtest: icbm: multipart: part %d: charset 0x%04x, subset 0x%04x, binary or UNICODE data\n", z, sec->charset, sec->charsubset); + } + } + } + if (args->icbmflags & AIM_IMFLAGS_HASICON) aim_send_im(sess, conn, userinfo->sn, AIM_IMFLAGS_BUDDYREQ, "You have an icon");