/*
 * Copyright (c) 2003 Matthew Dillon <dillon@backplane.com>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $DragonFly: src/sbin/newfs/fscopy.c,v 1.7 2005/08/08 17:06:18 joerg Exp $
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdarg.h>
#include <unistd.h>
#include <fcntl.h>
#include <dirent.h>
#include <errno.h>
#ifdef DIRBLKSIZ
#undef DIRBLKSIZ
#endif
#include "defs.h"

struct FSNode {
    struct FSNode	*fs_Next;
    struct FSNode	*fs_HNext;
    struct FSNode	*fs_Base;
    struct FSNode	*fs_Parent;
    struct stat		fs_St;
    char		*fs_Data;
    int			fs_Bytes;
    int			fs_Marker;
    char		fs_Name[4];
};

static
fsnode_t
fsmknode(const char *path)
{
    int pathlen = strlen(path);
    fsnode_t node = malloc(offsetof(struct FSNode, fs_Name[pathlen+1]));

    if (node == NULL) {
	fprintf(stderr, "ran out of memory copying filesystem\n");
	return(NULL);
    }
    bzero(node, sizeof(*node));
    bcopy(path, node->fs_Name, pathlen + 1);
    if (lstat(path, &node->fs_St) < 0) {
	fprintf(stderr, "Unable to lstat(\"%s\")\n", path);
	free(node);
	return(NULL);
    }
    return(node);
}

static fsnode_t
fsgethlink(fsnode_t hlinks, fsnode_t node)
{
    fsnode_t scan;

    for (scan = hlinks; scan; scan = scan->fs_HNext) {
	if (scan->fs_St.st_dev == node->fs_St.st_dev &&
	    scan->fs_St.st_ino == node->fs_St.st_ino
	) {
	    return(scan);
	}
    }
    return(NULL);
}

static char *
fshardpath(fsnode_t hlink, fsnode_t node)
{
    fsnode_t scan;
    char *path;
    char *tmp;

    for (scan = hlink; scan; scan = scan->fs_Parent)
	scan->fs_Marker = 1;
    for (scan = node; scan; scan = scan->fs_Parent) {
	if (scan->fs_Marker == 1) {
	    scan->fs_Marker = 2;
	    break;
	}
    }
    if (scan == NULL)
	return(NULL);

    /*
     * Build the path backwards
     */
    asprintf(&path, "%s", hlink->fs_Name);
    for (scan = hlink->fs_Parent; scan->fs_Marker == 1; scan = scan->fs_Parent) {
	tmp = path;
	asprintf(&path, "%s/%s", scan->fs_Name, tmp);
	free(tmp);
    }
    for (scan = node->fs_Parent; scan; scan = scan->fs_Parent) {
	if (scan->fs_Marker == 2)
	    break;
	tmp = path;
	asprintf(&path, "../%s", tmp);
	free(tmp);
    }

    for (scan = hlink; scan; scan = scan->fs_Parent)
	scan->fs_Marker = 0;
    for (scan = node; scan; scan = scan->fs_Parent)
	scan->fs_Marker = 0;
    return(path);
}

fsnode_t
FSCopy(fsnode_t *phlinks, const char *path)
{
    int n;
    DIR *dir;
    fsnode_t node;
    char buf[1024];

    node = fsmknode(path);
    if (node) {
	switch(node->fs_St.st_mode & S_IFMT) {
	case S_IFIFO:
	    break;
	case S_IFCHR:
	    break;
	case S_IFDIR:
	    if ((dir = opendir(path)) != NULL) {
		struct dirent *den;
		fsnode_t scan;
		fsnode_t *pscan;

		if (chdir(path) < 0) {
		    fprintf(stderr, "Unable to chdir into %s\n", path);
		    break;
		}
		pscan = &node->fs_Base;
		while ((den = readdir(dir)) != NULL) {
		    if (strcmp(den->d_name, ".") == 0)
			continue;
		    if (strcmp(den->d_name, "..") == 0)
			continue;
		    scan = FSCopy(phlinks, den->d_name);
		    if (scan) {
			*pscan = scan;
			scan->fs_Parent = node;
			pscan = &scan->fs_Next;
		    }
		}
		if (chdir("..") < 0) {
		    fprintf(stderr, "Unable to chdir .. after scanning %s\n", path);
		    exit(1);
		}
		closedir(dir);
	    }
	    break;
	case S_IFBLK:
	    break;
	case S_IFREG:
	    if (node->fs_St.st_nlink > 1 && fsgethlink(*phlinks, node)) {
		node->fs_Bytes = -1;	/* hardlink indicator */
	    } else if (node->fs_St.st_size >= 0x80000000LL) {
		fprintf(stderr, "File %s too large to copy\n", path);
		free(node);
		node = NULL;
	    } else if ((node->fs_Data = malloc(node->fs_St.st_size)) == NULL) {
		fprintf(stderr, "Ran out of memory copying %s\n", path);
		free(node);
		node = NULL;
	    } else if ((n = open(path, O_RDONLY)) < 0) {
		fprintf(stderr, "Unable to open %s for reading\n", path);
		free(node->fs_Data);
		free(node);
		node = NULL;
	    } else if (read(n, node->fs_Data, node->fs_St.st_size) != node->fs_St.st_size) {
		fprintf(stderr, "Unable to read %s\n", path);
		free(node->fs_Data);
		free(node);
		node = NULL;
		
	    } else {
		node->fs_Bytes = node->fs_St.st_size;
		if (node->fs_St.st_nlink > 1) {
		    node->fs_HNext = *phlinks;
		    *phlinks = node;
		}
	    }
	    break;
	case S_IFLNK:
	    if ((n = readlink(path, buf, sizeof(buf))) > 0) {
		if ((node->fs_Data = malloc(n + 1)) == NULL) {
		    fprintf(stderr, "Ran out of memory\n");
		    free(node);
		    node = NULL;
		} else {
		    node->fs_Bytes = n;
		    bcopy(buf, node->fs_Data, n);
		    node->fs_Data[n] = 0;
		}
	    } else if (n == 0) {
		node->fs_Data = NULL;
		node->fs_Bytes = 0;
	    } else {
		fprintf(stderr, "Unable to read link: %s\n", path);
		free(node);
		node = NULL;
	    }
	    break;
	case S_IFSOCK:
	    break;
	case S_IFWHT:
	    break;
	default:
	    break;
	}
    }
    return(node);
}

