1

/* $Id$ */

     2

     3

#ifdef ENABLE_NETWORK

     4

     5

#include "../../stdafx.h"

     6

#include "../../macros.h"

     7

#include "../../string.h"

     8

#include "../../helpers.hpp"

     9

    10

#include "packet.h"

    11

    12

/**

    13

 * @file packet.h Basic functions to create, fill and read packets.

    14

 */

    15

    16

    17

/* Do not want to include functions.h and all required headers */

    18

extern void NORETURN CDECL error(const char *str, ...);

    19

    20

    21

/**

    22

 * Create a packet for sending

    23

 * @param type the of packet

    24

 * @return the newly created packet

    25

 */

    26

Packet *NetworkSend_Init(const PacketType type)

    27

{

    28

	Packet *packet = MallocT<Packet>(1);

    29

	/* An error is inplace here, because it simply means we ran out of memory. */

    30

	if (packet == NULL) error("Failed to allocate Packet");

    31

    32

	/* Skip the size so we can write that in before sending the packet */

    33

	packet->size = sizeof(packet->size);

    34

	packet->buffer[packet->size++] = type;

    35

	packet->pos = 0;

    36

    37

	return packet;

    38

}

    39

    40

/**

    41

 * Writes the packet size from the raw packet from packet->size

    42

 * @param packet the packet to write the size of

    43

 */

    44

void NetworkSend_FillPacketSize(Packet *packet)

    45

{

    46

	packet->buffer[0] = GB(packet->size, 0, 8);

    47

	packet->buffer[1] = GB(packet->size, 8, 8);

    48

}

    49

    50

/**

    51

 * The next couple of functions make sure we can send

    52

 *  uint8, uint16, uint32 and uint64 endian-safe

    53

 *  over the network. The least significant bytes are

    54

 *  sent first.

    55

 *

    56

 *  So 0x01234567 would be sent as 67 45 23 01.

    57

 */

    58

    59

void NetworkSend_uint8(Packet *packet, uint8 data)

    60

{

    61

	assert(packet->size < sizeof(packet->buffer) - sizeof(data));

    62

	packet->buffer[packet->size++] = data;

    63

}

    64

    65

void NetworkSend_uint16(Packet *packet, uint16 data)

    66

{

    67

	assert(packet->size < sizeof(packet->buffer) - sizeof(data));

    68

	packet->buffer[packet->size++] = GB(data, 0, 8);

    69

	packet->buffer[packet->size++] = GB(data, 8, 8);

    70

}

    71

    72

void NetworkSend_uint32(Packet *packet, uint32 data)

    73

{

    74

	assert(packet->size < sizeof(packet->buffer) - sizeof(data));

    75

	packet->buffer[packet->size++] = GB(data,  0, 8);

    76

	packet->buffer[packet->size++] = GB(data,  8, 8);

    77

	packet->buffer[packet->size++] = GB(data, 16, 8);

    78

	packet->buffer[packet->size++] = GB(data, 24, 8);

    79

}

    80

    81

void NetworkSend_uint64(Packet *packet, uint64 data)

    82

{

    83

	assert(packet->size < sizeof(packet->buffer) - sizeof(data));

    84

	packet->buffer[packet->size++] = GB(data,  0, 8);

    85

	packet->buffer[packet->size++] = GB(data,  8, 8);

    86

	packet->buffer[packet->size++] = GB(data, 16, 8);

    87

	packet->buffer[packet->size++] = GB(data, 24, 8);

    88

	packet->buffer[packet->size++] = GB(data, 32, 8);

    89

	packet->buffer[packet->size++] = GB(data, 40, 8);

    90

	packet->buffer[packet->size++] = GB(data, 48, 8);

    91

	packet->buffer[packet->size++] = GB(data, 56, 8);

    92

}

    93

    94

/**

    95

 *  Sends a string over the network. It sends out

    96

 *  the string + '\0'. No size-byte or something.

    97

 */

    98

void NetworkSend_string(Packet *packet, const char* data)

    99

{

   100

	assert(data != NULL);

   101

	assert(packet->size < sizeof(packet->buffer) - strlen(data) - 1);

   102

	while ((packet->buffer[packet->size++] = *data++) != '\0') {}

   103

}

   104

   105

   106

/**

   107

 * Receiving commands

   108

 * Again, the next couple of functions are endian-safe

   109

 *  see the comment before NetworkSend_uint8 for more info.

   110

 */

   111

   112

   113

/** Is it safe to read from the packet, i.e. didn't we run over the buffer ? */

   115

{

   118

   119

	/* Check if variable is within packet-size */

   120

	if (packet->pos + bytes_to_read > packet->size) {

   122

		return false;

   123

	}

   124

   125

	return true;

   126

}

   127

   128

/**

   129

 * Reads the packet size from the raw packet and stores it in the packet->size

   130

 * @param packet the packet to read the size of

   131

 */

   132

void NetworkRecv_ReadPacketSize(Packet *packet)

   133

{

   134

	packet->size  = (uint16)packet->buffer[0];

   135

	packet->size += (uint16)packet->buffer[1] << 8;

   136

}

   137

   139

{

   140

	uint8 n;

   141

   142

	if (!CanReadFromPacket(cs, packet, sizeof(n))) return 0;

   143

   144

	n = packet->buffer[packet->pos++];

   145

	return n;

   146

}

   147

   149

{

   150

	uint16 n;

   151

   152

	if (!CanReadFromPacket(cs, packet, sizeof(n))) return 0;

   153

   154

	n  = (uint16)packet->buffer[packet->pos++];

   155

	n += (uint16)packet->buffer[packet->pos++] << 8;

   156

	return n;

   157

}

   158

   160

{

   161

	uint32 n;

   162

   163

	if (!CanReadFromPacket(cs, packet, sizeof(n))) return 0;

   164

   165

	n  = (uint32)packet->buffer[packet->pos++];

   166

	n += (uint32)packet->buffer[packet->pos++] << 8;

   167

	n += (uint32)packet->buffer[packet->pos++] << 16;

   168

	n += (uint32)packet->buffer[packet->pos++] << 24;

   169

	return n;

   170

}

   171

   173

{

   174

	uint64 n;

   175

   176

	if (!CanReadFromPacket(cs, packet, sizeof(n))) return 0;

   177

   178

	n  = (uint64)packet->buffer[packet->pos++];

   179

	n += (uint64)packet->buffer[packet->pos++] << 8;

   180

	n += (uint64)packet->buffer[packet->pos++] << 16;

   181

	n += (uint64)packet->buffer[packet->pos++] << 24;

   182

	n += (uint64)packet->buffer[packet->pos++] << 32;

   183

	n += (uint64)packet->buffer[packet->pos++] << 40;

   184

	n += (uint64)packet->buffer[packet->pos++] << 48;

   185

	n += (uint64)packet->buffer[packet->pos++] << 56;

   186

	return n;

   187

}

   188

   189

/** Reads a string till it finds a '\0' in the stream */

   191

{

   192

	PacketSize pos;

   193

	char *bufp = buffer;

   194

   195

	/* Don't allow reading from a closed socket */

   197

   198

	pos = p->pos;

   199

	while (--size > 0 && pos < p->size && (*buffer++ = p->buffer[pos++]) != '\0') {}

   200

   201

	if (size == 0 || pos == p->size) {

   202

		*buffer = '\0';

   203

		/* If size was sooner to zero then the string in the stream

   204

		 *  skip till the \0, so than packet can be read out correctly for the rest */

   205

		while (pos < p->size && p->buffer[pos] != '\0') pos++;

   206

		pos++;

   207

	}

   208

	p->pos = pos;

   209

   210

	str_validate(bufp);

   211

}

   212

   213

#endif /* ENABLE_NETWORK */