Core/Battle.net:

* Changed packet structures to mirror client names
* Simplified ToString Building
* Removed deprecated structures

World: Cleaned up duplicate realm info 'realm' and 'realmHandle' variables (realmHandle was removed, that data is fully contained in realm)

1 files changed, 263 insertions, 160 deletions

diff --git a/src/server/bnetserver/Packets/AuthenticationPackets.cpp b/src/server/bnetserver/Packets/AuthenticationPackets.cpp
index 4c49bdcc5f1..10c0bfe2499 100644
--- a/src/server/bnetserver/Packets/AuthenticationPackets.cpp
+++ b/src/server/bnetserver/Packets/AuthenticationPackets.cpp
@@ -19,22 +19,33 @@
 #include "Session.h"
 #include "Util.h"
 
+std::string Battlenet::Authentication::RequestCommon::ToString() const
+{
+    std::ostringstream stream;
+    stream << "Battlenet::Authentication::RequestCommon" << std::endl;
+    APPEND_FIELD(stream, Program);
+    APPEND_FIELD(stream, Platform);
+    APPEND_FIELD(stream, Locale);
+    APPEND_FIELD(stream, Versions);
+    return stream.str();
+}
+
 void Battlenet::Authentication::ResumeRequest::Read()
 {
-    Program = _stream.ReadFourCC();
-    Platform = _stream.ReadFourCC();
-    Locale = _stream.ReadFourCC();
+    Common.Program = _stream.ReadFourCC();
+    Common.Platform = _stream.ReadFourCC();
+    Common.Locale = _stream.ReadFourCC();
 
-    Components.resize(_stream.Read<uint32>(6));
-    for (size_t i = 0; i < Components.size(); ++i)
+    Common.Versions.resize(_stream.Read<uint32>(6));
+    for (size_t i = 0; i < Common.Versions.size(); ++i)
     {
-        Component& component = Components[i];
-        component.Program = _stream.ReadFourCC();
-        component.Platform = _stream.ReadFourCC();
-        component.Build = _stream.Read<uint32>(32);
+        Version::Record& component = Common.Versions[i];
+        component.ProgramId = _stream.ReadFourCC();
+        component.Component = _stream.ReadFourCC();
+        component.Version = _stream.Read<uint32>(32);
     }
 
-    Login = _stream.ReadString(9, 3);
+    Account = _stream.ReadString(9, 3);
     GameAccountRegion = _stream.Read<uint8>(8);
     GameAccountName = _stream.ReadString(5, 1);
 }
@@ -42,14 +53,11 @@ void Battlenet::Authentication::ResumeRequest::Read()
 std::string Battlenet::Authentication::ResumeRequest::ToString() const
 {
     std::ostringstream stream;
-    stream << "Battlenet::Authentication::ResumeRequest Program: " << Program << ", Platform: " << Platform << ", Locale: " << Locale;
-    for (Component const& component : Components)
-        stream << std::endl << "Battlenet::Component Program: " << component.Program << ", Platform: " << component.Platform << ", Build: " << component.Build;
-
-    stream << std::endl << "Login: " << Login;
-    stream << std::endl << "GameAccountRegion: " << uint32(GameAccountRegion);
-    stream << std::endl << "GameAccountName: " << GameAccountName;
-
+    stream << "Battlenet::Authentication::ResumeRequest" << std::endl;
+    APPEND_FIELD(stream, Common);
+    APPEND_FIELD(stream, Account);
+    APPEND_FIELD(stream, GameAccountRegion);
+    APPEND_FIELD(stream, GameAccountName);
     return stream.str();
 }
 
@@ -58,47 +66,18 @@ void Battlenet::Authentication::ResumeRequest::CallHandler(Session* session)
     session->HandleResumeRequest(*this);
 }
 
-Battlenet::Authentication::ProofRequest::~ProofRequest()
-{
-    for (size_t i = 0; i < Modules.size(); ++i)
-        delete Modules[i];
-}
-
-void Battlenet::Authentication::ProofRequest::Write()
-{
-    _stream.Write(Modules.size(), 3);
-    for (ModuleInfo const* info : Modules)
-    {
-        _stream.WriteBytes(info->Type.c_str(), 4);
-        _stream.WriteFourCC(info->Region);
-        _stream.WriteBytes(info->ModuleId, 32);
-        _stream.Write(info->DataSize, 10);
-        _stream.WriteBytes(info->Data, info->DataSize);
-    }
-}
-
-std::string Battlenet::Authentication::ProofRequest::ToString() const
-{
-    std::ostringstream stream;
-    stream << "Battlenet::Authentication::ProofRequest modules " << Modules.size();
-    for (ModuleInfo const* module : Modules)
-        stream << std::endl << "Battlenet::ModuleInfo Locale " << module->Region.c_str() << ", ModuleId " << ByteArrayToHexStr(module->ModuleId, 32) << ", DataSize " << module->DataSize << ", Data " << ByteArrayToHexStr(module->Data, module->DataSize);
-
-    return stream.str();
-}
-
 Battlenet::Authentication::ProofResponse::~ProofResponse()
 {
-    for (size_t i = 0; i < Modules.size(); ++i)
-        delete Modules[i];
+    for (size_t i = 0; i < Response.size(); ++i)
+        delete Response[i];
 }
 
 void Battlenet::Authentication::ProofResponse::Read()
 {
-    Modules.resize(_stream.Read<uint32>(3));
-    for (size_t i = 0; i < Modules.size(); ++i)
+    Response.resize(_stream.Read<uint32>(3));
+    for (size_t i = 0; i < Response.size(); ++i)
     {
-        BitStream*& dataStream = Modules[i];
+        BitStream*& dataStream = Response[i];
         dataStream = new BitStream(_stream.Read<uint32>(10));
         memcpy(dataStream->GetBuffer(), _stream.ReadBytes(dataStream->GetSize()).get(), dataStream->GetSize());
     }
@@ -107,13 +86,8 @@ void Battlenet::Authentication::ProofResponse::Read()
 std::string Battlenet::Authentication::ProofResponse::ToString() const
 {
     std::ostringstream stream;
-    stream << "Battlenet::Authentication::ProofResponse Modules " << Modules.size();
-    for (BitStream* module : Modules)
-    {
-        std::string hexStr = ByteArrayToHexStr(module->GetBuffer(), module->GetSize());
-        stream << std::endl << "Battlenet::Authentication::ProofResponse::ModuleData Size: " << module->GetSize() << ", Data: " << hexStr;
-    }
-
+    stream << "Battlenet::Authentication::ProofRequest" << std::endl;
+    APPEND_FIELD(stream, Response.size());
     return stream.str();
 }
 
@@ -124,21 +98,21 @@ void Battlenet::Authentication::ProofResponse::CallHandler(Session* session)
 
 void Battlenet::Authentication::LogonRequest3::Read()
 {
-    Program = _stream.ReadFourCC();
-    Platform = _stream.ReadFourCC();
-    Locale = _stream.ReadFourCC();
+    Common.Program = _stream.ReadFourCC();
+    Common.Platform = _stream.ReadFourCC();
+    Common.Locale = _stream.ReadFourCC();
 
-    Components.resize(_stream.Read<uint32>(6));
-    for (size_t i = 0; i < Components.size(); ++i)
+    Common.Versions.resize(_stream.Read<uint32>(6));
+    for (size_t i = 0; i < Common.Versions.size(); ++i)
     {
-        Component& component = Components[i];
-        component.Program = _stream.ReadFourCC();
-        component.Platform = _stream.ReadFourCC();
-        component.Build = _stream.Read<uint32>(32);
+        Version::Record& component = Common.Versions[i];
+        component.ProgramId = _stream.ReadFourCC();
+        component.Component = _stream.ReadFourCC();
+        component.Version = _stream.Read<uint32>(32);
     }
 
     if (_stream.Read<uint32>(1))
-        Login = _stream.ReadString(9, 3);
+        Account = _stream.ReadString(9, 3);
 
     Compatibility = _stream.Read<uint64>(64);
 }
@@ -146,15 +120,10 @@ void Battlenet::Authentication::LogonRequest3::Read()
 std::string Battlenet::Authentication::LogonRequest3::ToString() const
 {
     std::ostringstream stream;
-    stream << "Battlenet::Authentication::LogonRequest3 Program: " << Program << ", Platform: " << Platform << ", Locale: " << Locale;
-    for (Component const& component : Components)
-        stream << std::endl << "Battlenet::Component Program: " << component.Program << ", Platform: " << component.Platform << ", Build: " << component.Build;
-
-    if (!Login.empty())
-        stream << std::endl << " Login: " << Login;
-
-    stream << " Compatibility: " << Compatibility;
-
+    stream << "Battlenet::Authentication::LogonRequest3" << std::endl;
+    APPEND_FIELD(stream, Common);
+    APPEND_FIELD(stream, Account);
+    APPEND_FIELD(stream, Compatibility);
     return stream.str();
 }
 
@@ -165,142 +134,255 @@ void Battlenet::Authentication::LogonRequest3::CallHandler(Session* session)
 
 Battlenet::Authentication::LogonResponse::~LogonResponse()
 {
-    for (ModuleInfo* m : Modules)
+    for (ModuleInfo* m : Result.Success.FinalRequest)
         delete m;
 }
 
 void Battlenet::Authentication::LogonResponse::Write()
 {
-    _stream.Write(Result.ResultValue != ResponseFailure::UPDATE, 1);
-    if (Result.ResultValue == ResponseFailure::UPDATE)
+    _stream.Write(Result.Type, 1);
+    if (Result.Type == ResultType::SUCCESS)
     {
-        _stream.Write(Modules.size(), 3);
-        for (size_t i = 0; i < Modules.size(); ++i)
+        _stream.Write(Result.Success.FinalRequest.size(), 3);
+        for (size_t i = 0; i < Result.Success.FinalRequest.size(); ++i)
         {
-            ModuleInfo* info = Modules[i];
-            _stream.WriteBytes(info->Type.c_str(), 4);
-            _stream.WriteFourCC(info->Region);
-            _stream.WriteBytes(info->ModuleId, 32);
+            ModuleInfo* info = Result.Success.FinalRequest[i];
+            _stream.WriteBytes(info->Handle.Type.c_str(), 4);
+            _stream.WriteFourCC(info->Handle.Region);
+            _stream.WriteBytes(info->Handle.ModuleId, 32);
             _stream.Write(info->DataSize, 10);
             _stream.WriteBytes(info->Data, info->DataSize);
         }
 
-        _stream.Write(PingTimeout + std::numeric_limits<int32>::min(), 32);
-        _stream.Write(1, 1);    // RegulatorRules != NULL (not a pointer for us, always write)
-        // if written == 1
+        _stream.Write(Result.Success.PingTimeout + std::numeric_limits<int32>::min(), 32);
+        _stream.Write(Result.Success.RegulatorRules.is_initialized(), 1);
+        if (Result.Success.RegulatorRules.is_initialized())
         {
-            _stream.Write(RegulatorRules.Type == Regulator::LEAKY_BUCKET, 1);
-            if (RegulatorRules.Type == Regulator::LEAKY_BUCKET)
+            _stream.Write(Result.Success.RegulatorRules->Type == Regulator::LEAKY_BUCKET, 1);
+            if (Result.Success.RegulatorRules->Type == Regulator::LEAKY_BUCKET)
             {
-                _stream.Write(RegulatorRules.Threshold, 32);
-                _stream.Write(RegulatorRules.Rate, 32);
+                _stream.Write(Result.Success.RegulatorRules->LeakyBucket.Threshold, 32);
+                _stream.Write(Result.Success.RegulatorRules->LeakyBucket.Rate, 32);
             }
         }
 
-        _stream.WriteString(FirstName, 8); // First name
-        _stream.WriteString(LastName, 8); // Last name - not set for WoW
-
-        _stream.Write(AccountId, 32);
-        _stream.Write(Region, 8);
-        _stream.Write(Flags, 64);
-
-        _stream.Write(GameAccountRegion, 8);
-        _stream.WriteString(GameAccountName, 5, -1);
-        _stream.Write(GameAccountFlags, 64);
-
-        _stream.Write(FailedLogins, 32);
-        _stream.Write(false, 1);            // RaF
+        _stream.WriteString(Result.Success.FullName.GivenName, 8);
+        _stream.WriteString(Result.Success.FullName.Surname, 8);
+        _stream.Write(Result.Success.AccountId, 32);
+        _stream.Write(Result.Success.Region, 8);
+        _stream.Write(Result.Success.Flags, 64);
+        _stream.Write(Result.Success.GameAccountRegion, 8);
+        _stream.WriteString(Result.Success.GameAccountName, 5, -1);
+        _stream.Write(Result.Success.GameAccountFlags, 64);
+        _stream.Write(Result.Success.LogonFailures, 32);
     }
     else
     {
-        _stream.Write(!Modules.empty(), 1);
-        if (!Modules.empty())
+        _stream.Write(Result.Failure.Strings.is_initialized(), 1);
+        if (Result.Failure.Strings.is_initialized())
         {
-            ModuleInfo* info = Modules[0];
-            _stream.WriteBytes(info->Type.c_str(), 4);
-            _stream.WriteFourCC(info->Region);
-            _stream.WriteBytes(info->ModuleId, 32);
+            _stream.WriteBytes(Result.Failure.Strings->Type.c_str(), 4);
+            _stream.WriteFourCC(Result.Failure.Strings->Region);
+            _stream.WriteBytes(Result.Failure.Strings->ModuleId, 32);
         }
 
-        _stream.Write(Result.ResultValue, 2);
-        if (Result.ResultValue == ResponseFailure::FAILURE)
+        _stream.Write(Result.Failure.Result.Type, 2);
+        if (Result.Failure.Result.Type == FailureType::FAILURE)
         {
-            _stream.Write(Result.Error, 16);
-            _stream.Write(Result.Wait + std::numeric_limits<int32>::min(), 32);
+            _stream.Write(Result.Failure.Result.Failure.Error, 16);
+            _stream.Write(Result.Failure.Result.Failure.Wait + std::numeric_limits<int32>::min(), 32);
         }
     }
+
+    _stream.Write(Raf.is_initialized(), 1);
+    if (Raf.is_initialized())
+    {
+        _stream.Write(Raf->size(), 10);
+        _stream.WriteBytes(Raf->data(), Raf->size());
+    }
 }
 
 std::string Battlenet::Authentication::LogonResponse::ToString() const
 {
     std::ostringstream stream;
-    stream << "Battlenet::Authentication::LogonResponse AuthResult " << Result.Error << " PingTimeout " << PingTimeout
-        << " RegulatorRules.Threshold " << RegulatorRules.Threshold << " RegulatorRules.Rate " << RegulatorRules.Rate
-        << " FirstName " << FirstName << " LastName " << LastName << " AccountId " << AccountId << " Region " << uint32(Region) << " GameAccountName " << GameAccountName
-        << " GameAccountFlags " << GameAccountFlags << " FailedLogins " << FailedLogins << " Modules " << Modules.size();
+    stream << "Battlenet::Authentication::LogonResponse" << std::endl;
+    APPEND_FIELD(stream, Result);
+    APPEND_FIELD(stream, Raf);
+    return stream.str();
+}
 
-    for (ModuleInfo const* module : Modules)
-        stream << std::endl << "Battlenet::ModuleInfo Locale " << module->Region.c_str() << ", ModuleId " << ByteArrayToHexStr(module->ModuleId, 32) << ", DataSize " << module->DataSize << ", Data " << ByteArrayToHexStr(module->Data, module->DataSize);
+std::string Battlenet::Authentication::FailureType::ToString() const
+{
+    std::ostringstream stream;
+    stream << "Battlenet::Authentication::FailureType" << std::endl;
+    APPEND_FIELD(stream, Strings);
+    APPEND_FIELD(stream, Result);
+    return stream.str();
+}
 
+std::string Battlenet::Authentication::FailureType::ResultType::ToString() const
+{
+    std::ostringstream stream;
+    stream << "Battlenet::Authentication::ResponseFailure::Result" << std::endl;
+    switch (Type)
+    {
+        case UPDATE:
+            APPEND_FIELD(stream, Update);
+            break;
+        case FAILURE:
+            APPEND_FIELD(stream, Failure);
+            break;
+        case VERSION_CHECK_DISCONNECT:
+            APPEND_FIELD(stream, VersionCheckDisconnect);
+            break;
+        default:
+            break;
+    }
+    return stream.str();
+}
+
+std::string Battlenet::Authentication::FailureType::ResultType::UpdateType::ToString() const
+{
+    return "Battlenet::Authentication::ResponseFailure::Result::Update";
+}
+
+std::string Battlenet::Authentication::FailureType::ResultType::FailureType::ToString() const
+{
+    std::ostringstream stream;
+    stream << "Battlenet::Authentication::ResponseFailure::Result::Failure" << std::endl;
+    APPEND_FIELD(stream, Error);
+    APPEND_FIELD(stream, Wait);
+    return stream.str();
+}
+
+std::string Battlenet::Authentication::FailureType::ResultType::VersionCheckDisconnectType::ToString() const
+{
+    return "Battlenet::Authentication::ResponseFailure::Result::VersionCheckDisconnect";
+}
+
+std::string Battlenet::Authentication::Regulator::NoneType::ToString() const
+{
+    return "Battlenet::Regulator::None";
+}
+
+std::string Battlenet::Authentication::Regulator::LeakyBucketType::ToString() const
+{
+    std::ostringstream stream;
+    stream << "Battlenet::Regulator::LeakyBucket" << std::endl;
+    APPEND_FIELD(stream, Threshold);
+    APPEND_FIELD(stream, Rate);
+    return stream.str();
+}
+
+std::string Battlenet::Authentication::Regulator::ToString() const
+{
+    std::ostringstream stream;
+    stream << "Battlenet::Regulator" << std::endl;
+    switch (Type)
+    {
+        case NONE:
+            APPEND_FIELD(stream, None);
+            break;
+        case LEAKY_BUCKET:
+            APPEND_FIELD(stream, LeakyBucket);
+            break;
+        default:
+            break;
+    }
+    return stream.str();
+}
+
+std::string Battlenet::Authentication::LogonResponse::ResultType::ToString() const
+{
+    std::ostringstream stream;
+    stream << "Battlenet::Authentication::LogonResponse::Result" << std::endl;
+    switch (Type)
+    {
+        case SUCCESS:
+            APPEND_FIELD(stream, Success);
+            break;
+        case FAILURE:
+            APPEND_FIELD(stream, Failure);
+            break;
+        default:
+            break;
+    }
+    return stream.str();
+}
+
+std::string Battlenet::Authentication::LogonResponse::ResultType::SuccessType::ToString() const
+{
+    std::ostringstream stream;
+    stream << "Battlenet::Authentication::LogonResponse::Result::Success" << std::endl;
+    APPEND_FIELD(stream, FinalRequest);
+    APPEND_FIELD(stream, PingTimeout);
+    APPEND_FIELD(stream, RegulatorRules);
+    APPEND_FIELD(stream, FullName);
+    APPEND_FIELD(stream, AccountId);
+    APPEND_FIELD(stream, Region);
+    APPEND_FIELD(stream, Flags);
+    APPEND_FIELD(stream, GameAccountRegion);
+    APPEND_FIELD(stream, GameAccountName);
+    APPEND_FIELD(stream, GameAccountFlags);
+    APPEND_FIELD(stream, LogonFailures);
     return stream.str();
 }
 
 void Battlenet::Authentication::LogonResponse::SetAuthResult(AuthResult result)
 {
-    Result.ResultValue = result != AUTH_OK ? ResponseFailure::FAILURE : ResponseFailure::UPDATE;
-    Result.Error = result;
+    Result.Type = result != AUTH_OK ? ResultType::FAILURE : ResultType::SUCCESS;
+    Result.Failure.Result.Failure.Error = result;
 }
 
 Battlenet::Authentication::ResumeResponse::~ResumeResponse()
 {
-    for (ModuleInfo* m : Modules)
+    for (ModuleInfo* m : Result.Success.FinalRequest)
         delete m;
 }
 
 void Battlenet::Authentication::ResumeResponse::Write()
 {
-    _stream.Write(Result.ResultValue != ResponseFailure::UPDATE, 1);
-    if (Result.ResultValue == ResponseFailure::UPDATE)
+    _stream.Write(Result.Type, 1);
+    if (Result.Type == ResultType::SUCCESS)
     {
-        _stream.Write(Modules.size(), 3);
-        for (size_t i = 0; i < Modules.size(); ++i)
+        _stream.Write(Result.Success.FinalRequest.size(), 3);
+        for (size_t i = 0; i < Result.Success.FinalRequest.size(); ++i)
         {
-            ModuleInfo* info = Modules[i];
-            _stream.WriteBytes(info->Type.c_str(), 4);
-            _stream.WriteFourCC(info->Region);
-            _stream.WriteBytes(info->ModuleId, 32);
+            ModuleInfo* info = Result.Success.FinalRequest[i];
+            _stream.WriteBytes(info->Handle.Type.c_str(), 4);
+            _stream.WriteFourCC(info->Handle.Region);
+            _stream.WriteBytes(info->Handle.ModuleId, 32);
             _stream.Write(info->DataSize, 10);
             _stream.WriteBytes(info->Data, info->DataSize);
         }
 
-        _stream.Write(PingTimeout + std::numeric_limits<int32>::min(), 32);
-        _stream.Write(1, 1);    // RegulatorRules != NULL (not a pointer for us, always write)
-        // if written == 1
+        _stream.Write(Result.Success.PingTimeout + std::numeric_limits<int32>::min(), 32);
+        _stream.Write(Result.Success.RegulatorRules.is_initialized(), 1);
+        if (Result.Success.RegulatorRules.is_initialized())
         {
-            _stream.Write(RegulatorRules.Type == Regulator::LEAKY_BUCKET, 1);
-            if (RegulatorRules.Type == Regulator::LEAKY_BUCKET)
+            _stream.Write(Result.Success.RegulatorRules->Type == Regulator::LEAKY_BUCKET, 1);
+            if (Result.Success.RegulatorRules->Type == Regulator::LEAKY_BUCKET)
             {
-                _stream.Write(RegulatorRules.Threshold, 32);
-                _stream.Write(RegulatorRules.Rate, 32);
+                _stream.Write(Result.Success.RegulatorRules->LeakyBucket.Threshold, 32);
+                _stream.Write(Result.Success.RegulatorRules->LeakyBucket.Rate, 32);
             }
         }
     }
     else
     {
-        _stream.Write(!Modules.empty(), 1);
-        if (!Modules.empty())
+        _stream.Write(Result.Failure.Strings.is_initialized(), 1);
+        if (Result.Failure.Strings.is_initialized())
         {
-            ModuleInfo* info = Modules[0];
-            _stream.WriteBytes(info->Type.c_str(), 4);
-            _stream.WriteFourCC(info->Region);
-            _stream.WriteBytes(info->ModuleId, 32);
+            _stream.WriteBytes(Result.Failure.Strings->Type.c_str(), 4);
+            _stream.WriteFourCC(Result.Failure.Strings->Region);
+            _stream.WriteBytes(Result.Failure.Strings->ModuleId, 32);
         }
 
-        _stream.Write(Result.ResultValue, 2);
-        if (Result.ResultValue == ResponseFailure::FAILURE)
+        _stream.Write(Result.Failure.Result.Type, 2);
+        if (Result.Failure.Result.Type == FailureType::FAILURE)
         {
-            _stream.Write(Result.Error, 16);
-            _stream.Write(Result.Wait + std::numeric_limits<int32>::min(), 32);
+            _stream.Write(Result.Failure.Result.Failure.Error, 16);
+            _stream.Write(Result.Failure.Result.Failure.Wait + std::numeric_limits<int32>::min(), 32);
         }
     }
 }
@@ -308,18 +390,39 @@ void Battlenet::Authentication::ResumeResponse::Write()
 std::string Battlenet::Authentication::ResumeResponse::ToString() const
 {
     std::ostringstream stream;
-    stream << "Battlenet::Authentication::ResumeResponse AuthResult " << Result.Error << " PingTimeout " << PingTimeout
-        << " RegulatorRules.Threshold " << RegulatorRules.Threshold << " RegulatorRules.Rate " << RegulatorRules.Rate
-        << " Modules " << Modules.size();
-
-    for (ModuleInfo const* module : Modules)
-        stream << std::endl << "Battlenet::ModuleInfo Locale " << module->Region.c_str() << ", ModuleId " << ByteArrayToHexStr(module->ModuleId, 32) << ", DataSize " << module->DataSize << ", Data " << ByteArrayToHexStr(module->Data, module->DataSize);
-
+    stream << "Battlenet::Authentication::ResumeResponse" << std::endl;
     return stream.str();
 }
 
 void Battlenet::Authentication::ResumeResponse::SetAuthResult(AuthResult result)
 {
-    Result.ResultValue = result != AUTH_OK ? ResponseFailure::FAILURE : ResponseFailure::UPDATE;
-    Result.Error = result;
+    Result.Type = result != AUTH_OK ? ResultType::FAILURE : ResultType::SUCCESS;
+    Result.Failure.Result.Failure.Error = result;
+}
+
+Battlenet::Authentication::ProofRequest::~ProofRequest()
+{
+    for (size_t i = 0; i < Modules.size(); ++i)
+        delete Modules[i];
+}
+
+void Battlenet::Authentication::ProofRequest::Write()
+{
+    _stream.Write(Modules.size(), 3);
+    for (ModuleInfo const* info : Modules)
+    {
+        _stream.WriteBytes(info->Handle.Type.c_str(), 4);
+        _stream.WriteFourCC(info->Handle.Region);
+        _stream.WriteBytes(info->Handle.ModuleId, 32);
+        _stream.Write(info->DataSize, 10);
+        _stream.WriteBytes(info->Data, info->DataSize);
+    }
+}
+
+std::string Battlenet::Authentication::ProofRequest::ToString() const
+{
+    std::ostringstream stream;
+    stream << "Battlenet::Authentication::ProofRequest" << std::endl;
+    APPEND_FIELD(stream, Modules);
+    return stream.str();
 }