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.
423 lines
12 KiB
423 lines
12 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/>. |
|
|
|
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==*/ |
|
/***************************************************************************** |
|
* |
|
* $/Plasma20/Sources/Plasma/NucleusLib/pnNetCli/pnNetCli.h |
|
* |
|
***/ |
|
|
|
#ifndef PLASMA20_SOURCES_PLASMA_NUCLEUSLIB_PNNETCLI_PNNETCLI_H |
|
#define PLASMA20_SOURCES_PLASMA_NUCLEUSLIB_PNNETCLI_PNNETCLI_H |
|
|
|
|
|
/***************************************************************************** |
|
* |
|
* |
|
|
|
How to create a message sender/receiver: |
|
|
|
1. Define message ids |
|
|
|
enum { |
|
kMsgMoveObject, |
|
kMsgPlayerJoin, |
|
kMsgPing, |
|
kMsgPingReply, |
|
// etc. |
|
}; |
|
|
|
|
|
2. Define packed message structures |
|
|
|
#include <PshPack1.h> |
|
struct MoveObject { |
|
dword messageId; |
|
dword objectId; |
|
float newPos[3]; |
|
}; |
|
struct PlayerJoin { |
|
dword messageId; |
|
dword playerId; |
|
wchar name[kPlayerNameMaxLength]; |
|
byte data[kPlayerDataMaxLength]; |
|
dword vaultDataLen; |
|
byte vaultData[1]; // vaultData[vaultDataLen], actually |
|
// no more fields after variable-length data |
|
}; |
|
struct Ping { |
|
dword messageId; |
|
dword pingTimeMs; |
|
}; |
|
struct PingReply { |
|
dword messageId; |
|
dword pingTimeMs; |
|
} |
|
#include <PopPack.h> |
|
|
|
|
|
3. Define message fields |
|
|
|
static const NetMsgField kFieldObjectId = NET_MSG_FIELD_DWORD(); |
|
static const NetMsgField kFieldPlayerId = NET_MSG_FIELD_DWORD(); |
|
static const NetMsgField kFieldObjectPos = NET_MSG_FIELD_FLOAT_ARRAY(3); |
|
static const NetMsgField kFieldPlayerName = NET_MSG_FIELD_STRING(kPlayerNameMaxLength); |
|
static const NetMsgField kFieldPlayerData = NET_MSG_FIELD_PTR(kPlayerDataMaxLength); |
|
static const NetMsgField kFieldVaultDataLen = NET_MSG_FIELD_VAR_COUNT(kVaultDataMaxLength); |
|
static const NetMsgField kFieldVaultData = NET_MSG_FIELD_VAR_PTR(); |
|
static const NetMsgField kFieldPingTimeMs = NET_MSG_FIELD_DWORD(); |
|
|
|
|
|
4. Build field and message description blocks |
|
|
|
// MoveObject |
|
static const NetMsgField s_moveObjectFields[] = { |
|
kFieldObjectId, |
|
kFieldObjectPos, |
|
}; |
|
static const NetMsg s_msgMoveObject = NET_MSG(kMsgMoveObject, s_msgMoveObjectFields); |
|
|
|
// PlayerJoin |
|
static const NetMsgField s_playerJoinFields[] = { |
|
kFieldPlayerId, |
|
kFieldPlayerName, |
|
kFieldPlayerData, |
|
kFieldVaultDataLen, |
|
kFieldVaultData, |
|
}; |
|
static const NetMsg s_playerJoin = NET_MSG(kMsgPlayerJoin, s_msgPlayerJoin); |
|
|
|
|
|
|
|
5. Register message description blocks |
|
|
|
// for server: |
|
static const NetMsgInitSend s_srvSend[] = { |
|
{ s_moveObject }, |
|
{ s_playerJoin }, |
|
{ s_ping }, |
|
}; |
|
|
|
static const NetMsgInitRecv s_srvRecv[] = { |
|
{ s_pingReply, RecvMsgPingReply }, |
|
}; |
|
|
|
s_srvConn = NetMsgProtocolRegister( |
|
kNetProtocolCliToGame, |
|
true, |
|
s_srvSend, arrsize(s_srvSend), |
|
s_srvRecv, arrsize(s_srvRecv) |
|
); |
|
|
|
|
|
// for client: |
|
static const NetMsgInitSend s_cliSend[] = { |
|
{ s_pingReply }, |
|
}; |
|
|
|
static const NetMsgInitRecv s_cliRecv[] = { |
|
{ s_moveObject, RecvMsgMoveObject }, |
|
{ s_playerJoin, RecvMsgPlayerJoin }, |
|
{ s_ping, RecvMsgPing }, |
|
}; |
|
|
|
s_cliConn = NetMsgProtocolRegister( |
|
kNetProtocolCliToGame, |
|
false, |
|
s_cliSend, arrsize(s_cliSend), |
|
s_cliRecv, arrsize(s_cliRecv) |
|
); |
|
|
|
|
|
5. Send messages |
|
|
|
static void SendMoveObject (NetCli client, const Object * obj) { |
|
const unsigned_ptr msgMoveObject[] = { |
|
kMsgMoveObject, |
|
obj->id, |
|
3, (unsigned_ptr) &obj->pos, |
|
}; |
|
NetCliSend(client, msgMoveObject, arrsize(msgMoveObject)); |
|
} |
|
|
|
static void SendPlayerJoin (NetCli client, const Player * player) { |
|
const unsigned_ptr msgPlayerJoin[] = { |
|
kMsgPlayerJoin, |
|
player->name, |
|
player->data, |
|
player->vault->Count(), |
|
player->vault->Ptr() |
|
}; |
|
NetCliSend(client, msgPlayerJoin, arrsize(msgPlayerJoin)); |
|
}; |
|
|
|
static void SendPing (NetCli player) { |
|
const unsigned_ptr msgPing[] = { |
|
kMsgPing, |
|
TimeGetMs(), |
|
}; |
|
NetCliSend(player, msgPing, arrsize(msgPing)); |
|
} |
|
|
|
|
|
6. Receive messages |
|
|
|
bool RecvMsgPing (const byte msg[], NetCli * from, void * param) { |
|
Player * player = (Player *) param; |
|
const Ping * ping = (const Ping *) msg; |
|
const unsigned_ptr msgPingReply[] = { |
|
kMsgPingReply, |
|
ping->pingTimeMs, |
|
}; |
|
MsgConnSend(from, msgPingReply, arrsize(msgPingReply)); |
|
} |
|
|
|
* |
|
***/ |
|
|
|
|
|
/***************************************************************************** |
|
* |
|
* Constants |
|
* |
|
***/ |
|
|
|
|
|
|
|
/***************************************************************************** |
|
* |
|
* Field definition types |
|
* |
|
***/ |
|
|
|
enum ENetMsgFieldType { |
|
// Compressable fields |
|
kNetMsgFieldInteger, |
|
kNetMsgFieldReal, |
|
kNetMsgFieldString, // variable length unicode string |
|
kNetMsgFieldData, // data with length <= sizeof(dword) |
|
kNetMsgFieldPtr, // pointer to fixed length data |
|
kNetMsgFieldVarPtr, // pointer to variable length data |
|
|
|
// Non-compressible fields (images, sounds, encrypted data, etc) |
|
kNetMsgFieldRawData, // data with length <= sizeof(dword) |
|
kNetMsgFieldRawPtr, // pointer to fixed length data |
|
kNetMsgFieldRawVarPtr, // pointer to variable length data |
|
|
|
kNetMsgFieldVarCount, // count for kNetMsgFieldVarPtr and kNetMsgFieldRawVarPtr |
|
|
|
kNumNetMsgFieldTypes |
|
}; |
|
|
|
|
|
struct NetMsgField { |
|
ENetMsgFieldType type; // element type |
|
unsigned count; // max number of elements |
|
unsigned size; // element size |
|
}; |
|
|
|
struct NetMsg { |
|
const char * name; |
|
unsigned messageId; |
|
const NetMsgField * fields; |
|
unsigned count; |
|
}; |
|
|
|
// Opaque types |
|
struct NetCli; |
|
struct NetCliQueue; |
|
|
|
|
|
/***************************************************************************** |
|
* |
|
* Msg and field definition macros |
|
* |
|
***/ |
|
|
|
#define NET_MSG(msgId, msgFields) { #msgId, msgId, msgFields, arrsize(msgFields) } |
|
|
|
#define NET_MSG_FIELD(type, count, size) { type, count, size } |
|
|
|
#define NET_MSG_FIELD_BYTE() NET_MSG_FIELD(kNetMsgFieldInteger, 0, sizeof(byte)) |
|
#define NET_MSG_FIELD_WORD() NET_MSG_FIELD(kNetMsgFieldInteger, 0, sizeof(word)) |
|
#define NET_MSG_FIELD_DWORD() NET_MSG_FIELD(kNetMsgFieldInteger, 0, sizeof(dword)) |
|
#define NET_MSG_FIELD_QWORD() NET_MSG_FIELD(kNetMsgFieldInteger, 0, sizeof(qword)) |
|
#define NET_MSG_FIELD_FLOAT() NET_MSG_FIELD(kNetMsgFieldReal, 0, sizeof(float)) |
|
#define NET_MSG_FIELD_DOUBLE() NET_MSG_FIELD(kNetMsgFieldReal, 0, sizeof(double)) |
|
|
|
#define NET_MSG_FIELD_BYTE_ARRAY(maxCount) NET_MSG_FIELD(kNetMsgFieldInteger, maxCount, sizeof(byte)) |
|
#define NET_MSG_FIELD_WORD_ARRAY(maxCount) NET_MSG_FIELD(kNetMsgFieldInteger, maxCount, sizeof(word)) |
|
#define NET_MSG_FIELD_DWORD_ARRAY(maxCount) NET_MSG_FIELD(kNetMsgFieldInteger, maxCount, sizeof(dword)) |
|
#define NET_MSG_FIELD_QWORD_ARRAY(maxCount) NET_MSG_FIELD(kNetMsgFieldInteger, maxCount, sizeof(qword)) |
|
#define NET_MSG_FIELD_FLOAT_ARRAY(maxCount) NET_MSG_FIELD(kNetMsgFieldReal, maxCount, sizeof(float)) |
|
#define NET_MSG_FIELD_DOUBLE_ARRAY(maxCount) NET_MSG_FIELD(kNetMsgFieldReal, maxCount, sizeof(double)) |
|
|
|
#define NET_MSG_FIELD_STRING(maxLength) NET_MSG_FIELD(kNetMsgFieldString, maxLength, sizeof(wchar)) |
|
|
|
#define NET_MSG_FIELD_DATA(maxBytes) NET_MSG_FIELD(kNetMsgFieldData, maxBytes, 1) |
|
#define NET_MSG_FIELD_PTR(maxBytes) NET_MSG_FIELD(kNetMsgFieldPtr, maxBytes, 1) |
|
#define NET_MSG_FIELD_RAW_DATA(maxBytes) NET_MSG_FIELD(kNetMsgFieldRawData, maxBytes, 1) |
|
#define NET_MSG_FIELD_RAW_PTR(maxBytes) NET_MSG_FIELD(kNetMsgFieldRawPtr, maxBytes, 1) |
|
|
|
#define NET_MSG_FIELD_VAR_PTR() NET_MSG_FIELD(kNetMsgFieldVarPtr, 0, 0) |
|
#define NET_MSG_FIELD_RAW_VAR_PTR() NET_MSG_FIELD(kNetMsgFieldRawVarPtr, 0, 0) |
|
|
|
#define NET_MSG_FIELD_VAR_COUNT(elemSize, maxCount) NET_MSG_FIELD(kNetMsgFieldVarCount, maxCount, elemSize) |
|
|
|
|
|
/***************************************************************************** |
|
* |
|
* Message channels |
|
* |
|
***/ |
|
|
|
struct NetMsgInitSend { |
|
NetMsg msg; |
|
}; |
|
struct NetMsgInitRecv { |
|
NetMsg msg; |
|
bool (* recv)(const byte msg[], unsigned bytes, void * param); |
|
}; |
|
|
|
void NetMsgProtocolRegister ( |
|
unsigned protocol, // from pnNetBase/pnNbProtocol.h |
|
bool server, |
|
const NetMsgInitSend sendMsgs[], // messages this program can send |
|
unsigned sendMsgCount, |
|
const NetMsgInitRecv recvMsgs[], // messages this program can receive |
|
unsigned recvMsgCount, |
|
// Diffie-Hellman keys |
|
unsigned dh_g, |
|
const BigNum & dh_xa, // client: dh_x server: dh_a |
|
const BigNum & dh_n |
|
); |
|
|
|
void NetMsgProtocolDestroy ( |
|
unsigned protocol, |
|
bool server |
|
); |
|
|
|
|
|
/***************************************************************************** |
|
* |
|
* NetCliQueue |
|
* |
|
***/ |
|
|
|
NetCliQueue * NetCliQueueCreate ( |
|
unsigned flushTimeMs |
|
); |
|
|
|
void NetCliQueueDestroy ( |
|
NetCliQueue * queue |
|
); |
|
|
|
void NetCliQueueFlush ( |
|
NetCliQueue * queue |
|
); |
|
|
|
float NetCliQueueQueryFlush ( |
|
NetCliQueue * queue |
|
); |
|
|
|
|
|
/***************************************************************************** |
|
* |
|
* NetCli |
|
* |
|
***/ |
|
|
|
typedef bool (* FNetCliEncrypt) ( |
|
ENetError error, |
|
void * encryptParam |
|
); |
|
|
|
NetCli * NetCliConnectAccept ( |
|
AsyncSocket sock, |
|
unsigned protocol, |
|
bool unbuffered, |
|
FNetCliEncrypt encryptFcn, |
|
unsigned seedBytes, // optional |
|
const byte seedData[], // optional |
|
void * encryptParam // optional |
|
); |
|
|
|
#ifdef SERVER |
|
NetCli * NetCliListenAccept ( |
|
AsyncSocket sock, |
|
unsigned protocol, |
|
bool unbuffered, |
|
FNetCliEncrypt encryptFcn, |
|
unsigned seedBytes, // optional |
|
const byte seedData[], // optional |
|
void * encryptParam // optional |
|
); |
|
#endif |
|
|
|
#ifdef SERVER |
|
void NetCliListenReject ( |
|
AsyncSocket sock, |
|
ENetError error |
|
); |
|
#endif |
|
|
|
void NetCliClearSocket ( |
|
NetCli * cli |
|
); |
|
|
|
void NetCliSetQueue ( |
|
NetCli * cli, |
|
NetCliQueue * queue |
|
); |
|
|
|
void NetCliDisconnect ( |
|
NetCli * cli, |
|
bool hardClose |
|
); |
|
|
|
void NetCliDelete ( |
|
NetCli * cli, |
|
bool deleteSocket |
|
); |
|
|
|
void NetCliFlush ( |
|
NetCli * cli |
|
); |
|
|
|
void NetCliSend ( |
|
NetCli * cli, |
|
const unsigned_ptr msg[], |
|
unsigned count |
|
); |
|
|
|
bool NetCliDispatch ( |
|
NetCli * cli, |
|
const byte buffer[], |
|
unsigned bytes, |
|
void * param |
|
); |
|
|
|
|
|
#endif // PLASMA20_SOURCES_PLASMA_NUCLEUSLIB_PNNETCLI_PNNETCLI_H
|
|
|