Changeset 710

Timestamp:

28/07/2006 00:18:35 (6 years ago)

Author:

chris

Message:

• merge
• This is my current patch queue. I think that all of these are safe to apply. This is just under half of the pending changes in chris/general (the easy half).

Location:

box/chris/merge

Files:

• bin/bbackupctl/bbackupctl.cpp (modified) (5 diffs)
• bin/bbackupd/BackupClientContext.cpp (modified) (1 diff)
• bin/bbackupd/BackupClientDirectoryRecord.cpp (modified) (2 diffs)
• bin/bbackupd/BackupDaemon.cpp (modified) (20 diffs)
• bin/bbackupd/BackupDaemon.h (modified) (2 diffs)
• bin/bbackupd/Win32BackupService.cpp (modified) (2 diffs)
• bin/bbackupd/Win32BackupService.h (modified) (1 diff)
• bin/bbackupd/Win32ServiceFunctions.cpp (modified) (10 diffs)
• bin/bbackupd/Win32ServiceFunctions.h (modified) (1 diff)
• bin/bbackupd/bbackupd.cpp (modified) (4 diffs)
• bin/bbackupquery/BackupQueries.cpp (modified) (23 diffs)
• bin/bbackupquery/BackupQueries.h (modified) (1 diff)
• bin/bbackupquery/documentation.txt (modified) (1 diff)
• bin/bbstored/BBStoreDHousekeeping.cpp (modified) (5 diffs)
• bin/bbstored/BackupCommands.cpp (modified) (6 diffs)
• bin/bbstored/BackupContext.cpp (modified) (4 diffs)
• bin/bbstored/BackupStoreDaemon.cpp (modified) (6 diffs)
• bin/bbstored/BackupStoreDaemon.h (modified) (4 diffs)
• bin/bbstored/HousekeepStoreAccount.cpp (modified) (7 diffs)
• configure.ac (modified) (6 diffs)
• docs/backup/win32_build_on_linux_using_mingw.txt (modified) (3 diffs)
• infrastructure/BoxPlatform.pm.in (modified) (4 diffs)
• infrastructure/buildenv-testmain-template.cpp (modified) (2 diffs)
• infrastructure/makebuildenv.pl.in (modified) (21 diffs)
• infrastructure/msvc/2003/boxbackup.ncb (deleted)
• infrastructure/msvc/2003/boxbackup.suo (deleted)
• lib/backupclient/BackupClientFileAttributes.cpp (modified) (2 diffs)
• lib/backupclient/BackupStoreFile.cpp (modified) (1 diff)
• lib/backupclient/BackupStoreObjectDump.cpp (modified) (1 diff)
• lib/backupstore/BackupStoreAccounts.cpp (modified) (1 diff)
• lib/backupstore/BackupStoreCheck.cpp (modified) (2 diffs)
• lib/common/BoxPlatform.h (modified) (2 diffs)
• lib/common/FdGetLine.h (modified) (1 diff)
• lib/common/Guards.h (modified) (1 diff)
• lib/common/UnixUser.cpp (modified) (4 diffs)
• lib/common/makeexception.pl.in (modified) (3 diffs)
• lib/raidfile/RaidFileRead.cpp (modified) (8 diffs)
• lib/raidfile/RaidFileWrite.cpp (modified) (10 diffs)
• lib/server/Daemon.cpp (modified) (11 diffs)
• lib/server/ServerStream.h (modified) (5 diffs)
• lib/server/SocketStream.cpp (modified) (13 diffs)
• lib/server/SocketStream.h (modified) (1 diff)
• lib/server/SocketStreamTLS.cpp (modified) (2 diffs)
• lib/server/makeprotocol.pl.in (modified) (4 diffs)
• runtest.pl.in (modified) (6 diffs)
• test/backupdiff/testbackupdiff.cpp (modified) (10 diffs)
• test/backupstore/testbackupstore.cpp (modified) (26 diffs)
• test/backupstorefix/testfiles/testbackupstorefix.pl.in (modified) (2 diffs)
• test/backupstorepatch/testbackupstorepatch.cpp (modified) (6 diffs)
• test/basicserver/TestCommands.cpp (modified) (1 diff)
• test/basicserver/testbasicserver.cpp (modified) (15 diffs)
• test/bbackupd/testbbackupd.cpp (modified) (1 diff)
• test/bbackupd/testfiles/bbackupd.conf (deleted)
• test/bbackupd/testfiles/bbackupd.conf.in (copied) (copied from box/trunk/test/bbackupd/testfiles/bbackupd.conf)
• test/bbackupd/testfiles/extcheck1.pl.in (modified) (2 diffs)
• test/bbackupd/testfiles/extcheck2.pl.in (modified) (2 diffs)
• test/common/testcommon.cpp (modified) (2 diffs)
• test/raidfile/intercept.cpp (modified) (1 diff)
• test/raidfile/testraidfile.cpp (modified) (24 diffs)
• test/win32/testlibwin32.cpp (modified) (8 diffs)
• win32.bat (modified) (2 diffs)

box/chris/merge/bin/bbackupctl/bbackupctl.cpp

@@ -33 +33 @@
         printf("Usage: bbackupctl [-q] [-c config_file] <command>\n"
         "Commands are:\n"
-        "  sync -- start a syncronisation run now\n"
-        "  force-sync -- force the start of a syncronisation run, "
+        "  sync -- start a synchronisation (backup) run now\n"
+        "  force-sync -- force the start of a synchronisation run, "
         "even if SyncAllowScript says no\n"
         "  reload -- reload daemon configuration\n"
         "  terminate -- terminate daemon now\n"
         "  wait-for-sync -- wait until the next sync starts, then exit\n"
+        "  wait-for-end  -- wait until the next sync finishes, then exit\n"
+        "  sync-and-wait -- start sync, wait until it finishes, then exit\n"
         );
         exit(1);
@@ -108 +110 @@
         if(!conf.KeyExists("CommandSocket"))
         {
-                printf("Daemon isn't using a control socket, could not execute command.\nAdd a CommandSocket declaration to the bbackupd.conf file.\n");
+                printf("Daemon isn't using a control socket, "
+                        "could not execute command.\n"
+                        "Add a CommandSocket declaration to the "
+                        "bbackupd.conf file.\n");
                 return 1;
         }
@@ -189 +194 @@
         if(!quiet)
         {
-                printf("Daemon configuration summary:\n"        \
-                           "  AutomaticBackup = %s\n"                   \
-                           "  UpdateStoreInterval = %d seconds\n"       \
-                           "  MinimumFileAge = %d seconds\n"    \
-                           "  MaxUploadWait = %d seconds\n",
-                           autoBackup?"true":"false", updateStoreInterval, minimumFileAge, maxUploadWait);
+                printf("Daemon configuration summary:\n"
+                        "  AutomaticBackup = %s\n"
+                        "  UpdateStoreInterval = %d seconds\n"
+                        "  MinimumFileAge = %d seconds\n"
+                        "  MaxUploadWait = %d seconds\n",
+                        autoBackup?"true":"false", updateStoreInterval, 
+                        minimumFileAge, maxUploadWait);
+        }
+
+        std::string stateLine;
+        if(!getLine.GetLine(stateLine) || getLine.IsEOF())
+        {
+#if defined WIN32 && ! defined NDEBUG
+                syslog(LOG_ERR, "Failed to receive state line from daemon");
+#else
+                printf("Failed to receive state line from daemon\n");
+#endif
+                return 1;
+        }
+
+        // Decode it
+        int currentState;
+        if(::sscanf(stateLine.c_str(), "state %d", &currentState) != 1)
+        {
+                printf("State line didn't decode\n");
+                return 1;
         }
 
         // Is the command the "wait for sync to start" command?
         bool areWaitingForSync = false;
-        if(::strcmp(argv[0], "wait-for-sync") == 0)
-        {
-                // Check that it's not in non-automatic mode, because then it'll never start
+        bool areWaitingForSyncEnd = false;
+
+        if(::strcmp(argv[0], "wait-for-sync") == 0 ||
+           ::strcmp(argv[0], "wait-for-end") == 0)
+        {
+                // Check that it's not in non-automatic mode, 
+                // because then it'll never start
                 if(!autoBackup)
                 {
-                        printf("ERROR: Daemon is not in automatic mode -- sync will never start!\n");
+                        printf("ERROR: Daemon is not in automatic mode -- "
+                                "sync will never start!\n");
                         return 1;
                 }
         
-                // Yes... set the flag so we know what we're waiting for a sync to start
-                areWaitingForSync = true;
+                // Yes... set the flag so we know that 
+                // we're waiting for a sync to start/end
+                if(::strcmp(argv[0], "wait-for-sync") == 0)
+                {
+                        areWaitingForSync = true;
+                }
+                else if (::strcmp(argv[0], "wait-for-end") == 0)
+                {
+                        areWaitingForSyncEnd = true;
+                }
+        }
+        else if (::strcmp(argv[0], "sync-and-wait") == 0)
+        {
+                // send a sync command
+                std::string cmd("force-sync\n");
+                connection.Write(cmd.c_str(), cmd.size());
+                connection.WriteAllBuffered();
+                areWaitingForSyncEnd = true;
+
+                if (currentState != 0)
+                {
+                        printf("Waiting for current sync/error state "
+                                "to finish...\n");
+                }
         }
         else
@@ -221 +273 @@
         // Read the response
         std::string line;
+        bool syncIsRunning = false;
+
         while(!getLine.IsEOF() && getLine.GetLine(line))
         {
@@ -235 +289 @@
                         }               
                 }
+                else if(areWaitingForSyncEnd)
+                {
+                        if(line == "start-sync")
+                        {
+                                if (!quiet) printf("Sync started...\n");
+                                syncIsRunning = true;
+                        }
+                        else if(line == "finish-sync" && syncIsRunning)
+                        {
+                                if (!quiet) printf("Sync finished.\n");
+                                // Send a quit command to finish nicely
+                                connection.Write("quit\n", 5);
+                                
+                                // And we're done
+                                break;
+                        }
+                        else if(line == "finish-sync")
+                        {
+                                if (!quiet) printf("Previous sync finished.\n");
+                        }
+                        // daemon must still be busy
+                }
                 else
                 {

box/chris/merge/bin/bbackupd/BackupClientContext.cpp

@@ -177 +177 @@
                         mStorageLimitExceeded = true;
                         // Log
-                        ::syslog(LOG_INFO, "Exceeded storage limits on server -- not uploading changes to files");
+                        ::syslog(LOG_WARNING, "Exceeded storage limits on server -- not uploading changes to files");
                 }
         }

box/chris/merge/bin/bbackupd/BackupClientDirectoryRecord.cpp

@@ -646 +646 @@
                 //
                 // Condition for upload:
-                //    modifiction time within sync period
+                //    modification time within sync period
                 //    if it's been seen before but not uploaded, is the time from this first sight longer than the MaxUploadWait
                 //        and if we know about it from a directory listing, that it hasn't got the same upload time as on the store
-                if(
-                        (
-                                // Check the file modified within the acceptable time period we're checking
-                                // If the file isn't on the server, the acceptable time starts at zero.
-                                // Check pDirOnStore and en, because if we didn't download a directory listing,
-                                // pDirOnStore will be zero, but we know it's on the server.
-                                ( ((pDirOnStore != 0 && en == 0) || (modTime >= rParams.mSyncPeriodStart)) && modTime < rParams.mSyncPeriodEnd)
-
-                                // However, just in case things are continually modified, we check the first seen time.
-                                // The two compares of syncPeriodEnd and pendingFirstSeenTime are because the values are unsigned.
-                                || (pendingFirstSeenTime != 0 &&
-                                        (rParams.mSyncPeriodEnd > pendingFirstSeenTime)
-                                                && ((rParams.mSyncPeriodEnd - pendingFirstSeenTime) > rParams.mMaxUploadWait))
-
-                                // Then make sure that if files are added with a time less than the sync period start
-                                // (which can easily happen on file server), it gets uploaded. The directory contents checksum
-                                // will pick up the fact it has been added, so the store listing will be available when this happens.
-                                || ((modTime <= rParams.mSyncPeriodStart) && (en != 0) && (en->GetModificationTime() != modTime))
-                                
-                                // And just to catch really badly off clocks in the future for file server clients,
-                                // just upload the file if it's madly in the future.
-                                || (modTime > rParams.mUploadAfterThisTimeInTheFuture)
-                        )                       
-                        // But even then, only upload it if the mod time locally is different to that on the server.
-                        && (en == 0 || en->GetModificationTime() != modTime))
+
+                bool doUpload = false;
+
+                // Only upload a file if the mod time locally is 
+                // different to that on the server.
+
+                if (en == 0 || en->GetModificationTime() != modTime)
+                {
+                        // Check the file modified within the acceptable time period we're checking
+                        // If the file isn't on the server, the acceptable time starts at zero.
+                        // Check pDirOnStore and en, because if we didn't download a directory listing,
+                        // pDirOnStore will be zero, but we know it's on the server.
+                        if (modTime < rParams.mSyncPeriodEnd)
+                        {
+                                if (pDirOnStore != 0 && en == 0)
+                                {
+                                        doUpload = true;
+                                }
+                                else if (modTime >= rParams.mSyncPeriodStart)
+                                {
+                                        doUpload = true;
+                                }
+                        }
+
+                        // However, just in case things are continually 
+                        // modified, we check the first seen time.
+                        // The two compares of syncPeriodEnd and 
+                        // pendingFirstSeenTime are because the values 
+                        // are unsigned.
+
+                        if (!doUpload && 
+                                pendingFirstSeenTime != 0 &&
+                                rParams.mSyncPeriodEnd > pendingFirstSeenTime &&
+                                (rParams.mSyncPeriodEnd - pendingFirstSeenTime) 
+                                > rParams.mMaxUploadWait)
+                        {
+                                doUpload = true;
+                        }
+
+                        // Then make sure that if files are added with a 
+                        // time less than the sync period start
+                        // (which can easily happen on file server), it 
+                        // gets uploaded. The directory contents checksum
+                        // will pick up the fact it has been added, so the 
+                        // store listing will be available when this happens.
+
+                        if (!doUpload &&
+                                modTime <= rParams.mSyncPeriodStart && 
+                                en != 0 && 
+                                en->GetModificationTime() != modTime)
+                        {
+                                doUpload = true;
+                        }
+
+                        // And just to catch really badly off clocks in 
+                        // the future for file server clients,
+                        // just upload the file if it's madly in the future.
+
+                        if (!doUpload && modTime > 
+                                rParams.mUploadAfterThisTimeInTheFuture)
+                        {
+                                doUpload = true;
+                        }
+                }
+
+                if (doUpload)
                 {
                         // Make sure we're connected -- must connect here so we know whether
@@ -1023 +1064 @@
                                         mSubDirectories.erase(e);
                                         delete rec;
-                                        TRACE2("Deleted directory record for %s/%s\n", rLocalPath.c_str(), dirname.GetClearFilename().c_str());
+                                        TRACE2("Deleted directory record for "
+                                                "%s" DIRECTORY_SEPARATOR "%s\n",
+                                                rLocalPath.c_str(), 
+                                                dirname.GetClearFilename().c_str());
                                 }                               
                         }

box/chris/merge/bin/bbackupd/BackupDaemon.cpp

@@ -126 +126 @@
 
 #ifdef WIN32
+        // Create the event object to signal from main thread to worker
+        // when new messages are queued to be sent to the command socket.
+        mhMessageToSendEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+        if (mhMessageToSendEvent == INVALID_HANDLE_VALUE)
+        {
+                syslog(LOG_ERR, "Failed to create event object: error %d",
+                        GetLastError);
+                exit(1);
+        }
+
+        // Create the event object to signal from worker to main thread
+        // when a command has been received on the command socket.
+        mhCommandReceivedEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+        if (mhCommandReceivedEvent == INVALID_HANDLE_VALUE)
+        {
+                syslog(LOG_ERR, "Failed to create event object: error %d",
+                        GetLastError);
+                exit(1);
+        }
+
+        // Create the critical section to protect the message queue
+        InitializeCriticalSection(&mMessageQueueLock);
+
         // Create a thread to handle the named pipe
         HANDLE hThread;
@@ -264 +287 @@
 {
         mpCommandSocketInfo = new CommandSocketInfo;
-        this->mReceivedCommandConn = false;
+        WinNamedPipeStream& rSocket(mpCommandSocketInfo->mListeningSocket);
 
         // loop until the parent process exits
-        while (TRUE)
+        while (!IsTerminateWanted())
         {
                 try
                 {
-                        mpCommandSocketInfo->mListeningSocket.Accept(
-                                BOX_NAMED_PIPE_NAME);
+                        rSocket.Accept(BOX_NAMED_PIPE_NAME);
+                }
+                catch (BoxException &e)
+                {
+                        ::syslog(LOG_ERR, "Failed to open command socket: %s",
+                                e.what());
+                        SetTerminateWanted();
+                        break; // this is fatal
+                }
+                catch (...)
+                {
+                        ::syslog(LOG_ERR, "Failed to open command socket: "
+                                "unknown error");
+                        SetTerminateWanted();
+                        break; // this is fatal
+                }
+
+                try
+                {
+                        // Errors here do not kill the thread,
+                        // only the current connection.
 
                         // This next section comes from Ben's original function
@@ -290 +332 @@
                                 mState);
 
-                        mpCommandSocketInfo->mListeningSocket.Write(summary, summarySize);
-                        mpCommandSocketInfo->mListeningSocket.Write("ping\n", 5);
-
-                        IOStreamGetLine readLine(mpCommandSocketInfo->mListeningSocket);
+                        rSocket.Write(summary, summarySize);
+                        rSocket.Write("ping\n", 5);
+
+                        // old queued messages are not useful
+                        EnterCriticalSection(&mMessageQueueLock);
+                        mMessageList.clear();
+                        ResetEvent(mhMessageToSendEvent);
+                        LeaveCriticalSection(&mMessageQueueLock);
+
+                        IOStreamGetLine readLine(rSocket);
                         std::string command;
 
-                        while (mpCommandSocketInfo->mListeningSocket.IsConnected() &&
-                               readLine.GetLine(command) )
-                        {
-                                TRACE1("Receiving command '%s' over "
-                                        "command socket\n", command.c_str());
+                        while (rSocket.IsConnected() && !IsTerminateWanted())
+                        {
+                                HANDLE handles[2];
+                                handles[0] = mhMessageToSendEvent;
+                                handles[1] = rSocket.GetReadableEvent();
+
+                                DWORD result = WaitForMultipleObjects(
+                                        sizeof(handles)/sizeof(*handles),
+                                        handles, FALSE, 1000);
+
+                                if (result == 0)
+                                {
+                                        ResetEvent(mhMessageToSendEvent);
+
+                                        EnterCriticalSection(&mMessageQueueLock);
+                                        try
+                                        {
+                                                while (mMessageList.size() > 0)
+                                                {
+                                                        std::string message = *(mMessageList.begin());
+                                                        mMessageList.erase(mMessageList.begin());
+                                                        printf("Sending '%s' to waiting client... ", message.c_str());
+                                                        message += "\n";
+                                                        rSocket.Write(message.c_str(),
+                                                                message.length());
+
+                                                        printf("done.\n");
+                                                }
+                                        }
+                                        catch (...)
+                                        {
+                                                LeaveCriticalSection(&mMessageQueueLock);
+                                                throw;
+                                        }
+                                        LeaveCriticalSection(&mMessageQueueLock);
+                                        continue;
+                                }
+                                else if (result == WAIT_TIMEOUT)
+                                {
+                                        continue;
+                                }
+                                else if (result != 1)
+                                {
+                                        ::syslog(LOG_ERR, "WaitForMultipleObjects returned invalid result %d", result);
+                                        continue;
+                                }
+
+                                if (!readLine.GetLine(command))
+                                {
+                                        ::syslog(LOG_ERR, "Failed to read line");
+                                        continue;
+                                }
+
+                                printf("Received command '%s' from client\n", command.c_str());
 
                                 bool sendOK = false;
@@ -339 +436 @@
                                         sendOK = true;
                                 }
+                                else
+                                {
+                                        ::syslog(LOG_ERR, "Received unknown command '%s' from client", command.c_str());
+                                        sendResponse = true;
+                                        sendOK = false;
+                                }
 
                                 // Send a response back?
@@ -344 +447 @@
                                 {
                                         const char* response = sendOK ? "ok\n" : "error\n";
-                                        mpCommandSocketInfo->mListeningSocket.Write(
+                                        rSocket.Write(
                                                 response, strlen(response));
                                 }
@@ -353 +456 @@
                                 }
 
-                                this->mReceivedCommandConn = true;
-                        }
-
-                        mpCommandSocketInfo->mListeningSocket.Close();
+                                // this->mReceivedCommandConn = true;
+                        }
+
+                        rSocket.Close();
                 }
                 catch (BoxException &e)
@@ -505 +608 @@
         // haven't contacted the store yet
 
-        bool deserialised = DeserializeStoreObjectInfo(clientStoreMarker, 
-                lastSyncTime, nextSyncTime);
+        bool deleteStoreObjectInfoFile = DeserializeStoreObjectInfo(
+                clientStoreMarker, lastSyncTime, nextSyncTime);
  
         // --------------------------------------------------------------------------------------------
@@ -612 +715 @@
                         // so that we don't try to reload it after a
                         // partially completed backup
-                        if(deserialised && !DeleteStoreObjectInfo())
+                        if(deleteStoreObjectInfoFile && 
+                                !DeleteStoreObjectInfo())
                         {
                                 ::syslog(LOG_ERR, "Failed to delete the "
@@ -622 +726 @@
                                 continue;
                         }
+
+                        // In case the backup throws an exception,
+                        // we should not try to delete the store info
+                        // object file again.
+                        deleteStoreObjectInfoFile = false;
                         
                         // Do sync
@@ -730 +839 @@
                                 // --------------------------------------------------------------------------------------------
 
-                                // We had a successful backup, save the store info
-                                SerializeStoreObjectInfo(clientStoreMarker, lastSyncTime, nextSyncTime);
+                                // We had a successful backup, save the store 
+                                // info. If we save successfully, we must 
+                                // delete the file next time we start a backup
+
+                                deleteStoreObjectInfoFile = 
+                                        SerializeStoreObjectInfo(
+                                                clientStoreMarker, 
+                                                lastSyncTime, nextSyncTime);
 
                                 // --------------------------------------------------------------------------------------------
@@ -903 +1018 @@
 {
 #ifdef WIN32
-        // Really could use some interprocess protection, mutex etc
-        // any side effect should be too bad???? :)
-        DWORD timeout = (DWORD)BoxTimeToMilliSeconds(RequiredDelay);
-
-        while ( this->mReceivedCommandConn == false )
-        {
-                Sleep(1);
-
-                if ( timeout == 0 )
-                {
-                        DoSyncFlagOut = false;
-                        SyncIsForcedOut = false;
-                        return;
-                }
-                timeout--;
-        }
-        this->mReceivedCommandConn = false;
-        DoSyncFlagOut = this->mDoSyncFlagOut;
-        SyncIsForcedOut = this->mSyncIsForcedOut;
+        DWORD requiredDelayMs = BoxTimeToMilliSeconds(RequiredDelay);
+
+        DWORD result = WaitForSingleObject(mhCommandReceivedEvent, 
+                (DWORD)requiredDelayMs);
+
+        if (result == WAIT_OBJECT_0)
+        {
+                DoSyncFlagOut = this->mDoSyncFlagOut;
+                SyncIsForcedOut = this->mSyncIsForcedOut;
+                ResetEvent(mhCommandReceivedEvent);
+        }
+        else if (result == WAIT_TIMEOUT)
+        {
+                DoSyncFlagOut = false;
+                SyncIsForcedOut = false;
+        }
+        else
+        {
+                ::syslog(LOG_ERR, "Unexpected result from "
+                        "WaitForSingleObject: error %d", GetLastError());
+        }
 
         return;
@@ -954 +1071 @@
 #ifdef PLATFORM_CANNOT_FIND_PEER_UID_OF_UNIX_SOCKET
                                 bool uidOK = true;
-                                ::syslog(LOG_WARNING, "On this platform, no security check can be made on the credientials of peers connecting to the command socket. (bbackupctl)");
+                                ::syslog(LOG_WARNING, "On this platform, no security check can be made on the credentials of peers connecting to the command socket. (bbackupctl)");
 #else
                                 // Security check -- does the process connecting to this socket have
@@ -1024 +1141 @@
                         && mpCommandSocketInfo->mpGetLine->GetLine(command, false /* no preprocessing */, timeout))
                 {
-                        TRACE1("Receiving command '%s' over command socket\n", command.c_str());
-                        
+                        TRACE1("Receiving command '%s' over command socket\n", 
+                                command.c_str());
+
+                        #ifdef WIN32
+                        SetEvent(mhCommandReceivedEvent);
+                        #endif
+
                         bool sendOK = false;
                         bool sendResponse = true;
@@ -1138 +1260 @@
 void BackupDaemon::SendSyncStartOrFinish(bool SendStart)
 {
-        // The bbackupctl program can't rely on a state change, because it may never
-        // change if the server doesn't need to be contacted.
-
-#ifdef __MINGW32__
-#warning race condition: what happens if socket is closed?
-#endif
+        // The bbackupctl program can't rely on a state change, because it 
+        // may never change if the server doesn't need to be contacted.
 
         if (mpCommandSocketInfo != NULL &&
@@ -1153 +1271 @@
             )
         {
-                const char* message = SendStart ? "start-sync\n" : "finish-sync\n";
+                std::string message = SendStart ? "start-sync" : "finish-sync";
                 try
                 {
 #ifdef WIN32
-                        mpCommandSocketInfo->mListeningSocket.Write(message, 
-                                (int)strlen(message));
+                        EnterCriticalSection(&mMessageQueueLock);
+                        mMessageList.push_back(message);
+                        SetEvent(mhMessageToSendEvent);
+                        LeaveCriticalSection(&mMessageQueueLock);
 #else
-                        mpCommandSocketInfo->mpConnectedSocket->Write(message,
-                                strlen(message));
+                        message += "\n";
+                        mpCommandSocketInfo->mpConnectedSocket->Write(
+                                message.c_str(), message.size());
 #endif
                 }
@@ -1757 +1878 @@
 
         char newState[64];
-        char newStateSize = sprintf(newState, "state %d\n", State);
+        sprintf(newState, "state %d", State);
+        std::string message = newState;
 
 #ifdef WIN32
-        #ifndef _MSC_VER
-                #warning FIX ME: race condition
-        #endif
-
-        // what happens if the socket is closed by the other thread before
-        // we can write to it? Null pointer deref at best.
-        if (mpCommandSocketInfo && 
-            mpCommandSocketInfo->mListeningSocket.IsConnected())
-        {
-                try
-                {
-                        mpCommandSocketInfo->mListeningSocket.Write(newState, newStateSize);
-                }
-                catch(...)
-                {
-                        CloseCommandConnection();
-                }
-        }
+        EnterCriticalSection(&mMessageQueueLock);
+        mMessageList.push_back(newState);
+        SetEvent(mhMessageToSendEvent);
+        LeaveCriticalSection(&mMessageQueueLock);
 #else
-        if(mpCommandSocketInfo != 0 && mpCommandSocketInfo->mpConnectedSocket.get() != 0)
-        {
-                // Something connected to the command socket, tell it about the new state
-                try
-                {
-                        mpCommandSocketInfo->mpConnectedSocket->Write(newState, newStateSize);
-                }
-                catch(...)
-                {
-                        CloseCommandConnection();
-                }
+        message += "\n";
+
+        if(mpCommandSocketInfo == 0)
+        {
+                return;
+        }
+
+        if (mpCommandSocketInfo->mpConnectedSocket.get() == 0)
+        {
+                return;
+        }
+
+        // Something connected to the command socket, tell it about the new state
+        try
+        {
+                mpCommandSocketInfo->mpConnectedSocket->Write(message.c_str(),
+                        message.length());
+        }
+        catch(...)
+        {
+                CloseCommandConnection();
         }
 #endif
@@ -2174 +2292 @@
 static const int STOREOBJECTINFO_VERSION = 1;
 
-void BackupDaemon::SerializeStoreObjectInfo(int64_t aClientStoreMarker, box_time_t theLastSyncTime, box_time_t theNextSyncTime) const
+bool BackupDaemon::SerializeStoreObjectInfo(int64_t aClientStoreMarker, box_time_t theLastSyncTime, box_time_t theNextSyncTime) const
 {
         if(!GetConfiguration().KeyExists("StoreObjectInfoFile"))
         {
-                return;
+                return false;
         }
 
@@ -2186 +2304 @@
         if (StoreObjectInfoFile.size() <= 0)
         {
-                return;
-        }
+                return false;
+        }
+
+        bool created = false;
 
         try
@@ -2193 +2313 @@
                 FileStream aFile(StoreObjectInfoFile.c_str(), 
                         O_WRONLY | O_CREAT | O_TRUNC);
+                created = true;
+
                 Archive anArchive(aFile, 0);
 
@@ -2237 +2359 @@
                         StoreObjectInfoFile.c_str());
         }
+
+        return created;
 }
 

box/chris/merge/bin/bbackupd/BackupDaemon.h

@@ -47 +47 @@
 
 private:
-        // methods below do partial (specialized) serialization of client state only
-        void SerializeStoreObjectInfo(int64_t aClientStoreMarker, box_time_t theLastSyncTime, box_time_t theNextSyncTime) const;
-        bool DeserializeStoreObjectInfo(int64_t & aClientStoreMarker, box_time_t & theLastSyncTime, box_time_t & theNextSyncTime);
+        // methods below do partial (specialized) serialization of 
+        // client state only
+        bool SerializeStoreObjectInfo(int64_t aClientStoreMarker, 
+                box_time_t theLastSyncTime, box_time_t theNextSyncTime) const;
+        bool DeserializeStoreObjectInfo(int64_t & aClientStoreMarker, 
+                box_time_t & theLastSyncTime, box_time_t & theNextSyncTime);
         bool DeleteStoreObjectInfo() const;
         BackupDaemon(const BackupDaemon &);
@@ -183 +186 @@
 
         private:
-        bool mDoSyncFlagOut, mSyncIsForcedOut, mReceivedCommandConn;
+        bool mDoSyncFlagOut, mSyncIsForcedOut;
+        HANDLE mhMessageToSendEvent, mhCommandReceivedEvent;
+        CRITICAL_SECTION mMessageQueueLock;
+        std::vector<std::string> mMessageList;
 #endif
 };

box/chris/merge/bin/bbackupd/Win32BackupService.cpp

@@ -13 +13 @@
 #include "Win32BackupService.h"
 
-Win32BackupService gDaemonService;
+Win32BackupService* gpDaemonService = NULL;
 extern HANDLE gStopServiceEvent;
 
 unsigned int WINAPI RunService(LPVOID lpParameter)
 {
-        DWORD retVal = gDaemonService.WinService();
-        SetEvent( gStopServiceEvent );
+        DWORD retVal = gpDaemonService->WinService((const char*) lpParameter);
+        SetEvent(gStopServiceEvent);
         return retVal;
 }
@@ -25 +25 @@
 void TerminateService(void)
 {
-        gDaemonService.SetTerminateWanted();
+        gpDaemonService->SetTerminateWanted();
 }
 
-DWORD Win32BackupService::WinService(void)
+DWORD Win32BackupService::WinService(const char* pConfigFileName)
 {
-        int argc = 2;
-        //first off get the path name for the default 
-        char buf[MAX_PATH];
+        char exepath[MAX_PATH];
+        GetModuleFileName(NULL, exepath, sizeof(exepath));
+
+        std::string configfile;
         
-        GetModuleFileName(NULL, buf, sizeof(buf));
-        std::string buffer(buf);
-        std::string conf( "-c");
-        std::string cfile(buffer.substr(0,(buffer.find("bbackupd.exe"))) 
-                        + "bbackupd.conf");
+        if (pConfigFileName != NULL)
+        {
+                configfile = pConfigFileName;
+        }
+        else
+        {
+                // make the default config file name,
+                // based on the program path
+                configfile = exepath;
+                configfile = configfile.substr(0,
+                        configfile.rfind(DIRECTORY_SEPARATOR_ASCHAR));
+                configfile += DIRECTORY_SEPARATOR "bbackupd.conf";
+        }
 
-        const char *argv[] = {conf.c_str(), cfile.c_str()};
+        const char *argv[] = {exepath, "-c", configfile.c_str()};
+        int argc = sizeof(argv) / sizeof(*argv);
+        DWORD ret;
 
         MAINHELPER_START
+        ret = this->Main(BOX_FILE_BBACKUPD_DEFAULT_CONFIG, argc, argv);
+        MAINHELPER_END
 
-        return this->Main(BOX_FILE_BBACKUPD_DEFAULT_CONFIG, argc, argv);
-
-        MAINHELPER_END
+        return ret;
 }
 

box/chris/merge/bin/bbackupd/Win32BackupService.h

@@ -13 +13 @@
 {
 public:
-        DWORD WinService(void);
+        DWORD WinService(const char* pConfigFileName);
 };
 

box/chris/merge/bin/bbackupd/Win32ServiceFunctions.cpp

@@ -94 +94 @@
 // service cannot start if there is an eror.
 
+static char* spConfigFileName;
+
 VOID ServiceMain(DWORD argc, LPTSTR *argv) 
 {
-    // initialise service status
-    gServiceStatus.dwServiceType = SERVICE_WIN32;
-    gServiceStatus.dwCurrentState = SERVICE_STOPPED;
-    gServiceStatus.dwControlsAccepted = 0;
-    gServiceStatus.dwWin32ExitCode = NO_ERROR;
-    gServiceStatus.dwServiceSpecificExitCode = NO_ERROR;
-    gServiceStatus.dwCheckPoint = 0;
-    gServiceStatus.dwWaitHint = 0;
-
-    gServiceStatusHandle = RegisterServiceCtrlHandler(gServiceName, 
-        ServiceControlHandler);
-
-    if (gServiceStatusHandle)
-    {
-        // service is starting
-        gServiceStatus.dwCurrentState = SERVICE_START_PENDING;
-        SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
-
-        // do initialisation here
-        gStopServiceEvent = CreateEvent( 0, TRUE, FALSE, 0 );
+        // initialise service status
+        gServiceStatus.dwServiceType = SERVICE_WIN32;
+        gServiceStatus.dwCurrentState = SERVICE_STOPPED;
+        gServiceStatus.dwControlsAccepted = 0;
+        gServiceStatus.dwWin32ExitCode = NO_ERROR;
+        gServiceStatus.dwServiceSpecificExitCode = NO_ERROR;
+        gServiceStatus.dwCheckPoint = 0;
+        gServiceStatus.dwWaitHint = 0;
+
+        gServiceStatusHandle = RegisterServiceCtrlHandler(gServiceName, 
+                ServiceControlHandler);
+
+        if (gServiceStatusHandle)
+        {
+                // service is starting
+                gServiceStatus.dwCurrentState = SERVICE_START_PENDING;
+                SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
+
+                // do initialisation here
+                gStopServiceEvent = CreateEvent(0, TRUE, FALSE, 0);
                 if (!gStopServiceEvent)
                 {
@@ -130 +132 @@
                         0,
                         RunService,
-                        0,
+                        spConfigFileName,
                         CREATE_SUSPENDED,
                         NULL);
@@ -139 +141 @@
                 // we are now running so tell the SCM
                 gServiceStatus.dwControlsAccepted |= 
-                (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
+                        (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
                 gServiceStatus.dwCurrentState = SERVICE_RUNNING;
                 SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
@@ -157 +159 @@
                 gServiceStatus.dwCurrentState = SERVICE_STOPPED;
                 SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
-    }
-}
-
-void OurService(void)
-{
+        }
+}
+
+void OurService(char* pConfigFileName)
+{
+        spConfigFileName = pConfigFileName;
+
         SERVICE_TABLE_ENTRY serviceTable[] = 
         { 
@@ -180 +184 @@
 }
 
-void InstallService(void)
-{
-        SC_HANDLE newService, scm;
-
-        scm = OpenSCManager(0,0,SC_MANAGER_CREATE_SERVICE);
+int InstallService(const char* pConfigFileName)
+{
+        if (pConfigFileName != NULL)
+        {
+                struct stat st;
+
+                if (emu_stat(pConfigFileName, &st) != 0)
+                {
+                        syslog(LOG_ERR, "Failed to open configuration file: "
+                                "%s: %s", pConfigFileName, strerror(errno));
+                        return 1;
+                }
+
+                if (! st.st_mode & S_IFREG)
+                {
+        
+                        syslog(LOG_ERR, "Failed to open configuration file: "
+                                "%s: not a file", pConfigFileName);
+                        return 1;
+                }
+        }
+
+        SC_HANDLE scm = OpenSCManager(0,0,SC_MANAGER_CREATE_SERVICE);
 
         if (!scm) 
@@ -190 +212 @@
                 syslog(LOG_ERR, "Failed to open service control manager: "
                         "error %d", GetLastError());
-                return;
+                return 1;
         }
 
@@ -197 +219 @@
         cmd[sizeof(cmd)-1] = 0;
 
-        char cmd_args[MAX_PATH];
-        _snprintf(cmd_args, sizeof(cmd_args)-1, "%s --service", cmd);
-        cmd_args[sizeof(cmd_args)-1] = 0;
-
-        newService = CreateService(
+        std::string cmdWithArgs(cmd);
+        cmdWithArgs += " --service";
+
+        if (pConfigFileName != NULL)
+        {
+                cmdWithArgs += " \"";
+                cmdWithArgs += pConfigFileName;
+                cmdWithArgs += "\"";
+        }
+
+        SC_HANDLE newService = CreateService(
                 scm, 
                 SERVICE_NAME, 
@@ -209 +237 @@
                 SERVICE_AUTO_START, 
                 SERVICE_ERROR_NORMAL, 
-                cmd_args, 
+                cmdWithArgs.c_str(),
                 0,0,0,0,0);
 
+        DWORD err = GetLastError();
+        CloseServiceHandle(scm);
+
         if (!newService) 
         {
-                ::syslog(LOG_ERR, "Failed to create Box Backup service: "
-                        "error %d", GetLastError());
-                return;
+                if (err == ERROR_SERVICE_EXISTS)
+                {
+                        ::syslog(LOG_ERR, "Failed to create Box Backup "
+                                "service: it already exists");
+                }
+                else if (err == ERROR_SERVICE_MARKED_FOR_DELETE)
+                {
+                        ::syslog(LOG_ERR, "Failed to create Box Backup "
+                                "service: it is waiting to be deleted");
+                }
+                else if (err == ERROR_DUPLICATE_SERVICE_NAME)
+                {
+                        ::syslog(LOG_ERR, "Failed to create Box Backup "
+                                "service: a service with this name "
+                                "already exists");
+                }
+                else
+                {
+                        ::syslog(LOG_ERR, "Failed to create Box Backup "
+                                "service: error %d", err);
+                }
+                return 1;
         }
 
@@ -232 +282 @@
 
         CloseServiceHandle(newService);
-        CloseServiceHandle(scm);
-}
-
-void RemoveService(void)
-{
-        SC_HANDLE service, scm;
-        SERVICE_STATUS status;
-
-        scm = OpenSCManager(0,0,SC_MANAGER_CREATE_SERVICE);
+
+        return 0;
+}
+
+int RemoveService(void)
+{
+        SC_HANDLE scm = OpenSCManager(0,0,SC_MANAGER_CREATE_SERVICE);
 
         if (!scm) 
@@ -246 +294 @@
                 syslog(LOG_ERR, "Failed to open service control manager: "
                         "error %d", GetLastError());
-                return;
-        }
-
-        service = OpenService(scm, SERVICE_NAME, SERVICE_ALL_ACCESS|DELETE);
-        ControlService(service, SERVICE_CONTROL_STOP, &status);
+                return 1;
+        }
+
+        SC_HANDLE service = OpenService(scm, SERVICE_NAME, 
+                SERVICE_ALL_ACCESS|DELETE);
+        DWORD err = GetLastError();
+        CloseServiceHandle(scm);
 
         if (!service)
         {
-                syslog(LOG_ERR, "Failed to open Box Backup service: "
-                        "error %d", GetLastError());
-                return;
-        }
-
-        if (DeleteService(service))
+                if (err == ERROR_SERVICE_DOES_NOT_EXIST ||
+                        err == ERROR_IO_PENDING) 
+                        // hello microsoft? anyone home?
+                {
+                        syslog(LOG_ERR, "Failed to open Box Backup service: "
+                                "not installed or not found");
+                }
+                else
+                {
+                        syslog(LOG_ERR, "Failed to open Box Backup service: "
+                                "error %d", err);
+                }
+                return 1;
+        }
+
+        SERVICE_STATUS status;
+        if (!ControlService(service, SERVICE_CONTROL_STOP, &status))
+        {
+                err = GetLastError();
+                if (err != ERROR_SERVICE_NOT_ACTIVE)
+                {
+                        syslog(LOG_WARNING, "Failed to stop Box Backup "
+                                "service: error %d", err);
+                }
+        }
+
+        BOOL deleted = DeleteService(service);
+        err = GetLastError();
+        CloseServiceHandle(service);
+
+        if (deleted)
         {
                 syslog(LOG_INFO, "Box Backup service deleted");
+                return 0;
+        }
+        else if (err == ERROR_SERVICE_MARKED_FOR_DELETE)
+        {
+                syslog(LOG_ERR, "Failed to remove Box Backup service: "
+                        "it is already being deleted");
         }
         else
         {
                 syslog(LOG_ERR, "Failed to remove Box Backup service: "
-                        "error %d", GetLastError());
-        }
-
-        CloseServiceHandle(service);
-        CloseServiceHandle(scm);
+                        "error %d", err);
+        }
+
+        return 1;
 }
 

box/chris/merge/bin/bbackupd/Win32ServiceFunctions.h

@@ -13 +13 @@
 #define WIN32SERVICEFUNCTIONS_H
 
-void RemoveService(void);
-void InstallService(void);
-void OurService(void);
+int  RemoveService(void);
+int  InstallService(const char* pConfigFilePath);
+void OurService(char* pConfigFileName);
 
 #endif

box/chris/merge/bin/bbackupd/bbackupd.cpp

@@ -20 +20 @@
         #include "Win32BackupService.h"
 
-        extern Win32BackupService gDaemonService;
+        extern Win32BackupService* gpDaemonService;
 #endif
 
@@ -29 +29 @@
 #ifdef WIN32
 
-        ::openlog("Box Backup (bbackupd)", 0, 0);
+        ::openlog("Box Backup (bbackupd)", LOG_PID, LOG_LOCAL6);
 
         if(argc == 2 &&
@@ -41 +41 @@
         if(argc == 2 && ::strcmp(argv[1], "-r") == 0)
         {
-                RemoveService();
-                return 0;
+                return RemoveService();
         }
-        if(argc == 2 && ::strcmp(argv[1], "-i") == 0)
+        if((argc == 2 || argc == 3) && ::strcmp(argv[1], "-i") == 0)
         {
-                InstallService();
-                return 0;
+                const char* config = NULL;
+                if (argc == 3)
+                {
+                        config = argv[2];
+                }
+                return InstallService(config);
         }
 
         bool runAsWin32Service = false;
-        if (argc == 2 && ::strcmp(argv[1], "--service") == 0)
+        if (argc >= 2 && ::strcmp(argv[1], "--service") == 0)
         {
                 runAsWin32Service = true;
         }
-        
-        // Under win32 we must initialise the Winsock library
-        // before using sockets
-                
-        WSADATA info;
 
-        if (WSAStartup(0x0101, &info) == SOCKET_ERROR) 
-        {
-                // box backup will not run without sockets
-                ::syslog(LOG_ERR, "Failed to initialise Windows Sockets");
-                THROW_EXCEPTION(BackupStoreException, Internal)
-        }
+        gpDaemonService = new Win32BackupService();
 
         EnableBackupRights();
@@ -74 +67 @@
         if (runAsWin32Service)
         {
-                syslog(LOG_INFO,"Starting Box Backup Service");
-                OurService();
+                syslog(LOG_INFO, "Box Backup service starting");
+
+                char* config = NULL;
+                if (argc >= 3)
+                {
+                        config = strdup(argv[2]);
+                }
+
+                OurService(config);
+
+                if (config)
+                {
+                        free(config);
+                }
+
+                syslog(LOG_INFO, "Box Backup service shut down");
         }
         else
         {
-                ExitCode = gDaemonService.Main(
+                ExitCode = gpDaemonService->Main(
                         BOX_FILE_BBACKUPD_DEFAULT_CONFIG, argc, argv);
         }
 
-        // Clean up our sockets
-        WSACleanup();
+        ::closelog();
 
-        ::closelog();
+        delete gpDaemonService;
 
         return ExitCode;

box/chris/merge/bin/bbackupquery/BackupQueries.cpp

@@ -71 +71 @@
           mReturnCode(0)                // default return code
 {
+        #ifdef WIN32
+        mRunningAsRoot = TRUE;
+        #else
         mRunningAsRoot = (::geteuid() == 0);
+        #endif
 }
 
@@ -85 +89 @@
 {
 }
+
+typedef struct cmd_info
+{
+        const char* name;
+        const char* opts;
+} cmd_info_t;
 
 // --------------------------------------------------------------------------
@@ -163 +173 @@
         
         // Data about commands
-        static const char *commandNames[] = {"quit", "exit", "list",     "pwd", "cd", "lcd",    "sh", "getobject", "get", "compare", "restore", "help", "usage", "undelete", 0};
-        static const char *validOptions[] = {"",         "",     "rodIFtsh", "",           "od", "",    "",       "",              "i",   "alcqE",   "dri",     "",     "",      "",             0};
+        static cmd_info_t commands[] = 
+        {
+                { "quit", "" },
+                { "exit", "" },
+                { "list", "rodIFtTsh", },
+                { "pwd",  "" },
+                { "cd",   "od" },
+                { "lcd",  "" },
+                { "sh",   "" },
+                { "getobject", "" },
+                { "get",  "i" },
+                { "compare", "alcqAE" },
+                { "restore", "dri" },
+                { "help", "" },
+                { "usage", "" },
+                { "undelete", "" },
+                { NULL, NULL } 
+        };
         #define COMMAND_Quit            0
         #define COMMAND_Exit            1
@@ -184 +210 @@
         // Work out which command it is...
         int cmd = 0;
-        while(commandNames[cmd] != 0 && ::strcmp(cmdElements[0].c_str(), commandNames[cmd]) != 0)
+        while(commands[cmd].name != 0 && ::strcmp(cmdElements[0].c_str(), commands[cmd].name) != 0)
         {
                 cmd++;
         }
-        if(commandNames[cmd] == 0)
+        if(commands[cmd].name == 0)
         {
                 // Check for aliases
@@ -223 +249 @@
                 {
                         // Valid option?
-                        if(::strchr(validOptions[cmd], *c) == NULL)
-                        {
-                                printf("Invalid option '%c' for command %s\n", *c, commandNames[cmd]);
+                        if(::strchr(commands[cmd].opts, *c) == NULL)
+                        {
+                                printf("Invalid option '%c' for command %s\n", 
+                                        *c, commands[cmd].name);
                                 return;
                         }
@@ -320 +347 @@
         #define LIST_OPTION_ALLOWDELETED        'd'
         #define LIST_OPTION_NOOBJECTID          'I'
-        #define LIST_OPTION_NOFLAGS                     'F'
-        #define LIST_OPTION_TIMES                       't'
+        #define LIST_OPTION_NOFLAGS             'F'
+        #define LIST_OPTION_TIMES_LOCAL         't'
+        #define LIST_OPTION_TIMES_UTC           'T'
         #define LIST_OPTION_SIZEINBLOCKS        's'
         #define LIST_OPTION_DISPLAY_HASH        'h'
@@ -363 +391 @@
 //
 // Function
-//              Name:    BackupQueries::CommandList2(int64_t, const std::string &, const bool *)
+//              Name:    BackupQueries::List(int64_t, const std::string &, const bool *, bool)
 //              Purpose: Do the actual listing of directories and files
 //              Created: 2003/10/10
@@ -438 +466 @@
                 }
                 
-                if(opts[LIST_OPTION_TIMES])
-                {
-                        // Show times...
+                if(opts[LIST_OPTION_TIMES_LOCAL])
+                {
+                        // Show local times...
                         std::string time = BoxTimeToISO8601String(
                                 en->GetModificationTime());
@@ -845 +873 @@
 
         // Find object ID somehow
-        int64_t id;
+        int64_t fileId;
+        int64_t dirId = GetCurrentDirectoryID();
         std::string localName;
+
         // BLOCK
         {
+#ifdef WIN32
+                std::string fileName;
+                if(!ConvertConsoleToUtf8(args[0].c_str(), fileName))
+                        return;
+#else
+                std::string fileName(args[0]);
+#endif
+
+                if(!opts['i'])
+                {
+                        // does this remote filename include a path?
+                        std::string::size_type index = fileName.rfind('/');
+                        if(index != std::string::npos)
+                        {
+                                std::string dirName(fileName.substr(0, index));
+                                fileName = fileName.substr(index + 1);
+
+                                dirId = FindDirectoryObjectID(dirName);
+                                if(dirId == 0)
+                                {
+                                        printf("Directory '%s' not found\n", 
+                                                dirName.c_str());
+                                        return;
+                                }
+                        }
+                }
+
+                BackupStoreFilenameClear fn(fileName);
+
                 // Need to look it up in the current directory
                 mrConnection.QueryListDirectory(
-                                GetCurrentDirectoryID(),
+                                dirId,
                                 BackupProtocolClientListDirectory::Flags_File,  // just files
                                 (opts['i'])?(BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING):(BackupProtocolClientListDirectory::Flags_OldVersion | BackupProtocolClientListDirectory::Flags_Deleted), // only current versions
@@ -864 +923 @@
                 {
                         // Specified as ID. 
-                        id = ::strtoll(args[0].c_str(), 0, 16);
-                        if(id == std::numeric_limits<long long>::min() || id == std::numeric_limits<long long>::max() || id == 0)
+                        fileId = ::strtoll(args[0].c_str(), 0, 16);
+                        if(fileId == std::numeric_limits<long long>::min() || 
+                                fileId == std::numeric_limits<long long>::max() || 
+                                fileId == 0)
                         {
                                 printf("Not a valid object ID (specified in hex)\n");
@@ -872 +933 @@
                         
                         // Check that the item is actually in the directory
-                        if(dir.FindEntryByID(id) == 0)
-                        {
-                                printf("ID '%08llx' not found in current directory on store.\n(You can only download objects by ID from the current directory.)\n", id);
+                        if(dir.FindEntryByID(fileId) == 0)
+                        {
+                                printf("ID '%08llx' not found in current "
+                                        "directory on store.\n"
+                                        "(You can only download objects by ID "
+                                        "from the current directory.)\n", 
+                                        fileId);
                                 return;
                         }
@@ -885 +950 @@
                         // Specified by name, find the object in the directory to get the ID
                         BackupStoreDirectory::Iterator i(dir);
-#ifdef WIN32
-                        std::string fileName;
-                        if(!ConvertConsoleToUtf8(args[0].c_str(), fileName))
-                                return;
-                        BackupStoreFilenameClear fn(fileName);
-#else
-                        BackupStoreFilenameClear fn(args[0]);
-#endif
                         BackupStoreDirectory::Entry *en = i.FindMatchingClearName(fn);
                         
                         if(en == 0)
                         {
-                                printf("Filename '%s' not found in current directory on store.\n(Subdirectories in path not searched.)\n", args[0].c_str());
+                                printf("Filename '%s' not found in current "
+                                        "directory on store.\n"
+                                        "(Subdirectories in path not "
+                                        "searched.)\n", args[0].c_str());
                                 return;
                         }
                         
-                        id = en->GetObjectID();
+                        fileId = en->GetObjectID();
                         
-                        // Local name is the last argument, which is either the looked up filename, or
-                        // a filename specified by the user.
+                        // Local name is the last argument, which is either 
+                        // the looked up filename, or a filename specified 
+                        // by the user.
                         localName = args[args.size() - 1];
                 }
@@ -921 +982 @@
         {
                 // Request object
-                mrConnection.QueryGetFile(GetCurrentDirectoryID(), id);
+                mrConnection.QueryGetFile(dirId, fileId);
 
                 // Stream containing encoded file
@@ -930 +991 @@
 
                 // Done.
-                printf("Object ID %08llx fetched sucessfully.\n", id);
+                printf("Object ID %08llx fetched sucessfully.\n", fileId);
         }
         catch(...)
@@ -951 +1012 @@
         : mQuickCompare(false),
           mIgnoreExcludes(false),
+          mIgnoreAttributes(false),
           mDifferences(0),
           mDifferencesExplainedByModTime(0),
+          mUncheckedFiles(0),
           mExcludedDirs(0),
           mExcludedFiles(0),
@@ -1013 +1076 @@
         params.mQuickCompare = opts['q'];
         params.mIgnoreExcludes = opts['E'];
+        params.mIgnoreAttributes = opts['A'];
         
         // Try and work out the time before which all files should be on the server
@@ -1075 +1139 @@
         }
         
-        printf("\n[ %d (of %d) differences probably due to file modifications after the last upload ]\nDifferences: %d (%d dirs excluded, %d files excluded)\n",
-                params.mDifferencesExplainedByModTime, params.mDifferences, params.mDifferences, params.mExcludedDirs, params.mExcludedFiles);
+        printf("\n[ %d (of %d) differences probably due to file "
+                "modifications after the last upload ]\n"
+                "Differences: %d (%d dirs excluded, %d files excluded, "
+                "%d files not checked)\n",
+                params.mDifferencesExplainedByModTime, params.mDifferences, 
+                params.mDifferences, params.mExcludedDirs, 
+                params.mExcludedFiles, params.mUncheckedFiles);
         
         // Set return code?
         if(opts['c'])
         {
-                SetReturnCode((params.mDifferences == 0)?COMPARE_RETURN_SAME:COMPARE_RETURN_DIFFERENT);
+                if (params.mUncheckedFiles != 0)
+                {
+                        SetReturnCode(COMPARE_RETURN_ERROR);
+                } 
+                else if (params.mDifferences != 0)
+                {
+                        SetReturnCode(COMPARE_RETURN_DIFFERENT);
+                }
+                else
+                {
+                        SetReturnCode(COMPARE_RETURN_SAME);
+                }
         }
 }
@@ -1215 +1295 @@
                                 localDirDisplay.c_str(), 
                                 storeDirDisplay.c_str());
+                        rParams.mDifferences ++;
                 }
                 else
@@ -1220 +1301 @@
                         printf("ERROR: stat on local dir '%s'\n", 
                                 localDirDisplay.c_str());
+                        rParams.mUncheckedFiles ++;
                 }
                 return;
@@ -1269 +1351 @@
                 printf("ERROR: opendir on local dir '%s'\n", 
                         localDirDisplay.c_str());
+                rParams.mUncheckedFiles ++;
                 return;
         }
@@ -1456 +1539 @@
                                                 
                                                 // Compare attributes
+                                                box_time_t fileModTime = 0;
                                                 BackupClientFileAttributes localAttr;
-                                                box_time_t fileModTime = 0;
                                                 localAttr.ReadAttributes(localPath.c_str(), false /* don't zero mod times */, &fileModTime);                                    
                                                 modifiedAfterLastSync = (fileModTime > rParams.mLatestFileUploadTime);
-                                                if(!localAttr.Compare(fileOnServerStream->GetAttributes(),
+                                                if(!rParams.mIgnoreAttributes &&
+                                                   !localAttr.Compare(fileOnServerStream->GetAttributes(),
                                                                 true /* ignore attr mod time */,
                                                                 fileOnServerStream->IsSymLink() /* ignore modification time if it's a symlink */))
@@ -1555 +1639 @@
                                                 e.GetSubType(),
                                                 storePathDisplay.c_str());
+                                        rParams.mUncheckedFiles ++;
                                 }
                                 catch(...)
-                                {
+                                {       
                                         printf("ERROR: (unknown) during file fetch and comparison for '%s'\n", storePathDisplay.c_str());
+                                        rParams.mUncheckedFiles ++;
                                 }
 
@@ -1794 +1880 @@
                 break;
                 
+        #ifdef WIN32
+        case Restore_TargetPathNotFound:
+                printf("The target directory path does not exist.\n"
+                        "To restore to a directory whose parent "
+                        "does not exist, create the parent first.\n");
+                break;
+        #endif
+
         default:
                 printf("ERROR: Unknown restore result.\n");

box/chris/merge/bin/bbackupquery/BackupQueries.h

@@ -69 +69 @@
                 bool mQuickCompare;
                 bool mIgnoreExcludes;
+                bool mIgnoreAttributes;
                 int mDifferences;
                 int mDifferencesExplainedByModTime;
+                int mUncheckedFiles;
                 int mExcludedDirs;
                 int mExcludedFiles;

box/chris/merge/bin/bbackupquery/documentation.txt

@@ -105 +105 @@
         -q -- quick compare. Only checks file contents against checksums,
                         doesn't do a full download
+        -A -- ignore attribute differences
         -E -- ignore exclusion settings
         

box/chris/merge/bin/bbstored/BBStoreDHousekeeping.cpp

@@ -11 +11 @@
 
 #include <stdio.h>
+
+#ifdef HAVE_SYSLOG_H
 #include <syslog.h>
+#endif
 
 #include "BackupStoreDaemon.h"
@@ -30 +33 @@
 //
 // --------------------------------------------------------------------------
+void BackupStoreDaemon::HousekeepingInit()
+{
+
+        mLastHousekeepingRun = 0;
+}
+
+#ifndef WIN32
 void BackupStoreDaemon::HousekeepingProcess()
 {
+        HousekeepingInit();
+
         // Get the time between housekeeping runs
         const Configuration &rconfig(GetConfiguration());
         int64_t housekeepingInterval = SecondsToBoxTime(rconfig.GetKeyValueInt("TimeBetweenHousekeeping"));
-        
-        int64_t lastHousekeepingRun = 0;
 
         while(!StopRun())
         {
-                // Time now
+                RunHousekeepingIfNeeded();
+
+                // Calculate how long should wait before doing the next housekeeping run
                 int64_t timeNow = GetCurrentBoxTime();
-                // Do housekeeping if the time interval has elapsed since the last check
-                if((timeNow - lastHousekeepingRun) >= housekeepingInterval)
-                {
-                        // Store the time
-                        lastHousekeepingRun = timeNow;
-                        ::syslog(LOG_INFO, "Starting housekeeping");
-
-                        // Get the list of accounts
-                        std::vector<int32_t> accounts;
-                        if(mpAccountDatabase)
-                        {
-                                mpAccountDatabase->GetAllAccountIDs(accounts);
-                        }
-                        
-                        SetProcessTitle("housekeeping, active");
-                        
-                        // Check them all
-                        for(std::vector<int32_t>::const_iterator i = accounts.begin(); i != accounts.end(); ++i)
-                        {
-                                try
-                                {
-                                        if(mpAccounts)
-                                        {
-                                                // Get the account root
-                                                std::string rootDir;
-                                                int discSet = 0;
-                                                mpAccounts->GetAccountRoot(*i, rootDir, discSet);
-                                                
-                                                // Do housekeeping on this account
-                                                HousekeepStoreAccount housekeeping(*i, rootDir, discSet, *this);
-                                                housekeeping.DoHousekeeping();
-                                        }
-                                }
-                                catch(BoxException &e)
-                                {
-                                        ::syslog(LOG_ERR, "while housekeeping account %08X, exception %s (%d/%d) -- aborting housekeeping run for this account",
-                                                *i, e.what(), e.GetType(), e.GetSubType());
-                                }
-                                catch(std::exception &e)
-                                {
-                                        ::syslog(LOG_ERR, "while housekeeping account %08X, exception %s -- aborting housekeeping run for this account",
-                                                *i, e.what());
-                                }
-                                catch(...)
-                                {
-                                        ::syslog(LOG_ERR, "while housekeeping account %08X, unknown exception -- aborting housekeeping run for this account",
-                                                *i);
-                                }
-                                
-                                // Check to see if there's any message pending
-                                CheckForInterProcessMsg(0 /* no account */);
-                
-                                // Stop early?
-                                if(StopRun())
-                                {
-                                        break;
-                                }
-                        }
-                        
-                        ::syslog(LOG_INFO, "Finished housekeeping");
-                }
-
-                // Placed here for accuracy, if StopRun() is true, for example.
-                SetProcessTitle("housekeeping, idle");
-                
-                // Calculate how long should wait before doing the next housekeeping run
-                timeNow = GetCurrentBoxTime();
-                time_t secondsToGo = BoxTimeToSeconds((lastHousekeepingRun + housekeepingInterval) - timeNow);
+                time_t secondsToGo = BoxTimeToSeconds((mLastHousekeepingRun + housekeepingInterval) - timeNow);
                 if(secondsToGo < 1) secondsToGo = 1;
                 if(secondsToGo > 60) secondsToGo = 60;
@@ -118 +63 @@
         }
 }
-
+#endif
+
+void BackupStoreDaemon::RunHousekeepingIfNeeded()
+{
+        // Get the time between housekeeping runs
+        const Configuration &rconfig(GetConfiguration());
+        int64_t housekeepingInterval = SecondsToBoxTime(rconfig.GetKeyValueInt("TimeBetweenHousekeeping"));
+
+        // Time now
+        int64_t timeNow = GetCurrentBoxTime();
+        // Do housekeeping if the time interval has elapsed since the last check
+        if((timeNow - mLastHousekeepingRun) < housekeepingInterval)
+        {
+                return;
+        }
+
+        // Store the time
+        mLastHousekeepingRun = timeNow;
+        ::syslog(LOG_INFO, "Starting housekeeping");
+
+        // Get the list of accounts
+        std::vector<int32_t> accounts;
+        if(mpAccountDatabase)
+        {
+                mpAccountDatabase->GetAllAccountIDs(accounts);
+        }
+                        
+        SetProcessTitle("housekeeping, active");
+                        
+        // Check them all
+        for(std::vector<int32_t>::const_iterator i = accounts.begin(); i != accounts.end(); ++i)
+        {
+                try
+                {
+                        if(mpAccounts)
+                        {
+                                // Get the account root
+                                std::string rootDir;
+                                int discSet = 0;
+                                mpAccounts->GetAccountRoot(*i, rootDir, discSet);
+                                
+                                // Do housekeeping on this account
+                                HousekeepStoreAccount housekeeping(*i, rootDir, discSet, *this);
+                                housekeeping.DoHousekeeping();
+                        }
+                }
+                catch(BoxException &e)
+                {
+                        ::syslog(LOG_ERR, "while housekeeping account %08X, exception %s (%d/%d) -- aborting housekeeping run for this account",
+                                *i, e.what(), e.GetType(), e.GetSubType());
+                }
+                catch(std::exception &e)
+                {
+                        ::syslog(LOG_ERR, "while housekeeping account %08X, exception %s -- aborting housekeeping run for this account",
+                                *i, e.what());
+                }
+                catch(...)
+                {
+                        ::syslog(LOG_ERR, "while housekeeping account %08X, unknown exception -- aborting housekeeping run for this account",
+                                *i);
+                }
+        
+#ifndef WIN32   
+                // Check to see if there's any message pending
+                CheckForInterProcessMsg(0 /* no account */);
+#endif
+
+                // Stop early?
+                if(StopRun())
+                {
+                        break;
+                }
+        }
+                
+        ::syslog(LOG_INFO, "Finished housekeeping");
+
+        // Placed here for accuracy, if StopRun() is true, for example.
+        SetProcessTitle("housekeeping, idle");
+}
+
+#ifdef WIN32
+void BackupStoreDaemon::OnIdle()
+{
+        if (!mHousekeepingInited)
+        {
+                HousekeepingInit();
+                mHousekeepingInited = true;
+        }
+
+        RunHousekeepingIfNeeded();
+}
+#endif
 
 // --------------------------------------------------------------------------
@@ -129 +165 @@
 //
 // --------------------------------------------------------------------------
+#ifndef WIN32
 bool BackupStoreDaemon::CheckForInterProcessMsg(int AccountNum, int MaximumWaitTime)
 {
@@ -172 +209 @@
         return false;
 }
-
-
+#endif
+
+

box/chris/merge/bin/bbstored/BackupCommands.cpp

@@ -10 +10 @@
 #include "Box.h"
 
+#ifdef HAVE_SYSLOG_H
 #include <syslog.h>
+#endif
+
+#include <set>
+#include <sstream>
 
 #include "autogen_BackupProtocolServer.h"
@@ -328 +333 @@
                         
                         // Choose a temporary filename for the result of the combination
-                        std::string tempFn(RaidFileController::DiscSetPathToFileSystemPath(rContext.GetStoreDiscSet(), rContext.GetStoreRoot() + ".recombinetemp",
-                                p + 16 /* rotate which disc it's on */));
+#ifdef WIN32
+                        std::ostringstream fs(rContext.GetStoreRoot());
+                        fs << ".recombinetemp.";
+                        fs << p;
+                        std::string tempFn(fs.str());
+                        tempFn = RaidFileController::DiscSetPathToFileSystemPath(rContext.GetStoreDiscSet(), tempFn, p + 16);
+#else
+                        std::string tempFn(RaidFileController::DiscSetPathToFileSystemPath(rContext.GetStoreDiscSet(), rContext.GetStoreRoot() + ".recombinetemp", p + 16 /* rotate which disc it's on */));
+#endif
                         
                         // Open the temporary file
@@ -337 +349 @@
                                 {
                                         // Write nastily to allow this to work with gcc 2.x
+#ifdef WIN32
+                                        combined.reset(new FileStream(
+                                                tempFn.c_str(), 
+                                                O_RDWR | O_CREAT | O_EXCL | 
+                                                O_BINARY | O_TRUNC));
+#else
                                         std::auto_ptr<IOStream> t(new FileStream(tempFn.c_str(), O_RDWR | O_CREAT | O_EXCL));
                                         combined = t;
+#endif
                                 }
+#ifndef WIN32
                                 // Unlink immediately as it's a temporary file
                                 if(::unlink(tempFn.c_str()) != 0)
@@ -345 +365 @@
                                         THROW_EXCEPTION(CommonException, OSFileError);
                                 }
+#endif
                         }
                         catch(...)
@@ -360 +381 @@
                         
                         // Then shuffle round for the next go
+#ifdef WIN32
+                        if (from.get()) from->Close();
+#endif
                         from = combined;
                 }
@@ -397 +421 @@
                 }
 
-                // Object will be deleted when the stream is deleted, so can release the object auto_ptr here to
-                // avoid premature deletiong
+                // Object will be deleted when the stream is deleted, 
+                // so can release the object auto_ptr here to avoid 
+                // premature deletion
                 object.release();
         }

box/chris/merge/bin/bbstored/BackupContext.cpp

@@ -133 +133 @@
         bool gotLock = mWriteLock.TryAndGetLock(writeLockFile.c_str(), 0600 /* restrictive file permissions */);
         
+#ifndef WIN32
         if(!gotLock)
         {
@@ -151 +152 @@
                 } while(!gotLock && tries > 0);
         }
+#endif
         
         if(gotLock)
@@ -454 +456 @@
                         {
                                 // Open it twice
+#ifdef WIN32
+                                FileStream diff(tempFn.c_str(), 
+                                        O_RDWR | O_CREAT | O_BINARY);
+                                FileStream diff2(tempFn.c_str(), 
+                                        O_RDWR | O_BINARY);
+#else
                                 FileStream diff(tempFn.c_str(), O_RDWR | O_CREAT | O_EXCL);
                                 FileStream diff2(tempFn.c_str(), O_RDONLY);
-                                // Unlink it immediately, so it definately goes away
+
+                                // Unlink it immediately, so it definitely goes away
                                 if(::unlink(tempFn.c_str()) != 0)
                                 {
                                         THROW_EXCEPTION(CommonException, OSFileError);
                                 }
+#endif
                                 
                                 // Stream the incoming diff to this temporary file
@@ -509 +519 @@
                                 throw;
                         }
+
+#ifdef WIN32
+                        // we can't delete the file while it's open, above
+                        if(::unlink(tempFn.c_str()) != 0)
+                        {
+                                THROW_EXCEPTION(CommonException, OSFileError);
+                        }
+#endif
                 }
                 

box/chris/merge/bin/bbstored/BackupStoreDaemon.cpp

@@ -12 +12 @@
 #include <stdlib.h>
 #include <stdio.h>
+#include <signal.h>
+
+#ifdef HAVE_SYSLOG_H
 #include <syslog.h>
-#include <signal.h>
+#endif
 
 #include "BackupContext.h"
@@ -40 +43 @@
           mHaveForkedHousekeeping(false),
           mIsHousekeepingProcess(false),
+#ifdef WIN32
+          mHousekeepingInited(false)
+#else
           mInterProcessComms(mInterProcessCommsSocket)
+#endif
 {
 }
@@ -157 +164 @@
         mExtendedLogging = config.GetKeyValueBool("ExtendedLogging");
         
+#ifndef WIN32   
         // Fork off housekeeping daemon -- must only do this the first time Run() is called
         if(!mHaveForkedHousekeeping)
@@ -220 +228 @@
         else
         {
+#endif // !WIN32
                 // In server process -- use the base class to do the magic
                 ServerTLS<BOX_PORT_BBSTORED>::Run();
                 
+#ifndef WIN32   
                 // Why did it stop? Tell the housekeeping process to do the same
                 if(IsReloadConfigWanted())
@@ -233 +243 @@
                 }
         }
+#endif
 }
 
@@ -298 +309 @@
         ::syslog(LOG_INFO, "Connection statistics for %s: "
                         "IN=%lld OUT=%lld TOTAL=%lld\n", commonName,
-                        s.GetBytesRead(), s.GetBytesWritten(),
-                        s.GetBytesRead() + s.GetBytesWritten());
-}
+                        (long long)s.GetBytesRead(), 
+                        (long long)s.GetBytesWritten(),
+                        (long long)s.GetBytesRead() + 
+                        (long long)s.GetBytesWritten());
+}

box/chris/merge/bin/bbstored/BackupStoreDaemon.h

@@ -39 +39 @@
 public:
 
+#ifndef WIN32
         // For BackupContext to comminicate with housekeeping process
         void SendMessageToHousekeepingProcess(const void *Msg, int MsgLen)
@@ -44 +45 @@
                 mInterProcessCommsSocket.Write(Msg, MsgLen);
         }
+#endif
 
 protected:
@@ -58 +60 @@
         const ConfigurationVerify *GetConfigVerify() const;
         
+#ifndef WIN32   
         // Housekeeping functions
         void HousekeepingProcess();
         bool CheckForInterProcessMsg(int AccountNum = 0, int MaximumWaitTime = 0);
+#endif
 
         void LogConnectionStats(const char *commonName, const SocketStreamTLS &s);
@@ -71 +75 @@
         bool mIsHousekeepingProcess;
         
+#ifdef WIN32
+        virtual void OnIdle();
+        bool mHousekeepingInited;
+#else
         SocketStream mInterProcessCommsSocket;
         IOStreamGetLine mInterProcessComms;
+#endif
+
+        void HousekeepingInit();
+        void RunHousekeepingIfNeeded();
+        int64_t mLastHousekeepingRun;
 };
 

box/chris/merge/bin/bbstored/HousekeepStoreAccount.cpp

@@ -226 +226 @@
 bool HousekeepStoreAccount::ScanDirectory(int64_t ObjectID)
 {
+#ifndef WIN32
         if((--mCountUntilNextInterprocessMsgCheck) <= 0)
         {
@@ -236 +237 @@
                 }
         }
+#endif
 
         // Get the filename
@@ -252 +254 @@
         BackupStoreDirectory dir;
         dir.ReadFromStream(*dirStream, IOStream::TimeOutInfinite);
+        dirStream->Close();
         
         // Is it empty?
@@ -486 +489 @@
         for(std::set<DelEn, DelEnCompare>::iterator i(mPotentialDeletions.begin()); i != mPotentialDeletions.end(); ++i)
         {
+#ifndef WIN32
                 if((--mCountUntilNextInterprocessMsgCheck) <= 0)
                 {
@@ -496 +500 @@
                         }
                 }
+#endif
 
                 // Load up the directory it's in
@@ -730 +735 @@
                 for(std::vector<int64_t>::const_iterator i(mEmptyDirectories.begin()); i != mEmptyDirectories.end(); ++i)
                 {
+#ifndef WIN32
                         if((--mCountUntilNextInterprocessMsgCheck) <= 0)
                         {
@@ -740 +746 @@
                                 }
                         }
+#endif
 
                         // Do not delete the root directory

box/chris/merge/configure.ac

@@ -45 +45 @@
 
 ## Check for Berkely DB. Restrict to certain versions
-AX_PATH_BDB(, [
+AX_PATH_BDB([1.x or 4.1], [
   LIBS="$BDB_LIBS $LIBS"
   LDFLAGS="$BDB_LDFLAGS $LDFLAGS"
@@ -90 +90 @@
 AC_CHECK_HEADERS([netinet/in.h])
 AC_CHECK_HEADERS([sys/param.h sys/socket.h sys/time.h sys/types.h sys/wait.h])
-AC_CHECK_HEADERS([sys/xattr.h])
+AC_CHECK_HEADERS([sys/uio.h sys/xattr.h])
 
 if test "$ac_cv_header_regex_h" = "yes"; then
@@ -117 +117 @@
 AC_CHECK_DECLS([INFTIM],,, [[#include <poll.h>]])
 AC_CHECK_DECLS([SO_PEERCRED],,, [[#include <sys/socket.h>]])
+AC_CHECK_DECLS([O_BINARY],,,)
 AC_HEADER_TIME
 AC_STRUCT_TM
@@ -125 +126 @@
   AX_BSWAP64
 fi
+
 if test "$target_os" != "mingw32"; then
   AX_RANDOM_DEVICE
-fi
-AX_CHECK_MOUNT_POINT(,[
-  if test "$target_os" != "mingw32" -a "$target_os" != "winnt"; then
+  AX_CHECK_MOUNT_POINT(,[
     AC_MSG_ERROR([[cannot work out how to discover mount points on your platform]])
-  fi
   ])
+fi
+
 AX_CHECK_MALLOC_WORKAROUND
 
@@ -221 +222 @@
                    runtest.pl
                    test/backupstorefix/testfiles/testbackupstorefix.pl
+                   test/bbackupd/testfiles/bbackupd.conf
                    test/bbackupd/testfiles/extcheck1.pl
                    test/bbackupd/testfiles/extcheck2.pl
@@ -238 +240 @@
 to the documentation for more information on each feature.
 
+Regular expressions: $ac_cv_header_regex_h
 Large files:         $have_large_file_support
 Berkeley DB:         $ax_path_bdb_ok

box/chris/merge/docs/backup/win32_build_on_linux_using_mingw.txt

@@ -7 +7 @@
 - Fedora and SuSE users can download RPM packages from 
   [http://mirzam.it.vu.nl/mingw/]
+
+You will need to know the prefix used by the cross-compiler executables.
+It will usually be something like "ix86-mingw32*-". All the binaries in the
+cross-compiler package will start with this prefix. The documentation below
+assumes that it is "i386-mingw32-". Adjust to taste.
 
 Download Zlib from [http://www.zlib.net/], unpack and enter source directory:
@@ -17 +22 @@
         make install prefix=/usr/local/i386-mingw32
 
-Download OpenSSL 0.9.7 from 
+Download OpenSSL 0.9.8b from 
+[http://www.openssl.org/source/openssl-0.9.8b.tar.gz]
+
+Unpack and configure:
+
+        tar xzvf openssl-0.9.8b.tar.gz
+        cd openssl-0.9.8b
+        ./Configure mingw
+        make makefile.one
+        wget http://bbdev.fluffy.co.uk/svn/box/chris/win32/support/openssl-0.9.8b-mingw-cross.patch
+        patch -p1 < openssl-0.9.8b-mingw-cross.patch
+        make -f makefile.one
 
 Configure Box with:
@@ -28 +44 @@
         export LDFLAGS="-mthreads"
         export LIBS="-lcrypto -lws2_32 -lgdi32"
+        (if you don't have a "configure" file, run "./bootstrap")
         ./configure --target=i386-mingw32
-        make CXX="$CXX" AR="$AR" RANLIB="$RANLIB"
+        make CXX="$CXX" AR="$AR" RANLIB="$RANLIB" WINDRES="i386-mingw32-windres"

box/chris/merge/infrastructure/BoxPlatform.pm.in

@@ -2 +2 @@
 use Exporter;
 @ISA = qw/Exporter/;
-@EXPORT = qw/$build_os $build_cpu $target_os $make_command $bsd_make $platform_define $platform_cpu $gcc_v3 $product_version $product_name $install_into_dir $sub_make_options $platform_compile_line_extra $platform_link_line_extra $platform_lib_files $platform_exe_ext/;
+@EXPORT = qw/$build_os $build_cpu $target_os $make_command $bsd_make $platform_define $platform_cpu $gcc_v3 $product_version $product_name $install_into_dir $sub_make_options $platform_compile_line_extra $platform_link_line_extra $platform_lib_files $platform_exe_ext $target_windows update_if_changed/;
 
 BEGIN
@@ -8 +8 @@
 
         # which OS are we building under?
-        $build_os = `uname`;
-        chomp $build_os;
-        $build_cpu = `uname -p`;
-        chomp $build_cpu;
+        $target_os = '@target_os@';
+        $target_windows = 0;
+        $target_windows = 1 if $target_os =~ m'^mingw32' 
+                or $target_os eq "winnt";
+
+        if ($^O eq "MSWin32" and not -x "/usr/bin/uname")
+        {
+                $build_os = "winnt";
+                $build_cpu = "ix86";
+        }
+        else
+        {
+                $build_os = `uname`;
+                chomp $build_os;
+                $build_cpu = `uname -m`;
+                chomp $build_cpu;
+        }
+
         # Cygwin Builds usually something like CYGWIN_NT-5.0, CYGWIN_NT-5.1
         # Box Backup tried on Win2000,XP only :)
@@ -25 +39 @@
         $platform_link_line_extra = '@LDFLAGS@';
         $platform_lib_files = '@LIBS@';
-        $target_os = '@target_os@';
         $platform_exe_ext = '@EXEEXT@';
 
         # get version
-        open VERSION,"VERSION.txt" or die "VERSION.txt: $!";
+        if (! -r "VERSION.txt" and -r "../../VERSION.txt")
+        {
+                open VERSION,"../../VERSION.txt" or die "../../VERSION.txt: $!";
+        }
+        else
+        {
+                open VERSION,"VERSION.txt" or die "VERSION.txt: $!";
+        }
+
         $product_version = <VERSION>;
         chomp $product_version;
@@ -90 +111 @@
 }
 
+sub update_if_changed ($)
+{
+        my ($file) = @_;
+        die "$file.new: not found" unless -r "$file.new";
+
+        if (-r $file)
+        {
+                die "$file.new: not found" unless -r "$file.new";
+                if (system("diff --brief $file $file.new") == 0)
+                {
+                        unlink "$file.new";
+                        return;
+                }
+        }
+
+        if (system("cp $file.new $file") != 0)
+        {
+                die "failed to copy $file.new to $file";
+        }
+
+        if (system("diff --brief $file $file.new") != 0)
+        {
+                die "$file and $file.new are still different";
+        }
+
+        unlink "$file.new";
+        return;
+}
+
 1;
 

box/chris/merge/infrastructure/buildenv-testmain-template.cpp

@@ -42 +42 @@
 
 int failures = 0;
+int first_fail_line;
+std::string first_fail_file;
 
 int filedes_open_at_beginning = -1;
@@ -129 +131 @@
                         if(failures > 0)
                         {
-                                printf("FAILED: %d tests failed\n", failures);
+                                printf("FAILED: %d tests failed (first at "
+                                        "%s:%d)\n", failures, 
+                                        first_fail_file.c_str(),
+                                        first_fail_line);
                         }
                         else

box/chris/merge/infrastructure/makebuildenv.pl.in

@@ -15 +15 @@
 print "Box build environment setup.\n\n";
 
-
-my $implicit_dep = 'lib/common';
+my @implicit_deps = ('lib/common');
 
 # work out platform variables
@@ -39 +38 @@
 my %env_flags;
 
-my $windows_include_path = "-I../../lib/win32 ";
-if ($target_os ne "mingw32" && $target_os ne "winnt")
-{
-        $windows_include_path = "";
-        $env_flags{'IGNORE_lib/win32'} = 1;
+my $windows_include_path = "";
+if ($target_windows)
+{
+        $module_dependency{"lib/common"} = ["lib/win32"];
+        push @implicit_deps, "lib/win32";
+}
+else
+{
+        # $env_flags{'IGNORE_lib/win32'} = 1;
 }
 
@@ -112 +115 @@
 
 
-# open test mail program template file
+# open test main program template file
 my $test_template_file = 'infrastructure/buildenv-testmain-template.cpp';
 open FL,$test_template_file or die "Can't open test template file\n";
@@ -272 +275 @@
                 }
         }
-        $module_dependency{$mod} = [$implicit_dep,@md];
+        $module_dependency{$mod} = [@implicit_deps,@md];
         $module_library_link_opts{$mod} = [@lo];
         
@@ -287 +290 @@
 
 # make dirs for implicit dep
-mkdir "release/$implicit_dep",0755;
-mkdir "debug/$implicit_dep",0755;
+foreach my $dep (@implicit_deps)
+{
+        mkdir "release/$dep",0755;
+        mkdir "debug/$dep",0755;
+}
 
 # write a list of all the modules we've configured to use
-open CONFIGURED_MODS,'>local/modules.h' or die "Can't write configured modules list";
+open CONFIGURED_MODS,'>local/modules.h.new' or die 
+        "Can't write configured modules list";
 print CONFIGURED_MODS <<__E;
 // automatically generated file, do not edit
@@ -297 +304 @@
 #define _CONFIGURED_MODULES__H
 __E
-for($implicit_dep,@modules)
+for(@implicit_deps,@modules)
 {
         my $m = $_;
@@ -307 +314 @@
 __E
 close CONFIGURED_MODS;
-
+update_if_changed("local/modules.h");
 
 # now make a list of all the .h files we can find, recording which module they're in
 my %hfiles;
-for my $mod (@modules, $implicit_dep)
+for my $mod (@modules, @implicit_deps)
 {
         opendir DIR,$mod;
@@ -348 +355 @@
 }
 
-for my $mod (@modules, $implicit_dep)
+for my $mod (@modules, @implicit_deps)
 {
         opendir DIR,$mod;
@@ -374 +381 @@
 print "done\n\nGenerating Makefiles...\n";
 
+my %module_resources_win32;
 
 # Then write a makefile for each module
-for my $mod (@modules, $implicit_dep)
+for my $mod (@implicit_deps, @modules)
 {
         print $mod,"\n";
@@ -387 +395 @@
                 my $testmain = $test_template;
                 $testmain =~ s/TEST_NAME/$name/g;
-                open TESTMAIN,">$mod/_main.cpp" or die "Can't open test main file for $mod for writing\n";
+                open TESTMAIN,">$mod/_main.cpp.new" or die 
+                        "Can't open test main file for $mod for writing\n";
                 print TESTMAIN $testmain;
                 close TESTMAIN;
+                update_if_changed("$mod/_main.cpp");
                 
                 # test file...
@@ -395 +405 @@
                 {
                         my ($filename,$runcmd,$module) = @_;            
-                        open TESTFILE,">$filename" or die "Can't open test script file for $module for writing\n";
+                        open TESTFILE,">$filename.new" or die 
+                                "Can't open test script file for $module " .
+                                "for writing\n";
                         print TESTFILE "#!/bin/sh\necho TEST: $module\n";
                         if(-d "$module/testfiles")
@@ -414 +426 @@
                         print TESTFILE "$runcmd\n";
                         close TESTFILE;
+                        update_if_changed($filename);
                 }
                 
                 writetestfile("$mod/_t", 
-                        './test' . $platform_exe_ext . '$1 $2 $3 $4 $5', $mod);
+                        './test' . $platform_exe_ext . ' $1 $2 $3 $4 $5', $mod);
                 writetestfile("$mod/_t-gdb", 
-                        'gdb ./test ' . $platform_exe_ext, $mod);
+                        'gdb ./test' . $platform_exe_ext, $mod);
                 
         }
@@ -442 +455 @@
                 # and then dedup and reorder them
                 my %d_done;
-                for(my $a = $#deps_raw; $a >= 0; $a--)
-                {
-                        if(!exists $d_done{$deps_raw[$a]})
+                foreach my $dep (reverse @deps_raw)
+                {
+                        if(!exists $d_done{$dep})
                         {
                                 # insert
-                                push @all_deps_for_module, $deps_raw[$a];
+                                push @all_deps_for_module, $dep;
                                 # mark as done
-                                $d_done{$deps_raw[$a]} = 1;
+                                $d_done{$dep} = 1;
                         }
                 }
@@ -481 +494 @@
         # start the makefile
         my $mk_name_extra = ($bsd_make)?'':'X';
-        open MAKE,">$mod/Makefile".$mk_name_extra or die "Can't open Makefile for $mod\n";
+        open MAKE,">$mod/Makefile".$mk_name_extra.".new" or die 
+                "Can't open Makefile for $mod\n";
         my $debug_link_extra = ($target_is_library)?'':'../../debug/lib/debug/debug.a';
 
         my $release_flags = "-O2";
-        if ($target_os eq "mingw32")
+        if ($target_windows)
         {
                 $release_flags = "-O0 -g";
@@ -500 +514 @@
 RANLIB = ranlib
 PERL = "@PERL@"
+WINDRES = windres
 .ifdef RELEASE
 CXXFLAGS = -DNDEBUG $release_flags -Wall $include_paths $extra_platform_defines -DBOX_VERSION="\\"$product_version\\""
@@ -547 +562 @@
         }
         
-        # first, obtain a list of depenencies within the .h files
+        # first, obtain a list of dependencies within the .h files
         my %headers;
         for my $h (grep /\.h\Z/i, @items)
@@ -567 +582 @@
         # then... do the cpp files...
         my @obj_base;
-        for my $cpp (@items)
-        {
-                next unless $cpp =~ m/\A(.+)\.cpp\Z/i;
-                next if $cpp =~ /\A\._/;        # Temp Mac OS Resource hack
+        for my $file (@items)
+        {
+                my $is_cpp = $file =~ m/\A(.+)\.cpp\Z/i;
+                my $is_rc  = $file =~ m/\A(.+)\.rc\Z/i;
+                my $base = $1;
+
+                if ($target_windows)
+                {
+                        next if not $is_cpp and not $is_rc;
+                }
+                else
+                {
+                        next if not $is_cpp;
+                }
+
+                next if $file =~ /\A\._/; # Temp Mac OS Resource hack
 
                 # store for later
-                my $base = $1;
                 push @obj_base,$base;
         
                 # get the file...
-                open FL,"$mod/$cpp";
+                open FL,"$mod/$file";
                 my $f;
-                read FL,$f,-s "$mod/$cpp";
+                read FL,$f,-s "$mod/$file";
                 close FL;
                 
@@ -593 +619 @@
                 
                 # write the line for this cpp file
-                $make .= $out_name.': '.join(' ',$cpp,map
-                        { ($hfiles{$_} eq $mod)?$_:'../../'.$hfiles{$_}."/$_" } keys %dep)."\n";
-                $make .= "\t\$(CXX) \$(CXXFLAGS) $compile_line_extra -c $cpp -o $out_name\n\n";
-
+                my @dep_paths = map 
+                { 
+                        ($hfiles{$_} eq $mod)
+                        ? $_ 
+                        : '../../'.$hfiles{$_}."/$_"
+                }
+                keys %dep;
+
+                $make .= $out_name.': '.join(' ',$file,@dep_paths)."\n";
+
+                if ($is_cpp)
+                {
+                        $make .= "\t\$(CXX) \$(CXXFLAGS) $compile_line_extra ".
+                                "-c $file -o $out_name\n\n";
+                }
+                elsif ($is_rc)
+                {
+                        $make .= "\t\$(WINDRES) $file $out_name\n\n";
+                        my $res_list = $module_resources_win32{$mod};
+                        $res_list ||= [];
+                        push @$res_list, $base.'.o';
+                        $module_resources_win32{$mod} = $res_list;
+                }
         }
 
@@ -648 +693 @@
 
         my $o_file_list = join(' ',map {'$(OUTDIR)/'.$_.'.o'} @objs);
+
+        if ($has_deps and not $bsd_make)
+        {
+                print MAKE ".PHONY: all\n" .
+                        "all: dep_modules $end_target\n\n";
+        }
+
         print MAKE $end_target,': ',$o_file_list;
-        print MAKE ' dep_modules' if $has_deps and not $bsd_make;
         print MAKE " ",$lib_files unless $target_is_library;
         print MAKE "\n";
         
+        if ($target_windows)
+        {
+                foreach my $dep (@all_deps_for_module)
+                {
+                        my $res_list = $module_resources_win32{$dep};
+                        next unless $res_list;
+                        $o_file_list .= ' '.join(' ', 
+                                map {'$(OUTBASE)/'.$dep."/$_"} @$res_list);
+                }
+        }
+
         # stuff to make the final target...
         if($target_is_library)
@@ -731 +793 @@
         {
                 # need to post process this into a GNU makefile
-                open MAKE,">$mod/Makefile";
-                open MAKEB,"$mod/MakefileX";
+                open MAKE,">$mod/Makefile.new" or die $!;
+                open MAKEB,"$mod/MakefileX.new" or die $!;
 
                 while(<MAKEB>)
@@ -744 +806 @@
                 close MAKEB;
                 close MAKE;
-                unlink "$mod/MakefileX";
-        }
+                unlink "$mod/MakefileX.new";
+        }
+
+        update_if_changed("$mod/Makefile");
 }
 

box/chris/merge/lib/backupclient/BackupClientFileAttributes.cpp

@@ -643 +643 @@
         
         // If working as root, set user IDs
+        #ifndef WIN32
         if(::geteuid() == 0)
         {
@@ -662 +663 @@
                 #endif
         }
+        #endif
 
         if(static_cast<int>(xattrOffset+sizeof(u_int32_t))<=mpClearAttributes->GetSize())

box/chris/merge/lib/backupclient/BackupStoreFile.cpp

@@ -290 +290 @@
                         stream->CopyStreamTo(out);
                 }
+
+                out.Close();
                 
                 // Write the attributes

box/chris/merge/lib/backupclient/BackupStoreObjectDump.cpp

@@ -114 +114 @@
                 // Output item
                 int16_t f = (*i)->GetFlags();
-                OutputLine(file, ToTrace, "%06llx %4lld %016llx %4d %3d %4d%s%s%s%s%s%s\n",
+#ifdef WIN32
+                OutputLine(file, ToTrace, 
+                        "%06I64x %4I64d %016I64x %4d %3d %4d%s%s%s%s%s%s\n",
+#else
+                OutputLine(file, ToTrace, 
+                        "%06llx %4lld %016llx %4d %3d %4d%s%s%s%s%s%s\n",
+#endif
                         (*i)->GetObjectID(),
                         (*i)->GetSizeInBlocks(),

box/chris/merge/lib/backupstore/BackupStoreAccounts.cpp

@@ -142 +142 @@
 {
         char accid[64]; // big enough!
-        ::sprintf(accid, "%08x/", ID);
-        return std::string(std::string(BOX_RAIDFILE_ROOT_BBSTORED DIRECTORY_SEPARATOR) + accid);
+        ::sprintf(accid, "%08x" DIRECTORY_SEPARATOR, ID);
+        return std::string(std::string(BOX_RAIDFILE_ROOT_BBSTORED 
+                DIRECTORY_SEPARATOR) + accid);
 }
 

box/chris/merge/lib/backupstore/BackupStoreCheck.cpp

@@ -329 +329 @@
         StoreStructure::MakeObjectFilename(StartID, mStoreRoot, mDiscSetNumber, dirName, false /* don't make sure the dir exists */);
         // Check expectations
-        ASSERT(dirName.size() > 4 && dirName[dirName.size() - 4] == '/');
+        ASSERT(dirName.size() > 4 && 
+                dirName[dirName.size() - 4] == DIRECTORY_SEPARATOR_ASCHAR);
         // Remove the filename from it
         dirName.resize(dirName.size() - 4); // four chars for "/o00"
@@ -378 +379 @@
                 {
                         // Unexpected or bad file, delete it
-                        ::printf("Spurious file %s/%s found%s\n", dirName.c_str(), (*i).c_str(), mFixErrors?", deleting":"");
+                        ::printf("Spurious file %s" DIRECTORY_SEPARATOR "%s "
+                                "found%s\n", dirName.c_str(), (*i).c_str(), 
+                                mFixErrors?", deleting":"");
                         ++mNumberErrorsFound;
                         if(mFixErrors)

box/chris/merge/lib/common/BoxPlatform.h

@@ -41 +41 @@
 #endif
 
-// Slight hack; disable interception on Darwin within raidfile test
-#ifdef __APPLE__
+// Slight hack; disable interception in raidfile test on Darwin and Windows
+#if defined __APPLE__ || defined WIN32
         // TODO: Replace with autoconf test
         #define PLATFORM_CLIB_FNS_INTERCEPTION_IMPOSSIBLE
@@ -139 +139 @@
 #endif
 
+// for Unix compatibility with Windows :-)
+#if !HAVE_DECL_O_BINARY
+        #define O_BINARY 0
+#endif
+
 #ifdef WIN32
         typedef u_int64_t InodeRefType;

box/chris/merge/lib/common/FdGetLine.h

@@ -15 +15 @@
 #ifdef NDEBUG
         #define FDGETLINE_BUFFER_SIZE           1024
+#elif defined WIN32
+        // need enough space for at least one unicode character 
+        // in UTF-8 when calling console_read() from bbackupquery
+        #define FDGETLINE_BUFFER_SIZE           5
 #else
         #define FDGETLINE_BUFFER_SIZE           4

box/chris/merge/lib/common/Guards.h

@@ -25 +25 @@
 #include "MemLeakFindOn.h"
 
-template <int flags = O_RDONLY, int mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)>
+template <int flags = O_RDONLY | O_BINARY, int mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)>
 class FileHandleGuard
 {

box/chris/merge/lib/common/UnixUser.cpp

@@ -76 +76 @@
 UnixUser::~UnixUser()
 {
+#ifndef WIN32
         if(mRevertOnDestruction)
         {
@@ -85 +86 @@
                 }
         }
+#endif
 }
 
@@ -99 +101 @@
 void UnixUser::ChangeProcessUser(bool Temporary)
 {
+#ifndef WIN32
         if(Temporary)
         {
@@ -120 +123 @@
                 }
         }
+#endif
 }
 

box/chris/merge/lib/common/makeexception.pl.in

@@ -1 +1 @@
 #!@PERL@
+
+use lib "../../infrastructure";
+use BoxPlatform;
 
 # global exception list file
 my $global_list = '../../ExceptionCodes.txt';
-
 
 my @exception;
@@ -47 +49 @@
 print "Generating $class exception...\n";
 
-open CPP,">autogen_${class}Exception.cpp" or die "Can't open cpp file for writing";
-open H,">autogen_${class}Exception.h" or die "Can't open h file for writing";
+open CPP,">autogen_${class}Exception.cpp.new" or die "Can't open cpp file for writing";
+open H,">autogen_${class}Exception.h.new" or die "Can't open h file for writing";
 
 # write header file
@@ -200 +202 @@
 close H;
 close CPP;
+
+update_if_changed("autogen_${class}Exception.cpp");
+update_if_changed("autogen_${class}Exception.h");
 
 # update the global exception list

box/chris/merge/lib/raidfile/RaidFileRead.cpp

@@ -15 +15 @@
 #include <errno.h>
 #include <sys/stat.h>
+
+#ifdef HAVE_SYS_UIO_H
 #include <sys/uio.h>
+#endif
+
+#ifdef HAVE_SYSLOG_H
 #include <syslog.h>
+#endif
+
 #include <stdarg.h>
+
+#ifdef HAVE_DIRENT_H
 #include <dirent.h>
+#endif
 
 #include <stdio.h>
@@ -584 +594 @@
         // Open the parity file
         std::string parityFilename(RaidFileUtil::MakeRaidComponentName(rdiscSet, mFilename, (2 + startDisc) % READ_NUMBER_DISCS_REQUIRED));
-        mParityHandle = ::open(parityFilename.c_str(), O_RDONLY, 0555);
+        mParityHandle = ::open(parityFilename.c_str(), 
+                O_RDONLY | O_BINARY, 0555);
         if(mParityHandle == -1)
         {
@@ -1018 +1029 @@
 
                 // Attempt to open
-                int osFileHandle = ::open(writeFilename.c_str(), O_RDONLY, 0);
+                int osFileHandle = ::open(writeFilename.c_str(), 
+                        O_RDONLY | O_BINARY, 0);
                 if(osFileHandle == -1)
                 {
@@ -1056 +1068 @@
                 {
                         // Open stripe1
-                        stripe1 = ::open(stripe1Filename.c_str(), O_RDONLY, 0555);
+                        stripe1 = ::open(stripe1Filename.c_str(), 
+                                O_RDONLY | O_BINARY, 0555);
                         if(stripe1 == -1)
                         {
@@ -1062 +1075 @@
                         }
                         // Open stripe2
-                        stripe2 = ::open(stripe2Filename.c_str(), O_RDONLY, 0555);
+                        stripe2 = ::open(stripe2Filename.c_str(), 
+                                O_RDONLY | O_BINARY, 0555);
                         if(stripe2 == -1)
                         {
@@ -1170 +1184 @@
                         if(existingFiles & RaidFileUtil::Stripe1Exists)
                         {
-                                stripe1 = ::open(stripe1Filename.c_str(), O_RDONLY, 0555);
+                                stripe1 = ::open(stripe1Filename.c_str(), 
+                                        O_RDONLY | O_BINARY, 0555);
                                 if(stripe1 == -1)
                                 {
@@ -1179 +1194 @@
                         if(existingFiles & RaidFileUtil::Stripe2Exists)
                         {
-                                stripe2 = ::open(stripe2Filename.c_str(), O_RDONLY, 0555);
+                                stripe2 = ::open(stripe2Filename.c_str(), 
+                                        O_RDONLY | O_BINARY, 0555);
                                 if(stripe2 == -1)
                                 {
@@ -1186 +1202 @@
                         }
                         // Open parity
-                        parity = ::open(parityFilename.c_str(), O_RDONLY, 0555);
+                        parity = ::open(parityFilename.c_str(), 
+                                O_RDONLY | O_BINARY, 0555);
                         if(parity == -1)
                         {

box/chris/merge/lib/raidfile/RaidFileWrite.cpp

@@ -105 +105 @@
 
         // Attempt to open
-        mOSFileHandle = ::open(writeFilename.c_str(), O_WRONLY | O_CREAT,
+        mOSFileHandle = ::open(writeFilename.c_str(), 
+                O_WRONLY | O_CREAT | O_BINARY,
                 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
         if(mOSFileHandle == -1)
@@ -116 +117 @@
         int errnoBlock = EWOULDBLOCK;
         if(::flock(mOSFileHandle, LOCK_EX | LOCK_NB) != 0)
-#else
+#elif HAVE_DECL_F_SETLK
         int errnoBlock = EAGAIN;
         struct flock desc;
@@ -124 +125 @@
         desc.l_len = 0;
         if(::fcntl(mOSFileHandle, F_SETLK, &desc) != 0)
+#else
+        int errnoBlock = ENOSYS;
+        if (0)
 #endif
         {
@@ -243 +247 @@
         
         // Rename it into place -- BEFORE it's closed so lock remains
+
+#ifdef WIN32
+        // Except on Win32 which doesn't allow renaming open files
+        // Close file...
+        if(::close(mOSFileHandle) != 0)
+        {
+                THROW_EXCEPTION(RaidFileException, OSError)
+        }
+        mOSFileHandle = -1;
+#endif // WIN32
+
         RaidFileController &rcontroller(RaidFileController::GetController());
         RaidFileDiscSet rdiscSet(rcontroller.GetDiscSet(mSetNumber));
@@ -249 +264 @@
         // And the current name
         std::string renameFrom(renameTo + 'X');
+
+#ifdef WIN32
+        // need to delete the target first
+        if(::unlink(renameTo.c_str()) != 0 && 
+                GetLastError() != ERROR_FILE_NOT_FOUND)
+        {
+                THROW_EXCEPTION(RaidFileException, OSError)
+        }
+#endif
+
         if(::rename(renameFrom.c_str(), renameTo.c_str()) != 0)
         {
@@ -254 +279 @@
         }
         
+#ifndef WIN32   
         // Close file...
         if(::close(mOSFileHandle) != 0)
@@ -260 +286 @@
         }
         mOSFileHandle = -1;
+#endif // !WIN32
         
         // Raid it?
@@ -293 +320 @@
         
         // Unlink and close it
-        if((::unlink(writeFilename.c_str()) != 0)
-                || (::close(mOSFileHandle) != 0))
+
+#ifdef WIN32
+        // On Win32 we must close it first
+        if (::close(mOSFileHandle) != 0 ||
+                ::unlink(writeFilename.c_str()) != 0)
+#else // !WIN32
+        if (::unlink(writeFilename.c_str()) != 0 ||
+                ::close(mOSFileHandle) != 0)
+#endif // !WIN32
         {
                 THROW_EXCEPTION(RaidFileException, OSError)
@@ -389 +423 @@
         {
 #if HAVE_DECL_O_EXLOCK
-                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL | O_EXLOCK)> stripe1(stripe1FilenameW.c_str());
-                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL | O_EXLOCK)> stripe2(stripe2FilenameW.c_str());
-                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL | O_EXLOCK)> parity(parityFilenameW.c_str());
+                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL | O_EXLOCK | O_BINARY)> stripe1(stripe1FilenameW.c_str());
+                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL | O_EXLOCK | O_BINARY)> stripe2(stripe2FilenameW.c_str());
+                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL | O_EXLOCK | O_BINARY)> parity(parityFilenameW.c_str());
 #else
-                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL)> stripe1(stripe1FilenameW.c_str());
-                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL)> stripe2(stripe2FilenameW.c_str());
-                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL)> parity(parityFilenameW.c_str());
+                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL | O_BINARY)> stripe1(stripe1FilenameW.c_str());
+                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL | O_BINARY)> stripe2(stripe2FilenameW.c_str());
+                FileHandleGuard<(O_WRONLY | O_CREAT | O_EXCL | O_BINARY)> parity(parityFilenameW.c_str());
 #endif
 
@@ -531 +565 @@
                 stripe2.Close();
                 stripe1.Close();
+
+#ifdef WIN32
+                // Must delete before renaming
+                #define CHECK_UNLINK(file) \
+                { \
+                        if (::unlink(file) != 0 && errno != ENOENT) \
+                        { \
+                                THROW_EXCEPTION(RaidFileException, OSError); \
+                        } \
+                }
+                CHECK_UNLINK(stripe1Filename.c_str());
+                CHECK_UNLINK(stripe2Filename.c_str());
+                CHECK_UNLINK(parityFilename.c_str());
+                #undef CHECK_UNLINK
+#endif
                 
                 // Rename them into place

box/chris/merge/lib/server/Daemon.cpp

@@ -22 +22 @@
 #ifdef HAVE_SYSLOG_H
         #include <syslog.h>
+#endif
+
+#ifdef WIN32
+        #include <ws2tcpip.h>
 #endif
 
@@ -143 +147 @@
                                 fprintf(stderr, "%s: failed to start: "
                                         "failed to open configuration file: "
-                                        "%s", DaemonName(), 
+                                        "%s\n", DaemonName(), 
                                         mConfigFileName.c_str());
 #ifdef WIN32
@@ -190 +194 @@
                         THROW_EXCEPTION(ServerException, DaemoniseFailed)
                 }
+#endif // !WIN32
                 
                 // Server configuration
@@ -198 +203 @@
                 pidFileName = serverConfig.GetKeyValue("PidFile");
                 FileHandleGuard<(O_WRONLY | O_CREAT | O_TRUNC), (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)> pidFile(pidFileName.c_str());
-                
+        
+#ifndef WIN32   
                 // Handle changing to a different user
                 if(serverConfig.KeyExists("User"))
@@ -268 +274 @@
                 // open the log
                 ::openlog(DaemonName(), LOG_PID, LOG_LOCAL6);
+
                 // Log the start message
                 ::syslog(LOG_INFO, "Starting daemon (config: %s) (version " 
                         BOX_VERSION ")", mConfigFileName.c_str());
 
-#ifndef WIN32
                 // Write PID to file
                 char pid[32];
+
+#ifdef WIN32
+                int pidsize = sprintf(pid, "%d", (int)GetCurrentProcessId());
+#else
                 int pidsize = sprintf(pid, "%d", (int)getpid());
+#endif
+
                 if(::write(pidFile, pid, pidsize) != pidsize)
                 {
@@ -281 +293 @@
                         THROW_EXCEPTION(ServerException, DaemoniseFailed)
                 }
-#endif
                 
                 // Set up memory leak reporting
@@ -353 +364 @@
                 return 1;
         }
+
+#ifdef WIN32
+        // Under win32 we must initialise the Winsock library
+        // before using sockets
+
+        WSADATA info;
+
+        if (WSAStartup(0x0101, &info) == SOCKET_ERROR)
+        {
+                // will not run without sockets
+                ::syslog(LOG_ERR, "Failed to initialise Windows Sockets");
+                THROW_EXCEPTION(CommonException, Internal)
+        }
+#endif
+
+        int retcode = 0;
         
         // Main Daemon running
@@ -382 +409 @@
                                                 errors.c_str());
                                         // And give up
-                                        return 1;
+                                        retcode = 1;
+                                        break;
                                 }
                                 
@@ -410 +438 @@
                         "(%d/%d)", DaemonName(), e.what(), e.GetType(), 
                         e.GetSubType());
-                return 1;
+                retcode = 1;
         }
         catch(std::exception &e)
@@ -416 +444 @@
                 ::syslog(LOG_ERR, "%s: terminating due to exception %s", 
                         DaemonName(), e.what());
-                return 1;
+                retcode = 1;
         }
         catch(...)
@@ -422 +450 @@
                 ::syslog(LOG_ERR, "%s: terminating due to unknown exception",
                         DaemonName());
-                return 1;
-        }
-        
-        return 0;
+                retcode = 1;
+        }
+
+#ifdef WIN32
+        WSACleanup();
+#endif
+        
+        return retcode;
 }
 

box/chris/merge/lib/server/ServerStream.h

@@ -57 +57 @@
         }
 
+        #ifdef WIN32
+        virtual void OnIdle() { }
+        #endif
+
         virtual void Run()
         {
@@ -216 +220 @@
                                         {
                                                 // Since this is a template parameter, the if() will be optimised out by the compiler
+                                                #ifndef WIN32 // no fork on Win32
                                                 if(ForkToHandleRequests)
                                                 {
@@ -256 +261 @@
                                                 else
                                                 {
+                                                #endif // !WIN32
                                                         // Just handle in this connection
                                                         SetProcessTitle("handling");
                                                         HandleConnection(*connection);
                                                         SetProcessTitle("idle");                                                                                
-                                                }
+                                                #ifndef WIN32
+                                                }
+                                                #endif // !WIN32
                                         }
                                 }
-                                
+
+                                #ifdef WIN32
+                                OnIdle();
+                                #else // !WIN32
                                 // Clean up child processes (if forking daemon)
                                 if(ForkToHandleRequests)
@@ -278 +289 @@
                                         } while(p > 0);
                                 }
+                                #endif // !WIN32
                         }
                 }
@@ -302 +314 @@
         bool WillForkToHandleRequests()
         {
+                #ifdef WIN32
+                return false;
+                #else
                 return ForkToHandleRequests;
+                #endif // WIN32
         }
 

box/chris/merge/lib/server/SocketStream.cpp

@@ -37 +37 @@
 // --------------------------------------------------------------------------
 SocketStream::SocketStream()
-        : mSocketHandle(-1),
+        : mSocketHandle(INVALID_SOCKET_VALUE),
           mReadClosed(false),
           mWriteClosed(false),
@@ -86 +86 @@
                 THROW_EXCEPTION(ServerException, BadSocketHandle);
         }
-        if(mSocketHandle == -1)
+        if(mSocketHandle == INVALID_SOCKET_VALUE)
         {
                 THROW_EXCEPTION(ServerException, DupError);
@@ -102 +102 @@
 SocketStream::~SocketStream()
 {
-        if(mSocketHandle != -1)
+        if(mSocketHandle != INVALID_SOCKET_VALUE)
         {
                 Close();
@@ -118 +118 @@
 void SocketStream::Attach(int socket)
 {
-        if(mSocketHandle != -1) {THROW_EXCEPTION(ServerException, SocketAlreadyOpen)}
+        if(mSocketHandle != INVALID_SOCKET_VALUE) 
+        {
+                THROW_EXCEPTION(ServerException, SocketAlreadyOpen)
+        }
 
         mSocketHandle = socket;
@@ -135 +138 @@
 void SocketStream::Open(int Type, const char *Name, int Port)
 {
-        if(mSocketHandle != -1) {THROW_EXCEPTION(ServerException, SocketAlreadyOpen)}
+        if(mSocketHandle != INVALID_SOCKET_VALUE) 
+        {
+                THROW_EXCEPTION(ServerException, SocketAlreadyOpen)
+        }
         
         // Setup parameters based on type, looking up names if required
@@ -145 +151 @@
         // Create the socket
         mSocketHandle = ::socket(sockDomain, SOCK_STREAM, 0 /* let OS choose protocol */);
-        if(mSocketHandle == -1)
+        if(mSocketHandle == INVALID_SOCKET_VALUE)
         {
                 THROW_EXCEPTION(ServerException, SocketOpenError)
@@ -159 +165 @@
                 ::close(mSocketHandle);
 #endif
-                mSocketHandle = -1;
+                mSocketHandle = INVALID_SOCKET_VALUE;
                 THROW_EXCEPTION(ConnectionException, Conn_SocketConnectError)
         }
@@ -175 +181 @@
 int SocketStream::Read(void *pBuffer, int NBytes, int Timeout)
 {
-        if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+        if(mSocketHandle == INVALID_SOCKET_VALUE) 
+        {
+                THROW_EXCEPTION(ServerException, BadSocketHandle)
+        }
 
         if(Timeout != IOStream::TimeOutInfinite)
@@ -248 +257 @@
 void SocketStream::Write(const void *pBuffer, int NBytes)
 {
-        if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+        if(mSocketHandle == INVALID_SOCKET_VALUE) 
+        {
+                THROW_EXCEPTION(ServerException, BadSocketHandle)
+        }
         
         // Buffer in byte sized type.
@@ -312 +324 @@
 void SocketStream::Close()
 {
-        if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+        if(mSocketHandle == INVALID_SOCKET_VALUE) 
+        {
+                THROW_EXCEPTION(ServerException, BadSocketHandle)
+        }
 #ifdef WIN32
         if(::closesocket(mSocketHandle) == -1)
@@ -321 +336 @@
                 THROW_EXCEPTION(ServerException, SocketCloseError)
         }
-        mSocketHandle = -1;
+        mSocketHandle = INVALID_SOCKET_VALUE;
 }
 
@@ -334 +349 @@
 void SocketStream::Shutdown(bool Read, bool Write)
 {
-        if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+        if(mSocketHandle == INVALID_SOCKET_VALUE) 
+        {
+                THROW_EXCEPTION(ServerException, BadSocketHandle)
+        }
         
         // Do anything?
@@ -389 +407 @@
 tOSSocketHandle SocketStream::GetSocketHandle()
 {
-        if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+        if(mSocketHandle == INVALID_SOCKET_VALUE) 
+        {
+                THROW_EXCEPTION(ServerException, BadSocketHandle)
+        }
         return mSocketHandle;
 }

box/chris/merge/lib/server/SocketStream.h

@@ -15 +15 @@
 #ifdef WIN32
         typedef SOCKET tOSSocketHandle;
+        #define INVALID_SOCKET_VALUE (tOSSocketHandle)(-1)
 #else
         typedef int tOSSocketHandle;
+        #define INVALID_SOCKET_VALUE -1
 #endif
 

box/chris/merge/lib/server/SocketStreamTLS.cpp

@@ -138 +138 @@
         }
 
-#ifndef WIN32
         // Make the socket non-blocking so timeouts on Read work
+
+#ifdef WIN32
+        u_long nonblocking = 1;
+        ioctlsocket(socket, FIONBIO, &nonblocking);
+#else // !WIN32
         // This is more portable than using ioctl with FIONBIO
         int statusFlags = 0;
@@ -310 +314 @@
                 case SSL_ERROR_WANT_READ:
                 case SSL_ERROR_WANT_WRITE:
-                        // wait for the requried data
+                        // wait for the required data
                         // Will only get once around this loop, so don't need to calculate timeout values
                         if(WaitWhenRetryRequired(se, Timeout) == false)

box/chris/merge/lib/server/makeprotocol.pl.in

@@ -1 +1 @@
 #!@PERL@
 use strict;
+
+use lib "../../infrastructure";
+use BoxPlatform;
 
 # Make protocol C++ classes from a protocol description file
@@ -168 +171 @@
 # open files
 my $h_filename = 'autogen_'.$protocol_name.'Protocol'.$type.'.h';
-open CPP,'>autogen_'.$protocol_name.'Protocol'.$type.'.cpp';
-open H,">$h_filename";
+open CPP,'>autogen_'.$protocol_name.'Protocol'.$type.'.cpp.new';
+open H,">$h_filename.new";
 
 print CPP <<__E;
@@ -913 +916 @@
 close CPP;
 
+update_if_changed('autogen_'.$protocol_name.'Protocol'.$type.'.cpp');
+update_if_changed($h_filename);
 
 sub obj_is_type
@@ -982 +987 @@
                         # need to translate it
                         my ($format,$arg) = @{$log_display_types{$ty}};
+                        $arg =~ s/VAR/m$nm/g;
+
+                        if ($format eq "0x%llx" and $target_windows)
+                        {
+                                $format = "0x%I64x";
+                                $arg = "(uint64_t)$arg";
+                        }
+
                         push @str,$format;
-                        $arg =~ s/VAR/m$nm/g;
                         push @arg,$arg;
                 }

box/chris/merge/runtest.pl.in

@@ -1 +1 @@
 #!@PERL@
+
+use strict;
+use warnings;
 
 use lib 'infrastructure';
@@ -6 +9 @@
 my ($test_name,$test_mode) = @ARGV;
 
-$test_mode = 'debug' if $test_mode eq '';
+$test_mode = 'debug' if not defined $test_mode or $test_mode eq '';
 
 if($test_name eq '' || ($test_mode ne 'debug' && $test_mode ne 'release'))
@@ -18 +21 @@
 
 __E
-        exit(0);
+        exit(2);
 }
 
 my @results;
+my $exit_code = 0;
 
 if($test_name ne 'ALL')
 {
-        # run one test
-        runtest($test_name);
+        # run one or more specified test
+        if ($test_name =~ m/,/)
+        {
+                foreach my $test (split m/,/, $test_name)
+                {
+                        runtest($test);
+                }
+        }
+        else
+        {
+                runtest($test_name);
+        }
 }
 else
@@ -58 +72 @@
 print "--------\n",join("\n",@results),"\n";
 
+exit $exit_code;
+
 sub runtest
 {
@@ -68 +84 @@
         {
                 push @results,"$t: make failed";
+                $exit_code = 2;
                 return;
         }
@@ -83 +100 @@
                 }
                 close RESULTS;
+
                 chomp $last;
                 push @results,"$t: $last";
+
+                if ($last ne "PASSED") 
+                { 
+                        $exit_code = 1;
+                }
         }
         else

box/chris/merge/test/backupdiff/testbackupdiff.cpp

@@ -67 +67 @@
 void make_file_of_zeros(const char *filename, size_t size)
 {
-        static const size_t bs = 0x10000;
-        size_t remSize = size;
-        void *b = malloc(bs);
-        memset(b, 0, bs);
-        FILE *f = fopen(filename, "wb");
-
-        // Using largish blocks like this is much faster, while not consuming too much RAM
-        while(remSize > bs)
-        {
-                fwrite(b, bs, 1, f);
-                remSize -= bs;
-        }
-        fwrite(b, remSize, 1, f);
-
-        fclose(f);
-        free(b);
+        #ifdef WIN32
+        HANDLE handle = openfile(filename, O_WRONLY | O_CREAT | O_EXCL, 0);
+        TEST_THAT(handle != INVALID_HANDLE_VALUE);
+        SetFilePointer(handle, size, NULL, FILE_BEGIN);
+        TEST_THAT(GetLastError() == NO_ERROR);
+        TEST_THAT(SetEndOfFile(handle) == true);
+        TEST_THAT(CloseHandle(handle)  == true);
+        #else
+        int fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0600);
+        if (fd < 0) perror(filename);
+        TEST_THAT(fd >= 0);
+        TEST_THAT(ftruncate(fd, size) == 0);
+        TEST_THAT(close(fd) == 0);
+        #endif
 
         TEST_THAT((size_t)TestGetFileSize(filename) == size);
@@ -119 +117 @@
                 {
                         nnew++;
+                        #ifdef WIN32
+                        TRACE2("%8I64d this  s=%8I64d", b, s);
+                        #else
                         TRACE2("%8lld this  s=%8lld", b, s);
+                        #endif
                 }
                 else
                 {
                         nold++;
+                        #ifdef WIN32
+                        TRACE2("%8I64d other i=%8I64d", b, 0 - s);              
+                        #else
                         TRACE2("%8lld other i=%8lld", b, 0 - s);                
+                        #endif
                 }
                 // Decode the rest
@@ -208 +214 @@
         else
         {
+#ifdef WIN32
+                // Emulate the above stage!
+                char src[256], dst[256];
+                sprintf(src, "testfiles\\f%d.diff", to);
+                sprintf(dst, "testfiles\\f%d.encoded", to);
+                TEST_THAT(CopyFile(src, dst, FALSE) != 0)
+#else
                 // Emulate the above stage!
                 char cmd[256];
                 sprintf(cmd, "cp testfiles/f%d.diff testfiles/f%d.encoded", to, to);
                 ::system(cmd);
+#endif
         }
 
@@ -356 +370 @@
         // Want to trace out all the details
         #ifndef NDEBUG
+        #ifndef WIN32
         BackupStoreFile::TraceDetailsOfDiffProcess = true;
+        #endif
         #endif
 
@@ -371 +387 @@
                 std::auto_ptr<IOStream> encoded(BackupStoreFile::EncodeFile("testfiles/f0", 1 /* dir ID */, f0name));
                 encoded->CopyStreamTo(out);
+                out.Close();
                 check_encoded_file("testfiles/f0.encoded", 0, 33, 0);
         }
@@ -431 +448 @@
                         std::auto_ptr<IOStream> encoded(BackupStoreFile::EncodeFile("testfiles/f9", 1 /* dir ID */, fn));
                         encoded->CopyStreamTo(out);
+                        out.Close();
                         check_encoded_file("testfiles/f9.zerotest", 0, 0, 0);           
                 }
@@ -441 +459 @@
         }
         
+#ifndef WIN32   
         // Check that symlinks aren't diffed
         TEST_THAT(::symlink("f2", "testfiles/f2.symlink") == 0)
@@ -468 +487 @@
                 check_encoded_file("testfiles/f2.symlink.diff", 0, 0, 0);               
         }
-
-        // Check that diffing against a file which isn't "complete" and referes another isn't allowed
+#endif
+
+        // Check that diffing against a file which isn't "complete" and 
+        // references another isn't allowed
         {
                 FileStream blockindex("testfiles/f1.diff");
@@ -481 +502 @@
         }
 
-        // Found a nasty case where files of lots of the same thing sock up lots of processor
-        // time -- because of lots of matches found. Check this out!
+        // Found a nasty case where files of lots of the same thing 
+        // suck up lots of processor time -- because of lots of matches 
+        // found. Check this out!
+
+        #ifdef WIN32
+        ::fprintf(stdout, "Testing diffing two large streams, "
+                "may take a while!\n");
+        ::fflush(stdout);
+        #endif
+
         make_file_of_zeros("testfiles/zero.0", 20*1024*1024);
         make_file_of_zeros("testfiles/zero.1", 200*1024*1024);
+
         // Generate a first encoded file
         {
@@ -504 +534 @@
                         0, 0));
                 encoded->CopyStreamTo(out);
+
+                printf("Time taken: %d seconds\n", (int)(time(0) - beginTime));
+
+                #ifdef WIN32
+                TEST_THAT(time(0) < (beginTime + 300));
+                #else
                 TEST_THAT(time(0) < (beginTime + 40));
+                #endif
         }
         // Remove zero-files to save disk space

box/chris/merge/test/backupstore/testbackupstore.cpp

@@ -426 +426 @@
         
         free(data);
-        unlink("testfiles/test_download");
+        in.Close();
+        TEST_THAT(unlink("testfiles/test_download") == 0);
 }
 
@@ -931 +932 @@
                 TEST_THAT(loginConf->GetClientStoreMarker() == 0);
 
+#ifndef WIN32
                 // Check that we can't open a new connection which requests write permissions
                 {
@@ -942 +944 @@
                         protocol.QueryFinished();
                 }
+#endif
                 
                 // Set the client store marker
                 protocol.QuerySetClientStoreMarker(0x8732523ab23aLL);
 
+#ifndef WIN32
                 // Open a new connection which is read only
                 SocketStreamTLS connReadOnly;
@@ -964 +968 @@
                         TEST_THAT(loginConf->GetClientStoreMarker() == 0x8732523ab23aLL);
                 }
+#else // WIN32
+                BackupProtocolClient& protocolReadOnly(protocol);
+#endif
 
                 test_server_1(protocol, protocolReadOnly);
-
-
                 // Create and upload some test files
                 int64_t maxID = 0;
@@ -1439 +1444 @@
                         
                 // Finish the connections
+#ifndef WIN32
                 protocolReadOnly.QueryFinished();
+#endif
                 protocol.QueryFinished();
                 
                 // Close logs
+#ifndef WIN32
                 ::fclose(protocolReadOnlyLog);
+#endif
                 ::fclose(protocolLog);
         }
@@ -1521 +1530 @@
                 // The test block to a file
                 {
-                        FileStream f("testfiles/testenc1", O_WRONLY | O_CREAT | O_EXCL);
+                        FileStream f("testfiles" DIRECTORY_SEPARATOR 
+                                "testenc1", O_WRONLY | O_CREAT | O_EXCL);
                         f.Write(encfile, sizeof(encfile));
                 }
@@ -1527 +1537 @@
                 // Encode it
                 {
-                        FileStream out("testfiles/testenc1_enc", O_WRONLY | O_CREAT | O_EXCL);
-                        BackupStoreFilenameClear name("testfiles/testenc1");
-
-                        std::auto_ptr<IOStream> encoded(BackupStoreFile::EncodeFile("testfiles/testenc1", 32, name));
+                        FileStream out("testfiles" DIRECTORY_SEPARATOR 
+                                "testenc1_enc", O_WRONLY | O_CREAT | O_EXCL);
+                        BackupStoreFilenameClear name("testfiles"
+                                DIRECTORY_SEPARATOR "testenc1");
+
+                        std::auto_ptr<IOStream> encoded(
+                                BackupStoreFile::EncodeFile(
+                                        "testfiles" DIRECTORY_SEPARATOR
+                                        "testenc1", 32, name));
                         encoded->CopyStreamTo(out);
                 }
@@ -1536 +1551 @@
                 // Verify it
                 {
-                        FileStream enc("testfiles/testenc1_enc");
+                        FileStream enc("testfiles" DIRECTORY_SEPARATOR 
+                                "testenc1_enc");
                         TEST_THAT(BackupStoreFile::VerifyEncodedFileFormat(enc) == true);
                 }
@@ -1542 +1558 @@
                 // Decode it
                 {
-                        FileStream enc("testfiles/testenc1_enc");
-                        BackupStoreFile::DecodeFile(enc, "testfiles/testenc1_orig", IOStream::TimeOutInfinite);
+                        FileStream enc("testfiles" DIRECTORY_SEPARATOR 
+                                "testenc1_enc");
+                        BackupStoreFile::DecodeFile(enc, "testfiles"
+                                DIRECTORY_SEPARATOR "testenc1_orig", 
+                                IOStream::TimeOutInfinite);
                 }
                 
                 // Read in rebuilt original, and compare contents
                 {
-                        TEST_THAT(TestGetFileSize("testfiles/testenc1_orig") == sizeof(encfile));
-                        FileStream in("testfiles/testenc1_orig");
+                        TEST_THAT(TestGetFileSize("testfiles" 
+                                DIRECTORY_SEPARATOR "testenc1_orig") 
+                                == sizeof(encfile));
+                        FileStream in("testfiles" DIRECTORY_SEPARATOR 
+                                "testenc1_orig");
                         int encfile_i[ENCFILE_SIZE];
                         in.Read(encfile_i, sizeof(encfile_i));
@@ -1557 +1579 @@
                 // Check how many blocks it had, and test the stream based interface
                 {
-                        FileStream enc("testfiles/testenc1_enc");
+                        FileStream enc("testfiles" DIRECTORY_SEPARATOR 
+                                "testenc1_enc");
                         std::auto_ptr<BackupStoreFile::DecodedStream> decoded(BackupStoreFile::DecodeFileStream(enc, IOStream::TimeOutInfinite));
                         CollectInBufferStream d;
@@ -1571 +1594 @@
                 {
                         #define FILE_SIZE_JUST_OVER     ((4096*2)+58)
-                        FileStream f("testfiles/testenc2", O_WRONLY | O_CREAT | O_EXCL);
+                        FileStream f("testfiles" DIRECTORY_SEPARATOR 
+                                "testenc2", O_WRONLY | O_CREAT | O_EXCL);
                         f.Write(encfile + 2, FILE_SIZE_JUST_OVER);
+                        f.Close();
                         BackupStoreFilenameClear name("testenc2");
-                        std::auto_ptr<IOStream> encoded(BackupStoreFile::EncodeFile("testfiles/testenc2", 32, name));
+                        std::auto_ptr<IOStream> encoded(
+                                BackupStoreFile::EncodeFile(
+                                        "testfiles" DIRECTORY_SEPARATOR
+                                        "testenc2", 32, name));
                         CollectInBufferStream e;
                         encoded->CopyStreamTo(e);
@@ -1590 +1618 @@
                 // Test that reordered streams work too
                 {
-                        FileStream enc("testfiles/testenc1_enc");
+                        FileStream enc("testfiles" DIRECTORY_SEPARATOR 
+                                "testenc1_enc");
                         std::auto_ptr<IOStream> reordered(BackupStoreFile::ReorderFileToStreamOrder(&enc, false));
                         std::auto_ptr<BackupStoreFile::DecodedStream> decoded(BackupStoreFile::DecodeFileStream(*reordered, IOStream::TimeOutInfinite));
@@ -1602 +1631 @@
                 }
                 
+#ifndef WIN32           
                 // Try out doing this on a symlink
                 {
@@ -1615 +1645 @@
                         BackupStoreFile::DecodeFile(b, "testfiles/testsymlink_2", IOStream::TimeOutInfinite);
                 }
+#endif
         }
 
@@ -1620 +1651 @@
         {
                 RaidFileWrite::CreateDirectory(0, "test-info");
-                BackupStoreInfo::CreateNew(76, "test-info/", 0, 3461231233455433LL, 2934852487LL);
-                TEST_CHECK_THROWS(BackupStoreInfo::CreateNew(76, "test-info/", 0, 0, 0), RaidFileException, CannotOverwriteExistingFile);
-                std::auto_ptr<BackupStoreInfo> info(BackupStoreInfo::Load(76, "test-info/", 0, true));
+                BackupStoreInfo::CreateNew(76, "test-info" DIRECTORY_SEPARATOR, 
+                        0, 3461231233455433LL, 2934852487LL);
+                TEST_CHECK_THROWS(BackupStoreInfo::CreateNew(76, 
+                        "test-info" DIRECTORY_SEPARATOR, 0, 0, 0), 
+                        RaidFileException, CannotOverwriteExistingFile);
+                std::auto_ptr<BackupStoreInfo> info(
+                        BackupStoreInfo::Load(76, 
+                                "test-info" DIRECTORY_SEPARATOR, 0, true));
                 TEST_CHECK_THROWS(info->Save(), BackupStoreException, StoreInfoIsReadOnly);
                 TEST_CHECK_THROWS(info->ChangeBlocksUsed(1), BackupStoreException, StoreInfoIsReadOnly);
@@ -1631 +1667 @@
         }
         {
-                std::auto_ptr<BackupStoreInfo> info(BackupStoreInfo::Load(76, "test-info/", 0, false));
+                std::auto_ptr<BackupStoreInfo> info(BackupStoreInfo::Load(76, 
+                        "test-info" DIRECTORY_SEPARATOR, 0, false));
                 info->ChangeBlocksUsed(8);
                 info->ChangeBlocksInOldFiles(9);
@@ -1649 +1686 @@
         }
         {
-                std::auto_ptr<BackupStoreInfo> info(BackupStoreInfo::Load(76, "test-info/", 0, true));
+                std::auto_ptr<BackupStoreInfo> info(BackupStoreInfo::Load(76, 
+                        "test-info" DIRECTORY_SEPARATOR, 0, true));
                 TEST_THAT(info->GetBlocksUsed() == 7);
                 TEST_THAT(info->GetBlocksInOldFiles() == 5);
@@ -1667 +1705 @@
         TLSContext context;
         context.Initialise(false /* client */,
-                        "testfiles/clientCerts.pem",
-                        "testfiles/clientPrivKey.pem",
-                        "testfiles/clientTrustedCAs.pem");
+                        "testfiles" DIRECTORY_SEPARATOR "clientCerts.pem",
+                        "testfiles" DIRECTORY_SEPARATOR "clientPrivKey.pem",
+                        "testfiles" DIRECTORY_SEPARATOR "clientTrustedCAs.pem");
 
         // First, try logging in without an account having been created... just make sure login fails.
+
+#ifdef WIN32
+        int pid = LaunchServer("..\\..\\bin\\bbstored\\bbstored testfiles/bbstored.conf", "testfiles/bbstored.pid");
+#else
         int pid = LaunchServer("../../bin/bbstored/bbstored testfiles/bbstored.conf", "testfiles/bbstored.pid");
+#endif
+
         TEST_THAT(pid != -1 && pid != 0);
         if(pid > 0)
@@ -1701 +1745 @@
 
                 // Create an account for the test client
+#ifdef WIN32
+                TEST_THAT_ABORTONFAIL(::system("..\\..\\bin\\bbstoreaccounts\\bbstoreaccounts -c testfiles/bbstored.conf create 01234567 0 10000B 20000B") == 0);
+#else
                 TEST_THAT_ABORTONFAIL(::system("../../bin/bbstoreaccounts/bbstoreaccounts -c testfiles/bbstored.conf create 01234567 0 10000B 20000B") == 0);
                 TestRemoteProcessMemLeaks("bbstoreaccounts.memleaks");
+#endif
+
                 TEST_THAT(TestDirExists("testfiles/0_0/backup/01234567"));
                 TEST_THAT(TestDirExists("testfiles/0_1/backup/01234567"));
@@ -1726 +1775 @@
                 ::sleep(1);
                 TEST_THAT(!ServerIsAlive(pid));
+#ifndef WIN32
                 TestRemoteProcessMemLeaks("bbstored.memleaks");
+#endif
                 
                 // Set a new limit on the account -- leave the hard limit high to make sure the target for
                 // freeing space is the soft limit.
+
+#ifdef WIN32
+                TEST_THAT_ABORTONFAIL(::system("..\\..\\bin\\bbstoreaccounts\\bbstoreaccounts -c testfiles/bbstored.conf setlimit 01234567 10B 20000B") == 0);
+#else
                 TEST_THAT_ABORTONFAIL(::system("../../bin/bbstoreaccounts/bbstoreaccounts -c testfiles/bbstored.conf setlimit 01234567 10B 20000B") == 0);
                 TestRemoteProcessMemLeaks("bbstoreaccounts.memleaks");
+#endif
 
                 // Start things up
+#ifdef WIN32
+                pid = LaunchServer("..\\..\\bin\\bbstored\\bbstored testfiles/bbstored.conf", "testfiles/bbstored.pid");
+#else
                 pid = LaunchServer("../../bin/bbstored/bbstored testfiles/bbstored.conf", "testfiles/bbstored.pid");
+#endif
+
                 ::sleep(1);
                 TEST_THAT(ServerIsAlive(pid));
@@ -1759 +1820 @@
                 
                 // Set a really small hard limit
+#ifdef WIN32
+                TEST_THAT_ABORTONFAIL(::system("..\\..\\bin\\bbstoreaccounts\\bbstoreaccounts -c testfiles/bbstored.conf setlimit 01234567 10B 20B") == 0);
+#else
                 TEST_THAT_ABORTONFAIL(::system("../../bin/bbstoreaccounts/bbstoreaccounts -c testfiles/bbstored.conf setlimit 01234567 10B 20B") == 0);
                 TestRemoteProcessMemLeaks("bbstoreaccounts.memleaks");
+#endif
 
                 // Try to upload a file and create a directory, and check an error is generated
@@ -1809 +1874 @@
                 ::sleep(1);
                 TEST_THAT(!ServerIsAlive(pid));
+
+#ifndef WIN32
                 TestRemoteProcessMemLeaks("bbstored.memleaks");
+#endif
         }
 
@@ -1821 +1889 @@
         // Create an account for the test client
         TEST_THAT_ABORTONFAIL(::system("../../bin/bbstoreaccounts/bbstoreaccounts -c testfiles/bbstored.conf create 01234567 0 30000B 40000B") == 0);
+
+#ifndef WIN32
         TestRemoteProcessMemLeaks("bbstoreaccounts.memleaks");
+#endif
 
         // First, try logging in without an account having been created... just make sure login fails.
+
+#ifdef WIN32
+        int pid = LaunchServer("..\\..\\bin\\bbstored\\bbstored testfiles/bbstored_multi.conf", "testfiles/bbstored.pid");
+#else
         int pid = LaunchServer("../../bin/bbstored/bbstored testfiles/bbstored_multi.conf", "testfiles/bbstored.pid");
+#endif
+
         TEST_THAT(pid != -1 && pid != 0);
         if(pid > 0)
@@ -1841 +1918 @@
                 ::sleep(1);
                 TEST_THAT(!ServerIsAlive(pid));
+#ifndef WIN32
                 TestRemoteProcessMemLeaks("bbstored.memleaks");
+#endif
         }
 
@@ -1848 +1927 @@
 }
 
+#ifdef WIN32
+WCHAR* ConvertUtf8ToWideString(const char* pString);
+std::string ConvertPathToAbsoluteUnicode(const char *pFileName);
+#endif
+
 int test(int argc, const char *argv[])
 {
+#ifdef WIN32
+        // Under win32 we must initialise the Winsock library
+        // before using sockets
+
+        WSADATA info;
+        TEST_THAT(WSAStartup(0x0101, &info) != SOCKET_ERROR)
+
+        // this had better work, or bbstored will die when combining diffs
+        char* file = "foo";
+        std::string abs = ConvertPathToAbsoluteUnicode(file);
+        WCHAR* wfile = ConvertUtf8ToWideString(abs.c_str());
+
+        DWORD accessRights = FILE_READ_ATTRIBUTES | 
+                FILE_LIST_DIRECTORY | FILE_READ_EA | FILE_WRITE_ATTRIBUTES |
+                FILE_WRITE_DATA | FILE_WRITE_EA /*| FILE_ALL_ACCESS*/;
+        DWORD shareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
+
+        HANDLE h1 = CreateFileW(wfile, accessRights, shareMode,
+                NULL, OPEN_ALWAYS, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+        assert(h1 != INVALID_HANDLE_VALUE);
+        TEST_THAT(h1 != INVALID_HANDLE_VALUE);
+
+        accessRights = FILE_READ_ATTRIBUTES | 
+                FILE_LIST_DIRECTORY | FILE_READ_EA;
+
+        HANDLE h2 = CreateFileW(wfile, accessRights, shareMode,
+                NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+        assert(h2 != INVALID_HANDLE_VALUE);
+        TEST_THAT(h2 != INVALID_HANDLE_VALUE);
+
+        CloseHandle(h2);
+        CloseHandle(h1);
+
+        h1 = openfile("foo", O_CREAT | O_RDWR, 0);
+        TEST_THAT(h1 != INVALID_HANDLE_VALUE);
+        h2 = openfile("foo", O_RDWR, 0);
+        TEST_THAT(h2 != INVALID_HANDLE_VALUE);
+        CloseHandle(h2);
+        CloseHandle(h1);
+#endif
+
         // SSL library
         SSLLib::Initialise();
@@ -1866 +1991 @@
         // Use the setup crypto command to set up all these keys, so that the bbackupquery command can be used
         // for seeing what's going on.
+#ifdef WIN32
+        BackupClientCryptoKeys_Setup("testfiles\\bbackupd.keys");       
+#else
         BackupClientCryptoKeys_Setup("testfiles/bbackupd.keys");        
+#endif
         
         // encode in some filenames -- can't do static initialisation because the key won't be set up when these are initialised

box/chris/merge/test/backupstorefix/testfiles/testbackupstorefix.pl.in

@@ -55 +55 @@
         while(<INITIAL>)
         {
-                chomp;
+                chomp; s/\r//;
                 $expected{$_} = 1;
                 m/\A(.+?) .+? (.+)\Z/;
@@ -100 +100 @@
         {
                 print LISTING_COPY;
-                chomp;
+                chomp; s/\r//;
                 s/\[FILENAME NOT ENCRYPTED\]//;
                 if(exists $expected{$_})

box/chris/merge/test/backupstorepatch/testbackupstorepatch.cpp

@@ -284 +284 @@
 int test(int argc, const char *argv[])
 {
+#ifdef WIN32
+        // Under win32 we must initialise the Winsock library
+        // before using sockets
+
+        WSADATA info;
+        TEST_THAT(WSAStartup(0x0101, &info) != SOCKET_ERROR)
+#endif
+
         // Allocate a buffer
         buffer = ::malloc(BUFFER_SIZE);
@@ -310 +318 @@
 
         // Create an account
+#ifdef WIN32
+        TEST_THAT_ABORTONFAIL(::system("..\\..\\bin\\bbstoreaccounts\\bbstoreaccounts -c testfiles/bbstored.conf create 01234567 0 30000B 40000B") == 0);
+#else
         TEST_THAT_ABORTONFAIL(::system("../../bin/bbstoreaccounts/bbstoreaccounts -c testfiles/bbstored.conf create 01234567 0 30000B 40000B") == 0);
         TestRemoteProcessMemLeaks("bbstoreaccounts.memleaks");
+#endif
 
         // Create test files
@@ -320 +332 @@
 
         // First, try logging in without an account having been created... just make sure login fails.
+#ifdef WIN32
+        int pid = LaunchServer("..\\..\\bin\\bbstored\\bbstored testfiles/bbstored.conf", "testfiles/bbstored.pid");
+#else
         int pid = LaunchServer("../../bin/bbstored/bbstored testfiles/bbstored.conf", "testfiles/bbstored.pid");
+#endif
+
         TEST_THAT(pid != -1 && pid != 0);
         if(pid > 0)
@@ -398 +415 @@
                                         test_files[f].IDOnServer = stored->GetObjectID();
                                         test_files[f].IsCompletelyDifferent = isCompletelyDifferent;
-                                        printf("ID %lld, completely different: %s\n", test_files[f].IDOnServer,
+
+#ifdef WIN32
+                                        printf("ID %I64d, completely different: %s\n",
+#else
+                                        printf("ID %lld, completely different: %s\n", 
+#endif
+                                                test_files[f].IDOnServer,
                                                 test_files[f].IsCompletelyDifferent?"yes":"no");                        
                                 }
@@ -566 +589 @@
                         }
 
-                        // Send the server a restart signal, so it does housekeeping immedaitely, and wait for it to happen
+#ifdef WIN32
+                        wait_for_operation(12);
+#else
+                        // Send the server a restart signal, so it does housekeeping immediately, and wait for it to happen
                         ::sleep(1);     // wait for old connections to terminate
                         ::kill(pid, SIGHUP);
+#endif
+
                         // Get the revision number of the info file
                         int64_t first_revision = 0;
@@ -612 +640 @@
                 TEST_THAT(KillServer(pid));
                 TEST_THAT(!ServerIsAlive(pid));
+
+                #ifndef WIN32
                 TestRemoteProcessMemLeaks("bbstored.memleaks");
+                #endif
         }
         

box/chris/merge/test/basicserver/TestCommands.cpp

@@ -2 +2 @@
 #include "Box.h"
 
+#ifdef HAVE_SYSLOG_H
 #include <syslog.h>
+#endif
 
 #include "autogen_TestProtocolServer.h"

box/chris/merge/test/basicserver/testbasicserver.cpp

@@ -32 +32 @@
 #include "MemLeakFindOn.h"
 
-
 #define SERVER_LISTEN_PORT      2003
 
@@ -63 +62 @@
 void testservers_pause_before_reply()
 {
-         struct timespec t;
-         t.tv_sec = 0;
-         t.tv_nsec = COMMS_SERVER_WAIT_BEFORE_REPLYING * 1000 * 1000;   // convert to ns
-         ::nanosleep(&t, NULL);
+#ifdef WIN32
+        Sleep(COMMS_SERVER_WAIT_BEFORE_REPLYING);
+#else
+        struct timespec t;
+        t.tv_sec = 0;
+        t.tv_nsec = COMMS_SERVER_WAIT_BEFORE_REPLYING * 1000 * 1000;    // convert to ns
+        ::nanosleep(&t, NULL);
+#endif
 }
 
@@ -428 +431 @@
         }
 
+#ifdef WIN32
+        // Under win32 we must initialise the Winsock library
+        // before using sockets
+
+        WSADATA info;
+        TEST_THAT(WSAStartup(0x0101, &info) != SOCKET_ERROR)
+#endif
+
 //printf("SKIPPING TESTS------------------------\n");
 //goto protocolserver;
@@ -433 +444 @@
         // Launch a basic server
         {
-                int pid = LaunchServer("./test srv1 testfiles/srv1.conf", "testfiles/srv1.pid");
+#ifdef WIN32
+                int pid = LaunchServer("test srv1 testfiles\\srv1.conf", 
+                        "testfiles\\srv1.pid");
+#else
+                int pid = LaunchServer("./test srv1 testfiles/srv1.conf", 
+                        "testfiles/srv1.pid");
+#endif
+
                 TEST_THAT(pid != -1 && pid != 0);
                 if(pid > 0)
                 {
                         // Check that it's written the expected file
-                        TEST_THAT(TestFileExists("testfiles/srv1.test1"));
+                        TEST_THAT(TestFileExists("testfiles" 
+                                DIRECTORY_SEPARATOR "srv1.test1"));
                         TEST_THAT(ServerIsAlive(pid));
                         // Move the config file over
-                        TEST_THAT(::rename("testfiles/srv1b.conf", "testfiles/srv1.conf") != -1);
+#ifdef WIN32
+                        TEST_THAT(::unlink("testfiles" DIRECTORY_SEPARATOR 
+                                "srv1.conf") != -1);
+#endif
+                        TEST_THAT(::rename(
+                                "testfiles" DIRECTORY_SEPARATOR "srv1b.conf", 
+                                "testfiles" DIRECTORY_SEPARATOR "srv1.conf") 
+                                != -1);
+#ifndef WIN32
                         // Get it to reread the config file
                         TEST_THAT(HUPServer(pid));
@@ -447 +474 @@
                         TEST_THAT(ServerIsAlive(pid));
                         // Check that new file exists
-                        TEST_THAT(TestFileExists("testfiles/srv1.test2"));
+                        TEST_THAT(TestFileExists("testfiles" 
+                                DIRECTORY_SEPARATOR "srv1.test2"));
+#endif // !WIN32
                         // Kill it off
                         TEST_THAT(KillServer(pid));
+#ifndef WIN32
                         TestRemoteProcessMemLeaks("generic-daemon.memleaks");
+#endif // !WIN32
                 }
         }
@@ -456 +487 @@
         // Launch a test forking server
         {
-                int pid = LaunchServer("./test srv2 testfiles/srv2.conf", "testfiles/srv2.pid");
+#ifdef WIN32
+                int pid = LaunchServer("test srv2 testfiles\\srv2.conf", 
+                        "testfiles\\srv2.pid");
+#else
+                int pid = LaunchServer("./test srv2 testfiles/srv2.conf", 
+                        "testfiles/srv2.pid");
+#endif
+
                 TEST_THAT(pid != -1 && pid != 0);
                 if(pid > 0)
@@ -462 +500 @@
                         // Will it restart?
                         TEST_THAT(ServerIsAlive(pid));
+#ifndef WIN32
                         TEST_THAT(HUPServer(pid));
                         ::sleep(1);
                         TEST_THAT(ServerIsAlive(pid));
+#endif // !WIN32
                         // Make some connections
                         {
                                 SocketStream conn1;
                                 conn1.Open(Socket::TypeINET, "localhost", 2003);
+#ifndef WIN32
                                 SocketStream conn2;
                                 conn2.Open(Socket::TypeUNIX, "testfiles/srv2.sock");
                                 SocketStream conn3;
                                 conn3.Open(Socket::TypeINET, "localhost", 2003);
+#endif // !WIN32
                                 // Quick check that reconnections fail
                                 TEST_CHECK_THROWS(conn1.Open(Socket::TypeUNIX, "testfiles/srv2.sock");, ServerException, SocketAlreadyOpen);
@@ -478 +520 @@
                                 std::vector<IOStream *> conns;
                                 conns.push_back(&conn1);
+#ifndef WIN32
                                 conns.push_back(&conn2);
                                 conns.push_back(&conn3);
+#endif // !WIN32
                                 Srv2TestConversations(conns);
                                 // Implicit close
                         }
+#ifndef WIN32
                         // HUP again
                         TEST_THAT(HUPServer(pid));
                         ::sleep(1);
                         TEST_THAT(ServerIsAlive(pid));
+#endif // !WIN32
                         // Kill it
                         TEST_THAT(KillServer(pid));
                         ::sleep(1);
                         TEST_THAT(!ServerIsAlive(pid));
+#ifndef WIN32
                         TestRemoteProcessMemLeaks("test-srv2.memleaks");
+#endif // !WIN32
                 }
         }
@@ -497 +545 @@
         // Launch a test SSL server
         {
+#ifdef WIN32
+                int pid = LaunchServer("test srv3 testfiles\\srv3.conf", 
+                        "testfiles\\srv3.pid");
+#else
                 int pid = LaunchServer("./test srv3 testfiles/srv3.conf", "testfiles/srv3.pid");
+#endif
                 TEST_THAT(pid != -1 && pid != 0);
                 if(pid > 0)
@@ -503 +556 @@
                         // Will it restart?
                         TEST_THAT(ServerIsAlive(pid));
+
+#ifndef WIN32
                         TEST_THAT(HUPServer(pid));
                         ::sleep(1);
                         TEST_THAT(ServerIsAlive(pid));
+#endif
+
                         // Make some connections
                         {
@@ -520 +577 @@
                                 SocketStreamTLS conn1;
                                 conn1.Open(context, Socket::TypeINET, "localhost", 2003);
+#ifndef WIN32
                                 SocketStreamTLS conn2;
                                 conn2.Open(context, Socket::TypeUNIX, "testfiles/srv3.sock");
                                 SocketStreamTLS conn3;
                                 conn3.Open(context, Socket::TypeINET, "localhost", 2003);
+#endif
                                 // Quick check that reconnections fail
                                 TEST_CHECK_THROWS(conn1.Open(context, Socket::TypeUNIX, "testfiles/srv3.sock");, ServerException, SocketAlreadyOpen);
@@ -529 +588 @@
                                 std::vector<IOStream *> conns;
                                 conns.push_back(&conn1);
+#ifndef WIN32
                                 conns.push_back(&conn2);
                                 conns.push_back(&conn3);
+#endif
                                 Srv2TestConversations(conns);
                                 // Implicit close
                         }
+#ifndef WIN32
                         // HUP again
                         TEST_THAT(HUPServer(pid));
                         ::sleep(1);
                         TEST_THAT(ServerIsAlive(pid));
+#endif
                         // Kill it
                         TEST_THAT(KillServer(pid));
                         ::sleep(1);
                         TEST_THAT(!ServerIsAlive(pid));
+#ifndef WIN32
                         TestRemoteProcessMemLeaks("test-srv3.memleaks");
+#endif
                 }
         }
@@ -549 +614 @@
         // Launch a test protocol handling server
         {
-                int pid = LaunchServer("./test srv4 testfiles/srv4.conf", "testfiles/srv4.pid");
+#ifdef WIN32
+                int pid = LaunchServer("test srv4 testfiles\\srv4.conf", 
+                        "testfiles\\srv4.pid");
+#else
+                int pid = LaunchServer("./test srv4 testfiles/srv4.conf", 
+                        "testfiles/srv4.pid");
+#endif
                 TEST_THAT(pid != -1 && pid != 0);
                 if(pid > 0)
@@ -558 +629 @@
                         // Open a connection to it              
                         SocketStream conn;
+#ifdef WIN32
+                        conn.Open(Socket::TypeINET, "localhost", 2003);
+#else
                         conn.Open(Socket::TypeUNIX, "testfiles/srv4.sock");
+#endif
                         
                         // Create a protocol
@@ -621 +696 @@
                         ::sleep(1);
                         TEST_THAT(!ServerIsAlive(pid));
+#ifndef WIN32
                         TestRemoteProcessMemLeaks("test-srv4.memleaks");
+#endif
                 }
         }

box/chris/merge/test/bbackupd/testbbackupd.cpp

@@ -719 +719 @@
                         wait_for_backup_operation();
                         compareReturnValue = ::system("../../bin/bbackupquery/bbackupquery -q -c testfiles/bbackupd.conf -l testfiles/query3e.log \"compare -ac\" quit");
-                        TEST_THAT(compareReturnValue == 2*256); // should find differences
+                        TEST_THAT(compareReturnValue == 3*256); // should find differences
                         TestRemoteProcessMemLeaks("bbackupquery.memleaks");
                         // Check that it was reported correctly

box/chris/merge/test/bbackupd/testfiles/extcheck1.pl.in

@@ -2 +2 @@
 use strict;
 
-unless(open IN,"../../bin/bbackupquery/bbackupquery -q -c testfiles/bbackupd.conf -l testfiles/query4.log \"compare -ac\" quit|")
+my $flags = $ARGV[0] or "";
+
+unless(open IN,"../../bin/bbackupquery/bbackupquery -q -c testfiles/bbackupd.conf -l testfiles/query4.log \"compare -ac$flags\" quit|")
 {
         print "Couldn't open compare utility\n";
@@ -16 +18 @@
         if(m/continousupdate/)
         {
-                $ret = 2 unless m/exists/;
+                unless (/exists/)
+                {
+                        print "FAIL: continousupdate line does not match\n";
+                        $ret = 2;
+                }
                 $seen = 1;
         }
         else
         {
-                $ret = 2 unless m/\AWARNING/ || m/\ADifferences/ || /might be reason/ || /probably due to file mod/;
+                unless (/\AWARNING/ or /\ADifferences/ or /might be reason/
+                        or /probably due to file mod/)
+                {
+                        print "FAIL: Summary line does not match\n";
+                        $ret = 2;
+                }
         }
-        print;
+        print "READ: $_";
 }
 

box/chris/merge/test/bbackupd/testfiles/extcheck2.pl.in

@@ -2 +2 @@
 use strict;
 
-unless(open IN,"../../bin/bbackupquery/bbackupquery -q -c testfiles/bbackupd.conf -l testfiles/query4.log \"compare -ac\" quit|")
+my $flags = $ARGV[0] or "";
+
+unless(open IN,"../../bin/bbackupquery/bbackupquery -q -c testfiles/bbackupd.conf -l testfiles/query4.log \"compare -ac$flags\" quit|")
 {
         print "Couldn't open compare utility\n";
@@ -15 +17 @@
         if(m/continousupdate/)
         {
-                $ret = 2 unless m/contents/ || m/attributes/;
+                unless (m/contents/ or m/attributes/)
+                {
+                        print "FAIL: continuousupdate line does not match\n";
+                        $ret = 2;
+                }
         }
         else
         {
-                $ret = 2 unless m/\AWARNING/ || m/\ADifferences/ || /might be reason/ || /probably due to file mod/;
+                unless (/\AWARNING/ or /\ADifferences/ or /might be reason/ 
+                        or /probably due to file mod/)
+                {
+                        print "FAIL: summary line does not match\n";
+                        $ret = 2;
+                }
         }
-        print;
+
+        print "READ: $_";
 }
 

box/chris/merge/test/common/testcommon.cpp

@@ -25 +25 @@
 #include "Conversion.h"
 #include "autogen_ConversionException.h"
+#include "CollectInBufferStream.h"
+#include "Archive.h"
 
 #include "MemLeakFindOn.h"
@@ -566 +568 @@
         test_conversions();
 
+        // test that we can use Archive and CollectInBufferStream
+        // to read and write arbitrary types to a memory buffer
+
+        {
+                CollectInBufferStream buffer;
+                ASSERT(buffer.GetPosition() == 0);
+
+                {
+                        Archive archive(buffer, 0);
+                        ASSERT(buffer.GetPosition() == 0);
+
+                        archive.Write((bool) true);
+                        archive.Write((bool) false);
+                        archive.Write((int) 0x12345678);
+                        archive.Write((int) 0x87654321);
+                        archive.Write((int64_t)  0x0badfeedcafebabeLL);
+                        archive.Write((uint64_t) 0xfeedfacedeadf00dLL);
+                        archive.Write((uint8_t)  0x01);
+                        archive.Write((uint8_t)  0xfe);
+                        archive.Write(std::string("hello world!"));
+                        archive.Write(std::string("goodbye cruel world!"));
+                }
+
+                CollectInBufferStream buf2;
+                buf2.Write(buffer.GetBuffer(), buffer.GetSize());
+                TEST_THAT(buf2.GetPosition() == buffer.GetSize());
+
+                buf2.SetForReading();
+                TEST_THAT(buf2.GetPosition() == 0);
+
+                {
+                        Archive archive(buf2, 0);
+                        TEST_THAT(buf2.GetPosition() == 0);
+
+                        bool b;
+                        archive.Read(b); TEST_THAT(b == true);
+                        archive.Read(b); TEST_THAT(b == false);
+
+                        int i;
+                        archive.Read(i); TEST_THAT(i == 0x12345678);
+                        archive.Read(i); TEST_THAT((unsigned int)i == 0x87654321);
+
+                        uint64_t i64;
+                        archive.Read(i64); TEST_THAT(i64 == 0x0badfeedcafebabeLL);
+                        archive.Read(i64); TEST_THAT(i64 == 0xfeedfacedeadf00dLL);
+
+                        uint8_t i8;
+                        archive.Read(i8); TEST_THAT(i8 == 0x01);
+                        archive.Read(i8); TEST_THAT(i8 == 0xfe);
+
+                        std::string s;
+                        archive.Read(s); TEST_THAT(s == "hello world!");
+                        archive.Read(s); TEST_THAT(s == "goodbye cruel world!");
+
+                        TEST_THAT(!buf2.StreamDataLeft());
+                }
+        }
+
         return 0;
 }

box/chris/merge/test/raidfile/intercept.cpp

@@ -15 +15 @@
 #include <sys/types.h>
 #include <unistd.h>
+
+#ifdef HAVE_SYS_UIO_H
 #include <sys/uio.h>
+#endif
+
 #include <errno.h>
 

box/chris/merge/test/raidfile/testraidfile.cpp

@@ -13 +13 @@
 #include <unistd.h>
 #include <errno.h>
+
+#ifdef HAVE_SYSCALL
 #include <sys/syscall.h>
+#endif
 
 #include <string.h>
@@ -208 +211 @@
         }
         TEST_THAT(!readstream4.StreamDataLeft());               // check IOStream interface is correct
+        pread.reset();
 
         // Be nasty, and create some errors for the RAID stuff to recover from...
@@ -213 +217 @@
         {
                 char stripe1fn[256], stripe1fnRename[256];
-                sprintf(stripe1fn, "testfiles/%d_%d/%s.rf", set, startDisc, filename);
-                sprintf(stripe1fnRename, "testfiles/%d_%d/%s.rf-REMOVED", set, startDisc, filename);
+                sprintf(stripe1fn, "testfiles" DIRECTORY_SEPARATOR "%d_%d"
+                        DIRECTORY_SEPARATOR "%s.rf", set, startDisc, filename);
+                sprintf(stripe1fnRename, "testfiles" DIRECTORY_SEPARATOR "%d_%d"
+                        DIRECTORY_SEPARATOR "%s.rf-REMOVED", set, startDisc, 
+                        filename);
                 char stripe2fn[256], stripe2fnRename[256];
-                sprintf(stripe2fn, "testfiles/%d_%d/%s.rf", set, (startDisc + 1) % RAID_NUMBER_DISCS, filename);
-                sprintf(stripe2fnRename, "testfiles/%d_%d/%s.rf-REMOVED", set, (startDisc + 1) % RAID_NUMBER_DISCS, filename);
+                sprintf(stripe2fn, "testfiles" DIRECTORY_SEPARATOR "%d_%d"
+                        DIRECTORY_SEPARATOR "%s.rf", set, 
+                        (startDisc + 1) % RAID_NUMBER_DISCS, filename);
+                sprintf(stripe2fnRename, "testfiles" DIRECTORY_SEPARATOR "%d_%d"
+                        DIRECTORY_SEPARATOR "%s.rf-REMOVED", set, 
+                        (startDisc + 1) % RAID_NUMBER_DISCS, filename);
 
                 // Read with stripe1 + parity           
@@ -253 +264 @@
                 mungefilename[m++] = '\0';
                 char stripe1munge[256];
-                sprintf(stripe1munge, "testfiles/%d_%d/.raidfile-unreadable/%s", set, startDisc, mungefilename);
+                sprintf(stripe1munge, "testfiles" DIRECTORY_SEPARATOR "%d_%d"
+                        DIRECTORY_SEPARATOR ".raidfile-unreadable"
+                        DIRECTORY_SEPARATOR "%s", set, startDisc, 
+                        mungefilename);
                 char stripe2munge[256];
-                sprintf(stripe2munge, "testfiles/%d_%d/.raidfile-unreadable/%s", set, (startDisc + 1) % RAID_NUMBER_DISCS, mungefilename);
+                sprintf(stripe2munge, "testfiles" DIRECTORY_SEPARATOR "%d_%d"
+                        DIRECTORY_SEPARATOR ".raidfile-unreadable"
+                        DIRECTORY_SEPARATOR "%s", set, 
+                        (startDisc + 1) % RAID_NUMBER_DISCS, mungefilename);
                 
 
@@ -360 +377 @@
         // This time, don't discard and transform it to a RAID File
         char writefnPre[256];
-        sprintf(writefnPre, "testfiles/%d_%d/%s.rfwX", set, startDisc, filename);
+        sprintf(writefnPre, "testfiles" DIRECTORY_SEPARATOR "%d_%d"
+                DIRECTORY_SEPARATOR "%s.rfwX", set, startDisc, filename);
         TEST_THAT(TestFileExists(writefnPre));
         char writefn[256];
-        sprintf(writefn, "testfiles/%d_%d/%s.rfw", set, startDisc, filename);
+        sprintf(writefn, "testfiles" DIRECTORY_SEPARATOR "%d_%d"
+                DIRECTORY_SEPARATOR "%s.rfw", set, startDisc, filename);
         int usageInBlocks = write4.GetDiscUsageInBlocks();
         write4.Commit(DoTransform);
@@ -391 +410 @@
                 }
                 char stripe1fn[256];
-                sprintf(stripe1fn, "testfiles/%d_%d/%s.rf", set, startDisc, filename);
+                sprintf(stripe1fn, "testfiles" DIRECTORY_SEPARATOR "%d_%d"
+                        DIRECTORY_SEPARATOR "%s.rf", set, startDisc, filename);
                 TEST_THAT(TestGetFileSize(stripe1fn) == fs1);
                 char stripe2fn[256];
-                sprintf(stripe2fn, "testfiles/%d_%d/%s.rf", set, (startDisc + 1) % RAID_NUMBER_DISCS, filename);
+                sprintf(stripe2fn, "testfiles" DIRECTORY_SEPARATOR "%d_%d"
+                        DIRECTORY_SEPARATOR "%s.rf", set, 
+                        (startDisc + 1) % RAID_NUMBER_DISCS, filename);
                 TEST_THAT(TestGetFileSize(stripe2fn) == (int)(datasize - fs1));
                 // Parity file size
                 char parityfn[256];
-                sprintf(parityfn, "testfiles/%d_%d/%s.rf", set, (startDisc + 2) % RAID_NUMBER_DISCS, filename);
+                sprintf(parityfn, "testfiles" DIRECTORY_SEPARATOR "%d_%d"
+                        DIRECTORY_SEPARATOR "%s.rf", set, 
+                        (startDisc + 2) % RAID_NUMBER_DISCS, filename);
                 // Mildly complex calculation
                 unsigned int blocks = datasize / RAID_BLOCK_SIZE;
@@ -437 +461 @@
                 {
                         int f;
-                        TEST_THAT((f = ::open(stripe1fn, O_RDONLY, 0)) != -1);
+                        TEST_THAT((f = ::open(stripe1fn, O_RDONLY | O_BINARY, 
+                                0)) != -1);
                         TEST_THAT(sizeof(testblock) == ::read(f, testblock, sizeof(testblock)));
                         for(unsigned int q = 0; q < sizeof(testblock); ++q)
@@ -444 +469 @@
                         }
                         ::close(f);
-                        TEST_THAT((f = ::open(stripe2fn, O_RDONLY, 0)) != -1);
+                        TEST_THAT((f = ::open(stripe2fn, O_RDONLY | O_BINARY, 
+                                0)) != -1);
                         TEST_THAT(sizeof(testblock) == ::read(f, testblock, sizeof(testblock)));
                         for(unsigned int q = 0; q < sizeof(testblock); ++q)
@@ -537 +563 @@
         // Generate a random pre-existing write file (and ensure that it doesn't exist already)
         int f;
-        TEST_THAT((f = ::open("testfiles/0_2/overwrite_B.rfwX", O_WRONLY | O_CREAT | O_EXCL, 0755)) != -1);
+        TEST_THAT((f = ::open("testfiles" DIRECTORY_SEPARATOR "0_2" 
+                DIRECTORY_SEPARATOR "overwrite_B.rfwX", 
+                O_WRONLY | O_CREAT | O_EXCL | O_BINARY, 0755)) != -1);
         TEST_THAT(::write(f, "TESTTEST", 8) == 8);
         ::close(f);
@@ -558 +586 @@
         // Initialise the controller
         RaidFileController &rcontroller = RaidFileController::GetController();
-        rcontroller.Initialise("testfiles/raidfile.conf");
+        rcontroller.Initialise("testfiles" DIRECTORY_SEPARATOR "raidfile.conf");
 
         // some data
@@ -575 +603 @@
         // Try creating a directory
         RaidFileWrite::CreateDirectory(0, "test-dir");
-        TEST_THAT(TestDirExists("testfiles/0_0/test-dir"));
-        TEST_THAT(TestDirExists("testfiles/0_1/test-dir"));
-        TEST_THAT(TestDirExists("testfiles/0_2/test-dir"));
+        TEST_THAT(TestDirExists("testfiles" DIRECTORY_SEPARATOR "0_0" 
+                DIRECTORY_SEPARATOR "test-dir"));
+        TEST_THAT(TestDirExists("testfiles" DIRECTORY_SEPARATOR "0_1"
+                DIRECTORY_SEPARATOR "test-dir"));
+        TEST_THAT(TestDirExists("testfiles" DIRECTORY_SEPARATOR "0_2"
+                DIRECTORY_SEPARATOR "test-dir"));
         TEST_THAT(RaidFileRead::DirectoryExists(0, "test-dir"));
         TEST_THAT(!RaidFileRead::DirectoryExists(0, "test-dir-not"));
@@ -609 +640 @@
         // Before it's deleted, check to see the contents are as expected
         int f;
-        TEST_THAT((f = ::open("testfiles/0_2/test1.rfwX", O_RDONLY, 0)) >= 0);
+        TEST_THAT((f = ::open("testfiles" DIRECTORY_SEPARATOR "0_2"
+                DIRECTORY_SEPARATOR "test1.rfwX", O_RDONLY | O_BINARY, 0)) 
+                >= 0);
         char buffer[sizeof(data)];
-        TEST_THAT(::read(f, buffer, sizeof(buffer)) == sizeof(buffer));
+        int bytes_read = ::read(f, buffer, sizeof(buffer));
+        TEST_THAT(bytes_read == sizeof(buffer));
         for(unsigned int l = 0; l < 1024; ++l)
         {
@@ -625 +659 @@
         }
         TEST_THAT(::lseek(f, sizeof(data), SEEK_SET) == sizeof(buffer));
-        TEST_THAT(::read(f, buffer, sizeof(buffer)) == sizeof(buffer));
+        bytes_read = ::read(f, buffer, sizeof(buffer));
+        TEST_THAT(bytes_read == sizeof(buffer));
         for(unsigned int l = 0; l < 1024; ++l)
         {
@@ -636 +671 @@
         // Commit the data
         write1.Commit();
-        TEST_THAT((f = ::open("testfiles/0_2/test1.rfw", O_RDONLY, 0)) >= 0);
+        TEST_THAT((f = ::open("testfiles" DIRECTORY_SEPARATOR "0_2"
+                DIRECTORY_SEPARATOR "test1.rfw", O_RDONLY | O_BINARY, 0)) 
+                >= 0);
         ::close(f);
 
@@ -688 +725 @@
         // This time, discard it
         write2.Discard();
-        TEST_THAT((f = ::open("testfiles/0_2/test1.rfw", O_RDONLY, 0)) == -1);
+        TEST_THAT((f = ::open("testfiles" DIRECTORY_SEPARATOR "0_2"
+                DIRECTORY_SEPARATOR "test1.rfw", O_RDONLY | O_BINARY, 0)) 
+                == -1);
         
         // And leaving it there...
@@ -696 +735 @@
         // This time, commit it
         writeLeave.Commit();
-        TEST_THAT((f = ::open("testfiles/0_2/test1.rfw", O_RDONLY, 0)) != -1);
+        TEST_THAT((f = ::open("testfiles" DIRECTORY_SEPARATOR "0_2" 
+                DIRECTORY_SEPARATOR "test1.rfw", O_RDONLY | O_BINARY, 0)) 
+                != -1);
         ::close(f);
         
@@ -713 +754 @@
         write3b.Commit();
         // Test it
-        testReadingFileContents(0, "test1", data+3, sizeof(data) - 3, false /*TestRAIDProperties*/);
+        testReadingFileContents(0, "test1", data+3, sizeof(data) - 3, false 
+                /* TestRAIDProperties */);
 
         // And once again, but this time making it a raid file
@@ -722 +764 @@
         write3c.Commit(true);   // make RAID
         // Test it
-        testReadingFileContents(0, "test1", data+7, sizeof(data) - 7, false /*TestRAIDProperties*/);
+        testReadingFileContents(0, "test1", data+7, sizeof(data) - 7, false 
+                /*TestRAIDProperties*/);
 
         // Test opening a file which doesn't exist
@@ -737 +780 @@
 
                 // Try removing the parity file
-                TEST_THAT(::rename("testfiles/0_0/damage.rf", "testfiles/0_0/damage.rf-NT") == 0);
+                TEST_THAT(::rename("testfiles" DIRECTORY_SEPARATOR "0_0"
+                        DIRECTORY_SEPARATOR "damage.rf", 
+                        "testfiles" DIRECTORY_SEPARATOR "0_0"
+                        DIRECTORY_SEPARATOR "damage.rf-NT") == 0);
                 {
                         std::auto_ptr<RaidFileRead> pr0 = RaidFileRead::Open(0, "damage");
                         pr0->Read(buffer, sizeof(data));
                 }               
-                TEST_THAT(::rename("testfiles/0_0/damage.rf-NT", "testfiles/0_0/damage.rf") == 0);
-                
+                TEST_THAT(::rename("testfiles" DIRECTORY_SEPARATOR "0_0" DIRECTORY_SEPARATOR "damage.rf-NT", "testfiles" DIRECTORY_SEPARATOR "0_0" DIRECTORY_SEPARATOR "damage.rf") == 0);
+        
                 // Delete one of the files
-                TEST_THAT(::unlink("testfiles/0_1/damage.rf") == 0);    // stripe 1
+                TEST_THAT(::unlink("testfiles" DIRECTORY_SEPARATOR "0_1" DIRECTORY_SEPARATOR "damage.rf") == 0); // stripe 1
                 
 #ifdef TRF_CAN_INTERCEPT
                 // Open it and read...
                 {
-                        intercept_setup_error("testfiles/0_2/damage.rf", 0, EIO, SYS_read);     // stripe 2
+                        intercept_setup_error("testfiles" DIRECTORY_SEPARATOR "0_2" DIRECTORY_SEPARATOR "damage.rf", 0, EIO, SYS_read); // stripe 2
                         std::auto_ptr<RaidFileRead> pr1 = RaidFileRead::Open(0, "damage");
                         TEST_CHECK_THROWS(
@@ -762 +808 @@
 
                 // Delete another
-                TEST_THAT(::unlink("testfiles/0_0/damage.rf") == 0);            // parity
+                TEST_THAT(::unlink("testfiles" DIRECTORY_SEPARATOR "0_0" DIRECTORY_SEPARATOR "damage.rf") == 0); // parity
                 
                 TEST_CHECK_THROWS(
@@ -773 +819 @@
                 RaidFileWrite::CreateDirectory(0, "dirread");
                 // Make some contents
-                RaidFileWrite::CreateDirectory(0, "dirread/dfsdf1");
-                RaidFileWrite::CreateDirectory(0, "dirread/ponwq2");
-                {
-                        RaidFileWrite w(0, "dirread/sdf9873241");
+                RaidFileWrite::CreateDirectory(0, "dirread" DIRECTORY_SEPARATOR "dfsdf1");
+                RaidFileWrite::CreateDirectory(0, "dirread" DIRECTORY_SEPARATOR "ponwq2");
+                {
+                        RaidFileWrite w(0, "dirread" DIRECTORY_SEPARATOR "sdf9873241");
                         w.Open();
                         w.Write(data, sizeof(data));
@@ -782 +828 @@
                 }
                 {
-                        RaidFileWrite w(0, "dirread/fsdcxjni3242");
+                        RaidFileWrite w(0, "dirread" DIRECTORY_SEPARATOR "fsdcxjni3242");
                         w.Open();
                         w.Write(data, sizeof(data));
@@ -788 +834 @@
                 }
                 {
-                        RaidFileWrite w(0, "dirread/cskjnds3");
+                        RaidFileWrite w(0, "dirread" DIRECTORY_SEPARATOR "cskjnds3");
                         w.Open();
                         w.Write(data, sizeof(data));
@@ -804 +850 @@
                 TEST_THAT(list_matches(names, dir_list1));
                 // Delete things
-                TEST_THAT(::unlink("testfiles/0_0/dirread/sdf9873241.rf") == 0);
+                TEST_THAT(::unlink("testfiles" DIRECTORY_SEPARATOR "0_0" DIRECTORY_SEPARATOR "dirread" DIRECTORY_SEPARATOR "sdf9873241.rf") == 0);
                 TEST_THAT(true == RaidFileRead::ReadDirectoryContents(0, std::string("dirread"), RaidFileRead::DirReadType_FilesOnly, names));
                 TEST_THAT(list_matches(names, file_list1));
                 // Delete something else so that it's not recoverable
-                TEST_THAT(::unlink("testfiles/0_1/dirread/sdf9873241.rf") == 0);
+                TEST_THAT(::unlink("testfiles" DIRECTORY_SEPARATOR "0_1" DIRECTORY_SEPARATOR "dirread" DIRECTORY_SEPARATOR "sdf9873241.rf") == 0);
                 TEST_THAT(false == RaidFileRead::ReadDirectoryContents(0, std::string("dirread"), RaidFileRead::DirReadType_FilesOnly, names));
                 TEST_THAT(list_matches(names, file_list1));
                 // And finally...
-                TEST_THAT(::unlink("testfiles/0_2/dirread/sdf9873241.rf") == 0);
+                TEST_THAT(::unlink("testfiles" DIRECTORY_SEPARATOR "0_2" DIRECTORY_SEPARATOR "dirread" DIRECTORY_SEPARATOR "sdf9873241.rf") == 0);
                 TEST_THAT(true == RaidFileRead::ReadDirectoryContents(0, std::string("dirread"), RaidFileRead::DirReadType_FilesOnly, names));
                 TEST_THAT(list_matches(names, file_list2));

box/chris/merge/test/win32/testlibwin32.cpp

@@ -6 +6 @@
 
 #ifdef WIN32
+
+#include <assert.h>
+#include <AccCtrl.h>
+#include <Aclapi.h>
 
 #include "../../bin/bbackupd/BackupDaemon.h"
@@ -13 +17 @@
 int main(int argc, char* argv[])
 {
+        // ACL tests
+        char* exename = getenv("WINDIR");
+
+        PSID psidOwner;
+        PSID psidGroup;
+        PACL pDacl;
+        PSECURITY_DESCRIPTOR pSecurityDesc;
+
+        DWORD result = GetNamedSecurityInfo(
+                exename, // pObjectName
+                SE_FILE_OBJECT, // ObjectType
+                DACL_SECURITY_INFORMATION | // SecurityInfo
+                GROUP_SECURITY_INFORMATION |
+                OWNER_SECURITY_INFORMATION,
+                &psidOwner, // ppsidOwner,
+                &psidGroup, // ppsidGroup,
+                &pDacl,     // ppDacl,
+                NULL,       // ppSacl,
+                &pSecurityDesc // ppSecurityDescriptor
+        );
+        if (result != ERROR_SUCCESS)
+        {
+                printf("Error getting security info for '%s': error %d",
+                        exename, result);
+        }
+        assert(result == ERROR_SUCCESS);
+
+        char namebuf[1024];
+        char domainbuf[1024];
+        SID_NAME_USE nametype;
+        DWORD namelen = sizeof(namebuf);
+        DWORD domainlen = sizeof(domainbuf);
+
+        assert(LookupAccountSid(NULL, psidOwner, namebuf, &namelen,
+                domainbuf, &domainlen, &nametype));
+
+        printf("Owner:\n");
+        printf("User name:   %s\n", namebuf);
+        printf("Domain name: %s\n", domainbuf);
+        printf("Name type:   %d\n", nametype);
+        printf("\n");
+
+        namelen = sizeof(namebuf);
+        domainlen = sizeof(domainbuf);
+
+        assert(LookupAccountSid(NULL, psidGroup, namebuf, &namelen,
+                domainbuf, &domainlen, &nametype));
+
+        printf("Group:\n");
+        printf("User name:   %s\n", namebuf);
+        printf("Domain name: %s\n", domainbuf);
+        printf("Name type:   %d\n", nametype);
+        printf("\n");
+
+        ULONG numEntries;
+        PEXPLICIT_ACCESS pEntries;
+        result = GetExplicitEntriesFromAcl
+        (
+                pDacl,       // pAcl
+                &numEntries, // pcCountOfExplicitEntries,
+                &pEntries    // pListOfExplicitEntries
+        );
+        assert(result == ERROR_SUCCESS);
+
+        printf("Found %lu explicit DACL entries for '%s'\n\n",
+                (unsigned long)numEntries, exename);
+
+        for (ULONG i = 0; i < numEntries; i++)
+        {
+                EXPLICIT_ACCESS* pEntry = &(pEntries[i]);
+                printf("DACL entry %lu:\n", (unsigned long)i);
+
+                DWORD perms = pEntry->grfAccessPermissions;
+                printf("  Access permissions: ", perms);
+
+                #define PRINT_PERM(name) \
+                if (perms & name) \
+                { \
+                        printf(#name " "); \
+                        perms &= ~name; \
+                }
+
+                PRINT_PERM(FILE_ADD_FILE);
+                PRINT_PERM(FILE_ADD_SUBDIRECTORY);
+                PRINT_PERM(FILE_ALL_ACCESS);
+                PRINT_PERM(FILE_APPEND_DATA);
+                PRINT_PERM(FILE_CREATE_PIPE_INSTANCE);
+                PRINT_PERM(FILE_DELETE_CHILD);
+                PRINT_PERM(FILE_EXECUTE);
+                PRINT_PERM(FILE_LIST_DIRECTORY);
+                PRINT_PERM(FILE_READ_ATTRIBUTES);
+                PRINT_PERM(FILE_READ_DATA);
+                PRINT_PERM(FILE_READ_EA);
+                PRINT_PERM(FILE_TRAVERSE);
+                PRINT_PERM(FILE_WRITE_ATTRIBUTES);
+                PRINT_PERM(FILE_WRITE_DATA);
+                PRINT_PERM(FILE_WRITE_EA);
+                PRINT_PERM(STANDARD_RIGHTS_READ);
+                PRINT_PERM(STANDARD_RIGHTS_WRITE);
+                PRINT_PERM(SYNCHRONIZE);
+                PRINT_PERM(DELETE);
+                PRINT_PERM(READ_CONTROL);
+                PRINT_PERM(WRITE_DAC);
+                PRINT_PERM(WRITE_OWNER);
+                PRINT_PERM(MAXIMUM_ALLOWED);
+                PRINT_PERM(GENERIC_ALL);
+                PRINT_PERM(GENERIC_EXECUTE);
+                PRINT_PERM(GENERIC_WRITE);
+                PRINT_PERM(GENERIC_READ);
+                printf("\n");
+
+                if (perms)
+                {
+                        printf("  Bits left over: %08x\n", perms);
+                }
+                assert(!perms);
+
+                printf("  Access mode: ");
+                switch(pEntry->grfAccessMode)
+                {
+                case NOT_USED_ACCESS:
+                        printf("NOT_USED_ACCESS\n"); break;
+                case GRANT_ACCESS:
+                        printf("GRANT_ACCESS\n"); break;
+                case DENY_ACCESS:
+                        printf("DENY_ACCESS\n"); break;
+                case REVOKE_ACCESS:
+                        printf("REVOKE_ACCESS\n"); break;
+                case SET_AUDIT_SUCCESS:
+                        printf("SET_AUDIT_SUCCESS\n"); break;
+                case SET_AUDIT_FAILURE:
+                        printf("SET_AUDIT_FAILURE\n"); break;
+                default:
+                        printf("Unknown (%08x)\n", pEntry->grfAccessMode);
+                }
+
+                printf("  Trustee: ");
+                assert(pEntry->Trustee.pMultipleTrustee == NULL);
+                assert(pEntry->Trustee.MultipleTrusteeOperation == NO_MULTIPLE_TRUSTEE);
+                switch(pEntry->Trustee.TrusteeForm)
+                {
+                case TRUSTEE_IS_SID:
+                        {
+                                PSID trusteeSid = (PSID)(pEntry->Trustee.ptstrName);
+
+                                namelen = sizeof(namebuf);
+                                domainlen = sizeof(domainbuf);
+
+                                assert(LookupAccountSid(NULL, trusteeSid, namebuf, &namelen,
+                                        domainbuf, &domainlen, &nametype));
+
+                                printf("SID of %s\\%s (%d)\n", domainbuf, namebuf, nametype);
+                        }
+                        break;
+                case TRUSTEE_IS_NAME:
+                        printf("Name\n"); break;
+                case TRUSTEE_BAD_FORM:
+                        printf("Bad form\n"); assert(0);
+                case TRUSTEE_IS_OBJECTS_AND_SID:
+                        printf("Objects and SID\n"); break;
+                case TRUSTEE_IS_OBJECTS_AND_NAME:
+                        printf("Objects and name\n"); break;
+                default:
+                        printf("Unknown form\n"); assert(0);
+                }
+
+                printf("  Trustee type: ");
+                switch(pEntry->Trustee.TrusteeType)
+                {
+                case TRUSTEE_IS_UNKNOWN:
+                        printf("Unknown type.\n"); break;
+                case TRUSTEE_IS_USER:
+                        printf("User\n"); break;
+                case TRUSTEE_IS_GROUP:
+                        printf("Group\n"); break;
+                case TRUSTEE_IS_DOMAIN:
+                        printf("Domain\n"); break;
+                case TRUSTEE_IS_ALIAS:
+                        printf("Alias\n"); break;
+                case TRUSTEE_IS_WELL_KNOWN_GROUP:
+                        printf("Well-known group\n"); break;
+                case TRUSTEE_IS_DELETED:
+                        printf("Deleted account\n"); break;
+                case TRUSTEE_IS_INVALID:
+                        printf("Invalid trustee type\n"); break;
+                case TRUSTEE_IS_COMPUTER:
+                        printf("Computer\n"); break;
+                default:
+                        printf("Unknown type %d\n", pEntry->Trustee.TrusteeType); 
+                        assert(0);
+                }
+
+                printf("\n");
+        }
+
+        assert(LocalFree((HLOCAL)pEntries) == 0);
+        assert(LocalFree((HLOCAL)pSecurityDesc) == 0);
+
         chdir("c:\\tmp");
         openfile("test", O_CREAT, 0);
@@ -26 +228 @@
                 {
                         info = readdir(ourDir);
-                        if ( info ) printf("File/Dir name is : %s\r\n", info->d_name);
-
-                }while ( info != NULL );
+                        if (info) printf("File/Dir name is : %s\r\n", info->d_name);
+                }
+                while (info != NULL);
 
                 closedir(ourDir);
-
         }
         
@@ -42 +243 @@
                 {
                         info = readdir(ourDir);
-                        if ( info == NULL ) break;
+                        if (info == NULL) break;
                         std::string file(diry + info->d_name);
                         stat(file.c_str(), &ourfs);
-                        if ( info ) printf("File/Dir name is : %s\r\n", info->d_name);
-
-                }while ( info != NULL );
+                        if (info) printf("File/Dir name is : %s\r\n", info->d_name);
+                }
+                while ( info != NULL );
 
                 closedir(ourDir);
@@ -55 +256 @@
         stat("c:\\windows", &ourfs);
         stat("c:\\autoexec.bat", &ourfs);
-        printf("Finished dir read");
-#if 0
-        //remove - sleepycat include a version of getopt - mine never REALLY worked !
+        printf("Finished dir read\n");
+
         //test our getopt function
-        std::string commline("-q -c fgfgfg -f -l hello");
-
-        int c;
-        while((c = getopt(commline.size(), (char * const *)commline.c_str(), "qwc:l:")) != -1)
-        {
-                printf("switch = %c, param is %s\r\n", c, optarg);
-        }
-#endif
+        char * test_argv[] = 
+        {
+                "foobar.exe",
+                "-qwc",
+                "-",
+                "-c",
+                "fgfgfg",
+                "-f",
+                "-l",
+                "hello",
+                "-",
+                "force-sync",
+                NULL
+        };
+        int test_argc;
+        for (test_argc = 0; test_argv[test_argc]; test_argc++) { }
+        const char* opts = "qwc:l:";
+
+        assert(getopt(test_argc, test_argv, opts) == 'q');
+        assert(getopt(test_argc, test_argv, opts) == 'w');
+        assert(getopt(test_argc, test_argv, opts) == 'c');
+        assert(strcmp(optarg, "-") == 0);
+        assert(getopt(test_argc, test_argv, opts) == 'c');
+        assert(strcmp(optarg, "fgfgfg") == 0);
+        assert(getopt(test_argc, test_argv, opts) == '?');
+        assert(optopt == 'f');
+        assert(getopt(test_argc, test_argv, opts) == 'l');
+        assert(strcmp(optarg, "hello") == 0);
+        assert(getopt(test_argc, test_argv, opts) == -1);
+        // assert(optopt == 0); // no more options
+        assert(strcmp(test_argv[optind], "-") == 0);
+        assert(strcmp(test_argv[optind+1], "force-sync") == 0);
         //end of getopt test
         
         //now test our statfs funct
         stat("c:\\cert.cer", &ourfs);
-        
-        
 
         char *timee;
@@ -78 +300 @@
         timee = ctime(&ourfs.st_mtime);
 
-        if ( S_ISREG(ourfs.st_mode))
-        {
-                printf("is a normal file");
+        if (S_ISREG(ourfs.st_mode))
+        {
+                printf("is a normal file\n");
         }
         else
         {
-                printf("is a directory?");
-        }
-
-        lstat("c:\\windows", &ourfs);
+                printf("is a directory?\n");
+                exit(1);
+        }
+
+        lstat(getenv("WINDIR"), &ourfs);
 
         if ( S_ISDIR(ourfs.st_mode))
         {
-                printf("is a directory");
+                printf("is a directory\n");
         }
         else
         {
-                printf("is a file?");
+                printf("is a file?\n");
+                exit(1);
         }
 
@@ -106 +330 @@
         closelog();
 
+        /*
         //first off get the path name for the default 
         char buf[MAX_PATH];
@@ -113 +338 @@
         std::string conf("-c " + buffer.substr(0,(buffer.find("win32test.exe"))) + "bbackupd.conf");
         //std::string conf( "-c " + buffer.substr(0,(buffer.find("bbackupd.exe"))) + "bbackupd.conf");
-
+        */
 
         return 0;

box/chris/merge/win32.bat

@@ -3 +3 @@
 echo quick and dirty to get up and running by generating the required files 
 echo using Cygwin and Perl
+
+copy .\infrastructure\BoxPlatform.pm.in .\infrastructure\BoxPlatform.pm
 
 cd .\bin\bbackupquery\ & perl ./../../bin/bbackupquery/makedocumentation.pl
@@ -26 +28 @@
 cd ..\..\
 
-copy lib\win32\config.h.win32 lib\common\BoxConfig.h
+perl -i.orig -pe 's/@PERL@/perl/' ./test/bbackupd/testfiles/bbackupd.conf