Attachment #97963 for bug #138740

Lines 25-43 Link Here

(-)centericq-4.21.0.orig/libmsn-0.1/msn/connection.cpp (-23 / +36 lines)
25	#include <msn/util.h>	25	#include <msn/util.h>
26	#include <msn/passport.h>	26	#include <msn/passport.h>
27	#include <msn/externals.h>	27	#include <msn/externals.h>
		28	#include <msn/notificationserver.h>
28		29
29	#ifndef WIN32	30	#ifndef WIN32
30	#include <sys/socket.h>
31	#include <unistd.h>	31	#include <unistd.h>
		32	#include <sys/types.h>
		33	#include <sys/time.h>
		34	#include <sys/socket.h>
32	#else	35	#else
33	#include <winsock.h>	36	#include <winsock.h>
34	#include <io.h>	37	#include <io.h>
35	#endif	38	#endif
36		39
37	#include <stdlib.h>	40	#include <stdlib.h>
		41	#include <stdio.h>
		42	#include <cerrno>
38	#include <time.h>	43	#include <time.h>
39	#include <cassert>	44	#include <cassert>
40	#include <cerrno>
41		45
42	namespace MSN	46	namespace MSN
43	{	47	{
Lines 45-51 Link Here
45	static std::vector<std::string> errors;	49	static std::vector<std::string> errors;
46		50
47	Connection::Connection()	51	Connection::Connection()
48	: sock(0), connected(false), trid(1), user_data(NULL)	52	: sock(0), connected(false), trID(1), user_data(NULL)
49	{	53	{
50	srand((unsigned int) time(NULL));	54	srand((unsigned int) time(NULL));
51		55
Lines 112-126 Link Here
112		116
113	void Connection::disconnect()	117	void Connection::disconnect()
114	{	118	{
115	ext::unregisterSocket(this->sock);	119	this->myNotificationServer()->externalCallbacks.unregisterSocket(this->sock);
116	::close(this->sock);	120	::close(this->sock);
		121	this->sock = -1;
		122	this->writeBuffer.erase();
		123	this->readBuffer.erase();
		124	this->trID = 1;
117	}	125	}
118		126
119	std::vector<std::string> Connection::getLine()	127	std::vector<std::string> Connection::getLine()
120	{	128	{
121	assert(this->isWholeLineAvailable());	129	assert(this->isWholeLineAvailable());
122	std::string s = this->readBuffer.substr(0, this->readBuffer.find("\r\n"));	130	std::string s = this->readBuffer.substr(0, this->readBuffer.find("\r\n"));
123	ext::log(0, (s + "\n").c_str());	131	this->myNotificationServer()->externalCallbacks.log(0, (s + "\n").c_str());
124	return splitString(s, " ");	132	return splitString(s, " ");
125	}	133	}
126		134
Lines 131-137 Link Here
131		139
132	void Connection::errorOnSocket(int errno_)	140	void Connection::errorOnSocket(int errno_)
133	{	141	{
134	ext::showError(this, strerror(errno_));	142	this->myNotificationServer()->externalCallbacks.showError(this, strerror(errno_));
135	this->disconnect();	143	this->disconnect();
136	}	144	}
137		145
Lines 140-147 Link Here
140	this->connected = true;	148	this->connected = true;
141		149
142	// We know that we are connected, so this will try writing to the network.	150	// We know that we are connected, so this will try writing to the network.
143	this->write(this->writeBuffer, 1);	151	size_t writtenLength = this->write(this->writeBuffer, 1);
144	this->writeBuffer = "";	152	this->writeBuffer = this->writeBuffer.substr(writtenLength);
145	}	153	}
146		154
147	size_t Connection::write(std::string s, bool log) throw (std::runtime_error)	155	size_t Connection::write(std::string s, bool log) throw (std::runtime_error)
Lines 151-162 Link Here
151	else	159	else
152	{	160	{
153	if (log)	161	if (log)
154	ext::log(1, s.c_str());	162	this->myNotificationServer()->externalCallbacks.log(1, s.c_str());
155		163
156	size_t written = 0;	164	size_t written = 0;
157	while (written < s.size())	165	while (written < s.size())
158	{	166	{
159	size_t newWritten = ::write(this->sock, s.substr(written).c_str(), (int) (s.size() - written));	167	size_t newWritten = ::send(this->sock, s.substr(written).c_str(), (int) (s.size() - written), 0);
160	if (newWritten <= 0)	168	if (newWritten <= 0)
161	{	169	{
162	if (errno == EAGAIN)	170	if (errno == EAGAIN)
Lines 167-173 Link Here
167	written += newWritten;	175	written += newWritten;
168	}	176	}
169	if (written != s.size())	177	if (written != s.size())
170	throw std::runtime_error(strerror(errno));	178	{
		179	this->errorOnSocket(errno);
		180	return written;
		181	}
171	}	182	}
172	return s.size();	183	return s.size();
173	}	184	}
Lines 176-202 Link Here
176	{	187	{
177	std::string s = ss.str();	188	std::string s = ss.str();
178	size_t result = write(s, log);	189	size_t result = write(s, log);
179	ss.clear();
180	return result;	190	return result;
181	}	191	}
182		192
183	void Connection::dataArrivedOnSocket()	193	void Connection::dataArrivedOnSocket()
184	{	194	{
185	char tempReadBuffer[8192];	195	char tempReadBuffer[8192];
186	int amountRead = ::read(this->sock, &tempReadBuffer, 8192);	196	int amountRead = ::recv(this->sock, &tempReadBuffer, 8192, 0);
187	if (amountRead < 0)	197	if (amountRead < 0)
188	{	198	{
		199	if (errno == EAGAIN)
		200	return;
		201
189	// We shouldn't get EAGAIN here because dataArrivedOnSocket	202	// We shouldn't get EAGAIN here because dataArrivedOnSocket
190	// is only called when select/poll etc has told us that	203	// is only called when select/poll etc has told us that
191	// the socket is readable.	204	// the socket is readable.
192	assert(errno != EAGAIN);	205	// assert(errno != EAGAIN);
193		206
194	ext::showError(this, strerror(errno));	207	this->myNotificationServer()->externalCallbacks.showError(this, strerror(errno));
195	this->disconnect();	208	this->disconnect();
196	}	209	}
197	else if (amountRead == 0)	210	else if (amountRead == 0)
198	{	211	{
199	ext::showError(this, "Connection closed by remote endpoint.");	212	this->myNotificationServer()->externalCallbacks.showError(this, "Connection closed by remote endpoint.");
200	this->disconnect();	213	this->disconnect();
201	}	214	}
202	else	215	else
Lines 208-214 Link Here
208	}	221	}
209	catch (std::exception & e)	222	catch (std::exception & e)
210	{	223	{
211	ext::showError(this, e.what());	224	this->myNotificationServer()->externalCallbacks.showError(this, e.what());
212	}	225	}
213	}	226	}
214	}	227	}
Lines 244-250 Link Here
244	{	257	{
245	Message msg = Message(body, mime);	258	Message msg = Message(body, mime);
246		259
247	ext::gotInstantMessage(static_cast<SwitchboardServerConnection *>(this),	260	this->myNotificationServer()->externalCallbacks.gotInstantMessage(static_cast<SwitchboardServerConnection *>(this),
248	args[1], decodeURL(args[2]), &msg);	261	args[1], decodeURL(args[2]), &msg);
249	}	262	}
250		263
Lines 265-271 Link Here
265	if (! unreadFolder.empty())	278	if (! unreadFolder.empty())
266	unreadFolderCount = decimalFromString(unreadFolder);	279	unreadFolderCount = decimalFromString(unreadFolder);
267		280
268	ext::gotInitialEmailNotification(this, unreadInboxCount, unreadFolderCount);	281	this->myNotificationServer()->externalCallbacks.gotInitialEmailNotification(this, unreadInboxCount, unreadFolderCount);
269	}	282	}
270		283
271		284
Lines 277-283 Link Here
277	std::string from = headers["From-Addr"];	290	std::string from = headers["From-Addr"];
278	std::string subject = headers["Subject"];	291	std::string subject = headers["Subject"];
279		292
280	ext::gotNewEmailNotification(this, from, subject);	293	this->myNotificationServer()->externalCallbacks.gotNewEmailNotification(this, from, subject);
281	}	294	}
282		295
283		296
Lines 288-300 Link Here
288		301
289	void Connection::message_typing_user(std::vector<std::string> & args, std::string mime, std::string body)	302	void Connection::message_typing_user(std::vector<std::string> & args, std::string mime, std::string body)
290	{	303	{
291	ext::buddyTyping(this, args[1], decodeURL(args[2]));	304	this->myNotificationServer()->externalCallbacks.buddyTyping(this, args[1], decodeURL(args[2]));
292	}	305	}
293		306
294	void Connection::showError(int errorCode)	307	void Connection::showError(int errorCode)
295	{	308	{
296	std::ostringstream buf_;	309	std::ostringstream buf_;
297	buf_ << "An error has occurred while communicating with the MSN Messenger server: " << errors[errorCode] << " (code " << errorCode << ")";	310	buf_ << "Error code: " << errorCode << " (" << errors[errorCode] << ")";
298	ext::showError(this, buf_.str());	311	this->myNotificationServer()->externalCallbacks.showError(this, buf_.str());
299	}	312	}
300	}	313	}

Lines 35-40 Link Here

(-)centericq-4.21.0.orig/libmsn-0.1/msn/connection.h (-1 / +4 lines)
35	class callback;	35	class callback;
36	class Message;	36	class Message;
37	class Passport;	37	class Passport;
		38	class NotificationServerConnection;
38		39
39	/** An abstract base class that represents a connection to another computer.	40	/** An abstract base class that represents a connection to another computer.
40	*	41	*
Lines 68-74 Link Here
68	protected:	69	protected:
69	/** The transaction ID of the next command to be sent.	70	/** The transaction ID of the next command to be sent.
70	*/	71	*/
71	int trid;	72	int trID;
72		73
73	std::string readBuffer;	74	std::string readBuffer;
74	public:	75	public:
Lines 143-148 Link Here
143	/** Is this Connection connected to a remote endpoint?	144	/** Is this Connection connected to a remote endpoint?
144	*/	145	*/
145	bool isConnected() { return this->connected; };	146	bool isConnected() { return this->connected; };
		147	virtual NotificationServerConnection *myNotificationServer() = 0;
		148
146	protected:	149	protected:
147	/** Process a @c <code>MSG</code> command.	150	/** Process a @c <code>MSG</code> command.
148	*	151	*




#include <list>
#include <msn/switchboardserver.h>

/** \mainpage libmsn 3.2 Reference
 *
 * <code>libmsn</code> is a C++ library for Microsoft's MSN Messenger service. It
 * provides a high-level interface that allows an application to access instant
 * messaging features with ease.  For more information, please visit the
 * <a href='http://libmsn.bdash.net.nz'><code>libmsn</code></a> homepage.
 *
 * It is recommended that you read the
 * <a href='http://libmsn.bdash.net.nz/overview.php'>library overview</a>
 * before reading the reference documentation.  The library overview will
 * familiarise you with the architecture and core data-types of <code>libmsn</code>,
 * and will make the reference documentation much more understandable.




{
    class ListSyncInfo;
    
    class Callbacks
    {
    public:
        virtual void registerSocket(int s, int read, int write) = 0;
        virtual void unregisterSocket(int s) = 0;
        
        virtual void showError(MSN::Connection * conn, std::string msg) = 0;
        
        virtual void buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::BuddyStatus state) = 0;
        virtual void buddyOffline(MSN::Connection * conn, MSN::Passport buddy) = 0;
        
        virtual void log(int writing, const char* buf) = 0;
        
        virtual void gotFriendlyName(MSN::Connection * conn, std::string friendlyname) = 0;
        virtual void gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data) = 0;
        virtual void gotLatestListSerial(MSN::Connection * conn, int serial) = 0;
        virtual void gotGTC(MSN::Connection * conn, char c) = 0;
        virtual void gotBLP(MSN::Connection * conn, char c) = 0;
        
        virtual void gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname) = 0;
        
        virtual void addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID) = 0;
        
        virtual void removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID) = 0;
        
        virtual void addedGroup(MSN::Connection * conn, std::string groupName, int groupID) = 0;
        virtual void removedGroup(MSN::Connection * conn, int groupID) = 0;
        virtual void renamedGroup(MSN::Connection * conn, int groupID, std::string newGroupName) = 0;
        
        virtual void gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag) = 0;
        
        virtual void buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial) = 0;
        
        virtual void buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy) = 0;
        
        virtual void gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg) = 0;
        
        virtual void failedSendingMessage(MSN::Connection * conn) = 0;
        
        virtual void buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname) = 0;
        
        virtual void gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders) = 0;
        
        virtual void gotNewEmailNotification(MSN::Connection * conn, std::string from, std::string subject) = 0;
        
        virtual void gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv) = 0;
        
        virtual void fileTransferProgress(MSN::FileTransferInvitation * inv, std::string status, unsigned long recv, unsigned long total) = 0;
        
        virtual void fileTransferFailed(MSN::FileTransferInvitation * inv, int error, std::string message) = 0;
        
        virtual void fileTransferSucceeded(MSN::FileTransferInvitation * inv) = 0;
        
        virtual void gotNewConnection(MSN::Connection * conn) = 0;
        
        virtual void closingConnection(MSN::Connection * conn) = 0;
        
        virtual void changedStatus(MSN::Connection * conn, MSN::BuddyStatus state) = 0;
        
        virtual int connectToServer(std::string server, int port, bool *connected) = 0;
        
        virtual int listenOnPort(int port) = 0;
        
        virtual std::string getOurIP() = 0;
        
        virtual std::string getSecureHTTPProxy() = 0;
    };
}
#endif




#include <msn/message.h>
#include <msn/errorcodes.h>
#include <msn/externals.h>
#include <msn/notificationserver.h>

#ifndef WIN32
#include <unistd.h>
#include <time.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#else
#include <winsock.h>
#include <io.h>
#endif

#include <cassert>
#include <cerrno>
#include <cassert>

namespace MSN 
{

    
    void FileTransferInvitation::invitationWasCanceled(const std::string & body)
    {
        this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferFailed(this, 0, "Cancelled by remote user");
        if (this->invitationWasSent())
        {
            this->switchboardConnection->invitationsSent.remove(this);

                                                                                 std::string(tmp), FileTransferConnection::MSNFTP_SEND, this);
        FileTransferConnection * conn = new FileTransferConnection(auth);
        
        this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferProgress(this, "Sending IP address", 0, 0);
        
        while((conn->sock = this->switchboardConnection->myNotificationServer()->externalCallbacks.listenOnPort(port)) < 0)
        {
            port++;
            if (port > 6911)
            {
                this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferFailed(this, errno, strerror(errno));
                this->switchboardConnection->invitationsSent.remove(this);
                conn->disconnect();
                return;
            }
        }
        
        this->switchboardConnection->myNotificationServer()->externalCallbacks.registerSocket(conn->sock, 1, 0);
        
        this->switchboardConnection->addFileTransferConnection(conn);
        
        std::ostringstream buf_;
        buf_ << "Invitation-Command: ACCEPT\r\n";
        buf_ << "Invitation-Cookie: " << this->cookie << "\r\n";
        buf_ << "IP-Address: " << this->switchboardConnection->myNotificationServer()->externalCallbacks.getOurIP() << "\r\n";
        buf_ << "Port: " << port << "\r\n";
        buf_ << "AuthCookie: " << conn->auth.cookie << "\r\n";
        buf_ << "Launch-Application: FALSE\r\n";

        
        if (cookie.empty() || remote.empty() || port_c.empty())
        {
            this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferFailed(this, 0, "Missing parameters");
            this->switchboardConnection->invitationsReceived.remove(this);
            return;
        }

        
        std::ostringstream buf_;
        buf_ << "Connecting to " << remote << ":" << port << "\n";
        this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferProgress(this, buf_.str(), 0, 0);
        
        conn->sock = this->switchboardConnection->myNotificationServer()->externalCallbacks.connectToServer(remote, port, &conn->connected);
        
        if (conn->sock < 0)
        {
            this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferFailed(this, errno, strerror(errno));
            this->switchboardConnection->invitationsReceived.remove(this);
            return;
        }

        if (! conn->isConnected())
            this->switchboardConnection->myNotificationServer()->externalCallbacks.registerSocket(conn->sock, 0, 1);
        else
            this->switchboardConnection->myNotificationServer()->externalCallbacks.registerSocket(conn->sock, 1, 0);
        
        this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferProgress(this, "Connected", 0, 0);
        this->switchboardConnection->addFileTransferConnection(conn);
        
        conn->write("VER MSNFTP\r\n");

    
    void FileTransferConnection::disconnect()
    {
        Connection::disconnect();
        
        if (this->auth.fd)
        {
            fclose(this->auth.fd);
            this->auth.fd = NULL;
        }
        
        this->auth.inv->switchboardConnection->removeFileTransferConnection(this);
        delete this->auth.inv;
        this->auth.inv = NULL;
        Connection::disconnect();
    }
    
    FileTransferConnection::~FileTransferConnection()

    void FileTransferConnection::socketConnectionCompleted()
    {
        Connection::socketConnectionCompleted();
        this->myNotificationServer()->externalCallbacks.unregisterSocket(this->sock);
        this->myNotificationServer()->externalCallbacks.registerSocket(this->sock, 1, 0);
    }    
    
    void FileTransferConnection::socketIsWritable()

        if ((s = accept(this->sock, NULL, NULL)) < 0)
        {
            perror("Could not accept()\n");
            this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
            this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);
            return;
        }
        
        this->myNotificationServer()->externalCallbacks.unregisterSocket(this->sock);
        close(this->sock);
        
        this->sock = s;
        this->myNotificationServer()->externalCallbacks.registerSocket(this->sock, 1, 0);
        
        this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Connected", 0, 0);
        
        this->auth.connected = 1;
        this->connected = true;        

                
        if (args[0] == "VER")
        {
            if (this->write("VER MSNFTP\r\n") != strlen("VER MSNFTP\r\n"))
                return;
            this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Negotiating", 0, 0);
        }
        else if (args[0] == "USR")
        {
            if (args[2] != this->auth.cookie)  // if they DIFFER
            {
                this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
                this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);
                return;
            }

            if (this->auth.fd == NULL)
            {
                perror("fopen() failed");
                this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, "Could not open file for reading");
                this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);
                return;
            }
            
            // OK, now we lose control, but the next round of the polling loop will
            // say that the socket is writable, and then the fun starts...
            this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Sending data", 0, 0);
            this->myNotificationServer()->externalCallbacks.unregisterSocket(this->sock);
            this->myNotificationServer()->externalCallbacks.registerSocket(this->sock, 0, 1);                        
        }
    }
    

            blockHeader[1] = (blockLength >> 0) & 0xff;
            blockHeader[2] = (blockLength >> 8) & 0xff;
            
            if (this->write(std::string((char *) &blockHeader[bytesWritten], 3 - bytesWritten), false) != 3)
            {
                this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
                goto cleanup;
            }
            
            if (fread(readBuffer, sizeof(unsigned char), blockLength, this->auth.fd) < 0)
            {
                this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
                goto cleanup;
            }
            
            if ((blockLength = this->write(std::string((char *) readBuffer, blockLength), false)) < 0)
            {
                this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
                goto cleanup;
            }
            this->auth.bytes_done += blockLength;
        }
        free(readBuffer);
        this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Sending file", this->auth.bytes_done, this->auth.inv->fileSize);
        return;
cleanup:
            ;
        this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);
        if (readBuffer)
            free(readBuffer);
        if (this->auth.fd)
        {
            fclose(this->auth.fd);
            this->auth.fd = NULL;
        }
    }
    
    void FileTransferConnection::handleSend_Bye()
    {
        this->myNotificationServer()->externalCallbacks.fileTransferSucceeded(this->auth.inv);
            return;
        
        std::vector<std::string> args;
        ext::fileTransferSucceeded(this->auth.inv);
        
        this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);
        this->disconnect();

        if (args.size() > 0)
        {
            printf("%s", args[0].c_str());
            if (args.size() > 1)
                printf(" %s", args[1].c_str());
            printf("\n");
        }
        
        this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);        
    }
    
    

            std::ostringstream buf_;
            buf_ << "USR " << this->auth.username << " " << this->auth.cookie << "\r\n";
            this->write(buf_);
            this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Negotiating", 0, 0);
            return;
        } 
        else if (args[0] == "FIL")

        return;
error:
            ;
        this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
        this->switchboardConnection()->invitationsReceived.remove(this->auth.inv);
    }
    

                // Transfer completed block
                if (blockHeader[1] != 0 || blockHeader[2] != 0)
                {
                    this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, 0, "Invalid block header.\n");
                    goto cleanup;
                }
                this->write("BYE 16777989\r\n");
                this->myNotificationServer()->externalCallbacks.fileTransferSucceeded(this->auth.inv);
                
                goto cleanup;
            }
            else if (blockHeader[0] != 0U)
            {
                this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, 0, "Invalid block header.");
                goto cleanup;
            }
            

            blockLength = ((unsigned char) blockHeader[1]) | ((unsigned char) blockHeader[2]) << 8;
            if (blockLength > MAX_FTP_BLOCK_SIZE)
            {
                this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, 0, "Block size greater than largest expected block size.");
                goto cleanup;
            }
            

                // that indicates success isnt sent...
                
                this->write("BYE 16777989\r\n");
                this->myNotificationServer()->externalCallbacks.fileTransferSucceeded(this->auth.inv);
                goto cleanup;
            }
            this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Receiving file", this->auth.bytes_done, this->auth.inv->fileSize);
        }
        return;
cleanup:
            ;
        this->auth.inv->switchboardConnection->invitationsReceived.remove(this->auth.inv);
        if (this->auth.fd)
        {
            fclose(this->auth.fd);
            this->auth.fd = NULL;
        }
    }
    
    void FileTransferInvitation::rejectTransfer()

Lines 164-172 Link Here

(-)centericq-4.21.0.orig/libmsn-0.1/msn/filetransfer.h (-1 / +1 lines)
164	virtual void socketIsWritable();	164	virtual void socketIsWritable();
165	virtual void socketConnectionCompleted();	165	virtual void socketConnectionCompleted();
166	virtual void dataArrivedOnSocket();	166	virtual void dataArrivedOnSocket();
		167	virtual NotificationServerConnection *myNotificationServer() { return switchboardConnection()->myNotificationServer(); };
167	protected:	168	protected:
168	virtual void handleIncomingData();	169	virtual void handleIncomingData();
169
170	private:	170	private:
171	void handleSend();	171	void handleSend();
172	void handleReceive();	172	void handleReceive();




/*
  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
  ghost@aladdin.com

 */
/*$Id: md5.h,v 1.3 2002/10/11 06:49:22 jtownsend Exp $ */
/*
  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
  <ghost@aladdin.com>.  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 <purschke@bnl.gov>.
  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 */




/*
 * msntest.cpp
 * libmsn
 *
 * Created by Meredydd Luff.
 * Copyright (c) 2004 Meredydd Luff. All rights reserved.
 *
 * 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 <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/poll.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdlib.h>
#include <string.h>

#include <msn/msn.h>
#include <string>
#include <iostream>

class Callbacks : public MSN::Callbacks
{
    
    virtual void registerSocket(int s, int read, int write);
    virtual void unregisterSocket(int s);
    
    virtual void showError(MSN::Connection * conn, std::string msg);
    
    virtual void buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::BuddyStatus state);
    virtual void buddyOffline(MSN::Connection * conn, MSN::Passport buddy);
    
    virtual void log(int writing, const char* buf);
    
    virtual void gotFriendlyName(MSN::Connection * conn, std::string friendlyname);
    virtual void gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data);
    virtual void gotLatestListSerial(MSN::Connection * conn, int serial);
    virtual void gotGTC(MSN::Connection * conn, char c);
    virtual void gotBLP(MSN::Connection * conn, char c);
    
    virtual void gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
    
    virtual void addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
    
    virtual void removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
    
    virtual void addedGroup(MSN::Connection * conn, std::string groupName, int groupID);
    virtual void removedGroup(MSN::Connection * conn, int groupID);
    virtual void renamedGroup(MSN::Connection * conn, int groupID, std::string newGroupName);
    
    virtual void gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag);
    
    virtual void buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial);
    
    virtual void buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy);
    
    virtual void gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg);
    
    virtual void failedSendingMessage(MSN::Connection * conn);
    
    virtual void buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
    
    virtual void gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders);
    
    virtual void gotNewEmailNotification(MSN::Connection * conn, std::string from, std::string subject);
    
    virtual void gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv);
    
    virtual void fileTransferProgress(MSN::FileTransferInvitation * inv, std::string status, unsigned long recv, unsigned long total);
    
    virtual void fileTransferFailed(MSN::FileTransferInvitation * inv, int error, std::string message);
    
    virtual void fileTransferSucceeded(MSN::FileTransferInvitation * inv);
    
    virtual void gotNewConnection(MSN::Connection * conn);
    
    virtual void closingConnection(MSN::Connection * conn);
    
    virtual void changedStatus(MSN::Connection * conn, MSN::BuddyStatus state);
    
    virtual int connectToServer(std::string server, int port, bool *connected);
    
    virtual int listenOnPort(int port);
    
    virtual std::string getOurIP();
    
    virtual std::string getSecureHTTPProxy();
};

struct pollfd mySockets[21];

void handle_command(MSN::NotificationServerConnection &);
int countsocks(void);

int main()
{
    for (int i = 1; i < 20; i++)
    {
        mySockets[i].fd = -1;
        mySockets[i].events = POLLIN; 
        mySockets[i].revents = 0;
    }
    
    mySockets[0].fd = 0;
    mySockets[0].events = POLLIN;
    mySockets[0].revents = 0;
    
    Callbacks cb;
    MSN::Passport uname;
    char *pass = NULL;
    while (1)
    {
        fprintf(stderr, "Enter your login name: ");
        fflush(stdout);
        try
        {
            std::cin >> uname;
            break;
        }
        catch (MSN::InvalidPassport & e)
        {
            std::cout << e.what() << std::endl;
        }
    }
    
    pass = getpass("Enter your password: ");
    
    fprintf(stderr, "Connecting to the MSN Messenger service...\n");
    
    MSN::NotificationServerConnection mainConnection(uname, pass, cb);
    mainConnection.connect("messenger.hotmail.com", 1863);
        
    fprintf(stderr, "> ");
    fflush(stderr);
    while (1)
    {
        poll(mySockets, 20, -1);
        for (int i = 1; i < 20; i++)
        {
            if (mySockets[i].fd == -1)
                break; 
            
            if (mySockets[i].revents & POLLHUP) 
	    {
                mySockets[i].revents = 0; 
		continue; 
	    }
            
            if (mySockets[i].revents & (POLLERR | POLLNVAL))
            {
                printf("Dud socket (%d)! Code %x (ERR=%x, INVAL=%x)\n", mySockets[i].fd, mySockets[i].revents, POLLERR, POLLNVAL);
                
                MSN::Connection *c;
                
                // Retrieve the connection associated with the
                // socket's file handle on which the event has
                // occurred.
                c = mainConnection.connectionWithSocket(mySockets[i].fd);
                
                // if this is a libmsn socket
                if (c != NULL)
                {
                    // Delete the connection.  This will cause the resources
                    // that are being used to be freed.
                    delete c;
                }
                
                mySockets[i].fd = -1;
                mySockets[i].revents = 0;
                continue;
            }
            
            if (mySockets[i].revents & (POLLIN | POLLOUT | POLLPRI))
            {
                MSN::Connection *c;
                
                // Retrieve the connection associated with the
                // socket's file handle on which the event has
                // occurred.
                c = mainConnection.connectionWithSocket(mySockets[i].fd);
                
                // if this is a libmsn socket
                if (c != NULL)
                {
                    // If we aren't yet connected, a socket event means that
                    // our connection attempt has completed.
                    if (c->isConnected() == false)
                        c->socketConnectionCompleted();
                    
                    // If this event is due to new data becoming available 
                    if (mySockets[i].revents & POLLIN)
                        c->dataArrivedOnSocket();
                    
                    // If this event is due to the socket becoming writable
                    if (mySockets[i].revents & POLLOUT)
                        c->socketIsWritable();
                }          
            }
            mySockets[i].revents = 0;
        }

        if (mySockets[0].revents & POLLIN)
        {
            handle_command(mainConnection);
            mySockets[0].revents = 0;
        }
    }
}

void handle_command(MSN::NotificationServerConnection & mainConnection)
{
    char command[40];
    
    if (scanf(" %s", command) == EOF)
    {
        printf("\n");
        exit(0);
    }
    
    if (!strcmp(command, "quit"))
    {
        exit(0);
    } else if (!strcmp(command, "msg")) {
        char rcpt[80];
        char msg[1024];
        
        scanf(" %s", rcpt);
        
        fgets(msg, 1024, stdin);
        
        msg[strlen(msg)-1] = '\0';
        
        const std::string rcpt_ = rcpt;
        const std::string msg_ = msg;
        const std::pair<std::string, std::string> *ctx = new std::pair<std::string, std::string>(rcpt_, msg_);
        mainConnection.requestSwitchboardConnection(ctx);
    } else if (!strcmp(command, "status")) {
        char state[10];
        
        scanf(" %s", state);
        
        mainConnection.setState(MSN::buddyStatusFromString(state));
    } else if (!strcmp(command, "friendlyname")) {
        char fn[256];
        
        fgets(fn, 256, stdin);
        fn[strlen(fn)-1] = '\0';
        
        mainConnection.setFriendlyName(fn);
    } else if (!strcmp(command, "add")) {
        char list[10];
        char user[128];
        
        scanf(" %s %s", list, user);
        
        mainConnection.addToList(list, user);
    } else if (!strcmp(command, "del")) {
        char list[10];
        char user[128];
        
        scanf(" %s %s", list, user);
        
        mainConnection.removeFromList(list, user);
    } else if (!strcmp(command, "reconnect")) {
        if (mainConnection.connectionState() != MSN::NotificationServerConnection::NS_DISCONNECTED)
            mainConnection.disconnect();

        mainConnection.connect("messenger.hotmail.com", 1863);
    } else if (!strcmp(command, "disconnect")) {
        mainConnection.disconnect();
    } else {
        fprintf(stderr, "\nBad command \"%s\"", command);
    }
    
    fprintf(stderr, "\n> ");
    fflush(stderr);
}

int countsocks(void)
{
    int retval = 0;
    
    for (int a = 0; a < 20; a++)
    {
        if (mySockets[a].fd == -1) 
            break; 
        
        retval++;
    }
    return retval;
}

void Callbacks::registerSocket(int s, int reading, int writing)
{
    for (int a = 1; a < 20; a++)
    {
        if (mySockets[a].fd == -1)
        {
            mySockets[a].events = 0;
            if (reading)
                mySockets[a].events |= POLLIN;  
            
            if (writing)
                mySockets[a].events |= POLLOUT;  
            
            mySockets[a].fd = s;
            return;
        }
    }
}

void Callbacks::unregisterSocket(int s)
{
    for (int a = 1; a < 20; a++)
    {
        if (mySockets[a].fd == s)
        {
            for (int b = a; b < 19; b++)
                mySockets[b].fd = mySockets[b + 1].fd;
            
            mySockets[19].fd = -1;
        }
    }
}

void Callbacks::gotFriendlyName(MSN::Connection * conn, std::string friendlyname)
{
    printf("Your friendlyname is now: %s\n", friendlyname.c_str());
}

void Callbacks::gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * info)
{
    int a;
    std::list<MSN::Buddy> & list = info->forwardList;
    std::list<MSN::Buddy>::iterator i;
        
    for (a = 0; a < 4; a++)
    {
        switch (a)
        {
            case 0:
            {
                list = info->forwardList; 
                printf("Forward list:\n"); 
                break; 
            }
                
            case 1:
            { 
                list = info->reverseList; 
                printf("Reverse list:\n"); 
                break; 
            }
                
            case 2:
            {
                list = info->allowList; 
                printf("Allow list:\n");
                break;
            }
                
            case 3:
            { 
                list = info->blockList; 
                printf("Block list:\n"); 
                break; 
            }
        }
        
        for (i = list.begin(); i != list.end(); i++)
        {
            printf("-  %s (%s)\n", (*i).friendlyName.c_str(), (*i).userName.c_str());
            std::list<MSN::Buddy::PhoneNumber>::iterator pns = (*i).phoneNumbers.begin();
            std::list<MSN::Group *>::iterator g = (*i).groups.begin();
            for (; g != (*i).groups.end(); g++)
            {
                printf("    G: %s\n", (*g)->name.c_str());
            }
            
            for (; pns != (*i).phoneNumbers.end(); pns++)
            {
                printf("    %s: %s (%d)\n", (*pns).title.c_str(), (*pns).number.c_str(), (*pns).enabled);
            }
        }
    }
    
    printf("Available Groups:\n");
    std::map<int, MSN::Group>::iterator g = info->groups.begin();
    for (; g != info->groups.end(); g++)
    {
        printf("    %d: %s\n", (*g).second.groupID, (*g).second.name.c_str());
    }
}

void Callbacks::gotLatestListSerial(MSN::Connection * conn, int serial)
{
    printf("The latest serial number is: %d\n", serial);
}

void Callbacks::gotGTC(MSN::Connection * conn, char c)
{
    printf("Your GTC value is now %c\n", c);
}

void Callbacks::gotBLP(MSN::Connection * conn, char c)
{
    printf("Your BLP value is now %cL\n", c);
}

void Callbacks::gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport username, std::string friendlyname)
{
    printf("%s (%s) has added you to their contact list.\nYou might want to add them to your Allow or Block list\n", username.c_str(), friendlyname.c_str());
}

void Callbacks::addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport username, int groupID)
{
    printf("%s is now on your %s, group %d\n", username.c_str(), list.c_str(), groupID);
}

void Callbacks::removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport username, int groupID)
{
    printf("%s has been removed from your %s, group %d\n", username.c_str(), list.c_str(), groupID);
}

void Callbacks::addedGroup(MSN::Connection *conn, std::string groupName, int groupID)
{
    printf("A group named %s (%d) was added\n", groupName.c_str(), groupID);
}

void Callbacks::removedGroup(MSN::Connection *conn, int groupID)
{
    printf("A group with ID %d was removed\n", groupID);
}

void Callbacks::renamedGroup(MSN::Connection *conn, int groupID, std::string newGroupName)
{
    printf("A group with ID %d was renamed to %s\n", groupID, newGroupName.c_str());
}

void Callbacks::showError(MSN::Connection * conn, std::string msg)
{
    printf("MSN: Error: %s\n", msg.c_str());
}

void Callbacks::buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::BuddyStatus status)
{
    printf("%s (%s) is now %s\n", friendlyname.c_str(), buddy.c_str(), MSN::buddyStatusToString(status).c_str());
}

void Callbacks::buddyOffline(MSN::Connection *conn, MSN::Passport buddy)
{
    printf("%s is now offline\n", buddy.c_str());
}

void Callbacks::gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag)
{
    printf("Got switchboard connection\n");
    if (tag)
    {
        const std::pair<std::string, std::string> *ctx = static_cast<const std::pair<std::string, std::string> *>(tag);
        conn->inviteUser(ctx->first);
    }
}

void Callbacks::buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport username, std::string friendlyname, int is_initial)
{
    printf("%s (%s) is now in the session\n", friendlyname.c_str(), username.c_str());
    if (conn->auth.tag)
    {
        const std::pair<std::string, std::string> *ctx = static_cast<const std::pair<std::string, std::string> *>(conn->auth.tag);
        conn->sendMessage(ctx->second);
        delete ctx;
        conn->auth.tag = NULL;
    }
}

void Callbacks::buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport username)
{
    printf("%s has now left the session\n", username.c_str());
}

void Callbacks::gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport username, std::string friendlyname, MSN::Message * msg)
{
    printf("--- Message from %s (%s) in font %s:\n%s\n", friendlyname.c_str(), username.c_str(), msg->getFontName().c_str(), msg->getBody().c_str());
}

void Callbacks::failedSendingMessage(MSN::Connection * conn)
{
    printf("**************************************************\n");
    printf("ERROR:  Your last message failed to send correctly\n");
    printf("**************************************************\n");
}

void Callbacks::buddyTyping(MSN::Connection * conn, MSN::Passport username, std::string friendlyname)
{
    printf("\t%s (%s) is typing...\n", friendlyname.c_str(), username.c_str());
}

void Callbacks::gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders)
{
    if (unread_inbox > 0) 
        printf("You have %d new messages in your Inbox\n", unread_inbox); 
    
    if (unread_folders > 0) 
        printf("You have %d new messages in other folders.\n", unread_folders); 
}

void Callbacks::gotNewEmailNotification(MSN::Connection * conn, std::string from, std::string subject)
{
    printf("New e-mail has arrived from %s.\nSubject: %s\n", from.c_str(), subject.c_str());
}

void Callbacks::gotFileTransferInvitation(MSN::Connection *conn, MSN::Passport username, std::string friendlyname, MSN::FileTransferInvitation * inv)
{
    printf("Got file transfer invitation from %s (%s)\n", friendlyname.c_str(), username.c_str());
    inv->acceptTransfer("tmp.out");
}

void Callbacks::fileTransferProgress(MSN::FileTransferInvitation * inv, std::string status, unsigned long sent, unsigned long total)
{
    printf("File transfer: %s\t(%lu/%lu bytes sent)\n", status.c_str(), sent, total);
}

void Callbacks::fileTransferFailed(MSN::FileTransferInvitation * inv, int error, std::string message)
{
    printf("File transfer failed: %s\n", message.c_str());
}

void Callbacks::fileTransferSucceeded(MSN::FileTransferInvitation * inv)
{
    printf("File transfer successfully completed\n");
}

void Callbacks::gotNewConnection(MSN::Connection * conn)
{
    if (dynamic_cast<MSN::NotificationServerConnection *>(conn))
        dynamic_cast<MSN::NotificationServerConnection *>(conn)->synchronizeLists();
}

void Callbacks::closingConnection(MSN::Connection * conn)
{
    printf("Closed connection with socket %d\n", conn->sock);
}

void Callbacks::changedStatus(MSN::Connection * conn, MSN::BuddyStatus state)
{
    printf("Your state is now: %s\n", MSN::buddyStatusToString(state).c_str());
}

int Callbacks::connectToServer(std::string hostname, int port, bool *connected)
{
    struct sockaddr_in sa;
    struct hostent     *hp;
    int s;
    
    if ((hp = gethostbyname(hostname.c_str())) == NULL) {
        errno = ECONNREFUSED;                       
        return -1;
    }
    
    memset(&sa,0,sizeof(sa));
    memcpy((char *)&sa.sin_addr,hp->h_addr,hp->h_length);     /* set address */
    sa.sin_family = hp->h_addrtype;
    sa.sin_port = htons((u_short)port);
    
    if ((s = socket(hp->h_addrtype,SOCK_STREAM,0)) < 0)     /* get socket */
        return -1;

    int oldfdArgs = fcntl(s, F_GETFL, 0);
    fcntl(s, F_SETFL, oldfdArgs | O_NONBLOCK);
    
    if (connect(s,(struct sockaddr *)&sa,sizeof sa) < 0)
    {
        if (errno != EINPROGRESS) 
        { 
            close(s);
            return -1;
        }
        *connected = false;
    }
    else
        *connected = true;
    
    return s;
}

int Callbacks::listenOnPort(int port)
{
    int s;
    struct sockaddr_in addr;
    
    if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        return -1;
    }
    
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    
    if (bind(s, (sockaddr *)(&addr), sizeof(addr)) < 0 || listen(s, 1) < 0)
    {
        close(s);
        return -1;
    }
    
    return s;
}

std::string Callbacks::getOurIP(void)
{
    struct hostent * hn;
    char buf2[1024];
    
    gethostname(buf2,1024);
    hn = gethostbyname(buf2);
    
    return inet_ntoa( *((struct in_addr*)hn->h_addr));
}

void Callbacks::log(int i, const char *s)
{
    
}

std::string Callbacks::getSecureHTTPProxy()
{
    return "";
}




#include <msn/notificationserver.h>
#include <msn/errorcodes.h>
#include <msn/externals.h>
#include <msn/md5.h>
#include <msn/util.h>
#include <curl/curl.h>
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cassert>

#ifndef WIN32
#include <unistd.h>
#else
#include <io.h>
#endif

#include <stdio.h>

#ifndef curl_free
#define curl_free free
#endif

