initial commit

沈斌

2018-07-10 f00a2b2acc1480c21234001c78da43eec48683d1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
// Copyright 2015 Joyent, Inc.
 
module.exports = SSHBuffer;
 
var assert = require('assert-plus');
var Buffer = require('safer-buffer').Buffer;
 
function SSHBuffer(opts) {
    assert.object(opts, 'options');
    if (opts.buffer !== undefined)
        assert.buffer(opts.buffer, 'options.buffer');
 
    this._size = opts.buffer ? opts.buffer.length : 1024;
    this._buffer = opts.buffer || Buffer.alloc(this._size);
    this._offset = 0;
}
 
SSHBuffer.prototype.toBuffer = function () {
    return (this._buffer.slice(0, this._offset));
};
 
SSHBuffer.prototype.atEnd = function () {
    return (this._offset >= this._buffer.length);
};
 
SSHBuffer.prototype.remainder = function () {
    return (this._buffer.slice(this._offset));
};
 
SSHBuffer.prototype.skip = function (n) {
    this._offset += n;
};
 
SSHBuffer.prototype.expand = function () {
    this._size *= 2;
    var buf = Buffer.alloc(this._size);
    this._buffer.copy(buf, 0);
    this._buffer = buf;
};
 
SSHBuffer.prototype.readPart = function () {
    return ({data: this.readBuffer()});
};
 
SSHBuffer.prototype.readBuffer = function () {
    var len = this._buffer.readUInt32BE(this._offset);
    this._offset += 4;
    assert.ok(this._offset + len <= this._buffer.length,
        'length out of bounds at +0x' + this._offset.toString(16) +
        ' (data truncated?)');
    var buf = this._buffer.slice(this._offset, this._offset + len);
    this._offset += len;
    return (buf);
};
 
SSHBuffer.prototype.readString = function () {
    return (this.readBuffer().toString());
};
 
SSHBuffer.prototype.readCString = function () {
    var offset = this._offset;
    while (offset < this._buffer.length &&
        this._buffer[offset] !== 0x00)
        offset++;
    assert.ok(offset < this._buffer.length, 'c string does not terminate');
    var str = this._buffer.slice(this._offset, offset).toString();
    this._offset = offset + 1;
    return (str);
};
 
SSHBuffer.prototype.readInt = function () {
    var v = this._buffer.readUInt32BE(this._offset);
    this._offset += 4;
    return (v);
};
 
SSHBuffer.prototype.readInt64 = function () {
    assert.ok(this._offset + 8 < this._buffer.length,
        'buffer not long enough to read Int64');
    var v = this._buffer.slice(this._offset, this._offset + 8);
    this._offset += 8;
    return (v);
};
 
SSHBuffer.prototype.readChar = function () {
    var v = this._buffer[this._offset++];
    return (v);
};
 
SSHBuffer.prototype.writeBuffer = function (buf) {
    while (this._offset + 4 + buf.length > this._size)
        this.expand();
    this._buffer.writeUInt32BE(buf.length, this._offset);
    this._offset += 4;
    buf.copy(this._buffer, this._offset);
    this._offset += buf.length;
};
 
SSHBuffer.prototype.writeString = function (str) {
    this.writeBuffer(Buffer.from(str, 'utf8'));
};
 
SSHBuffer.prototype.writeCString = function (str) {
    while (this._offset + 1 + str.length > this._size)
        this.expand();
    this._buffer.write(str, this._offset);
    this._offset += str.length;
    this._buffer[this._offset++] = 0;
};
 
SSHBuffer.prototype.writeInt = function (v) {
    while (this._offset + 4 > this._size)
        this.expand();
    this._buffer.writeUInt32BE(v, this._offset);
    this._offset += 4;
};
 
SSHBuffer.prototype.writeInt64 = function (v) {
    assert.buffer(v, 'value');
    if (v.length > 8) {
        var lead = v.slice(0, v.length - 8);
        for (var i = 0; i < lead.length; ++i) {
            assert.strictEqual(lead[i], 0,
                'must fit in 64 bits of precision');
        }
        v = v.slice(v.length - 8, v.length);
    }
    while (this._offset + 8 > this._size)
        this.expand();
    v.copy(this._buffer, this._offset);
    this._offset += 8;
};
 
SSHBuffer.prototype.writeChar = function (v) {
    while (this._offset + 1 > this._size)
        this.expand();
    this._buffer[this._offset++] = v;
};
 
SSHBuffer.prototype.writePart = function (p) {
    this.writeBuffer(p.data);
};
 
SSHBuffer.prototype.write = function (buf) {
    while (this._offset + buf.length > this._size)
        this.expand();
    buf.copy(this._buffer, this._offset);
    this._offset += buf.length;
};