扭曲服务器，数控客户端

Question

我将用一个小例子来演示我面临的问题。

class TestProtocol(basic.LineReceiver):
    def lineReceived(self, line):
        print line

只要我使用 telnet 客户端连接到服务器，一切都正常。但是，线路未接收连接并使用netcat发送数据。我有一种感觉，这与扭曲中的默认分隔符“\r\n”有关。

我如何制作一个服务器，以便客户端（telnet 和 nc）在连接到客户端时以相似的方式运行？

Answer 1

LineReceiver 仅支持一个分隔符。您可以指定它，但一次只能有一个。一般来说，如果您想支持多个分隔符，您需要实现一个支持它的新协议。您可以查看 LineReceiver 的实现，了解有关如何实现基于线路的协议的一些想法。

netcat 发送您输入的任何内容，因此分隔符通常是 \n （但它可能因平台和终端仿真器而异）。对于 \n 的特殊情况（它是默认 LineReceiver 分隔符 \r\n 的子字符串），您还可以使用另一个技巧。将 TestProtocol.delimiter 设置为 "\n"，然后从传递给 的行末尾去除 "\r" lineReceived（如果有）。

class TestProtocol(basic.LineReceiver):
    delimiter = "\n"

    def lineReceived(self, line):
        print line.rstrip("\r")

Answer 2

另一种解决方法是将 nc 与 -C 开关结合使用。

来自手册：

-C 发送 CRLF 作为行尾

或按照 @CraigMcQueen 建议：

带有 -c 开关的套接字 (Ubuntu 软件包）。

Answer 3

Twisted 的 LineReceiver 和 LineOnlyReceiver 仅支持一个行结束分隔符。

以下是 UniversalLineReceiver 和 UniversalLineOnlyReceiver 的代码，它们重写了 dataReceived() 方法，支持通用行结尾（CR+LF 的任意组合， CR 或 LF）。使用正则表达式对象 delimiter_re 检测换行符。

请注意，它们用比我想要的更多的代码覆盖函数，因此如果底层 Twisted 实现发生更改，它们可能会中断。我已经测试过它们可以与 Twisted 13.2.0 配合使用。本质的变化是使用 delimiter_re。split() 来自 re 模块。

# Standard Python packages
import re

# Twisted framework
from twisted.protocols.basic import LineReceiver, LineOnlyReceiver

class UniversalLineReceiver(LineReceiver):
    delimiter_re = re.compile(br"\r\n|\r|\n")
    def dataReceived(self, data):
        """
        Protocol.dataReceived.
        Translates bytes into lines, and calls lineReceived (or
        rawDataReceived, depending on mode.)
        """
        if self._busyReceiving:
            self._buffer += data
            return

        try:
            self._busyReceiving = True
            self._buffer += data
            while self._buffer and not self.paused:
                if self.line_mode:
                    try:
                        line, remainder = self.delimiter_re.split(self._buffer, 1)
                    except ValueError:
                        if len(self._buffer) > self.MAX_LENGTH:
                            line, self._buffer = self._buffer, b''
                            return self.lineLengthExceeded(line)
                        return
                    else:
                        lineLength = len(line)
                        if lineLength > self.MAX_LENGTH:
                            exceeded = self._buffer
                            self._buffer = b''
                            return self.lineLengthExceeded(exceeded)
                        self._buffer = remainder
                        why = self.lineReceived(line)
                        if (why or self.transport and
                            self.transport.disconnecting):
                            return why
                else:
                    data = self._buffer
                    self._buffer = b''
                    why = self.rawDataReceived(data)
                    if why:
                        return why
        finally:
            self._busyReceiving = False

class UniversalLineOnlyReceiver(LineOnlyReceiver):
    delimiter_re = re.compile(br"\r\n|\r|\n")
    def dataReceived(self, data):
        """
        Translates bytes into lines, and calls lineReceived.
        """
        lines = self.delimiter_re.split(self._buffer+data)
        self._buffer = lines.pop(-1)
        for line in lines:
            if self.transport.disconnecting:
                # this is necessary because the transport may be told to lose
                # the connection by a line within a larger packet, and it is
                # important to disregard all the lines in that packet following
                # the one that told it to close.
                return
            if len(line) > self.MAX_LENGTH:
                return self.lineLengthExceeded(line)
            else:
                self.lineReceived(line)
        if len(self._buffer) > self.MAX_LENGTH:
            return self.lineLengthExceeded(self._buffer)