summaryrefslogtreecommitdiffstats
path: root/nping/utils_net.cc
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--nping/utils_net.cc1941
1 files changed, 1941 insertions, 0 deletions
diff --git a/nping/utils_net.cc b/nping/utils_net.cc
new file mode 100644
index 0000000..e7acbad
--- /dev/null
+++ b/nping/utils_net.cc
@@ -0,0 +1,1941 @@
+
+/***************************************************************************
+ * utils_net.cc -- Miscellaneous network-related functions that perform *
+ * various tasks. *
+ * *
+ ***********************IMPORTANT NMAP LICENSE TERMS************************
+ *
+ * The Nmap Security Scanner is (C) 1996-2023 Nmap Software LLC ("The Nmap
+ * Project"). Nmap is also a registered trademark of the Nmap Project.
+ *
+ * This program is distributed under the terms of the Nmap Public Source
+ * License (NPSL). The exact license text applying to a particular Nmap
+ * release or source code control revision is contained in the LICENSE
+ * file distributed with that version of Nmap or source code control
+ * revision. More Nmap copyright/legal information is available from
+ * https://nmap.org/book/man-legal.html, and further information on the
+ * NPSL license itself can be found at https://nmap.org/npsl/ . This
+ * header summarizes some key points from the Nmap license, but is no
+ * substitute for the actual license text.
+ *
+ * Nmap is generally free for end users to download and use themselves,
+ * including commercial use. It is available from https://nmap.org.
+ *
+ * The Nmap license generally prohibits companies from using and
+ * redistributing Nmap in commercial products, but we sell a special Nmap
+ * OEM Edition with a more permissive license and special features for
+ * this purpose. See https://nmap.org/oem/
+ *
+ * If you have received a written Nmap license agreement or contract
+ * stating terms other than these (such as an Nmap OEM license), you may
+ * choose to use and redistribute Nmap under those terms instead.
+ *
+ * The official Nmap Windows builds include the Npcap software
+ * (https://npcap.com) for packet capture and transmission. It is under
+ * separate license terms which forbid redistribution without special
+ * permission. So the official Nmap Windows builds may not be redistributed
+ * without special permission (such as an Nmap OEM license).
+ *
+ * Source is provided to this software because we believe users have a
+ * right to know exactly what a program is going to do before they run it.
+ * This also allows you to audit the software for security holes.
+ *
+ * Source code also allows you to port Nmap to new platforms, fix bugs, and add
+ * new features. You are highly encouraged to submit your changes as a Github PR
+ * or by email to the dev@nmap.org mailing list for possible incorporation into
+ * the main distribution. Unless you specify otherwise, it is understood that
+ * you are offering us very broad rights to use your submissions as described in
+ * the Nmap Public Source License Contributor Agreement. This is important
+ * because we fund the project by selling licenses with various terms, and also
+ * because the inability to relicense code has caused devastating problems for
+ * other Free Software projects (such as KDE and NASM).
+ *
+ * The free version of Nmap 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. Warranties,
+ * indemnification and commercial support are all available through the
+ * Npcap OEM program--see https://nmap.org/oem/
+ *
+ ***************************************************************************/
+#include "nping.h"
+#include "utils.h"
+#include "utils_net.h"
+#include "NpingOps.h"
+#include "global_structures.h"
+#include "output.h"
+#include "nbase.h"
+#include "pcap.h"
+#include "dnet.h"
+#include <vector>
+
+extern NpingOps o;
+
+int atoIP(const char *hostname, struct in_addr *dst){
+ struct sockaddr_in i;
+ unsigned int stlen=0;
+ if ( resolve(hostname, 0, (sockaddr_storage*)&i, (size_t *)&stlen , PF_INET) != 0 )
+ return OP_FAILURE;
+ *dst=i.sin_addr;
+ return OP_SUCCESS;
+} /* End of atoIP */
+
+int atoIP(const char *hostname, struct sockaddr_storage *ss, int family){
+ size_t stlen=0;
+ if(ss==NULL || hostname==NULL)
+ return OP_FAILURE;
+ if(family!=AF_INET && family!=AF_INET6)
+ return OP_FAILURE;
+ if ( resolve(hostname, 0, ss, &stlen , family) != 0 )
+ return OP_FAILURE;
+ return OP_SUCCESS;
+} /* End of atoIP */
+
+
+/** @warning The string is returned in a statically allocated buffer, which
+ * subsequent calls will overwrite.*/
+char *IPtoa(u32 i){
+ static char buffer[24];
+ char *aux=NULL;
+ memset(buffer, 0, 24);
+ struct in_addr myip;
+ myip.s_addr=i;
+ aux=inet_ntoa(myip);
+ /* Get our own copy of the data so only subsequent calls to IPtoa overwrite
+ * the returned buffer (not subsequent calls to inet_ntoa() made by other
+ * methods. */
+ if(aux!=NULL){
+ strncpy(buffer, aux, 23);
+ return buffer;
+ }
+ else
+ return NULL;
+} /* End of IPtoa() */
+
+
+/** @warning The string is returned in a statically allocated buffer, which
+ * subsequent calls will overwrite.*/
+char *IPtoa(struct sockaddr_storage *ss){
+ struct sockaddr_in *s4=(struct sockaddr_in *)ss;
+ struct sockaddr_in6 *s6=(struct sockaddr_in6 *)ss;
+ static char ipstring[256];
+ memset(ipstring, 0, 256);
+ if( ss==NULL ){
+ snprintf(ipstring,256, "[[NULL address supplied to IPtoa()]]");
+ return ipstring;
+ }
+ if(s6->sin6_family==AF_INET6){
+ inet_ntop(AF_INET6, &s6->sin6_addr, ipstring, sizeof(ipstring));
+ }else if( s4->sin_family == AF_INET ) {
+ inet_ntop(AF_INET, &s4->sin_addr, ipstring, sizeof(ipstring));
+ }else{
+ snprintf(ipstring,256,"[[Unknown address family sockaddr supplied to IPtoa()]]");
+ }
+ return ipstring;
+} /* End of IPtoa() */
+
+
+char *IPtoa(struct sockaddr_storage ss){
+ return IPtoa(&ss);
+} /* End of IPtoa() */
+
+char *IPtoa(struct sockaddr_storage *ss, int family){
+ if(ss==NULL){
+ return NULL;
+ }else if(family==AF_INET){
+ struct sockaddr_in *s4=(struct sockaddr_in *)ss;
+ return IPtoa(s4->sin_addr);
+ }else if(family==AF_INET6){
+ struct sockaddr_in6 *s6=(struct sockaddr_in6 *)ss;
+ return IPtoa(s6->sin6_addr);
+ }else{
+ return NULL;
+ }
+} /* End of IPtoa() */
+
+
+/** @warning The string is returned in a statically allocated buffer, which
+ * subsequent calls will overwrite.*/
+char *IPtoa(struct in_addr addr){
+ static char ipstring[256];
+ memset(ipstring, 0, 256);
+ inet_ntop(AF_INET, &addr, ipstring, sizeof(ipstring));
+ return ipstring;
+} /* End of IPtoa() */
+
+
+/** @warning The string is returned in a statically allocated buffer, which
+ * subsequent calls will overwrite.*/
+char *IPtoa(struct in6_addr addr){
+ static char ipstring[256];
+ memset(ipstring, 0, 256);
+ inet_ntop(AF_INET6, &addr, ipstring, sizeof(ipstring));
+ return ipstring;
+} /* End of IPtoa() */
+
+
+/** @warning The string is returned in a statically allocated buffer, which
+ * subsequent calls will overwrite.*/
+char *IPtoa(u8 *ipv6addr){
+ static char ipstring[256];
+ memset(ipstring, 0, 256);
+ struct in6_addr s6;
+ memcpy(s6.s6_addr, ipv6addr, 16);
+ inet_ntop(AF_INET6, &s6, ipstring, sizeof(ipstring));
+ return ipstring;
+} /* End of IPtoa() */
+
+
+/** Returns true if supplied value corresponds to a valid RFC compliant ICMP
+ * type. Otherwise it returns false. */
+bool isICMPType(u8 type){
+ switch (type){
+ case 0:
+ case 3:
+ case 4:
+ case 5:
+ case 8:
+ case 9:
+ case 10:
+ case 11:
+ case 12:
+ case 13:
+ case 14:
+ case 15:
+ case 16:
+ case 17:
+ case 18:
+ case 30:
+ return true;
+ break;
+
+ default:
+ return false;
+ break;
+ }
+ return false;
+} /* End of isICMPType() */
+
+
+u16 sockaddr2port(struct sockaddr_storage ss){
+ return sockaddr2port(&ss);
+}
+
+
+u16 sockaddr2port(struct sockaddr_storage *ss){
+ assert(ss!=NULL);
+ if(ss->ss_family==AF_INET)
+ return sockaddr2port( (struct sockaddr_in *)ss );
+ else if( ss->ss_family==AF_INET6){
+ return sockaddr2port( (struct sockaddr_in6 *)ss );
+ }else{
+ return 0;
+ }
+}
+
+
+u16 sockaddr2port(struct sockaddr_in *s4){
+ assert(s4!=NULL);
+ return ntohs(s4->sin_port);
+}
+
+
+u16 sockaddr2port(struct sockaddr_in6 *s6){
+ assert(s6!=NULL);
+ return ntohs(s6->sin6_port);
+}
+
+
+/* Sets the address family member of the supplied sockaddr. */
+int setsockaddrfamily(struct sockaddr_storage *ss, int family){
+ struct sockaddr_in *s4=(struct sockaddr_in *)ss;
+ s4->sin_family=family;
+ return OP_SUCCESS;
+} /* End of setsockaddrfamily() */
+
+
+/* Sets the special INADDR_ANY or in6addr_an constant on the sin_family or
+ * sin6_addr member of the supplied sockaddr. Note that for this to work,
+ * the supplied sockaddr_storage MUST have a correct address family set
+ * already (sin_family or sin6_family). */
+int setsockaddrany(struct sockaddr_storage *ss){
+ struct sockaddr_in *s4=(struct sockaddr_in *)ss;
+ struct sockaddr_in6 *s6=(struct sockaddr_in6 *)ss;
+ if(s4->sin_family==AF_INET)
+ s4->sin_addr.s_addr=INADDR_ANY;
+ else if(s6->sin6_family==AF_INET6)
+ s6->sin6_addr=in6addr_any;
+ else
+ return OP_FAILURE;
+ return OP_SUCCESS;
+} /* End of setsockaddrany() */
+
+
+/** Returns true if supplied value corresponds to a valid RFC compliant ICMP
+ * Code. Otherwise it returns false.
+ * @warning The fact that a given value matches a standard code does not
+ * mean the code is correct because it depends on the type being used */
+bool isICMPCode(u8 code){
+ /* Correct as of 25 June 09.
+ * http://www.iana.org/assignments/icmp-parameters */
+ if( code<=16 )
+ return true;
+ else
+ return false;
+} /* End of isICMPType() */
+
+
+
+/** Returns true if supplied value corresponds to a valid RFC compliant ICMP
+ * Code for the supplied type
+ * @warning The fact that a given value matches a standard code does not
+ * mean the code is correct because it depends on the type being used */
+bool isICMPCode(u8 code, u8 type){
+ /* Correct as of 25 June 09.
+ * http://www.iana.org/assignments/icmp-parameters */
+ switch (type){
+ case 0: /* Echo Reply */
+ if(code==0) return true;
+ break;
+
+ case 3: /* Destination Unreachable */
+ if(code<=15) return true;
+ break;
+
+ case 4: /* Source Quench */
+ if(code==0) return true;
+ break;
+
+ case 5: /* Redirect */
+ if(code<=3) return true;
+ break;
+
+ case 6: /* Alternate Address for Host */
+ if(code==0) return true;
+ break;
+
+ case 8: /* Echo */
+ if(code==0) return true;
+ break;
+
+ case 9: /* Router Advertisement */
+ if(code==0 || code==16) return true;
+ break;
+
+ case 10: /* Router Selection */
+ if(code==0) return true;
+ break;
+
+ case 11: /* Time Exceeded */
+ if(code==0 || code==1) return true;
+ break;
+
+ case 12: /* Parameter Problem */
+ if(code<=2) return true;
+ break;
+
+ case 13: /* Timestamp */
+ if(code==0) return true;
+ break;
+
+ case 14: /* Timestamp Reply */
+ if(code==0) return true;
+ break;
+
+ case 15: /* Information Request */
+ if(code==0) return true;
+ break;
+
+ case 16: /* Information Reply */
+ if(code==0) return true;
+ break;
+
+ case 17: /* Address Mask Request */
+ if(code==0) return true;
+ break;
+
+ case 18: /* Address Mask Reply */
+ if(code==0) return true;
+ break;
+
+ case 30: /* Traceroute */
+ return true;
+ break;
+
+ case 40: /* Experimental ICMP Security Failures Messages [RFC 2521] */
+ if(code<=5) return true;
+ break;
+
+ default:
+ return false;
+ break;
+ }
+ return false;
+} /* End of isICMPType() */
+
+
+/* This function fills buffer "dstbuff" with a printable string that
+ * represents the supplied packet. When sending IPv6 packet at raw TCP
+ * level, the caller may specify source and/or destination address so they
+ * also get included in the returned information. However, this is optional
+ * and is safe to pass NULL values. */
+int getPacketStrInfo(const char *proto, const u8 *packet, u32 len, u8 *dstbuff,
+ u32 dstlen, struct sockaddr_storage *ss_src, struct sockaddr_storage *ss_dst){
+ char *b=NULL;
+ int detail;
+
+ if ( dstbuff == NULL || dstlen < 512 )
+ nping_fatal(QT_3,"safe_ippackethdrinfo() Invalid values supplied.");
+
+ if(o.getVerbosity()>=VB_2)
+ detail=HIGH_DETAIL;
+ else if (o.getVerbosity()==VB_1)
+ detail=MEDIUM_DETAIL;
+ else
+ detail=LOW_DETAIL;
+
+ if( !strcasecmp(proto, "IP") || !strcasecmp(proto, "IPv4") || !strcasecmp(proto, "IPv6")){
+ b=(char *)ippackethdrinfo(packet, len, detail);
+ strncpy((char*)dstbuff, b, dstlen);
+ dstbuff[dstlen-1]=0; /* Just to be sure, NULL-terminate the last position*/
+ }else if( !strcasecmp(proto, "ARP") || !strcasecmp(proto, "RARP") ){
+ return arppackethdrinfo(packet, len, dstbuff, dstlen);
+ }else if( !strcasecmp(proto, "IPv6_NO_HEADER") || o.ipv6UsingSocket() ){
+ if( o.getMode()==TCP )
+ return tcppackethdrinfo(packet, len, dstbuff, dstlen, detail, ss_src, ss_dst);
+ else if ( o.getMode()==UDP )
+ return udppackethdrinfo(packet, len, dstbuff, dstlen, detail, ss_src, ss_dst);
+ else
+ nping_fatal(QT_3, "getPacketStrInfo(): Unable to determinate transport layer protocol");
+ }else{
+ nping_fatal(QT_3, "getPacketStrInfo(): Unknown protocol");
+ }
+ return OP_SUCCESS;
+} /* getPacketStrInfo() */
+
+
+/* Same as previous one but passes NULL sockaddr values automatically. */
+int getPacketStrInfo(const char *proto, const u8 *packet, u32 len, u8 *dstbuff, u32 dstlen){
+ return getPacketStrInfo(proto,packet,len,dstbuff,dstlen,NULL,NULL);
+} /* getPacketStrInfo() */
+
+
+/** This function converts a port ranges specification into an array of u16
+ * integers that represent each of the specified ports. It allocates space
+ * for the port lists and stores the pointer in the supplied "list" parameter.
+ * Also, the number of ports in the array is returned through the supplied
+ * "count" pointer.
+ * @warning the caller is the one responsible for free()ing the allocated
+ * list of ports.
+ */
+int nping_getpts_simple(const char *origexpr, u16 **list, int *count) {
+ u8 *porttbl;
+ int portwarning = 0;
+ int i, j;
+
+ /* Allocate array to hold 2^16 ports */
+ porttbl = (u8 *) safe_zalloc(65536);
+
+ /* Get the ports but do not allow changing the type with T:, U:, or P:. */
+ getpts_aux(origexpr, 0, porttbl, &portwarning);
+
+ /* Count how many are set. */
+ *count = 0;
+ for (i = 0; i <= 65535; i++) {
+ if (porttbl[i])
+ (*count)++;
+ }
+
+ if (*count == 0){
+ free(porttbl);
+ return OP_FAILURE;
+ }
+
+ *list = (unsigned short *) safe_zalloc(*count * sizeof(u16));
+
+ /* Fill in the list. */
+ for (i = 0, j = 0; i <= 65535; i++) {
+ if (porttbl[i])
+ (*list)[j++] = i;
+ }
+ free(porttbl);
+ return OP_SUCCESS;
+} /* End of nping_getpts_simple() */
+
+
+
+
+/** Determines the net iface that should be used when sending packets
+ * to "destination".
+ * @return OP_SUCCESS on success and OP_FAILUIRE in case of error.
+ * @warning "*dev" must be able to hold at least 16 bytes */
+int getNetworkInterfaceName(u32 destination, char *dev){
+ struct route_nfo rnfo;
+ struct sockaddr_in dst, src;
+ bool result=false;
+ if(dev==NULL)
+ nping_fatal(QT_3, "getNetworkInterfaceName(): NULL value supplied.");
+ memset(&rnfo, 0, sizeof(struct route_nfo) );
+ memset(&dst, 0, sizeof(struct sockaddr_in) );
+ memset(&src, 0, sizeof(struct sockaddr_in) );
+ dst.sin_addr.s_addr = destination;
+ dst.sin_family = AF_INET;
+ result=route_dst((struct sockaddr_storage *)&dst, &rnfo, NULL, NULL);
+ if( result == false )
+ return OP_FAILURE;
+ strncpy( dev, rnfo.ii.devname, 16 );
+ return OP_SUCCESS;
+} /* End of getSourceAddress() */
+
+
+
+/** Determines the net iface that should be used when sending packets
+ * to "destination".
+ * @return OP_SUCCESS on success and OP_FAILUIRE in case of error.
+ * @warning "*dev" must be able to hold at least 16 bytes */
+int getNetworkInterfaceName(struct sockaddr_storage *dst, char *dev){
+ struct route_nfo rnfo;
+ struct sockaddr_storage src;
+ bool result=false;
+ if(dev==NULL)
+ nping_fatal(QT_3, "getNetworkInterfaceName(): NULL value supplied.");
+ memset(&rnfo, 0, sizeof(struct route_nfo) );
+ memset(&src, 0, sizeof(struct sockaddr_in) );
+ result=route_dst(dst, &rnfo, NULL, NULL);
+ if( result == false )
+ return OP_FAILURE;
+ strncpy( dev, rnfo.ii.devname, 16 );
+ return OP_SUCCESS;
+} /* End of getSourceAddress() */
+
+
+typedef struct cached_host{
+ char hostname[MAX_CACHED_HOSTNAME_LEN];
+ struct sockaddr_storage ss;
+ size_t sslen;
+}cached_host_t;
+
+
+int resolveCached(char *host, struct sockaddr_storage *ss, size_t *sslen, int pf) {
+ static cached_host_t archive[MAX_CACHED_HOSTS];
+ static int cached_count=0;
+ static int current_index=0; /* Used when we reach the end of the array and we do circular buffer */
+ int result=0;
+ //static int way=1;
+ static int misses=0, hits=0;
+
+ /* Used for debug. When called with NULL,0x1337, print stats */
+ if(host==NULL && pf == 1337){
+ nping_print(DBG_4, "resolveCached(): MISSES: %d, HITS: %d\n", misses, hits);
+ return OP_SUCCESS;
+ }
+
+
+ if( ss==NULL || sslen==NULL || host==NULL)
+ nping_fatal(QT_3, "resolveCached(): NULL values supplied");
+
+ /* First we check if we have the host already cached */
+ for(int i=0; i<MAX_CACHED_HOSTS && i<cached_count; i++){
+ if( !strcasecmp( archive[i].hostname , host ) ){ /* Cache hit */
+ *sslen=archive[i].sslen;
+ memcpy(ss, &(archive[i].ss) , *sslen);
+ hits++;
+ nping_print(DBG_4, "resolveCached(): Cache hit %d for %s\n", hits, host);
+ return OP_SUCCESS;
+ }
+ }
+
+ /* Cache miss */
+ misses++;
+ nping_print(DBG_4, "resolveCached(): Cache miss %d for %s\n", misses, host);
+
+ if( (result=resolve(host, 0, ss, sslen, pf)) == 0 ){
+
+ /* Increment count */
+ if( cached_count < MAX_CACHED_HOSTS )
+ cached_count++;
+
+ /* Store info */
+ memset(&(archive[current_index]), 0, sizeof(cached_host_t) );
+ strncpy(archive[current_index].hostname, host, MAX_CACHED_HOSTNAME_LEN);
+ archive[current_index].sslen = *sslen;
+ memcpy(&(archive[current_index].ss), ss, *sslen);
+
+
+ /* I run some tests to see what is the best approach when the cache
+ * is full. The thing is that in Nping, we are likely to call
+ * this function over and over with specifying the same hosts. Deleting
+ * the oldest entry results in 100% cache misses. I also tried to start
+ * overwriting entries first backwards and then upwards. That showed
+ * much better results. However, if we simply overwrite the last
+ * cache entry over an over we get the best results. */
+ if( current_index < MAX_CACHED_HOSTS-1 )
+ current_index++;
+ return 0;
+
+
+
+ ///* Watch out for the overflow. If cache is full, */
+ //if( cached_count == MAX_CACHED_HOSTS ){
+ //if( way%2==1 ){
+ //if( current_index > 0 )
+ //current_index--;
+ //else{
+ //current_index=1;
+ //way++;
+ //}
+ //}
+ //else{
+ //if( current_index < MAX_CACHED_HOSTS-1 )
+ //current_index++;
+ //else{
+ //current_index=MAX_CACHED_HOSTS-2;
+ //way++;
+ //}
+ //}
+ //}
+ //else
+ //current_index++;
+ //return OP_SUCCESS;
+
+ }else{
+ nping_warning(QT_2, "Error resolving %s\n",host);
+ return OP_FAILURE;
+ }
+} /* End of resolveCached() */
+
+
+typedef struct gethostbyname_cached{
+ char hostname[MAX_CACHED_HOSTNAME_LEN];
+ struct hostent *h;
+}gethostbynamecached_t;
+
+
+struct hostent *gethostbynameCached(char *host){
+ static gethostbynamecached_t archive[MAX_CACHED_HOSTS];
+ static int cached_count=0;
+ static int current_index=0;
+ struct hostent *result=NULL;
+ static int misses=0, hits=0;
+ int i=0;
+
+ if( host==NULL)
+ nping_fatal(QT_3, "gethostbynameCached(): NULL values supplied");
+
+ /* First we check if we have the host already cached */
+ for(i=0; i<MAX_CACHED_HOSTS && i<cached_count; i++){
+ if( !strcasecmp( archive[i].hostname , host ) ){ /* Cache hit */
+ hits++;
+ nping_print(DBG_4, "gethostbynameCached(): Cache hit %d for %s", hits, host);
+ return archive[i].h;
+ }
+ }
+
+ /* Cache miss */
+ misses++;
+ nping_print(DBG_4, "gethostbynameCached(): Cache miss %d for %s", misses, host);
+
+ if( (result=gethostbyname(host) ) != NULL ){
+
+ /* Increment cache entry count */
+ if( cached_count < MAX_CACHED_HOSTS )
+ cached_count++;
+
+ /* If we've reached the max number of cached hosts, free the
+ * hostent entry that is in the last slot so we can insert a new
+ * one in its place */
+ if ( current_index==MAX_CACHED_HOSTS-1 && archive[current_index].h != NULL )
+ hostentfree( archive[current_index].h );
+
+ /* Store the hostent entry in the cache */
+ memset(&(archive[current_index]), 0, sizeof(gethostbynamecached_t) );
+ strncpy(archive[current_index].hostname, host, MAX_CACHED_HOSTNAME_LEN);
+ archive[current_index].h = hostentcpy( result );
+
+ /* Return the entry that we've just added */
+ if( current_index < MAX_CACHED_HOSTS-1 ){
+ current_index++;
+ return archive[current_index-1].h;
+ }
+ else{
+ return archive[current_index].h;
+ }
+
+ }else{
+ return NULL;
+ }
+} /* End of resolveCached() */
+
+
+struct hostent *hostentcpy(struct hostent *src){
+ struct hostent *st=NULL;
+ int aliases=0;
+ int addrs=0;
+
+ if( src == NULL )
+ return NULL;
+
+ st=(struct hostent *)safe_zalloc( sizeof(struct hostent) );
+
+ /* Copy host name */
+ if( src->h_name!= NULL )
+ st->h_name = strdup( src->h_name );
+
+ /* Copy aliases */
+ if( src->h_aliases != NULL ){
+ while( src->h_aliases[aliases] ) /* Fist count how many*/
+ aliases++;
+ st->h_aliases = (char **)safe_zalloc( aliases * sizeof(char*) ); /* Allocate array */
+ for( int i=0; i<aliases; i++) /* Copy all entries */
+ st->h_aliases[i] = strdup( src->h_aliases[i] );
+ }
+ /* Copy address type an length */
+ st->h_addrtype=src->h_addrtype;
+ st->h_length=src->h_length;
+
+ /* Copy list of addresses */
+ if( src->h_addr_list != NULL ){
+
+ while( src->h_addr_list[addrs] ) /* Fist count how many*/
+ addrs++;
+
+ st->h_addr_list = (char **)safe_zalloc( addrs * sizeof(char*) ); /* Allocate array */
+
+ for( int j=0; j<addrs; j++) /* Copy all entries */
+ st->h_addr_list[j] = strdup( src->h_addr_list[j] );
+
+ /* Create dummy synonym for h_addr_list[0]*/
+ st->h_addr=st->h_addr_list[0];
+ }
+ return st;
+} /* End of hostentcpy() */
+
+
+/** Free a hostend structure.
+ * @warning This function can ONLY be used with hostent structs returned by
+ * hostentcpy. Do NOT attempt to use this on a hostent returned by
+ * gethostbyname() because the structure may contain pointers to statically
+ * allocated memory regions.*/
+int hostentfree(struct hostent *src){
+ int aliases=0;
+ int addrs=0;
+
+ if( src == NULL )
+ return OP_SUCCESS;
+
+ /* Free host name */
+ if ( src->h_name != NULL )
+ free( src->h_name );
+
+ /* Free aliases */
+ if( src->h_aliases != NULL ){
+ while( src->h_aliases[aliases] ){
+ free(src->h_aliases[aliases]);
+ aliases++;
+ }
+ free(src->h_aliases);
+ }
+
+ /* Free list of addresses */
+ if( src->h_addr_list != NULL ){
+
+ while( src->h_addr_list[addrs] ){
+ addrs++;
+ free( src->h_addr_list[addrs] );
+ }
+ free( src->h_addr_list );
+ }
+
+ /* Finally free the base hostent struct */
+ free( src );
+ return OP_SUCCESS;
+} /* End of hostentfree() */
+
+
+
+/** Receives a MAC address as a string of format 00:13:01:e6:c7:ae or
+ * 00-13-01-e6-c7-ae and stores in targetbuff the 6 corresponding bytes.
+ * The "txt" parameter may take the special value "rand" or "random",
+ * in which case, 6 random bytes will be stored in "targetbuff".
+ * @return OP_SUCCESS on success and OP_FAILURE in case of error.
+ * Buffer targetbuff is NOT modified if "txt" does not have the proper
+ * format */
+int parseMAC(const char *txt, u8 *targetbuff){
+ u8 mac_data[6];
+ char tmphex[3];
+ int i=0, j=0;
+
+ if( txt==NULL || targetbuff==NULL )
+ return OP_FAILURE;
+
+ /* Set up a random MAC if user requested so. */
+ if( meansRandom(txt) ){
+ get_random_bytes(targetbuff, 6);
+ return OP_SUCCESS;
+ /* Or set it to FF:FF:FF:FF:FF:FF if user chose broadcast */
+ }else if( !strcasecmp(optarg, "broadcast") || !strcasecmp(optarg, "bcast") ){
+ memset(targetbuff, 0xFF, 6);
+ return OP_SUCCESS;
+ }
+
+ /* Array should look like 00:13:01:e6:c7:ae or 00-13-01-e6-c7-ae
+ Array positions: 01234567890123456 01234567890123456 */
+ if( strlen(txt)!=17 )
+ return OP_FAILURE;
+ /* Check MAC has the correct ':' or '-' characters */
+ if( (txt[2]!=':' && txt[2]!='-') || (txt[5]!=':' && txt[5]!='-') ||
+ (txt[8]!=':' && txt[8]!='-') || (txt[11]!=':' && txt[11]!='-') ||
+ (txt[14]!=':' && txt[14]!='-') )
+ return OP_FAILURE;
+
+ /* Convert txt into actual bytes */
+ for(i=0, j=0; i<6; i++, j+=3 ){
+ if( !isxdigit(txt[j]) || !isxdigit(txt[j+1]) )
+ return OP_FAILURE;
+ tmphex[0] = txt[j];
+ tmphex[1] = txt[j+1];
+ tmphex[2] = '\0';
+ mac_data[i] = (u8) strtol(tmphex, NULL, 16);
+ }
+ memcpy(targetbuff, mac_data, 6);
+ return OP_SUCCESS;
+} /* End of parseMAC() */
+
+
+
+char *MACtoa(u8 *mac){
+ static char macinfo[24];
+ memset(macinfo, 0, 24);
+ sprintf(macinfo,"%02X:%02X:%02X:%02X:%02X:%02X",
+ mac[0],mac[1],mac[2],mac[3],mac[4],mac[5]);
+ return macinfo;
+} /* End of MACtoa() */
+
+
+
+
+/* Returns a buffer of ASCII information about an ARP/RARP packet that may look
+ like "ARP who has 192.168.10.1? Tell 192.168.10.98"
+ Since this is a static buffer, don't use threads or call twice
+ within (say) printf(). And certainly don't try to free() it! The
+ returned buffer is NUL-terminated */
+const char *arppackethdrinfo(const u8 *packet, u32 len, int detail){
+ static char protoinfo[512];
+ if (packet==NULL)
+ nping_fatal(QT_3, "arppackethdrinfo(): NULL value supplied");
+ if( len < 28 )
+ return "BOGUS! Packet too short.";
+ u16 *htype = (u16 *)packet;
+ u16 *ptype = (u16 *)(packet+2);
+ u8 *hlen = (u8 *)(packet+4);
+ u8 *plen = (u8 *)(packet+5);
+ u16 *op = (u16 *)(packet+6);
+ u8 *sMAC= (u8 *)(packet+8);
+ u32 *sIP = (u32 *)(packet+14);
+ u8 *tMAC = (u8 *)(packet+18);
+ u32 *tIP = (u32 *)(packet+24);
+
+ if( ntohs(*op) == 1 ){ /* ARP Request */
+ sprintf(protoinfo, "ARP who has %s? ", IPtoa(*tIP));
+ sprintf(protoinfo+strlen(protoinfo),"Tell %s", IPtoa(*sIP) );
+ }
+ else if( ntohs(*op) == 2 ){ /* ARP Reply */
+ sprintf(protoinfo, "ARP reply %s ", IPtoa(*sIP));
+ sprintf(protoinfo+strlen(protoinfo),"is at %s", MACtoa(sMAC) );
+ }
+ else if( ntohs(*op) == 3 ){ /* RARP Request */
+ sprintf(protoinfo, "RARP who is %s? Tell %s", MACtoa(tMAC), MACtoa(sMAC) );
+ }
+ else if( ntohs(*op) ==4 ){ /* RARP Reply */
+ sprintf(protoinfo, "RARP reply: %s is at %s", MACtoa(tMAC), IPtoa(*tIP) );
+ }
+ else{
+ sprintf(protoinfo, "HTYPE:%04X PTYPE:%04X HLEN:%d PLEN:%d OP:%04X SMAC:%s SIP:%s DMAC:%s DIP:%s",
+ *htype, *ptype, *hlen, *plen, *op, MACtoa(sMAC), IPtoa(*sIP), MACtoa(tMAC), IPtoa(*tIP));
+ }
+ return protoinfo;
+} /* End of arppackethdrinfo() */
+
+
+
+
+int arppackethdrinfo(const u8 *packet, u32 len, u8 *dstbuff, u32 dstlen){
+ char *b=NULL;
+ int detail=0;
+
+ if ( dstbuff == NULL || dstlen < 512 )
+ nping_fatal(QT_3,"safe_arppackethdrinfo() Invalid values supplied.");
+
+ /* Determine level of detail in packet output from current verbosity level */
+ if(o.getVerbosity()>=VB_2)
+ detail=HIGH_DETAIL;
+ else if (o.getVerbosity()==VB_1)
+ detail=MEDIUM_DETAIL;
+ else
+ detail=LOW_DETAIL;
+
+ b=(char *)arppackethdrinfo(packet, len, detail);
+ strncpy((char*)dstbuff, b, dstlen);
+ dstbuff[dstlen-1]=0; /* Just to be sure, NULL-terminate the last position*/
+ return OP_SUCCESS;
+} /* End of arppackethdrinfo() */
+
+
+
+int tcppackethdrinfo(const u8 *packet, size_t len, u8 *dstbuff, size_t dstlen,
+ int detail, struct sockaddr_storage *src, struct sockaddr_storage *dst){
+
+ struct tcp_hdr *tcp=NULL; ; /* TCP header structure. */
+ char *p = NULL; /* Aux pointer. */
+ static char protoinfo[1024] = ""; /* Stores final info string. */
+ char tflags[10];
+ char tcpinfo[64] = "";
+ char buf[32];
+ char tcpoptinfo[256] = "";
+ struct sockaddr_in *s4=(struct sockaddr_in *)src;
+ struct sockaddr_in6 *s6=(struct sockaddr_in6 *)src;
+ struct sockaddr_in *d4=(struct sockaddr_in *)dst;
+ struct sockaddr_in6 *d6=(struct sockaddr_in6 *)dst;
+ char srcipstring[128];
+ char dstipstring[128];
+
+ assert(packet);
+ assert(dstbuff);
+ assert(len>=20);
+
+ tcp=(struct tcp_hdr *)packet;
+
+ /* Ensure we end up with a valid detail number */
+ if( detail!=LOW_DETAIL && detail!=MEDIUM_DETAIL && detail!=HIGH_DETAIL)
+ detail=LOW_DETAIL;
+
+
+ /* Determine target IP address */
+ if(src!=NULL){
+ if( s4->sin_family==AF_INET ){
+ inet_ntop(AF_INET, &s4->sin_addr, srcipstring, sizeof(srcipstring));
+ }
+ else if( s6->sin6_family==AF_INET6){
+ inet_ntop(AF_INET6, &s6->sin6_addr, srcipstring, sizeof(srcipstring));
+ }else{
+ sprintf(dstipstring, "unknown_addr_family");
+ }
+ }else{
+ sprintf(srcipstring, "this_host");
+ }
+
+ /* Determine source IP address */
+ if(dst!=NULL){
+ if( d4->sin_family==AF_INET ){
+ inet_ntop(AF_INET, &d4->sin_addr, dstipstring, sizeof(dstipstring));
+ }
+ else if( d6->sin6_family==AF_INET6){
+ inet_ntop(AF_INET6, &d6->sin6_addr, dstipstring, sizeof(dstipstring));
+ }else{
+ sprintf(dstipstring, "unknown_addr_family");
+ }
+ }else{
+ sprintf(dstipstring, "unknown_host");
+ }
+
+ /* TCP Flags */
+ p = tflags;
+ /* These are basically in tcpdump order */
+ if (tcp->th_flags & TH_SYN) *p++ = 'S';
+ if (tcp->th_flags & TH_FIN) *p++ = 'F';
+ if (tcp->th_flags & TH_RST) *p++ = 'R';
+ if (tcp->th_flags & TH_PUSH) *p++ = 'P';
+ if (tcp->th_flags & TH_ACK){ *p++ = 'A';
+ Snprintf(buf, sizeof(buf), " ack=%lu",
+ (unsigned long) ntohl(tcp->th_ack));
+ strncat(tcpinfo, buf, sizeof(tcpinfo) - strlen(tcpinfo) - 1);
+ }
+ if (tcp->th_flags & TH_URG) *p++ = 'U';
+ if (tcp->th_flags & TH_ECE) *p++ = 'E'; /* rfc 2481/3168 */
+ if (tcp->th_flags & TH_CWR) *p++ = 'C'; /* rfc 2481/3168 */
+ *p++ = '\0';
+
+
+ /* TCP Options */
+ if((u32) tcp->th_off * 4 > sizeof(struct tcp_hdr)) {
+ if(len < (u32) tcp->th_off * 4) {
+ Snprintf(tcpoptinfo, sizeof(tcpoptinfo), "option incomplete");
+
+ } else {
+ tcppacketoptinfo((u8*) tcp + sizeof(struct tcp_hdr),
+ tcp->th_off*4 - sizeof(struct tcp_hdr),
+ tcpoptinfo, sizeof(tcpoptinfo));
+ }
+ }
+
+ /* Rest of header fields */
+ if( detail == LOW_DETAIL ){
+ Snprintf(protoinfo, sizeof(protoinfo), "TCP %s:%d > %s:%d %s seq=%lu win=%hu %s",
+ srcipstring, ntohs(tcp->th_sport), dstipstring, ntohs(tcp->th_dport),
+ tflags, (unsigned long) ntohl(tcp->th_seq),
+ ntohs(tcp->th_win), tcpoptinfo);
+ }else if( detail == MEDIUM_DETAIL ){
+ Snprintf(protoinfo, sizeof(protoinfo), "TCP [%s:%d > %s:%d %s seq=%lu win=%hu csum=0x%04X%s%s]",
+ srcipstring, ntohs(tcp->th_sport), dstipstring, ntohs(tcp->th_dport),
+ tflags, (unsigned long) ntohl(tcp->th_seq),
+ ntohs(tcp->th_win), ntohs(tcp->th_sum),
+ (tcpoptinfo[0]!='\0') ? " " : "",
+ tcpoptinfo);
+ }else if( detail==HIGH_DETAIL ){
+ Snprintf(protoinfo, sizeof(protoinfo), "TCP [%s:%d > %s:%d %s seq=%lu ack=%lu off=%d res=%d win=%hu csum=0x%04X urp=%d%s%s] ",
+ srcipstring, ntohs(tcp->th_sport),
+ dstipstring, ntohs(tcp->th_dport),
+ tflags, (unsigned long) ntohl(tcp->th_seq),
+ (unsigned long) ntohl(tcp->th_ack),
+ (u8)tcp->th_off, (u8)tcp->th_x2, ntohs(tcp->th_win),
+ ntohs(tcp->th_sum), ntohs(tcp->th_urp),
+ (tcpoptinfo[0]!='\0') ? " " : "",
+ tcpoptinfo);
+ }
+
+ strncpy((char*)dstbuff, protoinfo, dstlen);
+
+ return OP_SUCCESS;
+
+} /* End of tcppackethdrinfo() */
+
+
+
+
+int udppackethdrinfo(const u8 *packet, size_t len, u8 *dstbuff, size_t dstlen,
+ int detail, struct sockaddr_storage *src, struct sockaddr_storage *dst){
+
+ struct udp_hdr *udp = NULL; /* UDP header structure. */
+ static char protoinfo[1024] = ""; /* Stores final info string. */
+ struct sockaddr_in *s4=(struct sockaddr_in *)src;
+ struct sockaddr_in6 *s6=(struct sockaddr_in6 *)src;
+ struct sockaddr_in *d4=(struct sockaddr_in *)dst;
+ struct sockaddr_in6 *d6=(struct sockaddr_in6 *)dst;
+ char srcipstring[128];
+ char dstipstring[128];
+
+ assert(packet);
+ assert(dstbuff);
+ assert(len>=8);
+
+ udp=(struct udp_hdr *)packet;
+
+ /* Ensure we end up with a valid detail number */
+ if( detail!=LOW_DETAIL && detail!=MEDIUM_DETAIL && detail!=HIGH_DETAIL)
+ detail=LOW_DETAIL;
+
+
+ /* Determine target IP address */
+ if(src!=NULL){
+ if( s4->sin_family==AF_INET ){
+ inet_ntop(AF_INET, &s4->sin_addr, srcipstring, sizeof(srcipstring));
+ }
+ else if( s6->sin6_family==AF_INET6){
+ inet_ntop(AF_INET6, &s6->sin6_addr, srcipstring, sizeof(srcipstring));
+ }else{
+ sprintf(dstipstring, "unknown_addr_family");
+ }
+ }else{
+ sprintf(srcipstring, "this_host");
+ }
+
+ /* Determine source IP address */
+ if(dst!=NULL){
+ if( d4->sin_family==AF_INET ){
+ inet_ntop(AF_INET, &d4->sin_addr, dstipstring, sizeof(dstipstring));
+ }
+ else if( d6->sin6_family==AF_INET6){
+ inet_ntop(AF_INET6, &d6->sin6_addr, dstipstring, sizeof(dstipstring));
+ }else{
+ sprintf(dstipstring, "unknown_addr_family");
+ }
+ }else{
+ sprintf(dstipstring, "unknown_host");
+ }
+
+ if( detail == LOW_DETAIL ){
+ Snprintf(protoinfo, sizeof(protoinfo), "UDP %s:%d > %s:%d",
+ srcipstring, ntohs(udp->uh_sport), dstipstring, ntohs(udp->uh_dport));
+ }else if( detail == MEDIUM_DETAIL ){
+ Snprintf(protoinfo, sizeof(protoinfo), "UDP [%s:%d > %s:%d csum=0x%04X]",
+ srcipstring, ntohs(udp->uh_sport), dstipstring, ntohs(udp->uh_dport), ntohs(udp->uh_sum));
+ }else if( detail==HIGH_DETAIL ){
+ Snprintf(protoinfo, sizeof(protoinfo), "UDP [%s:%d > %s:%d len=%d csum=0x%04X]",
+ srcipstring, ntohs(udp->uh_sport), dstipstring, ntohs(udp->uh_dport),
+ ntohs(udp->uh_ulen), ntohs(udp->uh_sum));
+ }
+
+ strncpy((char*)dstbuff, protoinfo, dstlen);
+
+ return OP_SUCCESS;
+
+} /* End of udppackethdrinfo() */
+
+
+
+/** Returns a random (null-terminated) ASCII string with no special
+ * meaning. Returned string may be between 1 and 512 bytes and contain
+ * random letters and some whitespace.
+ * @warning Returned string is stored in a static buffer that subsequent
+ * calls will overwrite.
+ * Note that the entropy of the returned data is very low (returned
+ * values are always formed by lowercase letters and whitespace). */
+const char *getRandomTextPayload(){
+ int len=0, i=0;
+ static char buffer[512+1];
+ const char letters[26]={'a','b','c','d','e','f','g','h','i','j','k',
+ 'l','m','n','o','p','q','r','s','t','u','v',
+ 'w','z','y','z'};
+
+ /* Determine how long the text should be */
+ while( (len=(2*get_random_u8())-1) == 0 );
+ /* Create the string */
+ for(i=0; i<len; i++){
+ if( get_random_u8()%5==0 )
+ buffer[i] = ' '; // Whitespace
+ else
+ buffer[i] = letters[ get_random_u8()%26 ];
+ }
+ buffer[len]='\0';
+ return buffer;
+} /* End of getRandomTextPayload() */
+
+
+
+/** UNIMPLEMENTED */
+int send_packet(NpingTarget *target, int rawfd, u8 *pkt, size_t pktLen){
+ int res;
+ struct sockaddr_in6 s6;
+ assert(pkt);
+ assert(target);
+ assert(pktLen > 0);
+
+ if ( o.sendEth() ){
+ eth_t *ethsd = eth_open_cached(o.getDevice());
+ eth_send(ethsd, pkt, pktLen);
+ }else{
+ if( o.ipv6() ){ /* IPv6 */
+ memset(&s6, 0, sizeof(struct sockaddr_in6));
+ s6.sin6_family=AF_INET6;
+ s6.sin6_addr = target->getIPv6Address();
+
+ /*
+ if( o.getMode()==TCP ){
+ dport=getDstPortFromTCPHeader(pkt, pktLen);
+ if(dport!=NULL)
+ s6.sin6_port = *dport;
+ else
+ nping_fatal(QT_3, "send_packet(): Could not determine TCP destination port.");
+ }
+ else if( o.getMode()==UDP){
+ dport=getDstPortFromUDPHeader(pkt, pktLen);
+ if(dport!=NULL)
+ s6.sin6_port = *dport;
+ else
+ nping_fatal(QT_3, "send_packet(): Could not determine UDP destination port.");
+ }
+ */
+
+ /* Linux doesn't seem to like sin6_port to be set to other value
+ * than 0. Unless we set it to zero, the sendto() call returns
+ * "Invalid argument" error. Does this happen in other systems?
+ * TODO: Should we check here if #ifdef LINUX and set the port to
+ * zero? */
+ s6.sin6_port=0;
+
+ res = Sendto("send_packet", rawfd, pkt, pktLen, 0, (struct sockaddr *)&s6, (int) sizeof(struct sockaddr_in6));
+ /*Sendto returns errors as -1 according to netutil.cc so lets catch that and return OP_FAILURE*/
+ if (res == -1) return OP_FAILURE;
+ }else{ /* IPv4 */
+ struct sockaddr_storage dst;
+ size_t dstlen;
+
+ dstlen = sizeof(dst);
+ target->getTargetSockAddr(&dst, &dstlen);
+ assert(dst.ss_family == AF_INET);
+ if( o.issetMTU() == true )
+ res = send_frag_ip_packet(rawfd, NULL, (struct sockaddr_in *) &dst, pkt, pktLen, o.getMTU() );
+ else
+ res = send_ip_packet_sd(rawfd, (struct sockaddr_in *) &dst, pkt, pktLen);
+ /*send_ip_packet_sd calls Sendto which returns errors as -1 according to netutil.cc so lets catch that and return OP_FAILURE*/
+ if (res == -1) return OP_FAILURE;
+ }
+ }
+ return OP_SUCCESS;
+} /* End of send_packet() */
+
+
+
+int print_dnet_interface(const struct intf_entry *entry, void *arg) {
+ if (entry==NULL)
+ return 0;
+ printf("*************************************************\n");
+ printf("intf_len = %d\n", entry->intf_len);
+ printf("intf_name = %s\n", entry->intf_name);
+ printf("intf_type = %u\n", entry->intf_type);
+ printf("intf_flags = %02x\n", entry->intf_flags);
+ printf("intf_mtu = %d\n", entry->intf_mtu);
+ printf("intf_addr = %s\n", addr_ntoa(&entry->intf_addr));
+ printf("intf_dst_addr = %s\n", addr_ntoa(&entry->intf_dst_addr));
+ printf("intf_link_addr = %s\n", addr_ntoa(&entry->intf_link_addr));
+ printf("intf_alias_num = %d\n", entry->intf_alias_num);
+ for(unsigned int i=0; i<entry->intf_alias_num; i++)
+ printf("intf_alias_addrs[%d] = %s\n", i, addr_ntoa(&entry->intf_alias_addrs[i]));
+ return 0;
+}
+
+
+/* Get a list of interfaces using dnet and intf_loop. */
+int print_interfaces_dnet() {
+ intf_t *it;
+ /* Initialize the interface array. */
+ it = intf_open();
+ if (!it)
+ fatal("%s: intf_open() failed. NULL descriptor", __func__);
+ if (intf_loop(it, print_dnet_interface, NULL) != 0)
+ fatal("%s: intf_loop() failed", __func__);
+ intf_close(it);
+ return 0;
+}
+
+
+
+/** @warning Returns pointer to an internal static buffer */
+struct sockaddr_storage *getSrcSockAddrFromIPPacket(u8 *pkt, size_t pktLen){
+ static struct sockaddr_storage ss;
+ struct sockaddr_in *s_ip4=(struct sockaddr_in *)&ss;
+ struct sockaddr_in6 *s_ip6=(struct sockaddr_in6 *)&ss;
+ struct ip *i4=(struct ip*)pkt;
+ memset(&ss, 0, sizeof(struct sockaddr_storage));
+
+ if(pkt==NULL || pktLen < 20)
+ return NULL;
+
+ if( i4->ip_v == 4 ){
+ s_ip4->sin_family=AF_INET;
+ memcpy(&(s_ip4->sin_addr.s_addr), pkt+12, 4);
+ }
+ else if(i4->ip_v == 6 ){
+ if(pktLen<40) /* Min length of an IPv6 header: 40 bytes*/
+ return NULL;
+ s_ip6->sin6_family=AF_INET6;
+ memcpy(s_ip6->sin6_addr.s6_addr, pkt+8, 16);
+ }
+ else{
+ return NULL;
+ }
+ return &ss;
+} /* End of getSrcSockAddrFromPacket() */
+
+
+
+
+
+u8 *getUDPheaderLocation(u8 *pkt, size_t pktLen){
+ struct ip *i4=(struct ip*)pkt;
+ if(pkt==NULL || pktLen < 40)
+ return NULL;
+
+ /* Packet is IPv4 */
+ if( i4->ip_v == 4 ){
+ if (i4->ip_p == IPPROTO_UDP) {
+ if( pktLen >= ((size_t)(i4->ip_hl*4 + 8)) ) /* We have a full IP+UDP packet */
+ return pkt+(i4->ip_hl*4);
+ }
+ else
+ return NULL;
+ }
+ /* Packet is IPv6 */
+ else if(i4->ip_v == 6 ){
+ if(pktLen<40 + 8 )
+ return NULL;
+ if( pkt[6] == IPPROTO_UDP ) /* Next Header is UDP? */
+ return pkt+40;
+ else /* Extension headers not supported, return NULL TODO: support it? */
+ return NULL;
+ }
+ else{
+ return NULL;
+ }
+ return NULL;
+} /* End of getUDPheaderLocation */
+
+
+u8 *getTCPheaderLocation(u8 *pkt, size_t pktLen){
+ struct ip *i4=(struct ip*)pkt;
+ if(pkt==NULL || pktLen < 40)
+ return NULL;
+
+ /* Packet is IPv4 */
+ if( i4->ip_v == 4 ){
+ if (i4->ip_p == IPPROTO_TCP) { /* Next proto is TCP? */
+ if( pktLen >= ((size_t)(i4->ip_hl*4 + 20)) ) /* We have a full IP+TCP packet */
+ return pkt+(i4->ip_hl*4);
+ }
+ else
+ return NULL;
+ }
+ /* Packet is IPv6 */
+ else if(i4->ip_v == 6 ){
+ if(pktLen<40 + 20 )
+ return NULL;
+ if( pkt[6] == IPPROTO_TCP ) /* Next Header is TCP? */
+ return pkt+40;
+ else /* Extension headers not supported, return NULL TODO: support it? */
+ return NULL;
+ }
+ else{
+ return NULL;
+ }
+
+ return NULL;
+
+} /* End of getTCPHeaderLocation() */
+
+
+
+
+/* Returns the IP protocol of the packet or -1 in case of failure */
+u8 getProtoFromIPPacket(u8 *pkt, size_t pktLen){
+ struct ip *i4=(struct ip*)pkt;
+ static u8 proto;
+
+ if(pkt==NULL || pktLen < 28)
+ return -1;
+
+ /* Packet is IPv4 */
+ if( i4->ip_v == 4 ){
+ proto = i4->ip_p;
+ return proto;
+ }
+
+ /* Packet is IPv6 */
+ else if(i4->ip_v == 6 ){
+ proto = pkt[6];
+ return proto;
+ }
+ return -1;
+} /* End of getProtoFromIPPacket() */
+
+
+
+/** @warning Returns pointer to an internal static buffer
+ * @return pointer on success, NULL in case of failure */
+u16 *getSrcPortFromIPPacket(u8 *pkt, size_t pktLen){
+ static u16 port;
+ u16 *pnt=NULL;
+ u8 *header=NULL;
+
+ if(pkt==NULL || pktLen < 28)
+ return NULL;
+
+ if((header=getTCPheaderLocation(pkt, pktLen))==NULL){
+ if ((header=getUDPheaderLocation(pkt, pktLen))==NULL)
+ return NULL;
+
+ }
+ pnt=(u16*)&(header[0]);
+ port= ntohs(*pnt);
+ return &port;
+} /* End of getSrcPortFromIPPacket() */
+
+
+/** @warning Returns pointer to an internal static buffer
+ * @return pointer on success, NULL in case of failure */
+u16 *getDstPortFromIPPacket(u8 *pkt, size_t pktLen){
+ static u16 port;
+ u16 *pnt=NULL;
+ u8 *header=NULL;
+
+ if(pkt==NULL || pktLen < 28)
+ return NULL;
+
+ if((header=getTCPheaderLocation(pkt, pktLen))==NULL){
+ if ((header=getUDPheaderLocation(pkt, pktLen))==NULL)
+ return NULL;
+ }
+ pnt=(u16*)&(header[2]);
+ port= ntohs(*pnt);
+ return &port;
+} /* End of getDstPortFromIPPacket() */
+
+
+/** @warning Returns pointer to an internal static buffer
+ * @return pointer on success, NULL in case of failure */
+u16 *getDstPortFromTCPHeader(u8 *pkt, size_t pktLen){
+ static u16 port;
+ u16 *pnt=NULL;
+
+ if(pkt==NULL || pktLen < 20)
+ return NULL;
+ pnt=(u16*)&(pkt[2]);
+ port= ntohs(*pnt);
+ return &port;
+} /* End of getDstPortFromTCPHeader() */
+
+
+/** @warning Returns pointer to an internal static buffer
+ * @return pointer on success, NULL in case of failure */
+u16 *getDstPortFromUDPHeader(u8 *pkt, size_t pktLen){
+ static u16 port;
+ u16 *pnt=NULL;
+
+ if(pkt==NULL || pktLen < 8)
+ return NULL;
+ pnt=(u16*)&(pkt[2]);
+ port= ntohs(*pnt);
+ return &port;
+} /* End of getDstPortFromUDPHeader() */
+
+
+int obtainRawSocket(){
+ int rawipsd=0;
+ int protocol=0;
+ int one=1;
+
+ if( o.ipv6() ){
+ switch( o.getMode() ){
+
+ case TCP:
+ protocol = IPPROTO_TCP;
+ break;
+
+ case UDP:
+ protocol = IPPROTO_UDP;
+ break;
+
+ case ICMP:
+ protocol = IPPROTO_ICMPV6;
+ break;
+
+ case ARP:
+ nping_warning(QT_2,"Warning: createRawSocket() should not be called in ARP mode.");
+ return 0;
+ break;
+
+ default:
+ nping_fatal(QT_3, "createRawSocket(): NpingOps::getMode() does not return a valid mode. Please report this bug.");
+ break;
+
+ }
+ if ((rawipsd = socket(AF_INET6, SOCK_RAW, protocol)) < 0 )
+ nping_fatal(QT_3,"Couldn't acquire IPv6 raw socket. Are you root?");
+
+ }else{
+ if ((rawipsd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0 )
+ nping_fatal(QT_3,"Couldn't acquire IPv4 raw socket. Are you root?");
+ /* Tell the kernel we are including our own IP Header (call to
+ * setsockopt passing option IP_HDRINCL) */
+ sethdrinclude(rawipsd);
+ }
+
+ /* Allow broadcast addresses */
+ if (setsockopt(rawipsd, SOL_SOCKET, SO_BROADCAST, (const char *)&one, sizeof(int)) == -1)
+ nping_warning(QT_2,"Failed to set SO_BROADCAST on raw socket.");
+
+ return rawipsd;
+} /* End of obtainRawSocket() */
+
+
+/** This function parses Linux file /proc/net/if_inet6 and returns a list
+ of network interfaces that are configured for IPv6.
+ @param ifbuff should be a buffer big enough to hold info for max_ifaces
+ interfaces.
+
+ Here is some info about the format of /proc/net/if_inet6, written by
+ Peter Bieringer and taken from:
+ http://tldp.org/HOWTO/Linux+IPv6-HOWTO/proc-net.html :
+
+ # cat /proc/net/if_inet6
+ 00000000000000000000000000000001 01 80 10 80 lo
+ +------------------------------+ ++ ++ ++ ++ ++
+ | | | | | |
+ 1 2 3 4 5 6
+
+ 1. IPv6 address displayed in 32 hexadecimal chars without colons as separator
+ 2. Netlink device number (interface index) in hexadecimal (see “ip addr” , too)
+ 3. Prefix length in hexadecimal
+ 4. Scope value (see kernel source “ include/net/ipv6.h” and “net/ipv6/addrconf.c” for more)
+ 5. Interface flags (see “include/linux/rtnetlink.h” and “net/ipv6/addrconf.c” for more)
+ 6. Device name
+
+
+ @warning This function is NOT portable. It will only work on Linux systems
+ and may not work in chroot-ed environments because it needs to be able
+ to access /proc/net/if_inet6.
+
+ */
+int getinterfaces_inet6_linux(if6_t *ifbuf, int max_ifaces){
+ FILE *if6file=NULL;
+ size_t i=0, j=0;
+ int readlines=0;
+ int parsed_ifs=0;
+ bool badaddr=false;
+ bool hasifname=false;
+ char buffer[2048];
+ char twobytes[3];
+ memset(buffer, 0, sizeof(buffer));
+
+ if(ifbuf==NULL || max_ifaces<=0)
+ nping_fatal(QT_3,"getinterfaces_inet6_linux() NULL values supplied");
+
+ /* TODO: Do we fatal() or should we just error and return OP_FAILURE? */
+ if ( !file_is_readable(PATH_PROC_IFINET6) )
+ nping_fatal(QT_3, "Couldn't get IPv6 interface information. File %s does not exist or you don't have read permissions.", PATH_PROC_IFINET6);
+ if( (if6file=fopen(PATH_PROC_IFINET6, "r"))==NULL )
+ nping_fatal(QT_3, "Failed to open %s.", PATH_PROC_IFINET6);
+
+ while( fgets(buffer,sizeof(buffer), if6file) ){
+
+ if(parsed_ifs>=max_ifaces)
+ break;
+
+ nping_print(DBG_4, "Read %s:%d: %s\n", PATH_PROC_IFINET6, ++readlines, buffer);
+
+ /* Check the line has the expected format ********************************/
+ /* Some versions of the kernel include colons in the IPv6 address, some
+ * others don't. E.g:
+ * fe80:0000:0000:0000:0333:a5ff:4444:9306 03 40 20 80 wlan0
+ * fe800000000000000333a5ff44449306 03 40 20 80 wlan0
+ * So what we do is to remove the colons so we can process the line
+ * no matter the format of the IPv6 addresses.
+ *
+ * TODO: Can interfaces with format eth0:1 appear on /proc/net/if_inet6?
+ * If they can, then we need to change the code to skip the last : */
+ removecolon(buffer);
+
+ /* 1. Check it has the correct length */
+ if( strlen(buffer) < strlen("00000000000000000000000000000001 01 80 10 80 lo") ){
+ continue;
+ }
+ /* 2. Check the inet6 address only contains hex digits */
+ for(i=0; i<32; i++){
+ if( !isxdigit(buffer[i]) ){
+ badaddr=true;
+ break;
+ }
+ }
+ if(badaddr){
+ badaddr=false;
+ continue;
+ }
+ /* 2. Check spaces are in the appropriate place */
+ if( buffer[32]!=' ' || buffer[35]!=' ' || buffer[38]!=' ' || buffer[41]!=' ' || buffer[44]!=' ' ){
+ continue;
+ }
+
+ /* 3. Check we have numbers in the part where we are supposed to have them */
+ if( !isxdigit( buffer[33] ) || !isxdigit( buffer[34] ) ||
+ !isxdigit( buffer[36] ) || !isxdigit( buffer[37] ) ||
+ !isxdigit( buffer[39] ) || !isxdigit( buffer[40] ) ||
+ !isxdigit( buffer[42] ) || !isxdigit( buffer[43] ) ){
+ continue;
+ }
+
+ /* 4. Check we actually have an interface name afterwards */
+ for(i=44; i<strlen(buffer); i++){
+ if( isalpha(buffer[i]) )
+ hasifname=true;
+ }
+ if(!hasifname){
+ hasifname=false;
+ continue;
+ }
+
+ /* If we get here means the read line has the expected format so we
+ * read the information and store it in a interface_info structure *
+ */
+
+ /* Store IPv6 address */
+ u8 ipv6addr[16];
+ for(i=0, j=0; j<16 && i<32; i+=2){
+ twobytes[0]=buffer[i];
+ twobytes[1]=buffer[i+1];
+ twobytes[2]='\0';
+ ipv6addr[j++]=(u8)strtol(twobytes, NULL, 16);
+ }
+
+ /* Store Netlink device number */
+ u8 dev_no;
+ twobytes[0]=buffer[33]; twobytes[1]=buffer[34]; twobytes[2]='\0';
+ dev_no=(u8)strtol(twobytes, NULL, 16);
+
+ /* Store prefix length */
+ u8 prefix_len;
+ twobytes[0]=buffer[36]; twobytes[1]=buffer[37]; twobytes[2]='\0';
+ prefix_len=(u8)strtol(twobytes, NULL, 16);
+
+ /* Store scope value */
+ u8 scope_value;
+ twobytes[0]=buffer[39]; twobytes[1]=buffer[40]; twobytes[2]='\0';
+ scope_value=(u8)strtol(twobytes, NULL, 16);
+
+ /* Store interface flags */
+ u8 dev_flags;
+ twobytes[0]=buffer[42]; twobytes[1]=buffer[43]; twobytes[2]='\0';
+ dev_flags=(u8)strtol(twobytes, NULL, 16);
+
+ /* Store interface name */
+ char devname[DEVNAMELEN];
+ memset(devname, 0, DEVNAMELEN);
+ for(i=44, j=0; i<strlen(buffer) && j<DEVNAMELEN-1; i++){
+ if( buffer[i]==' ' || buffer[i]=='\n')
+ continue;
+ else
+ devname[j++]=buffer[i];
+ }
+ devname[j]='\0';
+
+
+ /* Once we have all the info, copy it to user supplied buffer */
+ memset(&ifbuf[parsed_ifs], 0, sizeof(if6_t));
+ memcpy( ifbuf[parsed_ifs].devname, devname, DEVNAMELEN);
+ struct sockaddr_in6 *s6=(struct sockaddr_in6 *)&ifbuf[parsed_ifs].ss;
+ s6->sin6_family=AF_INET6;
+ memcpy(s6->sin6_addr.s6_addr, ipv6addr, 16);
+ memcpy(ifbuf[parsed_ifs].addr, ipv6addr, 16);
+ ifbuf[parsed_ifs].netmask_bits=prefix_len;
+ ifbuf[parsed_ifs].dev_no=dev_no;
+ ifbuf[parsed_ifs].scope=scope_value;
+ ifbuf[parsed_ifs].flags=dev_flags;
+ /* ifbuf[parsed_ifs].mac = ??? (we don't know, we don't set it) */
+
+ parsed_ifs++;
+
+/* Debugging code: This should print the exact same lines that
+ * /proc/net/if_inet6 contains. (well, unless that kernel includes colons
+ * in the ipv6 address)
+ *
+ for(i=0; i<16; i++)
+ printf("%02x", ipv6addr[i]);
+ printf(" %02x", dev_no);
+ printf(" %02x", prefix_len);
+ printf(" %02x", scope_value);
+ printf(" %02x", dev_flags);
+ printf(" %8s\n", devname);
+ */
+
+ } /* End of loop */
+
+ /* Cleanup */
+ if(if6file)
+ fclose(if6file);
+ return parsed_ifs;
+} /* End of getinterfaces_inet6_linux() */
+
+
+/** This function parses Linux file /proc/net/ipv6_route and returns a list
+ of routes for IPv6 packets.
+ @param ifbuff should be a buffer big enough to hold info for max_routes
+ routes.
+
+ Here is some info about the format of /proc/net/if_inet6, written by
+ Peter Bieringer and taken from:
+ http://tldp.org/HOWTO/Linux+IPv6-HOWTO/proc-net.html :
+
+ # cat /proc/net/ipv6_route
+ 00000000000000000000000000000000 00 00000000000000000000000000000000 00
+ +------------------------------+ ++ +------------------------------+ ++
+ | | | |
+ 1 2 3 4
+
+ ¬ 00000000000000000000000000000000 ffffffff 00000001 00000001 00200200 lo
+ ¬ +------------------------------+ +------+ +------+ +------+ +------+ ++
+ ¬ | | | | | |
+ ¬ 5 6 7 8 9 10
+
+ 1. IPv6 destination network displayed in 32 hexadecimal chars without colons as separator
+ 2. IPv6 destination prefix length in hexadecimal
+ 3. IPv6 source network displayed in 32 hexadecimal chars without colons as separator
+ 4. IPv6 source prefix length in hexadecimal
+ 5. IPv6 next hop displayed in 32 hexadecimal chars without colons as separator
+ 6. Metric in hexadecimal
+ 7. Reference counter
+ 8. Use counter
+ 9. Flags
+10. Device name
+
+ @warning This function is NOT portable. It will only work on Linux systems
+ and may not work in chroot-ed environments because it needs to be able
+ to access /proc/net/ipv6_route.
+ */
+int getroutes_inet6_linux(route6_t *rtbuf, int max_routes){
+ FILE *route6file=NULL;
+ size_t i=0, j=0;
+ int readlines=0;
+ int parsed_routes=0;
+ bool badchars=false;
+ bool hasifname=false;
+ char buffer[2048];
+ char twobytes[3];
+ memset(buffer, 0, sizeof(buffer));
+
+ if(rtbuf==NULL || max_routes<=0)
+ nping_fatal(QT_3,"getroutes_inet6_linux() NULL values supplied");
+
+ /* TODO: Do we fatal() or should we just error and return OP_FAILURE? */
+ if ( !file_is_readable(PATH_PROC_IPV6ROUTE) )
+ nping_fatal(QT_3, "Couldn't get IPv6 route information. File %s does not exist or you don't have read permissions.", PATH_PROC_IPV6ROUTE);
+ if( (route6file=fopen(PATH_PROC_IPV6ROUTE, "r"))==NULL )
+ nping_fatal(QT_3, "Failed to open %s.", PATH_PROC_IPV6ROUTE);
+
+ while( fgets(buffer,sizeof(buffer), route6file) ){
+
+ if(parsed_routes>=max_routes)
+ break;
+
+ nping_print(DBG_4, "Read %s:%d: %s\n",PATH_PROC_IPV6ROUTE, ++readlines, buffer);
+
+ /* Check the line has the expected format ********************************/
+ /* Some versions of the kernel include colons in the IPv6 address, some
+ * others don't. So what we do is to remove the colons so we can process
+ * the line no matter the format of the IPv6 addresses.
+ *
+ * TODO: Can interfaces with format eth0:1 appear on /proc/net/ipv6_route?
+ * If they can, then we need to change the code to skip the last : */
+ removecolon(buffer);
+
+ /* 1. Check it has the correct length. */
+ size_t min_len=0;
+ min_len += 3*32; /* Three IPv6 addresses in hex */
+ min_len += 2*2; /* Two 8bit hex values (prefix lengths) */
+ min_len += 4*8; /* Four 32-bit hex values */
+ min_len += 1; /* I guess one char is the min for a device len */
+ min_len += 9; /* 9 spaces */
+ if( strlen(buffer) < min_len ){
+ continue;
+ }
+ /* 2. Check the first 140 characters only contain hex digits or spaces */
+ for(i=0; i<140; i++){
+ if( !isxdigit(buffer[i]) && buffer[i]!=' '){
+ badchars=true;
+ break;
+ }
+ }
+ if(badchars){
+ badchars=false;
+ continue;
+ }
+ /* 2. Check spaces are in the appropriate place */
+ if( buffer[32]!=' ' || buffer[71]!=' ' || buffer[122]!=' ' ||
+ buffer[35]!=' ' || buffer[104]!=' ' || buffer[131]!=' ' ||
+ buffer[68]!=' ' || buffer[113]!=' ' || buffer[140]!=' ' ){
+ continue;
+ }
+
+ /* 4. Check we actually have an interface name afterwards */
+ for(i=140; i<strlen(buffer); i++){
+ if( isalpha(buffer[i]) )
+ hasifname=true;
+ }
+ if(!hasifname){
+ hasifname=false;
+ continue;
+ }
+
+ /* If we get here means the read line has the expected format so we
+ * read the information and store it in a interface_info structure *
+ */
+
+ /* Store destination network address */
+ u8 dst_addr[16];
+ for(i=0, j=0; j<16 && i<32; i+=2){
+ twobytes[0]=buffer[i]; twobytes[1]=buffer[i+1]; twobytes[2]='\0';
+ dst_addr[j++]=(u8)strtol(twobytes, NULL, 16);
+ }
+ /* Store destination network prefix */
+ u8 dst_prefix;
+ twobytes[0]=buffer[33]; twobytes[1]=buffer[34]; twobytes[2]='\0';
+ dst_prefix=(u8)strtol(twobytes, NULL, 16);
+
+ /* Store source network address */
+ u8 src_addr[16];
+ for(i=36, j=0; j<16 && i<68; i+=2){
+ twobytes[0]=buffer[i]; twobytes[1]=buffer[i+1]; twobytes[2]='\0';
+ src_addr[j++]=(u8)strtol(twobytes, NULL, 16);
+ }
+ /* Store source network prefix */
+ u8 src_prefix;
+ twobytes[0]=buffer[69]; twobytes[1]=buffer[70]; twobytes[2]='\0';
+ src_prefix=(u8)strtol(twobytes, NULL, 16);
+
+ /* Store next hop address */
+ u8 nh_addr[16];
+ for(i=72, j=0; j<16 && i<104; i+=2){
+ twobytes[0]=buffer[i]; twobytes[1]=buffer[i+1]; twobytes[2]='\0';
+ nh_addr[j++]=(u8)strtol(twobytes, NULL, 16);
+ }
+
+ /* Store metric */
+ u8 metric[4];
+ for(i=105, j=0; j<4 && i<113; i+=2){
+ twobytes[0]=buffer[i]; twobytes[1]=buffer[i+1]; twobytes[2]='\0';
+ metric[j++]=(u8)strtol(twobytes, NULL, 16);
+ }
+
+ /* Store reference counter */
+ u8 ref_count[4];
+ for(i=114, j=0; j<4 && i<122; i+=2){
+ twobytes[0]=buffer[i]; twobytes[1]=buffer[i+1]; twobytes[2]='\0';
+ ref_count[j++]=(u8)strtol(twobytes, NULL, 16);
+ }
+
+ /* Store use counter */
+ u8 use_count[4];
+ for(i=123, j=0; j<4 && i<131; i+=2){
+ twobytes[0]=buffer[i]; twobytes[1]=buffer[i+1]; twobytes[2]='\0';
+ use_count[j++]=(u8)strtol(twobytes, NULL, 16);
+ }
+
+ /* Store flags */
+ u8 flags[4];
+ for(i=132, j=0; j<4 && i<140; i+=2){
+ twobytes[0]=buffer[i]; twobytes[1]=buffer[i+1]; twobytes[2]='\0';
+ flags[j++]=(u8)strtol(twobytes, NULL, 16);
+ }
+
+ /* Store interface name */
+ char devname[DEVNAMELEN];
+ memset(devname, 0, DEVNAMELEN);
+ for(i=140, j=0; i<strlen(buffer) && j<DEVNAMELEN-1; i++){
+ if( buffer[i]==' ' || buffer[i]=='\n')
+ continue;
+ else
+ devname[j++]=buffer[i];
+ }
+ devname[j]='\0';
+
+ /* Once we have all the info, copy it to user supplied buffer */
+ memset(&rtbuf[parsed_routes], 0, sizeof(route6_t));
+ memcpy(rtbuf[parsed_routes].dst_net.s6_addr, dst_addr, 16);
+ rtbuf[parsed_routes].dst_prefix=dst_prefix;
+ memcpy(rtbuf[parsed_routes].src_net.s6_addr, src_addr, 16);
+ rtbuf[parsed_routes].src_prefix=src_prefix;
+ memcpy(rtbuf[parsed_routes].next_hop.s6_addr, nh_addr, 16);
+
+ /* TODO: Check the endianness stuff here is implemented right.
+ * The thing is that the part of the linux kernel that prints the info
+ * to /proc/net/ipv6_rout is the following:
+ * [From /net/ipv6/route.c ]
+ * 2427 seq_printf(m, " %08x %08x %08x %08x %8s\n",
+ * 2428 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
+ * 2429 rt->u.dst.__use, rt->rt6i_flags,
+ * 2430 rt->rt6i_dev ? rt->rt6i_dev->name : "");
+ *
+ * So as they are actually printing 32bit values with %08x, they are
+ * getting printed out in network byte order (big endian) so we call
+ * ntohl() for each of them so we actually convert them to the right
+ * representation in the current machine. With 8-bit values we have no
+ * problem because they are converted to binary using strtol() and it
+ * handles endianness by itself. Am I doing anything wrong here?
+ * */
+ memcpy(&rtbuf[parsed_routes].metric, metric, 4);
+ rtbuf[parsed_routes].metric=ntohl(rtbuf[parsed_routes].metric);
+ memcpy(&rtbuf[parsed_routes].ref_count, ref_count, 4);
+ rtbuf[parsed_routes].ref_count=ntohl(rtbuf[parsed_routes].ref_count);
+ memcpy(&rtbuf[parsed_routes].use_count, use_count, 4);
+ rtbuf[parsed_routes].use_count=ntohl(rtbuf[parsed_routes].use_count);
+ memcpy(&rtbuf[parsed_routes].flags, flags, 4);
+ rtbuf[parsed_routes].flags=ntohl(rtbuf[parsed_routes].flags);
+ memcpy(rtbuf[parsed_routes].devname, devname, DEVNAMELEN);
+
+/* Debugging code: This should print the exact same lines that
+ * /proc/net/if_inet6 contains. (well, unless that kernel includes colons
+ * in the ipv6 address)
+ *
+ for(i=0; i<16; i++)
+ printf("%02x", rtbuf[parsed_routes].dst_net.s6_addr[i]);
+
+ printf(" %02x ", rtbuf[parsed_routes].dst_prefix);
+
+ for(i=0; i<16; i++)
+ printf("%02x", rtbuf[parsed_routes].src_net.s6_addr[i]);
+
+ printf(" %02x ", rtbuf[parsed_routes].src_prefix);
+
+ for(i=0; i<16; i++)
+ printf("%02x", rtbuf[parsed_routes].next_hop.s6_addr[i]);
+
+ printf(" %08x", rtbuf[parsed_routes].metric);
+ printf(" %08x", rtbuf[parsed_routes].ref_count);
+ printf(" %08x", rtbuf[parsed_routes].use_count);
+ printf(" %08x", rtbuf[parsed_routes].flags);
+ printf(" %8s\n", rtbuf[parsed_routes].devname);
+*/
+ parsed_routes++;
+
+ } /* End of loop */
+
+ /* Cleanup */
+ if(route6file)
+ fclose(route6file);
+ return parsed_routes;
+} /* End of getroutes_inet6_linux() */
+
+
+/** This function takes a sockaddr_storage pointer that MUST contain a valid
+ * IPv6 address (a sockaddr_in6 struct with sin6_family set to AF_INET6),
+ * and returns the best route entry for the supplied destination.
+ * The route entries are read from /proc/net/ipv6_route through function
+ * getroutes_inet6_linux().
+ * @warning This function is NOT portable. It will only work on Linux systems
+ * and may not work in chroot-ed environments because it needs to be able
+ * to access /proc/net/ipv6_route.
+ * @warning It returns NULL in case of error. Check for it or you'll segfault.
+ * @warning returned pointer points to a static buffer that subsequent calls
+ * will overwrite. */
+route6_t *route_dst_ipv6_linux(const struct sockaddr_storage *const dst){
+ struct sockaddr_in6 *dstsin6=NULL; /* Cast for supplied sockaddr_storage var */
+ route6_t routes6[64]; /* Array of IPv6 routes */
+ int total_routes6=0; /* Number of returned routes */
+ static route6_t theone; /* Stores the best route we find */
+ route6_t *def_gw=NULL; /* Stores default gateway */
+ int best_match=0; /* Max number of bits that we've matched */
+ int curr_match=0; /* Matching bits in current route */
+ u8 zero_addr[16]; /* Just to compare route to addr "::" */
+ memset(zero_addr, 0, 16);
+ dstsin6=(struct sockaddr_in6 *)dst;
+
+ if(dst==NULL) return NULL;
+ if(dstsin6->sin6_family!=AF_INET6) return NULL;
+
+ /* Let's parse /proc/net/ipv6_route and get a list of routes */
+ if ( (total_routes6=getroutes_inet6_linux(routes6, 64)) <= 0 )
+ return NULL;
+
+ /* Now we go over the whole route list and select the match that has the
+ * largest prefix length */
+
+ for(int i=0; i<total_routes6; i++){
+ /* Check how many bits they have in common */
+ curr_match=bitcmp(dstsin6->sin6_addr.s6_addr, routes6[i].dst_net.s6_addr, 16);
+
+ /* Select only the best match (always taking into account that
+ * our dst address needs to match at least dst_prefix bits. */
+ if( curr_match > best_match && curr_match>=routes6[i].dst_prefix){
+ best_match=curr_match;
+ memcpy(&theone, &routes6[i], sizeof(route6_t));
+ }
+ /* There was no match, but we check if the route is actually "::"
+ * (like 0.0.0.0 in IPv4). If it is, we store it, just in case we
+ * end up without a better route. */
+ else if ( !memcmp( routes6[i].dst_net.s6_addr, zero_addr, 16) ){
+ if(def_gw==NULL){
+ def_gw=&routes6[i];
+ }
+ else if( !strncmp("lo", def_gw->devname, 2) ){
+ /* If the route we have is through the loopback interface,
+ * overwrite it, we prefer to choose any other device as
+ * the default gateway. We just compare the first two
+ * letters cause in Linux the interface is called "lo" but
+ * on BSD is usually called lo0. */
+ def_gw=&routes6[i];
+ }
+ }
+ }
+ if( best_match==0 ){
+ if(def_gw!=NULL)
+ memcpy(&theone, def_gw, sizeof(route6_t));
+ else return NULL;
+ }
+ return &theone;
+} /* End of route_dst_ipv6() */