Changeset 31 for box/nick

Timestamp:

24/10/2005 19:44:10 (7 years ago)

Author:

nick

Message:

update world - should be all the same now

Location:

box/nick/win

Files:

• bbackupctl.vcproj (added)
• bbackupd.vcproj (added)
• boxbackup.sln (added)
• boxbackup.suo (added)
• boxquery.vcproj (added)
• common.vcproj (added)
• infrastructure/makebuildenv.pl (modified) (8 diffs)
• lib/backupclient/BackupClientFileAttributes.cpp (modified) (2 diffs)
• lib/backupclient/BackupClientFileAttributes.h (modified) (1 diff)
• lib/backupclient/BackupClientRestore.cpp (modified) (2 diffs)
• lib/backupclient/BackupDaemonConfigVerify.cpp (modified) (1 diff)
• lib/backupclient/BackupStoreDirectory.h (modified) (1 diff)
• lib/backupclient/BackupStoreFile.cpp (modified) (11 diffs)
• lib/backupclient/BackupStoreFile.h (modified) (3 diffs)
• lib/backupclient/BackupStoreFileCombine.cpp (modified) (1 diff)
• lib/backupclient/BackupStoreFileDiff.cpp (modified) (6 diffs)
• lib/backupclient/BackupStoreFileEncodeStream.cpp (modified) (5 diffs)
• lib/backupclient/BackupStoreFileEncodeStream.h (modified) (2 diffs)
• lib/backupclient/BackupStoreObjectDump.cpp (modified) (1 diff)
• lib/common/Box.h (modified) (1 diff)
• lib/common/BoxPlatform.h (modified) (5 diffs)
• lib/common/BoxPortsAndFiles.h (modified) (2 diffs)
• lib/common/BoxTime.h (modified) (1 diff)
• lib/common/BoxTimeToText.cpp (modified) (2 diffs)
• lib/common/BoxTimeToUnix.h (modified) (1 diff)
• lib/common/Configuration.cpp (modified) (6 diffs)
• lib/common/Configuration.h (modified) (3 diffs)
• lib/common/Conversion.h (modified) (1 diff)
• lib/common/DebugPrintf.cpp (modified) (1 diff)
• lib/common/ExcludeList.cpp (modified) (9 diffs)
• lib/common/ExcludeList.h (modified) (4 diffs)
• lib/common/FileStream.cpp (modified) (11 diffs)
• lib/common/FileStream.h (modified) (2 diffs)
• lib/common/IOStream.cpp (modified) (2 diffs)
• lib/crypto/CipherBlowfish.cpp (modified) (1 diff)
• lib/crypto/CipherException.txt (modified) (1 diff)
• lib/crypto/Random.cpp (modified) (1 diff)
• lib/crypto/Random.h (modified) (1 diff)
• lib/raidfile/RaidFileWrite.cpp (modified) (1 diff)
• lib/server/Daemon.cpp (modified) (9 diffs)
• lib/server/LocalProcessStream.cpp (modified) (3 diffs)
• lib/server/ServerStream.h (modified) (1 diff)
• lib/server/ServerTLS.h (modified) (2 diffs)
• lib/server/Socket.cpp (modified) (4 diffs)
• lib/server/Socket.h (modified) (2 diffs)
• lib/server/SocketListen.h (modified) (2 diffs)
• lib/server/SocketStream.cpp (modified) (5 diffs)
• lib/server/SocketStream.h (modified) (1 diff)
• lib/server/SocketStreamTLS.cpp (modified) (2 diffs)
• lib/server/makeprotocol.pl (modified) (5 diffs)
• modules.txt (modified) (1 diff)
• test/basicserver/testbasicserver.cpp (modified) (1 diff)
• test/bbackupd/testbbackupd.cpp (modified) (3 diffs)
• win32test.vcproj (added)

box/nick/win/infrastructure/makebuildenv.pl

@@ -1 +1 @@
 #!/usr/bin/perl
 use strict;
+use Symbol;
 
 my @modules;
@@ -323 +324 @@
 # seed autogen code
 print "Seeding autogen code...\n";
-open FINDAUTOGEN,"find . -name Makefile.extra |" or die "Can't use find for locating files";
+open FINDAUTOGEN,"find . -follow -name Makefile.extra |" or die "Can't use find for locating files";
 while(<FINDAUTOGEN>)
 {
@@ -396 +397 @@
 $extra_platform_defines .= ' -DPLATFORM_GCC3' if $gcc_v3;
 
-# read in module definitions file and prepare directories
-open MODULES,"modules.txt" or die "Can't open modules file\n";
+# read in module definitions file, and any files it includes
+my @modules_files;
+sub read_modules_file
+{
+        my ($mf) = @_;
+        my $f = gensym;
+        open $f,$mf or die "Can't open modules file '$mf'\n";
+        while(<$f>)
+        {
+                if(m/\AINCLUDE\s+(\S+)\Z/)
+                {
+                        # include another file
+                        read_modules_file($1)
+                }
+                else
+                {
+                        push @modules_files,$_
+                }
+        }
+        close $f;
+}
+read_modules_file('modules.txt');
 
 # prepare directories...
@@ -403 +424 @@
 mkdir "debug",0755;
 
+# is the library code in another directory?
+my $external_lib = readlink('lib');
+if($external_lib ne '')
+{
+        # adjust to root of the library distribution
+        $external_lib =~ s!/lib\Z!!;
+        $external_lib = '../'.$external_lib;
+        # make symlinks
+        make_obj_symlink('debug');
+        make_obj_symlink('release');
+}
+sub make_obj_symlink
+{
+        my $m = $_[0];
+        my $target = $external_lib."/$m/lib/";
+        my $link = "$m/lib";
+        # check link
+        if(-e $link)
+        {
+                if(-l $link)
+                {
+                        if(readlink($link) ne $target)
+                        {
+                                print "Warning: replacing $link with new link to $target\n";
+                                unlink $link;
+                        }
+                }
+                else
+                {
+                        die "$link already exists, but it isn't a symbolic link"
+                }
+        }
+        if(!-e $link)
+        {
+                symlink $target,$link or die "Can't make $m/lib symlink";
+        }
+}
+
 print "Scanning code...\n";
 
 my $modules_omitted = 0;
 
-while(<MODULES>)
+# process lines in flattened modules files
+for(@modules_files)
 {
         # clean up line
-        chomp; s/\A\s+//; s/#.+\Z//; s/\s+\Z//; s/\s+/ /g;
+        chomp; s/\A\s+//; s/#.*\Z//; s/\s+\Z//; s/\s+/ /g;
         next unless m/\S/;
         
@@ -484 +544 @@
         $module_library_link_opts{$mod} = [@lo];
         
-        # make directories
+        # make directories, but not if we're using an external library and this a library module
         my ($s,$d) = split /\//,$mod;
-        mkdir "release/$s",0755;
-        mkdir "release/$s/$d",0755;
-        mkdir "debug/$s",0755;
-        mkdir "debug/$s/$d",0755;
-}
-close MODULES;
+        if($s ne 'lib' || $external_lib eq '')
+        {
+                mkdir "release/$s",0755;
+                mkdir "release/$s/$d",0755;
+                mkdir "debug/$s",0755;
+                mkdir "debug/$s/$d",0755;
+        }
+}
 
 # make dirs for implicit dep
@@ -1011 +1073 @@
                 if(exists $t{'SuccessFlags'})
                 {
-                        $env_flags{$_} = 1 for(@{$t{'SuccessFlags'}})
+                        for(@{$t{'SuccessFlags'}})
+                        {
+                                my ($k,$v) = split /=>/,$_;
+                                $v = 1 if $v eq '';
+                                $env_flags{$k} = $v
+                        }
                 }
                 $compile_line_extra .= $t{'SuccessCompileFlags'}.' ' if exists $t{'SuccessCompileFlags'};
@@ -1029 +1096 @@
                 if(exists $t{'FailureFlags'})
                 {
-                        $env_flags{$_} = 1 for(@{$t{'FailureFlags'}})
+                        for(@{$t{'FailureFlags'}})
+                        {
+                                my ($k,$v) = split /=>/,$_;
+                                $v = 1 if $v eq '';
+                                $env_flags{$k} = $v
+                        }
                 }
                 $compile_line_extra .= $t{'FailureCompileFlags'}.' ' if exists $t{'FailureCompileFlags'};
@@ -1035 +1107 @@
                 $test_failure_text .= $t{'FailureText'} if exists $t{'FailureText'};
         }
-}
-
-
-
+        $result
+}
+
+
+

box/nick/win/lib/backupclient/BackupClientFileAttributes.cpp

@@ -273 +273 @@
 // --------------------------------------------------------------------------
 void BackupClientFileAttributes::ReadAttributes(const char *Filename, bool ZeroModificationTimes, box_time_t *pModTime,
-        box_time_t *pAttrModTime, int64_t *pFileSize, ino_t *pInodeNumber, bool *pHasMultipleLinks)
+        box_time_t *pAttrModTime, int64_t *pFileSize, InodeRefType *pInodeNumber, bool *pHasMultipleLinks)
 {
         StreamableMemBlock *pnewAttr = 0;
@@ -334 +334 @@
                 FILL_IN_ATTRIBUTES
                 FILL_IN_ATTRIBUTES_2
+
+#ifdef WIN32
+                //this is to catch those problems with invalid time stamps stored...
+                //need to find out the reason why - but also a catch as well.
+                
+                //__time64_t winTime = BoxTimeToSeconds(pattr->ModificationTime);
+
+                box_time_t bob = BoxTimeToSeconds(pattr->ModificationTime);
+                __time64_t winTime = bob;
+                if (_gmtime64(&winTime) == 0 )
+                {
+                        ::syslog(LOG_ERR, "Corrupt value in store Modification Time in file %s", Filename);
+                        pattr->ModificationTime = 0;
+                }
+
+                bob = BoxTimeToSeconds(pattr->AttrModificationTime);
+                winTime = bob;
+                if (_gmtime64(&winTime) == 0 )
+                {
+                        ::syslog(LOG_ERR, "Corrupt value in store Attr Modification Time in file %s", Filename);
+                        pattr->AttrModificationTime = 0;
+                }
+#endif
                 
                 // Attributes ready. Encrypt into this block

box/nick/win/lib/backupclient/BackupClientFileAttributes.h

@@ -45 +45 @@
         void ReadAttributes(const char *Filename, bool ZeroModificationTimes = false,
                 box_time_t *pModTime = 0, box_time_t *pAttrModTime = 0, int64_t *pFileSize = 0,
-                ino_t *pInodeNumber = 0, bool *pHasMultipleLinks = 0);
+                InodeRefType *pInodeNumber = 0, bool *pHasMultipleLinks = 0);
         void WriteAttributes(const char *Filename) const;
 

box/nick/win/lib/backupclient/BackupClientRestore.cpp

@@ -16 +16 @@
 #include <unistd.h>
 #include <limits.h>
+#include <stdio.h>
 
 #include "BackupClientRestore.h"
@@ -224 +225 @@
 
         // Create the local directory (if not already done) -- path and owner set later, just use restrictive owner mode
-        if(ObjectExists(rLocalDirectoryName.c_str()) != ObjectExists_Dir)
-        {
-                if(::mkdir(rLocalDirectoryName.c_str(), S_IRWXU) != 0)
-                {
-                        THROW_EXCEPTION(CommonException, OSFileError);
-                }
+        switch(ObjectExists(rLocalDirectoryName.c_str()))
+        {
+                case ObjectExists_Dir:
+                        // Do nothing
+                        break;
+                case ObjectExists_File:
+                        {
+                                // File exists with this name, which is fun. Get rid of it.
+                                ::printf("WARNING: File present with name '%s', removing out of the way of restored directory. Use specific restore with ID to restore this object.", rLocalDirectoryName.c_str());
+                                if(::unlink(rLocalDirectoryName.c_str()) != 0)
+                                {
+                                        THROW_EXCEPTION(CommonException, OSFileError);
+                                }
+                                TRACE1("In restore, directory name collision with file %s", rLocalDirectoryName.c_str());
+                        }
+                        // follow through to... (no break)
+                case ObjectExists_NoObject:
+                        if(::mkdir(rLocalDirectoryName.c_str(), S_IRWXU) != 0)
+                        {
+                                THROW_EXCEPTION(CommonException, OSFileError);
+                        }
+                        break;
+                default:
+                        ASSERT(false);
+                        break;
         }
         

box/nick/win/lib/backupclient/BackupDaemonConfigVerify.cpp

@@ -85 +85 @@
 
         {"CommandSocket", 0, 0, 0},                             // not compulsory to have this
+        {"StoreObjectInfoFile", 0, 0, 0},                               // optional
+        {"KeepAliveTime", 0, ConfigTest_IsInt, 0},                              // optional
 
         {"NotifyScript", 0, 0, 0},                              // optional script to run when backup needs attention, eg store full

box/nick/win/lib/backupclient/BackupStoreDirectory.h

@@ -182 +182 @@
                         return (*(i++));
                 }
-        
+
+                // WARNING: This function is really very inefficient.
+                // Only use when you want to look up ONE filename, not in a loop looking up lots.
+                // In a looping situation, cache the decrypted filenames in another memory structure.
                 BackupStoreDirectory::Entry *FindMatchingClearName(const BackupStoreFilenameClear &rFilename, int16_t FlagsMustBeSet = Entry::Flags_INCLUDE_EVERYTHING, int16_t FlagsNotToBeSet = Entry::Flags_EXCLUDE_NOTHING)
                 {

box/nick/win/lib/backupclient/BackupStoreFile.cpp

@@ -14 +14 @@
 #include <string.h>
 #include <new>
+#include <string.h>
 #ifndef BOX_DISABLE_BACKWARDS_COMPATIBILITY_BACKUPSTOREFILE
         #include <syslog.h>
@@ -366 +367 @@
         if(mpEncodedData)
         {
-                ::free(mpEncodedData);
+                BackupStoreFile::CodingChunkFree(mpEncodedData);
         }
         if(mpClearData)
@@ -531 +532 @@
                 
                 // Allocate those blocks!
-                mpEncodedData = (uint8_t*)::malloc(maxEncodedDataSize + 32);
+                mpEncodedData = (uint8_t*)BackupStoreFile::CodingChunkAlloc(maxEncodedDataSize + 32);
 
                 // Allocate the block for the clear data, using the hint from the header.
@@ -913 +914 @@
 //
 // Function
-//              Name:    BackupStoreFile::EncodeChunk(const void *, int, void *, int)
-//              Purpose: Encodes a chunk (encryption, possible encrypted beforehand)
+//              Name:    BackupStoreFile::EncodeChunk(const void *, int, BackupStoreFile::EncodingBuffer &)
+//              Purpose: Encodes a chunk (encryption, possible compressed beforehand)
 //              Created: 8/12/03
 //
 // --------------------------------------------------------------------------
-int BackupStoreFile::EncodeChunk(const void *Chunk, int ChunkSize, void *Output, int OutputSize)
+int BackupStoreFile::EncodeChunk(const void *Chunk, int ChunkSize, BackupStoreFile::EncodingBuffer &rOutput)
 {
         ASSERT(spEncrypt != 0);
 
-        // Check there's enough space in the output block
-        if(OutputSize < MaxBlockSizeForChunkSize(ChunkSize))
-        {
-                THROW_EXCEPTION(BackupStoreException, OutputSizeTooSmallForChunk)
-        }
-        
+        // Check there's some space in the output block
+        if(rOutput.mBufferSize < 256)
+        {
+                rOutput.Reallocate(256);
+        }
+        
+        // Check alignment of the block
+        ASSERT((((uint32_t)rOutput.mpBuffer) % BACKUPSTOREFILE_CODING_BLOCKSIZE) == BACKUPSTOREFILE_CODING_OFFSET);
+
         // Want to compress it?
         bool compressChunk = (ChunkSize >= BACKUP_FILE_MIN_COMPRESSED_CHUNK_SIZE);
@@ -936 +940 @@
 
         // Store header
-        uint8_t *output = (uint8_t*)Output;
-        output[0] = header;
+        rOutput.mpBuffer[0] = header;
         int outOffset = 1;
 
@@ -943 +946 @@
         int ivLen = 0;
         const void *iv = spEncrypt->SetRandomIV(ivLen);
-        ::memcpy(output + outOffset, iv, ivLen);
+        ::memcpy(rOutput.mpBuffer + outOffset, iv, ivLen);
         outOffset += ivLen;
         
         // Start encryption process
         spEncrypt->Begin();
+        
+        #define ENCODECHUNK_CHECK_SPACE(ToEncryptSize)                                                                  \
+                {                                                                                                                                                       \
+                        if((rOutput.mBufferSize - outOffset) < ((ToEncryptSize) + 128))                 \
+                        {                                                                                                                                               \
+                                rOutput.Reallocate(rOutput.mBufferSize + (ToEncryptSize) + 128);        \
+                        }                                                                                                                                               \
+                }
         
         // Encode the chunk
@@ -966 +977 @@
                         if(s > 0)
                         {
-                                outOffset += spEncrypt->Transform(output + outOffset, OutputSize - outOffset, buffer, s);                               
+                                ENCODECHUNK_CHECK_SPACE(s)
+                                outOffset += spEncrypt->Transform(rOutput.mpBuffer + outOffset, rOutput.mBufferSize - outOffset, buffer, s);                            
                         }
                         else
@@ -975 +987 @@
                         }
                 }
-                outOffset += spEncrypt->Final(output + outOffset, OutputSize - outOffset);
+                ENCODECHUNK_CHECK_SPACE(16)
+                outOffset += spEncrypt->Final(rOutput.mpBuffer + outOffset, rOutput.mBufferSize - outOffset);
         }
         else
         {
                 // Straight encryption
-                outOffset += spEncrypt->Transform(output + outOffset, OutputSize - outOffset, Chunk, ChunkSize);
-                outOffset += spEncrypt->Final(output + outOffset, OutputSize - outOffset);
-        }
-        
-        ASSERT(outOffset < OutputSize);         // first check should have sorted this -- merely logic check
+                ENCODECHUNK_CHECK_SPACE(ChunkSize)
+                outOffset += spEncrypt->Transform(rOutput.mpBuffer + outOffset, rOutput.mBufferSize - outOffset, Chunk, ChunkSize);
+                ENCODECHUNK_CHECK_SPACE(16)
+                outOffset += spEncrypt->Final(rOutput.mpBuffer + outOffset, rOutput.mBufferSize - outOffset);
+        }
+        
+        ASSERT(outOffset < rOutput.mBufferSize);                // first check should have sorted this -- merely logic check
 
         return outOffset;
@@ -995 +1010 @@
 //              Purpose: Decode an encoded chunk -- use OutputBufferSizeForKnownOutputSize() to find
 //                               the extra output buffer size needed before calling.
+//                               See notes in EncodeChunk() for notes re alignment of the 
+//                               encoded data.
 //              Created: 8/12/03
 //
@@ -1000 +1017 @@
 int BackupStoreFile::DecodeChunk(const void *Encoded, int EncodedSize, void *Output, int OutputSize)
 {
+        // Check alignment of the encoded block
+        ASSERT((((uint32_t)Encoded) % BACKUPSTOREFILE_CODING_BLOCKSIZE) == BACKUPSTOREFILE_CODING_OFFSET);
+
         // First check
         if(EncodedSize < 1)
@@ -1393 +1413 @@
 }
 
+
+// --------------------------------------------------------------------------
+//
+// Function
+//              Name:    BackupStoreFile::EncodingBuffer::EncodingBuffer()
+//              Purpose: Constructor
+//              Created: 25/11/04
+//
+// --------------------------------------------------------------------------
+BackupStoreFile::EncodingBuffer::EncodingBuffer()
+        : mpBuffer(0),
+          mBufferSize(0)
+{
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//              Name:    BackupStoreFile::EncodingBuffer::~EncodingBuffer()
+//              Purpose: Destructor
+//              Created: 25/11/04
+//
+// --------------------------------------------------------------------------
+BackupStoreFile::EncodingBuffer::~EncodingBuffer()
+{
+        if(mpBuffer != 0)
+        {
+                BackupStoreFile::CodingChunkFree(mpBuffer);
+                mpBuffer = 0;
+        }
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//              Name:    BackupStoreFile::EncodingBuffer::Allocate(int)
+//              Purpose: Do initial allocation of block
+//              Created: 25/11/04
+//
+// --------------------------------------------------------------------------
+void BackupStoreFile::EncodingBuffer::Allocate(int Size)
+{
+        ASSERT(mpBuffer == 0);
+        uint8_t *buffer = (uint8_t*)BackupStoreFile::CodingChunkAlloc(Size);
+        if(buffer == 0)
+        {
+                throw std::bad_alloc();
+        }
+        mpBuffer = buffer;
+        mBufferSize = Size;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//              Name:    BackupStoreFile::EncodingBuffer::Reallocate(int)
+//              Purpose: Reallocate the block. Try not to call this, it has to copy
+//                               the entire contents as the block can't be reallocated straight.
+//              Created: 25/11/04
+//
+// --------------------------------------------------------------------------
+void BackupStoreFile::EncodingBuffer::Reallocate(int NewSize)
+{
+        TRACE2("Reallocating EncodingBuffer from %d to %d\n", mBufferSize, NewSize);
+        ASSERT(mpBuffer != 0);
+        uint8_t *buffer = (uint8_t*)BackupStoreFile::CodingChunkAlloc(NewSize);
+        if(buffer == 0)
+        {
+                throw std::bad_alloc();
+        }
+        // Copy data
+        ::memcpy(buffer, mpBuffer, (NewSize > mBufferSize)?mBufferSize:NewSize);
+        
+        // Free old
+        BackupStoreFile::CodingChunkFree(mpBuffer);
+        
+        // Store new buffer
+        mpBuffer = buffer;
+        mBufferSize = NewSize;
+}
+
+

box/nick/win/lib/backupclient/BackupStoreFile.h

@@ -23 +23 @@
         int64_t mTotalFileStreamSize;
 } BackupStoreFileStats;
+
+// BOX_PRIVATE_BEGIN
+// Interal builds don't have backwards compatibility
+#define BOX_DISABLE_BACKWARDS_COMPATIBILITY_BACKUPSTOREFILE
+// BOX_PRIVATE_END
+
+
+// Output buffer to EncodeChunk and input data to DecodeChunk must
+// have specific alignment, see function comments.
+#define BACKUPSTOREFILE_CODING_BLOCKSIZE                16
+#define BACKUPSTOREFILE_CODING_OFFSET                   15
+
+// Have some memory allocation commands, note closing "Off" at end of file.
+#include "MemLeakFindOn.h"
 
 // --------------------------------------------------------------------------
@@ -106 +120 @@
 #endif
 
-        // Limits
-        static void SetMaximumDiffingTime(int Seconds);
+        // Allocation of properly aligning chunks for decoding and encoding chunks
+        inline static void *CodingChunkAlloc(int Size)
+        {
+                uint8_t *a = (uint8_t*)malloc((Size) + (BACKUPSTOREFILE_CODING_BLOCKSIZE * 3));
+                if(a == 0) return 0;
+                // Align to main block size
+                ASSERT(sizeof(uint32_t) == sizeof(void*));      // make sure casting the right pointer size, will need to fix on platforms with 64 bit pointers
+                uint32_t adjustment = BACKUPSTOREFILE_CODING_BLOCKSIZE - (((uint32_t)a) % BACKUPSTOREFILE_CODING_BLOCKSIZE);
+                uint8_t *b = (a + adjustment);
+                // Store adjustment
+                *b = (uint8_t)adjustment;
+                // Return offset
+                return b + BACKUPSTOREFILE_CODING_OFFSET;
+        }
+        inline static void CodingChunkFree(void *Block)
+        {
+                // Check alignment is as expected
+                ASSERT(sizeof(uint32_t) == sizeof(void*));      // make sure casting the right pointer size, will need to fix on platforms with 64 bit pointers
+                ASSERT((((uint32_t)Block) % BACKUPSTOREFILE_CODING_BLOCKSIZE) == BACKUPSTOREFILE_CODING_OFFSET);
+                uint8_t *a = (uint8_t*)Block;
+                a -= BACKUPSTOREFILE_CODING_OFFSET;
+                // Adjust downwards...
+                a -= *a;
+                free(a);
+        }
+
+
+        // --------------------------------------------------------------------------
+        //
+        // Function
+        //              Name:    BackupStoreFile::SuspendFileDiff()
+        //              Purpose: Notifies BackupStoreFile object that a diff operation should be
+        //                               terminated ASAP. Usually called from an external timer.
+        //
+        //              Created: 12/1/04
+        //
+        // --------------------------------------------------------------------------
+        static void SuspendFileDiff();
 
         // Building blocks
+        class EncodingBuffer
+        {
+        public:
+                EncodingBuffer();
+                ~EncodingBuffer();
+        private:
+                // No copying
+                EncodingBuffer(const EncodingBuffer &);
+                EncodingBuffer &operator=(const EncodingBuffer &);
+        public:
+                void Allocate(int Size);
+                void Reallocate(int NewSize);
+                
+                uint8_t *mpBuffer;
+                int mBufferSize;
+        };
         static int MaxBlockSizeForChunkSize(int ChunkSize);
-        static int EncodeChunk(const void *Chunk, int ChunkSize, void *Output, int OutputSize);
+        static int EncodeChunk(const void *Chunk, int ChunkSize, BackupStoreFile::EncodingBuffer &rOutput);
 
         // Caller should know how big the output size is, but also allocate a bit more memory to cover various
@@ -135 +201 @@
 };
 
+#include "MemLeakFindOff.h"
+
 #endif // BACKUPSTOREFILE__H
 

box/nick/win/lib/backupclient/BackupStoreFileCombine.cpp

@@ -322 +322 @@
                 }
                 
-                // Free buffer
-                ::free(buffer);
-                buffer = 0;
+                // Free buffer, if allocated
+                if(buffer != 0)
+                {
+                        ::free(buffer);
+                        buffer = 0;
+                }
         }
         catch(...)

box/nick/win/lib/backupclient/BackupStoreFileDiff.cpp

@@ -13 +13 @@
 #include <map>
 #include <signal.h>
+#ifdef WIN32
+#include <time.h>
+#else
 #include <sys/time.h>
+#endif
 
 #include "BackupStoreFile.h"
@@ -45 +49 @@
 static void GenerateRecipe(BackupStoreFileEncodeStream::Recipe &rRecipe, BlocksAvailableEntry *pIndex, int64_t NumBlocks, std::map<int64_t, int64_t> &rFoundBlocks, int64_t SizeOfInputFile);
 
-// Avoid running on too long with diffs
-static int sMaximumDiffTime = 10;               // maximum time to spend diffing
+// control whether a currently active diff should be terminated ASAP
 static bool sDiffTimedOut = false;
-static bool sSetTimerSignelHandler = false;
-static void TimerSignalHandler(int signal);
-static void StartDiffTimer();
-
 
 // --------------------------------------------------------------------------
 //
 // Function
-//              Name:    BackupStoreFile::SetMaximumDiffingTime(int)
-//              Purpose: Sets the maximum time to spend diffing, in seconds. Time is
-//                               process virutal time.
-//              Created: 19/3/04
-//
-// --------------------------------------------------------------------------
-void BackupStoreFile::SetMaximumDiffingTime(int Seconds)
+//              Name:    BackupStoreFile::SuspendFileDiff()
+//              Purpose: Notifies BackupStoreFile object that a diff operation should be
+//                               terminated ASAP. Usually called from an external timer.
+//
+//              Created: 12/1/04
+//
+// --------------------------------------------------------------------------
+void BackupStoreFile::SuspendFileDiff()
 {
-        sMaximumDiffTime = Seconds;
-        TRACE1("Set maximum diffing time to %d seconds\n", Seconds);
+        sDiffTimedOut = true;
 }
-
 
 // --------------------------------------------------------------------------
@@ -176 +174 @@
         // Pointer to recipe we're going to create
         BackupStoreFileEncodeStream::Recipe *precipe = 0;
-
-        // Start the timeout timer, so that the operation doesn't continue for ever
-        StartDiffTimer();
         
         try
@@ -471 +466 @@
         BlocksAvailableEntry *pIndex, int64_t NumBlocks, int32_t Sizes[BACKUP_FILE_DIFF_MAX_BLOCK_SIZES])
 {
+        // reset state in case we got timing/call-order mess-up somewhere else
+        sDiffTimedOut = false;
+
         // Allocate the hash lookup table
         BlocksAvailableEntry **phashTable = (BlocksAvailableEntry **)::malloc(sizeof(BlocksAvailableEntry *) * (64*1024));
@@ -912 +910 @@
                         {
                                 char b[64];
+#ifdef WIN32
+                                sprintf(b, "%8I64d", (int64_t)(rRecipe[e].mpStartBlock - pIndex));
+#else
                                 sprintf(b, "%8lld", (int64_t)(rRecipe[e].mpStartBlock - pIndex));
+#endif
                                 TRACE3("%8lld %s %8lld\n", rRecipe[e].mSpaceBefore, (rRecipe[e].mpStartBlock == 0)?"       -":b, (int64_t)rRecipe[e].mBlocks);
                         }
@@ -920 +922 @@
 #endif
 }
-
-
-// --------------------------------------------------------------------------
-//
-// Function
-//              Name:    static TimerSignalHandler(int)
-//              Purpose: Signal handler
-//              Created: 19/3/04
-//
-// --------------------------------------------------------------------------
-void TimerSignalHandler(int signal)
-{
-        sDiffTimedOut = true;
-}
-
-
-// --------------------------------------------------------------------------
-//
-// Function
-//              Name:    static StartDiffTimer()
-//              Purpose: Starts the diff timeout timer
-//              Created: 19/3/04
-//
-// --------------------------------------------------------------------------
-void StartDiffTimer()
-{
-        // Set timer signal handler
-        if(!sSetTimerSignelHandler)
-        {
-                ::signal(SIGVTALRM, TimerSignalHandler);
-                sSetTimerSignelHandler = true;
-        }
-
-        struct itimerval timeout;
-        // Don't want this to repeat
-        timeout.it_interval.tv_sec = 0;
-        timeout.it_interval.tv_usec = 0;
-        // Single timeout after the specified number of seconds
-        timeout.it_value.tv_sec = sMaximumDiffTime;
-        timeout.it_value.tv_usec = 0;
-        // Set timer
-        if(::setitimer(ITIMER_VIRTUAL, &timeout, NULL) != 0)
-        {
-                TRACE0("WARNING: couldn't set diff timeout\n");
-        }
-        
-        // Unset flag (last thing)
-        sDiffTimedOut = false;
-}
-
-
-

box/nick/win/lib/backupclient/BackupStoreFileEncodeStream.cpp

@@ -51 +51 @@
           mLastBlockSize(0),
           mpRawBuffer(0),
-          mpEncodedBuffer(0),
           mAllocatedBufferSize(0),
           mEntryIVBase(0)
@@ -72 +71 @@
                 ::free(mpRawBuffer);
                 mpRawBuffer = 0;
-        }
-        if(mpEncodedBuffer)
-        {
-                ::free(mpEncodedBuffer);
-                mpEncodedBuffer = 0;
         }
         
@@ -212 +206 @@
                         // Then allocate two blocks of this size
                         mpRawBuffer = (uint8_t*)::malloc(mAllocatedBufferSize);
-                        mpEncodedBuffer = (uint8_t*)::malloc(mAllocatedBufferSize);
-                        if(mpRawBuffer == 0 || mpEncodedBuffer == 0)
+                        if(mpRawBuffer == 0)
                         {
                                 throw std::bad_alloc();
                         }
+#ifndef NDEBUG
+                        // In debug builds, make sure that the reallocation code is exercised.
+                        mEncodedBuffer.Allocate(mAllocatedBufferSize / 4);
+#else
+                        mEncodedBuffer.Allocate(mAllocatedBufferSize);
+#endif
                 }
                 else
@@ -412 +411 @@
                                 
                                 // Copy it in
-                                ::memcpy(buffer, mpEncodedBuffer + mPositionInCurrentBlock, s);
+                                ::memcpy(buffer, mEncodedBuffer.mpBuffer + mPositionInCurrentBlock, s);
                                 
                                 // Update variables
@@ -535 +534 @@
         
         // Encode it
-        mCurrentBlockEncodedSize = BackupStoreFile::EncodeChunk(mpRawBuffer, blockRawSize, mpEncodedBuffer, mAllocatedBufferSize);
+        mCurrentBlockEncodedSize = BackupStoreFile::EncodeChunk(mpRawBuffer, blockRawSize, mEncodedBuffer);
         
         //TRACE2("Encode: Encoded size of block %d is %d\n", (int32_t)mCurrentBlock, (int32_t)mCurrentBlockEncodedSize);

box/nick/win/lib/backupclient/BackupStoreFileEncodeStream.h

@@ -17 +17 @@
 #include "CollectInBufferStream.h"
 #include "MD5Digest.h"
+#include "BackupStoreFile.h"
 
 namespace BackupStoreFileCreation
@@ -115 +116 @@
         // Buffers
         uint8_t *mpRawBuffer;                           // buffer for raw data
-        uint8_t *mpEncodedBuffer;                       // buffer for encoded data
+        BackupStoreFile::EncodingBuffer mEncodedBuffer;
+                                                                                // buffer for encoded data
         int32_t mAllocatedBufferSize;           // size of above two allocated blocks
         uint64_t mEntryIVBase;                          // base for block entry IV

box/nick/win/lib/backupclient/BackupStoreObjectDump.cpp

@@ -97 +97 @@
                 if((*i)->GetDependsNewer() != 0)
                 {
+#ifdef WIN32
+                        depends_l += ::sprintf(depends + depends_l, " depNew(%I64x)", (*i)->GetDependsNewer());
+#else
                         depends_l += ::sprintf(depends + depends_l, " depNew(%llx)", (*i)->GetDependsNewer());
+#endif
                 }
                 if((*i)->GetDependsOlder() != 0)
                 {
+#ifdef WIN32
+                        depends_l += ::sprintf(depends + depends_l, " depOld(%I64x)", (*i)->GetDependsOlder());
+#else
                         depends_l += ::sprintf(depends + depends_l, " depOld(%llx)", (*i)->GetDependsOlder());
+#endif
                 }
 

box/nick/win/lib/common/Box.h

@@ -83 +83 @@
         #define EXCEPTION_CODENAMES_EXTENDED
         #define EXCEPTION_CODENAMES_EXTENDED_WITH_DESCRIPTION
-
+        
+        // But in private builds, these get disabled
+        // BOX_PRIVATE_BEGIN
+        #undef EXCEPTION_CODENAMES_EXTENDED
+        #undef EXCEPTION_CODENAMES_EXTENDED_WITH_DESCRIPTION
+        // BOX_PRIVATE_END
 #endif
 

box/nick/win/lib/common/BoxPlatform.h

@@ -12 +12 @@
 #define BOXPLATFORM__H
 
+#ifdef WIN32
+#define DIRECTORY_SEPARATOR                     "\\"
+#define DIRECTORY_SEPARATOR_ASCHAR      '\\'
+#else
 #define DIRECTORY_SEPARATOR                     "/"
 #define DIRECTORY_SEPARATOR_ASCHAR      '/'
+#endif
 
 #define PLATFORM_DEV_NULL                       "/dev/null"
@@ -26 +31 @@
 //        -- regex support not available on this platform
 
-
 #ifdef PLATFORM_OPENBSD
 
@@ -135 +139 @@
 
         #define PLATFORM_RANDOM_DEVICE  "/dev/urandom"
+
+        // If large file support is on, can't do the intercepts in the test/raidfile
+        #if _FILE_OFFSET_BITS == 64
+                #define PLATFORM_CLIB_FNS_INTERCEPTION_IMPOSSIBLE
+        #endif
 
 #endif // PLATFORM_LINUX
@@ -184 +193 @@
 #endif // PLATFORM_CYGWIN
 
+#ifdef WIN32
+
+        typedef unsigned __int16 u_int16_t;
+        typedef unsigned __int64 u_int64_t;
+        typedef unsigned __int64 uint64_t;
+        typedef __int64 int64_t;
+        typedef unsigned __int32 uint32_t;
+        typedef unsigned __int32 u_int32_t;
+        typedef __int32 int32_t;
+        typedef unsigned __int16 uint16_t;
+        typedef __int16 int16_t;
+        typedef unsigned __int8 uint8_t;
+        typedef __int8 int8_t;
+
+        typedef unsigned int uid_t;
+        typedef unsigned int gid_t;
+        typedef int pid_t;
+        
+        #define WIN32_LEAN_AND_MEAN
+        #define PLATFORM_BERKELEY_DB_NOT_SUPPORTED
+        //#define BERKELY_V4
+        //any prefs? - to be changed in the future
+        #define COMMAND_PORT 9035
+        //#define PLATFORM_REGEX_NOT_SUPPORTED
+
+        #define PLATFORM_KQUEUE_NOT_SUPPORTED
+        #define PLATFORM_dirent_BROKEN_d_type
+        #define PLATFORM_stat_SHORT_mtime
+        #define PLATFORM_stat_NO_st_flags
+        //#define PLATFORM_USES_MTAB_FILE_FOR_MOUNTS
+        //#define PLATFORM_open_NO_O_EXLOCK
+        #define PLATFORM_sockaddr_NO_len
+        #define PLATFORM_NO_BUILT_IN_SWAP64
+
+    #define PLATFORM_STATIC_TEMP_DIRECTORY_NAME "c:\\tmp"
+
+        #define PLATFORM_READLINE_NOT_SUPPORTED
+        #define PLATFORM_LCHOWN_NOT_SUPPORTED
+
+        #define INFTIM -1
+
+        // File listing canonical interesting mount points.  
+        #define MNTTAB          _PATH_MNTTAB   
+
+        // File listing currently active mount points.  
+        #define MOUNTED         _PATH_MOUNTED   
+
+        #define __need_FILE
+
+        // Extra includes
+    #include "emu.h"
+        //#include <stdint.h>
+        #include <stdlib.h>
+        //#include <netinet/in.h>
+        //#include <sys/socket.h>
+    #include <winsock2.h>
+        #include <sys/stat.h>
+        #include <sys/types.h>
+        //#include <dirent.h>
+        #include <stdio.h>
+        //#include <paths.h>
+    #include <time.h>
+
+        // No easy random entropy source
+        #define PLATFORM_RANDOM_DEVICE_NONE
+
+#endif // WIN32
 
 // Find out if credentials on UNIX sockets can be obtained
@@ -219 +295 @@
 
         #endif
-
+#elif WIN32
+        #define STRUCTURE_PATCKING_FOR_WIRE_USE_HEADERS
 #else
         compiler not supported!
 #endif
 
+//sorry ben I thought the best place was here
+//there was a function referencing ino_t which
+//is a short on win32 - broke it...
+#ifdef WIN32
+typedef u_int64_t InodeRefType;
+#else
+typedef ino_t InodeRefType;
+#endif
 
 #endif // BOXPLATFORM__H

box/nick/win/lib/common/BoxPortsAndFiles.h

@@ -13 +13 @@
 #define BOX_PORT_BASE           2200
 
+// BOX_PRIVATE_BEGIN
+
+// Locator daemon
+#define BOX_PORT_BLOCATORD                                      (BOX_PORT_BASE+0)
+#define BOX_FILE_BLOCATORD                                      "/etc/box/blocatord.conf"
+
+// BOX_PRIVATE_END
+
 // Backup store daemon
 #define BOX_PORT_BBSTORED                                       (BOX_PORT_BASE+1)
@@ -20 +28 @@
 
 // Backup client daemon
+#ifdef WIN32
+#define BOX_FILE_BBACKUPD_DEFAULT_CONFIG        "C:\\Program Files\\Box Backup\\bbackupd.conf"
+#else
 #define BOX_FILE_BBACKUPD_DEFAULT_CONFIG        "/etc/box/bbackupd.conf"
-
+#endif
 
 // RaidFile conf location efault
 #define BOX_FILE_RAIDFILE_DEFAULT_CONFIG        "/etc/box/raidfile.conf"
 
+// BOX_PRIVATE_BEGIN
+
+// smbpasswd authentication daemon (courier-imap authdaemon compatible)
+#define BOX_PORT_BAUTHSMBPWD                            (BOX_PORT_BASE+2)
+#define BOX_FILE_BAUTHSMBPWD_DEFAULT_CONFIG     "/etc/box/bauthsmbpwd.conf"
+
+// Message default config location
+#define BOX_FILE_BOXMSG_DEFAULT_CONFIG          "/etc/box/boxmsg.conf"
+
+// Message daemons
+#define BOX_FILE_BMSGD_DEFAULT_CONFIG           "/etc/box/bmsgd.conf"
+#define BOX_FILE_BMSGRECVD_DEFAULT_CONFIG       "/etc/box/bmsgrecvd.conf"
+#define BOX_PORT_BMSGRECVD                                      (BOX_PORT_BASE+3)
+
+// BOX_PRIVATE_END
+
 #endif // BOXPORTSANDFILES__H
 