void
FSPaste(const char *path, fsnode_t node, fsnode_t hlinks)
{
    struct timeval times[2];
    fsnode_t scan;
    int fd;
    int ok = 0;

    switch(node->fs_St.st_mode & S_IFMT) {
    case S_IFIFO:
	break;
    case S_IFCHR:
    case S_IFBLK:
	if (mknod(path, node->fs_St.st_mode, node->fs_St.st_rdev) < 0) {
	    fprintf(stderr, "Paste: mknod failed on %s\n", path);
	    break;
	}
	ok = 1;
	break;
    case S_IFDIR:
	fd = open(".", O_RDONLY);
	if (fd < 0) {
	    fprintf(stderr, "Paste: cannot open current directory\n");
	    exit(1);
	}
	if (mkdir(path, 0700) < 0 && errno != EEXIST) {
	    printf("Paste: unable to create directory %s\n", path);
	    close(fd);
	    break;
	}
	if (chdir(path) < 0) {
	    printf("Paste: unable to chdir into %s\n", path);
	    exit(1);
	}
	for (scan = node->fs_Base; scan; scan = scan->fs_Next) {
	    FSPaste(scan->fs_Name, scan, hlinks);
	}
	if (fchdir(fd) < 0) {
	    fprintf(stderr, "Paste: cannot fchdir current dir\n");
	    close(fd);
	    exit(1);
	}
	close(fd);
	ok = 1;
	break;
    case S_IFREG:
	if (node->fs_St.st_nlink > 1 && node->fs_Bytes < 0) {
	    if ((scan = fsgethlink(hlinks, node)) == NULL) {
		fprintf(stderr, "Cannot find hardlink for %s\n", path);
	    } else {
		char *hpath = fshardpath(scan, node);
		if (hpath == NULL || link(hpath, path) < 0) {
		    fprintf(stderr, "Cannot create hardlink: %s->%s\n", path, hpath ? hpath : "?");
		    if (hpath)
			free(hpath);
		    break;
		}
		ok = 1;
		free(hpath);
	    }
	    break;
	}
	if ((fd = open(path, O_RDWR|O_CREAT|O_TRUNC, 0600)) < 0) {
	    fprintf(stderr, "Cannot create file: %s\n", path);
	    break;
	}
	if (node->fs_Bytes > 0) {
	    if (write(fd, node->fs_Data, node->fs_Bytes) != node->fs_Bytes) {
		fprintf(stderr, "Cannot write file: %s\n", path);
		remove(path);
		close(fd);
		break;
	    }
	}
	close(fd);
	ok = 1;
	break;
    case S_IFLNK:
	if (symlink(node->fs_Bytes > 0 ? node->fs_Data : "", path) < 0) {
	    fprintf(stderr, "Unable to create symbolic link: %s\n", path);
	    break;
	}
	ok = 1;
	break;
    case S_IFSOCK:
	break;
    case S_IFWHT:
	break;
    default:
	break;
    }

    /* 
     * Set perms
     */
    if (ok) {
	struct stat *st = &node->fs_St;

	times[0].tv_sec = st->st_atime;
	times[0].tv_usec = 0;
	times[1].tv_sec = st->st_mtime;
	times[1].tv_usec = 0;

	if (lchown(path, st->st_uid, st->st_gid) < 0)
	    fprintf(stderr, "lchown failed on %s\n", path);
	if (lutimes(path, times) < 0)
	    fprintf(stderr, "lutimes failed on %s\n", path);
	if (lchmod(path, st->st_mode & ALLPERMS) < 0)
	    fprintf(stderr, "lchmod failed on %s\n", path);
	if (!S_ISLNK(st->st_mode)) {
	    if (chflags(path, st->st_flags) < 0)
		fprintf(stderr, "chflags failed on %s\n", path);
	}
    }
}