From 9d6cd42767f62938904eb4f5ad3106145a762d5a Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Sun, 11 Jun 2017 22:57:29 +0100
Subject: [PATCH 01/13] doc: added docs for send/receive buffer sizes

setRecvBufferSize and setSendBufferSize
---
 doc/api/dgram.md | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/doc/api/dgram.md b/doc/api/dgram.md
index 3e77827a5e4b65..f1ea60491ce157 100644
--- a/doc/api/dgram.md
+++ b/doc/api/dgram.md
@@ -398,6 +398,26 @@ decremented to 0 by a router, it will not be forwarded.
 The argument passed to to `socket.setMulticastTTL()` is a number of hops
 between 0 and 255. The default on most systems is `1` but can vary.
 
+### socket.setRecvBufferSize(size)
+<!-- YAML
+added: vx.x.x
+-->
+
+* `size` {number} Integer
+
+Sets the `SO_RCVBUF` socket option. Sets the maximum socket receive buffer
+in bytes.
+
+### socket.setSendBufferSize(size)
+<!-- YAML
+added: vx.x.x
+-->
+
+* `size` {number} Integer
+
+Sets the `SO_SNDBUF` socket option. Sets the maximum socket send buffer
+in bytes.
+
 ### socket.setTTL(ttl)
 <!-- YAML
 added: v0.1.101

From b84bf9579f87ed17f3fbfdfb42e5232e5634cb11 Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Sun, 11 Jun 2017 22:58:53 +0100
Subject: [PATCH 02/13] dgram: support for setting socket buffer size

setRecvBufferSize(int) and setSendBufferSize(int)
---
 lib/dgram.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/lib/dgram.js b/lib/dgram.js
index 9e9806f5b06d91..38b0391689cd85 100644
--- a/lib/dgram.js
+++ b/lib/dgram.js
@@ -636,6 +636,25 @@ Socket.prototype.unref = function() {
   return this;
 };
 
+
+Socket.prototype.setRecvBufferSize = function(size) {
+  var err = this._handle.setRecvBufferSize(size);
+
+  if (err) {
+	throw errnoException(err, 'setRecvBufferSize');
+  }
+};
+
+
+Socket.prototype.setSendBufferSize = function(size) {
+  var err = this._handle.setSendBufferSize(size);
+
+  if (err) {
+    throw errnoException(err, 'setSendBufferSize');
+  }
+};
+
+
 module.exports = {
   _createSocketHandle,
   createSocket,

From 8aed7aa157bd14c1a071c454519cd65bcf646dee Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Sun, 11 Jun 2017 23:00:51 +0100
Subject: [PATCH 03/13] dgram: tests for setting socket buffer size

---
 .../test-dgram-set-socket-buffer-size.js      | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 test/parallel/test-dgram-set-socket-buffer-size.js

diff --git a/test/parallel/test-dgram-set-socket-buffer-size.js b/test/parallel/test-dgram-set-socket-buffer-size.js
new file mode 100644
index 00000000000000..4d9e0c6b84bd2b
--- /dev/null
+++ b/test/parallel/test-dgram-set-socket-buffer-size.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+{
+  // Should throw ENOTSOCK if the socket is never bound.
+  const socket = dgram.createSocket('udp4');
+
+  assert.throws(() => {
+    socket.setRecvBufferSize(8192);
+  }, /^Error: setRecvBufferSize ENOTSOCK$/);
+  
+    assert.throws(() => {
+    socket.setSendBufferSize(8192);
+  }, /^Error: setSendBufferSize ENOTSOCK$/);
+}
+
+{
+  // Can call setRecvBufferSize() and setRecvBufferSize() after binding the socket.
+  const socket = dgram.createSocket('udp4');
+
+  socket.bind(0, common.mustCall(() => {
+    socket.setRecvBufferSize(8192);
+    socket.setSendBufferSize(8192);
+    socket.close();
+  }));
+}
\ No newline at end of file

From f7c1aa66653a4407d714fec80a381372380d19c3 Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Sun, 11 Jun 2017 23:02:16 +0100
Subject: [PATCH 04/13] src: udp - support to set socket buffer sizes

---
 src/udp_wrap.cc | 30 ++++++++++++++++++++++++++++++
 src/udp_wrap.h  |  2 ++
 2 files changed, 32 insertions(+)

diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 37396602baac5b..876d94c14de3e5 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -222,6 +222,36 @@ void UDPWrap::Bind6(const FunctionCallbackInfo<Value>& args) {
 }
 
 
+void UDPWrap::SetRecvBufferSize(const FunctionCallbackInfo<Value>& args) {
+  UDPWrap* wrap;
+  ASSIGN_OR_RETURN_UNWRAP(&wrap,
+                          args.Holder(),
+                          args.GetReturnValue().Set(UV_EBADF));
+
+  CHECK(args[0]->IsUint32());
+
+  int inputSize = args[0]->Uint32Value();
+  int err = uv_recv_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_), &inputSize);
+  
+  args.GetReturnValue().Set(err);  
+}
+
+
+void UDPWrap::SetSendBufferSize(const FunctionCallbackInfo<Value>& args) {
+  UDPWrap* wrap;
+  ASSIGN_OR_RETURN_UNWRAP(&wrap,
+                          args.Holder(),
+                          args.GetReturnValue().Set(UV_EBADF));
+
+  CHECK(args[0]->IsUint32());
+  
+  int inputSize = args[0]->Uint32Value();
+  int err = uv_send_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_), &inputSize);
+  
+  args.GetReturnValue().Set(err);  
+}
+
+
 #define X(name, fn)                                                           \
   void UDPWrap::name(const FunctionCallbackInfo<Value>& args) {               \
     UDPWrap* wrap = Unwrap<UDPWrap>(args.Holder());                           \
diff --git a/src/udp_wrap.h b/src/udp_wrap.h
index c8913d5da2e107..3b4244ec4e7273 100644
--- a/src/udp_wrap.h
+++ b/src/udp_wrap.h
@@ -55,6 +55,8 @@ class UDPWrap: public HandleWrap {
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetBroadcast(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetTTL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetRecvBufferSize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetSendBufferSize(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static v8::Local<v8::Object> Instantiate(Environment* env, AsyncWrap* parent);
   uv_udp_t* UVHandle();

From a99ec11b21838803a7e4073aeebbeb992559a5e2 Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Sun, 11 Jun 2017 23:10:13 +0100
Subject: [PATCH 05/13] dgram: fixed indentation

---
 lib/dgram.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/dgram.js b/lib/dgram.js
index 38b0391689cd85..cc34a4e9953bfa 100644
--- a/lib/dgram.js
+++ b/lib/dgram.js
@@ -641,7 +641,7 @@ Socket.prototype.setRecvBufferSize = function(size) {
   var err = this._handle.setRecvBufferSize(size);
 
   if (err) {
-	throw errnoException(err, 'setRecvBufferSize');
+    throw errnoException(err, 'setRecvBufferSize');
   }
 };
 

From 2581c09c187575aee2ab5f98570ffa4b02129966 Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Mon, 12 Jun 2017 00:39:31 +0100
Subject: [PATCH 06/13] dgram: added method mapping

---
 src/udp_wrap.cc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 876d94c14de3e5..f5814e46c3aae8 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -134,6 +134,8 @@ void UDPWrap::Initialize(Local<Object> target,
   env->SetProtoMethod(t, "setMulticastLoopback", SetMulticastLoopback);
   env->SetProtoMethod(t, "setBroadcast", SetBroadcast);
   env->SetProtoMethod(t, "setTTL", SetTTL);
+  env->SetProtoMethod(t, "setRecvBufferSize", SetRecvBufferSize);
+  env->SetProtoMethod(t, "setSendBufferSize", SetSendBufferSize);
 
   env->SetProtoMethod(t, "ref", HandleWrap::Ref);
   env->SetProtoMethod(t, "unref", HandleWrap::Unref);

From b0ac4ff3cf47f6cdfc90fbe22362dfcb3b612f0e Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Mon, 12 Jun 2017 01:17:01 +0100
Subject: [PATCH 07/13] dgram: fixed test for os independence. fixed docs

---
 doc/api/dgram.md                                   | 4 ++--
 test/parallel/test-dgram-set-socket-buffer-size.js | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/doc/api/dgram.md b/doc/api/dgram.md
index f1ea60491ce157..908457ebfa377e 100644
--- a/doc/api/dgram.md
+++ b/doc/api/dgram.md
@@ -400,7 +400,7 @@ between 0 and 255. The default on most systems is `1` but can vary.
 
 ### socket.setRecvBufferSize(size)
 <!-- YAML
-added: vx.x.x
+added: REPLACEME
 -->
 
 * `size` {number} Integer
@@ -410,7 +410,7 @@ in bytes.
 
 ### socket.setSendBufferSize(size)
 <!-- YAML
-added: vx.x.x
+added: REPLACEME
 -->
 
 * `size` {number} Integer
diff --git a/test/parallel/test-dgram-set-socket-buffer-size.js b/test/parallel/test-dgram-set-socket-buffer-size.js
index 4d9e0c6b84bd2b..877d915018df5d 100644
--- a/test/parallel/test-dgram-set-socket-buffer-size.js
+++ b/test/parallel/test-dgram-set-socket-buffer-size.js
@@ -5,16 +5,16 @@ const assert = require('assert');
 const dgram = require('dgram');
 
 {
-  // Should throw ENOTSOCK if the socket is never bound.
+  // Should throw error if the socket is never bound.
   const socket = dgram.createSocket('udp4');
 
   assert.throws(() => {
     socket.setRecvBufferSize(8192);
-  }, /^Error: setRecvBufferSize ENOTSOCK$/);
+  }, /^Error: setRecvBufferSize E[A-Z]+$/);
   
     assert.throws(() => {
     socket.setSendBufferSize(8192);
-  }, /^Error: setSendBufferSize ENOTSOCK$/);
+  }, /^Error: setSendBufferSize E[A-Z]+$/);
 }
 
 {
@@ -26,4 +26,4 @@ const dgram = require('dgram');
     socket.setSendBufferSize(8192);
     socket.close();
   }));
