Context Navigation

source: lib/misc.c @ 762d96f

Last change on this file since 762d96f was ffdf2e7, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-08-10T11:18:09Z
When doing SRV lookups, return an array with all RRs instead of just the first one. The first isn't always the best one and this is currently causing GTalk issues when talk2.l.google.com (which is currently dead) is first.
Property mode set to `100644`
File size: 15.4 KB

Line
1	/********************************************************************\
2	* BitlBee -- An IRC to other IM-networks gateway *
3	* *
4	* Copyright 2002-2006 Wilmer van der Gaast and others *
5	\********************************************************************/
6
7	/*
8	* Various utility functions. Some are copied from Gaim to support the
9	* IM-modules, most are from BitlBee.
10	*
11	* Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
12	* (and possibly other members of the Gaim team)
13	* Copyright 2002-2006 Wilmer van der Gaast <wilmer@gaast.net>
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"
35	#include "base64.h"
36	#include "md5.h"
37	#include <stdio.h>
38	#include <stdlib.h>
39	#include <string.h>
40	#include <ctype.h>
41	#include <glib.h>
42	#include <time.h>
43
44	#ifdef HAVE_RESOLV_A
45	#include <arpa/nameser.h>
46	#include <resolv.h>
47	#endif
48
49	#include "md5.h"
50	#include "ssl_client.h"
51
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
70	memset(&tm, 0, sizeof(struct tm));
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;
77
78	return mktime(&tm);
79	}
80
81	time_t mktime_utc( struct tm *tp )
82	{
83	struct tm utc;
84	time_t res, tres;
85
86	tp->tm_isdst = -1;
87	res = mktime( tp );
88	/* Problem is, mktime() just gave us the GMT timestamp for the
89	given local time... While the given time WAS NOT local. So
90	we should fix this now.
91
92	Now I could choose between messing with environment variables
93	(kludgy) or using timegm() (not portable)... Or doing the
94	following, which I actually prefer...
95
96	tzset() may also work but in other places I actually want to
97	use local time.
98
99	FFFFFFFFFFFFFFFFFFFFFUUUUUUUUUUUUUUUUUUUU!! */
100	gmtime_r( &res, &utc );
101	utc.tm_isdst = -1;
102	if( utc.tm_hour == tp->tm_hour && utc.tm_min == tp->tm_min )
103	/* Sweet! We're in UTC right now... */
104	return res;
105
106	tres = mktime( &utc );
107	res += res - tres;
108
109	/* Yes, this is a hack. And it will go wrong around DST changes.
110	BUT this is more likely to be threadsafe than messing with
111	environment variables, and possibly more portable... */
112
113	return res;
114	}
115
116	typedef struct htmlentity
117	{
118	char code[7];
119	char is[3];
120	} htmlentity_t;
121
122	static const htmlentity_t ent[] =
123	{
124	{ "lt", "<" },
125	{ "gt", ">" },
126	{ "amp", "&" },
127	{ "apos", "'" },
128	{ "quot", "\"" },
129	{ "aacute", "á" },
130	{ "eacute", "é" },
131	{ "iacute", "é" },
132	{ "oacute", "ó" },
133	{ "uacute", "ú" },
134	{ "agrave", "à" },
135	{ "egrave", "è" },
136	{ "igrave", "ì" },
137	{ "ograve", "ò" },
138	{ "ugrave", "ù" },
139	{ "acirc", "â" },
140	{ "ecirc", "ê" },
141	{ "icirc", "î" },
142	{ "ocirc", "ô" },
143	{ "ucirc", "û" },
144	{ "auml", "ä" },
145	{ "euml", "ë" },
146	{ "iuml", "ï" },
147	{ "ouml", "ö" },
148	{ "uuml", "ü" },
149	{ "nbsp", " " },
150	{ "", "" }
151	};
152
153	void strip_html( char *in )
154	{
155	char *start = in;
156	char out[strlen(in)+1];
157	char s = out, cs;
158	int i, matched;
159
160	memset( out, 0, sizeof( out ) );
161
162	while( *in )
163	{
164	if( in == '<' && ( isalpha( (in+1) ) \|\| *(in+1) == '/' ) )
165	{
166	/* If in points at a < and in+1 points at a letter or a slash, this is probably
167	a HTML-tag. Try to find a closing > and continue there. If the > can't be
168	found, assume that it wasn't a HTML-tag after all. */
169
170	cs = in;
171
172	while( in && in != '>' )
173	in ++;
174
175	if( *in )
176	{
177	if( g_strncasecmp( cs+1, "br", 2) == 0 )
178	*(s++) = '\n';
179	in ++;
180	}
181	else
182	{
183	in = cs;
184	(s++) = (in++);
185	}
186	}
187	else if( *in == '&' )
188	{
189	cs = ++in;
190	while( in && isalpha( in ) )
191	in ++;
192
193	if( *in == ';' ) in ++;
194	matched = 0;
195
196	for( i = 0; *ent[i].code; i ++ )
197	if( g_strncasecmp( ent[i].code, cs, strlen( ent[i].code ) ) == 0 )
198	{
199	int j;
200
201	for( j = 0; ent[i].is[j]; j ++ )
202	*(s++) = ent[i].is[j];
203
204	matched = 1;
205	break;
206	}
207
208	/* None of the entities were matched, so return the string */
209	if( !matched )
210	{
211	in = cs - 1;
212	(s++) = (in++);
213	}
214	}
215	else
216	{
217	(s++) = (in++);
218	}
219	}
220
221	strcpy( start, out );
222	}
223
224	char escape_html( const char html )
225	{
226	const char *c = html;
227	GString *ret;
228	char *str;
229
230	if( html == NULL )
231	return( NULL );
232
233	ret = g_string_new( "" );
234
235	while( *c )
236	{
237	switch( *c )
238	{
239	case '&':
240	ret = g_string_append( ret, "&" );
241	break;
242	case '<':
243	ret = g_string_append( ret, "<" );
244	break;
245	case '>':
246	ret = g_string_append( ret, ">" );
247	break;
248	case '"':
249	ret = g_string_append( ret, """ );
250	break;
251	default:
252	ret = g_string_append_c( ret, *c );
253	}
254	c ++;
255	}
256
257	str = ret->str;
258	g_string_free( ret, FALSE );
259	return( str );
260	}
261
262	/* Decode%20a%20file%20name */
263	void http_decode( char *s )
264	{
265	char *t;
266	int i, j, k;
267
268	t = g_new( char, strlen( s ) + 1 );
269
270	for( i = j = 0; s[i]; i ++, j ++ )
271	{
272	if( s[i] == '%' )
273	{
274	if( sscanf( s + i + 1, "%2x", &k ) )
275	{
276	t[j] = k;
277	i += 2;
278	}
279	else
280	{
281	*t = 0;
282	break;
283	}
284	}
285	else
286	{
287	t[j] = s[i];
288	}
289	}
290	t[j] = 0;
291
292	strcpy( s, t );
293	g_free( t );
294	}
295
296	/* Warning: This one explodes the string. Worst-cases can make the string 3x its original size! */
297	/* This fuction is safe, but make sure you call it safely as well! */
298	void http_encode( char *s )
299	{
300	char *t;
301	int i, j;
302
303	t = g_strdup( s );
304
305	for( i = j = 0; t[i]; i ++, j ++ )
306	{
307	/* Warning: isalnum() is locale-aware, so don't use it here! */
308	if( ( t[i] >= 'A' && t[i] <= 'Z' ) \|\|
309	( t[i] >= 'a' && t[i] <= 'z' ) \|\|
310	( t[i] >= '0' && t[i] <= '9' ) \|\|
311	strchr( "._-~", t[i] ) )
312	{
313	s[j] = t[i];
314	}
315	else
316	{
317	sprintf( s + j, "%%%02X", ((unsigned char*)t)[i] );
318	j += 2;
319	}
320	}
321	s[j] = 0;
322
323	g_free( t );
324	}
325
326	/* Strip newlines from a string. Modifies the string passed to it. */
327	char strip_newlines( char source )
328	{
329	int i;
330
331	for( i = 0; source[i] != '\0'; i ++ )
332	if( source[i] == '\n' \|\| source[i] == '\r' )
333	source[i] = ' ';
334
335	return source;
336	}
337
338	/* Wrap an IPv4 address into IPv6 space. Not thread-safe... */
339	char ipv6_wrap( char src )
340	{
341	static char dst[64];
342	int i;
343
344	for( i = 0; src[i]; i ++ )
345	if( ( src[i] < '0' \|\| src[i] > '9' ) && src[i] != '.' )
346	break;
347
348	/* Hmm, it's not even an IP... */
349	if( src[i] )
350	return src;
351
352	g_snprintf( dst, sizeof( dst ), "::ffff:%s", src );
353
354	return dst;
355	}
356
357	/* Unwrap an IPv4 address into IPv6 space. Thread-safe, because it's very simple. :-) */
358	char ipv6_unwrap( char src )
359	{
360	int i;
361
362	if( g_strncasecmp( src, "::ffff:", 7 ) != 0 )
363	return src;
364
365	for( i = 7; src[i]; i ++ )
366	if( ( src[i] < '0' \|\| src[i] > '9' ) && src[i] != '.' )
367	break;
368
369	/* Hmm, it's not even an IP... */
370	if( src[i] )
371	return src;
372
373	return ( src + 7 );
374	}
375
376	/* Convert from one charset to another.
377
378	from_cs, to_cs: Source and destination charsets
379	src, dst: Source and destination strings
380	size: Size if src. 0 == use strlen(). strlen() is not reliable for UNICODE/UTF16 strings though.
381	maxbuf: Maximum number of bytes to write to dst
382
383	Returns the number of bytes written to maxbuf or -1 on an error.
384	*/
385	signed int do_iconv( char from_cs, char to_cs, char src, char dst, size_t size, size_t maxbuf )
386	{
387	GIConv cd;
388	size_t res;
389	size_t inbytesleft, outbytesleft;
390	char *inbuf = src;
391	char *outbuf = dst;
392
393	cd = g_iconv_open( to_cs, from_cs );
394	if( cd == (GIConv) -1 )
395	return( -1 );
396
397	inbytesleft = size ? size : strlen( src );
398	outbytesleft = maxbuf - 1;
399	res = g_iconv( cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
400	*outbuf = '\0';
401	g_iconv_close( cd );
402
403	if( res == (size_t) -1 )
404	return( -1 );
405	else
406	return( outbuf - dst );
407	}
408
409	/* A pretty reliable random number generator. Tries to use the /dev/random
410	devices first, and falls back to the random number generator from libc
411	when it fails. Opens randomizer devices with O_NONBLOCK to make sure a
412	lack of entropy won't halt BitlBee. */
413	void random_bytes( unsigned char *buf, int count )
414	{
415	#ifndef _WIN32
416	static int use_dev = -1;
417
418	/* Actually this probing code isn't really necessary, is it? */
419	if( use_dev == -1 )
420	{
421	if( access( "/dev/random", R_OK ) == 0 \|\| access( "/dev/urandom", R_OK ) == 0 )
422	use_dev = 1;
423	else
424	{
425	use_dev = 0;
426	srand( ( getpid() << 16 ) ^ time( NULL ) );
427	}
428	}
429
430	if( use_dev )
431	{
432	int fd;
433
434	/* At least on Linux, /dev/random can block if there's not
435	enough entropy. We really don't want that, so if it can't
436	give anything, use /dev/urandom instead. */
437	if( ( fd = open( "/dev/random", O_RDONLY \| O_NONBLOCK ) ) >= 0 )
438	if( read( fd, buf, count ) == count )
439	{
440	close( fd );
441	return;
442	}
443	close( fd );
444
445	/* urandom isn't supposed to block at all, but just to be
446	sure. If it blocks, we'll disable use_dev and use the libc
447	randomizer instead. */
448	if( ( fd = open( "/dev/urandom", O_RDONLY \| O_NONBLOCK ) ) >= 0 )
449	if( read( fd, buf, count ) == count )
450	{
451	close( fd );
452	return;
453	}
454	close( fd );
455
456	/* If /dev/random blocks once, we'll still try to use it
457	again next time. If /dev/urandom also fails for some
458	reason, stick with libc during this session. */
459
460	use_dev = 0;
461	srand( ( getpid() << 16 ) ^ time( NULL ) );
462	}
463
464	if( !use_dev )
465	#endif
466	{
467	int i;
468
469	/* Possibly the LSB of rand() isn't very random on some
470	platforms. Seems okay on at least Linux and OSX though. */
471	for( i = 0; i < count; i ++ )
472	buf[i] = rand() & 0xff;
473	}
474	}
475
476	int is_bool( char *value )
477	{
478	if( *value == 0 )
479	return 0;
480
481	if( ( g_strcasecmp( value, "true" ) == 0 ) \|\| ( g_strcasecmp( value, "yes" ) == 0 ) \|\| ( g_strcasecmp( value, "on" ) == 0 ) )
482	return 1;
483	if( ( g_strcasecmp( value, "false" ) == 0 ) \|\| ( g_strcasecmp( value, "no" ) == 0 ) \|\| ( g_strcasecmp( value, "off" ) == 0 ) )
484	return 1;
485
486	while( *value )
487	if( !isdigit( *value ) )
488	return 0;
489	else
490	value ++;
491
492	return 1;
493	}
494
495	int bool2int( char *value )
496	{
497	int i;
498
499	if( ( g_strcasecmp( value, "true" ) == 0 ) \|\| ( g_strcasecmp( value, "yes" ) == 0 ) \|\| ( g_strcasecmp( value, "on" ) == 0 ) )
500	return 1;
501	if( ( g_strcasecmp( value, "false" ) == 0 ) \|\| ( g_strcasecmp( value, "no" ) == 0 ) \|\| ( g_strcasecmp( value, "off" ) == 0 ) )
502	return 0;
503
504	if( sscanf( value, "%d", &i ) == 1 )
505	return i;
506
507	return 0;
508	}
509
510	struct ns_srv_reply *srv_lookup( char service, char protocol, char domain )
511	{
512	struct ns_srv_reply **replies = NULL;
513	#ifdef HAVE_RESOLV_A
514	struct ns_srv_reply *reply = NULL;
515	char name[1024];
516	unsigned char querybuf[1024];
517	const unsigned char *buf;
518	ns_msg nsh;
519	ns_rr rr;
520	int i, n, len, size;
521
522	g_snprintf( name, sizeof( name ), "_%s._%s.%s", service, protocol, domain );
523
524	if( ( size = res_query( name, ns_c_in, ns_t_srv, querybuf, sizeof( querybuf ) ) ) <= 0 )
525	return NULL;
526
527	if( ns_initparse( querybuf, size, &nsh ) != 0 )
528	return NULL;
529
530	n = 0;
531	while( ns_parserr( &nsh, ns_s_an, n, &rr ) == 0 )
532	{
533	size = ns_rr_rdlen( rr );
534	buf = ns_rr_rdata( rr );
535
536	len = 0;
537	for( i = 6; i < size && buf[i]; i += buf[i] + 1 )
538	len += buf[i] + 1;
539
540	if( i > size )
541	break;
542
543	reply = g_malloc( sizeof( struct ns_srv_reply ) + len );
544	memcpy( reply->name, buf + 7, len );
545
546	for( i = buf[6]; i < len && buf[7+i]; i += buf[7+i] + 1 )
547	reply->name[i] = '.';
548
549	if( i > len )
550	{
551	g_free( reply );
552	break;
553	}
554
555	reply->prio = ( buf[0] << 8 ) \| buf[1];
556	reply->weight = ( buf[2] << 8 ) \| buf[3];
557	reply->port = ( buf[4] << 8 ) \| buf[5];
558
559	n ++;
560	replies = g_renew( struct ns_srv_reply *, replies, n + 1 );
561	replies[n-1] = reply;
562	}
563	if( replies )
564	replies[n] = NULL;
565	#endif
566
567	return replies;
568	}
569
570	void srv_free( struct ns_srv_reply **srv )
571	{
572	int i;
573
574	if( srv == NULL )
575	return;
576
577	for( i = 0; srv[i]; i ++ )
578	g_free( srv[i] );
579	g_free( srv );
580	}
581
582	/* Word wrapping. Yes, I know this isn't UTF-8 clean. I'm willing to take the risk. */
583	char word_wrap( const char msg, int line_len )
584	{
585	GString *ret = g_string_sized_new( strlen( msg ) + 16 );
586
587	while( strlen( msg ) > line_len )
588	{
589	int i;
590
591	/* First try to find out if there's a newline already. Don't
592	want to add more splits than necessary. */
593	for( i = line_len; i > 0 && msg[i] != '\n'; i -- );
594	if( msg[i] == '\n' )
595	{
596	g_string_append_len( ret, msg, i + 1 );
597	msg += i + 1;
598	continue;
599	}
600
601	for( i = line_len; i > 0; i -- )
602	{
603	if( msg[i] == '-' )
604	{
605	g_string_append_len( ret, msg, i + 1 );
606	g_string_append_c( ret, '\n' );
607	msg += i + 1;
608	break;
609	}
610	else if( msg[i] == ' ' )
611	{
612	g_string_append_len( ret, msg, i );
613	g_string_append_c( ret, '\n' );
614	msg += i + 1;
615	break;
616	}
617	}
618	if( i == 0 )
619	{
620	g_string_append_len( ret, msg, line_len );
621	g_string_append_c( ret, '\n' );
622	msg += line_len;
623	}
624	}
625	g_string_append( ret, msg );
626
627	return g_string_free( ret, FALSE );
628	}
629
630	gboolean ssl_sockerr_again( void *ssl )
631	{
632	if( ssl )
633	return ssl_errno == SSL_AGAIN;
634	else
635	return sockerr_again();
636	}
637
638	/* Returns values: -1 == Failure (base64-decoded to something unexpected)
639	0 == Okay
640	1 == Password doesn't match the hash. */
641	int md5_verify_password( char password, char hash )
642	{
643	md5_byte_t *pass_dec = NULL;
644	md5_byte_t pass_md5[16];
645	md5_state_t md5_state;
646	int ret = -1, i;
647
648	if( base64_decode( hash, &pass_dec ) == 21 )
649	{
650	md5_init( &md5_state );
651	md5_append( &md5_state, (md5_byte_t*) password, strlen( password ) );
652	md5_append( &md5_state, (md5_byte_t) pass_dec + 16, 5 ); / Hmmm, salt! */
653	md5_finish( &md5_state, pass_md5 );
654
655	for( i = 0; i < 16; i ++ )
656	{
657	if( pass_dec[i] != pass_md5[i] )
658	{
659	ret = 1;
660	break;
661	}
662	}
663
664	/* If we reached the end of the loop, it was a match! */
665	if( i == 16 )
666	ret = 0;
667	}
668
669	g_free( pass_dec );
670
671	return ret;
672	}
673
674	/* Split commands (root-style, not IRC-style). Handles "quoting of"
675	white\ space in 'various ways'. Returns a NULL-terminated static
676	char** so watch out with nested use! Definitely not thread-safe. */
677	char *split_command_parts( char command )
678	{
679	static char *cmd[IRC_MAX_ARGS+1];
680	char *s, q = 0;
681	int k;
682
683	memset( cmd, 0, sizeof( cmd ) );
684	cmd[0] = command;
685	k = 1;
686	for( s = command; *s && k < IRC_MAX_ARGS; s ++ )
687	if( *s == ' ' && !q )
688	{
689	*s = 0;
690	while( *++s == ' ' );
691	if( s == '"' \|\| s == '\'' )
692	{
693	q = *s;
694	s ++;
695	}
696	if( *s )
697	{
698	cmd[k++] = s;
699	s --;
700	}
701	else
702	{
703	break;
704	}
705	}
706	else if( *s == '\\' && ( ( !q && s[1] ) \|\| ( q && q == s[1] ) ) )
707	{
708	char *cpy;
709
710	for( cpy = s; *cpy; cpy ++ )
711	cpy[0] = cpy[1];
712	}
713	else if( *s == q )
714	{
715	q = *s = 0;
716	}
717
718	/* Full zero-padding for easier argc checking. */
719	while( k <= IRC_MAX_ARGS )
720	cmd[k++] = NULL;
721
722	return cmd;
723	}

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

Download in other formats: