Context Navigation

source: lib/misc.c @ de26f3c

Last change on this file since de26f3c was f5da476, checked in by Wilmer van der Gaast <wilmer@…>, at 2011-07-02T16:34:42Z
Fixed use of g_iconv() in do_iconv(). This was done wrong for ages and apparently screwed up charset handling in OSCAR pretty badly.. Found and fixed by dalias (#813). May or may not also fix other bugs.
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[strlen(s)+1];
311	int i, j;
312
313	strcpy( t, s );
314	for( i = j = 0; t[i]; i ++, j ++ )
315	{
316	/* Warning: isalnum() is locale-aware, so don't use it here! */
317	if( ( t[i] >= 'A' && t[i] <= 'Z' ) \|\|
318	( t[i] >= 'a' && t[i] <= 'z' ) \|\|
319	( t[i] >= '0' && t[i] <= '9' ) \|\|
320	strchr( "._-~", t[i] ) )
321	{
322	s[j] = t[i];
323	}
324	else
325	{
326	sprintf( s + j, "%%%02X", ((unsigned char*)t)[i] );
327	j += 2;
328	}
329	}
330	s[j] = 0;
331	}
332
333	/* Strip newlines from a string. Modifies the string passed to it. */
334	char strip_newlines( char source )
335	{
336	int i;
337
338	for( i = 0; source[i] != '\0'; i ++ )
339	if( source[i] == '\n' \|\| source[i] == '\r' )
340	source[i] = ' ';
341
342	return source;
343	}
344
345	/* Wrap an IPv4 address into IPv6 space. Not thread-safe... */
346	char ipv6_wrap( char src )
347	{
348	static char dst[64];
349	int i;
350
351	for( i = 0; src[i]; i ++ )
352	if( ( src[i] < '0' \|\| src[i] > '9' ) && src[i] != '.' )
353	break;
354
355	/* Hmm, it's not even an IP... */
356	if( src[i] )
357	return src;
358
359	g_snprintf( dst, sizeof( dst ), "::ffff:%s", src );
360
361	return dst;
362	}
363
364	/* Unwrap an IPv4 address into IPv6 space. Thread-safe, because it's very simple. :-) */
365	char ipv6_unwrap( char src )
366	{
367	int i;
368
369	if( g_strncasecmp( src, "::ffff:", 7 ) != 0 )
370	return src;
371
372	for( i = 7; src[i]; i ++ )
373	if( ( src[i] < '0' \|\| src[i] > '9' ) && src[i] != '.' )
374	break;
375
376	/* Hmm, it's not even an IP... */
377	if( src[i] )
378	return src;
379
380	return ( src + 7 );
381	}
382
383	/* Convert from one charset to another.
384
385	from_cs, to_cs: Source and destination charsets
386	src, dst: Source and destination strings
387	size: Size if src. 0 == use strlen(). strlen() is not reliable for UNICODE/UTF16 strings though.
388	maxbuf: Maximum number of bytes to write to dst
389
390	Returns the number of bytes written to maxbuf or -1 on an error.
391	*/
392	signed int do_iconv( char from_cs, char to_cs, char src, char dst, size_t size, size_t maxbuf )
393	{
394	GIConv cd;
395	size_t res;
396	size_t inbytesleft, outbytesleft;
397	char *inbuf = src;
398	char *outbuf = dst;
399
400	cd = g_iconv_open( to_cs, from_cs );
401	if( cd == (GIConv) -1 )
402	return -1;
403
404	inbytesleft = size ? size : strlen( src );
405	outbytesleft = maxbuf - 1;
406	res = g_iconv( cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
407	*outbuf = '\0';
408	g_iconv_close( cd );
409
410	if( res != 0 )
411	return -1;
412	else
413	return outbuf - dst;
414	}
415
416	/* A pretty reliable random number generator. Tries to use the /dev/random
417	devices first, and falls back to the random number generator from libc
418	when it fails. Opens randomizer devices with O_NONBLOCK to make sure a
419	lack of entropy won't halt BitlBee. */
420	void random_bytes( unsigned char *buf, int count )
421	{
422	#ifndef _WIN32
423	static int use_dev = -1;
424
425	/* Actually this probing code isn't really necessary, is it? */
426	if( use_dev == -1 )
427	{
428	if( access( "/dev/random", R_OK ) == 0 \|\| access( "/dev/urandom", R_OK ) == 0 )
429	use_dev = 1;
430	else
431	{
432	use_dev = 0;
433	srand( ( getpid() << 16 ) ^ time( NULL ) );
434	}
435	}
436
437	if( use_dev )
438	{
439	int fd;
440
441	/* At least on Linux, /dev/random can block if there's not
442	enough entropy. We really don't want that, so if it can't
443	give anything, use /dev/urandom instead. */
444	if( ( fd = open( "/dev/random", O_RDONLY \| O_NONBLOCK ) ) >= 0 )
445	if( read( fd, buf, count ) == count )
446	{
447	close( fd );
448	return;
449	}
450	close( fd );
451
452	/* urandom isn't supposed to block at all, but just to be
453	sure. If it blocks, we'll disable use_dev and use the libc
454	randomizer instead. */
455	if( ( fd = open( "/dev/urandom", O_RDONLY \| O_NONBLOCK ) ) >= 0 )
456	if( read( fd, buf, count ) == count )
457	{
458	close( fd );
459	return;
460	}
461	close( fd );
462
463	/* If /dev/random blocks once, we'll still try to use it
464	again next time. If /dev/urandom also fails for some
465	reason, stick with libc during this session. */
466
467	use_dev = 0;
468	srand( ( getpid() << 16 ) ^ time( NULL ) );
469	}
470
471	if( !use_dev )
472	#endif
473	{
474	int i;
475
476	/* Possibly the LSB of rand() isn't very random on some
477	platforms. Seems okay on at least Linux and OSX though. */
478	for( i = 0; i < count; i ++ )
479	buf[i] = rand() & 0xff;
480	}
481	}
482
483	int is_bool( char *value )
484	{
485	if( *value == 0 )
486	return 0;
487
488	if( ( g_strcasecmp( value, "true" ) == 0 ) \|\| ( g_strcasecmp( value, "yes" ) == 0 ) \|\| ( g_strcasecmp( value, "on" ) == 0 ) )
489	return 1;
490	if( ( g_strcasecmp( value, "false" ) == 0 ) \|\| ( g_strcasecmp( value, "no" ) == 0 ) \|\| ( g_strcasecmp( value, "off" ) == 0 ) )
491	return 1;
492
493	while( *value )
494	if( !isdigit( *value ) )
495	return 0;
496	else
497	value ++;
498
499	return 1;
500	}
501
502	int bool2int( char *value )
503	{
504	int i;
505
506	if( ( g_strcasecmp( value, "true" ) == 0 ) \|\| ( g_strcasecmp( value, "yes" ) == 0 ) \|\| ( g_strcasecmp( value, "on" ) == 0 ) )
507	return 1;
508	if( ( g_strcasecmp( value, "false" ) == 0 ) \|\| ( g_strcasecmp( value, "no" ) == 0 ) \|\| ( g_strcasecmp( value, "off" ) == 0 ) )
509	return 0;
510
511	if( sscanf( value, "%d", &i ) == 1 )
512	return i;
513
514	return 0;
515	}
516
517	struct ns_srv_reply *srv_lookup( char service, char protocol, char domain )
518	{
519	struct ns_srv_reply **replies = NULL;
520	#ifdef HAVE_RESOLV_A
521	struct ns_srv_reply *reply = NULL;
522	char name[1024];
523	unsigned char querybuf[1024];
524	const unsigned char *buf;
525	ns_msg nsh;
526	ns_rr rr;
527	int i, n, len, size;
528
529	g_snprintf( name, sizeof( name ), "_%s._%s.%s", service, protocol, domain );
530
531	if( ( size = res_query( name, ns_c_in, ns_t_srv, querybuf, sizeof( querybuf ) ) ) <= 0 )
532	return NULL;
533
534	if( ns_initparse( querybuf, size, &nsh ) != 0 )
535	return NULL;
536
537	n = 0;
538	while( ns_parserr( &nsh, ns_s_an, n, &rr ) == 0 )
539	{
540	size = ns_rr_rdlen( rr );
541	buf = ns_rr_rdata( rr );
542
543	len = 0;
544	for( i = 6; i < size && buf[i]; i += buf[i] + 1 )
545	len += buf[i] + 1;
546
547	if( i > size )
548	break;
549
550	reply = g_malloc( sizeof( struct ns_srv_reply ) + len );
551	memcpy( reply->name, buf + 7, len );
552
553	for( i = buf[6]; i < len && buf[7+i]; i += buf[7+i] + 1 )
554	reply->name[i] = '.';
555
556	if( i > len )
557	{
558	g_free( reply );
559	break;
560	}
561
562	reply->prio = ( buf[0] << 8 ) \| buf[1];
563	reply->weight = ( buf[2] << 8 ) \| buf[3];
564	reply->port = ( buf[4] << 8 ) \| buf[5];
565
566	n ++;
567	replies = g_renew( struct ns_srv_reply *, replies, n + 1 );
568	replies[n-1] = reply;
569	}
570	if( replies )
571	replies[n] = NULL;
572	#endif
573
574	return replies;
575	}
576
577	void srv_free( struct ns_srv_reply **srv )
578	{
579	int i;
580
581	if( srv == NULL )
582	return;
583
584	for( i = 0; srv[i]; i ++ )
585	g_free( srv[i] );
586	g_free( srv );
587	}
588
589	/* Word wrapping. Yes, I know this isn't UTF-8 clean. I'm willing to take the risk. */
590	char word_wrap( const char msg, int line_len )
591	{
592	GString *ret = g_string_sized_new( strlen( msg ) + 16 );
593
594	while( strlen( msg ) > line_len )
595	{
596	int i;
597
598	/* First try to find out if there's a newline already. Don't
599	want to add more splits than necessary. */
600	for( i = line_len; i > 0 && msg[i] != '\n'; i -- );
601	if( msg[i] == '\n' )
602	{
603	g_string_append_len( ret, msg, i + 1 );
604	msg += i + 1;
605	continue;
606	}
607
608	for( i = line_len; i > 0; i -- )
609	{
610	if( msg[i] == '-' )
611	{
612	g_string_append_len( ret, msg, i + 1 );
613	g_string_append_c( ret, '\n' );
614	msg += i + 1;
615	break;
616	}
617	else if( msg[i] == ' ' )
618	{
619	g_string_append_len( ret, msg, i );
620	g_string_append_c( ret, '\n' );
621	msg += i + 1;
622	break;
623	}
624	}
625	if( i == 0 )
626	{
627	g_string_append_len( ret, msg, line_len );
628	g_string_append_c( ret, '\n' );
629	msg += line_len;
630	}
631	}
632	g_string_append( ret, msg );
633
634	return g_string_free( ret, FALSE );
635	}
636
637	gboolean ssl_sockerr_again( void *ssl )
638	{
639	if( ssl )
640	return ssl_errno == SSL_AGAIN;
641	else
642	return sockerr_again();
643	}
644
645	/* Returns values: -1 == Failure (base64-decoded to something unexpected)
646	0 == Okay
647	1 == Password doesn't match the hash. */
648	int md5_verify_password( char password, char hash )
649	{
650	md5_byte_t *pass_dec = NULL;
651	md5_byte_t pass_md5[16];
652	md5_state_t md5_state;
653	int ret = -1, i;
654
655	if( base64_decode( hash, &pass_dec ) == 21 )
656	{
657	md5_init( &md5_state );
658	md5_append( &md5_state, (md5_byte_t*) password, strlen( password ) );
659	md5_append( &md5_state, (md5_byte_t) pass_dec + 16, 5 ); / Hmmm, salt! */
660	md5_finish( &md5_state, pass_md5 );
661
662	for( i = 0; i < 16; i ++ )
663	{
664	if( pass_dec[i] != pass_md5[i] )
665	{
666	ret = 1;
667	break;
668	}
669	}
670
671	/* If we reached the end of the loop, it was a match! */
672	if( i == 16 )
673	ret = 0;
674	}
675
676	g_free( pass_dec );
677
678	return ret;
679	}
680
681	/* Split commands (root-style, not IRC-style). Handles "quoting of"
682	white\ space in 'various ways'. Returns a NULL-terminated static
683	char** so watch out with nested use! Definitely not thread-safe. */
684	char *split_command_parts( char command )
685	{
686	static char *cmd[IRC_MAX_ARGS+1];
687	char *s, q = 0;
688	int k;
689
690	memset( cmd, 0, sizeof( cmd ) );
691	cmd[0] = command;
692	k = 1;
693	for( s = command; *s && k < IRC_MAX_ARGS; s ++ )
694	if( *s == ' ' && !q )
695	{
696	*s = 0;
697	while( *++s == ' ' );
698	if( s == '"' \|\| s == '\'' )
699	{
700	q = *s;
701	s ++;
702	}
703	if( *s )
704	{
705	cmd[k++] = s;
706	s --;
707	}
708	else
709	{
710	break;
711	}
712	}
713	else if( *s == '\\' && ( ( !q && s[1] ) \|\| ( q && q == s[1] ) ) )
714	{
715	char *cpy;
716
717	for( cpy = s; *cpy; cpy ++ )
718	cpy[0] = cpy[1];
719	}
720	else if( *s == q )
721	{
722	q = *s = 0;
723	}
724
725	/* Full zero-padding for easier argc checking. */
726	while( k <= IRC_MAX_ARGS )
727	cmd[k++] = NULL;
728
729	return cmd;
730	}

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

Download in other formats: