[Fix] Deal with fmtlib exceptions properly

src/client/rspamc.cxx

 	}
 };
 
+template<typename... T>
+static inline void rspamc_print(std::FILE *f, fmt::format_string<T...> fmt, T &&...args)
+{
+	static auto try_print_exception = 1;
+	try {
+		fmt::print(f, fmt, std::forward<T>(args)...);
+	} catch (const fmt::format_error &err) {
+		if (try_print_exception) {
+			if (fprintf(f, "Format error: %s\n", err.what()) < 0) {
+				try_print_exception = 0;
+			}
+		}
+	} catch (std::system_error &err) {
+		if (try_print_exception) {
+			if (fprintf(f, "System error: %s\n", err.what()) < 0) {
+				try_print_exception = 0;
+			}
+		}
+	} catch (...) {
+		if (try_print_exception) {
+			if (fprintf(f, "Unknown format error\n") < 0) {
+				try_print_exception = 0;
+			}
+		}
+	}
+}
+
 using sort_lambda = std::function<int(const ucl_object_t *, const ucl_object_t *)>;
 static const auto sort_map = frozen::make_unordered_map<frozen::string, sort_lambda>({
 	{"name", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
 		processed_passwd.resize(plen, '\0');
 		plen = rspamd_read_passphrase(processed_passwd.data(), plen, 0, nullptr);
 		if (plen == 0) {
-			fmt::print(stderr, "Invalid password\n");
+			rspamc_print(stderr, "Invalid password\n");
 			exit(EXIT_FAILURE);
 		}
 		processed_passwd.resize(plen);
 
 	/* Parse options */
 	if (!g_option_context_parse(context, argc, argv, &error)) {
-		fmt::print(stderr, "option parsing failed: {}\n", error->message);
+		rspamc_print(stderr, "option parsing failed: {}\n", error->message);
 		g_option_context_free(context);
 		exit(EXIT_FAILURE);
 	}
 {
 	guint cmd_len = 0;
 
-	fmt::print(stdout, "Rspamc commands summary:\n");
+	rspamc_print(stdout, "Rspamc commands summary:\n");
 
 	for (const auto &cmd: rspamc_commands) {
 		auto clen = strlen(cmd.name);
 	}
 
 	for (const auto &cmd: rspamc_commands) {
-		fmt::print(stdout,
-				   "  {:>{}} ({:7}{:1})\t{}\n",
-				   cmd.name,
-				   cmd_len,
-				   cmd.is_controller ? "control" : "normal",
-				   cmd.is_privileged ? "*" : "",
-				   cmd.description);
-	}
-
-	fmt::print(stdout,
-			   "\n* is for privileged commands that may need password (see -P option)\n");
-	fmt::print(stdout,
-			   "control commands use port 11334 while normal use 11333 by default (see -h option)\n");
+		rspamc_print(stdout,
+					 "  {:>{}} ({:7}{:1})\t{}\n",
+					 cmd.name,
+					 cmd_len,
+					 cmd.is_controller ? "control" : "normal",
+					 cmd.is_privileged ? "*" : "",
+					 cmd.description);
+	}
+
+	rspamc_print(stdout,
+				 "\n* is for privileged commands that may need password (see -P option)\n");
+	rspamc_print(stdout,
+				 "control commands use port 11334 while normal use 11333 by default (see -h option)\n");
 }
 
 static void
 				freeaddrinfo(res);
 			}
 			else {
-				fmt::print(stderr, "address resolution for {} failed: {}\n",
-						   ip,
-						   gai_strerror(r));
+				rspamc_print(stderr, "address resolution for {} failed: {}\n",
+							 ip,
+							 gai_strerror(r));
 			}
 		}
 		else {
 			}
 		}
 		if (indent && pos) {
-			fmt::print(out, "{:>{}}", " ", indent);
+			rspamc_print(out, "{:>{}}", " ", indent);
 		}
