/*

 * Purple's oscar protocol plugin

 * This file is the legal property of its developers.

 * Please see the AUTHORS file distributed alongside this file.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

*/

/*

 * Main libfaim header.  Must be included in client for prototypes/macros.

 *

 * "come on, i turned a chick lesbian; i think this is the hackish equivalent"

 *                                                -- Josh Myer

 *

 */

#ifndef _OSCAR_H_

#define _OSCAR_H_

#include "circbuffer.h"

#include "debug.h"

#include "eventloop.h"

#include "internal.h"

#include "proxy.h"

#include "sslconn.h"

#include <stdio.h>

#include <string.h>

#include <fcntl.h>

#include <sys/types.h>

#include <stdlib.h>

#include <stdarg.h>

#include <errno.h>

#include <time.h>

#ifndef _WIN32

#include <sys/time.h>

#include <unistd.h>

#include <netdb.h>

#include <netinet/in.h>

#include <sys/socket.h>

#else

#include "libc_interface.h"

#endif

typedef struct _ByteStream         ByteStream;

typedef struct _ClientInfo         ClientInfo;

typedef struct _FlapConnection     FlapConnection;

typedef struct _FlapFrame          FlapFrame;

typedef struct _IcbmArgsCh2        IcbmArgsCh2;

typedef struct _IcbmCookie         IcbmCookie;

typedef struct _OscarData          OscarData;

typedef struct _QueuedSnac         QueuedSnac;

typedef guint32 aim_snacid_t;

#include "snactypes.h"

#ifdef __cplusplus

extern "C" {

#endif

#define FAIM_SNAC_HASH_SIZE 16

/*

 * Current Maximum Length for usernames (not including NULL)

 *

 * Currently only names up to 16 characters can be registered

 * however it is apparently legal for them to be larger.

 */

#define MAXSNLEN 97

/*

 * Current Maximum Length for Instant Messages

 *

 * This was found basically by experiment, but not wholly

 * accurate experiment.  It should not be regarded

 * as completely correct.  But its a decent approximation.

 *

 * Note that although we can send this much, its impossible

 * for WinAIM clients (up through the latest (4.0.1957)) to

 * send any more than 1kb.  Amaze all your windows friends

 * with utterly oversized instant messages!

 */

#define MAXMSGLEN 2544

/*

 * Maximum size of a Buddy Icon.

 */

#define MAXICONLEN 7168

#define AIM_ICONIDENT "AVT1picture.id"

/*

 * Current Maximum Length for Chat Room Messages

 *

 * This is actually defined by the protocol to be

 * dynamic, but I have yet to see due cause to

 * define it dynamically here.  Maybe later.

 *

 */

#define MAXCHATMSGLEN 512

/*

 * Found by trial and error.

 */

#define MAXAVAILMSGLEN 251

/**

 * Maximum length for the password of an ICQ account

 */

#define MAXICQPASSLEN 8

#define AIM_MD5_STRING "AOL Instant Messenger (SM)"

/*

 * Client info.  Filled in by the client and passed in to

 * aim_send_login().  The information ends up getting passed to OSCAR

 * through the initial login command.

 *

 */

struct _ClientInfo

{

	const char *clientstring;

	guint16 clientid;

	guint16 major;

	guint16 minor;

	guint16 point;

	guint16 build;

	guint32 distrib;

	const char *country; /* two-letter abbrev */

	const char *lang; /* two-letter abbrev */

};

/* Needs to be checked */

#define CLIENTINFO_AIM_3_5_1670 { \

	"AOL Instant Messenger (SM), version 3.5.1670/WIN32", \

	0x0004, \

	0x0003, 0x0005, \

	0x0000, 0x0686, \

	0x0000002a, \

	"us", "en", \

}

/* Needs to be checked */

/* Latest winaim without ssi */

#define CLIENTINFO_AIM_4_1_2010 { \

	"AOL Instant Messenger (SM), version 4.1.2010/WIN32", \

	0x0004, \

	0x0004, 0x0001, \

	0x0000, 0x07da, \

	0x0000004b, \

	"us", "en", \

}

