pf7astvk4
/
Nginx
1
0
Fork 0
Code Issues Pull Requests 2 Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

开发内容合并 #17

Merged
pzthu8lr3 merged 1 commits from yuankaifeng_branch into master 5 months ago
Conversation 0 Commits 1 Files Changed 6
6 changed files with 0 additions and 593 deletions
Show Stats Download Patch File Download Diff File

64
src/controler_windows/connecter_controler.cpp
Unescape View File

@ -1,64 +0,0 @@
#include <iostream>
#include <string>
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib") // 告诉链接器链接WS2_32.lib库
#define PORT 8888 // 假设网关的端口为8888，你可以根据实际情况修改
int main() {
WSADATA wsaData;
SOCKET sock = INVALID_SOCKET;
struct sockaddr_in serverAddr;
char *recvbuf;
const char *sendbuf = "Hello, Gateway!";
// 初始化Winsock
int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
if (iResult != 0) {
std::cerr << "WSAStartup failed: " << iResult << std::endl;
return 1;
}
// 创建套接字
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock == INVALID_SOCKET) {
std::cerr << "Could not create socket: " << WSAGetLastError() << std::endl;
WSACleanup();
return 1;
}
// 设置服务器地址
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // 假设网关的IP为127.0.0.1，你可以根据实际情况修改
serverAddr.sin_port = htons(PORT);
// 连接到服务器
iResult = connect(sock, (SOCKADDR*)&serverAddr, sizeof(serverAddr));
if (iResult SOCKET_ERROR) {
std::cerr << "Connect failed with error: " << WSAGetLastError() << std::endl;
closesocket(sock);
WSACleanup();
return 1;
}
std::cout << "Connected to server." << std::endl;
// 发送消息
iResult = send(sock, sendbuf, strlen(sendbuf), 0);
if (iResult == SOCKET_ERROR) {
std::cerr << "Send failed with error: " << WSAGetLastError() << std::endl;
closesocket(sock);
WSACleanup();
return 1;
}
std::cout << "Message sent." << std::endl;
// 关闭套接字
closesocket(sock);
// 清理Winsock
WSACleanup();
return 0;
}

96
src/controler_windows/connecter_gateway.cpp
Unescape View File

