mirror of https://github.com/stella-emu/stella.git
Pluscart networking.
This commit is contained in:
Christian Speckner
parent
42e1fdb518
commit
67707bfdde
|
|
@ -56,12 +56,10 @@ CartridgeEnhanced::CartridgeEnhanced(const ByteBuffer& image, size_t size,
|
|||
// space will be filled with 0's from above
|
||||
std::copy_n(image.get(), std::min(mySize, size), myImage.get());
|
||||
|
||||
#if 0
|
||||
// Determine whether we have a PlusROM cart
|
||||
// PlusROM needs to call peek() method, so disable direct peeks
|
||||
if(myPlusROM.initialize(myImage, mySize))
|
||||
myDirectPeek = false;
|
||||
#endif
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
|
|
@ -143,6 +141,8 @@ void CartridgeEnhanced::reset()
|
|||
|
||||
// Upon reset we switch to the reset bank
|
||||
bank(startBank());
|
||||
|
||||
if (myPlusROM.isValid()) myPlusROM.reset();
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
|
|
@ -150,7 +150,6 @@ uInt8 CartridgeEnhanced::peek(uInt16 address)
|
|||
{
|
||||
const uInt16 peekAddress = address;
|
||||
|
||||
#if 0
|
||||
// Is this a PlusROM?
|
||||
if(myPlusROM.isValid())
|
||||
{
|
||||
|
|
@ -158,7 +157,6 @@ uInt8 CartridgeEnhanced::peek(uInt16 address)
|
|||
if(myPlusROM.peekHotspot(address, value))
|
||||
return value;
|
||||
}
|
||||
#endif
|
||||
|
||||
// hotspots in TIA range are reacting to pokes only
|
||||
if (hotspot() >= 0x80)
|
||||
|
|
@ -189,11 +187,9 @@ uInt8 CartridgeEnhanced::peek(uInt16 address)
|
|||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
bool CartridgeEnhanced::poke(uInt16 address, uInt8 value)
|
||||
{
|
||||
#if 0
|
||||
// Is this a PlusROM?
|
||||
if(myPlusROM.isValid() && myPlusROM.pokeHotspot(address, value))
|
||||
return true;
|
||||
#endif
|
||||
|
||||
// Switch banks if necessary
|
||||
if (checkSwitchBank(address & ADDR_MASK, value))
|
||||
|
|
@ -387,10 +383,10 @@ bool CartridgeEnhanced::save(Serializer& out) const
|
|||
out.putIntArray(myCurrentSegOffset.get(), myBankSegs);
|
||||
if(myRamSize > 0)
|
||||
out.putByteArray(myRAM.get(), myRamSize);
|
||||
#if 0
|
||||
|
||||
if(myPlusROM.isValid() && !myPlusROM.save(out))
|
||||
return false;
|
||||
#endif
|
||||
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
|
|
@ -409,10 +405,9 @@ bool CartridgeEnhanced::load(Serializer& in)
|
|||
in.getIntArray(myCurrentSegOffset.get(), myBankSegs);
|
||||
if(myRamSize > 0)
|
||||
in.getByteArray(myRAM.get(), myRamSize);
|
||||
#if 0
|
||||
|
||||
if(myPlusROM.isValid() && !myPlusROM.load(in))
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -16,9 +16,141 @@
|
|||
//============================================================================
|
||||
|
||||
#include <regex>
|
||||
#include <atomic>
|
||||
#include <sstream>
|
||||
#include <thread>
|
||||
|
||||
#include "bspf.hxx"
|
||||
#include "PlusROM.hxx"
|
||||
#include "http_lib.hxx"
|
||||
#include "Logger.hxx"
|
||||
#include "Version.hxx"
|
||||
|
||||
namespace {
|
||||
constexpr int MAX_CONCURRENT_REQUESTS = 5;
|
||||
constexpr int CONNECTION_TIMEOUT_MSEC = 3000;
|
||||
constexpr int READ_TIMEOUT_MSEC = 3000;
|
||||
constexpr int WRITE_TIMEOUT_MSEC = 3000;
|
||||
}
|
||||
|
||||
using std::chrono::milliseconds;
|
||||
|
||||
class PlusROMRequest {
|
||||
public:
|
||||
|
||||
struct Destination {
|
||||
Destination(string _host, string _path) : host(_host), path(_path) {}
|
||||
|
||||
string host;
|
||||
string path;
|
||||
};
|
||||
|
||||
struct PlusStoreId {
|
||||
PlusStoreId(string _nick, string _id) : nick(_nick), id(_id) {}
|
||||
|
||||
string nick;
|
||||
string id;
|
||||
};
|
||||
|
||||
enum class State : uInt8 {
|
||||
created,
|
||||
pending,
|
||||
done,
|
||||
failed
|
||||
};
|
||||
|
||||
public:
|
||||
|
||||
PlusROMRequest(Destination destination, PlusStoreId id, const uInt8* request, uInt8 requestSize)
|
||||
: myDestination(destination), myId(id), myRequestSize(requestSize)
|
||||
{
|
||||
myState = State::created;
|
||||
memcpy(myRequest.data(), request, myRequestSize);
|
||||
}
|
||||
|
||||
void execute() {
|
||||
myState = State::pending;
|
||||
|
||||
httplib::Client client(myDestination.host);
|
||||
httplib::Headers headers = {
|
||||
{"PlusStore-ID", myId.nick + " WE" + myId.id},
|
||||
{"User-Agent", string("Stella ") + STELLA_VERSION}
|
||||
};
|
||||
|
||||
client.set_connection_timeout(milliseconds(CONNECTION_TIMEOUT_MSEC));
|
||||
client.set_read_timeout(milliseconds(READ_TIMEOUT_MSEC));
|
||||
client.set_write_timeout(milliseconds(WRITE_TIMEOUT_MSEC));
|
||||
|
||||
auto response = client.Post(
|
||||
myDestination.path.c_str(),
|
||||
headers,
|
||||
reinterpret_cast<const char*>(myRequest.data()),
|
||||
myRequestSize,
|
||||
"application/octet-stream"
|
||||
);
|
||||
|
||||
if (response->status != 200) {
|
||||
ostringstream ss;
|
||||
ss
|
||||
<< "PlusCart: request to "
|
||||
<< myDestination.host
|
||||
<< "/"
|
||||
<< myDestination.path
|
||||
<< ": failed with HTTP status "
|
||||
<< response->status;
|
||||
|
||||
Logger::error(ss.str());
|
||||
|
||||
myState = State::failed;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (response->body.size() < 1 || static_cast<unsigned char>(response->body[0]) != (response->body.size() - 1)) {
|
||||
ostringstream ss;
|
||||
ss << "PlusCart: request to " << myDestination.host << "/" << myDestination.path << ": invalid response";
|
||||
|
||||
Logger::error(ss.str());
|
||||
|
||||
myState = State::failed;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
myResponse = response->body;
|
||||
myState = State::done;
|
||||
}
|
||||
|
||||
State getState() {
|
||||
return myState;
|
||||
}
|
||||
|
||||
std::pair<size_t, const uInt8*> getResponse() {
|
||||
if (myState != State::done) throw runtime_error("invalid access to response");
|
||||
|
||||
return std::pair<size_t, const uInt8*>(
|
||||
myResponse.size() - 1,
|
||||
myResponse.size() > 1 ? reinterpret_cast<const uInt8*>(myResponse.data() + 1) : nullptr
|
||||
);
|
||||
}
|
||||
|
||||
private:
|
||||
std::atomic<State> myState;
|
||||
|
||||
Destination myDestination;
|
||||
PlusStoreId myId;
|
||||
|
||||
std::array<uInt8, 256> myRequest;
|
||||
uInt8 myRequestSize;
|
||||
|
||||
string myResponse;
|
||||
|
||||
private:
|
||||
PlusROMRequest(const PlusROMRequest&) = delete;
|
||||
PlusROMRequest(PlusROMRequest&&) = delete;
|
||||
PlusROMRequest& operator=(const PlusROMRequest&) = delete;
|
||||
PlusROMRequest& operator=(PlusROMRequest&&) = delete;
|
||||
};
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
bool PlusROM::initialize(const ByteBuffer& image, size_t size)
|
||||
|
|
@ -48,8 +180,11 @@ bool PlusROM::initialize(const ByteBuffer& image, size_t size)
|
|||
if(i >= size || image[i] != 0 || !isValidHost(host))
|
||||
return myIsPlusROM = false; // Invalid host
|
||||
|
||||
myURL = "http://" + host + "/" + path;
|
||||
cerr << "URL: " << myURL << endl;
|
||||
myHost = host;
|
||||
myPath = "/" + path;
|
||||
|
||||
reset();
|
||||
|
||||
return myIsPlusROM = true;
|
||||
}
|
||||
|
||||
|
|
@ -59,11 +194,21 @@ bool PlusROM::peekHotspot(uInt16 address, uInt8& value)
|
|||
switch(address & 0x0FFF)
|
||||
{
|
||||
case 0x0FF2: // Read next byte from Rx buffer
|
||||
return false;
|
||||
receive();
|
||||
|
||||
value = myRxBuffer[myRxReadPos];
|
||||
if (myRxReadPos != myRxWritePos) myRxReadPos++;
|
||||
|
||||
return true;
|
||||
|
||||
case 0x0FF3: // Get number of unread bytes in Rx buffer
|
||||
return false;
|
||||
receive();
|
||||
|
||||
value = myRxWritePos - myRxReadPos;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -73,11 +218,17 @@ bool PlusROM::pokeHotspot(uInt16 address, uInt8 value)
|
|||
switch(address & 0x0FFF)
|
||||
{
|
||||
case 0x0FF0: // Write byte to Tx buffer
|
||||
return false;
|
||||
myTxBuffer[myTxPos++] = value;
|
||||
|
||||
return true;
|
||||
|
||||
case 0x0FF1: // Write byte to Tx buffer and send to backend
|
||||
// (and receive into Rx buffer)
|
||||
return false;
|
||||
|
||||
myTxBuffer[myTxPos++] = value;
|
||||
send();
|
||||
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
|
@ -89,6 +240,9 @@ bool PlusROM::save(Serializer& out) const
|
|||
{
|
||||
out.putByteArray(myRxBuffer.data(), myRxBuffer.size());
|
||||
out.putByteArray(myTxBuffer.data(), myTxBuffer.size());
|
||||
out.putInt(myRxReadPos);
|
||||
out.putInt(myRxWritePos);
|
||||
out.putInt(myTxPos);
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
|
|
@ -102,10 +256,15 @@ bool PlusROM::save(Serializer& out) const
|
|||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
bool PlusROM::load(Serializer& in)
|
||||
{
|
||||
myPendingRequests.clear();
|
||||
|
||||
try
|
||||
{
|
||||
in.getByteArray(myRxBuffer.data(), myRxBuffer.size());
|
||||
in.getByteArray(myTxBuffer.data(), myTxBuffer.size());
|
||||
myRxReadPos = in.getInt();
|
||||
myRxWritePos = in.getInt();
|
||||
myTxPos = in.getInt();
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
|
|
@ -116,6 +275,13 @@ bool PlusROM::load(Serializer& in)
|
|||
return true;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void PlusROM::reset()
|
||||
{
|
||||
myRxReadPos = myRxWritePos = myTxPos = 0;
|
||||
myPendingRequests.clear();
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
bool PlusROM::isValidHost(const string& host) const
|
||||
{
|
||||
|
|
@ -140,3 +306,73 @@ bool PlusROM::isValidPath(const string& path) const
|
|||
|
||||
return true;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void PlusROM::send()
|
||||
{
|
||||
if (myPendingRequests.size() >= MAX_CONCURRENT_REQUESTS) {
|
||||
// Try to make room by cosuming any requests that have completed.
|
||||
receive();
|
||||
}
|
||||
|
||||
if (myPendingRequests.size() >= MAX_CONCURRENT_REQUESTS) {
|
||||
Logger::error("PlusCart: max number of concurrent requests exceeded");
|
||||
|
||||
myTxPos = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
auto request = make_shared<PlusROMRequest>(
|
||||
PlusROMRequest::Destination(myHost, myPath),
|
||||
PlusROMRequest::PlusStoreId("DirtyHairy", "0123456789012345678912"),
|
||||
myTxBuffer.data(),
|
||||
myTxPos
|
||||
);
|
||||
|
||||
myTxPos = 0;
|
||||
|
||||
// We push to the back in order to avoid reverse_iterator in receive()
|
||||
myPendingRequests.push_back(request);
|
||||
|
||||
// The lambda will retain a copy of the shared_ptr that is alive as long as the
|
||||
// thread is running. Thus, the request can only be destructed once the thread has
|
||||
// finished, and we can safely evict it from the deque at any time.
|
||||
std::thread thread([=](){ request->execute(); });
|
||||
|
||||
thread.detach();
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
void PlusROM::receive()
|
||||
{
|
||||
auto iter = myPendingRequests.begin();
|
||||
|
||||
while (iter != myPendingRequests.end()) {
|
||||
switch ((*iter)->getState()) {
|
||||
case PlusROMRequest::State::failed:
|
||||
// Request has failed? -> remove it and start over
|
||||
myPendingRequests.erase(iter);
|
||||
iter = myPendingRequests.begin();
|
||||
|
||||
continue;
|
||||
|
||||
case PlusROMRequest::State::done:
|
||||
{
|
||||
// Request has finished sucessfully? -> consume the response, remove it
|
||||
// and start over
|
||||
auto [responseSize, response] = (*iter)->getResponse();
|
||||
|
||||
for (uInt8 i = 0; i < responseSize; i++)
|
||||
myRxBuffer[myRxWritePos++] = response[i];
|
||||
|
||||
myPendingRequests.erase(iter);
|
||||
iter = myPendingRequests.begin();
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
default:
|
||||
iter++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,6 +18,8 @@
|
|||
#ifndef PLUSROM_HXX
|
||||
#define PLUSROM_HXX
|
||||
|
||||
#include <deque>
|
||||
|
||||
#include "bspf.hxx"
|
||||
#include "Serializable.hxx"
|
||||
|
||||
|
|
@ -42,6 +44,9 @@
|
|||
|
||||
@author Stephen Anthony
|
||||
*/
|
||||
|
||||
class PlusROMRequest;
|
||||
|
||||
class PlusROM : public Serializable
|
||||
{
|
||||
public:
|
||||
|
|
@ -108,18 +113,34 @@ class PlusROM : public Serializable
|
|||
*/
|
||||
bool load(Serializer& in) override;
|
||||
|
||||
/**
|
||||
Reset.
|
||||
*/
|
||||
void reset();
|
||||
|
||||
private:
|
||||
//////////////////////////////////////////////////////
|
||||
// These probably belong in the networking library
|
||||
bool isValidHost(const string& host) const;
|
||||
bool isValidPath(const string& path) const;
|
||||
//////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
Receive data from all requests that have completed.
|
||||
*/
|
||||
void receive();
|
||||
|
||||
/**
|
||||
Send pending data to the backend on a thread.
|
||||
*/
|
||||
void send();
|
||||
|
||||
private:
|
||||
bool myIsPlusROM{false};
|
||||
string myURL;
|
||||
string myHost;
|
||||
string myPath;
|
||||
|
||||
std::array<uInt8, 256> myRxBuffer, myTxBuffer;
|
||||
uInt8 myRxReadPos, myRxWritePos, myTxPos;
|
||||
|
||||
std::deque<shared_ptr<PlusROMRequest>> myPendingRequests;
|
||||
|
||||
private:
|
||||
// Following constructors and assignment operators not supported
|
||||
|
|
|
|||
|
|
@ -0,0 +1,22 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2017 yhirose
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
||||
|
|
@ -0,0 +1,800 @@
|
|||
cpp-httplib
|
||||
===========
|
||||
|
||||
[](https://github.com/yhirose/cpp-httplib/actions)
|
||||
|
||||
A C++11 single-file header-only cross platform HTTP/HTTPS library.
|
||||
|
||||
It's extremely easy to setup. Just include the **httplib.h** file in your code!
|
||||
|
||||
NOTE: This is a multi-threaded 'blocking' HTTP library. If you are looking for a 'non-blocking' library, this is not the one that you want.
|
||||
|
||||
Simple examples
|
||||
---------------
|
||||
|
||||
#### Server
|
||||
|
||||
```c++
|
||||
#define CPPHTTPLIB_OPENSSL_SUPPORT
|
||||
#include "path/to/httplib.h"
|
||||
|
||||
// HTTP
|
||||
httplib::Server svr;
|
||||
|
||||
// HTTPS
|
||||
httplib::SSLServer svr;
|
||||
|
||||
svr.Get("/hi", [](const httplib::Request &, httplib::Response &res) {
|
||||
res.set_content("Hello World!", "text/plain");
|
||||
});
|
||||
|
||||
svr.listen("0.0.0.0", 8080);
|
||||
```
|
||||
|
||||
#### Client
|
||||
|
||||
```c++
|
||||
#define CPPHTTPLIB_OPENSSL_SUPPORT
|
||||
#include "path/to/httplib.h"
|
||||
|
||||
// HTTP
|
||||
httplib::Client cli("http://cpp-httplib-server.yhirose.repl.co");
|
||||
|
||||
// HTTPS
|
||||
httplib::Client cli("https://cpp-httplib-server.yhirose.repl.co");
|
||||
|
||||
auto res = cli.Get("/hi");
|
||||
res->status;
|
||||
res->body;
|
||||
```
|
||||
|
||||
### Try out the examples on Repl.it!
|
||||
|
||||
1. Run server at https://repl.it/@yhirose/cpp-httplib-server
|
||||
2. Run client at https://repl.it/@yhirose/cpp-httplib-client
|
||||
|
||||
SSL Support
|
||||
-----------
|
||||
|
||||
SSL support is available with `CPPHTTPLIB_OPENSSL_SUPPORT`. `libssl` and `libcrypto` should be linked.
|
||||
|
||||
NOTE: cpp-httplib currently supports only version 1.1.1.
|
||||
|
||||
```c++
|
||||
#define CPPHTTPLIB_OPENSSL_SUPPORT
|
||||
#include "path/to/httplib.h"
|
||||
|
||||
// Server
|
||||
httplib::SSLServer svr("./cert.pem", "./key.pem");
|
||||
|
||||
// Client
|
||||
httplib::Client cli("https://localhost:1234"); // scheme + host
|
||||
httplib::SSLClient cli("localhost:1234"); // host
|
||||
|
||||
// Use your CA bundle
|
||||
cli.set_ca_cert_path("./ca-bundle.crt");
|
||||
|
||||
// Disable cert verification
|
||||
cli.enable_server_certificate_verification(false);
|
||||
```
|
||||
|
||||
Note: When using SSL, it seems impossible to avoid SIGPIPE in all cases, since on some operating systems, SIGPIPE can only be suppressed on a per-message basis, but there is no way to make the OpenSSL library do so for its internal communications. If your program needs to avoid being terminated on SIGPIPE, the only fully general way might be to set up a signal handler for SIGPIPE to handle or ignore it yourself.
|
||||
|
||||
Server
|
||||
------
|
||||
|
||||
```c++
|
||||
#include <httplib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
using namespace httplib;
|
||||
|
||||
Server svr;
|
||||
|
||||
svr.Get("/hi", [](const Request& req, Response& res) {
|
||||
res.set_content("Hello World!", "text/plain");
|
||||
});
|
||||
|
||||
svr.Get(R"(/numbers/(\d+))", [&](const Request& req, Response& res) {
|
||||
auto numbers = req.matches[1];
|
||||
res.set_content(numbers, "text/plain");
|
||||
});
|
||||
|
||||
svr.Get("/body-header-param", [](const Request& req, Response& res) {
|
||||
if (req.has_header("Content-Length")) {
|
||||
auto val = req.get_header_value("Content-Length");
|
||||
}
|
||||
if (req.has_param("key")) {
|
||||
auto val = req.get_param_value("key");
|
||||
}
|
||||
res.set_content(req.body, "text/plain");
|
||||
});
|
||||
|
||||
svr.Get("/stop", [&](const Request& req, Response& res) {
|
||||
svr.stop();
|
||||
});
|
||||
|
||||
svr.listen("localhost", 1234);
|
||||
}
|
||||
```
|
||||
|
||||
`Post`, `Put`, `Delete` and `Options` methods are also supported.
|
||||
|
||||
### Bind a socket to multiple interfaces and any available port
|
||||
|
||||
```cpp
|
||||
int port = svr.bind_to_any_port("0.0.0.0");
|
||||
svr.listen_after_bind();
|
||||
```
|
||||
|
||||
### Static File Server
|
||||
|
||||
```cpp
|
||||
// Mount / to ./www directory
|
||||
auto ret = svr.set_mount_point("/", "./www");
|
||||
if (!ret) {
|
||||
// The specified base directory doesn't exist...
|
||||
}
|
||||
|
||||
// Mount /public to ./www directory
|
||||
ret = svr.set_mount_point("/public", "./www");
|
||||
|
||||
// Mount /public to ./www1 and ./www2 directories
|
||||
ret = svr.set_mount_point("/public", "./www1"); // 1st order to search
|
||||
ret = svr.set_mount_point("/public", "./www2"); // 2nd order to search
|
||||
|
||||
// Remove mount /
|
||||
ret = svr.remove_mount_point("/");
|
||||
|
||||
// Remove mount /public
|
||||
ret = svr.remove_mount_point("/public");
|
||||
```
|
||||
|
||||
```cpp
|
||||
// User defined file extension and MIME type mappings
|
||||
svr.set_file_extension_and_mimetype_mapping("cc", "text/x-c");
|
||||
svr.set_file_extension_and_mimetype_mapping("cpp", "text/x-c");
|
||||
svr.set_file_extension_and_mimetype_mapping("hh", "text/x-h");
|
||||
```
|
||||
|
||||
The followings are built-in mappings:
|
||||
|
||||
| Extension | MIME Type | Extension | MIME Type |
|
||||
| :--------- | :-------------------------- | :--------- | :-------------------------- |
|
||||
| css | text/css | mpga | audio/mpeg |
|
||||
| csv | text/csv | weba | audio/webm |
|
||||
| txt | text/plain | wav | audio/wave |
|
||||
| vtt | text/vtt | otf | font/otf |
|
||||
| html, htm | text/html | ttf | font/ttf |
|
||||
| apng | image/apng | woff | font/woff |
|
||||
| avif | image/avif | woff2 | font/woff2 |
|
||||
| bmp | image/bmp | 7z | application/x-7z-compressed |
|
||||
| gif | image/gif | atom | application/atom+xml |
|
||||
| png | image/png | pdf | application/pdf |
|
||||
| svg | image/svg+xml | mjs, js | application/javascript |
|
||||
| webp | image/webp | json | application/json |
|
||||
| ico | image/x-icon | rss | application/rss+xml |
|
||||
| tif | image/tiff | tar | application/x-tar |
|
||||
| tiff | image/tiff | xhtml, xht | application/xhtml+xml |
|
||||
| jpeg, jpg | image/jpeg | xslt | application/xslt+xml |
|
||||
| mp4 | video/mp4 | xml | application/xml |
|
||||
| mpeg | video/mpeg | gz | application/gzip |
|
||||
| webm | video/webm | zip | application/zip |
|
||||
| mp3 | audio/mp3 | wasm | application/wasm |
|
||||
|
||||
NOTE: These static file server methods are not thread-safe.
|
||||
|
||||
### Logging
|
||||
|
||||
```cpp
|
||||
svr.set_logger([](const auto& req, const auto& res) {
|
||||
your_logger(req, res);
|
||||
});
|
||||
```
|
||||
|
||||
### Error handler
|
||||
|
||||
```cpp
|
||||
svr.set_error_handler([](const auto& req, auto& res) {
|
||||
auto fmt = "<p>Error Status: <span style='color:red;'>%d</span></p>";
|
||||
char buf[BUFSIZ];
|
||||
snprintf(buf, sizeof(buf), fmt, res.status);
|
||||
res.set_content(buf, "text/html");
|
||||
});
|
||||
```
|
||||
|
||||
### Exception handler
|
||||
The exception handler gets called if a user routing handler throws an error.
|
||||
|
||||
```cpp
|
||||
svr.set_exception_handler([](const auto& req, auto& res, std::exception &e) {
|
||||
res.status = 500;
|
||||
auto fmt = "<h1>Error 500</h1><p>%s</p>";
|
||||
char buf[BUFSIZ];
|
||||
snprintf(buf, sizeof(buf), fmt, e.what());
|
||||
res.set_content(buf, "text/html");
|
||||
});
|
||||
```
|
||||
|
||||
### Pre routing handler
|
||||
|
||||
```cpp
|
||||
svr.set_pre_routing_handler([](const auto& req, auto& res) -> bool {
|
||||
if (req.path == "/hello") {
|
||||
res.set_content("world", "text/html");
|
||||
return Server::HandlerResponse::Handled;
|
||||
}
|
||||
return Server::HandlerResponse::Unhandled;
|
||||
});
|
||||
```
|
||||
|
||||
### Post routing handler
|
||||
|
||||
```cpp
|
||||
svr.set_post_routing_handler([](const auto& req, auto& res) {
|
||||
res.set_header("ADDITIONAL_HEADER", "value");
|
||||
});
|
||||
```
|
||||
|
||||
### 'multipart/form-data' POST data
|
||||
|
||||
```cpp
|
||||
svr.Post("/multipart", [&](const auto& req, auto& res) {
|
||||
auto size = req.files.size();
|
||||
auto ret = req.has_file("name1");
|
||||
const auto& file = req.get_file_value("name1");
|
||||
// file.filename;
|
||||
// file.content_type;
|
||||
// file.content;
|
||||
});
|
||||
```
|
||||
|
||||
### Receive content with a content receiver
|
||||
|
||||
```cpp
|
||||
svr.Post("/content_receiver",
|
||||
[&](const Request &req, Response &res, const ContentReader &content_reader) {
|
||||
if (req.is_multipart_form_data()) {
|
||||
// NOTE: `content_reader` is blocking until every form data field is read
|
||||
MultipartFormDataItems files;
|
||||
content_reader(
|
||||
[&](const MultipartFormData &file) {
|
||||
files.push_back(file);
|
||||
return true;
|
||||
},
|
||||
[&](const char *data, size_t data_length) {
|
||||
files.back().content.append(data, data_length);
|
||||
return true;
|
||||
});
|
||||
} else {
|
||||
std::string body;
|
||||
content_reader([&](const char *data, size_t data_length) {
|
||||
body.append(data, data_length);
|
||||
return true;
|
||||
});
|
||||
}
|
||||
});
|
||||
```
|
||||
|
||||
### Send content with the content provider
|
||||
|
||||
```cpp
|
||||
const size_t DATA_CHUNK_SIZE = 4;
|
||||
|
||||
svr.Get("/stream", [&](const Request &req, Response &res) {
|
||||
auto data = new std::string("abcdefg");
|
||||
|
||||
res.set_content_provider(
|
||||
data->size(), // Content length
|
||||
"text/plain", // Content type
|
||||
[data](size_t offset, size_t length, DataSink &sink) {
|
||||
const auto &d = *data;
|
||||
sink.write(&d[offset], std::min(length, DATA_CHUNK_SIZE));
|
||||
return true; // return 'false' if you want to cancel the process.
|
||||
},
|
||||
[data](bool success) { delete data; });
|
||||
});
|
||||
```
|
||||
|
||||
Without content length:
|
||||
|
||||
```cpp
|
||||
svr.Get("/stream", [&](const Request &req, Response &res) {
|
||||
res.set_content_provider(
|
||||
"text/plain", // Content type
|
||||
[&](size_t offset, size_t length, DataSink &sink) {
|
||||
if (/* there is still data */) {
|
||||
std::vector<char> data;
|
||||
// prepare data...
|
||||
sink.write(data.data(), data.size());
|
||||
} else {
|
||||
sink.done(); // No more data
|
||||
}
|
||||
return true; // return 'false' if you want to cancel the process.
|
||||
});
|
||||
});
|
||||
```
|
||||
|
||||
### Chunked transfer encoding
|
||||
|
||||
```cpp
|
||||
svr.Get("/chunked", [&](const Request& req, Response& res) {
|
||||
res.set_chunked_content_provider(
|
||||
"text/plain",
|
||||
[](size_t offset, DataSink &sink) {
|
||||
sink.write("123", 3);
|
||||
sink.write("345", 3);
|
||||
sink.write("789", 3);
|
||||
sink.done(); // No more data
|
||||
return true; // return 'false' if you want to cancel the process.
|
||||
}
|
||||
);
|
||||
});
|
||||
```
|
||||
|
||||
### 'Expect: 100-continue' handler
|
||||
|
||||
By default, the server sends a `100 Continue` response for an `Expect: 100-continue` header.
|
||||
|
||||
```cpp
|
||||
// Send a '417 Expectation Failed' response.
|
||||
svr.set_expect_100_continue_handler([](const Request &req, Response &res) {
|
||||
return 417;
|
||||
});
|
||||
```
|
||||
|
||||
```cpp
|
||||
// Send a final status without reading the message body.
|
||||
svr.set_expect_100_continue_handler([](const Request &req, Response &res) {
|
||||
return res.status = 401;
|
||||
});
|
||||
```
|
||||
|
||||
### Keep-Alive connection
|
||||
|
||||
```cpp
|
||||
svr.set_keep_alive_max_count(2); // Default is 5
|
||||
svr.set_keep_alive_timeout(10); // Default is 5
|
||||
```
|
||||
|
||||
### Timeout
|
||||
|
||||
```c++
|
||||
svr.set_read_timeout(5, 0); // 5 seconds
|
||||
svr.set_write_timeout(5, 0); // 5 seconds
|
||||
svr.set_idle_interval(0, 100000); // 100 milliseconds
|
||||
```
|
||||
|
||||
### Set maximum payload length for reading a request body
|
||||
|
||||
```c++
|
||||
svr.set_payload_max_length(1024 * 1024 * 512); // 512MB
|
||||
```
|
||||
|
||||
### Server-Sent Events
|
||||
|
||||
Please see [Server example](https://github.com/yhirose/cpp-httplib/blob/master/example/ssesvr.cc) and [Client example](https://github.com/yhirose/cpp-httplib/blob/master/example/ssecli.cc).
|
||||
|
||||
### Default thread pool support
|
||||
|
||||
`ThreadPool` is used as a **default** task queue, and the default thread count is 8, or `std::thread::hardware_concurrency()`. You can change it with `CPPHTTPLIB_THREAD_POOL_COUNT`.
|
||||
|
||||
If you want to set the thread count at runtime, there is no convenient way... But here is how.
|
||||
|
||||
```cpp
|
||||
svr.new_task_queue = [] { return new ThreadPool(12); };
|
||||
```
|
||||
|
||||
### Override the default thread pool with yours
|
||||
|
||||
You can supply your own thread pool implementation according to your need.
|
||||
|
||||
```cpp
|
||||
class YourThreadPoolTaskQueue : public TaskQueue {
|
||||
public:
|
||||
YourThreadPoolTaskQueue(size_t n) {
|
||||
pool_.start_with_thread_count(n);
|
||||
}
|
||||
|
||||
virtual void enqueue(std::function<void()> fn) override {
|
||||
pool_.enqueue(fn);
|
||||
}
|
||||
|
||||
virtual void shutdown() override {
|
||||
pool_.shutdown_gracefully();
|
||||
}
|
||||
|
||||
private:
|
||||
YourThreadPool pool_;
|
||||
};
|
||||
|
||||
svr.new_task_queue = [] {
|
||||
return new YourThreadPoolTaskQueue(12);
|
||||
};
|
||||
```
|
||||
|
||||
Client
|
||||
------
|
||||
|
||||
```c++
|
||||
#include <httplib.h>
|
||||
#include <iostream>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
httplib::Client cli("localhost", 1234);
|
||||
|
||||
if (auto res = cli.Get("/hi")) {
|
||||
if (res->status == 200) {
|
||||
std::cout << res->body << std::endl;
|
||||
}
|
||||
} else {
|
||||
auto err = res.error();
|
||||
...
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
NOTE: Constructor with scheme-host-port string is now supported!
|
||||
|
||||
```c++
|
||||
httplib::Client cli("localhost");
|
||||
httplib::Client cli("localhost:8080");
|
||||
httplib::Client cli("http://localhost");
|
||||
httplib::Client cli("http://localhost:8080");
|
||||
httplib::Client cli("https://localhost");
|
||||
httplib::SSLClient cli("localhost");
|
||||
```
|
||||
|
||||
### Error code
|
||||
|
||||
Here is the list of errors from `Result::error()`.
|
||||
|
||||
```c++
|
||||
enum Error {
|
||||
Success = 0,
|
||||
Unknown,
|
||||
Connection,
|
||||
BindIPAddress,
|
||||
Read,
|
||||
Write,
|
||||
ExceedRedirectCount,
|
||||
Canceled,
|
||||
SSLConnection,
|
||||
SSLLoadingCerts,
|
||||
SSLServerVerification,
|
||||
UnsupportedMultipartBoundaryChars
|
||||
};
|
||||
```
|
||||
|
||||
### GET with HTTP headers
|
||||
|
||||
```c++
|
||||
httplib::Headers headers = {
|
||||
{ "Accept-Encoding", "gzip, deflate" }
|
||||
};
|
||||
auto res = cli.Get("/hi", headers);
|
||||
```
|
||||
or
|
||||
```c++
|
||||
cli.set_default_headers({
|
||||
{ "Accept-Encoding", "gzip, deflate" }
|
||||
});
|
||||
auto res = cli.Get("/hi");
|
||||
```
|
||||
|
||||
### POST
|
||||
|
||||
```c++
|
||||
res = cli.Post("/post", "text", "text/plain");
|
||||
res = cli.Post("/person", "name=john1¬e=coder", "application/x-www-form-urlencoded");
|
||||
```
|
||||
|
||||
### POST with parameters
|
||||
|
||||
```c++
|
||||
httplib::Params params;
|
||||
params.emplace("name", "john");
|
||||
params.emplace("note", "coder");
|
||||
|
||||
auto res = cli.Post("/post", params);
|
||||
```
|
||||
or
|
||||
|
||||
```c++
|
||||
httplib::Params params{
|
||||
{ "name", "john" },
|
||||
{ "note", "coder" }
|
||||
};
|
||||
|
||||
auto res = cli.Post("/post", params);
|
||||
```
|
||||
|
||||
### POST with Multipart Form Data
|
||||
|
||||
```c++
|
||||
httplib::MultipartFormDataItems items = {
|
||||
{ "text1", "text default", "", "" },
|
||||
{ "text2", "aωb", "", "" },
|
||||
{ "file1", "h\ne\n\nl\nl\no\n", "hello.txt", "text/plain" },
|
||||
{ "file2", "{\n \"world\", true\n}\n", "world.json", "application/json" },
|
||||
{ "file3", "", "", "application/octet-stream" },
|
||||
};
|
||||
|
||||
auto res = cli.Post("/multipart", items);
|
||||
```
|
||||
|
||||
### PUT
|
||||
|
||||
```c++
|
||||
res = cli.Put("/resource/foo", "text", "text/plain");
|
||||
```
|
||||
|
||||
### DELETE
|
||||
|
||||
```c++
|
||||
res = cli.Delete("/resource/foo");
|
||||
```
|
||||
|
||||
### OPTIONS
|
||||
|
||||
```c++
|
||||
res = cli.Options("*");
|
||||
res = cli.Options("/resource/foo");
|
||||
```
|
||||
|
||||
### Timeout
|
||||
|
||||
```c++
|
||||
cli.set_connection_timeout(0, 300000); // 300 milliseconds
|
||||
cli.set_read_timeout(5, 0); // 5 seconds
|
||||
cli.set_write_timeout(5, 0); // 5 seconds
|
||||
```
|
||||
|
||||
### Receive content with a content receiver
|
||||
|
||||
```c++
|
||||
std::string body;
|
||||
|
||||
auto res = cli.Get("/large-data",
|
||||
[&](const char *data, size_t data_length) {
|
||||
body.append(data, data_length);
|
||||
return true;
|
||||
});
|
||||
```
|
||||
|
||||
```cpp
|
||||
std::string body;
|
||||
|
||||
auto res = cli.Get(
|
||||
"/stream", Headers(),
|
||||
[&](const Response &response) {
|
||||
EXPECT_EQ(200, response.status);
|
||||
return true; // return 'false' if you want to cancel the request.
|
||||
},
|
||||
[&](const char *data, size_t data_length) {
|
||||
body.append(data, data_length);
|
||||
return true; // return 'false' if you want to cancel the request.
|
||||
});
|
||||
```
|
||||
|
||||
### Send content with a content provider
|
||||
|
||||
```cpp
|
||||
std::string body = ...;
|
||||
|
||||
auto res = cli.Post(
|
||||
"/stream", body.size(),
|
||||
[](size_t offset, size_t length, DataSink &sink) {
|
||||
sink.write(body.data() + offset, length);
|
||||
return true; // return 'false' if you want to cancel the request.
|
||||
},
|
||||
"text/plain");
|
||||
```
|
||||
|
||||
### Chunked transfer encoding
|
||||
|
||||
```cpp
|
||||
auto res = cli.Post(
|
||||
"/stream",
|
||||
[](size_t offset, DataSink &sink) {
|
||||
sink.os << "chunked data 1";
|
||||
sink.os << "chunked data 2";
|
||||
sink.os << "chunked data 3";
|
||||
sink.done();
|
||||
return true; // return 'false' if you want to cancel the request.
|
||||
},
|
||||
"text/plain");
|
||||
```
|
||||
|
||||
### With Progress Callback
|
||||
|
||||
```cpp
|
||||
httplib::Client client(url, port);
|
||||
|
||||
// prints: 0 / 000 bytes => 50% complete
|
||||
auto res = cli.Get("/", [](uint64_t len, uint64_t total) {
|
||||
printf("%lld / %lld bytes => %d%% complete\n",
|
||||
len, total,
|
||||
(int)(len*100/total));
|
||||
return true; // return 'false' if you want to cancel the request.
|
||||
}
|
||||
);
|
||||
```
|
||||
|
||||
|
||||
|
||||
### Authentication
|
||||
|
||||
```cpp
|
||||
// Basic Authentication
|
||||
cli.set_basic_auth("user", "pass");
|
||||
|
||||
// Digest Authentication
|
||||
cli.set_digest_auth("user", "pass");
|
||||
|
||||
// Bearer Token Authentication
|
||||
cli.set_bearer_token_auth("token");
|
||||
```
|
||||
|
||||
NOTE: OpenSSL is required for Digest Authentication.
|
||||
|
||||
### Proxy server support
|
||||
|
||||
```cpp
|
||||
cli.set_proxy("host", port);
|
||||
|
||||
// Basic Authentication
|
||||
cli.set_proxy_basic_auth("user", "pass");
|
||||
|
||||
// Digest Authentication
|
||||
cli.set_proxy_digest_auth("user", "pass");
|
||||
|
||||
// Bearer Token Authentication
|
||||
cli.set_proxy_bearer_token_auth("pass");
|
||||
```
|
||||
|
||||
NOTE: OpenSSL is required for Digest Authentication.
|
||||
|
||||
### Range
|
||||
|
||||
```cpp
|
||||
httplib::Client cli("httpbin.org");
|
||||
|
||||
auto res = cli.Get("/range/32", {
|
||||
httplib::make_range_header({{1, 10}}) // 'Range: bytes=1-10'
|
||||
});
|
||||
// res->status should be 206.
|
||||
// res->body should be "bcdefghijk".
|
||||
```
|
||||
|
||||
```cpp
|
||||
httplib::make_range_header({{1, 10}, {20, -1}}) // 'Range: bytes=1-10, 20-'
|
||||
httplib::make_range_header({{100, 199}, {500, 599}}) // 'Range: bytes=100-199, 500-599'
|
||||
httplib::make_range_header({{0, 0}, {-1, 1}}) // 'Range: bytes=0-0, -1'
|
||||
```
|
||||
|
||||
### Keep-Alive connection
|
||||
|
||||
```cpp
|
||||
httplib::Client cli("localhost", 1234);
|
||||
|
||||
cli.Get("/hello"); // with "Connection: close"
|
||||
|
||||
cli.set_keep_alive(true);
|
||||
cli.Get("/world");
|
||||
|
||||
cli.set_keep_alive(false);
|
||||
cli.Get("/last-request"); // with "Connection: close"
|
||||
```
|
||||
|
||||
### Redirect
|
||||
|
||||
```cpp
|
||||
httplib::Client cli("yahoo.com");
|
||||
|
||||
auto res = cli.Get("/");
|
||||
res->status; // 301
|
||||
|
||||
cli.set_follow_location(true);
|
||||
res = cli.Get("/");
|
||||
res->status; // 200
|
||||
```
|
||||
|
||||
### Use a specific network interface
|
||||
|
||||
NOTE: This feature is not available on Windows, yet.
|
||||
|
||||
```cpp
|
||||
cli.set_interface("eth0"); // Interface name, IP address or host name
|
||||
```
|
||||
|
||||
Compression
|
||||
-----------
|
||||
|
||||
The server can apply compression to the following MIME type contents:
|
||||
|
||||
* all text types except text/event-stream
|
||||
* image/svg+xml
|
||||
* application/javascript
|
||||
* application/json
|
||||
* application/xml
|
||||
* application/xhtml+xml
|
||||
|
||||
### Zlib Support
|
||||
|
||||
'gzip' compression is available with `CPPHTTPLIB_ZLIB_SUPPORT`. `libz` should be linked.
|
||||
|
||||
### Brotli Support
|
||||
|
||||
Brotli compression is available with `CPPHTTPLIB_BROTLI_SUPPORT`. Necessary libraries should be linked.
|
||||
Please see https://github.com/google/brotli for more detail.
|
||||
|
||||
### Compress request body on client
|
||||
|
||||
```c++
|
||||
cli.set_compress(true);
|
||||
res = cli.Post("/resource/foo", "...", "text/plain");
|
||||
```
|
||||
|
||||
### Compress response body on client
|
||||
|
||||
```c++
|
||||
cli.set_decompress(false);
|
||||
res = cli.Get("/resource/foo", {{"Accept-Encoding", "gzip, deflate, br"}});
|
||||
res->body; // Compressed data
|
||||
```
|
||||
|
||||
Split httplib.h into .h and .cc
|
||||
-------------------------------
|
||||
|
||||
```console
|
||||
$ ./split.py -h
|
||||
usage: split.py [-h] [-e EXTENSION] [-o OUT]
|
||||
|
||||
This script splits httplib.h into .h and .cc parts.
|
||||
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
-e EXTENSION, --extension EXTENSION
|
||||
extension of the implementation file (default: cc)
|
||||
-o OUT, --out OUT where to write the files (default: out)
|
||||
|
||||
$ ./split.py
|
||||
Wrote out/httplib.h and out/httplib.cc
|
||||
```
|
||||
|
||||
NOTE
|
||||
----
|
||||
|
||||
### g++
|
||||
|
||||
g++ 4.8 and below cannot build this library since `<regex>` in the versions are [broken](https://stackoverflow.com/questions/12530406/is-gcc-4-8-or-earlier-buggy-about-regular-expressions).
|
||||
|
||||
### Windows
|
||||
|
||||
Include `httplib.h` before `Windows.h` or include `Windows.h` by defining `WIN32_LEAN_AND_MEAN` beforehand.
|
||||
|
||||
```cpp
|
||||
#include <httplib.h>
|
||||
#include <Windows.h>
|
||||
```
|
||||
|
||||
```cpp
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <Windows.h>
|
||||
#include <httplib.h>
|
||||
```
|
||||
|
||||
Note: Windows 8 or lower and Cygwin on Windows are not supported.
|
||||
|
||||
License
|
||||
-------
|
||||
|
||||
MIT license (© 2021 Yuji Hirose)
|
||||
|
||||
Special Thanks To
|
||||
-----------------
|
||||
|
||||
[These folks](https://github.com/yhirose/cpp-httplib/graphs/contributors) made great contributions to polish this library to totally another level from a simple toy!
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
//============================================================================
|
||||
//
|
||||
// SSSS tt lll lll
|
||||
// SS SS tt ll ll
|
||||
// SS tttttt eeee ll ll aaaa
|
||||
// SSSS tt ee ee ll ll aa
|
||||
// SS tt eeeeee ll ll aaaaa -- "An Atari 2600 VCS Emulator"
|
||||
// SS SS tt ee ll ll aa aa
|
||||
// SSSS ttt eeeee llll llll aaaaa
|
||||
//
|
||||
// Copyright (c) 1995-2021 by Bradford W. Mott, Stephen Anthony
|
||||
// and the Stella Team
|
||||
//
|
||||
// See the file "License.txt" for information on usage and redistribution of
|
||||
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||||
//============================================================================
|
||||
|
||||
#ifndef HTTPLIB_LIB_HXX
|
||||
#define HTTPLIB_LIB_HXX
|
||||
|
||||
/*
|
||||
* We can't control the quality of code from outside projects, so for now
|
||||
* just disable warnings for it.
|
||||
*/
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Weverything"
|
||||
#include "httplib.h"
|
||||
#pragma clang diagnostic pop
|
||||
#else
|
||||
#include "httplib.h"
|
||||
#endif
|
||||
|
||||
#endif // HTTPLIB_LIB_HXX
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,5 +1,5 @@
|
|||
LIBRETRO_COMM_DIR = $(CORE_DIR)/../libretro-common
|
||||
INCFLAGS := -I. -I$(CORE_DIR) -I$(CORE_DIR)/libretro -I$(CORE_DIR)/emucore -I$(CORE_DIR)/emucore/tia -I$(CORE_DIR)/common -I$(CORE_DIR)/common/audio -I$(CORE_DIR)/common/tv_filters -I$(CORE_DIR)/common/repository/sqlite -I$(CORE_DIR)/json -I$(CORE_DIR)/sqlite
|
||||
INCFLAGS := -I. -I$(CORE_DIR) -I$(CORE_DIR)/libretro -I$(CORE_DIR)/emucore -I$(CORE_DIR)/emucore/tia -I$(CORE_DIR)/common -I$(CORE_DIR)/common/audio -I$(CORE_DIR)/common/tv_filters -I$(CORE_DIR)/common/repository/sqlite -I$(CORE_DIR)/json -I$(CORE_DIR)/httplib -I$(CORE_DIR)/sqlite
|
||||
|
||||
ifneq (,$(findstring msvc2003,$(platform)))
|
||||
INCFLAGS += -I$(LIBRETRO_COMM_DIR)/include/compat/msvc
|
||||
|
|
|
|||
Loading…
Reference in New Issue