diff --git a/src/openvpn/manage.c b/src/openvpn/manage.c
index ae30930..bada1ae 100644
--- a/src/openvpn/manage.c
+++ b/src/openvpn/manage.c
@@ -3292,6 +3292,18 @@
     msg(M_CLIENT, ">PASSWORD:Auth-Token:%s", token);
 }
 
+/**
+ * Track which event the management socket is registered for in a persistent
+ * event set, so that event_ctl() is only called when it changes.
+ *
+ * @param persistent  The cached state, or NULL if the event set is rebuilt
+ *                    before every wait.
+ * @param n           The new state: 1 listening, 2 waiting to read from the
+ *                    client, 3 waiting to write to the client, 4 listening
+ *                    while accept() is paused for lack of resources.
+ *
+ * @return true if the socket must be registered again with event_ctl().
+ */
 static inline bool
 man_persist_state(unsigned int *persistent, const int n)
 {
@@ -3320,11 +3332,14 @@
         switch (man->connection.state)
         {
             case MS_LISTEN:
-                if (man_persist_state(persistent, 1))
+            {
+                const bool paused = (man->settings.flags & MF_SERVER) && socket_accept_paused();
+                if (man_persist_state(persistent, paused ? 4 : 1))
                 {
-                    event_ctl(es, ev, EVENT_READ, arg);
+                    event_ctl(es, ev, paused ? 0 : EVENT_READ, arg);
                 }
                 break;
+            }
 
             case MS_CC_WAIT_READ:
                 if (man_persist_state(persistent, 2))
@@ -3402,11 +3417,14 @@
     switch (man->connection.state)
     {
         case MS_LISTEN:
-            if (man_persist_state(persistent, 1))
+        {
+            const bool paused = (man->settings.flags & MF_SERVER) && socket_accept_paused();
+            if (man_persist_state(persistent, paused ? 4 : 1))
             {
-                event_ctl(es, man->connection.sd_top, EVENT_READ, arg);
+                event_ctl(es, man->connection.sd_top, paused ? 0 : EVENT_READ, arg);
             }
             break;
+        }
 
         case MS_CC_WAIT_READ:
             if (man_persist_state(persistent, 2))
diff --git a/src/openvpn/multi_io.c b/src/openvpn/multi_io.c
index e07b691..c06fbda 100644
--- a/src/openvpn/multi_io.c
+++ b/src/openvpn/multi_io.c
@@ -187,10 +187,25 @@
         }
         else if (!tuntap_is_dco_win(m->top.c1.tuntap))
         {
-            socket_set_listen_persistent(sock, m->multi_io->es, &sock->ev_arg);
+            if (socket_accept_paused())
+            {
+                socket_unset_listen_persistent(sock, m->multi_io->es);
+            }
+            else
+            {
+                socket_set_listen_persistent(sock, m->multi_io->es, &sock->ev_arg);
+            }
         }
     }
 
+    const time_t delay = socket_accept_paused();
+    if (delay && m->top.c2.timeval.tv_sec >= delay)
+    {
+        m->top.c2.timeval.tv_sec = (tv_sec_t)delay;
+        m->top.c2.timeval.tv_usec = 0;
+        m->earliest_wakeup = NULL;
+    }
+
     tun_set(m->top.c1.tuntap, m->multi_io->es, EVENT_READ, MULTI_IO_TUN, persistent);
 #if defined(ENABLE_DCO)
     dco_event_set(&m->top.c1.tuntap->dco, m->multi_io->es, MULTI_IO_DCO);
diff --git a/src/openvpn/socket.c b/src/openvpn/socket.c
index c07ef60..d756527 100644
--- a/src/openvpn/socket.c
+++ b/src/openvpn/socket.c
@@ -422,6 +422,38 @@
     gc_free(&gc);
 }
 
+/* accept() failed for lack of resources: no new accept() before this time */
+static time_t accept_resume = 0;       /* GLOBAL */
+static time_t accept_pause_logged = 0; /* GLOBAL */
+
+static void
+accept_check_resources(const int err)
+{
+#ifdef _WIN32
+    const bool out_of_resources = (err == WSAEMFILE || err == WSAENOBUFS);
+#else
+    const bool out_of_resources =
+        (err == EMFILE || err == ENFILE || err == ENOBUFS || err == ENOMEM);
+#endif
+    if (out_of_resources)
+    {
+        accept_resume = now + 1;
+        if (now >= accept_pause_logged + 60)
+        {
+            msg(M_WARN, "WARNING: out of resources to accept new connections, not accepting any "
+                        "for a second. New connections may fail meanwhile; check the open files "
+                        "limit. This message is shown at most once a minute.");
+            accept_pause_logged = now;
+        }
+    }
+}
+
+time_t
+socket_accept_paused(void)
+{
+    return now < accept_resume ? accept_resume - now : 0;
+}
+
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-conversion"
@@ -456,6 +488,10 @@
     else
     {
         new_sd = accept(sd, &act->dest.addr.sa, &remote_len);
+        if (!socket_defined(new_sd))
+        {
+            accept_check_resources(openvpn_errno());
+        }
     }
 
 #if 0 /* For debugging only, test the effect of accept() failures */
@@ -2700,6 +2736,10 @@
          * scripts don't have access to it */
         set_cloexec(ret);
     }
+    else
+    {
+        accept_check_resources(openvpn_errno());
+    }
     return ret;
 }
 
diff --git a/src/openvpn/socket.h b/src/openvpn/socket.h
index 2210bfe..6324a17 100644
--- a/src/openvpn/socket.h
+++ b/src/openvpn/socket.h
@@ -410,6 +410,9 @@
                                                  const char *bind_dev, struct addrinfo *bind_addr,
                                                  bool bind_ipv6_only, bool optional);
 
+/* Seconds left before accept() is retried after it failed for lack of resources */
+time_t socket_accept_paused(void);
+
 socket_descriptor_t socket_do_accept(socket_descriptor_t sd, struct link_socket_actual *act,
                                      const bool nowait);
 
@@ -846,6 +849,16 @@
 }
 
 static inline void
+socket_unset_listen_persistent(struct link_socket *sock, struct event_set *es)
+{
+    if (sock && sock->listen_persistent_queued)
+    {
+        event_del(es, socket_listen_event_handle(sock));
+        sock->listen_persistent_queued = false;
+    }
+}
+
+static inline void
 socket_reset_listen_persistent(struct link_socket *sock)
 {
 #ifdef _WIN32
