changeset 1259:7db9121aac80

[gaim-migrate @ 1269] MSN plugin committer: Tailor Script <[e-mail]>

--- a/STATUS	Thu Dec 14 07:17:34 2000 +0000
+++ b/STATUS	Thu Dec 14 08:33:41 2000 +0000
@@ -1,4 +1,4 @@
-STATUS of GAIM CVS tree. Last modified $Date: 2000-12-09 05:17:48 -0500 (Sat, 09 Dec 2000) $ by $Author: robflynn $.
+STATUS of GAIM CVS tree. Last modified $Date: 2000-12-14 03:33:41 -0500 (Thu, 14 Dec 2000) $ by $Author: robflynn $.
 
 This file is meant to provide gaim users who use the CVS version to see whether
 they actually want to compile what they just checked out. Gaim CVS is usually
@@ -95,6 +95,16 @@
 and functionality are planned but not yet implemented.
 
 
+MSN
+===
+
+MSN currently supports signing on, sending and receiving messages.  The
+buddylist is functional. When sending the initial message (to start a
+conversation) there will be a small delay.  It will appear as if the
+client has frozen.  This will not always be the case.  I have a fix
+that I havent taken the time to write yet.
+
+
 ICQ
 ===
 

--- a/configure.in	Thu Dec 14 07:17:34 2000 +0000
+++ b/configure.in	Thu Dec 14 08:33:41 2000 +0000
@@ -202,6 +202,7 @@
 	   plugins/Makefile
 	   plugins/yay/Makefile
 	   plugins/icq/Makefile
+	   plugins/msn/Makefile
            pixmaps/Makefile
            libfaim/Makefile
 	   po/Makefile.in

--- a/plugins/Makefile.am	Thu Dec 14 07:17:34 2000 +0000
+++ b/plugins/Makefile.am	Thu Dec 14 08:33:41 2000 +0000
@@ -5,7 +5,7 @@
 
 if PLUGINS
 
