mirror/SDRPlusPlus
0
0
Fork 0
mirror of https://github.com/AlexandreRouma/SDRPlusPlus.git synced 2025-07-10 11:05:22 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

more work

Browse Source
This commit is contained in:
AlexandreRouma
2023-01-26 02:55:11 +01:00
parent 66bbc93535
commit e59d804b31
4 changed files with 1262 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

304
core/src/utils/proto/http.cpp Normal file
View File

@ -0,0 +1,304 @@
#include "http.h"
#include <inttypes.h>
namespace net::http {
std::string MessageHeader::serialize() {
std::string data;
// Add start line
data += serializeStartLine() + "\r\n";
// Add fields
for (const auto& [key, value] : fields) {
data += key + ": " + value + "\r\n";
}
// Add terminator
data += "\r\n";
return data;
}
void MessageHeader::deserialize(const std::string& data) {
// Clear existing fields
fields.clear();
// Parse first line
std::string line;
int offset = readLine(data, line);
deserializeStartLine(line);
// Parse fields
while (offset < data.size()) {
// Read line
offset = readLine(data, line, offset);
// If empty line, the header is done
if (line.empty()) { break; }
// Read until first ':' for the key
int klen = 0;
for (; klen < line.size(); klen++) {
if (line[klen] == ':') { break; }
}
// Find offset of value
int voff = klen + 1;
for (; voff < line.size(); voff++) {
if (line[voff] != ' ' && line[voff] != '\t') { break; }
}
// Save field
fields[line.substr(0, klen)] = line.substr(voff);
}
}
std::map<std::string, std::string>& MessageHeader::getFields() {
return fields;
}
bool MessageHeader::hasField(const std::string& name) {
return fields.find(name) != fields.end();
}
std::string MessageHeader::getField(const std::string name) {
// TODO: Check if exists
return fields[name];
}
void MessageHeader::setField(const std::string& name, const std::string& value) {
fields[name] = value;
}
void MessageHeader::clearField(const std::string& name) {
// TODO: Check if exists (but maybe no error?)
fields.erase(name);
}
int MessageHeader::readLine(const std::string& str, std::string& line, int start) {
// Get line length
int len = 0;
bool cr = false;
for (int i = start; i < str.size(); i++) {
if (str[i] == '\n') {
if (len && str[i-1] == '\r') { cr = true; }
break;
}
len++;
}
// Copy line
line = str.substr(start, len - (cr ? 1:0));
return start + len + 1;
}
RequestHeader::RequestHeader(Method method, std::string uri, std::string host) {
this->method = method;
this->uri = uri;
setField("Host", host);
}
RequestHeader::RequestHeader(const std::string& data) {
deserialize(data);
}
Method RequestHeader::getMethod() {
return method;
}
void RequestHeader::setMethod(Method method) {
this->method = method;
}
std::string RequestHeader::getURI() {
return uri;
}
void RequestHeader::setURI(const std::string& uri) {
this->uri = uri;
}
void RequestHeader::deserializeStartLine(const std::string& data) {
// TODO
}
std::string RequestHeader::serializeStartLine() {
// TODO: Allow to specify version
return MethodStrings[method] + " " + uri + " HTTP/1.1";
}
ResponseHeader::ResponseHeader(StatusCode statusCode) {
this->statusCode = statusCode;
if (StatusCodeStrings.find(statusCode) != StatusCodeStrings.end()) {
this->statusString = StatusCodeStrings[statusCode];
}
else {
this->statusString = "UNKNOWN";
}
}
ResponseHeader::ResponseHeader(StatusCode statusCode, const std::string& statusString) {
this->statusCode = statusCode;
this->statusString = statusString;
}
ResponseHeader::ResponseHeader(const std::string& data) {
deserialize(data);
}
StatusCode ResponseHeader::getStatusCode() {
return statusCode;
}
void ResponseHeader::setStatusCode(StatusCode statusCode) {
this->statusCode = statusCode;
}
std::string ResponseHeader::getStatusString() {
return statusString;
}
void ResponseHeader::setStatusString(const std::string& statusString) {
this->statusString = statusString;
}
void ResponseHeader::deserializeStartLine(const std::string& data) {
// Parse version
int offset = 0;
for (; offset < data.size(); offset++) {
if (data[offset] == ' ') { break; }
}
// TODO: Error if null length
// TODO: Parse version
// Skip spaces
for (; offset < data.size(); offset++) {
if (data[offset] != ' ' && data[offset] != '\t') { break; }
}
// Parse status code
int codeOffset = offset;
for (; offset < data.size(); offset++) {
if (data[offset] == ' ') { break; }
}
// TODO: Error if null length
statusCode = (StatusCode)std::stoi(data.substr(codeOffset, codeOffset - offset));
// Skip spaces
for (; offset < data.size(); offset++) {
if (data[offset] != ' ' && data[offset] != '\t') { break; }
}
// Parse status string
int stringOffset = offset;
for (; offset < data.size(); offset++) {
if (data[offset] == ' ') { break; }
}
// TODO: Error if null length (maybe?)
statusString = data.substr(stringOffset, stringOffset - offset);
}
std::string ResponseHeader::serializeStartLine() {
char buf[1024];
sprintf(buf, "%d %s", (int)statusCode, statusString.c_str());
return buf;
}
ChunkHeader::ChunkHeader(size_t length) {
this->length = length;
}
ChunkHeader::ChunkHeader(const std::string& data) {
deserialize(data);
}
std::string ChunkHeader::serialize() {
char buf[64];
sprintf(buf, "%" PRIX64 "\r\n", length);
return buf;
}
void ChunkHeader::deserialize(const std::string& data) {
// Parse length
int offset = 0;
for (; offset < data.size(); offset++) {
if (data[offset] == ' ') { break; }
}
// TODO: Error if null length
length = (StatusCode)std::stoull(data.substr(0, offset), nullptr, 16);
// TODO: Parse rest
}
size_t ChunkHeader::getLength() {
return length;
}
void ChunkHeader::setLength(size_t length) {
this->length = length;
}
Client::Client(std::shared_ptr<Socket> sock) {
this->sock = sock;
}
int Client::sendRequestHeader(RequestHeader& req) {
return sock->sendstr(req.serialize());
}
int Client::recvRequestHeader(RequestHeader& req, int timeout) {
// Non-blocking mode not alloowed
if (!timeout) { return -1; }
// Read response
std::string respData;
int err = recvHeader(respData, timeout);
if (err) { return err; }
// Deserialize
req.deserialize(respData);
}
int Client::sendResponseHeader(ResponseHeader& resp) {
return sock->sendstr(resp.serialize());
}
int Client::recvResponseHeader(ResponseHeader& resp, int timeout) {
// Non-blocking mode not alloowed
if (!timeout) { return -1; }
// Read response
std::string respData;
int err = recvHeader(respData, timeout);
if (err) { return err; }
// Deserialize
resp.deserialize(respData);
}
int Client::sendChunkHeader(ChunkHeader& chdr) {
return sock->sendstr(chdr.serialize());
}
int Client::recvChunkHeader(ChunkHeader& chdr, int timeout) {
std::string respData;
int err = sock->recvline(respData, 0, timeout);
if (err <= 0) { return err; }
if (respData[respData.size()-1] == '\r') {
respData.pop_back();
}
chdr.deserialize(respData);
return 0;
}
int Client::recvHeader(std::string& data, int timeout) {
while (sock->isOpen()) {
std::string line;
int ret = sock->recvline(line);
if (line == "\r") { break; }
if (ret <= 0) { return ret; }
data += line + "\n";
}
return 0;
}
}

275
core/src/utils/proto/http.h Normal file
View File

@ -0,0 +1,275 @@
#pragma once
#include <map>
#include <string>
#include "../net.h"
namespace net::http {
enum Method {
METHOD_OPTIONS,
METHOD_GET,
METHOD_HEAD,
METHOD_POST,
METHOD_PUT,
METHOD_DELETE,
METHOD_TRACE,
METHOD_CONNECT
};
inline std::map<Method, std::string> MethodStrings {
{ METHOD_OPTIONS, "OPTIONS" },
{ METHOD_GET, "GET" },
{ METHOD_HEAD, "HEAD" },
{ METHOD_POST, "POST" },
{ METHOD_PUT, "PUT" },
{ METHOD_DELETE, "DELETE" },
{ METHOD_TRACE, "TRACE" },
{ METHOD_CONNECT, "CONNECT" }
};
enum StatusCode {
STATUS_CODE_CONTINUE = 100,
STATUS_CODE_SWITCH_PROTO = 101,
STATUS_CODE_OK = 200,
STATUS_CODE_CREATED = 201,
STATUS_CODE_ACCEPTED = 202,
STATUS_CODE_NON_AUTH_INFO = 203,
STATUS_CODE_NO_CONTENT = 204,
STATUS_CODE_RESET_CONTENT = 205,
STATUS_CODE_PARTIAL_CONTENT = 206,
STATUS_CODE_MULTIPLE_CHOICES = 300,
STATUS_CODE_MOVED_PERMANENTLY = 301,
STATUS_CODE_FOUND = 302,
STATUS_CODE_SEE_OTHER = 303,
STATUS_CODE_NOT_MODIFIED = 304,
STATUS_CODE_USE_PROXY = 305,
STATUS_CODE_TEMP_REDIRECT = 307,
STATUS_CODE_BAD_REQUEST = 400,
STATUS_CODE_UNAUTHORIZED = 401,
STATUS_CODE_PAYMENT_REQUIRED = 402,
STATUS_CODE_FORBIDDEN = 403,
STATUS_CODE_NOT_FOUND = 404,
STATUS_CODE_METHOD_NOT_ALLOWED = 405,
STATUS_CODE_NOT_ACCEPTABLE = 406,
STATUS_CODE_PROXY_AUTH_REQ = 407,
STATUS_CODE_REQUEST_TIEMOUT = 408,
STATUS_CODE_CONFLICT = 409,
STATUS_CODE_GONE = 410,
STATUS_CODE_LENGTH_REQUIRED = 411,
STATUS_CODE_PRECONDITION_FAILED = 412,
STATUS_CODE_REQ_ENTITY_TOO_LARGE = 413,
STATUS_CODE_REQ_URI_TOO_LONG = 414,
STATUS_CODE_UNSUPPORTED_MEDIA_TYPE = 415,
STATUS_CODE_REQ_RANGE_NOT_SATISFIABLE = 416,
STATUS_CODE_EXPECTATION_FAILED = 417,
STATUS_CODE_IM_A_TEAPOT = 418,
STATUS_CODE_ENHANCE_YOUR_CALM = 420,
STATUS_CODE_INTERNAL_SERVER_ERROR = 500,
STATUS_CODE_NOT_IMPLEMENTED = 501,
STATUS_CODE_BAD_GATEWAY = 502,
STATUS_CODE_SERVICE_UNAVAILABLE = 503,
STATUS_CODE_GATEWAY_TIMEOUT = 504,
STATUS_CODE_HTTP_VERSION_UNSUPPORTED = 505
};
inline std::map<StatusCode, std::string> StatusCodeStrings {
{ STATUS_CODE_CONTINUE , "CONTINUE" },
{ STATUS_CODE_SWITCH_PROTO , "SWITCH_PROTO" },
{ STATUS_CODE_OK , "OK" },
{ STATUS_CODE_CREATED , "CREATED" },
{ STATUS_CODE_ACCEPTED , "ACCEPTED" },
{ STATUS_CODE_NON_AUTH_INFO , "NON_AUTH_INFO" },
{ STATUS_CODE_NO_CONTENT , "NO_CONTENT" },
{ STATUS_CODE_RESET_CONTENT , "RESET_CONTENT" },
{ STATUS_CODE_PARTIAL_CONTENT , "PARTIAL_CONTENT" },
{ STATUS_CODE_MULTIPLE_CHOICES , "MULTIPLE_CHOICES" },
{ STATUS_CODE_MOVED_PERMANENTLY , "MOVED_PERMANENTLY" },
{ STATUS_CODE_FOUND , "FOUND" },
{ STATUS_CODE_SEE_OTHER , "SEE_OTHER" },
{ STATUS_CODE_NOT_MODIFIED , "NOT_MODIFIED" },
{ STATUS_CODE_USE_PROXY , "USE_PROXY" },
{ STATUS_CODE_TEMP_REDIRECT , "TEMP_REDIRECT" },
{ STATUS_CODE_BAD_REQUEST , "BAD_REQUEST" },
{ STATUS_CODE_UNAUTHORIZED , "UNAUTHORIZED" },
{ STATUS_CODE_PAYMENT_REQUIRED , "PAYMENT_REQUIRED" },
{ STATUS_CODE_FORBIDDEN , "FORBIDDEN" },
{ STATUS_CODE_NOT_FOUND , "NOT_FOUND" },
{ STATUS_CODE_METHOD_NOT_ALLOWED , "METHOD_NOT_ALLOWED" },
{ STATUS_CODE_NOT_ACCEPTABLE , "NOT_ACCEPTABLE" },
{ STATUS_CODE_PROXY_AUTH_REQ , "PROXY_AUTH_REQ" },
{ STATUS_CODE_REQUEST_TIEMOUT , "REQUEST_TIEMOUT" },
{ STATUS_CODE_CONFLICT , "CONFLICT" },
{ STATUS_CODE_GONE , "GONE" },
{ STATUS_CODE_LENGTH_REQUIRED , "LENGTH_REQUIRED" },
{ STATUS_CODE_PRECONDITION_FAILED , "PRECONDITION_FAILED" },
{ STATUS_CODE_REQ_ENTITY_TOO_LARGE , "REQ_ENTITY_TOO_LARGE" },
{ STATUS_CODE_REQ_URI_TOO_LONG , "REQ_URI_TOO_LONG" },
{ STATUS_CODE_UNSUPPORTED_MEDIA_TYPE , "UNSUPPORTED_MEDIA_TYPE" },
{ STATUS_CODE_REQ_RANGE_NOT_SATISFIABLE, "REQ_RANGE_NOT_SATISFIABLE"},
{ STATUS_CODE_EXPECTATION_FAILED , "EXPECTATION_FAILED" },
{ STATUS_CODE_IM_A_TEAPOT , "IM_A_TEAPOT" },
{ STATUS_CODE_ENHANCE_YOUR_CALM , "ENHANCE_YOUR_CALM" },
{ STATUS_CODE_INTERNAL_SERVER_ERROR , "INTERNAL_SERVER_ERROR" },
{ STATUS_CODE_NOT_IMPLEMENTED , "NOT_IMPLEMENTED" },
{ STATUS_CODE_BAD_GATEWAY , "BAD_GATEWAY" },
{ STATUS_CODE_SERVICE_UNAVAILABLE , "SERVICE_UNAVAILABLE" },
{ STATUS_CODE_GATEWAY_TIMEOUT , "GATEWAY_TIMEOUT" },
{ STATUS_CODE_HTTP_VERSION_UNSUPPORTED , "HTTP_VERSION_UNSUPPORTED" }
};
/**
* HTTP Message Header
*/
class MessageHeader {
public:
/**
* Serialize header to string.
* @return Header in string form.
*/
std::string serialize();
/**
* Deserialize header from string.
* @param data Header in string form.
*/
void deserialize(const std::string& data);
/**
* Get field list.
* @return Map from field name to field.
*/
std::map<std::string, std::string>& getFields();
/**
* Check if a field exists in the header.
* @return True if the field exists, false otherwise.
*/
bool hasField(const std::string& name);
/**
* Get field value.
* @param name Name of the field.
* @return Field value.
*/
std::string getField(const std::string name);
/**
* Set field.
* @param name Field name.
* @param value Field value.
*/
void setField(const std::string& name, const std::string& value);
/**
* Delete field.
* @param name Field name.
*/
void clearField(const std::string& name);
private:
int readLine(const std::string& str, std::string& line, int start = 0);
virtual std::string serializeStartLine() = 0;
virtual void deserializeStartLine(const std::string& data) = 0;
std::map<std::string, std::string> fields;
};
/**
* HTTP Request Header
*/
class RequestHeader : public MessageHeader {
public:
RequestHeader() {}
/**
* Create request header from the mandatory parameters.
* @param method HTTP Method.
* @param uri URI of request.
* @param host Server host passed in the 'Host' field.
*/
RequestHeader(Method method, std::string uri, std::string host);
/**
* Create request header from its serialized string form.
* @param data Request header in string form.
*/
RequestHeader(const std::string& data);
/**
* Get HTTP Method.
* @return HTTP Method.
*/
Method getMethod();
void setMethod(Method method);
std::string getURI();
void setURI(const std::string& uri);
private:
void deserializeStartLine(const std::string& data);
std::string serializeStartLine();
Method method;
std::string uri;
};
class ResponseHeader : public MessageHeader {
public:
ResponseHeader() {}
ResponseHeader(StatusCode statusCode);
ResponseHeader(StatusCode statusCode, const std::string& statusString);
ResponseHeader(const std::string& data);
StatusCode getStatusCode();
void setStatusCode(StatusCode statusCode);
std::string getStatusString();
void setStatusString(const std::string& statusString);
private:
void deserializeStartLine(const std::string& data);
std::string serializeStartLine();
StatusCode statusCode;
std::string statusString;
};
class ChunkHeader {
public:
ChunkHeader() {}
ChunkHeader(size_t length);
ChunkHeader(const std::string& data);
std::string serialize();
void deserialize(const std::string& data);
size_t getLength();
void setLength(size_t length);
private:
size_t length;
};
class Client {
public:
Client(std::shared_ptr<Socket> sock);
int sendRequestHeader(RequestHeader& req);
int recvRequestHeader(RequestHeader& req, int timeout = -1);
int sendResponseHeader(ResponseHeader& resp);
int recvResponseHeader(ResponseHeader& resp, int timeout = -1);
int sendChunkHeader(ChunkHeader& chdr);
int recvChunkHeader(ChunkHeader& chdr, int timeout = -1);
private:
int recvHeader(std::string& data, int timeout = -1);
std::shared_ptr<Socket> sock;
};
}