Panda3D
socket_portable.h
1 #ifndef __SOCKET_PORTABLE_H__
2 #define __SOCKET_PORTABLE_H__
3 //////////////////////////////////////////////////////////////////
4 // Lots of stuff to make network socket-based io transparent across multiple
5 // platforms
6 //////////////////////////////////////////////////////////////////
7 
8 const int ALL_OK = 0;
9 const int BASIC_ERROR = -1;
10 
11 /************************************************************************
12 * HP SOCKET LIBRARY STUFF
13 ************************************************************************/
14 #if defined(HP_SOCK)
15 
16 #ifndef _INCLUDE_HPUX_SOURCE
17 #define _INCLUDE_HPUX_SOURCE
18 #define _INCLUDE_POSIX_SOURCE
19 #define _INCLUDE_XOPEN_SOURCE
20 #endif
21 #include <sys/socket.h>
22 #include <sys/time.h>
23 #include <netinet/in.h>
24 #include <netdb.h>
25 #include <errno.h>
26 
27 #define socket_read read
28 #define socket_write write
29 #define socket_close close
30 
31 #define DO_CONNECT(a,b,c) connect(a,b,c)
32 #define DO_SOCKET_READ(a,b,c,d) socket_read(a,b,c)
33 #define DO_SOCKET_WRITE(a,b,c,d) socket_write(a,b,c)
34 
35 #define GETERROR() errno
36 
37 
38 #define SOCKIOCTL ioctl
39 typedef unsigned long SOCKET;
40 #define BAD_SOCKET 0xffffffff
41 
42 
43 /************************************************************************
44 * WINSOCK 32 bit STUFF
45 ************************************************************************/
46 #elif defined(WIN32) || defined(WIN32_VC) || defined(WIN64_VC)
47 #include <winsock2.h>
48 #include <Ws2tcpip.h>
49 
50 
51 inline int DO_SELECT(SOCKET n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,struct timeval *timeout)
52 {
53  return select((int) n, readfds, writefds, exceptfds,timeout);
54 }
55 
56 inline int DO_CONNECT( const SOCKET a, const struct sockaddr_in *b)
57 {
58  return connect(a, reinterpret_cast<const struct ::sockaddr *>(b), sizeof(sockaddr));
59 }
60 inline int DO_SOCKET_READ(const SOCKET a, char * buf, const int size)
61 {
62  return recv(a, buf, size, 0);
63 }
64 inline int DO_SOCKET_WRITE(const SOCKET a, const char * buff, const int len)
65 {
66  return send(a, buff, len, 0);
67 }
68 inline int DO_SOCKET_WRITE_TO(const SOCKET a, const char * buffer, const int buf_len, const sockaddr_in * addr)
69 {
70  return sendto(a, buffer, buf_len, 0, reinterpret_cast<const struct ::sockaddr *>(addr), sizeof(sockaddr));
71 }
72 inline SOCKET DO_NEWUDP()
73 {
74  return socket(AF_INET, SOCK_DGRAM, 0);
75 }
76 inline SOCKET DO_NEWTCP()
77 {
78  return socket(AF_INET, SOCK_STREAM, 0);
79 }
80 inline int DO_BIND(const SOCKET a, const sockaddr_in *b)
81 {
82  return ::bind(a, reinterpret_cast<const struct ::sockaddr *>(b), sizeof(sockaddr));
83 }
84 inline int DO_CLOSE(const SOCKET a)
85 {
86  return closesocket(a);
87 }
88 inline SOCKET DO_ACCEPT(SOCKET sck, sockaddr_in * adr)
89 {
90  int adrlen = sizeof(sockaddr);
91  return accept(sck, reinterpret_cast<sockaddr *>(adr), &adrlen);
92 };
93 inline int DO_RECV_FROM(SOCKET sck, char * data, int len, sockaddr_in * addr)
94 {
95  int plen = sizeof(sockaddr);
96  return recvfrom(sck, data, len, 0, reinterpret_cast<sockaddr *>(addr), &plen);
97 }
98 inline int DO_LISTEN(const SOCKET a, const int size)
99 {
100  return listen(a, size);
101 }
102 
103 inline int GETERROR()
104 {
105  return WSAGetLastError();
106 }
107 
108 inline int SOCKIOCTL(const SOCKET s, const long flags, unsigned long * val)
109 {
110  return ioctlsocket(s, flags, val);
111 }
112 
113 inline int init_network()
114 {
115  static struct WSAData mydata;
116  int answer = WSAStartup(0x0101, &mydata);
117  if (answer != 0)
118  return BASIC_ERROR;
119 
120  return ALL_OK;
121 }
122 
123 inline bool do_shutdown_send(SOCKET s)
124 {
125  return (shutdown(s,SD_SEND) == 0);
126 };
127 
128 typedef int socklen_t ;
129 const long LOCAL_NONBLOCK = 1;
130 const long LOCAL_FL_SET = FIONBIO ;
131 const int LOCAL_BLOCKING_ERROR = WSAEWOULDBLOCK;
132 const int LOCAL_CONNECT_BLOCKING = WSAEWOULDBLOCK;
133 const int LOCAL_NOTCONNECTED_ERROR = WSAENOTCONN;
134 const int LOCAL_TIMEOUT_ERROR = WSAETIMEDOUT;
135 const SOCKET BAD_SOCKET = (SOCKET)-1;
136 
137 /************************************************************************
138 * Solaris 2.6 and Irix 6.4 STUFF
139 ************************************************************************/
140 #elif defined(SunOS) || defined(SUNNEW) || defined(IRIX64)
141 
142 #include <sys/types.h>
143 #include <sys/time.h>
144 #include <sys/socket.h>
145 #include <sys/ioctl.h>
146 #include <sys/filio.h>
147 #include <netinet/in.h>
148 #include <netdb.h>
149 #include <errno.h>
150 #include <fcntl.h>
151 #include <signal.h>
152 #include <unistd.h>
153 #include <string.h>
154 #include <netinet/in_systm.h>
155 #include <netinet/ip.h>
156 #include <netinet/in.h>
157 #include <arpa/inet.h>
158 
159 typedef int SOCKET;
160 const SOCKET BAD_SOCKET = 0xffffffff;
161 
162 //#define DO_CONNECT(a,b) connect(a,(sockaddr *)b,sizeof(sockaddr))
163 //#define DO_SOCKET_READ(a,b,c) recv(a,b,c,0)
164 //#define DO_SOCKET_WRITE(a,b,c) send(a,b,c,0)
165 
166 inline int DO_CONNECT(const SOCKET a, const sockaddr_in *b)
167 {
168  return connect(a, reinterpret_cast<const struct ::sockaddr *>(b), sizeof(sockaddr));
169 }
170 inline int DO_SOCKET_READ(const SOCKET a, char * buf, const int size)
171 {
172  return recv(a, buf, size, 0);
173 }
174 inline int DO_SOCKET_WRITE(const SOCKET a, const char * buff, const int len)
175 {
176  return send(a, buff, len, 0);
177 }
178 
179 //#define DO_SOCKET_WRITE_TO(a,b,c,d) sendto(a,b,c,0,(sockaddr *)d,sizeof(sockaddr))
180 //#define DO_NEWUDP() socket(AF_INET, SOCK_DGRAM, 0)
181 //#define DO_NEWTCP() socket(AF_INET, SOCK_STREAM, 0)
182 //#define DO_BIND(a,b) ::bind(a,(sockaddr *)b,sizeof(sockaddr))
183 //#/define DO_CLOSE(a) close(a)
184 inline int DO_SOCKET_WRITE_TO(const SOCKET a, const char * buffer, const int buf_len, const sockaddr_in * addr)
185 {
186  return sendto(a, buffer, buf_len, 0, reinterpret_cast<const struct ::sockaddr *>(addr), sizeof(sockaddr));
187 }
188 inline SOCKET DO_NEWUDP()
189 {
190  return socket(AF_INET, SOCK_DGRAM, 0);
191 }
192 inline SOCKET DO_NEWTCP()
193 {
194  return socket(AF_INET, SOCK_STREAM, 0);
195 }
196 inline int DO_BIND(const SOCKET a, const sockaddr_in *b)
197 {
198  return ::bind(a, reinterpret_cast<const struct ::sockaddr *>(b), sizeof(sockaddr));
199 }
200 inline int DO_CLOSE(const SOCKET a)
201 {
202  return close(a);
203 }
204 inline int DO_ACCEPT(SOCKET sck, sockaddr_in * adr)
205 {
206  int adrlen = sizeof(sockaddr);
207  return accept(sck, ( sockaddr *)adr, &adrlen);
208 };
209 
210 inline int DO_RECV_FROM(SOCKET sck, char * data, int len, sockaddr_in * addr)
211 {
212  int plen = sizeof(sockaddr);
213  return recvfrom(sck, data, len, 0, (sockaddr *)addr, &plen);
214 }
215 inline int DO_LISTEN(const SOCKET a, const int size)
216 {
217  return listen(a, size);
218 }
219 
220 inline int GETERROR()
221 {
222  return errno;
223 }
224 
225 inline int SOCKIOCTL(const SOCKET s, const long flags, void * val)
226 {
227  return ioctl(s, flags, val);
228 }
229 
230 inline int init_network()
231 {
232  return ALL_OK;
233 }
234 #ifndef INADDR_NONE
235 const INADDR_NONE = -1;
236 #endif
237 
238 const long LOCAL_NONBLOCK = 1;
239 const long LOCAL_FL_SET = FIONBIO ;
240 const int LOCAL_BLOCKING_ERROR = EAGAIN;
241 const int LOCAL_CONNECT_BLOCKING = EINPROGRESS;
242 
243 /************************************************************************
244 * LINUX and FreeBSD STUFF
245 ************************************************************************/
246 
247 #elif defined(IS_LINUX) || defined(IS_OSX) || defined(IS_FREEBSD)
248 
249 #include <sys/types.h>
250 #include <sys/time.h>
251 #include <sys/socket.h>
252 #include <sys/ioctl.h>
253 #include <netinet/in.h>
254 #include <netdb.h>
255 #include <errno.h>
256 #include <fcntl.h>
257 #include <signal.h>
258 #include <unistd.h>
259 #include <stdio.h>
260 //#include <netinet/in_systm.h>
261 #include <netinet/tcp.h>
262 //#include <netinet/ip.h>
263 #include <netinet/in.h>
264 #include <arpa/inet.h>
265 #include <unistd.h>
266 
267 typedef struct sockaddr_in AddressType;
268 
269 typedef int SOCKET;
270 const SOCKET BAD_SOCKET = -1;
271 inline int DO_SELECT(SOCKET n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,struct timeval *timeout)
272 {
273  return select((int) n, readfds, writefds, exceptfds,timeout);
274 }
275 
276 inline int DO_CONNECT(const SOCKET a, const sockaddr_in *b)
277 {
278  return connect(a, reinterpret_cast<const struct ::sockaddr *>(b), sizeof(sockaddr));
279 }
280 inline int DO_SOCKET_READ(const SOCKET a, char * buf, const int size)
281 {
282  return recv(a, buf, size, 0);
283 }
284 inline int DO_SOCKET_WRITE(const SOCKET a, const char * buff, const int len)
285 {
286  return send(a, buff, len, 0);
287 }
288 ///////////////////////////////////////////////
289 inline int DO_SOCKET_WRITE_TO(const SOCKET a, const char * buffer, const int buf_len, const sockaddr_in * addr)
290 {
291  return sendto(a, buffer, buf_len, 0, reinterpret_cast<const struct ::sockaddr *>(addr), sizeof(sockaddr));
292 }
293 inline SOCKET DO_NEWUDP()
294 {
295  return socket(AF_INET, SOCK_DGRAM, 0);
296 }
297 inline SOCKET DO_NEWTCP()
298 {
299  return socket(AF_INET, SOCK_STREAM, 0);
300 }
301 inline int DO_BIND(const SOCKET a, const sockaddr_in *b)
302 {
303  return ::bind(a, reinterpret_cast<const struct ::sockaddr *>(b), sizeof(sockaddr));
304 }
305 inline int DO_CLOSE(const SOCKET a)
306 {
307  return close(a);
308 }
309 
310 inline int DO_ACCEPT(SOCKET sck, sockaddr_in * adr)
311 {
312  socklen_t adrlen = sizeof(sockaddr);
313  return accept(sck, ( sockaddr *)adr, &adrlen);
314 };
315 
316 inline int DO_RECV_FROM(SOCKET sck, char * data, int len, sockaddr_in * addr)
317 {
318  socklen_t plen = sizeof(sockaddr);
319  return recvfrom(sck, data, len, 0, (sockaddr *)addr, &plen);
320 }
321 
322 
323 inline int init_network()
324 {
325  signal(SIGPIPE, SIG_IGN); // hmm do i still need this ...
326  return ALL_OK;
327 }
328 
329 inline int DO_LISTEN(const SOCKET a, const int size)
330 {
331  return listen(a, size);
332 }
333 
334 inline int GETERROR()
335 {
336  return errno;
337 }
338 
339 inline int SOCKIOCTL(const SOCKET s, const long flags, void * val)
340 {
341  return ioctl(s, flags, val);
342 }
343 
344 inline bool do_shutdown_send(SOCKET s)
345 {
346  return (shutdown(s,SHUT_WR) == 0);
347 };
348 
349 
350 #define BSDBLOCK
351 
352 
353 const long LOCAL_NONBLOCK = 1;
354 // With BSDBLOCK defined, we don't need FIONBIO. Solaris doesn't provide it.
355 //const long LOCAL_FL_SET = FIONBIO ;
356 const int LOCAL_BLOCKING_ERROR = EAGAIN;
357 const int LOCAL_CONNECT_BLOCKING = EINPROGRESS;
358 
359 #else
360 /************************************************************************
361 * NO DEFINITION => GIVE COMPILATION ERROR
362 ************************************************************************/
363 No Host Type defined !!
364 #error Fatal
365 #endif
366 
367 
368 
369 #endif //__SOCKET_PORTABLE_H__