gomp-20050608-branch/libjava/classpath/native/jni/java-net/java_net_VMInetAddress.c

   1 /* VMInetAddress.c - Native methods for InetAddress class
   2    Copyright (C) 1998, 2002, 2005, 2006  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 /* do not move; needed here because of some macro definitions */
  39 #include <config.h>
  40
  41 #include <stdlib.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44
  45 #include <jni.h>
  46 #include <jcl.h>
  47
  48 #include "javanet.h"
  49
  50 #include "target_native.h"
  51 #ifndef WITHOUT_NETWORK
  52 #include "target_native_network.h"
  53 #endif /* WITHOUT_NETWORK */
  54
  55 #include "java_net_VMInetAddress.h"
  56
  57 /*************************************************************************/
  58
  59 /*
  60  * Function to return the local hostname
  61  */
  62 JNIEXPORT jstring JNICALL
  63 Java_java_net_VMInetAddress_getLocalHostname (JNIEnv * env,
  64                                               jclass class
  65                                               __attribute__ ((__unused__)))
  66 {
  67   char hostname[256];
  68   int result;
  69   jstring retval;
  70
  71 #ifndef WITHOUT_NETWORK
  72   TARGET_NATIVE_NETWORK_GET_HOSTNAME (hostname, sizeof (hostname), result);
  73   if (result != TARGET_NATIVE_OK)
  74     {
  75       strcpy (hostname, "localhost");
  76     }
  77 #else /* not WITHOUT_NETWORK */
  78   strcpy (hostname, "localhost");
  79 #endif /* not WITHOUT_NETWORK */
  80
  81   retval = (*env)->NewStringUTF (env, hostname);
  82
  83   return (retval);
  84 }
  85
  86 /*************************************************************************/
  87
  88 /*
  89  * Returns the value of the special IP address INADDR_ANY
  90  */
  91 JNIEXPORT jarray JNICALL
  92 Java_java_net_VMInetAddress_lookupInaddrAny (JNIEnv * env,
  93                                              jclass class
  94                                              __attribute__ ((__unused__)))
  95 {
  96   jarray IParray;
  97   jbyte *octets;
  98
  99   /* Allocate an array for the IP address */
 100   IParray = (*env)->NewByteArray (env, 4);
 101   if (IParray == NULL)
 102     {
 103       JCL_ThrowException (env, UNKNOWN_HOST_EXCEPTION, "Internal Error");
 104       return (jarray) NULL;
 105     }
 106
 107   /* Copy in the values */
 108   octets = (*env)->GetByteArrayElements (env, IParray, 0);
 109
 110 #ifndef WITHOUT_NETWORK
 111   TARGET_NATIVE_NETWORK_INT_TO_IPADDRESS_BYTES (INADDR_ANY,
 112                                                 octets[0],
 113                                                 octets[1],
 114                                                 octets[2], octets[3]);
 115   (*env)->ReleaseByteArrayElements (env, IParray, octets, 0);
 116 #else /* not WITHOUT_NETWORK */
 117   octets[0] = 0;
 118   octets[1] = 0;
 119   octets[2] = 0;
 120   octets[3] = 0;
 121 #endif /* not WITHOUT_NETWORK */
 122
 123   return (IParray);
 124 }
 125
 126 /*************************************************************************/
 127
 128 /*
 129  * Function to return the canonical hostname for a given IP address passed
 130  * in as a byte array
 131  */
 132 JNIEXPORT jstring JNICALL
 133 Java_java_net_VMInetAddress_getHostByAddr (JNIEnv * env,
 134                                            jclass class
 135                                            __attribute__ ((__unused__)),
 136                                            jarray arr)
 137 {
 138 #ifndef WITHOUT_NETWORK
 139   jbyte *octets;
 140   jsize len;
 141   int addr;
 142   char hostname[255];
 143   int result;
 144   jstring retval;
 145
 146   /* Grab the byte[] array with the IP out of the input data */
 147   len = (*env)->GetArrayLength (env, arr);
 148   if (len != 4)
 149     {
 150       JCL_ThrowException (env, UNKNOWN_HOST_EXCEPTION, "Bad IP Address");
 151       return (jstring) NULL;
 152     }
 153
 154   octets = (*env)->GetByteArrayElements (env, arr, 0);
 155   if (!octets)
 156     {
 157       JCL_ThrowException (env, UNKNOWN_HOST_EXCEPTION, "Bad IP Address");
 158       return (jstring) NULL;
 159     }
 160
 161   /* Convert it to a 32 bit address */
 162   TARGET_NATIVE_NETWORK_IPADDRESS_BYTES_TO_INT (octets[0],
 163                                                 octets[1],
 164                                                 octets[2], octets[3], addr);
 165
 166   /* Release some memory */
 167   (*env)->ReleaseByteArrayElements (env, arr, octets, 0);
 168
 169   /* Resolve the address and return the name */
 170   TARGET_NATIVE_NETWORK_GET_HOSTNAME_BY_ADDRESS (addr, hostname,
 171                                                  sizeof (hostname), result);
 172   if (result != TARGET_NATIVE_OK)
 173     {
 174       JCL_ThrowException (env, UNKNOWN_HOST_EXCEPTION,
 175                           TARGET_NATIVE_LAST_ERROR_STRING ());
 176       return (jstring) NULL;
 177     }
 178
 179   retval = (*env)->NewStringUTF (env, hostname);
 180
 181   return (retval);
 182 #else /* not WITHOUT_NETWORK */
 183   return (jstring) NULL;
 184 #endif /* not WITHOUT_NETWORK */
 185 }
 186
 187 /*************************************************************************/
 188
 189 JNIEXPORT jobjectArray JNICALL
 190 Java_java_net_VMInetAddress_getHostByName (JNIEnv * env,
 191                                            jclass class
 192                                            __attribute__ ((__unused__)),
 193                                            jstring host)
 194 {
 195 #ifndef WITHOUT_NETWORK
 196   const char *hostname;
 197 /* FIXME: limitation of max. 64 addresses - how to make it more flexibale? */
 198   int addresses[64];
 199   jsize addresses_count;
 200   int result;
 201   jclass arr_class;
 202   jobjectArray addrs;
 203   int i;
 204   jbyte *octets;
 205   jarray ret_octets;
 206   int max_addresses;
 207
 208   /* Grab the hostname string */
 209   hostname = (*env)->GetStringUTFChars (env, host, 0);
 210   if (!hostname)
 211     {
 212       JCL_ThrowException (env, UNKNOWN_HOST_EXCEPTION, "Null hostname");
 213       return (jobjectArray) NULL;
 214     }
 215
 216   max_addresses = sizeof (addresses) / sizeof (addresses[0]);
 217   TARGET_NATIVE_NETWORK_GET_HOSTNAME_BY_NAME (hostname,
 218                                               addresses,
 219                                               max_addresses,
 220                                               addresses_count, result);
 221   if (result != TARGET_NATIVE_OK)
 222     {
 223       JCL_ThrowException (env, UNKNOWN_HOST_EXCEPTION, (char *) hostname);
 224       return (jobjectArray) NULL;
 225     }
 226   (*env)->ReleaseStringUTFChars (env, host, hostname);
 227
 228   arr_class = (*env)->FindClass (env, "[B");
 229   if (!arr_class)
 230     {
 231       JCL_ThrowException (env, UNKNOWN_HOST_EXCEPTION, "Internal Error");
 232       return (jobjectArray) NULL;
 233     }
 234
 235   addrs = (*env)->NewObjectArray (env, addresses_count, arr_class, 0);
 236   if (!addrs)
 237     {
 238       JCL_ThrowException (env, UNKNOWN_HOST_EXCEPTION, "Internal Error");
 239       return (jobjectArray) NULL;
 240     }
 241
 242   /* Now loop and copy in each address */
 243   for (i = 0; i < addresses_count; i++)
 244     {
 245       ret_octets = (*env)->NewByteArray (env, 4);
 246       if (!ret_octets)
 247         {
 248           JCL_ThrowException (env, UNKNOWN_HOST_EXCEPTION, "Internal Error");
 249           return (jobjectArray) NULL;
 250         }
 251
 252       octets = (*env)->GetByteArrayElements (env, ret_octets, 0);
 253
 254       TARGET_NATIVE_NETWORK_INT_TO_IPADDRESS_BYTES (addresses[i],
 255                                                     octets[0],
 256                                                     octets[1],
 257                                                     octets[2], octets[3]);
 258
 259       (*env)->ReleaseByteArrayElements (env, ret_octets, octets, 0);
 260
 261       (*env)->SetObjectArrayElement (env, addrs, i, ret_octets);
 262     }
 263
 264   return (addrs);
 265 #else /* not WITHOUT_NETWORK */
 266   return (jobjectArray) NULL;
 267 #endif /* not WITHOUT_NETWORK */
 268 }
 269
 270 /* end of file */