win32.cc: fixed tab...

* win32.cc: fixed tab, indentation and whitespace
	inconsistencies
	removed jvm.h include
	added includes java/lang/UnsupportedOperationException.h,
	java/io/IOException.h, java/net/SocketException.h
	(WSAEventWrapper): class implementation
	(_Jv_WinStrError): implemented both overloads
	(_Jv_ThrowIOException): implemented both overloads
	(_Jv_ThrowSocketException): implemented both overloads
	(_Jv_select): implemented
	* include/win32.h: fixed tab, indentation and whitespace
	inconsistencies
	wrapped <windows.h> include with  #define WIN32_LEAN_AND_MEAN
	added jvm.h include
	(WSAEventWrapper): added class declaration
	(_Jv_WinStrError): added both overload declarations
	(_Jv_ThrowIOException): added both overload declarations
	(_Jv_ThrowSocketException): added both overload declarations
	removed ENOTCONN, ECONNRESET and ENOPROTOOPT defines
	(_Jv_select): added declaration
	(_Jv_socket): removed
	(_Jv_connect): removed
	(_Jv_close): removed
	(_Jv_bind): removed
	(_Jv_accept): removed
	(_Jv_listen): removed
	(_Jv_write): removed
	(_Jv_read): removed
	* java/io/natFileDescriptorWin32.cc: fixed tab, indentation and
	whitespace inconsistencies
	replaced <windows.h> #include with <platform.h>
	removed jvm.h include
	(testCanUseGetHandleInfo): new function which tests whether Win32
	GetHandleInformation() call can be used with console buffer handles
	(only supported on >=WinNT 5.0)
	(winerr): removed (superseded by _Jv_WinStrError in include/win32.h)
	(valid): rewrote implementation using GetHandleInformation()
	(sync): 	changed exception throwing to use error string and exception
	helper methods declared in include/win32.h
	(open): likewise
	(write): likewise
	(setLength): likewise
	(close): likewise
	(seek): likewise
	(getFilePointer): likewise
	(read): likewise
	* java/io/natFileWin32.cc: fixed tab, indentation and
	whitespace inconsistencies
	replaced <windows.h> #include with <platform.h>
	removed jvm.h include
	(_access): use JV_TEMP_UTF_STRING
	(_stat): likewise
	(performMkDir): use JV_TEMP_UTF_STRING
	(performRenameTo): likewise
	(performDelete): likewise
	(performCreate): likewise
	(performSetReadOnly): likewise
	(performSetLastModified): likewise
	* java/lang/natWin32Process.cc: fixed tab, indentation and
	whitespace inconsistencies
	replaced <windows.h> #include with <platform.h>
	removed includes gcj/cni.h, jvm.h
	(new_string): removed
	(startProcess): use JV_TEMP_UTF_STRING,
	changed exception throwing to use error string and exception
	helper methods declared in include/win32.h
	* java/net/natInetAddressWin32.cc: fixed tab, indentation and
	whitespace inconsistencies
	replaced <windows.h> #include with <platform.h>
	removed jvm.h include
	removed DISABLE_JAVA_NET conditional code
	removed POSIX conditional code not relevant to Win32
	(aton): use JV_TEMP_UTF_STRING
	removed POSIX conditional code not relevant to Win32
	(lookup): likewise
	(getLocalHostName): likewise
	* java/net/natNetworkInterfaceWin32.cc: fixed tab, indentation and
	whitespace inconsistencies
	removed unnecessary windows.h, winsock.h and gcj/cni.h includes
	removed DISABLE_JAVA_NET conditional code
	removed POSIX conditional code not relevant to Win32
	(winsock2GetRealNetworkInterfaces): new function to compute network
	interfaces via Winsock2 API
	(determineGetRealNetworkInterfacesFN): new function for returning
	a function pointer to the function used to compute network interfaces.
	(getRealNetworkInterfaces): implemented
	* java/net/natPlainDatagramSocketImplWin32.cc: fixed tab, indentation and
	whitespace inconsistencies
	removed gcj/cni.h include
	removed DISABLE_JAVA_NET conditional code
	removed POSIX conditional code not relevant to Win32
	changed net POSIXisms to Win32isms
	replaced _Jv socket-related calls with their real Win32 equivalents
	changed exception throwing to use error string and exception
	helper methods declared in include/win32.h
	(peekData): implemented timeout support
	(receive): likewise
	* java/net/natPlainSocketImplWin32.cc: fixed tab, indentation and
	whitespace inconsistencies
	removed gcj/cni.h and gcj/javaprims.h includes
	removed DISABLE_JAVA_NET conditional code
	removed POSIX conditional code not relevant to Win32
	changed net POSIXisms to Win32isms
	replaced _Jv socket-related calls with their real Win32
	equivalents
	changed exception throwing to use error string and exception
	helper methods declared in include/win32.h
	(throwConnectException): helper function for connect()
	(connect): implemented timeout support
	(accept): likewise
	(doRead): new helper function common to both read() method overloads,
	includes timeout support
	(read): implemented both overloads in terms of doRead()
	(available): implemented using ioctlsocket()