/* Needs to be checked */

#define CLIENTINFO_AIM_4_3_2188 { \

	"AOL Instant Messenger (SM), version 4.3.2188/WIN32", \

	0x0109, \

	0x0400, 0x0003, \

	0x0000, 0x088c, \

	0x00000086, \

	"us", "en", \

}

/* Needs to be checked */

#define CLIENTINFO_AIM_4_8_2540 { \

	"AOL Instant Messenger (SM), version 4.8.2540/WIN32", \

	0x0109, \

	0x0004, 0x0008, \

	0x0000, 0x09ec, \

	0x000000af, \

	"us", "en", \

}

/* Needs to be checked */

#define CLIENTINFO_AIM_5_0_2938 { \

	"AOL Instant Messenger, version 5.0.2938/WIN32", \

	0x0109, \

	0x0005, 0x0000, \

	0x0000, 0x0b7a, \

	0x00000000, \

	"us", "en", \

}

#define CLIENTINFO_AIM_5_1_3036 { \

	"AOL Instant Messenger, version 5.1.3036/WIN32", \

	0x0109, \

	0x0005, 0x0001, \

	0x0000, 0x0bdc, \

	0x000000d2, \

	"us", "en", \

}

#define CLIENTINFO_AIM_5_5_3415 { \

	"AOL Instant Messenger, version 5.5.3415/WIN32", \

	0x0109, \

	0x0005, 0x0005, \

	0x0000, 0x0057, \

	0x000000ef, \

	"us", "en", \

}

#define CLIENTINFO_AIM_5_9_3702 { \

	"AOL Instant Messenger, version 5.9.3702/WIN32", \

	0x0109, \

	0x0005, 0x0009, \

	0x0000, 0x0e76, \

	0x00000111, \

	"us", "en", \

}

#define CLIENTINFO_ICHAT_1_0 { \

	"Apple iChat", \

	0x311a, \

	0x0001, 0x0000, \

	0x0000, 0x003c, \

	0x000000c6, \

	"us", "en", \

}

/* Needs to be checked */

#define CLIENTINFO_ICQ_4_65_3281 { \

	"ICQ Inc. - Product of ICQ (TM) 2000b.4.65.1.3281.85", \

	0x010a, \

	0x0004, 0x0041, \

	0x0001, 0x0cd1, \

	0x00000055, \

	"us", "en", \

}

/* Needs to be checked */

#define CLIENTINFO_ICQ_5_34_3728 { \

	"ICQ Inc. - Product of ICQ (TM).2002a.5.34.1.3728.85", \

	0x010a, \

	0x0005, 0x0022, \

	0x0001, 0x0e8f, \

	0x00000055, \

	"us", "en", \

}

#define CLIENTINFO_ICQ_5_45_3777 { \

	"ICQ Inc. - Product of ICQ (TM).2003a.5.45.1.3777.85", \

	0x010a, \

	0x0005, 0x002d, \

	0x0001, 0x0ec1, \

	0x00000055, \

	"us", "en", \

}

#define CLIENTINFO_ICQ6_6_0_6059 { \

	"ICQ Client", \

	0x010a, \

	0x0006, 0x0000, \

	0x0000, 0x17ab, \

	0x00007535, \

	"us", "en", \

}

#define CLIENTINFO_ICQBASIC_14_3_1068 { \

	"ICQBasic", \

	0x010a, \

	0x0014, 0x0003, \

	0x0000, 0x042c, \

	0x0000043d, \

	"us", "en", \

}

#define CLIENTINFO_ICQBASIC_14_34_3000 { \

	"ICQBasic", \

	0x010a, \

	0x0014, 0x0034, \

	0x0000, 0x0bb8, \

	0x0000043d, \

	"us", "en", \

}

#define CLIENTINFO_ICQBASIC_14_34_3096 { \

	"ICQBasic", \

	0x010a, \

	0x0014, 0x0034, \

	0x0000, 0x0c18, \

	0x0000043d, \

	"us", "en", \

}

