Chat-O-Matic/libs/libimcomm/bos_signon.c

/**  _
 ** (_)_ __  __ ___ _ __  _ __
 ** | | '  \/ _/ _ \ '  \| '  \
 ** |_|_|_|_\__\___/_|_|_|_|_|_|
 **
 ** Copyright (C) 2003-2005, Claudio Leite
 ** All rights reserved.
 **
 ** Please see the file 'COPYING' for licensing information.
 **/

#include "imcomm.h"

#ifdef MD5_LOGIN
#include "md5.h"
#endif

#if 0
#define CLIENT_IDENT "AOL Instant Messenger, version 5.5.3595/WIN32"
#define CLIENT_V1 0x0109
#define CLIENT_V2 0x0005
#define CLIENT_V3 0x0005
#define CLIENT_V4 0x0000
#define CLIENT_V5 0x0e0b
#define CLIENT_V6 0x00000104
#else
#define CLIENT_IDENT "Apple iChat"
#define CLIENT_V1 0x311a
#define CLIENT_V2 0x0001
#define CLIENT_V3 0x0000
#define CLIENT_V4 0x0000
#define CLIENT_V5 0x003c
#define CLIENT_V6 0x00000c6
#endif

#ifdef MACINTOSH_CLASSIC

/*
 * Thanks to PuTTY source code for a lot of help on the MacTCP stuff.
 * Learning obsolete API's can be rather difficult...
 *
 * This should explain the similarities on variable and function names.
 */

int             initialized = 0;
short           refnum;
ProcessSerialNumber psn;
static pascal void mactcp_lookupdone(struct hostInfo *, char *);
static pascal void
mactcp_asr(StreamPtr, unsigned short, Ptr,
	   unsigned short, struct ICMPReport *);
static ResultUPP mactcp_lookupdone_upp;
static TCPNotifyUPP mactcp_asr_upp;
OSErr           err;

static pascal void
mactcp_lookupdone(struct hostInfo * hi, char *cookie)
{
	volatile int   *donep = (int *) cookie;

	*donep = TRUE;
}

static pascal void
mactcp_asr(StreamPtr str, unsigned short event, Ptr cookie,
	   unsigned short termin_reason, struct ICMPReport * icmp)
{
	WakeUpProcess(&psn);
}

void
mactcp_close(void *handle)
{
	TCPiopb         pb;

	pb.ioCRefNum = refnum;
	pb.csCode = TCPClose;
	pb.tcpStream = ((IMCOMM *) handle)->s;
	pb.csParam.close.validityFlags = 0;
	pb.csParam.close.userDataPtr = (Ptr) handle;
	PBControlSync((ParmBlkPtr) & pb);

	pb.ioCRefNum = refnum;
	pb.csCode = TCPAbort;
	pb.tcpStream = ((IMCOMM *) handle)->s;
	pb.csParam.abort.userDataPtr = (Ptr) handle;
	PBControlSync((ParmBlkPtr) & pb);

	pb.ioCRefNum = refnum;
	pb.csCode = TCPRelease;
	pb.tcpStream = ((IMCOMM *) handle)->s;
	pb.csParam.create.userDataPtr = (Ptr) handle;
	err = PBControlSync((ParmBlkPtr) & pb);
	if (err == noErr)
		free(pb.csParam.create.rcvBuff);
}
#endif

