#ifdef USE_IMAP
#include "imap.h"
+#include "imap/mx_imap.h"
#endif
#include "mutt_crypt.h"
#include "lib/mem.h"
#include "lib/intl.h"
#include "lib/str.h"
+#include "lib/debug.h"
#include <string.h>
#include <ctype.h>
mktemp (s);
if (period != NULL) {
*period = '.';
- sl = safe_strlen (s);
+ sl = mutt_strlen (s);
strfcpy (s + sl, period, l - sl);
}
}
if (b->parameter)
mutt_free_parameter (&b->parameter);
if (b->unlink && b->filename) {
- dprint (1, (debugfile, "mutt_free_body: Unlinking %s.\n", b->filename));
+ debug_print (1, ("unlinking %s.\n", b->filename));
unlink (b->filename);
}
else if (b->filename)
- dprint (1,
- (debugfile, "mutt_free_body: Not unlinking %s.\n",
- b->filename));
+ debug_print (1, ("not unlinking %s.\n", b->filename));
FREE (&b->filename);
FREE (&b->content);
*p = 0;
}
-LIST *mutt_add_list (LIST * head, const char *data)
-{
+LIST *mutt_add_list (LIST * head, const char *data) {
+ size_t len = mutt_strlen (data);
+ return (mutt_add_list_n (head, data, len ? len + 1 : 0));
+}
+
+LIST *mutt_add_list_n (LIST *head, const void *data, size_t len) {
LIST *tmp;
for (tmp = head; tmp && tmp->next; tmp = tmp->next);
+
if (tmp) {
tmp->next = safe_malloc (sizeof (LIST));
tmp = tmp->next;
- }
- else
+ } else
head = tmp = safe_malloc (sizeof (LIST));
- tmp->data = safe_strdup (data);
+ tmp->data = safe_malloc (len);
+ if (len)
+ memcpy (tmp->data, data, len);
tmp->next = NULL;
return head;
}
int mutt_matches_ignore (const char *s, LIST * t)
{
for (; t; t = t->next) {
- if (!ascii_strncasecmp (s, t->data, safe_strlen (t->data))
+ if (!ascii_strncasecmp (s, t->data, mutt_strlen (t->data))
|| *t->data == '*')
return 1;
}
case '+':
{
#ifdef USE_IMAP
- /* if folder = {host} or imap[s]://host/: don't append slash */
- if (mx_is_imap (NONULL (Maildir)) &&
- (Maildir[safe_strlen (Maildir) - 1] == '}' ||
- Maildir[safe_strlen (Maildir) - 1] == '/'))
+ /* if folder = imap[s]://host/: don't append slash */
+ if (imap_is_magic (NONULL (Maildir), NULL) == M_IMAP &&
+ Maildir[mutt_strlen (Maildir) - 1] == '/')
strfcpy (p, NONULL (Maildir), sizeof (p));
else
#endif
}
while (recurse);
-#ifdef USE_IMAP
- /* Rewrite IMAP path in canonical form - aids in string comparisons of
- * folders. May possibly fail, in which case s should be the same. */
- if (mx_is_imap (s))
- imap_expand_path (s, slen);
-#endif
-
return (s);
}
else
strfcpy (dest, pw->pw_gecos, destlen);
- pwnl = safe_strlen (pw->pw_name);
+ pwnl = mutt_strlen (pw->pw_name);
for (idx = 0; dest[idx]; idx++) {
if (dest[idx] == '&') {
FREE (p);
}
+/* move all the headers from extra not present in base into base */
+void mutt_merge_envelopes(ENVELOPE* base, ENVELOPE** extra)
+{
+ /* copies each existing element if necessary, and sets the element
+ * to NULL in the source so that mutt_free_envelope doesn't leave us
+ * with dangling pointers. */
+#define MOVE_ELEM(h) if (!base->h) { base->h = (*extra)->h; (*extra)->h = NULL; }
+ MOVE_ELEM(return_path);
+ MOVE_ELEM(from);
+ MOVE_ELEM(to);
+ MOVE_ELEM(cc);
+ MOVE_ELEM(bcc);
+ MOVE_ELEM(sender);
+ MOVE_ELEM(reply_to);
+ MOVE_ELEM(mail_followup_to);
+ MOVE_ELEM(list_post);
+ MOVE_ELEM(message_id);
+ MOVE_ELEM(supersedes);
+ MOVE_ELEM(date);
+ MOVE_ELEM(x_label);
+ if (!base->refs_changed) {
+ MOVE_ELEM(references);
+ }
+ if (!base->irt_changed) {
+ MOVE_ELEM(in_reply_to);
+ }
+ /* real_subj is subordinate to subject */
+ if (!base->subject) {
+ base->subject = (*extra)->subject;
+ base->real_subj = (*extra)->real_subj;
+ (*extra)->subject = NULL;
+ (*extra)->real_subj = NULL;
+ }
+ /* spam and user headers should never be hashed, and the new envelope may
+ * have better values. Use new versions regardless. */
+ mutt_buffer_free (&base->spam);
+ mutt_free_list (&base->userhdrs);
+ MOVE_ELEM(spam);
+ MOVE_ELEM(userhdrs);
+#undef MOVE_ELEM
+
+ mutt_free_envelope(extra);
+}
+
void _mutt_mktemp (char *s, const char *src, int line)
{
- snprintf (s, _POSIX_PATH_MAX, "%s/muttng-%s-%d-%d-%d", NONULL (Tempdir),
- NONULL (Hostname), (int) getuid (), (int) getpid (), Counter++);
- dprint (1,
- (debugfile, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, s));
+
+ snprintf (s, _POSIX_PATH_MAX, "%s/muttng-%s-%d-%d-%d-%x%x", NONULL (Tempdir),
+ NONULL (Hostname), (int) getuid (), (int) getpid (), Counter++,
+ (unsigned int) rand(), (unsigned int) rand());
+ debug_print (1, ("%s:%d: mutt_mktemp returns \"%s\".\n", src, line, s));
unlink (s);
}
}
*q = 0;
- if (safe_strncmp (s, Maildir, (len = safe_strlen (Maildir))) == 0 &&
+ if (safe_strncmp (s, Maildir, (len = mutt_strlen (Maildir))) == 0 &&
s[len] == '/') {
*s++ = '=';
- memmove (s, s + len, safe_strlen (s + len) + 1);
+ memmove (s, s + len, mutt_strlen (s + len) + 1);
}
- else if (safe_strncmp (s, Homedir, (len = safe_strlen (Homedir))) == 0 &&
+ else if (safe_strncmp (s, Homedir, (len = mutt_strlen (Homedir))) == 0 &&
s[len] == '/') {
*s++ = '~';
- memmove (s, s + len - 1, safe_strlen (s + len - 1) + 1);
+ memmove (s, s + len - 1, mutt_strlen (s + len - 1) + 1);
}
}
size_t slen;
int found = 0;
- slen = safe_strlen (src);
+ slen = mutt_strlen (src);
destlen--;
for (p = fmt, d = dest; destlen && *p; p++) {
ret++;
s++;
}
- return (safe_strlen (p));
+ return (mutt_strlen (p));
}
void mutt_FormatString (char *dest, /* output buffer */
if (count > col) {
count -= col; /* how many columns left on this line */
mutt_FormatString (buf, sizeof (buf), src, callback, data, flags);
- wid = safe_strlen (buf);
+ wid = mutt_strlen (buf);
if (count > wid) {
count -= wid; /* how many chars to pad */
memset (wptr, ch, count);
*p = '_';
}
- if ((len = safe_strlen (buf)) + wlen > destlen)
+ if ((len = mutt_strlen (buf)) + wlen > destlen)
len = (destlen - wlen > 0) ? (destlen - wlen) : 0;
memcpy (wptr, buf, len);
FILE *f;
struct stat s;
- int len = safe_strlen (path);
+ int len = mutt_strlen (path);
if (path[len - 1] == '|') {
/* read from a pipe */
}
#endif
- if (stat (s, st) != -1) {
- if (magic == -1) {
- mutt_error (_("%s is not a mailbox!"), s);
- return 1;
- }
-
+ if (magic > 0 && !mx_access (s, W_OK)) {
if (option (OPTCONFIRMAPPEND) &&
- (!TrashPath || (safe_strcmp (s, TrashPath) != 0)))
+ (!TrashPath || (mutt_strcmp (s, TrashPath) != 0))) {
/* if we're appending to the trash, there's no point in asking */
- {
snprintf (tmp, sizeof (tmp), _("Append messages to %s?"), s);
if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO)
ret = 1;
ret = -1;
}
}
+
+ if (stat (s, st) != -1) {
+ if (magic == -1) {
+ mutt_error (_("%s is not a mailbox!"), s);
+ return 1;
+ }
+ }
else {
#ifdef USE_IMAP
if (magic != M_IMAP)
if (s->flags & M_PENDINGPREFIX) {
int i;
- i = safe_strlen (Quotebuf);
+ i = mutt_strlen (Quotebuf);
Quotebuf[i++] = c;
Quotebuf[i] = '\0';
if (i == sizeof (Quotebuf) - 1 || c == '\n') {
void state_mark_attach (STATE * s)
{
- if ((s->flags & M_DISPLAY) && !safe_strcmp (Pager, "builtin"))
+ if ((s->flags & M_DISPLAY) && !mutt_strcmp (Pager, "builtin"))
state_puts (AttachmentMarker, s);
}
b = mutt_buffer_init (b);
b->data = safe_strdup (seed);
- b->dsize = safe_strlen (seed);
+ b->dsize = mutt_strlen (seed);
b->dptr = (char *) b->data + b->dsize;
return b;
}
void mutt_buffer_addstr (BUFFER * buf, const char *s)
{
- mutt_buffer_add (buf, s, safe_strlen (s));
+ mutt_buffer_add (buf, s, mutt_strlen (s));
}
void mutt_buffer_addch (BUFFER * buf, char c)
{
static char vstring[STRING];
- snprintf (vstring, sizeof (vstring), "Mutt-ng %s (%s)",
+ snprintf (vstring, sizeof (vstring), "Mutt-ng %s (%s) based on Mutt 1.5.9",
MUTT_VERSION, ReleaseDate);
return vstring;
}
if (regexec
(l->rx->rx, s, (size_t) l->nmatch, (regmatch_t *) pmatch,
(int) 0) == 0) {
- dprint (5,
- (debugfile, "mutt_match_spam_list: %s matches %s\n", s,
- l->rx->pattern));
- dprint (5,
- (debugfile, "mutt_match_spam_list: %d subs\n",
- l->rx->rx->re_nsub));
+ debug_print (5, ("%s matches %s\n%d subst", s, l->rx->pattern, l->rx->rx->re_nsub));
/* Copy template into text, with substitutions. */
for (p = l->template; *p;) {
}
}
text[tlen] = '\0';
- dprint (5, (debugfile, "mutt_match_spam_list: \"%s\"\n", text));
+ debug_print (5, ("\"%s\"\n", text));
return 1;
}
}
return 0;
}
+
+int mutt_cmp_header (const HEADER * h1, const HEADER * h2) {
+ if (h1 && h2) {
+ if (h1->received != h2->received ||
+ h1->date_sent != h2->date_sent ||
+ h1->content->length != h2->content->length ||
+ h1->lines != h2->lines ||
+ h1->zhours != h2->zhours ||
+ h1->zminutes != h2->zminutes ||
+ h1->zoccident != h2->zoccident ||
+ h1->mime != h2->mime ||
+ !mutt_cmp_env (h1->env, h2->env) ||
+ !mutt_cmp_body (h1->content, h2->content))
+ return (0);
+ else
+ return (1);
+ }
+ else {
+ if (h1 == NULL && h2 == NULL)
+ return (1);
+ else
+ return (0);
+ }
+}
+
+/* return 1 if address lists are strictly identical */
+int mutt_cmp_addr (const ADDRESS * a, const ADDRESS * b)
+{
+ while (a && b) {
+ if (mutt_strcmp (a->mailbox, b->mailbox) ||
+ mutt_strcmp (a->personal, b->personal))
+ return (0);
+
+ a = a->next;
+ b = b->next;
+ }
+ if (a || b)
+ return (0);
+
+ return (1);
+}
+
+int mutt_cmp_list (const LIST * a, const LIST * b)
+{
+ while (a && b) {
+ if (mutt_strcmp (a->data, b->data))
+ return (0);
+
+ a = a->next;
+ b = b->next;
+ }
+ if (a || b)
+ return (0);
+
+ return (1);
+}
+
+int mutt_cmp_env (const ENVELOPE * e1, const ENVELOPE * e2)
+{
+ if (e1 && e2) {
+ if (mutt_strcmp (e1->message_id, e2->message_id) ||
+ mutt_strcmp (e1->subject, e2->subject) ||
+ !mutt_cmp_list (e1->references, e2->references) ||
+ !mutt_cmp_addr (e1->from, e2->from) ||
+ !mutt_cmp_addr (e1->sender, e2->sender) ||
+ !mutt_cmp_addr (e1->reply_to, e2->reply_to) ||
+ !mutt_cmp_addr (e1->to, e2->to) ||
+ !mutt_cmp_addr (e1->cc, e2->cc) ||
+ !mutt_cmp_addr (e1->return_path, e2->return_path))
+ return (0);
+ else
+ return (1);
+ }
+ else {
+ if (e1 == NULL && e2 == NULL)
+ return (1);
+ else
+ return (0);
+ }
+}
+
+int mutt_cmp_param (const PARAMETER * p1, const PARAMETER * p2)
+{
+ while (p1 && p2) {
+ if (mutt_strcmp (p1->attribute, p2->attribute) ||
+ mutt_strcmp (p1->value, p2->value))
+ return (0);
+
+ p1 = p1->next;
+ p2 = p2->next;
+ }
+ if (p1 || p2)
+ return (0);
+
+ return (1);
+}
+
+int mutt_cmp_body (const BODY * b1, const BODY * b2)
+{
+ if (b1->type != b2->type ||
+ b1->encoding != b2->encoding ||
+ mutt_strcmp (b1->subtype, b2->subtype) ||
+ mutt_strcmp (b1->description, b2->description) ||
+ !mutt_cmp_param (b1->parameter, b2->parameter) ||
+ b1->length != b2->length)
+ return (0);
+ return (1);
+}
projects / apps / madmutt.git / blobdiff