source: lib/misc.c @ 424e663

Last change on this file since 424e663 was 424e663, checked in by Wilmer van der Gaast <wilmer@…>, at 2008-06-22T09:32:46Z

Partial fix for #419: Moved normalize() and some other stuff to OSCAR
becuase it's the only place where it's used, and using this to strip
spaces from all screennames before sending them to BitlBee.

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