Changes in / [783e9b7:c4a1036]

Files:

• .bzrignore (modified) (1 diff)
• Makefile (modified) (1 diff)
• bitlbee.c (modified) (6 diffs)
• bitlbee.h (modified) (1 diff)
• configure (modified) (2 diffs)
• doc/BUILD.win32 (added)
• ipc.c (modified) (3 diffs)
• lib/misc.c (modified) (1 diff)
• protocols/nogaim.h (modified) (1 diff)
• protocols/oscar/AUTHORS (modified) (1 diff)
• protocols/ssl_sspi.c (added)
• protocols/yahoo/libyahoo2.c (modified) (1 diff)
• protocols/yahoo/yahoo_httplib.c (modified) (1 diff)
• sock.h (modified) (1 diff)
• storage_text.c (modified) (1 diff)
• unix.c (modified) (3 diffs)
• utils/cross-compile.win32 (added)
• win32.c (added)
• win32.mk (added)

.bzrignore

@@ -2 +2 @@
 config.h
 bitlbee
+Debug
+Debugx
+deps
+admin/Debug
+admin/admin.plg
+bitlbee.plg
+*.plg
+*.aps
+*.clw
 user-guide.txt
 user-guide.html

Makefile

@@ -10 +10 @@
 
 # Program variables
-objects = account.o bitlbee.o conf.o crypting.o help.o ipc.o irc.o irc_commands.o log.o nick.o query.o root_commands.o set.o storage.o $(STORAGE_OBJS) unix.o user.o
+objects = account.o bitlbee.o crypting.o help.o ipc.o irc.o irc_commands.o nick.o query.o root_commands.o set.o storage.o $(STORAGE_OBJS) user.o
 headers = account.h bitlbee.h commands.h conf.h config.h crypting.h help.h ipc.h irc.h log.h nick.h query.h set.h sock.h storage.h user.h lib/events.h lib/http_client.h lib/ini.h lib/md5.h lib/misc.h lib/proxy.h lib/sha1.h lib/ssl_client.h lib/url.h protocols/nogaim.h
 subdirs = lib protocols
+
+ifeq ($(ARCH),Windows)
+objects += win32.o
+else
+objects += unix.o conf.o log.o
+endif
 
 # Expansion of variables

bitlbee.c

@@ -123 +123 @@
                 ipc_master_listen_socket();
         
+#ifndef _WIN32
         if( ( fp = fopen( global.conf->pidfile, "w" ) ) )
         {
@@ -132 +133 @@
                 log_message( LOGLVL_WARNING, "Warning: Couldn't write PID to `%s'", global.conf->pidfile );
         }
+#endif
         
         return( 0 );
@@ -140 +142 @@
         if( !irc_new( 0 ) )
                 return( 1 );
-        
-        log_link( LOGLVL_ERROR, LOGOUTPUT_IRC );
-        log_link( LOGLVL_WARNING, LOGOUTPUT_IRC );
         
         return( 0 );
@@ -254 +253 @@
         struct sockaddr_in conn_info;
         int new_socket = accept( global.listen_socket, (struct sockaddr *) &conn_info, &size );
-        pid_t client_pid = 0;
         
         if( new_socket == -1 )
@@ -262 +260 @@
         }
         
+#ifndef _WIN32
         if( global.conf->runmode == RUNMODE_FORKDAEMON )
         {
+                pid_t client_pid = 0;
                 int fds[2];
                 
@@ -320 +320 @@
         }
         else
+#endif
         {
                 log_message( LOGLVL_INFO, "Creating new connection with fd %d.", new_socket );

bitlbee.h

@@ -48 +48 @@
 #include <stdio.h>
 #include <ctype.h>
+#include <errno.h>
+
 #ifndef _WIN32
 #include <syslog.h>
-#include <errno.h>
 #endif
 

configure

@@ -285 +285 @@
 elif [ "$ssl" = "nss" ]; then
         detect_nss
+elif [ "$ssl" = "sspi" ]; then
+        echo
 elif [ "$ssl" = "openssl" ]; then
         echo
@@ -501 +503 @@
         echo 'Cygwin is not officially supported.'
 ;;
+Windows )
+        echo OUTFILE=bitlbee.exe >> Makefile.settings
+        echo LFLAGS+=-lwsock32 >> Makefile.settings
+        echo EFLAGS+=-lsecur32 >> Makefile.settings
+;;
 * )
         echo 'We haven'\''t tested BitlBee on many platforms yet, yours is untested. YMMV.'

