{"id":20874661,"url":"https://github.com/neomutt/test-library","last_synced_at":"2026-05-27T18:32:23.823Z","repository":{"id":72106960,"uuid":"99167919","full_name":"neomutt/test-library","owner":"neomutt","description":"⚠️ Sample code to test the NeoMutt libraries","archived":false,"fork":false,"pushed_at":"2023-09-26T21:35:44.000Z","size":275,"stargazers_count":2,"open_issues_count":0,"forks_count":0,"subscribers_count":5,"default_branch":"main","last_synced_at":"2025-03-12T16:15:11.567Z","etag":null,"topics":["c","library","neomutt","test"],"latest_commit_sha":null,"homepage":"","language":"C","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/neomutt.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2017-08-02T22:58:09.000Z","updated_at":"2023-02-27T23:05:40.000Z","dependencies_parsed_at":"2024-11-18T09:30:51.438Z","dependency_job_id":null,"html_url":"https://github.com/neomutt/test-library","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/neomutt/test-library","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/neomutt%2Ftest-library","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/neomutt%2Ftest-library/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/neomutt%2Ftest-library/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/neomutt%2Ftest-library/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/neomutt","download_url":"https://codeload.github.com/neomutt/test-library/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/neomutt%2Ftest-library/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33579665,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-05-27T02:00:06.184Z","response_time":53,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["c","library","neomutt","test"],"created_at":"2024-11-18T06:35:35.764Z","updated_at":"2026-05-27T18:32:23.805Z","avatar_url":"https://github.com/neomutt.png","language":"C","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Test Code for NeoMutt Libraries\n\n## Notes\n\n- They work for me, YMMV\n- They may get deleted without warning\n- They expect NeoMutt to be built in `../neo`\n\n## Samples\n\n- `test_conn` looks up a hostname\n- `test_hcache` creates an entry in the header cache and retrieves it\n- `test_lib` calls a function from each of the library source files\n\n## Library (477 functions)\n\nThere are now four libraries: libaddress, libcore, libemail and libmutt.\n\n### account (core)\n\n```c\nvoid                    account_free                      (struct Account **ptr);\nbool                    account_mailbox_add               (struct Account *a, struct Mailbox *m);\nbool                    account_mailbox_remove            (struct Account *a, struct Mailbox *m);\nstruct Account *        account_new                       (const char *name, struct ConfigSubset *sub);\n```\n\n### address (address)\n\n```c\nconst char AddressSpecials[];\n\nvoid                    mutt_addr_cat                     (char *buf, size_t buflen, const char *value, const char *specials);\nbool                    mutt_addr_cmp                     (const struct Address *a, const struct Address *b);\nstruct Address *        mutt_addr_copy                    (const struct Address *addr);\nstruct Address *        mutt_addr_create                  (const char *personal, const char *mailbox);\nconst char *            mutt_addr_for_display             (const struct Address *a);\nvoid                    mutt_addr_free                    (struct Address **ptr);\nstruct Address *        mutt_addr_new                     (void);\nbool                    mutt_addr_to_intl                 (struct Address *a);\nbool                    mutt_addr_to_local                (struct Address *a);\nbool                    mutt_addr_uses_unicode            (const char *str);\nbool                    mutt_addr_valid_msgid             (const char *msgid);\nsize_t                  mutt_addr_write                   (struct Buffer *buf, struct Address *addr, bool display);\nvoid                    mutt_addrlist_append              (struct AddressList *al, struct Address *a);\nvoid                    mutt_addrlist_clear               (struct AddressList *al);\nvoid                    mutt_addrlist_copy                (struct AddressList *dst, const struct AddressList *src, bool prune);\nint                     mutt_addrlist_count_recips        (const struct AddressList *al);\nvoid                    mutt_addrlist_dedupe              (struct AddressList *al);\nbool                    mutt_addrlist_equal               (const struct AddressList *ala, const struct AddressList *alb);\nint                     mutt_addrlist_parse               (struct AddressList *al, const char *s);\nint                     mutt_addrlist_parse2              (struct AddressList *al, const char *s);\nvoid                    mutt_addrlist_prepend             (struct AddressList *al, struct Address *a);\nvoid                    mutt_addrlist_qualify             (struct AddressList *al, const char *host);\nint                     mutt_addrlist_remove              (struct AddressList *al, const char *mailbox);\nvoid                    mutt_addrlist_remove_xrefs        (const struct AddressList *a, struct AddressList *b);\nbool                    mutt_addrlist_search              (const struct AddressList *haystack, const struct Address *needle);\nint                     mutt_addrlist_to_intl             (struct AddressList *al, char **err);\nint                     mutt_addrlist_to_local            (struct AddressList *al);\nbool                    mutt_addrlist_uses_unicode        (const struct AddressList *al);\nsize_t                  mutt_addrlist_write               (const struct AddressList *al, struct Buffer *buf, bool display);\nvoid                    mutt_addrlist_write_file          (const struct AddressList *al, FILE *fp, const char *header);\nsize_t                  mutt_addrlist_write_list          (const struct AddressList *al, struct ListHead *list);\nsize_t                  mutt_addrlist_write_wrap          (const struct AddressList *al, struct Buffer *buf, const char *header);\n```\n\n### atoi (mutt)\n\n```c\nconst char *            mutt_str_atoi                     (const char *str, int *dst);\nconst char *            mutt_str_atol                     (const char *str, long *dst);\nconst char *            mutt_str_atos                     (const char *str, short *dst);\nconst char *            mutt_str_atoui                    (const char *str, unsigned int *dst);\nconst char *            mutt_str_atoul                    (const char *str, unsigned long *dst);\nconst char *            mutt_str_atoull                   (const char *str, unsigned long long *dst);\nconst char *            mutt_str_atous                    (const char *str, unsigned short *dst);\n```\n\n### base64 (mutt)\n\n```c\nconst int Index64[];\n\nint                     mutt_b64_buffer_decode            (struct Buffer *buf, const char *in);\nsize_t                  mutt_b64_buffer_encode            (struct Buffer *buf, const char *in, size_t len);\nint                     mutt_b64_decode                   (const char *in, char *out, size_t olen);\nsize_t                  mutt_b64_encode                   (const char *in, size_t inlen, char *out, size_t outlen);\n```\n\n### body (email)\n\n```c\nbool                    mutt_body_cmp_strict              (const struct Body *b1, const struct Body *b2);\nvoid                    mutt_body_free                    (struct Body **ptr);\nchar *                  mutt_body_get_charset             (struct Body *b, char *buf, size_t buflen);\nstruct Body *           mutt_body_new                     (void);\n```\n\n### buffer (mutt)\n\n```c\nint                     buf_add_printf                    (struct Buffer *buf, const char *fmt, ...);\nsize_t                  buf_addch                         (struct Buffer *buf, char c);\nsize_t                  buf_addstr                        (struct Buffer *buf, const char *s);\nsize_t                  buf_addstr_n                      (struct Buffer *buf, const char *s, size_t len);\nvoid                    buf_alloc                         (struct Buffer *buf, size_t new_size);\nchar                    buf_at                            (const struct Buffer *buf, size_t offset);\nint                     buf_coll                          (const struct Buffer *a, const struct Buffer *b);\nsize_t                  buf_concat_path                   (struct Buffer *buf, const char *dir, const char *fname);\nsize_t                  buf_concatn_path                  (struct Buffer *buf, const char *dir, size_t dirlen, const char *fname, size_t fnamelen);\nsize_t                  buf_copy                          (struct Buffer *dst, const struct Buffer *src);\nvoid                    buf_dealloc                       (struct Buffer *buf);\nvoid                    buf_dequote_comment               (struct Buffer *buf);\nstruct Buffer *         buf_dup                           (const struct Buffer *buf);\nconst char *            buf_find_char                     (const struct Buffer *buf, const char c);\nconst char *            buf_find_string                   (const struct Buffer *buf, const char *s);\nvoid                    buf_fix_dptr                      (struct Buffer *buf);\nvoid                    buf_free                          (struct Buffer **ptr);\nstruct Buffer *         buf_init                          (struct Buffer *buf);\nsize_t                  buf_insert                        (struct Buffer *buf, size_t offset, const char *s);\nbool                    buf_is_empty                      (const struct Buffer *buf);\nbool                    buf_istr_equal                    (const struct Buffer *a, const struct Buffer *b);\nsize_t                  buf_len                           (const struct Buffer *buf);\nvoid                    buf_lower                         (struct Buffer *buf);\nstruct Buffer           buf_make                          (size_t size);\nstruct Buffer *         buf_new                           (const char *str);\nint                     buf_printf                        (struct Buffer *buf, const char *fmt, ...);\nvoid                    buf_reset                         (struct Buffer *buf);\nvoid                    buf_seek                          (struct Buffer *buf, size_t offset);\nsize_t                  buf_startswith                    (const struct Buffer *buf, const char *prefix);\nbool                    buf_str_equal                     (const struct Buffer *a, const struct Buffer *b);\nsize_t                  buf_strcpy                        (struct Buffer *buf, const char *s);\nsize_t                  buf_strcpy_n                      (struct Buffer *buf, const char *s, size_t len);\nchar *                  buf_strdup                        (const struct Buffer *buf);\nsize_t                  buf_substrcpy                     (struct Buffer *buf, const char *beg, const char *end);\nvoid                    buf_upper                         (struct Buffer *buf);\n```\n\n### charset (mutt)\n\n```c\nbool CharsetIsUtf8;\nwchar_t ReplacementChar;\n\nvoid                    mutt_ch_cache_cleanup             (void);\nvoid                    mutt_ch_canonical_charset         (char *buf, size_t buflen, const char *name);\nconst char *            mutt_ch_charset_lookup            (const char *chs);\nint                     mutt_ch_check                     (const char *s, size_t slen, const char *from, const char *to);\nbool                    mutt_ch_check_charset             (const char *cs, bool strict);\nchar *                  mutt_ch_choose                    (const char *fromcode, const struct Slist *charsets, const char *u, size_t ulen, char **d, size_t *dlen);\nbool                    mutt_ch_chscmp                    (const char *cs1, const char *cs2);\nint                     mutt_ch_convert_nonmime_string    (const struct Slist *const assumed_charset, const char *charset, char **ps);\nint                     mutt_ch_convert_string            (char **ps, const char *from, const char *to, uint8_t flags);\nint                     mutt_ch_fgetconv                  (struct FgetConv *fc);\nvoid                    mutt_ch_fgetconv_close            (struct FgetConv **ptr);\nstruct FgetConv *       mutt_ch_fgetconv_open             (FILE *fp, const char *from, const char *to, uint8_t flags);\nchar *                  mutt_ch_fgetconvs                 (char *buf, size_t buflen, struct FgetConv *fc);\nconst char *            mutt_ch_get_default_charset       (const struct Slist *const assumed_charset);\nchar *                  mutt_ch_get_langinfo_charset      (void);\nsize_t                  mutt_ch_iconv                     (iconv_t cd, const char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft, const char **inrepls, const char *outrepl, int *iconverrno);\nconst char *            mutt_ch_iconv_lookup              (const char *chs);\niconv_t                 mutt_ch_iconv_open                (const char *tocode, const char *fromcode, uint8_t flags);\nbool                    mutt_ch_lookup_add                (enum LookupType type, const char *pat, const char *replace, struct Buffer *err);\nvoid                    mutt_ch_lookup_remove             (void);\nvoid                    mutt_ch_set_charset               (const char *charset);\n```\n\n### command (core)\n\n```c\nstruct Command *        command_get                       (const char *s);\nsize_t                  commands_array                    (struct Command **first);\nvoid                    commands_cleanup                  (void);\nvoid                    commands_register                 (const struct Command *cmds, const size_t num_cmds);\n```\n\n### config_cache (core)\n\n```c\nconst struct Slist *    cc_assumed_charset                (void);\nconst char *            cc_charset                        (void);\nconst char *            cc_maildir_field_delimiter        (void);\nvoid                    config_cache_cleanup              (void);\n```\n\n### config_type (address)\n\n```c\nstruct Address *        address_new                       (const char *addr);\nconst struct Address *  cs_subset_address                 (const struct ConfigSubset *sub, const char *name);\n```\n\n### date (mutt)\n\n```c\ntime_t                  mutt_date_add_timeout             (time_t now, time_t timeout);\nint                     mutt_date_check_month             (const char *s);\nstruct tm               mutt_date_gmtime                  (time_t t);\nint                     mutt_date_local_tz                (time_t t);\nstruct tm               mutt_date_localtime               (time_t t);\nsize_t                  mutt_date_localtime_format        (char *buf, size_t buflen, const char *format, time_t t);\nsize_t                  mutt_date_localtime_format_locale (char *buf, size_t buflen, const char *format, time_t t, locale_t loc);\nvoid                    mutt_date_make_date               (struct Buffer *buf, bool local);\nint                     mutt_date_make_imap               (char *buf, size_t buflen, time_t timestamp);\ntime_t                  mutt_date_make_time               (struct tm *t, bool local);\nint                     mutt_date_make_tls                (char *buf, size_t buflen, time_t timestamp);\nvoid                    mutt_date_normalize_time          (struct tm *tm);\ntime_t                  mutt_date_now                     (void);\nuint64_t                mutt_date_now_ms                  (void);\ntime_t                  mutt_date_parse_date              (const char *s, struct Tz *tz_out);\ntime_t                  mutt_date_parse_imap              (const char *s);\nvoid                    mutt_date_sleep_ms                (size_t ms);\n```\n\n### dispatcher (core)\n\n```c\nconst char *            dispatcher_get_retval_name        (int rv);\n```\n\n### email (email)\n\n```c\nbool                    email_cmp_strict                  (const struct Email *e1, const struct Email *e2);\nvoid                    email_free                        (struct Email **ptr);\nstruct Email *          email_new                         (void);\nsize_t                  email_size                        (const struct Email *e);\nstruct ListNode *       header_add                        (struct ListHead *hdrlist, const char *header);\nstruct ListNode *       header_find                       (const struct ListHead *hdrlist, const char *header);\nvoid                    header_free                       (struct ListHead *hdrlist, struct ListNode *target);\nstruct ListNode *       header_set                        (struct ListHead *hdrlist, const char *header);\nstruct ListNode *       header_update                     (struct ListNode *hdr, const char *header);\n```\n\n### envelope (email)\n\n```c\nvoid                    mutt_autocrypthdr_free            (struct AutocryptHeader **ptr);\nstruct AutocryptHeader *mutt_autocrypthdr_new             (void);\nbool                    mutt_env_cmp_strict               (const struct Envelope *e1, const struct Envelope *e2);\nvoid                    mutt_env_free                     (struct Envelope **ptr);\nvoid                    mutt_env_merge                    (struct Envelope *base, struct Envelope **extra);\nstruct Envelope *       mutt_env_new                      (void);\nbool                    mutt_env_notify_send              (struct Email *e, enum NotifyEnvelope type);\nint                     mutt_env_to_intl                  (struct Envelope *env, const char **tag, char **err);\nvoid                    mutt_env_to_local                 (struct Envelope *env);\n```\n\n### envlist (mutt)\n\n```c\nvoid                    envlist_free                      (char ***envp);\nchar **                 envlist_init                      (char **envp);\nbool                    envlist_set                       (char ***envp, const char *name, const char *value, bool overwrite);\nbool                    envlist_unset                     (char ***envp, const char *name);\n```\n\n### exit (mutt)\n\n```c\nvoid                    mutt_exit                         (int code);\n```\n\n### file (mutt)\n\n```c\nconst char FilenameSafeChars[];\n\nvoid                    buf_file_expand_fmt_quote         (struct Buffer *dest, const char *fmt, const char *src);\nvoid                    buf_quote_filename                (struct Buffer *buf, const char *filename, bool add_outer);\nint                     mutt_file_check_empty             (const char *path);\nint                     mutt_file_chmod                   (const char *path, mode_t mode);\nint                     mutt_file_chmod_add               (const char *path, mode_t mode);\nint                     mutt_file_chmod_add_stat          (const char *path, mode_t mode, struct stat *st);\nint                     mutt_file_chmod_rm                (const char *path, mode_t mode);\nint                     mutt_file_chmod_rm_stat           (const char *path, mode_t mode, struct stat *st);\nint                     mutt_file_copy_bytes              (FILE *fp_in, FILE *fp_out, size_t size);\nint                     mutt_file_copy_stream             (FILE *fp_in, FILE *fp_out);\ntime_t                  mutt_file_decrease_mtime          (const char *fp, struct stat *st);\nvoid                    mutt_file_expand_fmt              (struct Buffer *dest, const char *fmt, const char *src);\nint                     mutt_file_fclose                  (FILE **fp);\nFILE *                  mutt_file_fopen                   (const char *path, const char *mode);\nint                     mutt_file_fsync_close             (FILE **fp);\nlong                    mutt_file_get_size                (const char *path);\nlong                    mutt_file_get_size_fp             (FILE *fp);\nvoid                    mutt_file_get_stat_timespec       (struct timespec *dest, struct stat *st, enum MuttStatType type);\nbool                    mutt_file_iter_line               (struct MuttFileIter *iter, FILE *fp, ReadLineFlags flags);\nint                     mutt_file_lock                    (int fd, bool excl, bool timeout);\nbool                    mutt_file_map_lines               (mutt_file_map_t func, void *user_data, FILE *fp, ReadLineFlags flags);\nint                     mutt_file_mkdir                   (const char *path, mode_t mode);\nint                     mutt_file_open                    (const char *path, uint32_t flags);\nDIR *                   mutt_file_opendir                 (const char *path, enum MuttOpenDirMode mode);\nsize_t                  mutt_file_quote_filename          (const char *filename, char *buf, size_t buflen);\nchar *                  mutt_file_read_keyword            (const char *file, char *buf, size_t buflen);\nchar *                  mutt_file_read_line               (char *line, size_t *size, FILE *fp, int *line_num, ReadLineFlags flags);\nint                     mutt_file_rename                  (const char *oldfile, const char *newfile);\nvoid                    mutt_file_resolve_symlink         (struct Buffer *buf);\nint                     mutt_file_rmtree                  (const char *path);\nconst char *            mutt_file_rotate                  (const char *path, int count);\nint                     mutt_file_safe_rename             (const char *src, const char *target);\nvoid                    mutt_file_sanitize_filename       (char *path, bool slash);\nint                     mutt_file_sanitize_regex          (struct Buffer *dest, const char *src);\nbool                    mutt_file_seek                    (FILE *fp, off_t offset, int whence);\nvoid                    mutt_file_set_mtime               (const char *from, const char *to);\nint                     mutt_file_stat_compare            (struct stat *st1, enum MuttStatType st1_type, struct stat *st2, enum MuttStatType st2_type);\nint                     mutt_file_stat_timespec_compare   (struct stat *st, enum MuttStatType type, struct timespec *b);\nint                     mutt_file_symlink                 (const char *oldpath, const char *newpath);\nint                     mutt_file_timespec_compare        (struct timespec *a, struct timespec *b);\nvoid                    mutt_file_touch_atime             (int fd);\nvoid                    mutt_file_unlink                  (const char *s);\nvoid                    mutt_file_unlink_empty            (const char *path);\nint                     mutt_file_unlock                  (int fd);\n```\n\n### filter (mutt)\n\n```c\npid_t                   filter_create                     (const char *cmd, FILE **fp_in, FILE **fp_out, FILE **fp_err, char **envlist);\npid_t                   filter_create_fd                  (const char *cmd, FILE **fp_in, FILE **fp_out, FILE **fp_err, int fdin, int fdout, int fderr, char **envlist);\nint                     filter_wait                       (pid_t pid);\n```\n\n### from (email)\n\n```c\nbool                    is_from                           (const char *s, char *path, size_t pathlen, time_t *tp);\n```\n\n### globals (email)\n\n```c\nstruct HashTable *AutoSubscribeCache;\nstruct ListHead Ignore;\nstruct RegexList MailLists;\nstruct ListHead MailToAllow;\nstruct RegexList NoSpamList;\nstruct ReplaceList SpamList;\nstruct RegexList SubscribedLists;\nstruct ListHead UnIgnore;\nstruct RegexList UnMailLists;\nstruct RegexList UnSubscribedLists;\n```\n\n### group (address)\n\n```c\nbool                    mutt_group_match                  (struct Group *g, const char *s);\nvoid                    mutt_grouplist_add                (struct GroupList *gl, struct Group *group);\nvoid                    mutt_grouplist_add_addrlist       (struct GroupList *gl, struct AddressList *al);\nint                     mutt_grouplist_add_regex          (struct GroupList *gl, const char *s, uint16_t flags, struct Buffer *err);\nvoid                    mutt_grouplist_cleanup            (void);\nvoid                    mutt_grouplist_clear              (struct GroupList *gl);\nvoid                    mutt_grouplist_destroy            (struct GroupList *gl);\nvoid                    mutt_grouplist_init               (void);\nint                     mutt_grouplist_remove_addrlist    (struct GroupList *gl, struct AddressList *al);\nint                     mutt_grouplist_remove_regex       (struct GroupList *gl, const char *s);\nstruct Group *          mutt_pattern_group                (const char *pat);\n```\n\n### hash (mutt)\n\n```c\nvoid                    mutt_hash_delete                  (struct HashTable *table, const char *strkey, const void *data);\nvoid *                  mutt_hash_find                    (const struct HashTable *table, const char *strkey);\nstruct HashElem *       mutt_hash_find_bucket             (const struct HashTable *table, const char *strkey);\nstruct HashElem *       mutt_hash_find_elem               (const struct HashTable *table, const char *strkey);\nvoid                    mutt_hash_free                    (struct HashTable **ptr);\nstruct HashElem *       mutt_hash_insert                  (struct HashTable *table, const char *strkey, void *data);\nvoid                    mutt_hash_int_delete              (struct HashTable *table, unsigned int intkey, const void *data);\nvoid *                  mutt_hash_int_find                (const struct HashTable *table, unsigned int intkey);\nstruct HashElem *       mutt_hash_int_insert              (struct HashTable *table, unsigned int intkey, void *data);\nstruct HashTable *      mutt_hash_int_new                 (size_t num_elems, HashFlags flags);\nstruct HashTable *      mutt_hash_new                     (size_t num_elems, HashFlags flags);\nvoid                    mutt_hash_set_destructor          (struct HashTable *table, hash_hdata_free_t fn, intptr_t fn_data);\nstruct HashElem *       mutt_hash_typed_insert            (struct HashTable *table, const char *strkey, int type, void *data);\nstruct HashElem *       mutt_hash_walk                    (const struct HashTable *table, struct HashWalkState *state);\n```\n\n### idna (address)\n\n```c\nchar *                  mutt_idna_intl_to_local           (const char *user, const char *domain, uint8_t flags);\nchar *                  mutt_idna_local_to_intl           (const char *user, const char *domain);\nconst char *            mutt_idna_print_version           (void);\nint                     mutt_idna_to_ascii_lz             (const char *input, char **output, uint8_t flags);\n```\n\n### list (mutt)\n\n```c\nvoid                    mutt_list_clear                   (struct ListHead *h);\nbool                    mutt_list_compare                 (const struct ListHead *ah, const struct ListHead *bh);\nstruct ListNode *       mutt_list_find                    (const struct ListHead *h, const char *data);\nvoid                    mutt_list_free                    (struct ListHead *h);\nvoid                    mutt_list_free_type               (struct ListHead *h, list_free_t fn);\nstruct ListNode *       mutt_list_insert_after            (struct ListHead *h, struct ListNode *n, char *s);\nstruct ListNode *       mutt_list_insert_head             (struct ListHead *h, char *s);\nstruct ListNode *       mutt_list_insert_tail             (struct ListHead *h, char *s);\nbool                    mutt_list_match                   (const char *s, struct ListHead *h);\nsize_t                  mutt_list_str_split               (struct ListHead *head, const char *src, char sep);\n```\n\n### logging (mutt)\n\n```c\nlog_dispatcher_t MuttLogger;\n\nint                     log_disp_file                     (time_t stamp, const char *file, int line, const char *function, enum LogLevel level, const char *format, ...);\nint                     log_disp_null                     (time_t stamp, const char *file, int line, const char *function, enum LogLevel level, const char *format, ...);\nint                     log_disp_queue                    (time_t stamp, const char *file, int line, const char *function, enum LogLevel level, const char *format, ...);\nint                     log_disp_terminal                 (time_t stamp, const char *file, int line, const char *function, enum LogLevel level, const char *format, ...);\nvoid                    log_file_close                    (bool verbose);\nint                     log_file_open                     (bool verbose);\nbool                    log_file_running                  (void);\nint                     log_file_set_filename             (const char *file, bool verbose);\nint                     log_file_set_level                (enum LogLevel level, bool verbose);\nvoid                    log_file_set_version              (const char *version);\nint                     log_queue_add                     (struct LogLine *ll);\nvoid                    log_queue_empty                   (void);\nvoid                    log_queue_flush                   (log_dispatcher_t disp);\nint                     log_queue_save                    (FILE *fp);\nvoid                    log_queue_set_max_size            (int size);\n```\n\n### mailbox (core)\n\n```c\nvoid                    mailbox_changed                   (struct Mailbox *m, enum NotifyMailbox action);\nstruct Mailbox *        mailbox_find                      (const char *path);\nstruct Mailbox *        mailbox_find_name                 (const char *name);\nvoid                    mailbox_free                      (struct Mailbox **ptr);\nvoid                    mailbox_gc_add                    (struct Email *e);\nvoid                    mailbox_gc_run                    (void);\nint                     mailbox_gen                       (void);\nconst char *            mailbox_get_type_name             (enum MailboxType type);\nstruct Mailbox *        mailbox_new                       (void);\nbool                    mailbox_set_subset                (struct Mailbox *m, struct ConfigSubset *sub);\nvoid                    mailbox_size_add                  (struct Mailbox *m, const struct Email *e);\nvoid                    mailbox_size_sub                  (struct Mailbox *m, const struct Email *e);\nvoid                    mailbox_update                    (struct Mailbox *m);\n```\n\n### mapping (mutt)\n\n```c\nconst char *            mutt_map_get_name                 (int val, const struct Mapping *map);\nint                     mutt_map_get_value                (const char *name, const struct Mapping *map);\nint                     mutt_map_get_value_n              (const char *name, size_t len, const struct Mapping *map);\n```\n\n### mbyte (mutt)\n\n```c\nbool OptLocales;\n\nvoid                    buf_mb_wcstombs                   (struct Buffer *dest, const wchar_t *wstr, size_t wlen);\nint                     mutt_mb_charlen                   (const char *s, int *width);\nint                     mutt_mb_filter_unprintable        (char **s);\nbool                    mutt_mb_get_initials              (const char *name, char *buf, size_t buflen);\nbool                    mutt_mb_is_display_corrupting_utf8(wchar_t wc);\nbool                    mutt_mb_is_lower                  (const char *s);\nbool                    mutt_mb_is_shell_char             (wchar_t ch);\nsize_t                  mutt_mb_mbstowcs                  (wchar_t **pwbuf, size_t *pwbuflen, size_t i, const char *buf);\nint                     mutt_mb_wcswidth                  (const wchar_t *s, size_t n);\nint                     mutt_mb_wcwidth                   (wchar_t wc);\nint                     mutt_mb_width                     (const char *str, int col, bool indent);\nsize_t                  mutt_mb_width_ceiling             (const wchar_t *s, size_t n, int w1);\n```\n\n### md5 (mutt)\n\n```c\nvoid *                  mutt_md5                          (const char *str, void *buf);\nvoid *                  mutt_md5_bytes                    (const void *buffer, size_t len, void *resbuf);\nvoid *                  mutt_md5_finish_ctx               (struct Md5Ctx *md5ctx, void *resbuf);\nvoid                    mutt_md5_init_ctx                 (struct Md5Ctx *md5ctx);\nvoid                    mutt_md5_process                  (const char *str, struct Md5Ctx *md5ctx);\nvoid                    mutt_md5_process_bytes            (const void *buf, size_t buflen, struct Md5Ctx *md5ctx);\nvoid                    mutt_md5_toascii                  (const void *digest, char *resbuf);\n```\n\n### memory (mutt)\n\n```c\nvoid *                  mutt_mem_calloc                   (size_t nmemb, size_t size);\nvoid                    mutt_mem_free                     (void *ptr);\nvoid *                  mutt_mem_malloc                   (size_t size);\nvoid                    mutt_mem_realloc                  (void *ptr, size_t size);\n```\n\n### message (core)\n\n```c\nvoid                    message_free                      (struct Message **ptr);\nstruct Message *        message_new                       (void);\n```\n\n### mime (email)\n\n```c\nconst char *const BodyEncodings[];\nconst char *const BodyTypes[];\nconst int IndexHex[];\nconst char MimeSpecials[];\n```\n\n### neomutt (core)\n\n```c\nstruct NeoMutt *NeoMutt;\n\nbool                    neomutt_account_add               (struct NeoMutt *n, struct Account *a);\nbool                    neomutt_account_remove            (struct NeoMutt *n, const struct Account *a);\nvoid                    neomutt_free                      (struct NeoMutt **ptr);\nvoid                    neomutt_mailboxlist_clear         (struct MailboxList *ml);\nsize_t                  neomutt_mailboxlist_get_all       (struct MailboxList *head, struct NeoMutt *n, enum MailboxType type);\nstruct NeoMutt *        neomutt_new                       (struct ConfigSet *cs);\n```\n\n### notify (mutt)\n\n```c\nvoid                    notify_free                       (struct Notify **ptr);\nstruct Notify *         notify_new                        (void);\nbool                    notify_observer_add               (struct Notify *notify, enum NotifyType type, observer_t callback, void *global_data);\nbool                    notify_observer_remove            (struct Notify *notify, const observer_t callback, const void *global_data);\nvoid                    notify_observer_remove_all        (struct Notify *notify);\nbool                    notify_send                       (struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data);\nvoid                    notify_set_parent                 (struct Notify *notify, struct Notify *parent);\n```\n\n### parameter (email)\n\n```c\nbool                    mutt_param_cmp_strict             (const struct ParameterList *pl1, const struct ParameterList *pl2);\nvoid                    mutt_param_delete                 (struct ParameterList *pl, const char *attribute);\nvoid                    mutt_param_free                   (struct ParameterList *pl);\nvoid                    mutt_param_free_one               (struct Parameter **p);\nchar *                  mutt_param_get                    (const struct ParameterList *pl, const char *s);\nstruct Parameter *      mutt_param_new                    (void);\nvoid                    mutt_param_set                    (struct ParameterList *pl, const char *attribute, const char *value);\n```\n\n### parse (email)\n\n```c\nvoid                    mutt_auto_subscribe               (const char *mailto);\nint                     mutt_check_encoding               (const char *c);\nenum ContentType        mutt_check_mime_type              (const char *s);\nchar *                  mutt_extract_message_id           (const char *s, size_t *len);\nbool                    mutt_is_message_type              (int type, const char *subtype);\nbool                    mutt_matches_ignore               (const char *s);\nvoid                    mutt_parse_content_type           (const char *s, struct Body *ct);\nbool                    mutt_parse_mailto                 (struct Envelope *env, char **body, const char *src);\nstruct Body *           mutt_parse_multipart              (FILE *fp, const char *boundary, off_t end_off, bool digest);\nvoid                    mutt_parse_part                   (FILE *fp, struct Body *b);\nstruct Body *           mutt_read_mime_header             (FILE *fp, bool digest);\nint                     mutt_rfc822_parse_line            (struct Envelope *env, struct Email *e, const char *name, size_t name_len, const char *body, bool user_hdrs, bool weed, bool do_2047);\nstruct Body *           mutt_rfc822_parse_message         (FILE *fp, struct Body *parent);\nstruct Envelope *       mutt_rfc822_read_header           (FILE *fp, struct Email *e, bool user_hdrs, bool weed);\nsize_t                  mutt_rfc822_read_line             (FILE *fp, struct Buffer *buf);\n```\n\n### path (mutt)\n\n```c\nbool                    mutt_path_abbr_folder             (struct Buffer *path, const char *folder);\nconst char *            mutt_path_basename                (const char *path);\nbool                    mutt_path_canon                   (struct Buffer *path, const char *homedir, bool is_dir);\nchar *                  mutt_path_concat                  (char *dest, const char *dir, const char *file, size_t dlen);\nchar *                  mutt_path_dirname                 (const char *path);\nchar *                  mutt_path_escape                  (const char *src);\nconst char *            mutt_path_getcwd                  (struct Buffer *cwd);\nbool                    mutt_path_parent                  (struct Buffer *path);\nbool                    mutt_path_pretty                  (struct Buffer *path, const char *homedir, bool is_dir);\nsize_t                  mutt_path_realpath                (struct Buffer *path);\nbool                    mutt_path_tidy                    (struct Buffer *path, bool is_dir);\nbool                    mutt_path_tidy_dotdot             (char *buf);\nbool                    mutt_path_tidy_slash              (char *buf, bool is_dir);\nbool                    mutt_path_tilde                   (struct Buffer *path, const char *homedir);\nbool                    mutt_path_to_absolute             (char *path, const char *reference);\n```\n\n### pool (mutt)\n\n```c\nvoid                    buf_pool_cleanup                  (void);\nstruct Buffer *         buf_pool_get                      (void);\nvoid                    buf_pool_release                  (struct Buffer **ptr);\n```\n\n### prex (mutt)\n\n```c\nregmatch_t *            mutt_prex_capture                 (enum Prex which, const char *str);\nvoid                    mutt_prex_cleanup                 (void);\n```\n\n### qsort_r (mutt)\n\n```c\nvoid                    mutt_qsort_r                      (void *base, size_t nmemb, size_t size, sort_t compar, void *sdata);\n```\n\n### random (mutt)\n\n```c\nuint32_t                mutt_rand32                       (void);\nuint64_t                mutt_rand64                       (void);\nvoid                    mutt_rand_base32                  (char *buf, size_t buflen);\n```\n\n### regex (mutt)\n\n```c\nbool                    mutt_regex_capture                (const struct Regex *regex, const char *str, size_t nmatch, regmatch_t matches());\nstruct Regex *          mutt_regex_compile                (const char *str, uint16_t flags);\nvoid                    mutt_regex_free                   (struct Regex **ptr);\nbool                    mutt_regex_match                  (const struct Regex *regex, const char *str);\nstruct Regex *          mutt_regex_new                    (const char *str, uint32_t flags, struct Buffer *err);\nint                     mutt_regexlist_add                (struct RegexList *rl, const char *str, uint16_t flags, struct Buffer *err);\nvoid                    mutt_regexlist_free               (struct RegexList *rl);\nbool                    mutt_regexlist_match              (struct RegexList *rl, const char *str);\nstruct RegexNode *      mutt_regexlist_new                (void);\nint                     mutt_regexlist_remove             (struct RegexList *rl, const char *str);\nint                     mutt_replacelist_add              (struct ReplaceList *rl, const char *pat, const char *templ, struct Buffer *err);\nchar *                  mutt_replacelist_apply            (struct ReplaceList *rl, char *buf, size_t buflen, const char *str);\nvoid                    mutt_replacelist_free             (struct ReplaceList *rl);\nbool                    mutt_replacelist_match            (struct ReplaceList *rl, char *buf, size_t buflen, const char *str);\nstruct Replace *        mutt_replacelist_new              (void);\nint                     mutt_replacelist_remove           (struct ReplaceList *rl, const char *pat);\n```\n\n### rfc2047 (email)\n\n```c\nvoid                    rfc2047_decode                    (char **pd);\nvoid                    rfc2047_decode_addrlist           (struct AddressList *al);\nvoid                    rfc2047_decode_envelope           (struct Envelope *env);\nvoid                    rfc2047_encode                    (char **pd, const char *specials, int col, const struct Slist *charsets);\nvoid                    rfc2047_encode_addrlist           (struct AddressList *al, const char *tag);\nvoid                    rfc2047_encode_envelope           (struct Envelope *env);\n```\n\n### rfc2231 (email)\n\n```c\nvoid                    rfc2231_decode_parameters         (struct ParameterList *pl);\nsize_t                  rfc2231_encode_string             (struct ParameterList *head, const char *attribute, char *value);\n```\n\n### signal (mutt)\n\n```c\nvoid                    mutt_sig_allow_interrupt          (bool allow);\nvoid                    mutt_sig_block                    (void);\nvoid                    mutt_sig_block_system             (void);\nvoid                    mutt_sig_empty_handler            (int sig);\nvoid                    mutt_sig_exit_handler             (int sig);\nvoid                    mutt_sig_init                     (sig_handler_t sig_fn, sig_handler_t exit_fn, sig_handler_t segv_fn);\nvoid                    mutt_sig_unblock                  (void);\nvoid                    mutt_sig_unblock_system           (bool restore);\n```\n\n### slist (mutt)\n\n```c\nstruct Slist *          slist_add_list                    (struct Slist *list, const struct Slist *add);\nstruct Slist *          slist_add_string                  (struct Slist *list, const char *str);\nbool                    slist_compare                     (const struct Slist *a, const struct Slist *b);\nstruct Slist *          slist_dup                         (const struct Slist *list);\nstruct Slist *          slist_empty                       (struct Slist **list);\nvoid                    slist_free                        (struct Slist **ptr);\nbool                    slist_is_empty                    (const struct Slist *list);\nbool                    slist_is_member                   (const struct Slist *list, const char *str);\nstruct Slist *          slist_new                         (uint32_t flags);\nstruct Slist *          slist_parse                       (const char *str, uint32_t flags);\nstruct Slist *          slist_remove_string               (struct Slist *list, const char *str);\nint                     slist_to_buffer                   (const struct Slist *list, struct Buffer *buf);\n```\n\n### state (mutt)\n\n```c\nvoid                    state_attach_puts                 (struct State *state, const char *t);\nconst char *            state_attachment_marker           (void);\nvoid                    state_mark_attach                 (struct State *state);\nvoid                    state_mark_protected_header       (struct State *state);\nvoid                    state_prefix_put                  (struct State *state, const char *buf, size_t buflen);\nvoid                    state_prefix_putc                 (struct State *state, char c);\nint                     state_printf                      (struct State *state, const char *fmt, ...);\nconst char *            state_protected_header_marker     (void);\nint                     state_putws                       (struct State *state, const wchar_t *ws);\n```\n\n### string (mutt)\n\n```c\nint                     mutt_istr_cmp                     (const char *a, const char *b);\nbool                    mutt_istr_equal                   (const char *a, const char *b);\nconst char *            mutt_istr_find                    (const char *haystack, const char *needle);\nint                     mutt_istr_remall                  (char *str, const char *target);\nsize_t                  mutt_istr_startswith              (const char *str, const char *prefix);\nint                     mutt_istrn_cmp                    (const char *a, const char *b, size_t num);\nbool                    mutt_istrn_equal                  (const char *a, const char *b, size_t num);\nconst char *            mutt_istrn_rfind                  (const char *haystack, size_t haystack_length, const char *needle);\nvoid                    mutt_str_adjust                   (char **ptr);\nvoid                    mutt_str_append_item              (char **str, const char *item, char sep);\nint                     mutt_str_asprintf                 (char **strp, const char *fmt, ...);\nchar *                  mutt_str_cat                      (char *buf, size_t buflen, const char *s);\nint                     mutt_str_cmp                      (const char *a, const char *b);\nint                     mutt_str_coll                     (const char *a, const char *b);\nsize_t                  mutt_str_copy                     (char *dest, const char *src, size_t dsize);\nvoid                    mutt_str_dequote_comment          (char *str);\nchar *                  mutt_str_dup                      (const char *str);\nbool                    mutt_str_equal                    (const char *a, const char *b);\nconst char *            mutt_str_find_word                (const char *src);\nconst char *            mutt_str_getenv                   (const char *name);\nbool                    mutt_str_inline_replace           (char *buf, size_t buflen, size_t xlen, const char *rstr);\nbool                    mutt_str_is_ascii                 (const char *str, size_t len);\nsize_t                  mutt_str_len                      (const char *a);\nchar *                  mutt_str_lower                    (char *str);\nsize_t                  mutt_str_lws_len                  (const char *s, size_t n);\nsize_t                  mutt_str_lws_rlen                 (const char *s, size_t n);\nconst char *            mutt_str_next_word                (const char *s);\nvoid                    mutt_str_remove_trailing_ws       (char *s);\nchar *                  mutt_str_replace                  (char **p, const char *s);\nchar *                  mutt_str_sep                      (char **stringp, const char *delim);\nchar *                  mutt_str_skip_email_wsp           (const char *s);\nchar *                  mutt_str_skip_whitespace          (const char *p);\nsize_t                  mutt_str_startswith               (const char *str, const char *prefix);\nconst char *            mutt_str_sysexit                  (int err_num);\nchar *                  mutt_str_upper                    (char *str);\nchar *                  mutt_strn_cat                     (char *d, size_t l, const char *s, size_t sl);\nchar *                  mutt_strn_copy                    (char *dest, const char *src, size_t len, size_t dsize);\nchar *                  mutt_strn_dup                     (const char *begin, size_t len);\nbool                    mutt_strn_equal                   (const char *a, const char *b, size_t num);\nconst char *            mutt_strn_rfind                   (const char *haystack, size_t haystack_length, const char *needle);\n```\n\n### tags (email)\n\n```c\nstruct HashTable *TagFormats;\nstruct HashTable *TagTransforms;\n\nvoid                    driver_tags_add                   (struct TagList *list, char *new_tag);\nvoid                    driver_tags_cleanup               (void);\nvoid                    driver_tags_free                  (struct TagList *list);\nchar *                  driver_tags_get                   (struct TagList *list);\nchar *                  driver_tags_get_transformed       (struct TagList *list);\nchar *                  driver_tags_get_transformed_for   (struct TagList *head, const char *name);\nchar *                  driver_tags_get_with_hidden       (struct TagList *list);\nvoid                    driver_tags_init                  (void);\nbool                    driver_tags_replace               (struct TagList *head, const char *tags);\n```\n\n### thread (email)\n\n```c\nvoid                    clean_references                  (struct MuttThread *brk, struct MuttThread *cur);\nstruct Email *          find_virtual                      (struct MuttThread *cur, bool reverse);\nvoid                    insert_message                    (struct MuttThread **add, struct MuttThread *parent, struct MuttThread *cur);\nbool                    is_descendant                     (const struct MuttThread *a, const struct MuttThread *b);\nvoid                    mutt_break_thread                 (struct Email *e);\nvoid                    unlink_message                    (struct MuttThread **old, struct MuttThread *cur);\n```\n\n### tmp (core)\n\n```c\nvoid                    buf_mktemp_full                   (struct Buffer *buf, const char *prefix, const char *suffix, const char *src, int line);\nFILE *                  mutt_file_mkstemp_full            (const char *file, int line, const char *func);\n```\n\n### url (email)\n\n```c\nenum UrlScheme          url_check_scheme                  (const char *str);\nvoid                    url_free                          (struct Url **ptr);\nstruct Url *            url_parse                         (const char *src);\nint                     url_pct_decode                    (char *s);\nvoid                    url_pct_encode                    (char *buf, size_t buflen, const char *src);\nint                     url_tobuffer                      (struct Url *url, struct Buffer *buf, uint8_t flags);\nint                     url_tostring                      (struct Url *url, char *dest, size_t len, uint8_t flags);\n```\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fneomutt%2Ftest-library","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fneomutt%2Ftest-library","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fneomutt%2Ftest-library/lists"}