/*
simgear::Socket, adapted from PLIB Socket by James Turner
Copyright (C) 2010 James Turner
-
+
PLIB - A Suite of Portable Game Libraries
Copyright (C) 1998,2002 Steve Baker
-
+
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
-
+
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
-
+
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifdef HAVE_CONFIG_H
# include <sys/socket.h>
# include <netinet/in.h>
# include <arpa/inet.h>
-# include <sys/time.h>
+# include <sys/time.h>
# include <unistd.h>
# include <netdb.h>
# include <fcntl.h>
#include <simgear/debug/logstream.hxx>
#include <simgear/structure/exception.hxx>
+#include <simgear/threads/SGThread.hxx>
-#include <OpenThreads/Thread>
-#include <OpenThreads/Mutex>
-#include <OpenThreads/Condition>
+using std::string;
namespace {
-class Resolver : public OpenThreads::Thread
+class Resolver : public SGThread
{
public:
static Resolver* instance()
{
if (!static_instance) {
- OpenThreads::Thread::Init();
-
static_instance = new Resolver;
atexit(&Resolver::cleanup);
static_instance->start();
}
-
+
return static_instance;
}
-
+
static void cleanup()
{
- static_instance->cancel();
+ static_instance->shutdown();
+ static_instance->join();
}
-
- Resolver()
+
+ Resolver() :
+ _done(false)
+ {
+ }
+
+ void shutdown()
{
- // take the lock initially, thread will wait upon it once running
_lock.lock();
+ _done = true;
+ _wait.signal();
+ _lock.unlock();
}
-
+
simgear::IPAddress* lookup(const string& host)
{
simgear::IPAddress* result = NULL;
_lock.unlock();
return result;
}
-
+
simgear::IPAddress* lookupSync(const string& host)
{
simgear::IPAddress* result = NULL;
*/
virtual void run()
{
- while (true) {
- _wait.wait(&_lock);
+ _lock.lock();
+ while (!_done) {
AddressCache::iterator it;
-
+
for (it = _cache.begin(); it != _cache.end(); ++it) {
if (it->second == NULL) {
string h = it->first;
-
+
_lock.unlock();
simgear::IPAddress* addr = new simgear::IPAddress;
// may take seconds or even minutes!
lookupHost(h.c_str(), *addr);
_lock.lock();
-
+
// cahce may have changed while we had the lock released -
// so iterators may be invalid: restart the traversal
it = _cache.begin();
_cache[h] = addr;
} // of found un-resolved entry
- } // of un-resolved address iteration
+ } // of un-resolved address iteration
+ _wait.wait(_lock);
} // of thread run loop
+ _lock.unlock();
}
private:
static Resolver* static_instance;
-
+
/**
* The actual synchronous, blocking host lookup function
* do *not* call this with any locks (mutexs) held, since depending
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_INET;
bool ok = false;
-
+
struct addrinfo* result0 = NULL;
int err = getaddrinfo(host, NULL, &hints, &result0);
if (err) {
freeaddrinfo(result0);
return ok;
}
-
- OpenThreads::Mutex _lock;
- OpenThreads::Condition _wait;
-
+
+ SGMutex _lock;
+ SGWaitCondition _wait;
+
typedef std::map<string, simgear::IPAddress*> AddressCache;
AddressCache _cache;
+ bool _done;
};
Resolver* Resolver::static_instance = NULL;
-
+
} // of anonymous namespace
namespace simgear
{
-
+
IPAddress::IPAddress ( const char* host, int port )
{
set ( host, port ) ;
addr->sin_addr.s_addr = INADDR_ANY;
return;
}
-
+
if (strcmp(host, "<broadcast>") == 0) {
addr->sin_addr.s_addr = INADDR_BROADCAST;
return;
}
-
+
// check the cache
IPAddress* cached = Resolver::instance()->lookupSync(host);
if (cached) {
memcpy(addr, cached->getAddr(), cached->getAddrLen());
}
-
+
addr->sin_port = htons (port); // fix up port after getaddrinfo
}
}
bool IPAddress::lookupNonblocking(const char* host, IPAddress& addr)
-{
+{
IPAddress* cached = Resolver::instance()->lookup(host);
if (!cached) {
return false;
}
-
+
addr = *cached;
return true;
}
const char* IPAddress::getHost () const
{
+ if (!addr) {
+ return NULL;
+ }
+
static char buf [32];
long x = ntohl(addr->sin_addr.s_addr);
sprintf(buf, "%d.%d.%d.%d",
return buf;
}
-unsigned int IPAddress::getIP () const
-{
- return addr->sin_addr.s_addr;
+unsigned int IPAddress::getIP () const
+{
+ if (!addr) {
+ return 0;
+ }
+
+ return addr->sin_addr.s_addr;
}
unsigned int IPAddress::getPort() const
{
+ if (!addr) {
+ return 0;
+ }
+
return ntohs(addr->sin_port);
}
void IPAddress::setPort(int port)
{
+ if (!addr) {
+ return;
+ }
+
addr->sin_port = htons(port);
}
-unsigned int IPAddress::getFamily () const
-{
- return addr->sin_family;
+unsigned int IPAddress::getFamily () const
+{
+ if (!addr) {
+ return 0;
+ }
+
+ return addr->sin_family;
}
const char* IPAddress::getLocalHost ()
bool IPAddress::getBroadcast () const
{
- return (addr->sin_addr.s_addr == INADDR_BROADCAST);
+ if (!addr) {
+ return false;
+ }
+
+ return (addr->sin_addr.s_addr == INADDR_BROADCAST);
}
unsigned int IPAddress::getAddrLen() const
addr = (struct sockaddr_in*) malloc(sizeof(struct sockaddr_in));
memset(addr, 0, sizeof(struct sockaddr_in));
}
-
+
return (struct sockaddr*) addr;
}
+bool IPAddress::isValid() const
+{
+ return (addr != NULL);
+}
+
Socket::Socket ()
{
handle = -1 ;
} else {
result = ::setsockopt( handle, SOL_SOCKET, SO_BROADCAST, NULL, 0 );
}
-
+
if ( result < 0 ) {
throw sg_exception("Socket::setBroadcast failed");
}
}
#endif
- // 224.0.0.0 - 239.255.255.255 are multicast
+ // 224.0.0.0 - 239.255.255.255 are multicast
// Usage of 239.x.x.x is recommended for local scope
// Reference: http://tools.ietf.org/html/rfc5771
if( ntohl(addr.getIP()) >= 0xe0000000 && ntohl(addr.getIP()) <= 0xefffffff ) {
a.sin_addr.S_un.S_addr = INADDR_ANY;
a.sin_family = AF_INET;
a.sin_port = htons(port);
-
+
if( (result = ::bind(handle,(const sockaddr*)&a,sizeof(a))) < 0 ) {
SG_LOG(SG_IO, SG_ALERT, "bind(any:" << port << ") failed. Errno " << errno << " (" << strerror(errno) << ")");
return result;
{
fd_set r,w;
int retval;
-
+
FD_ZERO (&r);
FD_ZERO (&w);
// It bothers me that select()'s first argument does not appear to
// work as advertised... [it hangs like this if called with
// anything less than FD_SETSIZE, which seems wasteful?]
-
+
// Note: we ignore the 'exception' fd_set - I have never had a
// need to use it. The name is somewhat misleading - the only
// thing I have ever seen it used for is to detect urgent data -
projects / simgear.git / blobdiff