Context Navigation

source: lib/misc.c @ 3a9b123

Last change on this file since 3a9b123 was 89c11e7, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-04-12T23:54:55Z
Restored CTCP/DCC hooks for outgoing file transfers.
Property mode set to `100644`
File size: 13.8 KB

Rev	Line
[b7d3cc34]	1	/********************************************************************\
	2	* BitlBee -- An IRC to other IM-networks gateway *
	3	* *
[1719464]	4	* Copyright 2002-2006 Wilmer van der Gaast and others *
[b7d3cc34]	5	\********************************************************************/
	6
	7	/*
[c88999c]	8	* Various utility functions. Some are copied from Gaim to support the
	9	* IM-modules, most are from BitlBee.
[b7d3cc34]	10	*
	11	* Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
	12	* (and possibly other members of the Gaim team)
[1719464]	13	* Copyright 2002-2006 Wilmer van der Gaast <wilmer@gaast.net>
[b7d3cc34]	14	*/
	15
	16	/*
	17	This program is free software; you can redistribute it and/or modify
	18	it under the terms of the GNU General Public License as published by
	19	the Free Software Foundation; either version 2 of the License, or
	20	(at your option) any later version.
	21
	22	This program is distributed in the hope that it will be useful,
	23	but WITHOUT ANY WARRANTY; without even the implied warranty of
	24	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	25	GNU General Public License for more details.
	26
	27	You should have received a copy of the GNU General Public License with
	28	the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
	29	if not, write to the Free Software Foundation, Inc., 59 Temple Place,
	30	Suite 330, Boston, MA 02111-1307 USA
	31	*/
	32
	33	#define BITLBEE_CORE
	34	#include "nogaim.h"
[4e8db1c]	35	#include "base64.h"
[c6ca3ee]	36	#include "md5.h"
[b7d3cc34]	37	#include <stdio.h>
	38	#include <stdlib.h>
	39	#include <string.h>
[dd8d4c5]	40	#include <ctype.h>
[b7d3cc34]	41	#include <glib.h>
	42	#include <time.h>
	43
[36e9f62]	44	#ifdef HAVE_RESOLV_A
	45	#include <arpa/nameser.h>
	46	#include <resolv.h>
	47	#endif
	48
[4cf80bb]	49	#include "md5.h"
[d52111a]	50	#include "ssl_client.h"
	51
[b7d3cc34]	52	void strip_linefeed(gchar *text)
	53	{
	54	int i, j;
	55	gchar *text2 = g_malloc(strlen(text) + 1);
	56
	57	for (i = 0, j = 0; text[i]; i++)
	58	if (text[i] != '\r')
	59	text2[j++] = text[i];
	60	text2[j] = '\0';
	61
	62	strcpy(text, text2);
	63	g_free(text2);
	64	}
	65
	66	time_t get_time(int year, int month, int day, int hour, int min, int sec)
	67	{
	68	struct tm tm;
	69
[613cc55]	70	memset(&tm, 0, sizeof(struct tm));
[b7d3cc34]	71	tm.tm_year = year - 1900;
	72	tm.tm_mon = month - 1;
	73	tm.tm_mday = day;
	74	tm.tm_hour = hour;
	75	tm.tm_min = min;
	76	tm.tm_sec = sec >= 0 ? sec : time(NULL) % 60;
[613cc55]	77
[b7d3cc34]	78	return mktime(&tm);
	79	}
	80
	81	typedef struct htmlentity
	82	{
[51fdc45]	83	char code[7];
	84	char is[3];
[b7d3cc34]	85	} htmlentity_t;
	86
