[gacutil] Use IKVM.Reflection instead of System.Reflection (#3582)

[mono.git] / mono / utils / mono-rand.c

diff --git a/mono/utils/mono-rand.c b/mono/utils/mono-rand.c
index 1e20760e898ebc9ef10350fe86143811b2e92cfe..0e5a85384705341e3c5233e0db110fae07201803 100644 (file)
--- a/mono/utils/mono-rand.c
+++ b/mono/utils/mono-rand.c
@@ -10,6 +10,7 @@
  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
  * Copyright 2001 Xamarin, Inc (http://www.novell.com)
+ * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  */
 
 
@@ -123,7 +124,7 @@ mono_rand_try_get_bytes (gpointer *handle, guchar *buffer, gint buffer_size, Mon
                        /* exception will be thrown in managed code */
                        CryptReleaseContext (provider, 0);
                        *handle = 0;
-                       mono_error_set_generic_error (error, "System", "ExecutionEngineException", "Failed to gen random bytes (%d)", GetLastError ());
+                       mono_error_set_execution_engine (error, "Failed to gen random bytes (%d)", GetLastError ());
                        return FALSE;
                }
        }
@@ -164,29 +165,29 @@ static void
 get_entropy_from_egd (const char *path, guchar *buffer, int buffer_size, MonoError *error)
 {
        struct sockaddr_un egd_addr;
-       gint file;
+       gint socket_fd;
        gint ret;
        guint offset = 0;
        int err = 0;
 
        mono_error_init (error);
        
-       file = socket (PF_UNIX, SOCK_STREAM, 0);
-       if (file < 0) {
+       socket_fd = socket (PF_UNIX, SOCK_STREAM, 0);
+       if (socket_fd < 0) {
                ret = -1;
                err = errno;
        } else {
                egd_addr.sun_family = AF_UNIX;
                strncpy (egd_addr.sun_path, path, sizeof (egd_addr.sun_path) - 1);
                egd_addr.sun_path [sizeof (egd_addr.sun_path) - 1] = '\0';
-               ret = connect (file, (struct sockaddr*) &egd_addr, sizeof (egd_addr));
+               ret = connect (socket_fd, (struct sockaddr*) &egd_addr, sizeof (egd_addr));
                err = errno;
        }
        if (ret == -1) {
-               if (file >= 0)
-                       close (file);
+               if (socket_fd >= 0)
+                       close (socket_fd);
                g_warning ("Entropy problem! Can't create or connect to egd socket %s", path);
-               mono_error_set_generic_error (error, "System", "ExecutionEngineException", "Failed to open egd socket %s: %s", path, strerror (err));
+               mono_error_set_execution_engine (error, "Failed to open egd socket %s: %s", path, strerror (err));
                return;
        }
 
@@ -198,16 +199,16 @@ get_entropy_from_egd (const char *path, guchar *buffer, int buffer_size, MonoErr
                request [0] = 2;
                request [1] = buffer_size < 255 ? buffer_size : 255;
                while (count < 2) {
-                       int sent = write (file, request + count, 2 - count);
+                       int sent = write (socket_fd, request + count, 2 - count);
                        err = errno;
                        if (sent >= 0) {
                                count += sent;
                        } else if (err == EINTR) {
                                continue;
                        } else {
-                               close (file);
+                               close (socket_fd);
                                g_warning ("Send egd request failed %d", err);
-                               mono_error_set_generic_error (error, "System", "ExecutionEngineException", "Failed to send request to egd socket: %s", strerror (err));
+                               mono_error_set_execution_engine (error, "Failed to send request to egd socket: %s", strerror (err));
                                return;
                        }
                }
@@ -215,7 +216,7 @@ get_entropy_from_egd (const char *path, guchar *buffer, int buffer_size, MonoErr
                count = 0;
                while (count != request [1]) {
                        int received;
-                       received = read (file, buffer + offset, request [1] - count);
+                       received = read (socket_fd, buffer + offset, request [1] - count);
                        err = errno;
                        if (received > 0) {
                                count += received;
@@ -223,9 +224,9 @@ get_entropy_from_egd (const char *path, guchar *buffer, int buffer_size, MonoErr
                        } else if (received < 0 && err == EINTR) {
                                continue;
                        } else {
-                               close (file);
+                               close (socket_fd);
                                g_warning ("Receive egd request failed %d", err);
-                               mono_error_set_generic_error (error, "System", "ExecutionEngineException", "Failed to get response from egd socket: %s", strerror(err));
+                               mono_error_set_execution_engine (error, "Failed to get response from egd socket: %s", strerror(err));
                                return;
                        }
                }
@@ -233,7 +234,7 @@ get_entropy_from_egd (const char *path, guchar *buffer, int buffer_size, MonoErr
                buffer_size -= request [1];
        }
 
-       close (file);
+       close (socket_fd);
 }
 
 gboolean
@@ -295,7 +296,7 @@ mono_rand_try_get_bytes (gpointer *handle, guchar *buffer, gint buffer_size, Mon
                                        continue;
                                g_warning("Entropy error! Error in read (%s).", strerror (errno));
                                /* exception will be thrown in managed code */
-                               mono_error_set_generic_error (error, "System", "ExecutionEngineException", "Entropy error! Error in read (%s).", strerror (errno));
+                               mono_error_set_execution_engine (error, "Entropy error! Error in read (%s).", strerror (errno));
                                return FALSE;
                        }
                        count += err;