VR Juggler Portable Runtime: vpr Namespace Reference

typedef LibraryUNIX vpr::Library

Definition at line 79 of file Library.h.

typedef boost::shared_ptr<Library> vpr::LibraryPtr

Definition at line 86 of file Library.h.

typedef FileHandle_t<FileHandleImplUNIX> vpr::FileHandle

Definition at line 72 of file FileHandle.h.

typedef Socket_t<SocketConfiguration> vpr::Socket

Definition at line 67 of file Socket.h.

typedef SocketDatagram_t<SocketConfiguration> vpr::SocketDatagram

Definition at line 71 of file SocketDatagram.h.

typedef SocketStream_t<SocketConfiguration> vpr::SocketStream

Definition at line 70 of file SocketStream.h.

typedef PRThreadPrivateDTOR vpr::KeyDestructor

Definition at line 59 of file ThreadKeyNSPR.h.

typedef PRInt8 vpr::Int8

Definition at line 49 of file vprTypesNSPR.h.

typedef PRUint8 vpr::Uint8

Definition at line 50 of file vprTypesNSPR.h.

typedef PRInt16 vpr::Int16

Definition at line 51 of file vprTypesNSPR.h.

typedef PRUint16 vpr::Uint16

Definition at line 52 of file vprTypesNSPR.h.

typedef PRInt32 vpr::Int32

Definition at line 53 of file vprTypesNSPR.h.

typedef PRUint32 vpr::Uint32

Definition at line 54 of file vprTypesNSPR.h.

typedef PRInt64 vpr::Int64

Definition at line 55 of file vprTypesNSPR.h.

typedef PRUint64 vpr::Uint64

Definition at line 56 of file vprTypesNSPR.h.

typedef void(*) vpr::KeyDestructor(void *)

Definition at line 62 of file ThreadKeyPosix.h.

typedef vpr::Uint32 vpr::thread_id_t

Definition at line 68 of file ThreadPosix.h.

typedef void(*) vpr::KeyDestructor(void *)

Definition at line 61 of file ThreadKeySGI.h.

typedef void(*) vpr::thread_func_t(void *)

Typedef to help with cross-platform abilities.

This type is the basic function pointer type for all functions initially passed as code to execute within a separate thread of control.

Definition at line 59 of file BaseThread.h.

typedef RETSIGTYPE(*) vpr::SignalHandler_t(int)

Definition at line 70 of file Signal.h.

typedef class InetAddrBSD vpr::InetAddr

Definition at line 153 of file vprDomain.h.

typedef class IOSysUnix vpr::IOSys

Definition at line 154 of file vprDomain.h.

typedef class Selector_t< class SelectorImplBSD > vpr::Selector

Definition at line 156 of file vprDomain.h.

typedef class SerialPort_t< class SerialPortImplTermios > vpr::SerialPort

Definition at line 157 of file vprDomain.h.

typedef class ErrorImplPosix vpr::Error

Definition at line 183 of file vprDomain.h.

typedef class SystemPosix vpr::System

Definition at line 184 of file vprDomain.h.

typedef class CondVarPosix vpr::CondVar

Definition at line 200 of file vprDomain.h.

typedef class MutexPosix vpr::Mutex

Definition at line 201 of file vprDomain.h.

typedef class RWMutexPosix vpr::RWMutex

Definition at line 202 of file vprDomain.h.

typedef class SemaphorePosix vpr::Semaphore

Definition at line 203 of file vprDomain.h.

typedef int vpr::cancel_state_t

Definition at line 205 of file vprDomain.h.

typedef class ThreadPosix vpr::Thread

Definition at line 206 of file vprDomain.h.

typedef class ThreadKeyPosix vpr::KeyId

Definition at line 207 of file vprDomain.h.

static const std::string vpr::DSO_NAME_EXT ( "" ) [static]

Referenced by vpr::LibraryLoader::makeFullDSOName().

static const std::string vpr::PATH_SEP ( "/" ) [static]

static const std::string vpr::DSO_FILE_EXT ( ".so" ) [static]

Referenced by vpr::LibraryLoader::makeFullDSOName().

static std::string vpr::errorPrep	(	const std::string &	who,
		const std::string &	msg
	)			`[static]`

Definition at line 50 of file LoaderError.cpp.

00051 {
00052    return who + ": " + msg;
00053 }

vpr::ReturnStatus vpr::getIfAddrs	(	std::vector< vpr::InetAddr > &	hostAddrs,
		const bool	withLoopback
	)

Retrieves all the IPv4 addresses associated with the local machine, including the loopback address (127.0.0.1) if so indicated.

This is an internal function that is not part of the public VPR interface.

This function exists in this form primarily because NSPR does not provide any wrapper that offerrs this functionality. Since the WinSock2 use of WSAIoctl() so closely mimics the use of ioctl(2) to get the interface addresses, much code duplication would be required between vpr::InetAddrBSD and vpr::InetAddrNSPR. Instead of duplicating complicated code, those classes call into this function.

Postcondition:: hostAddrs contains vpr::InetAddr objetcs holding all the local IPv4 addresses for the local machine.

Parameters:

	hostAddrs	Storage for the discovered local IPv4 addresses. The vector is cleared before the addresses are added, so any objects currently in the vector are lost.
	withLoopback	A flag indicating whether to include the loopback address (127.0.0.1) in `hostAddrs`.

Note:: This method currently supports only IPv4.

Returns:: vpr::ReturnStatus::Succeed is returned if the querying of all local addresses completes without error. Otherwise, vpr::ReturnStatus::Fail is returned.

Definition at line 102 of file InetAddrHelpers.cpp.

References clrOutBOLD, clrRED, errno, vpr::ReturnStatus::Fail, vpr::InetAddrBSD::setAddress(), vprDBG_ALL(), vprDBG_CRITICAL_LVL, vprDEBUG, and vprDEBUG_FLUSH.

Referenced by vpr::InetAddrNSPR::getAllLocalAddrs(), and vpr::InetAddrBSD::getAllLocalAddrs().

00104 {
00105 #if defined(VPR_OS_Windows)
00106    const unsigned long loop = ntohl(INADDR_LOOPBACK);
00107 #else
00108    const in_addr_t loop = ntohl(INADDR_LOOPBACK);
00109 #endif
00110 
00111    // Make sure hostAddrs is empty so that we can use push_back() below.
00112    hostAddrs.clear();
00113 
00114 #if defined(HAVE_GETIFADDRS)
00115    ifaddrs* addrs(NULL);
00116 
00117    int result = getifaddrs(&addrs);
00118 
00119    if ( result < 0 )
00120    {
00121       vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
00122          << clrOutBOLD(clrRED, "ERROR")
00123          << ": [vpr::getIfAddrs()] Failed to query interface addresses: "
00124          << strerror(errno) << std::endl << vprDEBUG_FLUSH;
00125       return vpr::ReturnStatus::Fail;
00126    }
00127    else
00128    {
00129       for ( ifaddrs* a = addrs; a != NULL; a = a->ifa_next )
00130       {
00131          sockaddr_in* addr_in = (sockaddr_in*) a->ifa_addr;
00132 
00133          // We only handle IPv4 addresses.
00134          if ( addr_in->sin_family != AF_INET )
00135          {
00136             continue;
00137          }
00138 
00139          // If we have the loopback address and withLoopback is false, then we
00140          // skip this address.
00141          if ( addr_in->sin_addr.s_addr == loop && ! withLoopback )
00142          {
00143             continue;
00144          }
00145 
00146          char netaddr[18];
00147          const char* temp_addr = inet_ntop(addr_in->sin_family,
00148                                            &addr_in->sin_addr, netaddr,
00149                                            sizeof(netaddr));
00150 
00151          if ( NULL != temp_addr )
00152          {
00153             vpr::InetAddr vpr_addr;
00154             vpr_addr.setAddress(netaddr, 0);
00155             hostAddrs.push_back(vpr_addr);
00156          }
00157       }
00158    }
00159 
00160    freeifaddrs(addrs);
00161 #else   /* ! HAVE_GETIFADDRS */
00162    // While the implementation of this method is long and rather complex
00163    // looking, the idea is simple:
00164    //
00165    //    1. Create an IPv4 socket.
00166    //    2. Use ioctl(2) or WSAIoctl() on the socket handle to query all the
00167    //       network interfaces.
00168    //    3. Iterate over the returned interface request objects and extract
00169    //       the valid IPv4 addresses.
00170    //    4. Store each IPv4 address in a new vpr::InetAddr object.
00171 #if defined(VPR_OS_Windows)
00172    typedef INTERFACE_INFO ifreq_t;
00173 
00174    SOCKET sock = WSASocket(AF_INET, SOCK_DGRAM, 0, 0, 0, 0);
00175 
00176    // Socket creation failed, so we cannot proceed.
00177    if ( sock == SOCKET_ERROR )
00178    {
00179       vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
00180          << clrOutBOLD(clrRED, "ERROR")
00181          << ": [vpr::getIfAddrs()] Socket creation failed (error code "
00182          << WSAGetLastError() << ")\n" << vprDEBUG_FLUSH;
00183       return vpr::ReturnStatus::Fail;
00184    }
00185 #else
00186    typedef ifreq ifreq_t;
00187 
00188    int sock = socket(AF_INET, SOCK_DGRAM, 0);
00189 
00190    // Socket creation failed, so we cannot proceed.
00191    if ( sock < 0 )
00192    {
00193       vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
00194          << clrOutBOLD(clrRED, "ERROR")
00195          << ": [vpr::getIfAddrs()] Socket creation failed: " << strerror(errno)
00196          << std::endl << vprDEBUG_FLUSH;
00197       return vpr::ReturnStatus::Fail;
00198    }
00199 #endif
00200 
00201    // Initial guess on the size of the buffer that will be returned by
00202    // ioctl(2) or WSAIoctl().
00203    unsigned int num_reqs(32);
00204 
00205    size_t lastlen(0);
00206    unsigned long bytes_returned(0);
00207 #if ! defined(VPR_OS_Windows)
00208    ifconf ifc;
00209 #endif
00210    ifreq_t* if_list(NULL);
00211 
00212    // Call ioctl(2) or WSAIoctl() iteratively to ensure that we get back all
00213    // the interface addresses. This is based on code from NSPR.
00214    for ( ; ; )
00215    {
00216       // Allocate storage for the data returned by ioctl(2) or WSAIoctl().
00217       if_list = new ifreq_t[num_reqs];
00218 
00219       if ( NULL == if_list )
00220       {
00221 #if defined(VPR_OS_Windows)
00222          closesocket(sock);
00223 #else
00224          close(sock);
00225 #endif
00226          vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
00227             << clrOutBOLD(clrRED, "ERROR")
00228             << ": [vpr::getIfAddrs()] Out of memory" << std::endl
00229             << vprDEBUG_FLUSH;
00230          return vpr::ReturnStatus::Fail;
00231       }
00232 
00233       const size_t len = sizeof(ifreq_t) * num_reqs;
00234 #if defined(VPR_OS_Windows)
00235       int result = WSAIoctl(sock, SIO_GET_INTERFACE_LIST, NULL, 0, if_list,
00236                             len, &bytes_returned, NULL, NULL);
00237 #else
00238       ifc.ifc_len = len;
00239       ifc.ifc_req = if_list;
00240 
00241       int result = ioctl(sock, SIOCGIFCONF, &ifc);
00242       bytes_returned = ifc.ifc_len;
00243 #endif
00244 
00245       // Ask the kernel for all the network interfaces to which sock could be
00246       // bound.
00247 #if defined(VPR_OS_Windows)
00248       if ( result == SOCKET_ERROR )
00249 #else
00250       if ( result < 0 )
00251 #endif
00252       {
00253 #if defined(VPR_OS_Windows)
00254          const int inval_err(WSAEINVAL);
00255          const int err_code(WSAGetLastError());
00256 #else
00257          const int inval_err(EINVAL);
00258          const int err_code(errno);
00259 #endif
00260 
00261          // If ioctl(2) or WSAIoctl() failed for reasons other than our buffer
00262          // being too small, then we cannot continue. We need to clean up after
00263          // ourselves before we return failure status.
00264          if ( err_code != inval_err || lastlen != 0 )
00265          {
00266 #if defined(VPR_OS_Windows)
00267             closesocket(sock);
00268 #else
00269             close(sock);
00270 #endif
00271             delete[] if_list;
00272 
00273             vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
00274                << clrOutBOLD(clrRED, "ERROR") << ": [vpr::getIfAddrs()] "
00275 #if defined(VPR_OS_Windows)
00276                << "Bad ioctl (error code " << err_code << ")"
00277 #else
00278                << "Bad ioctl: " << strerror(errno)
00279 #endif
00280                << std::endl << vprDEBUG_FLUSH;
00281             return vpr::ReturnStatus::Fail;
00282          }
00283       }
00284       // If ioctl(2) or WSAIoctl() returned successfully, check the size of
00285       // the buffer that it returned.
00286       else
00287       {
00288          // If lastlen is the same as the size of the buffer returned by
00289          // ioctl(2) or WSAIoctl(), then we are done. If the size of the buffer
00290          // returned by ioctl(2) or WASIoctl() is no larger than what we
00291          // allocated, then we are done.
00292          if ( bytes_returned == lastlen || bytes_returned <= len )
00293          {
00294             break;
00295          }
00296          // Otherwise, we continue iterating.
00297          else
00298          {
00299             lastlen = bytes_returned;
00300          }
00301       }
00302 
00303       // Increment the size of the returned buffer by increasing the number of
00304       // allocated request structures.
00305       num_reqs += 10;
00306       delete[] if_list;
00307    }
00308 
00309    // We are done with the socket.
00310 #if defined(VPR_OS_Windows)
00311    closesocket(sock);
00312 #else
00313    close(sock);
00314 #endif
00315 
00316    // Figure out how many interfaces were returned.
00317    const size_t num = bytes_returned / sizeof(ifreq_t);
00318 
00319    // Iterate over the returned ifreq objects and pull out the valid IPv4
00320    // addresses.
00321    for ( size_t i = 0; i < num; ++i )
00322    {
00323 #if defined(VPR_OS_Windows)
00324       sockaddr_in* addr = (sockaddr_in*) &if_list[i].iiAddress;
00325 #else
00326       sockaddr_in* addr = (sockaddr_in*) &ifc.ifc_req[i].ifr_addr;
00327 #endif
00328 
00329       // Skip addresses that are not IPv4.
00330       // XXX: We should support IPv6 at some point.
00331       if ( addr->sin_family != AF_INET )
00332       {
00333          continue;
00334       }
00335 
00336       // If we have the loopback address and withLoopback is false, then we
00337       // skip this address.
00338       if ( addr->sin_addr.s_addr == loop && ! withLoopback )
00339       {
00340          continue;
00341       }
00342 
00343       std::ostringstream addr_stream;
00344 
00345 #if defined(VPR_OS_Windows)
00346       // inet_ntoa() returns a pointer to static memory, which means that
00347       // it is not reentrant. Unfortunately, WinSock2 does not provide
00348       // inet_ntop(). The memory returned is guaranteed to be valid until
00349       // the next socket call in this thread, so there should not be a
00350       // race condition here.
00351       const char* temp_addr = inet_ntoa(addr->sin_addr);
00352 
00353       if ( NULL != temp_addr )
00354       {
00355          addr_stream << temp_addr;
00356       }
00357 #else
00358       char netaddr[18];
00359       const char* temp_addr = inet_ntop(addr->sin

vpr Namespace Reference

Classes

Namespaces

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation