text: // Copyright & License details are available under JXCORE_LICENSE file
  
  var assert = require('assert');
  var util = require('util');
  var events = require('events');
  
  var UDP = process.binding('udp_wrap').UDP;
  
  var BIND_STATE_UNBOUND = 0;
  var BIND_STATE_BINDING = 1;
  var BIND_STATE_BOUND = 2;
  
  // lazily loaded
  var cluster = null;
  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) {
    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');
  }
  
  exports._createSocketHandle = function(address, port, addressType, fd) {
    // Opening an existing fd is not supported for UDP handles.
    assert(typeof fd !== 'number' || fd < 0);
  
    var handle = newHandle(addressType);
  
    if (port || address) {
      var r = handle.bind(address, port || 0, 0);
      if (r == -1) {
        handle.close();
        handle = null;
      }
    }
  
    return handle;
  };
  
  function Socket(type, listener) {
    events.EventEmitter.call(this);
  
    var handle = newHandle(type);
    handle.owner = this;
  
    this._handle = handle;
    this._receiving = false;
    this._bindState = BIND_STATE_UNBOUND;
    this.type = type;
    this.fd = null; // compatibility hack
  
    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);
  };
  
  function startListening(socket) {
    socket._handle.onmessage = onMessage;
    // Todo: handle errors
    socket._handle.recvStart();
    socket._receiving = true;
    socket._bindState = BIND_STATE_BOUND;
    socket.fd = -42; // compatibility hack
  
    socket.emit('listening');
  }
  
  function replaceHandle(self, newHandle) {
  
    // Set up the handle that we got from master.
    newHandle.lookup = self._handle.lookup;
    newHandle.bind = self._handle.bind;
    newHandle.send = self._handle.send;
    newHandle.owner = self;
  
    // Replace the existing handle by the handle we got from master.
    self._handle.close();
    self._handle = newHandle;
  }
  
  Socket.prototype.bind = function(/* port, address, callback */) {
    var self = this;
  
    self._healthCheck();
  
    if (this._bindState != BIND_STATE_UNBOUND)
      throw new Error('Socket is already bound');
  
    this._bindState = BIND_STATE_BINDING;
  
    if (typeof arguments[arguments.length - 1] === 'function')
      self.once('listening', arguments[arguments.length - 1]);
  
    var UDP = process.binding('udp_wrap').UDP;
    if (arguments[0] instanceof UDP) {
      replaceHandle(self, arguments[0]);
      startListening(self);
      return;
    }
  
    var port = arguments[0];
    var address = arguments[1];
    if (typeof address === 'function') address = ''; // a.k.a. "any address"
  
    // resolve address first
    self._handle.lookup(address, function(err, ip) {
      if (err) {
        self._bindState = BIND_STATE_UNBOUND;
        self.emit('error', err);
        return;
      }
  
      if (!cluster) cluster = require('cluster');
  
      if (cluster.isWorker) {
        cluster._getServer(self, ip, port, self.type, -1, function(handle, err) {
          if (err) return self.emit('error', errnoException(err, 'bind'));
  
          if (!self._handle)
            // handle has been closed in the mean time.
            return handle.close();
  
          replaceHandle(self, handle);
          startListening(self);
        });
  
      } else {
        if (!self._handle) return; // handle has been closed in the mean time
  
        if (self._handle.bind(ip, port || 0, /* flags= */0)) {
          self.emit('error', errnoException(process._errno, 'bind'));
          self._bindState = BIND_STATE_UNBOUND;
          // Todo: close?
          return;
        }
  
        startListening(self);
      }
    });
  };
  
  // 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;
  
    if (!Buffer.isBuffer(buffer))
      throw new TypeError('First argument must be a buffer object.');
  
    offset = offset | 0;
    if (offset < 0) throw new RangeError('Offset should be >= 0');
  
    if (offset >= buffer.length)
      throw new RangeError('Offset into buffer too large');
  
    // Sending a zero-length datagram is kind of pointless but it _is_
    // allowed, hence check that length >= 0 rather than > 0.
    length = length | 0;
    if (length < 0) throw new RangeError('Length should be >= 0');
  
    if (offset + length > buffer.length)
      throw new RangeError('Offset + length beyond buffer length');
  
    port = port | 0;
    if (port <= 0 || port > 65535)
      throw new RangeError('Port should be > 0 and < 65536');
  
    callback = callback || noop;
  
    self._healthCheck();
  
    if (self._bindState == BIND_STATE_UNBOUND) self.bind(0, null);
  
    // If the socket hasn't been bound yet, push the outbound packet onto the
    // send queue and send after binding is complete.
    if (self._bindState != BIND_STATE_BOUND) {
      // If the send queue hasn't been initialized yet, do it, and install an
      // event handler that flushes the send queue after binding is done.
      if (!self._sendQueue) {
        self._sendQueue = [];
        self.once('listening', function() {
          // Flush the send queue.
          for (var i = 0; i < self._sendQueue.length; i++)
            self.send.apply(self, self._sendQueue[i]);
          self._sendQueue = undefined;
        });
      }
      self._sendQueue.push([buffer, offset, length, port, address, callback]);
      return;
    }
  
    self._handle.lookup(address, function(err, ip) {
      if (err) {
        if (callback) callback(err);
        self.emit('error', err);
      } else if (self._handle) {
        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
          var err = errnoException(process._errno, 'send');
          process.nextTick(function() {
            callback(err);
          });
        }
      }
    });
  };
  
  function afterSend(status, handle, req, buffer) {
    var self = handle.owner;
  
    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(process._errno, 'getsockname');
  
    return address;
  };
  
  Socket.prototype.setBroadcast = function(arg) {
    if (this._handle.setBroadcast((arg) ? 1 : 0)) {
      throw errnoException(process._errno, 'setBroadcast');
    }
  };
  
  Socket.prototype.setTTL = function(arg) {
    if (typeof arg !== 'number') {
      throw new TypeError('Argument must be a number');
    }
  
    if (this._handle.setTTL(arg)) {
      throw errnoException(process._errno, 'setTTL');
    }
  
    return arg;
  };
  
  Socket.prototype.setMulticastTTL = function(arg) {
    if (typeof arg !== 'number') {
      throw new TypeError('Argument must be a number');
    }
  
    if (this._handle.setMulticastTTL(arg)) {
      throw errnoException(process._errno, 'setMulticastTTL');
    }
  
    return arg;
  };
  
  Socket.prototype.setMulticastLoopback = function(arg) {
    arg = arg ? 1 : 0;
  
    if (this._handle.setMulticastLoopback(arg)) {
      throw errnoException(process._errno, 'setMulticastLoopback');
    }
  
    return arg; // 0.4 compatibility
  };
  
  Socket.prototype.addMembership = function(multicastAddress, interfaceAddress) {
    this._healthCheck();
  
    if (!multicastAddress) {
      throw new Error('multicast address must be specified');
    }
  
    if (this._handle.addMembership(multicastAddress, interfaceAddress)) {
      throw new errnoException(process._errno, 'addMembership');
    }
  };
  
  Socket.prototype.dropMembership = function(multicastAddress, interfaceAddress) {
    this._healthCheck();
  
    if (!multicastAddress) {
      throw new Error('multicast address must be specified');
    }
  
    if (this._handle.dropMembership(multicastAddress, interfaceAddress)) {
      throw new errnoException(process._errno, 'dropMembership');
    }
  };
  
  Socket.prototype._healthCheck = function() {
    if (!this._handle)
      throw new Error('Not running'); // error message from dgram_legacy.js
  };
  
  Socket.prototype._stopReceiving = function() {
    if (!this._receiving) return;
  
    this._handle.recvStop();
    this._receiving = false;
    this.fd = null; // compatibility hack
  };
  
  function onMessage(handle, slab, start, len, rinfo) {
    var self = handle.owner;
    if (!slab) {
      return self.emit('error', errnoException(process._errno, 'recvmsg'));
    }
    rinfo.size = len; // compatibility
    self.emit('message', slab.slice(start, start + len), rinfo);
  }
  
  Socket.prototype.ref = function() {
    if (this._handle) this._handle.ref();
  };
  
  Socket.prototype.unref = function() {
    if (this._handle) this._handle.unref();
  };
  
  // 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;
  }
  