WIP: Moved sources int src/, separated most of the source code from Perl.

The XS was left only for the unit / integration tests, and it links
libslic3r only. No wxWidgets are allowed to be used from Perl starting
from now.

src/slic3r/Utils/ASCIIFolding.hpp

@@ -0,0 +1,15 @@
+#ifndef slic3r_ASCIIFolding_hpp_
+#define slic3r_ASCIIFolding_hpp_
+
+#include <string>
+
+namespace Slic3r {
+
+// If possible, remove accents from accented latin characters.
+// This function is useful for generating file names to be processed by legacy firmwares.
+extern std::string fold_utf8_to_ascii(const char *src);
+extern std::string fold_utf8_to_ascii(const std::string &src);
+
+}; // namespace Slic3r
+
+#endif /* slic3r_ASCIIFolding_hpp_ */

src/slic3r/Utils/Bonjour.cpp

@@ -0,0 +1,781 @@
+#include "Bonjour.hpp"
+
+#include <cstdint>
+#include <algorithm>
+#include <array>
+#include <vector>
+#include <string>
+#include <random>
+#include <thread>
+#include <boost/optional.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/endian/conversion.hpp>
+#include <boost/asio.hpp>
+#include <boost/date_time/posix_time/posix_time_duration.hpp>
+#include <boost/format.hpp>
+
+using boost::optional;
+using boost::system::error_code;
+namespace endian = boost::endian;
+namespace asio = boost::asio;
+using boost::asio::ip::udp;
+
+
+namespace Slic3r {
+
+
+// Minimal implementation of a MDNS/DNS-SD client
+// This implementation is extremely simple, only the bits that are useful
+// for basic MDNS discovery of OctoPi devices are present.
+// However, the bits that are present are implemented with security in mind.
+// Only fully correct DNS replies are allowed through.
+// While decoding the decoder will bail the moment it encounters anything fishy.
+// At least that's the idea. To help prove this is actually the case,
+// the implementations has been tested with AFL.
+
+
+struct DnsName: public std::string
+{
+	enum
+	{
+		MAX_RECURSION = 10,     // Keep this low
+	};
+
+	static optional<DnsName> decode(const std::vector<char> &buffer, size_t &offset, unsigned depth = 0)
+	{
+		// Check offset sanity:
+		if (offset + 1 >= buffer.size()) {
+			return boost::none;
+		}
+
+		// Check for recursion depth to prevent parsing names that are nested too deeply or end up cyclic:
+		if (depth >= MAX_RECURSION) {
+			return boost::none;
+		}
+
+		DnsName res;
+		const size_t bsize = buffer.size();
+
+		while (true) {
+			const char* ptr = buffer.data() + offset;
+			unsigned len = static_cast<unsigned char>(*ptr);
+			if (len & 0xc0) {
+				// This is a recursive label
+				unsigned len_2 = static_cast<unsigned char>(ptr[1]);
+				size_t pointer = (len & 0x3f) << 8 | len_2;
+				const auto nested = decode(buffer, pointer, depth + 1);
+				if (!nested) {
+					return boost::none;
+				} else {
+					if (res.size() > 0) {
+						res.push_back('.');
+					}
+					res.append(*nested);
+					offset += 2;
+					return std::move(res);
+				}
+			} else if (len == 0) {
+				// This is a name terminator
+				offset++;
+				break;
+			} else {
+				// This is a regular label
+				len &= 0x3f;
+				if (len + offset + 1 >= bsize) {
+					return boost::none;
+				}
+
+				res.reserve(len);
+				if (res.size() > 0) {
+					res.push_back('.');
+				}
+
+				ptr++;
+				for (const auto end = ptr + len; ptr < end; ptr++) {
+					char c = *ptr;
+					if (c >= 0x20 && c <= 0x7f) {
+						res.push_back(c);
+					} else {
+						return boost::none;
+					}
+				}
+
+				offset += len + 1;
+			}
+		}
+
+		if (res.size() > 0) {
+			return std::move(res);
+		} else {
+			return boost::none;
+		}
+	}
+};
+
+struct DnsHeader
+{
+	uint16_t id;
+	uint16_t flags;
+	uint16_t qdcount;
+	uint16_t ancount;
+	uint16_t nscount;
+	uint16_t arcount;
+
+	enum
+	{
+		SIZE = 12,
+	};
+
+	static DnsHeader decode(const std::vector<char> &buffer) {
+		DnsHeader res;
+		const uint16_t *data_16 = reinterpret_cast<const uint16_t*>(buffer.data());
+		res.id = endian::big_to_native(data_16[0]);
+		res.flags = endian::big_to_native(data_16[1]);
+		res.qdcount = endian::big_to_native(data_16[2]);
+		res.ancount = endian::big_to_native(data_16[3]);
+		res.nscount = endian::big_to_native(data_16[4]);
+		res.arcount = endian::big_to_native(data_16[5]);
+		return res;
+	}
+
+	uint32_t rrcount() const {
+		return ancount + nscount + arcount;
+	}
+};
+
+struct DnsQuestion
+{
+	enum
+	{
+		MIN_SIZE = 5,
+	};
+
+	DnsName name;
+	uint16_t type;
+	uint16_t qclass;
+
+	DnsQuestion() :
+		type(0),
+		qclass(0)
+	{}
+
+	static optional<DnsQuestion> decode(const std::vector<char> &buffer, size_t &offset)
+	{
+		auto qname = DnsName::decode(buffer, offset);
+		if (!qname) {
+			return boost::none;
+		}
+
+		DnsQuestion res;
+		res.name = std::move(*qname);
+		const uint16_t *data_16 = reinterpret_cast<const uint16_t*>(buffer.data() + offset);
+		res.type = endian::big_to_native(data_16[0]);
+		res.qclass = endian::big_to_native(data_16[1]);
+
+		offset += 4;
+		return std::move(res);
+	}
+};
+
+struct DnsResource
+{
+	DnsName name;
+	uint16_t type;
+	uint16_t rclass;
+	uint32_t ttl;
+	std::vector<char> data;
+
+	DnsResource() :
+		type(0),
+		rclass(0),
+		ttl(0)
+	{}
+
+	static optional<DnsResource> decode(const std::vector<char> &buffer, size_t &offset, size_t &dataoffset)
+	{
+		const size_t bsize = buffer.size();
+		if (offset + 1 >= bsize) {
+			return boost::none;
+		}
+
+		auto rname = DnsName::decode(buffer, offset);
+		if (!rname) {
+			return boost::none;
+		}
+
+		if (offset + 10 >= bsize) {
+			return boost::none;
+		}
+
+		DnsResource res;
+		res.name = std::move(*rname);
+		const uint16_t *data_16 = reinterpret_cast<const uint16_t*>(buffer.data() + offset);
+		res.type = endian::big_to_native(data_16[0]);
+		res.rclass = endian::big_to_native(data_16[1]);
+		res.ttl = endian::big_to_native(*reinterpret_cast<const uint32_t*>(data_16 + 2));
+		uint16_t rdlength = endian::big_to_native(data_16[4]);
+
+		offset += 10;
+		if (offset + rdlength > bsize) {
+			return boost::none;
+		}
+
+		dataoffset = offset;
+		res.data = std::move(std::vector<char>(buffer.begin() + offset, buffer.begin() + offset + rdlength));
+		offset += rdlength;
+
+		return std::move(res);
+	}
+};
+
+struct DnsRR_A
+{
+	enum { TAG = 0x1 };
+
+	asio::ip::address_v4 ip;
+
+	static void decode(optional<DnsRR_A> &result, const DnsResource &rr)
+	{
+		if (rr.data.size() == 4) {
+			DnsRR_A res;
+			const uint32_t ip = endian::big_to_native(*reinterpret_cast<const uint32_t*>(rr.data.data()));
+			res.ip = asio::ip::address_v4(ip);
+			result = std::move(res);
+		}
+	}
+};
+
+struct DnsRR_AAAA
+{
+	enum { TAG = 0x1c };
+
+	asio::ip::address_v6 ip;
+
+	static void decode(optional<DnsRR_AAAA> &result, const DnsResource &rr)
+	{
+		if (rr.data.size() == 16) {
+			DnsRR_AAAA res;
+			std::array<unsigned char, 16> ip;
+			std::copy_n(rr.data.begin(), 16, ip.begin());
+			res.ip = asio::ip::address_v6(ip);
+			result = std::move(res);
+		}
+	}
+};
+
+struct DnsRR_SRV
+{
+	enum
+	{
+		TAG = 0x21,
+		MIN_SIZE = 8,
+	};
+
+	uint16_t priority;
+	uint16_t weight;
+	uint16_t port;
+	DnsName hostname;
+
+	static optional<DnsRR_SRV> decode(const std::vector<char> &buffer, const DnsResource &rr, size_t dataoffset)
+	{
+		if (rr.data.size() < MIN_SIZE) {
+			return boost::none;
+		}
+
+		DnsRR_SRV res;
+
+		const uint16_t *data_16 = reinterpret_cast<const uint16_t*>(rr.data.data());
+		res.priority = endian::big_to_native(data_16[0]);
+		res.weight = endian::big_to_native(data_16[1]);
+		res.port = endian::big_to_native(data_16[2]);
+
+		size_t offset = dataoffset + 6;
+		auto hostname = DnsName::decode(buffer, offset);
+
+		if (hostname) {
+			res.hostname = std::move(*hostname);
+			return std::move(res);
+		} else {
+			return boost::none;
+		}
+	}
+};
+
+struct DnsRR_TXT
+{
+	enum
+	{
+		TAG = 0x10,
+	};
+
+	std::vector<std::string> values;
+
+	static optional<DnsRR_TXT> decode(const DnsResource &rr)
+	{
+		const size_t size = rr.data.size();
+		if (size < 2) {
+			return boost::none;
+		}
+
+		DnsRR_TXT res;
+
+		for (auto it = rr.data.begin(); it != rr.data.end(); ) {
+			unsigned val_size = static_cast<unsigned char>(*it);
+			if (val_size == 0 || it + val_size >= rr.data.end()) {
+				return boost::none;
+			}
+			++it;
+
+			std::string value(val_size, ' ');
+			std::copy(it, it + val_size, value.begin());
+			res.values.push_back(std::move(value));
+
+			it += val_size;
+		}
+
+		return std::move(res);
+	}
+};
+
+struct DnsSDPair
+{
+	optional<DnsRR_SRV> srv;
+	optional<DnsRR_TXT> txt;
+};
+
+struct DnsSDMap : public std::map<std::string, DnsSDPair>
+{
+	void insert_srv(std::string &&name, DnsRR_SRV &&srv)
+	{
+		auto hit = this->find(name);
+		if (hit != this->end()) {
+			hit->second.srv = std::move(srv);
+		} else {
+			DnsSDPair pair;
+			pair.srv = std::move(srv);
+			this->insert(std::make_pair(std::move(name), std::move(pair)));
+		}
+	}
+
+	void insert_txt(std::string &&name, DnsRR_TXT &&txt)
+	{
+		auto hit = this->find(name);
+		if (hit != this->end()) {
+			hit->second.txt = std::move(txt);
+		} else {
+			DnsSDPair pair;
+			pair.txt = std::move(txt);
+			this->insert(std::make_pair(std::move(name), std::move(pair)));
+		}
+	}
+};
+
+struct DnsMessage
+{
+	enum
+	{
+		MAX_SIZE = 4096,
+		MAX_ANS = 30,
+	};
+
+	DnsHeader header;
+	optional<DnsQuestion> question;
+
+	optional<DnsRR_A> rr_a;
+	optional<DnsRR_AAAA> rr_aaaa;
+	std::vector<DnsRR_SRV> rr_srv;
+
+	DnsSDMap sdmap;
+
+	static optional<DnsMessage> decode(const std::vector<char> &buffer, optional<uint16_t> id_wanted = boost::none)
+	{
+		const auto size = buffer.size();
+		if (size < DnsHeader::SIZE + DnsQuestion::MIN_SIZE || size > MAX_SIZE) {
+			return boost::none;
+		}
+
+		DnsMessage res;
+		res.header = DnsHeader::decode(buffer);
+
+		if (id_wanted && *id_wanted != res.header.id) {
+			return boost::none;
+		}
+
+		if (res.header.qdcount > 1 || res.header.ancount > MAX_ANS) {
+			return boost::none;
+		}
+
+		size_t offset = DnsHeader::SIZE;
+		if (res.header.qdcount == 1) {
+			res.question = DnsQuestion::decode(buffer, offset);
+		}
+
+		for (unsigned i = 0; i < res.header.rrcount(); i++) {
+			size_t dataoffset = 0;
+			auto rr = DnsResource::decode(buffer, offset, dataoffset);
+			if (!rr) {
+				return boost::none;
+			} else {
+				res.parse_rr(buffer, std::move(*rr), dataoffset);
+			}
+		}
+
+		return std::move(res);
+	}
+private:
+	void parse_rr(const std::vector<char> &buffer, DnsResource &&rr, size_t dataoffset)
+	{
+		switch (rr.type) {
+			case DnsRR_A::TAG: DnsRR_A::decode(this->rr_a, rr); break;
+			case DnsRR_AAAA::TAG: DnsRR_AAAA::decode(this->rr_aaaa, rr); break;
+			case DnsRR_SRV::TAG: {
+				auto srv = DnsRR_SRV::decode(buffer, rr, dataoffset);
+				if (srv) { this->sdmap.insert_srv(std::move(rr.name), std::move(*srv)); }
+				break;
+			}
+			case DnsRR_TXT::TAG: {
+				auto txt = DnsRR_TXT::decode(rr);
+				if (txt) { this->sdmap.insert_txt(std::move(rr.name), std::move(*txt)); }
+				break;
+			}
+		}
+	}
+};
+
+std::ostream& operator<<(std::ostream &os, const DnsMessage &msg)
+{
+	os << "DnsMessage(ID: " << msg.header.id << ", "
+		<< "Q: " << (msg.question ? msg.question->name.c_str() : "none") << ", "
+		<< "A: " << (msg.rr_a ? msg.rr_a->ip.to_string() : "none") << ", "
+		<< "AAAA: " << (msg.rr_aaaa ? msg.rr_aaaa->ip.to_string() : "none") << ", "
+		<< "services: [";
+
+		enum { SRV_PRINT_MAX = 3 };
+		unsigned i = 0;
+		for (const auto &sdpair : msg.sdmap) {
+			os << sdpair.first << ", ";
+
+			if (++i >= SRV_PRINT_MAX) {
+				os << "...";
+				break;
+			}
+		}
+
+		os << "])";
+
+	return os;
+}
+
+
+struct BonjourRequest
+{
+	static const asio::ip::address_v4 MCAST_IP4;
+	static const uint16_t MCAST_PORT;
+
+	uint16_t id;
+	std::vector<char> data;
+
+	static optional<BonjourRequest> make(const std::string &service, const std::string &protocol);
+
+private:
+	BonjourRequest(uint16_t id, std::vector<char> &&data) :
+		id(id),
+		data(std::move(data))
+	{}
+};
+
+const asio::ip::address_v4 BonjourRequest::MCAST_IP4{0xe00000fb};
+const uint16_t BonjourRequest::MCAST_PORT = 5353;
+
+optional<BonjourRequest> BonjourRequest::make(const std::string &service, const std::string &protocol)
+{
+	if (service.size() > 15 || protocol.size() > 15) {
+		return boost::none;
+	}
+
+	std::random_device dev;
+	std::uniform_int_distribution<uint16_t> dist;
+	uint16_t id = dist(dev);
+	uint16_t id_big = endian::native_to_big(id);
+	const char *id_char = reinterpret_cast<char*>(&id_big);
+
+	std::vector<char> data;
+	data.reserve(service.size() + 18);
+
+	// Add the transaction ID
+	data.push_back(id_char[0]);
+	data.push_back(id_char[1]);
+
+	// Add metadata
+	static const unsigned char rq_meta[] = {
+		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+	};
+	std::copy(rq_meta, rq_meta + sizeof(rq_meta), std::back_inserter(data));
+
+	// Add PTR query name
+	data.push_back(service.size() + 1);
+	data.push_back('_');
+	data.insert(data.end(), service.begin(), service.end());
+	data.push_back(protocol.size() + 1);
+	data.push_back('_');
+	data.insert(data.end(), protocol.begin(), protocol.end());
+
+	// Add the rest of PTR record
+	static const unsigned char ptr_tail[] = {
+		0x05, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x00, 0x00, 0x0c, 0x00, 0xff,
+	};
+	std::copy(ptr_tail, ptr_tail + sizeof(ptr_tail), std::back_inserter(data));
+
+	return BonjourRequest(id, std::move(data));
+}
+
+
+// API - private part
+
+struct Bonjour::priv
+{
+	const std::string service;
+	const std::string protocol;
+	const std::string service_dn;
+	unsigned timeout;
+	unsigned retries;
+	uint16_t rq_id;
+
+	std::vector<char> buffer;
+	std::thread io_thread;
+	Bonjour::ReplyFn replyfn;
+	Bonjour::CompleteFn completefn;
+
+	priv(std::string service, std::string protocol);
+
+	std::string strip_service_dn(const std::string &service_name) const;
+	void udp_receive(udp::endpoint from, size_t bytes);
+	void lookup_perform();
+};
+
+Bonjour::priv::priv(std::string service, std::string protocol) :
+	service(std::move(service)),
+	protocol(std::move(protocol)),
+	service_dn((boost::format("_%1%._%2%.local") % this->service % this->protocol).str()),
+	timeout(10),
+	retries(1),
+	rq_id(0)
+{
+	buffer.resize(DnsMessage::MAX_SIZE);
+}
+
+std::string Bonjour::priv::strip_service_dn(const std::string &service_name) const
+{
+	if (service_name.size() <= service_dn.size()) {
+		return service_name;
+	}
+
+	auto needle = service_name.rfind(service_dn);
+	if (needle == service_name.size() - service_dn.size()) {
+		return service_name.substr(0, needle - 1);
+	} else {
+		return service_name;
+	}
+}
+
+void Bonjour::priv::udp_receive(udp::endpoint from, size_t bytes)
+{
+	if (bytes == 0 || !replyfn) {
+		return;
+	}
+
+	buffer.resize(bytes);
+	const auto dns_msg = DnsMessage::decode(buffer, rq_id);
+	if (dns_msg) {
+		asio::ip::address ip = from.address();
+		if (dns_msg->rr_a) { ip = dns_msg->rr_a->ip; }
+		else if (dns_msg->rr_aaaa) { ip = dns_msg->rr_aaaa->ip; }
+
+		for (const auto &sdpair : dns_msg->sdmap) {
+			if (! sdpair.second.srv) {
+				continue;
+			}
+
+			const auto &srv = *sdpair.second.srv;
+			auto service_name = strip_service_dn(sdpair.first);
+
+			std::string path;
+			std::string version;
+
+			if (sdpair.second.txt) {
+				static const std::string tag_path = "path=";
+				static const std::string tag_version = "version=";
+
+				for (const auto &value : sdpair.second.txt->values) {
+					if (value.size() > tag_path.size() && value.compare(0, tag_path.size(), tag_path) == 0) {
+						path = std::move(value.substr(tag_path.size()));
+					} else if (value.size() > tag_version.size() && value.compare(0, tag_version.size(), tag_version) == 0) {
+						version = std::move(value.substr(tag_version.size()));
+					}
+				}
+			}
+
+			BonjourReply reply(ip, srv.port, std::move(service_name), srv.hostname, std::move(path), std::move(version));
+			replyfn(std::move(reply));
+		}
+	}
+}
+
+void Bonjour::priv::lookup_perform()
+{
+	const auto brq = BonjourRequest::make(service, protocol);
+	if (!brq) {
+		return;
+	}
+
+	auto self = this;
+	rq_id = brq->id;
+
+	try {
+		boost::asio::io_service io_service;
+		udp::socket socket(io_service);
+		socket.open(udp::v4());
+		socket.set_option(udp::socket::reuse_address(true));
+		udp::endpoint mcast(BonjourRequest::MCAST_IP4, BonjourRequest::MCAST_PORT);
+		socket.send_to(asio::buffer(brq->data), mcast);
+
+		bool expired = false;
+		bool retry = false;
+		asio::deadline_timer timer(io_service);
+		retries--;
+		std::function<void(const error_code &)> timer_handler = [&](const error_code &error) {
+			if (retries == 0 || error) {
+				expired = true;
+				if (self->completefn) {
+					self->completefn();
+				}
+			} else {
+				retry = true;
+				retries--;
+				timer.expires_from_now(boost::posix_time::seconds(timeout));
+				timer.async_wait(timer_handler);
+			}
+		};
+
+		timer.expires_from_now(boost::posix_time::seconds(timeout));
+		timer.async_wait(timer_handler);
+
+		udp::endpoint recv_from;
+		const auto recv_handler = [&](const error_code &error, size_t bytes) {
+			if (!error) { self->udp_receive(recv_from, bytes); }
+		};
+		socket.async_receive_from(asio::buffer(buffer, buffer.size()), recv_from, recv_handler);
+
+		while (io_service.run_one()) {
+			if (expired) {
+				socket.cancel();
+			} else if (retry) {
+				retry = false;
+				socket.send_to(asio::buffer(brq->data), mcast);
+			} else {
+				buffer.resize(DnsMessage::MAX_SIZE);
+				socket.async_receive_from(asio::buffer(buffer, buffer.size()), recv_from, recv_handler);
+			}
+		}
+	} catch (std::exception& e) {
+	}
+}
+
+
+// API - public part
+
+BonjourReply::BonjourReply(boost::asio::ip::address ip, uint16_t port, std::string service_name, std::string hostname, std::string path, std::string version) :
+	ip(std::move(ip)),
+	port(port),
+	service_name(std::move(service_name)),
+	hostname(std::move(hostname)),
+	path(path.empty() ? std::move(std::string("/")) : std::move(path)),
+	version(version.empty() ? std::move(std::string("Unknown")) : std::move(version))
+{
+	std::string proto;
+	std::string port_suffix;
+	if (port == 443) { proto = "https://"; }
+	if (port != 443 && port != 80) { port_suffix = std::to_string(port).insert(0, 1, ':'); }
+	if (this->path[0] != '/') { this->path.insert(0, 1, '/'); }
+	full_address = proto + ip.to_string() + port_suffix;
+	if (this->path != "/") { full_address += path; }
+}
+
+bool BonjourReply::operator==(const BonjourReply &other) const
+{
+	return this->full_address == other.full_address
+		&& this->service_name == other.service_name;
+}
+
+bool BonjourReply::operator<(const BonjourReply &other) const
+{
+	if (this->ip != other.ip) {
+		// So that the common case doesn't involve string comparison
+		return this->ip < other.ip;
+	} else {
+		auto cmp = this->full_address.compare(other.full_address);
+		return cmp != 0 ? cmp < 0 : this->service_name < other.service_name;
+	}
+}
+
+std::ostream& operator<<(std::ostream &os, const BonjourReply &reply)
+{
+	os << "BonjourReply(" << reply.ip.to_string() << ", " << reply.service_name << ", "
+		<< reply.hostname << ", " << reply.path << ", " << reply.version << ")";
+	return os;
+}
+
+
+Bonjour::Bonjour(std::string service, std::string protocol) :
+	p(new priv(std::move(service), std::move(protocol)))
+{}
+
+Bonjour::Bonjour(Bonjour &&other) : p(std::move(other.p)) {}
+
+Bonjour::~Bonjour()
+{
+	if (p && p->io_thread.joinable()) {
+		p->io_thread.detach();
+	}
+}
+
+Bonjour& Bonjour::set_timeout(unsigned timeout)
+{
+	if (p) { p->timeout = timeout; }
+	return *this;
+}
+
+Bonjour& Bonjour::set_retries(unsigned retries)
+{
+	if (p && retries > 0) { p->retries = retries; }
+	return *this;
+}
+
+Bonjour& Bonjour::on_reply(ReplyFn fn)
+{
+	if (p) { p->replyfn = std::move(fn); }
+	return *this;
+}
+
+Bonjour& Bonjour::on_complete(CompleteFn fn)
+{
+	if (p) { p->completefn = std::move(fn); }
+	return *this;
+}
+
+Bonjour::Ptr Bonjour::lookup()
+{
+	auto self = std::make_shared<Bonjour>(std::move(*this));
+
+	if (self->p) {
+		auto io_thread = std::thread([self]() {
+				self->p->lookup_perform();
+			});
+		self->p->io_thread = std::move(io_thread);
+	}
+
+	return self;
+}
+
+
+}

