]> git.mxchange.org Git - simgear.git/blob - simgear/io/raw_socket.cxx
Add multicast support for sockets
[simgear.git] / simgear / io / raw_socket.cxx
1 /*
2      simgear::Socket, adapted from PLIB Socket by James Turner
3      Copyright (C) 2010  James Turner
4      
5      PLIB - A Suite of Portable Game Libraries
6      Copyright (C) 1998,2002  Steve Baker
7  
8      This library is free software; you can redistribute it and/or
9      modify it under the terms of the GNU Library General Public
10      License as published by the Free Software Foundation; either
11      version 2 of the License, or (at your option) any later version.
12  
13      This library is distributed in the hope that it will be useful,
14      but WITHOUT ANY WARRANTY; without even the implied warranty of
15      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16      Library General Public License for more details.
17  
18      You should have received a copy of the GNU Library General Public
19      License along with this library; if not, write to the Free Software
20      Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21 */
22
23 #ifdef HAVE_CONFIG_H
24 #  include <simgear_config.h>
25 #endif
26
27 #include <simgear/compiler.h>
28
29 #include "sg_socket.hxx"
30
31 #if defined(_WIN32) && !defined(__CYGWIN__)
32 # define WINSOCK // use winsock convetions, otherwise standard POSIX
33 #endif
34
35 #include <cstdlib>
36 #include <ctime>
37 #include <cstring>
38 #include <cassert>
39 #include <cstdio> // for snprintf
40
41 #if defined(WINSOCK)
42 #  include <winsock.h>
43 #  include <stdarg.h>
44 #else
45 #  include <sys/types.h>
46 #  include <sys/socket.h>
47 #  include <netinet/in.h>
48 #  include <arpa/inet.h>
49 #  include <sys/time.h>  
50 #  include <unistd.h>
51 #  include <netdb.h>
52 #  include <fcntl.h>
53 #endif
54
55 #if defined(_MSC_VER) && !defined(socklen_t)
56 #define socklen_t int
57 #endif
58
59 #include <simgear/debug/logstream.hxx>
60 #include <simgear/structure/exception.hxx>
61
62 namespace simgear
63 {
64                                                                                        
65 IPAddress::IPAddress ( const char* host, int port )
66 {
67   set ( host, port ) ;
68 }
69
70
71 void IPAddress::set ( const char* host, int port )
72 {
73   memset(this, 0, sizeof(IPAddress));
74
75   sin_family = AF_INET ;
76   sin_port = htons (port);
77
78   /* Convert a string specifying a host name or one of a few symbolic
79   ** names to a numeric IP address.  This usually calls gethostbyname()
80   ** to do the work; the names "" and "<broadcast>" are special.
81   */
82
83   if (!host || host[0] == '\0') {
84     sin_addr = INADDR_ANY;
85     return;
86   }
87   
88   if (strcmp(host, "<broadcast>") == 0) {
89     sin_addr = INADDR_BROADCAST;
90     return;
91   }
92   
93   sin_addr = inet_addr ( host ) ;
94   if (sin_addr != INADDR_NONE) {
95     return;
96   }
97 // finally, try gethostbyname
98     struct hostent *hp = gethostbyname ( host ) ;
99     if (!hp) {
100       SG_LOG(SG_IO, SG_WARN, "gethostbyname failed for " << host);
101       sin_addr = INADDR_ANY ;
102       return;
103     }
104     
105     memcpy ( (char *) &sin_addr, hp->h_addr, hp->h_length ) ;
106 }
107
108
109 /* Create a string object representing an IP address.
110    This is always a string of the form 'dd.dd.dd.dd' (with variable
111    size numbers). */
112
113 const char* IPAddress::getHost () const
114 {
115 #if 0
116   const char* buf = inet_ntoa ( sin_addr ) ;
117 #else
118   static char buf [32];
119         long x = ntohl(sin_addr);
120         sprintf(buf, "%d.%d.%d.%d",
121                 (int) (x>>24) & 0xff, (int) (x>>16) & 0xff,
122                 (int) (x>> 8) & 0xff, (int) (x>> 0) & 0xff );
123 #endif
124   return buf;
125 }
126
127 unsigned int IPAddress::getIP () const 
128
129         return sin_addr; 
130 }
131
132 unsigned int IPAddress::getPort() const
133 {
134   return ntohs(sin_port);
135 }
136
137 unsigned int IPAddress::getFamily () const 
138
139         return sin_family; 
140 }
141
142 const char* IPAddress::getLocalHost ()
143 {
144   //gethostbyname(gethostname())
145
146   char buf[256];
147   memset(buf, 0, sizeof(buf));
148   gethostname(buf, sizeof(buf)-1);
149   const hostent *hp = gethostbyname(buf);
150
151   if (hp && *hp->h_addr_list)
152   {
153     in_addr     addr = *((in_addr*)*hp->h_addr_list);
154     const char* host = inet_ntoa(addr);
155
156     if ( host )
157       return host ;
158   }
159
160   return "127.0.0.1" ;
161 }
162
163
164 bool IPAddress::getBroadcast () const
165 {
166   return sin_addr == INADDR_BROADCAST;
167 }
168
169
170 Socket::Socket ()
171 {
172   handle = -1 ;
173 }
174
175
176 Socket::~Socket ()
177 {
178   close () ;
179 }
180
181
182 void Socket::setHandle (int _handle)
183 {
184   close () ;
185   handle = _handle ;
186 }
187
188
189 bool Socket::open ( bool stream )
190 {
191   close () ;
192   handle = ::socket ( AF_INET, (stream? SOCK_STREAM: SOCK_DGRAM), 0 ) ;
193
194   // Jan 26, 2010: Patch to avoid the problem of the socket resource not
195   // yet being available if the program is restarted quickly after being
196   // killed.
197   //
198   // Reference: http://www.unixguide.net/network/socketfaq/4.5.shtml
199   // --
200   // Also required for joining multicast domains
201   if ( stream ) {
202     int opt_boolean = 1;
203 #if defined(_WIN32) || defined(__CYGWIN__)
204     setsockopt( handle, SOL_SOCKET, SO_REUSEADDR, (char *)&opt_boolean,
205                 sizeof(opt_boolean) );
206 #else
207     setsockopt( handle, SOL_SOCKET, SO_REUSEADDR, &opt_boolean,
208                 sizeof(opt_boolean) );
209 #endif
210   }
211
212   return (handle != -1);
213 }
214
215
216 void Socket::setBlocking ( bool blocking )
217 {
218   assert ( handle != -1 ) ;
219
220 #if defined(WINSOCK)
221     u_long nblocking = blocking? 0: 1;
222   ::ioctlsocket(handle, FIONBIO, &nblocking);
223 #else
224
225   int delay_flag = ::fcntl (handle, F_GETFL, 0);
226
227   if (blocking)
228     delay_flag &= (~O_NDELAY);
229   else
230     delay_flag |= O_NDELAY;
231
232   ::fcntl (handle, F_SETFL, delay_flag);
233 #endif
234 }
235
236
237 void Socket::setBroadcast ( bool broadcast )
238 {
239   assert ( handle != -1 ) ;
240   int result;
241   if ( broadcast ) {
242       int one = 1;
243 #if defined(_WIN32) || defined(__CYGWIN__)
244       result = ::setsockopt( handle, SOL_SOCKET, SO_BROADCAST, (char*)&one, sizeof(one) );
245 #else
246       result = ::setsockopt( handle, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one) );
247 #endif
248   } else {
249       result = ::setsockopt( handle, SOL_SOCKET, SO_BROADCAST, NULL, 0 );
250   }
251   
252   if ( result < 0 ) {
253       throw sg_exception("Socket::setBroadcast failed");
254   }
255 }
256
257
258 int Socket::bind ( const char* host, int port )
259 {
260   int result;
261   assert ( handle != -1 ) ;
262   IPAddress addr ( host, port ) ;
263   if( (result = ::bind(handle,(const sockaddr*)&addr,sizeof(IPAddress))) < 0 ) {
264     SG_LOG(SG_IO, SG_ALERT, "bind(" << host << ":" << port << ") failed. Errno " << errno << " (" << strerror(errno) << ")");
265     return result;
266   }
267
268   // 224.0.0.0 - 239.255.255.255 are multicast   
269   // Usage of 239.x.x.x is recommended for local scope
270   // Reference: http://tools.ietf.org/html/rfc5771
271   if( ntohl(addr.getIP()) >= 0xe0000000 && ntohl(addr.getIP()) <= 0xefffffff ) {
272     struct ip_mreq mreq;
273     mreq.imr_multiaddr.s_addr = addr.getIP();
274     mreq.imr_interface.s_addr = htonl(INADDR_ANY);
275     if( (result=::setsockopt(getHandle(), IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char *)&mreq, sizeof(mreq))) != 0 ) {
276       SG_LOG(SG_IO, SG_ALERT, "setsockopt(IP_ADD_MEMBERSHIP) failed. Errno " << errno << " (" << strerror(errno) << ")");
277       return result;
278     }
279   }
280
281   return 0;
282 }
283
284
285 int Socket::listen ( int backlog )
286 {
287   assert ( handle != -1 ) ;
288   return ::listen(handle,backlog);
289 }
290
291
292 int Socket::accept ( IPAddress* addr )
293 {
294   assert ( handle != -1 ) ;
295
296   if ( addr == NULL )
297   {
298     return ::accept(handle,NULL,NULL);
299   }
300   else
301   {
302     socklen_t addr_len = (socklen_t) sizeof(IPAddress) ;
303     return ::accept(handle,(sockaddr*)addr,&addr_len);
304   }
305 }
306
307
308 int Socket::connect ( const char* host, int port )
309 {
310   assert ( handle != -1 ) ;
311   IPAddress addr ( host, port ) ;
312   if ( addr.getBroadcast() ) {
313       setBroadcast( true );
314   }
315   return ::connect(handle,(const sockaddr*)&addr,sizeof(IPAddress));
316 }
317
318
319 int Socket::send (const void * buffer, int size, int flags)
320 {
321   assert ( handle != -1 ) ;
322   return ::send (handle, (const char*)buffer, size, flags);
323 }
324
325
326 int Socket::sendto ( const void * buffer, int size,
327                         int flags, const IPAddress* to )
328 {
329   assert ( handle != -1 ) ;
330   return ::sendto(handle,(const char*)buffer,size,flags,
331                          (const sockaddr*)to,sizeof(IPAddress));
332 }
333
334
335 int Socket::recv (void * buffer, int size, int flags)
336 {
337   assert ( handle != -1 ) ;
338   return ::recv (handle, (char*)buffer, size, flags);
339 }
340
341
342 int Socket::recvfrom ( void * buffer, int size,
343                           int flags, IPAddress* from )
344 {
345   assert ( handle != -1 ) ;
346   socklen_t fromlen = (socklen_t) sizeof(IPAddress) ;
347   return ::recvfrom(handle,(char*)buffer,size,flags,(sockaddr*)from,&fromlen);
348 }
349
350
351 void Socket::close (void)
352 {
353   if ( handle != -1 )
354   {
355 #if defined(WINSOCK)
356     ::closesocket( handle );
357 #else
358     ::close( handle );
359 #endif
360     handle = -1 ;
361   }
362 }
363
364
365 bool Socket::isNonBlockingError ()
366 {
367 #if defined(WINSOCK)
368   int wsa_errno = WSAGetLastError();
369   if ( wsa_errno != 0 )
370   {
371     WSASetLastError(0);
372         SG_LOG(SG_IO, SG_WARN, "isNonBlockingError: WSAGetLastError():" << wsa_errno);
373     switch (wsa_errno) {
374     case WSAEWOULDBLOCK: // always == NET_EAGAIN?
375     case WSAEALREADY:
376     case WSAEINPROGRESS:
377       return true;
378     }
379   }
380   return false;
381 #else
382   switch (errno) {
383   case EWOULDBLOCK: // always == NET_EAGAIN?
384   case EALREADY:
385   case EINPROGRESS:
386     return true;
387   }
388   return false;
389
390 #endif
391 }
392
393
394 //////////////////////////////////////////////////////////////////////
395 //
396 //      modified version by os
397 //
398 //////////////////////////////////////////////////////////////////////
399 int Socket::select ( Socket** reads, Socket** writes, int timeout )
400 {
401   fd_set r,w;
402   int   retval;
403   
404   FD_ZERO (&r);
405   FD_ZERO (&w);
406
407   int i, k ;
408   int num = 0 ;
409
410   if ( reads )
411   {
412     for ( i=0; reads[i]; i++ )
413     {
414       int fd = reads[i]->getHandle();
415       FD_SET (fd, &r);
416       num++;
417     }
418   }
419
420   if ( writes )
421   {
422     for ( i=0; writes[i]; i++ )
423     {
424       int fd = writes[i]->getHandle();
425       FD_SET (fd, &w);
426       num++;
427     }
428   }
429
430   if (!num)
431     return num ;
432
433   /* Set up the timeout */
434   struct timeval tv ;
435   tv.tv_sec = timeout/1000;
436   tv.tv_usec = (timeout%1000)*1000;
437
438   // It bothers me that select()'s first argument does not appear to
439   // work as advertised... [it hangs like this if called with
440   // anything less than FD_SETSIZE, which seems wasteful?]
441   
442   // Note: we ignore the 'exception' fd_set - I have never had a
443   // need to use it.  The name is somewhat misleading - the only
444   // thing I have ever seen it used for is to detect urgent data -
445   // which is an unportable feature anyway.
446
447   retval = ::select (FD_SETSIZE, &r, &w, 0, &tv);
448
449   //remove sockets that had no activity
450
451   num = 0 ;
452
453   if ( reads )
454   {
455     for ( k=i=0; reads[i]; i++ )
456     {
457       int fd = reads[i]->getHandle();
458       if ( FD_ISSET (fd, &r) )
459       {
460         reads[k++] = reads[i];
461         num++;
462       }
463     }
464     reads[k] = NULL ;
465   }
466
467   if ( writes )
468   {
469     for ( k=i=0; writes[i]; i++ )
470     {
471       int fd = writes[i]->getHandle();
472       if ( FD_ISSET (fd, &w) )
473       {
474         writes[k++] = writes[i];
475         num++;
476       }
477     }
478     writes[k] = NULL ;
479   }
480
481   if (retval == 0) // timeout
482     return (-2);
483   if (retval == -1)// error
484     return (-1);
485
486   return num ;
487 }
488
489
490 /* Init/Exit functions */
491
492 static void netExit ( void )
493 {
494 #if defined(WINSOCK)
495         /* Clean up windows networking */
496         if ( WSACleanup() == SOCKET_ERROR ) {
497                 if ( WSAGetLastError() == WSAEINPROGRESS ) {
498                         WSACancelBlockingCall();
499                         WSACleanup();
500                 }
501         }
502 #endif
503 }
504
505 int Socket::initSockets()
506 {
507   assert ( sizeof(sockaddr_in) == sizeof(IPAddress) ) ;
508
509 #if defined(WINSOCK)
510         /* Start up the windows networking */
511         WORD version_wanted = MAKEWORD(1,1);
512         WSADATA wsaData;
513
514         if ( WSAStartup(version_wanted, &wsaData) != 0 ) {
515                 throw sg_exception("WinSock initialization failed");
516         }
517 #endif
518
519   atexit( netExit ) ;
520         return(0);
521 }
522
523
524 } // of namespace simgear
525