1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
#include "gsCommon.h"
#include "gsAvailable.h"
#define PACKET_TYPE 0x09
#define MASTER_PORT 27900
#define MAX_RETRIES 1
#define TIMEOUT_TIME 2000
// this is the global var that the SDKs check
// to see if they should communicate with the backend
GSIACResult __GSIACResult = GSIACWaiting;
// this makes the gamename available to all of the SDKs
char __GSIACGamename[64] = {0};
// this allows devs to do their own hostname resolution
char GSIACHostname[64] = {0};
// used to keep state during the check
static struct
{
SOCKET sock;
SOCKADDR_IN address;
char packet[64];
int packetLen;
gsi_time sendTime;
int retryCount;
} AC;
static int get_sockaddrin(const char * hostname, int port, SOCKADDR_IN * saddr)
{
GS_ASSERT(hostname)
GS_ASSERT(saddr)
saddr->sin_family = AF_INET;
saddr->sin_port = htons((unsigned short)port);
saddr->sin_addr.s_addr = inet_addr(hostname);
if(saddr->sin_addr.s_addr == INADDR_NONE)
{
HOSTENT * host = gethostbyname(hostname);
if(!host)
return 0;
saddr->sin_addr.s_addr = *(unsigned int *)host->h_addr_list[0];
}
return 1;
}
static void SendPacket(void)
{
sendto(AC.sock, AC.packet, AC.packetLen, 0, (SOCKADDR *)&AC.address, sizeof(AC.address));
AC.sendTime = current_time();
}
void GSIStartAvailableCheckA(const char * gamename)
{
char hostname[64];
int override;
int rcode;
int len;
GS_ASSERT(gamename)
// store the gamename
strcpy(__GSIACGamename, gamename);
// clear the sock
AC.sock = INVALID_SOCKET;
// startup sockets
SocketStartUp();
// setup the hostname
override = GSIACHostname[0];
if(!override)
sprintf(hostname, "%s.available." GSI_DOMAIN_NAME, gamename);
// get the master address
rcode = get_sockaddrin(override?GSIACHostname:hostname, MASTER_PORT, &AC.address);
if(!rcode)
return;
// create the socket
AC.sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(AC.sock == INVALID_SOCKET)
return;
// setup our packet
AC.packet[0] = PACKET_TYPE;
len = (int)strlen(gamename);
memcpy(AC.packet + 5, gamename, (size_t)len + 1);
AC.packetLen = (len + 6);
// send it
SendPacket();
// no retries yet
AC.retryCount = 0;
}
#ifdef GSI_UNICODE
void GSIStartAvailableCheckW(const unsigned short * gamename)
{
char gamename_A[32];
GS_ASSERT(gamename)
UCS2ToAsciiString(gamename, gamename_A);
GSIStartAvailableCheckA(gamename_A);
}
#endif
static int HandlePacket(char * packet, int len, SOCKADDR_IN * address, int * disabledservices)
{
int bitfield;
// check the length
if(len < 7)
return 1;
// check the IP
if(memcmp(&address->sin_addr, &AC.address.sin_addr, sizeof(IN_ADDR)) != 0)
return 1;
// check the port
if(address->sin_port != AC.address.sin_port)
return 1;
// check the header
if(memcmp(packet, "\xFE\xFD\x09", 3) != 0)
return 1;
// read out the bitfield
// read byte-by-byte to avoid alignment issues
bitfield = (int)((packet[3] << 24) & 0xFF000000);
bitfield |= ((packet[4] << 16) & 0x00FF0000);
bitfield |= ((packet[5] << 8) & 0x0000FF00);
bitfield |= (packet[6] & 0x000000FF);
// set it
*disabledservices = bitfield;
return 0;
}
GSIACResult GSIAvailableCheckThink(void)
{
char packet[64];
SOCKADDR_IN address;
int len = sizeof(address);
int rcode;
int disabledservices;
// if we don't have a sock, possibly because of an initialization error, default to available
if(AC.sock == INVALID_SOCKET)
{
__GSIACResult = GSIACAvailable;
return __GSIACResult;
}
// did we get a response?
if(CanReceiveOnSocket(AC.sock))
{
// read it from the socket
rcode = (int)recvfrom(AC.sock, packet, (int)sizeof(packet), 0, (SOCKADDR *)&address, &len);
// verify the packet
rcode = HandlePacket(packet, rcode, &address, &disabledservices);
if(rcode == 0)
{
// we got a valid response, clean up
closesocket(AC.sock);
// set the result based on the bit flags
if(disabledservices & 1)
__GSIACResult = GSIACUnavailable;
else if(disabledservices & 2)
__GSIACResult = GSIACTemporarilyUnavailable;
else
__GSIACResult = GSIACAvailable;
// return it
return __GSIACResult;
}
}
// check for a timeout
if(current_time() > (AC.sendTime + TIMEOUT_TIME))
{
// check for too many retries
if(AC.retryCount == MAX_RETRIES)
{
// default to available
closesocket(AC.sock);
__GSIACResult = GSIACAvailable;
return __GSIACResult;
}
// send a retry
SendPacket();
AC.retryCount++;
}
return GSIACWaiting;
}
void GSICancelAvailableCheck(void)
{
if(AC.sock != INVALID_SOCKET)
{
closesocket(AC.sock);
AC.sock = INVALID_SOCKET;
__GSIACResult = GSIACWaiting;
}
}
|
