buffer: add buf.mask for ws

doc/api/buffer.markdown

@@ -810,6 +810,26 @@ buffer.
     var b = new Buffer(50);
     b.fill("h");
 
+### buf.mask(maskValue, targetBuffer[, targetStart][, sourceStart][, sourceEnd])
+
+* `maskValue` Number
+* `targetBuffer` Buffer
+* `targetStart` Number, optional
+* `sourceStart` Number, optional
+* `sourceEnd` Number, optional
+
+Takes the contents of `buf`, starting at `sourceStart` and ending at
+`sourceEnd`, and XOR's them with `maskValue`. The result is written to
+`targetBuffer`, starting at `targetOffset`. `sourceStart` and `targetStart`
+will default to `0` if not given; `sourceEnd` will default to `buf.length` if
+not given. The start, end, and offset parameters function the same as the
+corresponding parameters to
+[buf.copy](#buffer_buf_copy_targetbuffer_targetstart_sourcestart_sourceend).
+
+The target region of memory may overlap the source region of memory.
+
+Returns the number of bytes masked and written into `targetBuffer`.
+
 ### buffer.values()
 
 Creates iterator for buffer values (bytes). This function is called automatically

src/node_buffer.cc

@@ -310,6 +310,70 @@ void Base64Slice(const FunctionCallbackInfo<Value>& args) {
 }
 
 
+// bytesCopied = buffer.mask(mask, target, targetOffset, sourceStart, sourceEnd)
+void Mask(const FunctionCallbackInfo<Value> &args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  uint32_t mask32 = args[0]->Uint32Value();
+  char* mask = (char*)&mask32;
+
+  Local<Object> target = args[1]->ToObject(env->isolate());
+
+  if (!HasInstance(target))
+    return env->ThrowTypeError("second arg should be a Buffer");
+
+  ARGS_THIS(args.This())
+  size_t target_length = target->GetIndexedPropertiesExternalArrayDataLength();
+  char* target_data = static_cast<char*>(
+      target->GetIndexedPropertiesExternalArrayData());
+  size_t target_start;
+  size_t source_start;
+  size_t source_end;
+
+  CHECK_NOT_OOB(ParseArrayIndex(args[2], 0, &target_start));
+  CHECK_NOT_OOB(ParseArrayIndex(args[3], 0, &source_start));
+  CHECK_NOT_OOB(ParseArrayIndex(args[4], obj_length, &source_end));
+
+  // Copy 0 bytes; we're done
+  if (target_start >= target_length || source_start >= source_end)
+    return args.GetReturnValue().Set(0);
+
+  if (source_start > obj_length)
+    return env->ThrowRangeError("out of range index");
+
+  if (source_end - source_start > target_length - target_start)
+    source_end = source_start + target_length - target_start;
+
+  uint32_t to_copy = MIN(MIN(source_end - source_start,
+                             target_length - target_start),
+                             obj_length - source_start);
+
+  obj_data += source_start;
+  target_data += target_start;
+
+  uint32_t* target_data_32 = (uint32_t*)target_data;
+  uint32_t* obj_data_32 = (uint32_t*)obj_data;
+  size_t to_copy_32 = to_copy / 4;
+  size_t i;
+  for (i = 0; i < to_copy_32; ++i) {
+    target_data_32[i] = mask32 ^ obj_data_32[i];
+  }
+  target_data += to_copy_32 * 4;
+  obj_data += to_copy_32 * 4;
+
+  switch(to_copy % 4) {
+    case 3:
+      target_data[2] = obj_data[2] ^ mask[2];
+    case 2:
+      target_data[1] = obj_data[1] ^ mask[1];
+    case 1:
+      target_data[0] = obj_data[0] ^ mask[0];
+    case 0:;
+  }
+  return args.GetReturnValue().Set(to_copy);
+}
+
+
 // bytesCopied = buffer.copy(target[, targetStart][, sourceStart][, sourceEnd]);
 void Copy(const FunctionCallbackInfo<Value> &args) {
   Environment* env = Environment::GetCurrent(args);
@@ -741,6 +805,7 @@ void SetupBufferJS(const FunctionCallbackInfo<Value>& args) {
   env->SetMethod(proto, "utf8Write", Utf8Write);
 
   env->SetMethod(proto, "copy", Copy);
+  env->SetMethod(proto, "mask", Mask);
 
   // for backwards compatibility
   proto->ForceSet(env->offset_string(),

test/parallel/test-buffer-mask.js

@@ -0,0 +1,92 @@
+var common = require('../common');
+var assert = require('assert');
+
+var tests = [
+  testBasic,
+  testBounds,
+  testOverflow,
+  testNonAligned,
+  testReturnValue
+]
+
+tests.forEach(Function.prototype.call.bind(Function.prototype.call))
+
+function referenceImplementation(source, maskNum, output, offset, start, end) {
+  var i = 0;
+  var mask = new Buffer(4);
+  var length = end - start;
+  mask.writeUInt32LE(maskNum, 0);
+  var toCopy = Math.min(length, output.length - offset);
+  var maskIdx = 0;
+  for (var i = 0; i < toCopy; ++i) {
+    output[i + offset] = source[i + start] ^ mask[maskIdx];
+    maskIdx = (maskIdx + 1) & 3;
+  }
+}
+
+function testBasic() {
+  var input = new Buffer(256);
+  var output = new Buffer(256);
+  var refoutput = new Buffer(256);
+  var mask = 0xF0F0F0F0;
+
+  for (var i = 0; i < input.length; ++i)
+    input[i] = i;
+
+  output[0] = refoutput[0] = 0;
+  referenceImplementation(input, mask, refoutput, 1, 0, 255);
+  input.mask(mask, output, 1, 0, 255);
+  for (var i = 0; i < input.length; ++i) {
+    assert.equal(output[i], refoutput[i]);
+  }
+}
+
+function testBounds() {
+  var input = new Buffer(16);
+  var output = new Buffer(32);
+  try {
+    input.mask(120120, output, 0, 0, 17);
+    assert.fail('expected error');
+  } catch(err) {
+    assert.ok(err);
+  }
+}
+
+function testOverflow() {
+  var input = new Buffer(16);
+  var output = new Buffer(15);
+  try {
+    input.mask(120120, output);
+    assert.fail('expected error');
+  } catch(err) {
+    assert.ok(err);
+  }
+}
+
+function testNonAligned() {
+  var input = new Buffer(16);
+  var output = new Buffer(16);
+  var refoutput = new Buffer(16);
+  var mask = 0xF0F0F0F0;
+
+  for (var i = 0; i < input.length; ++i)
+    input[i] = i;
+
+  for (var end = 3; end > 0; --end) {
+    referenceImplementation(input, mask, refoutput, 0, 0, end);
+    input.mask(mask, output, 0, 0, end);
+
+    for (var i = 0; i < end; ++i)
+      assert.equal(output[i], refoutput[i]);
+  }
+}
+
+function testReturnValue() {
+  var input = new Buffer(16);
+  var output = new Buffer(16);
+  assert.equal(input.mask(0, output), 16)
+  assert.equal(input.mask(0, output, 4), 12)
+  assert.equal(input.mask(0, output, 4, 6), 10)
+  assert.equal(input.mask(0, output, 4, 6, 4), 0)
+  assert.equal(input.mask(0, output, 4, 6, 8), 2)
+}