-SUBDIRS = yay icq
+SUBDIRS = yay icq msn
 
 plugin_DATA = autorecon.so iconaway.so irc.so notify.so spellchk.so lagmeter.so
 plugindir = $(libdir)/gaim

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/plugins/msn/Makefile.am	Thu Dec 14 08:33:41 2000 +0000
@@ -0,0 +1,7 @@
+CFLAGS += -I\$(top_srcdir)/src
+LIBS = $(GTK_LIBS)
+
+pkgdir = $(libdir)/gaim
+pkg_LTLIBRARIES = libmsn.la
+
+libmsn_la_SOURCES = msn.c md5.c md.h

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/plugins/msn/md5.c	Thu Dec 14 08:33:41 2000 +0000
@@ -0,0 +1,392 @@
+/*
+  Copyright (C) 1999 Aladdin Enterprises.  All rights reserved.
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  L. Peter Deutsch
+  [e-mail]
+
+ */
+/*$Id: md5.c 1269 2000-12-14 08:33:41Z robflynn $ */
+/*
+  Independent implementation of MD5 (RFC 1321).
+
+  This code implements the MD5 Algorithm defined in RFC 1321.
+  It is derived directly from the text of the RFC and not from the
+  reference implementation.
+
+  The original and principal author of md5.c is L. Peter Deutsch
+  <[e-mail]>.  Other authors are noted in the change history
+  that follows (in reverse chronological order):
+
+  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
+  1999-05-03 lpd Original version.
+ */
+
+#include "md5.h"
+
+#ifdef TEST
+/*
+ * Compile with -DTEST to create a self-contained executable test program.
+ * The test program should print out the same values as given in section
+ * A.5 of RFC 1321, reproduced below.
+ */
+#include <string.h>
+main()
+{
+    static const char *const test[7] = {
+	"", /*d41d8cd98f00b204e9800998ecf8427e*/
+	"945399884.61923487334tuvga", /*0cc175b9c0f1b6a831c399e269772661*/
+	"abc", /*900150983cd24fb0d6963f7d28e17f72*/
+	"message digest", /*f96b697d7cb7938d525a2f31aaf161d0*/
+	"abcdefghijklmnopqrstuvwxyz", /*c3fcd3d76192e4007dfb496cca67e13b*/
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+				/*d174ab98d277d9f5a5611c2c9f419d9f*/
+	"12345678901234567890123456789012345678901234567890123456789012345678901234567890" /*57edf4a22be3c955ac49da2e2107b67a*/
+    };
+    int i;
+
+    for (i = 0; i < 7; ++i) {
+	md5_state_t state;
+	md5_byte_t digest[16];
+	int di;
+
+	md5_init(&state);
+	md5_append(&state, (const md5_byte_t *)test[i], strlen(test[i]));
+	md5_finish(&state, digest);
+	printf("MD5 (\"%s\") = ", test[i]);
+	for (di = 0; di < 16; ++di)
+	    printf("%02x", digest[di]);
+	printf("\n");
+    }
+    return 0;
+}
+#endif /* TEST */
+
+
+/*
+ * For reference, here is the program that computed the T values.
+ */
+#if 0
+#include <math.h>
+main()
+{
+    int i;
+    for (i = 1; i <= 64; ++i) {
+	unsigned long v = (unsigned long)(4294967296.0 * fabs(sin((double)i)));
+	printf("#define T%d 0x%08lx\n", i, v);
+    }
+    return 0;
+}
+#endif
+/*
+ * End of T computation program.
+ */
+#define T1 0xd76aa478
+#define T2 0xe8c7b756
+#define T3 0x242070db
+#define T4 0xc1bdceee
+#define T5 0xf57c0faf
+#define T6 0x4787c62a
+#define T7 0xa8304613
+#define T8 0xfd469501
+#define T9 0x698098d8
+#define T10 0x8b44f7af
+#define T11 0xffff5bb1
+#define T12 0x895cd7be
+#define T13 0x6b901122
+#define T14 0xfd987193
+#define T15 0xa679438e
+#define T16 0x49b40821
+#define T17 0xf61e2562
+#define T18 0xc040b340
+#define T19 0x265e5a51
+#define T20 0xe9b6c7aa
+#define T21 0xd62f105d
+#define T22 0x02441453
+#define T23 0xd8a1e681
+#define T24 0xe7d3fbc8
+#define T25 0x21e1cde6
+#define T26 0xc33707d6
+#define T27 0xf4d50d87
+#define T28 0x455a14ed
+#define T29 0xa9e3e905
+#define T30 0xfcefa3f8
+#define T31 0x676f02d9
+#define T32 0x8d2a4c8a
+#define T33 0xfffa3942
+#define T34 0x8771f681
+#define T35 0x6d9d6122
+#define T36 0xfde5380c
+#define T37 0xa4beea44
+#define T38 0x4bdecfa9
+#define T39 0xf6bb4b60
+#define T40 0xbebfbc70
+#define T41 0x289b7ec6
+#define T42 0xeaa127fa
+#define T43 0xd4ef3085
+#define T44 0x04881d05
+#define T45 0xd9d4d039
+#define T46 0xe6db99e5
+#define T47 0x1fa27cf8
+#define T48 0xc4ac5665
+#define T49 0xf4292244
+#define T50 0x432aff97
+#define T51 0xab9423a7
+#define T52 0xfc93a039
+#define T53 0x655b59c3
+#define T54 0x8f0ccc92
+#define T55 0xffeff47d
+#define T56 0x85845dd1
+#define T57 0x6fa87e4f
+#define T58 0xfe2ce6e0
+#define T59 0xa3014314
+#define T60 0x4e0811a1
+#define T61 0xf7537e82
+#define T62 0xbd3af235
+#define T63 0x2ad7d2bb
+#define T64 0xeb86d391
+
+static void
+md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
+{
+    md5_word_t
+	a = pms->abcd[0], b = pms->abcd[1],
+	c = pms->abcd[2], d = pms->abcd[3];
+    md5_word_t t;
+
+#ifndef ARCH_IS_BIG_ENDIAN
+# define ARCH_IS_BIG_ENDIAN 1	/* slower, default implementation */
+#endif
+#if ARCH_IS_BIG_ENDIAN
+
+    /*
+     * On big-endian machines, we must arrange the bytes in the right
+     * order.  (This also works on machines of unknown byte order.)
+     */
+    md5_word_t X[16];
+    const md5_byte_t *xp = data;
+    int i;
+
+    for (i = 0; i < 16; ++i, xp += 4)
+	X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
+
+#else  /* !ARCH_IS_BIG_ENDIAN */
+
+    /*
+     * On little-endian machines, we can process properly aligned data
+     * without copying it.
+     */
+    md5_word_t xbuf[16];
+    const md5_word_t *X;
+
+    if (!((data - (const md5_byte_t *)0) & 3)) {
+	/* data are properly aligned */
+	X = (const md5_word_t *)data;
+    } else {
+	/* not aligned */
+	memcpy(xbuf, data, 64);
+	X = xbuf;
+    }
+#endif
+
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+    /* Round 1. */
+    /* Let [abcd k s i] denote the operation
+       a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
+#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + F(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+    /* Do the following 16 operations. */
+    SET(a, b, c, d,  0,  7,  T1);
+    SET(d, a, b, c,  1, 12,  T2);
+    SET(c, d, a, b,  2, 17,  T3);
+    SET(b, c, d, a,  3, 22,  T4);
+    SET(a, b, c, d,  4,  7,  T5);
+    SET(d, a, b, c,  5, 12,  T6);
+    SET(c, d, a, b,  6, 17,  T7);
+    SET(b, c, d, a,  7, 22,  T8);
+    SET(a, b, c, d,  8,  7,  T9);
+    SET(d, a, b, c,  9, 12, T10);
+    SET(c, d, a, b, 10, 17, T11);
+    SET(b, c, d, a, 11, 22, T12);
+    SET(a, b, c, d, 12,  7, T13);
+    SET(d, a, b, c, 13, 12, T14);
+    SET(c, d, a, b, 14, 17, T15);
+    SET(b, c, d, a, 15, 22, T16);
+#undef SET
+
+     /* Round 2. */
+     /* Let [abcd k s i] denote the operation
+          a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + G(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  1,  5, T17);
+    SET(d, a, b, c,  6,  9, T18);
+    SET(c, d, a, b, 11, 14, T19);
+    SET(b, c, d, a,  0, 20, T20);
+    SET(a, b, c, d,  5,  5, T21);
+    SET(d, a, b, c, 10,  9, T22);
+    SET(c, d, a, b, 15, 14, T23);
+    SET(b, c, d, a,  4, 20, T24);
+    SET(a, b, c, d,  9,  5, T25);
+    SET(d, a, b, c, 14,  9, T26);
+    SET(c, d, a, b,  3, 14, T27);
+    SET(b, c, d, a,  8, 20, T28);
+    SET(a, b, c, d, 13,  5, T29);
+    SET(d, a, b, c,  2,  9, T30);
+    SET(c, d, a, b,  7, 14, T31);
+    SET(b, c, d, a, 12, 20, T32);
+#undef SET
+
+     /* Round 3. */
+     /* Let [abcd k s t] denote the operation
+          a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + H(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  5,  4, T33);
+    SET(d, a, b, c,  8, 11, T34);
+    SET(c, d, a, b, 11, 16, T35);
+    SET(b, c, d, a, 14, 23, T36);
+    SET(a, b, c, d,  1,  4, T37);
+    SET(d, a, b, c,  4, 11, T38);
+    SET(c, d, a, b,  7, 16, T39);
+    SET(b, c, d, a, 10, 23, T40);
+    SET(a, b, c, d, 13,  4, T41);
+    SET(d, a, b, c,  0, 11, T42);
+    SET(c, d, a, b,  3, 16, T43);
+    SET(b, c, d, a,  6, 23, T44);
+    SET(a, b, c, d,  9,  4, T45);
+    SET(d, a, b, c, 12, 11, T46);
+    SET(c, d, a, b, 15, 16, T47);
+    SET(b, c, d, a,  2, 23, T48);
+#undef SET
+
+     /* Round 4. */
+     /* Let [abcd k s t] denote the operation
+          a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + I(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  0,  6, T49);
+    SET(d, a, b, c,  7, 10, T50);
+    SET(c, d, a, b, 14, 15, T51);
+    SET(b, c, d, a,  5, 21, T52);
+    SET(a, b, c, d, 12,  6, T53);
+    SET(d, a, b, c,  3, 10, T54);
+    SET(c, d, a, b, 10, 15, T55);
+    SET(b, c, d, a,  1, 21, T56);
+    SET(a, b, c, d,  8,  6, T57);
+    SET(d, a, b, c, 15, 10, T58);
+    SET(c, d, a, b,  6, 15, T59);
+    SET(b, c, d, a, 13, 21, T60);
+    SET(a, b, c, d,  4,  6, T61);
+    SET(d, a, b, c, 11, 10, T62);
+    SET(c, d, a, b,  2, 15, T63);
+    SET(b, c, d, a,  9, 21, T64);
+#undef SET
+
+     /* Then perform the following additions. (That is increment each
+        of the four registers by the value it had before this block
+        was started.) */
+    pms->abcd[0] += a;
+    pms->abcd[1] += b;
+    pms->abcd[2] += c;
+    pms->abcd[3] += d;
+}
+
+void
+md5_init(md5_state_t *pms)
+{
+    pms->count[0] = pms->count[1] = 0;
+    pms->abcd[0] = 0x67452301;
+    pms->abcd[1] = 0xefcdab89;
+    pms->abcd[2] = 0x98badcfe;
+    pms->abcd[3] = 0x10325476;
+}
+
+void
+md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
+{
+    const md5_byte_t *p = data;
+    int left = nbytes;
+    int offset = (pms->count[0] >> 3) & 63;
+    md5_word_t nbits = (md5_word_t)(nbytes << 3);
+
+    if (nbytes <= 0)
+	return;
+
+    /* Update the message length. */
+    pms->count[1] += nbytes >> 29;
+    pms->count[0] += nbits;
+    if (pms->count[0] < nbits)
+	pms->count[1]++;
+
+    /* Process an initial partial block. */
+    if (offset) {
+	int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
+
+	memcpy(pms->buf + offset, p, copy);
+	if (offset + copy < 64)
+	    return;
+	p += copy;
+	left -= copy;
+	md5_process(pms, pms->buf);
+    }
+
+    /* Process full blocks. */
+    for (; left >= 64; p += 64, left -= 64)
+	md5_process(pms, p);
+
+    /* Process a final partial block. */
+    if (left)
+	memcpy(pms->buf, p, left);
+}
+
+void
+md5_finish(md5_state_t *pms, md5_byte_t digest[16])
+{
+    static const md5_byte_t pad[64] = {
+	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+    md5_byte_t data[8];
+    int i;
+
+    /* Save the length before padding. */
+    for (i = 0; i < 8; ++i)
+	data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
+    /* Pad to 56 bytes mod 64. */
+    md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+    /* Append the length. */
+    md5_append(pms, data, 8);
+    for (i = 0; i < 16; ++i)
+	digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/plugins/msn/md5.h	Thu Dec 14 08:33:41 2000 +0000
@@ -0,0 +1,94 @@
+/*
+  Copyright (C) 1999 Aladdin Enterprises.  All rights reserved.
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  L. Peter Deutsch
+  [e-mail]
+
+ */
+/*$Id: md5.h 1269 2000-12-14 08:33:41Z robflynn $ */
+/*
+  Independent implementation of MD5 (RFC 1321).
+
+  This code implements the MD5 Algorithm defined in RFC 1321.
+  It is derived directly from the text of the RFC and not from the
+  reference implementation.
+
+  The original and principal author of md5.h is L. Peter Deutsch
+  <[e-mail]>.  Other authors are noted in the change history
+  that follows (in reverse chronological order):
+
+  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
+	added conditionalization for C++ compilation from Martin
+	Purschke <[e-mail]>.
+  1999-05-03 lpd Original version.
+ */
+
+#ifndef md5_INCLUDED
+#  define md5_INCLUDED
+
+/*
+ * This code has some adaptations for the Ghostscript environment, but it
+ * will compile and run correctly in any environment with 8-bit chars and
+ * 32-bit ints.  Specifically, it assumes that if the following are
+ * defined, they have the same meaning as in Ghostscript: P1, P2, P3,
+ * ARCH_IS_BIG_ENDIAN.
+ */
+
+typedef unsigned char md5_byte_t; /* 8-bit byte */
+typedef unsigned int md5_word_t; /* 32-bit word */
+
+/* Define the state of the MD5 Algorithm. */
+typedef struct md5_state_s {
+    md5_word_t count[2];	/* message length in bits, lsw first */
+    md5_word_t abcd[4];		/* digest buffer */
+    md5_byte_t buf[64];		/* accumulate block */
+} md5_state_t;
+
+#ifdef __cplusplus
+extern "C" 
+{
+#endif
+
+/* Initialize the algorithm. */
+#ifdef P1
+void md5_init(P1(md5_state_t *pms));
+#else
+void md5_init(md5_state_t *pms);
+#endif
+
+/* Append a string to the message. */
+#ifdef P3
+void md5_append(P3(md5_state_t *pms, const md5_byte_t *data, int nbytes));
+#else
+void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
+#endif
+
+/* Finish the message and return the digest. */
+#ifdef P2
+void md5_finish(P2(md5_state_t *pms, md5_byte_t digest[16]));
+#else
+void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
+#endif
+
+#ifdef __cplusplus
+}  /* end extern "C" */
+#endif
+
+#endif /* md5_INCLUDED */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/plugins/msn/msn.c	Thu Dec 14 08:33:41 2000 +0000
@@ -0,0 +1,733 @@
+/*
+ * gaim - MSN Protocol Plugin
+ *
+ * Copyright (C) 2000, Rob Flynn <[e-mail]>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include "../config.h"
+
+#include <netdb.h>
+#include <gtk/gtk.h>
+#include <unistd.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include "multi.h"
+#include "prpl.h"
+#include "gaim.h"
+#include "gnome_applet_mgr.h"
+#include "md5.h"
+
+#define MSN_BUF_LEN 4096
+
+#define MIME_HEADER "MIME-Version: 1.0\r\nContent-Type: text/plain; charset=UTF-8\r\nX-MMS-IM-Format: FN=MS%20Sans%20Serif; EF=; CO=0; CS=0; PF=0\r\n\r\n"
+
+#define MSN_ONLINE  1
+#define MSN_BUSY    2
+#define MSN_IDLE    3
+#define MSN_BRB     4
+#define MSN_AWAY    5
+#define MSN_PHONE   6
+#define MSN_LUNCH   7
+#define MSN_OFFLINE 8
+#define MSN_HIDDEN  9
+
+
+struct msn_ask_add_permit {
+	struct gaim_connection *gc;
+	char *user;
+	char *friendly;
+};
+
+struct msn_data {
+	int fd;
+
+	char protocol[6];
+	char *friendly;
+	gchar *policy;
+};
+
+struct msn_conn {
+	gchar *user;
+	int inpa;
+	int fd;
+};
+
+void msn_handler(gpointer data, gint source, GdkInputCondition condition);
+
+GSList * msn_connections = NULL;
+
+static char *msn_name() {
+	return "MSN";
+}
+
+char *name() {
+	return "MSN";
+}
+
+char *description() {
+	return "Allows gaim to use the MSN protocol.  For some reason, this frightens me.";
+}
+
+struct msn_conn *find_msn_conn_by_user(gchar *user) {
+	struct msn_conn *mc;
+	GSList *conns = msn_connections;
+
+	while (conns) {
+		mc = (struct msn_conn *)conns->data;
+
+		if (mc != NULL) {
+			if (strcasecmp(mc->user, user) == 0) {
+				return mc;
+			}
+		}
+
+		conns = g_slist_next(conns);
+	}
+
+	return NULL;
+}
+
+void msn_read_line(char *buf, int fd) {
+
+	int status;
+	char c;
+	int i = 0;
+	
+	do {
+		status = recv(fd, &c, 1, 0);
+
+		if (!status)
+			return;
+
+		buf[i] = c;
+		i++;
+	} while (c != '\n');
+
+	buf[i] = '\0';
+	g_strchomp(buf);
+
+	/* I'm a bastard again :-) */
+	printf("MSN: %s\n", buf);
+}
+
+int msn_connect(char *server, int port) {
+	int fd;
+	struct hostent *host;
+	struct sockaddr_in site;
+
+	printf("Connecting to '%s' on '%d'\n", server, port);
+	host = gethostbyname(server);
+	if (!host) {
+		return -1;
+	}
+
+	site.sin_family = AF_INET;
+	site.sin_addr.s_addr = *(long *)(host->h_addr);
+	site.sin_port = htons(port);
+
+	fd = socket(AF_INET, SOCK_STREAM, 0);
+	if (fd < 0) {
+		return -1;
+	}
+
+	if (connect(fd, (struct sockaddr *)&site, sizeof(site)) < 0) {
+		return -1;
+	}
+
+	return fd;
+}
+
+static void msn_add_buddy(struct gaim_connection *gc, char *who) {
+	struct msn_data *mdata = (struct msn_data *)gc->proto_data;
+	time_t trId = time((time_t *)NULL);
+	gchar buf[4096];
+
+	g_snprintf(buf, 4096, "ADD %d FL %s %s\n", trId, who, who);
+	write(mdata->fd, buf, strlen(buf));
+}
+
+static void msn_rem_permit(struct gaim_connection *gc, char *who) {
+	struct msn_data *mdata = (struct msn_data *)gc->proto_data;
+	time_t trId = time((time_t *)NULL);
+	gchar buf[4096];
+
+	g_snprintf(buf, 4096, "REM %d AL %s %s\n", trId, who, who);
+	write(mdata->fd, buf, strlen(buf));
+}
+
+static void msn_add_permit(struct gaim_connection *gc, char *who) {
+	struct msn_data *mdata = (struct msn_data *)gc->proto_data;
+	time_t trId = time((time_t *)NULL);
+	gchar buf[4096];
+
+	g_snprintf(buf, 4096, "ADD %d AL %s %s\n", trId, who, who);
+	write(mdata->fd, buf, strlen(buf));
+}
+
+static void msn_remove_buddy(struct gaim_connection *gc, char *who) {
+	struct msn_data *mdata = (struct msn_data *)gc->proto_data;
+	time_t trId = time((time_t *)NULL);
+	gchar buf[4096];
+
+	g_snprintf(buf, 4096, "REM %d FL %s\n", trId, who);
+	write(mdata->fd, buf, strlen(buf));
+}
+
+void msn_accept_add_permit (gpointer w, struct msn_ask_add_permit *ap ) {
+	gchar buf[4096];
+
+	msn_add_permit(ap->gc, ap->user);
+}
+
+void msn_cancel_add_permit (gpointer w, struct msn_ask_add_permit *ap ) {
+	
+	g_free(ap->user);
+	g_free(ap->friendly);
+	g_free(ap);
+}
+
+void msn_callback (struct gaim_connection * gc, gint fd) {
+	struct msn_data *mdata;
+	char c;
+	int i = 0;
+	int status;
+	gchar buf[4096];
+	gchar **resps;
+	
+	mdata = (struct msn_data *)gc->proto_data;
+
+	do {
+		/* Read data from whatever connection our inpa
+		 * refered us from */
+		status = recv(fd, &c, 1,0);
+
+		if (!status)
+			return;
+
+		buf[i] = c;
+		i++;	
+	} while (c != '\n');
+
+	buf[i] = '\0';
+
+	g_strchomp(buf);
+
+	printf("MSN: %s\n", buf);
+
+	if (strlen(buf) == 0) { return; }
+	
+	resps = g_strsplit(buf, " ", 0);
+
+	/* See if someone is bumping us */
+	if (strcasecmp(resps[0], "BYE") == 0) {
+		struct msn_conn *mc;
+		GSList * conns = msn_connections;
+		
+		/* Yup.  Let's find their convo and kill it */
+
+		mc = find_msn_conn_by_user(resps[1]);
+
+		/* If we have the convo, remove it */
+		if (mc != NULL) {
+			/* and remove it */
+			conns = g_slist_remove(conns, mc);
+
+			g_free(mc->user);
+			gdk_input_remove(mc->inpa);
+			close(mc->fd);
+
+
+			g_free(mc);
+		}
+
+		g_strfreev(resps);
+		return;
+	}
+
+	if (strcasecmp(resps[0], "ADD") == 0) {
+		
+		if (strcasecmp(resps[2], "RL") == 0) {
+			gchar buf[4096];
+			struct msn_ask_add_permit *ap = g_new0(struct msn_ask_add_permit, 1);
+		       
+			g_snprintf(buf, 4096, "The user %s (%s) wants to add you to their buddylist.", resps[4], resps[5]);
+
+			ap->user = g_strdup(resps[4]);
+			ap->friendly = g_strdup(resps[5]);
+			ap->gc = gc;
+
+			do_ask_dialog(buf, ap, (GtkFunction)msn_accept_add_permit, (GtkFunction)msn_cancel_add_permit);
+		}
+
+		g_strfreev(resps);
+		return;
+	}
+
+	if (strcasecmp(resps[0], "REM") == 0) {
+		
+		if (strcasecmp(resps[2], "RL") == 0) {
+			msn_rem_permit(gc, resps[4]);
+		}
+
+		g_strfreev(resps);
+		return;
+	}
+	
+	if (strcasecmp(resps[0], "FLN") == 0) {
+		serv_got_update(gc, resps[1], 0, 0, 0, 0, MSN_OFFLINE, 0);
+	}
+
+	if (strcasecmp(resps[0], "ILN") == 0) {
+		int status;
+
+		if (!strcasecmp(resps[2], "NLN"))
+			status = MSN_ONLINE;
+		else if (!strcasecmp(resps[2], "BSY"))
+			status = MSN_BUSY;
+		else if (!strcasecmp(resps[2], "IDL"))
+			status = MSN_IDLE;
+		else if (!strcasecmp(resps[2], "BRB"))
+			status = MSN_BRB;
+		else if (!strcasecmp(resps[2], "AWY"))
+			status = MSN_AWAY;
+		else if (!strcasecmp(resps[2], "PHN"))
+			status = MSN_PHONE;
+		else if (!strcasecmp(resps[2], "LUN"))
+			status = MSN_LUNCH;
+		else
+			status = MSN_ONLINE;
+
+		serv_got_update(gc, resps[3], 1, 0, 0, 0, status, 0);
+
+		g_strfreev(resps);
+		return;
+		
+	}
+	
+	/* Check buddy update status */
+	if (strcasecmp(resps[0], "NLN") == 0) { 
+		/* FIXME: We currently dont care if they are busy,
+		 * idle, brb, away, phone, our out to lunch. This will
+		 * be supported eventually (BSY,IDL,BRB,AWY,PHN,LUN) 
+		 * respectively */
+
+		serv_got_update(gc, resps[2], 1, 0, 0, 0, MSN_ONLINE, 0);
+	}
+	
+	/* Check to see if we have an incoming buddylist */
+	if (strcasecmp(resps[0], "LST") == 0) { 
+		/* Check to see if there are any buddies in the list */
+		if (atoi(resps[5]) == 0) {
+			/* No buddies */
+			g_strfreev(resps);
+			return;
+		}
+
+		/* FIXME: We should support the permit and deny
+		 * lists as well */
+
+		if (strcasecmp(resps[2], "FL") == 0) {
+			struct buddy *b;
+
+			b = find_buddy(gc, resps[6]);
+
+			if (!b)
+				add_buddy(gc, "Buddies", resps[6], resps[6]);
+		}
+		
+		g_strfreev(resps);
+		return;
+	}
+	
+	/* Check to see if we got a message request */
+	if (strcasecmp(resps[0], "MSG") == 0) {
+		gchar *message;
+		gchar *buf2;
+		int size;
+		int status;
+		
+		/* Determine our message size */
+		size = atoi(resps[3]);
+
+		buf2 = (gchar *)g_malloc(sizeof(gchar) * (size+1));
+		status = recv(fd, buf2, size, 0);
+		buf2[size] = 0;
+
+		/* Looks like we got the message. If it's blank, let's bail */
+		if (strcasecmp(strstr(buf2, "\r\n\r\n")+4, "\r\n") == 0) {
+			g_free(buf2);
+			g_strfreev(resps);
+			return;
+		}
+
+		serv_got_im(gc, resps[1], strstr(buf2, "\r\n\r\n")+4, 0);
+
+		g_free(buf2);
+		g_strfreev(resps);
+		return;
+	}
+	
+
+	/* Check to see if we got a ring request */
+	if (strcasecmp(resps[0], "RNG") == 0) {
+		gchar **address;
+		struct msn_conn *mc = g_new0(struct msn_conn, 1);
+
+		address = g_strsplit(resps[2], ":", 0);
+
+		if (!(mc->fd = msn_connect(address[0], atoi(address[1])))) {
+			do_error_dialog(resps[5], "Msg Err from");
+			g_strfreev(address);
+			g_strfreev(resps);
+			g_free(mc);
+			return;
+		}
+
+		mc->user = g_strdup(resps[5]);
+
+		mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_READ, msn_handler, gc);
+		
+		g_snprintf(buf, 4096, "ANS 1 %s %s %s\n", gc->username, resps[4], resps[1]);
+		write(mc->fd, buf, strlen(buf));
+
+		msn_connections = g_slist_append(msn_connections, mc);
+
+		g_strfreev(address);
+		g_strfreev(resps);
+		return;
+	}
+
+	g_strfreev(resps);
+
+}
+
+
+void msn_handler(gpointer data, gint source, GdkInputCondition condition) {
+	msn_callback(data, source);
+}
+
+void msn_login(struct aim_user *user) {
+	time_t trId = time((time_t *)NULL);
+	char buf[4096];
+	char buf2[4096];
+	
+	struct gaim_connection *gc = new_gaim_conn(user);
+	struct msn_data *mdata = gc->proto_data = g_new0(struct msn_data, 1);
+	char c;
+	int i;
+	int status;
+
+	md5_state_t st;
+	md5_byte_t di[16];
+	int x;
+
+	gchar **results;
+
+	g_snprintf(mdata->protocol, strlen("MSNP2")+1, "MSNP2");
+	
+	set_login_progress(gc, 1,"Connecting");
+
+	while (gtk_events_pending())
+		gtk_main_iteration();
+	if (!g_slist_find(connections, gc))
+		return;
+
+	if (!(mdata->fd = msn_connect("messenger.hotmail.com", 1863))) {
+		hide_login_progress(gc, "Error connection to server");
+		signoff(gc);
+		return;	
+	}
+	
+	g_snprintf(buf, sizeof(buf), "Signon: %s", gc->username);
+	set_login_progress(gc, 2, buf);
+
+	/* This is where we will attempt to sign on */
+	g_snprintf(buf, 4096, "VER %d %s\n", trId, mdata->protocol);
+	write(mdata->fd, buf, strlen(buf));
+
+	msn_read_line(&buf2, mdata->fd);
+
+	buf[strlen(buf)-1] = '\0';
+	if (strcmp(buf, buf2) != 0) {
+		hide_login_progress(gc, buf2);
+		signoff(gc);
+		return;
+	}
+
+	/* Looks like our versions matched up.  Let's find out
+	 * which policy we should use */
+
+	g_snprintf(buf, 4096, "INF %d\n", trId);
+	write(mdata->fd, buf, strlen(buf));
+
+	msn_read_line(&buf2, mdata->fd);
+	results = g_strsplit(buf2, " ", 0);
+	mdata->policy = g_strdup(results[2]);
+	g_strfreev(results);
+
+	/* We've set our policy.  Now, lets attempt a sign on */
+	g_snprintf(buf, 4096, "USR %d %s I %s\n", trId, mdata->policy, gc->username);	
+	write(mdata->fd, buf, strlen(buf));
+
+	msn_read_line(&buf2, mdata->fd);
+
+	/* This is where things get kinky */
+	results = g_strsplit(buf2, " ", 0);
+
+	/* Are we being transfered to another server ?  */
+	if (strcasecmp(results[0], "XFR") == 0) {
+		/* Yup.  We should connect to the _new_ server */
+		strcpy(buf, results[3]);
+		g_strfreev(results);
+
+		results = g_strsplit(buf, ":", 0);
+
+		/* Connect to the new server */
+		if (!(mdata->fd = msn_connect(results[0], atoi(results[1])))) {
+			hide_login_progress(gc, "Error connecting to server");
+			signoff(gc);
+			g_strfreev(results);
+			return;	
+		}
+
+
+		g_strfreev(results);
+
+		/* We're now connected to the new server.  Send signon
+		 * information again */
+		g_snprintf(buf, 4096, "USR %d %s I %s\n", trId, mdata->policy, gc->username);	
+		write(mdata->fd, buf, strlen(buf));
+
+		msn_read_line(&buf, mdata->fd);
+		results = g_strsplit(buf, " ", 0);
+
+	}
+	
+	/* Otherwise, if we have a USR response, let's handle it */
+	if (strcasecmp("USR", results[0]) == 0) {
+		/* Looks like we got a response.  Let's get our challenge
+		 * string */
+		strcpy(buf, results[4]);
+
+	}
+	else {
+		g_strfreev(results);
+		hide_login_progress(gc, "Error signing on");
+		signoff(gc);
+		return;
+	}
+	g_strfreev(results);
+
+	/* Build our response string */
+	snprintf(buf2, 4096, "%s%s", buf, gc->password);
+
+	/* Use the MD5 Hashing */
+	md5_init(&st);
+	md5_append(&st, (const md5_byte_t *)buf2, strlen(buf2));
+	md5_finish(&st, di);
+
+	/* And now encode it in hex */
+	sprintf(buf, "%02x", di[0]);
+	for (x = 1; x < 16; x++) {
+		sprintf(buf, "%s%02x", buf, di[x]);
+	}
+
+	/* And now we should fire back a response */
+	g_snprintf(buf2, 4096, "USR %d %s S %s\n", trId, mdata->policy, buf);
+	write(mdata->fd, buf2, strlen(buf2));
+
+
+	msn_read_line(&buf, mdata->fd);
+
+	results = g_strsplit(buf, " ", 0);
+
+	if ((strcasecmp("USR", results[0]) == 0) && (strcasecmp("OK", results[2]) == 0)) {
+		mdata->friendly = g_strdup(results[4]);
+		g_strfreev(results);
+	}
+	else {
+		g_strfreev(results);
+		hide_login_progress(gc, "Error signing on!");
+		signoff(gc);
+		return;
+
+	}
+	set_login_progress(gc, 3, "Getting Config");
+	g_snprintf(buf, 4096, "SYN %d 0\n", trId);
+	write(mdata->fd, buf, strlen(buf));
+
+	/* Go online */
+	g_snprintf(buf, 4096, "CHG %d NLN\n", trId);
+	write(mdata->fd, buf, strlen(buf));
+
+	account_online(gc);
+	serv_finish_login(gc);
+
+	if (bud_list_cache_exists(gc))
+		do_import(NULL, gc);
+
+	/* We want to do this so that we can read what's going on */
+	gc->inpa = gdk_input_add(mdata->fd, GDK_INPUT_READ, msn_handler, gc);
+}
+
+void msn_send_im(struct gaim_connection *gc, char *who, char *message, int away) {
+	struct msn_conn *mc;
+	struct msn_data *mdata;
+	time_t trId = time((time_t *)NULL);
+	char *buf;
+
+	mdata = (struct msn_data *)gc->proto_data;
+	mc = find_msn_conn_by_user(who);
+
+	if (mc == NULL)
+	{
+		gchar buf2[4096];
+		gchar *address;
+		gchar *auth;
+		gchar **resps;
+
+		/* Request a new switchboard connection */
+		g_snprintf(buf2, 4096, "XFR %d SB\n", trId);
+		write(mdata->fd, buf2, strlen(buf2));
+		
+		/* Read the results */
+		msn_read_line(&buf2, mdata->fd);
+
+		resps = g_strsplit(buf2, " ", 0);
+
+		address = g_strdup(resps[3]);
+		auth = g_strdup(resps[5]);
+		g_strfreev(resps);
+
+		resps = g_strsplit(address, ":", 0);
+
+		mc = g_new0(struct msn_conn, 1);
+
+		if (!(mc->fd = msn_connect(resps[0], atoi(resps[1])))) {
+			g_strfreev(resps);
+			g_free(address);
+			g_free(auth);
+			g_free(mc);
+			return;
+		}
+
+		/* Looks like we got connected ok. Now, let's verify */
+		g_snprintf(buf2, 4096, "USR %d %s %s\n", trId, gc->username, auth);
+		write(mc->fd, buf2, strlen(buf2));
+
+		/* Read the results */
+		msn_read_line(&buf2, mc->fd);
+		g_strfreev(resps);
+		
+		resps = g_strsplit(buf2, " ", 0);
+		
+		if (!(strcasecmp("OK", resps[2]) == 0)) {
+			g_free(auth);
+			g_free(address);
+			g_strfreev(resps);
+			g_free(mc);
+			return;
+		}
+
+		mc->user = g_strdup(who);
+		mc->inpa = gdk_input_add(mc->fd, GDK_INPUT_READ, msn_handler, gc);
+
+		msn_connections = g_slist_append(msn_connections, mc);
+
+		/* Now we must invite our new user to the switchboard session */
+		g_snprintf(buf2, 4096, "CAL %d %s\n", trId, who);
+		write(mc->fd, buf2, strlen(buf2));
+
+		/* FIXME: This causes a delay.  I will make some sort of queing feature to prevent
+		 * this from being needed */
+
+		while (!strstr(buf2, "JOI")) {
+			msn_read_line(&buf2, mc->fd);
+		}
+		
+		g_free(auth);
+		g_free(address);
+		g_strfreev(resps);
+
+	}
+
+	/* Always practice safe sets :-) */ 
+	buf = (gchar *)g_malloc(sizeof(gchar) * (strlen(message) + strlen(MIME_HEADER) + 64));
+
+	g_snprintf(buf, strlen(message) + strlen(MIME_HEADER) + 64, "MSG %d N %d\r\n%s%s", trId, strlen(message)+strlen(MIME_HEADER), MIME_HEADER, message);
+
+	write(mc->fd, buf, strlen(buf));
+
+	g_free(buf);
+}
+
+static struct prpl *my_protocol = NULL;
+
+void msn_init(struct prpl *ret) {
+	ret->protocol = PROTO_MSN;
+	ret->name = msn_name;
+	ret->list_icon = NULL;
+	ret->action_menu = NULL;
+	ret->user_opts = NULL;
+	ret->login = msn_login;
+	ret->close = NULL;
+	ret->send_im = msn_send_im;
+	ret->set_info = NULL;
+	ret->get_info = NULL;
+	ret->set_away = NULL;
+	ret->get_away_msg = NULL;
+	ret->set_dir = NULL;
+	ret->get_dir = NULL;
+	ret->dir_search = NULL;
+	ret->set_idle = NULL;
+	ret->change_passwd = NULL;
+	ret->add_buddy = msn_add_buddy;
+	ret->add_buddies = NULL;
+	ret->remove_buddy = msn_remove_buddy;
+	ret->add_permit = msn_add_permit;
+	ret->rem_permit = msn_rem_permit;
+	ret->add_deny = NULL;
+	ret->warn = NULL;
+	ret->accept_chat = NULL;
+	ret->join_chat = NULL;
+	ret->chat_invite = NULL;
+	ret->chat_leave = NULL;
+	ret->chat_whisper = NULL;
+	ret->chat_send = NULL;
+	ret->keepalive = NULL;
+
+	my_protocol = ret;
+}
+
+char *gaim_plugin_init(GModule *handle) {
+	load_protocol(msn_init);
+	return NULL;
+}
+
+void gaim_plugin_remove() {
+	struct prpl *p = find_prpl(PROTO_MSN);
+	if (p == my_protocol)
+		unload_protocol(p);
+}