-		fmt::print(out, "{}\n", s);
+		rspamc_print(out, "{}\n", s);
 		pos = line.find_first_not_of(whitespace, pos + s.size());//skip leading whitespace
 	}
 }
 {
 	auto first = true;
 
-	fmt::print(out, "Symbol: {} ", ucl_object_key(obj));
+	rspamc_print(out, "Symbol: {} ", ucl_object_key(obj));
 	const auto *val = ucl_object_lookup(obj, "score");
 
 	if (val != nullptr) {
-		fmt::print(out, "({:.2f})", ucl_object_todouble(val));
+		rspamc_print(out, "({:.2f})", ucl_object_todouble(val));
 	}
 	val = ucl_object_lookup(obj, "options");
 	if (val != nullptr && ucl_object_type(val) == UCL_ARRAY) {
 		ucl_object_iter_t it = nullptr;
 		const ucl_object_t *cur;
 
-		fmt::print(out, "[");
+		rspamc_print(out, "[");
 
 		while ((cur = ucl_object_iterate(val, &it, true)) != nullptr) {
 			if (first) {
-				fmt::print(out, "{}", ucl_object_tostring(cur));
+				rspamc_print(out, "{}", ucl_object_tostring(cur));
 				first = false;
 			}
 			else {
-				fmt::print(out, ", {}", ucl_object_tostring(cur));
+				rspamc_print(out, ", {}", ucl_object_tostring(cur));
 			}
 		}
-		fmt::print(out, "]");
+		rspamc_print(out, "]");
 	}
-	fmt::print(out, "\n");
+	rspamc_print(out, "\n");
 }
 
 static void
 		auto *elt = ucl_object_lookup(obj, ucl_name);
 		if (elt) {
 			if (humanreport) {
-				fmt::print(out, ",{}={}", output_message, emphasis_argument(ucl_object_tostring(elt)));
+				rspamc_print(out, ",{}={}", output_message, emphasis_argument(ucl_object_tostring(elt)));
 			}
 			else {
-				fmt::print(out, "{}: {}\n", output_message, emphasis_argument(ucl_object_tostring(elt)));
+				rspamc_print(out, "{}: {}\n", output_message, emphasis_argument(ucl_object_tostring(elt)));
 			}
 		}
 	};
 
 	if (!humanreport) {
-		fmt::print(out, "[Metric: default]\n");
+		rspamc_print(out, "[Metric: default]\n");
 	}
 
 	const auto *elt = ucl_object_lookup(obj, "required_score");
 
 
 	if (humanreport) {
-		fmt::print(out,
-				   "{}/{}/{}/{}",
-				   emphasis_argument(score, 2),
-				   emphasis_argument(greylist_score, 2),
-				   emphasis_argument(addheader_score, 2),
-				   emphasis_argument(required_score, 2));
+		rspamc_print(out,
+					 "{}/{}/{}/{}",
+					 emphasis_argument(score, 2),
+					 emphasis_argument(greylist_score, 2),
+					 emphasis_argument(addheader_score, 2),
+					 emphasis_argument(required_score, 2));
 	}
 
 	elt = ucl_object_lookup(obj, "action");
 		if (act.has_value()) {
 			if (!tty) {
 				if (humanreport) {
-					fmt::print(out, ",action={}:{}", act.value(), ucl_object_tostring(elt));
+					rspamc_print(out, ",action={}:{}", act.value(), ucl_object_tostring(elt));
 				}
 				else {
 					print_protocol_string("action", "Action");
 				}
 
 				if (humanreport) {
-					fmt::print(out, ",action={}:{}", act.value(), colorized_action);
+					rspamc_print(out, ",action={}:{}", act.value(), colorized_action);
 				}
 				else {
-					fmt::print(out, "Action: {}\n", colorized_action);
+					rspamc_print(out, "Action: {}\n", colorized_action);
 				}
 			}
 
 			is_spam = act.value() < METRIC_ACTION_GREYLIST ? true : false;
 			if (!humanreport) {
-				fmt::print(out, "Spam: {}\n", is_spam ? "true" : "false");
+				rspamc_print(out, "Spam: {}\n", is_spam ? "true" : "false");
 			}
 		}
 		else {
 			if (humanreport) {
-				fmt::print(out, ",action={}:{}", METRIC_ACTION_NOACTION, ucl_object_tostring(elt));
+				rspamc_print(out, ",action={}:{}", METRIC_ACTION_NOACTION, ucl_object_tostring(elt));
 			}
 			else {
 				print_protocol_string("action", "Action");
 			is_skipped = 1;
 		}
 
-		fmt::print(out, ",spam={},skipped={}\n", is_spam ? 1 : 0, is_skipped);
+		rspamc_print(out, ",spam={},skipped={}\n", is_spam ? 1 : 0, is_skipped);
 	}
 	else if (got_scores == 2) {
-		fmt::print(out,
-				   "Score: {} / {}\n",
-				   emphasis_argument(score, 2),
-				   emphasis_argument(required_score, 2));
+		rspamc_print(out,
+					 "Score: {} / {}\n",
+					 emphasis_argument(score, 2),
+					 emphasis_argument(required_score, 2));
 	}
 
 	if (humanreport) {
-		fmt::print(out, "Content analysis details:   ({} points, {} required)\n\n",
-				   emphasis_argument(score, 2),
-				   emphasis_argument(addheader_score, 2));
-		fmt::print(out, " pts rule name              description\n");
-		fmt::print(out, "---- ---------------------- --------------------------------------------------\n");
+		rspamc_print(out, "Content analysis details:   ({} points, {} required)\n\n",
+					 emphasis_argument(score, 2),
+					 emphasis_argument(addheader_score, 2));
+		rspamc_print(out, " pts rule name              description\n");
+		rspamc_print(out, "---- ---------------------- --------------------------------------------------\n");
 	}
 
 	elt = ucl_object_lookup(obj, "symbols");
 		}
 	}
 	if (humanreport) {
-		fmt::print(out, "\n");
+		rspamc_print(out, "\n");
 	}
 }
 
 					 });
 
 	for (const auto *cur_elt: ar) {
-		fmt::print(out, "\t{}: {:3} usec\n",
-				   ucl_object_key(cur_elt), ucl_object_todouble(cur_elt));
+		rspamc_print(out, "\t{}: {:3} usec\n",
+					 ucl_object_key(cur_elt), ucl_object_todouble(cur_elt));
 	}
 }
 
 	auto print_protocol_string = [&](const char *ucl_name, const char *output_message) {
 		auto *elt = ucl_object_lookup(obj, ucl_name);
 		if (elt) {
-			fmt::print(out, "{}: {}\n", output_message, ucl_object_tostring(elt));
+			rspamc_print(out, "{}: {}\n", output_message, ucl_object_tostring(elt));
 		}
 	};
 
 			}
 		}
 		else {
-			fmt::print(out, "Urls: {}\n", emitted);
+			rspamc_print(out, "Urls: {}\n", emitted);
 		}
 		free(emitted);
 	}
 			}
 		}
 		else {
-			fmt::print(out, "Emails: {}\n", emitted);
+			rspamc_print(out, "Emails: {}\n", emitted);
 		}
 		free(emitted);
 	}
 
 		while ((cmesg = ucl_object_iterate(elt, &mit, true)) != nullptr) {
 			if (ucl_object_type(cmesg) == UCL_STRING) {
-				fmt::print(out, "Message - {}: {}\n",
-						   ucl_object_key(cmesg), ucl_object_tostring(cmesg));
+				rspamc_print(out, "Message - {}: {}\n",
+							 ucl_object_key(cmesg), ucl_object_tostring(cmesg));
 			}
 			else {
 				char *rendered_message;
 				rendered_message = (char *) ucl_object_emit(cmesg, UCL_EMIT_JSON_COMPACT);
-				fmt::print(out, "Message - {}: {:.60}\n",
-						   ucl_object_key(cmesg), rendered_message);
+				rspamc_print(out, "Message - {}: {:.60}\n",
+							 ucl_object_key(cmesg), rendered_message);
 				free(rendered_message);
 			}
 		}
 
 	elt = ucl_object_lookup(obj, "dkim-signature");
 	if (elt && elt->type == UCL_STRING) {
-		fmt::print(out, "DKIM-Signature: {}\n", ucl_object_tostring(elt));
+		rspamc_print(out, "DKIM-Signature: {}\n", ucl_object_tostring(elt));
 	}
 	else if (elt && elt->type == UCL_ARRAY) {
 		ucl_object_iter_t it = nullptr;
 		const ucl_object_t *cur;
 
 		while ((cur = ucl_object_iterate(elt, &it, true)) != nullptr) {
-			fmt::print(out, "DKIM-Signature: {}\n", ucl_object_tostring(cur));
+			rspamc_print(out, "DKIM-Signature: {}\n", ucl_object_tostring(cur));
 		}
 	}
 
 	elt = ucl_object_lookup(obj, "profile");
 
 	if (elt) {
-		fmt::print(out, "Profile data:\n");
+		rspamc_print(out, "Profile data:\n");
 		rspamc_profile_output(out, elt);
 	}
 }
 
 	const auto *elt = ucl_object_lookup(obj, "version");
 	if (elt != nullptr) {
-		fmt::print(out, "Rspamd version: {}\n", ucl_object_tostring(elt));
+		rspamc_print(out, "Rspamd version: {}\n", ucl_object_tostring(elt));
 	}
 
 	elt = ucl_object_lookup(obj, "uptime");
 	if (elt != nullptr) {
-		fmt::print("Uptime: ");
+		rspamc_print(out, "Uptime: ");
 		seconds = ucl_object_toint(elt);
 		if (seconds >= 2 * 3600) {
 			days = seconds / 86400;
 			hours = seconds / 3600 - days * 24;
 			minutes = seconds / 60 - hours * 60 - days * 1440;
-			fmt::print("{} day{} {} hour{} {} minute{}\n", days,
-					   days > 1 ? "s" : "", hours, hours > 1 ? "s" : "",
-					   minutes, minutes > 1 ? "s" : "");
+			rspamc_print(out, "{} day{} {} hour{} {} minute{}\n", days,
+						 days > 1 ? "s" : "", hours, hours > 1 ? "s" : "",
+						 minutes, minutes > 1 ? "s" : "");
 		}
 		/* If uptime is less than 1 minute print only seconds */
 		else if (seconds / 60 == 0) {
-			fmt::print("{} second{}\n", seconds,
-					   seconds > 1 ? "s" : "");
+			rspamc_print(out, "{} second{}\n", seconds,
+						 seconds > 1 ? "s" : "");
 		}
 		/* Else print the minutes and seconds. */
 		else {
 			hours = seconds / 3600;
 			minutes = seconds / 60 - hours * 60;
 			seconds -= hours * 3600 + minutes * 60;
-			fmt::print("{} hour {} minute{} {} second{}\n", hours,
-					   minutes, minutes > 1 ? "s" : "",
-					   seconds, seconds > 1 ? "s" : "");
+			rspamc_print(out, "{} hour {} minute{} {} second{}\n", hours,
+						 minutes, minutes > 1 ? "s" : "",
+						 seconds, seconds > 1 ? "s" : "");
 		}
 	}
 }
 rspamc_counters_output(FILE *out, ucl_object_t *obj)
 {
 	if (obj->type != UCL_ARRAY) {
-		fmt::print(out, "Bad output\n");
+		rspamc_print(out, "Bad output\n");
 		return;
 	}
 
 	memset(dash_buf, '-', dashes + max_len);
 	dash_buf[dashes + max_len] = '\0';
 
-	fmt::print(out, "Symbols cache\n");
-
-	fmt::print(out, " {} \n", emphasis_argument(dash_buf));
-	fmt::print(out,
-			   "| {:<4} | {:<{}} | {:^7} | {:^13} | {:^7} |\n",
-			   "Pri",
-			   "Symbol",
-			   max_len,
-			   "Weight",
-			   "Frequency",
-			   "Hits");
-	fmt::print(out, " {} \n", emphasis_argument(dash_buf));
-	fmt::print(out, "| {:<4} | {:<{}} | {:^7} | {:^13} | {:^7} |\n", "",
-			   "", max_len,
-			   "", "hits/min", "");
+	rspamc_print(out, "Symbols cache\n");
+
+	rspamc_print(out, " {} \n", emphasis_argument(dash_buf));
+	rspamc_print(out,
+				 "| {:<4} | {:<{}} | {:^7} | {:^13} | {:^7} |\n",
+				 "Pri",
+				 "Symbol",
+				 max_len,
+				 "Weight",
+				 "Frequency",
+				 "Hits");
+	rspamc_print(out, " {} \n", emphasis_argument(dash_buf));
+	rspamc_print(out, "| {:<4} | {:<{}} | {:^7} | {:^13} | {:^7} |\n", "",
+				 "", max_len,
+				 "", "hits/min", "");
 
 	for (const auto [i, cur]: rspamd::enumerate(counters_vec)) {
-		fmt::print(out, " {} \n", dash_buf);
+		rspamc_print(out, " {} \n", dash_buf);
 		const auto *sym = ucl_object_lookup(cur, "symbol");
 		const auto *weight = ucl_object_lookup(cur, "weight");
 		const auto *freq = ucl_object_lookup(cur, "frequency");
 				sym_name = ucl_object_tostring(sym);
 			}
 
-			fmt::print(out, "| {:<4} | {:<{}} | {:^7.1f} | {:^6.3f}({:^5.3f}) | {:^7} |\n", i,
-					   sym_name,
-					   max_len,
-					   ucl_object_todouble(weight),
-					   ucl_object_todouble(freq) * 60.0,
-					   ucl_object_todouble(freq_dev) * 60.0,
-					   (std::uintmax_t) ucl_object_toint(nhits));
+			rspamc_print(out, "| {:<4} | {:<{}} | {:^7.1f} | {:^6.3f}({:^5.3f}) | {:^7} |\n", i,
+						 sym_name,
+						 max_len,
+						 ucl_object_todouble(weight),
+						 ucl_object_todouble(freq) * 60.0,
+						 ucl_object_todouble(freq_dev) * 60.0,
+						 (std::uintmax_t) ucl_object_toint(nhits));
 		}
 	}
-	fmt::print(out, " {} \n", dash_buf);
+	rspamc_print(out, " {} \n", dash_buf);
 }
 
 static void
 	fmt::format_to(std::back_inserter(out_str), "Total learns: {}\n",
 				   ucl_object_toint(ucl_object_lookup(obj, "total_learns")));
 
-	fmt::print(out, "{}", out_str.c_str());
+	rspamc_print(out, "{}", out_str.c_str());
 }
 
 static void
 	struct rspamd_http_header *h;
 
 	kh_foreach_value(msg->headers, h, {
-		fmt::print(out, "{}: {}\n", std::string_view{h->name.begin, h->name.len},
-				   std::string_view{h->value.begin, h->value.len});
+		rspamc_print(out, "{}: {}\n", std::string_view{h->name.begin, h->name.len},
+					 std::string_view{h->value.begin, h->value.len});
 	});
 
-	fmt::print(out, "\n");
+	rspamc_print(out, "\n");
 }
 
 static void
 	auto headers_pos = rspamd_string_find_eoh(input, nullptr);
 
 	if (headers_pos == -1) {
-		fmt::print(stderr, "cannot find end of headers position");
+		rspamc_print(stderr, "cannot find end of headers position");
 		return;
 	}
 
 
 	/* Write message */
 	/* Original headers */
-	fmt::print(out, "{}", std::string_view{input->str, (std::size_t) headers_pos});
+	rspamc_print(out, "{}", std::string_view{input->str, (std::size_t) headers_pos});
 	/* Added headers */
-	fmt::print(out, "{}", added_headers);
+	rspamc_print(out, "{}", added_headers);
 	/* Message body */
-	fmt::print(out, "{}", input->str + headers_pos);
+	rspamc_print(out, "{}", input->str + headers_pos);
 }
 
 static void
 	GPid cld;
 
 	if (!g_shell_parse_argv(execute, &eargc, &eargv, &err)) {
-		fmt::print(stderr, "Cannot execute {}: {}", execute, err->message);
+		rspamc_print(stderr, "Cannot execute {}: {}", execute, err->message);
 		g_error_free(err);
 
 		return;
 								  static_cast<GSpawnFlags>(G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD), nullptr, nullptr, &cld,
 								  &infd, &outfd, &errfd, &exec_err)) {
 
-		fmt::print(stderr, "Cannot execute {}: {}", execute, exec_err->message);
+		rspamc_print(stderr, "Cannot execute {}: {}", execute, exec_err->message);
 		g_error_free(exec_err);
 
 		exit(EXIT_FAILURE);
 					ucl_out = (char *) ucl_object_emit(result,
 													   compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_CONFIG);
 				}
-				fmt::print(out, "{}", ucl_out);
+				rspamc_print(out, "{}", ucl_out);
 				free(ucl_out);
 			}
 			else {
 			ucl_object_unref(result);
 		}
 		else {
-			fmt::print(out, "{}\n", err->message);
+			rspamc_print(out, "{}\n", err->message);
 		}
 
 		fflush(out);
 		else {
 			if (cmd.need_input && !json) {
 				if (!compact && !humanreport) {
-					fmt::print(out, "Results for file: {} ({:.3} seconds)\n",
-							   emphasis_argument(cbdata->filename), diff);
+					rspamc_print(out, "Results for file: {} ({:.3} seconds)\n",
+								 emphasis_argument(cbdata->filename), diff);
 				}
 			}
 			else {
 				if (!compact && !json && !humanreport) {
-					fmt::print(out, "Results for command: {} ({:.3} seconds)\n",
-							   emphasis_argument(cmd.name), diff);
+					rspamc_print(out, "Results for command: {} ({:.3} seconds)\n",
+								 emphasis_argument(cmd.name), diff);
 				}
 			}
 
 														   compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_CONFIG);
 					}
 
-					fmt::print(out, "{}", ucl_out);
+					rspamc_print(out, "{}", ucl_out);
 					free(ucl_out);
 				}
 				else {
 				}
 
 				if (body) {
-					fmt::print(out, "\nNew body:\n{}\n",
-							   std::string_view{body, bodylen});
+					rspamc_print(out, "\nNew body:\n{}\n",
+								 std::string_view{body, bodylen});
 				}
 
 				ucl_object_unref(result);
 			}
 			else if (err != nullptr) {
-				fmt::print(out, "{}\n", err->message);
+				rspamc_print(out, "{}\n", err->message);
 
 				if (json && msg != nullptr) {
 					gsize rawlen;
 
 					if (raw_body) {
 						/* We can also output the resulting json */
-						fmt::print(out, "{}\n", std::string_view{raw_body, (std::size_t)(rawlen - bodylen)});
+						rspamc_print(out, "{}\n", std::string_view{raw_body, (std::size_t)(rawlen - bodylen)});
 					}
 				}
 			}
-			fmt::print(out, "\n");
+			rspamc_print(out, "\n");
 		}
 
 		fflush(out);
 		}
 	}
 	else {
-		fmt::print(stderr, "cannot connect to {}: {}\n", connect_str,
-				   strerror(errno));
+		rspamc_print(stderr, "cannot connect to {}: {}\n", connect_str,
+					 strerror(errno));
 		exit(EXIT_FAILURE);
 	}
 }
 			if (pentry->d_type == DT_UNKNOWN) {
 				/* Fallback to lstat */
 				if (lstat(fpath.c_str(), &st) == -1) {
-					fmt::print(stderr, "cannot stat file {}: {}\n",
-							   fpath, strerror(errno));
+					rspamc_print(stderr, "cannot stat file {}: {}\n",
+								 fpath, strerror(errno));
 					continue;
 				}
 
 			}
 #else
 			if (lstat(fpath.c_str(), &st) == -1) {
-				fmt::print(stderr, "cannot stat file {}: {}\n",
-						   fpath, strerror(errno));
+				rspamc_print(stderr, "cannot stat file {}: {}\n",
+							 fpath, strerror(errno));
 				continue;
 			}
 
 			else if (is_reg) {
 				auto *in = fopen(fpath.c_str(), "r");
 				if (in == nullptr) {
-					fmt::print(stderr, "cannot open file {}: {}\n",
-							   fpath, strerror(errno));
+					rspamc_print(stderr, "cannot open file {}: {}\n",
+								 fpath, strerror(errno));
 					continue;
 				}
 
 		}
 	}
 	else {
-		fmt::print(stderr, "cannot open directory {}: {}\n", name, strerror(errno));
+		rspamc_print(stderr, "cannot open directory {}: {}\n", name, strerror(errno));
 		exit(EXIT_FAILURE);
 	}
 
 			exclude_compiled[i] = g_pattern_spec_new(exclude_patterns[i]);
 
 			if (exclude_compiled[i] == nullptr) {
-				fmt::print(stderr, "Invalid glob pattern: {}\n",
-						   exclude_patterns[i]);
+				rspamc_print(stderr, "Invalid glob pattern: {}\n",
+							 exclude_patterns[i]);
 				exit(EXIT_FAILURE);
 			}
 		}
 			/* In case of command read arguments starting from 2 */
 			if (cmd.cmd == RSPAMC_COMMAND_ADD_SYMBOL || cmd.cmd == RSPAMC_COMMAND_ADD_ACTION) {
 				if (argc < 4 || argc > 5) {
-					fmt::print(stderr, "invalid arguments\n");
+					rspamc_print(stderr, "invalid arguments\n");
 					exit(EXIT_FAILURE);
 				}
 				if (argc == 5) {
 	}
 
 	if (!maybe_cmd.has_value()) {
-		fmt::print(stderr, "invalid command\n");
+		rspamc_print(stderr, "invalid command\n");
 		exit(EXIT_FAILURE);
 	}
 
 				struct stat st;
 
 				if (stat(argv[i], &st) == -1) {
-					fmt::print(stderr, "cannot stat file {}\n", argv[i]);
+					rspamc_print(stderr, "cannot stat file {}\n", argv[i]);
 					exit(EXIT_FAILURE);
 				}
 				if (S_ISDIR(st.st_mode)) {
 				else {
 					in = fopen(argv[i], "r");
 					if (in == nullptr) {
-						fmt::print(stderr, "cannot open file {}\n", argv[i]);
+						rspamc_print(stderr, "cannot open file {}\n", argv[i]);
 						exit(EXIT_FAILURE);
 					}
 					rspamc_process_input(event_loop, cmd, in, argv[i], kwattrs);
 	for (auto cld: children) {
 		auto res = 0;
 		if (waitpid(cld, &res, 0) == -1) {
-			fmt::print(stderr, "Cannot wait for {}: {}", cld,
-					   strerror(errno));
+			rspamc_print(stderr, "Cannot wait for {}: {}", cld,
+						 strerror(errno));
 
 			ret = errno;
 		}