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
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
|
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifndef __GSSOCKET_H__
#define __GSSOCKET_H__
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#include "gsPlatform.h"
#ifdef __cplusplus
extern "C" {
#endif
// GSI Cross Platform Socket Wrapper
// this should all inline and optimize out... I hope
// if they somehow get really complex, we need to move the implementation into the .c file.
#if defined _PS3 || defined _PSP
#define gsiSocketIsError(theReturnValue) ((theReturnValue) < 0)
#define gsiSocketIsNotError(theReturnValue) ((theReturnValue) >= 0)
#else
#define gsiSocketIsError(theReturnValue) ((theReturnValue) == -1)
#define gsiSocketIsNotError(theReturnValue) ((theReturnValue) != -1)
#endif
#if (0)
// to do for Saad and Martin, move towards this and phase out the #define jungle.
// we will trade a little speed for a lot of portability, and stability
// also out debug libs will assert all params comming in.
typedef enum
{
GS_SOCKERR_NONE = 0,
GS_SOCKERR_EWOULDBLOCK,
GS_SOCKERR_EINPROGRESS,
GS_SOCKERR_EALREADY,
GS_SOCKERR_ENOTSOCK,
GS_SOCKERR_EDESTADDRREQ,
GS_SOCKERR_EMSGSIZE,
GS_SOCKERR_EPROTOTYPE,
GS_SOCKERR_ENOPROTOOPT ,
GS_SOCKERR_EPROTONOSUPPORT ,
GS_SOCKERR_ESOCKTNOSUPPORT,
GS_SOCKERR_EOPNOTSUPP ,
GS_SOCKERR_EPFNOSUPPORT,
GS_SOCKERR_EAFNOSUPPORT,
GS_SOCKERR_EADDRINUSE ,
GS_SOCKERR_EADDRNOTAVAIL ,
GS_SOCKERR_ENETDOWN ,
GS_SOCKERR_ENETUNREACH ,
GS_SOCKERR_ENETRESET,
GS_SOCKERR_ECONNABORTED,
GS_SOCKERR_ECONNRESET ,
GS_SOCKERR_ENOBUFS ,
GS_SOCKERR_EISCONN ,
GS_SOCKERR_ENOTCONN,
GS_SOCKERR_ESHUTDOWN,
GS_SOCKERR_ETOOMANYREFS ,
GS_SOCKERR_ETIMEDOUT,
GS_SOCKERR_ECONNREFUSED,
GS_SOCKERR_ELOOP,
GS_SOCKERR_ENAMETOOLONG,
GS_SOCKERR_EHOSTDOWN ,
GS_SOCKERR_EHOSTUNREACH ,
GS_SOCKERR_ENOTEMPTY ,
GS_SOCKERR_EPROCLIM ,
GS_SOCKERR_EUSERS ,
GS_SOCKERR_EDQUOT ,
GS_SOCKERR_ESTALE ,
GS_SOCKERR_EREMOTE ,
GS_SOCKERR_EINVAL ,
GS_SOCKERR_COUNT ,
} GS_SOCKET_ERROR;
#define gsiSocketIsError(theReturnValue) ((theReturnValue) != GS_SOCKERR_NONE)
#define gsiSocketIsNotError(theReturnValue) ((theReturnValue) == GS_SOCKERR_NONE)
typedef int GSI_SOCKET;
// mj - may need to pragma pack this, otherwise, it will pad after u_short
typedef struct
{
// this is the same as the "default" winsocks
u_short sa_family; /* address family */
char sa_data[14]; /* up to 14 bytes of direct address */
} GS_SOCKADDR;
GSI_SOCKET gsiSocketAccept (GSI_SOCKET sock, GS_SOCKADDR* addr, int* len);
GS_SOCKET_ERROR gsiSocketSocket (int pf, int type, int protocol);
GS_SOCKET_ERROR gsiSocketClosesocket(GSI_SOCKET sock);
GS_SOCKET_ERROR gsiSocketShutdown (GSI_SOCKET sock, int how);
GS_SOCKET_ERROR gsiSocketBind (GSI_SOCKET sock, const GS_SOCKADDR* addr, int len);
GS_SOCKET_ERROR gsiSocketConnect (GSI_SOCKET sock, const GS_SOCKADDR* addr, int len);
GS_SOCKET_ERROR gsiSocketListen (GSI_SOCKET sock, int backlog);
GS_SOCKET_ERROR gsiSocketRecv (GSI_SOCKET sock, char* buf, int len, int flags);
GS_SOCKET_ERROR gsiSocketRecvfrom (GSI_SOCKET sock, char* buf, int len, int flags, GS_SOCKADDR* addr, int* fromlen);
GS_SOCKET_ERROR gsiSocketSend (GSI_SOCKET sock, const char* buf, int len, int flags);
GS_SOCKET_ERROR gsiSocketSendto (GSI_SOCKET sock, const char* buf, int len, int flags, const GS_SOCKADDR* addr, int tolen);
GS_SOCKET_ERROR gsiSocketGetsockopt (GSI_SOCKET sock, int level, int optname, char* optval, int* optlen);
GS_SOCKET_ERROR gsiSocketSetsockopt (GSI_SOCKET sock, int level, int optname, const char* optval, int optlen);
GS_SOCKET_ERROR gsiSocketGetsockname(GSI_SOCKET sock, GS_SOCKADDR* addr, int* len);
GS_SOCKET_ERROR GOAGetLastError (GSI_SOCKET sock);
gsiSocketGethostbyaddr(a,l,t) SOC_GetHostByAddr(a,l,t)
gsiSocketGethostbyname(n) SOC_GetHostByName(n)
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Types
#ifndef INADDR_NONE
#define INADDR_NONE 0xffffffff
#endif
#ifndef INVALID_SOCKET
#define INVALID_SOCKET (-1)
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Platform socket types
#if defined(_PSP)
#define AF_INET SCE_NET_INET_AF_INET
#define SOCK_STREAM SCE_NET_INET_SOCK_STREAM
#define SOCK_DGRAM SCE_NET_INET_SOCK_DGRAM
#define SOCK_RAW SCE_NET_INET_SOCK_RAW
#define INADDR_ANY SCE_NET_INET_INADDR_ANY
#define SOL_SOCKET SCE_NET_INET_SOL_SOCKET
#define SO_SNDBUF SCE_NET_INET_SO_SNDBUF
#define SO_RCVBUF SCE_NET_INET_SO_RCVBUF
#define SO_NBIO SCE_NET_INET_SO_NBIO
#define SO_BROADCAST SCE_NET_INET_SO_BROADCAST
#define SO_KEEPALIVE SCE_NET_INET_SO_KEEPALIVE
#define SO_REUSEADDR SCE_NET_INET_SO_REUSEADDR
#define IPPROTO_TCP SCE_NET_INET_IPPROTO_TCP // protocol defined by SOCK_STREAM
#define IPPROTO_UDP SCE_NET_INET_IPPROTO_UDP // protocol defined by SOCK_DGRAM
#define IPPROTO_ICMP SCE_NET_INET_IPPROTO_ICMP // protocol for ICMP pings
// structures
#define in_addr SceNetInetInAddr
#define sockaddr_in SceNetInetSockaddrIn
#define sockaddr SceNetInetSockaddr
// Remove FD types set in sys/types.h
// Replace with types in pspnet/sys/select.h
#if defined(_SYS_TYPES_H) && defined(FD_SET)
#undef fd_set
#undef FD_SET
#undef FD_CLR
#undef FD_ZERO
#undef timeval
#undef FD_SETSIZE
#endif
#define fd_set SceNetInetFdSet
#define timeval SceNetInetTimeval
#define FD_SET SceNetInetFD_SET
#define FD_CLR SceNetInetFD_CLR
#define FD_ZERO SceNetInetFD_ZERO
#define FD_SETSIZE SCE_NET_INET_FD_SETSIZE
// functions
#define htonl sceNetHtonl
#define ntohl sceNetNtohl
#define htons sceNetHtons
#define ntohs sceNetNtohs
#define socket sceNetInetSocket
#define shutdown sceNetInetShutdown
#define closesocket sceNetInetClose
#define setsockopt sceNetInetSetsockopt
#define getsockopt(s, l, on, ov, ol) sceNetInetGetsockopt(s, l, on, ov, (SceNetInetSocklen_t *)ol)
#define bind sceNetInetBind
#define select sceNetInetSelect
#define connect sceNetInetConnect
#define listen sceNetInetListen
#define accept(s,a,l) sceNetInetAccept(s, a, (SceNetInetSocklen_t *)l)
#define send sceNetInetSend
#define recv sceNetInetRecv
#define sendto sceNetInetSendto
#define recvfrom(s, b, l, f, fr, fl) sceNetInetRecvfrom(s, b, l, f, fr, (SceNetInetSocklen_t *)fl)
#define inet_addr sceNetInetInetAddr
// This is not the correct function for gethostname, it should get the string name of the local host
// not the sockaddr_in struct
#define gethostname // sceNetInetGetsockname
#define getsockname(s,n,l) sceNetInetGetsockname(s, n, (SceNetInetSocklen_t *)l)
#define GOAGetLastError(s) sceNetInetGetErrno()
// hostent support
struct hostent
{
char* h_name;
char** h_aliases;
gsi_u16 h_addrtype; // AF_INET
gsi_u16 h_length;
char** h_addr_list;
};
#define gethostbyname gsSocketGetHostByName
#define inet_ntoa gsSocketInetNtoa
#define GSI_RESOLVER_TIMEOUT (5*1000*1000) // 5 seconds
#define GSI_RESOLVER_RETRY (2)
struct hostent* gsSocketGetHostByName(const char* name); // gsSocketPSP.c
const char* gsSocketInetNtoa(struct in_addr in);
#endif // _PSP
// XBOX doesn't have host lookup
#if defined(_XBOX)
#if defined(_X360)
// hostent support
struct hostent
{
char* h_name;
char** h_aliases;
gsi_u16 h_addrtype; // AF_INET
gsi_u16 h_length;
char** h_addr_list;
};
typedef struct hostent HOSTENT;
struct hostent * gethostbyname(const char* name);
#else
typedef int HOSTENT;
#endif
char * inet_ntoa(IN_ADDR in_addr);
#endif
#if defined(SN_SYSTEMS)
#define IPPROTO_TCP PF_INET
#define IPPROTO_UDP PF_INET
#define FD_SETSIZE SN_MAX_SOCKETS
#endif
// SOCKET ERROR CODES
#if defined(_REVOLUTION) //not sure if Wii uses this or _REV
#define WSAEWOULDBLOCK SO_EWOULDBLOCK
#define WSAEINPROGRESS SO_EINPROGRESS
#define WSAEALREADY SO_EALREADY
#define WSAENOTSOCK SO_ENOTSOCK
#define WSAEDESTADDRREQ SO_EDESTADDRREQ
#define WSAEMSGSIZE SO_EMSGSIZE
#define WSAEPROTOTYPE SO_EPROTOTYPE
#define WSAENOPROTOOPT SO_ENOPROTOOPT
#define WSAEPROTONOSUPPORT SO_EPROTONOSUPPORT
#define WSAEOPNOTSUPP SO_EOPNOTSUPP
#define WSAEAFNOSUPPORT SO_EAFNOSUPPORT
#define WSAEADDRINUSE SO_EADDRINUSE
#define WSAEADDRNOTAVAIL SO_EADDRNOTAVAIL
#define WSAENETDOWN SO_ENETDOWN
#define WSAENETUNREACH SO_ENETUNREACH
#define WSAENETRESET SO_ENETRESET
#define WSAECONNABORTED SO_ECONNABORTED
#define WSAECONNRESET SO_ECONNRESET
#define WSAENOBUFS SO_ENOBUFS
#define WSAEISCONN SO_EISCONN
#define WSAENOTCONN SO_ENOTCONN
#define WSAETIMEDOUT SO_ETIMEDOUT
#define WSAECONNREFUSED SO_ECONNREFUSED
#define WSAELOOP SO_ELOOP
#define WSAENAMETOOLONG SO_ENAMETOOLONG
#define WSAEHOSTUNREACH SO_EHOSTUNREACH
#define WSAENOTEMPTY SO_ENOTEMPTY
#define WSAEDQUOT SO_EDQUOT
#define WSAESTALE SO_ESTALE
#define WSAEINVAL SO_EINVAL
#elif defined(_NITRO)
#define WSAEWOULDBLOCK SOC_EWOULDBLOCK
#define WSAEINPROGRESS SOC_EINPROGRESS
#define WSAEALREADY SOC_EALREADY
#define WSAENOTSOCK SOC_ENOTSOCK
#define WSAEDESTADDRREQ SOC_EDESTADDRREQ
#define WSAEMSGSIZE SOC_EMSGSIZE
#define WSAEPROTOTYPE SOC_EPROTOTYPE
#define WSAENOPROTOOPT SOC_ENOPROTOOPT
#define WSAEPROTONOSUPPORT SOC_EPROTONOSUPPORT
#define WSAEOPNOTSUPP SOC_EOPNOTSUPP
#define WSAEAFNOSUPPORT SOC_EAFNOSUPPORT
#define WSAEADDRINUSE SOC_EADDRINUSE
#define WSAEADDRNOTAVAIL SOC_EADDRNOTAVAIL
#define WSAENETDOWN SOC_ENETDOWN
#define WSAENETUNREACH SOC_ENETUNREACH
#define WSAENETRESET SOC_ENETRESET
#define WSAECONNABORTED SOC_ECONNABORTED
#define WSAECONNRESET SOC_ECONNRESET
#define WSAENOBUFS SOC_ENOBUFS
#define WSAEISCONN SOC_EISCONN
#define WSAENOTCONN SOC_ENOTCONN
#define WSAETIMEDOUT SOC_ETIMEDOUT
#define WSAECONNREFUSED SOC_ECONNREFUSED
#define WSAELOOP SOC_ELOOP
#define WSAENAMETOOLONG SOC_ENAMETOOLONG
#define WSAEHOSTUNREACH SOC_EHOSTUNREACH
#define WSAENOTEMPTY SOC_ENOTEMPTY
#define WSAEDQUOT SOC_EDQUOT
#define WSAESTALE SOC_ESTALE
#define WSAEINVAL SOC_EINVAL
#elif defined(_PS3)
#define WSAEWOULDBLOCK SYS_NET_EWOULDBLOCK
#define WSAEINPROGRESS SYS_NET_EINPROGRESS //SYS_NET_ERROR_EINPROGRESS
#define WSAEALREADY SYS_NET_EALREADY
#define WSAENOTSOCK SYS_NET_ENOTSOCK
#define WSAEDESTADDRREQ SYS_NET_EDESTADDRREQ
#define WSAEMSGSIZE SYS_NET_EMSGSIZE
#define WSAEPROTOTYPE SYS_NET_EPROTOTYPE
#define WSAENOPROTOOPT SYS_NET_ENOPROTOOPT
#define WSAEPROTONOSUPPORT SYS_NET_EPROTONOSUPPORT
#define WSAESOCKTNOSUPPORT SYS_NET_ESOCKTNOSUPPORT
#define WSAEOPNOTSUPP SYS_NET_EOPNOTSUPP
#define WSAEPFNOSUPPORT SYS_NET_EPFNOSUPPORT
#define WSAEAFNOSUPPORT SYS_NET_EAFNOSUPPORT
#define WSAEADDRINUSE SYS_NET_EADDRINUSE
#define WSAEADDRNOTAVAIL SYS_NET_EADDRNOTAVAIL
#define WSAENETDOWN SYS_NET_ENETDOWN
#define WSAENETUNREACH SYS_NET_ENETUNREACH
#define WSAENETRESET SYS_NET_ENETRESET
#define WSAECONNABORTED SYS_NET_ECONNABORTED
#define WSAECONNRESET SYS_NET_ECONNRESET // SYS_NET_ERROR_ECONNRESET
#define WSAENOBUFS SYS_NET_ENOBUFS // SYS_NET_ERROR_ENOBUFS
#define WSAEISCONN SYS_NET_EISCONN
#define WSAENOTCONN SYS_NET_ENOTCONN
#define WSAESHUTDOWN SYS_NET_ESHUTDOWN
#define WSAETOOMANYREFS SYS_NET_ETOOMANYREFS
#define WSAETIMEDOUT SYS_NET_ERROR_ETIMEDOUT
#define WSAECONNREFUSED SYS_NET_ECONNREFUSED
#define WSAELOOP SYS_NET_ELOOP
#define WSAENAMETOOLONG SYS_NET_ENAMETOOLONG
#define WSAEHOSTDOWN SYS_NET_EHOSTDOWN
#define WSAEHOSTUNREACH SYS_NET_EHOSTUNREACH
#define WSAENOTEMPTY SYS_NET_ENOTEMPTY
#define WSAEPROCLIM SYS_NET_EPROCLIM
#define WSAEUSERS SYS_NET_EUSERS
#define WSAEDQUOT SYS_NET_EDQUOT
#define WSAESTALE SYS_NET_ESTALE
#define WSAEREMOTE SYS_NET_EREMOTE
#define WSAEINVAL SYS_NET_EINVAL
#elif !defined(_WIN32)
#define WSAEWOULDBLOCK EWOULDBLOCK
#define WSAEINPROGRESS EINPROGRESS
#define WSAEALREADY EALREADY
#define WSAENOTSOCK ENOTSOCK
#define WSAEDESTADDRREQ EDESTADDRREQ
#define WSAEMSGSIZE EMSGSIZE
#define WSAEPROTOTYPE EPROTOTYPE
#define WSAENOPROTOOPT ENOPROTOOPT
#define WSAEPROTONOSUPPORT EPROTONOSUPPORT
#define WSAESOCKTNOSUPPORT ESOCKTNOSUPPORT
#define WSAEOPNOTSUPP EOPNOTSUPP
#define WSAEPFNOSUPPORT EPFNOSUPPORT
#define WSAEAFNOSUPPORT EAFNOSUPPORT
#define WSAEADDRINUSE EADDRINUSE
#define WSAEADDRNOTAVAIL EADDRNOTAVAIL
#define WSAENETDOWN ENETDOWN
#define WSAENETUNREACH ENETUNREACH
#define WSAENETRESET ENETRESET
#define WSAECONNABORTED ECONNABORTED
#define WSAECONNRESET ECONNRESET
#define WSAENOBUFS ENOBUFS
#define WSAEISCONN EISCONN
#define WSAENOTCONN ENOTCONN
#define WSAESHUTDOWN ESHUTDOWN
#define WSAETOOMANYREFS ETOOMANYREFS
#define WSAETIMEDOUT ETIMEDOUT
#define WSAECONNREFUSED ECONNREFUSED
#define WSAELOOP ELOOP
#define WSAENAMETOOLONG ENAMETOOLONG
#define WSAEHOSTDOWN EHOSTDOWN
#define WSAEHOSTUNREACH EHOSTUNREACH
#define WSAENOTEMPTY ENOTEMPTY
#define WSAEPROCLIM EPROCLIM
#define WSAEUSERS EUSERS
#define WSAEDQUOT EDQUOT
#define WSAESTALE ESTALE
#define WSAEREMOTE EREMOTE
#define WSAEINVAL EINVAL
#endif
// make caps types interchangeable on all platforms
#if !defined(_WIN32) && !defined(_NITRO) && !defined(_REVOLUTION) // necessary for Wii??
typedef int SOCKET;
typedef struct sockaddr SOCKADDR;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct in_addr IN_ADDR;
typedef struct hostent HOSTENT;
typedef struct timeval TIMEVAL;
#endif
#ifdef EENET
#define GOAGetLastError(s) sceEENetErrno
#define closesocket sceEENetClose
#endif
#ifdef INSOCK
//#define NETBUFSIZE (sceLIBNET_BUFFERSIZE)
#define NETBUFSIZE (32768) // buffer size for our samples
// used in place of shutdown function to avoid blocking shutdown call
int gsiShutdown(SOCKET s, int how);
#define GOAGetLastError(s) sceInsockErrno // not implemented
#define closesocket(s) gsiShutdown(s,SCE_INSOCK_SHUT_RDWR)
#undef shutdown
#define shutdown(s,h) gsiShutdown(s,h)
#endif
#ifdef _UNIX
#define GOAGetLastError(s) errno
#define closesocket close //on unix
#endif
#if !defined(_WIN32)
#define ioctlsocket ioctl
#endif
#if defined(_WIN32)
#define GOAGetLastError(s) WSAGetLastError()
#endif
#if defined(_REVOLUTION)
#define AF_INET SO_PF_INET
#define SOCK_DGRAM SO_SOCK_DGRAM
#define SOCK_STREAM SO_SOCK_STREAM
#define IPPROTO_UDP SO_IPPROTO_UDP
#define IPPROTO_TCP SO_IPPROTO_TCP
#define INADDR_ANY SO_INADDR_ANY
#define SOL_SOCKET SO_SOL_SOCKET
#define SO_SNDBUF SO_SO_SNDBUF
#define SO_RCVBUF SO_SO_RCVBUF
#define SO_REUSEADDR SO_SO_REUSEADDR
typedef int SOCKET;
typedef struct SOSockAddr SOCKADDR;
#define sockaddr SOSockAddr
typedef struct SOSockAddrIn SOCKADDR_IN;
#define sockaddr_in SOSockAddrIn
#define sin_family family
#define sin_port port
#define sin_addr addr
typedef struct SOInAddr IN_ADDR;
#define in_addr SOInAddr
#define s_addr addr
typedef struct SOHostEnt HOSTENT;
#define hostent SOHostEnt
#define h_name name
#define h_aliases aliases
#define h_addrtype addrType
#define h_length length
#define h_addr_list addrList
#define h_addr addrList[0]
int socket(int pf, int type, int protocol);
int closesocket(SOCKET sock);
int shutdown(SOCKET sock, int how);
int bind(SOCKET sock, const SOCKADDR* addr, int len);
int connect(SOCKET sock, const SOCKADDR* addr, int len);
int listen(SOCKET sock, int backlog);
SOCKET accept(SOCKET sock, SOCKADDR* addr, int* len);
int recv(SOCKET sock, char* buf, int len, int flags);
int recvfrom(SOCKET sock, char* buf, int len, int flags, SOCKADDR* addr, int* fromlen);
int send(SOCKET sock, const char* buf, int len, int flags);
int sendto(SOCKET sock, const char* buf, int len, int flags, const SOCKADDR* addr, int tolen);
int getsockopt(SOCKET sock, int level, int optname, char* optval, int* optlen);
int setsockopt(SOCKET sock, int level, int optname, const char* optval, int optlen);
#define gethostbyaddr(a,l,t) SOGetHostByAddr(a,l,t)
#define gethostbyname(n) SOGetHostByName(n)
// thread safe DNS lookups
#define getaddrinfo(n,s,h,r) SOGetAddrInfo(n,s,h,r)
#define freeaddrinfo(a) SOFreeAddrInfo(a)
int getsockname(SOCKET sock, SOCKADDR* addr, int* len);
#define htonl(l) SOHtoNl((u32)l)
#define ntohl(l) SONtoHl((u32)l)
#define htons(s) SOHtoNs((u16)s)
#define ntohs(s) SONtoHs((u16)s)
#define inet_ntoa(n) SOInetNtoA(n)
unsigned long inet_addr(const char * name);
int GOAGetLastError(SOCKET sock);
#endif
#if defined(_NITRO)
#define AF_INET SOC_PF_INET
#define SOCK_DGRAM SOC_SOCK_DGRAM
#define SOCK_STREAM SOC_SOCK_STREAM
#define IPPROTO_UDP 0
#define IPPROTO_TCP 0
#define INADDR_ANY SOC_INADDR_ANY
#define SOL_SOCKET SOC_SOL_SOCKET
#define SO_SNDBUF SOC_SO_SNDBUF
#define SO_RCVBUF SOC_SO_RCVBUF
#define SO_REUSEADDR SOC_SO_REUSEADDR
typedef int SOCKET;
typedef struct SOSockAddr SOCKADDR;
#define sockaddr SOSockAddr
typedef struct SOSockAddrIn SOCKADDR_IN;
#define sockaddr_in SOSockAddrIn
#define sin_family family
#define sin_port port
#define sin_addr addr
typedef struct SOInAddr IN_ADDR;
#define in_addr SOInAddr
#define s_addr addr
typedef struct SOHostEnt HOSTENT;
#define hostent SOHostEnt
#define h_name name
#define h_aliases aliases
#define h_addrtype addrType
#define h_length length
#define h_addr_list addrList
#define h_addr addrList[0]
int socket(int pf, int type, int protocol);
int closesocket(SOCKET sock);
int shutdown(SOCKET sock, int how);
int bind(SOCKET sock, const SOCKADDR* addr, int len);
int connect(SOCKET sock, const SOCKADDR* addr, int len);
int listen(SOCKET sock, int backlog);
SOCKET accept(SOCKET sock, SOCKADDR* addr, int* len);
int recv(SOCKET sock, char* buf, int len, int flags);
int recvfrom(SOCKET sock, char* buf, int len, int flags, SOCKADDR* addr, int* fromlen);
int send(SOCKET sock, const char* buf, int len, int flags);
int sendto(SOCKET sock, const char* buf, int len, int flags, const SOCKADDR* addr, int tolen);
int getsockopt(SOCKET sock, int level, int optname, char* optval, int* optlen);
int setsockopt(SOCKET sock, int level, int optname, const char* optval, int optlen);
#define gethostbyaddr(a,l,t) SOC_GetHostByAddr(a,l,t)
#define gethostbyname(n) SOC_GetHostByName(n)
int getsockname(SOCKET sock, SOCKADDR* addr, int* len);
#define htonl(l) SOC_HtoNl(l)
#define ntohl(l) SOC_NtoHl(l)
#define htons(s) SOC_HtoNs(s)
#define ntohs(s) SOC_NtoHs(s)
#define inet_ntoa(n) SOC_InetNtoA(n)
unsigned long inet_addr(const char * name);
int GOAGetLastError(SOCKET sock);
#endif
#if defined(_PS3)
#define accept(s,a,al) accept(s,a,(socklen_t*)(al))
#define bind(s,a,al) bind(s,a,(socklen_t)(al))
#define connect(s,a,al) connect(s,a,(socklen_t)(al))
#define getpeername(s,a,al) getpeername(s,a,(socklen_t*)(al))
#define getsockname(s,a,al) getsockname(s,a,(socklen_t*)(al))
#define getsockopt(s,l,o,v,vl) getsockopt(s,l,o,v,(socklen_t*)(vl))
#define recvfrom(s,b,l,f,a,al) recvfrom(s,b,l,f,a,(socklen_t*)(al))
#define sendto(s,b,l,f,a,al) sendto(s,b,l,f,a,(socklen_t)(al))
#define setsockopt(s,l,o,v,vl) setsockopt(s,l,o,v,(socklen_t)(vl))
#define closesocket socketclose
#define GOAGetLastError(s) sys_net_errno
#define EWOULDBLOCK sceNET_EWOULDBLOCK
#endif
#if defined(_MACOSX)
#define accept(s,a,al) accept(s,a,(socklen_t*)(al))
#define bind(s,a,al) bind(s,a,(socklen_t)(al))
#define connect(s,a,al) connect(s,a,(socklen_t)(al))
#define getpeername(s,a,al) getpeername(s,a,(socklen_t*)(al))
#define getsockname(s,a,al) getsockname(s,a,(socklen_t*)(al))
#define getsockopt(s,l,o,v,vl) getsockopt(s,l,o,v,(socklen_t*)(vl))
#define recvfrom(s,b,l,f,a,al) recvfrom(s,b,l,f,a,(socklen_t*)(al))
#define sendto(s,b,l,f,a,al) sendto(s,b,l,f,a,(socklen_t)(al))
#define setsockopt(s,l,o,v,vl) setsockopt(s,l,o,v,(socklen_t)(vl))
#endif
#if defined(SN_SYSTEMS)
int GOAGetLastError(SOCKET s);
#if !defined(__MWERKS__)
#define send(s,b,l,f) (int)send(s,b,(unsigned long)l,f)
#define recv(s,b,l,f) (int)recv(s,b,(unsigned long)l,f)
#define sendto(s,b,l,f,a,al) (int)sendto(s,b,(unsigned long)l,f,a,al)
#define recvfrom(s,b,l,f,a,al) (int)recvfrom(s,b,(unsigned long)l,f,a,al)
#endif
#endif
// SN Systems doesn't support gethostbyaddr
#if defined(SN_SYSTEMS)
#define gethostbyaddr(a,b,c) NULL
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Functions
int SetSockBlocking(SOCKET sock, int isblocking);
int SetSockBroadcast(SOCKET sock);
int DisableNagle(SOCKET sock);
int SetReceiveBufferSize(SOCKET sock, int size);
int SetSendBufferSize(SOCKET sock, int size);
int GetReceiveBufferSize(SOCKET sock);
int GetSendBufferSize(SOCKET sock);
int CanReceiveOnSocket(SOCKET sock);
int CanSendOnSocket(SOCKET sock);
int GSISocketSelect(SOCKET theSocket, int* theReadFlag, int* theWriteFlag, int* theExceptFlag);
void SocketStartUp();
void SocketShutDown();
HOSTENT * getlocalhost(void);
int IsPrivateIP(IN_ADDR * addr);
gsi_u32 gsiGetBroadcastIP(void);
#if defined(_PSP)
#define gethostbyaddr(a,b,c) NULL
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif // __GSSOCKET_H__
|