src/slic3r/Utils/Bonjour.hpp

@@ -0,0 +1,64 @@
+#ifndef slic3r_Bonjour_hpp_
+#define slic3r_Bonjour_hpp_
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <functional>
+#include <boost/asio/ip/address.hpp>
+
+
+namespace Slic3r {
+
+
+struct BonjourReply
+{
+	boost::asio::ip::address ip;
+	uint16_t port;
+	std::string service_name;
+	std::string hostname;
+	std::string full_address;
+	std::string path;
+	std::string version;
+
+	BonjourReply() = delete;
+	BonjourReply(boost::asio::ip::address ip, uint16_t port, std::string service_name, std::string hostname, std::string path, std::string version);
+
+	bool operator==(const BonjourReply &other) const;
+	bool operator<(const BonjourReply &other) const;
+};
+
+std::ostream& operator<<(std::ostream &, const BonjourReply &);
+
+
+/// Bonjour lookup performer
+class Bonjour : public std::enable_shared_from_this<Bonjour> {
+private:
+	struct priv;
+public:
+	typedef std::shared_ptr<Bonjour> Ptr;
+	typedef std::function<void(BonjourReply &&)> ReplyFn;
+	typedef std::function<void()> CompleteFn;
+
+	Bonjour(std::string service, std::string protocol = "tcp");
+	Bonjour(Bonjour &&other);
+	~Bonjour();
+
+	Bonjour& set_timeout(unsigned timeout);
+	Bonjour& set_retries(unsigned retries);
+	// ^ Note: By default there is 1 retry (meaning 1 broadcast is sent).
+	// Timeout is per one retry, ie. total time spent listening = retries * timeout.
+	// If retries > 1, then care needs to be taken as more than one reply from the same service may be received.
+
+	Bonjour& on_reply(ReplyFn fn);
+	Bonjour& on_complete(CompleteFn fn);
+
+	Ptr lookup();
+private:
+	std::unique_ptr<priv> p;
+};
+
+
+}
+
+#endif

src/slic3r/Utils/Duet.cpp

@@ -0,0 +1,279 @@
+#include "Duet.hpp"
+#include "PrintHostSendDialog.hpp"
+
+#include <algorithm>
+#include <ctime>
+#include <boost/filesystem/path.hpp>
+#include <boost/format.hpp>
+#include <boost/log/trivial.hpp>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/json_parser.hpp>
+
+#include <wx/frame.h>
+#include <wx/event.h>
+#include <wx/progdlg.h>
+#include <wx/sizer.h>
+#include <wx/stattext.h>
+#include <wx/textctrl.h>
+#include <wx/checkbox.h>
+
+#include "libslic3r/PrintConfig.hpp"
+#include "slic3r/GUI/GUI.hpp"
+#include "slic3r/GUI/MsgDialog.hpp"
+#include "Http.hpp"
+
+namespace fs = boost::filesystem;
+namespace pt = boost::property_tree;
+
+namespace Slic3r {
+
+Duet::Duet(DynamicPrintConfig *config) :
+	host(config->opt_string("print_host")),
+	password(config->opt_string("printhost_apikey"))
+{}
+
+Duet::~Duet() {}
+
+bool Duet::test(wxString &msg) const
+{
+	bool connected = connect(msg);
+	if (connected) {
+		disconnect();
+	}
+
+	return connected;
+}
+
+wxString Duet::get_test_ok_msg () const
+{
+	return wxString::Format("%s", _(L("Connection to Duet works correctly.")));
+}
+
+wxString Duet::get_test_failed_msg (wxString &msg) const
+{
+	return wxString::Format("%s: %s", _(L("Could not connect to Duet")), msg);
+}
+
+bool Duet::send_gcode(const std::string &filename) const
+{
+	enum { PROGRESS_RANGE = 1000 };
+
+	const auto errortitle = _(L("Error while uploading to the Duet"));
+	fs::path filepath(filename);
+
+	PrintHostSendDialog send_dialog(filepath.filename(), true);
+	if (send_dialog.ShowModal() != wxID_OK) { return false; }
+
+	const bool print = send_dialog.print(); 
+	const auto upload_filepath = send_dialog.filename();
+	const auto upload_filename = upload_filepath.filename();
+	const auto upload_parent_path = upload_filepath.parent_path();
+
+	wxProgressDialog progress_dialog(
+	 	_(L("Duet upload")),
+	 	_(L("Sending G-code file to Duet...")),
+		PROGRESS_RANGE, nullptr, wxPD_AUTO_HIDE | wxPD_APP_MODAL | wxPD_CAN_ABORT);
+	progress_dialog.Pulse();
+
+	wxString connect_msg;
+	if (!connect(connect_msg)) {
+		auto errormsg = wxString::Format("%s: %s", errortitle, connect_msg);
+		GUI::show_error(&progress_dialog, std::move(errormsg));
+		return false;
+	}
+
+	bool res = true;
+
+	auto upload_cmd = get_upload_url(upload_filepath.string());
+	BOOST_LOG_TRIVIAL(info) << boost::format("Duet: Uploading file %1%, filename: %2%, path: %3%, print: %4%, command: %5%")
+		% filepath.string()
+		% upload_filename.string()
+		% upload_parent_path.string()
+		% print
+		% upload_cmd;
+
+	auto http = Http::post(std::move(upload_cmd));
+	http.set_post_body(filename)
+		.on_complete([&](std::string body, unsigned status) {
+			BOOST_LOG_TRIVIAL(debug) << boost::format("Duet: File uploaded: HTTP %1%: %2%") % status % body;
+			progress_dialog.Update(PROGRESS_RANGE);
+
+			int err_code = get_err_code_from_body(body);
+			if (err_code != 0) {
+				auto msg = format_error(body, L("Unknown error occured"), 0);
+				GUI::show_error(&progress_dialog, std::move(msg));
+				res = false;
+			} else if (print) {
+				wxString errormsg;
+				res = start_print(errormsg, upload_filepath.string());
+				if (!res) {
+					GUI::show_error(&progress_dialog, std::move(errormsg));
+				}
+			}
+		})
+		.on_error([&](std::string body, std::string error, unsigned status) {
+			BOOST_LOG_TRIVIAL(error) << boost::format("Duet: Error uploading file: %1%, HTTP %2%, body: `%3%`") % error % status % body;
+			auto errormsg = wxString::Format("%s: %s", errortitle, format_error(body, error, status));
+			GUI::show_error(&progress_dialog, std::move(errormsg));
+			res = false;
+		})
+		.on_progress([&](Http::Progress progress, bool &cancel) {
+			if (cancel) {
+				// Upload was canceled
+				res = false;
+			} else if (progress.ultotal > 0) {
+				int value = PROGRESS_RANGE * progress.ulnow / progress.ultotal;
+				cancel = !progress_dialog.Update(std::min(value, PROGRESS_RANGE - 1));    // Cap the value to prevent premature dialog closing
+			} else {
+				cancel = !progress_dialog.Pulse();
+			}
+		})
+		.perform_sync();
+
+	disconnect();
+
+	return res;
+}
+
+bool Duet::has_auto_discovery() const
+{
+	return false;
+}
+
+bool Duet::can_test() const
+{
+	return true;
+}
+
+bool Duet::connect(wxString &msg) const
+{
+	bool res = false;
+	auto url = get_connect_url();
+
+	auto http = Http::get(std::move(url));
+	http.on_error([&](std::string body, std::string error, unsigned status) {
+			BOOST_LOG_TRIVIAL(error) << boost::format("Duet: Error connecting: %1%, HTTP %2%, body: `%3%`") % error % status % body;
+			msg = format_error(body, error, status);
+		})
+		.on_complete([&](std::string body, unsigned) {
+			BOOST_LOG_TRIVIAL(debug) << boost::format("Duet: Got: %1%") % body;
+
+			int err_code = get_err_code_from_body(body);
+			switch (err_code) {
+				case 0:
+					res = true;
+					break;
+				case 1:
+					msg = format_error(body, L("Wrong password"), 0);
+					break;
+				case 2:
+					msg = format_error(body, L("Could not get resources to create a new connection"), 0);
+					break;
+				default:
+					msg = format_error(body, L("Unknown error occured"), 0);
+					break;
+			}
+
+		})
+		.perform_sync();
+
+	return res;
+}
+
+void Duet::disconnect() const
+{
+	auto url =  (boost::format("%1%rr_disconnect")
+			% get_base_url()).str();
+
+	auto http = Http::get(std::move(url));
+	http.on_error([&](std::string body, std::string error, unsigned status) {
+		// we don't care about it, if disconnect is not working Duet will disconnect automatically after some time
+		BOOST_LOG_TRIVIAL(error) << boost::format("Duet: Error disconnecting: %1%, HTTP %2%, body: `%3%`") % error % status % body;
+	})
+	.perform_sync();
+}
+
+std::string Duet::get_upload_url(const std::string &filename) const
+{
+	return (boost::format("%1%rr_upload?name=0:/gcodes/%2%&%3%")
+			% get_base_url()
+			% Http::url_encode(filename) 
+			% timestamp_str()).str();
+}
+
+std::string Duet::get_connect_url() const
+{
+	return (boost::format("%1%rr_connect?password=%2%&%3%")
+			% get_base_url()
+			% (password.empty() ? "reprap" : password)
+			% timestamp_str()).str();
+}
+
+std::string Duet::get_base_url() const
+{
+	if (host.find("http://") == 0 || host.find("https://") == 0) {
+		if (host.back() == '/') {
+			return host;
+		} else {
+			return (boost::format("%1%/") % host).str();
+		}
+	} else {
+		return (boost::format("http://%1%/") % host).str();
+	}
+}
+
+std::string Duet::timestamp_str() const
+{
+	enum { BUFFER_SIZE = 32 };
+
+	auto t = std::time(nullptr);
+	auto tm = *std::localtime(&t);
+
+	char buffer[BUFFER_SIZE];
+	std::strftime(buffer, BUFFER_SIZE, "time=%Y-%m-%dT%H:%M:%S", &tm);
+
+	return std::string(buffer);
+}
+
+wxString Duet::format_error(const std::string &body, const std::string &error, unsigned status)
+{
+	if (status != 0) {
+		auto wxbody = wxString::FromUTF8(body.data());
+		return wxString::Format("HTTP %u: %s", status, wxbody);
+	} else {
+		return wxString::FromUTF8(error.data());
+	}
+}
+
+bool Duet::start_print(wxString &msg, const std::string &filename) const 
+{
+	bool res = false;
+	
+	auto url = (boost::format("%1%rr_gcode?gcode=M32%%20\"%2%\"")
+			% get_base_url()
+			% Http::url_encode(filename)).str();
+
+	auto http = Http::get(std::move(url));
+	http.on_error([&](std::string body, std::string error, unsigned status) {
+			BOOST_LOG_TRIVIAL(error) << boost::format("Duet: Error starting print: %1%, HTTP %2%, body: `%3%`") % error % status % body;
+			msg = format_error(body, error, status);
+		})
+		.on_complete([&](std::string body, unsigned) {
+			BOOST_LOG_TRIVIAL(debug) << boost::format("Duet: Got: %1%") % body;
+			res = true;
+		})
+		.perform_sync();
+
+	return res;
+}
+
+int Duet::get_err_code_from_body(const std::string &body) const
+{
+	pt::ptree root;
+	std::istringstream iss (body); // wrap returned json to istringstream
+	pt::read_json(iss, root);
+
+	return root.get<int>("err", 0);
+}
+
+}

src/slic3r/Utils/Duet.hpp

@@ -0,0 +1,47 @@
+#ifndef slic3r_Duet_hpp_
+#define slic3r_Duet_hpp_
+
+#include <string>
+#include <wx/string.h>
+
+#include "PrintHost.hpp"
+
+
+namespace Slic3r {
+
+
+class DynamicPrintConfig;
+class Http;
+
+class Duet : public PrintHost
+{
+public:
+	Duet(DynamicPrintConfig *config);
+	virtual ~Duet();
+
+	bool test(wxString &curl_msg) const;
+	wxString get_test_ok_msg () const;
+	wxString get_test_failed_msg (wxString &msg) const;
+	// Send gcode file to duet, filename is expected to be in UTF-8
+	bool send_gcode(const std::string &filename) const;
+	bool has_auto_discovery() const;
+	bool can_test() const;
+private:
+	std::string host;
+	std::string password;
+
+	std::string get_upload_url(const std::string &filename) const;
+	std::string get_connect_url() const;
+	std::string get_base_url() const;
+	std::string timestamp_str() const;
+	bool connect(wxString &msg) const;
+	void disconnect() const;
+	bool start_print(wxString &msg, const std::string &filename) const;
+	int get_err_code_from_body(const std::string &body) const;
+	static wxString format_error(const std::string &body, const std::string &error, unsigned status);
+};
+
+
+}
+
+#endif

