Skip to content
Permalink
Browse files
(svn r19607) -Codechange: use different packet types instead of packe…
…t subtypes
  • Loading branch information
smatz committed Apr 11, 2010
1 parent d2dc3a2 commit 11d6e21c3ac658b065b64c5c9d0f43c45d7966db
Show file tree
Hide file tree
Showing 5 changed files with 121 additions and 70 deletions.
@@ -35,8 +35,10 @@ enum {
PACKET_CLIENT_COMPANY_INFO,
PACKET_SERVER_COMPANY_INFO,
PACKET_SERVER_CLIENT_INFO,
PACKET_SERVER_NEED_PASSWORD,
PACKET_CLIENT_PASSWORD,
PACKET_SERVER_NEED_GAME_PASSWORD,
PACKET_SERVER_NEED_COMPANY_PASSWORD,
PACKET_CLIENT_GAME_PASSWORD,
PACKET_CLIENT_COMPANY_PASSWORD,
PACKET_SERVER_WELCOME,
PACKET_CLIENT_GETMAP,
PACKET_SERVER_WAIT,
@@ -75,7 +77,8 @@ struct CommandPacket;
/** Status of a client */
enum ClientStatus {
STATUS_INACTIVE, ///< The client is not connected nor active
STATUS_AUTHORIZING,///< The client is authorizing
STATUS_AUTH_GAME, ///< The client is authorizing with game (server) password
STATUS_AUTH_COMPANY, ///< The client is authorizing with company password
STATUS_AUTH, ///< The client is authorized
STATUS_MAP_WAIT, ///< The client is waiting as someone else is downloading the map
STATUS_MAP, ///< The client is downloading the map
@@ -167,18 +167,32 @@ DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_NEWGRFS_CHECKED)
return NETWORK_RECV_STATUS_OKAY;
}

DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_PASSWORD)(NetworkPasswordType type, const char *password)
DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_GAME_PASSWORD)(const char *password)
{
/*
* Packet: CLIENT_PASSWORD
* Packet: CLIENT_GAME_PASSWORD
* Function: Send a password to the server to authorize
* Data:
* uint8: NetworkPasswordType
* String: Password
*/
Packet *p = new Packet(PACKET_CLIENT_PASSWORD);
p->Send_uint8 (type);
p->Send_string(type == NETWORK_GAME_PASSWORD ? password : GenerateCompanyPasswordHash(password));
Packet *p = new Packet(PACKET_CLIENT_GAME_PASSWORD);
p->Send_string(password);
MY_CLIENT->Send_Packet(p);
return NETWORK_RECV_STATUS_OKAY;
}

DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_COMPANY_PASSWORD)(const char *password)
{
/*
* Packet: CLIENT_COMPANY_PASSWORD
* Function: Send a password to the server to authorize
* Data:
* uint8: NetworkPasswordType
* String: Password
*/
Packet *p = new Packet(PACKET_CLIENT_COMPANY_PASSWORD);
p->Send_string(GenerateCompanyPasswordHash(password));
MY_CLIENT->Send_Packet(p);
return NETWORK_RECV_STATUS_OKAY;
}
@@ -535,30 +549,32 @@ DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_CHECK_NEWGRFS)
return ret;
}

DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_NEED_PASSWORD)
DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_NEED_GAME_PASSWORD)
{
NetworkPasswordType type = (NetworkPasswordType)p->Recv_uint8();

const char *password = _network_join_server_password;
if (!StrEmpty(password)) {
return SEND_COMMAND(PACKET_CLIENT_GAME_PASSWORD)(password);
}

switch (type) {
case NETWORK_COMPANY_PASSWORD:
/* Initialize the password hash salting variables. */
_password_game_seed = p->Recv_uint32();
p->Recv_string(_password_server_id, sizeof(_password_server_id));
if (MY_CLIENT->HasClientQuit()) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
password = _network_join_company_password;
/* FALL THROUGH */
case NETWORK_GAME_PASSWORD:
if (StrEmpty(password)) {
ShowNetworkNeedPassword(type);
} else {
return SEND_COMMAND(PACKET_CLIENT_PASSWORD)(type, password);
}
return NETWORK_RECV_STATUS_OKAY;
ShowNetworkNeedPassword(NETWORK_GAME_PASSWORD);

default: return NETWORK_RECV_STATUS_MALFORMED_PACKET;
return NETWORK_RECV_STATUS_OKAY;
}

DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_NEED_COMPANY_PASSWORD)
{
_password_game_seed = p->Recv_uint32();
p->Recv_string(_password_server_id, sizeof(_password_server_id));
if (MY_CLIENT->HasClientQuit()) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

const char *password = _network_join_company_password;
if (!StrEmpty(password)) {
return SEND_COMMAND(PACKET_CLIENT_COMPANY_PASSWORD)(password);
}

ShowNetworkNeedPassword(NETWORK_COMPANY_PASSWORD);

return NETWORK_RECV_STATUS_OKAY;
}

DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_WELCOME)
@@ -921,8 +937,10 @@ static NetworkClientPacket * const _network_client_packet[] = {
NULL, // PACKET_CLIENT_COMPANY_INFO,
RECEIVE_COMMAND(PACKET_SERVER_COMPANY_INFO),
RECEIVE_COMMAND(PACKET_SERVER_CLIENT_INFO),
RECEIVE_COMMAND(PACKET_SERVER_NEED_PASSWORD),
NULL, // PACKET_CLIENT_PASSWORD,
RECEIVE_COMMAND(PACKET_SERVER_NEED_GAME_PASSWORD),
RECEIVE_COMMAND(PACKET_SERVER_NEED_COMPANY_PASSWORD),
NULL, // PACKET_CLIENT_GAME_PASSWORD,
NULL, // PACKET_CLIENT_COMPANY_PASSWORD,
RECEIVE_COMMAND(PACKET_SERVER_WELCOME),
NULL, // PACKET_CLIENT_GETMAP,
RECEIVE_COMMAND(PACKET_SERVER_WAIT),
@@ -22,7 +22,8 @@ DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_COMMAND)(const CommandPacket *cp);
DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_ERROR)(NetworkErrorCode errorno);
DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_QUIT)();
DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_CHAT)(NetworkAction action, DestType desttype, int dest, const char *msg, int64 data);
DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_PASSWORD)(NetworkPasswordType type, const char *password);
DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_GAME_PASSWORD)(const char *password);
DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_COMPANY_PASSWORD)(const char *password);
DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_SET_PASSWORD)(const char *password);
DEF_CLIENT_SEND_COMMAND_PARAM(PACKET_CLIENT_SET_NAME)(const char *name);
DEF_CLIENT_SEND_COMMAND(PACKET_CLIENT_ACK);
@@ -2210,8 +2210,13 @@ struct NetworkJoinStatusWindow : Window {
if (StrEmpty(str)) {
NetworkDisconnect();
ShowNetworkGameWindow();
} else {
SEND_COMMAND(PACKET_CLIENT_PASSWORD)(this->password_type, str);
return;
}

switch (this->password_type) {
case NETWORK_GAME_PASSWORD: SEND_COMMAND(PACKET_CLIENT_GAME_PASSWORD) (str); break;
case NETWORK_COMPANY_PASSWORD: SEND_COMMAND(PACKET_CLIENT_COMPANY_PASSWORD)(str); break;
default: NOT_REACHED();
}
}
};
@@ -209,22 +209,39 @@ DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_CHECK_NEWGRFS)(NetworkClientSocket *
return NETWORK_RECV_STATUS_OKAY;
}

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_NEED_PASSWORD)(NetworkClientSocket *cs, NetworkPasswordType type)
DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_NEED_GAME_PASSWORD)(NetworkClientSocket *cs)
{
/*
* Packet: SERVER_NEED_PASSWORD
* Function: Indication to the client that the server needs a password
* Packet: PACKET_SERVER_NEED_GAME_PASSWORD
* Function: Indication to the client that the server needs a game password
*/

/* Invalid packet when status is STATUS_AUTH_GAME or higher */
if (cs->status >= STATUS_AUTH_GAME) return NetworkCloseClient(cs, NETWORK_RECV_STATUS_MALFORMED_PACKET);

cs->status = STATUS_AUTH_GAME;

Packet *p = new Packet(PACKET_SERVER_NEED_GAME_PASSWORD);
cs->Send_Packet(p);
return NETWORK_RECV_STATUS_OKAY;
}

DEF_SERVER_SEND_COMMAND_PARAM(PACKET_SERVER_NEED_COMPANY_PASSWORD)(NetworkClientSocket *cs)
{
/*
* Packet: PACKET_SERVER_NEED_COMPANY_PASSWORD
* Function: Indication to the client that the server needs a company password
* Data:
* uint8: Type of password
* uint32: Generation seed
* string: Network ID of the server
*/

/* Invalid packet when status is AUTH or higher */
if (cs->status >= STATUS_AUTH) return NetworkCloseClient(cs, NETWORK_RECV_STATUS_MALFORMED_PACKET);
/* Invalid packet when status is STATUS_AUTH_COMPANY or higher */
if (cs->status >= STATUS_AUTH_COMPANY) return NetworkCloseClient(cs, NETWORK_RECV_STATUS_MALFORMED_PACKET);

cs->status = STATUS_AUTHORIZING;
cs->status = STATUS_AUTH_COMPANY;

Packet *p = new Packet(PACKET_SERVER_NEED_PASSWORD);
p->Send_uint8(type);
Packet *p = new Packet(PACKET_SERVER_NEED_COMPANY_PASSWORD);
p->Send_uint32(_settings_game.game_creation.generation_seed);
p->Send_string(_settings_client.network.network_id);
cs->Send_Packet(p);
@@ -647,11 +664,11 @@ DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_NEWGRFS_CHECKED)

/* We now want a password from the client else we do not allow him in! */
if (!StrEmpty(_settings_client.network.server_password)) {
return SEND_COMMAND(PACKET_SERVER_NEED_PASSWORD)(cs, NETWORK_GAME_PASSWORD);
return SEND_COMMAND(PACKET_SERVER_NEED_GAME_PASSWORD)(cs);
}

if (Company::IsValidID(ci->client_playas) && !StrEmpty(_network_company_states[ci->client_playas].password)) {
return SEND_COMMAND(PACKET_SERVER_NEED_PASSWORD)(cs, NETWORK_COMPANY_PASSWORD);
return SEND_COMMAND(PACKET_SERVER_NEED_COMPANY_PASSWORD)(cs);
}

return SEND_COMMAND(PACKET_SERVER_WELCOME)(cs);
@@ -728,42 +745,47 @@ DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_JOIN)
return SEND_COMMAND(PACKET_SERVER_CHECK_NEWGRFS)(cs);
}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_PASSWORD)
DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_GAME_PASSWORD)
{
NetworkPasswordType type;
char password[NETWORK_PASSWORD_LENGTH];
const NetworkClientInfo *ci;
if (cs->status != STATUS_AUTH_GAME) {
return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);
}

type = (NetworkPasswordType)p->Recv_uint8();
char password[NETWORK_PASSWORD_LENGTH];
p->Recv_string(password, sizeof(password));

if (cs->status == STATUS_AUTHORIZING && type == NETWORK_GAME_PASSWORD) {
/* Check game-password */
if (strcmp(password, _settings_client.network.server_password) != 0) {
/* Password is invalid */
return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_WRONG_PASSWORD);
}
/* Check game password */
if (strcmp(password, _settings_client.network.server_password) != 0) {
/* Password is invalid */
return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_WRONG_PASSWORD);
}

ci = cs->GetInfo();
const NetworkClientInfo *ci = cs->GetInfo();
if (Company::IsValidID(ci->client_playas) && !StrEmpty(_network_company_states[ci->client_playas].password)) {
return SEND_COMMAND(PACKET_SERVER_NEED_COMPANY_PASSWORD)(cs);
}

if (Company::IsValidID(ci->client_playas) && !StrEmpty(_network_company_states[ci->client_playas].password)) {
return SEND_COMMAND(PACKET_SERVER_NEED_PASSWORD)(cs, NETWORK_COMPANY_PASSWORD);
}
/* Valid password, allow user */
return SEND_COMMAND(PACKET_SERVER_WELCOME)(cs);
}

/* Valid password, allow user */
return SEND_COMMAND(PACKET_SERVER_WELCOME)(cs);
} else if (cs->status == STATUS_AUTHORIZING && type == NETWORK_COMPANY_PASSWORD) {
ci = cs->GetInfo();
DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_PASSWORD)
{
if (cs->status != STATUS_AUTH_COMPANY) {
return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);
}

if (strcmp(password, _network_company_states[ci->client_playas].password) != 0) {
/* Password is invalid */
return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_WRONG_PASSWORD);
}
char password[NETWORK_PASSWORD_LENGTH];
p->Recv_string(password, sizeof(password));

return SEND_COMMAND(PACKET_SERVER_WELCOME)(cs);
/* Check company password */
const NetworkClientInfo *ci = cs->GetInfo();
if (strcmp(password, _network_company_states[ci->client_playas].password) != 0) {
/* Password is invalid */
return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_WRONG_PASSWORD);
}

return SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_NOT_EXPECTED);
return SEND_COMMAND(PACKET_SERVER_WELCOME)(cs);
}

DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_GETMAP)
@@ -1271,8 +1293,10 @@ static NetworkServerPacket * const _network_server_packet[] = {
RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_INFO),
NULL, // PACKET_SERVER_COMPANY_INFO,
NULL, // PACKET_SERVER_CLIENT_INFO,
NULL, // PACKET_SERVER_NEED_PASSWORD,
RECEIVE_COMMAND(PACKET_CLIENT_PASSWORD),
NULL, // PACKET_SERVER_NEED_GAME_PASSWORD,
NULL, // PACKET_SERVER_NEED_COMPANY_PASSWORD,
RECEIVE_COMMAND(PACKET_CLIENT_GAME_PASSWORD),
RECEIVE_COMMAND(PACKET_CLIENT_COMPANY_PASSWORD),
NULL, // PACKET_SERVER_WELCOME,
RECEIVE_COMMAND(PACKET_CLIENT_GETMAP),
NULL, // PACKET_SERVER_WAIT,

0 comments on commit 11d6e21

Please sign in to comment.