Context Navigation

source: protocols/jabber/si.c @ d2b3f25

Last change on this file since d2b3f25 was 8256ad5, checked in by dequis <dx@…>, at 2014-10-27T06:36:05Z

Some more g_source_remove warning fixes

http_incoming_data calling itself
jabber_bs_free_transfer calling jabber_si_free_transfer

Property mode set to 100644

File size: 17.0 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 )
[8256ad5]	37	{
[2c2df7d]	38	b_event_remove( tf->watch_in );
[8256ad5]	39	tf->watch_in = 0;
	40	}
[2c2df7d]	41
	42	jd->filetransfers = g_slist_remove( jd->filetransfers, tf );
	43
[8a90001]	44	if( tf->fd != -1 )
[2c2df7d]	45	{
[b8a491d]	46	closesocket( tf->fd );
[8a90001]	47	tf->fd = -1;
[2c2df7d]	48	}
	49
[b5cfc2b]	50	if( tf->disco_timeout )
	51	b_event_remove( tf->disco_timeout );
	52
[2c2df7d]	53	g_free( tf->ini_jid );
	54	g_free( tf->tgt_jid );
	55	g_free( tf->iq_id );
	56	g_free( tf->sid );
[78d254f1]	57	g_free( tf );
[2c2df7d]	58	}
	59
[2ff2076]	60	/* file_transfer canceled() callback */
[2c2df7d]	61	void jabber_si_canceled( file_transfer_t ft, char reason )
	62	{
	63	struct jabber_transfer *tf = ft->data;
	64	struct xt_node reply, iqnode;
	65
	66	if( tf->accepted )
	67	return;
	68
	69	iqnode = jabber_make_packet( "iq", "error", tf->ini_jid, NULL );
	70	xt_add_attr( iqnode, "id", tf->iq_id );
	71	reply = jabber_make_error_packet( iqnode, "forbidden", "cancel", "403" );
	72	xt_free_node( iqnode );
	73
	74	if( !jabber_write_packet( tf->ic, reply ) )
	75	imcb_log( tf->ic, "WARNING: Error generating reply to file transfer request" );
	76	xt_free_node( reply );
	77
	78	}
	79
[b5cfc2b]	80	int jabber_si_check_features( struct jabber_transfer tf, GSList features ) {
	81	int foundft = FALSE, foundbt = FALSE, foundsi = FALSE;
	82
	83	while ( features )
	84	{
	85	if( !strcmp( features->data, XMLNS_FILETRANSFER ) )
	86	foundft = TRUE;
	87	if( !strcmp( features->data, XMLNS_BYTESTREAMS ) )
	88	foundbt = TRUE;
	89	if( !strcmp( features->data, XMLNS_SI ) )
	90	foundsi = TRUE;
	91
	92	features = g_slist_next(features);
	93	}
	94
	95	if( !foundft )
[17a6ee9]	96	imcb_file_canceled( tf->ic, tf->ft, "Buddy's client doesn't feature file transfers" );
[b5cfc2b]	97	else if( !foundbt )
[17a6ee9]	98	imcb_file_canceled( tf->ic, tf->ft, "Buddy's client doesn't feature byte streams (required)" );
[b5cfc2b]	99	else if( !foundsi )
[17a6ee9]	100	imcb_file_canceled( tf->ic, tf->ft, "Buddy's client doesn't feature stream initiation (required)" );
[b5cfc2b]	101
	102	return foundft && foundbt && foundsi;
	103	}
	104
	105	void jabber_si_transfer_start( struct jabber_transfer *tf ) {
	106
	107	if( !jabber_si_check_features( tf, tf->bud->features ) )
	108	return;
	109
	110	/* send the request to our buddy */
	111	jabber_si_send_request( tf->ic, tf->bud->full_jid, tf );
	112
	113	/* and start the receive logic */
[17a6ee9]	114	imcb_file_recv_start( tf->ic, tf->ft );
[b5cfc2b]	115
	116	}
	117
	118	gboolean jabber_si_waitfor_disco( gpointer data, gint fd, b_input_condition cond )
	119	{
	120	struct jabber_transfer *tf = data;
	121	struct jabber_data *jd = tf->ic->proto_data;
	122
	123	tf->disco_timeout_fired++;
	124
	125	if( tf->bud->features && jd->have_streamhosts==1 ) {
	126	tf->disco_timeout = 0;
[8a90001]	127	jabber_si_transfer_start( tf );
[b5cfc2b]	128	return FALSE;
	129	}
	130
	131	/* 8 seconds should be enough for server and buddy to respond */
	132	if ( tf->disco_timeout_fired < 16 )
	133	return TRUE;
	134
	135	if( !tf->bud->features && jd->have_streamhosts!=1 )
[8a90001]	136	imcb_log( tf->ic, "Couldn't get buddy's features nor discover all services of the server" );
[b5cfc2b]	137	else if( !tf->bud->features )
[8a90001]	138	imcb_log( tf->ic, "Couldn't get buddy's features" );
[b5cfc2b]	139	else
[8a90001]	140	imcb_log( tf->ic, "Couldn't discover some of the server's services" );
[b5cfc2b]	141
	142	tf->disco_timeout = 0;
[8a90001]	143	jabber_si_transfer_start( tf );
[b5cfc2b]	144	return FALSE;
	145	}
	146