-}
\ No newline at end of file
+}

From f6bf7f248e558ec49cddef9f440498c558a6574a Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Mon, 12 Jun 2017 21:40:33 +0100
Subject: [PATCH 08/13] dgram: fixed syntax, added options support

Docs updated. Added options support to set buffer sizes in
dgram.createSocket().
---
 doc/api/dgram.md                              |  5 ++
 lib/dgram.js                                  | 40 ++++++++++++---
 lib/internal/errors.js                        |  2 +
 src/udp_wrap.cc                               | 21 ++++----
 .../test-dgram-set-socket-buffer-size.js      | 50 +++++++++++++++++--
 5 files changed, 100 insertions(+), 18 deletions(-)

diff --git a/doc/api/dgram.md b/doc/api/dgram.md
index 908457ebfa377e..a5a1d5525825f9 100644
--- a/doc/api/dgram.md
+++ b/doc/api/dgram.md
@@ -481,6 +481,9 @@ changes:
   - version: REPLACEME
     pr-url: https://github.com/nodejs/node/pull/14560
     description: The `lookup` option is supported.
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/13623
+    description: `recvBufferSize` and `sendBufferSize` options are supported now.
 -->
 
 * `options` {Object} Available options are:
@@ -489,6 +492,8 @@ changes:
   * `reuseAddr` {boolean} When `true` [`socket.bind()`][] will reuse the
     address, even if another process has already bound a socket on it. Optional.
     Defaults to `false`.
+  * `recvBufferSize` {number} - Optional. Sets the `SO_RCVBUF` socket value.
+  * `sendBufferSize` {number} - Optional. Sets the `SO_SNDBUF` socket value.
   * `lookup` {Function} Custom lookup function. Defaults to [`dns.lookup()`][].
     Optional.
 * `callback` {Function} Attached as a listener for `'message'` events. Optional.
diff --git a/lib/dgram.js b/lib/dgram.js
index cc34a4e9953bfa..c03e2970272ce5 100644
--- a/lib/dgram.js
+++ b/lib/dgram.js
@@ -30,6 +30,7 @@ const EventEmitter = require('events');
 const setInitTriggerId = require('async_hooks').setInitTriggerId;
 const UV_UDP_REUSEADDR = process.binding('constants').os.UV_UDP_REUSEADDR;
 const async_id_symbol = process.binding('async_wrap').async_id_symbol;
+const uv = process.binding('uv');
 const nextTick = require('internal/process/next_tick').nextTick;
 
 const UDP = process.binding('udp_wrap').UDP;
@@ -121,6 +122,12 @@ function Socket(type, listener) {
 
   // If true - UV_UDP_REUSEADDR flag will be set
   this._reuseAddr = options && options.reuseAddr;
+  
+  if (options && options.recvBufferSize)
+    this._recvBufferSize = options.recvBufferSize;
+
+  if (options && options.sendBufferSize)
+    this._sendBufferSize = options.sendBufferSize;
 
   if (typeof listener === 'function')
     this.on('message', listener);
@@ -140,6 +147,12 @@ function startListening(socket) {
   socket._receiving = true;
   socket._bindState = BIND_STATE_BOUND;
   socket.fd = -42; // compatibility hack
+  
+  if (socket._recvBufferSize)
+    socket.setRecvBufferSize(socket._recvBufferSize);
+
+  if (socket._sendBufferSize)
+    socket.setSendBufferSize(socket._sendBufferSize);
 
   socket.emit('listening');
 }
@@ -327,6 +340,14 @@ function enqueue(self, toEnqueue) {
 }
 
 
+function isValidSize(size) {
+  return Number.isFinite(size) &&
+          size <= Number.MAX_SAFE_INTEGER &&
+          size >= 0 &&
+          size >>> 0 === size;
+}
+
+
 function onListenSuccess() {
   this.removeListener('error', onListenError);
   clearQueue.call(this);
@@ -638,20 +659,27 @@ Socket.prototype.unref = function() {
 
 
 Socket.prototype.setRecvBufferSize = function(size) {
+  if (!isValidSize(size))
+    throw new errors.TypeError('ERR_SOCKET_BAD_BUFFER_SIZE');
+
   var err = this._handle.setRecvBufferSize(size);
 
-  if (err) {
-    throw errnoException(err, 'setRecvBufferSize');
-  }
+  if (err)
+    throw new errors.TypeError('ERR_SOCKET_SET_BUFFER_SIZE',
+                               uv.errname(err));
+
 };
 
 
 Socket.prototype.setSendBufferSize = function(size) {
+  if (!isValidSize(size))
+    throw new errors.TypeError('ERR_SOCKET_BAD_BUFFER_SIZE');
+
   var err = this._handle.setSendBufferSize(size);
 
-  if (err) {
-    throw errnoException(err, 'setSendBufferSize');
-  }
+  if (err)
+    throw new errors.TypeError('ERR_SOCKET_SET_BUFFER_SIZE', 
+                               uv.errname(err));
 };
 
 
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 10e5be8a44056d..7d00b9e48545e1 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -245,11 +245,13 @@ E('ERR_SERVER_ALREADY_LISTEN',
   'Listen method has been called more than once without closing.');
 E('ERR_SOCKET_ALREADY_BOUND', 'Socket is already bound');
 E('ERR_SOCKET_BAD_PORT', 'Port should be > 0 and < 65536');
+E('ERR_SOCKET_BAD_BUFFER_SIZE', 'Buffer size must be a positive integer');
 E('ERR_SOCKET_BAD_TYPE',
   'Bad socket type specified. Valid types are: udp4, udp6');
 E('ERR_SOCKET_CANNOT_SEND', 'Unable to send data');
 E('ERR_SOCKET_CLOSED', 'Socket is closed');
 E('ERR_SOCKET_DGRAM_NOT_RUNNING', 'Not running');
+E('ERR_SOCKET_SET_BUFFER_SIZE', (reason) => `Coud not set buffer size: ${reason}`);
 E('ERR_STDERR_CLOSE', 'process.stderr cannot be closed');
 E('ERR_STDOUT_CLOSE', 'process.stdout cannot be closed');
 E('ERR_STREAM_WRAP', 'Stream has StringDecoder set or is in objectMode');
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index f5814e46c3aae8..58291f96f8cec6 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -46,6 +46,7 @@ using v8::Object;
 using v8::PropertyAttribute;
 using v8::PropertyCallbackInfo;
 using v8::String;
+using v8::Uint32;
 using v8::Undefined;
 using v8::Value;
 
@@ -225,32 +226,34 @@ void UDPWrap::Bind6(const FunctionCallbackInfo<Value>& args) {
 
 
 void UDPWrap::SetRecvBufferSize(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
   UDPWrap* wrap;
   ASSIGN_OR_RETURN_UNWRAP(&wrap,
                           args.Holder(),
                           args.GetReturnValue().Set(UV_EBADF));
 
   CHECK(args[0]->IsUint32());
+  int size =  (int)args[0].As<Uint32>()->Value();
+  int err = uv_recv_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_),
+                                &size);
 
-  int inputSize = args[0]->Uint32Value();
-  int err = uv_recv_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_), &inputSize);
-  
-  args.GetReturnValue().Set(err);  
+  args.GetReturnValue().Set(err);
 }
 
 
 void UDPWrap::SetSendBufferSize(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
   UDPWrap* wrap;
   ASSIGN_OR_RETURN_UNWRAP(&wrap,
                           args.Holder(),
                           args.GetReturnValue().Set(UV_EBADF));
 
   CHECK(args[0]->IsUint32());
-  
-  int inputSize = args[0]->Uint32Value();
-  int err = uv_send_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_), &inputSize);
-  
-  args.GetReturnValue().Set(err);  
+  int size =  (int)args[0].As<Uint32>()->Value();
+  int err = uv_send_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_),
+                                &size);
+
+  args.GetReturnValue().Set(err);
 }
 
 
diff --git a/test/parallel/test-dgram-set-socket-buffer-size.js b/test/parallel/test-dgram-set-socket-buffer-size.js
index 877d915018df5d..74fcf9b1183f43 100644
--- a/test/parallel/test-dgram-set-socket-buffer-size.js
+++ b/test/parallel/test-dgram-set-socket-buffer-size.js
@@ -10,11 +10,55 @@ const dgram = require('dgram');
 
   assert.throws(() => {
     socket.setRecvBufferSize(8192);
-  }, /^Error: setRecvBufferSize E[A-Z]+$/);
+  }, common.expectsError({
+    code: 'ERR_SOCKET_SET_BUFFER_SIZE',
+    type: Error,
+    message: /^Coud not set buffer size: E[A-Z]+$/
+  }));
+
+  assert.throws(() => {
+    socket.setSendBufferSize(8192);
+  }, common.expectsError({
+    code: 'ERR_SOCKET_SET_BUFFER_SIZE',
+    type: Error,
+    message: /^Coud not set buffer size: E[A-Z]+$/
+  }));
+  
   
+}
+
+{
+  // Should throw error if invalid buffer size is specified
+  const socket = dgram.createSocket('udp4');
+
+  socket.bind(0, common.mustCall(() => {
+
     assert.throws(() => {
-    socket.setSendBufferSize(8192);
-  }, /^Error: setSendBufferSize E[A-Z]+$/);
+      socket.setRecvBufferSize(-1);
+    }, common.expectsError({
+      code: 'ERR_SOCKET_BAD_BUFFER_SIZE',
+      type: Error,
+      message: /^Buffer size must be a positive integer$/
+    }));
+
+    assert.throws(() => {
+      socket.setRecvBufferSize(Infinity);
+    }, common.expectsError({
+      code: 'ERR_SOCKET_BAD_BUFFER_SIZE',
+      type: Error,
+      message: /^Buffer size must be a positive integer$/
+    }));
+
+    assert.throws(() => {
+      socket.setRecvBufferSize('Doh!');
+    }, common.expectsError({
+      code: 'ERR_SOCKET_BAD_BUFFER_SIZE',
+      type: Error,
+      message: /^Buffer size must be a positive integer$/
+    }));
+
+    socket.close();
+  }));
 }
 
 {

From d5789c0a46da8412774e56517a69ddf919a10f3a Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Wed, 14 Jun 2017 14:45:27 +0100
Subject: [PATCH 09/13] dgram: add support to get buffer sizes

---
 doc/api/dgram.md                              | 15 +++++
 lib/dgram.js                                  | 63 ++++++++++---------
 lib/internal/errors.js                        |  2 +-
 src/udp_wrap.cc                               | 41 ++++++------
 src/udp_wrap.h                                |  3 +-
 test/parallel/test-dgram-createSocket-type.js | 19 ++++++
 ...ze.js => test-dgram-socket-buffer-size.js} | 45 +++++++++----
 7 files changed, 122 insertions(+), 66 deletions(-)
 rename test/parallel/{test-dgram-set-socket-buffer-size.js => test-dgram-socket-buffer-size.js} (54%)

diff --git a/doc/api/dgram.md b/doc/api/dgram.md
index a5a1d5525825f9..66ab9b635d2397 100644
--- a/doc/api/dgram.md
+++ b/doc/api/dgram.md
@@ -227,6 +227,20 @@ never have reason to call this.
 If `multicastInterface` is not specified, the operating system will attempt to
 drop membership on all valid interfaces.
 
+### socket.getRecvBufferSize(size)
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns {number} the `SO_RCVBUF` socket receive buffer size in bytes.
+
+### socket.getSendBufferSize(size)
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns {number} the `SO_SNDBUF` socket send buffer size in bytes.
+
 ### socket.ref()
 <!-- YAML
 added: v0.9.1
@@ -478,6 +492,7 @@ s.bind(1234, () => {
 <!-- YAML
 added: v0.11.13
 changes:
+<<<<<<< f6bf7f248e558ec49cddef9f440498c558a6574a
   - version: REPLACEME
     pr-url: https://github.com/nodejs/node/pull/14560
     description: The `lookup` option is supported.
diff --git a/lib/dgram.js b/lib/dgram.js
index c03e2970272ce5..b51bbee8c1987e 100644
--- a/lib/dgram.js
+++ b/lib/dgram.js
@@ -30,7 +30,6 @@ const EventEmitter = require('events');
 const setInitTriggerId = require('async_hooks').setInitTriggerId;
 const UV_UDP_REUSEADDR = process.binding('constants').os.UV_UDP_REUSEADDR;
 const async_id_symbol = process.binding('async_wrap').async_id_symbol;
-const uv = process.binding('uv');
 const nextTick = require('internal/process/next_tick').nextTick;
 
 const UDP = process.binding('udp_wrap').UDP;
@@ -99,15 +98,19 @@ function _createSocketHandle(address, port, addressType, fd, flags) {
   return handle;
 }
 
+const kOptionSymbol = Symbol('options symbol');
 
 function Socket(type, listener) {
   EventEmitter.call(this);
   var lookup;
 
+  this[kOptionSymbol] = {};
   if (type !== null && typeof type === 'object') {
     var options = type;
     type = options.type;
     lookup = options.lookup;
+    this[kOptionSymbol].recvBufferSize = options.recvBufferSize;
+    this[kOptionSymbol].sendBufferSize = options.sendBufferSize;
   }
 
   var handle = newHandle(type, lookup);
@@ -122,12 +125,6 @@ function Socket(type, listener) {
 
   // If true - UV_UDP_REUSEADDR flag will be set
   this._reuseAddr = options && options.reuseAddr;
-  
-  if (options && options.recvBufferSize)
-    this._recvBufferSize = options.recvBufferSize;
-
-  if (options && options.sendBufferSize)
-    this._sendBufferSize = options.sendBufferSize;
 
   if (typeof listener === 'function')
     this.on('message', listener);
@@ -147,12 +144,12 @@ function startListening(socket) {
   socket._receiving = true;
   socket._bindState = BIND_STATE_BOUND;
   socket.fd = -42; // compatibility hack
-  
-  if (socket._recvBufferSize)
-    socket.setRecvBufferSize(socket._recvBufferSize);
 
-  if (socket._sendBufferSize)
-    socket.setSendBufferSize(socket._sendBufferSize);
+  if (socket[kOptionSymbol].recvBufferSize)
+    bufferSize(socket, socket[kOptionSymbol].recvBufferSize, 'recv');
+
+  if (socket[kOptionSymbol].sendBufferSize)
+    bufferSize(socket, socket[kOptionSymbol].sendBufferSize, 'send');
 
   socket.emit('listening');
 }
@@ -170,6 +167,20 @@ function replaceHandle(self, newHandle) {
   self._handle = newHandle;
 }
 
+function bufferSize(self, size, buffer) {
+  if (!isValidSize(size))
+    throw new errors.TypeError('ERR_SOCKET_BAD_BUFFER_SIZE');
+
+  try {
+    if (buffer === 'recv')
+      return self._handle.bufferSize(size, 0);
+    else
+      return self._handle.bufferSize(size, 1);
+  } catch (e) {
+    throw new errors.Error('ERR_SOCKET_BUFFER_SIZE', e);
+  }
+}
+
 Socket.prototype.bind = function(port_, address_ /*, callback*/) {
   let port = port_;
 
@@ -341,10 +352,7 @@ function enqueue(self, toEnqueue) {
 
 
 function isValidSize(size) {
-  return Number.isFinite(size) &&
-          size <= Number.MAX_SAFE_INTEGER &&
-          size >= 0 &&
-          size >>> 0 === size;
+  return size >>> 0 === size;
 }
 
 
@@ -659,27 +667,22 @@ Socket.prototype.unref = function() {
 
 
 Socket.prototype.setRecvBufferSize = function(size) {
-  if (!isValidSize(size))
-    throw new errors.TypeError('ERR_SOCKET_BAD_BUFFER_SIZE');
-
-  var err = this._handle.setRecvBufferSize(size);
+  bufferSize(this, size, 'recv');
+};
 
-  if (err)
-    throw new errors.TypeError('ERR_SOCKET_SET_BUFFER_SIZE',
-                               uv.errname(err));
 
+Socket.prototype.setSendBufferSize = function(size) {
+  bufferSize(this, size, 'send');
 };
 
 
-Socket.prototype.setSendBufferSize = function(size) {
-  if (!isValidSize(size))
-    throw new errors.TypeError('ERR_SOCKET_BAD_BUFFER_SIZE');
+Socket.prototype.getRecvBufferSize = function() {
+  return bufferSize(this, 0, 'recv');
+};
 
-  var err = this._handle.setSendBufferSize(size);
 
-  if (err)
-    throw new errors.TypeError('ERR_SOCKET_SET_BUFFER_SIZE', 
-                               uv.errname(err));
+Socket.prototype.getSendBufferSize = function() {
+  return bufferSize(this, 0, 'send');
 };
 
 
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 7d00b9e48545e1..041e51b1eedcf8 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -251,7 +251,7 @@ E('ERR_SOCKET_BAD_TYPE',
 E('ERR_SOCKET_CANNOT_SEND', 'Unable to send data');
 E('ERR_SOCKET_CLOSED', 'Socket is closed');
 E('ERR_SOCKET_DGRAM_NOT_RUNNING', 'Not running');
-E('ERR_SOCKET_SET_BUFFER_SIZE', (reason) => `Coud not set buffer size: ${reason}`);
+E('ERR_SOCKET_BUFFER_SIZE', (reason) => `Could not get or set buffer size: ${reason}`);
 E('ERR_STDERR_CLOSE', 'process.stderr cannot be closed');
 E('ERR_STDOUT_CLOSE', 'process.stdout cannot be closed');
 E('ERR_STREAM_WRAP', 'Stream has StringDecoder set or is in objectMode');
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 58291f96f8cec6..01dfec6e13b69f 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -135,8 +135,7 @@ void UDPWrap::Initialize(Local<Object> target,
   env->SetProtoMethod(t, "setMulticastLoopback", SetMulticastLoopback);
   env->SetProtoMethod(t, "setBroadcast", SetBroadcast);
   env->SetProtoMethod(t, "setTTL", SetTTL);
-  env->SetProtoMethod(t, "setRecvBufferSize", SetRecvBufferSize);
-  env->SetProtoMethod(t, "setSendBufferSize", SetSendBufferSize);
+  env->SetProtoMethod(t, "bufferSize", BufferSize);
 
   env->SetProtoMethod(t, "ref", HandleWrap::Ref);
   env->SetProtoMethod(t, "unref", HandleWrap::Unref);
@@ -225,7 +224,7 @@ void UDPWrap::Bind6(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void UDPWrap::SetRecvBufferSize(const FunctionCallbackInfo<Value>& args) {
+void UDPWrap::BufferSize(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   UDPWrap* wrap;
   ASSIGN_OR_RETURN_UNWRAP(&wrap,
@@ -233,27 +232,27 @@ void UDPWrap::SetRecvBufferSize(const FunctionCallbackInfo<Value>& args) {
                           args.GetReturnValue().Set(UV_EBADF));
 
   CHECK(args[0]->IsUint32());
-  int size =  (int)args[0].As<Uint32>()->Value();
-  int err = uv_recv_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_),
+  CHECK(args[1]->IsUint32());
+  int size = (int)args[0].As<Uint32>()->Value();
+  
+  int err = 0;
+  if (args[1].As<Uint32>()->Value() == 0)
+    err = uv_recv_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_),
                                 &size);
-
-  args.GetReturnValue().Set(err);
-}
-
-
-void UDPWrap::SetSendBufferSize(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  UDPWrap* wrap;
-  ASSIGN_OR_RETURN_UNWRAP(&wrap,
-                          args.Holder(),
-                          args.GetReturnValue().Set(UV_EBADF));
-
-  CHECK(args[0]->IsUint32());
-  int size =  (int)args[0].As<Uint32>()->Value();
-  int err = uv_send_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_),
+  else
+    err = uv_send_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_),
                                 &size);
 
-  args.GetReturnValue().Set(err);
+  if (err != 0) {
+    std::string syscall;
+    if (args[1].As<Uint32>()->Value() == 0)
+      syscall = "uv_recv_buffer_size";
+    else
+      syscall = "uv_send_buffer_size";
+
+    return env->ThrowUVException(err, syscall.c_str());
+  }
+  args.GetReturnValue().Set(size);
 }
 
 
diff --git a/src/udp_wrap.h b/src/udp_wrap.h
index 3b4244ec4e7273..36f670a2e15edf 100644
--- a/src/udp_wrap.h
+++ b/src/udp_wrap.h
@@ -55,8 +55,7 @@ class UDPWrap: public HandleWrap {
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetBroadcast(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetTTL(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetRecvBufferSize(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetSendBufferSize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void BufferSize(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static v8::Local<v8::Object> Instantiate(Environment* env, AsyncWrap* parent);
   uv_udp_t* UVHandle();
diff --git a/test/parallel/test-dgram-createSocket-type.js b/test/parallel/test-dgram-createSocket-type.js
index 96e3d6c8673d16..e87995756658a8 100644
--- a/test/parallel/test-dgram-createSocket-type.js
+++ b/test/parallel/test-dgram-createSocket-type.js
@@ -39,3 +39,22 @@ validTypes.forEach((validType) => {
     socket.close();
   });
 });
+
+// Ensure buffer sizes can be set
+{
+  const socket = dgram.createSocket({ type: 'udp4',
+                                      recvBufferSize: 1300,
+                                      sendBufferSize: 1800,
+                                    });
+
+  socket.bind(common.mustCall(() => {
+    // note: linux will double the buffer size
+    assert.ok(socket.getRecvBufferSize() === 1300 ||
+              socket.getRecvBufferSize() === 2600,
+              "SO_RCVBUF not 1300 or 2600");
+    assert.ok(socket.getSendBufferSize() === 1800 ||
+              socket.getSendBufferSize() === 3600,
+              "SO_SNDVBUF not 1800 or 3600");
+    socket.close();
+  }));
+}
diff --git a/test/parallel/test-dgram-set-socket-buffer-size.js b/test/parallel/test-dgram-socket-buffer-size.js
similarity index 54%
rename from test/parallel/test-dgram-set-socket-buffer-size.js
rename to test/parallel/test-dgram-socket-buffer-size.js
index 74fcf9b1183f43..9689554f87bd0f 100644
--- a/test/parallel/test-dgram-set-socket-buffer-size.js
+++ b/test/parallel/test-dgram-socket-buffer-size.js
@@ -11,28 +11,41 @@ const dgram = require('dgram');
   assert.throws(() => {
     socket.setRecvBufferSize(8192);
   }, common.expectsError({
-    code: 'ERR_SOCKET_SET_BUFFER_SIZE',
+    code: 'ERR_SOCKET_BUFFER_SIZE',
     type: Error,
-    message: /^Coud not set buffer size: E[A-Z]+$/
+    message: /^Could not get or set buffer size:.*$/
   }));
 
   assert.throws(() => {
     socket.setSendBufferSize(8192);
   }, common.expectsError({
-    code: 'ERR_SOCKET_SET_BUFFER_SIZE',
+    code: 'ERR_SOCKET_BUFFER_SIZE',
     type: Error,
-    message: /^Coud not set buffer size: E[A-Z]+$/
+    message: /^Could not get or set buffer size:.*$/
+  }));
+
+  assert.throws(() => {
+    socket.getRecvBufferSize();
+  }, common.expectsError({
+    code: 'ERR_SOCKET_BUFFER_SIZE',
+    type: Error,
+    message: /^Could not get or set buffer size:.*$/
+  }));
+
+  assert.throws(() => {
+    socket.getSendBufferSize();
+  }, common.expectsError({
+    code: 'ERR_SOCKET_BUFFER_SIZE',
+    type: Error,
+    message: /^Could not get or set buffer size:.*$/
   }));
-  
-  
 }
 
 {
   // Should throw error if invalid buffer size is specified
   const socket = dgram.createSocket('udp4');
 
-  socket.bind(0, common.mustCall(() => {
-
+  socket.bind(common.mustCall(() => {
     assert.throws(() => {
       socket.setRecvBufferSize(-1);
     }, common.expectsError({
@@ -61,13 +74,21 @@ const dgram = require('dgram');
   }));
 }
 
+  // Can set and get buffer sizes after binding the socket.
 {
-  // Can call setRecvBufferSize() and setRecvBufferSize() after binding the socket.
   const socket = dgram.createSocket('udp4');
 
-  socket.bind(0, common.mustCall(() => {
-    socket.setRecvBufferSize(8192);
-    socket.setSendBufferSize(8192);
+  socket.bind(common.mustCall(() => {
+    socket.setRecvBufferSize(1200);
+    socket.setSendBufferSize(1500);
+
+    // note: linux will double the buffer size
+    assert.ok(socket.getRecvBufferSize() === 1200 ||
+              socket.getRecvBufferSize() === 2400,
+              "SO_RCVBUF not 1200 or 2400");
+    assert.ok(socket.getSendBufferSize() === 1500 ||
+              socket.getSendBufferSize() === 3000,
+              "SO_SNDVBUF not 1500 or 3000");
     socket.close();
   }));
 }

From cd79a589bdfaa37647f7fdc88210141ee2ed4dbc Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Wed, 14 Jun 2017 16:19:55 +0100
Subject: [PATCH 10/13] dgram: fixed typos in tests and docs

---
 doc/api/dgram.md                               | 1 -
 test/parallel/test-dgram-createSocket-type.js  | 2 +-
 test/parallel/test-dgram-socket-buffer-size.js | 2 +-
 3 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/doc/api/dgram.md b/doc/api/dgram.md
index 66ab9b635d2397..38675223e9991e 100644
--- a/doc/api/dgram.md
+++ b/doc/api/dgram.md
@@ -492,7 +492,6 @@ s.bind(1234, () => {
 <!-- YAML
 added: v0.11.13
 changes:
-<<<<<<< f6bf7f248e558ec49cddef9f440498c558a6574a
   - version: REPLACEME
     pr-url: https://github.com/nodejs/node/pull/14560
     description: The `lookup` option is supported.
diff --git a/test/parallel/test-dgram-createSocket-type.js b/test/parallel/test-dgram-createSocket-type.js
index e87995756658a8..bf656d67cacaff 100644
--- a/test/parallel/test-dgram-createSocket-type.js
+++ b/test/parallel/test-dgram-createSocket-type.js
@@ -54,7 +54,7 @@ validTypes.forEach((validType) => {
               "SO_RCVBUF not 1300 or 2600");
     assert.ok(socket.getSendBufferSize() === 1800 ||
               socket.getSendBufferSize() === 3600,
-              "SO_SNDVBUF not 1800 or 3600");
+              "SO_SNDBUF not 1800 or 3600");
     socket.close();
   }));
 }
diff --git a/test/parallel/test-dgram-socket-buffer-size.js b/test/parallel/test-dgram-socket-buffer-size.js
index 9689554f87bd0f..698c17dd4bdbc5 100644
--- a/test/parallel/test-dgram-socket-buffer-size.js
+++ b/test/parallel/test-dgram-socket-buffer-size.js
@@ -88,7 +88,7 @@ const dgram = require('dgram');
               "SO_RCVBUF not 1200 or 2400");
     assert.ok(socket.getSendBufferSize() === 1500 ||
               socket.getSendBufferSize() === 3000,
-              "SO_SNDVBUF not 1500 or 3000");
+              "SO_SNDBUF not 1500 or 3000");
     socket.close();
   }));
 }

From de458d1e824c1eb6e281ce23093b747c8442d04e Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Wed, 14 Jun 2017 21:25:02 +0100
Subject: [PATCH 11/13] dgram: lint errors and other pr comments

---
 lib/dgram.js                                  |  7 +--
 lib/internal/errors.js                        |  3 +-
 src/udp_wrap.cc                               | 17 +++---
 test/parallel/test-dgram-createSocket-type.js | 13 ++--
 .../parallel/test-dgram-socket-buffer-size.js | 60 +++++++------------
 5 files changed, 39 insertions(+), 61 deletions(-)

diff --git a/lib/dgram.js b/lib/dgram.js
index b51bbee8c1987e..fa2f476096d993 100644
--- a/lib/dgram.js
+++ b/lib/dgram.js
@@ -168,7 +168,7 @@ function replaceHandle(self, newHandle) {
 }
 
 function bufferSize(self, size, buffer) {
-  if (!isValidSize(size))
+  if (size >>> 0 !== size)
     throw new errors.TypeError('ERR_SOCKET_BAD_BUFFER_SIZE');
 
   try {
@@ -351,11 +351,6 @@ function enqueue(self, toEnqueue) {
 }
 
 
-function isValidSize(size) {
-  return size >>> 0 === size;
-}
-
-
 function onListenSuccess() {
   this.removeListener('error', onListenError);
   clearQueue.call(this);
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 041e51b1eedcf8..847f0bff656f0e 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -251,7 +251,8 @@ E('ERR_SOCKET_BAD_TYPE',
 E('ERR_SOCKET_CANNOT_SEND', 'Unable to send data');
 E('ERR_SOCKET_CLOSED', 'Socket is closed');
 E('ERR_SOCKET_DGRAM_NOT_RUNNING', 'Not running');
-E('ERR_SOCKET_BUFFER_SIZE', (reason) => `Could not get or set buffer size: ${reason}`);
+E('ERR_SOCKET_BUFFER_SIZE',
+  (reason) => `Could not get or set buffer size: ${reason}`);
 E('ERR_STDERR_CLOSE', 'process.stderr cannot be closed');
 E('ERR_STDOUT_CLOSE', 'process.stdout cannot be closed');
 E('ERR_STREAM_WRAP', 'Stream has StringDecoder set or is in objectMode');
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 01dfec6e13b69f..58ffbacb05b6ea 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -233,24 +233,21 @@ void UDPWrap::BufferSize(const FunctionCallbackInfo<Value>& args) {
 
   CHECK(args[0]->IsUint32());
   CHECK(args[1]->IsUint32());
-  int size = (int)args[0].As<Uint32>()->Value();
-  
-  int err = 0;
+  int size = static_cast<int>(args[0].As<Uint32>()->Value());
+
+  int err;
   if (args[1].As<Uint32>()->Value() == 0)
     err = uv_recv_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_),
-                                &size);
+                              &size);
   else
     err = uv_send_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_),
-                                &size);
+                              &size);
 
   if (err != 0) {
-    std::string syscall;
     if (args[1].As<Uint32>()->Value() == 0)
-      syscall = "uv_recv_buffer_size";
+      return env->ThrowUVException(err, "uv_recv_buffer_size");
     else
-      syscall = "uv_send_buffer_size";
-
-    return env->ThrowUVException(err, syscall.c_str());
+      return env->ThrowUVException(err, "uv_send_buffer_size");
   }
   args.GetReturnValue().Set(size);
 }
diff --git a/test/parallel/test-dgram-createSocket-type.js b/test/parallel/test-dgram-createSocket-type.js
index bf656d67cacaff..4ab4205f8bef05 100644
--- a/test/parallel/test-dgram-createSocket-type.js
+++ b/test/parallel/test-dgram-createSocket-type.js
@@ -42,19 +42,20 @@ validTypes.forEach((validType) => {
 
 // Ensure buffer sizes can be set
 {
-  const socket = dgram.createSocket({ type: 'udp4',
-                                      recvBufferSize: 1300,
-                                      sendBufferSize: 1800,
-                                    });
+  const socket = dgram.createSocket({
+    type: 'udp4',
+    recvBufferSize: 1300,
+    sendBufferSize: 1800
+  });
 
   socket.bind(common.mustCall(() => {
     // note: linux will double the buffer size
     assert.ok(socket.getRecvBufferSize() === 1300 ||
               socket.getRecvBufferSize() === 2600,
-              "SO_RCVBUF not 1300 or 2600");
+              'SO_RCVBUF not 1300 or 2600');
     assert.ok(socket.getSendBufferSize() === 1800 ||
               socket.getSendBufferSize() === 3600,
-              "SO_SNDBUF not 1800 or 3600");
+              'SO_SNDBUF not 1800 or 3600');
     socket.close();
   }));
 }
diff --git a/test/parallel/test-dgram-socket-buffer-size.js b/test/parallel/test-dgram-socket-buffer-size.js
index 698c17dd4bdbc5..701cb6f09bb142 100644
--- a/test/parallel/test-dgram-socket-buffer-size.js
+++ b/test/parallel/test-dgram-socket-buffer-size.js
@@ -6,76 +6,60 @@ const dgram = require('dgram');
 
 {
   // Should throw error if the socket is never bound.
+  const errorObj = {
+    code: 'ERR_SOCKET_BUFFER_SIZE',
+    type: Error,
+    message: /^Could not get or set buffer size:.*$/
+  };
+
   const socket = dgram.createSocket('udp4');
 
   assert.throws(() => {
     socket.setRecvBufferSize(8192);
-  }, common.expectsError({
-    code: 'ERR_SOCKET_BUFFER_SIZE',
-    type: Error,
-    message: /^Could not get or set buffer size:.*$/
-  }));
+  }, common.expectsError(errorObj));
 
   assert.throws(() => {
     socket.setSendBufferSize(8192);
-  }, common.expectsError({
-    code: 'ERR_SOCKET_BUFFER_SIZE',
-    type: Error,
-    message: /^Could not get or set buffer size:.*$/
-  }));
+  }, common.expectsError(errorObj));
 
   assert.throws(() => {
     socket.getRecvBufferSize();
-  }, common.expectsError({
-    code: 'ERR_SOCKET_BUFFER_SIZE',
-    type: Error,
-    message: /^Could not get or set buffer size:.*$/
-  }));
+  }, common.expectsError(errorObj));
 
   assert.throws(() => {
     socket.getSendBufferSize();
-  }, common.expectsError({
-    code: 'ERR_SOCKET_BUFFER_SIZE',
-    type: Error,
-    message: /^Could not get or set buffer size:.*$/
-  }));
+  }, common.expectsError(errorObj));
 }
 
 {
   // Should throw error if invalid buffer size is specified
+  const errorObj = {
+    code: 'ERR_SOCKET_BAD_BUFFER_SIZE',
+    type: TypeError,
+    message: /^Buffer size must be a positive integer$/
+  };
+
   const socket = dgram.createSocket('udp4');
 
   socket.bind(common.mustCall(() => {
     assert.throws(() => {
       socket.setRecvBufferSize(-1);
-    }, common.expectsError({
-      code: 'ERR_SOCKET_BAD_BUFFER_SIZE',
-      type: Error,
-      message: /^Buffer size must be a positive integer$/
-    }));
+    }, common.expectsError(errorObj));
 
     assert.throws(() => {
       socket.setRecvBufferSize(Infinity);
-    }, common.expectsError({
-      code: 'ERR_SOCKET_BAD_BUFFER_SIZE',
-      type: Error,
-      message: /^Buffer size must be a positive integer$/
-    }));
+    }, common.expectsError(errorObj));
 
     assert.throws(() => {
       socket.setRecvBufferSize('Doh!');
-    }, common.expectsError({
-      code: 'ERR_SOCKET_BAD_BUFFER_SIZE',
-      type: Error,
-      message: /^Buffer size must be a positive integer$/
-    }));
+    }, common.expectsError(errorObj));
 
     socket.close();
   }));
 }
 
