Net::ERR_CONNECTION_RESET при попытке получить/получить данные с http-сервера localhostC++

Программы на C++. Форум разработчиков
Ответить
Anonymous
 Net::ERR_CONNECTION_RESET при попытке получить/получить данные с http-сервера localhost

Сообщение Anonymous »

У меня есть http-сервер на C++, работающий на моем локальном хосте, чтобы передавать некоторые данные в мой интерфейс Electron React. К сожалению, у меня возникли серьезные проблемы, и я пытался гуглить день и ночь. Он использует своего рода динамическое назначение портов. Сервер определенно работает, так как я могу свернуть ответ и открыть сгенерированные данные JSON в Firefox (не в Chrome, что заставляет меня думать, что это электронная проблема).
Я получаю следующую ошибку в своем инструменте разработки для порта 8080, который определенно работает:

Попытка получить данные из http://localhost:8080/simdata
GET http://localhost:8080/simdata net::ERR_CONNECTION_RESET

Для неиспользуемых портов я получаю:
GET http://localhost:8083/simdata net::ERR_CONNECTION_REFUSED

Вот создание C++ сервер:

Код: Выделить всё

#define WIN32_LEAN_AND_MEAN
#include 
#include 
#include "SimConnect.h"
#include 
#include 

#pragma comment(lib, "Ws2_32.lib")

HANDLE hSimConnect = NULL;

enum EVENT_ID {
EVENT_SIM_START,
EVENT_SIM_STOP,
EVENT_ENGINE_START,
EVENT_ENGINE_STOP,
};

enum DATA_REQUEST_ID {
DATA_REQUEST_ID,
};

struct PositionStruct {
double latitude;
double longitude;
double altitude;
};

struct AircraftDataStruct {
bool isEngineRunning;
bool isOnGround;
PositionStruct position;
bool engineCombustion[2];
};

AircraftDataStruct g_aircraftData = {
false,
false,
{0.0, 0.0, 0.0},
{false, false}
};

bool g_dataUpdated = false;

// Define standard ports to try
const int STANDARD_PORTS[] = { 8080, 8081, 8082, 8083, 8084 };
const int NUM_STANDARD_PORTS = sizeof(STANDARD_PORTS) / sizeof(STANDARD_PORTS[0]);

void CALLBACK SimConnectDispatchCallback(SIMCONNECT_RECV* pData, DWORD cbData, void* pContext)
{
switch (pData->dwID)
{
case SIMCONNECT_RECV_ID_SIMOBJECT_DATA:
{
SIMCONNECT_RECV_SIMOBJECT_DATA* pObjData = (SIMCONNECT_RECV_SIMOBJECT_DATA*)pData;
if (pObjData->dwRequestID == DATA_REQUEST_ID)
{
if (pObjData->dwDefineID == DATA_REQUEST_ID)
{
g_aircraftData.isOnGround = *(DWORD*)&pObjData->dwData;
g_aircraftData.position.latitude = *(double*)((char*)&pObjData->dwData + sizeof(DWORD));
g_aircraftData.position.longitude = *(double*)((char*)&pObjData->dwData + sizeof(DWORD) + sizeof(double));
g_aircraftData.position.altitude = *(double*)((char*)&pObjData->dwData + sizeof(DWORD) + sizeof(double) * 2);
g_aircraftData.engineCombustion[0] = *(DWORD*)((char*)&pObjData->dwData + sizeof(DWORD) + sizeof(double) * 3);
g_aircraftData.engineCombustion[1] = *(DWORD*)((char*)&pObjData->dwData + sizeof(DWORD) + sizeof(double) * 3 + sizeof(DWORD));
g_aircraftData.isEngineRunning = (g_aircraftData.engineCombustion[0] || g_aircraftData.engineCombustion[1]);

g_dataUpdated = true;
}
else
{
}
}
break;
}
default:
break;
}
}

void InitSimConnect()
{
HRESULT hr;

if (SUCCEEDED(SimConnect_Open(&hSimConnect, "SimBridge", NULL, 0, 0, 0)))
{
hr = SimConnect_AddToDataDefinition(hSimConnect, DATA_REQUEST_ID, "SIM ON GROUND", "Bool", SIMCONNECT_DATATYPE_INT32);
hr = SimConnect_AddToDataDefinition(hSimConnect, DATA_REQUEST_ID, "PLANE LATITUDE", "Degrees", SIMCONNECT_DATATYPE_FLOAT64);
hr = SimConnect_AddToDataDefinition(hSimConnect, DATA_REQUEST_ID, "PLANE LONGITUDE", "Degrees", SIMCONNECT_DATATYPE_FLOAT64);
hr = SimConnect_AddToDataDefinition(hSimConnect, DATA_REQUEST_ID, "PLANE ALTITUDE", "Feet", SIMCONNECT_DATATYPE_FLOAT64);
hr = SimConnect_AddToDataDefinition(hSimConnect, DATA_REQUEST_ID, "GENERAL ENG COMBUSTION:1", "Bool", SIMCONNECT_DATATYPE_INT32);
hr = SimConnect_AddToDataDefinition(hSimConnect, DATA_REQUEST_ID, "GENERAL ENG COMBUSTION:2", "Bool", SIMCONNECT_DATATYPE_INT32);
hr = SimConnect_RequestDataOnSimObject(hSimConnect, DATA_REQUEST_ID, DATA_REQUEST_ID, SIMCONNECT_OBJECT_ID_USER, SIMCONNECT_PERIOD_SECOND);
}
else
{
}
}

