path.c File Reference

Path manipulation functions. More...

#include "config.h"
#include <errno.h>
#include <libgen.h>
#include <limits.h>
#include <pwd.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "path.h"
#include "buffer.h"
#include "logging.h"
#include "memory.h"
#include "message.h"
#include "string2.h"

Include dependency graph for path.c:

Go to the source code of this file.

Functions
bool	mutt_path_tidy_slash (char *buf, bool is_dir)
	Remove unnecessary slashes and dots. More...
bool	mutt_path_tidy_dotdot (char *buf)
	Remove dot-dot-slash from a path. More...
bool	mutt_path_tidy (char *buf, bool is_dir)
	Remove unnecessary parts of a path. More...
bool	mutt_path_pretty (char *buf, size_t buflen, const char *homedir, bool is_dir)
	Tidy a filesystem path. More...
bool	mutt_path_tilde (char *buf, size_t buflen, const char *homedir)
	Expand '~' in a path. More...
bool	mutt_path_canon (char *buf, size_t buflen, const char *homedir, bool is_dir)
	Create the canonical version of a path. More...
const char *	mutt_path_basename (const char *f)
	Find the last component for a pathname. More...
char *	mutt_path_concat (char *d, const char *dir, const char *fname, size_t l)
	Join a directory name and a filename. More...
char *	mutt_path_dirname (const char *path)
	Return a path up to, but not including, the final '/'. More...
bool	mutt_path_to_absolute (char *path, const char *reference)
	Convert relative filepath to an absolute path. More...
size_t	mutt_path_realpath (char *buf)
	Resolve path, unraveling symlinks. More...
bool	mutt_path_parent (char *buf)
	Find the parent of a path. More...
bool	mutt_path_abbr_folder (char *buf, const char *folder)
	Create a folder abbreviation. More...
char *	mutt_path_escape (const char *src)
	Escapes single quotes in a path for a command string. More...
const char *	mutt_path_getcwd (struct Buffer *cwd)
	Get the current working directory. More...

Detailed Description

Path manipulation 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 path.c.

Function Documentation

mutt_path_tidy_slash()

bool mutt_path_tidy_slash	(	char *	buf,
		bool	is_dir
	)

Remove unnecessary slashes and dots.

Parameters

[in,out]	buf	Path to modify
[in]	is_dir	Should a trailing / be removed?

Return values

true

Success

Collapse repeated '//' and '/./'

Definition at line 54 of file path.c.

{
  if (!buf)
    return false;
 
  char *r = buf;
  char *w = buf;
 
  while (*r != '\0')
  {
    *w++ = *r++;
 
    if (r[-1] == '/') /* After a '/' ... */
    {
      for (; (r[0] == '/') || (r[0] == '.'); r++)
      {
        if (r[0] == '/') /* skip multiple /s */
          continue;
        if (r[0] == '.')
        {
          if (r[1] == '/') /* skip /./ */
          {
            r++;
            continue;
          }
          else if (r[1] == '\0') /* skip /.$ */
          {
            r[0] = '\0';
          }
          break; /* dot-anything-else isn't special */
        }
      }
    }
  }
 
  /* Strip a trailing / as long as it's not the only character */
  if (is_dir && (w > (buf + 1)) && (w[-1] == '/'))
    w--;
 
  *w = '\0';
 
  return true;
}

Here is the caller graph for this function:

mutt_path_tidy_dotdot()

bool mutt_path_tidy_dotdot

(

char *

buf

)

Remove dot-dot-slash from a path.

Parameters

[in,out]

buf

Path to modify

Return values

true

Success

Collapse dot-dot patterns, like '/dir/../'

Definition at line 105 of file path.c.