#define CLIENTINFO_NETSCAPE_7_0_1 { \

	"Netscape 2000 an approved user of AOL Instant Messenger (SM)", \

	0x1d0d, \

	0x0007, 0x0000, \

	0x0001, 0x0000, \

	0x00000058, \

	"us", "en", \

}

/*

 * We need to use the major-minor-micro versions from the official

 * AIM and ICQ programs here or AOL won't let us use certain features.

 *

 * 0x00000611 is the distid given to us by AOL for use as the default

 * libpurple distid.

 */

#define CLIENTINFO_PURPLE_AIM { \

	NULL, \

	0x0109, \

	0x0005, 0x0001, \

	0x0000, 0x0bdc, \

	0x00000611, \

	"us", "en", \

}

#define CLIENTINFO_PURPLE_ICQ { \

	NULL, \

	0x010a, \

	0x0014, 0x0034, \

	0x0000, 0x0c18, \

	0x00000611, \

	"us", "en", \

}

#define CLIENTINFO_AIM_KNOWNGOOD CLIENTINFO_AIM_5_1_3036

#define CLIENTINFO_ICQ_KNOWNGOOD CLIENTINFO_ICQBASIC_14_34_3096

typedef enum

{

	OSCAR_DISCONNECT_DONE, /* not considered an error */

	OSCAR_DISCONNECT_LOCAL_CLOSED, /* peer connections only, not considered an error */

	OSCAR_DISCONNECT_REMOTE_CLOSED,

	OSCAR_DISCONNECT_REMOTE_REFUSED, /* peer connections only */

	OSCAR_DISCONNECT_LOST_CONNECTION,

	OSCAR_DISCONNECT_INVALID_DATA,

	OSCAR_DISCONNECT_COULD_NOT_CONNECT,

	OSCAR_DISCONNECT_RETRYING /* peer connections only */

} OscarDisconnectReason;

typedef enum

{

	OSCAR_CAPABILITY_BUDDYICON            = 0x00000001,

	OSCAR_CAPABILITY_TALK                 = 0x00000002,

	OSCAR_CAPABILITY_DIRECTIM             = 0x00000004,

	OSCAR_CAPABILITY_CHAT                 = 0x00000008,

	OSCAR_CAPABILITY_GETFILE              = 0x00000010,

	OSCAR_CAPABILITY_SENDFILE             = 0x00000020,

	OSCAR_CAPABILITY_GAMES                = 0x00000040,

	OSCAR_CAPABILITY_ADDINS               = 0x00000080,

	OSCAR_CAPABILITY_SENDBUDDYLIST        = 0x00000100,

	OSCAR_CAPABILITY_GAMES2               = 0x00000200,

	OSCAR_CAPABILITY_ICQ_DIRECT           = 0x00000400,

	OSCAR_CAPABILITY_APINFO               = 0x00000800,

	OSCAR_CAPABILITY_ICQRTF               = 0x00001000,

	OSCAR_CAPABILITY_EMPTY                = 0x00002000,

	OSCAR_CAPABILITY_ICQSERVERRELAY       = 0x00004000,

	OSCAR_CAPABILITY_UNICODEOLD           = 0x00008000,

	OSCAR_CAPABILITY_TRILLIANCRYPT        = 0x00010000,

	OSCAR_CAPABILITY_UNICODE              = 0x00020000,

	OSCAR_CAPABILITY_INTEROPERATE         = 0x00040000,

	OSCAR_CAPABILITY_SHORTCAPS            = 0x00080000,

	OSCAR_CAPABILITY_HIPTOP               = 0x00100000,

	OSCAR_CAPABILITY_SECUREIM             = 0x00200000,

	OSCAR_CAPABILITY_SMS                  = 0x00400000,

	OSCAR_CAPABILITY_VIDEO                = 0x00800000,

	OSCAR_CAPABILITY_ICHATAV              = 0x01000000,

	OSCAR_CAPABILITY_LIVEVIDEO            = 0x02000000,

	OSCAR_CAPABILITY_CAMERA               = 0x04000000,

	OSCAR_CAPABILITY_ICHAT_SCREENSHARE    = 0x08000000,

	OSCAR_CAPABILITY_TYPING               = 0x10000000,

	OSCAR_CAPABILITY_GENERICUNKNOWN       = 0x20000000,

	OSCAR_CAPABILITY_LAST                 = 0x40000000

} OscarCapability;

/*

 * Byte Stream type. Sort of.

 *

 * Use of this type serves a couple purposes:

 *   - Buffer/buflen pairs are passed all around everywhere. This turns

 *     that into one value, as well as abstracting it slightly.

 *   - Through the abstraction, it is possible to enable bounds checking

 *     for robustness at the cost of performance.  But a clean failure on

 *     weird packets is much better than a segfault.

 *   - I like having variables named "bs".

 *

 * Don't touch the insides of this struct.  Or I'll have to kill you.

 *

 */

struct _ByteStream

{

	guint8 *data;

	guint32 len;

	guint32 offset;

};

struct _QueuedSnac

{

	guint16 family;

	guint16 subtype;

	FlapFrame *frame;

};

struct _FlapFrame

{

	guint8 channel;

	guint16 seqnum;

	ByteStream data;        /* payload stream */

};

struct _FlapConnection

{

	OscarData *od;              /**< Pointer to parent session. */

	gboolean connected;

	time_t lastactivity;             /**< Time of last transmit. */

	guint destroy_timeout;

	OscarDisconnectReason disconnect_reason;

	gchar *error_message;

	guint16 disconnect_code;

	/* A few variables that are only used when connecting */

	PurpleProxyConnectData *connect_data;

	guint16 cookielen;

	guint8 *cookie;

	gpointer new_conn_data;

	int fd;

	PurpleSslConnection *gsc;

	guint8 header[6];

	gssize header_received;

	FlapFrame buffer_incoming;

	PurpleCircBuffer *buffer_outgoing;

	guint watcher_incoming;

	guint watcher_outgoing;

	guint16 type;

	guint16 subtype;

	guint16 seqnum_out; /**< The sequence number of most recently sent packet. */

	guint16 seqnum_in; /**< The sequence number of most recently received packet. */

	GSList *groups;

	GSList *rateclasses; /* Contains nodes of struct rateclass. */

	GQueue *queued_snacs; /**< Contains QueuedSnacs. */

	GQueue *queued_lowpriority_snacs; /**< Contains QueuedSnacs to send only once queued_snacs is empty */

	guint queued_timeout;

	void *internal; /* internal conn-specific libfaim data */

};

struct _IcbmCookie

{

	guchar cookie[8];

	int type;

	void *data;

	time_t addtime;

	struct _IcbmCookie *next;

};

#include "peer.h"

/*

 * AIM Session: The main client-data interface.

 *

 */

struct _OscarData

{

	/** Only used when connecting with clientLogin */

	PurpleUtilFetchUrlData *url_data;

	gboolean iconconnecting;

	gboolean set_icon;

	GSList *create_rooms;

	gboolean conf;

	gboolean reqemail;

	gboolean setemail;

	char *email;

	gboolean setnick;

	char *newformatting;

	gboolean chpass;

	char *oldp;

	char *newp;

	GSList *oscar_chats;

	GHashTable *buddyinfo;

	GSList *requesticon;

	gboolean use_ssl;

	gboolean icq;

	guint getblisttimer;

	struct {

		guint maxwatchers; /* max users who can watch you */

		guint maxbuddies; /* max users you can watch */

		guint maxgroups; /* max groups in server list */

		guint maxpermits; /* max users on permit list */

		guint maxdenies; /* max users on deny list */

		guint maxsiglen; /* max size (bytes) of profile */

		guint maxawaymsglen; /* max size (bytes) of posted away message */

	} rights;

