455 #if defined(__linux__)

   455 #if defined(_AIX)

   456 

   457 /* following code creates a list of addresses from the kernel

   458  * routing table that are routed via the loopback address.

   459  * We check all destination addresses against this table

   460  * and override the scope_id field to use the relevant value for "lo"

   461  * in order to work-around the Linux bug that prevents packets destined

   462  * for certain local addresses from being sent via a physical interface.

   463  */

   464 

   465 struct loopback_route {

   466     struct in6_addr addr; /* destination address */

   467     int plen; /* prefix length */

   468 };

   469 

   470 static struct loopback_route *loRoutes = 0;

   471 static int nRoutes = 0; /* number of routes */

   472 static int loRoutes_size = 16; /* initial size */

   473 static int lo_scope_id = 0;

   474 

   475 static void initLoopbackRoutes();

   476 

   477 void printAddr (struct in6_addr *addr) {

   478     int i;

   479     for (i=0; i<16; i++) {

   480         printf ("%02x", addr->s6_addr[i]);

   481     }

   482     printf ("\n");

   483 }

   484 

   485 static jboolean needsLoopbackRoute (struct in6_addr* dest_addr) {

   486     int byte_count;

   487     int extra_bits, i;

   488     struct loopback_route *ptr;

   489 

   490     if (loRoutes == 0) {

   491         initLoopbackRoutes();

   492     }

   493 

   494     for (ptr = loRoutes, i=0; i<nRoutes; i++, ptr++) {

   495         struct in6_addr *target_addr=&ptr->addr;

   496         int dest_plen = ptr->plen;

   497         byte_count = dest_plen >> 3;

   498         extra_bits = dest_plen & 0x3;

   499 

   500         if (byte_count > 0) {

   501             if (memcmp(target_addr, dest_addr, byte_count)) {

   502                 continue;  /* no match */

   503             }

   504         }

   505 

   506         if (extra_bits > 0) {

   507             unsigned char c1 = ((unsigned char *)target_addr)[byte_count];

   508             unsigned char c2 = ((unsigned char *)&dest_addr)[byte_count];

   509             unsigned char mask = 0xff << (8 - extra_bits);

   510             if ((c1 & mask) != (c2 & mask)) {

   511                 continue;

   512             }

   513         }

   514         return JNI_TRUE;

   515     }

   516     return JNI_FALSE;

   517 }

   518 

   519 

   520 static void initLoopbackRoutes() {

   521     FILE *f;

   522     char srcp[8][5];

   523     char hopp[8][5];

   524     int dest_plen, src_plen, use, refcnt, metric;

   525     unsigned long flags;

   526     char dest_str[40];

   527     struct in6_addr dest_addr;

   528     char device[16];

   529     struct loopback_route *loRoutesTemp;

   530 

   531     if (loRoutes != 0) {

   532         free (loRoutes);

   533     }

   534     loRoutes = calloc (loRoutes_size, sizeof(struct loopback_route));

   535     if (loRoutes == 0) {

   536         return;

   537     }

   538     /*

   539      * Scan /proc/net/ipv6_route looking for a matching

   540      * route.

   541      */

   542     if ((f = fopen("/proc/net/ipv6_route", "r")) == NULL) {

   543         return ;

   544     }

   545     while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x "

   546                      "%4s%4s%4s%4s%4s%4s%4s%4s %02x "

   547                      "%4s%4s%4s%4s%4s%4s%4s%4s "

   548                      "%08x %08x %08x %08lx %8s",

   549                      dest_str, &dest_str[5], &dest_str[10], &dest_str[15],

   550                      &dest_str[20], &dest_str[25], &dest_str[30], &dest_str[35],

   551                      &dest_plen,

   552                      srcp[0], srcp[1], srcp[2], srcp[3],

   553                      srcp[4], srcp[5], srcp[6], srcp[7],

   554                      &src_plen,

   555                      hopp[0], hopp[1], hopp[2], hopp[3],

   556                      hopp[4], hopp[5], hopp[6], hopp[7],

   557                      &metric, &use, &refcnt, &flags, device) == 31) {

   558 

   559         /*

   560          * Some routes should be ignored

   561          */

   562         if ( (dest_plen < 0 || dest_plen > 128)  ||

   563              (src_plen != 0) ||

   564              (flags & (RTF_POLICY | RTF_FLOW)) ||

   565              ((flags & RTF_REJECT) && dest_plen == 0) ) {

   566             continue;

   567         }

   568 

   569         /*

   570          * Convert the destination address

   571          */

   572         dest_str[4] = ':';

   573         dest_str[9] = ':';

   574         dest_str[14] = ':';

   575         dest_str[19] = ':';

   576         dest_str[24] = ':';

   577         dest_str[29] = ':';

   578         dest_str[34] = ':';

   579         dest_str[39] = '\0';

   580 

   581         if (inet_pton(AF_INET6, dest_str, &dest_addr) < 0) {

   582             /* not an Ipv6 address */

   583             continue;

   584         }

   585         if (strcmp(device, "lo") != 0) {

   586             /* Not a loopback route */

   587             continue;

   588         } else {

   589             if (nRoutes == loRoutes_size) {

   590                 loRoutesTemp = realloc (loRoutes, loRoutes_size *

   591                                         sizeof (struct loopback_route) * 2);

   592 

   593                 if (loRoutesTemp == 0) {

   594                     free(loRoutes);

   595                     loRoutes = NULL;

   596                     nRoutes = 0;

   597                     fclose (f);

   598                     return;

   599                 }

   600                 loRoutes=loRoutesTemp;

   601                 loRoutes_size *= 2;

   602             }

   603             memcpy (&loRoutes[nRoutes].addr,&dest_addr,sizeof(struct in6_addr));

   604             loRoutes[nRoutes].plen = dest_plen;

   605             nRoutes ++;

   606         }

   607     }

   608 

   609     fclose (f);

   610     {

   611         /* now find the scope_id for "lo" */

   612 

   613         char devname[21];

   614         char addr6p[8][5];

   615         int plen, scope, dad_status, if_idx;

   616 

   617         if ((f = fopen("/proc/net/if_inet6", "r")) != NULL) {

   618             while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %08x %02x %02x %02x %20s\n",

   619                       addr6p[0], addr6p[1], addr6p[2], addr6p[3],

   620                       addr6p[4], addr6p[5], addr6p[6], addr6p[7],

   621                   &if_idx, &plen, &scope, &dad_status, devname) == 13) {

   622 

   623                 if (strcmp(devname, "lo") == 0) {

   624                     /*

   625                      * Found - so just return the index

   626                      */

   627                     fclose(f);

   628                     lo_scope_id = if_idx;

   629                     return;

   630                 }

   631             }

   632             fclose(f);

   633         }

   634     }

   635 }

   636 

   637 /*

   638  * Following is used for binding to local addresses. Equivalent

   639  * to code above, for bind().

   640  */

   641 

   642 struct localinterface {

   643     int index;

   644     char localaddr [16];

   645 };

   646 

   647 static struct localinterface *localifs = 0;

   648 static int localifsSize = 0;    /* size of array */

   649 static int nifs = 0;            /* number of entries used in array */

   650 

   651 /* not thread safe: make sure called once from one thread */

   652 

   653 static void initLocalIfs () {

   654     FILE *f;

   655     unsigned char staddr [16];

   656     char ifname [33];

   657     struct localinterface *lif=0;

   658     struct localinterface *localifsTemp;

   659     int index, x1, x2, x3;

   660     unsigned int u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,ua,ub,uc,ud,ue,uf;

   661 

   662     if ((f = fopen("/proc/net/if_inet6", "r")) == NULL) {

   663         return ;

   664     }

   665     while (fscanf (f, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x "

   666                 "%d %x %x %x %32s",&u0,&u1,&u2,&u3,&u4,&u5,&u6,&u7,

   667                 &u8,&u9,&ua,&ub,&uc,&ud,&ue,&uf,

   668                 &index, &x1, &x2, &x3, ifname) == 21) {

   669         staddr[0] = (unsigned char)u0;

   670         staddr[1] = (unsigned char)u1;

   671         staddr[2] = (unsigned char)u2;

   672         staddr[3] = (unsigned char)u3;

   673         staddr[4] = (unsigned char)u4;

   674         staddr[5] = (unsigned char)u5;

   675         staddr[6] = (unsigned char)u6;

   676         staddr[7] = (unsigned char)u7;

   677         staddr[8] = (unsigned char)u8;

   678         staddr[9] = (unsigned char)u9;

   679         staddr[10] = (unsigned char)ua;

   680         staddr[11] = (unsigned char)ub;

   681         staddr[12] = (unsigned char)uc;

   682         staddr[13] = (unsigned char)ud;

   683         staddr[14] = (unsigned char)ue;

   684         staddr[15] = (unsigned char)uf;

   685         nifs ++;

   686         if (nifs > localifsSize) {

   687             localifsTemp = (struct localinterface *) realloc(

   688                         localifs, sizeof (struct localinterface)* (localifsSize+5));

   689             if (localifsTemp == 0) {

   690                 free(localifs);

   691                 localifs = 0;

   692                 localifsSize = 0;

   693                 nifs = 0;

   694                 fclose(f);

   695                 return;

   696             }

   697             localifs = localifsTemp;

   698             lif = localifs + localifsSize;

   699             localifsSize += 5;

   700         } else {

   701             lif ++;

   702         }

   703         memcpy (lif->localaddr, staddr, 16);

   704         lif->index = index;

   705     }

   706     fclose (f);

   707 }

   708 

   709 /* return the scope_id (interface index) of the

   710  * interface corresponding to the given address

   711  * returns 0 if no match found

   712  */

   713 

   714 static int getLocalScopeID (char *addr) {

   715     struct localinterface *lif;

   716     int i;

   717     if (localifs == 0) {

   718         initLocalIfs();

   719     }

   720     for (i=0, lif=localifs; i<nifs; i++, lif++) {

   721         if (memcmp (addr, lif->localaddr, 16) == 0) {

   722             return lif->index;

   723         }

   724     }

   725     return 0;

   726 }

   727 

   728 void platformInit () {

   729     initLoopbackRoutes();

   730     initLocalIfs();

   731 }

   732 

   733 #elif defined(_AIX)