2021-07-09 07:43:26 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* fs/vfs/fs_chstat.c
|
|
|
|
*
|
|
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
|
|
* this work for additional information regarding copyright ownership. The
|
|
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
|
|
* "License"); you may not use this file except in compliance with the
|
|
|
|
* License. You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
|
|
* License for the specific language governing permissions and limitations
|
|
|
|
* under the License.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Included Files
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include <errno.h>
|
|
|
|
|
|
|
|
#include <nuttx/fs/fs.h>
|
|
|
|
|
|
|
|
#include "inode/inode.h"
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: chstat_recursive
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static int chstat_recursive(FAR const char *path,
|
|
|
|
FAR const struct stat *buf,
|
|
|
|
int flags, int resolve)
|
|
|
|
{
|
|
|
|
struct inode_search_s desc;
|
|
|
|
FAR struct inode *inode;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Get an inode for this path */
|
|
|
|
|
|
|
|
SETUP_SEARCH(&desc, path, true);
|
|
|
|
|
|
|
|
ret = inode_find(&desc);
|
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
/* This name does not refer to an inode in the pseudo file system and
|
|
|
|
* there is no mountpoint that includes in this path.
|
|
|
|
*/
|
|
|
|
|
|
|
|
goto errout_with_search;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the search results */
|
|
|
|
|
|
|
|
inode = desc.node;
|
|
|
|
DEBUGASSERT(inode != NULL);
|
|
|
|
|
|
|
|
/* The way we handle the chstat depends on the type of inode that we
|
|
|
|
* are dealing with.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef CONFIG_DISABLE_MOUNTPOINT
|
|
|
|
if (INODE_IS_MOUNTPT(inode))
|
|
|
|
{
|
|
|
|
/* The node is a file system mointpoint. Verify that the mountpoint
|
|
|
|
* supports the chstat() method
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (inode->u.i_mops && inode->u.i_mops->chstat)
|
|
|
|
{
|
|
|
|
/* Perform the chstat() operation */
|
|
|
|
|
|
|
|
ret = inode->u.i_mops->chstat(inode, desc.relpath, buf, flags);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -ENOSYS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
/* The node is part of the root pseudo file system. This path may
|
|
|
|
* recurse if soft links are supported in the pseudo file system.
|
|
|
|
*/
|
|
|
|
|
|
|
|
ret = inode_chstat(inode, buf, flags, resolve);
|
|
|
|
}
|
|
|
|
|
|
|
|
inode_release(inode);
|
|
|
|
|
|
|
|
errout_with_search:
|
|
|
|
RELEASE_SEARCH(&desc);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: fchstat
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static int chstat(FAR const char *path,
|
|
|
|
FAR struct stat *buf, int flags, int resolve)
|
|
|
|
{
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
/* Adjust and check buf and flags */
|
|
|
|
|
2022-04-08 06:06:17 +02:00
|
|
|
if ((flags & CH_STAT_MODE) && (buf->st_mode & ~0177777))
|
2021-07-09 07:43:26 +02:00
|
|
|
{
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((flags & CH_STAT_UID) && buf->st_uid == -1)
|
|
|
|
{
|
|
|
|
flags &= ~CH_STAT_UID;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((flags & CH_STAT_GID) && buf->st_gid == -1)
|
|
|
|
{
|
|
|
|
flags &= ~CH_STAT_GID;
|
|
|
|
}
|
|
|
|
|
|
|
|
clock_gettime(CLOCK_REALTIME, &buf->st_ctim);
|
|
|
|
|
|
|
|
if (flags & CH_STAT_ATIME)
|
|
|
|
{
|
|
|
|
if (buf->st_atim.tv_nsec == UTIME_OMIT)
|
|
|
|
{
|
|
|
|
flags &= ~CH_STAT_ATIME;
|
|
|
|
}
|
|
|
|
else if (buf->st_atim.tv_nsec == UTIME_NOW)
|
|
|
|
{
|
|
|
|
buf->st_atim = buf->st_ctim;
|
|
|
|
}
|
|
|
|
else if (buf->st_atim.tv_nsec >= 1000000000)
|
|
|
|
{
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & CH_STAT_MTIME)
|
|
|
|
{
|
|
|
|
if (buf->st_mtim.tv_nsec == UTIME_OMIT)
|
|
|
|
{
|
|
|
|
flags &= ~CH_STAT_MTIME;
|
|
|
|
}
|
|
|
|
else if (buf->st_mtim.tv_nsec == UTIME_NOW)
|
|
|
|
{
|
|
|
|
buf->st_mtim = buf->st_ctim;
|
|
|
|
}
|
|
|
|
else if (buf->st_mtim.tv_nsec >= 1000000000)
|
|
|
|
{
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Perform the chstat operation */
|
|
|
|
|
|
|
|
ret = chstat_recursive(path, buf, flags, resolve);
|
|
|
|
if (ret >= 0)
|
|
|
|
{
|
|
|
|
/* Successfully chstat'ed the file */
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
errout:
|
|
|
|
set_errno(-ret);
|
|
|
|
return ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Public Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: chmod
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* The chmod() function changes S_ISUID, S_ISGID, S_ISVTX and the file
|
|
|
|
* permission bits of the file named by the pathname pointed to by the
|
|
|
|
* path argument to the corresponding bits in the mode argument. The
|
|
|
|
* effective user ID of the process must match the owner of the file or
|
|
|
|
* the process must have appropriate privileges in order to do this.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* path - Specifies the file to be modified
|
|
|
|
* mode - Specifies the permission to set
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Upon successful completion, chmod() shall return 0.
|
|
|
|
* Otherwise, it shall return -1 and set errno to indicate the error.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int chmod(FAR const char *path, mode_t mode)
|
|
|
|
{
|
|
|
|
struct stat buf;
|
|
|
|
|
|
|
|
buf.st_mode = mode;
|
|
|
|
|
|
|
|
return chstat(path, &buf, CH_STAT_MODE, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: lchmod
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* The lchmod() system call is similar to chmod() but does not follow
|
|
|
|
* the symbolic links.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* path - Specifies the file to be modified
|
|
|
|
* mode - Specifies the permission to set
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Upon successful completion, lchmod() shall return 0.
|
|
|
|
* Otherwise, it shall return -1 and set errno to indicate the error.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int lchmod(FAR const char *path, mode_t mode)
|
|
|
|
{
|
|
|
|
struct stat buf;
|
|
|
|
|
|
|
|
buf.st_mode = mode;
|
|
|
|
|
|
|
|
return chstat(path, &buf, CH_STAT_MODE, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: chown
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* The chown() function shall change the user and group ownership of a
|
|
|
|
* file. Only processes with an effective user ID equal to the user ID
|
|
|
|
* of the file or with appropriate privileges may change the ownership
|
|
|
|
* of a file.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* path - Specifies the file to be modified
|
|
|
|
* owner - Specifies the owner to set
|
|
|
|
* group - Specifies the group to set
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Upon successful completion, chown() shall return 0.
|
|
|
|
* Otherwise, it shall return -1 and set errno to indicate the error.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int chown(FAR const char *path, uid_t owner, gid_t group)
|
|
|
|
{
|
|
|
|
struct stat buf;
|
|
|
|
|
|
|
|
buf.st_uid = owner;
|
|
|
|
buf.st_gid = group;
|
|
|
|
|
|
|
|
return chstat(path, &buf, CH_STAT_UID | CH_STAT_GID, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: lchown
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* The lchown() system call is similar to chown() but does not follow
|
|
|
|
* the symbolic links.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* path - Specifies the file to be modified
|
|
|
|
* owner - Specifies the owner to set
|
|
|
|
* group - Specifies the group to set
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Upon successful completion, lchown() shall return 0.
|
|
|
|
* Otherwise, it shall return -1 and set errno to indicate the error.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int lchown(FAR const char *path, uid_t owner, gid_t group)
|
|
|
|
{
|
|
|
|
struct stat buf;
|
|
|
|
|
|
|
|
buf.st_uid = owner;
|
|
|
|
buf.st_gid = group;
|
|
|
|
|
|
|
|
return chstat(path, &buf, CH_STAT_UID | CH_STAT_GID, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2021-08-09 10:08:20 +02:00
|
|
|
* Name: utimens
|
2021-07-09 07:43:26 +02:00
|
|
|
*
|
|
|
|
* Description:
|
2021-08-09 10:08:20 +02:00
|
|
|
* The utimens() function shall set the access and modification times of
|
2021-07-09 07:43:26 +02:00
|
|
|
* the file pointed to by the path argument to the value of the times
|
2021-08-09 10:08:20 +02:00
|
|
|
* argument. utimens() function allows time specifications accurate to
|
2021-07-09 07:43:26 +02:00
|
|
|
* the microsecond.
|
|
|
|
*
|
2021-08-09 10:08:20 +02:00
|
|
|
* For utimens(), the times argument is an array of timeval structures.
|
2021-07-09 07:43:26 +02:00
|
|
|
* The first array member represents the date and time of last access,
|
|
|
|
* and the second member represents the date and time of last
|
|
|
|
* modification. The times in the timeval structure are measured in
|
|
|
|
* seconds and microseconds since the Epoch, although rounding toward
|
|
|
|
* the nearest second may occur.
|
|
|
|
*
|
|
|
|
* If the times argument is a null pointer, the access and modification
|
|
|
|
* times of the file shall be set to the current time. The effective
|
|
|
|
* user ID of the process shall match the owner of the file, has write
|
|
|
|
* access to the file or appropriate privileges to use this call in this
|
2021-08-09 10:08:20 +02:00
|
|
|
* manner. Upon completion, utimens() shall mark the time of the last
|
2021-07-09 07:43:26 +02:00
|
|
|
* file status change, st_ctime, for update.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* path - Specifies the file to be modified
|
|
|
|
* times - Specifies the time value to set
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Upon successful completion, 0 shall be returned. Otherwise, -1 shall
|
|
|
|
* be returned and errno shall be set to indicate the error, and the file
|
|
|
|
* times shall not be affected.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2021-08-09 10:08:20 +02:00
|
|
|
int utimens(FAR const char *path, const struct timespec times[2])
|
2021-07-09 07:43:26 +02:00
|
|
|
{
|
|
|
|
struct stat buf;
|
|
|
|
|
|
|
|
if (times != NULL)
|
|
|
|
{
|
2021-08-09 10:08:20 +02:00
|
|
|
buf.st_atim = times[0];
|
|
|
|
buf.st_mtim = times[1];
|
2021-07-09 07:43:26 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
buf.st_atim.tv_nsec = UTIME_NOW;
|
|
|
|
buf.st_mtim.tv_nsec = UTIME_NOW;
|
|
|
|
}
|
|
|
|
|
|
|
|
return chstat(path, &buf, CH_STAT_ATIME | CH_STAT_MTIME, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2021-08-09 10:08:20 +02:00
|
|
|
* Name: lutimens
|
2021-07-09 07:43:26 +02:00
|
|
|
*
|
|
|
|
* Description:
|
2021-08-09 10:08:20 +02:00
|
|
|
* The lutimens() system call is similar to utimens() but does not follow
|
2021-07-09 07:43:26 +02:00
|
|
|
* the symbolic links.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* path - Specifies the file to be modified
|
|
|
|
* times - Specifies the time value to set
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Upon successful completion, 0 shall be returned. Otherwise, -1 shall
|
|
|
|
* be returned and errno shall be set to indicate the error, and the file
|
|
|
|
* times shall not be affected.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2021-08-09 10:08:20 +02:00
|
|
|
int lutimens(FAR const char *path, const struct timespec times[2])
|
2021-07-09 07:43:26 +02:00
|
|
|
{
|
|
|
|
struct stat buf;
|
|
|
|
|
|
|
|
if (times != NULL)
|
|
|
|
{
|
2021-08-09 10:08:20 +02:00
|
|
|
buf.st_atim = times[0];
|
|
|
|
buf.st_mtim = times[1];
|
2021-07-09 07:43:26 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
buf.st_atim.tv_nsec = UTIME_NOW;
|
|
|
|
buf.st_mtim.tv_nsec = UTIME_NOW;
|
|
|
|
}
|
|
|
|
|
|
|
|
return chstat(path, &buf, CH_STAT_ATIME | CH_STAT_MTIME, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: inode_chstat
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* The inode_chstat() function will change information about an 'inode'
|
|
|
|
* in the pseudo file system according the area pointed to by 'buf'.
|
|
|
|
*
|
|
|
|
* The 'buf' argument is a pointer to a stat structure, as defined in
|
|
|
|
* <sys/stat.h>, which information is placed concerning the file.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* inode - The inode of interest
|
|
|
|
* buf - The caller provide location in which to apply information
|
|
|
|
* about the inode.
|
2022-07-07 18:01:22 +02:00
|
|
|
* flags - The valid field in buf
|
2021-07-09 07:43:26 +02:00
|
|
|
* resolve - Whether to resolve the symbolic link
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Zero (OK) returned on success. Otherwise, a negated errno value is
|
|
|
|
* returned to indicate the nature of the failure.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int inode_chstat(FAR struct inode *inode,
|
|
|
|
FAR const struct stat *buf, int flags, int resolve)
|
|
|
|
{
|
|
|
|
DEBUGASSERT(inode != NULL && buf != NULL);
|
|
|
|
|
|
|
|
#ifdef CONFIG_PSEUDOFS_SOFTLINKS
|
|
|
|
/* Handle softlinks differently. Just call chstat() recursively on the
|
|
|
|
* target of the softlink.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (INODE_IS_SOFTLINK(inode))
|
|
|
|
{
|
|
|
|
if (resolve)
|
|
|
|
{
|
|
|
|
/* Increment the link counter. This is necessary to avoid
|
|
|
|
* infinite recursion if loops are encountered in the
|
|
|
|
* traversal. If we encounter more SYMLOOP_MAX symbolic links
|
|
|
|
* at any time during the traversal, error out.
|
|
|
|
*
|
|
|
|
* NOTE: That inode_search() will automatically skip over
|
|
|
|
* consecutive, intermediate symbolic links. Those numbers
|
|
|
|
* will not be included in the total.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (resolve > SYMLOOP_MAX)
|
|
|
|
{
|
|
|
|
return -ELOOP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* chstat() the target of the soft link. */
|
|
|
|
|
|
|
|
return chstat_recursive(inode->u.i_link, buf, flags, ++resolve);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_PSEUDOFS_ATTRIBUTES
|
|
|
|
if (flags & CH_STAT_MODE)
|
|
|
|
{
|
|
|
|
inode->i_mode = buf->st_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & CH_STAT_UID)
|
|
|
|
{
|
|
|
|
inode->i_owner = buf->st_uid;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & CH_STAT_GID)
|
|
|
|
{
|
|
|
|
inode->i_group = buf->st_gid;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & CH_STAT_ATIME)
|
|
|
|
{
|
|
|
|
inode->i_atime = buf->st_atim;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & CH_STAT_MTIME)
|
|
|
|
{
|
|
|
|
inode->i_mtime = buf->st_mtim;
|
|
|
|
}
|
|
|
|
|
|
|
|
inode->i_ctime = buf->st_ctim;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|