From-SVN: r70904

libjava/java/net/natInetAddressWin32.cc

@@ -7,124 +7,26 @@ Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
 details.  */
 
 #include <config.h>
+#include <platform.h>
 
-#ifdef WIN32
-
-#include <windows.h>
-#include <winsock.h>
 #undef STRICT
 
-#ifndef MAXHOSTNAMELEN
-#define MAXHOSTNAMELEN	64
-#endif /* MAXHOSTNAMELEN */
-
-#else /* WIN32 */
-
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <string.h>
-#include <errno.h>
-
-#include <sys/param.h>
-#include <sys/types.h>
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-#include <netinet/in.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-#include <arpa/inet.h>
-#endif
-#ifdef HAVE_NETDB_H
-#include <netdb.h>
-#endif
-
-#endif /* WIN32 */
-
-#include <gcj/cni.h>
-#include <jvm.h>
 #include <java/net/InetAddress.h>
 #include <java/net/UnknownHostException.h>
 #include <java/lang/SecurityException.h>
 
-#if defined(HAVE_UNAME) && ! defined(HAVE_GETHOSTNAME)
-#include <sys/utsname.h>
-#endif
-
-#ifndef HAVE_GETHOSTNAME_DECL
-extern "C" int gethostname (char *name, int namelen);
-#endif
-
-#ifdef DISABLE_JAVA_NET
-
-jbyteArray
-java::net::InetAddress::aton (jstring)
-{
-  return NULL;
-}
-
-jint
-java::net::InetAddress::getFamily (jbyteArray bytes)
-{
-  return 0;
-}
-
-JArray<java::net::InetAddress*> *
-java::net::InetAddress::lookup (jstring, java::net::InetAddress *, jboolean)
-{
-  return NULL;
-}
-
-jstring
-java::net::InetAddress::getLocalHostname ()
-{
-  return NULL;
-}
-
-#else /* DISABLE_JAVA_NET */
-
 jbyteArray
 java::net::InetAddress::aton (jstring host)
 {
-  char *hostname;
-  char buf[100];
-  int len = JvGetStringUTFLength(host);
-  if (len < 100)
-    hostname = buf;
-  else
-    hostname = (char*) _Jv_AllocBytes (len+1);
-  JvGetStringUTFRegion (host, 0, host->length(), hostname);
-  buf[len] = '\0';
+  JV_TEMP_UTF_STRING (hostname, host);
   char* bytes = NULL;
   int blen = 0;
-#ifdef HAVE_INET_ATON
-  struct in_addr laddr;
-  if (inet_aton (hostname, &laddr))
+  unsigned long laddr = inet_addr (hostname);
+  if (laddr != INADDR_NONE)
     {
       bytes = (char*) &laddr;
       blen = 4;
     }
-#elif defined(HAVE_INET_ADDR)
-#if ! HAVE_IN_ADDR_T
-  typedef jint in_addr_t;
-#endif
-  in_addr_t laddr = inet_addr (hostname);
-  if (laddr != (in_addr_t)(-1))
-    {
-      bytes = (char*) &laddr;
-      blen = 4;
-    }
-#endif
-#if defined (HAVE_INET_PTON) && defined (HAVE_INET6)
-  char inet6_addr[16];
-  if (len != 0 && inet_pton (AF_INET6, hostname, inet6_addr) > 0)
-    {
-      bytes = inet6_addr;
-      blen = 16;
-    }
-#endif
   if (blen == 0)
     return NULL;
   jbyteArray result = JvNewByteArray (blen);
@@ -149,69 +51,17 @@ java::net::InetAddress::getFamily (jbyteArray bytes)
 
 JArray<java::net::InetAddress*> *
 java::net::InetAddress::lookup (jstring host, java::net::InetAddress* iaddr,
-				jboolean all)
+        jboolean all)
 {
   struct hostent *hptr = NULL;
-#if defined (HAVE_GETHOSTBYNAME_R) || defined (HAVE_GETHOSTBYADDR_R)
-  struct hostent hent_r;
-#if HAVE_STRUCT_HOSTENT_DATA
-  struct hostent_data fixed_buffer, *buffer_r = &fixed_buffer;
-#else
-#if defined (__GLIBC__) 
-  // FIXME: in glibc, gethostbyname_r returns NETDB_INTERNAL to herr and
-  // ERANGE to errno if the buffer size is too small, rather than what is 
-  // expected here. We work around this by setting a bigger buffer size and 
-  // hoping that it is big enough.
-  char fixed_buffer[1024];
-#else
-  char fixed_buffer[200];
-#endif
-  char *buffer_r = fixed_buffer;
-  int size_r = sizeof (fixed_buffer);
-#endif
-#endif
-
   if (host != NULL)
     {
-      char *hostname;
-      char buf[100];
-      int len = JvGetStringUTFLength(host);
-      if (len < 100)
-	hostname = buf;
-      else
-	hostname = (char*) _Jv_AllocBytes (len+1);
-      JvGetStringUTFRegion (host, 0, host->length(), hostname);
-      buf[len] = '\0';
-#ifdef HAVE_GETHOSTBYNAME_R
-      while (true)
-	{
-	  int ok;
-#if HAVE_STRUCT_HOSTENT_DATA
-	  ok = ! gethostbyname_r (hostname, &hent_r, buffer_r);
-#else
-	  int herr = 0;
-#ifdef GETHOSTBYNAME_R_RETURNS_INT
-	  ok = ! gethostbyname_r (hostname, &hent_r, buffer_r, size_r,
-				  &hptr, &herr);
-#else
-	  hptr = gethostbyname_r (hostname, &hent_r, buffer_r, size_r, &herr);
-	  ok = hptr != NULL;
-#endif /* GETHOSTNAME_R_RETURNS_INT */
-	  if (! ok && herr == ERANGE)
-	    {
-	      size_r *= 2;
-	      buffer_r = (char *) _Jv_AllocBytes (size_r);
-	    }
-	  else
-#endif /* HAVE_STRUCT_HOSTENT_DATA */
-	    break;
-	}
-#else
+      JV_TEMP_UTF_STRING (hostname, host);
+
       // FIXME: this is insufficient if some other piece of code calls
       // this gethostbyname.
       JvSynchronize sync (java::net::InetAddress::localhostAddress);
       hptr = gethostbyname (hostname);
-#endif /* HAVE_GETHOSTBYNAME_R */
     }
   else
     {
@@ -221,51 +71,24 @@ java::net::InetAddress::lookup (jstring host, java::net::InetAddress* iaddr,
       int type;
       char *val;
       if (len == 4)
-	{
-	  val = chars;
-	  type = iaddr->family = AF_INET;
-	}
+        {
+          val = chars;
+          type = iaddr->family = AF_INET;
+        }
 #ifdef HAVE_INET6
       else if (len == 16)
-	{
-	  val = (char *) &chars;
-	  type = iaddr->family = AF_INET6;
-	}
+      {
+        val = (char *) &chars;
+        type = iaddr->family = AF_INET6;
+      }
 #endif /* HAVE_INET6 */
       else
-	JvFail ("unrecognized size");
+        JvFail ("unrecognized size");
 
-#ifdef HAVE_GETHOSTBYADDR_R
-      while (true)
-	{
-	  int ok;
-#if HAVE_STRUCT_HOSTENT_DATA
-	  ok = ! gethostbyaddr_r (val, len, type, &hent_r, buffer_r);
-#else
-	  int herr = 0;
-#ifdef GETHOSTBYADDR_R_RETURNS_INT
-	  ok = ! gethostbyaddr_r (val, len, type, &hent_r,
-				  buffer_r, size_r, &hptr, &herr);
-#else
-	  hptr = gethostbyaddr_r (val, len, type, &hent_r,
-				  buffer_r, size_r, &herr);
-	  ok = hptr != NULL;
-#endif /* GETHOSTBYADDR_R_RETURNS_INT */
-	  if (! ok && herr == ERANGE)
-	    {
-	      size_r *= 2;
-	      buffer_r = (char *) _Jv_AllocBytes (size_r);
-	    }
-	  else 
-#endif /* HAVE_STRUCT_HOSTENT_DATA */
-	    break;
-	}
-#else /* HAVE_GETHOSTBYADDR_R */
       // FIXME: this is insufficient if some other piece of code calls
       // this gethostbyaddr.
       JvSynchronize sync (java::net::InetAddress::localhostAddress);
       hptr = gethostbyaddr (val, len, type);
-#endif /* HAVE_GETHOSTBYADDR_R */
     }
   if (hptr != NULL)
     {
@@ -273,22 +96,23 @@ java::net::InetAddress::lookup (jstring host, java::net::InetAddress* iaddr,
         host = JvNewStringUTF (hptr->h_name);
       java::lang::SecurityException *ex = checkConnect (host);
       if (ex != NULL)
-	{
-	  if (iaddr == NULL || iaddr->addr == NULL)
-	    throw ex;
-	  hptr = NULL;
-	}
+        {
+          if (iaddr == NULL || iaddr->addr == NULL)
+            throw ex;
+          hptr = NULL;
+        }
     }
   if (hptr == NULL)
     {
       if (iaddr != NULL && iaddr->addr != NULL)
-	{
-	  iaddr->hostName = iaddr->getHostAddress();
-	  return NULL;
-	}
+        {
+          iaddr->hostName = iaddr->getHostAddress();
+          return NULL;
+        }
       else
-	throw new java::net::UnknownHostException(host);
+        throw new java::net::UnknownHostException(host);
     }
+
   int count;
   if (all)
     {
@@ -298,6 +122,7 @@ java::net::InetAddress::lookup (jstring host, java::net::InetAddress* iaddr,
     }
   else
     count = 1;
+
   JArray<java::net::InetAddress*> *result;
   java::net::InetAddress** iaddrs;
   if (all)
@@ -314,42 +139,30 @@ java::net::InetAddress::lookup (jstring host, java::net::InetAddress* iaddr,
   for (int i = 0;  i < count;  i++)
     {
       if (iaddrs[i] == NULL)
-	iaddrs[i] = new java::net::InetAddress (NULL, NULL);
+        iaddrs[i] = new java::net::InetAddress (NULL, NULL);
       if (iaddrs[i]->hostName == NULL)
         iaddrs[i]->hostName = host;
       if (iaddrs[i]->addr == NULL)
-	{
-	  char *bytes = hptr->h_addr_list[i];
-	  iaddrs[i]->addr = JvNewByteArray (hptr->h_length);
-	  iaddrs[i]->family = getFamily (iaddrs[i]->addr);
-	  memcpy (elements (iaddrs[i]->addr), bytes, hptr->h_length);
-	}
+        {
+          char *bytes = hptr->h_addr_list[i];
+          iaddrs[i]->addr = JvNewByteArray (hptr->h_length);
+          iaddrs[i]->family = getFamily (iaddrs[i]->addr);
+          memcpy (elements (iaddrs[i]->addr), bytes, hptr->h_length);
+        }
     }
+    
   return result;
 }
 
 jstring
 java::net::InetAddress::getLocalHostname ()
 {
-  char *chars;
-#ifdef HAVE_GETHOSTNAME
-  char buffer[MAXHOSTNAMELEN];
-  if (gethostname (buffer, MAXHOSTNAMELEN))
+  char buffer[400];
+  if (gethostname (buffer, sizeof(buffer)))
     return NULL;
-  chars = buffer;
-#elif HAVE_UNAME
-  struct utsname stuff;
-  if (uname (&stuff) != 0)
-    return NULL;
-  chars = stuff.nodename;
-#else
-  return NULL;
-#endif
   // It is admittedly non-optimal to convert the hostname to Unicode
   // only to convert it back in getByName, but simplicity wins.  Note
   // that unless there is a SecurityManager, we only get called once
   // anyway, thanks to the InetAddress.localhost cache.
-  return JvNewStringUTF (chars);
+  return JvNewStringUTF (buffer);
 }
-
-#endif /* DISABLE_JAVA_NET */