	PurpleConnection *gc;

	void *modlistv;

	/*

	 * Outstanding snac handling

	 *

	 * TODO: Should these be per-connection? -mid

	 */

	void *snac_hash[FAIM_SNAC_HASH_SIZE];

	aim_snacid_t snacid_next;

	/*

	 * TODO: Data specific to a certain family should go into a

	 *       hashtable and the core parts of libfaim shouldn't

	 *       need to know about them.

	 */

	IcbmCookie *msgcookies;

	struct aim_icq_info *icq_info;

	/** Only used when connecting with the old-style BUCP login. */

	struct aim_authresp_info *authinfo;

	struct aim_emailinfo *emailinfo;

	struct {

		struct aim_userinfo_s *userinfo;

	} locate;

	/* Server-stored information (ssi) */

	struct {

		gboolean received_data;

		guint16 numitems;

		struct aim_ssi_item *official;

		struct aim_ssi_item *local;

		struct aim_ssi_tmp *pending;

		time_t timestamp;

		gboolean waiting_for_ack;

		gboolean in_transaction;

	} ssi;

	/** Contains pointers to handler functions for each family/subtype. */

	GHashTable *handlerlist;

	/** A linked list containing FlapConnections. */

	GSList *oscar_connections;

	guint16 default_port;

	/** A linked list containing PeerConnections. */

	GSList *peer_connections;

};

/* Valid for calling aim_icq_setstatus() and for aim_userinfo_t->icqinfo.status */

#define AIM_ICQ_STATE_NORMAL            0x00000000

#define AIM_ICQ_STATE_AWAY              0x00000001

#define AIM_ICQ_STATE_DND               0x00000002

#define AIM_ICQ_STATE_OUT               0x00000004

#define AIM_ICQ_STATE_BUSY              0x00000010

#define AIM_ICQ_STATE_CHAT              0x00000020

#define AIM_ICQ_STATE_INVISIBLE         0x00000100

#define AIM_ICQ_STATE_WEBAWARE          0x00010000

#define AIM_ICQ_STATE_HIDEIP            0x00020000

#define AIM_ICQ_STATE_BIRTHDAY          0x00080000

#define AIM_ICQ_STATE_DIRECTDISABLED    0x00100000

#define AIM_ICQ_STATE_ICQHOMEPAGE       0x00200000

#define AIM_ICQ_STATE_DIRECTREQUIREAUTH 0x10000000

#define AIM_ICQ_STATE_DIRECTCONTACTLIST 0x20000000

/**

 * Only used when connecting with the old-style BUCP login.

 */

struct aim_clientrelease

{

	char *name;

	guint32 build;

	char *url;

	char *info;

};

/**

 * Only used when connecting with the old-style BUCP login.

 */

struct aim_authresp_info

{

	char *bn;

	guint16 errorcode;

	char *errorurl;

	guint16 regstatus;

	char *email;

	char *bosip;

	guint16 cookielen;

	guint8 *cookie;

	char *chpassurl;

	struct aim_clientrelease latestrelease;

	struct aim_clientrelease latestbeta;

};

/* Callback data for redirect. */

struct aim_redirect_data

{

	guint16 group;

	const char *ip;

	guint16 cookielen;

	const guint8 *cookie;

	const char *ssl_cert_cn;

	guint8 use_ssl;

	struct { /* group == SNAC_FAMILY_CHAT */

		guint16 exchange;

		const char *room;

		guint16 instance;

	} chat;

};

int oscar_connect_to_bos(PurpleConnection *gc, OscarData *od, const char *host, guint16 port, guint8 *cookie, guint16 cookielen);

/* family_auth.c */

/**

 * Only used when connecting with the old-style BUCP login.

 */

int aim_request_login(OscarData *od, FlapConnection *conn, const char *bn);

/**

 * Only used when connecting with the old-style BUCP login.

 */

int aim_send_login(OscarData *od, FlapConnection *conn, const char *bn, const char *password, gboolean truncate_pass, ClientInfo *ci, const char *key, gboolean allow_multiple_logins);

