entries[i].num = i + 1;
/* note: we are transfering the account pointer to the entries
* array, and freeing the accounts array below. the account
- * will be freed in free_menu(). */
+ * will be freed in menu_free(). */
entries[i].account = accounts[i];
entries[i].addr = mutt_addr_new();
}
/**
- * free_menu - Free the Autocrypt account Menu
+ * menu_free - Free the Autocrypt account Menu
* @param menu Menu to free
*/
-static void free_menu(struct Menu **menu)
+static void menu_free(struct Menu **menu)
{
struct AccountEntry *entries = (struct AccountEntry *) (*menu)->data;
case OP_AUTOCRYPT_CREATE_ACCT:
if (!mutt_autocrypt_account_init(false))
{
- free_menu(&menu);
+ menu_free(&menu);
menu = create_menu();
}
break;
if (!mutt_autocrypt_db_account_delete(entry->account))
{
- free_menu(&menu);
+ menu_free(&menu);
menu = create_menu();
}
}
}
}
- free_menu(&menu);
+ menu_free(&menu);
}
#ifdef HAVE_COLOR
if (free_colors && (cl->fg != COLOR_UNSET) && (cl->bg != COLOR_UNSET))
- mutt_free_color(cl->fg, cl->bg);
+ mutt_color_free(cl->fg, cl->bg);
#endif
regfree(&cl->regex);
}
/**
- * mutt_free_color - Free a colour
+ * mutt_color_free - Free a colour
* @param fg Foreground colour ID
* @param bg Background colour ID
*
* If there are no more users, the resource will be freed.
*/
-void mutt_free_color(uint32_t fg, uint32_t bg)
+void mutt_color_free(uint32_t fg, uint32_t bg)
{
struct ColorList *q = NULL;
{
if ((tmp->fg != fg) || (tmp->bg != bg))
{
- mutt_free_color(tmp->fg, tmp->bg);
+ mutt_color_free(tmp->fg, tmp->bg);
tmp->fg = fg;
tmp->bg = bg;
attr |= mutt_alloc_color(fg, bg);
}
/**
- * mutt_free_color_list - Free a list of colours
+ * mutt_color_list_free - Free a list of colours
* @param list ColorLine List
*/
-static void mutt_free_color_list(struct ColorLineList *list)
+static void mutt_color_list_free(struct ColorLineList *list)
{
struct ColorLine *np = NULL, *tmp = NULL;
STAILQ_FOREACH_SAFE(np, list, entries, tmp)
}
/**
- * mutt_free_colors - Free all the colours (on shutdown)
+ * mutt_colors_free - Free all the colours (on shutdown)
*/
-void mutt_free_colors(void)
+void mutt_colors_free(void)
{
- mutt_free_color_list(&ColorAttachList);
- mutt_free_color_list(&ColorBodyList);
- mutt_free_color_list(&ColorHdrList);
- mutt_free_color_list(&ColorIndexAuthorList);
- mutt_free_color_list(&ColorIndexFlagsList);
- mutt_free_color_list(&ColorIndexList);
- mutt_free_color_list(&ColorIndexSubjectList);
- mutt_free_color_list(&ColorIndexTagList);
- mutt_free_color_list(&ColorStatusList);
+ mutt_color_list_free(&ColorAttachList);
+ mutt_color_list_free(&ColorBodyList);
+ mutt_color_list_free(&ColorHdrList);
+ mutt_color_list_free(&ColorIndexAuthorList);
+ mutt_color_list_free(&ColorIndexFlagsList);
+ mutt_color_list_free(&ColorIndexList);
+ mutt_color_list_free(&ColorIndexSubjectList);
+ mutt_color_list_free(&ColorIndexTagList);
+ mutt_color_list_free(&ColorStatusList);
struct ColorList *cl = ColorList;
struct ColorList *next = NULL;
void ci_start_color(void);
int mutt_alloc_color(uint32_t fg, uint32_t bg);
int mutt_combine_color(uint32_t fg_attr, uint32_t bg_attr);
-void mutt_free_color(uint32_t fg, uint32_t bg);
-void mutt_free_colors(void);
+void mutt_color_free(uint32_t fg, uint32_t bg);
+void mutt_colors_free(void);
enum CommandResult mutt_parse_color(struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err);
enum CommandResult mutt_parse_mono(struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err);
enum CommandResult mutt_parse_uncolor(struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err);
/* attachments may have been added */
if (actx->idxlen && actx->idx[actx->idxlen - 1]->content->next)
{
- mutt_actx_free_entries(actx);
+ mutt_actx_entries_free(actx);
mutt_update_compose_menu(actx, menu, true);
}
}
/**
- * free_compress_info - Frees the compress info members and structure
+ * compress_info_free - Frees the compress info members and structure
* @param m Mailbox to free compress_info for
*/
-static void free_compress_info(struct Mailbox *m)
+static void compress_info_free(struct Mailbox *m)
{
if (!m || !m->compress_info)
return;
cmo_fail:
/* remove the partial uncompressed file */
remove(mailbox_path(m));
- free_compress_info(m);
+ compress_info_free(m);
return -1;
}
remove(mailbox_path(m));
cmoa_fail1:
/* Free the compress_info to prevent close from trying to recompress */
- free_compress_info(m);
+ compress_info_free(m);
return -1;
}
const struct MxOps *ops = ci->child_ops;
if (!ops)
{
- free_compress_info(m);
+ compress_info_free(m);
return -1;
}
}
}
- free_compress_info(m);
+ compress_info_free(m);
return 0;
}
}
/**
- * mutt_actx_free_entries - Free entries in an Attachment Context
+ * mutt_actx_entries_free - Free entries in an Attachment Context
* @param actx Attachment context
*/
-void mutt_actx_free_entries(struct AttachCtx *actx)
+void mutt_actx_entries_free(struct AttachCtx *actx)
{
if (!actx)
return;
struct AttachCtx *actx = *ptr;
- mutt_actx_free_entries(actx);
+ mutt_actx_entries_free(actx);
FREE(&actx->idx);
FREE(&actx->v2r);
FREE(&actx->fp_idx);
void mutt_actx_add_body (struct AttachCtx *actx, struct Body *new_body);
void mutt_actx_add_fp (struct AttachCtx *actx, FILE *fp_new);
void mutt_actx_free (struct AttachCtx **ptr);
-void mutt_actx_free_entries(struct AttachCtx *actx);
+void mutt_actx_entries_free(struct AttachCtx *actx);
struct AttachCtx *mutt_actx_new (void);
#endif /* MUTT_EMAIL_ATTACH_H */
}
/**
- * free_parameter - Free an Rfc2231Parameter
+ * parameter_free - Free an Rfc2231Parameter
* @param[out] p Rfc2231Parameter to free
*/
-static void free_parameter(struct Rfc2231Parameter **p)
+static void parameter_free(struct Rfc2231Parameter **p)
{
if (!p || !*p)
return;
l += vl;
struct Rfc2231Parameter *q = par->next;
- free_parameter(&par);
+ parameter_free(&par);
par = q;
if (par)
valp = par->value;
/**
* mutt_attachmatch_free - Free an AttachMatch - Implements ::list_free_t
+ * @param ptr AttachMatch to free
*
* @note We don't free minor because it is either a pointer into major,
* or a static string.
*/
-void mutt_attachmatch_free(struct AttachMatch **am)
+void mutt_attachmatch_free(struct AttachMatch **ptr)
{
- if (!am || !*am)
+ if (!ptr || !*ptr)
return;
- regfree(&(*am)->minor_regex);
- FREE(&(*am)->major);
- FREE(am);
+ struct AttachMatch *am = *ptr;
+ regfree(&am->minor_regex);
+ FREE(&am->major);
+ FREE(ptr);
}
/**
}
/**
- * mutt_free_opts - clean up before quitting
+ * mutt_opts_free - clean up before quitting
*/
-void mutt_free_opts(void)
+void mutt_opts_free(void)
{
mutt_list_free(&MuttrcStack);
mutt_list_free_type(&InlineAllow, (list_free_t) mutt_attachmatch_free);
mutt_list_free_type(&InlineExclude, (list_free_t) mutt_attachmatch_free);
- mutt_free_colors();
+ mutt_colors_free();
FREE(&CurrentFolder);
FREE(&HomeDir);
mutt_delete_hooks(MUTT_HOOK_NO_FLAGS);
mutt_hist_free();
- mutt_free_keys();
+ mutt_keys_free();
mutt_regexlist_free(&NoSpamList);
}
}
/**
- * mutt_free_keys - Free the key maps
+ * mutt_keys_free - Free the key maps
*/
-void mutt_free_keys(void)
+void mutt_keys_free(void)
{
struct Keymap *map = NULL;
struct Keymap *next = NULL;
extern const struct Binding OpAutocryptAcct[];
#endif
-void mutt_free_keys(void);
+void mutt_keys_free(void);
enum CommandResult mutt_parse_bind(struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err);
enum CommandResult mutt_parse_exec(struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err);
int mh_read_dir (struct Mailbox *m, const char *subdir);
int mh_read_sequences (struct MhSequences *mhs, const char *path);
MhSeqFlags mhs_check (struct MhSequences *mhs, int i);
-void mhs_free_sequences (struct MhSequences *mhs);
+void mhs_sequences_free (struct MhSequences *mhs);
MhSeqFlags mhs_set (struct MhSequences *mhs, int i, MhSeqFlags f);
mode_t mh_umask (struct Mailbox *m);
void mh_update_maildir (struct Maildir *md, struct MhSequences *mhs);
}
/**
- * mhs_free_sequences - Free some sequences
+ * mhs_sequences_free - Free some sequences
* @param mhs Sequences to free
*/
-void mhs_free_sequences(struct MhSequences *mhs)
+void mhs_sequences_free(struct MhSequences *mhs)
{
FREE(&mhs->flags);
}
if (replied)
mhs_write_one_sequence(fp_new, &mhs, MH_SEQ_REPLIED, NONULL(C_MhSeqReplied));
- mhs_free_sequences(&mhs);
+ mhs_sequences_free(&mhs);
/* try to commit the changes - no guarantee here */
mutt_file_fclose(&fp_new);
{
if (mh_read_token(t, &first, &last) < 0)
{
- mhs_free_sequences(mhs);
+ mhs_sequences_free(mhs);
rc = -1;
goto out;
}
}
}
- mhs_free_sequences(&mhs);
+ mhs_sequences_free(&mhs);
dirp = opendir(mailbox_path(m));
if (dirp)
if (mh_read_sequences(&mhs, mailbox_path(m)) < 0)
return -1;
mh_update_maildir(md, &mhs);
- mhs_free_sequences(&mhs);
+ mhs_sequences_free(&mhs);
/* check for modifications and adjust flags */
fnames = mutt_hash_new(count, MUTT_HASH_NO_FLAGS);
}
/**
- * maildir_free_entry - Free a Maildir object
- * @param[out] md Maildir to free
+ * maildir_entry_new - Create a new Maildir entry
+ * @retval ptr New Maildir entry
*/
-static void maildir_free_entry(struct Maildir **md)
+static struct Maildir *maildir_entry_new(void)
{
- if (!md || !*md)
+ return mutt_mem_calloc(1, sizeof(struct Maildir));
+}
+
+/**
+ * maildir_entry_free - Free a Maildir object
+ * @param[out] ptr Maildir to free
+ */
+static void maildir_entry_free(struct Maildir **ptr)
+{
+ if (!ptr || !*ptr)
return;
- FREE(&(*md)->canon_fname);
- if ((*md)->email)
- email_free(&(*md)->email);
+ struct Maildir *md = *ptr;
+ FREE(&md->canon_fname);
+ email_free(&md->email);
- FREE(md);
+ FREE(ptr);
}
/**
- * maildir_free_maildir - Free a Maildir list
+ * maildir_free - Free a Maildir list
* @param[out] md Maildir list to free
*/
-static void maildir_free_maildir(struct Maildir **md)
+static void maildir_free(struct Maildir **md)
{
if (!md || !*md)
return;
for (p = *md; p; p = q)
{
q = p->next;
- maildir_free_entry(&p);
+ maildir_entry_free(&p);
}
}
else
e->path = mutt_str_strdup(de->d_name);
- entry = mutt_mem_calloc(1, sizeof(struct Maildir));
+ entry = maildir_entry_new();
entry->email = e;
entry->inode = de->d_ino;
**last = entry;
if (m->msg_count > oldmsgcount)
num = m->msg_count - oldmsgcount;
- maildir_free_maildir(ptr);
+ maildir_free(ptr);
return num;
}
{
if (mh_read_sequences(&mhs, mailbox_path(m)) < 0)
{
- maildir_free_maildir(&md);
+ maildir_free(&md);
return -1;
}
mh_update_maildir(md, &mhs);
- mhs_free_sequences(&mhs);
+ mhs_sequences_free(&mhs);
}
maildir_move_to_mailbox(m, &md);
mutt_buffer_pool_free();
mutt_envlist_free();
mutt_browser_cleanup();
- mutt_free_opts();
- mutt_free_keys();
+ mutt_opts_free();
+ mutt_keys_free();
neomutt_free(&NeoMutt);
cs_free(&Config);
return rc;
char *mutt_compile_help(char *buf, size_t buflen, enum MenuType menu, const struct Mapping *items);
int mutt_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags);
-void mutt_free_opts(void);
+void mutt_opts_free(void);
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt);
int mutt_label_complete(char *buf, size_t buflen, int numtabs);
int mutt_command_complete(char *buf, size_t buflen, int pos, int numtabs);
static struct LookupList Lookups = TAILQ_HEAD_INITIALIZER(Lookups);
+/**
+ * lookup_new - Create a new Lookup
+ * @retval ptr New Lookup
+ */
+struct Lookup *lookup_new(void)
+{
+ return mutt_mem_calloc(1, sizeof(struct Lookup));
+}
+
+/**
+ * lookup_free - Free a Lookup
+ * @param ptr Lookup to free
+ */
+void lookup_free(struct Lookup **ptr)
+{
+ if (!ptr || !*ptr)
+ return;
+
+ struct Lookup *l = *ptr;
+ FREE(&l->replacement);
+ FREE(&l->regex.pattern);
+ if (l->regex.regex)
+ regfree(l->regex.regex);
+ FREE(&l->regex.regex);
+ FREE(&l->regex);
+
+ FREE(ptr);
+}
+
// clang-format off
/**
* PreferredMimeNames - Lookup table of preferred charsets
return false;
}
- struct Lookup *l = mutt_mem_calloc(1, sizeof(struct Lookup));
+ struct Lookup *l = lookup_new();
l->type = type;
l->replacement = mutt_str_strdup(replace);
l->regex.pattern = mutt_str_strdup(pat);
TAILQ_FOREACH_SAFE(l, &Lookups, entries, tmp)
{
TAILQ_REMOVE(&Lookups, l, entries);
- FREE(&l->replacement);
- FREE(&l->regex.pattern);
- if (l->regex.regex)
- regfree(l->regex.regex);
- FREE(&l->regex.regex);
- FREE(&l->regex);
- FREE(&l);
+ lookup_free(&l);
}
}
struct MyVarList MyVars = TAILQ_HEAD_INITIALIZER(MyVars);
+/**
+ * myvar_new - Create a new MyVar
+ * @param name Variable name
+ * @param value Variable value
+ * @retval ptr New MyVar
+ *
+ * @note The name and value will be copied.
+ */
+static struct MyVar *myvar_new(const char *name, const char *value)
+{
+ struct MyVar *myv = mutt_mem_calloc(1, sizeof(struct MyVar));
+ myv->name = mutt_str_strdup(name);
+ myv->value = mutt_str_strdup(value);
+ return myv;
+}
+
+/**
+ * myvar_free - Free a MyVar
+ * @param ptr MyVar to free
+ */
+void myvar_free(struct MyVar **ptr)
+{
+ if (!ptr || !*ptr)
+ return;
+
+ struct MyVar *myv = *ptr;
+ FREE(&myv->name);
+ FREE(&myv->value);
+ FREE(ptr);
+}
+
/**
* myvar_get - Get the value of a "my_" variable
* @param var Variable name
}
}
- myv = mutt_mem_calloc(1, sizeof(struct MyVar));
- myv->name = mutt_str_strdup(var);
- myv->value = mutt_str_strdup(val);
+ myv = myvar_new(var, val);
TAILQ_INSERT_TAIL(&MyVars, myv, entries);
}
if (mutt_str_strcmp(myv->name, var) == 0)
{
TAILQ_REMOVE(&MyVars, myv, entries);
- FREE(&myv->name);
- FREE(&myv->value);
- FREE(&myv);
+ myvar_free(&myv);
return;
}
}
}
/**
- * crypt_free_key - Release all the keys in a list
+ * crypt_key_free - Release all the keys in a list
* @param[out] keylist List of keys
*/
-static void crypt_free_key(struct CryptKeyInfo **keylist)
+static void crypt_key_free(struct CryptKeyInfo **keylist)
{
if (!keylist)
return;
#else
/**
- * free_recipient_set - Free a set of recipients
+ * recipient_set_free - Free a set of recipients
* @param p_rset Set of GPGME keys
*/
-static void free_recipient_set(gpgme_key_t **p_rset)
+static void recipient_set_free(gpgme_key_t **p_rset)
{
gpgme_key_t *rset = NULL;
{
mutt_error(_("error adding recipient '%s': %s"), buf, gpgme_strerror(err));
rset[rset_n] = NULL;
- free_recipient_set(&rset);
+ recipient_set_free(&rset);
gpgme_release(context);
return NULL;
}
#if (GPGME_VERSION_NUMBER >= 0x010b00) /* gpgme >= 1.11.0 */
mutt_buffer_pool_release(&recpstring);
#else
- free_recipient_set(&rset);
+ recipient_set_free(&rset);
#endif
gpgme_release(ctx);
gpgme_data_release(ciphertext);
}
}
- crypt_free_key(&keys);
+ crypt_key_free(&keys);
if (matches)
{
k = crypt_select_key(matches, a, NULL, app, forced_valid);
}
- crypt_free_key(&matches);
+ crypt_key_free(&matches);
}
else
k = NULL;
}
FREE(&pfcopy);
- crypt_free_key(&keys);
+ crypt_key_free(&keys);
if (matches)
{
k = crypt_select_key(matches, NULL, p, app, forced_valid);
- crypt_free_key(&matches);
+ crypt_key_free(&matches);
return k;
}
key_selected = true;
- crypt_free_key(&k_info);
+ crypt_key_free(&k_info);
mutt_addrlist_clear(&hookal);
if (crypt_hook)
rc = 0;
cleanup:
- crypt_free_key(&choice);
- crypt_free_key(&results);
+ crypt_key_free(&choice);
+ crypt_key_free(&results);
gpgme_release(ctx);
return rc;
}
att->length = sb.st_size;
bail:
- crypt_free_key(&key);
+ crypt_key_free(&key);
gpgme_data_release(keydata);
gpgme_release(context);
char input_signas[128];
snprintf(input_signas, sizeof(input_signas), "0x%s", crypt_fpr_or_lkeyid(p));
mutt_str_replace(is_smime ? &C_SmimeDefaultKey : &C_PgpSignAs, input_signas);
- crypt_free_key(&p);
+ crypt_key_free(&p);
e->security |= SEC_SIGN;
}
key_selected = true;
- pgp_free_key(&k_info);
+ pgp_key_free(&k_info);
mutt_addrlist_clear(&hookal);
if (crypt_hook)
char input_signas[128];
snprintf(input_signas, sizeof(input_signas), "0x%s", pgp_fpr_or_lkeyid(p));
mutt_str_replace(&C_PgpSignAs, input_signas);
- pgp_free_key(&p);
+ pgp_key_free(&p);
e->security |= SEC_SIGN;
return NULL;
snprintf(tmp, sizeof(tmp), "0x%s", pgp_fpr_or_lkeyid(pgp_principal_key(key)));
- pgp_free_key(&key);
+ pgp_key_free(&key);
mutt_mktemp(tempf, sizeof(tempf));
}
}
- pgp_free_key(&keys);
+ pgp_key_free(&keys);
if (matches)
{
pgp_remove_key(&matches, k);
}
- pgp_free_key(&matches);
+ pgp_key_free(&matches);
return k;
}
}
}
- pgp_free_key(&keys);
+ pgp_key_free(&keys);
if (matches)
{
k = pgp_select_key(matches, NULL, p);
if (k)
pgp_remove_key(&matches, k);
- pgp_free_key(&matches);
+ pgp_key_free(&matches);
}
else
{
}
/**
- * pgp_free_uid - Free a PGP UID
+ * pgp_uid_free - Free a PGP UID
* @param[out] upp PGP UID to free
*/
-static void pgp_free_uid(struct PgpUid **upp)
+static void pgp_uid_free(struct PgpUid **upp)
{
struct PgpUid *up = NULL, *q = NULL;
}
/**
- * free_key - Free a PGP Key info
+ * key_free - Free a PGP Key info
* @param[out] kpp PGP Key info to free
*/
-static void free_key(struct PgpKeyInfo **kpp)
+static void key_free(struct PgpKeyInfo **kpp)
{
if (!kpp || !*kpp)
return;
struct PgpKeyInfo *kp = *kpp;
- pgp_free_uid(&kp->address);
+ pgp_uid_free(&kp->address);
FREE(&kp->keyid);
FREE(&kp->fingerprint);
FREE(kpp);
}
/**
- * pgp_free_key - Free a PGP key info
+ * pgp_key_free - Free a PGP key info
* @param[out] kpp PGP key info to free
*/
-void pgp_free_key(struct PgpKeyInfo **kpp)
+void pgp_key_free(struct PgpKeyInfo **kpp)
{
if (!kpp || !*kpp)
return;
for (q = p->next; q && q->parent == p; q = r)
{
r = q->next;
- free_key(&q);
+ key_free(&q);
}
- free_key(&p->parent);
- free_key(&p);
+ key_free(&p->parent);
+ key_free(&p);
}
*kpp = NULL;
bool pgp_cansign(unsigned char type);
short pgp_get_abilities(unsigned char type);
-void pgp_free_key(struct PgpKeyInfo **kpp);
+void pgp_key_free(struct PgpKeyInfo **kpp);
struct PgpKeyInfo *pgp_remove_key(struct PgpKeyInfo **klist, struct PgpKeyInfo *key);
static char fp_smime_intermediateToUse[PATH_MAX];
/**
- * smime_free_key - Free a list of SMIME keys
+ * smime_key_free - Free a list of SMIME keys
* @param[out] keylist List of keys to free
*/
-static void smime_free_key(struct SmimeKey **keylist)
+static void smime_key_free(struct SmimeKey **keylist)
{
if (!keylist)
return;
* but anything less than that is an error. */
if (field < 3)
{
- smime_free_key(&key);
+ smime_key_free(&key);
return NULL;
}
}
}
- smime_free_key(&results);
+ smime_key_free(&results);
return match;
}
}
}
- smime_free_key(&results);
+ smime_key_free(&results);
if (matches)
{
return_key = smime_copy_key(smime_select_key(matches, mailbox));
}
- smime_free_key(&matches);
+ smime_key_free(&matches);
}
return return_key;
}
}
- smime_free_key(&results);
+ smime_key_free(&results);
if (matches)
{
return_key = smime_copy_key(smime_select_key(matches, str));
- smime_free_key(&matches);
+ smime_key_free(&matches);
}
return return_key;
if (*SmimeKeyToUse &&
(mutt_str_strcasecmp(k, SmimeKeyToUse + mutt_str_strlen(C_SmimeKeys) + 1) == 0))
{
- smime_free_key(&key);
+ smime_key_free(&key);
return;
}
else
if (mutt_str_strcasecmp(k, C_SmimeDefaultKey) != 0)
smime_class_void_passphrase();
- smime_free_key(&key);
+ smime_key_free(&key);
return;
}
sprintf(keylist + keylist_used, "%s%s", keylist_used ? " " : "", keyid);
keylist_used = mutt_str_strlen(keylist);
- smime_free_key(&key);
+ smime_key_free(&key);
}
return keylist;
}
snprintf(fp_smime_intermediateToUse, sizeof(fp_smime_intermediateToUse),
"%s/%s", NONULL(C_SmimeCertificates), intermediates);
- smime_free_key(&signas_key);
+ smime_key_free(&signas_key);
pid = smime_invoke_sign(&fp_smime_in, NULL, &fp_smime_err, -1,
fileno(fp_smime_out), -1, filetosign);
if (key)
{
mutt_str_replace(&C_SmimeSignAs, key->hash);
- smime_free_key(&key);
+ smime_key_free(&key);
e->security |= SEC_SIGN;
{
#ifdef HAVE_COLOR
if (a->pair != -1)
- mutt_free_color(a->fg, a->bg);
+ mutt_color_free(a->fg, a->bg);
#endif
a->attr = ANSI_OFF;
a->pair = -1;
{
#ifdef HAVE_COLOR
if (a->pair != -1)
- mutt_free_color(a->fg, a->bg);
+ mutt_color_free(a->fg, a->bg);
#endif
a->attr = ANSI_OFF;
a->pair = -1;
{
#ifdef HAVE_COLOR
if (a->pair != -1)
- mutt_free_color(a->fg, a->bg);
+ mutt_color_free(a->fg, a->bg);
#endif
a->pair = -1;
a->attr |= ANSI_COLOR;
{
#ifdef HAVE_COLOR
if (a->pair != -1)
- mutt_free_color(a->fg, a->bg);
+ mutt_color_free(a->fg, a->bg);
#endif
a->pair = -1;
a->attr |= ANSI_COLOR;
/* Editing the content type can rewrite the body structure. */
for (int i = 0; i < actx->idxlen; i++)
actx->idx[i]->content = NULL;
- mutt_actx_free_entries(actx);
+ mutt_actx_entries_free(actx);
mutt_update_recvattach_menu(actx, menu, true);
}
}
/**
- * mix_free_type2_list - Free a Remailer List
+ * mix_type2_list_free - Free a Remailer List
* @param[out] ttlp Remailer List to free
*/
-static void mix_free_type2_list(struct Remailer ***ttlp)
+static void mix_type2_list_free(struct Remailer ***ttlp)
{
struct Remailer **type2_list = *ttlp;
}
}
- mix_free_type2_list(&type2_list);
+ mix_type2_list_free(&type2_list);
FREE(&coords);
FREE(&chain);
}
test/address/mutt_addrlist_write.o
ATTACH_OBJS = test/attach/mutt_actx_add_fp.o \
- test/attach/mutt_actx_free_entries.o \
+ test/attach/mutt_actx_entries_free.o \
test/attach/mutt_actx_free.o \
test/attach/mutt_actx_add_body.o \
test/attach/mutt_actx_add_attach.o
/**
* @file
- * Test code for mutt_actx_free_entries()
+ * Test code for mutt_actx_entries_free()
*
* @authors
* Copyright (C) 2019 Richard Russon <rich@flatcap.org>
#include "address/lib.h"
#include "email/lib.h"
-void test_mutt_actx_free_entries(void)
+void test_mutt_actx_entries_free(void)
{
- // void mutt_actx_free_entries(struct AttachCtx *actx);
+ // void mutt_actx_entries_free(struct AttachCtx *actx);
{
- mutt_actx_free_entries(NULL);
- TEST_CHECK_(1, "mutt_actx_free_entries(NULL)");
+ mutt_actx_entries_free(NULL);
+ TEST_CHECK_(1, "mutt_actx_entries_free(NULL)");
}
}
NEOMUTT_TEST_ITEM(test_mutt_actx_add_body) \
NEOMUTT_TEST_ITEM(test_mutt_actx_add_fp) \
NEOMUTT_TEST_ITEM(test_mutt_actx_free) \
- NEOMUTT_TEST_ITEM(test_mutt_actx_free_entries) \
+ NEOMUTT_TEST_ITEM(test_mutt_actx_entries_free) \
NEOMUTT_TEST_ITEM(test_mutt_b64_buffer_decode) \
NEOMUTT_TEST_ITEM(test_mutt_b64_buffer_encode) \
NEOMUTT_TEST_ITEM(test_mutt_b64_decode) \
projects / neomutt / commitdiff