}
/* Update the delayed_set_stat info for an intermediate directory
- created on the path to DIR. The intermediate directory turned
+ created within the file name of DIR. The intermediate directory turned
out to be the same as this directory, e.g. due to ".." or symbolic
links. *DIR_STAT_INFO is the status of the directory. */
static void
make_directories (char *file_name)
{
char *cursor0 = file_name + FILESYSTEM_PREFIX_LEN (file_name);
- char *cursor; /* points into path */
+ char *cursor; /* points into the file name */
int did_something = 0; /* did we do anything yet? */
int mode;
int invert_permissions;
if (cursor == cursor0 || ISSLASH (cursor[-1]))
continue;
- /* Avoid mkdir where last part of path is "." or "..". */
+ /* Avoid mkdir where last part of file name is "." or "..". */
if (cursor[-1] == '.'
&& (cursor == cursor0 + 1 || ISSLASH (cursor[-2])
&& (cursor == cursor0 + 2 || ISSLASH (cursor[-3])))))
continue;
- *cursor = '\0'; /* truncate the path there */
+ *cursor = '\0'; /* truncate the name there */
mode = MODE_RWX & ~ newdir_umask;
invert_permissions = we_are_root ? 0 : MODE_WXUSR & ~ mode;
status = mkdir (file_name, mode ^ invert_permissions);
enum children children;
bool nfs;
bool found;
- char name[1]; /* path name of directory */
+ char name[1]; /* file name of directory */
};
static Hash_table *directory_table;
return directory;
}
-/* Return a directory entry for a given path NAME, or zero if none found. */
+/* Return a directory entry for a given file NAME, or zero if none found. */
static struct directory *
find_directory (char *name)
{
(*(char *const *) second) + 1);
}
-/* Recursively scan the given PATH. */
+/* Recursively scan the given directory. */
static void
-scan_path (struct obstack *stk, char *path, dev_t device)
+scan_directory (struct obstack *stk, char *dir_name, dev_t device)
{
- char *dirp = savedir (path); /* for scanning directory */
+ char *dirp = savedir (dir_name); /* for scanning directory */
char const *entry; /* directory entry being scanned */
size_t entrylen; /* length of directory entry */
char *name_buffer; /* directory, `/', and directory member */
if (! dirp)
{
- savedir_error (path);
+ savedir_error (dir_name);
}
errno = 0;
- name_buffer_size = strlen (path) + NAME_FIELD_SIZE;
+ name_buffer_size = strlen (dir_name) + NAME_FIELD_SIZE;
name_buffer = xmalloc (name_buffer_size + 2);
- strcpy (name_buffer, path);
- if (! ISSLASH (path[strlen (path) - 1]))
+ strcpy (name_buffer, dir_name);
+ if (! ISSLASH (dir_name[strlen (dir_name) - 1]))
strcat (name_buffer, "/");
name_length = strlen (name_buffer);
- directory = find_directory (path);
+ directory = find_directory (dir_name);
children = directory ? directory->children : CHANGED_CHILDREN;
if (dirp && children != NO_CHILDREN)
}
char *
-get_directory_contents (char *path, dev_t device)
+get_directory_contents (char *dir_name, dev_t device)
{
struct obstack stk;
char *buffer;
obstack_init (&stk);
- scan_path (&stk, path, device);
+ scan_directory (&stk, dir_name, device);
buffer = sort_obstack (&stk);
obstack_free (&stk, NULL);
return buffer;
/* Print a similar line when we make a directory automatically. */
void
-print_for_mkdir (char *pathname, int length, mode_t mode)
+print_for_mkdir (char *dirname, int length, mode_t mode)
{
char modes[11];
}
fprintf (stdlis, "%s %*s %.*s\n", modes, ugswidth + DATEWIDTH,
- _("Creating directory:"), length, quotearg (pathname));
+ _("Creating directory:"), length, quotearg (dirname));
}
}
static char *before_backup_name;
static char *after_backup_name;
-/* Return 1 if PATH is obviously "." or "/". */
+/* Return 1 if FILE_NAME is obviously "." or "/". */
static bool
-must_be_dot_or_slash (char const *path)
+must_be_dot_or_slash (char const *file_name)
{
- path += FILESYSTEM_PREFIX_LEN (path);
+ file_name += FILESYSTEM_PREFIX_LEN (file_name);
- if (ISSLASH (path[0]))
+ if (ISSLASH (file_name[0]))
{
for (;;)
- if (ISSLASH (path[1]))
- path++;
- else if (path[1] == '.' && ISSLASH (path[2 + (path[2] == '.')]))
- path += 2 + (path[2] == '.');
+ if (ISSLASH (file_name[1]))
+ file_name++;
+ else if (file_name[1] == '.'
+ && ISSLASH (file_name[2 + (file_name[2] == '.')]))
+ file_name += 2 + (file_name[2] == '.');
else
- return ! path[1];
+ return ! file_name[1];
}
else
{
- while (path[0] == '.' && ISSLASH (path[1]))
+ while (file_name[0] == '.' && ISSLASH (file_name[1]))
{
- path += 2;
- while (ISSLASH (*path))
- path++;
+ file_name += 2;
+ while (ISSLASH (*file_name))
+ file_name++;
}
- return ! path[0] || (path[0] == '.' && ! path[1]);
+ return ! file_name[0] || (file_name[0] == '.' && ! file_name[1]);
}
}
Report an error with errno set to zero for obvious cases of this;
otherwise call rmdir. */
static int
-safer_rmdir (const char *path)
+safer_rmdir (const char *file_name)
{
- if (must_be_dot_or_slash (path))
+ if (must_be_dot_or_slash (file_name))
{
errno = 0;
return -1;
}
- return rmdir (path);
+ return rmdir (file_name);
}
-/* Remove PATH, returning 1 on success. If PATH is a directory, then
- if OPTION is RECURSIVE_REMOVE_OPTION is set remove PATH
- recursively; otherwise, remove it only if it is empty. If PATH is
+/* Remove FILE_NAME, returning 1 on success. If FILE_NAME is a directory,
+ then if OPTION is RECURSIVE_REMOVE_OPTION is set remove FILE_NAME
+ recursively; otherwise, remove it only if it is empty. If FILE_NAME is
a directory that cannot be removed (e.g., because it is nonempty)
and if OPTION is WANT_DIRECTORY_REMOVE_OPTION, then return -1.
- Return 0 on error, with errno set; if PATH is obviously the working
+ Return 0 on error, with errno set; if FILE_NAME is obviously the working
directory return zero with errno set to zero. */
int
-remove_any_file (const char *path, enum remove_option option)
+remove_any_file (const char *file_name, enum remove_option option)
{
/* Try unlink first if we are not root, as this saves us a system
call in the common case where we're removing a non-directory. */
if (! we_are_root)
{
- if (unlink (path) == 0)
+ if (unlink (file_name) == 0)
return 1;
/* POSIX 1003.1-2001 requires EPERM when attempting to unlink a
return 0;
}
- if (safer_rmdir (path) == 0)
+ if (safer_rmdir (file_name) == 0)
return 1;
switch (errno)
{
case ENOTDIR:
- return we_are_root && unlink (path) == 0;
+ return we_are_root && unlink (file_name) == 0;
case 0:
case EEXIST:
case RECURSIVE_REMOVE_OPTION:
{
- char *directory = savedir (path);
+ char *directory = savedir (file_name);
char const *entry;
size_t entrylen;
(entrylen = strlen (entry)) != 0;
entry += entrylen + 1)
{
- char *path_buffer = new_name (path, entry);
- int r = remove_any_file (path_buffer, 1);
+ char *file_name_buffer = new_name (file_name, entry);
+ int r = remove_any_file (file_name_buffer, 1);
int e = errno;
- free (path_buffer);
+ free (file_name_buffer);
if (! r)
{
}
free (directory);
- return safer_rmdir (path) == 0;
+ return safer_rmdir (file_name) == 0;
}
}
break;
return 0;
}
-/* Check if PATH already exists and make a backup of it right now.
+/* Check if FILE_NAME already exists and make a backup of it right now.
Return success (nonzero) only if the backup is either unneeded, or
successful. For now, directories are considered to never need
backup. If THIS_IS_THE_ARCHIVE is nonzero, this is the archive and
so, we do not have to backup block or character devices, nor remote
entities. */
bool
-maybe_backup_file (const char *path, int this_is_the_archive)
+maybe_backup_file (const char *file_name, int this_is_the_archive)
{
struct stat file_stat;
/* Check if we really need to backup the file. */
- if (this_is_the_archive && _remdev (path))
+ if (this_is_the_archive && _remdev (file_name))
return true;
- if (stat (path, &file_stat))
+ if (stat (file_name, &file_stat))
{
if (errno == ENOENT)
return true;
- stat_error (path);
+ stat_error (file_name);
return false;
}
&& (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode)))
return true;
- assign_string (&before_backup_name, path);
+ assign_string (&before_backup_name, file_name);
/* A run situation may exist between Emacs or other GNU programs trying to
make a backup for the same file simultaneously. If theoretically
convention, GNU-wide, for all programs doing backups. */
assign_string (&after_backup_name, 0);
- after_backup_name = find_backup_file_name (path, backup_type);
+ after_backup_name = find_backup_file_name (file_name, backup_type);
if (! after_backup_name)
xalloc_die ();
return name;
}
-/* Find a match for PATH (whose string length is LENGTH) in the name
+/* Find a match for FILE_NAME (whose string length is LENGTH) in the name
list. */
static struct name *
-namelist_match (char const *path, size_t length)
+namelist_match (char const *file_name, size_t length)
{
struct name *p;
{
/* If first chars don't match, quick skip. */
- if (p->firstch && p->name[0] != path[0])
+ if (p->firstch && p->name[0] != file_name[0])
continue;
if (p->regexp
- ? fnmatch (p->name, path, recursion_option) == 0
+ ? fnmatch (p->name, file_name, recursion_option) == 0
: (p->length <= length
- && (path[p->length] == '\0'
- || (ISSLASH (path[p->length]) && recursion_option))
- && memcmp (path, p->name, p->length) == 0))
+ && (file_name[p->length] == '\0'
+ || (ISSLASH (file_name[p->length]) && recursion_option))
+ && memcmp (file_name, p->name, p->length) == 0))
return p;
}
return 0;
}
-/* Return true if and only if name PATH (from an archive) matches any
+/* Return true if and only if name FILE_NAME (from an archive) matches any
name from the namelist. */
int
-name_match (const char *path)
+name_match (const char *file_name)
{
- size_t length = strlen (path);
+ size_t length = strlen (file_name);
while (1)
{
return ! files_from_option;
}
- cursor = namelist_match (path, length);
+ cursor = namelist_match (file_name, length);
if (cursor)
{
- if (!(ISSLASH (path[cursor->length]) && recursion_option)
+ if (!(ISSLASH (file_name[cursor->length]) && recursion_option)
|| cursor->found_count == 0)
cursor->found_count++; /* remember it matched */
if (starting_file_option)
static void
add_hierarchy_to_namelist (struct name *name, dev_t device)
{
- char *path = name->name;
- char *buffer = get_directory_contents (path, device);
+ char *file_name = name->name;
+ char *buffer = get_directory_contents (file_name, device);
if (! buffer)
name->dir_contents = "\0\0\0\0";
int change_dir = name->change_dir;
name->dir_contents = buffer;
- strcpy (namebuf, path);
+ strcpy (namebuf, file_name);
if (! ISSLASH (namebuf[name_length - 1]))
{
namebuf[name_length++] = '/';
will have to do that if it wants to. Oh, and if the namelist is
empty, it returns null, unlike name_match, which returns TRUE. */
struct name *
-name_scan (const char *path)
+name_scan (const char *file_name)
{
- size_t length = strlen (path);
+ size_t length = strlen (file_name);
while (1)
{
- struct name *cursor = namelist_match (path, length);
+ struct name *cursor = namelist_match (file_name, length);
if (cursor)
return cursor;
name->found_count = 0;
}
-/* Yield a newly allocated file name consisting of PATH concatenated to
- NAME, with an intervening slash if PATH does not already end in one. */
+/* Yield a newly allocated file name consisting of FILE_NAME concatenated to
+ NAME, with an intervening slash if FILE_NAME does not already end in one. */
char *
-new_name (const char *path, const char *name)
+new_name (const char *file_name, const char *name)
{
- size_t pathlen = strlen (path);
+ size_t file_name_len = strlen (file_name);
size_t namesize = strlen (name) + 1;
- int slash = pathlen && ! ISSLASH (path[pathlen - 1]);
- char *buffer = xmalloc (pathlen + slash + namesize);
- memcpy (buffer, path, pathlen);
- buffer[pathlen] = '/';
- memcpy (buffer + pathlen + slash, name, namesize);
+ int slash = file_name_len && ! ISSLASH (file_name[file_name_len - 1]);
+ char *buffer = xmalloc (file_name_len + slash + namesize);
+ memcpy (buffer, file_name, file_name_len);
+ buffer[file_name_len] = '/';
+ memcpy (buffer + file_name_len + slash, name, namesize);
return buffer;
}
p = file_name;
else
{
- /* Skip file system prefixes, leading pathnames that contain
+ /* Skip file system prefixes, leading file name components that contain
"..", and leading slashes. */
size_t prefix_len = FILESYSTEM_PREFIX_LEN (file_name);
}
\f
/* Return the size of the prefix of FILE_NAME that is removed after
- stripping NUM leading path name components. NUM must be
+ stripping NUM leading file name components. NUM must be
positive. */
size_t
return -1;
}
\f
-/* Return nonzero if NAME contains ".." as a path name component. */
+/* Return nonzero if NAME contains ".." as a file name component. */
bool
contains_dot_dot (char const *name)
{
along with this program; if not, write to the Free Software Foundation,
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
-extern char *rmt_path__;
+extern char *rmt_dev_name__;
int rmt_open__ (const char *, int, int, const char *);
int rmt_close__ (int);
Distributed File System (DFS). However, when --force-local, a
filename is never remote. */
-#define _remdev(Path) \
- (!force_local_option && (rmt_path__ = strchr (Path, ':')) \
- && rmt_path__ > (Path) && ! memchr (Path, '/', rmt_path__ - (Path)))
+#define _remdev(dev_name) \
+ (!force_local_option && (rmt_dev_name__ = strchr (dev_name, ':')) \
+ && rmt_dev_name__ > (dev_name) \
+ && ! memchr (dev_name, '/', rmt_dev_name__ - (dev_name)))
-#define _isrmt(Fd) \
- ((Fd) >= __REM_BIAS)
+#define _isrmt(fd) \
+ ((fd) >= __REM_BIAS)
#define __REM_BIAS (1 << 30)
# define O_CREAT 01000
#endif
-#define rmtopen(Path, Oflag, Mode, Command) \
- (_remdev (Path) ? rmt_open__ (Path, Oflag, __REM_BIAS, Command) \
- : open (Path, Oflag, Mode))
+#define rmtopen(dev_name, oflag, mode, command) \
+ (_remdev (dev_name) ? rmt_open__ (dev_name, oflag, __REM_BIAS, command) \
+ : open (dev_name, oflag, mode))
-#define rmtaccess(Path, Amode) \
- (_remdev (Path) ? 0 : access (Path, Amode))
+#define rmtaccess(dev_name, amode) \
+ (_remdev (dev_name) ? 0 : access (dev_name, amode))
-#define rmtstat(Path, Buffer) \
- (_remdev (Path) ? (errno = EOPNOTSUPP), -1 : stat (Path, Buffer))
+#define rmtstat(dev_name, buffer) \
+ (_remdev (dev_name) ? (errno = EOPNOTSUPP), -1 : stat (dev_name, buffer))
-#define rmtcreat(Path, Mode, Command) \
- (_remdev (Path) \
- ? rmt_open__ (Path, 1 | O_CREAT, __REM_BIAS, Command) \
- : creat (Path, Mode))
+#define rmtcreat(dev_name, mode, command) \
+ (_remdev (dev_name) \
+ ? rmt_open__ (dev_name, 1 | O_CREAT, __REM_BIAS, command) \
+ : creat (dev_name, mode))
-#define rmtlstat(Path, Buffer) \
- (_remdev (Path) ? (errno = EOPNOTSUPP), -1 : lstat (Path, Buffer))
+#define rmtlstat(dev_name, muffer) \
+ (_remdev (dev_name) ? (errno = EOPNOTSUPP), -1 : lstat (dev_name, buffer))
-#define rmtread(Fd, Buffer, Length) \
- (_isrmt (Fd) ? rmt_read__ (Fd - __REM_BIAS, Buffer, Length) \
- : safe_read (Fd, Buffer, Length))
+#define rmtread(fd, buffer, length) \
+ (_isrmt (fd) ? rmt_read__ (fd - __REM_BIAS, buffer, length) \
+ : safe_read (fd, buffer, length))
-#define rmtwrite(Fd, Buffer, Length) \
- (_isrmt (Fd) ? rmt_write__ (Fd - __REM_BIAS, Buffer, Length) \
- : full_write (Fd, Buffer, Length))
+#define rmtwrite(fd, buffer, length) \
+ (_isrmt (fd) ? rmt_write__ (fd - __REM_BIAS, buffer, length) \
+ : full_write (fd, buffer, length))
-#define rmtlseek(Fd, Offset, Where) \
- (_isrmt (Fd) ? rmt_lseek__ (Fd - __REM_BIAS, Offset, Where) \
- : lseek (Fd, Offset, Where))
+#define rmtlseek(fd, offset, where) \
+ (_isrmt (fd) ? rmt_lseek__ (fd - __REM_BIAS, offset, where) \
+ : lseek (fd, offset, where))
-#define rmtclose(Fd) \
- (_isrmt (Fd) ? rmt_close__ (Fd - __REM_BIAS) : close (Fd))
+#define rmtclose(fd) \
+ (_isrmt (fd) ? rmt_close__ (fd - __REM_BIAS) : close (fd))
-#define rmtioctl(Fd, Request, Argument) \
- (_isrmt (Fd) ? rmt_ioctl__ (Fd - __REM_BIAS, Request, Argument) \
- : ioctl (Fd, Request, Argument))
+#define rmtioctl(fd, request, argument) \
+ (_isrmt (fd) ? rmt_ioctl__ (fd - __REM_BIAS, request, argument) \
+ : ioctl (fd, request, argument))
-#define rmtdup(Fd) \
- (_isrmt (Fd) ? (errno = EOPNOTSUPP), -1 : dup (Fd))
+#define rmtdup(fd) \
+ (_isrmt (fd) ? (errno = EOPNOTSUPP), -1 : dup (fd))
-#define rmtfstat(Fd, Buffer) \
- (_isrmt (Fd) ? (errno = EOPNOTSUPP), -1 : fstat (Fd, Buffer))
+#define rmtfstat(fd, buffer) \
+ (_isrmt (fd) ? (errno = EOPNOTSUPP), -1 : fstat (fd, buffer))
-#define rmtfcntl(Fd, Command, Argument) \
- (_isrmt (Fd) ? (errno = EOPNOTSUPP), -1 : fcntl (Fd, Command, Argument))
+#define rmtfcntl(cd, command, argument) \
+ (_isrmt (fd) ? (errno = EOPNOTSUPP), -1 : fcntl (fd, command, argument))
-#define rmtisatty(Fd) \
- (_isrmt (Fd) ? 0 : isatty (Fd))
+#define rmtisatty(fd) \
+ (_isrmt (fd) ? 0 : isatty (fd))
#define RMT_COMMAND (rmt_command_option ? rmt_command_option : "/etc/rmt")
/* Temporary variable used by macros in rmt.h. */
-char *rmt_path__;
+char *rmt_dev_name__;
\f
/* Close remote tape connection HANDLE, and reset errno to ERRNO_VALUE. */
}
/* Open a file (a magnetic tape device?) on the system specified in
- PATH, as the given user. PATH has the form `[USER@]HOST:FILE'.
+ FILE_NAME, as the given user. FILE_NAME has the form `[USER@]HOST:FILE'.
OPEN_MODE is O_RDONLY, O_WRONLY, etc. If successful, return the
remote pipe number plus BIAS. REMOTE_SHELL may be overridden. On
error, return -1. */
int
-rmt_open__ (const char *path, int open_mode, int bias, const char *remote_shell)
+rmt_open__ (const char *file_name, int open_mode, int bias,
+ const char *remote_shell)
{
int remote_pipe_number; /* pseudo, biased file descriptor */
- char *path_copy ; /* copy of path string */
+ char *file_name_copy; /* copy of file_name string */
char *remote_host; /* remote host name */
char *remote_file; /* remote file name (often a device) */
char *remote_user; /* remote user name */
{
char *cursor;
- path_copy = xstrdup (path);
- remote_host = path_copy;
+ file_name_copy = xstrdup (file_name);
+ remote_host = file_name_copy;
remote_user = 0;
remote_file = 0;
- for (cursor = path_copy; *cursor; cursor++)
+ for (cursor = file_name_copy; *cursor; cursor++)
switch (*cursor)
{
default:
break;
case '\n':
- /* Do not allow newlines in the path, since the protocol
+ /* Do not allow newlines in the file_name, since the protocol
uses newline delimiters. */
- free (path_copy);
+ free (file_name_copy);
errno = ENOENT;
return -1;
if (READ_SIDE (remote_pipe_number) < 0)
{
int e = errno;
- free (path_copy);
+ free (file_name_copy);
errno = e;
return -1;
}
#ifdef REMOTE_SHELL
remote_shell = REMOTE_SHELL;
#else
- free (path_copy);
+ free (file_name_copy);
errno = EIO;
return -1;
#endif
|| pipe (from_remote[remote_pipe_number]) == -1)
{
int e = errno;
- free (path_copy);
+ free (file_name_copy);
errno = e;
return -1;
}
if (status == -1)
{
int e = errno;
- free (path_copy);
+ free (file_name_copy);
errno = e;
return -1;
}
{
int e = errno;
free (command_buffer);
- free (path_copy);
+ free (file_name_copy);
_rmt_shutdown (remote_pipe_number, e);
return -1;
}
free (command_buffer);
}
- free (path_copy);
+ free (file_name_copy);
return remote_pipe_number + bias;
}
first part of the record. */
char *output_start;
-/* Catenate file PATH to the archive without creating a header for it.
+/* Catenate file FILE_NAME to the archive without creating a header for it.
It had better be a tar file or the archive is screwed. */
static void
-append_file (char *path)
+append_file (char *file_name)
{
- int handle = open (path, O_RDONLY | O_BINARY);
+ int handle = open (file_name, O_RDONLY | O_BINARY);
struct stat stat_data;
if (handle < 0)
{
- open_error (path);
+ open_error (file_name);
return;
}
if (fstat (handle, &stat_data) != 0)
- stat_error (path);
+ stat_error (file_name);
else
{
off_t bytes_left = stat_data.st_size;
status = safe_read (handle, start->buffer, buffer_size);
if (status == SAFE_READ_ERROR)
- read_fatal_details (path, stat_data.st_size - bytes_left,
+ read_fatal_details (file_name, stat_data.st_size - bytes_left,
buffer_size);
if (status == 0)
FATAL_ERROR ((0, 0,
ngettext ("%s: File shrank by %s byte",
"%s: File shrank by %s bytes",
bytes_left),
- quotearg_colon (path),
+ quotearg_colon (file_name),
STRINGIFY_BIGINT (bytes_left, buf)));
bytes_left -= status;
}
if (close (handle) != 0)
- close_error (path);
+ close_error (file_name);
}
/* Implement the 'r' (add files to end of archive), and 'u' (add files
output_start = current_block->buffer;
{
- char *path;
+ char *file_name;
- while ((path = name_from_list ()) != NULL)
+ while ((file_name = name_from_list ()) != NULL)
{
- if (excluded_name (path))
+ if (excluded_name (file_name))
continue;
- if (interactive_option && !confirm ("add", path))
+ if (interactive_option && !confirm ("add", file_name))
continue;
if (subcommand_option == CAT_SUBCOMMAND)
- append_file (path);
+ append_file (file_name);
else
- dump_file (path, 1, (dev_t) 0);
+ dump_file (file_name, 1, (dev_t) 0);
}
}
%d The directory name of the file,
equivalent to the result of the
dirname utility on the translated
- pathname.
+ file name.
%f The filename of the file, equivalent
to the result of the basename
- utility on the translated pathname.
+ utility on the translated file name.
%p The process ID of the pax process.
%% A '%' character. */
projects / chaz / tar / commitdiff
