/**
* set the stat() data of a file
**/
int setfile(const char *path, struct stat *fs)
{
DBG_IN();
struct utimbuf ut;
int rval;
rval = 0;
fs->st_mode &= S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
ut.actime = fs->st_atime;
ut.modtime = fs->st_mtime;
if (utime(path, &ut)) {
usyslog(LOG_WARNING, "utimes: %s", path);
rval = 1;
}
/*
* Changing the ownership probably won't succeed, unless we're root
* or POSIX_CHOWN_RESTRICTED is not set. Set uid/gid before setting
* the mode; current BSD behavior is to remove all setuid bits on
* chown. If chown fails, lose setuid/setgid bits.
*/
if (chown(path, fs->st_uid, fs->st_gid)) {
if (errno != EPERM) {
usyslog(LOG_WARNING, "chown: %s", path);
rval = 1;
}
fs->st_mode &= ~(S_ISTXT | S_ISUID | S_ISGID);
}
if (chmod(path, fs->st_mode)) {
usyslog(LOG_WARNING, "chown: %s", path);
rval = 1;
}
#ifdef HAVE_CHFLAGS
/*
* XXX
* NFS doesn't support chflags; ignore errors unless there's reason
* to believe we're losing bits. (Note, this still won't be right
* if the server supports flags and we were trying to *remove* flags
* on a file that we copied, i.e., that we didn't create.)
*/
errno = 0;
if (chflags(path, fs->st_flags)) {
if (errno != EOPNOTSUPP || fs->st_flags != 0) {
usyslog(LOG_WARNING, "chflags: %s", path);
rval = 1;
}
return (rval);
}
#endif
return 0;
}
/**
* copy a special file, actually we recreate this file and only copy
* its stat() data
*/
int copy_special(struct cow *cow)
{
DBG_IN();
if (mknod(cow->to_path, cow->stat->st_mode, cow->stat->st_rdev)) {
usyslog(LOG_WARNING, "mknod: %s", cow->to_path);
return (1);
}
return setfile(cow->to_path, cow->stat);
}
/**
* copy a fifo, actually we recreate the fifo and only copy
* its stat() data
**/
int copy_fifo(struct cow *cow)
{
DBG_IN();
if (mkfifo(cow->to_path, cow->stat->st_mode)) {
usyslog(LOG_WARNING, "mkfifo: %s", cow->to_path);
return (1);
}
return setfile(cow->to_path, cow->stat);
}
/**
* copy a link, actually we recreate the link and only copy its stat() data.
*/
int copy_link(struct cow *cow)
{
DBG_IN();
int len;
char link[PATHLEN_MAX];
if ((len = readlink(cow->from_path, link, sizeof(link)-1)) == -1) {
usyslog(LOG_WARNING, "readlink: %s", cow->from_path);
return (1);
}
link[len] = '\0';
if (symlink(link, cow->to_path)) {
usyslog(LOG_WARNING, "symlink: %s", link);
return (1);
}
return setlink(cow->to_path, cow->stat);
}
/**
* set the stat() data of a link
**/
static int setlink(const char *path, struct stat *fs)
{
DBG_IN();
if (lchown(path, fs->st_uid, fs->st_gid)) {
if (errno != EPERM) {
usyslog(LOG_WARNING, "lchown: %s", path);
return (1);
}
}
return (0);
}
/**
* initiate the cow-copy action
*/
int cow_cp(const char *path, int branch_ro, int branch_rw) {
DBG_IN();
// create the path to the file
path_create_cutlast(path, branch_ro, branch_rw);
char from[PATHLEN_MAX], to[PATHLEN_MAX];
snprintf(from, PATHLEN_MAX, "%s%s", uopt.branches[branch_ro].path, path);
snprintf(to, PATHLEN_MAX, "%s%s", uopt.branches[branch_rw].path, path);
setlocale(LC_ALL, "");
struct cow cow;
cow.uid = getuid();
// Copy the umask for explicit mode setting.
cow.umask = umask(0);
umask(cow.umask);
cow.from_path = from;
cow.to_path = to;
struct stat buf;
lstat(cow.from_path, &buf);
cow.stat = &buf;
int res;
switch (buf.st_mode & S_IFMT) {
case S_IFLNK:
res = copy_link(&cow);
break;
case S_IFDIR:
res = copy_directory(path, branch_ro, branch_rw);
break;
case S_IFBLK:
case S_IFCHR:
res = copy_special(&cow);
break;
case S_IFIFO:
res = copy_fifo(&cow);
break;
case S_IFSOCK:
usyslog(LOG_WARNING, "COW of sockets not supported: %s\n", cow.from_path);
return 1;
default:
res = copy_file(&cow);
}
return res;
}
/**
* Actually create the directory here.
*/
static int do_create(const char *path, int nbranch_ro, int nbranch_rw) {
DBG_IN();
char dirp[PATHLEN_MAX]; // dir path to create
sprintf(dirp, "%s%s", uopt.branches[nbranch_rw].path, path);
struct stat buf;
int res = stat(dirp, &buf);
if (res != -1) return 0; // already exists
if (nbranch_ro == nbranch_rw) {
// special case nbranch_ro = nbranch_rw, this is if we a create
// unionfs meta directories, so not directly on cow operations
buf.st_mode = S_IRWXU | S_IRWXG;
} else {
// data from the ro-branch
char o_dirp[PATHLEN_MAX]; // the pathname we want to copy
sprintf(o_dirp, "%s%s", uopt.branches[nbranch_ro].path, path);
res = stat(o_dirp, &buf);
if (res == -1) return 1; // lower level branch removed in the mean time?
}
res = mkdir(dirp, buf.st_mode);
if (res == -1) {
usyslog(LOG_DAEMON, "Creating %s failed: \n", dirp);
return 1;
}
if (nbranch_ro == nbranch_rw) return 0; // the special case again
if (setfile(dirp, &buf)) return 1; // directory already removed by another process?
// TODO: time, but its values are modified by the next dir/file creation steps?
return 0;
}
int lpc31_usbhost_initialize(void)
{
pid_t pid;
int ret;
/* First, register all of the class drivers needed to support the drivers
* that we care about
*/
#ifdef CONFIG_USBHOST_HUB
/* Initialize USB hub support */
ret = usbhost_hub_initialize();
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: usbhost_hub_initialize failed: %d\n", ret);
}
#endif
#ifdef CONFIG_USBHOST_MSC
/* Register the USB host Mass Storage Class */
ret = usbhost_msc_initialize();
if (ret != OK)
{
usyslog(LOG_ERR, "ERROR: Failed to register the mass storage class: %d\n", ret);
}
#endif
#ifdef CONFIG_USBHOST_CDCACM
/* Register the CDC/ACM serial class */
ret = usbhost_cdcacm_initialize();
if (ret != OK)
{
uerr("ERROR: Failed to register the CDC/ACM serial class\n");
}
#endif
#ifdef CONFIG_USBHOST_HIDKBD
/* Register the USB host HID keyboard class driver */
ret = usbhost_kbdinit();
if (ret != OK)
{
uerr("ERROR: Failed to register the KBD class\n");
}
#endif
/* Then get an instance of the USB EHCI interface. */
g_ehciconn = lpc31_ehci_initialize(0);
if (!g_ehciconn)
{
uerr("ERROR: lpc31_ehci_initialize failed\n");
return -ENODEV;
}
/* Start a thread to handle device connection. */
pid = kthread_create("EHCI Monitor", CONFIG_USBHOST_DEFPRIO,
CONFIG_USBHOST_STACKSIZE,
(main_t)ehci_waiter, (FAR char * const *)NULL);
if (pid < 0)
{
uerr("ERROR: Failed to create ehci_waiter task: %d\n", ret);
return -ENODEV;
}
return OK;
}
/**
* copy an ordinary file with all of its stat() data
**/
int copy_file(struct cow *cow)
{
DBG_IN();
static char buf[MAXBSIZE];
struct stat to_stat, *fs;
int from_fd, rcount, to_fd, wcount;
int rval = 0;
#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
char *p;
#endif
if ((from_fd = open(cow->from_path, O_RDONLY, 0)) == -1) {
usyslog(LOG_WARNING, "%s", cow->from_path);
return (1);
}
fs = cow->stat;
to_fd = open(cow->to_path, O_WRONLY | O_TRUNC | O_CREAT,
fs->st_mode & ~(S_ISTXT | S_ISUID | S_ISGID));
if (to_fd == -1) {
usyslog(LOG_WARNING, "%s", cow->to_path);
(void)close(from_fd);
return (1);
}
/*
* Mmap and write if less than 8M (the limit is so we don't totally
* trash memory on big files. This is really a minor hack, but it
* wins some CPU back.
*/
#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
if (fs->st_size > 0 && fs->st_size <= 8 * 1048576) {
if ((p = mmap(NULL, (size_t)fs->st_size, PROT_READ,
MAP_FILE|MAP_SHARED, from_fd, (off_t)0)) == MAP_FAILED) {
usyslog(LOG_WARNING, "mmap: %s", cow->from_path);
rval = 1;
} else {
madvise(p, fs->st_size, MADV_SEQUENTIAL);
if (write(to_fd, p, fs->st_size) != fs->st_size) {
usyslog(LOG_WARNING, "%s", cow->to_path);
rval = 1;
}
/* Some systems don't unmap on close(2). */
if (munmap(p, fs->st_size) < 0) {
usyslog(LOG_WARNING, "%s", cow->from_path);
rval = 1;
}
}
} else
#endif
{
while ((rcount = read(from_fd, buf, MAXBSIZE)) > 0) {
wcount = write(to_fd, buf, rcount);
if (rcount != wcount || wcount == -1) {
usyslog(LOG_WARNING, "%s", cow->to_path);
rval = 1;
break;
}
}
if (rcount < 0) {
usyslog(LOG_WARNING, "copy failed: %s", cow->from_path);
return 1;
}
}
if (rval == 1) {
(void)close(from_fd);
(void)close(to_fd);
return (1);
}
if (setfile(cow->to_path, cow->stat))
rval = 1;
/*
* If the source was setuid or setgid, lose the bits unless the
* copy is owned by the same user and group.
*/
#define RETAINBITS \
(S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO)
else if (fs->st_mode & (S_ISUID | S_ISGID) && fs->st_uid == cow->uid) {
if (fstat(to_fd, &to_stat)) {
usyslog(LOG_WARNING, "%s", cow->to_path);
rval = 1;
} else if (fs->st_gid == to_stat.st_gid &&
fchmod(to_fd, fs->st_mode & RETAINBITS & ~cow->umask)) {
usyslog(LOG_WARNING, "%s", cow->to_path);
rval = 1;
}
}
(void)close(from_fd);
if (close(to_fd)) {
usyslog(LOG_WARNING, "%s", cow->to_path);
rval = 1;
}
return (rval);
}
