1 files changed, 302 insertions, 0 deletions
diff --git a/misc/unix/rand.c b/misc/unix/rand.c
new file mode 100644
index 0000000..c0567a6
--- /dev/null
+++ b/misc/unix/rand.c
@@ -0,0 +1,302 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define APR_WANT_MEMFUNC
+#include "apr_want.h"
+#include "apr_general.h"
+
+#include "apr_arch_misc.h"
+#include <sys/stat.h>
+#if APR_HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#if APR_HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#if APR_HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#if APR_HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#if APR_HAVE_SYS_UN_H
+#include <sys/un.h>
+#endif
+#if defined(HAVE_UUID_H)
+#include <uuid.h>
+#elif defined(HAVE_UUID_UUID_H)
+#include <uuid/uuid.h>
+#elif defined(HAVE_SYS_UUID_H)
+#include <sys/uuid.h>
+#endif
+
+#if defined(SYS_RANDOM)
+#if defined(HAVE_SYS_RANDOM_H) && \
+    defined(HAVE_GETRANDOM)
+
+#include <sys/random.h>
+#define USE_GETRANDOM
+
+#elif defined(HAVE_SYS_SYSCALL_H) && \
+      defined(HAVE_LINUX_RANDOM_H) && \
+      defined(HAVE_DECL_SYS_GETRANDOM) && \
+      HAVE_DECL_SYS_GETRANDOM
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <linux/random.h>
+#define getrandom(buf, buflen, flags) \
+    syscall(SYS_getrandom, (buf), (buflen), (flags))
+#define USE_GETRANDOM
+
+#endif /* HAVE_SYS_RANDOM_H */
+#endif /* SYS_RANDOM */
+
+#ifndef SHUT_RDWR
+#define SHUT_RDWR 2
+#endif
+
+#if APR_HAS_OS_UUID
+
+#if defined(HAVE_UUID_CREATE)
+
+APR_DECLARE(apr_status_t) apr_os_uuid_get(unsigned char *uuid_data)
+{
+    uint32_t rv;
+    uuid_t g;
+
+    uuid_create(&g, &rv);
+
+    if (rv != uuid_s_ok)
+        return APR_EGENERAL;
+
+    memcpy(uuid_data, &g, sizeof(uuid_t));
+
+    return APR_SUCCESS;
+}
+
+#elif defined(HAVE_UUID_GENERATE)
+
+APR_DECLARE(apr_status_t) apr_os_uuid_get(unsigned char *uuid_data)
+{
+    uuid_t g;
+
+    uuid_generate(g);
+
+    memcpy(uuid_data, g, sizeof(uuid_t));
+
+    return APR_SUCCESS;
+}
+#endif 
+
+#endif /* APR_HAS_OS_UUID */
+
+#if APR_HAS_RANDOM
+
+APR_DECLARE(apr_status_t) apr_generate_random_bytes(unsigned char *buf, 
+                                                    apr_size_t length)
+{
+#if defined(HAVE_EGD)
+    /* use EGD-compatible socket daemon (such as EGD or PRNGd).
+     * message format:
+     * 0x00 (get entropy level)
+     *   0xMM (msb) 0xmm 0xll 0xLL (lsb)
+     * 0x01 (read entropy nonblocking) 0xNN (bytes requested)
+     *   0xMM (bytes granted) MM bytes
+     * 0x02 (read entropy blocking) 0xNN (bytes desired)
+     *   [block] NN bytes
+     * 0x03 (write entropy) 0xMM 0xLL (bits of entropy) 0xNN (bytes of data) 
+     *      NN bytes
+     * (no response - write only) 
+     * 0x04 (report PID)
+     *   0xMM (length of PID string, not null-terminated) MM chars
+     */
+    static const char *egd_sockets[] = { EGD_DEFAULT_SOCKET, NULL };
+    const char **egdsockname = NULL;
+
+    int egd_socket, egd_path_len, rv, bad_errno;
+    struct sockaddr_un addr;
+    apr_socklen_t egd_addr_len;
+    apr_size_t resp_expected;
+    unsigned char req[2], resp[255];
+    unsigned char *curbuf = buf;
+
+    for (egdsockname = egd_sockets; *egdsockname && length > 0; egdsockname++) {
+        egd_path_len = strlen(*egdsockname);
+        
+        if (egd_path_len > sizeof(addr.sun_path)) {
+            return APR_EINVAL;
+        }
+
+        memset(&addr, 0, sizeof(struct sockaddr_un));
+        addr.sun_family = AF_UNIX;
+        memcpy(addr.sun_path, *egdsockname, egd_path_len);
+        egd_addr_len = APR_OFFSETOF(struct sockaddr_un, sun_path) + 
+          egd_path_len; 
+
+        egd_socket = socket(PF_UNIX, SOCK_STREAM, 0);
+
+        if (egd_socket == -1) {
+            return errno;
+        }
+
+        rv = connect(egd_socket, (struct sockaddr*)&addr, egd_addr_len);
+
+        if (rv == -1) {
+            bad_errno = errno;
+            continue;
+        }
+
+        /* EGD can only return 255 bytes of data at a time.  Silly.  */ 
+        while (length > 0) {
+            apr_ssize_t srv;
+            req[0] = 2; /* We'll block for now. */
+            req[1] = length > 255 ? 255: length;
+
+            srv = write(egd_socket, req, 2);
+            if (srv == -1) {
+                bad_errno = errno;
+                shutdown(egd_socket, SHUT_RDWR);
+                close(egd_socket);
+                break;
+            }
+
+            if (srv != 2) {
+                shutdown(egd_socket, SHUT_RDWR);
+                close(egd_socket);
+                return APR_EGENERAL;
+            }
+            
+            resp_expected = req[1];
+            srv = read(egd_socket, resp, resp_expected);
+            if (srv == -1) {
+                bad_errno = errno;
+                shutdown(egd_socket, SHUT_RDWR);
+                close(egd_socket);
+                return bad_errno;
+            }
+            
+            memcpy(curbuf, resp, srv);
+            curbuf += srv;
+            length -= srv;
+        }
+        
+        shutdown(egd_socket, SHUT_RDWR);
+        close(egd_socket);
+    }
+
+    if (length > 0) {
+        /* We must have iterated through the list of sockets,
+         * and no go. Return the errno.
+         */
+        return bad_errno;
+    }
+
+#elif defined(SYS_RANDOM) && defined(USE_GETRANDOM)
+
+    do {
+        int rc;
+
+        rc = getrandom(buf, length, 0);
+        if (rc == -1) {
+            if (errno == EINTR) {
+                continue;
+            }
+            return errno;
+        }
+
+        buf += rc;
+        length -= rc;
+    } while (length > 0);
+
+#elif defined(SYS_RANDOM) && defined(HAVE_ARC4RANDOM_BUF)
+
+    arc4random_buf(buf, length);
+
+#elif defined(DEV_RANDOM)
+
+    int fd = -1;
+
+    /* On BSD/OS 4.1, /dev/random gives out 8 bytes at a time, then
+     * gives EOF, so reading 'length' bytes may require opening the
+     * device several times. */
+    do {
+        apr_ssize_t rc;
+
+        if (fd == -1)
+            if ((fd = open(DEV_RANDOM, O_RDONLY)) == -1)
+                return errno;
+        
+        do {
+            rc = read(fd, buf, length);
+        } while (rc == -1 && errno == EINTR);
+
+        if (rc < 0) {
+            int errnum = errno;
+            close(fd);
+            return errnum;
+        }
+        else if (rc == 0) {
+            close(fd);
+            fd = -1; /* force open() again */
+        }
+        else {
+            buf += rc;
+            length -= rc;
+        }
+    } while (length > 0);
+    
+    close(fd);
+
+#elif defined(OS2)
+
+    static UCHAR randbyte();
+    unsigned int idx;
+
+    for (idx=0; idx<length; idx++)
+	buf[idx] = randbyte();
+
+#elif defined(HAVE_TRUERAND) /* use truerand */
+
+    extern int randbyte(void);	/* from the truerand library */
+    unsigned int idx;
+
+    /* this will increase the startup time of the server, unfortunately...
+     * (generating 20 bytes takes about 8 seconds)
+     */
+    for (idx=0; idx<length; idx++)
+	buf[idx] = (unsigned char) randbyte();
+
+#else
+
+#error APR_HAS_RANDOM defined with no implementation
+
+#endif	/* DEV_RANDOM */
+
+    return APR_SUCCESS;
+}
+
+#undef	STR
+#undef	XSTR
+
+#ifdef OS2
+#include "randbyte_os2.inc"
+#endif
+
+#endif /* APR_HAS_RANDOM */