src/slic3r/Utils/FixModelByWin10.cpp

@@ -0,0 +1,402 @@
+#ifdef HAS_WIN10SDK
+
+#ifndef NOMINMAX
+# define NOMINMAX
+#endif
+
+#include "FixModelByWin10.hpp"
+
+#include <atomic>
+#include <chrono>
+#include <cstdint>
+#include <condition_variable>
+#include <exception>
+#include <string>
+#include <thread>
+
+#include <boost/filesystem.hpp>
+#include <boost/nowide/convert.hpp>
+#include <boost/nowide/cstdio.hpp>
+
+#include <roapi.h>
+// for ComPtr
+#include <wrl/client.h>
+// from C:/Program Files (x86)/Windows Kits/10/Include/10.0.17134.0/
+#include <winrt/robuffer.h>
+#include <winrt/windows.storage.provider.h>
+#include <winrt/windows.graphics.printing3d.h>
+
+#include "libslic3r/Model.hpp"
+#include "libslic3r/Print.hpp"
+#include "libslic3r/Format/3mf.hpp"
+#include "../GUI/GUI.hpp"
+#include "../GUI/PresetBundle.hpp"
+
+#include <wx/msgdlg.h>
+#include <wx/progdlg.h>
+
+extern "C"{
+	// from rapi.h
+	typedef HRESULT (__stdcall* FunctionRoInitialize)(int);
+	typedef HRESULT (__stdcall* FunctionRoUninitialize)();
+	typedef HRESULT	(__stdcall* FunctionRoActivateInstance)(HSTRING activatableClassId, IInspectable **instance);
+	typedef HRESULT (__stdcall* FunctionRoGetActivationFactory)(HSTRING activatableClassId, REFIID iid, void **factory);
+	// from winstring.h
+	typedef HRESULT	(__stdcall* FunctionWindowsCreateString)(LPCWSTR sourceString, UINT32  length, HSTRING *string);
+	typedef HRESULT	(__stdcall* FunctionWindowsDelteString)(HSTRING string);
+}
+
+namespace Slic3r {
+
+HMODULE							s_hRuntimeObjectLibrary  = nullptr;
+FunctionRoInitialize			s_RoInitialize			 = nullptr;
+FunctionRoUninitialize			s_RoUninitialize		 = nullptr;
+FunctionRoActivateInstance		s_RoActivateInstance     = nullptr;
+FunctionRoGetActivationFactory	s_RoGetActivationFactory = nullptr;
+FunctionWindowsCreateString		s_WindowsCreateString    = nullptr;
+FunctionWindowsDelteString		s_WindowsDeleteString    = nullptr;
+
+bool winrt_load_runtime_object_library()
+{
+	if (s_hRuntimeObjectLibrary == nullptr)
+		s_hRuntimeObjectLibrary = LoadLibrary(L"ComBase.dll");
+	if (s_hRuntimeObjectLibrary != nullptr) {
+		s_RoInitialize			 = (FunctionRoInitialize)			GetProcAddress(s_hRuntimeObjectLibrary, "RoInitialize");
+		s_RoUninitialize		 = (FunctionRoUninitialize)			GetProcAddress(s_hRuntimeObjectLibrary, "RoUninitialize");
+		s_RoActivateInstance	 = (FunctionRoActivateInstance)		GetProcAddress(s_hRuntimeObjectLibrary, "RoActivateInstance");
+		s_RoGetActivationFactory = (FunctionRoGetActivationFactory)	GetProcAddress(s_hRuntimeObjectLibrary, "RoGetActivationFactory");
+		s_WindowsCreateString	 = (FunctionWindowsCreateString)	GetProcAddress(s_hRuntimeObjectLibrary, "WindowsCreateString");
+		s_WindowsDeleteString	 = (FunctionWindowsDelteString)		GetProcAddress(s_hRuntimeObjectLibrary, "WindowsDeleteString");
+	}
+	return s_RoInitialize && s_RoUninitialize && s_RoActivateInstance && s_WindowsCreateString && s_WindowsDeleteString;
+}
+
+static HRESULT winrt_activate_instance(const std::wstring &class_name, IInspectable **pinst)
+{
+	HSTRING hClassName;
+	HRESULT hr = (*s_WindowsCreateString)(class_name.c_str(), class_name.size(), &hClassName);
+	if (S_OK != hr) 
+		return hr;
+	hr = (*s_RoActivateInstance)(hClassName, pinst);
+	(*s_WindowsDeleteString)(hClassName);
+	return hr;
+}
+
+template<typename TYPE>
+static HRESULT winrt_activate_instance(const std::wstring &class_name, TYPE **pinst)
+{
+	IInspectable *pinspectable = nullptr;
+	HRESULT hr = winrt_activate_instance(class_name, &pinspectable);
+	if (S_OK != hr)
+		return hr;
+	hr = pinspectable->QueryInterface(__uuidof(TYPE), (void**)pinst);
+	pinspectable->Release();
+	return hr;
+}
+
+static HRESULT winrt_get_activation_factory(const std::wstring &class_name, REFIID iid, void **pinst)
+{
+	HSTRING hClassName;
+	HRESULT hr = (*s_WindowsCreateString)(class_name.c_str(), class_name.size(), &hClassName);
+	if (S_OK != hr)
+		return hr;
+	hr = (*s_RoGetActivationFactory)(hClassName, iid, pinst);
+	(*s_WindowsDeleteString)(hClassName);
+	return hr;
+}
+
+template<typename TYPE>
+static HRESULT winrt_get_activation_factory(const std::wstring &class_name, TYPE **pinst)
+{
+	return winrt_get_activation_factory(class_name, __uuidof(TYPE), reinterpret_cast<void**>(pinst));
+}
+
+// To be called often to test whether to cancel the operation.
+typedef std::function<void ()> ThrowOnCancelFn;
+
+template<typename T>
+static AsyncStatus winrt_async_await(const Microsoft::WRL::ComPtr<T> &asyncAction, ThrowOnCancelFn throw_on_cancel, int blocking_tick_ms = 100)
+{
+	Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncInfo> asyncInfo;
+	asyncAction.As(&asyncInfo);
+	AsyncStatus status;
+	// Ugly blocking loop until the RepairAsync call finishes.
+//FIXME replace with a callback.
+// https://social.msdn.microsoft.com/Forums/en-US/a5038fb4-b7b7-4504-969d-c102faa389fb/trying-to-block-an-async-operation-and-wait-for-a-particular-time?forum=vclanguage
+	for (;;) {
+		asyncInfo->get_Status(&status);
+		if (status != AsyncStatus::Started)
+			return status;
+		throw_on_cancel();
+		::Sleep(blocking_tick_ms);
+	}
+}
+
+static HRESULT winrt_open_file_stream(
+	const std::wstring									 &path,
+	ABI::Windows::Storage::FileAccessMode				  mode,
+	ABI::Windows::Storage::Streams::IRandomAccessStream **fileStream,
+	ThrowOnCancelFn										  throw_on_cancel)
+{
+	// Get the file factory.
+	Microsoft::WRL::ComPtr<ABI::Windows::Storage::IStorageFileStatics> fileFactory;
+	HRESULT hr = winrt_get_activation_factory(L"Windows.Storage.StorageFile", fileFactory.GetAddressOf());
+	if (FAILED(hr)) return hr;
+
+	// Open the file asynchronously.
+	HSTRING hstr_path;
+	hr = (*s_WindowsCreateString)(path.c_str(), path.size(), &hstr_path);
+	if (FAILED(hr)) return hr;
+	Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncOperation<ABI::Windows::Storage::StorageFile*>> fileOpenAsync;
+	hr = fileFactory->GetFileFromPathAsync(hstr_path, fileOpenAsync.GetAddressOf());
+	if (FAILED(hr)) return hr;
+	(*s_WindowsDeleteString)(hstr_path);
+
+	// Wait until the file gets open, get the actual file.
+	AsyncStatus status = winrt_async_await(fileOpenAsync, throw_on_cancel);
+	Microsoft::WRL::ComPtr<ABI::Windows::Storage::IStorageFile> storageFile;
+	if (status == AsyncStatus::Completed) {
+		hr = fileOpenAsync->GetResults(storageFile.GetAddressOf());
+	} else {
+		Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncInfo> asyncInfo;
+		hr = fileOpenAsync.As(&asyncInfo);
+		if (FAILED(hr)) return hr;
+		HRESULT err;
+		hr = asyncInfo->get_ErrorCode(&err);
+		return FAILED(hr) ? hr : err;
+	}
+
+	Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncOperation<ABI::Windows::Storage::Streams::IRandomAccessStream*>> fileStreamAsync;
+	hr = storageFile->OpenAsync(mode, fileStreamAsync.GetAddressOf());
+	if (FAILED(hr)) return hr;
+
+	status = winrt_async_await(fileStreamAsync, throw_on_cancel);
+	if (status == AsyncStatus::Completed) {
+		hr = fileStreamAsync->GetResults(fileStream);
+	} else {
+		Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncInfo> asyncInfo;
+		hr = fileStreamAsync.As(&asyncInfo);
+		if (FAILED(hr)) return hr;
+		HRESULT err;
+		hr = asyncInfo->get_ErrorCode(&err);
+		if (!FAILED(hr))
+			hr = err;
+	}
+	return hr;
+}
+
+bool is_windows10()
+{
+	HKEY hKey;
+	LONG lRes = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", 0, KEY_READ, &hKey);
+	if (lRes == ERROR_SUCCESS) {
+		WCHAR szBuffer[512];
+		DWORD dwBufferSize = sizeof(szBuffer);
+		lRes = RegQueryValueExW(hKey, L"ProductName", 0, nullptr, (LPBYTE)szBuffer, &dwBufferSize);
+		if (lRes == ERROR_SUCCESS)
+			return wcsncmp(szBuffer, L"Windows 10", 10) == 0;
+		RegCloseKey(hKey);
+	}
+	return false;
+}
+
+// Progress function, to be called regularly to update the progress.
+typedef std::function<void (const char * /* message */, unsigned /* progress */)> ProgressFn;
+
+void fix_model_by_win10_sdk(const std::string &path_src, const std::string &path_dst, ProgressFn on_progress, ThrowOnCancelFn throw_on_cancel)
+{
+	if (! is_windows10())
+		throw std::runtime_error("fix_model_by_win10_sdk called on non Windows 10 system");
+
+	if (! winrt_load_runtime_object_library())
+		throw std::runtime_error("Failed to initialize the WinRT library.");
+
+	HRESULT hr = (*s_RoInitialize)(RO_INIT_MULTITHREADED);
+	{
+		on_progress(L("Exporting the source model"), 20);
+
+		Microsoft::WRL::ComPtr<ABI::Windows::Storage::Streams::IRandomAccessStream>       fileStream;
+		hr = winrt_open_file_stream(boost::nowide::widen(path_src), ABI::Windows::Storage::FileAccessMode::FileAccessMode_Read, fileStream.GetAddressOf(), throw_on_cancel);
+
+		Microsoft::WRL::ComPtr<ABI::Windows::Graphics::Printing3D::IPrinting3D3MFPackage> printing3d3mfpackage;
+		hr = winrt_activate_instance(L"Windows.Graphics.Printing3D.Printing3D3MFPackage", printing3d3mfpackage.GetAddressOf());
+
+		Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncOperation<ABI::Windows::Graphics::Printing3D::Printing3DModel*>> modelAsync;
+		hr = printing3d3mfpackage->LoadModelFromPackageAsync(fileStream.Get(), modelAsync.GetAddressOf());
+
+		AsyncStatus status = winrt_async_await(modelAsync, throw_on_cancel);
+		Microsoft::WRL::ComPtr<ABI::Windows::Graphics::Printing3D::IPrinting3DModel>	  model;
+		if (status == AsyncStatus::Completed)
+			hr = modelAsync->GetResults(model.GetAddressOf());
+		else
+			throw std::runtime_error(L("Failed loading the input model."));
+
+		Microsoft::WRL::ComPtr<ABI::Windows::Foundation::Collections::IVector<ABI::Windows::Graphics::Printing3D::Printing3DMesh*>> meshes;
+		hr = model->get_Meshes(meshes.GetAddressOf());
+		unsigned num_meshes = 0;
+		hr = meshes->get_Size(&num_meshes);
+		
+		on_progress(L("Repairing the model by the Netfabb service"), 40);
+		
+		Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncAction>					  repairAsync;
+		hr = model->RepairAsync(repairAsync.GetAddressOf());
+		status = winrt_async_await(repairAsync, throw_on_cancel);
+		if (status != AsyncStatus::Completed)
+			throw std::runtime_error(L("Mesh repair failed."));
+		repairAsync->GetResults();
+
+		on_progress(L("Loading the repaired model"), 60);
+
+		// Verify the number of meshes returned after the repair action.
+		meshes.Reset();
+		hr = model->get_Meshes(meshes.GetAddressOf());
+		hr = meshes->get_Size(&num_meshes);
+
+		// Save model to this class' Printing3D3MFPackage.
+		Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncAction>					  saveToPackageAsync;
+		hr = printing3d3mfpackage->SaveModelToPackageAsync(model.Get(), saveToPackageAsync.GetAddressOf());
+		status = winrt_async_await(saveToPackageAsync, throw_on_cancel);
+		if (status != AsyncStatus::Completed)
+			throw std::runtime_error(L("Saving mesh into the 3MF container failed."));
+		hr = saveToPackageAsync->GetResults();
+
+		Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncOperation<ABI::Windows::Storage::Streams::IRandomAccessStream*>> generatorStreamAsync;
+		hr = printing3d3mfpackage->SaveAsync(generatorStreamAsync.GetAddressOf());
+		status = winrt_async_await(generatorStreamAsync, throw_on_cancel);
+		if (status != AsyncStatus::Completed)
+			throw std::runtime_error(L("Saving mesh into the 3MF container failed."));
+		Microsoft::WRL::ComPtr<ABI::Windows::Storage::Streams::IRandomAccessStream> generatorStream;
+		hr = generatorStreamAsync->GetResults(generatorStream.GetAddressOf());
+
+		// Go to the beginning of the stream.
+		generatorStream->Seek(0);
+		Microsoft::WRL::ComPtr<ABI::Windows::Storage::Streams::IInputStream> inputStream;
+		hr = generatorStream.As(&inputStream);
+
+		// Get the buffer factory.
+		Microsoft::WRL::ComPtr<ABI::Windows::Storage::Streams::IBufferFactory> bufferFactory;
+		hr = winrt_get_activation_factory(L"Windows.Storage.Streams.Buffer", bufferFactory.GetAddressOf());
+
+		// Open the destination file.
+		FILE *fout = boost::nowide::fopen(path_dst.c_str(), "wb");
+
+		Microsoft::WRL::ComPtr<ABI::Windows::Storage::Streams::IBuffer> buffer;
+		byte														   *buffer_ptr;
+		bufferFactory->Create(65536 * 2048, buffer.GetAddressOf());
+		{
+			Microsoft::WRL::ComPtr<Windows::Storage::Streams::IBufferByteAccess> bufferByteAccess;
+			buffer.As(&bufferByteAccess);
+			hr = bufferByteAccess->Buffer(&buffer_ptr);
+		}
+		uint32_t length;
+		hr = buffer->get_Length(&length);
+
+		Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncOperationWithProgress<ABI::Windows::Storage::Streams::IBuffer*, UINT32>> asyncRead;
+		for (;;) {
+			hr = inputStream->ReadAsync(buffer.Get(), 65536 * 2048, ABI::Windows::Storage::Streams::InputStreamOptions_ReadAhead, asyncRead.GetAddressOf());
+			status = winrt_async_await(asyncRead, throw_on_cancel);
+			if (status != AsyncStatus::Completed)
+				throw std::runtime_error(L("Saving mesh into the 3MF container failed."));
+			hr = buffer->get_Length(&length);
+			if (length == 0)
+				break;
+			fwrite(buffer_ptr, length, 1, fout);
+		}
+		fclose(fout);
+		// Here all the COM objects will be released through the ComPtr destructors.
+	}
+	(*s_RoUninitialize)();
+}
+
+class RepairCanceledException : public std::exception {
+public:
+   const char* what() const throw() { return "Model repair has been canceled"; }
+};
+
+void fix_model_by_win10_sdk_gui(const ModelObject &model_object, const Print &print, Model &result)
+{
+	std::mutex 						mutex;
+	std::condition_variable			condition;
+	std::unique_lock<std::mutex>	lock(mutex);
+	struct Progress {
+		std::string 				message;
+		int 						percent  = 0;
+		bool						updated = false;
+	} progress;
+	std::atomic<bool>				canceled = false;
+	std::atomic<bool>				finished = false;
+
+	// Open a progress dialog.
+	wxProgressDialog progress_dialog(
+		_(L("Model fixing")),
+		_(L("Exporting model...")),
+		100, nullptr, wxPD_AUTO_HIDE | wxPD_APP_MODAL | wxPD_CAN_ABORT);
+	// Executing the calculation in a background thread, so that the COM context could be created with its own threading model.
+	// (It seems like wxWidgets initialize the COM contex as single threaded and we need a multi-threaded context).
+	bool success  = false;
+	auto on_progress = [&mutex, &condition, &progress](const char *msg, unsigned prcnt) {
+        std::lock_guard<std::mutex> lk(mutex);
+		progress.message = msg;
+		progress.percent = prcnt;
+		progress.updated = true;
+	    condition.notify_all();
+	};
+	auto worker_thread = boost::thread([&model_object, &print, &result, on_progress, &success, &canceled, &finished]() {
+		try {
+			on_progress(L("Exporting the source model"), 0);
+			boost::filesystem::path path_src = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
+			path_src += ".3mf";
+			Model model;
+			model.add_object(model_object);
+			if (! Slic3r::store_3mf(path_src.string().c_str(), &model, const_cast<Print*>(&print), false)) {
+				boost::filesystem::remove(path_src);
+				throw std::runtime_error(L("Export of a temporary 3mf file failed"));
+			}
+			model.clear_objects(); 
+			model.clear_materials();
+			boost::filesystem::path path_dst = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
+			path_dst += ".3mf";
+			fix_model_by_win10_sdk(path_src.string().c_str(), path_dst.string(), on_progress, 
+				[&canceled]() { if (canceled) throw RepairCanceledException(); });
+			boost::filesystem::remove(path_src);
+			PresetBundle bundle;
+			on_progress(L("Loading the repaired model"), 80);
+		    bool loaded = Slic3r::load_3mf(path_dst.string().c_str(), &bundle, &result);
+			boost::filesystem::remove(path_dst);
+			if (! loaded)
+ 				throw std::runtime_error(L("Import of the repaired 3mf file failed"));
+			success  = true;
+			finished = true;
+			on_progress(L("Model repair finished"), 100);
+		} catch (RepairCanceledException &ex) {
+			canceled = true;
+			finished = true;
+			on_progress(L("Model repair canceled"), 100);
+		} catch (std::exception &ex) {
+			success = false;
+			finished = true;
+			on_progress(ex.what(), 100);
+		}
+	});
+    while (! finished) {
+		condition.wait_for(lock, std::chrono::milliseconds(500), [&progress]{ return progress.updated; });
+		if (! progress_dialog.Update(progress.percent, _(progress.message)))
+			canceled = true;
+		progress.updated = false;
+    }
+
+	if (canceled) {
+		// Nothing to show.
+	} else if (success) {
+		wxMessageDialog dlg(nullptr, _(L("Model repaired successfully")), _(L("Model Repair by the Netfabb service")), wxICON_INFORMATION | wxOK_DEFAULT);
+		dlg.ShowModal();
+	} else {
+		wxMessageDialog dlg(nullptr, _(L("Model repair failed: \n")) + _(progress.message), _(L("Model Repair by the Netfabb service")), wxICON_ERROR | wxOK_DEFAULT);
+		dlg.ShowModal();
+	}
+	worker_thread.join();
+}
+
+} // namespace Slic3r
+
+#endif /* HAS_WIN10SDK */

