1 files changed, 71 insertions, 22 deletions

diff --git a/missing/flock.c b/missing/flock.c
index a4a9544b56..0b76961762 100644
--- a/missing/flock.c
+++ b/missing/flock.c
@@ -1,6 +1,64 @@
-#include "config.h"
+#include "ruby/internal/config.h"
+#include "ruby/ruby.h"
 
-#if defined(HAVE_LOCKF)
+#if defined _WIN32
+#elif defined __wasi__
+#include <errno.h>
+
+int
+flock(int fd, int operation)
+{
+    errno = EINVAL;
+    return -1;
+}
+#elif defined HAVE_FCNTL && defined HAVE_FCNTL_H
+
+/* These are the flock() constants.  Since this systems doesn't have
+   flock(), the values of the constants are probably not available.
+*/
+# ifndef LOCK_SH
+#  define LOCK_SH 1
+# endif
+# ifndef LOCK_EX
+#  define LOCK_EX 2
+# endif
+# ifndef LOCK_NB
+#  define LOCK_NB 4
+# endif
+# ifndef LOCK_UN
+#  define LOCK_UN 8
+# endif
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+
+int
+flock(int fd, int operation)
+{
+    struct flock lock;
+
+    switch (operation & ~LOCK_NB) {
+    case LOCK_SH:
+	lock.l_type = F_RDLCK;
+	break;
+    case LOCK_EX:
+	lock.l_type = F_WRLCK;
+	break;
+    case LOCK_UN:
+	lock.l_type = F_UNLCK;
+	break;
+    default:
+	errno = EINVAL;
+	return -1;
+    }
+    lock.l_whence = SEEK_SET;
+    lock.l_start = lock.l_len = 0L;
+
+    return fcntl(fd, (operation & LOCK_NB) ? F_SETLK : F_SETLKW, &lock);
+}
+
+#elif defined(HAVE_LOCKF)
 
 #include <unistd.h>
 #include <errno.h>
@@ -24,7 +82,7 @@
 #  define F_TEST	3	/* Test a region for other processes locks */
 # endif
 
-/* These are the flock() constants.  Since this sytems doesn't have
+/* These are the flock() constants.  Since this systems doesn't have
    flock(), the values of the constants are probably not available.
 */
 # ifndef LOCK_SH
@@ -41,48 +99,39 @@
 # endif
 
 int
-flock(fd, operation)
-    int fd;
-    int operation;
+flock(int fd, int operation)
 {
-    int i;
     switch (operation) {
 
 	/* LOCK_SH - get a shared lock */
       case LOCK_SH:
+        rb_notimplement();
+        return -1;
 	/* LOCK_EX - get an exclusive lock */
       case LOCK_EX:
-	i = lockf (fd, F_LOCK, 0);
-	break;
+	return lockf (fd, F_LOCK, 0);
 
 	/* LOCK_SH|LOCK_NB - get a non-blocking shared lock */
       case LOCK_SH|LOCK_NB:
+        rb_notimplement();
+        return -1;
 	/* LOCK_EX|LOCK_NB - get a non-blocking exclusive lock */
       case LOCK_EX|LOCK_NB:
-	i = lockf (fd, F_TLOCK, 0);
-	if (i == -1)
-	    if ((errno == EAGAIN) || (errno == EACCES))
-		errno = EWOULDBLOCK;
-	break;
+	return lockf (fd, F_TLOCK, 0);
 
 	/* LOCK_UN - unlock */
       case LOCK_UN:
-	i = lockf (fd, F_ULOCK, 0);
-	break;
+	return lockf (fd, F_ULOCK, 0);
 
 	/* Default - can't decipher operation */
       default:
-	i = -1;
 	errno = EINVAL;
-	break;
+        return -1;
     }
-    return i;
 }
 #else
 int
-flock(fd, operation)
-    int fd;
-    int operation;
+flock(int fd, int operation)
 {
     rb_notimplement();
     return -1;