You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
440 lines
10 KiB
440 lines
10 KiB
/*==LICENSE==* |
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools |
|
Copyright (C) 2011 Cyan Worlds, Inc. |
|
|
|
This program is free software: you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation, either version 3 of the License, or |
|
(at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
|
Additional permissions under GNU GPL version 3 section 7 |
|
|
|
If you modify this Program, or any covered work, by linking or |
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
(or a modified version of those libraries), |
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
licensors of this Program grant you additional |
|
permission to convey the resulting work. Corresponding Source for a |
|
non-source form of such a combination shall include the source code for |
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
work. |
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
|
or by snail mail at: |
|
Cyan Worlds, Inc. |
|
14617 N Newport Hwy |
|
Mead, WA 99021 |
|
|
|
*==LICENSE==*/ |
|
#include "plClientGuid.h" |
|
#include "hsStream.h" |
|
#include <sstream> |
|
#include "plNetCommon.h" |
|
#include "../pnMessage/plMessage.h" |
|
#include "../plSockets/plNet.h" |
|
|
|
plClientGuid::plClientGuid() |
|
:fPlayerID(0) |
|
,fCCRLevel(0) |
|
,fFlags(0) |
|
,fProtectedLogin(false) |
|
,fBuildType(plNetCommon::BuildType::kUnknown) |
|
,fSrcAddr(0) |
|
,fSrcPort(0) |
|
,fReserved(false) |
|
{ |
|
fAccountUUID.Clear(); |
|
} |
|
|
|
void plClientGuid::SetAccountUUID(const plUUID * v ) |
|
{ |
|
fAccountUUID.CopyFrom( v ); |
|
if ( !fAccountUUID.IsNull() ) |
|
fFlags|=kAccountUUID; |
|
else |
|
fFlags&=~kAccountUUID; |
|
} |
|
|
|
void plClientGuid::SetAccountUUID(const plUUID & v ) |
|
{ |
|
SetAccountUUID( &v ); |
|
} |
|
|
|
void plClientGuid::SetBuildType(UInt8 type) |
|
{ |
|
fBuildType=type; |
|
fFlags|=kBuildType; |
|
} |
|
|
|
void plClientGuid::SetPlayerID(UInt32 id) |
|
{ |
|
fPlayerID=id; |
|
if ( fPlayerID ) |
|
{ |
|
fFlags|=kPlayerID; |
|
fFlags&=~kTempPlayerID; |
|
} |
|
else |
|
fFlags&=~kPlayerID; |
|
} |
|
|
|
void plClientGuid::SetTempPlayerID(UInt32 id) |
|
{ |
|
fPlayerID=id; |
|
if ( fPlayerID ) |
|
{ |
|
fFlags&=~kPlayerID; |
|
fFlags|=kTempPlayerID; |
|
} |
|
else |
|
{ |
|
fFlags&=~kTempPlayerID; |
|
} |
|
} |
|
|
|
void plClientGuid::SetPlayerName( const char * v ) |
|
{ |
|
fPlayerName = v?v:""; |
|
if ( fPlayerName.size() ) |
|
fFlags|=kPlayerName; |
|
else |
|
fFlags&=~kPlayerName; |
|
} |
|
|
|
void plClientGuid::SetCCRLevel(UInt8 v) |
|
{ |
|
fCCRLevel=v; |
|
fFlags|=kCCRLevel; |
|
} |
|
|
|
void plClientGuid::SetProtectedLogin(bool b) |
|
{ |
|
fProtectedLogin=b; |
|
fFlags |= kProtectedLogin; |
|
} |
|
|
|
void plClientGuid::SetSrcAddr( UInt32 v ) |
|
{ |
|
fSrcAddr = v; |
|
if ( fSrcAddr ) |
|
fFlags|=kSrcAddr; |
|
else |
|
fFlags&=~kSrcAddr; |
|
} |
|
|
|
void plClientGuid::SetSrcAddrFromStr( const char * s ) |
|
{ |
|
hsAssert(false, "eric, port me"); |
|
} |
|
|
|
void plClientGuid::SetSrcPort( UInt16 v ) |
|
{ |
|
fSrcPort = v; |
|
if ( fSrcPort ) |
|
fFlags|=kSrcPort; |
|
else |
|
fFlags&=~kSrcPort; |
|
} |
|
|
|
void plClientGuid::SetReserved(bool b) |
|
{ |
|
fReserved=b; |
|
fFlags |= kReserved; |
|
} |
|
|
|
void plClientGuid::SetClientKey(const std::string& key) |
|
{ |
|
fClientKey = key; |
|
if ( fClientKey.size() ) |
|
fFlags|=kClientKey; |
|
else |
|
fFlags&=~kClientKey; |
|
} |
|
|
|
const char * plClientGuid::GetSrcAddrStr() const |
|
{ |
|
hsAssert(false, "eric, port me"); |
|
static const char foo[] = ""; |
|
return foo; |
|
} |
|
|
|
std::string plClientGuid::AsStdString() const |
|
{ |
|
#define kComma "," |
|
#define kEmpty "" |
|
const char * spacer = kEmpty; |
|
|
|
std::stringstream ss; |
|
|
|
ss << "["; |
|
|
|
if (IsFlagSet(kPlayerID)) |
|
{ |
|
ss << spacer << "Pid:" << fPlayerID; |
|
spacer = kComma; |
|
} |
|
else if (IsFlagSet(kTempPlayerID)) |
|
{ |
|
ss << spacer << "tPd:" << fPlayerID; |
|
spacer = kComma; |
|
} |
|
if (IsFlagSet(kPlayerName)) |
|
{ |
|
ss << spacer << "Plr:" << fPlayerName; |
|
} |
|
if (IsFlagSet(kCCRLevel)) |
|
{ |
|
ss << spacer << "CCR:" << (int)fCCRLevel; |
|
spacer = kComma; |
|
} |
|
if (IsFlagSet(kProtectedLogin)) |
|
{ |
|
ss << spacer << "Pro:" << (int)fProtectedLogin; |
|
spacer = kComma; |
|
} |
|
if (IsFlagSet(kBuildType)) |
|
{ |
|
ss << spacer << "Bld:" << plNetCommon::BuildType::BuildTypeStr(fBuildType); |
|
spacer = kComma; |
|
} |
|
if ( IsFlagSet(kSrcAddr) ) |
|
{ |
|
ss << spacer << "Addr:" << GetSrcAddrStr(); |
|
spacer = kComma; |
|
} |
|
if ( IsFlagSet(kSrcPort) ) |
|
{ |
|
ss << spacer << "Port:" << (int)fSrcPort; |
|
spacer = kComma; |
|
} |
|
if (IsFlagSet(kAccountUUID)) |
|
{ |
|
ss << spacer << "plUUID:" << fAccountUUID.AsStdString(); |
|
spacer = kComma; |
|
} |
|
if ( IsFlagSet(kReserved)) |
|
{ |
|
ss << spacer << "Res:" << (int)fReserved; |
|
spacer = kComma; |
|
} |
|
if (IsFlagSet(kClientKey)) |
|
{ |
|
ss << spacer << "ClientKey:" << fClientKey; |
|
spacer = kComma; |
|
} |
|
ss << "]"; |
|
|
|
return ss.str().c_str(); |
|
} |
|
|
|
std::string plClientGuid::AsLogString() const |
|
{ |
|
#define kSemicolon ";" |
|
const char* spacer = kSemicolon; |
|
|
|
std::stringstream ss; |
|
|
|
if (IsFlagSet(kAccountUUID)) |
|
{ |
|
ss << "AcctUUID=" << fAccountUUID.AsStdString(); |
|
ss << spacer; |
|
} |
|
if (IsFlagSet(kPlayerID)) |
|
{ |
|
ss << "PlayerID=" << fPlayerID; |
|
ss << spacer; |
|
} |
|
// else if (IsFlagSet(kTempPlayerID)) |
|
// { |
|
// ss << "tempPlayerID:" << fPlayerID; |
|
// ss << spacer; |
|
// } |
|
if ( IsFlagSet(kSrcAddr) ) |
|
{ |
|
ss << "SrcAddr=" << GetSrcAddrStr(); |
|
ss << spacer; |
|
} |
|
if ( IsFlagSet(kSrcPort) ) |
|
{ |
|
ss << "SrcPort=" << (int)fSrcPort; |
|
ss << spacer; |
|
} |
|
if (IsFlagSet(kCCRLevel)) |
|
{ |
|
ss << "CCRLevel=" << (int)fCCRLevel; |
|
ss << spacer; |
|
} |
|
if (IsFlagSet(kProtectedLogin)) |
|
{ |
|
ss << "Protected=" << (int)fProtectedLogin; |
|
ss << spacer; |
|
} |
|
if (IsFlagSet(kBuildType)) |
|
{ |
|
ss << "Build=" << plNetCommon::BuildType::BuildTypeStr(fBuildType); |
|
ss << spacer; |
|
} |
|
if (IsFlagSet(kReserved)) |
|
{ |
|
ss << "Reserved=" << (int)fReserved; |
|
ss << spacer; |
|
} |
|
if (IsFlagSet(kClientKey)) |
|
{ |
|
ss << "ClientKey=" << fClientKey; |
|
ss << spacer; |
|
} |
|
|
|
return ss.str().c_str(); |
|
} |
|
|
|
void plClientGuid::Read(hsStream * s, hsResMgr* mgr) |
|
{ |
|
s->LogSubStreamStart("push me"); |
|
s->LogReadSwap(&fFlags,"Flags"); |
|
if (IsFlagSet(kAccountUUID)) |
|
{ |
|
s->LogSubStreamPushDesc("AcctUUID"); |
|
fAccountUUID.Read( s ); |
|
} |
|
if (IsFlagSet(kPlayerID)) |
|
s->LogReadSwap(&fPlayerID,"PlayerID"); |
|
else if (IsFlagSet(kTempPlayerID)) |
|
s->LogReadSwap(&fPlayerID,"TempPlayerID"); |
|
if (IsFlagSet(kPlayerName)) |
|
{ |
|
s->LogSubStreamPushDesc("PlayerName"); |
|
plMsgStdStringHelper::Peek( fPlayerName, s ); |
|
} |
|
if (IsFlagSet(kCCRLevel)) |
|
s->LogReadSwap(&fCCRLevel,"CCRLevel"); |
|
if (IsFlagSet(kProtectedLogin)) |
|
s->LogReadSwap(&fProtectedLogin,"ProtectedLogin"); |
|
if (IsFlagSet(kBuildType)) |
|
s->LogReadSwap(&fBuildType,"BuildType"); |
|
if (IsFlagSet(kSrcAddr)) |
|
s->LogReadSwap(&fSrcAddr,"SrcAddr"); |
|
if (IsFlagSet(kSrcPort)) |
|
s->LogReadSwap(&fSrcPort,"SrcPort"); |
|
if (IsFlagSet(kReserved)) |
|
s->LogReadSwap(&fReserved,"Reserved"); |
|
if (IsFlagSet(kClientKey)) |
|
{ |
|
s->LogSubStreamPushDesc("ClientKey"); |
|
plMsgStdStringHelper::Peek( fClientKey, s ); |
|
} |
|
s->LogSubStreamEnd(); |
|
} |
|
|
|
void plClientGuid::Write(hsStream * s, hsResMgr* mgr) |
|
{ |
|
s->WriteSwap(fFlags); |
|
if (IsFlagSet(kAccountUUID)) |
|
fAccountUUID.Write( s ); |
|
if (IsFlagSet(kPlayerID)) |
|
s->WriteSwap(fPlayerID); |
|
else if (IsFlagSet(kTempPlayerID)) |
|
s->WriteSwap(fPlayerID); |
|
if (IsFlagSet(kPlayerName)) |
|
plMsgStdStringHelper::Poke( fPlayerName, s ); |
|
if (IsFlagSet(kCCRLevel)) |
|
s->WriteSwap(fCCRLevel); |
|
if (IsFlagSet(kProtectedLogin)) |
|
s->WriteSwap(fProtectedLogin); |
|
if (IsFlagSet(kBuildType)) |
|
s->WriteSwap(fBuildType); |
|
if (IsFlagSet(kSrcAddr)) |
|
s->WriteSwap(fSrcAddr); |
|
if (IsFlagSet(kSrcPort)) |
|
s->WriteSwap(fSrcPort); |
|
if (IsFlagSet(kReserved)) |
|
s->WriteSwap(fReserved); |
|
if (IsFlagSet(kClientKey)) |
|
plMsgStdStringHelper::Poke( fClientKey, s ); |
|
} |
|
|
|
void plClientGuid::CopyFrom(const plClientGuid * other) |
|
{ |
|
fFlags = other->fFlags; |
|
fAccountUUID.CopyFrom( &other->fAccountUUID ); |
|
fPlayerID = other->fPlayerID; |
|
fPlayerName = other->fPlayerName; |
|
fCCRLevel = other->fCCRLevel; |
|
fProtectedLogin = other->fProtectedLogin; |
|
fBuildType = other->fBuildType; |
|
fSrcAddr = other->fSrcAddr; |
|
fSrcPort = other->fSrcPort; |
|
fReserved = other->fReserved; |
|
fClientKey = other->fClientKey; |
|
} |
|
|
|
void plClientGuid::UpdateFrom(const plClientGuid * other) |
|
{ |
|
if ( !HasAccountUUID() && other->HasAccountUUID() ) |
|
SetAccountUUID( other->GetAccountUUID() ); |
|
if ( !HasPlayerID() && other->HasPlayerID() ) |
|
SetPlayerID( other->GetPlayerID() ); |
|
if ( !HasPlayerName() && other->HasPlayerName() ) |
|
SetPlayerName( other->GetPlayerName() ); |
|
if ( !HasProtectedLogin() && other->HasProtectedLogin() ) |
|
SetProtectedLogin( other->GetProtectedLogin() ); |
|
if ( !HasCCRLevel() && other->HasCCRLevel() ) |
|
SetCCRLevel( other->GetCCRLevel() ); |
|
if ( !HasBuildType() && other->HasBuildType() ) |
|
SetBuildType( other->GetBuildType() ); |
|
if ( !HasSrcAddr() && other->HasSrcAddr() ) |
|
SetSrcAddr( other->GetSrcAddr() ); |
|
if ( !HasSrcPort() && other->HasSrcPort() ) |
|
SetSrcPort( other->GetSrcPort() ); |
|
if ( !HasReservedBit() && other->HasReservedBit() ) |
|
SetReserved( other->IsReserved() ); |
|
if ( !HasClientKey() && other->HasClientKey() ) |
|
SetClientKey( other->GetClientKey() ); |
|
} |
|
|
|
void plClientGuid::Clear() |
|
{ |
|
plClientGuid tmp; |
|
CopyFrom( &tmp ); |
|
} |
|
|
|
bool plClientGuid::IsEqualTo(const plClientGuid * other) const |
|
{ |
|
return |
|
fFlags == other->fFlags && |
|
fAccountUUID.IsEqualTo( &other->fAccountUUID ) && |
|
fPlayerID == other->fPlayerID && |
|
fPlayerName == other->fPlayerName && |
|
fCCRLevel == other->fCCRLevel && |
|
fProtectedLogin == other->fProtectedLogin && |
|
fBuildType == other->fBuildType && |
|
fReserved == other->fReserved && |
|
fClientKey == other->fClientKey; |
|
} |
|
|
|
bool operator==(const plClientGuid & X, const plClientGuid & Y) |
|
{ |
|
return ( X.fAccountUUID.IsEqualTo( &Y.fAccountUUID )&&X.fPlayerID==Y.fPlayerID&&X.fFlags==Y.fFlags); |
|
} |
|
bool operator!=(const plClientGuid & X, const plClientGuid & Y) |
|
{ |
|
return ( !X.fAccountUUID.IsEqualTo( &Y.fAccountUUID )||X.fPlayerID!=Y.fPlayerID||X.fFlags!=Y.fFlags); |
|
} |
|
bool operator<(const plClientGuid & X, const plClientGuid & Y) |
|
{ |
|
return ( X.fAccountUUID.CompareTo( &Y.fAccountUUID )<0||X.fPlayerID<Y.fPlayerID); |
|
} |
|
|
|
|