DWORD WINAPI HttpServerThread(LPVOID lpParam)
{
WSADATA wsaData;
int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != 0)
{
return 1;
}

SOCKET listenSocket = INVALID_SOCKET;
int portIndex = 0;
bool socketCreated = false;

while (!socketCreated && portIndex < NUM_STANDARD_PORTS)
{
listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listenSocket == INVALID_SOCKET)
{
WSACleanup();
return 1;
}

sockaddr_in service;
service.sin_family = AF_INET;
service.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
service.sin_port = htons(STANDARD_PORTS[portIndex]);

if (bind(listenSocket, reinterpret_cast(&service), sizeof(service)) != SOCKET_ERROR)
{
socketCreated = true;
}
else
{
closesocket(listenSocket);
portIndex++;
}
}

if (!socketCreated)
{
WSACleanup();
return 1;
}

if (listen(listenSocket, SOMAXCONN) == SOCKET_ERROR)
{
closesocket(listenSocket);
WSACleanup();
return 1;
}

while (true)
{
SOCKET clientSocket = accept(listenSocket, NULL, NULL);
if (clientSocket == INVALID_SOCKET)
{
closesocket(listenSocket);
WSACleanup();
return 1;
}
char recvbuf[512];
int recvbuflen = 512;
int bytesReceived = recv(clientSocket, recvbuf, recvbuflen, 0);
if (bytesReceived == SOCKET_ERROR)
{
closesocket(clientSocket);
continue;
}
std::string jsonResponse = "{";
jsonResponse += "\"isEngineRunning\": " + std::string(g_aircraftData.isEngineRunning ? "true" : "false") + ",";
jsonResponse += "\"isOnGround\": " + std::string(g_aircraftData.isOnGround ? "true" : "false") + ",";
jsonResponse += "\"position\": {\"latitude\": " + std::to_string(g_aircraftData.position.latitude) + ",";
jsonResponse += "\"longitude\": " + std::to_string(g_aircraftData.position.longitude) + ",";
jsonResponse += "\"altitude\": " + std::to_string(g_aircraftData.position.altitude) + "}";
jsonResponse += "}";
std::string httpResponse = "HTTP/1.1 200 OK\r\n";
httpResponse += "Content-Type: application/json\r\n";
httpResponse += "Content-Length: " + std::to_string(jsonResponse.length()) + "\r\n";
httpResponse += "Access-Control-Allow-Origin: *\r\n";  // Allow any origin
httpResponse += "Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n";
httpResponse += "Access-Control-Allow-Headers: Content-Type\r\n";
httpResponse += "\r\n";
httpResponse += jsonResponse;
send(clientSocket, httpResponse.c_str(), static_cast(httpResponse.length()), 0);
closesocket(clientSocket);
}
closesocket(listenSocket);
WSACleanup();
return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
InitSimConnect();

HANDLE hThread = CreateThread(NULL, 0, HttpServerThread, NULL, 0, NULL);
if (hThread == NULL)
{
return 1;
}
while (true)
{
SimConnect_CallDispatch(hSimConnect, SimConnectDispatchCallback, NULL);

// Check if data has been updated
if (g_dataUpdated)
{
g_dataUpdated = false;
}
Sleep(1000);
}

return 0;
}

А вот код React, который обрабатывает запрос к серверу:

Код: Выделить всё

import React, { createContext, useContext, useState, useEffect, ReactNode } from 'react';

const ports = [8080, 8081, 8082, 8083, 8084];

interface SimDataContextProps {
data: any;
error: string | null;
refreshData: () => void;
}

interface SimDataProviderProps {
children: ReactNode;
}

const SimDataContext = createContext(undefined);

export const SimDataProvider: React.FC = ({ children }) => {
const [data, setData] = useState(null);
const [error, setError] = useState(null);

const fetchSimData = async () => {
for (let port of ports) {
try {
console.log(`Trying to fetch data from http://localhost:${port}/simdata`);
const response = await fetch(`http://localhost:${port}/simdata`);
if (response.ok) {
const jsonData = await response.json();
console.log(`Successfully fetched data from port ${port}:`, jsonData);
setData(jsonData);
setError(null);
return;
} else {
console.error(`Network response was not ok for port ${port}`);
}
} catch (err) {
console.error(`Error fetching from port ${port}:`, err);
}
}
setError('Failed to fetch data from all ports.');
};

useEffect(() => {
fetchSimData();
}, []);

return (

{children}

);
};

export const useSimData = () => {
const context = useContext(SimDataContext);
if (context === undefined) {
throw new Error('useSimData must be used within a SimDataProvider');
}
return context;
};

До сих пор я пробовал настроить 127.0.0.1 вместо использования localhost, но не помогло. Я также попытался разрешитьInsecureContent и поэкспериментировать с различными настройками CORS. Я также пытался отключить кеш.
Спасибо за помощь!

Подробнее здесь: https://stackoverflow.com/questions/787 ... lhost-http
Ответить

Быстрый ответ

Изменение регистра текста: 
Смайлики
:) :( :oops: :roll: :wink: :muza: :clever: :sorry: :angel: :read: *x)
Ещё смайлики…
   
К этому ответу прикреплено по крайней мере одно вложение.

Если вы не хотите добавлять вложения, оставьте поля пустыми.

Максимально разрешённый размер вложения: 15 МБ.

Вернуться в «C++»