/*- * Copyright 2016 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 "libmime/message.h" #include "libmime/lang_detection.h" #include "libstat/stat_api.h" #include "libcryptobox/cryptobox.h" #include "libutil/shingles.h" #include "contrib/uthash/utlist.h" /* Textpart methods */ /*** * @module rspamd_textpart * This module provides different methods to manipulate text parts data. Text parts * could be obtained from the `rspamd_task` by using of method `task:get_text_parts()` @example rspamd_config.R_EMPTY_IMAGE = function (task) parts = task:get_text_parts() if parts then for _,part in ipairs(parts) do if part:is_empty() then texts = task:get_texts() if texts then return true end return false end end end return false end */ /*** * @method text_part:is_utf() * Return TRUE if part is a valid utf text * @return {boolean} true if part is valid `UTF8` part */ LUA_FUNCTION_DEF(textpart, is_utf); /*** * @method text_part:has_8bit_raw() * Return TRUE if a part has raw 8bit characters * @return {boolean} true if a part has raw 8bit characters */ LUA_FUNCTION_DEF(textpart, has_8bit_raw); /*** * @method text_part:has_8bit() * Return TRUE if a part has raw 8bit characters * @return {boolean} true if a part has encoded 8bit characters */ LUA_FUNCTION_DEF(textpart, has_8bit); /*** * @method text_part:get_content([type]) * Get the text of the part (html tags stripped). Optional `type` defines type of content to get: * - `content` (default): utf8 content with HTML tags stripped and newlines preserved * - `content_oneline`: utf8 content with HTML tags and newlines stripped * - `raw`: raw content, not mime decoded nor utf8 converted * - `raw_parsed`: raw content, mime decoded, not utf8 converted * - `raw_utf`: raw content, mime decoded, utf8 converted (but with HTML tags and newlines) * @return {text} `UTF8` encoded content of the part (zero-copy if not converted to a lua string) */ LUA_FUNCTION_DEF(textpart, get_content); /*** * @method text_part:get_raw_content() * Get the original text of the part * @return {text} `UTF8` encoded content of the part (zero-copy if not converted to a lua string) */ LUA_FUNCTION_DEF(textpart, get_raw_content); /*** * @method text_part:get_content_oneline() *Get the text of the part (html tags and newlines stripped) * @return {text} `UTF8` encoded content of the part (zero-copy if not converted to a lua string) */ LUA_FUNCTION_DEF(textpart, get_content_oneline); /*** * @method text_part:get_length() * Get length of the text of the part * @return {integer} length of part in **bytes** */ LUA_FUNCTION_DEF(textpart, get_length); /*** * @method mime_part:get_raw_length() * Get length of the **raw** content of the part (e.g. HTML with tags unstripped) * @return {integer} length of part in **bytes** */ LUA_FUNCTION_DEF(textpart, get_raw_length); /*** * @method mime_part:get_urls_length() * Get length of the urls within the part * @return {integer} length of urls in **bytes** */ LUA_FUNCTION_DEF(textpart, get_urls_length); /*** * @method mime_part:get_lines_count() * Get lines number in the part * @return {integer} number of lines in the part */ LUA_FUNCTION_DEF(textpart, get_lines_count); /*** * @method mime_part:get_stats() * Returns a table with the following data: * - `lines`: number of lines * - `spaces`: number of spaces * - `double_spaces`: double spaces * - `empty_lines`: number of empty lines * - `non_ascii_characters`: number of non ascii characters * - `ascii_characters`: number of ascii characters * @return {table} table of stats */ LUA_FUNCTION_DEF(textpart, get_stats); /*** * @method mime_part:get_words_count() * Get words number in the part * @return {integer} number of words in the part */ LUA_FUNCTION_DEF(textpart, get_words_count); /*** * @method mime_part:get_words([how]) * Get words in the part. Optional `how` argument defines type of words returned: * - `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) * @return {table/strings} words in the part */ LUA_FUNCTION_DEF(textpart, get_words); /*** * @method mime_part:filter_words(regexp, [how][, max]]) * Filter words using some regexp: * - `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) * @param {rspamd_regexp} regexp regexp to match * @param {string} how what words to extract * @param {number} max maximum number of hits returned (all hits if <= 0 or nil) * @return {table/strings} words matching regexp */ LUA_FUNCTION_DEF(textpart, filter_words); /*** * @method text_part:is_empty() * Returns `true` if the specified part is empty * @return {bool} whether a part is empty */ LUA_FUNCTION_DEF(textpart, is_empty); /*** * @method text_part:is_html() * Returns `true` if the specified part has HTML content * @return {bool} whether a part is HTML part */ LUA_FUNCTION_DEF(textpart, is_html); /*** * @method text_part:get_html() * Returns html content of the specified part * @return {html} html content */ LUA_FUNCTION_DEF(textpart, get_html); /*** * @method text_part:get_language() * Returns the code of the most used unicode script in the text part. Does not work with raw parts * @return {string} short abbreviation (such as `ru`) for the script's language */ LUA_FUNCTION_DEF(textpart, get_language); /*** * @method text_part:get_charset() * Returns part real charset * @return {string} charset of the part */ LUA_FUNCTION_DEF(textpart, get_charset); /*** * @method text_part:get_languages() * Returns array of tables of all languages detected for a part: * - 'code': language code (short string) * - 'prob': logarithm of probability * @return {array|tables} all languages detected for the part */ LUA_FUNCTION_DEF(textpart, get_languages); /*** * @method text_part:get_fuzzy_hashes(mempool) * @param {rspamd_mempool} mempool - memory pool (usually task pool) * Returns direct hash of textpart as a string and array [1..32] of shingles each represented as a following table: * - [1] - 64 bit fuzzy hash represented as a string * - [2..4] - strings used to generate this hash * @return {string,array|tables} fuzzy hashes calculated */ LUA_FUNCTION_DEF(textpart, get_fuzzy_hashes); /*** * @method text_part:get_mimepart() * Returns the mime part object corresponding to this text part * @return {mimepart} mimepart object */ LUA_FUNCTION_DEF(textpart, get_mimepart); static const struct luaL_reg textpartlib_m[] = { LUA_INTERFACE_DEF(textpart, is_utf), LUA_INTERFACE_DEF(textpart, has_8bit_raw), LUA_INTERFACE_DEF(textpart, has_8bit), LUA_INTERFACE_DEF(textpart, get_content), LUA_INTERFACE_DEF(textpart, get_raw_content), LUA_INTERFACE_DEF(textpart, get_content_oneline), LUA_INTERFACE_DEF(textpart, get_length), LUA_INTERFACE_DEF(textpart, get_raw_length), LUA_INTERFACE_DEF(textpart, get_urls_length), LUA_INTERFACE_DEF(textpart, get_lines_count), LUA_INTERFACE_DEF(textpart, get_words_count), LUA_INTERFACE_DEF(textpart, get_words), LUA_INTERFACE_DEF(textpart, filter_words), LUA_INTERFACE_DEF(textpart, is_empty), LUA_INTERFACE_DEF(textpart, is_html), LUA_INTERFACE_DEF(textpart, get_html), LUA_INTERFACE_DEF(textpart, get_language), LUA_INTERFACE_DEF(textpart, get_charset), LUA_INTERFACE_DEF(textpart, get_languages), LUA_INTERFACE_DEF(textpart, get_mimepart), LUA_INTERFACE_DEF(textpart, get_stats), LUA_INTERFACE_DEF(textpart, get_fuzzy_hashes), {"__tostring", rspamd_lua_class_tostring}, {NULL, NULL}}; /* Mimepart methods */ /*** * @module rspamd_mimepart * This module provides access to mime parts found in a message @example rspamd_config.MISSING_CONTENT_TYPE = function(task) local parts = task:get_parts() if parts and #parts > 1 then -- We have more than one part for _,p in ipairs(parts) do local ct = p:get_header('Content-Type') -- And some parts have no Content-Type header if not ct then return true end end end return false end */ /*** * @method mime_part: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(mimepart, get_header); /*** * @method mime_part: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(mimepart, get_header_raw); /*** * @method mime_part:get_header_full(name[, case_sensitive]) * 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 * @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(mimepart, get_header_full); /*** * @method mimepart: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(mimepart, get_header_count); /*** * @method mimepart:get_raw_headers() * Get all undecoded headers of a mime part as a string * @return {rspamd_text} all raw headers for a message as opaque text */ LUA_FUNCTION_DEF(mimepart, get_raw_headers); /*** * @method mimepart:get_headers() * Get all undecoded headers of a mime part as a string * @return {rspamd_text} all raw headers for a message as opaque text */ LUA_FUNCTION_DEF(mimepart, get_headers); /*** * @method mime_part:get_content() * Get the parsed content of part * @return {text} opaque text object (zero-copy if not casted to lua string) */ LUA_FUNCTION_DEF(mimepart, get_content); /*** * @method mime_part:get_raw_content() * Get the raw content of part * @return {text} opaque text object (zero-copy if not casted to lua string) */ LUA_FUNCTION_DEF(mimepart, get_raw_content); /*** * @method mime_part:get_length() * Get length of the content of the part * @return {integer} length of part in **bytes** */ LUA_FUNCTION_DEF(mimepart, get_length); /*** * @method mime_part:get_type() * Extract content-type string of the mime part * @return {string,string} content type in form 'type','subtype' */ LUA_FUNCTION_DEF(mimepart, get_type); /*** * @method mime_part:get_type_full() * Extract content-type string of the mime part with all attributes * @return {string,string,table} content type in form 'type','subtype', {attrs} */ LUA_FUNCTION_DEF(mimepart, get_type_full); /*** * @method mime_part:get_detected_type() * Extract content-type string of the mime part. Use lua_magic detection * @return {string,string} content type in form 'type','subtype' */ LUA_FUNCTION_DEF(mimepart, get_detected_type); /*** * @method mime_part:get_detected_type_full() * Extract content-type string of the mime part with all attributes. Use lua_magic detection * @return {string,string,table} content type in form 'type','subtype', {attrs} */ LUA_FUNCTION_DEF(mimepart, get_detected_type_full); /*** * @method mime_part:get_detected_ext() * Returns a msdos extension name according to lua_magic detection * @return {string} detected extension (see lua_magic.types) */ LUA_FUNCTION_DEF(mimepart, get_detected_ext); /*** * @method mime_part:get_cte() * Extract content-transfer-encoding for a part * @return {string} content transfer encoding (e.g. `base64` or `7bit`) */ LUA_FUNCTION_DEF(mimepart, get_cte); /*** * @method mime_part:get_filename() * Extract filename associated with mime part if it is an attachment * @return {string} filename or `nil` if no file is associated with this part */ LUA_FUNCTION_DEF(mimepart, get_filename); /*** * @method mime_part:is_image() * Returns true if mime part is an image * @return {bool} true if a part is an image */ LUA_FUNCTION_DEF(mimepart, is_image); /*** * @method mime_part:get_image() * Returns rspamd_image structure associated with this part. This structure 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 {rspamd_image} image structure or nil if a part is not an image */ LUA_FUNCTION_DEF(mimepart, get_image); /*** * @method mime_part:is_archive() * Returns true if mime part is an archive * @return {bool} true if a part is an archive */ LUA_FUNCTION_DEF(mimepart, is_archive); /*** * @method mime_part:is_attachment() * Returns true if mime part looks like an attachment * @return {bool} true if a part looks like an attachment */ LUA_FUNCTION_DEF(mimepart, is_attachment); /*** * @method mime_part:get_archive() * Returns rspamd_archive structure associated with this part. This structure has * the following methods: * * * `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 {rspamd_archive} archive structure or nil if a part is not an archive */ LUA_FUNCTION_DEF(mimepart, get_archive); /*** * @method mime_part:is_multipart() * Returns true if mime part is a multipart part * @return {bool} true if a part is is a multipart part */ LUA_FUNCTION_DEF(mimepart, is_multipart); /*** * @method mime_part:is_message() * Returns true if mime part is a message part (message/rfc822) * @return {bool} true if a part is is a message part */ LUA_FUNCTION_DEF(mimepart, is_message); /*** * @method mime_part:get_boundary() * Returns boundary for a part (extracted from parent multipart for normal parts and * from the part itself for multipart) * @return {string} boundary value or nil */ LUA_FUNCTION_DEF(mimepart, get_boundary); /*** * @method mime_part:get_enclosing_boundary() * Returns an enclosing boundary for a part even for multiparts. For normal parts * this method is identical to `get_boundary` * @return {string} boundary value or nil */ LUA_FUNCTION_DEF(mimepart, get_enclosing_boundary); /*** * @method mime_part:get_children() * Returns rspamd_mimepart table of part's childer. Returns nil if mime part is not multipart * or a message part. * @return {rspamd_mimepart} table of children */ LUA_FUNCTION_DEF(mimepart, get_children); /*** * @method mime_part:is_text() * Returns true if mime part is a text part * @return {bool} true if a part is a text part */ LUA_FUNCTION_DEF(mimepart, is_text); /*** * @method mime_part:get_text() * Returns rspamd_textpart structure associated with this part. * @return {rspamd_textpart} textpart structure or nil if a part is not an text */ LUA_FUNCTION_DEF(mimepart, get_text); /*** * @method mime_part:get_digest() * Returns the unique digest for this mime part * @return {string} 128 characters hex string with digest of the part */ LUA_FUNCTION_DEF(mimepart, get_digest); /*** * @method mime_part:get_id() * Returns the order of the part in parts list * @return {number} index of the part (starting from 1 as it is Lua API) */ LUA_FUNCTION_DEF(mimepart, get_id); /*** * @method mime_part:is_broken() * Returns true if mime part has incorrectly specified content type * @return {bool} true if a part has bad content type */ LUA_FUNCTION_DEF(mimepart, is_broken); /*** * @method mime_part: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(mimepart, headers_foreach); /*** * @method mime_part:get_parent() * Returns parent part for this part * @return {rspamd_mimepart} parent part or nil */ LUA_FUNCTION_DEF(mimepart, get_parent); /*** * @method mime_part:get_specific() * Returns specific lua content for this part * @return {any} specific lua content */ LUA_FUNCTION_DEF(mimepart, get_specific); /*** * @method mime_part:set_specific() * Sets a specific content for this part * @return {any} previous specific lua content (or nil) */ LUA_FUNCTION_DEF(mimepart, set_specific); /*** * @method mime_part:is_specific() * Returns true if part has specific lua content * @return {boolean} flag */ LUA_FUNCTION_DEF(mimepart, is_specific); /*** * @method mime_part:get_urls([need_emails|list_protos][, need_images]) * Get all URLs found in a mime part. 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 () as well * @return {table rspamd_url} list of all urls found */ LUA_FUNCTION_DEF(mimepart, get_urls); static const struct luaL_reg mimepartlib_m[] = { LUA_INTERFACE_DEF(mimepart, get_content), LUA_INTERFACE_DEF(mimepart, get_raw_content), LUA_INTERFACE_DEF(mimepart, get_length), LUA_INTERFACE_DEF(mimepart, get_type), LUA_INTERFACE_DEF(mimepart, get_type_full), LUA_INTERFACE_DEF(mimepart, get_detected_type), LUA_INTERFACE_DEF(mimepart, get_detected_ext), LUA_INTERFACE_DEF(mimepart, get_detected_type_full), LUA_INTERFACE_DEF(mimepart, get_cte), LUA_INTERFACE_DEF(mimepart, get_filename), LUA_INTERFACE_DEF(mimepart, get_boundary), LUA_INTERFACE_DEF(mimepart, get_enclosing_boundary), LUA_INTERFACE_DEF(mimepart, get_header), LUA_INTERFACE_DEF(mimepart, get_header_raw), LUA_INTERFACE_DEF(mimepart, get_header_full), LUA_INTERFACE_DEF(mimepart, get_header_count), LUA_INTERFACE_DEF(mimepart, get_raw_headers), LUA_INTERFACE_DEF(mimepart, get_headers), LUA_INTERFACE_DEF(mimepart, is_image), LUA_INTERFACE_DEF(mimepart, get_image), LUA_INTERFACE_DEF(mimepart, is_archive), LUA_INTERFACE_DEF(mimepart, get_archive), LUA_INTERFACE_DEF(mimepart, is_multipart), LUA_INTERFACE_DEF(mimepart, is_message), LUA_INTERFACE_DEF(mimepart, get_children), LUA_INTERFACE_DEF(mimepart, get_parent), LUA_INTERFACE_DEF(mimepart, get_urls), LUA_INTERFACE_DEF(mimepart, is_text), LUA_INTERFACE_DEF(mimepart, is_broken), LUA_INTERFACE_DEF(mimepart, is_attachment), LUA_INTERFACE_DEF(mimepart, get_text), LUA_INTERFACE_DEF(mimepart, get_digest), LUA_INTERFACE_DEF(mimepart, get_id), LUA_INTERFACE_DEF(mimepart, headers_foreach), LUA_INTERFACE_DEF(mimepart, get_specific), LUA_INTERFACE_DEF(mimepart, set_specific), LUA_INTERFACE_DEF(mimepart, is_specific), {"__tostring", rspamd_lua_class_tostring}, {NULL, NULL}}; static struct rspamd_mime_text_part * lua_check_textpart(lua_State *L) { void *ud = rspamd_lua_check_udata(L, 1, "rspamd{textpart}"); luaL_argcheck(L, ud != NULL, 1, "'textpart' expected"); return ud ? *((struct rspamd_mime_text_part **) ud) : NULL; } static struct rspamd_mime_part * lua_check_mimepart(lua_State *L) { void *ud = rspamd_lua_check_udata(L, 1, "rspamd{mimepart}"); luaL_argcheck(L, ud != NULL, 1, "'mimepart' expected"); return ud ? *((struct rspamd_mime_part **) ud) : NULL; } static gint lua_textpart_is_utf(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part == NULL || IS_TEXT_PART_EMPTY(part)) { lua_pushboolean(L, FALSE); return 1; } lua_pushboolean(L, IS_TEXT_PART_UTF(part)); return 1; } static gint lua_textpart_has_8bit_raw(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part) { if (part->flags & RSPAMD_MIME_TEXT_PART_FLAG_8BIT_RAW) { lua_pushboolean(L, TRUE); } else { lua_pushboolean(L, FALSE); } } else { return luaL_error(L, "invalid arguments"); } return 1; } static gint lua_textpart_has_8bit(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part) { if (part->flags & RSPAMD_MIME_TEXT_PART_FLAG_8BIT_ENCODED) { lua_pushboolean(L, TRUE); } else { lua_pushboolean(L, FALSE); } } else { return luaL_error(L, "invalid arguments"); } return 1; } static gint lua_textpart_get_content(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); struct rspamd_lua_text *t; gsize len; const gchar *start, *type = NULL; if (part == NULL) { lua_pushnil(L); return 1; } if (lua_type(L, 2) == LUA_TSTRING) { type = lua_tostring(L, 2); } if (!type) { if (IS_TEXT_PART_EMPTY(part)) { lua_pushnil(L); return 1; } start = part->utf_content.begin; len = part->utf_content.len; } else if (strcmp(type, "content") == 0) { if (IS_TEXT_PART_EMPTY(part)) { lua_pushnil(L); return 1; } start = part->utf_content.begin; len = part->utf_content.len; } else if (strcmp(type, "content_oneline") == 0) { if (IS_TEXT_PART_EMPTY(part)) { lua_pushnil(L); return 1; } start = part->utf_stripped_content->data; len = part->utf_stripped_content->len; } else if (strcmp(type, "raw_parsed") == 0) { if (part->parsed.len == 0) { lua_pushnil(L); return 1; } start = part->parsed.begin; len = part->parsed.len; } else if (strcmp(type, "raw_utf") == 0) { if (part->utf_raw_content == NULL || part->utf_raw_content->len == 0) { lua_pushnil(L); return 1; } start = part->utf_raw_content->data; len = part->utf_raw_content->len; } else if (strcmp(type, "raw") == 0) { if (part->raw.len == 0) { lua_pushnil(L); return 1; } start = part->raw.begin; len = part->raw.len; } else { return luaL_error(L, "invalid content type: %s", type); } t = lua_newuserdata(L, sizeof(*t)); rspamd_lua_setclass(L, "rspamd{text}", -1); t->start = start; t->len = len; t->flags = 0; return 1; } static gint lua_textpart_get_raw_content(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); struct rspamd_lua_text *t; if (part == NULL || IS_TEXT_PART_EMPTY(part)) { lua_pushnil(L); return 1; } t = lua_newuserdata(L, sizeof(*t)); rspamd_lua_setclass(L, "rspamd{text}", -1); t->start = part->raw.begin; t->len = part->raw.len; t->flags = 0; return 1; } static gint lua_textpart_get_content_oneline(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part == NULL || IS_TEXT_PART_EMPTY(part)) { lua_pushnil(L); return 1; } lua_new_text(L, part->utf_stripped_content->data, part->utf_stripped_content->len, FALSE); return 1; } static gint lua_textpart_get_length(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part == NULL) { lua_pushnil(L); return 1; } if (IS_TEXT_PART_EMPTY(part) || part->utf_content.len == 0) { lua_pushinteger(L, 0); } else { lua_pushinteger(L, part->utf_content.len); } return 1; } static gint lua_textpart_get_raw_length(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part == NULL) { lua_pushnil(L); return 1; } lua_pushinteger(L, part->raw.len); return 1; } static gint lua_textpart_get_urls_length(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); GList *cur; guint total = 0; struct rspamd_process_exception *ex; if (part == NULL) { lua_pushnil(L); return 1; } for (cur = part->exceptions; cur != NULL; cur = g_list_next(cur)) { ex = cur->data; if (ex->type == RSPAMD_EXCEPTION_URL) { total += ex->len; } } lua_pushinteger(L, total); return 1; } static gint lua_textpart_get_lines_count(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part == NULL) { lua_pushnil(L); return 1; } if (IS_TEXT_PART_EMPTY(part)) { lua_pushinteger(L, 0); } else { lua_pushinteger(L, part->nlines); } return 1; } static gint lua_textpart_get_words_count(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part == NULL) { lua_pushnil(L); return 1; } if (IS_TEXT_PART_EMPTY(part) || part->utf_words == NULL) { lua_pushinteger(L, 0); } else { lua_pushinteger(L, part->nwords); } return 1; } static inline enum rspamd_lua_words_type word_extract_type_from_string(const gchar *how_str) { enum rspamd_lua_words_type how = RSPAMD_LUA_WORDS_MAX; 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; } return how; } static gint lua_textpart_get_words(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); enum rspamd_lua_words_type how = RSPAMD_LUA_WORDS_STEM; if (part == NULL) { return luaL_error(L, "invalid arguments"); } if (IS_TEXT_PART_EMPTY(part) || part->utf_words == NULL) { lua_createtable(L, 0, 0); } else { if (lua_type(L, 2) == LUA_TSTRING) { const gchar *how_str = lua_tostring(L, 2); how = word_extract_type_from_string(how_str); if (how == RSPAMD_LUA_WORDS_MAX) { return luaL_error(L, "invalid extraction type: %s", how_str); } } return rspamd_lua_push_words(L, part->utf_words, how); } return 1; } static gint lua_textpart_filter_words(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); struct rspamd_lua_regexp *re = lua_check_regexp(L, 2); gint lim = -1; enum rspamd_lua_words_type how = RSPAMD_LUA_WORDS_STEM; if (part == NULL || re == NULL) { return luaL_error(L, "invalid arguments"); } if (IS_TEXT_PART_EMPTY(part) || part->utf_words == NULL) { lua_createtable(L, 0, 0); } else { if (lua_type(L, 3) == LUA_TSTRING) { const gchar *how_str = lua_tostring(L, 3); how = word_extract_type_from_string(how_str); if (how == RSPAMD_LUA_WORDS_MAX) { return luaL_error(L, "invalid extraction type: %s", how_str); } } if (lua_type(L, 4) == LUA_TNUMBER) { lim = lua_tointeger(L, 4); } guint cnt, i; lua_createtable(L, 8, 0); for (i = 0, cnt = 1; i < part->utf_words->len; i++) { rspamd_stat_token_t *w = &g_array_index(part->utf_words, rspamd_stat_token_t, i); switch (how) { case RSPAMD_LUA_WORDS_STEM: if (w->stemmed.len > 0) { if (rspamd_regexp_match(re->re, w->stemmed.begin, w->stemmed.len, FALSE)) { lua_pushlstring(L, w->stemmed.begin, w->stemmed.len); lua_rawseti(L, -2, cnt++); } } break; case RSPAMD_LUA_WORDS_NORM: if (w->normalized.len > 0) { if (rspamd_regexp_match(re->re, w->normalized.begin, w->normalized.len, FALSE)) { lua_pushlstring(L, w->normalized.begin, w->normalized.len); lua_rawseti(L, -2, cnt++); } } break; case RSPAMD_LUA_WORDS_RAW: if (w->original.len > 0) { if (rspamd_regexp_match(re->re, w->original.begin, w->original.len, TRUE)) { lua_pushlstring(L, w->original.begin, w->original.len); lua_rawseti(L, -2, cnt++); } } break; case RSPAMD_LUA_WORDS_FULL: if (rspamd_regexp_match(re->re, w->normalized.begin, w->normalized.len, FALSE)) { rspamd_lua_push_full_word(L, w); /* Push to the resulting vector */ lua_rawseti(L, -2, cnt++); } break; default: break; } if (lim > 0 && cnt >= lim) { break; } } } return 1; } static gint lua_textpart_is_empty(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part == NULL) { lua_pushnil(L); return 1; } lua_pushboolean(L, IS_TEXT_PART_EMPTY(part)); return 1; } static gint lua_textpart_is_html(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part == NULL) { lua_pushnil(L); return 1; } lua_pushboolean(L, IS_TEXT_PART_HTML(part)); return 1; } static gint lua_textpart_get_html(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); struct html_content **phc; if (part == NULL || part->html == NULL) { lua_pushnil(L); } else { phc = lua_newuserdata(L, sizeof(*phc)); rspamd_lua_setclass(L, "rspamd{html}", -1); *phc = part->html; } return 1; } static gint lua_textpart_get_language(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part != NULL) { if (part->language != NULL && part->language[0] != '\0') { lua_pushstring(L, part->language); return 1; } else { lua_pushnil(L); } } else { return luaL_error(L, "invalid arguments"); } return 1; } static gint lua_textpart_get_charset(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part != NULL) { if (part->real_charset != NULL) { lua_pushstring(L, part->real_charset); return 1; } else { lua_pushnil(L); } } else { return luaL_error(L, "invalid arguments"); } return 1; } static gint lua_textpart_get_languages(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); guint i; struct rspamd_lang_detector_res *cur; if (part != NULL) { if (part->languages != NULL) { lua_createtable(L, part->languages->len, 0); PTR_ARRAY_FOREACH(part->languages, i, cur) { lua_createtable(L, 0, 2); lua_pushstring(L, "code"); lua_pushstring(L, cur->lang); lua_settable(L, -3); lua_pushstring(L, "prob"); lua_pushnumber(L, cur->prob); lua_settable(L, -3); lua_rawseti(L, -2, i + 1); } } else { lua_newtable(L); } } else { luaL_error(L, "invalid arguments"); } return 1; } struct lua_shingle_data { guint64 hash; rspamd_ftok_t t1; rspamd_ftok_t t2; rspamd_ftok_t t3; }; struct lua_shingle_filter_cbdata { struct rspamd_mime_text_part *part; rspamd_mempool_t *pool; }; #define STORE_TOKEN(i, t) \ do { \ if ((i) < part->utf_words->len) { \ word = &g_array_index(part->utf_words, rspamd_stat_token_t, (i)); \ sd->t.begin = word->stemmed.begin; \ sd->t.len = word->stemmed.len; \ } \ } while (0) static guint64 lua_shingles_filter(guint64 *input, gsize count, gint shno, const guchar *key, gpointer ud) { guint64 minimal = G_MAXUINT64; gsize i, min_idx = 0; struct lua_shingle_data *sd; rspamd_stat_token_t *word; struct lua_shingle_filter_cbdata *cbd = (struct lua_shingle_filter_cbdata *) ud; struct rspamd_mime_text_part *part; part = cbd->part; for (i = 0; i < count; i++) { if (minimal > input[i]) { minimal = input[i]; min_idx = i; } } sd = rspamd_mempool_alloc0(cbd->pool, sizeof(*sd)); sd->hash = minimal; STORE_TOKEN(min_idx, t1); STORE_TOKEN(min_idx + 1, t2); STORE_TOKEN(min_idx + 2, t3); return GPOINTER_TO_SIZE(sd); } #undef STORE_TOKEN static gint lua_textpart_get_fuzzy_hashes(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); rspamd_mempool_t *pool = rspamd_lua_check_mempool(L, 2); guchar key[rspamd_cryptobox_HASHBYTES], digest[rspamd_cryptobox_HASHBYTES], hexdigest[rspamd_cryptobox_HASHBYTES * 2 + 1], numbuf[64]; struct rspamd_shingle *sgl; guint i; struct lua_shingle_data *sd; rspamd_cryptobox_hash_state_t st; rspamd_stat_token_t *word; struct lua_shingle_filter_cbdata cbd; if (part == NULL || pool == NULL) { return luaL_error(L, "invalid arguments"); } if (IS_TEXT_PART_EMPTY(part) || part->utf_words == NULL) { lua_pushnil(L); lua_pushnil(L); } else { /* TODO: add keys and algorithms support */ rspamd_cryptobox_hash(key, "rspamd", strlen("rspamd"), NULL, 0); /* TODO: add short text support */ /* Calculate direct hash */ rspamd_cryptobox_hash_init(&st, key, rspamd_cryptobox_HASHKEYBYTES); for (i = 0; i < part->utf_words->len; i++) { word = &g_array_index(part->utf_words, rspamd_stat_token_t, i); rspamd_cryptobox_hash_update(&st, word->stemmed.begin, word->stemmed.len); } rspamd_cryptobox_hash_final(&st, digest); rspamd_encode_hex_buf(digest, sizeof(digest), hexdigest, sizeof(hexdigest)); lua_pushlstring(L, hexdigest, sizeof(hexdigest) - 1); cbd.pool = pool; cbd.part = part; sgl = rspamd_shingles_from_text(part->utf_words, key, pool, lua_shingles_filter, &cbd, RSPAMD_SHINGLES_MUMHASH); if (sgl == NULL) { lua_pushnil(L); } else { lua_createtable(L, G_N_ELEMENTS(sgl->hashes), 0); for (i = 0; i < G_N_ELEMENTS(sgl->hashes); i++) { sd = GSIZE_TO_POINTER(sgl->hashes[i]); lua_createtable(L, 4, 0); rspamd_snprintf(numbuf, sizeof(numbuf), "%uL", sd->hash); lua_pushstring(L, numbuf); lua_rawseti(L, -2, 1); /* Tokens */ lua_pushlstring(L, sd->t1.begin, sd->t1.len); lua_rawseti(L, -2, 2); lua_pushlstring(L, sd->t2.begin, sd->t2.len); lua_rawseti(L, -2, 3); lua_pushlstring(L, sd->t3.begin, sd->t3.len); lua_rawseti(L, -2, 4); lua_rawseti(L, -2, i + 1); /* Store table */ } } } return 2; } static gint lua_textpart_get_mimepart(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); struct rspamd_mime_part **pmime; if (part != NULL) { if (part->mime_part != NULL) { pmime = lua_newuserdata(L, sizeof(struct rspamd_mime_part *)); rspamd_lua_setclass(L, "rspamd{mimepart}", -1); *pmime = part->mime_part; return 1; } } lua_pushnil(L); return 1; } /*** * @method mime_part:get_stats() * Returns a table with the following data: * - * - `lines`: number of lines * - `spaces`: number of spaces * - `double_spaces`: double spaces * - `empty_lines`: number of empty lines * - `non_ascii_characters`: number of non ascii characters * - `ascii_characters`: number of ascii characters * @return {table} table of stats */ static gint lua_textpart_get_stats(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_text_part *part = lua_check_textpart(L); if (part != NULL) { lua_createtable(L, 0, 9); lua_pushstring(L, "lines"); lua_pushinteger(L, part->nlines); lua_settable(L, -3); lua_pushstring(L, "empty_lines"); lua_pushinteger(L, part->empty_lines); lua_settable(L, -3); lua_pushstring(L, "spaces"); lua_pushinteger(L, part->spaces); lua_settable(L, -3); lua_pushstring(L, "non_spaces"); lua_pushinteger(L, part->non_spaces); lua_settable(L, -3); lua_pushstring(L, "double_spaces"); lua_pushinteger(L, part->double_spaces); lua_settable(L, -3); lua_pushstring(L, "ascii_characters"); lua_pushinteger(L, part->ascii_chars); lua_settable(L, -3); lua_pushstring(L, "non_ascii_characters"); lua_pushinteger(L, part->non_ascii_chars); lua_settable(L, -3); lua_pushstring(L, "capital_letters"); lua_pushinteger(L, part->capital_letters); lua_settable(L, -3); lua_pushstring(L, "numeric_characters"); lua_pushinteger(L, part->numeric_characters); lua_settable(L, -3); } else { return luaL_error(L, "invalid arguments"); } return 1; } /* Mimepart implementation */ static gint lua_mimepart_get_content(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); struct rspamd_lua_text *t; if (part == NULL) { lua_pushnil(L); return 1; } t = lua_newuserdata(L, sizeof(*t)); rspamd_lua_setclass(L, "rspamd{text}", -1); t->start = part->parsed_data.begin; t->len = part->parsed_data.len; t->flags = 0; if (lua_is_text_binary(t)) { t->flags |= RSPAMD_TEXT_FLAG_BINARY; } return 1; } static gint lua_mimepart_get_raw_content(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); struct rspamd_lua_text *t; if (part == NULL) { lua_pushnil(L); return 1; } t = lua_newuserdata(L, sizeof(*t)); rspamd_lua_setclass(L, "rspamd{text}", -1); t->start = part->raw_data.begin; t->len = part->raw_data.len; t->flags = 0; return 1; } static gint lua_mimepart_get_length(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { lua_pushnil(L); return 1; } lua_pushinteger(L, part->parsed_data.len); return 1; } static gint lua_mimepart_get_type_common(lua_State *L, struct rspamd_content_type *ct, gboolean full) { GHashTableIter it; gpointer k, v; struct rspamd_content_type_param *param; if (ct == NULL) { lua_pushnil(L); lua_pushnil(L); return 2; } lua_pushlstring(L, ct->type.begin, ct->type.len); lua_pushlstring(L, ct->subtype.begin, ct->subtype.len); if (!full) { return 2; } lua_createtable(L, 0, 2 + (ct->attrs ? g_hash_table_size(ct->attrs) : 0)); if (ct->charset.len > 0) { lua_pushstring(L, "charset"); lua_pushlstring(L, ct->charset.begin, ct->charset.len); lua_settable(L, -3); } if (ct->boundary.len > 0) { lua_pushstring(L, "boundary"); lua_pushlstring(L, ct->boundary.begin, ct->boundary.len); lua_settable(L, -3); } if (ct->attrs) { g_hash_table_iter_init(&it, ct->attrs); while (g_hash_table_iter_next(&it, &k, &v)) { param = v; if (param->name.len > 0 && param->value.len > 0) { /* TODO: think about multiple values here */ lua_pushlstring(L, param->name.begin, param->name.len); lua_pushlstring(L, param->value.begin, param->value.len); lua_settable(L, -3); } } } return 3; } static gint lua_mimepart_get_type(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } return lua_mimepart_get_type_common(L, part->ct, FALSE); } static gint lua_mimepart_get_type_full(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } return lua_mimepart_get_type_common(L, part->ct, TRUE); } static gint lua_mimepart_get_detected_type(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } return lua_mimepart_get_type_common(L, part->detected_ct, FALSE); } static gint lua_mimepart_get_detected_type_full(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } return lua_mimepart_get_type_common(L, part->detected_ct, TRUE); } static gint lua_mimepart_get_detected_ext(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } if (part->detected_ext) { lua_pushstring(L, part->detected_ext); } else { lua_pushnil(L); } return 1; } static gint lua_mimepart_get_cte(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { lua_pushnil(L); return 1; } lua_pushstring(L, rspamd_cte_to_string(part->cte)); return 1; } static gint lua_mimepart_get_filename(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL || part->cd == NULL || part->cd->filename.len == 0) { lua_pushnil(L); return 1; } lua_pushlstring(L, part->cd->filename.begin, part->cd->filename.len); return 1; } static gint lua_mimepart_get_boundary(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L), *parent; if (part == NULL) { return luaL_error(L, "invalid arguments"); } if (IS_PART_MULTIPART(part)) { lua_pushlstring(L, part->specific.mp->boundary.begin, part->specific.mp->boundary.len); } else { parent = part->parent_part; if (!parent || !IS_PART_MULTIPART(parent)) { lua_pushnil(L); } else { lua_pushlstring(L, parent->specific.mp->boundary.begin, parent->specific.mp->boundary.len); } } return 1; } static gint lua_mimepart_get_enclosing_boundary(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L), *parent; if (part == NULL) { return luaL_error(L, "invalid arguments"); } parent = part->parent_part; if (!parent || !IS_PART_MULTIPART(parent)) { lua_pushnil(L); } else { lua_pushlstring(L, parent->specific.mp->boundary.begin, parent->specific.mp->boundary.len); } return 1; } static gint lua_mimepart_get_header_common(lua_State *L, enum rspamd_lua_task_header_type how) { struct rspamd_mime_part *part = lua_check_mimepart(L); const gchar *name; gboolean strong = FALSE; name = luaL_checkstring(L, 2); if (name && part) { if (lua_isboolean(L, 3)) { strong = lua_toboolean(L, 3); } return rspamd_lua_push_header_array(L, name, rspamd_message_get_header_from_hash(part->raw_headers, name, FALSE), how, strong); } lua_pushnil(L); return 1; } static gint lua_mimepart_get_header_full(lua_State *L) { LUA_TRACE_POINT; return lua_mimepart_get_header_common(L, RSPAMD_TASK_HEADER_PUSH_FULL); } static gint lua_mimepart_get_header(lua_State *L) { LUA_TRACE_POINT; return lua_mimepart_get_header_common(L, RSPAMD_TASK_HEADER_PUSH_SIMPLE); } static gint lua_mimepart_get_header_raw(lua_State *L) { LUA_TRACE_POINT; return lua_mimepart_get_header_common(L, RSPAMD_TASK_HEADER_PUSH_RAW); } static gint lua_mimepart_get_header_count(lua_State *L) { LUA_TRACE_POINT; return lua_mimepart_get_header_common(L, RSPAMD_TASK_HEADER_PUSH_COUNT); } static gint lua_mimepart_get_raw_headers(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); struct rspamd_lua_text *t; if (part) { t = lua_newuserdata(L, sizeof(*t)); rspamd_lua_setclass(L, "rspamd{text}", -1); t->start = part->raw_headers_str; t->len = part->raw_headers_len; t->flags = 0; } else { return luaL_error(L, "invalid arguments"); } return 1; } static gint lua_mimepart_get_headers(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); bool need_modified = lua_isnoneornil(L, 2) ? false : lua_toboolean(L, 2); if (part) { struct rspamd_mime_header *cur; int i = 1; lua_createtable(L, rspamd_mime_headers_count(part->raw_headers), 0); LL_FOREACH2(part->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_mimepart_is_image(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } lua_pushboolean(L, part->part_type == RSPAMD_MIME_PART_IMAGE); return 1; } static gint lua_mimepart_is_archive(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } lua_pushboolean(L, part->part_type == RSPAMD_MIME_PART_ARCHIVE); return 1; } static gint lua_mimepart_is_multipart(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } lua_pushboolean(L, IS_PART_MULTIPART(part) ? true : false); return 1; } static gint lua_mimepart_is_message(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } lua_pushboolean(L, IS_PART_MESSAGE(part) ? true : false); return 1; } static gint lua_mimepart_is_attachment(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } if (part->cd && part->cd->type == RSPAMD_CT_ATTACHMENT) { lua_pushboolean(L, true); } else { /* if has_name and not (image and Content-ID_header_present) */ if (part->cd && part->cd->filename.len > 0) { if (part->part_type != RSPAMD_MIME_PART_IMAGE && rspamd_message_get_header_from_hash(part->raw_headers, "Content-Id", FALSE) == NULL) { /* Filename is presented but no content id and not image */ lua_pushboolean(L, true); } else { /* Image or an embedded object */ lua_pushboolean(L, false); } } else { /* No filename */ lua_pushboolean(L, false); } } return 1; } static gint lua_mimepart_is_text(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } lua_pushboolean(L, part->part_type == RSPAMD_MIME_PART_TEXT); return 1; } static gint lua_mimepart_is_broken(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } if (part->ct) { lua_pushboolean(L, (part->ct->flags & RSPAMD_CONTENT_TYPE_BROKEN) ? true : false); } else { lua_pushboolean(L, false); } return 1; } static gint lua_mimepart_get_image(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); struct rspamd_image **pimg; if (part == NULL) { return luaL_error(L, "invalid arguments"); } if (part->part_type != RSPAMD_MIME_PART_IMAGE || part->specific.img == NULL) { lua_pushnil(L); } else { pimg = lua_newuserdata(L, sizeof(*pimg)); *pimg = part->specific.img; rspamd_lua_setclass(L, "rspamd{image}", -1); } return 1; } static gint lua_mimepart_get_archive(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); struct rspamd_archive **parch; if (part == NULL) { return luaL_error(L, "invalid arguments"); } if (part->part_type != RSPAMD_MIME_PART_ARCHIVE || part->specific.arch == NULL) { lua_pushnil(L); } else { parch = lua_newuserdata(L, sizeof(*parch)); *parch = part->specific.arch; rspamd_lua_setclass(L, "rspamd{archive}", -1); } return 1; } static gint lua_mimepart_get_children(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); struct rspamd_mime_part **pcur, *cur; guint i; if (part == NULL) { return luaL_error(L, "invalid arguments"); } if (!IS_PART_MULTIPART(part) || part->specific.mp->children == NULL) { lua_pushnil(L); } else { lua_createtable(L, part->specific.mp->children->len, 0); PTR_ARRAY_FOREACH(part->specific.mp->children, i, cur) { pcur = lua_newuserdata(L, sizeof(*pcur)); *pcur = cur; rspamd_lua_setclass(L, "rspamd{mimepart}", -1); lua_rawseti(L, -2, i + 1); } } return 1; } static gint lua_mimepart_get_parent(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); struct rspamd_mime_part **pparent; if (part == NULL) { return luaL_error(L, "invalid arguments"); } if (part->parent_part) { pparent = lua_newuserdata(L, sizeof(*pparent)); *pparent = part->parent_part; rspamd_lua_setclass(L, "rspamd{mimepart}", -1); } else { lua_pushnil(L); } return 1; } static gint lua_mimepart_get_text(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); struct rspamd_mime_text_part **ppart; if (part == NULL) { return luaL_error(L, "invalid arguments"); } if (part->part_type != RSPAMD_MIME_PART_TEXT || part->specific.txt == NULL) { lua_pushnil(L); } else { ppart = lua_newuserdata(L, sizeof(*ppart)); *ppart = part->specific.txt; rspamd_lua_setclass(L, "rspamd{textpart}", -1); } return 1; } static gint lua_mimepart_get_digest(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); gchar digestbuf[rspamd_cryptobox_HASHBYTES * 2 + 1]; if (part == NULL) { return luaL_error(L, "invalid arguments"); } memset(digestbuf, 0, sizeof(digestbuf)); rspamd_encode_hex_buf(part->digest, sizeof(part->digest), digestbuf, sizeof(digestbuf)); lua_pushstring(L, digestbuf); return 1; } static gint lua_mimepart_get_id(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } lua_pushinteger(L, part->part_number); return 1; } static gint lua_mimepart_headers_foreach(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); 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 (part && lua_isfunction(L, 2)) { 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 (part->headers_order) { hdr = part->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); } } } return 0; } static gint lua_mimepart_get_specific(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } if (part->part_type != RSPAMD_MIME_PART_CUSTOM_LUA) { lua_pushnil(L); } else { lua_rawgeti(L, LUA_REGISTRYINDEX, part->specific.lua_specific.cbref); } return 1; } static gint lua_mimepart_get_urls(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } 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, i; if (part->urls == NULL) { lua_newtable(L); return 1; } if (!lua_url_cbdata_fill(L, 2, &cb, default_protocols_mask, ~(0), max_urls)) { return luaL_error(L, "invalid arguments"); } sz = part->urls->len; lua_createtable(L, sz, 0); PTR_ARRAY_FOREACH(part->urls, i, u) { lua_tree_url_callback(u, u, &cb); } lua_url_cbdata_dtor(&cb); return 1; } static gint lua_mimepart_is_specific(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL) { return luaL_error(L, "invalid arguments"); } lua_pushboolean(L, part->part_type == RSPAMD_MIME_PART_CUSTOM_LUA); return 1; } static gint lua_mimepart_set_specific(lua_State *L) { LUA_TRACE_POINT; struct rspamd_mime_part *part = lua_check_mimepart(L); if (part == NULL || lua_isnil(L, 2)) { return luaL_error(L, "invalid arguments"); } if (part->part_type != RSPAMD_MIME_PART_UNDEFINED && part->part_type != RSPAMD_MIME_PART_CUSTOM_LUA) { return luaL_error(L, "internal error: trying to set specific lua content on part of type %d", part->part_type); } if (part->part_type == RSPAMD_MIME_PART_CUSTOM_LUA) { /* Push old specific data */ lua_rawgeti(L, LUA_REGISTRYINDEX, part->specific.lua_specific.cbref); luaL_unref(L, LUA_REGISTRYINDEX, part->specific.lua_specific.cbref); } else { part->part_type = RSPAMD_MIME_PART_CUSTOM_LUA; lua_pushnil(L); } /* Now, we push argument on the position 2 and save its reference */ lua_pushvalue(L, 2); part->specific.lua_specific.cbref = luaL_ref(L, LUA_REGISTRYINDEX); /* Now stack has just a return value as luaL_ref removes value from stack */ gint ltype = lua_type(L, 2); switch (ltype) { case LUA_TTABLE: part->specific.lua_specific.type = RSPAMD_LUA_PART_TABLE; break; case LUA_TSTRING: part->specific.lua_specific.type = RSPAMD_LUA_PART_STRING; break; case LUA_TUSERDATA: if (rspamd_lua_check_udata_maybe(L, 2, "rspamd{text}")) { part->specific.lua_specific.type = RSPAMD_LUA_PART_TEXT; } else { part->specific.lua_specific.type = RSPAMD_LUA_PART_UNKNOWN; } break; case LUA_TFUNCTION: part->specific.lua_specific.type = RSPAMD_LUA_PART_FUNCTION; break; default: part->specific.lua_specific.type = RSPAMD_LUA_PART_UNKNOWN; break; } return 1; } void luaopen_textpart(lua_State *L) { rspamd_lua_new_class(L, "rspamd{textpart}", textpartlib_m); lua_pop(L, 1); } void luaopen_mimepart(lua_State *L) { rspamd_lua_new_class(L, "rspamd{mimepart}", mimepartlib_m); lua_pop(L, 1); }