GTalkExt, ICQ, IRC, Jabber: folders restructurization

git-svn-id: http://svn.miranda-ng.org/main/trunk@1890 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

1 files changed, 551 insertions, 0 deletions

diff --git a/protocols/JabberG/src/jabber_ft.cpp b/protocols/JabberG/src/jabber_ft.cpp
new file mode 100644
index 0000000000..4ded28d84d
--- /dev/null
+++ b/protocols/JabberG/src/jabber_ft.cpp
@@ -0,0 +1,551 @@
+/*

+

+Jabber Protocol Plugin for Miranda IM

+Copyright ( C ) 2002-04  Santithorn Bunchua

+Copyright ( C ) 2005-12  George Hazan

+Copyright ( C ) 2007     Maxim Mluhov

+

+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 "jabber.h"

+#include <io.h>

+#include <fcntl.h>

+#include <sys/types.h>

+#include <sys/stat.h>

+#include "jabber_iq.h"

+#include "jabber_byte.h"

+#include "jabber_ibb.h"

+#include "jabber_caps.h"

+

+void CJabberProto::FtCancel( filetransfer* ft )

+{

+	JABBER_LIST_ITEM *item;

+	JABBER_BYTE_TRANSFER *jbt;

+	JABBER_IBB_TRANSFER *jibb;

+

+	Log( "Invoking JabberFtCancel()" );

+

+	// For file sending session that is still in si negotiation phase

+	if ( m_iqManager.ExpireByUserData( ft ))

+		return;

+	// For file receiving session that is still in si negotiation phase

+	LISTFOREACH(i, this, LIST_FTRECV)

+	{

+		item = ListGetItemPtrFromIndex( i );

+		if ( item->ft == ft ) {

+			Log( "Canceling file receiving session while in si negotiation" );

+			ListRemoveByIndex( i );

+			JSendBroadcast( ft->std.hContact, ACKTYPE_FILE, ACKRESULT_FAILED, ft, 0 );

+			delete ft;

+			return;

+		}

+	}

+	// For file transfer through bytestream

+	if (( jbt=ft->jbt ) != NULL ) {

+		Log( "Canceling bytestream session" );

+		jbt->state = JBT_ERROR;

+		if ( jbt->hConn ) {

+			Log( "Force closing bytestream session" );

+			Netlib_CloseHandle( jbt->hConn );

+			jbt->hConn = NULL;

+		}

+		if ( jbt->hSendEvent ) SetEvent( jbt->hSendEvent );

+		if ( jbt->hEvent ) SetEvent( jbt->hEvent );

+		if ( jbt->hProxyEvent ) SetEvent( jbt->hProxyEvent );

+	}

+	// For file transfer through IBB

+	if (( jibb=ft->jibb ) != NULL ) {

+		Log( "Canceling IBB session" );

+		jibb->state = JIBB_ERROR;

+		m_iqManager.ExpireByUserData( jibb );

+	}

+}

+

+///////////////// File sending using stream initiation /////////////////////////

+

+void CJabberProto::FtInitiate( TCHAR* jid, filetransfer* ft )

+{

+	TCHAR *rs;

+	TCHAR *filename, *p;

+	int i;

+	TCHAR sid[9];

+

+	if ( jid==NULL || ft==NULL || !m_bJabberOnline || ( rs=ListGetBestClientResourceNamePtr( jid ))==NULL ) {

+		if ( ft ) {

+			JSendBroadcast( ft->std.hContact, ACKTYPE_FILE, ACKRESULT_FAILED, ft, 0 );

+			delete ft;

+		}

+		return;

+	}

+	ft->type = FT_SI;

+	for ( i=0; i<8; i++ )

+		sid[i] = ( rand()%10 ) + '0';

+	sid[8] = '\0';

+	if ( ft->sid != NULL ) mir_free( ft->sid );

+	ft->sid = mir_tstrdup( sid );

+	filename = ft->std.ptszFiles[ ft->std.currentFileNumber ];

+	if (( p = _tcsrchr( filename, '\\' )) != NULL )

+		filename = p+1;

+

+	TCHAR tszJid[ 512 ];

+	mir_sntprintf( tszJid, SIZEOF(tszJid), _T("%s/%s"), jid, rs );

+

+	XmlNodeIq iq( m_iqManager.AddHandler( &CJabberProto::OnFtSiResult, JABBER_IQ_TYPE_SET, tszJid, JABBER_IQ_PARSE_FROM | JABBER_IQ_PARSE_TO, -1, ft ));

+	HXML si = iq << XCHILDNS( _T("si"), _T(JABBER_FEAT_SI)) << XATTR( _T("id"), sid ) 

+						<< XATTR( _T("mime-type"), _T("binary/octet-stream")) << XATTR( _T("profile"), _T(JABBER_FEAT_SI_FT));

+	si << XCHILDNS( _T("file"), _T(JABBER_FEAT_SI_FT)) << XATTR( _T("name"), filename) 

+		<< XATTRI64( _T("size"), ft->fileSize[ ft->std.currentFileNumber ] ) << XCHILD( _T("desc"), ft->szDescription);

+	

+	HXML field = si << XCHILDNS( _T("feature"), _T(JABBER_FEAT_FEATURE_NEG))

+							<< XCHILDNS( _T("x"), _T(JABBER_FEAT_DATA_FORMS)) << XATTR( _T("type"), _T("form"))

+							<< XCHILD( _T("field")) << XATTR( _T("var"), _T("stream-method")) << XATTR( _T("type"), _T("list-single"));

+

+	BOOL bDirect = m_options.BsDirect;

+	BOOL bProxy = m_options.BsProxyManual;

+	

+	// bytestreams support?

+	if ( bDirect || bProxy )

+		field << XCHILD( _T("option")) << XCHILD( _T("value"), _T(JABBER_FEAT_BYTESTREAMS));

+

+	field << XCHILD( _T("option")) << XCHILD( _T("value"), _T(JABBER_FEAT_IBB));

+	m_ThreadInfo->send( iq );

+}

+

+void CJabberProto::OnFtSiResult( HXML iqNode, CJabberIqInfo* pInfo )

+{

+	HXML siNode, featureNode, xNode, fieldNode, valueNode;

+	filetransfer *ft = (filetransfer *)pInfo->GetUserData();

+	if ( !ft ) return;

+

+	if (( pInfo->GetIqType() == JABBER_IQ_TYPE_RESULT ) && pInfo->m_szFrom && pInfo->m_szTo ) {

+		if (( siNode = xmlGetChild( iqNode , "si" )) != NULL ) {

+

+			// fix for very smart clients, like gajim

+			BOOL bDirect = m_options.BsDirect;

+			BOOL bProxy = m_options.BsProxyManual;

+

+			if (( featureNode = xmlGetChild( siNode , "feature" )) != NULL ) {

+				if (( xNode = xmlGetChildByTag( featureNode, "x", "xmlns", _T(JABBER_FEAT_DATA_FORMS))) != NULL ) {

+					if (( fieldNode = xmlGetChildByTag( xNode, "field", "var", _T("stream-method"))) != NULL ) {

+						if (( valueNode = xmlGetChild( fieldNode , "value" ))!=NULL && xmlGetText( valueNode )!=NULL ) {

+							if (( bDirect || bProxy ) && !_tcscmp( xmlGetText( valueNode ), _T(JABBER_FEAT_BYTESTREAMS))) {

+								// Start Bytestream session

+								JABBER_BYTE_TRANSFER *jbt = new JABBER_BYTE_TRANSFER;

+								ZeroMemory( jbt, sizeof( JABBER_BYTE_TRANSFER ));

+								jbt->srcJID = mir_tstrdup( pInfo->m_szTo );

+								jbt->dstJID = mir_tstrdup( pInfo->m_szFrom );

+								jbt->sid = mir_tstrdup( ft->sid );

+								jbt->pfnSend = &CJabberProto::FtSend;

+								jbt->pfnFinal = &CJabberProto::FtSendFinal;

+								jbt->ft = ft;

+								ft->type = FT_BYTESTREAM;

+								ft->jbt = jbt;

+								JForkThread(( JThreadFunc )&CJabberProto::ByteSendThread, jbt );

+							} else if ( !_tcscmp( xmlGetText( valueNode ), _T(JABBER_FEAT_IBB))) {

+								JABBER_IBB_TRANSFER *jibb = (JABBER_IBB_TRANSFER *) mir_alloc( sizeof ( JABBER_IBB_TRANSFER ));

+								ZeroMemory( jibb, sizeof( JABBER_IBB_TRANSFER ));

+								jibb->srcJID = mir_tstrdup( pInfo->m_szTo );

+								jibb->dstJID = mir_tstrdup( pInfo->m_szFrom );

+								jibb->sid = mir_tstrdup( ft->sid );

+								jibb->pfnSend = &CJabberProto::FtIbbSend;

+								jibb->pfnFinal = &CJabberProto::FtSendFinal;

+								jibb->ft = ft;

+								ft->type = FT_IBB;

+								ft->jibb = jibb;

+								JForkThread(( JThreadFunc )&CJabberProto::IbbSendThread, jibb );

+	}	}	}	}	}	}	}

+	else {

+		Log( "File transfer stream initiation request denied or failed" );

+		JSendBroadcast( ft->std.hContact, ACKTYPE_FILE, pInfo->GetIqType() == JABBER_IQ_TYPE_ERROR ? ACKRESULT_DENIED : ACKRESULT_FAILED, ft, 0 );

+		delete ft;

+	}

+}

+

+BOOL CJabberProto::FtSend( HANDLE hConn, filetransfer* ft )

+{

+	struct _stati64 statbuf;

+	int fd;

+	char* buffer;

+	int numRead;

+

+	Log( "Sending [%s]", ft->std.ptszFiles[ ft->std.currentFileNumber ] );

+	_tstati64( ft->std.ptszFiles[ ft->std.currentFileNumber ], &statbuf );	// file size in statbuf.st_size

+	if (( fd = _topen( ft->std.ptszFiles[ ft->std.currentFileNumber ], _O_BINARY|_O_RDONLY )) < 0 ) {

+		Log( "File cannot be opened" );

+		return FALSE;

+	}

+

+	ft->std.flags |= PFTS_SENDING;

+	ft->std.currentFileSize = statbuf.st_size;

+	ft->std.currentFileProgress = 0;

+

+	if (( buffer=( char* )mir_alloc( 2048 )) != NULL ) {

+		while (( numRead=_read( fd, buffer, 2048 )) > 0 ) {

+			if ( Netlib_Send( hConn, buffer, numRead, 0 ) != numRead ) {

+				mir_free( buffer );

+				_close( fd );

+				return FALSE;

+			}

+			ft->std.currentFileProgress += numRead;

+			ft->std.totalProgress += numRead;

+			JSendBroadcast( ft->std.hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, ( LPARAM )&ft->std );

+		}

+		mir_free( buffer );

+	}

+	_close( fd );

+	return TRUE;

+}

+

+BOOL CJabberProto::FtIbbSend( int blocksize, filetransfer* ft )

+{

+	struct _stati64 statbuf;

+	int fd;

+	char* buffer;

+	int numRead;

+

+	Log( "Sending [%s]", ft->std.ptszFiles[ ft->std.currentFileNumber ] );

+	_tstati64( ft->std.ptszFiles[ ft->std.currentFileNumber ], &statbuf );	// file size in statbuf.st_size

+	if (( fd = _topen( ft->std.ptszFiles[ ft->std.currentFileNumber ], _O_BINARY|_O_RDONLY )) < 0 ) {

+		Log( "File cannot be opened" );

+		return FALSE;

+	}

+

+	ft->std.flags |= PFTS_SENDING;

+	ft->std.currentFileSize = statbuf.st_size;

+	ft->std.currentFileProgress = 0;

+

+	if (( buffer=( char* )mir_alloc( blocksize )) != NULL ) {

+		while (( numRead=_read( fd, buffer, blocksize )) > 0 ) {

+			int iqId = SerialNext();

+			XmlNode msg( _T("message"));

+			xmlAddAttr( msg, _T("to"), ft->jibb->dstJID );

+			msg << XATTRID( iqId );

+

+			// let others send data too

+			Sleep(2);

+

+			char *encoded = JabberBase64Encode(buffer, numRead);

+

+			msg << XCHILD( _T("data"), _A2T(encoded)) << XATTR( _T("xmlns"), _T(JABBER_FEAT_IBB))

+				<< XATTR( _T("sid"), ft->jibb->sid ) << XATTRI( _T("seq"), ft->jibb->wPacketId );

+

+			HXML ampNode = msg << XCHILDNS( _T("amp"), _T(JABBER_FEAT_AMP));

+			ampNode << XCHILD( _T("rule")) << XATTR( _T("condition"), _T("deliver-at"))

+				<< XATTR( _T("value"), _T("stored")) << XATTR( _T("action"), _T("error"));

+			ampNode << XCHILD( _T("rule")) << XATTR( _T("condition"), _T("match-resource"))

+				<< XATTR( _T("value"), _T("exact")) << XATTR( _T("action"), _T("error"));

+			ft->jibb->wPacketId++;

+

+			mir_free( encoded );

+

+			if ( ft->jibb->state == JIBB_ERROR || ft->jibb->bStreamClosed || m_ThreadInfo->send( msg ) == SOCKET_ERROR ) {

+				Log( "JabberFtIbbSend unsuccessful exit" );

+				mir_free( buffer );

+				_close( fd );

+				return FALSE;

+			}

+

+			ft->jibb->dwTransferredSize += (DWORD)numRead;

+

+			ft->std.currentFileProgress += numRead;

+			ft->std.totalProgress += numRead;

+			JSendBroadcast( ft->std.hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, ( LPARAM )&ft->std );

+		}

+		mir_free( buffer );

+	}

+	_close( fd );

+	return TRUE;

+}

+

+void CJabberProto::FtSendFinal( BOOL success, filetransfer* ft )

+{

+	if ( !success ) {

+		Log( "File transfer complete with error" );

+		JSendBroadcast( ft->std.hContact, ACKTYPE_FILE, ft->state == FT_DENIED ? ACKRESULT_DENIED : ACKRESULT_FAILED, ft, 0 );

+	}

+	else {

+		if ( ft->std.currentFileNumber < ft->std.totalFiles-1 ) {

+			ft->std.currentFileNumber++;

+			replaceStrT( ft->std.tszCurrentFile, ft->std.ptszFiles[ ft->std.currentFileNumber ] );

+			JSendBroadcast( ft->std.hContact, ACKTYPE_FILE, ACKRESULT_NEXTFILE, ft, 0 );

+			FtInitiate( ft->jid, ft );

+			return;

+		}

+

+		JSendBroadcast( ft->std.hContact, ACKTYPE_FILE, ACKRESULT_SUCCESS, ft, 0 );

+	}

+

+	delete ft;

+}

+

+///////////////// File receiving through stream initiation /////////////////////////

+

+void CJabberProto::FtHandleSiRequest( HXML iqNode )

+{

+	const TCHAR* from, *sid, *str, *szId, *filename;

+	HXML siNode, fileNode, featureNode, xNode, fieldNode, n;

+	int i;

+    unsigned __int64 filesize;

+

+	if ( !iqNode ||

+		  ( from = xmlGetAttrValue( iqNode, _T("from"))) == NULL ||

+		  ( str = xmlGetAttrValue( iqNode,  _T("type"))) == NULL || _tcscmp( str, _T("set")) ||

+		  ( siNode = xmlGetChildByTag( iqNode, "si", "xmlns", _T(JABBER_FEAT_SI))) == NULL )

+		return;

+

+	szId = xmlGetAttrValue( iqNode,  _T("id"));

+	if (( sid = xmlGetAttrValue( siNode,  _T("id"))) != NULL &&

+		( fileNode = xmlGetChildByTag( siNode, "file", "xmlns", _T(JABBER_FEAT_SI_FT))) != NULL &&

+		( filename = xmlGetAttrValue( fileNode,  _T("name"))) != NULL &&

+		( str = xmlGetAttrValue( fileNode,  _T("size"))) != NULL ) {

+

+		filesize = _ttoi64( str );

+		if (( featureNode = xmlGetChildByTag( siNode, "feature", "xmlns", _T(JABBER_FEAT_FEATURE_NEG))) != NULL &&

+			( xNode = xmlGetChildByTag( featureNode, "x", "xmlns", _T(JABBER_FEAT_DATA_FORMS)))!=NULL &&

+			( fieldNode = xmlGetChildByTag( xNode, "field", "var", _T("stream-method")))!=NULL ) {

+

+			BOOL bIbbOnly = m_options.BsOnlyIBB;

+			HXML optionNode = NULL;

+			JABBER_FT_TYPE ftType = FT_OOB;

+

+			if ( !bIbbOnly ) {

+				for ( i=0; ; i++ ) {

+					optionNode = xmlGetChild( fieldNode ,i);

+					if ( !optionNode )

+						break;

+	

+					if ( !lstrcmp( xmlGetName( optionNode ), _T("option"))) {

+						if (( n = xmlGetChild( optionNode , "value" )) != NULL && xmlGetText( n )) {

+							if ( !_tcscmp( xmlGetText( n ), _T(JABBER_FEAT_BYTESTREAMS))) {

+								ftType = FT_BYTESTREAM;

+								break;

+			}	}	}	}	}

+

+			// try IBB only if bytestreams support not found or BsOnlyIBB flag exists

+			if ( bIbbOnly || !optionNode ) {

+				for ( i=0; ; i++ ) {

+					optionNode = xmlGetChild( fieldNode ,i);

+					if ( !optionNode )

+						break;

+

+					if ( !lstrcmp( xmlGetName( optionNode ), _T("option"))) {

+						if (( n = xmlGetChild( optionNode , "value" )) != NULL && xmlGetText( n )) {

+							if ( !_tcscmp( xmlGetText( n ), _T(JABBER_FEAT_IBB))) {

+								ftType = FT_IBB;

+								break;

+			}	}	}	}	}

+

+			if ( optionNode != NULL ) {

+				// Found known stream mechanism

+				filetransfer* ft = new filetransfer( this );

+				ft->dwExpectedRecvFileSize = filesize;

+				ft->jid = mir_tstrdup( from );

+				ft->std.hContact = HContactFromJID( from );

+				ft->sid = mir_tstrdup( sid );

+				ft->iqId = mir_tstrdup( szId );

+				ft->type = ftType;

+				ft->std.totalFiles = 1;

+				ft->std.tszCurrentFile = mir_tstrdup( filename );

+				ft->std.totalBytes = ft->std.currentFileSize = filesize;

+

+				PROTORECVFILET pre = { 0 };

+				pre.flags = PREF_TCHAR;

+				pre.fileCount = 1;

+				pre.timestamp = time( NULL );

+				pre.ptszFiles = ( TCHAR** )&filename;

+				pre.lParam = ( LPARAM )ft;

+				if (( n = xmlGetChild( fileNode , "desc" )) != NULL )

+					pre.tszDescription = ( TCHAR* )xmlGetText( n );

+

+				CCSDATA ccs = { ft->std.hContact, PSR_FILE, 0, ( LPARAM )&pre };

+				CallService( MS_PROTO_CHAINRECV, 0, ( LPARAM )&ccs );

+				return;

+			}

+			else {

+				// Unknown stream mechanism

+				XmlNodeIq iq( _T("error"), szId, from );

+				HXML e = iq << XCHILD( _T("error")) << XATTRI( _T("code"), 400 ) << XATTR( _T("type"), _T("cancel"));

+				e << XCHILDNS( _T("bad-request"), _T("urn:ietf:params:xml:ns:xmpp-stanzas"));

+				e << XCHILDNS( _T("no-valid-streams"), _T(JABBER_FEAT_SI));

+				m_ThreadInfo->send( iq );

+				return;

+	}	}	}

+

+	// Bad stream initiation, reply with bad-profile

+	XmlNodeIq iq( _T("error"), szId, from );

+	HXML e = iq << XCHILD( _T("error")) << XATTRI( _T("code"), 400 ) << XATTR( _T("type"), _T("cancel"));

+	e << XCHILDNS( _T("bad-request"), _T("urn:ietf:params:xml:ns:xmpp-stanzas"));

+	e << XCHILDNS( _T("bad-profile"), _T(JABBER_FEAT_SI));

+	m_ThreadInfo->send( iq );

+}

+

+void CJabberProto::FtAcceptSiRequest( filetransfer* ft )

+{

+	if ( !m_bJabberOnline || ft==NULL || ft->jid==NULL || ft->sid==NULL ) return;

+

+	JABBER_LIST_ITEM *item;

+	if (( item=ListAdd( LIST_FTRECV, ft->sid )) != NULL ) {

+		item->ft = ft;

+

+		m_ThreadInfo->send(

+			XmlNodeIq( _T("result"), ft->iqId, ft->jid )

+				<< XCHILDNS( _T("si"), _T(JABBER_FEAT_SI))

+				<< XCHILDNS( _T("feature"), _T(JABBER_FEAT_FEATURE_NEG))

+				<< XCHILDNS( _T("x"), _T(JABBER_FEAT_DATA_FORMS)) << XATTR( _T("type"), _T("submit"))

+				<< XCHILD( _T("field")) << XATTR( _T("var"), _T("stream-method"))

+				<< XCHILD( _T("value"), _T(JABBER_FEAT_BYTESTREAMS)));

+}	}

+

+void CJabberProto::FtAcceptIbbRequest( filetransfer* ft )

+{

+	if ( !m_bJabberOnline || ft==NULL || ft->jid==NULL || ft->sid==NULL ) return;

+

+	JABBER_LIST_ITEM *item;

+	if (( item=ListAdd( LIST_FTRECV, ft->sid )) != NULL ) {

+		item->ft = ft;

+

+		m_ThreadInfo->send(

+			XmlNodeIq( _T("result"), ft->iqId, ft->jid )

+				<< XCHILDNS( _T("si"), _T(JABBER_FEAT_SI))

+				<< XCHILDNS( _T("feature"), _T(JABBER_FEAT_FEATURE_NEG))

+				<< XCHILDNS( _T("x"), _T(JABBER_FEAT_DATA_FORMS)) << XATTR( _T("type"), _T("submit"))

+				<< XCHILD( _T("field")) << XATTR( _T("var"), _T("stream-method"))

+				<< XCHILD( _T("value"), _T(JABBER_FEAT_IBB)));

+}	}

+

+BOOL CJabberProto::FtHandleBytestreamRequest( HXML iqNode, CJabberIqInfo* pInfo )

+{

+	HXML queryNode = pInfo->GetChildNode();

+

+	const TCHAR* sid;

+	JABBER_LIST_ITEM *item;

+

+	if (( sid = xmlGetAttrValue( queryNode, _T("sid"))) != NULL && ( item = ListGetItemPtr( LIST_FTRECV, sid )) != NULL ) {

+		// Start Bytestream session

+		JABBER_BYTE_TRANSFER *jbt = new JABBER_BYTE_TRANSFER;

+		ZeroMemory( jbt, sizeof( JABBER_BYTE_TRANSFER ));

+		jbt->iqNode = xi.copyNode( iqNode );

+		jbt->pfnRecv = &CJabberProto::FtReceive;

+		jbt->pfnFinal = &CJabberProto::FtReceiveFinal;

+		jbt->ft = item->ft;

+		item->ft->jbt = jbt;

+		JForkThread(( JThreadFunc )&CJabberProto::ByteReceiveThread, jbt );

+		ListRemove( LIST_FTRECV, sid );

+		return TRUE;

+	}

+

+	Log( "File transfer invalid bytestream initiation request received" );

+	return TRUE;

+}

+

+BOOL CJabberProto::FtHandleIbbRequest( HXML iqNode, BOOL bOpen )

+{

+	if ( !iqNode ) return FALSE;

+

+	const TCHAR *id = xmlGetAttrValue( iqNode, _T("id"));

+	const TCHAR *from = xmlGetAttrValue( iqNode, _T("from"));

+	const TCHAR *to = xmlGetAttrValue( iqNode, _T("to"));

+	if ( !id || !from || !to ) return FALSE;

+

+	HXML ibbNode = xmlGetChildByTag( iqNode, bOpen ? "open" : "close", "xmlns", _T(JABBER_FEAT_IBB));

+	if ( !ibbNode ) return FALSE;

+

+	const TCHAR *sid = xmlGetAttrValue( ibbNode, _T("sid"));

+	if ( !sid ) return FALSE;

+

+	// already closed?

+	JABBER_LIST_ITEM *item = ListGetItemPtr( LIST_FTRECV, sid );

+	if ( !item ) {

+		m_ThreadInfo->send(

+			XmlNodeIq( _T("error"), id, from )

+				<< XCHILD( _T("error")) << XATTRI( _T("code"), 404 ) << XATTR( _T("type"), _T("cancel"))

+					<< XCHILDNS( _T("item-not-found"), _T("urn:ietf:params:xml:ns:xmpp-stanzas")));

+		return FALSE;

+	}

+

+	// open event

+	if ( bOpen ) {

+		if ( !item->jibb ) {

+			JABBER_IBB_TRANSFER *jibb = ( JABBER_IBB_TRANSFER * ) mir_alloc( sizeof( JABBER_IBB_TRANSFER ));

+			ZeroMemory( jibb, sizeof( JABBER_IBB_TRANSFER ));

+			jibb->srcJID = mir_tstrdup( from );

+			jibb->dstJID = mir_tstrdup( to );

+			jibb->sid = mir_tstrdup( sid );

+			jibb->pfnRecv = &CJabberProto::FtReceive;

+			jibb->pfnFinal = &CJabberProto::FtReceiveFinal;

+			jibb->ft = item->ft;

+			item->ft->jibb = jibb;

+			item->jibb = jibb;

+			JForkThread(( JThreadFunc )&CJabberProto::IbbReceiveThread, jibb );

+

+			m_ThreadInfo->send( XmlNodeIq( _T("result"), id, from ));

+			return TRUE;

+		}

+		// stream already open

+		m_ThreadInfo->send(

+			XmlNodeIq( _T("error"), id, from )

+				<< XCHILD( _T("error")) << XATTRI( _T("code"), 404 ) << XATTR( _T("type"), _T("cancel"))

+					<< XCHILDNS( _T("item-not-found"), _T("urn:ietf:params:xml:ns:xmpp-stanzas")));

+		return FALSE;

+	}

+	

+	// close event && stream already open

+	if ( item->jibb && item->jibb->hEvent ) {

+		item->jibb->bStreamClosed = TRUE;

+		SetEvent( item->jibb->hEvent );

+

+		m_ThreadInfo->send( XmlNodeIq( _T("result"), id, from ));

+		return TRUE;

+	}

+

+	ListRemove( LIST_FTRECV, sid );

+

+	return FALSE;

+}

+

+int CJabberProto::FtReceive( HANDLE, filetransfer* ft, char* buffer, int datalen )

+{

+	if ( ft->create() == -1 )

+		return -1;

+

+	__int64 remainingBytes = ft->std.currentFileSize - ft->std.currentFileProgress;

+	if ( remainingBytes > 0 ) {

+		int writeSize = ( remainingBytes<datalen ) ? remainingBytes : datalen;

+		if ( _write( ft->fileId, buffer, writeSize ) != writeSize ) {

+			Log( "_write() error" );

+			return -1;

+		}

+

+		ft->std.currentFileProgress += writeSize;

+		ft->std.totalProgress += writeSize;

+		JSendBroadcast( ft->std.hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, ( LPARAM )&ft->std );

+		return ( ft->std.currentFileSize == ft->std.currentFileProgress ) ? 0 : writeSize;

+	}

+

+	return 0;

+}

+

+void CJabberProto::FtReceiveFinal( BOOL success, filetransfer* ft )

+{

+	if ( success ) {

+		Log( "File transfer complete successfully" );

+		ft->complete();

+	}

+	else Log( "File transfer complete with error" );

+

+	delete ft;

+}