Context Navigation

source: lib/misc.c @ 858ea01

Last change on this file since 858ea01 was be999a5, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-08-23T23:12:24Z
First step in this merge. Mostly a bzr merge and then a cleanup of conflicts and parts I want to/have to redo (because of ui-fix).
Property mode set to `100644`
File size: 15.8 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	int taglen;
160
161	memset( out, 0, sizeof( out ) );
162
163	while( *in )
164	{
165	if( in == '<' && ( isalpha( (in+1) ) \|\| *(in+1) == '/' ) )
166	{
167	/* If in points at a < and in+1 points at a letter or a slash, this is probably
168	a HTML-tag. Try to find a closing > and continue there. If the > can't be
169	found, assume that it wasn't a HTML-tag after all. */
170
171	cs = in;
172
173	while( in && in != '>' )
174	in ++;
175
176	taglen = in - cs - 1; /* not <0 because the above loop runs at least once */
177	if( *in )
178	{
179	if( g_strncasecmp( cs+1, "b", taglen) == 0 )
180	*(s++) = '\x02';
181	else if( g_strncasecmp( cs+1, "/b", taglen) == 0 )
182	*(s++) = '\x02';
183	else if( g_strncasecmp( cs+1, "i", taglen) == 0 )
184	*(s++) = '\x1f';
185	else if( g_strncasecmp( cs+1, "/i", taglen) == 0 )
186	*(s++) = '\x1f';
187	else if( g_strncasecmp( cs+1, "br", taglen) == 0 )
188	*(s++) = '\n';
189	in ++;
190	}
191	else
192	{
193	in = cs;
194	(s++) = (in++);
195	}
196	}
197	else if( *in == '&' )
198	{
199	cs = ++in;
200	while( in && isalpha( in ) )
201	in ++;
202
203	if( *in == ';' ) in ++;
204	matched = 0;
205
206	for( i = 0; *ent[i].code; i ++ )
207	if( g_strncasecmp( ent[i].code, cs, strlen( ent[i].code ) ) == 0 )
208	{
209	int j;
210
211	for( j = 0; ent[i].is[j]; j ++ )
212	*(s++) = ent[i].is[j];
213
214	matched = 1;
215	break;
216	}
217
218	/* None of the entities were matched, so return the string */
219	if( !matched )
220	{
221	in = cs - 1;
222	(s++) = (in++);
223	}
224	}
225	else
226	{
227	(s++) = (in++);
228	}
229	}
230
231	strcpy( start, out );
232	}
233
234	char escape_html( const char html )
235	{
236	const char *c = html;
237	GString *ret;
238	char *str;
239
240	if( html == NULL )
241	return( NULL );
242
243	ret = g_string_new( "" );
244
245	while( *c )
246	{
247	switch( *c )
248	{
249	case '&':
250	ret = g_string_append( ret, "&" );
251	break;
252	case '<':
253	ret = g_string_append( ret, "<" );
254	break;
255	case '>':
256	ret = g_string_append( ret, ">" );
257	break;
258	case '"':
259	ret = g_string_append( ret, """ );
260	break;
261	default:
262	ret = g_string_append_c( ret, *c );
263	}
264	c ++;
265	}
266
267	str = ret->str;
268	g_string_free( ret, FALSE );
269	return( str );
270	}
271
272	/* Decode%20a%20file%20name */
273	void http_decode( char *s )
274	{
275	char *t;
276	int i, j, k;
277
278	t = g_new( char, strlen( s ) + 1 );
279
280	for( i = j = 0; s[i]; i ++, j ++ )
281	{
282	if( s[i] == '%' )
283	{
284	if( sscanf( s + i + 1, "%2x", &k ) )
285	{
286	t[j] = k;
287	i += 2;
288	}
289	else
290	{
291	*t = 0;
292	break;
293	}
294	}
295	else
296	{
297	t[j] = s[i];
298	}
299	}
300	t[j] = 0;
301
302	strcpy( s, t );
303	g_free( t );
304	}
305
306	/* Warning: This one explodes the string. Worst-cases can make the string 3x its original size! */
307	/* This fuction is safe, but make sure you call it safely as well! */
308	void http_encode( char *s )
309	{
310	char *t;
311	int i, j;
312
313	t = g_strdup( s );
314
315	for( i = j = 0; t[i]; i ++, j ++ )
316	{
317	/* Warning: isalnum() is locale-aware, so don't use it here! */
318	if( ( t[i] >= 'A' && t[i] <= 'Z' ) \|\|
319	( t[i] >= 'a' && t[i] <= 'z' ) \|\|
320	( t[i] >= '0' && t[i] <= '9' ) \|\|
321	strchr( "._-~", t[i] ) )
322	{
323	s[j] = t[i];
324	}
325	else
326	{
327	sprintf( s + j, "%%%02X", ((unsigned char*)t)[i] );
328	j += 2;
329	}
330	}
331	s[j] = 0;
332
333	g_free( t );
334	}
335
336	/* Strip newlines from a string. Modifies the string passed to it. */
337	char strip_newlines( char source )
338	{
339	int i;
340
341	for( i = 0; source[i] != '\0'; i ++ )
342	if( source[i] == '\n' \|\| source[i] == '\r' )
343	source[i] = ' ';
344
345	return source;
346	}
347
348	/* Wrap an IPv4 address into IPv6 space. Not thread-safe... */
349	char ipv6_wrap( char src )
350	{
351	static char dst[64];
352	int i;
353
354	for( i = 0; src[i]; i ++ )
355	if( ( src[i] < '0' \|\| src[i] > '9' ) && src[i] != '.' )
356	break;
357
358	/* Hmm, it's not even an IP... */
359	if( src[i] )
360	return src;
361
362	g_snprintf( dst, sizeof( dst ), "::ffff:%s", src );
363
364	return dst;
365	}
366
367	/* Unwrap an IPv4 address into IPv6 space. Thread-safe, because it's very simple. :-) */
368	char ipv6_unwrap( char src )
369	{
370	int i;
371
372	if( g_strncasecmp( src, "::ffff:", 7 ) != 0 )
373	return src;
374
375	for( i = 7; src[i]; i ++ )
376	if( ( src[i] < '0' \|\| src[i] > '9' ) && src[i] != '.' )
377	break;
378
379	/* Hmm, it's not even an IP... */
380	if( src[i] )
381	return src;
382
383	return ( src + 7 );
384	}
385
386	/* Convert from one charset to another.
387
388	from_cs, to_cs: Source and destination charsets
389	src, dst: Source and destination strings
390	size: Size if src. 0 == use strlen(). strlen() is not reliable for UNICODE/UTF16 strings though.
391	maxbuf: Maximum number of bytes to write to dst
392
393	Returns the number of bytes written to maxbuf or -1 on an error.
394	*/
395	signed int do_iconv( char from_cs, char to_cs, char src, char dst, size_t size, size_t maxbuf )
396	{
397	GIConv cd;
398	size_t res;
399	size_t inbytesleft, outbytesleft;
400	char *inbuf = src;
401	char *outbuf = dst;
402
403	cd = g_iconv_open( to_cs, from_cs );
404	if( cd == (GIConv) -1 )
405	return( -1 );
406
407	inbytesleft = size ? size : strlen( src );
408	outbytesleft = maxbuf - 1;
409	res = g_iconv( cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
410	*outbuf = '\0';
411	g_iconv_close( cd );
412
413	if( res == (size_t) -1 )
414	return( -1 );
415	else
416	return( outbuf - dst );
417	}
418
419	/* A pretty reliable random number generator. Tries to use the /dev/random
420	devices first, and falls back to the random number generator from libc
421	when it fails. Opens randomizer devices with O_NONBLOCK to make sure a
422	lack of entropy won't halt BitlBee. */
423	void random_bytes( unsigned char *buf, int count )
424	{
425	#ifndef _WIN32
426	static int use_dev = -1;
427
428	/* Actually this probing code isn't really necessary, is it? */
429	if( use_dev == -1 )
430	{
431	if( access( "/dev/random", R_OK ) == 0 \|\| access( "/dev/urandom", R_OK ) == 0 )
432	use_dev = 1;
433	else
434	{
435	use_dev = 0;
436	srand( ( getpid() << 16 ) ^ time( NULL ) );
437	}
438	}
439
440	if( use_dev )
441	{
442	int fd;
443
444	/* At least on Linux, /dev/random can block if there's not
445	enough entropy. We really don't want that, so if it can't
446	give anything, use /dev/urandom instead. */
447	if( ( fd = open( "/dev/random", O_RDONLY \| O_NONBLOCK ) ) >= 0 )
448	if( read( fd, buf, count ) == count )
449	{
450	close( fd );
451	return;
452	}
453	close( fd );
454
455	/* urandom isn't supposed to block at all, but just to be
456	sure. If it blocks, we'll disable use_dev and use the libc
457	randomizer instead. */
458	if( ( fd = open( "/dev/urandom", O_RDONLY \| O_NONBLOCK ) ) >= 0 )
459	if( read( fd, buf, count ) == count )
460	{
461	close( fd );
462	return;
463	}
464	close( fd );
465
466	/* If /dev/random blocks once, we'll still try to use it
467	again next time. If /dev/urandom also fails for some
468	reason, stick with libc during this session. */
469
470	use_dev = 0;
471	srand( ( getpid() << 16 ) ^ time( NULL ) );
472	}
473
474	if( !use_dev )
475	#endif
476	{
477	int i;
478
479	/* Possibly the LSB of rand() isn't very random on some
480	platforms. Seems okay on at least Linux and OSX though. */
481	for( i = 0; i < count; i ++ )
482	buf[i] = rand() & 0xff;
483	}
484	}
485
486	int is_bool( char *value )
487	{
488	if( *value == 0 )
489	return 0;
490
491	if( ( g_strcasecmp( value, "true" ) == 0 ) \|\| ( g_strcasecmp( value, "yes" ) == 0 ) \|\| ( g_strcasecmp( value, "on" ) == 0 ) )
492	return 1;
493	if( ( g_strcasecmp( value, "false" ) == 0 ) \|\| ( g_strcasecmp( value, "no" ) == 0 ) \|\| ( g_strcasecmp( value, "off" ) == 0 ) )
494	return 1;
495
496	while( *value )
497	if( !isdigit( *value ) )
498	return 0;
499	else
500	value ++;
501
502	return 1;
503	}
504
505	int bool2int( char *value )
506	{
507	int i;
508
509	if( ( g_strcasecmp( value, "true" ) == 0 ) \|\| ( g_strcasecmp( value, "yes" ) == 0 ) \|\| ( g_strcasecmp( value, "on" ) == 0 ) )
510	return 1;
511	if( ( g_strcasecmp( value, "false" ) == 0 ) \|\| ( g_strcasecmp( value, "no" ) == 0 ) \|\| ( g_strcasecmp( value, "off" ) == 0 ) )
512	return 0;
513
514	if( sscanf( value, "%d", &i ) == 1 )
515	return i;
516
517	return 0;
518	}
519
520	struct ns_srv_reply *srv_lookup( char service, char protocol, char domain )
521	{
522	struct ns_srv_reply **replies = NULL;
523	#ifdef HAVE_RESOLV_A
524	struct ns_srv_reply *reply = NULL;
525	char name[1024];
526	unsigned char querybuf[1024];
527	const unsigned char *buf;
528	ns_msg nsh;
529	ns_rr rr;
530	int i, n, len, size;
531
532	g_snprintf( name, sizeof( name ), "_%s._%s.%s", service, protocol, domain );
533
534	if( ( size = res_query( name, ns_c_in, ns_t_srv, querybuf, sizeof( querybuf ) ) ) <= 0 )
535	return NULL;
536
537	if( ns_initparse( querybuf, size, &nsh ) != 0 )
538	return NULL;
539
540	n = 0;
541	while( ns_parserr( &nsh, ns_s_an, n, &rr ) == 0 )
542	{
543	size = ns_rr_rdlen( rr );
544	buf = ns_rr_rdata( rr );
545
546	len = 0;
547	for( i = 6; i < size && buf[i]; i += buf[i] + 1 )
548	len += buf[i] + 1;
549
550	if( i > size )
551	break;
552
553	reply = g_malloc( sizeof( struct ns_srv_reply ) + len );
554	memcpy( reply->name, buf + 7, len );
555
556	for( i = buf[6]; i < len && buf[7+i]; i += buf[7+i] + 1 )
557	reply->name[i] = '.';
558
559	if( i > len )
560	{
561	g_free( reply );
562	break;
563	}
564
565	reply->prio = ( buf[0] << 8 ) \| buf[1];
566	reply->weight = ( buf[2] << 8 ) \| buf[3];
567	reply->port = ( buf[4] << 8 ) \| buf[5];
568
569	n ++;
570	replies = g_renew( struct ns_srv_reply *, replies, n + 1 );
571	replies[n-1] = reply;
572	}
573	if( replies )
574	replies[n] = NULL;
575	#endif
576
577	return replies;
578	}
579
580	void srv_free( struct ns_srv_reply **srv )
581	{
582	int i;
583
584	if( srv == NULL )
585	return;
586
587	for( i = 0; srv[i]; i ++ )
588	g_free( srv[i] );
589	g_free( srv );
590	}
591
592	/* Word wrapping. Yes, I know this isn't UTF-8 clean. I'm willing to take the risk. */
593	char word_wrap( const char msg, int line_len )
594	{
595	GString *ret = g_string_sized_new( strlen( msg ) + 16 );
596
597	while( strlen( msg ) > line_len )
598	{
599	int i;
600
601	/* First try to find out if there's a newline already. Don't
602	want to add more splits than necessary. */
603	for( i = line_len; i > 0 && msg[i] != '\n'; i -- );
604	if( msg[i] == '\n' )
605	{
606	g_string_append_len( ret, msg, i + 1 );
607	msg += i + 1;
608	continue;
609	}
610
611	for( i = line_len; i > 0; i -- )
612	{
613	if( msg[i] == '-' )
614	{
615	g_string_append_len( ret, msg, i + 1 );
616	g_string_append_c( ret, '\n' );
617	msg += i + 1;
618	break;
619	}
620	else if( msg[i] == ' ' )
621	{
622	g_string_append_len( ret, msg, i );
623	g_string_append_c( ret, '\n' );
624	msg += i + 1;
625	break;
626	}
627	}
628	if( i == 0 )
629	{
630	g_string_append_len( ret, msg, line_len );
631	g_string_append_c( ret, '\n' );
632	msg += line_len;
633	}
634	}
635	g_string_append( ret, msg );
636
637	return g_string_free( ret, FALSE );
638	}
639
640	gboolean ssl_sockerr_again( void *ssl )
641	{
642	if( ssl )
643	return ssl_errno == SSL_AGAIN;
644	else
645	return sockerr_again();
646	}
647
648	/* Returns values: -1 == Failure (base64-decoded to something unexpected)
649	0 == Okay
650	1 == Password doesn't match the hash. */
651	int md5_verify_password( char password, char hash )
652	{
653	md5_byte_t *pass_dec = NULL;
654	md5_byte_t pass_md5[16];
655	md5_state_t md5_state;
656	int ret = -1, i;
657
658	if( base64_decode( hash, &pass_dec ) == 21 )
659	{
660	md5_init( &md5_state );
661	md5_append( &md5_state, (md5_byte_t*) password, strlen( password ) );
662	md5_append( &md5_state, (md5_byte_t) pass_dec + 16, 5 ); / Hmmm, salt! */
663	md5_finish( &md5_state, pass_md5 );
664
665	for( i = 0; i < 16; i ++ )
666	{
667	if( pass_dec[i] != pass_md5[i] )
668	{
669	ret = 1;
670	break;
671	}
672	}
673
674	/* If we reached the end of the loop, it was a match! */
675	if( i == 16 )
676	ret = 0;
677	}
678
679	g_free( pass_dec );
680
681	return ret;
682	}
683
684	/* Split commands (root-style, not IRC-style). Handles "quoting of"
685	white\ space in 'various ways'. Returns a NULL-terminated static
686	char** so watch out with nested use! Definitely not thread-safe. */
687	char *split_command_parts( char command )
688	{
689	static char *cmd[IRC_MAX_ARGS+1];
690	char *s, q = 0;
691	int k;
692
693	memset( cmd, 0, sizeof( cmd ) );
694	cmd[0] = command;
695	k = 1;
696	for( s = command; *s && k < IRC_MAX_ARGS; s ++ )
697	if( *s == ' ' && !q )
698	{
699	*s = 0;
700	while( *++s == ' ' );
701	if( s == '"' \|\| s == '\'' )
702	{
703	q = *s;
704	s ++;
705	}
706	if( *s )
707	{
708	cmd[k++] = s;
709	s --;
710	}
711	else
712	{
713	break;
714	}
715	}
716	else if( *s == '\\' && ( ( !q && s[1] ) \|\| ( q && q == s[1] ) ) )
717	{
718	char *cpy;
719
720	for( cpy = s; *cpy; cpy ++ )
721	cpy[0] = cpy[1];
722	}
723	else if( *s == q )
724	{
725	q = *s = 0;
726	}
727
728	/* Full zero-padding for easier argc checking. */
729	while( k <= IRC_MAX_ARGS )
730	cmd[k++] = NULL;
731
732	return cmd;
733	}

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

Download in other formats: