function serializeError(error) {
try {
if (typeof error === 'object' &&
ObjectPrototypeToString(error) === '[object Error]') {
const constructors = GetConstructors(error);
for (var i = constructors.length - 1; i >= 0; i--) {
const name = GetName(constructors[i]);
if (errorConstructorNames.has(name)) {
try { error.stack; } catch {}
const serialized = serialize({
constructor: name,
properties: TryGetAllProperties(error)
});
return Buffer.concat([Buffer.from([kSerializedError]), serialized]);
}
}
}
} catch {}
try {
const serialized = serialize(error);
return Buffer.concat([Buffer.from([kSerializedObject]), serialized]);
} catch {}
return Buffer.concat([Buffer.from([kInspectedError]),
Buffer.from(lazyUtil().inspect(error), 'utf8')]);
}
test("Buffer.concat()", function () {
assertEqual(Buffer.concat([]).length, 0);
var b = new Buffer(5);
assertEqual(Buffer.concat([b]), b);
assertEqual(Buffer.concat([new Buffer(5), new Buffer(5)]).length, 10);
assertEqual(Buffer.concat([new Buffer(5), new Buffer(5)], 8).length, 8);
});
HDPrivateKey.prototype._buildFromBuffers = function(arg) {
/* jshint maxcomplexity: 8 */
/* jshint maxstatements: 20 */
HDPrivateKey._validateBufferArguments(arg);
Object.defineProperty(this, '_buffers', {
configurable: false,
value: arg
});
var sequence = [
arg.version, arg.depth, arg.parentFingerPrint, arg.childIndex, arg.chainCode,
BufferUtil.emptyBuffer(1), arg.privateKey
];
var concat = buffer.Buffer.concat(sequence);
if (!arg.checksum || !arg.checksum.length) {
arg.checksum = Base58Check.checksum(concat);
} else {
if (arg.checksum.toString() !== Base58Check.checksum(concat).toString()) {
throw new errors.InvalidB58Checksum(concat);
}
}
var xprivkey;
if (!arg.xprivkey) {
xprivkey = Base58Check.encode(buffer.Buffer.concat(sequence));
} else {
xprivkey = arg.xprivkey;
}
var privateKey = new PrivateKey(BN().fromBuffer(arg.privateKey));
var publicKey = privateKey.toPublicKey();
var size = HDPrivateKey.ParentFingerPrintSize;
var fingerPrint = Hash.sha256ripemd160(publicKey.toBuffer()).slice(0, size);
JSUtil.defineImmutable(this, {
xprivkey: xprivkey,
network: Network.get(BufferUtil.integerFromBuffer(arg.version)),
depth: BufferUtil.integerFromSingleByteBuffer(arg.depth),
privateKey: privateKey,
publicKey: publicKey,
fingerPrint: fingerPrint
});
var HDPublicKey = require('./hdpublickey');
var hdPublicKey = new HDPublicKey(this);
JSUtil.defineImmutable(this, {
hdPublicKey: hdPublicKey,
xpubkey: hdPublicKey.xpubkey
});
return this;
};
function exithandler(code, signal) {
if (exited) return;
exited = true;
if (timeoutId) {
clearTimeout(timeoutId);
timeoutId = null;
}
if (!callback) return;
// merge chunks
var stdout;
var stderr;
if (encoding ||
(
child.stdout &&
child.stdout._readableState &&
child.stdout._readableState.encoding
)) {
stdout = _stdout.join('');
} else {
stdout = Buffer.concat(_stdout);
}
if (encoding ||
(
child.stderr &&
child.stderr._readableState &&
child.stderr._readableState.encoding
)) {
stderr = _stderr.join('');
} else {
stderr = Buffer.concat(_stderr);
}
if (!ex && code === 0 && signal === null) {
callback(null, stdout, stderr);
return;
}
if (args.length !== 0)
cmd += ` ${args.join(' ')}`;
if (!ex) {
// eslint-disable-next-line no-restricted-syntax
ex = new Error('Command failed: ' + cmd + '\n' + stderr);
ex.killed = child.killed || killed;
ex.code = code < 0 ? getSystemErrorName(code) : code;
ex.signal = signal;
}
ex.cmd = cmd;
callback(ex, stdout, stderr);
}
BufferList.prototype.splice = function(start,howMany){
if (arguments.length > 2) throw new Error("splice inserting not implemented");
this.length -= howMany;
var end = start + howMany;
var sidx = this._getOffset(start);
var eidx = this._getOffset(end-1);
if (sidx.buffer == eidx.buffer){
var b = this._list[sidx.buffer]
var l = b.slice(0,sidx.byte);
var m = b.slice(sidx.byte,eidx.byte+1);
var r = b.slice(eidx.byte+1);
var nb = Buffer.concat([l,r], l.length + r.length);
if (nb.length === 0) this._list.splice(sidx.buffer,1);
else this._list[sidx.buffer] = nb;
return m;
}
var bl = this._list[sidx.buffer];
var nl = bl.slice(0,sidx.byte);
var l = bl.slice(sidx.byte+1);
var br = this._list[eidx.buffer];
var r = br.slice(0,eidx.byte);
var nr = br.slice(eidx.byte+1);
var arr = [];
arr.push(l);
for (var i=sidx.buffer+1; i<eidx.buffer; i++){
arr.push(this._list[i]);
}
arr.push(r);
var b = Buffer.concat(arr,howMany);
var sl = sidx.buffer + 1;
var sr = eidx.buffer - 1;
if (nl.length === 0) sl--;
if (nr.length === 0) sr++;
this._list.splice(sl, sr - sl + 1);
return b;
};
res.on('end', function () {
var body = JSON.parse(Buffer.concat(buffers).toString())
t.equal(body['test-request-header'], 'foo', 'request header 1')
t.equal(body['test-request-header-2'], 'FOO2', 'request header 2')
t.equal(Object.keys(body).length, 2, 'correct number of request headers')
t.end()
})
res.on('end', function () {
if (skipVerification)
t.skip('binary data not preserved on IE <= 8')
else
t.ok(reference.equals(Buffer.concat(buffers)), 'contents match')
t.end()
})
function transform (chunk, enc, callback) {
const _this = this
if (license) {
return callback(null, chunk)
}
// TODO is it more efficient to grow the buffer each time or to
// keep an array of chunks and concat the whole array each time?
buffer = Buffer.concat([buffer, chunk])
if (!supportsFiletype(buffer)) {
return callback(null, chunk)
}
parseLicenseFromFile(buffer)
.then(checkFoundLicense.bind(_this))
.catch(function () {
// Errors just mean we couldn't read the license from the buffer yet
// (this could be due to the fact that we haven't loaded all of the tag chunks yet)
return Promise.resolve()
})
.then(function () {
// Only call the callback after we've checked whether the part of
// the buffer loaded thus far has the license in it
callback(null, chunk)
})
},
function do_ref_delta() {
var buf = Buffer.concat(payload_accum, payload_size)
, target_oid = buf.slice(0, 20)
, delta
buf = buf.slice(20)
return inflate(buf, ondelta)
// TODO: these could be done in
// parallel.
function ondelta(err, _delta) {
if(err) {
return stream.emit('error', err)
}
delta = _delta
packfile._find_raw(target_oid, ontarget)
}
function ontarget(err, target) {
var out
out = apply_delta(delta, target.data)
stream.queue({
type: target.type
, data: out
})
stream.queue(null)
}
}
it('should encrypt vector ' + i, function() {
var key = new Buffer(vec.key, 'hex');
var iv = new Buffer(vec.iv, 'hex');
var input = new Buffer(vec.input, 'hex');
var enc = CBC.create({
type: 'encrypt',
key: key,
iv: iv
});
var out = new Buffer(enc.update(input).concat(enc.final()));
var cipher = crypto.createCipheriv('des-cbc', key, iv);
var expected = Buffer.concat([ cipher.update(input), cipher.final() ]);
assert.deepEqual(out, expected);
var dec = CBC.create({
type: 'decrypt',
key: key,
iv: iv
});
assert.deepEqual(new Buffer(dec.update(out).concat(dec.final())),
input);
});
function () {
var body = Buffer.isBuffer(arr[0]) ? Buffer.concat(arr)
: arr.join('')
this.emit('data', body)
this.emit('end')
if(callback) callback(null, body)
})
IndexEntry.prototype.toBuffer = function(version) {
var output = Concentrate()
// ctime
.uint32be(this.getCTime().getTime())
.uint32be(0)
// mtime
.uint32be(this.getMTime().getTime())
.uint32be(0)
.uint32be(this.getDev())
.uint32be(this.getIno())
.uint32be(this.getUid())
.uint32be(this.getGid())
.uint32be(this.getEntrySize())
.buffer((new Buffer(this.getSha())).toString('hex'))
.uint16be(this.getFlags());
if (version >= 3) output = output.uint16be(this.getExtendedFlags());
output = output.string(this.getPath());
var buf = output.result();
var padlen = (8 - (buf.length % 8)) || 8;
return Buffer.concat([
buf,
Buffer.alloc(padlen, 0)
]);
};
res.on('end', function(){
log.debug('Get the response of ' + requestMethod + ' ' + options.url + ' at ' + new Date());
if(responseTimeout){
clearTimeout(responseTimeout);
}
requestHandler(null, Buffer.concat(buffers), res);
});
req.on("end",function(){
reqData = Buffer.concat(postData);
resourceInfo.reqBody = reqData.toString();
GLOBAL.recorder && GLOBAL.recorder.updateRecord(resourceInfoId,resourceInfo);
callback();
});
}))).then(function() {
if (!acc.length) return Buffer.alloc(0);
else if (typeof acc[0] === 'string')
return acc.join('');
else
return Buffer.concat(acc);
});
BaseAsm.prototype._getBuffer = function getBuffer() {
// Compile all pending stubs
if (this.stubs)
this.stubs.compilePending();
return Buffer.concat(this._buffer.render(), this._buffer.size);
};
function end () {
var newFile,
params = [],
call = [];
if (options.$ !== false) {
params.push(typeof options.$ === "string" ? options.$ : "$");
call.push("jQuery");
}
if (options.window) {
params.push(typeof options.window === "string" ? options.window : "window");
call.push("window");
}
if (options.document) {
params.push(typeof options.document === "string" ? options.document : "document");
call.push("document");
}
if (options.undefined) {
params.push(typeof options.undefined === "string" ? options.undefined : "undefined");
}
newFile = new File({
cwd: file.cwd,
base: file.base,
path: file.path,
contents: Buffer.concat([
new Buffer(";(function (" + params.join(", ") + ") {" + options.newLine),
file.contents,
new Buffer(options.newLine + "})(" + call.join(", ") + ");")
])
});
this.emit("data", newFile);
this.emit("end");
}
/**
* Receive all the file contents
*
* @param {Object} err
* @param {Array} files Buffer list
*/
function concatAll(err, files) {
if (err) {
cb(err);
}
log.info('Finish combination!');
cb(null, Buffer.concat(utils._appendEnter(files)));
});
unix_dgram: function(message, severity){
var self = this;
var preambleBuffer = self.composerFunction('', severity);
var formattedMessageBuffer = Buffer.isBuffer(message) ? message : new Buffer(message);
var chunkSize = 2000 - preambleBuffer.length - 200;
var numChunks = Math.ceil(formattedMessageBuffer.length / chunkSize);
var fragments = [preambleBuffer];
if (numChunks > 1){
for (var i = 0; i < numChunks; i++){
fragments.push(formattedMessageBuffer.slice(i * chunkSize, Math.min(formattedMessageBuffer.length, (i + 1) * chunkSize)),
new Buffer(' [' + (i + 1) + '/' + numChunks + ']', 'ascii'));
}
} else{
fragments.push(formattedMessageBuffer);
}
var chunk = Buffer.concat(fragments);
var socket = getSocket('unix_dgram');
socket.send(chunk,
0,
chunk.length,
this.path,
function(err, bytes){
self._logError(err, bytes);
releaseSocket();
}
);
}
Script.compileTextArray = function compileTextArray(arr, offset) {
const asm = new Assembler();
asm.codeOffset(offset || 0);
for (let i = 0; i < arr.length; i++) {
let line = arr[i].split(/[\s,]+/g);
let opcode = line[0];
assert(Assembler.prototype.hasOwnProperty(opcode),
`Client: Unknown opcode "${opcode}"`);
const args = [];
for (let i = 1; i < line.length; i++) {
const arg = line[i];
if (/^\-?0x[0-9a-f]+$/.test(arg))
args.push(parseInt(arg, 16));
else if (/^-?\d+$/.test(arg))
args.push(parseInt(arg, 10));
else
args.push(arg);
}
asm[opcode].apply(asm, args);
}
const buf = new WBuf();
asm.render(buf);
const code = Buffer.concat(buf.render());
return new Script(code);
};
async function readFileHandle(filehandle, options) {
const statFields = await binding.fstat(filehandle.fd, false, kUsePromises);
let size;
if ((statFields[1/* mode */] & S_IFMT) === S_IFREG) {
size = statFields[8/* size */];
} else {
size = 0;
}
if (size > kMaxLength)
throw new ERR_FS_FILE_TOO_LARGE(size);
const chunks = [];
const chunkSize = size === 0 ?
kReadFileMaxChunkSize :
Math.min(size, kReadFileMaxChunkSize);
let endOfFile = false;
do {
const buf = Buffer.alloc(chunkSize);
const { bytesRead, buffer } =
await read(filehandle, buf, 0, chunkSize, -1);
endOfFile = bytesRead === 0;
if (bytesRead > 0)
chunks.push(buffer.slice(0, bytesRead));
} while (!endOfFile);
const result = Buffer.concat(chunks);
if (options.encoding) {
return result.toString(options.encoding);
} else {
return result;
}
}
fs.readFile(options[key], function (err, data) {
if (err) {
self.emit('error', new gutil.PluginError(ns, ns + " FILE NOT FOUND: [" + options[key] + "] for token [" + key + "]"));
} else {
// search for the start index of the token in the source-file buffer..
var tokenStart = file.contents.indexOf(key);
if (tokenStart < 0) {
self.emit('error', new gutil.PluginError(ns, ns + " TOKEN NOT FOUND: [" + key + "] in file [" + options[key] + "]"));
} else {
// split the source-file into head and tail buffers for
// content before and after the token
var tailStart = tokenStart + key.length;
var buffHead = new Buffer(tokenStart).fill(' ');
var buffTail = new Buffer(file.contents.length - tailStart).fill('*');
file.contents.copy(buffHead, 0, 0, tokenStart);
file.contents.copy(buffTail, 0, tokenStart + key.length, file.contents.length);
// rebuild the source-file buffer with the input-file buffer inserted between the head and tail
file.contents = Buffer.concat([buffHead, data, buffTail]);
}
}
next();
});
stream.on('end', () => {
content = Buffer.concat(content);
content = gst.common.parseTree(content);
content.sort(compareEntries);
async.map(content, recurse, callback);
});
file.on('end', function() {
var data = Buffer.concat(chunks);
saveImage(measurementId, data, side, res, function(err, image) {
if(err) next(err);
var imageRecord = returnImageRec(image, req.method);
return res.status(201).json(imageRecord);
});
});
res.once('end', function() {
agent.close();
zlib.gunzip(Buffer.concat(received), function(err, decompressed) {
assert.equal(decompressed, fox);
done();
});
});
BaseAsm.prototype.toBuffer = function toBuffer() {
// Compile all pending stubs
if (this.stubs)
this.stubs.compilePending();
var total = this._total - this._current.length + this._offset;
return Buffer.concat(this._buffers.concat(this._current), total);
};
stream.on('data', function handleStreamData(chunk) {
responseBuffer.push(chunk);
// make sure the content length is not over the maxContentLength if specified
if (config.maxContentLength > -1 && Buffer.concat(responseBuffer).length > config.maxContentLength) {
reject(createError('maxContentLength size of ' + config.maxContentLength + ' exceeded', config));
}
});
stream.on('end', function handleStreamEnd() {
var responseData = Buffer.concat(responseBuffer);
if (config.responseType !== 'arraybuffer') {
responseData = responseData.toString('utf8');
}
response.data = transformData(responseData, res.headers, config.transformResponse);
settle(resolve, reject, response);
});
res.on('end', function(err){
process.I_HTTP_CONNECT_COUNT -= 1;
console.log('http连接数:' + process.I_HTTP_CONNECT_COUNT);
var buffer = Buffer.concat(list);
if(params.callback) {
params.callback(buffer);
}
});
}).on('end', function () {
var script = Buffer.concat(chunks, size).toString('utf-8');
expect(script).to.contain('__customBrowserReloadClient__');
expect(script).to.contain('__browserReloadClientPlugin__');
done();
}