{
if (mutt_strcmp (a->mailbox, u->data) == 0) /* alias already found */
{
- dprint (1, (debugfile, "mutt_expand_aliases_r(): loop in alias found for '%s'\n", a->mailbox));
+ mutt_debug (1, "mutt_expand_aliases_r(): loop in alias found for '%s'\n",
+ a->mailbox);
i = 1;
break;
}
/* NULL address is assumed to be the user. */
if (!addr)
{
- dprint (5, (debugfile, "mutt_addr_is_user: yes, NULL address\n"));
+ mutt_debug (5, "mutt_addr_is_user: yes, NULL address\n");
return 1;
}
if (!addr->mailbox)
{
- dprint (5, (debugfile, "mutt_addr_is_user: no, no mailbox\n"));
+ mutt_debug (5, "mutt_addr_is_user: no, no mailbox\n");
return 0;
}
if (ascii_strcasecmp (addr->mailbox, Username) == 0)
{
- dprint (5, (debugfile, "mutt_addr_is_user: yes, %s = %s\n", addr->mailbox, Username));
+ mutt_debug (5, "mutt_addr_is_user: yes, %s = %s\n",
+ addr->mailbox, Username);
return 1;
}
if (string_is_address(addr->mailbox, Username, Hostname))
{
- dprint (5, (debugfile, "mutt_addr_is_user: yes, %s = %s @ %s \n", addr->mailbox, Username, Hostname));
+ mutt_debug (5, "mutt_addr_is_user: yes, %s = %s @ %s \n",
+ addr->mailbox, Username, Hostname);
return 1;
}
fqdn = mutt_fqdn (0);
if (string_is_address(addr->mailbox, Username, fqdn))
{
- dprint (5, (debugfile, "mutt_addr_is_user: yes, %s = %s @ %s \n", addr->mailbox, Username, NONULL(fqdn)));
+ mutt_debug (5, "mutt_addr_is_user: yes, %s = %s @ %s \n",
+ addr->mailbox, Username, NONULL(fqdn));
return 1;
}
fqdn = mutt_fqdn (1);
if (string_is_address(addr->mailbox, Username, fqdn))
{
- dprint (5, (debugfile, "mutt_addr_is_user: yes, %s = %s @ %s \n", addr->mailbox, Username, NONULL(fqdn)));
+ mutt_debug (5, "mutt_addr_is_user: yes, %s = %s @ %s \n",
+ addr->mailbox, Username, NONULL(fqdn));
return 1;
}
if (From && !ascii_strcasecmp (From->mailbox, addr->mailbox))
{
- dprint (5, (debugfile, "mutt_addr_is_user: yes, %s = %s\n", addr->mailbox, From->mailbox));
+ mutt_debug (5, "mutt_addr_is_user: yes, %s = %s\n",
+ addr->mailbox, From->mailbox);
return 1;
}
if (mutt_match_rx_list (addr->mailbox, Alternates))
{
- dprint (5, (debugfile, "mutt_addr_is_user: yes, %s matched by alternates.\n", addr->mailbox));
+ mutt_debug (5, "mutt_addr_is_user: yes, %s matched by alternates.\n",
+ addr->mailbox);
if (mutt_match_rx_list (addr->mailbox, UnAlternates))
- dprint (5, (debugfile, "mutt_addr_is_user: but, %s matched by unalternates.\n", addr->mailbox));
+ mutt_debug (5, "mutt_addr_is_user: but, %s matched by unalternates.\n",
+ addr->mailbox);
else
return 1;
}
- dprint (5, (debugfile, "mutt_addr_is_user: no, all failed.\n"));
+ mutt_debug (5, "mutt_addr_is_user: no, all failed.\n");
return 0;
}
if (rfc1524_expand_filename (entry->nametemplate,
a->filename, newfile, sizeof (newfile)))
{
- dprint(1, (debugfile, "oldfile: %s\t newfile: %s\n",
- a->filename, newfile));
+ mutt_debug (1, "oldfile: %s\t newfile: %s\n", a->filename, newfile);
if (safe_symlink (a->filename, newfile) == -1)
{
if (mutt_yesorno (_("Can't match nametemplate, continue?"), MUTT_YES) != MUTT_YES)
if (rfc1524_expand_filename (entry->nametemplate,
a->filename, newfile, sizeof (newfile)))
{
- dprint(1, (debugfile, "oldfile: %s\t newfile: %s\n",
- a->filename, newfile));
+ mutt_debug (1, "oldfile: %s\t newfile: %s\n", a->filename, newfile);
if (safe_symlink (a->filename, newfile) == -1)
{
if (mutt_yesorno (_("Can't match nametemplate, continue?"), MUTT_YES) != MUTT_YES)
n == TYPETEXT ? "text" :
n == TYPEVIDEO ? "video" : "other",
tmp.subtype);
- dprint(1, (debugfile, "mutt_check_lookup_list: \"%s\" -> %s\n",
- b->filename, type));
+ mutt_debug (1, "mutt_check_lookup_list: \"%s\" -> %s\n",
+ b->filename, type);
}
if (tmp.subtype)
FREE (&tmp.subtype);
decode_state.fpout = safe_fopen(pagerfile, "w");
if (!decode_state.fpout)
{
- dprint(1, (debugfile, "mutt_view_attachment:%d safe_fopen(%s) errno=%d %s\n", __LINE__, pagerfile, errno, strerror(errno)));
+ mutt_debug (1, "mutt_view_attachment:%d safe_fopen(%s) errno=%d %s\n",
+ __LINE__, pagerfile, errno, strerror(errno));
mutt_perror(pagerfile);
mutt_sleep(1);
goto return_error;
decode_state.flags = MUTT_CHARCONV;
mutt_decode_attachment(a, &decode_state);
if (fclose(decode_state.fpout) == EOF)
- dprint(1, (debugfile, "mutt_view_attachment:%d fclose errno=%d %s\n", __LINE__, pagerfile, errno, strerror(errno)));
+ mutt_debug (1, "mutt_view_attachment:%d fclose errno=%d %s\n",
+ __LINE__, pagerfile, errno, strerror(errno));
}
else
{
rfc1524_entry *entry;
int piped = false;
- dprint (2, (debugfile, "Using mailcap...\n"));
+ mutt_debug (2, "Using mailcap...\n");
entry = rfc1524_new_entry ();
rfc1524_mailcap_lookup (a, type, entry, MUTT_PRINT);
if (mutt_decode_save_attachment (fp, a, newfile, MUTT_PRINTING, 0) == 0)
{
- dprint (2, (debugfile, "successfully decoded %s type attachment to %s\n",
- type, newfile));
+ mutt_debug (2, "successfully decoded %s type attachment to %s\n",
+ type, newfile);
if ((ifp = fopen (newfile, "r")) == NULL)
{
goto bail0;
}
- dprint (2, (debugfile, "successfully opened %s read-only\n", newfile));
+ mutt_debug (2, "successfully opened %s read-only\n", newfile);
mutt_endwin (NULL);
if ((thepid = mutt_create_filter (NONULL(PrintCmd), &fpout, NULL, NULL)) < 0)
goto bail0;
}
- dprint (2, (debugfile, "Filter created.\n"));
+ mutt_debug (2, "Filter created.\n");
mutt_copy_stream (ifp, fpout);
url.path = NULL;
if (url_ciss_tostring (&url, host, sizeof (host), U_PATH) < 0)
{
- dprint (1, (debugfile, "bcache_path: URL to string failed\n"));
+ mutt_debug (1, "bcache_path: URL to string failed\n");
return -1;
}
host, path,
(*path && path[mutt_strlen (path) - 1] == '/') ? "" : "/");
- dprint (3, (debugfile, "bcache_path: rc: %d, path: '%s'\n", len, dst));
+ mutt_debug (3, "bcache_path: rc: %d, path: '%s'\n", len, dst);
if (len < 0 || len >= dstlen-1)
return -1;
- dprint (3, (debugfile, "bcache_path: directory: '%s'\n", dst));
+ mutt_debug (3, "bcache_path: directory: '%s'\n", dst);
return 0;
}
fp = safe_fopen (path, "r");
- dprint (3, (debugfile, "bcache: get: '%s': %s\n", path, fp == NULL ? "no" : "yes"));
+ mutt_debug (3, "bcache: get: '%s': %s\n", path, fp == NULL ? "no" : "yes");
return fp;
}
}
snprintf(path, sizeof (path), "%s%s%s", bcache->path, id, tmp ? ".tmp" : "");
- dprint (3, (debugfile, "bcache: put: '%s'\n", path));
+ mutt_debug (3, "bcache: put: '%s'\n", path);
return safe_fopen(path, "w+");
}
snprintf (path, sizeof (path), "%s%s", bcache->path, id);
snprintf (newpath, sizeof (newpath), "%s%s", bcache->path, newid);
- dprint (3, (debugfile, "bcache: mv: '%s' '%s'\n", path, newpath));
+ mutt_debug (3, "bcache: mv: '%s' '%s'\n", path, newpath);
return rename (path, newpath);
}
safe_strncat (path, sizeof (path), bcache->path, bcache->pathlen);
safe_strncat (path, sizeof (path), id, mutt_strlen (id));
- dprint (3, (debugfile, "bcache: del: '%s'\n", path));
+ mutt_debug (3, "bcache: del: '%s'\n", path);
return unlink (path);
}
else
rc = S_ISREG(st.st_mode) && st.st_size != 0 ? 0 : -1;
- dprint (3, (debugfile, "bcache: exists: '%s': %s\n", path, rc == 0 ? "yes" : "no"));
+ mutt_debug (3, "bcache: exists: '%s': %s\n", path, rc == 0 ? "yes" : "no");
return rc;
}
rc = 0;
- dprint (3, (debugfile, "bcache: list: dir: '%s'\n", bcache->path));
+ mutt_debug (3, "bcache: list: dir: '%s'\n", bcache->path);
while ((de = readdir (d)))
{
mutt_strncmp (de->d_name, "..", 2) == 0)
continue;
- dprint (3, (debugfile, "bcache: list: dir: '%s', id :'%s'\n", bcache->path, de->d_name));
+ mutt_debug (3, "bcache: list: dir: '%s', id :'%s'\n",
+ bcache->path, de->d_name);
if (want_id && want_id (de->d_name, bcache, data) != 0)
goto out;
if (closedir (d) < 0)
rc = -1;
}
- dprint (3, (debugfile, "bcache: list: did %d entries\n", rc));
+ mutt_debug (3, "bcache: list: did %d entries\n", rc);
return rc;
}
/* When in mailboxes mode, disables this feature */
if (Maildir)
{
- dprint(5, (debugfile, "= hit! Maildir: %s, LastDir: %s\n", Maildir, LastDir));
+ mutt_debug (5, "= hit! Maildir: %s, LastDir: %s\n",
+ Maildir, LastDir);
if (!GotoSwapper[0])
{
if (mutt_strcmp (LastDir, Maildir) != 0)
{
if (mutt_strcmp (p ? p : buf, (*tmp)->realpath) == 0)
{
- dprint(3,(debugfile,"mailbox '%s' already registered as '%s'\n", buf, (*tmp)->path));
+ mutt_debug (3, "mailbox '%s' already registered as '%s'\n",
+ buf, (*tmp)->path);
break;
}
}
{
if (mutt_strcmp (buf, (*tmp)->path) == 0)
{
- dprint(3,(debugfile,"virtual mailbox '%s' already registered as '%s'\n", buf, (*tmp)->path));
+ mutt_debug (3, "virtual mailbox '%s' already registered as '%s'\n",
+ buf, (*tmp)->path);
break;
}
}
init_pair(i, fg, bg);
- dprint (3, (debugfile,"mutt_alloc_color(): Color pairs used so far: %d\n",
- UserColors));
+ mutt_debug (3, "mutt_alloc_color(): Color pairs used so far: %d\n",
+ UserColors);
return (COLOR_PAIR (p->index));
}
if (p->count > 0) return;
UserColors--;
- dprint(1,(debugfile,"mutt_free_color(): Color pairs used so far: %d\n",
- UserColors));
+ mutt_debug (1, "mutt_free_color(): Color pairs used so far: %d\n",
+ UserColors);
if (p == ColorList)
{
{
*do_cache = 1;
}
- dprint (1, (debugfile,"Freeing pattern \"%s\" from ColorList\n",
- tmp->pattern));
+ mutt_debug (1, "Freeing pattern \"%s\" from ColorList\n",
+ tmp->pattern);
if (last)
{
last->next = tmp->next;
char imap_path[LONG_STRING];
#endif
- dprint (2, (debugfile, "mutt_complete: completing %s\n", s));
+ mutt_debug (2, "mutt_complete: completing %s\n", s);
#ifdef USE_NNTP
if (option (OPTNEWS))
if (dirp == NULL)
{
- dprint (1, (debugfile, "mutt_complete(): %s: %s (errno %d).\n", exp_dirpart, strerror (errno), errno));
+ mutt_debug (1, "mutt_complete(): %s: %s (errno %d).\n",
+ exp_dirpart, strerror (errno), errno);
return (-1);
}
{
for (t = HeaderOrderList; t; t = t->next)
{
- dprint(3, (debugfile, "Reorder list: %s\n", t->data));
+ mutt_debug (3, "Reorder list: %s\n", t->data);
hdr_count++;
}
}
- dprint (1, (debugfile, "WEED is %s\n", (flags & CH_WEED) ? "Set" : "Not"));
+ mutt_debug (1, "WEED is %s\n", (flags & CH_WEED) ? "Set" : "Not");
headers = safe_calloc (hdr_count, sizeof (char *));
{
if (!ascii_strncasecmp (buf, t->data, mutt_strlen (t->data)))
{
- dprint(2, (debugfile, "Reorder: %s matches %s\n", t->data, buf));
+ mutt_debug (2, "Reorder: %s matches %s\n", t->data, buf);
break;
}
}
if (!ignore)
{
- dprint (2, (debugfile, "Reorder: x = %d; hdr_count = %d\n", x, hdr_count));
+ mutt_debug (2, "Reorder: x = %d; hdr_count = %d\n", x, hdr_count);
if (!this_one) {
this_one = safe_strdup (buf);
this_one_len = mutt_strlen (this_one);
if ((r = _mutt_copy_message (fpout, msg->fp, hdr, hdr->content, flags, chflags)) == 0
&& (ferror (fpout) || feof (fpout)))
{
- dprint (1, (debugfile, "_mutt_copy_message failed to detect EOF!\n"));
+ mutt_debug (1, "_mutt_copy_message failed to detect EOF!\n");
r = -1;
}
mx_close_message (src, &msg);
gpgme_release (ctx);
state_attach_puts (_("[-- End signature information --]\n\n"), s);
- dprint (1, (debugfile, "verify_one: returning %d.\n", badsig));
+ mutt_debug (1, "verify_one: returning %d.\n", badsig);
return badsig? 1: anywarn? 2 : 0;
}
if ((err = gpgme_new (&tmpctx)) != GPG_ERR_NO_ERROR)
{
- dprint (1, (debugfile, "Error creating GPGME context\n"));
+ mutt_debug (1, "Error creating GPGME context\n");
return rc;
}
snprintf (tmpdir, sizeof(tmpdir), "%s/mutt-gpgme-XXXXXX", Tempdir);
if (!mkdtemp (tmpdir))
{
- dprint (1, (debugfile, "Error creating temporary GPGME home\n"));
+ mutt_debug (1, "Error creating temporary GPGME home\n");
goto err_ctx;
}
engineinfo = engineinfo->next;
if (!engineinfo)
{
- dprint (1, (debugfile, "Error finding GPGME PGP engine\n"));
+ mutt_debug (1, "Error finding GPGME PGP engine\n");
goto err_tmpdir;
}
engineinfo->file_name, tmpdir);
if (err != GPG_ERR_NO_ERROR)
{
- dprint (1, (debugfile, "Error setting GPGME context home\n"));
+ mutt_debug (1, "Error setting GPGME context home\n");
goto err_tmpdir;
}
}
if ((err = gpgme_op_import (tmpctx, keydata)) != GPG_ERR_NO_ERROR)
{
- dprint (1, (debugfile, "Error importing key\n"));
+ mutt_debug (1, "Error importing key\n");
goto err_tmpdir;
}
}
if (gpg_err_code (err) != GPG_ERR_EOF)
{
- dprint (1, (debugfile, "Error listing keys\n"));
+ mutt_debug (1, "Error listing keys\n");
goto err_fp;
}
char body_charset[STRING]; /* Only used for clearsigned messages. */
- dprint (2, (debugfile, "Entering pgp_application_pgp handler\n"));
+ mutt_debug (2, "Entering pgp_application_pgp handler\n");
/* For clearsigned messages we won't be able to get a character set
but we know that this may only be text thus we assume Latin-1
" of PGP message! --]\n\n"), s);
return 1;
}
- dprint (2, (debugfile, "Leaving pgp_application_pgp handler\n"));
+ mutt_debug (2, "Leaving pgp_application_pgp handler\n");
return err;
}
int is_signed;
int rc = 0;
- dprint (2, (debugfile, "Entering pgp_encrypted handler\n"));
+ mutt_debug (2, "Entering pgp_encrypted handler\n");
mutt_mktemp (tempfile, sizeof (tempfile));
if (!(fpout = safe_fopen (tempfile, "w+")))
safe_fclose (&fpout);
mutt_unlink(tempfile);
- dprint (2, (debugfile, "Leaving pgp_encrypted handler\n"));
+ mutt_debug (2, "Leaving pgp_encrypted handler\n");
return rc;
}
int is_signed;
int rc = 0;
- dprint (2, (debugfile, "Entering smime_encrypted handler\n"));
+ mutt_debug (2, "Entering smime_encrypted handler\n");
a->warnsig = 0;
mutt_mktemp (tempfile, sizeof (tempfile));
safe_fclose (&fpout);
mutt_unlink(tempfile);
- dprint (2, (debugfile, "Leaving smime_encrypted handler\n"));
+ mutt_debug (2, "Leaving smime_encrypted handler\n");
return rc;
}
if (!keys)
return NULL;
- dprint (5, (debugfile, "crypt_getkeybyaddr: looking for %s <%s>.",
- a->personal, a->mailbox));
+ mutt_debug (5, "crypt_getkeybyaddr: looking for %s <%s>.",
+ a->personal, a->mailbox);
for (k = keys; k; k = k->next)
{
- dprint (5, (debugfile, " looking at key: %s `%.15s'\n",
- crypt_keyid (k), k->uid));
+ mutt_debug (5, " looking at key: %s `%.15s'\n",
+ crypt_keyid (k), k->uid);
if (abilities && !(k->flags & abilities))
{
- dprint (5, (debugfile, " insufficient abilities: Has %x, want %x\n",
- k->flags, abilities));
+ mutt_debug (5, " insufficient abilities: Has %x, want %x\n",
+ k->flags, abilities);
continue;
}
if (abilities && !(k->flags & abilities))
continue;
- dprint (5, (debugfile, "crypt_getkeybystr: matching \"%s\" against "
- "key %s, \"%s\": ", p, crypt_long_keyid (k), k->uid));
+ mutt_debug (5, "crypt_getkeybystr: matching \"%s\" against "
+ "key %s, \"%s\": ", p, crypt_long_keyid (k), k->uid);
if (!*p
|| (pfcopy && mutt_strcasecmp (pfcopy, crypt_fpr (k)) == 0)
{
crypt_key_t *tmp;
- dprint (5, (debugfile, "match.\n"));
+ mutt_debug (5, "match.\n");
*matches_endp = tmp = crypt_copy_key (k);
matches_endp = &tmp->next;
vsnprintf (scratch, sizeof (scratch), fmt, ap);
- dprint (1, (debugfile, "%s\n", scratch));
+ mutt_debug (1, "%s\n", scratch);
mutt_format_string (Errorbuf, sizeof (Errorbuf),
0, MuttMessageWindow->cols, FMT_LEFT, 0, scratch, sizeof (scratch), 0);
return;
}
if (gettimeofday (&tv, NULL) < 0)
- dprint (1, (debugfile, "gettimeofday failed: %d\n", errno));
+ mutt_debug (1, "gettimeofday failed: %d\n", errno);
/* if timestamp is 0 no time-based suppression is done */
if (TimeInc)
progress->timestamp = ((unsigned int) tv.tv_sec * 1000)
else
snprintf (posstr, sizeof (posstr), "%ld", pos);
- dprint (5, (debugfile, "updating progress: %s\n", posstr));
+ mutt_debug (5, "updating progress: %s\n", posstr);
progress->pos = pos;
if (now)
if (option (OPTNOCURSES))
return;
- dprint (2, (debugfile, "In mutt_reflow_windows\n"));
+ mutt_debug (2, "In mutt_reflow_windows\n");
MuttStatusWindow->rows = 1;
MuttStatusWindow->cols = COLS;
{
char *p = strerror (errno);
- dprint (1, (debugfile, "%s: %s (errno = %d)\n", s,
- p ? p : "unknown error", errno));
+ mutt_debug (1, "%s: %s (errno = %d)\n",
+ s, p ? p : "unknown error", errno);
mutt_error ("%s: %s (errno = %d)", s, p ? p : _("unknown error"), errno);
}
op = km_dokey (MENU_MAIN);
- dprint(4, (debugfile, "mutt_index_menu[%d]: Got op %d\n", __LINE__, op));
+ mutt_debug (4, "mutt_index_menu[%d]: Got op %d\n", __LINE__, op);
if (op == -1) {
mutt_timeout_hook();
break;
case OP_MAIN_WINDOWED_VFOLDER_BACKWARD:
- dprint(2, (debugfile, "OP_MAIN_WINDOWED_VFOLDER_BACKWARD\n"));
+ mutt_debug (2, "OP_MAIN_WINDOWED_VFOLDER_BACKWARD\n");
if (NotmuchQueryWindowDuration <= 0)
{
mutt_message (_("Windowed queries disabled."));
mutt_message (_("Failed to create query, aborting."));
else
{
- dprint(2, (debugfile, "nm: + windowed query (%s)\n", buf));
+ mutt_debug (2, "nm: + windowed query (%s)\n", buf);
main_change_folder(menu, op, buf, sizeof (buf), &oldcount, &index_hint, 0);
}
break;
by whatever they typed at the prompt.) */
snprintf(buf, sizeof(buf), _("Message bound to %s."), str);
mutt_message(buf);
- dprint (1, (debugfile, "Mark: %s => %s\n", str, macro));
+ mutt_debug (1, "Mark: %s => %s\n", str, macro);
}
}
else
if (!*s)
return 0;
- dprint (3, (debugfile, "\nis_from(): parsing: %s", s));
+ mutt_debug (3, "\nis_from(): parsing: %s", s);
if (!is_day_name (s))
{
p = strchr(p + 4, ' ');
if (!p)
{
- dprint (1, (debugfile, "is_from(): error parsing what appears to be a pipermail-style obscured return_path: %s\n", s));
+ mutt_debug (1, "is_from(): error parsing what appears to be a "
+ "pipermail-style obscured return_path: %s\n", s);
return 0;
}
}
len = pathlen - 1;
memcpy (path, s, len);
path[len] = 0;
- dprint (3, (debugfile, "is_from(): got return path: %s\n", path));
+ mutt_debug (3, "is_from(): got return path: %s\n", path);
}
s = p + 1;
if (!is_day_name (s))
{
- dprint(1, (debugfile, "is_from(): expected weekday, got: %s\n", s));
+ mutt_debug (1, "is_from(): expected weekday, got: %s\n", s);
return 0;
}
}
if (sscanf (s, "%d", &yr) != 1) return 0;
tm.tm_year = yr > 1900 ? yr - 1900 : (yr < 70 ? yr + 100 : yr);
- dprint (3,(debugfile, "is_from(): month=%d, day=%d, hr=%d, min=%d, sec=%d, yr=%d.\n",
- tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_year));
+ mutt_debug (3, "is_from(): month=%d, day=%d, hr=%d, min=%d, sec=%d, yr=%d.\n",
+ tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_year);
tm.tm_isdst = -1;
{
strfcpy(d, ++p, len);
ret = 0;
- dprint(1, (debugfile, "getdnsdomainname(): %s\n", d));
+ mutt_debug (1, "getdnsdomainname(): %s\n", d);
}
freeaddrinfo(h);
}
else
memset (&tmp, 0, sizeof (tmp));
- dprint (2, (debugfile, "parse_pub_line: buf = `%s'\n", buf));
+ mutt_debug (2, "parse_pub_line: buf = `%s'\n", buf);
for (p = buf; p; p = pend)
{
{
case 1: /* record type */
{
- dprint (2, (debugfile, "record type: %s\n", p));
+ mutt_debug (2, "record type: %s\n", p);
if (!mutt_strcmp (p, "pub"))
is_pub = 1;
}
case 2: /* trust info */
{
- dprint (2, (debugfile, "trust info: %s\n", p));
+ mutt_debug (2, "trust info: %s\n", p);
switch (*p)
{ /* look only at the first letter */
}
case 3: /* key length */
{
- dprint (2, (debugfile, "key len: %s\n", p));
+ mutt_debug (2, "key len: %s\n", p);
if (!(*is_subkey && option (OPTPGPIGNORESUB)) &&
mutt_atos (p, &tmp.keylen) < 0)
}
case 4: /* pubkey algo */
{
- dprint (2, (debugfile, "pubkey algorithm: %s\n", p));
+ mutt_debug (2, "pubkey algorithm: %s\n", p);
if (!(*is_subkey && option (OPTPGPIGNORESUB)))
{
}
case 5: /* 16 hex digits with the long keyid. */
{
- dprint (2, (debugfile, "key id: %s\n", p));
+ mutt_debug (2, "key id: %s\n", p);
if (!(*is_subkey && option (OPTPGPIGNORESUB)))
mutt_str_replace (&tmp.keyid, p);
char tstr[11];
struct tm time;
- dprint (2, (debugfile, "time stamp: %s\n", p));
+ mutt_debug (2, "time stamp: %s\n", p);
if (!p)
break;
if (!is_uid && (*is_subkey && option (OPTPGPIGNORESUB)))
break;
- dprint (2, (debugfile, "user ID: %s\n", NONULL (p)));
+ mutt_debug (2, "user ID: %s\n", NONULL (p));
uid = safe_calloc (sizeof (pgp_uid_t), 1);
fix_uid (p);
case 11: /* signature class */
break;
case 12: /* key capabilities */
- dprint (2, (debugfile, "capabilities info: %s\n", p));
+ mutt_debug (2, "capabilities info: %s\n", p);
while(*p)
{
return k;
bail:
- dprint(5,(debugfile,"parse_pub_line: invalid number: '%s'\n", p));
+ mutt_debug (5, "parse_pub_line: invalid number: '%s'\n", p);
return NULL;
}
if (!(p = hash_find (Groups, k)))
{
- dprint (2, (debugfile, "mutt_pattern_group: Creating group %s.\n", k));
+ mutt_debug (2, "mutt_pattern_group: Creating group %s.\n", k);
p = safe_calloc (1, sizeof (group_t));
p->name = safe_strdup (k);
hash_insert (Groups, p->name, p, 0);
{
/* "i" may be zero if there is trailing whitespace, which is not an error */
if (i != 0)
- dprint (2, (debugfile, "%s:%d [mutt_decode_base64()]: "
- "didn't get a multiple of 4 chars.\n", __FILE__, __LINE__));
+ mutt_debug (2, "%s:%d [mutt_decode_base64()]: "
+ "didn't get a multiple of 4 chars.\n", __FILE__, __LINE__);
break;
}
if (rc)
{
mutt_error (_("One or more parts of this message could not be displayed"));
- dprint (1, (debugfile, "Failed on attachment #%d, type %s/%s.\n", count, TYPE(p), NONULL (p->subtype)));
+ mutt_debug (1, "Failed on attachment #%d, type %s/%s.\n",
+ count, TYPE(p), NONULL (p->subtype));
}
if ((s->flags & MUTT_REPLYING)
s->fpout = open_memstream (&temp, &tempsize);
if (!s->fpout) {
mutt_error (_("Unable to open memory stream!"));
- dprint (1, (debugfile, "Can't open memory stream.\n"));
+ mutt_debug (1, "Can't open memory stream.\n");
return -1;
}
#else
if ((s->fpout = safe_fopen (tempfile, "w")) == NULL)
{
mutt_error (_("Unable to open temporary file!"));
- dprint (1, (debugfile, "Can't open %s.\n", tempfile));
+ mutt_debug (1, "Can't open %s.\n", tempfile);
return -1;
}
#endif
if (rc)
{
- dprint (1, (debugfile, "Failed on attachment of type %s/%s.\n", TYPE(b), NONULL (b->subtype)));
+ mutt_debug (1, "Failed on attachment of type %s/%s.\n",
+ TYPE(b), NONULL (b->subtype));
}
if (decode)
if (b->encoding != ENC7BIT && b->encoding != ENC8BIT
&& b->encoding != ENCBINARY)
{
- dprint (1, (debugfile, "Bad encoding type %d for multipart entity, "
- "assuming 7 bit\n", b->encoding));
+ mutt_debug (1, "Bad encoding type %d for multipart entity, "
+ "assuming 7 bit\n", b->encoding);
b->encoding = ENC7BIT;
}
}
s->flags = oflags | (s->flags & MUTT_FIRSTDONE);
if (rc)
{
- dprint (1, (debugfile, "Bailing on attachment of type %s/%s.\n", TYPE(b), NONULL (b->subtype)));
+ mutt_debug (1, "Bailing on attachment of type %s/%s.\n",
+ TYPE(b), NONULL (b->subtype));
}
return rc;
{
#ifdef DEBUG
int ecode = kcdbecode (db);
- dprint (2, (debugfile, "kcdbopen failed for %s: %s (ecode %d)\n", kcdbpath, kcdbemsg (db), ecode));
+ mutt_debug (2, "kcdbopen failed for %s: %s (ecode %d)\n",
+ kcdbpath, kcdbemsg (db), ecode);
#endif
kcdbdel(db);
return NULL;
{
#ifdef DEBUG
int ecode = kcdbecode (db);
- dprint (2, (debugfile, "kcdbclose failed: %s (ecode %d)\n", kcdbemsg (db), ecode));
+ mutt_debug (2, "kcdbclose failed: %s (ecode %d)\n", kcdbemsg (db), ecode);
#endif
}
kcdbdel(db);
if (rc == MDB_SUCCESS)
ctx->txn_mode = txn_read;
else
- dprint(2, (debugfile, "mdb_get_r_txn: %s: %s\n",
- ctx->txn ? "mdb_txn_renew" : "mdb_txn_begin",
- mdb_strerror(rc)));
+ mutt_debug (2, "mdb_get_r_txn: %s: %s\n",
+ ctx->txn ? "mdb_txn_renew" : "mdb_txn_begin",
+ mdb_strerror(rc));
return rc;
}
if (rc == MDB_SUCCESS)
ctx->txn_mode = txn_write;
else
- dprint(2, (debugfile, "mdb_get_w_txn: mdb_txn_begin: %s\n",
- mdb_strerror(rc)));
+ mutt_debug (2, "mdb_get_w_txn: mdb_txn_begin: %s\n", mdb_strerror(rc));
return rc;
}
rc = mdb_env_create(&ctx->env);
if (rc != MDB_SUCCESS)
{
- dprint(2, (debugfile, "hcache_open_lmdb: mdb_env_create: %s\n",
- mdb_strerror(rc)));
+ mutt_debug (2, "hcache_open_lmdb: mdb_env_create: %s\n", mdb_strerror(rc));
FREE(&ctx);
return NULL;
}
rc = mdb_env_open(ctx->env, path, MDB_NOSUBDIR, 0644);
if (rc != MDB_SUCCESS)
{
- dprint(2, (debugfile, "hcache_open_lmdb: mdb_env_open: %s",
- mdb_strerror(rc)));
+ mutt_debug (2, "hcache_open_lmdb: mdb_env_open: %s", mdb_strerror(rc));
goto fail_env;
}
rc = mdb_get_r_txn(ctx);
if (rc != MDB_SUCCESS)
{
- dprint(2, (debugfile, "hcache_open_lmdb: mdb_txn_begin: %s",
- mdb_strerror(rc)));
+ mutt_debug (2, "hcache_open_lmdb: mdb_txn_begin: %s", mdb_strerror(rc));
goto fail_env;
}
rc = mdb_dbi_open(ctx->txn, NULL, MDB_CREATE, &ctx->db);
if (rc != MDB_SUCCESS)
{
- dprint(2, (debugfile, "hcache_open_lmdb: mdb_dbi_open: %s",
- mdb_strerror(rc)));
+ mutt_debug (2, "hcache_open_lmdb: mdb_dbi_open: %s", mdb_strerror(rc));
goto fail_dbi;
}
if (rc != MDB_SUCCESS)
{
ctx->txn = NULL;
- dprint(2, (debugfile, "hcache_lmdb_fetch: txn_renew: %s\n",
- mdb_strerror(rc)));
+ mutt_debug (2, "hcache_lmdb_fetch: txn_renew: %s\n", mdb_strerror(rc));
return NULL;
}
rc = mdb_get(ctx->txn, ctx->db, &dkey, &data);
}
if (rc != MDB_SUCCESS)
{
- dprint(2, (debugfile, "hcache_lmdb_fetch: mdb_get: %s\n",
- mdb_strerror(rc)));
+ mutt_debug (2, "hcache_lmdb_fetch: mdb_get: %s\n", mdb_strerror(rc));
return NULL;
}
rc = mdb_get_w_txn(ctx);
if (rc != MDB_SUCCESS)
{
- dprint(2, (debugfile, "hcache_lmdb_store: mdb_get_w_txn: %s\n",
- mdb_strerror(rc)));
+ mutt_debug (2, "hcache_lmdb_store: mdb_get_w_txn: %s\n", mdb_strerror(rc));
return rc;
}
rc = mdb_put(ctx->txn, ctx->db, &dkey, &databuf, 0);
if (rc != MDB_SUCCESS)
{
- dprint(2, (debugfile, "hcahce_lmdb_store: mdb_put: %s\n",
- mdb_strerror(rc)));
+ mutt_debug (2, "hcahce_lmdb_store: mdb_put: %s\n", mdb_strerror(rc));
mdb_txn_abort(ctx->txn);
ctx->txn_mode = txn_uninitialized;
ctx->txn = NULL;
rc = mdb_get_w_txn(ctx);
if (rc != MDB_SUCCESS)
{
- dprint(2, (debugfile, "hcache_lmdb_delete: mdb_get_w_txn: %s\n",
- mdb_strerror(rc)));
+ mutt_debug (2, "hcache_lmdb_delete: mdb_get_w_txn: %s\n", mdb_strerror(rc));
return rc;
}
rc = mdb_del(ctx->txn, ctx->db, &dkey, NULL);
{
if (rc != MDB_NOTFOUND)
{
- dprint(2, (debugfile, "hcache_lmdb_delete: mdb_del: %s\n",
- mdb_strerror(rc)));
+ mutt_debug (2, "hcache_lmdb_delete: mdb_del: %s\n", mdb_strerror(rc));
mdb_txn_abort(ctx->txn);
ctx->txn_mode = txn_uninitialized;
ctx->txn = NULL;
{
#ifdef DEBUG
int ecode = tcbdbecode (db);
- dprint (2, (debugfile, "tcbdbopen failed for %s: %s (ecode %d)\n", path, tcbdberrmsg (ecode), ecode));
+ mutt_debug (2, "tcbdbopen failed for %s: %s (ecode %d)\n",
+ path, tcbdberrmsg (ecode), ecode);
#endif
tcbdbdel(db);
return NULL;
{
#ifdef DEBUG
int ecode = tcbdbecode (db);
- dprint (2, (debugfile, "tcbdbclose failed: %s (ecode %d)\n", tcbdberrmsg (ecode), ecode));
+ mutt_debug (2, "tcbdbclose failed: %s (ecode %d)\n",
+ tcbdberrmsg (ecode), ecode);
#endif
}
tcbdbdel(db);
stat (path, &st);
if (mtime == st.st_mtime)
{
- dprint (1, (debugfile, "ci_edit_headers(): temp file was not modified.\n"));
+ mutt_debug (1, "ci_edit_headers(): temp file was not modified.\n");
/* the file has not changed! */
mutt_unlink (path);
return;
label_delete (label->data);
}
- dprint(1, (debugfile, "--label %s: %d\n", label->data, count));
+ mutt_debug (1, "--label %s: %d\n", label->data, count);
}
}
hash_insert(Labels, dup_label, (void *) count, 0);
}
- dprint(1, (debugfile, "++label %s: %d\n", label->data, count));
+ mutt_debug (1, "++label %s: %d\n", label->data, count);
}
}
if (! method[0])
continue;
- dprint (2, (debugfile, "imap_authenticate: Trying method %s\n", method));
+ mutt_debug (2, "imap_authenticate: Trying method %s\n", method);
authenticator = imap_authenticators;
while (authenticator->authenticate)
else
{
/* Fall back to default: any authenticator */
- dprint (2, (debugfile, "imap_authenticate: Using any available method.\n"));
+ mutt_debug (2, "imap_authenticate: Using any available method.\n");
authenticator = imap_authenticators;
while (authenticator->authenticate)
if (rc != IMAP_CMD_RESPOND)
{
- dprint (1, (debugfile, "Invalid response from server.\n"));
+ mutt_debug (1, "Invalid response from server.\n");
goto bail;
}
if (rc != IMAP_CMD_OK)
{
- dprint (1, (debugfile, "Error receiving server response.\n"));
+ mutt_debug (1, "Error receiving server response.\n");
goto bail;
}
if (rc != IMAP_CMD_RESPOND)
{
- dprint (1, (debugfile, "Invalid response from server: %s\n", ibuf));
+ mutt_debug (1, "Invalid response from server: %s\n", ibuf);
goto bail;
}
if ((len = mutt_from_base64 (obuf, idata->buf + 2)) == -1)
{
- dprint (1, (debugfile, "Error decoding base64 response.\n"));
+ mutt_debug (1, "Error decoding base64 response.\n");
goto bail;
}
obuf[len] = '\0';
- dprint (2, (debugfile, "CRAM challenge: %s\n", obuf));
+ mutt_debug (2, "CRAM challenge: %s\n", obuf);
/* The client makes note of the data and then responds with a string
* consisting of the user name, a space, and a 'digest'. The latter is
hmac_response[4], hmac_response[5], hmac_response[6], hmac_response[7],
hmac_response[8], hmac_response[9], hmac_response[10], hmac_response[11],
hmac_response[12], hmac_response[13], hmac_response[14], hmac_response[15]);
- dprint(2, (debugfile, "CRAM response: %s\n", obuf));
+ mutt_debug (2, "CRAM response: %s\n", obuf);
/* XXX - ibuf must be long enough to store the base64 encoding of obuf,
* plus the additional debris
if (rc != IMAP_CMD_OK)
{
- dprint (1, (debugfile, "Error receiving server response.\n"));
+ mutt_debug (1, "Error receiving server response.\n");
goto bail;
}
}
} while (!GSS_ERROR(maj_stat) && msg_ctx != 0);
- dprint (2, (debugfile, "((%s:%d )(%s:%d))", buf_maj, err_maj, buf_min, err_min));
+ mutt_debug (2, "((%s:%d )(%s:%d))", buf_maj, err_maj, buf_min, err_min);
}
/* imap_auth_gss: AUTH=GSSAPI support. */
&target_name);
if (maj_stat != GSS_S_COMPLETE)
{
- dprint (2, (debugfile, "Couldn't get service name for [%s]\n", buf1));
+ mutt_debug (2, "Couldn't get service name for [%s]\n", buf1);
return IMAP_AUTH_UNAVAIL;
}
#ifdef DEBUG
{
maj_stat = gss_display_name (&min_stat, target_name, &request_buf,
&mech_name);
- dprint (2, (debugfile, "Using service name [%s]\n",
- (char*) request_buf.value));
+ mutt_debug (2, "Using service name [%s]\n", (char*) request_buf.value);
maj_stat = gss_release_buffer (&min_stat, &request_buf);
}
#endif
if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED)
{
print_gss_error(maj_stat, min_stat);
- dprint (1, (debugfile, "Error acquiring credentials - no TGT?\n"));
+ mutt_debug (1, "Error acquiring credentials - no TGT?\n");
gss_release_name (&min_stat, &target_name);
return IMAP_AUTH_UNAVAIL;
if (rc != IMAP_CMD_RESPOND)
{
- dprint (2, (debugfile, "Invalid response from server: %s\n", buf1));
+ mutt_debug (2, "Invalid response from server: %s\n", buf1);
gss_release_name (&min_stat, &target_name);
goto bail;
}
/* now start the security context initialisation loop... */
- dprint (2, (debugfile, "Sending credentials\n"));
+ mutt_debug (2, "Sending credentials\n");
mutt_to_base64 (buf1, send_token.value, send_token.length,
sizeof (buf1) - 2);
gss_release_buffer (&min_stat, &send_token);
if (rc != IMAP_CMD_RESPOND)
{
- dprint (1, (debugfile, "Error receiving server response.\n"));
+ mutt_debug (1, "Error receiving server response.\n");
gss_release_name (&min_stat, &target_name);
goto bail;
}
if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED)
{
print_gss_error(maj_stat, min_stat);
- dprint (1, (debugfile, "Error exchanging credentials\n"));
+ mutt_debug (1, "Error exchanging credentials\n");
gss_release_name (&min_stat, &target_name);
goto err_abort_cmd;
if (rc != IMAP_CMD_RESPOND)
{
- dprint (1, (debugfile, "Error receiving server response.\n"));
+ mutt_debug (1, "Error receiving server response.\n");
goto bail;
}
request_buf.length = mutt_from_base64 (buf2, idata->buf + 2);
if (maj_stat != GSS_S_COMPLETE)
{
print_gss_error(maj_stat, min_stat);
- dprint (2, (debugfile, "Couldn't unwrap security level data\n"));
+ mutt_debug (2, "Couldn't unwrap security level data\n");
gss_release_buffer (&min_stat, &send_token);
goto err_abort_cmd;
}
- dprint (2, (debugfile, "Credential exchange complete\n"));
+ mutt_debug (2, "Credential exchange complete\n");
/* first octet is security levels supported. We want NONE */
#ifdef DEBUG
#endif
if ( !(((char*) send_token.value)[0] & GSS_AUTH_P_NONE) )
{
- dprint (2, (debugfile, "Server requires integrity or privacy\n"));
+ mutt_debug (2, "Server requires integrity or privacy\n");
gss_release_buffer (&min_stat, &send_token);
goto err_abort_cmd;
}
((char*) send_token.value)[0] = 0;
buf_size = ntohl (*((long *) send_token.value));
gss_release_buffer (&min_stat, &send_token);
- dprint (2, (debugfile, "Unwrapped security level flags: %c%c%c\n",
- server_conf_flags & GSS_AUTH_P_NONE ? 'N' : '-',
- server_conf_flags & GSS_AUTH_P_INTEGRITY ? 'I' : '-',
- server_conf_flags & GSS_AUTH_P_PRIVACY ? 'P' : '-'));
- dprint (2, (debugfile, "Maximum GSS token size is %ld\n", buf_size));
+ mutt_debug (2, "Unwrapped security level flags: %c%c%c\n",
+ server_conf_flags & GSS_AUTH_P_NONE ? 'N' : '-',
+ server_conf_flags & GSS_AUTH_P_INTEGRITY ? 'I' : '-',
+ server_conf_flags & GSS_AUTH_P_PRIVACY ? 'P' : '-');
+ mutt_debug (2, "Maximum GSS token size is %ld\n", buf_size);
/* agree to terms (hack!) */
buf_size = htonl (buf_size); /* not relevant without integrity/privacy */
&cflags, &send_token);
if (maj_stat != GSS_S_COMPLETE)
{
- dprint (2, (debugfile, "Error creating login request\n"));
+ mutt_debug (2, "Error creating login request\n");
goto err_abort_cmd;
}
mutt_to_base64 (buf1, send_token.value, send_token.length,
sizeof (buf1) - 2);
- dprint (2, (debugfile, "Requesting authorisation as %s\n",
- idata->conn->account.user));
+ mutt_debug (2, "Requesting authorisation as %s\n",
+ idata->conn->account.user);
safe_strcat (buf1, sizeof (buf1), "\r\n");
mutt_socket_write (idata->conn, buf1);
while (rc == IMAP_CMD_CONTINUE);
if (rc == IMAP_CMD_RESPOND)
{
- dprint (1, (debugfile, "Unexpected server continuation request.\n"));
+ mutt_debug (1, "Unexpected server continuation request.\n");
goto err_abort_cmd;
}
if (imap_code (idata->buf))
{
/* flush the security context */
- dprint (2, (debugfile, "Releasing GSS credentials\n"));
+ mutt_debug (2, "Releasing GSS credentials\n");
maj_stat = gss_delete_sec_context (&min_stat, &context, &send_token);
if (maj_stat != GSS_S_COMPLETE)
- dprint (1, (debugfile, "Error releasing credentials\n"));
+ mutt_debug (1, "Error releasing credentials\n");
/* send_token may contain a notification to the server to flush
* credentials. RFC 1731 doesn't specify what to do, and since this
* of 5 or higher */
if (debuglevel < IMAP_LOG_PASS)
- dprint (2, (debugfile, "Sending LOGIN command for %s...\n",
- idata->conn->account.user));
+ mutt_debug (2, "Sending LOGIN command for %s...\n",
+ idata->conn->account.user);
#endif
snprintf (buf, sizeof (buf), "LOGIN %s %s", q_user, q_pass);
if (mutt_sasl_client_new (idata->conn, &saslconn) < 0)
{
- dprint (1, (debugfile,
- "imap_auth_sasl: Error allocating SASL connection.\n"));
+ mutt_debug (1, "imap_auth_sasl: Error allocating SASL connection.\n");
return IMAP_AUTH_FAILURE;
}
if (rc != SASL_OK && rc != SASL_CONTINUE)
{
if (method)
- dprint (2, (debugfile, "imap_auth_sasl: %s unavailable\n", method));
+ mutt_debug (2, "imap_auth_sasl: %s unavailable\n", method);
else
- dprint (1, (debugfile, "imap_auth_sasl: Failure starting authentication exchange. No shared mechanisms?\n"));
+ mutt_debug (1, "imap_auth_sasl: Failure starting authentication exchange. "
+ "No shared mechanisms?\n");
/* SASL doesn't support LOGIN, so fall back */
return IMAP_AUTH_UNAVAIL;
buf[len++] = ' ';
if (sasl_encode64 (pc, olen, buf + len, bufsize - len, &olen) != SASL_OK)
{
- dprint (1, (debugfile, "imap_auth_sasl: error base64-encoding client response.\n"));
+ mutt_debug (1, "imap_auth_sasl: error base64-encoding client response.\n");
goto bail;
}
client_start = olen = 0;
* include space for the trailing null */
if (sasl_decode64 (idata->buf+2, len, buf, bufsize - 1, &len) != SASL_OK)
{
- dprint (1, (debugfile, "imap_auth_sasl: error base64-decoding server response.\n"));
+ mutt_debug (1, "imap_auth_sasl: error base64-decoding server response.\n");
goto bail;
}
}
}
if (sasl_encode64 (pc, olen, buf, bufsize, &olen) != SASL_OK)
{
- dprint (1, (debugfile, "imap_auth_sasl: error base64-encoding client response.\n"));
+ mutt_debug (1, "imap_auth_sasl: error base64-encoding client response.\n");
goto bail;
}
}
if (rc < 0)
{
mutt_socket_write (idata->conn, "*\r\n");
- dprint (1, (debugfile, "imap_auth_sasl: sasl_client_step error %d\n",rc));
+ mutt_debug (1, "imap_auth_sasl: sasl_client_step error %d\n", rc);
}
olen = 0;
if (method)
{
- dprint (2, (debugfile, "imap_auth_sasl: %s failed\n", method));
+ mutt_debug (2, "imap_auth_sasl: %s failed\n", method);
return IMAP_AUTH_UNAVAIL;
}
if (n)
{
int rc;
- dprint (3, (debugfile, "imap_browse: mbox: %s\n", mbox));
+ mutt_debug (3, "imap_browse: mbox: %s\n", mbox);
/* if our target exists and has inferiors, enter it if we
* aren't already going to */
if (showparents)
{
- dprint (3, (debugfile, "imap_init_browse: adding parent %s\n", mbox));
+ mutt_debug (3, "imap_init_browse: adding parent %s\n", mbox);
imap_add_folder (list.delim, mbox, 1, 0, state, 1);
}
state->folder = safe_strdup (buf);
}
- dprint (3, (debugfile, "imap_browse: Quoting mailbox scan: %s -> ", mbox));
+ mutt_debug (3, "imap_browse: Quoting mailbox scan: %s -> ", mbox);
snprintf (buf, sizeof (buf), "%s%%", mbox);
imap_munge_mbox_name (idata, munged_mbox, sizeof (munged_mbox), buf);
- dprint (3, (debugfile, "%s\n", munged_mbox));
+ mutt_debug (3, "%s\n", munged_mbox);
snprintf (buf, sizeof (buf), "%s \"\" %s", list_cmd, munged_mbox);
if (browse_add_list_result (idata, buf, state, 0))
goto fail;
if (imap_parse_path (folder, &mx) < 0)
{
- dprint (1, (debugfile, "imap_mailbox_create: Bad starting path %s\n",
- folder));
+ mutt_debug (1, "imap_mailbox_create: Bad starting path %s\n", folder);
return -1;
}
if (!(idata = imap_conn_find (&mx.account, MUTT_IMAP_CONN_NONEW)))
{
- dprint (1, (debugfile, "imap_mailbox_create: Couldn't find open connection to %s", mx.account.host));
+ mutt_debug (1, "imap_mailbox_create: Couldn't find open connection to %s",
+ mx.account.host);
goto fail;
}
if (imap_parse_path (mailbox, &mx) < 0)
{
- dprint (1, (debugfile, "imap_mailbox_rename: Bad source mailbox %s\n",
- mailbox));
+ mutt_debug (1, "imap_mailbox_rename: Bad source mailbox %s\n", mailbox);
return -1;
}
if (!(idata = imap_conn_find (&mx.account, MUTT_IMAP_CONN_NONEW)))
{
- dprint (1, (debugfile, "imap_mailbox_rename: Couldn't find open connection to %s", mx.account.host));
+ mutt_debug (1, "imap_mailbox_rename: Couldn't find open connection to %s",
+ mx.account.host);
goto fail;
}
if (imap_parse_path (state->folder, &mx))
{
- dprint (2, (debugfile,
- "browse_add_list_result: current folder %s makes no sense\n", state->folder));
+ mutt_debug (2, "browse_add_list_result: current folder %s makes no sense\n",
+ state->folder);
return -1;
}
{
safe_realloc (&idata->buf, idata->blen + IMAP_CMD_BUFSIZE);
idata->blen = idata->blen + IMAP_CMD_BUFSIZE;
- dprint (3, (debugfile, "imap_cmd_step: grew buffer to %u bytes\n",
- idata->blen));
+ mutt_debug (3, "imap_cmd_step: grew buffer to %u bytes\n", idata->blen);
}
/* back up over '\0' */
c = mutt_socket_readln (idata->buf + len, idata->blen - len, idata->conn);
if (c <= 0)
{
- dprint (1, (debugfile, "imap_cmd_step: Error reading server response.\n"));
+ mutt_debug (1, "imap_cmd_step: Error reading server response.\n");
cmd_handle_fatal (idata);
return IMAP_CMD_BAD;
}
{
safe_realloc (&idata->buf, IMAP_CMD_BUFSIZE);
idata->blen = IMAP_CMD_BUFSIZE;
- dprint (3, (debugfile, "imap_cmd_step: shrank buffer to %u bytes\n", idata->blen));
+ mutt_debug (3, "imap_cmd_step: shrank buffer to %u bytes\n", idata->blen);
}
idata->lastread = time (NULL);
rc = IMAP_CMD_CONTINUE;
else
{
- dprint (3, (debugfile, "IMAP queue drained\n"));
+ mutt_debug (3, "IMAP queue drained\n");
imap_cmd_finish (idata);
}
if (!s)
{
- dprint (2, (debugfile, "imap_cmd_trailer: not a tagged response"));
+ mutt_debug (2, "imap_cmd_trailer: not a tagged response");
return notrailer;
}
ascii_strncasecmp (s, "NO", 2) &&
ascii_strncasecmp (s, "BAD", 3)))
{
- dprint (2, (debugfile, "imap_cmd_trailer: not a command completion: %s",
- idata->buf));
+ mutt_debug (2, "imap_cmd_trailer: not a command completion: %s",
+ idata->buf);
return notrailer;
}
if ((flags & IMAP_CMD_FAIL_OK) && idata->status != IMAP_FATAL)
return -2;
- dprint (1, (debugfile, "imap_exec: command failed: %s\n", idata->buf));
+ mutt_debug (1, "imap_exec: command failed: %s\n", idata->buf);
return -1;
}
&& count > idata->ctx->msgcount)
{
/* read new mail messages */
- dprint (2, (debugfile, "imap_cmd_finish: Fetching new mail\n"));
+ mutt_debug (2, "imap_cmd_finish: Fetching new mail\n");
/* check_status: curs_main uses imap_check_mailbox to detect
* whether the index needs updating */
idata->check_status = IMAP_NEWMAIL_PENDING;
}
else if (idata->reopen & IMAP_EXPUNGE_PENDING)
{
- dprint (2, (debugfile, "imap_cmd_finish: Expunging mailbox\n"));
+ mutt_debug (2, "imap_cmd_finish: Expunging mailbox\n");
imap_expunge_mailbox (idata);
/* Detect whether we've gotten unexpected EXPUNGE messages */
if ((idata->reopen & IMAP_EXPUNGE_PENDING) &&
}
if (rc != IMAP_CMD_OK)
{
- dprint (1, (debugfile, "imap_cmd_idle: error starting IDLE\n"));
+ mutt_debug (1, "imap_cmd_idle: error starting IDLE\n");
return -1;
}
if (cmd_queue_full (idata))
{
- dprint (3, (debugfile, "cmd_new: IMAP command queue full\n"));
+ mutt_debug (3, "cmd_new: IMAP command queue full\n");
return NULL;
}
if (cmd_queue_full (idata))
{
- dprint (3, (debugfile, "Draining IMAP command pipeline\n"));
+ mutt_debug (3, "Draining IMAP command pipeline\n");
rc = imap_exec (idata, NULL, IMAP_CMD_FAIL_OK);
*/
if (ascii_strncasecmp ("EXISTS", s, 6) == 0)
{
- dprint (2, (debugfile, "Handling EXISTS\n"));
+ mutt_debug (2, "Handling EXISTS\n");
/* new mail arrived */
count = atoi (pn);
{
/* Notes 6.0.3 has a tendency to report fewer messages exist than
* it should. */
- dprint (1, (debugfile, "Message count is out of sync"));
+ mutt_debug (1, "Message count is out of sync");
return 0;
}
/* at least the InterChange server sends EXISTS messages freely,
* even when there is no new mail */
else if (count == idata->ctx->msgcount)
- dprint (3, (debugfile,
- "cmd_handle_untagged: superfluous EXISTS message.\n"));
+ mutt_debug (3, "cmd_handle_untagged: superfluous EXISTS message.\n");
else
{
if (!(idata->reopen & IMAP_EXPUNGE_PENDING))
{
- dprint (2, (debugfile,
- "cmd_handle_untagged: New mail in %s - %d messages total.\n",
- idata->mailbox, count));
+ mutt_debug (2,
+ "cmd_handle_untagged: New mail in %s - %d messages total.\n",
+ idata->mailbox, count);
idata->reopen |= IMAP_NEWMAIL_PENDING;
}
idata->newMailCount = count;
cmd_parse_enabled (idata, s);
else if (ascii_strncasecmp ("BYE", s, 3) == 0)
{
- dprint (2, (debugfile, "Handling BYE\n"));
+ mutt_debug (2, "Handling BYE\n");
/* check if we're logging out */
if (idata->status == IMAP_BYE)
}
else if (option (OPTIMAPSERVERNOISE) && (ascii_strncasecmp ("NO", s, 2) == 0))
{
- dprint (2, (debugfile, "Handling untagged NO\n"));
+ mutt_debug (2, "Handling untagged NO\n");
/* Display the warning message from the server */
mutt_error ("%s", s+3);
int x;
char* bracket;
- dprint (3, (debugfile, "Handling CAPABILITY\n"));
+ mutt_debug (3, "Handling CAPABILITY\n");
s = imap_next_word (s);
if ((bracket = strchr (s, ']')))
int expno, cur;
HEADER* h;
- dprint (2, (debugfile, "Handling EXPUNGE\n"));
+ mutt_debug (2, "Handling EXPUNGE\n");
expno = atoi (s);
int msgno, cur;
HEADER* h = NULL;
- dprint (3, (debugfile, "Handling FETCH\n"));
+ mutt_debug (3, "Handling FETCH\n");
msgno = atoi (s);
if (h && h->active && h->index+1 == msgno)
{
- dprint (2, (debugfile, "Message UID %d updated\n", HEADER_DATA(h)->uid));
+ mutt_debug (2, "Message UID %d updated\n", HEADER_DATA(h)->uid);
break;
}
if (!h)
{
- dprint (3, (debugfile, "FETCH response ignored for this message\n"));
+ mutt_debug (3, "FETCH response ignored for this message\n");
return;
}
if (*s != '(')
{
- dprint (1, (debugfile, "Malformed FETCH response"));
+ mutt_debug (1, "Malformed FETCH response");
return;
}
s++;
if (ascii_strncasecmp ("FLAGS", s, 5) != 0)
{
- dprint (2, (debugfile, "Only handle FLAGS updates\n"));
+ mutt_debug (2, "Only handle FLAGS updates\n");
return;
}
s = imap_next_word (s);
if (*s != '(')
{
- dprint (1, (debugfile, "Bad LIST response\n"));
+ mutt_debug (1, "Bad LIST response\n");
return;
}
s++;
if (list->name[0] == '\0')
{
idata->delim = list->delim;
- dprint (3, (debugfile, "Root delimiter: %c\n", idata->delim));
+ mutt_debug (3, "Root delimiter: %c\n", idata->delim);
}
}
if (!list.name || list.noselect)
return;
- dprint (3, (debugfile, "Subscribing to %s\n", list.name));
+ mutt_debug (3, "Subscribing to %s\n", list.name);
strfcpy (buf, "mailboxes \"", sizeof (buf));
mutt_account_tourl (&idata->conn->account, &url);
err.data = errstr;
err.dsize = sizeof (errstr);
if (mutt_parse_rc_line (buf, &token, &err))
- dprint (1, (debugfile, "Error adding subscribed mailbox: %s\n", errstr));
+ mutt_debug (1, "Error adding subscribed mailbox: %s\n", errstr);
FREE (&token.data);
}
/* cmd_parse_myrights: set rights bits according to MYRIGHTS response */
static void cmd_parse_myrights (IMAP_DATA* idata, const char* s)
{
- dprint (2, (debugfile, "Handling MYRIGHTS\n"));
+ mutt_debug (2, "Handling MYRIGHTS\n");
s = imap_next_word ((char*)s);
s = imap_next_word ((char*)s);
mutt_bit_set (idata->ctx->rights, MUTT_ACL_EXPUNGE);
break;
default:
- dprint(1, (debugfile, "Unknown right: %c\n", *s));
+ mutt_debug (1, "Unknown right: %c\n", *s);
}
s++;
}
unsigned int uid;
int msgno;
- dprint (2, (debugfile, "Handling SEARCH\n"));
+ mutt_debug (2, "Handling SEARCH\n");
while ((s = imap_next_word ((char*)s)) && *s != '\0')
{
if (*s++ != '(')
{
- dprint (1, (debugfile, "Error parsing STATUS\n"));
+ mutt_debug (1, "Error parsing STATUS\n");
return;
}
while (*s && *s != ')')
if (*s && *s != ')')
s = imap_next_word (s);
}
- dprint (3, (debugfile, "%s (UIDVALIDITY: %d, UIDNEXT: %d) %d messages, %d recent, %d unseen\n",
+ mutt_debug (3, "%s (UIDVALIDITY: %d, UIDNEXT: %d) %d messages, %d recent, %d unseen\n",
status->name, status->uidvalidity, status->uidnext,
- status->messages, status->recent, status->unseen));
+ status->messages, status->recent, status->unseen);
/* caller is prepared to handle the result herself */
if (idata->cmddata && idata->cmdtype == IMAP_CT_STATUS)
return;
}
- dprint (3, (debugfile, "Running default STATUS handler\n"));
+ mutt_debug (3, "Running default STATUS handler\n");
/* should perhaps move this code back to imap_buffy_check */
for (inc = Incoming; inc; inc = inc->next)
if (imap_parse_path (inc->path, &mx) < 0)
{
- dprint (1, (debugfile, "Error parsing mailbox %s, skipping\n", inc->path));
+ mutt_debug (1, "Error parsing mailbox %s, skipping\n", inc->path);
continue;
}
- /* dprint (2, (debugfile, "Buffy entry: [%s] mbox: [%s]\n", inc->path, NONULL(mx.mbox))); */
+ /* mutt_debug (2, "Buffy entry: [%s] mbox: [%s]\n", inc->path, NONULL(mx.mbox)); */
if (imap_account_match (&idata->conn->account, &mx.account))
{
if (value && !imap_mxcmp (mailbox, value))
{
- dprint (3, (debugfile, "Found %s in buffy list (OV: %d ON: %d U: %d)\n",
- mailbox, olduv, oldun, status->unseen));
+ mutt_debug (3, "Found %s in buffy list (OV: %d ON: %d U: %d)\n",
+ mailbox, olduv, oldun, status->unseen);
if (option(OPTMAILCHECKRECENT))
{
/* cmd_parse_enabled: record what the server has enabled */
static void cmd_parse_enabled (IMAP_DATA* idata, const char* s)
{
- dprint (2, (debugfile, "Handling ENABLED\n"));
+ mutt_debug (2, "Handling ENABLED\n");
while ((s = imap_next_word ((char*)s)) && *s != '\0')
{
if (imap_mboxcache_get (idata, mailbox, 0))
{
- dprint (3, (debugfile, "imap_access: found %s in cache\n", mailbox));
+ mutt_debug (3, "imap_access: found %s in cache\n", mailbox);
return 0;
}
snprintf (buf, sizeof (buf), "STATUS %s (UID-VALIDITY)", mbox);
else
{
- dprint (2, (debugfile, "imap_access: STATUS not supported?\n"));
+ mutt_debug (2, "imap_access: STATUS not supported?\n");
return -1;
}
if ((rc = imap_exec (idata, buf, IMAP_CMD_FAIL_OK)) < 0)
{
- dprint (1, (debugfile, "imap_access: Can't check STATUS of %s\n", mbox));
+ mutt_debug (1, "imap_access: Can't check STATUS of %s\n", mbox);
return rc;
}
int r = 0;
- dprint (2, (debugfile, "imap_read_literal: reading %ld bytes\n", bytes));
+ mutt_debug (2, "imap_read_literal: reading %ld bytes\n", bytes);
for (pos = 0; pos < bytes; pos++)
{
if (mutt_socket_readchar (idata->conn, &c) != 1)
{
- dprint (1, (debugfile, "imap_read_literal: error during read, %ld bytes read\n", pos));
+ mutt_debug (1, "imap_read_literal: error during read, %ld bytes read\n",
+ pos);
idata->status = IMAP_FATAL;
return -1;
if (h->index == -1)
{
- dprint (2, (debugfile, "Expunging message UID %d.\n", HEADER_DATA (h)->uid));
+ mutt_debug (2, "Expunging message UID %d.\n", HEADER_DATA (h)->uid);
h->active = 0;
idata->ctx->size -= h->content->length;
FREE (&idata->capstr);
new = 1;
if (idata->conn->ssf)
- dprint (2, (debugfile, "Communication encrypted at %d bits\n",
- idata->conn->ssf));
+ mutt_debug (2, "Communication encrypted at %d bits\n",
+ idata->conn->ssf);
}
else
mutt_account_unsetpass (&idata->conn->account);
/* sanity-check string */
if (ascii_strncasecmp ("FLAGS", s, 5) != 0)
{
- dprint (1, (debugfile, "imap_get_flags: not a FLAGS response: %s\n",
- s));
+ mutt_debug (1, "imap_get_flags: not a FLAGS response: %s\n", s);
return NULL;
}
s += 5;
SKIPWS(s);
if (*s != '(')
{
- dprint (1, (debugfile, "imap_get_flags: bogus FLAGS response: %s\n",
- s));
+ mutt_debug (1, "imap_get_flags: bogus FLAGS response: %s\n", s);
return NULL;
}
/* note bad flags response */
if (*s != ')')
{
- dprint (1, (debugfile,
- "imap_get_flags: Unterminated FLAGS response: %s\n", s));
+ mutt_debug (1, "imap_get_flags: Unterminated FLAGS response: %s\n", s);
mutt_free_list (hflags);
return NULL;
/* don't override PERMANENTFLAGS */
if (!idata->flags)
{
- dprint (3, (debugfile, "Getting mailbox FLAGS\n"));
+ mutt_debug (3, "Getting mailbox FLAGS\n");
if ((pc = imap_get_flags (&(idata->flags), pc)) == NULL)
goto fail;
}
/* PERMANENTFLAGS are massaged to look like FLAGS, then override FLAGS */
else if (ascii_strncasecmp ("OK [PERMANENTFLAGS", pc, 18) == 0)
{
- dprint (3, (debugfile, "Getting mailbox PERMANENTFLAGS\n"));
+ mutt_debug (3, "Getting mailbox PERMANENTFLAGS\n");
/* safe to call on NULL */
mutt_free_list (&(idata->flags));
/* skip "OK [PERMANENT" so syntax is the same as FLAGS */
/* save UIDVALIDITY for the header cache */
else if (ascii_strncasecmp ("OK [UIDVALIDITY", pc, 14) == 0)
{
- dprint (3, (debugfile, "Getting mailbox UIDVALIDITY\n"));
+ mutt_debug (3, "Getting mailbox UIDVALIDITY\n");
pc += 3;
pc = imap_next_word (pc);
idata->uid_validity = strtol (pc, NULL, 10);
}
else if (ascii_strncasecmp ("OK [UIDNEXT", pc, 11) == 0)
{
- dprint (3, (debugfile, "Getting mailbox UIDNEXT\n"));
+ mutt_debug (3, "Getting mailbox UIDNEXT\n");
pc += 3;
pc = imap_next_word (pc);
idata->uidnext = strtol (pc, NULL, 10);
if (!ascii_strncasecmp (imap_get_qualifier (idata->buf), "[READ-ONLY]", 11) \
&& !mutt_bit_isset (idata->capabilities, ACL))
{
- dprint (2, (debugfile, "Mailbox is read-only.\n"));
+ mutt_debug (2, "Mailbox is read-only.\n");
ctx->readonly = 1;
}
if (debuglevel > 2)
{
if (!idata->flags)
- dprint (3, (debugfile, "No folder flags found\n"));
+ mutt_debug (3, "No folder flags found\n");
else
{
LIST* t = idata->flags;
- dprint (3, (debugfile, "Mailbox flags: "));
+ mutt_debug (3, "Mailbox flags: ");
t = t->next;
while (t)
{
- dprint (3, (debugfile, "[%s] ", t->data));
+ mutt_debug (3, "[%s] ", t->data);
t = t->next;
}
- dprint (3, (debugfile, "\n"));
+ mutt_debug (3, "\n");
}
}
#endif
goto fail;
}
- dprint (2, (debugfile, "imap_open_mailbox: msgcount is %d\n", ctx->msgcount));
+ mutt_debug (2, "imap_open_mailbox: msgcount is %d\n", ctx->msgcount);
FREE (&mx.mbox);
return 0;
if (! (cmd = mutt_buffer_new ()))
{
- dprint (1, (debugfile, "imap_exec_msgset: unable to allocate buffer\n"));
+ mutt_debug (1, "imap_exec_msgset: unable to allocate buffer\n");
return -1;
}
if (idata->state < IMAP_SELECTED)
{
- dprint (2, (debugfile, "imap_sync_mailbox: no mailbox selected\n"));
+ mutt_debug (2, "imap_sync_mailbox: no mailbox selected\n");
return -1;
}
if (!appendctx)
appendctx = mx_open_mailbox (ctx->path, MUTT_APPEND | MUTT_QUIET, NULL);
if (!appendctx)
- dprint (1, (debugfile, "imap_sync_mailbox: Error opening mailbox in append mode\n"));
+ mutt_debug (1, "imap_sync_mailbox: Error opening mailbox in append mode\n");
else
_mutt_save_message (h, appendctx, 1, 0, 0);
h->label_changed = 0;
{
if (imap_cmd_step (idata) != IMAP_CMD_CONTINUE)
{
- dprint (1, (debugfile, "Error reading IDLE response\n"));
+ mutt_debug (1, "Error reading IDLE response\n");
return -1;
}
}
if (result < 0)
{
- dprint (1, (debugfile, "Poll failed, disabling IDLE\n"));
+ mutt_debug (1, "Poll failed, disabling IDLE\n");
mutt_bit_unset (idata->capabilities, IDLE);
}
}
if (imap_parse_path (path, &mx))
{
- dprint (1, (debugfile, "imap_get_mailbox: Error parsing %s\n", path));
+ mutt_debug (1, "imap_get_mailbox: Error parsing %s\n", path);
return -1;
}
if (!(*hidata = imap_conn_find (&(mx.account), option (OPTIMAPPASSIVE) ? MUTT_IMAP_CONN_NONEW : 0))
if (!mutt_bit_isset (idata->capabilities, IMAP4REV1) &&
!mutt_bit_isset (idata->capabilities, STATUS))
{
- dprint (2, (debugfile, "Server doesn't support STATUS\n"));
+ mutt_debug (2, "Server doesn't support STATUS\n");
continue;
}
/* Send commands to previous server. Sorting the buffy list
* may prevent some infelicitous interleavings */
if (imap_exec (lastdata, NULL, IMAP_CMD_FAIL_OK) == -1)
- dprint (1, (debugfile, "Error polling mailboxes\n"));
+ mutt_debug (1, "Error polling mailboxes\n");
lastdata = NULL;
}
if (imap_exec (idata, command, IMAP_CMD_QUEUE) < 0)
{
- dprint (1, (debugfile, "Error queueing command\n"));
+ mutt_debug (1, "Error queueing command\n");
return 0;
}
}
if (lastdata && (imap_exec (lastdata, NULL, IMAP_CMD_FAIL_OK) == -1))
{
- dprint (1, (debugfile, "Error polling mailboxes\n"));
+ mutt_debug (1, "Error polling mailboxes\n");
return 0;
}
}
status->uidvalidity = *(unsigned int *)uidvalidity;
status->uidnext = uidnext ? *(unsigned int *)uidnext: 0;
- dprint (3, (debugfile, "mboxcache: hcache uidvalidity %d, uidnext %d\n",
- status->uidvalidity, status->uidnext));
+ mutt_debug (3, "mboxcache: hcache uidvalidity %d, uidnext %d\n",
+ status->uidvalidity, status->uidnext);
}
mutt_hcache_free (hc, &uidvalidity);
mutt_hcache_free (hc, &uidnext);
snprintf (mbox, sizeof (mbox), "%smailboxes \"%s\"",
subscribe ? "" : "un", path);
if (mutt_parse_rc_line (mbox, &token, &err))
- dprint (1, (debugfile, "Error adding subscribed mailbox: %s\n", errstr));
+ mutt_debug (1, "Error adding subscribed mailbox: %s\n", errstr);
FREE (&token.data);
}
if (imap_parse_path (dest, &mx))
{
- dprint (1, (debugfile, "imap_fast_trash: bad destination %s\n", dest));
+ mutt_debug (1, "imap_fast_trash: bad destination %s\n", dest);
return -1;
}
/* check that the save-to folder is in the same account */
if (!mutt_account_match (&(idata->conn->account), &(mx.account)))
{
- dprint (3, (debugfile, "imap_fast_trash: %s not same server as %s\n",
- dest, ctx->path));
+ mutt_debug (3, "imap_fast_trash: %s not same server as %s\n",
+ dest, ctx->path);
return 1;
}
MUTT_TRASH, 0, 0);
if (rc < 0)
{
- dprint (1, (debugfile, "imap_fast_trash: Unable to mark messages as seen\n"));
+ mutt_debug (1, "imap_fast_trash: Unable to mark messages as seen\n");
goto out;
}
rc = imap_exec_msgset (idata, "UID COPY", mmbox, MUTT_TRASH, 0, 0);
if (!rc)
{
- dprint (1, (debugfile, "imap_fast_trash: No messages to trash\n"));
+ mutt_debug (1, "imap_fast_trash: No messages to trash\n");
rc = -1;
goto out;
}
else if (rc < 0)
{
- dprint (1, (debugfile, "could not queue copy\n"));
+ mutt_debug (1, "could not queue copy\n");
goto out;
}
else
{
if (triedcreate)
{
- dprint (1, (debugfile, "Already tried to create mailbox %s\n", mbox));
+ mutt_debug (1, "Already tried to create mailbox %s\n", mbox);
break;
}
/* bail out if command failed for reasons other than nonexistent target */
if (ascii_strncasecmp (imap_get_qualifier (idata->buf), "[TRYCREATE]", 11))
break;
- dprint (3, (debugfile, "imap_fast_trash: server suggests TRYCREATE\n"));
+ mutt_debug (3, "imap_fast_trash: server suggests TRYCREATE\n");
snprintf (prompt, sizeof (prompt), _("Create %s?"), mbox);
if (option (OPTCONFIRMCREATE) && mutt_yesorno (prompt, 1) != MUTT_YES)
{
if (!h.data->uid)
{
- dprint (2, (debugfile, "imap_read_headers: skipping hcache FETCH "
- "response for unknown message number %d\n", h.sid));
+ mutt_debug (2, "imap_read_headers: skipping hcache FETCH "
+ "response for unknown message number %d\n", h.sid);
mfhrc = -1;
continue;
}
else
{
/* bad header in the cache, we'll have to refetch. */
- dprint (3, (debugfile, "bad cache entry at %d, giving up\n", h.sid - 1));
+ mutt_debug (3, "bad cache entry at %d, giving up\n", h.sid - 1);
imap_free_header_data(&h.data);
evalhc = 0;
idx--;
if (!ftello (fp))
{
- dprint (2, (debugfile, "msg_fetch_header: ignoring fetch response with no body\n"));
+ mutt_debug (2, "msg_fetch_header: ignoring fetch response with no body\n");
mfhrc = -1;
msgend--;
continue;
idx++;
if (idx > msgend)
{
- dprint (1, (debugfile, "imap_read_headers: skipping FETCH response for "
- "unknown message number %d\n", h.sid));
+ mutt_debug (1, "imap_read_headers: skipping FETCH response for "
+ "unknown message number %d\n", h.sid);
mfhrc = -1;
idx--;
continue;
/* May receive FLAGS updates in a separate untagged response (#2935) */
if (idx < ctx->msgcount)
{
- dprint (2, (debugfile, "imap_read_headers: message %d is not new\n",
- h.sid));
+ mutt_debug (2, "imap_read_headers: message %d is not new\n", h.sid);
idx--;
continue;
}
&idata->uid_validity, sizeof (idata->uid_validity));
if (maxuid && idata->uidnext < maxuid + 1)
{
- dprint (2, (debugfile, "Overriding UIDNEXT: %u -> %u\n", idata->uidnext, maxuid + 1));
+ mutt_debug (2, "Overriding UIDNEXT: %u -> %u\n", idata->uidnext, maxuid + 1);
idata->uidnext = maxuid + 1;
}
if (idata->uidnext > 1)
{
char *pc;
- dprint (1, (debugfile, "imap_append_message(): command failed: %s\n",
- idata->buf));
+ mutt_debug (1, "imap_append_message(): command failed: %s\n", idata->buf);
pc = idata->buf + SEQLEN;
SKIPWS (pc);
{
char *pc;
- dprint (1, (debugfile, "imap_append_message(): command failed: %s\n",
- idata->buf));
+ mutt_debug (1, "imap_append_message(): command failed: %s\n", idata->buf);
pc = idata->buf + SEQLEN;
SKIPWS (pc);
pc = imap_next_word (pc);
if (imap_parse_path (dest, &mx))
{
- dprint (1, (debugfile, "imap_copy_messages: bad destination %s\n", dest));
+ mutt_debug (1, "imap_copy_messages: bad destination %s\n", dest);
return -1;
}
/* check that the save-to folder is in the same account */
if (!mutt_account_match (&(idata->conn->account), &(mx.account)))
{
- dprint (3, (debugfile, "imap_copy_messages: %s not same server as %s\n",
- dest, ctx->path));
+ mutt_debug (3, "imap_copy_messages: %s not same server as %s\n",
+ dest, ctx->path);
return 1;
}
if (h && h->attach_del)
{
- dprint (3, (debugfile, "imap_copy_messages: Message contains attachments to be deleted\n"));
+ mutt_debug (3, "imap_copy_messages: Message contains attachments to be deleted\n");
return 1;
}
{
if (ctx->hdrs[n]->tagged && ctx->hdrs[n]->attach_del)
{
- dprint (3, (debugfile, "imap_copy_messages: Message contains attachments to be deleted\n"));
+ mutt_debug (3, "imap_copy_messages: Message contains attachments to be deleted\n");
return 1;
}
rc = imap_sync_message (idata, ctx->hdrs[n], &sync_cmd, &err_continue);
if (rc < 0)
{
- dprint (1, (debugfile, "imap_copy_messages: could not sync\n"));
+ mutt_debug (1, "imap_copy_messages: could not sync\n");
goto out;
}
}
rc = imap_exec_msgset (idata, "UID COPY", mmbox, MUTT_TAG, 0, 0);
if (!rc)
{
- dprint (1, (debugfile, "imap_copy_messages: No messages tagged\n"));
+ mutt_debug (1, "imap_copy_messages: No messages tagged\n");
rc = -1;
goto out;
}
else if (rc < 0)
{
- dprint (1, (debugfile, "could not queue copy\n"));
+ mutt_debug (1, "could not queue copy\n");
goto out;
}
else
rc = imap_sync_message (idata, h, &sync_cmd, &err_continue);
if (rc < 0)
{
- dprint (1, (debugfile, "imap_copy_messages: could not sync\n"));
+ mutt_debug (1, "imap_copy_messages: could not sync\n");
goto out;
}
}
if ((rc = imap_exec (idata, cmd.data, IMAP_CMD_QUEUE)) < 0)
{
- dprint (1, (debugfile, "could not queue copy\n"));
+ mutt_debug (1, "could not queue copy\n");
goto out;
}
}
{
if (triedcreate)
{
- dprint (1, (debugfile, "Already tried to create mailbox %s\n", mbox));
+ mutt_debug (1, "Already tried to create mailbox %s\n", mbox);
break;
}
/* bail out if command failed for reasons other than nonexistent target */
if (ascii_strncasecmp (imap_get_qualifier (idata->buf), "[TRYCREATE]", 11))
break;
- dprint (3, (debugfile, "imap_copy_messages: server suggests TRYCREATE\n"));
+ mutt_debug (3, "imap_copy_messages: server suggests TRYCREATE\n");
snprintf (prompt, sizeof (prompt), _("Create %s?"), mbox);
if (option (OPTCONFIRMCREATE) && mutt_yesorno (prompt, 1) != MUTT_YES)
{
hd = h->data;
newh.data = hd;
- dprint (2, (debugfile, "imap_fetch_message: parsing FLAGS\n"));
+ mutt_debug (2, "imap_fetch_message: parsing FLAGS\n");
if ((s = msg_parse_flags (&newh, s)) == NULL)
return NULL;
SKIPWS (s);
if (*s != '\"')
{
- dprint (1, (debugfile, "msg_parse_fetch(): bogus INTERNALDATE entry: %s\n", s));
+ mutt_debug (1, "msg_parse_fetch(): bogus INTERNALDATE entry: %s\n", s);
return -1;
}
s++;
/* sanity-check string */
if (ascii_strncasecmp ("FLAGS", s, 5) != 0)
{
- dprint (1, (debugfile, "msg_parse_flags: not a FLAGS response: %s\n",
- s));
+ mutt_debug (1, "msg_parse_flags: not a FLAGS response: %s\n", s);
return NULL;
}
s += 5;
SKIPWS(s);
if (*s != '(')
{
- dprint (1, (debugfile, "msg_parse_flags: bogus FLAGS response: %s\n",
- s));
+ mutt_debug (1, "msg_parse_flags: bogus FLAGS response: %s\n", s);
return NULL;
}
s++;
s++;
else
{
- dprint (1, (debugfile,
- "msg_parse_flags: Unterminated FLAGS response: %s\n", s));
+ mutt_debug (1, "msg_parse_flags: Unterminated FLAGS response: %s\n", s);
return NULL;
}
if (*(unsigned int *)uv == idata->uid_validity)
h = mutt_hcache_restore (uv);
else
- dprint (3, (debugfile, "hcache uidvalidity mismatch: %u",
- *(unsigned int *)uv));
+ mutt_debug (3, "hcache uidvalidity mismatch: %u", *(unsigned int *)uv);
mutt_hcache_free (idata->hcache, &uv);
}
ImapPort = ntohs (service->s_port);
else
ImapPort = IMAP_PORT;
- dprint (3, (debugfile, "Using default IMAP port %d\n", ImapPort));
+ mutt_debug (3, "Using default IMAP port %d\n", ImapPort);
}
if (!ImapsPort)
{
ImapsPort = ntohs (service->s_port);
else
ImapsPort = IMAP_SSL_PORT;
- dprint (3, (debugfile, "Using default IMAPS port %d\n", ImapsPort));
+ mutt_debug (3, "Using default IMAPS port %d\n", ImapsPort);
}
/* Defaults */
if ((n = sscanf (tmp, "%127[^:/]%127s", mx->account.host, tmp)) < 1)
{
- dprint (1, (debugfile, "imap_parse_path: NULL host in %s\n", path));
+ mutt_debug (1, "imap_parse_path: NULL host in %s\n", path);
FREE (&mx->mbox);
return -1;
}
mx->account.flags |= MUTT_ACCT_SSL;
else
{
- dprint (1, (debugfile, "imap_parse_path: Unknown connection type in %s\n", path));
+ mutt_debug (1, "imap_parse_path: Unknown connection type in %s\n",
+ path);
FREE (&mx->mbox);
return -1;
}
} while (pc && *pc != '`');
if (!pc)
{
- dprint (1, (debugfile, "mutt_get_token: mismatched backticks\n"));
+ mutt_debug (1, "mutt_get_token: mismatched backticks\n");
return (-1);
}
cmd = mutt_substrdup (tok->dptr, pc);
if ((pid = mutt_create_filter (cmd, NULL, &fp, NULL)) < 0)
{
- dprint (1, (debugfile, "mutt_get_token: unable to fork command: %s", cmd));
+ mutt_debug (1, "mutt_get_token: unable to fork command: %s", cmd);
FREE (&cmd);
return (-1);
}
{
if (k == (size_t)(-1) || k == (size_t)(-2))
{
- dprint (1, (debugfile,
+ mutt_debug (1,
"parse_mbchar_table: mbrtowc returned %d converting %s in %s\n",
- (k == (size_t)(-1)) ? -1 : -2,
- s, t->orig_str));
+ (k == (size_t)(-1)) ? -1 : -2, s, t->orig_str);
if (k == (size_t)(-1))
memset (&mbstate, 0, sizeof (mbstate));
k = (k == (size_t)(-1)) ? 1 : slen;
/* Find the last item in the list that data points to. */
lastp = NULL;
- dprint(5, (debugfile, "parse_attach_list: ldata = %p, *ldata = %p\n",
- (void *)ldata, (void *)*ldata));
+ mutt_debug (5, "parse_attach_list: ldata = %p, *ldata = %p\n",
+ (void *)ldata, (void *)*ldata);
for (listp = *ldata; listp; listp = listp->next)
{
a = (ATTACH_MATCH *)listp->data;
- dprint(5, (debugfile, "parse_attach_list: skipping %s/%s\n",
- a->major, a->minor));
+ mutt_debug (5, "parse_attach_list: skipping %s/%s\n",
+ a->major, a->minor);
lastp = listp;
}
return -1;
}
- dprint(5, (debugfile, "parse_attach_list: added %s/%s [%d]\n",
- a->major, a->minor, a->major_int));
+ mutt_debug (5, "parse_attach_list: added %s/%s [%d]\n",
+ a->major, a->minor, a->major_int);
listp = safe_malloc(sizeof(LIST));
listp->data = (char *)a;
for(lp = *ldata; lp; )
{
a = (ATTACH_MATCH *)lp->data;
- dprint(5, (debugfile, "parse_unattach_list: check %s/%s [%d] : %s/%s [%d]\n",
- a->major, a->minor, a->major_int, tmp, minor, major));
+ mutt_debug (5, "parse_unattach_list: check %s/%s [%d] : %s/%s [%d]\n",
+ a->major, a->minor, a->major_int, tmp, minor, major);
if (a->major_int == major && !mutt_strcasecmp(minor, a->minor))
{
- dprint(5, (debugfile, "parse_unattach_list: removed %s/%s [%d]\n",
- a->major, a->minor, a->major_int));
+ mutt_debug (5, "parse_unattach_list: removed %s/%s [%d]\n",
+ a->major, a->minor, a->major_int);
regfree(&a->minor_rx);
FREE(&a->major);
}
mutt_extract_token (buf, s, MUTT_TOKEN_QUOTE | MUTT_TOKEN_SPACE | MUTT_TOKEN_SEMICOLON);
- dprint (3, (debugfile, "parse_alias: Second token is '%s'.\n",
- buf->data));
+ mutt_debug (3, "parse_alias: Second token is '%s'.\n", buf->data);
tmp->addr = mutt_parse_adrlist (tmp->addr, buf->data);
for (a = tmp->addr; a && a->mailbox; a = a->next)
{
if (!a->group)
- dprint (3, (debugfile, "parse_alias: %s\n",
- a->mailbox));
+ mutt_debug (3, "parse_alias: %s\n", a->mailbox);
else
- dprint (3, (debugfile, "parse_alias: Group %s\n",
- a->mailbox));
+ mutt_debug (3, "parse_alias: Group %s\n", a->mailbox);
}
}
#endif
}
}
- dprint(2, (debugfile, "Reading configuration file '%s'.\n", rcfile));
+ mutt_debug (2, "Reading configuration file '%s'.\n", rcfile);
if ((f = mutt_open_read (rcfile, &pid)) == NULL)
{
if ((debugfile = safe_fopen(buf, "w")) != NULL)
{
setbuf (debugfile, NULL); /* don't buffer the debugging output! */
- dprint(1,(debugfile,"NeoMutt/%s (%s) debugging at level %d\n",
- PACKAGE_VERSION, MUTT_VERSION, debuglevel));
+ mutt_debug (1, "NeoMutt/%s (%s) debugging at level %d\n",
+ PACKAGE_VERSION, MUTT_VERSION, debuglevel);
}
}
#endif
/* avoid duplicates */
tmp = hash_find(TagTransforms, tag);
if (tmp) {
- dprint(3,(debugfile,"tag transform '%s' already registered as '%s'\n", tag, tmp));
+ mutt_debug (3, "tag transform '%s' already registered as '%s'\n", tag, tmp);
FREE(&tag);
FREE(&transform);
continue;
/* avoid duplicates */
tmp = hash_find(TagFormats, format);
if (tmp) {
- dprint(3,(debugfile,"tag format '%s' already registered as '%s'\n", format, tmp));
+ mutt_debug (3, "tag format '%s' already registered as '%s'\n", format, tmp);
FREE(&tag);
FREE(&format);
continue;
* some of our "standard" functions in external programs, too.
*/
-#define _LIB_C 1
-
#if HAVE_CONFIG_H
# include "config.h"
#endif
break;
if (fwrite (buf, 1, chunk, out) != chunk)
{
- /* dprint (1, (debugfile, "mutt_copy_bytes(): fwrite() returned short byte count\n")); */
+ /* mutt_debug (1, "mutt_copy_bytes(): fwrite() returned short byte count\n"); */
return (-1);
}
size -= chunk;
*
*/
- dprint (1, (debugfile, "safe_rename: link (%s, %s) failed: %s (%d)\n", src, target, strerror (errno), errno));
+ mutt_debug (1, "safe_rename: link (%s, %s) failed: %s (%d)\n",
+ src, target, strerror (errno), errno);
/*
* FUSE may return ENOSYS. VFAT may return EPERM. FreeBSD's
#endif
)
{
- dprint (1, (debugfile, "safe_rename: trying rename...\n"));
+ mutt_debug (1, "safe_rename: trying rename...\n");
if (rename (src, target) == -1)
{
- dprint (1, (debugfile, "safe_rename: rename (%s, %s) failed: %s (%d)\n", src, target, strerror (errno), errno));
+ mutt_debug (1, "safe_rename: rename (%s, %s) failed: %s (%d)\n",
+ src, target, strerror (errno), errno);
return -1;
}
- dprint (1, (debugfile, "safe_rename: rename succeeded.\n"));
+ mutt_debug (1, "safe_rename: rename succeeded.\n");
return 0;
}
if (lstat (src, &ssb) == -1)
{
- dprint (1, (debugfile, "safe_rename: can't stat %s: %s (%d)\n",
- src, strerror (errno), errno));
+ mutt_debug (1, "safe_rename: can't stat %s: %s (%d)\n",
+ src, strerror (errno), errno);
return -1;
}
if (lstat (target, &tsb) == -1)
{
- dprint (1, (debugfile, "safe_rename: can't stat %s: %s (%d)\n",
- src, strerror (errno), errno));
+ mutt_debug (1, "safe_rename: can't stat %s: %s (%d)\n",
+ src, strerror (errno), errno);
return -1;
}
if (compare_stat (&ssb, &tsb) == -1)
{
- dprint (1, (debugfile, "safe_rename: stat blocks for %s and %s diverge; pretending EEXIST.\n", src, target));
+ mutt_debug (1, "safe_rename: stat blocks for %s and %s diverge; "
+ "pretending EEXIST.\n", src, target);
errno = EEXIST;
return -1;
}
if (unlink (src) == -1)
{
- dprint (1, (debugfile, "safe_rename: unlink (%s) failed: %s (%d)\n",
- src, strerror (errno), errno));
+ mutt_debug (1, "safe_rename: unlink (%s) failed: %s (%d)\n",
+ src, strerror (errno), errno);
}
snprintf (newdir, ndlen, "%s/%s", parent, ".muttXXXXXX");
if (mkdtemp(newdir) == NULL)
{
- dprint(1, (debugfile, "mutt_mkwrapdir: mkdtemp() failed\n"));
+ mutt_debug (1, "mutt_mkwrapdir: mkdtemp() failed\n");
return -1;
}
if (snprintf (newfile, nflen, "%s/%s", newdir, NONULL(basename)) >= nflen)
{
rmdir(newdir);
- dprint(1, (debugfile, "mutt_mkwrapdir: string was truncated\n"));
+ mutt_debug (1, "mutt_mkwrapdir: string was truncated\n");
return -1;
}
return 0;
if (!(dirp = opendir (path)))
{
- dprint (1, (debugfile, "mutt_rmtree: error opening directory %s\n", path));
+ mutt_debug (1, "mutt_rmtree: error opening directory %s\n", path);
return -1;
}
while ((de = readdir (dirp)))
if (lstat (path, &osb) < 0 || fstat (fd, &nsb) < 0 ||
compare_stat(&osb, &nsb) == -1)
{
-/* dprint (1, (debugfile, "safe_open(): %s is a symlink!\n", path)); */
+/* mutt_debug (1, "safe_open(): %s is a symlink!\n", path); */
close (fd);
return (-1);
}
return sysexits_h[i].str;
}
-void mutt_debug (FILE *fp, const char *fmt, ...)
+#ifdef DEBUG
+FILE *debugfile;
+int debuglevel;
+
+void mutt_debug (int level, const char *fmt, ...)
{
va_list ap;
time_t now = time (NULL);
static char buf[23] = "";
static time_t last = 0;
+ if (debuglevel < level || !debugfile)
+ return;
+
if (now > last)
{
strftime (buf, sizeof (buf), "%Y-%m-%d %H:%M:%S", localtime (&now));
last = now;
}
- fprintf (fp, "[%s] ", buf);
+ fprintf (debugfile, "[%s] ", buf);
va_start (ap, fmt);
- vfprintf (fp, fmt, ap);
+ vfprintf (debugfile, fmt, ap);
va_end (ap);
}
+#endif
int mutt_atos (const char *str, short *dst)
{
extern void (*mutt_error) (const char *, ...);
# endif
-# ifdef _LIB_C
-# define MUTT_LIB_WHERE
-# define MUTT_LIB_INITVAL(x) = x
-# else
-# define MUTT_LIB_WHERE extern
-# define MUTT_LIB_INITVAL(x)
-# endif
-
void mutt_exit (int);
-# ifdef DEBUG
-
-MUTT_LIB_WHERE FILE *debugfile MUTT_LIB_INITVAL(0);
-MUTT_LIB_WHERE int debuglevel MUTT_LIB_INITVAL(0);
-
-void mutt_debug (FILE *, const char *, ...);
-
-# define dprint(N,X) do { if(debuglevel>=N && debugfile) mutt_debug X; } while (0)
-
-# else
-
-# define dprint(N,X) do { } while (0)
-
-# endif
+#ifdef DEBUG
+extern FILE *debugfile;
+extern int debuglevel;
+void mutt_debug (int level, const char *, ...);
+#else
+#define mutt_debug(...) do { } while (0)
+#endif
/* Exit values used in send_msg() */
if (fgets (buf, sizeof (buf) - 1, ctx->fp) == NULL)
{
/* TODO: memory leak??? */
- dprint (1, (debugfile, "mmdf_parse_mailbox: unexpected EOF\n"));
+ mutt_debug (1, "mmdf_parse_mailbox: unexpected EOF\n");
break;
}
{
if (fseeko (ctx->fp, loc, SEEK_SET) != 0)
{
- dprint (1, (debugfile, "mmdf_parse_mailbox: fseek() failed\n"));
+ mutt_debug (1, "mmdf_parse_mailbox: fseek() failed\n");
mutt_error (_("Mailbox is corrupt!"));
return (-1);
}
mutt_strcmp (MMDF_SEP, buf) != 0)
{
if (fseeko (ctx->fp, loc, SEEK_SET) != 0)
- dprint (1, (debugfile, "mmdf_parse_mailbox: fseek() failed\n"));
+ mutt_debug (1, "mmdf_parse_mailbox: fseek() failed\n");
hdr->content->length = -1;
}
}
}
else
{
- dprint (1, (debugfile, "mmdf_parse_mailbox: corrupt mailbox!\n"));
+ mutt_debug (1, "mmdf_parse_mailbox: corrupt mailbox!\n");
mutt_error (_("Mailbox is corrupt!"));
return (-1);
}
fgets (buf, sizeof (buf), ctx->fp) == NULL ||
mutt_strncmp ("From ", buf, 5) != 0)
{
- dprint (1, (debugfile, "mbox_parse_mailbox: bad content-length in message %d (cl=" OFF_T_FMT ")\n", curhdr->index, curhdr->content->length));
- dprint (1, (debugfile, "\tLINE: %s", buf));
+ mutt_debug (1, "mbox_parse_mailbox: bad content-length in message "
+ "%d (cl=" OFF_T_FMT ")\n",
+ curhdr->index, curhdr->content->length);
+ mutt_debug (1, "\tLINE: %s", buf);
if (fseeko (ctx->fp, loc, SEEK_SET) != 0) /* nope, return the previous position */
{
- dprint (1, (debugfile, "mbox_parse_mailbox: fseek() failed\n"));
+ mutt_debug (1, "mbox_parse_mailbox: fseek() failed\n");
}
curhdr->content->length = -1;
}
/* count the number of lines in this message */
if (fseeko (ctx->fp, loc, SEEK_SET) != 0)
- dprint (1, (debugfile, "mbox_parse_mailbox: fseek() failed\n"));
+ mutt_debug (1, "mbox_parse_mailbox: fseek() failed\n");
while (cl-- > 0)
{
if (fgetc (ctx->fp) == '\n')
/* return to the offset of the next message separator */
if (fseeko (ctx->fp, tmploc, SEEK_SET) != 0)
- dprint (1, (debugfile, "mbox_parse_mailbox: fseek() failed\n"));
+ mutt_debug (1, "mbox_parse_mailbox: fseek() failed\n");
}
}
* folder.
*/
if (fseeko (ctx->fp, ctx->size, SEEK_SET) != 0)
- dprint (1, (debugfile, "mbox_check_mailbox: fseek() failed\n"));
+ mutt_debug (1, "mbox_check_mailbox: fseek() failed\n");
if (fgets (buffer, sizeof (buffer), ctx->fp) != NULL)
{
if ((ctx->magic == MUTT_MBOX && mutt_strncmp ("From ", buffer, 5) == 0) ||
(ctx->magic == MUTT_MMDF && mutt_strcmp (MMDF_SEP, buffer) == 0))
{
if (fseeko (ctx->fp, ctx->size, SEEK_SET) != 0)
- dprint (1, (debugfile, "mbox_check_mailbox: fseek() failed\n"));
+ mutt_debug (1, "mbox_check_mailbox: fseek() failed\n");
if (ctx->magic == MUTT_MBOX)
mbox_parse_mailbox (ctx);
else
}
else
{
- dprint (1, (debugfile, "mbox_check_mailbox: fgets returned NULL.\n"));
+ mutt_debug (1, "mbox_check_mailbox: fgets returned NULL.\n");
modified = 1;
}
}
*/
mutt_error (_("sync: mbox modified, but no modified messages! (report this bug)"));
mutt_sleep(5); /* the mutt_error /will/ get cleared! */
- dprint(1, (debugfile, "mbox_sync_mailbox(): no modified messages.\n"));
+ mutt_debug (1, "mbox_sync_mailbox(): no modified messages.\n");
unlink (tempfile);
goto bail;
}
if (fclose (fp) != 0)
{
fp = NULL;
- dprint(1, (debugfile, "mbox_sync_mailbox: safe_fclose (&) returned non-zero.\n"));
+ mutt_debug (1, "mbox_sync_mailbox: safe_fclose (&) returned non-zero.\n");
unlink (tempfile);
mutt_perror (tempfile);
mutt_sleep (5);
{
mutt_unblock_signals ();
mx_fastclose_mailbox (ctx);
- dprint (1, (debugfile, "mbox_sync_mailbox: unable to reopen temp copy of mailbox!\n"));
+ mutt_debug (1, "mbox_sync_mailbox: unable to reopen temp copy of mailbox!\n");
mutt_perror (tempfile);
mutt_sleep (5);
return (-1);
(ctx->magic == MUTT_MBOX && mutt_strncmp ("From ", buf, 5) != 0) ||
(ctx->magic == MUTT_MMDF && mutt_strcmp (MMDF_SEP, buf) != 0))
{
- dprint (1, (debugfile, "mbox_sync_mailbox: message not in expected position."));
- dprint (1, (debugfile, "\tLINE: %s\n", buf));
+ mutt_debug (1, "mbox_sync_mailbox: message not in expected position.");
+ mutt_debug (1, "\tLINE: %s\n", buf);
i = -1;
}
else
if (fseeko (ctx->fp, offset, SEEK_SET) != 0) /* return to proper offset */
{
i = -1;
- dprint (1, (debugfile, "mbox_sync_mailbox: fseek() failed\n"));
+ mutt_debug (1, "mbox_sync_mailbox: fseek() failed\n");
}
else
{
if (ftruncate (fileno (ctx->fp), ctx->size) != 0)
{
i = -1;
- dprint (1, (debugfile, "mbox_sync_mailbox: ftruncate() failed\n"));
+ mutt_debug (1, "mbox_sync_mailbox: ftruncate() failed\n");
}
}
}
if (stat (ctx->path, &st))
{
- dprint (1, (debugfile, "stat failed on %s\n", ctx->path));
+ mutt_debug (1, "stat failed on %s\n", ctx->path);
return 077;
}
continue;
/* FOO - really ignore the return value? */
- dprint (2,
- (debugfile, "%s:%d: queueing %s\n", __FILE__, __LINE__,
- de->d_name));
+ mutt_debug (2, "%s:%d: queueing %s\n",
+ __FILE__, __LINE__, de->d_name);
h = mutt_new_header ();
h->old = is_old;
while (md)
{
- dprint (2, (debugfile, "%s:%d maildir_add_to_context(): Considering %s\n",
- __FILE__, __LINE__, NONULL (md->canon_fname)));
+ mutt_debug (2, "%s:%d maildir_add_to_context(): Considering %s\n",
+ __FILE__, __LINE__, NONULL (md->canon_fname));
if (md->h)
{
- dprint (2,
- (debugfile,
- "%s:%d Adding header structure. Flags: %s%s%s%s%s\n", __FILE__,
- __LINE__, md->h->flagged ? "f" : "", md->h->deleted ? "D" : "",
- md->h->replied ? "r" : "", md->h->old ? "O" : "",
- md->h->read ? "R" : ""));
+ mutt_debug (2, "%s:%d Adding header structure. Flags: %s%s%s%s%s\n",
+ __FILE__, __LINE__, md->h->flagged ? "f" : "",
+ md->h->deleted ? "D" : "", md->h->replied ? "r" : "",
+ md->h->old ? "O" : "", md->h->read ? "R" : "");
if (ctx->msgcount == ctx->hdrmax)
mx_alloc_memory (ctx);
{
if (!ctx || !md || !*md || ctx->magic != MUTT_MH || Sort != SORT_ORDER)
return;
- dprint (4, (debugfile, "maildir: sorting %s into natural order\n",
- ctx->path));
+ mutt_debug (4, "maildir: sorting %s into natural order\n", ctx->path);
*md = maildir_sort (*md, (size_t) -1, md_cmp_path);
}
#define DO_SORT() do { \
if (!sort) \
{ \
- dprint (4, (debugfile, "maildir: need to sort %s by inode\n", ctx->path)); \
+ mutt_debug (4, "maildir: need to sort %s by inode\n", ctx->path); \
p = maildir_sort (p, (size_t) -1, md_cmp_inode); \
if (!last) \
*md = p; \
if (!msg->fp)
{
mutt_perror (path);
- dprint (1, (debugfile, "maildir_mh_open_message: fopen: %s: %s (errno %d).\n",
- path, strerror (errno), errno));
+ mutt_debug (1, "maildir_mh_open_message: fopen: %s: %s (errno %d).\n",
+ path, strerror (errno), errno);
return -1;
}
dest->path, subdir, (long long)time (NULL), mutt_rand64(),
NONULL (Hostname), suffix);
- dprint (2, (debugfile, "maildir_open_new_message (): Trying %s.\n",
- path));
+ mutt_debug (2, "maildir_open_new_message (): Trying %s.\n", path);
if ((fd = open (path, O_WRONLY | O_EXCL | O_CREAT, 0666)) == -1)
{
}
else
{
- dprint (2, (debugfile, "maildir_open_new_message (): Success.\n"));
+ mutt_debug (2, "maildir_open_new_message (): Success.\n");
msg->path = safe_strdup (path);
break;
}
NONULL (Hostname), suffix);
snprintf (full, _POSIX_PATH_MAX, "%s/%s", ctx->path, path);
- dprint (2, (debugfile, "_maildir_commit_message (): renaming %s to %s.\n",
- msg->path, full));
+ mutt_debug (2, "_maildir_commit_message (): renaming %s to %s.\n",
+ msg->path, full);
if (safe_rename (msg->path, full) == 0)
{
if ((p = strrchr (h->path, '/')) == NULL)
{
- dprint (1,
- (debugfile,
- "maildir_sync_message: %s: unable to find subdir!\n",
- h->path));
+ mutt_debug (1, "maildir_sync_message: %s: unable to find subdir!\n",
+ h->path);
return (-1);
}
p++;
if (mutt_convert_string (&reversed_user, Charset, "utf-8", 0) == -1)
{
- dprint (1, (debugfile,
+ mutt_debug (1,
"intl_to_local: Not reversible. Charset conv to utf-8 failed for user = '%s'.\n",
- reversed_user));
+ reversed_user);
goto cleanup;
}
if (ascii_strcasecmp (orig_user, reversed_user))
{
- dprint (1, (debugfile, "intl_to_local: Not reversible. orig = '%s', reversed = '%s'.\n",
- orig_user, reversed_user));
+ mutt_debug (1, "intl_to_local: Not reversible. orig = '%s', reversed = '%s'.\n",
+ orig_user, reversed_user);
goto cleanup;
}
if (mutt_convert_string (&reversed_domain, Charset, "utf-8", 0) == -1)
{
- dprint (1, (debugfile,
+ mutt_debug (1,
"intl_to_local: Not reversible. Charset conv to utf-8 failed for domain = '%s'.\n",
- reversed_domain));
+ reversed_domain);
goto cleanup;
}
{
if (idna_to_ascii_8z (reversed_domain, &tmp, IDNA_ALLOW_UNASSIGNED) != IDNA_SUCCESS)
{
- dprint (1, (debugfile,
+ mutt_debug (1,
"intl_to_local: Not reversible. idna_to_ascii_8z failed for domain = '%s'.\n",
- reversed_domain));
+ reversed_domain);
goto cleanup;
}
mutt_str_replace (&reversed_domain, tmp);
if (ascii_strcasecmp (orig_domain, reversed_domain))
{
- dprint (1, (debugfile, "intl_to_local: Not reversible. orig = '%s', reversed = '%s'.\n",
- orig_domain, reversed_domain));
+ mutt_debug (1, "intl_to_local: Not reversible. orig = '%s', reversed = '%s'.\n",
+ orig_domain, reversed_domain);
goto cleanup;
}
}
ls && notmuch_filenames_valid(ls);
notmuch_filenames_move_to_next(ls))
{
- dprint(2, (debugfile, "nm: %s: %s\n", id, notmuch_filenames_get(ls)));
+ mutt_debug (2, "nm: %s: %s\n", id, notmuch_filenames_get(ls));
}
}
tags && notmuch_tags_valid(tags);
notmuch_tags_move_to_next(tags))
{
- dprint(2, (debugfile, "nm: %s: %s\n", id, notmuch_tags_get(tags)));
+ mutt_debug (2, "nm: %s: %s\n", id, notmuch_tags_get(tags));
}
}
#endif
if (!data)
return;
- dprint(2, (debugfile, "nm: freeing header %p\n", data));
+ mutt_debug (2, "nm: freeing header %p\n", data);
FREE(&data->folder);
FREE(&data->tags);
FREE(&data->tags_transformed);
if (!data)
return;
- dprint(1, (debugfile, "nm: freeing context data %p\n", data));
+ mutt_debug (1, "nm: freeing context data %p\n", data);
if (data->db)
#ifdef NOTMUCH_API_3
return NULL;
data = safe_calloc(1, sizeof(struct nm_ctxdata));
- dprint(1, (debugfile, "nm: initialize context data %p\n", data));
+ mutt_debug (1, "nm: initialize context data %p\n", data);
data->db_limit = NotmuchDBLimit;
static char *header_get_fullpath(HEADER *h, char *buf, size_t bufsz)
{
snprintf(buf, bufsz, "%s/%s", nm_header_get_folder(h), h->path);
- /*dprint(2, (debugfile, "nm: returns fullpath '%s'\n", buf));*/
+ /*mutt_debug (2, "nm: returns fullpath '%s'\n", buf);*/
return buf;
}
*/
static void query_window_reset(void)
{
- dprint(2, (debugfile, "query_window_reset ()\n"));
+ mutt_debug (2, "query_window_reset ()\n");
NotmuchQueryWindowCurrentPosition = 0;
}
*/
static bool windowed_query_from_query(const char *query, char *buf, size_t bufsz)
{
- dprint(2, (debugfile, "nm: windowed_query_from_query (%s)\n", query));
+ mutt_debug (2, "nm: windowed_query_from_query (%s)\n", query);
int beg = NotmuchQueryWindowDuration * (NotmuchQueryWindowCurrentPosition + 1);
int end = NotmuchQueryWindowDuration * NotmuchQueryWindowCurrentPosition;
if (!query_window_check_timebase(NotmuchQueryWindowTimebase))
{
mutt_message (_("Invalid nm_query_window_timebase value (valid values are: hour, day, week, month or year)."));
- dprint(2, (debugfile, "Invalid nm_query_window_timebase value\n"));
+ mutt_debug (2, "Invalid nm_query_window_timebase value\n");
return false;
}
snprintf(buf, bufsz, "date:%d%s..%d%s and %s",
beg, NotmuchQueryWindowTimebase, end, NotmuchQueryWindowTimebase, NotmuchQueryWindowCurrentSearch);
- dprint(2, (debugfile, "nm: windowed_query_from_query (%s) -> %s\n", query, buf));
+ mutt_debug (2, "nm: windowed_query_from_query (%s) -> %s\n", query, buf);
return true;
}
*/
static char *get_query_string(struct nm_ctxdata *data, int window)
{
- dprint(2, (debugfile, "nm: get_query_string(%d)\n", window));
+ mutt_debug (2, "nm: get_query_string(%d)\n", window);
struct uri_tag *item;
windowed_query_from_query(data->db_query, buf, sizeof(buf)))
data->db_query = safe_strdup(buf);
- dprint(2, (debugfile, "nm: query (windowed) '%s'\n", data->db_query));
+ mutt_debug (2, "nm: query (windowed) '%s'\n", data->db_query);
}
else
- dprint(2, (debugfile, "nm: query '%s'\n", data->db_query));
+ mutt_debug (2, "nm: query '%s'\n", data->db_query);
return data->db_query;
}
if (strncmp(db_filename, "notmuch://", 10) == 0)
db_filename += 10;
- dprint(2, (debugfile, "nm: db filename '%s'\n", db_filename));
+ mutt_debug (2, "nm: db filename '%s'\n", db_filename);
return db_filename;
}
int ct = 0;
notmuch_status_t st = NOTMUCH_STATUS_SUCCESS;
- dprint(1, (debugfile, "nm: db open '%s' %s (timeout %d)\n", filename,
- writable ? "[WRITE]" : "[READ]", NotmuchOpenTimeout));
+ mutt_debug (1, "nm: db open '%s' %s (timeout %d)\n", filename,
+ writable ? "[WRITE]" : "[READ]", NotmuchOpenTimeout);
do
{
#ifdef NOTMUCH_API_3
{
if (data && data->db)
{
- dprint(1, (debugfile, "nm: db close\n"));
+ mutt_debug (1, "nm: db close\n");
#ifdef NOTMUCH_API_3
notmuch_database_destroy(data->db);
#else
if (!data->trans)
{
- dprint(2, (debugfile, "nm: db trans start\n"));
+ mutt_debug (2, "nm: db trans start\n");
if (notmuch_database_begin_atomic(data->db))
return -1;
data->trans = 1;
if (data->trans)
{
- dprint(2, (debugfile, "nm: db trans end\n"));
+ mutt_debug (2, "nm: db trans end\n");
data->trans = 0;
if (notmuch_database_end_atomic(data->db))
return -1;
return -1;
snprintf(path, sizeof(path), "%s/.notmuch/xapian", get_db_filename(data));
- dprint(2, (debugfile, "nm: checking '%s' mtime\n", path));
+ mutt_debug (2, "nm: checking '%s' mtime\n", path);
if (stat(path, &st))
return -1;
break;
*end = '\0';
- dprint(2, (debugfile, "nm: query exclude tag '%s'\n", tag));
+ mutt_debug (2, "nm: query exclude tag '%s'\n", tag);
notmuch_query_add_tag_exclude(query, tag);
end = tag = NULL;
}
apply_exclude_tags(q);
notmuch_query_set_sort(q, NOTMUCH_SORT_NEWEST_FIRST);
- dprint(2, (debugfile, "nm: query successfully initialized (%s)\n", str));
+ mutt_debug (2, "nm: query successfully initialized (%s)\n", str);
return q;
err:
if (!is_longrun(data))
char *tstr = NULL, *ttstr = NULL;
struct nm_hdrtag *tag_list = NULL, *tmp;
- dprint(2, (debugfile, "nm: tags update requested (%s)\n", data->virtual_id));
+ mutt_debug (2, "nm: tags update requested (%s)\n", data->virtual_id);
for (tags = notmuch_message_get_tags(msg); tags && notmuch_tags_valid(tags);
notmuch_tags_move_to_next(tags))
{
FREE(&tstr);
FREE(&ttstr);
- dprint(2, (debugfile, "nm: tags unchanged\n"));
+ mutt_debug (2, "nm: tags unchanged\n");
return 1;
}
/* new version */
data->tags = tstr;
- dprint(2, (debugfile, "nm: new tags: '%s'\n", tstr));
+ mutt_debug (2, "nm: new tags: '%s'\n", tstr);
data->tags_transformed = ttstr;
- dprint(2, (debugfile, "nm: new tag transforms: '%s'\n", ttstr));
+ mutt_debug (2, "nm: new tag transforms: '%s'\n", ttstr);
return 0;
}
struct nm_hdrdata *data = h->data;
char *p;
- dprint(2, (debugfile, "nm: path update requested path=%s, (%s)\n", path,
- data->virtual_id));
+ mutt_debug (2, "nm: path update requested path=%s, (%s)\n", path,
+ data->virtual_id);
p = strrchr(path, '/');
if (p && ((p - path) > 3) &&
data->folder = mutt_substrdup(path, p);
- dprint(2, (debugfile, "nm: folder='%s', file='%s'\n", data->folder, h->path));
+ mutt_debug (2, "nm: folder='%s', file='%s'\n", data->folder, h->path);
return 0;
}
*/
((struct nm_hdrdata *) h->data)->virtual_id = safe_strdup(id);
- dprint(2, (debugfile, "nm: initialize header data: [hdr=%p, data=%p] (%s)\n",
- h, h->data, id));
+ mutt_debug (2, "nm: initialize header data: [hdr=%p, data=%p] (%s)\n",
+ h, h->data, id);
if (!h->env->message_id)
h->env->message_id = nm2mutt_message_id(id);
if (!id)
return NULL;
- dprint(2, (debugfile, "nm: mutt header, id='%s'\n", id));
+ mutt_debug (2, "nm: mutt header, id='%s'\n", id);
if (!ctx->id_hash)
{
- dprint(2, (debugfile, "nm: init hash\n"));
+ mutt_debug (2, "nm: init hash\n");
ctx->id_hash = mutt_make_id_hash(ctx);
if (!ctx->id_hash)
return NULL;
}
mid = nm2mutt_message_id(id);
- dprint(2, (debugfile, "nm: mutt id='%s'\n", mid));
+ mutt_debug (2, "nm: mutt id='%s'\n", mid);
h = hash_find(ctx->id_hash, mid);
FREE(&mid);
{
data->ignmsgcount++;
progress_update(ctx, q);
- dprint(2, (debugfile, "nm: ignore id=%s, already in the context\n",
- notmuch_message_get_message_id(msg)));
+ mutt_debug (2, "nm: ignore id=%s, already in the context\n",
+ notmuch_message_get_message_id(msg));
return;
}
if (!path)
return;
- dprint(2, (debugfile, "nm: appending message, i=%d, id=%s, path=%s\n",
- ctx->msgcount, notmuch_message_get_message_id(msg), path));
+ mutt_debug (2, "nm: appending message, i=%d, id=%s, path=%s\n",
+ ctx->msgcount, notmuch_message_get_message_id(msg), path);
if (ctx->msgcount >= ctx->hdrmax)
{
- dprint(2, (debugfile, "nm: allocate mx memory\n"));
+ mutt_debug (2, "nm: allocate mx memory\n");
mx_alloc_memory(ctx);
}
if (access(path, F_OK) == 0)
h = maildir_parse_stream(MUTT_MAILDIR, f, newpath, 0, NULL);
fclose(f);
- dprint(1, (debugfile, "nm: not up-to-date: %s -> %s\n", path, newpath));
+ mutt_debug (1, "nm: not up-to-date: %s -> %s\n", path, newpath);
}
}
FREE(&folder);
if (!h)
{
- dprint(1, (debugfile, "nm: failed to parse message: %s\n", path));
+ mutt_debug (1, "nm: failed to parse message: %s\n", path);
goto done;
}
if (init_header(h, newpath ? newpath : path, msg) != 0)
{
mutt_free_header(&h);
- dprint(1, (debugfile, "nm: failed to append header!\n"));
+ mutt_debug (1, "nm: failed to append header!\n");
goto done;
}
if (hd)
{
- dprint(1, (debugfile, "nm: remember obsolete path: %s\n", path));
+ mutt_debug (1, "nm: remember obsolete path: %s\n", path);
hd->oldpath = safe_strdup(path);
}
}
notmuch_message_t *msg = NULL;
char *id = header_get_id(hdr);
- dprint(2, (debugfile, "nm: find message (%s)\n", id));
+ mutt_debug (2, "nm: find message (%s)\n", id);
if (id && db)
notmuch_database_find_message(db, id, &msg);
if (*tag == '-')
{
- dprint(1, (debugfile, "nm: remove tag: '%s'\n", tag + 1));
+ mutt_debug (1, "nm: remove tag: '%s'\n", tag + 1);
notmuch_message_remove_tag(msg, tag + 1);
}
else if (*tag == '!')
{
- dprint(1, (debugfile, "nm: toggle tag: '%s'\n", tag + 1));
+ mutt_debug (1, "nm: toggle tag: '%s'\n", tag + 1);
if (nm_message_has_tag (msg, tag + 1))
{
notmuch_message_remove_tag (msg, tag + 1);
}
else
{
- dprint(1, (debugfile, "nm: add tag: '%s'\n", (*tag == '+') ? tag + 1 : tag));
+ mutt_debug (1, "nm: add tag: '%s'\n", (*tag == '+') ? tag + 1 : tag);
notmuch_message_add_tag(msg, (*tag == '+') ? tag + 1 : tag);
}
end = tag = NULL;
if (rename(old, newpath) != 0)
{
- dprint(1, (debugfile, "nm: rename(2) failed %s -> %s\n", old, newpath));
+ mutt_debug (1, "nm: rename(2) failed %s -> %s\n", old, newpath);
return -1;
}
notmuch_database_t *db = get_db(data, true);
int trans;
- dprint(2, (debugfile, "nm: remove filename '%s'\n", path));
+ mutt_debug (2, "nm: remove filename '%s'\n", path);
if (!db)
return -1;
switch (st)
{
case NOTMUCH_STATUS_SUCCESS:
- dprint(2, (debugfile, "nm: remove success, call unlink\n"));
+ mutt_debug (2, "nm: remove success, call unlink\n");
unlink(path);
break;
case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
- dprint(2, (debugfile, "nm: remove success (duplicate), call unlink\n"));
+ mutt_debug (2, "nm: remove success (duplicate), call unlink\n");
unlink(path);
for (ls = notmuch_message_get_filenames(msg);
ls && notmuch_filenames_valid(ls);
{
path = notmuch_filenames_get(ls);
- dprint(2, (debugfile, "nm: remove duplicate: '%s'\n", path));
+ mutt_debug (2, "nm: remove duplicate: '%s'\n", path);
unlink(path);
notmuch_database_remove_message(db, path);
}
break;
default:
- dprint(1, (debugfile, "nm: failed to remove '%s' [st=%d]\n", path,
- (int) st));
+ mutt_debug (1, "nm: failed to remove '%s' [st=%d]\n", path,
+ (int) st);
break;
}
if (!db || !new || !old || (access(new, F_OK) != 0))
return -1;
- dprint(1, (debugfile, "nm: rename filename, %s -> %s\n", old, new));
+ mutt_debug (1, "nm: rename filename, %s -> %s\n", old, new);
trans = db_trans_begin(data);
if (trans < 0)
return -1;
- dprint(2, (debugfile, "nm: rename: add '%s'\n", new));
+ mutt_debug (2, "nm: rename: add '%s'\n", new);
st = notmuch_database_add_message(db, new, &msg);
if ((st != NOTMUCH_STATUS_SUCCESS) &&
(st != NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID))
{
- dprint(1, (debugfile, "nm: failed to add '%s' [st=%d]\n", new, (int) st));
+ mutt_debug (1, "nm: failed to add '%s' [st=%d]\n", new, (int) st);
goto done;
}
- dprint(2, (debugfile, "nm: rename: rem '%s'\n", old));
+ mutt_debug (2, "nm: rename: rem '%s'\n", old);
st = notmuch_database_remove_message(db, old);
switch (st)
{
case NOTMUCH_STATUS_SUCCESS:
break;
case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
- dprint(2, (debugfile, "nm: rename: syncing duplicate filename\n"));
+ mutt_debug (2, "nm: rename: syncing duplicate filename\n");
notmuch_message_destroy(msg);
msg = NULL;
notmuch_database_find_message_by_filename(db, new, &msg);
if (strcmp(new, path) == 0)
continue;
- dprint(2, (debugfile, "nm: rename: syncing duplicate: %s\n", path));
+ mutt_debug (2, "nm: rename: syncing duplicate: %s\n", path);
if (rename_maildir_filename(path, newpath, sizeof(newpath), h) == 0)
{
- dprint(2, (debugfile, "nm: rename dup %s -> %s\n", path, newpath));
+ mutt_debug (2, "nm: rename dup %s -> %s\n", path, newpath);
notmuch_database_remove_message(db, path);
notmuch_database_add_message(db, newpath, NULL);
}
st = NOTMUCH_STATUS_SUCCESS;
break;
default:
- dprint(1, (debugfile, "nm: failed to remove '%s' [st=%d]\n", old, (int) st));
+ mutt_debug (1, "nm: failed to remove '%s' [st=%d]\n", old, (int) st);
break;
}
res = notmuch_query_count_messages(q);
#endif
notmuch_query_destroy(q);
- dprint(1, (debugfile, "nm: count '%s', result=%d\n", qstr, res));
+ mutt_debug (1, "nm: count '%s', result=%d\n", qstr, res);
}
return res;
}
if (data && get_db(data, writable))
{
data->longrun = 1;
- dprint(2, (debugfile, "nm: long run initialized\n"));
+ mutt_debug (2, "nm: long run initialized\n");
}
}
struct nm_ctxdata *data = get_ctxdata(ctx);
if (data && (release_db(data) == 0))
- dprint(2, (debugfile, "nm: long run deinitialized\n"));
+ mutt_debug (2, "nm: long run deinitialized\n");
}
void nm_debug_check(CONTEXT *ctx)
if (data->db)
{
- dprint(1, (debugfile, "nm: ERROR: db is open, closing\n"));
+ mutt_debug (1, "nm: ERROR: db is open, closing\n");
release_db(data);
}
}
if (!(db = get_db(data, false)) || !(msg = get_nm_message(db, h)))
goto done;
- dprint(1, (debugfile,
- "nm: reading entire-thread messages...[current count=%d]\n",
- ctx->msgcount));
+ mutt_debug (1,
+ "nm: reading entire-thread messages...[current count=%d]\n",
+ ctx->msgcount);
progress_reset(ctx);
id = notmuch_message_get_thread_id(msg);
mutt_message(_("No more messages in the thread."));
data->oldmsgcount = 0;
- dprint(1, (debugfile,
- "nm: reading entire-thread messages... done [rc=%d, count=%d]\n",
- rc, ctx->msgcount));
+ mutt_debug (1,
+ "nm: reading entire-thread messages... done [rc=%d, count=%d]\n",
+ rc, ctx->msgcount);
return rc;
}
char *nm_uri_from_query(CONTEXT *ctx, char *buf, size_t bufsz)
{
- dprint(2, (debugfile, "nm_uri_from_query (%s)\n", buf));
+ mutt_debug (2, "nm_uri_from_query (%s)\n", buf);
struct nm_ctxdata *data = get_ctxdata(ctx);
char uri[_POSIX_PATH_MAX + LONG_STRING + 32]; /* path to DB + query + URI "decoration" */
strncpy(buf, uri, bufsz);
buf[bufsz - 1] = '\0';
- dprint(1, (debugfile, "nm: uri from query '%s'\n", buf));
+ mutt_debug (1, "nm: uri from query '%s'\n", buf);
return buf;
}
*/
bool nm_normalize_uri(char *new_uri, const char *orig_uri, size_t new_uri_sz)
{
- dprint(2, (debugfile, "nm_normalize_uri (%s)\n", orig_uri));
+ mutt_debug (2, "nm_normalize_uri (%s)\n", orig_uri);
char buf[LONG_STRING];
CONTEXT tmp_ctx;
if (url_parse_query(orig_uri, &tmp_ctxdata.db_filename, &tmp_ctxdata.query_items))
{
mutt_error(_("failed to parse notmuch uri: %s"), orig_uri);
- dprint(2, (debugfile, "nm_normalize_uri () -> error #1\n"));
+ mutt_debug (2, "nm_normalize_uri () -> error #1\n");
return false;
}
- dprint(2, (debugfile, "nm_normalize_uri #1 () -> db_query: %s\n", tmp_ctxdata.db_query));
+ mutt_debug (2, "nm_normalize_uri #1 () -> db_query: %s\n", tmp_ctxdata.db_query);
if (get_query_string(&tmp_ctxdata, false) == NULL)
{
mutt_error(_("failed to parse notmuch uri: %s"), orig_uri);
- dprint(2, (debugfile, "nm_normalize_uri () -> error #2\n"));
+ mutt_debug (2, "nm_normalize_uri () -> error #2\n");
return false;
}
- dprint(2, (debugfile, "nm_normalize_uri #2 () -> db_query: %s\n", tmp_ctxdata.db_query));
+ mutt_debug (2, "nm_normalize_uri #2 () -> db_query: %s\n", tmp_ctxdata.db_query);
strncpy(buf, tmp_ctxdata.db_query, sizeof(buf));
if (nm_uri_from_query(&tmp_ctx, buf, sizeof(buf)) == NULL)
{
mutt_error(_("failed to parse notmuch uri: %s"), orig_uri);
- dprint(2, (debugfile, "nm_normalize_uri () -> error #3\n"));
+ mutt_debug (2, "nm_normalize_uri () -> error #3\n");
return true;
}
strncpy(new_uri, buf, new_uri_sz);
- dprint(2, (debugfile, "nm_normalize_uri #3 (%s) -> %s\n", orig_uri, new_uri));
+ mutt_debug (2, "nm_normalize_uri #3 (%s) -> %s\n", orig_uri, new_uri);
return true;
}
if (NotmuchQueryWindowCurrentPosition != 0)
NotmuchQueryWindowCurrentPosition -= 1;
- dprint(2, (debugfile, "nm_query_window_forward (%d)\n", NotmuchQueryWindowCurrentPosition));
+ mutt_debug (2, "nm_query_window_forward (%d)\n", NotmuchQueryWindowCurrentPosition);
}
/**
void nm_query_window_backward(void)
{
NotmuchQueryWindowCurrentPosition += 1;
- dprint(2, (debugfile, "nm_query_window_backward (%d)\n", NotmuchQueryWindowCurrentPosition));
+ mutt_debug (2, "nm_query_window_backward (%d)\n", NotmuchQueryWindowCurrentPosition);
}
int nm_modify_message_tags(CONTEXT *ctx, HEADER *hdr, char *buf)
if (!(db = get_db(data, true)) || !(msg = get_nm_message(db, hdr)))
goto done;
- dprint(1, (debugfile, "nm: tags modify: '%s'\n", buf));
+ mutt_debug (1, "nm: tags modify: '%s'\n", buf);
update_tags(msg, buf);
update_header_flags(ctx, hdr, buf);
release_db(data);
if (hdr->changed)
ctx->mtime = time(NULL);
- dprint(1, (debugfile, "nm: tags modify done [rc=%d]\n", rc));
+ mutt_debug (1, "nm: tags modify done [rc=%d]\n", rc);
return rc;
}
notmuch_database_t *db = NULL;
int rc = -1, dflt = 0;
- dprint(1, (debugfile, "nm: count\n"));
+ mutt_debug (1, "nm: count\n");
if (url_parse_query(path, &db_filename, &query_items))
{
#else
notmuch_database_close(db);
#endif
- dprint(1, (debugfile, "nm: count close DB\n"));
+ mutt_debug (1, "nm: count close DB\n");
}
if (!dflt)
FREE(&db_filename);
url_free_tags(query_items);
- dprint(1, (debugfile, "nm: count done [rc=%d]\n", rc));
+ mutt_debug (1, "nm: count done [rc=%d]\n", rc);
return rc;
}
if (!db)
return -1;
- dprint(1, (debugfile, "nm: record message: %s\n", path));
+ mutt_debug (1, "nm: record message: %s\n", path);
trans = db_trans_begin(data);
if (trans < 0)
goto done;
if ((st != NOTMUCH_STATUS_SUCCESS) &&
(st != NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID))
{
- dprint(1, (debugfile, "nm: failed to add '%s' [st=%d]\n", path, (int) st));
+ mutt_debug (1, "nm: failed to add '%s' [st=%d]\n", path, (int) st);
goto done;
}
goto done;
*tag_count = 0;
- dprint(1, (debugfile, "nm: get all tags\n"));
+ mutt_debug (1, "nm: get all tags\n");
while (notmuch_tags_valid(tags))
{
if (!is_longrun(data))
release_db(data);
- dprint(1, (debugfile, "nm: get all tags done [rc=%d tag_count=%u]\n", rc,
- *tag_count));
+ mutt_debug (1, "nm: get all tags done [rc=%d tag_count=%u]\n", rc,
+ *tag_count);
return rc;
}
if (!data)
return -1;
- dprint(1, (debugfile, "nm: reading messages...[current count=%d]\n",
- ctx->msgcount));
+ mutt_debug (1, "nm: reading messages...[current count=%d]\n",
+ ctx->msgcount);
progress_reset(ctx);
mx_update_context(ctx, ctx->msgcount);
data->oldmsgcount = 0;
- dprint(1, (debugfile, "nm: reading messages... done [rc=%d, count=%d]\n", rc,
- ctx->msgcount));
+ mutt_debug (1, "nm: reading messages... done [rc=%d, count=%d]\n", rc,
+ ctx->msgcount);
return rc;
}
if (ctx->mtime >= mtime)
{
- dprint(2, (debugfile, "nm: check unnecessary (db=%d ctx=%d)\n", mtime,
- ctx->mtime));
+ mutt_debug (2, "nm: check unnecessary (db=%d ctx=%d)\n", mtime,
+ ctx->mtime);
return 0;
}
- dprint(1, (debugfile, "nm: checking (db=%d ctx=%d)\n", mtime, ctx->mtime));
+ mutt_debug (1, "nm: checking (db=%d ctx=%d)\n", mtime, ctx->mtime);
q = get_query(data, false);
if (!q)
goto done;
- dprint(1, (debugfile, "nm: start checking (count=%d)\n", ctx->msgcount));
+ mutt_debug (1, "nm: start checking (count=%d)\n", ctx->msgcount);
data->oldmsgcount = ctx->msgcount;
data->noprogress = 1;
ctx->mtime = time(NULL);
- dprint(1, (debugfile, "nm: ... check done [count=%d, new_flags=%d, occult=%d]\n",
- ctx->msgcount, new_flags, occult));
+ mutt_debug (1, "nm: ... check done [count=%d, new_flags=%d, occult=%d]\n",
+ ctx->msgcount, new_flags, occult);
return occult ? MUTT_REOPENED : (ctx->msgcount > data->oldmsgcount) ?
MUTT_NEW_MAIL :
if (!data)
return -1;
- dprint(1, (debugfile, "nm: sync start ...\n"));
+ mutt_debug (1, "nm: sync start ...\n");
if (!ctx->quiet)
{
{
strncpy(old, hd->oldpath, sizeof(old));
old[sizeof(old) - 1] = '\0';
- dprint(2, (debugfile, "nm: fixing obsolete path '%s'\n", old));
+ mutt_debug (2, "nm: fixing obsolete path '%s'\n", old);
}
else
header_get_fullpath(h, old, sizeof(old));
if (changed)
ctx->mtime = time(NULL);
- dprint(1, (debugfile, "nm: .... sync done [rc=%d]\n", rc));
+ mutt_debug (1, "nm: .... sync done [rc=%d]\n", rc);
return rc;
}
((ctx->magic == MUTT_MAILDIR) || (ctx->magic == MUTT_NOTMUCH)))
msg->fp = maildir_open_find_message(folder, cur->path, NULL);
- dprint(1, (debugfile, "%s\n", __func__));
+ mutt_debug (1, "%s\n", __func__);
return 0;
}
static int getnameinfo_err(int ret)
{
int err;
- dprint (1, (debugfile, "getnameinfo: "));
+ mutt_debug (1, "getnameinfo: ");
switch(ret)
{
case EAI_AGAIN:
- dprint (1, (debugfile, "The name could not be resolved at this time. Future attempts may succeed.\n"));
+ mutt_debug (1, "The name could not be resolved at this time. Future attempts may succeed.\n");
err=SASL_TRYAGAIN;
break;
case EAI_BADFLAGS:
- dprint (1, (debugfile, "The flags had an invalid value.\n"));
+ mutt_debug (1, "The flags had an invalid value.\n");
err=SASL_BADPARAM;
break;
case EAI_FAIL:
- dprint (1, (debugfile, "A non-recoverable error occurred.\n"));
+ mutt_debug (1, "A non-recoverable error occurred.\n");
err=SASL_FAIL;
break;
case EAI_FAMILY:
- dprint (1, (debugfile, "The address family was not recognized or the address length was invalid for the specified family.\n"));
+ mutt_debug (1, "The address family was not recognized or the address length was invalid for the specified family.\n");
err=SASL_BADPROT;
break;
case EAI_MEMORY:
- dprint (1, (debugfile, "There was a memory allocation failure.\n"));
+ mutt_debug (1, "There was a memory allocation failure.\n");
err=SASL_NOMEM;
break;
case EAI_NONAME:
- dprint (1, (debugfile, "The name does not resolve for the supplied parameters. NI_NAMEREQD is set and the host's name cannot be located, or both nodename and servname were null.\n"));
+ mutt_debug (1, "The name does not resolve for the supplied parameters. NI_NAMEREQD is set and the host's name cannot be located, or both nodename and servname were null.\n");
err=SASL_FAIL; /* no real equivalent */
break;
case EAI_SYSTEM:
- dprint (1, (debugfile, "A system error occurred. The error code can be found in errno(%d,%s)).\n",errno,strerror(errno)));
+ mutt_debug (1, "A system error occurred. The error code can be found in errno(%d,%s)).\n",errno,strerror(errno));
err=SASL_FAIL; /* no real equivalent */
break;
default:
- dprint (1, (debugfile, "Unknown error %d\n",ret));
+ mutt_debug (1, "Unknown error %d\n",ret);
err=SASL_FAIL; /* no real equivalent */
break;
}
if (rc != SASL_OK)
{
- dprint (1, (debugfile, "mutt_sasl_start: libsasl initialisation failed.\n"));
+ mutt_debug (1, "mutt_sasl_start: libsasl initialisation failed.\n");
return SASL_FAIL;
}
IP_PORT_BUFLEN) == SASL_OK)
plp = iplocalport;
else
- dprint (2, (debugfile, "SASL failed to parse local IP address\n"));
+ mutt_debug (2, "SASL failed to parse local IP address\n");
}
else
- dprint (2, (debugfile, "SASL failed to get local IP address\n"));
+ mutt_debug (2, "SASL failed to get local IP address\n");
size = sizeof (remote);
if (!getpeername (conn->fd, (struct sockaddr *)&remote, &size)){
IP_PORT_BUFLEN) == SASL_OK)
prp = ipremoteport;
else
- dprint (2, (debugfile, "SASL failed to parse remote IP address\n"));
+ mutt_debug (2, "SASL failed to parse remote IP address\n");
}
else
- dprint (2, (debugfile, "SASL failed to get remote IP address\n"));
+ mutt_debug (2, "SASL failed to get remote IP address\n");
- dprint (2, (debugfile, "SASL local ip: %s, remote ip:%s\n", NONULL(plp),
- NONULL(prp)));
+ mutt_debug (2, "SASL local ip: %s, remote ip:%s\n", NONULL(plp),
+ NONULL(prp));
rc = sasl_client_new (service, conn->account.host, plp, prp,
mutt_sasl_get_callbacks (&conn->account), 0, saslconn);
if (conn->ssf)
{
/* I'm not sure this actually has an effect, at least with SASLv2 */
- dprint (2, (debugfile, "External SSF: %d\n", conn->ssf));
+ mutt_debug (2, "External SSF: %d\n", conn->ssf);
if (sasl_setprop (*saslconn, SASL_SSF_EXTERNAL, &(conn->ssf)) != SASL_OK)
{
mutt_error (_("Error setting SASL external security strength"));
}
if (conn->account.user[0])
{
- dprint (2, (debugfile, "External authentication name: %s\n", conn->account.user));
+ mutt_debug (2, "External authentication name: %s\n", conn->account.user);
if (sasl_setprop (*saslconn, SASL_AUTH_EXTERNAL, conn->account.user) != SASL_OK)
{
mutt_error (_("Error setting SASL external user name"));
while (interaction->id != SASL_CB_LIST_END)
{
- dprint (2, (debugfile, "mutt_sasl_interact: filling in SASL interaction %ld.\n", interaction->id));
+ mutt_debug (2, "mutt_sasl_interact: filling in SASL interaction %ld.\n", interaction->id);
snprintf (prompt, sizeof (prompt), "%s: ", interaction->prompt);
resp[0] = '\0';
/* get ssf so we know whether we have to (en|de)code read/write */
sasl_getprop (saslconn, SASL_SSF, &tmp);
sasldata->ssf = tmp;
- dprint (3, (debugfile, "SASL protection strength: %u\n", *sasldata->ssf));
+ mutt_debug (3, "SASL protection strength: %u\n", *sasldata->ssf);
/* Add SASL SSF to transport SSF */
conn->ssf += *sasldata->ssf;
sasl_getprop (saslconn, SASL_MAXOUTBUF, &tmp);
sasldata->pbufsize = tmp;
- dprint (3, (debugfile, "SASL protection buffer size: %u\n", *sasldata->pbufsize));
+ mutt_debug (3, "SASL protection buffer size: %u\n", *sasldata->pbufsize);
/* clear input buffer */
sasldata->buf = NULL;
/* mutt_sasl_cb_log: callback to log SASL messages */
static int mutt_sasl_cb_log (void* context, int priority, const char* message)
{
- dprint (priority, (debugfile, "SASL: %s\n", message));
+ mutt_debug (priority, "SASL: %s\n", message);
return SASL_OK;
}
if (!account)
return SASL_BADPARAM;
- dprint (2, (debugfile, "mutt_sasl_cb_authname: getting %s for %s:%u\n",
+ mutt_debug (2, "mutt_sasl_cb_authname: getting %s for %s:%u\n",
id == SASL_CB_AUTHNAME ? "authname" : "user",
- account->host, account->port));
+ account->host, account->port);
if (id == SASL_CB_AUTHNAME)
{
if (!account || !psecret)
return SASL_BADPARAM;
- dprint (2, (debugfile,
- "mutt_sasl_cb_pass: getting password for %s@%s:%u\n", account->login,
- account->host, account->port));
+ mutt_debug (2, "mutt_sasl_cb_pass: getting password for %s@%s:%u\n",
+ account->login, account->host, account->port);
if (mutt_account_getpass (account))
return SASL_FAIL;
&sasldata->blen);
if (rc != SASL_OK)
{
- dprint (1, (debugfile, "SASL decode failed: %s\n",
- sasl_errstring (rc, NULL, NULL)));
+ mutt_debug (1, "SASL decode failed: %s\n",
+ sasl_errstring (rc, NULL, NULL));
goto out;
}
}
rc = sasl_encode (sasldata->saslconn, buf, olen, &pbuf, &plen);
if (rc != SASL_OK)
{
- dprint (1, (debugfile, "SASL encoding failed: %s\n",
- sasl_errstring (rc, NULL, NULL)));
+ mutt_debug (1, "SASL encoding failed: %s\n",
+ sasl_errstring (rc, NULL, NULL));
goto fail;
}
rc = conn->conn_open (conn);
- dprint (2, (debugfile, "Connected to %s:%d on fd=%d\n",
- NONULL (conn->account.host), conn->account.port, conn->fd));
+ mutt_debug (2, "Connected to %s:%d on fd=%d\n",
+ NONULL (conn->account.host), conn->account.port, conn->fd);
return rc;
}
int rc = -1;
if (conn->fd < 0)
- dprint (1, (debugfile, "mutt_socket_close: Attempt to close closed connection.\n"));
+ mutt_debug (1, "mutt_socket_close: Attempt to close closed connection.\n");
else
rc = conn->conn_close (conn);
if (conn->fd < 0)
{
- dprint (1, (debugfile, "mutt_socket_read: attempt to read from closed connection\n"));
+ mutt_debug (1, "mutt_socket_read: attempt to read from closed connection\n");
return -1;
}
int rc;
int sent = 0;
- dprint (dbg, (debugfile,"%d> %s", conn->fd, buf));
+ mutt_debug (dbg, "%d> %s", conn->fd, buf);
if (conn->fd < 0)
{
- dprint (1, (debugfile, "mutt_socket_write: attempt to write to closed connection\n"));
+ mutt_debug (1, "mutt_socket_write: attempt to write to closed connection\n");
return -1;
}
{
if ((rc = conn->conn_write (conn, buf + sent, len - sent)) < 0)
{
- dprint (1, (debugfile,
- "mutt_socket_write: error writing (%s), closing socket\n",
- strerror(errno)));
+ mutt_debug (1, "mutt_socket_write: error writing (%s), closing socket\n",
+ strerror(errno));
mutt_socket_close (conn);
return -1;
}
if (rc < len - sent)
- dprint (3, (debugfile,
- "mutt_socket_write: short write (%d of %d bytes)\n", rc,
- len - sent));
+ mutt_debug (3, "mutt_socket_write: short write (%d of %d bytes)\n",
+ rc, len - sent);
sent += rc;
}
conn->available = conn->conn_read (conn, conn->inbuf, sizeof (conn->inbuf));
else
{
- dprint (1, (debugfile, "mutt_socket_readchar: attempt to read from closed connection.\n"));
+ mutt_debug (1, "mutt_socket_readchar: attempt to read from closed connection.\n");
return -1;
}
conn->bufpos = 0;
i--;
buf[i] = '\0';
- dprint (dbg, (debugfile, "%d< %s\n", conn->fd, buf));
+ mutt_debug (dbg, "%d< %s\n", conn->fd, buf);
/* number of bytes read, not strlen */
return i + 1;
if (mutt_strlen (Preconnect))
{
- dprint (2, (debugfile, "Executing preconnect: %s\n", Preconnect));
+ mutt_debug (2, "Executing preconnect: %s\n", Preconnect);
rc = mutt_system (Preconnect);
- dprint (2, (debugfile, "Preconnect result: %d\n", rc));
+ mutt_debug (2, "Preconnect result: %d\n", rc);
if (rc)
{
save_errno = errno;
#endif
else
{
- dprint (1, (debugfile, "Unknown address family!\n"));
+ mutt_debug (1, "Unknown address family!\n");
return -1;
}
if (connect (fd, sa, sa_size) < 0)
{
save_errno = errno;
- dprint (2, (debugfile, "Connection failed. errno: %d...\n", errno));
+ mutt_debug (2, "Connection failed. errno: %d...\n", errno);
SigInt = 0; /* reset in case we caught SIGINTR while in connect() */
}
*/
if (! (ssldata->ctx = SSL_CTX_new (SSLv23_client_method())))
{
- dprint (1, (debugfile, "mutt_ssl_starttls: Error allocating SSL_CTX\n"));
+ mutt_debug (1, "mutt_ssl_starttls: Error allocating SSL_CTX\n");
goto bail_ssldata;
}
#ifdef SSL_OP_NO_TLSv1_2
#endif
if (! SSL_CTX_set_options(ssldata->ctx, ssl_options))
{
- dprint(1, (debugfile, "mutt_ssl_starttls: Error setting options to %ld\n", ssl_options));
+ mutt_debug (1, "mutt_ssl_starttls: Error setting options to %ld\n",
+ ssl_options);
goto bail_ctx;
}
{
if (! SSL_CTX_set_default_verify_paths (ssldata->ctx))
{
- dprint (1, (debugfile, "mutt_ssl_starttls: Error setting default verify paths\n"));
+ mutt_debug (1, "mutt_ssl_starttls: Error setting default verify paths\n");
goto bail_ctx;
}
}
if (SslCertFile && ! SSL_CTX_load_verify_locations (ssldata->ctx, SslCertFile, NULL))
- dprint (1, (debugfile, "mutt_ssl_starttls: Error loading trusted certificates\n"));
+ mutt_debug (1, "mutt_ssl_starttls: Error loading trusted certificates\n");
ssl_get_client_cert(ssldata, conn);
if (SslCiphers) {
if (!SSL_CTX_set_cipher_list (ssldata->ctx, SslCiphers)) {
- dprint (1, (debugfile, "mutt_ssl_starttls: Could not select preferred ciphers\n"));
+ mutt_debug (1, "mutt_ssl_starttls: Could not select preferred ciphers\n");
goto bail_ctx;
}
}
if (! (ssldata->ssl = SSL_new (ssldata->ctx)))
{
- dprint (1, (debugfile, "mutt_ssl_starttls: Error allocating SSL\n"));
+ mutt_debug (1, "mutt_ssl_starttls: Error allocating SSL\n");
goto bail_ctx;
}
if (SSL_set_fd (ssldata->ssl, conn->fd) != 1)
{
- dprint (1, (debugfile, "mutt_ssl_starttls: Error setting fd\n"));
+ mutt_debug (1, "mutt_ssl_starttls: Error setting fd\n");
goto bail_ssl;
}
{
if (! SSL_CTX_set_default_verify_paths (data->ctx))
{
- dprint (1, (debugfile, "ssl_socket_open: Error setting default verify paths\n"));
+ mutt_debug (1, "ssl_socket_open: Error setting default verify paths\n");
mutt_socket_close (conn);
return -1;
}
}
if (SslCertFile && ! SSL_CTX_load_verify_locations (data->ctx, SslCertFile, NULL))
- dprint (1, (debugfile, "ssl_socket_open: Error loading trusted certificates\n"));
+ mutt_debug (1, "ssl_socket_open: Error loading trusted certificates\n");
ssl_get_client_cert(data, conn);
if ((HostExDataIndex = SSL_get_ex_new_index (0, "host", NULL, NULL, NULL)) == -1)
{
- dprint (1, (debugfile, "failed to get index for application specific data\n"));
+ mutt_debug (1, "failed to get index for application specific data\n");
return -1;
}
if (! SSL_set_ex_data (ssldata->ssl, HostExDataIndex, conn->account.host))
{
- dprint (1, (debugfile, "failed to save hostname in SSL structure\n"));
+ mutt_debug (1, "failed to save hostname in SSL structure\n");
return -1;
}
errmsg = "unknown error";
}
- dprint (1, (debugfile, "SSL error: %s\n", errmsg));
+ mutt_debug (1, "SSL error: %s\n", errmsg);
}
static void ssl_dprint_err_stack (void)
output = safe_malloc (buflen + 1);
memcpy (output, buf, buflen);
output[buflen] = '\0';
- dprint (1, (debugfile, "SSL error stack: %s\n", output));
+ mutt_debug (1, "SSL error stack: %s\n", output);
FREE (&output);
}
BIO_free (bio);
{
if (X509_cmp_current_time (X509_get_notBefore (peercert)) >= 0)
{
- dprint (2, (debugfile, "Server certificate is not yet valid\n"));
+ mutt_debug (2, "Server certificate is not yet valid\n");
mutt_error (_("Server certificate is not yet valid"));
mutt_sleep (2);
return 0;
}
if (X509_cmp_current_time (X509_get_notAfter (peercert)) <= 0)
{
- dprint (2, (debugfile, "Server certificate has expired"));
+ mutt_debug (2, "Server certificate has expired");
mutt_error (_("Server certificate has expired"));
mutt_sleep (2);
return 0;
static int ssl_cache_trusted_cert (X509 *c)
{
- dprint (1, (debugfile, "ssl_cache_trusted_cert: trusted\n"));
+ mutt_debug (1, "ssl_cache_trusted_cert: trusted\n");
if (!SslSessionCerts)
SslSessionCerts = sk_X509_new_null();
return (sk_X509_push (SslSessionCerts, X509_dup(c)));
if (! (ssl = X509_STORE_CTX_get_ex_data (ctx, SSL_get_ex_data_X509_STORE_CTX_idx ())))
{
- dprint (1, (debugfile, "ssl_verify_callback: failed to retrieve SSL structure from X509_STORE_CTX\n"));
+ mutt_debug (1, "ssl_verify_callback: failed to retrieve SSL structure from X509_STORE_CTX\n");
return 0;
}
if (! (host = SSL_get_ex_data (ssl, HostExDataIndex)))
{
- dprint (1, (debugfile, "ssl_verify_callback: failed to retrieve hostname from SSL structure\n"));
+ mutt_debug (1, "ssl_verify_callback: failed to retrieve hostname from SSL structure\n");
return 0;
}
pos = X509_STORE_CTX_get_error_depth (ctx);
len = sk_X509_num (X509_STORE_CTX_get_chain (ctx));
- dprint (1, (debugfile, "ssl_verify_callback: checking cert chain entry %s (preverify: %d)\n",
+ mutt_debug (1, "ssl_verify_callback: checking cert chain entry %s (preverify: %d)\n",
X509_NAME_oneline (X509_get_subject_name (cert),
- buf, sizeof (buf)), preverify_ok));
+ buf, sizeof (buf)), preverify_ok);
/* check session cache first */
if (check_certificate_cache (cert))
{
- dprint (2, (debugfile, "ssl_verify_callback: using cached certificate\n"));
+ mutt_debug (2, "ssl_verify_callback: using cached certificate\n");
return 1;
}
mutt_sleep (2);
return interactive_check_cert (cert, pos, len);
}
- dprint (2, (debugfile, "ssl_verify_callback: hostname check passed\n"));
+ mutt_debug (2, "ssl_verify_callback: hostname check passed\n");
}
if (!preverify_ok)
/* automatic check from user's database */
if (SslCertFile && check_certificate_by_digest (cert))
{
- dprint (2, (debugfile, "ssl_verify_callback: digest check passed\n"));
+ mutt_debug (2, "ssl_verify_callback: digest check passed\n");
return 1;
}
int err = X509_STORE_CTX_get_error (ctx);
snprintf (buf, sizeof (buf), "%s (%d)",
X509_verify_cert_error_string (err), err);
- dprint (2, (debugfile, "X509_verify_cert: %s\n", buf));
+ mutt_debug (2, "X509_verify_cert: %s\n", buf);
}
#endif
unset_option(OPTIGNOREMACROEVENTS);
mutt_menuDestroy (&menu);
set_option (OPTNEEDREDRAW);
- dprint (2, (debugfile, "ssl interactive_check_cert: done=%d\n", done));
+ mutt_debug (2, "ssl interactive_check_cert: done=%d\n", done);
return (done == 2);
}
{
if (SslClientCert)
{
- dprint (2, (debugfile, "Using client certificate %s\n", SslClientCert));
+ mutt_debug (2, "Using client certificate %s\n", SslClientCert);
SSL_CTX_set_default_passwd_cb_userdata(ssldata->ctx, &conn->account);
SSL_CTX_set_default_passwd_cb(ssldata->ctx, ssl_passwd_cb);
SSL_CTX_use_certificate_file(ssldata->ctx, SslClientCert, SSL_FILETYPE_PEM);
if (mutt_account_getuser (account))
return 0;
- dprint (2, (debugfile, "ssl_passwd_cb: getting password for %s@%s:%u\n",
- account->user, account->host, account->port));
+ mutt_debug (2, "ssl_passwd_cb: getting password for %s@%s:%u\n",
+ account->user, account->host, account->port);
if (mutt_account_getpass (account))
return 0;
if (gnutls_x509_crt_init (&clientcrt) < 0)
{
- dprint (1, (debugfile, "Failed to init gnutls crt\n"));
+ mutt_debug (1, "Failed to init gnutls crt\n");
return;
}
if (gnutls_x509_crt_import (clientcrt, crtdata, GNUTLS_X509_FMT_DER) < 0)
{
- dprint (1, (debugfile, "Failed to import gnutls client crt\n"));
+ mutt_debug (1, "Failed to import gnutls client crt\n");
goto err_crt;
}
/* get length of DN */
gnutls_x509_crt_get_dn (clientcrt, NULL, &dnlen);
if (!(dn = calloc (1, dnlen)))
{
- dprint (1, (debugfile, "could not allocate DN\n"));
+ mutt_debug (1, "could not allocate DN\n");
goto err_crt;
}
gnutls_x509_crt_get_dn (clientcrt, dn, &dnlen);
- dprint (2, (debugfile, "client certificate DN: %s\n", dn));
+ mutt_debug (2, "client certificate DN: %s\n", dn);
/* extract CN to use as external user name */
if (!(cn = strstr (dn, "CN=")))
{
- dprint (1, (debugfile, "no CN found in DN\n"));
+ mutt_debug (1, "no CN found in DN\n");
goto err_dn;
}
cn += 3;
if (SslClientCert)
{
- dprint (2, (debugfile, "Using client certificate %s\n", SslClientCert));
+ mutt_debug (2, "Using client certificate %s\n", SslClientCert);
gnutls_certificate_set_x509_key_file (data->xcred, SslClientCert,
SslClientCert, GNUTLS_X509_FMT_PEM);
}
rc = gnutls_certificate_set_x509_trust_mem (data->xcred, &cert_list[i],
GNUTLS_X509_FMT_DER);
if (rc != 1)
- dprint (1, (debugfile, "error trusting certificate %d: %d\n", i, rc));
+ mutt_debug (1, "error trusting certificate %d: %d\n", i, rc);
certstat = tls_verify_peers (state);
/* If the cert chain now verifies, and the peer's cert was otherwise
{
if (b->unlink)
unlink (b->filename);
- dprint (1, (debugfile, "mutt_free_body: %sunlinking %s.\n",
- b->unlink ? "" : "not ", b->filename));
+ mutt_debug (1, "mutt_free_body: %sunlinking %s.\n",
+ b->unlink ? "" : "not ", b->filename);
}
FREE (&b->filename);
(int) getuid (), (int) getpid (), mutt_rand64(),
suffix ? "." : "", NONULL (suffix));
if (n >= slen)
- dprint (1, (debugfile, "%s:%d: ERROR: insufficient buffer space to hold temporary filename! slen=%zu but need %zu\n",
- src, line, slen, n));
- dprint (3, (debugfile, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, s));
+ mutt_debug (1, "%s:%d: ERROR: insufficient buffer space to hold temporary "
+ "filename! slen=%zu but need %zu\n",
+ src, line, slen, n);
+ mutt_debug (3, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, s);
if (unlink (s) && errno != ENOENT)
- dprint (1, (debugfile, "%s:%d: ERROR: unlink(\"%s\"): %s (errno %d)\n", src, line, s, strerror (errno), errno));
+ mutt_debug (1, "%s:%d: ERROR: unlink(\"%s\"): %s (errno %d)\n",
+ src, line, s, strerror (errno), errno);
}
void mutt_free_alias (ALIAS **p)
int i = 0;
#endif
- dprint(3, (debugfile, "fmtpipe = %s\n", src));
+ mutt_debug (3, "fmtpipe = %s\n", src);
strncpy(srccopy, src, n);
srccopy[n-1] = '\0';
char *p;
/* Extract the command name and copy to command line */
- dprint(3, (debugfile, "fmtpipe +++: %s\n", srcbuf->dptr));
+ mutt_debug (3, "fmtpipe +++: %s\n", srcbuf->dptr);
if (word->data)
*word->data = '\0';
mutt_extract_token(word, srcbuf, 0);
- dprint(3, (debugfile, "fmtpipe %2d: %s\n", i++, word->data));
+ mutt_debug (3, "fmtpipe %2d: %s\n", i++, word->data);
mutt_buffer_addch(command, '\'');
mutt_FormatString(buf, sizeof(buf), 0, cols, word->data, callback, data,
flags | MUTT_FORMAT_NOFILTER);
mutt_buffer_addch(command, ' ');
} while (MoreArgs(srcbuf));
- dprint(3, (debugfile, "fmtpipe > %s\n", command->data));
+ mutt_debug (3, "fmtpipe > %s\n", command->data);
col -= wlen; /* reset to passed in value */
wptr = dest; /* reset write ptr */
safe_fclose (&filter);
rc = mutt_wait_filter(pid);
if (rc != 0)
- dprint(1, (debugfile, "format pipe command exited code %d\n", rc));
+ mutt_debug (1, "format pipe command exited code %d\n", rc);
if (n > 0) {
dest[n] = 0;
while ((n > 0) && (dest[n-1] == '\n' || dest[n-1] == '\r'))
dest[--n] = '\0';
- dprint(3, (debugfile, "fmtpipe < %s\n", dest));
+ mutt_debug (3, "fmtpipe < %s\n", dest);
/* If the result ends with '%', this indicates that the filter
* generated %-tokens that mutt can expand. Eliminate the '%'
else
{
/* read error */
- dprint(1, (debugfile, "error reading from fmtpipe: %s (errno=%d)\n", strerror(errno), errno));
+ mutt_debug (1, "error reading from fmtpipe: %s (errno=%d)\n",
+ strerror(errno), errno);
*wptr = 0;
}
}
{
if (regexec (l->rx->rx, s, (size_t) 0, (regmatch_t *) 0, (int) 0) == 0)
{
- dprint (5, (debugfile, "mutt_match_rx_list: %s matches %s\n", s, l->rx->pattern));
+ mutt_debug (5, "mutt_match_rx_list: %s matches %s\n", s, l->rx->pattern);
return 1;
}
}
/* Does this pattern match? */
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", (int)l->rx->rx->re_nsub));
+ mutt_debug (5, "mutt_match_spam_list: %s matches %s\n", s, l->rx->pattern);
+ mutt_debug (5, "mutt_match_spam_list: %d subs\n", (int)l->rx->rx->re_nsub);
/* Copy template into text, with substitutions. */
for (p = l->template; *p && tlen < textsize - 1;)
* the validity of the text pointer. */
if (tlen < textsize) {
text[tlen] = '\0';
- dprint (5, (debugfile, "mutt_match_spam_list: \"%s\"\n", text));
+ mutt_debug (5, "mutt_match_spam_list: \"%s\"\n", text);
}
return 1;
}
attempt = 0;
while (fcntl (fd, F_SETLK, &lck) == -1)
{
- dprint(1,(debugfile, "mx_lock_file(): fcntl errno %d.\n", errno));
+ mutt_debug (1, "mx_lock_file(): fcntl errno %d.\n", errno);
if (errno != EAGAIN && errno != EACCES)
{
mutt_perror ("fcntl");
if (stat (path, &st) == -1)
{
- dprint (1, (debugfile, "mx_get_magic(): unable to stat %s: %s (errno %d).\n",
- path, strerror (errno), errno));
+ mutt_debug (1, "mx_get_magic(): unable to stat %s: %s (errno %d).\n",
+ path, strerror (errno), errno);
return (-1);
}
}
else
{
- dprint (1, (debugfile, "mx_get_magic(): unable to open file %s for reading.\n",
- path));
+ mutt_debug (1, "mx_get_magic(): unable to open file %s for reading.\n",
+ path);
return (-1);
}
if (!dest->mx_ops || !dest->mx_ops->open_new_msg)
{
- dprint (1, (debugfile, "mx_open_new_message(): function unimplemented for mailbox type %d.\n",
- dest->magic));
+ mutt_debug (1, "mx_open_new_message(): function unimplemented for mailbox type %d.\n",
+ dest->magic);
return NULL;
}
{
if (!ctx || !ctx->mx_ops)
{
- dprint (1, (debugfile, "mx_check_mailbox: null or invalid context.\n"));
+ mutt_debug (1, "mx_check_mailbox: null or invalid context.\n");
return -1;
}
if (!ctx->mx_ops || !ctx->mx_ops->open_msg)
{
- dprint (1, (debugfile, "mx_open_message(): function not implemented for mailbox type %d.\n", ctx->magic));
+ mutt_debug (1, "mx_open_message(): function not implemented for mailbox type %d.\n",
+ ctx->magic);
return NULL;
}
if (!(msg->write && ctx->append))
{
- dprint (1, (debugfile, "mx_commit_message(): msg->write = %d, ctx->append = %d\n",
- msg->write, ctx->append));
+ mutt_debug (1, "mx_commit_message(): msg->write = %d, ctx->append = %d\n",
+ msg->write, ctx->append);
return -1;
}
if ((*msg)->path)
{
- dprint (1, (debugfile, "mx_close_message (): unlinking %s\n",
- (*msg)->path));
+ mutt_debug (1, "mx_close_message (): unlinking %s\n", (*msg)->path);
unlink ((*msg)->path);
FREE (&(*msg)->path);
}
if (!nserv->newsrc_fp)
return;
- dprint (1, (debugfile, "Unlocking %s\n", nserv->newsrc_file));
+ mutt_debug (1, "Unlocking %s\n", nserv->newsrc_file);
mx_unlock_file (nserv->newsrc_file, fileno (nserv->newsrc_fp), 0);
safe_fclose (&nserv->newsrc_fp);
}
}
/* lock it */
- dprint (1, (debugfile, "Locking %s\n", nserv->newsrc_file));
+ mutt_debug (1, "Locking %s\n", nserv->newsrc_file);
if (mx_lock_file (nserv->newsrc_file, fileno (nserv->newsrc_fp), 0, 0, 1))
{
safe_fclose (&nserv->newsrc_fp);
nserv->size = sb.st_size;
nserv->mtime = sb.st_mtime;
nserv->newsrc_modified = 1;
- dprint (1, (debugfile, "Parsing %s\n", nserv->newsrc_file));
+ mutt_debug (1, "Parsing %s\n", nserv->newsrc_file);
/* .newsrc has been externally modified or hasn't been loaded yet */
for (i = 0; i < nserv->groups_num; i++)
nntp_data->newsrc_len = i;
safe_realloc (&nntp_data->newsrc_ent, i * sizeof (NEWSRC_ENTRY));
nntp_group_unread_stat (nntp_data);
- dprint (2, (debugfile, "nntp_newsrc_parse: %s\n", nntp_data->group));
+ mutt_debug (2, "nntp_newsrc_parse: %s\n", nntp_data->group);
}
FREE (&line);
return 1;
buf[off] = '\0';
/* newrc being fully rewritten */
- dprint (1, (debugfile, "Updating %s\n", nserv->newsrc_file));
+ mutt_debug (1, "Updating %s\n", nserv->newsrc_file);
if (nserv->newsrc_file && update_file (nserv->newsrc_file, buf) == 0)
{
struct stat sb;
FILE *fp;
cache_expand (file, sizeof (file), &nserv->conn->account, ".active");
- dprint (1, (debugfile, "Parsing %s\n", file));
+ mutt_debug (1, "Parsing %s\n", file);
fp = safe_fopen (file, "r");
if (!fp)
return -1;
}
cache_expand (file, sizeof (file), &nserv->conn->account, ".active");
- dprint (1, (debugfile, "Updating %s\n", file));
+ mutt_debug (1, "Updating %s\n", file);
rc = update_file (file, buf);
FREE (&buf);
return rc;
hdata = mutt_hcache_fetch_raw (hc, "index", 5);
if (hdata)
{
- dprint (2, (debugfile,
- "nntp_hcache_update: mutt_hcache_fetch index: %s\n", hdata));
+ mutt_debug (2, "nntp_hcache_update: mutt_hcache_fetch index: %s\n", hdata);
if (sscanf (hdata, ANUM " " ANUM, &first, &last) == 2)
{
old = 1;
continue;
snprintf (buf, sizeof (buf), "%d", current);
- dprint (2, (debugfile,
- "nntp_hcache_update: mutt_hcache_delete %s\n", buf));
+ mutt_debug (2, "nntp_hcache_update: mutt_hcache_delete %s\n", buf);
mutt_hcache_delete (hc, buf, strlen(buf));
}
}
{
snprintf (buf, sizeof (buf), "%u %u", nntp_data->firstMessage,
nntp_data->lastMessage);
- dprint (2, (debugfile,
- "nntp_hcache_update: mutt_hcache_store index: %s\n", buf));
+ mutt_debug (2, "nntp_hcache_update: mutt_hcache_store index: %s\n", buf);
mutt_hcache_store_raw (hc, "index", 5, buf, strlen (buf));
}
}
anum < nntp_data->firstMessage || anum > nntp_data->lastMessage)
{
if (nntp_data)
- dprint (2, (debugfile, "nntp_bcache_delete: mutt_bcache_del %s\n", id));
+ mutt_debug (2, "nntp_bcache_delete: mutt_bcache_del %s\n", id);
mutt_bcache_del (bcache, id);
}
return 0;
cache_expand (file, sizeof (file), &nntp_data->nserv->conn->account, file);
unlink (file);
nntp_data->lastCached = 0;
- dprint (2, (debugfile, "nntp_delete_group_cache: %s\n", file));
+ mutt_debug (2, "nntp_delete_group_cache: %s\n", file);
#endif
if (!nntp_data->bcache)
nntp_data->group);
if (nntp_data->bcache)
{
- dprint (2, (debugfile, "nntp_delete_group_cache: %s/*\n", nntp_data->group));
+ mutt_debug (2, "nntp_delete_group_cache: %s/*\n", nntp_data->group);
mutt_bcache_list (nntp_data->bcache, nntp_bcache_delete, NULL);
mutt_bcache_close (&nntp_data->bcache);
}
if (S_ISDIR (sb.st_mode))
{
rmdir (file);
- dprint (2, (debugfile, "nntp_clear_cache: %s\n", file));
+ mutt_debug (2, "nntp_clear_cache: %s\n", file);
}
}
closedir (dp);
last <= nntp_data->lastMessage)
{
nntp_data->lastCached = last;
- dprint (2, (debugfile, "nntp_select_server: %s lastCached=%u\n",
- nntp_data->group, last));
+ mutt_debug (2, "nntp_select_server: %s lastCached=%u\n",
+ nntp_data->group, last);
}
}
mutt_hcache_free (hc, &hdata);
p++;
}
- dprint (1, (debugfile,
- "nntp_auth: available methods: %s\n", nserv->authenticators));
+ mutt_debug (1, "nntp_auth: available methods: %s\n", nserv->authenticators);
a = authenticators;
while (1)
{
if (*m != '\0' && *m != ' ')
continue;
}
- dprint (1, (debugfile, "nntp_auth: trying method %s\n", method));
+ mutt_debug (1, "nntp_auth: trying method %s\n", method);
/* AUTHINFO USER authentication */
if (!strcmp (method, "USER"))
{
#ifdef DEBUG
if (debuglevel < MUTT_SOCK_LOG_FULL)
- dprint (MUTT_SOCK_LOG_CMD, (debugfile,
- "%d> AUTHINFO PASS *\n", conn->fd));
+ mutt_debug (MUTT_SOCK_LOG_CMD, "%d> AUTHINFO PASS *\n", conn->fd);
#endif
snprintf (buf, sizeof (buf), "AUTHINFO PASS %s\r\n",
conn->account.pass);
if (mutt_sasl_client_new (conn, &saslconn) < 0)
{
- dprint (1, (debugfile,
- "nntp_auth: error allocating SASL connection.\n"));
+ mutt_debug (1, "nntp_auth: error allocating SASL connection.\n");
continue;
}
if (rc != SASL_OK && rc != SASL_CONTINUE)
{
sasl_dispose (&saslconn);
- dprint (1, (debugfile,
- "nntp_auth: error starting SASL authentication exchange.\n"));
+ mutt_debug (1, "nntp_auth: error starting SASL authentication exchange.\n");
continue;
}
*p = '.';
}
*p = '\0';
- dprint (1, (debugfile, "SASL> %s\n", tmp));
+ mutt_debug (1, "SASL> %s\n", tmp);
}
#endif
if (sasl_encode64 (client_out, client_len,
buf + len, sizeof (buf) - len, &len) != SASL_OK)
{
- dprint (1, (debugfile,
- "nntp_auth: error base64-encoding client response.\n"));
+ mutt_debug (1, "nntp_auth: error base64-encoding client response.\n");
break;
}
}
if (debuglevel < MUTT_SOCK_LOG_FULL)
{
if (strchr (buf, ' '))
- dprint (MUTT_SOCK_LOG_CMD, (debugfile, "%d> AUTHINFO SASL %s%s\n",
- conn->fd, method, client_len ? " sasl_data" : ""));
+ mutt_debug (MUTT_SOCK_LOG_CMD, "%d> AUTHINFO SASL %s%s\n",
+ conn->fd, method, client_len ? " sasl_data" : "");
else
- dprint (MUTT_SOCK_LOG_CMD, (debugfile, "%d> sasl_data\n", conn->fd));
+ mutt_debug (MUTT_SOCK_LOG_CMD, "%d> sasl_data\n", conn->fd);
}
#endif
client_len = 0;
{
#ifdef DEBUG
if (debuglevel < MUTT_SOCK_LOG_FULL)
- dprint (MUTT_SOCK_LOG_CMD, (debugfile, "%d< %s\n", conn->fd, inbuf));
+ mutt_debug (MUTT_SOCK_LOG_CMD, "%d< %s\n", conn->fd, inbuf);
#endif
break;
}
if (debuglevel < MUTT_SOCK_LOG_FULL)
{
inbuf[3] = '\0';
- dprint (MUTT_SOCK_LOG_CMD, (debugfile,
- "%d< %s sasl_data\n", conn->fd, inbuf));
+ mutt_debug (MUTT_SOCK_LOG_CMD, "%d< %s sasl_data\n",
+ conn->fd, inbuf);
}
#endif
else if (sasl_decode64 (inbuf + 4, strlen (inbuf + 4),
buf, sizeof (buf) - 1, &len) != SASL_OK)
{
- dprint (1, (debugfile,
- "nntp_auth: error base64-decoding server response.\n"));
+ mutt_debug (1, "nntp_auth: error base64-decoding server response.\n");
break;
}
#ifdef DEBUG
*p = '.';
}
*p = '\0';
- dprint (1, (debugfile, "SASL< %s\n", tmp));
+ mutt_debug (1, "SASL< %s\n", tmp);
}
#endif
if (nntp_data && mutt_strcmp (desc, nntp_data->desc))
{
mutt_str_replace (&nntp_data->desc, desc);
- dprint (2, (debugfile, "group: %s, desc: %s\n", line, desc));
+ mutt_debug (2, "group: %s, desc: %s\n", line, desc);
}
return 0;
}
*field++ = '\0';
if (sscanf (line, ANUM, &anum) != 1)
return 0;
- dprint (2, (debugfile, "parse_overview_line: " ANUM "\n", anum));
+ mutt_debug (2, "parse_overview_line: " ANUM "\n", anum);
/* out of bounds */
if (anum < fc->first || anum > fc->last)
hdata = mutt_hcache_fetch (fc->hc, buf, strlen(buf));
if (hdata)
{
- dprint (2, (debugfile,
- "parse_overview_line: mutt_hcache_fetch %s\n", buf));
+ mutt_debug (2, "parse_overview_line: mutt_hcache_fetch %s\n", buf);
mutt_free_header (&hdr);
ctx->hdrs[ctx->msgcount] =
hdr = mutt_hcache_restore (hdata);
{
if (nntp_data->bcache)
{
- dprint (2, (debugfile,
- "parse_overview_line: mutt_bcache_del %s\n", buf));
+ mutt_debug (2, "parse_overview_line: mutt_bcache_del %s\n", buf);
mutt_bcache_del (nntp_data->bcache, buf);
}
save = 0;
/* not chached yet, store header */
else
{
- dprint (2, (debugfile,
- "parse_overview_line: mutt_hcache_store %s\n", buf));
+ mutt_debug (2, "parse_overview_line: mutt_hcache_store %s\n", buf);
mutt_hcache_store (fc->hc, buf, strlen(buf), hdr, 0);
}
}
snprintf (buf, sizeof (buf), "%d", current);
if (nntp_data->bcache)
{
- dprint (2, (debugfile,
- "nntp_fetch_headers: mutt_bcache_del %s\n", buf));
+ mutt_debug (2, "nntp_fetch_headers: mutt_bcache_del %s\n", buf);
mutt_bcache_del (nntp_data->bcache, buf);
}
#ifdef USE_HCACHE
if (fc.hc)
{
- dprint (2, (debugfile,
- "nntp_fetch_headers: mutt_hcache_delete %s\n", buf));
+ mutt_debug (2, "nntp_fetch_headers: mutt_hcache_delete %s\n", buf);
mutt_hcache_delete (fc.hc, buf, strlen(buf));
}
#endif
hdata = mutt_hcache_fetch (fc.hc, buf, strlen(buf));
if (hdata)
{
- dprint (2, (debugfile,
- "nntp_fetch_headers: mutt_hcache_fetch %s\n", buf));
+ mutt_debug (2, "nntp_fetch_headers: mutt_hcache_fetch %s\n", buf);
ctx->hdrs[ctx->msgcount] =
hdr = mutt_hcache_restore (hdata);
mutt_hcache_free (fc.hc, &hdata);
mutt_free_header (&hdr);
if (nntp_data->bcache)
{
- dprint (2, (debugfile,
- "nntp_fetch_headers: mutt_bcache_del %s\n", buf));
+ mutt_debug (2, "nntp_fetch_headers: mutt_bcache_del %s\n", buf);
mutt_bcache_del (nntp_data->bcache, buf);
}
continue;
if (nntp_data->bcache)
{
snprintf (buf, sizeof (buf), "%d", current);
- dprint (2, (debugfile,
- "nntp_fetch_headers: mutt_bcache_del %s\n", buf));
+ mutt_debug (2, "nntp_fetch_headers: mutt_bcache_del %s\n", buf);
mutt_bcache_del (nntp_data->bcache, buf);
}
rc = 0;
snprintf (buf, sizeof (buf), "%d", NHDR (hdr)->article_num);
if (nntp_data->bcache && hdr->deleted)
{
- dprint (2, (debugfile, "nntp_sync_mailbox: mutt_bcache_del %s\n", buf));
+ mutt_debug (2, "nntp_sync_mailbox: mutt_bcache_del %s\n", buf);
mutt_bcache_del (nntp_data->bcache, buf);
}
{
if (hdr->deleted && !hdr->read)
nntp_data->unread--;
- dprint (2, (debugfile, "nntp_sync_mailbox: mutt_hcache_store %s\n", buf));
+ mutt_debug (2, "nntp_sync_mailbox: mutt_hcache_store %s\n", buf);
mutt_hcache_store (hc, buf, strlen(buf), hdr, 0);
}
#endif
*now = timegm (&tm);
if (*now >= 0)
{
- dprint (1, (debugfile, "nntp_date: server time is %d\n", *now));
+ mutt_debug (1, "nntp_date: server time is %d\n", *now);
return 0;
}
}
{
int deleted;
- dprint (2, (debugfile,
- "nntp_check_mailbox: mutt_hcache_fetch %s\n", buf));
+ mutt_debug (2, "nntp_check_mailbox: mutt_hcache_fetch %s\n", buf);
hdr = mutt_hcache_restore (hdata);
mutt_hcache_free (hc, &hdata);
hdr->data = 0;
hdata = mutt_hcache_fetch (hc, buf, strlen(buf));
if (hdata)
{
- dprint (2, (debugfile,
- "nntp_check_mailbox: mutt_hcache_fetch %s\n", buf));
+ mutt_debug (2, "nntp_check_mailbox: mutt_hcache_fetch %s\n", buf);
if (ctx->msgcount >= ctx->hdrmax)
mx_alloc_memory (ctx);
mutt_free_header (&hdr);
if (nntp_data->bcache)
{
- dprint (2, (debugfile,
- "nntp_check_mailbox: mutt_bcache_del %s\n", buf));
+ mutt_debug (2, "nntp_check_mailbox: mutt_bcache_del %s\n", buf);
mutt_bcache_del (nntp_data->bcache, buf);
}
continue;
}
else if (*p == '\033' && *(p+1) == ']' && check_attachment_marker ((char *) p) == 0)
{
- dprint (2, (debugfile, "fill_buffer: Seen attachment marker.\n"));
+ mutt_debug (2, "fill_buffer: Seen attachment marker.\n");
while (*p++ != '\a') /* skip pseudo-ANSI sequence */
;
}
{
if (k == (size_t)(-1))
memset(&mbstate, 0, sizeof(mbstate));
- dprint (1, (debugfile, "%s:%d: mbrtowc returned %d; errno = %d.\n",
- __FILE__, __LINE__, k, errno));
+ mutt_debug (1, "%s:%d: mbrtowc returned %d; errno = %d.\n",
+ __FILE__, __LINE__, k, errno);
if (col + 4 > wrap_cols)
break;
col += 4;
{
if (wc == 0x200B || wc == 0xFEFF)
{
- dprint (3, (debugfile, "skip zero-width character U+%04X\n", (unsigned short)wc));
+ mutt_debug (3, "skip zero-width character U+%04X\n", (unsigned short)wc);
continue;
}
if (is_display_corrupting_utf8 (wc))
{
- dprint (3, (debugfile, "filtered U+%04X\n", (unsigned short)wc));
+ mutt_debug (3, "filtered U+%04X\n", (unsigned short)wc);
continue;
}
}
const char *p;
size_t i;
- dprint (2, (debugfile, "parse_parameters: `%s'\n", s));
+ mutt_debug (2, "parse_parameters: `%s'\n", s);
while (*s)
{
if ((p = strpbrk (s, "=;")) == NULL)
{
- dprint(1, (debugfile, "parse_parameters: malformed parameter: %s\n", s));
+ mutt_debug (1, "parse_parameters: malformed parameter: %s\n", s);
goto bail;
}
*/
if (i == 0)
{
- dprint(1, (debugfile, "parse_parameters: missing attribute: %s\n", s));
+ mutt_debug (1, "parse_parameters: missing attribute: %s\n", s);
new = NULL;
}
else
{
new->value = safe_strdup (buffer);
- dprint (2, (debugfile, "parse_parameter: `%s' = `%s'\n",
- new->attribute ? new->attribute : "",
- new->value ? new->value : ""));
+ mutt_debug (2, "parse_parameter: `%s' = `%s'\n",
+ new->attribute ? new->attribute : "",
+ new->value ? new->value : "");
/* Add this parameter to the list */
if (head)
}
else
{
- dprint (1, (debugfile, "parse_parameters(): parameter with no value: %s\n", s));
+ mutt_debug (1, "parse_parameters(): parameter with no value: %s\n", s);
s = p;
}
c = skip_email_wsp(c + 1);
if (!*c)
{
- dprint (1, (debugfile, "mutt_read_mime_header(): skipping empty header field: %s\n", line));
+ mutt_debug (1, "mutt_read_mime_header(): skipping empty header field: %s\n",
+ line);
continue;
}
}
else
{
- dprint (1, (debugfile, "read_mime_header: bogus MIME header: %s\n", line));
+ mutt_debug (1, "read_mime_header: bogus MIME header: %s\n", line);
break;
}
sec = 0;
else
{
- dprint(1, (debugfile, "parse_date: could not process time format: %s\n", t));
+ mutt_debug (1, "parse_date: could not process time format: %s\n", t);
return(-1);
}
tm.tm_hour = hour;
if (count < 4) /* don't check for missing timezone */
{
- dprint(1,(debugfile, "parse_date(): error parsing date format, using received time\n"));
+ mutt_debug (1, "parse_date(): error parsing date format, using received time\n");
return (-1);
}
}
if (e->spam && e->spam->data)
- dprint(5, (debugfile, "p822: spam = %s\n", e->spam->data));
+ mutt_debug (5, "p822: spam = %s\n", e->spam->data);
}
}
if (hdr->received < 0)
{
- dprint(1,(debugfile,"read_rfc822_header(): resetting invalid received time to 0\n"));
+ mutt_debug (1, "read_rfc822_header(): resetting invalid received time to 0\n");
hdr->received = 0;
}
/* check for missing or invalid date */
if (hdr->date_sent <= 0)
{
- dprint(1,(debugfile,"read_rfc822_header(): no date found, using received time from msg separator\n"));
+ mutt_debug (1, "read_rfc822_header(): no date found, using received time from msg separator\n");
hdr->date_sent = hdr->received;
}
}
for (type = *checklist; type; type = type->next)
{
a = (ATTACH_MATCH *)type->data;
- dprint(5, (debugfile, "cbpc: %s %d/%s ?? %s/%s [%d]... ",
- dflt ? "[OK] " : "[EXCL] ",
- b->type, b->subtype, a->major, a->minor, a->major_int));
+ mutt_debug (5, "cbpc: %s %d/%s ?? %s/%s [%d]... ",
+ dflt ? "[OK] " : "[EXCL] ",
+ b->type, b->subtype, a->major, a->minor, a->major_int);
if ((a->major_int == TYPEANY || a->major_int == b->type) &&
!regexec(&a->minor_rx, b->subtype, 0, NULL, 0))
{
- dprint(5, (debugfile, "yes\n"));
+ mutt_debug (5, "yes\n");
return 1;
}
else
{
- dprint(5, (debugfile, "no\n"));
+ mutt_debug (5, "no\n");
}
}
AT_COUNT("default");
shallrecurse = 0;
- dprint(5, (debugfile, "bp: desc=\"%s\"; fn=\"%s\", type=\"%d/%s\"\n",
- bp->description ? bp->description : ("none"),
- bp->filename ? bp->filename :
- bp->d_filename ? bp->d_filename : "(none)",
- bp->type, bp->subtype ? bp->subtype : "*"));
+ mutt_debug (5, "bp: desc=\"%s\"; fn=\"%s\", type=\"%d/%s\"\n",
+ bp->description ? bp->description : ("none"),
+ bp->filename ? bp->filename :
+ bp->d_filename ? bp->d_filename : "(none)",
+ bp->type, bp->subtype ? bp->subtype : "*");
if (bp->type == TYPEMESSAGE)
{
count++;
bp->attach_qualifies = shallcount ? 1 : 0;
- dprint(5, (debugfile, "cbp: %p shallcount = %d\n", (void *)bp, shallcount));
+ mutt_debug (5, "cbp: %p shallcount = %d\n", (void *)bp, shallcount);
if (shallrecurse)
{
- dprint(5, (debugfile, "cbp: %p pre count = %d\n", (void *)bp, count));
+ mutt_debug (5, "cbp: %p pre count = %d\n", (void *)bp, count);
bp->attach_count = count_body_parts(bp->parts, flags & ~MUTT_PARTS_TOPLEVEL);
count += bp->attach_count;
- dprint(5, (debugfile, "cbp: %p post count = %d\n", (void *)bp, count));
+ mutt_debug (5, "cbp: %p post count = %d\n", (void *)bp, count);
}
}
- dprint(5, (debugfile, "bp: return %d\n", count < 0 ? 0 : count));
+ mutt_debug (5, "bp: return %d\n", count < 0 ? 0 : count);
return count < 0 ? 0 : count;
}
size_t ds = err->dsize;
if (regerror(regerr, preg, err->data, ds) > ds)
- dprint(2, (debugfile, "warning: buffer too small for regerror\n"));
+ mutt_debug (2, "warning: buffer too small for regerror\n");
/* The return value is fixed, exists only to shorten code at callsite */
return RANGE_E_SYNTAX;
}
/* Snarf the contents of the two sides of the range. */
pat->min = scan_range_slot(s, pmatch, pspec->lgrp, RANGE_S_LEFT, kind);
pat->max = scan_range_slot(s, pmatch, pspec->rgrp, RANGE_S_RIGHT, kind);
- dprint(1, (debugfile, "pat->min=%d pat->max=%d\n", pat->min, pat->max));
+ mutt_debug (1, "pat->min=%d pat->max=%d\n", pat->min, pat->max);
/* Special case for a bare 0. */
if ((kind == RANGE_K_BARE) && (pat->min == 0) && (pat->max == 0))
{
if (regexec (PgpGoodSign.rx, line, 0, NULL, 0) == 0)
{
- dprint (2, (debugfile, "pgp_copy_checksig: \"%s\" matches regexp.\n",
- line));
+ mutt_debug (2, "pgp_copy_checksig: \"%s\" matches regexp.\n", line);
rv = 0;
}
else
- dprint (2, (debugfile, "pgp_copy_checksig: \"%s\" doesn't match regexp.\n",
- line));
+ mutt_debug (2, "pgp_copy_checksig: \"%s\" doesn't match regexp.\n",
+ line);
if (strncmp (line, "[GNUPG:] ", 9) == 0)
continue;
}
else
{
- dprint (2, (debugfile, "pgp_copy_checksig: No pattern.\n"));
+ mutt_debug (2, "pgp_copy_checksig: No pattern.\n");
mutt_copy_stream (fpin, fpout);
rv = 1;
}
{
if (regexec (PgpDecryptionOkay.rx, line, 0, NULL, 0) == 0)
{
- dprint (2, (debugfile, "pgp_check_decryption_okay: \"%s\" matches regexp.\n",
- line));
+ mutt_debug (2, "pgp_check_decryption_okay: \"%s\" matches regexp.\n",
+ line);
rv = 0;
break;
}
else
- dprint (2, (debugfile, "pgp_check_decryption_okay: \"%s\" doesn't match regexp.\n",
- line));
+ mutt_debug (2, "pgp_check_decryption_okay: \"%s\" doesn't match regexp.\n",
+ line);
}
FREE (&line);
}
else
{
- dprint (2, (debugfile, "pgp_check_decryption_okay: No pattern.\n"));
+ mutt_debug (2, "pgp_check_decryption_okay: No pattern.\n");
rv = 1;
}
int c;
char *expected_charset = gpgcharset && *gpgcharset ? gpgcharset : "utf-8";
- dprint(4,(debugfile,"pgp: recoding inline from [%s] to [%s]\n",
- expected_charset, Charset));
+ mutt_debug (4, "pgp: recoding inline from [%s] to [%s]\n",
+ expected_charset, Charset);
rewind (pgpout);
state_set_prefix (s);
if ((rv = mutt_wait_filter (thepid)))
badsig = -1;
- dprint (1, (debugfile, "pgp_verify_one: mutt_wait_filter returned %d.\n", rv));
+ mutt_debug (1, "pgp_verify_one: mutt_wait_filter returned %d.\n", rv);
}
safe_fclose (&pgperr);
mutt_unlink (sigfile);
mutt_unlink (pgperrfile);
- dprint (1, (debugfile, "pgp_verify_one: returning %d.\n", badsig));
+ mutt_debug (1, "pgp_verify_one: returning %d.\n", badsig);
return badsig;
}
void mutt_pgp_command (char *d, size_t dlen, struct pgp_command_context *cctx, const char *fmt)
{
mutt_FormatString (d, dlen, 0, MuttIndexWindow->cols, NONULL (fmt), _mutt_fmt_pgp_command, (unsigned long) cctx, 0);
- dprint (2, (debugfile, "mutt_pgp_command: %s\n", d));
+ mutt_debug (2, "mutt_pgp_command: %s\n", d);
}
/*
if (!keys)
return NULL;
- dprint (5, (debugfile, "pgp_getkeybyaddr: looking for %s <%s>.",
- a->personal, a->mailbox));
+ mutt_debug (5, "pgp_getkeybyaddr: looking for %s <%s>.",
+ a->personal, a->mailbox);
for (k = keys; k; k = kn)
{
kn = k->next;
- dprint (5, (debugfile, " looking at key: %s\n",
- pgp_keyid (k)));
+ mutt_debug (5, " looking at key: %s\n", pgp_keyid (k));
if (abilities && !(k->flags & abilities))
{
- dprint (5, (debugfile, " insufficient abilities: Has %x, want %x\n",
- k->flags, abilities));
+ mutt_debug (5, " insufficient abilities: Has %x, want %x\n",
+ k->flags, abilities);
continue;
}
match = 0;
- dprint (5, (debugfile, "pgp_getkeybystr: matching \"%s\" against key %s:\n",
- p, pgp_long_keyid (k)));
+ mutt_debug (5, "pgp_getkeybystr: matching \"%s\" against key %s:\n",
+ p, pgp_long_keyid (k));
if (!*p ||
(pfcopy && mutt_strcasecmp (pfcopy, k->fingerprint) == 0) ||
(pl && mutt_strcasecmp (pl, pgp_long_keyid (k)) == 0) ||
(ps && mutt_strcasecmp (ps, pgp_short_keyid (k)) == 0))
{
- dprint (5, (debugfile, "\t\tmatch.\n"));
+ mutt_debug (5, "\t\tmatch.\n");
match = 1;
}
else
{
for (a = k->address; a; a = a->next)
{
- dprint (5, (debugfile, "pgp_getkeybystr: matching \"%s\" against key %s, \"%s\":\n",
- p, pgp_long_keyid (k), NONULL (a->addr)));
+ mutt_debug (5, "pgp_getkeybystr: matching \"%s\" against key %s, \"%s\":\n",
+ p, pgp_long_keyid (k), NONULL (a->addr));
if (mutt_stristr (a->addr, p))
{
- dprint (5, (debugfile, "\t\tmatch.\n"));
+ mutt_debug (5, "\t\tmatch.\n");
match = 1;
break;
}
}
if (r == NULL)
{
- dprint (1, (debugfile, "pgp_dearmor: Can't find begin of ASCII armor.\n"));
+ mutt_debug (1, "pgp_dearmor: Can't find begin of ASCII armor.\n");
return;
}
}
if (r == NULL)
{
- dprint (1, (debugfile, "pgp_dearmor: Armor header doesn't end.\n"));
+ mutt_debug (1, "pgp_dearmor: Armor header doesn't end.\n");
return;
}
}
if (r == NULL)
{
- dprint (1, (debugfile, "pgp_dearmor: Can't find end of ASCII armor.\n"));
+ mutt_debug (1, "pgp_dearmor: Can't find end of ASCII armor.\n");
return;
}
if ((end = ftello (in) - strlen (line)) < start)
{
- dprint (1, (debugfile, "pgp_dearmor: end < start???\n"));
+ mutt_debug (1, "pgp_dearmor: end < start???\n");
return;
}
if (fseeko (in, start, SEEK_SET) == -1)
{
- dprint (1, (debugfile, "pgp_dearmor: Can't seekto start.\n"));
+ mutt_debug (1, "pgp_dearmor: Can't seekto start.\n");
return;
}
/* is signature? */
if ((p[0] & 0x3f) != PT_SIG)
{
- dprint (1, (debugfile, "pgp_mic_from_packet: tag = %d, want %d.\n",
- p[0]&0x3f, PT_SIG));
+ mutt_debug (1, "pgp_mic_from_packet: tag = %d, want %d.\n",
+ p[0]&0x3f, PT_SIG);
return -1;
}
return (short) p[4];
else
{
- dprint (1, (debugfile, "pgp_mic_from_packet: Bad signature packet.\n"));
+ mutt_debug (1, "pgp_mic_from_packet: Bad signature packet.\n");
return -1;
}
}
}
else
{
- dprint (1, (debugfile, "pgp_find_hash: No packet.\n"));
+ mutt_debug (1, "pgp_find_hash: No packet.\n");
}
bye:
{
pop_data->cmd_top = 1;
- dprint (1, (debugfile, "pop_read_header: set TOP capability\n"));
+ mutt_debug (1, "pop_read_header: set TOP capability\n");
}
if (ret == -2)
{
pop_data->cmd_top = 0;
- dprint (1, (debugfile, "pop_read_header: unset TOP capability\n"));
+ mutt_debug (1, "pop_read_header: unset TOP capability\n");
snprintf (pop_data->err_msg, sizeof (pop_data->err_msg),
_("Command TOP is not supported by server."));
}
if (i == ctx->msgcount)
{
- dprint (1, (debugfile, "pop_fetch_headers: new header %d %s\n", index, line));
+ mutt_debug (1, "pop_fetch_headers: new header %d %s\n", index, line);
if (i >= ctx->hdrmax)
mx_alloc_memory(ctx);
{
pop_data->cmd_uidl = 1;
- dprint (1, (debugfile, "pop_fetch_headers: set UIDL capability\n"));
+ mutt_debug (1, "pop_fetch_headers: set UIDL capability\n");
}
if (ret == -2 && pop_data->cmd_uidl == 2)
{
pop_data->cmd_uidl = 0;
- dprint (1, (debugfile, "pop_fetch_headers: unset UIDL capability\n"));
+ mutt_debug (1, "pop_fetch_headers: unset UIDL capability\n");
snprintf (pop_data->err_msg, sizeof (pop_data->err_msg),
_("Command UIDL is not supported by server."));
}
if (!pop_data->clear_cache)
return;
- dprint (1, (debugfile, "pop_clear_cache: delete cached messages\n"));
+ mutt_debug (1, "pop_clear_cache: delete cached messages\n");
for (i = 0; i < POP_CACHE_LEN; i++)
{
if (mutt_sasl_client_new (pop_data->conn, &saslconn) < 0)
{
- dprint (1, (debugfile, "pop_auth_sasl: Error allocating SASL connection.\n"));
+ mutt_debug (1, "pop_auth_sasl: Error allocating SASL connection.\n");
return POP_A_FAILURE;
}
if (rc != SASL_OK && rc != SASL_CONTINUE)
{
- dprint (1, (debugfile, "pop_auth_sasl: Failure starting authentication exchange. No shared mechanisms?\n"));
+ mutt_debug (1, "pop_auth_sasl: Failure starting authentication exchange. "
+ "No shared mechanisms?\n");
/* SASL doesn't support suggested mechanisms, so fall back */
return POP_A_UNAVAIL;
if (!mutt_strncmp (inbuf, "+ ", 2)
&& sasl_decode64 (inbuf+2, strlen (inbuf+2), buf, bufsize - 1, &len) != SASL_OK)
{
- dprint (1, (debugfile, "pop_auth_sasl: error base64-decoding server response.\n"));
+ mutt_debug (1, "pop_auth_sasl: error base64-decoding server response.\n");
goto bail;
}
}
if (sasl_encode64 (pc, olen, buf, bufsize, &olen) != SASL_OK)
{
- dprint (1, (debugfile, "pop_auth_sasl: error base64-encoding client response.\n"));
+ mutt_debug (1, "pop_auth_sasl: error base64-encoding client response.\n");
goto bail;
}
}
{
pop_data->cmd_user = 1;
- dprint (1, (debugfile, "pop_auth_user: set USER capability\n"));
+ mutt_debug (1, "pop_auth_user: set USER capability\n");
}
if (ret == -2)
{
pop_data->cmd_user = 0;
- dprint (1, (debugfile, "pop_auth_user: unset USER capability\n"));
+ mutt_debug (1, "pop_auth_user: unset USER capability\n");
snprintf (pop_data->err_msg, sizeof (pop_data->err_msg),
_("Command USER is not supported by server."));
}
comma = strchr (method, ':');
if (comma)
*comma++ = '\0';
- dprint (2, (debugfile, "pop_authenticate: Trying method %s\n", method));
+ mutt_debug (2, "pop_authenticate: Trying method %s\n", method);
authenticator = pop_authenticators;
while (authenticator->authenticate)
else
{
/* Fall back to default: any authenticator */
- dprint (2, (debugfile, "pop_authenticate: Using any available method.\n"));
+ mutt_debug (2, "pop_authenticate: Using any available method.\n");
authenticator = pop_authenticators;
while (authenticator->authenticate)
if (msg)
{
dbg = MUTT_SOCK_LOG_FULL;
- dprint (MUTT_SOCK_LOG_CMD, (debugfile, "> %s", msg));
+ mutt_debug (MUTT_SOCK_LOG_CMD, "> %s", msg);
}
#endif
if (newpc >= 0)
{
PostCount = newpc;
- dprint (3, (debugfile, "mutt_num_postponed: %d postponed IMAP messages found.\n", PostCount));
+ mutt_debug (3, "mutt_num_postponed: %d postponed IMAP messages found.\n",
+ PostCount);
}
else
- dprint (3, (debugfile, "mutt_num_postponed: using old IMAP postponed count.\n"));
+ mutt_debug (3, "mutt_num_postponed: using old IMAP postponed count.\n");
}
return PostCount;
}
if ((thepid = mutt_create_filter (cmd, NULL, &fp, NULL)) < 0)
{
- dprint (1, (debugfile, "unable to fork command: %s", cmd));
+ mutt_debug (1, "unable to fork command: %s", cmd);
return 0;
}
if (!quiet)
safe_fclose (&fp);
if (mutt_wait_filter (thepid))
{
- dprint (1, (debugfile, "Error: %s\n", msg));
+ mutt_debug (1, "Error: %s\n", msg);
if (!quiet) mutt_error ("%s", msg);
}
else
ch = dispchar[aptr->content->disposition];
else
{
- dprint(1, (debugfile, "ERROR: invalid content-disposition %d\n", aptr->content->disposition));
+ mutt_debug (1, "ERROR: invalid content-disposition %d\n",
+ aptr->content->disposition);
ch = '!';
}
snprintf (dest, destlen, "%c", ch);
/* ignore comments */
if (*buf == '#')
continue;
- dprint (2, (debugfile, "mailcap entry: %s\n", buf));
+ mutt_debug (2, "mailcap entry: %s\n", buf);
/* check type */
ch = get_field (buf);
{
field = ch;
ch = get_field (ch);
- dprint (2, (debugfile, "field: %s\n", field));
+ mutt_debug (2, "field: %s\n", field);
if (!ascii_strcasecmp (field, "needsterminal"))
{
path[x] = '\0';
mutt_expand_path (path, sizeof (path));
- dprint(2,(debugfile,"Checking mailcap file: %s\n",path));
+ mutt_debug (2, "Checking mailcap file: %s\n",path);
found = rfc1524_mailcap_parse (a, path, type, entry, opt);
}
width = quote_width (s, ql);
last = line[mutt_strlen (line) - 1];
- dprint (4, (debugfile, "f=f: line [%s], width = %ld, spaces = %d\n",
- NONULL(line), (long)width, fst->spaces));
+ mutt_debug (4, "f=f: line [%s], width = %ld, spaces = %d\n",
+ NONULL(line), (long)width, fst->spaces);
for (p = (char *)line, words = 0; (p = strsep (&line, " ")) != NULL ; )
{
- dprint(4,(debugfile,"f=f: word [%s], width: %d, remaining = [%s]\n",
- p, fst->width, line));
+ mutt_debug (4, "f=f: word [%s], width: %d, remaining = [%s]\n",
+ p, fst->width, line);
/* remember number of spaces */
if (!*p)
{
- dprint(4,(debugfile,"f=f: additional space\n"));
+ mutt_debug (4, "f=f: additional space\n");
fst->spaces++;
continue;
}
if (!(!fst->spaces && fst->delsp && last != ' ') &&
w < width && w + fst->width + fst->spaces > width)
{
- dprint(4,(debugfile,"f=f: break line at %d, %d spaces left\n",
- fst->width, fst->spaces));
+ mutt_debug (4, "f=f: break line at %d, %d spaces left\n",
+ fst->width, fst->spaces);
/* only honor trailing spaces for format=flowed replies */
if (option(OPTTEXTFLOWED))
for ( ; fst->spaces; fst->spaces--)
fst.delsp = 1;
}
- dprint (4, (debugfile, "f=f: DelSp: %s\n", delsp ? "yes" : "no"));
+ mutt_debug (4, "f=f: DelSp: %s\n", delsp ? "yes" : "no");
while ((buf = mutt_read_line (buf, &sz, s->fpin, NULL, 0)))
{
if (!hdr || !hdr->content || !hdr->content->filename)
return;
- dprint (2, (debugfile, "f=f: postprocess %s\n", hdr->content->filename));
+ mutt_debug (2, "f=f: postprocess %s\n", hdr->content->filename);
if ((in = safe_fopen (hdr->content->filename, "r")) == NULL)
return;
c = buf[len-1];
buf[len-1] = '\0';
}
- dprint (4, (debugfile, "f=f: line %d needs space-stuffing: '%s'\n",
- lc, buf));
+ mutt_debug (4, "f=f: line %d needs space-stuffing: '%s'\n",
+ lc, buf);
if (len > 0)
buf[len-1] = c;
#endif
if (!tempfp)
{
- dprint(1,(debugfile, "newsend_message: can't create tempfile %s (errno=%d)\n", msg->content->filename, errno));
+ mutt_debug (1, "newsend_message: can't create tempfile %s (errno=%d)\n",
+ msg->content->filename, errno);
mutt_perror (msg->content->filename);
goto cleanup;
}
*/
if (msg->env->from)
- dprint (5, (debugfile, "ci_send_message: msg->env->from before set_reverse_name: %s\n", msg->env->from->mailbox));
+ mutt_debug (5, "ci_send_message: msg->env->from before set_reverse_name: %s\n",
+ msg->env->from->mailbox);
msg->env->from = set_reverse_name (cur->env);
}
if (cur && option (OPTREPLYWITHXORIG) && !(flags & (SENDPOSTPONED|SENDRESEND|SENDFORWARD)))
msg->env->from = cur->env->x_original_to;
/* Not more than one from address */
msg->env->from->next = NULL;
- dprint (5, (debugfile, "ci_send_message: msg->env->from extracted from X-Original-To: header: %s\n", msg->env->from->mailbox));
+ mutt_debug (5, "ci_send_message: msg->env->from extracted from X-Original-To: header: %s\n",
+ msg->env->from->mailbox);
}
}
}
else
{
- dprint(1, (debugfile, "ERROR: invalid content-disposition %d\n", a->disposition));
+ mutt_debug (1, "ERROR: invalid content-disposition %d\n", a->disposition);
}
}
/* First, find the boundary to use */
if (!(p = mutt_get_parameter ("boundary", a->parameter)))
{
- dprint (1, (debugfile, "mutt_write_mime_body(): no boundary parameter found!\n"));
+ mutt_debug (1, "mutt_write_mime_body(): no boundary parameter found!\n");
mutt_error (_("No boundary parameter found! [report this error]"));
return (-1);
}
if ((fpin = fopen (a->filename, "r")) == NULL)
{
- dprint(1,(debugfile, "write_mime_body: %s no longer exists!\n",a->filename));
+ mutt_debug (1, "write_mime_body: %s no longer exists!\n",a->filename);
mutt_error (_("%s no longer exists!"), a->filename);
return -1;
}
if ((fp = fopen (fname, "r")) == NULL)
{
- dprint (1, (debugfile, "mutt_get_content_info: %s: %s (errno %d).\n",
- fname, strerror (errno), errno));
+ mutt_debug (1, "mutt_get_content_info: %s: %s (errno %d).\n",
+ fname, strerror (errno), errno);
return (NULL);
}
strfcpy (buf, PKGDATADIR"/mime.types", sizeof (buf));
break;
default:
- dprint (1, (debugfile, "mutt_lookup_mime_type: Internal error, count = %d.\n", count));
+ mutt_debug (1, "mutt_lookup_mime_type: Internal error, count = %d.\n",
+ count);
goto bye; /* shouldn't happen */
}
char buf[HUGE_STRING] = "";
int first = 1, enc, col = 0, w, l = 0, fold;
- dprint(4,(debugfile,"mwoh: pfx=[%s], tag=[%s], flags=%d value=[%s]\n",
- pfx, tag, flags, value));
+ mutt_debug (4, "mwoh: pfx=[%s], tag=[%s], flags=%d value=[%s]\n",
+ pfx, tag, flags, value);
if (tag && *tag && fprintf (fp, "%s%s: ", NONULL (pfx), tag) < 0)
return -1;
w = my_width (buf, col, flags);
enc = mutt_strncmp (buf, "=?", 2) == 0;
- dprint(5,(debugfile,"mwoh: word=[%s], col=%d, w=%d, next=[0x0%x]\n",
- buf, col, w, *next));
+ mutt_debug (5, "mwoh: word=[%s], col=%d, w=%d, next=[0x0%x]\n",
+ buf, col, w, *next);
/* insert a folding \n before the current word's lwsp except for
* header name, first word on a line (word longer than wrap width)
if (!(flags & CH_DISPLAY) && (pfxw + max <= wraplen || is_from))
{
valbuf = mutt_substrdup (start, end);
- dprint(4,(debugfile,"mwoh: buf[%s%s] short enough, "
- "max width = %d <= %d\n",
- NONULL(pfx), valbuf, max, wraplen));
+ mutt_debug (4, "mwoh: buf[%s%s] short enough, "
+ "max width = %d <= %d\n",
+ NONULL(pfx), valbuf, max, wraplen);
if (pfx && *pfx)
if (fputs (pfx, fp) == EOF)
return -1;
if (!(t = strchr (valbuf, ':')))
{
- dprint (1, (debugfile, "mwoh: warning: header not in "
- "'key: value' format!\n"));
+ mutt_debug (1, "mwoh: warning: header not in 'key: value' format!\n");
return 0;
}
if (print_val (fp, pfx, valbuf, flags, mutt_strlen (pfx)) < 0)
t = strchr (start, ':');
if (!t || t > end)
{
- dprint (1, (debugfile, "mwoh: warning: header not in "
- "'key: value' format!\n"));
+ mutt_debug (1, "mwoh: warning: header not in 'key: value' format!\n");
return 0;
}
if (is_from)
valbuf = mutt_substrdup (t, end);
}
- dprint(4,(debugfile,"mwoh: buf[%s%s] too long, "
- "max width = %d > %d\n",
- NONULL(pfx), valbuf, max, wraplen));
+ mutt_debug (4, "mwoh: buf[%s%s] too long, max width = %d > %d\n",
+ NONULL(pfx), valbuf, max, wraplen);
if (fold_one_header (fp, tagbuf, valbuf, pfx, wraplen, flags) < 0)
return -1;
FREE (&tagbuf);
if (!(flags & CH_DISPLAY) && mutt_strwidth (tag) + 2 + pfxw +
mutt_strwidth (v) <= wraplen)
{
- dprint(4,(debugfile,"mwoh: buf[%s%s: %s] is short enough\n",
- NONULL(pfx), tag, v));
+ mutt_debug (4, "mwoh: buf[%s%s: %s] is short enough\n",
+ NONULL(pfx), tag, v);
if (fprintf (fp, "%s%s: %s\n", NONULL(pfx), tag, v) <= 0)
goto out;
rc = 0;
if (dup)
{
- dprint (2, (debugfile, "mutt_remove_duplicates: Removing %s\n",
- addr->mailbox));
+ mutt_debug (2, "mutt_remove_duplicates: Removing %s\n", addr->mailbox);
*last = addr->next;
strfcpy(fcc_tok, path, sizeof (fcc_tok));
tok = strtok(fcc_tok, ",");
- dprint(1, (debugfile, "Fcc: initial mailbox = '%s'\n", tok));
+ mutt_debug (1, "Fcc: initial mailbox = '%s'\n", tok);
/* mutt_expand_path already called above for the first token */
status = mutt_write_fcc (tok, hdr, msgid, post, fcc, finalpath);
if (status != 0)
continue;
/* Only call mutt_expand_path iff tok has some data */
- dprint (1, (debugfile, "Fcc: additional mailbox token = '%s'\n", tok));
+ mutt_debug (1, "Fcc: additional mailbox token = '%s'\n", tok);
strfcpy (fcc_expanded, tok, sizeof (fcc_expanded));
mutt_expand_path (fcc_expanded, sizeof (fcc_expanded));
- dprint (1, (debugfile, " Additional mailbox expanded = '%s'\n", fcc_expanded));
+ mutt_debug (1, " Additional mailbox expanded = '%s'\n", fcc_expanded);
status = mutt_write_fcc (fcc_expanded, hdr, msgid, post, fcc, finalpath);
if (status != 0)
return status;
if (mx_open_mailbox (path, MUTT_APPEND | MUTT_QUIET, &f) == NULL)
{
- dprint (1, (debugfile, "mutt_write_fcc(): unable to open mailbox %s in append-mode, aborting.\n",
- path));
+ mutt_debug (1, "mutt_write_fcc(): unable to open mailbox %s in append-mode, aborting.\n",
+ path);
return (-1);
}
fflush (tempfp);
if (ferror (tempfp))
{
- dprint (1, (debugfile, "mutt_write_fcc(): %s: write failed.\n", tempfile));
+ mutt_debug (1, "mutt_write_fcc(): %s: write failed.\n", tempfile);
safe_fclose (&tempfp);
unlink (tempfile);
mx_commit_message (msg, &f); /* XXX - really? */
{
mutt_FormatString (d, dlen, 0, MuttIndexWindow->cols, NONULL(fmt), _mutt_fmt_smime_command,
(unsigned long) cctx, 0);
- dprint (2,(debugfile, "mutt_smime_command: %s\n", d));
+ mutt_debug (2, "mutt_smime_command: %s\n", d);
}
SmtpPort = ntohs (service->s_port);
else
SmtpPort = SMTP_PORT;
- dprint (3, (debugfile, "Using default SMTP port %d\n", SmtpPort));
+ mutt_debug (3, "Using default SMTP port %d\n", SmtpPort);
}
account->port = SmtpPort;
}
if (! method[0])
continue;
- dprint (2, (debugfile, "smtp_authenticate: Trying method %s\n", method));
+ mutt_debug (2, "smtp_authenticate: Trying method %s\n", method);
r = smtp_auth_sasl (conn, method);
if (rc != SASL_OK && rc != SASL_CONTINUE)
{
- dprint (2, (debugfile, "smtp_auth_sasl: %s unavailable\n", mech));
+ mutt_debug (2, "smtp_auth_sasl: %s unavailable\n", mech);
sasl_dispose (&saslconn);
return SMTP_AUTH_UNAVAIL;
}
if (sasl_encode64 (data, len, buf + mutt_strlen (buf),
bufsize - mutt_strlen (buf), &len) != SASL_OK)
{
- dprint (1, (debugfile, "smtp_auth_sasl: error base64-encoding client response.\n"));
+ mutt_debug (1, "smtp_auth_sasl: error base64-encoding client response.\n");
goto fail;
}
}
if (sasl_decode64 (buf+4, strlen (buf+4), buf, bufsize - 1, &len) != SASL_OK)
{
- dprint (1, (debugfile, "smtp_auth_sasl: error base64-decoding server response.\n"));
+ mutt_debug (1, "smtp_auth_sasl: error base64-decoding server response.\n");
goto fail;
}
}
if (sasl_encode64 (data, len, buf, bufsize, &len) != SASL_OK)
{
- dprint (1, (debugfile, "smtp_auth_sasl: error base64-encoding client response.\n"));
+ mutt_debug (1, "smtp_auth_sasl: error base64-encoding client response.\n");
goto fail;
}
}
spadlen = -spadlen; /* Left Justifty */
#ifdef DEBUG_SNPRINTF
- dprint (1, (debugfile, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
- zpadlen, spadlen, min, max, place));
+ mutt_debug (1, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
+ zpadlen, spadlen, min, max, place);
#endif
/* Spaces */
}
#ifdef DEBUG_SNPRINTF
- dprint (1, (debugfile, "fmtfp: %f =? %d.%d\n", fvalue, intpart, fracpart));
+ mutt_debug (1, "fmtfp: %f =? %d.%d\n", fvalue, intpart, fracpart);
#endif
/* Convert integer part */
projects / neomutt / commitdiff