muttlib.h File Reference

Some miscellaneous functions. More...

#include <stdbool.h>
#include <stdio.h>
#include <sys/types.h>
#include "attach/lib.h"

Include dependency graph for muttlib.h:

Go to the source code of this file.

Macros
#define	mutt_adv_mktemp(buf)
#define	mutt_adv_mktemp_draft(buf)

Functions
void	mutt_adv_mktemp_cfg (struct Buffer *buf, const char *cfg)
	Create a temporary file.
void	expand_path (struct Buffer *buf, bool regex)
	Create the canonical path.
void	pretty_mailbox (struct Buffer *s)
	Shorten a mailbox path using '~' or '='.
void	buf_sanitize_filename (struct Buffer *buf, const char *path, short slash)
	Replace unsafe characters in a filename.
void	generate_save_path (struct Buffer *dest, const struct Address *a)
	Make a safe filename from an email address.
int	mutt_check_overwrite (const char *attname, const char *path, struct Buffer *fname, enum SaveAttach *opt, char **directory)
	Ask the user if overwriting is necessary.
void	mutt_encode_path (struct Buffer *buf, const char *src)
	Convert a path to 'us-ascii'.
char *	mutt_gecos_name (char *dest, size_t destlen, struct passwd *pw)
	Lookup a user's real name in /etc/passwd.
void	mutt_get_parent_path (const char *path, char *buf, size_t buflen)
	Find the parent of a path (or mailbox)
bool	mutt_is_text_part (const struct Body *b)
	Is this part of an email in plain text?
bool	mutt_needs_mailcap (struct Body *b)
	Does this type need a mailcap entry do display.
FILE *	mutt_open_read (const char *path, pid_t *thepid)
	Run a command to read from.
int	mutt_save_confirm (const char *s, struct stat *st)
	Ask the user to save.
void	mutt_sleep (short s)
	Sleep for a while.
int	mutt_str_pretty_size (struct Buffer *buf, size_t num)
	Display an abbreviated size, like 3.4K.

Detailed Description

Some miscellaneous functions.

Authors

• Richard Russon
• Pietro Cerutti

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file muttlib.h.

Macro Definition Documentation

mutt_adv_mktemp

#define mutt_adv_mktemp

(

buf

)

Value:

mutt_adv_mktemp_cfg(buf, "tmp_dir")

Definition at line 39 of file muttlib.h.

mutt_adv_mktemp_draft

#define mutt_adv_mktemp_draft

(

buf

)

Value:

mutt_adv_mktemp_cfg(buf, "tmp_draft_dir")

Definition at line 40 of file muttlib.h.

Function Documentation

mutt_adv_mktemp_cfg()

void mutt_adv_mktemp_cfg	(	struct Buffer *	buf,
		const char *	cfg )

Create a temporary file.

Parameters

buf	Buffer for the name
cfg	Config option for the temp directory

Accept a "suggestion" for file name. If that file exists, then construct one with unique name but keep any extension. This might fail, I guess.

Definition at line 84 of file muttlib.c.

{
  if (buf_is_empty(buf))
  {
    buf_mktemp_full(buf, "neomutt", NULL, __FILE__, __LINE__, cfg);
  }
  else
  {
    struct Buffer *prefix = buf_pool_get();
    buf_strcpy(prefix, buf->data);
    mutt_file_sanitize_filename(prefix->data, true);
    const char *const c_tmp_dir = cs_subset_path(NeoMutt->sub, cfg);
    buf_printf(buf, "%s/%s", NONULL(c_tmp_dir), buf_string(prefix));
 
    struct stat st = { 0 };
    if ((lstat(buf_string(buf), &st) == -1) && (errno == ENOENT))
      goto out;
 
    char *suffix = strchr(prefix->data, '.');
    if (suffix)
    {
      *suffix = '\0';
      suffix++;
    }
    buf_mktemp_full(buf, prefix->data, suffix, __FILE__, __LINE__, cfg);
 
  out:
    buf_pool_release(&prefix);
  }
}

Here is the call graph for this function:

expand_path()

void expand_path	(	struct Buffer *	buf,
		bool	regex )

Create the canonical path.

Parameters

buf	Buffer with path
regex	If true, escape regex special characters

Note

The path is expanded in-place

Definition at line 122 of file muttlib.c.

{
  const char *s = NULL;
  const char *tail = "";
 
  bool recurse = false;
 
  struct Buffer *p = buf_pool_get();
  struct Buffer *q = buf_pool_get();
  struct Buffer *tmp = buf_pool_get();
 
  do
  {
    recurse = false;
    s = buf_string(buf);
 
    switch (*s)
    {
      case '~':
      {
        if ((s[1] == '/') || (s[1] == '\0'))
        {
          buf_strcpy(p, NeoMutt->home_dir);
          tail = s + 1;
        }
        else
        {
          char *t = strchr(s + 1, '/');
          if (t)
            *t = '\0';
 
          struct passwd *pw = getpwnam(s + 1);
          if (pw)
          {
            buf_strcpy(p, pw->pw_dir);
            if (t)
            {
              *t = '/';
              tail = t;
            }
            else
            {
              tail = "";
            }
          }
          else
          {
            /* user not found! */
            if (t)
              *t = '/';
            buf_reset(p);
            tail = s;
          }
        }
        break;
      }
 
      case '=':
      case '+':
      {
        const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
        enum MailboxType mb_type = mx_path_probe(c_folder);
 
        /* if folder = {host} or imap[s]://host/: don't append slash */
        if ((mb_type == MUTT_IMAP) && ((c_folder[strlen(c_folder) - 1] == '}') ||
                                       (c_folder[strlen(c_folder) - 1] == '/')))
        {
          buf_strcpy(p, c_folder);
        }
        else if (mb_type == MUTT_NOTMUCH)
        {
          buf_strcpy(p, c_folder);
        }
        else if (c_folder && (c_folder[strlen(c_folder) - 1] == '/'))
        {
          buf_strcpy(p, c_folder);
        }
        else
        {
          buf_printf(p, "%s/", NONULL(c_folder));
        }
 
        tail = s + 1;
        break;
      }
 
        /* elm compatibility, @ expands alias to user name */
 
      case '@':
      {
        struct AddressList *al = alias_lookup(s + 1);
        if (al && !TAILQ_EMPTY(al))
        {
          struct Email *e = email_new();
          e->env = mutt_env_new();
          mutt_addrlist_copy(&e->env->from, al, false);
          mutt_addrlist_copy(&e->env->to, al, false);
 
          buf_alloc(p, PATH_MAX);
          mutt_default_save(p, e);
 
          email_free(&e);
          /* Avoid infinite recursion if the resulting folder starts with '@' */
          if (*p->data != '@')
            recurse = true;
 
          tail = "";
        }
        break;
      }
 
      case '>':
      {
        const char *const c_mbox = cs_subset_string(NeoMutt->sub, "mbox");
        buf_strcpy(p, c_mbox);
        tail = s + 1;
        break;
      }
 
      case '<':
      {
        const char *const c_record = cs_subset_string(NeoMutt->sub, "record");
        buf_strcpy(p, c_record);
        tail = s + 1;
        break;
      }
 
      case '!':
      {
        if (s[1] == '!')
        {
          buf_strcpy(p, LastFolder);
          tail = s + 2;
        }
        else
        {
          const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
          buf_strcpy(p, c_spool_file);
          tail = s + 1;
        }
        break;
      }
 
      case '-':
      {
        buf_strcpy(p, LastFolder);
        tail = s + 1;
        break;
      }
 
      case '^':
      {
        buf_strcpy(p, CurrentFolder);
        tail = s + 1;
        break;
      }
 
      default:
      {
        buf_reset(p);
        tail = s;
      }
    }
 
    if (regex && *(buf_string(p)) && !recurse)
    {
      mutt_file_sanitize_regex(q, buf_string(p));
      buf_printf(tmp, "%s%s", buf_string(q), tail);
    }
    else
    {
      buf_printf(tmp, "%s%s", buf_string(p), tail);
    }
 
    buf_copy(buf, tmp);
  } while (recurse);
 
  buf_pool_release(&p);
  buf_pool_release(&q);
  buf_pool_release(&tmp);
 
  /* Rewrite IMAP path in canonical form - aids in string comparisons of
   * folders. May possibly fail, in which case buf should be the same. */
  if (imap_path_probe(buf_string(buf), NULL) == MUTT_IMAP)
    imap_path_canon(buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pretty_mailbox()

void pretty_mailbox

(

struct Buffer *

buf

)

Shorten a mailbox path using '~' or '='.

Parameters

buf	Buffer containing Mailbox name

Collapse the pathname using ~ or = when possible

Definition at line 428 of file muttlib.c.

{
  if (!buf || !buf->data)
    return;
 
  /* Ensure buffer is large enough for path manipulation operations.
   * The function will modify the string in-place, potentially shortening it.
   * buf_alloc() also guarantees buf->data is not NULL. */
  buf_alloc(buf, PATH_MAX);
 
  char *p = buf->data;
  char *q = buf->data;
  size_t len;
  enum UrlScheme scheme;
  char tmp[PATH_MAX] = { 0 };
 
  scheme = url_check_scheme(buf->data);
 
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
  if ((scheme == U_IMAP) || (scheme == U_IMAPS))
  {
    imap_pretty_mailbox(buf->data, buf->dsize, c_folder);
    goto done;
  }
 
  if (scheme == U_NOTMUCH)
    goto done;
 
  /* if buf is an url, only collapse path component */
  if (scheme != U_UNKNOWN)
  {
    p = strchr(buf->data, ':') + 1;
    if (mutt_strn_equal(p, "//", 2))
      q = strchr(p + 2, '/');
    if (!q)
      q = strchr(p, '\0');
    p = q;
  }
 
  /* cleanup path */
  if (strstr(p, "//") || strstr(p, "/./"))
  {
    /* first attempt to collapse the pathname, this is more
     * lightweight than realpath() and doesn't resolve links */
    while (*p)
    {
      if ((p[0] == '/') && (p[1] == '/'))
      {
        *q++ = '/';
        p += 2;
      }
      else if ((p[0] == '/') && (p[1] == '.') && (p[2] == '/'))
      {
        *q++ = '/';
        p += 3;
      }
      else
      {
        *q++ = *p++;
      }
    }
    *q = '\0';
  }
  else if (strstr(p, "..") && ((scheme == U_UNKNOWN) || (scheme == U_FILE)) &&
           realpath(p, tmp))
  {
    mutt_str_copy(p, tmp, buf->dsize - (p - buf->data));
  }
 
  if ((len = mutt_str_startswith(buf->data, c_folder)) && (buf->data[len] == '/'))
  {
    buf->data[0] = '=';
    memmove(buf->data + 1, buf->data + len, mutt_str_len(buf->data + len) + 1);
  }
  else if ((len = mutt_str_startswith(buf->data, NeoMutt->home_dir)) &&
           (buf->data[len] == '/'))
  {
    buf->data[0] = '~';
    memmove(buf->data + 1, buf->data + len, mutt_str_len(buf->data + len) + 1);
  }
 
done:
  buf_fix_dptr(buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

buf_sanitize_filename()

void buf_sanitize_filename	(	struct Buffer *	buf,
		const char *	path,
		short	slash )

Replace unsafe characters in a filename.

Parameters

buf	Buffer for the result
path	Filename to make safe
slash	Replace '/' characters too

Definition at line 913 of file muttlib.c.

{
  if (!buf || !path)
    return;
 
  buf_reset(buf);
 
  for (; *path; path++)
  {
    if ((slash && (*path == '/')) || !strchr(FilenameSafeChars, *path))
      buf_addch(buf, '_');
    else
      buf_addch(buf, *path);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

generate_save_path()

void generate_save_path	(	struct Buffer *	dest,
		const struct Address *	a )

Make a safe filename from an email address.

Parameters

dest	Buffer for the result
a	Address to use

The filename will be stripped of unsafe characters (/, space, etc) to make it safe.

Definition at line 608 of file muttlib.c.

{
  if (a && a->mailbox)
  {
    buf_copy(dest, a->mailbox);
    const bool c_save_address = cs_subset_bool(NeoMutt->sub, "save_address");
    if (!c_save_address)
    {
      char *p = strpbrk(dest->data, "%@");
      if (p)
      {
        *p = '\0';
        buf_fix_dptr(dest);
      }
    }
    mutt_str_lower(dest->data);
    /* Sanitize filename by replacing unsafe characters */
    for (char *p = dest->data; *p; p++)
      if ((*p == '/') || mutt_isspace(*p) || !IsPrint((unsigned char) *p))
        *p = '_';
  }
  else
  {
    buf_reset(dest);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_check_overwrite()

int mutt_check_overwrite	(	const char *	attname,
		const char *	path,
		struct Buffer *	fname,
		enum SaveAttach *	opt,
		char **	directory )

Ask the user if overwriting is necessary.

Parameters

[in]	attname	Attachment name
[in]	path	Path to save the file
[out]	fname	Buffer for filename
[out]	opt	Save option, see SaveAttach
[out]	directory	Directory to save under (OPTIONAL)

Return values

0	Success
-1	Abort
1	Error

Definition at line 524 of file muttlib.c.

{
  struct stat st = { 0 };
 
  buf_strcpy(fname, path);
  if (access(buf_string(fname), F_OK) != 0)
    return 0;
  if (stat(buf_string(fname), &st) != 0)
    return -1;
  if (S_ISDIR(st.st_mode))
  {
    enum QuadOption ans = MUTT_NO;
    if (directory)
    {
      switch (mw_multi_choice
              /* L10N: Means "The path you specified as the destination file is a directory."
                 See the msgid "Save to file: " (alias.c, recvattach.c)
                 These three letters correspond to the choices in the string.  */
              (_("File is a directory, save under it: (y)es, (n)o, (a)ll?"), _("yna")))
      {
        case 3: /* all */
          mutt_str_replace(directory, buf_string(fname));
          break;
        case 1: /* yes */
          FREE(directory);
          break;
        case -1: /* abort */
          FREE(directory);
          return -1;
        case 2: /* no */
          FREE(directory);
          return 1;
      }
    }
    /* L10N: Means "The path you specified as the destination file is a directory."
       See the msgid "Save to file: " (alias.c, recvattach.c) */
    else if ((ans = query_yesorno(_("File is a directory, save under it?"), MUTT_YES)) != MUTT_YES)
      return (ans == MUTT_NO) ? 1 : -1;
 
    struct Buffer *tmp = buf_pool_get();
    buf_strcpy(tmp, mutt_path_basename(NONULL(attname)));
    struct FileCompletionData cdata = { false, NULL, NULL, NULL, NULL };
    if ((mw_get_field(_("File under directory: "), tmp, MUTT_COMP_CLEAR,
                      HC_FILE, &CompleteFileOps, &cdata) != 0) ||
        buf_is_empty(tmp))
    {
      buf_pool_release(&tmp);
      return (-1);
    }
    buf_concat_path(fname, path, buf_string(tmp));
    buf_pool_release(&tmp);
  }
 
  if ((*opt == MUTT_SAVE_NO_FLAGS) && (access(buf_string(fname), F_OK) == 0))
  {
    char buf[4096] = { 0 };
    snprintf(buf, sizeof(buf), "%s - %s", buf_string(fname),
             // L10N: Options for: File %s exists, (o)verwrite, (a)ppend, or (c)ancel?
             _("File exists, (o)verwrite, (a)ppend, or (c)ancel?"));
    switch (mw_multi_choice(buf, _("oac")))
    {
      case -1: /* abort */
        return -1;
      case 3: /* cancel */
        return 1;
 
      case 2: /* append */
        *opt = MUTT_SAVE_APPEND;
        break;
      case 1: /* overwrite */
        break;
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_encode_path()

void mutt_encode_path	(	struct Buffer *	buf,
		const char *	src )

Convert a path to 'us-ascii'.

Parameters

buf	Buffer for the result
src	Path to convert (OPTIONAL)

If src is NULL, the path in buf will be converted in-place.

Definition at line 803 of file muttlib.c.

{
  char *p = mutt_str_dup(src);
  int rc = mutt_ch_convert_string(&p, cc_charset(), "us-ascii", MUTT_ICONV_NO_FLAGS);
  size_t len = buf_strcpy(buf, (rc == 0) ? NONULL(p) : NONULL(src));
 
  /* convert the path to POSIX "Portable Filename Character Set" */
  for (size_t i = 0; i < len; i++)
  {
    if (!mutt_isalnum(buf_at(buf, i)) && !strchr("/.-_", buf_at(buf, i)))
    {
      buf->data[i] = '_';
    }
  }
  FREE(&p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_gecos_name()

char * mutt_gecos_name	(	char *	dest,
		size_t	destlen,
		struct passwd *	pw )

Lookup a user's real name in /etc/passwd.

Parameters

dest	Buffer for the result
destlen	Length of buffer
pw	Passwd entry

Return values

ptr	Result buffer on success

Extract the real name from /etc/passwd's GECOS field. When set, honor the regular expression in $gecos_mask, otherwise assume that the GECOS field is a comma-separated list. Replace "&" by a capitalized version of the user's login name.

Definition at line 321 of file muttlib.c.

{
  regmatch_t pat_match[1] = { 0 };
  char *p = NULL;
 
  if (!pw || !pw->pw_gecos)
    return NULL;
 
  memset(dest, 0, destlen);
 
  const struct Regex *c_gecos_mask = cs_subset_regex(NeoMutt->sub, "gecos_mask");
  if (mutt_regex_capture(c_gecos_mask, pw->pw_gecos, 1, pat_match))
  {
    mutt_str_copy(dest, pw->pw_gecos + pat_match[0].rm_so,
                  MIN(pat_match[0].rm_eo - pat_match[0].rm_so + 1, destlen));
  }
  else if ((p = strchr(pw->pw_gecos, ',')))
  {
    mutt_str_copy(dest, pw->pw_gecos, MIN(destlen, p - pw->pw_gecos + 1));
  }
  else
  {
    mutt_str_copy(dest, pw->pw_gecos, destlen);
  }
 
  size_t pwnl = strlen(pw->pw_name);
 
  for (int idx = 0; dest[idx]; idx++)
  {
    if (dest[idx] == '&')
    {
      memmove(&dest[idx + pwnl], &dest[idx + 1],
              MAX((ssize_t) (destlen - idx - pwnl - 1), 0));
      memcpy(&dest[idx], pw->pw_name, MIN(destlen - idx - 1, pwnl));
      dest[idx] = mutt_toupper(dest[idx]);
    }
  }
 
  return dest;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_get_parent_path()

void mutt_get_parent_path	(	const char *	path,
		char *	buf,
		size_t	buflen )

Find the parent of a path (or mailbox)

Parameters

path	Path to use
buf	Buffer for the result
buflen	Length of buffer

Definition at line 867 of file muttlib.c.

{
  enum MailboxType mb_type = mx_path_probe(path);
 
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
  if (mb_type == MUTT_IMAP)
  {
    imap_get_parent_path(path, buf, buflen);
  }
  else if (mb_type == MUTT_NOTMUCH)
  {
    mutt_str_copy(buf, c_folder, buflen);
  }
  else
  {
    mutt_str_copy(buf, path, buflen);
    int n = mutt_str_len(buf);
    if (n == 0)
      return;
 
    /* remove any final trailing '/' */
    if (buf[n - 1] == '/')
      buf[n - 1] = '\0';
 
    /* Remove everything until the next slash */
    for (n--; ((n >= 0) && (buf[n] != '/')); n--)
      ; // do nothing
 
    if (n > 0)
    {
      buf[n] = '\0';
    }
    else
    {
      buf[0] = '/';
      buf[1] = '\0';
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_is_text_part()

bool mutt_is_text_part

(

const struct Body *

b

)

Is this part of an email in plain text?

Parameters

b	Part of an email

Return values

true	Part is in plain text

Definition at line 396 of file muttlib.c.

{
  int t = b->type;
  char *s = b->subtype;
 
  if (((WithCrypto & APPLICATION_PGP) != 0) && mutt_is_application_pgp(b))
    return false;
 
  if (t == TYPE_TEXT)
    return true;
 
  if (t == TYPE_MESSAGE)
  {
    if (mutt_istr_equal("delivery-status", s))
      return true;
  }
 
  if (((WithCrypto & APPLICATION_PGP) != 0) && (t == TYPE_APPLICATION))
  {
    if (mutt_istr_equal("pgp-keys", s))
      return true;
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_needs_mailcap()

bool mutt_needs_mailcap

(

struct Body *

b

)

Does this type need a mailcap entry do display.

Parameters

b	Attachment body to be displayed

Return values

true	NeoMutt requires a mailcap entry to display
false	otherwise

Definition at line 368 of file muttlib.c.

{
  switch (b->type)
  {
    case TYPE_TEXT:
      if (mutt_istr_equal("plain", b->subtype))
        return false;
      break;
    case TYPE_APPLICATION:
      if (((WithCrypto & APPLICATION_PGP) != 0) && mutt_is_application_pgp(b))
        return false;
      if (((WithCrypto & APPLICATION_SMIME) != 0) && mutt_is_application_smime(b))
        return false;
      break;
 
    case TYPE_MULTIPART:
    case TYPE_MESSAGE:
      return false;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_open_read()

FILE * mutt_open_read	(	const char *	path,
		pid_t *	thepid )

Run a command to read from.

Parameters

[in]	path	Path to command
[out]	thepid	PID of the command

Return values

ptr	File containing output of command

This function allows the user to specify a command to read stdout from in place of a normal file. If the last character in the string is a pipe (|), then we assume it is a command to run instead of a normal file.

Definition at line 645 of file muttlib.c.

{
  FILE *fp = NULL;
  struct stat st = { 0 };
 
  size_t len = mutt_str_len(path);
  if (len == 0)
  {
    return NULL;
  }
 
  if (path[len - 1] == '|')
  {
    /* read from a pipe */
 
    char *p = mutt_str_dup(path);
 
    p[len - 1] = 0;
    mutt_endwin();
    *thepid = filter_create(p, NULL, &fp, NULL, NeoMutt->env);
    FREE(&p);
  }
  else
  {
    if (stat(path, &st) < 0)
      return NULL;
    if (S_ISDIR(st.st_mode))
    {
      errno = EINVAL;
      return NULL;
    }
    fp = mutt_file_fopen(path, "r");
    *thepid = -1;
  }
  return fp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_save_confirm()

int mutt_save_confirm	(	const char *	s,
		struct stat *	st )

Ask the user to save.

Parameters

s	Save location
st	Timestamp

Return values

0	OK to proceed
-1	to abort
1	to retry

Definition at line 690 of file muttlib.c.

{
  int rc = 0;
 
  enum MailboxType type = mx_path_probe(s);
 
  if (type == MUTT_POP)
  {
    mutt_error(_("Can't save message to POP mailbox"));
    return 1;
  }
 
  if ((type != MUTT_MAILBOX_ERROR) && (type != MUTT_UNKNOWN) && (mx_access(s, W_OK) == 0))
  {
    const bool c_confirm_append = cs_subset_bool(NeoMutt->sub, "confirm_append");
    if (c_confirm_append)
    {
      struct Buffer *tmp = buf_pool_get();
      buf_printf(tmp, _("Append messages to %s?"), s);
      enum QuadOption ans = query_yesorno_help(buf_string(tmp), MUTT_YES,
                                               NeoMutt->sub, "confirm_append");
      if (ans == MUTT_NO)
        rc = 1;
      else if (ans == MUTT_ABORT)
        rc = -1;
      buf_pool_release(&tmp);
    }
  }
 
  if (type == MUTT_NNTP)
  {
    mutt_error(_("Can't save message to news server"));
    return 0;
  }
 
  if (stat(s, st) != -1)
  {
    if (type == MUTT_MAILBOX_ERROR)
    {
      mutt_error(_("%s is not a mailbox"), s);
      return 1;
    }
  }
  else if (type != MUTT_IMAP)
  {
    st->st_mtime = 0;
    st->st_atime = 0;
 
    /* pathname does not exist */
    if (errno == ENOENT)
    {
      const bool c_confirm_create = cs_subset_bool(NeoMutt->sub, "confirm_create");
      if (c_confirm_create)
      {
        struct Buffer *tmp = buf_pool_get();
        buf_printf(tmp, _("Create %s?"), s);
        enum QuadOption ans = query_yesorno_help(buf_string(tmp), MUTT_YES,
                                                 NeoMutt->sub, "confirm_create");
        if (ans == MUTT_NO)
          rc = 1;
        else if (ans == MUTT_ABORT)
          rc = -1;
        buf_pool_release(&tmp);
      }
 
      /* user confirmed with MUTT_YES or set `$confirm_create` */
      if (rc == 0)
      {
        /* create dir recursively */
        char *tmp_path = mutt_path_dirname(s);
        if (mutt_file_mkdir(tmp_path, S_IRWXU) == -1)
        {
          /* report failure & abort */
          mutt_perror("%s", s);
          FREE(&tmp_path);
          return 1;
        }
        FREE(&tmp_path);
      }
    }
    else
    {
      mutt_perror("%s", s);
      return 1;
    }
  }
 
  msgwin_clear_text(NULL);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sleep()

void mutt_sleep

(

short

s

)

Sleep for a while.

Parameters

s	Number of seconds to sleep

If the user config '$sleep_time' is larger, sleep that long instead.

Definition at line 787 of file muttlib.c.

{
  const short c_sleep_time = cs_subset_number(NeoMutt->sub, "sleep_time");
  if (c_sleep_time > s)
    sleep(c_sleep_time);
  else if (s)
    sleep(s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_str_pretty_size()

int mutt_str_pretty_size	(	struct Buffer *	buf,
		size_t	num )

Display an abbreviated size, like 3.4K.

Parameters

[out]	buf	Buffer for the result
[in]	num	Number to abbreviate

Return values

num	Bytes written to buf

Definition at line 935 of file muttlib.c.

{
  if (!buf)
    return 0;
 
  const bool c_size_show_bytes = cs_subset_bool(NeoMutt->sub, "size_show_bytes");
  const bool c_size_show_fractions = cs_subset_bool(NeoMutt->sub, "size_show_fractions");
  const bool c_size_show_mb = cs_subset_bool(NeoMutt->sub, "size_show_mb");
  const bool c_size_units_on_left = cs_subset_bool(NeoMutt->sub, "size_units_on_left");
 
  if (c_size_show_bytes && (num < 1024))
  {
    return buf_add_printf(buf, "%d", (int) num);
  }
 
  if (num == 0)
  {
    return buf_addstr(buf, c_size_units_on_left ? "K0" : "0K");
  }
 
  if (c_size_show_fractions && (num < 10189)) /* 0.1K - 9.9K */
  {
    return buf_add_printf(buf, c_size_units_on_left ? "K%3.1f" : "%3.1fK",
                          (num < 103) ? 0.1 : (num / 1024.0));
  }
 
  if (!c_size_show_mb || (num < 1023949)) /* 10K - 999K */
  {
    /* 51 is magic which causes 10189/10240 to be rounded up to 10 */
    return buf_add_printf(buf, c_size_units_on_left ? ("K%zu") : ("%zuK"), (num + 51) / 1024);
  }
 
  if (c_size_show_fractions && (num < 10433332)) /* 1.0M - 9.9M */
  {
    return buf_add_printf(buf, c_size_units_on_left ? "M%3.1f" : "%3.1fM", num / 1048576.0);
  }
 
  /* 10M+ -- (10433332 + 52428) / 1048576 = 10 */
  return buf_add_printf(buf, c_size_units_on_left ? ("M%zu") : ("%zuM"),
                        (num + 52428) / 1048576);
}

Here is the call graph for this function:

Here is the caller graph for this function: