Changeset 2983 for box/trunk/bin

Timestamp:

27/08/2011 15:06:46 (9 months ago)

Author:

chris

Message:

Combine client and server protocols to make way for an offline/local protocol.

Rename ProtocolObject? to Message.

Location:

box/trunk/bin

Files:

• bbackupd/BackupClientContext.cpp (modified) (6 diffs)
• bbackupd/BackupClientDeleteList.cpp (modified) (1 diff)
• bbackupd/BackupClientDirectoryRecord.cpp (modified) (10 diffs)
• bbackupd/BackupDaemon.cpp (modified) (7 diffs)
• bbackupd/BackupDaemon.h (modified) (3 diffs)
• bbackupquery/BackupQueries.cpp (modified) (19 diffs)
• bbackupquery/CommandCompletion.cpp (modified) (7 diffs)
• bbackupquery/bbackupquery.cpp (modified) (3 diffs)
• bbstored/BackupStoreDaemon.cpp (modified) (1 diff)

box/trunk/bin/bbackupd/BackupClientContext.cpp

@@ -26 +26 @@
 #include "BackupStoreException.h"
 #include "BackupDaemon.h"
-#include "autogen_BackupProtocolClient.h"
+#include "autogen_BackupProtocol.h"
 #include "BackupStoreFile.h"
 #include "Logging.h"
@@ -166 +166 @@
                 // Check the version of the server
                 {
-                        std::auto_ptr<BackupProtocolClientVersion> serverVersion(mpConnection->QueryVersion(BACKUP_STORE_SERVER_VERSION));
+                        std::auto_ptr<BackupProtocolVersion> serverVersion(mpConnection->QueryVersion(BACKUP_STORE_SERVER_VERSION));
                         if(serverVersion->GetVersion() != BACKUP_STORE_SERVER_VERSION)
                         {
@@ -174 +174 @@
 
                 // Login -- if this fails, the Protocol will exception
-                std::auto_ptr<BackupProtocolClientLoginConfirmed> loginConf(mpConnection->QueryLogin(mAccountNumber, 0 /* read/write */));
+                std::auto_ptr<BackupProtocolLoginConfirmed> loginConf(mpConnection->QueryLogin(mAccountNumber, 0 /* read/write */));
                 
                 // Check that the client store marker is the one we expect
@@ -420 +420 @@
         // Request filenames from the server, in a "safe" manner to ignore errors properly
         {
-                BackupProtocolClientGetObjectName send(ObjectID, ContainingDirectory);
+                BackupProtocolGetObjectName send(ObjectID, ContainingDirectory);
                 connection.Send(send);
         }
-        std::auto_ptr<BackupProtocolObjectCl> preply(connection.Receive());
+        std::auto_ptr<BackupProtocolMessage> preply(connection.Receive());
 
         // Is it of the right type?
-        if(preply->GetType() != BackupProtocolClientObjectName::TypeID)
+        if(preply->GetType() != BackupProtocolObjectName::TypeID)
         {
                 // Was an error or something
@@ -433 +433 @@
 
         // Cast to expected type.
-        BackupProtocolClientObjectName *names = (BackupProtocolClientObjectName *)(preply.get());
+        BackupProtocolObjectName *names = (BackupProtocolObjectName *)(preply.get());
 
         // Anything found?
@@ -483 +483 @@
 
         // Is it a directory?
-        rIsDirectoryOut = ((names->GetFlags() & BackupProtocolClientListDirectory::Flags_Dir) == BackupProtocolClientListDirectory::Flags_Dir);
+        rIsDirectoryOut = ((names->GetFlags() & BackupProtocolListDirectory::Flags_Dir) == BackupProtocolListDirectory::Flags_Dir);
         
         // Is it the current version?
-        rIsCurrentVersionOut = ((names->GetFlags() & (BackupProtocolClientListDirectory::Flags_OldVersion | BackupProtocolClientListDirectory::Flags_Deleted)) == 0);
+        rIsCurrentVersionOut = ((names->GetFlags() & (BackupProtocolListDirectory::Flags_OldVersion | BackupProtocolListDirectory::Flags_Deleted)) == 0);
 
         // And other information which may be required

box/trunk/bin/bbackupd/BackupClientDeleteList.cpp

@@ -14 +14 @@
 #include "BackupClientDeleteList.h"
 #include "BackupClientContext.h"
-#include "autogen_BackupProtocolClient.h"
+#include "autogen_BackupProtocol.h"
 
 #include "MemLeakFindOn.h"

box/trunk/bin/bbackupd/BackupClientDirectoryRecord.cpp

@@ -18 +18 @@
 #include <string.h>
 
-#include "autogen_BackupProtocolClient.h"
+#include "autogen_BackupProtocol.h"
 #include "Archive.h"
 #include "BackupClientContext.h"
@@ -336 +336 @@
                                                 file_st.st_nlink);
                                 }
-                                else if(file_st.st_nlink != 1)
+                                else if(file_st.st_nlink > 1)
                                 {
                                         if(!mSuppressMultipleLinksWarning)
@@ -614 +614 @@
 
                 // Query the directory
-                std::auto_ptr<BackupProtocolClientSuccess> dirreply(connection.QueryListDirectory(
+                std::auto_ptr<BackupProtocolSuccess> dirreply(connection.QueryListDirectory(
                                 mObjectID,
-                                BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING,    // both files and directories
-                                BackupProtocolClientListDirectory::Flags_Deleted | BackupProtocolClientListDirectory::Flags_OldVersion, // exclude old/deleted stuff
+                                BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING,  // both files and directories
+                                BackupProtocolListDirectory::Flags_Deleted | 
+                                BackupProtocolListDirectory::Flags_OldVersion, // exclude old/deleted stuff
                                 true /* want attributes */));
 
@@ -831 +832 @@
                                                                 // Rename the existing files (ie include old versions) on the server
                                                                 connection.QueryMoveObject(renameObjectID, renameInDirectory, mObjectID /* move to this directory */,
-                                                                        BackupProtocolClientMoveObject::Flags_MoveAllWithSameName | BackupProtocolClientMoveObject::Flags_AllowMoveOverDeletedObject,
+                                                                        BackupProtocolMoveObject::Flags_MoveAllWithSameName | 
+                                                                        BackupProtocolMoveObject::Flags_AllowMoveOverDeletedObject,
                                                                         storeFilename);
                                                                         
@@ -1365 +1367 @@
                                         // Rename the existing directory on the server
                                         connection.QueryMoveObject(renameObjectID, renameInDirectory, mObjectID /* move to this directory */,
-                                                BackupProtocolClientMoveObject::Flags_MoveAllWithSameName | BackupProtocolClientMoveObject::Flags_AllowMoveOverDeletedObject,
+                                                BackupProtocolMoveObject::Flags_MoveAllWithSameName | 
+                                                BackupProtocolMoveObject::Flags_AllowMoveOverDeletedObject,
                                                 storeFilename);
                                                 
@@ -1382 +1385 @@
                                 {
                                         // Create a new directory
-                                        std::auto_ptr<BackupProtocolClientSuccess> dirCreate(connection.QueryCreateDirectory(
+                                        std::auto_ptr<BackupProtocolSuccess> dirCreate(connection.QueryCreateDirectory(
                                                 mObjectID, attrModTime, storeFilename, attrStream));
                                         subDirObjectID = dirCreate->GetObjectID(); 
@@ -1578 +1581 @@
                         // YES -- try to do diff, if possible
                         // First, query the server to see if there's an old version available
-                        std::auto_ptr<BackupProtocolClientSuccess> getBlockIndex(connection.QueryGetBlockIndexByName(mObjectID, rStoreFilename));
+                        std::auto_ptr<BackupProtocolSuccess> getBlockIndex(connection.QueryGetBlockIndexByName(mObjectID, rStoreFilename));
                         int64_t diffFromID = getBlockIndex->GetObjectID();
                         
@@ -1626 +1629 @@
                                 // Upload the patch to the store
                                 //
-                                std::auto_ptr<BackupProtocolClientSuccess> stored(connection.QueryStoreFile(mObjectID, ModificationTime,
+                                std::auto_ptr<BackupProtocolSuccess> stored(connection.QueryStoreFile(mObjectID, ModificationTime,
                                                 AttributesHash, isCompletelyDifferent?(0):(diffFromID), rStoreFilename, *pStreamToUpload));
                                 
@@ -1667 +1670 @@
         
                         // Send to store
-                        std::auto_ptr<BackupProtocolClientSuccess> stored(
+                        std::auto_ptr<BackupProtocolSuccess> stored(
                                 connection.QueryStoreFile(
                                         mObjectID, ModificationTime,
@@ -1693 +1696 @@
                         if(connection.GetLastError(type, subtype))
                         {
-                                if(type == BackupProtocolClientError::ErrorType
-                                && subtype == BackupProtocolClientError::Err_StorageLimitExceeded)
+                                if(type == BackupProtocolError::ErrorType
+                                && subtype == BackupProtocolError::Err_StorageLimitExceeded)
                                 {
                                         // The hard limit was exceeded on the server, notify!

box/trunk/bin/bbackupd/BackupDaemon.cpp

@@ -51 +51 @@
 #include "SSLLib.h"
 
-#include "autogen_BackupProtocolClient.h"
+#include "autogen_BackupProtocol.h"
 #include "autogen_ClientException.h"
 #include "autogen_ConversionException.h"
@@ -697 +697 @@
         mDoSyncForcedByPreviousSyncError = false;
         
+        // Notify system administrator about the final state of the backup
         if(errorOccurred)
         {
@@ -758 +759 @@
                 }
         }
-        // Notify system administrator about the final state of the backup
-        else if(mReadErrorsOnFilesystemObjects)
+
+        if(mReadErrorsOnFilesystemObjects)
         {
                 NotifySysadmin(SysadminNotifier::ReadError);
         }
-        else if(mStorageLimitExceeded)
+
+        if(mStorageLimitExceeded)
         {
                 NotifySysadmin(SysadminNotifier::StoreFull);
         }
-        else
+
+        if (!errorOccurred && !mReadErrorsOnFilesystemObjects &&
+                !mStorageLimitExceeded)
         {
                 NotifySysadmin(SysadminNotifier::BackupOK);
@@ -1005 +1009 @@
 
                 (*i)->mpDirectoryRecord->SyncDirectory(params,
-                        BackupProtocolClientListDirectory::RootDirectory,
+                        BackupProtocolListDirectory::RootDirectory,
                         locationPath, std::string("/") + (*i)->mName);
 
@@ -2098 +2102 @@
         // Going to need a copy of the root directory. Get a connection,
         // and fetch it.
-        BackupProtocolClient &connection(rClientContext.GetConnection());
+        BackupProtocolCallable& connection(rClientContext.GetConnection());
         
         // Ask server for a list of everything in the root directory,
         // which is a directory itself
-        std::auto_ptr<BackupProtocolClientSuccess> dirreply(
+        std::auto_ptr<BackupProtocolSuccess> dirreply(
                 connection.QueryListDirectory(
-                        BackupProtocolClientListDirectory::RootDirectory,
+                        BackupProtocolListDirectory::RootDirectory,
                         // only directories
-                        BackupProtocolClientListDirectory::Flags_Dir,
+                        BackupProtocolListDirectory::Flags_Dir,
                         // exclude old/deleted stuff
-                        BackupProtocolClientListDirectory::Flags_Deleted |
-                        BackupProtocolClientListDirectory::Flags_OldVersion,
+                        BackupProtocolListDirectory::Flags_Deleted |
+                        BackupProtocolListDirectory::Flags_OldVersion,
                         false /* no attributes */));
 
@@ -2349 +2353 @@
                                 {
                                         MemBlockStream attrStream(attr);
-                                        std::auto_ptr<BackupProtocolClientSuccess>
+                                        std::auto_ptr<BackupProtocolSuccess>
                                                 dirCreate(connection.QueryCreateDirectory(
-                                                BackupProtocolClientListDirectory::RootDirectory,
+                                                BackupProtocolListDirectory::RootDirectory,
                                                 attrModTime, dirname, attrStream));
                                                 
@@ -2895 +2899 @@
         // Entries to delete, and it's the right time to do so...
         BOX_NOTICE("Deleting unused locations from store root...");
-        BackupProtocolClient &connection(rContext.GetConnection());
+        BackupProtocolCallable &connection(rContext.GetConnection());
         for(std::vector<std::pair<int64_t,std::string> >::iterator
                 i(mUnusedRootDirEntries.begin());

box/trunk/bin/bbackupd/BackupDaemon.h

@@ -25 +25 @@
 #include "TLSContext.h"
 
-#include "autogen_BackupProtocolClient.h"
+#include "autogen_BackupProtocol.h"
 
 #ifdef WIN32
@@ -383 +383 @@
         {
                 std::ostringstream msgs;
-                if (type != BackupProtocolClientError::ErrorType)
+                if (type != BackupProtocolError::ErrorType)
                 {
                         msgs << "unknown error type " << type;
@@ -391 +391 @@
                         switch(subtype)
                         {
-                        case BackupProtocolClientError::Err_WrongVersion:
+                        case BackupProtocolError::Err_WrongVersion:
                                 msgs << "WrongVersion";
                                 break;
-                        case BackupProtocolClientError::Err_NotInRightProtocolPhase:
+                        case BackupProtocolError::Err_NotInRightProtocolPhase:
                                 msgs << "NotInRightProtocolPhase";
                                 break;
-                        case BackupProtocolClientError::Err_BadLogin:
+                        case BackupProtocolError::Err_BadLogin:
                                 msgs << "BadLogin";
                                 break;
-                        case BackupProtocolClientError::Err_CannotLockStoreForWriting:
+                        case BackupProtocolError::Err_CannotLockStoreForWriting:
                                 msgs << "CannotLockStoreForWriting";
                                 break;
-                        case BackupProtocolClientError::Err_SessionReadOnly:
+                        case BackupProtocolError::Err_SessionReadOnly:
                                 msgs << "SessionReadOnly";
                                 break;
-                        case BackupProtocolClientError::Err_FileDoesNotVerify:
+                        case BackupProtocolError::Err_FileDoesNotVerify:
                                 msgs << "FileDoesNotVerify";
                                 break;
-                        case BackupProtocolClientError::Err_DoesNotExist:
+                        case BackupProtocolError::Err_DoesNotExist:
                                 msgs << "DoesNotExist";
                                 break;
-                        case BackupProtocolClientError::Err_DirectoryAlreadyExists:
+                        case BackupProtocolError::Err_DirectoryAlreadyExists:
                                 msgs << "DirectoryAlreadyExists";
                                 break;
-                        case BackupProtocolClientError::Err_CannotDeleteRoot:
+                        case BackupProtocolError::Err_CannotDeleteRoot:
                                 msgs << "CannotDeleteRoot";
                                 break;
-                        case BackupProtocolClientError::Err_TargetNameExists:
+                        case BackupProtocolError::Err_TargetNameExists:
                                 msgs << "TargetNameExists";
                                 break;
-                        case BackupProtocolClientError::Err_StorageLimitExceeded:
+                        case BackupProtocolError::Err_StorageLimitExceeded:
                                 msgs << "StorageLimitExceeded";
                                 break;
-                        case BackupProtocolClientError::Err_DiffFromFileDoesNotExist:
+                        case BackupProtocolError::Err_DiffFromFileDoesNotExist:
                                 msgs << "DiffFromFileDoesNotExist";
                                 break;
-                        case BackupProtocolClientError::Err_DoesNotExistInDirectory:
+                        case BackupProtocolError::Err_DoesNotExistInDirectory:
                                 msgs << "DoesNotExistInDirectory";
                                 break;
-                        case BackupProtocolClientError::Err_PatchConsistencyError:
+                        case BackupProtocolError::Err_PatchConsistencyError:
                                 msgs << "PatchConsistencyError";
                                 break;

box/trunk/bin/bbackupquery/BackupQueries.cpp

@@ -50 +50 @@
 #include "SelfFlushingStream.h"
 #include "Utils.h"
-#include "autogen_BackupProtocolClient.h"
+#include "autogen_BackupProtocol.h"
 
 #include "MemLeakFindOn.h"
@@ -359 +359 @@
 {
         // Generate exclude flags
-        int16_t excludeFlags = BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING;
-        if(!opts[LIST_OPTION_ALLOWOLD]) excludeFlags |= BackupProtocolClientListDirectory::Flags_OldVersion;
-        if(!opts[LIST_OPTION_ALLOWDELETED]) excludeFlags |= BackupProtocolClientListDirectory::Flags_Deleted;
+        int16_t excludeFlags = BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING;
+        if(!opts[LIST_OPTION_ALLOWOLD]) excludeFlags |= BackupProtocolListDirectory::Flags_OldVersion;
+        if(!opts[LIST_OPTION_ALLOWDELETED]) excludeFlags |= BackupProtocolListDirectory::Flags_Deleted;
 
         // Do communication
@@ -368 +368 @@
                 mrConnection.QueryListDirectory(
                                 DirID,
-                                BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING,
+                                BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING,
                                 // both files and directories
                                 excludeFlags,
@@ -435 +435 @@
                         *(f++) = ' ';
                         *(f++) = '\0';
-                        printf(displayflags);
+                        printf("%s", displayflags);
                         
                         if(en_flags != 0)
@@ -545 +545 @@
         // Start from current stack, or root, whichever is required
         std::vector<std::pair<std::string, int64_t> > stack;
-        int64_t dirID = BackupProtocolClientListDirectory::RootDirectory;
+        int64_t dirID = BackupProtocolListDirectory::RootDirectory;
         if(rDirName.size() > 0 && rDirName[0] == '/')
         {
@@ -561 +561 @@
 
         // Generate exclude flags
-        int16_t excludeFlags = BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING;
-        if(!AllowOldVersion) excludeFlags |= BackupProtocolClientListDirectory::Flags_OldVersion;
-        if(!AllowDeletedDirs) excludeFlags |= BackupProtocolClientListDirectory::Flags_Deleted;
+        int16_t excludeFlags = BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING;
+        if(!AllowOldVersion) excludeFlags |= BackupProtocolListDirectory::Flags_OldVersion;
+        if(!AllowDeletedDirs) excludeFlags |= BackupProtocolListDirectory::Flags_Deleted;
 
         // Read directories
@@ -583 +583 @@
                                         
                                         // New dir ID
-                                        dirID = (stack.size() > 0)?(stack[stack.size() - 1].second):BackupProtocolClientListDirectory::RootDirectory;
+                                        dirID = (stack.size() > 0)?(stack[stack.size() - 1].second):BackupProtocolListDirectory::RootDirectory;
                                 }
                                 else
                                 {       
                                         // At root anyway
-                                        dirID = BackupProtocolClientListDirectory::RootDirectory;
+                                        dirID = BackupProtocolListDirectory::RootDirectory;
                                 }
                         }
@@ -594 +594 @@
                         {
                                 // Not blank element. Read current directory.
-                                std::auto_ptr<BackupProtocolClientSuccess> dirreply(mrConnection.QueryListDirectory(
+                                std::auto_ptr<BackupProtocolSuccess> dirreply(mrConnection.QueryListDirectory(
                                                 dirID,
-                                                BackupProtocolClientListDirectory::Flags_Dir,   // just directories
+                                                BackupProtocolListDirectory::Flags_Dir, // just directories
                                                 excludeFlags,
                                                 true /* want attributes */));
@@ -647 +647 @@
         if(mDirStack.size() == 0)
         {
-                return BackupProtocolClientListDirectory::RootDirectory;
+                return BackupProtocolListDirectory::RootDirectory;
         }
         
@@ -838 +838 @@
         {
                 // Request object
-                std::auto_ptr<BackupProtocolClientSuccess> getobj(mrConnection.QueryGetObject(id));
-                if(getobj->GetObjectID() != BackupProtocolClientGetObject::NoObject)
+                std::auto_ptr<BackupProtocolSuccess> getobj(mrConnection.QueryGetObject(id));
+                if(getobj->GetObjectID() != BackupProtocolGetObject::NoObject)
                 {
                         // Stream that object out to the file
@@ -1018 +1018 @@
         {
                 // can retrieve anything by ID
-                flagsExclude = BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING;
+                flagsExclude = BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING;
         }
         else
@@ -1024 +1024 @@
                 // only current versions by name
                 flagsExclude =
-                        BackupProtocolClientListDirectory::Flags_OldVersion |
-                        BackupProtocolClientListDirectory::Flags_Deleted;
+                        BackupProtocolListDirectory::Flags_OldVersion |
+                        BackupProtocolListDirectory::Flags_Deleted;
         }
 
 
         fileId = FindFileID(args[0], opts, &dirId, &localName,
-                BackupProtocolClientListDirectory::Flags_File, // just files
+                BackupProtocolListDirectory::Flags_File, // just files
                 flagsExclude, NULL /* don't care about flags found */);
 
@@ -1520 +1520 @@
         mrConnection.QueryListDirectory(
                 DirID,
-                BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING,
+                BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING,
                 // get everything
-                BackupProtocolClientListDirectory::Flags_OldVersion |
-                BackupProtocolClientListDirectory::Flags_Deleted,
+                BackupProtocolListDirectory::Flags_OldVersion |
+                BackupProtocolListDirectory::Flags_Deleted,
                 // except for old versions and deleted files
                 true /* want attributes */);
@@ -1897 +1897 @@
         }
 
-        if(dirID == BackupProtocolClientListDirectory::RootDirectory)
+        if(dirID == BackupProtocolListDirectory::RootDirectory)
         {
                 BOX_ERROR("Cannot restore the root directory -- restore locations individually.");
@@ -2054 +2054 @@
 
         // Request full details from the server
-        std::auto_ptr<BackupProtocolClientAccountUsage> usage(mrConnection.QueryGetAccountUsage());
+        std::auto_ptr<BackupProtocolAccountUsage> usage(mrConnection.QueryGetAccountUsage());
 
         // Display each entry in turn
@@ -2130 +2130 @@
         fileId = FindFileID(storeDirEncoded, opts, &parentId, &fileName,
                 /* include files and directories */
-                BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING,
+                BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING,
                 /* include old and deleted files */
-                BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING,
+                BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING,
                 &flagsOut);
 
@@ -2145 +2145 @@
         {
                 // Undelete object
-                if(flagsOut & BackupProtocolClientListDirectory::Flags_File)
+                if(flagsOut & BackupProtocolListDirectory::Flags_File)
                 {
                         mrConnection.QueryUndeleteFile(parentId, fileId);
@@ -2210 +2210 @@
         fileId = FindFileID(storeDirEncoded, opts, &parentId, &fileName,
                 /* include files and directories */
-                BackupProtocolClientListDirectory::Flags_EXCLUDE_NOTHING,
+                BackupProtocolListDirectory::Flags_EXCLUDE_NOTHING,
                 /* exclude old and deleted files */
-                BackupProtocolClientListDirectory::Flags_OldVersion |
-                BackupProtocolClientListDirectory::Flags_Deleted,
+                BackupProtocolListDirectory::Flags_OldVersion |
+                BackupProtocolListDirectory::Flags_Deleted,
                 &flagsOut);
 
@@ -2228 +2228 @@
         {
                 // Delete object
-                if(flagsOut & BackupProtocolClientListDirectory::Flags_File)
+                if(flagsOut & BackupProtocolListDirectory::Flags_File)
                 {
                         mrConnection.QueryDeleteFile(parentId, fn);

box/trunk/bin/bbackupquery/CommandCompletion.cpp

@@ -33 +33 @@
 #include "Configuration.h"
 
-#include "autogen_BackupProtocolClient.h"
+#include "autogen_BackupProtocol.h"
 
 #include "MemLeakFindOn.h"
@@ -155 +155 @@
         if (rCommand.mOptions.find(LIST_OPTION_ALLOWOLD) == std::string::npos)
         {
-                excludeFlags |= BackupProtocolClientListDirectory::Flags_OldVersion;
+                excludeFlags |= BackupProtocolListDirectory::Flags_OldVersion;
         }
 
         if (rCommand.mOptions.find(LIST_OPTION_ALLOWDELETED) == std::string::npos)
         {
-                excludeFlags |= BackupProtocolClientListDirectory::Flags_Deleted;
+                excludeFlags |= BackupProtocolListDirectory::Flags_Deleted;
         }
 
@@ -226 +226 @@
 
         bool completeFiles = includeFlags &
-                BackupProtocolClientListDirectory::Flags_File;
+                BackupProtocolListDirectory::Flags_File;
         bool completeDirs = includeFlags &
-                BackupProtocolClientListDirectory::Flags_Dir;
+                BackupProtocolListDirectory::Flags_Dir;
         int16_t listFlags = 0;
 
         if(completeFiles)
         {
-                listFlags = BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING;
+                listFlags = BackupProtocolListDirectory::Flags_INCLUDE_EVERYTHING;
         }
         else if(completeDirs)
         {
-                listFlags = BackupProtocolClientListDirectory::Flags_Dir;
+                listFlags = BackupProtocolListDirectory::Flags_Dir;
         }
 
@@ -259 +259 @@
                 {
                         if(en->IsDir() &&
-                                (includeFlags & BackupProtocolClientListDirectory::Flags_Dir) == 0)
+                                (includeFlags & BackupProtocolListDirectory::Flags_Dir) == 0)
                         {
                                 // Was looking for a file, but this is a 
@@ -283 +283 @@
         completions = CompleteRemoteFileOrDirectory(rCommand, prefix,
                 rProtocol, rQueries,
-                BackupProtocolClientListDirectory::Flags_Dir);
+                BackupProtocolListDirectory::Flags_Dir);
 )
 
@@ -289 +289 @@
         completions = CompleteRemoteFileOrDirectory(rCommand, prefix,
                 rProtocol, rQueries,
-                BackupProtocolClientListDirectory::Flags_File);
+                BackupProtocolListDirectory::Flags_File);
 )
 
@@ -325 +325 @@
         rProtocol.QueryListDirectory(
                 listDirId,
-                BackupProtocolClientListDirectory::Flags_File,
+                BackupProtocolListDirectory::Flags_File,
                 excludeFlags, false /* no attributes */);
 

box/trunk/bin/bbackupquery/bbackupquery.cpp

@@ -51 +51 @@
 #include "BackupStoreConstants.h"
 #include "BackupStoreException.h"
-#include "autogen_BackupProtocolClient.h"
+#include "autogen_BackupProtocol.h"
 #include "BackupQueries.h"
 #include "FdGetLine.h"
@@ -448 +448 @@
         // Check the version of the server
         {
-                std::auto_ptr<BackupProtocolClientVersion> serverVersion(connection.QueryVersion(BACKUP_STORE_SERVER_VERSION));
+                std::auto_ptr<BackupProtocolVersion> serverVersion(connection.QueryVersion(BACKUP_STORE_SERVER_VERSION));
                 if(serverVersion->GetVersion() != BACKUP_STORE_SERVER_VERSION)
                 {
@@ -456 +456 @@
         // Login -- if this fails, the Protocol will exception
         connection.QueryLogin(conf.GetKeyValueUint32("AccountNumber"),
-                (readWrite)?0:(BackupProtocolClientLogin::Flags_ReadOnly));
+                (readWrite)?0:(BackupProtocolLogin::Flags_ReadOnly));
 
         // 5. Tell user.

box/trunk/bin/bbstored/BackupStoreDaemon.cpp

@@ -21 +21 @@
 #include "BackupStoreDaemon.h"
 #include "BackupStoreConfigVerify.h"
-#include "autogen_BackupProtocolServer.h"
+#include "autogen_BackupProtocol.h"
 #include "RaidFileController.h"
 #include "BackupStoreAccountDatabase.h"