MSGS.forEach(function (m) {
var b = msgpack.pack(m);
var bb = new buffer.Buffer(buf.length + b.length);
buf.copy(bb, 0, 0, buf.length);
b.copy(bb, buf.length, 0, b.length);
buf = bb;
});
emitter.send = function(message){
var buffer = new Buffer(JSON.stringify(message), "utf8");
var framedBuffer = new Buffer(buffer.length + 2);
framedBuffer[0] = 0;
buffer.copy(framedBuffer, 1, 0, buffer.length);
framedBuffer[framedBuffer.length - 1] = 255;
stream.write(framedBuffer);
};
this._write = function (chans, json) {
debug("Writing data: " + json);
var bufA = new Buffer(Buffer.byteLength(json) + mode_header_width + header_size + (chan_id_width * chans.length),'binary');
var bufB = new Buffer(pack('Cnn', MODE_MESG, chans.length, Buffer.byteLength(json)),'binary');
bufB.copy(bufA,0,0);
var bufD = new Buffer(chans.length * chan_id_width, 'binary');
for (var i = 0; i < chans.length; i++) {
(new Buffer(pack('N', chans[i].getId()), 'binary')).copy(bufD, i * chan_id_width, 0)
};
bufD.copy(bufA, bufB.length, 0);
var bufC = new Buffer(json);
bufC.copy(bufA,bufB.length + bufD.length,0);
doWrite(bufA);
}
ClientSpdyConnection.prototype.goaway = function goaway(status) {
var header = new Buffer(16);
header.writeUInt32BE(0x80030007, 0, true); // Version and type
header.writeUInt32BE(0x00000008, 4, true); // Length
var id = new Buffer(4);
// Server last good StreamID
id.writeUInt32BE((this.lastGoodID) & 0x7fffffff, 0, true);
id.copy(header, 8, 0, 4);
var statusBuffer = new Buffer(4);
statusBuffer.writeUInt32BE((status || 0) & 0x7fffffff, 0, true);
statusBuffer.copy(header, 12, 0, 4);
this.goAway = this.streamId;
this.write(header);
}
var bigIntToByteArray = function(v, size) {
var buf = new BitBuffer(size * 8), buf2 = new Buffer(v.toByteArray()),
st, en;
st = size - buf2.length;
en = buf2.length - size;
if (st < 0) {
st = 0;
}
if (en < 0) {
en = 0;
}
buf2.copy(buf.buf, st, en);
return buf;
};
// Cleans big buffer
function cleanBuffer() {
if(bufferStart > 0) {
if(bufferStart == bufferEnd) { // It's empty, just move pointers
bufferStart = bufferEnd = 0;
}
else {
// Move to beggining via helper buffer
var b2 = new Buffer(bufferEnd - bufferStart);
buffer.copy(b2, 0, bufferStart, bufferEnd); // Copy all valid data to new buffer
b2.copy(buffer, 0, 0); // Copy back to big buffer
bufferStart = 0;
bufferEnd = b2.length;
}
}
}
self.write = function() {
var bl = (typeof arguments[0] === 'string') ?
Buffer.byteLength(arguments[0], arguments[1]) :
arguments[0].length;
if (bufOffset + bl >= buf.length) {
var b = new Buffer(((bufOffset + bl + bufSz - 1) / bufSz) * bufSz);
buf.copy(b, 0, 0, bufOffset);
buf = b;
}
if (typeof arguments[0] === 'string') {
buf.write(arguments[0], bufOffset, arguments[1]);
} else {
arguments[0].copy(buf, bufOffset, 0, arguments[0].length);
}
bufOffset += bl;
};
/*
* Note: this is *not* necessarily the recommended way to
* generate key material and initialization-vectors, but
* it follows the OpenSSL method, as used by Node.js proper,
* which is slightly weird and non-standard for longer key-lengths,
* but does end up being compatible with produced cipher-texts from
* Node.js.
*/
function kdf(data, keyLen, ivLen) {
var totalLen = keyLen + ivLen;
var curLen = 0;
var prev = new Buffer('');
var iter = 1;
var kiv = new Buffer(totalLen);
kiv.fill(0);
while ( curLen < totalLen ) {
prev = kdf_d(data, prev, 1 );
prev.copy( kiv, curLen );
++iter;
curLen += 16;
}
var k = kiv.slice( 0, keyLen );
var i = kiv.slice( keyLen );
return {
key: kiv.slice( 0, keyLen ),
iv: kiv.slice( keyLen )
};
}
assert.strictEqual(512, c.length);
// copy 512 bytes, from 0 to 512.
b.fill(++cntr);
c.fill(++cntr);
var copied = b.copy(c, 0, 0, 512);
console.log('copied %d bytes from b into c', copied);
assert.strictEqual(512, copied);
for (var i = 0; i < c.length; i++) {
assert.strictEqual(b[i], c[i]);
}
// copy c into b, without specifying sourceEnd
b.fill(++cntr);
c.fill(++cntr);
var copied = c.copy(b, 0, 0);
console.log('copied %d bytes from c into b w/o sourceEnd', copied);
assert.strictEqual(c.length, copied);
for (var i = 0; i < c.length; i++) {
assert.strictEqual(c[i], b[i]);
}
// copy c into b, without specifying sourceStart
b.fill(++cntr);
c.fill(++cntr);
var copied = c.copy(b, 0);
console.log('copied %d bytes from c into b w/o sourceStart', copied);
assert.strictEqual(c.length, copied);
for (var i = 0; i < c.length; i++) {
assert.strictEqual(c[i], b[i]);
}
puts("b.length == " + b.length);
assert.equal(1024, b.length);
for (var i = 0; i < 1024; i++) {
assert.ok(b[i] >= 0);
b[i] = i % 256;
}
for (var i = 0; i < 1024; i++) {
assert.equal(i % 256, b[i]);
}
var c = new Buffer(512);
var copied = b.copy(c, 0, 0, 512);
assert.equal(512, copied);
for (var i = 0; i < c.length; i++) {
print('.');
assert.equal(i % 256, c[i]);
}
var asciiString = "hello world";
var offset = 100;
for (var j = 0; j < 500; j++) {
for (var i = 0; i < asciiString.length; i++) {
b[i] = asciiString.charCodeAt(i);
}
var asciiSlice = b.toString('ascii', 0, asciiString.length);
console.log("b.length == " + b.length);
assert.strictEqual(1024, b.length);
for (var i = 0; i < 1024; i++) {
assert.ok(b[i] >= 0);
b[i] = i % 256;
}
for (var i = 0; i < 1024; i++) {
assert.equal(i % 256, b[i]);
}
var c = new Buffer(512);
// copy 512 bytes, from 0 to 512.
var copied = b.copy(c, 0, 0, 512);
console.log("copied " + copied + " bytes from b into c");
assert.strictEqual(512, copied);
for (var i = 0; i < c.length; i++) {
print('.');
assert.equal(i % 256, c[i]);
}
console.log("");
// try to copy 513 bytes, and hope we don't overrun c, which is only 512 long
var copied = b.copy(c, 0, 0, 513);
console.log("copied " + copied + " bytes from b into c");
assert.strictEqual(512, copied);
for (var i = 0; i < c.length; i++) {
assert.equal(i % 256, c[i]);
}
* keystore | alignmt padding | codeSig | mic |
*/
var boot2_codeLen = boot2_len;
/* Align boot2 length to 16 byte boundry */
boot2_len = (boot2_codeLen + 4 + align_size - 1) & (~(align_size - 1));
var padding = boot2_len - boot2_codeLen;
/* Add padding */
for (var i = 0; i < padding; i++) {
boot2_data_buf.writeUInt32LE(0xFF, boot2_codeLen, 1, 'hex');
boot2_codeLen++;
}
tlv_buf.copy(boot2_data_buf, boot2_len, 0, tlv_buf_offset);
boot2_len += tlv_buf_offset;
/* Align length to 16 byte boundary for AES-CCM. Fill void with 0xFF */
var aligned_length = boot2_len;
aligned_length = (boot2_len + 4 + align_size - 1) & (~(align_size - 1));
aligned_length -= 4;
padding = aligned_length - boot2_len;
for (var i = 0; i < padding; i++) {
boot2_data_buf.writeUInt32LE(0xFF, boot2_len, 1, 'hex');
boot2_len++;
}
boot2_len = aligned_length;
boot2_crc_buf = boot2_data_buf.slice(0, boot2_len);
console.log("b.length == " + b.length);
assert.strictEqual(1024, b.length);
for (var i = 0; i < 1024; i++) {
assert.ok(b[i] >= 0);
b[i] = i % 256;
}
for (var i = 0; i < 1024; i++) {
assert.equal(i % 256, b[i]);
}
var c = new Buffer(512);
// copy 512 bytes, from 0 to 512.
var copied = b.copy(c, 0, 0, 512);
console.log("copied " + copied + " bytes from b into c");
assert.strictEqual(512, copied);
for (var i = 0; i < c.length; i++) {
print('.');
assert.equal(i % 256, c[i]);
}
console.log("");
// try to copy 513 bytes, and hope we don't overrun c, which is only 512 long
var copied = b.copy(c, 0, 0, 513);
console.log("copied " + copied + " bytes from b into c");
assert.strictEqual(512, copied);
for (var i = 0; i < c.length; i++) {
assert.equal(i % 256, c[i]);
}
// copy 512 bytes, from 0 to 512.
b.fill(++cntr);
c.fill(++cntr);
const copied = b.copy(c, 0, 0, 512);
console.log('copied %d bytes from b into c', copied);
assert.strictEqual(512, copied);
for (let i = 0; i < c.length; i++) {
assert.strictEqual(b[i], c[i]);
}
}
{
// copy c into b, without specifying sourceEnd
b.fill(++cntr);
c.fill(++cntr);
const copied = c.copy(b, 0, 0);
console.log('copied %d bytes from c into b w/o sourceEnd', copied);
assert.strictEqual(c.length, copied);
for (let i = 0; i < c.length; i++) {
assert.strictEqual(c[i], b[i]);
}
}
{
// copy c into b, without specifying sourceStart
b.fill(++cntr);
c.fill(++cntr);
const copied = c.copy(b, 0);
console.log('copied %d bytes from c into b w/o sourceStart', copied);
assert.strictEqual(c.length, copied);
for (let i = 0; i < c.length; i++) {
self.getBuffer = function() {
var b = new Buffer(bufOffset);
buf.copy(b, 0, 0, bufOffset);
return b;
};
test("Buffer.prototype.copy()", function () {
var b1 = new Buffer("abc"), b2 = new Buffer(3);
b1.copy(b2);
assertEqual(b2.toString(), "abc");
});