namespace MSN

    
    static size_t msn_handle_curl_write(void *ptr, size_t size, size_t nmemb, void  *stream);
    static size_t msn_handle_curl_header(void *ptr, size_t size, size_t nmemb, void *stream) ;    
            
    NotificationServerConnection::NotificationServerConnection(NotificationServerConnection::AuthData & auth_, Callbacks & cb_)
        : Connection(), auth(auth_), externalCallbacks(cb_), _connectionState(NS_DISCONNECTED)
    {
        registerCommandHandlers();
    }
    
    NotificationServerConnection::NotificationServerConnection(Passport username_, std::string password_, Callbacks & cb_) 
        : Connection(), auth(username_, password_), externalCallbacks(cb_), _connectionState(NS_DISCONNECTED)
    {
        registerCommandHandlers();
    }
    
    NotificationServerConnection::NotificationServerConnection(Callbacks & cb_) : Connection(), auth(Passport(), ""), externalCallbacks(cb_), _connectionState(NS_DISCONNECTED)
    {
        registerCommandHandlers();
    }
    
    NotificationServerConnection::~NotificationServerConnection()
    {
        if (this->connectionState() != NS_DISCONNECTED)
            this->disconnect();
    }
    
    Connection *NotificationServerConnection::connectionWithSocket(int fd)
    {
        this->assertConnectionStateIsNot(NS_DISCONNECTED);
        std::list<SwitchboardServerConnection *> & list = _switchboardConnections;
        std::list<SwitchboardServerConnection *>::iterator i = list.begin();
        
        if (this->sock == fd)
            return this;
        
        for (; i != list.end(); i++)
        {
            Connection *c = (*i)->connectionWithSocket(fd);
            if (c)
                return c;
        }
        return NULL;
    }
    
    SwitchboardServerConnection *NotificationServerConnection::switchboardWithOnlyUser(Passport username)
    {
        if (this->connectionState() >= NS_CONNECTED)
        {
            std::list<SwitchboardServerConnection *> & list = _switchboardConnections;
            std::list<SwitchboardServerConnection *>::iterator i = list.begin();
            
            for (; i != list.end(); i++)
            {
                if ((*i)->users.size() == 1 &&
                    *((*i)->users.begin()) == username)
                    return *i;
            }
        }
        return NULL;
    }
    
    const std::list<SwitchboardServerConnection *> & NotificationServerConnection::switchboardConnections()
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        return _switchboardConnections;
    }
    
    void NotificationServerConnection::addSwitchboardConnection(SwitchboardServerConnection *c)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);        
        _switchboardConnections.push_back(c);
    }

    void NotificationServerConnection::removeSwitchboardConnection(SwitchboardServerConnection *c)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);        
        _switchboardConnections.remove(c);
    }
    
    void NotificationServerConnection::addCallback(NotificationServerCallback callback,
                                                   int trid, void *data)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTING);        
        this->callbacks[trid] = std::make_pair(callback, data);
    }
    
    void NotificationServerConnection::removeCallback(int trid)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTING);        
        this->callbacks.erase(trid);
    }
    
    void NotificationServerConnection::registerCommandHandlers()
    {
        if (commandHandlers.size() == 0)
        {
            commandHandlers["OUT"] = &NotificationServerConnection::handle_OUT;
            commandHandlers["ADD"] = &NotificationServerConnection::handle_ADD;
            commandHandlers["REM"] = &NotificationServerConnection::handle_REM;
            commandHandlers["BLP"] = &NotificationServerConnection::handle_BLP;
            commandHandlers["GTC"] = &NotificationServerConnection::handle_GTC;
            commandHandlers["REA"] = &NotificationServerConnection::handle_REA;
            commandHandlers["CHG"] = &NotificationServerConnection::handle_CHG;
            commandHandlers["CHL"] = &NotificationServerConnection::handle_CHL;
            commandHandlers["ILN"] = &NotificationServerConnection::handle_ILN;
            commandHandlers["NLN"] = &NotificationServerConnection::handle_NLN;
            commandHandlers["FLN"] = &NotificationServerConnection::handle_FLN;
            commandHandlers["MSG"] = &NotificationServerConnection::handle_MSG;
            commandHandlers["ADG"] = &NotificationServerConnection::handle_ADG;
            commandHandlers["RMG"] = &NotificationServerConnection::handle_RMG;
            commandHandlers["REG"] = &NotificationServerConnection::handle_REG;
        }
    }
    
    void NotificationServerConnection::dispatchCommand(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);        
        std::map<std::string, void (NotificationServerConnection::*)(std::vector<std::string> &)>::iterator i = commandHandlers.find(args[0]);
        if (i != commandHandlers.end())
            (this->*commandHandlers[args[0]])(args);
    }
    
    void NotificationServerConnection::handle_OUT(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);        
        if (args.size() > 1)
        {
            if (args[1] == "OTH")
            {
                this->myNotificationServer()->externalCallbacks.showError(this, "You have logged onto MSN twice at once. Your MSN session will now terminate.");
            }
            else if (args[1] == "SSD")
            {
                this->myNotificationServer()->externalCallbacks.showError(this, "This MSN server is going down for maintenance. Your MSN session will now terminate.");
            } else {
                this->myNotificationServer()->externalCallbacks.showError(this, (std::string("The MSN server has terminated the connection with an unknown reason code. Please report this code: ") + 
                                      args[1]).c_str());
            }
        }
        this->disconnect();
    }
    
    void NotificationServerConnection::handle_ADD(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);        
        if (args[2] == "RL")
        {
            this->myNotificationServer()->externalCallbacks.gotNewReverseListEntry(this, args[4], decodeURL(args[5]));
        }
        else
        {
            int groupID = -1;
            if (args.size() > 5)
                groupID = decimalFromString(args[5]);
            
            this->myNotificationServer()->externalCallbacks.addedListEntry(this, args[2], args[4], groupID);
        }
        this->myNotificationServer()->externalCallbacks.gotLatestListSerial(this, decimalFromString(args[3]));
    }

    void NotificationServerConnection::handle_REM(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        int groupID = -1;
        if (args.size() > 4)
            groupID = decimalFromString(args[4]);
        
        this->myNotificationServer()->externalCallbacks.removedListEntry(this, args[2], args[4], groupID);
        this->myNotificationServer()->externalCallbacks.gotLatestListSerial(this, decimalFromString(args[3]));
    }
    
    void NotificationServerConnection::handle_BLP(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        this->myNotificationServer()->externalCallbacks.gotBLP(this, args[3][0]);
        this->myNotificationServer()->externalCallbacks.gotLatestListSerial(this, decimalFromString(args[3]));
    }

    void NotificationServerConnection::handle_GTC(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        this->myNotificationServer()->externalCallbacks.gotGTC(this, args[3][0]);
        this->myNotificationServer()->externalCallbacks.gotLatestListSerial(this, decimalFromString(args[3]));
    }
    
    void NotificationServerConnection::handle_REA(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        this->myNotificationServer()->externalCallbacks.gotFriendlyName(this, decodeURL(args[4]));
        this->myNotificationServer()->externalCallbacks.gotLatestListSerial(this, decimalFromString(args[2]));        
    }
    
    void NotificationServerConnection::handle_CHG(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        this->myNotificationServer()->externalCallbacks.changedStatus(this, buddyStatusFromString(args[2]));
    }
    
    void NotificationServerConnection::handle_CHL(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        md5_state_t state;
        md5_byte_t digest[16];
        int a;
        
        md5_init(&state);
        md5_append(&state, (md5_byte_t *)(args[2].c_str()), (int) args[2].size());
        md5_append(&state, (md5_byte_t *)"VT6PX?UQTM4WM%YR", 16);
        md5_finish(&state, digest);
        
        std::ostringstream buf_;
        buf_ << "QRY " << this->trID++ << " PROD0038W!61ZTF9 32\r\n";
        if (write(buf_) != buf_.str().size())
            return;
        
        
        char hexdigest[3];
        for (a = 0; a < 16; a++)
        {
            sprintf(hexdigest, "%02x", digest[a]);
            write(std::string(hexdigest, 2), false);
        }
    }
    
    void NotificationServerConnection::handle_ILN(std::vector<std::string> & args)
    {
        this->assertConnectionStateIs(NS_CONNECTED);
        this->myNotificationServer()->externalCallbacks.buddyChangedStatus(this, args[3], decodeURL(args[4]), buddyStatusFromString(args[2]));
    }
    
    void NotificationServerConnection::handle_NLN(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        this->myNotificationServer()->externalCallbacks.buddyChangedStatus(this, args[2], decodeURL(args[3]), buddyStatusFromString(args[1]));
    }
    
    void NotificationServerConnection::handle_FLN(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        this->myNotificationServer()->externalCallbacks.buddyOffline(this, args[1]);
    }    
    
    void NotificationServerConnection::handle_MSG(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        Connection::handle_MSG(args);
    }
    
    void NotificationServerConnection::handle_RNG(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        SwitchboardServerConnection::AuthData auth = SwitchboardServerConnection::AuthData(this->auth.username,
                                                                                           args[1],
                                                                                           args[4]);
        SwitchboardServerConnection *newSBconn = new SwitchboardServerConnection(auth, *this);
        this->addSwitchboardConnection(newSBconn);  
        std::pair<std::string, int> server_address = splitServerAddress(args[2]);  
        newSBconn->connect(server_address.first, server_address.second);        
    }
    
    void NotificationServerConnection::handle_ADG(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);        
        this->myNotificationServer()->externalCallbacks.addedGroup(this, decodeURL(args[3]), decimalFromString(args[4]));
        this->myNotificationServer()->externalCallbacks.gotLatestListSerial(this, decimalFromString(args[2]));
    }

    void NotificationServerConnection::handle_RMG(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        this->myNotificationServer()->externalCallbacks.removedGroup(this, decimalFromString(args[3]));
        this->myNotificationServer()->externalCallbacks.gotLatestListSerial(this, decimalFromString(args[2]));
    }

    void NotificationServerConnection::handle_REG(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        this->myNotificationServer()->externalCallbacks.renamedGroup(this, decimalFromString(args[3]), decodeURL(args[4]));
        this->myNotificationServer()->externalCallbacks.gotLatestListSerial(this, decimalFromString(args[2]));
    }


    void NotificationServerConnection::setState(BuddyStatus state)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        std::ostringstream buf_;
        buf_ << "CHG " << this->trID++ << " " << buddyStatusToString(state) << " 0\r\n";
        write(buf_);        
    }
    
    void NotificationServerConnection::setBLP(char setting)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        std::ostringstream buf_;
        buf_ << "BLP " << this->trID++ << " " << setting << "L\r\n";
        write(buf_);        
    }

    void NotificationServerConnection::setGTC(char setting)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        std::ostringstream buf_;
        buf_ << "GTC " << this->trID++ << " " << setting << "\r\n";
        write(buf_);        
    }
    
    void NotificationServerConnection::setFriendlyName(std::string friendlyName) throw (std::runtime_error)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        if (friendlyName.size() > 387)
            throw std::runtime_error("Friendly name too long!");
        
        std::ostringstream buf_;  
        buf_ << "REA " << this->trID++ << " " << this->auth.username << " " << encodeURL(friendlyName) << "\r\n";
        write(buf_);        
    }

    void NotificationServerConnection::addToList(std::string list, Passport buddyName)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        std::ostringstream buf_;
        buf_ << "ADD " << this->trID++ << " " << list << " " << buddyName << " " << buddyName << "\r\n";
        write(buf_);        
    }
    
    void NotificationServerConnection::removeFromList(std::string list, Passport buddyName)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        std::ostringstream buf_;
        buf_ << "REM " << this->trID++ << " " << list << " " << buddyName << "\r\n";
        write(buf_);        
    }
    
    void NotificationServerConnection::addToGroup(Passport buddyName, int groupID)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        std::ostringstream buf_;
        buf_ << "ADD " << this->trID++ << " " << "FL" << " " << buddyName << " " << buddyName <<  " " << groupID << "\r\n";
        write(buf_);
    }
    
    void NotificationServerConnection::removeFromGroup(Passport buddyName, int groupID)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        std::ostringstream buf_;
        buf_ << "REM " << this->trID++ << " " << "FL" << " " << buddyName << " " << groupID << "\r\n";
        write(buf_);
    }
    
    void NotificationServerConnection::addGroup(std::string groupName)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        std::ostringstream buf_;
        buf_ << "ADG " << this->trID++ << " " << encodeURL(groupName) << " " << 0 << "\r\n";
        write(buf_);        
    }
    
    void NotificationServerConnection::removeGroup(int groupID)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        std::ostringstream buf_;
        buf_ << "RMG " << this->trID++ << " " << groupID << "\r\n";
        write(buf_);
    }
    
    void NotificationServerConnection::renameGroup(int groupID, std::string newGroupName)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        std::ostringstream buf_;
        buf_ << "REG " << this->trID++ << " " << groupID << " " << encodeURL(newGroupName) << " " << 0 << "\r\n";
        write(buf_);
    }
    
    
    void NotificationServerConnection::synchronizeLists(int version)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        this->assertConnectionStateIsNot(NS_SYNCHRONISING);
        ListSyncInfo *info = new ListSyncInfo(version);
        
        std::ostringstream buf_;
        buf_ << "SYN " << this->trID << " " << version << "\r\n";
        if (write(buf_) != buf_.str().size())
            return;
        
        this->addCallback(&NotificationServerConnection::callback_SyncData, this->trID, (void *)info);
        this->synctrid = this->trID++;
        this->setConnectionState(NS_SYNCHRONISING);
    }
    
    void NotificationServerConnection::sendPing()
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        write("PNG\r\n");        
    }
    
    void NotificationServerConnection::requestSwitchboardConnection(const void *tag)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        SwitchboardServerConnection::AuthData *auth = new SwitchboardServerConnection::AuthData(this->auth.username, tag);
        std::ostringstream buf_;
        buf_ << "XFR " << this->trID << " SB\r\n";
        if (write(buf_) != buf_.str().size())
            return;
        
        this->addCallback(&NotificationServerConnection::callback_TransferToSwitchboard, this->trID++, (void *)auth);        
    }
    
    template <class _Tp>
    class _sameUserName
    {
        Buddy buddy;
public:
        _sameUserName(const _Tp &__u) : buddy(__u) {};
        bool operator()(const _Tp &__x) { return __x.userName == buddy.userName; }
    };
    
    void NotificationServerConnection::checkReverseList(ListSyncInfo *info)
    {
        std::list<Buddy> & flist = info->reverseList;
        std::list<Buddy> & alist = info->allowList;
        std::list<Buddy> & blist = info->blockList;
        std::list<Buddy>::iterator flist_i;
        std::list<Buddy>::iterator alist_i;
        std::list<Buddy>::iterator blist_i;
        
        for (flist_i = flist.begin(); flist_i != flist.end(); flist_i++)
        {
            if (std::count_if(alist.begin(), alist.end(), _sameUserName<Buddy>(*flist_i)) == 0 &&
                std::count_if(blist.begin(), blist.end(), _sameUserName<Buddy>(*flist_i)) == 0)
            {
                this->myNotificationServer()->externalCallbacks.gotNewReverseListEntry(this, (*flist_i).userName, (*flist_i).friendlyName);
            }
        }
    }
    
    void NotificationServerConnection::socketConnectionCompleted()
    {
        this->assertConnectionStateIs(NS_CONNECTING);
        this->setConnectionState(NS_CONNECTED);
        
        Connection::socketConnectionCompleted();
        
        // If an error occurs in Connection::socketConnectionCompleted, we
        // will be disconnected before we get here.
        if (this->connectionState() != NS_DISCONNECTED)
        {
            this->myNotificationServer()->externalCallbacks.unregisterSocket(this->sock);
            this->myNotificationServer()->externalCallbacks.registerSocket(this->sock, 1, 0);
        }
    }
    
    void NotificationServerConnection::connect(const std::string & hostname, unsigned int port)
    {
        this->assertConnectionStateIs(NS_DISCONNECTED);
        connectinfo *info = new connectinfo(this->auth.username, this->auth.password);
        
        if ((this->sock = this->myNotificationServer()->externalCallbacks.connectToServer(hostname, port, &this->connected)) == -1)
        {
            this->myNotificationServer()->externalCallbacks.showError(this, "Could not connect to MSN server");
            this->myNotificationServer()->externalCallbacks.closingConnection(this);
            return;
        }
        this->setConnectionState(NS_CONNECTING);
        this->myNotificationServer()->externalCallbacks.registerSocket(this->sock, 0, 1);
        if (this->connected)
            this->socketConnectionCompleted();
        
        std::ostringstream buf_;
        buf_ << "VER " << this->trID << " MSNP8\r\n";
        if (this->write(buf_) != buf_.str().size())
            return;
        
        this->addCallback(&NotificationServerConnection::callback_NegotiateCVR, this->trID++, (void *)info);
    }
    
    void NotificationServerConnection::connect(const std::string & hostname, unsigned int port, const Passport & username, const std::string & password)
    {
        this->auth.username = username;
        this->auth.password = password;
        this->connect(hostname, port);
    }
    
    void NotificationServerConnection::disconnect()
    {
        this->assertConnectionStateIsNot(NS_DISCONNECTED);
        
        std::list<SwitchboardServerConnection *> list = _switchboardConnections;
        std::list<SwitchboardServerConnection *>::iterator i = list.begin();
        for (; i != list.end(); i++)
        {
            delete *i;
        }
        
        this->callbacks.clear();
        
        this->setConnectionState(NS_DISCONNECTED);        
        this->myNotificationServer()->externalCallbacks.closingConnection(this);        
        Connection::disconnect();
    }
    
    void NotificationServerConnection::disconnectForTransfer()
    {
        this->assertConnectionStateIsNot(NS_DISCONNECTED);
        this->myNotificationServer()->externalCallbacks.unregisterSocket(this->sock);
        ::close(this->sock);
        this->setConnectionState(NS_DISCONNECTED);
    }
    
    void NotificationServerConnection::handleIncomingData()
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        while (this->isWholeLineAvailable())
        {
            std::vector<std::string> args = this->getLine();
            if (args[0] == "MSG" || args[0] == "NOT" || args[0] == "IPG")
            {
                int dataLength;
                if (args[0] == "MSG")
                    dataLength = decimalFromString(args[3]);
                else
                    dataLength = decimalFromString(args[1]);

                if (this->readBuffer.find("\r\n") + 2 + dataLength > this->readBuffer.size())
                    return;
            }
            this->readBuffer = this->readBuffer.substr(this->readBuffer.find("\r\n") + 2);
            int trid = 0;
            
            if (args.size() >= 6 && args[0] == "XFR" && args[2] == "NS")
            {
                // XFR TrID NS NotificationServerIP:Port 0 ThisServerIP:Port
                //  0    1  2             3              4        5    
                this->callbacks.clear(); // delete the callback data
                
                this->disconnectForTransfer();
                
                std::pair<std::string, int> server_address = splitServerAddress(args[3]);
                this->connect(server_address.first, server_address.second);
                return;
            }
            
            if (args.size() >= 7 && args[0] == "RNG")
            {
                // RNG SessionID SwitchboardServerIP:Port CKI AuthString InvitingUser InvitingDisplayName
                // 0      1                 2              3       4           5             6
                this->handle_RNG(args);
                return;
            }
            
            if (args.size() >= 1 && args[0] == "QNG")
            {
                // QNG
                //  0
                
                // ping response, ignore
                return;
            }
            
            if ((args.size() >= 4 && (args[0] == "LST" || args[0] == "LSG")) ||
                (args.size() >= 2 && (args[0] == "GTC" || args[0] == "BLP")) ||
                (args.size() >= 3 && args[0] == "BPR")
                )
            {
                // LST UserName FriendlyName UserLists [GroupNumbers]
                //  0      1          2          3           4
                //
                // or
                // (GTC|BLP) [TrID] [ListVersion] Setting
                //     0        1        2          4
                
                if (this->synctrid)
                {
                    trid = this->synctrid;
                }
                else
                {
                    trid = decimalFromString(args[1]);
                }
            } 
            else if (args.size() > 1)
            {
                try
                {
                    trid = decimalFromString(args[1]);
                }
                catch (...)
                {
                }
            }
            
            if (!this->callbacks.empty() && trid >= 0)
            {
                if (this->callbacks.find(trid) != this->callbacks.end())
                {
                    (this->*(this->callbacks[trid].first))(args, trid, this->callbacks[trid].second);
                    continue;
                }
            }
            
            if (isdigit(args[0][0]))
                this->showError(decimalFromString(args[0]));
            else
                this->dispatchCommand(args);
        }
    }
    
    void NotificationServerConnection::callback_SyncData(std::vector<std::string> & args, int trid, void *data) throw (std::runtime_error)
    {
        this->assertConnectionStateIs(NS_SYNCHRONISING);
        ListSyncInfo *info = static_cast<ListSyncInfo *>(data);
        
        if (args[0] == "SYN")
        {
            if (info->listVersion == decimalFromString(args[2]))
            {
                delete info;
                info = NULL;
                this->removeCallback(trid);
                this->myNotificationServer()->externalCallbacks.gotBuddyListInfo(this, NULL);
                this->setConnectionState(NS_CONNECTED);                
                return;
            }
            else 
            {
                info->listVersion = decimalFromString(args[2]);
                info->usersRemaining = decimalFromString(args[3]);
                info->groupsRemaining = decimalFromString(args[4]);
                this->myNotificationServer()->externalCallbacks.gotLatestListSerial(this, info->listVersion);
            }
        }
        else if (args[0] == "LST")
        {
            int list = decimalFromString(args[3]);
            if ((list & ListSyncInfo::LST_FL) == ListSyncInfo::LST_FL)
            {
                info->forwardList.push_back(Buddy(args[1], decodeURL(args[2])));
                std::vector<std::string> groups = splitString(args[4], ",");
                std::vector<std::string>::iterator i = groups.begin();
                for (; i != groups.end(); i++)
                {
                    int group = atoi(i->c_str());
                    info->groups[group].buddies.push_back(&(info->forwardList.back()));
                    info->forwardList.back().groups.push_back(&info->groups[group]);
                }
            }
            if ((list & ListSyncInfo::LST_RL) == ListSyncInfo::LST_RL)
            {
                info->reverseList.push_back(Buddy(args[1], decodeURL(args[2])));
            }
            if ((list & ListSyncInfo::LST_AL) == ListSyncInfo::LST_AL)
            {
                info->allowList.push_back(Buddy(args[1], decodeURL(args[2])));
            }
            if ((list & ListSyncInfo::LST_BL) == ListSyncInfo::LST_BL)
            {
                info->blockList.push_back(Buddy(args[1], decodeURL(args[2])));
            }
            info->usersRemaining--;
            if (info->usersRemaining == 0)
            {
                info->progress |= ListSyncInfo::LST_FL | ListSyncInfo::LST_RL | ListSyncInfo::LST_AL | ListSyncInfo::LST_BL;
            }
        }
        else if (args[0] == "GTC")
        {
            info->reverseListPrompting = args[1][0];
            info->progress |= ListSyncInfo::COMPLETE_GTC;
            this->myNotificationServer()->externalCallbacks.gotGTC(this, info->reverseListPrompting);
        }
        else if (args[0] == "BLP")
        {
            info->privacySetting = args[1][0];
            info->progress |= ListSyncInfo::COMPLETE_BLP;
            this->myNotificationServer()->externalCallbacks.gotBLP(this, info->privacySetting);
        }
        else if (args[0] == "LSG")
        {
            int groupID = decimalFromString(args[1]);
            Group g(groupID, decodeURL(args[2]));
            info->groups[groupID] = g;
        }
        else if (args[0] == "BPR")
        {
            bool enabled;
            if (decodeURL(args[2])[0] == 'Y')
                enabled = true;
            else
                enabled = false;
            info->forwardList.back().phoneNumbers.push_back(Buddy::PhoneNumber(args[1], 
                                                                               decodeURL(args[2]), 
                                                                               enabled));
        }
        else
            throw std::runtime_error("Unexpected sync data");
                
        if (info->progress == (ListSyncInfo::LST_FL | ListSyncInfo::LST_RL |
                               ListSyncInfo::LST_AL | ListSyncInfo::LST_BL | 
                               ListSyncInfo::COMPLETE_BLP | ListSyncInfo::COMPLETE_GTC))
        {
            this->removeCallback(trid);
            this->checkReverseList(info);
            this->myNotificationServer()->externalCallbacks.gotBuddyListInfo(this, info);
            this->synctrid = 0;
            delete info;
            this->setConnectionState(NS_CONNECTED);
        }
        else if (info->progress > 63 || info->progress < 0)
            throw std::runtime_error("Corrupt sync progress!");
    }
    
    
    void NotificationServerConnection::callback_NegotiateCVR(std::vector<std::string> & args, int trid, void *data)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        connectinfo * info = (connectinfo *) data;
        this->removeCallback(trid);
        
        if (args.size() >= 3 && args[0] != "VER" || args[2] != "MSNP8") // if either *differs*...
        {
            this->myNotificationServer()->externalCallbacks.showError(NULL, "Protocol negotiation failed");
            delete info;
            this->disconnect();
            return;
        }
        
        std::ostringstream buf_;
        buf_ << "CVR " << this->trID << " 0x0409 winnt 5.2 i386 MSNMSGR 6.0.0250 MSMSGS " << info->username << "\r\n";
        if (this->write(buf_) != buf_.str().size())
            return;
        this->addCallback(&NotificationServerConnection::callback_RequestUSR, this->trID++, (void *) data);
    }
    
    void NotificationServerConnection::callback_TransferToSwitchboard(std::vector<std::string> & args, int trid, void *data)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        SwitchboardServerConnection::AuthData *auth = static_cast<SwitchboardServerConnection::AuthData *>(data);
        this->removeCallback(trid);
        
        if (args[0] != "XFR")
        {
            this->showError(decimalFromString(args[0]));
            this->disconnect();
            delete auth;
            return;
        }
        
        auth->cookie = args[5];
        auth->sessionID = "";
        
        SwitchboardServerConnection *newconn = new SwitchboardServerConnection(*auth, *this);
        
        this->addSwitchboardConnection(newconn);
        std::pair<std::string, int> server_address = splitServerAddress(args[3]);
        newconn->connect(server_address.first, server_address.second);
        
        delete auth;
    }
    
    void NotificationServerConnection::callback_RequestUSR(std::vector<std::string> & args, int trid, void *data)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        connectinfo *info = (connectinfo *)data;
        this->removeCallback(trid);
        
        if (args.size() > 1 && args[0] != "CVR") // if*differs*...
        {
            this->myNotificationServer()->externalCallbacks.showError(NULL, "Protocol negotiation failed");
            delete info;
            this->disconnect();
            return;
        }
        
        std::ostringstream buf_;
        buf_ << "USR " << this->trID << " TWN I " << info->username << "\r\n";
        if (this->write(buf_) != buf_.str().size())
            return;
        
        this->addCallback(&NotificationServerConnection::callback_PassportAuthentication, this->trID++, (void *) data);
    }    
    
    void NotificationServerConnection::callback_PassportAuthentication(std::vector<std::string> & args, int trid, void * data)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        connectinfo * info;
        
        CURL *curl;
        CURLcode ret;
        curl_slist *slist = NULL;
        std::string auth;
        char *uname, *pword;
        std::string proxy;
        
        info=(connectinfo *)data;
        this->removeCallback(trid);
        
        if (isdigit(args[0][0]))
        {
            this->showError(decimalFromString(args[0]));
            delete info;
            this->disconnect();
            return;
        }
        
        if (args.size() >= 4 && args[4].empty()) {
            this->disconnect();
            delete info;
            return;
        }
        
        /* Now to fire off some HTTPS login */
        /* args[4] contains the most interesting part we need to send on */
        curl = curl_easy_init();
        if (curl == NULL) {
            this->disconnect();
            delete info;
            return;
        }
        
        proxy = this->myNotificationServer()->externalCallbacks.getSecureHTTPProxy();
        if (! proxy.empty()) 
            ret = curl_easy_setopt(curl, CURLOPT_PROXY, proxy.c_str());
        else	
            ret = CURLE_OK;
        
        if (ret == CURLE_OK)
            ret = curl_easy_setopt(curl, CURLOPT_URL, "https://login.passport.com/login2.srf");
        
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
        uname = curl_escape(const_cast<char *>(info->username.c_str()), 0);
        pword = curl_escape(const_cast<char *>(info->password.c_str()), 0);
        auth = std::string("Authorization: Passport1.4 OrgVerb=GET,OrgURL=http%3A%2F%2Fmessenger%2Emsn%2Ecom,sign-in=") + uname + ",pwd=" + pword + ","+ args[4];
        curl_free(uname);
        curl_free(pword);
        slist = curl_slist_append(slist, auth.c_str());
        
        if (ret == CURLE_OK)
            ret = curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
        if (ret == CURLE_OK)
            ret = curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
        if (ret == CURLE_OK)
            ret = curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
        /*if (ret == CURLE_OK)
            ret = curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);*/
        /*  if (ret == CURLE_OK)
            ret = curl_easy_setopt(curl, CURLOPT_USERAGENT, "msnlib/1.0 (Proteus)");*/
        if (ret == CURLE_OK)
            ret = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &msn_handle_curl_write);
        /*if (ret == CURLE_OK)
            ret = curl_easy_setopt(curl, CURLOPT_WRITEDATA, info);*/
        if (ret == CURLE_OK)
            ret = curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, &msn_handle_curl_header);
        if (ret == CURLE_OK)
            ret = curl_easy_setopt(curl, CURLOPT_WRITEHEADER, info);
        
        if (ret == CURLE_OK)
            ret = curl_easy_perform(curl);
        
        curl_easy_cleanup(curl);
        curl_slist_free_all(slist);
        
        /* ok, if auth succeeded info->cookie is now the cookie to pass back */
        if (info->cookie.empty())
        {
            // No authentication cookie /usually/ means that authentication failed.
            this->showError(911);
            
            this->disconnect();
            delete info;
            return;
        }
        
        std::ostringstream buf_;
        buf_ << "USR " << this->trID << " TWN S " << info->cookie << "\r\n";
        if (this->write(buf_) != buf_.str().size())
            return;
        this->addCallback(&NotificationServerConnection::callback_AuthenticationComplete, this->trID++, (void *) data);
    }
    
    void NotificationServerConnection::callback_AuthenticationComplete(std::vector<std::string> & args, int trid, void * data)
    {
        this->assertConnectionStateIsAtLeast(NS_CONNECTED);
        connectinfo * info = (connectinfo *) data;
        this->removeCallback(trid);
        
        if (isdigit(args[0][0]))
        {
            this->showError(decimalFromString(args[0]));
            delete info;
            this->disconnect();
            return;
        }
        
        this->myNotificationServer()->externalCallbacks.gotFriendlyName(this, decodeURL(args[4]));
        
        delete info;
        
        this->myNotificationServer()->externalCallbacks.gotNewConnection(this);
	
	ext::gotNewConnection(this);
    }    
    
    
    static size_t msn_handle_curl_write(void *ptr, size_t size, size_t nmemb, void  *stream) {
        return size * nmemb;
    }
    
    static size_t msn_handle_curl_header(void *ptr, size_t size, size_t nmemb, void *stream) 
    {
        connectinfo * info;
        std::string cookiedata;
        
        info = (connectinfo *)stream;
        
        if ((size * nmemb) < strlen("Authentication-Info:"))
            return (size * nmemb);
        
        std::string headers_ = std::string((char *)ptr, size * nmemb);
        Message::Headers headers = Message::Headers(headers_);
        cookiedata = headers["Authentication-Info:"];

        if (! cookiedata.empty()) 
        {
            size_t pos = cookiedata.find(",from-PP='");
            if (pos == std::string::npos) {
                info->cookie = "";
            } else {
                info->cookie = cookiedata.substr(pos + strlen(",from-PP='"));
                pos = info->cookie.find("'");
                if (pos != std::string::npos)
                    info->cookie = info->cookie.substr(0, pos);
            }
        }
        
        return (size * nmemb);
    }    
}




#include <msn/buddy.h>
#include <msn/passport.h>
#include <stdexcept>
#include <msn/externals.h>

namespace MSN
{    

public:
        /** Create a NotificationServerConnection with the specified authentication data
         */
        NotificationServerConnection(AuthData & auth_, Callbacks & cb);
        
        /** Create a NotificationServerConnection with the specified @a username and 
         *  @a password.
         */
        NotificationServerConnection(Passport username, std::string password, Callbacks & cb);
        
        /** Create a NotificationServerConnection with no specified username or password. */
        NotificationServerConnection(Callbacks & cb);
        
        virtual ~NotificationServerConnection();
        virtual void dispatchCommand(std::vector<std::string> & args);

            NS_ONLINE
        };

        NotificationServerState connectionState() const { return this->_connectionState; };
        Callbacks & externalCallbacks;
        virtual NotificationServerConnection *myNotificationServer() { return this; };        
protected:
        virtual void handleIncomingData();
        NotificationServerState _connectionState;
        
        void setConnectionState(NotificationServerState s) { this->_connectionState = s; };
        void assertConnectionStateIs(NotificationServerState s) { assert(this->_connectionState == s); };
        void assertConnectionStateIsNot(NotificationServerState s) { assert(this->_connectionState != s); };
        void assertConnectionStateIsAtLeast(NotificationServerState s) { assert(this->_connectionState >= s); };        
private:
        std::list<SwitchboardServerConnection *> _switchboardConnections;
        std::map<int, std::pair<NotificationServerCallback, void *> > callbacks;




#include <msn/externals.h>
#include <msn/filetransfer.h>

#include <stdio.h>
#include <sys/stat.h>
#include <algorithm>
#include <cassert>

    std::map<std::string, void (SwitchboardServerConnection::*)(std::vector<std::string> &)> SwitchboardServerConnection::commandHandlers;
    
    SwitchboardServerConnection::SwitchboardServerConnection(AuthData & auth_, NotificationServerConnection & n)
        : Connection(), auth(auth_), _connectionState(SB_DISCONNECTED), notificationServer(n)
    {
        registerCommandHandlers();
    }
    
    SwitchboardServerConnection::~SwitchboardServerConnection()
    {
        if (this->connectionState() != SB_DISCONNECTED)
            this->disconnect();
    }
        
    Connection *SwitchboardServerConnection::connectionWithSocket(int fd)
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTING);
        std::list<FileTransferConnection *> & list = _fileTransferConnections;
        std::list<FileTransferConnection *>::iterator i = list.begin();
        

    
    void SwitchboardServerConnection::addFileTransferConnection(FileTransferConnection *c)
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTED);        
        _fileTransferConnections.push_back(c);
    }

    void SwitchboardServerConnection::removeFileTransferConnection(FileTransferConnection *c)
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTED);        
        _fileTransferConnections.remove(c);
    }

    /**
     *  @todo  FIX THIS.  Delete shouldn't be here.
     */    
    void SwitchboardServerConnection::removeFileTransferConnection(FileTransferInvitation *inv)
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTED);        
        std::list<FileTransferConnection *> & list = _fileTransferConnections;
        std::list<FileTransferConnection *>::iterator i = list.begin();        
        for (i = list.begin(); i != list.end(); i++)

    void SwitchboardServerConnection::addCallback(SwitchboardServerCallback callback,
                                                   int trid, void *data)
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTING);        
        this->callbacks[trid] = std::make_pair(callback, data);
    }

    void SwitchboardServerConnection::removeCallback(int trid)
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTING);        
        this->callbacks.erase(trid);
    }
    

    
    void SwitchboardServerConnection::dispatchCommand(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTED);        
        std::map<std::string, void (SwitchboardServerConnection::*)(std::vector<std::string> &)>::iterator i = commandHandlers.find(args[0]);
        if (i != commandHandlers.end())
            (this->*commandHandlers[args[0]])(args);

    
    void SwitchboardServerConnection::sendMessage(const Message *msg)
    {
        this->assertConnectionStateIsAtLeast(SB_READY);        
        std::string s = msg->asString();
        
        std::ostringstream buf_;
        buf_ << "MSG " << this->trID++ << " A " << (int) s.size() << "\r\n" << s;
        this->write(buf_);
    }


    
    void SwitchboardServerConnection::handleInvite(Passport from, const std::string & friendly, const std::string & mime, const std::string & body)
    {
        this->assertConnectionStateIsAtLeast(SB_READY);        
        Message::Headers headers = Message::Headers(body);
        std::string command = headers["Invitation-Command"];
        std::string cookie = headers["Invitation-Cookie"];

        } 
        else if (inv == NULL)
        {
            printf("Very odd - just got a %s out of mid-air...\n", command.c_str()); 
        }
        else if (command == "ACCEPT")
        {

        {
            inv->invitationWasCanceled(body);
        } else {
            printf("Argh, don't support %s yet!\n", command.c_str());
        }
    }
    
    void SwitchboardServerConnection::handleNewInvite(Passport & from, const std::string & friendly, const std::string & mime, const std::string & body)
    {
        this->assertConnectionStateIsAtLeast(SB_READY);        
        Message::Headers headers = Message::Headers(body);
        std::string appname;
        std::string filename;

        {
            invg = new FileTransferInvitation(Invitation::MSNFTP, headers["Invitation-Cookie"], from, 
                                              this, filename, atol(filesize.c_str()));
            this->myNotificationServer()->externalCallbacks.gotFileTransferInvitation(this, from, friendly, static_cast<FileTransferInvitation *>(invg));
        }
        
        if (invg == NULL)
        {
            this->myNotificationServer()->externalCallbacks.showError(this, "Unknown invitation type!");
            return;
        }
        

    
    void SwitchboardServerConnection::handle_BYE(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTED);        
        std::list<Passport> & list = this->users;
        std::list<Passport>::iterator i;
        
        this->myNotificationServer()->externalCallbacks.buddyLeftConversation(this, args[1]);
        
        for (i = list.begin(); i != list.end(); i++)
        {

    
    void SwitchboardServerConnection::handle_JOI(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTED);        
        if (args[1] == this->auth.username)
            return;
        
        if (this->auth.sessionID.empty() && this->connectionState() == SB_WAITING_FOR_USERS)
            this->setConnectionState(SB_READY);
        
        this->users.push_back(args[1]);
        this->myNotificationServer()->externalCallbacks.buddyJoinedConversation(this, args[1], decodeURL(args[2]), 0);
    }
    
    void SwitchboardServerConnection::handle_NAK(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTED);        
        this->myNotificationServer()->externalCallbacks.failedSendingMessage(this);
    }
    
    void SwitchboardServerConnection::handle_MSG(std::vector<std::string> & args)
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTED);        
        Connection::handle_MSG(args);
    }
    
    void SwitchboardServerConnection::sendTypingNotification()
    {
        this->assertConnectionStateIsAtLeast(SB_READY);        
        std::ostringstream buf_, msg_;
        msg_ << "MIME-Version: 1.0\r\n";
        msg_ << "Content-Type: text/x-msmsgscontrol\r\n";

        msg_ << "\r\n";
        size_t msg_length = msg_.str().size();
        
        buf_ << "MSG " << this->trID++ << " U " << (int) msg_length << "\r\n" << msg_.str();
        
        write(buf_);        
    }
    
    void SwitchboardServerConnection::inviteUser(Passport userName)
    {
        this->assertConnectionStateIsAtLeast(SB_WAITING_FOR_USERS);        
        std::ostringstream buf_;
        buf_ << "CAL " << this->trID++ << " " << userName << "\r\n";
        write(buf_);        
    }
    
    void SwitchboardServerConnection::connect(const std::string & hostname, unsigned int port)
    {
        this->assertConnectionStateIs(SB_DISCONNECTED);

        if ((this->sock = this->myNotificationServer()->externalCallbacks.connectToServer(hostname, port, &this->connected)) == -1)
        {
            this->myNotificationServer()->externalCallbacks.showError(this, "Could not connect to switchboard server");
            return;
        }
        
        this->myNotificationServer()->externalCallbacks.registerSocket(this->sock, 1, 1);
        this->setConnectionState(SB_CONNECTING);
        
        if (this->connected)
            this->socketConnectionCompleted();
        
        std::ostringstream buf_;
        if (this->auth.sessionID.empty())
        {
            buf_ << "USR " << this->trID << " " << this->auth.username << " " << this->auth.cookie << "\r\n";
            if (this->write(buf_) != buf_.str().size())
                return;
            this->addCallback(&SwitchboardServerConnection::callback_InviteUsers, this->trID, NULL);
        } 
        else
        {
            buf_ << "ANS " << this->trID << " " << this->auth.username << " " << this->auth.cookie << " " << this->auth.sessionID << "\r\n";
            if (this->write(buf_) != buf_.str().size())
                return;
            this->myNotificationServer()->externalCallbacks.gotNewConnection(this);
            this->addCallback(&SwitchboardServerConnection::callback_AnsweredCall, this->trID, NULL);
        }
        
        this->trID++;    
    }
    
    void SwitchboardServerConnection::disconnect()
    {
        this->assertConnectionStateIsNot(SB_DISCONNECTED);
        notificationServer.removeSwitchboardConnection(this);
        this->myNotificationServer()->externalCallbacks.closingConnection(this);
        
        std::list<FileTransferConnection *> list = _fileTransferConnections;
        std::list<FileTransferConnection *>::iterator i = list.begin();

        {
            removeFileTransferConnection(*i);
        }
        this->callbacks.clear();
        Connection::disconnect();
        this->setConnectionState(SB_DISCONNECTED);
    }    
    
    void SwitchboardServerConnection::socketConnectionCompleted()
    {
        this->assertConnectionStateIs(SB_CONNECTING);
        Connection::socketConnectionCompleted();
        this->myNotificationServer()->externalCallbacks.unregisterSocket(this->sock);
        this->myNotificationServer()->externalCallbacks.registerSocket(this->sock, 1, 0);
        this->setConnectionState(SB_WAITING_FOR_USERS);
    }
    
    void SwitchboardServerConnection::handleIncomingData()
    {
        this->assertConnectionStateIsAtLeast(SB_CONNECTED);        
        while (this->isWholeLineAvailable())
        {                
            std::vector<std::string> args = this->getLine();

    
    void SwitchboardServerConnection::callback_InviteUsers(std::vector<std::string> & args, int trid, void *)
    {    
        this->assertConnectionStateIsAtLeast(SB_CONNECTED);
        this->removeCallback(trid);
        
        if (args[2] != "OK")

            return;
        }
        
        this->myNotificationServer()->externalCallbacks.gotSwitchboard(this, this->auth.tag);
        this->myNotificationServer()->externalCallbacks.gotNewConnection(this);
    }
    
    void SwitchboardServerConnection::callback_AnsweredCall(std::vector<std::string> & args, int trid, void * data)
    {
        this->assertConnectionStateIs(SB_WAITING_FOR_USERS);        
        if (args.size() >= 3 && args[0] == "ANS" && args[2] == "OK")
            return;
        

                return;
            
            this->users.push_back(args[4]);
            this->myNotificationServer()->externalCallbacks.buddyJoinedConversation(this, args[4], decodeURL(args[5]), 1);
            if (args[2] == args[3])
            {
                this->removeCallback(trid);
                this->setConnectionState(SB_READY);
            }
        }
    }
    
    FileTransferInvitation *SwitchboardServerConnection::sendFile(const std::string path)
    {
        this->assertConnectionStateIs(SB_READY);        
        struct stat st_info;
        
        if (stat(path.c_str(), &st_info) < 0)
        { 
            this->myNotificationServer()->externalCallbacks.showError(this, "Could not open file"); 
            return NULL; 
        }
        

        
        delete msg;
        
        this->myNotificationServer()->externalCallbacks.fileTransferProgress(inv, "Negotiating connection", 0, 0);
        
        return inv;
    }

Lines 28-33 Link Here

(-)centericq-4.21.0.orig/libmsn-0.1/msn/switchboardserver.h (-2 / +11 lines)
28	#include <msn/connection.h>	28	#include <msn/connection.h>
29	#include <msn/passport.h>	29	#include <msn/passport.h>
30	#include <string>	30	#include <string>
		31	#include <cassert>
31		32
32	namespace MSN	33	namespace MSN
33	{	34	{
Lines 40-45 Link Here
40	*/	41	*/
41	class SwitchboardServerConnection : public Connection	42	class SwitchboardServerConnection : public Connection
42	{	43	{
		44	friend class FileTransferConnection;
		45	friend class FileTransferInvitation;
43	private:	46	private:
44	typedef void (SwitchboardServerConnection::SwitchboardServerCallback)(std::vector<std::string> & args, int trid, void );	47	typedef void (SwitchboardServerConnection::SwitchboardServerCallback)(std::vector<std::string> & args, int trid, void );
45	public:	48	public:
Lines 141-150 Link Here
141	SB_READY	144	SB_READY
142	};	145	};
143		146
144	SwitchboardServerState connectionState() const { return this->connectionStatus; };	147	SwitchboardServerState connectionState() const { return this->_connectionState; };
		148	virtual NotificationServerConnection *myNotificationServer() { return &notificationServer; };
145	protected:	149	protected:
146	virtual void handleIncomingData();	150	virtual void handleIncomingData();
147	SwitchboardServerState connectionStatus;	151	SwitchboardServerState _connectionState;
		152
		153	void setConnectionState(SwitchboardServerState s) { this->_connectionState = s; };
		154	void assertConnectionStateIs(SwitchboardServerState s) { assert(this->_connectionState == s); };
		155	void assertConnectionStateIsNot(SwitchboardServerState s) { assert(this->_connectionState != s); };
		156	void assertConnectionStateIsAtLeast(SwitchboardServerState s) { assert(this->_connectionState >= s); };
148	private:	157	private:
149	NotificationServerConnection & notificationServer;	158	NotificationServerConnection & notificationServer;
150	std::list<FileTransferConnection *> _fileTransferConnections;	159	std::list<FileTransferConnection *> _fileTransferConnections;

Lines 21-27 Link Here

(-)centericq-4.21.0.orig/libmsn-0.1/msn/util.cpp (-1 / +1 lines)
21	*/	21	*/
22		22
23	#include <msn/util.h>	23	#include <msn/util.h>
24	#include <cerrno>	24	#include <errno.h>
25	#include <cctype>	25	#include <cctype>
26		26
27	namespace MSN	27	namespace MSN





// ----------------------------------------------------------------------------

msnhook::msnhook(): abstracthook(msn), conn(cb) {
    ourstatus = offline;
    fonline = false;
    destroying = false;

	face.log(s);
}

void msncallbacks::log(int writing, const char* buf) {
    string pref = writing ? "OUT" : "IN";
    ::log((string) "[" + pref + "] " + buf);
}

void msncallbacks::registerSocket(int s, int reading, int writing) {
    ::log("msncallbacks::registerSocket");
    if(reading) mhook.rfds.push_back(s);
    if(writing) mhook.wfds.push_back(s);
}

void msncallbacks::unregisterSocket(int s) {
    ::log("msncallbacks::unregisterSocket");
    vector<int>::iterator i;

    i = find(mhook.rfds.begin(), mhook.rfds.end(), s);

    if(i != mhook.wfds.end()) mhook.wfds.erase(i);
}

void msncallbacks::gotFriendlyName(MSN::Connection * conn, string friendlyname) {
    ::log("msncallbacks::gotFriendlyName");
    if(!friendlyname.empty())
	mhook.friendlynicks[conf.getourid(msn).nickname] = friendlyname;
}

void msncallbacks::gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data) {
    ::log("msncallbacks::gotBuddyListInfo");
    imcontact ic;
    bool found;


    face.update();
}

void msncallbacks::gotLatestListSerial(MSN::Connection * conn, int serial) {
    ::log("msncallbacks::gotLatestListSerial");
}

void msncallbacks::gotGTC(MSN::Connection * conn, char c) {
    ::log("msncallbacks::gotGTC");
}

void msncallbacks::gotBLP(MSN::Connection * conn, char c) {
    ::log("msncallbacks::gotBLP");
}

void msncallbacks::gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname) {
    ::log("msncallbacks::gotNewReverseListEntry");

    try {
	mhook.conn.addToList("AL", buddy);

    em.store(imnotification(ic, _("The user has added you to his/her contact list")));
}

void msncallbacks::addedListEntry(MSN::Connection * conn, string lst, MSN::Passport buddy, int groupID) {
    ::log("msncallbacks::addedListEntry");
    mhook.slst[lst].push_back(msnbuddy(buddy, "", groupID));
}

void msncallbacks::removedListEntry(MSN::Connection * conn, string lst, MSN::Passport buddy, int groupID) {
    ::log("msncallbacks::removedListEntry");
    vector<msnbuddy>::iterator i = mhook.slst[lst].begin();
    while(i != mhook.slst[lst].end()) {
	if(i->nick == buddy) {

    }
}

void msncallbacks::showError(MSN::Connection * conn, string msg) {
    ::log(msg);
}

void msncallbacks::buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, string friendlyname, MSN::BuddyStatus state) {
    ::log("msncallbacks::buddyChangedStatus");
    mhook.statusupdate(buddy, friendlyname, buddy2stat(state));
}

void msncallbacks::buddyOffline(MSN::Connection * conn, MSN::Passport buddy) {
    ::log("msncallbacks::buddyOffline");
    mhook.statusupdate(buddy, "", offline);
}

void msncallbacks::gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag) {
    ::log("msncallbacks::gotSwitchboard");

    if(tag) {
	const msnhook::qevent *ctx = static_cast<const msnhook::qevent *>(tag);

    }
}

