You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
122 lines
3.9 KiB
C++
122 lines
3.9 KiB
C++
/*
|
|
* This file is part of OpenTTD.
|
|
* OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
|
|
* OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/**
|
|
* @file tcp_http.h Basic functions to receive and send HTTP TCP packets.
|
|
*/
|
|
|
|
#ifndef NETWORK_CORE_TCP_HTTP_H
|
|
#define NETWORK_CORE_TCP_HTTP_H
|
|
|
|
#include "tcp.h"
|
|
|
|
/** Callback for when the HTTP handler has something to tell us. */
|
|
struct HTTPCallback {
|
|
/**
|
|
* An error has occurred and the connection has been closed.
|
|
* @note HTTP socket handler is closed/freed.
|
|
*/
|
|
virtual void OnFailure() = 0;
|
|
|
|
/**
|
|
* We're receiving data.
|
|
* @param data the received data, nullptr when all data has been received.
|
|
* @param length the amount of received data, 0 when all data has been received.
|
|
* @note When nullptr is sent the HTTP socket handler is closed/freed.
|
|
*/
|
|
virtual void OnReceiveData(const char *data, size_t length) = 0;
|
|
|
|
/** Silentium */
|
|
virtual ~HTTPCallback() {}
|
|
};
|
|
|
|
/** Base socket handler for HTTP traffic. */
|
|
class NetworkHTTPSocketHandler : public NetworkSocketHandler {
|
|
private:
|
|
char recv_buffer[4096]; ///< Partially received message.
|
|
int recv_pos; ///< Current position in buffer.
|
|
int recv_length; ///< Length of the data still retrieving.
|
|
HTTPCallback *callback; ///< The callback to call for the incoming data.
|
|
const char *data; ///< The (POST) data we might want to forward (to a redirect).
|
|
int redirect_depth; ///< The depth of the redirection.
|
|
|
|
int HandleHeader();
|
|
int Receive();
|
|
public:
|
|
SOCKET sock; ///< The socket currently connected to
|
|
|
|
/**
|
|
* Whether this socket is currently bound to a socket.
|
|
* @return true when the socket is bound, false otherwise
|
|
*/
|
|
bool IsConnected() const
|
|
{
|
|
return this->sock != INVALID_SOCKET;
|
|
}
|
|
|
|
NetworkRecvStatus CloseConnection(bool error = true) override;
|
|
|
|
NetworkHTTPSocketHandler(SOCKET sock, HTTPCallback *callback,
|
|
const char *host, const char *url, const char *data, int depth);
|
|
|
|
~NetworkHTTPSocketHandler();
|
|
|
|
static int Connect(char *uri, HTTPCallback *callback,
|
|
const char *data = nullptr, int depth = 0);
|
|
|
|
static void HTTPReceive();
|
|
};
|
|
|
|
/** Connect with a HTTP server and do ONE query. */
|
|
class NetworkHTTPContentConnecter : TCPConnecter {
|
|
std::string hostname; ///< Hostname we are connecting to.
|
|
HTTPCallback *callback; ///< Callback to tell that we received some data (or won't).
|
|
const char *url; ///< The URL we want to get at the server.
|
|
const char *data; ///< The data to send
|
|
int depth; ///< How far we have recursed
|
|
|
|
public:
|
|
/**
|
|
* Start the connecting.
|
|
* @param hostname The hostname to connect to.
|
|
* @param callback The callback for HTTP retrieval.
|
|
* @param url The url at the server.
|
|
* @param data The data to send.
|
|
* @param depth The depth (redirect recursion) of the queries.
|
|
*/
|
|
NetworkHTTPContentConnecter(const std::string &hostname, HTTPCallback *callback, const char *url, const char *data = nullptr, int depth = 0) :
|
|
TCPConnecter(hostname, 80),
|
|
hostname(hostname),
|
|
callback(callback),
|
|
url(stredup(url)),
|
|
data(data),
|
|
depth(depth)
|
|
{
|
|
}
|
|
|
|
/** Free all our allocated data. */
|
|
~NetworkHTTPContentConnecter()
|
|
{
|
|
free(this->url);
|
|
}
|
|
|
|
void OnFailure() override
|
|
{
|
|
this->callback->OnFailure();
|
|
free(this->data);
|
|
}
|
|
|
|
void OnConnect(SOCKET s) override
|
|
{
|
|
new NetworkHTTPSocketHandler(s, this->callback, this->hostname.c_str(), this->url, this->data, this->depth);
|
|
/* We've relinquished control of data now. */
|
|
this->data = nullptr;
|
|
}
|
|
};
|
|
|
|
#endif /* NETWORK_CORE_TCP_HTTP_H */
|