iikorni/quakespasm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Big net::msg conversion

Browse Source
This commit is contained in:
iikorni
2026-08-30 12:38:12 -05:00
parent 216dd1aecd
commit df2b863d72
36 changed files with 2860 additions and 2764 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Quake/net_dgrm.cpp
+201 -187
View File
@@ -121,7 +121,7 @@ static void NET_Ban_f(void) {
#endif // BAN_TEST
int Datagram_SendMessage(qsocket_t *sock, sizebuf_t *data) {
int Datagram_SendMessage(qsocket_t *sock, net::msg &msg) {
unsigned int packetLen;
unsigned int dataLen;
unsigned int eom;
@@ -137,11 +137,11 @@ int Datagram_SendMessage(qsocket_t *sock, sizebuf_t *data) {
Sys_Error("SendMessage: called with canSend == false");
#endif
std::memcpy(sock->sendMessage, data->data, data->cursize);
sock->sendMessageLength = data->cursize;
std::memcpy(sock->sendMessage, msg.data(), msg.size());
sock->sendMessageLength = msg.size();
if (data->cursize <= MAX_DATAGRAM) {
dataLen = data->cursize;
if (msg.size() <= MAX_DATAGRAM) {
dataLen = msg.size();
eom = NETFLAG_EOM;
} else {
dataLen = MAX_DATAGRAM;
@@ -235,7 +235,7 @@ bool Datagram_CanSendUnreliableMessage(qsocket_t *sock) {
}
int Datagram_SendUnreliableMessage(qsocket_t *sock, sizebuf_t *data) {
int Datagram_SendUnreliableMessage(qsocket_t *sock, net::msg &msg) {
int packetLen;
#ifdef DEBUG
@@ -246,11 +246,11 @@ int Datagram_SendUnreliableMessage(qsocket_t *sock, sizebuf_t *data) {
Sys_Error("Datagram_SendUnreliableMessage: message too big: %u", data->cursize);
#endif
packetLen = NET_HEADERSIZE + data->cursize;
packetLen = NET_HEADERSIZE + msg.size();
packetBuffer.length = BigLong(packetLen | NETFLAG_UNRELIABLE);
packetBuffer.sequence = BigLong(sock->unreliableSendSequence++);
std::memcpy(packetBuffer.data, data->data, data->cursize);
std::memcpy(packetBuffer.data, msg.data(), msg.size());
if (sfunc.Write(sock->socket, (byte *) &packetBuffer, packetLen, &sock->addr) == -1)
return -1;
@@ -324,8 +324,8 @@ int Datagram_GetMessage(qsocket_t *sock) {
length -= NET_HEADERSIZE;
SZ_Clear(&net_message);
SZ_Write(&net_message, packetBuffer.data, length);
net_message.clear();
net_message.write(packetBuffer.data, length);
ret = 2;
break;
@@ -369,9 +369,9 @@ int Datagram_GetMessage(qsocket_t *sock) {
length -= NET_HEADERSIZE;
if (flags & NETFLAG_EOM) {
SZ_Clear(&net_message);
SZ_Write(&net_message, sock->receiveMessage, sock->receiveMessageLength);
SZ_Write(&net_message, packetBuffer.data, length);
net_message.clear();
net_message.write(sock->receiveMessage, sock->receiveMessageLength);
net_message.write(packetBuffer.data, length);
sock->receiveMessageLength = 0;
ret = 1;
@@ -482,15 +482,19 @@ static void Test_Poll(void *unused) {
net_landriverlevel = testDriver;
while (1) {
len = dfunc.Read(testSocket, net_message.data, net_message.maxsize, &clientaddr);
if (len < (int) sizeof(int))
const auto buf = new std::uint8_t[MAX_DATAGRAM];
len = dfunc.Read(testSocket, &buf[0], MAX_DATAGRAM, &clientaddr);
if (len < (int) sizeof(int)) {
delete []buf;
break;
}
net_message.write(buf, len);
delete []buf;
net_message.cursize = len;
MSG_BeginReading();
control = BigLong(*((int *) net_message.data));
MSG_ReadLong();
net_message.begin_reading();
control = BigLong(*((int *) net_message.data()));
net_message.read_long();
if (control == -1)
break;
if ((control & (~NETFLAG_LENGTH_MASK)) != (int) NETFLAG_CTL)
@@ -498,18 +502,18 @@ static void Test_Poll(void *unused) {
if ((control & NETFLAG_LENGTH_MASK) != len)
break;
if (MSG_ReadByte() != CCREP_PLAYER_INFO)
if (net_message.read_byte().value() != CCREP_PLAYER_INFO)
Sys_Error("Unexpected response to Player Info request\n");
MSG_ReadByte(); /* playerNumber */
std::strcpy(name, MSG_ReadString());
colors = MSG_ReadLong();
frags = MSG_ReadLong();
connectTime = MSG_ReadLong();
std::strcpy(address, MSG_ReadString());
net_message.read_byte().value(); /* playerNumber */
std::strcpy(name, net_message.read_string().value().c_str());
colors = net_message.read_long().value();
frags = net_message.read_long().value();
connectTime = net_message.read_long().value();
std::strcpy(address, net_message.read_string().value().c_str());
console::info("%s\n frags:%3i colors:%d %d time:%d\n %s\n", name, frags, colors >> 4, colors & 0x0f,
connectTime / 60, address);
connectTime / 60, address);
}
testPollCount--;
@@ -572,15 +576,15 @@ JustDoIt:
testDriver = net_landriverlevel;
for (n = 0; n < maxusers; n++) {
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREQ_PLAYER_INFO);
MSG_WriteByte(&net_message, n);
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(testSocket, net_message.data, net_message.cursize, &sendaddr);
net_message.write_long(0);
net_message.write_byte(CCREQ_PLAYER_INFO);
net_message.write_byte(n);
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(testSocket, net_message.data(), net_message.size(), &sendaddr);
}
SZ_Clear(&net_message);
net_message.clear();
SchedulePollProcedure(&testPollProcedure, 0.1);
}
@@ -603,15 +607,19 @@ static void Test2_Poll(void *unused) {
net_landriverlevel = test2Driver;
name[0] = 0;
len = dfunc.Read(test2Socket, net_message.data, net_message.maxsize, &clientaddr);
if (len < (int) sizeof(int))
auto buf = new std::uint8_t[MAX_DATAGRAM];
len = dfunc.Read(test2Socket, &buf[0], MAX_DATAGRAM, &clientaddr);
if (len < (int) sizeof(int)) {
delete []buf;
goto Reschedule;
}
net_message.write(buf, len);
delete []buf;
net_message.cursize = len;
MSG_BeginReading();
control = BigLong(*((int *) net_message.data));
MSG_ReadLong();
net_message.begin_reading();
control = BigLong(*((int *) net_message.data()));
net_message.read_long();
if (control == -1)
goto Error;
if ((control & (~NETFLAG_LENGTH_MASK)) != (int) NETFLAG_CTL)
@@ -619,24 +627,24 @@ static void Test2_Poll(void *unused) {
if ((control & NETFLAG_LENGTH_MASK) != len)
goto Error;
if (MSG_ReadByte() != CCREP_RULE_INFO)
if (net_message.read_byte().value() != CCREP_RULE_INFO)
goto Error;
std::strcpy(name, MSG_ReadString());
std::strcpy(name, net_message.read_string().value().c_str());
if (name[0] == 0)
goto Done;
std::strcpy(value, MSG_ReadString());
std::strcpy(value, net_message.read_string().value().c_str());
console::info("%-16.16s %-16.16s\n", name, value);
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREQ_RULE_INFO);
MSG_WriteString(&net_message, name);
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(test2Socket, net_message.data, net_message.cursize, &clientaddr);
SZ_Clear(&net_message);
net_message.write_long(0);
net_message.write_byte(CCREQ_RULE_INFO);
net_message.write_string(name);
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(test2Socket, net_message.data(), net_message.size(), &clientaddr);
net_message.clear();
Reschedule:
SchedulePollProcedure(&test2PollProcedure, 0.05);
@@ -697,14 +705,14 @@ JustDoIt:
test2InProgress = true;
test2Driver = net_landriverlevel;
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREQ_RULE_INFO);
MSG_WriteString(&net_message, "");
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(test2Socket, net_message.data, net_message.cursize, &sendaddr);
SZ_Clear(&net_message);
net_message.write_long(0);
net_message.write_byte(CCREQ_RULE_INFO);
net_message.write_string("");
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(test2Socket, net_message.data(), net_message.size(), &sendaddr);
net_message.clear();
SchedulePollProcedure(&test2PollProcedure, 0.05);
}
@@ -793,16 +801,20 @@ static qsocket_t *_Datagram_CheckNewConnections(void) {
if (acceptsock == INVALID_SOCKET)
return NULL;
SZ_Clear(&net_message);
net_message.clear();
len = dfunc.Read(acceptsock, net_message.data, net_message.maxsize, &clientaddr);
if (len < (int) sizeof(int))
return NULL;
net_message.cursize = len;
auto buf = new byte[MAX_DATAGRAM];
len = dfunc.Read(acceptsock, &buf[0], MAX_DATAGRAM, &clientaddr);
if (len < (int) sizeof(int)) {
delete []buf;
return nullptr;
}
net_message.write(buf, len);
delete []buf;
MSG_BeginReading();
control = BigLong(*((int *) net_message.data));
MSG_ReadLong();
net_message.begin_reading();
control = BigLong(*((int *) net_message.data()));
net_message.read_long();
if (control == -1)
return NULL;
if ((control & (~NETFLAG_LENGTH_MASK)) != (int) NETFLAG_CTL)
@@ -810,25 +822,25 @@ static qsocket_t *_Datagram_CheckNewConnections(void) {
if ((control & NETFLAG_LENGTH_MASK) != len)
return NULL;
command = MSG_ReadByte();
command = net_message.read_byte().value();
if (command == CCREQ_SERVER_INFO) {
if (std::strcmp(MSG_ReadString(), "QUAKE") != 0)
if (std::strcmp(net_message.read_string().value().c_str(), "QUAKE") != 0)
return NULL;
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREP_SERVER_INFO);
net_message.write_long(0);
net_message.write_byte(CCREP_SERVER_INFO);
dfunc.GetSocketAddr(acceptsock, &newaddr);
MSG_WriteString(&net_message, dfunc.AddrToString(&newaddr));
MSG_WriteString(&net_message, hostname.string);
MSG_WriteString(&net_message, sv.name);
MSG_WriteByte(&net_message, net_activeconnections);
MSG_WriteByte(&net_message, svs.maxclients);
MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
SZ_Clear(&net_message);
net_message.write_string(dfunc.AddrToString(&newaddr));
net_message.write_string(hostname.string);
net_message.write_string(sv.name);
net_message.write_byte(net_activeconnections);
net_message.write_byte(svs.maxclients);
net_message.write_byte(NET_PROTOCOL_VERSION);
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data(), net_message.size(), &clientaddr);
net_message.clear();
return NULL;
}
@@ -838,7 +850,7 @@ static qsocket_t *_Datagram_CheckNewConnections(void) {
int clientNumber;
client_t *client;
playerNumber = MSG_ReadByte();
playerNumber = net_message.read_byte().value();
activeNumber = -1;
for (clientNumber = 0, client = svs.clients; clientNumber < svs.maxclients; clientNumber++, client++) {
@@ -852,42 +864,40 @@ static qsocket_t *_Datagram_CheckNewConnections(void) {
if (clientNumber == svs.maxclients)
return NULL;
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREP_PLAYER_INFO);
MSG_WriteByte(&net_message, playerNumber);
MSG_WriteString(&net_message, client->name);
MSG_WriteLong(&net_message, client->colors);
MSG_WriteLong(&net_message, (int) client->edict->v.frags);
MSG_WriteLong(&net_message, (int) (net_time - client->netconnection->connecttime));
MSG_WriteString(&net_message, client->netconnection->address);
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
SZ_Clear(&net_message);
net_message.write_long(0);
net_message.write_byte(CCREP_PLAYER_INFO);
net_message.write_byte(playerNumber);
net_message.write_string(client->name);
net_message.write_long(client->colors);
net_message.write_long((int) client->edict->v.frags);
net_message.write_long((int) (net_time - client->netconnection->connecttime));
net_message.write_string(client->netconnection->address);
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data(), net_message.size(), &clientaddr);
net_message.clear();
return NULL;
}
if (command == CCREQ_RULE_INFO) {
const char *prevCvarName;
// find the search start location
prevCvarName = MSG_ReadString();
auto prevCvarName = net_message.read_string().value();
auto var = convar::find_var_after(prevCvarName, std::nullopt);
// send the response
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREP_RULE_INFO);
net_message.write_long(0);
net_message.write_byte(CCREP_RULE_INFO);
if (var) {
MSG_WriteString(&net_message, var.value()->name.c_str());
MSG_WriteString(&net_message, var.value()->string);
net_message.write_string(var.value()->name.c_str());
net_message.write_string(var.value()->string);
}
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
SZ_Clear(&net_message);
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data(), net_message.size(), &clientaddr);
net_message.clear();
return NULL;
}
@@ -895,18 +905,18 @@ static qsocket_t *_Datagram_CheckNewConnections(void) {
if (command != CCREQ_CONNECT)
return NULL;
if (std::strcmp(MSG_ReadString(), "QUAKE") != 0)
if (std::strcmp(net_message.read_string().value().c_str(), "QUAKE") != 0)
return NULL;
if (MSG_ReadByte() != NET_PROTOCOL_VERSION) {
SZ_Clear(&net_message);
if (net_message.read_byte().value() != NET_PROTOCOL_VERSION) {
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREP_REJECT);
MSG_WriteString(&net_message, "Incompatible version.\n");
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
SZ_Clear(&net_message);
net_message.write_long(0);
net_message.write_byte(CCREP_REJECT);
net_message.write_string("Incompatible version.\n");
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data(), net_message.size(), &clientaddr);
net_message.clear();
return NULL;
}
@@ -916,14 +926,14 @@ static qsocket_t *_Datagram_CheckNewConnections(void) {
in_addr_t testAddr;
testAddr = ((struct sockaddr_in *) &clientaddr)->sin_addr.s_addr;
if ((testAddr & banMask.s_addr) == banAddr.s_addr) {
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREP_REJECT);
MSG_WriteString(&net_message, "You have been banned.\n");
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
SZ_Clear(&net_message);
net_message.write_long(0);
net_message.write_byte(CCREP_REJECT);
net_message.write_string("You have been banned.\n");
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data(), net_message.size(), &clientaddr);
net_message.clear();
return NULL;
}
}
@@ -938,15 +948,15 @@ static qsocket_t *_Datagram_CheckNewConnections(void) {
// is this a duplicate connection reqeust?
if (ret == 0 && net_time - s->connecttime < 2.0) {
// yes, so send a duplicate reply
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREP_ACCEPT);
net_message.write_long(0);
net_message.write_byte(CCREP_ACCEPT);
dfunc.GetSocketAddr(s->socket, &newaddr);
MSG_WriteLong(&net_message, dfunc.GetSocketPort(&newaddr));
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
SZ_Clear(&net_message);
net_message.write_long(dfunc.GetSocketPort(&newaddr));
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data(), net_message.size(), &clientaddr);
net_message.clear();
return NULL;
}
// it's somebody coming back in from a crash/disconnect
@@ -960,14 +970,14 @@ static qsocket_t *_Datagram_CheckNewConnections(void) {
sock = NET_NewQSocket();
if (sock == NULL) // no room; try to let him know
{
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREP_REJECT);
MSG_WriteString(&net_message, "Server is full.\n");
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
SZ_Clear(&net_message);
net_message.write_long(0);
net_message.write_byte(CCREP_REJECT);
net_message.write_string("Server is full.\n");
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data(), net_message.size(), &clientaddr);
net_message.clear();
return NULL;
}
@@ -992,16 +1002,16 @@ static qsocket_t *_Datagram_CheckNewConnections(void) {
std::strcpy(sock->address, dfunc.AddrToString(&clientaddr));
// send him back the info about the server connection he has been allocated
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREP_ACCEPT);
net_message.write_long(0);
net_message.write_byte(CCREP_ACCEPT);
dfunc.GetSocketAddr(newsock, &newaddr);
MSG_WriteLong(&net_message, dfunc.GetSocketPort(&newaddr));
net_message.write_long(dfunc.GetSocketPort(&newaddr));
// MSG_WriteString(&net_message, dfunc.AddrToString(&newaddr));
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data, net_message.cursize, &clientaddr);
SZ_Clear(&net_message);
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(acceptsock, net_message.data(), net_message.size(), &clientaddr);
net_message.clear();
return sock;
}
@@ -1029,21 +1039,22 @@ static void _Datagram_SearchForHosts(bool xmit) {
dfunc.GetSocketAddr(dfunc.controlSock, &myaddr);
if (xmit) {
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREQ_SERVER_INFO);
MSG_WriteString(&net_message, "QUAKE");
MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Broadcast(dfunc.controlSock, net_message.data, net_message.cursize);
SZ_Clear(&net_message);
net_message.write_long(0);
net_message.write_byte(CCREQ_SERVER_INFO);
net_message.write_string("QUAKE");
net_message.write_byte(NET_PROTOCOL_VERSION);
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Broadcast(dfunc.controlSock, net_message.data(), net_message.size());
net_message.clear();
}
while ((ret = dfunc.Read(dfunc.controlSock, net_message.data, net_message.maxsize, &readaddr)) > 0) {
auto buf = new std::uint8_t[MAX_DATAGRAM];
while ((ret = dfunc.Read(dfunc.controlSock, &buf[0], MAX_DATAGRAM, &readaddr)) > 0) {
if (ret < (int) sizeof(int))
continue;
net_message.cursize = ret;
net_message.write(buf, ret);
// don't answer our own query
if (dfunc.AddrCompare(&readaddr, &myaddr) >= 0)
@@ -1053,9 +1064,9 @@ static void _Datagram_SearchForHosts(bool xmit) {
if (hostCacheCount == HOSTCACHESIZE)
continue;
MSG_BeginReading();
control = BigLong(*((int *) net_message.data));
MSG_ReadLong();
net_message.begin_reading();
control = BigLong(*((int *) net_message.data()));
net_message.read_long();
if (control == -1)
continue;
if ((control & (~NETFLAG_LENGTH_MASK)) != (int) NETFLAG_CTL)
@@ -1063,10 +1074,10 @@ static void _Datagram_SearchForHosts(bool xmit) {
if ((control & NETFLAG_LENGTH_MASK) != ret)
continue;
if (MSG_ReadByte() != CCREP_SERVER_INFO)
if (net_message.read_byte().value() != CCREP_SERVER_INFO)
continue;
dfunc.GetAddrFromName(MSG_ReadString(), &readaddr);
dfunc.GetAddrFromName(net_message.read_string().value().c_str(), &readaddr);
// search the cache for this server
for (n = 0; n < hostCacheCount; n++) {
if (dfunc.AddrCompare(&readaddr, &hostcache[n].addr) == 0)
@@ -1079,11 +1090,11 @@ static void _Datagram_SearchForHosts(bool xmit) {
// add it
hostCacheCount++;
std::strcpy(hostcache[n].name, MSG_ReadString());
std::strcpy(hostcache[n].map, MSG_ReadString());
hostcache[n].users = MSG_ReadByte();
hostcache[n].maxusers = MSG_ReadByte();
if (MSG_ReadByte() != NET_PROTOCOL_VERSION) {
std::strcpy(hostcache[n].name, net_message.read_string().value().c_str());
std::strcpy(hostcache[n].map, net_message.read_string().value().c_str());
hostcache[n].users = net_message.read_byte().value();
hostcache[n].maxusers = net_message.read_byte().value();
if (net_message.read_byte().value() != NET_PROTOCOL_VERSION) {
std::strcpy(hostcache[n].cname, hostcache[n].name);
hostcache[n].cname[14] = 0;
std::strcpy(hostcache[n].name, "*");
@@ -1110,6 +1121,7 @@ static void _Datagram_SearchForHosts(bool xmit) {
}
}
}
delete []buf;
}
void Datagram_SearchForHosts(bool xmit) {
@@ -1131,7 +1143,7 @@ static qsocket_t *_Datagram_Connect(const char *host) {
int reps;
double start_time;
int control;
const char *reason;
std::string reason;
// see if we can resolve the host name
if (dfunc.GetAddrFromName(host, &sendaddr) == -1) {
@@ -1159,17 +1171,18 @@ static qsocket_t *_Datagram_Connect(const char *host) {
start_time = net_time;
for (reps = 0; reps < 3; reps++) {
SZ_Clear(&net_message);
net_message.clear();
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREQ_CONNECT);
MSG_WriteString(&net_message, "QUAKE");
MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
*((int *) net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write(newsock, net_message.data, net_message.cursize, &sendaddr);
SZ_Clear(&net_message);
net_message.write_long(0);
net_message.write_byte(CCREQ_CONNECT);
net_message.write_string("QUAKE");
net_message.write_byte(NET_PROTOCOL_VERSION);
*((int *) net_message.data()) = BigLong(NETFLAG_CTL | (net_message.size() & NETFLAG_LENGTH_MASK));
dfunc.Write(newsock, net_message.data(), net_message.size(), &sendaddr);
net_message.clear();
auto buf = new std::uint8_t[MAX_DATAGRAM];
do {
ret = dfunc.Read(newsock, net_message.data, net_message.maxsize, &readaddr);
ret = dfunc.Read(newsock, &buf[0], MAX_DATAGRAM, &readaddr);
// if we got something, validate it
if (ret > 0) {
// is it from the right place?
@@ -1187,11 +1200,11 @@ static qsocket_t *_Datagram_Connect(const char *host) {
continue;
}
net_message.cursize = ret;
MSG_BeginReading();
net_message.write(buf, ret);
net_message.begin_reading();
control = BigLong(*((int *) net_message.data));
MSG_ReadLong();
control = BigLong(*((int *) net_message.data()));
net_message.read_long();
if (control == -1) {
ret = 0;
continue;
@@ -1206,6 +1219,7 @@ static qsocket_t *_Datagram_Connect(const char *host) {
}
}
} while (ret == 0 && (SetNetTime() - start_time) < 2.5);
delete []buf;
if (ret)
break;
@@ -1217,33 +1231,33 @@ static qsocket_t *_Datagram_Connect(const char *host) {
if (ret == 0) {
reason = "No Response";
console::info("%s\n", reason);
std::strcpy(m_return_reason, reason);
console::info("%s\n", reason.c_str());
std::strcpy(m_return_reason, reason.c_str());
goto ErrorReturn;
}
if (ret == -1) {
reason = "Network Error";
console::info("%s\n", reason);
std::strcpy(m_return_reason, reason);
console::info("%s\n", reason.c_str());
std::strcpy(m_return_reason, reason.c_str());
goto ErrorReturn;
}
ret = MSG_ReadByte();
ret = net_message.read_byte().value();
if (ret == CCREP_REJECT) {
reason = MSG_ReadString();
console::info("%s\n", reason);
q_strlcpy(m_return_reason, reason, sizeof(m_return_reason));
reason = net_message.read_string().value();
console::info("%s\n", reason.c_str());
q_strlcpy(m_return_reason, reason.c_str(), sizeof(m_return_reason));
goto ErrorReturn;
}
if (ret == CCREP_ACCEPT) {
std::memcpy(&sock->addr, &sendaddr, sizeof(struct qsockaddr));
dfunc.SetSocketPort(&sock->addr, MSG_ReadLong());
dfunc.SetSocketPort(&sock->addr, net_message.read_long().value());
} else {
reason = "Bad Response";
console::info("%s\n", reason);
std::strcpy(m_return_reason, reason);
console::info("%s\n", reason.c_str());
std::strcpy(m_return_reason, reason.c_str());
goto ErrorReturn;
}
@@ -1255,8 +1269,8 @@ static qsocket_t *_Datagram_Connect(const char *host) {
// switch the connection to the specified address
if (dfunc.Connect(newsock, &sock->addr) == -1) {
reason = "Connect to Game failed";
console::info("%s\n", reason);
std::strcpy(m_return_reason, reason);
console::info("%s\n", reason.c_str());
std::strcpy(m_return_reason, reason.c_str());
goto ErrorReturn;
}