[2ff2076]	147	void jabber_si_transfer_request( struct im_connection ic, file_transfer_t ft, char *who )
	148	{
	149	struct jabber_transfer *tf;
	150	struct jabber_data *jd = ic->proto_data;
[b5cfc2b]	151	struct jabber_buddy *bud;
	152	char server = jd->server, s;
	153
	154	if( ( s = strchr( who, '=' ) ) && jabber_chat_by_jid( ic, s + 1 ) )
	155	bud = jabber_buddy_by_ext_jid( ic, who, 0 );
	156	else
	157	bud = jabber_buddy_by_jid( ic, who, 0 );
[2ff2076]	158
[b5cfc2b]	159	if( bud == NULL )
	160	{
[17a6ee9]	161	imcb_file_canceled( ic, ft, "Couldn't find buddy (BUG?)" );
[b5cfc2b]	162	return;
	163	}
[b8a491d]	164
[dce3903]	165	imcb_log( ic, "Trying to send %s(%zd bytes) to %s", ft->file_name, ft->file_size, who );
[2ff2076]	166
	167	tf = g_new0( struct jabber_transfer, 1 );
	168
	169	tf->ic = ic;
	170	tf->ft = ft;
[8a90001]	171	tf->fd = -1;
[2ff2076]	172	tf->ft->data = tf;
	173	tf->ft->free = jabber_si_free_transfer;
[b5cfc2b]	174	tf->bud = bud;
[2ff2076]	175	ft->write = jabber_bs_send_write;
	176
	177	jd->filetransfers = g_slist_prepend( jd->filetransfers, tf );
	178
[b5cfc2b]	179	/* query buddy's features and server's streaming proxies if neccessary */
[dc0ba9c]	180
[b5cfc2b]	181	if( !tf->bud->features )
	182	jabber_iq_query_features( ic, bud->full_jid );
[dc0ba9c]	183
[8a90001]	184	/* If <auto> is not set don't check for proxies */
	185	if( ( jd->have_streamhosts!=1 ) && ( jd->streamhosts==NULL ) &&
	186	( strstr( set_getstr( &ic->acc->set, "proxy" ), "<auto>" ) != NULL ) ) {
[b5cfc2b]	187	jd->have_streamhosts = 0;
	188	jabber_iq_query_server( ic, server, XMLNS_DISCO_ITEMS );
[8a90001]	189	} else if ( jd->streamhosts!=NULL )
	190	jd->have_streamhosts = 1;
[2ff2076]	191
[b5cfc2b]	192	/* if we had to do a query, wait for the result.
	193	* Otherwise fire away. */
	194	if( !tf->bud->features \|\| jd->have_streamhosts!=1 )
	195	tf->disco_timeout = b_timeout_add( 500, jabber_si_waitfor_disco, tf );
	196	else
	197	jabber_si_transfer_start( tf );
[2ff2076]	198	}
	199
[2c2df7d]	200	/*
	201	* First function that gets called when a file transfer request comes in.
	202	* A lot to parse.
	203	*
	204	* We choose a stream type from the options given by the initiator.
	205	* Then we wait for imcb to call the accept or cancel callbacks.
	206	*/
	207	int jabber_si_handle_request( struct im_connection ic, struct xt_node node, struct xt_node *sinode)
	208	{
	209	struct xt_node c, d, *reply;
[78d254f1]	210	char sid, ini_jid, tgt_jid, iq_id, s, ext_jid, *size_s;
[2c2df7d]	211	struct jabber_buddy *bud;
	212	int requestok = FALSE;
[aed152f]	213	char name, cmp;
[2c2df7d]	214	size_t size;
	215	struct jabber_transfer *tf;
	216	struct jabber_data *jd = ic->proto_data;
	217	file_transfer_t *ft;
	218
	219	/* All this means we expect something like this: ( I think )
	220	* <iq from=... to=... id=...>
	221	* <si id=id xmlns=si profile=ft>
	222	* <file xmlns=ft/>
	223	* <feature xmlns=feature>
	224	* <x xmlns=xdata type=submit>
	225	* <field var=stream-method>
	226	*
	227	*/
	228	if( !( ini_jid = xt_find_attr( node, "from" ) ) \|\|
	229	!( tgt_jid = xt_find_attr( node, "to" ) ) \|\|
	230	!( iq_id = xt_find_attr( node, "id" ) ) \|\|
	231	!( sid = xt_find_attr( sinode, "id" ) ) \|\|
[aed152f]	232	!( cmp = xt_find_attr( sinode, "profile" ) ) \|\|
	233	!( 0 == strcmp( cmp, XMLNS_FILETRANSFER ) ) \|\|
[2c2df7d]	234	!( d = xt_find_node( sinode->children, "file" ) ) \|\|
[aed152f]	235	!( cmp = xt_find_attr( d, "xmlns" ) ) \|\|
	236	!( 0 == strcmp( cmp, XMLNS_FILETRANSFER ) ) \|\|
[2c2df7d]	237	!( name = xt_find_attr( d, "name" ) ) \|\|
[78d254f1]	238	!( size_s = xt_find_attr( d, "size" ) ) \|\|
[b8a491d]	239	!( 1 == sscanf( size_s, "%zd", &size ) ) \|\|
[2c2df7d]	240	!( d = xt_find_node( sinode->children, "feature" ) ) \|\|
[aed152f]	241	!( cmp = xt_find_attr( d, "xmlns" ) ) \|\|
	242	!( 0 == strcmp( cmp, XMLNS_FEATURE ) ) \|\|
[2c2df7d]	243	!( d = xt_find_node( d->children, "x" ) ) \|\|
[aed152f]	244	!( cmp = xt_find_attr( d, "xmlns" ) ) \|\|
	245	!( 0 == strcmp( cmp, XMLNS_XDATA ) ) \|\|
	246	!( cmp = xt_find_attr( d, "type" ) ) \|\|
	247	!( 0 == strcmp( cmp, "form" ) ) \|\|
[2c2df7d]	248	!( d = xt_find_node( d->children, "field" ) ) \|\|
[aed152f]	249	!( cmp = xt_find_attr( d, "var" ) ) \|\|
	250	!( 0 == strcmp( cmp, "stream-method" ) ) )
[2c2df7d]	251	{
	252	imcb_log( ic, "WARNING: Received incomplete Stream Initiation request" );
[b8a491d]	253	}
	254	else
[2c2df7d]	255	{
	256	/* Check if we support one of the options */
	257
	258	c = d->children;
	259	while( ( c = xt_find_node( c, "option" ) ) )
[b8a491d]	260	if( ( d = xt_find_node( c->children, "value" ) ) &&
[699376f7]	261	( d->text != NULL ) &&
[b8a491d]	262	( strcmp( d->text, XMLNS_BYTESTREAMS ) == 0 ) )
[2c2df7d]	263	{
	264	requestok = TRUE;
	265	break;
	266	}
[1bb1e01]	267	else
	268	{
	269	c = c->next;
	270	}
[2ff2076]	271
	272	if ( !requestok )
	273	imcb_log( ic, "WARNING: Unsupported file transfer request from %s", ini_jid);
[2c2df7d]	274	}
	275
[b8a491d]	276	if( requestok )
[2c2df7d]	277	{
	278	/* Figure out who the transfer should come frome... */
	279
[b8a491d]	280	ext_jid = ini_jid;
[2c2df7d]	281	if( ( s = strchr( ini_jid, '/' ) ) )
	282	{
	283	if( ( bud = jabber_buddy_by_jid( ic, ini_jid, GET_BUDDY_EXACT ) ) )
	284	{
[1cc0df3]	285	bud->last_msg = time( NULL );
[2c2df7d]	286	ext_jid = bud->ext_jid ? : bud->bare_jid;
	287	}
	288	else
	289	s = 0; / We need to generate a bare JID now. */
	290	}
	291
	292	if( !( ft = imcb_file_send_start( ic, ext_jid, name, size ) ) )
	293	{
	294	imcb_log( ic, "WARNING: Error handling transfer request from %s", ini_jid);
	295	requestok = FALSE;
	296	}
	297
[92d3044]	298	if( s )
	299	*s = '/';
[2ff2076]	300	}
[92d3044]	301
	302	if( !requestok )
[2c2df7d]	303	{
	304	reply = jabber_make_error_packet( node, "item-not-found", "cancel", NULL );
	305	if (!jabber_write_packet( ic, reply ))
	306	imcb_log( ic, "WARNING: Error generating reply to file transfer request" );
	307	xt_free_node( reply );
	308	return XT_HANDLED;
	309	}
	310
	311	/* Request is fine. */
	312
	313	tf = g_new0( struct jabber_transfer, 1 );
	314
	315	tf->ini_jid = g_strdup( ini_jid );
	316	tf->tgt_jid = g_strdup( tgt_jid );
	317	tf->iq_id = g_strdup( iq_id );
	318	tf->sid = g_strdup( sid );
	319	tf->ic = ic;
	320	tf->ft = ft;
[8a90001]	321	tf->fd = -1;
[2c2df7d]	322	tf->ft->data = tf;
	323	tf->ft->accept = jabber_si_answer_request;
	324	tf->ft->free = jabber_si_free_transfer;
	325	tf->ft->canceled = jabber_si_canceled;
	326
	327	jd->filetransfers = g_slist_prepend( jd->filetransfers, tf );
	328
	329	return XT_HANDLED;
	330	}
	331
	332	/*
[dce3903]	333	* imc called the accept callback which probably means that the user accepted this file transfer.
[2c2df7d]	334	* We send our response to the initiator.
	335	* In the next step, the initiator will send us a request for the given stream type.
	336	* (currently that can only be a SOCKS5 bytestream)
	337	*/
	338	void jabber_si_answer_request( file_transfer_t *ft ) {
	339	struct jabber_transfer *tf = ft->data;
	340	struct xt_node node, sinode, *reply;
	341
	342	/* generate response, start with the SI tag */
	343	sinode = xt_new_node( "si", NULL, NULL );
	344	xt_add_attr( sinode, "xmlns", XMLNS_SI );
	345	xt_add_attr( sinode, "profile", XMLNS_FILETRANSFER );
	346	xt_add_attr( sinode, "id", tf->sid );
	347
	348	/* now the file tag */
	349	node = xt_new_node( "file", NULL, NULL );
	350	xt_add_attr( node, "xmlns", XMLNS_FILETRANSFER );
	351
	352	xt_add_child( sinode, node );
	353
	354	/* and finally the feature tag */
	355	node = xt_new_node( "field", NULL, NULL );
	356	xt_add_attr( node, "var", "stream-method" );
	357	xt_add_attr( node, "type", "list-single" );
	358
	359	/* Currently all we can do. One could also implement in-band (IBB) */
	360	xt_add_child( node, xt_new_node( "value", XMLNS_BYTESTREAMS, NULL ) );
	361
	362	node = xt_new_node( "x", NULL, node );
	363	xt_add_attr( node, "xmlns", XMLNS_XDATA );
	364	xt_add_attr( node, "type", "submit" );
	365
	366	node = xt_new_node( "feature", NULL, node );
	367	xt_add_attr( node, "xmlns", XMLNS_FEATURE );
	368
	369	xt_add_child( sinode, node );
	370
	371	reply = jabber_make_packet( "iq", "result", tf->ini_jid, sinode );
	372	xt_add_attr( reply, "id", tf->iq_id );
	373
	374	if( !jabber_write_packet( tf->ic, reply ) )
	375	imcb_log( tf->ic, "WARNING: Error generating reply to file transfer request" );
	376	else
	377	tf->accepted = TRUE;
	378	xt_free_node( reply );
	379	}
[2ff2076]	380
	381	static xt_status jabber_si_handle_response(struct im_connection ic, struct xt_node node, struct xt_node *orig )
	382	{
	383	struct xt_node c, d;
[bd599b9]	384	char ini_jid = NULL, tgt_jid, iq_id, cmp;
[2ff2076]	385	GSList *tflist;
	386	struct jabber_transfer *tf=NULL;
	387	struct jabber_data *jd = ic->proto_data;
	388
	389	if( !( tgt_jid = xt_find_attr( node, "from" ) ) \|\|
	390	!( ini_jid = xt_find_attr( node, "to" ) ) )
	391	{
	392	imcb_log( ic, "Invalid SI response from=%s to=%s", tgt_jid, ini_jid );
	393	return XT_HANDLED;
	394	}
	395
	396	/* All this means we expect something like this: ( I think )
[dce3903]	397	* <iq from=... to=... id=...>
[2ff2076]	398	* <si xmlns=si>
[dce3903]	399	* [ <file xmlns=ft/> ] <-- not neccessary
[2ff2076]	400	* <feature xmlns=feature>
	401	* <x xmlns=xdata type=submit>
	402	* <field var=stream-method>
	403	* <value>
	404	*/
	405	if( !( tgt_jid = xt_find_attr( node, "from" ) ) \|\|
	406	!( ini_jid = xt_find_attr( node, "to" ) ) \|\|
[dce3903]	407	!( iq_id = xt_find_attr( node, "id" ) ) \|\|
[2ff2076]	408	!( c = xt_find_node( node->children, "si" ) ) \|\|
[aed152f]	409	!( cmp = xt_find_attr( c, "xmlns" ) ) \|\|
	410	!( strcmp( cmp, XMLNS_SI ) == 0 ) \|\|
[2ff2076]	411	!( d = xt_find_node( c->children, "feature" ) ) \|\|
[aed152f]	412	!( cmp = xt_find_attr( d, "xmlns" ) ) \|\|
	413	!( strcmp( cmp, XMLNS_FEATURE ) == 0 ) \|\|
[2ff2076]	414	!( d = xt_find_node( d->children, "x" ) ) \|\|
[aed152f]	415	!( cmp = xt_find_attr( d, "xmlns" ) ) \|\|
	416	!( strcmp( cmp, XMLNS_XDATA ) == 0 ) \|\|
	417	!( cmp = xt_find_attr( d, "type" ) ) \|\|
	418	!( strcmp( cmp, "submit" ) == 0 ) \|\|
[2ff2076]	419	!( d = xt_find_node( d->children, "field" ) ) \|\|
[aed152f]	420	!( cmp = xt_find_attr( d, "var" ) ) \|\|
	421	!( strcmp( cmp, "stream-method" ) == 0 ) \|\|
[2ff2076]	422	!( d = xt_find_node( d->children, "value" ) ) )
	423	{
	424	imcb_log( ic, "WARNING: Received incomplete Stream Initiation response" );
	425	return XT_HANDLED;
	426	}
	427
	428	if( !( strcmp( d->text, XMLNS_BYTESTREAMS ) == 0 ) ) {
	429	/* since we should only have advertised what we can do and the peer should
	430	* only have chosen what we offered, this should never happen */
	431	imcb_log( ic, "WARNING: Received invalid Stream Initiation response, method %s", d->text );
	432
	433	return XT_HANDLED;
	434	}
	435
	436	/* Let's see if we can find out what this bytestream should be for... */
	437
	438	for( tflist = jd->filetransfers ; tflist; tflist = g_slist_next(tflist) )
	439	{
	440	struct jabber_transfer *tft = tflist->data;
[dce3903]	441	if( ( strcmp( tft->iq_id, iq_id ) == 0 ) )
[2ff2076]	442	{
	443	tf = tft;
	444	break;
	445	}
	446	}
	447
	448	if (!tf)
	449	{
	450	imcb_log( ic, "WARNING: Received bytestream request from %s that doesn't match an SI request", ini_jid );
	451	return XT_HANDLED;
	452	}
	453
	454	tf->ini_jid = g_strdup( ini_jid );
	455	tf->tgt_jid = g_strdup( tgt_jid );
	456
[dce3903]	457	imcb_log( ic, "File %s: %s accepted the transfer!", tf->ft->file_name, tgt_jid );
	458
[2ff2076]	459	jabber_bs_send_start( tf );
	460
	461	return XT_HANDLED;
	462	}
	463
	464	int jabber_si_send_request(struct im_connection ic, char who, struct jabber_transfer *tf )
	465	{
	466	struct xt_node node, sinode;
	467	struct jabber_buddy *bud;
	468
	469	/* who knows how many bits the future holds :) */
	470	char filesizestr[ 1 + ( int ) ( 0.301029995663981198f * sizeof( size_t ) * 8 ) ];
	471
	472	const char *methods[] =
	473	{
	474	XMLNS_BYTESTREAMS,
	475	//XMLNS_IBB,
	476	NULL
	477	};
	478	const char **m;
	479	char *s;
	480
	481	/* Maybe we should hash this? */
	482	tf->sid = g_strdup_printf( "BitlBeeJabberSID%d", tf->ft->local_id );
	483
[793cc25]	484	if( ( s = strchr( who, '=' ) ) && jabber_chat_by_jid( ic, s + 1 ) )
[2ff2076]	485	bud = jabber_buddy_by_ext_jid( ic, who, 0 );
	486	else
	487	bud = jabber_buddy_by_jid( ic, who, 0 );
	488
	489	/* start with the SI tag */
	490	sinode = xt_new_node( "si", NULL, NULL );
	491	xt_add_attr( sinode, "xmlns", XMLNS_SI );
	492	xt_add_attr( sinode, "profile", XMLNS_FILETRANSFER );
	493	xt_add_attr( sinode, "id", tf->sid );
	494
	495	/* if( mimetype )
	496	xt_add_attr( node, "mime-type", mimetype ); */
	497
	498	/* now the file tag */
	499	/* if( desc )
	500	node = xt_new_node( "desc", descr, NULL ); */
	501	node = xt_new_node( "range", NULL, NULL );
	502
	503	sprintf( filesizestr, "%zd", tf->ft->file_size );
	504	node = xt_new_node( "file", NULL, node );
	505	xt_add_attr( node, "xmlns", XMLNS_FILETRANSFER );
	506	xt_add_attr( node, "name", tf->ft->file_name );
	507	xt_add_attr( node, "size", filesizestr );
	508	/* if (hash)
	509	xt_add_attr( node, "hash", hash );
	510	if (date)
	511	xt_add_attr( node, "date", date ); */
	512
	513	xt_add_child( sinode, node );
	514
	515	/* and finally the feature tag */
	516	node = xt_new_node( "field", NULL, NULL );
	517	xt_add_attr( node, "var", "stream-method" );
	518	xt_add_attr( node, "type", "list-single" );
	519
	520	for ( m = methods ; *m ; m ++ )
	521	xt_add_child( node, xt_new_node( "option", NULL, xt_new_node( "value", (char )m, NULL ) ) );
	522
	523	node = xt_new_node( "x", NULL, node );
	524	xt_add_attr( node, "xmlns", XMLNS_XDATA );
	525	xt_add_attr( node, "type", "form" );
	526
	527	node = xt_new_node( "feature", NULL, node );
	528	xt_add_attr( node, "xmlns", XMLNS_FEATURE );
	529
	530	xt_add_child( sinode, node );
	531
	532	/* and we are there... */
	533	node = jabber_make_packet( "iq", "set", bud ? bud->full_jid : who, sinode );
	534	jabber_cache_add( ic, node, jabber_si_handle_response );
[dce3903]	535	tf->iq_id = g_strdup( xt_find_attr( node, "id" ) );
[2ff2076]	536
	537	return jabber_write_packet( ic, node );
	538	}

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

Download in other formats: