Repository navigation
Expand file tree
/
Copy pathProxyBroker.dart
More file actions
267 lines (190 loc) · 8.18 KB
/
Copy pathProxyBroker.dart
File metadata and controls
267 lines (190 loc) · 8.18 KB
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
import 'dart:core';
import 'dart:async';
import 'dart:io';
import 'Protocol.dart';
class ProxyBroker {
ServerSocket mainSocket;
Map workers = {};
List usedForwardingPorts = [];
bool start(port, {Function onDone, Function onError}) {
if (onDone == null) {
onDone = () => print('server started on port $port');
}
if (onError == null) {
onError = () => print('error stopping server');
}
// request the OS to bind a new socket to the specified port
ServerSocket.bind('0.0.0.0', port).then((ServerSocket server) {
mainSocket = server;
// listen for incoming connections
mainSocket.listen((Socket controlSocket) {
var workerId;
controlSocket.done.then((socket) {
print('control socket for worker: $workerId fully disconnected');
}).catchError((error) {
print('error in controlSocket for worker: $workerId');
});
// listen for incoming data
controlSocket.listen((List<int> data) {
print('incoming ${data.length} bytes on main socket');
Map msg = parseProtocolMsg(data);
if (msg == null) {
print('invalid msg, closing connection');
controlSocket.close();
return;
} else if (msg['version'] == 0xff && msg['cmdCode'] == CMD_REGISTER_WORKER) {
// The port received from the worker in the register will be
// used as worker id: The broker will open that port, and all
// data comming to it will be forwarded to that worker
print('new worker requesting to listen at port: ${msg['port']}');
if (workers.containsKey(msg['port'])) {
var resp = buildRegisterRejectedResponse(msg['port']);
print('error, a worker has already been registered for that port');
controlSocket.add(resp);
// TODO: close connection here? or wait for another msg?
// controlSocket.close();
return;
}
workerId = msg['port'];
workers[workerId] = {'controlSocket': controlSocket,
'forwardingSockets': [],
'browserSockets': [],
'proxySocket': null};
// open the workerId port and listen (connections to that port will be forwarded to the worker)
ServerSocket.bind('0.0.0.0', workerId).then((ServerSocket server) {
print('worker listening at port: $workerId');
workers[workerId]['proxySocket'] = server;
// wait for new client requesting a connection
server.listen((Socket browserSocket) {
print('new client for proxyPort $workerId');
// save socket to close it later
workers[workerId]['browserSockets'].add(browserSocket);
browserSocket.done.catchError((error) => print('error on browserSocket for workerId: $workerId, : $error'));
// request a forwarding connection to the worker
requestForwardingConn(workerId, onDone: (workerForwSocket) {
// listen browserSocket for incoming data and forward it to the worker
browserSocket.listen((List<int> data) {
print('${data.length} bytes of data received from browser in port $workerId, forwarding them to the worker');
try {
workerForwSocket.add(data);
} on SocketException {
print('socket exception while adding data');
} catch (e) {
print('caught exception while adding data to socket: $e');
}
}, onError: (e) {
print('error listening from browserSocket: $e');
if (e.osError.errorCode == 104) {
// Connection reset by peer, errno = 104
print('connection reset by peer, closing socket');
browserSocket.close();
}
});
// listen workerSocket for incoming data and forward it to the browser
workerForwSocket.listen((List<int> data) {
print('${data.length} bytes of data received from worker, sending it back to the browser');
try {
browserSocket.add(data);
} on SocketException {
print('socket exception while adding data');
} catch (e) {
print('caught exception while adding data to socket: $e');
}
}, onError: (e) => print('error listening from workerForwSocket: $e'));
});
}, onError: (error) => print('error while listening for connections in proxy socket for workerId: $workerId. Error: $error'));
}, onError: (error) => print('error binding socket for workerId: $workerId. Error: $error'));
// send register success msg to the worker
var resp = buildRegisterSuccessResponse(workerId);
controlSocket.add(resp);
}
}, onDone: () {
// worker controlSocket closed
print('closed controlSocket for worker $workerId');
removeWorker(workerId);
}, onError: (error) {
print('error on listen() for incoming data on controlSocket, workerId: $workerId');
removeWorker(workerId);
});
}, onError: (error) => print('error while listening for connections in main socket'));
onDone();
}).catchError((error) => onError());
return true;
}
int chooseNewForwardingPort() {
const BASE_PORT = 7000;
for (var i=0 ; i<=1000; i++) {
var chosenPort = BASE_PORT + i;
if (!usedForwardingPorts.contains(chosenPort)) {
return chosenPort;
}
}
return -1;
}
void requestForwardingConn(workerId, {Function(Socket) onDone}) {
if (!workers.containsKey(workerId)) {
print('there is no worker with id: $workerId');
return;
}
var worker = workers[workerId];
var newPort = chooseNewForwardingPort();
usedForwardingPorts.add(newPort);
print('opening port $newPort to wait the worker to make the reverse connection');
// open random port and wait for worker to make the reverse connection
ServerSocket.bind('0.0.0.0', newPort).then((ServerSocket server) {
// listen for incoming connections
server.listen((Socket workerForwSocket) {
print('forwarding connection stablished!');
// close the server (only accept the first connection)
server.close();
usedForwardingPorts.remove(newPort);
// save the socket to close it later
worker['forwardingSockets'].add(workerForwSocket);
onDone(workerForwSocket);
});
// send request to the worker to ask him to connect the given port
var msg = buildOpenForwardingMsg(newPort);
worker['controlSocket'].add(msg);
});
}
void removeWorker(int workerId) {
print('removing worker: $workerId');
if (!workers.containsKey(workerId)) {
print('error: worker with id: $workerId does not exist, unable to remove it');
return;
}
var worker = workers[workerId];
worker['controlSocket'].destroy();
worker['proxySocket'].close();
for (var socket in worker['forwardingSockets']) {
socket.destroy();
}
for (var socket in worker['browserSockets']) {
socket.destroy();
}
workers.remove(workerId);
}
void stop({Function onDone, Function onError}) {
print('stopping server');
if (onDone == null) {
onError = () => print('server stopped');
}
if (onError == null) {
onError = () => print('error stopping server');
}
var workerIds = workers.keys.toList();
for (var workerId in workerIds) {
removeWorker(workerId);
}
mainSocket.close()
.then((socket) => onDone())
.catchError((error) => onError());
}
}
void main() async {
var server = new ProxyBroker();
server.start(9999);
// wait 5 seconds
await new Future.delayed(const Duration(seconds : 5));
// server.stop();
}