Changeset cf02dd6 for libfaim

Timestamp:

Dec 10, 2003, 3:20:45 PM (23 years ago)

Author:

James M. Kretchmar <kretch@mit.edu>

Branches:

master, barnowl_perlaim, debian, owl, release-1.10, release-1.4, release-1.5, release-1.6, release-1.7, release-1.8, release-1.9

Children:

b1fe407

Parents:

8c46404

Message:

*** empty log message ***

Location:

libfaim

Files:

• Makefile.in (modified) (1 diff)
• admin.c (modified) (4 diffs)
• aim.h (modified) (24 diffs)
• aim_cbtypes.h (modified) (1 diff)
• aim_internal.h (modified) (5 diffs)
• auth.c (modified) (15 diffs)
• bos.c (modified) (2 diffs)
• buddylist.c (modified) (10 diffs)
• chat.c (modified) (20 diffs)
• chatnav.c (modified) (25 diffs)
• conn.c (modified) (9 diffs)
• email.c (modified) (5 diffs)
• ft.c (modified) (1 diff)
• icq.c (modified) (3 diffs)
• im.c (modified) (28 diffs)
• info.c (deleted)
• meta.c (deleted)
• misc.c (modified) (1 diff)
• newsearch.c (deleted)
• odir.c (modified) (4 diffs)
• oscar.c (modified) (214 diffs)
• popups.c (modified) (1 diff)
• rxhandlers.c (modified) (1 diff)
• search.c (modified) (2 diffs)
• service.c (modified) (16 diffs)
• ssi.c (modified) (49 diffs)
• tlv.c (modified) (38 diffs)
• txqueue.c (modified) (4 diffs)

libfaim/Makefile.in

@@ -5 +5 @@
 OBJS=admin.o adverts.o auth.o bos.o buddylist.o bstream.o \
      chat.o chatnav.o conn.o email.o ft.o icq.o im.o \
-     info.o invite.o md5.o meta.o misc.o msgcookie.o newsearch.o \
+     invite.o md5.o misc.o msgcookie.o locate.o \
      popups.o rxhandlers.o rxqueue.o search.o service.o \
      snac.o ssi.o stats.o tlv.o translate.o txqueue.o \
-     util.o
+     util.o odir.o bart.o
 CFLAGS=@CFLAGS@ -I. -DAIM_BUILDDATE=\"x\" -DAIM_BUILDTIME=\"x\"
 

libfaim/admin.c

@@ -111 +111 @@
         aim_putsnac(&fr->data, 0x0007, 0x0004, 0x0000, snacid);
 
-        aim_addtlvtochain_raw(&tl, 0x0001, strlen(newnick), newnick);
-        
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_add_raw(&tl, 0x0001, strlen(newnick), newnick);
+        
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
         
         aim_tx_enqueue(sess, fr);
@@ -139 +139 @@
 
         /* new password TLV t(0002) */
-        aim_addtlvtochain_raw(&tl, 0x0002, strlen(newpw), newpw);
+        aim_tlvlist_add_raw(&tl, 0x0002, strlen(newpw), newpw);
 
         /* current password TLV t(0012) */
-        aim_addtlvtochain_raw(&tl, 0x0012, strlen(curpw), curpw);
-
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_add_raw(&tl, 0x0012, strlen(curpw), curpw);
+
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
 
         aim_tx_enqueue(sess, fr);
@@ -168 +168 @@
         aim_putsnac(&fr->data, 0x0007, 0x0004, 0x0000, snacid);
 
-        aim_addtlvtochain_raw(&tl, 0x0011, strlen(newemail), newemail);
-        
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_add_raw(&tl, 0x0011, strlen(newemail), newemail);
+        
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
         
         aim_tx_enqueue(sess, fr);
@@ -205 +205 @@
         /* This is 0x0013 if unable to confirm at this time */
 
-        tl = aim_readtlvchain(bs);
+        tl = aim_tlvlist_read(bs);
 
         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))

libfaim/aim.h

@@ -78 +78 @@
 #ifndef TRUE
 #define TRUE (!FALSE)
+#endif
+
+#ifndef bool
+#define bool fu8_t
 #endif
 
@@ -206 +210 @@
 }
 
+#define CLIENTINFO_AIM_5_5_3415 { \
+        "AOL Instant Messenger, version 5.5.3415/WIN32", \
+        0x0109, \
+        0x0005, 0x0005, \
+        0x0000, 0x0057, \
+        0x000000ef, \
+        "us", "en", \
+}
+
 #define CLIENTINFO_ICHAT_1_0 { \
         "Apple iChat", \
@@ -244 +257 @@
 }
 
-#define CLIENTINFO_ICQBasic_14_3_1068 { \
+#define CLIENTINFO_ICQBASIC_14_3_1068 { \
         "ICQBasic", \
         0x010a, \
@@ -253 +266 @@
 }
 
-#define CLIENTINFO_Netscape_7_0_1 { \
+#define CLIENTINFO_NETSCAPE_7_0_1 { \
         "Netscape 2000 an approved user of AOL Instant Messenger (SM)", \
         0x1d0d, \
@@ -366 +379 @@
 } aim_msgcookie_t;
 
-/* Values for sess->flags */
-#define AIM_SESS_FLAGS_SNACLOGIN         0x00000001
-#define AIM_SESS_FLAGS_XORLOGIN          0x00000002
-#define AIM_SESS_FLAGS_NONBLOCKCONNECT   0x00000004
-#define AIM_SESS_FLAGS_DONTTIMEOUTONICBM 0x00000008
-
 /*
  * AIM Session: The main client-data interface.  
@@ -427 +434 @@
         } socksproxy;
 
-        fu32_t flags; /* AIM_SESS_FLAGS_ */
+        bool nonblocking;
 
         int debug;
@@ -445 +452 @@
         struct aim_authresp_info *authinfo;
         struct aim_emailinfo *emailinfo;
+
+        struct {
+                struct aim_userinfo_s *userinfo;
+                struct userinfo_node *torequest;
+                struct userinfo_node *requested;
+                int waiting_for_response;
+        } locate;
 
         /* Server-stored information (ssi) */
@@ -475 +489 @@
 
 
+
 /*
  * Get command from connections
@@ -540 +555 @@
 faim_export int aim_request_login(aim_session_t *sess, aim_conn_t *conn, const char *sn);
 faim_export int aim_send_login(aim_session_t *, aim_conn_t *, const char *, const char *, struct client_info_s *, const char *key);
-faim_export int aim_encode_password_md5(const char *password, const char *key, fu8_t *digest);
 faim_export void aim_purge_rxqueue(aim_session_t *);
 faim_export void aim_cleansnacs(aim_session_t *, int maxage);
@@ -571 +585 @@
 typedef void (*faim_debugging_callback_t)(aim_session_t *sess, int level, const char *format, va_list va);
 faim_export int aim_setdebuggingcb(aim_session_t *sess, faim_debugging_callback_t);
-faim_export void aim_session_init(aim_session_t *, fu32_t flags, int debuglevel);
+faim_export void aim_session_init(aim_session_t *, bool nonblocking, int debuglevel);
 faim_export void aim_session_kill(aim_session_t *);
 faim_export void aim_setupproxy(aim_session_t *sess, const char *server, const char *username, const char *password);
@@ -580 +594 @@
 
 
-/* service.c */
+/* 0x0001 - service.c */
 faim_export int aim_srv_setavailmsg(aim_session_t *sess, char *msg);
+faim_export int aim_srv_setidle(aim_session_t *sess, fu32_t idletime);
 
 
@@ -600 +615 @@
 faim_export int aim_nop(aim_session_t *, aim_conn_t *);
 faim_export int aim_flap_nop(aim_session_t *sess, aim_conn_t *conn);
-faim_export int aim_bos_setidle(aim_session_t *, aim_conn_t *, fu32_t);
 faim_export int aim_bos_changevisibility(aim_session_t *, aim_conn_t *, int, const char *);
-faim_export int aim_bos_setbuddylist(aim_session_t *, aim_conn_t *, const char *);
-faim_export int aim_bos_setprofile(aim_session_t *sess, aim_conn_t *conn, const char *profile_encoding, const char *profile, const int profile_len, const char *awaymsg_encoding, const char *awaymsg, const int awaymsg_len, fu32_t caps);
 faim_export int aim_bos_setgroupperm(aim_session_t *, aim_conn_t *, fu32_t mask);
 faim_export int aim_bos_setprivacyflags(aim_session_t *, aim_conn_t *, fu32_t);
@@ -609 +621 @@
 faim_export int aim_reqservice(aim_session_t *, aim_conn_t *, fu16_t);
 faim_export int aim_bos_reqrights(aim_session_t *, aim_conn_t *);
-faim_export int aim_bos_reqbuddyrights(aim_session_t *, aim_conn_t *);
-faim_export int aim_bos_reqlocaterights(aim_session_t *, aim_conn_t *);
-faim_export int aim_setdirectoryinfo(aim_session_t *sess, aim_conn_t *conn, const char *first, const char *middle, const char *last, const char *maiden, const char *nickname, const char *street, const char *city, const char *state, const char *zip, int country, fu16_t privacy);
-faim_export int aim_setuserinterests(aim_session_t *sess, aim_conn_t *conn, const char *interest1, const char *interest2, const char *interest3, const char *interest4, const char *interest5, fu16_t privacy);
 faim_export int aim_setextstatus(aim_session_t *sess, fu32_t status);
 
@@ -936 +944 @@
 
 
-/* info.c */
+/* 0x0002 - locate.c */
 /*
  * AIM User Info, Standard Form.
  */
-#define AIM_FLAG_UNCONFIRMED    0x0001 /* "damned transients" */
+#define AIM_FLAG_UNCONFIRMED    0x0001 /* "damned transients" */
 #define AIM_FLAG_ADMINISTRATOR  0x0002
-#define AIM_FLAG_AOL            0x0004
-#define AIM_FLAG_OSCAR_PAY      0x0008
-#define AIM_FLAG_FREE           0x0010
-#define AIM_FLAG_AWAY           0x0020
-#define AIM_FLAG_ICQ            0x0040
-#define AIM_FLAG_WIRELESS       0x0080
-#define AIM_FLAG_UNKNOWN100     0x0100
-#define AIM_FLAG_UNKNOWN200     0x0200
-#define AIM_FLAG_ACTIVEBUDDY    0x0400
-#define AIM_FLAG_UNKNOWN800     0x0800
-#define AIM_FLAG_ABINTERNAL     0x1000
-#define AIM_FLAG_ALLUSERS       0x001f
+#define AIM_FLAG_AOL                    0x0004
+#define AIM_FLAG_OSCAR_PAY              0x0008
+#define AIM_FLAG_FREE                   0x0010
+#define AIM_FLAG_AWAY                   0x0020
+#define AIM_FLAG_ICQ                    0x0040
+#define AIM_FLAG_WIRELESS               0x0080
+#define AIM_FLAG_UNKNOWN100             0x0100
+#define AIM_FLAG_UNKNOWN200             0x0200
+#define AIM_FLAG_ACTIVEBUDDY    0x0400
+#define AIM_FLAG_UNKNOWN800             0x0800
+#define AIM_FLAG_ABINTERNAL             0x1000
+#define AIM_FLAG_ALLUSERS               0x001f
 
 #define AIM_USERINFO_PRESENT_FLAGS        0x00000001
@@ -966 +974 @@
 #define AIM_USERINFO_PRESENT_CREATETIME   0x00000200
 
-typedef struct {
-        char sn[MAXSNLEN+1];
+struct userinfo_node {
+        char *sn;
+        struct userinfo_node *next;
+};
+
+typedef struct aim_userinfo_s {
+        char *sn;
         fu16_t warnlevel; /* evil percent * 10 (999 = 99.9%) */
         fu16_t idletime; /* in seconds */
@@ -982 +995 @@
         } icqinfo;
         fu32_t present;
+
         fu16_t iconcsumlen;
         fu8_t *iconcsum;
-        char *availmsg_encoding;
-        char *availmsg;
-        int availmsg_len;
+
+        char *info;
+        char *info_encoding;
+        fu16_t info_len;
+
+        char *avail;
+        char *avail_encoding;
+        fu16_t avail_len;
+
+        char *away;
+        char *away_encoding;
+        fu16_t away_len;
+
+        struct aim_userinfo_s *next;
 } aim_userinfo_t;
 
-faim_export const char *aim_userinfo_sn(aim_userinfo_t *ui);
-faim_export fu16_t aim_userinfo_flags(aim_userinfo_t *ui);
-faim_export fu16_t aim_userinfo_idle(aim_userinfo_t *ui);
-faim_export float aim_userinfo_warnlevel(aim_userinfo_t *ui);
-faim_export time_t aim_userinfo_createtime(aim_userinfo_t *ui);
-faim_export time_t aim_userinfo_membersince(aim_userinfo_t *ui);
-faim_export time_t aim_userinfo_onlinesince(aim_userinfo_t *ui);
-faim_export fu32_t aim_userinfo_sessionlen(aim_userinfo_t *ui);
-faim_export int aim_userinfo_hascap(aim_userinfo_t *ui, fu32_t cap);
-
-#define AIM_CAPS_BUDDYICON      0x00000001
-#define AIM_CAPS_VOICE          0x00000002
-#define AIM_CAPS_DIRECTIM       0x00000004
-#define AIM_CAPS_CHAT           0x00000008
-#define AIM_CAPS_GETFILE        0x00000010
-#define AIM_CAPS_SENDFILE       0x00000020
-#define AIM_CAPS_GAMES          0x00000040
-#define AIM_CAPS_SAVESTOCKS     0x00000080
+#define AIM_CAPS_BUDDYICON              0x00000001
+#define AIM_CAPS_VOICE                  0x00000002
+#define AIM_CAPS_DIRECTIM               0x00000004
+#define AIM_CAPS_CHAT                   0x00000008
+#define AIM_CAPS_GETFILE                0x00000010
+#define AIM_CAPS_SENDFILE               0x00000020
+#define AIM_CAPS_GAMES                  0x00000040
+#define AIM_CAPS_SAVESTOCKS             0x00000080
 #define AIM_CAPS_SENDBUDDYLIST  0x00000100
-#define AIM_CAPS_GAMES2         0x00000200
-#define AIM_CAPS_ICQ            0x00000400
-#define AIM_CAPS_APINFO         0x00000800
-#define AIM_CAPS_ICQRTF         0x00001000
-#define AIM_CAPS_EMPTY          0x00002000
+#define AIM_CAPS_GAMES2                 0x00000200
+#define AIM_CAPS_ICQ_DIRECT             0x00000400
+#define AIM_CAPS_APINFO                 0x00000800
+#define AIM_CAPS_ICQRTF                 0x00001000
+#define AIM_CAPS_EMPTY                  0x00002000
 #define AIM_CAPS_ICQSERVERRELAY 0x00004000
-#define AIM_CAPS_ICQUTF8OLD     0x00008000
+#define AIM_CAPS_ICQUTF8OLD             0x00008000
 #define AIM_CAPS_TRILLIANCRYPT  0x00010000
-#define AIM_CAPS_ICQUTF8        0x00020000
+#define AIM_CAPS_ICQUTF8                0x00020000
 #define AIM_CAPS_INTEROPERATE   0x00040000
-#define AIM_CAPS_ICHAT          0x00080000
-#define AIM_CAPS_HIPTOP         0x00100000
-#define AIM_CAPS_SECUREIM       0x00200000
-#define AIM_CAPS_LAST           0x00400000
-
-faim_export int aim_0002_000b(aim_session_t *sess, aim_conn_t *conn, const char *sn);
+#define AIM_CAPS_ICHAT                  0x00080000
+#define AIM_CAPS_HIPTOP                 0x00100000
+#define AIM_CAPS_SECUREIM               0x00200000
+#define AIM_CAPS_SMS                    0x00400000
+#define AIM_CAPS_GENERICUNKNOWN 0x00800000
+#define AIM_CAPS_VIDEO                  0x01000000
+#define AIM_CAPS_LAST                   0x02000000
 
 #define AIM_SENDMEMBLOCK_FLAG_ISREQUEST  0
@@ -1029 +1045 @@
 
 faim_export int aim_sendmemblock(aim_session_t *sess, aim_conn_t *conn, fu32_t offset, fu32_t len, const fu8_t *buf, fu8_t flag);
-
-#define AIM_GETINFO_GENERALINFO 0x00001
-#define AIM_GETINFO_AWAYMESSAGE 0x00003
-#define AIM_GETINFO_CAPABILITIES 0x0004
 
 struct aim_invite_priv {
@@ -1058 +1070 @@
 #define AIM_COOKIETYPE_OFTICON  0x15
 
-/* 0x0005 */ faim_export int aim_getinfo(aim_session_t *, aim_conn_t *, const char *, fu16_t);
+faim_export aim_userinfo_t *aim_locate_finduserinfo(aim_session_t *sess, const char *sn);
+
+/* 0x0002 */ faim_export int aim_locate_reqrights(aim_session_t *sess);
+/* 0x0004 */ faim_export int aim_locate_setprofile(aim_session_t *sess, const char *profile_encoding, const char *profile, const int profile_len, const char *awaymsg_encoding, const char *awaymsg, const int awaymsg_len);
+/* 0x0004 */ faim_export int aim_locate_setcaps(aim_session_t *sess, fu32_t caps);
+/* 0x0005 */ faim_export int aim_locate_getinfo(aim_session_t *sess, const char *, fu16_t);
+/* 0x0009 */ faim_export int aim_locate_setdirinfo(aim_session_t *sess, const char *first, const char *middle, const char *last, const char *maiden, const char *nickname, const char *street, const char *city, const char *state, const char *zip, int country, fu16_t privacy);
+/* 0x000b */ faim_export int aim_locate_000b(aim_session_t *sess, const char *sn);
+/* 0x000f */ faim_export int aim_locate_setinterests(aim_session_t *sess, const char *interest1, const char *interest2, const char *interest3, const char *interest4, const char *interest5, fu16_t privacy);
+/* 0x0015 */ faim_export int aim_locate_getinfoshort(aim_session_t *sess, const char *sn, fu32_t flags);
 
 
 
 /* 0x0003 - buddylist.c */
-/* 0x0004 */ faim_export int aim_add_buddy(aim_session_t *, aim_conn_t *, const char *);
-/* 0x0005 */ faim_export int aim_remove_buddy(aim_session_t *, aim_conn_t *, const char *);
-/* 0x000b */ faim_export int aim_sendbuddyoncoming(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *info);
-/* 0x000c */ faim_export int aim_sendbuddyoffgoing(aim_session_t *sess, aim_conn_t *conn, const char *sn);
+/* 0x0002 */ faim_export int aim_buddylist_reqrights(aim_session_t *, aim_conn_t *);
+/* 0x0004 */ faim_export int aim_buddylist_set(aim_session_t *, aim_conn_t *, const char *);
+/* 0x0004 */ faim_export int aim_buddylist_addbuddy(aim_session_t *, aim_conn_t *, const char *);
+/* 0x0005 */ faim_export int aim_buddylist_removebuddy(aim_session_t *, aim_conn_t *, const char *);
+/* 0x000b */ faim_export int aim_buddylist_oncoming(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *info);
+/* 0x000c */ faim_export int aim_buddylist_offgoing(aim_session_t *sess, aim_conn_t *conn, const char *sn);
 
 
@@ -1194 +1217 @@
 faim_export fu32_t aim_ssi_getpresence(struct aim_ssi_item *list);
 faim_export char *aim_ssi_getalias(struct aim_ssi_item *list, const char *gn, const char *sn);
+faim_export char *aim_ssi_getcomment(struct aim_ssi_item *list, const char *gn, const char *sn);
 faim_export int aim_ssi_waitingforauth(struct aim_ssi_item *list, const char *gn, const char *sn);
 
@@ -1205 +1229 @@
 faim_export int aim_ssi_movebuddy(aim_session_t *sess, const char *oldgn, const char *newgn, const char *sn);
 faim_export int aim_ssi_aliasbuddy(aim_session_t *sess, const char *gn, const char *sn, const char *alias);
+faim_export int aim_ssi_editcomment(aim_session_t *sess, const char *gn, const char *sn, const char *alias);
 faim_export int aim_ssi_rename_group(aim_session_t *sess, const char *oldgn, const char *newgn);
 faim_export int aim_ssi_cleanlist(aim_session_t *sess);
@@ -1211 +1236 @@
 faim_export int aim_ssi_setpresence(aim_session_t *sess, fu32_t presence);
 faim_export int aim_ssi_seticon(aim_session_t *sess, fu8_t *iconsum, fu16_t iconsumlen);
+faim_export int aim_ssi_delicon(aim_session_t *sess);
 
 
@@ -1326 +1352 @@
 };
 
-faim_export int aim_email_sendcookies(aim_session_t *sess, aim_conn_t *conn);
-faim_export int aim_email_activate(aim_session_t *sess, aim_conn_t *conn);
-
-
-
+faim_export int aim_email_sendcookies(aim_session_t *sess);
+faim_export int aim_email_activate(aim_session_t *sess);
+
+
+
+#if defined(FAIM_INTERNAL) || defined(FAIM_NEED_TLV)
 /* tlv.c - TLV handling */
-#if defined(FAIM_INTERNAL) || defined(FAIM_NEED_TLV)
-/* Generic TLV structure. */
+
+/* TLV structure */
 typedef struct aim_tlv_s {
         fu16_t type;
@@ -1340 +1367 @@
 } aim_tlv_t;
 
-/* List of above. */
+/* TLV List structure */
 typedef struct aim_tlvlist_s {
         aim_tlv_t *tlv;
@@ -1346 +1373 @@
 } aim_tlvlist_t;
 
-/* TLV-handling functions */
-
-#if 0
-/* Very, very raw TLV handling. */
-faim_internal int aim_puttlv_8(fu8_t *buf, const fu16_t t, const fu8_t v);
-faim_internal int aim_puttlv_16(fu8_t *buf, const fu16_t t, const fu16_t v);
-faim_internal int aim_puttlv_32(fu8_t *buf, const fu16_t t, const fu32_t v);
-faim_internal int aim_puttlv_raw(fu8_t *buf, const fu16_t t, const fu16_t l, const fu8_t *v);
-#endif
-
-/* TLV list handling. */
-faim_internal aim_tlvlist_t *aim_readtlvchain(aim_bstream_t *bs);
-faim_internal aim_tlvlist_t *aim_readtlvchain_num(aim_bstream_t *bs, fu16_t num);
-faim_internal aim_tlvlist_t *aim_readtlvchain_len(aim_bstream_t *bs, fu16_t len);
+/* TLV handling functions */
+faim_internal aim_tlv_t *aim_tlv_gettlv(aim_tlvlist_t *list, fu16_t type, const int nth);
+faim_internal char *aim_tlv_getstr(aim_tlvlist_t *list, const fu16_t type, const int nth);
+faim_internal fu8_t aim_tlv_get8(aim_tlvlist_t *list, const fu16_t type, const int nth);
+faim_internal fu16_t aim_tlv_get16(aim_tlvlist_t *list, const fu16_t type, const int nth);
+faim_internal fu32_t aim_tlv_get32(aim_tlvlist_t *list, const fu16_t type, const int nth);
+
+/* TLV list handling functions */
+faim_internal aim_tlvlist_t *aim_tlvlist_read(aim_bstream_t *bs);
+faim_internal aim_tlvlist_t *aim_tlvlist_readnum(aim_bstream_t *bs, fu16_t num);
+faim_internal aim_tlvlist_t *aim_tlvlist_readlen(aim_bstream_t *bs, fu16_t len);
 faim_internal aim_tlvlist_t *aim_tlvlist_copy(aim_tlvlist_t *orig);
+
+faim_internal int aim_tlvlist_count(aim_tlvlist_t **list);
+faim_internal int aim_tlvlist_size(aim_tlvlist_t **list);
 faim_internal int aim_tlvlist_cmp(aim_tlvlist_t *one, aim_tlvlist_t *two);
-faim_internal void aim_freetlvchain(aim_tlvlist_t **list);
-faim_internal aim_tlv_t *aim_gettlv(aim_tlvlist_t *, fu16_t t, const int n);
-faim_internal char *aim_gettlv_str(aim_tlvlist_t *, const fu16_t t, const int n);
-faim_internal fu8_t aim_gettlv8(aim_tlvlist_t *list, const fu16_t type, const int num);
-faim_internal fu16_t aim_gettlv16(aim_tlvlist_t *list, const fu16_t t, const int n);
-faim_internal fu32_t aim_gettlv32(aim_tlvlist_t *list, const fu16_t t, const int n);
-faim_internal int aim_writetlvchain(aim_bstream_t *bs, aim_tlvlist_t **list);
-faim_internal int aim_addtlvtochain8(aim_tlvlist_t **list, const fu16_t t, const fu8_t v);
-faim_internal int aim_addtlvtochain16(aim_tlvlist_t **list, const fu16_t t, const fu16_t v);
-faim_internal int aim_addtlvtochain32(aim_tlvlist_t **list, const fu16_t type, const fu32_t v);
-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 fu32_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, aim_userinfo_t *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_internal int aim_sizetlvchain(aim_tlvlist_t **list);
+faim_internal int aim_tlvlist_write(aim_bstream_t *bs, aim_tlvlist_t **list);
+faim_internal void aim_tlvlist_free(aim_tlvlist_t **list);
+
+faim_internal int aim_tlvlist_add_raw(aim_tlvlist_t **list, const fu16_t type, const fu16_t length, const fu8_t *value);
+faim_internal int aim_tlvlist_add_noval(aim_tlvlist_t **list, const fu16_t type);
+faim_internal int aim_tlvlist_add_8(aim_tlvlist_t **list, const fu16_t type, const fu8_t value);
+faim_internal int aim_tlvlist_add_16(aim_tlvlist_t **list, const fu16_t type, const fu16_t value);
+faim_internal int aim_tlvlist_add_32(aim_tlvlist_t **list, const fu16_t type, const fu32_t value);
+faim_internal int aim_tlvlist_add_caps(aim_tlvlist_t **list, const fu16_t type, const fu32_t caps);
+faim_internal int aim_tlvlist_add_userinfo(aim_tlvlist_t **list, fu16_t type, aim_userinfo_t *userinfo);
+faim_internal int aim_tlvlist_add_frozentlvlist(aim_tlvlist_t **list, fu16_t type, aim_tlvlist_t **tl);
+
+faim_internal int aim_tlvlist_replace_raw(aim_tlvlist_t **list, const fu16_t type, const fu16_t lenth, const fu8_t *value);
+faim_internal int aim_tlvlist_replace_noval(aim_tlvlist_t **list, const fu16_t type);
+faim_internal int aim_tlvlist_replace_8(aim_tlvlist_t **list, const fu16_t type, const fu8_t value);
+faim_internal int aim_tlvlist_replace_16(aim_tlvlist_t **list, const fu16_t type, const fu16_t value);
+faim_internal int aim_tlvlist_replace_32(aim_tlvlist_t **list, const fu16_t type, const fu32_t value);
+
+faim_internal void aim_tlvlist_remove(aim_tlvlist_t **list, const fu16_t type);
 #endif /* FAIM_INTERNAL */
 

libfaim/aim_cbtypes.h

@@ -212 +212 @@
 #define AIM_CB_SSI_REQDATA 0x0004
 #define AIM_CB_SSI_REQIFCHANGED 0x0005
-#define AIM_CB_SSI_REQLIST 0x0005
 #define AIM_CB_SSI_LIST 0x0006
 #define AIM_CB_SSI_ACTIVATE 0x0007

libfaim/aim_internal.h

@@ -47 +47 @@
 faim_internal int chat_modfirst(aim_session_t *sess, aim_module_t *mod);
 faim_internal int locate_modfirst(aim_session_t *sess, aim_module_t *mod);
-faim_internal int general_modfirst(aim_session_t *sess, aim_module_t *mod);
+faim_internal int service_modfirst(aim_session_t *sess, aim_module_t *mod);
 faim_internal int invite_modfirst(aim_session_t *sess, aim_module_t *mod);
 faim_internal int translate_modfirst(aim_session_t *sess, aim_module_t *mod);
@@ -189 +189 @@
 faim_internal void aim_conn_addgroup(aim_conn_t *conn, fu16_t group);
 
-faim_internal fu32_t aim_getcap(aim_session_t *sess, aim_bstream_t *bs, int len);
-faim_internal int aim_putcap(aim_bstream_t *bs, fu32_t caps);
-
 faim_internal int aim_cachecookie(aim_session_t *sess, aim_msgcookie_t *cookie);
 faim_internal aim_msgcookie_t *aim_uncachecookie(aim_session_t *sess, fu8_t *cookie, int type);
@@ -200 +197 @@
 faim_internal int aim_cookie_free(aim_session_t *sess, aim_msgcookie_t *cookie);
 
+/* 0x0002 - locate.c */
+faim_internal void aim_locate_requestuserinfo(aim_session_t *sess, const char *sn);
+faim_internal fu32_t aim_locate_getcaps(aim_session_t *sess, aim_bstream_t *bs, int len);
+faim_internal fu32_t aim_locate_getcaps_short(aim_session_t *sess, aim_bstream_t *bs, int len);
+faim_internal int aim_putcap(aim_bstream_t *bs, fu32_t caps);
 faim_internal void aim_info_free(aim_userinfo_t *);
 faim_internal int aim_info_extract(aim_session_t *sess, aim_bstream_t *bs, aim_userinfo_t *);
@@ -205 +207 @@
 
 faim_internal int aim_chat_readroominfo(aim_bstream_t *bs, struct aim_chat_roominfo *outinfo);
-
-faim_internal void faimdprintf(aim_session_t *sess, int dlevel, const char *format, ...);
 
 faim_internal void aim_conn_kill_chat(aim_session_t *sess, aim_conn_t *conn);
@@ -216 +216 @@
 faim_internal int aim_rates_delparam(aim_session_t *, aim_conn_t *);
 
+faim_internal void faimdprintf(aim_session_t *sess, int dlevel, const char *format, ...);
+
 #ifndef FAIM_INTERNAL_INSANE
 #define printf() printf called inside libfaim

libfaim/auth.c

@@ -12 +12 @@
 #include "md5.h"
 
-static int aim_encode_password(const char *password, fu8_t *encoded);
-
-/* 
+#include <ctype.h>
+
+/**
+ * Encode a password using old XOR method
+ *
+ * This takes a const pointer to a (null terminated) string
+ * containing the unencoded password.  It also gets passed
+ * an already allocated buffer to store the encoded password.
+ * This buffer should be the exact length of the password without
+ * the null.  The encoded password buffer /is not %NULL terminated/.
+ *
+ * The encoding_table seems to be a fixed set of values.  We'll
+ * hope it doesn't change over time!  
+ *
+ * This is only used for the XOR method, not the better MD5 method.
+ *
+ * @param password Incoming password.
+ * @param encoded Buffer to put encoded password.
+ */
+static int aim_encode_password(const char *password, fu8_t *encoded)
+{
+        fu8_t encoding_table[] = {
+#if 0 /* old v1 table */
+                0xf3, 0xb3, 0x6c, 0x99,
+                0x95, 0x3f, 0xac, 0xb6,
+                0xc5, 0xfa, 0x6b, 0x63,
+                0x69, 0x6c, 0xc3, 0x9f
+#else /* v2.1 table, also works for ICQ */
+                0xf3, 0x26, 0x81, 0xc4,
+                0x39, 0x86, 0xdb, 0x92,
+                0x71, 0xa3, 0xb9, 0xe6,
+                0x53, 0x7a, 0x95, 0x7c
+#endif
+        };
+        int i;
+
+        for (i = 0; i < strlen(password); i++)
+                encoded[i] = (password[i] ^ encoding_table[i]);
+
+        return 0;
+}
+
+#ifdef USE_OLD_MD5
+static int aim_encode_password_md5(const char *password, const char *key, fu8_t *digest)
+{
+        md5_state_t state;
+
+        md5_init(&state);       
+        md5_append(&state, (const md5_byte_t *)key, strlen(key));
+        md5_append(&state, (const md5_byte_t *)password, strlen(password));
+        md5_append(&state, (const md5_byte_t *)AIM_MD5_STRING, strlen(AIM_MD5_STRING));
+        md5_finish(&state, (md5_byte_t *)digest);
+
+        return 0;
+}
+#else
+static int aim_encode_password_md5(const char *password, const char *key, fu8_t *digest)
+{
+        md5_state_t state;
+        fu8_t passdigest[16];
+
+        md5_init(&state);
+        md5_append(&state, (const md5_byte_t *)password, strlen(password));
+        md5_finish(&state, (md5_byte_t *)&passdigest);
+
+        md5_init(&state);       
+        md5_append(&state, (const md5_byte_t *)key, strlen(key));
+        md5_append(&state, (const md5_byte_t *)&passdigest, 16);
+        md5_append(&state, (const md5_byte_t *)AIM_MD5_STRING, strlen(AIM_MD5_STRING));
+        md5_finish(&state, (md5_byte_t *)digest);
+
+        return 0;
+}
+#endif
+
+/*
+ * The FLAP version is sent by itself at the beginning of authorization 
+ * connections.  The FLAP version is also sent before the cookie when connecting 
+ * for other services (BOS, chatnav, chat, etc.).
+ */
+faim_export int aim_sendflapver(aim_session_t *sess, aim_conn_t *conn)
+{
+        aim_frame_t *fr;
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x01, 4)))
+                return -ENOMEM;
+
+        aimbs_put32(&fr->data, 0x00000001);
+
+        aim_tx_enqueue(sess, fr);
+
+        return 0;
+}
+
+/*
  * This just pushes the passed cookie onto the passed connection, without
  * the SNAC header or any of that.
@@ -31 +123 @@
 
         aimbs_put32(&fr->data, 0x00000001);
-        aim_addtlvtochain_raw(&tl, 0x0006, length, chipsahoy);
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
-
-        aim_tx_enqueue(sess, fr);
-
-        return 0;
-}
-
-/*
- * Normally the FLAP version is sent as the first few bytes of the cookie,
- * meaning you generally never call this.
- *
- * But there are times when something might want it seperate. Specifically,
- * libfaim sends this internally when doing SNAC login.
- *
- */
-faim_export int aim_sendflapver(aim_session_t *sess, aim_conn_t *conn)
-{
-        aim_frame_t *fr;
-
-        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x01, 4)))
-                return -ENOMEM;
-
-        aimbs_put32(&fr->data, 0x00000001);
-
-        aim_tx_enqueue(sess, fr);
-
-        return 0;
-}
-
-/*
- * This is a bit confusing.
- *
- * Normal SNAC login goes like this:
- *   - connect
- *   - server sends flap version
- *   - client sends flap version
- *   - client sends screen name (17/6)
- *   - server sends hash key (17/7)
- *   - client sends auth request (17/2 -- aim_send_login)
- *   - server yells
- *
- * XOR login (for ICQ) goes like this:
- *   - connect
- *   - server sends flap version
- *   - client sends auth request which contains flap version (aim_send_login)
- *   - server yells
- *
- * For the client API, we make them implement the most complicated version,
- * and for the simpler version, we fake it and make it look like the more
- * complicated process.
- *
- * This is done by giving the client a faked key, just so we can convince
- * them to call aim_send_login right away, which will detect the session
- * flag that says this is XOR login and ignore the key, sending an ICQ
- * login request instead of the normal SNAC one.
- *
- * As soon as AOL makes ICQ log in the same way as AIM, this is /gone/.
- *
- * XXX This may cause problems if the client relies on callbacks only
- * being called from the context of aim_rxdispatch()...
- *
- */
-static int goddamnicq(aim_session_t *sess, aim_conn_t *conn, const char *sn)
-{
-        aim_frame_t fr;
-        aim_rxcallback_t userfunc;
-        
-        sess->flags &= ~AIM_SESS_FLAGS_SNACLOGIN;
-        sess->flags |= AIM_SESS_FLAGS_XORLOGIN;
-
-        fr.conn = conn;
-        
-        if ((userfunc = aim_callhandler(sess, conn, 0x0017, 0x0007)))
-                userfunc(sess, &fr, "");
-
-        return 0;
-}
-
-/*
- * In AIM 3.5 protocol, the first stage of login is to request login from the 
- * Authorizer, passing it the screen name for verification.  If the name is 
- * invalid, a 0017/0003 is spit back, with the standard error contents.  If 
- * valid, a 0017/0007 comes back, which is the signal to send it the main 
- * login command (0017/0002). 
- *
- */
-faim_export int aim_request_login(aim_session_t *sess, aim_conn_t *conn, const char *sn)
-{
-        aim_frame_t *fr;
-        aim_snacid_t snacid;
-        aim_tlvlist_t *tl = NULL;
-        
-        if (!sess || !conn || !sn)
-                return -EINVAL;
-
-        if ((sn[0] >= '0') && (sn[0] <= '9'))
-                return goddamnicq(sess, conn, sn);
-
-        sess->flags |= AIM_SESS_FLAGS_SNACLOGIN;
-
-        aim_sendflapver(sess, conn);
-
-        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+2+2+strlen(sn))))
-                return -ENOMEM;
-
-        snacid = aim_cachesnac(sess, 0x0017, 0x0006, 0x0000, NULL, 0);
-        aim_putsnac(&fr->data, 0x0017, 0x0006, 0x0000, snacid);
-
-        aim_addtlvtochain_raw(&tl, 0x0001, strlen(sn), sn);
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_add_raw(&tl, 0x0006, length, chipsahoy);
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
 
         aim_tx_enqueue(sess, fr);
@@ -174 +156 @@
 
         aimbs_put32(&fr->data, 0x00000001); /* FLAP Version */
-        aim_addtlvtochain_raw(&tl, 0x0001, strlen(sn), sn);
-        aim_addtlvtochain_raw(&tl, 0x0002, passwdlen, password_encoded);
+        aim_tlvlist_add_raw(&tl, 0x0001, strlen(sn), sn);
+        aim_tlvlist_add_raw(&tl, 0x0002, passwdlen, password_encoded);
 
         if (ci->clientstring)
-                aim_addtlvtochain_raw(&tl, 0x0003, strlen(ci->clientstring), ci->clientstring);
-        aim_addtlvtochain16(&tl, 0x0016, (fu16_t)ci->clientid);
-        aim_addtlvtochain16(&tl, 0x0017, (fu16_t)ci->major);
-        aim_addtlvtochain16(&tl, 0x0018, (fu16_t)ci->minor);
-        aim_addtlvtochain16(&tl, 0x0019, (fu16_t)ci->point);
-        aim_addtlvtochain16(&tl, 0x001a, (fu16_t)ci->build);
-        aim_addtlvtochain32(&tl, 0x0014, (fu32_t)ci->distrib); /* distribution chan */
-        aim_addtlvtochain_raw(&tl, 0x000f, strlen(ci->lang), ci->lang);
-        aim_addtlvtochain_raw(&tl, 0x000e, strlen(ci->country), ci->country);
-
-        aim_writetlvchain(&fr->data, &tl);
+                aim_tlvlist_add_raw(&tl, 0x0003, strlen(ci->clientstring), ci->clientstring);
+        aim_tlvlist_add_16(&tl, 0x0016, (fu16_t)ci->clientid);
+        aim_tlvlist_add_16(&tl, 0x0017, (fu16_t)ci->major);
+        aim_tlvlist_add_16(&tl, 0x0018, (fu16_t)ci->minor);
+        aim_tlvlist_add_16(&tl, 0x0019, (fu16_t)ci->point);
+        aim_tlvlist_add_16(&tl, 0x001a, (fu16_t)ci->build);
+        aim_tlvlist_add_32(&tl, 0x0014, (fu32_t)ci->distrib); /* distribution chan */
+        aim_tlvlist_add_raw(&tl, 0x000f, strlen(ci->lang), ci->lang);
+        aim_tlvlist_add_raw(&tl, 0x000e, strlen(ci->country), ci->country);
+
+        aim_tlvlist_write(&fr->data, &tl);
 
         free(password_encoded);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_free(&tl);
 
         aim_tx_enqueue(sess, fr);
@@ -199 +181 @@
 
 /*
- * send_login(int socket, char *sn, char *password)
- *  
+ * Subtype 0x0002
+ *
  * This is the initial login request packet.
  *
@@ -237 +219 @@
                 return -EINVAL;
 
-        /*
-         * What the XORLOGIN flag _really_ means is that its an ICQ login,
-         * which is really stupid and painful, so its not done here.
-         *
-         */
-        if (sess->flags & AIM_SESS_FLAGS_XORLOGIN)
+        /* If we're signing on an ICQ account then use the older, XOR login method */
+        if (isdigit(sn[0]))
                 return goddamnicq2(sess, conn, sn, password, ci);
-
 
         if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 1152)))
@@ -252 +229 @@
         aim_putsnac(&fr->data, 0x0017, 0x0002, 0x0000, snacid);
 
-        aim_addtlvtochain_raw(&tl, 0x0001, strlen(sn), sn);
+        aim_tlvlist_add_raw(&tl, 0x0001, strlen(sn), sn);
 
         aim_encode_password_md5(password, key, digest);
-        aim_addtlvtochain_raw(&tl, 0x0025, 16, digest);
-
-        /*
-         * Newer versions of winaim have an empty type x004c TLV here.
-         */
+        aim_tlvlist_add_raw(&tl, 0x0025, 16, digest);
+
+#ifndef USE_OLD_MD5
+        aim_tlvlist_add_noval(&tl, 0x004c);
+#endif
 
         if (ci->clientstring)
-                aim_addtlvtochain_raw(&tl, 0x0003, strlen(ci->clientstring), ci->clientstring);
-        aim_addtlvtochain16(&tl, 0x0016, (fu16_t)ci->clientid);
-        aim_addtlvtochain16(&tl, 0x0017, (fu16_t)ci->major);
-        aim_addtlvtochain16(&tl, 0x0018, (fu16_t)ci->minor);
-        aim_addtlvtochain16(&tl, 0x0019, (fu16_t)ci->point);
-        aim_addtlvtochain16(&tl, 0x001a, (fu16_t)ci->build);
-        aim_addtlvtochain32(&tl, 0x0014, (fu32_t)ci->distrib);
-        aim_addtlvtochain_raw(&tl, 0x000e, strlen(ci->country), ci->country);
-        aim_addtlvtochain_raw(&tl, 0x000f, strlen(ci->lang), ci->lang);
+                aim_tlvlist_add_raw(&tl, 0x0003, strlen(ci->clientstring), ci->clientstring);
+        aim_tlvlist_add_16(&tl, 0x0016, (fu16_t)ci->clientid);
+        aim_tlvlist_add_16(&tl, 0x0017, (fu16_t)ci->major);
+        aim_tlvlist_add_16(&tl, 0x0018, (fu16_t)ci->minor);
+        aim_tlvlist_add_16(&tl, 0x0019, (fu16_t)ci->point);
+        aim_tlvlist_add_16(&tl, 0x001a, (fu16_t)ci->build);
+        aim_tlvlist_add_32(&tl, 0x0014, (fu32_t)ci->distrib);
+        aim_tlvlist_add_raw(&tl, 0x000f, strlen(ci->lang), ci->lang);
+        aim_tlvlist_add_raw(&tl, 0x000e, strlen(ci->country), ci->country);
 
 #ifndef NOSSI
@@ -277 +254 @@
          * to use SSI.
          */
-        aim_addtlvtochain8(&tl, 0x004a, 0x01);
+        aim_tlvlist_add_8(&tl, 0x004a, 0x01);
 #endif
 
-        aim_writetlvchain(&fr->data, &tl);
-
-        aim_freetlvchain(&tl);
+        aim_tlvlist_write(&fr->data, &tl);
+
+        aim_tlvlist_free(&tl);
         
         aim_tx_enqueue(sess, fr);
-
-        return 0;
-}
-
-faim_export int aim_encode_password_md5(const char *password, const char *key, fu8_t *digest)
-{
-        md5_state_t state;
-
-        md5_init(&state);       
-        md5_append(&state, (const md5_byte_t *)key, strlen(key));
-        md5_append(&state, (const md5_byte_t *)password, strlen(password));
-        md5_append(&state, (const md5_byte_t *)AIM_MD5_STRING, strlen(AIM_MD5_STRING));
-        md5_finish(&state, (md5_byte_t *)digest);
-
-        return 0;
-}
-
-/**
- * aim_encode_password - Encode a password using old XOR method
- * @password: incoming password
- * @encoded: buffer to put encoded password
- *
- * This takes a const pointer to a (null terminated) string
- * containing the unencoded password.  It also gets passed
- * an already allocated buffer to store the encoded password.
- * This buffer should be the exact length of the password without
- * the null.  The encoded password buffer /is not %NULL terminated/.
- *
- * The encoding_table seems to be a fixed set of values.  We'll
- * hope it doesn't change over time!  
- *
- * This is only used for the XOR method, not the better MD5 method.
- *
- */
-static int aim_encode_password(const char *password, fu8_t *encoded)
-{
-        fu8_t encoding_table[] = {
-#if 0 /* old v1 table */
-                0xf3, 0xb3, 0x6c, 0x99,
-                0x95, 0x3f, 0xac, 0xb6,
-                0xc5, 0xfa, 0x6b, 0x63,
-                0x69, 0x6c, 0xc3, 0x9f
-#else /* v2.1 table, also works for ICQ */
-                0xf3, 0x26, 0x81, 0xc4,
-                0x39, 0x86, 0xdb, 0x92,
-                0x71, 0xa3, 0xb9, 0xe6,
-                0x53, 0x7a, 0x95, 0x7c
-#endif
-        };
-        int i;
-
-        for (i = 0; i < strlen(password); i++)
-                encoded[i] = (password[i] ^ encoding_table[i]);
 
         return 0;
@@ -349 +273 @@
  * The client should check the value passed as errorcode. If
  * its nonzero, there was an error.
- *
  */
 static int parse(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
@@ -365 +288 @@
          * from what is parsed here.
          */
-        tlvlist = aim_readtlvchain(bs);
+        tlvlist = aim_tlvlist_read(bs);
 
         /*
@@ -371 +294 @@
          */
         memset(sess->sn, 0, sizeof(sess->sn));
-        if (aim_gettlv(tlvlist, 0x0001, 1)) {
-                info->sn = aim_gettlv_str(tlvlist, 0x0001, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0001, 1)) {
+                info->sn = aim_tlv_getstr(tlvlist, 0x0001, 1);
                 strncpy(sess->sn, info->sn, sizeof(sess->sn));
         }
@@ -380 +303 @@
          * have an error url.
          */
-        if (aim_gettlv(tlvlist, 0x0008, 1)) 
-                info->errorcode = aim_gettlv16(tlvlist, 0x0008, 1);
-        if (aim_gettlv(tlvlist, 0x0004, 1))
-                info->errorurl = aim_gettlv_str(tlvlist, 0x0004, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0008, 1)) 
+                info->errorcode = aim_tlv_get16(tlvlist, 0x0008, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0004, 1))
+                info->errorurl = aim_tlv_getstr(tlvlist, 0x0004, 1);
 
         /*
          * BOS server address.
          */
-        if (aim_gettlv(tlvlist, 0x0005, 1))
-                info->bosip = aim_gettlv_str(tlvlist, 0x0005, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0005, 1))
+                info->bosip = aim_tlv_getstr(tlvlist, 0x0005, 1);
 
         /*
          * Authorization cookie.
          */
-        if (aim_gettlv(tlvlist, 0x0006, 1)) {
+        if (aim_tlv_gettlv(tlvlist, 0x0006, 1)) {
                 aim_tlv_t *tmptlv;
 
-                tmptlv = aim_gettlv(tlvlist, 0x0006, 1);
+                tmptlv = aim_tlv_gettlv(tlvlist, 0x0006, 1);
 
                 info->cookielen = tmptlv->length;
@@ -410 +333 @@
          * XXX - Not really true!
          */
-        if (aim_gettlv(tlvlist, 0x0011, 1))
-                info->email = aim_gettlv_str(tlvlist, 0x0011, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0011, 1))
+                info->email = aim_tlv_getstr(tlvlist, 0x0011, 1);
 
         /*
@@ -427 +350 @@
          *
          */
-        if (aim_gettlv(tlvlist, 0x0013, 1))
-                info->regstatus = aim_gettlv16(tlvlist, 0x0013, 1);
-
-        if (aim_gettlv(tlvlist, 0x0040, 1))
-                info->latestbeta.build = aim_gettlv32(tlvlist, 0x0040, 1);
-        if (aim_gettlv(tlvlist, 0x0041, 1))
-                info->latestbeta.url = aim_gettlv_str(tlvlist, 0x0041, 1);
-        if (aim_gettlv(tlvlist, 0x0042, 1))
-                info->latestbeta.info = aim_gettlv_str(tlvlist, 0x0042, 1);
-        if (aim_gettlv(tlvlist, 0x0043, 1))
-                info->latestbeta.name = aim_gettlv_str(tlvlist, 0x0043, 1);
-        if (aim_gettlv(tlvlist, 0x0048, 1))
-                ; /* no idea what this is */
-
-        if (aim_gettlv(tlvlist, 0x0044, 1))
-                info->latestrelease.build = aim_gettlv32(tlvlist, 0x0044, 1);
-        if (aim_gettlv(tlvlist, 0x0045, 1))
-                info->latestrelease.url = aim_gettlv_str(tlvlist, 0x0045, 1);
-        if (aim_gettlv(tlvlist, 0x0046, 1))
-                info->latestrelease.info = aim_gettlv_str(tlvlist, 0x0046, 1);
-        if (aim_gettlv(tlvlist, 0x0047, 1))
-                info->latestrelease.name = aim_gettlv_str(tlvlist, 0x0047, 1);
-        if (aim_gettlv(tlvlist, 0x0049, 1))
-                ; /* no idea what this is */
+        if (aim_tlv_gettlv(tlvlist, 0x0013, 1))
+                info->regstatus = aim_tlv_get16(tlvlist, 0x0013, 1);
+
+        if (aim_tlv_gettlv(tlvlist, 0x0040, 1))
+                info->latestbeta.build = aim_tlv_get32(tlvlist, 0x0040, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0041, 1))
+                info->latestbeta.url = aim_tlv_getstr(tlvlist, 0x0041, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0042, 1))
+                info->latestbeta.info = aim_tlv_getstr(tlvlist, 0x0042, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0043, 1))
+                info->latestbeta.name = aim_tlv_getstr(tlvlist, 0x0043, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0048, 1))
+                ; /* beta serial */
+
+        if (aim_tlv_gettlv(tlvlist, 0x0044, 1))
+                info->latestrelease.build = aim_tlv_get32(tlvlist, 0x0044, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0045, 1))
+                info->latestrelease.url = aim_tlv_getstr(tlvlist, 0x0045, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0046, 1))
+                info->latestrelease.info = aim_tlv_getstr(tlvlist, 0x0046, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0047, 1))
+                info->latestrelease.name = aim_tlv_getstr(tlvlist, 0x0047, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0049, 1))
+                ; /* lastest release serial */
 
         /*
          * URL to change password.
          */
-        if (aim_gettlv(tlvlist, 0x0054, 1))
-                info->chpassurl = aim_gettlv_str(tlvlist, 0x0054, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0054, 1))
+                info->chpassurl = aim_tlv_getstr(tlvlist, 0x0054, 1);
 
         /*
          * Unknown.  Seen on an @mac.com screen name with value of 0x003f
          */
-        if (aim_gettlv(tlvlist, 0x0055, 1))
+        if (aim_tlv_gettlv(tlvlist, 0x0055, 1))
                 ;
 
@@ -469 +392 @@
                 ret = userfunc(sess, rx, info);
 
-        aim_freetlvchain(&tlvlist);
+        aim_tlvlist_free(&tlvlist);
 
         return ret;
@@ -475 +398 @@
 
 /*
+ * Subtype 0x0007 (kind of) - Send a fake type 0x0007 SNAC to the client
+ *
+ * This is a bit confusing.
+ *
+ * Normal SNAC login goes like this:
+ *   - connect
+ *   - server sends flap version
+ *   - client sends flap version
+ *   - client sends screen name (17/6)
+ *   - server sends hash key (17/7)
+ *   - client sends auth request (17/2 -- aim_send_login)
+ *   - server yells
+ *
+ * XOR login (for ICQ) goes like this:
+ *   - connect
+ *   - server sends flap version
+ *   - client sends auth request which contains flap version (aim_send_login)
+ *   - server yells
+ *
+ * For the client API, we make them implement the most complicated version,
+ * and for the simpler version, we fake it and make it look like the more
+ * complicated process.
+ *
+ * This is done by giving the client a faked key, just so we can convince
+ * them to call aim_send_login right away, which will detect the session
+ * flag that says this is XOR login and ignore the key, sending an ICQ
+ * login request instead of the normal SNAC one.
+ *
+ * As soon as AOL makes ICQ log in the same way as AIM, this is /gone/.
+ *
+ * XXX This may cause problems if the client relies on callbacks only
+ * being called from the context of aim_rxdispatch()...
+ *
+ */
+static int goddamnicq(aim_session_t *sess, aim_conn_t *conn, const char *sn)
+{
+        aim_frame_t fr;
+        aim_rxcallback_t userfunc;
+        
+        fr.conn = conn;
+        
+        if ((userfunc = aim_callhandler(sess, conn, 0x0017, 0x0007)))
+                userfunc(sess, &fr, "");
+
+        return 0;
+}
+
+/*
+ * Subtype 0x0006
+ *
+ * In AIM 3.5 protocol, the first stage of login is to request login from the 
+ * Authorizer, passing it the screen name for verification.  If the name is 
+ * invalid, a 0017/0003 is spit back, with the standard error contents.  If 
+ * valid, a 0017/0007 comes back, which is the signal to send it the main 
+ * login command (0017/0002). 
+ *
+ */
+faim_export int aim_request_login(aim_session_t *sess, aim_conn_t *conn, const char *sn)
+{
+        aim_frame_t *fr;
+        aim_snacid_t snacid;
+        aim_tlvlist_t *tl = NULL;
+        
+        if (!sess || !conn || !sn)
+                return -EINVAL;
+
+        if (isdigit(sn[0]))
+                return goddamnicq(sess, conn, sn);
+
+        aim_sendflapver(sess, conn);
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+2+2+strlen(sn) /*+8*/ )))
+                return -ENOMEM;
+
+        snacid = aim_cachesnac(sess, 0x0017, 0x0006, 0x0000, NULL, 0);
+        aim_putsnac(&fr->data, 0x0017, 0x0006, 0x0000, snacid);
+
+        aim_tlvlist_add_raw(&tl, 0x0001, strlen(sn), sn);
+/*      aim_tlvlist_add_noval(&tl, 0x004b);
+        aim_tlvlist_add_noval(&tl, 0x005a); */
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
+
+        aim_tx_enqueue(sess, fr);
+
+        return 0;
+}
+
+/*
+ * Subtype 0x0007
+ *
  * Middle handler for 0017/0007 SNACs.  Contains the auth key prefixed
  * by only its length in a two byte word.

libfaim/bos.c

@@ -13 +13 @@
 faim_export int aim_bos_reqrights(aim_session_t *sess, aim_conn_t *conn)
 {
-        return aim_genericreq_n(sess, conn, 0x0009, 0x0002);
+        return aim_genericreq_n_snacid(sess, conn, 0x0009, 0x0002);
 }
 
@@ -27 +27 @@
          * TLVs follow 
          */
-        tlvlist = aim_readtlvchain(bs);
+        tlvlist = aim_tlvlist_read(bs);
 
         /*
          * TLV type 0x0001: Maximum number of buddies on permit list.
          */
-        if (aim_gettlv(tlvlist, 0x0001, 1))
-                maxpermits = aim_gettlv16(tlvlist, 0x0001, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0001, 1))
+                maxpermits = aim_tlv_get16(tlvlist, 0x0001, 1);
 
         /*
          * TLV type 0x0002: Maximum number of buddies on deny list.
          */
-        if (aim_gettlv(tlvlist, 0x0002, 1)) 
-                maxdenies = aim_gettlv16(tlvlist, 0x0002, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0002, 1)) 
+                maxdenies = aim_tlv_get16(tlvlist, 0x0002, 1);
 
         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
                 ret = userfunc(sess, rx, maxpermits, maxdenies);
 
-        aim_freetlvchain(&tlvlist);
+        aim_tlvlist_free(&tlvlist);
 
         return ret;  

libfaim/buddylist.c

@@ -15 +15 @@
  *
  */
-faim_export int aim_bos_reqbuddyrights(aim_session_t *sess, aim_conn_t *conn)
-{
-        return aim_genericreq_n(sess, conn, 0x0003, 0x0002);
+faim_export int aim_buddylist_reqrights(aim_session_t *sess, aim_conn_t *conn)
+{
+        return aim_genericreq_n_snacid(sess, conn, 0x0003, 0x0002);
 }
 
@@ -34 +34 @@
          * TLVs follow 
          */
-        tlvlist = aim_readtlvchain(bs);
+        tlvlist = aim_tlvlist_read(bs);
 
         /*
          * TLV type 0x0001: Maximum number of buddies.
          */
-        if (aim_gettlv(tlvlist, 0x0001, 1))
-                maxbuddies = aim_gettlv16(tlvlist, 0x0001, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0001, 1))
+                maxbuddies = aim_tlv_get16(tlvlist, 0x0001, 1);
 
         /*
@@ -50 +50 @@
          * 
          */
-        if (aim_gettlv(tlvlist, 0x0002, 1))
-                maxwatchers = aim_gettlv16(tlvlist, 0x0002, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0002, 1))
+                maxwatchers = aim_tlv_get16(tlvlist, 0x0002, 1);
 
         /*
@@ -62 +62 @@
                 ret = userfunc(sess, rx, maxbuddies, maxwatchers);
 
-        aim_freetlvchain(&tlvlist);
+        aim_tlvlist_free(&tlvlist);
 
         return ret;  
@@ -74 +74 @@
  *
  */
-faim_export int aim_add_buddy(aim_session_t *sess, aim_conn_t *conn, const char *sn)
+faim_export int aim_buddylist_addbuddy(aim_session_t *sess, aim_conn_t *conn, const char *sn)
 {
         aim_frame_t *fr;
@@ -106 +106 @@
  *
  */
-faim_export int aim_bos_setbuddylist(aim_session_t *sess, aim_conn_t *conn, const char *buddy_list)
+faim_export int aim_buddylist_set(aim_session_t *sess, aim_conn_t *conn, const char *buddy_list)
 {
         aim_frame_t *fr;
@@ -154 +154 @@
  *
  */
-faim_export int aim_remove_buddy(aim_session_t *sess, aim_conn_t *conn, const char *sn)
+faim_export int aim_buddylist_removebuddy(aim_session_t *sess, aim_conn_t *conn, const char *sn)
 {
         aim_frame_t *fr;
@@ -182 +182 @@
  *
  */
-faim_export int aim_sendbuddyoncoming(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *info)
+faim_export int aim_buddylist_oncoming(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *info)
 {
         aim_frame_t *fr;
@@ -209 +209 @@
  *
  */
-faim_export int aim_sendbuddyoffgoing(aim_session_t *sess, aim_conn_t *conn, const char *sn)
+faim_export int aim_buddylist_offgoing(aim_session_t *sess, aim_conn_t *conn, const char *sn)
 {
         aim_frame_t *fr;
@@ -253 +253 @@
                 ret = userfunc(sess, rx, &userinfo);
 
+        if (snac->subtype == 0x000b)
+                aim_locate_requestuserinfo(sess, userinfo.sn);
         aim_info_free(&userinfo);
 

libfaim/chat.c

@@ -104 +104 @@
         aimbs_put16(&bs, instance);
 
-        aim_addtlvtochain_raw(list, type, aim_bstream_curpos(&bs), buf);
+        aim_tlvlist_add_raw(list, type, aim_bstream_curpos(&bs), buf);
 
         free(buf);
@@ -144 +144 @@
 
         aim_addtlvtochain_chatroom(&tl, 0x0001, exchange, roomname, instance);
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
 
         aim_tx_enqueue(sess, fr);
@@ -250 +250 @@
         aim_putcap(&hdrbs, AIM_CAPS_CHAT);
 
-        aim_addtlvtochain16(&itl, 0x000a, 0x0001);
-        aim_addtlvtochain_noval(&itl, 0x000f);
-        aim_addtlvtochain_raw(&itl, 0x000c, strlen(msg), msg);
+        aim_tlvlist_add_16(&itl, 0x000a, 0x0001);
+        aim_tlvlist_add_noval(&itl, 0x000f);
+        aim_tlvlist_add_raw(&itl, 0x000c, strlen(msg), msg);
         aim_addtlvtochain_chatroom(&itl, 0x2711, exchange, roomname, instance);
-        aim_writetlvchain(&hdrbs, &itl);
-        
-        aim_addtlvtochain_raw(&otl, 0x0005, aim_bstream_curpos(&hdrbs), hdr);
-
-        aim_writetlvchain(&fr->data, &otl);
+        aim_tlvlist_write(&hdrbs, &itl);
+        
+        aim_tlvlist_add_raw(&otl, 0x0005, aim_bstream_curpos(&hdrbs), hdr);
+
+        aim_tlvlist_write(&fr->data, &otl);
 
         free(hdr);
-        aim_freetlvchain(&itl);
-        aim_freetlvchain(&otl);
+        aim_tlvlist_free(&itl);
+        aim_tlvlist_free(&otl);
         
         aim_tx_enqueue(sess, fr);
@@ -308 +308 @@
          * Everything else are TLVs.
          */ 
-        tlvlist = aim_readtlvchain(bs);
+        tlvlist = aim_tlvlist_read(bs);
 
         /*
          * TLV type 0x006a is the room name in Human Readable Form.
          */
-        if (aim_gettlv(tlvlist, 0x006a, 1))
-                roomname = aim_gettlv_str(tlvlist, 0x006a, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x006a, 1))
+                roomname = aim_tlv_getstr(tlvlist, 0x006a, 1);
 
         /*
          * Type 0x006f: Number of occupants.
          */
-        if (aim_gettlv(tlvlist, 0x006f, 1))
-                usercount = aim_gettlv16(tlvlist, 0x006f, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x006f, 1))
+                usercount = aim_tlv_get16(tlvlist, 0x006f, 1);
 
         /*
          * Type 0x0073:  Occupant list.
          */
-        if (aim_gettlv(tlvlist, 0x0073, 1)) {   
+        if (aim_tlv_gettlv(tlvlist, 0x0073, 1)) {       
                 int curoccupant = 0;
                 aim_tlv_t *tmptlv;
                 aim_bstream_t occbs;
 
-                tmptlv = aim_gettlv(tlvlist, 0x0073, 1);
+                tmptlv = aim_tlv_gettlv(tlvlist, 0x0073, 1);
 
                 /* Allocate enough userinfo structs for all occupants */
@@ -344 +344 @@
          * Type 0x00c9: Flags. (AIM_CHATROOM_FLAG)
          */
-        if (aim_gettlv(tlvlist, 0x00c9, 1))
-                flags = aim_gettlv16(tlvlist, 0x00c9, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x00c9, 1))
+                flags = aim_tlv_get16(tlvlist, 0x00c9, 1);
 
         /* 
          * Type 0x00ca: Creation time (4 bytes)
          */
-        if (aim_gettlv(tlvlist, 0x00ca, 1))
-                creationtime = aim_gettlv32(tlvlist, 0x00ca, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x00ca, 1))
+                creationtime = aim_tlv_get32(tlvlist, 0x00ca, 1);
 
         /* 
          * Type 0x00d1: Maximum Message Length
          */
-        if (aim_gettlv(tlvlist, 0x00d1, 1))
-                maxmsglen = aim_gettlv16(tlvlist, 0x00d1, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x00d1, 1))
+                maxmsglen = aim_tlv_get16(tlvlist, 0x00d1, 1);
 
         /* 
          * Type 0x00d2: Unknown. (2 bytes)
          */
-        if (aim_gettlv(tlvlist, 0x00d2, 1))
-                unknown_d2 = aim_gettlv16(tlvlist, 0x00d2, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x00d2, 1))
+                unknown_d2 = aim_tlv_get16(tlvlist, 0x00d2, 1);
 
         /* 
          * Type 0x00d3: Room Description
          */
-        if (aim_gettlv(tlvlist, 0x00d3, 1))
-                roomdesc = aim_gettlv_str(tlvlist, 0x00d3, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x00d3, 1))
+                roomdesc = aim_tlv_getstr(tlvlist, 0x00d3, 1);
 
         /*
          * Type 0x000d4: Unknown (flag only)
          */
-        if (aim_gettlv(tlvlist, 0x000d4, 1))
+        if (aim_tlv_gettlv(tlvlist, 0x000d4, 1))
                 ;
 
@@ -380 +380 @@
          * Type 0x00d5: Unknown. (1 byte)
          */
-        if (aim_gettlv(tlvlist, 0x00d5, 1))
-                unknown_d5 = aim_gettlv8(tlvlist, 0x00d5, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x00d5, 1))
+                unknown_d5 = aim_tlv_get8(tlvlist, 0x00d5, 1);
 
 
@@ -387 +387 @@
          * Type 0x00d6: Encoding 1 ("us-ascii")
          */
-        if (aim_gettlv(tlvlist, 0x000d6, 1))
+        if (aim_tlv_gettlv(tlvlist, 0x000d6, 1))
                 ;
         
@@ -393 +393 @@
          * Type 0x00d7: Language 1 ("en")
          */
-        if (aim_gettlv(tlvlist, 0x000d7, 1))
+        if (aim_tlv_gettlv(tlvlist, 0x000d7, 1))
                 ;
 
@@ -399 +399 @@
          * Type 0x00d8: Encoding 2 ("us-ascii")
          */
-        if (aim_gettlv(tlvlist, 0x000d8, 1))
+        if (aim_tlv_gettlv(tlvlist, 0x000d8, 1))
                 ;
         
@@ -405 +405 @@
          * Type 0x00d9: Language 2 ("en")
          */
-        if (aim_gettlv(tlvlist, 0x000d9, 1))
+        if (aim_tlv_gettlv(tlvlist, 0x000d9, 1))
                 ;
 
@@ -411 +411 @@
          * Type 0x00da: Maximum visible message length
          */
-        if (aim_gettlv(tlvlist, 0x000da, 1))
-                maxvisiblemsglen = aim_gettlv16(tlvlist, 0x00da, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x000da, 1))
+                maxvisiblemsglen = aim_tlv_get16(tlvlist, 0x00da, 1);
 
         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) {
@@ -438 +438 @@
         free(roomname);
         free(roomdesc);
-        aim_freetlvchain(&tlvlist);
+        aim_tlvlist_free(&tlvlist);
 
         return ret;
@@ -516 +516 @@
          * Type 1: Flag meaning this message is destined to the room.
          */
-        aim_addtlvtochain_noval(&otl, 0x0001);
+        aim_tlvlist_add_noval(&otl, 0x0001);
 
         /*
@@ -522 +522 @@
          */
         if (!(flags & AIM_CHATFLAGS_NOREFLECT))
-                aim_addtlvtochain_noval(&otl, 0x0006);
+                aim_tlvlist_add_noval(&otl, 0x0006);
 
         /*
@@ -528 +528 @@
          */
         if (flags & AIM_CHATFLAGS_AWAY)
-                aim_addtlvtochain_noval(&otl, 0x0007);
+                aim_tlvlist_add_noval(&otl, 0x0007);
 
         /*
          * SubTLV: Type 1: Message
          */
-        aim_addtlvtochain_raw(&itl, 0x0001, msglen, msg);
+        aim_tlvlist_add_raw(&itl, 0x0001, msglen, msg);
 
         /*
@@ -542 +542 @@
          * 
          */
-        aim_addtlvtochain_frozentlvlist(&otl, 0x0005, &itl);
-
-        aim_writetlvchain(&fr->data, &otl);
-        
-        aim_freetlvchain(&itl);
-        aim_freetlvchain(&otl);
+        aim_tlvlist_add_frozentlvlist(&otl, 0x0005, &itl);
+
+        aim_tlvlist_write(&fr->data, &otl);
+        
+        aim_tlvlist_free(&itl);
+        aim_tlvlist_free(&otl);
         
         aim_tx_enqueue(sess, fr);
@@ -621 +621 @@
          * Start parsing TLVs right away. 
          */
-        otl = aim_readtlvchain(bs);
+        otl = aim_tlvlist_read(bs);
 
         /*
          * Type 0x0003: Source User Information
          */
-        if (aim_gettlv(otl, 0x0003, 1)) {
+        if (aim_tlv_gettlv(otl, 0x0003, 1)) {
                 aim_tlv_t *userinfotlv;
                 aim_bstream_t tbs;
 
-                userinfotlv = aim_gettlv(otl, 0x0003, 1);
+                userinfotlv = aim_tlv_gettlv(otl, 0x0003, 1);
 
                 aim_bstream_init(&tbs, userinfotlv->value, userinfotlv->length);
@@ -640 +640 @@
          * room (as opposed to a whisper).
          */
-        if (aim_gettlv(otl, 0x0001, 1))
+        if (aim_tlv_gettlv(otl, 0x0001, 1))
                 ;
 
@@ -646 +646 @@
          * Type 0x0005: Message Block.  Conains more TLVs.
          */
-        if (aim_gettlv(otl, 0x0005, 1)) {
+        if (aim_tlv_gettlv(otl, 0x0005, 1)) {
                 aim_tlvlist_t *itl;
                 aim_tlv_t *msgblock;
                 aim_bstream_t tbs;
 
-                msgblock = aim_gettlv(otl, 0x0005, 1);
+                msgblock = aim_tlv_gettlv(otl, 0x0005, 1);
                 aim_bstream_init(&tbs, msgblock->value, msgblock->length);
-                itl = aim_readtlvchain(&tbs);
+                itl = aim_tlvlist_read(&tbs);
 
                 /* 
                  * Type 0x0001: Message.
                  */     
-                if (aim_gettlv(itl, 0x0001, 1))
-                        msg = aim_gettlv_str(itl, 0x0001, 1);
-
-                aim_freetlvchain(&itl); 
+                if (aim_tlv_gettlv(itl, 0x0001, 1))
+                        msg = aim_tlv_getstr(itl, 0x0001, 1);
+
+                aim_tlvlist_free(&itl); 
         }
 
@@ -670 +670 @@
         free(cookie);
         free(msg);
-        aim_freetlvchain(&otl);
+        aim_tlvlist_free(&otl);
 
         return ret;

libfaim/chatnav.c

@@ -68 +68 @@
         aimbs_put8(&fr->data, 0x01);
 
-        aim_addtlvtochain_raw(&tl, 0x00d3, strlen(name), name);
-        aim_addtlvtochain_raw(&tl, 0x00d6, strlen(charset), charset);
-        aim_addtlvtochain_raw(&tl, 0x00d7, strlen(lang), lang);
+        aim_tlvlist_add_raw(&tl, 0x00d3, strlen(name), name);
+        aim_tlvlist_add_raw(&tl, 0x00d6, strlen(charset), charset);
+        aim_tlvlist_add_raw(&tl, 0x00d7, strlen(lang), lang);
 
         /* tlvcount */
-        aimbs_put16(&fr->data, aim_counttlvchain(&tl));
-        aim_writetlvchain(&fr->data, &tl);
-
-        aim_freetlvchain(&tl);
+        aimbs_put16(&fr->data, aim_tlvlist_count(&tl));
+        aim_tlvlist_write(&fr->data, &tl);
+
+        aim_tlvlist_free(&tl);
 
         aim_tx_enqueue(sess, fr);
@@ -93 +93 @@
         aim_tlvlist_t *tlvlist, *innerlist;
 
-        tlvlist = aim_readtlvchain(bs);
+        tlvlist = aim_tlvlist_read(bs);
 
         /* 
          * Type 0x0002: Maximum concurrent rooms.
          */ 
-        if (aim_gettlv(tlvlist, 0x0002, 1))
-                maxrooms = aim_gettlv8(tlvlist, 0x0002, 1);
+        if (aim_tlv_gettlv(tlvlist, 0x0002, 1))
+                maxrooms = aim_tlv_get8(tlvlist, 0x0002, 1);
 
         /* 
@@ -108 +108 @@
          * 
          */
-        for (curexchange = 0; ((exchangetlv = aim_gettlv(tlvlist, 0x0003, curexchange+1))); ) {
+        for (curexchange = 0; ((exchangetlv = aim_tlv_gettlv(tlvlist, 0x0003, curexchange+1))); ) {
                 aim_bstream_t tbs;
 
@@ -119 +119 @@
                 /* exchange number */
                 exchanges[curexchange-1].number = aimbs_get16(&tbs);
-                innerlist = aim_readtlvchain(&tbs);
+                innerlist = aim_tlvlist_read(&tbs);
 
                 /* 
@@ -127 +127 @@
                  *
                  */
-                if (aim_gettlv(innerlist, 0x000a, 1))
+                if (aim_tlv_gettlv(innerlist, 0x000a, 1))
                         ;
 
@@ -133 +133 @@
                  * Type 0x000d: Unknown.
                  */
-                if (aim_gettlv(innerlist, 0x000d, 1))
+                if (aim_tlv_gettlv(innerlist, 0x000d, 1))
                         ;
 
@@ -139 +139 @@
                  * Type 0x0004: Unknown
                  */
-                if (aim_gettlv(innerlist, 0x0004, 1))
+                if (aim_tlv_gettlv(innerlist, 0x0004, 1))
                         ;
 
@@ -145 +145 @@
                  * Type 0x0002: Unknown
                  */
-                if (aim_gettlv(innerlist, 0x0002, 1)) {
+                if (aim_tlv_gettlv(innerlist, 0x0002, 1)) {
                         fu16_t classperms;
 
-                        classperms = aim_gettlv16(innerlist, 0x0002, 1);
+                        classperms = aim_tlv_get16(innerlist, 0x0002, 1);
                         
                         faimdprintf(sess, 1, "faim: class permissions %x\n", classperms);
@@ -162 +162 @@
                  *
                  */ 
-                if (aim_gettlv(innerlist, 0x00c9, 1))
-                        exchanges[curexchange-1].flags = aim_gettlv16(innerlist, 0x00c9, 1);
+                if (aim_tlv_gettlv(innerlist, 0x00c9, 1))
+                        exchanges[curexchange-1].flags = aim_tlv_get16(innerlist, 0x00c9, 1);
                       
                 /*
                  * Type 0x00ca: Creation Date 
                  */
-                if (aim_gettlv(innerlist, 0x00ca, 1))
+                if (aim_tlv_gettlv(innerlist, 0x00ca, 1))
                         ;
                       
@@ -174 +174 @@
                  * Type 0x00d0: Mandatory Channels?
                  */
-                if (aim_gettlv(innerlist, 0x00d0, 1))
+                if (aim_tlv_gettlv(innerlist, 0x00d0, 1))
                         ;
 
@@ -180 +180 @@
                  * Type 0x00d1: Maximum Message length
                  */
-                if (aim_gettlv(innerlist, 0x00d1, 1))
+                if (aim_tlv_gettlv(innerlist, 0x00d1, 1))
                         ;
 
@@ -186 +186 @@
                  * Type 0x00d2: Maximum Occupancy?
                  */
-                if (aim_gettlv(innerlist, 0x00d2, 1))   
+                if (aim_tlv_gettlv(innerlist, 0x00d2, 1))       
                         ;
 
@@ -192 +192 @@
                  * Type 0x00d3: Exchange Description
                  */
-                if (aim_gettlv(innerlist, 0x00d3, 1))   
-                        exchanges[curexchange-1].name = aim_gettlv_str(innerlist, 0x00d3, 1);
+                if (aim_tlv_gettlv(innerlist, 0x00d3, 1))       
+                        exchanges[curexchange-1].name = aim_tlv_getstr(innerlist, 0x00d3, 1);
                 else
                         exchanges[curexchange-1].name = NULL;
@@ -200 +200 @@
                  * Type 0x00d4: Exchange Description URL
                  */
-                if (aim_gettlv(innerlist, 0x00d4, 1))   
+                if (aim_tlv_gettlv(innerlist, 0x00d4, 1))       
                         ;
 
@@ -211 +211 @@
                  * 
                  */
-                if (aim_gettlv(innerlist, 0x00d5, 1)) {
+                if (aim_tlv_gettlv(innerlist, 0x00d5, 1)) {
                         fu8_t createperms;
 
-                        createperms = aim_gettlv8(innerlist, 0x00d5, 1);
+                        createperms = aim_tlv_get8(innerlist, 0x00d5, 1);
                 }
 
@@ -220 +220 @@
                  * Type 0x00d6: Character Set (First Time)
                  */           
-                if (aim_gettlv(innerlist, 0x00d6, 1))   
-                        exchanges[curexchange-1].charset1 = aim_gettlv_str(innerlist, 0x00d6, 1);
+                if (aim_tlv_gettlv(innerlist, 0x00d6, 1))       
+                        exchanges[curexchange-1].charset1 = aim_tlv_getstr(innerlist, 0x00d6, 1);
                 else
                         exchanges[curexchange-1].charset1 = NULL;
@@ -228 +228 @@
                  * Type 0x00d7: Language (First Time)
                  */           
-                if (aim_gettlv(innerlist, 0x00d7, 1))   
-                        exchanges[curexchange-1].lang1 = aim_gettlv_str(innerlist, 0x00d7, 1);
+                if (aim_tlv_gettlv(innerlist, 0x00d7, 1))       
+                        exchanges[curexchange-1].lang1 = aim_tlv_getstr(innerlist, 0x00d7, 1);
                 else
                         exchanges[curexchange-1].lang1 = NULL;
@@ -236 +236 @@
                  * Type 0x00d8: Character Set (Second Time)
                  */           
-                if (aim_gettlv(innerlist, 0x00d8, 1))   
-                        exchanges[curexchange-1].charset2 = aim_gettlv_str(innerlist, 0x00d8, 1);
+                if (aim_tlv_gettlv(innerlist, 0x00d8, 1))       
+                        exchanges[curexchange-1].charset2 = aim_tlv_getstr(innerlist, 0x00d8, 1);
                 else
                         exchanges[curexchange-1].charset2 = NULL;
@@ -244 +244 @@
                  * Type 0x00d9: Language (Second Time)
                  */           
-                if (aim_gettlv(innerlist, 0x00d9, 1))   
-                        exchanges[curexchange-1].lang2 = aim_gettlv_str(innerlist, 0x00d9, 1);
+                if (aim_tlv_gettlv(innerlist, 0x00d9, 1))       
+                        exchanges[curexchange-1].lang2 = aim_tlv_getstr(innerlist, 0x00d9, 1);
                 else
                         exchanges[curexchange-1].lang2 = NULL;
@@ -252 +252 @@
                  * Type 0x00da: Unknown
                  */
-                if (aim_gettlv(innerlist, 0x00da, 1))   
-                        ;
-
-                aim_freetlvchain(&innerlist);
+                if (aim_tlv_gettlv(innerlist, 0x00da, 1))       
+                        ;
+
+                aim_tlvlist_free(&innerlist);
         }
 
@@ -272 +272 @@
         }
         free(exchanges);
-        aim_freetlvchain(&tlvlist);
+        aim_tlvlist_free(&tlvlist);
 
         return ret;
@@ -290 +290 @@
         aim_bstream_t bbbs;
 
-        tlvlist = aim_readtlvchain(bs);
-
-        if (!(bigblock = aim_gettlv(tlvlist, 0x0004, 1))) {
+        tlvlist = aim_tlvlist_read(bs);
+
+        if (!(bigblock = aim_tlv_gettlv(tlvlist, 0x0004, 1))) {
                 faimdprintf(sess, 0, "no bigblock in top tlv in create room response\n");
-                aim_freetlvchain(&tlvlist);
+                aim_tlvlist_free(&tlvlist);
                 return 0;
         }
@@ -308 +308 @@
         if (detaillevel != 0x02) {
                 faimdprintf(sess, 0, "unknown detaillevel in create room response (0x%02x)\n", detaillevel);
-                aim_freetlvchain(&tlvlist);
+                aim_tlvlist_free(&tlvlist);
                 free(ck);
                 return 0;
@@ -315 +315 @@
         unknown = aimbs_get16(&bbbs);
 
-        innerlist = aim_readtlvchain(&bbbs);
-
-        if (aim_gettlv(innerlist, 0x006a, 1))
-                fqcn = aim_gettlv_str(innerlist, 0x006a, 1);
-
-        if (aim_gettlv(innerlist, 0x00c9, 1))
-                flags = aim_gettlv16(innerlist, 0x00c9, 1);
-
-        if (aim_gettlv(innerlist, 0x00ca, 1))
-                createtime = aim_gettlv32(innerlist, 0x00ca, 1);
-
-        if (aim_gettlv(innerlist, 0x00d1, 1))
-                maxmsglen = aim_gettlv16(innerlist, 0x00d1, 1);
-
-        if (aim_gettlv(innerlist, 0x00d2, 1))
-                maxoccupancy = aim_gettlv16(innerlist, 0x00d2, 1);
-
-        if (aim_gettlv(innerlist, 0x00d3, 1))
-                name = aim_gettlv_str(innerlist, 0x00d3, 1);
-
-        if (aim_gettlv(innerlist, 0x00d5, 1))
-                createperms = aim_gettlv8(innerlist, 0x00d5, 1);
+        innerlist = aim_tlvlist_read(&bbbs);
+
+        if (aim_tlv_gettlv(innerlist, 0x006a, 1))
+                fqcn = aim_tlv_getstr(innerlist, 0x006a, 1);
+
+        if (aim_tlv_gettlv(innerlist, 0x00c9, 1))
+                flags = aim_tlv_get16(innerlist, 0x00c9, 1);
+
+        if (aim_tlv_gettlv(innerlist, 0x00ca, 1))
+                createtime = aim_tlv_get32(innerlist, 0x00ca, 1);
+
+        if (aim_tlv_gettlv(innerlist, 0x00d1, 1))
+                maxmsglen = aim_tlv_get16(innerlist, 0x00d1, 1);
+
+        if (aim_tlv_gettlv(innerlist, 0x00d2, 1))
+                maxoccupancy = aim_tlv_get16(innerlist, 0x00d2, 1);
+
+        if (aim_tlv_gettlv(innerlist, 0x00d3, 1))
+                name = aim_tlv_getstr(innerlist, 0x00d3, 1);
+
+        if (aim_tlv_gettlv(innerlist, 0x00d5, 1))
+                createperms = aim_tlv_get8(innerlist, 0x00d5, 1);
 
         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) {
@@ -345 +345 @@
         free(name);
         free(fqcn);
-        aim_freetlvchain(&innerlist);
-        aim_freetlvchain(&tlvlist);
+        aim_tlvlist_free(&innerlist);
+        aim_tlvlist_free(&tlvlist);
 
         return ret;

libfaim/conn.c

@@ -192 +192 @@
 
 /**
- * aim_connrst - Clears out connection list, killing remaining connections.
- * @sess: Session to be cleared
- *
- * Clears out the connection list and kills any connections left.
- *
+ * Clears out connection list, killing remaining connections.
+ *
+ * @param sess Session to be cleared
  */
 static void aim_connrst(aim_session_t *sess)
@@ -218 +216 @@
 
 /**
- * aim_conn_init - Reset a connection to default values.
- * @deadconn: Connection to be reset
- *
+ * Reset a connection to default values.
  * Initializes and/or resets a connection structure.
  *
+ * @param deadconn Connection to be reset
  */
 static void aim_conn_init(aim_conn_t *deadconn)
@@ -533 +530 @@
                 fd = socket(hp->h_addrtype, SOCK_STREAM, 0);
 
-                if (sess->flags & AIM_SESS_FLAGS_NONBLOCKCONNECT)
+                if (sess->nonblocking)
                         fcntl(fd, F_SETFL, O_NONBLOCK); /* XXX save flags */
 
                 if (connect(fd, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0) {
-                        if (sess->flags & AIM_SESS_FLAGS_NONBLOCKCONNECT) {
+                        if (sess->nonblocking) {
                                 if ((errno == EINPROGRESS) || (errno == EINTR)) {
                                         if (statusret)
@@ -853 +850 @@
 
 /**
- * aim_session_init - Initializes a session structure
- * @sess: Session to initialize
- * @flags: Flags to use. Any of %AIM_SESS_FLAGS %OR'd together.
- * @debuglevel: Level of debugging output (zero is least)
- *
- * Sets up the initial values for a session.
- *
- */
-faim_export void aim_session_init(aim_session_t *sess, fu32_t flags, int debuglevel)
+ * Initializes a session structure by setting the initial values 
+ * stuff in the aim_session_t struct.
+ *
+ * @param sess Session to initialize.
+ * @param nonblocking Set to true if you want connections to be non-blocking.
+ * @param debuglevel Level of debugging output (zero is least).
+ */
+faim_export void aim_session_init(aim_session_t *sess, bool nonblocking, int debuglevel)
 {
 
@@ -873 +869 @@
         aim_initsnachash(sess);
         sess->msgcookies = NULL;
-        sess->icq_info = NULL;
-        sess->oft_info = NULL;
-        sess->snacid_next = 0x00000001;
-
-        sess->flags = 0;
+        sess->nonblocking = nonblocking;
         sess->debug = debuglevel;
         sess->debugcb = defaultdebugcb;
-
         sess->modlistv = NULL;
-
+        sess->snacid_next = 0x00000001;
+
+        sess->locate.userinfo = NULL;
+        sess->locate.torequest = NULL;
+        sess->locate.requested = NULL;
+        sess->locate.waiting_for_response = FALSE;
         sess->ssi.received_data = 0;
         sess->ssi.numitems = 0;
@@ -890 +886 @@
         sess->ssi.timestamp = (time_t)0;
         sess->ssi.waiting_for_ack = 0;
-
+        sess->icq_info = NULL;
         sess->authinfo = NULL;
         sess->emailinfo = NULL;
-
-        /*
-         * Default to SNAC login unless XORLOGIN is explicitly set.
-         */
-        if (!(flags & AIM_SESS_FLAGS_XORLOGIN))
-                sess->flags |= AIM_SESS_FLAGS_SNACLOGIN;
-        sess->flags |= flags;
+        sess->oft_info = NULL;
 
         /*
@@ -907 +897 @@
         aim_tx_setenqueue(sess, AIM_TX_QUEUED, NULL);
 
-
         /*
          * Register all the modules for this session...
          */
         aim__registermodule(sess, misc_modfirst); /* load the catch-all first */
-        aim__registermodule(sess, general_modfirst);
+        aim__registermodule(sess, service_modfirst);
         aim__registermodule(sess, locate_modfirst);
         aim__registermodule(sess, buddylist_modfirst);
@@ -926 +915 @@
         aim__registermodule(sess, chatnav_modfirst);
         aim__registermodule(sess, chat_modfirst);
-        /*      aim__registermodule(sess, odir_modfirst); */ /* kretch */
-        /*      aim__registermodule(sess, bart_modfirst); */ /* kretch */
+        aim__registermodule(sess, odir_modfirst);
+        aim__registermodule(sess, bart_modfirst);
         /* missing 0x11 - 0x12 */
         aim__registermodule(sess, ssi_modfirst);
@@ -1058 +1047 @@
         aim_tx_enqueue(sess, fr);
 
+        /* clean out SNACs over 60sec old */
+        aim_cleansnacs(sess, 60);
+
         return 0;
 }

libfaim/email.c

@@ -19 +19 @@
  * @return Return 0 if no errors, otherwise return the error number.
  */
-faim_export int aim_email_sendcookies(aim_session_t *sess, aim_conn_t *conn)
-{
+faim_export int aim_email_sendcookies(aim_session_t *sess)
+{
+        aim_conn_t *conn;
         aim_frame_t *fr;
         aim_snacid_t snacid;
 
-        if (!sess || !conn)
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_EML)))
                 return -EINVAL;
 
@@ -81 +82 @@
         fu8_t *cookie8, *cookie16;
         int tmp, havenewmail = 0; /* Used to tell the client we have _new_ mail */
+
+        char *alertitle = NULL, *alerturl = NULL;
 
         cookie8 = aimbs_getraw(bs, 8); /* Possibly the code used to log you in to mail? */
@@ -105 +108 @@
         new->cookie16 = cookie16;
 
-        tlvlist = aim_readtlvchain_num(bs, aimbs_get16(bs));
-
-        tmp = aim_gettlv16(tlvlist, 0x0080, 1);
+        tlvlist = aim_tlvlist_readnum(bs, aimbs_get16(bs));
+
+        tmp = aim_tlv_get16(tlvlist, 0x0080, 1);
         if (tmp) {
                 if (new->nummsgs < tmp)
@@ -118 +121 @@
                 new->nummsgs++; /* We know we have at least 1 new email */
         }
-        new->url = aim_gettlv_str(tlvlist, 0x0007, 1);
-        if (!(new->unread = aim_gettlv8(tlvlist, 0x0081, 1))) {
+        new->url = aim_tlv_getstr(tlvlist, 0x0007, 1);
+        if (!(new->unread = aim_tlv_get8(tlvlist, 0x0081, 1))) {
                 havenewmail = 0;
                 new->nummsgs = 0;
         }
-        new->domain = aim_gettlv_str(tlvlist, 0x0082, 1);
-        new->flag = aim_gettlv16(tlvlist, 0x0084, 1);
-
+        new->domain = aim_tlv_getstr(tlvlist, 0x0082, 1);
+        new->flag = aim_tlv_get16(tlvlist, 0x0084, 1);
+
+        alertitle = aim_tlv_getstr(tlvlist, 0x0005, 1);
+        alerturl  = aim_tlv_getstr(tlvlist, 0x000d, 1);
+        
         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
-                ret = userfunc(sess, rx, new, havenewmail);
-
-        aim_freetlvchain(&tlvlist);
+                ret = userfunc(sess, rx, new, havenewmail, alertitle, (alerturl ? alerturl + 2 : NULL));
+
+        aim_tlvlist_free(&tlvlist);
+
+        free(alertitle);
+        free(alerturl);
 
         return ret;
@@ -141 +150 @@
  * @return Return 0 if no errors, otherwise return the error number.
  */
-faim_export int aim_email_activate(aim_session_t *sess, aim_conn_t *conn)
-{
+faim_export int aim_email_activate(aim_session_t *sess)
+{
+        aim_conn_t *conn;
         aim_frame_t *fr;
         aim_snacid_t snacid;
 
-        if (!sess || !conn)
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_EML)))
                 return -EINVAL;
 

libfaim/ft.c

@@ -259 +259 @@
                 return 0; /* not an error */
 
-        if (addr.sa_family != AF_INET) { /* just in case IPv6 really is happening */
+        if ((addr.sa_family != AF_INET) && (addr.sa_family != AF_INET6)) { /* just in case IPv6 really is happening */
                 close(acceptfd);
                 aim_conn_close(cur);

libfaim/icq.c

@@ -317 +317 @@
 
         aim_tx_enqueue(sess, fr);
+
+        return 0;
+}
+
+/*
+ * Send an SMS message.  This is the non-US way.  The US-way is to IM 
+ * their cell phone number (+19195551234).
+ *
+ * We basically construct and send an XML message.  The format is:
+ * <icq_sms_message>
+ *   <destination>full_phone_without_leading_+</destination>
+ *   <text>message</text>
+ *   <codepage>1252</codepage>
+ *   <senders_UIN>self_uin</senders_UIN>
+ *   <senders_name>self_name</senders_name>
+ *   <delivery_receipt>Yes|No</delivery_receipt>
+ *   <time>Wkd, DD Mmm YYYY HH:MM:SS TMZ</time>
+ * </icq_sms_message>
+ *
+ * Yeah hi Peter, whaaaat's happening.  If there's any way to use 
+ * a codepage other than 1252 that would be great.  Thaaaanks.
+ */
+faim_export int aim_icq_sendsms(aim_session_t *sess, const char *name, const char *msg, const char *alias)
+{
+        aim_conn_t *conn;
+        aim_frame_t *fr;
+        aim_snacid_t snacid;
+        int bslen, xmllen;
+        char *xml, timestr[30];
+        time_t t;
+        struct tm *tm;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, 0x0015)))
+                return -EINVAL;
+
+        if (!name || !msg || !alias)
+                return -EINVAL;
+
+        time(&t);
+        tm = gmtime(&t);
+        strftime(timestr, 30, "%a, %d %b %Y %T %Z", tm);
+
+        /* The length of xml included the null terminating character */
+        xmllen = 225 + strlen(name) + strlen(msg) + strlen(sess->sn) + strlen(alias) + strlen(timestr) + 1;
+
+        if (!(xml = (char *)malloc(xmllen*sizeof(char))))
+                return -ENOMEM;
+        snprintf(xml, xmllen, "<icq_sms_message>\n"
+                "\t<destination>%s</destination>\n"
+                "\t<text>%s</text>\n"
+                "\t<codepage>1252</codepage>\n"
+                "\t<senders_UIN>%s</senders_UIN>\n"
+                "\t<senders_name>%s</senders_name>\n"
+                "\t<delivery_receipt>Yes</delivery_receipt>\n"
+                "\t<time>%s</time>\n"
+                "</icq_sms_message>\n",
+                name, msg, sess->sn, alias, timestr);
+
+        bslen = 37 + xmllen;
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 4 + bslen))) {
+                free(xml);
+                return -ENOMEM;
+        }
+
+        snacid = aim_cachesnac(sess, 0x0015, 0x0002, 0x0000, NULL, 0);
+        aim_putsnac(&fr->data, 0x0015, 0x0002, 0x0000, snacid);
+
+        /* For simplicity, don't bother using a tlvlist */
+        aimbs_put16(&fr->data, 0x0001);
+        aimbs_put16(&fr->data, bslen);
+
+        aimbs_putle16(&fr->data, bslen - 2);
+        aimbs_putle32(&fr->data, atoi(sess->sn));
+        aimbs_putle16(&fr->data, 0x07d0); /* I command thee. */
+        aimbs_putle16(&fr->data, snacid); /* eh. */
+
+        /* From libicq200-0.3.2/src/SNAC-SRV.cpp */
+        aimbs_putle16(&fr->data, 0x8214);
+        aimbs_put16(&fr->data, 0x0001);
+        aimbs_put16(&fr->data, 0x0016);
+        aimbs_put32(&fr->data, 0x00000000);
+        aimbs_put32(&fr->data, 0x00000000);
+        aimbs_put32(&fr->data, 0x00000000);
+        aimbs_put32(&fr->data, 0x00000000);
+
+        aimbs_put16(&fr->data, 0x0000);
+        aimbs_put16(&fr->data, xmllen);
+        aimbs_putraw(&fr->data, xml, xmllen);
+
+        aim_tx_enqueue(sess, fr);
+
+        free(xml);
 
         return 0;
@@ -368 +461 @@
         fu16_t cmdlen, cmd, reqid;
 
-        if (!(tl = aim_readtlvchain(bs)) || !(datatlv = aim_gettlv(tl, 0x0001, 1))) {
-                aim_freetlvchain(&tl);
+        if (!(tl = aim_tlvlist_read(bs)) || !(datatlv = aim_tlv_gettlv(tl, 0x0001, 1))) {
+                aim_tlvlist_free(&tl);
                 faimdprintf(sess, 0, "corrupt ICQ response\n");
                 return 0;
@@ -549 +642 @@
         }
 
-        aim_freetlvchain(&tl);
+        aim_tlvlist_free(&tl);
 
         return ret;

libfaim/im.c

@@ -167 +167 @@
                 return -EINVAL;
 
-        return aim_genericreq_n(sess, conn, 0x0004, 0x0004);
+        return aim_genericreq_n_snacid(sess, conn, 0x0004, 0x0004);
 }
 
@@ -390 +390 @@
         aim_tx_enqueue(sess, fr);
 
-        /* Move this to receive aim_flap_nop and send aim_flap_nop */
-        if (!(sess->flags & AIM_SESS_FLAGS_DONTTIMEOUTONICBM))
-                aim_cleansnacs(sess, 60); /* clean out SNACs over 60sec old */
+        /* clean out SNACs over 60sec old */
+        aim_cleansnacs(sess, 60);
 
         return 0;
@@ -633 +632 @@
         aim_im_puticbm(&fr->data, ck, 0x0002, sn);
 
-        aim_addtlvtochain_noval(&tl, 0x0003);
+        aim_tlvlist_add_noval(&tl, 0x0003);
 
         hdrlen = 2+8+16+6+8+6+4;
@@ -643 +642 @@
         aim_putcap(&hdrbs, AIM_CAPS_DIRECTIM);
 
-        aim_addtlvtochain16(&itl, 0x000a, 0x0001);
-        aim_addtlvtochain_raw(&itl, 0x0003, 4, ip);
-        aim_addtlvtochain16(&itl, 0x0005, port);
-        aim_addtlvtochain_noval(&itl, 0x000f);
+        aim_tlvlist_add_16(&itl, 0x000a, 0x0001);
+        aim_tlvlist_add_raw(&itl, 0x0003, 4, ip);
+        aim_tlvlist_add_16(&itl, 0x0005, port);
+        aim_tlvlist_add_noval(&itl, 0x000f);
         
-        aim_writetlvchain(&hdrbs, &itl);
-
-        aim_addtlvtochain_raw(&tl, 0x0005, aim_bstream_curpos(&hdrbs), hdr);
-
-        aim_writetlvchain(&fr->data, &tl);
+        aim_tlvlist_write(&hdrbs, &itl);
+
+        aim_tlvlist_add_raw(&tl, 0x0005, aim_bstream_curpos(&hdrbs), hdr);
+
+        aim_tlvlist_write(&fr->data, &tl);
 
         free(hdr);
-        aim_freetlvchain(&itl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_free(&itl);
+        aim_tlvlist_free(&tl);
 
         aim_tx_enqueue(sess, fr);
@@ -688 +687 @@
                 aim_bstream_t bs;
 
-                aim_addtlvtochain16(&subtl, 0x000a, 0x0001);
-                aim_addtlvtochain_noval(&subtl, 0x000f);
-/*              aim_addtlvtochain_raw(&subtl, 0x000e, 2, "en");
-                aim_addtlvtochain_raw(&subtl, 0x000d, 8, "us-ascii");
-                aim_addtlvtochain_raw(&subtl, 0x000c, 24, "Please accept this file."); */
+                aim_tlvlist_add_16(&subtl, 0x000a, 0x0001);
+                aim_tlvlist_add_noval(&subtl, 0x000f);
+/*              aim_tlvlist_add_raw(&subtl, 0x000e, 2, "en");
+                aim_tlvlist_add_raw(&subtl, 0x000d, 8, "us-ascii");
+                aim_tlvlist_add_raw(&subtl, 0x000c, 24, "Please accept this file."); */
                 if (oft_info->clientip) {
                         fu8_t ip[4];
@@ -703 +702 @@
                                 i++;
                         }
-                        aim_addtlvtochain_raw(&subtl, 0x0003, 4, ip);
+                        aim_tlvlist_add_raw(&subtl, 0x0003, 4, ip);
                 }
-                aim_addtlvtochain16(&subtl, 0x0005, oft_info->port);
+                aim_tlvlist_add_16(&subtl, 0x0005, oft_info->port);
 
                 /* TLV t(2711) */
@@ -719 +718 @@
                 aimbs_put8(&bs, 0x00);
 
-                aim_addtlvtochain_raw(&subtl, 0x2711, bs.len, bs.data);
+                aim_tlvlist_add_raw(&subtl, 0x2711, bs.len, bs.data);
                 free(buf);
         }
@@ -729 +728 @@
 
                 /* TLV t(0005) - Encompasses everything from above. Gee. */
-                buflen = 2+8+16+aim_sizetlvchain(&subtl);
+                buflen = 2+8+16+aim_tlvlist_size(&subtl);
                 buf = malloc(buflen);
                 aim_bstream_init(&bs, buf, buflen);
@@ -735 +734 @@
                 aimbs_putraw(&bs, oft_info->cookie, 8);
                 aim_putcap(&bs, AIM_CAPS_SENDFILE);
-                aim_writetlvchain(&bs, &subtl);
-                aim_freetlvchain(&subtl);
-                aim_addtlvtochain_raw(&tl, 0x0005, bs.len, bs.data);
+                aim_tlvlist_write(&bs, &subtl);
+                aim_tlvlist_free(&subtl);
+                aim_tlvlist_add_raw(&tl, 0x0005, bs.len, bs.data);
                 free(buf);
 
                 /* TLV t(0003) - Request an ack */
-                aim_addtlvtochain_noval(&tl, 0x0003);
-        }
-
-        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 11+strlen(oft_info->sn) + aim_sizetlvchain(&tl))))
+                aim_tlvlist_add_noval(&tl, 0x0003);
+        }
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 11+strlen(oft_info->sn) + aim_tlvlist_size(&tl))))
                 return -ENOMEM;
 
@@ -754 +753 @@
 
         /* All that crap from above (the 0x0005 TLV and the 0x0003 TLV) */
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
 
         aim_tx_enqueue(sess, fr);
@@ -1033 +1032 @@
         sn = aimbs_getstr(bs, snlen);
 
-        tlvlist = aim_readtlvchain(bs);
-
-        if (aim_gettlv(tlvlist, 0x0003, 1))
+        tlvlist = aim_tlvlist_read(bs);
+
+        if (aim_tlv_gettlv(tlvlist, 0x0003, 1))
                 icbmflags |= AIM_IMFLAGS_ACK;
-        if (aim_gettlv(tlvlist, 0x0004, 1))
+        if (aim_tlv_gettlv(tlvlist, 0x0004, 1))
                 icbmflags |= AIM_IMFLAGS_AWAY;
 
-        if ((msgblock = aim_gettlv(tlvlist, 0x0002, 1))) {
+        if ((msgblock = aim_tlv_gettlv(tlvlist, 0x0002, 1))) {
                 aim_bstream_t mbs;
                 int featurelen, msglen;
@@ -1065 +1064 @@
 
         free(sn);
-        aim_freetlvchain(&tlvlist);
+        aim_tlvlist_free(&tlvlist);
 
         return ret;
@@ -1655 +1654 @@
          * There's another block of TLVs embedded in the type 5 here. 
          */
-        block1 = aim_gettlv(tlvlist, 0x0005, 1);
+        block1 = aim_tlv_gettlv(tlvlist, 0x0005, 1);
         aim_bstream_init(&bbs, block1->value, block1->length);
 
@@ -1678 +1677 @@
          * identify what type of rendezvous this is.
          */
-        args.reqclass = aim_getcap(sess, &bbs, 0x10);
+        args.reqclass = aim_locate_getcaps(sess, &bbs, 0x10);
 
         /* 
@@ -1686 +1685 @@
          * Ack packets for instance have nothing more to them.
          */
-        list2 = aim_readtlvchain(&bbs);
+        list2 = aim_tlvlist_read(&bbs);
 
         /*
@@ -1693 +1692 @@
          * XXX - I don't like this.  Maybe just read in an int?  Or inet_ntoa...
          */
-        if (aim_gettlv(list2, 0x0002, 1)) {
+        if (aim_tlv_gettlv(list2, 0x0002, 1)) {
                 aim_tlv_t *iptlv;
 
-                iptlv = aim_gettlv(list2, 0x0002, 1);
+                iptlv = aim_tlv_gettlv(list2, 0x0002, 1);
                 if (iptlv->length == 4)
-                        snprintf(proxyip, sizeof(proxyip), "%hhd.%hhd.%hhd.%hhd",
+                        snprintf(proxyip, sizeof(proxyip), "%hhu.%hhu.%hhu.%hhu",
                                 iptlv->value[0], iptlv->value[1],
                                 iptlv->value[2], iptlv->value[3]);
@@ -1706 +1705 @@
          * IP address from the perspective of the client.
          */
-        if (aim_gettlv(list2, 0x0003, 1)) {
+        if (aim_tlv_gettlv(list2, 0x0003, 1)) {
                 aim_tlv_t *iptlv;
 
-                iptlv = aim_gettlv(list2, 0x0003, 1);
+                iptlv = aim_tlv_gettlv(list2, 0x0003, 1);
                 if (iptlv->length == 4)
-                        snprintf(clientip, sizeof(clientip), "%hhd.%hhd.%hhd.%hhd",
+                        snprintf(clientip, sizeof(clientip), "%hhu.%hhu.%hhu.%hhu",
                                 iptlv->value[0], iptlv->value[1],
                                 iptlv->value[2], iptlv->value[3]);
@@ -1721 +1720 @@
          * This is added by the server.
          */
-        if (aim_gettlv(list2, 0x0004, 1)) {
+        if (aim_tlv_gettlv(list2, 0x0004, 1)) {
                 aim_tlv_t *iptlv;
 
-                iptlv = aim_gettlv(list2, 0x0004, 1);
+                iptlv = aim_tlv_gettlv(list2, 0x0004, 1);
                 if (iptlv->length == 4)
-                        snprintf(verifiedip, sizeof(verifiedip), "%hhd.%hhd.%hhd.%hhd",
+                        snprintf(verifiedip, sizeof(verifiedip), "%hhu.%hhu.%hhu.%hhu",
                                 iptlv->value[0], iptlv->value[1],
                                 iptlv->value[2], iptlv->value[3]);
@@ -1734 +1733 @@
          * Port number for something.
          */
-        if (aim_gettlv(list2, 0x0005, 1))
-                args.port = aim_gettlv16(list2, 0x0005, 1);
+        if (aim_tlv_gettlv(list2, 0x0005, 1))
+                args.port = aim_tlv_get16(list2, 0x0005, 1);
 
         /*
@@ -1742 +1741 @@
          * 0x0002 - "I will accept this file from you"
          */
-        if (aim_gettlv(list2, 0x000a, 1))
+        if (aim_tlv_gettlv(list2, 0x000a, 1))
                 ;
 
@@ -1748 +1747 @@
          * Error code.
          */
-        if (aim_gettlv(list2, 0x000b, 1))
-                args.errorcode = aim_gettlv16(list2, 0x000b, 1);
+        if (aim_tlv_gettlv(list2, 0x000b, 1))
+                args.errorcode = aim_tlv_get16(list2, 0x000b, 1);
 
         /*
          * Invitation message / chat description.
          */
-        if (aim_gettlv(list2, 0x000c, 1))
-                args.msg = aim_gettlv_str(list2, 0x000c, 1);
+        if (aim_tlv_gettlv(list2, 0x000c, 1))
+                args.msg = aim_tlv_getstr(list2, 0x000c, 1);
 
         /*
          * Character set.
          */
-        if (aim_gettlv(list2, 0x000d, 1))
-                args.encoding = aim_gettlv_str(list2, 0x000d, 1);
+        if (aim_tlv_gettlv(list2, 0x000d, 1))
+                args.encoding = aim_tlv_getstr(list2, 0x000d, 1);
         
         /*
          * Language.
          */
-        if (aim_gettlv(list2, 0x000e, 1))
-                args.language = aim_gettlv_str(list2, 0x000e, 1);
+        if (aim_tlv_gettlv(list2, 0x000e, 1))
+                args.language = aim_tlv_getstr(list2, 0x000e, 1);
 
         /*
@@ -1774 +1773 @@
          * Maybe means we should connect directly to transfer the file?
          */
-        if (aim_gettlv(list2, 0x000f, 1))
+        if (aim_tlv_gettlv(list2, 0x000f, 1))
                 ;
 
@@ -1782 +1781 @@
          * Maybe means we should proxy the file transfer through an AIM server?
          */
-        if (aim_gettlv(list2, 0x0010, 1))
+        if (aim_tlv_gettlv(list2, 0x0010, 1))
                 ;
 
@@ -1798 +1797 @@
          * Service Data blocks are module-specific in format.
          */
-        if ((servdatatlv = aim_gettlv(list2, 0x2711 /* 10001 */, 1))) {
+        if ((servdatatlv = aim_tlv_gettlv(list2, 0x2711 /* 10001 */, 1))) {
 
                 aim_bstream_init(&sdbs, servdatatlv->value, servdatatlv->length);
@@ -1832 +1831 @@
         free((char *)args.language);
 
-        aim_freetlvchain(&list2);
+        aim_tlvlist_free(&list2);
 
         return ret;
@@ -1848 +1847 @@
          * Make a bstream for the meaty part.  Yum.  Meat.
          */
-        if (!(block = aim_gettlv(tlvlist, 0x0005, 1)))
+        if (!(block = aim_tlv_gettlv(tlvlist, 0x0005, 1)))
                 return -1;
         aim_bstream_init(&meat, block->value, block->length);
@@ -1947 +1946 @@
                  * further data is derived from what is parsed here.
                  */
-                tlvlist = aim_readtlvchain(bs);
+                tlvlist = aim_tlvlist_read(bs);
 
                 ret = incomingim_ch2(sess, mod, rx, snac, channel, &userinfo, tlvlist, cookie);
 
-                aim_freetlvchain(&tlvlist);
+                aim_tlvlist_free(&tlvlist);
 
         } else if (channel == 4) {
                 aim_tlvlist_t *tlvlist;
 
-                tlvlist = aim_readtlvchain(bs);
+                tlvlist = aim_tlvlist_read(bs);
                 ret = incomingim_ch4(sess, mod, rx, snac, channel, &userinfo, tlvlist, cookie);
-                aim_freetlvchain(&tlvlist);
+                aim_tlvlist_free(&tlvlist);
 
         } else {
@@ -2056 +2055 @@
         aimbs_putraw(&fr->data, sender, strlen(sender));
 
-        aim_addtlvtochain16(&tl, 0x0003, code);
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_add_16(&tl, 0x0003, code);
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
 
         aim_tx_enqueue(sess, fr);

libfaim/misc.c

@@ -12 +12 @@
 /*
  * Generic routine for sending commands.
- *
  *
  * I know I can do this in a smarter way...but I'm not thinking straight

libfaim/odir.c

@@ -31 +31 @@
 
         /* Create a TLV chain, write it to the outgoing frame, then free the chain */
-        aim_addtlvtochain_raw(&tl, 0x001c, strlen(region), region);
-        aim_addtlvtochain16(&tl, 0x000a, 0x0001); /* Type of search */
-        aim_addtlvtochain_raw(&tl, 0x0005, strlen(email), email);
-
-        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+aim_sizetlvchain(&tl))))
+        aim_tlvlist_add_raw(&tl, 0x001c, strlen(region), region);
+        aim_tlvlist_add_16(&tl, 0x000a, 0x0001); /* Type of search */
+        aim_tlvlist_add_raw(&tl, 0x0005, strlen(email), email);
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+aim_tlvlist_size(&tl))))
                 return -ENOMEM;
         snacid = aim_cachesnac(sess, 0x000f, 0x0002, 0x0000, NULL, 0);
         aim_putsnac(&fr->data, 0x000f, 0x0002, 0x0000, snacid);
 
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
 
         aim_tx_enqueue(sess, fr);
@@ -80 +80 @@
 
         /* Create a TLV chain, write it to the outgoing frame, then free the chain */
-        aim_addtlvtochain_raw(&tl, 0x001c, strlen(region), region);
-        aim_addtlvtochain16(&tl, 0x000a, 0x0000); /* Type of search */
+        aim_tlvlist_add_raw(&tl, 0x001c, strlen(region), region);
+        aim_tlvlist_add_16(&tl, 0x000a, 0x0000); /* Type of search */
         if (first)
-                aim_addtlvtochain_raw(&tl, 0x0001, strlen(first), first);
+                aim_tlvlist_add_raw(&tl, 0x0001, strlen(first), first);
         if (last)
-                aim_addtlvtochain_raw(&tl, 0x0002, strlen(last), last);
+                aim_tlvlist_add_raw(&tl, 0x0002, strlen(last), last);
         if (middle)
-                aim_addtlvtochain_raw(&tl, 0x0003, strlen(middle), middle);
+                aim_tlvlist_add_raw(&tl, 0x0003, strlen(middle), middle);
         if (maiden)
-                aim_addtlvtochain_raw(&tl, 0x0004, strlen(maiden), maiden);
+                aim_tlvlist_add_raw(&tl, 0x0004, strlen(maiden), maiden);
         if (country)
-                aim_addtlvtochain_raw(&tl, 0x0006, strlen(country), country);
+                aim_tlvlist_add_raw(&tl, 0x0006, strlen(country), country);
         if (state)
-                aim_addtlvtochain_raw(&tl, 0x0007, strlen(state), state);
+                aim_tlvlist_add_raw(&tl, 0x0007, strlen(state), state);
         if (city)
-                aim_addtlvtochain_raw(&tl, 0x0008, strlen(city), city);
+                aim_tlvlist_add_raw(&tl, 0x0008, strlen(city), city);
         if (nick)
-                aim_addtlvtochain_raw(&tl, 0x000c, strlen(nick), nick);
+                aim_tlvlist_add_raw(&tl, 0x000c, strlen(nick), nick);
         if (zip)
-                aim_addtlvtochain_raw(&tl, 0x000d, strlen(zip), zip);
+                aim_tlvlist_add_raw(&tl, 0x000d, strlen(zip), zip);
         if (address)
-                aim_addtlvtochain_raw(&tl, 0x0021, strlen(address), address);
-
-        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+aim_sizetlvchain(&tl))))
+                aim_tlvlist_add_raw(&tl, 0x0021, strlen(address), address);
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+aim_tlvlist_size(&tl))))
                 return -ENOMEM;
         snacid = aim_cachesnac(sess, 0x000f, 0x0002, 0x0000, NULL, 0);
         aim_putsnac(&fr->data, 0x000f, 0x0002, 0x0000, snacid);
 
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
 
         aim_tx_enqueue(sess, fr);
@@ -135 +135 @@
 
         /* Create a TLV chain, write it to the outgoing frame, then free the chain */
-        aim_addtlvtochain_raw(&tl, 0x001c, strlen(region), region);
-        aim_addtlvtochain16(&tl, 0x000a, 0x0001); /* Type of search */
+        aim_tlvlist_add_raw(&tl, 0x001c, strlen(region), region);
+        aim_tlvlist_add_16(&tl, 0x000a, 0x0001); /* Type of search */
         if (interest)
-                aim_addtlvtochain_raw(&tl, 0x0001, strlen(interest), interest);
-
-        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+aim_sizetlvchain(&tl))))
+                aim_tlvlist_add_raw(&tl, 0x0001, strlen(interest), interest);
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+aim_tlvlist_size(&tl))))
                 return -ENOMEM;
         snacid = aim_cachesnac(sess, 0x000f, 0x0002, 0x0000, NULL, 0);
         aim_putsnac(&fr->data, 0x000f, 0x0002, 0x0000, snacid);
 
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
 
         aim_tx_enqueue(sess, fr);
@@ -174 +174 @@
         while (numresults) {
                 struct aim_odir *new;
-                aim_tlvlist_t *tl = aim_readtlvchain_num(bs, aimbs_get16(bs));
+                aim_tlvlist_t *tl = aim_tlvlist_readnum(bs, aimbs_get16(bs));
                 new = (struct aim_odir *)malloc(sizeof(struct aim_odir));
-                new->first = aim_gettlv_str(tl, 0x0001, 1);
-                new->last = aim_gettlv_str(tl, 0x0002, 1);
-                new->middle = aim_gettlv_str(tl, 0x0003, 1);
-                new->maiden = aim_gettlv_str(tl, 0x0004, 1);
-                new->email = aim_gettlv_str(tl, 0x0005, 1);
-                new->country = aim_gettlv_str(tl, 0x0006, 1);
-                new->state = aim_gettlv_str(tl, 0x0007, 1);
-                new->city = aim_gettlv_str(tl, 0x0008, 1);
-                new->sn = aim_gettlv_str(tl, 0x0009, 1);
-                new->interest = aim_gettlv_str(tl, 0x000b, 1);
-                new->nick = aim_gettlv_str(tl, 0x000c, 1);
-                new->zip = aim_gettlv_str(tl, 0x000d, 1);
-                new->region = aim_gettlv_str(tl, 0x001c, 1);
-                new->address = aim_gettlv_str(tl, 0x0021, 1);
+                new->first = aim_tlv_getstr(tl, 0x0001, 1);
+                new->last = aim_tlv_getstr(tl, 0x0002, 1);
+                new->middle = aim_tlv_getstr(tl, 0x0003, 1);
+                new->maiden = aim_tlv_getstr(tl, 0x0004, 1);
+                new->email = aim_tlv_getstr(tl, 0x0005, 1);
+                new->country = aim_tlv_getstr(tl, 0x0006, 1);
+                new->state = aim_tlv_getstr(tl, 0x0007, 1);
+                new->city = aim_tlv_getstr(tl, 0x0008, 1);
+                new->sn = aim_tlv_getstr(tl, 0x0009, 1);
+                new->interest = aim_tlv_getstr(tl, 0x000b, 1);
+                new->nick = aim_tlv_getstr(tl, 0x000c, 1);
+                new->zip = aim_tlv_getstr(tl, 0x000d, 1);
+                new->region = aim_tlv_getstr(tl, 0x001c, 1);
+                new->address = aim_tlv_getstr(tl, 0x0021, 1);
                 new->next = results;
                 results = new;

libfaim/oscar.c

@@ -31 +31 @@
 #include "buddyicon.h"
 #include "conversation.h"
+#include "core.h"
 #include "debug.h"
 #include "ft.h"
@@ -41 +42 @@
 #include "request.h"
 #include "util.h"
-#include "html.h"
 
 #include "aim.h"
 #include "md5.h"
-
-/* XXX CORE/UI */
-#include "gtkinternal.h"
-#include "gaim.h"
-
 
 #define UC_AOL          0x02
@@ -61 +56 @@
 #define AIMHASHDATA "http://gaim.sourceforge.net/aim_data.php3"
 
+#define OSCAR_CONNECT_STEPS 6
+
 static GaimPlugin *my_protocol = NULL;
 
-static int caps_aim = AIM_CAPS_CHAT | AIM_CAPS_BUDDYICON | AIM_CAPS_DIRECTIM | AIM_CAPS_SENDFILE | AIM_CAPS_INTEROPERATE;
-static int caps_icq = AIM_CAPS_BUDDYICON | AIM_CAPS_DIRECTIM | AIM_CAPS_SENDFILE | AIM_CAPS_ICQUTF8 | AIM_CAPS_INTEROPERATE;
+static int caps_aim = AIM_CAPS_CHAT | AIM_CAPS_BUDDYICON | AIM_CAPS_DIRECTIM | AIM_CAPS_SENDFILE | AIM_CAPS_INTEROPERATE | AIM_CAPS_ICHAT;
+static int caps_icq = AIM_CAPS_BUDDYICON | AIM_CAPS_DIRECTIM | AIM_CAPS_SENDFILE | AIM_CAPS_ICQUTF8 | AIM_CAPS_INTEROPERATE | AIM_CAPS_ICHAT;
 
 static fu8_t features_aim[] = {0x01, 0x01, 0x01, 0x02};
 static fu8_t features_icq[] = {0x01, 0x06};
 
-struct oscar_data {
+typedef struct _OscarData OscarData;
+struct _OscarData {
         aim_session_t *sess;
         aim_conn_t *conn;
@@ -101 +99 @@
         gboolean killme;
         gboolean icq;
-        GSList *evilhack;
         guint icontimer;
         guint getblisttimer;
@@ -151 +148 @@
 };
 
-/* Various PRPL-specific buddy info that we want to keep track of */
+/*
+ * Various PRPL-specific buddy info that we want to keep track of
+ * Some other info is maintained by locate.c, and I'd like to move 
+ * the rest of this to libfaim, mostly im.c
+ */
 struct buddyinfo {
-        time_t signon;
-        int caps;
         gboolean typingnot;
         gchar *availmsg;
@@ -168 +167 @@
         time_t ico_time;
         gboolean ico_need;
-
-        fu16_t iconcsumlen;
-        fu8_t *iconcsum;
+        gboolean ico_sent;
 };
 
@@ -219 +216 @@
 static int gaim_parse_misses     (aim_session_t *, aim_frame_t *, ...);
 static int gaim_parse_clientauto (aim_session_t *, aim_frame_t *, ...);
-static int gaim_parse_user_info  (aim_session_t *, aim_frame_t *, ...);
+static int gaim_parse_userinfo   (aim_session_t *, aim_frame_t *, ...);
 static int gaim_parse_motd       (aim_session_t *, aim_frame_t *, ...);
 static int gaim_chatnav_info     (aim_session_t *, aim_frame_t *, ...);
-static int gaim_chat_join        (aim_session_t *, aim_frame_t *, ...);
-static int gaim_chat_leave       (aim_session_t *, aim_frame_t *, ...);
-static int gaim_chat_info_update (aim_session_t *, aim_frame_t *, ...);
-static int gaim_chat_incoming_msg(aim_session_t *, aim_frame_t *, ...);
+static int gaim_conv_chat_join        (aim_session_t *, aim_frame_t *, ...);
+static int gaim_conv_chat_leave       (aim_session_t *, aim_frame_t *, ...);
+static int gaim_conv_chat_info_update (aim_session_t *, aim_frame_t *, ...);
+static int gaim_conv_chat_incoming_msg(aim_session_t *, aim_frame_t *, ...);
 static int gaim_email_parseupdate(aim_session_t *, aim_frame_t *, ...);
 static int gaim_icon_error       (aim_session_t *, aim_frame_t *, ...);
@@ -284 +281 @@
 
 /* prpl actions - remove this at some point */
+/* Because I don't like forward declarations?  I think that was why... */
 static void oscar_set_info(GaimConnection *gc, const char *text);
 
@@ -295 +293 @@
         struct buddyinfo *bi = data;
         g_free(bi->availmsg);
-        g_free(bi->iconcsum);
         g_free(bi);
 }
@@ -384 +381 @@
 }
 
-static struct direct_im *find_direct_im(struct oscar_data *od, const char *who) {
+static struct direct_im *find_direct_im(OscarData *od, const char *who) {
         GSList *d = od->direct_ims;
         struct direct_im *m = NULL;
@@ -428 +425 @@
 
 static struct chat_connection *find_oscar_chat(GaimConnection *gc, int id) {
-        GSList *g = ((struct oscar_data *)gc->proto_data)->oscar_chats;
+        GSList *g = ((OscarData *)gc->proto_data)->oscar_chats;
         struct chat_connection *c = NULL;
 
@@ -444 +441 @@
 static struct chat_connection *find_oscar_chat_by_conn(GaimConnection *gc,
                                                         aim_conn_t *conn) {
-        GSList *g = ((struct oscar_data *)gc->proto_data)->oscar_chats;
+        GSList *g = ((OscarData *)gc->proto_data)->oscar_chats;
         struct chat_connection *c = NULL;
 
@@ -460 +457 @@
 static void gaim_odc_disconnect(aim_session_t *sess, aim_conn_t *conn) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         GaimConversation *cnv;
         struct direct_im *dim;
@@ -496 +493 @@
         aim_session_t *sess = aim_conn_getsess(conn);
         GaimConnection *gc = sess ? sess->aux_data : NULL;
-        struct oscar_data *od;
+        OscarData *od;
 
         if (!gc) {
-                /* gc is null. we return, else we seg SIGSEG on next line. */
                 gaim_debug(GAIM_DEBUG_INFO, "oscar",
                                    "oscar callback for closed connection (1).\n");
@@ -505 +501 @@
         }
       
-        od = (struct oscar_data *)gc->proto_data;
+        od = (OscarData *)gc->proto_data;
 
         if (!g_list_find(gaim_connections_get_all(), gc)) {
@@ -606 +602 @@
 
 static void oscar_debug(aim_session_t *sess, int level, const char *format, va_list va) {
-        char *s = g_strdup_vprintf(format, va);
-        char buf[256];
-        char *t;
         GaimConnection *gc = sess->aux_data;
-
-        g_snprintf(buf, sizeof(buf), "%s %d: ", gaim_account_get_username(gaim_connection_get_account(gc)), level);
-        t = g_strconcat(buf, s, NULL);
-        gaim_debug(GAIM_DEBUG_INFO, "oscar", t);
-        if (t[strlen(t)-1] != '\n')
+        gchar *s = g_strdup_vprintf(format, va);
+        gchar *buf;
+
+        buf = g_strdup_printf("%s %d: %s", gaim_account_get_username(gaim_connection_get_account(gc)), level, s);
+        gaim_debug(GAIM_DEBUG_INFO, "oscar", buf);
+        if (buf[strlen(buf)-1] != '\n')
                 gaim_debug(GAIM_DEBUG_INFO, NULL, "\n");
-        g_free(t);
+        g_free(buf);
         g_free(s);
 }
@@ -623 +617 @@
 {
         GaimConnection *gc = data;
-        struct oscar_data *od;
+        OscarData *od;
         aim_session_t *sess;
         aim_conn_t *conn;
@@ -635 +629 @@
         sess = od->sess;
         conn = aim_getconn_type_all(sess, AIM_CONN_TYPE_AUTH);
-        
         conn->fd = source;
 
@@ -645 +638 @@
         aim_conn_completeconnect(sess, conn);
         gc->inpa = gaim_input_add(conn->fd, GAIM_INPUT_READ, oscar_callback, conn);
+        aim_request_login(sess, conn, gaim_account_get_username(gaim_connection_get_account(gc)));
+
         gaim_debug(GAIM_DEBUG_INFO, "oscar",
-                           "Password sent, waiting for response\n");
+                           "Screen name sent, waiting for response\n");
+        gaim_connection_update_progress(gc, _("Screen name sent"), 1, OSCAR_CONNECT_STEPS);
 }
 
@@ -652 +648 @@
         aim_session_t *sess;
         aim_conn_t *conn;
-        char buf[256];
         GaimConnection *gc = gaim_account_get_connection(account);
-        struct oscar_data *od = gc->proto_data = g_new0(struct oscar_data, 1);
+        OscarData *od = gc->proto_data = g_new0(OscarData, 1);
 
         gaim_debug(GAIM_DEBUG_MISC, "oscar", "oscar_login: gc = %p\n", gc);
@@ -667 +662 @@
 
         sess = g_new0(aim_session_t, 1);
-
-        aim_session_init(sess, AIM_SESS_FLAGS_NONBLOCKCONNECT, 0);
+        aim_session_init(sess, TRUE, 0);
         aim_setdebuggingcb(sess, oscar_debug);
-
-        /* we need an immediate queue because we don't use a while-loop to
-         * see if things need to be sent. */
+        /*
+         * We need an immediate queue because we don't use a while-loop 
+         * to see if things need to be sent.
+         */
         aim_tx_setenqueue(sess, AIM_TX_IMMEDIATE, NULL);
         od->sess = sess;
@@ -685 +680 @@
         }
 
-        g_snprintf(buf, sizeof(buf), _("Signon: %s"), gaim_account_get_username(account));
-        gaim_connection_update_progress(gc, buf, 2, 5);
-
         aim_conn_addhandler(sess, conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR, gaim_connerr, 0);
         aim_conn_addhandler(sess, conn, 0x0017, 0x0007, gaim_parse_login, 0);
@@ -699 +691 @@
                 return;
         }
-        aim_request_login(sess, conn, gaim_account_get_username(account));
+
+        gaim_connection_update_progress(gc, _("Connecting"), 0, OSCAR_CONNECT_STEPS);
 }
 
 static void oscar_close(GaimConnection *gc) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
 
         while (od->oscar_chats) {
@@ -733 +726 @@
         }
         g_hash_table_destroy(od->buddyinfo);
-        while (od->evilhack) {
-                g_free(od->evilhack->data);
-                od->evilhack = g_slist_remove(od->evilhack, od->evilhack->data);
-        }
         while (od->create_rooms) {
                 struct create_room *cr = od->create_rooms->data;
@@ -773 +762 @@
 static void oscar_bos_connect(gpointer data, gint source, GaimInputCondition cond) {
         GaimConnection *gc = data;
-        struct oscar_data *od;
+        OscarData *od;
         aim_session_t *sess;
         aim_conn_t *bosconn;
@@ -794 +783 @@
         aim_conn_completeconnect(sess, bosconn);
         gc->inpa = gaim_input_add(bosconn->fd, GAIM_INPUT_READ, oscar_callback, bosconn);
+
         gaim_connection_update_progress(gc,
-                        _("Connection established, cookie sent"), 4, 5);
+                        _("Connection established, cookie sent"), 4, OSCAR_CONNECT_STEPS);
 }
 
@@ -834 +824 @@
         struct aim_oft_info *oft_info = xfer->data;
         GaimConnection *gc = oft_info->sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
 
         if (gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) {
@@ -900 +890 @@
         struct aim_oft_info *oft_info = xfer->data;
         GaimConnection *gc = oft_info->sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
 
         gaim_debug(GAIM_DEBUG_INFO, "oscar", "AAA - in oscar_xfer_end\n");
@@ -919 +909 @@
         struct aim_oft_info *oft_info = xfer->data;
         GaimConnection *gc = oft_info->sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
 
         gaim_debug(GAIM_DEBUG_INFO, "oscar",
@@ -936 +926 @@
         struct aim_oft_info *oft_info = xfer->data;
         GaimConnection *gc = oft_info->sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
 
         gaim_debug(GAIM_DEBUG_INFO, "oscar",
@@ -1007 +997 @@
 
 static void oscar_ask_sendfile(GaimConnection *gc, const char *destsn) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         GaimXfer *xfer;
         struct aim_oft_info *oft_info;
@@ -1038 +1028 @@
 static int gaim_parse_auth_resp(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         GaimAccount *account = gc->account;
         aim_conn_t *bosconn;
@@ -1136 +1126 @@
         aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_ERROR, gaim_parse_msgerr, 0);
         aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_MTN, gaim_parse_mtn, 0);
-        aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_LOC, AIM_CB_LOC_USERINFO, gaim_parse_user_info, 0);
+        aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_LOC, AIM_CB_LOC_USERINFO, gaim_parse_userinfo, 0);
         aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_ACK, gaim_parse_msgack, 0);
         aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, AIM_CB_GEN_MOTD, gaim_parse_motd, 0);
@@ -1163 +1153 @@
 #endif
 
-        ((struct oscar_data *)gc->proto_data)->conn = bosconn;
+        od->conn = bosconn;
         for (i = 0; i < (int)strlen(info->bosip); i++) {
                 if (info->bosip[i] == ':') {
@@ -1182 +1172 @@
         gaim_input_remove(gc->inpa);
 
+        gaim_connection_update_progress(gc, _("Received authorization"), 3, OSCAR_CONNECT_STEPS);
+
         return 1;
 }
 
+/* XXX - Should use gaim_url_fetch for the below stuff */
 struct pieceofcrap {
         GaimConnection *gc;
@@ -1198 +1191 @@
 {
         struct pieceofcrap *pos = data;
-        struct oscar_data *od = pos->gc->proto_data;
+        OscarData *od = pos->gc->proto_data;
         char in = '\0';
         int x = 0;
@@ -1217 +1210 @@
                         "this is fixed.  Check %s for updates."), GAIM_WEBSITE);
                 gaim_notify_warning(pos->gc, NULL,
-                                                        _("Gaim was Unable to get a valid AIM login hash."),
+                                                        _("Gaim was unable to get a valid AIM login hash."),
                                                         buf);
                 gaim_input_remove(pos->inpa);
@@ -1247 +1240 @@
                         "this is fixed.  Check %s for updates."), GAIM_WEBSITE);
                 gaim_notify_warning(pos->gc, NULL,
-                                                        _("Gaim was Unable to get a valid AIM login hash."),
+                                                        _("Gaim was unable to get a valid AIM login hash."),
                                                         buf);
                 g_free(buf);
@@ -1335 +1328 @@
                         "this is fixed.  Check %s for updates."), GAIM_WEBSITE);
                 gaim_notify_warning(pos->gc, NULL,
-                                                        _("Gaim was Unable to get a valid login hash."),
+                                                        _("Gaim was unable to get a valid login hash."),
                                                         buf);
         }
@@ -1343 +1336 @@
 
 static int gaim_parse_login(aim_session_t *sess, aim_frame_t *fr, ...) {
-        char *key;
-        va_list ap;
         GaimConnection *gc = sess->aux_data;
+        OscarData *od = gc->proto_data;
         GaimAccount *account = gaim_connection_get_account(gc);
         GaimAccount *ac = gaim_connection_get_account(gc);
-        struct oscar_data *od = gc->proto_data;
+#if 0
+        struct client_info_s info = {"gaim", 7, 3, 2003, "us", "en", 0x0004, 0x0000, 0x04b};
+#endif
+        va_list ap;
+        char *key;
 
         va_start(ap, fr);
@@ -1359 +1355 @@
                                            gaim_account_get_password(account), &info, key);
         } else {
-#if 0
-                struct client_info_s info = {"gaim", 4, 1, 2010, "us", "en", 0x0004, 0x0000, 0x04b};
-#endif
                 struct client_info_s info = CLIENTINFO_AIM_KNOWNGOOD;
                 aim_send_login(sess, fr->conn, gaim_account_get_username(ac),
                                            gaim_account_get_password(account), &info, key);
         }
+
+        gaim_connection_update_progress(gc, _("Password sent"), 2, OSCAR_CONNECT_STEPS);
 
         return 1;
@@ -1376 +1371 @@
 
         aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, 0x0001, gaim_parse_genericerr, 0);
-        aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERJOIN, gaim_chat_join, 0);
-        aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERLEAVE, gaim_chat_leave, 0);
-        aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_ROOMINFOUPDATE, gaim_chat_info_update, 0);
-        aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_INCOMINGMSG, gaim_chat_incoming_msg, 0);
+        aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERJOIN, gaim_conv_chat_join, 0);
+        aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERLEAVE, gaim_conv_chat_leave, 0);
+        aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_ROOMINFOUPDATE, gaim_conv_chat_info_update, 0);
+        aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_INCOMINGMSG, gaim_conv_chat_incoming_msg, 0);
 
         aim_clientready(sess, fr->conn);
@@ -1407 +1402 @@
         aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_EML, AIM_CB_EML_MAILSTATUS, gaim_email_parseupdate, 0);
 
-        aim_email_sendcookies(sess, fr->conn);
-        aim_email_activate(sess, fr->conn);
+        aim_email_sendcookies(sess);
+        aim_email_activate(sess);
         aim_clientready(sess, fr->conn);
 
@@ -1416 +1411 @@
 static int conninitdone_icon(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
 
         aim_conn_addhandler(sess, fr->conn, 0x0018, 0x0001, gaim_parse_genericerr, 0);
@@ -1435 +1430 @@
 static void oscar_chatnav_connect(gpointer data, gint source, GaimInputCondition cond) {
         GaimConnection *gc = data;
-        struct oscar_data *od;
+        OscarData *od;
         aim_session_t *sess;
         aim_conn_t *tstconn;
@@ -1464 +1459 @@
 {
         GaimConnection *gc = data;
-        struct oscar_data *od;
+        OscarData *od;
         aim_session_t *sess;
         aim_conn_t *tstconn;
@@ -1494 +1489 @@
         struct chat_connection *ccon = data;
         GaimConnection *gc = ccon->gc;
-        struct oscar_data *od;
+        OscarData *od;
         aim_session_t *sess;
         aim_conn_t *tstconn;
@@ -1526 +1521 @@
 static void oscar_email_connect(gpointer data, gint source, GaimInputCondition cond) {
         GaimConnection *gc = data;
-        struct oscar_data *od;
+        OscarData *od;
         aim_session_t *sess;
         aim_conn_t *tstconn;
@@ -1555 +1550 @@
 static void oscar_icon_connect(gpointer data, gint source, GaimInputCondition cond) {
         GaimConnection *gc = data;
-        struct oscar_data *od;
+        OscarData *od;
         aim_session_t *sess;
         aim_conn_t *tstconn;
@@ -1748 +1743 @@
 static int gaim_parse_oncoming(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         struct buddyinfo *bi;
         time_t time_idle = 0, signon = 0;
@@ -1789 +1784 @@
         }
 
-        if (caps & AIM_CAPS_ICQ)
-                caps ^= AIM_CAPS_ICQ;
+        if (caps & AIM_CAPS_ICQ_DIRECT)
+                caps ^= AIM_CAPS_ICQ_DIRECT;
 
         if (info->present & AIM_USERINFO_PRESENT_IDLE) {
@@ -1805 +1800 @@
                 gaim_connection_set_display_name(gc, info->sn);
 
-        bi = g_hash_table_lookup(od->buddyinfo, normalize(info->sn));
+        bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(gc->account, info->sn));
         if (!bi) {
                 bi = g_new0(struct buddyinfo, 1);
-                g_hash_table_insert(od->buddyinfo, g_strdup(normalize(info->sn)), bi);
-        }
-        bi->signon = info->onlinesince ? info->onlinesince : (info->sessionlen + time(NULL));
-        if (caps)
-                bi->caps = caps;
+                g_hash_table_insert(od->buddyinfo, g_strdup(gaim_normalize(gc->account, info->sn)), bi);
+        }
         bi->typingnot = FALSE;
         bi->ico_informed = FALSE;
@@ -1819 +1811 @@
         /* Available message stuff */
         free(bi->availmsg);
-        if (info->availmsg)
-                if (info->availmsg_encoding) {
-                        gchar *enc = g_strdup_printf("charset=\"%s\"", info->availmsg_encoding);
-                        bi->availmsg = oscar_encoding_to_utf8(enc, info->availmsg, info->availmsg_len);
+        if (info->avail != NULL)
+                if (info->avail_encoding) {
+                        gchar *enc = g_strdup_printf("charset=\"%s\"", info->avail_encoding);
+                        bi->availmsg = oscar_encoding_to_utf8(enc, info->avail, info->avail_len);
                         g_free(enc);
                 } else {
                         /* No explicit encoding means utf8.  Yay. */
-                        bi->availmsg = g_strdup(info->availmsg);
+                        bi->availmsg = g_strdup(info->avail);
                 }
         else
@@ -1833 +1825 @@
         /* Server stored icon stuff */
         if (info->iconcsumlen) {
-                char *b16, *saved_b16;
-                GaimBuddy *b;
-
-                free(bi->iconcsum);
-                bi->iconcsum = malloc(info->iconcsumlen);
-                memcpy(bi->iconcsum, info->iconcsum, info->iconcsumlen);
-                bi->iconcsumlen = info->iconcsumlen;
-                b16 = tobase16(bi->iconcsum, bi->iconcsumlen);
+                const char *filename = NULL, *saved_b16 = NULL;
+                char *b16 = NULL;
+                GaimBuddy *b = NULL;
+
+                b16 = gaim_base16_encode(info->iconcsum, info->iconcsumlen);
                 b = gaim_find_buddy(gc->account, info->sn);
-                saved_b16 = gaim_buddy_get_setting(b, "icon_checksum");
+                /*
+                 * If for some reason the checksum is valid, but cached file is not..
+                 * we want to know.
+                 */
+                filename = gaim_buddy_get_setting(b, "buddy_icon");
+                if (filename != NULL) {
+                        if (g_file_test(filename, G_FILE_TEST_EXISTS))
+                                saved_b16 = gaim_buddy_get_setting(b, "icon_checksum");
+                } else
+                        saved_b16 = NULL;
+
                 if (!b16 || !saved_b16 || strcmp(b16, saved_b16)) {
                         GSList *cur = od->requesticon;
@@ -1848 +1847 @@
                                 cur = cur->next;
                         if (!cur) {
-                                od->requesticon = g_slist_append(od->requesticon, strdup(normalize(info->sn)));
+                                od->requesticon = g_slist_append(od->requesticon, g_strdup(gaim_normalize(gc->account, info->sn)));
                                 if (od->icontimer)
                                         g_source_remove(od->icontimer);
@@ -1854 +1853 @@
                         }
                 }
-                g_free(saved_b16);
                 g_free(b16);
         }
@@ -1865 +1863 @@
 static int gaim_parse_offgoing(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         va_list ap;
         aim_userinfo_t *info;
@@ -1875 +1873 @@
         serv_got_update(gc, info->sn, 0, 0, 0, 0, 0);
 
-        g_hash_table_remove(od->buddyinfo, normalize(info->sn));
+        g_hash_table_remove(od->buddyinfo, gaim_normalize(gc->account, info->sn));
 
         return 1;
@@ -1890 +1888 @@
         struct direct_im *dim = data;
         GaimConnection *gc = dim->gc;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         GaimConversation *cnv;
         char buf[256];
@@ -1929 +1927 @@
 static int oscar_sendfile_estblsh(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         GaimXfer *xfer;
         struct aim_oft_info *oft_info;
@@ -2002 +2000 @@
 static int oscar_sendfile_prompt(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         GaimXfer *xfer;
         struct aim_oft_info *oft_info;
@@ -2047 +2045 @@
 static int oscar_sendfile_ack(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         GaimXfer *xfer;
         va_list ap;
@@ -2079 +2077 @@
 static int oscar_sendfile_done(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         GaimXfer *xfer;
         va_list ap;
@@ -2104 +2102 @@
 static void accept_direct_im(struct ask_direct *d) {
         GaimConnection *gc = d->gc;
-        struct oscar_data *od;
+        OscarData *od;
         struct direct_im *dim;
         char *host; int port = 4443;
@@ -2114 +2112 @@
         }
 
-        od = (struct oscar_data *)gc->proto_data;
+        od = (OscarData *)gc->proto_data;
         gaim_debug(GAIM_DEBUG_INFO, "oscar", "Accepted DirectIM.\n");
 
@@ -2163 +2161 @@
 static int incomingim_chan1(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *userinfo, struct aim_incomingim_ch1_args *args) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
-        char *tmp;
-        GaimImFlags flags = 0;
+        OscarData *od = gc->proto_data;
+        gchar *tmp;
+        GaimConvImFlags flags = 0;
         gsize convlen;
         GError *err = NULL;
@@ -2171 +2169 @@
         const char *iconfile;
 
-        bi = g_hash_table_lookup(od->buddyinfo, normalize(userinfo->sn));
+        bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(gc->account, userinfo->sn));
         if (!bi) {
                 bi = g_new0(struct buddyinfo, 1);
-                g_hash_table_insert(od->buddyinfo, g_strdup(normalize(userinfo->sn)), bi);
+                g_hash_table_insert(od->buddyinfo, g_strdup(gaim_normalize(gc->account, userinfo->sn)), bi);
         }
 
         if (args->icbmflags & AIM_IMFLAGS_AWAY)
-                flags |= GAIM_IM_AUTO_RESP;
+                flags |= GAIM_CONV_IM_AUTO_RESP;
 
         if (args->icbmflags & AIM_IMFLAGS_TYPINGNOT)
@@ -2197 +2195 @@
 
         if ((iconfile = gaim_account_get_buddy_icon(gaim_connection_get_account(gc))) && 
-            (args->icbmflags & AIM_IMFLAGS_BUDDYREQ)) {
+            (args->icbmflags & AIM_IMFLAGS_BUDDYREQ) && !bi->ico_sent && bi->ico_informed) {
                 FILE *file;
                 struct stat st;
@@ -2241 +2239 @@
                         gaim_debug(GAIM_DEBUG_INFO, "oscar",
                                            "Unicode IM conversion: %s\n", err->message);
-                        tmp = strdup(_("(There was an error receiving this message)"));
+                        tmp = g_strdup(_("(There was an error receiving this message)"));
                         g_error_free(err);
                 }
@@ -2263 +2261 @@
                         gaim_debug(GAIM_DEBUG_INFO, "oscar",
                                            "ISO-8859-1 IM conversion: %s\n", err->message);
-                        tmp = strdup(_("(There was an error receiving this message)"));
+                        tmp = g_strdup(_("(There was an error receiving this message)"));
                         g_error_free(err);
                 }
         }
 
-        /* strip_linefeed(tmp); */
+        /* gaim_str_strip_cr(tmp); */
         serv_got_im(gc, userinfo->sn, tmp, flags, time(NULL));
         g_free(tmp);
@@ -2277 +2275 @@
 static int incomingim_chan2(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *userinfo, struct aim_incomingim_ch2_args *args) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         const char *username = gaim_account_get_username(gaim_connection_get_account(gc));
 
@@ -2438 +2436 @@
 
         if (g_list_find(gaim_connections_get_all(), gc)) {
-                struct oscar_data *od = gc->proto_data;
+                OscarData *od = gc->proto_data;
                 GaimBuddy *buddy = gaim_find_buddy(gc->account, data->name);
                 GaimGroup *group = gaim_find_buddys_group(buddy);
@@ -2464 +2462 @@
 
         if (g_list_find(gaim_connections_get_all(), gc)) {
-                /* struct oscar_data *od = gc->proto_data; */
+                /* OscarData *od = gc->proto_data; */
                 /* XXX - Take the buddy out of our buddy list */
         }
@@ -2502 +2500 @@
 
         if (g_list_find(gaim_connections_get_all(), gc)) {
-                struct oscar_data *od = gc->proto_data;
+                OscarData *od = gc->proto_data;
 #ifdef NOSSI
                 GaimBuddy *buddy;
@@ -2509 +2507 @@
                 buddy = gaim_find_buddy(gc->account, data->name);
                 aim_im_sendch4(od->sess, data->name, AIM_ICQMSG_AUTHGRANTED, &message);
-                show_got_added(gc, NULL, data->name, (buddy ? gaim_get_buddy_alias_only(buddy) : NULL), NULL);
+                gaim_account_notify_added(gc->account, NULL, data->name, (buddy ? gaim_get_buddy_alias_only(buddy) : NULL), NULL);
 #else
                 aim_ssi_sendauthreply(od->sess, data->name, 0x01, NULL);
@@ -2523 +2521 @@
 
         if (g_list_find(gaim_connections_get_all(), gc)) {
-                struct oscar_data *od = gc->proto_data;
+                OscarData *od = gc->proto_data;
 #ifdef NOSSI
                 aim_im_sendch4(od->sess, data->name, AIM_ICQMSG_AUTHDENIED, msg ? msg : _("No reason given."));
@@ -2540 +2538 @@
 }
 
-/* When someone sends you contacts  */
-static void gaim_icq_contactadd(struct name_data *data) {
+/* When someone sends you buddies */
+static void gaim_icq_buddyadd(struct name_data *data) {
         GaimConnection *gc = data->gc;
 
         if (g_list_find(gaim_connections_get_all(), gc)) {
-                show_add_buddy(gc, data->name, NULL, data->nick);
+                gaim_blist_request_add_buddy(gaim_connection_get_account(gc), data->name, NULL, data->nick);
         }
 
@@ -2568 +2566 @@
         msg2 = (gchar **)g_malloc((numtoks+1)*sizeof(gchar *));
         for (i=0; msg1[i]; i++) {
-                strip_linefeed(msg1[i]);
+                gaim_str_strip_cr(msg1[i]);
                 msg2[i] = g_convert(msg1[i], strlen(msg1[i]), "UTF-8", "ISO-8859-1", NULL, NULL, &err);
                 if (err) {
@@ -2595 +2593 @@
                 case 0x04: { /* Someone sent you a URL */
                         if (i >= 2) {
-                                gchar *uin = g_strdup_printf("%u", args->uin);
-                                gchar *message = g_strdup_printf("<A HREF=\"%s\">%s</A>", msg2[1], msg2[0]);
-                                serv_got_im(gc, uin, message, 0, time(NULL));
-                                g_free(uin);
-                                g_free(message);
+                                if (msg2[1] != NULL) {
+                                        gchar *uin = g_strdup_printf("%u", args->uin);
+                                        gchar *message = g_strdup_printf("<A HREF=\"%s\">%s</A>",
+                                                                                                         msg2[1],
+                                                                                                         (msg2[0] && msg2[0][0]) ? msg2[0] : msg2[1]);
+                                        serv_got_im(gc, uin, message, 0, time(NULL));
+                                        g_free(uin);
+                                        g_free(message);
+                                }
                         }
                 } break;
@@ -2626 +2628 @@
                 case 0x07: { /* Someone has denied you authorization */
                         if (i >= 1) {
-                                gchar *dialog_msg = g_strdup_printf(_("The user %u has denied your request to add them to your contact list for the following reason:\n%s"), args->uin, msg2[0] ? msg2[0] : _("No reason given."));
+                                gchar *dialog_msg = g_strdup_printf(_("The user %u has denied your request to add them to your buddy list for the following reason:\n%s"), args->uin, msg2[0] ? msg2[0] : _("No reason given."));
                                 gaim_notify_info(gc, NULL, _("ICQ authorization denied."),
                                                                  dialog_msg);
@@ -2634 +2636 @@
 
                 case 0x08: { /* Someone has granted you authorization */
-                        gchar *dialog_msg = g_strdup_printf(_("The user %u has granted your request to add them to your contact list."), args->uin);
+                        gchar *dialog_msg = g_strdup_printf(_("The user %u has granted your request to add them to your buddy list."), args->uin);
                         gaim_notify_info(gc, NULL, "ICQ authorization accepted.",
                                                          dialog_msg);
@@ -2666 +2668 @@
                 case 0x12: {
                         /* Ack for authorizing/denying someone.  Or possibly an ack for sending any system notice */
-                        /* Someone added you to their contact list? */
+                        /* Someone added you to their buddy list? */
                 } break;
 
-                case 0x13: { /* Someone has sent you some ICQ contacts */
+                case 0x13: { /* Someone has sent you some ICQ buddies */
                         int i, num;
                         gchar **text;
@@ -2679 +2681 @@
                                 for (i=0; i<num; i++) {
                                         struct name_data *data = g_new(struct name_data, 1);
-                                        gchar *message = g_strdup_printf(_("ICQ user %u has sent you a contact: %s (%s)"), args->uin, text[i*2+2], text[i*2+1]);
+                                        gchar *message = g_strdup_printf(_("ICQ user %u has sent you a buddy: %s (%s)"), args->uin, text[i*2+2], text[i*2+1]);
                                         data->gc = gc;
                                         data->name = g_strdup(text[i*2+1]);
@@ -2685 +2687 @@
 
                                         gaim_request_action(gc, NULL, message,
-                                                                                _("Do you want to add this contact "
-                                                                                  "to your Buddy List?"),
+                                                                                _("Do you want to add this buddy "
+                                                                                  "to your buddy list?"),
                                                                                 0, data, 2,
-                                                                                _("Add"), G_CALLBACK(gaim_icq_contactadd),
+                                                                                _("Add"), G_CALLBACK(gaim_icq_buddyadd),
                                                                                 _("Decline"), G_CALLBACK(oscar_free_name_data));
                                         g_free(message);
@@ -2696 +2698 @@
                 } break;
 
-                case 0x1a: { /* Someone has sent you a greeting card or requested contacts? */
+                case 0x1a: { /* Someone has sent you a greeting card or requested buddies? */
                         /* This is boring and silly. */
                 } break;
@@ -2851 +2853 @@
 static int gaim_parse_clientauto_ch2(aim_session_t *sess, const char *who, fu16_t reason, const char *cookie) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
 
 /* BBB */
@@ -2881 +2883 @@
                         char *status_msg = gaim_icq_status(state);
                         char *dialog_msg, **splitmsg;
-                        struct oscar_data *od = gc->proto_data;
-                        GSList *l = od->evilhack;
-                        gboolean evilhack = FALSE;
 
                         /* Split at (carriage return/newline)'s, then rejoin later with BRs between. */
                         splitmsg = g_strsplit(msg, "\r\n", 0);
 
-                        /* If who is in od->evilhack, then we're just getting the away message, otherwise this 
-                         * will just get appended to the info box (which is already showing). */
-                        while (l) {
-                                char *x = l->data;
-                                if (!strcmp(x, normalize(who))) {
-                                        evilhack = TRUE;
-                                        g_free(x);
-                                        od->evilhack = g_slist_remove(od->evilhack, x);
-                                        break;
-                                }
-                                l = l->next;
-                        }
-
-                        if (evilhack)
-                                dialog_msg = g_strdup_printf(_("<B>UIN:</B> %s<BR><B>Status:</B> %s<HR>%s"), who, status_msg, g_strjoinv("<BR>", splitmsg));
-                        else
-                                dialog_msg = g_strdup_printf(_("<B>Status:</B> %s<HR>%s"), status_msg, g_strjoinv("<BR>", splitmsg));
-                        g_show_info_text(gc, who, 2, dialog_msg, NULL);
+                        dialog_msg = g_strdup_printf(_("<B>UIN:</B> %s<BR><B>Status:</B> %s<HR>%s"), who, status_msg, g_strjoinv("<BR>", splitmsg));
+                        gaim_notify_formatted(gc, NULL, _("Buddy Information"), NULL, dialog_msg, NULL, NULL);
 
                         g_free(status_msg);
@@ -2974 +2957 @@
 #if 0
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         GaimXfer *xfer;
 #endif
@@ -3040 +3023 @@
 }
 
+/*
+ * We get this error when there was an error in the locate family.  This 
+ * happens when you request info of someone who is offline.
+ */
 static int gaim_parse_locerr(aim_session_t *sess, aim_frame_t *fr, ...) {
-        char *buf;
+        gchar *buf;
         va_list ap;
         fu16_t reason;
@@ -3051 +3038 @@
         va_end(ap);
 
-        buf = g_strdup_printf(_("User information for %s unavailable:"), destn);
-        gaim_notify_error(sess->aux_data, NULL, buf,
-                                          (reason < msgerrreasonlen) ? _(msgerrreason[reason]) : _("No reason given."));
-        g_free(buf);
+        if (destn != NULL) {
+                buf = g_strdup_printf(_("User information for %s unavailable:"), destn);
+                gaim_notify_error(sess->aux_data, NULL, buf,
+                                                  (reason < msgerrreasonlen) ? _(msgerrreason[reason]) : _("No reason given."));
+                g_free(buf);
+        }
 
         return 1;
@@ -3092 +3081 @@
                                 break;
                         case AIM_CAPS_DIRECTIM:
-                                tmp = _("Direct IM");
+                                tmp = _("AIM Direct IM");
                                 break;
                         case AIM_CAPS_CHAT:
@@ -3113 +3102 @@
                                 tmp = _("Send Buddy List");
                                 break;
-                        case AIM_CAPS_ICQ:
-                                tmp = _("EveryBuddy Bug");
+                        case AIM_CAPS_ICQ_DIRECT:
+                                tmp = _("ICQ Direct Connect");
                                 break;
                         case AIM_CAPS_APINFO:
@@ -3141 +3130 @@
                                 break;
                         case AIM_CAPS_SECUREIM:
-                                tmp = _("Secure IM");
+                                tmp = _("Security Enabled");
+                                break;
+                        case AIM_CAPS_VIDEO:
+                                tmp = _("Video Chat");
                                 break;
                         default:
@@ -3157 +3149 @@
 }
 
-static int gaim_parse_user_info(aim_session_t *sess, aim_frame_t *fr, ...) {
+static int gaim_parse_userinfo(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
-        gchar *header;
-        GSList *l = od->evilhack;
-        gboolean evilhack = FALSE;
-        gchar *membersince = NULL, *onlinesince = NULL, *idle = NULL;
+        GString *text;
+        gchar *info_utf8 = NULL, *away_utf8 = NULL;
+        const char *final = NULL;
         va_list ap;
-        aim_userinfo_t *info;
-        fu16_t infotype;
-        char *text_enc = NULL, *text = NULL, *utf8 = NULL;
-        int text_len;
-        const char *username = gaim_account_get_username(gaim_connection_get_account(gc));
+        aim_userinfo_t *userinfo;
 
         va_start(ap, fr);
-        info = va_arg(ap, aim_userinfo_t *);
-        infotype = (fu16_t) va_arg(ap, unsigned int);
-        text_enc = va_arg(ap, char *);
-        text = va_arg(ap, char *);
-        text_len = va_arg(ap, int);
+        userinfo = va_arg(ap, aim_userinfo_t *);
         va_end(ap);
 
-        if (text_len > 0) {
-                if (!(utf8 = oscar_encoding_to_utf8(text_enc, text, text_len))) {
-                        utf8 = g_strdup(_("<i>Unable to display information because it was sent in an unknown encoding.</i>"));
-                        gaim_debug(GAIM_DEBUG_ERROR, "oscar",
-                                           "Encountered an unknown encoding while parsing userinfo\n");
-                }
-        }
-
-        if (info->present & AIM_USERINFO_PRESENT_ONLINESINCE) {
-                onlinesince = g_strdup_printf(_("Online Since : <b>%s</b><br>\n"),
-                                        asctime(localtime((time_t *)&info->onlinesince)));
-        }
-
-        if (info->present & AIM_USERINFO_PRESENT_MEMBERSINCE) {
-                membersince = g_strdup_printf(_("Member Since : <b>%s</b><br>\n"),
-                                        asctime(localtime((time_t *)&info->membersince)));
-        }
-
-        if (info->present & AIM_USERINFO_PRESENT_IDLE) {
-                gchar *itime = sec_to_text(info->idletime*60);
-                idle = g_strdup_printf(_("Idle : <b>%s</b>"), itime);
+        text = g_string_new("");
+        g_string_append_printf(text, _("Username: <b>%s</b><br>\n"), userinfo->sn);
+        g_string_append_printf(text, _("Warning Level: <b>%d%%</b><br>\n"), (int)((userinfo->warnlevel/10.0) + 0.5));
+
+        if (userinfo->present & AIM_USERINFO_PRESENT_ONLINESINCE)
+                g_string_append_printf(text, _("Online Since: <b>%s</b><br>\n"),
+                                        asctime(localtime((time_t *)&userinfo->onlinesince)));
+
+        if (userinfo->present & AIM_USERINFO_PRESENT_MEMBERSINCE)
+                g_string_append_printf(text, _("Member Since: <b>%s</b><br>\n"),
+                                        asctime(localtime((time_t *)&userinfo->membersince)));
+
+        if (userinfo->present & AIM_USERINFO_PRESENT_IDLE) {
+                gchar *itime = gaim_str_seconds_to_string(userinfo->idletime*60);
+                g_string_append_printf(text, _("Idle: <b>%s</b>"), itime);
                 g_free(itime);
         } else
-                idle = g_strdup(_("Idle: <b>Active</b>"));
-
-        header = g_strdup_printf(_("Username : <b>%s</b>  %s <br>\n"
-                        "Warning Level : <b>%d %%</b><br>\n"
-                        "%s"
-                        "%s"
-                        "%s\n"
-                        "<hr>\n"),
-                        info->sn,
-                        /* images(info->flags), */
-                        "",
-                        (int)((info->warnlevel/10.0) + 0.5),
-                        onlinesince ? onlinesince : "",
-                        membersince ? membersince : "",
-                        idle ? idle : "");
-
-        g_free(onlinesince);
-        g_free(membersince);
-        g_free(idle);
-
-        while (l) {
-                char *x = l->data;
-                if (!strcmp(x, normalize(info->sn))) {
-                        evilhack = TRUE;
-                        g_free(x);
-                        od->evilhack = g_slist_remove(od->evilhack, x);
-                        break;
-                }
-                l = l->next;
-        }
-
-        if (infotype == AIM_GETINFO_AWAYMESSAGE) {
-                if (evilhack) {
-                        g_show_info_text(gc, info->sn, 2,
-                                         header,
-                                         (utf8 && *utf8) ? away_subs(utf8, username) :
-                                         _("<i>User has no away message</i>"), NULL);
-                } else {
-                        g_show_info_text(gc, info->sn, 0,
-                                         header,
-                                         (utf8 && *utf8) ? away_subs(utf8, username) : NULL,
-                                         (utf8 && *utf8) ? "<hr>" : NULL,
-                                         NULL);
-                }
-        } else if (infotype == AIM_GETINFO_CAPABILITIES) {
-                g_show_info_text(gc, info->sn, 2,
-                                header,
-                                "<i>", _("Client Capabilities: "),
-                                caps_string(info->capabilities),
-                                "</i>",
-                                NULL);
-        } else {
-                g_show_info_text(gc, info->sn, 1,
-                                 (utf8 && *utf8) ? away_subs(utf8, username) : _("<i>No Information Provided</i>"),
-                                 NULL);
-        }
-
-        g_free(header);
-        g_free(utf8);
+                g_string_append_printf(text, _("Idle: <b>Active</b>"));
+
+        if ((userinfo->flags & AIM_FLAG_AWAY) && (userinfo->away_len > 0) && (userinfo->away != NULL) && (userinfo->away_encoding != NULL)) {
+                away_utf8 = oscar_encoding_to_utf8(userinfo->away_encoding, userinfo->away, userinfo->away_len);
+                if (away_utf8 != NULL) {
+                        g_string_append_printf(text, "<hr>%s", away_utf8);
+                        g_free(away_utf8);
+                }
+        }
+
+        if ((userinfo->info_len > 0) && (userinfo->info != NULL) && (userinfo->info_encoding != NULL)) {
+                info_utf8 = oscar_encoding_to_utf8(userinfo->info_encoding, userinfo->info, userinfo->info_len);
+                if (info_utf8 != NULL) {
+                        g_string_append_printf(text, "<hr>%s", info_utf8);
+                        g_free(info_utf8);
+                }
+        }
+
+        final = gaim_str_sub_away_formatters(text->str, gaim_account_get_username(gaim_connection_get_account(gc)));
+        g_string_free(text, TRUE);
+        gaim_notify_formatted(gc, NULL, _("Buddy Information"), NULL, final, NULL, NULL);
 
         return 1;
@@ -3288 +3226 @@
         fu16_t type;
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
 
         va_start(ap, fr);
@@ -3363 +3301 @@
 }
 
-static int gaim_chat_join(aim_session_t *sess, aim_frame_t *fr, ...) {
+static int gaim_conv_chat_join(aim_session_t *sess, aim_frame_t *fr, ...) {
         va_list ap;
         int count, i;
@@ -3381 +3319 @@
 
         for (i = 0; i < count; i++)
-                gaim_chat_add_user(GAIM_CHAT(c->cnv), info[i].sn, NULL);
+                gaim_conv_chat_add_user(GAIM_CONV_CHAT(c->cnv), info[i].sn, NULL);
 
         return 1;
 }
 
-static int gaim_chat_leave(aim_session_t *sess, aim_frame_t *fr, ...) {
+static int gaim_conv_chat_leave(aim_session_t *sess, aim_frame_t *fr, ...) {
         va_list ap;
         int count, i;
@@ -3404 +3342 @@
 
         for (i = 0; i < count; i++)
-                gaim_chat_remove_user(GAIM_CHAT(c->cnv), info[i].sn, NULL);
+                gaim_conv_chat_remove_user(GAIM_CONV_CHAT(c->cnv), info[i].sn, NULL);
 
         return 1;
 }
 
-static int gaim_chat_info_update(aim_session_t *sess, aim_frame_t *fr, ...) {
+static int gaim_conv_chat_info_update(aim_session_t *sess, aim_frame_t *fr, ...) {
         va_list ap;
         aim_userinfo_t *userinfo;
@@ -3445 +3383 @@
 }
 
-static int gaim_chat_incoming_msg(aim_session_t *sess, aim_frame_t *fr, ...) {
+static int gaim_conv_chat_incoming_msg(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
         va_list ap;
@@ -3467 +3405 @@
         struct aim_emailinfo *emailinfo;
         int havenewmail;
+        char *alertitle, *alerturl;
 
         va_start(ap, fr);
         emailinfo = va_arg(ap, struct aim_emailinfo *);
         havenewmail = va_arg(ap, int);
+        alertitle = va_arg(ap, char *);
+        alerturl  = va_arg(ap, char *);
         va_end(ap);
 
@@ -3479 +3420 @@
                 g_free(to);
         }
+        
+        if (alertitle)
+                gaim_debug(GAIM_DEBUG_MISC, "oscar", "Got an alert '%s' %s\n", alertitle, alerturl ? alerturl : "");
 
         return 1;
@@ -3485 +3429 @@
 static int gaim_icon_error(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         char *sn;
 
@@ -3503 +3447 @@
 static int gaim_icon_parseicon(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         GSList *cur;
         va_list ap;
@@ -3523 +3467 @@
                 gaim_buddy_icons_set_for_user(gaim_connection_get_account(gc),
                                                                           sn, icon, iconlen);
-                b16 = tobase16(iconcsum, iconcsumlen);
+                b16 = gaim_base16_encode(iconcsum, iconcsumlen);
                 if (b16) {
                         gaim_buddy_set_setting(b, "icon_checksum", b16);
                         gaim_blist_save();
-                        free(b16);
+                        g_free(b16);
                 }
         }
@@ -3551 +3495 @@
 static gboolean gaim_icon_timerfunc(gpointer data) {
         GaimConnection *gc = data;
-        struct oscar_data *od = gc->proto_data;
-        struct buddyinfo *bi;
+        OscarData *od = gc->proto_data;
+        aim_userinfo_t *userinfo;
         aim_conn_t *conn;
 
@@ -3595 +3539 @@
         }
 
-        bi = g_hash_table_lookup(od->buddyinfo, (char *)od->requesticon->data);
-        if (bi && (bi->iconcsumlen > 0)) {
-                aim_bart_request(od->sess, od->requesticon->data, bi->iconcsum, bi->iconcsumlen);
+        userinfo = aim_locate_finduserinfo(od->sess, (char *)od->requesticon->data);
+        if ((userinfo != NULL) && (userinfo->iconcsumlen > 0)) {
+                aim_bart_request(od->sess, od->requesticon->data, userinfo->iconcsum, userinfo->iconcsumlen);
                 return FALSE;
         } else {
@@ -3690 +3634 @@
         va_end(ap);
 
-        serv_got_eviled(gc, (userinfo && userinfo->sn[0]) ? userinfo->sn : NULL, (newevil/10.0) + 0.5);
+        serv_got_eviled(gc, (userinfo && userinfo->sn) ? userinfo->sn : NULL, (newevil/10.0) + 0.5);
 
         return 1;
@@ -3714 +3658 @@
 static int gaim_connerr(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         va_list ap;
         fu16_t code;
@@ -3740 +3684 @@
 
 static int conninitdone_bos(aim_session_t *sess, aim_frame_t *fr, ...) {
+        GaimConnection *gc = sess->aux_data;
 
         aim_reqpersonalinfo(sess, fr->conn);
 
 #ifndef NOSSI
-        gaim_debug(GAIM_DEBUG_INFO, "oscar", "ssi: requesting ssi list\n");
+        gaim_debug(GAIM_DEBUG_INFO, "oscar", "ssi: requesting rights and list\n");
         aim_ssi_reqrights(sess);
         aim_ssi_reqdata(sess);
 #endif
 
-        aim_bos_reqlocaterights(sess, fr->conn);
-        aim_bos_reqbuddyrights(sess, fr->conn);
+        aim_locate_reqrights(sess);
+        aim_buddylist_reqrights(sess, fr->conn);
         aim_im_reqparams(sess);
-        aim_bos_reqrights(sess, fr->conn); /* XXX - Don't call this with ssi? */
+        aim_bos_reqrights(sess, fr->conn); /* XXX - Don't call this with ssi */
 
 #ifdef NOSSI
+        gaim_debug(GAIM_DEBUG_INFO, "oscar", "bos: requesting rights\n");
+        aim_bos_reqrights(sess, fr->conn);
         aim_bos_setgroupperm(sess, fr->conn, AIM_FLAG_ALLUSERS);
         aim_bos_setprivacyflags(sess, fr->conn, AIM_PRIVFLAGS_ALLOWIDLE | AIM_PRIVFLAGS_ALLOWMEMBERSINCE);
 #endif
 
+        gaim_connection_update_progress(gc, _("Finalizing connection"), 5, OSCAR_CONNECT_STEPS);
+
         return 1;
 }
@@ -3764 +3713 @@
 static int conninitdone_admin(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
 
         aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_ADM, 0x0003, gaim_info_change, 0);
@@ -3839 +3788 @@
 {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         va_list ap;
         fu16_t maxsiglen;
@@ -3853 +3802 @@
 
         if (od->icq)
-                aim_bos_setprofile(sess, fr->conn, NULL, NULL, 0, NULL, NULL, 0, caps_icq);
+                aim_locate_setcaps(od->sess, caps_icq);
         else
-                oscar_set_info(gc, gc->account->user_info);
+                aim_locate_setcaps(od->sess, caps_aim);
+        oscar_set_info(gc, gc->account->user_info);
 
         return 1;
@@ -3864 +3814 @@
         fu16_t maxbuddies, maxwatchers;
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
 
         va_start(ap, fr);
@@ -3881 +3831 @@
 
 static int gaim_bosrights(aim_session_t *sess, aim_frame_t *fr, ...) {
+        GaimConnection *gc = sess->aux_data;
+        OscarData *od = (OscarData *)gc->proto_data;
+        va_list ap;
         fu16_t maxpermits, maxdenies;
-        va_list ap;
-        GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
 
         va_start(ap, fr);
@@ -3904 +3854 @@
         aim_clientready(sess, fr->conn);
         aim_srv_setavailmsg(sess, NULL);
-        aim_bos_setidle(sess, fr->conn, 0);
+        aim_srv_setidle(sess, 0);
 
         if (od->icq) {
@@ -3935 +3885 @@
         args.msglen = msg->msglen;
         args.msg = msg->msg;
-        t = get_time(msg->year, msg->month, msg->day, msg->hour, msg->minute, 0);
+        t = gaim_time_build(msg->year, msg->month, msg->day, msg->hour, msg->minute, 0);
         incomingim_chan4(sess, fr->conn, NULL, &args, t);
 
@@ -3946 +3896 @@
         return 1;
 }
+
+#if 0
+/*
+ * Update, 2003-11-09:
+ * Joseph S. Myers, a gcc dude, fixed this for gcc 3.4!  Rock on!
+ *
+ * It may not be my place to do this, but...
+ * I feel pretty strongly that the "last 2 digits" warning is ridiculously 
+ * stupid, and should not exist for % switches (%x in our case) that request 
+ * a year in the preferred representation for the current locale.  For that 
+ * reason I've chosen to not use this workaround (n., see kluge).
+ *
+ * I have a date.  I want to show it to the user in the "preferred" way.  
+ * Whether that displays a 2 digit year is perfectly fine--after all, it's 
+ * what the locale wanted.
+ * 
+ * If I have a necessity for a full representation of the year in the current 
+ * locale, then I'll use a switch that returns a full representation of the 
+ * year.
+ *
+ * If you think the preferred locale should show 4 digits instead of 2 digits 
+ * (because you're anal, or whatever), then change the f***ing locale.
+ *
+ * I guess the bottom line is--I'm trying to show a date to the user how they 
+ * prefer to see it, why the hell does gcc want me to change that?
+ *
+ * See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=3190
+ * See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=8714
+ */
+
+/*
+ * This function was recommended by the STRFTIME(3) man page to remove the
+ * "last 2 digits" warning.
+ */
+static size_t my_strftime(char *s, size_t max, const char  *fmt,  
+                        const struct tm *tm)
+{
+        return strftime(s, max, fmt, tm);
+}
+#endif
 
 static int gaim_icqinfo(aim_session_t *sess, aim_frame_t *fr, ...)
@@ -3966 +3956 @@
         g_snprintf(who, sizeof(who), "%u", info->uin);
         buf = g_strdup_printf("<b>%s:</b> %s", _("UIN"), who);
-        if (info->nick && info->nick[0] && (utf8 = gaim_try_conv_to_utf8(info->nick))) {
+        if (info->nick && info->nick[0] && (utf8 = gaim_utf8_try_convert(info->nick))) {
                 tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Nick"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
         }
-        if (info->first && info->first[0] && (utf8 = gaim_try_conv_to_utf8(info->first))) {
+        if (info->first && info->first[0] && (utf8 = gaim_utf8_try_convert(info->first))) {
                 tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("First Name"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
         }
-        if (info->last && info->last[0] && (utf8 = gaim_try_conv_to_utf8(info->last))) {
+        if (info->last && info->last[0] && (utf8 = gaim_utf8_try_convert(info->last))) {
                 tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Last Name"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
         }
-        if (info->email && info->email[0] && (utf8 = gaim_try_conv_to_utf8(info->email))) {
+        if (info->email && info->email[0] && (utf8 = gaim_utf8_try_convert(info->email))) {
                 tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Email Address"), ":</b> <a href=\"mailto:", utf8, "\">", utf8, "</a>", NULL);  g_free(tmp); g_free(utf8);
         }
@@ -3981 +3971 @@
                 int i;
                 for (i = 0; i < info->numaddresses; i++) {
-                        if (info->email2[i] && info->email2[i][0] && (utf8 = gaim_try_conv_to_utf8(info->email2[i]))) {
+                        if (info->email2[i] && info->email2[i][0] && (utf8 = gaim_utf8_try_convert(info->email2[i]))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Email Address"), ":</b> <a href=\"mailto:", utf8, "\">", utf8, "</a>", NULL);  g_free(tmp); g_free(utf8);
                         }
                 }
         }
-        if (info->mobile && info->mobile[0] && (utf8 = gaim_try_conv_to_utf8(info->mobile))) {
+        if (info->mobile && info->mobile[0] && (utf8 = gaim_utf8_try_convert(info->mobile))) {
                 tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Mobile Phone"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
         }
@@ -4006 +3996 @@
                 tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Age"), ":</b> ", age, NULL);  g_free(tmp);
         }
-        if (info->personalwebpage && info->personalwebpage[0] && (utf8 = gaim_try_conv_to_utf8(info->personalwebpage))) {
+        if (info->personalwebpage && info->personalwebpage[0] && (utf8 = gaim_utf8_try_convert(info->personalwebpage))) {
                 tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Personal Web Page"), ":</b> <a href=\"", utf8, "\">", utf8, "</a>", NULL);  g_free(tmp); g_free(utf8);
         }
-        if (info->info && info->info[0] && (utf8 = gaim_try_conv_to_utf8(info->info))) {
+        if (info->info && info->info[0] && (utf8 = gaim_utf8_try_convert(info->info))) {
                 tmp = buf;  buf = g_strconcat(tmp, "<hr><b>", _("Additional Information"), ":</b><br>", utf8, NULL);  g_free(tmp); g_free(utf8);
         }
@@ -4015 +4005 @@
         if ((info->homeaddr && (info->homeaddr[0])) || (info->homecity && info->homecity[0]) || (info->homestate && info->homestate[0]) || (info->homezip && info->homezip[0])) {
                 tmp = buf;  buf = g_strconcat(tmp, "<b>", _("Home Address"), ":</b>", NULL);  g_free(tmp);
-                if (info->homeaddr && info->homeaddr[0] && (utf8 = gaim_try_conv_to_utf8(info->homeaddr))) {
+                if (info->homeaddr && info->homeaddr[0] && (utf8 = gaim_utf8_try_convert(info->homeaddr))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Address"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
                 }
-                if (info->homecity && info->homecity[0] && (utf8 = gaim_try_conv_to_utf8(info->homecity))) {
+                if (info->homecity && info->homecity[0] && (utf8 = gaim_utf8_try_convert(info->homecity))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("City"), ":</b> ", utf8,  NULL);  g_free(tmp); g_free(utf8);
                 }
-                if (info->homestate && info->homestate[0] && (utf8 = gaim_try_conv_to_utf8(info->homestate))) {
+                if (info->homestate && info->homestate[0] && (utf8 = gaim_utf8_try_convert(info->homestate))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("State"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
                 }
-                if (info->homezip && info->homezip[0] && (utf8 = gaim_try_conv_to_utf8(info->homezip))) {
+                if (info->homezip && info->homezip[0] && (utf8 = gaim_utf8_try_convert(info->homezip))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Zip Code"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
                 }
@@ -4031 +4021 @@
         if ((info->workaddr && info->workaddr[0]) || (info->workcity && info->workcity[0]) || (info->workstate && info->workstate[0]) || (info->workzip && info->workzip[0])) {
                 tmp = buf;  buf = g_strconcat(tmp, "<b>", _("Work Address"), ":</b>", NULL);  g_free(tmp);
-                if (info->workaddr && info->workaddr[0] && (utf8 = gaim_try_conv_to_utf8(info->workaddr))) {
+                if (info->workaddr && info->workaddr[0] && (utf8 = gaim_utf8_try_convert(info->workaddr))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Address"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
                 }
-                if (info->workcity && info->workcity[0] && (utf8 = gaim_try_conv_to_utf8(info->workcity))) {
+                if (info->workcity && info->workcity[0] && (utf8 = gaim_utf8_try_convert(info->workcity))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("City"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
                 }
-                if (info->workstate && info->workstate[0] && (utf8 = gaim_try_conv_to_utf8(info->workstate))) {
+                if (info->workstate && info->workstate[0] && (utf8 = gaim_utf8_try_convert(info->workstate))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("State"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
                 }
-                if (info->workzip && info->workzip[0] && (utf8 = gaim_try_conv_to_utf8(info->workzip))) {
+                if (info->workzip && info->workzip[0] && (utf8 = gaim_utf8_try_convert(info->workzip))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Zip Code"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
                 }
@@ -4047 +4037 @@
         if ((info->workcompany && info->workcompany[0]) || (info->workdivision && info->workdivision[0]) || (info->workposition && info->workposition[0]) || (info->workwebpage && info->workwebpage[0])) {
                 tmp = buf;  buf = g_strconcat(tmp, "<b>", _("Work Information"), ":</b>", NULL);  g_free(tmp);
-                if (info->workcompany && info->workcompany[0] && (utf8 = gaim_try_conv_to_utf8(info->workcompany))) {
+                if (info->workcompany && info->workcompany[0] && (utf8 = gaim_utf8_try_convert(info->workcompany))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Company"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
                 }
-                if (info->workdivision && info->workdivision[0] && (utf8 = gaim_try_conv_to_utf8(info->workdivision))) {
+                if (info->workdivision && info->workdivision[0] && (utf8 = gaim_utf8_try_convert(info->workdivision))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Division"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
                 }
-                if (info->workposition && info->workposition[0] && (utf8 = gaim_try_conv_to_utf8(info->workposition))) {
+                if (info->workposition && info->workposition[0] && (utf8 = gaim_utf8_try_convert(info->workposition))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Position"), ":</b> ", utf8, NULL);  g_free(tmp); g_free(utf8);
                 }
-                if (info->workwebpage && info->workwebpage[0] && (utf8 = gaim_try_conv_to_utf8(info->workwebpage))) {
+                if (info->workwebpage && info->workwebpage[0] && (utf8 = gaim_utf8_try_convert(info->workwebpage))) {
                         tmp = buf;  buf = g_strconcat(tmp, "\n<br><b>", _("Web Page"), ":</b> <a href=\"", utf8, "\">", utf8, "</a>", NULL);  g_free(tmp); g_free(utf8);
                 }
@@ -4083 +4073 @@
         va_end(ap);
 
-        if (info->uin && info->nick && info->nick[0] && (utf8 = gaim_try_conv_to_utf8(info->nick))) {
+        if (info->uin && info->nick && info->nick[0] && (utf8 = gaim_utf8_try_convert(info->nick))) {
                 g_snprintf(who, sizeof(who), "%u", info->uin);
                 serv_got_alias(gc, who, utf8);
@@ -4098 +4088 @@
 static int gaim_popup(aim_session_t *sess, aim_frame_t *fr, ...)
 {
+        GaimConnection *gc = sess->aux_data;
+        gchar *text;
+        va_list ap;
         char *msg, *url;
         fu16_t wid, hei, delay;
-        va_list ap;
 
         va_start(ap, fr);
@@ -4110 +4102 @@
         va_end(ap);
 
-        serv_got_popup(msg, url, wid, hei);
+        text = g_strdup_printf("%s<br><a href=\"%s\">%s</a>", msg, url, url);
+        gaim_notify_formatted(gc, NULL, _("Pop-Up Message"), NULL, text, NULL, NULL);
+        g_free(text);
 
         return 1;
 }
 
-static int gaim_parse_searchreply(aim_session_t *sess, aim_frame_t *fr, ...) {
+static int gaim_parse_searchreply(aim_session_t *sess, aim_frame_t *fr, ...)
+{
         GaimConnection *gc = sess->aux_data;
         gchar *secondary;
@@ -4248 +4243 @@
 
 static void oscar_keepalive(GaimConnection *gc) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         aim_flap_nop(od->sess, od->conn);
 }
 
 static int oscar_send_typing(GaimConnection *gc, const char *name, int typing) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         struct direct_im *dim = find_direct_im(od, name);
         if (dim)
@@ -4267 +4262 @@
                 for (list=gc->account->deny; (list && aim_sncmp(name, list->data)); list=list->next);
                 if (!list) {
-                        struct buddyinfo *bi = g_hash_table_lookup(od->buddyinfo, normalize(name));
+                        struct buddyinfo *bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(gc->account, name));
                         if (bi && bi->typingnot) {
                                 if (typing == GAIM_TYPING)
@@ -4281 +4276 @@
 }
 static void oscar_ask_direct_im(GaimConnection *gc, const char *name);
-static int gaim_odc_send_im(aim_session_t *, aim_conn_t *, const char *, GaimImFlags);
-
-static int oscar_send_im(GaimConnection *gc, const char *name, const char *message, GaimImFlags imflags) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+static int gaim_odc_send_im(aim_session_t *, aim_conn_t *, const char *, GaimConvImFlags);
+
+static int oscar_send_im(GaimConnection *gc, const char *name, const char *message, GaimConvImFlags imflags) {
+        OscarData *od = (OscarData *)gc->proto_data;
         struct direct_im *dim = find_direct_im(od, name);
         int ret = 0;
@@ -4294 +4289 @@
                 /* If we're directly connected, send a direct IM */
                 ret = gaim_odc_send_im(od->sess, dim->conn, message, imflags);
-        } else if (imflags & GAIM_IM_IMAGES) {
+        } else if (imflags & GAIM_CONV_IM_IMAGES) {
                 /* Trying to send an IM image outside of a direct connection. */
                 oscar_ask_direct_im(gc, name);
@@ -4304 +4299 @@
                 gsize len;
 
-                bi = g_hash_table_lookup(od->buddyinfo, normalize(name));
+                bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(gc->account, name));
                 if (!bi) {
                         bi = g_new0(struct buddyinfo, 1);
-                        g_hash_table_insert(od->buddyinfo, g_strdup(normalize(name)), bi);
+                        g_hash_table_insert(od->buddyinfo, g_strdup(gaim_normalize(gc->account, name)), bi);
                 }
 
@@ -4319 +4314 @@
                         args.featureslen = sizeof(features_aim);
 
-                        if (imflags & GAIM_IM_AUTO_RESP)
+                        if (imflags & GAIM_CONV_IM_AUTO_RESP)
                                 args.flags |= AIM_IMFLAGS_AWAY;
                 }
@@ -4341 +4336 @@
                                 args.iconstamp = st.st_mtime;
 
-                                if ((args.iconlen != bi->ico_me_len) || (args.iconsum != bi->ico_me_csum) || (args.iconstamp != bi->ico_me_time))
+                                if ((args.iconlen != bi->ico_me_len) || (args.iconsum != bi->ico_me_csum) || (args.iconstamp != bi->ico_me_time)) {
                                         bi->ico_informed = FALSE;
+                                        bi->ico_sent     = FALSE;
+                                }
 
                                 if (!bi->ico_informed) {
@@ -4362 +4359 @@
                 /* For ICQ send newlines as CR/LF, for AIM send newlines as <BR> */
                 if (isdigit(name[0]))
-                        tmpmsg = add_cr(message);
+                        tmpmsg = gaim_str_add_cr(message);
                 else
-                        tmpmsg = strdup_withhtml(message);
+                        tmpmsg = gaim_strdup_withhtml(message);
                 len = strlen(tmpmsg);
 
@@ -4421 +4418 @@
 }
 
-static void oscar_get_info(GaimConnection *g, const char *name) {
-        struct oscar_data *od = (struct oscar_data *)g->proto_data;
-        if (od->icq)
+static void oscar_get_info(GaimConnection *gc, const char *name) {
+        OscarData *od = (OscarData *)gc->proto_data;
+
+        if (od->icq && isdigit(name[0]))
                 aim_icq_getallinfo(od->sess, name);
         else
-                /* people want the away message on the top, so we get the away message
-                 * first and then get the regular info, since it's too difficult to
-                 * insert in the middle. i hate people. */
-                aim_getinfo(od->sess, od->conn, name, AIM_GETINFO_AWAYMESSAGE);
-}
-
-static void oscar_get_away(GaimConnection *g, const char *who) {
-        struct oscar_data *od = (struct oscar_data *)g->proto_data;
+                aim_locate_getinfoshort(od->sess, name, 0x00000003);
+}
+
+static void oscar_get_away(GaimConnection *gc, const char *who) {
+        OscarData *od = (OscarData *)gc->proto_data;
         if (od->icq) {
-                GaimBuddy *budlight = gaim_find_buddy(g->account, who);
+                GaimBuddy *budlight = gaim_find_buddy(gc->account, who);
                 if (budlight)
                         if ((budlight->uc & 0xffff0000) >> 16)
@@ -4444 +4439 @@
                 else
                         gaim_debug(GAIM_DEBUG_ERROR, "oscar",
-                                           "Error: Could not find %s in local contact list, therefore unable to request status message.\n", who);
+                                           "Error: Could not find %s in local buddy list, therefore unable to request status message.\n", who);
         } else
-                aim_getinfo(od->sess, od->conn, who, AIM_GETINFO_GENERALINFO);
-}
-
-static void oscar_set_dir(GaimConnection *g, const char *first, const char *middle, const char *last,
+                aim_locate_getinfoshort(od->sess, who, 0x00000002);
+}
+
+static void oscar_set_dir(GaimConnection *gc, const char *first, const char *middle, const char *last,
                           const char *maiden, const char *city, const char *state, const char *country, int web) {
         /* XXX - some of these things are wrong, but i'm lazy */
-        struct oscar_data *od = (struct oscar_data *)g->proto_data;
-        aim_setdirectoryinfo(od->sess, od->conn, first, middle, last,
+        OscarData *od = (OscarData *)gc->proto_data;
+        aim_locate_setdirinfo(od->sess, first, middle, last,
                                 maiden, NULL, NULL, city, state, NULL, 0, web);
 }
 
 static void oscar_set_idle(GaimConnection *gc, int time) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
-        aim_bos_setidle(od->sess, od->conn, time);
+        OscarData *od = (OscarData *)gc->proto_data;
+        aim_srv_setidle(od->sess, time);
 }
 
 static void oscar_set_info(GaimConnection *gc, const char *text) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         fu32_t flags = 0;
         char *text_html = NULL;
@@ -4476 +4471 @@
                                                           "again when you are fully connected."));
 
-        if (od->icq)
-                aim_bos_setprofile(od->sess, od->conn, NULL, NULL, 0, NULL, NULL, 0, caps_icq);
-        else {
-                if (!text) {
-                        aim_bos_setprofile(od->sess, od->conn, NULL, NULL, 0, NULL, NULL, 0, caps_aim);
-                        return;
-                }
+        if (!text) {
+                aim_locate_setprofile(od->sess, NULL, "", 0, NULL, NULL, 0);
+                return;
+        }
                 
-                text_html = strdup_withhtml(text);
-                flags = oscar_encoding_check(text_html);
-                if (flags & AIM_IMFLAGS_UNICODE) {
-                        msg = g_convert(text_html, strlen(text_html), "UCS-2BE", "UTF-8", NULL, &msglen, NULL);
-                        aim_bos_setprofile(od->sess, od->conn, "unicode-2-0", msg, (msglen > od->rights.maxsiglen ? od->rights.maxsiglen : msglen), NULL, NULL, 0, caps_aim);
-                        g_free(msg);
-                } else if (flags & AIM_IMFLAGS_ISO_8859_1) {
-                        msg = g_convert(text_html, strlen(text_html), "ISO-8859-1", "UTF-8", NULL, &msglen, NULL);
-                        aim_bos_setprofile(od->sess, od->conn, "iso-8859-1", msg, (msglen > od->rights.maxsiglen ? od->rights.maxsiglen : msglen), NULL, NULL, 0, caps_aim);
-                        g_free(msg);
-                } else {
-                        msglen = strlen(text_html);
-                        aim_bos_setprofile(od->sess, od->conn, "us-ascii", text_html, (msglen > od->rights.maxsiglen ? od->rights.maxsiglen : msglen), NULL, NULL, 0, caps_aim);
-                }
-
-                if (msglen > od->rights.maxsiglen) {
-                        gchar *errstr;
-                        errstr = g_strdup_printf(ngettext("The maximum profile length of %d byte "
-                                                                         "has been exceeded.  Gaim has truncated it for you.",
-                                                                         "The maximum profile length of %d bytes "
-                                                                         "has been exceeded.  Gaim has truncated it for you.",
-                                                                         od->rights.maxsiglen), od->rights.maxsiglen);
-                        gaim_notify_warning(gc, NULL, _("Profile too long."), errstr);
-                        g_free(errstr);
-                }
-
-                g_free(text_html);
-
-        }
+        text_html = gaim_strdup_withhtml(text);
+        flags = oscar_encoding_check(text_html);
+        if (flags & AIM_IMFLAGS_UNICODE) {
+                msg = g_convert(text_html, strlen(text_html), "UCS-2BE", "UTF-8", NULL, &msglen, NULL);
+                aim_locate_setprofile(od->sess, "unicode-2-0", msg, (msglen > od->rights.maxsiglen ? od->rights.maxsiglen : msglen), NULL, NULL, 0);
+                g_free(msg);
+        } else if (flags & AIM_IMFLAGS_ISO_8859_1) {
+                msg = g_convert(text_html, strlen(text_html), "ISO-8859-1", "UTF-8", NULL, &msglen, NULL);
+                aim_locate_setprofile(od->sess, "iso-8859-1", msg, (msglen > od->rights.maxsiglen ? od->rights.maxsiglen : msglen), NULL, NULL, 0);
+                g_free(msg);
+        } else {
+                msglen = strlen(text_html);
+                aim_locate_setprofile(od->sess, "us-ascii", text_html, (msglen > od->rights.maxsiglen ? od->rights.maxsiglen : msglen), NULL, NULL, 0);
+        }
+
+        if (msglen > od->rights.maxsiglen) {
+                gchar *errstr;
+                errstr = g_strdup_printf(ngettext("The maximum profile length of %d byte "
+                                                                 "has been exceeded.  Gaim has truncated it for you.",
+                                                                 "The maximum profile length of %d bytes "
+                                                                 "has been exceeded.  Gaim has truncated it for you.",
+                                                                 od->rights.maxsiglen), od->rights.maxsiglen);
+                gaim_notify_warning(gc, NULL, _("Profile too long."), errstr);
+                g_free(errstr);
+        }
+
+        g_free(text_html);
 
         return;
 }
 
-static void oscar_set_away_aim(GaimConnection *gc, struct oscar_data *od, const char *text)
+static void oscar_set_away_aim(GaimConnection *gc, OscarData *od, const char *text)
 {
         fu32_t flags = 0;
@@ -4538 +4528 @@
 
         if (!text) {
-                aim_bos_setprofile(od->sess, od->conn, NULL, NULL, 0, NULL, "", 0, caps_aim);
+                aim_locate_setprofile(od->sess, NULL, NULL, 0, NULL, "", 0);
                 return;
         }
 
-        text_html = strdup_withhtml(text);
+        text_html = gaim_strdup_withhtml(text);
         flags = oscar_encoding_check(text_html);
         if (flags & AIM_IMFLAGS_UNICODE) {
                 msg = g_convert(text_html, strlen(text_html), "UCS-2BE", "UTF-8", NULL, &msglen, NULL);
-                aim_bos_setprofile(od->sess, od->conn, NULL, NULL, 0, "unicode-2-0", msg, 
-                        (msglen > od->rights.maxawaymsglen ? od->rights.maxawaymsglen : msglen), caps_aim);
+                aim_locate_setprofile(od->sess, NULL, NULL, 0, "unicode-2-0", msg, 
+                        (msglen > od->rights.maxawaymsglen ? od->rights.maxawaymsglen : msglen));
                 g_free(msg);
                 gc->away = g_strndup(text, od->rights.maxawaymsglen/2);
         } else if (flags & AIM_IMFLAGS_ISO_8859_1) {
                 msg = g_convert(text_html, strlen(text_html), "ISO-8859-1", "UTF-8", NULL, &msglen, NULL);
-                aim_bos_setprofile(od->sess, od->conn, NULL, NULL, 0, "iso-8859-1", msg, 
-                        (msglen > od->rights.maxawaymsglen ? od->rights.maxawaymsglen : msglen), caps_aim);
+                aim_locate_setprofile(od->sess, NULL, NULL, 0, "iso-8859-1", msg, 
+                        (msglen > od->rights.maxawaymsglen ? od->rights.maxawaymsglen : msglen));
                 g_free(msg);
                 gc->away = g_strndup(text_html, od->rights.maxawaymsglen);
         } else {
                 msglen = strlen(text_html);
-                aim_bos_setprofile(od->sess, od->conn, NULL, NULL, 0, "us-ascii", text_html, 
-                        (msglen > od->rights.maxawaymsglen ? od->rights.maxawaymsglen : msglen), caps_aim);
+                aim_locate_setprofile(od->sess, NULL, NULL, 0, "us-ascii", text_html, 
+                        (msglen > od->rights.maxawaymsglen ? od->rights.maxawaymsglen : msglen));
                 gc->away = g_strndup(text_html, od->rights.maxawaymsglen);
         }
@@ -4579 +4569 @@
 }
 
-static void oscar_set_away_icq(GaimConnection *gc, struct oscar_data *od, const char *state, const char *message)
+static void oscar_set_away_icq(GaimConnection *gc, OscarData *od, const char *state, const char *message)
 {
         GaimAccount *account = gaim_connection_get_account(gc);
@@ -4631 +4621 @@
 static void oscar_set_away(GaimConnection *gc, const char *state, const char *message)
 {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
 
         if (od->icq)
@@ -4642 +4632 @@
 
 static void oscar_warn(GaimConnection *gc, const char *name, int anon) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         aim_im_warn(od->sess, od->conn, name, anon ? AIM_WARN_ANON : 0);
 }
@@ -4648 +4638 @@
 static void oscar_dir_search(GaimConnection *gc, const char *first, const char *middle, const char *last,
                              const char *maiden, const char *city, const char *state, const char *country, const char *email) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         if (strlen(email))
                 aim_search_address(od->sess, od->conn, email);
@@ -4654 +4644 @@
 
 static void oscar_add_buddy(GaimConnection *gc, const char *name, GaimGroup *g) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
 #ifdef NOSSI
         aim_add_buddy(od->sess, od->conn, name);
@@ -4673 +4663 @@
 
 static void oscar_add_buddies(GaimConnection *gc, GList *buddies) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
 #ifdef NOSSI
         char buf[MSG_LEN];
@@ -4679 +4669 @@
         while (buddies) {
                 if (n > MSG_LEN - 18) {
-                        aim_bos_setbuddylist(od->sess, od->conn, buf);
+                        aim_buddylist_set(od->sess, od->conn, buf);
                         n = 0;
                 }
@@ -4685 +4675 @@
                 buddies = buddies->next;
         }
-        aim_bos_setbuddylist(od->sess, od->conn, buf);
+        aim_buddylist_set(od->sess, od->conn, buf);
 #else
         if (od->sess->ssi.received_data) {
                 while (buddies) {
-                        GaimBuddy *buddy = gaim_find_buddy(gc->account, (const char *)buddies->data);
-                        GaimGroup *group = gaim_find_buddys_group(buddy);
-                        if (buddy && group) {
-                                gaim_debug(GAIM_DEBUG_INFO, "oscar",
-                                                   "ssi: adding buddy %s to group %s\n", (const char *)buddies->data, group->name);
-                                aim_ssi_addbuddy(od->sess, buddy->name, group->name, gaim_get_buddy_alias_only(buddy), NULL, NULL, 0);
-                        }
+                        oscar_add_buddy(gc, (const char *)buddies->data, NULL);
                         buddies = buddies->next;
                 }
@@ -4703 +4687 @@
 
 static void oscar_remove_buddy(GaimConnection *gc, const char *name, const char *group) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
 #ifdef NOSSI
         aim_remove_buddy(od->sess, od->conn, name);
@@ -4716 +4700 @@
 
 static void oscar_remove_buddies(GaimConnection *gc, GList *buddies, const char *group) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
 #ifdef NOSSI
         GList *cur;
@@ -4735 +4719 @@
 #ifndef NOSSI
 static void oscar_move_buddy(GaimConnection *gc, const char *name, const char *old_group, const char *new_group) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         if (od->sess->ssi.received_data && strcmp(old_group, new_group)) {
                 gaim_debug(GAIM_DEBUG_INFO, "oscar",
@@ -4744 +4728 @@
 
 static void oscar_alias_buddy(GaimConnection *gc, const char *name, const char *alias) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         if (od->sess->ssi.received_data) {
                 char *gname = aim_ssi_itemlist_findparentname(od->sess->ssi.local, name);
@@ -4756 +4740 @@
 
 static void oscar_rename_group(GaimConnection *g, const char *old_group, const char *new_group, GList *members) {
-        struct oscar_data *od = (struct oscar_data *)g->proto_data;
+        OscarData *od = (OscarData *)g->proto_data;
 
         if (od->sess->ssi.received_data) {
@@ -4780 +4764 @@
 static int gaim_ssi_parseerr(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         va_list ap;
         fu16_t reason;
@@ -4807 +4791 @@
 static int gaim_ssi_parserights(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         int numtypes, i;
         fu16_t *maxitems;
@@ -4840 +4824 @@
         GaimConnection *gc = sess->aux_data;
         GaimAccount *account = gaim_connection_get_account(gc);
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         struct aim_ssi_item *curitem;
         int tmp;
@@ -4862 +4846 @@
         /* Add from server list to local list */
         for (curitem=sess->ssi.local; curitem; curitem=curitem->next) {
+                if ((curitem->name == NULL) || (g_utf8_validate(curitem->name, -1, NULL)))
                 switch (curitem->type) {
                         case 0x0000: { /* Buddy */
                                 if (curitem->name) {
                                         char *gname = aim_ssi_itemlist_findparentname(sess->ssi.local, curitem->name);
-                                        char *gname_utf8 = gaim_try_conv_to_utf8(gname);
+                                        char *gname_utf8 = gname ? gaim_utf8_try_convert(gname) : NULL;
                                         char *alias = aim_ssi_getalias(sess->ssi.local, gname, curitem->name);
-                                        char *alias_utf8 = gaim_try_conv_to_utf8(alias);
+                                        char *alias_utf8 = alias ? gaim_utf8_try_convert(alias) : NULL;
                                         GaimBuddy *buddy = gaim_find_buddy(gc->account, curitem->name);
                                         /* Should gname be freed here? -- elb */
@@ -4893 +4878 @@
                                                 export = TRUE;
                                         }
-                                        free(gname_utf8);
-                                        free(alias_utf8);
+                                        g_free(gname_utf8);
+                                        g_free(alias_utf8);
                                 }
                         } break;
@@ -4958 +4943 @@
                 GaimGroup *group;
                 GaimBuddy *buddy;
-                struct gaim_buddy_list *blist;
+                GaimBuddyList *blist;
                 GSList *cur;
 
@@ -4975 +4960 @@
                                                 buddy = (GaimBuddy *)bnode;
                                                 if (buddy->account == gc->account) {
-                                                        gchar *servernick = gaim_buddy_get_setting(buddy, "servernick");
-                                                        if (servernick) {
+                                                        const char *servernick = gaim_buddy_get_setting(buddy, "servernick");
+                                                        if (servernick)
                                                                 serv_got_alias(gc, buddy->name, servernick);
-                                                                g_free(servernick);
-                                                        }
+
                                                         if (aim_ssi_itemlist_exists(sess->ssi.local, buddy->name)) {
                                                                 /* Store local alias on server */
@@ -5061 +5045 @@
                         }
 
-                        case 0x000e: { /* contact requires authorization */
+                        case 0x000e: { /* buddy requires authorization */
                                 if ((retval->action == AIM_CB_SSI_ADD) && (retval->name))
                                         gaim_auth_sendrequest(gc, retval->name);
@@ -5112 +5096 @@
         gaim_request_yes_no(gc, NULL, _("Authorization Given"), dialog_msg,
                                                 0, data,
-                                                G_CALLBACK(gaim_icq_contactadd),
+                                                G_CALLBACK(gaim_icq_buddyadd),
                                                 G_CALLBACK(oscar_free_name_data));
 
@@ -5185 +5169 @@
         if (reply) {
                 /* Granted */
-                dialog_msg = g_strdup_printf(_("The user %s has granted your request to add them to your contact list."), nombre);
+                dialog_msg = g_strdup_printf(_("The user %s has granted your request to add them to your buddy list."), nombre);
                 gaim_notify_info(gc, NULL, _("Authorization Granted"), dialog_msg);
         } else {
                 /* Denied */
-                dialog_msg = g_strdup_printf(_("The user %s has denied your request to add them to your contact list for the following reason:\n%s"), nombre, msg ? msg : _("No reason given."));
+                dialog_msg = g_strdup_printf(_("The user %s has denied your request to add them to your buddy list for the following reason:\n%s"), nombre, msg ? msg : _("No reason given."));
                 gaim_notify_info(gc, NULL, _("Authorization Denied"), dialog_msg);
         }
@@ -5211 +5195 @@
         gaim_debug(GAIM_DEBUG_INFO, "oscar",
                            "ssi: %s added you to their buddy list\n", sn);
-        show_got_added(gc, NULL, sn, (buddy ? gaim_get_buddy_alias_only(buddy) : NULL), NULL);
+        gaim_account_notify_added(gc->account, NULL, sn, (buddy ? gaim_get_buddy_alias_only(buddy) : NULL), NULL);
 
         return 1;
@@ -5238 +5222 @@
 
 static void oscar_join_chat(GaimConnection *g, GHashTable *data) {
-        struct oscar_data *od = (struct oscar_data *)g->proto_data;
+        OscarData *od = (OscarData *)g->proto_data;
         aim_conn_t *cur;
         char *name, *exchange;
@@ -5264 +5248 @@
 
 static void oscar_chat_invite(GaimConnection *g, int id, const char *message, const char *name) {
-        struct oscar_data *od = (struct oscar_data *)g->proto_data;
+        OscarData *od = (OscarData *)g->proto_data;
         struct chat_connection *ccon = find_oscar_chat(g, id);
         
@@ -5275 +5259 @@
 
 static void oscar_chat_leave(GaimConnection *g, int id) {
-        struct oscar_data *od = g ? (struct oscar_data *)g->proto_data : NULL;
+        OscarData *od = g ? (OscarData *)g->proto_data : NULL;
         GSList *bcs = g->buddy_chats;
         GaimConversation *b = NULL;
@@ -5284 +5268 @@
                 count++;
                 b = (GaimConversation *)bcs->data;
-                if (id == gaim_chat_get_id(GAIM_CHAT(b)))
+                if (id == gaim_conv_chat_get_id(GAIM_CONV_CHAT(b)))
                         break;
                 bcs = bcs->next;
@@ -5296 +5280 @@
                            "Attempting to leave room %s (currently in %d rooms)\n", b->name, count);
         
-        c = find_oscar_chat(g, gaim_chat_get_id(GAIM_CHAT(b)));
+        c = find_oscar_chat(g, gaim_conv_chat_get_id(GAIM_CONV_CHAT(b)));
         if (c != NULL) {
                 if (od)
@@ -5309 +5293 @@
         }
         /* we do this because with Oscar it doesn't tell us we left */
-        serv_got_chat_left(g, gaim_chat_get_id(GAIM_CHAT(b)));
+        serv_got_chat_left(g, gaim_conv_chat_get_id(GAIM_CONV_CHAT(b)));
 }
 
 static int oscar_chat_send(GaimConnection *g, int id, const char *message) {
-        struct oscar_data *od = (struct oscar_data *)g->proto_data;
+        OscarData *od = (OscarData *)g->proto_data;
         GSList *bcs = g->buddy_chats;
         GaimConversation *b = NULL;
@@ -5322 +5306 @@
         while (bcs) {
                 b = (GaimConversation *)bcs->data;
-                if (id == gaim_chat_get_id(GAIM_CHAT(b)))
+                if (id == gaim_conv_chat_get_id(GAIM_CONV_CHAT(b)))
                         break;
                 bcs = bcs->next;
@@ -5357 +5341 @@
                 return -E2BIG;
 
-        buf2 = strip_html(buf);
+        buf2 = gaim_markup_strip_html(buf);
         if (strlen(buf2) > c->maxvis) {
                 g_free(buf2);
@@ -5384 +5368 @@
 static void oscar_list_emblems(GaimBuddy *b, char **se, char **sw, char **nw, char **ne)
 {
+        GaimAccount *account = NULL;
+        GaimConnection *gc = NULL;
+        OscarData *od = NULL;
         char *emblems[4] = {NULL,NULL,NULL,NULL};
         int i = 0;
+        aim_userinfo_t *userinfo = NULL;
+
+        if (b != NULL)
+                account = b->account;
+        if (account != NULL)
+                gc = account->gc;
+        if (gc != NULL)
+                od = gc->proto_data;
 
         if (!GAIM_BUDDY_IS_ONLINE(b)) {
-                GaimAccount *account;
-                GaimConnection *gc;
-                struct oscar_data *od;
                 char *gname;
-                if ((b->name) && (account = b->account) && (gc = account->gc) && 
-                        (od = gc->proto_data) && (od->sess->ssi.received_data) && 
+                if ((b->name) && (od) && (od->sess->ssi.received_data) && 
                         (gname = aim_ssi_itemlist_findparentname(od->sess->ssi.local, b->name)) && 
                         (aim_ssi_waitingforauth(od->sess->ssi.local, gname, b->name))) {
@@ -5432 +5423 @@
 /*      if (b->uc & UC_UNCONFIRMED && i < 4)
                 emblems[i++] = "unconfirmed"; */
+
+        if ((i < 4) && (od != NULL)) {
+                userinfo = aim_locate_finduserinfo(od->sess, b->name);
+                if ((userinfo != NULL) && (userinfo->capabilities & AIM_CAPS_SECUREIM))
+                        emblems[i++] = "secure";
+        }
+
         *se = emblems[0];
         *sw = emblems[1];
@@ -5440 +5438 @@
 static char *oscar_tooltip_text(GaimBuddy *b) {
         GaimConnection *gc = b->account->gc;
-        struct oscar_data *od = gc->proto_data;
-        struct buddyinfo *bi = g_hash_table_lookup(od->buddyinfo, normalize(b->name));
-        gchar *tmp, *yay = g_strdup("");
+        OscarData *od = gc->proto_data;
+        struct buddyinfo *bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(b->account, b->name));
+        aim_userinfo_t *userinfo = aim_locate_finduserinfo(od->sess, b->name);
+        gchar *tmp = NULL, *ret = g_strdup("");
 
         if (GAIM_BUDDY_IS_ONLINE(b)) {
                 if (isdigit(b->name[0])) {
-                        char *tmp, *status;
+                        char *status;
                         status = gaim_icq_status((b->uc & 0xffff0000) >> 16);
-                        tmp = yay;
-                        yay = g_strconcat(tmp, _("<b>Status:</b> "), status, "\n", NULL);
+                        tmp = ret;
+                        ret = g_strconcat(tmp, _("<b>Status:</b> "), status, "\n", NULL);
                         g_free(tmp);
                         g_free(status);
                 }
 
-                if (bi) {
-                        char *tstr = sec_to_text(time(NULL) - bi->signon + 
+                if (userinfo != NULL) {
+                        char *tstr = gaim_str_seconds_to_string(time(NULL) - userinfo->onlinesince +
                                 (gc->login_time_official ? gc->login_time_official - gc->login_time : 0));
-                        tmp = yay;
-                        yay = g_strconcat(tmp, _("<b>Logged In:</b> "), tstr, "\n", NULL);
-                        free(tmp);
-                        free(tstr);
-
-                        if (bi->ipaddr) {
-                                char *tstr =  g_strdup_printf("%hhd.%hhd.%hhd.%hhd",
-                                                                (bi->ipaddr & 0xff000000) >> 24,
-                                                                (bi->ipaddr & 0x00ff0000) >> 16,
-                                                                (bi->ipaddr & 0x0000ff00) >> 8,
-                                                                (bi->ipaddr & 0x000000ff));
-                                tmp = yay;
-                                yay = g_strconcat(tmp, _("<b>IP Address:</b> "), tstr, "\n", NULL);
-                                free(tmp);
-                                free(tstr);
-                        }
-
-                        if (bi->caps) {
-                                char *caps = caps_string(bi->caps);
-                                tmp = yay;
-                                yay = g_strconcat(tmp, _("<b>Capabilities:</b> "), caps, "\n", NULL);
-                                free(tmp);
-                        }
-
-                        if (bi->availmsg && !(b->uc & UC_UNAVAILABLE)) {
-                                gchar *escaped = g_markup_escape_text(bi->availmsg, strlen(bi->availmsg));
-                                tmp = yay;
-                                yay = g_strconcat(tmp, _("<b>Available:</b> "), escaped, "\n", NULL);
-                                free(tmp);
-                                g_free(escaped);
+                        tmp = ret;
+                        ret = g_strconcat(tmp, _("<b>Logged In:</b> "), tstr, "\n", NULL);
+                        g_free(tmp);
+                        g_free(tstr);
+                }
+
+                if ((bi != NULL) && (bi->ipaddr)) {
+                        char *tstr =  g_strdup_printf("%hhu.%hhu.%hhu.%hhu",
+                                                        (bi->ipaddr & 0xff000000) >> 24,
+                                                        (bi->ipaddr & 0x00ff0000) >> 16,
+                                                        (bi->ipaddr & 0x0000ff00) >> 8,
+                                                        (bi->ipaddr & 0x000000ff));
+                        tmp = ret;
+                        ret = g_strconcat(tmp, _("<b>IP Address:</b> "), tstr, "\n", NULL);
+                        g_free(tmp);
+                        g_free(tstr);
+                }
+
+                if ((userinfo != NULL) && (userinfo->capabilities)) {
+                        char *caps = caps_string(userinfo->capabilities);
+                        tmp = ret;
+                        ret = g_strconcat(tmp, _("<b>Capabilities:</b> "), caps, "\n", NULL);
+                        g_free(tmp);
+                }
+
+                if ((bi != NULL) && (bi->availmsg != NULL) && !(b->uc & UC_UNAVAILABLE)) {
+                        gchar *escaped = g_markup_escape_text(bi->availmsg, strlen(bi->availmsg));
+                        tmp = ret;
+                        ret = g_strconcat(tmp, _("<b>Available:</b> "), escaped, "\n", NULL);
+                        g_free(tmp);
+                        g_free(escaped);
+                }
+
+                if ((userinfo != NULL) && (userinfo->flags & AIM_FLAG_AWAY) && (userinfo->away_len > 0) && (userinfo->away != NULL) && (userinfo->away_encoding != NULL)) {
+                        gchar *away_utf8 = oscar_encoding_to_utf8(userinfo->away_encoding, userinfo->away, userinfo->away_len);
+                        if (away_utf8 != NULL) {
+                                gchar *tmp1, *tmp2;
+                                const char *tmp3;
+                                tmp1 = gaim_strreplace(away_utf8, "<BR>", "\n");
+                                tmp2 = gaim_markup_strip_html(tmp1);
+                                g_free(tmp1);
+                                tmp1 = g_markup_escape_text(tmp2, strlen(tmp2));
+                                g_free(tmp2);
+                                tmp3 = gaim_str_sub_away_formatters(tmp1, gaim_account_get_username(gaim_connection_get_account(gc)));
+                                g_free(tmp1);
+                                tmp = ret;
+                                ret = g_strconcat(tmp, _("<b>Away Message:</b> "), tmp3, "\n", NULL);
+                                g_free(tmp);
+                                g_free(away_utf8);
                         }
                 }
@@ -5492 +5510 @@
                 char *gname = aim_ssi_itemlist_findparentname(od->sess->ssi.local, b->name);
                 if (aim_ssi_waitingforauth(od->sess->ssi.local, gname, b->name)) {
-                        tmp = yay;
-                        yay = g_strconcat(tmp, _("<b>Status:</b> Not Authorized"), "\n", NULL);
+                        tmp = ret;
+                        ret = g_strconcat(tmp, _("<b>Status:</b> Not Authorized"), "\n", NULL);
                         g_free(tmp);
                 } else {
-                        tmp = yay;
-                        yay = g_strconcat(tmp, _("<b>Status:</b> Offline"), "\n", NULL);
+                        tmp = ret;
+                        ret = g_strconcat(tmp, _("<b>Status:</b> Offline"), "\n", NULL);
                         g_free(tmp);
                 }
@@ -5503 +5521 @@
 
         /* remove the trailing newline character */
-        if (yay)
-                yay[strlen(yay)-1] = '\0';
-        return yay;
+        if (ret)
+                ret[strlen(ret)-1] = '\0';
+        return ret;
 }
 
 static char *oscar_status_text(GaimBuddy *b) {
         GaimConnection *gc = b->account->gc;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         gchar *ret = NULL;
 
@@ -5519 +5537 @@
                         ret = g_strdup(_("Away"));
         } else if (GAIM_BUDDY_IS_ONLINE(b)) {
-                struct buddyinfo *bi = g_hash_table_lookup(od->buddyinfo, normalize(b->name));
+                struct buddyinfo *bi = g_hash_table_lookup(od->buddyinfo, gaim_normalize(b->account, b->name));
                 if (bi->availmsg)
                         ret = g_markup_escape_text(bi->availmsg, strlen(bi->availmsg));
@@ -5536 +5554 @@
 static int oscar_icon_req(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         va_list ap;
         fu16_t type;
         fu8_t flags = 0, length = 0;
         char *md5 = NULL;
+
 
         va_start(ap, fr);
@@ -5598 +5617 @@
 static int gaim_odc_initiate(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         GaimConversation *cnv;
         struct direct_im *dim;
@@ -5646 +5665 @@
         double percent;
         GaimConnection *gc = sess->aux_data;
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         GaimConversation *c;
         struct direct_im *dim;
@@ -5662 +5681 @@
         }
         /* XXX is this really necessary? */
-        while (gtk_events_pending())
-                gtk_main_iteration();
+        gaim_core_mainloop_finish_events();
 
         c = gaim_find_conversation_with_account(sn, gaim_connection_get_account(gc));
@@ -5705 +5723 @@
 static int gaim_odc_incoming(aim_session_t *sess, aim_frame_t *fr, ...) {
         GaimConnection *gc = sess->aux_data;
-        GaimImFlags imflags = 0;
+        GaimConvImFlags imflags = 0;
         GString *newmsg = g_string_new("");
         GSList *images = NULL;
@@ -5726 +5744 @@
 
         if (isawaymsg)
-                imflags |= GAIM_IM_AUTO_RESP;
+                imflags |= GAIM_CONV_IM_AUTO_RESP;
 
         /* message has a binary trailer */
@@ -5790 +5808 @@
                 /* set the flag if we caught any images */
                 if (images)
-                        imflags |= GAIM_IM_IMAGES;
+                        imflags |= GAIM_CONV_IM_IMAGES;
         } else {
                 g_string_append_len(newmsg, msg, len);
@@ -5840 +5858 @@
 }
 
-static int gaim_odc_send_im(aim_session_t *sess, aim_conn_t *conn, const char *message, GaimImFlags imflags) {
+static int gaim_odc_send_im(aim_session_t *sess, aim_conn_t *conn, const char *message, GaimConvImFlags imflags) {
         char *buf;
         size_t len;
         int ret;
 
-        if (imflags & GAIM_IM_IMAGES) {
+        if (imflags & GAIM_CONV_IM_IMAGES) {
                 GString *msg = g_string_new("");
                 GString *data = g_string_new("<BINARY>");
@@ -5872 +5890 @@
                                         g_string_append_printf(msg,
                                                 "<IMG SRC=\"file://%s\" ID=\"%d\" DATASIZE=\"%d\">",
-                                                image->filename, oscar_id, image->size);
+                                                image->filename, oscar_id, (int)image->size);
                                 else
                                         g_string_append_printf(msg,
                                                 "<IMG ID=\"%d\" DATASIZE=\"%d\">",
-                                                oscar_id, image->size);
+                                                oscar_id, (int)image->size);
 
                                 /* ... and append the data to the binary section ... */
                                 g_string_append_printf(data, "<DATA ID=\"%d\" SIZE=\"%d\">",
-                                        oscar_id, image->size);
+                                        oscar_id, (int)image->size);
                                 data = g_string_append_len(data, image->data, image->size);
                                 data = g_string_append(data, "</DATA>");
@@ -5915 +5933 @@
 
         /* XXX - The last parameter below is the encoding.  Let Paco-Paco do something with it. */
-        if (imflags & GAIM_IM_AUTO_RESP)
+        if (imflags & GAIM_CONV_IM_AUTO_RESP)
                 ret =  aim_odc_send_im(sess, conn, buf, len, 0, 1);
         else
@@ -5937 +5955 @@
 static void oscar_direct_im(struct ask_do_dir_im *data) {
         GaimConnection *gc = data->gc;
-        struct oscar_data *od;
+        OscarData *od;
         struct direct_im *dim;
 
@@ -5946 +5964 @@
         }
 
-        od = (struct oscar_data *)gc->proto_data;
+        od = (OscarData *)gc->proto_data;
 
         dim = find_direct_im(od, data->who);
@@ -6002 +6020 @@
 static void oscar_set_permit_deny(GaimConnection *gc) {
         GaimAccount *account = gaim_connection_get_account(gc);
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
 #ifdef NOSSI
         GSList *list, *g = gaim_blist_groups(), *g1;
@@ -6066 +6084 @@
                 oscar_set_permit_deny(gc);
 #else
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         gaim_debug(GAIM_DEBUG_INFO, "oscar", "ssi: About to add a permit\n");
         if (od->sess->ssi.received_data)
@@ -6078 +6096 @@
                 oscar_set_permit_deny(gc);
 #else
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         gaim_debug(GAIM_DEBUG_INFO, "oscar", "ssi: About to add a deny\n");
         if (od->sess->ssi.received_data)
@@ -6090 +6108 @@
                 oscar_set_permit_deny(gc);
 #else
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         gaim_debug(GAIM_DEBUG_INFO, "oscar", "ssi: About to delete a permit\n");
         if (od->sess->ssi.received_data)
@@ -6102 +6120 @@
                 oscar_set_permit_deny(gc);
 #else
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
+        OscarData *od = (OscarData *)gc->proto_data;
         gaim_debug(GAIM_DEBUG_INFO, "oscar", "ssi: About to delete a deny\n");
         if (od->sess->ssi.received_data)
@@ -6111 +6129 @@
 static GList *oscar_away_states(GaimConnection *gc)
 {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         GList *m = NULL;
 
@@ -6128 +6146 @@
 }
 
+static void oscar_ssi_editcomment(struct name_data *data, const char *text) {
+        OscarData *od = data->gc->proto_data;
+        GaimBuddy *b;
+        GaimGroup *g;
+
+        if (!(b = gaim_find_buddy(gaim_connection_get_account(data->gc), data->name))) {
+                oscar_free_name_data(data);
+                return;
+        }
+
+        if (!(g = gaim_find_buddys_group(b))) {
+                oscar_free_name_data(data);
+                return;
+        }
+
+        aim_ssi_editcomment(od->sess, g->name, data->name, text);
+        oscar_free_name_data(data);
+}
+
+static void oscar_buddycb_edit_comment(GaimConnection *gc, const char *name) {
+        OscarData *od = gc->proto_data;
+        struct name_data *data = g_new(struct name_data, 1);
+        GaimBuddy *b;
+        GaimGroup *g;
+        char *comment;
+        gchar *comment_utf8;
+
+        if (!(b = gaim_find_buddy(gaim_connection_get_account(gc), name)))
+                return;
+        if (!(g = gaim_find_buddys_group(b)))
+                return;
+        comment = aim_ssi_getcomment(od->sess->ssi.local, g->name, name);
+        comment_utf8 = comment ? gaim_utf8_try_convert(comment) : NULL;
+
+        data->gc = gc;
+        data->name = g_strdup(name);
+        data->nick = NULL;
+
+        gaim_request_input(gc, NULL, _("Buddy Comment:"), NULL,
+                                           comment_utf8, TRUE, FALSE,
+                                           _("OK"), G_CALLBACK(oscar_ssi_editcomment),
+                                           _("Cancel"), G_CALLBACK(oscar_free_name_data),
+                                           data);
+
+        free(comment);
+        g_free(comment_utf8);
+}
+
 static GList *oscar_buddy_menu(GaimConnection *gc, const char *who) {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         GList *m = NULL;
         struct proto_buddy_menu *pbm;
+
+        pbm = g_new0(struct proto_buddy_menu, 1);
+        pbm->label = _("Edit Buddy Comment");
+        pbm->callback = oscar_buddycb_edit_comment;
+        pbm->gc = gc;
+        m = g_list_append(m, pbm);
 
         if (od->icq) {
@@ -6143 +6215 @@
         } else {
                 GaimBuddy *b = gaim_find_buddy(gc->account, who);
-                struct buddyinfo *bi;
+                aim_userinfo_t *userinfo;
 
                 if (b)
-                        bi = g_hash_table_lookup(od->buddyinfo, normalize(b->name));
-
-                if (b && bi && aim_sncmp(gaim_account_get_username(gaim_connection_get_account(gc)), who) && GAIM_BUDDY_IS_ONLINE(b)) {
-                        if (bi->caps & AIM_CAPS_DIRECTIM) {
+                        userinfo = aim_locate_finduserinfo(od->sess, b->name);
+
+                if (b && userinfo && aim_sncmp(gaim_account_get_username(gaim_connection_get_account(gc)), who) && GAIM_BUDDY_IS_ONLINE(b)) {
+                        if (userinfo->capabilities & AIM_CAPS_DIRECTIM) {
                                 pbm = g_new0(struct proto_buddy_menu, 1);
                                 pbm->label = _("Direct IM");
@@ -6157 +6229 @@
                         }
 
-                        if (bi->caps & AIM_CAPS_SENDFILE) {
+                        if (userinfo->capabilities & AIM_CAPS_SENDFILE) {
                                 pbm = g_new0(struct proto_buddy_menu, 1);
                                 pbm->label = _("Send File");
@@ -6165 +6237 @@
                         }
 #if 0
-                        if (bi->caps & AIM_CAPS_GETFILE) {
+                        if (userinfo->capabilities & AIM_CAPS_GETFILE) {
                                 pbm = g_new0(struct proto_buddy_menu, 1);
                                 pbm->label = _("Get File");
@@ -6191 +6263 @@
 
 static void oscar_format_screenname(GaimConnection *gc, const char *nick) {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         if (!aim_sncmp(gaim_account_get_username(gaim_connection_get_account(gc)), nick)) {
                 if (!aim_getconn_type(od->sess, AIM_CONN_TYPE_AUTH)) {
@@ -6217 +6289 @@
 static void oscar_confirm_account(GaimConnection *gc)
 {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         aim_conn_t *conn = aim_getconn_type(od->sess, AIM_CONN_TYPE_AUTH);
 
@@ -6230 +6302 @@
 static void oscar_show_email(GaimConnection *gc)
 {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         aim_conn_t *conn = aim_getconn_type(od->sess, AIM_CONN_TYPE_AUTH);
 
@@ -6243 +6315 @@
 static void oscar_change_email(GaimConnection *gc, const char *email)
 {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         aim_conn_t *conn = aim_getconn_type(od->sess, AIM_CONN_TYPE_AUTH);
 
@@ -6266 +6338 @@
 static void oscar_show_awaitingauth(GaimConnection *gc)
 {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         gchar *nombre, *text, *tmp;
         GaimBlistNode *gnode, *cnode, *bnode;
@@ -6312 +6384 @@
 }
 
+static void search_by_email_cb(GaimConnection *gc, const char *email)
+{
+        serv_dir_search(gc, "", "", "", "", "", "", "", email);
+}
+
+static void oscar_show_find_email(GaimConnection *gc)
+{
+        gaim_request_input(gc, _("Find Buddy by E-mail"),
+                                           _("Search for a buddy by e-mail address"),
+                                           _("Type the e-mail address of the buddy you are "
+                                                 "searching for."),
+                                           NULL, FALSE, FALSE,
+                                           _("Search"), G_CALLBACK(search_by_email_cb),
+                                           _("Cancel"), NULL, gc);
+}
+
 #if 0
 static void oscar_setavailmsg(GaimConnection *gc, char *text) {
-        struct oscar_data *od = (struct oscar_data *)gc->proto_data;
-
+        OscarData *od = (OscarData *)gc->proto_data;
+
+        aim_locate_setprofile(od->sess, NULL, NULL, 0, NULL, "", 0);
         aim_srv_setavailmsg(od->sess, text);
 }
@@ -6321 +6410 @@
 static void oscar_show_setavailmsg(GaimConnection *gc)
 {
-        gaim_request_input(gc, NULL, _("Available Message:"),
-                                           NULL, _("Please talk to me, I'm lonely! (and single)"), TRUE, FALSE,
+        gaim_request_input(gc, NULL, _("Available Message:"), NULL,
+                                           _("I'm doing work and hoping for a distraction--IM me!"), 
+                                           TRUE, FALSE,
                                            _("OK"), G_CALLBACK(oscar_setavailmsg),
                                            _("Cancel"), NULL,
@@ -6329 +6419 @@
 #endif
 
+static void oscar_show_set_info(GaimConnection *gc)
+{
+        gaim_account_request_change_user_info(gaim_connection_get_account(gc));
+}
+
+static void oscar_change_pass(GaimConnection *gc)
+{
+        gaim_account_request_change_password(gaim_connection_get_account(gc));
+}
+
 static void oscar_show_chpassurl(GaimConnection *gc)
 {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         gchar *substituted = gaim_strreplace(od->sess->authinfo->chpassurl, "%s", gaim_account_get_username(gaim_connection_get_account(gc)));
         gaim_notify_uri(gc, substituted);
@@ -6337 +6437 @@
 }
 
+static void oscar_show_imforwardingurl(GaimConnection *gc)
+{
+        gaim_notify_uri(gc, "http://mymobile.aol.com/dbreg/register?action=imf&clientID=1");
+}
+
 static void oscar_set_icon(GaimConnection *gc, const char *iconfile)
 {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         aim_session_t *sess = od->sess;
         FILE *file;
@@ -6372 +6477 @@
 static GList *oscar_actions(GaimConnection *gc)
 {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         struct proto_actions_menu *pam;
         GList *m = NULL;
@@ -6378 +6483 @@
         pam = g_new0(struct proto_actions_menu, 1);
         pam->label = _("Set User Info");
-        pam->callback = show_set_info;
+        pam->callback = oscar_show_set_info;
         pam->gc = gc;
         m = g_list_append(m, pam);
@@ -6392 +6497 @@
         pam = g_new0(struct proto_actions_menu, 1);
         pam->label = _("Change Password");
-        pam->callback = show_change_passwd;
+        pam->callback = oscar_change_pass;
         pam->gc = gc;
         m = g_list_append(m, pam);
@@ -6404 +6509 @@
         }
 
+        if (od->sess->authinfo->chpassurl) {
+                pam = g_new0(struct proto_actions_menu, 1);
+                pam->label = _("Configure IM Forwarding (URL)");
+                pam->callback = oscar_show_imforwardingurl;
+                pam->gc = gc;
+                m = g_list_append(m, pam);
+        }
+
         if (!od->icq) {
                 /* AIM actions */
@@ -6445 +6558 @@
         pam = g_new0(struct proto_actions_menu, 1);
         pam->label = _("Search for Buddy by Email");
-        pam->callback = show_find_email;
+        pam->callback = oscar_show_find_email;
         pam->gc = gc;
         m = g_list_append(m, pam);
@@ -6460 +6573 @@
 static void oscar_change_passwd(GaimConnection *gc, const char *old, const char *new)
 {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
 
         if (od->icq) {
@@ -6479 +6592 @@
 static void oscar_convo_closed(GaimConnection *gc, const char *who)
 {
-        struct oscar_data *od = gc->proto_data;
+        OscarData *od = gc->proto_data;
         struct direct_im *dim = find_direct_im(od, who);
 

libfaim/popups.c

@@ -23 +23 @@
         fu16_t width, height, delay;
 
-        tl = aim_readtlvchain(bs);
+        tl = aim_tlvlist_read(bs);
 
-        msg = aim_gettlv_str(tl, 0x0001, 1);
-        url = aim_gettlv_str(tl, 0x0002, 1);
-        width = aim_gettlv16(tl, 0x0003, 1);
-        height = aim_gettlv16(tl, 0x0004, 1);
-        delay = aim_gettlv16(tl, 0x0005, 1);
+        msg = aim_tlv_getstr(tl, 0x0001, 1);
+        url = aim_tlv_getstr(tl, 0x0002, 1);
+        width = aim_tlv_get16(tl, 0x0003, 1);
+        height = aim_tlv_get16(tl, 0x0004, 1);
+        delay = aim_tlv_get16(tl, 0x0005, 1);
 
         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
                 ret = userfunc(sess, rx, msg, url, width, height, delay);
 
-        aim_freetlvchain(&tl);
+        aim_tlvlist_free(&tl);
         free(msg);
         free(url);

libfaim/rxhandlers.c

@@ -185 +185 @@
                 return consumenonsnac(sess, fr, 0x0017, 0x0003);
 
-        tlvlist = aim_readtlvchain(&fr->data);
-
-        if (aim_gettlv(tlvlist, 0x0009, 1))
-                code = aim_gettlv16(tlvlist, 0x0009, 1);
-
-        if (aim_gettlv(tlvlist, 0x000b, 1))
-                msg = aim_gettlv_str(tlvlist, 0x000b, 1);
+        tlvlist = aim_tlvlist_read(&fr->data);
+
+        if (aim_tlv_gettlv(tlvlist, 0x0009, 1))
+                code = aim_tlv_get16(tlvlist, 0x0009, 1);
+
+        if (aim_tlv_gettlv(tlvlist, 0x000b, 1))
+                msg = aim_tlv_getstr(tlvlist, 0x000b, 1);
 
         if ((userfunc = aim_callhandler(sess, fr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR))) 
                 ret = userfunc(sess, fr, code, msg);
 
-        aim_freetlvchain(&tlvlist);
+        aim_tlvlist_free(&tlvlist);
 
         free(msg);

libfaim/search.c

@@ -78 +78 @@
                 searchaddr = (char *)snac2->data;
 
-        tlvlist = aim_readtlvchain(bs);
-        m = aim_counttlvchain(&tlvlist);
+        tlvlist = aim_tlvlist_read(bs);
+        m = aim_tlvlist_count(&tlvlist);
 
-        /* XXX uhm. */
-        while ((cur = aim_gettlv_str(tlvlist, 0x0001, j+1)) && j < m) {
+        /* XXX uhm.
+         * This is the only place that uses something other than 1 for the 3rd 
+         * parameter to aim_tlv_gettlv_whatever().
+         */
+        while ((cur = aim_tlv_getstr(tlvlist, 0x0001, j+1)) && j < m) {
                 buf = realloc(buf, (j+1) * (MAXSNLEN+1));
 
@@ -91 +94 @@
         }
 
-        aim_freetlvchain(&tlvlist);
+        aim_tlvlist_free(&tlvlist);
 
         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))

libfaim/service.c

@@ -109 +109 @@
         memset(&redir, 0, sizeof(redir));
 
-        tlvlist = aim_readtlvchain(bs);
-
-        if (!aim_gettlv(tlvlist, 0x000d, 1) ||
-                        !aim_gettlv(tlvlist, 0x0005, 1) ||
-                        !aim_gettlv(tlvlist, 0x0006, 1)) {
-                aim_freetlvchain(&tlvlist);
+        tlvlist = aim_tlvlist_read(bs);
+
+        if (!aim_tlv_gettlv(tlvlist, 0x000d, 1) ||
+                        !aim_tlv_gettlv(tlvlist, 0x0005, 1) ||
+                        !aim_tlv_gettlv(tlvlist, 0x0006, 1)) {
+                aim_tlvlist_free(&tlvlist);
                 return 0;
         }
 
-        redir.group = aim_gettlv16(tlvlist, 0x000d, 1);
-        redir.ip = aim_gettlv_str(tlvlist, 0x0005, 1);
-        redir.cookielen = aim_gettlv(tlvlist, 0x0006, 1)->length;
-        redir.cookie = aim_gettlv_str(tlvlist, 0x0006, 1);
+        redir.group = aim_tlv_get16(tlvlist, 0x000d, 1);
+        redir.ip = aim_tlv_getstr(tlvlist, 0x0005, 1);
+        redir.cookielen = aim_tlv_gettlv(tlvlist, 0x0006, 1)->length;
+        redir.cookie = aim_tlv_getstr(tlvlist, 0x0006, 1);
 
         /* Fetch original SNAC so we can get csi if needed */
@@ -144 +144 @@
         free(origsnac);
 
-        aim_freetlvchain(&tlvlist);
+        aim_tlvlist_free(&tlvlist);
 
         return ret;
@@ -152 +152 @@
 faim_internal int aim_reqrates(aim_session_t *sess, aim_conn_t *conn)
 {
-        return aim_genericreq_n(sess, conn, 0x0001, 0x0006);
+        return aim_genericreq_n_snacid(sess, conn, 0x0001, 0x0006);
 }
 
@@ -492 +492 @@
 faim_export int aim_reqpersonalinfo(aim_session_t *sess, aim_conn_t *conn)
 {
-        return aim_genericreq_n(sess, conn, 0x0001, 0x000e);
+        return aim_genericreq_n_snacid(sess, conn, 0x0001, 0x000e);
 }
 
@@ -544 +544 @@
  *
  */
-faim_export int aim_bos_setidle(aim_session_t *sess, aim_conn_t *conn, fu32_t idletime)
-{
+faim_export int aim_srv_setidle(aim_session_t *sess, fu32_t idletime)
+{
+        aim_conn_t *conn;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_BOS)))
+                return -EINVAL;
+
         return aim_genericreq_l(sess, conn, 0x0001, 0x0011, &idletime);
 }
@@ -586 +591 @@
         }
 
-        tl = aim_readtlvchain(bs);
-
-        if (aim_gettlv(tl, 0x0005, 1))
-                ip = aim_gettlv_str(tl, 0x0005, 1);
-
-        cktlv = aim_gettlv(tl, 0x0006, 1);
+        tl = aim_tlvlist_read(bs);
+
+        if (aim_tlv_gettlv(tl, 0x0005, 1))
+                ip = aim_tlv_getstr(tl, 0x0005, 1);
+
+        cktlv = aim_tlv_gettlv(tl, 0x0006, 1);
 
         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
                 ret = userfunc(sess, rx, ip, cktlv ? cktlv->value : NULL);
 
-        aim_freetlvchain(&tl);
+        aim_tlvlist_free(&tl);
         free(ip);
 
@@ -627 +632 @@
          * TLVs follow 
          */
-        tlvlist = aim_readtlvchain(bs);
-
-        msg = aim_gettlv_str(tlvlist, 0x000b, 1);
+        tlvlist = aim_tlvlist_read(bs);
+
+        msg = aim_tlv_getstr(tlvlist, 0x000b, 1);
 
         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
@@ -636 +641 @@
         free(msg);
 
-        aim_freetlvchain(&tlvlist);
+        aim_tlvlist_free(&tlvlist);
 
         return ret;
@@ -661 +666 @@
  * really necessary.
  *
+ * Wha?  No?  Since when?  I think WinAIM sends an empty channel 3 
+ * SNAC as a no-op...
  */
 faim_export int aim_nop(aim_session_t *sess, aim_conn_t *conn)
@@ -761 +768 @@
         aim_putsnac(&fr->data, 0x0001, 0x001e, 0x0000, snacid);
         
-        aim_addtlvtochain32(&tl, 0x0006, data);
-        aim_writetlvchain(&fr->data, &tl);
-        aim_freetlvchain(&tl);
+        aim_tlvlist_add_32(&tl, 0x0006, data);
+        aim_tlvlist_write(&fr->data, &tl);
+        aim_tlvlist_free(&tl);
         
         aim_tx_enqueue(sess, fr);
@@ -788 +795 @@
                 return -EINVAL;
 
-        if (msg) {
+        if (msg != NULL) {
                 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 4 + strlen(msg) + 8)))
                         return -ENOMEM;
@@ -795 +802 @@
                 aim_putsnac(&fr->data, 0x0001, 0x001e, 0x0000, snacid);
 
-                aimbs_put16(&fr->data, 0x001d);
-                aimbs_put16(&fr->data, strlen(msg)+8);
+                aimbs_put16(&fr->data, 0x001d); /* userinfo TLV type */
+                aimbs_put16(&fr->data, strlen(msg)+8); /* total length of userinfo TLV data */
                 aimbs_put16(&fr->data, 0x0002);
                 aimbs_put8(&fr->data, 0x04);
@@ -871 +878 @@
         offset = aimbs_get32(bs);
         len = aimbs_get32(bs);
-        list = aim_readtlvchain(bs);
-
-        modname = aim_gettlv_str(list, 0x0001, 1);
+        list = aim_tlvlist_read(bs);
+
+        modname = aim_tlv_getstr(list, 0x0001, 1);
 
         faimdprintf(sess, 1, "data at 0x%08lx (%d bytes) of requested\n", offset, len, modname ? modname : "aim.exe");
@@ -881 +888 @@
 
         free(modname);
-        aim_freetlvchain(&list);
+        aim_tlvlist_free(&list);
 
         return ret;
@@ -1068 +1075 @@
 }
 
-faim_internal int general_modfirst(aim_session_t *sess, aim_module_t *mod)
+faim_internal int service_modfirst(aim_session_t *sess, aim_module_t *mod)
 {
 
@@ -1076 +1083 @@
         mod->toolversion = 0x0629;
         mod->flags = 0;
-        strncpy(mod->name, "general", sizeof(mod->name));
+        strncpy(mod->name, "service", sizeof(mod->name));
         mod->snachandler = snachandler;
 

libfaim/ssi.c

@@ -22 +22 @@
  * You don't know the half of it.
  *
- * XXX - Preserve unknown data in TLV lists
- *
  */
 
@@ -39 +37 @@
 static struct aim_ssi_item *aim_ssi_itemlist_rebuildgroup(struct aim_ssi_item *list, const char *name)
 {
-  int newlen;
-  struct aim_ssi_item *cur, *group;
-
-  owl_function_debugmsg("aim_ssi_itemlist_rebuildgroup: in for group %s", name?name:"NULL");
-  
-  if (!list) return(NULL);
-  
-  /* Find the group */
-  if (!(group = aim_ssi_itemlist_finditem(list, name, NULL, AIM_SSI_TYPE_GROUP))) return(NULL);
-  
-  /* Free the old data */
-  aim_freetlvchain(&group->data);
-  group->data = NULL;
-  
-  /* Find the length for the new additional data */
-  newlen = 0;
-  if (group->gid == 0x0000) {
-    for (cur=list; cur; cur=cur->next)
-      if ((cur->type == AIM_SSI_TYPE_GROUP) && (cur->gid != 0x0000))
-        newlen += 2;
-  } else {
-    for (cur=list; cur; cur=cur->next)
-      if ((cur->gid == group->gid) && (cur->type == AIM_SSI_TYPE_BUDDY))
-        newlen += 2;
-  }
-  owl_function_debugmsg("aim_ssi_itemlist_rebuildgroup: newlen is %i", newlen);
-  
-  /* Build the new TLV list */
-  if (newlen > 0) {
-    fu8_t *newdata;
-    
-    if (!(newdata = (fu8_t *)malloc((newlen)*sizeof(fu8_t)))) return NULL;
-    newlen = 0;
-    if (group->gid == 0x0000) {
-      for (cur=list; cur; cur=cur->next)
-        if ((cur->type == AIM_SSI_TYPE_GROUP) && (cur->gid != 0x0000))
-          newlen += aimutil_put16(newdata+newlen, cur->gid);
-    } else {
-      for (cur=list; cur; cur=cur->next)
-        if ((cur->gid == group->gid) && (cur->type == AIM_SSI_TYPE_BUDDY))
-          newlen += aimutil_put16(newdata+newlen, cur->bid);
-    }
-    aim_addtlvtochain_raw(&group->data, 0x00c8, newlen, newdata);
-    
-    free(newdata);
-  }
-
-  owl_function_debugmsg("aim_ssi_itemlist_rebuildgroup: exiting");
-  return group;
+        int newlen;
+        struct aim_ssi_item *cur, *group;
+
+        if (!list)
+                return NULL;
+
+        /* Find the group */
+        if (!(group = aim_ssi_itemlist_finditem(list, name, NULL, AIM_SSI_TYPE_GROUP)))
+                return NULL;
+
+        /* Find the length for the new additional data */
+        newlen = 0;
+        if (group->gid == 0x0000) {
+                for (cur=list; cur; cur=cur->next)
+                        if ((cur->type == AIM_SSI_TYPE_GROUP) && (cur->gid != 0x0000))
+                                newlen += 2;
+        } else {
+                for (cur=list; cur; cur=cur->next)
+                        if ((cur->gid == group->gid) && (cur->type == AIM_SSI_TYPE_BUDDY))
+                                newlen += 2;
+        }
+
+        /* Build the new TLV list */
+        if (newlen > 0) {
+                fu8_t *newdata;
+
+                if (!(newdata = (fu8_t *)malloc((newlen)*sizeof(fu8_t))))
+                        return NULL;
+                newlen = 0;
+                if (group->gid == 0x0000) {
+                        for (cur=list; cur; cur=cur->next)
+                                if ((cur->type == AIM_SSI_TYPE_GROUP) && (cur->gid != 0x0000))
+                                                newlen += aimutil_put16(newdata+newlen, cur->gid);
+                } else {
+                        for (cur=list; cur; cur=cur->next)
+                                if ((cur->gid == group->gid) && (cur->type == AIM_SSI_TYPE_BUDDY))
+                                                newlen += aimutil_put16(newdata+newlen, cur->bid);
+                }
+                aim_tlvlist_replace_raw(&group->data, 0x00c8, newlen, newdata);
+
+                free(newdata);
+        }
+
+        return group;
 }
 
@@ -104 +97 @@
 static struct aim_ssi_item *aim_ssi_itemlist_add(struct aim_ssi_item **list, const char *name, fu16_t gid, fu16_t bid, fu16_t type, aim_tlvlist_t *data)
 {
-  int i;
-  struct aim_ssi_item *cur, *new;
-  
-  if (!list) return(NULL);
-  
-  if (!(new = (struct aim_ssi_item *)malloc(sizeof(struct aim_ssi_item)))) return(NULL);
-  
-  /* Set the name */
-  if (name) {
-    new->name = (char *)malloc((strlen(name)+1)*sizeof(char));
-    strcpy(new->name, name);
-  } else {
-    new->name = NULL;
-  }
-  
-  /* Set the group ID# and buddy ID# */
-  new->gid = gid;
-  new->bid = bid;
-  if (type == AIM_SSI_TYPE_GROUP) {
-    if ((new->gid == 0xFFFF) && name) {
-      do {
-        new->gid += 0x0001;
-        for (cur=*list, i=0; ((cur) && (!i)); cur=cur->next)
-          if ((cur->type == AIM_SSI_TYPE_GROUP) && (cur->gid == new->gid))
-            i=1;
-      } while (i);
-    }
-  } else {
-    if (new->bid == 0xFFFF) {
-      do {
-        new->bid += 0x0001;
-        for (cur=*list, i=0; ((cur) && (!i)); cur=cur->next)
-          if ((cur->bid == new->bid) && (cur->gid == new->gid))
-            i=1;
-      } while (i);
-    }
-  }
-  
-  /* Set the type */
-  new->type = type;
-  
-  /* Set the TLV list */
-  new->data = aim_tlvlist_copy(data);
-  
-  /* Add the item to the list in the correct numerical position.  Fancy, eh? */
-  if (*list) {
-    if ((new->gid < (*list)->gid) || ((new->gid == (*list)->gid) && (new->bid < (*list)->bid))) {
-      new->next = *list;
-      *list = new;
-    } else {
-      struct aim_ssi_item *prev;
-      for ((prev=*list, cur=(*list)->next); (cur && ((new->gid > cur->gid) || ((new->gid == cur->gid) && (new->bid > cur->bid)))); prev=cur, cur=cur->next);
-      new->next = prev->next;
-      prev->next = new;
-    }
-  } else {
-    new->next = *list;
-    *list = new;
-  }
-
-  return(new);
+        int i;
+        struct aim_ssi_item *cur, *new;
+
+        if (!list)
+                return NULL;
+
+        if (!(new = (struct aim_ssi_item *)malloc(sizeof(struct aim_ssi_item))))
+                return NULL;
+
+        /* Set the name */
+        if (name) {
+                new->name = (char *)malloc((strlen(name)+1)*sizeof(char));
+                strcpy(new->name, name);
+        } else
+                new->name = NULL;
+
+        /* Set the group ID# and buddy ID# */
+        new->gid = gid;
+        new->bid = bid;
+        if (type == AIM_SSI_TYPE_GROUP) {
+                if ((new->gid == 0xFFFF) && name) {
+                        do {
+                                new->gid += 0x0001;
+                                for (cur=*list, i=0; ((cur) && (!i)); cur=cur->next)
+                                        if ((cur->type == AIM_SSI_TYPE_GROUP) && (cur->gid == new->gid))
+                                                i=1;
+                        } while (i);
+                }
+        } else {
+                if (new->bid == 0xFFFF) {
+                        do {
+                                new->bid += 0x0001;
+                                for (cur=*list, i=0; ((cur) && (!i)); cur=cur->next)
+                                        if ((cur->bid == new->bid) && (cur->gid == new->gid))
+                                                i=1;
+                        } while (i);
+                }
+        }
+
+        /* Set the type */
+        new->type = type;
+
+        /* Set the TLV list */
+        new->data = aim_tlvlist_copy(data);
+
+        /* Add the item to the list in the correct numerical position.  Fancy, eh? */
+        if (*list) {
+                if ((new->gid < (*list)->gid) || ((new->gid == (*list)->gid) && (new->bid < (*list)->bid))) {
+                        new->next = *list;
+                        *list = new;
+                } else {
+                        struct aim_ssi_item *prev;
+                        for ((prev=*list, cur=(*list)->next); (cur && ((new->gid > cur->gid) || ((new->gid == cur->gid) && (new->bid > cur->bid)))); prev=cur, cur=cur->next);
+                        new->next = prev->next;
+                        prev->next = new;
+                }
+        } else {
+                new->next = *list;
+                *list = new;
+        }
+
+        return new;
 }
 
@@ -176 +170 @@
 static int aim_ssi_itemlist_del(struct aim_ssi_item **list, struct aim_ssi_item *del)
 {
-  if (!list || !(*list) || !del) return -EINVAL;
-
-  owl_function_debugmsg("aim_ssi_itemlist_del: in");
-  /* Remove the item from the list */
-  if (*list == del) {
-    *list = (*list)->next;
-    owl_function_debugmsg("aim_ssi_itemlist_del: deleted %s from beginning of list", del->name);
-  } else {
-    struct aim_ssi_item *cur;
-    for (cur=*list; (cur->next && (cur->next!=del)); cur=cur->next);
-    if (cur->next) cur->next=cur->next->next;
-    owl_function_debugmsg("aim_ssi_itemlist_del: deleted %s from middle of list", del->name);
-  }
-
-  /* Free the deleted item */
-  owl_function_debugmsg("aim_ssi_itemlist_del: freeing");
-  free(del->name);
-  aim_freetlvchain(&del->data);
-  free(del);
-
-  return(0);
+        if (!list || !(*list) || !del)
+                return -EINVAL;
+
+        /* Remove the item from the list */
+        if (*list == del) {
+                *list = (*list)->next;
+        } else {
+                struct aim_ssi_item *cur;
+                for (cur=*list; (cur->next && (cur->next!=del)); cur=cur->next);
+                if (cur->next)
+                        cur->next = del->next;
+        }
+
+        /* Free the removed item */
+        free(del->name);
+        aim_tlvlist_free(&del->data);
+        free(del);
+
+        return 0;
 }
 
@@ -208 +200 @@
 static int aim_ssi_itemlist_cmp(struct aim_ssi_item *cur1, struct aim_ssi_item *cur2)
 {
-  if (!cur1 || !cur2)
-    return 1;
-  
-  if (cur1->data && !cur2->data)
-    return 2;
-  
-  if (!cur1->data && cur2->data)
-    return 3;
-  
-  if ((cur1->data && cur2->data) && (aim_tlvlist_cmp(cur1->data, cur2->data)))
-    return 4;
-  
-  if (cur1->name && !cur2->name)
-    return 5;
-  
-  if (!cur1->name && cur2->name)
-    return 6;
-  
-  if (cur1->name && cur2->name && aim_sncmp(cur1->name, cur2->name))
-    return 7;
-  
-  if (cur1->gid != cur2->gid)
-    return 8;
-  
-  if (cur1->bid != cur2->bid)
-    return 9;
-  
-  if (cur1->type != cur2->type)
-    return 10;
-  
-  return 0;
+        if (!cur1 || !cur2)
+                return 1;
+
+        if (cur1->data && !cur2->data)
+                return 2;
+
+        if (!cur1->data && cur2->data)
+                return 3;
+
+        if ((cur1->data && cur2->data) && (aim_tlvlist_cmp(cur1->data, cur2->data)))
+                        return 4;
+
+        if (cur1->name && !cur2->name)
+                return 5;
+
+        if (!cur1->name && cur2->name)
+                return 6;
+
+        if (cur1->name && cur2->name && aim_sncmp(cur1->name, cur2->name))
+                return 7;
+
+        if (cur1->gid != cur2->gid)
+                return 8;
+
+        if (cur1->bid != cur2->bid)
+                return 9;
+
+        if (cur1->type != cur2->type)
+                return 10;
+
+        return 0;
 }
 
 faim_export int aim_ssi_itemlist_valid(struct aim_ssi_item *list, struct aim_ssi_item *item)
 {
-  struct aim_ssi_item *cur;
-  for (cur=list; cur; cur=cur->next)
-    if (cur == item)
-      return 1;
-  return 0;
+        struct aim_ssi_item *cur;
+        for (cur=list; cur; cur=cur->next)
+                if (cur == item)
+                        return 1;
+        return 0;
 }
 
@@ -260 +252 @@
 faim_export struct aim_ssi_item *aim_ssi_itemlist_find(struct aim_ssi_item *list, fu16_t gid, fu16_t bid)
 {
-  struct aim_ssi_item *cur;
-  for (cur=list; cur; cur=cur->next)
-    if ((cur->gid == gid) && (cur->bid == bid))
-      return cur;
-  return NULL;
+        struct aim_ssi_item *cur;
+        for (cur=list; cur; cur=cur->next)
+                if ((cur->gid == gid) && (cur->bid == bid))
+                        return cur;
+        return NULL;
 }
 
@@ -279 +271 @@
 faim_export struct aim_ssi_item *aim_ssi_itemlist_finditem(struct aim_ssi_item *list, const char *gn, const char *sn, fu16_t type)
 {
-  struct aim_ssi_item *cur;
-  if (!list)
-    return NULL;
-  
-  if (gn && sn) { /* For finding buddies in groups */
-    for (cur=list; cur; cur=cur->next)
-      if ((cur->type == type) && (cur->name) && !(aim_sncmp(cur->name, sn))) {
-        struct aim_ssi_item *curg;
-        for (curg=list; curg; curg=curg->next)
-          if ((curg->type == AIM_SSI_TYPE_GROUP) && (curg->gid == cur->gid) && (curg->name) && !(aim_sncmp(curg->name, gn)))
-            return cur;
-      }
-    
-  } else if (gn) { /* For finding groups */
-    for (cur=list; cur; cur=cur->next) {
-      if ((cur->type == type) && (cur->bid == 0x0000) && (cur->name) && !(aim_sncmp(cur->name, gn))) {
-        return cur;
-      }
-    }
-    
-  } else if (sn) { /* For finding permits, denies, and ignores */
-    for (cur=list; cur; cur=cur->next) {
-      if ((cur->type == type) && (cur->name) && !(aim_sncmp(cur->name, sn))) {
-        return cur;
-      }
-    }
-    
-    /* For stuff without names--permit deny setting, visibility mask, etc. */
-  } else for (cur=list; cur; cur=cur->next) {
-    if ((cur->type == type) && (!cur->name))
-      return cur;
-  }
-  
-  return NULL;
+        struct aim_ssi_item *cur;
+        if (!list)
+                return NULL;
+
+        if (gn && sn) { /* For finding buddies in groups */
+                for (cur=list; cur; cur=cur->next)
+                        if ((cur->type == type) && (cur->name) && !(aim_sncmp(cur->name, sn))) {
+                                struct aim_ssi_item *curg;
+                                for (curg=list; curg; curg=curg->next)
+                                        if ((curg->type == AIM_SSI_TYPE_GROUP) && (curg->gid == cur->gid) && (curg->name) && !(aim_sncmp(curg->name, gn)))
+                                                return cur;
+                        }
+
+        } else if (gn) { /* For finding groups */
+                for (cur=list; cur; cur=cur->next) {
+                        if ((cur->type == type) && (cur->bid == 0x0000) && (cur->name) && !(aim_sncmp(cur->name, gn))) {
+                                return cur;
+                        }
+                }
+
+        } else if (sn) { /* For finding permits, denies, and ignores */
+                for (cur=list; cur; cur=cur->next) {
+                        if ((cur->type == type) && (cur->name) && !(aim_sncmp(cur->name, sn))) {
+                                return cur;
+                        }
+                }
+
+        /* For stuff without names--permit deny setting, visibility mask, etc. */
+        } else for (cur=list; cur; cur=cur->next) {
+                if ((cur->type == type) && (!cur->name))
+                        return cur;
+        }
+
+        return NULL;
 }
 
@@ -324 +316 @@
 faim_export struct aim_ssi_item *aim_ssi_itemlist_exists(struct aim_ssi_item *list, const char *sn)
 {
-  struct aim_ssi_item *cur;
-  if (!list || !sn)
-    return NULL;
-  for (cur=list; cur; cur=cur->next)
-    if ((cur->type == AIM_SSI_TYPE_BUDDY) && (cur->name) && (!aim_sncmp(cur->name, sn)))
-      return cur;
-  return NULL;
+        struct aim_ssi_item *cur;
+        if (!list || !sn)
+                return NULL;
+        for (cur=list; cur; cur=cur->next)
+                if ((cur->type == AIM_SSI_TYPE_BUDDY) && (cur->name) && (!aim_sncmp(cur->name, sn)))
+                        return cur;
+        return NULL;
 }
 
@@ -342 +334 @@
 faim_export char *aim_ssi_itemlist_findparentname(struct aim_ssi_item *list, const char *sn)
 {
-  struct aim_ssi_item *cur, *curg;
-  if (!list || !sn)
-    return NULL;
-  if (!(cur = aim_ssi_itemlist_exists(list, sn)))
-    return NULL;
-  if (!(curg = aim_ssi_itemlist_find(list, cur->gid, 0x0000)))
-    return NULL;
-  return curg->name;
+        struct aim_ssi_item *cur, *curg;
+        if (!list || !sn)
+                return NULL;
+        if (!(cur = aim_ssi_itemlist_exists(list, sn)))
+                return NULL;
+        if (!(curg = aim_ssi_itemlist_find(list, cur->gid, 0x0000)))
+                return NULL;
+        return curg->name;
 }
 
@@ -360 +352 @@
 faim_export int aim_ssi_getpermdeny(struct aim_ssi_item *list)
 {
-  struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, NULL, NULL, AIM_SSI_TYPE_PDINFO);
-  if (cur) {
-    aim_tlvlist_t *tlvlist = cur->data;
-    if (tlvlist) {
-      aim_tlv_t *tlv = aim_gettlv(tlvlist, 0x00ca, 1);
-      if (tlv && tlv->value)
-        return aimutil_get8(tlv->value);
-    }
-  }
-  return 0;
+        struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, NULL, NULL, AIM_SSI_TYPE_PDINFO);
+        if (cur) {
+                aim_tlv_t *tlv = aim_tlv_gettlv(cur->data, 0x00ca, 1);
+                if (tlv && tlv->value)
+                        return aimutil_get8(tlv->value);
+        }
+        return 0;
 }
 
@@ -382 +371 @@
 faim_export fu32_t aim_ssi_getpresence(struct aim_ssi_item *list)
 {
-  struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, NULL, NULL, AIM_SSI_TYPE_PRESENCEPREFS);
-  if (cur) {
-    aim_tlvlist_t *tlvlist = cur->data;
-    if (tlvlist) {
-      aim_tlv_t *tlv = aim_gettlv(tlvlist, 0x00c9, 1);
-      if (tlv && tlv->length)
-        return aimutil_get32(tlv->value);
-    }
-  }
-  return 0xFFFFFFFF;
+        struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, NULL, NULL, AIM_SSI_TYPE_PRESENCEPREFS);
+        if (cur) {
+                aim_tlv_t *tlv = aim_tlv_gettlv(cur->data, 0x00c9, 1);
+                if (tlv && tlv->length)
+                        return aimutil_get32(tlv->value);
+        }
+        return 0xFFFFFFFF;
 }
 
 /**
  * Locally find the alias of the given buddy.
+ *
+ * @param list A pointer to the current list of items.
+ * @param gn The group of the buddy.
+ * @param sn The name of the buddy.
+ * @return A pointer to a NULL terminated string that is the buddy's 
+ *         alias, or NULL if the buddy has no alias.  You should free
+ *         this returned value!
+ */
+faim_export char *aim_ssi_getalias(struct aim_ssi_item *list, const char *gn, const char *sn)
+{
+        struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, gn, sn, AIM_SSI_TYPE_BUDDY);
+        if (cur) {
+                aim_tlv_t *tlv = aim_tlv_gettlv(cur->data, 0x0131, 1);
+                if (tlv && tlv->length) {
+                        char *alias = (char *)malloc((tlv->length+1)*sizeof(char));
+                        strncpy(alias, tlv->value, tlv->length);
+                        alias[tlv->length] = 0;
+                        return alias;
+                }
+        }
+        return NULL;
+}
+
+/**
+ * Locally find the comment of the given buddy.
+ *
+ * @param list A pointer to the current list of items.
+ * @param gn The group of the buddy.
+ * @param sn The name of the buddy.
+ * @return A pointer to a NULL terminated string that is the buddy's 
+ *         comment, or NULL if the buddy has no comment.  You should free
+ *         this returned value!
+ */
+faim_export char *aim_ssi_getcomment(struct aim_ssi_item *list, const char *gn, const char *sn)
+{
+        struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, gn, sn, AIM_SSI_TYPE_BUDDY);
+        if (cur) {
+                aim_tlv_t *tlv = aim_tlv_gettlv(cur->data, 0x013c, 1);
+                if (tlv && tlv->length) {
+                        char *alias = (char *)malloc((tlv->length+1)*sizeof(char));
+                        strncpy(alias, tlv->value, tlv->length);
+                        alias[tlv->length] = 0;
+                        return alias;
+                }
+        }
+        return NULL;
+}
+
+/**
+ * Locally find if you are waiting for authorization for a buddy.
  *
  * @param list A pointer to the current list of items.
@@ -404 +440 @@
  *         this returned value!
  */
-faim_export char *aim_ssi_getalias(struct aim_ssi_item *list, const char *gn, const char *sn)
-{
-  struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, gn, sn, AIM_SSI_TYPE_BUDDY);
-  if (cur) {
-    aim_tlvlist_t *tlvlist = cur->data;
-    if (tlvlist) {
-      aim_tlv_t *tlv = aim_gettlv(tlvlist, 0x0131, 1);
-      if (tlv && tlv->length) {
-        char *alias = (char *)malloc((tlv->length+1)*sizeof(char));
-        strncpy(alias, tlv->value, tlv->length);
-        alias[tlv->length] = 0;
-        return alias;
-      }
-    }
-  }
-  return NULL;
-}
-
-/**
- * Locally find if you are waiting for authorization for a buddy.
- *
- * @param list A pointer to the current list of items.
- * @param gn The group of the buddy.
- * @param sn The name of the buddy.
- * @return A pointer to a NULL terminated string that is the buddies 
- *         alias, or NULL if the buddy has no alias.  You should free
- *         this returned value!
- */
 faim_export int aim_ssi_waitingforauth(struct aim_ssi_item *list, const char *gn, const char *sn)
 {
-  struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, gn, sn, AIM_SSI_TYPE_BUDDY);
-  if (cur) {
-    aim_tlvlist_t *tlvlist = cur->data;
-    if (tlvlist)
-      if (aim_gettlv(tlvlist, 0x0066, 1))
-        return 1;
-  }
-  return 0;
+        struct aim_ssi_item *cur = aim_ssi_itemlist_finditem(list, gn, sn, AIM_SSI_TYPE_BUDDY);
+        if (cur) {
+                if (aim_tlv_gettlv(cur->data, 0x0066, 1))
+                        return 1;
+        }
+        return 0;
 }
 
@@ -453 +459 @@
 static int aim_ssi_sync(aim_session_t *sess)
 {
-  struct aim_ssi_item *cur1, *cur2;
-  struct aim_ssi_tmp *cur, *new;
-
-  owl_function_debugmsg("aim_ssi_sync: beginning");
-  
-  if (!sess) return (-EINVAL);
-
-  /* If we're waiting for an ack, we shouldn't do anything else */
-  if (sess->ssi.waiting_for_ack) {
-    owl_function_debugmsg("Aborting aim_ssi_sync, waiting for ack");
-    return 0;
-  }
-  
-  /*
-   * Compare the 2 lists and create an aim_ssi_tmp for each difference.  
-   * We should only send either additions, modifications, or deletions 
-   * before waiting for an acknowledgement.  So first do deletions, then 
-   * additions, then modifications.  Also, both the official and the local 
-   * list should be in ascending numerical order for the group ID#s and the 
-   * buddy ID#s, which makes things more efficient.  I think.
-   */
-
-  /* Additions */
-  if (!sess->ssi.pending) {
-    for (cur1=sess->ssi.local; cur1; cur1=cur1->next) {
-      if (!aim_ssi_itemlist_find(sess->ssi.official, cur1->gid, cur1->bid)) {
-        owl_function_debugmsg("aim_ssi_sync: doing addition");
-        new = (struct aim_ssi_tmp *)malloc(sizeof(struct aim_ssi_tmp));
-        new->action = AIM_CB_SSI_ADD;
-        new->ack = 0xffff;
-        new->name = NULL;
-        new->item = cur1;
-        new->next = NULL;
-        if (sess->ssi.pending) {
-          for (cur=sess->ssi.pending; cur->next; cur=cur->next);
-          cur->next = new;
-        } else
-          sess->ssi.pending = new;
-      }
-    }
-  }
-  
-  /* Deletions */
-  if (!sess->ssi.pending) {
-    for (cur1=sess->ssi.official; cur1; cur1=cur1->next) {
-      if (!aim_ssi_itemlist_find(sess->ssi.local, cur1->gid, cur1->bid)) {
-        owl_function_debugmsg("aim_ssi_sync: doing deletion");
-        new = (struct aim_ssi_tmp *)malloc(sizeof(struct aim_ssi_tmp));
-        new->action = AIM_CB_SSI_DEL;
-        new->ack = 0xffff;
-        new->name = NULL;
-        new->item = cur1;
-        new->next = NULL;
-        if (sess->ssi.pending) {
-          for (cur=sess->ssi.pending; cur->next; cur=cur->next);
-          cur->next = new;
-        } else
-          sess->ssi.pending = new;
-      }
-    }
-  }
-  
-  /* Modifications */
-  if (!sess->ssi.pending) {
-    for (cur1=sess->ssi.local; cur1; cur1=cur1->next) {
-      cur2 = aim_ssi_itemlist_find(sess->ssi.official, cur1->gid, cur1->bid);
-      if (cur2 && (aim_ssi_itemlist_cmp(cur1, cur2))) {
-        owl_function_debugmsg("aim_ssi_sync: doing modification");
-        new = (struct aim_ssi_tmp *)malloc(sizeof(struct aim_ssi_tmp));
-        new->action = AIM_CB_SSI_MOD;
-        new->ack = 0xffff;
-        new->name = NULL;
-        new->item = cur1;
-        new->next = NULL;
-        if (sess->ssi.pending) {
-          for (cur=sess->ssi.pending; cur->next; cur=cur->next);
-          cur->next = new;
-        } else
-          sess->ssi.pending = new;
-      }
-    }
-  }
-  
-  /* We're out of stuff to do, so tell the AIM servers we're done and exit */
-  if (!sess->ssi.pending) {
-    owl_function_debugmsg("aim_ssi_sync: telling server we're done modifying SSI data.");
-    aim_ssi_modend(sess);
-    return 0;
-  }
-  
-  /* Make sure we don't send anything else between now 
-   * and when we receive the ack for the following operation */
-  owl_function_debugmsg("aim_ssi_sync: setting SSI waiting_for_ack");
-  sess->ssi.waiting_for_ack = 1;
-  
-  /* Now go mail off our data and wait 4 to 6 weeks */
-  owl_function_debugmsg("aim_ssi_sync: about to call addmoddel to send SNACs to server");
-  aim_ssi_addmoddel(sess);
-  
-  return 0;
+        struct aim_ssi_item *cur1, *cur2;
+        struct aim_ssi_tmp *cur, *new;
+
+        if (!sess)
+                return -EINVAL;
+
+        /* If we're waiting for an ack, we shouldn't do anything else */
+        if (sess->ssi.waiting_for_ack)
+                return 0;
+
+        /*
+         * Compare the 2 lists and create an aim_ssi_tmp for each difference.  
+         * We should only send either additions, modifications, or deletions 
+         * before waiting for an acknowledgement.  So first do deletions, then 
+         * additions, then modifications.  Also, both the official and the local 
+         * list should be in ascending numerical order for the group ID#s and the 
+         * buddy ID#s, which makes things more efficient.  I think.
+         */
+
+        /* Additions */
+        if (!sess->ssi.pending) {
+                for (cur1=sess->ssi.local; cur1; cur1=cur1->next) {
+                        if (!aim_ssi_itemlist_find(sess->ssi.official, cur1->gid, cur1->bid)) {
+                                new = (struct aim_ssi_tmp *)malloc(sizeof(struct aim_ssi_tmp));
+                                new->action = AIM_CB_SSI_ADD;
+                                new->ack = 0xffff;
+                                new->name = NULL;
+                                new->item = cur1;
+                                new->next = NULL;
+                                if (sess->ssi.pending) {
+                                        for (cur=sess->ssi.pending; cur->next; cur=cur->next);
+                                        cur->next = new;
+                                } else
+                                        sess->ssi.pending = new;
+                        }
+                }
+        }
+
+        /* Deletions */
+        if (!sess->ssi.pending) {
+                for (cur1=sess->ssi.official; cur1; cur1=cur1->next) {
+                        if (!aim_ssi_itemlist_find(sess->ssi.local, cur1->gid, cur1->bid)) {
+                                new = (struct aim_ssi_tmp *)malloc(sizeof(struct aim_ssi_tmp));
+                                new->action = AIM_CB_SSI_DEL;
+                                new->ack = 0xffff;
+                                new->name = NULL;
+                                new->item = cur1;
+                                new->next = NULL;
+                                if (sess->ssi.pending) {
+                                        for (cur=sess->ssi.pending; cur->next; cur=cur->next);
+                                        cur->next = new;
+                                } else
+                                        sess->ssi.pending = new;
+                        }
+                }
+        }
+
+        /* Modifications */
+        if (!sess->ssi.pending) {
+                for (cur1=sess->ssi.local; cur1; cur1=cur1->next) {
+                        cur2 = aim_ssi_itemlist_find(sess->ssi.official, cur1->gid, cur1->bid);
+                        if (cur2 && (aim_ssi_itemlist_cmp(cur1, cur2))) {
+                                new = (struct aim_ssi_tmp *)malloc(sizeof(struct aim_ssi_tmp));
+                                new->action = AIM_CB_SSI_MOD;
+                                new->ack = 0xffff;
+                                new->name = NULL;
+                                new->item = cur1;
+                                new->next = NULL;
+                                if (sess->ssi.pending) {
+                                        for (cur=sess->ssi.pending; cur->next; cur=cur->next);
+                                        cur->next = new;
+                                } else
+                                        sess->ssi.pending = new;
+                        }
+                }
+        }
+
+        /* We're out of stuff to do, so tell the AIM servers we're done and exit */
+        if (!sess->ssi.pending) {
+                aim_ssi_modend(sess);
+                return 0;
+        }
+
+        /* Make sure we don't send anything else between now 
+         * and when we receive the ack for the following operation */
+        sess->ssi.waiting_for_ack = 1;
+
+        /* Now go mail off our data and wait 4 to 6 weeks */
+        aim_ssi_addmoddel(sess);
+
+        return 0;
 }
 
@@ -565 +562 @@
 static int aim_ssi_freelist(aim_session_t *sess)
 {
-  struct aim_ssi_item *cur, *del;
-  struct aim_ssi_tmp *curtmp, *deltmp;
-  
-  cur = sess->ssi.official;
-  while (cur) {
-    del = cur;
-    cur = cur->next;
-    free(del->name);
-    aim_freetlvchain(&del->data);
-    free(del);
-  }
-  
-  cur = sess->ssi.local;
-  while (cur) {
-    del = cur;
-    cur = cur->next;
-    free(del->name);
-    aim_freetlvchain(&del->data);
-    free(del);
-  }
-  
-  curtmp = sess->ssi.pending;
-  while (curtmp) {
-    deltmp = curtmp;
-    curtmp = curtmp->next;
-    free(deltmp);
-  }
-  
-  sess->ssi.numitems = 0;
-  sess->ssi.official = NULL;
-  sess->ssi.local = NULL;
-  sess->ssi.pending = NULL;
-  sess->ssi.timestamp = (time_t)0;
-  
-  return 0;
+        struct aim_ssi_item *cur, *del;
+        struct aim_ssi_tmp *curtmp, *deltmp;
+
+        cur = sess->ssi.official;
+        while (cur) {
+                del = cur;
+                cur = cur->next;
+                free(del->name);
+                aim_tlvlist_free(&del->data);
+                free(del);
+        }
+
+        cur = sess->ssi.local;
+        while (cur) {
+                del = cur;
+                cur = cur->next;
+                free(del->name);
+                aim_tlvlist_free(&del->data);
+                free(del);
+        }
+
+        curtmp = sess->ssi.pending;
+        while (curtmp) {
+                deltmp = curtmp;
+                curtmp = curtmp->next;
+                free(deltmp);
+        }
+
+        sess->ssi.numitems = 0;
+        sess->ssi.official = NULL;
+        sess->ssi.local = NULL;
+        sess->ssi.pending = NULL;
+        sess->ssi.timestamp = (time_t)0;
+
+        return 0;
 }
 
@@ -610 +607 @@
 faim_export int aim_ssi_deletelist(aim_session_t *sess)
 {
-  struct aim_ssi_item *cur, *del;
-  
-  if (!sess) return (-EINVAL);
-  
-  /* Free the local list */
-  cur = sess->ssi.local;
-  while (cur) {
-    del = cur;
-    cur = cur->next;
-    free(del->name);
-    aim_freetlvchain(&del->data);
-    free(del);
-  }
-  sess->ssi.local = NULL;
-  
-  /* Sync our local list with the server list */
-  aim_ssi_sync(sess);
-  
-  return 0;
+        struct aim_ssi_item *cur, *del;
+
+        if (!sess)
+                return -EINVAL;
+
+        /* Free the local list */
+        cur = sess->ssi.local;
+        while (cur) {
+                del = cur;
+                cur = cur->next;
+                free(del->name);
+                aim_tlvlist_free(&del->data);
+                free(del);
+        }
+        sess->ssi.local = NULL;
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
 }
 
@@ -642 +640 @@
 faim_export int aim_ssi_cleanlist(aim_session_t *sess)
 {
-  struct aim_ssi_item *cur, *next;
-  
-  if (!sess) return -EINVAL;
-
-  /* Delete any buddies, permits, or denies with empty names. */
-  /* If there are any buddies directly in the master group, add them to a real group. */
-  /* DESTROY any buddies that are directly in the master group. */
-  /* Do the same for buddies that are in a non-existant group. */
-  /* This will kind of mess up if you hit the item limit, but this function isn't too critical */
-  cur = sess->ssi.local;
-  while (cur) {
-    next = cur->next;
-    if (!cur->name) {
-      if (cur->type == AIM_SSI_TYPE_BUDDY)
-        aim_ssi_delbuddy(sess, NULL, NULL);
-      else if (cur->type == AIM_SSI_TYPE_PERMIT)
-        aim_ssi_delpermit(sess, NULL);
-      else if (cur->type == AIM_SSI_TYPE_DENY)
-        aim_ssi_deldeny(sess, NULL);
-    } else if ((cur->type == AIM_SSI_TYPE_BUDDY) && ((cur->gid == 0x0000) || (!aim_ssi_itemlist_find(sess->ssi.local, cur->gid, 0x0000)))) {
-      aim_ssi_addbuddy(sess, cur->name, "orphans", NULL, NULL, NULL, 0);
-      aim_ssi_delbuddy(sess, cur->name, NULL);
-    }
-    cur = next;
-  }
-  
-  /* Check if there are empty groups and delete them */
-  cur = sess->ssi.local;
-  while (cur) {
-    next = cur->next;
-    if (cur->type == AIM_SSI_TYPE_GROUP) {
-      aim_tlv_t *tlv = aim_gettlv(cur->data, 0x00c8, 1);
-      if (!tlv || !tlv->length)
-        aim_ssi_itemlist_del(&sess->ssi.local, cur);
-    }
-    cur = next;
-  }
-  
-  /* Check if the master group is empty */
-  if ((cur = aim_ssi_itemlist_find(sess->ssi.local, 0x0000, 0x0000)) && (!cur->data))
-    aim_ssi_itemlist_del(&sess->ssi.local, cur);
-  
-  return 0;
+        struct aim_ssi_item *cur, *next;
+
+        if (!sess)
+                return -EINVAL;
+
+        /* Delete any buddies, permits, or denies with empty names. */
+        /* If there are any buddies directly in the master group, add them to a real group. */
+        /* DESTROY any buddies that are directly in the master group. */
+        /* Do the same for buddies that are in a non-existant group. */
+        /* This will kind of mess up if you hit the item limit, but this function isn't too critical */
+        cur = sess->ssi.local;
+        while (cur) {
+                next = cur->next;
+                if (!cur->name) {
+                        if (cur->type == AIM_SSI_TYPE_BUDDY)
+                                aim_ssi_delbuddy(sess, NULL, NULL);
+                        else if (cur->type == AIM_SSI_TYPE_PERMIT)
+                                aim_ssi_delpermit(sess, NULL);
+                        else if (cur->type == AIM_SSI_TYPE_DENY)
+                                aim_ssi_deldeny(sess, NULL);
+                } else if ((cur->type == AIM_SSI_TYPE_BUDDY) && ((cur->gid == 0x0000) || (!aim_ssi_itemlist_find(sess->ssi.local, cur->gid, 0x0000)))) {
+                        aim_ssi_addbuddy(sess, cur->name, "orphans", NULL, NULL, NULL, 0);
+                        aim_ssi_delbuddy(sess, cur->name, NULL);
+                }
+                cur = next;
+        }
+
+        /* Check if there are empty groups and delete them */
+        cur = sess->ssi.local;
+        while (cur) {
+                next = cur->next;
+                if (cur->type == AIM_SSI_TYPE_GROUP) {
+                        aim_tlv_t *tlv = aim_tlv_gettlv(cur->data, 0x00c8, 1);
+                        if (!tlv || !tlv->length)
+                                aim_ssi_itemlist_del(&sess->ssi.local, cur);
+                }
+                cur = next;
+        }
+
+        /* Check if the master group is empty */
+        if ((cur = aim_ssi_itemlist_find(sess->ssi.local, 0x0000, 0x0000)) && (!cur->data))
+                aim_ssi_itemlist_del(&sess->ssi.local, cur);
+
+        return 0;
 }
 
@@ -700 +699 @@
 faim_export int aim_ssi_addbuddy(aim_session_t *sess, const char *name, const char *group, const char *alias, const char *comment, const char *smsnum, int needauth)
 {
-  struct aim_ssi_item *parent;
-  aim_tlvlist_t *data = NULL;
-  
-  if (!sess || !name || !group) return (-EINVAL);
-
-  /* Find the parent */
-  if (!(parent = aim_ssi_itemlist_finditem(sess->ssi.local, group, NULL, AIM_SSI_TYPE_GROUP))) {
-    /* Find the parent's parent (the master group) */
-    if (!(parent = aim_ssi_itemlist_find(sess->ssi.local, 0x0000, 0x0000))) {
-      if (!(parent = aim_ssi_itemlist_add(&sess->ssi.local, NULL, 0x0000, 0x0000, AIM_SSI_TYPE_GROUP, NULL))) {
-        return -ENOMEM;
-      }
-    }
-    /* Add the parent */
-    if (!(parent = aim_ssi_itemlist_add(&sess->ssi.local, group, 0xFFFF, 0x0000, AIM_SSI_TYPE_GROUP, NULL))) {
-      return -ENOMEM;
-    }
-    
-    /* Modify the parent's parent (the master group) */
-    aim_ssi_itemlist_rebuildgroup(sess->ssi.local, NULL);
-  }
-  
-  /* Create a TLV list for the new buddy */
-  if (needauth) aim_addtlvtochain_noval(&data, 0x0066);
-  if (alias) aim_addtlvtochain_raw(&data, 0x0131, strlen(alias), alias);
-  if (smsnum) aim_addtlvtochain_raw(&data, 0x013a, strlen(smsnum), smsnum);
-  if (comment) aim_addtlvtochain_raw(&data, 0x013c, strlen(comment), comment);
-  
-  /* Add that bad boy */
-  aim_ssi_itemlist_add(&sess->ssi.local, name, parent->gid, 0xFFFF, AIM_SSI_TYPE_BUDDY, data);
-  aim_freetlvchain(&data);
-  
-  /* Modify the parent group */
-  aim_ssi_itemlist_rebuildgroup(sess->ssi.local, group);
-  
-  /* Sync our local list with the server list */
-  aim_ssi_sync(sess);
-  
-  return(0);
+        struct aim_ssi_item *parent;
+        aim_tlvlist_t *data = NULL;
+
+        if (!sess || !name || !group)
+                return -EINVAL;
+
+        /* Find the parent */
+        if (!(parent = aim_ssi_itemlist_finditem(sess->ssi.local, group, NULL, AIM_SSI_TYPE_GROUP))) {
+                /* Find the parent's parent (the master group) */
+                if (!(parent = aim_ssi_itemlist_find(sess->ssi.local, 0x0000, 0x0000)))
+                        if (!(parent = aim_ssi_itemlist_add(&sess->ssi.local, NULL, 0x0000, 0x0000, AIM_SSI_TYPE_GROUP, NULL)))
+                                return -ENOMEM;
+                /* Add the parent */
+                if (!(parent = aim_ssi_itemlist_add(&sess->ssi.local, group, 0xFFFF, 0x0000, AIM_SSI_TYPE_GROUP, NULL)))
+                        return -ENOMEM;
+
+                /* Modify the parent's parent (the master group) */
+                aim_ssi_itemlist_rebuildgroup(sess->ssi.local, NULL);
+        }
+
+        /* Create a TLV list for the new buddy */
+        if (needauth)
+                aim_tlvlist_add_noval(&data, 0x0066);
+        if (alias)
+                aim_tlvlist_add_raw(&data, 0x0131, strlen(alias), alias);
+        if (smsnum)
+                aim_tlvlist_add_raw(&data, 0x013a, strlen(smsnum), smsnum);
+        if (comment)
+                aim_tlvlist_add_raw(&data, 0x013c, strlen(comment), comment);
+
+        /* Add that bad boy */
+        aim_ssi_itemlist_add(&sess->ssi.local, name, parent->gid, 0xFFFF, AIM_SSI_TYPE_BUDDY, data);
+        aim_tlvlist_free(&data);
+
+        /* Modify the parent group */
+        aim_ssi_itemlist_rebuildgroup(sess->ssi.local, group);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
 }
 
@@ -751 +752 @@
 {
 
-  if (!sess || !name) return -EINVAL;
-
-  /* Add that bad boy */
-  aim_ssi_itemlist_add(&sess->ssi.local, name, 0x0000, 0xFFFF, AIM_SSI_TYPE_PERMIT, NULL);
-
-  /* Sync our local list with the server list */
-  aim_ssi_sync(sess);
-
-  return(0);
+        if (!sess || !name)
+                return -EINVAL;
+
+        /* Add that bad boy */
+        aim_ssi_itemlist_add(&sess->ssi.local, name, 0x0000, 0xFFFF, AIM_SSI_TYPE_PERMIT, NULL);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
 }
 
@@ -772 +774 @@
 {
 
-  if (!sess || !name) return (-EINVAL);
-
-  /* Add that bad boy */
-  aim_ssi_itemlist_add(&sess->ssi.local, name, 0x0000, 0xFFFF, AIM_SSI_TYPE_DENY, NULL);
-  
-  /* Sync our local list with the server list */
-  aim_ssi_sync(sess);
-  
-  return(0);
+        if (!sess || !name)
+                return -EINVAL;
+
+        /* Add that bad boy */
+        aim_ssi_itemlist_add(&sess->ssi.local, name, 0x0000, 0xFFFF, AIM_SSI_TYPE_DENY, NULL);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
 }
 
@@ -793 +796 @@
 faim_export int aim_ssi_delbuddy(aim_session_t *sess, const char *name, const char *group)
 {
-  struct aim_ssi_item *del;
-
-  if (!sess) return -EINVAL;
-  
-  /* Find the buddy */
-  del=aim_ssi_itemlist_finditem(sess->ssi.local, group, name, AIM_SSI_TYPE_BUDDY);
-  if (!del) return(-EINVAL);
-  
-  /* Remove the item from the list */
-  aim_ssi_itemlist_del(&sess->ssi.local, del);
-
-  /* Modify the parent group */
-  aim_ssi_itemlist_rebuildgroup(sess->ssi.local, group);
-  
-  /* Check if we should delete the parent group */
-  if ((del = aim_ssi_itemlist_finditem(sess->ssi.local, group, NULL, AIM_SSI_TYPE_GROUP)) && (!del->data)) {
-    aim_ssi_itemlist_del(&sess->ssi.local, del);
-    
-    /* Modify the parent group */
-    aim_ssi_itemlist_rebuildgroup(sess->ssi.local, NULL);
-    
-    /* Check if we should delete the parent's parent (the master group) */
-    if ((del = aim_ssi_itemlist_find(sess->ssi.local, 0x0000, 0x0000)) && (!del->data)) {
-      aim_ssi_itemlist_del(&sess->ssi.local, del);
-    }
-  }
-  
-  /* Sync our local list with the server list */
-  owl_function_debugmsg("aim_ssi_delbuddy: about to sync");
-  aim_ssi_sync(sess);
-  
-  return(0);
+        struct aim_ssi_item *del;
+
+        if (!sess)
+                return -EINVAL;
+
+        /* Find the buddy */
+        if (!(del = aim_ssi_itemlist_finditem(sess->ssi.local, group, name, AIM_SSI_TYPE_BUDDY)))
+                return -EINVAL;
+
+        /* Remove the item from the list */
+        aim_ssi_itemlist_del(&sess->ssi.local, del);
+
+        /* Modify the parent group */
+        aim_ssi_itemlist_rebuildgroup(sess->ssi.local, group);
+
+        /* Check if we should delete the parent group */
+        if ((del = aim_ssi_itemlist_finditem(sess->ssi.local, group, NULL, AIM_SSI_TYPE_GROUP)) && (!del->data)) {
+                aim_ssi_itemlist_del(&sess->ssi.local, del);
+
+                /* Modify the parent group */
+                aim_ssi_itemlist_rebuildgroup(sess->ssi.local, NULL);
+
+                /* Check if we should delete the parent's parent (the master group) */
+                if ((del = aim_ssi_itemlist_find(sess->ssi.local, 0x0000, 0x0000)) && (!del->data)) {
+                        aim_ssi_itemlist_del(&sess->ssi.local, del);
+                }
+        }
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
 }
 
@@ -836 +839 @@
 faim_export int aim_ssi_delpermit(aim_session_t *sess, const char *name)
 {
-  struct aim_ssi_item *del;
-  
-  if (!sess)
-    return -EINVAL;
-  
-  /* Find the item */
-  if (!(del = aim_ssi_itemlist_finditem(sess->ssi.local, NULL, name, AIM_SSI_TYPE_PERMIT)))
-    return -EINVAL;
-  
-  /* Remove the item from the list */
-  aim_ssi_itemlist_del(&sess->ssi.local, del);
-  
-  /* Sync our local list with the server list */
-  aim_ssi_sync(sess);
-  
-  return 0;
+        struct aim_ssi_item *del;
+
+        if (!sess)
+                return -EINVAL;
+
+        /* Find the item */
+        if (!(del = aim_ssi_itemlist_finditem(sess->ssi.local, NULL, name, AIM_SSI_TYPE_PERMIT)))
+                return -EINVAL;
+
+        /* Remove the item from the list */
+        aim_ssi_itemlist_del(&sess->ssi.local, del);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
 }
 
@@ -863 +866 @@
 faim_export int aim_ssi_deldeny(aim_session_t *sess, const char *name)
 {
-  struct aim_ssi_item *del;
-  
-  if (!sess)
-    return -EINVAL;
-  
-  /* Find the item */
-  if (!(del = aim_ssi_itemlist_finditem(sess->ssi.local, NULL, name, AIM_SSI_TYPE_DENY)))
-    return -EINVAL;
-  
-  /* Remove the item from the list */
-  aim_ssi_itemlist_del(&sess->ssi.local, del);
-  
-  /* Sync our local list with the server list */
-  aim_ssi_sync(sess);
-  
-  return 0;
+        struct aim_ssi_item *del;
+
+        if (!sess)
+                return -EINVAL;
+
+        /* Find the item */
+        if (!(del = aim_ssi_itemlist_finditem(sess->ssi.local, NULL, name, AIM_SSI_TYPE_DENY)))
+                return -EINVAL;
+
+        /* Remove the item from the list */
+        aim_ssi_itemlist_del(&sess->ssi.local, del);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
 }
 
@@ -893 +896 @@
 faim_export int aim_ssi_movebuddy(aim_session_t *sess, const char *oldgn, const char *newgn, const char *sn)
 {
-  aim_ssi_addbuddy(sess, sn, newgn, aim_ssi_getalias(sess->ssi.local, oldgn, sn), NULL, NULL, aim_ssi_waitingforauth(sess->ssi.local, oldgn, sn));
-  aim_ssi_delbuddy(sess, sn, oldgn);
-  return 0;
+        aim_ssi_addbuddy(sess, sn, newgn, aim_ssi_getalias(sess->ssi.local, oldgn, sn), NULL, NULL, aim_ssi_waitingforauth(sess->ssi.local, oldgn, sn));
+        aim_ssi_delbuddy(sess, sn, oldgn);
+        return 0;
 }
 
@@ -904 +907 @@
  * @param gn The group that the buddy is currently in.
  * @param sn The screen name of the buddy.
- * @param alias The new alias for the buddy.
+ * @param alias The new alias for the buddy, or NULL if you want to remove 
+ *        a buddy's comment.
  * @return Return 0 if no errors, otherwise return the error number.
  */
 faim_export int aim_ssi_aliasbuddy(aim_session_t *sess, const char *gn, const char *sn, const char *alias)
 {
-  struct aim_ssi_item *tmp;
-  aim_tlvlist_t *data = NULL;
-  
-  if (!sess || !gn || !sn)
-    return -EINVAL;
-  
-  if (!(tmp = aim_ssi_itemlist_finditem(sess->ssi.local, gn, sn, AIM_SSI_TYPE_BUDDY)))
-    return -EINVAL;
-  
-  if (alias && !strlen(alias))
-    alias = NULL;
-  
-  /* Need to add the x0131 TLV to the TLV chain */
-  if (alias)
-    aim_addtlvtochain_raw(&data, 0x0131, strlen(alias), alias);
-  
-  aim_freetlvchain(&tmp->data);
-  tmp->data = data;
-  
-  /* Sync our local list with the server list */
-  aim_ssi_sync(sess);
-  
-  return 0;
+        struct aim_ssi_item *tmp;
+
+        if (!sess || !gn || !sn)
+                return -EINVAL;
+
+        if (!(tmp = aim_ssi_itemlist_finditem(sess->ssi.local, gn, sn, AIM_SSI_TYPE_BUDDY)))
+                return -EINVAL;
+
+        /* Either add or remove the 0x0131 TLV from the TLV chain */
+        if ((alias != NULL) && (strlen(alias) > 0))
+                aim_tlvlist_replace_raw(&tmp->data, 0x0131, strlen(alias), alias);
+        else
+                aim_tlvlist_remove(&tmp->data, 0x0131);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
+}
+
+/**
+ * Change the comment stored on the server for a given buddy.
+ *
+ * @param sess The oscar session.
+ * @param gn The group that the buddy is currently in.
+ * @param sn The screen name of the buddy.
+ * @param alias The new comment for the buddy, or NULL if you want to remove 
+ *        a buddy's comment.
+ * @return Return 0 if no errors, otherwise return the error number.
+ */
+faim_export int aim_ssi_editcomment(aim_session_t *sess, const char *gn, const char *sn, const char *comment)
+{
+        struct aim_ssi_item *tmp;
+
+        if (!sess || !gn || !sn)
+                return -EINVAL;
+
+        if (!(tmp = aim_ssi_itemlist_finditem(sess->ssi.local, gn, sn, AIM_SSI_TYPE_BUDDY)))
+                return -EINVAL;
+
+        /* Either add or remove the 0x0131 TLV from the TLV chain */
+        if ((comment != NULL) && (strlen(comment) > 0))
+                aim_tlvlist_replace_raw(&tmp->data, 0x013c, strlen(comment), comment);
+        else
+                aim_tlvlist_remove(&tmp->data, 0x013c);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
 }
 
@@ -944 +975 @@
 faim_export int aim_ssi_rename_group(aim_session_t *sess, const char *oldgn, const char *newgn)
 {
-  struct aim_ssi_item *group;
-  
-  if (!sess || !oldgn || !newgn)
-    return -EINVAL;
-  
-  if (!(group = aim_ssi_itemlist_finditem(sess->ssi.local, oldgn, NULL, AIM_SSI_TYPE_GROUP)))
-    return -EINVAL;
-  
-  free(group->name);
-  group->name = (char *)malloc((strlen(newgn)+1)*sizeof(char));
-  strcpy(group->name, newgn);
-  
-  /* Sync our local list with the server list */
-  aim_ssi_sync(sess);
-  
-  return 0;
+        struct aim_ssi_item *group;
+
+        if (!sess || !oldgn || !newgn)
+                return -EINVAL;
+
+        if (!(group = aim_ssi_itemlist_finditem(sess->ssi.local, oldgn, NULL, AIM_SSI_TYPE_GROUP)))
+                return -EINVAL;
+
+        free(group->name);
+        group->name = (char *)malloc((strlen(newgn)+1)*sizeof(char));
+        strcpy(group->name, newgn);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
 }
 
@@ -978 +1009 @@
 faim_export int aim_ssi_setpermdeny(aim_session_t *sess, fu8_t permdeny, fu32_t vismask)
 {
-  struct aim_ssi_item *tmp;
-  aim_tlvlist_t *data = NULL;
-  
-  if (!sess)
-    return -EINVAL;
-  
-  /* Need to add the x00ca TLV to the TLV chain */
-  aim_addtlvtochain8(&data, 0x00ca, permdeny);
-  
-  /* Need to add the x00cb TLV to the TLV chain */
-  aim_addtlvtochain32(&data, 0x00cb, vismask);
-  
-  if ((tmp = aim_ssi_itemlist_finditem(sess->ssi.local, NULL, NULL, AIM_SSI_TYPE_PDINFO))) {
-    aim_freetlvchain(&tmp->data);
-    tmp->data = data;
-  } else {
-    tmp = aim_ssi_itemlist_add(&sess->ssi.local, NULL, 0x0000, 0xFFFF, AIM_SSI_TYPE_PDINFO, data);
-    aim_freetlvchain(&data);
-  }
-  
-  /* Sync our local list with the server list */
-  aim_ssi_sync(sess);
-  
-  return 0;
+        struct aim_ssi_item *tmp;
+
+        if (!sess)
+                return -EINVAL;
+
+        /* Find the PDINFO item, or add it if it does not exist */
+        if (!(tmp = aim_ssi_itemlist_finditem(sess->ssi.local, NULL, NULL, AIM_SSI_TYPE_PDINFO)))
+                tmp = aim_ssi_itemlist_add(&sess->ssi.local, NULL, 0x0000, 0xFFFF, AIM_SSI_TYPE_PDINFO, NULL);
+
+        /* Need to add the 0x00ca TLV to the TLV chain */
+        aim_tlvlist_replace_8(&tmp->data, 0x00ca, permdeny);
+
+        /* Need to add the 0x00cb TLV to the TLV chain */
+        aim_tlvlist_replace_32(&tmp->data, 0x00cb, vismask);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
 }
 
@@ -1014 +1040 @@
 faim_export int aim_ssi_seticon(aim_session_t *sess, fu8_t *iconsum, fu16_t iconsumlen)
 {
-  struct aim_ssi_item *tmp;
-  aim_tlvlist_t *data = NULL;
-  fu8_t *csumdata;
-  
-  if (!sess || !iconsum || !iconsumlen)
-    return -EINVAL;
-  
-  if (!(csumdata = (fu8_t *)malloc((iconsumlen+2)*sizeof(fu8_t))))
-    return -ENOMEM;
-  csumdata[0] = 0x00;
-  csumdata[1] = 0x10;
-  memcpy(&csumdata[2], iconsum, iconsumlen);
-  
-  /* Need to add the x00d5 TLV to the TLV chain */
-  aim_addtlvtochain_raw(&data, 0x00d5, (iconsumlen+2) * sizeof(fu8_t), csumdata);
-  
-  /* This TLV is added to cache the icon. */
-  aim_addtlvtochain_noval(&data, 0x0131);
-  
-  if ((tmp = aim_ssi_itemlist_finditem(sess->ssi.local, NULL, "1", AIM_SSI_TYPE_ICONINFO))) {
-    /* If the new tlvchain and oldtlvchain are the same, then do nothing */
-    if (!aim_tlvlist_cmp(tmp->data, data)) {
-      /* The new tlvlist is the identical to the old one */
-      aim_freetlvchain(&data);
-      free(csumdata);
-      return 0;
-    }
-    aim_freetlvchain(&tmp->data);
-    tmp->data = data;
-  } else {
-    tmp = aim_ssi_itemlist_add(&sess->ssi.local, "1", 0x0000, 0x51F4, AIM_SSI_TYPE_ICONINFO, data);
-    aim_freetlvchain(&data);
-  }
-  
-  /* Sync our local list with the server list */
-  aim_ssi_sync(sess);
-  free(csumdata);
-  return 0;
+        struct aim_ssi_item *tmp;
+        fu8_t *csumdata;
+
+        if (!sess || !iconsum || !iconsumlen)
+                return -EINVAL;
+
+        /* Find the ICONINFO item, or add it if it does not exist */
+        if (!(tmp = aim_ssi_itemlist_finditem(sess->ssi.local, NULL, "1", AIM_SSI_TYPE_ICONINFO))) {
+                tmp = aim_ssi_itemlist_add(&sess->ssi.local, "1", 0x0000, 0x51F4, AIM_SSI_TYPE_ICONINFO, NULL);
+        }
+
+        /* Need to add the 0x00d5 TLV to the TLV chain */
+        if (!(csumdata = (fu8_t *)malloc((iconsumlen+2)*sizeof(fu8_t))))
+                return -ENOMEM;
+        csumdata[0] = 0x00;
+        csumdata[1] = 0x10;
+        memcpy(&csumdata[2], iconsum, iconsumlen);
+        aim_tlvlist_replace_raw(&tmp->data, 0x00d5, (iconsumlen+2) * sizeof(fu8_t), csumdata);
+        free(csumdata);
+
+        /* Need to add the 0x0131 TLV to the TLV chain, used to cache the icon */
+        aim_tlvlist_replace_noval(&tmp->data, 0x0131);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+        return 0;
+}
+
+/**
+ * Remove a reference to a server stored buddy icon.  This will make your 
+ * icon stop showing up to other people.
+ *
+ * @param sess The oscar session.
+ * @return Return 0 if no errors, otherwise return the error number.
+ */
+faim_export int aim_ssi_delicon(aim_session_t *sess)
+{
+        struct aim_ssi_item *tmp;
+
+        if (!sess)
+                return -EINVAL;
+
+        /* Find the ICONINFO item and delete it if it exists*/
+        if ((tmp = aim_ssi_itemlist_finditem(sess->ssi.local, NULL, "1", AIM_SSI_TYPE_ICONINFO)))
+                aim_ssi_itemlist_del(&sess->ssi.local, tmp);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+        return 0;
 }
 
@@ -1059 +1096 @@
  * @param sess The oscar session.
  * @param presence I think it's a bitmask, but I only know what one of the bits is:
+ *        0x00000002 - Hide wireless?
  *        0x00000400 - Allow others to see your idle time
  * @return Return 0 if no errors, otherwise return the error number.
  */
 faim_export int aim_ssi_setpresence(aim_session_t *sess, fu32_t presence) {
-  struct aim_ssi_item *tmp;
-  aim_tlvlist_t *data = NULL;
-  
-  if (!sess)
-    return -EINVAL;
-  
-  /* Need to add the x00c9 TLV to the TLV chain */
-  aim_addtlvtochain32(&data, 0x00c9, presence);
-  
-  if ((tmp = aim_ssi_itemlist_finditem(sess->ssi.local, NULL, NULL, AIM_SSI_TYPE_PRESENCEPREFS))) {
-    aim_freetlvchain(&tmp->data);
-    tmp->data = data;
-  } else {
-    tmp = aim_ssi_itemlist_add(&sess->ssi.local, NULL, 0x0000, 0xFFFF, AIM_SSI_TYPE_PRESENCEPREFS, data);
-    aim_freetlvchain(&data);
-  }
-  
-  /* Sync our local list with the server list */
-  aim_ssi_sync(sess);
-  
-  return 0;
+        struct aim_ssi_item *tmp;
+
+        if (!sess)
+                return -EINVAL;
+
+        /* Find the PRESENCEPREFS item, or add it if it does not exist */
+        if (!(tmp = aim_ssi_itemlist_finditem(sess->ssi.local, NULL, NULL, AIM_SSI_TYPE_PRESENCEPREFS)))
+                tmp = aim_ssi_itemlist_add(&sess->ssi.local, NULL, 0x0000, 0xFFFF, AIM_SSI_TYPE_PRESENCEPREFS, NULL);
+
+        /* Need to add the x00c9 TLV to the TLV chain */
+        aim_tlvlist_replace_32(&tmp->data, 0x00c9, presence);
+
+        /* Sync our local list with the server list */
+        aim_ssi_sync(sess);
+
+        return 0;
 }
 
@@ -1091 +1124 @@
 faim_export int aim_ssi_reqrights(aim_session_t *sess)
 {
-  aim_conn_t *conn;
-  
-  if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)))
-    return -EINVAL;
-  
-  return aim_genericreq_n(sess, conn, AIM_CB_FAM_SSI, AIM_CB_SSI_REQRIGHTS);
+        aim_conn_t *conn;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)))
+                return -EINVAL;
+
+        return aim_genericreq_n_snacid(sess, conn, AIM_CB_FAM_SSI, AIM_CB_SSI_REQRIGHTS);
 }
 
@@ -1104 +1137 @@
 static int parserights(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  int ret = 0, i;
-  aim_rxcallback_t userfunc;
-  aim_tlvlist_t *tlvlist;
-  aim_tlv_t *tlv;
-  aim_bstream_t bstream;
-  fu16_t *maxitems;
-  
-  /* This SNAC is made up of a bunch of TLVs */
-  tlvlist = aim_readtlvchain(bs);
-  
-  /* TLV 0x0004 contains the maximum number of each item */
-  if (!(tlv = aim_gettlv(tlvlist, 0x0004, 1))) {
-    aim_freetlvchain(&tlvlist);
-    return 0;
-  }
-  
-  aim_bstream_init(&bstream, tlv->value, tlv->length);
-  
-  if (!(maxitems = (fu16_t *)malloc((tlv->length/2)*sizeof(fu16_t)))) {
-    aim_freetlvchain(&tlvlist);
-    return 0;
-  }
-  
-  for (i=0; i<(tlv->length/2); i++)
-    maxitems[i] = aimbs_get16(&bstream);
-  
-  if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
-    ret = userfunc(sess, rx, tlv->length/2, maxitems);
-  
-  aim_freetlvchain(&tlvlist);
-  free(maxitems);
-  
-  return ret;
+        int ret = 0, i;
+        aim_rxcallback_t userfunc;
+        aim_tlvlist_t *tlvlist;
+        aim_tlv_t *tlv;
+        aim_bstream_t bstream;
+        fu16_t *maxitems;
+
+        /* This SNAC is made up of a bunch of TLVs */
+        tlvlist = aim_tlvlist_read(bs);
+
+        /* TLV 0x0004 contains the maximum number of each item */
+        if (!(tlv = aim_tlv_gettlv(tlvlist, 0x0004, 1))) {
+                aim_tlvlist_free(&tlvlist);
+                return 0;
+        }
+
+        aim_bstream_init(&bstream, tlv->value, tlv->length);
+
+        if (!(maxitems = (fu16_t *)malloc((tlv->length/2)*sizeof(fu16_t)))) {
+                aim_tlvlist_free(&tlvlist);
+                return 0;
+        }
+
+        for (i=0; i<(tlv->length/2); i++)
+                maxitems[i] = aimbs_get16(&bstream);
+
+        if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
+                ret = userfunc(sess, rx, tlv->length/2, maxitems);
+
+        aim_tlvlist_free(&tlvlist);
+        free(maxitems);
+
+        return ret;
 }
 
@@ -1146 +1179 @@
 faim_export int aim_ssi_reqdata(aim_session_t *sess)
 {
-  aim_conn_t *conn;
-  
-  if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)))
-    return -EINVAL;
-  
-  /* Free any current data, just in case */
-  aim_ssi_freelist(sess);
-  
-  return aim_genericreq_n_snacid(sess, conn, AIM_CB_FAM_SSI, AIM_CB_SSI_REQDATA);
+        aim_conn_t *conn;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)))
+                return -EINVAL;
+
+        /* Free any current data, just in case */
+        aim_ssi_freelist(sess);
+
+        return aim_genericreq_n_snacid(sess, conn, AIM_CB_FAM_SSI, AIM_CB_SSI_REQDATA);
 }
 
@@ -1169 +1202 @@
 faim_export int aim_ssi_reqifchanged(aim_session_t *sess, time_t timestamp, fu16_t numitems)
 {
-  aim_conn_t *conn;
-  aim_frame_t *fr;
-  aim_snacid_t snacid;
-  
-  if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)))
-    return -EINVAL;
-  
-  if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+4+2)))
-    return -ENOMEM;
-  
-  snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, AIM_CB_SSI_REQIFCHANGED, 0x0000, NULL, 0);
-  
-  aim_putsnac(&fr->data, AIM_CB_FAM_SSI, AIM_CB_SSI_REQIFCHANGED, 0x0000, snacid);
-  aimbs_put32(&fr->data, timestamp);
-  aimbs_put16(&fr->data, numitems);
-  
-  aim_tx_enqueue(sess, fr);
-  
-  /* Free any current data, just in case */
-  aim_ssi_freelist(sess);
-  
-  return 0;
+        aim_conn_t *conn;
+        aim_frame_t *fr;
+        aim_snacid_t snacid;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)))
+                return -EINVAL;
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+4+2)))
+                return -ENOMEM;
+
+        snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, AIM_CB_SSI_REQIFCHANGED, 0x0000, NULL, 0);
+
+        aim_putsnac(&fr->data, AIM_CB_FAM_SSI, AIM_CB_SSI_REQIFCHANGED, 0x0000, snacid);
+        aimbs_put32(&fr->data, timestamp);
+        aimbs_put16(&fr->data, numitems);
+
+        aim_tx_enqueue(sess, fr);
+
+        /* Free any current data, just in case */
+        aim_ssi_freelist(sess);
+
+        return 0;
 }
 
@@ -1198 +1231 @@
 static int parsedata(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  int ret = 0;
-  aim_rxcallback_t userfunc;
-  fu8_t fmtver; /* guess */
-  fu16_t namelen, gid, bid, type;
-  char *name;
-  aim_tlvlist_t *data;
-  
-  fmtver = aimbs_get8(bs); /* Version of ssi data.  Should be 0x00 */
-  sess->ssi.numitems += aimbs_get16(bs); /* # of items in this SSI SNAC */
-  
-  /* Read in the list */
-  while (aim_bstream_empty(bs) > 4) { /* last four bytes are timestamp */
-    if ((namelen = aimbs_get16(bs)))
-      name = aimbs_getstr(bs, namelen);
-    else
-      name = NULL;
-    gid = aimbs_get16(bs);
-    bid = aimbs_get16(bs);
-    type = aimbs_get16(bs);
-    data = aim_readtlvchain_len(bs, aimbs_get16(bs));
-    aim_ssi_itemlist_add(&sess->ssi.official, name, gid, bid, type, data);
-    free(name);
-    aim_freetlvchain(&data);
-  }
-  
-  /* Read in the timestamp */
-  sess->ssi.timestamp = aimbs_get32(bs);
-  
-  if (!(snac->flags & 0x0001)) {
-    /* Make a copy of the list */
-    struct aim_ssi_item *cur;
-    for (cur=sess->ssi.official; cur; cur=cur->next)
-      aim_ssi_itemlist_add(&sess->ssi.local, cur->name, cur->gid, cur->bid, cur->type, cur->data);
-    
-    sess->ssi.received_data = 1;
-    
-    if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
-      ret = userfunc(sess, rx, fmtver, sess->ssi.numitems, sess->ssi.official, sess->ssi.timestamp);
-  }
-  
-  return ret;
+        int ret = 0;
+        aim_rxcallback_t userfunc;
+        fu8_t fmtver; /* guess */
+        fu16_t namelen, gid, bid, type;
+        char *name;
+        aim_tlvlist_t *data;
+
+        fmtver = aimbs_get8(bs); /* Version of ssi data.  Should be 0x00 */
+        sess->ssi.numitems += aimbs_get16(bs); /* # of items in this SSI SNAC */
+
+        /* Read in the list */
+        while (aim_bstream_empty(bs) > 4) { /* last four bytes are timestamp */
+                if ((namelen = aimbs_get16(bs)))
+                        name = aimbs_getstr(bs, namelen);
+                else
+                        name = NULL;
+                gid = aimbs_get16(bs);
+                bid = aimbs_get16(bs);
+                type = aimbs_get16(bs);
+                data = aim_tlvlist_readlen(bs, aimbs_get16(bs));
+                aim_ssi_itemlist_add(&sess->ssi.official, name, gid, bid, type, data);
+                free(name);
+                aim_tlvlist_free(&data);
+        }
+
+        /* Read in the timestamp */
+        sess->ssi.timestamp = aimbs_get32(bs);
+
+        if (!(snac->flags & 0x0001)) {
+                /* Make a copy of the list */
+                struct aim_ssi_item *cur;
+                for (cur=sess->ssi.official; cur; cur=cur->next)
+                        aim_ssi_itemlist_add(&sess->ssi.local, cur->name, cur->gid, cur->bid, cur->type, cur->data);
+
+                sess->ssi.received_data = 1;
+
+                if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
+                        ret = userfunc(sess, rx, fmtver, sess->ssi.numitems, sess->ssi.official, sess->ssi.timestamp);
+        }
+
+        return ret;
 }
 
@@ -1252 +1285 @@
 faim_export int aim_ssi_enable(aim_session_t *sess)
 {
-  aim_conn_t *conn;
-  
-  if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)))
-    return -EINVAL;
-  
-  return aim_genericreq_n(sess, conn, AIM_CB_FAM_SSI, 0x0007);
+        aim_conn_t *conn;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)))
+                return -EINVAL;
+
+        return aim_genericreq_n(sess, conn, AIM_CB_FAM_SSI, 0x0007);
 }
 
@@ -1270 +1303 @@
 faim_export int aim_ssi_addmoddel(aim_session_t *sess)
 {
-  aim_conn_t *conn;
-  aim_frame_t *fr;
-  aim_snacid_t snacid;
-  int snaclen;
-  struct aim_ssi_tmp *cur;
-  
-  if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)) || !sess->ssi.pending || !sess->ssi.pending->item) {
-    owl_function_debugmsg("aim_ssi_addmoddel: aborting early");
-    return -EINVAL;
-  }
-  
-  /* Calculate total SNAC size */
-  snaclen = 10; /* For family, subtype, flags, and SNAC ID */
-  for (cur=sess->ssi.pending; cur; cur=cur->next) {
-    snaclen += 10; /* For length, GID, BID, type, and length */
-    if (cur->item->name) snaclen += strlen(cur->item->name);
-    if (cur->item->data) snaclen += aim_sizetlvchain(&cur->item->data);
-  }
-  
-  if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, snaclen))) return (-ENOMEM);
-  
-  snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, sess->ssi.pending->action, 0x0000, NULL, 0);
-  aim_putsnac(&fr->data, AIM_CB_FAM_SSI, sess->ssi.pending->action, 0x0000, snacid);
-  
-  for (cur=sess->ssi.pending; cur; cur=cur->next) {
-    aimbs_put16(&fr->data, cur->item->name ? strlen(cur->item->name) : 0);
-    if (cur->item->name) aimbs_putraw(&fr->data, cur->item->name, strlen(cur->item->name));
-    aimbs_put16(&fr->data, cur->item->gid);
-    aimbs_put16(&fr->data, cur->item->bid);
-    aimbs_put16(&fr->data, cur->item->type);
-    aimbs_put16(&fr->data, cur->item->data ? aim_sizetlvchain(&cur->item->data) : 0);
-    if (cur->item->data) aim_writetlvchain(&fr->data, &cur->item->data);
-  }
-  
-  aim_tx_enqueue(sess, fr);
-
-  owl_function_debugmsg("aim_ssi_addmoddel: exiting normally");
-  return 0;
+        aim_conn_t *conn;
+        aim_frame_t *fr;
+        aim_snacid_t snacid;
+        int snaclen;
+        struct aim_ssi_tmp *cur;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)) || !sess->ssi.pending || !sess->ssi.pending->item)
+                return -EINVAL;
+
+        /* Calculate total SNAC size */
+        snaclen = 10; /* For family, subtype, flags, and SNAC ID */
+        for (cur=sess->ssi.pending; cur; cur=cur->next) {
+                snaclen += 10; /* For length, GID, BID, type, and length */
+                if (cur->item->name)
+                        snaclen += strlen(cur->item->name);
+                if (cur->item->data)
+                        snaclen += aim_tlvlist_size(&cur->item->data);
+        }
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, snaclen)))
+                return -ENOMEM;
+
+        snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, sess->ssi.pending->action, 0x0000, NULL, 0);
+        aim_putsnac(&fr->data, AIM_CB_FAM_SSI, sess->ssi.pending->action, 0x0000, snacid);
+
+        for (cur=sess->ssi.pending; cur; cur=cur->next) {
+                aimbs_put16(&fr->data, cur->item->name ? strlen(cur->item->name) : 0);
+                if (cur->item->name)
+                        aimbs_putraw(&fr->data, cur->item->name, strlen(cur->item->name));
+                aimbs_put16(&fr->data, cur->item->gid);
+                aimbs_put16(&fr->data, cur->item->bid);
+                aimbs_put16(&fr->data, cur->item->type);
+                aimbs_put16(&fr->data, cur->item->data ? aim_tlvlist_size(&cur->item->data) : 0);
+                if (cur->item->data)
+                        aim_tlvlist_write(&fr->data, &cur->item->data);
+        }
+
+        aim_tx_enqueue(sess, fr);
+
+        return 0;
 }
 
@@ -1317 +1352 @@
 static int parseadd(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  int ret = 0;
-  aim_rxcallback_t userfunc;
-  char *name;
-  fu16_t len, gid, bid, type;
-  aim_tlvlist_t *data;
-  
-  while (aim_bstream_empty(bs)) {
-    if ((len = aimbs_get16(bs)))
-      name = aimbs_getstr(bs, len);
-    else
-      name = NULL;
-    gid = aimbs_get16(bs);
-    bid = aimbs_get16(bs);
-    type = aimbs_get16(bs);
-    if ((len = aimbs_get16(bs)))
-      data = aim_readtlvchain_len(bs, len);
-    else
-      data = NULL;
-    
-    aim_ssi_itemlist_add(&sess->ssi.local, name, gid, bid, type, data);
-    aim_ssi_itemlist_add(&sess->ssi.official, name, gid, bid, type, data);
-    free(name);
-    aim_freetlvchain(&data);
-    
-    if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
-      ret = userfunc(sess, rx);
-    
-    free(name);
-  }
-  
-  return ret;
+        int ret = 0;
+        aim_rxcallback_t userfunc;
+        char *name;
+        fu16_t len, gid, bid, type;
+        aim_tlvlist_t *data;
+
+        while (aim_bstream_empty(bs)) {
+                if ((len = aimbs_get16(bs)))
+                        name = aimbs_getstr(bs, len);
+                else
+                        name = NULL;
+                gid = aimbs_get16(bs);
+                bid = aimbs_get16(bs);
+                type = aimbs_get16(bs);
+                if ((len = aimbs_get16(bs)))
+                        data = aim_tlvlist_readlen(bs, len);
+                else
+                        data = NULL;
+
+                aim_ssi_itemlist_add(&sess->ssi.local, name, gid, bid, type, data);
+                aim_ssi_itemlist_add(&sess->ssi.official, name, gid, bid, type, data);
+                free(name);
+                aim_tlvlist_free(&data);
+
+                if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
+                        ret = userfunc(sess, rx);
+
+                free(name);
+        }
+
+        return ret;
 }
 
@@ -1357 +1392 @@
 static int parsemod(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  int ret = 0;
-  aim_rxcallback_t userfunc;
-  char *name;
-  fu16_t len, gid, bid, type;
-  aim_tlvlist_t *data;
-  struct aim_ssi_item *item;
-  
-  while (aim_bstream_empty(bs)) {
-    if ((len = aimbs_get16(bs)))
-      name = aimbs_getstr(bs, len);
-    else
-      name = NULL;
-    gid = aimbs_get16(bs);
-    bid = aimbs_get16(bs);
-    type = aimbs_get16(bs);
-    if ((len = aimbs_get16(bs)))
-      data = aim_readtlvchain_len(bs, len);
-    else
-      data = NULL;
-    
-    /* Replace the 2 local items with the given one */
-    if ((item = aim_ssi_itemlist_find(sess->ssi.local, gid, bid))) {
-      item->type = type;
-      free(item->name);
-      if (name) {
-        item->name = (char *)malloc((strlen(name)+1)*sizeof(char));
-        strcpy(item->name, name);
-      } else
-        item->name = NULL;
-      aim_freetlvchain(&item->data);
-      item->data = aim_tlvlist_copy(data);
-    }
-    
-    if ((item = aim_ssi_itemlist_find(sess->ssi.official, gid, bid))) {
-      item->type = type;
-      free(item->name);
-      if (name) {
-        item->name = (char *)malloc((strlen(name)+1)*sizeof(char));
-        strcpy(item->name, name);
-      } else
-        item->name = NULL;
-      aim_freetlvchain(&item->data);
-      item->data = aim_tlvlist_copy(data);
-    }
-    
-    if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
-      ret = userfunc(sess, rx);
-    
-    free(name);
-    aim_freetlvchain(&data);
-  }
-  
-  return ret;
+        int ret = 0;
+        aim_rxcallback_t userfunc;
+        char *name;
+        fu16_t len, gid, bid, type;
+        aim_tlvlist_t *data;
+        struct aim_ssi_item *item;
+
+        while (aim_bstream_empty(bs)) {
+                if ((len = aimbs_get16(bs)))
+                        name = aimbs_getstr(bs, len);
+                else
+                        name = NULL;
+                gid = aimbs_get16(bs);
+                bid = aimbs_get16(bs);
+                type = aimbs_get16(bs);
+                if ((len = aimbs_get16(bs)))
+                        data = aim_tlvlist_readlen(bs, len);
+                else
+                        data = NULL;
+
+                /* Replace the 2 local items with the given one */
+                if ((item = aim_ssi_itemlist_find(sess->ssi.local, gid, bid))) {
+                        item->type = type;
+                        free(item->name);
+                        if (name) {
+                                item->name = (char *)malloc((strlen(name)+1)*sizeof(char));
+                                strcpy(item->name, name);
+                        } else
+                                item->name = NULL;
+                        aim_tlvlist_free(&item->data);
+                        item->data = aim_tlvlist_copy(data);
+                }
+
+                if ((item = aim_ssi_itemlist_find(sess->ssi.official, gid, bid))) {
+                        item->type = type;
+                        free(item->name);
+                        if (name) {
+                                item->name = (char *)malloc((strlen(name)+1)*sizeof(char));
+                                strcpy(item->name, name);
+                        } else
+                                item->name = NULL;
+                        aim_tlvlist_free(&item->data);
+                        item->data = aim_tlvlist_copy(data);
+                }
+
+                if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
+                        ret = userfunc(sess, rx);
+
+                free(name);
+                aim_tlvlist_free(&data);
+        }
+
+        return ret;
 }
 
@@ -1419 +1454 @@
 static int parsedel(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  int ret = 0;
-  aim_rxcallback_t userfunc;
-  fu16_t gid, bid;
-  struct aim_ssi_item *del;
-  
-  while (aim_bstream_empty(bs)) {
-    aim_bstream_advance(bs, aimbs_get16(bs));
-    gid = aimbs_get16(bs);
-    bid = aimbs_get16(bs);
-    aimbs_get16(bs);
-    aim_bstream_advance(bs, aimbs_get16(bs));
-    
-    if ((del = aim_ssi_itemlist_find(sess->ssi.local, gid, bid)))
-      aim_ssi_itemlist_del(&sess->ssi.local, del);
-    if ((del = aim_ssi_itemlist_find(sess->ssi.official, gid, bid)))
-      aim_ssi_itemlist_del(&sess->ssi.official, del);
-    
-    if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
-      ret = userfunc(sess, rx);
-  }
-  
-  return ret;
+        int ret = 0;
+        aim_rxcallback_t userfunc;
+        fu16_t gid, bid;
+        struct aim_ssi_item *del;
+
+        while (aim_bstream_empty(bs)) {
+                aim_bstream_advance(bs, aimbs_get16(bs));
+                gid = aimbs_get16(bs);
+                bid = aimbs_get16(bs);
+                aimbs_get16(bs);
+                aim_bstream_advance(bs, aimbs_get16(bs));
+
+                if ((del = aim_ssi_itemlist_find(sess->ssi.local, gid, bid)))
+                        aim_ssi_itemlist_del(&sess->ssi.local, del);
+                if ((del = aim_ssi_itemlist_find(sess->ssi.official, gid, bid)))
+                        aim_ssi_itemlist_del(&sess->ssi.official, del);
+
+                if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
+                        ret = userfunc(sess, rx);
+        }
+
+        return ret;
 }
 
@@ -1451 +1486 @@
 static int parseack(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  int ret = 0;
-  aim_rxcallback_t userfunc;
-  struct aim_ssi_tmp *cur, *del;
-
-  owl_function_debugmsg("Handling SNAC SSI ACK");
-  
-  /* Read in the success/failure flags from the ack SNAC */
-  cur = sess->ssi.pending;
-  while (cur && (aim_bstream_empty(bs)>0)) {
-    cur->ack = aimbs_get16(bs);
-    cur = cur->next;
-  }
-  
-  /*
-   * If outcome is 0, then add the item to the item list, or replace the other item, 
-   * or remove the old item.  If outcome is non-zero, then remove the item from the 
-   * local list, or unmodify it, or add it.
-   */
-  for (cur=sess->ssi.pending; (cur && (cur->ack != 0xffff)); cur=cur->next) {
-    owl_function_debugmsg("parseack: processing a change");
-    if (cur->item) {
-      if (cur->ack) {
-        /* Our action was unsuccessful, so change the local list back to how it was */
-        if (cur->action == AIM_CB_SSI_ADD) {
-          owl_function_debugmsg("parseack: unsuccesful add, reverting");
-          /* Remove the item from the local list */
-          /* Make sure cur->item is still valid memory */
-          if (aim_ssi_itemlist_valid(sess->ssi.local, cur->item)) {
-            if (cur->item->name) {
-              cur->name = (char *)malloc((strlen(cur->item->name)+1)*sizeof(char));
-              strcpy(cur->name, cur->item->name);
-            }
-            aim_ssi_itemlist_del(&sess->ssi.local, cur->item);
-          }
-          cur->item = NULL;
-          
-        } else if (cur->action == AIM_CB_SSI_MOD) {
-          /* Replace the local item with the item from the official list */
-          owl_function_debugmsg("parseack: unsuccesful modify, reverting");
-          if (aim_ssi_itemlist_valid(sess->ssi.local, cur->item)) {
-            struct aim_ssi_item *cur1;
-            if ((cur1 = aim_ssi_itemlist_find(sess->ssi.official, cur->item->gid, cur->item->bid))) {
-              free(cur->item->name);
-              if (cur1->name) {
-                cur->item->name = (char *)malloc((strlen(cur1->name)+1)*sizeof(char));
-                strcpy(cur->item->name, cur1->name);
-              } else
-                cur->item->name = NULL;
-              aim_freetlvchain(&cur->item->data);
-              cur->item->data = aim_tlvlist_copy(cur1->data);
-            }
-          } else
-            cur->item = NULL;
-          
-        } else if (cur->action == AIM_CB_SSI_DEL) {
-          /* Add the item back into the local list */
-          owl_function_debugmsg("parseack: unsuccesful delete, reverting");
-          if (aim_ssi_itemlist_valid(sess->ssi.official, cur->item)) {
-            aim_ssi_itemlist_add(&sess->ssi.local, cur->item->name, cur->item->gid, cur->item->bid, cur->item->type, cur->item->data);
-          } else
-            cur->item = NULL;
-        }
-        
-      } else {
-        /* Do the exact opposite */
-        if (cur->action == AIM_CB_SSI_ADD) {
-          /* Add the local item to the official list */
-          owl_function_debugmsg("parseack: succesful add");
-          if (aim_ssi_itemlist_valid(sess->ssi.local, cur->item)) {
-            aim_ssi_itemlist_add(&sess->ssi.official, cur->item->name, cur->item->gid, cur->item->bid, cur->item->type, cur->item->data);
-          } else
-            cur->item = NULL;
-          
-        } else if (cur->action == AIM_CB_SSI_MOD) {
-          /* Replace the official item with the item from the local list */
-          owl_function_debugmsg("parseack: succesful modify");
-          if (aim_ssi_itemlist_valid(sess->ssi.local, cur->item)) {
-            struct aim_ssi_item *cur1;
-            if ((cur1 = aim_ssi_itemlist_find(sess->ssi.official, cur->item->gid, cur->item->bid))) {
-              free(cur1->name);
-              if (cur->item->name) {
-                cur1->name = (char *)malloc((strlen(cur->item->name)+1)*sizeof(char));
-                strcpy(cur1->name, cur->item->name);
-              } else
-                cur1->name = NULL;
-              aim_freetlvchain(&cur1->data);
-              cur1->data = aim_tlvlist_copy(cur->item->data);
-            }
-          } else
-            cur->item = NULL;
-          
-        } else if (cur->action == AIM_CB_SSI_DEL) {
-          /* Remove the item from the official list */
-          owl_function_debugmsg("parseack: succesful delete");
-          if (aim_ssi_itemlist_valid(sess->ssi.official, cur->item))
-            aim_ssi_itemlist_del(&sess->ssi.official, cur->item);
-          cur->item = NULL;
-        }
-        
-      }
-    } /* End if (cur->item) */
-  } /* End for loop */
-  
-  if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
-    ret = userfunc(sess, rx, sess->ssi.pending);
-  
-  /* Free all aim_ssi_tmp's with an outcome */
-  cur = sess->ssi.pending;
-  while (cur && (cur->ack != 0xffff)) {
-    del = cur;
-    cur = cur->next;
-    free(del->name);
-    free(del);
-  }
-  sess->ssi.pending = cur;
-  
-  /* If we're not waiting for any more acks, then send more SNACs */
-
-  if (!sess->ssi.pending) {
-    sess->ssi.pending = NULL;
-    sess->ssi.waiting_for_ack = 0;
-    owl_function_debugmsg("parseack: Clearing SSI waiting_for_ack");
-    aim_ssi_sync(sess);
-  }
-
-  owl_function_debugmsg("parseack: returning with %i", ret);
-  
-  return ret;
+        int ret = 0;
+        aim_rxcallback_t userfunc;
+        struct aim_ssi_tmp *cur, *del;
+
+        /* Read in the success/failure flags from the ack SNAC */
+        cur = sess->ssi.pending;
+        while (cur && (aim_bstream_empty(bs)>0)) {
+                cur->ack = aimbs_get16(bs);
+                cur = cur->next;
+        }
+
+        /*
+         * If outcome is 0, then add the item to the item list, or replace the other item, 
+         * or remove the old item.  If outcome is non-zero, then remove the item from the 
+         * local list, or unmodify it, or add it.
+         */
+        for (cur=sess->ssi.pending; (cur && (cur->ack != 0xffff)); cur=cur->next) {
+        if (cur->item) {
+                if (cur->ack) {
+                        /* Our action was unsuccessful, so change the local list back to how it was */
+                        if (cur->action == AIM_CB_SSI_ADD) {
+                                /* Remove the item from the local list */
+                                /* Make sure cur->item is still valid memory */
+                                if (aim_ssi_itemlist_valid(sess->ssi.local, cur->item)) {
+                                        if (cur->item->name) {
+                                                cur->name = (char *)malloc((strlen(cur->item->name)+1)*sizeof(char));
+                                                strcpy(cur->name, cur->item->name);
+                                        }
+                                        aim_ssi_itemlist_del(&sess->ssi.local, cur->item);
+                                }
+                                cur->item = NULL;
+
+                        } else if (cur->action == AIM_CB_SSI_MOD) {
+                                /* Replace the local item with the item from the official list */
+                                if (aim_ssi_itemlist_valid(sess->ssi.local, cur->item)) {
+                                        struct aim_ssi_item *cur1;
+                                        if ((cur1 = aim_ssi_itemlist_find(sess->ssi.official, cur->item->gid, cur->item->bid))) {
+                                                free(cur->item->name);
+                                                if (cur1->name) {
+                                                        cur->item->name = (char *)malloc((strlen(cur1->name)+1)*sizeof(char));
+                                                        strcpy(cur->item->name, cur1->name);
+                                                } else
+                                                        cur->item->name = NULL;
+                                                aim_tlvlist_free(&cur->item->data);
+                                                cur->item->data = aim_tlvlist_copy(cur1->data);
+                                        }
+                                } else
+                                        cur->item = NULL;
+
+                        } else if (cur->action == AIM_CB_SSI_DEL) {
+                                /* Add the item back into the local list */
+                                if (aim_ssi_itemlist_valid(sess->ssi.official, cur->item)) {
+                                        aim_ssi_itemlist_add(&sess->ssi.local, cur->item->name, cur->item->gid, cur->item->bid, cur->item->type, cur->item->data);
+                                } else
+                                        cur->item = NULL;
+                        }
+
+                } else {
+                        /* Do the exact opposite */
+                        if (cur->action == AIM_CB_SSI_ADD) {
+                        /* Add the local item to the official list */
+                                if (aim_ssi_itemlist_valid(sess->ssi.local, cur->item)) {
+                                        aim_ssi_itemlist_add(&sess->ssi.official, cur->item->name, cur->item->gid, cur->item->bid, cur->item->type, cur->item->data);
+                                } else
+                                        cur->item = NULL;
+
+                        } else if (cur->action == AIM_CB_SSI_MOD) {
+                                /* Replace the official item with the item from the local list */
+                                if (aim_ssi_itemlist_valid(sess->ssi.local, cur->item)) {
+                                        struct aim_ssi_item *cur1;
+                                        if ((cur1 = aim_ssi_itemlist_find(sess->ssi.official, cur->item->gid, cur->item->bid))) {
+                                                free(cur1->name);
+                                                if (cur->item->name) {
+                                                        cur1->name = (char *)malloc((strlen(cur->item->name)+1)*sizeof(char));
+                                                        strcpy(cur1->name, cur->item->name);
+                                                } else
+                                                        cur1->name = NULL;
+                                                aim_tlvlist_free(&cur1->data);
+                                                cur1->data = aim_tlvlist_copy(cur->item->data);
+                                        }
+                                } else
+                                        cur->item = NULL;
+
+                        } else if (cur->action == AIM_CB_SSI_DEL) {
+                                /* Remove the item from the official list */
+                                if (aim_ssi_itemlist_valid(sess->ssi.official, cur->item))
+                                        aim_ssi_itemlist_del(&sess->ssi.official, cur->item);
+                                cur->item = NULL;
+                        }
+
+                }
+        } /* End if (cur->item) */
+        } /* End for loop */
+
+        if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
+                ret = userfunc(sess, rx, sess->ssi.pending);
+
+        /* Free all aim_ssi_tmp's with an outcome */
+        cur = sess->ssi.pending;
+        while (cur && (cur->ack != 0xffff)) {
+                del = cur;
+                cur = cur->next;
+                free(del->name);
+                free(del);
+        }
+        sess->ssi.pending = cur;
+
+        /* If we're not waiting for any more acks, then send more SNACs */
+        if (!sess->ssi.pending) {
+                sess->ssi.pending = NULL;
+                sess->ssi.waiting_for_ack = 0;
+                aim_ssi_sync(sess);
+        }
+
+        return ret;
 }
 
@@ -1590 +1612 @@
 static int parsedataunchanged(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  int ret = 0;
-  aim_rxcallback_t userfunc;
-  
-  sess->ssi.received_data = 1;
-  
-  if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
-    ret = userfunc(sess, rx);
-  
-  return ret;
+        int ret = 0;
+        aim_rxcallback_t userfunc;
+
+        sess->ssi.received_data = 1;
+
+        if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
+                ret = userfunc(sess, rx);
+
+        return ret;
 }
 
@@ -1609 +1631 @@
 faim_export int aim_ssi_modbegin(aim_session_t *sess)
 {
-  aim_conn_t *conn;
-  
-  if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)))
-    return -EINVAL;
-  
-  return aim_genericreq_n(sess, conn, AIM_CB_FAM_SSI, AIM_CB_SSI_EDITSTART);
+        aim_conn_t *conn;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)))
+                return -EINVAL;
+
+        return aim_genericreq_n(sess, conn, AIM_CB_FAM_SSI, AIM_CB_SSI_EDITSTART);
 }
 
@@ -1625 +1647 @@
 faim_export int aim_ssi_modend(aim_session_t *sess)
 {
-  aim_conn_t *conn;
-  
-  if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI))) return -EINVAL;
-  
-  return aim_genericreq_n(sess, conn, AIM_CB_FAM_SSI, AIM_CB_SSI_EDITSTOP);
+        aim_conn_t *conn;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)))
+                return -EINVAL;
+
+        return aim_genericreq_n(sess, conn, AIM_CB_FAM_SSI, AIM_CB_SSI_EDITSTOP);
 }
 
@@ -1640 +1663 @@
 faim_export int aim_ssi_sendauth(aim_session_t *sess, char *sn, char *msg)
 {
-  aim_conn_t *conn;
-  aim_frame_t *fr;
-  aim_snacid_t snacid;
-  
-  if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)) || !sn)
-    return -EINVAL;
-  
-  if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+1+strlen(sn)+2+(msg ? strlen(msg)+1 : 0)+2)))
-    return -ENOMEM;
-  
-  snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTH, 0x0000, NULL, 0);
-  aim_putsnac(&fr->data, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTH, 0x0000, snacid);
-  
-  /* Screen name */
-  aimbs_put8(&fr->data, strlen(sn));
-  aimbs_putraw(&fr->data, sn, strlen(sn));
-  
-  /* Message (null terminated) */
-  aimbs_put16(&fr->data, msg ? strlen(msg) : 0);
-  if (msg) {
-    aimbs_putraw(&fr->data, msg, strlen(msg));
-    aimbs_put8(&fr->data, 0x00);
-  }
-  
-  /* Unknown */
-  aimbs_put16(&fr->data, 0x0000);
-  
-  aim_tx_enqueue(sess, fr);
-  
-  return 0;
+        aim_conn_t *conn;
+        aim_frame_t *fr;
+        aim_snacid_t snacid;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)) || !sn)
+                return -EINVAL;
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+1+strlen(sn)+2+(msg ? strlen(msg)+1 : 0)+2)))
+                return -ENOMEM;
+
+        snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTH, 0x0000, NULL, 0);
+        aim_putsnac(&fr->data, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTH, 0x0000, snacid);
+
+        /* Screen name */
+        aimbs_put8(&fr->data, strlen(sn));
+        aimbs_putraw(&fr->data, sn, strlen(sn));
+
+        /* Message (null terminated) */
+        aimbs_put16(&fr->data, msg ? strlen(msg) : 0);
+        if (msg) {
+                aimbs_putraw(&fr->data, msg, strlen(msg));
+                aimbs_put8(&fr->data, 0x00);
+        }
+
+        /* Unknown */
+        aimbs_put16(&fr->data, 0x0000);
+
+        aim_tx_enqueue(sess, fr);
+
+        return 0;
 }
 
@@ -1677 +1700 @@
 static int receiveauthgrant(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  int ret = 0;
-  aim_rxcallback_t userfunc;
-  fu16_t tmp;
-  char *sn, *msg;
-  
-  /* Read screen name */
-  if ((tmp = aimbs_get8(bs)))
-    sn = aimbs_getstr(bs, tmp);
-  else
-    sn = NULL;
-  
-  /* Read message (null terminated) */
-  if ((tmp = aimbs_get16(bs)))
-    msg = aimbs_getstr(bs, tmp);
-  else
-    msg = NULL;
-  
-  /* Unknown */
-  tmp = aimbs_get16(bs);
-  
-  if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
-    ret = userfunc(sess, rx, sn, msg);
-  
-  free(sn);
-  free(msg);
-  
-  return ret;
+        int ret = 0;
+        aim_rxcallback_t userfunc;
+        fu16_t tmp;
+        char *sn, *msg;
+
+        /* Read screen name */
+        if ((tmp = aimbs_get8(bs)))
+                sn = aimbs_getstr(bs, tmp);
+        else
+                sn = NULL;
+
+        /* Read message (null terminated) */
+        if ((tmp = aimbs_get16(bs)))
+                msg = aimbs_getstr(bs, tmp);
+        else
+                msg = NULL;
+
+        /* Unknown */
+        tmp = aimbs_get16(bs);
+
+        if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
+                ret = userfunc(sess, rx, sn, msg);
+
+        free(sn);
+        free(msg);
+
+        return ret;
 }
 
@@ -1715 +1738 @@
 faim_export int aim_ssi_sendauthrequest(aim_session_t *sess, char *sn, char *msg)
 {
-  aim_conn_t *conn;
-  aim_frame_t *fr;
-  aim_snacid_t snacid;
-  
-  if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)) || !sn)
-    return -EINVAL;
-  
-  if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+1+strlen(sn)+2+(msg ? strlen(msg)+1 : 0)+2)))
-    return -ENOMEM;
-  
-  snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTHREQ, 0x0000, NULL, 0);
-  aim_putsnac(&fr->data, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTHREQ, 0x0000, snacid);
-  
-  /* Screen name */
-  aimbs_put8(&fr->data, strlen(sn));
-  aimbs_putraw(&fr->data, sn, strlen(sn));
-  
-  /* Message (null terminated) */
-  aimbs_put16(&fr->data, msg ? strlen(msg) : 0);
-  if (msg) {
-    aimbs_putraw(&fr->data, msg, strlen(msg));
-    aimbs_put8(&fr->data, 0x00);
-  }
-  
-  /* Unknown */
-  aimbs_put16(&fr->data, 0x0000);
-  
-  aim_tx_enqueue(sess, fr);
-  
-  return 0;
+        aim_conn_t *conn;
+        aim_frame_t *fr;
+        aim_snacid_t snacid;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)) || !sn)
+                return -EINVAL;
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+1+strlen(sn)+2+(msg ? strlen(msg)+1 : 0)+2)))
+                return -ENOMEM;
+
+        snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTHREQ, 0x0000, NULL, 0);
+        aim_putsnac(&fr->data, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTHREQ, 0x0000, snacid);
+
+        /* Screen name */
+        aimbs_put8(&fr->data, strlen(sn));
+        aimbs_putraw(&fr->data, sn, strlen(sn));
+
+        /* Message (null terminated) */
+        aimbs_put16(&fr->data, msg ? strlen(msg) : 0);
+        if (msg) {
+                aimbs_putraw(&fr->data, msg, strlen(msg));
+                aimbs_put8(&fr->data, 0x00);
+        }
+
+        /* Unknown */
+        aimbs_put16(&fr->data, 0x0000);
+
+        aim_tx_enqueue(sess, fr);
+
+        return 0;
 }
 
@@ -1752 +1775 @@
 static int receiveauthrequest(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  int ret = 0;
-  aim_rxcallback_t userfunc;
-  fu16_t tmp;
-  char *sn, *msg;
-  
-  /* Read screen name */
-  if ((tmp = aimbs_get8(bs)))
-    sn = aimbs_getstr(bs, tmp);
-  else
-    sn = NULL;
-  
-  /* Read message (null terminated) */
-  if ((tmp = aimbs_get16(bs)))
-    msg = aimbs_getstr(bs, tmp);
-  else
-    msg = NULL;
-  
-  /* Unknown */
-  tmp = aimbs_get16(bs);
-  
-  if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
-    ret = userfunc(sess, rx, sn, msg);
-  
-  free(sn);
-  free(msg);
-  
-  return ret;
+        int ret = 0;
+        aim_rxcallback_t userfunc;
+        fu16_t tmp;
+        char *sn, *msg;
+
+        /* Read screen name */
+        if ((tmp = aimbs_get8(bs)))
+                sn = aimbs_getstr(bs, tmp);
+        else
+                sn = NULL;
+
+        /* Read message (null terminated) */
+        if ((tmp = aimbs_get16(bs)))
+                msg = aimbs_getstr(bs, tmp);
+        else
+                msg = NULL;
+
+        /* Unknown */
+        tmp = aimbs_get16(bs);
+
+        if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
+                ret = userfunc(sess, rx, sn, msg);
+
+        free(sn);
+        free(msg);
+
+        return ret;
 }
 
@@ -1793 +1816 @@
 faim_export int aim_ssi_sendauthreply(aim_session_t *sess, char *sn, fu8_t reply, char *msg)
 {
-  aim_conn_t *conn;
-  aim_frame_t *fr;
-  aim_snacid_t snacid;
-  
-  if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)) || !sn)
-    return -EINVAL;
-  
-  if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 1+strlen(sn) + 1 + 2+(msg ? strlen(msg)+1 : 0) + 2)))
-    return -ENOMEM;
-  
-  snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTHREP, 0x0000, NULL, 0);
-  aim_putsnac(&fr->data, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTHREP, 0x0000, snacid);
-  
-  /* Screen name */
-  aimbs_put8(&fr->data, strlen(sn));
-  aimbs_putraw(&fr->data, sn, strlen(sn));
-  
-  /* Grant or deny */
-  aimbs_put8(&fr->data, reply);
-  
-  /* Message (null terminated) */
-  aimbs_put16(&fr->data, msg ? (strlen(msg)+1) : 0);
-  if (msg) {
-    aimbs_putraw(&fr->data, msg, strlen(msg));
-    aimbs_put8(&fr->data, 0x00);
-  }
-  
-  /* Unknown */
-  aimbs_put16(&fr->data, 0x0000);
-  
-  aim_tx_enqueue(sess, fr);
-  
-  return 0;
+        aim_conn_t *conn;
+        aim_frame_t *fr;
+        aim_snacid_t snacid;
+
+        if (!sess || !(conn = aim_conn_findbygroup(sess, AIM_CB_FAM_SSI)) || !sn)
+                return -EINVAL;
+
+        if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 1+strlen(sn) + 1 + 2+(msg ? strlen(msg)+1 : 0) + 2)))
+                return -ENOMEM;
+
+        snacid = aim_cachesnac(sess, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTHREP, 0x0000, NULL, 0);
+        aim_putsnac(&fr->data, AIM_CB_FAM_SSI, AIM_CB_SSI_SENDAUTHREP, 0x0000, snacid);
+
+        /* Screen name */
+        aimbs_put8(&fr->data, strlen(sn));
+        aimbs_putraw(&fr->data, sn, strlen(sn));
+
+        /* Grant or deny */
+        aimbs_put8(&fr->data, reply);
+
+        /* Message (null terminated) */
+        aimbs_put16(&fr->data, msg ? (strlen(msg)+1) : 0);
+        if (msg) {
+                aimbs_putraw(&fr->data, msg, strlen(msg));
+                aimbs_put8(&fr->data, 0x00);
+        }
+
+        /* Unknown */
+        aimbs_put16(&fr->data, 0x0000);
+
+        aim_tx_enqueue(sess, fr);
+
+        return 0;
 }
 
@@ -1835 +1858 @@
 static int receiveauthreply(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  int ret = 0;
-  aim_rxcallback_t userfunc;
-  fu16_t tmp;
-  fu8_t reply;
-  char *sn, *msg;
-  
-  /* Read screen name */
-  if ((tmp = aimbs_get8(bs)))
-    sn = aimbs_getstr(bs, tmp);
-  else
-    sn = NULL;
-  
-  /* Read reply */
-  reply = aimbs_get8(bs);
-  
-  /* Read message (null terminated) */
-  if ((tmp = aimbs_get16(bs)))
-    msg = aimbs_getstr(bs, tmp);
-  else
-    msg = NULL;
-  
-  /* Unknown */
-  tmp = aimbs_get16(bs);
-  
-  if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
-    ret = userfunc(sess, rx, sn, reply, msg);
-  
-  free(sn);
-  free(msg);
-  
-  return ret;
+        int ret = 0;
+        aim_rxcallback_t userfunc;
+        fu16_t tmp;
+        fu8_t reply;
+        char *sn, *msg;
+
+        /* Read screen name */
+        if ((tmp = aimbs_get8(bs)))
+                sn = aimbs_getstr(bs, tmp);
+        else
+                sn = NULL;
+
+        /* Read reply */
+        reply = aimbs_get8(bs);
+
+        /* Read message (null terminated) */
+        if ((tmp = aimbs_get16(bs)))
+                msg = aimbs_getstr(bs, tmp);
+        else
+                msg = NULL;
+
+        /* Unknown */
+        tmp = aimbs_get16(bs);
+
+        if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
+                ret = userfunc(sess, rx, sn, reply, msg);
+
+        free(sn);
+        free(msg);
+
+        return ret;
 }
 
@@ -1873 +1896 @@
 static int receiveadded(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  int ret = 0;
-  aim_rxcallback_t userfunc;
-  fu16_t tmp;
-  char *sn;
-  
-  /* Read screen name */
-  if ((tmp = aimbs_get8(bs))) {
-    sn = aimbs_getstr(bs, tmp);
-  } else {
-    sn = NULL;
-  }
-  
-  if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) {
-    ret = userfunc(sess, rx, sn);
-  }
-  
-  free(sn);
-  return(ret);
+        int ret = 0;
+        aim_rxcallback_t userfunc;
+        fu16_t tmp;
+        char *sn;
+
+        /* Read screen name */
+        if ((tmp = aimbs_get8(bs)))
+                sn = aimbs_getstr(bs, tmp);
+        else
+                sn = NULL;
+
+        if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
+                ret = userfunc(sess, rx, sn);
+
+        free(sn);
+
+        return ret;
 }
 
 static int snachandler(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 {
-  if (snac->subtype == AIM_CB_SSI_RIGHTSINFO) {
-    return parserights(sess, mod, rx, snac, bs);
-  } else if (snac->subtype == AIM_CB_SSI_LIST) {
-    return parsedata(sess, mod, rx, snac, bs);
-  } else if (snac->subtype == AIM_CB_SSI_ADD) {
-    return parseadd(sess, mod, rx, snac, bs);
-  } else if (snac->subtype == AIM_CB_SSI_MOD) {
-    return parsemod(sess, mod, rx, snac, bs);
-  } else if (snac->subtype == AIM_CB_SSI_DEL) {
-    return parsedel(sess, mod, rx, snac, bs);
-  } else if (snac->subtype == AIM_CB_SSI_SRVACK) {
-    return parseack(sess, mod, rx, snac, bs);
-  } else if (snac->subtype == AIM_CB_SSI_NOLIST) {
-    return parsedataunchanged(sess, mod, rx, snac, bs);
-  } else if (snac->subtype == AIM_CB_SSI_RECVAUTH) {
-    return receiveauthgrant(sess, mod, rx, snac, bs);
-  } else if (snac->subtype == AIM_CB_SSI_RECVAUTHREQ) {
-    return receiveauthrequest(sess, mod, rx, snac, bs);
-  } else if (snac->subtype == AIM_CB_SSI_RECVAUTHREP) {
-    return receiveauthreply(sess, mod, rx, snac, bs);
-  } else if (snac->subtype == AIM_CB_SSI_ADDED) {
-    return receiveadded(sess, mod, rx, snac, bs);
-  }
-  return(0);
+
+        if (snac->subtype == AIM_CB_SSI_RIGHTSINFO)
+                return parserights(sess, mod, rx, snac, bs);
+        else if (snac->subtype == AIM_CB_SSI_LIST)
+                return parsedata(sess, mod, rx, snac, bs);
+        else if (snac->subtype == AIM_CB_SSI_ADD)
+                return parseadd(sess, mod, rx, snac, bs);
+        else if (snac->subtype == AIM_CB_SSI_MOD)
+                return parsemod(sess, mod, rx, snac, bs);
+        else if (snac->subtype == AIM_CB_SSI_DEL)
+                return parsedel(sess, mod, rx, snac, bs);
+        else if (snac->subtype == AIM_CB_SSI_SRVACK)
+                return parseack(sess, mod, rx, snac, bs);
+        else if (snac->subtype == AIM_CB_SSI_NOLIST)
+                return parsedataunchanged(sess, mod, rx, snac, bs);
+        else if (snac->subtype == AIM_CB_SSI_RECVAUTH)
+                return receiveauthgrant(sess, mod, rx, snac, bs);
+        else if (snac->subtype == AIM_CB_SSI_RECVAUTHREQ)
+                return receiveauthrequest(sess, mod, rx, snac, bs);
+        else if (snac->subtype == AIM_CB_SSI_RECVAUTHREP)
+                return receiveauthreply(sess, mod, rx, snac, bs);
+        else if (snac->subtype == AIM_CB_SSI_ADDED)
+                return receiveadded(sess, mod, rx, snac, bs);
+
+        return 0;
 }
 
 static void ssi_shutdown(aim_session_t *sess, aim_module_t *mod)
 {
-  aim_ssi_freelist(sess);
-  return;
+        aim_ssi_freelist(sess);
 }
 
 faim_internal int ssi_modfirst(aim_session_t *sess, aim_module_t *mod)
 {
-  
-  mod->family = AIM_CB_FAM_SSI;
-  mod->version = 0x0004;
-  mod->toolid = 0x0110;
-  mod->toolversion = 0x0629;
-  mod->flags = 0;
-  strncpy(mod->name, "ssi", sizeof(mod->name));
-  mod->snachandler = snachandler;
-  mod->shutdown = ssi_shutdown;
-  
-  return 0;
-}
+
+        mod->family = AIM_CB_FAM_SSI;
+        mod->version = 0x0004;
+        mod->toolid = 0x0110;
+        mod->toolversion = 0x0629;
+        mod->flags = 0;
+        strncpy(mod->name, "ssi", sizeof(mod->name));
+        mod->snachandler = snachandler;
+        mod->shutdown = ssi_shutdown;
+
+        return 0;
+}

libfaim/tlv.c

@@ -3 +3 @@
 #include <aim.h>
 
-static aim_tlv_t *createtlv(void)
-{
-        aim_tlv_t *newtlv;
-
-        if (!(newtlv = (aim_tlv_t *)malloc(sizeof(aim_tlv_t))))
+static aim_tlv_t *createtlv(fu16_t type, fu16_t length, fu8_t *value)
+{
+        aim_tlv_t *ret;
+
+        if (!(ret = (aim_tlv_t *)malloc(sizeof(aim_tlv_t))))
                 return NULL;
-        memset(newtlv, 0, sizeof(aim_tlv_t));
-
-        return newtlv;
+        ret->type = type;
+        ret->length = length;
+        ret->value = value;
+
+        return ret;
 }
 
@@ -28 +30 @@
 
 /**
- * aim_readtlvchain - Read a TLV chain from a buffer.
- * @param bs Input bstream
+ * Read a TLV chain from a buffer.
  *
  * Reads and parses a series of TLV patterns from a data buffer; the
  * returned structure is manipulatable with the rest of the TLV
- * routines.  When done with a TLV chain, aim_freetlvchain() should
+ * routines.  When done with a TLV chain, aim_tlvlist_free() should
  * be called to free the dynamic substructures.
  *
@@ -42 +43 @@
  * in libfaim.
  *
- */
-faim_internal aim_tlvlist_t *aim_readtlvchain(aim_bstream_t *bs)
+ * @param bs Input bstream
+ */
+faim_internal aim_tlvlist_t *aim_tlvlist_read(aim_bstream_t *bs)
 {
         aim_tlvlist_t *list = NULL, *cur;
@@ -71 +73 @@
 
                         if (length > aim_bstream_empty(bs)) {
-                                aim_freetlvchain(&list);
+                                aim_tlvlist_free(&list);
                                 return NULL;
                         }
@@ -77 +79 @@
                         cur = (aim_tlvlist_t *)malloc(sizeof(aim_tlvlist_t));
                         if (!cur) {
-                                aim_freetlvchain(&list);
+                                aim_tlvlist_free(&list);
                                 return NULL;
                         }
@@ -83 +85 @@
                         memset(cur, 0, sizeof(aim_tlvlist_t));
 
-                        cur->tlv = createtlv();
+                        cur->tlv = createtlv(type, length, NULL);
                         if (!cur->tlv) {
                                 free(cur);
-                                aim_freetlvchain(&list);
+                                aim_tlvlist_free(&list);
                                 return NULL;
                         }
-                        cur->tlv->type = type;
-                        if ((cur->tlv->length = length)) {
-                               cur->tlv->value = aimbs_getraw(bs, length);      
-                               if (!cur->tlv->value) {
-                                       freetlv(&cur->tlv);
-                                       free(cur);
-                                       aim_freetlvchain(&list);
-                                       return NULL;
-                               }
+                        if (cur->tlv->length > 0) {
+                                cur->tlv->value = aimbs_getraw(bs, length);     
+                                if (!cur->tlv->value) {
+                                        freetlv(&cur->tlv);
+                                        free(cur);
+                                        aim_tlvlist_free(&list);
+                                        return NULL;
+                                }
                         }
 
@@ -109 +110 @@
 
 /**
- * aim_readtlvchain_num - Read a TLV chain from a buffer.
+ * Read a TLV chain from a buffer.
+ *
+ * Reads and parses a series of TLV patterns from a data buffer; the
+ * returned structure is manipulatable with the rest of the TLV
+ * routines.  When done with a TLV chain, aim_tlvlist_free() should
+ * be called to free the dynamic substructures.
+ *
+ * XXX There should be a flag setable here to have the tlvlist contain
+ * bstream references, so that at least the ->value portion of each 
+ * element doesn't need to be malloc/memcpy'd.  This could prove to be
+ * just as effecient as the in-place TLV parsing used in a couple places
+ * in libfaim.
+ *
  * @param bs Input bstream
  * @param num The max number of TLVs that will be read, or -1 if unlimited.  
@@ -115 +128 @@
  *        but the chain is not at the end of the SNAC, and the chain is 
  *        preceeded by the number of TLVs.  So you can limit that with this.
+ */
+faim_internal aim_tlvlist_t *aim_tlvlist_readnum(aim_bstream_t *bs, fu16_t num)
+{
+        aim_tlvlist_t *list = NULL, *cur;
+
+        while ((aim_bstream_empty(bs) > 0) && (num != 0)) {
+                fu16_t type, length;
+
+                type = aimbs_get16(bs);
+                length = aimbs_get16(bs);
+
+                if (length > aim_bstream_empty(bs)) {
+                        aim_tlvlist_free(&list);
+                        return NULL;
+                }
+
+                cur = (aim_tlvlist_t *)malloc(sizeof(aim_tlvlist_t));
+                if (!cur) {
+                        aim_tlvlist_free(&list);
+                        return NULL;
+                }
+
+                memset(cur, 0, sizeof(aim_tlvlist_t));
+
+                cur->tlv = createtlv(type, length, NULL);
+                if (!cur->tlv) {
+                        free(cur);
+                        aim_tlvlist_free(&list);
+                        return NULL;
+                }
+                if (cur->tlv->length > 0) {
+                        cur->tlv->value = aimbs_getraw(bs, length);
+                        if (!cur->tlv->value) {
+                                freetlv(&cur->tlv);
+                                free(cur);
+                                aim_tlvlist_free(&list);
+                                return NULL;
+                        }
+                }
+
+                if (num > 0)
+                        num--;
+                cur->next = list;
+                list = cur;
+        }
+
+        return list;
+}
+
+/**
+ * Read a TLV chain from a buffer.
  *
  * Reads and parses a series of TLV patterns from a data buffer; the
  * returned structure is manipulatable with the rest of the TLV
- * routines.  When done with a TLV chain, aim_freetlvchain() should
+ * routines.  When done with a TLV chain, aim_tlvlist_free() should
  * be called to free the dynamic substructures.
  *
@@ -127 +191 @@
  * in libfaim.
  *
- */
-faim_internal aim_tlvlist_t *aim_readtlvchain_num(aim_bstream_t *bs, fu16_t num)
-{
-        aim_tlvlist_t *list = NULL, *cur;
-
-        while ((aim_bstream_empty(bs) > 0) && (num != 0)) {
-                fu16_t type, length;
-
-                type = aimbs_get16(bs);
-                length = aimbs_get16(bs);
-
-                if (length > aim_bstream_empty(bs)) {
-                        aim_freetlvchain(&list);
-                        return NULL;
-                }
-
-                cur = (aim_tlvlist_t *)malloc(sizeof(aim_tlvlist_t));
-                if (!cur) {
-                        aim_freetlvchain(&list);
-                        return NULL;
-                }
-
-                memset(cur, 0, sizeof(aim_tlvlist_t));
-
-                cur->tlv = createtlv();
-                if (!cur->tlv) {
-                        free(cur);
-                        aim_freetlvchain(&list);
-                        return NULL;
-                }
-                cur->tlv->type = type;
-                if ((cur->tlv->length = length)) {
-                       cur->tlv->value = aimbs_getraw(bs, length);
-                       if (!cur->tlv->value) {
-                               freetlv(&cur->tlv);
-                               free(cur);
-                               aim_freetlvchain(&list);
-                               return NULL;
-                       }
-                }
-
-                num--;
-                cur->next = list;
-                list = cur;
-        }
-
-        return list;
-}
-
-/**
- * aim_readtlvchain_len - Read a TLV chain from a buffer.
  * @param bs Input bstream
  * @param len The max length in bytes that will be read.
@@ -183 +196 @@
  *        but the chain is not at the end of the SNAC, and the chain is 
  *        preceeded by the length of the TLVs.  So you can limit that with this.
- *
- * Reads and parses a series of TLV patterns from a data buffer; the
- * returned structure is manipulatable with the rest of the TLV
- * routines.  When done with a TLV chain, aim_freetlvchain() should
- * be called to free the dynamic substructures.
- *
- * XXX There should be a flag setable here to have the tlvlist contain
- * bstream references, so that at least the ->value portion of each 
- * element doesn't need to be malloc/memcpy'd.  This could prove to be
- * just as effecient as the in-place TLV parsing used in a couple places
- * in libfaim.
- *
- */
-faim_internal aim_tlvlist_t *aim_readtlvchain_len(aim_bstream_t *bs, fu16_t len)
+ */
+faim_internal aim_tlvlist_t *aim_tlvlist_readlen(aim_bstream_t *bs, fu16_t len)
 {
         aim_tlvlist_t *list = NULL, *cur;
@@ -207 +208 @@
 
                 if (length > aim_bstream_empty(bs)) {
-                        aim_freetlvchain(&list);
+                        aim_tlvlist_free(&list);
                         return NULL;
                 }
@@ -213 +214 @@
                 cur = (aim_tlvlist_t *)malloc(sizeof(aim_tlvlist_t));
                 if (!cur) {
-                        aim_freetlvchain(&list);
+                        aim_tlvlist_free(&list);
                         return NULL;
                 }
@@ -219 +220 @@
                 memset(cur, 0, sizeof(aim_tlvlist_t));
 
-                cur->tlv = createtlv();
+                cur->tlv = createtlv(type, length, NULL);
                 if (!cur->tlv) {
                         free(cur);
-                        aim_freetlvchain(&list);
+                        aim_tlvlist_free(&list);
                         return NULL;
                 }
-                cur->tlv->type = type;
-                if ((cur->tlv->length = length)) {
-                       cur->tlv->value = aimbs_getraw(bs, length);
-                       if (!cur->tlv->value) {
-                               freetlv(&cur->tlv);
-                               free(cur);
-                               aim_freetlvchain(&list);
-                               return NULL;
-                       }
-                }
-
-                len -= aim_sizetlvchain(&cur);
+                if (cur->tlv->length > 0) {
+                        cur->tlv->value = aimbs_getraw(bs, length);
+                        if (!cur->tlv->value) {
+                                freetlv(&cur->tlv);
+                                free(cur);
+                                aim_tlvlist_free(&list);
+                                return NULL;
+                        }
+                }
+
+                len -= aim_tlvlist_size(&cur);
                 cur->next = list;
                 list = cur;
@@ -245 +245 @@
 
 /**
- * aim_tlvlist_copy - Duplicate a TLV chain.
- * @param orig
- *
+ * Duplicate a TLV chain.
  * This is pretty pelf exslanatory.
  *
+ * @param orig The TLV chain you want to make a copy of.
+ * @return A newly allocated TLV chain.
  */
 faim_internal aim_tlvlist_t *aim_tlvlist_copy(aim_tlvlist_t *orig)
@@ -256 +256 @@
 
         while (orig) {
-                aim_addtlvtochain_raw(&new, orig->tlv->type, orig->tlv->length, orig->tlv->value);
+                aim_tlvlist_add_raw(&new, orig->tlv->type, orig->tlv->length, orig->tlv->value);
                 orig = orig->next;
         }
@@ -275 +275 @@
         aim_bstream_t bs1, bs2;
 
-        if (aim_sizetlvchain(&one) != aim_sizetlvchain(&two))
+        if (aim_tlvlist_size(&one) != aim_tlvlist_size(&two))
                 return 1;
 
-        aim_bstream_init(&bs1, ((fu8_t *)malloc(aim_sizetlvchain(&one)*sizeof(fu8_t))), aim_sizetlvchain(&one));
-        aim_bstream_init(&bs2, ((fu8_t *)malloc(aim_sizetlvchain(&two)*sizeof(fu8_t))), aim_sizetlvchain(&two));
-
-        aim_writetlvchain(&bs1, &one);
-        aim_writetlvchain(&bs2, &two);
+        aim_bstream_init(&bs1, ((fu8_t *)malloc(aim_tlvlist_size(&one)*sizeof(fu8_t))), aim_tlvlist_size(&one));
+        aim_bstream_init(&bs2, ((fu8_t *)malloc(aim_tlvlist_size(&two)*sizeof(fu8_t))), aim_tlvlist_size(&two));
+
+        aim_tlvlist_write(&bs1, &one);
+        aim_tlvlist_write(&bs2, &two);
 
         if (memcmp(bs1.data, bs2.data, bs1.len)) {
@@ -297 +297 @@
 
 /**
- * aim_freetlvchain - Free a TLV chain structure
+ * Free a TLV chain structure
  * @list: Chain to be freed
  *
@@ -305 +305 @@
  *
  */
-faim_internal void aim_freetlvchain(aim_tlvlist_t **list)
+faim_internal void aim_tlvlist_free(aim_tlvlist_t **list)
 {
         aim_tlvlist_t *cur;
@@ -328 +328 @@
 
 /**
- * aim_counttlvchain - Count the number of TLVs in a chain
- * @list: Chain to be counted
- *
- * Returns the number of TLVs stored in the passed chain.
- *
- */
-faim_internal int aim_counttlvchain(aim_tlvlist_t **list)
+ * Count the number of TLVs in a chain.
+ *
+ * @param list Chain to be counted.
+ * @return The number of TLVs stored in the passed chain.
+ */
+faim_internal int aim_tlvlist_count(aim_tlvlist_t **list)
 {
         aim_tlvlist_t *cur;
@@ -349 +348 @@
 
 /**
- * aim_sizetlvchain - Count the number of bytes in a TLV chain
- * @list: Chain to be sized
- *
- * Returns the number of bytes that would be needed to 
- * write the passed TLV chain to a data buffer.
- *
- */
-faim_internal int aim_sizetlvchain(aim_tlvlist_t **list)
+ * Count the number of bytes in a TLV chain.
+ *
+ * @param list Chain to be sized
+ * @return The number of bytes that would be needed to 
+ *         write the passed TLV chain to a data buffer.
+ */
+faim_internal int aim_tlvlist_size(aim_tlvlist_t **list)
 {
         aim_tlvlist_t *cur;
@@ -371 +369 @@
 
 /**
- * aim_addtlvtochain_raw - Add a string to a TLV chain
- * @list: Desination chain (%NULL pointer if empty)
- * @t: TLV type
- * @l: Length of string to add (not including %NULL)
- * @v: String to add
- *
  * Adds the passed string as a TLV element of the passed type
  * to the TLV chain.
  *
- */
-faim_internal int aim_addtlvtochain_raw(aim_tlvlist_t **list, const fu16_t t, const fu16_t l, const fu8_t *v)
+ * @param list Desination chain (%NULL pointer if empty).
+ * @param type TLV type.
+ * @length Length of string to add (not including %NULL).
+ * @value String to add.
+ * @retun The size of the value added.
+ */
+faim_internal int aim_tlvlist_add_raw(aim_tlvlist_t **list, const fu16_t type, const fu16_t length, const fu8_t *value)
 {
         aim_tlvlist_t *newtlv, *cur;
 
-        if (!list)
+        if (list == NULL)
                 return 0;
 
@@ -392 +389 @@
         memset(newtlv, 0x00, sizeof(aim_tlvlist_t));
 
-        if (!(newtlv->tlv = createtlv())) {
+        if (!(newtlv->tlv = createtlv(type, length, NULL))) {
                 free(newtlv);
                 return 0;
         }
-        newtlv->tlv->type = t;
-        if ((newtlv->tlv->length = l)) {
+        if (newtlv->tlv->length > 0) {
                 newtlv->tlv->value = (fu8_t *)malloc(newtlv->tlv->length);
-                memcpy(newtlv->tlv->value, v, newtlv->tlv->length);
+                memcpy(newtlv->tlv->value, value, newtlv->tlv->length);
         }
 
@@ -414 +410 @@
 
 /**
- * aim_addtlvtochain8 - Add a 8bit integer to a TLV chain
- * @list: Destination chain
- * @type: TLV type to add
- * @val: Value to add
- *
- * Adds a one-byte unsigned integer to a TLV chain.
- *
- */
-faim_internal int aim_addtlvtochain8(aim_tlvlist_t **list, const fu16_t t, const fu8_t v)
+ * Add a one byte integer to a TLV chain.
+ *
+ * @param list Destination chain.
+ * @param type TLV type to add.
+ * @param value Value to add.
+ * @retun The size of the value added.
+ */
+faim_internal int aim_tlvlist_add_8(aim_tlvlist_t **list, const fu16_t type, const fu8_t value)
 {
         fu8_t v8[1];
 
-        aimutil_put8(v8, v);
-
-        return aim_addtlvtochain_raw(list, t, 1, v8);
-}
-
-/**
- * aim_addtlvtochain16 - Add a 16bit integer to a TLV chain
- * @list: Destination chain
- * @t: TLV type to add
- * @v: Value to add
- *
- * Adds a two-byte unsigned integer to a TLV chain.
- *
- */
-faim_internal int aim_addtlvtochain16(aim_tlvlist_t **list, const fu16_t t, const fu16_t v)
+        aimutil_put8(v8, value);
+
+        return aim_tlvlist_add_raw(list, type, 1, v8);
+}
+
+/**
+ * Add a two byte integer to a TLV chain.
+ *
+ * @param list Destination chain.
+ * @param type TLV type to add.
+ * @param value Value to add.
+ * @retun The size of the value added.
+ */
+faim_internal int aim_tlvlist_add_16(aim_tlvlist_t **list, const fu16_t type, const fu16_t value)
 {
         fu8_t v16[2];
 
-        aimutil_put16(v16, v);
-
-        return aim_addtlvtochain_raw(list, t, 2, v16);
-}
-
-/**
- * aim_addtlvtochain32 - Add a 32bit integer to a TLV chain
- * @list: Destination chain
- * @type: TLV type to add
- * @val: Value to add
- *
- * Adds a four-byte unsigned integer to a TLV chain.
- *
- */
-faim_internal int aim_addtlvtochain32(aim_tlvlist_t **list, const fu16_t t, const fu32_t v)
+        aimutil_put16(v16, value);
+
+        return aim_tlvlist_add_raw(list, type, 2, v16);
+}
+
+/**
+ * Add a four byte integer to a TLV chain.
+ *
+ * @param list Destination chain.
+ * @param type TLV type to add.
+ * @param value Value to add.
+ * @retun The size of the value added.
+ */
+faim_internal int aim_tlvlist_add_32(aim_tlvlist_t **list, const fu16_t type, const fu32_t value)
 {
         fu8_t v32[4];
 
-        aimutil_put32(v32, v);
-
-        return aim_addtlvtochain_raw(list, t, 4, v32);
-}
-
-/**
- * aim_addtlvtochain_caps - Add a capability block to a TLV chain
- * @list: Destination chain
- * @type: TLV type to add
- * @caps: Bitfield of capability flags to send
- *
+        aimutil_put32(v32, value);
+
+        return aim_tlvlist_add_raw(list, type, 4, v32);
+}
+
+/**
  * Adds a block of capability blocks to a TLV chain. The bitfield
  * passed in should be a bitwise %OR of any of the %AIM_CAPS constants:
  *
- *      %AIM_CAPS_BUDDYICON   Supports Buddy Icons
- *
- *      %AIM_CAPS_VOICE       Supports Voice Chat
- *
- *      %AIM_CAPS_IMIMAGE     Supports DirectIM/IMImage
- *
- *      %AIM_CAPS_CHAT        Supports Chat
- *
- *      %AIM_CAPS_GETFILE     Supports Get File functions
- *
- *      %AIM_CAPS_SENDFILE    Supports Send File functions
- *
- */
-faim_internal int aim_addtlvtochain_caps(aim_tlvlist_t **list, const fu16_t t, const fu32_t caps)
+ *     %AIM_CAPS_BUDDYICON   Supports Buddy Icons
+ *     %AIM_CAPS_VOICE       Supports Voice Chat
+ *     %AIM_CAPS_IMIMAGE     Supports DirectIM/IMImage
+ *     %AIM_CAPS_CHAT        Supports Chat
+ *     %AIM_CAPS_GETFILE     Supports Get File functions
+ *     %AIM_CAPS_SENDFILE    Supports Send File functions
+ *
+ * @param list Destination chain
+ * @param type TLV type to add
+ * @param caps Bitfield of capability flags to send
+ * @retun The size of the value added.
+ */
+faim_internal int aim_tlvlist_add_caps(aim_tlvlist_t **list, const fu16_t type, const fu32_t caps)
 {
         fu8_t buf[16*16]; /* XXX icky fixed length buffer */
@@ -501 +488 @@
         aim_putcap(&bs, caps);
 
-        return aim_addtlvtochain_raw(list, t, aim_bstream_curpos(&bs), buf);
-}
-
-faim_internal int aim_addtlvtochain_userinfo(aim_tlvlist_t **list, fu16_t type, aim_userinfo_t *ui)
+        return aim_tlvlist_add_raw(list, type, aim_bstream_curpos(&bs), buf);
+}
+
+/**
+ * Adds the given userinfo struct to a TLV chain.
+ *
+ * @param list Destination chain.
+ * @param type TLV type to add.
+ * @retun The size of the value added.
+ */
+faim_internal int aim_tlvlist_add_userinfo(aim_tlvlist_t **list, fu16_t type, aim_userinfo_t *userinfo)
 {
         fu8_t buf[1024]; /* bleh */
@@ -511 +505 @@
         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
- * @type: TLV type to add
- *
+        aim_putuserinfo(&bs, userinfo);
+
+        return aim_tlvlist_add_raw(list, type, aim_bstream_curpos(&bs), buf);
+}
+
+/**
  * Adds a TLV with a zero length to a TLV chain.
  *
- */
-faim_internal int aim_addtlvtochain_noval(aim_tlvlist_t **list, const fu16_t t)
-{
-        return aim_addtlvtochain_raw(list, t, 0, NULL);
+ * @param list Destination chain.
+ * @param type TLV type to add.
+ * @retun The size of the value added.
+ */
+faim_internal int aim_tlvlist_add_noval(aim_tlvlist_t **list, const fu16_t type)
+{
+        return aim_tlvlist_add_raw(list, type, 0, NULL);
 }
 
@@ -539 +532 @@
  *
  */
-faim_internal int aim_addtlvtochain_frozentlvlist(aim_tlvlist_t **list, fu16_t type, aim_tlvlist_t **tl)
+faim_internal int aim_tlvlist_add_frozentlvlist(aim_tlvlist_t **list, fu16_t type, aim_tlvlist_t **tl)
 {
         fu8_t *buf;
@@ -545 +538 @@
         aim_bstream_t bs;
 
-        buflen = aim_sizetlvchain(tl);
+        buflen = aim_tlvlist_size(tl);
 
         if (buflen <= 0)
@@ -555 +548 @@
         aim_bstream_init(&bs, buf, buflen);
 
-        aim_writetlvchain(&bs, tl);
-
-        aim_addtlvtochain_raw(list, type, aim_bstream_curpos(&bs), buf);
+        aim_tlvlist_write(&bs, tl);
+
+        aim_tlvlist_add_raw(list, type, aim_bstream_curpos(&bs), buf);
 
         free(buf);
@@ -565 +558 @@
 
 /**
- * aim_writetlvchain - Write a TLV chain into a data buffer.
+ * Substitute a TLV of a given type with a new TLV of the same type.  If 
+ * you attempt to replace a TLV that does not exist, this function will 
+ * just add a new TLV as if you called aim_tlvlist_add_raw().
+ *
+ * @param list Desination chain (%NULL pointer if empty).
+ * @param type TLV type.
+ * @param length Length of string to add (not including %NULL).
+ * @param value String to add.
+ * @return The length of the TLV.
+ */
+faim_internal int aim_tlvlist_replace_raw(aim_tlvlist_t **list, const fu16_t type, const fu16_t length, const fu8_t *value)
+{
+        aim_tlvlist_t *cur;
+
+        if (list == NULL)
+                return 0;
+
+        for (cur = *list; ((cur != NULL) && (cur->tlv->type != type)); cur = cur->next);
+        if (cur == NULL)
+                return aim_tlvlist_add_raw(list, type, length, value);
+
+        free(cur->tlv->value);
+        cur->tlv->length = length;
+        if (cur->tlv->length > 0) {
+                cur->tlv->value = (fu8_t *)malloc(cur->tlv->length);
+                memcpy(cur->tlv->value, value, cur->tlv->length);
+        } else
+                cur->tlv->value = NULL;
+
+        return cur->tlv->length;
+}
+
+/**
+ * Substitute a TLV of a given type with a new TLV of the same type.  If 
+ * you attempt to replace a TLV that does not exist, this function will 
+ * just add a new TLV as if you called aim_tlvlist_add_raw().
+ *
+ * @param list Desination chain (%NULL pointer if empty).
+ * @param type TLV type.
+ * @return The length of the TLV.
+ */
+faim_internal int aim_tlvlist_replace_noval(aim_tlvlist_t **list, const fu16_t type)
+{
+        return aim_tlvlist_replace_raw(list, type, 0, NULL);
+}
+
+/**
+ * Substitute a TLV of a given type with a new TLV of the same type.  If 
+ * you attempt to replace a TLV that does not exist, this function will 
+ * just add a new TLV as if you called aim_tlvlist_add_raw().
+ *
+ * @param list Desination chain (%NULL pointer if empty).
+ * @param type TLV type.
+ * @param value 8 bit value to add.
+ * @return The length of the TLV.
+ */
+faim_internal int aim_tlvlist_replace_8(aim_tlvlist_t **list, const fu16_t type, const fu8_t value)
+{
+        fu8_t v8[1];
+
+        aimutil_put8(v8, value);
+
+        return aim_tlvlist_replace_raw(list, type, 1, v8);
+}
+
+/**
+ * Substitute a TLV of a given type with a new TLV of the same type.  If 
+ * you attempt to replace a TLV that does not exist, this function will 
+ * just add a new TLV as if you called aim_tlvlist_add_raw().
+ *
+ * @param list Desination chain (%NULL pointer if empty).
+ * @param type TLV type.
+ * @param value 32 bit value to add.
+ * @return The length of the TLV.
+ */
+faim_internal int aim_tlvlist_replace_32(aim_tlvlist_t **list, const fu16_t type, const fu32_t value)
+{
+        fu8_t v32[4];
+
+        aimutil_put32(v32, value);
+
+        return aim_tlvlist_replace_raw(list, type, 4, v32);
+}
+
+/**
+ * Remove a TLV of a given type.  If you attempt to remove a TLV that 
+ * does not exist, nothing happens.
+ *
+ * @param list Desination chain (%NULL pointer if empty).
+ * @param type TLV type.
+ */
+faim_internal void aim_tlvlist_remove(aim_tlvlist_t **list, const fu16_t type)
+{
+        aim_tlvlist_t *del;
+
+        if (!list || !(*list))
+                return;
+
+        /* Remove the item from the list */
+        if ((*list)->tlv->type == type) {
+                del = *list;
+                *list = (*list)->next;
+        } else {
+                aim_tlvlist_t *cur;
+                for (cur=*list; (cur->next && (cur->next->tlv->type!=type)); cur=cur->next);
+                if (!cur->next)
+                        return;
+                del = cur->next;
+                cur->next = del->next;
+        }
+
+        /* Free the removed item */
+        free(del->tlv->value);
+        free(del->tlv);
+        free(del);
+}
+
+/**
+ * aim_tlvlist_write - Write a TLV chain into a data buffer.
  * @buf: Destination buffer
  * @buflen: Maximum number of bytes that will be written to buffer
@@ -572 +683 @@
  * Copies a TLV chain into a raw data buffer, writing only the number
  * of bytes specified. This operation does not free the chain; 
- * aim_freetlvchain() must still be called to free up the memory used
+ * aim_tlvlist_free() must still be called to free up the memory used
  * by the chain structures.
  *
  * XXX clean this up, make better use of bstreams 
  */
-faim_internal int aim_writetlvchain(aim_bstream_t *bs, aim_tlvlist_t **list)
+faim_internal int aim_tlvlist_write(aim_bstream_t *bs, aim_tlvlist_t **list)
 {
         int goodbuflen;
@@ -583 +694 @@
 
         /* do an initial run to test total length */
-        goodbuflen = aim_sizetlvchain(list);
+        goodbuflen = aim_tlvlist_size(list);
 
         if (goodbuflen > aim_bstream_empty(bs))
@@ -601 +712 @@
 
 /**
- * aim_gettlv - Grab the Nth TLV of type type in the TLV list list.
- * @list: Source chain
- * @type: Requested TLV type
- * @nth: Index of TLV of type to get
+ * Grab the Nth TLV of type type in the TLV list list.
  *
  * Returns a pointer to an aim_tlv_t of the specified type; 
@@ -611 +719 @@
  * in a chain.
  *
- */
-faim_internal aim_tlv_t *aim_gettlv(aim_tlvlist_t *list, const fu16_t t, const int n)
+ * @param list Source chain.
+ * @param type Requested TLV type.
+ * @param nth Index of TLV of type to get.
+ * @return The TLV you were looking for, or NULL if one could not be found.
+ */
+faim_internal aim_tlv_t *aim_tlv_gettlv(aim_tlvlist_t *list, const fu16_t type, const int nth)
 {
         aim_tlvlist_t *cur;
@@ -619 +731 @@
         for (cur = list, i = 0; cur; cur = cur->next) {
                 if (cur && cur->tlv) {
-                        if (cur->tlv->type == t)
+                        if (cur->tlv->type == type)
                                 i++;
-                        if (i >= n)
+                        if (i >= nth)
                                 return cur->tlv;
                 }
@@ -630 +742 @@
 
 /**
- * aim_gettlv_str - Retrieve the Nth TLV in chain as a string.
- * @list: Source TLV chain
- * @type: TLV type to search for
- * @nth: Index of TLV to return
- *
- * Same as aim_gettlv(), except that the return value is a %NULL-
- * terminated string instead of an aim_tlv_t.  This is a 
- * dynamic buffer and must be freed by the caller.
- *
- */
-faim_internal char *aim_gettlv_str(aim_tlvlist_t *list, const fu16_t t, const int n)
+ * Retrieve the data from the nth TLV in the given TLV chain as a string.
+ *
+ * @param list Source TLV chain.
+ * @param type TLV type to search for.
+ * @param nth Index of TLV to return.
+ * @return The value of the TLV you were looking for, or NULL if one could 
+ *         not be found.  This is a dynamic buffer and must be freed by the 
+ *         caller.
+ */
+faim_internal char *aim_tlv_getstr(aim_tlvlist_t *list, const fu16_t type, const int nth)
 {
         aim_tlv_t *tlv;
         char *newstr;
 
-        if (!(tlv = aim_gettlv(list, t, n)))
+        if (!(tlv = aim_tlv_gettlv(list, type, nth)))
                 return NULL;
 
         newstr = (char *) malloc(tlv->length + 1);
         memcpy(newstr, tlv->value, tlv->length);
-        *(newstr + tlv->length) = '\0';
+        newstr[tlv->length] = '\0';
 
         return newstr;
@@ -656 +767 @@
 
 /**
- * aim_gettlv8 - Retrieve the Nth TLV in chain as a 8bit integer.
- * @list: Source TLV chain
- * @type: TLV type to search for
- * @nth: Index of TLV to return
- *
- * Same as aim_gettlv(), except that the return value is a 
- * 8bit integer instead of an aim_tlv_t. 
- *
- */
-faim_internal fu8_t aim_gettlv8(aim_tlvlist_t *list, const fu16_t t, const int n)
+ * Retrieve the data from the nth TLV in the given TLV chain as an 8bit 
+ * integer.
+ *
+ * @param list Source TLV chain.
+ * @param type TLV type to search for.
+ * @param nth Index of TLV to return.
+ * @return The value the TLV you were looking for, or 0 if one could 
+ *         not be found.
+ */
+faim_internal fu8_t aim_tlv_get8(aim_tlvlist_t *list, const fu16_t type, const int nth)
 {
         aim_tlv_t *tlv;
 
-        if (!(tlv = aim_gettlv(list, t, n)))
+        if (!(tlv = aim_tlv_gettlv(list, type, nth)))
                 return 0; /* erm */
         return aimutil_get8(tlv->value);
@@ -675 +786 @@
 
 /**
- * aim_gettlv16 - Retrieve the Nth TLV in chain as a 16bit integer.
- * @list: Source TLV chain
- * @type: TLV type to search for
- * @nth: Index of TLV to return
- *
- * Same as aim_gettlv(), except that the return value is a 
- * 16bit integer instead of an aim_tlv_t. 
- *
- */
-faim_internal fu16_t aim_gettlv16(aim_tlvlist_t *list, const fu16_t t, const int n)
+ * Retrieve the data from the nth TLV in the given TLV chain as a 16bit 
+ * integer.
+ *
+ * @param list Source TLV chain.
+ * @param type TLV type to search for.
+ * @param nth Index of TLV to return.
+ * @return The value the TLV you were looking for, or 0 if one could 
+ *         not be found.
+ */
+faim_internal fu16_t aim_tlv_get16(aim_tlvlist_t *list, const fu16_t type, const int nth)
 {
         aim_tlv_t *tlv;
 
-        if (!(tlv = aim_gettlv(list, t, n)))
+        if (!(tlv = aim_tlv_gettlv(list, type, nth)))
                 return 0; /* erm */
         return aimutil_get16(tlv->value);
@@ -694 +805 @@
 
 /**
- * aim_gettlv32 - Retrieve the Nth TLV in chain as a 32bit integer.
- * @list: Source TLV chain
- * @type: TLV type to search for
- * @nth: Index of TLV to return
- *
- * Same as aim_gettlv(), except that the return value is a 
- * 32bit integer instead of an aim_tlv_t. 
- *
- */
-faim_internal fu32_t aim_gettlv32(aim_tlvlist_t *list, const fu16_t t, const int n)
+ * Retrieve the data from the nth TLV in the given TLV chain as a 32bit 
+ * integer.
+ *
+ * @param list Source TLV chain.
+ * @param type TLV type to search for.
+ * @param nth Index of TLV to return.
+ * @return The value the TLV you were looking for, or 0 if one could 
+ *         not be found.
+ */
+faim_internal fu32_t aim_tlv_get32(aim_tlvlist_t *list, const fu16_t type, const int nth)
 {
         aim_tlv_t *tlv;
 
-        if (!(tlv = aim_gettlv(list, t, n)))
+        if (!(tlv = aim_tlv_gettlv(list, type, nth)))
                 return 0; /* erm */
         return aimutil_get32(tlv->value);
 }
-
-#if 0
-/**
- * aim_puttlv_8 - Write a one-byte TLV.
- * @buf: Destination buffer
- * @t: TLV type
- * @v: Value
- *
- * Writes a TLV with a one-byte integer value portion.
- *
- */
-faim_export int aim_puttlv_8(fu8_t *buf, const fu16_t t, const fu8_t v)
-{
-        fu8_t v8[1];
-
-        aimutil_put8(v8, v);
-
-        return aim_puttlv_raw(buf, t, 1, v8);
-}
-
-/**
- * aim_puttlv_16 - Write a two-byte TLV.
- * @buf: Destination buffer
- * @t: TLV type
- * @v: Value
- *
- * Writes a TLV with a two-byte integer value portion.
- *
- */
-faim_export int aim_puttlv_16(fu8_t *buf, const fu16_t t, const fu16_t v)
-{
-        fu8_t v16[2];
-
-        aimutil_put16(v16, v);
-
-        return aim_puttlv_raw(buf, t, 2, v16);
-}
-
-
-/**
- * aim_puttlv_32 - Write a four-byte TLV.
- * @buf: Destination buffer
- * @t: TLV type
- * @v: Value
- *
- * Writes a TLV with a four-byte integer value portion.
- *
- */
-faim_export int aim_puttlv_32(fu8_t *buf, const fu16_t t, const fu32_t v)
-{
-        fu8_t v32[4];
-
-        aimutil_put32(v32, v);
-
-        return aim_puttlv_raw(buf, t, 4, v32);
-}
-
-/**
- * aim_puttlv_raw - Write a raw TLV.
- * @buf: Destination buffer
- * @t: TLV type
- * @l: Length of string
- * @v: String to write
- *
- * Writes a TLV with a raw value portion.  (Only the first @l
- * bytes of the passed buffer will be written, which should not
- * include a terminating NULL.)
- *
- */
-faim_export int aim_puttlv_raw(fu8_t *buf, const fu16_t t, const fu16_t l, const fu8_t *v)
-{
-        int i;
-
-        i = aimutil_put16(buf, t);
-        i += aimutil_put16(buf+i, l);
-        if (l)
-                memcpy(buf+i, v, l);
-        i += l;
-
-        return i;
-}
-#endif

libfaim/txqueue.c

@@ -29 +29 @@
 faim_internal aim_frame_t *aim_tx_new(aim_session_t *sess, aim_conn_t *conn, fu8_t framing, fu16_t chan, int datalen)
 {
-  aim_frame_t *fr;
-  
-  if (!conn) {
-    faimdprintf(sess, 0, "aim_tx_new: ERROR: no connection specified\n");
-    return NULL;
-  }
-  
-  /* For sanity... */
-  if ((conn->type == AIM_CONN_TYPE_RENDEZVOUS) || (conn->type == AIM_CONN_TYPE_LISTENER)) {
-    if (framing != AIM_FRAMETYPE_OFT) {
-      faimdprintf(sess, 0, "aim_tx_new: attempted to allocate inappropriate frame type for rendezvous connection\n");
-      return NULL;
-    }
-  } else {
-    if (framing != AIM_FRAMETYPE_FLAP) {
-      faimdprintf(sess, 0, "aim_tx_new: attempted to allocate inappropriate frame type for FLAP connection\n");
-      return NULL;
-    }
-  }
-  
-  if (!(fr = (aim_frame_t *)malloc(sizeof(aim_frame_t)))) return NULL;
-  memset(fr, 0, sizeof(aim_frame_t));
-  
-  fr->conn = conn; 
-  fr->hdrtype = framing;
-  if (fr->hdrtype == AIM_FRAMETYPE_FLAP) {
-    fr->hdr.flap.type = chan;
-  } else if (fr->hdrtype == AIM_FRAMETYPE_OFT) {
-    fr->hdr.rend.type = chan;
-  } else {
-    faimdprintf(sess, 0, "tx_new: unknown framing\n");
-  }
-  
-  if (datalen > 0) {
-    fu8_t *data;
-    if (!(data = (unsigned char *)malloc(datalen))) {
-      aim_frame_destroy(fr);
-      return NULL;
-    }
-    aim_bstream_init(&fr->data, data, datalen);
-  }
-  
-  return fr;
+        aim_frame_t *fr;
+
+        if (!conn) {
+                faimdprintf(sess, 0, "aim_tx_new: ERROR: no connection specified\n");
+                return NULL;
+        }
+
+        /* For sanity... */
+        if ((conn->type == AIM_CONN_TYPE_RENDEZVOUS) || (conn->type == AIM_CONN_TYPE_LISTENER)) {
+                if (framing != AIM_FRAMETYPE_OFT) {
+                        faimdprintf(sess, 0, "aim_tx_new: attempted to allocate inappropriate frame type for rendezvous connection\n");
+                        return NULL;
+                }
+        } else {
+                if (framing != AIM_FRAMETYPE_FLAP) {
+                        faimdprintf(sess, 0, "aim_tx_new: attempted to allocate inappropriate frame type for FLAP connection\n");
+                        return NULL;
+                }
+        }
+
+        if (!(fr = (aim_frame_t *)malloc(sizeof(aim_frame_t))))
+                return NULL;
+        memset(fr, 0, sizeof(aim_frame_t));
+
+        fr->conn = conn; 
+
+        fr->hdrtype = framing;
+
+        if (fr->hdrtype == AIM_FRAMETYPE_FLAP) {
+
+                fr->hdr.flap.type = chan;
+
+        } else if (fr->hdrtype == AIM_FRAMETYPE_OFT) {
+
+                fr->hdr.rend.type = chan;
+
+        } else 
+                faimdprintf(sess, 0, "tx_new: unknown framing\n");
+
+        if (datalen > 0) {
+                fu8_t *data;
+
+                if (!(data = (unsigned char *)malloc(datalen))) {
+                        aim_frame_destroy(fr);
+                        return NULL;
+                }
+
+                aim_bstream_init(&fr->data, data, datalen);
+        }
+
+        return fr;
 }
 
@@ -90 +98 @@
 static int aim_tx_enqueue__queuebased(aim_session_t *sess, aim_frame_t *fr)
 {
-  
-  if (!fr->conn) {
-    faimdprintf(sess, 1, "aim_tx_enqueue: WARNING: enqueueing packet with no connecetion\n");
-    fr->conn = aim_getconn_type(sess, AIM_CONN_TYPE_BOS);
-  }
-  
-  if (fr->hdrtype == AIM_FRAMETYPE_FLAP) {
-    /* assign seqnum -- XXX should really not assign until hardxmit */
-    fr->hdr.flap.seqnum = aim_get_next_txseqnum(fr->conn);
-  }
-  
-  fr->handled = 0; /* not sent yet */
-  
-  /* see overhead note in aim_rxqueue counterpart */
-  if (!sess->queue_outgoing)
-    sess->queue_outgoing = fr;
-  else {
-    aim_frame_t *cur;
-    
-    for (cur = sess->queue_outgoing; cur->next; cur = cur->next)
-      ;
-    cur->next = fr;
-  }
-  
-  return 0;
+
+        if (!fr->conn) {
+                faimdprintf(sess, 1, "aim_tx_enqueue: WARNING: enqueueing packet with no connecetion\n");
+                fr->conn = aim_getconn_type(sess, AIM_CONN_TYPE_BOS);
+        }
+
+        if (fr->hdrtype == AIM_FRAMETYPE_FLAP) {
+                /* assign seqnum -- XXX should really not assign until hardxmit */
+                fr->hdr.flap.seqnum = aim_get_next_txseqnum(fr->conn);
+        }
+
+        fr->handled = 0; /* not sent yet */
+
+        /* see overhead note in aim_rxqueue counterpart */
+        if (!sess->queue_outgoing)
+                sess->queue_outgoing = fr;
+        else {
+                aim_frame_t *cur;
+
+                for (cur = sess->queue_outgoing; cur->next; cur = cur->next)
+                        ;
+                cur->next = fr;
+        }
+
+        return 0;
 }
 
@@ -131 +139 @@
 {
 
-  if (!fr->conn) {
-    faimdprintf(sess, 1, "aim_tx_enqueue: ERROR: packet has no connection\n");
-    aim_frame_destroy(fr);
-    return 0;
-  }
-  
-  if (fr->hdrtype == AIM_FRAMETYPE_FLAP) fr->hdr.flap.seqnum = aim_get_next_txseqnum(fr->conn);
-  fr->handled = 0; /* not sent yet */
-  aim_tx_sendframe(sess, fr);
-  aim_frame_destroy(fr);
-  
-  return 0;
+        if (!fr->conn) {
+                faimdprintf(sess, 1, "aim_tx_enqueue: ERROR: packet has no connection\n");
+                aim_frame_destroy(fr);
+                return 0;
+        }
+
+        if (fr->hdrtype == AIM_FRAMETYPE_FLAP)
+                fr->hdr.flap.seqnum = aim_get_next_txseqnum(fr->conn);
+
+        fr->handled = 0; /* not sent yet */
+
+        aim_tx_sendframe(sess, fr);
+
+        aim_frame_destroy(fr);
+
+        return 0;
 }
 
 faim_export int aim_tx_setenqueue(aim_session_t *sess, int what, int (*func)(aim_session_t *, aim_frame_t *))
 {
-  if (what == AIM_TX_QUEUED) {
-    sess->tx_enqueue = &aim_tx_enqueue__queuebased;
-  } else if (what == AIM_TX_IMMEDIATE) {
-    sess->tx_enqueue = &aim_tx_enqueue__immediate;
-  } else if (what == AIM_TX_USER) {
-    if (!func) return -EINVAL;
-    sess->tx_enqueue = func;
-  } else {
-    return -EINVAL; /* unknown action */
-  }
-  
-  return 0;
+        
+        if (what == AIM_TX_QUEUED)
+                sess->tx_enqueue = &aim_tx_enqueue__queuebased;
+        else if (what == AIM_TX_IMMEDIATE) 
+                sess->tx_enqueue = &aim_tx_enqueue__immediate;
+        else if (what == AIM_TX_USER) {
+                if (!func)
+                        return -EINVAL;
+                sess->tx_enqueue = func;
+        } else
+                return -EINVAL; /* unknown action */
+
+        return 0;
 }
 
 faim_internal int aim_tx_enqueue(aim_session_t *sess, aim_frame_t *fr)
 {
-  
-  /*
-   * If we want to send a connection thats inprogress, we have to force
-   * them to use the queue based version. Otherwise, use whatever they
-   * want.
-   */
-  if (fr && fr->conn && 
-      (fr->conn->status & AIM_CONN_STATUS_INPROGRESS)) {
-    return aim_tx_enqueue__queuebased(sess, fr);
-  }
-  
-  return (*sess->tx_enqueue)(sess, fr);
+        
+        /*
+         * If we want to send a connection thats inprogress, we have to force
+         * them to use the queue based version. Otherwise, use whatever they
+         * want.
+         */
+        if (fr && fr->conn && 
+                        (fr->conn->status & AIM_CONN_STATUS_INPROGRESS)) {
+                return aim_tx_enqueue__queuebased(sess, fr);
+        }
+
+        return (*sess->tx_enqueue)(sess, fr);
 }
 
@@ -188 +201 @@
 faim_internal flap_seqnum_t aim_get_next_txseqnum(aim_conn_t *conn)
 {
-  flap_seqnum_t ret;
-  ret = ++conn->seqnum;
-  return ret;
+        flap_seqnum_t ret;
+        
+        ret = ++conn->seqnum;
+
+        return ret;
 }
 
 static int aim_send(int fd, const void *buf, size_t count)
 {
-  int left, cur;
-  
-  for (cur = 0, left = count; left; ) {
-    int ret;
-    
-    ret = send(fd, ((unsigned char *)buf)+cur, left, 0);
-    if (ret == -1) {
-      return -1;
-    } else if (ret == 0) {
-      return cur;
-    }
-    
-    cur += ret;
-    left -= ret;
-  }
-  
-  return cur;
+        int left, cur;
+
+        for (cur = 0, left = count; left; ) {
+                int ret;
+
+                ret = send(fd, ((unsigned char *)buf)+cur, left, 0);
+                if (ret == -1)
+                        return -1;
+                else if (ret == 0)
+                        return cur;
+
+                cur += ret;
+                left -= ret;
+        }
+
+        return cur;
 }
 
 static int aim_bstream_send(aim_bstream_t *bs, aim_conn_t *conn, size_t count)
 {
-  int wrote = 0;
-  int rv = 0;
-  if (!bs || !conn || (count < 0))
-    return -EINVAL;
-  
-  if (count > aim_bstream_empty(bs))
-    count = aim_bstream_empty(bs); /* truncate to remaining space */
-  
-  if (count) {
-    if ((conn->type == AIM_CONN_TYPE_RENDEZVOUS) && 
-        (conn->subtype == AIM_CONN_SUBTYPE_OFT_DIRECTIM)) {
-      /* I strongly suspect that this is a horrible thing to do
-       * and I feel really guilty doing it. */
-      const char *sn = aim_odc_getsn(conn);
-      aim_rxcallback_t userfunc;
-      while (count - wrote > 1024) {
-        rv = aim_send(conn->fd, bs->data + bs->offset + wrote, 1024);
-        if (rv < 0) {
-          fprintf(stderr, "aim_bstream_send: aim_send failed...\n");
-          return -EINVAL;
-        }
-        wrote = wrote + rv;
-          
-        if ((userfunc=aim_callhandler(conn->sessv, conn, 
-                                      AIM_CB_FAM_SPECIAL, 
-                                      AIM_CB_SPECIAL_IMAGETRANSFER)))
-          userfunc(conn->sessv, NULL, sn, 
-                   count-wrote>1024 ? ((double)wrote / count) : 1);
-      }
-    }
-    if (count - wrote) {
-      rv = aim_send(conn->fd, bs->data + bs->offset + wrote, count - wrote);
-      if (rv < 0) {
-        fprintf(stderr, "aim_bstream_send: aim_send failed...\n");
-        return -EINVAL;
-      }
-      wrote = wrote + rv;
-    }
-    
-  }
-  
-  if (((aim_session_t *)conn->sessv)->debug >= 2) {
-    int i;
-    aim_session_t *sess = (aim_session_t *)conn->sessv;
-    
-    faimdprintf(sess, 2, "\nOutgoing data: (%d bytes)", wrote);
-    for (i = 0; i < wrote; i++) {
-      if (!(i % 8)) 
-        faimdprintf(sess, 2, "\n\t");
-      faimdprintf(sess, 2, "0x%02x ", *(bs->data + bs->offset + i));
-    }
-    faimdprintf(sess, 2, "\n");
-  }
-  
-  bs->offset += wrote;
-  
-  return wrote;
+        int wrote = 0;
+        if (!bs || !conn || (count < 0))
+                return -EINVAL;
+
+        if (count > aim_bstream_empty(bs))
+                count = aim_bstream_empty(bs); /* truncate to remaining space */
+
+        if (count) {
+                if ((conn->type == AIM_CONN_TYPE_RENDEZVOUS) && 
+                    (conn->subtype == AIM_CONN_SUBTYPE_OFT_DIRECTIM)) {
+                        /* I strongly suspect that this is a horrible thing to do
+                         * and I feel really guilty doing it. */
+                        const char *sn = aim_odc_getsn(conn);
+                        aim_rxcallback_t userfunc;
+                        while (count - wrote > 1024) {
+                                wrote = wrote + aim_send(conn->fd, bs->data + bs->offset + wrote, 1024);
+                                if ((userfunc=aim_callhandler(conn->sessv, conn, 
+                                                                AIM_CB_FAM_SPECIAL, 
+                                                                AIM_CB_SPECIAL_IMAGETRANSFER)))
+                                  userfunc(conn->sessv, NULL, sn, 
+                                           count-wrote>1024 ? ((double)wrote / count) : 1);
+                        }
+                }
+                if (count - wrote) {
+                        wrote = wrote + aim_send(conn->fd, bs->data + bs->offset + wrote, count - wrote);
+                }
+
+        }
+
+        if (((aim_session_t *)conn->sessv)->debug >= 2) {
+                int i;
+                aim_session_t *sess = (aim_session_t *)conn->sessv;
+
+                faimdprintf(sess, 2, "\nOutgoing data: (%d bytes)", wrote);
+                for (i = 0; i < wrote; i++) {
+                        if (!(i % 8)) 
+                                faimdprintf(sess, 2, "\n\t");
+                        faimdprintf(sess, 2, "0x%02x ", *(bs->data + bs->offset + i));
+                }
+                faimdprintf(sess, 2, "\n");
+        }
+
+        bs->offset += wrote;
+
+        return wrote;
 }
 
 static int sendframe_flap(aim_session_t *sess, aim_frame_t *fr)
 {
-  aim_bstream_t obs;
-  fu8_t *obs_raw;
-  int payloadlen, err = 0, obslen;
-  
-  payloadlen = aim_bstream_curpos(&fr->data);
-  
-  if (!(obs_raw = malloc(6 + payloadlen)))
-    return -ENOMEM;
-  
-  aim_bstream_init(&obs, obs_raw, 6 + payloadlen);
-  
-  /* FLAP header */
-  aimbs_put8(&obs, 0x2a);
-  aimbs_put8(&obs, fr->hdr.flap.type);
-  aimbs_put16(&obs, fr->hdr.flap.seqnum);
-  aimbs_put16(&obs, payloadlen);
-  
-  /* payload */
-  aim_bstream_rewind(&fr->data);
-  aimbs_putbs(&obs, &fr->data, payloadlen);
-  
-  obslen = aim_bstream_curpos(&obs);
-  aim_bstream_rewind(&obs);
-  if (aim_bstream_send(&obs, fr->conn, obslen) != obslen)
-    err = -errno;
-  
-  free(obs_raw); /* XXX aim_bstream_free */
-  
-  fr->handled = 1;
-  fr->conn->lastactivity = time(NULL);
-  
-  return err;
+        aim_bstream_t obs;
+        fu8_t *obs_raw;
+        int payloadlen, err = 0, obslen;
+
+        payloadlen = aim_bstream_curpos(&fr->data);
+
+        if (!(obs_raw = malloc(6 + payloadlen)))
+                return -ENOMEM;
+
+        aim_bstream_init(&obs, obs_raw, 6 + payloadlen);
+
+        /* FLAP header */
+        aimbs_put8(&obs, 0x2a);
+        aimbs_put8(&obs, fr->hdr.flap.type);
+        aimbs_put16(&obs, fr->hdr.flap.seqnum);
+        aimbs_put16(&obs, payloadlen);
+
+        /* payload */
+        aim_bstream_rewind(&fr->data);
+        aimbs_putbs(&obs, &fr->data, payloadlen);
+
+        obslen = aim_bstream_curpos(&obs);
+        aim_bstream_rewind(&obs);
+        if (aim_bstream_send(&obs, fr->conn, obslen) != obslen)
+                err = -errno;
+        
+        free(obs_raw); /* XXX aim_bstream_free */
+
+        fr->handled = 1;
+        fr->conn->lastactivity = time(NULL);
+
+        return err;
 }