{
if (mutt_str_strcmp(a->mailbox, np->data) == 0) /* alias already found */
{
- mutt_debug(1, "loop in alias found for '%s'\n", a->mailbox);
+ mutt_debug(LL_DEBUG1, "loop in alias found for '%s'\n", a->mailbox);
i = true;
break;
}
url.path = NULL;
if (url_tostring(&url, host, sizeof(host), U_PATH) < 0)
{
- mutt_debug(1, "URL to string failed\n");
+ mutt_debug(LL_DEBUG1, "URL to string failed\n");
return -1;
}
mutt_encode_path(dst, dstlen, dst);
- mutt_debug(3, "rc: %d, path: '%s'\n", len, dst);
+ mutt_debug(LL_DEBUG3, "rc: %d, path: '%s'\n", len, dst);
if (len < 0 || (size_t) len >= dstlen - 1)
return -1;
- mutt_debug(3, "directory: '%s'\n", dst);
+ mutt_debug(LL_DEBUG3, "directory: '%s'\n", dst);
return 0;
}
snprintf(path, sizeof(path), "%s%s", bcache->path, id);
snprintf(newpath, sizeof(newpath), "%s%s", bcache->path, newid);
- mutt_debug(3, "bcache: mv: '%s' '%s'\n", path, newpath);
+ mutt_debug(LL_DEBUG3, "bcache: mv: '%s' '%s'\n", path, newpath);
return rename(path, newpath);
}
fp = mutt_file_fopen(path, "r");
- mutt_debug(3, "bcache: get: '%s': %s\n", path, fp ? "yes" : "no");
+ mutt_debug(LL_DEBUG3, "bcache: get: '%s': %s\n", path, fp ? "yes" : "no");
return fp;
}
}
}
- mutt_debug(3, "bcache: put: '%s'\n", path);
+ mutt_debug(LL_DEBUG3, "bcache: put: '%s'\n", path);
return mutt_file_fopen(path, "w+");
}
mutt_str_strncat(path, sizeof(path), bcache->path, bcache->pathlen);
mutt_str_strncat(path, sizeof(path), id, mutt_str_strlen(id));
- mutt_debug(3, "bcache: del: '%s'\n", path);
+ mutt_debug(LL_DEBUG3, "bcache: del: '%s'\n", path);
return unlink(path);
}
else
rc = S_ISREG(st.st_mode) && st.st_size != 0 ? 0 : -1;
- mutt_debug(3, "bcache: exists: '%s': %s\n", path, rc == 0 ? "yes" : "no");
+ mutt_debug(LL_DEBUG3, "bcache: exists: '%s': %s\n", path, rc == 0 ? "yes" : "no");
return rc;
}
rc = 0;
- mutt_debug(3, "bcache: list: dir: '%s'\n", bcache->path);
+ mutt_debug(LL_DEBUG3, "bcache: list: dir: '%s'\n", bcache->path);
while ((de = readdir(d)))
{
continue;
}
- mutt_debug(3, "bcache: list: dir: '%s', id :'%s'\n", bcache->path, de->d_name);
+ mutt_debug(LL_DEBUG3, "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;
}
- mutt_debug(3, "bcache: list: did %d entries\n", rc);
+ mutt_debug(LL_DEBUG3, "bcache: list: did %d entries\n", rc);
return rc;
}
/* When in mailboxes mode, disables this feature */
if (Folder)
{
- mutt_debug(3, "= hit! Folder: %s, LastDir: %s\n", Folder, LastDir);
+ mutt_debug(LL_DEBUG3, "= hit! Folder: %s, LastDir: %s\n", Folder, LastDir);
if (GotoSwapper[0] == '\0')
{
if (mutt_str_strcmp(LastDir, Folder) != 0)
init_pair(i, fg, bg);
- mutt_debug(3, "Color pairs used so far: %d\n", UserColors);
+ mutt_debug(LL_DEBUG3, "Color pairs used so far: %d\n", UserColors);
return COLOR_PAIR(p->index);
}
return;
UserColors--;
- mutt_debug(1, "Color pairs used so far: %d\n", UserColors);
+ mutt_debug(LL_DEBUG1, "Color pairs used so far: %d\n", UserColors);
if (p == ColorList)
{
{
*do_cache = true;
}
- mutt_debug(1, "Freeing pattern \"%s\" from ColorList\n", buf->data);
+ mutt_debug(LL_DEBUG1, "Freeing pattern \"%s\" from ColorList\n", buf->data);
if (tmp)
STAILQ_REMOVE_AFTER(cl, tmp, entries);
else
fflush(stdout);
int rc = mutt_system(buf);
if (rc == -1)
- mutt_debug(1, "Error running \"%s\"!", buf);
+ mutt_debug(LL_DEBUG1, "Error running \"%s\"!", buf);
if ((rc != 0) || WaitKey)
mutt_any_key_to_continue(NULL);
char imap_path[PATH_MAX];
#endif
- mutt_debug(2, "completing %s\n", buf);
+ mutt_debug(LL_DEBUG2, "completing %s\n", buf);
#ifdef USE_NNTP
if (OptNews)
if (!dirp)
{
- mutt_debug(1, "%s: %s (errno %d).\n", exp_dirpart, strerror(errno), errno);
+ mutt_debug(LL_DEBUG1, "%s: %s (errno %d).\n", exp_dirpart, strerror(errno), errno);
return -1;
}
if (index > 1)
{
- mutt_debug(1, "Variable has an invalid value: %d\n", index);
+ mutt_debug(LL_DEBUG1, "Variable has an invalid value: %d\n", index);
return CSR_ERR_INVALID | CSR_INV_TYPE;
}
struct HashElem *parent = cs_get_elem(cs, ac->var_names[i]);
if (!parent)
{
- mutt_debug(1, "%s doesn't exist\n", ac->var_names[i]);
+ mutt_debug(LL_DEBUG1, "%s doesn't exist\n", ac->var_names[i]);
success = false;
break;
}
ac->vars[i] = cs_inherit_variable(cs, parent, acname);
if (!ac->vars[i])
{
- mutt_debug(1, "failed to create %s\n", acname);
+ mutt_debug(LL_DEBUG1, "failed to create %s\n", acname);
success = false;
break;
}
mutt_buffer_reset(&err);
int result = cs_str_reset(cs, child, &err);
if (CSR_RESULT(result) != CSR_SUCCESS)
- mutt_debug(1, "reset failed for %s: %s\n", child, err.data);
+ mutt_debug(LL_DEBUG1, "reset failed for %s: %s\n", child, err.data);
mutt_hash_delete(cs->hash, child, NULL);
}
list[index++] = he;
if (index == 1022)
{
- mutt_debug(1, "Too many config items to sort\n");
+ mutt_debug(LL_DEBUG1, "Too many config items to sort\n");
break;
}
}
if ((value < 1) || (value >= (mutt_array_size(MagicValues) - 1)))
{
- mutt_debug(1, "Variable has an invalid value: %d\n", value);
+ mutt_debug(LL_DEBUG1, "Variable has an invalid value: %d\n", value);
return CSR_ERR_INVALID | CSR_INV_TYPE;
}
if (k == (size_t)(-1) || k == (size_t)(-2))
{
/* XXX put message in err buffer; fail? warning? */
- mutt_debug(1, "mbtable_parse: mbrtowc returned %d converting %s in %s\n",
+ mutt_debug(LL_DEBUG1, "mbtable_parse: mbrtowc returned %d converting %s in %s\n",
(k == (size_t)(-1)) ? -1 : -2, s, t->orig_str);
if (k == (size_t)(-1))
memset(&mbstate, 0, sizeof(mbstate));
if (value >= (mutt_array_size(QuadValues) - 1))
{
- mutt_debug(1, "Variable has an invalid value: %d\n", value);
+ mutt_debug(LL_DEBUG1, "Variable has an invalid value: %d\n", value);
return CSR_ERR_INVALID | CSR_INV_TYPE;
}
{
if (!reg_one_var(cs, &vars[i], &err))
{
- mutt_debug(1, "%s\n", err.data);
+ mutt_debug(LL_DEBUG1, "%s\n", err.data);
rc = false;
}
}
{
if (cs->listeners[i] == fn)
{
- mutt_debug(1, "Listener was already registered\n");
+ mutt_debug(LL_DEBUG1, "Listener was already registered\n");
return;
}
}
return;
}
}
- mutt_debug(1, "Listener wasn't registered\n");
+ mutt_debug(LL_DEBUG1, "Listener wasn't registered\n");
}
/**
{
struct Inheritance *i = he->data;
cdef = i->parent->data;
- mutt_debug(1, "Variable '%s' is inherited type.\n", cdef->name);
+ mutt_debug(LL_DEBUG1, "Variable '%s' is inherited type.\n", cdef->name);
return CSR_ERR_CODE;
}
cst = cs_get_type_def(cs, he->type);
if (!cst)
{
- mutt_debug(1, "Variable '%s' has an invalid type %d\n", cdef->name, he->type);
+ mutt_debug(LL_DEBUG1, "Variable '%s' has an invalid type %d\n", cdef->name, he->type);
return CSR_ERR_CODE;
}
if (!cst)
{
- mutt_debug(1, "Variable '%s' has an invalid type %d\n", cdef->name, DTYPE(he->type));
+ mutt_debug(LL_DEBUG1, "Variable '%s' has an invalid type %d\n", cdef->name,
+ DTYPE(he->type));
return CSR_ERR_CODE;
}
if (!cst)
{
- mutt_debug(1, "Variable '%s' has an invalid type %d\n", cdef->name, he->type);
+ mutt_debug(LL_DEBUG1, "Variable '%s' has an invalid type %d\n", cdef->name, he->type);
return CSR_ERR_CODE;
}
if (!cst)
{
- mutt_debug(1, "Variable '%s' has an invalid type %d\n", cdef->name, DTYPE(he->type));
+ mutt_debug(LL_DEBUG1, "Variable '%s' has an invalid type %d\n", cdef->name,
+ DTYPE(he->type));
return CSR_ERR_CODE;
}
if (!cst)
{
- mutt_debug(1, "Variable '%s' has an invalid type %d\n", cdef->name, he->type);
+ mutt_debug(LL_DEBUG1, "Variable '%s' has an invalid type %d\n", cdef->name, he->type);
return CSR_ERR_CODE;
}
if (!cst)
{
- mutt_debug(1, "Variable '%s' has an invalid type %d\n", cdef->name, he->type);
+ mutt_debug(LL_DEBUG1, "Variable '%s' has an invalid type %d\n", cdef->name, he->type);
return CSR_ERR_CODE;
}
id = mutt_map_get_value(value, SortSidebarMethods);
break;
default:
- mutt_debug(1, "Invalid sort type: %u\n", cdef->type & DT_SUBTYPE_MASK);
+ mutt_debug(LL_DEBUG1, "Invalid sort type: %u\n", cdef->type & DT_SUBTYPE_MASK);
return CSR_ERR_CODE;
break;
}
str = mutt_map_get_name(sort, SortSidebarMethods);
break;
default:
- mutt_debug(1, "Invalid sort type: %u\n", cdef->type & DT_SUBTYPE_MASK);
+ mutt_debug(LL_DEBUG1, "Invalid sort type: %u\n", cdef->type & DT_SUBTYPE_MASK);
return CSR_ERR_CODE;
break;
}
if (!str)
{
- mutt_debug(1, "Variable has an invalid value: %d/%d\n",
+ mutt_debug(LL_DEBUG1, "Variable has an invalid value: %d/%d\n",
cdef->type & DT_SUBTYPE_MASK, sort);
return CSR_ERR_INVALID | CSR_INV_TYPE;
}
str = mutt_map_get_name((value & SORT_MASK), SortSidebarMethods);
break;
default:
- mutt_debug(1, "Invalid sort type: %u\n", cdef->type & DT_SUBTYPE_MASK);
+ mutt_debug(LL_DEBUG1, "Invalid sort type: %u\n", cdef->type & DT_SUBTYPE_MASK);
return CSR_ERR_CODE;
break;
}
#endif
else
{
- mutt_debug(1, "Unknown address family!\n");
+ mutt_debug(LL_DEBUG1, "Unknown address family!\n");
return -1;
}
if (connect(fd, sa, sa_size) < 0)
{
save_errno = errno;
- mutt_debug(2, "Connection failed. errno: %d...\n", errno);
+ mutt_debug(LL_DEBUG2, "Connection failed. errno: %d...\n", errno);
SigInt = 0; /* reset in case we caught SIGINTR while in connect() */
}
h = reqs[0]->ar_result;
else if (status == EAI_INPROGRESS)
{
- mutt_debug(1, "timeout\n");
+ mutt_debug(LL_DEBUG1, "timeout\n");
/* request is not finish, cancel it to free it safely */
if (gai_cancel(reqs[0]) == EAI_NOTCANCELED)
{
}
}
else
- mutt_debug(1, "fail: (%d) %s\n", status, gai_strerror(status));
+ mutt_debug(LL_DEBUG1, "fail: (%d) %s\n", status, gai_strerror(status));
}
FREE(&reqs[0]);
#else /* !HAVE_GETADDRINFO_A */
- mutt_debug(3, "before getaddrinfo\n");
+ mutt_debug(LL_DEBUG3, "before getaddrinfo\n");
getaddrinfo(node, NULL, &hints, &h);
- mutt_debug(3, "after getaddrinfo\n");
+ mutt_debug(LL_DEBUG3, "after getaddrinfo\n");
#endif
{
mutt_str_strfcpy(buf, ++p, buflen);
rc = 0;
- mutt_debug(1, "Hostname: %s\n", buf);
+ mutt_debug(LL_DEBUG1, "Hostname: %s\n", buf);
freeaddrinfo(h);
}
static int getnameinfo_err(int ret)
{
int err;
- mutt_debug(1, "getnameinfo: ");
+ mutt_debug(LL_DEBUG1, "getnameinfo: ");
switch (ret)
{
case EAI_AGAIN:
- mutt_debug(1, "The name could not be resolved at this time. Future "
- "attempts may succeed.\n");
+ mutt_debug(LL_DEBUG1,
+ "The name could not be resolved at this time. Future "
+ "attempts may succeed.\n");
err = SASL_TRYAGAIN;
break;
case EAI_BADFLAGS:
- mutt_debug(1, "The flags had an invalid value.\n");
+ mutt_debug(LL_DEBUG1, "The flags had an invalid value.\n");
err = SASL_BADPARAM;
break;
case EAI_FAIL:
- mutt_debug(1, "A non-recoverable error occurred.\n");
+ mutt_debug(LL_DEBUG1, "A non-recoverable error occurred.\n");
err = SASL_FAIL;
break;
case EAI_FAMILY:
- mutt_debug(1, "The address family was not recognized or the address "
- "length was invalid for the specified family.\n");
+ mutt_debug(LL_DEBUG1,
+ "The address family was not recognized or the address "
+ "length was invalid for the specified family.\n");
err = SASL_BADPROT;
break;
case EAI_MEMORY:
- mutt_debug(1, "There was a memory allocation failure.\n");
+ mutt_debug(LL_DEBUG1, "There was a memory allocation failure.\n");
err = SASL_NOMEM;
break;
case EAI_NONAME:
- 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");
+ mutt_debug(LL_DEBUG1,
+ "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:
- mutt_debug(1,
+ mutt_debug(LL_DEBUG1,
"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:
- mutt_debug(1, "Unknown error %d\n", ret);
+ mutt_debug(LL_DEBUG1, "Unknown error %d\n", ret);
err = SASL_FAIL; /* no real equivalent */
break;
}
mutt_priority = 1;
break;
default:
- mutt_debug(1, "SASL unknown log priority: %s\n", message);
+ mutt_debug(LL_DEBUG1, "SASL unknown log priority: %s\n", message);
return SASL_OK;
}
mutt_debug(mutt_priority, "SASL: %s\n", message);
if (rc != SASL_OK)
{
- mutt_debug(1, "libsasl initialisation failed.\n");
+ mutt_debug(LL_DEBUG1, "libsasl initialisation failed.\n");
return SASL_FAIL;
}
if (!account)
return SASL_BADPARAM;
- mutt_debug(2, "getting %s for %s:%u\n", id == SASL_CB_AUTHNAME ? "authname" : "user",
- account->host, account->port);
+ mutt_debug(LL_DEBUG2, "getting %s for %s:%u\n",
+ id == SASL_CB_AUTHNAME ? "authname" : "user", account->host,
+ account->port);
if (id == SASL_CB_AUTHNAME)
{
if (!account || !psecret)
return SASL_BADPARAM;
- mutt_debug(2, "getting password for %s@%s:%u\n", account->login,
+ mutt_debug(LL_DEBUG2, "getting password for %s@%s:%u\n", account->login,
account->host, account->port);
if (mutt_account_getpass(account) < 0)
rc = sasl_decode(sasldata->saslconn, buf, rc, &sasldata->buf, &sasldata->blen);
if (rc != SASL_OK)
{
- mutt_debug(1, "SASL decode failed: %s\n", sasl_errstring(rc, NULL, NULL));
+ mutt_debug(LL_DEBUG1, "SASL decode failed: %s\n", sasl_errstring(rc, NULL, NULL));
goto out;
}
} while (sasldata->blen == 0);
rc = sasl_encode(sasldata->saslconn, buf, olen, &pbuf, &plen);
if (rc != SASL_OK)
{
- mutt_debug(1, "SASL encoding failed: %s\n", sasl_errstring(rc, NULL, NULL));
+ mutt_debug(LL_DEBUG1, "SASL encoding failed: %s\n", sasl_errstring(rc, NULL, NULL));
goto fail;
}
if (iptostring((struct sockaddr *) &local, size, iplocalport, IP_PORT_BUFLEN) == SASL_OK)
plp = iplocalport;
else
- mutt_debug(2, "SASL failed to parse local IP address\n");
+ mutt_debug(LL_DEBUG2, "SASL failed to parse local IP address\n");
}
else
- mutt_debug(2, "SASL failed to get local IP address\n");
+ mutt_debug(LL_DEBUG2, "SASL failed to get local IP address\n");
size = sizeof(remote);
if (!getpeername(conn->fd, (struct sockaddr *) &remote, &size))
if (iptostring((struct sockaddr *) &remote, size, ipremoteport, IP_PORT_BUFLEN) == SASL_OK)
prp = ipremoteport;
else
- mutt_debug(2, "SASL failed to parse remote IP address\n");
+ mutt_debug(LL_DEBUG2, "SASL failed to parse remote IP address\n");
}
else
- mutt_debug(2, "SASL failed to get remote IP address\n");
+ mutt_debug(LL_DEBUG2, "SASL failed to get remote IP address\n");
- mutt_debug(2, "SASL local ip: %s, remote ip:%s\n", NONULL(plp), NONULL(prp));
+ mutt_debug(LL_DEBUG2, "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 */
- mutt_debug(2, "External SSF: %d\n", conn->ssf);
+ mutt_debug(LL_DEBUG2, "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])
{
- mutt_debug(2, "External authentication name: %s\n", conn->account.user);
+ mutt_debug(LL_DEBUG2, "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)
{
- mutt_debug(2, "filling in SASL interaction %ld.\n", interaction->id);
+ mutt_debug(LL_DEBUG2, "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;
- mutt_debug(3, "SASL protection strength: %u\n", *sasldata->ssf);
+ mutt_debug(LL_DEBUG3, "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;
- mutt_debug(3, "SASL protection buffer size: %u\n", *sasldata->pbufsize);
+ mutt_debug(LL_DEBUG3, "SASL protection buffer size: %u\n", *sasldata->pbufsize);
/* clear input buffer */
sasldata->buf = NULL;
if (!Preconnect)
return 0;
- mutt_debug(2, "Executing preconnect: %s\n", Preconnect);
+ mutt_debug(LL_DEBUG2, "Executing preconnect: %s\n", Preconnect);
const int rc = mutt_system(Preconnect);
- mutt_debug(2, "Preconnect result: %d\n", rc);
+ mutt_debug(LL_DEBUG2, "Preconnect result: %d\n", rc);
if (rc != 0)
{
const int save_errno = errno;
rc = conn->conn_open(conn);
- mutt_debug(2, "Connected to %s:%d on fd=%d\n", conn->account.host,
+ mutt_debug(LL_DEBUG2, "Connected to %s:%d on fd=%d\n", conn->account.host,
conn->account.port, conn->fd);
return rc;
int rc = -1;
if (conn->fd < 0)
- mutt_debug(1, "Attempt to close closed connection.\n");
+ mutt_debug(LL_DEBUG1, "Attempt to close closed connection.\n");
else
rc = conn->conn_close(conn);
if (conn->fd < 0)
{
- mutt_debug(1, "attempt to write to closed connection\n");
+ mutt_debug(LL_DEBUG1, "attempt to write to closed connection\n");
return -1;
}
const int rc = conn->conn_write(conn, buf + sent, len - sent);
if (rc < 0)
{
- mutt_debug(1, "error writing (%s), closing socket\n", strerror(errno));
+ mutt_debug(LL_DEBUG1, "error writing (%s), closing socket\n", strerror(errno));
mutt_socket_close(conn);
return -1;
}
if (rc < len - sent)
- mutt_debug(3, "short write (%d of %d bytes)\n", rc, len - sent);
+ mutt_debug(LL_DEBUG3, "short write (%d of %d bytes)\n", rc, len - sent);
sent += rc;
}
conn->available = conn->conn_read(conn, conn->inbuf, sizeof(conn->inbuf));
else
{
- mutt_debug(1, "attempt to read from closed connection.\n");
+ mutt_debug(LL_DEBUG1, "attempt to read from closed connection.\n");
return -1;
}
conn->bufpos = 0;
int rc = 1;
char buf[STRING];
- mutt_debug(2, "loading trusted certificates\n");
+ mutt_debug(LL_DEBUG2, "loading trusted certificates\n");
store = SSL_CTX_get_cert_store(ctx);
if (!store)
{
if ((X509_cmp_current_time(X509_get0_notBefore(cert)) >= 0) ||
(X509_cmp_current_time(X509_get0_notAfter(cert)) <= 0))
{
- mutt_debug(2, "filtering expired cert: %s\n",
+ mutt_debug(LL_DEBUG2, "filtering expired cert: %s\n",
X509_NAME_oneline(X509_get_subject_name(cert), buf, sizeof(buf)));
}
else
X509_VERIFY_PARAM_set_flags(param, X509_V_FLAG_PARTIAL_CHAIN);
if (SSL_CTX_set1_param(ctx, param) == 0)
{
- mutt_debug(2, "SSL_CTX_set1_param() failed.\n");
+ mutt_debug(LL_DEBUG2, "SSL_CTX_set1_param() failed.\n");
rc = -1;
}
X509_VERIFY_PARAM_free(param);
}
else
{
- mutt_debug(2, "X509_VERIFY_PARAM_new() failed.\n");
+ mutt_debug(LL_DEBUG2, "X509_VERIFY_PARAM_new() failed.\n");
rc = -1;
}
}
errmsg = "unknown error";
}
- mutt_debug(1, "SSL error: %s\n", errmsg);
+ mutt_debug(LL_DEBUG1, "SSL error: %s\n", errmsg);
}
/**
output = mutt_mem_malloc(buflen + 1);
memcpy(output, buf, buflen);
output[buflen] = '\0';
- mutt_debug(1, "SSL error stack: %s\n", output);
+ mutt_debug(LL_DEBUG1, "SSL error stack: %s\n", output);
FREE(&output);
}
BIO_free(bio);
if (mutt_account_getuser(account) < 0)
return 0;
- mutt_debug(2, "getting password for %s@%s:%u\n", account->user, account->host,
- account->port);
+ mutt_debug(LL_DEBUG2, "getting password for %s@%s:%u\n", account->user,
+ account->host, account->port);
if (mutt_account_getpass(account) < 0)
return 0;
{
if (!silent)
{
- mutt_debug(2, "Server certificate is not yet valid\n");
+ mutt_debug(LL_DEBUG2, "Server certificate is not yet valid\n");
mutt_error(_("Server certificate is not yet valid"));
}
return false;
{
if (!silent)
{
- mutt_debug(2, "Server certificate has expired\n");
+ mutt_debug(LL_DEBUG2, "Server certificate has expired\n");
mutt_error(_("Server certificate has expired"));
}
return false;
if (!SslClientCert)
return;
- mutt_debug(2, "Using client certificate %s\n", SslClientCert);
+ mutt_debug(LL_DEBUG2, "Using client certificate %s\n", SslClientCert);
SSL_CTX_set_default_passwd_cb_userdata(ssldata->sctx, &conn->account);
SSL_CTX_set_default_passwd_cb(ssldata->sctx, ssl_passwd_cb);
SSL_CTX_use_certificate_file(ssldata->sctx, SslClientCert, SSL_FILETYPE_PEM);
/* if we are using a client cert, SASL may expect an external auth name */
if (mutt_account_getuser(&conn->account) < 0)
- mutt_debug(1, "Couldn't get user info\n");
+ mutt_debug(LL_DEBUG1, "Couldn't get user info\n");
}
/**
*/
static int ssl_cache_trusted_cert(X509 *c)
{
- mutt_debug(1, "trusted\n");
+ mutt_debug(LL_DEBUG1, "trusted\n");
if (!SslSessionCerts)
SslSessionCerts = sk_X509_new_null();
return sk_X509_push(SslSessionCerts, X509_dup(c));
OptIgnoreMacroEvents = false;
mutt_menu_pop_current(menu);
mutt_menu_destroy(&menu);
- mutt_debug(2, "done=%d\n", done);
+ mutt_debug(LL_DEBUG2, "done=%d\n", done);
return done == 2;
}
ssl = X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
if (!ssl)
{
- mutt_debug(1, "failed to retrieve SSL structure from X509_STORE_CTX\n");
+ mutt_debug(LL_DEBUG1,
+ "failed to retrieve SSL structure from X509_STORE_CTX\n");
return false;
}
host = SSL_get_ex_data(ssl, HostExDataIndex);
if (!host)
{
- mutt_debug(1, "failed to retrieve hostname from SSL structure\n");
+ mutt_debug(LL_DEBUG1, "failed to retrieve hostname from SSL structure\n");
return false;
}
pos = X509_STORE_CTX_get_error_depth(ctx);
len = sk_X509_num(X509_STORE_CTX_get0_chain(ctx));
- mutt_debug(1, "checking cert chain entry %s (preverify: %d skipmode: %d)\n",
+ mutt_debug(LL_DEBUG1, "checking cert chain entry %s (preverify: %d skipmode: %d)\n",
X509_NAME_oneline(X509_get_subject_name(cert), buf, sizeof(buf)),
preverify_ok, skip_mode);
if (X509_digest(last_cert, EVP_sha256(), last_cert_md, &last_cert_mdlen) &&
compare_certificates(cert, last_cert, last_cert_md, last_cert_mdlen))
{
- mutt_debug(2, "ignoring duplicate skipped certificate.\n");
+ mutt_debug(LL_DEBUG2, "ignoring duplicate skipped certificate.\n");
return true;
}
}
/* check session cache first */
if (check_certificate_cache(cert))
{
- mutt_debug(2, "using cached certificate\n");
+ mutt_debug(LL_DEBUG2, "using cached certificate\n");
SSL_set_ex_data(ssl, SkipModeExDataIndex, NULL);
return true;
}
* for hostname mismatches. */
return interactive_check_cert(cert, pos, len, ssl, false);
}
- mutt_debug(2, "hostname check passed\n");
+ mutt_debug(LL_DEBUG2, "hostname check passed\n");
}
if (!preverify_ok || skip_mode)
/* automatic check from user's database */
if (CertificateFile && check_certificate_by_digest(cert))
{
- mutt_debug(2, "digest check passed\n");
+ mutt_debug(LL_DEBUG2, "digest check passed\n");
SSL_set_ex_data(ssl, SkipModeExDataIndex, NULL);
return true;
}
/* log verification error */
int err = X509_STORE_CTX_get_error(ctx);
snprintf(buf, sizeof(buf), "%s (%d)", X509_verify_cert_error_string(err), err);
- mutt_debug(2, "X509_verify_cert: %s\n", buf);
+ mutt_debug(LL_DEBUG2, "X509_verify_cert: %s\n", buf);
/* prompt user */
return interactive_check_cert(cert, pos, len, ssl, true);
HostExDataIndex = SSL_get_ex_new_index(0, "host", NULL, NULL, NULL);
if (HostExDataIndex == -1)
{
- mutt_debug(1, "#1 failed to get index for application specific data\n");
+ mutt_debug(LL_DEBUG1,
+ "#1 failed to get index for application specific data\n");
return -1;
}
if (!SSL_set_ex_data(ssldata->ssl, HostExDataIndex, conn->account.host))
{
- mutt_debug(1, "#2 failed to save hostname in SSL structure\n");
+ mutt_debug(LL_DEBUG1, "#2 failed to save hostname in SSL structure\n");
return -1;
}
SkipModeExDataIndex = SSL_get_ex_new_index(0, "skip", NULL, NULL, NULL);
if (SkipModeExDataIndex == -1)
{
- mutt_debug(1, "#3 failed to get index for application specific data\n");
+ mutt_debug(LL_DEBUG1,
+ "#3 failed to get index for application specific data\n");
return -1;
}
if (!SSL_set_ex_data(ssldata->ssl, SkipModeExDataIndex, NULL))
{
- mutt_debug(1, "#4 failed to save skip mode in SSL structure\n");
+ mutt_debug(LL_DEBUG1, "#4 failed to save skip mode in SSL structure\n");
return -1;
}
{
if (!SSL_CTX_set_default_verify_paths(ssldata->sctx))
{
- mutt_debug(1, "Error setting default verify paths\n");
+ mutt_debug(LL_DEBUG1, "Error setting default verify paths\n");
goto free_ctx;
}
}
if (CertificateFile && !ssl_load_certificates(ssldata->sctx))
- mutt_debug(1, "Error loading trusted certificates\n");
+ mutt_debug(LL_DEBUG1, "Error loading trusted certificates\n");
ssl_get_client_cert(ssldata, conn);
{
rc = gnutls_certificate_set_x509_trust_mem(data->xcred, &cert_list[i], GNUTLS_X509_FMT_DER);
if (rc != 1)
- mutt_debug(1, "error trusting certificate %d: %d\n", i, rc);
+ mutt_debug(LL_DEBUG1, "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 (gnutls_x509_crt_init(&clientcrt) < 0)
{
- mutt_debug(1, "Failed to init gnutls crt\n");
+ mutt_debug(LL_DEBUG1, "Failed to init gnutls crt\n");
return;
}
if (gnutls_x509_crt_import(clientcrt, crtdata, GNUTLS_X509_FMT_DER) < 0)
{
- mutt_debug(1, "Failed to import gnutls client crt\n");
+ mutt_debug(LL_DEBUG1, "Failed to import gnutls client crt\n");
goto err_crt;
}
/* get length of DN */
dn = mutt_mem_calloc(1, dnlen);
gnutls_x509_crt_get_dn(clientcrt, dn, &dnlen);
- mutt_debug(2, "client certificate DN: %s\n", dn);
+ mutt_debug(LL_DEBUG2, "client certificate DN: %s\n", dn);
/* extract CN to use as external user name */
cn = strstr(dn, "CN=");
if (!cn)
{
- mutt_debug(1, "no CN found in DN\n");
+ mutt_debug(LL_DEBUG1, "no CN found in DN\n");
goto err_dn;
}
/* if we are using a client cert, SASL may expect an external auth name */
if (mutt_account_getuser(&conn->account) < 0)
- mutt_debug(1, "Couldn't get user info\n");
+ mutt_debug(LL_DEBUG1, "Couldn't get user info\n");
err_dn:
FREE(&dn);
if (SslClientCert)
{
- mutt_debug(2, "Using client certificate %s\n", SslClientCert);
+ mutt_debug(LL_DEBUG2, "Using client certificate %s\n", SslClientCert);
gnutls_certificate_set_x509_key_file(data->xcred, SslClientCert,
SslClientCert, GNUTLS_X509_FMT_PEM);
}
struct ListNode *np = NULL;
STAILQ_FOREACH(np, &HeaderOrderList, entries)
{
- mutt_debug(3, "Reorder list: %s\n", np->data);
+ mutt_debug(LL_DEBUG3, "Reorder list: %s\n", np->data);
hdr_count++;
}
}
- mutt_debug(1, "WEED is %s\n", (flags & CH_WEED) ? "Set" : "Not");
+ mutt_debug(LL_DEBUG1, "WEED is %s\n", (flags & CH_WEED) ? "Set" : "Not");
headers = mutt_mem_calloc(hdr_count, sizeof(char *));
++x;
if (mutt_str_startswith(buf, np->data, CASE_IGNORE))
{
- mutt_debug(2, "Reorder: %s matches %s", np->data, buf);
+ mutt_debug(LL_DEBUG2, "Reorder: %s matches %s", np->data, buf);
break;
}
}
if (!ignore)
{
- mutt_debug(2, "Reorder: x = %d; hdr_count = %d\n", x, hdr_count);
+ mutt_debug(LL_DEBUG2, "Reorder: x = %d; hdr_count = %d\n", x, hdr_count);
if (!this_one)
{
this_one = mutt_str_strdup(buf);
int r = mutt_copy_message_fp(fpout, msg->fp, e, flags, chflags);
if ((r == 0) && (ferror(fpout) || feof(fpout)))
{
- mutt_debug(1, "failed to detect EOF!\n");
+ mutt_debug(LL_DEBUG1, "failed to detect EOF!\n");
r = -1;
}
mx_msg_close(src, &msg);
{
char *p = strerror(errno);
- mutt_debug(1, "%s: %s (errno = %d)\n", s, p ? p : "unknown error", errno);
+ mutt_debug(LL_DEBUG1, "%s: %s (errno = %d)\n", s, p ? p : "unknown error", errno);
mutt_error("%s: %s (errno = %d)", s, p ? p : _("unknown error"), errno);
}
rc = mutt_file_chmod_rm_stat(fname, S_IWUSR | S_IWGRP | S_IWOTH, &sb);
if (rc == -1)
{
- mutt_debug(1, "Could not remove write permissions of %s: %s", fname, strerror(errno));
+ mutt_debug(LL_DEBUG1, "Could not remove write permissions of %s: %s",
+ fname, strerror(errno));
/* Do not bail out here as we are checking afterwards if we should adopt
* changes of the temporary file. */
}
if (dup)
{
- mutt_debug(2, "Removing %s\n", addr->mailbox);
+ mutt_debug(LL_DEBUG2, "Removing %s\n", addr->mailbox);
*last = addr->next;
{
if (b->unlink)
unlink(b->filename);
- mutt_debug(1, "%sunlinking %s.\n", b->unlink ? "" : "not ", b->filename);
+ mutt_debug(LL_DEBUG1, "%sunlinking %s.\n", b->unlink ? "" : "not ", b->filename);
}
FREE(&b->filename);
p = strchr(p + plen, ' ');
if (!p)
{
- mutt_debug(1,
+ mutt_debug(LL_DEBUG1,
"error parsing what appears to be a pipermail-style "
"obscured return_path: %s\n",
s);
if (!mutt_date_is_day_name(s))
{
- mutt_debug(1, " expected weekday, got: %s\n", s);
+ mutt_debug(LL_DEBUG1, " expected weekday, got: %s\n", s);
return false;
}
}
return false;
tm.tm_year = (yr > 1900) ? (yr - 1900) : ((yr < 70) ? (yr + 100) : yr);
- mutt_debug(3, "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(LL_DEBUG3, "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;
if (mutt_ch_convert_string(&reversed_user, Charset, "utf-8", 0) != 0)
{
- mutt_debug(1, "Not reversible. Charset conv to utf-8 failed for user = '%s'.\n",
+ mutt_debug(LL_DEBUG1, "Not reversible. Charset conv to utf-8 failed for user = '%s'.\n",
reversed_user);
goto cleanup;
}
if (mutt_str_strcasecmp(user, reversed_user) != 0)
{
- mutt_debug(1, "#1 Not reversible. orig = '%s', reversed = '%s'.\n", user, reversed_user);
+ mutt_debug(LL_DEBUG1, "#1 Not reversible. orig = '%s', reversed = '%s'.\n",
+ user, reversed_user);
goto cleanup;
}
if (mutt_ch_convert_string(&reversed_domain, Charset, "utf-8", 0) != 0)
{
- mutt_debug(1, "Not reversible. Charset conv to utf-8 failed for domain = '%s'.\n",
+ mutt_debug(LL_DEBUG1, "Not reversible. Charset conv to utf-8 failed for domain = '%s'.\n",
reversed_domain);
goto cleanup;
}
{
if (idna_to_ascii_8z(reversed_domain, &tmp, IDNA_ALLOW_UNASSIGNED) != IDNA_SUCCESS)
{
- mutt_debug(1, "Not reversible. idna_to_ascii_8z failed for domain = '%s'.\n",
+ mutt_debug(LL_DEBUG1, "Not reversible. idna_to_ascii_8z failed for domain = '%s'.\n",
reversed_domain);
goto cleanup;
}
if (mutt_str_strcasecmp(domain, reversed_domain) != 0)
{
- mutt_debug(1, "#2 Not reversible. orig = '%s', reversed = '%s'.\n", domain, reversed_domain);
+ mutt_debug(LL_DEBUG1, "#2 Not reversible. orig = '%s', reversed = '%s'.\n",
+ domain, reversed_domain);
goto cleanup;
}
}
const char *p = NULL;
size_t i;
- mutt_debug(2, "'%s'\n", s);
+ mutt_debug(LL_DEBUG2, "'%s'\n", s);
while (*s)
{
p = strpbrk(s, "=;");
if (!p)
{
- mutt_debug(1, "malformed parameter: %s\n", s);
+ mutt_debug(LL_DEBUG1, "malformed parameter: %s\n", s);
goto bail;
}
*/
if (i == 0)
{
- mutt_debug(1, "missing attribute: %s\n", s);
+ mutt_debug(LL_DEBUG1, "missing attribute: %s\n", s);
new = NULL;
}
else
{
new->value = mutt_str_strdup(buffer);
- mutt_debug(2, "parse_parameter: '%s' = '%s'\n",
+ mutt_debug(LL_DEBUG2, "parse_parameter: '%s' = '%s'\n",
new->attribute ? new->attribute : "", new->value ? new->value : "");
/* Add this parameter to the list */
}
else
{
- mutt_debug(1, "parameter with no value: %s\n", s);
+ mutt_debug(LL_DEBUG1, "parameter with no value: %s\n", s);
s = p;
}
if (!s || !ct)
return;
- mutt_debug(2, "RFC8255 >> Content-Language set to %s\n", s);
+ mutt_debug(LL_DEBUG2, "RFC8255 >> Content-Language set to %s\n", s);
ct->language = mutt_str_strdup(s);
}
if (e->received < 0)
{
- mutt_debug(1, "resetting invalid received time to 0\n");
+ mutt_debug(LL_DEBUG1, "resetting invalid received time to 0\n");
e->received = 0;
}
/* check for missing or invalid date */
if (e->date_sent <= 0)
{
- mutt_debug(1, "no date found, using received time from msg separator\n");
+ mutt_debug(LL_DEBUG1,
+ "no date found, using received time from msg separator\n");
e->date_sent = e->received;
}
}
c = mutt_str_skip_email_wsp(c + 1);
if (!*c)
{
- mutt_debug(1, "skipping empty header field: %s\n", line);
+ mutt_debug(LL_DEBUG1, "skipping empty header field: %s\n", line);
continue;
}
}
else
{
- mutt_debug(1, "bogus MIME header: %s\n", line);
+ mutt_debug(LL_DEBUG1, "bogus MIME header: %s\n", line);
break;
}
struct Body *zxx_part = NULL;
char *lang = NULL;
- mutt_debug(2, "RFC8255 >> entering in handler multilingual handler\n");
+ mutt_debug(LL_DEBUG2,
+ "RFC8255 >> entering in handler multilingual handler\n");
if ((a->encoding == ENC_BASE64) || (a->encoding == ENC_QUOTED_PRINTABLE) ||
(a->encoding == ENC_UUENCODED))
{
char *preferred_languages = NULL;
if (PreferredLanguages)
{
- mutt_debug(2, "RFC8255 >> preferred_languages set in config to '%s'\n", PreferredLanguages);
+ mutt_debug(LL_DEBUG2, "RFC8255 >> preferred_languages set in config to '%s'\n",
+ PreferredLanguages);
preferred_languages = mutt_str_strdup(PreferredLanguages);
lang = strtok(preferred_languages, ",");
}
if (b->language && (mutt_str_strcmp("zxx", b->language) == 0))
zxx_part = b;
- mutt_debug(2, "RFC8255 >> comparing configuration preferred_language='%s' to mail part content-language='%s'\n",
+ mutt_debug(LL_DEBUG2, "RFC8255 >> comparing configuration preferred_language='%s' to mail part content-language='%s'\n",
lang, b->language);
if (lang && b->language && (mutt_str_strcmp(lang, b->language) == 0))
{
- mutt_debug(2, "RFC8255 >> preferred_language='%s' matches content-language='%s' >> part selected to be displayed\n",
+ mutt_debug(LL_DEBUG2, "RFC8255 >> preferred_language='%s' matches content-language='%s' >> part selected to be displayed\n",
lang, b->language);
choice = b;
break;
if (rc != 0)
{
mutt_error(_("One or more parts of this message could not be displayed"));
- mutt_debug(1, "Failed on attachment #%d, type %s/%s.\n", count, TYPE(p),
- NONULL(p->subtype));
+ mutt_debug(LL_DEBUG1, "Failed on attachment #%d, type %s/%s.\n", count,
+ TYPE(p), NONULL(p->subtype));
}
if ((s->flags & MUTT_REPLYING) && IncludeOnlyfirst && (s->flags & MUTT_FIRSTDONE))
if (!s->fpout)
{
mutt_error(_("Unable to open 'memory stream'"));
- mutt_debug(1, "Can't open 'memory stream'.\n");
+ mutt_debug(LL_DEBUG1, "Can't open 'memory stream'.\n");
return -1;
}
#else
if (!s->fpout)
{
mutt_error(_("Unable to open temporary file"));
- mutt_debug(1, "Can't open %s.\n", tempfile);
+ mutt_debug(LL_DEBUG1, "Can't open %s.\n", tempfile);
return -1;
}
#endif
rc = handler(b, s);
if (rc != 0)
{
- mutt_debug(1, "Failed on attachment of type %s/%s.\n", TYPE(b), NONULL(b->subtype));
+ mutt_debug(LL_DEBUG1, "Failed on attachment of type %s/%s.\n", TYPE(b),
+ NONULL(b->subtype));
}
if (decode)
{
/* "i" may be zero if there is trailing whitespace, which is not an error */
if (i != 0)
- mutt_debug(2, "didn't get a multiple of 4 chars.\n");
+ mutt_debug(LL_DEBUG2, "didn't get a multiple of 4 chars.\n");
break;
}
if ((b->encoding != ENC_7BIT) && (b->encoding != ENC_8BIT) && (b->encoding != ENC_BINARY))
{
- mutt_debug(1, "Bad encoding type %d for multipart entity, assuming 7 bit\n", b->encoding);
+ mutt_debug(LL_DEBUG1, "Bad encoding type %d for multipart entity, assuming 7 bit\n",
+ b->encoding);
b->encoding = ENC_7BIT;
}
}
s->flags = oflags | (s->flags & MUTT_FIRSTDONE);
if (rc != 0)
{
- mutt_debug(1, "Bailing on attachment of type %s/%s.\n", TYPE(b), NONULL(b->subtype));
+ mutt_debug(LL_DEBUG1, "Bailing on attachment of type %s/%s.\n", TYPE(b),
+ NONULL(b->subtype));
}
return rc;
else
{
int ecode = kcdbecode(db);
- mutt_debug(2, "kcdbopen failed for %s: %s (ecode %d)\n", kcdbpath, kcdbemsg(db), ecode);
+ mutt_debug(LL_DEBUG2, "kcdbopen failed for %s: %s (ecode %d)\n", kcdbpath,
+ kcdbemsg(db), ecode);
kcdbdel(db);
return NULL;
}
if (!kcdbclose(db))
{
int ecode = kcdbecode(db);
- mutt_debug(2, "kcdbclose failed: %s (ecode %d)\n", kcdbemsg(db), ecode);
+ mutt_debug(LL_DEBUG2, "kcdbclose failed: %s (ecode %d)\n", kcdbemsg(db), ecode);
}
kcdbdel(db);
}
ctx->txn_mode = TXN_READ;
else
{
- mutt_debug(2, "%s: %s\n", ctx->txn ? "mdb_txn_renew" : "mdb_txn_begin",
- mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "%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
- mutt_debug(2, "mdb_txn_begin: %s\n", mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "mdb_txn_begin: %s\n", mdb_strerror(rc));
return rc;
}
rc = mdb_env_create(&ctx->env);
if (rc != MDB_SUCCESS)
{
- mutt_debug(2, "mdb_env_create: %s\n", mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "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)
{
- mutt_debug(2, "mdb_env_open: %s\n", mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "mdb_env_open: %s\n", mdb_strerror(rc));
goto fail_env;
}
rc = mdb_get_r_txn(ctx);
if (rc != MDB_SUCCESS)
{
- mutt_debug(2, "mdb_txn_begin: %s\n", mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "mdb_txn_begin: %s\n", mdb_strerror(rc));
goto fail_env;
}
rc = mdb_dbi_open(ctx->txn, NULL, MDB_CREATE, &ctx->db);
if (rc != MDB_SUCCESS)
{
- mutt_debug(2, "mdb_dbi_open: %s\n", mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "mdb_dbi_open: %s\n", mdb_strerror(rc));
goto fail_dbi;
}
if (rc != MDB_SUCCESS)
{
ctx->txn = NULL;
- mutt_debug(2, "txn_renew: %s\n", mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "txn_renew: %s\n", mdb_strerror(rc));
return NULL;
}
rc = mdb_get(ctx->txn, ctx->db, &dkey, &data);
}
if (rc != MDB_SUCCESS)
{
- mutt_debug(2, "mdb_get: %s\n", mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "mdb_get: %s\n", mdb_strerror(rc));
return NULL;
}
rc = mdb_get_w_txn(ctx);
if (rc != MDB_SUCCESS)
{
- mutt_debug(2, "mdb_get_w_txn: %s\n", mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "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)
{
- mutt_debug(2, "mdb_put: %s\n", mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "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)
{
- mutt_debug(2, "mdb_get_w_txn: %s\n", mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "mdb_get_w_txn: %s\n", mdb_strerror(rc));
return rc;
}
rc = mdb_del(ctx->txn, ctx->db, &dkey, NULL);
if (rc != MDB_SUCCESS && rc != MDB_NOTFOUND)
{
- mutt_debug(2, "mdb_del: %s\n", mdb_strerror(rc));
+ mutt_debug(LL_DEBUG2, "mdb_del: %s\n", mdb_strerror(rc));
mdb_txn_abort(ctx->txn);
ctx->txn_mode = TXN_UNINITIALIZED;
ctx->txn = NULL;
else
{
int ecode = tcbdbecode(db);
- mutt_debug(2, "tcbdbopen failed for %s: %s (ecode %d)\n", path,
+ mutt_debug(LL_DEBUG2, "tcbdbopen failed for %s: %s (ecode %d)\n", path,
tcbdberrmsg(ecode), ecode);
tcbdbdel(db);
return NULL;
if (!tcbdbclose(db))
{
int ecode = tcbdbecode(db);
- mutt_debug(2, "tcbdbclose failed: %s (ecode %d)\n", tcbdberrmsg(ecode), ecode);
+ mutt_debug(LL_DEBUG2, "tcbdbclose failed: %s (ecode %d)\n", tcbdberrmsg(ecode), ecode);
}
tcbdbdel(db);
}
if (ImapAuthenticators && *ImapAuthenticators)
{
- mutt_debug(2, "Trying user-defined imap_authenticators.\n");
+ mutt_debug(LL_DEBUG2, "Trying user-defined imap_authenticators.\n");
/* Try user-specified list of authentication methods */
char *methods = mutt_str_strdup(ImapAuthenticators);
if (!method[0])
continue;
- mutt_debug(2, "Trying method %s\n", method);
+ mutt_debug(LL_DEBUG2, "Trying method %s\n", method);
for (size_t i = 0; i < mutt_array_size(imap_authenticators); ++i)
{
else
{
/* Fall back to default: any authenticator */
- mutt_debug(2, "Trying pre-defined imap_authenticators.\n");
+ mutt_debug(LL_DEBUG2, "Trying pre-defined imap_authenticators.\n");
for (size_t i = 0; i < mutt_array_size(imap_authenticators); ++i)
{
if (rc != IMAP_CMD_RESPOND)
{
- mutt_debug(1, "Invalid response from server.\n");
+ mutt_debug(LL_DEBUG1, "Invalid response from server.\n");
goto bail;
}
if (rc != IMAP_CMD_OK)
{
- mutt_debug(1, "Error receiving server response.\n");
+ mutt_debug(LL_DEBUG1, "Error receiving server response.\n");
goto bail;
}
if (rc != IMAP_CMD_RESPOND)
{
- mutt_debug(1, "Invalid response from server: %s\n", ibuf);
+ mutt_debug(LL_DEBUG1, "Invalid response from server: %s\n", ibuf);
goto bail;
}
len = mutt_b64_decode(adata->buf + 2, obuf, sizeof(obuf));
if (len == -1)
{
- mutt_debug(1, "Error decoding base64 response.\n");
+ mutt_debug(LL_DEBUG1, "Error decoding base64 response.\n");
goto bail;
}
obuf[len] = '\0';
- mutt_debug(2, "CRAM challenge: %s\n", obuf);
+ mutt_debug(LL_DEBUG2, "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
/* dubious optimisation I saw elsewhere: make the whole string in one call */
int off = snprintf(obuf, sizeof(obuf), "%s ", adata->conn->account.user);
mutt_md5_toascii(hmac_response, obuf + off);
- mutt_debug(2, "CRAM response: %s\n", obuf);
+ mutt_debug(LL_DEBUG2, "CRAM response: %s\n", obuf);
/* ibuf must be long enough to store the base64 encoding of obuf,
* plus the additional debris */
if (rc != IMAP_CMD_OK)
{
- mutt_debug(1, "Error receiving server response.\n");
+ mutt_debug(LL_DEBUG1, "Error receiving server response.\n");
goto bail;
}
}
} while (!GSS_ERROR(maj_stat) && msg_ctx != 0);
- mutt_debug(2, "((%s:%d )(%s:%d))\n", buf_maj, err_maj, buf_min, err_min);
+ mutt_debug(LL_DEBUG2, "((%s:%d )(%s:%d))\n", buf_maj, err_maj, buf_min, err_min);
}
/**
maj_stat = gss_import_name(&min_stat, &request_buf, gss_nt_service_name, &target_name);
if (maj_stat != GSS_S_COMPLETE)
{
- mutt_debug(2, "Couldn't get service name for [%s]\n", buf1);
+ mutt_debug(LL_DEBUG2, "Couldn't get service name for [%s]\n", buf1);
retval = IMAP_AUTH_UNAVAIL;
goto cleanup;
}
else if (DebugLevel >= 2)
{
gss_display_name(&min_stat, target_name, &request_buf, &mech_name);
- mutt_debug(2, "Using service name [%s]\n", (char *) request_buf.value);
+ mutt_debug(LL_DEBUG2, "Using service name [%s]\n", (char *) request_buf.value);
gss_release_buffer(&min_stat, &request_buf);
}
/* Acquire initial credentials - without a TGT GSSAPI is UNAVAIL */
if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED)
{
print_gss_error(maj_stat, min_stat);
- mutt_debug(1, "Error acquiring credentials - no TGT?\n");
+ mutt_debug(LL_DEBUG1, "Error acquiring credentials - no TGT?\n");
gss_release_name(&min_stat, &target_name);
retval = IMAP_AUTH_UNAVAIL;
if (rc != IMAP_CMD_RESPOND)
{
- mutt_debug(2, "Invalid response from server: %s\n", buf1);
+ mutt_debug(LL_DEBUG2, "Invalid response from server: %s\n", buf1);
gss_release_name(&min_stat, &target_name);
goto bail;
}
/* now start the security context initialisation loop... */
- mutt_debug(2, "Sending credentials\n");
+ mutt_debug(LL_DEBUG2, "Sending credentials\n");
mutt_b64_buffer_encode(buf1, send_token.value, send_token.length);
gss_release_buffer(&min_stat, &send_token);
mutt_buffer_addstr(buf1, "\r\n");
if (rc != IMAP_CMD_RESPOND)
{
- mutt_debug(1, "#1 Error receiving server response.\n");
+ mutt_debug(LL_DEBUG1, "#1 Error receiving server response.\n");
gss_release_name(&min_stat, &target_name);
goto bail;
}
if (mutt_b64_buffer_decode(buf2, adata->buf + 2) < 0)
{
- mutt_debug(1, "Invalid base64 server response.\n");
+ mutt_debug(LL_DEBUG1, "Invalid base64 server response.\n");
gss_release_name(&min_stat, &target_name);
goto err_abort_cmd;
}
if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED)
{
print_gss_error(maj_stat, min_stat);
- mutt_debug(1, "Error exchanging credentials\n");
+ mutt_debug(LL_DEBUG1, "Error exchanging credentials\n");
gss_release_name(&min_stat, &target_name);
goto err_abort_cmd;
if (rc != IMAP_CMD_RESPOND)
{
- mutt_debug(1, "#2 Error receiving server response.\n");
+ mutt_debug(LL_DEBUG1, "#2 Error receiving server response.\n");
goto bail;
}
if (mutt_b64_buffer_decode(buf2, adata->buf + 2) < 0)
{
- mutt_debug(1, "Invalid base64 server response.\n");
+ mutt_debug(LL_DEBUG1, "Invalid base64 server response.\n");
goto err_abort_cmd;
}
request_buf.value = buf2->data;
if (maj_stat != GSS_S_COMPLETE)
{
print_gss_error(maj_stat, min_stat);
- mutt_debug(2, "Couldn't unwrap security level data\n");
+ mutt_debug(LL_DEBUG2, "Couldn't unwrap security level data\n");
gss_release_buffer(&min_stat, &send_token);
goto err_abort_cmd;
}
- mutt_debug(2, "Credential exchange complete\n");
+ mutt_debug(LL_DEBUG2, "Credential exchange complete\n");
/* first octet is security levels supported. We want NONE */
server_conf_flags = ((char *) send_token.value)[0];
if (!(((char *) send_token.value)[0] & GSS_AUTH_P_NONE))
{
- mutt_debug(2, "Server requires integrity or privacy\n");
+ mutt_debug(LL_DEBUG2, "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);
- mutt_debug(2, "Unwrapped security level flags: %c%c%c\n",
+ mutt_debug(LL_DEBUG2, "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);
+ mutt_debug(LL_DEBUG2, "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)
{
- mutt_debug(2, "Error creating login request\n");
+ mutt_debug(LL_DEBUG2, "Error creating login request\n");
goto err_abort_cmd;
}
mutt_b64_buffer_encode(buf1, send_token.value, send_token.length);
- mutt_debug(2, "Requesting authorisation as %s\n", adata->conn->account.user);
+ mutt_debug(LL_DEBUG2, "Requesting authorisation as %s\n", adata->conn->account.user);
mutt_buffer_addstr(buf1, "\r\n");
mutt_socket_send(adata->conn, mutt_b2s(buf1));
while (rc == IMAP_CMD_CONTINUE);
if (rc == IMAP_CMD_RESPOND)
{
- mutt_debug(1, "Unexpected server continuation request.\n");
+ mutt_debug(LL_DEBUG1, "Unexpected server continuation request.\n");
goto err_abort_cmd;
}
if (imap_code(adata->buf))
{
/* flush the security context */
- mutt_debug(2, "Releasing GSS credentials\n");
+ mutt_debug(LL_DEBUG2, "Releasing GSS credentials\n");
maj_stat = gss_delete_sec_context(&min_stat, &context, &send_token);
if (maj_stat != GSS_S_COMPLETE)
- mutt_debug(1, "Error releasing credentials\n");
+ mutt_debug(LL_DEBUG1, "Error releasing credentials\n");
/* send_token may contain a notification to the server to flush
* credentials. RFC1731 doesn't specify what to do, and since this
* of 5 or higher */
if (DebugLevel < IMAP_LOG_PASS)
- mutt_debug(2, "Sending LOGIN command for %s...\n", adata->conn->account.user);
+ mutt_debug(LL_DEBUG2, "Sending LOGIN command for %s...\n",
+ adata->conn->account.user);
snprintf(buf, sizeof(buf), "LOGIN %s %s", q_user, q_pass);
if (imap_exec(adata, buf, IMAP_CMD_PASS) != IMAP_EXEC_SUCCESS)
if (mutt_sasl_client_new(adata->conn, &saslconn) < 0)
{
- mutt_debug(1, "Error allocating SASL connection.\n");
+ mutt_debug(LL_DEBUG1, "Error allocating SASL connection.\n");
return IMAP_AUTH_FAILURE;
}
if (rc != SASL_OK && rc != SASL_CONTINUE)
{
if (method)
- mutt_debug(2, "%s unavailable\n", method);
+ mutt_debug(LL_DEBUG2, "%s unavailable\n", method);
else
{
mutt_debug(
buf[len++] = ' ';
if (sasl_encode64(pc, olen, buf + len, bufsize - len, &olen) != SASL_OK)
{
- mutt_debug(1, "#1 error base64-encoding client response.\n");
+ mutt_debug(LL_DEBUG1, "#1 error base64-encoding client response.\n");
goto bail;
}
client_start = false;
* include space for the trailing null */
if (sasl_decode64(adata->buf + 2, len, buf, bufsize - 1, &len) != SASL_OK)
{
- mutt_debug(1, "error base64-decoding server response.\n");
+ mutt_debug(LL_DEBUG1, "error base64-decoding server response.\n");
goto bail;
}
}
}
if (sasl_encode64(pc, olen, buf, bufsize, &olen) != SASL_OK)
{
- mutt_debug(1, "#2 error base64-encoding client response.\n");
+ mutt_debug(LL_DEBUG1, "#2 error base64-encoding client response.\n");
goto bail;
}
}
if (rc < 0)
{
mutt_socket_send(adata->conn, "*\r\n");
- mutt_debug(1, "sasl_client_step error %d\n", rc);
+ mutt_debug(LL_DEBUG1, "sasl_client_step error %d\n", rc);
}
olen = 0;
if (method)
{
- mutt_debug(2, "%s failed\n", method);
+ mutt_debug(LL_DEBUG2, "%s failed\n", method);
return IMAP_AUTH_UNAVAIL;
}
if (n)
{
int rc;
- mutt_debug(3, "mbox: %s\n", mbox);
+ mutt_debug(LL_DEBUG3, "mbox: %s\n", mbox);
/* if our target exists and has inferiors, enter it if we
* aren't already going to */
if (showparents)
{
- mutt_debug(3, "adding parent %s\n", mbox);
+ mutt_debug(LL_DEBUG3, "adding parent %s\n", mbox);
add_folder(list.delim, mbox, true, false, state, true);
}
state->folder = mutt_str_strdup(buf);
}
- mutt_debug(3, "Quoting mailbox scan: %s -> ", mbox);
+ mutt_debug(LL_DEBUG3, "Quoting mailbox scan: %s -> ", mbox);
snprintf(buf, sizeof(buf), "%s%%", mbox);
imap_munge_mbox_name(adata->unicode, munged_mbox, sizeof(munged_mbox), buf);
- mutt_debug(3, "%s\n", munged_mbox);
+ mutt_debug(LL_DEBUG3, "%s\n", munged_mbox);
snprintf(buf, sizeof(buf), "%s \"\" %s", list_cmd, munged_mbox);
if (browse_add_list_result(adata, buf, state, false))
goto fail;
if (imap_adata_find(path, &adata, &mdata) < 0)
{
- mutt_debug(1, "Couldn't find open connection to %s\n", path);
+ mutt_debug(LL_DEBUG1, "Couldn't find open connection to %s\n", path);
goto err;
}
if (imap_adata_find(path, &adata, &mdata) < 0)
{
- mutt_debug(1, "Couldn't find open connection to %s\n", path);
+ mutt_debug(LL_DEBUG1, "Couldn't find open connection to %s\n", path);
return -1;
}
if (cmd_queue_full(adata))
{
- mutt_debug(3, "IMAP command queue full\n");
+ mutt_debug(LL_DEBUG3, "IMAP command queue full\n");
return NULL;
}
{
if (cmd_queue_full(adata))
{
- mutt_debug(3, "Draining IMAP command pipeline\n");
+ mutt_debug(LL_DEBUG3, "Draining IMAP command pipeline\n");
const int rc = imap_exec(adata, NULL, flags & IMAP_CMD_POLL);
unsigned int exp_msn;
struct Email *e = NULL;
- mutt_debug(2, "Handling EXPUNGE\n");
+ mutt_debug(LL_DEBUG2, "Handling EXPUNGE\n");
struct ImapMboxData *mdata = adata->mailbox->mdata;
struct ImapMboxData *mdata = adata->mailbox->mdata;
- mutt_debug(2, "Handling VANISHED\n");
+ mutt_debug(LL_DEBUG2, "Handling VANISHED\n");
if (mutt_str_startswith(s, "(EARLIER)", CASE_IGNORE))
{
struct SeqsetIterator *iter = mutt_seqset_iterator_new(s);
if (!iter)
{
- mutt_debug(2, "VANISHED: empty seqset [%s]?\n", s);
+ mutt_debug(LL_DEBUG2, "VANISHED: empty seqset [%s]?\n", s);
return;
}
if ((exp_msn < 1) || (exp_msn > mdata->max_msn))
{
- mutt_debug(1, "VANISHED: msn for UID %u is incorrect.\n", uid);
+ mutt_debug(LL_DEBUG1, "VANISHED: msn for UID %u is incorrect.\n", uid);
continue;
}
if (mdata->msn_index[exp_msn - 1] != e)
{
- mutt_debug(1, "VANISHED: msn_index for UID %u is incorrect.\n", uid);
+ mutt_debug(LL_DEBUG1, "VANISHED: msn_index for UID %u is incorrect.\n", uid);
continue;
}
}
if (rc < 0)
- mutt_debug(1, "VANISHED: illegal seqset %s\n", s);
+ mutt_debug(LL_DEBUG1, "VANISHED: illegal seqset %s\n", s);
mdata->reopen |= IMAP_EXPUNGE_PENDING;
struct ImapMboxData *mdata = imap_mdata_get(adata->mailbox);
- mutt_debug(3, "Handling FETCH\n");
+ mutt_debug(LL_DEBUG3, "Handling FETCH\n");
if (mutt_str_atoui(s, &msn) < 0)
{
- mutt_debug(3, "Skipping FETCH response - illegal MSN\n");
+ mutt_debug(LL_DEBUG3, "Skipping FETCH response - illegal MSN\n");
return;
}
if ((msn < 1) || (msn > mdata->max_msn))
{
- mutt_debug(3, "Skipping FETCH response - MSN %u out of range\n", msn);
+ mutt_debug(LL_DEBUG3, "Skipping FETCH response - MSN %u out of range\n", msn);
return;
}
e = mdata->msn_index[msn - 1];
if (!e || !e->active)
{
- mutt_debug(3, "Skipping FETCH response - MSN %u not in msn_index\n", msn);
+ mutt_debug(LL_DEBUG3, "Skipping FETCH response - MSN %u not in msn_index\n", msn);
return;
}
- mutt_debug(2, "Message UID %u updated\n", imap_edata_get(e)->uid);
+ mutt_debug(LL_DEBUG2, "Message UID %u updated\n", imap_edata_get(e)->uid);
/* skip FETCH */
s = imap_next_word(s);
s = imap_next_word(s);
if (*s != '(')
{
- mutt_debug(1, "Malformed FETCH response\n");
+ mutt_debug(LL_DEBUG1, "Malformed FETCH response\n");
return;
}
s++;
SKIPWS(s);
if (*s != '(')
{
- mutt_debug(1, "bogus FLAGS response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "bogus FLAGS response: %s\n", s);
return;
}
s++;
s++;
else
{
- mutt_debug(1, "Unterminated FLAGS response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "Unterminated FLAGS response: %s\n", s);
return;
}
}
SKIPWS(s);
if (mutt_str_atoui(s, &uid) < 0)
{
- mutt_debug(1, "Illegal UID. Skipping update.\n");
+ mutt_debug(LL_DEBUG1, "Illegal UID. Skipping update.\n");
return;
}
if (uid != imap_edata_get(e)->uid)
{
- mutt_debug(1, "UID vs MSN mismatch. Skipping update.\n");
+ mutt_debug(LL_DEBUG1, "UID vs MSN mismatch. Skipping update.\n");
return;
}
uid_checked = 1;
SKIPWS(s);
if (*s != '(')
{
- mutt_debug(1, "bogus MODSEQ response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "bogus MODSEQ response: %s\n", s);
return;
}
s++;
s++;
else
{
- mutt_debug(1, "Unterminated MODSEQ response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "Unterminated MODSEQ response: %s\n", s);
return;
}
}
break; /* end of request */
else if (*s)
{
- mutt_debug(2, "Only handle FLAGS updates\n");
+ mutt_debug(LL_DEBUG2, "Only handle FLAGS updates\n");
break;
}
}
*/
static void cmd_parse_capability(struct ImapAccountData *adata, char *s)
{
- mutt_debug(3, "Handling CAPABILITY\n");
+ mutt_debug(LL_DEBUG3, "Handling CAPABILITY\n");
s = imap_next_word(s);
char *bracket = strchr(s, ']');
if (mutt_str_word_casecmp(Capabilities[i], s) == 0)
{
adata->capabilities |= (1 << i);
- mutt_debug(3, " Found capability \"%s\": %d\n", Capabilities[i], i);
+ mutt_debug(LL_DEBUG3, " Found capability \"%s\": %d\n", Capabilities[i], i);
break;
}
}
s = imap_next_word(s);
if (*s != '(')
{
- mutt_debug(1, "Bad LIST response\n");
+ mutt_debug(LL_DEBUG1, "Bad LIST response\n");
return;
}
s++;
if (list->name[0] == '\0')
{
adata->delim = list->delim;
- mutt_debug(3, "Root delimiter: %c\n", adata->delim);
+ mutt_debug(LL_DEBUG3, "Root delimiter: %c\n", adata->delim);
}
}
if (!list.name || list.noselect)
return;
- mutt_debug(3, "Subscribing to %s\n", list.name);
+ mutt_debug(LL_DEBUG3, "Subscribing to %s\n", list.name);
mutt_str_strfcpy(buf, "mailboxes \"", sizeof(buf));
mutt_account_tourl(&adata->conn->account, &url);
err.data = errstr;
err.dsize = sizeof(errstr);
if (mutt_parse_rc_line(buf, &token, &err))
- mutt_debug(1, "Error adding subscribed mailbox: %s\n", errstr);
+ mutt_debug(LL_DEBUG1, "Error adding subscribed mailbox: %s\n", errstr);
FREE(&token.data);
}
*/
static void cmd_parse_myrights(struct ImapAccountData *adata, const char *s)
{
- mutt_debug(2, "Handling MYRIGHTS\n");
+ mutt_debug(LL_DEBUG2, "Handling MYRIGHTS\n");
s = imap_next_word((char *) s);
s = imap_next_word((char *) s);
adata->mailbox->rights |= MUTT_ACL_DELETE | MUTT_ACL_EXPUNGE;
break;
default:
- mutt_debug(1, "Unknown right: %c\n", *s);
+ mutt_debug(LL_DEBUG1, "Unknown right: %c\n", *s);
}
s++;
}
struct Email *e = NULL;
struct ImapMboxData *mdata = adata->mailbox->mdata;
- mutt_debug(2, "Handling SEARCH\n");
+ mutt_debug(LL_DEBUG2, "Handling SEARCH\n");
while ((s = imap_next_word((char *) s)) && *s != '\0')
{
if (strlen(adata->buf) < litlen)
{
- mutt_debug(1, "Error parsing STATUS mailbox\n");
+ mutt_debug(LL_DEBUG1, "Error parsing STATUS mailbox\n");
return;
}
struct ImapMboxData *mdata = imap_mdata_get(m);
if (!mdata)
{
- mutt_debug(3, "Received status for an unexpected mailbox: %s\n", mailbox);
+ mutt_debug(LL_DEBUG3, "Received status for an unexpected mailbox: %s\n", mailbox);
return;
}
olduv = mdata->uid_validity;
if (*s++ != '(')
{
- mutt_debug(1, "Error parsing STATUS\n");
+ mutt_debug(LL_DEBUG1, "Error parsing STATUS\n");
return;
}
while (*s && *s != ')')
const unsigned long ulcount = strtoul(value, &value, 10);
if (((errno == ERANGE) && (ulcount == ULONG_MAX)) || ((unsigned int) ulcount != ulcount))
{
- mutt_debug(1, "Error parsing STATUS number\n");
+ mutt_debug(LL_DEBUG1, "Error parsing STATUS number\n");
return;
}
const unsigned int count = (unsigned int) ulcount;
if (*s && *s != ')')
s = imap_next_word(s);
}
- mutt_debug(3, "%s (UIDVALIDITY: %u, UIDNEXT: %u) %d messages, %d recent, %d unseen\n",
+ mutt_debug(LL_DEBUG3, "%s (UIDVALIDITY: %u, UIDNEXT: %u) %d messages, %d recent, %d unseen\n",
mdata->name, mdata->uid_validity, mdata->uid_next, mdata->messages,
mdata->recent, mdata->unseen);
- mutt_debug(3, "Running default STATUS handler\n");
+ mutt_debug(LL_DEBUG3, "Running default STATUS handler\n");
- mutt_debug(3, "Found %s in mailbox list (OV: %u ON: %u U: %d)\n", mailbox,
- olduv, oldun, mdata->unseen);
+ mutt_debug(LL_DEBUG3, "Found %s in mailbox list (OV: %u ON: %u U: %d)\n",
+ mailbox, olduv, oldun, mdata->unseen);
if (MailCheckRecent)
{
*/
static void cmd_parse_enabled(struct ImapAccountData *adata, const char *s)
{
- mutt_debug(2, "Handling ENABLED\n");
+ mutt_debug(LL_DEBUG2, "Handling ENABLED\n");
while ((s = imap_next_word((char *) s)) && *s != '\0')
{
static void cmd_parse_exists(struct ImapAccountData *adata, const char *pn)
{
unsigned int count = 0;
- mutt_debug(2, "Handling EXISTS\n");
+ mutt_debug(LL_DEBUG2, "Handling EXISTS\n");
if (mutt_str_atoui(pn, &count) < 0)
{
- mutt_debug(1, "Malformed EXISTS: '%s'\n", pn);
+ mutt_debug(LL_DEBUG1, "Malformed EXISTS: '%s'\n", pn);
return;
}
{
/* Notes 6.0.3 has a tendency to report fewer messages exist than
* it should. */
- mutt_debug(1, "Message count is out of sync\n");
+ mutt_debug(LL_DEBUG1, "Message count is out of sync\n");
}
/* at least the InterChange server sends EXISTS messages freely,
* even when there is no new mail */
else if (count == mdata->max_msn)
- mutt_debug(3, "superfluous EXISTS message.\n");
+ mutt_debug(LL_DEBUG3, "superfluous EXISTS message.\n");
else
{
- mutt_debug(2, "New mail in %s - %d messages total.\n", mdata->name, count);
+ mutt_debug(LL_DEBUG2, "New mail in %s - %d messages total.\n", mdata->name, count);
mdata->reopen |= IMAP_NEWMAIL_PENDING;
mdata->new_mail_count = count;
}
cmd_parse_enabled(adata, s);
else if (mutt_str_startswith(s, "BYE", CASE_IGNORE))
{
- mutt_debug(2, "Handling BYE\n");
+ mutt_debug(LL_DEBUG2, "Handling BYE\n");
/* check if we're logging out */
if (adata->status == IMAP_BYE)
}
else if (ImapServernoise && mutt_str_startswith(s, "NO", CASE_IGNORE))
{
- mutt_debug(2, "Handling untagged NO\n");
+ mutt_debug(LL_DEBUG2, "Handling untagged NO\n");
/* Display the warning message from the server */
mutt_error("%s", s + 2);
{
mutt_mem_realloc(&adata->buf, adata->blen + IMAP_CMD_BUFSIZE);
adata->blen = adata->blen + IMAP_CMD_BUFSIZE;
- mutt_debug(3, "grew buffer to %u bytes\n", adata->blen);
+ mutt_debug(LL_DEBUG3, "grew buffer to %u bytes\n", adata->blen);
}
/* back up over '\0' */
c = mutt_socket_readln_d(adata->buf + len, adata->blen - len, adata->conn, MUTT_SOCK_LOG_FULL);
if (c <= 0)
{
- mutt_debug(1, "Error reading server response.\n");
+ mutt_debug(LL_DEBUG1, "Error reading server response.\n");
cmd_handle_fatal(adata);
return IMAP_CMD_BAD;
}
{
mutt_mem_realloc(&adata->buf, IMAP_CMD_BUFSIZE);
adata->blen = IMAP_CMD_BUFSIZE;
- mutt_debug(3, "shrank buffer to %u bytes\n", adata->blen);
+ mutt_debug(LL_DEBUG3, "shrank buffer to %u bytes\n", adata->blen);
}
adata->lastread = time(NULL);
rc = IMAP_CMD_CONTINUE;
else
{
- mutt_debug(3, "IMAP queue drained\n");
+ mutt_debug(LL_DEBUG3, "IMAP queue drained\n");
imap_cmd_finish(adata);
}
if (!s)
{
- mutt_debug(2, "not a tagged response\n");
+ mutt_debug(LL_DEBUG2, "not a tagged response\n");
return notrailer;
}
!mutt_str_startswith(s, "NO", CASE_IGNORE) &&
!mutt_str_startswith(s, "BAD", CASE_IGNORE)))
{
- mutt_debug(2, "not a command completion: %s\n", adata->buf);
+ mutt_debug(LL_DEBUG2, "not a command completion: %s\n", adata->buf);
return notrailer;
}
if (adata->status != IMAP_FATAL)
return IMAP_EXEC_ERROR;
- mutt_debug(1, "command failed: %s\n", adata->buf);
+ mutt_debug(LL_DEBUG1, "command failed: %s\n", adata->buf);
return IMAP_EXEC_FATAL;
}
// First remove expunged emails from the msn_index
if (mdata->reopen & IMAP_EXPUNGE_PENDING)
{
- mutt_debug(2, "Expunging mailbox\n");
+ mutt_debug(LL_DEBUG2, "Expunging mailbox\n");
imap_expunge_mailbox(adata->mailbox);
}
if (!(mdata->reopen & IMAP_EXPUNGE_PENDING))
mdata->check_status = IMAP_NEWMAIL_PENDING;
- mutt_debug(2, "Fetching new mails from %d to %d\n", mdata->max_msn + 1,
- mdata->new_mail_count);
+ mutt_debug(LL_DEBUG2, "Fetching new mails from %d to %d\n",
+ mdata->max_msn + 1, mdata->new_mail_count);
imap_read_headers(adata->mailbox, mdata->max_msn + 1, mdata->new_mail_count, false);
}
}
if (rc != IMAP_CMD_OK)
{
- mutt_debug(1, "error starting IDLE\n");
+ mutt_debug(LL_DEBUG1, "error starting IDLE\n");
return -1;
}
const size_t plen = mutt_str_startswith(s, "FLAGS", CASE_IGNORE);
if (plen == 0)
{
- mutt_debug(1, "not a FLAGS response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "not a FLAGS response: %s\n", s);
return NULL;
}
s += plen;
SKIPWS(s);
if (*s != '(')
{
- mutt_debug(1, "bogus FLAGS response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "bogus FLAGS response: %s\n", s);
return NULL;
}
/* note bad flags response */
if (*s != ')')
{
- mutt_debug(1, "Unterminated FLAGS response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "Unterminated FLAGS response: %s\n", s);
mutt_list_free(hflags);
return NULL;
if (DebugLevel >= IMAP_LOG_LTRL)
buf = mutt_buffer_alloc(bytes + 10);
- mutt_debug(2, "reading %ld bytes\n", bytes);
+ mutt_debug(LL_DEBUG2, "reading %ld bytes\n", bytes);
for (unsigned long pos = 0; pos < bytes; pos++)
{
if (mutt_socket_readchar(adata->conn, &c) != 1)
{
- mutt_debug(1, "error during read, %ld bytes read\n", pos);
+ mutt_debug(LL_DEBUG1, "error during read, %ld bytes read\n", pos);
adata->status = IMAP_FATAL;
mutt_buffer_free(&buf);
if (e->index == INT_MAX)
{
- mutt_debug(2, "Expunging message UID %u.\n", imap_edata_get(e)->uid);
+ mutt_debug(LL_DEBUG2, "Expunging message UID %u.\n", imap_edata_get(e)->uid);
e->active = false;
m->size -= e->content->length;
{
if (imap_cmd_step(adata) != IMAP_CMD_CONTINUE)
{
- mutt_debug(1, "Error reading IDLE response\n");
+ mutt_debug(LL_DEBUG1, "Error reading IDLE response\n");
return -1;
}
}
if (result < 0)
{
- mutt_debug(1, "Poll failed, disabling IDLE\n");
+ mutt_debug(LL_DEBUG1, "Poll failed, disabling IDLE\n");
adata->capabilities &= ~IMAP_CAP_IDLE; // Clear the flag
}
}
uid_validity_flag = "UID-VALIDITY";
else
{
- mutt_debug(2, "Server doesn't support STATUS\n");
+ mutt_debug(LL_DEBUG2, "Server doesn't support STATUS\n");
return -1;
}
int rc = imap_exec(adata, command, queue ? IMAP_CMD_QUEUE : 0 | IMAP_CMD_POLL);
if (rc < 0)
{
- mutt_debug(1, "Error queueing command\n");
+ mutt_debug(LL_DEBUG1, "Error queueing command\n");
return rc;
}
return mdata->messages;
len = snprintf(mbox, sizeof(mbox), "%smailboxes ", subscribe ? "" : "un");
imap_quote_string(mbox + len, sizeof(mbox) - len, path, true);
if (mutt_parse_rc_line(mbox, &token, &err))
- mutt_debug(1, "Error adding subscribed mailbox: %s\n", errstr);
+ mutt_debug(LL_DEBUG1, "Error adding subscribed mailbox: %s\n", errstr);
FREE(&token.data);
}
/* check that the save-to folder is in the same account */
if (!mutt_account_match(&(adata->conn->account), &(dest_adata->conn->account)))
{
- mutt_debug(3, "%s not same server as %s\n", dest, m->path);
+ mutt_debug(LL_DEBUG3, "%s not same server as %s\n", dest, m->path);
goto out;
}
rc = imap_sync_message_for_copy(m, m->emails[i], sync_cmd, &err_continue);
if (rc < 0)
{
- mutt_debug(1, "could not sync\n");
+ mutt_debug(LL_DEBUG1, "could not sync\n");
goto out;
}
}
rc = imap_exec_msgset(m, "UID COPY", dest_mdata->munge_name, MUTT_TRASH, false, false);
if (!rc)
{
- mutt_debug(1, "No messages to trash\n");
+ mutt_debug(LL_DEBUG1, "No messages to trash\n");
rc = -1;
goto out;
}
else if (rc < 0)
{
- mutt_debug(1, "could not queue copy\n");
+ mutt_debug(LL_DEBUG1, "could not queue copy\n");
goto out;
}
else
{
if (triedcreate)
{
- mutt_debug(1, "Already tried to create mailbox %s\n", dest_mdata->name);
+ mutt_debug(LL_DEBUG1, "Already tried to create mailbox %s\n", dest_mdata->name);
break;
}
/* bail out if command failed for reasons other than nonexistent target */
if (!mutt_str_startswith(imap_get_qualifier(adata->buf), "[TRYCREATE]", CASE_IGNORE))
break;
- mutt_debug(3, "server suggests TRYCREATE\n");
+ mutt_debug(LL_DEBUG3, "server suggests TRYCREATE\n");
snprintf(prompt, sizeof(prompt), _("Create %s?"), dest_mdata->name);
if (Confirmcreate && mutt_yesorno(prompt, 1) != MUTT_YES)
{
if (adata->state < IMAP_SELECTED)
{
- mutt_debug(2, "no mailbox selected\n");
+ mutt_debug(LL_DEBUG2, "no mailbox selected\n");
return -1;
}
adata->state = IMAP_AUTHENTICATED;
FREE(&adata->capstr);
if (adata->conn->ssf)
- mutt_debug(2, "Communication encrypted at %d bits\n", adata->conn->ssf);
+ mutt_debug(LL_DEBUG2, "Communication encrypted at %d bits\n",
+ adata->conn->ssf);
}
else
mutt_account_unsetpass(&adata->conn->account);
/* don't override PERMANENTFLAGS */
if (STAILQ_EMPTY(&mdata->flags))
{
- mutt_debug(3, "Getting mailbox FLAGS\n");
+ mutt_debug(LL_DEBUG3, "Getting mailbox FLAGS\n");
pc = get_flags(&mdata->flags, pc);
if (!pc)
goto fail;
/* PERMANENTFLAGS are massaged to look like FLAGS, then override FLAGS */
else if (mutt_str_startswith(pc, "OK [PERMANENTFLAGS", CASE_IGNORE))
{
- mutt_debug(3, "Getting mailbox PERMANENTFLAGS\n");
+ mutt_debug(LL_DEBUG3, "Getting mailbox PERMANENTFLAGS\n");
/* safe to call on NULL */
mutt_list_free(&mdata->flags);
/* skip "OK [PERMANENT" so syntax is the same as FLAGS */
/* save UIDVALIDITY for the header cache */
else if (mutt_str_startswith(pc, "OK [UIDVALIDITY", CASE_IGNORE))
{
- mutt_debug(3, "Getting mailbox UIDVALIDITY\n");
+ mutt_debug(LL_DEBUG3, "Getting mailbox UIDVALIDITY\n");
pc += 3;
pc = imap_next_word(pc);
if (mutt_str_atoui(pc, &mdata->uid_validity) < 0)
}
else if (mutt_str_startswith(pc, "OK [UIDNEXT", CASE_IGNORE))
{
- mutt_debug(3, "Getting mailbox UIDNEXT\n");
+ mutt_debug(LL_DEBUG3, "Getting mailbox UIDNEXT\n");
pc += 3;
pc = imap_next_word(pc);
if (mutt_str_atoui(pc, &mdata->uid_next) < 0)
}
else if (mutt_str_startswith(pc, "OK [HIGHESTMODSEQ", CASE_IGNORE))
{
- mutt_debug(3, "Getting mailbox HIGHESTMODSEQ\n");
+ mutt_debug(LL_DEBUG3, "Getting mailbox HIGHESTMODSEQ\n");
pc += 3;
pc = imap_next_word(pc);
if (mutt_str_atoull(pc, &mdata->modseq) < 0)
}
else if (mutt_str_startswith(pc, "OK [NOMODSEQ", CASE_IGNORE))
{
- mutt_debug(3, "Mailbox has NOMODSEQ set\n");
+ mutt_debug(LL_DEBUG3, "Mailbox has NOMODSEQ set\n");
mdata->modseq = 0;
}
else
if (mutt_str_startswith(imap_get_qualifier(adata->buf), "[READ-ONLY]", CASE_IGNORE) &&
!(adata->capabilities & IMAP_CAP_ACL))
{
- mutt_debug(2, "Mailbox is read-only.\n");
+ mutt_debug(LL_DEBUG2, "Mailbox is read-only.\n");
m->readonly = true;
}
if (DebugLevel > 2)
{
if (STAILQ_EMPTY(&mdata->flags))
- mutt_debug(3, "No folder flags found\n");
+ mutt_debug(LL_DEBUG3, "No folder flags found\n");
else
{
struct ListNode *np = NULL;
{
mutt_buffer_add_printf(&flag_buffer, "[%s] ", np->data);
}
- mutt_debug(3, "%s\n", flag_buffer.data);
+ mutt_debug(LL_DEBUG3, "%s\n", flag_buffer.data);
FREE(&flag_buffer.data);
}
}
goto fail;
}
- mutt_debug(2, "msg_count is %d\n", m->msg_count);
+ mutt_debug(LL_DEBUG2, "msg_count is %d\n", m->msg_count);
return 0;
fail:
cmd = mutt_buffer_new();
if (!cmd)
{
- mutt_debug(1, "unable to allocate buffer\n");
+ mutt_debug(LL_DEBUG1, "unable to allocate buffer\n");
return -1;
}
cmd->dptr = cmd->data;
cmd = mutt_buffer_new();
if (!cmd)
{
- mutt_debug(1, "fail to remove old flags\n");
+ mutt_debug(LL_DEBUG1, "fail to remove old flags\n");
return -1;
}
cmd->dptr = cmd->data;
if (imap_exec(adata, cmd->data, 0) != IMAP_EXEC_SUCCESS)
{
- mutt_debug(1, "fail to add new flags\n");
+ mutt_debug(LL_DEBUG1, "fail to add new flags\n");
mutt_buffer_free(&cmd);
return -1;
}
}
/* We are good sync them */
- mutt_debug(1, "NEW TAGS: %s\n", buf);
+ mutt_debug(LL_DEBUG1, "NEW TAGS: %s\n", buf);
driver_tags_replace(&e->tags, buf);
FREE(&imap_edata_get(e)->flags_remote);
imap_edata_get(e)->flags_remote = driver_tags_get_with_hidden(&e->tags);
size_t plen = mutt_str_startswith(s, "FLAGS", CASE_IGNORE);
if (plen == 0)
{
- mutt_debug(1, "not a FLAGS response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "not a FLAGS response: %s\n", s);
return NULL;
}
s += plen;
SKIPWS(s);
if (*s != '(')
{
- mutt_debug(1, "bogus FLAGS response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "bogus FLAGS response: %s\n", s);
return NULL;
}
s++;
s++;
else
{
- mutt_debug(1, "Unterminated FLAGS response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "Unterminated FLAGS response: %s\n", s);
return NULL;
}
SKIPWS(s);
if (*s != '\"')
{
- mutt_debug(1, "bogus INTERNALDATE entry: %s\n", s);
+ mutt_debug(LL_DEBUG1, "bogus INTERNALDATE entry: %s\n", s);
return -1;
}
s++;
SKIPWS(s);
if (*s != '(')
{
- mutt_debug(1, "bogus MODSEQ response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "bogus MODSEQ response: %s\n", s);
return -1;
}
s++;
s++;
else
{
- mutt_debug(1, "Unterminated MODSEQ response: %s\n", s);
+ mutt_debug(LL_DEBUG1, "Unterminated MODSEQ response: %s\n", s);
return -1;
}
}
if (!h.edata->uid)
{
- mutt_debug(2, "skipping hcache FETCH response for message number %d missing a UID\n",
+ mutt_debug(LL_DEBUG2, "skipping hcache FETCH response for message number %d missing a UID\n",
h.edata->msn);
continue;
}
if ((h.edata->msn < 1) || (h.edata->msn > msn_end))
{
- mutt_debug(1, "skipping hcache FETCH response for unknown message number %d\n",
+ mutt_debug(LL_DEBUG1, "skipping hcache FETCH response for unknown message number %d\n",
h.edata->msn);
continue;
}
if (mdata->msn_index[h.edata->msn - 1])
{
- mutt_debug(2, "skipping hcache FETCH for duplicate message %d\n",
+ mutt_debug(LL_DEBUG2, "skipping hcache FETCH for duplicate message %d\n",
h.edata->msn);
continue;
}
int rc;
unsigned int uid = 0;
- mutt_debug(2, "Reading uid seqset from header cache\n");
+ mutt_debug(LL_DEBUG2, "Reading uid seqset from header cache\n");
struct Mailbox *m = adata->mailbox;
struct ImapMboxData *mdata = adata->mailbox->mdata;
unsigned int msn = 1;
if ((header_msn < 1) || (header_msn > msn_end) || !mdata->msn_index[header_msn - 1])
{
- mutt_debug(1, "skipping CONDSTORE flag update for unknown message number %u\n", header_msn);
+ mutt_debug(LL_DEBUG1, "skipping CONDSTORE flag update for unknown message number %u\n",
+ header_msn);
continue;
}
if (!ftello(fp))
{
- mutt_debug(2, "ignoring fetch response with no body\n");
+ mutt_debug(LL_DEBUG2, "ignoring fetch response with no body\n");
continue;
}
if ((h.edata->msn < 1) || (h.edata->msn > fetch_msn_end))
{
- mutt_debug(1, "skipping FETCH response for unknown message number %d\n",
+ mutt_debug(LL_DEBUG1, "skipping FETCH response for unknown message number %d\n",
h.edata->msn);
continue;
}
/* May receive FLAGS updates in a separate untagged response (#2935) */
if (mdata->msn_index[h.edata->msn - 1])
{
- mutt_debug(2, "skipping FETCH response for duplicate message %d\n",
+ mutt_debug(LL_DEBUG2, "skipping FETCH response for duplicate message %d\n",
h.edata->msn);
continue;
}
sizeof(mdata->uid_validity));
if (maxuid && mdata->uid_next < maxuid + 1)
{
- mutt_debug(2, "Overriding UIDNEXT: %u -> %u\n", mdata->uid_next, maxuid + 1);
+ mutt_debug(LL_DEBUG2, "Overriding UIDNEXT: %u -> %u\n", mdata->uid_next, maxuid + 1);
mdata->uid_next = maxuid + 1;
}
if (mdata->uid_next > 1)
if (rc != IMAP_CMD_RESPOND)
{
- mutt_debug(1, "#1 command failed: %s\n", adata->buf);
+ mutt_debug(LL_DEBUG1, "#1 command failed: %s\n", adata->buf);
char *pc = adata->buf + SEQLEN;
SKIPWS(pc);
if (!imap_code(adata->buf))
{
- mutt_debug(1, "#2 command failed: %s\n", adata->buf);
+ mutt_debug(LL_DEBUG1, "#2 command failed: %s\n", adata->buf);
char *pc = adata->buf + SEQLEN;
SKIPWS(pc);
pc = imap_next_word(pc);
if (single && en->email->attach_del)
{
- mutt_debug(3, "#1 Message contains attachments to be deleted\n");
+ mutt_debug(LL_DEBUG3, "#1 Message contains attachments to be deleted\n");
return 1;
}
if (imap_parse_path(dest, &conn_account, buf, sizeof(buf)))
{
- mutt_debug(1, "bad destination %s\n", dest);
+ mutt_debug(LL_DEBUG1, "bad destination %s\n", dest);
return -1;
}
/* check that the save-to folder is in the same account */
if (!mutt_account_match(&adata->conn->account, &conn_account))
{
- mutt_debug(3, "%s not same server as %s\n", dest, m->path);
+ mutt_debug(LL_DEBUG3, "%s not same server as %s\n", dest, m->path);
return 1;
}
{
if (en->email->attach_del)
{
- mutt_debug(3, "#2 Message contains attachments to be deleted\n");
+ mutt_debug(LL_DEBUG3,
+ "#2 Message contains attachments to be deleted\n");
return 1;
}
rc = imap_sync_message_for_copy(m, en->email, &sync_cmd, &err_continue);
if (rc < 0)
{
- mutt_debug(1, "#1 could not sync\n");
+ mutt_debug(LL_DEBUG1, "#1 could not sync\n");
goto out;
}
}
rc = imap_exec_msgset(m, "UID COPY", mmbox, MUTT_TAG, false, false);
if (!rc)
{
- mutt_debug(1, "No messages tagged\n");
+ mutt_debug(LL_DEBUG1, "No messages tagged\n");
rc = -1;
goto out;
}
else if (rc < 0)
{
- mutt_debug(1, "#1 could not queue copy\n");
+ mutt_debug(LL_DEBUG1, "#1 could not queue copy\n");
goto out;
}
else
rc = imap_sync_message_for_copy(m, en->email, &sync_cmd, &err_continue);
if (rc < 0)
{
- mutt_debug(1, "#2 could not sync\n");
+ mutt_debug(LL_DEBUG1, "#2 could not sync\n");
goto out;
}
}
rc = imap_exec(adata, cmd.data, IMAP_CMD_QUEUE);
if (rc != IMAP_EXEC_SUCCESS)
{
- mutt_debug(1, "#2 could not queue copy\n");
+ mutt_debug(LL_DEBUG1, "#2 could not queue copy\n");
goto out;
}
}
{
if (triedcreate)
{
- mutt_debug(1, "Already tried to create mailbox %s\n", mbox);
+ mutt_debug(LL_DEBUG1, "Already tried to create mailbox %s\n", mbox);
break;
}
/* bail out if command failed for reasons other than nonexistent target */
if (!mutt_str_startswith(imap_get_qualifier(adata->buf), "[TRYCREATE]", CASE_IGNORE))
break;
- mutt_debug(3, "server suggests TRYCREATE\n");
+ mutt_debug(LL_DEBUG3, "server suggests TRYCREATE\n");
snprintf(prompt, sizeof(prompt), _("Create %s?"), mbox);
if (Confirmcreate && mutt_yesorno(prompt, 1) != MUTT_YES)
{
memcpy(&old_edata, edata, sizeof(old_edata));
- mutt_debug(2, "parsing FLAGS\n");
+ mutt_debug(LL_DEBUG2, "parsing FLAGS\n");
s = msg_parse_flags(&newh, s);
if (!s)
return NULL;
return 0;
}
}
- mutt_debug(3, "no ImapAccountData found\n");
+ mutt_debug(LL_DEBUG3, "no ImapAccountData found\n");
return -1;
}
mdata->uid_validity = *(unsigned int *) uidvalidity;
mdata->uid_next = uidnext ? *(unsigned int *) uidnext : 0;
mdata->modseq = modseq ? *modseq : 0;
- mutt_debug(3, "hcache uidvalidity %u, uidnext %u, modseq %llu\n",
+ mutt_debug(LL_DEBUG3, "hcache uidvalidity %u, uidnext %u, modseq %llu\n",
mdata->uid_validity, mdata->uid_next, mdata->modseq);
}
mutt_hcache_free(hc, &uidvalidity);
if (*(unsigned int *) uv == mdata->uid_validity)
e = mutt_hcache_restore(uv);
else
- mutt_debug(3, "hcache uidvalidity mismatch: %u\n", *(unsigned int *) uv);
+ mutt_debug(LL_DEBUG3, "hcache uidvalidity mismatch: %u\n", *(unsigned int *) uv);
mutt_hcache_free(mdata->hcache, &uv);
}
b->data[0] = '\0';
int rc = mutt_hcache_store_raw(mdata->hcache, "/UIDSEQSET", 10, b->data, seqset_size + 1);
- mutt_debug(3, "Stored /UIDSEQSET %s\n", b->data);
+ mutt_debug(LL_DEBUG3, "Stored /UIDSEQSET %s\n", b->data);
mutt_buffer_free(&b);
return rc;
}
char *hc_seqset = mutt_hcache_fetch_raw(mdata->hcache, "/UIDSEQSET", 10);
char *seqset = mutt_str_strdup(hc_seqset);
mutt_hcache_free(mdata->hcache, (void **) &hc_seqset);
- mutt_debug(3, "Retrieved /UIDSEQSET %s\n", NONULL(seqset));
+ mutt_debug(LL_DEBUG3, "Retrieved /UIDSEQSET %s\n", NONULL(seqset));
return seqset;
}
ImapPort = ntohs(service->s_port);
else
ImapPort = IMAP_PORT;
- mutt_debug(3, "Using default IMAP port %d\n", ImapPort);
+ mutt_debug(LL_DEBUG3, "Using default IMAP port %d\n", ImapPort);
}
if (!ImapsPort)
{
ImapsPort = ntohs(service->s_port);
else
ImapsPort = IMAP_SSL_PORT;
- mutt_debug(3, "Using default IMAPS port %d\n", ImapsPort);
+ mutt_debug(LL_DEBUG3, "Using default IMAPS port %d\n", ImapsPort);
}
/* Defaults */
op = km_dokey(MENU_MAIN);
- mutt_debug(3, "[%d]: Got op %d\n", __LINE__, op);
+ mutt_debug(LL_DEBUG3, "[%d]: Got op %d\n", __LINE__, op);
/* either user abort or timeout */
if (op < 0)
case OP_MAIN_WINDOWED_VFOLDER_BACKWARD:
if (!prereq(Context, menu, CHECK_IN_MAILBOX))
break;
- mutt_debug(2, "OP_MAIN_WINDOWED_VFOLDER_BACKWARD\n");
+ mutt_debug(LL_DEBUG2, "OP_MAIN_WINDOWED_VFOLDER_BACKWARD\n");
if (NmQueryWindowDuration <= 0)
{
mutt_message(_("Windowed queries disabled"));
mutt_message(_("Failed to create query, aborting"));
else
{
- mutt_debug(2, "nm: + windowed query (%s)\n", buf);
+ mutt_debug(LL_DEBUG2, "nm: + windowed query (%s)\n", buf);
main_change_folder(menu, op, NULL, buf, sizeof(buf), &oldcount, &index_hint);
}
break;
by whatever they typed at the prompt.) */
snprintf(buf2, sizeof(buf2), _("Message bound to %s"), str);
mutt_message(buf2);
- mutt_debug(1, "Mark: %s => %s\n", str, macro);
+ mutt_debug(LL_DEBUG1, "Mark: %s => %s\n", str, macro);
}
}
else
return MUTT_CMD_ERROR;
}
- mutt_debug(3, "added %s/%s [%d]\n", a->major, a->minor, a->major_int);
+ mutt_debug(LL_DEBUG3, "added %s/%s [%d]\n", a->major, a->minor, a->major_int);
mutt_list_insert_tail(head, (char *) a);
} while (MoreArgs(s));
STAILQ_FOREACH_SAFE(np, head, entries, tmp2)
{
a = (struct AttachMatch *) np->data;
- mutt_debug(3, "check %s/%s [%d] : %s/%s [%d]\n", a->major, a->minor,
- a->major_int, tmp, minor, major);
+ mutt_debug(LL_DEBUG3, "check %s/%s [%d] : %s/%s [%d]\n", a->major,
+ a->minor, a->major_int, tmp, minor, major);
if (a->major_int == major && (mutt_str_strcasecmp(minor, a->minor) == 0))
{
- mutt_debug(3, "removed %s/%s [%d]\n", a->major, a->minor, a->major_int);
+ mutt_debug(LL_DEBUG3, "removed %s/%s [%d]\n", a->major, a->minor, a->major_int);
regfree(&a->minor_regex);
FREE(&a->major);
STAILQ_REMOVE(head, np, ListNode, entries);
}
}
- mutt_debug(2, "Reading configuration file '%s'.\n", rcfile);
+ mutt_debug(LL_DEBUG2, "Reading configuration file '%s'.\n", rcfile);
f = mutt_open_read(rcfile, &pid);
if (!f)
}
else
{
- mutt_debug(1, "Corrupted buffer");
+ mutt_debug(LL_DEBUG1, "Corrupted buffer");
return MUTT_CMD_ERROR;
}
}
tmp = mutt_hash_find(TagFormats, format);
if (tmp)
{
- mutt_debug(3, "tag format '%s' already registered as '%s'\n", format, tmp);
+ mutt_debug(LL_DEBUG3, "tag format '%s' already registered as '%s'\n", format, tmp);
FREE(&tag);
FREE(&format);
continue;
tmp = mutt_hash_find(TagTransforms, tag);
if (tmp)
{
- mutt_debug(3, "tag transform '%s' already registered as '%s'\n", tag, tmp);
+ mutt_debug(LL_DEBUG3, "tag transform '%s' already registered as '%s'\n", tag, tmp);
FREE(&tag);
FREE(&transform);
continue;
}
else
{
- mutt_debug(1, "Corrupted buffer");
+ mutt_debug(LL_DEBUG1, "Corrupted buffer");
return MUTT_CMD_ERROR;
}
}
} while (pc && *pc != '`');
if (!pc)
{
- mutt_debug(1, "mismatched backticks\n");
+ mutt_debug(LL_DEBUG1, "mismatched backticks\n");
return -1;
}
struct Buffer cmd;
pid = mutt_create_filter(cmd.data, NULL, &fp, NULL);
if (pid < 0)
{
- mutt_debug(1, "unable to fork command: %s\n", cmd);
+ mutt_debug(LL_DEBUG1, "unable to fork command: %s\n", cmd);
FREE(&cmd.data);
return -1;
}
char *p = strrchr(e->path, '/');
if (!p)
{
- mutt_debug(1, "%s: unable to find subdir!\n", e->path);
+ mutt_debug(LL_DEBUG1, "%s: unable to find subdir!\n", e->path);
return -1;
}
p++;
snprintf(path, sizeof(path), "%s/tmp/%s.%lld.R%" PRIu64 ".%s%s", m->path, subdir,
(long long) time(NULL), mutt_rand64(), NONULL(ShortHostname), suffix);
- mutt_debug(2, "Trying %s.\n", path);
+ mutt_debug(LL_DEBUG2, "Trying %s.\n", path);
fd = open(path, O_WRONLY | O_EXCL | O_CREAT, 0666);
if (fd == -1)
}
else
{
- mutt_debug(2, "Success.\n");
+ mutt_debug(LL_DEBUG2, "Success.\n");
msg->path = mutt_str_strdup(path);
break;
}
struct stat st;
if (stat(m->path, &st))
{
- mutt_debug(1, "stat failed on %s\n", m->path);
+ mutt_debug(LL_DEBUG1, "stat failed on %s\n", m->path);
return 077;
}
}
/* FOO - really ignore the return value? */
- mutt_debug(2, "queueing %s\n", de->d_name);
+ mutt_debug(LL_DEBUG2, "queueing %s\n", de->d_name);
e = mutt_email_new();
e->old = is_old;
while (md)
{
- mutt_debug(2, "Considering %s\n", NONULL(md->canon_fname));
+ mutt_debug(LL_DEBUG2, "Considering %s\n", NONULL(md->canon_fname));
if (md->email)
{
- mutt_debug(2, "Adding header structure. Flags: %s%s%s%s%s\n",
+ mutt_debug(LL_DEBUG2, "Adding header structure. Flags: %s%s%s%s%s\n",
md->email->flagged ? "f" : "", md->email->deleted ? "D" : "",
md->email->replied ? "r" : "", md->email->old ? "O" : "",
md->email->read ? "R" : "");
{
if (!m || !md || !*md || (m->magic != MUTT_MH) || (Sort != SORT_ORDER))
return;
- mutt_debug(3, "maildir: sorting %s into natural order\n", m->path);
+ mutt_debug(LL_DEBUG3, "maildir: sorting %s into natural order\n", m->path);
*md = maildir_sort(*md, (size_t) -1, md_cmp_path);
}
if (!sort)
{
- mutt_debug(3, "maildir: need to sort %s by inode\n", m->path);
+ mutt_debug(LL_DEBUG3, "maildir: need to sort %s by inode\n", m->path);
p = maildir_sort(p, (size_t) -1, md_cmp_inode);
if (!last)
*md = p;
if (!msg->fp)
{
mutt_perror(path);
- mutt_debug(1, "fopen: %s: %s (errno %d).\n", path, strerror(errno), errno);
+ mutt_debug(LL_DEBUG1, "fopen: %s: %s (errno %d).\n", path, strerror(errno), errno);
return -1;
}
mutt_rand64(), NONULL(ShortHostname), suffix);
mutt_buffer_printf(full, "%s/%s", m->path, mutt_b2s(path));
- mutt_debug(2, "renaming %s to %s.\n", msg->path, mutt_b2s(full));
+ mutt_debug(LL_DEBUG2, "renaming %s to %s.\n", msg->path, mutt_b2s(full));
if (mutt_file_safe_rename(msg->path, mutt_b2s(full)) == 0)
{
if (!fgets(buf, sizeof(buf) - 1, adata->fp))
{
/* TODO: memory leak??? */
- mutt_debug(1, "unexpected EOF\n");
+ mutt_debug(LL_DEBUG1, "unexpected EOF\n");
break;
}
{
if (fseeko(adata->fp, loc, SEEK_SET) != 0)
{
- mutt_debug(1, "#1 fseek() failed\n");
+ mutt_debug(LL_DEBUG1, "#1 fseek() failed\n");
mutt_error(_("Mailbox is corrupt"));
return -1;
}
(mutt_str_strcmp(MMDF_SEP, buf) != 0))
{
if (fseeko(adata->fp, loc, SEEK_SET) != 0)
- mutt_debug(1, "#2 fseek() failed\n");
+ mutt_debug(LL_DEBUG1, "#2 fseek() failed\n");
e->content->length = -1;
}
}
}
else
{
- mutt_debug(1, "corrupt mailbox\n");
+ mutt_debug(LL_DEBUG1, "corrupt mailbox\n");
mutt_error(_("Mailbox is corrupt"));
return -1;
}
!fgets(buf, sizeof(buf), adata->fp) ||
!mutt_str_startswith(buf, "From ", CASE_MATCH))
{
- mutt_debug(1, "bad content-length in message %d (cl=" OFF_T_FMT ")\n",
+ mutt_debug(LL_DEBUG1, "bad content-length in message %d (cl=" OFF_T_FMT ")\n",
e_cur->index, e_cur->content->length);
- mutt_debug(1, "\tLINE: %s", buf);
+ mutt_debug(LL_DEBUG1, "\tLINE: %s", buf);
/* nope, return the previous position */
if ((loc < 0) || (fseeko(adata->fp, loc, SEEK_SET) != 0))
{
- mutt_debug(1, "#1 fseek() failed\n");
+ mutt_debug(LL_DEBUG1, "#1 fseek() failed\n");
}
e_cur->content->length = -1;
}
/* count the number of lines in this message */
if ((loc < 0) || (fseeko(adata->fp, loc, SEEK_SET) != 0))
- mutt_debug(1, "#2 fseek() failed\n");
+ mutt_debug(LL_DEBUG1, "#2 fseek() failed\n");
while (cl-- > 0)
{
if (fgetc(adata->fp) == '\n')
/* return to the offset of the next message separator */
if (fseeko(adata->fp, tmploc, SEEK_SET) != 0)
- mutt_debug(1, "#3 fseek() failed\n");
+ mutt_debug(LL_DEBUG1, "#3 fseek() failed\n");
}
}
*/
char buffer[LONG_STRING];
if (fseeko(adata->fp, m->size, SEEK_SET) != 0)
- mutt_debug(1, "#1 fseek() failed\n");
+ mutt_debug(LL_DEBUG1, "#1 fseek() failed\n");
if (fgets(buffer, sizeof(buffer), adata->fp))
{
if ((m->magic == MUTT_MBOX && mutt_str_startswith(buffer, "From ", CASE_MATCH)) ||
(m->magic == MUTT_MMDF && (mutt_str_strcmp(buffer, MMDF_SEP) == 0)))
{
if (fseeko(adata->fp, m->size, SEEK_SET) != 0)
- mutt_debug(1, "#2 fseek() failed\n");
+ mutt_debug(LL_DEBUG1, "#2 fseek() failed\n");
int old_msg_count = m->msg_count;
if (m->magic == MUTT_MBOX)
}
else
{
- mutt_debug(1, "fgets returned NULL.\n");
+ mutt_debug(LL_DEBUG1, "fgets returned NULL.\n");
modified = true;
}
}
*/
mutt_error(
_("sync: mbox modified, but no modified messages (report this bug)"));
- mutt_debug(1, "no modified messages.\n");
+ mutt_debug(LL_DEBUG1, "no modified messages.\n");
unlink(tempfile);
goto bail;
}
if (fclose(fp) != 0)
{
fp = NULL;
- mutt_debug(1, "mutt_file_fclose (&) returned non-zero.\n");
+ mutt_debug(LL_DEBUG1, "mutt_file_fclose (&) returned non-zero.\n");
unlink(tempfile);
mutt_perror(tempfile);
goto bail;
{
mutt_sig_unblock();
mx_fastclose_mailbox(m);
- mutt_debug(1, "unable to reopen temp copy of mailbox!\n");
+ mutt_debug(LL_DEBUG1, "unable to reopen temp copy of mailbox!\n");
mutt_perror(tempfile);
FREE(&new_offset);
FREE(&old_offset);
(m->magic == MUTT_MBOX && !mutt_str_startswith(buf, "From ", CASE_MATCH)) ||
(m->magic == MUTT_MMDF && (mutt_str_strcmp(MMDF_SEP, buf) != 0)))
{
- mutt_debug(1, "message not in expected position.\n");
- mutt_debug(1, "\tLINE: %s\n", buf);
+ mutt_debug(LL_DEBUG1, "message not in expected position.\n");
+ mutt_debug(LL_DEBUG1, "\tLINE: %s\n", buf);
i = -1;
}
else
if (fseeko(adata->fp, offset, SEEK_SET) != 0) /* return to proper offset */
{
i = -1;
- mutt_debug(1, "fseek() failed\n");
+ mutt_debug(LL_DEBUG1, "fseek() failed\n");
}
else
{
if ((m->size < 0) || (ftruncate(fileno(adata->fp), m->size) != 0))
{
i = -1;
- mutt_debug(1, "ftruncate() failed\n");
+ mutt_debug(LL_DEBUG1, "ftruncate() failed\n");
}
}
}
if (!MenuStackCount || (MenuStack[MenuStackCount - 1] != menu))
{
- mutt_debug(1, "called with inactive menu\n");
+ mutt_debug(LL_DEBUG1, "called with inactive menu\n");
return;
}
INotifyFd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
if (INotifyFd == -1)
{
- mutt_debug(2, "inotify_init1 failed, errno=%d %s\n", errno, strerror(errno));
+ mutt_debug(LL_DEBUG2, "inotify_init1 failed, errno=%d %s\n", errno, strerror(errno));
return -1;
}
mutt_poll_fd_add(0, POLLIN);
new_desc = inotify_add_watch(INotifyFd, iter->mh_backup_path, INOTIFY_MASK_FILE);
if (new_desc == -1)
{
- mutt_debug(2, "inotify_add_watch failed for '%s', errno=%d %s\n",
+ mutt_debug(LL_DEBUG2, "inotify_add_watch failed for '%s', errno=%d %s\n",
iter->mh_backup_path, errno, strerror(errno));
}
else
{
- mutt_debug(3, "inotify_add_watch descriptor=%d for '%s'\n", desc, iter->mh_backup_path);
+ mutt_debug(LL_DEBUG3, "inotify_add_watch descriptor=%d for '%s'\n",
+ desc, iter->mh_backup_path);
iter->st_dev = sb.st_dev;
iter->st_ino = sb.st_ino;
iter->desc = new_desc;
}
else
{
- mutt_debug(3, "cleanup watch (implicitly removed) - descriptor=%d\n", desc);
+ mutt_debug(LL_DEBUG3, "cleanup watch (implicitly removed) - descriptor=%d\n", desc);
}
if (MonitorContextDescriptor == desc)
rc = -1;
if (errno != EINTR)
{
- mutt_debug(2, "poll() failed, errno=%d %s\n", errno, strerror(errno));
+ mutt_debug(LL_DEBUG2, "poll() failed, errno=%d %s\n", errno, strerror(errno));
}
}
else
else if (PollFds[i].fd == INotifyFd)
{
MonitorFilesChanged = 1;
- mutt_debug(3, "file change(s) detected\n");
+ mutt_debug(LL_DEBUG3, "file change(s) detected\n");
char *ptr = buf;
const struct inotify_event *event;
if (len == -1)
{
if (errno != EAGAIN)
- mutt_debug(2, "read inotify events failed, errno=%d %s\n",
+ mutt_debug(LL_DEBUG2, "read inotify events failed, errno=%d %s\n",
errno, strerror(errno));
break;
}
while (ptr < (buf + len))
{
event = (const struct inotify_event *) ptr;
- mutt_debug(3, "+ detail: descriptor=%d mask=0x%x\n", event->wd,
- event->mask);
+ mutt_debug(LL_DEBUG3, "+ detail: descriptor=%d mask=0x%x\n",
+ event->wd, event->mask);
if (event->mask & IN_IGNORED)
monitor_handle_ignore(event->wd);
else if (event->wd == MonitorContextDescriptor)
if (((INotifyFd == -1) && (monitor_init() == -1)) ||
(desc = inotify_add_watch(INotifyFd, info.path, mask)) == -1)
{
- mutt_debug(2, "inotify_add_watch failed for '%s', errno=%d %s\n", info.path,
- errno, strerror(errno));
+ mutt_debug(LL_DEBUG2, "inotify_add_watch failed for '%s', errno=%d %s\n",
+ info.path, errno, strerror(errno));
return -1;
}
- mutt_debug(3, "inotify_add_watch descriptor=%d for '%s'\n", desc, info.path);
+ mutt_debug(LL_DEBUG3, "inotify_add_watch descriptor=%d for '%s'\n", desc, info.path);
if (!m)
MonitorContextDescriptor = desc;
}
inotify_rm_watch(info.monitor->desc, INotifyFd);
- mutt_debug(3, "inotify_rm_watch for '%s' descriptor=%d\n", info.path,
+ mutt_debug(LL_DEBUG3, "inotify_rm_watch for '%s' descriptor=%d\n", info.path,
info.monitor->desc);
monitor_delete(info.monitor);
*/
void mutt_buffer_pool_free(void)
{
- mutt_debug(1, "mutt_buffer_pool_free: %zu of %zu returned to pool\n",
+ mutt_debug(LL_DEBUG1, "mutt_buffer_pool_free: %zu of %zu returned to pool\n",
BufferPoolCount, BufferPoolLen);
while (BufferPoolCount)
if (BufferPoolCount >= BufferPoolLen)
{
- mutt_debug(1, "Internal buffer pool error\n");
+ mutt_debug(LL_DEBUG1, "Internal buffer pool error\n");
mutt_buffer_free(pbuf);
return;
}
sec = 0;
else
{
- mutt_debug(1, "could not process time format: %s\n", t);
+ mutt_debug(LL_DEBUG1, "could not process time format: %s\n", t);
return -1;
}
if ((hour < 0) || (hour > 23) || (min < 0) || (min > 59) || (sec < 0) || (sec > 60))
if (count < 4) /* don't check for missing timezone */
{
- mutt_debug(1, "error parsing date format, using received time\n");
+ mutt_debug(LL_DEBUG1, "error parsing date format, using received time\n");
return -1;
}
snprintf(newdir, ndlen, "%s/%s", parent, ".muttXXXXXX");
if (!mkdtemp(newdir))
{
- mutt_debug(1, "mkdtemp() failed\n");
+ mutt_debug(LL_DEBUG1, "mkdtemp() failed\n");
return -1;
}
if (snprintf(newfile, nflen, "%s/%s", newdir, NONULL(basename)) >= nflen)
{
rmdir(newdir);
- mutt_debug(1, "string was truncated\n");
+ mutt_debug(LL_DEBUG1, "string was truncated\n");
return -1;
}
return 0;
if ((lstat(src, &ssb) == 0) && (lstat(target, &tsb) == 0) &&
(compare_stat(&ssb, &tsb) == 0))
{
- mutt_debug(1, "link (%s, %s) reported failure: %s (%d) but actually succeeded\n",
+ mutt_debug(LL_DEBUG1, "link (%s, %s) reported failure: %s (%d) but actually succeeded\n",
src, target, strerror(errno), errno);
goto success;
}
* With other file systems, rename should just fail when
* the files reside on different file systems, so it's safe
* to try it here. */
- mutt_debug(1, "link (%s, %s) failed: %s (%d)\n", src, target, strerror(errno), errno);
+ mutt_debug(LL_DEBUG1, "link (%s, %s) failed: %s (%d)\n", src, target,
+ strerror(errno), errno);
/* FUSE may return ENOSYS. VFAT may return EPERM. FreeBSD's
* msdosfs may return EOPNOTSUPP. ENOTSUP can also appear. */
#endif
)
{
- mutt_debug(1, "trying rename...\n");
+ mutt_debug(LL_DEBUG1, "trying rename...\n");
if (rename(src, target) == -1)
{
- mutt_debug(1, "rename (%s, %s) failed: %s (%d)\n", src, target,
+ mutt_debug(LL_DEBUG1, "rename (%s, %s) failed: %s (%d)\n", src, target,
strerror(errno), errno);
return -1;
}
- mutt_debug(1, "rename succeeded.\n");
+ mutt_debug(LL_DEBUG1, "rename succeeded.\n");
return 0;
}
/* Stat both links and check if they are equal. */
if (lstat(src, &ssb) == -1)
{
- mutt_debug(1, "#1 can't stat %s: %s (%d)\n", src, strerror(errno), errno);
+ mutt_debug(LL_DEBUG1, "#1 can't stat %s: %s (%d)\n", src, strerror(errno), errno);
return -1;
}
if (lstat(target, &tsb) == -1)
{
- mutt_debug(1, "#2 can't stat %s: %s (%d)\n", src, strerror(errno), errno);
+ mutt_debug(LL_DEBUG1, "#2 can't stat %s: %s (%d)\n", src, strerror(errno), errno);
return -1;
}
if (!compare_stat(&ssb, &tsb))
{
- mutt_debug(1, "stat blocks for %s and %s diverge; pretending EEXIST.\n", src, target);
+ mutt_debug(LL_DEBUG1, "stat blocks for %s and %s diverge; pretending EEXIST.\n", src, target);
errno = EEXIST;
return -1;
}
* Should we really ignore the return value here? XXX */
if (unlink(src) == -1)
{
- mutt_debug(1, "unlink (%s) failed: %s (%d)\n", src, strerror(errno), errno);
+ mutt_debug(LL_DEBUG1, "unlink (%s) failed: %s (%d)\n", src, strerror(errno), errno);
}
return 0;
DIR *dirp = opendir(path);
if (!dirp)
{
- mutt_debug(1, "error opening directory %s\n", path);
+ mutt_debug(LL_DEBUG1, "error opening directory %s\n", path);
return -1;
}
while ((de = readdir(dirp)))
while (fcntl(fd, F_SETLK, &lck) == -1)
{
- mutt_debug(1, "fcntl errno %d.\n", errno);
+ mutt_debug(LL_DEBUG1, "fcntl errno %d.\n", errno);
if ((errno != EAGAIN) && (errno != EACCES))
{
mutt_perror("fcntl");
p = mutt_hash_find(Groups, k);
if (!p)
{
- mutt_debug(2, "Creating group %s.\n", k);
+ mutt_debug(LL_DEBUG2, "Creating group %s.\n", k);
p = mutt_mem_calloc(1, sizeof(struct Group));
p->name = mutt_str_strdup(k);
STAILQ_INIT(&p->rs);
char *dd = buf;
- mutt_debug(3, "Collapse path: %s\n", buf);
+ mutt_debug(LL_DEBUG3, "Collapse path: %s\n", buf);
while ((dd = strstr(dd, "/..")))
{
if (dd[3] == '/') /* paths follow dots */
dd = buf; /* restart at the beginning */
}
- mutt_debug(3, "Collapsed to: %s\n", buf);
+ mutt_debug(LL_DEBUG3, "Collapsed to: %s\n", buf);
return true;
}
{
if (!homedir)
{
- mutt_debug(3, "no homedir\n");
+ mutt_debug(LL_DEBUG3, "no homedir\n");
return false;
}
struct passwd *pw = getpwnam(user);
if (!pw || !pw->pw_dir)
{
- mutt_debug(1, "no such user: %s\n", user);
+ mutt_debug(LL_DEBUG1, "no such user: %s\n", user);
return false;
}
size_t dirlen = mutt_str_strlen(dir);
if ((len + dirlen) >= buflen)
{
- mutt_debug(3, "result too big for the buffer %d >= %d\n", len + dirlen, buflen);
+ mutt_debug(LL_DEBUG3, "result too big for the buffer %d >= %d\n", len + dirlen, buflen);
return false;
}
{
if (!getcwd(result, sizeof(result)))
{
- mutt_debug(1, "getcwd failed: %s (%d)\n", strerror(errno), errno);
+ mutt_debug(LL_DEBUG1, "getcwd failed: %s (%d)\n", strerror(errno), errno);
return false;
}
size_t dirlen = mutt_str_strlen(buf);
if ((cwdlen + dirlen + 1) >= buflen)
{
- mutt_debug(3, "result too big for the buffer %d >= %d\n", cwdlen + dirlen + 1, buflen);
+ mutt_debug(LL_DEBUG3, "result too big for the buffer %d >= %d\n",
+ cwdlen + dirlen + 1, buflen);
return false;
}
if (!begin)
{
- mutt_debug(1, "%s: ERROR: 'begin' is NULL\n", __func__);
+ mutt_debug(LL_DEBUG1, "%s: ERROR: 'begin' is NULL\n", __func__);
return NULL;
}
}
else
{
- mutt_debug(1, "Couldn't get user info\n");
+ mutt_debug(LL_DEBUG1, "Couldn't get user info\n");
return -1;
}
}
mutt_str_strfcpy(command, entry->composecommand, sizeof(command));
if (rfc1524_expand_filename(entry->nametemplate, a->filename, newfile, sizeof(newfile)))
{
- mutt_debug(1, "oldfile: %s\t newfile: %s\n", a->filename, newfile);
+ mutt_debug(LL_DEBUG1, "oldfile: %s\t newfile: %s\n", a->filename, newfile);
if (mutt_file_symlink(a->filename, newfile) == -1)
{
if (mutt_yesorno(_("Can't match nametemplate, continue?"), MUTT_YES) != MUTT_YES)
mutt_str_strfcpy(command, entry->editcommand, sizeof(command));
if (rfc1524_expand_filename(entry->nametemplate, a->filename, newfile, sizeof(newfile)))
{
- mutt_debug(1, "oldfile: %s\t newfile: %s\n", a->filename, newfile);
+ mutt_debug(LL_DEBUG1, "oldfile: %s\t newfile: %s\n", a->filename, newfile);
if (mutt_file_symlink(a->filename, newfile) == -1)
{
if (mutt_yesorno(_("Can't match nametemplate, continue?"), MUTT_YES) != MUTT_YES)
"multipart" :
n == TYPE_TEXT ? "text" : n == TYPE_VIDEO ? "video" : "other",
tmp.subtype);
- mutt_debug(1, "\"%s\" -> %s\n", b->filename, type);
+ mutt_debug(LL_DEBUG1, "\"%s\" -> %s\n", b->filename, type);
}
if (tmp.subtype)
FREE(&tmp.subtype);
/* interactive command */
int rv = mutt_system(command);
if (rv == -1)
- mutt_debug(1, "Error running \"%s\"!", command);
+ mutt_debug(LL_DEBUG1, "Error running \"%s\"!", command);
if ((rv != 0) || (entry->needsterminal && WaitKey))
mutt_any_key_to_continue(NULL);
decode_state.fpout = mutt_file_fopen(pagerfile, "w");
if (!decode_state.fpout)
{
- mutt_debug(1, "mutt_file_fopen(%s) errno=%d %s\n", pagerfile, errno,
- strerror(errno));
+ mutt_debug(LL_DEBUG1, "mutt_file_fopen(%s) errno=%d %s\n", pagerfile,
+ errno, strerror(errno));
mutt_perror(pagerfile);
goto return_error;
}
decode_state.flags = MUTT_CHARCONV;
mutt_decode_attachment(a, &decode_state);
if (fclose(decode_state.fpout) == EOF)
- mutt_debug(1, "fclose(%s) errno=%d %s\n", pagerfile, errno, strerror(errno));
+ mutt_debug(LL_DEBUG1, "fclose(%s) errno=%d %s\n", pagerfile, errno,
+ strerror(errno));
}
else
{
char command[HUGE_STRING];
int piped = false;
- mutt_debug(2, "Using mailcap...\n");
+ mutt_debug(LL_DEBUG2, "Using mailcap...\n");
struct Rfc1524MailcapEntry *entry = rfc1524_new_entry();
rfc1524_mailcap_lookup(a, type, entry, MUTT_PRINT);
{
int rc = mutt_system(command);
if (rc == -1)
- mutt_debug(1, "Error running \"%s\"!", command);
+ mutt_debug(LL_DEBUG1, "Error running \"%s\"!", command);
if ((rc != 0) || WaitKey)
mutt_any_key_to_continue(NULL);
mutt_mktemp(newfile, sizeof(newfile));
if (mutt_decode_save_attachment(fp, a, newfile, MUTT_PRINTING, 0) == 0)
{
- mutt_debug(2, "successfully decoded %s type attachment to %s\n", type, newfile);
+ mutt_debug(LL_DEBUG2, "successfully decoded %s type attachment to %s\n", type, newfile);
ifp = fopen(newfile, "r");
if (!ifp)
goto bail0;
}
- mutt_debug(2, "successfully opened %s read-only\n", newfile);
+ mutt_debug(LL_DEBUG2, "successfully opened %s read-only\n", newfile);
mutt_endwin();
thepid = mutt_create_filter(NONULL(PrintCommand), &fpout, NULL, NULL);
goto bail0;
}
- mutt_debug(2, "Filter created.\n");
+ mutt_debug(LL_DEBUG2, "Filter created.\n");
mutt_file_copy_stream(ifp, fpout);
stat(path, &st);
if (mtime == st.st_mtime)
{
- mutt_debug(1, "temp file was not modified.\n");
+ mutt_debug(LL_DEBUG1, "temp file was not modified.\n");
/* the file has not changed! */
mutt_file_unlink(path);
return;
if (gettimeofday(&now, NULL) < 0)
{
- mutt_debug(1, "gettimeofday failed: %d\n", errno);
+ mutt_debug(LL_DEBUG1, "gettimeofday failed: %d\n", errno);
return;
}
{
OptMsgErr = true;
if (gettimeofday(&LastError, NULL) < 0)
- mutt_debug(1, "gettimeofday failed: %d\n", errno);
+ mutt_debug(LL_DEBUG1, "gettimeofday failed: %d\n", errno);
}
else
{
*/
static int handle_panic(lua_State *l)
{
- mutt_debug(1, "lua runtime panic: %s\n", lua_tostring(l, -1));
+ mutt_debug(LL_DEBUG1, "lua runtime panic: %s\n", lua_tostring(l, -1));
mutt_error("Lua runtime panic: %s\n", lua_tostring(l, -1));
lua_pop(l, 1);
return -1;
*/
static int handle_error(lua_State *l)
{
- mutt_debug(1, "lua runtime error: %s\n", lua_tostring(l, -1));
+ mutt_debug(LL_DEBUG1, "lua runtime error: %s\n", lua_tostring(l, -1));
mutt_error("Lua runtime error: %s\n", lua_tostring(l, -1));
lua_pop(l, 1);
return -1;
*/
static int lua_mutt_call(lua_State *l)
{
- mutt_debug(2, " * lua_mutt_call()\n");
+ mutt_debug(LL_DEBUG2, " * lua_mutt_call()\n");
struct Buffer token, expn, err;
char buffer[LONG_STRING] = "";
const struct Command *command = NULL;
static int lua_mutt_set(lua_State *l)
{
const char *param = lua_tostring(l, -2);
- mutt_debug(2, " * lua_mutt_set(%s)\n", param);
+ mutt_debug(LL_DEBUG2, " * lua_mutt_set(%s)\n", param);
if (mutt_str_startswith(param, "my_", CASE_MATCH))
{
static int lua_mutt_get(lua_State *l)
{
const char *param = lua_tostring(l, -1);
- mutt_debug(2, " * lua_mutt_get(%s)\n", param);
+ mutt_debug(LL_DEBUG2, " * lua_mutt_get(%s)\n", param);
if (mutt_str_startswith(param, "my_", CASE_MATCH))
{
struct HashElem *he = cs_get_elem(Config, param);
if (!he)
{
- mutt_debug(2, " * error\n");
+ mutt_debug(LL_DEBUG2, " * error\n");
luaL_error(l, "NeoMutt parameter not found %s", param);
return -1;
}
*/
static int lua_mutt_enter(lua_State *l)
{
- mutt_debug(2, " * lua_mutt_enter()\n");
+ mutt_debug(LL_DEBUG2, " * lua_mutt_enter()\n");
struct Buffer token, err;
char *buffer = mutt_str_strdup(lua_tostring(l, -1));
int rc = 0;
*/
static int lua_mutt_message(lua_State *l)
{
- mutt_debug(2, " * lua_mutt_message()\n");
+ mutt_debug(LL_DEBUG2, " * lua_mutt_message()\n");
const char *msg = lua_tostring(l, -1);
if (msg)
mutt_message(msg);
*/
static int lua_mutt_error(lua_State *l)
{
- mutt_debug(2, " * lua_mutt_error()\n");
+ mutt_debug(LL_DEBUG2, " * lua_mutt_error()\n");
const char *msg = lua_tostring(l, -1);
if (msg)
mutt_error(msg);
*/
static int luaopen_mutt_decl(lua_State *l)
{
- mutt_debug(2, " * luaopen_mutt()\n");
+ mutt_debug(LL_DEBUG2, " * luaopen_mutt()\n");
luaL_newlib(l, luaMuttDecl);
int lib_idx = lua_gettop(l);
/* table_idx, key value, value's type */
if (*l)
return true;
- mutt_debug(2, " * lua_init()\n");
+ mutt_debug(LL_DEBUG2, " * lua_init()\n");
*l = luaL_newstate();
if (!*l)
unsigned long data, struct Buffer *err)
{
lua_init(&Lua);
- mutt_debug(2, " * mutt_lua_parse(%s)\n", buf->data);
+ mutt_debug(LL_DEBUG2, " * mutt_lua_parse(%s)\n", buf->data);
if (luaL_dostring(Lua, s->dptr))
{
- mutt_debug(2, " * %s -> failure\n", s->dptr);
+ mutt_debug(LL_DEBUG2, " * %s -> failure\n", s->dptr);
mutt_buffer_printf(err, "%s: %s", s->dptr, lua_tostring(Lua, -1));
/* pop error message from the stack */
lua_pop(Lua, 1);
return MUTT_CMD_ERROR;
}
- mutt_debug(2, " * %s -> success\n", s->dptr);
+ mutt_debug(LL_DEBUG2, " * %s -> success\n", s->dptr);
return MUTT_CMD_SUCCESS;
}
enum CommandResult mutt_lua_source_file(struct Buffer *buf, struct Buffer *s,
unsigned long data, struct Buffer *err)
{
- mutt_debug(2, " * mutt_lua_source()\n");
+ mutt_debug(LL_DEBUG2, " * mutt_lua_source()\n");
lua_init(&Lua);
STAILQ_FOREACH(np, checklist, entries)
{
a = (struct AttachMatch *) np->data;
- mutt_debug(3, "%s %d/%s ?? %s/%s [%d]... ", dflt ? "[OK] " : "[EXCL] ", b->type,
- b->subtype ? b->subtype : "*", a->major, a->minor, a->major_int);
+ mutt_debug(LL_DEBUG3, "%s %d/%s ?? %s/%s [%d]... ", dflt ? "[OK] " : "[EXCL] ",
+ b->type, b->subtype ? b->subtype : "*", a->major, a->minor, a->major_int);
if ((a->major_int == TYPE_ANY || a->major_int == b->type) &&
(!b->subtype || !regexec(&a->minor_regex, b->subtype, 0, NULL, 0)))
{
- mutt_debug(3, "yes\n");
+ mutt_debug(LL_DEBUG3, "yes\n");
return true;
}
else
{
- mutt_debug(3, "no\n");
+ mutt_debug(LL_DEBUG3, "no\n");
}
}
count++;
bp->attach_qualifies = shallcount ? true : false;
- mutt_debug(3, "%p shallcount = %d\n", (void *) bp, shallcount);
+ mutt_debug(LL_DEBUG3, "%p shallcount = %d\n", (void *) bp, shallcount);
if (shallrecurse)
{
- mutt_debug(3, "%p pre count = %d\n", (void *) bp, count);
+ mutt_debug(LL_DEBUG3, "%p pre count = %d\n", (void *) bp, count);
bp->attach_count = count_body_parts(bp->parts, flags & ~MUTT_PARTS_TOPLEVEL);
count += bp->attach_count;
- mutt_debug(3, "%p post count = %d\n", (void *) bp, count);
+ mutt_debug(LL_DEBUG3, "%p post count = %d\n", (void *) bp, count);
}
}
- mutt_debug(3, "return %d\n", count < 0 ? 0 : count);
+ mutt_debug(LL_DEBUG3, "return %d\n", count < 0 ? 0 : count);
return (count < 0) ? 0 : count;
}
if (OptNoCurses)
return;
- mutt_debug(2, "entering\n");
+ mutt_debug(LL_DEBUG2, "entering\n");
MuttStatusWindow->rows = 1;
MuttStatusWindow->cols = COLS;
mutt_buffer_printf(buf, "%s/%s-%s-%d-%d-%ld%ld%s%s", NONULL(Tmpdir), NONULL(prefix),
NONULL(Hostname), (int) getuid(), (int) getpid(), random(),
random(), suffix ? "." : "", NONULL(suffix));
- mutt_debug(3, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, mutt_b2s(buf));
+ mutt_debug(LL_DEBUG3, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, mutt_b2s(buf));
if (unlink(mutt_b2s(buf)) && errno != ENOENT)
{
- mutt_debug(1, "%s:%d: ERROR: unlink(\"%s\"): %s (errno %d)\n", src, line,
- mutt_b2s(buf), strerror(errno), errno);
+ mutt_debug(LL_DEBUG1, "%s:%d: ERROR: unlink(\"%s\"): %s (errno %d)\n", src,
+ line, mutt_b2s(buf), strerror(errno), errno);
}
}
(int) getpid(), mutt_rand64(), suffix ? "." : "", NONULL(suffix));
if (n >= buflen)
{
- mutt_debug(1,
+ mutt_debug(LL_DEBUG1,
"%s:%d: ERROR: insufficient buffer space to hold temporary "
"filename! buflen=%zu but need %zu\n",
src, line, buflen, n);
}
- mutt_debug(3, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, buf);
+ mutt_debug(LL_DEBUG3, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, buf);
if (unlink(buf) && errno != ENOENT)
{
- mutt_debug(1, "%s:%d: ERROR: unlink(\"%s\"): %s (errno %d)\n", src, line,
- buf, strerror(errno), errno);
+ mutt_debug(LL_DEBUG1, "%s:%d: ERROR: unlink(\"%s\"): %s (errno %d)\n", src,
+ line, buf, strerror(errno), errno);
}
}
char srccopy[LONG_STRING];
int i = 0;
- mutt_debug(3, "fmtpipe = %s\n", src);
+ mutt_debug(LL_DEBUG3, "fmtpipe = %s\n", src);
strncpy(srccopy, src, n);
srccopy[n - 1] = '\0';
do
{
/* Extract the command name and copy to command line */
- mutt_debug(3, "fmtpipe +++: %s\n", srcbuf->dptr);
+ mutt_debug(LL_DEBUG3, "fmtpipe +++: %s\n", srcbuf->dptr);
if (word->data)
*word->data = '\0';
mutt_extract_token(word, srcbuf, 0);
- mutt_debug(3, "fmtpipe %2d: %s\n", i++, word->data);
+ mutt_debug(LL_DEBUG3, "fmtpipe %2d: %s\n", i++, word->data);
mutt_buffer_addch(command, '\'');
mutt_expando_format(tmp, sizeof(tmp), 0, cols, word->data, callback,
data, flags | MUTT_FORMAT_NOFILTER);
mutt_buffer_addch(command, ' ');
} while (MoreArgs(srcbuf));
- mutt_debug(3, "fmtpipe > %s\n", command->data);
+ mutt_debug(LL_DEBUG3, "fmtpipe > %s\n", command->data);
col -= wlen; /* reset to passed in value */
wptr = buf; /* reset write ptr */
mutt_file_fclose(&filter);
rc = mutt_wait_filter(pid);
if (rc != 0)
- mutt_debug(1, "format pipe command exited code %d\n", rc);
+ mutt_debug(LL_DEBUG1, "format pipe command exited code %d\n", rc);
if (n > 0)
{
buf[n] = 0;
else
{
/* read error */
- mutt_debug(1, "error reading from fmtpipe: %s (errno=%d)\n",
+ mutt_debug(LL_DEBUG1, "error reading from fmtpipe: %s (errno=%d)\n",
strerror(errno), errno);
*wptr = 0;
}
if (!m->mx_ops || !m->mx_ops->msg_open_new)
{
- mutt_debug(1, "function unimplemented for mailbox type %d.\n", m->magic);
+ mutt_debug(LL_DEBUG1, "function unimplemented for mailbox type %d.\n", m->magic);
return NULL;
}
if (!m->mx_ops || !m->mx_ops->msg_open)
{
- mutt_debug(1, "function not implemented for mailbox type %d.\n", m->magic);
+ mutt_debug(LL_DEBUG1, "function not implemented for mailbox type %d.\n", m->magic);
return NULL;
}
if (!(msg->write && m->append))
{
- mutt_debug(1, "msg->write = %d, m->append = %d\n", msg->write, m->append);
+ mutt_debug(LL_DEBUG1, "msg->write = %d, m->append = %d\n", msg->write, m->append);
return -1;
}
if ((*msg)->path)
{
- mutt_debug(1, "unlinking %s\n", (*msg)->path);
+ mutt_debug(LL_DEBUG1, "unlinking %s\n", (*msg)->path);
unlink((*msg)->path);
FREE(&(*msg)->path);
}
if (stat(path, st) != 0)
{
- mutt_debug(1, "unable to stat %s: %s (errno %d).\n", path, strerror(errno), errno);
+ mutt_debug(LL_DEBUG1, "unable to stat %s: %s (errno %d).\n", path,
+ strerror(errno), errno);
return MUTT_UNKNOWN;
}
engineinfo = engineinfo->next;
if (!engineinfo)
{
- mutt_debug(1, "Error finding GPGME PGP engine\n");
+ mutt_debug(LL_DEBUG1, "Error finding GPGME PGP engine\n");
engine_version = mutt_str_strdup("0.0.0");
}
else
gpgme_release(ctx);
state_attach_puts(_("[-- End signature information --]\n\n"), s);
- mutt_debug(1, "returning %d.\n", badsig);
+ mutt_debug(LL_DEBUG1, "returning %d.\n", badsig);
return badsig ? 1 : anywarn ? 2 : 0;
}
snprintf(tmpdir, sizeof(tmpdir), "%s/neomutt-gpgme-XXXXXX", Tmpdir);
if (!mkdtemp(tmpdir))
{
- mutt_debug(1, "Error creating temporary GPGME home\n");
+ mutt_debug(LL_DEBUG1, "Error creating temporary GPGME home\n");
goto err_ctx;
}
engineinfo = engineinfo->next;
if (!engineinfo)
{
- mutt_debug(1, "Error finding GPGME PGP engine\n");
+ mutt_debug(LL_DEBUG1, "Error finding GPGME PGP engine\n");
goto err_tmpdir;
}
engineinfo->file_name, tmpdir);
if (err != GPG_ERR_NO_ERROR)
{
- mutt_debug(1, "Error setting GPGME context home\n");
+ mutt_debug(LL_DEBUG1, "Error setting GPGME context home\n");
goto err_tmpdir;
}
}
}
if (gpg_err_code(err) != GPG_ERR_EOF)
{
- mutt_debug(1, "Error listing keys\n");
+ mutt_debug(LL_DEBUG1, "Error listing keys\n");
goto err_fp;
}
char body_charset[STRING]; /* Only used for clearsigned messages. */
- mutt_debug(2, "Entering handler\n");
+ mutt_debug(LL_DEBUG2, "Entering 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
s);
return 1;
}
- mutt_debug(2, "Leaving handler\n");
+ mutt_debug(LL_DEBUG2, "Leaving handler\n");
return err;
}
int is_signed;
int rc = 0;
- mutt_debug(2, "Entering handler\n");
+ mutt_debug(LL_DEBUG2, "Entering handler\n");
FILE *fpout = mutt_file_mkstemp();
if (!fpout)
}
mutt_file_fclose(&fpout);
- mutt_debug(2, "Leaving handler\n");
+ mutt_debug(LL_DEBUG2, "Leaving handler\n");
return rc;
}
int is_signed = 0;
int rc = 0;
- mutt_debug(2, "Entering handler\n");
+ mutt_debug(LL_DEBUG2, "Entering handler\n");
/* clear out any mime headers before the handler, so they can't be spoofed. */
mutt_env_free(&a->mime_headers);
}
mutt_file_fclose(&fpout);
- mutt_debug(2, "Leaving handler\n");
+ mutt_debug(LL_DEBUG2, "Leaving handler\n");
return rc;
}
if (abilities && !(k->flags & abilities))
{
- mutt_debug(2, " insufficient abilities: Has %x, want %x\n", k->flags, abilities);
+ mutt_debug(LL_DEBUG2, " insufficient abilities: Has %x, want %x\n", k->flags, abilities);
continue;
}
*/
void pgp_gpgme_set_sender(const char *sender)
{
- mutt_debug(2, "setting to: %s\n", sender);
+ mutt_debug(LL_DEBUG2, "setting to: %s\n", sender);
FREE(¤t_sender);
current_sender = mutt_str_strdup(sender);
}
else
memset(&tmp, 0, sizeof(tmp));
- mutt_debug(2, "buf = '%s'\n", buf);
+ mutt_debug(LL_DEBUG2, "buf = '%s'\n", buf);
for (p = buf; p; p = pend)
{
{
case 1: /* record type */
{
- mutt_debug(2, "record type: %s\n", p);
+ mutt_debug(LL_DEBUG2, "record type: %s\n", p);
if (mutt_str_strcmp(p, "pub") == 0)
is_pub = true;
}
case 2: /* trust info */
{
- mutt_debug(2, "trust info: %s\n", p);
+ mutt_debug(LL_DEBUG2, "trust info: %s\n", p);
switch (*p)
{ /* look only at the first letter */
}
case 3: /* key length */
{
- mutt_debug(2, "key len: %s\n", p);
+ mutt_debug(LL_DEBUG2, "key len: %s\n", p);
if (!(*is_subkey && PgpIgnoreSubkeys) && mutt_str_atos(p, &tmp.keylen) < 0)
{
}
case 4: /* pubkey algo */
{
- mutt_debug(2, "pubkey algorithm: %s\n", p);
+ mutt_debug(LL_DEBUG2, "pubkey algorithm: %s\n", p);
if (!(*is_subkey && PgpIgnoreSubkeys))
{
}
case 5: /* 16 hex digits with the long keyid. */
{
- mutt_debug(2, "key id: %s\n", p);
+ mutt_debug(LL_DEBUG2, "key id: %s\n", p);
if (!(*is_subkey && PgpIgnoreSubkeys))
mutt_str_replace(&tmp.keyid, p);
}
case 6: /* timestamp (1998-02-28) */
{
- mutt_debug(2, "time stamp: %s\n", p);
+ mutt_debug(LL_DEBUG2, "time stamp: %s\n", p);
if (strchr(p, '-')) /* gpg pre-2.0.10 used format (yyyy-mm-dd) */
{
if (!is_uid && (*is_subkey && PgpIgnoreSubkeys))
break;
- mutt_debug(2, "user ID: %s\n", NONULL(p));
+ mutt_debug(LL_DEBUG2, "user ID: %s\n", NONULL(p));
uid = mutt_mem_calloc(1, sizeof(struct PgpUid));
fix_uid(p);
case 11: /* signature class */
break;
case 12: /* key capabilities */
- mutt_debug(2, "capabilities info: %s\n", p);
+ mutt_debug(LL_DEBUG2, "capabilities info: %s\n", p);
while (*p)
{
return k;
bail:
- mutt_debug(1, "invalid number: '%s'\n", p);
+ mutt_debug(LL_DEBUG1, "invalid number: '%s'\n", p);
return NULL;
}
{
if (regexec(PgpGoodSign->regex, line, 0, NULL, 0) == 0)
{
- mutt_debug(2, "\"%s\" matches regex.\n", line);
+ mutt_debug(LL_DEBUG2, "\"%s\" matches regex.\n", line);
rc = 0;
}
else
- mutt_debug(2, "\"%s\" doesn't match regex.\n", line);
+ mutt_debug(LL_DEBUG2, "\"%s\" doesn't match regex.\n", line);
if (strncmp(line, "[GNUPG:] ", 9) == 0)
continue;
}
else
{
- mutt_debug(2, "No pattern.\n");
+ mutt_debug(LL_DEBUG2, "No pattern.\n");
mutt_file_copy_stream(fpin, fpout);
rc = 1;
}
{
if (regexec(PgpDecryptionOkay->regex, line, 0, NULL, 0) == 0)
{
- mutt_debug(2, "\"%s\" matches regex.\n", line);
+ mutt_debug(LL_DEBUG2, "\"%s\" matches regex.\n", line);
rc = 0;
break;
}
else
- mutt_debug(2, "\"%s\" doesn't match regex.\n", line);
+ mutt_debug(LL_DEBUG2, "\"%s\" doesn't match regex.\n", line);
}
FREE(&line);
}
else
{
- mutt_debug(2, "No pattern.\n");
+ mutt_debug(LL_DEBUG2, "No pattern.\n");
rc = 1;
}
if (plen == 0)
continue;
s = line + plen;
- mutt_debug(2, "checking \"%s\".\n", line);
+ mutt_debug(LL_DEBUG2, "checking \"%s\".\n", line);
if (mutt_str_startswith(s, "BEGIN_DECRYPTION", CASE_MATCH))
inside_decrypt = 1;
else if (mutt_str_startswith(s, "END_DECRYPTION", CASE_MATCH))
{
if (!inside_decrypt)
{
- mutt_debug(2, "\tPLAINTEXT encountered outside of DECRYPTION.\n");
+ mutt_debug(LL_DEBUG2,
+ "\tPLAINTEXT encountered outside of DECRYPTION.\n");
rv = -2;
break;
}
}
else if (mutt_str_startswith(s, "DECRYPTION_FAILED", CASE_MATCH))
{
- mutt_debug(2, "\tDECRYPTION_FAILED encountered. Failure.\n");
+ mutt_debug(LL_DEBUG2, "\tDECRYPTION_FAILED encountered. Failure.\n");
rv = -3;
break;
}
{
/* Don't break out because we still have to check for
* PLAINTEXT outside of the decryption boundaries. */
- mutt_debug(2, "\tDECRYPTION_OKAY encountered.\n");
+ mutt_debug(LL_DEBUG2, "\tDECRYPTION_OKAY encountered.\n");
rv = 0;
}
}
int ch;
char *expected_charset = gpgcharset && *gpgcharset ? gpgcharset : "utf-8";
- mutt_debug(3, "pgp: recoding inline from [%s] to [%s]\n", expected_charset, Charset);
+ mutt_debug(LL_DEBUG3, "pgp: recoding inline from [%s] to [%s]\n",
+ expected_charset, Charset);
rewind(pgpout);
state_set_prefix(s);
if (rv)
badsig = -1;
- mutt_debug(1, "mutt_wait_filter returned %d.\n", rv);
+ mutt_debug(LL_DEBUG1, "mutt_wait_filter returned %d.\n", rv);
}
mutt_file_fclose(&pgperr);
mutt_file_unlink(sigfile);
- mutt_debug(1, "returning %d.\n", badsig);
+ mutt_debug(LL_DEBUG1, "returning %d.\n", badsig);
return badsig;
}
{
mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, NONULL(fmt),
fmt_pgp_command, (unsigned long) cctx, 0);
- mutt_debug(2, "%s\n", buf);
+ mutt_debug(LL_DEBUG2, "%s\n", buf);
}
/**
mutt_pgp_command(cmd, sizeof(cmd), &cctx, PgpImportCommand);
if (mutt_system(cmd) != 0)
- mutt_debug(1, "Error running \"%s\"!", cmd);
+ mutt_debug(LL_DEBUG1, "Error running \"%s\"!", cmd);
}
/**
mutt_message(_("Fetching PGP key..."));
if (mutt_system(cmd) != 0)
- mutt_debug(1, "Error running \"%s\"!", cmd);
+ mutt_debug(LL_DEBUG1, "Error running \"%s\"!", cmd);
if (!isendwin())
mutt_clear_error();
if (abilities && !(k->flags & abilities))
{
- mutt_debug(3, " insufficient abilities: Has %x, want %x\n", k->flags, abilities);
+ mutt_debug(LL_DEBUG3, " insufficient abilities: Has %x, want %x\n", k->flags, abilities);
continue;
}
}
if (!r)
{
- mutt_debug(1, "Can't find begin of ASCII armor.\n");
+ mutt_debug(LL_DEBUG1, "Can't find begin of ASCII armor.\n");
return;
}
}
if (!r)
{
- mutt_debug(1, "Armor header doesn't end.\n");
+ mutt_debug(LL_DEBUG1, "Armor header doesn't end.\n");
return;
}
}
if (!r)
{
- mutt_debug(1, "Can't find end of ASCII armor.\n");
+ mutt_debug(LL_DEBUG1, "Can't find end of ASCII armor.\n");
return;
}
end = ftello(in) - strlen(line);
if (end < start)
{
- mutt_debug(1, "end < start???\n");
+ mutt_debug(LL_DEBUG1, "end < start???\n");
return;
}
if (fseeko(in, start, SEEK_SET) == -1)
{
- mutt_debug(1, "Can't seekto start.\n");
+ mutt_debug(LL_DEBUG1, "Can't seekto start.\n");
return;
}
/* is signature? */
if ((p[0] & 0x3f) != PT_SIG)
{
- mutt_debug(1, "tag = %d, want %d.\n", p[0] & 0x3f, PT_SIG);
+ mutt_debug(LL_DEBUG1, "tag = %d, want %d.\n", p[0] & 0x3f, PT_SIG);
return -1;
}
}
else
{
- mutt_debug(1, "Bad signature packet.\n");
+ mutt_debug(LL_DEBUG1, "Bad signature packet.\n");
return -1;
}
}
}
else
{
- mutt_debug(1, "No packet.\n");
+ mutt_debug(LL_DEBUG1, "No packet.\n");
}
bye:
{
mutt_expando_format(buf, buflen, 0, MuttIndexWindow->cols, NONULL(fmt),
fmt_smime_command, (unsigned long) cctx, 0);
- mutt_debug(2, "%s\n", buf);
+ mutt_debug(LL_DEBUG2, "%s\n", buf);
}
/**
if (!adata->newsrc_fp)
return;
- mutt_debug(1, "Unlocking %s\n", adata->newsrc_file);
+ mutt_debug(LL_DEBUG1, "Unlocking %s\n", adata->newsrc_file);
mutt_file_unlock(fileno(adata->newsrc_fp));
mutt_file_fclose(&adata->newsrc_fp);
}
}
/* lock it */
- mutt_debug(1, "Locking %s\n", adata->newsrc_file);
+ mutt_debug(LL_DEBUG1, "Locking %s\n", adata->newsrc_file);
if (mutt_file_lock(fileno(adata->newsrc_fp), false, true))
{
mutt_file_fclose(&adata->newsrc_fp);
adata->size = sb.st_size;
adata->mtime = sb.st_mtime;
adata->newsrc_modified = true;
- mutt_debug(1, "Parsing %s\n", adata->newsrc_file);
+ mutt_debug(LL_DEBUG1, "Parsing %s\n", adata->newsrc_file);
/* .newsrc has been externally modified or hasn't been loaded yet */
for (unsigned int i = 0; i < adata->groups_num; i++)
mdata->newsrc_len = j;
mutt_mem_realloc(&mdata->newsrc_ent, j * sizeof(struct NewsrcEntry));
nntp_group_unread_stat(mdata);
- mutt_debug(2, "%s\n", mdata->group);
+ mutt_debug(LL_DEBUG2, "%s\n", mdata->group);
}
FREE(&line);
return 1;
buf[off] = '\0';
/* newrc being fully rewritten */
- mutt_debug(1, "Updating %s\n", adata->newsrc_file);
+ mutt_debug(LL_DEBUG1, "Updating %s\n", adata->newsrc_file);
if (adata->newsrc_file && update_file(adata->newsrc_file, buf) == 0)
{
struct stat sb;
if (sscanf(line, "%1023s " ANUM " " ANUM " %c %8191[^\n]", group, &last,
&first, &mod, desc) < 4)
{
- mutt_debug(2, "Cannot parse server line: %s\n", line);
+ mutt_debug(LL_DEBUG2, "Cannot parse server line: %s\n", line);
return 0;
}
time_t t;
cache_expand(file, sizeof(file), &adata->conn->account, ".active");
- mutt_debug(1, "Parsing %s\n", file);
+ mutt_debug(LL_DEBUG1, "Parsing %s\n", file);
FILE *fp = mutt_file_fopen(file, "r");
if (!fp)
return -1;
}
cache_expand(file, sizeof(file), &adata->conn->account, ".active");
- mutt_debug(1, "Updating %s\n", file);
+ mutt_debug(LL_DEBUG1, "Updating %s\n", file);
rc = update_file(file, buf);
FREE(&buf);
return rc;
hdata = mutt_hcache_fetch_raw(hc, "index", 5);
if (hdata)
{
- mutt_debug(2, "mutt_hcache_fetch index: %s\n", (char *) hdata);
+ mutt_debug(LL_DEBUG2, "mutt_hcache_fetch index: %s\n", (char *) hdata);
if (sscanf(hdata, ANUM " " ANUM, &first, &last) == 2)
{
old = true;
continue;
snprintf(buf, sizeof(buf), "%u", current);
- mutt_debug(2, "mutt_hcache_delete %s\n", buf);
+ mutt_debug(LL_DEBUG2, "mutt_hcache_delete %s\n", buf);
mutt_hcache_delete(hc, buf, strlen(buf));
}
}
if (!old || mdata->first_message != first || mdata->last_message != last)
{
snprintf(buf, sizeof(buf), "%u %u", mdata->first_message, mdata->last_message);
- mutt_debug(2, "mutt_hcache_store index: %s\n", buf);
+ mutt_debug(LL_DEBUG2, "mutt_hcache_store index: %s\n", buf);
mutt_hcache_store_raw(hc, "index", 5, buf, strlen(buf) + 1);
}
}
anum < mdata->first_message || anum > mdata->last_message)
{
if (mdata)
- mutt_debug(2, "mutt_bcache_del %s\n", id);
+ mutt_debug(LL_DEBUG2, "mutt_bcache_del %s\n", id);
mutt_bcache_del(bcache, id);
}
return 0;
cache_expand(file, sizeof(file), &mdata->adata->conn->account, file);
unlink(file);
mdata->last_cached = 0;
- mutt_debug(2, "%s\n", file);
+ mutt_debug(LL_DEBUG2, "%s\n", file);
#endif
if (!mdata->bcache)
}
if (mdata->bcache)
{
- mutt_debug(2, "%s/*\n", mdata->group);
+ mutt_debug(LL_DEBUG2, "%s/*\n", mdata->group);
mutt_bcache_list(mdata->bcache, nntp_bcache_delete, NULL);
mutt_bcache_close(&mdata->bcache);
}
if (S_ISDIR(sb.st_mode))
{
rmdir(file);
- mutt_debug(2, "%s\n", file);
+ mutt_debug(LL_DEBUG2, "%s\n", file);
}
}
closedir(dp);
if (last >= mdata->first_message && last <= mdata->last_message)
{
mdata->last_cached = last;
- mutt_debug(2, "%s last_cached=%u\n", mdata->group, last);
+ mutt_debug(LL_DEBUG2, "%s last_cached=%u\n", mdata->group, last);
}
}
mutt_hcache_free(hc, &hdata);
p++;
}
- mutt_debug(1, "available methods: %s\n", adata->authenticators);
+ mutt_debug(LL_DEBUG1, "available methods: %s\n", adata->authenticators);
a = authenticators;
while (true)
{
if (*m != '\0' && *m != ' ')
continue;
}
- mutt_debug(1, "trying method %s\n", method);
+ mutt_debug(LL_DEBUG1, "trying method %s\n", method);
/* AUTHINFO USER authentication */
if (strcmp(method, "USER") == 0)
if (mutt_sasl_client_new(conn, &saslconn) < 0)
{
- mutt_debug(1, "error allocating SASL connection.\n");
+ mutt_debug(LL_DEBUG1, "error allocating SASL connection.\n");
continue;
}
if (rc != SASL_OK && rc != SASL_CONTINUE)
{
sasl_dispose(&saslconn);
- mutt_debug(1, "error starting SASL authentication exchange.\n");
+ mutt_debug(LL_DEBUG1,
+ "error starting SASL authentication exchange.\n");
continue;
}
if (sasl_encode64(client_out, client_len, buf + len,
sizeof(buf) - len, &len) != SASL_OK)
{
- mutt_debug(1, "error base64-encoding client response.\n");
+ mutt_debug(LL_DEBUG1, "error base64-encoding client response.\n");
break;
}
}
else if (sasl_decode64(inbuf + 4, strlen(inbuf + 4), buf,
sizeof(buf) - 1, &len) != SASL_OK)
{
- mutt_debug(1, "error base64-decoding server response.\n");
+ mutt_debug(LL_DEBUG1, "error base64-decoding server response.\n");
break;
}
else
if (mdata && (mutt_str_strcmp(desc, mdata->desc) != 0))
{
mutt_str_replace(&mdata->desc, desc);
- mutt_debug(2, "group: %s, desc: %s\n", line, desc);
+ mutt_debug(LL_DEBUG2, "group: %s, desc: %s\n", line, desc);
}
return 0;
}
*field++ = '\0';
if (sscanf(line, ANUM, &anum) != 1)
return 0;
- mutt_debug(2, "" ANUM "\n", anum);
+ mutt_debug(LL_DEBUG2, "" ANUM "\n", anum);
/* out of bounds */
if (anum < fc->first || anum > fc->last)
void *hdata = mutt_hcache_fetch(fc->hc, buf, strlen(buf));
if (hdata)
{
- mutt_debug(2, "mutt_hcache_fetch %s\n", buf);
+ mutt_debug(LL_DEBUG2, "mutt_hcache_fetch %s\n", buf);
mutt_email_free(&e);
e = mutt_hcache_restore(hdata);
m->emails[m->msg_count] = e;
{
if (mdata->bcache)
{
- mutt_debug(2, "mutt_bcache_del %s\n", buf);
+ mutt_debug(LL_DEBUG2, "mutt_bcache_del %s\n", buf);
mutt_bcache_del(mdata->bcache, buf);
}
save = false;
/* not cached yet, store header */
else
{
- mutt_debug(2, "mutt_hcache_store %s\n", buf);
+ mutt_debug(LL_DEBUG2, "mutt_hcache_store %s\n", buf);
mutt_hcache_store(fc->hc, buf, strlen(buf), e, 0);
}
}
snprintf(buf, sizeof(buf), "%u", current);
if (mdata->bcache)
{
- mutt_debug(2, "#1 mutt_bcache_del %s\n", buf);
+ mutt_debug(LL_DEBUG2, "#1 mutt_bcache_del %s\n", buf);
mutt_bcache_del(mdata->bcache, buf);
}
#ifdef USE_HCACHE
if (fc.hc)
{
- mutt_debug(2, "mutt_hcache_delete %s\n", buf);
+ mutt_debug(LL_DEBUG2, "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)
{
- mutt_debug(2, "mutt_hcache_fetch %s\n", buf);
+ mutt_debug(LL_DEBUG2, "mutt_hcache_fetch %s\n", buf);
e = mutt_hcache_restore(hdata);
m->emails[m->msg_count] = e;
mutt_hcache_free(fc.hc, &hdata);
mutt_email_free(&e);
if (mdata->bcache)
{
- mutt_debug(2, "#2 mutt_bcache_del %s\n", buf);
+ mutt_debug(LL_DEBUG2, "#2 mutt_bcache_del %s\n", buf);
mutt_bcache_del(mdata->bcache, buf);
}
continue;
if (mdata->bcache)
{
snprintf(buf, sizeof(buf), "%u", current);
- mutt_debug(2, "#3 mutt_bcache_del %s\n", buf);
+ mutt_debug(LL_DEBUG2, "#3 mutt_bcache_del %s\n", buf);
mutt_bcache_del(mdata->bcache, buf);
}
rc = 0;
{
bool deleted;
- mutt_debug(2, "#1 mutt_hcache_fetch %s\n", buf);
+ mutt_debug(LL_DEBUG2, "#1 mutt_hcache_fetch %s\n", buf);
e = mutt_hcache_restore(hdata);
mutt_hcache_free(hc, &hdata);
e->edata = NULL;
hdata = mutt_hcache_fetch(hc, buf, strlen(buf));
if (hdata)
{
- mutt_debug(2, "#2 mutt_hcache_fetch %s\n", buf);
+ mutt_debug(LL_DEBUG2, "#2 mutt_hcache_fetch %s\n", buf);
if (m->msg_count >= m->email_max)
mx_alloc_memory(m);
mutt_email_free(&e);
if (mdata->bcache)
{
- mutt_debug(2, "mutt_bcache_del %s\n", buf);
+ mutt_debug(LL_DEBUG2, "mutt_bcache_del %s\n", buf);
mutt_bcache_del(mdata->bcache, buf);
}
continue;
*now = timegm(&tm);
if (*now >= 0)
{
- mutt_debug(1, "server time is %lu\n", *now);
+ mutt_debug(LL_DEBUG1, "server time is %lu\n", *now);
return 0;
}
}
snprintf(buf, sizeof(buf), "%d", nntp_edata_get(e)->article_num);
if (mdata->bcache && e->deleted)
{
- mutt_debug(2, "mutt_bcache_del %s\n", buf);
+ mutt_debug(LL_DEBUG2, "mutt_bcache_del %s\n", buf);
mutt_bcache_del(mdata->bcache, buf);
}
{
if (e->deleted && !e->read)
mdata->unread--;
- mutt_debug(2, "mutt_hcache_store %s\n", buf);
+ mutt_debug(LL_DEBUG2, "mutt_hcache_store %s\n", buf);
mutt_hcache_store(hc, buf, strlen(buf), e, 0);
}
#endif
if (!ptr || !*ptr)
return;
- mutt_debug(1, "nm: freeing context data %p\n", ptr);
+ mutt_debug(LL_DEBUG1, "nm: freeing context data %p\n", ptr);
struct NmMboxData *mdata = *ptr;
return NULL;
struct NmMboxData *mdata = mutt_mem_calloc(1, sizeof(struct NmMboxData));
- mutt_debug(1, "nm: initialize mailbox mdata %p\n", (void *) mdata);
+ mutt_debug(LL_DEBUG1, "nm: initialize mailbox mdata %p\n", (void *) mdata);
mdata->db_limit = NmDbLimit;
mdata->query_type = string_to_query_type(NmQueryType);
return;
struct NmEmailData *edata = *ptr;
- mutt_debug(2, "nm: freeing email %p\n", (void *) edata);
+ mutt_debug(LL_DEBUG2, "nm: freeing email %p\n", (void *) edata);
FREE(&edata->folder);
FREE(&edata->oldpath);
FREE(&edata->virtual_id);
*/
static void query_window_reset(void)
{
- mutt_debug(2, "entering\n");
+ mutt_debug(LL_DEBUG2, "entering\n");
cs_str_native_set(Config, "nm_query_window_current_position", 0, NULL);
}
*/
static bool windowed_query_from_query(const char *query, char *buf, size_t buflen)
{
- mutt_debug(2, "nm: %s\n", query);
+ mutt_debug(LL_DEBUG2, "nm: %s\n", query);
int beg = NmQueryWindowDuration * (NmQueryWindowCurrentPosition + 1);
int end = NmQueryWindowDuration * NmQueryWindowCurrentPosition;
{
mutt_message(_("Invalid nm_query_window_timebase value (valid values are: "
"hour, day, week, month or year)"));
- mutt_debug(2, "Invalid nm_query_window_timebase value\n");
+ mutt_debug(LL_DEBUG2, "Invalid nm_query_window_timebase value\n");
return false;
}
end, NmQueryWindowTimebase, NmQueryWindowCurrentSearch);
}
- mutt_debug(2, "nm: %s -> %s\n", query, buf);
+ mutt_debug(LL_DEBUG2, "nm: %s -> %s\n", query, buf);
return true;
}
*/
static char *get_query_string(struct NmMboxData *mdata, bool window)
{
- mutt_debug(2, "nm: %s\n", window ? "true" : "false");
+ mutt_debug(LL_DEBUG2, "nm: %s\n", window ? "true" : "false");
if (!mdata)
return NULL;
mdata->db_query = mutt_str_strdup(buf);
}
- mutt_debug(2, "nm: query (windowed) '%s'\n", mdata->db_query);
+ mutt_debug(LL_DEBUG2, "nm: query (windowed) '%s'\n", mdata->db_query);
}
else
- mutt_debug(2, "nm: query '%s'\n", mdata->db_query);
+ mutt_debug(LL_DEBUG2, "nm: query '%s'\n", mdata->db_query);
return mdata->db_query;
}
break;
*end = '\0';
- mutt_debug(2, "nm: query exclude tag '%s'\n", tag);
+ mutt_debug(LL_DEBUG2, "nm: query exclude tag '%s'\n", tag);
notmuch_query_add_tag_exclude(query, tag);
end = NULL;
tag = NULL;
apply_exclude_tags(q);
notmuch_query_set_sort(q, NOTMUCH_SORT_NEWEST_FIRST);
- mutt_debug(2, "nm: query successfully initialized (%s)\n", str);
+ mutt_debug(LL_DEBUG2, "nm: query successfully initialized (%s)\n", str);
return q;
err:
nm_db_release(m);
char *new_tags = NULL;
char *old_tags = NULL;
- mutt_debug(2, "nm: tags update requested (%s)\n", edata->virtual_id);
+ mutt_debug(LL_DEBUG2, "nm: tags update requested (%s)\n", edata->virtual_id);
for (notmuch_tags_t *tags = notmuch_message_get_tags(msg);
tags && notmuch_tags_valid(tags); notmuch_tags_move_to_next(tags))
{
FREE(&old_tags);
FREE(&new_tags);
- mutt_debug(2, "nm: tags unchanged\n");
+ mutt_debug(LL_DEBUG2, "nm: tags unchanged\n");
return 1;
}
FREE(&new_tags);
new_tags = driver_tags_get_transformed(&e->tags);
- mutt_debug(2, "nm: new tags: '%s'\n", new_tags);
+ mutt_debug(LL_DEBUG2, "nm: new tags: '%s'\n", new_tags);
FREE(&new_tags);
new_tags = driver_tags_get(&e->tags);
- mutt_debug(2, "nm: new tag transforms: '%s'\n", new_tags);
+ mutt_debug(LL_DEBUG2, "nm: new tag transforms: '%s'\n", new_tags);
FREE(&new_tags);
return 0;
{
struct NmEmailData *edata = e->edata;
- mutt_debug(2, "nm: path update requested path=%s, (%s)\n", path, edata->virtual_id);
+ mutt_debug(LL_DEBUG2, "nm: path update requested path=%s, (%s)\n", path, edata->virtual_id);
char *p = strrchr(path, '/');
if (p && ((p - path) > 3) &&
edata->folder = mutt_str_substr_dup(path, p);
- mutt_debug(2, "nm: folder='%s', file='%s'\n", edata->folder, e->path);
+ mutt_debug(LL_DEBUG2, "nm: folder='%s', file='%s'\n", edata->folder, e->path);
return 0;
}
const char *id = notmuch_message_get_message_id(msg);
edata->virtual_id = mutt_str_strdup(id);
- mutt_debug(2, "nm: [e=%p, edata=%p] (%s)\n", (void *) e, (void *) e->edata, id);
+ mutt_debug(LL_DEBUG2, "nm: [e=%p, edata=%p] (%s)\n", (void *) e, (void *) e->edata, id);
if (!e->env->message_id)
e->env->message_id = nm2mutt_message_id(id);
if (!id)
return NULL;
- mutt_debug(2, "nm: neomutt email, id='%s'\n", id);
+ mutt_debug(LL_DEBUG2, "nm: neomutt email, id='%s'\n", id);
if (!m->id_hash)
{
- mutt_debug(2, "nm: init hash\n");
+ mutt_debug(LL_DEBUG2, "nm: init hash\n");
m->id_hash = mutt_make_id_hash(m);
if (!m->id_hash)
return NULL;
}
char *mid = nm2mutt_message_id(id);
- mutt_debug(2, "nm: neomutt id='%s'\n", mid);
+ mutt_debug(LL_DEBUG2, "nm: neomutt id='%s'\n", mid);
struct Email *e = mutt_hash_find(m->id_hash, mid);
FREE(&mid);
{
mdata->ignmsgcount++;
progress_update(m, q);
- mutt_debug(2, "nm: ignore id=%s, already in the m\n",
+ mutt_debug(LL_DEBUG2, "nm: ignore id=%s, already in the m\n",
notmuch_message_get_message_id(msg));
return;
}
if (!path)
return;
- mutt_debug(2, "nm: appending message, i=%d, id=%s, path=%s\n", m->msg_count,
- notmuch_message_get_message_id(msg), path);
+ mutt_debug(LL_DEBUG2, "nm: appending message, i=%d, id=%s, path=%s\n",
+ m->msg_count, notmuch_message_get_message_id(msg), path);
if (m->msg_count >= m->email_max)
{
- mutt_debug(2, "nm: allocate mx memory\n");
+ mutt_debug(LL_DEBUG2, "nm: allocate mx memory\n");
mx_alloc_memory(m);
}
if (access(path, F_OK) == 0)
e = maildir_parse_stream(MUTT_MAILDIR, f, newpath, false, NULL);
fclose(f);
- mutt_debug(1, "nm: not up-to-date: %s -> %s\n", path, newpath);
+ mutt_debug(LL_DEBUG1, "nm: not up-to-date: %s -> %s\n", path, newpath);
}
}
FREE(&folder);
if (!e)
{
- mutt_debug(1, "nm: failed to parse message: %s\n", path);
+ mutt_debug(LL_DEBUG1, "nm: failed to parse message: %s\n", path);
goto done;
}
if (init_email(e, newpath ? newpath : path, msg) != 0)
{
mutt_email_free(&e);
- mutt_debug(1, "nm: failed to append email!\n");
+ mutt_debug(LL_DEBUG1, "nm: failed to append email!\n");
goto done;
}
if (edata)
{
- mutt_debug(1, "nm: remember obsolete path: %s\n", path);
+ mutt_debug(LL_DEBUG1, "nm: remember obsolete path: %s\n", path);
edata->oldpath = mutt_str_strdup(path);
}
}
notmuch_message_t *msg = NULL;
char *id = email_get_id(e);
- mutt_debug(2, "nm: find message (%s)\n", id);
+ mutt_debug(LL_DEBUG2, "nm: find message (%s)\n", id);
if (id && db)
notmuch_database_find_message(db, id, &msg);
if (*tag == '-')
{
- mutt_debug(1, "nm: remove tag: '%s'\n", tag + 1);
+ mutt_debug(LL_DEBUG1, "nm: remove tag: '%s'\n", tag + 1);
notmuch_message_remove_tag(msg, tag + 1);
}
else if (*tag == '!')
{
- mutt_debug(1, "nm: toggle tag: '%s'\n", tag + 1);
+ mutt_debug(LL_DEBUG1, "nm: toggle tag: '%s'\n", tag + 1);
if (nm_message_has_tag(msg, tag + 1))
{
notmuch_message_remove_tag(msg, tag + 1);
}
else
{
- mutt_debug(1, "nm: add tag: '%s'\n", (*tag == '+') ? tag + 1 : tag);
+ mutt_debug(LL_DEBUG1, "nm: add tag: '%s'\n", (*tag == '+') ? tag + 1 : tag);
notmuch_message_add_tag(msg, (*tag == '+') ? tag + 1 : tag);
}
end = NULL;
if (rename(old, buf) != 0)
{
- mutt_debug(1, "nm: rename(2) failed %s -> %s\n", old, buf);
+ mutt_debug(LL_DEBUG1, "nm: rename(2) failed %s -> %s\n", old, buf);
return -1;
}
if (!mdata)
return -1;
- mutt_debug(2, "nm: remove filename '%s'\n", path);
+ mutt_debug(LL_DEBUG2, "nm: remove filename '%s'\n", path);
notmuch_database_t *db = nm_db_get(m, true);
if (!db)
switch (st)
{
case NOTMUCH_STATUS_SUCCESS:
- mutt_debug(2, "nm: remove success, call unlink\n");
+ mutt_debug(LL_DEBUG2, "nm: remove success, call unlink\n");
unlink(path);
break;
case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
- mutt_debug(2, "nm: remove success (duplicate), call unlink\n");
+ mutt_debug(LL_DEBUG2, "nm: remove success (duplicate), call unlink\n");
unlink(path);
for (ls = notmuch_message_get_filenames(msg);
ls && notmuch_filenames_valid(ls); notmuch_filenames_move_to_next(ls))
{
path = notmuch_filenames_get(ls);
- mutt_debug(2, "nm: remove duplicate: '%s'\n", path);
+ mutt_debug(LL_DEBUG2, "nm: remove duplicate: '%s'\n", path);
unlink(path);
notmuch_database_remove_message(db, path);
}
break;
default:
- mutt_debug(1, "nm: failed to remove '%s' [st=%d]\n", path, (int) st);
+ mutt_debug(LL_DEBUG1, "nm: failed to remove '%s' [st=%d]\n", path, (int) st);
break;
}
notmuch_filenames_t *ls = NULL;
notmuch_message_t *msg = NULL;
- mutt_debug(1, "nm: rename filename, %s -> %s\n", old, new);
+ mutt_debug(LL_DEBUG1, "nm: rename filename, %s -> %s\n", old, new);
int trans = nm_db_trans_begin(m);
if (trans < 0)
return -1;
- mutt_debug(2, "nm: rename: add '%s'\n", new);
+ mutt_debug(LL_DEBUG2, "nm: rename: add '%s'\n", new);
#ifdef HAVE_NOTMUCH_DATABASE_INDEX_FILE
st = notmuch_database_index_file(db, new, NULL, &msg);
#else
if ((st != NOTMUCH_STATUS_SUCCESS) && (st != NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID))
{
- mutt_debug(1, "nm: failed to add '%s' [st=%d]\n", new, (int) st);
+ mutt_debug(LL_DEBUG1, "nm: failed to add '%s' [st=%d]\n", new, (int) st);
goto done;
}
- mutt_debug(2, "nm: rename: rem '%s'\n", old);
+ mutt_debug(LL_DEBUG2, "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:
- mutt_debug(2, "nm: rename: syncing duplicate filename\n");
+ mutt_debug(LL_DEBUG2, "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;
- mutt_debug(2, "nm: rename: syncing duplicate: %s\n", path);
+ mutt_debug(LL_DEBUG2, "nm: rename: syncing duplicate: %s\n", path);
if (rename_maildir_filename(path, newpath, sizeof(newpath), e) == 0)
{
- mutt_debug(2, "nm: rename dup %s -> %s\n", path, newpath);
+ mutt_debug(LL_DEBUG2, "nm: rename dup %s -> %s\n", path, newpath);
notmuch_database_remove_message(db, path);
#ifdef HAVE_NOTMUCH_DATABASE_INDEX_FILE
notmuch_database_index_file(db, newpath, NULL, NULL);
st = NOTMUCH_STATUS_SUCCESS;
break;
default:
- mutt_debug(1, "nm: failed to remove '%s' [st=%d]\n", old, (int) st);
+ mutt_debug(LL_DEBUG1, "nm: failed to remove '%s' [st=%d]\n", old, (int) st);
break;
}
res = notmuch_query_count_messages(q);
#endif
notmuch_query_destroy(q);
- mutt_debug(1, "nm: count '%s', result=%d\n", qstr, res);
+ mutt_debug(LL_DEBUG1, "nm: count '%s', result=%d\n", qstr, res);
if (limit > 0 && res > limit)
res = limit;
if (!(db = nm_db_get(m, false)) || !(msg = get_nm_message(db, e)))
goto done;
- mutt_debug(1, "nm: reading entire-thread messages...[current count=%d]\n", m->msg_count);
+ mutt_debug(LL_DEBUG1, "nm: reading entire-thread messages...[current count=%d]\n",
+ m->msg_count);
progress_reset(m);
const char *id = notmuch_message_get_thread_id(msg);
mutt_message(_("No more messages in the thread"));
mdata->oldmsgcount = 0;
- mutt_debug(1, "nm: reading entire-thread messages... done [rc=%d, count=%d]\n",
+ mutt_debug(LL_DEBUG1, "nm: reading entire-thread messages... done [rc=%d, count=%d]\n",
rc, m->msg_count);
return rc;
}
*/
char *nm_uri_from_query(struct Mailbox *m, char *buf, size_t buflen)
{
- mutt_debug(2, "(%s)\n", buf);
+ mutt_debug(LL_DEBUG2, "(%s)\n", buf);
struct NmMboxData *mdata = nm_mdata_get(m);
char uri[PATH_MAX + LONG_STRING + 32]; /* path to DB + query + URI "decoration" */
int added;
if (using_default_data)
nm_mdata_free((void **) &mdata);
- mutt_debug(1, "nm: uri from query '%s'\n", buf);
+ mutt_debug(LL_DEBUG1, "nm: uri from query '%s'\n", buf);
return buf;
}
if (NmQueryWindowCurrentPosition != 0)
NmQueryWindowCurrentPosition--;
- mutt_debug(2, "(%d)\n", NmQueryWindowCurrentPosition);
+ mutt_debug(LL_DEBUG2, "(%d)\n", NmQueryWindowCurrentPosition);
}
/**
void nm_query_window_backward(void)
{
NmQueryWindowCurrentPosition++;
- mutt_debug(2, "(%d)\n", NmQueryWindowCurrentPosition);
+ mutt_debug(LL_DEBUG2, "(%d)\n", NmQueryWindowCurrentPosition);
}
/**
if (safe_asprintf(&new_str, "id:%s and (%s)", email_get_id(e), orig_str) < 0)
return false;
- mutt_debug(2, "nm: checking if message is still queried: %s\n", new_str);
+ mutt_debug(LL_DEBUG2, "nm: checking if message is still queried: %s\n", new_str);
notmuch_query_t *q = notmuch_query_create(db, new_str);
notmuch_query_destroy(q);
- mutt_debug(2, "nm: checking if message is still queried: %s = %s\n", new_str,
- result ? "true" : "false");
+ mutt_debug(LL_DEBUG2, "nm: checking if message is still queried: %s = %s\n",
+ new_str, result ? "true" : "false");
return result;
}
notmuch_database_t *db = NULL;
int rc = -1;
int limit = NmDbLimit;
- mutt_debug(1, "nm: count\n");
+ mutt_debug(LL_DEBUG1, "nm: count\n");
url = url_parse(m->path);
if (!url)
if (db)
{
nm_db_free(db);
- mutt_debug(1, "nm: count close DB\n");
+ mutt_debug(LL_DEBUG1, "nm: count close DB\n");
}
url_free(&url);
- mutt_debug(1, "nm: count done [rc=%d]\n", rc);
+ mutt_debug(LL_DEBUG1, "nm: count done [rc=%d]\n", rc);
return rc;
}
if (!db)
return -1;
- mutt_debug(1, "nm: record message: %s\n", path);
+ mutt_debug(LL_DEBUG1, "nm: record message: %s\n", path);
int trans = nm_db_trans_begin(m);
if (trans < 0)
goto done;
if ((st != NOTMUCH_STATUS_SUCCESS) && (st != NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID))
{
- mutt_debug(1, "nm: failed to add '%s' [st=%d]\n", path, (int) st);
+ mutt_debug(LL_DEBUG1, "nm: failed to add '%s' [st=%d]\n", path, (int) st);
goto done;
}
goto done;
*tag_count = 0;
- mutt_debug(1, "nm: get all tags\n");
+ mutt_debug(LL_DEBUG1, "nm: get all tags\n");
while (notmuch_tags_valid(tags))
{
nm_db_release(m);
- mutt_debug(1, "nm: get all tags done [rc=%d tag_count=%u]\n", rc, *tag_count);
+ mutt_debug(LL_DEBUG1, "nm: get all tags done [rc=%d tag_count=%u]\n", rc, *tag_count);
return rc;
}
if (!mdata)
return -1;
- mutt_debug(1, "nm: reading messages...[current count=%d]\n", m->msg_count);
+ mutt_debug(LL_DEBUG1, "nm: reading messages...[current count=%d]\n", m->msg_count);
progress_reset(m);
mdata->oldmsgcount = 0;
- mutt_debug(1, "nm: reading messages... done [rc=%d, count=%d]\n", rc, m->msg_count);
+ mutt_debug(LL_DEBUG1, "nm: reading messages... done [rc=%d, count=%d]\n", rc, m->msg_count);
return rc;
}
if (m->mtime.tv_sec >= mtime)
{
- mutt_debug(2, "nm: check unnecessary (db=%lu mailbox=%lu)\n", mtime, m->mtime);
+ mutt_debug(LL_DEBUG2, "nm: check unnecessary (db=%lu mailbox=%lu)\n", mtime, m->mtime);
return 0;
}
- mutt_debug(1, "nm: checking (db=%lu mailbox=%lu)\n", mtime, m->mtime);
+ mutt_debug(LL_DEBUG1, "nm: checking (db=%lu mailbox=%lu)\n", mtime, m->mtime);
notmuch_query_t *q = get_query(m, false);
if (!q)
goto done;
- mutt_debug(1, "nm: start checking (count=%d)\n", m->msg_count);
+ mutt_debug(LL_DEBUG1, "nm: start checking (count=%d)\n", m->msg_count);
mdata->oldmsgcount = m->msg_count;
mdata->noprogress = true;
m->mtime.tv_sec = time(NULL);
m->mtime.tv_nsec = 0;
- mutt_debug(1, "nm: ... check done [count=%d, new_flags=%d, occult=%d]\n",
+ mutt_debug(LL_DEBUG1, "nm: ... check done [count=%d, new_flags=%d, occult=%d]\n",
m->msg_count, new_flags, occult);
return occult ? MUTT_REOPENED :
bool changed = false;
char msgbuf[PATH_MAX + 64];
- mutt_debug(1, "nm: sync start ...\n");
+ mutt_debug(LL_DEBUG1, "nm: sync start ...\n");
if (!m->quiet)
{
{
mutt_str_strfcpy(old, edata->oldpath, sizeof(old));
old[sizeof(old) - 1] = '\0';
- mutt_debug(2, "nm: fixing obsolete path '%s'\n", old);
+ mutt_debug(LL_DEBUG2, "nm: fixing obsolete path '%s'\n", old);
}
else
email_get_fullpath(e, old, sizeof(old));
}
FREE(&uri);
- mutt_debug(1, "nm: .... sync done [rc=%d]\n", rc);
+ mutt_debug(LL_DEBUG1, "nm: .... sync done [rc=%d]\n", rc);
return rc;
}
if (!(db = nm_db_get(m, true)) || !(msg = get_nm_message(db, e)))
goto done;
- mutt_debug(1, "nm: tags modify: '%s'\n", buf);
+ mutt_debug(LL_DEBUG1, "nm: tags modify: '%s'\n", buf);
update_tags(msg, buf);
update_email_flags(m, e, buf);
m->mtime.tv_sec = time(NULL);
m->mtime.tv_nsec = 0;
}
- mutt_debug(1, "nm: tags modify done [rc=%d]\n", rc);
+ mutt_debug(LL_DEBUG1, "nm: tags modify done [rc=%d]\n", rc);
return rc;
}
if (nm_path_probe(db_filename, NULL) == MUTT_NOTMUCH)
db_filename += NmUriProtocolLen;
- mutt_debug(2, "nm: db filename '%s'\n", db_filename);
+ mutt_debug(LL_DEBUG2, "nm: db filename '%s'\n", db_filename);
return db_filename;
}
char *msg = NULL;
#endif
- mutt_debug(1, "nm: db open '%s' %s (timeout %d)\n", filename,
+ mutt_debug(LL_DEBUG1, "nm: db open '%s' %s (timeout %d)\n", filename,
writable ? "[WRITE]" : "[READ]", NmOpenTimeout);
const notmuch_database_mode_t mode =
if (!adata || !adata->db || nm_db_is_longrun(m))
return -1;
- mutt_debug(1, "nm: db close\n");
+ mutt_debug(LL_DEBUG1, "nm: db close\n");
nm_db_free(adata->db);
adata->db = NULL;
adata->longrun = false;
if (adata->trans)
return 0;
- mutt_debug(2, "nm: db trans start\n");
+ mutt_debug(LL_DEBUG2, "nm: db trans start\n");
if (notmuch_database_begin_atomic(adata->db))
return -1;
adata->trans = true;
if (!adata->trans)
return 0;
- mutt_debug(2, "nm: db trans end\n");
+ mutt_debug(LL_DEBUG2, "nm: db trans end\n");
adata->trans = false;
if (notmuch_database_end_atomic(adata->db))
return -1;
char path[PATH_MAX];
snprintf(path, sizeof(path), "%s/.notmuch/xapian", nm_db_get_filename(m));
- mutt_debug(2, "nm: checking '%s' mtime\n", path);
+ mutt_debug(LL_DEBUG2, "nm: checking '%s' mtime\n", path);
struct stat st;
if (stat(path, &st))
return;
adata->longrun = true;
- mutt_debug(2, "nm: long run initialized\n");
+ mutt_debug(LL_DEBUG2, "nm: long run initialized\n");
}
/**
{
adata->longrun = false; /* to force nm_db_release() released DB */
if (nm_db_release(m) == 0)
- mutt_debug(2, "nm: long run deinitialized\n");
+ mutt_debug(LL_DEBUG2, "nm: long run deinitialized\n");
else
adata->longrun = true;
}
if (!adata || !adata->db)
return;
- mutt_debug(1, "nm: ERROR: db is open, closing\n");
+ mutt_debug(LL_DEBUG1, "nm: ERROR: db is open, closing\n");
nm_db_release(m);
}
((check_attachment_marker((char *) p) == 0) ||
(check_protected_header_marker((char *) p) == 0)))
{
- mutt_debug(2, "Seen attachment marker.\n");
+ mutt_debug(LL_DEBUG2, "Seen attachment marker.\n");
while (*p++ != '\a') /* skip pseudo-ANSI sequence */
;
}
{
if (k == (size_t)(-1))
memset(&mbstate, 0, sizeof(mbstate));
- mutt_debug(1, "mbrtowc returned %lu; errno = %d.\n", k, errno);
+ mutt_debug(LL_DEBUG1, "mbrtowc returned %lu; errno = %d.\n", k, errno);
if (col + 4 > wrap_cols)
break;
col += 4;
/* zero width space, zero width no-break space */
if (wc == 0x200B || wc == 0xFEFF)
{
- mutt_debug(3, "skip zero-width character U+%04X\n", (unsigned short) wc);
+ mutt_debug(LL_DEBUG3, "skip zero-width character U+%04X\n", (unsigned short) wc);
continue;
}
if (mutt_mb_is_display_corrupting_utf8(wc))
{
- mutt_debug(3, "filtered U+%04X\n", (unsigned short) wc);
+ mutt_debug(LL_DEBUG3, "filtered U+%04X\n", (unsigned short) wc);
continue;
}
}
else
{
char *escaped_folder = mutt_path_escape(Context->mailbox->path);
- mutt_debug(2, "escaped folder path: %s\n", escaped_folder);
+ mutt_debug(LL_DEBUG2, "escaped folder path: %s\n", escaped_folder);
mutt_buffer_addch(&cmd_buf, '\'');
mutt_buffer_addstr(&cmd_buf, escaped_folder);
mutt_buffer_addch(&cmd_buf, '\'');
size_t ds = err->dsize;
if (regerror(regerr, preg, err->data, ds) > ds)
- mutt_debug(2, "warning: buffer too small for regerror\n");
+ mutt_debug(LL_DEBUG2, "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);
- mutt_debug(1, "pat->min=%d pat->max=%d\n", pat->min, pat->max);
+ mutt_debug(LL_DEBUG1, "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))
{
adata->cmd_top = 1;
- mutt_debug(1, "set TOP capability\n");
+ mutt_debug(LL_DEBUG1, "set TOP capability\n");
}
if (rc == -2)
{
adata->cmd_top = 0;
- mutt_debug(1, "unset TOP capability\n");
+ mutt_debug(LL_DEBUG1, "unset TOP capability\n");
snprintf(adata->err_msg, sizeof(adata->err_msg), "%s",
_("Command TOP is not supported by server"));
}
if (i == m->msg_count)
{
- mutt_debug(1, "new header %d %s\n", index, line);
+ mutt_debug(LL_DEBUG1, "new header %d %s\n", index, line);
if (i >= m->email_max)
mx_alloc_memory(m);
{
adata->cmd_uidl = 1;
- mutt_debug(1, "set UIDL capability\n");
+ mutt_debug(LL_DEBUG1, "set UIDL capability\n");
}
if (ret == -2 && adata->cmd_uidl == 2)
{
adata->cmd_uidl = 0;
- mutt_debug(1, "unset UIDL capability\n");
+ mutt_debug(LL_DEBUG1, "unset UIDL capability\n");
snprintf(adata->err_msg, sizeof(adata->err_msg), "%s",
_("Command UIDL is not supported by server"));
}
if (!adata->clear_cache)
return;
- mutt_debug(1, "delete cached messages\n");
+ mutt_debug(LL_DEBUG1, "delete cached messages\n");
for (int i = 0; i < POP_CACHE_LEN; i++)
{
if (mutt_sasl_client_new(adata->conn, &saslconn) < 0)
{
- mutt_debug(1, "Error allocating SASL connection.\n");
+ mutt_debug(LL_DEBUG1, "Error allocating SASL connection.\n");
return POP_A_FAILURE;
}
if (mutt_str_startswith(inbuf, "+ ", CASE_MATCH) &&
sasl_decode64(inbuf + 2, strlen(inbuf + 2), buf, bufsize - 1, &len) != SASL_OK)
{
- mutt_debug(1, "error base64-decoding server response.\n");
+ mutt_debug(LL_DEBUG1, "error base64-decoding server response.\n");
goto bail;
}
}
if (sasl_encode64(pc, olen, buf, bufsize, &olen) != SASL_OK)
{
- mutt_debug(1, "error base64-encoding client response.\n");
+ mutt_debug(LL_DEBUG1, "error base64-encoding client response.\n");
goto bail;
}
}
{
adata->cmd_user = 1;
- mutt_debug(1, "set USER capability\n");
+ mutt_debug(LL_DEBUG1, "set USER capability\n");
}
if (ret == -2)
{
adata->cmd_user = 0;
- mutt_debug(1, "unset USER capability\n");
+ mutt_debug(LL_DEBUG1, "unset USER capability\n");
snprintf(adata->err_msg, sizeof(adata->err_msg), "%s",
_("Command USER is not supported by server"));
}
comma = strchr(method, ':');
if (comma)
*comma++ = '\0';
- mutt_debug(2, "Trying method %s\n", method);
+ mutt_debug(LL_DEBUG2, "Trying method %s\n", method);
authenticator = pop_authenticators;
while (authenticator->authenticate)
else
{
/* Fall back to default: any authenticator */
- mutt_debug(2, "Using any available method.\n");
+ mutt_debug(LL_DEBUG2, "Using any available method.\n");
authenticator = pop_authenticators;
while (authenticator->authenticate)
}
if (ret < 0)
- mutt_debug(1, "Error closing POP connection\n");
+ mutt_debug(LL_DEBUG1, "Error closing POP connection\n");
mutt_clear_error();
}
if (newpc >= 0)
{
PostCount = newpc;
- mutt_debug(3, "%d postponed IMAP messages found.\n", PostCount);
+ mutt_debug(LL_DEBUG3, "%d postponed IMAP messages found.\n", PostCount);
}
else
- mutt_debug(3, "using old IMAP postponed count.\n");
+ mutt_debug(LL_DEBUG3, "using old IMAP postponed count.\n");
}
return PostCount;
}
return;
}
if (gettimeofday(&tv, NULL) < 0)
- mutt_debug(1, "gettimeofday failed: %d\n", errno);
+ mutt_debug(LL_DEBUG1, "gettimeofday failed: %d\n", errno);
/* if timestamp is 0 no time-based suppression is done */
if (TimeInc != 0)
{
thepid = mutt_create_filter(cmd, NULL, &fp, NULL);
if (thepid < 0)
{
- mutt_debug(1, "unable to fork command: %s\n", cmd);
+ mutt_debug(LL_DEBUG1, "unable to fork command: %s\n", cmd);
return 0;
}
if (!quiet)
mutt_file_fclose(&fp);
if (mutt_wait_filter(thepid))
{
- mutt_debug(1, "Error: %s\n", msg);
+ mutt_debug(LL_DEBUG1, "Error: %s\n", msg);
if (!quiet)
mutt_error("%s", msg);
}
ch = dispchar[aptr->content->disposition];
else
{
- mutt_debug(1, "ERROR: invalid content-disposition %d\n", aptr->content->disposition);
+ mutt_debug(LL_DEBUG1, "ERROR: invalid content-disposition %d\n",
+ aptr->content->disposition);
ch = '!';
}
snprintf(buf, buflen, "%c", ch);
/* ignore comments */
if (*buf == '#')
continue;
- mutt_debug(2, "mailcap entry: %s\n", buf);
+ mutt_debug(LL_DEBUG2, "mailcap entry: %s\n", buf);
/* check type */
ch = get_field(buf);
{
field = ch;
ch = get_field(ch);
- mutt_debug(2, "field: %s\n", field);
+ mutt_debug(LL_DEBUG2, "field: %s\n", field);
size_t plen;
if (mutt_str_strcasecmp(field, "needsterminal") == 0)
mutt_mem_realloc(&test_command, len);
if (rfc1524_expand_command(a, a->filename, type, test_command, len) == 1)
{
- mutt_debug(1, "Command is expecting to be piped\n");
+ mutt_debug(LL_DEBUG1, "Command is expecting to be piped\n");
}
if (mutt_system(test_command) != 0)
{
path[x] = '\0';
mutt_expand_path(path, sizeof(path));
- mutt_debug(2, "Checking mailcap file: %s\n", path);
+ mutt_debug(LL_DEBUG2, "Checking mailcap file: %s\n", path);
found = rfc1524_mailcap_parse(a, path, type, entry, opt);
}
/* remember number of spaces */
if (!*p)
{
- mutt_debug(3, "f=f: additional space\n");
+ mutt_debug(LL_DEBUG3, "f=f: additional space\n");
fst->spaces++;
continue;
}
if (!(!fst->spaces && fst->delsp && last != ' ') && w < width &&
w + fst->width + fst->spaces > width)
{
- mutt_debug(3, "f=f: break line at %lu, %lu spaces left\n", fst->width, fst->spaces);
+ mutt_debug(LL_DEBUG3, "f=f: break line at %lu, %lu spaces left\n",
+ fst->width, fst->spaces);
/* only honor trailing spaces for format=flowed replies */
if (TextFlowed)
for (; fst->spaces; fst->spaces--)
fst.delsp = 1;
}
- mutt_debug(3, "f=f: DelSp: %s\n", delsp ? "yes" : "no");
+ mutt_debug(LL_DEBUG3, "f=f: DelSp: %s\n", delsp ? "yes" : "no");
while ((buf = mutt_file_read_line(buf, &sz, s->fpin, NULL, 0)))
{
if (!e || !e->content || !e->content->filename)
return;
- mutt_debug(2, "f=f: postprocess %s\n", e->content->filename);
+ mutt_debug(LL_DEBUG2, "f=f: postprocess %s\n", e->content->filename);
in = mutt_file_fopen(e->content->filename, "r");
if (!in)
if (!tempfp)
{
- mutt_debug(1, "can't create tempfile %s (errno=%d)\n", msg->content->filename, errno);
+ mutt_debug(LL_DEBUG1, "can't create tempfile %s (errno=%d)\n",
+ msg->content->filename, errno);
mutt_perror(msg->content->filename);
goto cleanup;
}
}
else
{
- mutt_debug(1, "ERROR: invalid content-disposition %d\n", a->disposition);
+ mutt_debug(LL_DEBUG1, "ERROR: invalid content-disposition %d\n", a->disposition);
}
}
const char *p = mutt_param_get(&a->parameter, "boundary");
if (!p)
{
- mutt_debug(1, "no boundary parameter found\n");
+ mutt_debug(LL_DEBUG1, "no boundary parameter found\n");
mutt_error(_("No boundary parameter found [report this error]"));
return -1;
}
fpin = fopen(a->filename, "r");
if (!fpin)
{
- mutt_debug(1, "%s no longer exists\n", a->filename);
+ mutt_debug(LL_DEBUG1, "%s no longer exists\n", a->filename);
mutt_error(_("%s no longer exists"), a->filename);
return -1;
}
fp = fopen(fname, "r");
if (!fp)
{
- mutt_debug(1, "%s: %s (errno %d).\n", fname, strerror(errno), errno);
+ mutt_debug(LL_DEBUG1, "%s: %s (errno %d).\n", fname, strerror(errno), errno);
return NULL;
}
snprintf(buf, sizeof(buf), "%s/.mime.types", NONULL(HomeDir));
break;
default:
- mutt_debug(1, "Internal error, count = %d.\n", count);
+ mutt_debug(LL_DEBUG1, "Internal error, count = %d.\n", count);
goto bye; /* shouldn't happen */
}
t = strchr(valbuf, ':');
if (!t)
{
- mutt_debug(1, "#1 warning: header not in 'key: value' format!\n");
+ mutt_debug(LL_DEBUG1, "#1 warning: header not in 'key: value' format!\n");
FREE(&valbuf);
return 0;
}
t = strchr(start, ':');
if (!t || t > end)
{
- mutt_debug(1, "#2 warning: header not in 'key: value' format!\n");
+ mutt_debug(LL_DEBUG1, "#2 warning: header not in 'key: value' format!\n");
return 0;
}
if (is_from)
valbuf = mutt_str_substr_dup(t, end);
}
- mutt_debug(2, "buf[%s%s] too long, max width = %d > %d\n", NONULL(pfx),
- NONULL(valbuf), max, wraplen);
+ mutt_debug(LL_DEBUG2, "buf[%s%s] too long, max width = %d > %d\n",
+ NONULL(pfx), NONULL(valbuf), max, wraplen);
if (fold_one_header(fp, tagbuf, valbuf, pfx, wraplen, flags) < 0)
{
FREE(&valbuf);
if (!tok)
return -1;
- mutt_debug(1, "Fcc: initial mailbox = '%s'\n", tok);
+ mutt_debug(LL_DEBUG1, "Fcc: initial mailbox = '%s'\n", tok);
/* mutt_expand_path already called above for the first token */
int status = mutt_write_fcc(tok, e, msgid, post, fcc, finalpath);
if (status != 0)
continue;
/* Only call mutt_expand_path if tok has some data */
- mutt_debug(1, "Fcc: additional mailbox token = '%s'\n", tok);
+ mutt_debug(LL_DEBUG1, "Fcc: additional mailbox token = '%s'\n", tok);
mutt_str_strfcpy(fcc_expanded, tok, sizeof(fcc_expanded));
mutt_expand_path(fcc_expanded, sizeof(fcc_expanded));
- mutt_debug(1, " Additional mailbox expanded = '%s'\n", fcc_expanded);
+ mutt_debug(LL_DEBUG1, " Additional mailbox expanded = '%s'\n", fcc_expanded);
status = mutt_write_fcc(fcc_expanded, e, msgid, post, fcc, finalpath);
if (status != 0)
return status;
struct Context *ctx_fcc = mx_mbox_open(m_fcc, MUTT_APPEND | MUTT_QUIET);
if (!ctx_fcc)
{
- mutt_debug(1, "unable to open mailbox %s in append-mode, aborting.\n", path);
+ mutt_debug(LL_DEBUG1, "unable to open mailbox %s in append-mode, aborting.\n", path);
mailbox_free(&m_fcc);
goto done;
}
fflush(tempfp);
if (ferror(tempfp))
{
- mutt_debug(1, "%s: write failed.\n", tempfile);
+ mutt_debug(LL_DEBUG1, "%s: write failed.\n", tempfile);
mutt_file_fclose(&tempfp);
unlink(tempfile);
mx_msg_commit(ctx_fcc->mailbox, msg); /* XXX really? */
SmtpPort = ntohs(service->s_port);
else
SmtpPort = SMTP_PORT;
- mutt_debug(3, "Using default SMTP port %d\n", SmtpPort);
+ mutt_debug(LL_DEBUG3, "Using default SMTP port %d\n", SmtpPort);
}
account->port = SmtpPort;
}
if (rc != SASL_OK && rc != SASL_CONTINUE)
{
- mutt_debug(2, "%s unavailable\n", mech);
+ mutt_debug(LL_DEBUG2, "%s unavailable\n", mech);
sasl_dispose(&saslconn);
return SMTP_AUTH_UNAVAIL;
}
if (sasl_encode64(data, len, buf + mutt_str_strlen(buf),
bufsize - mutt_str_strlen(buf), &len) != SASL_OK)
{
- mutt_debug(1, "#1 error base64-encoding client response.\n");
+ mutt_debug(LL_DEBUG1, "#1 error base64-encoding client response.\n");
goto fail;
}
}
if (sasl_decode64(buf + 4, strlen(buf + 4), buf, bufsize - 1, &len) != SASL_OK)
{
- mutt_debug(1, "error base64-decoding server response.\n");
+ mutt_debug(LL_DEBUG1, "error base64-decoding server response.\n");
goto fail;
}
}
if (sasl_encode64(data, len, buf, bufsize, &len) != SASL_OK)
{
- mutt_debug(1, "#2 error base64-encoding client response.\n");
+ mutt_debug(LL_DEBUG1, "#2 error base64-encoding client response.\n");
goto fail;
}
}
if (!method[0])
continue;
- mutt_debug(2, "Trying method %s\n", method);
+ mutt_debug(LL_DEBUG2, "Trying method %s\n", method);
if (strcmp(method, "oauthbearer") == 0)
{
projects / neomutt / commitdiff