this.deflate(dict, function (err, chunks, size) {
if (err) return callback(err);
var offset = type === 'SYN_STREAM' ? 18 : 14,
total = (type === 'SYN_STREAM' ? 10 : 6) + size,
frame = new Buffer(offset + size);;
frame.writeUInt16BE(0x8002, 0, true); // Control + Version
frame.writeUInt16BE(type === 'SYN_STREAM' ? 1 : 2, 2, true); // type
frame.writeUInt32BE(total & 0x00ffffff, 4, true); // No flag support
frame.writeUInt32BE(id & 0x7fffffff, 8, true); // Stream-ID
if (type === 'SYN_STREAM') {
frame[4] = 2;
frame.writeUInt32BE(assoc & 0x7fffffff, 12, true); // Stream-ID
}
frame.writeUInt8(priority & 0x3, 16, true); // Priority
for (var i = 0; i < chunks.length; i++) {
chunks[i].copy(frame, offset);
offset += chunks[i].length;
}
callback(null, frame);
});
bn.random = function random(a, b) {
assert.equal(a.length, b.length);
var result = new Buffer(a.length);
for (var i = 0; i < a.length; i += 2) {
var aword = a.readUInt16BE(i),
bword = b.readUInt16BE(i);
if (aword === bword) {
result.writeUInt16BE(aword, i);
continue;
}
var word = (aword + Math.random() * (bword - aword)) | 0;
result.writeUInt16BE(word, i);
if (word < bword) {
i += 2;
break;
}
}
// Fill rest with random bytes
if (i !== a.length) {
crypto.randomBytes(a.length - i).copy(result, i);
}
return result;
};
bn.add = function add(a, b) {
// a should be the bigger one buffer
if (a.length < b.length) {
var t = a;
a = b;
b = t;
}
var result = new Buffer(a.length + 2),
over = 0;
for (var i = a.length - 2, j = b.length - 2; i >= 0; i -= 2, j -= 2) {
var aword = a.readUInt16BE(i),
bword = j >= 0 ? b.readUInt16BE(j) : 0,
rword = aword + bword + over;
over = rword >> 16;
result.writeUInt16BE(rword & 0xffff, i);
}
// Write last overflowed word
result.writeUInt16BE(over, i);
// Do not return last byte if overflow hasn't happened
return over ? result : result.slice(0, result.length - 2);
};
DERNode.prototype._encodeStr = function encodeStr(str, tag) {
if (tag === 'bitstr') {
return this._createEncoderBuffer([ str.unused | 0, str.data ]);
} else if (tag === 'bmpstr') {
const buf = new Buffer(str.length * 2);
for (let i = 0; i < str.length; i++) {
buf.writeUInt16BE(str.charCodeAt(i), i * 2);
}
return this._createEncoderBuffer(buf);
} else if (tag === 'numstr') {
if (!this._isNumstr(str)) {
return this.reporter.error('Encoding of string type: numstr supports ' +
'only digits and space');
}
return this._createEncoderBuffer(str);
} else if (tag === 'printstr') {
if (!this._isPrintstr(str)) {
return this.reporter.error('Encoding of string type: printstr supports ' +
'only latin upper and lower case letters, ' +
'digits, space, apostrophe, left and rigth ' +
'parenthesis, plus sign, comma, hyphen, ' +
'dot, slash, colon, equal sign, ' +
'question mark');
}
return this._createEncoderBuffer(str);
} else if (/str$/.test(tag)) {
return this._createEncoderBuffer(str);
} else if (tag === 'objDesc') {
return this._createEncoderBuffer(str);
} else {
return this.reporter.error('Encoding of string type: ' + tag +
' unsupported');
}
};
bn.shr = function shr(a) {
var result = new Buffer(a.length),
under = 0;
for (var i = 0; i < result.length; i += 2) {
var word = a.readUInt16BE(i);
result.writeUInt16BE((word >> 1) | under, i);
under = (word & 1) << 15;
}
return result;
};
DERNode.prototype._encodeStr = function encodeStr(str, tag) {
if (tag === 'octstr')
return this._createEncoderBuffer(str);
else if (tag === 'bitstr')
return this._createEncoderBuffer([ str.unused | 0, str.data ]);
else if (tag === 'ia5str' || tag === 'utf8str')
return this._createEncoderBuffer(str);
else if (tag === 'bmpstr') {
var buf = new Buffer(str.length * 2);
for (var i = 0; i < str.length; i++) {
buf.writeUInt16BE(str.charCodeAt(i), i * 2);
}
return this._createEncoderBuffer(buf);
}
return this.reporter.error('Encoding of string type: ' + tag +
' unsupported');
};
encode: function (val) {
var buf = new Buffer(2);
var flags = 0x0000;
//Bajt 1
{
flags = flags | (val.QR << 15);
flags = flags | (val.OpCode << 11);
flags = flags | (val.AA << 10);
flags = flags | (val.TC << 9);
flags = flags | (val.RD << 8);
}
//Bajt 2
{
flags = flags | (val.RA << 7);
flags = flags | (val.Z << 6);
//flags = flags | val.RCode; // Cannot be here as it would overwrite some data!
flags = flags | val.RCode;
}
// Encode
buf.writeUInt16BE(flags, 0);
return buf;
},
bn.sub = function sub(a, b) {
var result = new Buffer(Math.max(a.length, b.length)),
under = 0;
for (var i = a.length - 2, j = b.length - 2;
i >= 0 || j >= 0;
i -= 2, j -= 2) {
var aword = i >= 0 ? a.readUInt16BE(i) : 0,
bword = j >= 0 ? b.readUInt16BE(j) : 0,
rword = aword - bword - under;
if (rword < 0) {
rword += 0x10000;
under = 1;
} else {
under = 0;
}
result.writeUInt16BE(rword, i);
}
// Do not return last byte if overflow hasn't happened
return result;
};
//
// internal, converts object into spdy dictionary
//
function headersToDict(headers, preprocess) {
function stringify(value) {
if (value !== undefined) {
if (Array.isArray(value)) {
return value.join('\x00');
} else if (typeof value === 'string') {
return value;
} else {
return value.toString();
}
} else {
return '';
}
}
// Lower case of all headers keys
var loweredHeaders = {};
Object.keys(headers || {}).map(function(key) {
loweredHeaders[key.toLowerCase()] = headers[key];
});
// Allow outer code to add custom headers or remove something
if (preprocess) preprocess(loweredHeaders);
// Transform object into kv pairs
var len = 2,
pairs = Object.keys(loweredHeaders).filter(function(key) {
var lkey = key.toLowerCase();
return lkey !== 'connection' && lkey !== 'keep-alive' &&
lkey !== 'proxy-connection' && lkey !== 'transfer-encoding';
}).map(function(key) {
var klen = Buffer.byteLength(key),
value = stringify(loweredHeaders[key]),
vlen = Buffer.byteLength(value);
len += 4 + klen + vlen;
return [klen, key, vlen, value];
}),
result = new Buffer(len);
result.writeUInt16BE(pairs.length, 0, true);
var offset = 2;
pairs.forEach(function(pair) {
// Write key length
result.writeUInt16BE(pair[0], offset, true);
// Write key
result.write(pair[1], offset + 2);
offset += pair[0] + 2;
// Write value length
result.writeUInt16BE(pair[2], offset, true);
// Write value
result.write(pair[3], offset + 2);
offset += pair[2] + 2;
});
return result;
};
NetWriter.prototype.writeUInt16BE = function (value) {
var buffer = new Buffer(2);
buffer.writeUInt16BE(value, 0, true);
this.content.push(buffer);
this.size += 2;
};
encode: function (val) {
var ret = (new Buffer(2));
ret.writeUInt16BE(val, 0);
return ret;
},