src/slic3r/Utils/FixModelByWin10.hpp

@@ -0,0 +1,26 @@
+#ifndef slic3r_GUI_Utils_FixModelByWin10_hpp_
+#define slic3r_GUI_Utils_FixModelByWin10_hpp_
+
+#include <string>
+
+namespace Slic3r {
+
+class Model;
+class ModelObject;
+class Print;
+
+#ifdef HAS_WIN10SDK
+
+extern bool is_windows10();
+extern void fix_model_by_win10_sdk_gui(const ModelObject &model_object, const Print &print, Model &result);
+
+#else /* HAS_WIN10SDK */
+
+inline bool is_windows10() { return false; }
+inline void fix_model_by_win10_sdk_gui(const ModelObject &, const Print &, Model &) {}
+
+#endif /* HAS_WIN10SDK */
+
+} // namespace Slic3r
+
+#endif /* slic3r_GUI_Utils_FixModelByWin10_hpp_ */

src/slic3r/Utils/HexFile.cpp

@@ -0,0 +1,106 @@
+#include "HexFile.hpp"
+
+#include <sstream>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/ini_parser.hpp>
+
+namespace fs = boost::filesystem;
+namespace pt = boost::property_tree;
+
+
+namespace Slic3r {
+namespace Utils {
+
+
+static HexFile::DeviceKind parse_device_kind(const std::string &str)
+{
+	     if (str == "mk2") { return HexFile::DEV_MK2; }
+	else if (str == "mk3") { return HexFile::DEV_MK3; }
+	else if (str == "mm-control") { return HexFile::DEV_MM_CONTROL; }
+	else { return HexFile::DEV_GENERIC; }
+}
+
+static size_t hex_num_sections(fs::ifstream &file)
+{
+	file.seekg(0);
+	if (! file.good()) {
+		return 0;
+	}
+
+	static const char *hex_terminator = ":00000001FF\r";
+	size_t res = 0;
+	std::string line;
+	while (getline(file, line, '\n').good()) {
+		// Account for LF vs CRLF
+		if (!line.empty() && line.back() != '\r') {
+			line.push_back('\r');
+		}
+
+		if (line == hex_terminator) {
+			res++;
+		}
+	}
+
+	return res;
+}
+
+HexFile::HexFile(fs::path path) :
+	path(std::move(path))
+{
+	fs::ifstream file(this->path);
+	if (! file.good()) {
+		return;
+	}
+
+	std::string line;
+	std::stringstream header_ini;
+	while (std::getline(file, line, '\n').good()) {
+		if (line.empty()) {
+			continue;
+		}
+
+		// Account for LF vs CRLF
+		if (!line.empty() && line.back() == '\r') {
+			line.pop_back();
+		}
+
+		if (line.front() == ';') {
+			line.front() = ' ';
+			header_ini << line << std::endl;
+		} else if (line.front() == ':') {
+			break;
+		}
+	}
+
+	pt::ptree ptree;
+	try {
+		pt::read_ini(header_ini, ptree);
+	} catch (std::exception &e) {
+		return;
+	}
+
+	bool has_device_meta = false;
+	const auto device = ptree.find("device");
+	if (device != ptree.not_found()) {
+		this->device = parse_device_kind(device->second.data());
+		has_device_meta = true;
+	}
+
+	const auto model_id = ptree.find("model_id");
+	if (model_id != ptree.not_found()) {
+		this->model_id = model_id->second.data();
+	}
+
+	if (! has_device_meta) {
+		// No device metadata, look at the number of 'sections'
+		if (hex_num_sections(file) == 2) {
+			// Looks like a pre-metadata l10n firmware for the MK3, assume that's the case
+			this->device = DEV_MK3;
+		}
+	}
+}
+
+
+}
+}

src/slic3r/Utils/HexFile.hpp

@@ -0,0 +1,33 @@
+#ifndef slic3r_Hex_hpp_
+#define slic3r_Hex_hpp_
+
+#include <string>
+#include <boost/filesystem/path.hpp>
+
+
+namespace Slic3r {
+namespace Utils {
+
+
+struct HexFile
+{
+	enum DeviceKind {
+		DEV_GENERIC,
+		DEV_MK2,
+		DEV_MK3,
+		DEV_MM_CONTROL,
+	};
+
+	boost::filesystem::path path;
+	DeviceKind device = DEV_GENERIC;
+	std::string model_id;
+
+	HexFile() {}
+	HexFile(boost::filesystem::path path);
+};
+
+
+}
+}
+
+#endif

src/slic3r/Utils/Http.cpp

@@ -0,0 +1,451 @@
+#include "Http.hpp"
+
+#include <cstdlib>
+#include <functional>
+#include <thread>
+#include <deque>
+#include <sstream>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/format.hpp>
+
+#include <curl/curl.h>
+
+#include "../../libslic3r/libslic3r.h"
+
+namespace fs = boost::filesystem;
+
+
+namespace Slic3r {
+
+
+// Private
+
+class CurlGlobalInit
+{
+	static const CurlGlobalInit instance;
+
+	CurlGlobalInit()  { ::curl_global_init(CURL_GLOBAL_DEFAULT); }
+	~CurlGlobalInit() { ::curl_global_cleanup(); }
+};
+
+struct Http::priv
+{
+	enum {
+		DEFAULT_SIZE_LIMIT = 5 * 1024 * 1024,
+	};
+
+	::CURL *curl;
+	::curl_httppost *form;
+	::curl_httppost *form_end;
+	::curl_slist *headerlist;
+	// Used for reading the body
+	std::string buffer;
+	// Used for storing file streams added as multipart form parts
+	// Using a deque here because unlike vector it doesn't ivalidate pointers on insertion
+	std::deque<fs::ifstream> form_files;
+	std::string postfields;
+	size_t limit;
+	bool cancel;
+
+	std::thread io_thread;
+	Http::CompleteFn completefn;
+	Http::ErrorFn errorfn;
+	Http::ProgressFn progressfn;
+
+	priv(const std::string &url);
+	~priv();
+
+	static bool ca_file_supported(::CURL *curl);
+	static size_t writecb(void *data, size_t size, size_t nmemb, void *userp);
+	static int xfercb(void *userp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow);
+	static int xfercb_legacy(void *userp, double dltotal, double dlnow, double ultotal, double ulnow);
+	static size_t form_file_read_cb(char *buffer, size_t size, size_t nitems, void *userp);
+
+	void form_add_file(const char *name, const fs::path &path, const char* filename);
+	void set_post_body(const fs::path &path);
+
+	std::string curl_error(CURLcode curlcode);
+	std::string body_size_error();
+	void http_perform();
+};
+
+Http::priv::priv(const std::string &url) :
+	curl(::curl_easy_init()),
+	form(nullptr),
+	form_end(nullptr),
+	headerlist(nullptr),
+	limit(0),
+	cancel(false)
+{
+	if (curl == nullptr) {
+		throw std::runtime_error(std::string("Could not construct Curl object"));
+	}
+
+	::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());   // curl makes a copy internally
+	::curl_easy_setopt(curl, CURLOPT_USERAGENT, SLIC3R_FORK_NAME "/" SLIC3R_VERSION);
+}
+
+Http::priv::~priv()
+{
+	::curl_easy_cleanup(curl);
+	::curl_formfree(form);
+	::curl_slist_free_all(headerlist);
+}
+
+bool Http::priv::ca_file_supported(::CURL *curl)
+{
+#ifdef _WIN32
+	bool res = false;
+#else
+	bool res = true;
+#endif
+
+	if (curl == nullptr) { return res; }
+
+#if LIBCURL_VERSION_MAJOR >= 7 && LIBCURL_VERSION_MINOR >= 48
+	::curl_tlssessioninfo *tls;
+	if (::curl_easy_getinfo(curl, CURLINFO_TLS_SSL_PTR, &tls) == CURLE_OK) {
+		if (tls->backend == CURLSSLBACKEND_SCHANNEL || tls->backend == CURLSSLBACKEND_DARWINSSL) {
+			// With Windows and OS X native SSL support, cert files cannot be set
+			res = false;
+		}
+	}
+#endif
+
+	return res;
+}
+
+size_t Http::priv::writecb(void *data, size_t size, size_t nmemb, void *userp)
+{
+	auto self = static_cast<priv*>(userp);
+	const char *cdata = static_cast<char*>(data);
+	const size_t realsize = size * nmemb;
+
+	const size_t limit = self->limit > 0 ? self->limit : DEFAULT_SIZE_LIMIT;
+	if (self->buffer.size() + realsize > limit) {
+		// This makes curl_easy_perform return CURLE_WRITE_ERROR
+		return 0;
+	}
+
+	self->buffer.append(cdata, realsize);
+
+	return realsize;
+}
+
+int Http::priv::xfercb(void *userp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
+{
+	auto self = static_cast<priv*>(userp);
+	bool cb_cancel = false;
+
+	if (self->progressfn) {
+		Progress progress(dltotal, dlnow, ultotal, ulnow);
+		self->progressfn(progress, cb_cancel);
+	}
+
+	return self->cancel || cb_cancel;
+}
+
+int Http::priv::xfercb_legacy(void *userp, double dltotal, double dlnow, double ultotal, double ulnow)
+{
+	return xfercb(userp, dltotal, dlnow, ultotal, ulnow);
+}
+
+size_t Http::priv::form_file_read_cb(char *buffer, size_t size, size_t nitems, void *userp)
+{
+	auto stream = reinterpret_cast<fs::ifstream*>(userp);
+
+	try {
+		stream->read(buffer, size * nitems);
+	} catch (...) {
+		return CURL_READFUNC_ABORT;
+	}
+
+	return stream->gcount();
+}
+
+void Http::priv::form_add_file(const char *name, const fs::path &path, const char* filename)
+{
+	// We can't use CURLFORM_FILECONTENT, because curl doesn't support Unicode filenames on Windows
+	// and so we use CURLFORM_STREAM with boost ifstream to read the file.
+
+	if (filename == nullptr) {
+		filename = path.string().c_str();
+	}
+
+	form_files.emplace_back(path, std::ios::in | std::ios::binary);
+	auto &stream = form_files.back();
+	stream.seekg(0, std::ios::end);
+	size_t size = stream.tellg();
+	stream.seekg(0);
+
+	if (filename != nullptr) {
+		::curl_formadd(&form, &form_end,
+			CURLFORM_COPYNAME, name,
+			CURLFORM_FILENAME, filename,
+			CURLFORM_CONTENTTYPE, "application/octet-stream",
+			CURLFORM_STREAM, static_cast<void*>(&stream),
+			CURLFORM_CONTENTSLENGTH, static_cast<long>(size),
+			CURLFORM_END
+		);
+	}
+}
+
+void Http::priv::set_post_body(const fs::path &path)
+{
+	std::ifstream file(path.string());
+	std::string file_content { std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>() };
+	postfields = file_content;
+}
+
+std::string Http::priv::curl_error(CURLcode curlcode)
+{
+	return (boost::format("%1% (%2%)")
+		% ::curl_easy_strerror(curlcode)
+		% curlcode
+	).str();
+}
+
+std::string Http::priv::body_size_error()
+{
+	return (boost::format("HTTP body data size exceeded limit (%1% bytes)") % limit).str();
+}
+
+void Http::priv::http_perform()
+{
+	::curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+	::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writecb);
+	::curl_easy_setopt(curl, CURLOPT_WRITEDATA, static_cast<void*>(this));
+	::curl_easy_setopt(curl, CURLOPT_READFUNCTION, form_file_read_cb);
+
+	::curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
+#if LIBCURL_VERSION_MAJOR >= 7 && LIBCURL_VERSION_MINOR >= 32
+	::curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, xfercb);
+	::curl_easy_setopt(curl, CURLOPT_XFERINFODATA, static_cast<void*>(this));
+	(void)xfercb_legacy;   // prevent unused function warning
+#else
+	::curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, xfercb);
+	::curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, static_cast<void*>(this));
+#endif
+
+#ifndef NDEBUG
+	::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+#endif
+
+	if (headerlist != nullptr) {
+		::curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
+	}
+
+	if (form != nullptr) {
+		::curl_easy_setopt(curl, CURLOPT_HTTPPOST, form);
+	}
+
+	if (!postfields.empty()) {
+		::curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postfields.c_str());
+		::curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, postfields.size());
+	}
+
+	CURLcode res = ::curl_easy_perform(curl);
+
+	if (res != CURLE_OK) {
+		if (res == CURLE_ABORTED_BY_CALLBACK) {
+			if (cancel) {
+				// The abort comes from the request being cancelled programatically
+				Progress dummyprogress(0, 0, 0, 0);
+				bool cancel = true;
+				if (progressfn) { progressfn(dummyprogress, cancel); }
+			} else {
+				// The abort comes from the CURLOPT_READFUNCTION callback, which means reading file failed
+				if (errorfn) { errorfn(std::move(buffer), "Error reading file for file upload", 0); }
+			}
+		}
+		else if (res == CURLE_WRITE_ERROR) {
+			if (errorfn) { errorfn(std::move(buffer), body_size_error(), 0); }
+		} else {
+			if (errorfn) { errorfn(std::move(buffer), curl_error(res), 0); }
+		};
+	} else {
+		long http_status = 0;
+		::curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_status);
+		
+		if (http_status >= 400) {
+			if (errorfn) { errorfn(std::move(buffer), std::string(), http_status); }
+		} else {
+			if (completefn) { completefn(std::move(buffer), http_status); }
+		}
+	}
+}
+
+Http::Http(const std::string &url) : p(new priv(url)) {}
+
+
+// Public
+
+Http::Http(Http &&other) : p(std::move(other.p)) {}
+
+Http::~Http()
+{
+	if (p && p->io_thread.joinable()) {
+		p->io_thread.detach();
+	}
+}
+
+
+Http& Http::size_limit(size_t sizeLimit)
+{
+	if (p) { p->limit = sizeLimit; }
+	return *this;
+}
+
+Http& Http::header(std::string name, const std::string &value)
+{
+	if (!p) { return * this; }
+
+	if (name.size() > 0) {
+		name.append(": ").append(value);
+	} else {
+		name.push_back(':');
+	}
+	p->headerlist = curl_slist_append(p->headerlist, name.c_str());
+	return *this;
+}
+
+Http& Http::remove_header(std::string name)
+{
+	if (p) {
+		name.push_back(':');
+		p->headerlist = curl_slist_append(p->headerlist, name.c_str());
+	}
+
+	return *this;
+}
+
+Http& Http::ca_file(const std::string &name)
+{
+	if (p && priv::ca_file_supported(p->curl)) {
+		::curl_easy_setopt(p->curl, CURLOPT_CAINFO, name.c_str());
+	}
+
+	return *this;
+}
+
+Http& Http::form_add(const std::string &name, const std::string &contents)
+{
+	if (p) {
+		::curl_formadd(&p->form, &p->form_end,
+			CURLFORM_COPYNAME, name.c_str(),
+			CURLFORM_COPYCONTENTS, contents.c_str(),
+			CURLFORM_END
+		);
+	}
+
+	return *this;
+}
+
+Http& Http::form_add_file(const std::string &name, const fs::path &path)
+{
+	if (p) { p->form_add_file(name.c_str(), path.c_str(), nullptr); }
+	return *this;
+}
+
+Http& Http::form_add_file(const std::string &name, const fs::path &path, const std::string &filename)
+{
+	if (p) { p->form_add_file(name.c_str(), path.c_str(), filename.c_str()); }
+	return *this;
+}
+
+Http& Http::set_post_body(const fs::path &path)
+{
+	if (p) { p->set_post_body(path);}
+	return *this;
+}
+
+Http& Http::on_complete(CompleteFn fn)
+{
+	if (p) { p->completefn = std::move(fn); }
+	return *this;
+}
+
+Http& Http::on_error(ErrorFn fn)
+{
+	if (p) { p->errorfn = std::move(fn); }
+	return *this;
+}
+
+Http& Http::on_progress(ProgressFn fn)
+{
+	if (p) { p->progressfn = std::move(fn); }
+	return *this;
+}
+
+Http::Ptr Http::perform()
+{
+	auto self = std::make_shared<Http>(std::move(*this));
+
+	if (self->p) {
+		auto io_thread = std::thread([self](){
+				self->p->http_perform();
+			});
+		self->p->io_thread = std::move(io_thread);
+	}
+
+	return self;
+}
+
+void Http::perform_sync()
+{
+	if (p) { p->http_perform(); }
+}
+
+void Http::cancel()
+{
+	if (p) { p->cancel = true; }
+}
+
+Http Http::get(std::string url)
+{
+	return std::move(Http{std::move(url)});
+}
+
+Http Http::post(std::string url)
+{
+	Http http{std::move(url)};
+	curl_easy_setopt(http.p->curl, CURLOPT_POST, 1L);
+	return http;
+}
+
+bool Http::ca_file_supported()
+{
+	::CURL *curl = ::curl_easy_init();
+	bool res = priv::ca_file_supported(curl);
+	if (curl != nullptr) { ::curl_easy_cleanup(curl); }
+	return res;
+}
+
+std::string Http::url_encode(const std::string &str)
+{
+	::CURL *curl = ::curl_easy_init();
+	if (curl == nullptr) {
+		return str;
+	}
+	char *ce = ::curl_easy_escape(curl, str.c_str(), str.length());
+	std::string encoded = std::string(ce);
+
+	::curl_free(ce);
+	::curl_easy_cleanup(curl);
+
+	return encoded;
+}
+
+std::ostream& operator<<(std::ostream &os, const Http::Progress &progress)
+{
+	os << "Http::Progress("
+		<< "dltotal = " << progress.dltotal
+		<< ", dlnow = " << progress.dlnow
+		<< ", ultotal = " << progress.ultotal
+		<< ", ulnow = " << progress.ulnow
+		<< ")";
+	return os;
+}
+
+
+}

src/slic3r/Utils/Http.hpp

@@ -0,0 +1,115 @@
+#ifndef slic3r_Http_hpp_
+#define slic3r_Http_hpp_
+
+#include <memory>
+#include <string>
+#include <functional>
+#include <boost/filesystem/path.hpp>
+
+
+namespace Slic3r {
+
+
+/// Represetns a Http request
+class Http : public std::enable_shared_from_this<Http> {
+private:
+	struct priv;
+public:
+	struct Progress
+	{
+		size_t dltotal;   // Total bytes to download
+		size_t dlnow;     // Bytes downloaded so far
+		size_t ultotal;   // Total bytes to upload
+		size_t ulnow;     // Bytes uploaded so far
+
+		Progress(size_t dltotal, size_t dlnow, size_t ultotal, size_t ulnow) :
+			dltotal(dltotal), dlnow(dlnow), ultotal(ultotal), ulnow(ulnow)
+		{}
+	};
+
+	typedef std::shared_ptr<Http> Ptr;
+	typedef std::function<void(std::string /* body */, unsigned /* http_status */)> CompleteFn;
+	
+	// A HTTP request may fail at various stages of completeness (URL parsing, DNS lookup, TCP connection, ...).
+	// If the HTTP request could not be made or failed before completion, the `error` arg contains a description
+	// of the error and `http_status` is zero.
+	// If the HTTP request was completed but the response HTTP code is >= 400, `error` is empty and `http_status` contains the response code.
+	// In either case there may or may not be a body.
+	typedef std::function<void(std::string /* body */, std::string /* error */, unsigned /* http_status */)> ErrorFn;
+
+	// See the Progress struct above.
+	// Writing true to the `cancel` reference cancels the request in progress.
+	typedef std::function<void(Progress, bool& /* cancel */)> ProgressFn;
+
+	Http(Http &&other);
+
+	// Note: strings are expected to be UTF-8-encoded
+
+	// These are the primary constructors that create a HTTP object
+	// for a GET and a POST request respectively.
+	static Http get(std::string url);
+	static Http post(std::string url);
+	~Http();
+
+	Http(const Http &) = delete;
+	Http& operator=(const Http &) = delete;
+	Http& operator=(Http &&) = delete;
+
+	// Sets a maximum size of the data that can be received.
+	// A value of zero sets the default limit, which is is 5MB.
+	Http& size_limit(size_t sizeLimit);
+	// Sets a HTTP header field.
+	Http& header(std::string name, const std::string &value);
+	// Removes a header field.
+	Http& remove_header(std::string name);
+	// Sets a CA certificate file for usage with HTTPS. This is only supported on some backends,
+	// specifically, this is supported with OpenSSL and NOT supported with Windows and OS X native certificate store.
+	// See also ca_file_supported().
+	Http& ca_file(const std::string &filename);
+	// Add a HTTP multipart form field
+	Http& form_add(const std::string &name, const std::string &contents);
+	// Add a HTTP multipart form file data contents, `name` is the name of the part
+	Http& form_add_file(const std::string &name, const boost::filesystem::path &path);
+	// Same as above except also override the file's filename with a custom one
+	Http& form_add_file(const std::string &name, const boost::filesystem::path &path, const std::string &filename);
+
+	// Set the file contents as a POST request body.
+	// The data is used verbatim, it is not additionally encoded in any way.
+	// This can be used for hosts which do not support multipart requests.
+	Http& set_post_body(const boost::filesystem::path &path);
+
+	// Callback called on HTTP request complete
+	Http& on_complete(CompleteFn fn);
+	// Callback called on an error occuring at any stage of the requests: Url parsing, DNS lookup,
+	// TCP connection, HTTP transfer, and finally also when the response indicates an error (status >= 400).
+	// Therefore, a response body may or may not be present.
+	Http& on_error(ErrorFn fn);
+	// Callback called on data download/upload prorgess (called fairly frequently).
+	// See the `Progress` structure for description of the data passed.
+	// Writing a true-ish value into the cancel reference parameter cancels the request.
+	Http& on_progress(ProgressFn fn);
+
+	// Starts performing the request in a background thread
+	Ptr perform();
+	// Starts performing the request on the current thread
+	void perform_sync();
+	// Cancels a request in progress
+	void cancel();
+
+	// Tells whether current backend supports seting up a CA file using ca_file()
+	static bool ca_file_supported();
+
+	// converts the given string to an url_encoded_string
+	static std::string url_encode(const std::string &str);
+private:
+	Http(const std::string &url);
+
+	std::unique_ptr<priv> p;
+};
+
+std::ostream& operator<<(std::ostream &, const Http::Progress &);
+
+
+}
+
+#endif

src/slic3r/Utils/OctoPrint.cpp

@@ -0,0 +1,173 @@
+#include "OctoPrint.hpp"
+#include "PrintHostSendDialog.hpp"
+
+#include <algorithm>
+#include <boost/format.hpp>
+#include <boost/log/trivial.hpp>
+
+#include "libslic3r/PrintConfig.hpp"
+#include "Http.hpp"
+
+namespace fs = boost::filesystem;
+
+
+namespace Slic3r {
+
+OctoPrint::OctoPrint(DynamicPrintConfig *config) :
+	host(config->opt_string("print_host")),
+	apikey(config->opt_string("printhost_apikey")),
+	cafile(config->opt_string("printhost_cafile"))
+{}
+
+OctoPrint::~OctoPrint() {}
+
+bool OctoPrint::test(wxString &msg) const
+{
+	// Since the request is performed synchronously here,
+	// it is ok to refer to `msg` from within the closure
+
+	bool res = true;
+	auto url = make_url("api/version");
+
+	BOOST_LOG_TRIVIAL(info) << boost::format("Octoprint: Get version at: %1%") % url;
+
+	auto http = Http::get(std::move(url));
+	set_auth(http);
+	http.on_error([&](std::string body, std::string error, unsigned status) {
+			BOOST_LOG_TRIVIAL(error) << boost::format("Octoprint: Error getting version: %1%, HTTP %2%, body: `%3%`") % error % status % body;
+			res = false;
+			msg = format_error(body, error, status);
+		})
+		.on_complete([&](std::string body, unsigned) {
+			BOOST_LOG_TRIVIAL(debug) << boost::format("Octoprint: Got version: %1%") % body;
+		})
+		.perform_sync();
+
+	return res;
+}
+
+wxString OctoPrint::get_test_ok_msg () const
+{
+	return wxString::Format("%s", _(L("Connection to OctoPrint works correctly.")));
+}
+
+wxString OctoPrint::get_test_failed_msg (wxString &msg) const
+{
+	return wxString::Format("%s: %s\n\n%s",
+						_(L("Could not connect to OctoPrint")), msg, _(L("Note: OctoPrint version at least 1.1.0 is required.")));
+}
+
+bool OctoPrint::send_gcode(const std::string &filename) const
+{
+	enum { PROGRESS_RANGE = 1000 };
+
+	const auto errortitle = _(L("Error while uploading to the OctoPrint server"));
+	fs::path filepath(filename);
+
+	PrintHostSendDialog send_dialog(filepath.filename(), true);
+	if (send_dialog.ShowModal() != wxID_OK) { return false; }
+
+	const bool print = send_dialog.print();
+	const auto upload_filepath = send_dialog.filename();
+	const auto upload_filename = upload_filepath.filename();
+	const auto upload_parent_path = upload_filepath.parent_path();
+
+	wxProgressDialog progress_dialog(
+		_(L("OctoPrint upload")),
+		_(L("Sending G-code file to the OctoPrint server...")),
+		PROGRESS_RANGE, nullptr, wxPD_AUTO_HIDE | wxPD_APP_MODAL | wxPD_CAN_ABORT);
+	progress_dialog.Pulse();
+
+	wxString test_msg;
+	if (!test(test_msg)) {
+		auto errormsg = wxString::Format("%s: %s", errortitle, test_msg);
+		GUI::show_error(&progress_dialog, std::move(errormsg));
+		return false;
+	}
+
+	bool res = true;
+
+	auto url = make_url("api/files/local");
+
+	BOOST_LOG_TRIVIAL(info) << boost::format("Octoprint: Uploading file %1% at %2%, filename: %3%, path: %4%, print: %5%")
+		% filepath.string()
+		% url
+		% upload_filename.string()
+		% upload_parent_path.string()
+		% print;
+
+	auto http = Http::post(std::move(url));
+	set_auth(http);
+	http.form_add("print", print ? "true" : "false")
+		.form_add("path", upload_parent_path.string())
+		.form_add_file("file", filename, upload_filename.string())
+		.on_complete([&](std::string body, unsigned status) {
+			BOOST_LOG_TRIVIAL(debug) << boost::format("Octoprint: File uploaded: HTTP %1%: %2%") % status % body;
+			progress_dialog.Update(PROGRESS_RANGE);
+		})
+		.on_error([&](std::string body, std::string error, unsigned status) {
+			BOOST_LOG_TRIVIAL(error) << boost::format("Octoprint: Error uploading file: %1%, HTTP %2%, body: `%3%`") % error % status % body;
+			auto errormsg = wxString::Format("%s: %s", errortitle, format_error(body, error, status));
+			GUI::show_error(&progress_dialog, std::move(errormsg));
+			res = false;
+		})
+		.on_progress([&](Http::Progress progress, bool &cancel) {
+			if (cancel) {
+				// Upload was canceled
+				res = false;
+			} else if (progress.ultotal > 0) {
+				int value = PROGRESS_RANGE * progress.ulnow / progress.ultotal;
+				cancel = !progress_dialog.Update(std::min(value, PROGRESS_RANGE - 1));    // Cap the value to prevent premature dialog closing
+			} else {
+				cancel = !progress_dialog.Pulse();
+			}
+		})
+		.perform_sync();
+
+	return res;
+}
+
+bool OctoPrint::has_auto_discovery() const
+{
+	return true;
+}
+
+bool OctoPrint::can_test() const
+{
+	return true;
+}
+
+void OctoPrint::set_auth(Http &http) const
+{
+	http.header("X-Api-Key", apikey);
+
+	if (! cafile.empty()) {
+		http.ca_file(cafile);
+	}
+}
+
+std::string OctoPrint::make_url(const std::string &path) const
+{
+	if (host.find("http://") == 0 || host.find("https://") == 0) {
+		if (host.back() == '/') {
+			return (boost::format("%1%%2%") % host % path).str();
+		} else {
+			return (boost::format("%1%/%2%") % host % path).str();
+		}
+	} else {
+		return (boost::format("http://%1%/%2%") % host % path).str();
+	}
+}
+
+wxString OctoPrint::format_error(const std::string &body, const std::string &error, unsigned status)
+{
+	if (status != 0) {
+		auto wxbody = wxString::FromUTF8(body.data());
+		return wxString::Format("HTTP %u: %s", status, wxbody);
+	} else {
+		return wxString::FromUTF8(error.data());
+	}
+}
+
+
+}

src/slic3r/Utils/OctoPrint.hpp

@@ -0,0 +1,42 @@
+#ifndef slic3r_OctoPrint_hpp_
+#define slic3r_OctoPrint_hpp_
+
+#include <string>
+#include <wx/string.h>
+
+#include "PrintHost.hpp"
+
+
+namespace Slic3r {
+
+
+class DynamicPrintConfig;
+class Http;
+
+class OctoPrint : public PrintHost
+{
+public:
+	OctoPrint(DynamicPrintConfig *config);
+	virtual ~OctoPrint();
+
+	bool test(wxString &curl_msg) const;
+	wxString get_test_ok_msg () const;
+	wxString get_test_failed_msg (wxString &msg) const;
+	// Send gcode file to octoprint, filename is expected to be in UTF-8
+	bool send_gcode(const std::string &filename) const;
+	bool has_auto_discovery() const;
+	bool can_test() const;
+private:
+	std::string host;
+	std::string apikey;
+	std::string cafile;
+
+	void set_auth(Http &http) const;
+	std::string make_url(const std::string &path) const;
+	static wxString format_error(const std::string &body, const std::string &error, unsigned status);
+};
+
+
+}
+
+#endif

src/slic3r/Utils/PresetUpdater.cpp

@@ -0,0 +1,633 @@
+#include "PresetUpdater.hpp"
+
+#include <algorithm>
+#include <thread>
+#include <unordered_map>
+#include <ostream>
+#include <stdexcept>
+#include <boost/format.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/log/trivial.hpp>
+
+#include <wx/app.h>
+#include <wx/event.h>
+#include <wx/msgdlg.h>
+
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Utils.hpp"
+#include "slic3r/GUI/GUI.hpp"
+#include "slic3r/GUI/PresetBundle.hpp"
+#include "slic3r/GUI/UpdateDialogs.hpp"
+#include "slic3r/GUI/ConfigWizard.hpp"
+#include "slic3r/Utils/Http.hpp"
+#include "slic3r/Config/Version.hpp"
+#include "slic3r/Config/Snapshot.hpp"
+
+namespace fs = boost::filesystem;
+using Slic3r::GUI::Config::Index;
+using Slic3r::GUI::Config::Version;
+using Slic3r::GUI::Config::Snapshot;
+using Slic3r::GUI::Config::SnapshotDB;
+
+
+namespace Slic3r {
+
+
+enum {
+	SLIC3R_VERSION_BODY_MAX = 256,
+};
+
+static const char *INDEX_FILENAME = "index.idx";
+static const char *TMP_EXTENSION = ".download";
+
+
+struct Update
+{
+	fs::path source;
+	fs::path target;
+	Version version;
+
+	Update(fs::path &&source, fs::path &&target, const Version &version) :
+		source(std::move(source)),
+		target(std::move(target)),
+		version(version)
+	{}
+
+	std::string name() const { return source.stem().string(); }
+
+	friend std::ostream& operator<<(std::ostream& os , const Update &self) {
+		os << "Update(" << self.source.string() << " -> " << self.target.string() << ')';
+		return os;
+	}
+};
+
+struct Incompat
+{
+	fs::path bundle;
+	Version version;
+
+	Incompat(fs::path &&bundle, const Version &version) :
+		bundle(std::move(bundle)),
+		version(version)
+	{}
+
+	std::string name() const { return bundle.stem().string(); }
+
+	friend std::ostream& operator<<(std::ostream& os , const Incompat &self) {
+		os << "Incompat(" << self.bundle.string() << ')';
+		return os;
+	}
+};
+
+struct Updates
+{
+	std::vector<Incompat> incompats;
+	std::vector<Update> updates;
+};
+
+
+struct PresetUpdater::priv
+{
+	int version_online_event;
+	std::vector<Index> index_db;
+
+	bool enabled_version_check;
+	bool enabled_config_update;
+	std::string version_check_url;
+	bool had_config_update;
+
+	fs::path cache_path;
+	fs::path rsrc_path;
+	fs::path vendor_path;
+
+	bool cancel;
+	std::thread thread;
+
+	priv(int version_online_event);
+
+	void set_download_prefs(AppConfig *app_config);
+	bool get_file(const std::string &url, const fs::path &target_path) const;
+	void prune_tmps() const;
+	void sync_version() const;
+	void sync_config(const std::set<VendorProfile> vendors) const;
+
+	void check_install_indices() const;
+	Updates get_config_updates() const;
+	void perform_updates(Updates &&updates, bool snapshot = true) const;
+
+	static void copy_file(const fs::path &from, const fs::path &to);
+};
+
+PresetUpdater::priv::priv(int version_online_event) :
+	version_online_event(version_online_event),
+	had_config_update(false),
+	cache_path(fs::path(Slic3r::data_dir()) / "cache"),
+	rsrc_path(fs::path(resources_dir()) / "profiles"),
+	vendor_path(fs::path(Slic3r::data_dir()) / "vendor"),
+	cancel(false)
+{
+	set_download_prefs(GUI::get_app_config());
+	check_install_indices();
+	index_db = std::move(Index::load_db());
+}
+
+// Pull relevant preferences from AppConfig
+void PresetUpdater::priv::set_download_prefs(AppConfig *app_config)
+{
+	enabled_version_check = app_config->get("version_check") == "1";
+	version_check_url = app_config->version_check_url();
+	enabled_config_update = app_config->get("preset_update") == "1" && !app_config->legacy_datadir();
+}
+
+// Downloads a file (http get operation). Cancels if the Updater is being destroyed.
+bool PresetUpdater::priv::get_file(const std::string &url, const fs::path &target_path) const
+{
+	bool res = false;
+	fs::path tmp_path = target_path;
+	tmp_path += (boost::format(".%1%%2%") % get_current_pid() % TMP_EXTENSION).str();
+
+	BOOST_LOG_TRIVIAL(info) << boost::format("Get: `%1%`\n\t-> `%2%`\n\tvia tmp path `%3%`")
+		% url
+		% target_path.string()
+		% tmp_path.string();
+
+	Http::get(url)
+		.on_progress([this](Http::Progress, bool &cancel) {
+			if (cancel) { cancel = true; }
+		})
+		.on_error([&](std::string body, std::string error, unsigned http_status) {
+			(void)body;
+			BOOST_LOG_TRIVIAL(error) << boost::format("Error getting: `%1%`: HTTP %2%, %3%")
+				% url
+				% http_status
+				% error;
+		})
+		.on_complete([&](std::string body, unsigned /* http_status */) {
+			fs::fstream file(tmp_path, std::ios::out | std::ios::binary | std::ios::trunc);
+			file.write(body.c_str(), body.size());
+			file.close();
+			fs::rename(tmp_path, target_path);
+			res = true;
+		})
+		.perform_sync();
+
+	return res;
+}
+
+// Remove leftover paritally downloaded files, if any.
+void PresetUpdater::priv::prune_tmps() const
+{
+	for (fs::directory_iterator it(cache_path); it != fs::directory_iterator(); ++it) {
+		if (it->path().extension() == TMP_EXTENSION) {
+			BOOST_LOG_TRIVIAL(debug) << "Cache prune: " << it->path().string();
+			fs::remove(it->path());
+		}
+	}
+}
+
+// Get Slic3rPE version available online, save in AppConfig.
+void PresetUpdater::priv::sync_version() const
+{
+	if (! enabled_version_check) { return; }
+
+	BOOST_LOG_TRIVIAL(info) << boost::format("Downloading Slic3rPE online version from: `%1%`") % version_check_url;
+
+	Http::get(version_check_url)
+		.size_limit(SLIC3R_VERSION_BODY_MAX)
+		.on_progress([this](Http::Progress, bool &cancel) {
+			cancel = this->cancel;
+		})
+		.on_error([&](std::string body, std::string error, unsigned http_status) {
+			(void)body;
+			BOOST_LOG_TRIVIAL(error) << boost::format("Error getting: `%1%`: HTTP %2%, %3%")
+				% version_check_url
+				% http_status
+				% error;
+		})
+		.on_complete([&](std::string body, unsigned /* http_status */) {
+			boost::trim(body);
+			BOOST_LOG_TRIVIAL(info) << boost::format("Got Slic3rPE online version: `%1%`. Sending to GUI thread...") % body;
+			wxCommandEvent* evt = new wxCommandEvent(version_online_event);
+			evt->SetString(body);
+			GUI::get_app()->QueueEvent(evt);
+		})
+		.perform_sync();
+}
+
+// Download vendor indices. Also download new bundles if an index indicates there's a new one available.
+// Both are saved in cache.
+void PresetUpdater::priv::sync_config(const std::set<VendorProfile> vendors) const
+{
+	BOOST_LOG_TRIVIAL(info) << "Syncing configuration cache";
+
+	if (!enabled_config_update) { return; }
+
+	// Donwload vendor preset bundles
+	for (const auto &index : index_db) {
+		if (cancel) { return; }
+
+		const auto vendor_it = vendors.find(VendorProfile(index.vendor()));
+		if (vendor_it == vendors.end()) {
+			BOOST_LOG_TRIVIAL(warning) << "No such vendor: " << index.vendor();
+			continue;
+		}
+
+		const VendorProfile &vendor = *vendor_it;
+		if (vendor.config_update_url.empty()) {
+			BOOST_LOG_TRIVIAL(info) << "Vendor has no config_update_url: " << vendor.name;
+			continue;
+		}
+
+		// Download a fresh index
+		BOOST_LOG_TRIVIAL(info) << "Downloading index for vendor: " << vendor.name;
+		const auto idx_url = vendor.config_update_url + "/" + INDEX_FILENAME;
+		const auto idx_path = cache_path / (vendor.id + ".idx");
+		if (! get_file(idx_url, idx_path)) { continue; }
+		if (cancel) { return; }
+
+		// Load the fresh index up
+		Index new_index;
+		new_index.load(idx_path);
+
+		// See if a there's a new version to download
+		const auto recommended_it = new_index.recommended();
+		if (recommended_it == new_index.end()) {
+			BOOST_LOG_TRIVIAL(error) << boost::format("No recommended version for vendor: %1%, invalid index?") % vendor.name;
+			continue;
+		}
+		const auto recommended = recommended_it->config_version;
+
+		BOOST_LOG_TRIVIAL(debug) << boost::format("Got index for vendor: %1%: current version: %2%, recommended version: %3%")
+			% vendor.name
+			% vendor.config_version.to_string()
+			% recommended.to_string();
+
+		if (vendor.config_version >= recommended) { continue; }
+
+		// Download a fresh bundle
+		BOOST_LOG_TRIVIAL(info) << "Downloading new bundle for vendor: " << vendor.name;
+		const auto bundle_url = (boost::format("%1%/%2%.ini") % vendor.config_update_url % recommended.to_string()).str();
+		const auto bundle_path = cache_path / (vendor.id + ".ini");
+		if (! get_file(bundle_url, bundle_path)) { continue; }
+		if (cancel) { return; }
+	}
+}
+
+// Install indicies from resources. Only installs those that are either missing or older than in resources.
+void PresetUpdater::priv::check_install_indices() const
+{
+	BOOST_LOG_TRIVIAL(info) << "Checking if indices need to be installed from resources...";
+
+	for (fs::directory_iterator it(rsrc_path); it != fs::directory_iterator(); ++it) {
+		const auto &path = it->path();
+		if (path.extension() == ".idx") {
+			const auto path_in_cache = cache_path / path.filename();
+
+			if (! fs::exists(path_in_cache)) {
+				BOOST_LOG_TRIVIAL(info) << "Install index from resources: " << path.filename();
+				copy_file(path, path_in_cache);
+			} else {
+				Index idx_rsrc, idx_cache;
+				idx_rsrc.load(path);
+				idx_cache.load(path_in_cache);
+
+				if (idx_cache.version() < idx_rsrc.version()) {
+					BOOST_LOG_TRIVIAL(info) << "Update index from resources: " << path.filename();
+					copy_file(path, path_in_cache);
+				}
+			}
+		}
+	}
+}
+
+// Generates a list of bundle updates that are to be performed
+Updates PresetUpdater::priv::get_config_updates() const
+{
+	Updates updates;
+
+	BOOST_LOG_TRIVIAL(info) << "Checking for cached configuration updates...";
+
+	for (const auto idx : index_db) {
+		auto bundle_path = vendor_path / (idx.vendor() + ".ini");
+
+		if (! fs::exists(bundle_path)) {
+			BOOST_LOG_TRIVIAL(info) << "Bundle not present for index, skipping: " << idx.vendor();
+			continue;
+		}
+
+		// Perform a basic load and check the version
+		const auto vp = VendorProfile::from_ini(bundle_path, false);
+
+		const auto ver_current = idx.find(vp.config_version);
+		if (ver_current == idx.end()) {
+			auto message = (boost::format("Preset bundle `%1%` version not found in index: %2%") % idx.vendor() % vp.config_version.to_string()).str();
+			BOOST_LOG_TRIVIAL(error) << message;
+			throw std::runtime_error(message);
+		}
+
+		// Getting a recommended version from the latest index, wich may have been downloaded
+		// from the internet, or installed / updated from the installation resources.
+		const auto recommended = idx.recommended();
+		if (recommended == idx.end()) {
+			BOOST_LOG_TRIVIAL(error) << boost::format("No recommended version for vendor: %1%, invalid index?") % idx.vendor();
+		}
+
+		BOOST_LOG_TRIVIAL(debug) << boost::format("Vendor: %1%, version installed: %2%, version cached: %3%")
+			% vp.name
+			% ver_current->config_version.to_string()
+			% recommended->config_version.to_string();
+
+		if (! ver_current->is_current_slic3r_supported()) {
+			BOOST_LOG_TRIVIAL(warning) << "Current Slic3r incompatible with installed bundle: " << bundle_path.string();
+			updates.incompats.emplace_back(std::move(bundle_path), *ver_current);
+		} else if (recommended->config_version > ver_current->config_version) {
+			// Config bundle update situation
+
+			// Check if the update is already present in a snapshot
+			const auto recommended_snap = SnapshotDB::singleton().snapshot_with_vendor_preset(vp.name, recommended->config_version);
+			if (recommended_snap != SnapshotDB::singleton().end()) {
+				BOOST_LOG_TRIVIAL(info) << boost::format("Bundle update %1% %2% already found in snapshot %3%, skipping...")
+					% vp.name
+					% recommended->config_version.to_string()
+					% recommended_snap->id;
+				continue;
+			}
+
+			auto path_src = cache_path / (idx.vendor() + ".ini");
+			auto path_in_rsrc = rsrc_path / (idx.vendor() + ".ini");
+			if (! fs::exists(path_src)) {
+				if (! fs::exists(path_in_rsrc)) {
+					BOOST_LOG_TRIVIAL(warning) << boost::format("Index for vendor %1% indicates update, but bundle found in neither cache nor resources")
+						% idx.vendor();
+					continue;
+				} else {
+					path_src = std::move(path_in_rsrc);
+					path_in_rsrc.clear();
+				}
+			}
+
+			auto new_vp = VendorProfile::from_ini(path_src, false);
+			bool found = false;
+			if (new_vp.config_version == recommended->config_version) {
+				updates.updates.emplace_back(std::move(path_src), std::move(bundle_path), *recommended);
+				found = true;
+			} else if (! path_in_rsrc.empty() && fs::exists(path_in_rsrc)) {
+				new_vp = VendorProfile::from_ini(path_in_rsrc, false);
+				if (new_vp.config_version == recommended->config_version) {
+					updates.updates.emplace_back(std::move(path_in_rsrc), std::move(bundle_path), *recommended);
+					found = true;
+				}
+			}
+			if (! found)
+				BOOST_LOG_TRIVIAL(warning) << boost::format("Index for vendor %1% indicates update (%2%) but the new bundle was found neither in cache nor resources")
+					% idx.vendor()
+					% recommended->config_version.to_string();
+		}
+	}
+
+	return updates;
+}
+
+void PresetUpdater::priv::perform_updates(Updates &&updates, bool snapshot) const
+{
+	if (updates.incompats.size() > 0) {
+		if (snapshot) {
+			BOOST_LOG_TRIVIAL(info) << "Taking a snapshot...";
+			SnapshotDB::singleton().take_snapshot(*GUI::get_app_config(), Snapshot::SNAPSHOT_DOWNGRADE);
+		}
+
+		BOOST_LOG_TRIVIAL(info) << boost::format("Deleting %1% incompatible bundles") % updates.incompats.size();
+
+		for (const auto &incompat : updates.incompats) {
+			BOOST_LOG_TRIVIAL(info) << '\t' << incompat;
+			fs::remove(incompat.bundle);
+		}
+	}
+	else if (updates.updates.size() > 0) {
+		if (snapshot) {
+			BOOST_LOG_TRIVIAL(info) << "Taking a snapshot...";
+			SnapshotDB::singleton().take_snapshot(*GUI::get_app_config(), Snapshot::SNAPSHOT_UPGRADE);
+		}
+
+		BOOST_LOG_TRIVIAL(info) << boost::format("Performing %1% updates") % updates.updates.size();
+
+		for (const auto &update : updates.updates) {
+			BOOST_LOG_TRIVIAL(info) << '\t' << update;
+
+			copy_file(update.source, update.target);
+
+			PresetBundle bundle;
+			bundle.load_configbundle(update.target.string(), PresetBundle::LOAD_CFGBNDLE_SYSTEM);
+
+			BOOST_LOG_TRIVIAL(info) << boost::format("Deleting %1% conflicting presets")
+				% (bundle.prints.size() + bundle.filaments.size() + bundle.printers.size());
+
+			auto preset_remover = [](const Preset &preset) {
+				BOOST_LOG_TRIVIAL(info) << '\t' << preset.file;
+				fs::remove(preset.file);
+			};
+
+			for (const auto &preset : bundle.prints)    { preset_remover(preset); }
+			for (const auto &preset : bundle.filaments) { preset_remover(preset); }
+			for (const auto &preset : bundle.printers)  { preset_remover(preset); }
+
+			// Also apply the `obsolete_presets` property, removing obsolete ini files
+
+			BOOST_LOG_TRIVIAL(info) << boost::format("Deleting %1% obsolete presets")
+				% (bundle.obsolete_presets.prints.size() + bundle.obsolete_presets.filaments.size() + bundle.obsolete_presets.printers.size());
+
+			auto obsolete_remover = [](const char *subdir, const std::string &preset) {
+				auto path = fs::path(Slic3r::data_dir()) / subdir / preset;
+				path += ".ini";
+				BOOST_LOG_TRIVIAL(info) << '\t' << path.string();
+				fs::remove(path);
+			};
+
+			for (const auto &name : bundle.obsolete_presets.prints)    { obsolete_remover("print", name); }
+			for (const auto &name : bundle.obsolete_presets.filaments) { obsolete_remover("filament", name); }
+			for (const auto &name : bundle.obsolete_presets.filaments) { obsolete_remover("sla_material", name); }
+			for (const auto &name : bundle.obsolete_presets.printers)  { obsolete_remover("printer", name); }
+		}
+	}
+}
+
+void PresetUpdater::priv::copy_file(const fs::path &source, const fs::path &target)
+{
+	static const auto perms = fs::owner_read | fs::owner_write | fs::group_read | fs::others_read;   // aka 644
+
+	// Make sure the file has correct permission both before and after we copy over it
+	if (fs::exists(target)) {
+		fs::permissions(target, perms);
+	}
+	fs::copy_file(source, target, fs::copy_option::overwrite_if_exists);
+	fs::permissions(target, perms);
+}
+
+
+PresetUpdater::PresetUpdater(int version_online_event) :
+	p(new priv(version_online_event))
+{}
+
+
+// Public
+
+PresetUpdater::~PresetUpdater()
+{
+	if (p && p->thread.joinable()) {
+		// This will stop transfers being done by the thread, if any.
+		// Cancelling takes some time, but should complete soon enough.
+		p->cancel = true;
+		p->thread.join();
+	}
+}
+
+void PresetUpdater::sync(PresetBundle *preset_bundle)
+{
+	p->set_download_prefs(GUI::get_app_config());
+	if (!p->enabled_version_check && !p->enabled_config_update) { return; }
+
+	// Copy the whole vendors data for use in the background thread
+	// Unfortunatelly as of C++11, it needs to be copied again
+	// into the closure (but perhaps the compiler can elide this).
+	std::set<VendorProfile> vendors = preset_bundle->vendors;
+
+	p->thread = std::move(std::thread([this, vendors]() {
+		this->p->prune_tmps();
+		this->p->sync_version();
+		this->p->sync_config(std::move(vendors));
+	}));
+}
+
+void PresetUpdater::slic3r_update_notify()
+{
+	if (! p->enabled_version_check) { return; }
+
+	if (p->had_config_update) {
+		BOOST_LOG_TRIVIAL(info) << "New Slic3r version available, but there was a configuration update, notification won't be displayed";
+		return;
+	}
+
+	auto* app_config = GUI::get_app_config();
+	const auto ver_slic3r = Semver::parse(SLIC3R_VERSION);
+	const auto ver_online_str = app_config->get("version_online");
+	const auto ver_online = Semver::parse(ver_online_str);
+	const auto ver_online_seen = Semver::parse(app_config->get("version_online_seen"));
+	if (! ver_slic3r) {
+		throw std::runtime_error("Could not parse Slic3r version string: " SLIC3R_VERSION);
+	}
+
+	if (ver_online) {
+		// Only display the notification if the version available online is newer AND if we haven't seen it before
+		if (*ver_online > *ver_slic3r && (! ver_online_seen || *ver_online_seen < *ver_online)) {
+			GUI::MsgUpdateSlic3r notification(*ver_slic3r, *ver_online);
+			notification.ShowModal();
+			if (notification.disable_version_check()) {
+				app_config->set("version_check", "0");
+				p->enabled_version_check = false;
+			}
+		}
+		app_config->set("version_online_seen", ver_online_str);
+	}
+}
+
+bool PresetUpdater::config_update() const
+{
+	if (! p->enabled_config_update) { return true; }
+
+	auto updates = p->get_config_updates();
+	if (updates.incompats.size() > 0) {
+		BOOST_LOG_TRIVIAL(info) << boost::format("%1% bundles incompatible. Asking for action...") % updates.incompats.size();
+
+		std::unordered_map<std::string, wxString> incompats_map;
+		for (const auto &incompat : updates.incompats) {
+			auto vendor = incompat.name();
+
+			const auto min_slic3r = incompat.version.min_slic3r_version;
+			const auto max_slic3r = incompat.version.max_slic3r_version;
+			wxString restrictions;
+			if (min_slic3r != Semver::zero() && max_slic3r != Semver::inf()) {
+				restrictions = wxString::Format(_(L("requires min. %s and max. %s")),
+					min_slic3r.to_string(),
+					max_slic3r.to_string()
+				);
+			} else if (min_slic3r != Semver::zero()) {
+				restrictions = wxString::Format(_(L("requires min. %s")), min_slic3r.to_string());
+			} else {
+				restrictions = wxString::Format(_(L("requires max. %s")), max_slic3r.to_string());
+			}
+
+			incompats_map.emplace(std::make_pair(std::move(vendor), std::move(restrictions)));
+		}
+
+		p->had_config_update = true;   // This needs to be done before a dialog is shown because of OnIdle() + CallAfter() in Perl
+
+		GUI::MsgDataIncompatible dlg(std::move(incompats_map));
+		const auto res = dlg.ShowModal();
+		if (res == wxID_REPLACE) {
+			BOOST_LOG_TRIVIAL(info) << "User wants to re-configure...";
+			p->perform_updates(std::move(updates));
+			GUI::ConfigWizard wizard(nullptr, GUI::ConfigWizard::RR_DATA_INCOMPAT);
+			if (! wizard.run(GUI::get_preset_bundle(), this)) {
+				return false;
+			}
+			GUI::load_current_presets();
+		} else {
+			BOOST_LOG_TRIVIAL(info) << "User wants to exit Slic3r, bye...";
+			return false;
+		}
+	}
+	else if (updates.updates.size() > 0) {
+		BOOST_LOG_TRIVIAL(info) << boost::format("Update of %1% bundles available. Asking for confirmation ...") % updates.updates.size();
+
+		std::unordered_map<std::string, std::string> updates_map;
+		for (const auto &update : updates.updates) {
+			auto vendor = update.name();
+			auto ver_str = update.version.config_version.to_string();
+			if (! update.version.comment.empty()) {
+				ver_str += std::string(" (") + update.version.comment + ")";
+			}
+			updates_map.emplace(std::make_pair(std::move(vendor), std::move(ver_str)));
+		}
+
+		p->had_config_update = true;   // Ditto, see above
+
+		GUI::MsgUpdateConfig dlg(std::move(updates_map));
+
+		const auto res = dlg.ShowModal();
+		if (res == wxID_OK) {
+			BOOST_LOG_TRIVIAL(debug) << "User agreed to perform the update";
+			p->perform_updates(std::move(updates));
+
+			// Reload global configuration
+			auto *app_config = GUI::get_app_config();
+			GUI::get_preset_bundle()->load_presets(*app_config);
+			GUI::load_current_presets();
+		} else {
+			BOOST_LOG_TRIVIAL(info) << "User refused the update";
+		}
+	} else {
+		BOOST_LOG_TRIVIAL(info) << "No configuration updates available.";
+	}
+
+	return true;
+}
+
+void PresetUpdater::install_bundles_rsrc(std::vector<std::string> bundles, bool snapshot) const
+{
+	Updates updates;
+
+	BOOST_LOG_TRIVIAL(info) << boost::format("Installing %1% bundles from resources ...") % bundles.size();
+
+	for (const auto &bundle : bundles) {
+		auto path_in_rsrc = p->rsrc_path / bundle;
+		auto path_in_vendors = p->vendor_path / bundle;
+		updates.updates.emplace_back(std::move(path_in_rsrc), std::move(path_in_vendors), Version());
+	}
+
+	p->perform_updates(std::move(updates), snapshot);
+}
+
+
+}

src/slic3r/Utils/PresetUpdater.hpp

@@ -0,0 +1,42 @@
+#ifndef slic3r_PresetUpdate_hpp_
+#define slic3r_PresetUpdate_hpp_
+
+#include <memory>
+#include <vector>
+
+namespace Slic3r {
+
+
+class AppConfig;
+class PresetBundle;
+
+class PresetUpdater
+{
+public:
+	PresetUpdater(int version_online_event);
+	PresetUpdater(PresetUpdater &&) = delete;
+	PresetUpdater(const PresetUpdater &) = delete;
+	PresetUpdater &operator=(PresetUpdater &&) = delete;
+	PresetUpdater &operator=(const PresetUpdater &) = delete;
+	~PresetUpdater();
+
+	// If either version check or config updating is enabled, get the appropriate data in the background and cache it.
+	void sync(PresetBundle *preset_bundle);
+
+	// If version check is enabled, check if chaced online slic3r version is newer, notify if so.
+	void slic3r_update_notify();
+
+	// If updating is enabled, check if updates are available in cache, if so, ask about installation.
+	// A false return value implies Slic3r should exit due to incompatibility of configuration.
+	bool config_update() const;
+
+	// "Update" a list of bundles from resources (behaves like an online update).
+	void install_bundles_rsrc(std::vector<std::string> bundles, bool snapshot = true) const;
+private:
+	struct priv;
+	std::unique_ptr<priv> p;
+};
+
+
+}
+#endif

src/slic3r/Utils/PrintHost.cpp

@@ -0,0 +1,23 @@
+#include "OctoPrint.hpp"
+#include "Duet.hpp"
+
+#include "libslic3r/PrintConfig.hpp"
+
+namespace Slic3r {
+
+
+PrintHost::~PrintHost() {}
+
+PrintHost* PrintHost::get_print_host(DynamicPrintConfig *config)
+{
+	PrintHostType kind = config->option<ConfigOptionEnum<PrintHostType>>("host_type")->value;
+	if (kind == htOctoPrint) {
+		return new OctoPrint(config);
+	} else if (kind == htDuet) {
+		return new Duet(config);
+	}
+	return nullptr;
+}
+
+
+}

src/slic3r/Utils/PrintHost.hpp

@@ -0,0 +1,35 @@
+#ifndef slic3r_PrintHost_hpp_
+#define slic3r_PrintHost_hpp_
+
+#include <memory>
+#include <string>
+#include <wx/string.h>
+
+
+namespace Slic3r {
+
+
+class DynamicPrintConfig;
+
+class PrintHost
+{
+public:
+	virtual ~PrintHost();
+
+	virtual bool test(wxString &curl_msg) const = 0;
+	virtual wxString get_test_ok_msg () const = 0;
+	virtual wxString get_test_failed_msg (wxString &msg) const = 0;
+	// Send gcode file to print host, filename is expected to be in UTF-8
+	virtual bool send_gcode(const std::string &filename) const = 0;
+	virtual bool has_auto_discovery() const = 0;
+	virtual bool can_test() const = 0;
+
+	static PrintHost* get_print_host(DynamicPrintConfig *config);
+};
+
+
+
+
+}
+
+#endif

src/slic3r/Utils/PrintHostSendDialog.cpp

@@ -0,0 +1,52 @@
+#include "PrintHostSendDialog.hpp"
+
+#include <wx/frame.h>
+#include <wx/event.h>
+#include <wx/progdlg.h>
+#include <wx/sizer.h>
+#include <wx/stattext.h>
+#include <wx/textctrl.h>
+#include <wx/checkbox.h>
+
+#include "slic3r/GUI/GUI.hpp"
+#include "slic3r/GUI/MsgDialog.hpp"
+
+
+namespace fs = boost::filesystem;
+
+namespace Slic3r {
+
+PrintHostSendDialog::PrintHostSendDialog(const fs::path &path, bool can_start_print) :
+	MsgDialog(nullptr, _(L("Send G-Code to printer host")), _(L("Upload to Printer Host with the following filename:")), wxID_NONE),
+	txt_filename(new wxTextCtrl(this, wxID_ANY, path.filename().wstring())),
+	box_print(new wxCheckBox(this, wxID_ANY, _(L("Start printing after upload")))),
+	can_start_print(can_start_print)
+{
+	auto *label_dir_hint = new wxStaticText(this, wxID_ANY, _(L("Use forward slashes ( / ) as a directory separator if needed.")));
+	label_dir_hint->Wrap(CONTENT_WIDTH);
+
+	content_sizer->Add(txt_filename, 0, wxEXPAND);
+	content_sizer->Add(label_dir_hint);
+	content_sizer->AddSpacer(VERT_SPACING);
+	content_sizer->Add(box_print, 0, wxBOTTOM, 2*VERT_SPACING);
+
+	btn_sizer->Add(CreateStdDialogButtonSizer(wxOK | wxCANCEL));
+
+	txt_filename->SetFocus();
+	wxString stem(path.stem().wstring());
+	txt_filename->SetSelection(0, stem.Length());
+
+	box_print->Enable(can_start_print);
+
+	Fit();
+}
+
+fs::path PrintHostSendDialog::filename() const 
+{
+	return fs::path(txt_filename->GetValue().wx_str());
+}
+
+bool PrintHostSendDialog::print() const 
+{ 
+	return box_print->GetValue(); }
+}

src/slic3r/Utils/PrintHostSendDialog.hpp

@@ -0,0 +1,38 @@
+#ifndef slic3r_PrintHostSendDialog_hpp_
+#define slic3r_PrintHostSendDialog_hpp_
+
+#include <string>
+
+#include <boost/filesystem/path.hpp>
+
+#include <wx/string.h>
+#include <wx/frame.h>
+#include <wx/event.h>
+#include <wx/progdlg.h>
+#include <wx/sizer.h>
+#include <wx/stattext.h>
+#include <wx/textctrl.h>
+#include <wx/checkbox.h>
+
+#include "slic3r/GUI/GUI.hpp"
+#include "slic3r/GUI/MsgDialog.hpp"
+
+
+namespace Slic3r {
+
+class PrintHostSendDialog : public GUI::MsgDialog
+{
+private:
+	wxTextCtrl *txt_filename;
+	wxCheckBox *box_print;
+	bool can_start_print;
+
+public:
+	PrintHostSendDialog(const boost::filesystem::path &path, bool can_start_print);
+	boost::filesystem::path filename() const;
+	bool print() const;
+};
+
+}
+
+#endif

src/slic3r/Utils/Semver.hpp

@@ -0,0 +1,151 @@
+#ifndef slic3r_Semver_hpp_
+#define slic3r_Semver_hpp_
+
+#include <string>
+#include <cstring>
+#include <ostream>
+#include <stdexcept>
+#include <boost/optional.hpp>
+#include <boost/format.hpp>
+
+#include "semver/semver.h"
+
+namespace Slic3r {
+
+
+class Semver
+{
+public:
+	struct Major { const int i;  Major(int i) : i(i) {} };
+	struct Minor { const int i;  Minor(int i) : i(i) {} };
+	struct Patch { const int i;  Patch(int i) : i(i) {} };
+
+	Semver() : ver(semver_zero()) {}
+
+	Semver(int major, int minor, int patch,
+		boost::optional<const std::string&> metadata = boost::none,
+		boost::optional<const std::string&> prerelease = boost::none)
+		: ver(semver_zero())
+	{
+		ver.major = major;
+		ver.minor = minor;
+		ver.patch = patch;
+		set_metadata(metadata);
+		set_prerelease(prerelease);
+	}
+
+	Semver(const std::string &str) : ver(semver_zero())
+	{
+		auto parsed = parse(str);
+		if (! parsed) {
+			throw std::runtime_error(std::string("Could not parse version string: ") + str);
+		}
+		ver = parsed->ver;
+		parsed->ver = semver_zero();
+	}
+
+	static boost::optional<Semver> parse(const std::string &str)
+	{
+		semver_t ver = semver_zero();
+		if (::semver_parse(str.c_str(), &ver) == 0) {
+			return Semver(ver);
+		} else {
+			return boost::none;
+		}
+	}
+
+	static const Semver zero() { return Semver(semver_zero()); }
+
+	static const Semver inf()
+	{
+		static semver_t ver = { std::numeric_limits<int>::max(), std::numeric_limits<int>::max(), std::numeric_limits<int>::max(), nullptr, nullptr };
+		return Semver(ver);
+	}
+
+	static const Semver invalid()
+	{
+		static semver_t ver = { -1, 0, 0, nullptr, nullptr };
+		return Semver(ver);
+	}
+
+	Semver(Semver &&other) : ver(other.ver) { other.ver = semver_zero(); }
+	Semver(const Semver &other) : ver(::semver_copy(&other.ver)) {}
+
+	Semver &operator=(Semver &&other)
+	{
+		::semver_free(&ver);
+		ver = other.ver;
+		other.ver = semver_zero();
+		return *this;
+	}
+
+	Semver &operator=(const Semver &other)
+	{
+		::semver_free(&ver);
+		ver = ::semver_copy(&other.ver);
+		return *this;
+	}
+
+	~Semver() { ::semver_free(&ver); }
+
+	// const accessors
+	int 		maj()        const { return ver.major; }
+	int 		min()        const { return ver.minor; }
+	int 		patch() 	 const { return ver.patch; }
+	const char*	prerelease() const { return ver.prerelease; }
+	const char*	metadata() 	 const { return ver.metadata; }
+	
+	// Setters
+	void set_maj(int maj) { ver.major = maj; }
+	void set_min(int min) { ver.minor = min; }
+	void set_patch(int patch) { ver.patch = patch; }
+	void set_metadata(boost::optional<const std::string&> meta) { ver.metadata = meta ? strdup(*meta) : nullptr; }
+	void set_prerelease(boost::optional<const std::string&> pre) { ver.prerelease = pre ? strdup(*pre) : nullptr; }
+
+	// Comparison
+	bool operator<(const Semver &b)  const { return ::semver_compare(ver, b.ver) == -1; }
+	bool operator<=(const Semver &b) const { return ::semver_compare(ver, b.ver) <= 0; }
+	bool operator==(const Semver &b) const { return ::semver_compare(ver, b.ver) == 0; }
+	bool operator!=(const Semver &b) const { return ::semver_compare(ver, b.ver) != 0; }
+	bool operator>=(const Semver &b) const { return ::semver_compare(ver, b.ver) >= 0; }
+	bool operator>(const Semver &b)  const { return ::semver_compare(ver, b.ver) == 1; }
+	// We're using '&' instead of the '~' operator here as '~' is unary-only:
+	// Satisfies patch if Major and minor are equal.
+	bool operator&(const Semver &b) const { return ::semver_satisfies_patch(ver, b.ver); }
+	bool operator^(const Semver &b) const { return ::semver_satisfies_caret(ver, b.ver); }
+	bool in_range(const Semver &low, const Semver &high) const { return low <= *this && *this <= high; }
+
+	// Conversion
+	std::string to_string() const {
+		auto res = (boost::format("%1%.%2%.%3%") % ver.major % ver.minor % ver.patch).str();
+		if (ver.prerelease != nullptr) { res += '-'; res += ver.prerelease; }
+		if (ver.metadata != nullptr)   { res += '+'; res += ver.metadata; }
+		return res;
+	}
+
+	// Arithmetics
+	Semver& operator+=(const Major &b) { ver.major += b.i; return *this; }
+	Semver& operator+=(const Minor &b) { ver.minor += b.i; return *this; }
+	Semver& operator+=(const Patch &b) { ver.patch += b.i; return *this; }
+	Semver& operator-=(const Major &b) { ver.major -= b.i; return *this; }
+	Semver& operator-=(const Minor &b) { ver.minor -= b.i; return *this; }
+	Semver& operator-=(const Patch &b) { ver.patch -= b.i; return *this; }
+	Semver operator+(const Major &b) const { Semver res(*this); return res += b; }
+	Semver operator+(const Minor &b) const { Semver res(*this); return res += b; }
+	Semver operator+(const Patch &b) const { Semver res(*this); return res += b; }
+	Semver operator-(const Major &b) const { Semver res(*this); return res -= b; }
+	Semver operator-(const Minor &b) const { Semver res(*this); return res -= b; }
+	Semver operator-(const Patch &b) const { Semver res(*this); return res -= b; }
+
+private:
+	semver_t ver;
+
+	Semver(semver_t ver) : ver(ver) {}
+
+	static semver_t semver_zero() { return { 0, 0, 0, nullptr, nullptr }; }
+	static char * strdup(const std::string &str) { return ::semver_strdup(const_cast<char*>(str.c_str())); }
+};
+
+
+}
+#endif

src/slic3r/Utils/Serial.cpp