/**

 * Only used when connecting with the old-style BUCP login.

 */

/* 0x000b */ int aim_auth_securid_send(OscarData *od, const char *securid);

/**

 * Only used when connecting with clientLogin.

 */

void send_client_login(OscarData *od, const char *username);

/* flap_connection.c */

FlapConnection *flap_connection_new(OscarData *, int type);

void flap_connection_close(OscarData *od, FlapConnection *conn);

void flap_connection_destroy(FlapConnection *conn, OscarDisconnectReason reason, const gchar *error_message);

void flap_connection_schedule_destroy(FlapConnection *conn, OscarDisconnectReason reason, const gchar *error_message);

FlapConnection *flap_connection_findbygroup(OscarData *od, guint16 group);

FlapConnection *flap_connection_getbytype(OscarData *, int type);

FlapConnection *flap_connection_getbytype_all(OscarData *, int type);

void flap_connection_recv_cb(gpointer data, gint source, PurpleInputCondition cond);

void flap_connection_recv_cb_ssl(gpointer data, PurpleSslConnection *gsc, PurpleInputCondition cond);

void flap_connection_send(FlapConnection *conn, FlapFrame *frame);

void flap_connection_send_version(OscarData *od, FlapConnection *conn);

void flap_connection_send_version_with_cookie(OscarData *od, FlapConnection *conn, guint16 length, const guint8 *chipsahoy);

void flap_connection_send_version_with_cookie_and_clientinfo(OscarData *od, FlapConnection *conn, guint16 length, const guint8 *chipsahoy, ClientInfo *ci);

void flap_connection_send_snac(OscarData *od, FlapConnection *conn, guint16 family, const guint16 subtype, guint16 flags, aim_snacid_t snacid, ByteStream *data);

void flap_connection_send_snac_with_priority(OscarData *od, FlapConnection *conn, guint16 family, const guint16 subtype, guint16 flags, aim_snacid_t snacid, ByteStream *data, gboolean high_priority);

void flap_connection_send_keepalive(OscarData *od, FlapConnection *conn);

FlapFrame *flap_frame_new(OscarData *od, guint16 channel, int datalen);

/* oscar_data.c */

typedef int (*aim_rxcallback_t)(OscarData *od, FlapConnection *conn, FlapFrame *frame, ...);

OscarData *oscar_data_new(void);

void oscar_data_destroy(OscarData *);

void oscar_data_addhandler(OscarData *od, guint16 family, guint16 subtype, aim_rxcallback_t newhandler, guint16 flags);

aim_rxcallback_t aim_callhandler(OscarData *od, guint16 family, guint16 subtype);

/* misc.c */

#define AIM_VISIBILITYCHANGE_PERMITADD    0x05

#define AIM_VISIBILITYCHANGE_PERMITREMOVE 0x06

#define AIM_VISIBILITYCHANGE_DENYADD      0x07

#define AIM_VISIBILITYCHANGE_DENYREMOVE   0x08

#define AIM_PRIVFLAGS_ALLOWIDLE           0x01

#define AIM_PRIVFLAGS_ALLOWMEMBERSINCE    0x02

#define AIM_WARN_ANON                     0x01

/* 0x0001 - family_oservice.c */

/* 0x0002 */ void aim_srv_clientready(OscarData *od, FlapConnection *conn);

/* 0x0004 */ void aim_srv_requestnew(OscarData *od, guint16 serviceid);

/* 0x0006 */ void aim_srv_reqrates(OscarData *od, FlapConnection *conn);

/* 0x0008 */ void aim_srv_rates_addparam(OscarData *od, FlapConnection *conn);

/* 0x0009 */ void aim_srv_rates_delparam(OscarData *od, FlapConnection *conn);

/* 0x000c */ void aim_srv_sendpauseack(OscarData *od, FlapConnection *conn);

/* 0x000e */ void aim_srv_reqpersonalinfo(OscarData *od, FlapConnection *conn);

