/*----------------------------------------------------------------------------*/
/*filter.c*/
/*----------------------------------------------------------------------------*/
/*The filtering translator*/
/*----------------------------------------------------------------------------*/
/*Based on the code of unionfs translator.*/
/*----------------------------------------------------------------------------*/
/*Copyright (C) 2001, 2002, 2005, 2008 Free Software Foundation, Inc.
  Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of the
  License, or * (at your option) any later version.

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  USA.*/
/*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/
#define _GNU_SOURCE 1
/*----------------------------------------------------------------------------*/
#include "filter.h"
/*----------------------------------------------------------------------------*/
#include <error.h>
#include <argp.h>
#include <argz.h>
#include <hurd/netfs.h>
#include <fcntl.h>
/*----------------------------------------------------------------------------*/
#include "debug.h"
#include "options.h"
#include "trace.h"
/*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/
/*--------Global Variables----------------------------------------------------*/
/*The name of the server*/
char * netfs_server_name = "filter";
/*----------------------------------------------------------------------------*/
/*The version of the server*/
char * netfs_server_version = "0.0";
/*----------------------------------------------------------------------------*/
/*The maximal length of a chain of symbolic links*/
int netfs_maxsymlinks = 12;
/*----------------------------------------------------------------------------*/
/*A port to the underlying node*/
mach_port_t underlying_node;
/*----------------------------------------------------------------------------*/
/*Status information for the underlying node*/
io_statbuf_t underlying_node_stat;
/*----------------------------------------------------------------------------*/
/*Mapped time used for updating node information*/
volatile struct mapped_time_value * maptime;
/*----------------------------------------------------------------------------*/
/*The filesystem ID*/
pid_t fsid;
/*----------------------------------------------------------------------------*/
/*The port from which we will read (TODO: and write) the data*/
mach_port_t target;
/*----------------------------------------------------------------------------*/
/*The file to print debug messages to*/
FILE * filter_dbg;
/*----------------------------------------------------------------------------*/
/*The name of the translator to filter out*/
char * target_name = NULL;
/*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/
/*--------Functions-----------------------------------------------------------*/
/*Attempts to create a file named `name` in `dir` for `user` with mode `mode`*/
error_t
netfs_attempt_create_file
	(
	struct iouser * user,
	struct node * dir,
	char * name,
	mode_t mode,
	struct node ** node
	)
	{
	LOG_MSG("netfs_attempt_create_file");

	/*Unlock `dir` and say that we can do nothing else here*/
	mutex_unlock(&dir->lock);
	return EOPNOTSUPP;
	}/*netfs_attempt_create_file*/
/*----------------------------------------------------------------------------*/
/*Return an error if the process of opening a file should not be allowed
	to complete because of insufficient permissions*/
error_t
netfs_check_open_permissions
	(
	struct iouser * user,
	struct node * np,
	int flags,
	int newnode
	)
	{
	LOG_MSG("netfs_check_open_permissions");

	error_t err = 0;
	
	/*Cheks user's permissions*/
	if(flags & O_READ)
		err = fshelp_access(&np->nn_stat, S_IREAD, user);
	if(!err && (flags & O_WRITE))
		err = fshelp_access(&np->nn_stat, S_IWRITE, user);
	if(!err && (flags & O_EXEC))
		err = fshelp_access(&np->nn_stat, S_IEXEC, user);
		
	/*Return the result of the check*/
	return err;
	}/*netfs_check_open_permissions*/