/* PROTO */
IMCOMM_RET
imcomm_im_signon(void *handle, const char *sn, const char *pw)
{
	IMCOMM_RET      ret;
	pkt_t          *packet;

#ifdef MACINTOSH_CLASSIC
	OSErr           err;
	struct hostInfo hostinfo;
	volatile int    resolverDone = FALSE;
	TCPiopb         pb;
	UDPiopb         upb;
	size_t          buflen;
#else
	struct sockaddr_in sin;
	struct hostent *he;
#endif

#ifndef MD5_LOGIN
	const char      client_ident[] = CLIENT_IDENT;
	const unsigned char roaststring[] =
	{0xF3, 0x26, 0x81, 0xC4, 0x39, 0x86, 0xDB, 0x92, 0x71, 0xA3, 0xB9,
	0xE6, 0x53, 0x7A, 0x95, 0x7C};
	unsigned char  *roastpw;
	int             x;
#else
	pkt_t          *pk2;
#endif

#ifdef MACINTOSH_CLASSIC
	if (!initialized) {
		err = OpenDriver("\p.IPP", &refnum);
		if (err != noErr) {
			printf("Error initializing driver.\n");
			return IMCOMM_RET_ERROR;
		}
		err = OpenResolver(NULL);
		if (err != noErr) {
			printf("Error initializing resolver.\n");
			return IMCOMM_RET_ERROR;
		}
		mactcp_lookupdone_upp = NewResultProc(&mactcp_lookupdone);
		mactcp_asr_upp = NewTCPNotifyProc(&mactcp_asr);
		initialized = 1;
	}
	err =
		StrToAddr("login.oscar.aol.com", &hostinfo, mactcp_lookupdone_upp,
			  (char *) &resolverDone);
	if (err == cacheFault)
		while (!resolverDone)
			continue;

	upb.ioCRefNum = refnum;
	upb.csCode = UDPMaxMTUSize;
	upb.csParam.mtu.remoteHost = hostinfo.addr[0];
	upb.csParam.mtu.userDataPtr = (Ptr) handle;
	err = PBControlSync((ParmBlkPtr) & upb);
	if (err != noErr) {
		printf("Error retrieving MTU.\n");
		return IMCOMM_RET_ERROR;
	}
	buflen = upb.csParam.mtu.mtuSize * 4 + 1024;
	if (buflen < 4096)
		buflen = 4096;

	GetCurrentProcess(&psn);

	pb.ioCRefNum = refnum;
	pb.csCode = TCPCreate;
	pb.csParam.create.rcvBuff = malloc(buflen);
	pb.csParam.create.rcvBuffLen = buflen;
	pb.csParam.create.notifyProc = mactcp_asr_upp;
	pb.csParam.create.userDataPtr = (Ptr) handle;
	err = PBControlSync((ParmBlkPtr) & pb);
	if (err != noErr) {
		printf("Error creating TCP stream.\n");
		return IMCOMM_RET_ERROR;
	}
	((IMCOMM *) handle)->s = pb.tcpStream;

	pb.ioCRefNum = refnum;
	pb.csCode = TCPActiveOpen;
	pb.tcpStream = ((IMCOMM *) handle)->s;
	pb.csParam.open.validityFlags = 0;
	pb.csParam.open.remoteHost = hostinfo.addr[0];
	pb.csParam.open.remotePort = ((IMCOMM *) handle)->oscarport;
	pb.csParam.open.localPort = 0;
	pb.csParam.open.timeToLive = 0;
	pb.csParam.open.security = 0;
	pb.csParam.open.optionCnt = 0;
	pb.csParam.open.userDataPtr = (Ptr) handle;
	err = PBControlSync((ParmBlkPtr) & pb);
	if (err != noErr) {
		printf("Connection failed.\n");
		return IMCOMM_RET_ERROR;
	}
	((IMCOMM *) handle)->readable = 1;
#else
	/* XXX insert modular socket code here */
#ifdef __MINGW32__
	if (WSAStartup(0x101, &((IMCOMM *) handle)->wsadata)) {
		printf("ERROR: %i\n", WSAGetLastError());
		return IMCOMM_RET_ERROR;
	}
#endif

	if (((IMCOMM *) handle)->proxymode == PROXY_TYPE_SOCKS5) {
		connect_socks5(handle, "login.oscar.aol.com",
			       ((IMCOMM *) handle)->oscarport);
	} else if (((IMCOMM *) handle)->proxymode == PROXY_TYPE_HTTPS) {
		connect_https(handle, "login.oscar.aol.com",
			      ((IMCOMM *) handle)->oscarport);
	} else {
		if ((he = gethostbyname("login.oscar.aol.com")) == NULL) {
			perror("gethostbyname()");
			return IMCOMM_RET_ERROR;
		}
		if ((((IMCOMM *) handle)->socket =
		     socket(AF_INET, SOCK_STREAM, 0)) == -1) {
			perror("socket()");
			return IMCOMM_RET_ERROR;
		}
		sin.sin_family = AF_INET;
		sin.sin_port = htons(((IMCOMM *) handle)->oscarport);

		sin.sin_addr = *((struct in_addr *) he->h_addr);
		memset(&(sin.sin_zero), 0, 8);

		if (connect
		    (((IMCOMM *) handle)->socket, (struct sockaddr *) & sin,
		     sizeof(struct sockaddr)) == -1) {
			perror("connect()");
			return IMCOMM_RET_ERROR;
		}
	}
	/* end socket code for now */
#endif

#ifdef MD5_LOGIN
	((IMCOMM *) handle)->pw = strdup((char *) pw);
	((IMCOMM *) handle)->sn = strdup((char *) sn);
	packet = pkt_init(12 + strlen(sn));
#else
	roastpw = malloc(strlen(pw) + 1);
	memset(roastpw, 0, strlen(pw) + 1);

	for (x = 0; x < (int) strlen(pw); x++)
		roastpw[x] = (pw[x] ^ roaststring[x]);

	packet = pkt_init(66 + strlen(client_ident) + strlen(sn) + strlen(pw));

	pkt_add32(packet, 0x00000001);
#endif

	/*
         * I should really build a TLV here instead, but this works.
         */

	/*
         * Add SN length + SN
         */
	pkt_add16(packet, 0x0001);
	pkt_add16(packet, (uint16_t) strlen(sn));
	pkt_addraw(packet, (uint8_t *) sn, strlen(sn));

#ifdef MD5_LOGIN
	/*
         * Add unknown TLV's...
         */
	pkt_add16(packet, 0x004B);
	pkt_add16(packet, 0x0000);
	pkt_add16(packet, 0x005A);
	pkt_add16(packet, 0x0000);
#else
	/*
         * Add roasted PW length + roasted PW
         */
	pkt_add16(packet, 0x0002);
	pkt_add16(packet, (uint16_t) strlen(pw));
	pkt_addraw(packet, (uint8_t *) pw, strlen(pw));

	/*
         * Add client ident string
         */
	pkt_add16(packet, 0x0003);
	pkt_add16(packet, (uint16_t) strlen(client_ident));
	pkt_addraw(packet, (uint8_t *) client_ident, strlen(client_ident));

	/*
         * Add client ID (hardcoded)
         */
	pkt_add16(packet, 0x0016);
	pkt_add16(packet, 0x0002);
	pkt_add16(packet, 0x0109);

	/*
         * Add client versions (hardcoded)
         */
	pkt_add16(packet, 0x0017);
	pkt_add16(packet, 0x0002);
	pkt_add16(packet, 0x0005);
	pkt_add16(packet, 0x0018);
	pkt_add16(packet, 0x0002);
	pkt_add16(packet, 0x0005);
	pkt_add16(packet, 0x0019);
	pkt_add16(packet, 0x0002);
	pkt_add16(packet, 0x0000);
	pkt_add16(packet, 0x001A);
	pkt_add16(packet, 0x0002);
	pkt_add16(packet, 0x0057);
	pkt_add16(packet, 0x0014);
	pkt_add16(packet, 0x0004);
	pkt_add32(packet, 0x000000ef);
	pkt_add16(packet, 0x000F);
	pkt_add16(packet, 0x0002);
	pkt_addraw(packet, (unsigned char *) "en", 2);
	pkt_add16(packet, 0x000E);
	pkt_add16(packet, 0x0002);
	pkt_addraw(packet, (unsigned char *) "us", 2);
#endif

#ifdef MD5_LOGIN
	pk2 = pkt_init(4);
	pkt_add32(pk2, 0x00000001);
	flap_sendpkt(handle, 0x01, pk2, 0);
	pkt_free(pk2);

	ret = snac_sendpkt(handle, 0x17, 0x06, packet, 0);
#else
	ret = flap_sendpkt(handle, 0x01, packet, 0);
	free(roastpw);
#endif
	pkt_free(packet);
	return ret;

}

