static gboolean profile = FALSE;
static gboolean skip_images = FALSE;
static gboolean skip_attachments = FALSE;
-static const char *key = nullptr;
+static const char *pubkey = nullptr;
static const char *user_agent = "rspamc";
std::vector<GPid> children;
GError **error);
static GOptionEntry entries[] =
- {
- {"connect", 'h', 0, G_OPTION_ARG_STRING, &connect_str,
- "Specify host and port", nullptr},
- {"password", 'P', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK,
- (void *) &rspamc_password_callback, "Specify control password", nullptr},
- {"classifier", 'c', 0, G_OPTION_ARG_STRING, &classifier,
- "Classifier to learn spam or ham", nullptr},
- {"weight", 'w', 0, G_OPTION_ARG_INT, &weight,
- "Weight for fuzzy operations", nullptr},
- {"flag", 'f', 0, G_OPTION_ARG_INT, &flag, "Flag for fuzzy operations",
- nullptr},
- {"pass-all", 'p', 0, G_OPTION_ARG_NONE, &pass_all, "Pass all filters",
- nullptr},
- {"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "More verbose output",
- nullptr},
- {"ip", 'i', 0, G_OPTION_ARG_STRING, &ip,
- "Emulate that message was received from specified ip address",
- nullptr},
- {"user", 'u', 0, G_OPTION_ARG_STRING, &user,
- "Emulate that message was received from specified authenticated user", nullptr},
- {"deliver", 'd', 0, G_OPTION_ARG_STRING, &deliver_to,
- "Emulate that message is delivered to specified user (for LDA/statistics)", nullptr},
- {"from", 'F', 0, G_OPTION_ARG_STRING, &from,
- "Emulate that message has specified SMTP FROM address", nullptr},
- {"rcpt", 'r', 0, G_OPTION_ARG_STRING_ARRAY, &rcpts,
- "Emulate that message has specified SMTP RCPT address", nullptr},
- {"helo", 0, 0, G_OPTION_ARG_STRING, &helo,
- "Imitate SMTP HELO passing from MTA", nullptr},
- {"hostname", 0, 0, G_OPTION_ARG_STRING, &hostname,
- "Imitate hostname passing from MTA", nullptr},
- {"timeout", 't', 0, G_OPTION_ARG_DOUBLE, &timeout,
- "Time in seconds to wait for a reply", nullptr},
- {"bind", 'b', 0, G_OPTION_ARG_STRING, &local_addr,
- "Bind to specified ip address", nullptr},
- {"commands", 0, 0, G_OPTION_ARG_NONE, &print_commands,
- "List available commands", nullptr},
- {"human", 'R', 0, G_OPTION_ARG_NONE, &humanreport, "Output human readable report", nullptr},
- {"json", 'j', 0, G_OPTION_ARG_NONE, &json, "Output json reply", nullptr},
- {"compact", '\0', 0, G_OPTION_ARG_NONE, &compact, "Output compact json reply", nullptr},
- {"headers", 0, 0, G_OPTION_ARG_NONE, &headers, "Output HTTP headers",
- nullptr},
- {"raw", 0, 0, G_OPTION_ARG_NONE, &raw, "Input is a raw file, not an email file",
- nullptr},
- {"ucl", 0, 0, G_OPTION_ARG_NONE, &ucl_reply, "Output ucl reply from rspamd",
- nullptr},
- {"max-requests", 'n', 0, G_OPTION_ARG_INT, &max_requests,
- "Maximum count of parallel requests to rspamd", nullptr},
- {"extended-urls", 0, 0, G_OPTION_ARG_NONE, &extended_urls,
- "Output urls in extended format", nullptr},
- {"key", 0, 0, G_OPTION_ARG_STRING, &key,
- "Use specified pubkey to encrypt request", nullptr},
- {"exec", 'e', 0, G_OPTION_ARG_STRING, &execute,
- "Execute the specified command and pass output to it", nullptr},
- {"mime", 'm', 0, G_OPTION_ARG_NONE, &mime_output,
- "Write mime body of message with headers instead of just a scan's result", nullptr},
- {"header", 0, 0, G_OPTION_ARG_STRING_ARRAY, &http_headers,
- "Add custom HTTP header to query (can be repeated)", nullptr},
- {"exclude", 0, 0, G_OPTION_ARG_STRING_ARRAY, &exclude_patterns,
- "Exclude specific glob patterns in file names (can be repeated)", nullptr},
- {"sort", 0, 0, G_OPTION_ARG_STRING, &sort,
- "Sort output in a specific order (name, weight, frequency, hits)", nullptr},
- {"empty", 'E', 0, G_OPTION_ARG_NONE, &empty_input,
- "Allow empty input instead of reading from stdin", nullptr},
- {"fuzzy-symbol", 'S', 0, G_OPTION_ARG_STRING, &fuzzy_symbol,
- "Learn the specified fuzzy symbol", nullptr},
- {"compressed", 'z', 0, G_OPTION_ARG_NONE, &compressed,
- "Enable zstd compression", nullptr},
- {"profile", '\0', 0, G_OPTION_ARG_NONE, &profile,
- "Profile symbols execution time", nullptr},
- {"dictionary", 'D', 0, G_OPTION_ARG_FILENAME, &dictionary,
- "Use dictionary to compress data", nullptr},
- {"skip-images", '\0', 0, G_OPTION_ARG_NONE, &skip_images,
- "Skip images when learning/unlearning fuzzy", nullptr},
- {"skip-attachments", '\0', 0, G_OPTION_ARG_NONE, &skip_attachments,
- "Skip attachments when learning/unlearning fuzzy", nullptr},
- {"user-agent", 'U', 0, G_OPTION_ARG_STRING, &user_agent,
- "Use specific User-Agent instead of \"rspamc\"", nullptr},
- {nullptr, 0, 0, G_OPTION_ARG_NONE, nullptr, nullptr, nullptr}
- };
+ {
+ {"connect", 'h', 0, G_OPTION_ARG_STRING, &connect_str,
+ "Specify host and port", nullptr},
+ {"password", 'P', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK,
+ (void *) &rspamc_password_callback, "Specify control password", nullptr},
+ {"classifier", 'c', 0, G_OPTION_ARG_STRING, &classifier,
+ "Classifier to learn spam or ham", nullptr},
+ {"weight", 'w', 0, G_OPTION_ARG_INT, &weight,
+ "Weight for fuzzy operations", nullptr},
+ {"flag", 'f', 0, G_OPTION_ARG_INT, &flag, "Flag for fuzzy operations",
+ nullptr},
+ {"pass-all", 'p', 0, G_OPTION_ARG_NONE, &pass_all, "Pass all filters",
+ nullptr},
+ {"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "More verbose output",
+ nullptr},
+ {"ip", 'i', 0, G_OPTION_ARG_STRING, &ip,
+ "Emulate that message was received from specified ip address",
+ nullptr},
+ {"user", 'u', 0, G_OPTION_ARG_STRING, &user,
+ "Emulate that message was received from specified authenticated user", nullptr},
+ {"deliver", 'd', 0, G_OPTION_ARG_STRING, &deliver_to,
+ "Emulate that message is delivered to specified user (for LDA/statistics)", nullptr},
+ {"from", 'F', 0, G_OPTION_ARG_STRING, &from,
+ "Emulate that message has specified SMTP FROM address", nullptr},
+ {"rcpt", 'r', 0, G_OPTION_ARG_STRING_ARRAY, &rcpts,
+ "Emulate that message has specified SMTP RCPT address", nullptr},
+ {"helo", 0, 0, G_OPTION_ARG_STRING, &helo,
+ "Imitate SMTP HELO passing from MTA", nullptr},
+ {"hostname", 0, 0, G_OPTION_ARG_STRING, &hostname,
+ "Imitate hostname passing from MTA", nullptr},
+ {"timeout", 't', 0, G_OPTION_ARG_DOUBLE, &timeout,
+ "Time in seconds to wait for a reply", nullptr},
+ {"bind", 'b', 0, G_OPTION_ARG_STRING, &local_addr,
+ "Bind to specified ip address", nullptr},
+ {"commands", 0, 0, G_OPTION_ARG_NONE, &print_commands,
+ "List available commands", nullptr},
+ {"human", 'R', 0, G_OPTION_ARG_NONE, &humanreport, "Output human readable report", nullptr},
+ {"json", 'j', 0, G_OPTION_ARG_NONE, &json, "Output json reply", nullptr},
+ {"compact", '\0', 0, G_OPTION_ARG_NONE, &compact, "Output compact json reply", nullptr},
+ {"headers", 0, 0, G_OPTION_ARG_NONE, &headers, "Output HTTP headers",
+ nullptr},
+ {"raw", 0, 0, G_OPTION_ARG_NONE, &raw, "Input is a raw file, not an email file",
+ nullptr},
+ {"ucl", 0, 0, G_OPTION_ARG_NONE, &ucl_reply, "Output ucl reply from rspamd",
+ nullptr},
+ {"max-requests", 'n', 0, G_OPTION_ARG_INT, &max_requests,
+ "Maximum count of parallel requests to rspamd", nullptr},
+ {"extended-urls", 0, 0, G_OPTION_ARG_NONE, &extended_urls,
+ "Output urls in extended format", nullptr},
+ {"key", 0, 0, G_OPTION_ARG_STRING, &pubkey,
+ "Use specified pubkey to encrypt request", nullptr},
+ {"exec", 'e', 0, G_OPTION_ARG_STRING, &execute,
+ "Execute the specified command and pass output to it", nullptr},
+ {"mime", 'm', 0, G_OPTION_ARG_NONE, &mime_output,
+ "Write mime body of message with headers instead of just a scan's result", nullptr},
+ {"header", 0, 0, G_OPTION_ARG_STRING_ARRAY, &http_headers,
+ "Add custom HTTP header to query (can be repeated)", nullptr},
+ {"exclude", 0, 0, G_OPTION_ARG_STRING_ARRAY, &exclude_patterns,
+ "Exclude specific glob patterns in file names (can be repeated)", nullptr},
+ {"sort", 0, 0, G_OPTION_ARG_STRING, &sort,
+ "Sort output in a specific order (name, weight, frequency, hits)", nullptr},
+ {"empty", 'E', 0, G_OPTION_ARG_NONE, &empty_input,
+ "Allow empty input instead of reading from stdin", nullptr},
+ {"fuzzy-symbol", 'S', 0, G_OPTION_ARG_STRING, &fuzzy_symbol,
+ "Learn the specified fuzzy symbol", nullptr},
+ {"compressed", 'z', 0, G_OPTION_ARG_NONE, &compressed,
+ "Enable zstd compression", nullptr},
+ {"profile", '\0', 0, G_OPTION_ARG_NONE, &profile,
+ "Profile symbols execution time", nullptr},
+ {"dictionary", 'D', 0, G_OPTION_ARG_FILENAME, &dictionary,
+ "Use dictionary to compress data", nullptr},
+ {"skip-images", '\0', 0, G_OPTION_ARG_NONE, &skip_images,
+ "Skip images when learning/unlearning fuzzy", nullptr},
+ {"skip-attachments", '\0', 0, G_OPTION_ARG_NONE, &skip_attachments,
+ "Skip attachments when learning/unlearning fuzzy", nullptr},
+ {"user-agent", 'U', 0, G_OPTION_ARG_STRING, &user_agent,
+ "Use specific User-Agent instead of \"rspamc\"", nullptr},
+ {nullptr, 0, 0, G_OPTION_ARG_NONE, nullptr, nullptr, nullptr}
+ };
static void rspamc_symbols_output(FILE *out, ucl_object_t *obj);
};
static const constexpr auto rspamc_commands = rspamd::array_of(
- rspamc_command{
- .cmd = RSPAMC_COMMAND_SYMBOLS,
- .name = "symbols",
- .path = "checkv2",
- .description = "scan message and show symbols (default command)",
- .is_controller = FALSE,
- .is_privileged = FALSE,
- .need_input = TRUE,
- .command_output_func = rspamc_symbols_output
- },
- rspamc_command{
- .cmd = RSPAMC_COMMAND_LEARN_SPAM,
- .name = "learn_spam",
- .path = "learnspam",
- .description = "learn message as spam",
- .is_controller = TRUE,
- .is_privileged = TRUE,
- .need_input = TRUE,
- .command_output_func = nullptr
- },
- rspamc_command{
- .cmd = RSPAMC_COMMAND_LEARN_HAM,
- .name = "learn_ham",
- .path = "learnham",
- .description = "learn message as ham",
- .is_controller = TRUE,
- .is_privileged = TRUE,
- .need_input = TRUE,
- .command_output_func = nullptr
- },
- rspamc_command{
- .cmd = RSPAMC_COMMAND_FUZZY_ADD,
- .name = "fuzzy_add",
- .path = "fuzzyadd",
- .description =
- "add hashes from a message to the fuzzy storage (check -f and -w options for this command)",
- .is_controller = TRUE,
- .is_privileged = TRUE,
- .need_input = TRUE,
- .command_output_func = nullptr
- },
- rspamc_command{
- .cmd = RSPAMC_COMMAND_FUZZY_DEL,
- .name = "fuzzy_del",
- .path = "fuzzydel",
- .description =
- "delete hashes from a message from the fuzzy storage (check -f option for this command)",
- .is_controller = TRUE,
- .is_privileged = TRUE,
- .need_input = TRUE,
- .command_output_func = nullptr
- },
- rspamc_command{
- .cmd = RSPAMC_COMMAND_FUZZY_DELHASH,
- .name = "fuzzy_delhash",
- .path = "fuzzydelhash",
- .description =
- "delete a hash from fuzzy storage (check -f option for this command)",
- .is_controller = TRUE,
- .is_privileged = TRUE,
- .need_input = FALSE,
- .command_output_func = nullptr
- },
- rspamc_command{
- .cmd = RSPAMC_COMMAND_STAT,
- .name = "stat",
- .path = "stat",
- .description = "show rspamd statistics",
- .is_controller = TRUE,
- .is_privileged = FALSE,
- .need_input = FALSE,
- .command_output_func = rspamc_stat_output,
- },
- rspamc_command{
- .cmd = RSPAMC_COMMAND_STAT_RESET,
- .name = "stat_reset",
- .path = "statreset",
- .description = "show and reset rspamd statistics (useful for graphs)",
- .is_controller = TRUE,
- .is_privileged = TRUE,
- .need_input = FALSE,
- .command_output_func = rspamc_stat_output
- },
- rspamc_command{
- .cmd = RSPAMC_COMMAND_COUNTERS,
- .name = "counters",
- .path = "counters",
- .description = "display rspamd symbols statistics",
- .is_controller = TRUE,
- .is_privileged = FALSE,
- .need_input = FALSE,
- .command_output_func = rspamc_counters_output
- },
- rspamc_command{
- .cmd = RSPAMC_COMMAND_UPTIME,
- .name = "uptime",
- .path = "auth",
- .description = "show rspamd uptime",
- .is_controller = TRUE,
- .is_privileged = FALSE,
- .need_input = FALSE,
- .command_output_func = rspamc_uptime_output
- },
- rspamc_command{
- .cmd = RSPAMC_COMMAND_ADD_SYMBOL,
- .name = "add_symbol",
- .path = "addsymbol",
- .description = "add or modify symbol settings in rspamd",
- .is_controller = TRUE,
- .is_privileged = TRUE,
- .need_input = FALSE,
- .command_output_func = nullptr
- },
- rspamc_command{
- .cmd = RSPAMC_COMMAND_ADD_ACTION,
- .name = "add_action",
- .path = "addaction",
- .description = "add or modify action settings",
- .is_controller = TRUE,
- .is_privileged = TRUE,
- .need_input = FALSE,
- .command_output_func = nullptr
- }
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_SYMBOLS,
+ .name = "symbols",
+ .path = "checkv2",
+ .description = "scan message and show symbols (default command)",
+ .is_controller = FALSE,
+ .is_privileged = FALSE,
+ .need_input = TRUE,
+ .command_output_func = rspamc_symbols_output
+ },
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_LEARN_SPAM,
+ .name = "learn_spam",
+ .path = "learnspam",
+ .description = "learn message as spam",
+ .is_controller = TRUE,
+ .is_privileged = TRUE,
+ .need_input = TRUE,
+ .command_output_func = nullptr
+ },
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_LEARN_HAM,
+ .name = "learn_ham",
+ .path = "learnham",
+ .description = "learn message as ham",
+ .is_controller = TRUE,
+ .is_privileged = TRUE,
+ .need_input = TRUE,
+ .command_output_func = nullptr
+ },
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_FUZZY_ADD,
+ .name = "fuzzy_add",
+ .path = "fuzzyadd",
+ .description =
+ "add hashes from a message to the fuzzy storage (check -f and -w options for this command)",
+ .is_controller = TRUE,
+ .is_privileged = TRUE,
+ .need_input = TRUE,
+ .command_output_func = nullptr
+ },
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_FUZZY_DEL,
+ .name = "fuzzy_del",
+ .path = "fuzzydel",
+ .description =
+ "delete hashes from a message from the fuzzy storage (check -f option for this command)",
+ .is_controller = TRUE,
+ .is_privileged = TRUE,
+ .need_input = TRUE,
+ .command_output_func = nullptr
+ },
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_FUZZY_DELHASH,
+ .name = "fuzzy_delhash",
+ .path = "fuzzydelhash",
+ .description =
+ "delete a hash from fuzzy storage (check -f option for this command)",
+ .is_controller = TRUE,
+ .is_privileged = TRUE,
+ .need_input = FALSE,
+ .command_output_func = nullptr
+ },
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_STAT,
+ .name = "stat",
+ .path = "stat",
+ .description = "show rspamd statistics",
+ .is_controller = TRUE,
+ .is_privileged = FALSE,
+ .need_input = FALSE,
+ .command_output_func = rspamc_stat_output,
+ },
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_STAT_RESET,
+ .name = "stat_reset",
+ .path = "statreset",
+ .description = "show and reset rspamd statistics (useful for graphs)",
+ .is_controller = TRUE,
+ .is_privileged = TRUE,
+ .need_input = FALSE,
+ .command_output_func = rspamc_stat_output
+ },
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_COUNTERS,
+ .name = "counters",
+ .path = "counters",
+ .description = "display rspamd symbols statistics",
+ .is_controller = TRUE,
+ .is_privileged = FALSE,
+ .need_input = FALSE,
+ .command_output_func = rspamc_counters_output
+ },
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_UPTIME,
+ .name = "uptime",
+ .path = "auth",
+ .description = "show rspamd uptime",
+ .is_controller = TRUE,
+ .is_privileged = FALSE,
+ .need_input = FALSE,
+ .command_output_func = rspamc_uptime_output
+ },
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_ADD_SYMBOL,
+ .name = "add_symbol",
+ .path = "addsymbol",
+ .description = "add or modify symbol settings in rspamd",
+ .is_controller = TRUE,
+ .is_privileged = TRUE,
+ .need_input = FALSE,
+ .command_output_func = nullptr
+ },
+ rspamc_command{
+ .cmd = RSPAMC_COMMAND_ADD_ACTION,
+ .name = "add_action",
+ .path = "addaction",
+ .description = "add or modify action settings",
+ .is_controller = TRUE,
+ .is_privileged = TRUE,
+ .need_input = FALSE,
+ .command_output_func = nullptr
+ }
);
struct rspamc_callback_data {
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 {
- const auto *elt1 = ucl_object_lookup(o1, "symbol");
- const auto *elt2 = ucl_object_lookup(o2, "symbol");
-
- if (elt1 && elt2) {
- return strcmp(ucl_object_tostring(elt1),
- ucl_object_tostring(elt2));
- }
- else if (ucl_object_key(o1) != nullptr && ucl_object_key(o2) != nullptr) {
- return strcmp(ucl_object_key(o1),
- ucl_object_key(o2));
- }
- return 0;
- }},
- {"weight", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
- const auto *elt1 = ucl_object_lookup(o1, "weight");
- const auto *elt2 = ucl_object_lookup(o2, "weight");
-
- if (elt1 && elt2) {
- return ucl_object_todouble(elt2) * 1000.0 - ucl_object_todouble(elt1) * 1000.0;
- }
- return 0;
- }},
- {"score", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
- const auto *elt1 = ucl_object_lookup(o1, "score");
- const auto *elt2 = ucl_object_lookup(o2, "score");
-
- if (elt1 && elt2) {
- return std::fabs(ucl_object_todouble(elt2)) * 1000.0 -
- std::fabs(ucl_object_todouble(elt1)) * 1000.0;
- }
- return 0;
- }},
- {"time", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
- const auto *elt1 = ucl_object_lookup(o1, "time");
- const auto *elt2 = ucl_object_lookup(o2, "time");
-
- if (elt1 && elt2) {
- return ucl_object_todouble(elt2) * 1000.0 - ucl_object_todouble(elt1) * 1000.0;
- }
- return 0;
- }},
- {"frequency", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
- const auto *elt1 = ucl_object_lookup(o1, "frequency");
- const auto *elt2 = ucl_object_lookup(o2, "frequency");
-
- if (elt1 && elt2) {
- return ucl_object_todouble(elt2) * 1000.0 - ucl_object_todouble(elt1) * 1000.0;
- }
- return 0;
- }},
- {"hits", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
- const auto *elt1 = ucl_object_lookup(o1, "hits");
- const auto *elt2 = ucl_object_lookup(o2, "hits");
-
- if (elt1 && elt2) {
- return ucl_object_toint(elt2) - ucl_object_toint(elt1);
- }
- return 0;
- }},
+ {"name", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
+ const auto *elt1 = ucl_object_lookup(o1, "symbol");
+ const auto *elt2 = ucl_object_lookup(o2, "symbol");
+
+ if (elt1 && elt2) {
+ return strcmp(ucl_object_tostring(elt1),
+ ucl_object_tostring(elt2));
+ }
+ else if (ucl_object_key(o1) != nullptr && ucl_object_key(o2) != nullptr) {
+ return strcmp(ucl_object_key(o1),
+ ucl_object_key(o2));
+ }
+ return 0;
+ }},
+ {"weight", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
+ const auto *elt1 = ucl_object_lookup(o1, "weight");
+ const auto *elt2 = ucl_object_lookup(o2, "weight");
+
+ if (elt1 && elt2) {
+ return ucl_object_todouble(elt2) * 1000.0 - ucl_object_todouble(elt1) * 1000.0;
+ }
+ return 0;
+ }},
+ {"score", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
+ const auto *elt1 = ucl_object_lookup(o1, "score");
+ const auto *elt2 = ucl_object_lookup(o2, "score");
+
+ if (elt1 && elt2) {
+ return std::fabs(ucl_object_todouble(elt2)) * 1000.0 -
+ std::fabs(ucl_object_todouble(elt1)) * 1000.0;
+ }
+ return 0;
+ }},
+ {"time", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
+ const auto *elt1 = ucl_object_lookup(o1, "time");
+ const auto *elt2 = ucl_object_lookup(o2, "time");
+
+ if (elt1 && elt2) {
+ return ucl_object_todouble(elt2) * 1000.0 - ucl_object_todouble(elt1) * 1000.0;
+ }
+ return 0;
+ }},
+ {"frequency", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
+ const auto *elt1 = ucl_object_lookup(o1, "frequency");
+ const auto *elt2 = ucl_object_lookup(o2, "frequency");
+
+ if (elt1 && elt2) {
+ return ucl_object_todouble(elt2) * 1000.0 - ucl_object_todouble(elt1) * 1000.0;
+ }
+ return 0;
+ }},
+ {"hits", [](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
+ const auto *elt1 = ucl_object_lookup(o1, "hits");
+ const auto *elt2 = ucl_object_lookup(o2, "hits");
+
+ if (elt1 && elt2) {
+ return ucl_object_toint(elt2) - ucl_object_toint(elt1);
+ }
+ return 0;
+ }},
});
/* TODO: remove once migrate to C++20 standard */
const auto sort_functor = sort_map.find(sort_view);
if (sort_functor != sort_map.end()) {
std::stable_sort(std::begin(cont), std::end(cont),
- [&](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
- auto order = sort_functor->second(o1, o2);
+ [&](const ucl_object_t *o1, const ucl_object_t *o2) -> int {
+ auto order = sort_functor->second(o1, o2);
- return inverse ? order > 0 : order < 0;
- });
+ return inverse ? order > 0 : order < 0;
+ });
}
}
}
/* Prepare parser */
context = g_option_context_new("- run rspamc client");
g_option_context_set_summary(context,
- "Summary:\n Rspamd client version " RVERSION "\n Release id: " RID);
+ "Summary:\n Rspamd client version " RVERSION "\n Release id: " RID);
g_option_context_add_main_entries(context, entries, nullptr);
/* Parse options */
{
std::string s{inp};
std::transform(std::begin(s), std::end(s), std::begin(s),
- [](unsigned char c) { return std::tolower(c); });
+ [](unsigned char c) { return std::tolower(c); });
return s;
}
rspamd_action_from_str_rspamc(const char *data) -> std::optional<int>
{
static constexpr const auto str_map = frozen::make_unordered_map<frozen::string, int>({
- {"reject", METRIC_ACTION_REJECT},
- {"greylist", METRIC_ACTION_GREYLIST},
- {"add_header", METRIC_ACTION_ADD_HEADER},
- {"add header", METRIC_ACTION_ADD_HEADER},
- {"rewrite_subject", METRIC_ACTION_REWRITE_SUBJECT},
- {"rewrite subject", METRIC_ACTION_REWRITE_SUBJECT},
- {"soft_reject", METRIC_ACTION_SOFT_REJECT},
- {"soft reject", METRIC_ACTION_SOFT_REJECT},
- {"no_action", METRIC_ACTION_NOACTION},
- {"no action", METRIC_ACTION_NOACTION},
+ {"reject", METRIC_ACTION_REJECT},
+ {"greylist", METRIC_ACTION_GREYLIST},
+ {"add_header", METRIC_ACTION_ADD_HEADER},
+ {"add header", METRIC_ACTION_ADD_HEADER},
+ {"rewrite_subject", METRIC_ACTION_REWRITE_SUBJECT},
+ {"rewrite subject", METRIC_ACTION_REWRITE_SUBJECT},
+ {"soft_reject", METRIC_ACTION_SOFT_REJECT},
+ {"soft reject", METRIC_ACTION_SOFT_REJECT},
+ {"no_action", METRIC_ACTION_NOACTION},
+ {"no action", METRIC_ACTION_NOACTION},
});
auto st_lower = rspamd_string_tolower(data);
check_rspamc_command(const char *cmd) -> std::optional<rspamc_command>
{
static constexpr const auto str_map = frozen::make_unordered_map<frozen::string, int>({
- {"symbols", RSPAMC_COMMAND_SYMBOLS},
- {"check", RSPAMC_COMMAND_SYMBOLS},
- {"report", RSPAMC_COMMAND_SYMBOLS},
- {"learn_spam", RSPAMC_COMMAND_LEARN_SPAM},
- {"learn_ham", RSPAMC_COMMAND_LEARN_HAM},
- {"fuzzy_add", RSPAMC_COMMAND_FUZZY_ADD},
- {"fuzzy_del", RSPAMC_COMMAND_FUZZY_DEL},
- {"fuzzy_delhash", RSPAMC_COMMAND_FUZZY_DELHASH},
- {"stat", RSPAMC_COMMAND_STAT},
- {"stat_reset", RSPAMC_COMMAND_STAT_RESET},
- {"counters", RSPAMC_COMMAND_COUNTERS},
- {"uptime", RSPAMC_COMMAND_UPTIME},
+ {"symbols", RSPAMC_COMMAND_SYMBOLS},
+ {"check", RSPAMC_COMMAND_SYMBOLS},
+ {"report", RSPAMC_COMMAND_SYMBOLS},
+ {"learn_spam", RSPAMC_COMMAND_LEARN_SPAM},
+ {"learn_ham", RSPAMC_COMMAND_LEARN_HAM},
+ {"fuzzy_add", RSPAMC_COMMAND_FUZZY_ADD},
+ {"fuzzy_del", RSPAMC_COMMAND_FUZZY_DEL},
+ {"fuzzy_delhash", RSPAMC_COMMAND_FUZZY_DELHASH},
+ {"stat", RSPAMC_COMMAND_STAT},
+ {"stat_reset", RSPAMC_COMMAND_STAT_RESET},
+ {"counters", RSPAMC_COMMAND_COUNTERS},
+ {"uptime", RSPAMC_COMMAND_UPTIME},
});
std::string cmd_lc = rspamd_string_tolower(cmd);
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);
+ " {:>{}} ({: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");
+ "\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");
+ "control commands use port 11334 while normal use 11333 by default (see -h option)\n");
}
static void
rspamd_inet_addr_t *addr = nullptr;
if (!rspamd_parse_inet_address(&addr, ip, strlen(ip),
- RSPAMD_INET_ADDRESS_PARSE_DEFAULT)) {
+ RSPAMD_INET_ADDRESS_PARSE_DEFAULT)) {
/* Try to resolve */
struct addrinfo hints, *res, *cur;
int r;
cur = res;
while (cur) {
addr = rspamd_inet_address_from_sa(cur->ai_addr,
- cur->ai_addrlen);
+ cur->ai_addrlen);
if (addr != nullptr) {
ip = g_strdup(rspamd_inet_address_to_string(addr));
}
else {
fmt::print(stderr, "address resolution for {} failed: {}\n",
- ip,
- gai_strerror(r));
+ ip,
+ gai_strerror(r));
}
}
else {
}
else {
add_client_header(opts,
- hdr_view.substr(0, std::distance(std::begin(hdr_view), delim_pos)),
- hdr_view.substr(std::distance(std::begin(hdr_view), delim_pos) + 1));
+ hdr_view.substr(0, std::distance(std::begin(hdr_view), delim_pos)),
+ hdr_view.substr(std::distance(std::begin(hdr_view), delim_pos) + 1));
}
hdr++;
}
}
-static void
-print_indented_line(FILE *out, std::string_view line, size_t maxlen, size_t indent)
-{
- if (maxlen < 1) {
- return;
- }
-
- std::string_view s;
- for (size_t pos = 0; pos < line.size(); pos += s.size()) {
- s = line.substr(pos, pos ? (maxlen-indent) : maxlen);
- if (indent && pos) {
- fmt::print(out, "{:>{}}", " ", indent);
- }
- fmt::print(out, "{}\n", s);
- }
-}
-
static void
rspamc_symbol_human_output(FILE *out, const ucl_object_t *obj)
{
line += '\n';
}
- print_indented_line(out, line, 78, 28);
+ auto print_indented_line = [&](size_t maxlen, size_t indent) {
+ if (maxlen < 1 || maxlen < indent) {
+ return;
+ }
+ for (size_t pos = 0; pos < line.size(); ) {
+ auto s = line.substr(pos, pos ? (maxlen-indent) : maxlen);
+ if (indent && pos) {
+ fmt::print(out, "{:>{}}", " ", indent);
+ }
+ fmt::print(out, "{}\n", s);
+ pos += s.size();
+ }
+ };
+
+ print_indented_line(78, 28);
}
static void
if (humanreport) {
fmt::print(out,
- "{}/{}/{}/{}",
- emphasis_argument(score, 2),
- emphasis_argument(greylist_score, 2),
- emphasis_argument(addheader_score, 2),
- emphasis_argument(required_score, 2));
+ "{}/{}/{}/{}",
+ 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");
}
else if (got_scores == 2) {
fmt::print(out,
- "Score: {} / {}\n",
- emphasis_argument(score, 2),
- emphasis_argument(required_score, 2));
+ "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(required_score, 2));
+ emphasis_argument(score, 2),
+ emphasis_argument(required_score, 2));
fmt::print(out, " pts rule name description\n");
fmt::print(out, "---- ---------------------- --------------------------------------------------\n");
}
ar.push_back(cur);
}
std::stable_sort(std::begin(ar), std::end(ar),
- [](const ucl_object_t *u1, const ucl_object_t *u2) -> int {
- return ucl_object_compare(u1, u2);
- });
+ [](const ucl_object_t *u1, const ucl_object_t *u2) -> int {
+ return ucl_object_compare(u1, u2);
+ });
for (const auto *cur_elt : ar) {
fmt::print(out, "\t{}: {:3} usec\n",
- ucl_object_key(cur_elt), ucl_object_todouble(cur_elt));
+ ucl_object_key(cur_elt), ucl_object_todouble(cur_elt));
}
}
}
if (humanreport) {
- if (emitted && strcmp(emitted, "[]")) {
- print_indented_line(out, fmt::format("Domains found: {}", emitted), 78, 4);
- }
+ if (emitted && strcmp(emitted, "[]") != 0) {
+ auto folded_line = rspamd_header_value_fold("Domains found: ", sizeof("Domains found: ") - 1,
+ emitted, strlen(emitted), 78,
+ RSPAMD_TASK_NEWLINES_LF, nullptr);
+ fmt::print("Domains found: {}\n", folded_line->str);
+ g_string_free(folded_line, true);
+ }
}
else {
fmt::print(out, "Urls: {}\n", emitted);
}
if (humanreport) {
- if (emitted && strcmp(emitted, "[]")) {
- print_indented_line(out, fmt::format("Emails found: {}", emitted), 78, 4);
+ if (emitted && strcmp(emitted, "[]") != 0) {
+ auto folded_line = rspamd_header_value_fold("Emails found: ", sizeof("Emails found: ") - 1,
+ emitted, strlen(emitted), 78,
+ RSPAMD_TASK_NEWLINES_LF, nullptr);
+ fmt::print("Emails found: {}\n", folded_line->str);
+ g_string_free(folded_line, true);
}
}
else {
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));
+ 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);
+ ucl_object_key(cmesg), rendered_message);
free(rendered_message);
}
}
const auto *elt = ucl_object_lookup(obj, "version");
if (elt != nullptr) {
fmt::print(out, "Rspamd version: %s\n", ucl_object_tostring(
- elt));
+ elt));
}
elt = ucl_object_lookup(obj, "uptime");
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" : "");
+ 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%s\n", seconds,
- (gint) seconds > 1 ? "s" : "");
+ (gint) seconds > 1 ? "s" : "");
}
/* Else print the minutes and seconds. */
else {
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" : "");
+ minutes, minutes > 1 ? "s" : "",
+ seconds, seconds > 1 ? "s" : "");
}
}
}
fmt::print(out, " {} \n", emphasis_argument(dash_buf));
fmt::print(out,
- "| {:<4} | {:<{}} | {:^7} | {:^13} | {:^7} |\n",
- "Pri",
- "Symbol",
- max_len,
- "Weight",
- "Frequency",
- "Hits");
+ "| {:<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", "");
+ "", max_len,
+ "", "hits/min", "");
for (const auto [i, cur] : rspamd::enumerate(counters_vec)) {
fmt::print(out, " {} \n", dash_buf);
if (sym->len > max_len) {
rspamd_snprintf(sym_buf, sizeof(sym_buf), "%*s...",
- (max_len - 3), ucl_object_tostring(sym));
+ (max_len - 3), ucl_object_tostring(sym));
sym_name = sym_buf;
}
else {
}
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));
+ 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);
while ((cur = ucl_object_iterate (actions, &iter, true)) != nullptr) {
auto cnt = ucl_object_toint(cur);
fmt::format_to(std::back_inserter(out), "Messages with action {}: {}, {:.2f}%\n",
- ucl_object_key(cur), emphasis_argument(cnt),
- ((double) cnt / (double) scanned) * 100.);
+ ucl_object_key(cur), emphasis_argument(cnt),
+ ((double) cnt / (double) scanned) * 100.);
}
}
auto spam = ucl_object_toint(ucl_object_lookup(obj, "spam_count"));
auto ham = ucl_object_toint(ucl_object_lookup(obj, "ham_count"));
fmt::format_to(std::back_inserter(out), "Messages treated as spam: {}, {:.2f}%\n",
- emphasis_argument(spam),
- ((double) spam / (double) scanned) * 100.);
+ emphasis_argument(spam),
+ ((double) spam / (double) scanned) * 100.);
fmt::format_to(std::back_inserter(out), "Messages treated as ham: {}, {:.2f}%\n",
- emphasis_argument(ham),
- ((double) ham / (double) scanned) * 100.);
+ emphasis_argument(ham),
+ ((double) ham / (double) scanned) * 100.);
}
}
if (label) {
fmt::format_to(std::back_inserter(out), "Statfile: {} <{}> type: {}; ", symbol,
- label, type);
+ label, type);
}
else {
fmt::format_to(std::back_inserter(out), "Statfile: {} type: {}; ", symbol, type);
}
fmt::format_to(std::back_inserter(out), "length: {}; free blocks: {}; total blocks: {}; "
- "free: {:.2f}%; learned: {}; users: {}; languages: {}\n",
- size,
- blocks - used_blocks, blocks,
- blocks > 0 ? (blocks - used_blocks) * 100.0 / (double) blocks : 0,
- version,
- nusers, nlanguages);
+ "free: {:.2f}%; learned: {}; users: {}; languages: {}\n",
+ size,
+ blocks - used_blocks, blocks,
+ blocks > 0 ? (blocks - used_blocks) * 100.0 / (double) blocks : 0,
+ version,
+ nusers, nlanguages);
}
static void
auto scanned = ucl_object_toint(ucl_object_lookup(obj, "scanned"));
fmt::format_to(std::back_inserter(out_str), "Messages scanned: {}\n",
- emphasis_argument(scanned));
+ emphasis_argument(scanned));
rspamc_stat_actions(obj, out_str, scanned);
fmt::format_to(std::back_inserter(out_str), "Messages learned: {}\n",
- emphasis_argument(ucl_object_toint(ucl_object_lookup(obj, "learned"))));
+ emphasis_argument(ucl_object_toint(ucl_object_lookup(obj, "learned"))));
fmt::format_to(std::back_inserter(out_str), "Connections count: {}\n",
- emphasis_argument(ucl_object_toint(ucl_object_lookup(obj, "connections"))));
+ emphasis_argument(ucl_object_toint(ucl_object_lookup(obj, "connections"))));
fmt::format_to(std::back_inserter(out_str), "Control connections count: {}\n",
- emphasis_argument(ucl_object_toint(ucl_object_lookup(obj, "control_connections"))));
+ emphasis_argument(ucl_object_toint(ucl_object_lookup(obj, "control_connections"))));
const auto *avg_time_obj = ucl_object_lookup(obj, "scan_times");
if (cnt > 0) {
auto sum = rspamd_sum_floats(nums.data(), &cnt);
fmt::format_to(std::back_inserter(out_str),
- "Average scan time: {} sec\n",
- emphasis_argument(sum / cnt, 3));
+ "Average scan time: {} sec\n",
+ emphasis_argument(sum / cnt, 3));
}
}
/* Pools */
fmt::format_to(std::back_inserter(out_str), "Pools allocated: {}\n",
- ucl_object_toint(ucl_object_lookup(obj, "pools_allocated")));
+ ucl_object_toint(ucl_object_lookup(obj, "pools_allocated")));
fmt::format_to(std::back_inserter(out_str), "Pools freed: {}\n",
- ucl_object_toint(ucl_object_lookup(obj, "pools_freed")));
+ ucl_object_toint(ucl_object_lookup(obj, "pools_freed")));
fmt::format_to(std::back_inserter(out_str), "Bytes allocated: {}\n",
- ucl_object_toint(ucl_object_lookup(obj, "bytes_allocated")));
+ ucl_object_toint(ucl_object_lookup(obj, "bytes_allocated")));
fmt::format_to(std::back_inserter(out_str), "Memory chunks allocated: {}\n",
- ucl_object_toint(ucl_object_lookup(obj, "chunks_allocated")));
+ ucl_object_toint(ucl_object_lookup(obj, "chunks_allocated")));
fmt::format_to(std::back_inserter(out_str), "Shared chunks allocated: {}\n",
- ucl_object_toint(ucl_object_lookup(obj, "shared_chunks_allocated")));
+ ucl_object_toint(ucl_object_lookup(obj, "shared_chunks_allocated")));
fmt::format_to(std::back_inserter(out_str), "Chunks freed: {}\n",
- ucl_object_toint(ucl_object_lookup(obj, "chunks_freed")));
+ ucl_object_toint(ucl_object_lookup(obj, "chunks_freed")));
fmt::format_to(std::back_inserter(out_str), "Oversized chunks: {}\n",
- ucl_object_toint(ucl_object_lookup(obj, "chunks_oversized")));
+ ucl_object_toint(ucl_object_lookup(obj, "chunks_oversized")));
/* Fuzzy */
const auto *st = ucl_object_lookup(obj, "fuzzy_hashes");
while ((cur = ucl_iterate_object (st, &it, true)) != nullptr) {
auto num = ucl_object_toint(cur);
fmt::format_to(std::back_inserter(out_str), "Fuzzy hashes in storage \"{}\": {}\n",
- ucl_object_key(cur),
- num);
+ ucl_object_key(cur),
+ num);
stored += num;
}
fmt::format_to(std::back_inserter(out_str), "Fuzzy hashes stored: {}\n",
- stored);
+ stored);
}
st = ucl_object_lookup(obj, "fuzzy_checked");
}
}
fmt::format_to(std::back_inserter(out_str), "Total learns: {}\n",
- ucl_object_toint(ucl_object_lookup(obj, "total_learns")));
+ ucl_object_toint(ucl_object_lookup(obj, "total_learns")));
fmt::print(out, "{}", out_str.c_str());
}
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});
+ std::string_view{h->value.begin, h->value.len});
});
fmt::print(out, "\n");
}
fmt::format_to(std::back_inserter(added_headers), "X-Spam-Scanner: {}{}",
- "rspamc " RVERSION, line_end);
+ "rspamc " RVERSION, line_end);
fmt::format_to(std::back_inserter(added_headers), "X-Spam-Scan-Time: {:.3}{}",
- time, line_end);
+ time, line_end);
/*
* TODO: add milter_headers support here
}
fmt::format_to(std::back_inserter(added_headers),"X-Spam-Action: {}{}",
- action, line_end);
+ action, line_end);
fmt::format_to(std::back_inserter(added_headers), "X-Spam-Score: {:.2f} / {:.2f}{}",
- score, required_score, line_end);
+ score, required_score, line_end);
/* SA style stars header */
std::string scorebuf;
}
fmt::format_to(std::back_inserter(added_headers), "X-Spam-Level: {}{}",
- scorebuf, line_end);
+ scorebuf, line_end);
/* Short description of all symbols */
std::string symbuf;
}
auto *folded_symbuf = rspamd_header_value_fold("X-Spam-Symbols", strlen("X-Spam-Symbols"),
- symbuf.data(), symbuf.size(),
- 0, nl_type, ",");
+ symbuf.data(), symbuf.size(),
+ 0, nl_type, ",");
fmt::format_to(std::back_inserter(added_headers), "X-Spam-Symbols: {}{}",
- folded_symbuf->str, line_end);
+ folded_symbuf->str, line_end);
g_string_free(folded_symbuf, TRUE);
res = ucl_object_lookup(result, "dkim-signature");
if (res && res->type == UCL_STRING) {
fmt::format_to(std::back_inserter(added_headers), "DKIM-Signature: {}{}",
- ucl_object_tostring(res), line_end);
+ ucl_object_tostring(res), line_end);
}
else if (res && res->type == UCL_ARRAY) {
it = nullptr;
while ((cur = ucl_object_iterate (res, &it, true)) != nullptr) {
fmt::format_to(std::back_inserter(added_headers), "DKIM-Signature: {}{}",
- ucl_object_tostring(cur), line_end);
+ ucl_object_tostring(cur), line_end);
}
}
/* We also append json data as a specific header */
if (json) {
json_header = ucl_object_emit(result,
- compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_JSON);
+ compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_JSON);
}
else {
json_header = ucl_object_emit(result,
- compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_CONFIG);
+ compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_CONFIG);
}
auto *json_header_encoded = rspamd_encode_base64_fold(json_header,
- strlen((char *)json_header), 60, nullptr, nl_type);
+ strlen((char *)json_header), 60, nullptr, nl_type);
free(json_header);
fmt::format_to(std::back_inserter(added_headers),
- "X-Spam-Result: {}{}",
- json_header_encoded, line_end);
+ "X-Spam-Result: {}{}",
+ json_header_encoded, line_end);
g_free(json_header_encoded);
}
}
else {
fmt::format_to(std::back_inserter(added_headers), "X-Spam-Scanner: {}{}",
- "rspamc " RVERSION, line_end);
+ "rspamc " RVERSION, line_end);
fmt::format_to(std::back_inserter(added_headers), "X-Spam-Scan-Time: {:.3f}{}",
- time, line_end);
+ time, line_end);
fmt::format_to(std::back_inserter(added_headers), "X-Spam-Error: {}{}",
- err->message, line_end);
+ err->message, line_end);
}
/* Write message */
}
if (!g_spawn_async_with_pipes(nullptr, eargv, nullptr,
- static_cast<GSpawnFlags>(G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD), nullptr, nullptr, &cld,
- &infd, &outfd, &errfd, &exec_err)) {
+ 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);
g_error_free(exec_err);
if (json) {
ucl_out = (char *)ucl_object_emit(result,
- compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_JSON);
+ compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_JSON);
}
else {
ucl_out = (char *)ucl_object_emit(result,
- compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_CONFIG);
+ compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_CONFIG);
}
fmt::print(out, "{}", ucl_out);
free(ucl_out);
if (cmd.need_input && !json) {
if (!compact && !humanreport) {
fmt::print(out, "Results for file: {} ({:.3} seconds)\n",
- emphasis_argument(cbdata->filename), diff);
+ emphasis_argument(cbdata->filename), diff);
}
}
else {
if (!compact && !json && !humanreport) {
fmt::print(out, "Results for command: {} ({:.3} seconds)\n",
- emphasis_argument(cmd.name), diff);
+ emphasis_argument(cmd.name), diff);
}
}
if (ucl_reply || cmd.command_output_func == nullptr) {
if (cmd.need_input) {
ucl_object_insert_key(result,
- ucl_object_fromstring(cbdata->filename.c_str()),
- "filename", 0,
- false);
+ ucl_object_fromstring(cbdata->filename.c_str()),
+ "filename", 0,
+ false);
}
ucl_object_insert_key(result,
- ucl_object_fromdouble(diff),
- "scan_time", 0,
- false);
+ ucl_object_fromdouble(diff),
+ "scan_time", 0,
+ false);
char *ucl_out;
if (json) {
ucl_out = (char *)ucl_object_emit(result,
- compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_JSON);
+ compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_JSON);
}
else {
ucl_out = (char *)ucl_object_emit(result,
- compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_CONFIG);
+ compact ? UCL_EMIT_JSON_COMPACT : UCL_EMIT_CONFIG);
}
fmt::print(out, "{}", ucl_out);
if (body) {
fmt::print(out, "\nNew body:\n{}\n",
- std::string_view{body, bodylen});
+ std::string_view{body, bodylen});
}
ucl_object_unref(result);
}
- conn = rspamd_client_init(http_ctx, ev_base, hostbuf.c_str(), port, timeout, key);
+ conn = rspamd_client_init(http_ctx, ev_base, hostbuf.c_str(), port, timeout, pubkey);
if (conn != nullptr) {
auto *cbdata = new rspamc_callback_data;
if (cmd.need_input) {
rspamd_client_command(conn, cmd.path, attrs, in, rspamc_client_cb,
- cbdata, compressed, dictionary, cbdata->filename.c_str(), &err);
+ cbdata, compressed, dictionary, cbdata->filename.c_str(), &err);
}
else {
rspamd_client_command(conn,
- cmd.path,
- attrs,
- nullptr,
- rspamc_client_cb,
- cbdata,
- compressed,
- dictionary,
- cbdata->filename.c_str(),
- &err);
+ cmd.path,
+ attrs,
+ nullptr,
+ rspamc_client_cb,
+ cbdata,
+ compressed,
+ dictionary,
+ cbdata->filename.c_str(),
+ &err);
}
}
else {
fmt::print(stderr, "cannot connect to {}: {}\n", connect_str,
- strerror(errno));
+ strerror(errno));
exit(EXIT_FAILURE);
}
}
}
# endif
#else
-# if defined(NAME_MAX)
+ # if defined(NAME_MAX)
name_max = (NAME_MAX > 255) ? NAME_MAX : 255;
# else
# error "buffer size for readdir_r cannot be determined"
fpath.clear();
fmt::format_to(std::back_inserter(fpath), "{}{}{}",
- name, G_DIR_SEPARATOR,
- pentry->d_name);
+ name, G_DIR_SEPARATOR,
+ pentry->d_name);
/* Check exclude */
auto **ex = exclude_compiled;
#if GLIB_MAJOR_VERSION >= 2 && GLIB_MINOR_VERSION >= 70
if (g_pattern_spec_match(*ex, fpath.size(), fpath.c_str(), nullptr)) {
#else
- if (g_pattern_match(*ex, fpath.size(), fpath.c_str(), nullptr)) {
+ if (g_pattern_match(*ex, fpath.size(), fpath.c_str(), nullptr)) {
#endif
skip = true;
break;
/* Fallback to lstat */
if (lstat(fpath.c_str(), &st) == -1) {
fmt::print(stderr, "cannot stat file {}: {}\n",
- fpath, strerror(errno));
+ fpath, strerror(errno));
continue;
}
auto *in = fopen(fpath.c_str(), "r");
if (in == nullptr) {
fmt::print(stderr, "cannot open file {}: {}\n",
- fpath, strerror(errno));
+ fpath, strerror(errno));
continue;
}
if (exclude_compiled[i] == nullptr) {
fmt::print(stderr, "Invalid glob pattern: {}\n",
- exclude_patterns[i]);
+ exclude_patterns[i]);
exit(EXIT_FAILURE);
}
}
http_config.kp_cache_size_server = 0;
http_config.user_agent = user_agent;
http_ctx = rspamd_http_context_create_config(&http_config,
- event_loop, nullptr);
+ event_loop, nullptr);
/* Ignore sigpipe */
struct sigaction sigpipe_act;
auto res = 0;
if (waitpid(cld, &res, 0) == -1) {
fmt::print(stderr, "Cannot wait for {}: {}", cld,
- strerror(errno));
+ strerror(errno));
ret = errno;
}
projects / thirdparty / rspamd.git / commitdiff
