/*---------------------------------------------------------------------------*/
/*node.c*/
/*---------------------------------------------------------------------------*/
/*Implementation of node management strategies*/
/*---------------------------------------------------------------------------*/
/*Based on the code of unionfs translator.*/
/*---------------------------------------------------------------------------*/
/*Copyright (C) 2001, 2002, 2005, 2008, 2009 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 <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <stdio.h>
#include <argz.h>
#include <hurd/fsys.h>
/*---------------------------------------------------------------------------*/
#include "debug.h"
#include "node.h"
#include "options.h"
#include "lib.h"
#include "nsmux.h"
#include "ncache.h"
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*--------Global Variables---------------------------------------------------*/
/*The lock protecting the underlying filesystem*/
struct mutex ulfs_lock = MUTEX_INITIALIZER;
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*--------Functions----------------------------------------------------------*/
/*Derives a new node from `lnode` and adds a reference to `lnode`*/
error_t node_create (lnode_t * lnode, node_t ** node)
{
error_t err = 0;
/*Create a new netnode */
netnode_t *netnode_new = malloc (sizeof (netnode_t));
/*Reset the memory allocated for the new netnode (just in case :-) ) */
memset (netnode_new, 0, sizeof (netnode_t));
/*If the memory could not be allocated */
if (netnode_new == NULL)
err = ENOMEM;
else
{
/*create a new node from the netnode */
node_t *node_new = netfs_make_node (netnode_new);
/*If the creation failed */
if (node_new == NULL)
{
/*set the error code */
err = ENOMEM;
/*destroy the netnode created above */
free (netnode_new);
/*stop */
return err;
}
node_new->nn->type = NODE_TYPE_NORMAL;
/*link the lnode to the new node */
lnode->node = node_new;
/*setup the references in the newly created node */
node_new->nn->lnode = lnode;
lnode_ref_add (lnode);
/*setup the information in the netnode */
node_new->nn->flags = 0;
node_new->nn->ncache_next = node_new->nn->ncache_prev = NULL;
/*initialize the data fields dealing with positioning this node
in the dynamic translator stack */
node_new->nn->dyntrans = NULL;
node_new->nn->below = NULL;
/*store the result of creation in the second parameter */
*node = node_new;
}
/*Return the result of operations */
return err;
} /*node_create */
/*---------------------------------------------------------------------------*/
/*Derives a new proxy from `lnode`*/
error_t node_create_proxy (lnode_t * lnode, node_t ** node)
{
error_t err = 0;
/*Create a new netnode */
netnode_t *netnode_new = malloc (sizeof (netnode_t));
/*Reset the memory allocated for the new netnode. We do this here
since lnode_add_proxy will try to reference the `lnode` in this
netnode and will do bad writes to memory. */
memset (netnode_new, 0, sizeof (netnode_t));
/*If the memory could not be allocated */
if (netnode_new == NULL)
err = ENOMEM;
else
{
/*create a new node from the netnode */
node_t *node_new = netfs_make_node (netnode_new);
/*If the creation failed */
if (node_new == NULL)
{
/*set the error code */
err = ENOMEM;
/*destroy the netnode created above */
free (netnode_new);
/*stop */
return err;
}
node_new->nn->type = NODE_TYPE_PROXY;
/*add this new node to the list of proxies of `lnode` */
lnode_add_proxy (lnode, node_new);
/*setup the information in the netnode */
node_new->nn->flags = 0;
node_new->nn->ncache_next = node_new->nn->ncache_prev = NULL;
/*initialize the data fields dealing with positioning this node
in the dynamic translator stack */
node_new->nn->dyntrans = NULL;
node_new->nn->below = NULL;
/*store the result of creation in the second parameter */
*node = node_new;
}
/*Return the result of operations */
return err;
} /*node_create_proxy */
/*---------------------------------------------------------------------------*/
/*Creates a proxy (or a shadow) node for the supplied port*/
error_t node_create_from_port (mach_port_t port, node_t ** node)
{
error_t err = 0;
/*Create a new netnode */
netnode_t * netnode_new = malloc (sizeof (netnode_t));
/*Reset the memory allocated for the new netnode (just in case :-) ) */
memset (netnode_new, 0, sizeof (netnode_t));
/*If the memory could not be allocated */
if (netnode_new == NULL)
err = ENOMEM;
else
{
/*create a new node from the netnode */
node_t * node_new = netfs_make_node (netnode_new);
/*If the creation failed */
if (node_new == NULL)
{
/*set the error code */
err = ENOMEM;
/*destroy the netnode created above */
free (netnode_new);
/*stop */
return err;
}
/*The caller may want to change this to NODE_TYPE_SHADOW if it's
the case. */
node_new->nn->type = NODE_TYPE_PROXY;
/*this node is ``orphan'' -- it is not associated to any lnode
and has some service functions only */
node_new->nn->lnode = NULL;
/*setup the information in the netnode */
node_new->nn->flags = 0;
node_new->nn->ncache_next = node_new->nn->ncache_prev = NULL;
node_new->nn->port = port;
/*initialize the data fields dealing with positioning this node
in the dynamic translator stack */
node_new->nn->dyntrans = NULL;
node_new->nn->below = NULL;
/*store the result of creation in the second parameter */
*node = node_new;
}
/*Return the result of operations */
return err;
} /*node_create_from_port */
/*---------------------------------------------------------------------------*/
/*Destroys the specified node and removes a light reference from the
associated light node*/
void node_destroy (node_t * np)
{
/*Die if the node does not belong to node cache */
assert (!np->nn->ncache_next || !np->nn->ncache_prev);
/*Destroy the port to the underlying filesystem allocated to the node */
if (np->nn->port != MACH_PORT_NULL)
PORT_DEALLOC (np->nn->port);
/*TODO: If this node is a shadow node, kill the translator sitting
on this node. */
/*If there is an lnode associated with the current node, detach
it */
if (np->nn->lnode)
{
if (np->nn->lnode->node == np)
{
mutex_lock (&np->nn->lnode->lock);
/*orphan the light node */
np->nn->lnode->node = NULL;
lnode_ref_remove (np->nn->lnode);
}
else
/*remove a reference to this node from the list of proxies */
lnode_remove_proxy (np->nn->lnode, np);
}
/*Free the netnode and the node itself */
free (np->nn);
free (np);
} /*node_destroy */
/*---------------------------------------------------------------------------*/
/*Creates the root node and the corresponding lnode*/
error_t node_create_root (node_t ** root_node)
{
/*Try to create a new lnode */
lnode_t *lnode;
error_t err = lnode_create (NULL, &lnode);
/*Stop, if the creation failed */
if (err)
return err;
/*Try to derive the node corresponding to `lnode` */
node_t *node;
err = node_create (lnode, &node);
/*If the operation failed */
if (err)
{
/*destroy the created lnode */
lnode_destroy (lnode);
/*stop */
return err;
}
/*Release the lock on the lnode */
mutex_unlock (&lnode->lock);
/*Store the result in the parameter */
*root_node = node;
/*Return the result */
return err;
} /*node_create_root */
/*---------------------------------------------------------------------------*/
/*Initializes the port to the underlying filesystem for the root node*/
error_t node_init_root (node_t * node /*the root node */
)
{
error_t err = 0;
/*Acquire a lock for operations on the underlying filesystem */
mutex_lock (&ulfs_lock);
/*Open the port to the directory specified in `dir` */
node->nn->port = file_name_lookup (dir, O_READ | O_DIRECTORY, 0);
/*If the directory could not be opened */
if (node->nn->port == MACH_PORT_NULL)
{
/*set the error code accordingly */
err = errno;
LOG_MSG ("node_init_root: Could not open the port for %s.", dir);
/*release the lock and stop */
mutex_unlock (&ulfs_lock);
return err;
}
LOG_MSG ("node_init_root: Port for %s opened successfully.", dir);
LOG_MSG ("\tPort: 0x%lX", (unsigned long) node->nn->port);
/*Stat the root node */
err = io_stat (node->nn->port, &node->nn_stat);
if (err)
{
/*deallocate the port */
PORT_DEALLOC (node->nn->port);
LOG_MSG ("node_init_root: Could not stat the root node.");
/*unlock the mutex and exit */
mutex_unlock (&ulfs_lock);
return err;
}
/*Set the path to the corresponding lnode to `dir` */
node->nn->lnode->path = strdup (dir);
if (!node->nn->lnode->path)
{
/*deallocate the port */
PORT_DEALLOC (node->nn->port);
/*unlock the mutex */
mutex_unlock (&ulfs_lock);
LOG_MSG ("node_init_root: Could not strdup the directory.");
return ENOMEM;
}
/*The current position in dir */
char *p = dir + strlen (dir);
/*Go through the path from end to beginning */
for (; p >= dir; --p)
{
/*If the current character is a '/' */
if (*p == '/')
{
/*If p is not the first character */
if (p > dir)
{
/*if this slash is escaped, skip it */
if (*(p - 1) == '\\')
continue;
}
/*advance the pointer to the first character after the slash */
++p;
/*stop */
break;
}
}
LOG_MSG ("node_init_root: The name of root node is %s.", p);
/*Set the name of the lnode to the last element in the path to dir */
node->nn->lnode->name = strdup (p);
/*If the name of the node could not be duplicated */
if (!node->nn->lnode->name)
{
/*free the name of the path to the node and deallocate teh port */
free (node->nn->lnode->path);
PORT_DEALLOC (node->nn->port);
/*unlock the mutex */
mutex_unlock (&ulfs_lock);
LOG_MSG ("node_init_root: Could not strdup the name of the root node.");
return ENOMEM;
}
/*Compute the length of the name of the root node */
node->nn->lnode->name_len = strlen (p);
/*Release the lock for operations on the undelying filesystem */
mutex_unlock (&ulfs_lock);
/*Return the result of operations */
return err;
} /*node_init_root */
/*---------------------------------------------------------------------------*/
/*Frees a list of dirents*/
void node_entries_free (node_dirent_t * dirents)
{
/*The current and the next elements */
node_dirent_t *dirent, *dirent_next;
/*Go through all elements of the list */
for (dirent = dirents; dirent; dirent = dirent_next)
{
/*store the next element */
dirent_next = dirent->next;
/*free the dirent stored in the current element of the list */
free (dirent->dirent);
/*free the current element */
free (dirent);
}
} /*node_entries_free */
/*---------------------------------------------------------------------------*/
/*Reads the directory entries from `node`, which must be locked*/
error_t node_entries_get (node_t * node, node_dirent_t ** dirents)
{
error_t err = 0;
/*The list of dirents */
struct dirent **dirent_list, **dirent;
/*The head of the list of dirents */
node_dirent_t *node_dirent_list = NULL;
/*The size of the array of pointers to dirent */
size_t dirent_data_size;
/*The array of dirents */
char *dirent_data;
/*Obtain the directory entries for the given node */
err = dir_entries_get
(node->nn->port, &dirent_data, &dirent_data_size, &dirent_list);
if (err)
{
return err;
}
/*The new entry in the list */
node_dirent_t *node_dirent_new;
/*The new dirent */
struct dirent *dirent_new;
/*LOG_MSG("node_entries_get: Getting entries for %p", node); */
/*The name of the current dirent */
char *name;
/*The length of the current name */
size_t name_len;
/*The size of the current dirent */
size_t size;
/*Go through all elements of the list of pointers to dirent */
for (dirent = dirent_list; *dirent; ++dirent)
{
/*obtain the name of the current dirent */
name = &((*dirent)->d_name[0]);
/*If the current dirent is either '.' or '..', skip it */
if ((strcmp (name, ".") == 0) || (strcmp (name, "..") == 0))
continue;
/*obtain the length of the current name */
name_len = strlen (name);
/*obtain the length of the current dirent */
size = DIRENT_LEN (name_len);
/*create a new list element */
node_dirent_new = malloc (sizeof (node_dirent_t));
if (!node_dirent_new)
{
err = ENOMEM;
break;
}
/*create a new dirent */
dirent_new = malloc (size);
if (!dirent_new)
{
free (node_dirent_new);
err = ENOMEM;
break;
}
/*fill the dirent with information */
dirent_new->d_ino = (*dirent)->d_ino;
dirent_new->d_type = (*dirent)->d_type;
dirent_new->d_reclen = size;
strcpy ((char *) dirent_new + DIRENT_NAME_OFFS, name);
/*add the dirent to the list */
node_dirent_new->dirent = dirent_new;
node_dirent_new->next = node_dirent_list;
node_dirent_list = node_dirent_new;
}
/*If something went wrong in the loop */
if (err)
/*free the list of dirents */
node_entries_free (node_dirent_list);
else
/*store the list of dirents in the second parameter */
*dirents = node_dirent_list;
/*Free the list of pointers to dirent */
free (dirent_list);
/*Free the results of listing the dirents */
munmap (dirent_data, dirent_data_size);
/*Return the result of operations */
return err;
} /*node_entries_get */
/*---------------------------------------------------------------------------*/
/*Makes sure that all ports to the underlying filesystem of `node` are
up to date*/
error_t node_update (node_t * node)
{
error_t err = 0;
/*The full path to this node */
char *path;
/*Stat information for `node` */
io_statbuf_t stat;
/*The port to the file corresponding to `node` */
file_t port;
/*If the specified node is the root node or if it must not be updated */
if (NODE_IS_ROOT (node) || (node->nn->flags & FLAG_NODE_ULFS_FIXED))
/*do nothing */
return err; /*return 0; actually */
/*Gain exclusive access to the root node of the filesystem */
mutex_lock (&netfs_root_node->lock);
/*Construct the full path to `node` */
err = lnode_path_construct (node->nn->lnode, &path);
if (err)
{
mutex_unlock (&netfs_root_node->lock);
return err;
}
/*Deallocate `node`'s port to the underlying filesystem */
if (node->nn->port)
PORT_DEALLOC (node->nn->port);
/*Try to lookup the file for `node` in its untranslated version */
err = file_lookup
(netfs_root_node->nn->port, path, O_READ | O_NOTRANS, O_NOTRANS,
0, &port, &stat);
if (err)
{
node->nn->port = MACH_PORT_NULL;
err = 0; /*failure (?) */
return err;
}
/*If the node looked up is actually the root node of the proxy filesystem */
if ((stat.st_ino == underlying_node_stat.st_ino)
&& (stat.st_fsid == underlying_node_stat.st_fsid))
/*set `err` accordingly */
err = ELOOP;
else
{
/*deallocate the obtained port */
PORT_DEALLOC (port);
/*obtain the translated version of the required node */
err = file_lookup
(netfs_root_node->nn->port, path, O_READ, 0, 0, &port, &stat);
}
/*If there have been errors */
if (err)
/*reset the port */
port = MACH_PORT_NULL;
/*Store the port in the node */
node->nn->port = port;
/*Remove the flag about the invalidity of the current node and set the
flag that the node is up-to-date */
node->nn->flags &= ~FLAG_NODE_INVALIDATE;
node->nn->flags |= FLAG_NODE_ULFS_UPTODATE;
/*Release the lock on the root node of proxy filesystem */
mutex_unlock (&netfs_root_node->lock);
/*Return the result of operations */
return err;
} /*node_update */
/*---------------------------------------------------------------------------*/
/*Computes the size of the given directory*/
error_t node_get_size (node_t * dir, OFFSET_T * off)
{
error_t err = 0;
/*The final size */
size_t size = 0;
/*The number of directory entries */
/*int count = 0; */
/*The the node in the directory entries list from which we start counting */
/*node_dirent_t * dirent_start = NULL; */
/*The currently analyzed dirent */
node_dirent_t *dirent_current = NULL;
/*The pointer to the beginning of the list of dirents */
node_dirent_t *dirent_list = NULL;
/*The first entry we have to analyze */
/*int first_entry = 2; */
/*Takes into consideration the name of the current dirent */
void bump_size (const char *name)
{
/*Increment the current size by the size of the current dirent */
size += DIRENT_LEN (strlen (name));
/*Count the current dirent */
/*++count; */
} /*bump_size */
/*Obtain the list of entries in the current directory */
err = node_entries_get (dir, &dirent_list);
if (err)
return err;
/*Obtain the pointer to the dirent which has the number first_entry */
/*Actually, the first element of the list */
/*This code is included in unionfs, but it's completely useless here */
/*for
(
dirent_start = dirent_list, count = 2;
dirent_start && count < first_entry;
dirent_start = dirent_start->next, ++count
); */
/*Reset the count */
/*count = 0; */
/*Make space for '.' and '..' entries */
/*This code is included in unionfs, but it's completely useless here */
/*if(first_entry == 0)
bump_size(".");
if(first_entry <= 1)
bump_size(".."); */
/*See how much space is required for the node */
for (dirent_current = dirent_list /*dirent_start */ ; dirent_current;
dirent_current = dirent_current->next)
bump_size (dirent_current->dirent->d_name);
/*Free the list of dirents */
node_entries_free (dirent_list);
/*Return the size */
*off = size;
return 0;
} /*node_get_size */
/*---------------------------------------------------------------------------*/
/*Remove the file called `name` under `dir`*/
error_t node_unlink_file (node_t * dir, char *name)
{
error_t err = 0;
/*The port to the file which will be unlinked */
mach_port_t p;
/*Stat information about the file which will be unlinked */
io_statbuf_t stat;
/*If port corresponding to `dir` is invalid */
if (dir->nn->port == MACH_PORT_NULL)
/*stop with an error */
return ENOENT; /*FIXME: Is the return value indeed meaningful here? */
/*Attempt to lookup the specified file */
err = file_lookup (dir->nn->port, name, O_NOTRANS, O_NOTRANS, 0, &p, &stat);
if (err)
return err;
/*Deallocate the obtained port */
PORT_DEALLOC (p);
/*Unlink file `name` under `dir` */
err = dir_unlink (dir->nn->port, name);
if (err)
return err;
return err;
} /*node_unlink_file */
/*---------------------------------------------------------------------------*/
/*Starts translator `trans` on the (shadow) node `np`, which should
mirror the file `filename`, and returns the port `port` to the root
of the translator opened as `flags.`*/
error_t
node_set_translator
(struct protid * diruser, node_t * np, char * trans, int flags,
char * filename, mach_port_t * port)
{
error_t err;
mach_port_t p;
/*An unauthenticated port to the directory containing `np` */
mach_port_t unauth_dir;
/*A copy (possibly extended) of the name of the translator */
char * ext;
/*The holders of argz-transformed translator name and arguments */
char * argz = NULL;
size_t argz_len = 0;
/*The control port for the active translator */
mach_port_t active_control;
/*The PID of the started translator */
pid_t trans_pid;
/*A copy of the user information, supplied in `user` */
struct iouser * user;
/*A protid for the supplied node */
struct protid * newpi;
/*Identity information about the current process (for fsys_getroot) */
uid_t * uids;
size_t nuids;
gid_t * gids;
size_t ngids;
/*The retry information returned by fsys_getroot */
string_t retry_name;
mach_port_t retry_port;
/*Try to get the number of effective UIDs */
nuids = geteuids (0, 0);
if (nuids < 0)
return EPERM;
/*Allocate some memory for the UIDs on the stack */
uids = alloca (nuids * sizeof (uid_t));
/*Fetch the UIDs themselves */
nuids = geteuids (nuids, uids);
if (nuids < 0)
return EPERM;
/*Try to get the number of effective GIDs */
ngids = getgroups (0, 0);
if (ngids < 0)
return EPERM;
/*Allocate some memory for the GIDs on the stack */
gids = alloca (ngids * sizeof (gid_t));
/*Fetch the GIDs themselves */
ngids = getgroups (ngids, gids);
if (ngids < 0)
return EPERM;
/*Opens the port on which to set the new translator */
error_t
open_port
(int flags, mach_port_t * underlying,
mach_msg_type_name_t * underlying_type, task_t task, void *cookie)
{
err = 0;
/*Check, whether the user has the permissions to open this node */
err = check_open_permissions (diruser->user, &np->nn_stat, flags);
if (err)
return err;
if (!np->nn->port)
{
/*We have to do the lookup only in case the supplied node does
not already have a port. */
np->nn->port = file_name_lookup_under
(diruser->po->np->nn->port, filename, flags, 0);
if (!np->nn->port)
return ENOENT;
}
/*Duplicate the supplied user */
err = iohelp_dup_iouser (&user, diruser->user);
if (err)
return err;
/*Create a protid for this node */
newpi = netfs_make_protid
(netfs_make_peropen (np, flags, diruser->po), user);
if (!newpi)
{
iohelp_free_iouser (user);
return errno;
}
LOG_MSG ("node_set_translators.open_port: PASSED");
/*Obtain the resulting port right and set its type appropriately */
*underlying = p = ports_get_send_right (newpi);
*underlying_type = MACH_MSG_TYPE_COPY_SEND;
/**underlying_type = MACH_MSG_TYPE_COPY_SEND;*/
/**underlying_type = MACH_MSG_TYPE_MOVE_SEND;*/
LOG_MSG ("node_set_translators.open_port: %ld", (long) *underlying);
/*Drop our reference to the port */
ports_port_deref (newpi);
/*Store the task ID of the new translator */
trans_pid = task2pid(task);
/*
char buf[256];
char *_buf = buf;
size_t len = 256;
io_read (p, &_buf, &len, 0, len);
LOG_MSG ("node_set_translator: Read from np: '%s'", buf);
*/
/*Return the result of operations (everything should be okay here) */
return err;
} /*open_port */
/*Adds a "/hurd/" at the beginning of the translator name, if required */
char * put_in_hurd (const char *name)
{
/*If the path to the translator is absolute, return a copy of the name */
/*TODO: A better decision technique on whether we have to add the prefix */
if (name[0] == '/')
return strdup (name);
/*Compute the length of the name */
size_t len = strlen (name);
/*Try to allocate new memory */
char * full = malloc (6 /*strlen("/hurd/") */ + len + 1);
if (!full)
return NULL;
/*Construct the name */
strcpy (full, "/hurd/");
/*LOG_MSG("node_set_translator: %s", full); */
strcpy (full + 6, name);
/*LOG_MSG("node_set_translator: %s", full); */
full[6 + len] = 0;
/*LOG_MSG("node_set_translator: %s", full); */
/*Return the full path */
return full;
} /*put_in_hurd */
/*Obtain the unauthenticated port to the directory */
err = io_restrict_auth (diruser->po->np->nn->port, &unauth_dir, 0, 0, 0, 0);
if (err)
return err;
/*Obtain a copy (possibly extended) of the name */
ext = put_in_hurd (trans);
if (!ext)
return ENOMEM;
/*TODO: Better argument-parsing? */
/*Obtain the argz version of the translator name */
err = argz_create_sep (ext, ' ', &argz, &argz_len);
if (err)
return err;
/*Start the translator */
/*The value 60000 for the timeout is the one found in settrans */
err = fshelp_start_translator
(open_port, NULL, argz, argz, argz_len, 60000, &active_control);
if (err)
return err;
/*Attempt to set a translator on the port opened by the previous call */
err = file_set_translator
(p, 0, FS_TRANS_SET, 0, argz, argz_len,
active_control, MACH_MSG_TYPE_COPY_SEND);
PORT_DEALLOC (p);
if (err)
return err;
/*Register the new translator*/
err = trans_register (active_control, trans_pid, &np->nn->dyntrans);
LOG_MSG ("node_set_translator: Translator PID: %d", (int)trans_pid);
if (err)
return err;
/*Obtain the port to the top of the newly-set translator */
err = fsys_getroot
(active_control, unauth_dir, MACH_MSG_TYPE_COPY_SEND,
uids, nuids, gids, ngids, flags, &retry_port, retry_name, &p);
if (err)
return err;
/*Return the port */
*port = p;
/*Everything is OK here */
return 0;
} /*node_set_translator */
/*---------------------------------------------------------------------------*/
/*Gets the port to the supplied node. */
error_t
node_get_port
(struct protid * diruser, node_t * np, int flags, mach_port_t * port)
{
error_t error = 0;
/*The new user for the port */
struct iouser * user;
/*The protid for the port */
struct protid * newpi;
/*Create a port to the supplied node without checking anything. */
flags &= ~OPENONLY_STATE_MODES;
error = iohelp_dup_iouser (&user, diruser->user);
if (error)
return error;
newpi = netfs_make_protid
(netfs_make_peropen (np, flags, diruser->po), user);
if (!newpi)
{
iohelp_free_iouser (user);
error = errno;
return error;
}
*port = ports_get_right (newpi);
ports_port_deref (newpi);
return error;
} /*node_get_port */
/*---------------------------------------------------------------------------*/
/*Gets the send port right to the supplied node. */
error_t
node_get_send_port
(struct protid * diruser, node_t * np, int flags, mach_port_t * port)
{
error_t error = 0;
/*The new user for the port */
struct iouser * user;
/*The protid for the port */
struct protid * newpi;
/*Create a port to the supplied node without checking anything. */
flags &= ~OPENONLY_STATE_MODES;
error = iohelp_dup_iouser (&user, diruser->user);
if (error)
return error;
newpi = netfs_make_protid
(netfs_make_peropen (np, flags, diruser->po), user);
if (!newpi)
{
iohelp_free_iouser (user);
error = errno;
return error;
}
*port = ports_get_send_right (newpi);
ports_port_deref (newpi);
return error;
} /*node_get_send_port */
/*---------------------------------------------------------------------------*/