/* 0x0011 */ void aim_srv_setidle(OscarData *od, guint32 idletime);

/* 0x0014 */ void aim_srv_setprivacyflags(OscarData *od, FlapConnection *conn, guint32);

/* 0x0016 */ void aim_srv_nop(OscarData *od, FlapConnection *conn);

/* 0x0017 */ void aim_srv_setversions(OscarData *od, FlapConnection *conn);

/* 0x001e */ int aim_srv_setextrainfo(OscarData *od, gboolean seticqstatus, guint32 icqstatus, gboolean setstatusmsg, const char *statusmsg, const char *itmsurl);

void aim_bos_reqrights(OscarData *od, FlapConnection *conn);

int aim_bos_changevisibility(OscarData *od, FlapConnection *conn, int, const char *);

void aim_bos_setgroupperm(OscarData *od, FlapConnection *conn, guint32 mask);

#define AIM_CLIENTTYPE_UNKNOWN  0x0000

#define AIM_CLIENTTYPE_MC       0x0001

#define AIM_CLIENTTYPE_WINAIM   0x0002

#define AIM_CLIENTTYPE_WINAIM41 0x0003

#define AIM_CLIENTTYPE_AOL_TOC  0x0004

guint16 aim_im_fingerprint(const guint8 *msghdr, int len);

#define AIM_RATE_CODE_CHANGE     0x0001

#define AIM_RATE_CODE_WARNING    0x0002

#define AIM_RATE_CODE_LIMIT      0x0003

#define AIM_RATE_CODE_CLEARLIMIT 0x0004

void aim_ads_requestads(OscarData *od, FlapConnection *conn);

/* family_icbm.c */

#define AIM_OFT_SUBTYPE_SEND_FILE	0x0001

#define AIM_OFT_SUBTYPE_SEND_DIR	0x0002

#define AIM_OFT_SUBTYPE_GET_FILE	0x0011

#define AIM_OFT_SUBTYPE_GET_LIST	0x0012

#define AIM_TRANSFER_DENY_NOTSUPPORTED	0x0000

#define AIM_TRANSFER_DENY_DECLINE	0x0001

#define AIM_TRANSFER_DENY_NOTACCEPTING	0x0002

#define AIM_IMPARAM_FLAG_CHANNEL_MSGS_ALLOWED   0x00000001

#define AIM_IMPARAM_FLAG_MISSED_CALLS_ENABLED   0x00000002

#define AIM_IMPARAM_FLAG_EVENTS_ALLOWED         0x00000008

#define AIM_IMPARAM_FLAG_SMS_SUPPORTED          0x00000010

#define AIM_IMPARAM_FLAG_OFFLINE_MSGS_ALLOWED   0x00000100

/* This is what the server will give you if you don't set them yourself. */

/* This is probably out of date. */

#define AIM_IMPARAM_DEFAULTS { \

	0, \

	AIM_IMPARAM_FLAG_CHANNEL_MSGS_ALLOWED | AIM_IMPARAM_FLAG_MISSED_CALLS_ENABLED, \

	512, /* !! Note how small this is. */ \

	(99.9)*10, (99.9)*10, \

	1000 /* !! And how large this is. */ \

}

/* This is what most AIM versions use. */

/* This is probably out of date. */

#define AIM_IMPARAM_REASONABLE { \

	0, \

	AIM_IMPARAM_FLAG_CHANNEL_MSGS_ALLOWED | AIM_IMPARAM_FLAG_MISSED_CALLS_ENABLED, \

	8000, \

	(99.9)*10, (99.9)*10, \

	0 \

}

struct aim_icbmparameters

{

	guint16 maxchan;

	guint32 flags; /* AIM_IMPARAM_FLAG_ */

	guint16 maxmsglen; /* message size that you will accept */

	guint16 maxsenderwarn; /* this and below are *10 (999=99.9%) */

	guint16 maxrecverwarn;

	guint32 minmsginterval; /* in milliseconds? */

};

/*