-  // Can set and get buffer sizes after binding the socket.
 {
+  // Can set and get buffer sizes after binding the socket.
   const socket = dgram.createSocket('udp4');
 
   socket.bind(common.mustCall(() => {
@@ -85,10 +69,10 @@ const dgram = require('dgram');
     // note: linux will double the buffer size
     assert.ok(socket.getRecvBufferSize() === 1200 ||
               socket.getRecvBufferSize() === 2400,
-              "SO_RCVBUF not 1200 or 2400");
+              'SO_RCVBUF not 1200 or 2400');
     assert.ok(socket.getSendBufferSize() === 1500 ||
               socket.getSendBufferSize() === 3000,
-              "SO_SNDBUF not 1500 or 3000");
+              'SO_SNDBUF not 1500 or 3000');
     socket.close();
   }));
 }

From f196be9497acbb3258323f0dec3cabf085ad7386 Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Wed, 21 Jun 2017 22:09:06 +0100
Subject: [PATCH 12/13] dgram: addressing pr coments

---
 src/udp_wrap.cc                               | 12 +++++--
 .../parallel/test-dgram-socket-buffer-size.js | 34 ++++++++-----------
 2 files changed, 25 insertions(+), 21 deletions(-)

diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 58ffbacb05b6ea..8a43ae91f81e4f 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -235,13 +235,21 @@ void UDPWrap::BufferSize(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[1]->IsUint32());
   int size = static_cast<int>(args[0].As<Uint32>()->Value());
 
+  if (size != args[0].As<Uint32>()->Value()) {
+    if (args[1].As<Uint32>()->Value() == 0)
+      return env->ThrowUVException(EINVAL, "uv_recv_buffer_size");
+    else
+      return env->ThrowUVException(EINVAL, "uv_send_buffer_size");
+  }
+
   int err;
-  if (args[1].As<Uint32>()->Value() == 0)
+  if (args[1].As<Uint32>()->Value() == 0) {
     err = uv_recv_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_),
                               &size);
-  else
+  } else {
     err = uv_send_buffer_size(reinterpret_cast<uv_handle_t*>(&wrap->handle_),
                               &size);
+  }
 
   if (err != 0) {
     if (args[1].As<Uint32>()->Value() == 0)
diff --git a/test/parallel/test-dgram-socket-buffer-size.js b/test/parallel/test-dgram-socket-buffer-size.js
index 701cb6f09bb142..2987703ba53aa6 100644
--- a/test/parallel/test-dgram-socket-buffer-size.js
+++ b/test/parallel/test-dgram-socket-buffer-size.js
@@ -39,21 +39,20 @@ const dgram = require('dgram');
     message: /^Buffer size must be a positive integer$/
   };
 
+  const badBufferSizes = [-1, Infinity, 'Doh!'];
+
   const socket = dgram.createSocket('udp4');
 
   socket.bind(common.mustCall(() => {
-    assert.throws(() => {
-      socket.setRecvBufferSize(-1);
-    }, common.expectsError(errorObj));
-
-    assert.throws(() => {
-      socket.setRecvBufferSize(Infinity);
-    }, common.expectsError(errorObj));
-
-    assert.throws(() => {
-      socket.setRecvBufferSize('Doh!');
-    }, common.expectsError(errorObj));
-
+    badBufferSizes.forEach((badBufferSize) => {
+      assert.throws(() => {
+        socket.setRecvBufferSize(badBufferSize);
+      }, common.expectsError(errorObj));
+
+      assert.throws(() => {
+        socket.setSendBufferSize(badBufferSize);
+      }, common.expectsError(errorObj));
+    });
     socket.close();
   }));
 }
@@ -64,15 +63,12 @@ const dgram = require('dgram');
 
   socket.bind(common.mustCall(() => {
     socket.setRecvBufferSize(1200);
-    socket.setSendBufferSize(1500);
+    socket.setSendBufferSize(1200);
 
     // note: linux will double the buffer size
-    assert.ok(socket.getRecvBufferSize() === 1200 ||
-              socket.getRecvBufferSize() === 2400,
-              'SO_RCVBUF not 1200 or 2400');
-    assert.ok(socket.getSendBufferSize() === 1500 ||
-              socket.getSendBufferSize() === 3000,
-              'SO_SNDBUF not 1500 or 3000');
+    const expectedBufferSize = common.isLinux ? 2400 : 1200;
+    assert.strictEqual(socket.getRecvBufferSize(), expectedBufferSize);
+    assert.strictEqual(socket.getSendBufferSize(), expectedBufferSize);
     socket.close();
   }));
 }

From f4d35646aed2d32b4e9f36640be35c5181a9e93f Mon Sep 17 00:00:00 2001
From: Damien O'Reilly <damienreilly@gmail.com>
Date: Sun, 10 Sep 2017 22:21:00 +0100
Subject: [PATCH 13/13] dgram: fixed buffer sizes in tests

Buffer sizes were not accepted by OS if they were
below a minimum threshold, therefore tests would
fail.
---
 test/parallel/test-dgram-createSocket-type.js  | 12 ++++++------
 test/parallel/test-dgram-socket-buffer-size.js |  6 +++---
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/test/parallel/test-dgram-createSocket-type.js b/test/parallel/test-dgram-createSocket-type.js
index 4ab4205f8bef05..613e1c80308734 100644
--- a/test/parallel/test-dgram-createSocket-type.js
+++ b/test/parallel/test-dgram-createSocket-type.js
@@ -44,17 +44,17 @@ validTypes.forEach((validType) => {
 {
   const socket = dgram.createSocket({
     type: 'udp4',
-    recvBufferSize: 1300,
-    sendBufferSize: 1800
+    recvBufferSize: 10000,
+    sendBufferSize: 15000
   });
 
   socket.bind(common.mustCall(() => {
     // note: linux will double the buffer size
-    assert.ok(socket.getRecvBufferSize() === 1300 ||
-              socket.getRecvBufferSize() === 2600,
+    assert.ok(socket.getRecvBufferSize() === 10000 ||
+              socket.getRecvBufferSize() === 20000,
               'SO_RCVBUF not 1300 or 2600');
-    assert.ok(socket.getSendBufferSize() === 1800 ||
-              socket.getSendBufferSize() === 3600,
+    assert.ok(socket.getSendBufferSize() === 15000 ||
+              socket.getSendBufferSize() === 30000,
               'SO_SNDBUF not 1800 or 3600');
     socket.close();
   }));
diff --git a/test/parallel/test-dgram-socket-buffer-size.js b/test/parallel/test-dgram-socket-buffer-size.js
index 2987703ba53aa6..13fbd4fb4be601 100644
--- a/test/parallel/test-dgram-socket-buffer-size.js
+++ b/test/parallel/test-dgram-socket-buffer-size.js
@@ -62,11 +62,11 @@ const dgram = require('dgram');
   const socket = dgram.createSocket('udp4');
 
   socket.bind(common.mustCall(() => {
-    socket.setRecvBufferSize(1200);
-    socket.setSendBufferSize(1200);
+    socket.setRecvBufferSize(10000);
+    socket.setSendBufferSize(10000);
 
     // note: linux will double the buffer size
-    const expectedBufferSize = common.isLinux ? 2400 : 1200;
+    const expectedBufferSize = common.isLinux ? 20000 : 10000;
     assert.strictEqual(socket.getRecvBufferSize(), expectedBufferSize);
     assert.strictEqual(socket.getSendBufferSize(), expectedBufferSize);
     socket.close();