ExternalVendorCode/gns3-server
1
0
Fork 0
mirror of https://github.com/GNS3/gns3-server.git synced 2024-12-18 20:37:57 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Support for serial console for Virtual BOX and VMware using asyncio

Browse Source 
Ref #747
This commit is contained in:
Julien Duponchelle 2016-11-07 11:16:51 +01:00
parent 3c5cbebfb4
commit 553e137a13
No known key found for this signature in database
GPG Key ID: CE8B29639E07F5E8
9 changed files with 198 additions and 565 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,4 +1,5 @@
*.py[cod]
__pycache__
#py.test
.cache

5
gns3server/compute/project.py
View File

@ -24,7 +24,7 @@ import zipstream
import zipfile
import json
from uuid import UUID
from uuid import UUID, uuid4
from .port_manager import PortManager
from .notification_manager import NotificationManager
from ..config import Config
@ -49,10 +49,13 @@ class Project:
def __init__(self, name=None, project_id=None, path=None):
self._name = name
if project_id:
try:
UUID(project_id, version=4)
except ValueError:
raise aiohttp.web.HTTPBadRequest(text="{} is not a valid UUID".format(project_id))
else:
project_id = str(uuid4())
self._id = project_id
self._nodes = set()

77
gns3server/compute/virtualbox/virtualbox_vm.py
View File

@ -30,12 +30,13 @@ import asyncio
import xml.etree.ElementTree as ET
from gns3server.utils import parse_version
from gns3server.utils.telnet_server import TelnetServer
from gns3server.utils.asyncio import wait_for_file_creation, wait_for_named_pipe_creation, locked_coroutine
from .virtualbox_error import VirtualBoxError
from ..nios.nio_udp import NIOUDP
from ..adapters.ethernet_adapter import EthernetAdapter
from ..base_node import BaseNode
from gns3server.utils.asyncio.telnet_server import AsyncioTelnetServer
from gns3server.utils.asyncio.serial import asyncio_open_serial
from gns3server.utils.asyncio import locked_coroutine
from gns3server.compute.virtualbox.virtualbox_error import VirtualBoxError
from gns3server.compute.nios.nio_udp import NIOUDP
from gns3server.compute.adapters.ethernet_adapter import EthernetAdapter
from gns3server.compute.base_node import BaseNode
if sys.platform.startswith('win'):
import msvcrt
@ -53,12 +54,11 @@ class VirtualBoxVM(BaseNode):
def __init__(self, name, node_id, project, manager, vmname, linked_clone=False, console=None, adapters=0):
super().__init__(name, node_id, project, manager, console=console, linked_clone=linked_clone)
super().__init__(name, node_id, project, manager, console=console, linked_clone=linked_clone, console_type="telnet")
self._maximum_adapters = 8
self._system_properties = {}
self._telnet_server_thread = None
self._serial_pipe = None
self._telnet_server = None
self._local_udp_tunnels = {}
# VirtualBox settings
@ -81,6 +81,7 @@ class VirtualBoxVM(BaseNode):
json = {"name": self.name,
"node_id": self.id,
"console": self.console,
"console_type": self.console_type,
"project_id": self.project.id,
"vmname": self.vmname,
"headless": self.headless,
@ -243,16 +244,7 @@ class VirtualBoxVM(BaseNode):
self._local_udp_tunnels[adapter_number][1],
nio)
if self._console is not None:
try:
# wait for VirtualBox to create the pipe file.
if sys.platform.startswith("win"):
yield from wait_for_named_pipe_creation(self._get_pipe_name())
else:
yield from wait_for_file_creation(self._get_pipe_name())
except asyncio.TimeoutError:
raise VirtualBoxError('Pipe file "{}" for remote console has not been created by VirtualBox'.format(self._get_pipe_name()))
self._start_remote_console()
yield from self._start_console()
if (yield from self.check_hw_virtualization()):
self._hw_virtualization = True
@ -874,54 +866,21 @@ class VirtualBoxVM(BaseNode):
os.makedirs(os.path.join(self.working_dir, self._vmname), exist_ok=True)
def _start_remote_console(self):
@asyncio.coroutine
def _start_console(self):
"""
Starts remote console support for this VM.
"""
# starts the Telnet to pipe thread
pipe_name = self._get_pipe_name()
if sys.platform.startswith("win"):
try:
self._serial_pipe = open(pipe_name, "a+b")
except OSError as e:
raise VirtualBoxError("Could not open the pipe {}: {}".format(pipe_name, e))
try:
self._telnet_server_thread = TelnetServer(self._vmname, msvcrt.get_osfhandle(self._serial_pipe.fileno()), self._manager.port_manager.console_host, self._console)
except OSError as e:
raise VirtualBoxError("Unable to create Telnet server: {}".format(e))
self._telnet_server_thread.start()
else:
try:
self._serial_pipe = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self._serial_pipe.connect(pipe_name)
except OSError as e:
raise VirtualBoxError("Could not connect to the pipe {}: {}".format(pipe_name, e))
try:
self._telnet_server_thread = TelnetServer(self._vmname, self._serial_pipe, self._manager.port_manager.console_host, self._console)
except OSError as e:
raise VirtualBoxError("Unable to create Telnet server: {}".format(e))
self._telnet_server_thread.start()
pipe = yield from asyncio_open_serial(self._get_pipe_name())
server = AsyncioTelnetServer(reader=pipe, writer=pipe, binary=True, echo=True)
self._telnet_server = yield from asyncio.start_server(server.run, '127.0.0.1', self.console)
def _stop_remote_console(self):
"""
Stops remote console support for this VM.
"""
if self._telnet_server_thread:
if self._telnet_server_thread.is_alive():
self._telnet_server_thread.stop()
self._telnet_server_thread.join(timeout=3)
if self._telnet_server_thread.is_alive():
log.warn("Serial pipe thread is still alive!")
self._telnet_server_thread = None
if self._serial_pipe:
if sys.platform.startswith("win"):
win32file.CloseHandle(msvcrt.get_osfhandle(self._serial_pipe.fileno()))
else:
self._serial_pipe.close()
self._serial_pipe = None
if self._telnet_server:
self._telnet_server.close()
@asyncio.coroutine
def adapter_add_nio_binding(self, adapter_number, nio):

72
gns3server/compute/vmware/vmware_vm.py
View File

@ -25,18 +25,16 @@ import socket
import asyncio
import tempfile
from gns3server.utils.telnet_server import TelnetServer
from gns3server.utils.interfaces import interfaces
from gns3server.utils.asyncio import wait_for_file_creation, wait_for_named_pipe_creation, locked_coroutine
from gns3server.utils.asyncio.telnet_server import AsyncioTelnetServer
from gns3server.utils.asyncio.serial import asyncio_open_serial
from gns3server.utils.asyncio import locked_coroutine
from collections import OrderedDict
from .vmware_error import VMwareError
from ..nios.nio_udp import NIOUDP
from ..adapters.ethernet_adapter import EthernetAdapter
from ..base_node import BaseNode
if sys.platform.startswith('win'):
import msvcrt
import win32file
import logging
log = logging.getLogger(__name__)
@ -53,8 +51,7 @@ class VMwareVM(BaseNode):
super().__init__(name, node_id, project, manager, console=console, linked_clone=linked_clone)
self._vmx_pairs = OrderedDict()
self._telnet_server_thread = None
self._serial_pipe = None
self._telnet_server = None
self._vmnets = []
self._maximum_adapters = 10
self._started = False
@ -82,6 +79,7 @@ class VMwareVM(BaseNode):
json = {"name": self.name,
"node_id": self.id,
"console": self.console,
"console_type": self.console_type,
"project_id": self.project.id,
"vmx_path": self.vmx_path,
"headless": self.headless,
@ -440,15 +438,7 @@ class VMwareVM(BaseNode):
if nio:
yield from self._add_ubridge_connection(nio, adapter_number)
# if self._console is not None:
# try:
# if sys.platform.startswith("win"):
# yield from wait_for_named_pipe_creation(self._get_pipe_name())
# else:
# yield from wait_for_file_creation(self._get_pipe_name()) # wait for VMware to create the pipe file.
# except asyncio.TimeoutError:
# raise VMwareError('Pipe file "{}" for remote console has not been created by VMware'.format(self._get_pipe_name()))
# self._start_remote_console()
yield from self._start_console()
except VMwareError:
yield from self.stop()
raise
@ -797,57 +787,25 @@ class VMwareVM(BaseNode):
serial_port = {"serial0.present": "TRUE",
"serial0.filetype": "pipe",
"serial0.filename": pipe_name,
"serial0.pipe.endpoint": "server"}
"serial0.pipe.endpoint": "server",
"serial0.startconnected": "TRUE"}
self._vmx_pairs.update(serial_port)
def _start_remote_console(self):
@asyncio.coroutine
def _start_console(self):
"""
Starts remote console support for this VM.
"""
# starts the Telnet to pipe thread
pipe_name = self._get_pipe_name()
if sys.platform.startswith("win"):
try:
self._serial_pipe = open(pipe_name, "a+b")
except OSError as e:
raise VMwareError("Could not open the pipe {}: {}".format(pipe_name, e))
try:
self._telnet_server_thread = TelnetServer(self.name, msvcrt.get_osfhandle(self._serial_pipe.fileno()), self._manager.port_manager.console_host, self._console)
except OSError as e:
raise VMwareError("Unable to create Telnet server: {}".format(e))
self._telnet_server_thread.start()
else:
try:
self._serial_pipe = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self._serial_pipe.connect(pipe_name)
except OSError as e:
raise VMwareError("Could not connect to the pipe {}: {}".format(pipe_name, e))
try:
self._telnet_server_thread = TelnetServer(self.name, self._serial_pipe, self._manager.port_manager.console_host, self._console)
except OSError as e:
raise VMwareError("Unable to create Telnet server: {}".format(e))
self._telnet_server_thread.start()
pipe = yield from asyncio_open_serial(self._get_pipe_name())
server = AsyncioTelnetServer(reader=pipe, writer=pipe, binary=True, echo=True)
self._telnet_server = yield from asyncio.start_server(server.run, '127.0.0.1', self.console)
def _stop_remote_console(self):
"""
Stops remote console support for this VM.
"""
if self._telnet_server_thread:
if self._telnet_server_thread.is_alive():
self._telnet_server_thread.stop()
self._telnet_server_thread.join(timeout=3)
if self._telnet_server_thread.is_alive():
log.warn("Serial pipe thread is still alive!")
self._telnet_server_thread = None
if self._serial_pipe:
if sys.platform.startswith("win"):
win32file.CloseHandle(msvcrt.get_osfhandle(self._serial_pipe.fileno()))
else:
self._serial_pipe.close()
self._serial_pipe = None
if self._telnet_server:
self._telnet_server.close()
@asyncio.coroutine
def start_capture(self, adapter_number, output_file):

8
gns3server/schemas/virtualbox.py
View File

@ -66,6 +66,10 @@ VBOX_CREATE_SCHEMA = {
"maximum": 65535,
"type": "integer"
},
"console_type": {
"description": "Console type",
"enum": ["telnet"]
},
"ram": {
"description": "Amount of RAM",
"minimum": 0,
@ -152,6 +156,10 @@ VBOX_OBJECT_SCHEMA = {
"maximum": 65535,
"type": "integer"
},
"console_type": {
"description": "Console type",
"enum": ["telnet"]
},
"ram": {
"description": "Amount of RAM",
"minimum": 0,

8
gns3server/schemas/vmware.py
View File

@ -48,6 +48,10 @@ VMWARE_CREATE_SCHEMA = {
"maximum": 65535,
"type": "integer"
},
"console_type": {
"description": "Console type",
"enum": ["telnet"]
},
"headless": {
"description": "Headless mode",
"type": "boolean"
@ -143,6 +147,10 @@ VMWARE_OBJECT_SCHEMA = {
"maximum": 65535,
"type": "integer"
},
"console_type": {
"description": "Console type",
"enum": ["telnet"]
},
"linked_clone": {
"description": "Whether the VM is a linked clone or not",
"type": "boolean"

137
gns3server/utils/asyncio/serial.py Normal file
View File

@ -0,0 +1,137 @@
#!/usr/bin/env python
#
# Copyright (C) 2016 GNS3 Technologies Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import sys
import asyncio
from gns3server.utils.asyncio import wait_for_file_creation, wait_for_named_pipe_creation
from gns3server.compute.error import NodeError
"""
This module handle connection to unix socket or Windows named pipe
"""
if sys.platform.startswith("win"):
import win32file
import win32pipe
import msvcrt
class SerialReaderWriterProtocol(asyncio.Protocol):
def __init__(self):
self._output = asyncio.StreamReader()
self.transport = None
def read(self, n=-1):
return self._output.read(n=n)
def at_eof(self):
return self._output.at_eof()
def write(self, data):
if self.transport:
self.transport.write(data)
@asyncio.coroutine
def drain(self):
pass
def connection_made(self, transport):
self.transport = transport
def data_received(self, data):
self._output.feed_data(data)
class WindowsPipe:
"""
Write input and output stream to the same object
"""
def __init__(self, path):
self._handle = open(path, "a+b")
self._pipe = msvcrt.get_osfhandle(self._handle.fileno())
@asyncio.coroutine
def read(self, n=-1):
(read, num_avail, num_message) = win32pipe.PeekNamedPipe(self._pipe, 0)
if num_avail > 0:
(error_code, output) = win32file.ReadFile(self._pipe, num_avail, None)
return output
yield from asyncio.sleep(0.01)
return b""
def at_eof(self):
return False
def write(self, data):
win32file.WriteFile(self._pipe, data)
@asyncio.coroutine
def drain(self):
return
def close(self):
pass
@asyncio.coroutine
def _asyncio_open_serial_windows(path):
"""
Open a windows named pipe
:returns: An IO like object
"""
try:
yield from wait_for_named_pipe_creation(path)
except asyncio.TimeoutError:
raise NodeError('Pipe file "{}" is missing'.format(path))
return WindowsPipe(path)
@asyncio.coroutine
def _asyncio_open_serial_unix(path):
"""
Open a unix socket or a windows named pipe
:returns: An IO like object
"""
try:
# wait for VM to create the pipe file.
yield from wait_for_file_creation(path)
except asyncio.TimeoutError:
raise NodeError('Pipe file "{}" is missing'.format(path))
output = SerialReaderWriterProtocol()
con = yield from asyncio.get_event_loop().create_unix_connection(lambda: output, path)
return output
@asyncio.coroutine
def asyncio_open_serial(path):
"""
Open a unix socket or a windows named pipe
:returns: An IO like object
"""
if sys.platform.startswith("win"):
return (yield from _asyncio_open_serial_windows(path))
else:
return (yield from _asyncio_open_serial_unix(path))

1
gns3server/utils/asyncio/telnet_server.py
View File

@ -245,6 +245,7 @@ class AsyncioTelnetServer:
log.debug("Unhandled DONT telnet command: "
"{0:#x} {1:#x} {2:#x}".format(*iac_cmd))
elif iac_cmd[1] == WILL:
if iac_cmd[2] not in [BINARY]:
log.debug("Unhandled WILL telnet command: "
"{0:#x} {1:#x} {2:#x}".format(*iac_cmd))
elif iac_cmd[1] == WONT:

442
gns3server/utils/telnet_server.py
View File

@ -1,442 +0,0 @@
# -*- coding: utf-8 -*-
#
# Copyright (C) 2014 GNS3 Technologies Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# TODO: port TelnetServer to asyncio
import sys
import time
import threading
import socket
import select
import logging
log = logging.getLogger(__name__)
if sys.platform.startswith("win"):
import win32pipe
import win32file
class TelnetServer(threading.Thread):
"""
Mini Telnet Server.
:param node_name: node name
:param pipe_path: path to node pipe (UNIX socket on Linux/UNIX, Named Pipe on Windows)
:param host: server host
:param port: server port
"""
def __init__(self, node_name, pipe_path, host, port):
threading.Thread.__init__(self)
self._node_name = node_name
self._pipe = pipe_path
self._host = host
self._port = port
self._reader_thread = None
self._use_thread = False
self._write_lock = threading.Lock()
self._clients = {}
self._timeout = 1
self._alive = True
if sys.platform.startswith("win"):
# we must a thread for reading the pipe on Windows because it is a Named Pipe and it cannot be monitored by select()
self._use_thread = True
for res in socket.getaddrinfo(host, port, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
af, socktype, proto, _, sa = res
self._server_socket = socket.socket(af, socktype, proto)
self._server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self._server_socket.bind(sa)
self._server_socket.listen(socket.SOMAXCONN)
break
log.info("Telnet server initialized, waiting for clients on {}:{}".format(self._host, self._port))
def run(self):
"""
Thread loop.
"""
while True:
recv_list = [self._server_socket.fileno()]
if not self._use_thread:
recv_list.append(self._pipe.fileno())
for client in self._clients.values():
if client.is_active():
recv_list.append(client.socket().fileno())
else:
del self._clients[client.socket().fileno()]
try:
client.socket().shutdown(socket.SHUT_RDWR)
except OSError as e:
log.warn("shutdown: {}".format(e))
client.socket().close()
break
try:
rlist, slist, elist = select.select(recv_list, [], [], self._timeout)
except OSError as e:
log.critical("fatal select error: {}".format(e))
return False
if not self._alive:
log.info("Telnet server for {} is exiting".format(self._node_name))
return True
for sock_fileno in rlist:
if sock_fileno == self._server_socket.fileno():
try:
sock, addr = self._server_socket.accept()
host, port = addr
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
log.info("new client {}:{} has connected".format(host, port))
except OSError as e:
log.error("could not accept new client: {}".format(e))
continue
new_client = TelnetClient(self._node_name, sock, host, port)
self._clients[sock.fileno()] = new_client
if self._use_thread and not self._reader_thread:
self._reader_thread = threading.Thread(target=self._reader, daemon=True)
self._reader_thread.start()
elif not self._use_thread and sock_fileno == self._pipe.fileno():
data = self._read_from_pipe()
if not data:
log.warning("pipe has been closed!")
return False
for client in self._clients.values():
try:
client.send(data)
except OSError as e:
log.debug(e)
client.deactivate()
elif sock_fileno in self._clients:
try:
data = self._clients[sock_fileno].socket_recv()
if not data:
continue
# For some reason, windows likes to send "cr/lf" when you send a "cr".
# Strip that so we don't get a double prompt.
data = data.replace(b"\r\n", b"\n")
self._write_to_pipe(data)
except Exception as msg:
log.info(msg)
self._clients[sock_fileno].deactivate()
def _write_to_pipe(self, data):
"""
Writes data to the pipe.
:param data: data to write
"""
if sys.platform.startswith('win'):
win32file.WriteFile(self._pipe, data)
else:
self._pipe.sendall(data)
def _read_from_pipe(self):
"""
Reads data from the pipe.
:returns: data
"""
if sys.platform.startswith('win'):
(read, num_avail, num_message) = win32pipe.PeekNamedPipe(self._pipe, 0)
if num_avail > 0:
(error_code, output) = win32file.ReadFile(self._pipe, num_avail, None)
return output
return b""
else:
return self._pipe.recv(1024)
def _reader(self):
"""
Loops forever and copy everything from the pipe to the socket.
"""
log.debug("reader thread has started")
while self._alive:
try:
data = self._read_from_pipe()
if not data and not sys.platform.startswith('win'):
log.debug("pipe has been closed! (no data)")
break
self._write_lock.acquire()
try:
for client in self._clients.values():
client.send(data)
finally:
self._write_lock.release()
if sys.platform.startswith('win'):
# sleep every 10 ms
time.sleep(0.01)
except Exception as e:
log.debug("pipe has been closed! {}".format(e))
break
log.debug("reader thread exited")
self.stop()
def stop(self):
"""
Stops the server.
"""
if self._alive:
self._alive = False
for client in self._clients.values():
client.socket().close()
client.deactivate()
# Mostly from https://code.google.com/p/miniboa/source/browse/trunk/miniboa/telnet.py
# Telnet Commands
SE = 240 # End of sub-negotiation parameters
NOP = 241 # No operation
DATMK = 242 # Data stream portion of a sync.
BREAK = 243 # NVT Character BRK
IP = 244 # Interrupt Process
AO = 245 # Abort Output
AYT = 246 # Are you there
EC = 247 # Erase Character
EL = 248 # Erase Line
GA = 249 # The Go Ahead Signal
SB = 250 # Sub-option to follow
WILL = 251 # Will; request or confirm option begin
WONT = 252 # Wont; deny option request
DO = 253 # Do = Request or confirm remote option
DONT = 254 # Don't = Demand or confirm option halt
IAC = 255 # Interpret as Command
SEND = 1 # Sub-process negotiation SEND command
IS = 0 # Sub-process negotiation IS command
# Telnet Options
BINARY = 0 # Transmit Binary
ECHO = 1 # Echo characters back to sender
RECON = 2 # Reconnection
SGA = 3 # Suppress Go-Ahead
TMARK = 6 # Timing Mark
TTYPE = 24 # Terminal Type
NAWS = 31 # Negotiate About Window Size
LINEMO = 34 # Line Mode
class TelnetClient(object):
"""
Represents a Telnet client connection.
:param node_name: Node name
:param sock: socket connection
:param host: IP of the Telnet client
:param port: port of the Telnet client
"""
def __init__(self, node_name, sock, host, port):
self._active = True
self._sock = sock
self._host = host
self._port = port
sock.send(bytes([IAC, WILL, ECHO,
IAC, WILL, SGA,
IAC, WILL, BINARY,
IAC, DO, BINARY]))
welcome_msg = "{} console is now available... Press RETURN to get started.\r\n".format(node_name)
sock.send(welcome_msg.encode('utf-8'))
def is_active(self):
"""
Returns either the client is active or not.
:return: boolean
"""
return self._active
def socket(self):
"""
Returns the socket for this Telnet client.
:returns: socket instance.
"""
return self._sock
def send(self, data):
"""
Sends data to the remote end.
:param data: data to send
"""
try:
self._sock.send(data)
except OSError as e:
self._active = False
raise Exception("Socket send: {}".format(e))
def deactivate(self):
"""
Sets the client to disconnect on the next server poll.
"""
self._active = False
def socket_recv(self):
"""
Called by Telnet Server when data is ready.
"""
try:
buf = self._sock.recv(1024)
except BlockingIOError:
return None
except ConnectionResetError:
buf = b''
# is the connection closed?
if not buf:
raise Exception("connection closed by {}:{}".format(self._host, self._port))
# Process and remove any telnet commands from the buffer
if IAC in buf:
buf = self._IAC_parser(buf)
return buf
def _read_block(self, bufsize):
"""
Reads a block for data from the socket.
:param bufsize: size of the buffer
:returns: data read
"""
buf = self._sock.recv(1024, socket.MSG_WAITALL)
# If we don't get everything we were looking for then the
# client probably disconnected.
if len(buf) < bufsize:
raise Exception("connection closed by {}:{}".format(self._host, self._port))
return buf
def _IAC_parser(self, buf):
"""
Processes and removes any Telnet commands from the buffer.
:param buf: buffer
:returns: buffer minus Telnet commands
"""
skip_to = 0
while self._active:
# Locate an IAC to process
iac_loc = buf.find(IAC, skip_to)
if iac_loc < 0:
break
# Get the TELNET command
iac_cmd = bytearray([IAC])
try:
iac_cmd.append(buf[iac_loc + 1])
except IndexError:
buf.extend(self._read_block(1))
iac_cmd.append(buf[iac_loc + 1])
# Is this just a 2-byte TELNET command?
if iac_cmd[1] not in [WILL, WONT, DO, DONT]:
if iac_cmd[1] == AYT:
log.debug("Telnet server received Are-You-There (AYT)")
self._sock.send(b'\r\nYour Are-You-There received. I am here.\r\n')
elif iac_cmd[1] == IAC:
# It's data, not an IAC
iac_cmd.pop()
# This prevents the 0xff from being
# interrupted as yet another IAC
skip_to = iac_loc + 1
log.debug("Received IAC IAC")
elif iac_cmd[1] == NOP:
pass
else:
log.debug("Unhandled telnet command: "
"{0:#x} {1:#x}".format(*iac_cmd))
# This must be a 3-byte TELNET command
else:
try:
iac_cmd.append(buf[iac_loc + 2])
except IndexError:
buf.extend(self._read_block(1))
iac_cmd.append(buf[iac_loc + 2])
# We do ECHO, SGA, and BINARY. Period.
if iac_cmd[1] == DO and iac_cmd[2] not in [ECHO, SGA, BINARY]:
self._sock.send(bytes([IAC, WONT, iac_cmd[2]]))
log.debug("Telnet WON'T {:#x}".format(iac_cmd[2]))
else:
log.debug("Unhandled telnet command: "
"{0:#x} {1:#x} {2:#x}".format(*iac_cmd))
# Remove the entire TELNET command from the buffer
buf = buf.replace(iac_cmd, b'', 1)
# Return the new copy of the buffer, minus telnet commands
return buf
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO)
if sys.platform.startswith('win'):
import msvcrt
pipe_name = r'\\.\pipe\VBOX\Linux_Microcore_4.7.1'
pipe = open(pipe_name, 'a+b')
telnet_server = TelnetServer("VBOX", msvcrt.get_osfhandle(pipe.fileno()), "127.0.0.1", 3900)
else:
pipe_name = "/tmp/pipe_test"
try:
unix_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
unix_socket.connect(pipe_name)
except OSError as e:
print("Could not connect to UNIX socket {}: {}".format(pipe_name, e))
sys.exit(False)
telnet_server = TelnetServer("VBOX", unix_socket, "127.0.0.1", 3900)
telnet_server.setDaemon(True)
telnet_server.start()
try:
telnet_server.join()
except KeyboardInterrupt:
telnet_server.stop()
telnet_server.join(timeout=3)