parse_web_socket_frame: use $wsbuf_ref directly, so that we really consume data
[pve-client.git] / PVE / APIClient / Commands / lxc.pm
1 package PVE::APIClient::Commands::lxc;
2
3 use strict;
4 use warnings;
5 use JSON;
6 use URI::Escape;
7 use IO::Select;
8 use IO::Socket::SSL;
9 use MIME::Base64;
10 use Digest::SHA;
11 use HTTP::Response;
12
13 use PVE::Tools;
14 use PVE::JSONSchema qw(get_standard_option);
15 use PVE::CLIHandler;
16 use PVE::PTY;
17
18 use base qw(PVE::CLIHandler);
19 use PVE::APIClient::Config;
20
21 my $CRLF = "\x0D\x0A";
22 my $max_payload_size = 65536;
23
24 my $build_web_socket_request = sub {
25     my ($host, $path, $ticket, $termproxy) = @_;
26
27     my $key = '';
28     $key .= chr(int(rand(256))) for 1 .. 16;
29     my $enckey = MIME::Base64::encode_base64($key, '');
30
31     my $encticket = uri_escape($ticket);
32     my $cookie = "PVEAuthCookie=$encticket; path=/; secure;";
33
34     $path .= "?port=$termproxy->{port}" .
35         "&vncticket=" . uri_escape($termproxy->{ticket});
36
37     my $request = "GET $path HTTP/1.1$CRLF"
38         . "Upgrade: WebSocket$CRLF"
39         . "Connection: Upgrade$CRLF"
40         . "Host: $host$CRLF"
41         . "Sec-WebSocket-Key: $enckey$CRLF"
42         . "Sec-WebSocket-Version: 13$CRLF"
43         . "Sec-WebSocket-Protocol: binary$CRLF"
44         . "Cookie: $cookie$CRLF"
45         . "$CRLF";
46
47     return ($request, $enckey);
48 };
49
50 my $create_websockt_frame = sub {
51     my ($payload) = @_;
52
53     my $string = "\x82"; # binary frame
54     my $payload_len = length($payload);
55     if ($payload_len <= 125) {
56         $string .= pack 'C', $payload_len | 128;
57     } elsif ($payload_len <= 0xffff) {
58         $string .= pack 'C', 126 | 128;
59         $string .= pack 'n', $payload_len;
60     } else {
61         $string .= pack 'C', 127 | 128;
62         $string .= pack 'Q>', $payload_len;
63     }
64
65     $string .= pack 'N', 0; # we simply use 0 as mask
66     $string .= $payload;
67
68     return $string;
69 };
70
71 my $parse_web_socket_frame = sub  {
72     my ($wsbuf_ref) = @_;
73
74     my $payload;
75     my $req_close = 0;
76
77     while (my $len = length($$wsbuf_ref)) {
78         last if $len < 2;
79
80         my $hdr = unpack('C', substr($$wsbuf_ref, 0, 1));
81         my $opcode = $hdr & 0b00001111;
82         my $fin = $hdr & 0b10000000;
83
84         die "received fragmented websocket frame\n" if !$fin;
85
86         my $rsv = $hdr & 0b01110000;
87         die "received websocket frame with RSV flags\n" if $rsv;
88
89         my $payload_len = unpack 'C', substr($$wsbuf_ref, 1, 1);
90
91         my $masked = $payload_len & 0b10000000;
92         die "received masked websocket frame from server\n" if $masked;
93
94         my $offset = 2;
95         $payload_len = $payload_len & 0b01111111;
96         if ($payload_len == 126) {
97             last if $len < 4;
98             $payload_len = unpack('n', substr($$wsbuf_ref, $offset, 2));
99             $offset += 2;
100         } elsif ($payload_len == 127) {
101             last if $len < 10;
102             $payload_len = unpack('Q>', substr($$wsbuf_ref, $offset, 8));
103             $offset += 8;
104         }
105
106         die "received too large websocket frame (len = $payload_len)\n"
107             if ($payload_len > $max_payload_size) || ($payload_len < 0);
108
109         last if $len < ($offset + $payload_len);
110
111         my $data = substr($$wsbuf_ref, 0, $offset + $payload_len, ''); # now consume data
112
113         my $frame_data = substr($data, $offset, $payload_len);
114
115         $payload = '' if !defined($payload);
116         $payload .= $frame_data;
117
118         if ($opcode == 1 || $opcode == 2) {
119             # continue
120         } elsif ($opcode == 8) {
121             my $statuscode = unpack ("n", $frame_data);
122             $req_close = 1;
123         } else {
124             die "received unhandled websocket opcode $opcode\n";
125         }
126     }
127
128     return ($payload, $req_close);
129 };
130
131 my $client_exit = sub {
132     my ($select, $web_socket, $old_termios) = @_;
133
134     foreach my $fh ($select->handles) {
135         $select->remove($fh);
136
137         if ($fh == $web_socket) {
138             if ($fh->connected) {
139
140                 # close connection
141                 # Opcode, mask, statuscode
142                 my $msg = "\x88" . pack('N', 0) . pack('n', 0);
143                 $fh->syswrite($msg);
144                 close($fh);
145             }
146         }
147
148     }
149
150     # switch back to blocking mode (else later shell commands will fail).
151     STDIN->blocking(1);
152
153     #
154     # Reset the terminal parameters.
155     #
156     print "\e[24H\r\n";
157     PVE::PTY::tcsetattr(*STDIN, $old_termios);
158 };
159
160 __PACKAGE__->register_method ({
161     name => 'enter',
162     path => 'enter',
163     method => 'POST',
164     description => "Enter container console.",
165     parameters => {
166         additionalProperties => 0,
167         properties => {
168             remote => get_standard_option('pveclient-remote-name'),
169             vmid => {
170                 description => "The container ID",
171                 type => 'string',
172             },
173         },
174     },
175     returns => { type => 'null'},
176     code => sub {
177         my ($param) = @_;
178
179         my $config = PVE::APIClient::Config->load();
180         my $conn = PVE::APIClient::Config->remote_conn($config, $param->{remote});
181
182         # Get the real node from the resources endpoint
183         my $resource_list = $conn->get("api2/json/cluster/resources", { type => 'vm'});
184         my ($resource) = grep { $_->{type} eq "lxc" && $_->{vmid} eq $param->{vmid}} @$resource_list;
185
186         die "container '$param->{vmid}' does not exist\n"
187             if !(defined($resource) && defined($resource->{node}));
188
189         my $node = $resource->{node};
190
191         my $api_path = "api2/json/nodes/$node/lxc/$param->{vmid}";
192
193         my $termproxy = $conn->post("${api_path}/termproxy", {});
194
195         my $web_socket =  IO::Socket::SSL->new(
196             PeerHost => $conn->{host},
197             PeerPort => $conn->{port},
198             SSL_verify_mode => SSL_VERIFY_NONE, # fixme: ???
199             timeout => 30) ||
200             die "failed to connect: $!\n";
201
202         # WebSocket Handshake
203
204         my ($request, $wskey) = $build_web_socket_request->(
205             $conn->{host}, "/$api_path/vncwebsocket", $conn->{ticket}, $termproxy);
206
207         $web_socket->syswrite($request);
208
209         my $wsbuf = '';
210
211         my $wb_socket_read_available_bytes = sub {
212             my $nr = $web_socket->sysread($wsbuf, $max_payload_size, length($wsbuf));
213             die "web socket read error - $!\n" if $nr < 0;
214             return $nr;
215         };
216
217         my $raw_response = '';
218
219         while(1) {
220             my $nr = $wb_socket_read_available_bytes->();
221             if ($wsbuf =~ s/^(.*?)$CRLF$CRLF//s) {
222                 $raw_response = $1;
223                 last;
224             }
225             last if !$nr;
226         };
227
228         # Note: we keep any remaining data in $wsbuf
229
230         my $response = HTTP::Response->parse($raw_response);
231
232         # Note: Digest::SHA::sha1_base64 has wrong padding
233         my $wsaccept = Digest::SHA::sha1_base64("${wskey}258EAFA5-E914-47DA-95CA-C5AB0DC85B11") . "=";
234
235         die "got invalid websocket reponse: $raw_response\n"
236             if !(($response->code == 101) &&
237                  (lc $response->header('connection') eq 'upgrade') &&
238                  (lc $response->header('upgrade') eq 'websocket') &&
239                  ($response->header('sec-websocket-protocol') eq 'binary') &&
240                  ($response->header('sec-websocket-accept') eq $wsaccept));
241
242         # send auth again...
243         my $frame = $create_websockt_frame->($termproxy->{user} . ":" . $termproxy->{ticket} . "\n");
244         $web_socket->syswrite($frame);
245
246         # Send resize command
247         my ($columns, $rows) = PVE::PTY::tcgetsize(*STDIN);
248         $frame = $create_websockt_frame->("1:$columns:$rows:");
249         $web_socket->syswrite($frame);
250
251         # Set STDIN to "raw -echo" mode
252         my $old_termios = PVE::PTY::tcgetattr(*STDIN);
253         my $raw_termios = {%$old_termios};
254         PVE::PTY::cfmakeraw($raw_termios);
255         PVE::PTY::tcsetattr(*STDIN, $raw_termios);
256
257         # And set it to non-blocking so we can every char with IO::Select.
258         STDIN->blocking(0);
259
260         my $select = IO::Select->new;
261
262         $web_socket->blocking(0);
263         $select->add($web_socket);
264         $select->add(fileno(STDIN));
265
266         my @messages;
267         my $ctrl_a_pressed_before = 0;
268         my $next_ping = time() + 3;
269
270         eval {
271             while (1) {
272                 # Ping server every 3 seconds.
273                 my $now = time();
274                 if ($now >= $next_ping) {
275                     push(@messages, $create_websockt_frame->("2"));
276                     $next_ping = $now + 3;
277                 }
278
279                 # Write
280                 foreach my $fh ($select->can_write(0.5)) {
281                     if ($fh == $web_socket and my $msg = shift @messages) {
282                         $fh->syswrite($msg, length($msg));
283                     }
284                 }
285
286                 # Read
287                 foreach my $fh ($select->can_read(0.5)) {
288
289                     # From Web Socket
290                     if ($fh == $web_socket) {
291                         # Read from WebSocket
292                         my $nr = $wb_socket_read_available_bytes->();
293                         my ($payload, $req_close) = $parse_web_socket_frame->(\$wsbuf);
294
295                         if ($payload ne "OK") {
296                             syswrite(\*STDOUT, $payload, length($payload));
297                         }
298                     }
299
300                     # From STDIN
301                     elsif ($fh == fileno(STDIN)) {
302
303                         # Read from STDIN
304                         my $nr = read(\*STDIN, my $buff, 4096);
305                         if (!$nr) {
306                             next;
307                         }
308
309                         my $char = ord($buff);
310
311                         if ($ctrl_a_pressed_before == 1 && $char == hex("0x71")) {
312                             $client_exit->($select, $web_socket, $old_termios);
313                             return;
314                         }
315
316                         if ($char == hex("0x01")) {
317                             if ($ctrl_a_pressed_before == 0) {
318                                 $ctrl_a_pressed_before = 1;
319                             }
320                         }
321                         else {
322                             $ctrl_a_pressed_before = 0;
323                         }
324
325                         push(@messages, $create_websockt_frame->("0:" . $nr . ":" . $buff));
326                     }
327                 }
328             }
329         };
330         print "ERROR: " . $@ . ".\n" if $@;
331
332         $client_exit->($select, $web_socket, $old_termios);
333
334         return undef
335     }});
336
337 __PACKAGE__->register_method ({
338     name => 'list',
339     path => 'list',
340     method => 'GET',
341     description => "List containers.",
342     parameters => {
343         additionalProperties => 0,
344         properties => {
345             remote => get_standard_option('pveclient-remote-name'),
346         },
347     },
348     returns => { type => 'null'},
349     code => sub {
350         my ($param) = @_;
351
352         die "implement me";
353
354     }});
355
356
357 our $cmddef = {
358     enter => [ __PACKAGE__, 'enter', ['remote', 'vmid']],
359     list => [ __PACKAGE__, 'list', ['remote']],
360 };
361
362 1;