@@ -0,0 +1,495 @@
+#include "Serial.hpp"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <chrono>
+#include <thread>
+#include <fstream>
+#include <stdexcept>
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/format.hpp>
+#include <boost/optional.hpp>
+
+#if _WIN32
+	#include <Windows.h>
+	#include <Setupapi.h>
+	#include <initguid.h>
+	#include <devguid.h>
+	#include <regex>
+	// Undefine min/max macros incompatible with the standard library
+	// For example, std::numeric_limits<std::streamsize>::max()
+	// produces some weird errors
+	#ifdef min
+	#undef min
+	#endif
+	#ifdef max
+	#undef max
+	#endif
+	#include "boost/nowide/convert.hpp"
+	#pragma comment(lib, "user32.lib")
+#elif __APPLE__
+	#include <CoreFoundation/CoreFoundation.h>
+	#include <CoreFoundation/CFString.h>
+	#include <IOKit/IOKitLib.h>
+	#include <IOKit/serial/IOSerialKeys.h>
+	#include <IOKit/serial/ioss.h>
+	#include <sys/syslimits.h>
+#endif
+
+#ifndef _WIN32
+	#include <sys/ioctl.h>
+	#include <sys/time.h>
+	#include <sys/unistd.h>
+	#include <sys/select.h>
+#endif
+
+#if defined(__APPLE__) || defined(__OpenBSD__)
+	#include <termios.h>
+#elif defined __linux__
+	#include <fcntl.h>
+	#include <asm-generic/ioctls.h>
+#endif
+
+using boost::optional;
+
+
+namespace Slic3r {
+namespace Utils {
+
+static bool looks_like_printer(const std::string &friendly_name)
+{
+	return friendly_name.find("Original Prusa") != std::string::npos;
+}
+
+#if _WIN32
+void parse_hardware_id(const std::string &hardware_id, SerialPortInfo &spi)
+{
+	unsigned vid, pid;
+	std::regex pattern("USB\\\\.*VID_([[:xdigit:]]+)&PID_([[:xdigit:]]+).*");
+	std::smatch matches;
+	if (std::regex_match(hardware_id, matches, pattern)) {
+		try {
+			vid = std::stoul(matches[1].str(), 0, 16);
+			pid = std::stoul(matches[2].str(), 0, 16);
+			spi.id_vendor = vid;
+			spi.id_product = pid;
+		}
+		catch (...) {}
+	}
+}
+#endif
+
+#ifdef __linux__
+optional<std::string> sysfs_tty_prop(const std::string &tty_dev, const std::string &name)
+{
+	const auto prop_path = (boost::format("/sys/class/tty/%1%/device/../%2%") % tty_dev % name).str();
+	std::ifstream file(prop_path);
+	std::string res;
+
+	std::getline(file, res);
+	if (file.good()) { return res; }
+	else { return boost::none; }
+}
+
+optional<unsigned long> sysfs_tty_prop_hex(const std::string &tty_dev, const std::string &name)
+{
+	auto prop = sysfs_tty_prop(tty_dev, name);
+	if (!prop) { return boost::none; }
+
+	try { return std::stoul(*prop, 0, 16); }
+	catch (...) { return boost::none; }
+}
+#endif
+
+std::vector<SerialPortInfo> scan_serial_ports_extended()
+{
+	std::vector<SerialPortInfo> output;
+
+#ifdef _WIN32
+	SP_DEVINFO_DATA devInfoData = { 0 };
+	devInfoData.cbSize = sizeof(devInfoData);
+	// Get the tree containing the info for the ports.
+	HDEVINFO hDeviceInfo = SetupDiGetClassDevs(&GUID_DEVCLASS_PORTS, 0, nullptr, DIGCF_PRESENT);
+	if (hDeviceInfo != INVALID_HANDLE_VALUE) {
+		// Iterate over all the devices in the tree.
+		for (int nDevice = 0; SetupDiEnumDeviceInfo(hDeviceInfo, nDevice, &devInfoData); ++ nDevice) {
+			SerialPortInfo port_info;
+			// Get the registry key which stores the ports settings.
+			HKEY hDeviceKey = SetupDiOpenDevRegKey(hDeviceInfo, &devInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
+			if (hDeviceKey) {
+				// Read in the name of the port.
+				wchar_t pszPortName[4096];
+				DWORD dwSize = sizeof(pszPortName);
+				DWORD dwType = 0;
+				if (RegQueryValueEx(hDeviceKey, L"PortName", NULL, &dwType, (LPBYTE)pszPortName, &dwSize) == ERROR_SUCCESS)
+					port_info.port = boost::nowide::narrow(pszPortName);
+				RegCloseKey(hDeviceKey);
+				if (port_info.port.empty())
+					continue;
+			}
+
+			// Find the size required to hold the device info.
+			DWORD regDataType;
+			DWORD reqSize = 0;
+			SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_HARDWAREID, nullptr, nullptr, 0, &reqSize);
+			std::vector<wchar_t> hardware_id(reqSize > 1 ? reqSize : 1);
+			// Now store it in a buffer.
+			if (! SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_HARDWAREID, &regDataType, (BYTE*)hardware_id.data(), reqSize, nullptr))
+				continue;
+			parse_hardware_id(boost::nowide::narrow(hardware_id.data()), port_info);
+
+			// Find the size required to hold the friendly name.
+			reqSize = 0;
+			SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_FRIENDLYNAME, nullptr, nullptr, 0, &reqSize);
+			std::vector<wchar_t> friendly_name;
+			friendly_name.reserve(reqSize > 1 ? reqSize : 1);
+			// Now store it in a buffer.
+			if (! SetupDiGetDeviceRegistryProperty(hDeviceInfo, &devInfoData, SPDRP_FRIENDLYNAME, nullptr, (BYTE*)friendly_name.data(), reqSize, nullptr)) {
+				port_info.friendly_name = port_info.port;
+			} else {
+				port_info.friendly_name = boost::nowide::narrow(friendly_name.data());
+				port_info.is_printer = looks_like_printer(port_info.friendly_name);
+			}
+			output.emplace_back(std::move(port_info));
+		}
+	}
+#elif __APPLE__
+	// inspired by https://sigrok.org/wiki/Libserialport
+	CFMutableDictionaryRef classes = IOServiceMatching(kIOSerialBSDServiceValue);
+	if (classes != 0) {
+		io_iterator_t iter;
+		if (IOServiceGetMatchingServices(kIOMasterPortDefault, classes, &iter) == KERN_SUCCESS) {
+			io_object_t port;
+			while ((port = IOIteratorNext(iter)) != 0) {
+				CFTypeRef cf_property = IORegistryEntryCreateCFProperty(port, CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0);
+				if (cf_property) {
+					char path[PATH_MAX];
+					Boolean result = CFStringGetCString((CFStringRef)cf_property, path, sizeof(path), kCFStringEncodingUTF8);
+					CFRelease(cf_property);
+					if (result) {
+						SerialPortInfo port_info;
+						port_info.port = path;
+
+						// Attempt to read out the device friendly name
+						if ((cf_property = IORegistryEntrySearchCFProperty(port, kIOServicePlane,
+						         CFSTR("USB Interface Name"), kCFAllocatorDefault,
+						         kIORegistryIterateRecursively | kIORegistryIterateParents)) ||
+						    (cf_property = IORegistryEntrySearchCFProperty(port, kIOServicePlane,
+						         CFSTR("USB Product Name"), kCFAllocatorDefault,
+						         kIORegistryIterateRecursively | kIORegistryIterateParents)) ||
+						    (cf_property = IORegistryEntrySearchCFProperty(port, kIOServicePlane,
+						         CFSTR("Product Name"), kCFAllocatorDefault,
+						         kIORegistryIterateRecursively | kIORegistryIterateParents)) ||
+						    (cf_property = IORegistryEntryCreateCFProperty(port, 
+						         CFSTR(kIOTTYDeviceKey), kCFAllocatorDefault, 0))) {
+							// Description limited to 127 char, anything longer would not be user friendly anyway.
+							char description[128];
+							if (CFStringGetCString((CFStringRef)cf_property, description, sizeof(description), kCFStringEncodingUTF8)) {
+								port_info.friendly_name = std::string(description) + " (" + port_info.port + ")";
+								port_info.is_printer = looks_like_printer(port_info.friendly_name);
+							}
+							CFRelease(cf_property);
+						}
+						if (port_info.friendly_name.empty())
+							port_info.friendly_name = port_info.port;
+
+						// Attempt to read out the VID & PID
+						int vid, pid;
+						auto cf_vendor = IORegistryEntrySearchCFProperty(port, kIOServicePlane, CFSTR("idVendor"),
+							kCFAllocatorDefault, kIORegistryIterateRecursively | kIORegistryIterateParents);
+						auto cf_product = IORegistryEntrySearchCFProperty(port, kIOServicePlane, CFSTR("idProduct"),
+							kCFAllocatorDefault, kIORegistryIterateRecursively | kIORegistryIterateParents);
+						if (cf_vendor && cf_product) {
+							if (CFNumberGetValue((CFNumberRef)cf_vendor, kCFNumberIntType, &vid) &&
+								CFNumberGetValue((CFNumberRef)cf_product, kCFNumberIntType, &pid)) {
+								port_info.id_vendor = vid;
+								port_info.id_product = pid;
+							}
+						}
+						if (cf_vendor) { CFRelease(cf_vendor); }
+						if (cf_product) { CFRelease(cf_product); }
+
+						output.emplace_back(std::move(port_info));
+					}
+				}
+				IOObjectRelease(port);
+			}
+		}
+	}
+#else
+    // UNIX / Linux
+    std::initializer_list<const char*> prefixes { "ttyUSB" , "ttyACM", "tty.", "cu.", "rfcomm" };
+    for (auto &dir_entry : boost::filesystem::directory_iterator(boost::filesystem::path("/dev"))) {
+        std::string name = dir_entry.path().filename().string();
+        for (const char *prefix : prefixes) {
+            if (boost::starts_with(name, prefix)) {
+                const auto path = dir_entry.path().string();
+                SerialPortInfo spi;
+                spi.port = path;
+#ifdef __linux__
+				auto friendly_name = sysfs_tty_prop(name, "product");
+				if (friendly_name) {
+					spi.is_printer = looks_like_printer(*friendly_name);
+					spi.friendly_name = (boost::format("%1% (%2%)") % *friendly_name % path).str();
+				} else {
+					spi.friendly_name = path;
+				}
+				auto vid = sysfs_tty_prop_hex(name, "idVendor");
+				auto pid = sysfs_tty_prop_hex(name, "idProduct");
+				if (vid && pid) {
+					spi.id_vendor = *vid;
+					spi.id_product = *pid;
+				}
+#else
+                spi.friendly_name = path;
+#endif
+                output.emplace_back(std::move(spi));
+                break;
+            }
+        }
+    }
+#endif
+
+    output.erase(std::remove_if(output.begin(), output.end(), 
+        [](const SerialPortInfo &info) {
+            return boost::starts_with(info.port, "Bluetooth") || boost::starts_with(info.port, "FireFly"); 
+        }),
+        output.end());
+    return output;
+}
+
+std::vector<std::string> scan_serial_ports()
+{
+	std::vector<SerialPortInfo> ports = scan_serial_ports_extended();
+	std::vector<std::string> output;
+	output.reserve(ports.size());
+	for (const SerialPortInfo &spi : ports)
+		output.emplace_back(std::move(spi.port));
+	return output;
+}
+
+
+
+// Class Serial
+
+namespace asio = boost::asio;
+using boost::system::error_code;
+
+Serial::Serial(asio::io_service& io_service) :
+	asio::serial_port(io_service)
+{}
+
+Serial::Serial(asio::io_service& io_service, const std::string &name, unsigned baud_rate) :
+	asio::serial_port(io_service, name)
+{
+	set_baud_rate(baud_rate);
+}
+
+Serial::~Serial() {}
+
+void Serial::set_baud_rate(unsigned baud_rate)
+{
+	try {
+		// This does not support speeds > 115200
+		set_option(boost::asio::serial_port_base::baud_rate(baud_rate));
+	} catch (boost::system::system_error &) {
+		auto handle = native_handle();
+
+		auto handle_errno = [](int retval) {
+			if (retval != 0) {
+				throw std::runtime_error(
+					(boost::format("Could not set baud rate: %1%") % strerror(errno)).str()
+				);
+			}
+		};
+
+#if __APPLE__
+		termios ios;
+		handle_errno(::tcgetattr(handle, &ios));
+		handle_errno(::cfsetspeed(&ios, baud_rate));
+		speed_t newSpeed = baud_rate;
+		handle_errno(::ioctl(handle, IOSSIOSPEED, &newSpeed));
+		handle_errno(::tcsetattr(handle, TCSANOW, &ios));
+#elif __linux
+
+		/* The following definitions are kindly borrowed from:
+			/usr/include/asm-generic/termbits.h
+			Unfortunately we cannot just include that one because
+			it would redefine the "struct termios" already defined
+			the <termios.h> already included by Boost.ASIO. */
+#define K_NCCS 19
+		struct termios2 {
+			tcflag_t c_iflag;
+			tcflag_t c_oflag;
+			tcflag_t c_cflag;
+			tcflag_t c_lflag;
+			cc_t c_line;
+			cc_t c_cc[K_NCCS];
+			speed_t c_ispeed;
+			speed_t c_ospeed;
+		};
+#define BOTHER CBAUDEX
+
+		termios2 ios;
+		handle_errno(::ioctl(handle, TCGETS2, &ios));
+		ios.c_ispeed = ios.c_ospeed = baud_rate;
+		ios.c_cflag &= ~CBAUD;
+		ios.c_cflag |= BOTHER | CLOCAL | CREAD;
+		ios.c_cc[VMIN] = 1; // Minimum of characters to read, prevents eof errors when 0 bytes are read
+		ios.c_cc[VTIME] = 1;
+		handle_errno(::ioctl(handle, TCSETS2, &ios));
+
+#elif __OpenBSD__
+		struct termios ios;
+		handle_errno(::tcgetattr(handle, &ios));
+		handle_errno(::cfsetspeed(&ios, baud_rate));
+		handle_errno(::tcsetattr(handle, TCSAFLUSH, &ios));
+#else
+		throw std::runtime_error("Custom baud rates are not currently supported on this OS");
+#endif
+	}
+}
+
+void Serial::set_DTR(bool on)
+{
+	auto handle = native_handle();
+#if defined(_WIN32) && !defined(__SYMBIAN32__)
+	if (! EscapeCommFunction(handle, on ? SETDTR : CLRDTR)) {
+		throw std::runtime_error("Could not set serial port DTR");
+	}
+#else
+	int status;
+	if (::ioctl(handle, TIOCMGET, &status) == 0) {
+		on ? status |= TIOCM_DTR : status &= ~TIOCM_DTR;
+		if (::ioctl(handle, TIOCMSET, &status) == 0) {
+			return;
+		}
+	}
+
+	throw std::runtime_error(
+		(boost::format("Could not set serial port DTR: %1%") % strerror(errno)).str()
+	);
+#endif
+}
+
+void Serial::reset_line_num()
+{
+	// See https://github.com/MarlinFirmware/Marlin/wiki/M110
+	write_string("M110 N0\n");
+	m_line_num = 0;
+}
+
+bool Serial::read_line(unsigned timeout, std::string &line, error_code &ec)
+{
+	auto &io_service = get_io_service();
+	asio::deadline_timer timer(io_service);
+	char c = 0;
+	bool fail = false;
+
+	while (true) {
+		io_service.reset();
+
+		asio::async_read(*this, boost::asio::buffer(&c, 1), [&](const error_code &read_ec, size_t size) {
+			if (ec || size == 0) {
+				fail = true;
+				ec = read_ec;   // FIXME: only if operation not aborted
+			}
+			timer.cancel();   // FIXME: ditto
+		});
+
+		if (timeout > 0) {
+			timer.expires_from_now(boost::posix_time::milliseconds(timeout));
+			timer.async_wait([&](const error_code &ec) {
+				// Ignore timer aborts
+				if (!ec) {
+					fail = true;
+					this->cancel();
+				}
+			});
+		}
+
+		io_service.run();
+
+		if (fail) {
+			return false;
+		} else if (c != '\n') {
+			line += c;
+		} else {
+			return true;
+		}
+	}
+}
+
+void Serial::printer_setup()
+{
+	printer_reset();
+	write_string("\r\r\r\r\r\r\r\r\r\r");    // Gets rid of line noise, if any
+}
+
+size_t Serial::write_string(const std::string &str)
+{
+	// TODO: might be wise to timeout here as well
+	return asio::write(*this, asio::buffer(str));
+}
+
+bool Serial::printer_ready_wait(unsigned retries, unsigned timeout)
+{
+	std::string line;
+	error_code ec;
+
+	for (; retries > 0; retries--) {
+		reset_line_num();
+
+		while (read_line(timeout, line, ec)) {
+			if (line == "ok") {
+				return true;
+			}
+			line.clear();
+		}
+
+		line.clear();
+	}
+
+	return false;
+}
+
+size_t Serial::printer_write_line(const std::string &line, unsigned line_num)
+{
+	const auto formatted_line = Utils::Serial::printer_format_line(line, line_num);
+	return write_string(formatted_line);
+}
+
+size_t Serial::printer_write_line(const std::string &line)
+{
+	m_line_num++;
+	return printer_write_line(line, m_line_num);
+}
+
+void Serial::printer_reset()
+{
+	this->set_DTR(false);
+	std::this_thread::sleep_for(std::chrono::milliseconds(200));
+	this->set_DTR(true);
+	std::this_thread::sleep_for(std::chrono::milliseconds(200));
+	this->set_DTR(false);
+	std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+}
+
+std::string Serial::printer_format_line(const std::string &line, unsigned line_num)
+{
+	const auto line_num_str = std::to_string(line_num);
+
+	unsigned checksum = 'N';
+	for (auto c : line_num_str) { checksum ^= c; }
+	checksum ^= ' ';
+	for (auto c : line) { checksum ^= c; }
+
+	return (boost::format("N%1% %2%*%3%\n") % line_num_str % line % checksum).str();
+}
+
+
+} // namespace Utils
+} // namespace Slic3r

src/slic3r/Utils/Serial.hpp

@@ -0,0 +1,82 @@
+#ifndef slic3r_GUI_Utils_Serial_hpp_
+#define slic3r_GUI_Utils_Serial_hpp_
+
+#include <vector>
+#include <string>
+#include <boost/system/error_code.hpp>
+#include <boost/asio.hpp>
+
+
+namespace Slic3r {
+namespace Utils {
+
+struct SerialPortInfo {
+	std::string port;
+	unsigned    id_vendor = -1;
+	unsigned    id_product = -1;
+	std::string friendly_name;
+	bool        is_printer = false;
+
+	bool id_match(unsigned id_vendor, unsigned id_product) const { return id_vendor == this->id_vendor && id_product == this->id_product; }
+};
+
+inline bool operator==(const SerialPortInfo &sp1, const SerialPortInfo &sp2)
+{
+	return
+		sp1.port       == sp2.port       &&
+		sp1.id_vendor  == sp2.id_vendor  &&
+		sp1.id_product == sp2.id_product &&
+		sp1.is_printer == sp2.is_printer;
+}
+
+extern std::vector<std::string> 	scan_serial_ports();
+extern std::vector<SerialPortInfo> 	scan_serial_ports_extended();
+
+
+class Serial : public boost::asio::serial_port
+{
+public:
+	Serial(boost::asio::io_service &io_service);
+	Serial(boost::asio::io_service &io_service, const std::string &name, unsigned baud_rate);
+	Serial(const Serial &) = delete;
+	Serial &operator=(const Serial &) = delete;
+	~Serial();
+
+	void set_baud_rate(unsigned baud_rate);
+	void set_DTR(bool on);
+
+	// Resets the line number both internally as well as with the firmware using M110
+	void reset_line_num();
+
+	// Reads a line or times out, the timeout is in milliseconds
+	bool read_line(unsigned timeout, std::string &line, boost::system::error_code &ec);
+
+	// Perform an initial setup for communicating with a printer
+	void printer_setup();
+
+	// Write data from a string
+	size_t write_string(const std::string &str);
+
+	// Attempts to reset the line numer and waits until the printer says "ok"
+	bool printer_ready_wait(unsigned retries, unsigned timeout);
+
+	// Write Marlin-formatted line, with a line number and a checksum
+	size_t printer_write_line(const std::string &line, unsigned line_num);
+
+	// Same as above, but with internally-managed line number
+	size_t printer_write_line(const std::string &line);
+	
+	// Toggles DTR to reset the printer
+	void printer_reset();
+
+	// Formats a line Marlin-style, ie. with a sequential number and a checksum
+	static std::string printer_format_line(const std::string &line, unsigned line_num);
+private:
+	unsigned m_line_num = 0;
+};
+
+
+} // Utils
+} // Slic3r
+
+#endif /* slic3r_GUI_Utils_Serial_hpp_ */

src/slic3r/Utils/Time.cpp

@@ -0,0 +1,80 @@
+#include "Time.hpp"
+
+#ifdef WIN32
+	#define WIN32_LEAN_AND_MEAN
+	#include <windows.h>
+	#undef WIN32_LEAN_AND_MEAN
+#endif /* WIN32 */
+
+namespace Slic3r {
+namespace Utils {
+
+time_t parse_time_ISO8601Z(const std::string &sdate)
+{
+	int y, M, d, h, m, s;
+	if (sscanf(sdate.c_str(), "%04d%02d%02dT%02d%02d%02dZ", &y, &M, &d, &h, &m, &s) != 6)
+        return (time_t)-1;
+	struct tm tms;
+    tms.tm_year = y - 1900;  // Year since 1900
+	tms.tm_mon  = M - 1;     // 0-11
+	tms.tm_mday = d;         // 1-31
+	tms.tm_hour = h;         // 0-23
+	tms.tm_min  = m;         // 0-59
+	tms.tm_sec  = s;         // 0-61 (0-60 in C++11)
+	return mktime(&tms);
+}
+
+std::string format_time_ISO8601Z(time_t time)
+{
+	struct tm tms;
+#ifdef WIN32
+	gmtime_s(&tms, &time);
+#else
+	gmtime_r(&time, &tms);
+#endif
+	char buf[128];
+	sprintf(buf, "%04d%02d%02dT%02d%02d%02dZ",
+    	tms.tm_year + 1900,
+		tms.tm_mon + 1,
+		tms.tm_mday,
+		tms.tm_hour,
+		tms.tm_min,
+		tms.tm_sec);
+	return buf;
+}
+
+std::string format_local_date_time(time_t time)
+{
+	struct tm tms;
+#ifdef WIN32
+	localtime_s(&tms, &time);
+#else
+	localtime_r(&time, &tms);
+#endif
+    char buf[80];
+ 	strftime(buf, 80, "%x %X", &tms);
+    return buf;
+}
+
+time_t get_current_time_utc()
+{
+#ifdef WIN32
+	SYSTEMTIME st;
+	::GetSystemTime(&st);
+	std::tm tm;
+	tm.tm_sec   = st.wSecond;
+	tm.tm_min   = st.wMinute;
+	tm.tm_hour  = st.wHour;
+	tm.tm_mday  = st.wDay;
+	tm.tm_mon   = st.wMonth - 1;
+	tm.tm_year  = st.wYear - 1900;
+	tm.tm_isdst = -1;
+	return mktime(&tm);
+#else
+	const time_t current_local = time(nullptr);
+	return mktime(gmtime(&current_local));
+#endif
+}
+
+}; // namespace Utils
+}; // namespace Slic3r

src/slic3r/Utils/Time.hpp

@@ -0,0 +1,25 @@
+#ifndef slic3r_Utils_Time_hpp_
+#define slic3r_Utils_Time_hpp_
+
+#include <string>
+#include <time.h>
+
+namespace Slic3r {
+namespace Utils {
+
+// Utilities to convert an UTC time_t to/from an ISO8601 time format,
+// useful for putting timestamps into file and directory names.
+// Returns (time_t)-1 on error.
+extern time_t parse_time_ISO8601Z(const std::string &s);
+extern std::string format_time_ISO8601Z(time_t time);
+
+// Format the date and time from an UTC time according to the active locales and a local time zone.
+extern std::string format_local_date_time(time_t time);
+
+// There is no gmtime() on windows.
+extern time_t get_current_time_utc();
+
+}; // namespace Utils
+}; // namespace Slic3r
+
+#endif /* slic3r_Utils_Time_hpp_ */