enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-sleep/README.md

@@ -0,0 +1,29 @@
+# Sleep Module for mruby
+
+mruby sleep module
+
+## Install by mrbgems
+
+- add `conf.gem` line to your build configuration.
+
+```ruby
+MRuby::Build.new do |conf|
+
+    # ... (snip) ...
+
+    conf.gem :core => 'mruby-sleep'
+end
+```
+
+## Example
+
+```ruby
+sleep(10)
+usleep(10000)
+```
+
+# License
+
+under the MIT License:
+
+- <https://opensource.org/license/mit>

data/ext/enclave/mruby/mrbgems/mruby-sleep/example/sleep.rb

@@ -0,0 +1,2 @@
+sleep(10)
+usleep(10000)

data/ext/enclave/mruby/mrbgems/mruby-sleep/mrbgem.rake

@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-sleep') do |spec|
+  spec.license = 'MIT'
+  spec.authors = ['MATSUMOTO Ryosuke', 'mruby developers']
+  spec.summary = 'Kernel#sleep and Kernel#usleep'
+end

data/ext/enclave/mruby/mrbgems/mruby-sleep/src/sleep.c

@@ -0,0 +1,187 @@
+/*
+** mrb_sleep - sleep methods for mruby
+**
+** Copyright (c) mod_mruby developers 2012-
+** Copyright (c) mruby developers 2018
+**
+** Permission is hereby granted, free of charge, to any person obtaining
+** a copy of this software and associated documentation files (the
+** "Software"), to deal in the Software without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Software, and to
+** permit persons to whom the Software is furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** [ MIT license: https://www.opensource.org/licenses/mit-license.php ]
+*/
+
+#include <time.h>
+#ifdef _WIN32
+    #include <windows.h>
+    #define sleep(x) Sleep(x * 1000)
+    #define usleep(x) Sleep((DWORD)(((x)<1000) ? 1 : ((x)/1000)))
+#else
+    #include <unistd.h>
+    #include <sys/time.h>
+#endif
+
+#include <mruby.h>
+#include <mruby/presym.h>
+
+/*
+ * call-seq:
+ *   sleep(duration) -> integer
+ *
+ * Suspends the current thread for duration seconds (which may be any number,
+ * including a Float with fractional seconds if floating point is enabled).
+ * Returns the actual number of seconds slept (rounded), which may be less than
+ * that asked for if another thread calls Thread#run. Zero arguments causes
+ * sleep to sleep forever.
+ *
+ *   Time.new    #=> 2008-03-08 19:56:19 +0900
+ *   sleep 1.2   #=> 1
+ *   Time.new    #=> 2008-03-08 19:56:20 +0900
+ *   sleep 1.9   #=> 2
+ *   Time.new    #=> 2008-03-08 19:56:22 +0900
+ *
+ * Note: Forever sleep (called without an argument) is not implemented.
+ */
+static mrb_value
+f_sleep(mrb_state *mrb, mrb_value self)
+{
+    time_t beg = time(0);
+    time_t end;
+#ifndef MRB_NO_FLOAT
+    mrb_float sec;
+
+    mrb_get_args(mrb, "f", &sec);
+    if (sec >= 0) {
+        usleep(sec * 1000000);
+    }
+    else {
+        mrb_raise(mrb, E_ARGUMENT_ERROR, "time interval must not be negative");
+    }
+#else
+    mrb_int sec;
+
+    mrb_get_args(mrb, "i", &sec);
+    if (sec >= 0) {
+        sleep(sec);
+    }
+    else {
+        mrb_raise(mrb, E_ARGUMENT_ERROR, "time interval must not be negative");
+    }
+#endif
+    end = time(0) - beg;
+
+    return mrb_fixnum_value((mrb_int)end);
+}
+
+/* mruby special; needed for mruby without float numbers */
+/*
+ * call-seq:
+ *   usleep(microseconds) -> 0
+ *
+ * Suspends the current thread for microseconds microseconds (which should be
+ * an integer). This provides microsecond-level precision for short delays.
+ * Returns 0 on successful completion.
+ *
+ *   usleep(500000)  # Sleep for 0.5 seconds (500,000 microseconds)
+ *   usleep(1000)    # Sleep for 1 millisecond (1,000 microseconds)
+ *   usleep(100)     # Sleep for 100 microseconds
+ *
+ * Note: This function is useful for precise timing in embedded systems
+ * where sub-second delays are required.
+ */
+static mrb_value
+f_usleep(mrb_state *mrb, mrb_value self)
+{
+    mrb_int usec;
+    time_t slp_tm;
+#ifdef _WIN32
+    FILETIME st_ft,ed_ft;
+    unsigned __int64 st_time = 0;
+    unsigned __int64 ed_time = 0;
+#else
+    struct timeval st_tm,ed_tm;
+#endif
+
+#ifdef _WIN32
+    GetSystemTimeAsFileTime(&st_ft);
+#else
+    gettimeofday(&st_tm, NULL);
+#endif
+
+    /* not implemented forever sleep (called without an argument)*/
+    mrb_get_args(mrb, "i", &usec);
+
+    if (usec >= 0) {
+        usleep(usec);
+    }
+    else {
+        mrb_raise(mrb, E_ARGUMENT_ERROR, "time interval must not be negative");
+    }
+
+#ifdef _WIN32
+    GetSystemTimeAsFileTime(&ed_ft);
+
+    st_time |= st_ft.dwHighDateTime;
+    st_time <<=32;
+    st_time |= st_ft.dwLowDateTime;
+    ed_time |= ed_ft.dwHighDateTime;
+    ed_time <<=32;
+    ed_time |= ed_ft.dwLowDateTime;
+
+    slp_tm = (time_t)((ed_time - st_time) / 10);
+#else
+    gettimeofday(&ed_tm, NULL);
+
+    if (st_tm.tv_usec > ed_tm.tv_usec) {
+        slp_tm = 1000000 + ed_tm.tv_usec - st_tm.tv_usec;
+    }
+    else {
+        slp_tm = ed_tm.tv_usec - st_tm.tv_usec;
+    }
+#endif
+
+    return mrb_fixnum_value((mrb_int)slp_tm);
+}
+
+/*
+ * Initializes the mruby-sleep gem by defining sleep and usleep methods
+ * as private methods in the Kernel module, making them available globally.
+ *
+ * - sleep: requires 1 argument (duration in seconds), supports floating point
+ *   when MRB_NO_FLOAT is not defined, otherwise uses integer seconds
+ * - usleep: requires 1 argument (duration in microseconds), integer only
+ *
+ * Both methods provide thread suspension capabilities for timing control
+ * in embedded Ruby environments with cross-platform support (Windows/Unix).
+ */
+void
+mrb_mruby_sleep_gem_init(mrb_state *mrb)
+{
+  mrb_define_module_function_id(mrb, mrb->kernel_module, MRB_SYM(sleep),   f_sleep,   MRB_ARGS_REQ(1));
+  mrb_define_module_function_id(mrb, mrb->kernel_module, MRB_SYM(usleep),  f_usleep,  MRB_ARGS_REQ(1));
+}
+
+/*
+ * Finalizes the mruby-sleep gem. Currently no cleanup is required
+ * as the sleep/usleep implementation uses system calls without
+ * persistent state or allocated resources.
+ */
+void
+mrb_mruby_sleep_gem_final(mrb_state *mrb)
+{
+}

data/ext/enclave/mruby/mrbgems/mruby-sleep/test/sleep_test.rb

@@ -0,0 +1,29 @@
+assert("sleep works") do
+  assert_nothing_raised { sleep(1) }
+  assert_nothing_raised { sleep(0) }
+end
+
+assert("sleep would accept non-negative float value") do
+  skip unless Object.const_defined?(:Float)
+  assert_nothing_raised { sleep(0.01) }
+  assert_nothing_raised { sleep(0.0) }
+  assert_nothing_raised { sleep(-0.0) }
+end
+
+assert("sleep would not accept negative integer value") do
+  assert_raise(ArgumentError) { sleep(-1) }
+end
+
+assert("sleep would not accept negative float value") do
+  skip unless Object.const_defined?(:Float)
+  assert_raise(ArgumentError) { sleep(-0.1) }
+end
+
+assert("usleep works") do
+  assert_nothing_raised { usleep(100) }
+  assert_nothing_raised { usleep(0) }
+end
+
+assert("usleep would not accept negative value") do
+  assert_raise(ArgumentError) { usleep(-100) }
+end

data/ext/enclave/mruby/mrbgems/mruby-socket/README.md

@@ -0,0 +1,56 @@
+# mruby-socket
+
+"mruby-socket" mrbgem provides BSD socket interface for mruby.
+API is compatible with CRuby's "socket" library.
+
+## Example
+
+```sh
+% vi kame.rb
+s = TCPSocket.open("www.kame.net", 80)
+s.write("GET / HTTP/1.0\r\n\r\n")
+puts s.read
+s.close
+
+% mruby kame.rb
+HTTP/1.1 200 OK
+Date: Tue, 21 May 2013 04:31:30 GMT
+...
+```
+
+## Requirement
+
+- [mruby-io](../mruby-io) mrbgem
+- [iij/mruby-mtest](https://github.com/iij/mruby-mtest) mrbgem to run tests
+- system must have RFC3493 basic socket interface
+- and some POSIX API...
+
+## TODO
+
+- add missing methods
+- write more tests
+- fix possible descriptor leakage (see XXX comments)
+- `UNIXSocket#recv_io` `UNIXSocket#send_io`
+
+## License
+
+Copyright (c) 2013 Internet Initiative Japan Inc.
+Copyright (c) 2017 mruby developers
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/ext/enclave/mruby/mrbgems/mruby-socket/include/socket_hal.h

@@ -0,0 +1,83 @@
+/*
+** socket_hal.h - Socket HAL (Hardware Abstraction Layer) interface
+**
+** See Copyright Notice in mruby.h
+**
+** This header defines the platform-independent socket HAL interface.
+** Platform-specific implementations are provided by HAL gems:
+**   - hal-posix-socket: POSIX socket implementation (Linux, macOS, BSD, Unix)
+**   - hal-win-socket: Windows socket implementation (Windows, MinGW)
+*/
+
+#ifndef MRUBY_SOCKET_HAL_H
+#define MRUBY_SOCKET_HAL_H
+
+#include <mruby.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Socket HAL Initialization/Finalization
+ */
+
+/* Initialize socket subsystem (e.g., WSAStartup on Windows) */
+void mrb_hal_socket_init(mrb_state *mrb);
+
+/* Finalize socket subsystem (e.g., WSACleanup on Windows) */
+void mrb_hal_socket_final(mrb_state *mrb);
+
+/*
+ * Socket Control Operations
+ */
+
+/* Set non-blocking mode on socket
+ * Returns 0 on success, -1 on error (sets errno) */
+int mrb_hal_socket_set_nonblock(mrb_state *mrb, int fd, int nonblock);
+
+/*
+ * Address Conversion Functions
+ */
+
+/* Convert network address to presentation format (string)
+ * af: address family (AF_INET, AF_INET6)
+ * src: network address in binary form
+ * dst: buffer for string result
+ * size: size of dst buffer
+ * Returns: dst on success, NULL on error */
+const char* mrb_hal_socket_inet_ntop(int af, const void *src, char *dst, size_t size);
+
+/* Convert presentation format (string) to network address
+ * af: address family (AF_INET, AF_INET6)
+ * src: string representation of address
+ * dst: buffer for network address result
+ * Returns: 1 on success, 0 if src is not valid, -1 on error */
+int mrb_hal_socket_inet_pton(int af, const char *src, void *dst);
+
+/*
+ * Platform-Specific Socket Features
+ */
+
+/* Create Unix domain socket address structure
+ * path: Unix socket path
+ * Returns: packed sockaddr string, or raises exception if not supported */
+mrb_value mrb_hal_socket_sockaddr_un(mrb_state *mrb, const char *path, size_t pathlen);
+
+/* Create a pair of connected sockets
+ * domain: address family (e.g., AF_UNIX)
+ * type: socket type (e.g., SOCK_STREAM)
+ * protocol: protocol (usually 0)
+ * sv: array to receive the two socket descriptors
+ * Returns: 0 on success, -1 on error (sets errno) */
+int mrb_hal_socket_socketpair(mrb_state *mrb, int domain, int type, int protocol, int sv[2]);
+
+/* Get Unix socket path from sockaddr
+ * Returns: Unix socket path string, or raises exception if not supported */
+mrb_value mrb_hal_socket_unix_path(mrb_state *mrb, const char *sockaddr, size_t socklen);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MRUBY_SOCKET_HAL_H */

data/ext/enclave/mruby/mrbgems/mruby-socket/mrbgem.rake

@@ -0,0 +1,37 @@
+MRuby::Gem::Specification.new('mruby-socket') do |spec|
+  spec.license = 'MIT'
+  spec.authors = ['Internet Initiative Japan Inc.', 'mruby developers']
+  spec.summary = 'standard socket class'
+
+  #spec.cc.defines << "HAVE_SA_LEN=0"
+
+  spec.add_dependency('mruby-io', :core => 'mruby-io')
+  spec.add_dependency('mruby-error', :core => 'mruby-error')
+  # spec.add_dependency('mruby-mtest')
+
+  # Check if HAL gem is loaded
+  # HAL gems must be explicitly specified in build config (recommended) or via auto-selection below
+  spec.build.gems.one? { |g| g.name =~ /^hal-.*-socket$/ } or begin
+    # No HAL found - determine appropriate error message or auto-load
+    suggested_hal = if spec.for_windows?
+      'hal-win-socket'
+    elsif RUBY_PLATFORM =~ /linux|darwin|bsd/
+      'hal-posix-socket'
+    else
+      nil
+    end
+
+    if suggested_hal
+      # Auto-load HAL gem for convenience (for development)
+      # This works because HAL gems declare dependency on mruby-socket
+      warn "mruby-socket: No HAL specified, loading #{suggested_hal} (explicit selection recommended)"
+      spec.build.gem core: suggested_hal
+    else
+      # Unknown platform - fail with helpful message
+      fail "mruby-socket: No HAL available for platform '#{RUBY_PLATFORM}'.\n" \
+           "Please specify HAL gem explicitly in your build config:\n" \
+           "  conf.gem core: 'hal-posix-socket'   # For Linux/macOS/BSD\n" \
+           "  conf.gem core: 'hal-win-socket'     # For Windows"
+    end
+  end
+end