How to send HTTP3 request between server and client

[Purushoth24051999]

I have written HTTP3 listener using a sample provided in the MSQUIC library, and my server listens in the 5000 port.

I want to receive HTTPS requests in GET, POST, and OPTIONS methods and send responses for those.

I have triggered a request from CURL. Since curl rejects self-signed certificates I have requested an insecure connection using the below command,

curl -v --http3 --insecure https://192.168.1.114:5000 

For a single request from a client I have received 3 QUIC_STREAM_EVENT_RECEIVE triggers and the data received in the stream is not in readable format. I have mentioned my code in ServerStreamCallback()

case QUIC_STREAM_EVENT_RECEIVE:
{
	std::cout << "[strm][" << stream << "] Data received:\nBuffer_count: " << streamEvent->RECEIVE.BufferCount << std::endl
		<< "total_buffer_length: " << streamEvent->RECEIVE.TotalBufferLength << std::endl;

	std::string receivedData;
	for (int i = 0; i < streamEvent->RECEIVE.BufferCount; i++)
	{
		auto& length = streamEvent->RECEIVE.Buffers[i].Length;
		std::string data(length, '\0');
		memcpy(&data[0], streamEvent->RECEIVE.Buffers[i].Buffer, length);
		receivedData += data;
	}
	std::cout << "Received data: " << receivedData << std::endl;

	std::string response = "HTTP/3 200 OK\r\nContent-Length: 2\r\n\r\nOK";
	ServerSend(stream, response);
	break;
}

OUTPUT in HTTP3 listener:

OUTPUT in CURL client:

NOTE:

If I send a data from client written using MSQUIC the above server code works well.

MSQUIC CLIENT CODE:

void Http3Client::ClientSend(HQUIC connection)
{
	try
	{
		QUIC_STATUS status;
		HQUIC stream = NULL;
		uint8_t* sendBufferRaw;
		QUIC_BUFFER* sendBuffer;

		if (QUIC_SUCCEEDED(status = MsQuicHelper::msQuic->StreamOpen(connection, QUIC_STREAM_OPEN_FLAG_NONE, ClientStreamCallback, NULL, &stream)))
		{
			printf("[strm][%p] Starting...\n", stream);

			if (QUIC_SUCCEEDED(status = MsQuicHelper::msQuic->StreamStart(stream, QUIC_STREAM_START_FLAG_NONE)))
			{
				std::string http3Request = "GET /test?viewId=10137&userId=101 HTTP/3\r\nHost: " + targetIp + "\r\n\r\n";
				MsQuicHelper::sendBufferLength = http3Request.size();
				sendBufferRaw = (uint8_t*)malloc(sizeof(QUIC_BUFFER) + MsQuicHelper::sendBufferLength);
				if (sendBufferRaw != NULL)
				{
					sendBuffer = (QUIC_BUFFER*)sendBufferRaw;
					sendBuffer->Buffer = sendBufferRaw + sizeof(QUIC_BUFFER);
					sendBuffer->Length = MsQuicHelper::sendBufferLength;
					memcpy(sendBuffer->Buffer, http3Request.data(), sendBuffer->Length);

					std::cout << "[strm][" << stream << "]\n" << sendBuffer->Buffer << "\nSending data..." << std::endl;

					if (QUIC_FAILED(status = MsQuicHelper::msQuic->StreamSend(stream, sendBuffer, 1, QUIC_SEND_FLAG_FIN, sendBuffer)))
					{
						std::cout << "StreamSend failed. Status: " << std::hex << status << std::endl;
						free(sendBufferRaw);
						goto Http3ClientError;
					}
				}
				else
				{
					std::cout << "SendBuffer allocation failed!" << std::endl;
					status = QUIC_STATUS_OUT_OF_MEMORY;
					goto Http3ClientError;
				}
			}
			else
			{
				std::cout << "StreamStart failed. Status: " << std::hex << status << std::endl;
				MsQuicHelper::msQuic->StreamClose(stream);
				goto Http3ClientError;
			}

		}
		else
		{
			std::cout << "StreamOpen failed. Status: " << std::hex << status << std::endl;
			goto Http3ClientError;
		}

	Http3ClientError:

		if (QUIC_FAILED(status))
			MsQuicHelper::msQuic->ConnectionShutdown(connection, QUIC_CONNECTION_SHUTDOWN_FLAG_NONE, 0);
	}
	catch(...)
       {
               std::cout << "Exception in ClientSend()\n";
       } 
}

OUTPUT OF HTTP3 LISTENER:

OUTPUT OF MSQUIC CLIENT:

[nibanks]

Feel free to take a look at how I do this in msh3: https://github.com/nibanks/msh3/blob/main/lib/msh3.cpp

[Purushoth24051999]

Is the received request in my case is encoded, if so it is mandatory for me to use ls-quack to encode and decode it?

[anrossi]

HTTP/3 (and HTTP/2) uses a binary format for the headers and messages in HTTP, while HTTP/1.1 used human-readable text.
So yes, you'll need to decode the received frames using some QPACK library, such as ls-qpack.