@ -1,96 +0,0 @@
#include <winsock2.h>
#include <iostream>
#include <string>
#include <cstring>
#pragma comment(lib, "ws2_32.lib")
#define PORT 8888 // 监听的端口号
#define KEY "secret_password" // 定义认证密钥
int main() {
WSADATA wsaData;
SOCKET sock, newSock;
SOCKADDR_IN serverAddr, clientAddr;
int cAddrLen = sizeof(clientAddr);
char recvbuf[1024];
char sendbuf[1024];
// 初始化Winsock
WSAStartup(MAKEWORD(2,2), &wsaData);
// 创建套接字
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock == INVALID_SOCKET) {
std::cerr << "Could not create socket: " << WSAGetLastError() << std::endl;
WSACleanup();
return 1;
}
// 设置服务器地址
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = INADDR_ANY;
serverAddr.sin_port = htons(PORT);
// 绑定套接字到地址
if (bind(sock, (SOCKADDR*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
std::cerr << "Bind failed with error: " << WSAGetLastError() << std::endl;
closesocket(sock);
WSACleanup();
return 1;
}
// 开始监听
if (listen(sock, SOMAXCONN) == SOCKET_ERROR) {
std::cerr << "Listen failed with error: " << WSAGetLastError() << std::endl;
closesocket(sock);
WSACleanup();
return 1;
}
std::cout << "Server listening on port " << PORT << "..." << std::endl;
// 接受连接
newSock = accept(sock, (SOCKADDR*)&clientAddr, &cAddrLen);
if (newSock == INVALID_SOCKET) {
std::cerr << "Accept failed with error: " << WSAGetLastError() << std::endl;
closesocket(sock);
WSACleanup();
return 1;
}
std::cout << "Connected with client." << std::endl;
// 发送密钥
strcpy(sendbuf, KEY);
if (send(newSock, sendbuf, strlen(sendbuf), 0) == SOCKET_ERROR) {
std::cerr << "Send failed with error: " << WSAGetLastError() << std::endl;
closesocket(newSock);
closesocket(sock);
WSACleanup();
return 1;
}
// 接收客户端响应的密钥
int iResult = recv(newSock, recvbuf, sizeof(recvbuf), 0);
if (iResult > 0) {
recvbuf[iResult] = '\0';
if (strcmp(recvbuf, KEY) == 0) {
std::cout << "Authentication successful." << std::endl;
// 认证成功后，可以接收客户端的消息或进行其他操作
// ...
} else {
std::cerr << "Authentication failed." << std::endl;
}
} else {
std::cerr << "Receive failed with error: " << WSAGetLastError() << std::endl;
}
// 关闭套接字
closesocket(newSock);
closesocket(sock);
// 清理Winsock
WSACleanup();
return 0;
}

59
src/controler_windows/interface_cpptovue.cpp
Unescape View File

@ -1,59 +0,0 @@
// main.cpp
#include <Poco/Net/HTTPServer.h>
#include <Poco/Net/HTTPRequestHandler.h>
#include <Poco/Net/HTTPRequestHandlerFactory.h>
#include <Poco/Net/HTTPResponse.h>
#include <Poco/Net/HTTPServerParams.h>
#include <Poco/Net/ServerSocket.h>
#include <Poco/JSON/JSON.h>
#include <Poco/JSON/Parser.h>
#include <iostream>
using namespace Poco::Net;
using namespace Poco::JSON;
class DataRequestHandler : public HTTPRequestHandler {
public:
void handleRequest(HTTPServerRequest &req, HTTPServerResponse &resp) override {
// 设置响应的HTTP头
resp.setContentType("application/json");
// 创建 JSON 对象
Object::Ptr pObj = new Object();
pObj->set("key", "value"); // 示例数据
// 将 JSON 对象转换为字符串
String result;
Poco::JSON::Stringifier::stringify(*pObj, result);
// 发送响应
resp.send() << result;
}
};
class DataRequestHandlerFactory : public HTTPRequestHandlerFactory {
public:
HTTPRequestHandler* createRequestHandler(const HTTPServerRequest &req) override {
// 检查请求的路径是否为 "/api/data"
if (req.getURI() == "/api/data") {
return new DataRequestHandler();
}
return 0;
}
};
int main(int argc, char** argv) {
ServerSocket svs(8080);
HTTPServerParams* pParams = new HTTPServerParams;
pParams->setMaxQueued(100);
pParams->setMaxThreads(16);
HTTPServer srv(new DataRequestHandlerFactory(), svs, pParams);
std::cout << "Server started on port 8080" << std::endl;
srv.start();
std::cin.get(); // 等待用户输入以结束服务器
srv.stop();
return 0;
}

0
src/controler_windows/message_handler.cpp
Unescape View File

288
src/controller_ubuntu/connecter_controler.cpp
Unescape View File

@ -1,288 +0,0 @@
#include <iostream>
#include <thread>
#include <vector>
#include <map>
#include <mutex>
#include <atomic>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <cstring>
#define BUFFER_SIZE 1024
#define HTTP_SERVER_PORT 8080
std::vector<std::thread> threads; // 存储所有连接线程
std::map<int, int> sockets; // 存储套接字
std::mutex sockets_mutex; // 用于同步访问 sockets
std::atomic<bool> exit_flag(false); // 原子退出标志
// 维护连接的函数
void KeepConnection(int sock) {
char buffer[BUFFER_SIZE];
int nbytes;
while (!exit_flag) {
nbytes = recv(sock, buffer, BUFFER_SIZE, 0);
if (nbytes <= 0) {
std::cout << "Gateway disconnected" << std::endl;
break;
}
std::cout << "Received from gateway (Socket " << sock << "): " << buffer << std::endl;
}
{
std::lock_guard<std::mutex> lock(sockets_mutex);
sockets.erase(sock); // 从集合中移除套接字
}
close(sock);
}
// 连接到网关的函数
void ConnectToGateway(const std::string& ip, int port) {
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror("Could not create socket");
return;
}
struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
if (inet_pton(AF_INET, ip.c_str(), &server_addr.sin_addr) <= 0) {
perror("Invalid address");
close(sock);
return;
}
if (connect(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("Connection to the server failed");
close(sock);
return;
}
{
std::lock_guard<std::mutex> lock(sockets_mutex);
sockets[sock] = 1; // 将套接字添加到集合中
}
std::cout << "Connected to gateway at " << ip << ":" << port << " (Socket " << sock << ")" << std::endl;
// 在新线程中维护连接
threads.emplace_back(KeepConnection, sock);
}
// 处理HTTP请求的函数
void HandleHttpRequest(int client_socket) {
char buffer[BUFFER_SIZE];
int bytes_read = recv(client_socket, buffer, sizeof(buffer), 0);
if (bytes_read <= 0) {
close(client_socket);
return;
}
// 简单解析HTTP请求
std::string http_request(buffer, bytes_read);
std::string ip;
int port;
// 寻找IP和端口号
auto host_pos = http_request.find("Host: ");
if (host_pos != std::string::npos) {
auto start = host_pos + std::string("Host: ").size();
ip = http_request.substr(start, http_request.find("\r\n", start) - start);
}
auto content_length_pos = http_request.find("Content-Length:");
if (content_length_pos != std::string::npos) {
auto start = content_length_pos + std::string("Content-Length: ").size();
int length = std::stoi(http_request.substr(start, http_request.find("\r\n", start) - start));
if (length > 0) {
char* content = new char[length];
bytes_read = recv(client_socket, content, length, 0);
if (bytes_read > 0) {
// 解析JSON内容（假设前端发送的是JSON格式）
// 这里需要添加JSON解析逻辑来提取IP和端口
// 示例：{"ip":"192.168.1.1","port":8080}
// 可以使用第三方库如nlohmann/json来解析JSON
// 假设解析后得到ip和port
// ConnectToGateway(ip, port);
delete[] content;
}
}
}
// 发送HTTP响应
std::string response = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n";
send(client_socket, response.c_str(), response.size(), 0);
close(client_socket);
}
// 启动HTTP服务器的函数
void StartHttpServer() {
int http_server_socket = socket(AF_INET, SOCK_STREAM, 0);
if (http_server_socket < 0) {
perror("Could not create HTTP server socket");
return;
}
int opt = 1;
if (setsockopt(http_server_socket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
perror("Setsockopt failed");
close(http_server_socket);
return;
}
struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(HTTP_SERVER_PORT);
if (bind(http_server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("Bind failed");
close(http_server_socket);
return;
}
if (listen(http_server_socket, 5) < 0) {
perror("Listen failed");
close(http_server_socket);
return;
}
std::cout << "HTTP server listening on port " << HTTP_SERVER_PORT << std::endl;
while (!exit_flag) {
int client_socket = accept(http_server_socket, NULL, NULL);
if (client_socket < 0) {
perror("Accept failed");
continue;
}
threads.emplace_back(HandleHttpRequest, client_socket);
}
close(http_server_socket);
}
int main() {
// threads.emplace_back(StartHttpServer);
// std::string command, ip;
// int port;
// bool in_connect_mode = false;
// std::cout << "Enter command (connect/exit): ";
// while (true) {
// if (in_connect_mode)
// {
// std::cout << "continue connect or not ? (y or n) ";
// std::cin >> command;
// if(command=="y"){
// std::cout << "Enter the gateway IP address: ";
// std::cin >> ip;
// std::cout << "Enter the gateway port: ";
// std::cin >> port;
// ConnectToGateway(ip, port);
// }
// else {
// in_connect_mode = false; // 退出连接模式
// std::cout << "Exiting connect mode." << std::endl;
// }
// }
// else{
// std::cout << "Enter command (connect/exit): ";
// std::cin>>command;
// if (command == "connect") {
// if (in_connect_mode) {
// std::cout << "Already in connect mode." << std::endl;
// continue;
// }
// in_connect_mode = true; // 进入连接模式
// std::cout << "Enter the gateway IP address: ";
// std::cin >> ip;
// std::cout << "Enter the gateway port: ";
// std::cin >> port;
// ConnectToGateway(ip, port);
// } else if (command == "exit") {
// exit_flag = true; // 设置退出标志
// std::cout << "Exiting program." << std::endl;
// // 关闭所有套接字
// for (auto& sock_pair : sockets) {
// shutdown(sock_pair.first, SHUT_RDWR); // 关闭套接字的发送和接收
// close(sock_pair.first);
// }
// sockets.clear();
// std::cout << "sockets.clear" << std::endl;
// // 等待所有线程结束
// for (auto& thread : threads) {
// if (thread.joinable()) {
// thread.join();
// }
// }
// threads.clear();
// break; // 退出主循环
// } else {
// std::cout << "Unknown command" << std::endl;
// }
// }
// }
// std::cout<<"out"<<std::endl;
// return 0;
std::thread http_server_thread(StartHttpServer);
std::string command, ip;
int port;
bool in_connect_mode = false;
while (true) {
std::cout << "Enter command (connect/exit): ";
std::cin >> command;
if (command == "connect") {
if (in_connect_mode) {
std::cout << "Already in connect mode." << std::endl;
continue;
}
in_connect_mode = true;
std::cout << "Enter the gateway IP address: ";
std::cin >> ip;
std::cout << "Enter the gateway port: ";
std::cin >> port;
ConnectToGateway(ip, port);
} else if (command == "exit") {
break; // 接收到退出命令，退出主循环
} else {
std::cout << "Unknown command" << std::endl;
}
}
// 设置退出标志
exit_flag = true;
// 强制结束HTTP服务器线程
if (http_server_thread.joinable()) {
http_server_thread.join();
}
// 关闭所有套接字
for (auto& sock_pair : sockets) {
shutdown(sock_pair.first, SHUT_RDWR);
close(sock_pair.first);
}
sockets.clear();
// 等待所有工作线程结束
for (auto& thread : threads) {
if (thread.joinable()) {
thread.join();
}
}
threads.clear();
std::cout << "Exited program." << std::endl;
return 0;
}

86
src/controller_ubuntu/connecter_gateway.cpp
Unescape View File

@ -1,86 +0,0 @@
#include <iostream>
#include <thread>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#define PORT 8080
#define MAX_CLIENTS 5
#define BUFFER_SIZE 1024
// 声明 handle_client 函数
void handle_client(int client_socket);
int main() {
int server_fd, new_socket;
struct sockaddr_in server_addr, client_addr;
socklen_t client_len = sizeof(client_addr);
char buffer[BUFFER_SIZE];
int opt = 1;
// 创建套接字
server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server_fd < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
// 设置选项，允许重用地址
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
perror("setsockopt failed");
exit(EXIT_FAILURE);
}
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(PORT);
// 绑定
if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("bind failed");
exit(EXIT_FAILURE);
}
// 监听
if (listen(server_fd, MAX_CLIENTS) < 0) {
perror("listen failed");
exit(EXIT_FAILURE);
}
std::cout << "Server listening on port " << PORT << std::endl;
while (true) {
client_len = sizeof(client_addr);
new_socket = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);
if (new_socket < 0) {
perror("accept failed");
exit(EXIT_FAILURE);
}
std::cout << "New client connected from " << inet_ntoa(client_addr.sin_addr) << " port " << ntohs(client_addr.sin_port) << std::endl;
// 创建并启动线程处理客户端
std::thread(handle_client, new_socket).detach();
}
close(server_fd);
return 0;
}
// 定义 handle_client 函数
void handle_client(int client_socket) {
while (true) {
char buffer[BUFFER_SIZE];
memset(buffer, 0, BUFFER_SIZE); // 清空缓冲区
int nbytes = read(client_socket, buffer, BUFFER_SIZE);
if (nbytes <= 0) {
std::cout << "Client disconnected." << std::endl;
close(client_socket);
break;
}
std::cout << "Received message from client: " << buffer << std::endl;
// 这里可以添加更多的处理逻辑
}
}
Write Preview
Loading…
Cancel
Save