| /*--------------------------------------------------------------- |
| * 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 |
| 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 |
