nexmon – Rev 1
?pathlinks?
/*---------------------------------------------------------------
* Copyright (c) 1999,2000,2001,2002,2003
* The Board of Trustees of the University of Illinois
* All Rights Reserved.
*---------------------------------------------------------------
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software (Iperf) and associated
* documentation files (the "Software"), to deal in the Software
* without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute,
* sublicense, and/or sell copies of the Software, and to permit
* persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
*
* Redistributions of source code must retain the above
* copyright notice, this list of conditions and
* the following disclaimers.
*
*
* Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimers in the documentation and/or other materials
* provided with the distribution.
*
*
* Neither the names of the University of Illinois, NCSA,
* nor the names of its contributors may be used to endorse
* or promote products derived from this Software without
* specific prior written permission.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
* ________________________________________________________________
* National Laboratory for Applied Network Research
* National Center for Supercomputing Applications
* University of Illinois at Urbana-Champaign
* http://www.ncsa.uiuc.edu
* ________________________________________________________________
*
* Socket.cpp
* by Ajay Tirumala <tirumala@ncsa.uiuc.edu>
* and Mark Gates <mgates@nlanr.net>
* ------------------------------------------------------------------- */
#define HEADERS()
#include "headers.h"
#include "SocketAddr.h"
#ifdef __cplusplus
extern "C" {
#endif
/* -------------------------------------------------------------------
* Create a socket address. If inHostname is not null, resolve that
* address and fill it in. Fill in the port number. Use IPv6 ADDR_ANY
* if that is what is desired.
* ------------------------------------------------------------------- */
void SockAddr_remoteAddr( thread_Settings *inSettings ) {
SockAddr_zeroAddress( &inSettings->peer );
if ( inSettings->mHost != NULL ) {
SockAddr_setHostname( inSettings->mHost, &inSettings->peer,
isIPV6( inSettings ) );
} else {
#ifdef HAVE_IPV6
if ( isIPV6( inSettings ) ) {
((struct sockaddr*)&inSettings->peer)->sa_family = AF_INET6;
} else {
((struct sockaddr*)&inSettings->peer)->sa_family = AF_INET;
}
}
if ( SockAddr_isIPv6( &inSettings->peer ) ) {
inSettings->size_peer = sizeof( struct sockaddr_in6 );
} else {
inSettings->size_peer = sizeof( struct sockaddr_in );
}
#else
((struct sockaddr*)&inSettings->peer)->sa_family = AF_INET;
}
inSettings->size_peer = sizeof( struct sockaddr_in );
#endif
SockAddr_setPort( &inSettings->peer, inSettings->mPort );
}
// end SocketAddr
void SockAddr_localAddr( thread_Settings *inSettings ) {
SockAddr_zeroAddress( &inSettings->local );
if ( inSettings->mLocalhost != NULL ) {
SockAddr_setHostname( inSettings->mLocalhost, &inSettings->local,
isIPV6( inSettings ) );
} else {
#ifdef HAVE_IPV6
if ( isIPV6( inSettings ) ) {
((struct sockaddr*)&inSettings->local)->sa_family = AF_INET6;
} else {
((struct sockaddr*)&inSettings->local)->sa_family = AF_INET;
}
}
if ( SockAddr_isIPv6( &inSettings->local ) ) {
inSettings->size_local = sizeof( struct sockaddr_in6 );
} else {
inSettings->size_local = sizeof( struct sockaddr_in );
}
#else
((struct sockaddr*)&inSettings->local)->sa_family = AF_INET;
}
inSettings->size_local = sizeof( struct sockaddr_in );
#endif
/*
* This section handles the *local* port binding (which is messy)
* Quintuple is Proto:LocalIP:LocalPort:DstIP:DstPort
*
* There are three threads being Client, Listener and Server
* mPort comes from the -p command (which defaults to 5001)
* mLocalhost indicates -B set requesting a local binding
* mBindPort comes from -B IP:<port> (where port defaults to 0)
* Multicast IP address, e.g. 239.1.1.1, is set per a -B
* Zero will cause the OS to auto assign a LocalPort
* For iperf -s; Windows uses listener thread, *nix a server thread
* (so, effectively, Listener and Server threads are the same)
* Client threads support either auto assignment (default) or
* user specified (via -B)
*/
if (inSettings->mLocalhost == NULL) {
if (inSettings->mThreadMode == kMode_Client) {
/*
* Client thread, -p and no -B,
* OS will auto assign a free local port
*/
SockAddr_setPortAny (&inSettings->local);
} else {
/* Server or Listener thread, -p and no -B */
SockAddr_setPort( &inSettings->local, inSettings->mPort );
}
} else {
/* -B was set (required to receive IP multicast) */
if (inSettings->mThreadMode == kMode_Client) {
/* Client thread */
if (inSettings->mBindPort) {
/*
* User specified port so use it
*/
SockAddr_setPort( &inSettings->local, inSettings->mBindPort );
} else {
/*
* No user specified port, let OS assign a free one
*/
SockAddr_setPortAny (&inSettings->local);
}
} else {
/*
* Server or Listener thread, both always use -p port
* any -B port will be ignored
*/
SockAddr_setPort( &inSettings->local, inSettings->mPort );
}
}
}
// end SocketAddr
/* -------------------------------------------------------------------
* Resolve the hostname address and fill it in.
* ------------------------------------------------------------------- */
void SockAddr_setHostname( const char* inHostname,
iperf_sockaddr *inSockAddr,
int isIPv6 ) {
// ..I think this works for both ipv6 & ipv4... we'll see
#if defined(HAVE_IPV6)
{
struct addrinfo *res, *itr;
int ret_ga;
ret_ga = getaddrinfo(inHostname, NULL, NULL, &res);
if ( ret_ga ) {
fprintf(stderr, "error: %s\n", gai_strerror(ret_ga));
exit(1);
}
if ( !res->ai_addr ) {
fprintf(stderr, "getaddrinfo failed to get an address... target was '%s'\n", inHostname);
exit(1);
}
// Check address type before filling in the address
// ai_family = PF_xxx; ai_protocol = IPPROTO_xxx, see netdb.h
// ...but AF_INET6 == PF_INET6
itr = res;
if ( isIPv6 ) {
// First check all results for a IPv6 Address
while ( itr != NULL ) {
if ( itr->ai_family == AF_INET6 ) {
memcpy(inSockAddr, (itr->ai_addr),
(itr->ai_addrlen));
freeaddrinfo(res);
return;
} else {
itr = itr->ai_next;
}
}
}
itr = res;
// Now find a IPv4 Address
while ( itr != NULL ) {
if ( itr->ai_family == AF_INET ) {
memcpy(inSockAddr, (itr->ai_addr),
(itr->ai_addrlen));
freeaddrinfo(res);
return;
} else {
itr = itr->ai_next;
}
}
}
#else
// first try just converting dotted decimal
// on Windows gethostbyname doesn't understand dotted decimal
int rc = inet_pton( AF_INET, inHostname,
(unsigned char*)&(((struct sockaddr_in*)inSockAddr)->sin_addr) );
inSockAddr->sin_family = AF_INET;
if ( rc == 0 ) {
struct hostent *hostP = gethostbyname( inHostname );
if ( hostP == NULL ) {
/* this is the same as herror() but works on more systems */
const char* format;
switch ( h_errno ) {
case HOST_NOT_FOUND:
format = "%s: Unknown host\n";
break;
case NO_ADDRESS:
format = "%s: No address associated with name\n";
break;
case NO_RECOVERY:
format = "%s: Unknown server error\n";
break;
case TRY_AGAIN:
format = "%s: Host name lookup failure\n";
break;
default:
format = "%s: Unknown resolver error\n";
break;
}
fprintf( stderr, format, inHostname );
exit(1);
return; // TODO throw
}
memcpy(&(((struct sockaddr_in*)inSockAddr)->sin_addr), *(hostP->h_addr_list),
(hostP->h_length));
}
#endif
}
// end setHostname
/* -------------------------------------------------------------------
* Copy the IP address into the string.
* ------------------------------------------------------------------- */
void SockAddr_getHostAddress( iperf_sockaddr *inSockAddr, char* outAddress,
size_t len ) {
if ( ((struct sockaddr*)inSockAddr)->sa_family == AF_INET ) {
inet_ntop( AF_INET, &(((struct sockaddr_in*) inSockAddr)->sin_addr),
outAddress, len);
}
#ifdef HAVE_IPV6
else {
inet_ntop( AF_INET6, &(((struct sockaddr_in6*) inSockAddr)->sin6_addr),
outAddress, len);
}
#endif
}
// end getHostAddress
/* -------------------------------------------------------------------
* Set the address to any (generally all zeros).
* ------------------------------------------------------------------- */
void SockAddr_setAddressAny( iperf_sockaddr *inSockAddr ) {
if ( ((struct sockaddr*)inSockAddr)->sa_family == AF_INET )
memset( &(((struct sockaddr_in*) inSockAddr)->sin_addr), 0,
sizeof( struct in_addr ));
#if defined(HAVE_IPV6)
else
memset( &(((struct sockaddr_in6*) inSockAddr)->sin6_addr), 0,
sizeof( struct in6_addr ));
#endif
}
// end setAddressAny
/* -------------------------------------------------------------------
* Set the port to the given port. Handles the byte swapping.
* ------------------------------------------------------------------- */
void SockAddr_setPort( iperf_sockaddr *inSockAddr, unsigned short inPort ) {
if ( ((struct sockaddr*)inSockAddr)->sa_family == AF_INET )
((struct sockaddr_in*) inSockAddr)->sin_port = htons( inPort );
#if defined(HAVE_IPV6)
else
((struct sockaddr_in6*) inSockAddr)->sin6_port = htons( inPort );
#endif
}
// end setPort
/* -------------------------------------------------------------------
* Set the port to zero, which lets the OS pick the port.
* ------------------------------------------------------------------- */
void SockAddr_setPortAny( iperf_sockaddr *inSockAddr ) {
SockAddr_setPort( inSockAddr, 0 );
}
// end setPortAny
/* -------------------------------------------------------------------
* Return the port. Handles the byte swapping.
* ------------------------------------------------------------------- */
unsigned short SockAddr_getPort( iperf_sockaddr *inSockAddr ) {
if ( ((struct sockaddr*)inSockAddr)->sa_family == AF_INET )
return ntohs( ((struct sockaddr_in*) inSockAddr)->sin_port );
#if defined(HAVE_IPV6)
else
return ntohs( ((struct sockaddr_in6*) inSockAddr)->sin6_port);
#endif
return 0;
}
// end getPort
/* -------------------------------------------------------------------
* Return the IPv4 Internet Address from the sockaddr_in structure
* ------------------------------------------------------------------- */
struct in_addr* SockAddr_get_in_addr( iperf_sockaddr *inSockAddr ) {
if ( ((struct sockaddr*)inSockAddr)->sa_family == AF_INET )
return &(((struct sockaddr_in*) inSockAddr)->sin_addr);
fprintf(stderr, "FATAL: get_in_addr called on IPv6 address\n");
return NULL;
}
/* -------------------------------------------------------------------
* Return the IPv6 Internet Address from the sockaddr_in6 structure
* ------------------------------------------------------------------- */
#ifdef HAVE_IPV6
struct in6_addr* SockAddr_get_in6_addr( iperf_sockaddr *inSockAddr ) {
if ( ((struct sockaddr*)inSockAddr)->sa_family == AF_INET6 )
return &(((struct sockaddr_in6*) inSockAddr)->sin6_addr);
fprintf(stderr, "FATAL: get_in6_addr called on IPv4 address\n");
return NULL;
}
#endif
/* -------------------------------------------------------------------
* Return the size of the appropriate address structure.
* ------------------------------------------------------------------- */
Socklen_t SockAddr_get_sizeof_sockaddr( iperf_sockaddr *inSockAddr ) {
#if defined(HAVE_IPV6)
if ( ((struct sockaddr*)inSockAddr)->sa_family == AF_INET6 ) {
return(sizeof(struct sockaddr_in6));
}
#endif
return(sizeof(struct sockaddr_in));
}
// end get_sizeof_sockaddr
/* -------------------------------------------------------------------
* Return if IPv6 socket
* ------------------------------------------------------------------- */
int SockAddr_isIPv6( iperf_sockaddr *inSockAddr ) {
#if defined(HAVE_IPV6)
if ( ((struct sockaddr*)inSockAddr)->sa_family == AF_INET6 ) {
return 1;
}
#endif
return 0;
}
// end get_sizeof_sockaddr
/* -------------------------------------------------------------------
* Return true if the address is a IPv4 multicast address.
* ------------------------------------------------------------------- */
int SockAddr_isMulticast( iperf_sockaddr *inSockAddr ) {
#if defined(HAVE_IPV6)
if ( ((struct sockaddr*)inSockAddr)->sa_family == AF_INET6 ) {
return( IN6_IS_ADDR_MULTICAST(&(((struct sockaddr_in6*) inSockAddr)->sin6_addr) ));
} else
#endif
{
// 224.0.0.0 to 239.255.255.255 (e0.00.00.00 to ef.ff.ff.ff)
const unsigned long kMulticast_Mask = 0xe0000000L;
return(kMulticast_Mask ==
(ntohl( ((struct sockaddr_in*) inSockAddr)->sin_addr.s_addr) & kMulticast_Mask));
}
}
// end isMulticast
/* -------------------------------------------------------------------
* Zero out the address structure.
* ------------------------------------------------------------------- */
void SockAddr_zeroAddress( iperf_sockaddr *inSockAddr ) {
memset( inSockAddr, 0, sizeof( iperf_sockaddr ));
}
// zeroAddress
/* -------------------------------------------------------------------
* Compare two sockaddrs and return true if they are equal
* ------------------------------------------------------------------- */
int SockAddr_are_Equal( struct sockaddr* first, struct sockaddr* second ) {
if ( first->sa_family == AF_INET && second->sa_family == AF_INET ) {
// compare IPv4 adresses
return( ((long) ((struct sockaddr_in*)first)->sin_addr.s_addr == (long) ((struct sockaddr_in*)second)->sin_addr.s_addr)
&& ( ((struct sockaddr_in*)first)->sin_port == ((struct sockaddr_in*)second)->sin_port) );
}
#if defined(HAVE_IPV6)
if ( first->sa_family == AF_INET6 && second->sa_family == AF_INET6 ) {
// compare IPv6 addresses
return( !memcmp(((struct sockaddr_in6*)first)->sin6_addr.s6_addr, ((struct sockaddr_in6*)second)->sin6_addr.s6_addr, sizeof(struct in6_addr))
&& (((struct sockaddr_in6*)first)->sin6_port == ((struct sockaddr_in6*)second)->sin6_port) );
}
#endif
return 0;
}
/* -------------------------------------------------------------------
* Compare two sockaddrs and return true if the hosts are equal
* ------------------------------------------------------------------- */
int SockAddr_Hostare_Equal( struct sockaddr* first, struct sockaddr* second ) {
if ( first->sa_family == AF_INET && second->sa_family == AF_INET ) {
// compare IPv4 adresses
return( (long) ((struct sockaddr_in*)first)->sin_addr.s_addr ==
(long) ((struct sockaddr_in*)second)->sin_addr.s_addr);
}
#if defined(HAVE_IPV6)
if ( first->sa_family == AF_INET6 && second->sa_family == AF_INET6 ) {
// compare IPv6 addresses
return( !memcmp(((struct sockaddr_in6*)first)->sin6_addr.s6_addr,
((struct sockaddr_in6*)second)->sin6_addr.s6_addr, sizeof(struct in6_addr)));
}
#endif
return 0;
}
#ifdef __cplusplus
} /* end extern "C" */
#endif