{
  if (!buf || (buf[0] != '/'))
    return false;
 
  char *dd = buf;
 
  mutt_debug(LL_DEBUG3, "Collapse path: %s\n", buf);
  while ((dd = strstr(dd, "/..")))
  {
    if (dd[3] == '/') /* paths follow dots */
    {
      char *dest = NULL;
      if (dd != buf) /* not at start of string */
      {
        dd[0] = '\0';
        dest = strrchr(buf, '/');
      }
      if (!dest)
        dest = buf;
 
      memmove(dest, dd + 3, strlen(dd + 3) + 1);
    }
    else if (dd[3] == '\0') /* dots at end of string */
    {
      if (dd == buf) /* at start of string */
      {
        dd[1] = '\0';
      }
      else
      {
        dd[0] = '\0';
        char *s = strrchr(buf, '/');
        if (s == buf)
          s[1] = '\0';
        else if (s)
          s[0] = '\0';
      }
    }
    else
    {
      dd += 3; /* skip over '/..dir/' */
      continue;
    }
 
    dd = buf; /* restart at the beginning */
  }
 
  mutt_debug(LL_DEBUG3, "Collapsed to:  %s\n", buf);
  return true;
}

Here is the caller graph for this function:

mutt_path_tidy()

bool mutt_path_tidy	(	char *	buf,
		bool	is_dir
	)

Remove unnecessary parts of a path.

Parameters

[in,out]	buf	Path to modify
[in]	is_dir	Is the path a directory?

Return values

true

Success

Remove unnecessary dots and slashes from a path

Definition at line 165 of file path.c.

{
  if (!buf || (buf[0] != '/'))
    return false;
 
  if (!mutt_path_tidy_slash(buf, is_dir))
    return false;
 
  return mutt_path_tidy_dotdot(buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_path_pretty()

bool mutt_path_pretty	(	char *	buf,
		size_t	buflen,
		const char *	homedir,
		bool	is_dir
	)

Tidy a filesystem path.

Parameters

buf	Path to modify
buflen	Length of the buffer
homedir	Home directory for '~' substitution
is_dir	Is the path a directory?

Return values

true

Success

Tidy a path and replace a home directory with '~'

Definition at line 186 of file path.c.

{
  if (!buf)
    return false;
 
  mutt_path_tidy(buf, is_dir);
 
  size_t len = mutt_str_startswith(buf, homedir);
  if (len == 0)
    return false;
 
  if ((buf[len] != '/') && (buf[len] != '\0'))
    return false;
 
  buf[0] = '~';
  if (buf[len] == '\0')
  {
    buf[1] = '\0';
    return true;
  }
 
  mutt_str_copy(buf + 1, buf + len, buflen - len);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_path_tilde()

bool mutt_path_tilde	(	char *	buf,
		size_t	buflen,
		const char *	homedir
	)

Expand '~' in a path.

Parameters

buf	Path to modify
buflen	Length of the buffer
homedir	Home directory for '~' substitution

Return values

true

Success

Behaviour:

• ~/dir (~ expanded)
• ~realuser/dir (~realuser expanded)
• ~nonuser/dir (~nonuser not changed)

Definition at line 223 of file path.c.

{
  if (!buf || (buf[0] != '~'))
    return false;
 
  char result[PATH_MAX] = { 0 };
  char *dir = NULL;
  size_t len = 0;
 
  if ((buf[1] == '/') || (buf[1] == '\0'))
  {
    if (!homedir)
    {
      mutt_debug(LL_DEBUG3, "no homedir\n");
      return false;
    }
 
    len = mutt_str_copy(result, homedir, sizeof(result));
    dir = buf + 1;
  }
  else
  {
    char user[128] = { 0 };
    dir = strchr(buf + 1, '/');
    if (dir)
      mutt_str_copy(user, buf + 1, MIN(dir - buf, (unsigned) sizeof(user)));
    else
      mutt_str_copy(user, buf + 1, sizeof(user));
 
    struct passwd *pw = getpwnam(user);
    if (!pw || !pw->pw_dir)
    {
      mutt_debug(LL_DEBUG1, "no such user: %s\n", user);
      return false;
    }
 
    len = mutt_str_copy(result, pw->pw_dir, sizeof(result));
  }
 
  size_t dirlen = mutt_str_len(dir);
  if ((len + dirlen) >= buflen)
  {
    mutt_debug(LL_DEBUG3, "result too big for the buffer %ld >= %ld\n", len + dirlen, buflen);
    return false;
  }
 
  mutt_str_copy(result + len, dir, sizeof(result) - len);
  mutt_str_copy(buf, result, buflen);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_path_canon()

bool mutt_path_canon	(	char *	buf,
		size_t	buflen,
		const char *	homedir,
		bool	is_dir
	)

Create the canonical version of a path.

Parameters

buf	Path to modify
buflen	Length of the buffer
homedir	Home directory for '~' substitution
is_dir	Is the path a directory?

Return values

true

Success

Remove unnecessary dots and slashes from a path and expand '~'.

Definition at line 285 of file path.c.

{
  if (!buf)
    return false;
 
  char result[PATH_MAX] = { 0 };
 
  if (buf[0] == '~')
  {
    mutt_path_tilde(buf, buflen, homedir);
  }
  else if (buf[0] != '/')
  {
    if (!getcwd(result, sizeof(result)))
    {
      mutt_debug(LL_DEBUG1, "getcwd failed: %s (%d)\n", strerror(errno), errno);
      return false;
    }
 
    size_t cwdlen = mutt_str_len(result);
    size_t dirlen = mutt_str_len(buf);
    if ((cwdlen + dirlen + 1) >= buflen)
    {
      mutt_debug(LL_DEBUG3, "result too big for the buffer %ld >= %ld\n",
                 cwdlen + dirlen + 1, buflen);
      return false;
    }
 
    result[cwdlen] = '/';
    mutt_str_copy(result + cwdlen + 1, buf, sizeof(result) - cwdlen - 1);
    mutt_str_copy(buf, result, buflen);
  }
 
  if (!mutt_path_tidy(buf, is_dir))
    return false;
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_path_basename()

const char * mutt_path_basename

(

const char *

f

)

Find the last component for a pathname.

Parameters

f	String to be examined

Return values

ptr	Part of pathname after last '/' character

Definition at line 329 of file path.c.

{
  if (!f)
    return NULL;
 
  const char *p = strrchr(f, '/');
  if (p)
    return p + 1;
  return f;
}

Here is the caller graph for this function:

mutt_path_concat()

char * mutt_path_concat	(	char *	d,
		const char *	dir,
		const char *	fname,
		size_t	l
	)

Join a directory name and a filename.

Parameters

d	Buffer for the result
dir	Directory name
fname	File name
l	Length of buffer

Return values

ptr	Destination buffer

If both dir and fname are supplied, they are separated with '/'. If either is missing, then the other will be copied exactly.

Definition at line 351 of file path.c.

{
  if (!d || !dir || !fname)
    return NULL;
 
  const char *fmt = "%s/%s";
 
  if ((fname[0] == '\0') || ((dir[0] != '\0') && (dir[strlen(dir) - 1] == '/')))
    fmt = "%s%s";
 
  snprintf(d, l, fmt, dir, fname);
  return d;
}

Here is the caller graph for this function:

mutt_path_dirname()

char * mutt_path_dirname

(

const char *

path

)

Return a path up to, but not including, the final '/'.

Parameters

path

Path

Return values

ptr	The directory containing p

Unlike the IEEE Std 1003.1-2001 specification of dirname(3), this implementation does not modify its parameter, so callers need not manually copy their paths into a modifiable buffer prior to calling this function.

Note

The caller must free the returned string

Definition at line 376 of file path.c.

{
  if (!path)
    return NULL;
 
  char buf[PATH_MAX] = { 0 };
  mutt_str_copy(buf, path, sizeof(buf));
  return mutt_str_dup(dirname(buf));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_path_to_absolute()

bool mutt_path_to_absolute	(	char *	path,
		const char *	reference
	)

Convert relative filepath to an absolute path.

Parameters

path	Relative path
reference	Absolute path that path is relative to

Return values

true	Success
false	Failure

Use POSIX functions to convert a path to absolute, relatively to another path

Note

path should be at least of PATH_MAX length

Definition at line 397 of file path.c.

{
  if (!path || !reference)
    return false;
 
  char abs_path[PATH_MAX] = { 0 };
  int path_len;
 
  /* if path is already absolute, don't do anything */
  if ((strlen(path) > 1) && (path[0] == '/'))
  {
    return true;
  }
 
  char *dirpath = mutt_path_dirname(reference);
  mutt_str_copy(abs_path, dirpath, sizeof(abs_path));
  FREE(&dirpath);
  mutt_strn_cat(abs_path, sizeof(abs_path), "/", 1); /* append a / at the end of the path */
 
  path_len = sizeof(abs_path) - strlen(path);
 
  mutt_strn_cat(abs_path, sizeof(abs_path), path, (path_len > 0) ? path_len : 0);
 
  path = realpath(abs_path, path);
  if (!path && (errno != ENOENT))
  {
    mutt_perror(_("Error: converting path to absolute"));
    return false;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_path_realpath()

size_t mutt_path_realpath

(

char *

buf

)

Resolve path, unraveling symlinks.

Parameters

buf	Buffer containing path

Return values

num	String length of resolved path
0	Error, buf is not overwritten

Resolve and overwrite the path in buf.

Note

Size of buf should be at least PATH_MAX bytes.

Definition at line 440 of file path.c.

{
  if (!buf)
    return 0;
 
  char s[PATH_MAX] = { 0 };
 
  if (!realpath(buf, s))
    return 0;
 
  return mutt_str_copy(buf, s, sizeof(s));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_path_parent()

bool mutt_path_parent

(

char *

buf

)

Find the parent of a path.

Parameters

buf	Buffer for the result

Return values

true

Success

Definition at line 458 of file path.c.

{
  if (!buf)
    return false;
 
  int n = mutt_str_len(buf);
  if (n < 2)
    return false;
 
  if (buf[n - 1] == '/')
    n--;
 
  // Find the previous '/'
  for (n--; ((n >= 0) && (buf[n] != '/')); n--)
    ; // do nothing
 
  if (n == 0) // Always keep at least one '/'
    n++;
 
  buf[n] = '\0';
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_path_abbr_folder()

bool mutt_path_abbr_folder	(	char *	buf,
		const char *	folder
	)

Create a folder abbreviation.

Parameters

buf	Path to modify
folder	Base path for '=' substitution

Return values

true	Path was abbreviated

Abbreviate a path using '=' to represent the 'folder'. If the folder path is passed, it won't be abbreviated to just '='

Definition at line 490 of file path.c.

{
  if (!buf || !folder)
    return false;
 
  size_t flen = mutt_str_len(folder);
  if (flen < 2)
    return false;
 
  if (folder[flen - 1] == '/')
    flen--;
 
  if (!mutt_strn_equal(buf, folder, flen))
    return false;
 
  if (buf[flen + 1] == '\0') // Don't abbreviate to '=/'
    return false;
 
  size_t rlen = mutt_str_len(buf + flen + 1);
 
  buf[0] = '=';
  memmove(buf + 1, buf + flen + 1, rlen + 1);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_path_escape()

char * mutt_path_escape

(

const char *

src

)

Escapes single quotes in a path for a command string.

Parameters

src	the path to escape

Return values

ptr	The escaped string

Definition at line 520 of file path.c.

{
  if (!src)
    return NULL;
 
  static char dest[STR_COMMAND];
  char *destp = dest;
  int destsize = 0;
 
  while (*src && (destsize < sizeof(dest) - 1))
  {
    if (*src != '\'')
    {
      *destp++ = *src++;
      destsize++;
    }
    else
    {
      /* convert ' into '\'' */
      if (destsize + 4 < sizeof(dest))
      {
        *destp++ = *src++;
        *destp++ = '\\';
        *destp++ = '\'';
        *destp++ = '\'';
        destsize += 4;
      }
      else
        break;
    }
  }
  *destp = '\0';
 
  return dest;
}

Here is the caller graph for this function:

mutt_path_getcwd()

const char * mutt_path_getcwd

(

struct Buffer *

cwd

)

Get the current working directory.

Parameters

cwd	Buffer for the result

Return values

ptr	String of current working directory

Definition at line 561 of file path.c.

{
  if (!cwd)
    return NULL;
 
  mutt_buffer_alloc(cwd, PATH_MAX);
  char *retval = getcwd(cwd->data, cwd->dsize);
  while (!retval && (errno == ERANGE))
  {
    mutt_buffer_alloc(cwd, cwd->dsize + 256);
    retval = getcwd(cwd->data, cwd->dsize);
  }
  if (retval)
    mutt_buffer_fix_dptr(cwd);
  else
    mutt_buffer_reset(cwd);
 
  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function: