file.h File Reference

File management functions. More...

#include "config.h"
#include <dirent.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/types.h>

Include dependency graph for file.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	timespec
	Time value with nanosecond precision. More...
struct	MuttFileIter
	State record for mutt_file_iter_line() More...

Macros
#define	MUTT_RL_NO_FLAGS   0
	No flags are set. More...
#define	MUTT_RL_CONT   (1 << 0)
	-continuation More...
#define	MUTT_RL_EOL   (1 << 1)
	don't strip \n / \r\n More...
#define	mutt_file_mkstemp()   mutt_file_mkstemp_full(__FILE__, __LINE__, __func__)

Typedefs
typedef uint8_t	ReadLineFlags
	Flags for mutt_file_read_line(), e.g. MUTT_RL_CONT. More...
typedef bool(*	mutt_file_map_t) (char *line, int line_num, void *user_data)

Enumerations
enum	MuttStatType { MUTT_STAT_ATIME , MUTT_STAT_MTIME , MUTT_STAT_CTIME }
	Flags for mutt_file_get_stat_timespec. More...
enum	MuttOpenDirMode { MUTT_OPENDIR_NONE , MUTT_OPENDIR_CREATE }
	Mode flag for mutt_file_opendir() More...

Functions
int	mutt_file_check_empty (const char *path)
	Is the mailbox empty. More...
int	mutt_file_chmod (const char *path, mode_t mode)
	Set permissions of a file. More...
int	mutt_file_chmod_add (const char *path, mode_t mode)
	Add permissions to a file. More...
int	mutt_file_chmod_add_stat (const char *path, mode_t mode, struct stat *st)
	Add permissions to a file. More...
int	mutt_file_chmod_rm (const char *path, mode_t mode)
	Remove permissions from a file. More...
int	mutt_file_chmod_rm_stat (const char *path, mode_t mode, struct stat *st)
	Remove permissions from a file. More...
int	mutt_file_copy_bytes (FILE *fp_in, FILE *fp_out, size_t size)
	Copy some content from one file to another. More...
int	mutt_file_copy_stream (FILE *fp_in, FILE *fp_out)
	Copy the contents of one file into another. More...
time_t	mutt_file_decrease_mtime (const char *fp, struct stat *st)
	Decrease a file's modification time by 1 second. More...
void	mutt_file_expand_fmt (struct Buffer *dest, const char *fmt, const char *src)
	Replace s in a string with a filename. More...
void	mutt_file_expand_fmt_quote (char *dest, size_t destlen, const char *fmt, const char *src)
int	mutt_file_fclose (FILE **fp)
	Close a FILE handle (and NULL the pointer) More...
FILE *	mutt_file_fopen (const char *path, const char *mode)
	Call fopen() safely. More...
int	mutt_file_fsync_close (FILE **fp)
	Flush the data, before closing a file (and NULL the pointer) More...
long	mutt_file_get_size (const char *path)
	Get the size of a file. More...
long	mutt_file_get_size_fp (FILE *fp)
	Get the size of a file. More...
void	mutt_file_get_stat_timespec (struct timespec *dest, struct stat *st, enum MuttStatType type)
	Read the stat() time into a time value. More...
bool	mutt_file_iter_line (struct MuttFileIter *iter, FILE *fp, ReadLineFlags flags)
	Iterate over the lines from an open file pointer. More...
int	mutt_file_lock (int fd, bool excl, bool timeout)
	(Try to) Lock a file using fcntl() More...
bool	mutt_file_map_lines (mutt_file_map_t func, void *user_data, FILE *fp, ReadLineFlags flags)
	Process lines of text read from a file pointer. More...
int	mutt_file_mkdir (const char *path, mode_t mode)
	Recursively create directories. More...
FILE *	mutt_file_mkstemp_full (const char *file, int line, const char *func)
	Create temporary file safely. More...
int	mutt_file_open (const char *path, uint32_t flags)
	Open a file. More...
DIR *	mutt_file_opendir (const char *path, enum MuttOpenDirMode mode)
	Open a directory. More...
size_t	mutt_file_quote_filename (const char *filename, char *buf, size_t buflen)
	Quote a filename to survive the shell's quoting rules. More...
char *	mutt_file_read_keyword (const char *file, char *buf, size_t buflen)
	Read a keyword from a file. More...
char *	mutt_file_read_line (char *line, size_t *size, FILE *fp, int *line_num, ReadLineFlags flags)
	Read a line from a file. More...
int	mutt_file_rename (const char *oldfile, const char *newfile)
	Rename a file. More...
int	mutt_file_rmtree (const char *path)
	Recursively remove a directory. More...
const char *	mutt_file_rotate (const char *path, int num)
	Rotate a set of numbered files. More...
int	mutt_file_safe_rename (const char *src, const char *target)
	NFS-safe renaming of files. More...
void	mutt_file_sanitize_filename (char *path, bool slash)
	Replace unsafe characters in a filename. More...
int	mutt_file_sanitize_regex (struct Buffer *dest, const char *src)
	Escape any regex-magic characters in a string. More...
bool	mutt_file_seek (FILE *fp, LOFF_T offset, int whence)
	Wrapper for fseeko with error handling. More...
void	mutt_file_set_mtime (const char *from, const char *to)
	Set the modification time of one file from another. More...
int	mutt_file_stat_compare (struct stat *st1, enum MuttStatType st1_type, struct stat *st2, enum MuttStatType st2_type)
	Compare two stat infos. More...
int	mutt_file_stat_timespec_compare (struct stat *st, enum MuttStatType type, struct timespec *b)
	Compare stat info with a time value. More...
int	mutt_file_symlink (const char *oldpath, const char *newpath)
	Create a symlink. More...
int	mutt_file_timespec_compare (struct timespec *a, struct timespec *b)
	Compare to time values. More...
void	mutt_file_touch_atime (int fd)
	Set the access time to current time. More...
void	mutt_file_unlink (const char *s)
	Delete a file, carefully. More...
void	mutt_file_unlink_empty (const char *path)
	Delete a file if it's empty. More...
int	mutt_file_unlock (int fd)
	Unlock a file previously locked by mutt_file_lock() More...
void	mutt_file_resolve_symlink (struct Buffer *buf)
	Resolve a symlink in place. More...
void	mutt_buffer_quote_filename (struct Buffer *buf, const char *filename, bool add_outer)
	Quote a filename to survive the shell's quoting rules. More...
void	mutt_buffer_file_expand_fmt_quote (struct Buffer *dest, const char *fmt, const char *src)
	Replace s in a string with a filename. More...

Variables
const char	filename_safe_chars []

Detailed Description

File management functions.

Authors

• Richard Russon

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 file.h.

Macro Definition Documentation

MUTT_RL_NO_FLAGS

#define MUTT_RL_NO_FLAGS   0

No flags are set.

Definition at line 39 of file file.h.

MUTT_RL_CONT

#define MUTT_RL_CONT   (1 << 0)

-continuation

Definition at line 40 of file file.h.

MUTT_RL_EOL

#define MUTT_RL_EOL   (1 << 1)

don't strip \n / \r\n

Definition at line 41 of file file.h.

mutt_file_mkstemp

#define mutt_file_mkstemp

(

)

mutt_file_mkstemp_full(__FILE__, __LINE__, __func__)

Definition at line 122 of file file.h.

Typedef Documentation

ReadLineFlags

typedef uint8_t ReadLineFlags

Flags for mutt_file_read_line(), e.g. MUTT_RL_CONT.

Definition at line 38 of file file.h.

mutt_file_map_t

typedef bool(* mutt_file_map_t) (char *line, int line_num, void *user_data)

Definition at line 98 of file file.h.

Enumeration Type Documentation

MuttStatType

enum MuttStatType

Flags for mutt_file_get_stat_timespec.

These represent filesystem timestamps returned by stat()

Enumerator
MUTT_STAT_ATIME	File/dir's atime - last accessed time.
MUTT_STAT_MTIME	File/dir's mtime - last modified time.
MUTT_STAT_CTIME	File/dir's ctime - creation time.

Definition at line 61 of file file.h.

{
  MUTT_STAT_ATIME, 
  MUTT_STAT_MTIME, 
  MUTT_STAT_CTIME, 
};

MuttOpenDirMode

enum MuttOpenDirMode

Mode flag for mutt_file_opendir()

Enumerator
MUTT_OPENDIR_NONE	Plain opendir()
MUTT_OPENDIR_CREATE	Create the directory if it doesn't exist.

Definition at line 71 of file file.h.

{
  MUTT_OPENDIR_NONE,   
  MUTT_OPENDIR_CREATE, 
};

Function Documentation

mutt_file_check_empty()

int mutt_file_check_empty

(

const char *

path

)

Is the mailbox empty.

Parameters

path	Path to mailbox

Return values

1	Mailbox is empty
0	Mailbox is not empty
-1	Error

Definition at line 1484 of file file.c.

{
  if (!path)
    return -1;
 
  struct stat st = { 0 };
  if (stat(path, &st) == -1)
    return -1;
 
  return st.st_size == 0;
}

Here is the caller graph for this function:

mutt_file_chmod()

int mutt_file_chmod	(	const char *	path,
		mode_t	mode
	)

Set permissions of a file.

Parameters

path	Filename
mode	the permissions to set

Return values

num	Same as chmod(2)

This is essentially chmod(path, mode), see chmod(2).

Definition at line 1114 of file file.c.

{
  if (!path)
    return -1;
 
  return chmod(path, mode);
}

mutt_file_chmod_add()

int mutt_file_chmod_add	(	const char *	path,
		mode_t	mode
	)

Add permissions to a file.

Parameters

path	Filename
mode	the permissions to add

Return values

num	Same as chmod(2)

Adds the given permissions to the file. Permissions not mentioned in mode will stay as they are. This function resembles the chmod ugoa+rwxXst command family. Example:

mutt_file_chmod_add(path, S_IWUSR | S_IWGRP | S_IWOTH);

will add write permissions to path but does not alter read and other permissions.

See also

mutt_file_chmod_add_stat()

Definition at line 1139 of file file.c.

{
  return mutt_file_chmod_add_stat(path, mode, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_chmod_add_stat()

int mutt_file_chmod_add_stat	(	const char *	path,
		mode_t	mode,
		struct stat *	st
	)

Add permissions to a file.

Parameters

path	Filename
mode	the permissions to add
st	struct stat for the file (optional)

Return values

num	Same as chmod(2)

Same as mutt_file_chmod_add() but saves a system call to stat() if a non-NULL stat structure is given. Useful if the stat structure of the file was retrieved before by the calling code. Example:

struct stat st;
stat(path, &st);
// ... do something else with st ...
mutt_file_chmod_add_stat(path, S_IWUSR | S_IWGRP | S_IWOTH, st);

See also

mutt_file_chmod_add()

Definition at line 1162 of file file.c.

{
  if (!path)
    return -1;
 
  struct stat st2 = { 0 };
 
  if (!st)
  {
    if (stat(path, &st2) == -1)
      return -1;
    st = &st2;
  }
  return chmod(path, st->st_mode | mode);
}

Here is the caller graph for this function:

mutt_file_chmod_rm()

int mutt_file_chmod_rm	(	const char *	path,
		mode_t	mode
	)

Remove permissions from a file.

Parameters

path	Filename
mode	the permissions to remove

Return values

num	Same as chmod(2)

Removes the given permissions from the file. Permissions not mentioned in mode will stay as they are. This function resembles the chmod ugoa-rwxXst command family. Example:

mutt_file_chmod_rm(path, S_IWUSR | S_IWGRP | S_IWOTH);

will remove write permissions from path but does not alter read and other permissions.

See also

mutt_file_chmod_rm_stat()

Definition at line 1195 of file file.c.

{
  return mutt_file_chmod_rm_stat(path, mode, NULL);
}

Here is the call graph for this function:

mutt_file_chmod_rm_stat()

int mutt_file_chmod_rm_stat	(	const char *	path,
		mode_t	mode,
		struct stat *	st
	)

Remove permissions from a file.

Parameters

path	Filename
mode	the permissions to remove
st	struct stat for the file (optional)

Return values

num	Same as chmod(2)

Same as mutt_file_chmod_rm() but saves a system call to stat() if a non-NULL stat structure is given. Useful if the stat structure of the file was retrieved before by the calling code. Example:

struct stat st;
stat(path, &st);
// ... do something else with st ...
mutt_file_chmod_rm_stat(path, S_IWUSR | S_IWGRP | S_IWOTH, st);

See also

mutt_file_chmod_rm()

Definition at line 1218 of file file.c.

{
  if (!path)
    return -1;
 
  struct stat st2 = { 0 };
 
  if (!st)
  {
    if (stat(path, &st2) == -1)
      return -1;
    st = &st2;
  }
  return chmod(path, st->st_mode & ~mode);
}

Here is the caller graph for this function:

mutt_file_copy_bytes()

int mutt_file_copy_bytes	(	FILE *	fp_in,
		FILE *	fp_out,
		size_t	size
	)

Copy some content from one file to another.

Parameters

fp_in	Source file
fp_out	Destination file
size	Maximum number of bytes to copy

Return values

0	Success
-1	Error, see errno

Definition at line 229 of file file.c.

{
  if (!fp_in || !fp_out)
    return -1;
 
  while (size > 0)
  {
    char buf[2048] = { 0 };
    size_t chunk = (size > sizeof(buf)) ? sizeof(buf) : size;
    chunk = fread(buf, 1, chunk, fp_in);
    if (chunk < 1)
      break;
    if (fwrite(buf, 1, chunk, fp_out) != chunk)
      return -1;
 
    size -= chunk;
  }
 
  if (fflush(fp_out) != 0)
    return -1;
  return 0;
}

Here is the caller graph for this function:

mutt_file_copy_stream()

int mutt_file_copy_stream	(	FILE *	fp_in,
		FILE *	fp_out
	)

Copy the contents of one file into another.

Parameters

fp_in	Source file
fp_out	Destination file

Return values

n	Success, number of bytes copied
-1	Error, see errno

Definition at line 259 of file file.c.

{
  if (!fp_in || !fp_out)
    return -1;
 
  size_t total = 0;
  size_t l;
  char buf[1024] = { 0 };
 
  while ((l = fread(buf, 1, sizeof(buf), fp_in)) > 0)
  {
    if (fwrite(buf, 1, l, fp_out) != l)
      return -1;
    total += l;
  }
 
  if (fflush(fp_out) != 0)
    return -1;
  return total;
}

Here is the caller graph for this function:

mutt_file_decrease_mtime()

time_t mutt_file_decrease_mtime	(	const char *	fp,
		struct stat *	st
	)

Decrease a file's modification time by 1 second.

Parameters

fp	Filename
st	struct stat for the file (optional)

Return values

num	Updated Unix mtime
-1	Error, see errno

If a file's mtime is NOW, then set it to 1 second in the past.

Definition at line 1035 of file file.c.

{
  if (!fp)
    return -1;
 
  struct utimbuf utim;
  struct stat st2 = { 0 };
  time_t mtime;
 
  if (!st)
  {
    if (stat(fp, &st2) == -1)
      return -1;
    st = &st2;
  }
 
  mtime = st->st_mtime;
  if (mtime == mutt_date_now())
  {
    mtime -= 1;
    utim.actime = mtime;
    utim.modtime = mtime;
    int rc;
    do
    {
      rc = utime(fp, &utim);
    } while ((rc == -1) && (errno == EINTR));
 
    if (rc == -1)
      return -1;
  }
 
  return mtime;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_expand_fmt()

void mutt_file_expand_fmt	(	struct Buffer *	dest,
		const char *	fmt,
		const char *	src
	)

Replace s in a string with a filename.

Parameters

dest	Buffer for the result
fmt	printf-like format string
src	Filename to substitute

Definition at line 1519 of file file.c.

{
  if (!dest || !fmt || !src)
    return;
 
  const char *p = NULL;
  bool found = false;
 
  mutt_buffer_reset(dest);
 
  for (p = fmt; *p; p++)
  {
    if (*p == '%')
    {
      switch (p[1])
      {
        case '%':
          mutt_buffer_addch(dest, *p++);
          break;
        case 's':
          found = true;
          mutt_buffer_addstr(dest, src);
          p++;
          break;
        default:
          mutt_buffer_addch(dest, *p);
          break;
      }
    }
    else
    {
      mutt_buffer_addch(dest, *p);
    }
  }
 
  if (!found)
  {
    mutt_buffer_addch(dest, ' ');
    mutt_buffer_addstr(dest, src);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_expand_fmt_quote()

void mutt_file_expand_fmt_quote	(	char *	dest,
		size_t	destlen,
		const char *	fmt,
		const char *	src
	)

mutt_file_fclose()

int mutt_file_fclose

(

FILE **

fp

)

Close a FILE handle (and NULL the pointer)

Parameters

[out]

fp

FILE handle to close

Return values

0	Success
EOF	Error, see errno

Definition at line 151 of file file.c.

{
  if (!fp || !*fp)
    return 0;
 
  int rc = fclose(*fp);
  *fp = NULL;
  return rc;
}

mutt_file_fopen()

FILE * mutt_file_fopen	(	const char *	path,
		const char *	mode
	)

Call fopen() safely.

Parameters

path	Filename
mode	Mode e.g. "r" readonly; "w" read-write

Return values

ptr	FILE handle
NULL	Error, see errno

When opening files for writing, make sure the file doesn't already exist to avoid race conditions.

Definition at line 634 of file file.c.

{
  if (!path || !mode)
    return NULL;
 
  if (mode[0] == 'w')
  {
    uint32_t flags = O_CREAT | O_EXCL | O_NOFOLLOW;
 
    if (mode[1] == '+')
      flags |= O_RDWR;
    else
      flags |= O_WRONLY;
 
    int fd = mutt_file_open(path, flags);
    if (fd < 0)
      return NULL;
 
    return fdopen(fd, mode);
  }
  else
    return fopen(path, mode);
}

Here is the call graph for this function:

mutt_file_fsync_close()

int mutt_file_fsync_close

(

FILE **

fp

)

Flush the data, before closing a file (and NULL the pointer)

Parameters

[out]

fp

FILE handle to close

Return values

0	Success
EOF	Error, see errno

Definition at line 167 of file file.c.

{
  if (!fp || !*fp)
    return 0;
 
  int rc = 0;
 
  if (fflush(*fp) || fsync(fileno(*fp)))
  {
    int save_errno = errno;
    rc = -1;
    mutt_file_fclose(fp);
    errno = save_errno;
  }
  else
    rc = mutt_file_fclose(fp);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_get_size()

long mutt_file_get_size

(

const char *

path

)

Get the size of a file.

Parameters

path	File to measure

Return values

num	Size in bytes
0	Error

Definition at line 1567 of file file.c.

{
  if (!path)
    return 0;
 
  struct stat st = { 0 };
  if (stat(path, &st) != 0)
    return 0;
 
  return st.st_size;
}

Here is the caller graph for this function:

mutt_file_get_size_fp()

long mutt_file_get_size_fp

(

FILE *

fp

)

Get the size of a file.

Parameters

fp	FILE* to measure

Return values

num	Size in bytes
0	Error

Definition at line 1585 of file file.c.

{
  if (!fp)
    return 0;
 
  struct stat st = { 0 };
  if (fstat(fileno(fp), &st) != 0)
    return 0;
 
  return st.st_size;
}

Here is the caller graph for this function:

mutt_file_get_stat_timespec()

void mutt_file_get_stat_timespec	(	struct timespec *	dest,
		struct stat *	st,
		enum MuttStatType	type
	)

Read the stat() time into a time value.

Parameters

dest	Time value to populate
st	stat info
type	Type of stat info to read, e.g. MUTT_STAT_ATIME

Definition at line 1627 of file file.c.

{
  if (!dest || !st)
    return;
 
  dest->tv_sec = 0;
  dest->tv_nsec = 0;
 
  switch (type)
  {
    case MUTT_STAT_ATIME:
      dest->tv_sec = st->st_atime;
#ifdef HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC
      dest->tv_nsec = st->st_atim.tv_nsec;
#endif
      break;
    case MUTT_STAT_MTIME:
      dest->tv_sec = st->st_mtime;
#ifdef HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
      dest->tv_nsec = st->st_mtim.tv_nsec;
#endif
      break;
    case MUTT_STAT_CTIME:
      dest->tv_sec = st->st_ctime;
#ifdef HAVE_STRUCT_STAT_ST_CTIM_TV_NSEC
      dest->tv_nsec = st->st_ctim.tv_nsec;
#endif
      break;
  }
}

Here is the caller graph for this function:

mutt_file_iter_line()

bool mutt_file_iter_line	(	struct MuttFileIter *	iter,
		FILE *	fp,
		ReadLineFlags	flags
	)

Iterate over the lines from an open file pointer.

Parameters

iter	State of iteration including ptr to line
fp	File pointer to read from
flags	Same as mutt_file_read_line()

Return values

true	Data read
false	On eof

This is a slightly cleaner interface for mutt_file_read_line() which avoids the eternal C loop initialization ugliness. Use like this:

struct MuttFileIter iter = { 0 };
while (mutt_file_iter_line(&iter, fp, flags))
{
  do_stuff(iter.line, iter.line_num);
}

Definition at line 817 of file file.c.

{
  if (!iter)
    return false;
 
  char *p = mutt_file_read_line(iter->line, &iter->size, fp, &iter->line_num, flags);
  if (!p)
    return false;
  iter->line = p;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_lock()

int mutt_file_lock	(	int	fd,
		bool	excl,
		bool	timeout
	)

(Try to) Lock a file using fcntl()

Parameters

fd	File descriptor to file
excl	If true, try to lock exclusively
timeout	If true, Retry MAX_LOCK_ATTEMPTS times

Return values

0	Success
-1	Failure

Use fcntl() to lock a file.

Use mutt_file_unlock() to unlock the file.

Definition at line 1247 of file file.c.

{
  struct stat st = { 0 }, prev_sb = { 0 };
  int count = 0;
  int attempt = 0;
 
  struct flock lck;
  memset(&lck, 0, sizeof(struct flock));
  lck.l_type = excl ? F_WRLCK : F_RDLCK;
  lck.l_whence = SEEK_SET;
 
  while (fcntl(fd, F_SETLK, &lck) == -1)
  {
    mutt_debug(LL_DEBUG1, "fcntl errno %d\n", errno);
    if ((errno != EAGAIN) && (errno != EACCES))
    {
      mutt_perror("fcntl");
      return -1;
    }
 
    if (fstat(fd, &st) != 0)
      st.st_size = 0;
 
    if (count == 0)
      prev_sb = st;
 
    /* only unlock file if it is unchanged */
    if ((prev_sb.st_size == st.st_size) && (++count >= (timeout ? MAX_LOCK_ATTEMPTS : 0)))
    {
      if (timeout)
        mutt_error(_("Timeout exceeded while attempting fcntl lock"));
      return -1;
    }
 
    prev_sb = st;
 
    mutt_message(_("Waiting for fcntl lock... %d"), ++attempt);
    sleep(1);
  }
 
  return 0;
}

Here is the caller graph for this function:

mutt_file_map_lines()

bool mutt_file_map_lines	(	mutt_file_map_t	func,
		void *	user_data,
		FILE *	fp,
		ReadLineFlags	flags
	)

Process lines of text read from a file pointer.

Parameters

func	Callback function to call for each line, see mutt_file_map_t
user_data	Arbitrary data passed to "func"
fp	File pointer to read from
flags	Same as mutt_file_read_line()

Return values

true	All data mapped
false	"func" returns false

Definition at line 838 of file file.c.

{
  if (!func || !fp)
    return false;
 
  struct MuttFileIter iter = { 0 };
  while (mutt_file_iter_line(&iter, fp, flags))
  {
    if (!(*func)(iter.line, iter.line_num, user_data))
    {
      FREE(&iter.line);
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_mkdir()

int mutt_file_mkdir	(	const char *	path,
		mode_t	mode
	)

Recursively create directories.

Parameters

path	Directories to create
mode	Permissions for final directory

Return values

0	Success
-1	Error (errno set)

Create a directory, creating the parents if necessary. (like mkdir -p)

Note

The permissions are only set on the final directory. The permissions of any parent directories are determined by the umask. (This is how "mkdir -p" behaves)

Definition at line 946 of file file.c.

{
  if (!path || (*path == '\0'))
  {
    errno = EINVAL;
    return -1;
  }
 
  errno = 0;
  char tmp_path[PATH_MAX] = { 0 };
  const size_t len = strlen(path);
 
  if (len >= sizeof(tmp_path))
  {
    errno = ENAMETOOLONG;
    return -1;
  }
 
  struct stat st = { 0 };
  if ((stat(path, &st) == 0) && S_ISDIR(st.st_mode))
    return 0;
 
  /* Create a mutable copy */
  mutt_str_copy(tmp_path, path, sizeof(tmp_path));
 
  for (char *p = tmp_path + 1; *p; p++)
  {
    if (*p != '/')
      continue;
 
    /* Temporarily truncate the path */
    *p = '\0';
 
    if ((mkdir(tmp_path, S_IRWXU | S_IRWXG | S_IRWXO) != 0) && (errno != EEXIST))
      return -1;
 
    *p = '/';
  }
 
  if ((mkdir(tmp_path, mode) != 0) && (errno != EEXIST))
    return -1;
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_mkstemp_full()

FILE * mutt_file_mkstemp_full	(	const char *	file,
		int	line,
		const char *	func
	)

Create temporary file safely.

Parameters

file	Source file of caller
line	Source line number of caller
func	Function name of caller

Return values

ptr	FILE handle
NULL	Error, see errno

Create and immediately unlink a temp file using mkstemp().

Definition at line 1001 of file file.c.

{
  char name[PATH_MAX] = { 0 };
 
  const char *const c_tmp_dir = cs_subset_path(NeoMutt->sub, "tmp_dir");
  int n = snprintf(name, sizeof(name), "%s/neomutt-XXXXXX", NONULL(c_tmp_dir));
  if (n < 0)
    return NULL;
 
  int fd = mkstemp(name);
  if (fd == -1)
    return NULL;
 
  FILE *fp = fdopen(fd, "w+");
 
  if ((unlink(name) != 0) && (errno != ENOENT))
  {
    mutt_file_fclose(&fp);
    return NULL;
  }
 
  MuttLogger(0, file, line, func, 1, "created temp file '%s'\n", name);
  return fp;
}

Here is the call graph for this function:

mutt_file_open()

int mutt_file_open	(	const char *	path,
		uint32_t	flags
	)

Open a file.

Parameters

path	Pathname to open
flags	Flags, e.g. O_EXCL

Return values

>0	Success, file handle
-1	Error

Definition at line 548 of file file.c.

{
  if (!path)
    return -1;
 
  int fd;
  struct Buffer safe_file = mutt_buffer_make(0);
  struct Buffer safe_dir = mutt_buffer_make(0);
 
  if (flags & O_EXCL)
  {
    mutt_buffer_alloc(&safe_file, PATH_MAX);
    mutt_buffer_alloc(&safe_dir, PATH_MAX);
 
    if (mkwrapdir(path, &safe_file, &safe_dir) == -1)
    {
      fd = -1;
      goto cleanup;
    }
 
    fd = open(mutt_buffer_string(&safe_file), flags, 0600);
    if (fd < 0)
    {
      rmdir(mutt_buffer_string(&safe_dir));
      goto cleanup;
    }
 
    /* NFS and I believe cygwin do not handle movement of open files well */
    close(fd);
    if (put_file_in_place(path, mutt_buffer_string(&safe_file),
                          mutt_buffer_string(&safe_dir)) == -1)
    {
      fd = -1;
      goto cleanup;
    }
  }
 
  fd = open(path, flags & ~O_EXCL, 0600);
  if (fd < 0)
    goto cleanup;
 
  /* make sure the file is not symlink */
  struct stat st_old = { 0 };
  struct stat st_new = { 0 };
  if (((lstat(path, &st_old) < 0) || (fstat(fd, &st_new) < 0)) ||
      !compare_stat(&st_old, &st_new))
  {
    close(fd);
    fd = -1;
    goto cleanup;
  }
 
cleanup:
  mutt_buffer_dealloc(&safe_file);
  mutt_buffer_dealloc(&safe_dir);
 
  return fd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_opendir()

DIR * mutt_file_opendir	(	const char *	path,
		enum MuttOpenDirMode	mode
	)

Open a directory.

Parameters

path	Directory path
mode	See MuttOpenDirMode

Return values

ptr	DIR handle
NULL	Error, see errno

Definition at line 614 of file file.c.

{
  if ((mode == MUTT_OPENDIR_CREATE) && (mutt_file_mkdir(path, S_IRWXU) == -1))
  {
    return NULL;
  }
  errno = 0;
  return opendir(path);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_quote_filename()

size_t mutt_file_quote_filename	(	const char *	filename,
		char *	buf,
		size_t	buflen
	)

Quote a filename to survive the shell's quoting rules.

Parameters

filename	String to convert
buf	Buffer for the result
buflen	Length of buffer

Return values

num	Bytes written to the buffer

From the Unix programming FAQ by way of Liviu.

Definition at line 864 of file file.c.

{
  if (!buf)
    return 0;
 
  if (!filename)
  {
    *buf = '\0';
    return 0;
  }
 
  size_t j = 0;
 
  /* leave some space for the trailing characters. */
  buflen -= 6;
 
  buf[j++] = '\'';
 
  for (size_t i = 0; (j < buflen) && filename[i]; i++)
  {
    if ((filename[i] == '\'') || (filename[i] == '`'))
    {
      buf[j++] = '\'';
      buf[j++] = '\\';
      buf[j++] = filename[i];
      buf[j++] = '\'';
    }
    else
      buf[j++] = filename[i];
  }
 
  buf[j++] = '\'';
  buf[j] = '\0';
 
  return j;
}

Here is the caller graph for this function:

mutt_file_read_keyword()

char * mutt_file_read_keyword	(	const char *	file,
		char *	buf,
		size_t	buflen
	)

Read a keyword from a file.

Parameters

file	File to read
buf	Buffer to store the keyword
buflen	Length of the buf

Return values

ptr	Start of the keyword

Read one line from the start of a file. Skip any leading whitespace and extract the first token.

Definition at line 1454 of file file.c.

{
  FILE *fp = mutt_file_fopen(file, "r");
  if (!fp)
    return NULL;
 
  buf = fgets(buf, buflen, fp);
  mutt_file_fclose(&fp);
 
  if (!buf)
    return NULL;
 
  SKIPWS(buf);
  char *start = buf;
 
  while ((*buf != '\0') && !isspace(*buf))
    buf++;
 
  *buf = '\0';
 
  return start;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_read_line()

char * mutt_file_read_line	(	char *	line,
		size_t *	size,
		FILE *	fp,
		int *	line_num,
		ReadLineFlags	flags
	)

Read a line from a file.

Parameters

[out]	line	Buffer allocated on the head (optional)
[in]	size	Length of buffer
[in]	fp	File to read
[out]	line_num	Current line number (optional)
[in]	flags	Flags, e.g. MUTT_RL_CONT

Return values

ptr	The allocated string

Read a line from "fp" into the dynamically allocated "line", increasing "line" if necessary. The ending "\n" or "\r\n" is removed. If a line ends with "\", this char and the linefeed is removed, and the next line is read too.

Definition at line 736 of file file.c.

{
  if (!size || !fp)
    return NULL;
 
  size_t offset = 0;
  char *ch = NULL;
 
  if (!line)
  {
    *size = 256;
    line = mutt_mem_malloc(*size);
  }
 
  while (true)
  {
    if (!fgets(line + offset, *size - offset, fp))
    {
      FREE(&line);
      return NULL;
    }
    ch = strchr(line + offset, '\n');
    if (ch)
    {
      if (line_num)
        (*line_num)++;
      if (flags & MUTT_RL_EOL)
        return line;
      *ch = '\0';
      if ((ch > line) && (*(ch - 1) == '\r'))
        *--ch = '\0';
      if (!(flags & MUTT_RL_CONT) || (ch == line) || (*(ch - 1) != '\\'))
        return line;
      offset = ch - line - 1;
    }
    else
    {
      int c;
      c = getc(fp); /* This is kind of a hack. We want to know if the
                        char at the current point in the input stream is EOF.
                        feof() will only tell us if we've already hit EOF, not
                        if the next character is EOF. So, we need to read in
                        the next character and manually check if it is EOF. */
      if (c == EOF)
      {
        /* The last line of fp isn't \n terminated */
        if (line_num)
          (*line_num)++;
        return line;
      }
      else
      {
        ungetc(c, fp); /* undo our damage */
        /* There wasn't room for the line -- increase "line" */
        offset = *size - 1; /* overwrite the terminating 0 */
        *size += 256;
        mutt_mem_realloc(&line, *size);
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_rename()

int mutt_file_rename	(	const char *	oldfile,
		const char *	newfile
	)

Rename a file.

Parameters

oldfile	Old filename
newfile	New filename

Return values

0	Success
1	Old file doesn't exist
2	New file already exists
3	Some other error

Note

on access(2) use No dangling symlink problems here due to mutt_file_fopen().

Definition at line 1419 of file file.c.

{
  if (!oldfile || !newfile)
    return -1;
  if (access(oldfile, F_OK) != 0)
    return 1;
  if (access(newfile, F_OK) == 0)
    return 2;
 
  FILE *fp_old = fopen(oldfile, "r");
  if (!fp_old)
    return 3;
  FILE *fp_new = mutt_file_fopen(newfile, "w");
  if (!fp_new)
  {
    mutt_file_fclose(&fp_old);
    return 3;
  }
  mutt_file_copy_stream(fp_old, fp_new);
  mutt_file_fclose(&fp_new);
  mutt_file_fclose(&fp_old);
  mutt_file_unlink(oldfile);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_rmtree()

int mutt_file_rmtree

(

const char *

path

)

Recursively remove a directory.

Parameters

path	Directory to delete

Return values

0	Success
-1	Error, see errno

Definition at line 458 of file file.c.

{
  if (!path)
    return -1;
 
  struct dirent *de = NULL;
  struct stat st = { 0 };
  int rc = 0;
 
  DIR *dir = mutt_file_opendir(path, MUTT_OPENDIR_NONE);
  if (!dir)
  {
    mutt_debug(LL_DEBUG1, "error opening directory %s\n", path);
    return -1;
  }
 
  /* We avoid using the buffer pool for this function, because it
   * invokes recursively to an unknown depth. */
  struct Buffer cur = mutt_buffer_make(PATH_MAX);
 
  while ((de = readdir(dir)))
  {
    if ((strcmp(".", de->d_name) == 0) || (strcmp("..", de->d_name) == 0))
      continue;
 
    mutt_buffer_printf(&cur, "%s/%s", path, de->d_name);
    /* XXX make nonrecursive version */
 
    if (stat(mutt_buffer_string(&cur), &st) == -1)
    {
      rc = 1;
      continue;
    }
 
    if (S_ISDIR(st.st_mode))
      rc |= mutt_file_rmtree(mutt_buffer_string(&cur));
    else
      rc |= unlink(mutt_buffer_string(&cur));
  }
  closedir(dir);
 
  rc |= rmdir(path);
 
  mutt_buffer_dealloc(&cur);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_rotate()

const char * mutt_file_rotate	(	const char *	path,
		int	count
	)

Rotate a set of numbered files.

Parameters

path	Template filename
count	Maximum number of files

Return values

ptr	Name of the 0'th file

Given a template 'temp', rename files numbered 0 to (count-1).

Rename:

• ...
• temp1 -> temp2
• temp0 -> temp1

Definition at line 518 of file file.c.

{
  if (!path)
    return NULL;
 
  struct Buffer *old_file = mutt_buffer_pool_get();
  struct Buffer *new_file = mutt_buffer_pool_get();
 
  /* rotate the old debug logs */
  for (count -= 2; count >= 0; count--)
  {
    mutt_buffer_printf(old_file, "%s%d", path, count);
    mutt_buffer_printf(new_file, "%s%d", path, count + 1);
    (void) rename(mutt_buffer_string(old_file), mutt_buffer_string(new_file));
  }
 
  path = mutt_buffer_strdup(old_file);
  mutt_buffer_pool_release(&old_file);
  mutt_buffer_pool_release(&new_file);
 
  return path;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_safe_rename()

int mutt_file_safe_rename	(	const char *	src,
		const char *	target
	)

NFS-safe renaming of files.

Parameters

src	Original filename
target	New filename

Return values

0	Success
-1	Error, see errno

Warning: We don't check whether src and target are equal.

Definition at line 343 of file file.c.

{
  struct stat st_src = { 0 };
  struct stat st_target = { 0 };
  int link_errno;
 
  if (!src || !target)
    return -1;
 
  if (link(src, target) != 0)
  {
    link_errno = errno;
 
    /* It is historically documented that link can return -1 if NFS
     * dies after creating the link.  In that case, we are supposed
     * to use stat to check if the link was created.
     *
     * Derek Martin notes that some implementations of link() follow a
     * source symlink.  It might be more correct to use stat() on src.
     * I am not doing so to minimize changes in behavior: the function
     * used lstat() further below for 20 years without issue, and I
     * believe was never intended to be used on a src symlink.  */
    if ((lstat(src, &st_src) == 0) && (lstat(target, &st_target) == 0) &&
        (compare_stat(&st_src, &st_target) == 0))
    {
      mutt_debug(LL_DEBUG1, "link (%s, %s) reported failure: %s (%d) but actually succeeded\n",
                 src, target, strerror(errno), errno);
      goto success;
    }
 
    errno = link_errno;
 
    /* Coda does not allow cross-directory links, but tells
     * us it's a cross-filesystem linking attempt.
     *
     * However, the Coda rename call is allegedly safe to use.
     *
     * 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(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. */
    if ((errno == EXDEV) || (errno == ENOSYS) || errno == EPERM
#ifdef ENOTSUP
        || errno == ENOTSUP
#endif
#ifdef EOPNOTSUPP
        || errno == EOPNOTSUPP
#endif
    )
    {
      mutt_debug(LL_DEBUG1, "trying rename\n");
      if (rename(src, target) == -1)
      {
        mutt_debug(LL_DEBUG1, "rename (%s, %s) failed: %s (%d)\n", src, target,
                   strerror(errno), errno);
        return -1;
      }
      mutt_debug(LL_DEBUG1, "rename succeeded\n");
 
      return 0;
    }
 
    return -1;
  }
 
  /* Remove the compare_stat() check, because it causes problems with maildir
   * on filesystems that don't properly support hard links, such as sshfs.  The
   * filesystem creates the link, but the resulting file is given a different
   * inode number by the sshfs layer.  This results in an infinite loop
   * creating links.  */
#if 0
  /* Stat both links and check if they are equal. */
  if (lstat(src, &st_src) == -1)
  {
    mutt_debug(LL_DEBUG1, "#1 can't stat %s: %s (%d)\n", src, strerror(errno), errno);
    return -1;
  }
 
  if (lstat(target, &st_target) == -1)
  {
    mutt_debug(LL_DEBUG1, "#2 can't stat %s: %s (%d)\n", src, strerror(errno), errno);
    return -1;
  }
 
  /* pretend that the link failed because the target file did already exist. */
 
  if (!compare_stat(&st_src, &st_target))
  {
    mutt_debug(LL_DEBUG1, "stat blocks for %s and %s diverge; pretending EEXIST\n", src, target);
    errno = EEXIST;
    return -1;
  }
#endif
 
success:
  /* Unlink the original link.
   * Should we really ignore the return value here? XXX */
  if (unlink(src) == -1)
  {
    mutt_debug(LL_DEBUG1, "unlink (%s) failed: %s (%d)\n", src, strerror(errno), errno);
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_sanitize_filename()

void mutt_file_sanitize_filename	(	char *	path,
		bool	slash
	)

Replace unsafe characters in a filename.

Parameters

path	Filename to make safe
slash	Replace '/' characters too

Definition at line 663 of file file.c.

{
  if (!path)
    return;
 
  for (; *path; path++)
  {
    if ((slash && (*path == '/')) || !strchr(filename_safe_chars, *path))
      *path = '_';
  }
}

Here is the caller graph for this function:

mutt_file_sanitize_regex()

int mutt_file_sanitize_regex	(	struct Buffer *	dest,
		const char *	src
	)

Escape any regex-magic characters in a string.

Parameters

dest	Buffer for result
src	String to transform

Return values

0	Success
-1	Error

Definition at line 682 of file file.c.

{
  if (!dest || !src)
    return -1;
 
  mutt_buffer_reset(dest);
  while (*src != '\0')
  {
    if (strchr(rx_special_chars, *src))
      mutt_buffer_addch(dest, '\\');
    mutt_buffer_addch(dest, *src++);
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_seek()

bool mutt_file_seek	(	FILE *	fp,
		LOFF_T	offset,
		int	whence
	)

Wrapper for fseeko with error handling.

Parameters

[in]	fp	File to seek
[in]	offset	Offset
[in]	whence	Seek mode

Return values

true	Seek was successful
false	Seek failed

Definition at line 706 of file file.c.

{
  if (!fp)
  {
    return false;
  }
 
  if (fseeko(fp, offset, whence) != 0)
  {
    mutt_perror(_("Failed to seek file: %s"), strerror(errno));
    return false;
  }
 
  return true;
}

Here is the caller graph for this function:

mutt_file_set_mtime()

void mutt_file_set_mtime	(	const char *	from,
		const char *	to
	)

Set the modification time of one file from another.

Parameters

from	Filename whose mtime should be copied
to	Filename to update

Definition at line 1075 of file file.c.

{
  if (!from || !to)
    return;
 
  struct utimbuf utim;
  struct stat st = { 0 };
 
  if (stat(from, &st) != -1)
  {
    utim.actime = st.st_mtime;
    utim.modtime = st.st_mtime;
    utime(to, &utim);
  }
}

Here is the caller graph for this function:

mutt_file_stat_compare()

int mutt_file_stat_compare	(	struct stat *	st1,
		enum MuttStatType	st1_type,
		struct stat *	st2,
		enum MuttStatType	st2_type
	)

Compare two stat infos.

Parameters

st1	First stat info
st1_type	Type of first stat info, e.g. MUTT_STAT_ATIME
st2	Second stat info
st2_type	Type of second stat info, e.g. MUTT_STAT_ATIME

Return values

-1	a precedes b
0	a and b are identical
1	b precedes a

Definition at line 1689 of file file.c.

{
  if (!st1 || !st2)
    return 0;
 
  struct timespec a = { 0 };
  struct timespec b = { 0 };
 
  mutt_file_get_stat_timespec(&a, st1, st1_type);
  mutt_file_get_stat_timespec(&b, st2, st2_type);
  return mutt_file_timespec_compare(&a, &b);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_stat_timespec_compare()

int mutt_file_stat_timespec_compare	(	struct stat *	st,
		enum MuttStatType	type,
		struct timespec *	b
	)

Compare stat info with a time value.

Parameters

st	stat info
type	Type of stat info, e.g. MUTT_STAT_ATIME
b	Time value

Return values

-1	a precedes b
0	a and b are identical
1	b precedes a

Definition at line 1667 of file file.c.

{
  if (!st || !b)
    return 0;
 
  struct timespec a = { 0 };
 
  mutt_file_get_stat_timespec(&a, st, type);
  return mutt_file_timespec_compare(&a, b);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_symlink()

int mutt_file_symlink	(	const char *	oldpath,
		const char *	newpath
	)

Create a symlink.

Parameters

oldpath	Existing pathname
newpath	New pathname

Return values

0	Success
-1	Error, see errno

Definition at line 287 of file file.c.

{
  struct stat st_old = { 0 };
  struct stat st_new = { 0 };
 
  if (!oldpath || !newpath)
    return -1;
 
  if ((unlink(newpath) == -1) && (errno != ENOENT))
    return -1;
 
  if (oldpath[0] == '/')
  {
    if (symlink(oldpath, newpath) == -1)
      return -1;
  }
  else
  {
    struct Buffer abs_oldpath = mutt_buffer_make(PATH_MAX);
 
    if (!mutt_path_getcwd(&abs_oldpath))
    {
      mutt_buffer_dealloc(&abs_oldpath);
      return -1;
    }
 
    mutt_buffer_addch(&abs_oldpath, '/');
    mutt_buffer_addstr(&abs_oldpath, oldpath);
    if (symlink(mutt_buffer_string(&abs_oldpath), newpath) == -1)
    {
      mutt_buffer_dealloc(&abs_oldpath);
      return -1;
    }
 
    mutt_buffer_dealloc(&abs_oldpath);
  }
 
  if ((stat(oldpath, &st_old) == -1) || (stat(newpath, &st_new) == -1) ||
      !compare_stat(&st_old, &st_new))
  {
    unlink(newpath);
    return -1;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_timespec_compare()

int mutt_file_timespec_compare	(	struct timespec *	a,
		struct timespec *	b
	)

Compare to time values.

Parameters

a	First time value
b	Second time value

Return values

-1	a precedes b
0	a and b are identical
1	b precedes a

Definition at line 1605 of file file.c.

{
  if (!a || !b)
    return 0;
  if (a->tv_sec < b->tv_sec)
    return -1;
  if (a->tv_sec > b->tv_sec)
    return 1;
 
  if (a->tv_nsec < b->tv_nsec)
    return -1;
  if (a->tv_nsec > b->tv_nsec)
    return 1;
  return 0;
}

Here is the caller graph for this function:

mutt_file_touch_atime()

void mutt_file_touch_atime

(

int

fd

)

Set the access time to current time.

Parameters

fd	File descriptor of the file to alter

This is just as read() would do on !noatime. Silently ignored if futimens() isn't supported.

Definition at line 1098 of file file.c.

{
#ifdef HAVE_FUTIMENS
  struct timespec times[2] = { { 0, UTIME_NOW }, { 0, UTIME_OMIT } };
  futimens(fd, times);
#endif
}

Here is the caller graph for this function:

mutt_file_unlink()

void mutt_file_unlink

(

const char *

s

)

Delete a file, carefully.

Parameters

s

Filename

This won't follow symlinks.

Definition at line 193 of file file.c.

{
  if (!s)
    return;
 
  struct stat st = { 0 };
  /* Defend against symlink attacks */
 
  const bool is_regular_file = (lstat(s, &st) == 0) && S_ISREG(st.st_mode);
  if (!is_regular_file)
    return;
 
  const int fd = open(s, O_RDWR | O_NOFOLLOW);
  if (fd < 0)
    return;
 
  struct stat st2 = { 0 };
  if ((fstat(fd, &st2) != 0) || !S_ISREG(st2.st_mode) ||
      (st.st_dev != st2.st_dev) || (st.st_ino != st2.st_ino))
  {
    close(fd);
    return;
  }
 
  unlink(s);
  close(fd);
}

Here is the caller graph for this function:

mutt_file_unlink_empty()

void mutt_file_unlink_empty

(

const char *

path

)

Delete a file if it's empty.

Parameters

path	File to delete

Definition at line 1383 of file file.c.

{
  if (!path)
    return;
 
  struct stat st = { 0 };
 
  int fd = open(path, O_RDWR);
  if (fd == -1)
    return;
 
  if (mutt_file_lock(fd, true, true) == -1)
  {
    close(fd);
    return;
  }
 
  if ((fstat(fd, &st) == 0) && (st.st_size == 0))
    unlink(path);
 
  mutt_file_unlock(fd);
  close(fd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_file_unlock()

int mutt_file_unlock

(

int

fd

)

Unlock a file previously locked by mutt_file_lock()

Parameters

fd	File descriptor to file

Return values

0

Always

Definition at line 1295 of file file.c.

{
  struct flock unlockit;
 
  memset(&unlockit, 0, sizeof(struct flock));
  unlockit.l_type = F_UNLCK;
  unlockit.l_whence = SEEK_SET;
  (void) fcntl(fd, F_SETLK, &unlockit);
 
  return 0;
}

Here is the caller graph for this function:

mutt_file_resolve_symlink()

void mutt_file_resolve_symlink

(

struct Buffer *

buf

)

Resolve a symlink in place.

Parameters

buf	Input/output path

Definition at line 1707 of file file.c.

{
  struct stat st = { 0 };
  int rc = lstat(mutt_buffer_string(buf), &st);
  if ((rc != -1) && S_ISLNK(st.st_mode))
  {
    char path[PATH_MAX] = { 0 };
    if (realpath(mutt_buffer_string(buf), path))
    {
      mutt_buffer_strcpy(buf, path);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_buffer_quote_filename()

void mutt_buffer_quote_filename	(	struct Buffer *	buf,
		const char *	filename,
		bool	add_outer
	)

Quote a filename to survive the shell's quoting rules.

Parameters

buf	Buffer for the result
filename	String to convert
add_outer	If true, add 'single quotes' around the result

Definition at line 907 of file file.c.

{
  if (!buf || !filename)
    return;
 
  mutt_buffer_reset(buf);
  if (add_outer)
    mutt_buffer_addch(buf, '\'');
 
  for (; *filename != '\0'; filename++)
  {
    if ((*filename == '\'') || (*filename == '`'))
    {
      mutt_buffer_addch(buf, '\'');
      mutt_buffer_addch(buf, '\\');
      mutt_buffer_addch(buf, *filename);
      mutt_buffer_addch(buf, '\'');
    }
    else
      mutt_buffer_addch(buf, *filename);
  }
 
  if (add_outer)
    mutt_buffer_addch(buf, '\'');
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_buffer_file_expand_fmt_quote()

void mutt_buffer_file_expand_fmt_quote	(	struct Buffer *	dest,
		const char *	fmt,
		const char *	src
	)

Replace s in a string with a filename.

Parameters

dest	Buffer for the result
fmt	printf-like format string
src	Filename to substitute

This function also quotes the file to prevent shell problems.

Definition at line 1504 of file file.c.

{
  struct Buffer tmp = mutt_buffer_make(PATH_MAX);
 
  mutt_buffer_quote_filename(&tmp, src, true);
  mutt_file_expand_fmt(dest, fmt, mutt_buffer_string(&tmp));
  mutt_buffer_dealloc(&tmp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

filename_safe_chars

const char filename_safe_chars[]

extern

Definition at line 60 of file file.c.