diff options
Diffstat (limited to 'src/lua/lua_task.c')
| -rw-r--r-- | src/lua/lua_task.c | 7295 |
1 files changed, 7295 insertions, 0 deletions
diff --git a/src/lua/lua_task.c b/src/lua/lua_task.c new file mode 100644 index 0000000..7278602 --- /dev/null +++ b/src/lua/lua_task.c @@ -0,0 +1,7295 @@ +/* + * Copyright 2023 Vsevolod Stakhov + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "lua_common.h" +#include "lua_url.h" + +#include "message.h" +#include "images.h" +#include "archives.h" +#include "utlist.h" +#include "unix-std.h" +#include "libmime/smtp_parsers.h" +#include "libserver/mempool_vars_internal.h" +#include "libserver/dkim.h" +#include "libserver/task.h" +#include "libserver/cfg_file_private.h" +#include "libmime/scan_result_private.h" +#include "libstat/stat_api.h" +#include "libserver/maps/map_helpers.h" + +#include <math.h> +#include "libmime/received.h" + +/*** + * @module rspamd_task + * This module provides routines for tasks manipulation in rspamd. Tasks usually + * represent messages being scanned, and this API provides access to such elements + * as headers, symbols, metrics and so on and so forth. Normally, task objects + * are passed to the lua callbacks allowing to check specific properties of messages + * and add the corresponding symbols to the scan's results. +@example +rspamd_config.DATE_IN_PAST = function(task) + local dm = task:get_date{format = 'message', gmt = true} + local dt = task:get_date{format = 'connect', gmt = true} + -- A day + if dt - dm > 86400 then + return true + end + + return false +end + */ + +/* Task methods */ + +/*** + * @function rspamd_task.create([cfg]) + * Create a new empty task + * @return {rspamd_task} new task + */ +LUA_FUNCTION_DEF(task, create); +/*** + * @function rspamd_task.load_from_file(filename[, cfg]) + * Loads a message from specific file + * @return {boolean,rspamd_task|error} status + new task or error message + */ +LUA_FUNCTION_DEF(task, load_from_file); +/*** + * @function rspamd_task.load_from_string(message[, cfg]) + * Loads a message from specific file + * @return {boolean,rspamd_task|error} status + new task or error message + */ +LUA_FUNCTION_DEF(task, load_from_string); +/*** + * @method task:get_message() + * Returns task raw message content as opaque text + * @return {rspamd_text} task raw content + */ +LUA_FUNCTION_DEF(task, get_message); +/*** + * @method task:set_message(msg) + * Updates task message with another message; It also parses a message to + * fill the internal structures. + * Input might be a string, a lua_text or a table of the former stuff. + * @param {string/text/table} msg new message to set + * @return {boolean,number} if a message has been set + its raw size + */ +LUA_FUNCTION_DEF(task, set_message); +/*** + * @method task:process_message() + * Parses message + */ +LUA_FUNCTION_DEF(task, process_message); +/*** + * @method task:get_cfg() + * Get configuration object for a task. + * @return {rspamd_config} (config.md)[configuration object] for the task + */ +LUA_FUNCTION_DEF(task, get_cfg); +LUA_FUNCTION_DEF(task, set_cfg); +LUA_FUNCTION_DEF(task, destroy); +/*** + * @method task:get_mempool() + * Returns memory pool valid for a lifetime of task. It is used internally by + * many rspamd routines. + * @return {rspamd_mempool} memory pool object + */ +LUA_FUNCTION_DEF(task, get_mempool); +/*** + * @method task:get_session() + * Returns asynchronous session object that is used by many rspamd asynchronous + * utilities internally. + * @return {rspamd_session} session object + */ +LUA_FUNCTION_DEF(task, get_session); +/*** + * @method task:set_session(session) + * Sets new async session for a task + */ +LUA_FUNCTION_DEF(task, set_session); +/*** + * @method task:get_ev_base() + * Return asynchronous event base for using in callbacks and resolver. + * @return {rspamd_ev_base} event base + */ +LUA_FUNCTION_DEF(task, get_ev_base); +/*** + * @method task:get_worker() + * Returns a worker object associated with the task + * @return {rspamd_worker} worker object + */ +LUA_FUNCTION_DEF(task, get_worker); +/*** + * @method task:insert_result([enforce_symbol,]symbol, weight[, option1, ...]) + * Insert specific symbol to the tasks scanning results assigning the initial + * weight to it. + * @param {boolean} enforce_symbol if represented and true, then insert symbol even if it is not registered in the metric + * @param {string} symbol symbol to insert + * @param {number} weight initial weight (this weight is multiplied by the metric weight) + * @param {string} options list of optional options attached to a symbol inserted +@example +local function cb(task) + if task:get_header('Some header') then + task:insert_result('SOME_HEADER', 1.0, 'Got some header') + end +end + */ +LUA_FUNCTION_DEF(task, insert_result); +/*** + * @method task:insert_result_named(shadow_result, [enforce_symbol,]symbol, weight[, option1, ...]) + * Insert specific symbol to the tasks scanning results assigning the initial + * weight to it. + * @param {string} shadow_result name of shadow result + * @param {boolean} enforce_symbol if represented and true, then insert symbol even if it is not registered in the metric + * @param {string} symbol symbol to insert + * @param {number} weight initial weight (this weight is multiplied by the metric weight) + * @param {string} options list of optional options attached to a symbol inserted + */ +LUA_FUNCTION_DEF(task, insert_result_named); + +/*** + * @method task:adjust_result(symbol, score[, option1, ...]) + * Alters the existing symbol's score to a new score. It is not affected by + * metric score or grow factor. You can also add new options + * using this method. Symbol must be already inserted into metric or an error + * will be emitted. + * @param {string} symbol symbol to adjust + * @param {number} score this value is NOT multiplied by the metric score + * @param {string/table} options list of optional options attached to a symbol adjusted + */ +LUA_FUNCTION_DEF(task, adjust_result); + +/*** + * @method task:remove_result(symbol[, shadow_result]) + * Removes the symbol from a named or unnamed/default result + * @param {string} symbol symbol to remove + * @param {string} shadow_result name of shadow result + * @return {boolean} true if a symbol has been removed + */ +LUA_FUNCTION_DEF(task, remove_result); +/*** + * @method task:set_pre_result(action, [message, [module], [score], [priority], [flags]) + * Sets pre-result for a task. It is used in pre-filters to specify early result + * of the task scanned. If a pre-filter sets some result, then further processing + * may be skipped. For selecting action it is possible to use global table + * `rspamd_actions` or a string value: + * + * - `reject`: reject message permanently + * - `add header`: add spam header + * - `rewrite subject`: rewrite subject to spam subject + * - `greylist`: greylist message + * - `accept` or `no action`: whitelist message + * + * This function also accepts a table from Rspamd 2.6 with the following keys: + * - action: string required + * - message: string + * - module: string + * - score: number + * - priority: integer + * - flags: flags string + * - result: named result if needed + * + * @param {rspamd_action or string} action a numeric or string action value + * @param {string} message action message + * @param {string} module optional module name + * @param {number/nil} score optional explicit score + * @param {number/nil} priority optional explicit priority + * @param {string/nil} flags optional flags (e.g. 'least' for least action) +@example +local function cb(task) + local gr = task:get_header('Greylist') + if gr and gr == 'greylist' then + task:set_pre_result('soft reject', 'Greylisting required') + end +end + */ +LUA_FUNCTION_DEF(task, set_pre_result); + +/*** + * @method task:has_pre_result() + * Returns true if task has some pre-result being set. + * If result has been set this function also returns pre result action, + * message and module as strings in this order. + * + * @return {boolean,[string,string,string]} true if task has some pre-result being set + */ +LUA_FUNCTION_DEF(task, has_pre_result); +/*** + * @method task:append_message(message, [category]) + * Adds a message to scanning output. + * @param {string} message + * @param {category} message category +@example +local function cb(task) + task:append_message('Example message') +end + */ +LUA_FUNCTION_DEF(task, append_message); +/*** + * @method task:get_urls([need_emails|list_protos][, need_images]) + * Get all URLs found in a message. Telephone urls and emails are not included unless explicitly asked in `list_protos` + * @param {boolean} need_emails if `true` then return also email urls, this can be a comma separated string of protocols desired or a table (e.g. `mailto` or `telephone`) + * @param {boolean} need_images return urls from images (<img src=...>) as well + * @return {table rspamd_url} list of all urls found +@example +local function phishing_cb(task) + local urls = task:get_urls({'https', 'http'}); + + if urls then + for _,url in ipairs(urls) do + if url:is_phished() then + return true + end + end + end + return false +end + */ +LUA_FUNCTION_DEF(task, get_urls); +/*** + * @method task:get_urls_filtered([{flags_include}, [{flags_exclude}]], [{protocols_mask}]) + * Get urls managed by either exclude or include flags list + * - If flags include are nil then all but excluded urls are returned + * - If flags exclude are nil then only included explicitly urls are returned + * - If both parameters are nil then all urls are included + * @param {table} flags_include included flags + * @param {table} flags_exclude excluded flags + * @param {table} protocols_mask include only specific protocols + * @return {table rspamd_url} list of urls matching conditions + */ +LUA_FUNCTION_DEF(task, get_urls_filtered); +/*** + * @method task:has_urls([need_emails]) + * Returns 'true' if a task has urls listed + * @param {boolean} need_emails if `true` then return also email urls + * @return {boolean} true if a task has urls (urls or emails if `need_emails` is true) + */ +LUA_FUNCTION_DEF(task, has_urls); +/*** + * @method task:inject_url(url) + * Inserts an url into a task (useful for redirected urls) + * @param {lua_url} url url to inject + */ +LUA_FUNCTION_DEF(task, inject_url); +/*** + * @method task:get_content() + * Get raw content for the specified task + * @return {text} the data contained in the task + */ +LUA_FUNCTION_DEF(task, get_content); + +/*** + * @method task:get_filename() + * Returns filename for a specific task + * @return {string|nil} filename or nil if unknown + */ +LUA_FUNCTION_DEF(task, get_filename); + +/*** + * @method task:get_rawbody() + * Get raw body for the specified task + * @return {text} the data contained in the task + */ +LUA_FUNCTION_DEF(task, get_rawbody); + +/*** + * @method task:get_emails() + * Get all email addresses found in a message. + * @return {table rspamd_url} list of all email addresses found + */ +LUA_FUNCTION_DEF(task, get_emails); +/*** + * @method task:get_text_parts() + * Get all text (and HTML) parts found in a message + * @return {table rspamd_text_part} list of text parts + */ +LUA_FUNCTION_DEF(task, get_text_parts); +/*** + * @method task:get_parts() + * Get all mime parts found in a message + * @return {table rspamd_mime_part} list of mime parts + */ +LUA_FUNCTION_DEF(task, get_parts); +/*** + * @method task:get_meta_words([how='stem']) + * Get meta words from task (subject and displayed names) + * - `stem`: stemmed words (default) + * - `norm`: normalised words (utf normalised + lowercased) + * - `raw`: raw words in utf (if possible) + * - `full`: list of tables, each table has the following fields: + * - [1] - stemmed word + * - [2] - normalised word + * - [3] - raw word + * - [4] - flags (table of strings) + */ +LUA_FUNCTION_DEF(task, get_meta_words); +/*** + * @method task:get_request_header(name) + * Get value of a HTTP request header. + * @param {string} name name of header to get + * @return {rspamd_text} value of an HTTP header + */ +LUA_FUNCTION_DEF(task, get_request_header); +/*** + * @method task:set_request_header(name, value) + * Set value of a HTTP request header. If value is omitted, then a header is removed + * @param {string} name name of header to get + * @param {rspamd_text/string} value new header's value + */ +LUA_FUNCTION_DEF(task, set_request_header); +/*** + * @method task:get_subject() + * Returns task subject (either from the protocol override or from a header) + * @return {string} value of a subject (decoded) + */ +LUA_FUNCTION_DEF(task, get_subject); +/*** + * @method task:get_header(name[, case_sensitive]) + * Get decoded value of a header specified with optional case_sensitive flag. + * By default headers are searched in caseless matter. + * @param {string} name name of header to get + * @param {boolean} case_sensitive case sensitiveness flag to search for a header + * @return {string} decoded value of a header + */ +LUA_FUNCTION_DEF(task, get_header); +/*** + * @method task:has_header(name[, case_sensitive]) + * Get decoded value of a header specified with optional case_sensitive flag. + * By default headers are searched in the case insensitive matter. + * @param {string} name name of header to get + * @param {boolean} case_sensitive case sensitiveness flag to search for a header + * @return {boolean} true if header exists + */ +LUA_FUNCTION_DEF(task, has_header); +/*** + * @method task:get_header_raw(name[, case_sensitive]) + * Get raw value of a header specified with optional case_sensitive flag. + * By default headers are searched in caseless matter. + * @param {string} name name of header to get + * @param {boolean} case_sensitive case sensitiveness flag to search for a header + * @return {string} raw value of a header + */ +LUA_FUNCTION_DEF(task, get_header_raw); +/*** + * @method task:get_header_full(name[, case_sensitive[, need_modified]]) + * Get raw value of a header specified with optional case_sensitive flag. + * By default headers are searched in caseless matter. This method returns more + * information about the header as a list of tables with the following structure: + * + * - `name` - name of a header + * - `value` - raw value of a header + * - `decoded` - decoded value of a header + * - `tab_separated` - `true` if a header and a value are separated by `tab` character + * - `empty_separator` - `true` if there are no separator between a header and a value + * @param {string} name name of header to get + * @param {boolean} case_sensitive case sensitiveness flag to search for a header + * @param {boolean} need_modified return a modified value of a header if presented + * @return {list of tables} all values of a header as specified above +@example +function check_header_delimiter_tab(task, header_name) + for _,rh in ipairs(task:get_header_full(header_name)) do + if rh['tab_separated'] then return true end + end + return false +end + */ +LUA_FUNCTION_DEF(task, get_header_full); +/*** + * @method task:get_header_count(name[, case_sensitive]) + * Lightweight version if you need just a header's count + * * By default headers are searched in caseless matter. + * @param {string} name name of header to get + * @param {boolean} case_sensitive case sensitiveness flag to search for a header + * @return {number} number of header's occurrences or 0 if not found + */ +LUA_FUNCTION_DEF(task, get_header_count); +/*** + * @method task:get_raw_headers() + * Get all undecoded headers of a message as a string + * @return {rspamd_text} all raw headers for a message as opaque text + */ +LUA_FUNCTION_DEF(task, get_raw_headers); + +/*** + * @method task:get_headers([need_modified=false]) + * Get all headers of a message in the same format as get_header_full + * @return {table of headers data} all headers for a message + */ +LUA_FUNCTION_DEF(task, get_headers); + +/*** + * @method task:modify_header(name, mods) + * Modify an existing or non-existing header with the name `name` + * Mods is a table with the following structure: + * { + * "add" = { {order, value}, {order, value} }, + * "remove" = {order, order, order} + * } + * Modifications are evaluated in order: remove, add, so headers are first + * removed (if any) and then added + * Order in remove starts from 1, where 0 means 'remove all', and negative value means + * remove from the end + * Order in addition means addition from the top: 0 means the most top header, 1 one after, etc + * negative order means addition to the end, e.g. -1 is appending header. + * @return {bool} true if header could be modified (always true unless we don't have an unparsed message) + */ +LUA_FUNCTION_DEF(task, modify_header); + +/*** + * @method task:get_received_headers() + * Returns a list of tables of parsed received headers. A tables returned have + * the following structure: + * + * - `from_hostname` - string that represents hostname provided by a peer + * - `from_ip` - string representation of sending IP address + * - `real_hostname` - hostname as resolved by MTA + * - `real_ip` - rspamd_ip object representing sending IP address + * - `by_hostname` - MTA hostname + * - `proto` - protocol, e.g. ESMTP or ESMTPS + * - `timestamp` - received timestamp + * - `for` - for value (unparsed mailbox) + * + * Please note that in some situations rspamd cannot parse all the fields of received headers. + * In that case you should check all strings for validity. + * @return {table of tables} list of received headers described above + */ +LUA_FUNCTION_DEF(task, get_received_headers); +/*** + * @method task:get_queue_id() + * Returns queue ID of the message being processed. + */ +LUA_FUNCTION_DEF(task, get_queue_id); +/*** + * @method task:get_uid() + * Returns ID of the task being processed. + */ +LUA_FUNCTION_DEF(task, get_uid); +/*** + * @method task:get_resolver() + * Returns ready to use rspamd_resolver object suitable for making asynchronous DNS requests. + * @return {rspamd_resolver} resolver object associated with the task's session + * @example +local logger = require "rspamd_logger" + +local function task_cb(task) + local function dns_cb(resolver, to_resolve, results, err) + -- task object is available due to closure + task:inc_dns_req() + if results then + logger.info(string.format('<%s> [%s] resolved for symbol: %s', + task:get_message_id(), to_resolve, 'EXAMPLE_SYMBOL')) + task:insert_result('EXAMPLE_SYMBOL', 1) + end + end + local r = task:get_resolver() + r:resolve_a(task:get_session(), task:get_mempool(), 'example.com', dns_cb) +end + */ +LUA_FUNCTION_DEF(task, get_resolver); +/*** + * @method task:set_resolver(resolver) + * Sets rspamd_resolver for a specified task. + */ +LUA_FUNCTION_DEF(task, set_resolver); +/*** +* @method task:inc_dns_req() +* Increment number of DNS requests for the task. Is used just for logging purposes. +*/ +LUA_FUNCTION_DEF(task, inc_dns_req); +/*** + * @method task:get_dns_req() + * Get number of dns requests being sent in the task + * @return {number} number of DNS requests + */ +LUA_FUNCTION_DEF(task, get_dns_req); + +/*** + * @method task:has_recipients([type]) + * Return true if there are SMTP or MIME recipients for a task. + * @param {integer|string} type if specified has the following meaning: `0` or `any` means try SMTP recipients and fallback to MIME if failed, `1` or `smtp` means checking merely SMTP recipients and `2` or `mime` means MIME recipients only + * @return {bool,integer} `true` if there are recipients of the following type and a number of such a recipients excluding artificial ones + */ +LUA_FUNCTION_DEF(task, has_recipients); + +/*** + * @method task:get_recipients([type]) + * Return SMTP or MIME recipients for a task. This function returns list of internet addresses each one is a table with the following structure: + * + * - `name` - name of internet address in UTF8, e.g. for `Vsevolod Stakhov <blah@foo.com>` it returns `Vsevolod Stakhov` + * - `addr` - address part of the address + * - `user` - user part (if present) of the address, e.g. `blah` + * - `domain` - domain part (if present), e.g. `foo.com` + * @param {integer|string} type if specified has the following meaning: `0` or `any` means try SMTP recipients and fallback to MIME if failed, `1` or `smtp` means checking merely SMTP recipients and `2` or `mime` means MIME recipients only + * @return {list of addresses} list of recipients or `nil` + */ +LUA_FUNCTION_DEF(task, get_recipients); + +/*** + * @method task:get_principal_recipient() + * Returns a single string with so called `principal recipient` for a message. The order + * of check is the following: + * + * - deliver-to request header + * - the first recipient (envelope) + * - the first recipient (mime) + * @return {string} principal recipient + */ +LUA_FUNCTION_DEF(task, get_principal_recipient); +/*** + * @method task:get_reply_sender() + * Returns a single string with address that should be used to reply on a message + * + * - reply-to header + * - from header + * - smtp from as a last resort + * @return {address} email address + */ +LUA_FUNCTION_DEF(task, get_reply_sender); + +/*** + * @method task:set_recipients([type], {rcpt1, rcpt2...}, [how='add']) + * Sets recipients for a task. This function accepts table that will be converted to the address. + * If some fields are missing they are subsequently reconstructed by this function. E.g. if you + * specify 'user' and 'domain', then address and raw string will be reconstructed + * + * - `name` - name of internet address in UTF8, e.g. for `Vsevolod Stakhov <blah@foo.com>` it returns `Vsevolod Stakhov` + * - `addr` - address part of the address + * - `user` - user part (if present) of the address, e.g. `blah` + * - `domain` - domain part (if present), e.g. `foo.com` + * @param {integer|string} type if specified has the following meaning: `0` or `any` means try SMTP recipients and fallback to MIME if failed, `1` or `smtp` means checking merely SMTP recipients and `2` or `mime` means MIME recipients only + * @param {list of tables} recipients recipients to set + * @param {string} how define how to set recipients: `rewrite` - rewrite existing recipients, `alias` - treat existing recipients as aliased recipients, `add` - add new recipients + * @return {boolean} result of the operation + */ +LUA_FUNCTION_DEF(task, set_recipients); + +/*** + * @method task:has_from([type]) + * Return true if there is SMTP or MIME sender for a task. + * @param {integer|string} type if specified has the following meaning: `0` or `any` means try SMTP recipients and fallback to MIME if failed, `1` or `smtp` means checking merely SMTP recipients and `2` or `mime` means MIME recipients only + * @return {bool} `true` if there is sender of the following type + */ +LUA_FUNCTION_DEF(task, has_from); + +/*** + * @method task:get_from([type]) + * Return SMTP or MIME sender for a task. This function returns an internet address which one is a table with the following structure: + * + * - `raw` - the original value without any processing + * - `name` - name of internet address in UTF8, e.g. for `Vsevolod Stakhov <blah@foo.com>` it returns `Vsevolod Stakhov` + * - `addr` - address part of the address + * - `user` - user part (if present) of the address, e.g. `blah` + * - `domain` - domain part (if present), e.g. `foo.com` + * - `flags` - table with following keys set to true if given condition fulfilled: + * - [valid] - valid SMTP address in conformity with https://tools.ietf.org/html/rfc5321#section-4.1. + * - [ip] - domain is IPv4/IPv6 address + * - [braced] - angled `<blah@foo.com>` address + * - [quoted] - quoted user part + * - [empty] - empty address + * - [backslash] - user part contains backslash + * - [8bit] - contains 8bit characters + * @param {integer|string} type if specified has the following meaning: `0` or `any` means try SMTP sender and fallback to MIME if failed, `1` or `smtp` means checking merely SMTP sender and `2` or `mime` means MIME `From:` only + * @return {address} sender or `nil` + */ +LUA_FUNCTION_DEF(task, get_from); + +/*** + * @method task:set_from(type, addr) + * Sets sender for a task. This function accepts table that will be converted to the address. + * If some fields are missing they are subsequently reconstructed by this function. E.g. if you + * specify 'user' and 'domain', then address and raw string will be reconstructed + * + * - `name` - name of internet address in UTF8, e.g. for `Vsevolod Stakhov <blah@foo.com>` it returns `Vsevolod Stakhov` + * - `addr` - address part of the address + * - `user` - user part (if present) of the address, e.g. `blah` + * - `domain` - domain part (if present), e.g. `foo.com` + * @param {integer|string} type if specified has the following meaning: `0` or `any` means try SMTP sender and fallback to MIME if failed, `1` or `smtp` means checking merely SMTP sender and `2` or `mime` means MIME `From:` only + * @param {table + * @return {boolean} success or not + */ +LUA_FUNCTION_DEF(task, set_from); +/*** + * @method task:get_user() + * Returns authenticated user name for this task if specified by an MTA. + * @return {string} username or nil + */ +LUA_FUNCTION_DEF(task, get_user); +/*** + * @method task:set_user([username]) + * Sets or resets (if username is not specified) authenticated user name for this task. + * @return {string} the previously set username or nil + */ +LUA_FUNCTION_DEF(task, set_user); +/*** + * @method task:get_from_ip() + * Returns [ip_addr](ip.md) object of a sender that is provided by MTA + * @return {rspamd_ip} ip address object + */ +LUA_FUNCTION_DEF(task, get_from_ip); +/*** + * @method task:set_from_ip(str) + * Set tasks's IP address based on the passed string + * @param {string} str string representation of ip + */ +LUA_FUNCTION_DEF(task, set_from_ip); +LUA_FUNCTION_DEF(task, get_from_ip_num); +/*** + * @method task:get_client_ip() + * Returns [ip_addr](ip.md) object of a client connected to rspamd (normally, it is an IP address of MTA) + * @return {rspamd_ip} ip address object + */ +LUA_FUNCTION_DEF(task, get_client_ip); +/*** + * @method task:get_helo() + * Returns the value of SMTP helo provided by MTA. + * @return {string} HELO value + */ +LUA_FUNCTION_DEF(task, get_helo); +LUA_FUNCTION_DEF(task, set_helo); +/*** + * @method task:get_hostname() + * Returns the value of sender's hostname provided by MTA + * @return {string} hostname value + */ +LUA_FUNCTION_DEF(task, get_hostname); +LUA_FUNCTION_DEF(task, set_hostname); +/*** + * @method task:get_images() + * Returns list of all images found in a task as a table of `rspamd_image`. + * Each image has the following methods: + * + * * `get_width` - return width of an image in pixels + * * `get_height` - return height of an image in pixels + * * `get_type` - return string representation of image's type (e.g. 'jpeg') + * * `get_filename` - return string with image's file name + * * `get_size` - return size in bytes + * @return {list of rspamd_image} images found in a message + */ +LUA_FUNCTION_DEF(task, get_images); +/*** + * @method task:get_archives() + * Returns list of all archives found in a task as a table of `rspamd_archive`. + * Each archive has the following methods available: + * + * * `get_files` - return list of strings with filenames inside archive + * * `get_files_full` - return list of tables with all information about files + * * `is_encrypted` - return true if an archive is encrypted + * * `get_type` - return string representation of image's type (e.g. 'zip') + * * `get_filename` - return string with archive's file name + * * `get_size` - return size in bytes + * @return {list of rspamd_archive} archives found in a message + */ +LUA_FUNCTION_DEF(task, get_archives); +/*** + * @method task:get_dkim_results() + * Returns list of all dkim check results as table of maps. Callee must ensure that + * dkim checks have been completed by adding dependency on `DKIM_TRACE` symbol. + * Fields in map: + * + * * `result` - string result of check: + * - `reject` + * - `allow` + * - `tempfail` + * - `permfail` + * - `not found` + * - `bad record` + * * `domain` - dkim domain + * * `selector` - dkim selector + * * `bhash` - short version of b tag (8 base64 symbols) + * * `fail_reason` - reason of failure (if applicable) + * @return {list of maps} dkim check results + */ +LUA_FUNCTION_DEF(task, get_dkim_results); +/*** + * @method task:get_symbol(name, [shadow_result_name]) + * Searches for a symbol `name` in all metrics results and returns a list of tables + * one per metric that describes the symbol inserted. + * Please note, that for using this function you need to ensure that the symbol + * being queried is already checked. This is guaranteed if there is a dependency + * between the caller symbol and the checked symbol (either virtual or real). + * Please check `rspamd_config:register_dependency` method for details. + * The symbols are returned as the list of the following tables: + * + * - `metric` - name of metric + * - `score` - score of a symbol in that metric + * - `options` - a table of strings representing options of a symbol + * - `group` - a group of symbol (or 'ungrouped') + * @param {string} name symbol's name + * @return {list of tables} list of tables or nil if symbol was not found + */ +LUA_FUNCTION_DEF(task, get_symbol); +/*** + * @method task:get_symbols_all() + * Returns array of symbols matched in default metric with all metadata + * @return {table} table of tables formatted as in `task:get_symbol()` except that `metric` is absent and `name` is added + */ +LUA_FUNCTION_DEF(task, get_symbols_all); +/*** + * @method task:get_symbols([shadow_result_name]) + * Returns array of all symbols matched for this task + * @return {table, table} table of strings with symbols names + table of theirs scores + */ +LUA_FUNCTION_DEF(task, get_symbols); + +/*** + * @method task:get_groups([need_private]) + * Returns a map [group -> group_score] for matched group. If `need_private` is + * unspecified, then the global option `public_groups_only` is used for default. + * @return {table, number} a map [group -> group_score] + */ +LUA_FUNCTION_DEF(task, get_groups); + +/*** + * @method task:get_symbols_numeric() + * Returns array of all symbols matched for this task + * @return {table|number, table|number} table of numbers with symbols ids + table of theirs scores + */ +LUA_FUNCTION_DEF(task, get_symbols_numeric); + +/*** + * @method task:get_symbols_tokens() + * Returns array of all symbols as statistical tokens + * @return {table|number} table of numbers + */ +LUA_FUNCTION_DEF(task, get_symbols_tokens); + +/*** + * @method task:process_ann_tokens(symbols, ann_tokens, offset, [min]) + * Processes ann tokens + * @param {table|string} symbols list of symbols in this profile + * @param {table|number} ann_tokens list of tokens (including metatokens) + * @param {integer} offset offset for symbols token (#metatokens) + * @param {number} min minimum value for symbols found (e.g. for 0 score symbols) + * @return nothing + */ +LUA_FUNCTION_DEF(task, process_ann_tokens); + +/*** + * @method task:has_symbol(name, [shadow_result_name]) + * Fast path to check if a specified symbol is in the task's results. + * Please note, that for using this function you need to ensure that the symbol + * being queried is already checked. This is guaranteed if there is a dependency + * between the caller symbol and the checked symbol (either virtual or real). + * Please check `rspamd_config:register_dependency` method for details. + * @param {string} name symbol's name + * @return {boolean} `true` if symbol has been found + */ +LUA_FUNCTION_DEF(task, has_symbol); +/*** + * @method task:enable_symbol(name) + * Enable specified symbol for this particular task + * @param {string} name symbol's name + * @return {boolean} `true` if symbol has been found + */ +LUA_FUNCTION_DEF(task, enable_symbol); +/*** + * @method task:disable_symbol(name) + * Disable specified symbol for this particular task + * @param {string} name symbol's name + * @return {boolean} `true` if symbol has been found + */ +LUA_FUNCTION_DEF(task, disable_symbol); +/*** + * @method task:get_date(type[, gmt]) + * Returns timestamp for a connection or for a MIME message. This function can be called with a + * single table arguments with the following fields: + * + * * `format` - a format of date returned: + * - `message` - returns a mime date as integer (unix timestamp) + * - `connect` - returns a unix timestamp of a connection to rspamd + * * `gmt` - returns date in `GMT` timezone (normal for unix timestamps) + * + * By default this function returns connection time in numeric format. + * @param {string} type date format as described above + * @param {boolean} gmt gmt flag as described above + * @return {string/number} date representation according to format + * @example +rspamd_config.DATE_IN_PAST = function(task) + local dm = task:get_date{format = 'message', gmt = true} + local dt = task:get_date{format = 'connect', gmt = true} + -- A day + if dt - dm > 86400 then + return true + end + + return false +end + */ +LUA_FUNCTION_DEF(task, get_date); +/*** + * @method task:get_message_id() + * Returns message identifier from the `Message-ID` header. Angle brackets (`<>`) + * are stripped off if present. If a Message-ID header is missing `undef` is + * returned. + * @return {string} ID of the message + */ +LUA_FUNCTION_DEF(task, get_message_id); +/*** + * @method task:get_timeval([raw]) + * Returns the timestamp for a task start processing time. + * @param {boolean} raw if true then two float numbers are returned: task start timestamp and timeout event timestamp + * @return {table} table with fields as described in `struct timeval` in C + */ +LUA_FUNCTION_DEF(task, get_timeval); +/*** + * @method task:get_scan_time([set]) + * Returns 2 floating point numbers: scan real time and scan virtual time. + * If `set` is `true`, then the finishing time is also set (enabled by default). + * This function should be normally called on idempotent phase. + * @return {number,number} real and virtual times in seconds with floating point + */ +LUA_FUNCTION_DEF(task, get_scan_time); +/*** + * @method task:get_metric_result() + * Get full result of a metric as a table: + * - `score`: current score + * - `action`: current action as a string + * - `nnegative`: number of negative rules matched + * - `npositive`: number of positive rules matched + * - `positive_score`: total score for positive rules + * - `negative_score`: total score for negative rules + * - `passthrough`: set to true if message has a passthrough result + * @return {table} metric result + */ +LUA_FUNCTION_DEF(task, get_metric_result); +/*** + * @method task:get_metric_score(name) + * Get the current score of metric `name` (must be nil or 'default') . Should be used in idempotent filters only. + * @param {string} name name of a metric + * @return {number,number} 2 numbers containing the current score and required score of the metric + */ +LUA_FUNCTION_DEF(task, get_metric_score); +/*** + * @method task:get_metric_action(name) + * Get the current action of metric `name` (must be nil or 'default'). Should be used in idempotent filters only. + * @param {string} name name of a metric + * @return {string} the current action of the metric as a string + */ +LUA_FUNCTION_DEF(task, get_metric_action); +/*** + * @method task:set_metric_score(name, score) + * Set the current score of metric `name`. Should be used in post-filters only. + * @param {string} name name of a metric + * @param {number} score the current score of the metric + */ +LUA_FUNCTION_DEF(task, set_metric_score); +/*** + * @method task:set_metric_subject(subject) + * Set the subject in the default metric + * @param {string} subject subject to set + */ +LUA_FUNCTION_DEF(task, set_metric_subject); + +/*** + * @method task:learn(is_spam[, classifier) + * Learn classifier `classifier` with the task. If `is_spam` is true then message + * is learnt as spam. Otherwise HAM is learnt. By default, this function learns + * `bayes` classifier. + * @param {boolean} is_spam learn spam or ham + * @param {string} classifier classifier's name + * @return {boolean} `true` if classifier has been learnt successfully + */ +LUA_FUNCTION_DEF(task, learn); +/*** + * @method task:set_settings(obj) + * Set users settings object for a task. The format of this object is described + * [here](https://rspamd.com/doc/configuration/settings.html). + * @param {any} obj any lua object that corresponds to the settings format + */ +LUA_FUNCTION_DEF(task, set_settings); + +/*** + * @method task:set_settings_id(id) + * Set users settings id for a task (must be registered previously) + * @available 2.0+ + * @param {number} id numeric id + * @return {boolean} true if settings id has been replaced from the existing one + */ +LUA_FUNCTION_DEF(task, set_settings_id); + +/*** + * @method task:get_settings() + * Gets users settings object for a task. The format of this object is described + * [here](https://rspamd.com/doc/configuration/settings.html). + * @return {lua object} lua object generated from UCL + */ +LUA_FUNCTION_DEF(task, get_settings); + +/*** + * @method task:lookup_settings(key) + * Gets users settings object with the specified key for a task. + * @param {string} key key to lookup + * @return {lua object} lua object generated from UCL + */ +LUA_FUNCTION_DEF(task, lookup_settings); + +/*** + * @method task:get_settings_id() + * Get numeric hash of settings id if specified for this task. 0 is returned otherwise. + * @return {number} settings-id hash + */ +LUA_FUNCTION_DEF(task, get_settings_id); + +/*** + * @method task:set_milter_reply(obj) + * Set special reply for milter + * @param {any} obj any lua object that corresponds to the settings format + * @example +task:set_milter_reply({ + add_headers = {['X-Lua'] = 'test'}, + -- 1 is the position of header to remove + remove_headers = {['DKIM-Signature'] = 1}, +}) + */ +LUA_FUNCTION_DEF(task, set_milter_reply); + +/*** + * @method task:process_re(params) + * Processes the specified regexp and returns number of captures (cached or new) + * Params is the table with the following fields (mandatory fields are marked with `*`): + * - `re`* : regular expression object + * - `type`*: type of regular expression: + * + `mime`: mime regexp + * + `header`: header regexp + * + `rawheader`: raw header expression + * + `rawmime`: raw mime regexp + * + `body`: raw body regexp + * + `url`: url regexp + * - `header`: for header and rawheader regexp means the name of header + * - `strong`: case sensitive match for headers + * @return {number} number of regexp occurrences in the task (limited by 255 so far) + */ +LUA_FUNCTION_DEF(task, process_regexp); + +/*** + * @method task:cache_set(key, value) + * Store some value to the task cache + * @param {string} key key to use + * @param {any} value any value (including functions and tables) + */ +LUA_FUNCTION_DEF(task, cache_set); +/*** + * @method task:cache_get(key) + * Returns cached value or nil if nothing is cached + * @param {string} key key to use + * @return {any} cached value + */ +LUA_FUNCTION_DEF(task, cache_get); + +/*** + * @method task:get_size() + * Returns size of the task in bytes (that includes headers + parts size) + * @return {number} size in bytes + */ +LUA_FUNCTION_DEF(task, get_size); + +/*** + * @method task:set_flag(flag_name[, set]) + * Set specific flag for task: + * + * - `no_log`: do not log task summary + * - `no_stat`: do not include task into scanned stats + * - `pass_all`: check all filters for task + * - `extended_urls`: output extended info about urls + * - `skip`: skip task processing + * - `learn_spam`: learn message as spam + * - `learn_ham`: learn message as ham + * - `broken_headers`: header data is broken for a message + * @param {string} flag to set + * @param {boolean} set set or clear flag (default is set) +@example +--[[ +For messages with undefined queue ID (scanned with rspamc or WebUI) +do not include results into statistics and do not log task summary +(it will not appear in the WebUI history as well). +]]-- + +-- Callback function to set flags +local function no_log_stat_cb(task) + if not task:get_queue_id() then + task:set_flag('no_log') + task:set_flag('no_stat') + end +end + +rspamd_config:register_symbol({ + name = 'LOCAL_NO_LOG_STAT', + type = 'postfilter', + callback = no_log_stat_cb +}) + */ +LUA_FUNCTION_DEF(task, set_flag); + + +/*** + * @method task:has_flag(flag_name) + * Checks for a specific flag in task: + * + * - `no_log`: do not log task summary + * - `no_stat`: do not include task into scanned stats + * - `pass_all`: check all filters for task + * - `extended_urls`: output extended info about urls + * - `skip`: skip task processing + * - `learn_spam`: learn message as spam + * - `learn_ham`: learn message as ham + * - `broken_headers`: header data is broken for a message + * @param {string} flag to check + * @return {boolean} true if flags is set + */ +LUA_FUNCTION_DEF(task, has_flag); + + +/*** + * @method task:get_flags() + * Get list of flags for task: + * + * - `no_log`: do not log task summary + * - `no_stat`: do not include task into scanned stats + * - `pass_all`: check all filters for task + * - `extended_urls`: output extended info about urls + * - `skip`: skip task processing + * - `learn_spam`: learn message as spam + * - `learn_ham`: learn message as ham + * - `broken_headers`: header data is broken for a message + * - `milter`: task is initiated by milter connection + * @return {array of strings} table with all flags as strings + */ +LUA_FUNCTION_DEF(task, get_flags); + +/*** + * @method task:get_digest() + * Returns message's unique digest (32 hex symbols) + * @return {string} hex digest + */ +LUA_FUNCTION_DEF(task, get_digest); + +/*** + * @method task:store_in_file([mode|table]) + * If task was loaded using file scan, then this method just returns its name, + * otherwise, a fresh temporary file is created and its name is returned. Default + * mode is 0600. To convert lua number to the octal mode you can use the following + * trick: `tonumber("0644", 8)`. The file is automatically removed when task is + * destroyed. + * + * If table argument is specified, the following extra fields are allowed: + * + * - `mode`: same as mode argument + * - `force_new`: always create a new file + * - `filename`: use specific filename instead of a temporary one + * - `tmpmask`: use specific tempmask, e.g. '/tmp/file-XXXXX', where XXXX will be replaced by some random letters + * - `keep`: do not remove file after task is processed + * + * @param {number} mode mode for new file + * @return {string} file name with task content + */ +LUA_FUNCTION_DEF(task, store_in_file); + +/*** + * @method task:get_protocol_reply([flags]) + * This method being called from a **postfilter** will return reply for a message + * as it is returned to a client. This method returns the Lua table corresponding + * to the UCL object. Flags is a table that specify which information should be + * there in a reply: + * + * - `basic`: basic info, such as message-id + * - `metrics`: metrics and symbols + * - `messages`: messages + * - `dkim`: dkim signature + * - `milter`: milter control block + * - `extra`: extra data, such as profiling + * - `urls`: list of all urls in a message + * + * @param {table} flags table of flags (default is all flags but `urls`) + * @return {table} ucl object corresponding to the reply + */ +LUA_FUNCTION_DEF(task, get_protocol_reply); + +/*** + * @method task:headers_foreach(callback, [params]) + * This method calls `callback` for each header that satisfies some condition. + * By default, all headers are iterated unless `callback` returns `true`. Nil or + * false means continue of iterations. + * Params could be as following: + * + * - `full`: header value is full table of all attributes @see task:get_header_full for details + * - `regexp`: return headers that satisfies the specified regexp + * @param {function} callback function from header name and header value + * @param {table} params optional parameters + */ +LUA_FUNCTION_DEF(task, headers_foreach); + +/*** + * @method task:disable_action(action) + * Disables some action for this task (e.g. 'greylist') + * + * @param {string} action action to disable + * @return {boolean} true if an action was enabled and is disabled after the method call + */ +LUA_FUNCTION_DEF(task, disable_action); + +/*** + * @method task:get_newlines_type() + * Returns the most frequent newlines type met in a task + * + * @return {string} "cr" for \r, "lf" for \n, "crlf" for \r\n + */ +LUA_FUNCTION_DEF(task, get_newlines_type); + +/*** + * @method task:get_stat_tokens() + * Returns list of tables the statistical tokens: + * - `data`: 64 bit number encoded as a string + * - `t1`: the first token (if any) + * - `t2`: the second token (if any) + * - `win`: window index + * - `flag`: table of strings: + * - `text`: text token + * - `meta`: meta token + * - `lua`: lua meta token + * - `exception`: exception + * - `subject`: subject token + * - `unigram`: unigram token + * + * @return {table of tables} + */ +LUA_FUNCTION_DEF(task, get_stat_tokens); + +/*** + * @method task:lookup_words(map, function({o, n, s, f}) ... end) + * Matches words in a task (including meta words) against some map (set, regexp and so on) + * and call the specified function with a table containing 4 values: + * - [1] - stemmed word + * - [2] - normalised word + * - [3] - raw word + * - [4] - flags (table of strings) + */ +LUA_FUNCTION_DEF(task, lookup_words); + +/** + * @method task:topointer() + * + * Returns raw C pointer (lightuserdata) associated with task. This might be + * broken with luajit and GC64, use with caution. + */ +LUA_FUNCTION_DEF(task, topointer); + +/** + * @method task:add_named_result(name, symbol_control_function) + * + * Adds a new named result for this task. symbol_control_function is a callback + * called with 3 parameters: + * `function(task, symbol, result_name)` and it should return boolean that + * specifies if this symbol should be added to this named result. + * @param {string} name for this result + * @param {function} symbol_control_function predicate for symbols + */ +LUA_FUNCTION_DEF(task, add_named_result); + +/** + * @method task:get_all_named_results() + * + * Returns all named results registered for the task as a table of strings + * @return {table|string} all named results starting from `default` + */ +LUA_FUNCTION_DEF(task, get_all_named_results); + +/*** + * @method task:get_dns_req() + * Get number of dns requests being sent in the task + * @return {number} number of DNS requests + */ +LUA_FUNCTION_DEF(task, get_dns_req); + +static const struct luaL_reg tasklib_f[] = { + LUA_INTERFACE_DEF(task, create), + LUA_INTERFACE_DEF(task, load_from_file), + LUA_INTERFACE_DEF(task, load_from_string), + {NULL, NULL}}; + +static const struct luaL_reg tasklib_m[] = { + LUA_INTERFACE_DEF(task, get_message), + LUA_INTERFACE_DEF(task, set_message), + LUA_INTERFACE_DEF(task, destroy), + LUA_INTERFACE_DEF(task, process_message), + LUA_INTERFACE_DEF(task, set_cfg), + LUA_INTERFACE_DEF(task, get_cfg), + LUA_INTERFACE_DEF(task, get_mempool), + LUA_INTERFACE_DEF(task, get_session), + LUA_INTERFACE_DEF(task, set_session), + LUA_INTERFACE_DEF(task, get_ev_base), + LUA_INTERFACE_DEF(task, get_worker), + LUA_INTERFACE_DEF(task, insert_result), + LUA_INTERFACE_DEF(task, insert_result_named), + LUA_INTERFACE_DEF(task, adjust_result), + LUA_INTERFACE_DEF(task, remove_result), + LUA_INTERFACE_DEF(task, set_pre_result), + LUA_INTERFACE_DEF(task, has_pre_result), + LUA_INTERFACE_DEF(task, append_message), + LUA_INTERFACE_DEF(task, has_urls), + LUA_INTERFACE_DEF(task, get_urls), + LUA_INTERFACE_DEF(task, get_urls_filtered), + LUA_INTERFACE_DEF(task, inject_url), + LUA_INTERFACE_DEF(task, get_content), + LUA_INTERFACE_DEF(task, get_filename), + LUA_INTERFACE_DEF(task, get_rawbody), + LUA_INTERFACE_DEF(task, get_emails), + LUA_INTERFACE_DEF(task, get_text_parts), + LUA_INTERFACE_DEF(task, get_parts), + LUA_INTERFACE_DEF(task, get_request_header), + LUA_INTERFACE_DEF(task, set_request_header), + LUA_INTERFACE_DEF(task, get_header), + LUA_INTERFACE_DEF(task, has_header), + LUA_INTERFACE_DEF(task, get_header_raw), + LUA_INTERFACE_DEF(task, get_header_full), + LUA_INTERFACE_DEF(task, get_header_count), + LUA_INTERFACE_DEF(task, get_raw_headers), + LUA_INTERFACE_DEF(task, get_headers), + LUA_INTERFACE_DEF(task, modify_header), + LUA_INTERFACE_DEF(task, get_received_headers), + LUA_INTERFACE_DEF(task, get_queue_id), + LUA_INTERFACE_DEF(task, get_uid), + LUA_INTERFACE_DEF(task, get_resolver), + LUA_INTERFACE_DEF(task, set_resolver), + LUA_INTERFACE_DEF(task, inc_dns_req), + LUA_INTERFACE_DEF(task, get_dns_req), + LUA_INTERFACE_DEF(task, has_recipients), + LUA_INTERFACE_DEF(task, get_recipients), + LUA_INTERFACE_DEF(task, set_recipients), + LUA_INTERFACE_DEF(task, get_principal_recipient), + LUA_INTERFACE_DEF(task, get_reply_sender), + LUA_INTERFACE_DEF(task, has_from), + LUA_INTERFACE_DEF(task, get_from), + LUA_INTERFACE_DEF(task, set_from), + LUA_INTERFACE_DEF(task, get_user), + LUA_INTERFACE_DEF(task, set_user), + {"get_addr", lua_task_get_from_ip}, + {"get_ip", lua_task_get_from_ip}, + {"get_from_addr", lua_task_get_from_ip}, + LUA_INTERFACE_DEF(task, get_from_ip), + LUA_INTERFACE_DEF(task, set_from_ip), + LUA_INTERFACE_DEF(task, get_from_ip_num), + LUA_INTERFACE_DEF(task, get_client_ip), + LUA_INTERFACE_DEF(task, get_subject), + LUA_INTERFACE_DEF(task, get_helo), + LUA_INTERFACE_DEF(task, set_helo), + LUA_INTERFACE_DEF(task, get_hostname), + LUA_INTERFACE_DEF(task, set_hostname), + LUA_INTERFACE_DEF(task, get_images), + LUA_INTERFACE_DEF(task, get_archives), + LUA_INTERFACE_DEF(task, get_dkim_results), + LUA_INTERFACE_DEF(task, get_symbol), + LUA_INTERFACE_DEF(task, get_symbols), + LUA_INTERFACE_DEF(task, get_symbols_all), + LUA_INTERFACE_DEF(task, get_symbols_numeric), + LUA_INTERFACE_DEF(task, get_symbols_tokens), + LUA_INTERFACE_DEF(task, get_groups), + LUA_INTERFACE_DEF(task, process_ann_tokens), + LUA_INTERFACE_DEF(task, has_symbol), + LUA_INTERFACE_DEF(task, enable_symbol), + LUA_INTERFACE_DEF(task, disable_symbol), + LUA_INTERFACE_DEF(task, get_date), + LUA_INTERFACE_DEF(task, get_message_id), + LUA_INTERFACE_DEF(task, get_timeval), + LUA_INTERFACE_DEF(task, get_scan_time), + LUA_INTERFACE_DEF(task, get_metric_result), + LUA_INTERFACE_DEF(task, get_metric_score), + LUA_INTERFACE_DEF(task, get_metric_action), + LUA_INTERFACE_DEF(task, set_metric_score), + LUA_INTERFACE_DEF(task, set_metric_subject), + LUA_INTERFACE_DEF(task, learn), + LUA_INTERFACE_DEF(task, set_settings), + LUA_INTERFACE_DEF(task, get_settings), + LUA_INTERFACE_DEF(task, lookup_settings), + LUA_INTERFACE_DEF(task, get_settings_id), + LUA_INTERFACE_DEF(task, set_settings_id), + LUA_INTERFACE_DEF(task, cache_get), + LUA_INTERFACE_DEF(task, cache_set), + LUA_INTERFACE_DEF(task, process_regexp), + LUA_INTERFACE_DEF(task, get_size), + LUA_INTERFACE_DEF(task, set_flag), + LUA_INTERFACE_DEF(task, get_flags), + LUA_INTERFACE_DEF(task, has_flag), + {"set_rmilter_reply", lua_task_set_milter_reply}, + LUA_INTERFACE_DEF(task, set_milter_reply), + LUA_INTERFACE_DEF(task, get_digest), + LUA_INTERFACE_DEF(task, store_in_file), + LUA_INTERFACE_DEF(task, get_protocol_reply), + LUA_INTERFACE_DEF(task, headers_foreach), + LUA_INTERFACE_DEF(task, disable_action), + LUA_INTERFACE_DEF(task, get_newlines_type), + LUA_INTERFACE_DEF(task, get_stat_tokens), + LUA_INTERFACE_DEF(task, get_meta_words), + LUA_INTERFACE_DEF(task, lookup_words), + LUA_INTERFACE_DEF(task, add_named_result), + LUA_INTERFACE_DEF(task, get_all_named_results), + LUA_INTERFACE_DEF(task, topointer), + {"__tostring", rspamd_lua_class_tostring}, + {NULL, NULL}}; + +/* Image methods */ +LUA_FUNCTION_DEF(image, get_width); +LUA_FUNCTION_DEF(image, get_height); +LUA_FUNCTION_DEF(image, get_type); +LUA_FUNCTION_DEF(image, get_filename); +LUA_FUNCTION_DEF(image, get_size); + +static const struct luaL_reg imagelib_m[] = { + LUA_INTERFACE_DEF(image, get_width), + LUA_INTERFACE_DEF(image, get_height), + LUA_INTERFACE_DEF(image, get_type), + LUA_INTERFACE_DEF(image, get_filename), + LUA_INTERFACE_DEF(image, get_size), + {"__tostring", rspamd_lua_class_tostring}, + {NULL, NULL}}; + +/* Archive methods */ +LUA_FUNCTION_DEF(archive, get_type); +LUA_FUNCTION_DEF(archive, get_files); +LUA_FUNCTION_DEF(archive, get_files_full); +/* TODO: Export archive flags as integers to use bitops for that */ +LUA_FUNCTION_DEF(archive, is_encrypted); +LUA_FUNCTION_DEF(archive, is_obfuscated); +LUA_FUNCTION_DEF(archive, is_unreadable); +LUA_FUNCTION_DEF(archive, get_filename); +LUA_FUNCTION_DEF(archive, get_size); + +static const struct luaL_reg archivelib_m[] = { + LUA_INTERFACE_DEF(archive, get_type), + LUA_INTERFACE_DEF(archive, get_files), + LUA_INTERFACE_DEF(archive, get_files_full), + LUA_INTERFACE_DEF(archive, is_encrypted), + LUA_INTERFACE_DEF(archive, is_obfuscated), + LUA_INTERFACE_DEF(archive, is_unreadable), + LUA_INTERFACE_DEF(archive, get_filename), + LUA_INTERFACE_DEF(archive, get_size), + {"__tostring", rspamd_lua_class_tostring}, + {NULL, NULL}}; + +/* Utility functions */ +struct rspamd_task * +lua_check_task(lua_State *L, gint pos) +{ + void *ud = rspamd_lua_check_udata(L, pos, "rspamd{task}"); + luaL_argcheck(L, ud != NULL, pos, "'task' expected"); + return ud ? *((struct rspamd_task **) ud) : NULL; +} + +struct rspamd_task * +lua_check_task_maybe(lua_State *L, gint pos) +{ + void *ud = rspamd_lua_check_udata_maybe(L, pos, "rspamd{task}"); + + return ud ? *((struct rspamd_task **) ud) : NULL; +} + +static struct rspamd_image * +lua_check_image(lua_State *L) +{ + void *ud = rspamd_lua_check_udata(L, 1, "rspamd{image}"); + luaL_argcheck(L, ud != NULL, 1, "'image' expected"); + return ud ? *((struct rspamd_image **) ud) : NULL; +} + +static struct rspamd_archive * +lua_check_archive(lua_State *L) +{ + void *ud = rspamd_lua_check_udata(L, 1, "rspamd{archive}"); + luaL_argcheck(L, ud != NULL, 1, "'archive' expected"); + return ud ? *((struct rspamd_archive **) ud) : NULL; +} + +static void +lua_task_set_cached(lua_State *L, struct rspamd_task *task, const gchar *key, + gint pos) +{ + LUA_TRACE_POINT; + khiter_t k; + + lua_pushvalue(L, pos); + + k = kh_get(rspamd_task_lua_cache, &task->lua_cache, (char *) key); + + if (G_UNLIKELY(k != kh_end(&task->lua_cache))) { + /* Unref previous value */ + luaL_unref(L, LUA_REGISTRYINDEX, kh_value(&task->lua_cache, k).ref); + } + else { + int r; + + k = kh_put(rspamd_task_lua_cache, &task->lua_cache, rspamd_mempool_strdup(task->task_pool, key), &r); + } + + kh_value(&task->lua_cache, k).ref = luaL_ref(L, LUA_REGISTRYINDEX); + kh_value(&task->lua_cache, k).id = GPOINTER_TO_UINT(task->message); +} + + +static gboolean +lua_task_get_cached(lua_State *L, struct rspamd_task *task, const gchar *key) +{ + LUA_TRACE_POINT; + khiter_t k; + + k = kh_get(rspamd_task_lua_cache, &task->lua_cache, (char *) key); + + if (k != kh_end(&task->lua_cache) && (kh_value(&task->lua_cache, k).id == GPOINTER_TO_UINT(task->message))) { + lua_rawgeti(L, LUA_REGISTRYINDEX, kh_value(&task->lua_cache, k).ref); + + return TRUE; + } + + return FALSE; +} + +/* Task methods */ +static int +lua_task_process_message(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gboolean enforce = FALSE; + + if (task != NULL) { + if (task->msg.len > 0) { + if (lua_isboolean(L, 2)) { + enforce = lua_toboolean(L, 2); + } + + if (rspamd_message_parse(task)) { + if (enforce || + (!(task->flags & RSPAMD_TASK_FLAG_SKIP_PROCESS) && + !(task->processed_stages & RSPAMD_TASK_STAGE_PROCESS_MESSAGE))) { + + lua_pushboolean(L, TRUE); + rspamd_message_process(task); + task->processed_stages |= RSPAMD_TASK_STAGE_PROCESS_MESSAGE; + } + else { + lua_pushboolean(L, FALSE); + } + } + else { + lua_pushboolean(L, FALSE); + } + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static int +lua_task_get_cfg(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_config **pcfg; + + if (task) { + pcfg = lua_newuserdata(L, sizeof(gpointer)); + rspamd_lua_setclass(L, "rspamd{config}", -1); + *pcfg = task->cfg; + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static int +lua_task_set_cfg(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + void *ud = rspamd_lua_check_udata(L, 2, "rspamd{config}"); + + if (task) { + luaL_argcheck(L, ud != NULL, 1, "'config' expected"); + task->cfg = ud ? *((struct rspamd_config **) ud) : NULL; + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static int +lua_task_destroy(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task != NULL) { + rspamd_task_free(task); + } + + return 0; +} + +static int +lua_task_get_message(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_lua_text *t; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + t = lua_newuserdata(L, sizeof(*t)); + rspamd_lua_setclass(L, "rspamd{text}", -1); + t->flags = 0; + t->start = task->msg.begin; + t->len = task->msg.len; + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static int +lua_task_set_message(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_lua_text *t; + struct rspamd_task *task = lua_check_task(L, 1); + gboolean message_set = FALSE; + + if (task) { + gsize final_len = 0; + gchar *buf = NULL; + + if (lua_type(L, 2) == LUA_TTABLE) { + /* Piecewise construct */ + guint vec_len = rspamd_lua_table_size(L, 2); + + + for (guint i = 0; i < vec_len; i++) { + lua_rawgeti(L, 2, i + 1); + + if (lua_type(L, -1) == LUA_TSTRING) { + gsize l; + + (void) lua_tolstring(L, -1, &l); + final_len += l; + } + else { + t = lua_check_text(L, -1); + + if (t) { + final_len += t->len; + } + } + + lua_pop(L, 1); + } + + if (final_len > 0) { + gchar *pos; + + buf = rspamd_mempool_alloc(task->task_pool, final_len); + pos = buf; + + for (guint i = 0; i < vec_len; i++) { + lua_rawgeti(L, 2, i + 1); + + if (lua_type(L, -1) == LUA_TSTRING) { + gsize l; + const gchar *s; + + s = lua_tolstring(L, -1, &l); + memcpy(pos, s, l); + pos += l; + } + else { + t = lua_check_text(L, -1); + + if (t) { + memcpy(pos, t->start, t->len); + pos += t->len; + } + } + + lua_pop(L, 1); + } + + task->flags |= RSPAMD_TASK_FLAG_MESSAGE_REWRITE; + task->msg.begin = buf; + task->msg.len = final_len; + message_set = TRUE; + } + } + else { + if (lua_type(L, 2) == LUA_TSTRING) { + const gchar *s; + + s = lua_tolstring(L, -1, &final_len); + buf = rspamd_mempool_alloc(task->task_pool, final_len); + memcpy(buf, s, final_len); + } + else { + t = lua_check_text(L, -1); + + if (t) { + final_len = t->len; + buf = rspamd_mempool_alloc(task->task_pool, final_len); + memcpy(buf, t->start, final_len); + } + } + + if (buf) { + task->msg.begin = buf; + task->msg.len = final_len; + task->flags |= RSPAMD_TASK_FLAG_MESSAGE_REWRITE; + message_set = TRUE; + } + } + + if (message_set) { + if (rspamd_message_parse(task)) { + rspamd_message_process(task); + lua_pushboolean(L, TRUE); + lua_pushinteger(L, final_len); + + return 2; + } + else { + lua_pushboolean(L, FALSE); + } + } + else { + lua_pushboolean(L, FALSE); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static void +lua_task_unmap_dtor(gpointer p) +{ + struct rspamd_task *task = (struct rspamd_task *) p; + + if (task->msg.begin) { + munmap((gpointer) task->msg.begin, task->msg.len); + } +} + +static void +lua_task_free_dtor(gpointer p) +{ + g_free(p); +} + +static gint +lua_task_load_from_file(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = NULL, **ptask; + const gchar *fname = luaL_checkstring(L, 1), *err = NULL; + struct rspamd_config *cfg = NULL; + gboolean res = FALSE; + gpointer map; + gsize sz; + + if (fname) { + + if (lua_type(L, 2) == LUA_TUSERDATA) { + gpointer p; + p = rspamd_lua_check_udata_maybe(L, 2, "rspamd{config}"); + + if (p) { + cfg = *(struct rspamd_config **) p; + } + } + + if (strcmp(fname, "-") == 0) { + /* Read from stdin */ + gint fd = STDIN_FILENO; + GString *data = g_string_sized_new(BUFSIZ); + gchar buf[BUFSIZ]; + gssize r; + + for (;;) { + r = read(fd, buf, sizeof(buf)); + + if (r == -1) { + err = strerror(errno); + break; + } + else if (r == 0) { + break; + } + else { + g_string_append_len(data, buf, r); + } + } + + task = rspamd_task_new(NULL, cfg, NULL, NULL, NULL, FALSE); + task->msg.begin = data->str; + task->msg.len = data->len; + rspamd_mempool_add_destructor(task->task_pool, + lua_task_free_dtor, data->str); + res = TRUE; + g_string_free(data, FALSE); /* Buffer is still valid */ + } + else { + map = rspamd_file_xmap(fname, PROT_READ, &sz, TRUE); + + if (!map) { + err = strerror(errno); + } + else { + task = rspamd_task_new(NULL, cfg, NULL, NULL, NULL, FALSE); + task->msg.begin = map; + task->msg.len = sz; + rspamd_mempool_add_destructor(task->task_pool, + lua_task_unmap_dtor, task); + res = TRUE; + } + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + lua_pushboolean(L, res); + + if (res) { + ptask = lua_newuserdata(L, sizeof(*ptask)); + *ptask = task; + rspamd_lua_setclass(L, "rspamd{task}", -1); + } + else { + if (err) { + lua_pushstring(L, err); + } + else { + lua_pushnil(L); + } + } + + return 2; +} + +static gint +lua_task_load_from_string(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = NULL, **ptask; + const gchar *str_message; + gsize message_len; + struct rspamd_config *cfg = NULL; + + str_message = luaL_checklstring(L, 1, &message_len); + + if (str_message) { + + if (lua_type(L, 2) == LUA_TUSERDATA) { + gpointer p; + p = rspamd_lua_check_udata_maybe(L, 2, "rspamd{config}"); + + if (p) { + cfg = *(struct rspamd_config **) p; + } + } + + task = rspamd_task_new(NULL, cfg, NULL, NULL, NULL, FALSE); + task->msg.begin = g_malloc(message_len); + memcpy((gchar *) task->msg.begin, str_message, message_len); + task->msg.len = message_len; + rspamd_mempool_add_destructor(task->task_pool, lua_task_free_dtor, + (gpointer) task->msg.begin); + } + else { + return luaL_error(L, "invalid arguments"); + } + + lua_pushboolean(L, true); + + ptask = lua_newuserdata(L, sizeof(*ptask)); + *ptask = task; + rspamd_lua_setclass(L, "rspamd{task}", -1); + + return 2; +} + +static gint +lua_task_create(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = NULL, **ptask; + struct rspamd_config *cfg = NULL; + struct ev_loop *ev_base = NULL; + + if (lua_type(L, 1) == LUA_TUSERDATA) { + gpointer p; + p = rspamd_lua_check_udata_maybe(L, 1, "rspamd{config}"); + + if (p) { + cfg = *(struct rspamd_config **) p; + } + } + + if (lua_type(L, 2) == LUA_TUSERDATA) { + gpointer p; + p = rspamd_lua_check_udata_maybe(L, 2, "rspamd{ev_base}"); + + if (p) { + ev_base = *(struct ev_loop **) p; + } + } + + task = rspamd_task_new(NULL, cfg, NULL, NULL, ev_base, FALSE); + task->flags |= RSPAMD_TASK_FLAG_EMPTY; + + ptask = lua_newuserdata(L, sizeof(*ptask)); + *ptask = task; + rspamd_lua_setclass(L, "rspamd{task}", -1); + + return 1; +} + +static int +lua_task_get_mempool(lua_State *L) +{ + LUA_TRACE_POINT; + rspamd_mempool_t **ppool; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task != NULL) { + ppool = lua_newuserdata(L, sizeof(rspamd_mempool_t *)); + rspamd_lua_setclass(L, "rspamd{mempool}", -1); + *ppool = task->task_pool; + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static int +lua_task_get_session(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_async_session **psession; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task != NULL) { + psession = lua_newuserdata(L, sizeof(void *)); + rspamd_lua_setclass(L, "rspamd{session}", -1); + *psession = task->s; + } + else { + return luaL_error(L, "invalid arguments"); + } + return 1; +} + +static int +lua_task_set_session(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_async_session *session = lua_check_session(L, 2); + struct rspamd_task *task = lua_check_task(L, 1); + + if (task != NULL && session != NULL) { + task->s = session; + } + else { + return luaL_error(L, "invalid arguments"); + } + return 1; +} + +static int +lua_task_get_ev_base(lua_State *L) +{ + LUA_TRACE_POINT; + struct ev_loop **pbase; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task != NULL) { + pbase = lua_newuserdata(L, sizeof(struct ev_loop *)); + rspamd_lua_setclass(L, "rspamd{ev_base}", -1); + *pbase = task->event_loop; + } + else { + return luaL_error(L, "invalid arguments"); + } + return 1; +} + +static int +lua_task_get_worker(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_worker **pworker; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task != NULL) { + if (task->worker) { + pworker = lua_newuserdata(L, sizeof(struct rspamd_worker *)); + rspamd_lua_setclass(L, "rspamd{worker}", -1); + *pworker = task->worker; + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + return 1; +} + + +static gint +lua_task_insert_result_common(lua_State *L, struct rspamd_scan_result *result, + gint common_args_pos) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *symbol_name; + double weight; + struct rspamd_symbol_result *s; + enum rspamd_symbol_insert_flags flags = RSPAMD_SYMBOL_INSERT_DEFAULT; + gint i, top, args_start; + + if (task != NULL) { + if (lua_isboolean(L, common_args_pos)) { + args_start = common_args_pos + 1; + + if (lua_toboolean(L, common_args_pos)) { + flags |= RSPAMD_SYMBOL_INSERT_ENFORCE; + } + } + else { + args_start = common_args_pos; + } + + symbol_name = rspamd_mempool_strdup(task->task_pool, + luaL_checkstring(L, args_start)); + weight = luaL_checknumber(L, args_start + 1); + top = lua_gettop(L); + s = rspamd_task_insert_result_full(task, symbol_name, weight, + NULL, flags, result); + + /* Get additional options */ + if (s) { + if (s->sym == NULL) { + /* Unknown symbol, print traceback */ + lua_pushfstring(L, "unknown symbol %s", symbol_name); + rspamd_lua_traceback(L); + + msg_info_task("symbol insertion issue: %s", lua_tostring(L, -1)); + + lua_pop(L, 1); /* Traceback string */ + } + for (i = args_start + 2; i <= top; i++) { + gint ltype = lua_type(L, i); + + if (ltype == LUA_TSTRING) { + gsize optlen; + const char *opt = lua_tolstring(L, i, &optlen); + + rspamd_task_add_result_option(task, s, opt, optlen); + } + else if (ltype == LUA_TUSERDATA) { + struct rspamd_lua_text *t = lua_check_text(L, i); + + if (t) { + rspamd_task_add_result_option(task, s, t->start, + t->len); + } + } + else if (ltype == LUA_TTABLE) { + gsize objlen = rspamd_lua_table_size(L, i); + + for (guint j = 1; j <= objlen; j++) { + lua_rawgeti(L, i, j); + + if (lua_type(L, -1) == LUA_TSTRING) { + gsize optlen; + const char *opt = lua_tolstring(L, -1, &optlen); + + rspamd_task_add_result_option(task, s, opt, optlen); + } + else if (lua_type(L, -1) == LUA_TUSERDATA) { + struct rspamd_lua_text *t = lua_check_text(L, -1); + + if (t) { + rspamd_task_add_result_option(task, s, t->start, + t->len); + } + else { + return luaL_error(L, "not rspamd_text option in a table " + "when adding symbol %s: %s type", + s->name); + } + } + else { + const gchar *tname = lua_typename(L, lua_type(L, -1)); + lua_pop(L, 2); + + return luaL_error(L, "not a string option in a table " + "when adding symbol %s: %s type", + s->name, tname); + } + + lua_pop(L, 1); + } + } + else if (ltype == LUA_TNIL) { + /* We have received a NULL option, it is not good but not a fatal error */ + msg_info_task("nil option when adding symbol %s at pos %d", + s->name, i); + continue; + } + else { + const gchar *tname = lua_typename(L, ltype); + + return luaL_error(L, "not a string/table option " + "when adding symbol %s: %s type", + s->name, tname); + } + } + } + else if (task->settings == NULL && task->settings_elt == NULL) { + lua_pushfstring(L, "insertion failed for %s", symbol_name); + rspamd_lua_traceback(L); + + msg_info_task("symbol insertion issue: %s", lua_tostring(L, -1)); + + lua_pop(L, 2); /* Traceback string + error string */ + } + else { + /* Usually denied by settings */ + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_insert_result(lua_State *L) +{ + return lua_task_insert_result_common(L, NULL, 2); +} + +static gint +lua_task_insert_result_named(lua_State *L) +{ + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *named_result = luaL_checkstring(L, 2); + struct rspamd_scan_result *res; + + if (task && named_result) { + res = rspamd_find_metric_result(task, named_result); + + if (res == NULL) { + return luaL_error(L, "invalid arguments: bad named result: %s", + named_result); + } + + return lua_task_insert_result_common(L, res, 3); + } + + return luaL_error(L, "invalid arguments"); +} + +static gint +lua_task_adjust_result(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *symbol_name; + struct rspamd_scan_result *metric_res; + struct rspamd_symbol_result *s = NULL; + double weight; + gint i, top; + + if (task != NULL) { + + symbol_name = luaL_checkstring(L, 2); + weight = luaL_checknumber(L, 3); + top = lua_gettop(L); + metric_res = task->result; + + if (metric_res) { + s = rspamd_task_find_symbol_result(task, symbol_name, NULL); + } + else { + return luaL_error(L, "no metric result"); + } + + if (s) { + if (!isnan(weight)) { + metric_res->score -= s->score; + s->score = weight; + metric_res->score += s->score; + } + } + else { + return luaL_error(L, "symbol not found: %s", symbol_name); + } + + /* Get additional options */ + if (s) { + for (i = 4; i <= top; i++) { + if (lua_type(L, i) == LUA_TSTRING) { + gsize optlen; + const char *opt = lua_tolstring(L, i, &optlen); + + rspamd_task_add_result_option(task, s, opt, optlen); + } + else if (lua_type(L, i) == LUA_TUSERDATA) { + struct rspamd_lua_text *t = lua_check_text(L, i); + + if (t) { + rspamd_task_add_result_option(task, s, t->start, + t->len); + } + } + else if (lua_type(L, i) == LUA_TTABLE) { + gsize objlen = rspamd_lua_table_size(L, i); + + for (guint j = 1; j <= objlen; j++) { + lua_rawgeti(L, i, j); + + if (lua_type(L, -1) == LUA_TSTRING) { + gsize optlen; + const char *opt = lua_tolstring(L, -1, &optlen); + + rspamd_task_add_result_option(task, s, opt, optlen); + } + else if (lua_type(L, -1) == LUA_TUSERDATA) { + struct rspamd_lua_text *t = lua_check_text(L, -1); + + if (t) { + rspamd_task_add_result_option(task, s, t->start, + t->len); + } + } + + lua_pop(L, 1); + } + } + } + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_remove_result(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *symbol_name = luaL_checkstring(L, 2); + struct rspamd_scan_result *metric_res; + const gchar *named_result = luaL_optstring(L, 3, NULL); + + if (task != NULL) { + metric_res = rspamd_find_metric_result(task, named_result); + + if (metric_res == NULL) { + return luaL_error(L, "invalid arguments: bad named result: %s", + named_result); + } + + lua_pushboolean(L, (rspamd_task_remove_symbol_result(task, symbol_name, + metric_res)) != NULL); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_pre_result(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *message = NULL, *module = NULL, *fl_str = NULL, *act_str = NULL, + *res_name = NULL; + gdouble score = NAN; + struct rspamd_action *action; + guint priority = RSPAMD_PASSTHROUGH_NORMAL, flags = 0; + + if (task != NULL) { + + if (RSPAMD_TASK_IS_SKIPPED(task)) { + /* Do not set pre-result for a skipped task */ + return 0; + } + + if (lua_type(L, 2) == LUA_TTABLE) { + GError *err = NULL; + + if (!rspamd_lua_parse_table_arguments(L, 2, &err, + RSPAMD_LUA_PARSE_ARGUMENTS_DEFAULT, + "*action=S;message=S;module=S;score=D;priority=i;flags=S;result=S", + &act_str, &message, &module, &score, &priority, &fl_str, &res_name)) { + gint ret = luaL_error(L, "invalid arguments: %s", err->message); + g_error_free(err); + + return ret; + } + } + else { + if (lua_type(L, 2) == LUA_TSTRING) { + act_str = lua_tostring(L, 2); + } + else { + return luaL_error(L, "invalid arguments"); + } + + if (lua_type(L, 3) == LUA_TSTRING) { + message = lua_tostring(L, 3); + } + + if (lua_type(L, 4) == LUA_TSTRING) { + module = lua_tostring(L, 4); + } + + if (lua_type(L, 5) == LUA_TNUMBER) { + score = lua_tonumber(L, 5); + } + + if (lua_type(L, 6) == LUA_TNUMBER) { + priority = lua_tointeger(L, 6); + } + + if (lua_type(L, 7) == LUA_TSTRING) { + fl_str = lua_tostring(L, 7); + } + } + + enum rspamd_action_type internal_type; + + if (strcmp(act_str, "accept") == 0) { + /* Compatibility! */ + act_str = "no action"; + } + else if (rspamd_action_from_str(act_str, &internal_type)) { + /* Compatibility! */ + act_str = rspamd_action_to_str(internal_type); + } + + action = rspamd_config_get_action(task->cfg, act_str); + + if (action == NULL) { + return luaL_error(L, "unknown action %s", act_str); + } + + if (module == NULL) { + module = "Unknown lua"; + } + + if (message == NULL) { + message = "unknown reason"; + flags |= RSPAMD_PASSTHROUGH_NO_SMTP_MESSAGE; + } + + if (fl_str != NULL) { + /* + * TODO: convert to a set of string and split by `,` + add table support + * once this legacy code is migrated to C++ + */ + if (strstr(fl_str, "least") != NULL) { + flags |= RSPAMD_PASSTHROUGH_LEAST; + } + else if (strstr(fl_str, "no_smtp_message") != NULL) { + flags |= RSPAMD_PASSTHROUGH_NO_SMTP_MESSAGE; + } + else if (strstr(fl_str, "process_all") != NULL) { + flags |= RSPAMD_PASSTHROUGH_PROCESS_ALL; + } + } + + + rspamd_add_passthrough_result(task, + action, + priority, + score, + rspamd_mempool_strdup(task->task_pool, message), + rspamd_mempool_strdup(task->task_pool, module), + flags, + rspamd_find_metric_result(task, res_name)); + + /* Don't classify or filter message if pre-filter sets results */ + + if (res_name == NULL && !(flags & (RSPAMD_PASSTHROUGH_LEAST | RSPAMD_PASSTHROUGH_PROCESS_ALL))) { + task->processed_stages |= (RSPAMD_TASK_STAGE_CLASSIFIERS | + RSPAMD_TASK_STAGE_CLASSIFIERS_PRE | + RSPAMD_TASK_STAGE_CLASSIFIERS_POST); + rspamd_symcache_disable_all_symbols(task, task->cfg->cache, + SYMBOL_TYPE_IDEMPOTENT | SYMBOL_TYPE_IGNORE_PASSTHROUGH); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_has_pre_result(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gint nret = 1; + + if (task) { + if (task->result->passthrough_result) { + struct rspamd_passthrough_result *pr = task->result->passthrough_result; + + lua_pushboolean(L, true); + nret = 4; + /* bool, action, message, module */ + + if (pr->action) { + lua_pushstring(L, rspamd_action_to_str(pr->action->action_type)); + } + else { + lua_pushnil(L); + } + + if (pr->message) { + lua_pushstring(L, pr->message); + } + else { + lua_pushnil(L); + } + if (pr->module) { + lua_pushstring(L, pr->module); + } + else { + lua_pushnil(L); + } + } + else { + lua_pushboolean(L, false); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return nret; +} + +static gint +lua_task_append_message(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *category; + + if (task != NULL) { + if (lua_type(L, 3) == LUA_TSTRING) { + category = luaL_checkstring(L, 3); + } + else { + category = "unknown"; + } + + ucl_object_insert_key(task->messages, + ucl_object_lua_import(L, 2), + category, 0, + true); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + + +static gint +lua_task_get_urls(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct lua_tree_cb_data cb; + struct rspamd_url *u; + static const gint default_protocols_mask = PROTOCOL_HTTP | PROTOCOL_HTTPS | + PROTOCOL_FILE | PROTOCOL_FTP; + gsize sz, max_urls = 0; + + if (task) { + if (task->cfg) { + max_urls = task->cfg->max_lua_urls; + } + + if (task->message == NULL) { + lua_newtable(L); + + return 1; + } + + /* Exclude RSPAMD_URL_FLAG_CONTENT to preserve backward compatibility */ + if (!lua_url_cbdata_fill(L, 2, &cb, default_protocols_mask, + ~(RSPAMD_URL_FLAG_CONTENT | RSPAMD_URL_FLAG_IMAGE), + max_urls)) { + return luaL_error(L, "invalid arguments"); + } + + sz = kh_size(MESSAGE_FIELD(task, urls)); + sz = lua_url_adjust_skip_prob(task->task_timestamp, + MESSAGE_FIELD(task, digest), &cb, sz); + + lua_createtable(L, sz, 0); + + if (cb.sort) { + struct rspamd_url **urls_sorted; + gint i = 0; + + urls_sorted = g_new0(struct rspamd_url *, sz); + + kh_foreach_key(MESSAGE_FIELD(task, urls), u, { + if (i < sz) { + urls_sorted[i] = u; + i++; + } + }); + + qsort(urls_sorted, i, sizeof(struct rspamd_url *), rspamd_url_cmp_qsort); + + for (int j = 0; j < i; j++) { + lua_tree_url_callback(urls_sorted[j], urls_sorted[j], &cb); + } + + g_free(urls_sorted); + } + else { + kh_foreach_key(MESSAGE_FIELD(task, urls), u, { + lua_tree_url_callback(u, u, &cb); + }); + } + + lua_url_cbdata_dtor(&cb); + } + else { + return luaL_error(L, "invalid arguments, no task"); + } + + return 1; +} + +static gint +lua_task_get_urls_filtered(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct lua_tree_cb_data cb; + struct rspamd_url *u; + static const gint default_protocols_mask = PROTOCOL_HTTP | PROTOCOL_HTTPS | + PROTOCOL_FILE | PROTOCOL_FTP; + gsize sz, max_urls = 0; + + if (task) { + if (task->cfg) { + max_urls = task->cfg->max_lua_urls; + } + + if (task->message == NULL) { + lua_newtable(L); + + return 1; + } + + if (!lua_url_cbdata_fill_exclude_include(L, 2, &cb, default_protocols_mask, max_urls)) { + return luaL_error(L, "invalid arguments"); + } + + sz = kh_size(MESSAGE_FIELD(task, urls)); + sz = lua_url_adjust_skip_prob(task->task_timestamp, + MESSAGE_FIELD(task, digest), &cb, sz); + + lua_createtable(L, sz, 0); + + if (cb.sort) { + struct rspamd_url **urls_sorted; + gint i = 0; + + urls_sorted = g_new0(struct rspamd_url *, sz); + + kh_foreach_key(MESSAGE_FIELD(task, urls), u, { + if (i < sz) { + urls_sorted[i] = u; + i++; + } + }); + + qsort(urls_sorted, i, sizeof(struct rspamd_url *), rspamd_url_cmp_qsort); + + for (int j = 0; j < i; j++) { + lua_tree_url_callback(urls_sorted[j], urls_sorted[j], &cb); + } + + g_free(urls_sorted); + } + else { + kh_foreach_key(MESSAGE_FIELD(task, urls), u, { + lua_tree_url_callback(u, u, &cb); + }); + } + + lua_url_cbdata_dtor(&cb); + } + else { + return luaL_error(L, "invalid arguments, no task"); + } + + return 1; +} + +static gint +lua_task_has_urls(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + bool need_emails = false; + gboolean ret = FALSE; + gsize sz = 0; + + if (task) { + if (task->message) { + if (lua_gettop(L) >= 2) { + need_emails = lua_toboolean(L, 2); + } + + if (need_emails) { + /* Simplified check */ + if (kh_size(MESSAGE_FIELD(task, urls)) > 0) { + sz += kh_size(MESSAGE_FIELD(task, urls)); + ret = TRUE; + } + } + else { + /* Linear scan */ + struct rspamd_url *u; + kh_foreach_key(MESSAGE_FIELD(task, urls), u, { + if (u->protocol != PROTOCOL_MAILTO) { + sz++; + ret = TRUE; + } + }); + } + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + lua_pushboolean(L, ret); + lua_pushinteger(L, sz); + + return 2; +} + +static gint +lua_task_inject_url(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_lua_url *url = lua_check_url(L, 2); + struct rspamd_mime_part *mpart = NULL; + + if (lua_isuserdata(L, 3)) { + /* We also have a mime part there */ + mpart = *((struct rspamd_mime_part **) rspamd_lua_check_udata_maybe(L, + 3, "rspamd{mimepart}")); + } + + if (task && task->message && url && url->url) { + if (rspamd_url_set_add_or_increase(MESSAGE_FIELD(task, urls), url->url, false)) { + if (mpart && mpart->urls) { + /* Also add url to the mime part */ + g_ptr_array_add(mpart->urls, url->url); + } + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_get_content(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_lua_text *t; + + if (task) { + t = lua_newuserdata(L, sizeof(*t)); + rspamd_lua_setclass(L, "rspamd{text}", -1); + t->len = task->msg.len; + t->start = task->msg.begin; + t->flags = 0; + + if (lua_is_text_binary(t)) { + t->flags |= RSPAMD_TEXT_FLAG_BINARY; + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_filename(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + if (task->msg.fpath) { + lua_pushstring(L, task->msg.fpath); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_rawbody(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_lua_text *t; + + if (task) { + if (task->message != NULL) { + + + if (MESSAGE_FIELD(task, raw_headers_content).len > 0) { + g_assert(MESSAGE_FIELD(task, raw_headers_content).len <= task->msg.len); + t = lua_new_text_task(L, task, task->msg.begin + MESSAGE_FIELD(task, raw_headers_content).len, + task->msg.len - MESSAGE_FIELD(task, raw_headers_content).len, FALSE); + } + else { + t = lua_new_text_task(L, task, task->msg.begin, + task->msg.len, FALSE); + } + + t->flags = 0; + } + else { + /* Push body it it is there */ + if (task->msg.len > 0 && task->msg.begin != NULL) { + lua_new_text_task(L, task, task->msg.begin, task->msg.len, FALSE); + } + else { + lua_pushnil(L); + } + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_emails(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct lua_tree_cb_data cb; + struct rspamd_url *u; + gsize max_urls = 0, sz; + + if (task) { + if (task->message) { + if (task->cfg) { + max_urls = task->cfg->max_lua_urls; + } + + if (!lua_url_cbdata_fill(L, 2, &cb, PROTOCOL_MAILTO, + ~(RSPAMD_URL_FLAG_CONTENT | RSPAMD_URL_FLAG_IMAGE), + max_urls)) { + return luaL_error(L, "invalid arguments"); + } + + sz = kh_size(MESSAGE_FIELD(task, urls)); + sz = lua_url_adjust_skip_prob(task->task_timestamp, + MESSAGE_FIELD(task, digest), &cb, sz); + + lua_createtable(L, sz, 0); + + kh_foreach_key(MESSAGE_FIELD(task, urls), u, { + lua_tree_url_callback(u, u, &cb); + }); + + lua_url_cbdata_dtor(&cb); + } + else { + lua_newtable(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_text_parts(lua_State *L) +{ + LUA_TRACE_POINT; + guint i; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_mime_text_part *part, **ppart; + + if (task != NULL) { + + if (task->message) { + if (!lua_task_get_cached(L, task, "text_parts")) { + lua_createtable(L, MESSAGE_FIELD(task, text_parts)->len, 0); + + PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, text_parts), i, part) + { + ppart = lua_newuserdata(L, sizeof(struct rspamd_mime_text_part *)); + *ppart = part; + rspamd_lua_setclass(L, "rspamd{textpart}", -1); + /* Make it array */ + lua_rawseti(L, -2, i + 1); + } + + lua_task_set_cached(L, task, "text_parts", -1); + } + } + else { + lua_newtable(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_parts(lua_State *L) +{ + LUA_TRACE_POINT; + guint i; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_mime_part *part, **ppart; + + if (task != NULL) { + if (task->message) { + lua_createtable(L, MESSAGE_FIELD(task, parts)->len, 0); + + PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, parts), i, part) + { + ppart = lua_newuserdata(L, sizeof(struct rspamd_mime_part *)); + *ppart = part; + rspamd_lua_setclass(L, "rspamd{mimepart}", -1); + /* Make it array */ + lua_rawseti(L, -2, i + 1); + } + } + else { + lua_newtable(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_request_header(lua_State *L) +{ + LUA_TRACE_POINT; + rspamd_ftok_t *hdr; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *s; + struct rspamd_lua_text *t; + + s = luaL_checkstring(L, 2); + + if (s && task) { + hdr = rspamd_task_get_request_header(task, s); + + if (hdr) { + t = lua_newuserdata(L, sizeof(*t)); + rspamd_lua_setclass(L, "rspamd{text}", -1); + t->start = hdr->begin; + t->len = hdr->len; + t->flags = 0; + + return 1; + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_request_header(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *s, *v = NULL; + rspamd_fstring_t *buf; + struct rspamd_lua_text *t; + rspamd_ftok_t *hdr, *new_name; + gsize len, vlen = 0; + + s = luaL_checklstring(L, 2, &len); + + if (s && task) { + if (lua_type(L, 3) == LUA_TSTRING) { + v = luaL_checklstring(L, 3, &vlen); + } + else if (lua_type(L, 3) == LUA_TUSERDATA) { + t = lua_check_text(L, 3); + + if (t != NULL) { + v = t->start; + vlen = t->len; + } + } + + if (v != NULL) { + buf = rspamd_fstring_new_init(v, vlen); + hdr = rspamd_ftok_map(buf); + buf = rspamd_fstring_new_init(s, len); + new_name = rspamd_ftok_map(buf); + + rspamd_task_add_request_header(task, new_name, hdr); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + + return 0; +} + + +gint rspamd_lua_push_header(lua_State *L, struct rspamd_mime_header *rh, + enum rspamd_lua_task_header_type how) +{ + LUA_TRACE_POINT; + switch (how) { + case RSPAMD_TASK_HEADER_PUSH_FULL: + /* Create new associated table for a header */ + lua_createtable(L, 0, 7); + rspamd_lua_table_set(L, "name", rh->name); + + if (rh->value) { + rspamd_lua_table_set(L, "value", rh->value); + } + + if (rh->raw_len > 0) { + lua_pushstring(L, "raw"); + lua_pushlstring(L, rh->raw_value, rh->raw_len); + lua_settable(L, -3); + } + + if (rh->decoded) { + rspamd_lua_table_set(L, "decoded", rh->decoded); + } + + lua_pushstring(L, "tab_separated"); + lua_pushboolean(L, rh->flags & RSPAMD_HEADER_TAB_SEPARATED); + lua_settable(L, -3); + lua_pushstring(L, "empty_separator"); + lua_pushboolean(L, rh->flags & RSPAMD_HEADER_EMPTY_SEPARATOR); + lua_settable(L, -3); + rspamd_lua_table_set(L, "separator", rh->separator); + lua_pushstring(L, "order"); + lua_pushinteger(L, rh->order); + lua_settable(L, -3); + break; + case RSPAMD_TASK_HEADER_PUSH_RAW: + if (rh->value) { + lua_pushstring(L, rh->value); + } + else { + lua_pushnil(L); + } + break; + case RSPAMD_TASK_HEADER_PUSH_SIMPLE: + if (rh->decoded) { + lua_pushstring(L, rh->decoded); + } + else { + lua_pushnil(L); + } + break; + case RSPAMD_TASK_HEADER_PUSH_COUNT: + default: + g_assert_not_reached(); + break; + } + + return 1; +} + +gint rspamd_lua_push_header_array(lua_State *L, + const gchar *name, + struct rspamd_mime_header *rh, + enum rspamd_lua_task_header_type how, + gboolean strong) +{ + LUA_TRACE_POINT; + struct rspamd_mime_header *cur; + guint i; + gint nret = 1; + + if (rh == NULL) { + if (how == RSPAMD_TASK_HEADER_PUSH_HAS) { + lua_pushboolean(L, false); + nret = 1; + } + else if (how == RSPAMD_TASK_HEADER_PUSH_COUNT) { + lua_pushnumber(L, 0); + } + else { + lua_pushnil(L); + } + + return nret; + } + + if (how == RSPAMD_TASK_HEADER_PUSH_FULL) { + lua_createtable(L, 0, 0); + i = 0; + + DL_FOREACH(rh, cur) + { + if (!strong || strcmp(name, cur->name) == 0) { + rspamd_lua_push_header(L, cur, how); + lua_rawseti(L, -2, ++i); + } + } + } + else if (how == RSPAMD_TASK_HEADER_PUSH_COUNT) { + i = 0; + + DL_FOREACH(rh, cur) + { + if (!strong || strcmp(name, cur->name) == 0) { + i++; + } + } + + lua_pushinteger(L, i); + } + else if (how == RSPAMD_TASK_HEADER_PUSH_HAS) { + nret = 1; + bool found = false; + + if (strong) { + /* We still have to check all headers in the chain */ + DL_FOREACH(rh, cur) + { + if (strcmp(name, cur->name) == 0) { + found = true; + break; + } + } + } + else { + found = true; + } + + lua_pushboolean(L, found); + } + else { + DL_FOREACH(rh, cur) + { + if (!strong || strcmp(name, cur->name) == 0) { + return rspamd_lua_push_header(L, cur, how); + } + } + + /* Not found with this case */ + lua_pushnil(L); + } + + return nret; +} + +static gint +lua_task_get_header_common(lua_State *L, enum rspamd_lua_task_header_type how) +{ + LUA_TRACE_POINT; + gboolean strong = FALSE, need_modified = FALSE; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_mime_header *rh; + const gchar *name; + + name = luaL_checkstring(L, 2); + + if (name && task) { + if (lua_gettop(L) >= 3) { + strong = lua_toboolean(L, 3); + if (lua_isboolean(L, 4)) { + need_modified = lua_toboolean(L, 4); + } + } + + + rh = rspamd_message_get_header_array(task, name, need_modified); + + return rspamd_lua_push_header_array(L, name, rh, how, strong); + } + else { + return luaL_error(L, "invalid arguments"); + } +} + +static gint +lua_task_get_header_full(lua_State *L) +{ + return lua_task_get_header_common(L, RSPAMD_TASK_HEADER_PUSH_FULL); +} + +static gint +lua_task_get_header(lua_State *L) +{ + return lua_task_get_header_common(L, RSPAMD_TASK_HEADER_PUSH_SIMPLE); +} + +static gint +lua_task_get_header_raw(lua_State *L) +{ + return lua_task_get_header_common(L, RSPAMD_TASK_HEADER_PUSH_RAW); +} + +static gint +lua_task_get_header_count(lua_State *L) +{ + return lua_task_get_header_common(L, RSPAMD_TASK_HEADER_PUSH_COUNT); +} + +static gint +lua_task_has_header(lua_State *L) +{ + return lua_task_get_header_common(L, RSPAMD_TASK_HEADER_PUSH_HAS); +} + +static gint +lua_task_get_headers(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + bool need_modified = lua_isnoneornil(L, 2) ? false : lua_toboolean(L, 2); + + if (task && task->message) { + struct rspamd_mime_header *cur; + int i = 1; + + lua_createtable(L, rspamd_mime_headers_count(MESSAGE_FIELD(task, raw_headers)), 0); + LL_FOREACH2(MESSAGE_FIELD(task, headers_order), cur, ord_next) + { + if (need_modified && cur->modified_chain) { + struct rspamd_mime_header *cur_modified; + + LL_FOREACH(cur->modified_chain, cur_modified) + { + rspamd_lua_push_header(L, cur_modified, RSPAMD_TASK_HEADER_PUSH_FULL); + lua_rawseti(L, -2, i++); + } + } + else { + rspamd_lua_push_header(L, cur, RSPAMD_TASK_HEADER_PUSH_FULL); + lua_rawseti(L, -2, i++); + } + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + + return 1; +} + +static gint +lua_task_get_raw_headers(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_lua_text *t; + + if (task && task->message) { + t = lua_newuserdata(L, sizeof(*t)); + rspamd_lua_setclass(L, "rspamd{text}", -1); + t->start = MESSAGE_FIELD(task, raw_headers_content).begin; + t->len = MESSAGE_FIELD(task, raw_headers_content).len; + t->flags = 0; + } + else { + return luaL_error(L, "invalid arguments"); + } + + + return 1; +} + +static gint +lua_task_get_received_headers(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + if (!task->message) { + /* No message - no received */ + lua_newtable(L); + return 1; + } + + if (!lua_task_get_cached(L, task, "received")) { + + if (rspamd_received_export_to_lua(task, L)) { + lua_task_set_cached(L, task, "received", -1); + } + else { + /* no received, preserve compatibility */ + lua_newtable(L); + return 1; + } + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_queue_id(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + if (task->queue_id != NULL && strcmp(task->queue_id, "undef") != 0) { + lua_pushstring(L, task->queue_id); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_uid(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + lua_pushstring(L, task->task_pool->tag.uid); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_resolver(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_dns_resolver **presolver; + + if (task != NULL && task->resolver != NULL) { + presolver = lua_newuserdata(L, sizeof(void *)); + rspamd_lua_setclass(L, "rspamd{resolver}", -1); + *presolver = task->resolver; + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_resolver(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_dns_resolver *resolver = lua_check_dns_resolver(L, 2); + + if (task != NULL && resolver != NULL) { + task->resolver = resolver; + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_inc_dns_req(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + static guint warning_shown = 0; + + if (warning_shown < 100) { + warning_shown++; + msg_warn_task_check("task:inc_dns_req is deprecated and should not be used"); + } + + if (task != NULL) { + /* Deprecation: already done in rspamd_dns_resolver_request */ + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_get_dns_req(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task != NULL) { + lua_pushinteger(L, task->dns_requests); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +enum lua_email_address_type { + LUA_ADDRESS_ANY = 0u, + LUA_ADDRESS_SMTP = 1, + LUA_ADDRESS_MIME = 2, + LUA_ADDRESS_MASK = 0x3FF, + LUA_ADDRESS_RAW = (1u << 10), + LUA_ADDRESS_ORIGINAL = (1u << 11), + LUA_ADDRESS_MAX = LUA_ADDRESS_MASK, +}; + +/* + * Convert element at the specified position to the type + * for get_from/get_recipients + */ +static enum lua_email_address_type +lua_task_str_to_get_type(lua_State *L, struct rspamd_task *task, gint pos, gint last_pos) +{ + const gchar *type = NULL; + gint ret = LUA_ADDRESS_ANY; + guint64 h; + gsize sz; + + /* Get what value */ + do { + if (lua_type(L, pos) == LUA_TNUMBER) { + ret = lua_tonumber(L, pos); + + if (ret >= LUA_ADDRESS_ANY && ret < LUA_ADDRESS_MAX) { + return ret; + } + + return LUA_ADDRESS_ANY; + } + else if (lua_type(L, pos) == LUA_TSTRING) { + type = lua_tolstring(L, pos, &sz); + + if (type && sz > 0) { + h = rspamd_cryptobox_fast_hash_specific(RSPAMD_CRYPTOBOX_XXHASH64, + type, sz, 0xdeadbabe); + + switch (h) { + case 0xDA081341FB600389ULL: /* mime */ + ret = LUA_ADDRESS_MIME; + break; + case 0xEEC8A7832F8C43ACULL: /* any */ + ret = LUA_ADDRESS_ANY; + break; + case 0x472274D5193B2A80ULL: /* smtp */ + case 0xEFE0F586CC9F14A9ULL: /* envelope */ + ret = LUA_ADDRESS_SMTP; + break; + default: + msg_err_task("invalid email type: %*s", (gint) sz, type); + break; + } + } + } + else if (lua_type(L, pos) == LUA_TTABLE) { + for (lua_pushnil(L); lua_next(L, pos); lua_pop(L, 1)) { + type = lua_tolstring(L, -1, &sz); + + if (type && sz > 0) { + h = rspamd_cryptobox_fast_hash_specific(RSPAMD_CRYPTOBOX_XXHASH64, + type, sz, 0xdeadbabe); + + switch (h) { + case 0xDA081341FB600389ULL: /* mime */ + ret |= LUA_ADDRESS_MIME; + break; + case 0xEEC8A7832F8C43ACULL: /* any */ + ret |= LUA_ADDRESS_ANY; + break; + case 0x472274D5193B2A80ULL: /* smtp */ + case 0xEFE0F586CC9F14A9ULL: /* envelope */ + ret |= LUA_ADDRESS_SMTP; + break; + case 0xAF4DE083D9AD0132: /* raw */ + ret |= LUA_ADDRESS_RAW; + break; + case 0xC7AB6C7B7B0F5A8A: /* orig */ + case 0x1778AE905589E431: /* original */ + ret |= LUA_ADDRESS_ORIGINAL; + break; + default: + msg_err_task("invalid email type: %*s", (gint) sz, type); + break; + } + } + } + } + pos++; + } while (pos <= last_pos); + + return ret; +} + +#define EMAIL_CHECK_FLAG(fl, str) \ + do { \ + if (addr->flags & (fl)) { \ + lua_pushstring(L, (str)); \ + lua_pushboolean(L, true); \ + lua_settable(L, -3); \ + } \ + } while (0) + +static void +lua_push_email_address(lua_State *L, struct rspamd_email_address *addr) +{ + if (addr) { + lua_createtable(L, 0, 5); + + if (addr->raw_len > 0) { + lua_pushstring(L, "raw"); + lua_pushlstring(L, addr->raw, addr->raw_len); + lua_settable(L, -3); + } + else { + lua_pushstring(L, "raw"); + lua_pushstring(L, ""); + lua_settable(L, -3); + } + if (addr->addr_len > 0) { + lua_pushstring(L, "addr"); + lua_pushlstring(L, addr->addr, addr->addr_len); + lua_settable(L, -3); + } + else { + lua_pushstring(L, "addr"); + lua_pushstring(L, ""); + lua_settable(L, -3); + } + if (addr->domain_len > 0) { + lua_pushstring(L, "domain"); + lua_pushlstring(L, addr->domain, addr->domain_len); + lua_settable(L, -3); + } + else { + lua_pushstring(L, "domain"); + lua_pushstring(L, ""); + lua_settable(L, -3); + } + if (addr->user_len > 0) { + lua_pushstring(L, "user"); + lua_pushlstring(L, addr->user, addr->user_len); + lua_settable(L, -3); + } + else { + lua_pushstring(L, "user"); + lua_pushstring(L, ""); + lua_settable(L, -3); + } + + if (addr->name) { + lua_pushstring(L, "name"); + lua_pushstring(L, addr->name); + lua_settable(L, -3); + } + else { + lua_pushstring(L, "name"); + lua_pushstring(L, ""); + lua_settable(L, -3); + } + + lua_pushstring(L, "flags"); + lua_createtable(L, 0, 7); + + EMAIL_CHECK_FLAG(RSPAMD_EMAIL_ADDR_VALID, "valid"); + EMAIL_CHECK_FLAG(RSPAMD_EMAIL_ADDR_IP, "ip"); + EMAIL_CHECK_FLAG(RSPAMD_EMAIL_ADDR_BRACED, "braced"); + EMAIL_CHECK_FLAG(RSPAMD_EMAIL_ADDR_QUOTED, "quoted"); + EMAIL_CHECK_FLAG(RSPAMD_EMAIL_ADDR_EMPTY, "empty"); + EMAIL_CHECK_FLAG(RSPAMD_EMAIL_ADDR_HAS_BACKSLASH, "backslash"); + EMAIL_CHECK_FLAG(RSPAMD_EMAIL_ADDR_HAS_8BIT, "8bit"); + + lua_settable(L, -3); + } +} + +void lua_push_emails_address_list(lua_State *L, GPtrArray *addrs, int flags) +{ + struct rspamd_email_address *addr; + guint i, pos = 1; + + lua_createtable(L, addrs->len, 0); + + for (i = 0; i < addrs->len; i++) { + addr = g_ptr_array_index(addrs, i); + + if (addr->flags & RSPAMD_EMAIL_ADDR_ORIGINAL) { + if (flags & LUA_ADDRESS_ORIGINAL) { + lua_push_email_address(L, addr); + lua_rawseti(L, -2, pos); + pos++; + } + } + else { + lua_push_email_address(L, addr); + lua_rawseti(L, -2, pos); + pos++; + } + } +} + +static gboolean +lua_import_email_address(lua_State *L, struct rspamd_task *task, + gint pos, + struct rspamd_email_address **paddr) +{ + struct rspamd_email_address *addr; + const gchar *p; + gchar *dst; + gsize len; + + g_assert(paddr != NULL); + + if (!lua_istable(L, pos)) { + return FALSE; + } + + addr = g_malloc0(sizeof(*addr)); + + lua_pushstring(L, "name"); + lua_gettable(L, pos); + + if (lua_type(L, -1) == LUA_TSTRING) { + p = lua_tolstring(L, -1, &len); + dst = rspamd_mempool_alloc(task->task_pool, len + 1); + rspamd_strlcpy(dst, p, len + 1); + addr->name = dst; + } + + lua_pop(L, 1); + + lua_pushstring(L, "user"); + lua_gettable(L, pos); + + if (lua_type(L, -1) == LUA_TSTRING) { + p = lua_tolstring(L, -1, &len); + addr->user = (const gchar *) rspamd_mempool_alloc(task->task_pool, len); + memcpy((gchar *) addr->user, p, len); + addr->user_len = len; + } + + lua_pop(L, 1); + + lua_pushstring(L, "domain"); + lua_gettable(L, pos); + + if (lua_type(L, -1) == LUA_TSTRING) { + p = lua_tolstring(L, -1, &len); + addr->domain = (const gchar *) rspamd_mempool_alloc(task->task_pool, len); + memcpy((gchar *) addr->domain, p, len); + addr->domain_len = len; + } + + lua_pop(L, 1); + + lua_pushstring(L, "addr"); + lua_gettable(L, pos); + + if (lua_type(L, -1) == LUA_TSTRING) { + p = lua_tolstring(L, -1, &len); + addr->addr = (const gchar *) rspamd_mempool_alloc(task->task_pool, len); + memcpy((gchar *) addr->addr, p, len); + addr->addr_len = len; + } + else { + /* Construct addr */ + len = addr->domain_len + addr->user_len + 1; + addr->addr = (const gchar *) rspamd_mempool_alloc(task->task_pool, len); + addr->addr_len = rspamd_snprintf((gchar *) addr->addr, len, "%*s@%*s", + (int) addr->user_len, addr->user, + (int) addr->domain_len, addr->domain); + } + + lua_pop(L, 1); + + lua_pushstring(L, "raw"); + lua_gettable(L, pos); + + if (lua_type(L, -1) == LUA_TSTRING) { + gchar *cpy; + p = lua_tolstring(L, -1, &len); + cpy = rspamd_mempool_alloc(task->task_pool, len + 1); + memcpy(cpy, p, len); + cpy[len] = '\0'; + addr->raw_len = len; + addr->raw = cpy; + } + else { + /* Construct raw addr */ + len = addr->addr_len + 3; + + if (addr->name) { + len += strlen(addr->name) + 1; + dst = rspamd_mempool_alloc(task->task_pool, len + 1); + + addr->raw_len = rspamd_snprintf(dst, len, "%s <%*s>", + addr->name, + (int) addr->addr_len, addr->addr); + } + else { + dst = rspamd_mempool_alloc(task->task_pool, len + 1); + + addr->raw_len = rspamd_snprintf(dst, len, "<%*s@%*s>", + (int) addr->user_len, addr->user, + (int) addr->domain_len, addr->domain); + } + + addr->raw = dst; + } + + lua_pop(L, 1); + addr->flags = RSPAMD_EMAIL_ADDR_VALID; + + *paddr = addr; + + return TRUE; +} + +static gint +lua_task_get_recipients(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + GPtrArray *ptrs = NULL; + gint what = 0; + + if (task) { + if (lua_gettop(L) == 2) { + /* Get what value */ + what = lua_task_str_to_get_type(L, task, 2, lua_gettop(L)); + } + + switch (what & LUA_ADDRESS_MASK) { + case LUA_ADDRESS_SMTP: + /* Here we check merely envelope rcpt */ + ptrs = task->rcpt_envelope; + break; + case LUA_ADDRESS_MIME: + /* Here we check merely mime rcpt */ + ptrs = MESSAGE_FIELD_CHECK(task, rcpt_mime); + break; + case LUA_ADDRESS_ANY: + default: + if (task->rcpt_envelope) { + ptrs = task->rcpt_envelope; + } + else { + ptrs = MESSAGE_FIELD_CHECK(task, rcpt_mime); + } + break; + } + if (ptrs) { + lua_push_emails_address_list(L, ptrs, what & ~LUA_ADDRESS_MASK); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_recipients(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + GPtrArray *ptrs = NULL; + struct rspamd_email_address *addr = NULL; + gint what = 0, pos = 3; + const gchar *how = "add"; + gboolean need_update_digest = FALSE; + + if (task && lua_gettop(L) >= 3) { + + /* Get what value */ + what = lua_task_str_to_get_type(L, task, 2, -1); + + if (lua_isstring(L, 4)) { + how = lua_tostring(L, 4); + } + + switch (what) { + case LUA_ADDRESS_SMTP: + /* Here we check merely envelope rcpt */ + if (task->rcpt_envelope) { + ptrs = task->rcpt_envelope; + } + else { + ptrs = g_ptr_array_new(); + task->rcpt_envelope = ptrs; + } + break; + case LUA_ADDRESS_MIME: + /* Here we check merely mime rcpt */ + ptrs = MESSAGE_FIELD_CHECK(task, rcpt_mime); + need_update_digest = TRUE; + break; + case LUA_ADDRESS_ANY: + default: + if (task->rcpt_envelope) { + if (task->rcpt_envelope) { + ptrs = task->rcpt_envelope; + } + else { + ptrs = g_ptr_array_new(); + task->rcpt_envelope = ptrs; + } + } + else { + ptrs = MESSAGE_FIELD_CHECK(task, rcpt_mime); + need_update_digest = TRUE; + } + break; + } + if (ptrs) { + guint i, flags_existing = RSPAMD_EMAIL_ADDR_ORIGINAL, flags_add = 0; + struct rspamd_email_address *tmp; + + if (strcmp(how, "alias") == 0) { + flags_add |= RSPAMD_EMAIL_ADDR_ALIASED; + } + else if (strcmp(how, "rewrite") == 0) { + /* Clear old addresses */ + PTR_ARRAY_FOREACH(ptrs, i, tmp) + { + rspamd_email_address_free(addr); + } + + g_ptr_array_set_size(ptrs, 0); + } + + PTR_ARRAY_FOREACH(ptrs, i, tmp) + { + tmp->flags |= flags_existing; + } + + lua_pushvalue(L, pos); + + for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) { + if (lua_import_email_address(L, task, lua_gettop(L), &addr)) { + + if (need_update_digest) { + rspamd_message_update_digest(task->message, + addr->addr, addr->addr_len); + } + + addr->flags |= flags_add; + g_ptr_array_add(ptrs, addr); + } + } + + lua_pop(L, 1); + lua_pushboolean(L, true); + } + else { + lua_pushboolean(L, false); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + + +#define CHECK_EMAIL_ADDR(addr) \ + do { \ + if (addr == NULL) { \ + ret = 0; \ + } \ + else { \ + ret = addr->flags & RSPAMD_EMAIL_ADDR_VALID; \ + } \ + } while (0) + +#define CHECK_EMAIL_ADDR_LIST(addr) \ + do { \ + if (addr == NULL) { \ + ret = 0; \ + } \ + else { \ + ret = addr->len > 0; \ + nrcpt = addr->len; \ + } \ + } while (0) + +static gint +lua_task_has_from(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gint what = 0, nrcpt = 0; + gboolean ret = FALSE; + + if (task) { + if (lua_gettop(L) == 2) { + /* Get what value */ + what = lua_task_str_to_get_type(L, task, 2, lua_gettop(L)); + } + + switch (what & LUA_ADDRESS_MASK) { + case LUA_ADDRESS_SMTP: + /* Here we check merely envelope rcpt */ + CHECK_EMAIL_ADDR(task->from_envelope); + break; + case LUA_ADDRESS_MIME: + /* Here we check merely mime rcpt */ + CHECK_EMAIL_ADDR_LIST(MESSAGE_FIELD_CHECK(task, from_mime)); + break; + case LUA_ADDRESS_ANY: + default: + CHECK_EMAIL_ADDR(task->from_envelope); + + if (!ret) { + CHECK_EMAIL_ADDR_LIST(MESSAGE_FIELD_CHECK(task, from_mime)); + } + break; + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + lua_pushboolean(L, ret); + (void) nrcpt; /* Silence warning */ + + return 1; +} + +static inline int +rspamd_check_real_recipients_array_size(GPtrArray *ar) +{ + gint ret = 0, i; + struct rspamd_email_address *addr; + + PTR_ARRAY_FOREACH(ar, i, addr) + { + if (!(addr->flags & RSPAMD_EMAIL_ADDR_ORIGINAL)) { + ret++; + } + } + + return ret; +} + +static gint +lua_task_has_recipients(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gint what = 0, nrcpt = 0; + gboolean ret = FALSE; + + if (task) { + if (lua_gettop(L) == 2) { + /* Get what value */ + what = lua_task_str_to_get_type(L, task, 2, lua_gettop(L)); + } + + switch (what & LUA_ADDRESS_MASK) { + case LUA_ADDRESS_SMTP: + /* Here we check merely envelope rcpt */ + nrcpt = rspamd_check_real_recipients_array_size(task->rcpt_envelope); + ret = nrcpt > 0; + break; + case LUA_ADDRESS_MIME: + /* Here we check merely mime rcpt */ + nrcpt = rspamd_check_real_recipients_array_size(MESSAGE_FIELD_CHECK(task, rcpt_mime)); + ret = nrcpt > 0; + break; + case LUA_ADDRESS_ANY: + default: + nrcpt = rspamd_check_real_recipients_array_size(task->rcpt_envelope); + ret = nrcpt > 0; + + if (!ret) { + nrcpt = rspamd_check_real_recipients_array_size(MESSAGE_FIELD_CHECK(task, rcpt_mime)); + ret = nrcpt > 0; + } + break; + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + lua_pushboolean(L, ret); + lua_pushinteger(L, nrcpt); + + return 2; +} + +static gint +lua_task_get_from(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + GPtrArray *addrs = NULL; + struct rspamd_email_address *addr = NULL; + gint what = 0; + + if (task) { + if (lua_gettop(L) == 2) { + /* Get what value */ + what = lua_task_str_to_get_type(L, task, 2, lua_gettop(L)); + } + + switch (what & LUA_ADDRESS_MASK) { + case LUA_ADDRESS_SMTP: + /* Here we check merely envelope rcpt */ + addr = task->from_envelope; + break; + case LUA_ADDRESS_MIME: + /* Here we check merely mime rcpt */ + addrs = MESSAGE_FIELD_CHECK(task, from_mime); + break; + case LUA_ADDRESS_ANY: + default: + if (task->from_envelope) { + addr = task->from_envelope; + } + else { + addrs = MESSAGE_FIELD_CHECK(task, from_mime); + } + break; + } + + if (addrs && addrs->len > 0) { + lua_push_emails_address_list(L, addrs, what & ~LUA_ADDRESS_MASK); + } + else if (addr) { + /* Create table to preserve compatibility */ + if (addr->addr) { + lua_createtable(L, 1, 0); + if (what & LUA_ADDRESS_ORIGINAL) { + if (task->from_envelope_orig) { + lua_push_email_address(L, task->from_envelope_orig); + } + else { + lua_push_email_address(L, addr); + } + } + else { + lua_push_email_address(L, addr); + } + + lua_rawseti(L, -2, 1); + } + else { + lua_pushnil(L); + } + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_from(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *how = "rewrite"; + GPtrArray *addrs = NULL; + struct rspamd_email_address **paddr = NULL, *addr; + gboolean need_update_digest = FALSE; + gint what = 0; + + if (task && lua_gettop(L) >= 3) { + what = lua_task_str_to_get_type(L, task, 2, -1); + + if (lua_isstring(L, 4)) { + how = lua_tostring(L, 4); + } + + switch (what & LUA_ADDRESS_MASK) { + case LUA_ADDRESS_SMTP: + /* Here we check merely envelope rcpt */ + paddr = &task->from_envelope; + break; + case LUA_ADDRESS_MIME: + /* Here we check merely mime rcpt */ + addrs = MESSAGE_FIELD_CHECK(task, from_mime); + need_update_digest = TRUE; + break; + case LUA_ADDRESS_ANY: + default: + if (task->from_envelope) { + paddr = &task->from_envelope; + } + else { + addrs = MESSAGE_FIELD_CHECK(task, from_mime); + need_update_digest = TRUE; + } + break; + } + + if (addrs) { + if (lua_import_email_address(L, task, 3, &addr)) { + guint i, flags_add = RSPAMD_EMAIL_ADDR_ORIGINAL; + struct rspamd_email_address *tmp; + + if (strcmp(how, "alias") == 0) { + flags_add |= RSPAMD_EMAIL_ADDR_ALIASED; + } + + PTR_ARRAY_FOREACH(addrs, i, tmp) + { + tmp->flags |= flags_add; + } + + if (need_update_digest) { + rspamd_message_update_digest(task->message, + addr->addr, addr->addr_len); + } + + g_ptr_array_add(addrs, addr); + lua_pushboolean(L, true); + } + else { + lua_pushboolean(L, false); + } + } + else if (paddr) { + /* SMTP from case */ + if (lua_import_email_address(L, task, 3, &addr)) { + task->from_envelope_orig = *paddr; + task->from_envelope = addr; + lua_pushboolean(L, true); + } + else { + lua_pushboolean(L, false); + } + } + else { + lua_pushboolean(L, false); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_principal_recipient(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *r; + + if (task) { + r = rspamd_task_get_principal_recipient(task); + if (r != NULL) { + lua_pushstring(L, r); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_reply_sender(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_mime_header *rh; + + if (task) { + + rh = rspamd_message_get_header_array(task, "Reply-To", FALSE); + + if (rh) { + GPtrArray *addrs; + + addrs = rspamd_email_address_from_mime(task->task_pool, rh->decoded, + strlen(rh->decoded), NULL, -1); + + if (addrs == NULL || addrs->len == 0) { + lua_pushnil(L); + } + else { + struct rspamd_email_address *addr; + + addr = (struct rspamd_email_address *) g_ptr_array_index(addrs, 0); + lua_pushlstring(L, addr->addr, addr->addr_len); + } + } + else if (MESSAGE_FIELD_CHECK(task, from_mime) && + MESSAGE_FIELD(task, from_mime)->len >= 1) { + struct rspamd_email_address *addr; + + addr = (struct rspamd_email_address *) g_ptr_array_index( + MESSAGE_FIELD(task, from_mime), 0); + + lua_pushlstring(L, addr->addr, addr->addr_len); + } + else if (task->from_envelope) { + lua_pushlstring(L, task->from_envelope->addr, + task->from_envelope->addr_len); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_user(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + if (task->auth_user != NULL) { + lua_pushstring(L, task->auth_user); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_user(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *new_user; + + if (task) { + + if (lua_type(L, 2) == LUA_TSTRING) { + new_user = lua_tostring(L, 2); + + if (task->auth_user) { + /* Push old user */ + lua_pushstring(L, task->auth_user); + } + else { + lua_pushnil(L); + } + + task->auth_user = rspamd_mempool_strdup(task->task_pool, new_user); + } + else { + /* Reset user */ + if (task->auth_user) { + /* Push old user */ + lua_pushstring(L, task->auth_user); + } + else { + lua_pushnil(L); + } + + task->auth_user = NULL; + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_from_ip(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + if (task->from_addr) { + rspamd_lua_ip_push(L, task->from_addr); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_from_ip(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + rspamd_inet_addr_t *addr = NULL; + + if (!task) { + return luaL_error(L, "no task"); + } + else { + if (lua_type(L, 2) == LUA_TSTRING) { + gsize len; + const gchar *ip_str = lua_tolstring(L, 2, &len); + + if (!rspamd_parse_inet_address(&addr, + ip_str, + len, + RSPAMD_INET_ADDRESS_PARSE_DEFAULT)) { + return luaL_error(L, "invalid IP string: %s", ip_str); + } + else { + if (task->from_addr) { + rspamd_inet_address_free(task->from_addr); + } + + task->from_addr = addr; + } + } + else if (lua_type(L, 2) == LUA_TUSERDATA) { + struct rspamd_lua_ip *ip = lua_check_ip(L, 2); + + if (ip && ip->addr) { + if (task->from_addr) { + rspamd_inet_address_free(task->from_addr); + } + + task->from_addr = rspamd_inet_address_copy(ip->addr, NULL); + } + else { + return luaL_error(L, "invalid IP object"); + } + } + else { + return luaL_error(L, "invalid IP argument type: %s", lua_typename(L, lua_type(L, 2))); + } + } + + return 0; +} + +static gint +lua_task_get_from_ip_num(lua_State *L) +{ + LUA_TRACE_POINT; + msg_err("this function is deprecated and should no longer be used"); + lua_pushnil(L); + return 1; +} + +static gint +lua_task_get_client_ip(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + if (task->client_addr) { + rspamd_lua_ip_push(L, task->client_addr); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_helo(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + if (task->helo != NULL) { + lua_pushstring(L, task->helo); + return 1; + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_subject(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + if (MESSAGE_FIELD_CHECK(task, subject) != NULL) { + lua_pushstring(L, MESSAGE_FIELD(task, subject)); + return 1; + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_helo(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *new_helo; + + if (task) { + new_helo = luaL_checkstring(L, 2); + if (new_helo) { + task->helo = rspamd_mempool_strdup(task->task_pool, new_helo); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_get_hostname(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + if (task->hostname != NULL) { + /* Check whether it looks like an IP address */ + if (*task->hostname == '[') { + /* + * From the milter documentation: + * If the reverse lookup fails or if none of the IP + * addresses of the resolved host name matches the + * original IP address, hostname will contain the + * message sender's IP address enclosed in square + * brackets (e.g. `[a.b.c.d]') + */ + lua_pushnil(L); + } + else { + lua_pushstring(L, task->hostname); + } + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_hostname(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *new_hostname; + + if (task) { + new_hostname = luaL_checkstring(L, 2); + if (new_hostname) { + task->hostname = rspamd_mempool_strdup(task->task_pool, + new_hostname); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_get_images(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + guint nelt = 0, i; + struct rspamd_mime_part *part; + struct rspamd_image **pimg; + + if (task) { + if (task->message) { + if (!lua_task_get_cached(L, task, "images")) { + lua_createtable(L, MESSAGE_FIELD(task, parts)->len, 0); + + PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, parts), i, part) + { + if (part->part_type == RSPAMD_MIME_PART_IMAGE) { + pimg = lua_newuserdata(L, sizeof(struct rspamd_image *)); + rspamd_lua_setclass(L, "rspamd{image}", -1); + *pimg = part->specific.img; + lua_rawseti(L, -2, ++nelt); + } + } + + lua_task_set_cached(L, task, "images", -1); + } + } + else { + lua_newtable(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_archives(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + guint nelt = 0, i; + struct rspamd_mime_part *part; + struct rspamd_archive **parch; + + if (task) { + if (task->message) { + if (!lua_task_get_cached(L, task, "archives")) { + lua_createtable(L, MESSAGE_FIELD(task, parts)->len, 0); + + PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, parts), i, part) + { + if (part->part_type == RSPAMD_MIME_PART_ARCHIVE) { + parch = lua_newuserdata(L, sizeof(struct rspamd_archive *)); + rspamd_lua_setclass(L, "rspamd{archive}", -1); + *parch = part->specific.arch; + lua_rawseti(L, -2, ++nelt); + } + } + + lua_task_set_cached(L, task, "archives", -1); + } + } + else { + lua_newtable(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_dkim_results(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + guint nelt = 0, i; + struct rspamd_dkim_check_result **pres, **cur; + + if (task) { + if (!lua_task_get_cached(L, task, "dkim_results")) { + pres = rspamd_mempool_get_variable(task->task_pool, + RSPAMD_MEMPOOL_DKIM_CHECK_RESULTS); + + if (pres == NULL) { + lua_newtable(L); + } + else { + for (cur = pres; *cur != NULL; cur++) { + nelt++; + } + + lua_createtable(L, nelt, 0); + + for (i = 0; i < nelt; i++) { + struct rspamd_dkim_check_result *res = pres[i]; + const gchar *result_str = "unknown"; + + lua_createtable(L, 0, 4); + + switch (res->rcode) { + case DKIM_CONTINUE: + result_str = "allow"; + break; + case DKIM_REJECT: + result_str = "reject"; + break; + case DKIM_TRYAGAIN: + result_str = "tempfail"; + break; + case DKIM_NOTFOUND: + result_str = "not found"; + break; + case DKIM_RECORD_ERROR: + result_str = "bad record"; + break; + case DKIM_PERM_ERROR: + result_str = "permanent error"; + break; + default: + break; + } + + rspamd_lua_table_set(L, "result", result_str); + + if (res->domain) { + rspamd_lua_table_set(L, "domain", res->domain); + } + + if (res->selector) { + rspamd_lua_table_set(L, "selector", res->selector); + } + + if (res->short_b) { + rspamd_lua_table_set(L, "bhash", res->short_b); + } + + if (res->fail_reason) { + rspamd_lua_table_set(L, "fail_reason", res->fail_reason); + } + + lua_rawseti(L, -2, i + 1); + } + } + + lua_task_set_cached(L, task, "dkim_results", -1); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static inline gboolean +lua_push_symbol_result(lua_State *L, + struct rspamd_task *task, + const gchar *symbol, + struct rspamd_symbol_result *symbol_result, + struct rspamd_scan_result *metric_res, + gboolean add_metric, + gboolean add_name) +{ + + struct rspamd_symbol_result *s = NULL; + struct rspamd_symbol_option *opt; + struct rspamd_symbols_group *sym_group; + guint i; + gint j = 1, table_fields_cnt = 4; + + if (!metric_res) { + metric_res = task->result; + } + + if (!symbol_result) { + s = rspamd_task_find_symbol_result(task, symbol, metric_res); + } + else { + s = symbol_result; + } + + if (s && !(s->flags & RSPAMD_SYMBOL_RESULT_IGNORED)) { + if (add_metric) { + table_fields_cnt++; + } + if (add_name) { + table_fields_cnt++; + } + + lua_createtable(L, 0, table_fields_cnt); + + if (add_name) { + lua_pushstring(L, "name"); + lua_pushstring(L, symbol); + lua_settable(L, -3); + } + lua_pushstring(L, "score"); + lua_pushnumber(L, s->score); + lua_settable(L, -3); + + if (s->sym && s->sym->gr) { + lua_pushstring(L, "group"); + lua_pushstring(L, s->sym->gr->name); + lua_settable(L, -3); + + lua_pushstring(L, "groups"); + lua_createtable(L, s->sym->groups->len, 0); + + PTR_ARRAY_FOREACH(s->sym->groups, i, sym_group) + { + lua_pushstring(L, sym_group->name); + lua_rawseti(L, -2, i + 1); + } + + lua_settable(L, -3); + } + else { + lua_pushstring(L, "group"); + lua_pushstring(L, "ungrouped"); + lua_settable(L, -3); + } + + if (s->options) { + lua_pushstring(L, "options"); + lua_createtable(L, kh_size(s->options), 0); + + DL_FOREACH(s->opts_head, opt) + { + lua_pushlstring(L, opt->option, opt->optlen); + lua_rawseti(L, -2, j++); + } + + lua_settable(L, -3); + } + + return TRUE; + } + + return FALSE; +} + +static gint +lua_task_get_symbol(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *symbol; + gboolean found = FALSE; + + symbol = luaL_checkstring(L, 2); + + if (task && symbol) { + struct rspamd_scan_result *sres = NULL; + + if (lua_isstring(L, 3)) { + sres = rspamd_find_metric_result(task, lua_tostring(L, 3)); + + if (sres == NULL) { + return luaL_error(L, "invalid scan result: %s", + lua_tostring(L, 3)); + } + } + + /* Always push as a table for compatibility :( */ + lua_createtable(L, 1, 0); + + if ((found = lua_push_symbol_result(L, task, symbol, + NULL, sres, TRUE, FALSE))) { + lua_rawseti(L, -2, 1); + } + else { + /* Pop table */ + lua_pop(L, 1); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + if (!found) { + lua_pushnil(L); + } + + return 1; +} + +static gint +lua_task_has_symbol(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_symbol_result *s; + const gchar *symbol; + gboolean found = FALSE; + + symbol = luaL_checkstring(L, 2); + + if (task && symbol) { + if (lua_isstring(L, 3)) { + s = rspamd_task_find_symbol_result(task, symbol, + rspamd_find_metric_result(task, lua_tostring(L, 3))); + + if (s && !(s->flags & RSPAMD_SYMBOL_RESULT_IGNORED)) { + found = TRUE; + } + } + else { + s = rspamd_task_find_symbol_result(task, symbol, NULL); + + if (s && !(s->flags & RSPAMD_SYMBOL_RESULT_IGNORED)) { + found = TRUE; + } + } + lua_pushboolean(L, found); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_enable_symbol(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *symbol; + gboolean found = FALSE; + + symbol = luaL_checkstring(L, 2); + + if (task && symbol) { + found = rspamd_symcache_enable_symbol(task, task->cfg->cache, symbol); + lua_pushboolean(L, found); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_disable_symbol(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *symbol; + gboolean found = FALSE; + + symbol = luaL_checkstring(L, 2); + + if (task && symbol) { + found = rspamd_symcache_disable_symbol(task, task->cfg->cache, symbol); + lua_pushboolean(L, found); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_symbols(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_scan_result *mres; + gint i = 1; + struct rspamd_symbol_result *s; + + if (task) { + mres = task->result; + + if (lua_isstring(L, 2)) { + mres = rspamd_find_metric_result(task, lua_tostring(L, 2)); + } + + if (mres) { + lua_createtable(L, kh_size(mres->symbols), 0); + lua_createtable(L, kh_size(mres->symbols), 0); + + kh_foreach_value(mres->symbols, s, { + if (!(s->flags & RSPAMD_SYMBOL_RESULT_IGNORED)) { + lua_pushstring(L, s->name); + lua_rawseti(L, -3, i); + lua_pushnumber(L, s->score); + lua_rawseti(L, -2, i); + i++; + } + }); + } + else { + lua_createtable(L, 0, 0); + lua_createtable(L, 0, 0); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 2; +} + +static gint +lua_task_get_symbols_all(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_scan_result *mres; + struct rspamd_symbol_result *s; + gboolean found = FALSE; + gint i = 1; + + if (task) { + mres = task->result; + + if (lua_isstring(L, 2)) { + mres = rspamd_find_metric_result(task, lua_tostring(L, 2)); + } + + if (mres) { + found = TRUE; + lua_createtable(L, kh_size(mres->symbols), 0); + + kh_foreach_value(mres->symbols, s, { + if (!(s->flags & RSPAMD_SYMBOL_RESULT_IGNORED)) { + lua_push_symbol_result(L, task, s->name, s, mres, FALSE, TRUE); + lua_rawseti(L, -2, i++); + } + }); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + if (!found) { + lua_pushnil(L); + } + + return 1; +} + + +static gint +lua_task_get_symbols_numeric(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_scan_result *mres; + gint i = 1, id; + struct rspamd_symbol_result *s; + + if (task) { + mres = task->result; + + if (lua_isstring(L, 2)) { + mres = rspamd_find_metric_result(task, lua_tostring(L, 2)); + } + + if (mres) { + lua_createtable(L, kh_size(mres->symbols), 0); + lua_createtable(L, kh_size(mres->symbols), 0); + + lua_createtable(L, kh_size(mres->symbols), 0); + + kh_foreach_value(mres->symbols, s, { + if (!(s->flags & RSPAMD_SYMBOL_RESULT_IGNORED)) { + id = rspamd_symcache_find_symbol(task->cfg->cache, + s->name); + lua_pushinteger(L, id); + lua_rawseti(L, -3, i); + lua_pushnumber(L, s->score); + lua_rawseti(L, -2, i); + i++; + } + }); + } + else { + lua_createtable(L, 0, 0); + lua_createtable(L, 0, 0); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 2; +} + +static gint +lua_task_get_groups(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gboolean need_private; + struct rspamd_scan_result *mres; + struct rspamd_symbols_group *gr; + gdouble gr_score; + + if (task) { + mres = task->result; + + if (lua_isboolean(L, 2)) { + need_private = lua_toboolean(L, 2); + } + else { + need_private = !(task->cfg->public_groups_only); + } + + if (lua_isstring(L, 3)) { + mres = rspamd_find_metric_result(task, lua_tostring(L, 3)); + } + + if (mres == NULL) { + lua_pushnil(L); + + return 1; + } + + lua_createtable(L, 0, kh_size(mres->sym_groups)); + + kh_foreach(mres->sym_groups, gr, gr_score, { + if (!(gr->flags & RSPAMD_SYMBOL_GROUP_PUBLIC)) { + if (!need_private) { + continue; + } + } + + lua_pushnumber(L, gr_score); + lua_setfield(L, -2, gr->name); + }); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +struct tokens_foreach_cbdata { + struct rspamd_task *task; + lua_State *L; + gint idx; + gboolean normalize; +}; + +static void +tokens_foreach_cb(struct rspamd_symcache_item *item, gpointer ud) +{ + struct tokens_foreach_cbdata *cbd = ud; + struct rspamd_symbol_result *s; + gint flags; + const gchar *sym; + + sym = rspamd_symcache_item_name(item); + flags = rspamd_symcache_item_flags(item); + + if (flags & SYMBOL_TYPE_NOSTAT) { + return; + } + + if ((s = rspamd_task_find_symbol_result(cbd->task, sym, NULL)) != NULL) { + if (s->flags & RSPAMD_SYMBOL_RESULT_IGNORED) { + lua_pushnumber(cbd->L, 0.0); + } + else { + if (cbd->normalize) { + lua_pushnumber(cbd->L, tanh(s->score)); + } + else { + lua_pushnumber(cbd->L, s->score); + } + } + } + else { + lua_pushnumber(cbd->L, 0.0); + } + + lua_rawseti(cbd->L, -2, cbd->idx++); +} + +static gint +lua_task_get_symbols_tokens(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct tokens_foreach_cbdata cbd; + + if (task) { + cbd.task = task; + cbd.L = L; + cbd.idx = 1; + cbd.normalize = TRUE; + + if (lua_type(L, 2) == LUA_TBOOLEAN) { + cbd.normalize = lua_toboolean(L, 2); + } + else { + cbd.normalize = TRUE; + } + + lua_createtable(L, + rspamd_symcache_stats_symbols_count(task->cfg->cache), 0); + rspamd_symcache_foreach(task->cfg->cache, tokens_foreach_cb, &cbd); + } + else { + return luaL_error(L, "invalid arguments"); + } + + /* Return type is table created */ + return 1; +} + +static gint +lua_task_process_ann_tokens(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gint offset = luaL_checkinteger(L, 4); + gdouble min_score = 0.0; + + if (task && lua_istable(L, 2) && lua_istable(L, 3)) { + guint symlen = rspamd_lua_table_size(L, 2); + if (lua_isnumber(L, 5)) { + min_score = lua_tonumber(L, 5); + } + + for (guint i = 1; i <= symlen; i++, offset++) { + const gchar *sym; + struct rspamd_symbol_result *sres; + + lua_rawgeti(L, 2, i); + sym = lua_tostring(L, -1); + + /* + * TODO: this cycle involves one hash lookup per symbol in a profile + * Basically, in a common case that would be a table of all symbols + * So we need to do N_symbols hash lookups which is not optimal + * The optimal solution is to convert [sym1, sym2, ... symn] profile + * to a set {sym1 = true, sym2 = true, ...} and then for each + * resulting symbol check this table. + * + * That would lead to N_results lookups which is usually MUCH smaller + */ + sres = rspamd_task_find_symbol_result(task, sym, NULL); + + if (sres && !(sres->flags & RSPAMD_SYMBOL_RESULT_IGNORED)) { + + if (!isnan(sres->score) && !isinf(sres->score) && + (!sres->sym || + !(rspamd_symcache_item_flags(sres->sym->cache_item) & SYMBOL_TYPE_NOSTAT))) { + + gdouble norm_score; + + if (sres->sym && !isnan(sres->sym->score)) { + if (sres->sym->score == 0) { + + if (sres->score == 0) { + /* Binary symbol */ + norm_score = 1.0; + } + else { + norm_score = fabs(tanh(sres->score)); + } + } + else { + /* Get dynamic weight */ + norm_score = fabs(sres->score / sres->sym->score); + + if (norm_score > 1.0) { + /* Multiple hits, we assume them as a single one */ + norm_score = 1.0; + } + } + } + else { + norm_score = fabs(tanh(sres->score)); + } + + lua_pushnumber(L, MAX(min_score, norm_score)); + lua_rawseti(L, 3, offset + 1); + } + } + + lua_pop(L, 1); /* Symbol name */ + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +enum lua_date_type { + DATE_CONNECT = 0, + DATE_MESSAGE, + DATE_INVALID +}; + +static enum lua_date_type +lua_task_detect_date_type(struct rspamd_task *task, + lua_State *L, gint idx, gboolean *gmt) +{ + enum lua_date_type type = DATE_CONNECT; + + if (lua_type(L, idx) == LUA_TNUMBER) { + gint num = lua_tonumber(L, idx); + if (num >= DATE_CONNECT && num < DATE_INVALID) { + return num; + } + } + else if (lua_type(L, idx) == LUA_TTABLE) { + const gchar *str; + + lua_pushvalue(L, idx); + lua_pushstring(L, "format"); + lua_gettable(L, -2); + + str = lua_tostring(L, -1); + + if (str) { + if (g_ascii_strcasecmp(str, "message") == 0) { + type = DATE_MESSAGE; + } + } + else { + msg_warn_task("date format has not been specified"); + } + + lua_pop(L, 1); + + lua_pushstring(L, "gmt"); + lua_gettable(L, -2); + + if (lua_type(L, -1) == LUA_TBOOLEAN) { + *gmt = lua_toboolean(L, -1); + } + + /* Value and table */ + lua_pop(L, 2); + } + + return type; +} + +static gint +lua_task_get_date(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_mime_header *h; + gdouble tim; + enum lua_date_type type = DATE_CONNECT; + gboolean gmt = TRUE; + + if (task != NULL) { + if (lua_gettop(L) > 1) { + type = lua_task_detect_date_type(task, L, 2, &gmt); + } + /* Get GMT date and store it to time_t */ + if (type == DATE_CONNECT) { + tim = task->task_timestamp; + + if (!gmt) { + struct tm t; + time_t tt; + + tt = tim; + rspamd_localtime(tt, &t); +#if !defined(__sun) + t.tm_gmtoff = 0; +#endif + t.tm_isdst = 0; + /* Preserve fractional part as Lua is aware of it */ + tim = mktime(&t) + (tim - tt); + } + } + else { + h = rspamd_message_get_header_array(task, "Date", FALSE); + + if (h) { + time_t tt; + struct tm t; + GError *err = NULL; + + tt = rspamd_parse_smtp_date(h->decoded, strlen(h->decoded), + &err); + + if (err == NULL) { + if (!gmt) { + rspamd_localtime(tt, &t); +#if !defined(__sun) + t.tm_gmtoff = 0; +#endif + t.tm_isdst = 0; + tim = mktime(&t); + } + else { + tim = tt; + } + } + else { + g_error_free(err); + tim = 0.0; + } + } + else { + tim = 0.0; + } + } + + lua_pushnumber(L, tim); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_message_id(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task != NULL) { + if (MESSAGE_FIELD_CHECK(task, message_id) != NULL) { + lua_pushstring(L, MESSAGE_FIELD(task, message_id)); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_timeval(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct timeval tv; + + if (task != NULL) { + if (lua_isboolean(L, 2) && !!lua_toboolean(L, 2)) { + lua_pushnumber(L, task->task_timestamp); + } + else { + double_to_tv(task->task_timestamp, &tv); + lua_createtable(L, 0, 2); + lua_pushstring(L, "tv_sec"); + lua_pushinteger(L, (lua_Integer) tv.tv_sec); + lua_settable(L, -3); + lua_pushstring(L, "tv_usec"); + lua_pushinteger(L, (lua_Integer) tv.tv_usec); + lua_settable(L, -3); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_scan_time(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gboolean set = TRUE; + + if (task != NULL) { + if (lua_isboolean(L, 2)) { + set = lua_toboolean(L, 2); + } + + rspamd_task_set_finish_time(task); + gdouble diff = task->time_real_finish - task->task_timestamp; + lua_pushnumber(L, diff); + lua_pushnumber(L, diff); + + if (!set) { + /* Reset to nan to allow further calcs in rspamd_task_set_finish_time */ + task->time_real_finish = NAN; + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 2; +} + +static gint +lua_task_get_size(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task != NULL) { + lua_pushinteger(L, task->msg.len); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +/** +* - `no_log`: do not log task summary +* - `no_stat`: do not include task into scanned stats +* - `pass_all`: check all filters for task +* - `extended_urls`: output extended info about urls +* - `skip`: skip task processing +*/ + +#define LUA_TASK_FLAG_WRITE(flag, set) \ + do { \ + task->flags = (set) ? (task->flags | (flag)) : (task->flags & ~(flag)); \ + } while (0) + +#define LUA_TASK_SET_FLAG(flag, strname, macro, set) \ + do { \ + if (!found && strcmp((flag), strname) == 0) { \ + LUA_TASK_FLAG_WRITE((macro), set); \ + found = TRUE; \ + } \ + } while (0) + +#define LUA_TASK_FLAG_READ(flag) \ + do { \ + lua_pushboolean(L, !!(task->flags & (flag))); \ + } while (0) + +#define LUA_TASK_GET_FLAG(flag, strname, macro) \ + do { \ + if (!found && strcmp((flag), strname) == 0) { \ + LUA_TASK_FLAG_READ((macro)); \ + found = TRUE; \ + } \ + } while (0) + +#define LUA_TASK_PROTOCOL_FLAG_READ(flag) \ + do { \ + lua_pushboolean(L, !!(task->protocol_flags & (flag))); \ + } while (0) + +#define LUA_TASK_GET_PROTOCOL_FLAG(flag, strname, macro) \ + do { \ + if (!found && strcmp((flag), strname) == 0) { \ + LUA_TASK_PROTOCOL_FLAG_READ((macro)); \ + found = TRUE; \ + } \ + } while (0) + +static gint +lua_task_set_flag(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *flag = luaL_checkstring(L, 2); + gboolean set = TRUE, found = FALSE; + + if (lua_gettop(L) >= 3) { + set = lua_toboolean(L, 3); + } + + if (task != NULL && flag != NULL) { + LUA_TASK_SET_FLAG(flag, "pass_all", RSPAMD_TASK_FLAG_PASS_ALL, set); + LUA_TASK_SET_FLAG(flag, "no_log", RSPAMD_TASK_FLAG_NO_LOG, set); + LUA_TASK_SET_FLAG(flag, "no_stat", RSPAMD_TASK_FLAG_NO_STAT, set); + LUA_TASK_SET_FLAG(flag, "skip", RSPAMD_TASK_FLAG_SKIP, set); + LUA_TASK_SET_FLAG(flag, "learn_spam", RSPAMD_TASK_FLAG_LEARN_SPAM, set); + LUA_TASK_SET_FLAG(flag, "learn_ham", RSPAMD_TASK_FLAG_LEARN_HAM, set); + LUA_TASK_SET_FLAG(flag, "broken_headers", + RSPAMD_TASK_FLAG_BROKEN_HEADERS, set); + LUA_TASK_SET_FLAG(flag, "greylisted", RSPAMD_TASK_FLAG_GREYLISTED, set); + LUA_TASK_SET_FLAG(flag, "skip_process", RSPAMD_TASK_FLAG_SKIP_PROCESS, set); + LUA_TASK_SET_FLAG(flag, "message_rewrite", RSPAMD_TASK_FLAG_MESSAGE_REWRITE, set); + + if (!found) { + msg_warn_task("unknown flag requested: %s", flag); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_has_flag(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *flag = luaL_checkstring(L, 2); + gboolean found = FALSE; + + if (task != NULL && flag != NULL) { + LUA_TASK_GET_FLAG(flag, "pass_all", RSPAMD_TASK_FLAG_PASS_ALL); + LUA_TASK_GET_FLAG(flag, "no_log", RSPAMD_TASK_FLAG_NO_LOG); + LUA_TASK_GET_FLAG(flag, "no_stat", RSPAMD_TASK_FLAG_NO_STAT); + LUA_TASK_GET_FLAG(flag, "skip", RSPAMD_TASK_FLAG_SKIP); + LUA_TASK_GET_FLAG(flag, "learn_spam", RSPAMD_TASK_FLAG_LEARN_SPAM); + LUA_TASK_GET_FLAG(flag, "learn_ham", RSPAMD_TASK_FLAG_LEARN_HAM); + LUA_TASK_GET_FLAG(flag, "greylisted", RSPAMD_TASK_FLAG_GREYLISTED); + LUA_TASK_GET_FLAG(flag, "broken_headers", + RSPAMD_TASK_FLAG_BROKEN_HEADERS); + LUA_TASK_GET_FLAG(flag, "skip_process", + RSPAMD_TASK_FLAG_SKIP_PROCESS); + LUA_TASK_GET_FLAG(flag, "bad_unicode", + RSPAMD_TASK_FLAG_BAD_UNICODE); + LUA_TASK_GET_FLAG(flag, "mime", + RSPAMD_TASK_FLAG_MIME); + LUA_TASK_GET_FLAG(flag, "message_rewrite", + RSPAMD_TASK_FLAG_MESSAGE_REWRITE); + LUA_TASK_GET_PROTOCOL_FLAG(flag, "milter", + RSPAMD_TASK_PROTOCOL_FLAG_MILTER); + + if (!found) { + msg_warn_task("unknown flag requested: %s", flag); + lua_pushboolean(L, 0); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_flags(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gint idx = 1; + guint flags, bit, i; + + if (task) { + lua_createtable(L, 8, 0); + + flags = task->flags; + + for (i = 0; i <= RSPAMD_TASK_FLAG_MAX_SHIFT; i++) { + bit = (1U << i); + + if (flags & bit) { + switch (bit) { + case RSPAMD_TASK_FLAG_PASS_ALL: + lua_pushstring(L, "pass_all"); + lua_rawseti(L, -2, idx++); + break; + case RSPAMD_TASK_FLAG_NO_LOG: + lua_pushstring(L, "no_log"); + lua_rawseti(L, -2, idx++); + break; + case RSPAMD_TASK_FLAG_NO_STAT: + lua_pushstring(L, "no_stat"); + lua_rawseti(L, -2, idx++); + break; + case RSPAMD_TASK_FLAG_SKIP: + lua_pushstring(L, "skip"); + lua_rawseti(L, -2, idx++); + break; + case RSPAMD_TASK_FLAG_BROKEN_HEADERS: + lua_pushstring(L, "broken_headers"); + lua_rawseti(L, -2, idx++); + break; + case RSPAMD_TASK_FLAG_LEARN_SPAM: + lua_pushstring(L, "learn_spam"); + lua_rawseti(L, -2, idx++); + break; + case RSPAMD_TASK_FLAG_LEARN_HAM: + lua_pushstring(L, "learn_ham"); + lua_rawseti(L, -2, idx++); + break; + case RSPAMD_TASK_FLAG_GREYLISTED: + lua_pushstring(L, "greylisted"); + lua_rawseti(L, -2, idx++); + break; + case RSPAMD_TASK_FLAG_SKIP_PROCESS: + lua_pushstring(L, "skip_process"); + lua_rawseti(L, -2, idx++); + break; + case RSPAMD_TASK_FLAG_MESSAGE_REWRITE: + lua_pushstring(L, "message_rewrite"); + lua_rawseti(L, -2, idx++); + break; + default: + break; + } + } + } + + if (task->protocol_flags & RSPAMD_TASK_PROTOCOL_FLAG_MILTER) { + lua_pushstring(L, "milter"); + lua_rawseti(L, -2, idx++); + } + if (task->protocol_flags & RSPAMD_TASK_PROTOCOL_FLAG_BODY_BLOCK) { + lua_pushstring(L, "body_block"); + lua_rawseti(L, -2, idx++); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_digest(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gchar hexbuf[sizeof(MESSAGE_FIELD(task, digest)) * 2 + 1]; + gint r; + + if (task) { + if (task->message) { + r = rspamd_encode_hex_buf(MESSAGE_FIELD(task, digest), + sizeof(MESSAGE_FIELD(task, digest)), + hexbuf, sizeof(hexbuf) - 1); + + if (r > 0) { + hexbuf[r] = '\0'; + lua_pushstring(L, hexbuf); + } + else { + lua_pushnil(L); + } + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_learn(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gboolean is_spam = FALSE; + const gchar *clname = NULL; + GError *err = NULL; + int ret = 1; + + if (task == NULL) { + return luaL_error(L, "invalid arguments"); + } + + is_spam = lua_toboolean(L, 2); + if (lua_gettop(L) > 2) { + clname = luaL_checkstring(L, 3); + } + + if (!rspamd_learn_task_spam(task, is_spam, clname, &err)) { + lua_pushboolean(L, FALSE); + if (err != NULL) { + lua_pushstring(L, err->message); + ret = 2; + } + } + else { + lua_pushboolean(L, TRUE); + } + + return ret; +} + +static gint +lua_task_set_settings(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + ucl_object_t *settings; + const ucl_object_t *act, *metric_elt, *vars, *cur; + ucl_object_iter_t it = NULL; + struct rspamd_scan_result *mres; + guint i; + + settings = ucl_object_lua_import(L, 2); + + if (settings != NULL && task != NULL) { + + if (task->settings) { + /* Do not allow to set settings on top of the existing ones */ + ucl_object_unref(settings); + + return luaL_error(L, "invalid invocation: settings has been already set"); + } + + metric_elt = ucl_object_lookup(settings, DEFAULT_METRIC); + + if (metric_elt) { + task->settings = ucl_object_ref(metric_elt); + ucl_object_unref(settings); + } + else { + task->settings = settings; + } + + act = ucl_object_lookup(task->settings, "actions"); + + if (act && ucl_object_type(act) == UCL_OBJECT) { + /* Adjust desired actions */ + mres = task->result; + + it = NULL; + + while ((cur = ucl_object_iterate(act, &it, true)) != NULL) { + const gchar *act_name = ucl_object_key(cur); + struct rspamd_action_config *action_config = NULL; + double act_score; + enum rspamd_action_type act_type; + + if (!rspamd_action_from_str(act_name, &act_type)) { + act_type = -1; + } + + for (i = 0; i < mres->nactions; i++) { + struct rspamd_action_config *cur_act = &mres->actions_config[i]; + + if (cur_act->action->action_type == METRIC_ACTION_CUSTOM && + act_type == -1) { + /* Compare by name */ + if (g_ascii_strcasecmp(act_name, cur_act->action->name) == 0) { + action_config = cur_act; + break; + } + } + else { + if (cur_act->action->action_type == act_type) { + action_config = cur_act; + break; + } + } + } + + if (!action_config) { + act_score = ucl_object_todouble(cur); + if (!isnan(act_score)) { + struct rspamd_action *new_act; + + new_act = rspamd_config_get_action(task->cfg, act_name); + + if (new_act == NULL) { + /* New action! */ + msg_info_task("added new action %s with threshold %.2f " + "due to settings", + act_name, + act_score); + new_act = rspamd_mempool_alloc0(task->task_pool, + sizeof(*new_act)); + new_act->name = rspamd_mempool_strdup(task->task_pool, act_name); + new_act->action_type = METRIC_ACTION_CUSTOM; + new_act->threshold = act_score; + } + else { + /* A disabled action that is enabled */ + msg_info_task("enabled disabled action %s with threshold %.2f " + "due to settings", + act_name, + act_score); + } + + /* Insert it to the mres structure */ + gsize new_actions_cnt = mres->nactions + 1; + struct rspamd_action_config *old_actions = mres->actions_config; + + mres->actions_config = rspamd_mempool_alloc(task->task_pool, + sizeof(struct rspamd_action_config) * new_actions_cnt); + memcpy(mres->actions_config, old_actions, + sizeof(struct rspamd_action_config) * mres->nactions); + mres->actions_config[mres->nactions].action = new_act; + mres->actions_config[mres->nactions].cur_limit = act_score; + mres->nactions++; + } + /* Disabled/missing action is disabled one more time, not an error */ + } + else { + /* Found the existing configured action */ + if (ucl_object_type(cur) == UCL_NULL) { + /* Disable action completely */ + action_config->flags |= RSPAMD_ACTION_RESULT_DISABLED; + msg_info_task("disabled action %s due to settings", + action_config->action->name); + } + else { + act_score = ucl_object_todouble(cur); + if (isnan(act_score)) { + msg_info_task("disabled action %s threshold (was %.2f) due to settings", + action_config->action->name, + action_config->cur_limit); + action_config->flags |= RSPAMD_ACTION_RESULT_NO_THRESHOLD; + } + else { + action_config->cur_limit = act_score; + msg_debug_task("adjusted action %s: %.2f -> %.2f", + act_name, + action_config->cur_limit, + act_score); + } + } + } + } + } + + vars = ucl_object_lookup(task->settings, "variables"); + if (vars && ucl_object_type(vars) == UCL_OBJECT) { + /* Set memory pool variables */ + it = NULL; + + while ((cur = ucl_object_iterate(vars, &it, true)) != NULL) { + if (ucl_object_type(cur) == UCL_STRING) { + rspamd_mempool_set_variable(task->task_pool, + ucl_object_key(cur), rspamd_mempool_strdup(task->task_pool, ucl_object_tostring(cur)), NULL); + } + } + } + + rspamd_symcache_process_settings(task, task->cfg->cache); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_set_milter_reply(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + ucl_object_t *reply, *prev; + + reply = ucl_object_lua_import(L, 2); + + if (reply != NULL && task != NULL) { + prev = rspamd_mempool_get_variable(task->task_pool, + RSPAMD_MEMPOOL_MILTER_REPLY); + + if (prev) { + /* + * We need to be very special about the add_headers part + * If we want to insert some existing object, such as + * add_headers = { + * hdr = {value = val1, order = 1}, + * } + * + * and new header has something similar: + * add_headers = { + * hdr = {value = val2, order = 1}, + * } + * + * then we need to convert it to an array... + * + * add_headers = { + * hdr = [{value = val1, order = 1}, {value = val2, order = 1}], + * } + * + * UCL itself cannot do it directly. So the trick is to extract the + * original object, pack it into an array and then insert it back. + * + * I wish there was a simpler way to do it... + */ + const ucl_object_t *add_hdrs = ucl_object_lookup(prev, "add_headers"); + const ucl_object_t *nadd_hdrs = ucl_object_lookup(reply, "add_headers"); + + if (add_hdrs && nadd_hdrs) { + ucl_object_iter_t it = NULL; + const ucl_object_t *cur; + + while ((cur = ucl_object_iterate(nadd_hdrs, &it, true)) != NULL) { + gsize klen; + const gchar *key = ucl_object_keyl(cur, &klen); + const ucl_object_t *existing; + + existing = ucl_object_lookup_len(add_hdrs, key, klen); + + if (existing && ucl_object_type(existing) != UCL_ARRAY) { + ucl_object_t *ar = ucl_object_typed_new(UCL_ARRAY); + + ucl_array_append(ar, ucl_object_ref(existing)); + /* Avoid double refcount */ + key = ucl_object_keyl(existing, &klen); + ucl_object_delete_keyl((ucl_object_t *) add_hdrs, key, klen); + ucl_object_insert_key((ucl_object_t *) add_hdrs, + ar, key, klen, false); + } + } + } + + if (!ucl_object_merge(prev, reply, false)) { + msg_err_task("internal error: cannot merge two objects when setting milter reply!"); + } + ucl_object_unref(reply); + } + else { + rspamd_mempool_set_variable(task->task_pool, + RSPAMD_MEMPOOL_MILTER_REPLY, + reply, + (rspamd_mempool_destruct_t) ucl_object_unref); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_get_settings(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task != NULL) { + + if (task->settings) { + return ucl_object_push_lua(L, task->settings, true); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_lookup_settings(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *key = NULL; + const ucl_object_t *elt; + + if (task != NULL) { + + if (lua_isstring(L, 2)) { + key = lua_tostring(L, 2); + } + + if (task->settings) { + if (key == NULL) { + return ucl_object_push_lua(L, task->settings, true); + } + else { + elt = ucl_object_lookup(task->settings, key); + + if (elt) { + return ucl_object_push_lua(L, elt, true); + } + else { + lua_pushnil(L); + } + } + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_settings_id(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task != NULL) { + + if (task->settings_elt) { + lua_pushinteger(L, task->settings_elt->id); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_settings_id(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + guint32 id = lua_tointeger(L, 2); + + if (task != NULL && id != 0) { + + struct rspamd_config_settings_elt *selt = + rspamd_config_find_settings_id_ref(task->cfg, id); + + if (selt == NULL) { + return luaL_error(L, "settings id %f is unknown", (lua_Number) id); + } + if (task->settings_elt) { + /* Overwrite existing settings from Lua */ + REF_RELEASE(task->settings_elt); + lua_pushboolean(L, true); + } + else { + lua_pushboolean(L, false); + } + + task->settings_elt = selt; + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_cache_get(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *key = luaL_checkstring(L, 2); + + if (task && key) { + if (!lua_task_get_cached(L, task, key)) { + lua_pushnil(L); + } + } + else { + luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_cache_set(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *key = luaL_checkstring(L, 2); + + if (task && key && lua_gettop(L) >= 3) { + lua_task_set_cached(L, task, key, 3); + } + else { + luaL_error(L, "invalid arguments"); + } + + return 0; +} + +struct lua_file_cbdata { + gchar *fname; + gint fd; + gboolean keep; +}; + +static void +lua_tmp_file_dtor(gpointer p) +{ + struct lua_file_cbdata *cbdata = p; + + if (!cbdata->keep) { + unlink(cbdata->fname); + } + + close(cbdata->fd); +} + +static gint +lua_task_store_in_file(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gboolean force_new = FALSE, keep = FALSE; + gchar fpath[PATH_MAX]; + const gchar *tmpmask = NULL, *fname = NULL; + guint mode = 00600; + gint fd; + struct lua_file_cbdata *cbdata; + GError *err = NULL; + + if (task) { + if (lua_istable(L, 2)) { + if (!rspamd_lua_parse_table_arguments(L, 2, &err, + RSPAMD_LUA_PARSE_ARGUMENTS_DEFAULT, + "filename=S;tmpmask=S;mode=I;force_new=B;keep=B", + &fname, &tmpmask, &mode, &force_new, &keep)) { + msg_err_task("cannot get parameters list: %e", err); + + if (err) { + g_error_free(err); + } + + return luaL_error(L, "invalid arguments"); + } + } + else if (lua_isnumber(L, 2)) { + mode = lua_tointeger(L, 2); + } + + if (!force_new && (task->flags & RSPAMD_TASK_FLAG_FILE) && + task->msg.fpath) { + lua_pushstring(L, task->msg.fpath); + } + else { + if (fname == NULL) { + if (tmpmask == NULL) { + rspamd_snprintf(fpath, sizeof(fpath), "%s%c%s", + task->cfg->temp_dir, + G_DIR_SEPARATOR, "rmsg-XXXXXXXXXX"); + } + else { + rspamd_snprintf(fpath, sizeof(fpath), "%s", tmpmask); + } + + fd = g_mkstemp_full(fpath, O_WRONLY | O_CREAT | O_EXCL, mode); + fname = fpath; + + if (fd != -1) { + fchmod(fd, mode); + } + } + else { + fd = rspamd_file_xopen(fname, O_WRONLY | O_CREAT | O_EXCL, + (guint) mode, FALSE); + } + + if (fd == -1) { + msg_err_task("cannot save file: %s", strerror(errno)); + lua_pushnil(L); + } + else { + if (write(fd, task->msg.begin, task->msg.len) == -1) { + msg_err_task("cannot write file %s: %s", fpath, + strerror(errno)); + unlink(fname); + close(fd); + lua_pushnil(L); + + return 1; + } + + cbdata = rspamd_mempool_alloc(task->task_pool, sizeof(*cbdata)); + cbdata->fd = fd; + cbdata->fname = rspamd_mempool_strdup(task->task_pool, fname); + cbdata->keep = keep; + lua_pushstring(L, cbdata->fname); + rspamd_mempool_add_destructor(task->task_pool, + lua_tmp_file_dtor, cbdata); + } + } + } + else { + luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_process_regexp(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_lua_regexp *re = NULL; + gboolean strong = FALSE; + const gchar *type_str = NULL, *header_str = NULL; + gsize header_len = 0; + GError *err = NULL; + gint ret = 0; + enum rspamd_re_type type = RSPAMD_RE_BODY; + + /* + * - `re`* : regular expression object + * - `type`*: type of regular expression: + * + `mime`: mime regexp + * + `rawmime`: raw mime regexp + * + `header`: header regexp + * + `rawheader`: raw header expression + * + `body`: raw body regexp + * + `url`: url regexp + * - `header`: for header and rawheader regexp means the name of header + * - `strong`: case sensitive match for headers + */ + if (task != NULL) { + if (!rspamd_lua_parse_table_arguments(L, 2, &err, + RSPAMD_LUA_PARSE_ARGUMENTS_DEFAULT, + "*re=U{regexp};*type=S;header=V;strong=B", + &re, &type_str, &header_len, &header_str, + &strong)) { + msg_err_task("cannot get parameters list: %e", err); + + if (err) { + g_error_free(err); + } + + return luaL_error(L, "invalid arguments"); + } + else { + type = rspamd_re_cache_type_from_string(type_str); + + if ((type == RSPAMD_RE_HEADER || type == RSPAMD_RE_RAWHEADER) && header_str == NULL) { + msg_err_task( + "header argument is mandatory for header/rawheader regexps"); + } + else { + ret = rspamd_re_cache_process(task, re->re, type, + (gpointer) header_str, header_len, strong); + } + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + lua_pushinteger(L, ret); + + return 1; +} + +static gint +lua_task_get_metric_result(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_scan_result *metric_res; + struct rspamd_action *action; + + if (task) { + metric_res = task->result; + + if (lua_isstring(L, 2)) { + metric_res = rspamd_find_metric_result(task, lua_tostring(L, 2)); + + if (metric_res == NULL) { + lua_pushnil(L); + + return 1; + } + } + + /* Fields added: + * - `score`: current score + * - `action`: current action as a string + * - `nnegative`: number of negative rules matched + * - `npositive`: number of positive rules matched + * - `positive_score`: total score for positive rules + * - `negative_score`: total score for negative rules + * - `passthrough`: set to true if message has a passthrough result + */ + lua_createtable(L, 0, 7); + + lua_pushstring(L, "score"); + lua_pushnumber(L, metric_res->score); + lua_settable(L, -3); + + action = rspamd_check_action_metric(task, NULL, metric_res); + + if (action) { + lua_pushstring(L, "action"); + lua_pushstring(L, action->name); + lua_settable(L, -3); + } + + lua_pushstring(L, "nnegative"); + lua_pushnumber(L, metric_res->nnegative); + lua_settable(L, -3); + + lua_pushstring(L, "npositive"); + lua_pushnumber(L, metric_res->npositive); + lua_settable(L, -3); + + lua_pushstring(L, "positive_score"); + lua_pushnumber(L, metric_res->positive_score); + lua_settable(L, -3); + + lua_pushstring(L, "negative_score"); + lua_pushnumber(L, metric_res->negative_score); + lua_settable(L, -3); + + lua_pushstring(L, "passthrough"); + lua_pushboolean(L, !!(metric_res->passthrough_result != NULL)); + lua_settable(L, -3); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_metric_score(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + gdouble rs; + struct rspamd_scan_result *metric_res; + + if (task) { + metric_res = task->result; + + if (lua_isstring(L, 2)) { + metric_res = rspamd_find_metric_result(task, lua_tostring(L, 2)); + } + + if (metric_res != NULL) { + lua_createtable(L, 2, 0); + lua_pushnumber(L, isnan(metric_res->score) ? 0.0 : metric_res->score); + rs = rspamd_task_get_required_score(task, metric_res); + lua_rawseti(L, -2, 1); + lua_pushnumber(L, rs); + lua_rawseti(L, -2, 2); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_metric_action(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_action *action; + + if (task) { + struct rspamd_scan_result *mres = task->result; + + if (lua_isstring(L, 2)) { + mres = rspamd_find_metric_result(task, lua_tostring(L, 2)); + } + + if (mres == NULL) { + lua_pushnil(L); + + return 1; + } + + action = rspamd_check_action_metric(task, NULL, mres); + lua_pushstring(L, action->name); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_metric_score(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_scan_result *metric_res; + gdouble nscore; + + if (lua_isnumber(L, 2)) { + nscore = luaL_checknumber(L, 2); + } + else { + nscore = luaL_checknumber(L, 3); + } + + if (task) { + metric_res = task->result; + + if (lua_isstring(L, 4)) { + metric_res = rspamd_find_metric_result(task, lua_tostring(L, 4)); + } + + if (metric_res != NULL) { + msg_debug_task("set metric score from %.2f to %.2f", + metric_res->score, nscore); + metric_res->score = nscore; + lua_pushboolean(L, true); + } + else { + lua_pushboolean(L, false); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_disable_action(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *action_name; + struct rspamd_action_config *action_res; + + action_name = luaL_checkstring(L, 2); + + if (task && action_name) { + + for (guint i = 0; i < task->result->nactions; i++) { + action_res = &task->result->actions_config[i]; + + if (strcmp(action_name, action_res->action->name) == 0) { + if (isnan(action_res->cur_limit)) { + lua_pushboolean(L, false); + } + else { + action_res->cur_limit = NAN; + lua_pushboolean(L, true); + } + + break; + } + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_newlines_type(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + if (task->message) { + switch (MESSAGE_FIELD(task, nlines_type)) { + case RSPAMD_TASK_NEWLINES_CR: + lua_pushstring(L, "cr"); + break; + case RSPAMD_TASK_NEWLINES_LF: + lua_pushstring(L, "lf"); + break; + case RSPAMD_TASK_NEWLINES_CRLF: + default: + lua_pushstring(L, "crlf"); + break; + } + } + else { + lua_pushstring(L, "crlf"); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static void +lua_push_stat_token(lua_State *L, rspamd_token_t *tok) +{ + gchar numbuf[64]; + + /* Table values + * - `data`: 64 bit number encoded as a string + * - `t1`: the first token (if any) + * - `t2`: the second token (if any) + * - `win`: window index + * - `flag`: table of strings: + * - `text`: text token + * - `meta`: meta token + * - `lua`: lua meta token + * - `exception`: exception + * - `subject`: subject token + * - `unigram`: unigram token + */ + lua_createtable(L, 0, 5); + + rspamd_snprintf(numbuf, sizeof(numbuf), "%uL", tok->data); + lua_pushstring(L, "data"); + lua_pushstring(L, numbuf); + lua_settable(L, -3); + + if (tok->t1) { + lua_pushstring(L, "t1"); + lua_pushlstring(L, tok->t1->stemmed.begin, tok->t1->stemmed.len); + lua_settable(L, -3); + } + + if (tok->t2) { + lua_pushstring(L, "t2"); + lua_pushlstring(L, tok->t2->stemmed.begin, tok->t2->stemmed.len); + lua_settable(L, -3); + } + + lua_pushstring(L, "win"); + lua_pushinteger(L, tok->window_idx); + lua_settable(L, -3); + + lua_pushstring(L, "flags"); + lua_createtable(L, 0, 5); + + /* Flags */ + { + if (tok->flags & RSPAMD_STAT_TOKEN_FLAG_TEXT) { + lua_pushstring(L, "text"); + lua_pushboolean(L, true); + lua_settable(L, -3); + } + if (tok->flags & RSPAMD_STAT_TOKEN_FLAG_META) { + lua_pushstring(L, "meta"); + lua_pushboolean(L, true); + lua_settable(L, -3); + } + if (tok->flags & RSPAMD_STAT_TOKEN_FLAG_LUA_META) { + lua_pushstring(L, "lua"); + lua_pushboolean(L, true); + lua_settable(L, -3); + } + if (tok->flags & RSPAMD_STAT_TOKEN_FLAG_EXCEPTION) { + lua_pushstring(L, "exception"); + lua_pushboolean(L, true); + lua_settable(L, -3); + } + if (tok->flags & RSPAMD_STAT_TOKEN_FLAG_HEADER) { + lua_pushstring(L, "header"); + lua_pushboolean(L, true); + lua_settable(L, -3); + } + } + lua_settable(L, -3); +} + +static gint +lua_task_get_stat_tokens(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + guint i; + rspamd_token_t *tok; + + if (task) { + if (!task->tokens) { + rspamd_stat_process_tokenize(NULL, task); + } + + if (!task->tokens) { + lua_pushnil(L); + } + else { + lua_createtable(L, task->tokens->len, 0); + + PTR_ARRAY_FOREACH(task->tokens, i, tok) + { + lua_push_stat_token(L, tok); + lua_rawseti(L, -2, i + 1); + } + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_set_metric_subject(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *subject; + + subject = luaL_checkstring(L, 2); + + if (task && subject) { + rspamd_mempool_set_variable(task->task_pool, "metric_subject", + rspamd_mempool_strdup(task->task_pool, subject), NULL); + lua_pushboolean(L, true); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_protocol_reply(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + guint flags = 0; + ucl_object_t *obj; + + if (!task) { + return luaL_error(L, "invalid arguments"); + } + + if (!(task->processed_stages & (RSPAMD_TASK_STAGE_POST_FILTERS >> 1))) { + return luaL_error(L, "must not be called before post-filters"); + } + + if (lua_istable(L, 2)) { + for (lua_pushnil(L); lua_next(L, 2); lua_pop(L, 1)) { + if (lua_isstring(L, -1)) { + const gchar *str = lua_tostring(L, -1); + + if (strcmp(str, "default") == 0) { + flags |= RSPAMD_PROTOCOL_DEFAULT; + } + else if (strcmp(str, "basic") == 0) { + flags |= RSPAMD_PROTOCOL_BASIC; + } + else if (strcmp(str, "metrics") == 0) { + flags |= RSPAMD_PROTOCOL_METRICS; + } + else if (strcmp(str, "messages") == 0) { + flags |= RSPAMD_PROTOCOL_MESSAGES; + } + else if (strcmp(str, "rmilter") == 0) { + flags |= RSPAMD_PROTOCOL_RMILTER; + } + else if (strcmp(str, "dkim") == 0) { + flags |= RSPAMD_PROTOCOL_DKIM; + } + else if (strcmp(str, "extra") == 0) { + flags |= RSPAMD_PROTOCOL_EXTRA; + } + else { + msg_err_task("invalid protocol flag: %s", str); + } + } + } + } + else { + flags = RSPAMD_PROTOCOL_DEFAULT; + } + + obj = rspamd_protocol_write_ucl(task, flags); + + if (obj) { + ucl_object_push_lua(L, obj, true); + } + else { + lua_pushnil(L); + } + + return 1; +} + +static gint +lua_task_headers_foreach(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + enum rspamd_lua_task_header_type how = RSPAMD_TASK_HEADER_PUSH_SIMPLE; + struct rspamd_lua_regexp *re = NULL; + struct rspamd_mime_header *hdr, *cur; + gint old_top; + + if (task && lua_isfunction(L, 2)) { + if (task->message) { + if (lua_istable(L, 3)) { + lua_pushstring(L, "full"); + lua_gettable(L, 3); + + if (lua_isboolean(L, -1) && lua_toboolean(L, -1)) { + how = RSPAMD_TASK_HEADER_PUSH_FULL; + } + + lua_pop(L, 1); + + lua_pushstring(L, "raw"); + lua_gettable(L, 3); + + if (lua_isboolean(L, -1) && lua_toboolean(L, -1)) { + how = RSPAMD_TASK_HEADER_PUSH_RAW; + } + + lua_pop(L, 1); + + lua_pushstring(L, "regexp"); + lua_gettable(L, 3); + + if (lua_isuserdata(L, -1)) { + RSPAMD_LUA_CHECK_UDATA_PTR_OR_RETURN(L, -1, "rspamd{regexp}", + struct rspamd_lua_regexp, re); + } + + lua_pop(L, 1); + } + + if (MESSAGE_FIELD(task, headers_order)) { + hdr = MESSAGE_FIELD(task, headers_order); + + LL_FOREACH2(hdr, cur, ord_next) + { + if (re && re->re) { + if (!rspamd_regexp_match(re->re, cur->name, + strlen(cur->name), FALSE)) { + continue; + } + } + + old_top = lua_gettop(L); + lua_pushvalue(L, 2); + lua_pushstring(L, cur->name); + rspamd_lua_push_header(L, cur, how); + + if (lua_pcall(L, 2, LUA_MULTRET, 0) != 0) { + msg_err("call to header_foreach failed: %s", + lua_tostring(L, -1)); + lua_settop(L, old_top); + break; + } + else { + if (lua_gettop(L) > old_top) { + if (lua_isboolean(L, old_top + 1)) { + if (lua_toboolean(L, old_top + 1)) { + lua_settop(L, old_top); + break; + } + } + } + } + + lua_settop(L, old_top); + } + } + } /* if (task->message) */ + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_modify_header(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *hname = luaL_checkstring(L, 2); + + if (hname && task && lua_type(L, 3) == LUA_TTABLE) { + if (task->message) { + ucl_object_t *mods = ucl_object_lua_import(L, 3); + + rspamd_message_set_modified_header(task, + MESSAGE_FIELD(task, raw_headers), + hname, + mods, + &(MESSAGE_FIELD(task, headers_order))); + ucl_object_unref(mods); + + lua_pushboolean(L, true); + } + else { + lua_pushboolean(L, false); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_get_meta_words(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + enum rspamd_lua_words_type how = RSPAMD_LUA_WORDS_STEM; + + if (task == NULL) { + return luaL_error(L, "invalid arguments"); + } + + if (task->meta_words == NULL) { + lua_createtable(L, 0, 0); + } + else { + if (lua_type(L, 2) == LUA_TSTRING) { + const gchar *how_str = lua_tostring(L, 2); + + if (strcmp(how_str, "stem") == 0) { + how = RSPAMD_LUA_WORDS_STEM; + } + else if (strcmp(how_str, "norm") == 0) { + how = RSPAMD_LUA_WORDS_NORM; + } + else if (strcmp(how_str, "raw") == 0) { + how = RSPAMD_LUA_WORDS_RAW; + } + else if (strcmp(how_str, "full") == 0) { + how = RSPAMD_LUA_WORDS_FULL; + } + else { + return luaL_error(L, "unknown words type: %s", how_str); + } + } + + return rspamd_lua_push_words(L, task->meta_words, how); + } + + return 1; +} + +static guint +lua_lookup_words_array(lua_State *L, + gint cbpos, + struct rspamd_task *task, + struct rspamd_lua_map *map, + GArray *words) +{ + rspamd_stat_token_t *tok; + guint i, nmatched = 0; + gint err_idx; + gboolean matched; + const gchar *key; + gsize keylen; + + for (i = 0; i < words->len; i++) { + tok = &g_array_index(words, rspamd_stat_token_t, i); + + matched = FALSE; + + if (tok->normalized.len == 0) { + continue; + } + + key = tok->normalized.begin; + keylen = tok->normalized.len; + + switch (map->type) { + case RSPAMD_LUA_MAP_SET: + case RSPAMD_LUA_MAP_HASH: + /* We know that tok->normalized is zero terminated in fact */ + if (rspamd_match_hash_map(map->data.hash, key, keylen)) { + matched = TRUE; + } + break; + case RSPAMD_LUA_MAP_REGEXP: + case RSPAMD_LUA_MAP_REGEXP_MULTIPLE: + if (rspamd_match_regexp_map_single(map->data.re_map, key, + keylen)) { + matched = TRUE; + } + break; + default: + g_assert_not_reached(); + break; + } + + if (matched) { + nmatched++; + + lua_pushcfunction(L, &rspamd_lua_traceback); + err_idx = lua_gettop(L); + lua_pushvalue(L, cbpos); /* Function */ + rspamd_lua_push_full_word(L, tok); + + if (lua_pcall(L, 1, 0, err_idx) != 0) { + msg_err_task("cannot call callback function for lookup words: %s", + lua_tostring(L, -1)); + } + + lua_settop(L, err_idx - 1); + } + } + + return nmatched; +} + +static gint +lua_task_lookup_words(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + struct rspamd_lua_map *map = lua_check_map(L, 2); + struct rspamd_mime_text_part *tp; + + guint i, matches = 0; + + if (task == NULL || map == NULL || task->message == NULL || lua_type(L, 3) != LUA_TFUNCTION) { + return luaL_error(L, "invalid arguments"); + } + + if (map->type != RSPAMD_LUA_MAP_SET && + map->type != RSPAMD_LUA_MAP_REGEXP && + map->type != RSPAMD_LUA_MAP_HASH && + map->type != RSPAMD_LUA_MAP_REGEXP_MULTIPLE) { + return luaL_error(L, "invalid map type"); + } + + PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, text_parts), i, tp) + { + if (tp->utf_words) { + matches += lua_lookup_words_array(L, 3, task, map, tp->utf_words); + } + } + + if (task->meta_words) { + matches += lua_lookup_words_array(L, 3, task, map, task->meta_words); + } + + lua_pushinteger(L, matches); + + return 1; +} + +static gint +lua_task_topointer(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + /* XXX: this might cause issues on arm64 and LuaJIT */ + lua_pushlightuserdata(L, task); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_task_add_named_result(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + const gchar *name = luaL_checkstring(L, 2); + gint cbref; + + if (task && name && lua_isfunction(L, 3)) { + lua_pushvalue(L, 3); + cbref = luaL_ref(L, LUA_REGISTRYINDEX); + rspamd_create_metric_result(task, name, cbref); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 0; +} + +static gint +lua_task_get_all_named_results(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_task *task = lua_check_task(L, 1); + + if (task) { + gint n = 0; + struct rspamd_scan_result *res; + + DL_COUNT(task->result, res, n); + lua_createtable(L, n, 0); + n = 1; + + DL_FOREACH(task->result, res) + { + if (res->name != NULL) { + lua_pushstring(L, res->name); + } + else { + lua_pushstring(L, DEFAULT_METRIC); + } + + lua_rawseti(L, -2, n++); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + + +/* Image functions */ +static gint +lua_image_get_width(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_image *img = lua_check_image(L); + + if (img != NULL) { + lua_pushinteger(L, img->width); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_image_get_height(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_image *img = lua_check_image(L); + + if (img != NULL) { + lua_pushinteger(L, img->height); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_image_get_type(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_image *img = lua_check_image(L); + + if (img != NULL) { + lua_pushstring(L, rspamd_image_type_str(img->type)); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_image_get_size(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_image *img = lua_check_image(L); + + if (img != NULL) { + lua_pushinteger(L, img->data->len); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_image_get_filename(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_image *img = lua_check_image(L); + + if (img != NULL) { + if (img->filename != NULL) { + lua_pushlstring(L, img->filename->begin, img->filename->len); + } + else { + lua_pushnil(L); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +/* Archive methods */ +static gint +lua_archive_get_type(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_archive *arch = lua_check_archive(L); + + if (arch != NULL) { + lua_pushstring(L, rspamd_archive_type_str(arch->type)); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_archive_get_files(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_archive *arch = lua_check_archive(L); + guint i, max_files = 0; + struct rspamd_archive_file *f; + + if (arch != NULL) { + if (lua_isnumber(L, 2)) { + max_files = lua_tointeger(L, 2); + max_files = MIN(arch->files->len, max_files); + } + else { + max_files = arch->files->len; + } + + lua_createtable(L, max_files, 0); + + for (i = 0; i < max_files; i++) { + f = g_ptr_array_index(arch->files, i); + + lua_pushlstring(L, f->fname->str, f->fname->len); + lua_rawseti(L, -2, i + 1); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_archive_get_files_full(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_archive *arch = lua_check_archive(L); + guint i, max_files = 0; + struct rspamd_archive_file *f; + + if (arch != NULL) { + if (lua_isnumber(L, 2)) { + max_files = lua_tointeger(L, 2); + max_files = MIN(arch->files->len, max_files); + } + else { + max_files = arch->files->len; + } + + lua_createtable(L, max_files, 0); + + for (i = 0; i < max_files; i++) { + f = g_ptr_array_index(arch->files, i); + + lua_createtable(L, 0, 4); + + lua_pushstring(L, "name"); + lua_pushlstring(L, f->fname->str, f->fname->len); + lua_settable(L, -3); + + lua_pushstring(L, "compressed_size"); + lua_pushinteger(L, f->compressed_size); + lua_settable(L, -3); + + lua_pushstring(L, "uncompressed_size"); + lua_pushinteger(L, f->uncompressed_size); + lua_settable(L, -3); + + lua_pushstring(L, "encrypted"); + lua_pushboolean(L, (f->flags & RSPAMD_ARCHIVE_FILE_ENCRYPTED) ? true : false); + lua_settable(L, -3); + + lua_rawseti(L, -2, i + 1); + } + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_archive_is_encrypted(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_archive *arch = lua_check_archive(L); + + if (arch != NULL) { + lua_pushboolean(L, (arch->flags & RSPAMD_ARCHIVE_ENCRYPTED) ? true : false); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_archive_is_obfuscated(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_archive *arch = lua_check_archive(L); + + if (arch != NULL) { + lua_pushboolean(L, + (arch->flags & RSPAMD_ARCHIVE_HAS_OBFUSCATED_FILES) ? true : false); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_archive_is_unreadable(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_archive *arch = lua_check_archive(L); + + if (arch != NULL) { + lua_pushboolean(L, (arch->flags & RSPAMD_ARCHIVE_CANNOT_READ) ? true : false); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_archive_get_size(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_archive *arch = lua_check_archive(L); + + if (arch != NULL) { + lua_pushinteger(L, arch->size); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +static gint +lua_archive_get_filename(lua_State *L) +{ + LUA_TRACE_POINT; + struct rspamd_archive *arch = lua_check_archive(L); + + if (arch != NULL) { + lua_pushlstring(L, arch->archive_name->begin, arch->archive_name->len); + } + else { + return luaL_error(L, "invalid arguments"); + } + + return 1; +} + +/* Init part */ + +static gint +lua_load_task(lua_State *L) +{ + lua_newtable(L); + luaL_register(L, NULL, tasklib_f); + + return 1; +} + +static void +luaopen_archive(lua_State *L) +{ + rspamd_lua_new_class(L, "rspamd{archive}", archivelib_m); + lua_pop(L, 1); +} + +void luaopen_task(lua_State *L) +{ + rspamd_lua_new_class(L, "rspamd{task}", tasklib_m); + lua_pop(L, 1); + + rspamd_lua_add_preload(L, "rspamd_task", lua_load_task); + + luaopen_archive(L); +} + +void luaopen_image(lua_State *L) +{ + rspamd_lua_new_class(L, "rspamd{image}", imagelib_m); + lua_pop(L, 1); +} + +void rspamd_lua_task_push(lua_State *L, struct rspamd_task *task) +{ + struct rspamd_task **ptask; + + ptask = lua_newuserdata(L, sizeof(gpointer)); + rspamd_lua_setclass(L, "rspamd{task}", -1); + *ptask = task; +} |