Makefile: adjust CFLAGS to support extern inline.
inputdev.h: copied from hurd/console-client/mach-inputdev.h.
version.h: copied from configured directory.
---
Makefile | 8 +-
input.h | 3 +
inputdev.h | 6 +-
trans.c | 892 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
trans.h | 17 +-
version.h | 29 ++
6 files changed, 946 insertions(+), 9 deletions(-)
create mode 100644 trans.c
create mode 100644 version.h
diff --git a/Makefile b/Makefile
index b940c4f..40f5b07 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
-CC = gcc
-CFLAGS = -O -g -Wall -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64
+CFLAGS = -O -g -Wall -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -I. \
+ -std=gnu99 -fgnu89-inline
OBJS = kstoucs.o symname.o compose.o xkb.o parser.tab.o lex.o \
xkbdata.o xkbdefaults.o xkbtimer.o timer.o kbd-repeat.o \
kdioctlServer.o
@@ -35,8 +35,8 @@ lex.c: lex.l parser.tab.h
parser.tab.c parser.tab.h: parser.y
$(YACC) -v -d $<
-input_driver_test: input_driver_test.c
- $(CC) -rdynamic $(CFLAGS) $(LIBS) -ldl input_driver_test.c -o
input_driver_test
+input_driver_test: input_driver_test.c trans.o
+ $(CC) -rdynamic $(CFLAGS) $(LIBS) -ldl input_driver_test.c trans.o -o
input_driver_test
kbd-repeat.o: kdioctl_S.h
diff --git a/input.h b/input.h
index e5683a8..351fa34 100644
--- a/input.h
+++ b/input.h
@@ -55,6 +55,9 @@ error_t console_input (char *buf, size_t size);
cons_vcons_scrollback. */
int console_scrollback (cons_scroll_t type, float value);
+/* Returns current console ID. */
+error_t console_current_id (int *cur);
+
/* Switch the active console to console ID or DELTA (relative to the
active console). */
error_t console_switch (int id, int delta);
diff --git a/inputdev.h b/inputdev.h
index 9a4ee42..985e1e1 100644
--- a/inputdev.h
+++ b/inputdev.h
@@ -1,5 +1,5 @@
-/* inputdev.h - Interfaces for the PC pc-kbd and mouse input drivers.
- Copyright (C) 2002, 2004 Free Software Foundation, Inc.
+/* mach-inputdev.h - Interfaces for the PC pc-kbd and mouse input drivers.
+ Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc.
Written by Marco Gerards.
This file is part of the GNU Hurd.
@@ -50,7 +50,7 @@
#ifndef _INPUTDEV_H_
#define _INPUTDEV_H_ 1
-#include "trans.h"
+#include <trans.h>
typedef u_short kev_type; /* kd event type */
diff --git a/trans.c b/trans.c
new file mode 100644
index 0000000..a90b5c5
--- /dev/null
+++ b/trans.c
@@ -0,0 +1,892 @@
+/* trans.c -- Control a translator node for the repeaters.
+
+ Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
+
+ Written by Marco Gerards.
+
+ 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, 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 */
+
+#include <fcntl.h>
+#include <maptime.h>
+#include <stddef.h>
+#include <dirent.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <hurd/hurd_types.h>
+#include <error.h>
+#include <version.h>
+
+#include "trans.h"
+
+
+char *netfs_server_name = "console";
+char *netfs_server_version = HURD_VERSION;
+int netfs_maxsymlinks = 0;
+
+/* Handy source of time. */
+static volatile struct mapped_time_value *console_maptime;
+
+static consnode_t node_list = 0;
+
+struct netnode
+{
+ consnode_t node;
+ char *symlink_path;
+};
+
+typedef mach_msg_header_t request_t;
+
+
+int
+console_demuxer (mach_msg_header_t *inp,
+ mach_msg_header_t *outp)
+{
+ int ret;
+ struct protid *user = (struct protid *) inp;
+ request_t *inop = (request_t *) inp;
+
+ ret = netfs_demuxer (inp, outp);
+ if (ret)
+ return ret;
+
+ user = ports_lookup_port (netfs_port_bucket, inop->msgh_local_port,
netfs_protid_class);
+ if (!user)
+ return ret;
+
+ /* Don't do anything for the root node. */
+ if (user->po->np == netfs_root_node)
+ {
+ ports_port_deref (user);
+ return 0;
+ }
+
+ if (!ret && user->po->np->nn->node && user->po->np->nn->node->demuxer)
+ ret = user->po->np->nn->node->demuxer (inp, outp);
+
+ ports_port_deref (user);
+ return ret;
+}
+
+
+
+/* Make sure that NP->nn_stat is filled with current information. CRED
+ identifies the user responsible for the operation. */
+error_t
+netfs_validate_stat (struct node *np, struct iouser *cred)
+{
+ return 0;
+}
+
+
+/* This should attempt a chmod call for the user specified by CRED on node
+ NODE, to change the owner to UID and the group to GID. */
+error_t
+netfs_attempt_chown (struct iouser *cred, struct node *np,
+ uid_t uid, uid_t gid)
+{
+ return EOPNOTSUPP;
+}
+
+
+/* This should attempt a chauthor call for the user specified by CRED on node
+ NODE, to change the author to AUTHOR. */
+error_t
+netfs_attempt_chauthor (struct iouser *cred, struct node *np,
+ uid_t author)
+{
+ return EOPNOTSUPP;
+}
+
+
+/* This should attempt a chmod call for the user specified by CRED on node
+ NODE, to change the mode to MODE. Unlike the normal Unix and Hurd meaning
+ of chmod, this function is also used to attempt to change files into other
+ types. If such a transition is attempted which is impossible, then return
+ EOPNOTSUPP. */
+error_t
+netfs_attempt_chmod (struct iouser *cred, struct node *np,
+ mode_t mode)
+{
+ return EOPNOTSUPP;
+}
+
+
+/* Attempt to turn NODE (user CRED) into a symlink with target NAME. */
+error_t
+netfs_attempt_mksymlink (struct iouser *cred, struct node *np,
+ char *name)
+{
+ if (!np->nn->node)
+ {
+ if (np->nn->symlink_path)
+ free (np->nn->symlink_path);
+ np->nn->symlink_path = strdup (name);
+ return 0;
+ }
+ else if (np->nn->node->mksymlink)
+ return np->nn->node->mksymlink (cred, np, name);
+ return EOPNOTSUPP;
+}
+
+
+/* Attempt to turn NODE (user CRED) into a device. TYPE is either S_IFBLK or
+ S_IFCHR. */
+error_t
+netfs_attempt_mkdev (struct iouser *cred, struct node *np,
+ mode_t type, dev_t indexes)
+{
+ return EOPNOTSUPP;
+}
+
+
+/* This should attempt a chflags call for the user specified by CRED on node
+ NODE, to change the flags to FLAGS. */
+error_t
+netfs_attempt_chflags (struct iouser *cred, struct node *np,
+ int flags)
+{
+ return EOPNOTSUPP;
+}
+
+
+/* This should attempt a utimes call for the user specified by CRED on
+ locked node NP, to change the atime to ATIME and the mtime to
+ MTIME. If ATIME or MTIME is null, then set to the current
+ time. */
+error_t
+netfs_attempt_utimes (struct iouser *cred, struct node *np,
+ struct timespec *atime, struct timespec *mtime)
+{
+ error_t err = fshelp_isowner (&np->nn_stat, cred);
+ int flags = TOUCH_CTIME;
+
+ if (! err)
+ {
+ if (mtime)
+ np->nn_stat.st_mtim = *mtime;
+ else
+ flags |= TOUCH_MTIME;
+
+ if (atime)
+ np->nn_stat.st_atim = *atime;
+ else
+ flags |= TOUCH_ATIME;
+
+ fshelp_touch (&np->nn_stat, flags, console_maptime);
+ }
+ return err;
+
+}
+
+
+/* This should attempt to set the size of the locked file NP (for user
+ CRED) to SIZE bytes long. */
+error_t
+netfs_attempt_set_size (struct iouser *cred, struct node *np,
+ loff_t size)
+{
+ return EOPNOTSUPP;
+}
+
+/* This should attempt to fetch filesystem status information for the
+ remote filesystem, for the user CRED. NP is locked. */
+error_t
+netfs_attempt_statfs (struct iouser *cred, struct node *np,
+ fsys_statfsbuf_t *st)
+{
+ return EOPNOTSUPP;
+}
+
+
+/* This should sync the locked file NP completely to disk, for the
+ user CRED. If WAIT is set, return only after the sync is
+ completely finished. */
+error_t
+netfs_attempt_sync (struct iouser *cred, struct node *np,
+ int wait)
+{
+ return 0;
+}
+
+
+/* This should sync the entire remote filesystem. If WAIT is set,
+ return only after the sync is completely finished. */
+error_t
+netfs_attempt_syncfs (struct iouser *cred, int wait)
+{
+ return 0;
+}
+
+
+/* Lookup NAME in DIR (which is locked) for USER; set *NP to the found
+ name upon return. If the name was not found, then return ENOENT.
+ On any error, clear *NP. (*NP, if found, should be locked and a
+ reference to it generated. This call should unlock DIR no matter
+ what.) */
+error_t
+netfs_attempt_lookup (struct iouser *user, struct node *dir,
+ char *name, struct node **node)
+{
+ error_t err;
+ consnode_t cn;
+
+ *node = 0;
+ err = fshelp_access (&dir->nn_stat, S_IEXEC, user);
+ if (err)
+ goto out;
+
+ if (strcmp (name, ".") == 0)
+ {
+ /* Current directory -- just add an additional reference to DIR
+ and return it. */
+ netfs_nref (dir);
+ *node = dir;
+ goto out;
+ }
+
+ if (strcmp (name, "..") == 0)
+ {
+ err = EAGAIN;
+ goto out;
+ }
+
+ for (cn = node_list; cn; cn = cn->next)
+ if (!strcmp (name, cn->name))
+ {
+ if (cn->node == NULL)
+ {
+ struct netnode *nn = calloc (1, sizeof *nn);
+ if (nn == NULL)
+ {
+ err = ENOMEM;
+ goto out;
+ }
+
+ *node = netfs_make_node (nn);
+
+ nn->node = cn;
+ (*node)->nn_stat = netfs_root_node->nn_stat;
+ (*node)->nn_stat.st_mode = (netfs_root_node->nn_stat.st_mode &
~S_IFMT & ~S_ITRANS);
+ (*node)->nn_stat.st_ino = 5;
+ if (cn->readlink)
+ {
+ (*node)->nn_stat.st_mode |= S_IFLNK;
+ (*node)->nn_stat.st_size = cn->readlink (user, NULL, NULL);
+ }
+ else
+ {
+ (*node)->nn_stat.st_mode |= S_IFCHR;
+ (*node)->nn_stat.st_size = 0;
+ }
+ cn->node = *node;
+ goto out;
+ }
+ else
+ {
+ *node = cn->node;
+
+ netfs_nref (*node);
+ goto out;
+ }
+ }
+
+ err = ENOENT;
+
+ out:
+ mutex_unlock (&dir->lock);
+ if (err)
+ *node = 0;
+ else
+ mutex_lock (&(*node)->lock);
+
+ if (!err && *node != dir && (*node)->nn->node->open)
+ (*node)->nn->node->open ();
+
+ return err;
+}
+
+
+error_t
+netfs_S_io_seek (struct protid *user, off_t offset,
+ int whence, off_t *newoffset)
+{
+ /* XXX: Will all nodes be device nodes? */
+ if (!user)
+ return EOPNOTSUPP;
+ else
+ return ESPIPE;
+}
+
+
+error_t
+netfs_S_io_select (struct protid *user, mach_port_t reply,
+ mach_msg_type_name_t replytype, int *type)
+{
+ struct node *np;
+
+ if (!user)
+ return EOPNOTSUPP;
+
+ np = user->po->np;
+
+ if (np->nn->node && np->nn->node->select)
+ return np->nn->node->select (user, reply, replytype, type);
+ return EOPNOTSUPP;
+}
+
+
+/* Delete NAME in DIR (which is locked) for USER. */
+error_t
+netfs_attempt_unlink (struct iouser *user, struct node *dir,
+ char *name)
+{
+ error_t err;
+ consnode_t cn;
+
+ err = fshelp_access (&dir->nn_stat, S_IWRITE, user);
+ if (err)
+ return err;
+
+ for (cn = node_list; cn; cn = cn->next)
+ if (!strcmp (name, cn->name))
+ {
+ if (cn->mksymlink)
+ return 0;
+ else
+ break;
+ }
+ return EOPNOTSUPP;
+}
+
+
+/* Attempt to rename the directory FROMDIR to TODIR. Note that neither
+ of the specific nodes are locked. */
+error_t
+netfs_attempt_rename (struct iouser *user, struct node *fromdir,
+ char *fromname, struct node *todir,
+ char *toname, int excl)
+{
+ return EOPNOTSUPP;
+}
+
+
+/* Attempt to create a new directory named NAME in DIR (which is
+ locked) for USER with mode MODE. */
+error_t
+netfs_attempt_mkdir (struct iouser *user, struct node *dir,
+ char *name, mode_t mode)
+{
+ return EOPNOTSUPP;
+}
+
+
+/* Attempt to remove directory named NAME in DIR (which is locked) for
+ USER. */
+error_t
+netfs_attempt_rmdir (struct iouser *user,
+ struct node *dir, char *name)
+{
+ return EOPNOTSUPP;
+}
+
+
+/* Create a link in DIR with name NAME to FILE for USER. Note that
+ neither DIR nor FILE are locked. If EXCL is set, do not delete the
+ target. Return EEXIST if NAME is already found in DIR. */
+error_t
+netfs_attempt_link (struct iouser *user, struct node *dir,
+ struct node *file, char *name, int excl)
+{
+ error_t err;
+ consnode_t cn;
+
+ err = fshelp_access (&dir->nn_stat, S_IWRITE, user);
+ if (err)
+ return err;
+
+ if (!file->nn->node && file->nn->symlink_path)
+ {
+ for (cn = node_list; cn; cn = cn->next)
+ if (!strcmp (name, cn->name))
+ {
+ if (cn->mksymlink)
+ {
+ file->nn->node = cn;
+ cn->mksymlink (user, file, file->nn->symlink_path);
+ free (file->nn->symlink_path);
+ file->nn->symlink_path = NULL;
+ return 0;
+ }
+ else
+ break;
+ }
+ }
+ return EOPNOTSUPP;
+}
+
+
+/* Attempt to create an anonymous file related to DIR (which is
+ locked) for USER with MODE. Set *NP to the returned file upon
+ success. No matter what, unlock DIR. */
+error_t
+netfs_attempt_mkfile (struct iouser *user, struct node *dir,
+ mode_t mode, struct node **np)
+{
+ error_t err;
+ struct netnode *nn;
+
+ err = fshelp_access (&dir->nn_stat, S_IWRITE, user);
+ if (err)
+ {
+ *np = 0;
+ return err;
+ }
+
+ mutex_unlock (&dir->lock);
+
+ nn = calloc (1, sizeof (*nn));
+ if (!nn)
+ return ENOMEM;
+
+ *np = netfs_make_node (nn);
+ mutex_lock (&(*np)->lock);
+ spin_unlock (&netfs_node_refcnt_lock);
+
+ return 0;
+}
+
+
+/* Attempt to create a file named NAME in DIR (which is locked) for
+ USER with MODE. Set *NP to the new node upon return. On any
+ error, clear *NP. *NP should be locked on success; no matter what,
+ unlock DIR before returning. */
+error_t
+netfs_attempt_create_file (struct iouser *user, struct node *dir,
+ char *name, mode_t mode, struct node **np)
+{
+ *np = 0;
+ mutex_unlock (&dir->lock);
+ return EOPNOTSUPP;
+}
+
+
+/* Read the contents of locked node NP (a symlink), for USER, into
+ BUF. */
+error_t
+netfs_attempt_readlink (struct iouser *user, struct node *np,
+ char *buf)
+{
+ if (np->nn->node && np->nn->node->readlink)
+ return np->nn->node->readlink (user, np, buf);
+ return EOPNOTSUPP;
+}
+
+
+/* Locked node NP is being opened by USER, with FLAGS. NEWNODE is
+ nonzero if we just created this node. Return an error if we should
+ not permit the open to complete because of a permission
+ restriction. */
+error_t
+netfs_check_open_permissions (struct iouser *user, struct node *np,
+ int flags, int newnode)
+{
+ error_t err = 0;
+
+ 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 err;
+
+}
+
+
+/* This function will never be called. It is only used when a node is
+ a symlink or by io_read, which is overridden. */
+error_t
+netfs_attempt_read (struct iouser *cred, struct node *np,
+ loff_t offset, size_t *len, void *data)
+{
+ return EOPNOTSUPP;
+}
+
+
+/* This function will never be called. It is only called from
+ io_write, which is overridden. */
+error_t
+netfs_attempt_write (struct iouser *cred, struct node *np,
+ loff_t offset, size_t *len, void *data)
+{
+ return EOPNOTSUPP;
+}
+
+
+error_t
+netfs_S_io_read (struct protid *user,
+ char **data,
+ mach_msg_type_number_t *datalen,
+ off_t offset,
+ mach_msg_type_number_t amount)
+{
+ struct node *np;
+
+ if (!user)
+ return EOPNOTSUPP;
+ np = user->po->np;
+
+ if (np->nn->node && np->nn->node->read)
+ return np->nn->node->read (user, data, datalen, offset, amount);
+ return EOPNOTSUPP;
+}
+
+
+error_t
+netfs_S_io_write (struct protid *user,
+ char *data,
+ mach_msg_type_number_t datalen,
+ off_t offset,
+ mach_msg_type_number_t *amount)
+{
+ struct node *np;
+
+ if (!user)
+ return EOPNOTSUPP;
+
+ np = user->po->np;
+ if (np->nn->node && np->nn->node->write)
+ return np->nn->node->write (user, data, datalen, offset, amount);
+ return EOPNOTSUPP;
+}
+
+
+/* Return the valid access types (bitwise OR of O_READ, O_WRITE, and
+ O_EXEC) in *TYPES for locked file NP and user CRED. */
+error_t
+netfs_report_access (struct iouser *cred, struct node *np,
+ int *types)
+{
+ *types = 0;
+ 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;
+ return 0;
+
+}
+
+/* Node NP has no more references; free all its associated storage. */
+void netfs_node_norefs (struct node *np)
+
+{
+ if (np->nn->node)
+ {
+ if (np->nn->node->close)
+ np->nn->node->close ();
+ np->nn->node->node = 0;
+ }
+
+ if (np->nn->symlink_path)
+ free (np->nn->symlink_path);
+
+ spin_unlock (&netfs_node_refcnt_lock);
+ free (np->nn);
+ free (np);
+}
+
+
+/* Returned directory entries are aligned to blocks this many bytes long.
+ Must be a power of two. */
+#define DIRENT_ALIGN 4
+#define DIRENT_NAME_OFFS offsetof (struct dirent, d_name)
+/* Length is structure before the name + the name + '\0', all
+ padded to a four-byte alignment. */
+#define DIRENT_LEN(name_len) \
+ ((DIRENT_NAME_OFFS + (name_len) + 1 + (DIRENT_ALIGN - 1)) \
+ & ~(DIRENT_ALIGN - 1))
+
+/* Fill the array *DATA of size BUFSIZE with up to NENTRIES dirents
+ from DIR (which is locked) starting with entry ENTRY for user CRED.
+ The number of entries in the array is stored in *AMT and the number
+ of bytes in *DATACNT. If the supplied buffer is not large enough
+ to hold the data, it should be grown. */
+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)
+{
+ error_t err;
+ int count = 0;
+ size_t size = 0; /* Total size of our return block. */
+ consnode_t cn = node_list;
+ consnode_t first_node;
+
+
+ /* Add the length of a directory entry for NAME to SIZE and return true,
+ unless it would overflow MAX_DATA_LEN or NUM_ENTRIES, in which case
+ return false. */
+ int bump_size (const char *name)
+ {
+ if (num_entries == -1 || count < num_entries)
+ {
+ size_t new_size = size + DIRENT_LEN (strlen (name));
+ if (max_data_len > 0 && new_size > max_data_len)
+ return 0;
+ size = new_size;
+ count++;
+ return 1;
+ }
+ else
+ return 0;
+ }
+
+ if (dir != netfs_root_node)
+ return ENOTDIR;
+
+ for (first_node = node_list, count = 2;
+ first_node && first_entry > count;
+ first_node = first_node->next);
+ count++;
+
+ count = 0;
+
+ /* Make space for the `.' and `..' entries. */
+ if (first_entry == 0)
+ bump_size (".");
+ if (first_entry <= 1)
+ bump_size ("..");
+
+ for (cn = first_node; cn; cn = cn->next)
+ bump_size (cn->name);
+
+
+ /* Allocate it. */
+ *data = mmap (0, size, PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
+ err = ((void *) *data == (void *) -1) ? errno : 0;
+
+ if (! err)
+ /* Copy out the result. */
+ {
+ char *p = *data;
+
+ int add_dir_entry (const char *name, ino_t fileno, int type)
+ {
+ if (num_entries == -1 || count < num_entries)
+ {
+ struct dirent hdr;
+ size_t name_len = strlen (name);
+ size_t sz = DIRENT_LEN (name_len);
+
+ if (sz > size)
+ return 0;
+ else
+ size -= sz;
+
+ hdr.d_fileno = fileno;
+ hdr.d_reclen = sz;
+ hdr.d_type = type;
+ hdr.d_namlen = name_len;
+
+ memcpy (p, &hdr, DIRENT_NAME_OFFS);
+ strcpy (p + DIRENT_NAME_OFFS, name);
+ p += sz;
+
+ count++;
+
+ return 1;
+ }
+ else
+ return 0;
+ }
+
+ *data_len = size;
+ *data_entries = count;
+
+ count = 0;
+
+ /* Add `.' and `..' entries. */
+ if (first_entry == 0)
+ add_dir_entry (".", 2, DT_DIR);
+ if (first_entry <= 1)
+ add_dir_entry ("..", 2, DT_DIR);
+
+ /* Fill in the real directory entries. */
+ for (cn = first_node; cn; cn = cn->next)
+ if (!add_dir_entry (cn->name, cn->id, cn->readlink ? DT_LNK : DT_CHR))
+ break;
+ }
+
+ fshelp_touch (&dir->nn_stat, TOUCH_ATIME, console_maptime);
+ return err;
+}
+
+
+
+static any_t
+console_client_translator (any_t unused)
+{
+ error_t err;
+
+ do
+ {
+ ports_manage_port_operations_multithread (netfs_port_bucket,
+ console_demuxer,
+ 1000 * 60 * 2,
+ 1000 * 60 * 10,
+ 0);
+ err = netfs_shutdown (0);
+ }
+ while (err);
+ return 0;
+}
+
+
+/* Create a node with the name NAME and return it in *CN. */
+error_t
+console_create_consnode (const char *name, consnode_t *cn)
+{
+ *cn = malloc (sizeof (struct consnode));
+ if (!*cn)
+ return ENOMEM;
+
+ (*cn)->name = strdup (name);
+ if (!(*cn)->name)
+ {
+ free (cn);
+ return ENOMEM;
+ }
+
+ (*cn)->readlink = NULL;
+ (*cn)->mksymlink = NULL;
+
+ return 0;
+}
+
+
+/* Destroy the node CN. */
+void
+console_destroy_consnode (consnode_t cn)
+{
+ if (!cn)
+ return;
+ free (cn->name);
+ free (cn);
+}
+
+
+/* Register the node CN with the translator. */
+void
+console_register_consnode (consnode_t cn)
+{
+ cn->node = 0;
+ cn->next = node_list;
+ node_list = cn;
+}
+
+
+/* Unregister the node CN from the translator. */
+void
+console_unregister_consnode (consnode_t cn)
+{
+ if (!cn)
+ return;
+
+ if (node_list == cn)
+ node_list = cn->next;
+ else
+ {
+ consnode_t prev = node_list;
+
+ for (prev = node_list; prev->next != cn; prev = prev->next)
+ ;
+
+ prev->next = cn->next;
+ }
+}
+
+
+error_t
+console_setup_node (char *path)
+{
+ mach_port_t underlying;
+ mach_port_t bootstrap;
+ error_t err;
+ struct stat ul_stat;
+ file_t node;
+ struct port_info *newpi;
+ mach_port_t right;
+
+ node = file_name_lookup (path, O_CREAT|O_NOTRANS, 0664);
+ if (node == MACH_PORT_NULL)
+ return errno;
+
+ task_get_bootstrap_port (mach_task_self (), &bootstrap);
+ netfs_init ();
+
+ /* Create the root node (some attributes initialized below). */
+ netfs_root_node = netfs_make_node (0);
+ if (! netfs_root_node)
+ error (1, ENOMEM, "Cannot create root node");
+
+ err = maptime_map (0, 0, &console_maptime);
+ if (err)
+ error (1, err, "Cannot map time");
+
+ err = ports_create_port (netfs_control_class, netfs_port_bucket, sizeof
(struct port_info), &newpi);
+ right = ports_get_send_right (newpi);
+ err = file_set_translator (node, 0, FS_TRANS_EXCL | FS_TRANS_SET, 0, 0, 0,
+ right, MACH_MSG_TYPE_COPY_SEND);
+ mach_port_deallocate (mach_task_self (), right);
+ underlying = node;
+
+ err = io_stat (node, &ul_stat);
+ if (err)
+ error (1, err, "Cannot stat underlying node");
+
+ netfs_root_node->nn_stat.st_ino = 2;
+ netfs_root_node->nn_stat.st_uid = ul_stat.st_uid;
+ netfs_root_node->nn_stat.st_gid = ul_stat.st_gid;
+ netfs_root_node->nn_stat.st_author = ul_stat.st_author;
+ netfs_root_node->nn_stat.st_mode = S_IFDIR | (ul_stat.st_mode & ~S_IFMT &
~S_ITRANS);
+ netfs_root_node->nn_stat.st_fsid = getpid ();
+ netfs_root_node->nn_stat.st_nlink = 1;
+ netfs_root_node->nn_stat.st_size = 0;
+ netfs_root_node->nn_stat.st_blocks = 0;
+ netfs_root_node->nn_stat.st_fstype = FSTYPE_MISC;
+ netfs_root_node->nn_translated = 0;
+
+ /* If the underlying node isn't a directory, propagate read permission to
+ execute permission since we need that for lookups. */
+ if (! S_ISDIR (ul_stat.st_mode))
+ {
+ if (ul_stat.st_mode & S_IRUSR)
+ netfs_root_node->nn_stat.st_mode |= S_IXUSR;
+ if (ul_stat.st_mode & S_IRGRP)
+ netfs_root_node->nn_stat.st_mode |= S_IXGRP;
+ if (ul_stat.st_mode & S_IROTH)
+ netfs_root_node->nn_stat.st_mode |= S_IXOTH;
+ }
+
+ fshelp_touch (&netfs_root_node->nn_stat, TOUCH_ATIME|TOUCH_MTIME|TOUCH_CTIME,
+ console_maptime);
+
+ cthread_detach (cthread_fork (console_client_translator, NULL));
+
+ return 0;
+}
diff --git a/trans.h b/trans.h
index d8e7a2c..f781e31 100644
--- a/trans.h
+++ b/trans.h
@@ -1,5 +1,5 @@
/* trans.h -- Control a translator node for the repeaters.
- Copyright (C) 2004 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005 Free Software Foundation, Inc.
Written by Marco Gerards.
This program is free software; you can redistribute it and/or
@@ -54,15 +54,28 @@ struct consnode
/* The demuxer used for this node. */
int (*demuxer) (mach_msg_header_t *inp, mach_msg_header_t *outp);
+ /* Called when the symlink is read */
+ error_t (*readlink) (struct iouser *user, struct node *np, char *buf);
+
+ /* Called when the symlink is written */
+ error_t (*mksymlink) (struct iouser *cred, struct node *np, char *name);
+
struct consnode *next;
};
typedef struct consnode *consnode_t;
+/* Register the node CN with the translator. */
void console_register_consnode (consnode_t cn);
-void console_unregister_consnode (consnode_t node);
+/* Unregister the node CN from the translator. */
+void console_unregister_consnode (consnode_t cn);
+/* Create a node with the name NAME and return it in *CN. */
error_t console_create_consnode (const char *name, consnode_t *cn);
+/* Destroy the node CN. */
void console_destroy_consnode (consnode_t cn);
+
+/* Setup the translator for console client nodes on PATH. */
+error_t console_setup_node (char *path);
diff --git a/version.h b/version.h
new file mode 100644
index 0000000..8969db3
--- /dev/null
+++ b/version.h
@@ -0,0 +1,29 @@
+/* Hurd version
+ Copyright (C) 1996, 1997, 1999 Free Software Foundation, Inc.
+ Written by Thomas Bushnell, n/BSG.
+
+ This file is part of the GNU Hurd.
+
+ The GNU Hurd 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, or (at
+ your option) any later version.
+
+ The GNU Hurd 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, USA. */
+
+#ifndef HURD_VERSION
+#define HURD_VERSION "0.3"
+#endif
+
+/* The standard way to print versions for --version. */
+#define STANDARD_HURD_VERSION(s) \
+ #s " (GNU Hurd) " HURD_VERSION
+#define STANDARD_HURD_VERSION_EXTRA(s, extra) \
+ #s " (GNU Hurd; " extra ") " HURD_VERSION
--
1.7.2
