/*
* @brief Sends an out-of-band datagram
*/
void Netchan_OutOfBand(int32_t sock, const net_addr_t *addr, const void *data, size_t len) {
mem_buf_t send;
byte send_buffer[MAX_MSG_SIZE];
// write the packet header
Mem_InitBuffer(&send, send_buffer, sizeof(send_buffer));
Net_WriteLong(&send, -1); // -1 sequence means out of band
Mem_WriteBuffer(&send, data, len);
// send the datagram
Net_SendDatagram(sock, addr, send.data, send.size);
}
/*
* @brief Send the rest of the command line over as an unconnected command.
*/
static void Cl_Rcon_f(void) {
char message[1024];
int32_t i;
net_addr_t to;
if (!rcon_password->string) {
Com_Print("No rcon_password set\n");
return;
}
memset(&to, 0, sizeof(to));
message[0] = (char) 255;
message[1] = (char) 255;
message[2] = (char) 255;
message[3] = (char) 255;
message[4] = 0;
strcat(message, "rcon ");
strcat(message, rcon_password->string);
strcat(message, " ");
for (i = 1; i < Cmd_Argc(); i++) {
strcat(message, Cmd_Argv(i));
strcat(message, " ");
}
if (cls.state >= CL_CONNECTED)
to = cls.net_chan.remote_address;
else {
if (*rcon_address->string == '\0') {
Com_Print("Not connected and no rcon_address set\n");
return;
}
if (!Net_StringToNetaddr(rcon_address->string, &to)) {
Com_Warn("Invalid rcon_address: %s\n", rcon_address->string);
return;
}
if (to.port == 0)
to.port = htons(PORT_SERVER);
}
Net_SendDatagram(NS_UDP_CLIENT, &to, message, strlen(message) + 1);
}
/*
* @brief Tries to send an unreliable message to a connection, and handles the
* transmission / retransmission of the reliable messages.
*
* A 0 size will still generate a packet and deal with the reliable messages.
*/
void Netchan_Transmit(net_chan_t *chan, byte *data, size_t len) {
mem_buf_t send;
byte send_buffer[MAX_MSG_SIZE];
// check for message overflow
if (chan->message.overflowed) {
chan->fatal_error = true;
Com_Print("%s:Outgoing message overflow\n", Net_NetaddrToString(&chan->remote_address));
return;
}
const _Bool send_reliable = Netchan_NeedReliable(chan);
if (!chan->reliable_size && chan->message.size) {
memcpy(chan->reliable_buffer, chan->message_buffer, chan->message.size);
chan->reliable_size = chan->message.size;
chan->message.size = 0;
chan->reliable_sequence ^= 1;
}
// write the packet header
Mem_InitBuffer(&send, send_buffer, sizeof(send_buffer));
const uint32_t w1 = (chan->outgoing_sequence & ~(1 << 31)) | (send_reliable << 31);
const uint32_t w2 = (chan->incoming_sequence & ~(1 << 31)) | (chan->incoming_reliable_sequence
<< 31);
chan->outgoing_sequence++;
chan->last_sent = quake2world.time;
Net_WriteLong(&send, w1);
Net_WriteLong(&send, w2);
// send the qport if we are a client
if (chan->source == NS_UDP_CLIENT)
Net_WriteByte(&send, chan->qport);
// copy the reliable message to the packet first
if (send_reliable) {
Mem_WriteBuffer(&send, chan->reliable_buffer, chan->reliable_size);
chan->last_reliable_sequence = chan->outgoing_sequence;
}
// add the unreliable part if space is available
if (send.max_size - send.size >= len)
Mem_WriteBuffer(&send, data, len);
else
Com_Warn("Netchan_Transmit: dumped unreliable\n");
// send the datagram
Net_SendDatagram(chan->source, &chan->remote_address, send.data, send.size);
if (net_showpackets->value) {
if (send_reliable)
Com_Print("Send %u bytes: s=%i reliable=%i ack=%i rack=%i\n", (uint32_t) send.size,
chan->outgoing_sequence - 1, chan->reliable_sequence, chan->incoming_sequence,
chan->incoming_reliable_sequence);
else
Com_Print("Send %u bytes : s=%i ack=%i rack=%i\n", (uint32_t) send.size,
chan->outgoing_sequence - 1, chan->incoming_sequence,
chan->incoming_reliable_sequence);
}
}