/* PROTO */
IMCOMM_RET
bos_signon_phase2(void *handle, unsigned const char *server, unsigned const char *cookie, uint16_t cookie_len)
{
	char           *host;
	uint16_t        port;
	pkt_t          *packet;
	int             x, ret;
	int             newlen;

#ifdef MACINTOSH_CLASSIC
	OSErr           err;
	struct hostInfo hostinfo;
	volatile int    resolverDone = FALSE;
	TCPiopb         pb;
	UDPiopb         upb;
	size_t          buflen;
#else
	struct sockaddr_in sin;
#endif

#if defined(PLAN9) || defined(__MINGW32__)
	long            addy;
	struct in_addr  ina;
#else
	struct hostent *he;
#endif

	port = atoi(strchr((char *) server, ':') + 1);

	host = (char *) malloc(strlen((char *) server) + 1);

#ifdef __OpenBSD__
	strlcpy(host, (char *) server, strlen((char *) server));
#else
	strcpy(host, (char *) server);
#endif

	for (x = 0; x < (int) strlen(host); x++)
		if (host[x] == ':') {
			host[x] = 0;
			break;
		}
#ifdef MACINTOSH_CLASSIC
	mactcp_close(handle);
	((IMCOMM *) handle)->readable = 0;

	err =
		StrToAddr(host, &hostinfo, mactcp_lookupdone_upp,
			  (char *) &resolverDone);
	if (err == cacheFault)
		while (!resolverDone)
			continue;

	upb.ioCRefNum = refnum;
	upb.csCode = UDPMaxMTUSize;
	upb.csParam.mtu.remoteHost = hostinfo.addr[0];
	upb.csParam.mtu.userDataPtr = (Ptr) handle;
	err = PBControlSync((ParmBlkPtr) & upb);
	if (err != noErr) {
		printf("Error retrieving MTU.\n");
		return IMCOMM_RET_ERROR;
	}
	buflen = upb.csParam.mtu.mtuSize * 4 + 1024;
	if (buflen < 4096)
		buflen = 4096;

	pb.ioCRefNum = refnum;
	pb.csCode = TCPCreate;
	pb.csParam.create.rcvBuff = malloc(buflen);
	pb.csParam.create.rcvBuffLen = buflen;
	pb.csParam.create.notifyProc = mactcp_asr_upp;
	pb.csParam.create.userDataPtr = (Ptr) handle;
	err = PBControlSync((ParmBlkPtr) & pb);
	if (err != noErr) {
		printf("Error creating TCP stream.\n");
		return IMCOMM_RET_ERROR;
	}
	((IMCOMM *) handle)->s = pb.tcpStream;

	pb.ioCRefNum = refnum;
	pb.csCode = TCPActiveOpen;
	pb.tcpStream = ((IMCOMM *) handle)->s;
	pb.csParam.open.validityFlags = 0;
	pb.csParam.open.remoteHost = hostinfo.addr[0];
	pb.csParam.open.remotePort = port;
	pb.csParam.open.localPort = 0;
	pb.csParam.open.timeToLive = 0;
	pb.csParam.open.security = 0;
	pb.csParam.open.optionCnt = 0;
	pb.csParam.open.userDataPtr = (Ptr) handle;
	err = PBControlSync((ParmBlkPtr) & pb);
	if (err != noErr) {
		printf("Connection failed.\n");
		return IMCOMM_RET_ERROR;
	}
	((IMCOMM *) handle)->readable = 1;

#else
	if (((IMCOMM *) handle)->ischild == 0)
		shutdown(((IMCOMM *) handle)->socket, 0x02);

	if (((IMCOMM *) handle)->proxymode == PROXY_TYPE_SOCKS5) {
		connect_socks5(handle, host, port);
	} else if (((IMCOMM *) handle)->proxymode == PROXY_TYPE_HTTPS) {
		connect_https(handle, host, port);
	} else {

#if !defined(PLAN9) && !defined(__MINGW32__)
		if ((he = gethostbyname(host)) == NULL) {
			perror("gethostbyname()");
			free(host);
			return IMCOMM_RET_ERROR;
		}
		free(host);
#else
		addy = inet_addr(host);
		ina.s_addr = addy;
		free(host);
#endif

		if ((((IMCOMM *) handle)->socket =
		     socket(AF_INET, SOCK_STREAM, 0)) == -1) {
			perror("socket()");
			return IMCOMM_RET_ERROR;
		}
		sin.sin_family = AF_INET;
		sin.sin_port = htons(port);

#if defined(PLAN9) || defined(__MINGW32__)
		sin.sin_addr = ina;
#else
		sin.sin_addr = *((struct in_addr *) he->h_addr);
#endif

		memset(&(sin.sin_zero), 0, 8);

		if (connect
		    (((IMCOMM *) handle)->socket, (struct sockaddr *) & sin,
		     sizeof(struct sockaddr)) == -1) {
			perror("connect()");
			return IMCOMM_RET_ERROR;
		}
#endif
	}

	newlen = cookie_len + 8;
	packet = pkt_init(newlen);
	pkt_add32(packet, 0x00000001);
	pkt_add16(packet, 0x0006);
	pkt_add16(packet, cookie_len);
	pkt_addraw(packet, (uint8_t *) cookie, cookie_len);

	ret = flap_sendpkt(handle, 0x01, packet, 0);
	pkt_free(packet);
	return ret;
}

