Changeset 6738a67 for lib


Ignore:
Timestamp:
2008-07-16T23:22:52Z (16 years ago)
Author:
Sven Moritz Hallberg <pesco@…>
Branches:
master
Children:
9b55485
Parents:
9730d72 (diff), 6a78c0e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge in latest trunk

Location:
lib
Files:
1 added
15 edited
2 moved

Legend:

Unmodified
Added
Removed

  • lib/Makefile

    r9730d72 r6738a67  
    1010
    1111# [SH] Program variables
    12 objects = arc.o base64.o $(EVENT_HANDLER) http_client.o ini.o md5.o misc.o proxy.o sha1.o $(SSL_CLIENT) url.o
     12objects = arc.o base64.o $(EVENT_HANDLER) http_client.o ini.o md5.o misc.o proxy.o sha1.o $(SSL_CLIENT) url.o xmltree.o
    1313
    1414CFLAGS += -Wall

  • lib/arc.c

    r9730d72 r6738a67  
    131131   
    132132   Both functions return the number of bytes in the result string.
     133   
     134   Note that if you use the pad_to argument, you will need zero-termi-
     135   nation to find back the original string length after decryption. So
     136   it shouldn't be used if your string contains \0s by itself!
    133137*/
    134138
    135 int arc_encode( char *clear, int clear_len, unsigned char **crypt, char *password )
     139int arc_encode( char *clear, int clear_len, unsigned char **crypt, char *password, int pad_to )
    136140{
    137141        struct arc_state *st;
    138142        unsigned char *key;
    139         int key_len, i;
     143        char *padded = NULL;
     144        int key_len, i, padded_len;
    140145       
    141146        key_len = strlen( password ) + ARC_IV_LEN;
    142147        if( clear_len <= 0 )
    143148                clear_len = strlen( clear );
     149       
     150        /* Pad the string to the closest multiple of pad_to. This makes it
     151           impossible to see the exact length of the password. */
     152        if( pad_to > 0 && ( clear_len % pad_to ) > 0 )
     153        {
     154                padded_len = clear_len + pad_to - ( clear_len % pad_to );
     155                padded = g_malloc( padded_len );
     156                memcpy( padded, clear, clear_len );
     157               
     158                /* First a \0 and then random data, so we don't have to do
     159                   anything special when decrypting. */
     160                padded[clear_len] = 0;
     161                random_bytes( (unsigned char*) padded + clear_len + 1, padded_len - clear_len - 1 );
     162               
     163                clear = padded;
     164                clear_len = padded_len;
     165        }
    144166       
    145167        /* Prepare buffers and the key + IV */
    … …  
    161183       
    162184        g_free( st );
     185        g_free( padded );
    163186       
    164187        return clear_len + ARC_IV_LEN;

  • lib/arc.h

    r9730d72 r6738a67  
    3131};
    3232
    33 struct arc_state *arc_keymaker( unsigned char *key, int kl, int cycles );
     33#ifndef G_GNUC_MALLOC
     34#define G_GNUC_MALLOC
     35#endif
     36
     37G_GNUC_MALLOC struct arc_state *arc_keymaker( unsigned char *key, int kl, int cycles );
    3438unsigned char arc_getbyte( struct arc_state *st );
    35 int arc_encode( char *clear, int clear_len, unsigned char **crypt, char *password );
     39int arc_encode( char *clear, int clear_len, unsigned char **crypt, char *password, int pad_to );
    3640int arc_decode( unsigned char *crypt, int crypt_len, char **clear, char *password );

  • lib/base64.c

    r9730d72 r6738a67  
    118118        int i, outlen = 0;
    119119       
    120         for( i = 0; in[i]; i += 4 )
     120        for( i = 0; in[i] && in[i+1] && in[i+2] && in[i+3]; i += 4 )
    121121        {
    122122                int sx;

  • lib/events_glib.c

    r9730d72 r6738a67  
    5151} GaimIOClosure;
    5252
    53 static GMainLoop *loop;
     53static GMainLoop *loop = NULL;
    5454
    5555void b_main_init()
    5656{
    57         loop = g_main_new( FALSE );
     57        if( loop == NULL )
     58                loop = g_main_new( FALSE );
    5859}
    5960

  • lib/misc.c

    r9730d72 r6738a67  
    3333#define BITLBEE_CORE
    3434#include "nogaim.h"
     35#include "base64.h"
    3536#include <stdio.h>
    3637#include <stdlib.h>
    … …  
    5960        strcpy(text, text2);
    6061        g_free(text2);
    61 }
    62 
    63 char *normalize(const char *s)
    64 {
    65         static char buf[BUF_LEN];
    66         char *t, *u;
    67         int x = 0;
    68 
    69         g_return_val_if_fail((s != NULL), NULL);
    70 
    71         u = t = g_strdup(s);
    72 
    73         strcpy(t, s);
    74         g_strdown(t);
    75 
    76         while (*t && (x < BUF_LEN - 1)) {
    77                 if (*t != ' ') {
    78                         buf[x] = *t;
    79                         x++;
    80                 }
    81                 t++;
    82         }
    83         buf[x] = '\0';
    84         g_free(u);
    85         return buf;
    8662}
    8763
    … …  
    408384void random_bytes( unsigned char *buf, int count )
    409385{
     386#ifndef _WIN32
    410387        static int use_dev = -1;
    411388       
    … …  
    457434       
    458435        if( !use_dev )
     436#endif
    459437        {
    460438                int i;
    … …  
    608586                return sockerr_again();
    609587}
     588
     589/* Returns values: -1 == Failure (base64-decoded to something unexpected)
     590                    0 == Okay
     591                    1 == Password doesn't match the hash. */
     592int md5_verify_password( char *password, char *hash )
     593{
     594        md5_byte_t *pass_dec = NULL;
     595        md5_byte_t pass_md5[16];
     596        md5_state_t md5_state;
     597        int ret = -1, i;
     598       
     599        if( base64_decode( hash, &pass_dec ) == 21 )
     600        {
     601                md5_init( &md5_state );
     602                md5_append( &md5_state, (md5_byte_t*) password, strlen( password ) );
     603                md5_append( &md5_state, (md5_byte_t*) pass_dec + 16, 5 ); /* Hmmm, salt! */
     604                md5_finish( &md5_state, pass_md5 );
     605               
     606                for( i = 0; i < 16; i ++ )
     607                {
     608                        if( pass_dec[i] != pass_md5[i] )
     609                        {
     610                                ret = 1;
     611                                break;
     612                        }
     613                }
     614               
     615                /* If we reached the end of the loop, it was a match! */
     616                if( i == 16 )
     617                        ret = 0;
     618        }
     619       
     620        g_free( pass_dec );
     621
     622        return ret;
     623}

  • lib/misc.h

    r9730d72 r6738a67  
    4141G_MODULE_EXPORT char *add_cr( char *text );
    4242G_MODULE_EXPORT char *strip_newlines(char *source);
    43 G_MODULE_EXPORT char *normalize( const char *s );
    4443
    4544G_MODULE_EXPORT time_t get_time( int year, int month, int day, int hour, int min, int sec );
    … …  
    6766G_MODULE_EXPORT gboolean ssl_sockerr_again( void *ssl );
    6867
     68G_MODULE_EXPORT int md5_verify_password( char *password, char *hash );
     69
    6970#endif

  • lib/proxy.c

    r9730d72 r6738a67  
    114114{
    115115        struct sockaddr_in *sin;
     116        struct sockaddr_in me;
    116117        int fd = -1;
    117118
    … …  
    127128
    128129        sock_make_nonblocking(fd);
     130       
     131        if( global.conf->iface_out )
     132        {
     133                me.sin_family = AF_INET;
     134                me.sin_port = 0;
     135                me.sin_addr.s_addr = inet_addr( global.conf->iface_out );
     136               
     137                if( bind( fd, (struct sockaddr *) &me, sizeof( me ) ) != 0 )
     138                        event_debug( "bind( %d, \"%s\" ) failure\n", fd, global.conf->iface_out );
     139        }
    129140       
    130141        event_debug("proxy_connect_none( \"%s\", %d ) = %d\n", host, port, fd);
    … …  
    530541        struct PHB *phb;
    531542       
    532         if (!host || !port || (port == -1) || !func || strlen(host) > 128) {
     543        if (!host || port <= 0 || !func || strlen(host) > 128) {
    533544                return -1;
    534545        }
    … …  
    538549        phb->data = data;
    539550       
    540         if ((proxytype == PROXY_NONE) || strlen(proxyhost) > 0 || !proxyport || (proxyport == -1))
     551        if (proxytype == PROXY_NONE || !proxyhost[0] || proxyport <= 0)
    541552                return proxy_connect_none(host, port, phb);
    542553        else if (proxytype == PROXY_HTTP)

  • lib/ssl_bogus.c

    r9730d72 r6738a67  
    6565        return GAIM_INPUT_READ;
    6666}
     67
     68int ssl_pending( void *conn )
     69{
     70        return 0;
     71}

  • lib/ssl_client.h

    r9730d72 r6738a67  
    6363G_MODULE_EXPORT int ssl_write( void *conn, const char *buf, int len );
    6464
     65/* See ssl_openssl.c for an explanation. */
     66G_MODULE_EXPORT int ssl_pending( void *conn );
     67
    6568/* Abort the SSL connection and disconnect the socket. Do not use close()
    6669   directly, both the SSL library and the peer will be unhappy! */

  • lib/ssl_gnutls.c

    r9730d72 r6738a67  
    216216}
    217217
     218/* See ssl_openssl.c for an explanation. */
     219int ssl_pending( void *conn )
     220{
     221        return 0;
     222}
     223
    218224void ssl_disconnect( void *conn_ )
    219225{

  • lib/ssl_nss.c

    r9730d72 r6738a67  
    175175}
    176176
     177/* See ssl_openssl.c for an explanation. */
     178int ssl_pending( void *conn )
     179{
     180        return 0;
     181}
     182
    177183void ssl_disconnect( void *conn_ )
    178184{

  • lib/ssl_openssl.c

    r9730d72 r6738a67  
    6868       
    6969        conn->fd = proxy_connect( host, port, ssl_connected, conn );
     70        if( conn->fd < 0 )
     71        {
     72                g_free( conn );
     73                return NULL;
     74        }
     75       
    7076        conn->func = func;
    7177        conn->data = data;
    7278        conn->inpa = -1;
    73        
    74         if( conn->fd < 0 )
    75         {
    76                 g_free( conn );
    77                 return NULL;
    78         }
    7979       
    8080        return conn;
    … …  
    236236}
    237237
     238/* Only OpenSSL *really* needs this (and well, maybe NSS). See for more info:
     239   http://www.gnu.org/software/gnutls/manual/gnutls.html#index-gnutls_005frecord_005fcheck_005fpending-209
     240   http://www.openssl.org/docs/ssl/SSL_pending.html
     241   
     242   Required because OpenSSL empties the TCP buffer completely but doesn't
     243   necessarily give us all the unencrypted data.
     244   
     245   Returns 0 if there's nothing left or if we don't have to care (GnuTLS),
     246   1 if there's more data. */
     247int ssl_pending( void *conn )
     248{
     249        return ( ((struct scd*)conn) && ((struct scd*)conn)->established ) ?
     250               SSL_pending( ((struct scd*)conn)->ssl ) > 0 : 0;
     251}
     252
    238253void ssl_disconnect( void *conn_ )
    239254{

  • lib/url.c

    r9730d72 r6738a67  
    2626#include "url.h"
    2727
    28 /* Convert an URL to a url_t structure                                  */
     28/* Convert an URL to a url_t structure */
    2929int url_set( url_t *url, char *set_url )
    3030{
    31         char s[MAX_STRING];
     31        char s[MAX_STRING+1];
    3232        char *i;
    3333       
    34         /* protocol://                                                  */
     34        memset( url, 0, sizeof( url_t ) );
     35        memset( s, 0, sizeof( s ) );
     36       
     37        /* protocol:// */
    3538        if( ( i = strstr( set_url, "://" ) ) == NULL )
    3639        {
    … …  
    4952                        url->proto = PROTO_SOCKS5;
    5053                else
    51                 {
    52                         return( 0 );
    53                 }
     54                        return 0;
     55               
    5456                strncpy( s, i + 3, MAX_STRING );
    5557        }
    5658       
    57         /* Split                                                        */
     59        /* Split */
    5860        if( ( i = strchr( s, '/' ) ) == NULL )
    5961        {
    … …  
    6769        strncpy( url->host, s, MAX_STRING );
    6870       
    69         /* Check for username in host field                             */
     71        /* Check for username in host field */
    7072        if( strrchr( url->host, '@' ) != NULL )
    7173        {
    … …  
    7678                *url->pass = 0;
    7779        }
    78         /* If not: Fill in defaults                                     */
     80        /* If not: Fill in defaults */
    7981        else
    8082        {
    … …  
    8284        }
    8385       
    84         /* Password?                                                    */
     86        /* Password? */
    8587        if( ( i = strchr( url->user, ':' ) ) != NULL )
    8688        {
    … …  
    8890                strcpy( url->pass, i + 1 );
    8991        }
    90         /* Port number?                                                 */
     92        /* Port number? */
    9193        if( ( i = strchr( url->host, ':' ) ) != NULL )
    9294        {

  • lib/url.h

    r9730d72 r6738a67  
    2626#include "bitlbee.h"
    2727
    28 #define PROTO_HTTP              2
    29 #define PROTO_HTTPS             5
    30 #define PROTO_SOCKS4    3
    31 #define PROTO_SOCKS5    4
    32 #define PROTO_DEFAULT   PROTO_HTTP
     28#define PROTO_HTTP      2
     29#define PROTO_HTTPS     5
     30#define PROTO_SOCKS4    3
     31#define PROTO_SOCKS5    4
     32#define PROTO_DEFAULT   PROTO_HTTP
    3333
    3434typedef struct url
    … …  
    3636        int proto;
    3737        int port;
    38         char host[MAX_STRING];
    39         char file[MAX_STRING];
    40         char user[MAX_STRING];
    41         char pass[MAX_STRING];
     38        char host[MAX_STRING+1];
     39        char file[MAX_STRING+1];
     40        char user[MAX_STRING+1];
     41        char pass[MAX_STRING+1];
    4242} url_t;
    4343

  • lib/xmltree.c

    r9730d72 r6738a67  
    111111};
    112112
    113 struct xt_parser *xt_new( gpointer data )
     113struct xt_parser *xt_new( const struct xt_handler_entry *handlers, gpointer data )
    114114{
    115115        struct xt_parser *xt = g_new0( struct xt_parser, 1 );
    116116       
    117117        xt->data = data;
     118        xt->handlers = handlers;
    118119        xt_reset( xt );
    119120       

  • lib/xmltree.h

    r9730d72 r6738a67  
    7171        struct xt_node *cur;
    7272       
    73         struct xt_handler_entry *handlers;
     73        const struct xt_handler_entry *handlers;
    7474        gpointer data;
    7575       
    … …  
    7777};
    7878
    79 struct xt_parser *xt_new( gpointer data );
     79struct xt_parser *xt_new( const struct xt_handler_entry *handlers, gpointer data );
    8080void xt_reset( struct xt_parser *xt );
    8181int xt_feed( struct xt_parser *xt, char *text, int text_len );
Note: See TracChangeset for help on using the changeset viewer.