[39cc341]	87	static const htmlentity_t ent[] =
[b7d3cc34]	88	{
[39cc341]	89	{ "lt", "<" },
	90	{ "gt", ">" },
	91	{ "amp", "&" },
[b52e478]	92	{ "apos", "'" },
[39cc341]	93	{ "quot", "\"" },
	94	{ "aacute", "á" },
	95	{ "eacute", "é" },
	96	{ "iacute", "é" },
	97	{ "oacute", "ó" },
	98	{ "uacute", "ú" },
	99	{ "agrave", "à" },
	100	{ "egrave", "è" },
	101	{ "igrave", "ì" },
	102	{ "ograve", "ò" },
	103	{ "ugrave", "ù" },
	104	{ "acirc", "â" },
	105	{ "ecirc", "ê" },
	106	{ "icirc", "î" },
	107	{ "ocirc", "ô" },
	108	{ "ucirc", "û" },
	109	{ "auml", "ä" },
	110	{ "euml", "ë" },
	111	{ "iuml", "ï" },
	112	{ "ouml", "ö" },
	113	{ "uuml", "ü" },
	114	{ "nbsp", " " },
	115	{ "", "" }
[b7d3cc34]	116	};
	117
	118	void strip_html( char *in )
	119	{
	120	char *start = in;
	121	char *out = g_malloc( strlen( in ) + 1 );
	122	char s = out, cs;
	123	int i, matched;
	124
	125	memset( out, 0, strlen( in ) + 1 );
	126
	127	while( *in )
	128	{
	129	if( in == '<' && ( isalpha( (in+1) ) \|\| *(in+1) == '/' ) )
	130	{
	131	/* If in points at a < and in+1 points at a letter or a slash, this is probably
	132	a HTML-tag. Try to find a closing > and continue there. If the > can't be
	133	found, assume that it wasn't a HTML-tag after all. */
	134
	135	cs = in;
	136
	137	while( in && in != '>' )
	138	in ++;
	139
	140	if( *in )
	141	{
	142	if( g_strncasecmp( cs+1, "br", 2) == 0 )
	143	*(s++) = '\n';
	144	in ++;
	145	}
	146	else
	147	{
	148	in = cs;
	149	(s++) = (in++);
	150	}
	151	}
	152	else if( *in == '&' )
	153	{
	154	cs = ++in;
	155	while( in && isalpha( in ) )
	156	in ++;
	157
	158	if( *in == ';' ) in ++;
	159	matched = 0;
	160
	161	for( i = 0; *ent[i].code; i ++ )
	162	if( g_strncasecmp( ent[i].code, cs, strlen( ent[i].code ) ) == 0 )
	163	{
[39cc341]	164	int j;
	165
	166	for( j = 0; ent[i].is[j]; j ++ )
	167	*(s++) = ent[i].is[j];
	168
[b7d3cc34]	169	matched = 1;
	170	break;
	171	}
	172
	173	/* None of the entities were matched, so return the string */
	174	if( !matched )
	175	{
	176	in = cs - 1;
	177	(s++) = (in++);
	178	}
	179	}
	180	else
	181	{
	182	(s++) = (in++);
	183	}
	184	}
	185
	186	strcpy( start, out );
	187	g_free( out );
	188	}
	189
	190	char escape_html( const char html )
	191	{
	192	const char *c = html;
	193	GString *ret;
	194	char *str;
	195
	196	if( html == NULL )
	197	return( NULL );
	198
	199	ret = g_string_new( "" );
	200
	201	while( *c )
	202	{
	203	switch( *c )
	204	{
	205	case '&':
	206	ret = g_string_append( ret, "&" );
	207	break;
	208	case '<':
	209	ret = g_string_append( ret, "<" );
	210	break;
	211	case '>':
	212	ret = g_string_append( ret, ">" );
	213	break;
	214	case '"':
	215	ret = g_string_append( ret, """ );
	216	break;
	217	default:
	218	ret = g_string_append_c( ret, *c );
	219	}
	220	c ++;
	221	}
	222
	223	str = ret->str;
	224	g_string_free( ret, FALSE );
	225	return( str );
	226	}
	227
[c88999c]	228	/* Decode%20a%20file%20name */
	229	void http_decode( char *s )
	230	{
	231	char *t;
	232	int i, j, k;
	233
	234	t = g_new( char, strlen( s ) + 1 );
	235
	236	for( i = j = 0; s[i]; i ++, j ++ )
	237	{
	238	if( s[i] == '%' )
	239	{
	240	if( sscanf( s + i + 1, "%2x", &k ) )
	241	{
	242	t[j] = k;
	243	i += 2;
	244	}
	245	else
	246	{
	247	*t = 0;
	248	break;
	249	}
	250	}
	251	else
	252	{
	253	t[j] = s[i];
	254	}
	255	}
	256	t[j] = 0;
	257
	258	strcpy( s, t );
	259	g_free( t );
	260	}
	261
	262	/* Warning: This one explodes the string. Worst-cases can make the string 3x its original size! */
	263	/* This fuction is safe, but make sure you call it safely as well! */
	264	void http_encode( char *s )
	265	{
	266	char *t;
	267	int i, j;
	268
	269	t = g_strdup( s );
	270
	271	for( i = j = 0; t[i]; i ++, j ++ )
	272	{
[dd8d4c5]	273	/* if( t[i] <= ' ' \|\| ((unsigned char )t)[i] >= 128 \|\| t[i] == '%' ) /
	274	if( !isalnum( t[i] ) )
[c88999c]	275	{
	276	sprintf( s + j, "%%%02X", ((unsigned char*)t)[i] );
	277	j += 2;
	278	}
	279	else
	280	{
	281	s[j] = t[i];
	282	}
	283	}
	284	s[j] = 0;
	285
	286	g_free( t );
	287	}
	288
	289	/* Strip newlines from a string. Modifies the string passed to it. */
	290	char strip_newlines( char source )
	291	{
	292	int i;
	293
	294	for( i = 0; source[i] != '\0'; i ++ )
	295	if( source[i] == '\n' \|\| source[i] == '\r' )
	296	source[i] = ' ';
	297
	298	return source;
	299	}
[2a6ca4f]	300
	301	/* Wrap an IPv4 address into IPv6 space. Not thread-safe... */
	302	char ipv6_wrap( char src )
	303	{
	304	static char dst[64];
	305	int i;
	306
	307	for( i = 0; src[i]; i ++ )
	308	if( ( src[i] < '0' \|\| src[i] > '9' ) && src[i] != '.' )
	309	break;
	310
	311	/* Hmm, it's not even an IP... */
	312	if( src[i] )
	313	return src;
	314
	315	g_snprintf( dst, sizeof( dst ), "::ffff:%s", src );
	316
	317	return dst;
	318	}
	319
	320	/* Unwrap an IPv4 address into IPv6 space. Thread-safe, because it's very simple. :-) */
	321	char ipv6_unwrap( char src )
	322	{
	323	int i;
	324
	325	if( g_strncasecmp( src, "::ffff:", 7 ) != 0 )
	326	return src;
	327
	328	for( i = 7; src[i]; i ++ )
	329	if( ( src[i] < '0' \|\| src[i] > '9' ) && src[i] != '.' )
	330	break;
	331
	332	/* Hmm, it's not even an IP... */
	333	if( src[i] )
	334	return src;
	335
	336	return ( src + 7 );
	337	}
[e27661d]	338
	339	/* Convert from one charset to another.
	340
	341	from_cs, to_cs: Source and destination charsets
	342	src, dst: Source and destination strings
	343	size: Size if src. 0 == use strlen(). strlen() is not reliable for UNICODE/UTF16 strings though.
	344	maxbuf: Maximum number of bytes to write to dst
	345
	346	Returns the number of bytes written to maxbuf or -1 on an error.
	347	*/
	348	signed int do_iconv( char from_cs, char to_cs, char src, char dst, size_t size, size_t maxbuf )
	349	{
[574af7e]	350	GIConv cd;
[e27661d]	351	size_t res;
	352	size_t inbytesleft, outbytesleft;
	353	char *inbuf = src;
	354	char *outbuf = dst;
	355
[574af7e]	356	cd = g_iconv_open( to_cs, from_cs );
	357	if( cd == (GIConv) -1 )
[e27661d]	358	return( -1 );
	359
	360	inbytesleft = size ? size : strlen( src );
	361	outbytesleft = maxbuf - 1;
[574af7e]	362	res = g_iconv( cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
[e27661d]	363	*outbuf = '\0';
[574af7e]	364	g_iconv_close( cd );
[e27661d]	365
	366	if( res == (size_t) -1 )
	367	return( -1 );
	368	else
	369	return( outbuf - dst );
	370	}
	371
[7f49a86]	372	/* A pretty reliable random number generator. Tries to use the /dev/random
	373	devices first, and falls back to the random number generator from libc
	374	when it fails. Opens randomizer devices with O_NONBLOCK to make sure a
	375	lack of entropy won't halt BitlBee. */
	376	void random_bytes( unsigned char *buf, int count )
	377	{
	378	#ifndef _WIN32
	379	static int use_dev = -1;
	380
	381	/* Actually this probing code isn't really necessary, is it? */
	382	if( use_dev == -1 )
	383	{
	384	if( access( "/dev/random", R_OK ) == 0 \|\| access( "/dev/urandom", R_OK ) == 0 )
	385	use_dev = 1;
	386	else
	387	{
	388	use_dev = 0;
	389	srand( ( getpid() << 16 ) ^ time( NULL ) );
	390	}
	391	}
	392
	393	if( use_dev )
	394	{
	395	int fd;
	396
	397	/* At least on Linux, /dev/random can block if there's not
	398	enough entropy. We really don't want that, so if it can't
	399	give anything, use /dev/urandom instead. */
	400	if( ( fd = open( "/dev/random", O_RDONLY \| O_NONBLOCK ) ) >= 0 )
	401	if( read( fd, buf, count ) == count )
	402	{
	403	close( fd );
	404	return;
	405	}
	406	close( fd );
	407
	408	/* urandom isn't supposed to block at all, but just to be
	409	sure. If it blocks, we'll disable use_dev and use the libc
	410	randomizer instead. */
	411	if( ( fd = open( "/dev/urandom", O_RDONLY \| O_NONBLOCK ) ) >= 0 )
	412	if( read( fd, buf, count ) == count )
	413	{
	414	close( fd );
	415	return;
	416	}
	417	close( fd );
	418
	419	/* If /dev/random blocks once, we'll still try to use it
	420	again next time. If /dev/urandom also fails for some
	421	reason, stick with libc during this session. */
	422
	423	use_dev = 0;
	424	srand( ( getpid() << 16 ) ^ time( NULL ) );
	425	}
	426
	427	if( !use_dev )
	428	#endif
	429	{
	430	int i;
	431
	432	/* Possibly the LSB of rand() isn't very random on some
	433	platforms. Seems okay on at least Linux and OSX though. */
	434	for( i = 0; i < count; i ++ )
	435	buf[i] = rand() & 0xff;
	436	}
	437	}
	438
[5100caa]	439	int is_bool( char *value )
	440	{
	441	if( *value == 0 )
	442	return 0;
	443
	444	if( ( g_strcasecmp( value, "true" ) == 0 ) \|\| ( g_strcasecmp( value, "yes" ) == 0 ) \|\| ( g_strcasecmp( value, "on" ) == 0 ) )
	445	return 1;
	446	if( ( g_strcasecmp( value, "false" ) == 0 ) \|\| ( g_strcasecmp( value, "no" ) == 0 ) \|\| ( g_strcasecmp( value, "off" ) == 0 ) )
	447	return 1;
	448
	449	while( *value )
	450	if( !isdigit( *value ) )
	451	return 0;
	452	else
	453	value ++;
	454
	455	return 1;
	456	}
	457
	458	int bool2int( char *value )
	459	{
	460	int i;
	461
	462	if( ( g_strcasecmp( value, "true" ) == 0 ) \|\| ( g_strcasecmp( value, "yes" ) == 0 ) \|\| ( g_strcasecmp( value, "on" ) == 0 ) )
	463	return 1;
	464	if( ( g_strcasecmp( value, "false" ) == 0 ) \|\| ( g_strcasecmp( value, "no" ) == 0 ) \|\| ( g_strcasecmp( value, "off" ) == 0 ) )
	465	return 0;
	466
	467	if( sscanf( value, "%d", &i ) == 1 )
	468	return i;
	469
	470	return 0;
	471	}
[36e9f62]	472
	473	struct ns_srv_reply srv_lookup( char service, char protocol, char domain )
	474	{
	475	struct ns_srv_reply *reply = NULL;
	476	#ifdef HAVE_RESOLV_A
	477	char name[1024];
	478	unsigned char querybuf[1024];
	479	const unsigned char *buf;
	480	ns_msg nsh;
	481	ns_rr rr;
	482	int i, len, size;
	483
	484	g_snprintf( name, sizeof( name ), "_%s._%s.%s", service, protocol, domain );
	485
	486	if( ( size = res_query( name, ns_c_in, ns_t_srv, querybuf, sizeof( querybuf ) ) ) <= 0 )
	487	return NULL;
	488
	489	if( ns_initparse( querybuf, size, &nsh ) != 0 )
	490	return NULL;
	491
	492	if( ns_parserr( &nsh, ns_s_an, 0, &rr ) != 0 )
	493	return NULL;
	494
	495	size = ns_rr_rdlen( rr );
	496	buf = ns_rr_rdata( rr );
	497
	498	len = 0;
	499	for( i = 6; i < size && buf[i]; i += buf[i] + 1 )
	500	len += buf[i] + 1;
	501
	502	if( i > size )
	503	return NULL;
	504
	505	reply = g_malloc( sizeof( struct ns_srv_reply ) + len );
	506	memcpy( reply->name, buf + 7, len );
	507
	508	for( i = buf[6]; i < len && buf[7+i]; i += buf[7+i] + 1 )
	509	reply->name[i] = '.';
	510
	511	if( i > len )
	512	{
	513	g_free( reply );
	514	return NULL;
	515	}
	516
	517	reply->prio = ( buf[0] << 8 ) \| buf[1];
	518	reply->weight = ( buf[2] << 8 ) \| buf[3];
	519	reply->port = ( buf[4] << 8 ) \| buf[5];
	520	#endif
	521
	522	return reply;
	523	}
[d444c09]	524
	525	/* Word wrapping. Yes, I know this isn't UTF-8 clean. I'm willing to take the risk. */
[c6ca3ee]	526	char word_wrap( const char msg, int line_len )
[d444c09]	527	{
	528	GString *ret = g_string_sized_new( strlen( msg ) + 16 );
	529
	530	while( strlen( msg ) > line_len )
	531	{
	532	int i;
	533
	534	/* First try to find out if there's a newline already. Don't
	535	want to add more splits than necessary. */
	536	for( i = line_len; i > 0 && msg[i] != '\n'; i -- );
	537	if( msg[i] == '\n' )
	538	{
	539	g_string_append_len( ret, msg, i + 1 );
	540	msg += i + 1;
	541	continue;
	542	}
	543
	544	for( i = line_len; i > 0; i -- )
	545	{
	546	if( msg[i] == '-' )
	547	{
	548	g_string_append_len( ret, msg, i + 1 );
	549	g_string_append_c( ret, '\n' );
	550	msg += i + 1;
	551	break;
	552	}
	553	else if( msg[i] == ' ' )
	554	{
	555	g_string_append_len( ret, msg, i );
	556	g_string_append_c( ret, '\n' );
	557	msg += i + 1;
	558	break;
	559	}
	560	}
	561	if( i == 0 )
	562	{
	563	g_string_append_len( ret, msg, line_len );
	564	g_string_append_c( ret, '\n' );
	565	msg += line_len;
	566	}
	567	}
	568	g_string_append( ret, msg );
	569
	570	return g_string_free( ret, FALSE );
	571	}
[d52111a]	572
	573	gboolean ssl_sockerr_again( void *ssl )
	574	{
	575	if( ssl )
	576	return ssl_errno == SSL_AGAIN;
	577	else
	578	return sockerr_again();
	579	}
[4e8db1c]	580
	581	/* Returns values: -1 == Failure (base64-decoded to something unexpected)
	582	0 == Okay
	583	1 == Password doesn't match the hash. */
	584	int md5_verify_password( char password, char hash )
	585	{
	586	md5_byte_t *pass_dec = NULL;
	587	md5_byte_t pass_md5[16];
	588	md5_state_t md5_state;
[6a78c0e]	589	int ret = -1, i;
[4e8db1c]	590
[6a78c0e]	591	if( base64_decode( hash, &pass_dec ) == 21 )
[4e8db1c]	592	{
	593	md5_init( &md5_state );
	594	md5_append( &md5_state, (md5_byte_t*) password, strlen( password ) );
	595	md5_append( &md5_state, (md5_byte_t) pass_dec + 16, 5 ); / Hmmm, salt! */
	596	md5_finish( &md5_state, pass_md5 );
	597
	598	for( i = 0; i < 16; i ++ )
	599	{
	600	if( pass_dec[i] != pass_md5[i] )
	601	{
	602	ret = 1;
	603	break;
	604	}
	605	}
	606
	607	/* If we reached the end of the loop, it was a match! */
	608	if( i == 16 )
	609	ret = 0;
	610	}
	611
	612	g_free( pass_dec );
	613
	614	return ret;
	615	}
[24b8bbb]	616
	617	char *split_command_parts( char command )
	618	{
	619	static char *cmd[IRC_MAX_ARGS+1];
	620	char *s, q = 0;
	621	int k;
	622
	623	memset( cmd, 0, sizeof( cmd ) );
	624	cmd[0] = command;
	625	k = 1;
	626	for( s = command; *s && k < IRC_MAX_ARGS; s ++ )
	627	if( *s == ' ' && !q )
	628	{
	629	*s = 0;
	630	while( *++s == ' ' );
	631	if( s == '"' \|\| s == '\'' )
	632	{
	633	q = *s;
	634	s ++;
	635	}
	636	if( *s )
	637	{
	638	cmd[k++] = s;
	639	s --;
	640	}
	641	else
	642	{
	643	break;
	644	}
	645	}
	646	else if( *s == '\\' && ( ( !q && s[1] ) \|\| ( q && q == s[1] ) ) )
	647	{
	648	char *cpy;
	649
	650	for( cpy = s; *cpy; cpy ++ )
	651	cpy[0] = cpy[1];
	652	}
	653	else if( *s == q )
	654	{
	655	q = *s = 0;
	656	}
[89c11e7]	657
	658	/* Full zero-padding for easier argc checking. */
	659	while( k <= IRC_MAX_ARGS )
	660	cmd[k++] = NULL;
[24b8bbb]	661
	662	return cmd;
	663	}

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

Download in other formats: