/*
Plugin of Miranda IM for communicating with users of the MSN Messenger protocol.
Copyright (c) 2006-2011 Boris Krasnovskiy.
Copyright (c) 2003-2005 George Hazan.
Copyright (c) 2002-2003 Richard Hughes (original version).

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, see <http://www.gnu.org/licenses/>.
*/

#include "msn_global.h"
#include "msn_proto.h"
#include "sdk/m_smileyadd.h"

static const char sttP2Pheader[] =
	"Content-Type: application/x-msnmsgrp2p\r\n"
	"P2P-Dest: %s\r\n\r\n";

static const char sttP2PheaderV2[] =
	"Content-Type: application/x-msnmsgrp2p\r\n"
	"P2P-Dest: %s\r\n"
	"P2P-Src: %s;%s\r\n\r\n";

const char sttVoidUid[] = "{00000000-0000-0000-0000-000000000000}";
static const char szUbnCall[] = "{F13B5C79-0126-458F-A29D-747C79C56530}";

static const char p2pV2Caps[] = { 0x01, 0x0C, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0F, 0x01, 0x00, 0x00 }; 

void P2P_Header::logHeader(CMsnProto *ppro)
{
	ppro->MSN_DebugLog("--- Printing message header");
	ppro->MSN_DebugLog("    SessionID = %08X", mSessionID);
	ppro->MSN_DebugLog("    MessageID = %08X", mID);
#ifndef __GNUC__
	ppro->MSN_DebugLog("    Offset of data = %I64u", mOffset);
	ppro->MSN_DebugLog("    Total amount of data = %I64u", mTotalSize);
#else
	ppro->MSN_DebugLog("    Offset of data = %llu", mOffset);
	ppro->MSN_DebugLog("    Total amount of data = %llu", hdrdata->mTotalSize);
#endif
	ppro->MSN_DebugLog("    Data in packet = %lu bytes", mPacketLen);
	ppro->MSN_DebugLog("    Flags = %08X", mFlags);
	ppro->MSN_DebugLog("    Acknowledged session ID: %08X", mAckSessionID);
	ppro->MSN_DebugLog("    Acknowledged message ID: %08X", mAckUniqueID);
#ifndef __GNUC__
	ppro->MSN_DebugLog("    Acknowledged data size: %I64u", mAckDataSize);
#else
	ppro->MSN_DebugLog("    Acknowledged data size: %llu", mAckDataSize);
#endif
	ppro->MSN_DebugLog("------------------------");
}

void P2PV2_Header::logHeader(CMsnProto *ppro)
{
	ppro->MSN_DebugLog("--- Printing message header");
	ppro->MSN_DebugLog("    SessionID = %08X", mSessionID);
	ppro->MSN_DebugLog("    MessageID = %08X", mID);
#ifndef __GNUC__
	ppro->MSN_DebugLog("    Remaining amount of data = %I64u", mRemSize);
#else
	ppro->MSN_DebugLog("    Remaining amount of data = %llu", mTotalSize);
#endif
	ppro->MSN_DebugLog("    Data in packet = %lu bytes", mPacketLen);
	ppro->MSN_DebugLog("    Packet Number = %lu", mPacketNum);
	ppro->MSN_DebugLog("    Operation Code = %08X", mOpCode);
	ppro->MSN_DebugLog("    TF Code = %08X", mTFCode);
	ppro->MSN_DebugLog("    Acknowledged message ID: %08X", mAckUniqueID);
	ppro->MSN_DebugLog("------------------------");
}

bool CMsnProto::p2p_createListener(filetransfer* ft, directconnection *dc, MimeHeaders& chdrs)
{
	if (MyConnection.extIP == 0) return false;
	
	NETLIBBIND nlb = {0};
	nlb.cbSize = sizeof(nlb);
	nlb.pfnNewConnectionV2 = MSN_ConnectionProc;
	nlb.pExtra = this;
	HANDLE sb = (HANDLE) MSN_CallService(MS_NETLIB_BINDPORT, (WPARAM) hNetlibUser, (LPARAM)&nlb);
	if (sb == NULL) 
	{
		MSN_DebugLog("Unable to bind the port for incoming transfers");
		return false;
	}

	ThreadData* newThread = new ThreadData;
	newThread->mType = SERVER_P2P_DIRECT;
	newThread->mCaller = 3;
	newThread->mIncomingBoundPort = sb;
	newThread->mIncomingPort = nlb.wPort;
	strncpy(newThread->mCookie, dc->callId , sizeof(newThread->mCookie));
	newThread->mInitialContactWLID = mir_strdup(ft->p2p_dest);

	newThread->startThread(&CMsnProto::p2p_filePassiveThread, this);

	char hostname[256] = "";

	gethostname(hostname, sizeof(hostname));
	PHOSTENT he = gethostbyname(hostname);

	hostname[0] = 0;
	bool ipInt = false;
	for (unsigned i = 0; i < sizeof(hostname) / 16; ++i) 
	{
		const PIN_ADDR addr = (PIN_ADDR)he->h_addr_list[i];

		if (addr == NULL) break;
		if (i != 0) strcat(hostname, " ");
		ipInt |= (addr->S_un.S_addr == MyConnection.extIP);
		strcat(hostname, inet_ntoa(*addr));
	}

	chdrs.addString("Bridge", "TCPv1");
	chdrs.addBool("Listening", true);

	if (dc->useHashedNonce)
		chdrs.addString("Hashed-Nonce", dc->mNonceToHash(), 2);
	else
		chdrs.addString("Nonce", dc->mNonceToText(), 2);

	bool bUbnCall = !ft->p2p_sessionid;

	if (!ipInt)
	{
		chdrs.addString("IPv4External-Addrs", mir_strdup(MyConnection.GetMyExtIPStr()), bUbnCall ? 6 : 2);
		chdrs.addLong("IPv4External-Port", nlb.wExPort, bUbnCall ? 4 : 0);
	}
	chdrs.addString("IPv4Internal-Addrs", mir_strdup(hostname), bUbnCall ? 6 : 2);
	chdrs.addLong("IPv4Internal-Port", nlb.wPort, bUbnCall ? 4 : 0);
	chdrs.addULong("SessionID", ft->p2p_sessionid);
	chdrs.addString("SChannelState", "0");
	chdrs.addString("Capabilities-Flags", "1");

	return true;
}

bool p2p_IsDlFileOk(filetransfer* ft)
{
	mir_sha1_ctx sha1ctx;
	BYTE sha[MIR_SHA1_HASH_SIZE];
	mir_sha1_init(&sha1ctx);

	bool res = false;

	int fileId = _topen(ft->std.tszCurrentFile, O_RDONLY | _O_BINARY, _S_IREAD);
	if (fileId != -1) 
	{
		BYTE buf[4096];
		int bytes;

		while((bytes = _read(fileId, buf, sizeof(buf))) > 0)
			mir_sha1_append(&sha1ctx, buf, bytes);

		_close(fileId);
		mir_sha1_finish(&sha1ctx, sha);

		char *szSha = arrayToHex(sha, MIR_SHA1_HASH_SIZE);
		char *szAvatarHash = MSN_GetAvatarHash(ft->p2p_object);

		res = szAvatarHash != NULL && _stricmp(szAvatarHash, szSha) == 0;

		mir_free(szSha);
		mir_free(szAvatarHash);
	}
	return res;
}



/////////////////////////////////////////////////////////////////////////////////////////
// sttSavePicture2disk - final handler for avatars downloading

void CMsnProto::p2p_pictureTransferFailed(filetransfer* ft)
{
	switch(ft->p2p_type)
	{
	case MSN_APPID_AVATAR:
	case MSN_APPID_AVATAR2:
		{
			PROTO_AVATAR_INFORMATION AI = {0};
			AI.cbSize = sizeof(AI);
			AI.hContact = ft->std.hContact;
			deleteSetting(ft->std.hContact, "AvatarHash");
			SendBroadcast(AI.hContact, ACKTYPE_AVATAR, ACKRESULT_FAILED, &AI, 0);
		}
		break;
	}
	_tremove(ft->std.tszCurrentFile);
}

void CMsnProto::p2p_savePicture2disk(filetransfer* ft)
{
	ft->close();

	if (p2p_IsDlFileOk(ft))
	{
		int fileId = _topen(ft->std.tszCurrentFile, O_RDONLY | _O_BINARY, _S_IREAD);
		if (fileId == -1) 
		{
			p2p_pictureTransferFailed(ft);
			return;
		}

		const char* ext;
		int format;
		BYTE buf[6];

		int bytes = _read(fileId, buf, sizeof(buf));
		_close(fileId);
		if (bytes > 4)
			format = MSN_GetImageFormat(buf, &ext);
		else
		{
			p2p_pictureTransferFailed(ft);
			return;
		}

		switch(ft->p2p_type)
		{
		case MSN_APPID_AVATAR:
		case MSN_APPID_AVATAR2:
			{
				PROTO_AVATAR_INFORMATION AI = {0};
				AI.cbSize = sizeof(AI);
				AI.format = format;
				AI.hContact = ft->std.hContact;
				MSN_GetAvatarFileName(AI.hContact, AI.filename, sizeof(AI.filename), ext);

				TCHAR *aname = mir_a2t(AI.filename);
				_trename(ft->std.tszCurrentFile, aname);
				mir_free(aname);

				setString(ft->std.hContact, "PictSavedContext", ft->p2p_object);
				SendBroadcast(AI.hContact, ACKTYPE_AVATAR, ACKRESULT_SUCCESS, &AI, 0);

				// Store also avatar hash
				char *szAvatarHash = MSN_GetAvatarHash(ft->p2p_object);
				setString(ft->std.hContact, "AvatarSavedHash", szAvatarHash);
				MSN_DebugLog("Avatar for contact %08x saved to file '%s'", AI.hContact, AI.filename);
				mir_free(szAvatarHash);
			}
			break;

		case MSN_APPID_CUSTOMSMILEY:
		case MSN_APPID_CUSTOMANIMATEDSMILEY:
			{
				SMADD_CONT cont;
				cont.cbSize = sizeof(SMADD_CONT);
				cont.hContact = ft->std.hContact;
				cont.type = 1;

				TCHAR *extt = mir_a2t(ext);
				TCHAR* pathcpy = mir_tstrdup(ft->std.tszCurrentFile);
				_tcscpy(_tcsrchr(pathcpy, '.') + 1, extt);
				_trename(ft->std.tszCurrentFile, pathcpy);
				mir_free(extt);

				cont.path = pathcpy;

				MSN_CallService(MS_SMILEYADD_LOADCONTACTSMILEYS, 0, (LPARAM)&cont);
				mir_free(pathcpy);
			}
			break;
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////////////
// p2p_sendAck - sends MSN P2P acknowledgement to the received message

static const char sttVoidSession[] = "ACHTUNG!!! an attempt made to send a message via the empty session";

void  CMsnProto::p2p_sendMsg(const char *wlid, unsigned appId, P2PB_Header& hdrdata, char* msgbody, size_t msgsz)
{
	ThreadData* info = MSN_GetP2PThreadByContact(wlid);
	if (info == NULL)
	{
		bool isOffline;
		info = MSN_StartSB(wlid, isOffline);
	}
	p2p_sendMsg(info, wlid, appId, hdrdata, msgbody, msgsz);
}

void  CMsnProto::p2p_sendMsg(ThreadData* info, const char *wlid, unsigned appId, P2PB_Header& hdrdata, char* msgbody, size_t msgsz)
{
	unsigned msgType;

	if (info == NULL) msgType = 0;
	else if (info->mType == SERVER_P2P_DIRECT) msgType = 1;
	else msgType = 2;

	unsigned fportion = msgType == 1 ? 1352 : 1202;
	if (hdrdata.isV2Hdr()) fportion += 4;

	char* buf = (char*) alloca(sizeof(sttP2PheaderV2)+ MSN_MAX_EMAIL_LEN + 
		120 + fportion);

	size_t offset = 0;
	do 
	{
		size_t portion = msgsz - offset;
		if (portion > fportion) portion = fportion;

		char* p = buf;

		// add message header
		p += msgType == 1 ? sizeof(unsigned) : 
			sprintf(p, hdrdata.isV2Hdr() ? sttP2PheaderV2 : sttP2Pheader, wlid, MyOptions.szEmail, MyOptions.szMachineGuidP2P);

		if (hdrdata.isV2Hdr())
		{
			P2PV2_Header *ph = (P2PV2_Header*)&hdrdata; 
			if (offset == 0) 
			{
				if (!info || !info->mBridgeInit)
				{
					if (info && ph->mSessionID)
					{
						P2PV2_Header tHdr;
						tHdr.mID = ph->mID;
						p2p_sendMsg(info, wlid, 0, tHdr, NULL, 0);
					}
					else
					{
						ph->mOpCode |= ph->mAckUniqueID && msgType != 1 ? 1 : 3;
						ph->mCap = p2pV2Caps;
						if (info) info->mBridgeInit = true;
					}
				}
			}
			else 
			{
				ph->mOpCode = 0;
				ph->mCap = NULL;
			}
		}

		if (msgsz)
		{
			if (hdrdata.isV2Hdr())
			{
				P2PV2_Header *ph = (P2PV2_Header*)&hdrdata; 
				ph->mPacketLen = (unsigned)portion;
				ph->mRemSize = msgsz - offset - portion;
				ph->mTFCode = offset ?  ph->mTFCode & 0xfe : ph->mTFCode | 0x01;

				if (offset == 0)
					ph->mPacketNum = p2p_getPktNum(wlid);
			}
			else
			{
				P2P_Header *ph = (P2P_Header*)&hdrdata; 
				ph->mPacketLen = (unsigned)portion;
				ph->mOffset = offset;
				ph->mTotalSize = msgsz;
			}
		}

		// add message body
		p = hdrdata.createMsg(p, wlid, this);
		hdrdata.logHeader(this);

		if (msgsz)
			memcpy(p, msgbody + offset, portion); p += portion;

		// add message footer
		if (msgType != 1)
		{ 
			*(unsigned*)p = _htonl(appId);
			p += 4;
		}

		switch (msgType) 
		{
			case 0:
				MsgQueue_Add(wlid, 'D', buf, p - buf);
				break;

			case 1: 
				*(unsigned*)buf = (unsigned)(p - buf - sizeof(unsigned));
				info->send(buf, p - buf);
				break;

			case 2:
				info->sendRawMessage('D', buf, p - buf);
				break;
		}
		offset += portion;
	} 
	while( offset < msgsz );
}


void  CMsnProto::p2p_sendAck(const char *wlid, P2PB_Header* hdr)
{	
	if (hdr == NULL) return;

	if (!hdr->isV2Hdr())
	{
		P2P_Header *hdrdata = (P2P_Header*)hdr;
		P2P_Header tHdr;

		tHdr.mSessionID = hdrdata->mSessionID;
		tHdr.mAckDataSize = hdrdata->mTotalSize;
		tHdr.mFlags = 2;
		tHdr.mAckSessionID = hdrdata->mID;
		tHdr.mAckUniqueID = hdrdata->mAckSessionID;

		p2p_sendMsg(wlid, 0, tHdr, NULL, 0);
	}
	else
	{
		P2PV2_Header *hdrdata = (P2PV2_Header*)hdr;
		P2PV2_Header tHdr;

		tHdr.mAckUniqueID = hdrdata->mID;

		p2p_sendMsg(wlid, 0, tHdr, NULL, 0);
	}
}


/////////////////////////////////////////////////////////////////////////////////////////
// p2p_sendEndSession - sends MSN P2P file transfer end packet

void  CMsnProto::p2p_sendAbortSession(filetransfer* ft)
{
	if (ft == NULL) 
	{
		MSN_DebugLog(sttVoidSession);
		return;
	}

	if (ft->p2p_isV2) return;

	P2P_Header tHdr;

	tHdr.mSessionID = ft->p2p_sessionid;
	tHdr.mAckSessionID = ft->p2p_sendmsgid;
	tHdr.mID = p2p_getMsgId(ft->p2p_dest, 1);

	if (ft->std.flags & PFTS_SENDING) 
	{
		tHdr.mFlags = 0x40;
		tHdr.mAckSessionID = tHdr.mID - 2;
	}
	else 
	{
		tHdr.mAckUniqueID = 0x8200000f;
		tHdr.mFlags = 0x80;
		tHdr.mAckDataSize = ft->std.currentFileSize;
	}

	p2p_sendMsg(ft->p2p_dest, 0, tHdr, NULL, 0);
	ft->ts = time(NULL);
}

void  CMsnProto::p2p_sendRedirect(filetransfer* ft)
{
	if (ft == NULL) 
	{
		MSN_DebugLog(sttVoidSession);
		return;
	}

	if (ft->p2p_isV2) return;

	P2P_Header tHdr;

	tHdr.mSessionID = ft->p2p_sessionid;
	tHdr.mFlags = 0x01;
	tHdr.mAckSessionID = ft->p2p_sendmsgid;
	tHdr.mAckDataSize = ft->std.currentFileProgress;

	p2p_sendMsg(ft->p2p_dest, 0, tHdr, NULL, 0);

	ft->tTypeReq = MSN_GetP2PThreadByContact(ft->p2p_dest) ? SERVER_P2P_DIRECT : SERVER_SWITCHBOARD;
	ft->ts = time(NULL);
	ft->p2p_waitack = true;
}

/////////////////////////////////////////////////////////////////////////////////////////
// p2p_sendSlp - send MSN P2P SLP packet

void  CMsnProto::p2p_sendSlp(int iKind, filetransfer *ft, MimeHeaders &pHeaders,
	MimeHeaders &pContent, const char *wlid)
{
	if (ft == NULL) 
	{
		MSN_DebugLog(sttVoidSession);
		return;
	}

	if (wlid == NULL) wlid = ft->p2p_dest;

	size_t cbContLen = pContent.getLength();
	pHeaders.addULong("Content-Length", (unsigned)cbContLen + 1);

	char* buf = (char*)alloca(pHeaders.getLength() + cbContLen + 512);
	char* p = buf;

	switch (iKind) 
	{
		case -3:   p += sprintf(p, "ACK MSNMSGR:%s MSNSLP/1.0", wlid); break;
		case -2:   p += sprintf(p, "INVITE MSNMSGR:%s MSNSLP/1.0", wlid); break;
		case -1:   p += sprintf(p, "BYE MSNMSGR:%s MSNSLP/1.0", wlid); break;
		case 200:  p += sprintf(p, "MSNSLP/1.0 200 OK");	break;
		case 481:  p += sprintf(p, "MSNSLP/1.0 481 No Such Call"); break;
		case 500:  p += sprintf(p, "MSNSLP/1.0 500 Internal Error"); break;
		case 603:  p += sprintf(p, "MSNSLP/1.0 603 DECLINE"); break;
		case 1603: p += sprintf(p, "MSNSLP/1.0 603 Decline"); break;
		default: return;
	}
	
	if (iKind < 0) 
	{
		mir_free(ft->p2p_branch);
		ft->p2p_branch = getNewUuid();
	}

	if (ft->p2p_isV2)
	{
		p += sprintf(p,
			"\r\nTo: <msnmsgr:%s>\r\n"
			"From: <msnmsgr:%s;%s>\r\n"
			"Via: MSNSLP/1.0/TLP ;branch=%s\r\n", 
			wlid, MyOptions.szEmail, MyOptions.szMachineGuidP2P, ft->p2p_branch);
	}
	else
	{
		p += sprintf(p,
			"\r\nTo: <msnmsgr:%s>\r\n"
			"From: <msnmsgr:%s>\r\n"
			"Via: MSNSLP/1.0/TLP ;branch=%s\r\n", 
			wlid, MyOptions.szEmail, ft->p2p_branch);
	}

	p = pHeaders.writeToBuffer(p);
	p = pContent.writeToBuffer(p);

	unsigned short status = getWord(ft->std.hContact, "Status", ID_STATUS_OFFLINE);
	if (!(myFlags & cap_SupportsP2PBootstrap) || ft->p2p_sessionid || 
		MSN_GetThreadByContact(wlid, SERVER_P2P_DIRECT) ||
		status == ID_STATUS_OFFLINE || status == ID_STATUS_INVISIBLE || 
		m_iStatus == ID_STATUS_INVISIBLE)
	{
		if (!ft->p2p_isV2)
		{
			P2P_Header tHdr;
			tHdr.mAckSessionID = ft->p2p_acksessid;

			p2p_sendMsg(wlid, 0, tHdr, buf, p - buf + 1);
			ft->p2p_waitack = true;

			switch (iKind) 
			{
				case -1: case 500: case 603: 
					ft->p2p_byemsgid  = tHdr.mID; 
					break;
			}

		}
		else
		{
			P2PV2_Header tHdr;
			tHdr.mTFCode = 0x01;

			p2p_sendMsg(wlid, 0, tHdr, buf, p - buf + 1);
		}
	}
	else
		msnNsThread->sendPacket("UUN", "%s 3 %d\r\n%s", wlid, p - buf, buf);

	ft->ts = time(NULL);
}

/////////////////////////////////////////////////////////////////////////////////////////
// p2p_sendBye - closes P2P session

void  CMsnProto::p2p_sendBye(filetransfer* ft)
{
	if (ft == NULL) 
	{
		MSN_DebugLog(sttVoidSession);
		return;
	}

	MimeHeaders tHeaders(8);
	tHeaders.addString("CSeq", "0 ");
	tHeaders.addString("Call-ID", ft->p2p_callID);
	tHeaders.addLong("Max-Forwards", 0);
	tHeaders.addString("Content-Type", "application/x-msnmsgr-sessionclosebody");

	MimeHeaders chdrs(2);
	chdrs.addULong("SessionID", ft->p2p_sessionid);
	chdrs.addString("SChannelState", "0");

	p2p_sendSlp(-1, ft, tHeaders, chdrs);
}

void  CMsnProto::p2p_sendCancel(filetransfer* ft)
{
	p2p_sendBye(ft);
	p2p_sendAbortSession(ft);
}

void  CMsnProto::p2p_sendNoCall(filetransfer* ft)
{
	if (ft == NULL) 
	{
		MSN_DebugLog(sttVoidSession);
		return;
	}
	 
	MimeHeaders tHeaders(8);
	tHeaders.addString("CSeq", "0 ");
	tHeaders.addString("Call-ID", ft->p2p_callID);
	tHeaders.addLong("Max-Forwards", 0);
	tHeaders.addString("Content-Type", "application/x-msnmsgr-session-failure-respbody");

	MimeHeaders chdrs(2);
	chdrs.addULong("SessionID", ft->p2p_sessionid);
	chdrs.addString("SChannelState", "0");

	p2p_sendSlp(481, ft, tHeaders, chdrs);
}

/////////////////////////////////////////////////////////////////////////////////////////
// p2p_sendStatus - send MSN P2P status and its description

void  CMsnProto::p2p_sendStatus(filetransfer* ft, long lStatus)
{
	if (ft == NULL) 
	{
		MSN_DebugLog(sttVoidSession);
		return;
	}

	MimeHeaders tHeaders(8);
	tHeaders.addString("CSeq", "1 ");
	tHeaders.addString("Call-ID", ft->p2p_callID);
	tHeaders.addLong("Max-Forwards", 0);

	MimeHeaders chdrs(2);
	chdrs.addULong("SessionID", ft->p2p_sessionid);

	if (lStatus != 1603)
	{
		tHeaders.addString("Content-Type", "application/x-msnmsgr-sessionreqbody");

		chdrs.addString("SChannelState", "0");
	}
	else
		tHeaders.addString("Content-Type", "application/x-msnmsgr-transrespbody");

	p2p_sendSlp(lStatus, ft, tHeaders, chdrs);
}

void  CMsnProto::p2p_sendAvatarInit(filetransfer* ft)
{
	unsigned body = 0;

	if (ft->p2p_isV2)
	{
		P2PV2_Header tHdr;
		tHdr.mSessionID = ft->p2p_sessionid;
		tHdr.mTFCode = 0x01;
		p2p_sendMsg(ft->p2p_dest, ft->p2p_appID, tHdr, (char*)&body, sizeof(body));
	}
	else
	{
		P2P_Header tHdr;
		tHdr.mSessionID = ft->p2p_sessionid;
		tHdr.mAckSessionID = ft->p2p_acksessid;
		p2p_sendMsg(ft->p2p_dest, ft->p2p_appID, tHdr, (char*)&body, sizeof(body));

		ft->ts = time(NULL);
		ft->p2p_waitack = true;
	}
}


/////////////////////////////////////////////////////////////////////////////////////////
// p2p_connectTo - connects to a remote P2P server

static const char p2p_greeting[8] = { 4, 0, 0, 0, 'f', 'o', 'o', 0  };

static void sttSendPacket(ThreadData* T, void* hdr, unsigned len)
{
	T->send((char*)&len, sizeof(unsigned));
	T->send((char*)hdr, len);
}

bool CMsnProto::p2p_connectTo(ThreadData* info, directconnection *dc)
{
	NETLIBOPENCONNECTION tConn = {0};
	tConn.cbSize = sizeof(tConn);
	tConn.szHost = info->mServer;
	tConn.flags = NLOCF_V2;
	tConn.timeout = 5;

	char* tPortDelim = strrchr(info->mServer, ':');
	if (tPortDelim != NULL) 
	{
		*tPortDelim = '\0';
		tConn.wPort = (WORD)atol(tPortDelim + 1);
	}

	MSN_DebugLog("Connecting to %s:%d", tConn.szHost, tConn.wPort);

	info->s = (HANDLE)MSN_CallService(MS_NETLIB_OPENCONNECTION, (WPARAM)hNetlibUser, (LPARAM)&tConn);
	if (info->s == NULL)
	{
		TWinErrorCode err;
		MSN_DebugLog("Connection Failed (%d): %s", err.mErrorCode, err.getText());
		return false;
	}
	info->send(p2p_greeting, sizeof(p2p_greeting));

	bool isV2 = strchr(info->mInitialContactWLID, ';') != NULL;

	P2P_Header reply;
	if (!isV2)
	{
		reply.mFlags = 0x100;

		if (dc->useHashedNonce)
			memcpy(&reply.mAckSessionID, dc->mNonce, sizeof(UUID));
		else
			dc->xNonceToBin((UUID*)&reply.mAckSessionID);

		char buf[48];
		reply.createMsg(buf, info->mInitialContactWLID, this);
		sttSendPacket(info, buf, sizeof(buf));
	}
	else
		sttSendPacket(info, dc->mNonce, sizeof(UUID));

	long cbPacketLen;
	HReadBuffer buf(info, 0);
	BYTE* p;
	if ((p = buf.surelyRead(4)) == NULL) 
	{
		MSN_DebugLog("Error reading data, closing filetransfer");
		return false;
	}

	cbPacketLen = *(long*)p;
	if ((p = buf.surelyRead(cbPacketLen)) == NULL)
		return false;

	bool cookieMatch;

	if (!isV2)
	{
		P2P_Header cookie((char*)p);

		if (dc->useHashedNonce) 
		{
			char* hnonce = dc->calcHashedNonce((UUID*)&cookie.mAckSessionID);
			cookieMatch = strcmp(hnonce, dc->xNonce) == 0;
			mir_free(hnonce);
		}
		else
			cookieMatch = memcmp(&cookie.mAckSessionID, &reply.mAckSessionID, sizeof(UUID)) == 0;
	}
	else
	{
		char* hnonce = dc->calcHashedNonce((UUID*)p);
		cookieMatch = strcmp(hnonce, dc->xNonce) == 0;
		mir_free(hnonce);
	}

	if (!cookieMatch) 
	{
		MSN_DebugLog("Invalid cookie received, exiting");
		return false;
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////////////////
// p2p_listen - acts like a local P2P server

bool CMsnProto::p2p_listen(ThreadData* info, directconnection *dc)
{
	switch(WaitForSingleObject(info->hWaitEvent, 6000)) 
	{
	case WAIT_TIMEOUT:
	case WAIT_FAILED:
		MSN_DebugLog("Incoming connection timed out, closing file transfer");
		MSN_StartP2PTransferByContact(info->mInitialContactWLID);
LBL_Error:
		MSN_DebugLog("File listen failed");
		return false;
	}

	HReadBuffer buf(info, 0);
	BYTE* p;

	if ((p = buf.surelyRead(8)) == NULL)
		goto LBL_Error;

	if (memcmp(p, p2p_greeting, 8) != 0) 
	{
		MSN_DebugLog("Invalid input data, exiting");
		return false;
	}

	if ((p = buf.surelyRead(4)) == NULL) 
	{
		MSN_DebugLog("Error reading data, closing filetransfer");
		return false;
	}

	long cbPacketLen = *(long*)p;
	if ((p = buf.surelyRead(cbPacketLen)) == NULL)
		goto LBL_Error;

	bool cookieMatch;
	bool isV2 = strchr(info->mInitialContactWLID, ';') != NULL;

	if (!isV2)
	{
		P2P_Header cookie((char*)p);

		if (dc->useHashedNonce) 
		{
			char* hnonce = dc->calcHashedNonce((UUID*)&cookie.mAckSessionID);
			cookieMatch = strcmp(hnonce, dc->xNonce) == 0;
			mir_free(hnonce);
			memcpy(&cookie.mAckSessionID, dc->mNonce, sizeof(UUID));
		}
		else
			cookieMatch = memcmp(&cookie.mAckSessionID, dc->mNonce, sizeof(UUID)) == 0;

		if (!cookieMatch) 
		{
			MSN_DebugLog("Invalid cookie received, exiting");
			return false;
		}

		char buf[48];
		cookie.createMsg(buf, info->mInitialContactWLID, this);
		sttSendPacket(info, buf, sizeof(buf));
	}
	else
	{
		char* hnonce = dc->calcHashedNonce((UUID*)p);
		cookieMatch = strcmp(hnonce, dc->xNonce) == 0;
		mir_free(hnonce);

		if (!cookieMatch) 
		{
			MSN_DebugLog("Invalid cookie received, exiting");
			goto LBL_Error;
		}

		sttSendPacket(info, dc->mNonce, sizeof(UUID));
	}

	return true;
}

LONG  CMsnProto::p2p_sendPortion(filetransfer* ft, ThreadData* T, bool isV2)
{
	LONG trid;
	char databuf[1500], *p = databuf;

	// Compute the amount of data to send
	unsigned fportion = T->mType == SERVER_P2P_DIRECT ? 1352 : 1202;
	if (isV2) fportion += 4;
	
	const unsigned __int64 dt = ft->std.currentFileSize - ft->std.currentFileProgress;
	const unsigned portion = dt > fportion ? fportion : dt;

	// Fill data size for direct transfer

	if (T->mType != SERVER_P2P_DIRECT)
		p += sprintf(p, isV2 ? sttP2PheaderV2 : sttP2Pheader, ft->p2p_dest, MyOptions.szEmail, MyOptions.szMachineGuidP2P);
	else
		p += sizeof(unsigned);

	if (!isV2)
	{
		// Fill P2P header
		P2P_Header H;

		H.mSessionID = ft->p2p_sessionid;
		H.mID = ft->p2p_sendmsgid;
		H.mFlags = ft->p2p_appID == MSN_APPID_FILE ? 0x01000030 : 0x20;
		H.mTotalSize = ft->std.currentFileSize;
		H.mOffset = ft->std.currentFileProgress;
		H.mPacketLen = portion;
		H.mAckSessionID = ft->p2p_acksessid;

		p = H.createMsg(p, ft->p2p_dest, this);
	}
	else
	{
		P2PV2_Header H;

		H.mSessionID = ft->p2p_sessionid;
		H.mTFCode = (ft->p2p_appID == MSN_APPID_FILE ? 6 : 4) | (ft->std.currentFileProgress ? 0 : 1);
		H.mRemSize = ft->std.currentFileSize - ft->std.currentFileProgress - portion;
		H.mPacketLen = portion;
		H.mPacketNum = ft->p2p_sendmsgid;

		p = H.createMsg(p, ft->p2p_dest, this);
		H.logHeader(this);
	}

	if (T->mType == SERVER_P2P_DIRECT)
		*(unsigned*)databuf = portion + (p - databuf) - (unsigned)sizeof(unsigned);

	// Fill data (payload) for transfer
	_read(ft->fileId, p, portion);
	p += portion;

	if (T->mType == SERVER_P2P_DIRECT)
		trid = T->send(databuf, p - databuf);
	else
	{
		// Define packet footer for server transfer
		*(unsigned*)p = _htonl(ft->p2p_appID);
		p += sizeof(unsigned);

		trid = T->sendRawMessage('D', (char *)databuf, p - databuf);
	}

	if (trid != 0) 
	{
		ft->std.totalProgress += portion;
		ft->std.currentFileProgress += portion;
		if (ft->p2p_appID == MSN_APPID_FILE && clock() >= ft->nNotify)
		{
			SendBroadcast(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, (LPARAM)&ft->std);
			ft->nNotify = clock() + 500;
		}
	}
	else
		MSN_DebugLog(" Error sending");
	ft->ts = time(NULL);
	ft->p2p_waitack = true;

	return trid;
}

/////////////////////////////////////////////////////////////////////////////////////////
// p2p_sendFeedThread - sends a file via server

void __cdecl CMsnProto::p2p_sendFeedThread(void* arg)
{
	ThreadData* info = (ThreadData*)arg;

	bool isV2 = strchr(info->mInitialContactWLID, ';') != NULL;

	info->contactJoined(info->mInitialContactWLID);
	mir_free(info->mInitialContactWLID); info->mInitialContactWLID = NULL;

	MSN_DebugLog("File send thread started");

	switch(WaitForSingleObject(info->hWaitEvent, 6000)) 
	{
		case WAIT_FAILED:
			MSN_DebugLog("File send wait failed");
			return;
	}

	HANDLE hLockHandle = NULL;
	ThreadData* T = NULL;
	TInfoType lastType = SERVER_DISPATCH;

	filetransfer *ft = p2p_getSessionByCallID(info->mCookie, 
		info->mJoinedIdentContactsWLID.getCount() ? info->mJoinedIdentContactsWLID[0] : info->mJoinedContactsWLID[0]);

	if (ft != NULL && WaitForSingleObject(ft->hLockHandle, 2000) == WAIT_OBJECT_0)
	{
		hLockHandle = ft->hLockHandle;

		if (isV2)
			ft->p2p_sendmsgid = p2p_getPktNum(ft->p2p_dest);
		else
		{
			if (ft->p2p_sendmsgid == 0)
				ft->p2p_sendmsgid = p2p_getMsgId(ft->p2p_dest, 1);
		}

		T = MSN_GetP2PThreadByContact(ft->p2p_dest);
		if (T != NULL)
			ft->tType = lastType = T->mType;

		ReleaseMutex(hLockHandle);
	}
	else
		return;

	bool fault = false;
	while (WaitForSingleObject(hLockHandle, 2000) == WAIT_OBJECT_0 &&
		ft->std.currentFileProgress < ft->std.currentFileSize && !ft->bCanceled)
	{
		if (ft->tType != lastType)
			T = MSN_GetThreadByContact(ft->p2p_dest, ft->tType);

		bool cfault = (T == NULL || p2p_sendPortion(ft, T, isV2) == 0);

		if (cfault) 
		{
			if (fault) 
			{
				MSN_DebugLog("File send failed");
				break;
			}
			else
				SleepEx(3000, TRUE);  // Allow 3 sec for redirect request
		}
		fault = cfault;

		ReleaseMutex(hLockHandle);

		if (T != NULL && T->mType != SERVER_P2P_DIRECT)
			WaitForSingleObject(T->hWaitEvent, 5000);
	}
	ReleaseMutex(hLockHandle);
	SendBroadcast(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, (LPARAM)&ft->std);

	if (isV2 && ft->p2p_appID == MSN_APPID_FILE)
	{
		ft->bCompleted = true;
		p2p_sendBye(ft);
		p2p_sessionComplete(ft);
	}
	MSN_DebugLog("File send thread completed");
}


void  CMsnProto::p2p_sendFeedStart(filetransfer* ft)
{
	if (ft->std.flags & PFTS_SENDING)
	{
		ThreadData* newThread = new ThreadData;
		newThread->mType = SERVER_FILETRANS;
		strcpy(newThread->mCookie, ft->p2p_callID);
		newThread->mInitialContactWLID = mir_strdup(ft->p2p_dest);
		newThread->startThread(&CMsnProto::p2p_sendFeedThread, this);
	}	
}

/////////////////////////////////////////////////////////////////////////////////////////
// p2p_sendFileDirectly - sends a file via MSN P2P protocol

void CMsnProto::p2p_sendRecvFileDirectly(ThreadData* info)
{
	long cbPacketLen = 0;
	long state = 0;

	HReadBuffer buf(info, 0);
	char *wlid = info->mInitialContactWLID;

	info->contactJoined(wlid);
	info->mInitialContactWLID = NULL;

	MSN_StartP2PTransferByContact(wlid);
	p2p_redirectSessions(wlid);
	p2p_startSessions(wlid);

	bool isV2 = strchr(wlid, ';') != NULL;

	for (;;) 
	{
		long len = state ? cbPacketLen : 4;

		BYTE* p = buf.surelyRead(len);

		if (p == NULL)
			break;

		if (state == 0)
			cbPacketLen = *(long*)p;
		else if (!isV2)
			p2p_processMsg(info, (char*)p, wlid);
		else
			p2p_processMsgV2(info, (char*)p, wlid);

		state = (state + 1) % 2;
	}

	info->contactLeft(wlid);
	p2p_redirectSessions(wlid);
	mir_free(wlid);
}

/////////////////////////////////////////////////////////////////////////////////////////
// bunch of thread functions to cover all variants of P2P file transfers

void __cdecl CMsnProto::p2p_fileActiveThread(void* arg)
{
	ThreadData* info = (ThreadData*)arg;

	MSN_DebugLog("p2p_fileActiveThread() started: connecting to '%s'", info->mServer);

	directconnection *dc = p2p_getDCByCallID(info->mCookie, info->mInitialContactWLID);
	if (dc)
	{
		if (p2p_connectTo(info, dc))
			p2p_sendRecvFileDirectly(info);
		else
		{
			mir_free(info->mInitialContactWLID);
			info->mInitialContactWLID = NULL;
		}

		if (!MSN_GetThreadByContact(dc->wlid, SERVER_P2P_DIRECT) && !MSN_GetUnconnectedThread(dc->wlid, SERVER_P2P_DIRECT))
			p2p_unregisterDC(dc);
	}

	MSN_DebugLog("p2p_fileActiveThread() completed: connecting to '%s'", info->mServer);
}

void __cdecl CMsnProto::p2p_filePassiveThread(void* arg)
{
	ThreadData* info = (ThreadData*)arg;

	MSN_DebugLog("p2p_filePassiveThread() started: listening");

	directconnection *dc = p2p_getDCByCallID(info->mCookie, info->mInitialContactWLID);
	if (dc)
	{
		if (p2p_listen(info, dc))
			p2p_sendRecvFileDirectly(info);
		else
		{
			mir_free(info->mInitialContactWLID); info->mInitialContactWLID = NULL;
		}

		if (!MSN_GetThreadByContact(dc->wlid, SERVER_P2P_DIRECT) && !MSN_GetUnconnectedThread(dc->wlid, SERVER_P2P_DIRECT))
			p2p_unregisterDC(dc);
	}

	MSN_DebugLog("p2p_filePassiveThread() completed");
}


void CMsnProto::p2p_InitFileTransfer(
	ThreadData*		info,
	MimeHeaders&	tFileInfo,
	MimeHeaders&	tFileInfo2, 
	const char* wlid)
{
	if (info->mJoinedContactsWLID.getCount() == 0 && info->mJoinedIdentContactsWLID.getCount() == 0)
		return;

	const char	*szCallID = tFileInfo["Call-ID"],
				*szBranch = tFileInfo["Via"];

	if (szBranch != NULL) {
		szBranch = strstr(szBranch, "branch=");
		if (szBranch != NULL)
			szBranch += 7;
	}
	if (szCallID == NULL || szBranch == NULL) {
		MSN_DebugLog("Ignoring invalid invitation: CallID='%s', szBranch='%s'", szCallID, szBranch);
		return;
	}

	const char	*szSessionID = tFileInfo2["SessionID"],
				*szEufGuid   = tFileInfo2["EUF-GUID"],
				*szContext   = tFileInfo2["Context"],
				*szAppId     = tFileInfo2["AppID"];

	if (szSessionID == NULL || szAppId == NULL || szEufGuid == NULL) 
	{
		MSN_DebugLog("Ignoring invalid invitation: SessionID='%s', AppID=%s, Branch='%s',Context='%s'",
			szSessionID, szAppId, szEufGuid, szContext);
		return;
	}

	unsigned dwAppID = strtoul(szAppId, NULL, 10);
	unsigned dwSessionId = strtoul(szSessionID, NULL, 10);

	if (p2p_getSessionByID(dwSessionId))
		return;

	szContext = MSN_Base64Decode(szContext);

	filetransfer* ft = new filetransfer(this);
	ft->p2p_acksessid = MSN_GenRandom();
	ft->p2p_sessionid = dwSessionId;
	ft->p2p_appID = dwAppID == MSN_APPID_AVATAR ? MSN_APPID_AVATAR2 : dwAppID;
	ft->p2p_type = dwAppID;
	ft->p2p_ackID = dwAppID == MSN_APPID_FILE ? 2000 : 1000;
	replaceStr(ft->p2p_callID, szCallID);
	replaceStr(ft->p2p_branch, szBranch);
	ft->p2p_dest = mir_strdup(wlid);
	ft->p2p_isV2 = strchr(wlid, ';') != NULL;
 	ft->std.hContact = MSN_HContactFromEmail(wlid);

	p2p_registerSession(ft);

	switch (dwAppID)
	{
	case MSN_APPID_AVATAR:
	case MSN_APPID_AVATAR2:
		if (!_stricmp(szEufGuid, "{A4268EEC-FEC5-49E5-95C3-F126696BDBF6}")) {
			DBVARIANT dbv;
			bool pictmatch = !getString("PictObject", &dbv);
			if (pictmatch) 
			{
				UrlDecode(dbv.pszVal);

				ezxml_t xmlcon = ezxml_parse_str((char*)szContext, strlen(szContext));
				ezxml_t xmldb = ezxml_parse_str(dbv.pszVal, strlen(dbv.pszVal));

				const char *szCtBuf = ezxml_attr(xmlcon, "SHA1C");
				if (szCtBuf)
				{
					const char *szPtBuf = ezxml_attr(xmldb,  "SHA1C");
					pictmatch = szPtBuf && strcmp(szCtBuf, szPtBuf) == 0;
				}
				else
				{
					const char *szCtBuf = ezxml_attr(xmlcon, "SHA1D");
					const char *szPtBuf = ezxml_attr(xmldb,  "SHA1D");
					pictmatch = szCtBuf && szPtBuf && strcmp(szCtBuf, szPtBuf) == 0;
				}

				ezxml_free(xmlcon);
				ezxml_free(xmldb);
				MSN_FreeVariant(&dbv);
			}
			if (pictmatch) 
			{
				char szFileName[MAX_PATH];
				MSN_GetAvatarFileName(NULL, szFileName, SIZEOF(szFileName), NULL);
				ft->fileId = _open(szFileName, O_RDONLY | _O_BINARY, _S_IREAD);
				if (ft->fileId == -1) 
				{
					p2p_sendStatus(ft, 603);
					MSN_ShowError("Your avatar not set correctly. Avatar should be set in View/Change My Details | Avatar");
					MSN_DebugLog("Unable to open avatar file '%s', error %d", szFileName, errno);
					p2p_unregisterSession(ft);
				}
				else
				{
					mir_free(ft->std.tszCurrentFile);
					ft->std.tszCurrentFile = mir_a2t(szFileName);
//						MSN_DebugLog("My avatar file opened for %s as %08p::%d", szEmail, ft, ft->fileId);
					ft->std.totalBytes = ft->std.currentFileSize = _filelengthi64(ft->fileId);
					ft->std.flags |= PFTS_SENDING;

					//---- send 200 OK Message
					p2p_sendStatus(ft, 200);
					p2p_sendFeedStart(ft);

					if (ft->p2p_isV2)
					{
						p2p_sendAvatarInit(ft);
						MSN_StartP2PTransferByContact(ft->p2p_dest);
					}
				}
			}
			else
			{
				p2p_sendStatus(ft, 603);
				MSN_DebugLog("Requested avatar does not match current avatar");
				p2p_unregisterSession(ft);
			}
		}
		break;

	case MSN_APPID_FILE:
		if (!_stricmp(szEufGuid, "{5D3E02AB-6190-11D3-BBBB-00C04F795683}")) 
		{
			wchar_t* wszFileName = ((HFileContext*)szContext)->wszFileName;
			{	for (wchar_t* p = wszFileName; *p != 0; p++)
				{	
					switch(*p) 
					{
					case ':': case '?': case '/': case '\\': case '*':
						*p = '_';
					}	
				}	
			}

			mir_free(ft->std.tszCurrentFile);
			ft->std.tszCurrentFile = mir_u2t(wszFileName);

			ft->std.totalBytes = ft->std.currentFileSize = ((HFileContext*)szContext)->dwSize;
			ft->std.totalFiles = 1;

			TCHAR tComment[40];
			mir_sntprintf(tComment, SIZEOF(tComment), TranslateT("%I64u bytes"), ft->std.currentFileSize);

			PROTORECVFILET pre = {0};
			pre.flags = PREF_TCHAR;
			pre.fileCount = 1;
			pre.timestamp = time(NULL);
			pre.tszDescription = tComment;
			pre.ptszFiles = &ft->std.tszCurrentFile;
			pre.lParam = (LPARAM)ft;

			CCSDATA ccs;
			ccs.hContact = ft->std.hContact;
			ccs.szProtoService = PSR_FILE;
			ccs.wParam = 0;
			ccs.lParam = (LPARAM)&pre;
			MSN_CallService(MS_PROTO_CHAINRECV, 0, (LPARAM)&ccs);
		}
		break;

	case MSN_APPID_WEBCAM:
		if (!_stricmp(szEufGuid, "{4BD96FC0-AB17-4425-A14A-439185962DC8}")) {
			MSN_ShowPopup(ft->std.hContact,
				TranslateT("Contact tried to send its webcam data (currently not supported)"), 
				MSN_ALLOW_MSGBOX | MSN_SHOW_ERROR);
		}
		if (!_stricmp(szEufGuid, "{1C9AA97E-9C05-4583-A3BD-908A196F1E92}")) {
			MSN_ShowPopup(ft->std.hContact,
				TranslateT("Contact tried to view our webcam data (currently not supported)"), 
				MSN_ALLOW_MSGBOX | MSN_SHOW_ERROR);
		}
		p2p_sendStatus(ft, 603);
		p2p_unregisterSession(ft);
		break;

	case MSN_APPID_MEDIA_SHARING:
		MSN_ShowPopup(ft->std.hContact,
			TranslateT("Contact tried to share media with us (currently not supported)"), 
			MSN_ALLOW_MSGBOX | MSN_SHOW_ERROR);
		p2p_sendStatus(ft, 603);
		p2p_unregisterSession(ft);
		break;

	default:
		p2p_sendStatus(ft, 603);
		p2p_unregisterSession(ft);
		MSN_DebugLog("Invalid or unknown data transfer request (AppID/EUF-GUID: %ld/%s)", dwAppID, szEufGuid);
		break;
	}

	mir_free((void*)szContext);
}

void CMsnProto::p2p_InitDirectTransfer(MimeHeaders& tFileInfo, MimeHeaders& tFileInfo2, const char* wlid)
{
	const char	*szCallID = tFileInfo["Call-ID"],
				*szBranch = tFileInfo["Via"],
				*szConnType = tFileInfo2["Conn-Type"],
				*szUPnPNat = tFileInfo2["UPnPNat"],
				*szNetID = tFileInfo2["NetID"],
				*szICF = tFileInfo2["ICF"],
				*szHashedNonce = tFileInfo2["Hashed-Nonce"];

	if (szBranch != NULL) 
	{
		szBranch = strstr(szBranch, "branch=");
		if (szBranch != NULL)
			szBranch += 7;
	}
	if (szCallID == NULL || szBranch == NULL) 
	{
		MSN_DebugLog("Ignoring invalid invitation: CallID='%s', Branch='%s'", szCallID, szBranch);
		return;
	}

	if (szConnType == NULL || szUPnPNat == NULL || szICF == NULL || szNetID == NULL) 
	{
		MSN_DebugLog("Ignoring invalid invitation: ConnType='%s', UPnPNat='%s', ICF='%s', NetID='%s'",
			szConnType, szUPnPNat, szICF, szNetID);
		return;
	}

	filetransfer ftl(this), *ft = p2p_getSessionByCallID(szCallID, wlid);
	if (!ft || !ft->p2p_sessionid)
	{
		ft = &ftl;
		replaceStr(ft->p2p_dest, wlid);
		replaceStr(ft->p2p_callID, szCallID);
		replaceStr(ft->p2p_branch, szBranch);
		ft->p2p_isV2 = strchr(wlid, ';') != NULL;
		ft->std.hContact = MSN_HContactFromEmail(wlid);
	}
	else
	{
		replaceStr(ft->p2p_callID, szCallID);
		replaceStr(ft->p2p_branch, szBranch);
		ft->p2p_acksessid = MSN_GenRandom();
/*
		if (p2p_isAvatarOnly(ft->std.hContact)) 
		{
	//		p2p_sendStatus(ft, 1603);
	//		return;
		}
		else
			SendBroadcast(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_INITIALISING, ft, 0);
*/
	}

	directconnection *dc = p2p_getDCByCallID(szCallID, wlid);
	if (dc)
	{
		if (MSN_GetThreadByContact(wlid, SERVER_P2P_DIRECT))
		{
			p2p_sendStatus(ft, 1603);
			return;
		}
		p2p_unregisterDC(dc);
	}

	dc = new directconnection(szCallID, wlid);
	dc->useHashedNonce = szHashedNonce != NULL;
	if (dc->useHashedNonce)
		dc->xNonce = mir_strdup(szHashedNonce);
	p2p_registerDC(dc);

	MimeHeaders tResult(8);
	tResult.addString("CSeq", "1 ");
	tResult.addString("Call-ID", szCallID);
	tResult.addLong("Max-Forwards", 0);

	MyConnectionType conType = {0};

	conType.extIP = atol(szNetID);
	conType.SetUdpCon(szConnType);
	conType.upnpNAT = strcmp(szUPnPNat, "true") == 0;
	conType.icf = strcmp(szICF, "true") == 0;
	conType.CalculateWeight();

	MimeHeaders chdrs(12);
	bool listen = false;

	MSN_DebugLog("Connection weight, his: %d mine: %d", conType.weight, MyConnection.weight);
	if (conType.weight <= MyConnection.weight)
		listen = p2p_createListener(ft, dc, chdrs);

	if (!listen) 
	{
		chdrs.addString("Bridge", "TCPv1");
		chdrs.addBool("Listening", false);

		if (dc->useHashedNonce)
			chdrs.addString("Hashed-Nonce", dc->mNonceToHash(), 2);
		else
			chdrs.addString("Nonce", sttVoidUid);

		chdrs.addULong("SessionID", ft->p2p_sessionid);
		chdrs.addString("SChannelState", "0");
		chdrs.addString("Capabilities-Flags", "1");
	}

	tResult.addString("Content-Type", "application/x-msnmsgr-transrespbody");

	if (!ft->p2p_isV2) p2p_getMsgId(ft->p2p_dest, -1);
	p2p_sendSlp(200, ft, tResult, chdrs);
}


void CMsnProto::p2p_startConnect(const char* wlid, const char* szCallID, const char* addr, const char* port)
{
	if (port == NULL) return;

	while (addr != NULL) 
	{
		char* pSpace = (char*)strchr(addr, ' ');
		if (pSpace != NULL) *(pSpace++) = 0;

		ThreadData* newThread = new ThreadData;

		newThread->mType = SERVER_P2P_DIRECT;
		newThread->mInitialContactWLID = mir_strdup(wlid);
		mir_snprintf(newThread->mCookie, sizeof(newThread->mCookie), "%s", szCallID);
		mir_snprintf(newThread->mServer, sizeof(newThread->mServer), "%s:%s", addr, port);

		newThread->startThread(&CMsnProto::p2p_fileActiveThread, this);

		addr = pSpace;
	}
}

void CMsnProto::p2p_InitDirectTransfer2(MimeHeaders& tFileInfo, MimeHeaders& tFileInfo2, const char* wlid)
{
	const char  *szCallID = tFileInfo["Call-ID"],
				*szInternalAddress = tFileInfo2["IPv4Internal-Addrs"],
				*szInternalPort = tFileInfo2["IPv4Internal-Port"],
				*szExternalAddress = tFileInfo2["IPv4External-Addrs"],
				*szExternalPort = tFileInfo2["IPv4External-Port"],
				*szNonce = tFileInfo2["Nonce"],
				*szHashedNonce = tFileInfo2["Hashed-Nonce"],
				*szListening = tFileInfo2["Listening"];

	if ((szNonce == NULL && szHashedNonce == NULL) || szListening == NULL) 
	{
		MSN_DebugLog("Ignoring invalid invitation: Listening='%s', Nonce=%s", szListening, szNonce);
		return;
	}

	directconnection* dc = p2p_getDCByCallID(szCallID, wlid);
	if (dc == NULL) 
	{
		dc = new directconnection(szCallID, wlid);
		p2p_registerDC(dc);
	}

	dc->useHashedNonce = szHashedNonce != NULL;
	replaceStr(dc->xNonce, szHashedNonce ? szHashedNonce : szNonce);

	if (!strcmp(szListening, "true") && strcmp(dc->xNonce, sttVoidUid)) 
	{
		p2p_startConnect(wlid, szCallID, szInternalAddress, szInternalPort);
		p2p_startConnect(wlid, szCallID, szExternalAddress, szExternalPort);
	}
}

void CMsnProto::p2p_AcceptTransfer(MimeHeaders& tFileInfo, MimeHeaders& tFileInfo2, const char* wlid)
{
	const char *szCallID = tFileInfo["Call-ID"];
	const char* szOldContentType = tFileInfo["Content-Type"];
	const char *szBranch = tFileInfo["Via"];

	if (szBranch != NULL) {
		szBranch = strstr(szBranch, "branch=");
		if (szBranch != NULL)
			szBranch += 7;
	}

	filetransfer ftl(this), *ft = p2p_getSessionByCallID(szCallID, wlid);

	if (!ft || !ft->p2p_sessionid)
	{
		ft = &ftl;
		replaceStr(ft->p2p_branch, szBranch);
		replaceStr(ft->p2p_callID, szCallID);
		replaceStr(ft->p2p_dest, wlid);
		ft->p2p_isV2 = strchr(wlid, ';') != NULL;
		ft->std.hContact = MSN_HContactFromEmail(wlid);
	}
	else
	{
		if (!(ft->std.flags & PFTS_SENDING)) 
		{
			replaceStr(ft->p2p_branch, szBranch);
			replaceStr(ft->p2p_callID, szCallID);
		}
	}

	if (szCallID == NULL || szBranch == NULL || szOldContentType == NULL) 
	{
		MSN_DebugLog("Ignoring invalid invitation: CallID='%s', szBranch='%s'", szCallID, szBranch);
LBL_Close:
		p2p_sendStatus(ft, 500);
		return;
	}

	MimeHeaders tResult(8);
	tResult.addString("CSeq", "0 ");
	tResult.addString("Call-ID", ft->p2p_callID);
	tResult.addLong("Max-Forwards", 0);

	MimeHeaders chdrs(12);

	if (!strcmp(szOldContentType, "application/x-msnmsgr-sessionreqbody")) 
	{
		if (ft == &ftl)
		{
			p2p_sendCancel(ft);
			return;
		}

		if (!ft->bAccepted)
		{
			replaceStr(ft->p2p_dest, wlid);
			ft->bAccepted = true;
		}
		else
			return;

		if (ft->p2p_type != MSN_APPID_FILE)
		{
			if (ft->fileId == -1) ft->create(); 
			return;
		}

		p2p_sendFeedStart(ft);

		ThreadData* T = MSN_GetP2PThreadByContact(ft->p2p_dest);
		if (T != NULL && T->mType == SERVER_P2P_DIRECT)
		{
			MSN_StartP2PTransferByContact(ft->p2p_dest);
			return;
		}

		if (usingGateway)
			MSN_StartP2PTransferByContact(ft->p2p_dest);

		directconnection* dc = new directconnection(szCallID, wlid);
		p2p_registerDC(dc);

		tResult.addString("Content-Type", "application/x-msnmsgr-transreqbody");

		chdrs.addString("Bridges", "TCPv1");
		chdrs.addLong("NetID", MyConnection.extIP);
		chdrs.addString("Conn-Type", MyConnection.GetMyUdpConStr());
		chdrs.addBool("UPnPNat", MyConnection.upnpNAT);
		chdrs.addBool("ICF", MyConnection.icf);
		chdrs.addString("Hashed-Nonce", dc->mNonceToHash(), 2);
	}
	else if (!strcmp(szOldContentType, "application/x-msnmsgr-transrespbody")) 
	{
		const char	*szListening       = tFileInfo2["Listening"],
					*szNonce           = tFileInfo2["Nonce"],
					*szHashedNonce     = tFileInfo2["Hashed-Nonce"],
					*szExternalAddress = tFileInfo2["IPv4External-Addrs"],
					*szExternalPort    = tFileInfo2["IPv4External-Port" ],
					*szInternalAddress = tFileInfo2["IPv4Internal-Addrs"],
					*szInternalPort    = tFileInfo2["IPv4Internal-Port" ];
		if ((szNonce == NULL && szHashedNonce == NULL) || szListening == NULL) 
		{
			MSN_DebugLog("Invalid data packet, exiting...");
			goto LBL_Close;
		}

		directconnection* dc = p2p_getDCByCallID(szCallID, wlid);
		if (dc == NULL) return;

		if (!dc->bAccepted)
			dc->bAccepted = true;
		else
			return;

		dc->useHashedNonce = szHashedNonce != NULL;
		replaceStr(dc->xNonce, szHashedNonce ? szHashedNonce : szNonce);

		// another side reported that it will be a server.
		if (!strcmp(szListening, "true") && (szNonce == NULL || strcmp(szNonce, sttVoidUid))) 
		{
			p2p_startConnect(ft->p2p_dest, szCallID, szInternalAddress, szInternalPort);
			p2p_startConnect(ft->p2p_dest, szCallID, szExternalAddress, szExternalPort);
			return;
		}

		// no, send a file via server
		if (!p2p_createListener(ft, dc, chdrs)) 
		{
			p2p_unregisterDC(dc);
			if (ft != &ftl)
				MSN_StartP2PTransferByContact(ft->p2p_dest);
			else
				p2p_startSessions(ft->p2p_dest);
			return;
		}

		tResult.addString("Content-Type", "application/x-msnmsgr-transrespbody");
	}
	else if (!strcmp(szOldContentType, "application/x-msnmsgr-transreqbody")) 
	{
		const char *szHashedNonce = tFileInfo2["Hashed-Nonce"];
		const char *szNonce       = tFileInfo2["Nonce"];

		directconnection* dc = p2p_getDCByCallID(szCallID, wlid);
		if (dc == NULL) 
		{
			dc = new directconnection(szCallID, wlid);
			p2p_registerDC(dc);
		}

		dc->useHashedNonce = szHashedNonce != NULL;
		replaceStr(dc->xNonce, szHashedNonce ? szHashedNonce : szNonce);

		// no, send a file via server
		if (!p2p_createListener(ft, dc, chdrs)) 
		{
			p2p_unregisterDC(dc);
			MSN_StartP2PTransferByContact(ft->p2p_dest);
			return;
		}

		tResult.addString("Content-Type", "application/x-msnmsgr-transrespbody");
	}
	else 
		return;

	if (!ft->p2p_isV2) p2p_getMsgId(ft->p2p_dest, -1);
	p2p_sendSlp(-2, ft, tResult, chdrs);
}


/////////////////////////////////////////////////////////////////////////////////////////
// p2p_processSIP - processes all MSN SIP commands

void CMsnProto::p2p_processSIP(ThreadData* info, char* msgbody, P2PB_Header* hdrdata, const char* wlid)
{
	int iMsgType = 0;
	if (!memcmp(msgbody, "INVITE MSNMSGR:", 15))
		iMsgType = 1;
	else if (!memcmp(msgbody, "MSNSLP/1.0 200 ", 15))
		iMsgType = 2;
	else if (!memcmp(msgbody, "BYE MSNMSGR:", 12))
		iMsgType = 3;
	else if (!memcmp(msgbody, "MSNSLP/1.0 603 ", 15))
		iMsgType = 4;
	else if (!memcmp(msgbody, "MSNSLP/1.0 481 ", 15))
		iMsgType = 4;
	else if (!memcmp(msgbody, "MSNSLP/1.0 500 ", 15))
		iMsgType = 4;
	else if (!memcmp(msgbody, "ACK MSNMSGR:", 12))
		iMsgType = 5;

	char* peol = strstr(msgbody, "\r\n");
	if (peol != NULL)
		msgbody = peol+2;

	MimeHeaders tFileInfo, tFileInfo2;
	msgbody = tFileInfo.readFromBuffer(msgbody);
	msgbody = tFileInfo2.readFromBuffer(msgbody);

	const char* szContentType = tFileInfo["Content-Type"];
	if (szContentType == NULL) 
	{
		MSN_DebugLog("Invalid or missing Content-Type field, exiting");
		return;
	}

	if (hdrdata && !hdrdata->isV2Hdr())
	{
		if (iMsgType == 2 || (iMsgType == 1 && !strcmp(szContentType, "application/x-msnmsgr-transreqbody")))
			p2p_getMsgId(wlid, 1);
	}

	switch(iMsgType) 
	{
	case 1:
		if (!strcmp(szContentType, "application/x-msnmsgr-sessionreqbody"))
			p2p_InitFileTransfer(info, tFileInfo, tFileInfo2, wlid);
		else if (!strcmp(szContentType, "application/x-msnmsgr-transreqbody"))
			p2p_InitDirectTransfer(tFileInfo, tFileInfo2, wlid);
		else if (!strcmp(szContentType, "application/x-msnmsgr-transrespbody"))
			p2p_InitDirectTransfer2(tFileInfo, tFileInfo2, wlid);
		break;

	case 2:
		p2p_AcceptTransfer(tFileInfo, tFileInfo2, wlid);
		break;

	case 3:
		if (!strcmp(szContentType, "application/x-msnmsgr-sessionclosebody"))
		{
			filetransfer* ft = p2p_getSessionByCallID(tFileInfo["Call-ID"], wlid);
			if (ft != NULL)
			{
				if (ft->std.currentFileProgress < ft->std.currentFileSize)
				{
					ft->bCanceled = true;
					p2p_sendAbortSession(ft);
				}
				else
				{
					if (!(ft->std.flags & PFTS_SENDING)) 
						ft->bCompleted = true;
				}

				p2p_sessionComplete(ft);
			}
		}
		break;

	case 4:
		{
			const char* callID = tFileInfo["Call-ID"];

//			application/x-msnmsgr-session-failure-respbody
			
  			directconnection *dc = p2p_getDCByCallID(callID, wlid);
			if (dc != NULL)
			{
				p2p_unregisterDC(dc);
				break;
			}

			filetransfer* ft = p2p_getSessionByCallID(callID, wlid);
			if (ft == NULL)
				break;

			ft->close();
			if (!(ft->std.flags & PFTS_SENDING)) _tremove(ft->std.tszCurrentFile);

			p2p_unregisterSession(ft);
		}
		break;

	case 5:
		if (!strcmp(szContentType, "application/x-msnmsgr-turnsetup"))
		{
//			tFileInfo2["ServerAddress"];
//			tFileInfo2["SessionUsername"];
//			tFileInfo2["SessionPassword"];
		}
		else if (!strcmp(szContentType, "application/x-msnmsgr-transudpswitch"))
		{
//			tFileInfo2["IPv6AddrsAndPorts"];
//			tFileInfo2["IPv4ExternalAddrsAndPorts"];
//			tFileInfo2["IPv4InternalAddrsAndPorts"];
		}
		break;
	}
}


/////////////////////////////////////////////////////////////////////////////////////////
// p2p_processMsg - processes all MSN P2P incoming messages
void  CMsnProto::p2p_processMsgV2(ThreadData* info,  char* msgbody, const char* wlid)
{
	P2PV2_Header hdrdata;
	
	char *msg = hdrdata.parseMsg(msgbody);
	hdrdata.logHeader(this);

	if (hdrdata.mSessionID == 0)
	{
		if (hdrdata.mPacketLen == 0)
		{
			if (hdrdata.mOpCode & 0x02)
				p2p_sendAck(wlid, &hdrdata);
			return;
		}

		if (hdrdata.mRemSize || hdrdata.mTFCode == 0)
		{
			char msgid[128];
			mir_snprintf(msgid, sizeof(msgid), "%s_%08x", wlid, hdrdata.mPacketNum);

			int idx;
			if (hdrdata.mTFCode == 0x01)
			{
				const size_t portion = hdrdata.mPacketLen + (msg - msgbody);
				const size_t len = portion + hdrdata.mRemSize;
				idx = addCachedMsg(msgid, msgbody, 0, portion, len, false);
			}
			else
			{
				size_t len = hdrdata.mPacketLen + hdrdata.mRemSize;
				size_t offset = getCachedMsgSize(msgid); if (offset >= len) offset -= len;
				idx = addCachedMsg(msgid, msg, offset, hdrdata.mPacketLen, len, false);
			}

			if (hdrdata.mRemSize == 0)
			{
	  			size_t newsize;
				if (getCachedMsg(idx, msgbody, newsize))
				{
					unsigned id = hdrdata.mID;
					msg = hdrdata.parseMsg(msgbody);
					hdrdata.mID = id;

					if (hdrdata.mOpCode & 0x02)
						p2p_sendAck(wlid, &hdrdata);

					if (hdrdata.mTFCode)
						p2p_processSIP(info, msg, &hdrdata, wlid);
					mir_free(msgbody);
				}
				else
					clearCachedMsg(idx);
			}
		}
		else
		{
			if (hdrdata.mOpCode & 0x02)
				p2p_sendAck(wlid, &hdrdata);

			p2p_processSIP(info, msg, &hdrdata, wlid);
		}

		return;
	}

	if (hdrdata.mOpCode & 0x02)
		p2p_sendAck(wlid, &hdrdata);

	filetransfer* ft = p2p_getSessionByID(hdrdata.mSessionID);
	if (ft == NULL) return;

	ft->ts = time(NULL);

	if (hdrdata.mTFCode >= 4 && hdrdata.mTFCode <= 7) 
	{
		_write(ft->fileId, msg, hdrdata.mPacketLen);

		ft->std.totalProgress += hdrdata.mPacketLen;
		ft->std.currentFileProgress += hdrdata.mPacketLen;

		if (ft->p2p_appID == MSN_APPID_FILE && clock() >= ft->nNotify)
		{
			SendBroadcast(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, (LPARAM)&ft->std);
			ft->nNotify = clock() + 500;

			//---- send an ack: body was transferred correctly
			MSN_DebugLog("Transferred %I64u bytes remaining %I64u", ft->std.currentFileProgress, hdrdata.mRemSize);
		}

		if (hdrdata.mRemSize == 0) 
		{
			SendBroadcast(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, (LPARAM)&ft->std);
			if (ft->p2p_appID == MSN_APPID_FILE)
			{
				ft->complete();
			}
			else 
			{
				p2p_savePicture2disk(ft);
				if (!ft->p2p_isV2) p2p_sendBye(ft);
			}
		}	
	}
}

void  CMsnProto::p2p_processMsg(ThreadData* info,  char* msgbody, const char* wlid)
{
	P2P_Header hdrdata; 
	msgbody = hdrdata.parseMsg(msgbody);
	hdrdata.logHeader(this);

	//---- if we got a message
	if (LOWORD(hdrdata.mFlags) == 0 && hdrdata.mSessionID == 0)
	{
//		MsnContact *cont = Lists_Get(wlid);
//		if (cont && cont->places.getCount())
//			return;

		if (hdrdata.mPacketLen < hdrdata.mTotalSize)
		{
			char msgid[128];
			mir_snprintf(msgid, sizeof(msgid), "%s_%08x", wlid, hdrdata.mID);
			int idx = addCachedMsg(msgid, msgbody, (size_t)hdrdata.mOffset, hdrdata.mPacketLen, 
				(size_t)hdrdata.mTotalSize, false);

			char* newbody;
			size_t newsize;
			if (getCachedMsg(idx, newbody, newsize))
			{
				p2p_sendAck(wlid, &hdrdata);
				p2p_processSIP(info, newbody, &hdrdata, wlid);
				mir_free(newbody);
			}
			else
			{
				if (hdrdata.mOffset + hdrdata.mPacketLen >= hdrdata.mTotalSize)
					clearCachedMsg(idx);
			}
		}
		else
		{
			p2p_sendAck(wlid, &hdrdata);
			p2p_processSIP(info, msgbody, &hdrdata, wlid);
		}

		return;
	}

	filetransfer* ft = p2p_getSessionByID(hdrdata.mSessionID);
	if (ft == NULL)
		ft = p2p_getSessionByUniqueID(hdrdata.mAckUniqueID);

	if (ft == NULL) return;

	ft->ts = time(NULL);

	//---- receiving redirect -----------
	if (hdrdata.mFlags == 0x01) 
	{
		if (WaitForSingleObject(ft->hLockHandle, INFINITE) == WAIT_OBJECT_0) 
		{
			__int64 dp = (__int64)(ft->std.currentFileProgress - hdrdata.mAckDataSize);
			ft->std.totalProgress -= dp ;
			ft->std.currentFileProgress -= dp;
			_lseeki64(ft->fileId, ft->std.currentFileProgress, SEEK_SET);
			ft->tType = info->mType;
			ReleaseMutex(ft->hLockHandle);
		}	
	}

	//---- receiving ack -----------
	if (hdrdata.mFlags == 0x02) 
	{
		ft->p2p_waitack = false;

		if (hdrdata.mAckSessionID == ft->p2p_sendmsgid) 
		{
			if (ft->p2p_appID == MSN_APPID_FILE) 
			{
				ft->bCompleted = true;
				p2p_sendBye(ft);
			}
			return;
		}

		if (hdrdata.mAckSessionID == ft->p2p_byemsgid)
		{
			p2p_sessionComplete(ft);
			return;
		}

		switch(ft->p2p_ackID) 
		{
		case 1000:
			//---- send Data Preparation Message
			p2p_sendAvatarInit(ft);
			break;

		case 1001:
			//---- send Data Messages
			MSN_StartP2PTransferByContact(ft->p2p_dest);
			break;
		}

		ft->p2p_ackID++;
		return;
	}

	if (LOWORD(hdrdata.mFlags) == 0) 
	{
		//---- accept the data preparation message ------
//		const unsigned* pLongs = (unsigned*)msgbody;
		if (hdrdata.mPacketLen == 4 && hdrdata.mTotalSize == 4) 
		{
			p2p_sendAck(ft->p2p_dest, &hdrdata);
			return;
		}
		else
			hdrdata.mFlags = 0x20;
	}

	//---- receiving data -----------
	if (LOWORD(hdrdata.mFlags) == 0x20 || LOWORD(hdrdata.mFlags) == 0x30) 
	{
		if (hdrdata.mOffset + hdrdata.mPacketLen > hdrdata.mTotalSize)
			hdrdata.mPacketLen = DWORD(hdrdata.mTotalSize - hdrdata.mOffset);

		if (ft->tTypeReq == 0 || ft->tTypeReq == info->mType) 
		{
			ft->tType = info->mType;
			ft->p2p_sendmsgid = hdrdata.mID;
		}

		__int64 dsz = ft->std.currentFileSize - hdrdata.mOffset;
		if (dsz > hdrdata.mPacketLen) dsz = hdrdata.mPacketLen;

		if (ft->tType == info->mType) 
		{
			if (dsz > 0 && ft->fileId >= 0) 
			{
				if (ft->lstFilePtr != hdrdata.mOffset)
					_lseeki64(ft->fileId, hdrdata.mOffset, SEEK_SET);
				_write(ft->fileId, msgbody, (unsigned int)dsz);

				ft->lstFilePtr = hdrdata.mOffset + dsz;

				__int64 dp = ft->lstFilePtr - ft->std.currentFileProgress;
				if (dp > 0) 
				{
					ft->std.totalProgress += dp;
					ft->std.currentFileProgress += dp;

					if (ft->p2p_appID == MSN_APPID_FILE && clock() >= ft->nNotify)
					{
						SendBroadcast(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, (LPARAM)&ft->std);
						ft->nNotify = clock() + 500;
					}
				}

				//---- send an ack: body was transferred correctly
				MSN_DebugLog("Transferred %I64u bytes out of %I64u", ft->std.currentFileProgress, hdrdata.mTotalSize);
			}

			if (ft->std.currentFileProgress >= hdrdata.mTotalSize) 
			{
				SendBroadcast(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, (LPARAM)&ft->std);
				p2p_sendAck(ft->p2p_dest, &hdrdata);
				if (ft->p2p_appID == MSN_APPID_FILE)
				{
					ft->ts = time(NULL);
					ft->p2p_waitack = true;
					ft->complete();
				}
				else 
				{
					p2p_savePicture2disk(ft);
					p2p_sendBye(ft);
				}
			}	
		}	
	}

	if (hdrdata.mFlags == 0x40 || hdrdata.mFlags == 0x80) 
	{
		p2p_sendAbortSession(ft);
		p2p_unregisterSession(ft);
	}
}

/////////////////////////////////////////////////////////////////////////////////////////
// p2p_invite - invite another side to transfer an avatar

void  CMsnProto::p2p_invite(unsigned iAppID, filetransfer* ft, const char *wlid)
{
	const char* szAppID;
	switch(iAppID) 
	{
	case MSN_APPID_FILE:			        szAppID = "{5D3E02AB-6190-11D3-BBBB-00C04F795683}";	break;
	case MSN_APPID_AVATAR:			        szAppID = "{A4268EEC-FEC5-49E5-95C3-F126696BDBF6}";	break;
	case MSN_APPID_CUSTOMSMILEY:	        szAppID = "{A4268EEC-FEC5-49E5-95C3-F126696BDBF6}";	break;
	case MSN_APPID_CUSTOMANIMATEDSMILEY:	szAppID = "{A4268EEC-FEC5-49E5-95C3-F126696BDBF6}";	break;
	default: return;
	}

	ft->p2p_type = iAppID;
	ft->p2p_acksessid = MSN_GenRandom();
	mir_free(ft->p2p_callID);
	ft->p2p_callID = getNewUuid();

	MsnContact* cont = Lists_Get(ft->std.hContact);

	if (ft->p2p_dest == NULL)
	{
		ft->p2p_isV2 = (cont->cap2 & capex_SupportsPeerToPeerV2) != 0;
		ft->p2p_dest = mir_strdup(wlid ? wlid : cont->email);
	}

	char*  pContext = NULL;
	size_t cbContext = 0;

	switch (iAppID) 
	{
		case MSN_APPID_FILE:
			{
				cbContext = sizeof(HFileContext);
				pContext = (char*)malloc(cbContext);
				HFileContext* ctx = (HFileContext*)pContext;
				memset(pContext, 0, cbContext);
				if (ft->p2p_isV2)
				{
					cbContext -= 64;
					ctx->ver = 2; 
				}
				else
				{
					ctx->ver = 3; 
					ctx->id = 0xffffffff;
				}
				ctx->len = (unsigned)cbContext;
				ctx->type = MSN_TYPEID_FTNOPREVIEW;
				ctx->dwSize = ft->std.currentFileSize;

				TCHAR* pszFiles = _tcsrchr(ft->std.tszCurrentFile, '\\');
				if (pszFiles)
					pszFiles++;
				else
					pszFiles = ft->std.tszCurrentFile;

				wchar_t *fname = mir_t2u(pszFiles);
				wcsncpy(ctx->wszFileName, fname, MAX_PATH);
				mir_free(fname);

				ft->p2p_appID = MSN_APPID_FILE;
			}
			break;

		default:
			ft->p2p_appID = MSN_APPID_AVATAR2;

			if (ft->p2p_object == NULL)
			{
				delete ft;
				return;
			}

			ezxml_t xmlo = ezxml_parse_str(NEWSTR_ALLOCA(ft->p2p_object), strlen(ft->p2p_object));
			ezxml_t xmlr = ezxml_new("msnobj");
				
			const char* p;
			p = ezxml_attr(xmlo, "Creator");
			if (p != NULL)
				ezxml_set_attr(xmlr, "Creator", p);
			p = ezxml_attr(xmlo, "Size");
			if (p != NULL) {
				ezxml_set_attr(xmlr, "Size", p);
				ft->std.totalBytes = ft->std.currentFileSize = _atoi64(p);
			}
			p = ezxml_attr(xmlo, "Type");
			if (p != NULL)
				ezxml_set_attr(xmlr, "Type", p);
			p = ezxml_attr(xmlo, "Location");
			if (p != NULL)
				ezxml_set_attr(xmlr, "Location", p);
			p = ezxml_attr(xmlo, "Friendly");
			if (p != NULL)
				ezxml_set_attr(xmlr, "Friendly", p);
			p = ezxml_attr(xmlo, "SHA1D");
			if (p != NULL)
				ezxml_set_attr(xmlr, "SHA1D", p);
			p = ezxml_attr(xmlo, "SHA1C");
			if (p != NULL)
				ezxml_set_attr(xmlr, "SHA1C", p);

			pContext = ezxml_toxml(xmlr, false);
			cbContext = strlen(pContext)+1;

			ezxml_free(xmlr);
			ezxml_free(xmlo);

			break;
	}

	bool sessionExist = p2p_sessionRegistered(ft);
	if (!sessionExist) 
	{
		p2p_registerSession(ft);

		unsigned short status = getWord(ft->std.hContact, "Status", ID_STATUS_OFFLINE);
		if ((myFlags & 0x4000000) && cont->places.getCount() <= 1 && 
			status != ID_STATUS_OFFLINE && status != ID_STATUS_INVISIBLE && m_iStatus != ID_STATUS_INVISIBLE)
		{
			if (ft->p2p_isV2)
			{
				if (cont->places[0].cap1 & cap_SupportsP2PBootstrap)
				{
					char wlid[128];
					mir_snprintf(wlid, SIZEOF(wlid), 
						strcmp(cont->places[0].id, sttVoidUid) ? "%s;%s" : "%s", 
						cont->email, cont->places[0].id);

					if (!MSN_GetThreadByContact(wlid, SERVER_P2P_DIRECT))
						p2p_inviteDc(ft, wlid);
					else
						p2p_invite(ft->p2p_type, ft, wlid);

					free(pContext);
					return;
				}
			}
			else
			{
				const char *wlid = cont->email;
				if (cont->cap1 & cap_SupportsP2PBootstrap)
				{
					if (!MSN_GetThreadByContact(wlid, SERVER_P2P_DIRECT))
						p2p_inviteDc(ft, wlid);
					else
						p2p_invite(ft->p2p_type, ft, wlid);

					free(pContext);
					return;
				}
			}
		}
	}

	if (!ft->bAccepted)
		ft->p2p_sessionid = MSN_GenRandom();

	int cbContextEnc = Netlib_GetBase64EncodedBufferSize((int)cbContext);
	char* szContextEnc = (char*)alloca(cbContextEnc);
	NETLIBBASE64 nlb = { szContextEnc, cbContextEnc, (PBYTE)pContext, (int)cbContext };
	MSN_CallService(MS_NETLIB_BASE64ENCODE, 0, LPARAM(&nlb));

	MimeHeaders chdrs(10);
	chdrs.addString("EUF-GUID", szAppID);
	chdrs.addULong("SessionID", ft->p2p_sessionid);
	chdrs.addULong("AppID", ft->p2p_appID);
	chdrs.addString("Context", szContextEnc);

	MimeHeaders tResult(8);
	tResult.addString("CSeq", "0 ");
	tResult.addString("Call-ID", ft->p2p_callID);
	tResult.addLong("Max-Forwards", 0);
	tResult.addString("Content-Type", "application/x-msnmsgr-sessionreqbody");

	if (iAppID != MSN_APPID_FILE) 
		ft->p2p_waitack = true;

	if (ft->p2p_isV2 && ft->std.currentFileNumber == 0)
	{
		for (int i = 0; i < cont->places.getCount(); ++i)
		{
			char wlid[128];
			mir_snprintf(wlid, SIZEOF(wlid), 
				strcmp(cont->places[i].id, sttVoidUid) ? "%s;%s" : "%s", 
				cont->email, cont->places[i].id);

			p2p_sendSlp(-2, ft, tResult, chdrs, wlid);
		}
	}
	else
		p2p_sendSlp(-2, ft, tResult, chdrs, wlid);

	free(pContext);
}


void CMsnProto::p2p_inviteDc(filetransfer* ft, const char *wlid)
{
	directconnection* dc = new directconnection(szUbnCall, wlid);
	p2p_registerDC(dc);

	MimeHeaders tResult(8);
	tResult.addString("CSeq", "0 ");
	tResult.addString("Call-ID", dc->callId);
	tResult.addLong("Max-Forwards", 0);
	tResult.addString("Content-Type", "application/x-msnmsgr-transreqbody");

	MimeHeaders chdrs(12);

	chdrs.addString("Bridges", "TCPv1 SBBridge");
	chdrs.addLong("NetID", MyConnection.extIP);
	chdrs.addString("Conn-Type", MyConnection.GetMyUdpConStr());
	chdrs.addBool("UPnPNat", MyConnection.upnpNAT);
	chdrs.addBool("ICF", MyConnection.icf);
	chdrs.addString("Hashed-Nonce", dc->mNonceToHash(), 2);
	chdrs.addString("SessionID", "0");
	chdrs.addString("SChannelState", "0");
	chdrs.addString("Capabilities-Flags", "1");

	p2p_sendSlp(-2, ft, tResult, chdrs, wlid);
}
/*
void CMsnProto::p2p_sendSessionAck(filetransfer* ft)
{
	MimeHeaders tResult(8);
	tResult.addString("CSeq", "0 ");
	tResult.addString("Call-ID", sttVoidUid);
	tResult.addLong("Max-Forwards", 0);
	tResult.addString("Content-Type", "application/x-msnmsgr-transdestaddrupdate");

	MimeHeaders chdrs(8);

	chdrs.addString("IPv4ExternalAddrsAndPorts", mir_strdup(MyConnection.GetMyExtIPStr()), 6);
	chdrs.addString("IPv4InternalAddrsAndPorts", mir_strdup(MyConnection.GetMyExtIPStr()), 6);
	chdrs.addString("SessionID", "0");
	chdrs.addString("SChannelState", "0");
	chdrs.addString("Capabilities-Flags", "1");

	p2p_sendSlp(-3, ft, tResult, chdrs);
}
*/
void  CMsnProto::p2p_sessionComplete(filetransfer* ft)
{
	if (ft->std.flags & PFTS_SENDING) 
	{
		if (ft->openNext() == -1) 
		{
			bool success = ft->std.currentFileNumber >= ft->std.totalFiles && ft->bCompleted;
			SendBroadcast(ft->std.hContact, ACKTYPE_FILE, success ? ACKRESULT_SUCCESS : ACKRESULT_FAILED, ft, 0);
			p2p_unregisterSession(ft);
		}
		else 
		{
			SendBroadcast(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_NEXTFILE, ft, 0);
			p2p_invite(ft->p2p_appID, ft, NULL);
		}
	}
	else 
	{
		SendBroadcast(ft->std.hContact, ACKTYPE_FILE, ft->bCompleted ? ACKRESULT_SUCCESS : ACKRESULT_FAILED, ft, 0);
		p2p_unregisterSession(ft);
	}
}

char* P2PV2_Header::parseMsg(char *buf)
{
	unsigned char hdrLen1 = *(unsigned char*)buf;
	mOpCode = *(unsigned char*)(buf + 1);
	mPacketLen = _htons(*(unsigned short*)(buf + 2));
	mID = _htonl(*(unsigned*)(buf + 4));

	char* buf1 = buf + hdrLen1;

	for (char *tlvp = buf + 8; tlvp < buf1 && *tlvp; tlvp += 2 + tlvp[1])
	{
		switch (*tlvp)
		{
		case 1:
			mCap = tlvp;
			break;
		case 2:
			mAckUniqueID = _htonl(*(unsigned*)(tlvp + 4));
			break;
		case 3:
			break;
		}
	}

	if (mPacketLen == 0) return buf + hdrLen1;

	unsigned char hdrLen2 = *(unsigned char*)buf1;
	mTFCode = *(unsigned char*)(buf1 + 1);
	mPacketNum = _htons(*(unsigned short*)(buf1 + 2));
	mSessionID = _htonl(*(unsigned*)(buf1 + 4));

	char* buf2 = buf1 + hdrLen2;

	for (char *tlvp1 = buf1 + 8; tlvp1 < buf2 && *tlvp1; tlvp1 += 2 + tlvp1[1])
	{
		switch (*tlvp1)
		{
		case 1:
			mRemSize = _htonl64(*(unsigned __int64*)(tlvp1 + 2));
			break;
		}
	}

	mPacketLen -= hdrLen2;
	return buf1 + hdrLen2;
}

char* P2PV2_Header::createMsg(char *buf, const char* wlid, CMsnProto *ppro)
{
	unsigned char hdrLen1 = 8 + (mAckUniqueID ? 6 : 0) + (mCap ? 2 + mCap[1] : 0);
	unsigned char comp = hdrLen1 & 3;
	hdrLen1 += comp ? 4 - comp : 0; 

	unsigned char hdrLen2 = mPacketLen ? (8 + (mRemSize ? 10 : 0)) : 0;
	comp = hdrLen2 & 3;
	hdrLen2 += comp ? 4 - comp : 0;

	mID = ppro->p2p_getMsgId(wlid, mPacketLen + hdrLen2);

	memset(buf, 0, hdrLen1 + hdrLen2);

	*(unsigned char*)(buf + 0) = hdrLen1;
	*(unsigned char*)(buf + 1) = mOpCode;
	*(unsigned short*)(buf + 2) = _htons(mPacketLen + hdrLen2);
	*(unsigned*)(buf + 4) = _htonl(mID);

	char *buf1 = buf + 8;
	
	if (mAckUniqueID)
	{
		*(unsigned char*)buf1 = 2;
		*(unsigned char*)(buf1 + 1) = 4;
		*(unsigned*)(buf1 + 2) = _htonl(mAckUniqueID);
		buf1 += 6;
	}
	if (mCap)
	{
		unsigned len = 2 + mCap[1];
		memcpy(buf1, mCap,  len);
		buf1 += len;
	}

	buf1 = buf + hdrLen1;

	if (hdrLen2 == 0) return buf1;

	*(unsigned char*)(buf1 + 0) = hdrLen2;
	*(unsigned char*)(buf1 + 1) = mTFCode;
	*(unsigned short*)(buf1 + 2) = _htons(mPacketNum);
	*(unsigned*)(buf1 + 4) = _htonl(mSessionID);
	
	if (mRemSize)
	{
		*(unsigned char*)(buf1 + 8) = 1;
		*(unsigned char*)(buf1 + 9) = 8;
		*(unsigned __int64*)(buf1 + 10) = _htonl64(mRemSize);
	}

	return buf1 + hdrLen2;
}

char* P2P_Header::createMsg(char *buf, const char* wlid, CMsnProto *ppro)
{ 
	if (!mID) mID = ppro->p2p_getMsgId(wlid, 1); 
	memcpy(buf, &mSessionID, 48); 
	return buf + 48; 
}