/*----------------------------------------------------------------------------*/
/*Attempts an utimes call for the user `cred` on node `node`*/
error_t
netfs_attempt_utimes
	(
	struct iouser * cred,
	struct node * node,
	struct timespec * atime,
	struct timespec * mtime
	)
	{
	LOG_MSG("netfs_attempt_utimes");

	error_t err = 0;
	
	/*See what information is to be updated*/
	int flags = TOUCH_CTIME;
	
	/*Check if the user is indeed the owner of the node*/
	err = fshelp_isowner(&node->nn_stat, cred);
	
	/*If the user is allowed to do utimes*/
	if(!err)
		{
		/*If atime is to be updated*/
		if(atime)
			/*update the atime*/
			node->nn_stat.st_atim = *atime;
		else
			/*the current time will be set as the atime*/
			flags |= TOUCH_ATIME;
		
		/*If mtime is to be updated*/
		if(mtime)
			/*update the mtime*/
			node->nn_stat.st_mtim = *mtime;
		else
			/*the current time will be set as mtime*/
			flags |= TOUCH_MTIME;
		
		/*touch the file*/
		fshelp_touch(&node->nn_stat, flags, maptime);
		}
	
	/*Return the result of operations*/
	return err;
	}/*netfs_attempt_utimes*/
/*----------------------------------------------------------------------------*/
/*Returns the valid access types for file `node` and user `cred`*/
error_t
netfs_report_access
	(
	struct iouser * cred,
	struct node * np,
	int * types
	)
	{
	LOG_MSG("netfs_report_access");

	/*No access at first*/
	*types = 0;
	
	/*Check the access and set the required bits*/
	if(fshelp_access(&np->nn_stat, S_IREAD,  cred) == 0)
		*types |= O_READ;
	if(fshelp_access(&np->nn_stat, S_IWRITE, cred) == 0)
		*types |= O_WRITE;
	if(fshelp_access(&np->nn_stat, S_IEXEC,  cred) == 0)
		*types |= O_EXEC;

	/*Everything OK*/
	return 0;
	}/*netfs_report_access*/
/*----------------------------------------------------------------------------*/
/*Validates the stat data for the node*/
error_t
netfs_validate_stat
	(
	struct node * np,
	struct iouser * cred
	)
	{
	LOG_MSG("netfs_validate_stat");

	error_t err = 0;
	
	/*Validate the stat information about the node*/
	err = io_stat(np->nn->port, &np->nn_stat);

	/*Return the result of operations*/
	return err;
	}/*netfs_validate_stat*/
/*----------------------------------------------------------------------------*/
/*Syncs `node` completely to disk*/
error_t
netfs_attempt_sync
	(
	struct iouser * cred,
	struct node * node,
	int wait
	)
	{
	LOG_MSG("netfs_attempt_sync");

	/*Operation is not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_sync*/
/*----------------------------------------------------------------------------*/
/*Fetches a directory*/
error_t
netfs_get_dirents
	(
	struct iouser * cred,
	struct node * dir,
	int first_entry,
	int num_entries,
	char ** data,
	mach_msg_type_number_t * data_len,
	vm_size_t max_data_len,
	int * data_entries
	)
	{
	LOG_MSG("netfs_get_dirents");
	
	/*This node is not a directory*/
	return ENOTDIR;
	}/*netfs_get_dirents*/
/*----------------------------------------------------------------------------*/
/*Looks up `name` under `dir` for `user`*/
error_t
netfs_attempt_lookup
	(
	struct iouser * user,
	struct node * dir,
	char * name,
	struct node ** node
	)
	{
	LOG_MSG("netfs_attempt_lookup: '%s'", name);
		
	/*Unlock the mutexes in `dir`*/
	mutex_unlock(&dir->lock);
	return EOPNOTSUPP;
	}/*netfs_attempt_lookup*/
/*----------------------------------------------------------------------------*/
/*Deletes `name` in `dir` for `user`*/
error_t
netfs_attempt_unlink
	(
	struct iouser * user,
	struct node * dir,
	char * name
	)
	{
	LOG_MSG("netfs_attempt_unlink");

	return 0;
	}/*netfs_attempt_unlink*/
/*----------------------------------------------------------------------------*/
/*Attempts to rename `fromdir`/`fromname` to `todir`/`toname`*/
error_t
netfs_attempt_rename
	(
	struct iouser * user,
	struct node * fromdir,
	char * fromname,
	struct node * todir,
	char * toname,
	int excl
	)
	{
	LOG_MSG("netfs_attempt_rename");

	/*Operation not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_rename*/
/*----------------------------------------------------------------------------*/
/*Attempts to create a new directory*/
error_t
netfs_attempt_mkdir
	(
	struct iouser * user,
	struct node * dir,
	char * name,
	mode_t mode
	)
	{
	LOG_MSG("netfs_attempt_mkdir");

	return 0;
	}/*netfs_attempt_mkdir*/
/*----------------------------------------------------------------------------*/
/*Attempts to remove directory `name` in `dir` for `user`*/
error_t
netfs_attempt_rmdir
	(
	struct iouser * user,
	struct node * dir,
	char * name
	)
	{
	LOG_MSG("netfs_attempt_rmdir");

	return 0;
	}/*netfs_attempt_rmdir*/
/*----------------------------------------------------------------------------*/
/*Attempts to change the mode of `node` for user `cred` to `uid`:`gid`*/
error_t
netfs_attempt_chown
	(
	struct iouser * cred,
	struct node * node,
	uid_t uid,
	uid_t gid
	)
	{
	LOG_MSG("netfs_attempt_chown");

	/*Operation is not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_chown*/
/*----------------------------------------------------------------------------*/
/*Attempts to change the author of `node` to `author`*/
error_t
netfs_attempt_chauthor
	(
	struct iouser * cred,
	struct node * node,
	uid_t author
	)
	{
	LOG_MSG("netfs_attempt_chauthor");

	/*Operation is not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_chauthor*/
/*----------------------------------------------------------------------------*/
/*Attempts to change the mode of `node` to `mode` for `cred`*/
error_t
netfs_attempt_chmod
	(
	struct iouser * user,
	struct node * node,
	mode_t mode
	)
	{
	LOG_MSG("netfs_attempt_chmod");

	/*Operation is not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_chmod*/
/*----------------------------------------------------------------------------*/
/*Attempts to turn `node` into a symlink targetting `name`*/
error_t
netfs_attempt_mksymlink
	(
	struct iouser * cred,
	struct node * node,
	char * name
	)
	{
	LOG_MSG("netfs_attempt_mksymlink");

	/*Operation is not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_mksymlink*/
/*----------------------------------------------------------------------------*/
/*Attempts to turn `node` into a device; type can be either S_IFBLK or S_IFCHR*/
error_t
netfs_attempt_mkdev
	(
	struct iouser * cred,
	struct node * node,
	mode_t type,
	dev_t indexes
	)
	{
	LOG_MSG("netfs_attempt_mkdev");

	/*Operation is not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_mkdev*/
/*----------------------------------------------------------------------------*/
/*Attempts to set the passive translator record for `file` passing `argz`*/
error_t
netfs_set_translator
	(
	struct iouser * cred,
	struct node * node,
	char * argz,
	size_t arglen
	)
	{
	LOG_MSG("netfs_set_translator");

	/*Operation is not supported*/
	return EOPNOTSUPP;
	}/*netfs_set_translator	*/
/*----------------------------------------------------------------------------*/
/*Attempts to call chflags for `node`*/
error_t
netfs_attempt_chflags
	(
	struct iouser * cred,
	struct node * node,
	int flags
	)
	{
	LOG_MSG("netfs_attempt_chflags");

	/*Operation is not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_chflags*/
/*----------------------------------------------------------------------------*/
/*Attempts to set the size of file `node`*/
error_t
netfs_attempt_set_size
	(
	struct iouser * cred,
	struct node * node,
	loff_t size
	)
	{
	LOG_MSG("netfs_attempt_set_size");

	/*Operation is not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_set_size*/
/*----------------------------------------------------------------------------*/
/*Fetches the filesystem status information*/
error_t
netfs_attempt_statfs
	(
	struct iouser * cred,
	struct node * node,
	fsys_statfsbuf_t * st
	)
	{
	LOG_MSG("netfs_attempt_statfs");

	/*Operation is not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_statfs*/
/*----------------------------------------------------------------------------*/
/*Syncs the filesystem*/
error_t
netfs_attempt_syncfs
	(
	struct iouser * cred,
	int wait
	)
	{
	LOG_MSG("netfs_attempt_syncfs");

	/*Everythin OK*/
	return 0;
	}/*netfs_attempt_syncfs*/
/*----------------------------------------------------------------------------*/
/*Creates a link in `dir` with `name` to `file`*/
error_t
netfs_attempt_link
	(
	struct iouser * user,
	struct node * dir,
	struct node * file,
	char * name,
	int excl
	)
	{
	LOG_MSG("netfs_attempt_link");

	/*Operation not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_link*/
/*----------------------------------------------------------------------------*/
/*Attempts to create an anonymous file related to `dir` with `mode`*/
error_t
netfs_attempt_mkfile
	(
	struct iouser * user,
	struct node * dir,
	mode_t mode,
	struct node ** node
	)
	{
	LOG_MSG("netfs_attempt_mkfile");

	/*Unlock the directory*/
	mutex_unlock(&dir->lock);

	/*Operation not supported*/
	return EOPNOTSUPP;
	}/*netfs_attempt_mkfile*/
/*----------------------------------------------------------------------------*/
/*Reads the contents of symlink `node` into `buf`*/
error_t
netfs_attempt_readlink
	(
	struct iouser * user,
	struct node * node,
	char * buf
	)
	{
	LOG_MSG("netfs_attempt_readlink");

	/*Operation not supported (why?..)*/
	return EOPNOTSUPP;
	}/*netfs_attempt_readlink*/
/*----------------------------------------------------------------------------*/
/*Reads from file `node` up to `len` bytes from `offset` into `data`*/
error_t
netfs_attempt_read
	(
	struct iouser * cred,
	struct node * np,
	loff_t offset,
	size_t * len,
	void * data
	)
	{
	LOG_MSG("netfs_attempt_read");

	error_t err = 0;

	/*Obtain a pointer to the first byte of the supplied buffer*/
	char * buf = data;
	
	/*Try to read the requested information from the file*/
	err = io_read(np->nn->port, &buf, len, offset, *len);
	
	/*If some data has been read successfully*/
	if(!err && (buf != data))
		{
		/*copy the data from the buffer into which it has just been read into
			the supplied receiver*/
		memcpy(data, buf, *len);
		
		/*unmap the new buffer*/
		munmap(buf, *len);
		}

	/*Return the result of reading*/
	return err;
	}/*netfs_attempt_read*/
/*----------------------------------------------------------------------------*/
/*Writes to file `node` up to `len` bytes from offset from `data`*/
error_t
netfs_attempt_write
	(
	struct iouser * cred,
	struct node * node,
	loff_t offset,
	size_t * len,
	void * data
	)
	{
	LOG_MSG("netfs_attempt_write");

	return 0;
	}/*netfs_attempt_write*/
/*----------------------------------------------------------------------------*/
/*Frees all storage associated with the node*/
void
netfs_node_norefs
	(
	struct node * np
	)
	{
	/*Destroy the node*/
	node_destroy(np);
	}/*netfs_node_norefs*/
/*----------------------------------------------------------------------------*/
/*Implements file_get_translator_cntl as described in <hurd/fs.defs>
	(according to diskfs_S_file_get_translator_cntl)*/
kern_return_t
netfs_S_file_get_translator_cntl
	(
	struct protid * user,
	mach_port_t * cntl,
	mach_msg_type_name_t * cntltype
	)
	{
	/*If the information about the user is missing*/
	if(!user)
		return EOPNOTSUPP;
		
	error_t err = 0;
	
	/*Obtain the node for which we are called*/
	node_t * np = user->po->np;
	
	/*Lock the node*/
	mutex_lock(&np->lock);
	
	/*Check if the user is the owner of this node*/
	err = fshelp_isowner(&np->nn_stat, user->user);
	
	/*If no errors have happened*/
	if(!err)
		/*try to fetch the control port*/
		err = fshelp_fetch_control(&np->transbox, cntl);
		
	/*If no errors have occurred, but no port has been returned*/
	if(!err && (cntl == MACH_PORT_NULL))
		/*set the error accordingly*/
		err = ENXIO;
		
	/*If no errors have occurred so far*/
	if(!err)
		/*set the control port type*/
		*cntltype = MACH_MSG_TYPE_MOVE_SEND;
		
	/*Unlock the node*/
	mutex_unlock(&np->lock);
	
	/*Return the result of operations*/
	return err;
	}/*netfs_S_file_get_translator_cntl*/
/*----------------------------------------------------------------------------*/
/*Entry point*/
int
main
	(
	int argc,
	char ** argv
	)
	{
	/*Start logging*/
	INIT_LOG();
	LOG_MSG(">> Starting initialization...");

	/*The port on which this translator will be set upon*/
	mach_port_t bootstrap_port;
	
	error_t err = 0;
	
	/*Parse the command line arguments*/
	argp_parse(&argp_startup, argc, argv, ARGP_IN_ORDER, 0, 0);
	if(target_name == NULL)
		{
		char * p = *argv + strlen(*argv);
		
		/*find where the name of this executable starts (it should match \-.*)*/
		for(; p >= *argv; --p)
			if(*p == '/')
				{
				if((p > *argv) && (p[-1] == '\\'))
					continue; /*this is an escaped '/'*/
				/*we've reached the beginning of the name*/
				break;
				}

		if(*p == '/')
			++p;
		
		if(*p == '-') /*actually, any filter translator must have a name starting
									with '-'*/
			++p;
			
		target_name = p;
		}
	LOG_MSG("Command line arguments parsed. Target name: '%s'.", target_name);
	
	/*Try to create the root node*/
	err = node_create_root(&netfs_root_node);
	if(err)
		error(EXIT_FAILURE, err, "Failed to create the root node");
	LOG_MSG("Root node created.");

	/*Obtain the bootstrap port*/
	task_get_bootstrap_port(mach_task_self(), &bootstrap_port);

	/*Initialize the translator*/
	netfs_init();

	/*Obtain a port to the underlying node opened as O_NOTRANS*/
	underlying_node = netfs_startup(bootstrap_port, O_READ | O_NOTRANS);
	LOG_MSG("netfs initialization complete.");

	/*Initialize the root node*/
	err = node_init_root(underlying_node, netfs_root_node);
	if(err)
		error(EXIT_FAILURE, err, "Failed to initialize the root node");
	LOG_MSG("Root node initialized.");
	LOG_MSG("\tRoot node address: 0x%lX", (unsigned long)netfs_root_node);
	
	/*Map the time for updating node information*/
	err = maptime_map(0, 0, &maptime);
	if(err)
		error(EXIT_FAILURE, err, "Failed to map the time");
	LOG_MSG("Time mapped.");
		
	/*Obtain stat information about the underlying node*/
	err = io_stat(underlying_node, &underlying_node_stat);
	if(err)
		error(EXIT_FAILURE, err,
			"Cannot obtain stat information about the underlying node");
	LOG_MSG("Stat information for undelying node obtained.");
	
	/*Obtain the ID of the current process*/
	fsid = getpid();
	
	/*Setup the stat information for the root node*/
	netfs_root_node->nn_stat = underlying_node_stat;

	netfs_root_node->nn_stat.st_ino 	= FILTER_ROOT_INODE;
	netfs_root_node->nn_stat.st_fsid	= fsid;
	netfs_root_node->nn_stat.st_mode = underlying_node_stat.st_mode;
		
	netfs_root_node->nn_translated = netfs_root_node->nn_stat.st_mode;
	
	/*Filter the translator stack under ourselves*/
	err = trace_find(underlying_node, "/hurd/m", O_READ, &target);
	if(err)
		error
			(
			EXIT_FAILURE, err,
			"Could not trace the translator stack on the underlying node"
			);
			
	netfs_root_node->nn->port = target;
	
	/*Update the timestamps of the root node*/
	fshelp_touch
		(&netfs_root_node->nn_stat, TOUCH_ATIME | TOUCH_MTIME | TOUCH_CTIME,
		maptime);

	LOG_MSG(">> Initialization complete. Entering netfs server loop...");
	
	/*Start serving clients*/
	for(;;)
		netfs_server_loop();
	}/*main*/
/*----------------------------------------------------------------------------*/