You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
150 lines
4.9 KiB
150 lines
4.9 KiB
/**
|
|
* Type definitions used in the http server
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <stdint.h>
|
|
#include <stddef.h>
|
|
#include "httpd-config.h"
|
|
|
|
// opaque conn type struct
|
|
struct HttpdConnType;
|
|
typedef struct HttpdConnType HttpdConnType;
|
|
typedef HttpdConnType* ConnTypePtr;
|
|
|
|
struct httpd_thread_handle;
|
|
typedef struct httpd_thread_handle httpd_thread_handle_t;
|
|
|
|
struct httpd_init_options;
|
|
|
|
typedef uint32_t httpd_ipaddr_t;
|
|
|
|
/**
|
|
* CGI handler state / return value
|
|
*/
|
|
typedef enum {
|
|
/// Some work was done and the CGI wants to be called again at a later time.
|
|
/// Splitting long-running jobs allows other requests to be handled.
|
|
HTTPD_CGI_MORE = 0,
|
|
/// The CGI handled the request and is now done with it
|
|
HTTPD_CGI_DONE = 1,
|
|
/// This CGI did not handle the request, fall through to following ones
|
|
HTTPD_CGI_NOTFOUND = 2,
|
|
/// This is, in effect, identical to NOTFOUND, it's returned by auth functions when a fall-through is allowed.
|
|
/// The next route in the route list will be attempted.
|
|
HTTPD_CGI_AUTHENTICATED = 3, // TODO rename to PASS?
|
|
} httpd_cgi_state;
|
|
|
|
/**
|
|
* HTTP method (verb) used for the request
|
|
*/
|
|
typedef enum {
|
|
HTTPD_METHOD_GET = 1,
|
|
HTTPD_METHOD_POST = 2,
|
|
HTTPD_METHOD_OPTIONS = 3,
|
|
HTTPD_METHOD_PUT = 4,
|
|
HTTPD_METHOD_DELETE = 5,
|
|
HTTPD_METHOD_PATCH = 6,
|
|
HTTPD_METHOD_HEAD = 7,
|
|
} httpd_method;
|
|
|
|
/**
|
|
* Transfer mode
|
|
*/
|
|
typedef enum {
|
|
HTTPD_TRANSFER_CLOSE = 0,
|
|
HTTPD_TRANSFER_CHUNKED = 1,
|
|
HTTPD_TRANSFER_NONE = 2,
|
|
} httpd_transfer_opt;
|
|
|
|
|
|
/* init options */
|
|
|
|
struct httpd_init_options {
|
|
uint16_t port;
|
|
};
|
|
|
|
|
|
/* Private types - exposed to allow static alloc */
|
|
|
|
struct HttpdQueuedHeader;
|
|
typedef struct HttpdQueuedHeader {
|
|
/// Pointer to the next queued header
|
|
struct HttpdQueuedHeader *next;
|
|
/// Text of the header, including CRLF
|
|
char headerLine[];
|
|
} HttpdQueuedHeader;
|
|
|
|
typedef struct HttpdSendBacklogItem HttpdSendBacklogItem;
|
|
struct HttpdSendBacklogItem {
|
|
size_t len;
|
|
HttpdSendBacklogItem *next;
|
|
uint8_t data[];
|
|
};
|
|
|
|
//Private data for http connection
|
|
typedef struct HttpdPriv HttpdPriv;
|
|
struct HttpdPriv {
|
|
char head[HTTPD_MAX_HEAD_LEN];
|
|
char corsToken[HTTPD_MAX_CORS_TOKEN_LEN];
|
|
size_t headPos;
|
|
uint8_t *sendBuff;
|
|
size_t sendBuffLen;
|
|
char *chunkHdr;
|
|
HttpdSendBacklogItem *sendBacklog;
|
|
HttpdQueuedHeader *headersToSend; // Linked list of headers to send with the response. Will be freed with the request.
|
|
size_t sendBacklogSize;
|
|
uint8_t flags;
|
|
};
|
|
|
|
/// Callback type that releases the user data attached to the connection.
|
|
/// The format is compatible with regular "free()" or
|
|
typedef void (* httpdUserDataCleanupCb)(void *userData);
|
|
|
|
|
|
//A struct describing the POST data sent inside the http connection. This is used by the CGI functions
|
|
typedef struct HttpdPostData HttpdPostData;
|
|
struct HttpdPostData {
|
|
// FIXME len can be negative due to a stupid hack at `src/httpd.c:923`
|
|
int len; // POST Content-Length
|
|
size_t buffSize; // The maximum length of the post buffer
|
|
size_t buffLen; // The amount of bytes in the current post buffer
|
|
size_t received; // The total amount of bytes received so far
|
|
char *buff; // Actual POST data buffer
|
|
char *multipartBoundary; //Text of the multipart boundary, if any
|
|
};
|
|
|
|
typedef struct HttpdConnData HttpdConnData;
|
|
typedef httpd_cgi_state (* cgiSendCallback)(HttpdConnData *connData);
|
|
typedef httpd_cgi_state (* cgiRecvHandler)(HttpdConnData *connData, uint8_t *data, size_t len);
|
|
|
|
//A struct describing a http connection. This gets passed to cgi functions.
|
|
struct HttpdConnData {
|
|
ConnTypePtr conn; // The TCP connection. Exact type depends on the platform.
|
|
HttpdPriv priv; // Internal httpd state for the connection
|
|
|
|
httpd_method requestType; // One of the HTTPD_METHOD_* values
|
|
char *hostName; // Host name field of request
|
|
char *url; // The URL requested, without hostname or GET arguments
|
|
char *getArgs; // The GET arguments for this request, if any.
|
|
HttpdPostData post; // POST data structure
|
|
|
|
cgiSendCallback cgi; // CGI function pointer
|
|
cgiRecvHandler recvHdl; // Handler for data received after headers, if any
|
|
const void *cgiArg; // First CGI argument, can be NULL if not needed
|
|
const void *cgiArg2; // Second CGI argument for CGIs that need two parameters
|
|
void *cgiData; // Opaque data pointer for the CGI function
|
|
|
|
/// Opaque data pointer for user data that carries over between CGI calls for the same connection.
|
|
void *userData;
|
|
/// If userData is not NULL when a connection is finalized, this function (if set) is called to handle the cleanup.
|
|
/// This mechanism is useful when the user data is allocated by an auth CGI and the request can end in any number
|
|
/// of other routes, perhaps even with a static file - then the cleanup code doesn't need to be repeated everywhere.
|
|
httpdUserDataCleanupCb userDataCleanupCb;
|
|
|
|
// this should be at the end because of padding
|
|
uint16_t remote_port; // Remote TCP port
|
|
httpd_ipaddr_t remote_ip; // IP address of client
|
|
uint8_t slot; // Slot ID - index in s_connData
|
|
};
|
|
|