Context Navigation

source: protocols/jabber/si.c @ 0fbd3a6d

Last change on this file since 0fbd3a6d was dc0ba9c, checked in by kenobi <kenobi@…>, at 2007-12-18T02:07:59Z
sending via proxy
Property mode set to `100644`
File size: 14.2 KB

Rev	Line
[2c2df7d]	1	/***************************************************************************\
	2	* *
	3	* BitlBee - An IRC to IM gateway *
	4	* Jabber module - SI packets *
	5	* *
	6	* Copyright 2007 Uli Meis <a.sporto+bee@gmail.com> *
	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 along *
	19	* with this program; if not, write to the Free Software Foundation, Inc., *
	20	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
	21	* *
	22	\***************************************************************************/
	23
	24	#include "jabber.h"
	25	#include "sha1.h"
	26
	27	void jabber_si_answer_request( file_transfer_t *ft );
[2ff2076]	28	int jabber_si_send_request(struct im_connection ic, char who, struct jabber_transfer *tf );
[2c2df7d]	29
[2ff2076]	30	/* file_transfer free() callback */
[2c2df7d]	31	void jabber_si_free_transfer( file_transfer_t *ft)
	32	{
	33	struct jabber_transfer *tf = ft->data;
	34	struct jabber_data *jd = tf->ic->proto_data;
	35
	36	if ( tf->watch_in )
	37	b_event_remove( tf->watch_in );
	38
	39	jd->filetransfers = g_slist_remove( jd->filetransfers, tf );
	40
	41	if( tf->fd )
	42	{
	43	close( tf->fd );
	44	tf->fd = 0;
	45	}
	46
	47	g_free( tf->ini_jid );
	48	g_free( tf->tgt_jid );
	49	g_free( tf->iq_id );
	50	g_free( tf->sid );
	51	}
	52
[2ff2076]	53	/* file_transfer finished() callback */
[2c2df7d]	54	void jabber_si_finished( file_transfer_t *ft )
	55	{
	56	struct jabber_transfer *tf = ft->data;
	57
	58	imcb_log( tf->ic, "File %s transferred successfully!" , ft->file_name );
	59	}
	60
[2ff2076]	61	/* file_transfer canceled() callback */
[2c2df7d]	62	void jabber_si_canceled( file_transfer_t ft, char reason )
	63	{
	64	struct jabber_transfer *tf = ft->data;
	65	struct xt_node reply, iqnode;
	66
	67	if( tf->accepted )
	68	return;
	69
	70	iqnode = jabber_make_packet( "iq", "error", tf->ini_jid, NULL );
	71	xt_add_attr( iqnode, "id", tf->iq_id );
	72	reply = jabber_make_error_packet( iqnode, "forbidden", "cancel", "403" );
	73	xt_free_node( iqnode );
	74
	75	if( !jabber_write_packet( tf->ic, reply ) )
	76	imcb_log( tf->ic, "WARNING: Error generating reply to file transfer request" );
	77	xt_free_node( reply );
	78
	79	}
	80
[2ff2076]	81	void jabber_si_transfer_request( struct im_connection ic, file_transfer_t ft, char *who )
	82	{
	83	struct jabber_transfer *tf;
	84	struct jabber_data *jd = ic->proto_data;
[dc0ba9c]	85	char *server = jd->server;
[2ff2076]	86
[dce3903]	87	imcb_log( ic, "Trying to send %s(%zd bytes) to %s", ft->file_name, ft->file_size, who );
[2ff2076]	88
	89	tf = g_new0( struct jabber_transfer, 1 );
	90
	91	tf->ic = ic;
	92	tf->ft = ft;
	93	tf->ft->data = tf;
	94	tf->ft->free = jabber_si_free_transfer;
	95	tf->ft->finished = jabber_si_finished;
	96	ft->write = jabber_bs_send_write;
	97
	98	jd->filetransfers = g_slist_prepend( jd->filetransfers, tf );
	99
[dc0ba9c]	100	/* query the buddy's features */
	101	jabber_iq_query_features( ic, who );
	102
	103	/* query proxies from the server */
	104	if( !jd->have_streamhosts )
	105	jabber_iq_query_server( ic, server, XMLNS_DISCO_ITEMS );
	106
	107	/* send the request to our buddy */
[2ff2076]	108	jabber_si_send_request( ic, who, tf );
	109
[dc0ba9c]	110	/* and start the receive logic */
[2ff2076]	111	imcb_file_recv_start( ft );
	112	}
	113
[2c2df7d]	114	/*
	115	* First function that gets called when a file transfer request comes in.
	116	* A lot to parse.
	117	*
	118	* We choose a stream type from the options given by the initiator.
	119	* Then we wait for imcb to call the accept or cancel callbacks.
	120	*/
	121	int jabber_si_handle_request( struct im_connection ic, struct xt_node node, struct xt_node *sinode)
	122	{
	123	struct xt_node c, d, *reply;
	124	char sid, ini_jid, tgt_jid, iq_id, s, ext_jid;
	125	struct jabber_buddy *bud;
	126	int requestok = FALSE;
	127	char *name;
	128	size_t size;
	129	struct jabber_transfer *tf;
	130	struct jabber_data *jd = ic->proto_data;
	131	file_transfer_t *ft;
	132
	133	/* All this means we expect something like this: ( I think )
	134	* <iq from=... to=... id=...>
	135	* <si id=id xmlns=si profile=ft>
	136	* <file xmlns=ft/>
	137	* <feature xmlns=feature>
	138	* <x xmlns=xdata type=submit>
	139	* <field var=stream-method>
	140	*
	141	*/
	142	if( !( ini_jid = xt_find_attr( node, "from" ) ) \|\|
	143	!( tgt_jid = xt_find_attr( node, "to" ) ) \|\|
	144	!( iq_id = xt_find_attr( node, "id" ) ) \|\|
	145	!( sid = xt_find_attr( sinode, "id" ) ) \|\|
	146	!( strcmp( xt_find_attr( sinode, "profile" ), XMLNS_FILETRANSFER ) == 0 ) \|\|
	147	!( d = xt_find_node( sinode->children, "file" ) ) \|\|
	148	!( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_FILETRANSFER ) == 0 ) \|\|
	149	!( name = xt_find_attr( d, "name" ) ) \|\|
	150	!( size = (size_t) atoll( xt_find_attr( d, "size" ) ) ) \|\|
	151	!( d = xt_find_node( sinode->children, "feature" ) ) \|\|
	152	!( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_FEATURE ) == 0 ) \|\|
	153	!( d = xt_find_node( d->children, "x" ) ) \|\|
	154	!( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_XDATA ) == 0 ) \|\|
	155	!( strcmp( xt_find_attr( d, "type" ), "form" ) == 0 ) \|\|
	156	!( d = xt_find_node( d->children, "field" ) ) \|\|
	157	!( strcmp( xt_find_attr( d, "var" ), "stream-method" ) == 0 ) )
	158	{
	159	imcb_log( ic, "WARNING: Received incomplete Stream Initiation request" );
	160	} else
	161	{
	162	/* Check if we support one of the options */
	163
	164	c = d->children;
	165	while( ( c = xt_find_node( c, "option" ) ) )
	166	if( ( d = xt_find_node( c->children, "value" ) ) &&
	167	( strcmp( d->text, XMLNS_BYTESTREAMS ) == 0 ) )
	168	{
	169	requestok = TRUE;
	170	break;
	171	}
[2ff2076]	172
	173	if ( !requestok )
	174	imcb_log( ic, "WARNING: Unsupported file transfer request from %s", ini_jid);
[2c2df7d]	175	}
	176
	177	if ( requestok )
	178	{
	179	/* Figure out who the transfer should come frome... */
	180
	181	if( ( s = strchr( ini_jid, '/' ) ) )
	182	{
	183	if( ( bud = jabber_buddy_by_jid( ic, ini_jid, GET_BUDDY_EXACT ) ) )
	184	{
	185	bud->last_act = time( NULL );
	186	ext_jid = bud->ext_jid ? : bud->bare_jid;
	187	}
	188	else
	189	s = 0; / We need to generate a bare JID now. */
	190	}
	191
	192	if( !( ft = imcb_file_send_start( ic, ext_jid, name, size ) ) )
	193	{
	194	imcb_log( ic, "WARNING: Error handling transfer request from %s", ini_jid);
	195	requestok = FALSE;
	196	}
	197
	198	*s = '/';
[2ff2076]	199	}
[2c2df7d]	200
	201	if ( !requestok )
	202	{
	203	reply = jabber_make_error_packet( node, "item-not-found", "cancel", NULL );
	204	if (!jabber_write_packet( ic, reply ))
	205	imcb_log( ic, "WARNING: Error generating reply to file transfer request" );
	206	xt_free_node( reply );
	207	return XT_HANDLED;
	208	}
	209
	210	/* Request is fine. */
	211
	212	imcb_log( ic, "File transfer request from %s for %s (%zd kb). ", xt_find_attr( node, "from" ), name, size/1024 );
	213
	214	imcb_log( ic, "Accept the DCC transfer if you'd like the file. If you don't, issue the 'transfers reject' command.");
	215
	216	tf = g_new0( struct jabber_transfer, 1 );
	217
	218	tf->ini_jid = g_strdup( ini_jid );
	219	tf->tgt_jid = g_strdup( tgt_jid );
	220	tf->iq_id = g_strdup( iq_id );
	221	tf->sid = g_strdup( sid );
	222	tf->ic = ic;
	223	tf->ft = ft;
	224	tf->ft->data = tf;
	225	tf->ft->accept = jabber_si_answer_request;
	226	tf->ft->free = jabber_si_free_transfer;
	227	tf->ft->finished = jabber_si_finished;
	228	tf->ft->canceled = jabber_si_canceled;
	229
	230	jd->filetransfers = g_slist_prepend( jd->filetransfers, tf );
	231
	232	return XT_HANDLED;
	233	}
	234
	235	/*
[dce3903]	236	* imc called the accept callback which probably means that the user accepted this file transfer.
[2c2df7d]	237	* We send our response to the initiator.
	238	* In the next step, the initiator will send us a request for the given stream type.
	239	* (currently that can only be a SOCKS5 bytestream)
	240	*/
	241	void jabber_si_answer_request( file_transfer_t *ft ) {
	242	struct jabber_transfer *tf = ft->data;
	243	struct xt_node node, sinode, *reply;
	244
	245	/* generate response, start with the SI tag */
	246	sinode = xt_new_node( "si", NULL, NULL );
	247	xt_add_attr( sinode, "xmlns", XMLNS_SI );
	248	xt_add_attr( sinode, "profile", XMLNS_FILETRANSFER );
	249	xt_add_attr( sinode, "id", tf->sid );
	250
	251	/* now the file tag */
	252	node = xt_new_node( "file", NULL, NULL );
	253	xt_add_attr( node, "xmlns", XMLNS_FILETRANSFER );
	254
	255	xt_add_child( sinode, node );
	256
	257	/* and finally the feature tag */
	258	node = xt_new_node( "field", NULL, NULL );
	259	xt_add_attr( node, "var", "stream-method" );
	260	xt_add_attr( node, "type", "list-single" );
	261
	262	/* Currently all we can do. One could also implement in-band (IBB) */
	263	xt_add_child( node, xt_new_node( "value", XMLNS_BYTESTREAMS, NULL ) );
	264
	265	node = xt_new_node( "x", NULL, node );
	266	xt_add_attr( node, "xmlns", XMLNS_XDATA );
	267	xt_add_attr( node, "type", "submit" );
	268
	269	node = xt_new_node( "feature", NULL, node );
	270	xt_add_attr( node, "xmlns", XMLNS_FEATURE );
	271
	272	xt_add_child( sinode, node );
	273
	274	reply = jabber_make_packet( "iq", "result", tf->ini_jid, sinode );
	275	xt_add_attr( reply, "id", tf->iq_id );
	276
	277	if( !jabber_write_packet( tf->ic, reply ) )
	278	imcb_log( tf->ic, "WARNING: Error generating reply to file transfer request" );
	279	else
	280	tf->accepted = TRUE;
	281	xt_free_node( reply );
	282	}
[2ff2076]	283
	284	static xt_status jabber_si_handle_response(struct im_connection ic, struct xt_node node, struct xt_node *orig )
	285	{
	286	struct xt_node c, d;
[dce3903]	287	char ini_jid, tgt_jid, *iq_id;
[2ff2076]	288	GSList *tflist;
	289	struct jabber_transfer *tf=NULL;
	290	struct jabber_data *jd = ic->proto_data;
	291
	292	if( !( tgt_jid = xt_find_attr( node, "from" ) ) \|\|
	293	!( ini_jid = xt_find_attr( node, "to" ) ) )
	294	{
	295	imcb_log( ic, "Invalid SI response from=%s to=%s", tgt_jid, ini_jid );
	296	return XT_HANDLED;
	297	}
	298
	299	/* All this means we expect something like this: ( I think )
[dce3903]	300	* <iq from=... to=... id=...>
[2ff2076]	301	* <si xmlns=si>
[dce3903]	302	* [ <file xmlns=ft/> ] <-- not neccessary
[2ff2076]	303	* <feature xmlns=feature>
	304	* <x xmlns=xdata type=submit>
	305	* <field var=stream-method>
	306	* <value>
	307	*/
	308	if( !( tgt_jid = xt_find_attr( node, "from" ) ) \|\|
	309	!( ini_jid = xt_find_attr( node, "to" ) ) \|\|
[dce3903]	310	!( iq_id = xt_find_attr( node, "id" ) ) \|\|
[2ff2076]	311	!( c = xt_find_node( node->children, "si" ) ) \|\|
	312	!( strcmp( xt_find_attr( c, "xmlns" ), XMLNS_SI ) == 0 ) \|\|
[dce3903]	313	/* !( d = xt_find_node( c->children, "file" ) ) \|\|
	314	!( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_FILETRANSFER ) == 0 ) \|\| */
[2ff2076]	315	!( d = xt_find_node( c->children, "feature" ) ) \|\|
	316	!( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_FEATURE ) == 0 ) \|\|
	317	!( d = xt_find_node( d->children, "x" ) ) \|\|
	318	!( strcmp( xt_find_attr( d, "xmlns" ), XMLNS_XDATA ) == 0 ) \|\|
	319	!( strcmp( xt_find_attr( d, "type" ), "submit" ) == 0 ) \|\|
	320	!( d = xt_find_node( d->children, "field" ) ) \|\|
	321	!( strcmp( xt_find_attr( d, "var" ), "stream-method" ) == 0 ) \|\|
	322	!( d = xt_find_node( d->children, "value" ) ) )
	323	{
	324	imcb_log( ic, "WARNING: Received incomplete Stream Initiation response" );
	325	return XT_HANDLED;
	326	}
	327
	328	if( !( strcmp( d->text, XMLNS_BYTESTREAMS ) == 0 ) ) {
	329	/* since we should only have advertised what we can do and the peer should
	330	* only have chosen what we offered, this should never happen */
	331	imcb_log( ic, "WARNING: Received invalid Stream Initiation response, method %s", d->text );
	332
	333	return XT_HANDLED;
	334	}
	335
	336	/* Let's see if we can find out what this bytestream should be for... */
	337
	338	for( tflist = jd->filetransfers ; tflist; tflist = g_slist_next(tflist) )
	339	{
	340	struct jabber_transfer *tft = tflist->data;
[dce3903]	341	if( ( strcmp( tft->iq_id, iq_id ) == 0 ) )
[2ff2076]	342	{
	343	tf = tft;
	344	break;
	345	}
	346	}
	347
	348	if (!tf)
	349	{
	350	imcb_log( ic, "WARNING: Received bytestream request from %s that doesn't match an SI request", ini_jid );
	351	return XT_HANDLED;
	352	}
	353
	354	tf->ini_jid = g_strdup( ini_jid );
	355	tf->tgt_jid = g_strdup( tgt_jid );
	356
[dce3903]	357	imcb_log( ic, "File %s: %s accepted the transfer!", tf->ft->file_name, tgt_jid );
	358
[2ff2076]	359	jabber_bs_send_start( tf );
	360
	361	return XT_HANDLED;
	362	}
	363
	364	int jabber_si_send_request(struct im_connection ic, char who, struct jabber_transfer *tf )
	365	{
	366	struct xt_node node, sinode;
	367	struct jabber_buddy *bud;
	368
	369	/* who knows how many bits the future holds :) */
	370	char filesizestr[ 1 + ( int ) ( 0.301029995663981198f * sizeof( size_t ) * 8 ) ];
	371
	372	const char *methods[] =
	373	{
	374	XMLNS_BYTESTREAMS,
	375	//XMLNS_IBB,
	376	NULL
	377	};
	378	const char **m;
	379	char *s;
	380
	381	/* Maybe we should hash this? */
	382	tf->sid = g_strdup_printf( "BitlBeeJabberSID%d", tf->ft->local_id );
	383
[793cc25]	384	if( ( s = strchr( who, '=' ) ) && jabber_chat_by_jid( ic, s + 1 ) )
[2ff2076]	385	bud = jabber_buddy_by_ext_jid( ic, who, 0 );
	386	else
	387	bud = jabber_buddy_by_jid( ic, who, 0 );
	388
	389	/* start with the SI tag */
	390	sinode = xt_new_node( "si", NULL, NULL );
	391	xt_add_attr( sinode, "xmlns", XMLNS_SI );
	392	xt_add_attr( sinode, "profile", XMLNS_FILETRANSFER );
	393	xt_add_attr( sinode, "id", tf->sid );
	394
	395	/* if( mimetype )
	396	xt_add_attr( node, "mime-type", mimetype ); */
	397
	398	/* now the file tag */
	399	/* if( desc )
	400	node = xt_new_node( "desc", descr, NULL ); */
	401	node = xt_new_node( "range", NULL, NULL );
	402
	403	sprintf( filesizestr, "%zd", tf->ft->file_size );
	404	node = xt_new_node( "file", NULL, node );
	405	xt_add_attr( node, "xmlns", XMLNS_FILETRANSFER );
	406	xt_add_attr( node, "name", tf->ft->file_name );
	407	xt_add_attr( node, "size", filesizestr );
	408	/* if (hash)
	409	xt_add_attr( node, "hash", hash );
	410	if (date)
	411	xt_add_attr( node, "date", date ); */
	412
	413	xt_add_child( sinode, node );
	414
	415	/* and finally the feature tag */
	416	node = xt_new_node( "field", NULL, NULL );
	417	xt_add_attr( node, "var", "stream-method" );
	418	xt_add_attr( node, "type", "list-single" );
	419
	420	for ( m = methods ; *m ; m ++ )
	421	xt_add_child( node, xt_new_node( "option", NULL, xt_new_node( "value", (char )m, NULL ) ) );
	422
	423	node = xt_new_node( "x", NULL, node );
	424	xt_add_attr( node, "xmlns", XMLNS_XDATA );
	425	xt_add_attr( node, "type", "form" );
	426
	427	node = xt_new_node( "feature", NULL, node );
	428	xt_add_attr( node, "xmlns", XMLNS_FEATURE );
	429
	430	xt_add_child( sinode, node );
	431
	432	/* and we are there... */
	433	node = jabber_make_packet( "iq", "set", bud ? bud->full_jid : who, sinode );
	434	jabber_cache_add( ic, node, jabber_si_handle_response );
[dce3903]	435	tf->iq_id = g_strdup( xt_find_attr( node, "id" ) );
[2ff2076]	436
	437	return jabber_write_packet( ic, node );
	438	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: