path.h File Reference

Path manipulation functions. More...

#include <stdbool.h>
#include <stdio.h>

Include dependency graph for path.h:

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

Go to the source code of this file.

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

Detailed Description

Path manipulation functions.

Authors

• Richard Russon
• Dennis Schön

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

Function Documentation

mutt_path_abbr_folder()

bool mutt_path_abbr_folder	(	struct Buffer *	path,
		const char *	folder
	)

Create a folder abbreviation.

Parameters

path	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 399 of file path.c.

{
  if (buf_is_empty(path) || !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_string(path), folder, flen))
    return false;
 
  if (buf_at(path, flen + 1) == '\0') // Don't abbreviate to '=/'
    return false;
 
  size_t rlen = mutt_str_len(path->data + flen + 1);
 
  path->data[0] = '=';
  memmove(path->data + 1, path->data + flen + 1, rlen + 1);
  buf_fix_dptr(path);
 
  return true;
}

Here is the call graph for this function:

mutt_path_basename()

const char * mutt_path_basename

(

const char *

path

)

Find the last component for a pathname.

Parameters

path	String to be examined

Return values

ptr	Part of pathname after last '/' character

Note

Basename of / is /

Definition at line 282 of file path.c.

{
  if (!path)
    return NULL;
 
  const char *p = strrchr(path, '/');
  if (p)
  {
    if (p[1] == '\0')
      return path;
 
    return p + 1;
  }
 
  return path;
}

Here is the caller graph for this function:

mutt_path_canon()

bool mutt_path_canon	(	struct Buffer *	path,
		const char *	homedir,
		bool	is_dir
	)

Create the canonical version of a path.

Parameters

path	Path to modify
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 248 of file path.c.

{
  if (buf_is_empty(path))
    return false;
 
  if (buf_at(path, 0) == '~')
  {
    mutt_path_tilde(path, homedir);
  }
  else if (buf_at(path, 0) != '/')
  {
    char cwd[PATH_MAX] = { 0 };
    if (!getcwd(cwd, sizeof(cwd)))
    {
      mutt_debug(LL_DEBUG1, "getcwd failed: %s (%d)\n", strerror(errno), errno); // LCOV_EXCL_LINE
      return false; // LCOV_EXCL_LINE
    }
 
    size_t cwd_len = mutt_str_len(cwd);
    cwd[cwd_len] = '/';
    cwd[cwd_len + 1] = '\0';
    buf_insert(path, 0, cwd);
  }
 
  return mutt_path_tidy(path, is_dir);
}

Here is the call graph for this function:

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

Dirname of / is /

The caller must free the returned string

Definition at line 312 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_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

Note

Do not free the returned string

Definition at line 433 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; // LCOV_EXCL_LINE
      }
    }
  }
  *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 476 of file path.c.

{
  if (!cwd)
    return NULL;
 
  buf_alloc(cwd, PATH_MAX);
  char *rc = getcwd(cwd->data, cwd->dsize);
  while (!rc && (errno == ERANGE))
  {
    buf_alloc(cwd, cwd->dsize + 256);   // LCOV_EXCL_LINE
    rc = getcwd(cwd->data, cwd->dsize); // LCOV_EXCL_LINE
  }
  if (rc)
    buf_fix_dptr(cwd);
  else
    buf_reset(cwd); // LCOV_EXCL_LINE
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_path_realpath()

size_t mutt_path_realpath

(

struct Buffer *

path

)

Resolve path, unraveling symlinks.

Parameters

path	Buffer containing path

Return values

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

Resolve and overwrite the path in buf.

Definition at line 377 of file path.c.

{
  if (buf_is_empty(path))
    return 0;
 
  char s[PATH_MAX] = { 0 };
 
  if (!realpath(buf_string(path), s))
    return 0;
 
  return buf_strcpy(path, s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_path_tidy()

bool mutt_path_tidy	(	struct Buffer *	path,
		bool	is_dir
	)

Remove unnecessary parts of a path.

Parameters

[in,out]	path	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 169 of file path.c.

{
  if (buf_is_empty(path) || (buf_at(path, 0) != '/'))
    return false;
 
  if (!mutt_path_tidy_slash(path->data, is_dir))
    return false; // LCOV_EXCL_LINE
 
  mutt_path_tidy_dotdot(path->data);
  buf_fix_dptr(path);
 
  return true;
}

Here is the call graph for this function:

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 109 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_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 58 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_tilde()

bool mutt_path_tilde	(	struct Buffer *	path,
		const char *	homedir
	)

Expand '~' in a path.

Parameters

path	Path to modify
homedir	Home directory for '~' substitution

Return values

true

Success

Behaviour:

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

Definition at line 194 of file path.c.

{
  if (buf_is_empty(path) || (buf_at(path, 0) != '~'))
    return false;
 
  char result[PATH_MAX] = { 0 };
  char *dir = NULL;
  size_t len = 0;
 
  if ((buf_at(path, 1) == '/') || (buf_at(path, 1) == '\0'))
  {
    if (!homedir)
    {
      mutt_debug(LL_DEBUG3, "no homedir\n");
      return false;
    }
 
    len = mutt_str_copy(result, homedir, sizeof(result));
    dir = path->data + 1;
  }
  else
  {
    char user[128] = { 0 };
    dir = strchr(path->data + 1, '/');
    if (dir)
      mutt_str_copy(user, path->data + 1, MIN(dir - path->data, (unsigned) sizeof(user)));
    else
      mutt_str_copy(user, path->data + 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));
  }
 
  mutt_str_copy(result + len, dir, sizeof(result) - len);
  buf_strcpy(path, result);
 
  return true;
}

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 a relative path to its absolute form.

Parameters

[in,out]	path	Relative path
[in]	reference	Absolute path that path is relative to

Return values

true	Success, path was changed into its absolute form
false	Failure, path is untouched

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

Note

path should be able to store PATH_MAX characters + the terminator.

Definition at line 333 of file path.c.

{
  if (!path || !reference)
    return false;
 
  /* if path is already absolute, don't do anything */
  if ((strlen(path) > 1) && (path[0] == '/'))
  {
    return true;
  }
 
  struct Buffer *abs_path = buf_pool_get();
 
  char *dirpath = mutt_path_dirname(reference);
  buf_printf(abs_path, "%s/%s", dirpath, path);
  FREE(&dirpath);
 
  char rpath[PATH_MAX + 1] = { 0 };
  const char *result = realpath(buf_string(abs_path), rpath);
  buf_pool_release(&abs_path);
  if (!result)
  {
    if (errno != ENOENT)
    {
      mutt_perror(_("Error: converting path to absolute"));
    }
    return false;
  }
  else
  {
    mutt_str_copy(path, rpath, PATH_MAX);
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function: