Permalink
Browse files

dgram: integrate libuv UDP support

  • Loading branch information...
1 parent 9cb6249 commit cbd4033619cc45abdf878285c412bac9c3f36e4e @bnoordhuis bnoordhuis committed Aug 20, 2011
Showing with 687 additions and 2 deletions.
  1. +10 −2 doc/api/dgram.markdown
  2. 0 lib/{dgram.js → dgram_legacy.js}
  3. +312 −0 lib/dgram_uv.js
  4. +3 −0 src/node.js
  5. +1 −0 src/node_extensions.h
  6. +360 −0 src/udp_wrap.cc
  7. +1 −0 wscript
View
@@ -31,6 +31,11 @@ Creates a datagram socket of the specified types. Valid types are:
Takes an optional callback which is added as a listener for `message` events.
+Call `socket.bind` if you want to receive datagrams. `socket.bind()` will bind
+to the "all interfaces" address on a random port (it does the right thing for
+both `udp4` and `udp6` sockets). You can then retrieve the address and port
+with `socket.address().address` and `socket.address().port`.
+
### dgram.send(buf, offset, length, path, [callback])
For Unix domain datagram sockets, the destination address is a pathname in the filesystem.
@@ -61,6 +66,10 @@ re-used. Note that DNS lookups will delay the time that a send takes place, at
least until the next tick. The only way to know for sure that a send has taken place
is to use the callback.
+If the socket has not been previously bound with a call to `bind`, it's
+assigned a random port number and bound to the "all interfaces" address
+(0.0.0.0 for IPv4-only systems, ::0 for IPv6 and dual stack systems).
+
Example of sending a UDP packet to a random port on `localhost`;
var dgram = require('dgram');
@@ -142,8 +151,7 @@ Example of a UDP server listening on port 41234:
### dgram.close()
-Close the underlying socket and stop listening for data on it. UDP sockets
-automatically listen for messages, even if they did not call `bind()`.
+Close the underlying socket and stop listening for data on it.
### dgram.address()
File renamed without changes.
View
@@ -0,0 +1,312 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var util = require('util');
+var events = require('events');
+
+var UDP = process.binding('udp_wrap').UDP;
+
+// lazily loaded
+var dns = null;
+var net = null;
+
+
+// no-op callback
+function noop() {
+}
+
+
+function isIP(address) {
+ if (!net)
+ net = require('net');
+
+ return net.isIP(address);
+}
+
+
+function lookup(address, family, callback) {
+ // implicit 'bind before send' needs to run on the same tick
+ var matchedFamily = isIP(address);
+ if (matchedFamily)
+ return callback(null, address, matchedFamily);
+
+ if (!dns)
+ dns = require('dns');
+
+ return dns.lookup(address, family, callback);
+}
+
+
+function lookup4(address, callback) {
+ return lookup(address || '0.0.0.0', 4, callback);
+}
+
+
+function lookup6(address, callback) {
+ return lookup(address || '::0', 6, callback);
+}
+
+
+function newHandle(type) {
+ if (type == 'udp4') {
+ var handle = new UDP;
+ handle.lookup = lookup4;
+ return handle;
+ }
+
+ if (type == 'udp6') {
+ var handle = new UDP;
+ handle.lookup = lookup6;
+ handle.bind = handle.bind6;
+ handle.send = handle.send6;
+ return handle;
+ }
+
+ if (type == 'unix_dgram')
+ throw new Error('unix_dgram sockets are not supported any more.');
+
+ throw new Error('Bad socket type specified. Valid types are: udp4, udp6');
+}
+
+
+function Socket(type, listener) {
+ events.EventEmitter.call(this);
+
+ var handle = newHandle(type);
+ handle.socket = this;
+
+ this._handle = handle;
+ this._receiving = false;
+ this._bound = false;
+ this.type = type;
+
+ if (typeof listener === 'function')
+ this.on('message', listener);
+}
+util.inherits(Socket, events.EventEmitter);
+exports.Socket = Socket;
+
+
+exports.createSocket = function(type, listener) {
+ return new Socket(type, listener);
+};
+
+
+Socket.prototype.bind = function(port, address) {
+ var self = this;
+
+ self._healthCheck();
+
+ // resolve address first
+ self._handle.lookup(address, function(err, ip) {
+ if (!err) {
+ if (self._handle.bind(ip, port || 0, /*flags=*/0)) {
+ err = errnoException(errno, 'bind');
+ }
+ else {
+ self._bound = true;
+ self.emit('listening');
+ self._startReceiving();
+ }
+ }
+
+ if (err) {
+ // caller may not have had a chance yet to register its
+ // error event listener so defer the error to the next tick
+ process.nextTick(function() {
+ self.emit('error', err);
+ });
+ }
+ });
+};
+
+
+// thin wrapper around `send`, here for compatibility with dgram_legacy.js
+Socket.prototype.sendto = function(buffer,
+ offset,
+ length,
+ port,
+ address,
+ callback) {
+ if (typeof offset !== 'number' || typeof length !== 'number')
+ throw new Error('send takes offset and length as args 2 and 3');
+
+ if (typeof address !== 'string')
+ throw new Error(this.type + ' sockets must send to port, address');
+
+ this.send(buffer, offset, length, port, address, callback);
+};
+
+
+Socket.prototype.send = function(buffer,
+ offset,
+ length,
+ port,
+ address,
+ callback) {
+ var self = this;
+
+ callback = callback || noop;
+
+ self._healthCheck();
+ self._startReceiving();
+
+ self._handle.lookup(address, function(err, ip) {
+ if (err) {
+ if (callback) callback(err);
+ self.emit('error', err);
+ }
+ else {
+ var req = self._handle.send(buffer, offset, length, port, ip);
+ if (req) {
+ req.oncomplete = afterSend;
+ req.cb = callback;
+ }
+ else {
+ // don't emit as error, dgram_legacy.js compatibility
+ callback(errnoException(errno, 'send'));
+ }
+ }
+ });
+};
+
+
+function afterSend(status, handle, req, buffer) {
+ var self = handle.socket;
+
+ // CHECKME socket's been closed by user, don't call callback?
+ if (handle !== self._handle)
+ void(0);
+
+ if (req.cb)
+ req.cb(null, buffer.length); // compatibility with dgram_legacy.js
+}
+
+
+Socket.prototype.close = function() {
+ this._healthCheck();
+ this._stopReceiving();
+ this._handle.close();
+ this._handle = null;
+ this.emit('close');
+};
+
+
+Socket.prototype.address = function() {
+ this._healthCheck();
+
+ var address = this._handle.getsockname();
+ if (!address)
+ throw errnoException(errno, 'getsockname');
+
+ return address;
+};
+
+
+Socket.prototype.setBroadcast = function(arg) {
+ throw new Error('not yet implemented');
+};
+
+
+Socket.prototype.setTTL = function(arg) {
+ throw new Error('not yet implemented');
+};
+
+
+Socket.prototype.setMulticastTTL = function(arg) {
+ throw new Error('not yet implemented');
+};
+
+
+Socket.prototype.setMulticastLoopback = function(arg) {
+ throw new Error('not yet implemented');
+};
+
+
+Socket.prototype.addMembership = function(multicastAddress,
+ multicastInterface) {
+ // are we ever going to support this in libuv?
+ throw new Error('not yet implemented');
+};
+
+
+Socket.prototype.dropMembership = function(multicastAddress,
+ multicastInterface) {
+ // are we ever going to support this in libuv?
+ throw new Error('not yet implemented');
+};
+
+
+Socket.prototype._healthCheck = function() {
+ if (!this._handle)
+ throw new Error('Not running'); // error message from dgram_legacy.js
+};
+
+
+Socket.prototype._startReceiving = function() {
+ if (this._receiving)
+ return;
+
+ if (!this._bound) {
+ this.bind(); // bind to random port
+
+ // sanity check
+ if (!this._bound)
+ throw new Error('implicit bind failed');
+ }
+
+ this._handle.onmessage = onMessage;
+ this._handle.recvStart();
+ this._receiving = true;
+ this.fd = -42; // compatibility hack
+};
+
+
+Socket.prototype._stopReceiving = function() {
+ if (!this._receiving)
+ return;
+
+ this._handle.onmessage = null;
+ this._handle.recvStop();
+ this._receiving = false;
+};
+
+
+function onMessage(handle, nread, buf, rinfo) {
+ var self = handle.socket;
+
+ if (nread == -1) {
+ self.emit('error', errnoException('recvmsg'));
+ }
+ else {
+ rinfo.size = buf.length; // compatibility
+ self.emit('message', buf, rinfo);
+ }
+}
+
+
+// TODO share with net_uv and others
+function errnoException(errorno, syscall) {
+ var e = new Error(syscall + ' ' + errorno);
+ e.errno = e.code = errorno;
+ e.syscall = syscall;
+ return e;
+}
View
@@ -425,6 +425,9 @@
case 'timers':
return process.features.uv ? 'timers_uv' : 'timers_legacy';
+ case 'dgram':
+ return process.features.uv ? 'dgram_uv' : 'dgram_legacy';
+
case 'dns':
return process.features.uv ? 'dns_uv' : 'dns_legacy';
View
@@ -44,6 +44,7 @@ NODE_EXT_LIST_ITEM(node_os)
// libuv rewrite
NODE_EXT_LIST_ITEM(node_timer_wrap)
NODE_EXT_LIST_ITEM(node_tcp_wrap)
+NODE_EXT_LIST_ITEM(node_udp_wrap)
NODE_EXT_LIST_ITEM(node_pipe_wrap)
NODE_EXT_LIST_ITEM(node_cares_wrap)
NODE_EXT_LIST_ITEM(node_stdio_wrap)
Oops, something went wrong.

0 comments on commit cbd4033

Please sign in to comment.