void msncallbacks::buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial) {
    ::log("msncallbacks::buddyJoinedConversation");
    if(conn->auth.tag) {
	const msnhook::qevent *ctx = static_cast<const msnhook::qevent *>(conn->auth.tag);
	mhook.lconn[ctx->nick] = conn;

    }
}

void msncallbacks::buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy) {
    ::log("msncallbacks::buddyLeftConversation");
}

void msncallbacks::gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg) {
    ::log("msncallbacks::gotInstantMessage");
    imcontact ic(nicktodisp(buddy), msn);

    mhook.checkinlist(ic);

    em.store(immessage(ic, imevent::incoming, text));
}

void msncallbacks::failedSendingMessage(MSN::Connection * conn) {
    ::log("msncallbacks::failedSendingMessage");
}

void msncallbacks::buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname) {
    ::log("msncallbacks::buddyTyping");
    icqcontact *c = clist.get(imcontact(nicktodisp(buddy), msn));
    if(c) c->setlasttyping(timer_current);
}

void msncallbacks::gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders) {
    ::log("msncallbacks::gotInitialEmailNotification");
    face.log(_("+ [msn] unread e-mail: %d in inbox, %d in folders"),
	unread_inbox, unread_folders);
}

void msncallbacks::gotNewEmailNotification(MSN::Connection * conn, string from, string subject) {
    ::log("msncallbacks::gotNewEmailNotification");
    face.log(_("+ [msn] e-mail from %s, %s"), from.c_str(), subject.c_str());
    clist.get(contactroot)->playsound(imevent::email);
}

void msncallbacks::gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv) {
    ::log("msncallbacks::gotFileTransferInvitation");
    if(!mhook.fcapabs.count(hookcapab::files))
	return;


    face.transferupdate(inv->fileName, fr, icqface::tsInit, inv->fileSize, 0);
}

void msncallbacks::fileTransferProgress(MSN::FileTransferInvitation * inv, string status, unsigned long recv, unsigned long total) {
    ::log("msncallbacks::fileTransferProgress");
    imfile fr;

    if(mhook.getfevent(inv, fr)) {

    }
}

void msncallbacks::fileTransferFailed(MSN::FileTransferInvitation * inv, int error, string message) {
    ::log("msncallbacks::fileTransferFailed");
    imfile fr;

    if(mhook.getfevent(inv, fr)) {

    }
}

void msncallbacks::fileTransferSucceeded(MSN::FileTransferInvitation * inv) {
    ::log("msncallbacks::fileTransferSucceeded");
    imfile fr;

    if(mhook.getfevent(inv, fr)) {

    }
}

void msncallbacks::gotNewConnection(MSN::Connection * conn) {
    ::log("msncallbacks::gotNewConnection");
    if(dynamic_cast<MSN::NotificationServerConnection *>(conn))
	dynamic_cast<MSN::NotificationServerConnection *>(conn)->synchronizeLists();
}

void msncallbacks::closingConnection(MSN::Connection * conn) {
    ::log("msncallbacks::closingConnection");

    MSN::SwitchboardServerConnection *swc;


    unregisterSocket(conn->sock);
}

void msncallbacks::changedStatus(MSN::Connection * conn, MSN::BuddyStatus state) {
    ::log("msncallbacks::changedStatus");
}

int msncallbacks::connectToServer(string server, int port, bool *connected) {
    ::log("msncallbacks::connectToServer");
    struct sockaddr_in sa;
    struct hostent *hp;
    int a, s;

    return s;
}

int msncallbacks::listenOnPort(int port) {
    ::log("msncallbacks::listenOnPort");
    int s;
    struct sockaddr_in addr;


    return s;
}

string msncallbacks::getOurIP() {
    ::log("msncallbacks::getOurIP");
    struct hostent *hn;
    char buf2[1024];


    return inet_ntoa(*((struct in_addr*) hn->h_addr));
}

string msncallbacks::getSecureHTTPProxy() {
    ::log("msncallbacks::getSecureHTTPProxy");
    return "";
}

void msncallbacks::addedGroup(MSN::Connection * conn, string groupName, int groupID) {
    ::log("msncallbacks::addedGroup");
    int i;
    icqcontact *c;


    }
}

void msncallbacks::renamedGroup(MSN::Connection * conn, int groupID, string newGroupName) {
    ::log("msncallbacks::renamedGroup");
    mhook.mgroups[groupID] = newGroupName;
}

void msncallbacks::removedGroup(MSN::Connection * conn, int groupID) {
    ::log("msncallbacks::removedGroup");
    mhook.mgroups.erase(groupID);
}





	{ return nick != anick; }
};

class msncallbacks : public MSN::Callbacks {
    public:
        void registerSocket(int s, int read, int write);
        void unregisterSocket(int s);
        void showError(MSN::Connection * conn, std::string msg);
        void buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::BuddyStatus state);
        void buddyOffline(MSN::Connection * conn, MSN::Passport buddy);
        void log(int writing, const char* buf);
        void gotFriendlyName(MSN::Connection * conn, std::string friendlyname);
        void gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data);
        void gotLatestListSerial(MSN::Connection * conn, int serial);
        void gotGTC(MSN::Connection * conn, char c);
        void gotBLP(MSN::Connection * conn, char c);
        void gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
        void addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
        void removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
        void addedGroup(MSN::Connection * conn, std::string groupName, int groupID);
        void removedGroup(MSN::Connection * conn, int groupID);
        void renamedGroup(MSN::Connection * conn, int groupID, std::string newGroupName);
        void gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag);
        void buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial);
        void buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy);
        void gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg);
        void failedSendingMessage(MSN::Connection * conn);
        void buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
        void gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders);
        void gotNewEmailNotification(MSN::Connection * conn, std::string from, std::string subject);
        void gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv);
        void fileTransferProgress(MSN::FileTransferInvitation * inv, std::string status, unsigned long recv, unsigned long total);
        void fileTransferFailed(MSN::FileTransferInvitation * inv, int error, std::string message);
        void fileTransferSucceeded(MSN::FileTransferInvitation * inv);
        void gotNewConnection(MSN::Connection * conn);
        void closingConnection(MSN::Connection * conn);
        void changedStatus(MSN::Connection * conn, MSN::BuddyStatus state);
        int connectToServer(std::string server, int port, bool *connected);
        int listenOnPort(int port);
        std::string getOurIP();
        std::string getSecureHTTPProxy();
};

class msnhook : public abstracthook {

    friend void msncallbacks::registerSocket(int s, int reading, int writing);
    friend void msncallbacks::unregisterSocket(int s);
    friend void msncallbacks::showError(MSN::Connection * conn, string msg);
    friend void msncallbacks::buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, string friendlyname, MSN::BuddyStatus state);
    friend void msncallbacks::buddyOffline(MSN::Connection * conn, MSN::Passport buddy);
    friend void msncallbacks::log(int writing, const char* buf);
    friend void msncallbacks::gotFriendlyName(MSN::Connection * conn, string friendlyname);
    friend void msncallbacks::gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data);
    friend void msncallbacks::gotLatestListSerial(MSN::Connection * conn, int serial);
    friend void msncallbacks::gotGTC(MSN::Connection * conn, char c);
    friend void msncallbacks::gotBLP(MSN::Connection * conn, char c);
    friend void msncallbacks::gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
    friend void msncallbacks::addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
    friend void msncallbacks::removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
    friend void msncallbacks::addedGroup(MSN::Connection * conn, string groupName, int groupID);
    friend void msncallbacks::removedGroup(MSN::Connection * conn, int groupID);
    friend void msncallbacks::renamedGroup(MSN::Connection * conn, int groupID, string newGroupName);
    friend void msncallbacks::gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag);
    friend void msncallbacks::buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial);
    friend void msncallbacks::buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy);
    friend void msncallbacks::gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg);
    friend void msncallbacks::failedSendingMessage(MSN::Connection * conn);
    friend void msncallbacks::buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
    friend void msncallbacks::gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders);
    friend void msncallbacks::gotNewEmailNotification(MSN::Connection * conn, string from, string subject);
    friend void msncallbacks::gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv);
    friend void msncallbacks::fileTransferProgress(MSN::FileTransferInvitation * inv, string status, unsigned long recv, unsigned long total);
    friend void msncallbacks::fileTransferFailed(MSN::FileTransferInvitation * inv, int error, string message);
    friend void msncallbacks::fileTransferSucceeded(MSN::FileTransferInvitation * inv);
    friend void msncallbacks::gotNewConnection(MSN::Connection * conn);
    friend void msncallbacks::closingConnection(MSN::Connection * conn);
    friend void msncallbacks::changedStatus(MSN::Connection * conn, MSN::BuddyStatus state);
    friend int msncallbacks::connectToServer(string server, int port, bool *connected);
    friend int msncallbacks::listenOnPort(int port);
    friend string msncallbacks::getOurIP();
    friend string msncallbacks::getSecureHTTPProxy();

    protected:
	imstatus ourstatus;
	bool fonline, flogged, readinfo, destroying;
	MSN::NotificationServerConnection conn;
	msncallbacks cb;
	time_t timer_ping;

	struct qevent {

Return to bug 138740

Lines 27-41 Link Here

(-)centericq-4.21.0.orig/libmsn-0.1/msn/errorcodes.h (-3 / +3 lines)
27	#include <list>	27	#include <list>
28	#include <msn/switchboardserver.h>	28	#include <msn/switchboardserver.h>
29		29
30	/** \mainpage libmsn 3.1.1 Reference	30	/** \mainpage libmsn 3.2 Reference
31	*	31	*
32	* <code>libmsn</code> is a C++ library for Microsoft's MSN Messenger service. It	32	* <code>libmsn</code> is a C++ library for Microsoft's MSN Messenger service. It
33	* provides a high-level interface that allows an application to access instant	33	* provides a high-level interface that allows an application to access instant
34	* messaging features with ease. For more information, please visit the	34	* messaging features with ease. For more information, please visit the
35	* <a href='http://libmsn.bluewire.org.nz'><code>libmsn</code></a> homepage.	35	* <a href='http://libmsn.bdash.net.nz'><code>libmsn</code></a> homepage.
36	*	36	*
37	* It is recommended that you read the	37	* It is recommended that you read the
38	* <a href='http://libmsn.bluewire.org.nz/overview.php'>library overview</a>	38	* <a href='http://libmsn.bdash.net.nz/overview.php'>library overview</a>
39	* before reading the reference documentation. The library overview will	39	* before reading the reference documentation. The library overview will
40	* familiarise you with the architecture and core data-types of <code>libmsn</code>,	40	* familiarise you with the architecture and core data-types of <code>libmsn</code>,
41	* and will make the reference documentation much more understandable.	41	* and will make the reference documentation much more understandable.

Lines 29-99 Link Here

(-)centericq-4.21.0.orig/libmsn-0.1/msn/externals.h (-38 / +39 lines)
29	{	29	{
30	class ListSyncInfo;	30	class ListSyncInfo;
31		31
32	namespace ext	32	class Callbacks
33	{	33	{
34	void registerSocket(int s, int read, int write);	34	public:
35	void unregisterSocket(int s);	35	virtual void registerSocket(int s, int read, int write) = 0;
		36	virtual void unregisterSocket(int s) = 0;
36		37
37	void showError(MSN::Connection * conn, std::string msg);	38	virtual void showError(MSN::Connection * conn, std::string msg) = 0;
38		39
39	void buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::BuddyStatus state);	40	virtual void buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::BuddyStatus state) = 0;
40	void buddyOffline(MSN::Connection * conn, MSN::Passport buddy);	41	virtual void buddyOffline(MSN::Connection * conn, MSN::Passport buddy) = 0;
41		42
42	void log(int writing, const char* buf);	43	virtual void log(int writing, const char* buf) = 0;
43		44
44	void gotFriendlyName(MSN::Connection * conn, std::string friendlyname);	45	virtual void gotFriendlyName(MSN::Connection * conn, std::string friendlyname) = 0;
45	void gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data);	46	virtual void gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data) = 0;
46	void gotLatestListSerial(MSN::Connection * conn, int serial);	47	virtual void gotLatestListSerial(MSN::Connection * conn, int serial) = 0;
47	void gotGTC(MSN::Connection * conn, char c);	48	virtual void gotGTC(MSN::Connection * conn, char c) = 0;
48	void gotBLP(MSN::Connection * conn, char c);	49	virtual void gotBLP(MSN::Connection * conn, char c) = 0;
49		50
50	void gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);	51	virtual void gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname) = 0;
51		52
52	void addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);	53	virtual void addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID) = 0;
53		54
54	void removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);	55	virtual void removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID) = 0;
55		56
56	void addedGroup(MSN::Connection * conn, std::string groupName, int groupID);	57	virtual void addedGroup(MSN::Connection * conn, std::string groupName, int groupID) = 0;
57	void removedGroup(MSN::Connection * conn, int groupID);	58	virtual void removedGroup(MSN::Connection * conn, int groupID) = 0;
58	void renamedGroup(MSN::Connection * conn, int groupID, std::string newGroupName);	59	virtual void renamedGroup(MSN::Connection * conn, int groupID, std::string newGroupName) = 0;
59		60
60	void gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag);	61	virtual void gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag) = 0;
61		62
62	void buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial);	63	virtual void buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial) = 0;
63		64
64	void buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy);	65	virtual void buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy) = 0;
65		66
66	void gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg);	67	virtual void gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg) = 0;
67		68
68	void failedSendingMessage(MSN::Connection * conn);	69	virtual void failedSendingMessage(MSN::Connection * conn) = 0;
69		70
70	void buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);	71	virtual void buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname) = 0;
71		72
72	void gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders);	73	virtual void gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders) = 0;
73		74
74	void gotNewEmailNotification(MSN::Connection * conn, std::string from, std::string subject);	75	virtual void gotNewEmailNotification(MSN::Connection * conn, std::string from, std::string subject) = 0;
75		76
76	void gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv);	77	virtual void gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv) = 0;
77		78
78	void fileTransferProgress(MSN::FileTransferInvitation * inv, std::string status, unsigned long recv, unsigned long total);	79	virtual void fileTransferProgress(MSN::FileTransferInvitation * inv, std::string status, unsigned long recv, unsigned long total) = 0;
79		80
80	void fileTransferFailed(MSN::FileTransferInvitation * inv, int error, std::string message);	81	virtual void fileTransferFailed(MSN::FileTransferInvitation * inv, int error, std::string message) = 0;
81		82
82	void fileTransferSucceeded(MSN::FileTransferInvitation * inv);	83	virtual void fileTransferSucceeded(MSN::FileTransferInvitation * inv) = 0;
83		84
84	void gotNewConnection(MSN::Connection * conn);	85	virtual void gotNewConnection(MSN::Connection * conn) = 0;
85		86
86	void closingConnection(MSN::Connection * conn);	87	virtual void closingConnection(MSN::Connection * conn) = 0;
87		88
88	void changedStatus(MSN::Connection * conn, MSN::BuddyStatus state);	89	virtual void changedStatus(MSN::Connection * conn, MSN::BuddyStatus state) = 0;
89		90
90	int connectToServer(std::string server, int port, bool *connected);	91	virtual int connectToServer(std::string server, int port, bool *connected) = 0;
91		92
92	int listenOnPort(int port);	93	virtual int listenOnPort(int port) = 0;
93		94
94	std::string getOurIP(void);	95	virtual std::string getOurIP() = 0;
95		96
96	std::string getSecureHTTPProxy(void);	97	virtual std::string getSecureHTTPProxy() = 0;
97	}	98	};
98	}	99	}
99	#endif	100	#endif

Lines 24-40 Link Here

(-)centericq-4.21.0.orig/libmsn-0.1/msn/filetransfer.cpp (-59 / +67 lines)
24	#include <msn/message.h>	24	#include <msn/message.h>
25	#include <msn/errorcodes.h>	25	#include <msn/errorcodes.h>
26	#include <msn/externals.h>	26	#include <msn/externals.h>
		27	#include <msn/notificationserver.h>
27		28
28	#ifndef WIN32	29	#ifndef WIN32
29	#include <unistd.h>	30	#include <unistd.h>
		31	#include <time.h>
		32	#include <sys/types.h>
		33	#include <sys/time.h>
30	#include <sys/socket.h>	34	#include <sys/socket.h>
31	#else	35	#else
32	#include <winsock.h>	36	#include <winsock.h>
33	#include <io.h>	37	#include <io.h>
34	#endif	38	#endif
35		39
36	#include <cassert>
37	#include <cerrno>	40	#include <cerrno>
		41	#include <cassert>
38		42
39	namespace MSN	43	namespace MSN
40	{	44	{
Lines 54-60 Link Here
54		58
55	void FileTransferInvitation::invitationWasCanceled(const std::string & body)	59	void FileTransferInvitation::invitationWasCanceled(const std::string & body)
56	{	60	{
57	ext::fileTransferFailed(this, 0, "Cancelled by remote user");	61	this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferFailed(this, 0, "Cancelled by remote user");
58	if (this->invitationWasSent())	62	if (this->invitationWasSent())
59	{	63	{
60	this->switchboardConnection->invitationsSent.remove(this);	64	this->switchboardConnection->invitationsSent.remove(this);
Lines 75-102 Link Here
75	std::string(tmp), FileTransferConnection::MSNFTP_SEND, this);	79	std::string(tmp), FileTransferConnection::MSNFTP_SEND, this);
76	FileTransferConnection * conn = new FileTransferConnection(auth);	80	FileTransferConnection * conn = new FileTransferConnection(auth);
77		81
78	ext::fileTransferProgress(this, "Sending IP address", 0, 0);	82	this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferProgress(this, "Sending IP address", 0, 0);
79		83
80	while((conn->sock = ext::listenOnPort(port)) < 0)	84	while((conn->sock = this->switchboardConnection->myNotificationServer()->externalCallbacks.listenOnPort(port)) < 0)
81	{	85	{
82	port++;	86	port++;
83	if (port > 6911)	87	if (port > 6911)
84	{	88	{
85	ext::fileTransferFailed(this, errno, strerror(errno));	89	this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferFailed(this, errno, strerror(errno));
86	this->switchboardConnection->invitationsSent.remove(this);	90	this->switchboardConnection->invitationsSent.remove(this);
87	conn->disconnect();	91	conn->disconnect();
88	return;	92	return;
89	}	93	}
90	}	94	}
91		95
92	ext::registerSocket(conn->sock, 1, 0);	96	this->switchboardConnection->myNotificationServer()->externalCallbacks.registerSocket(conn->sock, 1, 0);
93		97
94	this->switchboardConnection->addFileTransferConnection(conn);	98	this->switchboardConnection->addFileTransferConnection(conn);
95		99
96	std::ostringstream buf_;	100	std::ostringstream buf_;
97	buf_ << "Invitation-Command: ACCEPT\r\n";	101	buf_ << "Invitation-Command: ACCEPT\r\n";
98	buf_ << "Invitation-Cookie: " << this->cookie << "\r\n";	102	buf_ << "Invitation-Cookie: " << this->cookie << "\r\n";
99	buf_ << "IP-Address: " << ext::getOurIP() << "\r\n";	103	buf_ << "IP-Address: " << this->switchboardConnection->myNotificationServer()->externalCallbacks.getOurIP() << "\r\n";
100	buf_ << "Port: " << port << "\r\n";	104	buf_ << "Port: " << port << "\r\n";
101	buf_ << "AuthCookie: " << conn->auth.cookie << "\r\n";	105	buf_ << "AuthCookie: " << conn->auth.cookie << "\r\n";
102	buf_ << "Launch-Application: FALSE\r\n";	106	buf_ << "Launch-Application: FALSE\r\n";
Lines 119-125 Link Here
119		123
120	if (cookie.empty() \|\| remote.empty() \|\| port_c.empty())	124	if (cookie.empty() \|\| remote.empty() \|\| port_c.empty())
121	{	125	{
122	ext::fileTransferFailed(this, 0, "Missing parameters");	126	this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferFailed(this, 0, "Missing parameters");
123	this->switchboardConnection->invitationsReceived.remove(this);	127	this->switchboardConnection->invitationsReceived.remove(this);
124	return;	128	return;
125	}	129	}
Lines 132-154 Link Here
132		136
133	std::ostringstream buf_;	137	std::ostringstream buf_;
134	buf_ << "Connecting to " << remote << ":" << port << "\n";	138	buf_ << "Connecting to " << remote << ":" << port << "\n";
135	ext::fileTransferProgress(this, buf_.str(), 0, 0);	139	this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferProgress(this, buf_.str(), 0, 0);
136		140
137	conn->sock = ext::connectToServer(remote, port, &conn->connected);	141	conn->sock = this->switchboardConnection->myNotificationServer()->externalCallbacks.connectToServer(remote, port, &conn->connected);
138		142
139	if (conn->sock < 0)	143	if (conn->sock < 0)
140	{	144	{
141	ext::fileTransferFailed(this, errno, strerror(errno));	145	this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferFailed(this, errno, strerror(errno));
142	this->switchboardConnection->invitationsReceived.remove(this);	146	this->switchboardConnection->invitationsReceived.remove(this);
143	return;	147	return;
144	}	148	}
145		149
146	if (! conn->isConnected())	150	if (! conn->isConnected())
147	ext::registerSocket(conn->sock, 0, 1);	151	this->switchboardConnection->myNotificationServer()->externalCallbacks.registerSocket(conn->sock, 0, 1);
148	else	152	else
149	ext::registerSocket(conn->sock, 1, 0);	153	this->switchboardConnection->myNotificationServer()->externalCallbacks.registerSocket(conn->sock, 1, 0);
150		154
151	ext::fileTransferProgress(this, "Connected", 0, 0);	155	this->switchboardConnection->myNotificationServer()->externalCallbacks.fileTransferProgress(this, "Connected", 0, 0);
152	this->switchboardConnection->addFileTransferConnection(conn);	156	this->switchboardConnection->addFileTransferConnection(conn);
153		157
154	conn->write("VER MSNFTP\r\n");	158	conn->write("VER MSNFTP\r\n");
Lines 156-165 Link Here
156		160
157	void FileTransferConnection::disconnect()	161	void FileTransferConnection::disconnect()
158	{	162	{
		163	Connection::disconnect();
		164
		165	if (this->auth.fd)
		166	{
		167	fclose(this->auth.fd);
		168	this->auth.fd = NULL;
		169	}
		170
159	this->auth.inv->switchboardConnection->removeFileTransferConnection(this);	171	this->auth.inv->switchboardConnection->removeFileTransferConnection(this);
160	delete this->auth.inv;	172	delete this->auth.inv;
161	this->auth.inv = NULL;	173	this->auth.inv = NULL;
162	Connection::disconnect();
163	}	174	}
164		175
165	FileTransferConnection::~FileTransferConnection()	176	FileTransferConnection::~FileTransferConnection()
Lines 170-177 Link Here
170	void FileTransferConnection::socketConnectionCompleted()	181	void FileTransferConnection::socketConnectionCompleted()
171	{	182	{
172	Connection::socketConnectionCompleted();	183	Connection::socketConnectionCompleted();
173	ext::unregisterSocket(this->sock);	184	this->myNotificationServer()->externalCallbacks.unregisterSocket(this->sock);
174	ext::registerSocket(this->sock, 1, 0);	185	this->myNotificationServer()->externalCallbacks.registerSocket(this->sock, 1, 0);
175	}	186	}
176		187
177	void FileTransferConnection::socketIsWritable()	188	void FileTransferConnection::socketIsWritable()
Lines 223-240 Link Here
223	if ((s = accept(this->sock, NULL, NULL)) < 0)	234	if ((s = accept(this->sock, NULL, NULL)) < 0)
224	{	235	{
225	perror("Could not accept()\n");	236	perror("Could not accept()\n");
226	ext::fileTransferFailed(this->auth.inv, errno, strerror(errno));	237	this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
227	this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);	238	this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);
228	return;	239	return;
229	}	240	}
230		241
231	ext::unregisterSocket(this->sock);	242	this->myNotificationServer()->externalCallbacks.unregisterSocket(this->sock);
232	close(this->sock);	243	close(this->sock);
233		244
234	this->sock = s;	245	this->sock = s;
235	ext::registerSocket(this->sock, 1, 0);	246	this->myNotificationServer()->externalCallbacks.registerSocket(this->sock, 1, 0);
236		247
237	ext::fileTransferProgress(this->auth.inv, "Connected", 0, 0);	248	this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Connected", 0, 0);
238		249
239	this->auth.connected = 1;	250	this->auth.connected = 1;
240	this->connected = true;	251	this->connected = true;
Lines 250-263 Link Here
250		261
251	if (args[0] == "VER")	262	if (args[0] == "VER")
252	{	263	{
253	this->write("VER MSNFTP\r\n");	264	if (this->write("VER MSNFTP\r\n") != strlen("VER MSNFTP\r\n"))
254	ext::fileTransferProgress(this->auth.inv, "Negotiating", 0, 0);	265	return;
		266	this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Negotiating", 0, 0);
255	}	267	}
256	else if (args[0] == "USR")	268	else if (args[0] == "USR")
257	{	269	{
258	if (args[2] != this->auth.cookie) // if they DIFFER	270	if (args[2] != this->auth.cookie) // if they DIFFER
259	{	271	{
260	ext::fileTransferFailed(this->auth.inv, errno, strerror(errno));	272	this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
261	this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);	273	this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);
262	return;	274	return;
263	}	275	}
Lines 272-287 Link Here
272	if (this->auth.fd == NULL)	284	if (this->auth.fd == NULL)
273	{	285	{
274	perror("fopen() failed");	286	perror("fopen() failed");
275	ext::fileTransferFailed(this->auth.inv, errno, "Could not open file for reading");	287	this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, "Could not open file for reading");
276	this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);	288	this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);
277	return;	289	return;
278	}	290	}
279		291
280	// OK, now we lose control, but the next round of the polling loop will	292	// OK, now we lose control, but the next round of the polling loop will
281	// say that the socket is writable, and then the fun starts...	293	// say that the socket is writable, and then the fun starts...
282	ext::fileTransferProgress(this->auth.inv, "Sending data", 0, 0);	294	this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Sending data", 0, 0);
283	ext::unregisterSocket(this->sock);	295	this->myNotificationServer()->externalCallbacks.unregisterSocket(this->sock);
284	ext::registerSocket(this->sock, 0, 1);	296	this->myNotificationServer()->externalCallbacks.registerSocket(this->sock, 0, 1);
285	}	297	}
286	}	298	}
287		299
Lines 309-363 Link Here
309	blockHeader[1] = (blockLength >> 0) & 0xff;	321	blockHeader[1] = (blockLength >> 0) & 0xff;
310	blockHeader[2] = (blockLength >> 8) & 0xff;	322	blockHeader[2] = (blockLength >> 8) & 0xff;
311		323
312	if (this->write(std::string((char *) &blockHeader[bytesWritten], 3 - bytesWritten), false) < 0)	324	if (this->write(std::string((char *) &blockHeader[bytesWritten], 3 - bytesWritten), false) != 3)
313	{	325	{
314	ext::fileTransferFailed(this->auth.inv, errno, strerror(errno));	326	this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
315	goto cleanup;	327	goto cleanup;
316	}	328	}
317		329
318	if (fread(readBuffer, sizeof(unsigned char), blockLength, this->auth.fd) < 0)	330	if (fread(readBuffer, sizeof(unsigned char), blockLength, this->auth.fd) < 0)
319	{	331	{
320	ext::fileTransferFailed(this->auth.inv, errno, strerror(errno));	332	this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
321	goto cleanup;	333	goto cleanup;
322	}	334	}
323		335
324	if (this->write(std::string((char *) readBuffer, blockLength), false) < 0)	336	if ((blockLength = this->write(std::string((char *) readBuffer, blockLength), false)) < 0)
325	{	337	{
326	ext::fileTransferFailed(this->auth.inv, errno, strerror(errno));	338	this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
327	goto cleanup;	339	goto cleanup;
328	}	340	}
329	this->auth.bytes_done += blockLength;	341	this->auth.bytes_done += blockLength;
330	}	342	}
331	free(readBuffer);	343	free(readBuffer);
332	ext::fileTransferProgress(this->auth.inv, "Sending file", this->auth.bytes_done, this->auth.inv->fileSize);	344	this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Sending file", this->auth.bytes_done, this->auth.inv->fileSize);
333	return;	345	return;
334	cleanup:	346	cleanup:
335	;	347	;
336	this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);	348	this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);
337	if (readBuffer)	349	if (readBuffer)
338	free(readBuffer);	350	free(readBuffer);
		351	if (this->auth.fd)
		352	{
		353	fclose(this->auth.fd);
		354	this->auth.fd = NULL;
		355	}
339	}	356	}
340		357
341	void FileTransferConnection::handleSend_Bye()	358	void FileTransferConnection::handleSend_Bye()
342	{	359	{
343	if (! this->isWholeLineAvailable())	360	this->myNotificationServer()->externalCallbacks.fileTransferSucceeded(this->auth.inv);
344	return;
345
346	std::vector<std::string> args;
347	ext::fileTransferSucceeded(this->auth.inv);
348		361
349	args = this->getLine();	362	this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);
350	this->readBuffer = this->readBuffer.substr(this->readBuffer.find("\r\n") + 2);	363	this->disconnect();
351
352	if (args.size() > 0)
353	{
354	printf("%s", args[0].c_str());
355	if (args.size() > 1)
356	printf(" %s", args[1].c_str());
357	printf("\n");
358	}
359
360	this->auth.inv->switchboardConnection->invitationsSent.remove(this->auth.inv);
361	}	364	}
362		365
363		366
Lines 382-388 Link Here
382	std::ostringstream buf_;	385	std::ostringstream buf_;
383	buf_ << "USR " << this->auth.username << " " << this->auth.cookie << "\r\n";	386	buf_ << "USR " << this->auth.username << " " << this->auth.cookie << "\r\n";
384	this->write(buf_);	387	this->write(buf_);
385	ext::fileTransferProgress(this->auth.inv, "Negotiating", 0, 0);	388	this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Negotiating", 0, 0);
386	return;	389	return;
387	}	390	}
388	else if (args[0] == "FIL")	391	else if (args[0] == "FIL")
Lines 396-402 Link Here
396	return;	399	return;
397	error:	400	error:
398	;	401	;
399	ext::fileTransferFailed(this->auth.inv, errno, strerror(errno));	402	this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, errno, strerror(errno));
400	this->switchboardConnection()->invitationsReceived.remove(this->auth.inv);	403	this->switchboardConnection()->invitationsReceived.remove(this->auth.inv);
401	}	404	}
402		405
Lines 422-438 Link Here
422	// Transfer completed block	425	// Transfer completed block
423	if (blockHeader[1] != 0 \|\| blockHeader[2] != 0)	426	if (blockHeader[1] != 0 \|\| blockHeader[2] != 0)
424	{	427	{
425	ext::fileTransferFailed(this->auth.inv, 0, "Invalid block header.\n");	428	this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, 0, "Invalid block header.\n");
426	goto cleanup;	429	goto cleanup;
427	}	430	}
428	this->write("BYE 16777989\r\n");	431	this->write("BYE 16777989\r\n");
429	ext::fileTransferSucceeded(this->auth.inv);	432	this->myNotificationServer()->externalCallbacks.fileTransferSucceeded(this->auth.inv);
430		433
431	goto cleanup;	434	goto cleanup;
432	}	435	}
433	else if (blockHeader[0] != 0U)	436	else if (blockHeader[0] != 0U)
434	{	437	{
435	ext::fileTransferFailed(this->auth.inv, 0, "Invalid block header.");	438	this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, 0, "Invalid block header.");
436	goto cleanup;	439	goto cleanup;
437	}	440	}
438		441
Lines 440-446 Link Here
440	blockLength = ((unsigned char) blockHeader[1]) \| ((unsigned char) blockHeader[2]) << 8;	443	blockLength = ((unsigned char) blockHeader[1]) \| ((unsigned char) blockHeader[2]) << 8;
441	if (blockLength > MAX_FTP_BLOCK_SIZE)	444	if (blockLength > MAX_FTP_BLOCK_SIZE)
442	{	445	{
443	ext::fileTransferFailed(this->auth.inv, 0, "Block size greater than largest expected block size.");	446	this->myNotificationServer()->externalCallbacks.fileTransferFailed(this->auth.inv, 0, "Block size greater than largest expected block size.");
444	goto cleanup;	447	goto cleanup;
445	}	448	}
446		449
Lines 459-473 Link Here
459	// that indicates success isnt sent...	462	// that indicates success isnt sent...
460		463
461	this->write("BYE 16777989\r\n");	464	this->write("BYE 16777989\r\n");
462	ext::fileTransferSucceeded(this->auth.inv);	465	this->myNotificationServer()->externalCallbacks.fileTransferSucceeded(this->auth.inv);
463	goto cleanup;	466	goto cleanup;
464	}	467	}
465	ext::fileTransferProgress(this->auth.inv, "Receiving file", this->auth.bytes_done, this->auth.inv->fileSize);	468	this->myNotificationServer()->externalCallbacks.fileTransferProgress(this->auth.inv, "Receiving file", this->auth.bytes_done, this->auth.inv->fileSize);
466	}	469	}
467	return;	470	return;
468	cleanup:	471	cleanup:
469	;	472	;
470	this->auth.inv->switchboardConnection->invitationsReceived.remove(this->auth.inv);	473	this->auth.inv->switchboardConnection->invitationsReceived.remove(this->auth.inv);
		474	if (this->auth.fd)
		475	{
		476	fclose(this->auth.fd);
		477	this->auth.fd = NULL;
		478	}
471	}	479	}
472		480
473	void FileTransferInvitation::rejectTransfer()	481	void FileTransferInvitation::rejectTransfer()

Line 0 Link Here

(-)centericq-4.21.0.orig/libmsn-0.1/msn/md5.h (+94 lines)
		1	/*
		2	Copyright (C) 1999 Aladdin Enterprises. All rights reserved.
		3
		4	This software is provided 'as-is', without any express or implied
		5	warranty. In no event will the authors be held liable for any damages
		6	arising from the use of this software.
		7
		8	Permission is granted to anyone to use this software for any purpose,
		9	including commercial applications, and to alter it and redistribute it
		10	freely, subject to the following restrictions:
		11
		12	1. The origin of this software must not be misrepresented; you must not
		13	claim that you wrote the original software. If you use this software
		14	in a product, an acknowledgment in the product documentation would be
		15	appreciated but is not required.
		16	2. Altered source versions must be plainly marked as such, and must not be
		17	misrepresented as being the original software.
		18	3. This notice may not be removed or altered from any source distribution.
		19
		20	L. Peter Deutsch
		21	ghost@aladdin.com
		22
		23	*/
		24	/$Id: md5.h,v 1.3 2002/10/11 06:49:22 jtownsend Exp $ /
		25	/*
		26	Independent implementation of MD5 (RFC 1321).
		27
		28	This code implements the MD5 Algorithm defined in RFC 1321.
		29	It is derived directly from the text of the RFC and not from the
		30	reference implementation.
		31
		32	The original and principal author of md5.h is L. Peter Deutsch
		33	<ghost@aladdin.com>. Other authors are noted in the change history
		34	that follows (in reverse chronological order):
		35
		36	1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
		37	1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
		38	added conditionalization for C++ compilation from Martin
		39	Purschke <purschke@bnl.gov>.
		40	1999-05-03 lpd Original version.
		41	*/
		42
		43	#ifndef md5_INCLUDED
		44	# define md5_INCLUDED
		45
		46	/*
		47	* This code has some adaptations for the Ghostscript environment, but it
		48	* will compile and run correctly in any environment with 8-bit chars and
		49	* 32-bit ints. Specifically, it assumes that if the following are
		50	* defined, they have the same meaning as in Ghostscript: P1, P2, P3,
		51	* ARCH_IS_BIG_ENDIAN.
		52	*/
		53
		54	typedef unsigned char md5_byte_t; /* 8-bit byte */
		55	typedef unsigned int md5_word_t; /* 32-bit word */
		56
		57	/* Define the state of the MD5 Algorithm. */
		58	typedef struct md5_state_s {
		59	md5_word_t count[2]; /* message length in bits, lsw first */
		60	md5_word_t abcd[4]; /* digest buffer */
		61	md5_byte_t buf[64]; /* accumulate block */
		62	} md5_state_t;
		63
		64	#ifdef __cplusplus
65	extern "C"
66	{
67	#endif
68
69	/* Initialize the algorithm. */
70	#ifdef P1
71	void md5_init(P1(md5_state_t *pms));
72	#else
73	void md5_init(md5_state_t *pms);
74	#endif
75
76	/* Append a string to the message. */
77	#ifdef P3
78	void md5_append(P3(md5_state_t pms, const md5_byte_t data, int nbytes));
79	#else
80	void md5_append(md5_state_t pms, const md5_byte_t data, int nbytes);
81	#endif
82
83	/* Finish the message and return the digest. */
84	#ifdef P2
85	void md5_finish(P2(md5_state_t *pms, md5_byte_t digest[16]));
86	#else
87	void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
88	#endif
89
90	#ifdef __cplusplus
91	} /* end extern "C" */
92	#endif
93
94	#endif /* md5_INCLUDED */

Line 0 Link Here

(-)centericq-4.21.0.orig/libmsn-0.1/msn/msntest.cpp (+647 lines)
		1	/*
		2	* msntest.cpp
		3	* libmsn
		4	*
		5	* Created by Meredydd Luff.
		6	* Copyright (c) 2004 Meredydd Luff. All rights reserved.
		7	*
		8	* This program is free software; you can redistribute it and/or modify
		9	* it under the terms of the GNU General Public License as published by
		10	* the Free Software Foundation; either version 2 of the License, or
		11	* (at your option) any later version.
		12	*
		13	* This program is distributed in the hope that it will be useful,
		14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		16	* GNU General Public License for more details.
		17	*
		18	* You should have received a copy of the GNU General Public License
		19	* along with this program; if not, write to the Free Software
		20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		21	*/
		22
		23	#include <errno.h>
		24	#include <sys/types.h>
		25	#include <sys/socket.h>
		26	#include <unistd.h>
		27	#include <sys/stat.h>
		28	#include <sys/poll.h>
		29	#include <arpa/inet.h>
		30	#include <fcntl.h>
		31	#include <netinet/in.h>
		32	#include <netdb.h>
		33	#include <stdlib.h>
		34	#include <string.h>
		35
		36	#include <msn/msn.h>
		37	#include <string>
		38	#include <iostream>
		39
		40	class Callbacks : public MSN::Callbacks
		41	{
		42
		43	virtual void registerSocket(int s, int read, int write);
		44	virtual void unregisterSocket(int s);
		45
		46	virtual void showError(MSN::Connection * conn, std::string msg);
		47
		48	virtual void buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::BuddyStatus state);
		49	virtual void buddyOffline(MSN::Connection * conn, MSN::Passport buddy);
		50
		51	virtual void log(int writing, const char* buf);
		52
		53	virtual void gotFriendlyName(MSN::Connection * conn, std::string friendlyname);
		54	virtual void gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data);
		55	virtual void gotLatestListSerial(MSN::Connection * conn, int serial);
		56	virtual void gotGTC(MSN::Connection * conn, char c);
		57	virtual void gotBLP(MSN::Connection * conn, char c);
		58
		59	virtual void gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
		60
		61	virtual void addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
		62
		63	virtual void removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
		64
65	virtual void addedGroup(MSN::Connection * conn, std::string groupName, int groupID);
66	virtual void removedGroup(MSN::Connection * conn, int groupID);
67	virtual void renamedGroup(MSN::Connection * conn, int groupID, std::string newGroupName);
68
69	virtual void gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag);
70
71	virtual void buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial);
72
73	virtual void buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy);
74
75	virtual void gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg);
76
77	virtual void failedSendingMessage(MSN::Connection * conn);
78
79	virtual void buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
80
81	virtual void gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders);
82
83	virtual void gotNewEmailNotification(MSN::Connection * conn, std::string from, std::string subject);
84
85	virtual void gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv);
86
87	virtual void fileTransferProgress(MSN::FileTransferInvitation * inv, std::string status, unsigned long recv, unsigned long total);
88
89	virtual void fileTransferFailed(MSN::FileTransferInvitation * inv, int error, std::string message);
90
91	virtual void fileTransferSucceeded(MSN::FileTransferInvitation * inv);
92
93	virtual void gotNewConnection(MSN::Connection * conn);
94
95	virtual void closingConnection(MSN::Connection * conn);
96
97	virtual void changedStatus(MSN::Connection * conn, MSN::BuddyStatus state);
98
99	virtual int connectToServer(std::string server, int port, bool *connected);
100
101	virtual int listenOnPort(int port);
102
103	virtual std::string getOurIP();
104
105	virtual std::string getSecureHTTPProxy();
106	};
107
108	struct pollfd mySockets[21];
109
110	void handle_command(MSN::NotificationServerConnection &);
111	int countsocks(void);
112
113	int main()
114	{
115	for (int i = 1; i < 20; i++)
116	{
117	mySockets[i].fd = -1;
118	mySockets[i].events = POLLIN;
119	mySockets[i].revents = 0;
120	}
121
122	mySockets[0].fd = 0;
123	mySockets[0].events = POLLIN;
124	mySockets[0].revents = 0;
125
126	Callbacks cb;
127	MSN::Passport uname;
128	char *pass = NULL;
129	while (1)
130	{
131	fprintf(stderr, "Enter your login name: ");
132	fflush(stdout);
133	try
134	{
135	std::cin >> uname;
136	break;
137	}
138	catch (MSN::InvalidPassport & e)
139	{
140	std::cout << e.what() << std::endl;
141	}
142	}
143
144	pass = getpass("Enter your password: ");
145
146	fprintf(stderr, "Connecting to the MSN Messenger service...\n");
147
148	MSN::NotificationServerConnection mainConnection(uname, pass, cb);
149	mainConnection.connect("messenger.hotmail.com", 1863);
150
151	fprintf(stderr, "> ");
152	fflush(stderr);
153	while (1)
154	{
155	poll(mySockets, 20, -1);
156	for (int i = 1; i < 20; i++)
157	{
158	if (mySockets[i].fd == -1)
159	break;
160
161	if (mySockets[i].revents & POLLHUP)
162	{
163	mySockets[i].revents = 0;
164	continue;
165	}
166
167	if (mySockets[i].revents & (POLLERR \| POLLNVAL))
168	{
169	printf("Dud socket (%d)! Code %x (ERR=%x, INVAL=%x)\n", mySockets[i].fd, mySockets[i].revents, POLLERR, POLLNVAL);
170
171	MSN::Connection *c;
172
173	// Retrieve the connection associated with the
174	// socket's file handle on which the event has
175	// occurred.
176	c = mainConnection.connectionWithSocket(mySockets[i].fd);
177
178	// if this is a libmsn socket
179	if (c != NULL)
180	{
181	// Delete the connection. This will cause the resources
182	// that are being used to be freed.
183	delete c;
184	}
185
186	mySockets[i].fd = -1;
187	mySockets[i].revents = 0;
188	continue;
189	}
190
191	if (mySockets[i].revents & (POLLIN \| POLLOUT \| POLLPRI))
192	{
193	MSN::Connection *c;
194
195	// Retrieve the connection associated with the
196	// socket's file handle on which the event has
197	// occurred.
198	c = mainConnection.connectionWithSocket(mySockets[i].fd);
199
200	// if this is a libmsn socket
201	if (c != NULL)
202	{
203	// If we aren't yet connected, a socket event means that
204	// our connection attempt has completed.
205	if (c->isConnected() == false)
206	c->socketConnectionCompleted();
207
208	// If this event is due to new data becoming available
209	if (mySockets[i].revents & POLLIN)
210	c->dataArrivedOnSocket();
211
212	// If this event is due to the socket becoming writable
213	if (mySockets[i].revents & POLLOUT)
214	c->socketIsWritable();
215	}
216	}
217	mySockets[i].revents = 0;
218	}
219
220	if (mySockets[0].revents & POLLIN)
221	{
222	handle_command(mainConnection);
223	mySockets[0].revents = 0;
224	}
225	}
226	}
227
228	void handle_command(MSN::NotificationServerConnection & mainConnection)
229	{
230	char command[40];
231
232	if (scanf(" %s", command) == EOF)
233	{
234	printf("\n");
235	exit(0);
236	}
237
238	if (!strcmp(command, "quit"))
239	{
240	exit(0);
241	} else if (!strcmp(command, "msg")) {
242	char rcpt[80];
243	char msg[1024];
244
245	scanf(" %s", rcpt);
246
247	fgets(msg, 1024, stdin);
248
249	msg[strlen(msg)-1] = '\0';
250
251	const std::string rcpt_ = rcpt;
252	const std::string msg_ = msg;
253	const std::pair<std::string, std::string> *ctx = new std::pair<std::string, std::string>(rcpt_, msg_);
254	mainConnection.requestSwitchboardConnection(ctx);
255	} else if (!strcmp(command, "status")) {
256	char state[10];
257
258	scanf(" %s", state);
259
260	mainConnection.setState(MSN::buddyStatusFromString(state));
261	} else if (!strcmp(command, "friendlyname")) {
262	char fn[256];
263
264	fgets(fn, 256, stdin);
265	fn[strlen(fn)-1] = '\0';
266
267	mainConnection.setFriendlyName(fn);
268	} else if (!strcmp(command, "add")) {
269	char list[10];
270	char user[128];
271
272	scanf(" %s %s", list, user);
273
274	mainConnection.addToList(list, user);
275	} else if (!strcmp(command, "del")) {
276	char list[10];
277	char user[128];
278
279	scanf(" %s %s", list, user);
280
281	mainConnection.removeFromList(list, user);
282	} else if (!strcmp(command, "reconnect")) {
283	if (mainConnection.connectionState() != MSN::NotificationServerConnection::NS_DISCONNECTED)
284	mainConnection.disconnect();
285
286	mainConnection.connect("messenger.hotmail.com", 1863);
287	} else if (!strcmp(command, "disconnect")) {
288	mainConnection.disconnect();
289	} else {
290	fprintf(stderr, "\nBad command \"%s\"", command);
291	}
292
293	fprintf(stderr, "\n> ");
294	fflush(stderr);
295	}
296
297	int countsocks(void)
298	{
299	int retval = 0;
300
301	for (int a = 0; a < 20; a++)
302	{
303	if (mySockets[a].fd == -1)
304	break;
305
306	retval++;
307	}
308	return retval;
309	}
310
311	void Callbacks::registerSocket(int s, int reading, int writing)
312	{
313	for (int a = 1; a < 20; a++)
314	{
315	if (mySockets[a].fd == -1)
316	{
317	mySockets[a].events = 0;
318	if (reading)
319	mySockets[a].events \|= POLLIN;
320
321	if (writing)
322	mySockets[a].events \|= POLLOUT;
323
324	mySockets[a].fd = s;
325	return;
326	}
327	}
328	}
329
330	void Callbacks::unregisterSocket(int s)
331	{
332	for (int a = 1; a < 20; a++)
333	{
334	if (mySockets[a].fd == s)
335	{
336	for (int b = a; b < 19; b++)
337	mySockets[b].fd = mySockets[b + 1].fd;
338
339	mySockets[19].fd = -1;
340	}
341	}
342	}
343
344	void Callbacks::gotFriendlyName(MSN::Connection * conn, std::string friendlyname)
345	{
346	printf("Your friendlyname is now: %s\n", friendlyname.c_str());
347	}
348
349	void Callbacks::gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * info)
350	{
351	int a;
352	std::list<MSN::Buddy> & list = info->forwardList;
353	std::list<MSN::Buddy>::iterator i;
354
355	for (a = 0; a < 4; a++)
356	{
357	switch (a)
358	{
359	case 0:
360	{
361	list = info->forwardList;
362	printf("Forward list:\n");
363	break;
364	}
365
366	case 1:
367	{
368	list = info->reverseList;
369	printf("Reverse list:\n");
370	break;
371	}
372
373	case 2:
374	{
375	list = info->allowList;
376	printf("Allow list:\n");
377	break;
378	}
379
380	case 3:
381	{
382	list = info->blockList;
383	printf("Block list:\n");
384	break;
385	}
386	}
387
388	for (i = list.begin(); i != list.end(); i++)
389	{
390	printf("- %s (%s)\n", (i).friendlyName.c_str(), (i).userName.c_str());
391	std::list<MSN::Buddy::PhoneNumber>::iterator pns = (*i).phoneNumbers.begin();
392	std::list<MSN::Group >::iterator g = (i).groups.begin();
393	for (; g != (*i).groups.end(); g++)
394	{
395	printf(" G: %s\n", (*g)->name.c_str());
396	}
397
398	for (; pns != (*i).phoneNumbers.end(); pns++)
399	{
400	printf(" %s: %s (%d)\n", (pns).title.c_str(), (pns).number.c_str(), (*pns).enabled);
401	}
402	}
403	}
404
405	printf("Available Groups:\n");
406	std::map<int, MSN::Group>::iterator g = info->groups.begin();
407	for (; g != info->groups.end(); g++)
408	{
409	printf(" %d: %s\n", (g).second.groupID, (g).second.name.c_str());
410	}
411	}
412
413	void Callbacks::gotLatestListSerial(MSN::Connection * conn, int serial)
414	{
415	printf("The latest serial number is: %d\n", serial);
416	}
417
418	void Callbacks::gotGTC(MSN::Connection * conn, char c)
419	{
420	printf("Your GTC value is now %c\n", c);
421	}
422
423	void Callbacks::gotBLP(MSN::Connection * conn, char c)
424	{
425	printf("Your BLP value is now %cL\n", c);
426	}
427
428	void Callbacks::gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport username, std::string friendlyname)
429	{
430	printf("%s (%s) has added you to their contact list.\nYou might want to add them to your Allow or Block list\n", username.c_str(), friendlyname.c_str());
431	}
432
433	void Callbacks::addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport username, int groupID)
434	{
435	printf("%s is now on your %s, group %d\n", username.c_str(), list.c_str(), groupID);
436	}
437
438	void Callbacks::removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport username, int groupID)
439	{
440	printf("%s has been removed from your %s, group %d\n", username.c_str(), list.c_str(), groupID);
441	}
442
443	void Callbacks::addedGroup(MSN::Connection *conn, std::string groupName, int groupID)
444	{
445	printf("A group named %s (%d) was added\n", groupName.c_str(), groupID);
446	}
447
448	void Callbacks::removedGroup(MSN::Connection *conn, int groupID)
449	{
450	printf("A group with ID %d was removed\n", groupID);
451	}
452
453	void Callbacks::renamedGroup(MSN::Connection *conn, int groupID, std::string newGroupName)
454	{
455	printf("A group with ID %d was renamed to %s\n", groupID, newGroupName.c_str());
456	}
457
458	void Callbacks::showError(MSN::Connection * conn, std::string msg)
459	{
460	printf("MSN: Error: %s\n", msg.c_str());
461	}
462
463	void Callbacks::buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::BuddyStatus status)
464	{
465	printf("%s (%s) is now %s\n", friendlyname.c_str(), buddy.c_str(), MSN::buddyStatusToString(status).c_str());
466	}
467
468	void Callbacks::buddyOffline(MSN::Connection *conn, MSN::Passport buddy)
469	{
470	printf("%s is now offline\n", buddy.c_str());
471	}
472
473	void Callbacks::gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag)
474	{
475	printf("Got switchboard connection\n");
476	if (tag)
477	{
478	const std::pair<std::string, std::string> ctx = static_cast<const std::pair<std::string, std::string> >(tag);
479	conn->inviteUser(ctx->first);
480	}
481	}
482
483	void Callbacks::buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport username, std::string friendlyname, int is_initial)
484	{
485	printf("%s (%s) is now in the session\n", friendlyname.c_str(), username.c_str());
486	if (conn->auth.tag)
487	{
488	const std::pair<std::string, std::string> ctx = static_cast<const std::pair<std::string, std::string> >(conn->auth.tag);
489	conn->sendMessage(ctx->second);
490	delete ctx;
491	conn->auth.tag = NULL;
492	}
493	}
494
495	void Callbacks::buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport username)
496	{
497	printf("%s has now left the session\n", username.c_str());
498	}
499
500	void Callbacks::gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport username, std::string friendlyname, MSN::Message * msg)
501	{
502	printf("--- Message from %s (%s) in font %s:\n%s\n", friendlyname.c_str(), username.c_str(), msg->getFontName().c_str(), msg->getBody().c_str());
503	}
504
505	void Callbacks::failedSendingMessage(MSN::Connection * conn)
506	{
507	printf("**************************************************\n");
508	printf("ERROR: Your last message failed to send correctly\n");
509	printf("**************************************************\n");
510	}
511
512	void Callbacks::buddyTyping(MSN::Connection * conn, MSN::Passport username, std::string friendlyname)
513	{
514	printf("\t%s (%s) is typing...\n", friendlyname.c_str(), username.c_str());
515	}
516
517	void Callbacks::gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders)
518	{
519	if (unread_inbox > 0)
520	printf("You have %d new messages in your Inbox\n", unread_inbox);
521
522	if (unread_folders > 0)
523	printf("You have %d new messages in other folders.\n", unread_folders);
524	}
525
526	void Callbacks::gotNewEmailNotification(MSN::Connection * conn, std::string from, std::string subject)
527	{
528	printf("New e-mail has arrived from %s.\nSubject: %s\n", from.c_str(), subject.c_str());
529	}
530
531	void Callbacks::gotFileTransferInvitation(MSN::Connection conn, MSN::Passport username, std::string friendlyname, MSN::FileTransferInvitation inv)
532	{
533	printf("Got file transfer invitation from %s (%s)\n", friendlyname.c_str(), username.c_str());
534	inv->acceptTransfer("tmp.out");
535	}
536
537	void Callbacks::fileTransferProgress(MSN::FileTransferInvitation * inv, std::string status, unsigned long sent, unsigned long total)
538	{
539	printf("File transfer: %s\t(%lu/%lu bytes sent)\n", status.c_str(), sent, total);
540	}
541
542	void Callbacks::fileTransferFailed(MSN::FileTransferInvitation * inv, int error, std::string message)
543	{
544	printf("File transfer failed: %s\n", message.c_str());
545	}
546
547	void Callbacks::fileTransferSucceeded(MSN::FileTransferInvitation * inv)
548	{
549	printf("File transfer successfully completed\n");
550	}
551
552	void Callbacks::gotNewConnection(MSN::Connection * conn)
553	{
554	if (dynamic_cast<MSN::NotificationServerConnection *>(conn))
555	dynamic_cast<MSN::NotificationServerConnection *>(conn)->synchronizeLists();
556	}
557
558	void Callbacks::closingConnection(MSN::Connection * conn)
559	{
560	printf("Closed connection with socket %d\n", conn->sock);
561	}
562
563	void Callbacks::changedStatus(MSN::Connection * conn, MSN::BuddyStatus state)
564	{
565	printf("Your state is now: %s\n", MSN::buddyStatusToString(state).c_str());
566	}
567
568	int Callbacks::connectToServer(std::string hostname, int port, bool *connected)
569	{
570	struct sockaddr_in sa;
571	struct hostent *hp;
572	int s;
573
574	if ((hp = gethostbyname(hostname.c_str())) == NULL) {
575	errno = ECONNREFUSED;
576	return -1;
577	}
578
579	memset(&sa,0,sizeof(sa));
580	memcpy((char )&sa.sin_addr,hp->h_addr,hp->h_length); / set address */
581	sa.sin_family = hp->h_addrtype;
582	sa.sin_port = htons((u_short)port);
583
584	if ((s = socket(hp->h_addrtype,SOCK_STREAM,0)) < 0) /* get socket */
585	return -1;
586
587	int oldfdArgs = fcntl(s, F_GETFL, 0);
588	fcntl(s, F_SETFL, oldfdArgs \| O_NONBLOCK);
589
590	if (connect(s,(struct sockaddr *)&sa,sizeof sa) < 0)
591	{
592	if (errno != EINPROGRESS)
593	{
594	close(s);
595	return -1;
596	}
597	*connected = false;
598	}
599	else
600	*connected = true;
601
602	return s;
603	}
604
605	int Callbacks::listenOnPort(int port)
606	{
607	int s;
608	struct sockaddr_in addr;
609
610	if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
611	{
612	return -1;
613	}
614
615	memset(&addr, 0, sizeof(addr));
616	addr.sin_family = AF_INET;
617	addr.sin_port = htons(port);
618
619	if (bind(s, (sockaddr *)(&addr), sizeof(addr)) < 0 \|\| listen(s, 1) < 0)
620	{
621	close(s);
622	return -1;
623	}
624
625	return s;
626	}
627
628	std::string Callbacks::getOurIP(void)
629	{
630	struct hostent * hn;
631	char buf2[1024];
632
633	gethostname(buf2,1024);
634	hn = gethostbyname(buf2);
635
636	return inet_ntoa( ((struct in_addr)hn->h_addr));
637	}
638
639	void Callbacks::log(int i, const char *s)
640	{
641
642	}
643
644	std::string Callbacks::getSecureHTTPProxy()
645	{
646	return "";
647	}

Lines 29-34 Link Here

(-)centericq-4.21.0.orig/libmsn-0.1/msn/notificationserver.h (-6 / +13 lines)
29	#include <msn/buddy.h>	29	#include <msn/buddy.h>
30	#include <msn/passport.h>	30	#include <msn/passport.h>
31	#include <stdexcept>	31	#include <stdexcept>
		32	#include <msn/externals.h>
32		33
33	namespace MSN	34	namespace MSN
34	{	35	{
Lines 154-168 Link Here
154	public:	155	public:
155	/** Create a NotificationServerConnection with the specified authentication data	156	/** Create a NotificationServerConnection with the specified authentication data
156	*/	157	*/
157	NotificationServerConnection(AuthData & auth_);	158	NotificationServerConnection(AuthData & auth_, Callbacks & cb);
158		159
159	/** Create a NotificationServerConnection with the specified @a username and	160	/** Create a NotificationServerConnection with the specified @a username and
160	* @a password.	161	* @a password.
161	*/	162	*/
162	NotificationServerConnection(Passport username, std::string password);	163	NotificationServerConnection(Passport username, std::string password, Callbacks & cb);
163		164
164	/** Create a NotificationServerConnection with no specified username or password. */	165	/** Create a NotificationServerConnection with no specified username or password. */
165	NotificationServerConnection();	166	NotificationServerConnection(Callbacks & cb);
166		167
167	virtual ~NotificationServerConnection();	168	virtual ~NotificationServerConnection();
168	virtual void dispatchCommand(std::vector<std::string> & args);	169	virtual void dispatchCommand(std::vector<std::string> & args);
Lines 283-293 Link Here
283	NS_ONLINE	284	NS_ONLINE
284	};	285	};
285		286
286	NotificationServerState connectionState() const { return this->connectionStatus; };	287	NotificationServerState connectionState() const { return this->_connectionState; };
		288	Callbacks & externalCallbacks;
		289	virtual NotificationServerConnection *myNotificationServer() { return this; };
287	protected:	290	protected:
288	virtual void handleIncomingData();	291	virtual void handleIncomingData();
289	NotificationServerState connectionStatus;	292	NotificationServerState _connectionState;
290		293
		294	void setConnectionState(NotificationServerState s) { this->_connectionState = s; };
		295	void assertConnectionStateIs(NotificationServerState s) { assert(this->_connectionState == s); };
		296	void assertConnectionStateIsNot(NotificationServerState s) { assert(this->_connectionState != s); };
		297	void assertConnectionStateIsAtLeast(NotificationServerState s) { assert(this->_connectionState >= s); };
291	private:	298	private:
292	std::list<SwitchboardServerConnection *> _switchboardConnections;	299	std::list<SwitchboardServerConnection *> _switchboardConnections;
293	std::map<int, std::pair<NotificationServerCallback, void *> > callbacks;	300	std::map<int, std::pair<NotificationServerCallback, void *> > callbacks;

Lines 86-92 Link Here

(-)centericq-4.21.0.orig/src/hooks/msnhook.cc (-71 / +71 lines)
86		86
87	// ----------------------------------------------------------------------------	87	// ----------------------------------------------------------------------------
88		88
89	msnhook::msnhook(): abstracthook(msn), conn() {	89	msnhook::msnhook(): abstracthook(msn), conn(cb) {
90	ourstatus = offline;	90	ourstatus = offline;
91	fonline = false;	91	fonline = false;
92	destroying = false;	92	destroying = false;
Lines 605-623 Link Here
605	face.log(s);	605	face.log(s);
606	}	606	}
607		607
608	void MSN::ext::log(int writing, const char* buf) {	608	void msncallbacks::log(int writing, const char* buf) {
609	string pref = writing ? "OUT" : "IN";	609	string pref = writing ? "OUT" : "IN";
610	::log((string) "[" + pref + "] " + buf);	610	::log((string) "[" + pref + "] " + buf);
611	}	611	}
612		612
613	void MSN::ext::registerSocket(int s, int reading, int writing) {	613	void msncallbacks::registerSocket(int s, int reading, int writing) {
614	::log("MSN::ext::registerSocket");	614	::log("msncallbacks::registerSocket");
615	if(reading) mhook.rfds.push_back(s);	615	if(reading) mhook.rfds.push_back(s);
616	if(writing) mhook.wfds.push_back(s);	616	if(writing) mhook.wfds.push_back(s);
617	}	617	}
618		618
619	void MSN::ext::unregisterSocket(int s) {	619	void msncallbacks::unregisterSocket(int s) {
620	::log("MSN::ext::unregisterSocket");	620	::log("msncallbacks::unregisterSocket");
621	vector<int>::iterator i;	621	vector<int>::iterator i;
622		622
623	i = find(mhook.rfds.begin(), mhook.rfds.end(), s);	623	i = find(mhook.rfds.begin(), mhook.rfds.end(), s);
Lines 627-640 Link Here
627	if(i != mhook.wfds.end()) mhook.wfds.erase(i);	627	if(i != mhook.wfds.end()) mhook.wfds.erase(i);
628	}	628	}
629		629
630	void MSN::ext::gotFriendlyName(MSN::Connection * conn, string friendlyname) {	630	void msncallbacks::gotFriendlyName(MSN::Connection * conn, string friendlyname) {
631	::log("MSN::ext::gotFriendlyName");	631	::log("msncallbacks::gotFriendlyName");
632	if(!friendlyname.empty())	632	if(!friendlyname.empty())
633	mhook.friendlynicks[conf.getourid(msn).nickname] = friendlyname;	633	mhook.friendlynicks[conf.getourid(msn).nickname] = friendlyname;
634	}	634	}
635		635
636	void MSN::ext::gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data) {	636	void msncallbacks::gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data) {
637	::log("MSN::ext::gotBuddyListInfo");	637	::log("msncallbacks::gotBuddyListInfo");
638	imcontact ic;	638	imcontact ic;
639	bool found;	639	bool found;
640		640
Lines 689-708 Link Here
689	face.update();	689	face.update();
690	}	690	}
691		691
692	void MSN::ext::gotLatestListSerial(MSN::Connection * conn, int serial) {	692	void msncallbacks::gotLatestListSerial(MSN::Connection * conn, int serial) {
693	::log("MSN::ext::gotLatestListSerial");	693	::log("msncallbacks::gotLatestListSerial");
694	}	694	}
695		695
696	void MSN::ext::gotGTC(MSN::Connection * conn, char c) {	696	void msncallbacks::gotGTC(MSN::Connection * conn, char c) {
697	::log("MSN::ext::gotGTC");	697	::log("msncallbacks::gotGTC");
698	}	698	}
699		699
700	void MSN::ext::gotBLP(MSN::Connection * conn, char c) {	700	void msncallbacks::gotBLP(MSN::Connection * conn, char c) {
701	::log("MSN::ext::gotBLP");	701	::log("msncallbacks::gotBLP");
702	}	702	}
703		703
704	void MSN::ext::gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname) {	704	void msncallbacks::gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname) {
705	::log("MSN::ext::gotNewReverseListEntry");	705	::log("msncallbacks::gotNewReverseListEntry");
706		706
707	try {	707	try {
708	mhook.conn.addToList("AL", buddy);	708	mhook.conn.addToList("AL", buddy);
Lines 714-726 Link Here
714	em.store(imnotification(ic, _("The user has added you to his/her contact list")));	714	em.store(imnotification(ic, _("The user has added you to his/her contact list")));
715	}	715	}
716		716
717	void MSN::ext::addedListEntry(MSN::Connection * conn, string lst, MSN::Passport buddy, int groupID) {	717	void msncallbacks::addedListEntry(MSN::Connection * conn, string lst, MSN::Passport buddy, int groupID) {
718	::log("MSN::ext::addedListEntry");	718	::log("msncallbacks::addedListEntry");
719	mhook.slst[lst].push_back(msnbuddy(buddy, "", groupID));	719	mhook.slst[lst].push_back(msnbuddy(buddy, "", groupID));
720	}	720	}
721		721
722	void MSN::ext::removedListEntry(MSN::Connection * conn, string lst, MSN::Passport buddy, int groupID) {	722	void msncallbacks::removedListEntry(MSN::Connection * conn, string lst, MSN::Passport buddy, int groupID) {
723	::log("MSN::ext::removedListEntry");	723	::log("msncallbacks::removedListEntry");
724	vector<msnbuddy>::iterator i = mhook.slst[lst].begin();	724	vector<msnbuddy>::iterator i = mhook.slst[lst].begin();
725	while(i != mhook.slst[lst].end()) {	725	while(i != mhook.slst[lst].end()) {
726	if(i->nick == buddy) {	726	if(i->nick == buddy) {
Lines 732-753 Link Here
732	}	732	}
733	}	733	}
734		734
735	void MSN::ext::showError(MSN::Connection * conn, string msg) {	735	void msncallbacks::showError(MSN::Connection * conn, string msg) {
736	::log(msg);	736	::log(msg);
737	}	737	}
738		738
739	void MSN::ext::buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, string friendlyname, MSN::BuddyStatus state) {	739	void msncallbacks::buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, string friendlyname, MSN::BuddyStatus state) {
740	::log("MSN::ext::buddyChangedStatus");	740	::log("msncallbacks::buddyChangedStatus");
741	mhook.statusupdate(buddy, friendlyname, buddy2stat(state));	741	mhook.statusupdate(buddy, friendlyname, buddy2stat(state));
742	}	742	}
743		743
744	void MSN::ext::buddyOffline(MSN::Connection * conn, MSN::Passport buddy) {	744	void msncallbacks::buddyOffline(MSN::Connection * conn, MSN::Passport buddy) {
745	::log("MSN::ext::buddyOffline");	745	::log("msncallbacks::buddyOffline");
746	mhook.statusupdate(buddy, "", offline);	746	mhook.statusupdate(buddy, "", offline);
747	}	747	}
748		748
749	void MSN::ext::gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag) {	749	void msncallbacks::gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag) {
750	::log("MSN::ext::gotSwitchboard");	750	::log("msncallbacks::gotSwitchboard");
751		751
752	if(tag) {	752	if(tag) {
753	const msnhook::qevent ctx = static_cast<const msnhook::qevent >(tag);	753	const msnhook::qevent ctx = static_cast<const msnhook::qevent >(tag);
Lines 755-762 Link Here
755	}	755	}
756	}	756	}
757		757
758	void MSN::ext::buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial) {	758	void msncallbacks::buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial) {
759	::log("MSN::ext::buddyJoinedConversation");	759	::log("msncallbacks::buddyJoinedConversation");
760	if(conn->auth.tag) {	760	if(conn->auth.tag) {
761	const msnhook::qevent ctx = static_cast<const msnhook::qevent >(conn->auth.tag);	761	const msnhook::qevent ctx = static_cast<const msnhook::qevent >(conn->auth.tag);
762	mhook.lconn[ctx->nick] = conn;	762	mhook.lconn[ctx->nick] = conn;
Lines 765-776 Link Here
765	}	765	}
766	}	766	}
767		767
768	void MSN::ext::buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy) {	768	void msncallbacks::buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy) {
769	::log("MSN::ext::buddyLeftConversation");	769	::log("msncallbacks::buddyLeftConversation");
770	}	770	}
771		771
772	void MSN::ext::gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg) {	772	void msncallbacks::gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg) {
773	::log("MSN::ext::gotInstantMessage");	773	::log("msncallbacks::gotInstantMessage");
774	imcontact ic(nicktodisp(buddy), msn);	774	imcontact ic(nicktodisp(buddy), msn);
775		775
776	mhook.checkinlist(ic);	776	mhook.checkinlist(ic);
Lines 779-808 Link Here
779	em.store(immessage(ic, imevent::incoming, text));	779	em.store(immessage(ic, imevent::incoming, text));
780	}	780	}
781		781
782	void MSN::ext::failedSendingMessage(MSN::Connection * conn) {	782	void msncallbacks::failedSendingMessage(MSN::Connection * conn) {
783	::log("MSN::ext::failedSendingMessage");	783	::log("msncallbacks::failedSendingMessage");
784	}	784	}
785		785
786	void MSN::ext::buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname) {	786	void msncallbacks::buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname) {
787	::log("MSN::ext::buddyTyping");	787	::log("msncallbacks::buddyTyping");
788	icqcontact *c = clist.get(imcontact(nicktodisp(buddy), msn));	788	icqcontact *c = clist.get(imcontact(nicktodisp(buddy), msn));
789	if(c) c->setlasttyping(timer_current);	789	if(c) c->setlasttyping(timer_current);
790	}	790	}
791		791
792	void MSN::ext::gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders) {	792	void msncallbacks::gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders) {
793	::log("MSN::ext::gotInitialEmailNotification");	793	::log("msncallbacks::gotInitialEmailNotification");
794	face.log(_("+ [msn] unread e-mail: %d in inbox, %d in folders"),	794	face.log(_("+ [msn] unread e-mail: %d in inbox, %d in folders"),
795	unread_inbox, unread_folders);	795	unread_inbox, unread_folders);
796	}	796	}
797		797
798	void MSN::ext::gotNewEmailNotification(MSN::Connection * conn, string from, string subject) {	798	void msncallbacks::gotNewEmailNotification(MSN::Connection * conn, string from, string subject) {
799	::log("MSN::ext::gotNewEmailNotification");	799	::log("msncallbacks::gotNewEmailNotification");
800	face.log(_("+ [msn] e-mail from %s, %s"), from.c_str(), subject.c_str());	800	face.log(_("+ [msn] e-mail from %s, %s"), from.c_str(), subject.c_str());
801	clist.get(contactroot)->playsound(imevent::email);	801	clist.get(contactroot)->playsound(imevent::email);
802	}	802	}
803		803
804	void MSN::ext::gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv) {	804	void msncallbacks::gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv) {
805	::log("MSN::ext::gotFileTransferInvitation");	805	::log("msncallbacks::gotFileTransferInvitation");
806	if(!mhook.fcapabs.count(hookcapab::files))	806	if(!mhook.fcapabs.count(hookcapab::files))
807	return;	807	return;
808		808
Lines 821-828 Link Here
821	face.transferupdate(inv->fileName, fr, icqface::tsInit, inv->fileSize, 0);	821	face.transferupdate(inv->fileName, fr, icqface::tsInit, inv->fileSize, 0);
822	}	822	}
823		823
824	void MSN::ext::fileTransferProgress(MSN::FileTransferInvitation * inv, string status, unsigned long recv, unsigned long total) {	824	void msncallbacks::fileTransferProgress(MSN::FileTransferInvitation * inv, string status, unsigned long recv, unsigned long total) {
825	::log("MSN::ext::fileTransferProgress");	825	::log("msncallbacks::fileTransferProgress");
826	imfile fr;	826	imfile fr;
827		827
828	if(mhook.getfevent(inv, fr)) {	828	if(mhook.getfevent(inv, fr)) {
Lines 831-838 Link Here
831	}	831	}
832	}	832	}
833		833
834	void MSN::ext::fileTransferFailed(MSN::FileTransferInvitation * inv, int error, string message) {	834	void msncallbacks::fileTransferFailed(MSN::FileTransferInvitation * inv, int error, string message) {
835	::log("MSN::ext::fileTransferFailed");	835	::log("msncallbacks::fileTransferFailed");
836	imfile fr;	836	imfile fr;
837		837
838	if(mhook.getfevent(inv, fr)) {	838	if(mhook.getfevent(inv, fr)) {
Lines 841-848 Link Here
841	}	841	}
842	}	842	}
843		843
844	void MSN::ext::fileTransferSucceeded(MSN::FileTransferInvitation * inv) {	844	void msncallbacks::fileTransferSucceeded(MSN::FileTransferInvitation * inv) {
845	::log("MSN::ext::fileTransferSucceeded");	845	::log("msncallbacks::fileTransferSucceeded");
846	imfile fr;	846	imfile fr;
847		847
848	if(mhook.getfevent(inv, fr)) {	848	if(mhook.getfevent(inv, fr)) {
Lines 851-864 Link Here
851	}	851	}
852	}	852	}
853		853
854	void MSN::ext::gotNewConnection(MSN::Connection * conn) {	854	void msncallbacks::gotNewConnection(MSN::Connection * conn) {
855	::log("MSN::ext::gotNewConnection");	855	::log("msncallbacks::gotNewConnection");
856	if(dynamic_cast<MSN::NotificationServerConnection *>(conn))	856	if(dynamic_cast<MSN::NotificationServerConnection *>(conn))
857	dynamic_cast<MSN::NotificationServerConnection *>(conn)->synchronizeLists();	857	dynamic_cast<MSN::NotificationServerConnection *>(conn)->synchronizeLists();
858	}	858	}
859		859
860	void MSN::ext::closingConnection(MSN::Connection * conn) {	860	void msncallbacks::closingConnection(MSN::Connection * conn) {
861	::log("MSN::ext::closingConnection");	861	::log("msncallbacks::closingConnection");
862		862
863	MSN::SwitchboardServerConnection *swc;	863	MSN::SwitchboardServerConnection *swc;
864		864
Lines 894-905 Link Here
894	unregisterSocket(conn->sock);	894	unregisterSocket(conn->sock);
895	}	895	}
896		896
897	void MSN::ext::changedStatus(MSN::Connection * conn, MSN::BuddyStatus state) {	897	void msncallbacks::changedStatus(MSN::Connection * conn, MSN::BuddyStatus state) {
898	::log("MSN::ext::changedStatus");	898	::log("msncallbacks::changedStatus");
899	}	899	}
900		900
901	int MSN::ext::connectToServer(string server, int port, bool *connected) {	901	int msncallbacks::connectToServer(string server, int port, bool *connected) {
902	::log("MSN::ext::connectToServer");	902	::log("msncallbacks::connectToServer");
903	struct sockaddr_in sa;	903	struct sockaddr_in sa;
904	struct hostent *hp;	904	struct hostent *hp;
905	int a, s;	905	int a, s;
Lines 936-943 Link Here
936	return s;	936	return s;
937	}	937	}
938		938
939	int MSN::ext::listenOnPort(int port) {	939	int msncallbacks::listenOnPort(int port) {
940	::log("MSN::ext::listenOnPort");	940	::log("msncallbacks::listenOnPort");
941	int s;	941	int s;
942	struct sockaddr_in addr;	942	struct sockaddr_in addr;
943		943
Lines 956-963 Link Here
956	return s;	956	return s;
957	}	957	}
958		958
959	string MSN::ext::getOurIP() {	959	string msncallbacks::getOurIP() {
960	::log("MSN::ext::getOurIP");	960	::log("msncallbacks::getOurIP");
961	struct hostent *hn;	961	struct hostent *hn;
962	char buf2[1024];	962	char buf2[1024];
963		963
Lines 967-979 Link Here
967	return inet_ntoa(((struct in_addr) hn->h_addr));	967	return inet_ntoa(((struct in_addr) hn->h_addr));
968	}	968	}
969		969
970	string MSN::ext::getSecureHTTPProxy() {	970	string msncallbacks::getSecureHTTPProxy() {
971	::log("MSN::ext::getSecureHTTPProxy");	971	::log("msncallbacks::getSecureHTTPProxy");
972	return "";	972	return "";
973	}	973	}
974		974
975	void MSN::ext::addedGroup(MSN::Connection * conn, string groupName, int groupID) {	975	void msncallbacks::addedGroup(MSN::Connection * conn, string groupName, int groupID) {
976	::log("MSN::ext::addedGroup");	976	::log("msncallbacks::addedGroup");
977	int i;	977	int i;
978	icqcontact *c;	978	icqcontact *c;
979		979
Lines 994-1006 Link Here
994	}	994	}
995	}	995	}
996		996
997	void MSN::ext::renamedGroup(MSN::Connection * conn, int groupID, string newGroupName) {	997	void msncallbacks::renamedGroup(MSN::Connection * conn, int groupID, string newGroupName) {
998	::log("MSN::ext::renamedGroup");	998	::log("msncallbacks::renamedGroup");
999	mhook.mgroups[groupID] = newGroupName;	999	mhook.mgroups[groupID] = newGroupName;
1000	}	1000	}
1001		1001
1002	void MSN::ext::removedGroup(MSN::Connection * conn, int groupID) {	1002	void msncallbacks::removedGroup(MSN::Connection * conn, int groupID) {
1003	::log("MSN::ext::removedGroup");	1003	::log("msncallbacks::removedGroup");
1004	mhook.mgroups.erase(groupID);	1004	mhook.mgroups.erase(groupID);
1005	}	1005	}
1006		1006

Lines 20-68 Link Here

(-)centericq-4.21.0.orig/src/hooks/msnhook.h (-36 / +77 lines)
20	{ return nick != anick; }	20	{ return nick != anick; }
21	};	21	};
22		22
		23	class msncallbacks : public MSN::Callbacks {
		24	public:
		25	void registerSocket(int s, int read, int write);
		26	void unregisterSocket(int s);
		27	void showError(MSN::Connection * conn, std::string msg);
		28	void buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::BuddyStatus state);
		29	void buddyOffline(MSN::Connection * conn, MSN::Passport buddy);
		30	void log(int writing, const char* buf);
		31	void gotFriendlyName(MSN::Connection * conn, std::string friendlyname);
		32	void gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data);
		33	void gotLatestListSerial(MSN::Connection * conn, int serial);
		34	void gotGTC(MSN::Connection * conn, char c);
		35	void gotBLP(MSN::Connection * conn, char c);
		36	void gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
		37	void addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
		38	void removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
		39	void addedGroup(MSN::Connection * conn, std::string groupName, int groupID);
		40	void removedGroup(MSN::Connection * conn, int groupID);
		41	void renamedGroup(MSN::Connection * conn, int groupID, std::string newGroupName);
		42	void gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag);
		43	void buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial);
		44	void buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy);
		45	void gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg);
		46	void failedSendingMessage(MSN::Connection * conn);
		47	void buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
		48	void gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders);
		49	void gotNewEmailNotification(MSN::Connection * conn, std::string from, std::string subject);
		50	void gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv);
		51	void fileTransferProgress(MSN::FileTransferInvitation * inv, std::string status, unsigned long recv, unsigned long total);
		52	void fileTransferFailed(MSN::FileTransferInvitation * inv, int error, std::string message);
		53	void fileTransferSucceeded(MSN::FileTransferInvitation * inv);
		54	void gotNewConnection(MSN::Connection * conn);
		55	void closingConnection(MSN::Connection * conn);
		56	void changedStatus(MSN::Connection * conn, MSN::BuddyStatus state);
		57	int connectToServer(std::string server, int port, bool *connected);
		58	int listenOnPort(int port);
		59	std::string getOurIP();
		60	std::string getSecureHTTPProxy();
		61	};
		62
23	class msnhook : public abstracthook {	63	class msnhook : public abstracthook {
24		64
25	friend void MSN::ext::registerSocket(int s, int reading, int writing);	65	friend void msncallbacks::registerSocket(int s, int reading, int writing);
26	friend void MSN::ext::unregisterSocket(int s);	66	friend void msncallbacks::unregisterSocket(int s);
27	friend void MSN::ext::showError(MSN::Connection * conn, string msg);	67	friend void msncallbacks::showError(MSN::Connection * conn, string msg);
28	friend void MSN::ext::buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, string friendlyname, MSN::BuddyStatus state);	68	friend void msncallbacks::buddyChangedStatus(MSN::Connection * conn, MSN::Passport buddy, string friendlyname, MSN::BuddyStatus state);
29	friend void MSN::ext::buddyOffline(MSN::Connection * conn, MSN::Passport buddy);	69	friend void msncallbacks::buddyOffline(MSN::Connection * conn, MSN::Passport buddy);
30	friend void MSN::ext::log(int writing, const char* buf);	70	friend void msncallbacks::log(int writing, const char* buf);
31	friend void MSN::ext::gotFriendlyName(MSN::Connection * conn, string friendlyname);	71	friend void msncallbacks::gotFriendlyName(MSN::Connection * conn, string friendlyname);
32	friend void MSN::ext::gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data);	72	friend void msncallbacks::gotBuddyListInfo(MSN::NotificationServerConnection * conn, MSN::ListSyncInfo * data);
33	friend void MSN::ext::gotLatestListSerial(MSN::Connection * conn, int serial);	73	friend void msncallbacks::gotLatestListSerial(MSN::Connection * conn, int serial);
34	friend void MSN::ext::gotGTC(MSN::Connection * conn, char c);	74	friend void msncallbacks::gotGTC(MSN::Connection * conn, char c);
35	friend void MSN::ext::gotBLP(MSN::Connection * conn, char c);	75	friend void msncallbacks::gotBLP(MSN::Connection * conn, char c);
36	friend void MSN::ext::gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);	76	friend void msncallbacks::gotNewReverseListEntry(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
37	friend void MSN::ext::addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);	77	friend void msncallbacks::addedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
38	friend void MSN::ext::removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);	78	friend void msncallbacks::removedListEntry(MSN::Connection * conn, std::string list, MSN::Passport buddy, int groupID);
39	friend void MSN::ext::addedGroup(MSN::Connection * conn, string groupName, int groupID);	79	friend void msncallbacks::addedGroup(MSN::Connection * conn, string groupName, int groupID);
40	friend void MSN::ext::removedGroup(MSN::Connection * conn, int groupID);	80	friend void msncallbacks::removedGroup(MSN::Connection * conn, int groupID);
41	friend void MSN::ext::renamedGroup(MSN::Connection * conn, int groupID, string newGroupName);	81	friend void msncallbacks::renamedGroup(MSN::Connection * conn, int groupID, string newGroupName);
42	friend void MSN::ext::gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag);	82	friend void msncallbacks::gotSwitchboard(MSN::SwitchboardServerConnection * conn, const void * tag);
43	friend void MSN::ext::buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial);	83	friend void msncallbacks::buddyJoinedConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, int is_initial);
44	friend void MSN::ext::buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy);	84	friend void msncallbacks::buddyLeftConversation(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy);
45	friend void MSN::ext::gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg);	85	friend void msncallbacks::gotInstantMessage(MSN::SwitchboardServerConnection * conn, MSN::Passport buddy, std::string friendlyname, MSN::Message * msg);
46	friend void MSN::ext::failedSendingMessage(MSN::Connection * conn);	86	friend void msncallbacks::failedSendingMessage(MSN::Connection * conn);
47	friend void MSN::ext::buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);	87	friend void msncallbacks::buddyTyping(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname);
48	friend void MSN::ext::gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders);	88	friend void msncallbacks::gotInitialEmailNotification(MSN::Connection * conn, int unread_inbox, int unread_folders);
49	friend void MSN::ext::gotNewEmailNotification(MSN::Connection * conn, string from, string subject);	89	friend void msncallbacks::gotNewEmailNotification(MSN::Connection * conn, string from, string subject);
50	friend void MSN::ext::gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv);	90	friend void msncallbacks::gotFileTransferInvitation(MSN::Connection * conn, MSN::Passport buddy, std::string friendlyname, MSN::FileTransferInvitation * inv);
51	friend void MSN::ext::fileTransferProgress(MSN::FileTransferInvitation * inv, string status, unsigned long recv, unsigned long total);	91	friend void msncallbacks::fileTransferProgress(MSN::FileTransferInvitation * inv, string status, unsigned long recv, unsigned long total);
52	friend void MSN::ext::fileTransferFailed(MSN::FileTransferInvitation * inv, int error, string message);	92	friend void msncallbacks::fileTransferFailed(MSN::FileTransferInvitation * inv, int error, string message);
53	friend void MSN::ext::fileTransferSucceeded(MSN::FileTransferInvitation * inv);	93	friend void msncallbacks::fileTransferSucceeded(MSN::FileTransferInvitation * inv);
54	friend void MSN::ext::gotNewConnection(MSN::Connection * conn);	94	friend void msncallbacks::gotNewConnection(MSN::Connection * conn);
55	friend void MSN::ext::closingConnection(MSN::Connection * conn);	95	friend void msncallbacks::closingConnection(MSN::Connection * conn);
56	friend void MSN::ext::changedStatus(MSN::Connection * conn, MSN::BuddyStatus state);	96	friend void msncallbacks::changedStatus(MSN::Connection * conn, MSN::BuddyStatus state);
57	friend int MSN::ext::connectToServer(string server, int port, bool *connected);	97	friend int msncallbacks::connectToServer(string server, int port, bool *connected);
58	friend int MSN::ext::listenOnPort(int port);	98	friend int msncallbacks::listenOnPort(int port);
59	friend string MSN::ext::getOurIP();	99	friend string msncallbacks::getOurIP();
60	friend string MSN::ext::getSecureHTTPProxy();	100	friend string msncallbacks::getSecureHTTPProxy();
61		101
62	protected:	102	protected:
63	imstatus ourstatus;	103	imstatus ourstatus;
64	bool fonline, flogged, readinfo, destroying;	104	bool fonline, flogged, readinfo, destroying;
65	MSN::NotificationServerConnection conn;	105	MSN::NotificationServerConnection conn;
		106	msncallbacks cb;
66	time_t timer_ping;	107	time_t timer_ping;
67		108
68	struct qevent {	109	struct qevent {