Sockets 通过LISP USOCKET接收数据

我想把数据传过去。当数据到达服务器时，服务器应该回复。但是，

流读取（定义如下）仅在与发送的原始数据进行回显时返回数据。例如，如果我发送
hello
并且服务器使用相同的数据进行回复，
hello
，则
流读取
返回，但如果服务器使用
hi
进行回复，
流读取
直到服务器发送其接收到的确切缓冲区后才会返回

代码如下：（我在网上找到了大部分。）

至于服务器，我使用的是boostblocking服务器示例的一个稍加修改的版本。（c++）完整的代码可以在这里找到：

。。。
无效会话（socket\u ptr sock）
{
尝试
{    
对于（；；）
{
字符数据[最大长度]；
boost:：system:：error\u code error；
size\u t length=sock->read\u some（boost:：asio:：buffer（data），错误）；
if（error==boost:：asio:：error:：eof）
中断；//对等方已完全关闭连接。
else if（错误）
抛出boost:：system:：system_error（error）；//其他一些错误。
标准：：向量v（数据，数据+长度）；
std:：string theStr；
对于（unsigned int i=0；i，如果没有看到服务器的代码，很难不经过一点推测就回答。但是：

从客户端到服务器的每次调用都使用相同的套接字。如果服务器不希望这样，那么它将不会按照您希望的方式运行

您对
stream read
调用
socket listen
的定义。您的意思是
usocket:socket listen
？这是一个服务器端函数（使用不同的参数）。我可能没有查看您运行的确切代码

咨询说明：（a）
我的流实际上是一个套接字，而不是流；（b）我鼓励您使用管理外部库

这是一个完整的工作示例。这是在LispWorks上；我使用了服务器的LW内部结构，以完全清楚地说明哪个是服务器，哪个是客户端

CL-USER 1 > (ql:quickload :usocket)
To load "usocket":
  Load 1 ASDF system:
    usocket
; Loading "usocket"

(:USOCKET)

CL-USER 2 > (comm:start-up-server
             :service 6003
             :function (lambda (handle)
                         (let* ((stream (make-instance 'comm:socket-stream
                                                       :socket handle
                                                       :direction :io
                                                       :element-type 'base-char))
                                (line (read-line stream)))
                           (format stream "Hello: ~a~%" line)
                           (force-output stream))))
#<MP:PROCESS Name "6003 server" Priority 85000000 State "Running">

CL-USER 3 > (defun socket-read (socket)
              (read-line (usocket:socket-stream socket)))
SOCKET-READ

CL-USER 4 > (defun socket-print (string socket)
              (write-line string (usocket:socket-stream socket))
              (force-output (usocket:socket-stream socket)))
SOCKET-PRINT

CL-USER 5 > (defun test (thing)
              (let ((socket (usocket:socket-connect "127.0.0.1" 6003)))
                (socket-print thing socket)
                (socket-read socket)))
TEST

CL-USER 6 > (test "Buttered toast")
"Hello: Buttered toast"
NIL

CL-USER 7 > (test "A nice cup of tea")
"Hello: A nice cup of tea"
NIL

CL-USER 1>（ql:quickload:usocket）
要加载“usocket”：
加载1 ASDF系统：
乌索克特
；加载“usocket”
（：USOCKET）
CL-USER 2>（通信：启动服务器
：服务6003
：功能（λ（手柄）
（let*（（流）（使实例'comm:socket流
：插座手柄
：方向：io
：元素类型“基本字符”）
（行（读取行流）））
（格式化流“Hello:~a~%”行）
（力输出流）
#
CL-USER 3>（解除套接字读取（套接字）
（读取行（usocket:socket-stream-socket）））
套接字读取
CL-USER 4>（定义套接字打印（字符串套接字）
（写入行字符串（usocket:socket流socket））
（力输出（usocket:socket流socket）））
插页印刷
CL-USER 5>（除雾测试（物件）
（let（（插座（usocket:socket-connect“127.0.0.1”6003）））
（插座打印件插座）
（套接字读取套接字）））
试验
CL-USER 6>（测试“黄油吐司”）
“你好：黄油吐司”
无
CL-USER 7>（测试“一杯好茶”）
“你好：一杯好茶”
无

如果您仍然有困难，请再次用源代码为您的服务器和您的实际流读取< /C> > ./P>看起来服务器是问题，用实际的C++回声服务器替换它，所有的工作都是如此！
...

void session(socket_ptr sock)
{
   try
   {    
    for (;;)
    {
      char data[max_length];

      boost::system::error_code error;
      size_t length = sock->read_some(boost::asio::buffer(data), error);
      if (error == boost::asio::error::eof)
      break; // Connection closed cleanly by peer.
      else if (error)
      throw boost::system::system_error(error); // Some other error.


    std::vector<char> v(data,data+length);
            std::string theStr;

        for(unsigned int i=0;i<v.size();i++)
        {
        if(v[i]<32 || v[i]>=0x7f);//Remove non-ascii char
        else theStr.insert(theStr.end(),v[i]);
    }
    std::cout<<"|"<<theStr<<"|"<<std::endl;

    boost::asio::write(*sock, boost::asio::buffer(data, length)); //works
    boost::asio::write(*sock, boost::asio::buffer("some", 4));  //doesn't work
}
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception in thread: " << e.what() << "\n";
  }
}
   ...

CL-USER 1 > (ql:quickload :usocket)
To load "usocket":
  Load 1 ASDF system:
    usocket
; Loading "usocket"

(:USOCKET)

CL-USER 2 > (comm:start-up-server
             :service 6003
             :function (lambda (handle)
                         (let* ((stream (make-instance 'comm:socket-stream
                                                       :socket handle
                                                       :direction :io
                                                       :element-type 'base-char))
                                (line (read-line stream)))
                           (format stream "Hello: ~a~%" line)
                           (force-output stream))))
#<MP:PROCESS Name "6003 server" Priority 85000000 State "Running">

CL-USER 3 > (defun socket-read (socket)
              (read-line (usocket:socket-stream socket)))
SOCKET-READ

CL-USER 4 > (defun socket-print (string socket)
              (write-line string (usocket:socket-stream socket))
              (force-output (usocket:socket-stream socket)))
SOCKET-PRINT

CL-USER 5 > (defun test (thing)
              (let ((socket (usocket:socket-connect "127.0.0.1" 6003)))
                (socket-print thing socket)
                (socket-read socket)))
TEST

CL-USER 6 > (test "Buttered toast")
"Hello: Buttered toast"
NIL

CL-USER 7 > (test "A nice cup of tea")
"Hello: A nice cup of tea"
NIL