ipc.c

@@ -439 +439 @@
 }
 
+#ifndef _WIN32
 char *ipc_master_save_state()
 {
@@ -504 +505 @@
 }
 
-#ifndef _WIN32
 int ipc_master_listen_socket()
 {
@@ -541 +541 @@
 }
 #else
+int ipc_master_listen_socket()
+{
         /* FIXME: Open named pipe \\.\BITLBEE */
+        return 0;
+}
 #endif
 

lib/misc.c

@@ -392 +392 @@
 }
 
-/* A pretty reliable random number generator. Tries to use the /dev/random
-   devices first, and falls back to the random number generator from libc
-   when it fails. Opens randomizer devices with O_NONBLOCK to make sure a
-   lack of entropy won't halt BitlBee. */
-void random_bytes( unsigned char *buf, int count )
-{
-        static int use_dev = -1;
-        
-        /* Actually this probing code isn't really necessary, is it? */
-        if( use_dev == -1 )
-        {
-                if( access( "/dev/random", R_OK ) == 0 || access( "/dev/urandom", R_OK ) == 0 )
-                        use_dev = 1;
-                else
-                {
-                        use_dev = 0;
-                        srand( ( getpid() << 16 ) ^ time( NULL ) );
-                }
-        }
-        
-        if( use_dev )
-        {
-                int fd;
-                
-                /* At least on Linux, /dev/random can block if there's not
-                   enough entropy. We really don't want that, so if it can't
-                   give anything, use /dev/urandom instead. */
-                if( ( fd = open( "/dev/random", O_RDONLY | O_NONBLOCK ) ) >= 0 )
-                        if( read( fd, buf, count ) == count )
-                        {
-                                close( fd );
-                                return;
-                        }
-                close( fd );
-                
-                /* urandom isn't supposed to block at all, but just to be
-                   sure. If it blocks, we'll disable use_dev and use the libc
-                   randomizer instead. */
-                if( ( fd = open( "/dev/urandom", O_RDONLY | O_NONBLOCK ) ) >= 0 )
-                        if( read( fd, buf, count ) == count )
-                        {
-                                close( fd );
-                                return;
-                        }
-                close( fd );
-                
-                /* If /dev/random blocks once, we'll still try to use it
-                   again next time. If /dev/urandom also fails for some
-                   reason, stick with libc during this session. */
-                
-                use_dev = 0;
-                srand( ( getpid() << 16 ) ^ time( NULL ) );
-        }
-        
-        if( !use_dev )
-        {
-                int i;
-                
-                /* Possibly the LSB of rand() isn't very random on some
-                   platforms. Seems okay on at least Linux and OSX though. */
-                for( i = 0; i < count; i ++ )
-                        buf[i] = rand() & 0xff;
-        }
-}
-
 int is_bool( char *value )
 {

protocols/nogaim.h

@@ -131 +131 @@
         struct im_connection *ic; /* the connection it belongs to */
 };
+
+struct ft 
+{
+        const char *filename;
+        
+        /* Total number of bytes in file */
+        size_t total_bytes;
+        
+        /* Current number of bytes received */
+        size_t cur_bytes;
+};
+
+struct ft_request 
+{
+        const char *filename;
+        struct gaim_connection *gc;
+};
+
+typedef void (*ft_recv_handler) (struct ft *, void *data, size_t len);
 
 struct prpl {

protocols/oscar/AUTHORS

@@ -28 +28 @@
 E: awwaiid@auk.cx
 D: Figured out original password roasting
-
-

protocols/yahoo/libyahoo2.c

@@ -69 +69 @@
 #ifdef __MINGW32__
 # include <winsock2.h>
-# define write(a,b,c) send(a,b,c,0)
-# define read(a,b,c)  recv(a,b,c,0)
 #endif
 

protocols/yahoo/yahoo_httplib.c

@@ -51 +51 @@
 #ifdef __MINGW32__
 # include <winsock2.h>
-# define write(a,b,c) send(a,b,c,0)
-# define read(a,b,c)  recv(a,b,c,0)
 # define snprintf _snprintf
 #endif

sock.h

@@ -16 +16 @@
 #else
 # include <winsock2.h>
-# ifndef _MSC_VER
-#  include <ws2tcpip.h>
-# endif
+# include <ws2tcpip.h>
 # if !defined(BITLBEE_CORE) && defined(_MSC_VER)
 #   pragma comment(lib,"bitlbee.lib")
 # endif
 # include <io.h>
-# define read(a,b,c) recv(a,b,c,0)
-# define write(a,b,c) send(a,b,c,0)
-# define umask _umask
-# define mode_t int
 # define sock_make_nonblocking(fd) { int non_block = 1; ioctlsocket(fd, FIONBIO, &non_block); }
 # define sock_make_blocking(fd) { int non_block = 0; ioctlsocket(fd, FIONBIO, &non_block); }

storage_text.c

@@ -27 +27 @@
 #include "bitlbee.h"
 #include "crypting.h"
+#ifdef _WIN32
+# define umask _umask
+# define mode_t int
+#endif
+
+#ifndef F_OK
+#define F_OK 0
+#endif
 
 static void text_init (void)

unix.c

@@ -60 +60 @@
         if( global.conf->runmode == RUNMODE_INETD )
         {
+                log_link( LOGLVL_ERROR, LOGOUTPUT_IRC );
+                log_link( LOGLVL_WARNING, LOGOUTPUT_IRC );
+        
                 i = bitlbee_inetd_init();
                 log_message( LOGLVL_INFO, "Bitlbee %s starting in inetd mode.", BITLBEE_VERSION );
@@ -66 +69 @@
         else if( global.conf->runmode == RUNMODE_DAEMON )
         {
+                log_link( LOGLVL_ERROR, LOGOUTPUT_SYSLOG );
+                log_link( LOGLVL_WARNING, LOGOUTPUT_SYSLOG );
+
                 i = bitlbee_daemon_init();
                 log_message( LOGLVL_INFO, "Bitlbee %s starting in daemon mode.", BITLBEE_VERSION );
@@ -219 +225 @@
         return( (double) time->tv_sec + (double) time->tv_usec / 1000000 );
 }
+
+/* A pretty reliable random number generator. Tries to use the /dev/random
+   devices first, and falls back to the random number generator from libc
+   when it fails. Opens randomizer devices with O_NONBLOCK to make sure a
+   lack of entropy won't halt BitlBee. */
+void random_bytes( unsigned char *buf, int count )
+{
+        static int use_dev = -1;
+        
+        /* Actually this probing code isn't really necessary, is it? */
+        if( use_dev == -1 )
+        {
+                if( access( "/dev/random", R_OK ) == 0 || access( "/dev/urandom", R_OK ) == 0 )
+                        use_dev = 1;
+                else
+                {
+                        use_dev = 0;
+                        srand( ( getpid() << 16 ) ^ time( NULL ) );
+                }
+        }
+        
+        if( use_dev )
+        {
+                int fd;
+                
+                /* At least on Linux, /dev/random can block if there's not
+                   enough entropy. We really don't want that, so if it can't
+                   give anything, use /dev/urandom instead. */
+                if( ( fd = open( "/dev/random", O_RDONLY | O_NONBLOCK ) ) >= 0 )
+                        if( read( fd, buf, count ) == count )
+                        {
+                                close( fd );
+                                return;
+                        }
+                close( fd );
+                
+                /* urandom isn't supposed to block at all, but just to be
+                   sure. If it blocks, we'll disable use_dev and use the libc
+                   randomizer instead. */
+                if( ( fd = open( "/dev/urandom", O_RDONLY | O_NONBLOCK ) ) >= 0 )
+                        if( read( fd, buf, count ) == count )
+                        {
+                                close( fd );
+                                return;
+                        }
+                close( fd );
+                
+                /* If /dev/random blocks once, we'll still try to use it
+                   again next time. If /dev/urandom also fails for some
+                   reason, stick with libc during this session. */
+                
+                use_dev = 0;
+                srand( ( getpid() << 16 ) ^ time( NULL ) );
+        }
+        
+        if( !use_dev )
+        {
+                int i;
+                
+                /* Possibly the LSB of rand() isn't very random on some
+                   platforms. Seems okay on at least Linux and OSX though. */
+                for( i = 0; i < count; i ++ )
+                        buf[i] = rand() & 0xff;
+        }
+}
+
+