/* PROTO */
void
handle_srv_migration(void *handle, uint8_t * data, uint16_t len)
{
	TLVLIST        *tlv, *trav;
	uint16_t        num_family, cookie_len = 0;
	pkt_t          *inpkt;
	int             status = 0;
	char           *bos_server = 0;
	uint8_t        *cookie = 0;

	inpkt = pkt_initP(data + 10, len - 10);

	num_family = pkt_get16(inpkt);
	if (num_family != 0 && num_family != ((IMCOMM *) handle)->num_families) {
		printf("migration has different number of families.\n");
		printf("not proceeding (bifurcated?)\n");
		return;
	}
	pkt_freeP(inpkt);

	if (((IMCOMM *) handle)->srv_pause)
		((IMCOMM *) handle)->srv_pause = 0;

	tlv =
		tlv_split(data + 12 + (num_family * 2),
			  len - (12 + (num_family * 2)), 0);

	printf("migration beginning.\n");

	for (trav = tlv; trav != NULL; trav = trav->next) {
		if (trav->type == 0x0005) {
			bos_server = malloc(trav->len + 1);
			memcpy(bos_server, trav->value, trav->len);
			bos_server[trav->len] = 0;
			status++;
		} else if (trav->type == 0x0006) {
			cookie = malloc(trav->len);
			cookie_len = trav->len;
			memcpy(cookie, trav->value, trav->len);
			status++;
		}
	}

	clear_tlv_list(tlv);

	printf("server: %s\n", bos_server);

	if (((IMCOMM *) handle)->callbacks[IMCOMM_ERROR])
		((IMCOMM *) handle)->callbacks[IMCOMM_ERROR] (handle,
					       IMCOMM_STATUS_MIGRATIONDONE);

	bos_signon_phase2(handle, (unsigned char *) bos_server, cookie,
			  cookie_len);
	free(bos_server);
	free(cookie);
}

#ifdef MD5_LOGIN

#define AIM_MD5_STRING "AOL Instant Messenger (SM)"

/*
 * New stuff for MD5-based login
 */

/* PROTO */
void
bos_md5snac(void *handle, uint8_t * data, uint16_t len)
{
	uint8_t        *authkey;
	uint16_t        authkeylen;
	md5_state_t     state;
	md5_byte_t      auth_hash[16];
	pkt_t          *packet;

	if (data[3] == 0x07) {
		const char      client_ident[] = CLIENT_IDENT;

		authkeylen = two_to_16(data + 10);
		authkey = malloc(authkeylen);
		memcpy(authkey, data + 12, authkeylen);

		md5_init(&state);
		md5_append(&state, (const md5_byte_t *) authkey, authkeylen);
		md5_append(&state, (const md5_byte_t *) ((IMCOMM *) handle)->pw,
			   strlen(((IMCOMM *) handle)->pw));
		md5_append(&state, (const md5_byte_t *) AIM_MD5_STRING,
			   strlen(AIM_MD5_STRING));
		md5_finish(&state, auth_hash);

		free(authkey);

		packet =
			pkt_init(67 + strlen(CLIENT_IDENT) + 16 +
				 strlen(((IMCOMM *) handle)->sn));

		/*
	         * I should really build a TLV here instead, but this works.
	         */

		/*
	         * Add SN length + SN
	         */
		pkt_add16(packet, 0x0001);
		pkt_add16(packet, (uint16_t) strlen(((IMCOMM *) handle)->sn));
		pkt_addraw(packet, (uint8_t *) ((IMCOMM *) handle)->sn,
			   strlen(((IMCOMM *) handle)->sn));
		pkt_add16(packet, 0x0025);
		pkt_add16(packet, 0x0010);
		pkt_addraw(packet, (uint8_t *) auth_hash, 16);


		/*
	         * Add client ident string
	         */
		pkt_add16(packet, 0x0003);
		pkt_add16(packet, (uint16_t) strlen(client_ident));
		pkt_addraw(packet, (uint8_t *) client_ident, strlen(client_ident));
		/*
	         * Add client ID (hardcoded)
	         */
		pkt_add16(packet, 0x0016);
		pkt_add16(packet, 0x0002);
		pkt_add16(packet, CLIENT_V1);

		/*
	         * Add client versions (hardcoded)
	         */
		pkt_add16(packet, 0x0017);
		pkt_add16(packet, 0x0002);
		pkt_add16(packet, CLIENT_V2);
		pkt_add16(packet, 0x0018);
		pkt_add16(packet, 0x0002);
		pkt_add16(packet, CLIENT_V3);
		pkt_add16(packet, 0x0019);
		pkt_add16(packet, 0x0002);
		pkt_add16(packet, CLIENT_V4);
		pkt_add16(packet, 0x001A);
		pkt_add16(packet, 0x0002);
		pkt_add16(packet, CLIENT_V5);
		pkt_add16(packet, 0x0014);
		pkt_add16(packet, 0x0004);
		pkt_add32(packet, CLIENT_V6);
		pkt_add16(packet, 0x000F);
		pkt_add16(packet, 0x0002);
		pkt_addraw(packet, (unsigned char *) "en", 2);
		pkt_add16(packet, 0x000E);
		pkt_add16(packet, 0x0002);
		pkt_addraw(packet, (unsigned char *) "us", 2);
		pkt_add16(packet, 0x004A);
		pkt_add16(packet, 0x0001);
		pkt_add8(packet, 0x01);

		snac_sendpkt(handle, 0x17, 0x02, packet, 0);
		pkt_free(packet);
		return;
	} else if (data[3] == 0x03) {
		TLVLIST        *tlv, *trav;
		uint16_t        numtlv, cookie_len = 0;
		int             status = 0;
		char           *bos_server = 0;
		uint8_t        *cookie = 0;

		numtlv = count_tlv(data + 10, len - 10);
		tlv = tlv_split(data + 10, len - 10, numtlv);

		for (trav = tlv; trav != NULL; trav = trav->next) {
			if (trav->type == 0x0008) {
				if (((IMCOMM *) handle)->callbacks[IMCOMM_ERROR])
					((IMCOMM *) handle)->callbacks[IMCOMM_ERROR] (handle,
						IMCOMM_ERROR_INVALID_LOGIN);
#ifdef MACINTOSH_CLASSIC

#else
				shutdown(((IMCOMM *) handle)->socket, 0x02);
				((IMCOMM *) handle)->socket = -1;
#endif
			} else if (trav->type == 0x0005) {
				bos_server = malloc(trav->len + 1);
				memcpy(bos_server, trav->value, trav->len);
				bos_server[trav->len] = 0;
				status++;
			} else if (trav->type == 0x0006) {
				cookie = malloc(trav->len);
				cookie_len = trav->len;
				memcpy(cookie, trav->value, trav->len);
				status++;
			}
		}

		clear_tlv_list(tlv);

		if (status == 2) {
			if (((IMCOMM *) handle)->callbacks[IMCOMM_ERROR])
				((IMCOMM *) handle)->callbacks[IMCOMM_ERROR] (handle,
						    IMCOMM_STATUS_AUTHDONE);
			bos_signon_phase2(handle, (unsigned char *) bos_server, cookie,
					  cookie_len);
			free(bos_server);
			free(cookie);
		}
	}
}

#endif				/* MD5_LOGIN */