asyncengine 0.0.1.testing

data/ext/asyncengine_ext/libuv/src/ares/windows_port.c

@@ -0,0 +1,22 @@
+#include "ares_setup.h"
+
+
+/* only do the following on windows
+ */
+#if (defined(WIN32) || defined(WATT32)) && !defined(MSDOS)
+
+#ifdef __WATCOMC__
+/*
+ * Watcom needs a DllMain() in order to initialise the clib startup code.
+ */
+BOOL
+WINAPI DllMain (HINSTANCE hnd, DWORD reason, LPVOID reserved)
+{
+  (void) hnd;
+  (void) reason;
+  (void) reserved;
+  return (TRUE);
+}
+#endif
+
+#endif /* WIN32 builds only */

data/ext/asyncengine_ext/libuv/src/unix/async.c

@@ -0,0 +1,58 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ * 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.
+ */
+
+#include "uv.h"
+#include "internal.h"
+
+
+static void uv__async(EV_P_ ev_async* w, int revents) {
+  uv_async_t* async = container_of(w, uv_async_t, async_watcher);
+
+  if (async->async_cb) {
+    async->async_cb(async, 0);
+  }
+}
+
+
+int uv_async_init(uv_loop_t* loop, uv_async_t* async, uv_async_cb async_cb) {
+  uv__handle_init(loop, (uv_handle_t*)async, UV_ASYNC);
+  loop->counters.async_init++;
+
+  ev_async_init(&async->async_watcher, uv__async);
+  async->async_cb = async_cb;
+
+  /* Note: This does not have symmetry with the other libev wrappers. */
+  ev_async_start(loop->ev, &async->async_watcher);
+  ev_unref(loop->ev);
+
+  return 0;
+}
+
+
+int uv_async_send(uv_async_t* async) {
+  ev_async_send(async->loop->ev, &async->async_watcher);
+  return 0;
+}
+
+
+void uv__async_close(uv_async_t* handle) {
+  ev_async_stop(handle->loop->ev, &handle->async_watcher);
+  ev_ref(handle->loop->ev);
+}

data/ext/asyncengine_ext/libuv/src/unix/cares.c

@@ -0,0 +1,194 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * 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.
+ */
+
+#include "uv.h"
+#include "internal.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+
+
+/*
+ * This is called once per second by loop->timer. It is used to
+ * constantly callback into c-ares for possibly processing timeouts.
+ */
+static void uv__ares_timeout(uv_timer_t* handle, int status) {
+  assert(!uv_ares_handles_empty(handle->loop));
+  ares_process_fd(handle->loop->channel, ARES_SOCKET_BAD, ARES_SOCKET_BAD);
+}
+
+
+static void uv__ares_timer_start(uv_loop_t* loop) {
+  if (uv_is_active((uv_handle_t*)&loop->timer)) return;
+  uv_timer_start(&loop->timer, uv__ares_timeout, 1000, 1000);
+  uv_ref(loop);
+}
+
+
+static void uv__ares_timer_stop(uv_loop_t* loop) {
+  if (!uv_is_active((uv_handle_t*)&loop->timer)) return;
+  uv_timer_stop(&loop->timer);
+  uv_unref(loop);
+}
+
+
+static void uv__ares_io(struct ev_loop* ev, struct ev_io* watcher,
+    int revents) {
+  uv_loop_t* loop = ev_userdata(ev);
+
+  assert(ev == loop->ev);
+
+  /* Reset the idle timer */
+  uv_timer_again(&loop->timer);
+
+  /* Process DNS responses */
+  ares_process_fd(loop->channel,
+      revents & EV_READ ? watcher->fd : ARES_SOCKET_BAD,
+      revents & EV_WRITE ? watcher->fd : ARES_SOCKET_BAD);
+}
+
+
+/* Allocates and returns a new uv_ares_task_t */
+static uv_ares_task_t* uv__ares_task_create(uv_loop_t* loop, int fd) {
+  uv_ares_task_t* h = malloc(sizeof(uv_ares_task_t));
+
+  if (h == NULL) {
+    uv_fatal_error(ENOMEM, "malloc");
+    return NULL;
+  }
+
+  h->loop = loop;
+  h->sock = fd;
+
+  ev_io_init(&h->read_watcher, uv__ares_io, fd, EV_READ);
+  ev_io_init(&h->write_watcher, uv__ares_io, fd, EV_WRITE);
+
+  h->read_watcher.data = h;
+  h->write_watcher.data = h;
+
+  return h;
+}
+
+
+/* Callback from ares when socket operation is started */
+static void uv__ares_sockstate_cb(void* data, ares_socket_t sock,
+    int read, int write) {
+  uv_loop_t* loop = data;
+  uv_ares_task_t* h;
+
+  assert((uv_loop_t*)loop->timer.data == loop);
+
+  h = uv_find_ares_handle(loop, sock);
+
+  if (read || write) {
+    if (!h) {
+      /* New socket */
+
+      /* If this is the first socket then start the timer. */
+      if (!uv_is_active((uv_handle_t*)&loop->timer)) {
+        assert(uv_ares_handles_empty(loop));
+        uv__ares_timer_start(loop);
+      }
+
+      h = uv__ares_task_create(loop, sock);
+      uv_add_ares_handle(loop, h);
+    }
+
+    if (read) {
+      ev_io_start(loop->ev, &h->read_watcher);
+    } else {
+      ev_io_stop(loop->ev, &h->read_watcher);
+    }
+
+    if (write) {
+      ev_io_start(loop->ev, &h->write_watcher);
+    } else {
+      ev_io_stop(loop->ev, &h->write_watcher);
+    }
+
+  } else {
+    /*
+     * read == 0 and write == 0 this is c-ares's way of notifying us that
+     * the socket is now closed. We must free the data associated with
+     * socket.
+     */
+    assert(h && "When an ares socket is closed we should have a handle for it");
+
+    ev_io_stop(loop->ev, &h->read_watcher);
+    ev_io_stop(loop->ev, &h->write_watcher);
+
+    uv_remove_ares_handle(h);
+    free(h);
+
+    if (uv_ares_handles_empty(loop)) {
+      uv__ares_timer_stop(loop);
+    }
+  }
+}
+
+
+/* c-ares integration initialize and terminate */
+/* TODO: share this with windows? */
+int uv_ares_init_options(uv_loop_t* loop, ares_channel *channelptr,
+    struct ares_options *options, int optmask) {
+  int rc;
+
+  /* only allow single init at a time */
+  if (loop->channel != NULL) {
+    uv__set_artificial_error(loop, UV_EALREADY);
+    return -1;
+  }
+
+  /* set our callback as an option */
+  options->sock_state_cb = uv__ares_sockstate_cb;
+  options->sock_state_cb_data = loop;
+  optmask |= ARES_OPT_SOCK_STATE_CB;
+
+  /* We do the call to ares_init_option for caller. */
+  rc = ares_init_options(channelptr, options, optmask);
+
+  /* if success, save channel */
+  if (rc == ARES_SUCCESS) {
+    loop->channel = *channelptr;
+  } 
+
+  /*
+   * Initialize the timeout timer. The timer won't be started until the
+   * first socket is opened.
+   */
+  uv_timer_init(loop, &loop->timer);
+  uv_unref(loop);
+  loop->timer.data = loop;
+
+  return rc;
+}
+
+
+/* TODO share this with windows? */
+void uv_ares_destroy(uv_loop_t* loop, ares_channel channel) {
+  /* only allow destroy if did init */
+  if (loop->channel) {
+    uv__ares_timer_stop(loop);
+    ares_destroy(channel);
+    loop->channel = NULL;
+  }
+}

data/ext/asyncengine_ext/libuv/src/unix/check.c

@@ -0,0 +1,80 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ * 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.
+ */
+
+#include "uv.h"
+#include "internal.h"
+
+
+static void uv__check(EV_P_ ev_check* w, int revents) {
+  uv_check_t* check = container_of(w, uv_check_t, check_watcher);
+
+  if (check->check_cb) {
+    check->check_cb(check, 0);
+  }
+}
+
+
+int uv_check_init(uv_loop_t* loop, uv_check_t* check) {
+  uv__handle_init(loop, (uv_handle_t*)check, UV_CHECK);
+  loop->counters.check_init++;
+
+  ev_check_init(&check->check_watcher, uv__check);
+  check->check_cb = NULL;
+
+  return 0;
+}
+
+
+int uv_check_start(uv_check_t* check, uv_check_cb cb) {
+  int was_active = ev_is_active(&check->check_watcher);
+
+  check->check_cb = cb;
+
+  ev_check_start(check->loop->ev, &check->check_watcher);
+
+  if (!was_active) {
+    ev_unref(check->loop->ev);
+  }
+
+  return 0;
+}
+
+
+int uv_check_stop(uv_check_t* check) {
+  int was_active = ev_is_active(&check->check_watcher);
+
+  ev_check_stop(check->loop->ev, &check->check_watcher);
+
+  if (was_active) {
+    ev_ref(check->loop->ev);
+  }
+
+  return 0;
+}
+
+
+int uv__check_active(const uv_check_t* handle) {
+  return ev_is_active(&handle->check_watcher);
+}
+
+
+void uv__check_close(uv_check_t* handle) {
+  uv_check_stop(handle);
+}