box/nick/win/lib/common/BoxTime.h

@@ -32 +32 @@
         return ((box_time_t)Seconds * MICRO_SEC_IN_SEC_LL);
 }
-inline int64_t BoxTimeToSeconds(box_time_t Time)
+inline box_time_t BoxTimeToSeconds(box_time_t Time)
 {
         return Time / MICRO_SEC_IN_SEC_LL;
 }
-inline int64_t BoxTimeToMilliSeconds(box_time_t Time)
+inline box_time_t BoxTimeToMilliSeconds(box_time_t Time)
 {
         return Time / MILLI_SEC_IN_NANO_SEC_LL;

box/nick/win/lib/common/BoxTimeToText.cpp

@@ -28 +28 @@
 std::string BoxTimeToISO8601String(box_time_t Time)
 {
-        time_t timeInSecs = (time_t)BoxTimeToSeconds(Time);
+#ifdef WIN32
+        struct tm *time;
+        box_time_t bob = BoxTimeToSeconds(Time);
+
+        __time64_t winTime = bob;
+
+        time = _gmtime64(&winTime);
+        char str[128];  // more than enough space
+        
+        if ( time == NULL )
+        {
+                //::sprintf(str, "%016I64x ", bob);
+                return std::string("");
+        }
+
+        
+        sprintf(str, "%04d-%02d-%02dT%02d:%02d:%02d", time->tm_year + 1900,
+                time->tm_mon + 1, time->tm_mday, time->tm_hour, time->tm_min, time->tm_sec);
+
+#else
+        box_time_t bob = BoxTimeToSeconds(Time);
+        time_t timeInSecs = bob;
+        //timeInSecs = _time64(NULL);
         struct tm time;
         gmtime_r(&timeInSecs, &time);
@@ -35 +57 @@
         sprintf(str, "%04d-%02d-%02dT%02d:%02d:%02d", time.tm_year + 1900,
                 time.tm_mon + 1, time.tm_mday, time.tm_hour, time.tm_min, time.tm_sec);
-                
+#endif  
         return std::string(str);
 }

box/nick/win/lib/common/BoxTimeToUnix.h

@@ -11 +11 @@
 #define FILEMODIFICATIONTIMETOTIMEVAL__H
 
+#ifdef WIN32
+#include <time.h>
+#else
 #include <sys/time.h>
+#endif
 
 #include "BoxTime.h"

box/nick/win/lib/common/Configuration.cpp

@@ -20 +20 @@
 #include "MemLeakFindOn.h"
 
+#include "FileModificationTime.h"
+
 // utility whitespace function
 inline bool iw(int c)
@@ -30 +32 @@
 static const bool sValueBooleanValue[] = {true, true, false, false};
 
-
-
-// --------------------------------------------------------------------------
-//
-// Function
-//              Name:    Configuration::Configuration(const std::string &)
+// --------------------------------------------------------------------------
+//
+// Function
+//              Name:    Configuration::Configuration(const std::string &, box_time_t)
 //              Purpose: Constructor
 //              Created: 2003/07/23
 //
 // --------------------------------------------------------------------------
-Configuration::Configuration(const std::string &rName)
-        : mName(rName)
-{
-}
-
+Configuration::Configuration(const std::string &rName, box_time_t configModTime)
+        : mName(rName), mConfigModTime(configModTime)
+{
+}
 
 // --------------------------------------------------------------------------
@@ -57 +56 @@
         : mName(rToCopy.mName),
           mSubConfigurations(rToCopy.mSubConfigurations),
-          mKeys(rToCopy.mKeys)
+          mKeys(rToCopy.mKeys),
+          mConfigModTime(rToCopy.mConfigModTime)
 {
 }
@@ -95 +95 @@
         rErrorMsg.erase();
         
+        // Save modification time to be able to distinguish across configuration sets
+        struct stat st;
+        if(::stat(Filename, &st) != 0)
+        {
+                THROW_EXCEPTION(CommonException, OSFileError)
+        }
+
         // Open the file
         FileHandleGuard<O_RDONLY> file(Filename);
@@ -102 +109 @@
         
         // Object to create
-        Configuration *pconfig = new Configuration(std::string("<root>"));
+        Configuration *pconfig = new Configuration(std::string("<root>"), FileModificationTime(st));
         
         try
@@ -177 +184 @@
                         {
                                 // New config object
-                                Configuration config(blockName);
+                                Configuration config(blockName, rConfig.mConfigModTime);
                                 
                                 // Continue processing into this block

box/nick/win/lib/common/Configuration.h

@@ -16 +16 @@
 #include <string>
 #include <memory>
+
+#include "BoxTime.h"
 
 // For defining tests
@@ -59 +61 @@
 {
 private:
-        Configuration(const std::string &rName);
+        Configuration(const std::string &rName, box_time_t configModTime);
 public:
         Configuration(const Configuration &rToCopy);
         ~Configuration();
         
+        box_time_t GetModTime() const { return mConfigModTime; }
+
         enum
         {
@@ -89 +93 @@
         // Order of keys, not preserved
         std::map<std::string, std::string> mKeys;
-        
+protected:
+        box_time_t mConfigModTime;
 private:
         static bool LoadInto(Configuration &rConfig, FdGetLine &rGetLine, std::string &rErrorMsg, bool RootLevel);

box/nick/win/lib/common/Conversion.h

@@ -87 +87 @@
         }
         
+        // Specialise for bool -> string
+        template<>
+        inline std::string Convert<std::string, bool>(bool From)
+        {
+                return std::string(From?"true":"false");
+        }
 };
 

box/nick/win/lib/common/DebugPrintf.cpp

@@ -56 +56 @@
         if(BoxDebugTraceToSyslog)
         {
+#ifdef WIN32            
                 // Remove trailing '\n', if it's there
+                if(r > 0 && text[r-1] == '\n')
+                {
+
+                        text[r-1] = '\0';
+#else
                 if(r > 0 && text[r] == '\n')
                 {
+
                         text[r] = '\0';
+#endif
                         --r;
                 }

box/nick/win/lib/common/ExcludeList.cpp

@@ -9 +9 @@
 
 #include "Box.h"
-
+#ifdef WIN32
+    #include <boost/regex.hpp>
+#else
 #ifndef PLATFORM_REGEX_NOT_SUPPORTED
         #include <regex.h>
         #define EXCLUDELIST_IMPLEMENTATION_REGEX_T_DEFINED
+#endif
 #endif
 
@@ -45 +48 @@
 ExcludeList::~ExcludeList()
 {
+#ifdef WIN32
+        //under win32 and boost - we didn't use pointers so all should aotu distruct.
+#else
 #ifndef PLATFORM_REGEX_NOT_SUPPORTED
         // free regex memory
@@ -55 +61 @@
                 delete pregex;
         }
+#endif
 #endif
 
@@ -107 +114 @@
 void ExcludeList::AddRegexEntries(const std::string &rEntries)
 {
+#ifdef WIN32
+        //Under Win32 we use the boost library for the regular expression matching
+
+        // Split strings up
+        std::vector<std::string> ens;
+        SplitString(rEntries, Configuration::MultiValueSeparator, ens);
+        
+        // Create and add new regular expressions
+        for(std::vector<std::string>::const_iterator i(ens.begin()); i != ens.end(); ++i)
+        {
+                if(i->size() > 0)
+                {
+                        try{
+                                boost::regex ourReg(i->c_str());
+                                this->mRegex.push_back(ourReg);
+                                // Store in list of regular expression string for Serialize
+                                this->mRegexStr.push_back(i->c_str());
+                        }
+                        catch(...)
+                        {
+                                THROW_EXCEPTION(CommonException, BadRegularExpression)
+                        }
+                }
+        }
+#else
 #ifndef PLATFORM_REGEX_NOT_SUPPORTED
 
@@ -131 +163 @@
                                 // Store in list of regular expressions
                                 mRegex.push_back(pregex);
+                                // Store in list of regular expression string for Serialize
+                                mRegexStr.push_back(i->c_str());
                         }
                         catch(...)
@@ -142 +176 @@
 #else
         THROW_EXCEPTION(CommonException, RegexNotSupportedOnThisPlatform)
+#endif
 #endif
 }
@@ -174 +209 @@
         
         // Check against regular expressions
+#ifdef WIN32
+        for(std::vector<boost::regex>::const_iterator i(mRegex.begin()); i != mRegex.end(); ++i)
+        {
+                // Test against this expression
+                try
+                {
+                boost::smatch what;
+                if(boost::regex_match(rTest, what, *i, boost::match_extra))
+                {
+                        // match happened
+                        return true;
+                }
+                // In all other cases, including an error, just continue to the next expression
+                }
+                catch(...)
+                {
+                        //just continue of no match
+                }
+        }
+#else
 #ifndef PLATFORM_REGEX_NOT_SUPPORTED
         for(std::vector<regex_t *>::const_iterator i(mRegex.begin()); i != mRegex.end(); ++i)
@@ -185 +240 @@
                 // In all other cases, including an error, just continue to the next expression
         }
+#endif
 #endif
 
@@ -214 +270 @@
 }
 
-
-        
-
-
+// --------------------------------------------------------------------------
+//
+// Function
+//              Name:    ExcludeList::Deserialize(Archive & rArchive)
+//              Purpose: Deserializes this object instance from a stream of bytes, using an Archive abstraction.
+//
+//              Created: 2005/04/11
+//
+// --------------------------------------------------------------------------
+void ExcludeList::Deserialize(Archive & rArchive)
+{
+        //
+        //
+        //
+        mDefinite.clear();
+
+#ifdef WIN32
+        //under win32 and boost - we didn't use pointers so all should aotu distruct.
+#else
+#ifndef PLATFORM_REGEX_NOT_SUPPORTED
+        // free regex memory
+        while(mRegex.size() > 0)
+        {
+                regex_t *pregex = mRegex.back();
+                mRegex.pop_back();
+                // Free regex storage, and the structure itself
+                ::regfree(pregex);
+                delete pregex;
+        }
+
+        mRegexStr.clear();
+#endif
+#endif
+
+        // Clean up exceptions list
+        if(mpAlwaysInclude != 0)
+        {
+                delete mpAlwaysInclude;
+                mpAlwaysInclude = 0;
+        }
+
+        //
+        //
+        //
+        int64_t iCount = 0;
+        rArchive.Get(iCount);
+
+        if (iCount > 0)
+        {
+                for (int v = 0; v < iCount; v++)
+                {
+                        std::string strItem;
+                        rArchive.Get(strItem);
+
+                        /**** LOAD ****/ mDefinite.insert(strItem);
+                }
+        }
+
+        //
+        //
+        //
+#ifndef PLATFORM_REGEX_NOT_SUPPORTED
+        rArchive.Get(iCount);
+
+        if (iCount > 0)
+        {
+                for (int v = 0; v < iCount; v++)
+                {
+                        std::string strItem;
+                        rArchive.Get(strItem);
+
+#ifdef WIN32
+                        try
+                        {
+                                boost::regex ourReg(strItem.c_str());
+                                this->mRegex.push_back(ourReg);
+                                // Store in list of regular expression string for Serialize
+                                /**** LOAD ****/ this->mRegexStr.push_back(strItem);
+                        }
+                        catch(...)
+                        {
+                                THROW_EXCEPTION(CommonException, BadRegularExpression)
+                        }
+#else
+                        // Allocate memory
+                        regex_t* pregex = new regex_t;
+                        
+                        try
+                        {
+                                // Compile
+                                if(::regcomp(pregex, strItem.c_str(), REG_EXTENDED | REG_NOSUB) != 0)
+                                {
+                                        THROW_EXCEPTION(CommonException, BadRegularExpression)
+                                }
+                                
+                                // Store in list of regular expressions
+                                /**** LOAD ****/ mRegex.push_back(pregex);
+                                // Store in list of regular expression string for Serialize
+                                /**** LOAD ****/ mRegexStr.push_back(strItem);
+                        }
+                        catch(...)
+                        {
+                                delete pregex;
+                                throw;
+                        }
+#endif
+                }
+        }
+#endif // PLATFORM_REGEX_NOT_SUPPORTED
+
+        //
+        //
+        //
+        int64_t aMagicMarker = 0;
+        rArchive.Get(aMagicMarker);
+
+        if (aMagicMarker == ARCHIVE_MAGIC_VALUE_NOOP)
+        {
+                // NOOP
+        }
+        else if (aMagicMarker == ARCHIVE_MAGIC_VALUE_RECURSE)
+        {
+                /**** LOAD ****/ mpAlwaysInclude = new ExcludeList;
+                if (!mpAlwaysInclude)
+                        throw std::bad_alloc();
+
+                mpAlwaysInclude->Deserialize(rArchive);
+        }
+        else
+        {
+                // there is something going on here
+                THROW_EXCEPTION(CommonException, Internal)
+        }
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//              Name:    ExcludeList::Serialize(Archive & rArchive)
+//              Purpose: Serializes this object instance into a stream of bytes, using an Archive abstraction.
+//
+//              Created: 2005/04/11
+//
+// --------------------------------------------------------------------------
+void ExcludeList::Serialize(Archive & rArchive) const
+{
+        //
+        //
+        //
+        int64_t iCount = mDefinite.size();
+        rArchive.Add(iCount);
+
+        for (std::set<std::string>::const_iterator i = mDefinite.begin(); i != mDefinite.end(); i++)
+                rArchive.Add(*i);
+
+        //
+        //
+        //
+#ifndef PLATFORM_REGEX_NOT_SUPPORTED
+        ASSERT(mRegex.size() == mRegexStr.size());      // don't even try to save compiled regular expressions - use string copies
+
+        iCount = mRegexStr.size();
+        rArchive.Add(iCount);
+
+        for (std::vector<std::string>::const_iterator i = mRegexStr.begin(); i != mRegexStr.end(); i++)
+                rArchive.Add(*i);
+#endif // PLATFORM_REGEX_NOT_SUPPORTED
+
+        //
+        //
+        //
+        if (!mpAlwaysInclude)
+        {
+                int64_t aMagicMarker = ARCHIVE_MAGIC_VALUE_NOOP;
+                rArchive.Add(aMagicMarker);
+        }
+        else
+        {
+                int64_t aMagicMarker = ARCHIVE_MAGIC_VALUE_RECURSE; // be explicit about whether recursion follows
+                rArchive.Add(aMagicMarker);
+
+                mpAlwaysInclude->Serialize(rArchive);
+        }
+}

box/nick/win/lib/common/ExcludeList.h

@@ -15 +15 @@
 #include <vector>
 
+#ifdef WIN32
+#include <boost/regex.hpp>
+#else
 // avoid including regex.h in lots of places
 #ifndef EXCLUDELIST_IMPLEMENTATION_REGEX_T_DEFINED
         typedef int regex_t;
 #endif
+#endif
+#include "Archive.h"
 
 // --------------------------------------------------------------------------
@@ -34 +39 @@
         ~ExcludeList();
 
+        void Deserialize(Archive & rArchive);
+        void Serialize(Archive & rArchive) const;
+
         void AddDefiniteEntries(const std::string &rEntries);
         void AddRegexEntries(const std::string &rEntries);
@@ -46 +54 @@
         unsigned int SizeOfDefiniteList() const {return mDefinite.size();}
         unsigned int SizeOfRegexList() const
+#ifdef WIN32
+                //lets be explicit in this
+                {return mRegex.size();}
+#else
 #ifndef PLATFORM_REGEX_NOT_SUPPORTED
                 {return mRegex.size();}
@@ -51 +63 @@
                 {return 0;}
 #endif
+#endif
 
 private:
         std::set<std::string> mDefinite;
+
+#ifdef WIN32
+        std::vector<boost::regex> mRegex;
+        std::vector<std::string> mRegexStr;
+#else
 #ifndef PLATFORM_REGEX_NOT_SUPPORTED
         std::vector<regex_t *> mRegex;
+        std::vector<std::string> mRegexStr;     // save original regular expression string-based source for Serialize
+#endif
 #endif
 

box/nick/win/lib/common/FileStream.cpp

@@ -23 +23 @@
 // --------------------------------------------------------------------------
 FileStream::FileStream(const char *Filename, int flags, int mode)
+#ifdef WIN32
+        : mOSFileHandle(::openfile(Filename, flags, mode)),
+#else
         : mOSFileHandle(::open(Filename, flags, mode)),
+#endif
           mIsEOF(false)
 {
+#ifdef WIN32
+        if(mOSFileHandle == 0)
+#else
         if(mOSFileHandle < 0)
+#endif
         {
                 MEMLEAKFINDER_NOT_A_LEAK(this);
                 THROW_EXCEPTION(CommonException, OSFileOpenError)
         }
+#ifdef WIN32
+        this->fileName = Filename;
+#endif
 }
 
@@ -42 +53 @@
 //
 // --------------------------------------------------------------------------
+#ifdef WIN32
+FileStream::FileStream(HANDLE FileDescriptor)
+#else
 FileStream::FileStream(int FileDescriptor)
+#endif
         : mOSFileHandle(FileDescriptor),
           mIsEOF(false)
@@ -62 +77 @@
 //
 // --------------------------------------------------------------------------
+#ifndef WIN32
 FileStream::FileStream(const FileStream &rToCopy)
         : mOSFileHandle(::dup(rToCopy.mOSFileHandle)),
@@ -72 +88 @@
         }
 }
-
+#endif
 // --------------------------------------------------------------------------
 //
@@ -99 +115 @@
 int FileStream::Read(void *pBuffer, int NBytes, int Timeout)
 {
-        if(mOSFileHandle == -1) {THROW_EXCEPTION(CommonException, FileClosed)}
+        if(mOSFileHandle == INVALID_FILE) {THROW_EXCEPTION(CommonException, FileClosed)}
+
+#ifdef WIN32
+        int r;
+        DWORD numBytesRead = 0;
+        BOOL valid = ReadFile(
+                this->mOSFileHandle,
+                pBuffer,
+                NBytes,
+                &numBytesRead,
+                NULL
+                );
+
+        if ( valid )
+        {
+        r = numBytesRead;
+        }
+        else
+        {
+                r = -1;
+        }
+#else
         int r = ::read(mOSFileHandle, pBuffer, NBytes);
+#endif
         if(r == -1)
         {
@@ -144 +182 @@
 void FileStream::Write(const void *pBuffer, int NBytes)
 {
-        if(mOSFileHandle == -1) {THROW_EXCEPTION(CommonException, FileClosed)}
+        if(mOSFileHandle == INVALID_FILE) {THROW_EXCEPTION(CommonException, FileClosed)}
+#ifdef WIN32
+        DWORD numBytesWritten = 0;
+        BOOL res = WriteFile(
+                this->mOSFileHandle,
+                pBuffer,
+                NBytes,
+                &numBytesWritten,
+                NULL
+                );
+
+        if ( (res == 0) || (numBytesWritten != NBytes))
+        {
+                DWORD err = GetLastError();
+                THROW_EXCEPTION(CommonException, OSFileWriteError)
+        }
+
+
+#else
         if(::write(mOSFileHandle, pBuffer, NBytes) != NBytes)
         {
                 THROW_EXCEPTION(CommonException, OSFileWriteError)
         }
+#endif
 }
 
@@ -162 +219 @@
 IOStream::pos_type FileStream::GetPosition() const
 {
-        if(mOSFileHandle == -1) {THROW_EXCEPTION(CommonException, FileClosed)}
+#ifdef WIN32
+        LARGE_INTEGER conv;
+
+        conv.HighPart = 0;
+        conv.LowPart = 0;
+
+        conv.LowPart = SetFilePointer(this->mOSFileHandle, 0, &conv.HighPart, FILE_CURRENT);
+
+        return (IOStream::pos_type)conv.QuadPart;
+
+#else
+        if(mOSFileHandle == INVALID_FILE) {THROW_EXCEPTION(CommonException, FileClosed)}
         off_t p = ::lseek(mOSFileHandle, 0, SEEK_CUR);
         if(p == -1)
@@ -170 +238 @@
         
         return (IOStream::pos_type)p;
+#endif
 }
 
@@ -183 +252 @@
 void FileStream::Seek(IOStream::pos_type Offset, int SeekType)
 {
-        if(mOSFileHandle == -1) {THROW_EXCEPTION(CommonException, FileClosed)}
+        if(mOSFileHandle == INVALID_FILE) {THROW_EXCEPTION(CommonException, FileClosed)}
+
+#ifdef WIN32
+        LARGE_INTEGER conv;
+
+        conv.QuadPart = Offset;
+        DWORD retVal = SetFilePointer(this->mOSFileHandle, conv.LowPart, &conv.HighPart, ConvertSeekTypeToOSWhence(SeekType));
+
+        if ( retVal == INVALID_SET_FILE_POINTER && (GetLastError() != NO_ERROR) )
+        {
+                THROW_EXCEPTION(CommonException, OSFileError)
+        }
+#else
         if(::lseek(mOSFileHandle, Offset, ConvertSeekTypeToOSWhence(SeekType)) == -1)
         {
                 THROW_EXCEPTION(CommonException, OSFileError)
         }
-        
+#endif
         // Not end of file any more!
         mIsEOF = false;
@@ -208 +289 @@
                 THROW_EXCEPTION(CommonException, FileAlreadyClosed)
         }
+#ifdef WIN32
+        if(::CloseHandle(mOSFileHandle) == 0)
+        {
+                THROW_EXCEPTION(CommonException, OSFileCloseError)
+        }
+        mOSFileHandle = NULL;
+        mIsEOF = true;
+#else
         if(::close(mOSFileHandle) != 0)
         {
@@ -214 +303 @@
         mOSFileHandle = -1;
         mIsEOF = true;
+#endif
+        
 }
 

box/nick/win/lib/common/FileStream.h

@@ -18 +18 @@
 #include <unistd.h>
 
+#ifdef WIN32
+#define INVALID_FILE NULL
+#else
+#define INVALID_FILE -1
+#endif
+
 class FileStream : public IOStream
 {
 public:
+#ifdef WIN32
+        FileStream(const char *Filename, int flags = (O_RDONLY | O_BINARY), int mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH));
+        FileStream(HANDLE FileDescriptor);
+#else
         FileStream(const char *Filename, int flags = O_RDONLY, int mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH));
         FileStream(int FileDescriptor);
         FileStream(const FileStream &rToCopy);
+#endif
+        
         virtual ~FileStream();
         
@@ -37 +49 @@
 
 private:
+#ifdef WIN32
+        HANDLE mOSFileHandle;
+        //for debugging..
+        std::string fileName;
+#else
         int mOSFileHandle;
+#endif
         bool mIsEOF;
 };

box/nick/win/lib/common/IOStream.cpp

@@ -106 +106 @@
         switch(SeekType)
         {
+#ifdef WIN32
+        case SeekType_Absolute:
+                ostype = FILE_BEGIN;
+                break;
+        case SeekType_Relative:
+                ostype = FILE_CURRENT;
+                break;
+        case SeekType_End:
+                ostype = FILE_END;
+                break;
+#else
         case SeekType_Absolute:
                 ostype = SEEK_SET;
@@ -115 +126 @@
                 ostype = SEEK_END;
                 break;
+#endif
         
         default:

box/nick/win/lib/crypto/CipherBlowfish.cpp

@@ -111 +111 @@
 CipherBlowfish::~CipherBlowfish()
 {
+#ifdef PLATFORM_OLD_OPENSSL
+        // Zero copy of key
+        for(unsigned int l = 0; l < mKey.size(); ++l)
+        {
+                mKey[l] = '\0';
+        }
+#endif
 }
 

box/nick/win/lib/crypto/CipherException.txt

@@ -16 +16 @@
 EVPSetPaddingFailure                            13
 RandomInitFailed                                        14      Failed to read from random device
+LengthRequestedTooLongForRandomHex      15

box/nick/win/lib/crypto/Random.cpp

@@ -60 +60 @@
 //
 // Function
+//              Name:    Random::GenerateHex(int)
+//              Purpose: Generate Length bytes of hex encoded data. Note that the
+//                               maximum length requested is limited. (Returns a string
+//                               2 x Length characters long.)
+//              Created: 1/11/04
+//
+// --------------------------------------------------------------------------
+std::string Random::GenerateHex(int Length)
+{
+        uint8_t r[256];
+        if(Length > sizeof(r))
+        {
+                THROW_EXCEPTION(CipherException, LengthRequestedTooLongForRandomHex)
+        }
+        Random::Generate(r, Length);
+        
+        std::string o;
+        static const char *h = "0123456789abcdef";
+        for(int l = 0; l < Length; ++l)
+        {
+                o += h[r[l] >> 4];
+                o += h[r[l] & 0xf];
+        }
+        
+        return o;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
 //              Name:    Random::RandomInt(int)
 //              Purpose: Return a random integer between 0 and MaxValue inclusive.

box/nick/win/lib/crypto/Random.h

@@ -11 +11 @@
 #define RANDOM__H
 
+#include <string>
+
 namespace Random
 {
         void Initialise();
         void Generate(void *pOutput, int Length);
+        std::string GenerateHex(int Length);
         uint32_t RandomInt(uint32_t MaxValue);
 };

box/nick/win/lib/raidfile/RaidFileWrite.cpp

@@ -183 +183 @@
         
         // Use lseek to find the current file position
-        off_t p = ::lseek(mOSFileHandle, SEEK_CUR, 0);
+        off_t p = ::lseek(mOSFileHandle, 0, SEEK_CUR);
         if(p == -1)
         {

box/nick/win/lib/server/Daemon.cpp

@@ -140 +140 @@
                 // Let the derived class have a go at setting up stuff in the initial process
                 SetupInInitialProcess();
-                
+#ifndef WIN32           
                 // Set signal handler
                 if(::signal(SIGHUP, SignalHandler) == SIG_ERR || ::signal(SIGTERM, SignalHandler) == SIG_ERR)
@@ -216 +216 @@
                         }
                 }
+#endif
 
                 // open the log
@@ -222 +223 @@
                 ::syslog(LOG_INFO, "Starting daemon (config: %s) (version " BOX_VERSION ")", configfile);
 
+#ifndef WIN32
                 // Write PID to file
                 char pid[32];
@@ -230 +232 @@
                         THROW_EXCEPTION(ServerException, DaemoniseFailed)
                 }
+#endif
                 
                 // Set up memory leak reporting
@@ -242 +245 @@
                 if(asDaemon)
                 {
+#ifndef WIN32
                         // Close standard streams
                         ::close(0);
                         ::close(1);
                         ::close(2);
-                        
+                
                         // Open and redirect them into /dev/null
                         int devnull = ::open(PLATFORM_DEV_NULL, O_RDWR, 0);
@@ -262 +266 @@
                                 ::close(devnull);
                         }
-                        
+#endif                  
                         // And definately don't try and send anything to those file descriptors
                         // -- this has in the past sent text to something which isn't expecting it.
@@ -354 +358 @@
 void Daemon::EnterChild()
 {
+#ifndef WIN32
         // Unset signal handlers
         ::signal(SIGHUP, SIG_DFL);
         ::signal(SIGTERM, SIG_DFL);
+#endif
 }
 
@@ -370 +376 @@
 void Daemon::SignalHandler(int sigraised)
 {
+#ifndef WIN32
         if(spDaemon != 0)
         {
@@ -386 +393 @@
                 }
         }
+#endif
 }
 

box/nick/win/lib/server/LocalProcessStream.cpp

@@ -10 +10 @@
 #include "Box.h"
 
+#ifndef WIN32
 #include <sys/socket.h>
+#endif
 #include <unistd.h>
 
@@ -37 +39 @@
         std::vector<std::string> command;
         SplitString(std::string(CommandLine), ' ', command);
+#ifndef WIN32
         // Build arguments
         char *args[MAX_ARGUMENTS + 4];
@@ -95 +98 @@
         rPidOut = pid;
         return stream;  
+#else
+        ::syslog(LOG_ERR, "vfork not implimented - LocalProcessStream.cpp");
+        std::auto_ptr<IOStream> stream;
+        return stream;
+#endif
+
 }
 

box/nick/win/lib/server/ServerStream.h

@@ -121 +121 @@
                         {
                                 // Get the address we need to bind to
-                                const Configuration &config(GetConfiguration());
+                                // this-> in next line required to build under some gcc versions
+                                const Configuration &config(this->GetConfiguration());
                                 const Configuration &server(config.GetSubConfiguration("Server"));
                                 std::string addrs = server.GetKeyValue("ListenAddresses");

box/nick/win/lib/server/ServerTLS.h

@@ -47 +47 @@
                 // First, set up the SSL context.
                 // Get parameters from the configuration
-                const Configuration &conf(GetConfiguration());
+                // this-> in next line required to build under some gcc versions
+                const Configuration &conf(this->GetConfiguration());
                 const Configuration &serverconf(conf.GetSubConfiguration("Server"));
                 std::string certFile(serverconf.GetKeyValue("CertificateFile"));
@@ -61 +62 @@
         {
                 rStream.Handshake(mContext, true /* is server */);
-                Connection(rStream);
+                // this-> in next line required to build under some gcc versions
+                this->Connection(rStream);
         }
         

box/nick/win/lib/server/Socket.cpp

@@ -12 +12 @@
 #include <unistd.h>
 #include <sys/types.h>
+#ifndef WIN32
 #include <sys/socket.h>
 #include <netdb.h>
@@ -17 +18 @@
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#endif
 
 #include <string.h>
@@ -72 +74 @@
                 }
                 break;
-        
+
+#ifndef WIN32
         case TypeUNIX:
                 sockDomain = AF_UNIX;
@@ -90 +93 @@
                 }
                 break;
-                
+#endif
+
         default:
                 THROW_EXCEPTION(CommonException, BadArguments)

box/nick/win/lib/server/Socket.h

@@ -11 +11 @@
 #define SOCKET__H
 
+#ifdef WIN32
+#include "emu.h"
+typedef int socklen_t;
+#else
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <sys/un.h>
+#endif
 
 #include <string>
@@ -20 +25 @@
         struct sockaddr sa_generic;
         struct sockaddr_in sa_inet;
+#ifndef WIN32
         struct sockaddr_un sa_unix;
+#endif
 } SocketAllAddr;
 

box/nick/win/lib/server/SocketListen.h

@@ -95 +95 @@
                 if(mSocketHandle != -1)
                 {
+#ifdef WIN32
+                        if(::closesocket(mSocketHandle) == -1)
+#else
                         if(::close(mSocketHandle) == -1)
+#endif
                         {
                                 THROW_EXCEPTION(ServerException, SocketCloseError)
@@ -129 +133 @@
                 
                 // Set an option to allow reuse (useful for -HUP situations!)
+#ifdef WIN32
+                if(::setsockopt(mSocketHandle, SOL_SOCKET, SO_REUSEADDR, "", 0) == -1)
+#else
                 int option = true;
                 if(::setsockopt(mSocketHandle, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) == -1)
+#endif
                 {
                         THROW_EXCEPTION(ServerException, SocketOpenError)

box/nick/win/lib/server/SocketStream.cpp

@@ -141 +141 @@
         {
                 // Dispose of the socket
+#ifdef WIN32
+                ::closesocket(mSocketHandle);
+#else
                 ::close(mSocketHandle);
+#endif
                 mSocketHandle = -1;
                 THROW_EXCEPTION(ConnectionException, Conn_SocketConnectError)
@@ -192 +196 @@
         }
 
+#ifdef WIN32
+        int r = ::recv(mSocketHandle, (char*)pBuffer, NBytes, 0);
+#else
         int r = ::read(mSocketHandle, pBuffer, NBytes);
+#endif
         if(r == -1)
         {
@@ -237 +245 @@
         {
                 // Try to send.
+#ifdef WIN32
+                int sent = ::send(mSocketHandle, buffer, bytesLeft, 0);
+#else
                 int sent = ::write(mSocketHandle, buffer, bytesLeft);
+#endif
                 if(sent == -1)
                 {
@@ -284 +296 @@
 {
         if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
-        
+#ifdef WIN32
+        if(::closesocket(mSocketHandle) == -1)
+#elif
         if(::close(mSocketHandle) == -1)
+#endif
         {
                 THROW_EXCEPTION(ServerException, SocketCloseError)
@@ -355 +370 @@
 //
 // --------------------------------------------------------------------------
+#ifdef WIN32
+SOCKET SocketStream::GetSocketHandle()
+#else
 int SocketStream::GetSocketHandle()
+#endif
 {
         if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}

box/nick/win/lib/server/SocketStream.h

@@ -43 +43 @@
 
 protected:
+#ifdef WIN32
+        SOCKET GetSocketHandle();
+#else
         int GetSocketHandle();
+#endif
         void MarkAsReadClosed() {mReadClosed = true;}
         void MarkAsWriteClosed() {mWriteClosed = true;}
 
 private:
+#ifdef WIN32
+        SOCKET mSocketHandle;
+#else
         int mSocketHandle;
+#endif
         bool mReadClosed;
         bool mWriteClosed;

box/nick/win/lib/server/SocketStreamTLS.cpp

@@ -15 +15 @@
 #include <poll.h>
 #include <errno.h>
+#ifndef WIN32
 #include <sys/ioctl.h>
+#endif
 
 #include "SocketStreamTLS.h"
@@ -121 +123 @@
                 THROW_EXCEPTION(ServerException, TLSAllocationFailed)
         }
+#ifdef WIN32
+        SOCKET socket = GetSocketHandle();
+#else
         int socket = GetSocketHandle();
+#endif
         BIO_set_fd(mpBIO, socket, BIO_NOCLOSE);
         

box/nick/win/lib/server/makeprotocol.pl

@@ -312 +312 @@
         ~$classname_base$cmd();
         int GetType() const;
+        enum
+        {
+                TypeID = $cmd_id{$cmd}
+        };
 __E
         # constants
@@ -522 +526 @@
         virtual ~$classname_base();
 
+        std::auto_ptr<$derive_objects_from> Receive();
+        void Send(const ${derive_objects_from} &rObject);
 __E
 if($implement_syslog)
@@ -649 +655 @@
 }
 __E
+# write receieve and send functions
+print CPP <<__E;
+std::auto_ptr<$derive_objects_from> ${prefix}Receive()
+{
+        std::auto_ptr<${derive_objects_from}> preply((${derive_objects_from}*)(Protocol::Receive().release()));
+
+__E
+        if($implement_syslog)
+        {
+                print CPP <<__E;
+        if(mLogToSysLog)
+        {
+                preply->LogSysLog("Receive");
+        }
+__E
+        }
+        if($implement_filelog)
+        {
+                print CPP <<__E;
+        if(mLogToFile != 0)
+        {
+                preply->LogFile("Receive", mLogToFile);
+        }
+__E
+        }
+print CPP <<__E;
+
+        return preply;
+}
+
+void ${prefix}Send(const ${derive_objects_from} &rObject)
+{
+__E
+        if($implement_syslog)
+        {
+                print CPP <<__E;
+        if(mLogToSysLog)
+        {
+                rObject.LogSysLog("Send");
+        }
+__E
+        }
+        if($implement_filelog)
+        {
+                print CPP <<__E;
+        if(mLogToFile != 0)
+        {
+                rObject.LogFile("Send", mLogToFile);
+        }
+__E
+        }
+
+print CPP <<__E;
+        Protocol::Send(rObject);
+}
+
+__E
 # write server function?
 if($type eq 'Server')
@@ -663 +726 @@
         {
                 // Get an object from the conversation
-                std::auto_ptr<ProtocolObject> o1(Receive());
-                std::auto_ptr<${derive_objects_from}> pobj((${derive_objects_from}*)o1.release());
+                std::auto_ptr<${derive_objects_from}> pobj(Receive());
 
 __E
@@ -802 +864 @@
 std::auto_ptr<$classname_base$reply> ${classname_base}::Query(const $classname_base$cmd &rQuery$argextra)
 {
-__E
-        if($implement_syslog)
-        {
-                print CPP <<__E;
-        if(mLogToSysLog)
-        {
-                rQuery.LogSysLog("Send");
-        }
-__E
-        }
-        if($implement_filelog)
-        {
-                print CPP <<__E;
-        if(mLogToFile != 0)
-        {
-                rQuery.LogFile("Send", mLogToFile);
-        }
-__E
-        }
-        print CPP <<__E;
-        
         // Send query
         Send(rQuery);
         $send_stream_extra
         // Wait for the reply
-        std::auto_ptr<${derive_objects_from}> preply((${derive_objects_from}*)(Receive().release()));
-
-__E
-        if($implement_syslog)
-        {
-                print CPP <<__E;
-        if(mLogToSysLog)
-        {
-                preply->LogSysLog("Receive");
-        }
-__E
-        }
-        if($implement_filelog)
-        {
-                print CPP <<__E;
-        if(mLogToFile != 0)
-        {
-                preply->LogFile("Receive", mLogToFile);
-        }
-__E
-        }
-        print CPP <<__E;
-
+        std::auto_ptr<${derive_objects_from}> preply(Receive().release());
 
         if(preply->GetType() == $reply_id)

box/nick/win/modules.txt

@@ -48 +48 @@
 # END_IF_DISTRIBUTION
 
+

box/nick/win/test/basicserver/testbasicserver.cpp

@@ -350 +350 @@
         for(unsigned int c = 0; c < conns.size(); ++c)
         {
-                delete getline[c];
-        }
-        delete [] getline;
+                if ( getline[c] ) delete getline[c];
+                getline[c] = 0;
+        }
+        if ( getline ) delete [] getline;
+        getline = 0;
 }
 

box/nick/win/test/bbackupd/testbbackupd.cpp

@@ -374 +374 @@
                 TEST_THAT(::mkdir("testfiles/TestDir1/symlink-to-dir", 0755) == 0);
                 TEST_THAT(::mkdir("testfiles/TestDir1/x1/dir-to-file", 0755) == 0);
+                // NOTE: create a file within the directory to avoid deletion by the housekeeping process later
+                TEST_THAT(::symlink("does-not-exist", "testfiles/TestDir1/x1/dir-to-file/contents") == 0);
                 wait_for_backup_operation();
                 compareReturnValue = ::system("../../bin/bbackupquery/bbackupquery -q -c testfiles/bbackupd.conf -l testfiles/query3s.log \"compare -ac\" quit");
@@ -381 +383 @@
                 // And the inverse, replace a directory with a file/symlink
                 printf("Replace directory with symlink\n");
+                TEST_THAT(::unlink("testfiles/TestDir1/x1/dir-to-file/contents") == 0);
                 TEST_THAT(::rmdir("testfiles/TestDir1/x1/dir-to-file") == 0);
                 TEST_THAT(::symlink("does-not-exist", "testfiles/TestDir1/x1/dir-to-file") == 0);
@@ -386 +389 @@
                 compareReturnValue = ::system("../../bin/bbackupquery/bbackupquery -q -c testfiles/bbackupd.conf -l testfiles/query3s.log \"compare -ac\" quit");
                 TEST_THAT(compareReturnValue == 1*256);
-                TestRemoteProcessMemLeaks("bbackupquery.memleaks");             
-                
+                TestRemoteProcessMemLeaks("bbackupquery.memleaks");
+                
+                // And then, put it back to how it was before.
+                printf("Replace symlink with directory (which was a symlink)\n");
+                TEST_THAT(::unlink("testfiles/TestDir1/x1/dir-to-file") == 0);
+                TEST_THAT(::mkdir("testfiles/TestDir1/x1/dir-to-file", 0755) == 0);
+                TEST_THAT(::symlink("does-not-exist", "testfiles/TestDir1/x1/dir-to-file/contents2") == 0);
+                wait_for_backup_operation();
+                compareReturnValue = ::system("../../bin/bbackupquery/bbackupquery -q -c testfiles/bbackupd.conf -l testfiles/query3s.log \"compare -ac\" quit");
+                TEST_THAT(compareReturnValue == 1*256);
+                TestRemoteProcessMemLeaks("bbackupquery.memleaks");
+                
+                // And finally, put it back to how it was before it was put back to how it was before
+                // This gets lots of nasty things in the store with directories over other old directories.
+                printf("Put it all back to how it was\n");
+                TEST_THAT(::unlink("testfiles/TestDir1/x1/dir-to-file/contents2") == 0);
+                TEST_THAT(::rmdir("testfiles/TestDir1/x1/dir-to-file") == 0);
+                TEST_THAT(::symlink("does-not-exist", "testfiles/TestDir1/x1/dir-to-file") == 0);
+                wait_for_backup_operation();
+                compareReturnValue = ::system("../../bin/bbackupquery/bbackupquery -q -c testfiles/bbackupd.conf -l testfiles/query3s.log \"compare -ac\" quit");
+                TEST_THAT(compareReturnValue == 1*256);
+                TestRemoteProcessMemLeaks("bbackupquery.memleaks");
+
                 // case which went wrong: rename a tracked file over a deleted file
                 printf("Rename an existing file over a deleted file\n");