/* 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 #include #include 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 static unsigned char DNSRsp[] = { 0, 43, 0, 0, 0x81, 0x80, 0, 1, 0, 1, 0, 0, 0, 0 }; static unsigned char qrecord[] = { 5, 'e', 'c', 'h', 'o', 's', 3, 's', 'r', 'v', 0, 0, 1, 0, 1 }; static 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 { /* save header */ memcpy(&hdrbuf[DNSREC_LEN - hdrbuf_remaining], dnsreq, hdrbuf_remaining); dnsreq += hdrbuf_remaining; readbuf_remaining -= hdrbuf_remaining; hdrbuf_remaining = 0; /* get record length */ rec_remaining = (unsigned) hdrbuf[0] * 256 + (unsigned) hdrbuf[1]; rec_remaining -= (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, UV_RUN_DEFAULT); return 0; }