asyncengine 0.0.1.testing

data/ext/asyncengine_ext/libuv/test/dns-server.c

@@ -0,0 +1,321 @@
+/* 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 "task.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+typedef struct {
+  uv_write_t req;
+  uv_buf_t buf;
+} write_req_t;
+
+
+/* used to track multiple DNS requests received */
+typedef struct {
+  char* prevbuf_ptr;
+  int prevbuf_pos;
+  int prevbuf_rem;
+} dnsstate;
+
+
+/* modify handle to append dnsstate */
+typedef struct {
+  uv_tcp_t handle;
+  dnsstate state;
+} dnshandle;
+
+
+static uv_loop_t* loop;
+
+
+static uv_tcp_t server;
+
+
+static void after_write(uv_write_t* req, int status);
+static void after_read(uv_stream_t*, ssize_t nread, uv_buf_t buf);
+static void on_close(uv_handle_t* peer);
+static void on_connection(uv_stream_t*, int status);
+
+#define WRITE_BUF_LEN   (64*1024)
+#define DNSREC_LEN      (4)
+
+#define LEN_OFFSET 0
+#define QUERYID_OFFSET 2
+unsigned char DNSRsp[] = {0, 43, 0, 0, 0x81, 0x80, 0, 1, 0, 1, 0, 0, 0, 0 };
+unsigned char qrecord[] = {5, 'e', 'c', 'h', 'o', 's', 3, 's', 'r', 'v', 0, 0, 1, 0, 1};
+unsigned char arecord[] = {0xc0, 0x0c, 0, 1, 0, 1, 0, 0, 5, 0xbd, 0, 4, 10, 0, 1, 1 };
+
+
+static void after_write(uv_write_t* req, int status) {
+  write_req_t* wr;
+
+  if (status) {
+    uv_err_t err = uv_last_error(loop);
+    fprintf(stderr, "uv_write error: %s\n", uv_strerror(err));
+    ASSERT(0);
+  }
+
+  wr = (write_req_t*) req;
+
+  /* Free the read/write buffer and the request */
+  free(wr->buf.base);
+  free(wr);
+}
+
+
+static void after_shutdown(uv_shutdown_t* req, int status) {
+  uv_close((uv_handle_t*) req->handle, on_close);
+  free(req);
+}
+
+
+static void addrsp(write_req_t* wr, char* hdr) {
+  char * dnsrsp;
+  short int rsplen;
+  short int* reclen;
+
+  rsplen = sizeof(DNSRsp) + sizeof(qrecord) + sizeof(arecord);
+
+  ASSERT (rsplen + wr->buf.len < WRITE_BUF_LEN);
+
+  dnsrsp = wr->buf.base + wr->buf.len;
+
+  /* copy stock response */
+  memcpy(dnsrsp, DNSRsp, sizeof(DNSRsp));
+  memcpy(dnsrsp + sizeof(DNSRsp), qrecord, sizeof(qrecord));
+  memcpy(dnsrsp + sizeof(DNSRsp) + sizeof(qrecord), arecord, sizeof(arecord));
+
+  /* overwrite with network order length and id from request header */
+  reclen = (short int*)dnsrsp;
+  *reclen = htons(rsplen-2);
+  dnsrsp[QUERYID_OFFSET] = hdr[QUERYID_OFFSET];
+  dnsrsp[QUERYID_OFFSET+1] = hdr[QUERYID_OFFSET+1];
+
+  wr->buf.len += rsplen;
+}
+
+static void process_req(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
+  write_req_t* wr;
+  dnshandle* dns = (dnshandle*)handle;
+  char hdrbuf[DNSREC_LEN];
+  int hdrbuf_remaining = DNSREC_LEN;
+  int rec_remaining = 0;
+  int readbuf_remaining;
+  char* dnsreq;
+  char* hdrstart;
+  int usingprev = 0;
+
+  wr = (write_req_t*) malloc(sizeof *wr);
+  wr->buf.base = (char*)malloc(WRITE_BUF_LEN);
+  wr->buf.len = 0;
+
+  if (dns->state.prevbuf_ptr != NULL) {
+    dnsreq = dns->state.prevbuf_ptr + dns->state.prevbuf_pos;
+    readbuf_remaining = dns->state.prevbuf_rem;
+    usingprev = 1;
+  } else {
+    dnsreq = buf.base;
+    readbuf_remaining = nread;
+  }
+  hdrstart = dnsreq;
+
+  while (dnsreq != NULL) {
+    /* something to process */
+    while (readbuf_remaining > 0) {
+      /* something to process in current buffer */
+      if (hdrbuf_remaining > 0) {
+        /* process len and id */
+        if (readbuf_remaining < hdrbuf_remaining) {
+          /* too little to get request header. save for next buffer */
+          memcpy(&hdrbuf[DNSREC_LEN - hdrbuf_remaining], dnsreq, readbuf_remaining);
+          hdrbuf_remaining = DNSREC_LEN - readbuf_remaining;
+          break;
+        } else {
+          short int reclen_n;
+          /* save header */
+          memcpy(&hdrbuf[DNSREC_LEN - hdrbuf_remaining], dnsreq, hdrbuf_remaining);
+          dnsreq += hdrbuf_remaining;
+          readbuf_remaining -= hdrbuf_remaining;
+          hdrbuf_remaining = 0;
+
+          /* get record length */
+          reclen_n = *((short int*)hdrbuf);
+          rec_remaining = ntohs(reclen_n) - (DNSREC_LEN - 2);
+        }
+      }
+
+      if (rec_remaining <= readbuf_remaining) {
+        /* prepare reply */
+        addrsp(wr, hdrbuf);
+
+        /* move to next record */
+        dnsreq += rec_remaining;
+        hdrstart = dnsreq;
+        readbuf_remaining -= rec_remaining;
+        rec_remaining = 0;
+        hdrbuf_remaining = DNSREC_LEN;
+      } else {
+        /* otherwise this buffer is done. */
+        rec_remaining -= readbuf_remaining;
+        break;
+      }
+    }
+
+    /* if we had to use bytes from prev buffer, start processing the current one */
+    if (usingprev == 1) {
+      /* free previous buffer */
+      free(dns->state.prevbuf_ptr);
+      dnsreq = buf.base;
+      readbuf_remaining = nread;
+      usingprev = 0;
+    } else {
+      dnsreq = NULL;
+    }
+  }
+
+  /* send write buffer */
+  if (wr->buf.len > 0) {
+    if (uv_write((uv_write_t*) &wr->req, handle, &wr->buf, 1, after_write)) {
+      FATAL("uv_write failed");
+    }
+  }
+
+  if (readbuf_remaining > 0) {
+    /* save start of record position, so we can continue on next read */
+    dns->state.prevbuf_ptr = buf.base;
+    dns->state.prevbuf_pos = hdrstart - buf.base;
+    dns->state.prevbuf_rem = nread - dns->state.prevbuf_pos;
+  } else {
+    /* nothing left in this buffer */
+    dns->state.prevbuf_ptr = NULL;
+    dns->state.prevbuf_pos = 0;
+    dns->state.prevbuf_rem = 0;
+    free(buf.base);
+  }
+}
+
+static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
+  uv_shutdown_t* req;
+
+  if (nread < 0) {
+    /* Error or EOF */
+    ASSERT (uv_last_error(loop).code == UV_EOF);
+
+    if (buf.base) {
+      free(buf.base);
+    }
+
+    req = malloc(sizeof *req);
+    uv_shutdown(req, handle, after_shutdown);
+
+    return;
+  }
+
+  if (nread == 0) {
+    /* Everything OK, but nothing read. */
+    free(buf.base);
+    return;
+  }
+  /* process requests and send responses */
+  process_req(handle, nread, buf);
+}
+
+
+static void on_close(uv_handle_t* peer) {
+  free(peer);
+}
+
+
+static uv_buf_t buf_alloc(uv_handle_t* handle, size_t suggested_size) {
+  uv_buf_t buf;
+  buf.base = (char*) malloc(suggested_size);
+  buf.len = suggested_size;
+  return buf;
+}
+
+
+static void on_connection(uv_stream_t* server, int status) {
+  dnshandle* handle;
+  int r;
+
+  ASSERT(status == 0);
+
+  handle = (dnshandle*) malloc(sizeof *handle);
+  ASSERT(handle != NULL);
+
+  /* initialize read buffer state */
+  handle->state.prevbuf_ptr = 0;
+  handle->state.prevbuf_pos = 0;
+  handle->state.prevbuf_rem = 0;
+
+  r = uv_tcp_init(loop, (uv_tcp_t*)handle);
+  ASSERT(r == 0);
+
+  r = uv_accept(server, (uv_stream_t*)handle);
+  ASSERT(r == 0);
+
+  r = uv_read_start((uv_stream_t*)handle, buf_alloc, after_read);
+  ASSERT(r == 0);
+}
+
+
+static int dns_start(int port) {
+  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port);
+  int r;
+
+  r = uv_tcp_init(loop, &server);
+  if (r) {
+    /* TODO: Error codes */
+    fprintf(stderr, "Socket creation error\n");
+    return 1;
+  }
+
+  r = uv_tcp_bind(&server, addr);
+  if (r) {
+    /* TODO: Error codes */
+    fprintf(stderr, "Bind error\n");
+    return 1;
+  }
+
+  r = uv_listen((uv_stream_t*)&server, 128, on_connection);
+  if (r) {
+    /* TODO: Error codes */
+    fprintf(stderr, "Listen error\n");
+    return 1;
+  }
+
+  return 0;
+}
+
+
+HELPER_IMPL(dns_server) {
+  loop = uv_default_loop();
+
+  if (dns_start(TEST_PORT_2))
+    return 1;
+
+  uv_run(loop);
+  return 0;
+}

data/ext/asyncengine_ext/libuv/test/echo-server.c

@@ -0,0 +1,370 @@
+/* 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 "task.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct {
+  uv_write_t req;
+  uv_buf_t buf;
+} write_req_t;
+
+static uv_loop_t* loop;
+
+static int server_closed;
+static stream_type serverType;
+static uv_tcp_t tcpServer;
+static uv_udp_t udpServer;
+static uv_pipe_t pipeServer;
+static uv_handle_t* server;
+
+static void after_write(uv_write_t* req, int status);
+static void after_read(uv_stream_t*, ssize_t nread, uv_buf_t buf);
+static void on_close(uv_handle_t* peer);
+static void on_server_close(uv_handle_t* handle);
+static void on_connection(uv_stream_t*, int status);
+
+
+static void after_write(uv_write_t* req, int status) {
+  write_req_t* wr;
+
+  if (status) {
+    uv_err_t err = uv_last_error(loop);
+    fprintf(stderr, "uv_write error: %s\n", uv_strerror(err));
+    ASSERT(0);
+  }
+
+  wr = (write_req_t*) req;
+
+  /* Free the read/write buffer and the request */
+  free(wr->buf.base);
+  free(wr);
+}
+
+
+static void after_shutdown(uv_shutdown_t* req, int status) {
+  uv_close((uv_handle_t*)req->handle, on_close);
+  free(req);
+}
+
+
+static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
+  int i;
+  write_req_t *wr;
+  uv_shutdown_t* req;
+
+  if (nread < 0) {
+    /* Error or EOF */
+    ASSERT (uv_last_error(loop).code == UV_EOF);
+
+    if (buf.base) {
+      free(buf.base);
+    }
+
+    req = (uv_shutdown_t*) malloc(sizeof *req);
+    uv_shutdown(req, handle, after_shutdown);
+
+    return;
+  }
+
+  if (nread == 0) {
+    /* Everything OK, but nothing read. */
+    free(buf.base);
+    return;
+  }
+
+  /*
+   * Scan for the letter Q which signals that we should quit the server.
+   * If we get QS it means close the stream.
+   */
+  if (!server_closed) {
+    for (i = 0; i < nread; i++) {
+      if (buf.base[i] == 'Q') {
+        if (i + 1 < nread && buf.base[i + 1] == 'S') {
+          free(buf.base);
+          uv_close((uv_handle_t*)handle, on_close);
+          return;
+        } else {
+          uv_close(server, on_server_close);
+          server_closed = 1;
+        }
+      }
+    }
+  }
+
+  wr = (write_req_t*) malloc(sizeof *wr);
+
+  wr->buf = uv_buf_init(buf.base, nread);
+  if (uv_write(&wr->req, handle, &wr->buf, 1, after_write)) {
+    FATAL("uv_write failed");
+  }
+}
+
+
+static void on_close(uv_handle_t* peer) {
+  free(peer);
+}
+
+
+static uv_buf_t echo_alloc(uv_handle_t* handle, size_t suggested_size) {
+  return uv_buf_init(malloc(suggested_size), suggested_size);
+}
+
+
+static void on_connection(uv_stream_t* server, int status) {
+  uv_stream_t* stream;
+  int r;
+
+  if (status != 0) {
+    fprintf(stderr, "Connect error %d\n",
+        uv_last_error(loop).code);
+  }
+  ASSERT(status == 0);
+
+  switch (serverType) {
+  case TCP:
+    stream = malloc(sizeof(uv_tcp_t));
+    ASSERT(stream != NULL);
+    r = uv_tcp_init(loop, (uv_tcp_t*)stream);
+    ASSERT(r == 0);
+    break;
+
+  case PIPE:
+    stream = malloc(sizeof(uv_pipe_t));
+    ASSERT(stream != NULL);
+    r = uv_pipe_init(loop, (uv_pipe_t*)stream, 0);
+    ASSERT(r == 0);
+    break;
+
+  default:
+    ASSERT(0 && "Bad serverType");
+    abort();
+  }
+
+  /* associate server with stream */
+  stream->data = server;
+
+  r = uv_accept(server, stream);
+  ASSERT(r == 0);
+
+  r = uv_read_start(stream, echo_alloc, after_read);
+  ASSERT(r == 0);
+}
+
+
+static void on_server_close(uv_handle_t* handle) {
+  ASSERT(handle == server);
+}
+
+
+static void on_send(uv_udp_send_t* req, int status);
+
+
+static void on_recv(uv_udp_t* handle,
+                    ssize_t nread,
+                    uv_buf_t buf,
+                    struct sockaddr* addr,
+                    unsigned flags) {
+  uv_udp_send_t* req;
+  int r;
+
+  ASSERT(nread > 0);
+  ASSERT(addr->sa_family == AF_INET);
+
+  req = malloc(sizeof(*req));
+  ASSERT(req != NULL);
+
+  r = uv_udp_send(req, handle, &buf, 1, *(struct sockaddr_in*)addr, on_send);
+  ASSERT(r == 0);
+}
+
+
+static void on_send(uv_udp_send_t* req, int status) {
+  ASSERT(status == 0);
+  free(req);
+}
+
+
+static int tcp4_echo_start(int port) {
+  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port);
+  int r;
+
+  server = (uv_handle_t*)&tcpServer;
+  serverType = TCP;
+
+  r = uv_tcp_init(loop, &tcpServer);
+  if (r) {
+    /* TODO: Error codes */
+    fprintf(stderr, "Socket creation error\n");
+    return 1;
+  }
+
+  r = uv_tcp_bind(&tcpServer, addr);
+  if (r) {
+    /* TODO: Error codes */
+    fprintf(stderr, "Bind error\n");
+    return 1;
+  }
+
+  r = uv_listen((uv_stream_t*)&tcpServer, SOMAXCONN, on_connection);
+  if (r) {
+    /* TODO: Error codes */
+    fprintf(stderr, "Listen error %s\n",
+        uv_err_name(uv_last_error(loop)));
+    return 1;
+  }
+
+  return 0;
+}
+
+
+static int tcp6_echo_start(int port) {
+  struct sockaddr_in6 addr6 = uv_ip6_addr("::1", port);
+  int r;
+
+  server = (uv_handle_t*)&tcpServer;
+  serverType = TCP;
+
+  r = uv_tcp_init(loop, &tcpServer);
+  if (r) {
+    /* TODO: Error codes */
+    fprintf(stderr, "Socket creation error\n");
+    return 1;
+  }
+
+  /* IPv6 is optional as not all platforms support it */
+  r = uv_tcp_bind6(&tcpServer, addr6);
+  if (r) {
+    /* show message but return OK */
+    fprintf(stderr, "IPv6 not supported\n");
+    return 0;
+  }
+
+  r = uv_listen((uv_stream_t*)&tcpServer, SOMAXCONN, on_connection);
+  if (r) {
+    /* TODO: Error codes */
+    fprintf(stderr, "Listen error\n");
+    return 1;
+  }
+
+  return 0;
+}
+
+
+static int udp4_echo_start(int port) {
+  int r;
+
+  server = (uv_handle_t*)&udpServer;
+  serverType = UDP;
+
+  r = uv_udp_init(loop, &udpServer);
+  if (r) {
+    fprintf(stderr, "uv_udp_init: %s\n",
+        uv_strerror(uv_last_error(loop)));
+    return 1;
+  }
+
+  r = uv_udp_recv_start(&udpServer, echo_alloc, on_recv);
+  if (r) {
+    fprintf(stderr, "uv_udp_recv_start: %s\n",
+        uv_strerror(uv_last_error(loop)));
+    return 1;
+  }
+
+  return 0;
+}
+
+
+static int pipe_echo_start(char* pipeName) {
+  int r;
+
+  server = (uv_handle_t*)&pipeServer;
+  serverType = PIPE;
+
+  r = uv_pipe_init(loop, &pipeServer, 0);
+  if (r) {
+    fprintf(stderr, "uv_pipe_init: %s\n",
+        uv_strerror(uv_last_error(loop)));
+    return 1;
+  }
+
+  r = uv_pipe_bind(&pipeServer, pipeName);
+  if (r) {
+    fprintf(stderr, "uv_pipe_bind: %s\n",
+        uv_strerror(uv_last_error(loop)));
+    return 1;
+  }
+
+  r = uv_listen((uv_stream_t*)&pipeServer, SOMAXCONN, on_connection);
+  if (r) {
+    fprintf(stderr, "uv_pipe_listen: %s\n",
+        uv_strerror(uv_last_error(loop)));
+    return 1;
+  }
+
+  return 0;
+}
+
+
+HELPER_IMPL(tcp4_echo_server) {
+  loop = uv_default_loop();
+
+  if (tcp4_echo_start(TEST_PORT))
+    return 1;
+
+  uv_run(loop);
+  return 0;
+}
+
+
+HELPER_IMPL(tcp6_echo_server) {
+  loop = uv_default_loop();
+
+  if (tcp6_echo_start(TEST_PORT))
+    return 1;
+
+  uv_run(loop);
+  return 0;
+}
+
+
+HELPER_IMPL(pipe_echo_server) {
+  loop = uv_default_loop();
+
+  if (pipe_echo_start(TEST_PIPENAME))
+    return 1;
+
+  uv_run(loop);
+  return 0;
+}
+
+
+HELPER_IMPL(udp4_echo_server) {
+  loop = uv_default_loop();
+
+  if (udp4_echo_start(TEST_PORT))
+    return 1;
+
+  uv_run(loop);
+  return 0;
+}

data/ext/asyncengine_ext/libuv/test/fixtures/load_error.node

@@ -0,0 +1 @@
+foobar