Slic3r::anonymous_namespace{Flashforge.cpp} Namespace Reference

Functions
std::string	trim_null_terminated_ascii (const char *data, size_t len)
bool	parse_discovery_response (const std::vector< unsigned char > &response, const std::string &ip_address, FlashforgeDiscoveredPrinter &printer)
std::vector< std::string >	get_discovery_broadcast_addresses ()
std::string	safe_config_string (DynamicPrintConfig *config, const char *key)
bool	try_parse_json_int (const json &value, int &out)
bool	validate_local_api_response (const std::string &response_body, wxString &error_msg)
std::string	sanitize_flashforge_filename (const std::string &filename, const std::string &fallback_extension={})

Variables
constexpr unsigned short	FLASHFORGE_DISCOVERY_PORT = 48899
constexpr unsigned short	FLASHFORGE_DISCOVERY_LISTEN_PORT = 18007
const std::array< unsigned char, 20 >	FLASHFORGE_DISCOVERY_MESSAGE

Function Documentation

get_discovery_broadcast_addresses()

std::vector< std::string > Slic3r::anonymous_namespace{Flashforge.cpp}::get_discovery_broadcast_addresses

(

)

{
    std::set<std::string> addresses = {"255.255.255.255", "192.168.0.255", "192.168.1.255"};
 
    try {
        boost::asio::io_context          io_context;
        boost::asio::ip::tcp::resolver   resolver(io_context);
        boost::system::error_code        ec;
        const auto                       host_name = boost::asio::ip::host_name(ec);
        if (!ec) {
            const auto results = resolver.resolve(boost::asio::ip::tcp::v4(), host_name, "", ec);
            if (!ec) {
                for (const auto& entry : results) {
                    const auto addr = entry.endpoint().address();
                    if (!addr.is_v4())
                        continue;
 
                    const auto bytes = addr.to_v4().to_bytes();
                    if (bytes[0] == 127)
                        continue;
 
                    addresses.insert((boost::format("%1%.%2%.%3%.255") % static_cast<int>(bytes[0]) % static_cast<int>(bytes[1]) % static_cast<int>(bytes[2])).str());
                }
            }
        }
    } catch (...) {
    }
 
    return {addresses.begin(), addresses.end()};
}

References get_discovery_broadcast_addresses().

Referenced by get_discovery_broadcast_addresses().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_discovery_response()

bool Slic3r::anonymous_namespace{Flashforge.cpp}::parse_discovery_response	(	const std::vector< unsigned char > &	response,
		const std::string &	ip_address,
		FlashforgeDiscoveredPrinter &	printer )

{
    if (response.size() < 0xC4)
        return false;
 
    printer.name          = trim_null_terminated_ascii(reinterpret_cast<const char*>(response.data()), 32);
    printer.serial_number = trim_null_terminated_ascii(reinterpret_cast<const char*>(response.data() + 0x92), 32);
    printer.ip_address    = ip_address;
    return !(printer.name.empty() && printer.serial_number.empty());
}

References Slic3r::FlashforgeDiscoveredPrinter::ip_address, Slic3r::FlashforgeDiscoveredPrinter::name, parse_discovery_response(), Slic3r::FlashforgeDiscoveredPrinter::serial_number, and trim_null_terminated_ascii().

Referenced by parse_discovery_response().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_config_string()

std::string Slic3r::anonymous_namespace{Flashforge.cpp}::safe_config_string	(	DynamicPrintConfig *	config,
		const char *	key )

{
    if (config == nullptr)
        return {};
 
    if (const auto* opt = config->option<ConfigOptionString>(key); opt != nullptr)
        return opt->value;
 
    return {};
}

References Slic3r::ConfigBase::option(), and safe_config_string().

Referenced by safe_config_string().

Here is the call graph for this function:

Here is the caller graph for this function:

sanitize_flashforge_filename()

std::string Slic3r::anonymous_namespace{Flashforge.cpp}::sanitize_flashforge_filename	(	const std::string &	filename,
		const std::string &	fallback_extension = {} )

                                                                                                        {})
{
    std::string basename = fs::path(filename).filename().string();
    if (basename.empty()) {
        basename = "print";
        if (!fallback_extension.empty())
            basename += fallback_extension;
    }
 
    for (char& ch : basename) {
        const bool is_ascii_alnum = (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');
        if (!is_ascii_alnum && ch != '.' && ch != '_' && ch != '-') {
            ch = '_';
        }
    }
 
    return basename;
}

References sanitize_flashforge_filename().

Referenced by sanitize_flashforge_filename().

Here is the call graph for this function:

Here is the caller graph for this function:

trim_null_terminated_ascii()

std::string Slic3r::anonymous_namespace{Flashforge.cpp}::trim_null_terminated_ascii	(	const char *	data,
		size_t	len )

{
    std::string out(data, data + len);
    const auto  pos = out.find('\0');
    if (pos != std::string::npos)
        out.resize(pos);
    boost::trim(out);
    return out;
}

References trim_null_terminated_ascii().

Referenced by parse_discovery_response(), and trim_null_terminated_ascii().

Here is the call graph for this function:

Here is the caller graph for this function:

try_parse_json_int()

bool Slic3r::anonymous_namespace{Flashforge.cpp}::try_parse_json_int	(	const json &	value,
		int &	out )

{
    try {
        if (value.is_number_integer() || value.is_number_unsigned()) {
            out = value.get<int>();
            return true;
        }
 
        if (value.is_boolean()) {
            out = value.get<bool>() ? 1 : 0;
            return true;
        }
 
        if (value.is_string()) {
            std::string text = value.get<std::string>();
            boost::trim(text);
            if (text.empty())
                return false;
 
            size_t pos = 0;
            const long parsed = std::stol(text, &pos, 10);
            if (pos == text.size()) {
                out = static_cast<int>(parsed);
                return true;
            }
        }
    } catch (...) {
    }
 
    return false;
}

References try_parse_json_int().

Referenced by try_parse_json_int(), and validate_local_api_response().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_local_api_response()

bool Slic3r::anonymous_namespace{Flashforge.cpp}::validate_local_api_response	(	const std::string &	response_body,
		wxString &	error_msg )

{
    const auto parsed = json::parse(response_body, nullptr, false, true);
    if (parsed.is_discarded() || !parsed.is_object()) {
        error_msg = _(L("Flashforge returned an invalid JSON response."));
        return false;
    }
 
    int  result_code = 0;
    bool has_code    = false;
 
    if (parsed.contains("code"))
        has_code = try_parse_json_int(parsed["code"], result_code);
    if (!has_code && parsed.contains("err"))
        has_code = try_parse_json_int(parsed["err"], result_code);
 
    if (has_code && result_code != 0) {
        std::string message;
        if (parsed.contains("message") && parsed["message"].is_string())
            message = parsed["message"].get<std::string>();
        else if (parsed.contains("msg") && parsed["msg"].is_string())
            message = parsed["msg"].get<std::string>();
 
        if (message.empty())
            message = _u8L("Request failed");
 
        // TRN %1% is the error code returned by the printer, %2% its error message.
        error_msg = GUI::from_u8((boost::format(_u8L("Flashforge local API error %1%: %2%")) % result_code % message).str());
        return false;
    }
 
    return true;
}

References _, _u8L, Slic3r::GUI::from_u8(), L, try_parse_json_int(), and validate_local_api_response().

Referenced by validate_local_api_response().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

FLASHFORGE_DISCOVERY_LISTEN_PORT

unsigned short Slic3r::anonymous_namespace{Flashforge.cpp}::FLASHFORGE_DISCOVERY_LISTEN_PORT = 18007

constexpr

FLASHFORGE_DISCOVERY_MESSAGE

const std::array<unsigned char, 20> Slic3r::anonymous_namespace{Flashforge.cpp}::FLASHFORGE_DISCOVERY_MESSAGE

Initial value:

= {
    0x77, 0x77, 0x77, 0x2e, 0x75, 0x73, 0x72, 0x22,
    0x65, 0x36, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00
}

                                                                 {
    0x77, 0x77, 0x77, 0x2e, 0x75, 0x73, 0x72, 0x22,
    0x65, 0x36, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00
};

FLASHFORGE_DISCOVERY_PORT

unsigned short Slic3r::anonymous_namespace{Flashforge.cpp}::FLASHFORGE_DISCOVERY_PORT = 48899

constexpr