]>
Commit | Line | Data |
---|---|---|
9bbd7ba3 | 1 | /* ------------------------------------------------------------------------- |
9bf10d6b | 2 | * Project: GSocket (Generic Socket) |
9bbd7ba3 | 3 | * Name: gsocket.c |
9bf10d6b | 4 | * Author: Guillermo Rodriguez Garcia <guille@iies.es> |
9bbd7ba3 GRG |
5 | * Purpose: GSocket main MSW file |
6 | * CVSID: $Id$ | |
7 | * ------------------------------------------------------------------------- | |
8 | */ | |
9 | ||
9bf10d6b GRG |
10 | /* |
11 | * PLEASE don't put C++ comments here - this is a C source file. | |
12 | */ | |
13 | ||
8a9c2246 | 14 | #ifdef _MSC_VER |
29c25a8e GRG |
15 | /* RPCNOTIFICATION_ROUTINE in rasasync.h (included from winsock.h), |
16 | * warning: conditional expression is constant. | |
17 | */ | |
18 | # pragma warning(disable:4115) | |
19 | /* FD_SET, | |
20 | * warning: named type definition in parentheses. | |
21 | */ | |
22 | # pragma warning(disable:4127) | |
23 | /* GAddress_UNIX_GetPath, | |
24 | * warning: unreferenced formal parameter. | |
25 | */ | |
26 | # pragma warning(disable:4100) | |
27 | #endif /* _MSC_VER */ | |
28 | ||
8a9c2246 | 29 | |
2f7c2af5 | 30 | #ifndef __GSOCKET_STANDALONE__ |
33ac7e6f | 31 | # include "wx/defs.h" |
29c25a8e | 32 | # include "wx/setup.h" |
0ce742cf GRG |
33 | #endif |
34 | ||
35 | #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) | |
36 | ||
0ce742cf | 37 | #ifndef __GSOCKET_STANDALONE__ |
ed2eb9af GRG |
38 | # include "wx/msw/gsockmsw.h" |
39 | # include "wx/gsocket.h" | |
9bbd7ba3 | 40 | #else |
ed2eb9af GRG |
41 | # include "gsockmsw.h" |
42 | # include "gsocket.h" | |
43 | #endif /* __GSOCKET_STANDALONE__ */ | |
9bbd7ba3 | 44 | |
29c25a8e | 45 | /* Redefine some GUI-only functions to do nothing in console mode */ |
ed2eb9af | 46 | #if defined(wxUSE_GUI) && !wxUSE_GUI |
29c25a8e | 47 | # define _GSocket_GUI_Init(socket) (1) |
ed2eb9af GRG |
48 | # define _GSocket_GUI_Destroy(socket) |
49 | # define _GSocket_Enable_Events(socket) | |
50 | # define _GSocket_Disable_Events(socket) | |
51 | #endif /* wxUSE_GUI */ | |
9bbd7ba3 | 52 | |
9bbd7ba3 | 53 | |
9bbd7ba3 GRG |
54 | #include <assert.h> |
55 | #include <string.h> | |
56 | #include <stdio.h> | |
57 | #include <stdlib.h> | |
58 | #include <stddef.h> | |
59 | #include <ctype.h> | |
8a9c2246 | 60 | |
9bbd7ba3 GRG |
61 | #include <winsock.h> |
62 | ||
8a9c2246 | 63 | |
c42404a5 VZ |
64 | /* if we use configure for MSW SOCKLEN_T will be already defined */ |
65 | #ifndef SOCKLEN_T | |
ed2eb9af | 66 | # define SOCKLEN_T int |
c42404a5 VZ |
67 | #endif |
68 | ||
9bbd7ba3 | 69 | |
9bf10d6b | 70 | /* Constructors / Destructors for GSocket */ |
9bbd7ba3 | 71 | |
da051b23 | 72 | GSocket *GSocket_new(void) |
9bbd7ba3 | 73 | { |
ed2eb9af | 74 | int i, success; |
9bbd7ba3 GRG |
75 | GSocket *socket; |
76 | ||
77 | if ((socket = (GSocket *) malloc(sizeof(GSocket))) == NULL) | |
78 | return NULL; | |
79 | ||
80 | socket->m_fd = INVALID_SOCKET; | |
81 | for (i = 0; i < GSOCK_MAX_EVENT; i++) | |
82 | { | |
83 | socket->m_cbacks[i] = NULL; | |
84 | } | |
ed2eb9af | 85 | socket->m_detected = 0; |
33ac7e6f KB |
86 | socket->m_local = NULL; |
87 | socket->m_peer = NULL; | |
9bbd7ba3 | 88 | socket->m_error = GSOCK_NOERROR; |
33ac7e6f | 89 | socket->m_server = FALSE; |
9bbd7ba3 GRG |
90 | socket->m_stream = TRUE; |
91 | socket->m_non_blocking = FALSE; | |
92 | socket->m_timeout.tv_sec = 10 * 60; /* 10 minutes */ | |
b661e675 | 93 | socket->m_timeout.tv_usec = 0; |
ed2eb9af | 94 | socket->m_establishing = FALSE; |
9bbd7ba3 | 95 | |
70988afb | 96 | /* Per-socket GUI-specific initialization */ |
ed2eb9af GRG |
97 | success = _GSocket_GUI_Init(socket); |
98 | if (!success) | |
9bbd7ba3 | 99 | { |
70988afb | 100 | free(socket); |
3ca6a5f0 | 101 | socket = NULL; |
9bbd7ba3 | 102 | } |
9bbd7ba3 GRG |
103 | |
104 | return socket; | |
105 | } | |
106 | ||
107 | void GSocket_destroy(GSocket *socket) | |
108 | { | |
109 | assert(socket != NULL); | |
110 | ||
70988afb GRG |
111 | /* Per-socket GUI-specific cleanup */ |
112 | _GSocket_GUI_Destroy(socket); | |
9bbd7ba3 | 113 | |
75d684d9 | 114 | /* Check that the socket is really shutdowned */ |
9bbd7ba3 GRG |
115 | if (socket->m_fd != INVALID_SOCKET) |
116 | GSocket_Shutdown(socket); | |
117 | ||
75d684d9 | 118 | /* Destroy private addresses */ |
9bbd7ba3 GRG |
119 | if (socket->m_local) |
120 | GAddress_destroy(socket->m_local); | |
121 | ||
122 | if (socket->m_peer) | |
123 | GAddress_destroy(socket->m_peer); | |
124 | ||
9bf10d6b | 125 | /* Destroy the socket itself */ |
9bbd7ba3 GRG |
126 | free(socket); |
127 | } | |
128 | ||
9bf10d6b GRG |
129 | /* GSocket_Shutdown: |
130 | * Disallow further read/write operations on this socket, close | |
131 | * the fd and disable all callbacks. | |
132 | */ | |
9bbd7ba3 GRG |
133 | void GSocket_Shutdown(GSocket *socket) |
134 | { | |
135 | int evt; | |
136 | ||
137 | assert(socket != NULL); | |
138 | ||
75d684d9 | 139 | /* If socket has been created, shutdown it */ |
9bbd7ba3 GRG |
140 | if (socket->m_fd != INVALID_SOCKET) |
141 | { | |
9bbd7ba3 GRG |
142 | shutdown(socket->m_fd, 2); |
143 | closesocket(socket->m_fd); | |
144 | socket->m_fd = INVALID_SOCKET; | |
145 | } | |
146 | ||
75d684d9 | 147 | /* Disable GUI callbacks */ |
9bbd7ba3 | 148 | for (evt = 0; evt < GSOCK_MAX_EVENT; evt++) |
9bbd7ba3 | 149 | socket->m_cbacks[evt] = NULL; |
9bbd7ba3 | 150 | |
557e7011 | 151 | socket->m_detected = GSOCK_LOST_FLAG; |
75d684d9 | 152 | _GSocket_Disable_Events(socket); |
9bbd7ba3 GRG |
153 | } |
154 | ||
155 | /* Address handling */ | |
156 | ||
9bf10d6b GRG |
157 | /* GSocket_SetLocal: |
158 | * GSocket_GetLocal: | |
159 | * GSocket_SetPeer: | |
160 | * GSocket_GetPeer: | |
161 | * Set or get the local or peer address for this socket. The 'set' | |
162 | * functions return GSOCK_NOERROR on success, an error code otherwise. | |
163 | * The 'get' functions return a pointer to a GAddress object on success, | |
164 | * or NULL otherwise, in which case they set the error code of the | |
165 | * corresponding GSocket. | |
166 | * | |
167 | * Error codes: | |
168 | * GSOCK_INVSOCK - the socket is not valid. | |
169 | * GSOCK_INVADDR - the address is not valid. | |
170 | */ | |
9bbd7ba3 GRG |
171 | GSocketError GSocket_SetLocal(GSocket *socket, GAddress *address) |
172 | { | |
173 | assert(socket != NULL); | |
174 | ||
9bf10d6b | 175 | /* the socket must be initialized, or it must be a server */ |
9bbd7ba3 GRG |
176 | if (socket->m_fd != INVALID_SOCKET && !socket->m_server) |
177 | { | |
178 | socket->m_error = GSOCK_INVSOCK; | |
179 | return GSOCK_INVSOCK; | |
180 | } | |
181 | ||
9bf10d6b | 182 | /* check address */ |
9bbd7ba3 GRG |
183 | if (address == NULL || address->m_family == GSOCK_NOFAMILY) |
184 | { | |
185 | socket->m_error = GSOCK_INVADDR; | |
186 | return GSOCK_INVADDR; | |
187 | } | |
188 | ||
189 | if (socket->m_local) | |
190 | GAddress_destroy(socket->m_local); | |
191 | ||
192 | socket->m_local = GAddress_copy(address); | |
193 | ||
194 | return GSOCK_NOERROR; | |
195 | } | |
196 | ||
197 | GSocketError GSocket_SetPeer(GSocket *socket, GAddress *address) | |
198 | { | |
199 | assert(socket != NULL); | |
200 | ||
9bf10d6b | 201 | /* check address */ |
9bbd7ba3 GRG |
202 | if (address == NULL || address->m_family == GSOCK_NOFAMILY) |
203 | { | |
204 | socket->m_error = GSOCK_INVADDR; | |
205 | return GSOCK_INVADDR; | |
206 | } | |
207 | ||
208 | if (socket->m_peer) | |
209 | GAddress_destroy(socket->m_peer); | |
210 | ||
211 | socket->m_peer = GAddress_copy(address); | |
212 | ||
213 | return GSOCK_NOERROR; | |
214 | } | |
215 | ||
216 | GAddress *GSocket_GetLocal(GSocket *socket) | |
217 | { | |
218 | GAddress *address; | |
219 | struct sockaddr addr; | |
85806dc2 GRG |
220 | SOCKLEN_T size = sizeof(addr); |
221 | GSocketError err; | |
9bbd7ba3 GRG |
222 | |
223 | assert(socket != NULL); | |
224 | ||
9bf10d6b | 225 | /* try to get it from the m_local var first */ |
9bbd7ba3 GRG |
226 | if (socket->m_local) |
227 | return GAddress_copy(socket->m_local); | |
228 | ||
9bf10d6b | 229 | /* else, if the socket is initialized, try getsockname */ |
9bbd7ba3 GRG |
230 | if (socket->m_fd == INVALID_SOCKET) |
231 | { | |
232 | socket->m_error = GSOCK_INVSOCK; | |
233 | return NULL; | |
234 | } | |
235 | ||
9bbd7ba3 GRG |
236 | if (getsockname(socket->m_fd, &addr, &size) == SOCKET_ERROR) |
237 | { | |
238 | socket->m_error = GSOCK_IOERR; | |
239 | return NULL; | |
240 | } | |
241 | ||
9bf10d6b GRG |
242 | /* got a valid address from getsockname, create a GAddress object */ |
243 | if ((address = GAddress_new()) == NULL) | |
9bbd7ba3 GRG |
244 | { |
245 | socket->m_error = GSOCK_MEMERR; | |
246 | return NULL; | |
247 | } | |
9bf10d6b GRG |
248 | |
249 | if ((err = _GAddress_translate_from(address, &addr, size)) != GSOCK_NOERROR) | |
9bbd7ba3 | 250 | { |
9bbd7ba3 | 251 | GAddress_destroy(address); |
85806dc2 | 252 | socket->m_error = err; |
9bbd7ba3 GRG |
253 | return NULL; |
254 | } | |
255 | ||
256 | return address; | |
257 | } | |
258 | ||
259 | GAddress *GSocket_GetPeer(GSocket *socket) | |
260 | { | |
261 | assert(socket != NULL); | |
262 | ||
9bf10d6b | 263 | /* try to get it from the m_peer var */ |
9bbd7ba3 GRG |
264 | if (socket->m_peer) |
265 | return GAddress_copy(socket->m_peer); | |
266 | ||
267 | return NULL; | |
268 | } | |
269 | ||
270 | /* Server specific parts */ | |
271 | ||
272 | /* GSocket_SetServer: | |
9bf10d6b GRG |
273 | * Sets up this socket as a server. The local address must have been |
274 | * set with GSocket_SetLocal() before GSocket_SetServer() is called. | |
275 | * Returns GSOCK_NOERROR on success, one of the following otherwise: | |
33ac7e6f | 276 | * |
9bf10d6b GRG |
277 | * Error codes: |
278 | * GSOCK_INVSOCK - the socket is in use. | |
279 | * GSOCK_INVADDR - the local address has not been set. | |
33ac7e6f | 280 | * GSOCK_IOERR - low-level error. |
9bbd7ba3 GRG |
281 | */ |
282 | GSocketError GSocket_SetServer(GSocket *sck) | |
283 | { | |
284 | u_long arg = 1; | |
285 | ||
286 | assert(sck != NULL); | |
287 | ||
9bf10d6b | 288 | /* must not be in use */ |
9bbd7ba3 GRG |
289 | if (sck->m_fd != INVALID_SOCKET) |
290 | { | |
291 | sck->m_error = GSOCK_INVSOCK; | |
292 | return GSOCK_INVSOCK; | |
293 | } | |
294 | ||
9bf10d6b | 295 | /* the local addr must have been set */ |
9bbd7ba3 GRG |
296 | if (!sck->m_local) |
297 | { | |
298 | sck->m_error = GSOCK_INVADDR; | |
299 | return GSOCK_INVADDR; | |
300 | } | |
301 | ||
302 | /* Initialize all fields */ | |
303 | sck->m_server = TRUE; | |
304 | sck->m_stream = TRUE; | |
305 | sck->m_oriented = TRUE; | |
306 | ||
307 | /* Create the socket */ | |
308 | sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_STREAM, 0); | |
9bbd7ba3 GRG |
309 | |
310 | if (sck->m_fd == INVALID_SOCKET) | |
311 | { | |
312 | sck->m_error = GSOCK_IOERR; | |
313 | return GSOCK_IOERR; | |
314 | } | |
315 | ||
483c6690 | 316 | ioctlsocket(sck->m_fd, FIONBIO, (u_long FAR *) &arg); |
75d684d9 | 317 | _GSocket_Enable_Events(sck); |
483c6690 | 318 | |
9bf10d6b GRG |
319 | /* Bind to the local address, |
320 | * retrieve the actual address bound, | |
321 | * and listen up to 5 connections. | |
322 | */ | |
323 | if ((bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0) || | |
324 | (getsockname(sck->m_fd, | |
325 | sck->m_local->m_addr, | |
378d2bd3 | 326 | (SOCKLEN_T *)&sck->m_local->m_len) != 0) || |
9bf10d6b | 327 | (listen(sck->m_fd, 5) != 0)) |
9bbd7ba3 GRG |
328 | { |
329 | closesocket(sck->m_fd); | |
330 | sck->m_fd = INVALID_SOCKET; | |
331 | sck->m_error = GSOCK_IOERR; | |
332 | return GSOCK_IOERR; | |
333 | } | |
334 | ||
335 | return GSOCK_NOERROR; | |
b661e675 | 336 | } |
9bbd7ba3 GRG |
337 | |
338 | /* GSocket_WaitConnection: | |
9bf10d6b GRG |
339 | * Waits for an incoming client connection. Returns a pointer to |
340 | * a GSocket object, or NULL if there was an error, in which case | |
341 | * the last error field will be updated for the calling GSocket. | |
342 | * | |
343 | * Error codes (set in the calling GSocket) | |
344 | * GSOCK_INVSOCK - the socket is not valid or not a server. | |
345 | * GSOCK_TIMEDOUT - timeout, no incoming connections. | |
346 | * GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking. | |
347 | * GSOCK_MEMERR - couldn't allocate memory. | |
33ac7e6f | 348 | * GSOCK_IOERR - low-level error. |
9bbd7ba3 GRG |
349 | */ |
350 | GSocket *GSocket_WaitConnection(GSocket *sck) | |
351 | { | |
352 | GSocket *connection; | |
85806dc2 GRG |
353 | struct sockaddr from; |
354 | SOCKLEN_T fromlen = sizeof(from); | |
355 | GSocketError err; | |
9bbd7ba3 GRG |
356 | u_long arg = 1; |
357 | ||
358 | assert(sck != NULL); | |
359 | ||
9bf10d6b | 360 | /* Reenable CONNECTION events */ |
75d684d9 GRG |
361 | sck->m_detected &= ~GSOCK_CONNECTION_FLAG; |
362 | ||
9bf10d6b | 363 | /* If the socket has already been created, we exit immediately */ |
9bbd7ba3 GRG |
364 | if (sck->m_fd == INVALID_SOCKET || !sck->m_server) |
365 | { | |
366 | sck->m_error = GSOCK_INVSOCK; | |
367 | return NULL; | |
368 | } | |
369 | ||
370 | /* Create a GSocket object for the new connection */ | |
371 | connection = GSocket_new(); | |
372 | ||
373 | if (!connection) | |
374 | { | |
375 | sck->m_error = GSOCK_MEMERR; | |
376 | return NULL; | |
377 | } | |
378 | ||
379 | /* Wait for a connection (with timeout) */ | |
380 | if (_GSocket_Input_Timeout(sck) == GSOCK_TIMEDOUT) | |
381 | { | |
382 | GSocket_destroy(connection); | |
383 | /* sck->m_error set by _GSocket_Input_Timeout */ | |
384 | return NULL; | |
385 | } | |
386 | ||
85806dc2 | 387 | connection->m_fd = accept(sck->m_fd, &from, &fromlen); |
9bbd7ba3 GRG |
388 | |
389 | if (connection->m_fd == INVALID_SOCKET) | |
390 | { | |
aa3981f2 GRG |
391 | if (WSAGetLastError() == WSAEWOULDBLOCK) |
392 | sck->m_error = GSOCK_WOULDBLOCK; | |
393 | else | |
394 | sck->m_error = GSOCK_IOERR; | |
395 | ||
9bbd7ba3 | 396 | GSocket_destroy(connection); |
9bbd7ba3 GRG |
397 | return NULL; |
398 | } | |
399 | ||
400 | /* Initialize all fields */ | |
401 | connection->m_server = FALSE; | |
402 | connection->m_stream = TRUE; | |
403 | connection->m_oriented = TRUE; | |
404 | ||
85806dc2 GRG |
405 | /* Setup the peer address field */ |
406 | connection->m_peer = GAddress_new(); | |
407 | if (!connection->m_peer) | |
408 | { | |
409 | GSocket_destroy(connection); | |
410 | sck->m_error = GSOCK_MEMERR; | |
411 | return NULL; | |
412 | } | |
413 | err = _GAddress_translate_from(connection->m_peer, &from, fromlen); | |
414 | if (err != GSOCK_NOERROR) | |
415 | { | |
416 | GAddress_destroy(connection->m_peer); | |
417 | GSocket_destroy(connection); | |
418 | sck->m_error = err; | |
419 | return NULL; | |
420 | } | |
421 | ||
cb421e53 | 422 | ioctlsocket(connection->m_fd, FIONBIO, (u_long FAR *) &arg); |
75d684d9 | 423 | _GSocket_Enable_Events(connection); |
cb421e53 | 424 | |
9bbd7ba3 GRG |
425 | return connection; |
426 | } | |
427 | ||
9bbd7ba3 GRG |
428 | /* Client specific parts */ |
429 | ||
430 | /* GSocket_Connect: | |
9bf10d6b GRG |
431 | * For stream (connection oriented) sockets, GSocket_Connect() tries |
432 | * to establish a client connection to a server using the peer address | |
433 | * as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the | |
434 | * connection has been succesfully established, or one of the error | |
435 | * codes listed below. Note that for nonblocking sockets, a return | |
436 | * value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection | |
437 | * request can be completed later; you should use GSocket_Select() | |
438 | * to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the | |
439 | * corresponding asynchronous events. | |
440 | * | |
441 | * For datagram (non connection oriented) sockets, GSocket_Connect() | |
442 | * just sets the peer address established with GSocket_SetPeer() as | |
443 | * default destination. | |
444 | * | |
445 | * Error codes: | |
446 | * GSOCK_INVSOCK - the socket is in use or not valid. | |
447 | * GSOCK_INVADDR - the peer address has not been established. | |
448 | * GSOCK_TIMEDOUT - timeout, the connection failed. | |
449 | * GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only) | |
450 | * GSOCK_MEMERR - couldn't allocate memory. | |
33ac7e6f | 451 | * GSOCK_IOERR - low-level error. |
9bbd7ba3 GRG |
452 | */ |
453 | GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream) | |
454 | { | |
9bf10d6b | 455 | int ret, err; |
9bbd7ba3 | 456 | u_long arg = 1; |
9bbd7ba3 GRG |
457 | |
458 | assert(sck != NULL); | |
459 | ||
9bf10d6b | 460 | /* Enable CONNECTION events (needed for nonblocking connections) */ |
75d684d9 GRG |
461 | sck->m_detected &= ~GSOCK_CONNECTION_FLAG; |
462 | ||
9bbd7ba3 GRG |
463 | if (sck->m_fd != INVALID_SOCKET) |
464 | { | |
465 | sck->m_error = GSOCK_INVSOCK; | |
466 | return GSOCK_INVSOCK; | |
467 | } | |
468 | ||
469 | if (!sck->m_peer) | |
470 | { | |
471 | sck->m_error = GSOCK_INVADDR; | |
472 | return GSOCK_INVADDR; | |
473 | } | |
474 | ||
9bf10d6b | 475 | /* Streamed or dgram socket? */ |
9bbd7ba3 GRG |
476 | sck->m_stream = (stream == GSOCK_STREAMED); |
477 | sck->m_oriented = TRUE; | |
478 | sck->m_server = FALSE; | |
ed2eb9af | 479 | sck->m_establishing = FALSE; |
9bbd7ba3 | 480 | |
9bbd7ba3 | 481 | /* Create the socket */ |
9bf10d6b GRG |
482 | sck->m_fd = socket(sck->m_peer->m_realfamily, |
483 | sck->m_stream? SOCK_STREAM : SOCK_DGRAM, 0); | |
9bbd7ba3 GRG |
484 | |
485 | if (sck->m_fd == INVALID_SOCKET) | |
486 | { | |
487 | sck->m_error = GSOCK_IOERR; | |
488 | return GSOCK_IOERR; | |
489 | } | |
490 | ||
483c6690 | 491 | ioctlsocket(sck->m_fd, FIONBIO, (u_long FAR *) &arg); |
75d684d9 | 492 | _GSocket_Enable_Events(sck); |
483c6690 | 493 | |
9bf10d6b | 494 | /* Connect it to the peer address, with a timeout (see below) */ |
9bbd7ba3 GRG |
495 | ret = connect(sck->m_fd, sck->m_peer->m_addr, sck->m_peer->m_len); |
496 | ||
497 | if (ret == SOCKET_ERROR) | |
498 | { | |
aa3981f2 GRG |
499 | err = WSAGetLastError(); |
500 | ||
501 | /* If connect failed with EWOULDBLOCK and the GSocket object | |
502 | * is in blocking mode, we select() for the specified timeout | |
503 | * checking for writability to see if the connection request | |
504 | * completes. | |
9bbd7ba3 | 505 | */ |
cb421e53 | 506 | if ((err == WSAEWOULDBLOCK) && (!sck->m_non_blocking)) |
9bbd7ba3 | 507 | { |
9bf10d6b GRG |
508 | err = _GSocket_Connect_Timeout(sck); |
509 | ||
510 | if (err != GSOCK_NOERROR) | |
9bbd7ba3 GRG |
511 | { |
512 | closesocket(sck->m_fd); | |
513 | sck->m_fd = INVALID_SOCKET; | |
9bf10d6b | 514 | /* sck->m_error is set in _GSocket_Connect_Timeout */ |
9bbd7ba3 | 515 | } |
9bf10d6b GRG |
516 | |
517 | return err; | |
9bbd7ba3 | 518 | } |
aa3981f2 GRG |
519 | |
520 | /* If connect failed with EWOULDBLOCK and the GSocket object | |
521 | * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK | |
522 | * (and return GSOCK_WOULDBLOCK) but we don't close the socket; | |
523 | * this way if the connection completes, a GSOCK_CONNECTION | |
524 | * event will be generated, if enabled. | |
525 | */ | |
cb421e53 | 526 | if ((err == WSAEWOULDBLOCK) && (sck->m_non_blocking)) |
9bbd7ba3 | 527 | { |
ed2eb9af | 528 | sck->m_establishing = TRUE; |
aa3981f2 GRG |
529 | sck->m_error = GSOCK_WOULDBLOCK; |
530 | return GSOCK_WOULDBLOCK; | |
9bbd7ba3 | 531 | } |
aa3981f2 GRG |
532 | |
533 | /* If connect failed with an error other than EWOULDBLOCK, | |
9bf10d6b | 534 | * then the call to GSocket_Connect() has failed. |
aa3981f2 GRG |
535 | */ |
536 | closesocket(sck->m_fd); | |
537 | sck->m_fd = INVALID_SOCKET; | |
538 | sck->m_error = GSOCK_IOERR; | |
539 | return GSOCK_IOERR; | |
9bbd7ba3 GRG |
540 | } |
541 | ||
542 | return GSOCK_NOERROR; | |
543 | } | |
544 | ||
9bf10d6b GRG |
545 | /* Datagram sockets */ |
546 | ||
547 | /* GSocket_SetNonOriented: | |
548 | * Sets up this socket as a non-connection oriented (datagram) socket. | |
549 | * Before using this function, the local address must have been set | |
550 | * with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR | |
551 | * on success, or one of the following otherwise. | |
552 | * | |
553 | * Error codes: | |
554 | * GSOCK_INVSOCK - the socket is in use. | |
555 | * GSOCK_INVADDR - the local address has not been set. | |
33ac7e6f | 556 | * GSOCK_IOERR - low-level error. |
9bf10d6b GRG |
557 | */ |
558 | GSocketError GSocket_SetNonOriented(GSocket *sck) | |
559 | { | |
560 | u_long arg = 1; | |
561 | ||
562 | assert(sck != NULL); | |
563 | ||
564 | if (sck->m_fd != INVALID_SOCKET) | |
565 | { | |
566 | sck->m_error = GSOCK_INVSOCK; | |
567 | return GSOCK_INVSOCK; | |
568 | } | |
569 | ||
570 | if (!sck->m_local) | |
571 | { | |
572 | sck->m_error = GSOCK_INVADDR; | |
573 | return GSOCK_INVADDR; | |
574 | } | |
575 | ||
576 | /* Initialize all fields */ | |
577 | sck->m_stream = FALSE; | |
578 | sck->m_server = FALSE; | |
579 | sck->m_oriented = FALSE; | |
580 | ||
581 | /* Create the socket */ | |
582 | sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_DGRAM, 0); | |
583 | ||
584 | if (sck->m_fd == INVALID_SOCKET) | |
585 | { | |
586 | sck->m_error = GSOCK_IOERR; | |
587 | return GSOCK_IOERR; | |
588 | } | |
589 | ||
590 | ioctlsocket(sck->m_fd, FIONBIO, (u_long FAR *) &arg); | |
591 | _GSocket_Enable_Events(sck); | |
592 | ||
593 | /* Bind to the local address, | |
594 | * and retrieve the actual address bound. | |
595 | */ | |
596 | if ((bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0) || | |
597 | (getsockname(sck->m_fd, | |
598 | sck->m_local->m_addr, | |
378d2bd3 | 599 | (SOCKLEN_T *)&sck->m_local->m_len) != 0)) |
9bf10d6b GRG |
600 | { |
601 | closesocket(sck->m_fd); | |
602 | sck->m_fd = INVALID_SOCKET; | |
603 | sck->m_error = GSOCK_IOERR; | |
604 | return GSOCK_IOERR; | |
605 | } | |
606 | ||
607 | return GSOCK_NOERROR; | |
608 | } | |
609 | ||
9bbd7ba3 GRG |
610 | /* Generic IO */ |
611 | ||
612 | /* Like recv(), send(), ... */ | |
613 | int GSocket_Read(GSocket *socket, char *buffer, int size) | |
614 | { | |
75d684d9 GRG |
615 | int ret; |
616 | ||
9bbd7ba3 GRG |
617 | assert(socket != NULL); |
618 | ||
9bf10d6b | 619 | /* Reenable INPUT events */ |
75d684d9 GRG |
620 | socket->m_detected &= ~GSOCK_INPUT_FLAG; |
621 | ||
9bbd7ba3 GRG |
622 | if (socket->m_fd == INVALID_SOCKET || socket->m_server) |
623 | { | |
624 | socket->m_error = GSOCK_INVSOCK; | |
625 | return -1; | |
626 | } | |
627 | ||
75d684d9 | 628 | /* If the socket is blocking, wait for data (with a timeout) */ |
9bbd7ba3 GRG |
629 | if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT) |
630 | return -1; | |
631 | ||
75d684d9 | 632 | /* Read the data */ |
9bbd7ba3 | 633 | if (socket->m_stream) |
75d684d9 | 634 | ret = _GSocket_Recv_Stream(socket, buffer, size); |
9bbd7ba3 | 635 | else |
75d684d9 GRG |
636 | ret = _GSocket_Recv_Dgram(socket, buffer, size); |
637 | ||
638 | if (ret == SOCKET_ERROR) | |
639 | { | |
75d684d9 | 640 | if (WSAGetLastError() != WSAEWOULDBLOCK) |
75d684d9 | 641 | socket->m_error = GSOCK_IOERR; |
75d684d9 | 642 | else |
75d684d9 | 643 | socket->m_error = GSOCK_WOULDBLOCK; |
9bf10d6b | 644 | return -1; |
75d684d9 GRG |
645 | } |
646 | ||
647 | return ret; | |
9bbd7ba3 GRG |
648 | } |
649 | ||
650 | int GSocket_Write(GSocket *socket, const char *buffer, int size) | |
651 | { | |
75d684d9 GRG |
652 | int ret; |
653 | ||
9bbd7ba3 GRG |
654 | assert(socket != NULL); |
655 | ||
656 | if (socket->m_fd == INVALID_SOCKET || socket->m_server) | |
657 | { | |
658 | socket->m_error = GSOCK_INVSOCK; | |
659 | return -1; | |
660 | } | |
661 | ||
75d684d9 | 662 | /* If the socket is blocking, wait for writability (with a timeout) */ |
9bbd7ba3 GRG |
663 | if (_GSocket_Output_Timeout(socket) == GSOCK_TIMEDOUT) |
664 | return -1; | |
665 | ||
9bf10d6b | 666 | /* Write the data */ |
9bbd7ba3 | 667 | if (socket->m_stream) |
75d684d9 | 668 | ret = _GSocket_Send_Stream(socket, buffer, size); |
9bbd7ba3 | 669 | else |
75d684d9 GRG |
670 | ret = _GSocket_Send_Dgram(socket, buffer, size); |
671 | ||
672 | if (ret == SOCKET_ERROR) | |
673 | { | |
674 | if (WSAGetLastError() != WSAEWOULDBLOCK) | |
675 | socket->m_error = GSOCK_IOERR; | |
676 | else | |
677 | socket->m_error = GSOCK_WOULDBLOCK; | |
678 | ||
9bf10d6b GRG |
679 | /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect |
680 | * does). Once the first OUTPUT event is received, users can assume | |
681 | * that the socket is writable until a read operation fails. Only then | |
682 | * will further OUTPUT events be posted. | |
683 | */ | |
75d684d9 GRG |
684 | socket->m_detected &= ~GSOCK_OUTPUT_FLAG; |
685 | return -1; | |
686 | } | |
687 | ||
688 | return ret; | |
9bbd7ba3 GRG |
689 | } |
690 | ||
483c6690 GRG |
691 | /* GSocket_Select: |
692 | * Polls the socket to determine its status. This function will | |
693 | * check for the events specified in the 'flags' parameter, and | |
694 | * it will return a mask indicating which operations can be | |
695 | * performed. This function won't block, regardless of the | |
9bf10d6b | 696 | * mode (blocking | nonblocking) of the socket. |
483c6690 GRG |
697 | */ |
698 | GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) | |
9bbd7ba3 | 699 | { |
ed2eb9af GRG |
700 | #if defined(wxUSE_GUI) && !wxUSE_GUI |
701 | ||
702 | GSocketEventFlags result = 0; | |
703 | fd_set readfds; | |
704 | fd_set writefds; | |
705 | fd_set exceptfds; | |
706 | static const struct timeval tv = { 0, 0 }; | |
707 | ||
9bbd7ba3 GRG |
708 | assert(socket != NULL); |
709 | ||
ed2eb9af GRG |
710 | FD_ZERO(&readfds); |
711 | FD_ZERO(&writefds); | |
712 | FD_ZERO(&exceptfds); | |
713 | FD_SET(socket->m_fd, &readfds); | |
714 | FD_SET(socket->m_fd, &writefds); | |
715 | FD_SET(socket->m_fd, &exceptfds); | |
716 | ||
717 | /* Check known state first */ | |
718 | result |= (GSOCK_CONNECTION_FLAG & socket->m_detected & flags); | |
719 | result |= (GSOCK_LOST_FLAG & socket->m_detected & flags); | |
720 | ||
721 | /* Try select now */ | |
722 | if (select(socket->m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0) | |
723 | return result; | |
724 | ||
725 | /* Check for readability */ | |
726 | if (FD_ISSET(socket->m_fd, &readfds)) | |
727 | { | |
728 | /* Assume that closure of the socket is always reported via exceptfds */ | |
729 | if (socket->m_server && socket->m_stream) | |
730 | result |= (GSOCK_CONNECTION_FLAG & flags); | |
731 | else | |
732 | result |= (GSOCK_INPUT_FLAG & flags); | |
733 | } | |
734 | ||
735 | /* Check for writability */ | |
736 | if (FD_ISSET(socket->m_fd, &writefds)) | |
737 | { | |
738 | if (socket->m_establishing && !socket->m_server) | |
739 | { | |
740 | result |= (GSOCK_CONNECTION_FLAG & flags); | |
741 | socket->m_establishing = FALSE; | |
742 | socket->m_detected |= GSOCK_CONNECTION_FLAG; | |
743 | } | |
744 | else | |
745 | result |= (GSOCK_OUTPUT_FLAG & flags); | |
746 | } | |
747 | ||
748 | /* Check for exceptions and errors */ | |
749 | if (FD_ISSET(socket->m_fd, &exceptfds)) | |
750 | { | |
751 | result |= (GSOCK_LOST_FLAG & flags); | |
752 | socket->m_establishing = FALSE; | |
753 | socket->m_detected = GSOCK_LOST_FLAG; | |
754 | } | |
755 | ||
756 | return result; | |
757 | ||
33ac7e6f | 758 | #else |
ed2eb9af GRG |
759 | |
760 | assert(socket != NULL); | |
ef57d866 | 761 | return flags & socket->m_detected; |
ed2eb9af GRG |
762 | |
763 | #endif /* !wxUSE_GUI */ | |
9bbd7ba3 GRG |
764 | } |
765 | ||
9bf10d6b | 766 | /* Attributes */ |
9bbd7ba3 GRG |
767 | |
768 | /* GSocket_SetNonBlocking: | |
9bf10d6b GRG |
769 | * Sets the socket to non-blocking mode. All IO calls will return |
770 | * immediately. | |
9bbd7ba3 | 771 | */ |
5c9eff30 | 772 | void GSocket_SetNonBlocking(GSocket *socket, int non_block) |
9bbd7ba3 GRG |
773 | { |
774 | assert(socket != NULL); | |
775 | ||
776 | socket->m_non_blocking = non_block; | |
777 | } | |
778 | ||
779 | /* GSocket_SetTimeout: | |
9bf10d6b GRG |
780 | * Sets the timeout for blocking calls. Time is expressed in |
781 | * milliseconds. | |
9bbd7ba3 | 782 | */ |
75d684d9 | 783 | void GSocket_SetTimeout(GSocket *socket, unsigned long millis) |
9bbd7ba3 GRG |
784 | { |
785 | assert(socket != NULL); | |
786 | ||
75d684d9 GRG |
787 | socket->m_timeout.tv_sec = (millis / 1000); |
788 | socket->m_timeout.tv_usec = (millis % 1000) * 1000; | |
9bbd7ba3 GRG |
789 | } |
790 | ||
791 | /* GSocket_GetError: | |
9bf10d6b GRG |
792 | * Returns the last error occured for this socket. Note that successful |
793 | * operations do not clear this back to GSOCK_NOERROR, so use it only | |
794 | * after an error. | |
9bbd7ba3 GRG |
795 | */ |
796 | GSocketError GSocket_GetError(GSocket *socket) | |
797 | { | |
798 | assert(socket != NULL); | |
799 | ||
800 | return socket->m_error; | |
801 | } | |
802 | ||
803 | /* Callbacks */ | |
804 | ||
9bf10d6b GRG |
805 | /* GSOCK_INPUT: |
806 | * There is data to be read in the input buffer. If, after a read | |
807 | * operation, there is still data available, the callback function will | |
808 | * be called again. | |
809 | * GSOCK_OUTPUT: | |
33ac7e6f | 810 | * The socket is available for writing. That is, the next write call |
9bf10d6b GRG |
811 | * won't block. This event is generated only once, when the connection is |
812 | * first established, and then only if a call failed with GSOCK_WOULDBLOCK, | |
813 | * when the output buffer empties again. This means that the app should | |
814 | * assume that it can write since the first OUTPUT event, and no more | |
815 | * OUTPUT events will be generated unless an error occurs. | |
816 | * GSOCK_CONNECTION: | |
817 | * Connection succesfully established, for client sockets, or incoming | |
818 | * client connection, for server sockets. Wait for this event (also watch | |
819 | * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call. | |
820 | * GSOCK_LOST: | |
821 | * The connection is lost (or a connection request failed); this could | |
822 | * be due to a failure, or due to the peer closing it gracefully. | |
9bbd7ba3 GRG |
823 | */ |
824 | ||
825 | /* GSocket_SetCallback: | |
483c6690 | 826 | * Enables the callbacks specified by 'flags'. Note that 'flags' |
9bbd7ba3 GRG |
827 | * may be a combination of flags OR'ed toghether, so the same |
828 | * callback function can be made to accept different events. | |
829 | * The callback function must have the following prototype: | |
830 | * | |
831 | * void function(GSocket *socket, GSocketEvent event, char *cdata) | |
832 | */ | |
483c6690 | 833 | void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags, |
9bbd7ba3 GRG |
834 | GSocketCallback callback, char *cdata) |
835 | { | |
836 | int count; | |
837 | ||
9bf10d6b | 838 | assert(socket != NULL); |
9bbd7ba3 GRG |
839 | |
840 | for (count = 0; count < GSOCK_MAX_EVENT; count++) | |
841 | { | |
483c6690 | 842 | if ((flags & (1 << count)) != 0) |
9bbd7ba3 GRG |
843 | { |
844 | socket->m_cbacks[count] = callback; | |
845 | socket->m_data[count] = cdata; | |
846 | } | |
847 | } | |
9bbd7ba3 GRG |
848 | } |
849 | ||
850 | /* GSocket_UnsetCallback: | |
483c6690 | 851 | * Disables all callbacks specified by 'flags', which may be a |
9bbd7ba3 GRG |
852 | * combination of flags OR'ed toghether. |
853 | */ | |
483c6690 | 854 | void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags) |
9bbd7ba3 | 855 | { |
9bf10d6b | 856 | int count; |
9bbd7ba3 GRG |
857 | |
858 | assert(socket != NULL); | |
859 | ||
860 | for (count = 0; count < GSOCK_MAX_EVENT; count++) | |
861 | { | |
483c6690 | 862 | if ((flags & (1 << count)) != 0) |
9bbd7ba3 GRG |
863 | { |
864 | socket->m_cbacks[count] = NULL; | |
75d684d9 | 865 | socket->m_data[count] = NULL; |
9bbd7ba3 GRG |
866 | } |
867 | } | |
9bbd7ba3 GRG |
868 | } |
869 | ||
70988afb | 870 | /* Internals (IO) */ |
9bbd7ba3 GRG |
871 | |
872 | /* _GSocket_Input_Timeout: | |
873 | * For blocking sockets, wait until data is available or | |
874 | * until timeout ellapses. | |
875 | */ | |
876 | GSocketError _GSocket_Input_Timeout(GSocket *socket) | |
877 | { | |
878 | fd_set readfds; | |
879 | ||
cb421e53 | 880 | if (!socket->m_non_blocking) |
9bbd7ba3 GRG |
881 | { |
882 | FD_ZERO(&readfds); | |
883 | FD_SET(socket->m_fd, &readfds); | |
884 | if (select(0, &readfds, NULL, NULL, &socket->m_timeout) == 0) | |
885 | { | |
886 | socket->m_error = GSOCK_TIMEDOUT; | |
887 | return GSOCK_TIMEDOUT; | |
888 | } | |
889 | } | |
890 | return GSOCK_NOERROR; | |
891 | } | |
892 | ||
893 | /* _GSocket_Output_Timeout: | |
894 | * For blocking sockets, wait until data can be sent without | |
895 | * blocking or until timeout ellapses. | |
896 | */ | |
897 | GSocketError _GSocket_Output_Timeout(GSocket *socket) | |
898 | { | |
899 | fd_set writefds; | |
900 | ||
cb421e53 | 901 | if (!socket->m_non_blocking) |
9bbd7ba3 GRG |
902 | { |
903 | FD_ZERO(&writefds); | |
904 | FD_SET(socket->m_fd, &writefds); | |
905 | if (select(0, NULL, &writefds, NULL, &socket->m_timeout) == 0) | |
906 | { | |
907 | socket->m_error = GSOCK_TIMEDOUT; | |
908 | return GSOCK_TIMEDOUT; | |
909 | } | |
910 | } | |
911 | return GSOCK_NOERROR; | |
912 | } | |
913 | ||
9bf10d6b GRG |
914 | /* _GSocket_Connect_Timeout: |
915 | * For blocking sockets, wait until the connection is | |
916 | * established or fails, or until timeout ellapses. | |
917 | */ | |
918 | GSocketError _GSocket_Connect_Timeout(GSocket *socket) | |
919 | { | |
920 | fd_set writefds; | |
921 | fd_set exceptfds; | |
922 | ||
5330a869 GRG |
923 | FD_ZERO(&writefds); |
924 | FD_ZERO(&exceptfds); | |
925 | FD_SET(socket->m_fd, &writefds); | |
926 | FD_SET(socket->m_fd, &exceptfds); | |
927 | if (select(0, NULL, &writefds, &exceptfds, &socket->m_timeout) == 0) | |
9bf10d6b | 928 | { |
5330a869 GRG |
929 | socket->m_error = GSOCK_TIMEDOUT; |
930 | return GSOCK_TIMEDOUT; | |
9bf10d6b GRG |
931 | } |
932 | if (!FD_ISSET(socket->m_fd, &writefds)) | |
933 | { | |
934 | socket->m_error = GSOCK_IOERR; | |
935 | return GSOCK_IOERR; | |
936 | } | |
937 | ||
938 | return GSOCK_NOERROR; | |
939 | } | |
940 | ||
9bbd7ba3 GRG |
941 | int _GSocket_Recv_Stream(GSocket *socket, char *buffer, int size) |
942 | { | |
75d684d9 | 943 | return recv(socket->m_fd, buffer, size, 0); |
9bbd7ba3 GRG |
944 | } |
945 | ||
946 | int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size) | |
947 | { | |
948 | struct sockaddr from; | |
75d684d9 | 949 | SOCKLEN_T fromlen = sizeof(from); |
9bbd7ba3 | 950 | int ret; |
85806dc2 | 951 | GSocketError err; |
9bbd7ba3 | 952 | |
9bbd7ba3 GRG |
953 | ret = recvfrom(socket->m_fd, buffer, size, 0, &from, &fromlen); |
954 | ||
955 | if (ret == SOCKET_ERROR) | |
75d684d9 | 956 | return SOCKET_ERROR; |
9bbd7ba3 GRG |
957 | |
958 | /* Translate a system address into a GSocket address */ | |
959 | if (!socket->m_peer) | |
960 | { | |
961 | socket->m_peer = GAddress_new(); | |
962 | if (!socket->m_peer) | |
963 | { | |
964 | socket->m_error = GSOCK_MEMERR; | |
965 | return -1; | |
966 | } | |
967 | } | |
85806dc2 GRG |
968 | err = _GAddress_translate_from(socket->m_peer, &from, fromlen); |
969 | if (err != GSOCK_NOERROR) | |
9bbd7ba3 | 970 | { |
cb421e53 | 971 | GAddress_destroy(socket->m_peer); |
85806dc2 GRG |
972 | socket->m_peer = NULL; |
973 | socket->m_error = err; | |
9bbd7ba3 GRG |
974 | return -1; |
975 | } | |
976 | ||
977 | return ret; | |
978 | } | |
979 | ||
980 | int _GSocket_Send_Stream(GSocket *socket, const char *buffer, int size) | |
981 | { | |
75d684d9 | 982 | return send(socket->m_fd, buffer, size, 0); |
9bbd7ba3 GRG |
983 | } |
984 | ||
985 | int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size) | |
986 | { | |
987 | struct sockaddr *addr; | |
988 | int len, ret; | |
85806dc2 | 989 | GSocketError err; |
9bbd7ba3 GRG |
990 | |
991 | if (!socket->m_peer) | |
992 | { | |
993 | socket->m_error = GSOCK_INVADDR; | |
994 | return -1; | |
995 | } | |
996 | ||
85806dc2 GRG |
997 | err = _GAddress_translate_to(socket->m_peer, &addr, &len); |
998 | if (err != GSOCK_NOERROR) | |
9bbd7ba3 | 999 | { |
85806dc2 | 1000 | socket->m_error = err; |
9bbd7ba3 GRG |
1001 | return -1; |
1002 | } | |
1003 | ||
1004 | ret = sendto(socket->m_fd, buffer, size, 0, addr, len); | |
1005 | ||
1006 | /* Frees memory allocated by _GAddress_translate_to */ | |
1007 | free(addr); | |
1008 | ||
9bbd7ba3 GRG |
1009 | return ret; |
1010 | } | |
1011 | ||
1012 | ||
1013 | /* | |
1014 | * ------------------------------------------------------------------------- | |
1015 | * GAddress | |
1016 | * ------------------------------------------------------------------------- | |
1017 | */ | |
1018 | ||
032d5581 GRG |
1019 | /* CHECK_ADDRESS verifies that the current address family is either |
1020 | * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it | |
1021 | * initalizes it to be a GSOCK_*family*. In other cases, it returns | |
1022 | * an appropiate error code. | |
1023 | * | |
1024 | * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error. | |
9bbd7ba3 | 1025 | */ |
032d5581 | 1026 | #define CHECK_ADDRESS(address, family) \ |
9bbd7ba3 GRG |
1027 | { \ |
1028 | if (address->m_family == GSOCK_NOFAMILY) \ | |
1029 | if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \ | |
1030 | return address->m_error; \ | |
1031 | if (address->m_family != GSOCK_##family) \ | |
032d5581 GRG |
1032 | { \ |
1033 | address->m_error = GSOCK_INVADDR; \ | |
1034 | return GSOCK_INVADDR; \ | |
1035 | } \ | |
1036 | } | |
1037 | ||
1038 | #define CHECK_ADDRESS_RETVAL(address, family, retval) \ | |
1039 | { \ | |
1040 | if (address->m_family == GSOCK_NOFAMILY) \ | |
1041 | if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \ | |
1042 | return retval; \ | |
1043 | if (address->m_family != GSOCK_##family) \ | |
9bbd7ba3 GRG |
1044 | { \ |
1045 | address->m_error = GSOCK_INVADDR; \ | |
1046 | return retval; \ | |
1047 | } \ | |
1048 | } | |
1049 | ||
032d5581 | 1050 | |
da051b23 | 1051 | GAddress *GAddress_new(void) |
9bbd7ba3 GRG |
1052 | { |
1053 | GAddress *address; | |
1054 | ||
1055 | if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL) | |
1056 | return NULL; | |
1057 | ||
1058 | address->m_family = GSOCK_NOFAMILY; | |
1059 | address->m_addr = NULL; | |
1060 | address->m_len = 0; | |
1061 | ||
1062 | return address; | |
1063 | } | |
1064 | ||
1065 | GAddress *GAddress_copy(GAddress *address) | |
1066 | { | |
1067 | GAddress *addr2; | |
1068 | ||
1069 | assert(address != NULL); | |
1070 | ||
1071 | if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL) | |
1072 | return NULL; | |
1073 | ||
1074 | memcpy(addr2, address, sizeof(GAddress)); | |
1075 | ||
1076 | if (address->m_addr) | |
1077 | { | |
1078 | addr2->m_addr = (struct sockaddr *) malloc(addr2->m_len); | |
1079 | if (addr2->m_addr == NULL) | |
1080 | { | |
1081 | free(addr2); | |
1082 | return NULL; | |
1083 | } | |
1084 | memcpy(addr2->m_addr, address->m_addr, addr2->m_len); | |
1085 | } | |
1086 | ||
1087 | return addr2; | |
1088 | } | |
1089 | ||
1090 | void GAddress_destroy(GAddress *address) | |
1091 | { | |
1092 | assert(address != NULL); | |
1093 | ||
29c25a8e GRG |
1094 | if (address->m_addr) |
1095 | free(address->m_addr); | |
1096 | ||
9bbd7ba3 GRG |
1097 | free(address); |
1098 | } | |
1099 | ||
1100 | void GAddress_SetFamily(GAddress *address, GAddressType type) | |
1101 | { | |
1102 | assert(address != NULL); | |
1103 | ||
1104 | address->m_family = type; | |
1105 | } | |
1106 | ||
1107 | GAddressType GAddress_GetFamily(GAddress *address) | |
1108 | { | |
1109 | assert(address != NULL); | |
1110 | ||
1111 | return address->m_family; | |
1112 | } | |
1113 | ||
1114 | GSocketError _GAddress_translate_from(GAddress *address, | |
1115 | struct sockaddr *addr, int len) | |
1116 | { | |
1117 | address->m_realfamily = addr->sa_family; | |
1118 | switch (addr->sa_family) | |
1119 | { | |
1120 | case AF_INET: | |
1121 | address->m_family = GSOCK_INET; | |
1122 | break; | |
1123 | case AF_UNIX: | |
1124 | address->m_family = GSOCK_UNIX; | |
1125 | break; | |
1126 | #ifdef AF_INET6 | |
1127 | case AF_INET6: | |
1128 | address->m_family = GSOCK_INET6; | |
1129 | break; | |
1130 | #endif | |
1131 | default: | |
1132 | { | |
1133 | address->m_error = GSOCK_INVOP; | |
1134 | return GSOCK_INVOP; | |
1135 | } | |
1136 | } | |
1137 | ||
1138 | if (address->m_addr) | |
1139 | free(address->m_addr); | |
1140 | ||
1141 | address->m_len = len; | |
1142 | address->m_addr = (struct sockaddr *) malloc(len); | |
1143 | ||
1144 | if (address->m_addr == NULL) | |
1145 | { | |
1146 | address->m_error = GSOCK_MEMERR; | |
1147 | return GSOCK_MEMERR; | |
1148 | } | |
1149 | memcpy(address->m_addr, addr, len); | |
1150 | ||
1151 | return GSOCK_NOERROR; | |
1152 | } | |
1153 | ||
1154 | GSocketError _GAddress_translate_to(GAddress *address, | |
1155 | struct sockaddr **addr, int *len) | |
1156 | { | |
1157 | if (!address->m_addr) | |
1158 | { | |
1159 | address->m_error = GSOCK_INVADDR; | |
1160 | return GSOCK_INVADDR; | |
1161 | } | |
1162 | ||
1163 | *len = address->m_len; | |
1164 | *addr = (struct sockaddr *) malloc(address->m_len); | |
1165 | if (*addr == NULL) | |
1166 | { | |
1167 | address->m_error = GSOCK_MEMERR; | |
1168 | return GSOCK_MEMERR; | |
1169 | } | |
1170 | ||
1171 | memcpy(*addr, address->m_addr, address->m_len); | |
1172 | return GSOCK_NOERROR; | |
1173 | } | |
1174 | ||
1175 | /* | |
1176 | * ------------------------------------------------------------------------- | |
1177 | * Internet address family | |
1178 | * ------------------------------------------------------------------------- | |
1179 | */ | |
1180 | ||
1181 | GSocketError _GAddress_Init_INET(GAddress *address) | |
1182 | { | |
9bf10d6b | 1183 | address->m_len = sizeof(struct sockaddr_in); |
9bbd7ba3 GRG |
1184 | address->m_addr = (struct sockaddr *) malloc(address->m_len); |
1185 | if (address->m_addr == NULL) | |
1186 | { | |
1187 | address->m_error = GSOCK_MEMERR; | |
1188 | return GSOCK_MEMERR; | |
1189 | } | |
1190 | ||
9bbd7ba3 GRG |
1191 | address->m_family = GSOCK_INET; |
1192 | address->m_realfamily = PF_INET; | |
1193 | ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET; | |
9bf10d6b | 1194 | ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY; |
9bbd7ba3 GRG |
1195 | |
1196 | return GSOCK_NOERROR; | |
1197 | } | |
1198 | ||
1199 | GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname) | |
1200 | { | |
1201 | struct hostent *he; | |
1202 | struct in_addr *addr; | |
1203 | ||
1204 | assert(address != NULL); | |
1205 | ||
032d5581 | 1206 | CHECK_ADDRESS(address, INET); |
9bbd7ba3 GRG |
1207 | |
1208 | addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr); | |
1209 | ||
1210 | addr->s_addr = inet_addr(hostname); | |
b661e675 | 1211 | |
9bbd7ba3 GRG |
1212 | /* If it is a numeric host name, convert it now */ |
1213 | if (addr->s_addr == INADDR_NONE) | |
1214 | { | |
1215 | struct in_addr *array_addr; | |
1216 | ||
1217 | /* It is a real name, we solve it */ | |
1218 | if ((he = gethostbyname(hostname)) == NULL) | |
1219 | { | |
9bf10d6b | 1220 | /* addr->s_addr = INADDR_NONE just done by inet_addr() above */ |
9bbd7ba3 GRG |
1221 | address->m_error = GSOCK_NOHOST; |
1222 | return GSOCK_NOHOST; | |
1223 | } | |
1224 | array_addr = (struct in_addr *) *(he->h_addr_list); | |
1225 | addr->s_addr = array_addr[0].s_addr; | |
1226 | } | |
1227 | return GSOCK_NOERROR; | |
1228 | } | |
1229 | ||
9bf10d6b GRG |
1230 | GSocketError GAddress_INET_SetAnyAddress(GAddress *address) |
1231 | { | |
1232 | return GAddress_INET_SetHostAddress(address, INADDR_ANY); | |
1233 | } | |
1234 | ||
9bbd7ba3 GRG |
1235 | GSocketError GAddress_INET_SetHostAddress(GAddress *address, |
1236 | unsigned long hostaddr) | |
1237 | { | |
1238 | struct in_addr *addr; | |
1239 | ||
1240 | assert(address != NULL); | |
1241 | ||
032d5581 | 1242 | CHECK_ADDRESS(address, INET); |
9bbd7ba3 GRG |
1243 | |
1244 | addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr); | |
1245 | addr->s_addr = hostaddr; | |
1246 | ||
1247 | return GSOCK_NOERROR; | |
1248 | } | |
1249 | ||
1250 | GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port, | |
1251 | const char *protocol) | |
1252 | { | |
1253 | struct servent *se; | |
1254 | struct sockaddr_in *addr; | |
1255 | ||
1256 | assert(address != NULL); | |
032d5581 | 1257 | CHECK_ADDRESS(address, INET); |
9bbd7ba3 GRG |
1258 | |
1259 | if (!port) | |
1260 | { | |
1261 | address->m_error = GSOCK_INVPORT; | |
9bf10d6b | 1262 | return GSOCK_INVPORT; |
9bbd7ba3 | 1263 | } |
b661e675 | 1264 | |
9bbd7ba3 GRG |
1265 | se = getservbyname(port, protocol); |
1266 | if (!se) | |
1267 | { | |
1268 | if (isdigit(port[0])) | |
1269 | { | |
1270 | int port_int; | |
1271 | ||
1272 | port_int = atoi(port); | |
1273 | addr = (struct sockaddr_in *)address->m_addr; | |
aa3981f2 | 1274 | addr->sin_port = htons((u_short) port_int); |
9bbd7ba3 GRG |
1275 | return GSOCK_NOERROR; |
1276 | } | |
1277 | ||
1278 | address->m_error = GSOCK_INVPORT; | |
1279 | return GSOCK_INVPORT; | |
1280 | } | |
1281 | ||
1282 | addr = (struct sockaddr_in *)address->m_addr; | |
1283 | addr->sin_port = se->s_port; | |
1284 | ||
1285 | return GSOCK_NOERROR; | |
1286 | } | |
1287 | ||
1288 | GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port) | |
1289 | { | |
1290 | struct sockaddr_in *addr; | |
1291 | ||
1292 | assert(address != NULL); | |
032d5581 | 1293 | CHECK_ADDRESS(address, INET); |
b661e675 | 1294 | |
9bbd7ba3 GRG |
1295 | addr = (struct sockaddr_in *)address->m_addr; |
1296 | addr->sin_port = htons(port); | |
1297 | ||
1298 | return GSOCK_NOERROR; | |
1299 | } | |
1300 | ||
1301 | GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf) | |
1302 | { | |
1303 | struct hostent *he; | |
1304 | char *addr_buf; | |
1305 | struct sockaddr_in *addr; | |
1306 | ||
b661e675 | 1307 | assert(address != NULL); |
032d5581 | 1308 | CHECK_ADDRESS(address, INET); |
9bbd7ba3 GRG |
1309 | |
1310 | addr = (struct sockaddr_in *)address->m_addr; | |
1311 | addr_buf = (char *)&(addr->sin_addr); | |
1312 | ||
1313 | he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET); | |
1314 | if (he == NULL) | |
1315 | { | |
1316 | address->m_error = GSOCK_NOHOST; | |
1317 | return GSOCK_NOHOST; | |
1318 | } | |
1319 | ||
1320 | strncpy(hostname, he->h_name, sbuf); | |
1321 | ||
1322 | return GSOCK_NOERROR; | |
1323 | } | |
1324 | ||
1325 | unsigned long GAddress_INET_GetHostAddress(GAddress *address) | |
1326 | { | |
1327 | struct sockaddr_in *addr; | |
1328 | ||
b661e675 | 1329 | assert(address != NULL); |
032d5581 | 1330 | CHECK_ADDRESS_RETVAL(address, INET, 0); |
9bbd7ba3 GRG |
1331 | |
1332 | addr = (struct sockaddr_in *)address->m_addr; | |
1333 | ||
1334 | return addr->sin_addr.s_addr; | |
1335 | } | |
1336 | ||
1337 | unsigned short GAddress_INET_GetPort(GAddress *address) | |
1338 | { | |
1339 | struct sockaddr_in *addr; | |
1340 | ||
b661e675 | 1341 | assert(address != NULL); |
032d5581 | 1342 | CHECK_ADDRESS_RETVAL(address, INET, 0); |
9bbd7ba3 GRG |
1343 | |
1344 | addr = (struct sockaddr_in *)address->m_addr; | |
1345 | return ntohs(addr->sin_port); | |
1346 | } | |
1347 | ||
1348 | /* | |
1349 | * ------------------------------------------------------------------------- | |
1350 | * Unix address family | |
1351 | * ------------------------------------------------------------------------- | |
1352 | */ | |
1353 | ||
1354 | GSocketError _GAddress_Init_UNIX(GAddress *address) | |
1355 | { | |
1356 | assert (address != NULL); | |
1357 | address->m_error = GSOCK_INVADDR; | |
1358 | return GSOCK_INVADDR; | |
1359 | } | |
1360 | ||
1361 | GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path) | |
1362 | { | |
1363 | assert (address != NULL); | |
1364 | address->m_error = GSOCK_INVADDR; | |
1365 | return GSOCK_INVADDR; | |
1366 | } | |
1367 | ||
1368 | GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf) | |
1369 | { | |
1370 | assert (address != NULL); | |
1371 | address->m_error = GSOCK_INVADDR; | |
1372 | return GSOCK_INVADDR; | |
1373 | } | |
1374 | ||
a497618a | 1375 | #else /* !wxUSE_SOCKETS */ |
9bbd7ba3 | 1376 | |
33ac7e6f | 1377 | /* |
9bf10d6b | 1378 | * Translation unit shouldn't be empty, so include this typedef to make the |
a497618a VZ |
1379 | * compiler (VC++ 6.0, for example) happy |
1380 | */ | |
1381 | typedef (*wxDummy)(); | |
9bbd7ba3 | 1382 | |
a497618a | 1383 | #endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */ |