#include <lib-lib/macros.h>
#include <lib-lib/buffer.h>
#include <lib-lib/mapping.h>
+#include <lib-lib/debug.h>
+#include <lib-lib/rx.h>
+
+#include <lib-sys/unix.h>
#include <lib-ui/curses.h>
+#include <lib-ui/history.h>
#include "mutt.h"
-#include "history.h"
#include "keymap.h"
#include "mbyte.h"
#include "charset.h"
#include "mutt_idna.h"
#if defined(USE_SSL) || defined(USE_GNUTLS)
-#include "mutt_ssl.h"
+#include <lib-sys/mutt_ssl.h>
#endif
#if defined (USE_LIBESMTP) && (defined (USE_SSL) || defined (USE_GNUTLS))
#include "mx.h"
#include "init.h"
-#include "lib/rx.h"
#include "lib/list.h"
-#include "lib/debug.h"
#include <ctype.h>
#include <stdlib.h>
char* errbuf __attribute__ ((unused)), size_t errlen __attribute__ ((unused))) {
if (!dst)
return (0);
- address_delete ((address_t**) dst->data);
+ address_list_wipe((address_t**) dst->data);
if (val && *val)
*((address_t**) dst->data) = rfc822_parse_adrlist (NULL, val);
return (1);
/* not reached */
}
-static void add_to_list (LIST ** list, const char *str)
+static void add_to_list (string_list_t ** list, const char *str)
{
- LIST *t, *last = NULL;
+ string_list_t *t, *last = NULL;
/* don't add a NULL or empty string to the list */
if (!str || *str == '\0')
}
if (!*list || last) {
- t = p_new(LIST, 1);
+ t = p_new(string_list_t, 1);
t->data = m_strdup(str);
if (last) {
last->next = t;
i = rx_lookup ((*list), rx->pattern);
if (i >= 0)
- rx_free (&rx);
+ rx_delete(&rx);
else
list_push_back (list, rx);
return 0;
return 0;
if (spam->rx && !m_strcmp(spam->rx->pattern, pat)) {
*list = spam->next;
- rx_free (&spam->rx);
+ rx_delete(&spam->rx);
p_delete(&spam->template);
p_delete(&spam);
return 1;
for (spam = prev->next; spam;) {
if (!m_strcmp(spam->rx->pattern, pat)) {
prev->next = spam->next;
- rx_free (&spam->rx);
+ rx_delete(&spam->rx);
p_delete(&spam->template);
p_delete(&spam);
spam = prev->next;
}
-static void remove_from_list (LIST ** l, const char *str)
+static void remove_from_list (string_list_t ** l, const char *str)
{
- LIST *p, *last = NULL;
+ string_list_t *p, *last = NULL;
if (m_strcmp("*", str) == 0)
- mutt_free_list (l); /* ``unCMD *'' means delete all current entries */
+ string_list_wipe(l); /* ``unCMD *'' means delete all current entries */
else {
p = *l;
last = NULL;
int i = 0;
if (m_strcmp("*", str) == 0) {
- list_del (l, (list_del_t*) rx_free);
+ list_del (l, (list_del_t*) rx_delete);
return (0);
}
else {
i = rx_lookup ((*l), str);
if (i >= 0) {
rx_t* r = list_pop_idx ((*l), i);
- rx_free (&r);
+ rx_delete(&r);
return (0);
}
}
{
do {
mutt_extract_token (buf, s, 0);
- add_to_list ((LIST **) data, buf->data);
+ add_to_list ((string_list_t **) data, buf->data);
}
while (MoreArgs (s));
/* "*" is a special case. */
if (!m_strcmp(buf->data, "*")) {
mutt_free_spam_list (&SpamList);
- list_del (&NoSpamList, (list_del_t*) rx_free);
+ list_del (&NoSpamList, (list_del_t*) rx_delete);
return 0;
}
* Check for deletion of entire list
*/
if (m_strcmp(buf->data, "*") == 0) {
- mutt_free_list ((LIST **) data);
+ string_list_wipe((string_list_t **) data);
break;
}
- remove_from_list ((LIST **) data, buf->data);
+ remove_from_list ((string_list_t **) data, buf->data);
}
while (MoreArgs (s));
}
}
-static int parse_attach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
+static int parse_attach_list (BUFFER *buf, BUFFER *s, string_list_t **ldata,
BUFFER *err __attribute__ ((unused))) {
ATTACH_MATCH *a;
- LIST *listp, *lastp;
+ string_list_t *listp, *lastp;
char *p;
char *tmpminor;
int len;
debug_print (5, ("parse_attach_list: added %s/%s [%d]\n",
a->major, a->minor, a->major_int));
- listp = p_new(LIST, 1);
+ listp = p_new(string_list_t, 1);
listp->data = (char *)a;
listp->next = NULL;
if (lastp) {
return 0;
}
-static int parse_unattach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
+static int parse_unattach_list (BUFFER *buf, BUFFER *s, string_list_t **ldata,
BUFFER *err __attribute__ ((unused))) {
ATTACH_MATCH *a;
- LIST *lp, *lastp, *newlp;
+ string_list_t *lp, *lastp, *newlp;
char *tmp;
int major;
char *minor;
major = mutt_check_mime_type(tmp);
/* We must do our own walk here because remove_from_list() will only
- * remove the LIST->data, not anything pointed to by the LIST->data. */
+ * remove the string_list_t->data, not anything pointed to by the string_list_t->data. */
lastp = NULL;
for(lp = *ldata; lp; ) {
a = (ATTACH_MATCH *)lp->data;
return 0;
}
-static int print_attach_list (LIST *lp, char op, const char *name) {
+static int print_attach_list (string_list_t *lp, char op, const char *name) {
while (lp) {
printf("attachments %c%s %s/%s\n", op, name,
((ATTACH_MATCH *)lp->data)->major,
unsigned long data __attribute__ ((unused)),
BUFFER *err) {
char op, *category;
- LIST **listp;
+ string_list_t **listp;
mutt_extract_token(buf, s, 0);
if (!buf->data || *buf->data == '\0') {
static int parse_unattachments (BUFFER *buf, BUFFER *s, unsigned long data __attribute__ ((unused)), BUFFER *err) {
char op, *p;
- LIST **listp;
+ string_list_t **listp;
mutt_extract_token(buf, s, 0);
if (!buf->data || *buf->data == '\0') {
unsigned long data __attribute__ ((unused)),
BUFFER * err __attribute__ ((unused)))
{
- ALIAS *tmp, *last = NULL;
+ alias_t *tmp, *last = NULL;
do {
mutt_extract_token (buf, s, 0);
set_option (OPTFORCEREDRAWINDEX);
}
else
- mutt_free_alias (&Aliases);
+ alias_list_wipe(&Aliases);
break;
}
else
else
Aliases = tmp->next;
tmp->next = NULL;
- mutt_free_alias (&tmp);
+ alias_list_wipe(&tmp);
break;
}
last = tmp;
unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
- ALIAS *tmp = Aliases;
- ALIAS *last = NULL;
+ alias_t *tmp = Aliases;
+ alias_t *last = NULL;
char *estr = NULL;
if (!MoreArgs (s)) {
if (!tmp) {
/* create a new alias */
- tmp = p_new(ALIAS, 1);
- tmp->self = tmp;
+ tmp = alias_new();
tmp->name = m_strdup(buf->data);
/* give the main addressbook code a chance */
if (CurrentMenu == MENU_ALIAS)
}
else {
/* override the previous value */
- address_delete (&tmp->addr);
+ address_list_wipe(&tmp->addr);
if (CurrentMenu == MENU_ALIAS)
set_option (OPTFORCEREDRAWINDEX);
}
unsigned long data __attribute__ ((unused)),
BUFFER * err __attribute__ ((unused)))
{
- LIST *last = NULL;
- LIST *tmp = UserHeader;
- LIST *ptr;
+ string_list_t *last = NULL;
+ string_list_t *tmp = UserHeader;
+ string_list_t *ptr;
size_t l;
do {
mutt_extract_token (buf, s, 0);
if (m_strcmp("*", buf->data) == 0)
- mutt_free_list (&UserHeader);
+ string_list_wipe(&UserHeader);
else {
tmp = UserHeader;
last = NULL;
UserHeader = tmp->next;
tmp = tmp->next;
ptr->next = NULL;
- mutt_free_list (&ptr);
+ string_list_wipe(&ptr);
}
else {
last = tmp;
static int parse_my_hdr (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
- LIST *tmp;
+ string_list_t *tmp;
size_t keylen;
char *p;
if (!tmp->next)
break;
}
- tmp->next = mutt_new_list ();
+ tmp->next = string_item_new();
tmp = tmp->next;
}
else {
- tmp = mutt_new_list ();
+ tmp = string_item_new();
UserHeader = tmp;
}
tmp->data = buf->data;
r = -1;
break;
} else if (DTYPE (option->type) == DT_ADDR)
- address_delete ((address_t **) option->data);
+ address_list_wipe((address_t **) option->data);
else if (DTYPE (option->type) == DT_USER)
/* to unset $user_ means remove */
hash_delete (ConfigOptions, option->option,
int Num_matched = 0; /* Number of matches for completion */
char Completed[STRING] = { 0 }; /* completed string (command or variable) */
-const char *Matches[MAX (NUMVARS, NUMCOMMANDS) + 1]; /* all the matches + User_typed */
+char *Matches[MAX (NUMVARS, NUMCOMMANDS) + 1]; /* all the matches + User_typed */
/* helper function for completion. Changes the dest buffer if
necessary/possible to aid completion.
if (numtabs == 1) {
Num_matched = 0;
m_strcpy(User_typed, sizeof(User_typed), pt);
- p_clear(Matches, sizeof(Matches));
- p_clear(Completed, sizeof(Completed));
+ p_clear(Matches, countof(Matches));
+ p_clear(Completed, countof(Completed));
for (num = 0; Commands[num].name; num++)
candidate (Completed, User_typed, Commands[num].name,
sizeof(Completed));
if (numtabs == 1) {
Num_matched = 0;
m_strcpy(User_typed, sizeof(User_typed), pt);
- p_clear(Matches, sizeof(Matches));
- p_clear(Completed, sizeof(Completed));
+ p_clear(Matches, countof(Matches));
+ p_clear(Completed, countof(Completed));
for (num = 0; MuttVars[num].option; num++)
candidate(Completed, User_typed, MuttVars[num].option,
sizeof(Completed));
if (numtabs == 1) {
Num_matched = 0;
m_strcpy(User_typed, sizeof(User_typed), pt);
- p_clear(Matches, sizeof(Matches));
- p_clear(Completed, sizeof(Completed));
+ p_clear(Matches, countof(Matches));
+ p_clear(Completed, countof(Completed));
for (num = 0; menu[num].name; num++)
candidate (Completed, User_typed, menu[num].name, sizeof(Completed));
/* try the generic menu */
}
/* Implement the -Q command line flag */
-int mutt_query_variables (LIST * queries)
+int mutt_query_variables (string_list_t * queries)
{
- LIST *p;
+ string_list_t *p;
char errbuff[STRING];
char command[STRING];
return 0;
}
-static int mutt_execute_commands (LIST * p)
+static int mutt_execute_commands (string_list_t * p)
{
BUFFER err, token;
char errstr[SHORT_STRING];
return 0;
}
-void mutt_init (int skip_sys_rc, LIST * commands)
+void mutt_init (int skip_sys_rc, string_list_t * commands)
{
struct passwd *pw;
struct utsname utsname;
if (!Homedir)
Homedir = m_strdup(pw->pw_dir);
- Realname = m_strdup(mutt_gecos_name (rnbuf, sizeof(rnbuf), pw));
+ mutt_gecos_name(rnbuf, sizeof(rnbuf), pw, GecosMask.rx);
+ Realname = m_strdup(rnbuf);
Shell = m_strdup(pw->pw_shell);
endpwent ();
}
else
Hostname = m_strdup(utsname.nodename);
- if (!p && getdnsdomainname (buffer, sizeof(buffer)) == -1)
+ if (!p && getdnsdomainname(buffer, sizeof(buffer)) == -1)
Fqdn = m_strdup("@");
else
if (*buffer != '@') {