renet 0.1.14 → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +7 -0
- data/README +6 -16
- data/ext/renet/callbacks.c +53 -0
- data/ext/renet/compress.c +654 -0
- data/ext/renet/enet/callbacks.h +27 -0
- data/ext/renet/enet/enet.h +592 -0
- data/ext/renet/enet/list.h +43 -0
- data/ext/renet/enet/protocol.h +198 -0
- data/ext/renet/enet/time.h +18 -0
- data/ext/renet/enet/types.h +13 -0
- data/ext/renet/enet/unix.h +47 -0
- data/ext/renet/enet/utility.h +12 -0
- data/ext/renet/enet/win32.h +57 -0
- data/ext/renet/extconf.rb +5 -16
- data/ext/renet/host.c +492 -0
- data/ext/renet/list.c +75 -0
- data/ext/renet/packet.c +165 -0
- data/ext/renet/peer.c +1004 -0
- data/ext/renet/protocol.c +1913 -0
- data/ext/renet/renet.c +1 -0
- data/ext/renet/renet_connection.c +383 -208
- data/ext/renet/renet_connection.h +3 -3
- data/ext/renet/renet_server.c +263 -159
- data/ext/renet/renet_server.h +5 -5
- data/ext/renet/unix.c +557 -0
- data/ext/renet/win32.c +478 -0
- data/lib/renet.rb +1 -16
- metadata +33 -16
data/ext/renet/renet_server.h
CHANGED
@@ -26,8 +26,8 @@ typedef struct {
|
|
26
26
|
ENetEvent* event;
|
27
27
|
ENetAddress* address;
|
28
28
|
int channels;
|
29
|
-
int
|
30
|
-
char*
|
29
|
+
int n_clients;
|
30
|
+
char* conn_ip;
|
31
31
|
} Server;
|
32
32
|
|
33
33
|
void init_renet_server();
|
@@ -44,13 +44,13 @@ VALUE renet_server_update(VALUE self, VALUE timeout);
|
|
44
44
|
VALUE renet_server_use_compression(VALUE self, VALUE flag);
|
45
45
|
|
46
46
|
VALUE renet_server_on_connection(VALUE self, VALUE method);
|
47
|
-
void renet_server_execute_on_connection(VALUE peer_id, VALUE ip);
|
47
|
+
void renet_server_execute_on_connection(VALUE self, VALUE peer_id, VALUE ip);
|
48
48
|
|
49
49
|
VALUE renet_server_on_packet_receive(VALUE self, VALUE method);
|
50
|
-
void renet_server_execute_on_packet_receive(VALUE peer_id,
|
50
|
+
void renet_server_execute_on_packet_receive(VALUE self, VALUE peer_id, ENetPacket * const packet, enet_uint8 channelID);
|
51
51
|
|
52
52
|
VALUE renet_server_on_disconnection(VALUE self, VALUE method);
|
53
|
-
void renet_server_execute_on_disconnection(VALUE peer_id);
|
53
|
+
void renet_server_execute_on_disconnection(VALUE self, VALUE peer_id);
|
54
54
|
|
55
55
|
VALUE renet_server_max_clients(VALUE self);
|
56
56
|
VALUE renet_server_clients_count(VALUE self);
|
data/ext/renet/unix.c
ADDED
@@ -0,0 +1,557 @@
|
|
1
|
+
/**
|
2
|
+
@file unix.c
|
3
|
+
@brief ENet Unix system specific functions
|
4
|
+
*/
|
5
|
+
#ifndef _WIN32
|
6
|
+
|
7
|
+
#include <sys/types.h>
|
8
|
+
#include <sys/socket.h>
|
9
|
+
#include <sys/ioctl.h>
|
10
|
+
#include <sys/time.h>
|
11
|
+
#include <arpa/inet.h>
|
12
|
+
#include <netinet/tcp.h>
|
13
|
+
#include <netdb.h>
|
14
|
+
#include <unistd.h>
|
15
|
+
#include <string.h>
|
16
|
+
#include <errno.h>
|
17
|
+
#include <time.h>
|
18
|
+
|
19
|
+
#define ENET_BUILDING_LIB 1
|
20
|
+
#include "enet/enet.h"
|
21
|
+
|
22
|
+
#ifdef __APPLE__
|
23
|
+
#ifdef HAS_POLL
|
24
|
+
#undef HAS_POLL
|
25
|
+
#endif
|
26
|
+
#ifndef HAS_FCNTL
|
27
|
+
#define HAS_FCNTL 1
|
28
|
+
#endif
|
29
|
+
#ifndef HAS_INET_PTON
|
30
|
+
#define HAS_INET_PTON 1
|
31
|
+
#endif
|
32
|
+
#ifndef HAS_INET_NTOP
|
33
|
+
#define HAS_INET_NTOP 1
|
34
|
+
#endif
|
35
|
+
#ifndef HAS_MSGHDR_FLAGS
|
36
|
+
#define HAS_MSGHDR_FLAGS 1
|
37
|
+
#endif
|
38
|
+
#ifndef HAS_SOCKLEN_T
|
39
|
+
#define HAS_SOCKLEN_T 1
|
40
|
+
#endif
|
41
|
+
#endif
|
42
|
+
|
43
|
+
#ifdef HAS_FCNTL
|
44
|
+
#include <fcntl.h>
|
45
|
+
#endif
|
46
|
+
|
47
|
+
#ifdef HAS_POLL
|
48
|
+
#include <sys/poll.h>
|
49
|
+
#endif
|
50
|
+
|
51
|
+
#ifndef HAS_SOCKLEN_T
|
52
|
+
typedef int socklen_t;
|
53
|
+
#endif
|
54
|
+
|
55
|
+
#ifndef MSG_NOSIGNAL
|
56
|
+
#define MSG_NOSIGNAL 0
|
57
|
+
#endif
|
58
|
+
|
59
|
+
static enet_uint32 timeBase = 0;
|
60
|
+
|
61
|
+
int
|
62
|
+
enet_initialize (void)
|
63
|
+
{
|
64
|
+
return 0;
|
65
|
+
}
|
66
|
+
|
67
|
+
void
|
68
|
+
enet_deinitialize (void)
|
69
|
+
{
|
70
|
+
}
|
71
|
+
|
72
|
+
enet_uint32
|
73
|
+
enet_host_random_seed (void)
|
74
|
+
{
|
75
|
+
return (enet_uint32) time (NULL);
|
76
|
+
}
|
77
|
+
|
78
|
+
enet_uint32
|
79
|
+
enet_time_get (void)
|
80
|
+
{
|
81
|
+
struct timeval timeVal;
|
82
|
+
|
83
|
+
gettimeofday (& timeVal, NULL);
|
84
|
+
|
85
|
+
return timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - timeBase;
|
86
|
+
}
|
87
|
+
|
88
|
+
void
|
89
|
+
enet_time_set (enet_uint32 newTimeBase)
|
90
|
+
{
|
91
|
+
struct timeval timeVal;
|
92
|
+
|
93
|
+
gettimeofday (& timeVal, NULL);
|
94
|
+
|
95
|
+
timeBase = timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - newTimeBase;
|
96
|
+
}
|
97
|
+
|
98
|
+
int
|
99
|
+
enet_address_set_host (ENetAddress * address, const char * name)
|
100
|
+
{
|
101
|
+
struct hostent * hostEntry = NULL;
|
102
|
+
#ifdef HAS_GETHOSTBYNAME_R
|
103
|
+
struct hostent hostData;
|
104
|
+
char buffer [2048];
|
105
|
+
int errnum;
|
106
|
+
|
107
|
+
#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
|
108
|
+
gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
|
109
|
+
#else
|
110
|
+
hostEntry = gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & errnum);
|
111
|
+
#endif
|
112
|
+
#else
|
113
|
+
hostEntry = gethostbyname (name);
|
114
|
+
#endif
|
115
|
+
|
116
|
+
if (hostEntry == NULL ||
|
117
|
+
hostEntry -> h_addrtype != AF_INET)
|
118
|
+
{
|
119
|
+
#ifdef HAS_INET_PTON
|
120
|
+
if (! inet_pton (AF_INET, name, & address -> host))
|
121
|
+
#else
|
122
|
+
if (! inet_aton (name, (struct in_addr *) & address -> host))
|
123
|
+
#endif
|
124
|
+
return -1;
|
125
|
+
return 0;
|
126
|
+
}
|
127
|
+
|
128
|
+
address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
|
129
|
+
|
130
|
+
return 0;
|
131
|
+
}
|
132
|
+
|
133
|
+
int
|
134
|
+
enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength)
|
135
|
+
{
|
136
|
+
#ifdef HAS_INET_NTOP
|
137
|
+
if (inet_ntop (AF_INET, & address -> host, name, nameLength) == NULL)
|
138
|
+
#else
|
139
|
+
char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
|
140
|
+
if (addr != NULL)
|
141
|
+
{
|
142
|
+
size_t addrLen = strlen(addr);
|
143
|
+
if (addrLen >= nameLength)
|
144
|
+
return -1;
|
145
|
+
memcpy (name, addr, addrLen + 1);
|
146
|
+
}
|
147
|
+
else
|
148
|
+
#endif
|
149
|
+
return -1;
|
150
|
+
return 0;
|
151
|
+
}
|
152
|
+
|
153
|
+
int
|
154
|
+
enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
|
155
|
+
{
|
156
|
+
struct in_addr in;
|
157
|
+
struct hostent * hostEntry = NULL;
|
158
|
+
#ifdef HAS_GETHOSTBYADDR_R
|
159
|
+
struct hostent hostData;
|
160
|
+
char buffer [2048];
|
161
|
+
int errnum;
|
162
|
+
|
163
|
+
in.s_addr = address -> host;
|
164
|
+
|
165
|
+
#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
|
166
|
+
gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
|
167
|
+
#else
|
168
|
+
hostEntry = gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & errnum);
|
169
|
+
#endif
|
170
|
+
#else
|
171
|
+
in.s_addr = address -> host;
|
172
|
+
|
173
|
+
hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
|
174
|
+
#endif
|
175
|
+
|
176
|
+
if (hostEntry == NULL)
|
177
|
+
return enet_address_get_host_ip (address, name, nameLength);
|
178
|
+
else
|
179
|
+
{
|
180
|
+
size_t hostLen = strlen (hostEntry -> h_name);
|
181
|
+
if (hostLen >= nameLength)
|
182
|
+
return -1;
|
183
|
+
memcpy (name, hostEntry -> h_name, hostLen + 1);
|
184
|
+
}
|
185
|
+
|
186
|
+
return 0;
|
187
|
+
}
|
188
|
+
|
189
|
+
int
|
190
|
+
enet_socket_bind (ENetSocket socket, const ENetAddress * address)
|
191
|
+
{
|
192
|
+
struct sockaddr_in sin;
|
193
|
+
|
194
|
+
memset (& sin, 0, sizeof (struct sockaddr_in));
|
195
|
+
|
196
|
+
sin.sin_family = AF_INET;
|
197
|
+
|
198
|
+
if (address != NULL)
|
199
|
+
{
|
200
|
+
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
|
201
|
+
sin.sin_addr.s_addr = address -> host;
|
202
|
+
}
|
203
|
+
else
|
204
|
+
{
|
205
|
+
sin.sin_port = 0;
|
206
|
+
sin.sin_addr.s_addr = INADDR_ANY;
|
207
|
+
}
|
208
|
+
|
209
|
+
return bind (socket,
|
210
|
+
(struct sockaddr *) & sin,
|
211
|
+
sizeof (struct sockaddr_in));
|
212
|
+
}
|
213
|
+
|
214
|
+
int
|
215
|
+
enet_socket_get_address (ENetSocket socket, ENetAddress * address)
|
216
|
+
{
|
217
|
+
struct sockaddr_in sin;
|
218
|
+
socklen_t sinLength = sizeof (struct sockaddr_in);
|
219
|
+
|
220
|
+
if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
|
221
|
+
return -1;
|
222
|
+
|
223
|
+
address -> host = (enet_uint32) sin.sin_addr.s_addr;
|
224
|
+
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
|
225
|
+
|
226
|
+
return 0;
|
227
|
+
}
|
228
|
+
|
229
|
+
int
|
230
|
+
enet_socket_listen (ENetSocket socket, int backlog)
|
231
|
+
{
|
232
|
+
return listen (socket, backlog < 0 ? SOMAXCONN : backlog);
|
233
|
+
}
|
234
|
+
|
235
|
+
ENetSocket
|
236
|
+
enet_socket_create (ENetSocketType type)
|
237
|
+
{
|
238
|
+
return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
|
239
|
+
}
|
240
|
+
|
241
|
+
int
|
242
|
+
enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
|
243
|
+
{
|
244
|
+
int result = -1;
|
245
|
+
switch (option)
|
246
|
+
{
|
247
|
+
case ENET_SOCKOPT_NONBLOCK:
|
248
|
+
#ifdef HAS_FCNTL
|
249
|
+
result = fcntl (socket, F_SETFL, (value ? O_NONBLOCK : 0) | (fcntl (socket, F_GETFL) & ~O_NONBLOCK));
|
250
|
+
#else
|
251
|
+
result = ioctl (socket, FIONBIO, & value);
|
252
|
+
#endif
|
253
|
+
break;
|
254
|
+
|
255
|
+
case ENET_SOCKOPT_BROADCAST:
|
256
|
+
result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int));
|
257
|
+
break;
|
258
|
+
|
259
|
+
case ENET_SOCKOPT_REUSEADDR:
|
260
|
+
result = setsockopt (socket, SOL_SOCKET, SO_REUSEADDR, (char *) & value, sizeof (int));
|
261
|
+
break;
|
262
|
+
|
263
|
+
case ENET_SOCKOPT_RCVBUF:
|
264
|
+
result = setsockopt (socket, SOL_SOCKET, SO_RCVBUF, (char *) & value, sizeof (int));
|
265
|
+
break;
|
266
|
+
|
267
|
+
case ENET_SOCKOPT_SNDBUF:
|
268
|
+
result = setsockopt (socket, SOL_SOCKET, SO_SNDBUF, (char *) & value, sizeof (int));
|
269
|
+
break;
|
270
|
+
|
271
|
+
case ENET_SOCKOPT_RCVTIMEO:
|
272
|
+
{
|
273
|
+
struct timeval timeVal;
|
274
|
+
timeVal.tv_sec = value / 1000;
|
275
|
+
timeVal.tv_usec = (value % 1000) * 1000;
|
276
|
+
result = setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char *) & timeVal, sizeof (struct timeval));
|
277
|
+
break;
|
278
|
+
}
|
279
|
+
|
280
|
+
case ENET_SOCKOPT_SNDTIMEO:
|
281
|
+
{
|
282
|
+
struct timeval timeVal;
|
283
|
+
timeVal.tv_sec = value / 1000;
|
284
|
+
timeVal.tv_usec = (value % 1000) * 1000;
|
285
|
+
result = setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *) & timeVal, sizeof (struct timeval));
|
286
|
+
break;
|
287
|
+
}
|
288
|
+
|
289
|
+
case ENET_SOCKOPT_NODELAY:
|
290
|
+
result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int));
|
291
|
+
break;
|
292
|
+
|
293
|
+
default:
|
294
|
+
break;
|
295
|
+
}
|
296
|
+
return result == -1 ? -1 : 0;
|
297
|
+
}
|
298
|
+
|
299
|
+
int
|
300
|
+
enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value)
|
301
|
+
{
|
302
|
+
int result = -1;
|
303
|
+
socklen_t len;
|
304
|
+
switch (option)
|
305
|
+
{
|
306
|
+
case ENET_SOCKOPT_ERROR:
|
307
|
+
len = sizeof (int);
|
308
|
+
result = getsockopt (socket, SOL_SOCKET, SO_ERROR, value, & len);
|
309
|
+
break;
|
310
|
+
|
311
|
+
default:
|
312
|
+
break;
|
313
|
+
}
|
314
|
+
return result == -1 ? -1 : 0;
|
315
|
+
}
|
316
|
+
|
317
|
+
int
|
318
|
+
enet_socket_connect (ENetSocket socket, const ENetAddress * address)
|
319
|
+
{
|
320
|
+
struct sockaddr_in sin;
|
321
|
+
int result;
|
322
|
+
|
323
|
+
memset (& sin, 0, sizeof (struct sockaddr_in));
|
324
|
+
|
325
|
+
sin.sin_family = AF_INET;
|
326
|
+
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
|
327
|
+
sin.sin_addr.s_addr = address -> host;
|
328
|
+
|
329
|
+
result = connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
|
330
|
+
if (result == -1 && errno == EINPROGRESS)
|
331
|
+
return 0;
|
332
|
+
|
333
|
+
return result;
|
334
|
+
}
|
335
|
+
|
336
|
+
ENetSocket
|
337
|
+
enet_socket_accept (ENetSocket socket, ENetAddress * address)
|
338
|
+
{
|
339
|
+
int result;
|
340
|
+
struct sockaddr_in sin;
|
341
|
+
socklen_t sinLength = sizeof (struct sockaddr_in);
|
342
|
+
|
343
|
+
result = accept (socket,
|
344
|
+
address != NULL ? (struct sockaddr *) & sin : NULL,
|
345
|
+
address != NULL ? & sinLength : NULL);
|
346
|
+
|
347
|
+
if (result == -1)
|
348
|
+
return ENET_SOCKET_NULL;
|
349
|
+
|
350
|
+
if (address != NULL)
|
351
|
+
{
|
352
|
+
address -> host = (enet_uint32) sin.sin_addr.s_addr;
|
353
|
+
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
|
354
|
+
}
|
355
|
+
|
356
|
+
return result;
|
357
|
+
}
|
358
|
+
|
359
|
+
int
|
360
|
+
enet_socket_shutdown (ENetSocket socket, ENetSocketShutdown how)
|
361
|
+
{
|
362
|
+
return shutdown (socket, (int) how);
|
363
|
+
}
|
364
|
+
|
365
|
+
void
|
366
|
+
enet_socket_destroy (ENetSocket socket)
|
367
|
+
{
|
368
|
+
if (socket != -1)
|
369
|
+
close (socket);
|
370
|
+
}
|
371
|
+
|
372
|
+
int
|
373
|
+
enet_socket_send (ENetSocket socket,
|
374
|
+
const ENetAddress * address,
|
375
|
+
const ENetBuffer * buffers,
|
376
|
+
size_t bufferCount)
|
377
|
+
{
|
378
|
+
struct msghdr msgHdr;
|
379
|
+
struct sockaddr_in sin;
|
380
|
+
int sentLength;
|
381
|
+
|
382
|
+
memset (& msgHdr, 0, sizeof (struct msghdr));
|
383
|
+
|
384
|
+
if (address != NULL)
|
385
|
+
{
|
386
|
+
memset (& sin, 0, sizeof (struct sockaddr_in));
|
387
|
+
|
388
|
+
sin.sin_family = AF_INET;
|
389
|
+
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
|
390
|
+
sin.sin_addr.s_addr = address -> host;
|
391
|
+
|
392
|
+
msgHdr.msg_name = & sin;
|
393
|
+
msgHdr.msg_namelen = sizeof (struct sockaddr_in);
|
394
|
+
}
|
395
|
+
|
396
|
+
msgHdr.msg_iov = (struct iovec *) buffers;
|
397
|
+
msgHdr.msg_iovlen = bufferCount;
|
398
|
+
|
399
|
+
sentLength = sendmsg (socket, & msgHdr, MSG_NOSIGNAL);
|
400
|
+
|
401
|
+
if (sentLength == -1)
|
402
|
+
{
|
403
|
+
if (errno == EWOULDBLOCK)
|
404
|
+
return 0;
|
405
|
+
|
406
|
+
return -1;
|
407
|
+
}
|
408
|
+
|
409
|
+
return sentLength;
|
410
|
+
}
|
411
|
+
|
412
|
+
int
|
413
|
+
enet_socket_receive (ENetSocket socket,
|
414
|
+
ENetAddress * address,
|
415
|
+
ENetBuffer * buffers,
|
416
|
+
size_t bufferCount)
|
417
|
+
{
|
418
|
+
struct msghdr msgHdr;
|
419
|
+
struct sockaddr_in sin;
|
420
|
+
int recvLength;
|
421
|
+
|
422
|
+
memset (& msgHdr, 0, sizeof (struct msghdr));
|
423
|
+
|
424
|
+
if (address != NULL)
|
425
|
+
{
|
426
|
+
msgHdr.msg_name = & sin;
|
427
|
+
msgHdr.msg_namelen = sizeof (struct sockaddr_in);
|
428
|
+
}
|
429
|
+
|
430
|
+
msgHdr.msg_iov = (struct iovec *) buffers;
|
431
|
+
msgHdr.msg_iovlen = bufferCount;
|
432
|
+
|
433
|
+
recvLength = recvmsg (socket, & msgHdr, MSG_NOSIGNAL);
|
434
|
+
|
435
|
+
if (recvLength == -1)
|
436
|
+
{
|
437
|
+
if (errno == EWOULDBLOCK)
|
438
|
+
return 0;
|
439
|
+
|
440
|
+
return -1;
|
441
|
+
}
|
442
|
+
|
443
|
+
#ifdef HAS_MSGHDR_FLAGS
|
444
|
+
if (msgHdr.msg_flags & MSG_TRUNC)
|
445
|
+
return -1;
|
446
|
+
#endif
|
447
|
+
|
448
|
+
if (address != NULL)
|
449
|
+
{
|
450
|
+
address -> host = (enet_uint32) sin.sin_addr.s_addr;
|
451
|
+
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
|
452
|
+
}
|
453
|
+
|
454
|
+
return recvLength;
|
455
|
+
}
|
456
|
+
|
457
|
+
int
|
458
|
+
enet_socketset_select (ENetSocket maxSocket, ENetSocketSet * readSet, ENetSocketSet * writeSet, enet_uint32 timeout)
|
459
|
+
{
|
460
|
+
struct timeval timeVal;
|
461
|
+
|
462
|
+
timeVal.tv_sec = timeout / 1000;
|
463
|
+
timeVal.tv_usec = (timeout % 1000) * 1000;
|
464
|
+
|
465
|
+
return select (maxSocket + 1, readSet, writeSet, NULL, & timeVal);
|
466
|
+
}
|
467
|
+
|
468
|
+
int
|
469
|
+
enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout)
|
470
|
+
{
|
471
|
+
#ifdef HAS_POLL
|
472
|
+
struct pollfd pollSocket;
|
473
|
+
int pollCount;
|
474
|
+
|
475
|
+
pollSocket.fd = socket;
|
476
|
+
pollSocket.events = 0;
|
477
|
+
|
478
|
+
if (* condition & ENET_SOCKET_WAIT_SEND)
|
479
|
+
pollSocket.events |= POLLOUT;
|
480
|
+
|
481
|
+
if (* condition & ENET_SOCKET_WAIT_RECEIVE)
|
482
|
+
pollSocket.events |= POLLIN;
|
483
|
+
|
484
|
+
pollCount = poll (& pollSocket, 1, timeout);
|
485
|
+
|
486
|
+
if (pollCount < 0)
|
487
|
+
{
|
488
|
+
if (errno == EINTR && * condition & ENET_SOCKET_WAIT_INTERRUPT)
|
489
|
+
{
|
490
|
+
* condition = ENET_SOCKET_WAIT_INTERRUPT;
|
491
|
+
|
492
|
+
return 0;
|
493
|
+
}
|
494
|
+
|
495
|
+
return -1;
|
496
|
+
}
|
497
|
+
|
498
|
+
* condition = ENET_SOCKET_WAIT_NONE;
|
499
|
+
|
500
|
+
if (pollCount == 0)
|
501
|
+
return 0;
|
502
|
+
|
503
|
+
if (pollSocket.revents & POLLOUT)
|
504
|
+
* condition |= ENET_SOCKET_WAIT_SEND;
|
505
|
+
|
506
|
+
if (pollSocket.revents & POLLIN)
|
507
|
+
* condition |= ENET_SOCKET_WAIT_RECEIVE;
|
508
|
+
|
509
|
+
return 0;
|
510
|
+
#else
|
511
|
+
fd_set readSet, writeSet;
|
512
|
+
struct timeval timeVal;
|
513
|
+
int selectCount;
|
514
|
+
|
515
|
+
timeVal.tv_sec = timeout / 1000;
|
516
|
+
timeVal.tv_usec = (timeout % 1000) * 1000;
|
517
|
+
|
518
|
+
FD_ZERO (& readSet);
|
519
|
+
FD_ZERO (& writeSet);
|
520
|
+
|
521
|
+
if (* condition & ENET_SOCKET_WAIT_SEND)
|
522
|
+
FD_SET (socket, & writeSet);
|
523
|
+
|
524
|
+
if (* condition & ENET_SOCKET_WAIT_RECEIVE)
|
525
|
+
FD_SET (socket, & readSet);
|
526
|
+
|
527
|
+
selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
|
528
|
+
|
529
|
+
if (selectCount < 0)
|
530
|
+
{
|
531
|
+
if (errno == EINTR && * condition & ENET_SOCKET_WAIT_INTERRUPT)
|
532
|
+
{
|
533
|
+
* condition = ENET_SOCKET_WAIT_INTERRUPT;
|
534
|
+
|
535
|
+
return 0;
|
536
|
+
}
|
537
|
+
|
538
|
+
return -1;
|
539
|
+
}
|
540
|
+
|
541
|
+
* condition = ENET_SOCKET_WAIT_NONE;
|
542
|
+
|
543
|
+
if (selectCount == 0)
|
544
|
+
return 0;
|
545
|
+
|
546
|
+
if (FD_ISSET (socket, & writeSet))
|
547
|
+
* condition |= ENET_SOCKET_WAIT_SEND;
|
548
|
+
|
549
|
+
if (FD_ISSET (socket, & readSet))
|
550
|
+
* condition |= ENET_SOCKET_WAIT_RECEIVE;
|
551
|
+
|
552
|
+
return 0;
|
553
|
+
#endif
|
554
|
+
}
|
555
|
+
|
556
|
+
#endif
|
557
|
+
|