vfs: check userland buffers before reading them.

[haiku.git] / src / bin / copyattr.cpp

/*
 * Copyright 2005-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <Directory.h>
#include <Entry.h>
#include <File.h>
#include <fs_attr.h>
#include <Mime.h>
#include <Node.h>
#include <Path.h>
#include <SymLink.h>
#include <TypeConstants.h>

#include <EntryFilter.h>


using BPrivate::EntryFilter;


static const char *kCommandName = "copyattr";
static const int kCopyBufferSize = 64 * 1024;   // 64 KB

static int kArgc;
static const char *const *kArgv;

// usage
const char *kUsage =
"Usage: %s <options> <source> [ ... ] <destination>\n"
"\n"
"Copies attributes from one or more files to another, or copies one or more\n"
"files or directories, with all or a specified subset of their attributes, to\n"
"another location.\n"
"\n"
"If option \"-d\"/\"--data\" is given, the behavior is similar to \"cp -df\",\n"
"save that attributes are copied. That is, if more than one source file is\n"
"given, the destination file must be a directory. If the destination is a\n"
"directory (or a symlink to a directory), the source files are copied into\n"
"the destination directory. Entries that are in the way are removed, unless\n"
"they are directories. If the source is a directory too, the attributes will\n"
"be copied and, if recursive operation is specified, the program continues\n"
"copying the contents of the source directory. If the source is not a\n"
"directory the program aborts with an error message.\n"
"\n"
"If option \"-d\"/\"--data\" is not given, only attributes are copied.\n"
"Regardless of the file type of the destination, the attributes of the source\n"
"files are copied to it. If an attribute with the same name as one to be\n"
"copied already exists, it is replaced. If more than one source file is\n"
"specified the semantics are similar to invoking the program multiple times\n"
"with the same options and destination and only one source file at a time,\n"
"in the order the source files are given. If recursive operation is\n"
"specified, the program recursively copies the attributes of the directory\n"
"contents; if the destination file is not a directory, or for a source entry\n"
"there exists no destination entry, the program aborts with an error\n"
"message.\n"
"\n"
"Note, that the behavior of the program differs from the one shipped with\n"
"BeOS R5.\n"
"\n"
"Options:\n"
"  -d, --data         - Copy the data of the file(s), too.\n"
"  -h, --help         - Print this help text and exit.\n"
"  -m, --move         - If -d is given, the source files are removed after\n"
"                       being copied. Has no effect otherwise.\n"
"  -n, --name <name>  - Only copy the attribute with name <name>.\n"
"  -r, --recursive    - Copy directories recursively.\n"
"  -t, --type <type>  - Copy only the attributes of type <type>. If -n is\n"
"                       specified too, only the attribute matching the name\n"
"                       and the type is copied.\n"
"  -x <pattern>       - Exclude source entries matching <pattern>.\n"
"  -X <pattern>       - Exclude source paths matching <pattern>.\n"
"  -v, --verbose      - Print more messages.\n"
"   -, --             - Marks the end of options. The arguments after, even\n"
"                       if starting with \"-\" are considered file names.\n"
"\n"
"Parameters:\n"
"  <type>             - One of: int, llong, string, mimestr, float, double,\n"
"                       boolean.\n"
;

// supported attribute types
struct supported_attribute_type {
        const char      *type_name;
        type_code       type;
};

const supported_attribute_type kSupportedAttributeTypes[] = {
        { "int",                B_INT32_TYPE },
        { "llong",              B_INT64_TYPE },
        { "string",             B_STRING_TYPE },
        { "mimestr",    B_MIME_STRING_TYPE },
        { "float",              B_FLOAT_TYPE },
        { "double",             B_DOUBLE_TYPE },
        { "boolean",    B_BOOL_TYPE },
        { NULL, 0 },
};

// AttributeFilter
struct AttributeFilter {
        AttributeFilter()
                :
                fName(NULL),
                fType(B_ANY_TYPE)
        {
        }

        void SetTo(const char *name, type_code type)
        {
                fName = name;
                fType = type;
        }

        bool Filter(const char *name, type_code type) const {
                if (fName && strcmp(name, fName) != 0)
                        return false;

                return (fType == B_ANY_TYPE || type == fType);
        }

private:
        const char      *fName;
        type_code       fType;
};


// Parameters
struct Parameters {
        Parameters()
                :
                copy_data(false),
                recursive(false),
                move_files(false),
                verbose(false)
        {
        }

        bool                    copy_data;
        bool                    recursive;
        bool                    move_files;
        bool                    verbose;
        AttributeFilter attribute_filter;
        EntryFilter             entry_filter;
};


// print_usage
static void
print_usage(bool error)
{
        // get command name
        const char *commandName = NULL;
        if (kArgc > 0) {
                if (const char *lastSlash = strchr(kArgv[0], '/'))
                        commandName = lastSlash + 1;
                else
                        commandName = kArgv[0];
        }

        if (!commandName || strlen(commandName) == 0)
                commandName = kCommandName;

        // print usage
        fprintf((error ? stderr : stdout), kUsage, commandName);
}


// print_usage_and_exit
static void
print_usage_and_exit(bool error)
{
        print_usage(error);
        exit(error ? 1 : 0);
}


// next_arg
static const char *
next_arg(int &argi, bool optional = false)
{
        if (argi >= kArgc) {
                if (!optional)
                        print_usage_and_exit(true);
                return NULL;
        }

        return kArgv[argi++];
}


// copy_attributes
static void
copy_attributes(const char *sourcePath, BNode &source, const char *destPath,
        BNode &destination, const Parameters &parameters)
{
        char attrName[B_ATTR_NAME_LENGTH];
        while (source.GetNextAttrName(attrName) == B_OK) {
                // get attr info
                attr_info attrInfo;
                status_t error = source.GetAttrInfo(attrName, &attrInfo);
                if (error != B_OK) {
                        fprintf(stderr, "Error: Failed to get info of attribute \"%s\" "
                                "of file \"%s\": %s\n", attrName, sourcePath, strerror(error));
                        exit(1);
                }

                // filter
                if (!parameters.attribute_filter.Filter(attrName, attrInfo.type))
                        continue;

                // copy the attribute
                char buffer[kCopyBufferSize];
                off_t offset = 0;
                off_t bytesLeft = attrInfo.size;
                // go at least once through the loop, so that empty attribute will be
                // created as well
                do {
                        size_t toRead = kCopyBufferSize;
                        if ((off_t)toRead > bytesLeft)
                                toRead = bytesLeft;

                        // read
                        ssize_t bytesRead = source.ReadAttr(attrName, attrInfo.type,
                                offset, buffer, toRead);
                        if (bytesRead < 0) {
                                fprintf(stderr, "Error: Failed to read attribute \"%s\" "
                                        "of file \"%s\": %s\n", attrName, sourcePath,
                                        strerror(bytesRead));
                                exit(1);
                        }

                        // write
                        ssize_t bytesWritten = destination.WriteAttr(attrName,
                                attrInfo.type, offset, buffer, bytesRead);
                        if (bytesWritten < 0) {
                                fprintf(stderr, "Error: Failed to write attribute \"%s\" "
                                        "of file \"%s\": %s\n", attrName, destPath,
                                        strerror(bytesWritten));
                                exit(1);
                        }

                        bytesLeft -= bytesRead;
                        offset += bytesRead;

                } while (bytesLeft > 0);
        }
}


// copy_file_data
static void
copy_file_data(const char *sourcePath, BFile &source, const char *destPath,
        BFile &destination, const Parameters &parameters)
{
        char buffer[kCopyBufferSize];
        off_t offset = 0;
        while (true) {
                // read
                ssize_t bytesRead = source.ReadAt(offset, buffer, sizeof(buffer));
                if (bytesRead < 0) {
                        fprintf(stderr, "Error: Failed to read from file \"%s\": %s\n",
                                sourcePath, strerror(bytesRead));
                        exit(1);
                }

                if (bytesRead == 0)
                        return;

                // write
                ssize_t bytesWritten = destination.WriteAt(offset, buffer, bytesRead);
                if (bytesWritten < 0) {
                        fprintf(stderr, "Error: Failed to write to file \"%s\": %s\n",
                                destPath, strerror(bytesWritten));
                        exit(1);
                }

                offset += bytesRead;
        }
}


// copy_entry
static void
copy_entry(const char *sourcePath, const char *destPath,
        const Parameters &parameters)
{
        // apply entry filter
        if (!parameters.entry_filter.Filter(sourcePath))
                return;

        // stat source
        struct stat sourceStat;
        if (lstat(sourcePath, &sourceStat) < 0) {
                fprintf(stderr, "Error: Couldn't access \"%s\": %s\n", sourcePath,
                        strerror(errno));
                exit(1);
        }

        // stat destination
        struct stat destStat;
        bool destExists = lstat(destPath, &destStat) == 0;

        if (!destExists && !parameters.copy_data) {
                fprintf(stderr, "Error: Destination file \"%s\" does not exist.\n",
                        destPath);
                exit(1);
        }

        if (parameters.verbose)
                printf("%s\n", destPath);

        // check whether to delete/create the destination
        bool unlinkDest = (destExists && parameters.copy_data);
        bool createDest = parameters.copy_data;
        if (destExists) {
                if (S_ISDIR(destStat.st_mode)) {
                        if (S_ISDIR(sourceStat.st_mode)) {
                                // both are dirs; nothing to do
                                unlinkDest = false;
                                createDest = false;
                        } else if (parameters.copy_data || parameters.recursive) {
                                // destination is directory, but source isn't, and mode is
                                // not non-recursive attributes-only copy
                                fprintf(stderr, "Error: Can't copy \"%s\", since directory "
                                        "\"%s\" is in the way.\n", sourcePath, destPath);
                                exit(1);
                        }
                }
        }

        // unlink the destination
        if (unlinkDest) {
                if (unlink(destPath) < 0) {
                        fprintf(stderr, "Error: Failed to unlink \"%s\": %s\n", destPath,
                                strerror(errno));
                        exit(1);
                }
        }

        // open source node
        BNode _sourceNode;
        BFile sourceFile;
        BDirectory sourceDir;
        BNode *sourceNode = NULL;
        status_t error;

        if (S_ISDIR(sourceStat.st_mode)) {
                error = sourceDir.SetTo(sourcePath);
                sourceNode = &sourceDir;
        } else if (S_ISREG(sourceStat.st_mode)) {
                error = sourceFile.SetTo(sourcePath, B_READ_ONLY);
                sourceNode = &sourceFile;
        } else {
                error = _sourceNode.SetTo(sourcePath);
                sourceNode = &_sourceNode;
        }

        if (error != B_OK) {
                fprintf(stderr, "Error: Failed to open \"%s\": %s\n",
                        sourcePath, strerror(error));
                exit(1);
        }

        // create the destination
        BNode _destNode;
        BDirectory destDir;
        BFile destFile;
        BSymLink destSymLink;
        BNode *destNode = NULL;

        if (createDest) {
                if (S_ISDIR(sourceStat.st_mode)) {
                        // create dir
                        error = BDirectory().CreateDirectory(destPath, &destDir);
                        if (error != B_OK) {
                                fprintf(stderr, "Error: Failed to make directory \"%s\": %s\n",
                                        destPath, strerror(error));
                                exit(1);
                        }

                        destNode = &destDir;

                } else if (S_ISREG(sourceStat.st_mode)) {
                        // create file
                        error = BDirectory().CreateFile(destPath, &destFile);
                        if (error != B_OK) {
                                fprintf(stderr, "Error: Failed to create file \"%s\": %s\n",
                                        destPath, strerror(error));
                                exit(1);
                        }

                        destNode = &destFile;

                        // copy file contents
                        copy_file_data(sourcePath, sourceFile, destPath, destFile,
                                parameters);

                } else if (S_ISLNK(sourceStat.st_mode)) {
                        // read symlink
                        char linkTo[B_PATH_NAME_LENGTH + 1];
                        ssize_t bytesRead = readlink(sourcePath, linkTo,
                                sizeof(linkTo) - 1);
                        if (bytesRead < 0) {
                                fprintf(stderr, "Error: Failed to read symlink \"%s\": %s\n",
                                        sourcePath, strerror(errno));
                                exit(1);
                        }

                        // null terminate the link contents
                        linkTo[bytesRead] = '\0';

                        // create symlink
                        error = BDirectory().CreateSymLink(destPath, linkTo, &destSymLink);
                        if (error != B_OK) {
                                fprintf(stderr, "Error: Failed to create symlink \"%s\": %s\n",
                                        destPath, strerror(error));
                                exit(1);
                        }

                        destNode = &destSymLink;

                } else {
                        fprintf(stderr, "Error: Source file \"%s\" has unsupported type.\n",
                                sourcePath);
                        exit(1);
                }

                // copy attributes (before setting the permissions!)
                copy_attributes(sourcePath, *sourceNode, destPath, *destNode,
                        parameters);

                // set file owner, group, permissions, times
                destNode->SetOwner(sourceStat.st_uid);
                destNode->SetGroup(sourceStat.st_gid);
                destNode->SetPermissions(sourceStat.st_mode);
                #ifdef HAIKU_TARGET_PLATFORM_HAIKU
                        destNode->SetCreationTime(sourceStat.st_crtime);
                #endif
                destNode->SetModificationTime(sourceStat.st_mtime);

        } else {
                // open destination node
                error = _destNode.SetTo(destPath);
                if (error != B_OK) {
                        fprintf(stderr, "Error: Failed to open \"%s\": %s\n",
                                destPath, strerror(error));
                        exit(1);
                }

                destNode = &_destNode;

                // copy attributes
                copy_attributes(sourcePath, *sourceNode, destPath, *destNode,
                        parameters);
        }

        // the destination node is no longer needed
        destNode->Unset();

        // recurse
        if (parameters.recursive && S_ISDIR(sourceStat.st_mode)) {
                char buffer[sizeof(dirent) + B_FILE_NAME_LENGTH];
                dirent *entry = (dirent*)buffer;
                while (sourceDir.GetNextDirents(entry, sizeof(buffer), 1) == 1) {
                        if (strcmp(entry->d_name, ".") == 0
                                || strcmp(entry->d_name, "..") == 0) {
                                continue;
                        }

                        // construct new entry paths
                        BPath sourceEntryPath;
                        error = sourceEntryPath.SetTo(sourcePath, entry->d_name);
                        if (error != B_OK) {
                                fprintf(stderr, "Error: Failed to construct entry path from "
                                        "dir \"%s\" and name \"%s\": %s\n",
                                        sourcePath, entry->d_name, strerror(error));
                                exit(1);
                        }

                        BPath destEntryPath;
                        error = destEntryPath.SetTo(destPath, entry->d_name);
                        if (error != B_OK) {
                                fprintf(stderr, "Error: Failed to construct entry path from "
                                        "dir \"%s\" and name \"%s\": %s\n",
                                        destPath, entry->d_name, strerror(error));
                                exit(1);
                        }

                        // copy the entry
                        copy_entry(sourceEntryPath.Path(), destEntryPath.Path(),
                                parameters);
                }
        }

        // remove source in move mode
        if (parameters.move_files) {
                if (S_ISDIR(sourceStat.st_mode)) {
                        if (rmdir(sourcePath) < 0) {
                                fprintf(stderr, "Error: Failed to remove \"%s\": %s\n",
                                        sourcePath, strerror(errno));
                                exit(1);
                        }

                } else {
                        if (unlink(sourcePath) < 0) {
                                fprintf(stderr, "Error: Failed to unlink \"%s\": %s\n",
                                        sourcePath, strerror(errno));
                                exit(1);
                        }
                }
        }
}

// copy_files
static void
copy_files(const char **sourcePaths, int sourceCount,
        const char *destPath, const Parameters &parameters)
{
        // check, if destination exists
        BEntry destEntry;
        status_t error = destEntry.SetTo(destPath);
        if (error != B_OK) {
                fprintf(stderr, "Error: Couldn't access \"%s\": %s\n", destPath,
                        strerror(error));
                exit(1);
        }
        bool destExists = destEntry.Exists();

        // If it exists, check whether it is a directory. In case we don't copy
        // the data, we pretend the destination is no directory, even if it is
        // one.
        bool destIsDir = false;
        if (destExists && parameters.copy_data) {
                struct stat st;
                error = destEntry.GetStat(&st);
                if (error != B_OK) {
                        fprintf(stderr, "Error: Failed to stat \"%s\": %s\n", destPath,
                                strerror(error));
                        exit(1);
                }

                if (S_ISDIR(st.st_mode)) {
                        destIsDir = true;
                } else if (S_ISLNK(st.st_mode)) {
                        // a symlink -- check if it refers to a dir
                        BEntry resolvedDestEntry;
                        if (resolvedDestEntry.SetTo(destPath, true) == B_OK
                                && resolvedDestEntry.IsDirectory()) {
                                destIsDir = true;
                        }
                }
        }

        // If we have multiple source files, the destination should be a directory,
        // if we want to copy the file data.
        if (sourceCount > 1 && parameters.copy_data && !destIsDir) {
                fprintf(stderr, "Error: Destination needs to be a directory when "
                        "multiple source files are specified and option \"-d\" is "
                        "given.\n");
                exit(1);
        }

        // iterate through the source files
        for (int i = 0; i < sourceCount; i++) {
                const char *sourcePath = sourcePaths[i];
                // If the destination is a directory, we usually want to copy the
                // sources into it. The user might have specified a source path ending
                // in "/." or "/.." however, in which case we copy the contents of the
                // given directory.
                bool copySourceContentsOnly = false;
                if (destIsDir) {
                        // skip trailing '/'s
                        int sourceLen = strlen(sourcePath);
                        while (sourceLen > 1 && sourcePath[sourceLen - 1] == '/')
                                sourceLen--;

                        // find the start of the leaf name
                        int leafStart = sourceLen;
                        while (leafStart > 0 && sourcePath[leafStart - 1] != '/')
                                leafStart--;

                        // If the path is the root directory or the leaf is "." or "..",
                        // we copy the contents only.
                        int leafLen = sourceLen - leafStart;
                        if (leafLen == 0 || (leafLen <= 2
                                        && strncmp(sourcePath + leafStart, "..", leafLen) == 0)) {
                                copySourceContentsOnly = true;
                        }
                }

                if (destIsDir && !copySourceContentsOnly) {
                        // construct a usable destination entry path
                        // normalize source path
                        BPath normalizedSourcePath;
                        error = normalizedSourcePath.SetTo(sourcePath);
                        if (error != B_OK) {
                                fprintf(stderr, "Error: Invalid path \"%s\".\n", sourcePath);
                                exit(1);
                        }

                        BPath destEntryPath;
                        error = destEntryPath.SetTo(destPath, normalizedSourcePath.Leaf());
                        if (error != B_OK) {
                                fprintf(stderr, "Error: Failed to get destination path for "
                                        "source \"%s\" and destination directory \"%s\".\n",
                                        sourcePath, destPath);
                                exit(1);
                        }

                        copy_entry(normalizedSourcePath.Path(), destEntryPath.Path(),
                                parameters);
                } else {
                        copy_entry(sourcePath, destPath, parameters);
                }
        }
}


// main
int
main(int argc, const char *const *argv)
{
        kArgc = argc;
        kArgv = argv;

        // parameters
        Parameters parameters;
        const char *attributeName = NULL;
        const char *attributeTypeString = NULL;
        const char **files = new const char*[argc];
        int fileCount = 0;

        // parse the arguments
        bool moreOptions = true;
        for (int argi = 1; argi < argc; ) {
                const char *arg = argv[argi++];
                if (moreOptions && arg[0] == '-') {
                        if (strcmp(arg, "-d") == 0 || strcmp(arg, "--data") == 0) {
                                parameters.copy_data = true;

                        } else if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) {
                                print_usage_and_exit(false);

                        } else if (strcmp(arg, "-m") == 0 || strcmp(arg, "--move") == 0) {
                                parameters.move_files = true;

                        } else if (strcmp(arg, "-n") == 0 || strcmp(arg, "--name") == 0) {
                                if (attributeName) {
                                        fprintf(stderr, "Error: Only one attribute name can be "
                                                "specified.\n");
                                        exit(1);
                                }

                                attributeName = next_arg(argi);

                        } else if (strcmp(arg, "-r") == 0
                                        || strcmp(arg, "--recursive") == 0) {
                                parameters.recursive = true;

                        } else if (strcmp(arg, "-t") == 0 || strcmp(arg, "--type") == 0) {
                                if (attributeTypeString) {
                                        fprintf(stderr, "Error: Only one attribute type can be "
                                                "specified.\n");
                                        exit(1);
                                }

                                attributeTypeString = next_arg(argi);

                        } else if (strcmp(arg, "-v") == 0
                                        || strcmp(arg, "--verbose") == 0) {
                                parameters.verbose = true;

                        } else if (strcmp(arg, "-x") == 0) {
                                parameters.entry_filter.AddExcludeFilter(next_arg(argi), true);

                        } else if (strcmp(arg, "-X") == 0) {
                                parameters.entry_filter.AddExcludeFilter(next_arg(argi), false);

                        } else if (strcmp(arg, "-") == 0 || strcmp(arg, "--") == 0) {
                                moreOptions = false;

                        } else {
                                fprintf(stderr, "Error: Invalid option: \"%s\"\n", arg);
                                print_usage_and_exit(true);
                        }

                } else {
                        // file
                        files[fileCount++] = arg;
                }
        }

        // check parameters

        // enough files
        if (fileCount < 2) {
                fprintf(stderr, "Error: Not enough file names specified.\n");
                print_usage_and_exit(true);
        }

        // attribute type
        type_code attributeType = B_ANY_TYPE;
        if (attributeTypeString) {
                bool found = false;
                for (int i = 0; kSupportedAttributeTypes[i].type_name; i++) {
                        if (strcmp(attributeTypeString,
                                        kSupportedAttributeTypes[i].type_name) == 0) {
                                found = true;
                                attributeType = kSupportedAttributeTypes[i].type;
                                break;
                        }
                }

                if (!found) {
                        fprintf(stderr, "Error: Unsupported attribute type: \"%s\"\n",
                                attributeTypeString);
                        exit(1);
                }
        }

        // init the attribute filter
        parameters.attribute_filter.SetTo(attributeName, attributeType);

        // turn of move_files, if we are not copying the file data
        parameters.move_files &= parameters.copy_data;

        // do the copying
        fileCount--;
        const char *destination = files[fileCount];
        files[fileCount] = NULL;
        copy_files(files, fileCount, destination, parameters);

        return 0;
}