Changeset dd34575 for lib


Ignore:
Timestamp:
2008-04-02T13:28:23Z (17 years ago)
Author:
Jelmer Vernooij <jelmer@…>
Branches:
master
Children:
6ff51ff, 85d7b85
Parents:
0db75ad (diff), fa75134 (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 trunk.

Location:
lib
Files:
14 edited
2 moved

Legend:

Unmodified
Added
Removed

  • lib/Makefile

    r0db75ad rdd34575  
    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

    r0db75ad rdd34575  
    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

    r0db75ad rdd34575  
    3131};
    3232
    33 struct arc_state *arc_keymaker( unsigned char *key, int kl, int cycles );
     33G_GNUC_MALLOC struct arc_state *arc_keymaker( unsigned char *key, int kl, int cycles );
    3434unsigned char arc_getbyte( struct arc_state *st );
    35 int arc_encode( char *clear, int clear_len, unsigned char **crypt, char *password );
     35int arc_encode( char *clear, int clear_len, unsigned char **crypt, char *password, int pad_to );
    3636int arc_decode( unsigned char *crypt, int crypt_len, char **clear, char *password );

  • lib/base64.c

    r0db75ad rdd34575  
    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

    r0db75ad rdd34575  
    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

    r0db75ad rdd34575  
    3333#define BITLBEE_CORE
    3434#include "nogaim.h"
     35#include "base64.h"
    3536#include <stdio.h>
    3637#include <stdlib.h>
    … …  
    597598                return sockerr_again();
    598599}
     600
     601/* Returns values: -1 == Failure (base64-decoded to something unexpected)
     602                    0 == Okay
     603                    1 == Password doesn't match the hash. */
     604int md5_verify_password( char *password, char *hash )
     605{
     606        md5_byte_t *pass_dec = NULL;
     607        md5_byte_t pass_md5[16];
     608        md5_state_t md5_state;
     609        int ret, i;
     610       
     611        if( base64_decode( hash, &pass_dec ) != 21 )
     612        {
     613                ret = -1;
     614        }
     615        else
     616        {
     617                md5_init( &md5_state );
     618                md5_append( &md5_state, (md5_byte_t*) password, strlen( password ) );
     619                md5_append( &md5_state, (md5_byte_t*) pass_dec + 16, 5 ); /* Hmmm, salt! */
     620                md5_finish( &md5_state, pass_md5 );
     621               
     622                for( i = 0; i < 16; i ++ )
     623                {
     624                        if( pass_dec[i] != pass_md5[i] )
     625                        {
     626                                ret = 1;
     627                                break;
     628                        }
     629                }
     630               
     631                /* If we reached the end of the loop, it was a match! */
     632                if( i == 16 )
     633                        ret = 0;
     634        }
     635       
     636        g_free( pass_dec );
     637
     638        return ret;
     639}

  • lib/misc.h

    r0db75ad rdd34575  
    6767G_MODULE_EXPORT gboolean ssl_sockerr_again( void *ssl );
    6868
     69G_MODULE_EXPORT int md5_verify_password( char *password, char *hash );
     70
    6971#endif

  • lib/proxy.c

    r0db75ad rdd34575  
    530530        struct PHB *phb;
    531531       
    532         if (!host || !port || (port == -1) || !func || strlen(host) > 128) {
     532        if (!host || port <= 0 || !func || strlen(host) > 128) {
    533533                return -1;
    534534        }
    … …  
    538538        phb->data = data;
    539539       
    540         if ((proxytype == PROXY_NONE) || strlen(proxyhost) > 0 || !proxyport || (proxyport == -1))
     540        if (proxytype == PROXY_NONE || !proxyhost[0] || proxyport <= 0)
    541541                return proxy_connect_none(host, port, phb);
    542542        else if (proxytype == PROXY_HTTP)

  • lib/ssl_client.h

    r0db75ad rdd34575  
    6060G_MODULE_EXPORT int ssl_write( void *conn, const char *buf, int len );
    6161
     62/* See ssl_openssl.c for an explanation. */
     63G_MODULE_EXPORT int ssl_pending( void *conn );
     64
    6265/* Abort the SSL connection and disconnect the socket. Do not use close()
    6366   directly, both the SSL library and the peer will be unhappy! */

  • lib/ssl_gnutls.c

    r0db75ad rdd34575  
    211211}
    212212
     213/* See ssl_openssl.c for an explanation. */
     214int ssl_pending( void *conn )
     215{
     216        return 0;
     217}
     218
    213219void ssl_disconnect( void *conn_ )
    214220{

  • lib/ssl_nss.c

    r0db75ad rdd34575  
    169169}
    170170
     171/* See ssl_openssl.c for an explanation. */
     172int ssl_pending( void *conn )
     173{
     174        return 0;
     175}
     176
    171177void ssl_disconnect( void *conn_ )
    172178{

  • lib/ssl_openssl.c

    r0db75ad rdd34575  
    6262       
    6363        conn->fd = proxy_connect( host, port, ssl_connected, conn );
     64        if( conn->fd < 0 )
     65        {
     66                g_free( conn );
     67                return NULL;
     68        }
     69       
    6470        conn->func = func;
    6571        conn->data = data;
    6672        conn->inpa = -1;
    67        
    68         if( conn->fd < 0 )
    69         {
    70                 g_free( conn );
    71                 return NULL;
    72         }
    7373       
    7474        return conn;
    … …  
    231231}
    232232
     233/* Only OpenSSL *really* needs this (and well, maybe NSS). See for more info:
     234   http://www.gnu.org/software/gnutls/manual/gnutls.html#index-gnutls_005frecord_005fcheck_005fpending-209
     235   http://www.openssl.org/docs/ssl/SSL_pending.html
     236   
     237   Required because OpenSSL empties the TCP buffer completely but doesn't
     238   necessarily give us all the unencrypted data.
     239   
     240   Returns 0 if there's nothing left or if we don't have to care (GnuTLS),
     241   1 if there's more data. */
     242int ssl_pending( void *conn )
     243{
     244        return ( ((struct scd*)conn) && ((struct scd*)conn)->established ) ?
     245               SSL_pending( ((struct scd*)conn)->ssl ) > 0 : 0;
     246}
     247
    233248void ssl_disconnect( void *conn_ )
    234249{

  • lib/url.c

    r0db75ad rdd34575  
    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

    r0db75ad rdd34575  
    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

    r0db75ad rdd34575  
    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

    r0db75ad rdd34575  
    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.