diff options
Diffstat (limited to 'term')
| -rw-r--r-- | term/Makefile | 45 | ||||
| -rw-r--r-- | term/devio.c | 554 | ||||
| -rw-r--r-- | term/main.c | 147 | ||||
| -rw-r--r-- | term/munge.c | 725 | ||||
| -rw-r--r-- | term/term.h | 264 | ||||
| -rw-r--r-- | term/users.c | 1659 |
6 files changed, 3394 insertions, 0 deletions
diff --git a/term/Makefile b/term/Makefile new file mode 100644 index 00000000..40c06ba4 --- /dev/null +++ b/term/Makefile @@ -0,0 +1,45 @@ +# +# Copyright (C) 1995 Free Software Foundation, Inc. +# Written by Michael I. Bushnell, p/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. + +dir := term +makemode := server + +target = term +SRCS = devio.c munge.c users.c main.c +LCLHDRS = term.h + +OBJS = $(subst .c,.o,$(SRCS)) termServer.o device_replyServer.o tioctlServer.o ourmsgUser.o ../libtrivfs/libtrivfs.a ../libports/libports.a ../libihash/libihash.a ../libthreads/libthreads.a + +include ../Makeconf + +# The reason for -Dout= is to prevent errors for get_init_port, +# get_init_ports, get_init_int, get_init_ints, get_dtable, and get_fd. +# We don't use those, so we're safe in breaking them. +ourmsg_U.h ourmsgUser.c: ourmsg.defs ../hurd/hurd_types.defs + $(CPP) $(CPPFLAGS) -Droutine=simpleroutine -Dout= $< \ + | $(MIGCOM) -prefix nowait_ -server /dev/null \ + -user ourmsgUser.c -header ourmsg_U.h + mv ourmsg_U.h tmp.h + sed -e 's/_msg_user_/_ourmsg_user/' < tmp.h > ourmsg_U.h + rm -f tmp.h + +ourmsg.defs: $(includedir)/hurd/msg.defs + rm -f $@ + ln -s $< $@ diff --git a/term/devio.c b/term/devio.c new file mode 100644 index 00000000..e24e34fb --- /dev/null +++ b/term/devio.c @@ -0,0 +1,554 @@ +/* + Copyright (C) 1995 Free Software Foundation, Inc. + Written by Michael I. Bushnell, p/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. */ + +#include "term.h" +#include <device/device.h> +#include <device/device_request.h> +#include <hurd/ports.h> +#include <string.h> +#include <sys/types.h> +#include <hurd.h> +#include <stdio.h> + +#undef B50 +#undef B75 +#undef B110 +#undef B134 +#undef B150 +#undef B200 +#undef B300 +#undef B600 +#undef B1200 +#undef B1800 +#undef B2400 +#undef B4800 +#undef B9600 +#undef EXTA +#undef EXTB +#include <device/tty_status.h> + +/* This flag is set if there is an outstanding device_write. */ +static int output_pending; + +/* This flag is set if there is an outstanding device_read. */ +static int input_pending; + +/* This flag is set if there is an outstanding device_open. */ +static int open_pending; + +static char pending_output[IO_INBAND_MAX]; +static int npending_output; + +static struct port_class *phys_reply_class; + +/* The Mach device_t representing the terminal. */ +static device_t phys_device = MACH_PORT_NULL; + +/* The ports we get replies on for device calls. */ +static mach_port_t phys_reply_writes = MACH_PORT_NULL; +static mach_port_t phys_reply = MACH_PORT_NULL; + +/* The port-info structs. */ +static struct port_info *phys_reply_writes_pi; +static struct port_info *phys_reply_pi; + +static device_t device_master; + +static void init_devio (void) __attribute__ ((constructor)); +static void +init_devio () +{ + mach_port_t host_priv; + errno = get_privileged_ports (&host_priv, &device_master); + if (errno) + { + perror ("Getting priviliged ports"); + exit (1); + } + mach_port_deallocate (mach_task_self (), host_priv); + phys_reply_class = ports_create_class (0, 0); +} + +/* XXX Convert a real speed to a bogus Mach speed. Return + -1 if the real speed was bogus, else 0. */ +static int +real_speed_to_bogus_speed (int rspeed, int *bspeed) +{ + switch (rspeed) + { + case 0: + *bspeed = B0; + break; + case 50: + *bspeed = B50; + break; + case 75: + *bspeed = B75; + break; + case 110: + *bspeed = B110; + break; + case 134: + *bspeed = B134; + break; + case 150: + *bspeed = B150; + break; + case 200: + *bspeed = B200; + break; + case 300: + *bspeed = B300; + break; + case 600: + *bspeed = B600; + break; + case 1200: + *bspeed = B1200; + break; + case 1800: + *bspeed = B1800; + break; + case 2400: + *bspeed = B2400; + break; + case 4800: + *bspeed = B4800; + break; + case 9600: + *bspeed = B9600; + break; + case 19200: + *bspeed = EXTA; + break; + case 28400: + *bspeed = EXTB; + break; + default: + return -1; + } + return 0; +} + +/* XXX Convert a bogus speed to a real speed. */ +static int +bogus_speed_to_real_speed (int bspeed) +{ + switch (bspeed) + { + case B0: + default: + return 0; + case B50: + return 50; + case B75: + return 75; + case B110: + return 110; + case B134: + return 134; + case B150: + return 150; + case B200: + return 200; + case B300: + return 300; + case B600: + return 600; + case B1200: + return 1200; + case B1800: + return 1800; + case B2400: + return 2400; + case B4800: + return 4800; + case B9600: + return 9600; + case EXTA: + return 19200; + case EXTB: + return 38400; + } +} + + +/* If there are characters on the output queue and no + pending output requests, then send them. */ +void +start_output () +{ + char *cp; + int size; + error_t err; + + size = qsize (outputq); + + if (!size || output_pending) + return; + + /* Copy characters onto PENDING_OUTPUT, not bothering + those already there. */ + + if (size + npending_output > IO_INBAND_MAX) + size = IO_INBAND_MAX - npending_output; + + cp = pending_output + npending_output; + npending_output += size; + + while (size--) + *cp++ = dequeue (outputq); + + /* Submit all the outstanding characters to the device. */ + /* The D_NOWAIT flag does not, in fact, prevent blocks. Instead, + it merely causes D_WOULD_BLOCK errors when carrier is down... + whee.... */ + err = device_write_request_inband (phys_device, phys_reply_writes, D_NOWAIT, + 0, pending_output, npending_output); + + if (err == MACH_SEND_INVALID_DEST) + desert_dtr (); + else if (!err) + output_pending = 1; +} + +error_t +device_write_reply_inband (mach_port_t replypt, + error_t return_code, + int amount) +{ + if (replypt != phys_reply_writes) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + output_pending = 0; + + if (return_code == 0) + { + if (amount >= npending_output) + { + npending_output = 0; + condition_broadcast (outputq->wait); + } + else + { + /* Copy the characters that didn't get output + to the front of the array. */ + npending_output -= amount; + memmove (pending_output, pending_output + amount, npending_output); + } + start_output (); + } + else if (return_code == D_WOULD_BLOCK) + /* Carrier has dropped. */ + desert_dtr (); + else + start_output (); + + mutex_unlock (&global_lock); + return 0; +} + +error_t +device_read_reply_inband (mach_port_t replypt, + error_t error_code, + char *data, + u_int datalen) +{ + int i, flush; + error_t err; + + if (replypt != phys_reply) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + input_pending = 0; + + if (!error_code && (termstate.c_cflag & CREAD)) + for (i = 0; i < datalen; i++) + { + flush = input_character (data[i]); + if (flush) + break; + } + else if (error_code == D_WOULD_BLOCK) + { + desert_dtr (); + mutex_unlock (&global_lock); + return 0; + } + + /* D_NOWAIT does not actually prevent blocks; it merely causes + D_WOULD_BLOCK errors when carrier drops. */ + err = device_read_request_inband (phys_device, phys_reply, D_NOWAIT, + 0, vm_page_size); + if (err) + desert_dtr (); + else + input_pending = 1; + + mutex_unlock (&global_lock); + return 0; +} + +void +set_break () +{ + device_set_status (phys_device, TTY_SET_BREAK, 0, 0); +} + +void +clear_break () +{ + device_set_status (phys_device, TTY_CLEAR_BREAK, 0, 0); +} + +void +abandon_physical_output () +{ + int val = D_WRITE; + + mach_port_deallocate (mach_task_self (), phys_reply_writes); + ports_reallocate_port (phys_reply_writes_pi); + phys_reply_writes = ports_get_right (phys_reply_writes_pi); + mach_port_insert_right (mach_task_self (), phys_reply_writes, + phys_reply_writes, MACH_MSG_TYPE_MAKE_SEND); + + device_set_status (phys_device, TTY_FLUSH, &val, TTY_FLUSH_COUNT); + npending_output = 0; + output_pending = 0; +} + +int +pending_output_size () +{ + /* Unfortunately, there's no way to get the amount back from Mach + that has actually been written from this... */ + return npending_output; +} + +void +desert_dtr () +{ + /* This will work, because we set the TF_HUPCLS bit earlier. */ + device_close (phys_device); + mach_port_deallocate (mach_task_self (), phys_device); + phys_device = MACH_PORT_NULL; + + mach_port_deallocate (mach_task_self (), phys_reply); + mach_port_deallocate (mach_task_self (), phys_reply_writes); + phys_reply = phys_reply_writes = MACH_PORT_NULL; + + ports_port_deref (phys_reply_pi); + ports_port_deref (phys_reply_writes_pi); + phys_reply_pi = phys_reply_writes_pi = 0; + + report_carrier_off (); +} + +error_t +assert_dtr () +{ + error_t err; + + if (open_pending || (phys_device != MACH_PORT_NULL)) + return 0; + + assert (phys_reply == MACH_PORT_NULL); + assert (phys_reply_pi == 0); + phys_reply_pi = ports_allocate_port (term_bucket, sizeof (struct port_info), + phys_reply_class); + phys_reply = ports_get_right (phys_reply_pi); + mach_port_insert_right (mach_task_self (), phys_reply, phys_reply, + MACH_MSG_TYPE_MAKE_SEND); + + err = device_open_request (device_master, phys_reply, + D_READ|D_WRITE, pterm_name); + if (err) + { + mach_port_deallocate (mach_task_self (), phys_reply); + phys_reply = MACH_PORT_NULL; + ports_port_deref (phys_reply_pi); + phys_reply_pi = 0; + } + return err; +} + + +kern_return_t +device_open_reply (mach_port_t replyport, + int returncode, + mach_port_t device) +{ + struct tty_status ttystat; + int count = TTY_STATUS_COUNT; + error_t err; + + if (replyport != phys_reply) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + open_pending = 0; + + if (returncode != 0) + { + /* Bogus. */ + report_carrier_on (); + report_carrier_off (); + + mach_port_deallocate (mach_task_self (), phys_reply); + phys_reply = MACH_PORT_NULL; + ports_port_deref (phys_reply_pi); + phys_reply_pi = 0; + mutex_unlock (&global_lock); + return 0; + } + + assert (phys_device == MACH_PORT_NULL); + assert (phys_reply_writes == MACH_PORT_NULL); + assert (phys_reply_writes_pi == 0); + phys_device = device; + phys_reply_writes_pi = ports_allocate_port (term_bucket, + sizeof (struct port_info), + phys_reply_class); + phys_reply_writes = ports_get_right (phys_reply_writes_pi); + mach_port_insert_right (mach_task_self (), phys_reply_writes, + phys_reply_writes, MACH_MSG_TYPE_MAKE_SEND); + + device_get_status (phys_device, TTY_STATUS, + (dev_status_t)&ttystat, &count); + ttystat.tt_breakc = 0; + ttystat.tt_flags = TF_ANYP | TF_LITOUT | TF_NOHANG | TF_HUPCLS; + device_set_status (phys_device, TTY_STATUS, + (dev_status_t)&ttystat, TTY_STATUS_COUNT); + + err = device_read_request_inband (phys_device, phys_reply, D_NOWAIT, + 0, vm_page_size); + input_pending = 1; + report_carrier_on (); + if (err) + desert_dtr (); + + mutex_unlock (&global_lock); + + return 0; +} + +/* Adjust physical state on the basis of the terminal state. + Where it isn't possible, mutate terminal state to match + reality. */ +void +set_bits () +{ + struct tty_status ttystat; + int cnt = TTY_STATUS_COUNT; + + assert (!(termstate.c_cflag & CIGNORE)); + + if (phys_device == MACH_PORT_NULL) + return; + + /* Find the current state. */ + device_get_status (phys_device, TTY_STATUS, (dev_status_t) &ttystat, &cnt); + if (termstate.__ispeed) + real_speed_to_bogus_speed (termstate.__ispeed, &ttystat.tt_ispeed); + if (termstate.__ospeed) + real_speed_to_bogus_speed (termstate.__ospeed, &ttystat.tt_ospeed); + + /* Try and set it. */ + device_set_status (phys_device, TTY_STATUS, + (dev_status_t) &ttystat, TTY_STATUS_COUNT); + + /* And now make termstate match reality. */ + cnt = TTY_STATUS_COUNT; + device_get_status (phys_device, TTY_STATUS, (dev_status_t) &ttystat, &cnt); + termstate.__ispeed = bogus_speed_to_real_speed (ttystat.tt_ispeed); + termstate.__ospeed = bogus_speed_to_real_speed (ttystat.tt_ospeed); + + /* Mach forces us to use the normal stop bit convention: + two bits at 110 bps; 1 bit otherwise. */ + if (termstate.__ispeed == 110) + termstate.c_cflag |= CSTOPB; + else + termstate.c_cflag &= ~CSTOPB; + + /* Mach only supports 8 bit channels. So wark the CSIZE to conform. */ + termstate.c_cflag = ((termstate.c_cflag & ~CSIZE) + | ((termstate.c_cflag & PARENB) ? CS7 : CS8)); +} + +void +mdmctl (int how, int bits) +{ + int oldbits, newbits; + int cnt; + if ((how == MDMCTL_BIS) || (how == MDMCTL_BIC)) + { + cnt = TTY_MODEM_COUNT; + device_get_status (phys_device, TTY_MODEM, + (dev_status_t) &oldbits, &cnt); + if (cnt < TTY_MODEM_COUNT) + oldbits = 0; /* what else can we do? */ + } + + if (how == MDMCTL_BIS) + newbits = (oldbits | bits); + else if (how == MDMCTL_BIC) + newbits = (oldbits &= ~bits); + else + newbits = bits; + + device_set_status (phys_device, TTY_MODEM, + (dev_status_t) &newbits, TTY_MODEM_COUNT); +} + +int +mdmstate () +{ + int bits, cnt; + + cnt = TTY_MODEM_COUNT; + device_get_status (phys_device, TTY_MODEM, (dev_status_t) &bits, &cnt); + if (cnt != TTY_MODEM_COUNT) + return 0; + else + return bits; +} + +/* Unused stubs */ +kern_return_t +device_read_reply (mach_port_t port, + kern_return_t retcode, + io_buf_ptr_t data, + mach_msg_type_number_t cnt) +{ + return EOPNOTSUPP; +} + +kern_return_t +device_write_reply (mach_port_t replyport, + kern_return_t retcode, + int written) +{ + return EOPNOTSUPP; +} diff --git a/term/main.c b/term/main.c new file mode 100644 index 00000000..b1e384c3 --- /dev/null +++ b/term/main.c @@ -0,0 +1,147 @@ +/* + Copyright (C) 1995 Free Software Foundation, Inc. + Written by Michael I. Bushnell, p/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. */ + +#include "term.h" +#include <hurd.h> +#include <fcntl.h> +#include <hurd/trivfs.h> +#include <stdio.h> +#include <hurd/fsys.h> +#include <string.h> + +int trivfs_fstype = FSTYPE_TERM; +int trivfs_fsid = 0; /* pid?? */ +int trivfs_support_read = 1; +int trivfs_support_write = 1; +int trivfs_support_exec = 0; + +int trivfs_allow_open = O_READ|O_WRITE; + +struct port_class *trivfs_protid_portclasses[1]; +struct port_class *trivfs_cntl_portclasses[1]; +int trivfs_protid_nportclasses = 1; +int trivfs_cntl_nportclasses = 1; + +int +demuxer (mach_msg_header_t *inp, mach_msg_header_t *outp) +{ + extern int term_server (mach_msg_header_t *, mach_msg_header_t *); + extern int tioctl_server (mach_msg_header_t *, mach_msg_header_t *); + extern int device_reply_server (mach_msg_header_t *, mach_msg_header_t *); + + return (trivfs_demuxer (inp, outp) + || term_server (inp, outp) + || tioctl_server (inp, outp) + || device_reply_server (inp, outp)); +} + +int +main (int argc, char **argv) +{ + file_t file; + mach_port_t ctlport, bootstrap; + + term_bucket = ports_create_bucket (); + + tty_cntl_class = ports_create_class (trivfs_clean_cntl, 0); + tty_class = ports_create_class (trivfs_clean_protid, 0); + cttyid_class = ports_create_class (0, 0); + + trivfs_protid_portclasses[0] = tty_class; + trivfs_cntl_portclasses[0] = tty_cntl_class; + + task_get_bootstrap_port (mach_task_self (), &bootstrap); + + if (bootstrap == MACH_PORT_NULL) + { + if (argc != 3) + { + fprintf (stderr, "Usage: term mach-dev-name ttyname\n"); + exit (1); + } + pterm_name = argv[1]; + nodename = argv[2]; + + /* Install control port in filesystem */ + file = file_name_lookup (nodename, O_CREAT|O_NOTRANS, 0666); + if (file == MACH_PORT_NULL) + { + perror (nodename); + exit (1); + } + + ctlport = trivfs_handle_port (file, tty_cntl_class, term_bucket, + tty_class, term_bucket); + termctl = ports_lookup_port (term_bucket, ctlport, tty_cntl_class); + assert (termctl); + + errno = file_set_translator (file, 0, FS_TRANS_EXCL | FS_TRANS_SET, + 0, 0, 0, ctlport, MACH_MSG_TYPE_MAKE_SEND); + if (errno) + { + perror ("setting translator"); + exit (1); + } + } + else + { + if (argc < 2 || argc > 3) + { + fprintf (stderr, "Usage (as translator): term mach-dev-name [ttyname]\n"); + exit (1); + } + pterm_name = argv[1]; + nodename = (argv[2] ?: ""); + + ctlport = trivfs_handle_port (MACH_PORT_NULL, tty_cntl_class, + term_bucket, tty_class, term_bucket); + errno = fsys_startup (bootstrap, ctlport, MACH_MSG_TYPE_MAKE_SEND, + &file); + if (errno) + { + perror ("Starting translator"); + exit (1); + } + termctl = ports_lookup_port (term_bucket, ctlport, 0); + assert (termctl); + termctl->underlying = file; + } + + bzero (&termstate, sizeof (termstate)); + termflags = NO_CARRIER; + output_psize = 0; + mutex_init (&global_lock); + + inputq = create_queue (256, 100, 300); + rawq = create_queue (256, 100, 300); + outputq = create_queue (256, 100, 300); + + condition_init (&carrier_alert); + condition_init (&select_alert); + condition_implies (inputq->wait, &select_alert); + condition_implies (outputq->wait, &select_alert); + + /* Launch */ + ports_manage_port_operations_multithread (term_bucket, demuxer, 0, 0, + 0, MACH_PORT_NULL); + + return 0; +} + diff --git a/term/munge.c b/term/munge.c new file mode 100644 index 00000000..31f0bdee --- /dev/null +++ b/term/munge.c @@ -0,0 +1,725 @@ +/* + Copyright (C) 1995 Free Software Foundation, Inc. + Written by Michael I. Bushnell, p/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. */ + +#include "term.h" +#include <termios.h> +#include <unistd.h> +#include <signal.h> +#include <ctype.h> +#include <string.h> + +/* Number of characters in the rawq which have been + echoed continuously without intervening output. */ +int echo_qsize; + +/* Where the output_psize was when echo_qsize was last 0. */ +int echo_pstart; + +/* Actually drop character onto output queue. This should be the + only place where we actually enqueue characters on the output queue; + it is responsible for keeping track of cursor positions. */ +inline void +poutput (int c) +{ + if (termflags & FLUSH_OUTPUT) + return; /* never mind */ + + if ((c >= ' ') && (c < '\177')) + output_psize++; + else if (c == '\r') + output_psize = 0; + else if (c == '\t') + output_psize += (output_psize + 8) % 8; + else if (c == '\b') + output_psize--; + + enqueue (&outputq, c); +} + +/* Place C on output queue, doing normal output processing. + This is used for write, never for echo. */ +void +output_character (int c) +{ + int oflag = termstate.c_oflag; + + /* One might think we should turn of INHDERASE here, but, no + in U*x it is only turned off by echoed characters. + See echo_char in input.c. */ + if (oflag & OPOST) + { + /* Characters we write specially */ + if ((oflag & ONLCR) && c == '\n') + { + poutput ('\r'); + poutput ('\n'); + } + else if ((oflag & OXTABS) && c == '\t') + { + poutput (' '); + while (output_psize % 8) + poutput (' '); + } + else if ((oflag & ONOEOT) && c == CHAR_EOT) + ; + else if ((oflag & OTILDE) && c == '~') + { + poutput ('\\'); + poutput ('`'); + } + else if ((oflag & OLCASE) && isalpha (c)) + { + if (isupper (c)) + poutput ('\\'); + else + c = toupper (c); + poutput (c); + } + else + poutput (c); + } + else + poutput (c); + echo_qsize = 0; + echo_pstart = output_psize; +} + +/* Report the width of character C as printed by output_character, + if output_psize were at LOC. . */ +int +output_width (int c, int loc) +{ + int oflag = termstate.c_oflag; + + if (oflag & OPOST) + { + if ((oflag & OTILDE) && c == '~') + return 2; + if ((oflag & OLCASE) && isalpha (c) && isupper (c)) + return 2; + } + if (c == '\t') + { + int n = loc + 1; + while (n % 8) + n++; + return n; + } + if ((c >= ' ') && (c < '\177')) + return 1; + return 0; +} + + + +/* For ICANON mode, this holds the edited line. */ +struct queue *rawq; + +/* For each character in this table, if the element is set, then + the character is EVEN */ +char const char_parity[] = +{ + 1, 0, 0, 1, 0, 1, 1, 0, /* nul - bel */ + 0, 1, 1, 0, 1, 0, 0, 1, /* bs - si */ + 0, 1, 1, 0, 1, 0, 0, 1, /* dle - etb */ + 1, 0, 0, 1, 0, 1, 1, 0, /* can - us */ + 0, 1, 1, 0, 1, 0, 0, 1, /* sp - ' */ + 1, 0, 0, 1, 0, 1, 1, 0, /* ( - / */ + 1, 0, 0, 1, 0, 1, 1, 0, /* 0 - 7 */ + 0, 1, 1, 0, 1, 0, 0, 1, /* 8 - ? */ + 0, 1, 1, 0, 1, 0, 0, 1, /* @ - G */ + 1, 0, 0, 1, 0, 1, 1, 0, /* H - O */ + 1, 0, 0, 1, 0, 1, 1, 0, /* P - W */ + 0, 1, 1, 0, 1, 0, 0, 1, /* X - _ */ + 1, 0, 0, 1, 0, 1, 1, 0, /* ` - g */ + 0, 1, 1, 0, 1, 0, 0, 1, /* h - o */ + 0, 1, 1, 0, 1, 0, 0, 1, /* p - w */ + 1, 0, 0, 1, 0, 1, 1, 0, /* x - del */ +}; +#define checkevenpar(c) (((c)&0x80) \ + ? !char_parity[(c)&0x7f] \ + : char_parity[(c)&0x7f]) +#define checkoddpar(c) (((c)&0x80) \ + ? char_parity[(c)&0x7f] \ + : !char_parity[(c)&0x7f]) + + + +/* These functions are used by both echo and erase code */ + +/* Tell if we should echo a character at all */ +static inline int +echo_p (char c, int quoted) +{ + return ((termstate.c_lflag & ECHO) + || (c == '\n' && (termstate.c_lflag & ECHONL) && !quoted)); +} + +/* Tell if this character deserves double-width cntrl processing */ +static inline int +echo_double (char c, int quoted) +{ + return (iscntrl (c) && (termstate.c_lflag & ECHOCTL) + && !((c == '\n' || c == '\t') && !quoted)); +} + +/* Do a single C-h SPC C-h sequence */ +static inline void +write_erase_sequence () +{ + poutput ('\b'); + poutput (' '); + poutput ('\b'); +} + +/* Echo a single character to the output */ +/* If this is an echo of a character which is being hard-erased, + set hderase. If this is a newline or tab which should not receive + their normal special processing, set quoted. */ +static void +echo_char (char c, int hderase, int quoted) +{ + echo_qsize++; + + if (echo_p (c, quoted)) + { + if (!hderase && (termflags & INSIDE_HDERASE)) + { + poutput ('/'); + termflags &= ~INSIDE_HDERASE; + echo_qsize = 0; + echo_pstart = output_psize; + } + + if (hderase && !(termflags & INSIDE_HDERASE)) + { + poutput ('\\'); + termflags |= INSIDE_HDERASE; + } + + /* Control characters that should use caret-letter */ + if (echo_double (c, quoted)) + { + poutput ('^'); + poutput (c + ('A' - CHAR_SOH)); + } + else + poutput (c); + } +} + + +/* Re-echo the current rawq preceded by the VREPRINT char. */ +static inline void +reprint_line () +{ + short *cp; + + if (termstate.c_cc[VREPRINT] != _POSIX_VDISABLE) + echo_char (termstate.c_cc[VREPRINT], 0, 0); + else + echo_char (CHAR_DC3, 0, 0); + echo_char ('\n', 0, 0); + + echo_qsize = 0; + echo_pstart = output_psize; + + for (cp = rawq->cs; cp != rawq->ce; cp++) + echo_char (unquote_char (*cp), 0, char_quoted_p (*cp)); +} + +/* Erase a single character off the end of the rawq, and delete + it from the screen appropriately. Set ERASE_CHAR if this + is being done by the VERASE character, to that character. */ +static void +erase_1 (char erase_char) +{ + int quoted; + char c; + quoted_char cq; + + if (qsize (rawq) == 0) + return; + + cq = queue_erase (rawq); + c = unquote_char (cq); + quoted = char_quoted_p (cq); + + if (!echo_p (c, quoted)) + return; + + /* The code for WERASE knows that we echo erase_char iff + !ECHOPRT && !ECHO. */ + + if (echo_qsize--) + { + if (termstate.c_lflag & ECHOPRT) + echo_char (c, 1, quoted); + else if (!(termstate.c_lflag & ECHOE) && erase_char) + echo_char (erase_char, 0, 0); + else + { + int nerase; + + if (echo_double (c, quoted)) + nerase = 2; + else if (c == '\t') + { + quoted_char *cp; + int loc = echo_pstart; + + for (cp = rawq->ce - echo_qsize; cp != rawq->ce; cp++) + loc += (echo_double (unquote_char (*cp), char_quoted_p (*cp)) + ? 2 + : output_width (*cp, loc)); + nerase = output_psize - loc; + } + else + nerase = output_width (c, output_psize); + + while (nerase--) + write_erase_sequence (); + } + if (echo_qsize == 0) + assert (echo_pstart == output_psize); + } + else + reprint_line (); +} + + +/* Place newly input character C on the input queue. If all remaining + pending input characters should be dropped, return 1; else return + 0. */ +int +input_character (int c) +{ + int lflag = termstate.c_lflag; + int iflag = termstate.c_iflag; + int cflag = termstate.c_cflag; + cc_t *cc = termstate.c_cc; + struct queue **qp = (lflag & ICANON) ? &rawq : &inputq; + int flush = 0; + + /* Handle parity errors */ + if ((iflag & INPCK) + && ((cflag & PARODD) ? checkoddpar (c) : checkevenpar (c))) + { + if (iflag & IGNPAR) + goto alldone; + else if (iflag & PARMRK) + { + enqueue_quote (qp, CHAR_USER_QUOTE); + enqueue_quote (qp, '\0'); + enqueue_quote (qp, c); + goto alldone; + } + else + c = 0; + } + + /* Check to see if we should send IXOFF */ + if ((iflag & IXOFF) + && !qavail (*qp) + && (cc[VSTOP] != _POSIX_VDISABLE)) + { + poutput (cc[VSTOP]); + termflags |= SENT_VSTOP; + } + + /* Character mutations */ + if (!(iflag & ISTRIP) && (iflag & PARMRK) && (c == CHAR_USER_QUOTE)) + enqueue_quote (qp, CHAR_USER_QUOTE); /* cause doubling */ + + if (iflag & ISTRIP) + c &= 0x7f; + + /* Handle LNEXT right away */ + if (termflags & LAST_LNEXT) + { + enqueue_quote (qp, c); + echo_char (c, 0, 1); + termflags &= ~LAST_LNEXT; + } + + /* Mutate ILCASE */ + if ((iflag & ILCASE) && isalpha(c)) + { + if (termflags & LAST_SLASH) + erase_1 (0); /* remove the slash from input */ + else + c = isupper(c) ? tolower (c) : c; + } + + /* IEXTEN control chars */ + if (lflag & IEXTEN) + { + if (CCEQ (cc[VLNEXT], c)) + { + if (lflag & ECHO) + { + poutput ('^'); + poutput ('\b'); + } + termflags |= LAST_LNEXT; + goto alldone; + } + + if (CCEQ (cc[VDISCARD], c)) + { + if (termflags & FLUSH_OUTPUT) + termflags &= ~FLUSH_OUTPUT; + else + { + drop_output (); + termflags |= FLUSH_OUTPUT; + } + } + } + + /* Signals */ + if (lflag & ISIG) + { + if (CCEQ (cc[VINTR], c) || CCEQ (cc[VQUIT], c)) + { + if (!(lflag & NOFLSH)) + { + drop_output (); + flush = 1; + } + echo_char (c, 0, 0); + send_signal (CCEQ (cc[VINTR], c) ? SIGINT : SIGQUIT); + goto alldone; + } + + if (CCEQ (cc[VSUSP], c)) + { + if (!(lflag & NOFLSH)) + flush = 1; + echo_char (c, 0, 0); + send_signal (SIGTSTP); + goto alldone; + } + } + + /* IXON */ + if (iflag & IXON) + { + if (CCEQ (cc[VSTOP], c)) + { + termflags |= USER_OUTPUT_SUSP; + + if (!(CCEQ(cc[VSTART], c))) /* toggle if VSTART == VSTOP */ + /* Alldone code always turns off USER_OUTPUT_SUSP. */ + goto alldone; + + return flush; + } + if (CCEQ (cc[VSTART], c)) + goto alldone; + } + + /* Newline and carriage-return frobbing */ + if (c == '\r') + { + if (iflag & ICRNL) + c = '\n'; + else if (iflag & IGNCR) + goto alldone; + } + else if ((c == '\n') && (iflag & INLCR)) + c = '\r'; + + /* Canonical mode processing */ + if (lflag & ICANON) + { + if (CCEQ (cc[VERASE], c)) + { + if (qsize(rawq)) + erase_1 (c); + if (!(termflags & LAST_SLASH) + || !(lflag & IEXTEN)) + goto alldone; + } + + if (CCEQ (cc[VKILL], c)) + { + if (!(termflags & LAST_SLASH) + || !(lflag & IEXTEN)) + { + if ((lflag & ECHOKE) && !(lflag & ECHOPRT) + && (echo_qsize == qsize (rawq))) + { + while (output_psize > echo_pstart) + write_erase_sequence (); + } + else + { + echo_char (c, 0, 0); + if ((lflag & ECHOK) || (lflag & ECHOKE)) + echo_char ('\n', 0, 0); + } + clear_queue (rawq); + echo_qsize = 0; + echo_pstart = output_psize; + termflags &= ~(LAST_SLASH|LAST_LNEXT|INSIDE_HDERASE); + goto alldone; + } + else + erase_1 (0); /* remove \ */ + } + + if (CCEQ (cc[VWERASE], c)) + { + /* If we are not going to echo the erase, then + echo a WERASE character right now. (If we + passed it to erase_1; it would echo it multiple + times.) */ + if (!(lflag & (ECHOPRT|ECHOE))) + echo_char (cc[VWERASE], 0, 1); + + /* Erase whitespace */ + while (qsize (rawq) && isblank (unquote_char (rawq->ce[-1]))) + erase_1 (0); + + /* Erase word. */ + if (lflag & ALTWERASE) + /* For ALTWERASE, we erase back to the first blank */ + while (qsize (rawq) && !isblank (unquote_char (rawq->ce[-1]))) + erase_1 (0); + else + /* For regular WERASE, we erase back to the first nonalpha/_ */ + while (qsize (rawq) && !isblank (unquote_char (rawq->ce[-1])) + && (isalnum (unquote_char (rawq->ce[-1])) + || (unquote_char (rawq->ce[-1]) != '_'))) + erase_1 (0); + + goto alldone; + } + + if (CCEQ (cc[VREPRINT], c) && (lflag & IEXTEN)) + { + reprint_line (); + goto alldone; + } + + if (CCEQ (cc[VSTATUS], c) && (lflag & ISIG) && (lflag & IEXTEN)) + { + send_signal (SIGINFO); + goto alldone; + } + } + + /* Now we have a character intended as input. See if it will fit. */ + if (!qavail (*qp)) + { + if (iflag & IMAXBEL) + poutput ('\a'); + else + { + /* Drop everything */ + drop_output (); + flush = 1; + } + goto alldone; + } + + /* Echo */ + echo_char (c, 0, 0); + if (CCEQ (cc[VEOF], c) && (lflag & ECHO)) + { + /* Special bizzare echo processing for VEOF character. */ + int n; + n = echo_double (c, 0) ? 2 : output_width (c, output_psize); + while (n--) + poutput ('\b'); + } + + /* Put character on input queue */ + enqueue (qp, c); + + /* Check for break characters in canonical input processing */ + if (lflag & ICANON) + { + if (CCEQ (cc[VEOL], c) + || CCEQ (cc[VEOL2], c) + || CCEQ (cc[VEOF], c) + || c == '\n') + /* Make input available */ + while (qsize (rawq)) + enqueue (&inputq, dequeue (rawq)); + } + +alldone: + /* Restart output */ + if ((iflag & IXANY) || (CCEQ (cc[VSTART], c))) + termflags &= ~USER_OUTPUT_SUSP; + start_output (); + + return flush; +} + + +/* This is called by the lower half when a break is received. */ +void +input_break () +{ + struct queue **qp = termstate.c_lflag & ICANON ? &rawq : &inputq; + + /* Don't do anything if IGNBRK is set. */ + if (termstate.c_iflag & IGNBRK) + return; + + /* If BRKINT is set, then flush queues and send SIGINT. */ + if (termstate.c_iflag & BRKINT) + { + drop_output (); + /* XXX drop pending input How?? */ + send_signal (SIGINT); + return; + } + + /* A break is then read as a null byte; marked specially if PARMRK is set. */ + if (termstate.c_iflag & PARMRK) + { + enqueue_quote (qp, CHAR_USER_QUOTE); + enqueue_quote (qp, '\0'); + } + enqueue_quote (qp, '\0'); +} + +/* Called when a character is recived with a framing error. */ +void +input_framing_error (int c) +{ + struct queue **qp = termstate.c_lflag & ICANON ? &rawq : &inputq; + + /* Ignore it if IGNPAR is set. */ + if (termstate.c_iflag & IGNPAR) + return; + + /* If PARMRK is set, pass it specially marked. */ + if (termstate.c_iflag & PARMRK) + { + enqueue_quote (qp, CHAR_USER_QUOTE); + enqueue_quote (qp, '\0'); + enqueue_quote (qp, c); + } + else + /* Otherwise, it looks like a null. */ + enqueue_quote (qp, '\0'); +} + +/* Copy the characters in RAWQ to the end of INPUTQ and clear RAWQ. */ +void +copy_rawq () +{ + while (qsize (rawq)) + enqueue (&inputq, dequeue (rawq)); +} + +/* Process all the characters in INPUTQ as if they had just been read. */ +void +rescan_inputq () +{ + short *buf; + int i, n; + + n = qsize (inputq); + buf = alloca (n * sizeof (quoted_char)); + bcopy (inputq->cs, buf, n * sizeof (quoted_char)); + clear_queue (inputq); + + for (i = 0; i < n; i++) + input_character (unquote_char (buf[i])); +} + +void +drop_output () +{ + clear_queue (outputq); + abandon_physical_output (); +} + +error_t +drain_output () +{ + int cancel = 0; + + while ((qsize (outputq) || pending_output_size ()) + && (!(termflags & NO_CARRIER) || (termstate.c_cflag & CLOCAL)) + && !cancel) + cancel = hurd_condition_wait (outputq->wait, &global_lock); + + return cancel ? EINTR : 0; +} + +/* Create and return a new queue. */ +struct queue * +create_queue (int size, int lowat, int hiwat) +{ + struct queue *q; + + q = malloc (sizeof (struct queue) + size * sizeof (quoted_char)); + q->susp = 0; + q->lowat = lowat; + q->hiwat = hiwat; + q->cs = q->ce = q->array; + q->arraylen = size; + q->wait = malloc (sizeof (struct condition)); + condition_init (q->wait); + return q; +} + +/* Make Q able to have more characters added to it. */ +struct queue * +reallocate_queue (struct queue *q) +{ + int len; + struct queue *newq; + + len = qsize (q); + + if (len < q->arraylen / 2) + { + /* Shift the characters to the front of + the queue. */ + memmove (q->array, q->cs, len * sizeof (quoted_char)); + q->cs = q->array; + q->ce = q->cs + len; + } + else + { + /* Make the queue twice as large. */ + newq = malloc (sizeof (struct queue) + + q->arraylen * 2 * sizeof (quoted_char)); + newq->susp = q->susp; + newq->lowat = q->lowat; + newq->hiwat = q->hiwat; + newq->cs = newq->array; + newq->ce = newq->array + len; + newq->arraylen = q->arraylen * 2; + newq->wait = q->wait; + memmove (newq->array, q->cs, len * sizeof (quoted_char)); + free (q); + q = newq; + } + return q; +} diff --git a/term/term.h b/term/term.h new file mode 100644 index 00000000..a55f7027 --- /dev/null +++ b/term/term.h @@ -0,0 +1,264 @@ +/* + Copyright (C) 1995 Free Software Foundation, Inc. + Written by Michael I. Bushnell, p/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. */ + +#include <cthreads.h> +#include <assert.h> + +#undef MDMBUF +#undef ECHO +#undef TOSTOP +#undef FLUSHO +#undef PENDIN +#undef NOFLSH +#include <termios.h> + +#define CHAR_SOH '\001' /* C-a */ +#define CHAR_EOT '\004' /* C-d */ +#define CHAR_DC3 '\022' /* C-r */ +#define CHAR_USER_QUOTE '\377' /* break quoting, etc. */ + +/* XXX These belong in <termios.h> */ +#define ILCASE (1 << 14) +#define OLCASE (1 << 9) +#define OTILDE (1 << 10) + +/* used in mdmctl device call */ +#define MDMCTL_BIS 0 +#define MDMCTL_BIC 1 +#define MDMCTL_SET 2 + +/* Directly user-visible state */ +struct termios termstate; + +/* Other state with the following bits: */ +long termflags; + +#define USER_OUTPUT_SUSP 0x00000001 /* user has suspended output */ +#define TTY_OPEN 0x00000002 /* someone has us open */ +#define LAST_SLASH 0x00000004 /* last input char was \ */ +#define LAST_LNEXT 0x00000008 /* last input char was VLNEXT */ +#define INSIDE_HDERASE 0x00000010 /* inside \.../ hardcopy erase pair */ +#define SENT_VSTOP 0x00000020 /* we've sent VSTOP to IXOFF peer */ +#define FLUSH_OUTPUT 0x00000040 /* user wants output flushed */ +#define NO_CARRIER 0x00000080 /* carrier is absent */ +#define EXCL_USE 0x00000100 /* user accessible exclusive use */ +#define NO_OWNER 0x00000200 /* there is no foreground_id */ +#define ICKY_ASYNC 0x00000400 /* some user has set O_ASYNC */ + +/* PHYSICAL position of the terminal cursor */ +int output_psize; + +/* Global lock */ +struct mutex global_lock; + +/* Wakeup when NO_CARRIER turns off */ +struct condition carrier_alert; + +/* Wakeup for select */ +struct condition select_alert; + +/* Bucket for all our ports. */ +struct port_bucket *term_bucket; + +/* Port class for tty control ports */ +struct port_class *tty_cntl_class; + +/* Port class for tty I/O ports */ +struct port_class *tty_class; + +/* Port class for ctty ID ports */ +struct port_class *cttyid_class; + +/* Trivfs control structure for the tty */ +struct trivfs_control *termctl; + +/* Filename for this terminal */ +char *nodename; + +/* Mach device name for this terminal */ +char *pterm_name; + +/* The queues we use */ +struct queue *inputq, *rawq, *outputq; + + +/* Character queues */ +#define QUEUE_QUOTE_MARK 0xf000 +typedef short quoted_char; +struct queue +{ + int susp; + int lowat; + int hiwat; + short *cs, *ce; + int arraylen; + struct condition *wait; + quoted_char array[0]; +}; + +struct queue *create_queue (int size, int lowat, int hiwat); + +/* Return the number of characters in Q. */ +extern inline int +qsize (struct queue *q) +{ + return q->ce - q->cs; +} + +/* Return nonzero if characters can be added to Q. */ +extern inline int +qavail (struct queue *q) +{ + return !q->susp; +} + +/* Flush all the characters from Q. */ +extern inline int +clear_queue (struct queue *q) +{ + q->susp = 0; + q->cs = q->ce = q->array; + condition_broadcast (q->wait); +} + + +/* Return the next character off Q; leave the quoting bit on. */ +extern inline quoted_char +dequeue_quote (struct queue *q) +{ + int beep = 0; + + assert (qsize (q)); + if (q->susp && (qsize (q) < q->lowat)) + { + q->susp = 0; + beep = 1; + } + if (qsize (q) == 1) + beep = 1; + if (beep) + condition_broadcast (q->wait); + return *q->cs++; +} + +/* Return the next character off Q. */ +extern inline char +dequeue (struct queue *q) +{ + return dequeue_quote (q) & ~QUEUE_QUOTE_MARK; +} + +struct queue *reallocate_queue (struct queue *); + +/* Add C to *QP. */ +extern inline void +enqueue_internal (struct queue **qp, quoted_char c) +{ + struct queue *q = *qp; + + if (q->ce - q->array == q->arraylen) + q = *qp = reallocate_queue (q); + + *q->ce++ = c; + + if (qsize (q) == 1) + condition_broadcast (q->wait); + + if (!q->susp && (qsize (q) > q->hiwat)) + q->susp = 1; +} + +/* Add C to *QP. */ +extern inline void +enqueue (struct queue **qp, char c) +{ + enqueue_internal (qp, c); +} + +/* Add C to *QP, marking it with a quote. */ +extern inline void +enqueue_quote (struct queue **qp, char c) +{ + enqueue_internal (qp, c | QUEUE_QUOTE_MARK); +} + +/* Return the unquoted version of a quoted_char. */ +extern inline char +unquote_char (quoted_char c) +{ + return c & ~QUEUE_QUOTE_MARK; +} + +/* Tell if a quoted_char is actually quoted. */ +extern inline int +char_quoted_p (quoted_char c) +{ + return c & QUEUE_QUOTE_MARK; +} + +/* Remove the most recently enqueue character from Q; leaving + the quote mark on. */ +extern inline short +queue_erase (struct queue *q) +{ + short answer; + int beep = 0; + + assert (qsize (q)); + answer = *--q->ce; + if (q->susp && (qsize (q) < q->lowat)) + { + q->susp = 0; + beep = 1; + } + if (qsize (q) == 0) + beep = 1; + if (beep) + condition_broadcast (q->wait); + return answer; +} + + +/* Functions devio is supposed to call */ +int input_character (int); +void report_carrier_on (void); +void report_carrier_off (void); + + +/* Other decls */ +void drop_output (void); +void send_signal (int); +error_t drain_output (); +void output_character (int); +void copy_rawq (void); +void rescan_inputq (void); + + +/* exported by the devio interface */ +void start_output (void); +void set_break (void); +void clear_break (void); +void abandon_physical_output (void); +int pending_output_size (void); +error_t assert_dtr (void); +void desert_dtr (void); +void set_bits (void); +void mdmctl (int, int); +int mdmstate (void); diff --git a/term/users.c b/term/users.c new file mode 100644 index 00000000..4eb61be8 --- /dev/null +++ b/term/users.c @@ -0,0 +1,1659 @@ +/* + Copyright (C) 1995 Free Software Foundation, Inc. + Written by Michael I. Bushnell, p/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. */ + +#include "term.h" +#include <sys/stat.h> +#include <unistd.h> +#include <sys/types.h> +#include <string.h> +#include <fcntl.h> +#include <hurd/trivfs.h> +#include <cthreads.h> +#include <hurd.h> +#include "ourmsg_U.h" + +#undef ECHO +#undef MDMBUF +#undef TOSTOP +#undef FLUSHO +#undef PENDIN +#undef NOFLSH + +#include "term_S.h" +#include "tioctl_S.h" +#include <sys/ioctl.h> + +#define TTYDEFCHARS +#include <sys/ttydefaults.h> + +/* Count of active opens */ +int nperopens; + +/* io_async requests */ +struct async_req +{ + mach_port_t notify; + struct async_req *next; +}; +struct async_req *async_requests; + +mach_port_t async_icky_id; +mach_port_t async_id; +struct port_info *cttyid; +int foreground_id; + +struct winsize window_size; + +static void call_asyncs (void); + +/* Attach this on the hook of any protid that is a ctty. */ +struct protid_hook +{ + int refcnt; + pid_t pid, pgrp; +}; + +static error_t +open_hook (struct trivfs_control *cntl, + uid_t *uids, u_int nuids, + uid_t *gids, u_int ngids, + int flags) +{ + int cancel = 0; + error_t err; + + mutex_lock (&global_lock); + + if (!(termflags & TTY_OPEN)) + { + bzero (&termstate, sizeof termstate); + + /* This is different from BSD: we don't turn on ISTRIP, + and we use CS8 rather than CS7|PARENB. */ + termstate.c_iflag |= BRKINT | ICRNL | IMAXBEL | IXON | IXANY; + termstate.c_oflag |= OPOST | ONLCR | OXTABS; + termstate.c_lflag |= (ECHO | ICANON | ISIG | IEXTEN + | ECHOE|ECHOKE|ECHOCTL); + termstate.c_cflag |= CREAD | CS8 | HUPCL; + + bcopy (ttydefchars, termstate.c_cc, NCCS); + } + else if (termflags & EXCL_USE) + { + mutex_unlock (&global_lock); + return EBUSY; + } + + /* Wait for carrier to turn on. */ + while (((termflags & NO_CARRIER) && !(termstate.c_cflag & CLOCAL)) + && !(flags & O_NONBLOCK) + && !cancel) + { + err = assert_dtr (); + if (err) + { + mutex_unlock (&global_lock); + return err; + } + cancel = hurd_condition_wait (&carrier_alert, &global_lock); + } + + if ((termflags & NO_CARRIER) && !(termstate.c_cflag & CLOCAL)) + { + mutex_unlock (&global_lock); + return EWOULDBLOCK; + } + if (cancel) + { + mutex_unlock (&global_lock); + return EINTR; + } + + termflags |= TTY_OPEN; + if (!(termstate.c_cflag & CIGNORE)) + set_bits (); + + mutex_unlock (&global_lock); + return 0; +} +error_t (*trivfs_check_open_hook) (struct trivfs_control *, uid_t *, + u_int, uid_t *, u_int, int) + = open_hook; + +static error_t +pi_create_hook (struct trivfs_protid *cred) +{ + mutex_lock (&global_lock); + if (cred->hook) + ((struct protid_hook *)cred->hook)->refcnt++; + mutex_unlock (&global_lock); + + return 0; +} +error_t (*trivfs_protid_create_hook) (struct trivfs_protid *) = pi_create_hook; + +static void +pi_destroy_hook (struct trivfs_protid *cred) +{ + mutex_lock (&global_lock); + if (cred->hook && !--((struct protid_hook *)cred->hook)->refcnt) + free (cred->hook); + mutex_unlock (&global_lock); +} +void (*trivfs_protid_destroy_hook) (struct trivfs_protid *) = pi_destroy_hook; + +static error_t +po_create_hook (struct trivfs_peropen *po) +{ + mutex_lock (&global_lock); + nperopens++; + if (po->openmodes & O_ASYNC) + termflags |= ICKY_ASYNC; + mutex_unlock (&global_lock); + return 0; +} +error_t (*trivfs_peropen_create_hook) (struct trivfs_peropen *) = + po_create_hook; + +static void +po_destroy_hook (struct trivfs_peropen *po) +{ + mutex_lock (&global_lock); + nperopens--; + if (!nperopens) + { + /* Empty queues */ + clear_queue (inputq); + clear_queue (rawq); + drain_output (); + + /* Possibly drop carrier */ + if ((termstate.c_cflag & HUPCL) || (termflags & NO_CARRIER)) + desert_dtr (); + + termflags &= ~TTY_OPEN; + } + mutex_unlock (&global_lock); +} +void (*trivfs_peropen_destroy_hook) (struct trivfs_peropen *) + = po_destroy_hook; + +/* Tell if CRED can do foreground terminal operations */ +static inline int +fg_p (struct trivfs_protid *cred) +{ + struct protid_hook *hook = cred->hook; + + if (!hook || (termflags & NO_OWNER)) + return 1; + + if (hook->pid == foreground_id + || hook->pgrp == -foreground_id) + return 1; + + return 0; +} + +void +trivfs_modify_stat (struct trivfs_protid *cred, struct stat *st) +{ + st->st_blksize = 512; + st->st_fstype = FSTYPE_TERM; + st->st_fsid = getpid (); + st->st_ino = 0; + st->st_mode &= ~S_IFMT; + st->st_mode |= S_IFCHR; +} + +/* Implement term_getctty as described in <hurd/term.defs>. */ +kern_return_t +S_term_getctty (mach_port_t arg, + mach_port_t *id, + mach_msg_type_name_t *idtype) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, + arg, tty_class); + error_t err; + + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + *id = ports_get_right (cttyid); + *idtype = MACH_MSG_TYPE_MAKE_SEND; + err = 0; + } + ports_port_deref (cred); + mutex_unlock (&global_lock); + return err; +} + +/* Implement termctty_open_terminal as described in <hurd/term.defs>. */ +kern_return_t +S_termctty_open_terminal (mach_port_t arg, + int flags, + mach_port_t *result, + mach_msg_type_name_t *resulttype) +{ + error_t err; + mach_port_t new_realnode; + struct trivfs_protid *newcred; + struct port_info *pi = ports_lookup_port (term_bucket, arg, cttyid_class); + + if (!pi) + return EOPNOTSUPP; + + assert (pi == cttyid); + + err = io_restrict_auth (termctl->underlying, &new_realnode, 0, 0, 0, 0); + + if (!err) + { + err = trivfs_open (termctl, 0, 0, 0, 0, flags, new_realnode, &newcred); + if (!err) + { + *result = ports_get_right (newcred); + *resulttype = MACH_MSG_TYPE_MAKE_SEND; + ports_port_deref (newcred); + } + } + + ports_port_deref (pi); + return err; +} + +/* Implement term_become_ctty as described in <hurd/term.defs>. */ +kern_return_t +S_term_open_ctty (mach_port_t arg, + pid_t pid, + pid_t pgrp, + mach_port_t *newpt, + mach_msg_type_name_t *newpttype) +{ + error_t err; + struct trivfs_protid *newcred; + struct trivfs_protid *cred = ports_lookup_port (term_bucket, arg, tty_class); + + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + if (!cred->po->openmodes & (O_READ|O_WRITE)) + { + mutex_unlock (&global_lock); + err = EBADF; + } + else + { + mutex_unlock (&global_lock); + err = trivfs_protid_dup (cred, &newcred); + + if (!err) + { + struct protid_hook *hook = malloc (sizeof (struct protid_hook)); + + hook->pid = pid; + hook->pgrp = pgrp; + hook->refcnt = 1; + + if (newcred->hook) + /* We inherited CRED's hook, get rid of our ref to it. */ + pi_destroy_hook (newcred); + newcred->hook = hook; + + *newpt = ports_get_right (newcred); + *newpttype = MACH_MSG_TYPE_MAKE_SEND; + + ports_port_deref (newcred); + } + } + + ports_port_deref (cred); + + return err; +} + +/* Called for user writes to the terminal as described + in <hurd/io.defs>. */ +error_t +trivfs_S_io_write (struct trivfs_protid *cred, + mach_port_t reply, + mach_msg_type_name_t replytype, + char *data, + u_int datalen, + off_t offset, + int *amt) +{ + int i; + int cancel; + + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + /* Check for errors first. */ + + if ((cred->po->openmodes & O_WRITE) == 0) + { + mutex_unlock (&global_lock); + return EBADF; + } + + if ((termstate.c_lflag & TOSTOP) && !fg_p (cred)) + { + mutex_unlock (&global_lock); + return EBACKGROUND; + } + + if ((termflags & NO_CARRIER) && !(termstate.c_cflag & CLOCAL)) + { + mutex_unlock (&global_lock); + return EIO; + + } + + cancel = 0; + for (i = 0; i < datalen; i++) + { + while (!qavail (outputq) && !cancel) + cancel = hurd_condition_wait (outputq->wait, &global_lock); + if (cancel) + break; + + output_character (data[i]); + } + + *amt = i; + + start_output (); + + trivfs_set_mtime (termctl); + + call_asyncs (); + + mutex_unlock (&global_lock); + + return ((cancel && datalen && !*amt) ? EINTR : 0); +} + +/* Called for user reads from the terminal. */ +error_t +trivfs_S_io_read (struct trivfs_protid *cred, + mach_port_t reply, + mach_msg_type_name_t replytype, + char **data, + u_int *datalen, + off_t offset, + int amount) +{ + int cancel; + int i, max; + char *cp; + + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + if ((cred->po->openmodes & O_READ) == 0) + { + mutex_unlock (&global_lock); + return EBADF; + } + + if (!fg_p (cred)) + { + mutex_unlock (&global_lock); + return EBACKGROUND; + } + + while (!qsize (inputq)) + { + if ((termflags & NO_CARRIER) && !(termstate.c_cflag & CLOCAL)) + { + /* Return EOF, Posix.1 7.1.1.10. */ + mutex_unlock (&global_lock); + *datalen = 0; + return 0; + } + + if (cred->po->openmodes & O_NONBLOCK) + { + mutex_unlock (&global_lock); + return EWOULDBLOCK; + } + + if (hurd_condition_wait (inputq->wait, &global_lock)) + { + mutex_unlock (&global_lock); + return EINTR; + } + } + + max = (amount < qsize (inputq)) ? amount : qsize (inputq); + + if (max > *datalen) + vm_allocate (mach_task_self (), (vm_address_t *)data, max, 1); + + cancel = 0; + cp = *data; + for (i = 0; i < max; i++) + { + char c = dequeue (inputq); + + /* Unless this is EOF, add it to the response. */ + if (!(termstate.c_lflag & ICANON) + || !CCEQ (termstate.c_cc[VEOF], c)) + *cp++ = c; + + /* If this is a break character, then finish now. */ + if ((termstate.c_lflag & ICANON) + && (c == '\n' + || CCEQ (termstate.c_cc[VEOF], c) + || CCEQ (termstate.c_cc[VEOL], c) + || CCEQ (termstate.c_cc[VEOL2], c))) + break; + + /* If this is the delayed suspend character, then signal now. */ + if ((termstate.c_lflag & ISIG) + && CCEQ (termstate.c_cc[VDSUSP], c)) + { + /* The CANCEL flag is being used here to tell the return + below to make sure we don't signal EOF on a VDUSP that + happens at the front of a line. */ + send_signal (SIGTSTP); + cancel = 1; + break; + } + } + + *datalen = cp - *data; + + mutex_unlock (&global_lock); + + call_asyncs (); + + return !*datalen && cancel ? EINTR : 0; +} + +error_t +trivfs_S_io_readable (struct trivfs_protid *cred, + mach_port_t reply, + mach_msg_type_name_t replytype, + int *amt) +{ + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if ((cred->po->openmodes & O_READ) == 0) + return EBADF; + *amt = qsize (inputq); + mutex_unlock (&global_lock); + + return 0; +} + +/* TIOCMODG ioctl -- Get modem state */ +kern_return_t +S_tioctl_tiocmodg (io_t port, + int *state) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, + port, tty_class); + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + *state = mdmstate (); + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return 0; +} + +/* TIOCMODS ioctl -- Set modem state */ +kern_return_t +S_tioctl_tiocmods (io_t port, + int state) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + mdmctl (MDMCTL_SET, state); + err = 0; + } + + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + +/* TIOCEXCL ioctl -- Set exclusive use */ +kern_return_t +S_tioctl_tiocexcl (io_t port) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + termflags |= EXCL_USE; + err = 0; + } + + mutex_unlock (&global_lock); + ports_port_deref (cred); + return err; +} + +/* TIOCNXCL ioctl -- Clear exclusive use */ +kern_return_t +S_tioctl_tiocnxcl (io_t port) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, + port, tty_class); + error_t err; + + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + termflags &= ~EXCL_USE; + err = 0; + } + + mutex_unlock (&global_lock); + ports_port_deref (cred); + return err; +} + +/* TIOCFLUSH ioctl -- Flush input, output, or both */ +kern_return_t +S_tioctl_tiocflush (io_t port, + int flags) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + if (flags == 0) + flags = O_READ|O_WRITE; + + if (flags & O_READ) + clear_queue (inputq); + + if (flags & O_WRITE) + drop_output (); + + err = 0; + } + + mutex_unlock (&global_lock); + ports_port_deref (cred); + return err; +} + +/* TIOCGETA ioctl -- Get termios state */ +kern_return_t +S_tioctl_tiocgeta (io_t port, + tcflag_t *modes, + cc_t *ccs, + speed_t *speeds) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + modes[0] = termstate.c_iflag; + modes[1] = termstate.c_oflag; + modes[2] = termstate.c_cflag; + modes[3] = termstate.c_lflag; + bcopy (termstate.c_cc, ccs, NCCS); + speeds[0] = termstate.__ispeed; + speeds[1] = termstate.__ospeed; + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return 0; +} + +/* Common code for the varios TIOCSET* commands. */ +static error_t +set_state (io_t port, + tcflag_t *modes, + cc_t *ccs, + speed_t *speeds, + int draino, + int flushi) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + int oldlflag; + + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else if (!fg_p (cred)) + err = EBACKGROUND; + else + { + if (draino) + { + err = drain_output (); + if (err) + { + mutex_unlock (&global_lock); + ports_port_deref (cred); + return err; + } + } + + if (flushi) + clear_queue (inputq); + + oldlflag = termstate.c_lflag; + termstate.c_iflag = modes[0]; + termstate.c_oflag = modes[1]; + termstate.c_cflag = modes[2]; + termstate.c_lflag = modes[3]; + bcopy (ccs, termstate.c_cc, NCCS); + termstate.__ispeed = speeds[0]; + termstate.__ospeed = speeds[1]; + if (!(termstate.c_cflag & CIGNORE)) + set_bits (); + if (oldlflag & ICANON) + { + if (!(termstate.c_lflag & ICANON)) + copy_rawq (); + } + else + { + if (termstate.c_lflag & ICANON) + rescan_inputq (); + } + err = 0; + } + + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + + + +/* TIOCSETA -- Set termios state */ +kern_return_t +S_tioctl_tiocseta (io_t port, + tcflag_t *modes, + cc_t *ccs, + speed_t *speeds) +{ + return set_state (port, modes, ccs, speeds, 0, 0); +} + +/* Drain output, then set term state. */ +kern_return_t +S_tioctl_tiocsetaw (io_t port, + tcflag_t *modes, + cc_t *ccs, + speed_t *speeds) +{ + return set_state (port, modes, ccs, speeds, 1, 0); +} + +/* Flush input, drain output, then set term state. */ +kern_return_t +S_tioctl_tiocsetaf (io_t port, + tcflag_t *modes, + cc_t *ccs, + speed_t *speeds) + +{ + return set_state (port, modes, ccs, speeds, 1, 1); +} + +/* TIOCGETD -- Return line discipline */ +kern_return_t +S_tioctl_tiocgetd (io_t port, + int *disc) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + if (!cred) + return EOPNOTSUPP; + + *disc = 0; + + ports_port_deref (cred); + return 0; +} + +/* TIOCSETD -- Set line discipline */ +kern_return_t +S_tioctl_tiocsetd (io_t port, + int disc) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, + port, tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + mutex_unlock (&global_lock); + + if (disc != 0) + err = ENXIO; + else + err = 0; + + ports_port_deref (cred); + return 0; +} + +/* TIOCDRAIN -- Wait for output to drain */ +kern_return_t +S_tioctl_tiocdrain (io_t port) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, + port, tty_class); + error_t err; + + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if (!(cred->po->openmodes & O_WRITE)) + { + mutex_unlock (&global_lock); + return EBADF; + } + + err = drain_output (); + mutex_unlock (&global_lock); + return err; +} + +/* TIOCSIG -- PTY master generate signal */ +kern_return_t +S_tioctl_tiocsig (io_t port) +{ + return EOPNOTSUPP; +} + +/* TIOCEXT -- PTY master enter external mode */ +kern_return_t +S_tioctl_tiocext (io_t port) +{ + return EOPNOTSUPP; +} + +/* TIOCUCNTL -- PTY set/clear usr cntl mode */ +kern_return_t +S_tioctl_tiocucntl (io_t port, + int how) +{ + return EOPNOTSUPP; +} + +/* TIOCSWINSZ -- Set window size */ +kern_return_t +S_tioctl_tiocswinsz (io_t port, + struct winsize size) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + err = 0; + + ports_port_deref (cred); + + if (!err && (size.ws_row - window_size.ws_row + + size.ws_col - window_size.ws_col + + size.ws_xpixel - window_size.ws_xpixel + + size.ws_ypixel - window_size.ws_ypixel) != 0) + { + /* The size is actually changing. Record the new size and notify the + process group. */ + window_size = size; + send_signal (SIGWINCH); + } + + mutex_unlock (&global_lock); + + return err; +} + +/* TIOCGWINSZ -- Fetch window size */ +kern_return_t +S_tioctl_tiocgwinsz (io_t port, + struct winsize *size) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + *size = window_size; + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return 0; +} + +/* TIOCREMOTE -- PTY enter remote mode */ +kern_return_t +S_tioctl_tiocremote (io_t port, + int how) +{ + return EOPNOTSUPP; +} + +/* TIOCMGET -- Fetch all modem bits */ +kern_return_t +S_tioctl_tiocmget (io_t port, + int *bits) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + *bits = mdmstate (); + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return 0; +} + +/* TIOCMSET -- Set all modem bits */ +kern_return_t +S_tioctl_tiocmset (io_t port, + int bits) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + mdmctl (MDMCTL_SET, bits); + err = 0; + } + + mutex_unlock (&global_lock); + ports_port_deref (cred); + return err; +} + +/* TIOCMBIC -- Clear some modem bits */ +kern_return_t +S_tioctl_tiocmbic (io_t port, + int bits) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + mdmctl (MDMCTL_BIC, bits); + err = 0; + } + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + +/* TIOCMBIS -- Set some modem bits */ +kern_return_t +S_tioctl_tiocmbis (io_t port, + int bits) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + mutex_lock (&global_lock); + + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + mdmctl (MDMCTL_BIS, bits); + err = 0; + } + mutex_unlock (&global_lock); + ports_port_deref (cred); + return err; +} + +/* TIOCSTART -- start output as if VSTART were typed */ +kern_return_t +S_tioctl_tiocstart (io_t port) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + termflags &= ~USER_OUTPUT_SUSP; + err = 0; + } + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + +/* TIOCSTOP -- stop output as if VSTOP were typed */ +kern_return_t +S_tioctl_tiocstop (io_t port) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, + port, tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + termflags |= USER_OUTPUT_SUSP; + err = 0; + } + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + +/* TIOCPKT -- PTY Master packet mode */ +kern_return_t +S_tioctl_tiocpkt (io_t port, + int how) +{ + return EOPNOTSUPP; +} + +/* TIOCSTI -- Simulate terminal input */ +kern_return_t +S_tioctl_tiocsti (io_t port, + char c) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, + port, tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + /* BSD returns EACCES if this is not our controlling terminal, + but we have no way to do that. (And I don't think it actually + provides any security there, either.) */ + + if (!(cred->po->openmodes & O_READ)) + err = EPERM; + else + { + input_character (c); + err = 0; + } + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + +/* TIOCOUTQ -- return output queue size */ +kern_return_t +S_tioctl_tiocoutq (io_t port, + int *queue_size) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + *queue_size = qsize (outputq) + pending_output_size (); + err = 0; + } + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + +/* TIOCSPGRP -- set pgrp of terminal */ +kern_return_t +S_tioctl_tiocspgrp (io_t port, + int pgrp) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + termflags &= ~NO_OWNER; + foreground_id = -pgrp; + err = 0; + } + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + +/* TIOCGPGRP --- fetch pgrp of terminal */ +kern_return_t +S_tioctl_tiocgpgrp (io_t port, + int *pgrp) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t ret; + + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if (termflags & NO_OWNER) + ret = ENOTTY; /* that's what BSD says... */ + else + { + *pgrp = - foreground_id; + ret = 0; + } + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return ret; +} + +/* TIOCCDTR -- clear DTR */ +kern_return_t +S_tioctl_tioccdtr (io_t port) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + mdmctl (MDMCTL_BIC, TIOCM_DTR); + err = 0; + } + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + +/* TIOCSDTR -- set DTR */ +kern_return_t +S_tioctl_tiocsdtr (io_t port) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + mdmctl (MDMCTL_BIS, TIOCM_DTR); + err = 0; + } + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + +/* TIOCCBRK -- Clear break condition */ +kern_return_t +S_tioctl_tioccbrk (io_t port) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + clear_break (); + err = 0; + } + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + +/* TIOCSBRK -- Set break condition */ +kern_return_t +S_tioctl_tiocsbrk (io_t port) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, + port, tty_class); + error_t err; + if (!cred) + return EOPNOTSUPP; + + mutex_lock (&global_lock); + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + err = EBADF; + else + { + set_break (); + err = 0; + } + mutex_unlock (&global_lock); + + ports_port_deref (cred); + return err; +} + +error_t +trivfs_S_file_truncate (struct trivfs_protid *cred, + off_t size) +{ + if (!cred) + return EOPNOTSUPP; + mutex_lock (&global_lock); + if ((cred->po->openmodes & O_WRITE) == 0) + { + mutex_unlock (&global_lock); + return EBADF; + } + mutex_unlock (&global_lock); + return 0; +} + +error_t +trivfs_S_io_seek (struct trivfs_protid *cred, + off_t off, + int whence, + off_t *newp) +{ + return ESPIPE; +} + +error_t +trivfs_S_io_get_openmodes (struct trivfs_protid *cred, + mach_port_t reply, + mach_msg_type_name_t replytype, + int *bits) +{ + if (!cred) + return EOPNOTSUPP; + mutex_lock (&global_lock); + *bits = cred->po->openmodes; + mutex_unlock (&global_lock); + return 0; +} + +#define HONORED_STATE_MODES (O_APPEND|O_ASYNC|O_FSYNC|O_NONBLOCK|O_NOATIME) + +error_t +trivfs_S_io_set_all_openmodes (struct trivfs_protid *cred, + mach_port_t reply, + mach_msg_type_name_t replytype, + int bits) +{ + + if (!cred) + return EOPNOTSUPP; + mutex_lock (&global_lock); + cred->po->openmodes &= ~HONORED_STATE_MODES; + cred->po->openmodes |= (bits & HONORED_STATE_MODES); + mutex_unlock (&global_lock); + return 0; +} + +error_t +trivfs_S_io_set_some_openmodes (struct trivfs_protid *cred, + mach_port_t reply, + mach_msg_type_name_t reply_type, + int bits) +{ + if (!cred) + return EOPNOTSUPP; + mutex_lock (&global_lock); + cred->po->openmodes |= (bits & HONORED_STATE_MODES); + mutex_unlock (&global_lock); + return 0; +} + +error_t +trivfs_S_io_clear_some_openmodes (struct trivfs_protid *cred, + mach_port_t reply, + mach_msg_type_name_t reply_type, + int bits) +{ + if (!cred) + return EOPNOTSUPP; + mutex_lock (&global_lock); + cred->po->openmodes &= ~(bits & HONORED_STATE_MODES); + mutex_unlock (&global_lock); + return 0; +} + +error_t +trivfs_S_io_mod_owner (struct trivfs_protid *cred, + mach_port_t reply, + mach_msg_type_name_t reply_type, + pid_t owner) +{ + if (!cred) + return EOPNOTSUPP; + mutex_lock (&global_lock); + termflags &= ~NO_OWNER; + foreground_id = owner; + mutex_unlock (&global_lock); + return 0; +} + +error_t +trivfs_S_io_get_owner (struct trivfs_protid *cred, + mach_port_t erply, + mach_msg_type_name_t reply_type, + pid_t *owner) +{ + if (!cred) + return EOPNOTSUPP; + mutex_lock (&global_lock); + if (termflags & NO_OWNER) + { + mutex_unlock (&global_lock); + return ENOTTY; + } + *owner = foreground_id; + mutex_unlock (&global_lock); + return 0; +} + +error_t +trivfs_S_io_get_async_icky (struct trivfs_protid *cred, + mach_port_t *id, + mach_msg_type_name_t *idtype) +{ + if (!cred) + return EOPNOTSUPP; + mutex_lock (&global_lock); + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + { + mutex_unlock (&global_lock); + return EBADF; + } + *id = async_icky_id; + *idtype = MACH_MSG_TYPE_MAKE_SEND; + mutex_unlock (&global_lock); + return 0; +} + +error_t +trivfs_S_io_async (struct trivfs_protid *cred, + mach_port_t notify, + mach_port_t *id, + mach_msg_type_name_t *idtype) +{ + struct async_req *ar; + if (!cred) + return EOPNOTSUPP; + mutex_lock (&global_lock); + if (!(cred->po->openmodes & (O_READ|O_WRITE))) + { + mutex_unlock (&global_lock); + return EBADF; + } + ar = malloc (sizeof (struct async_req)); + ar->notify = notify; + ar->next = async_requests; + async_requests = ar; + *id = async_id; + *idtype = MACH_MSG_TYPE_MAKE_SEND; + mutex_unlock (&global_lock); + return 0; +} + +error_t +trivfs_S_io_select (struct trivfs_protid *cred, + mach_port_t reply, + mach_msg_type_name_t reply_type, + int *type, + int *idtag) +{ + int available; + + if (!cred) + return EOPNOTSUPP; + + /* We don't deal with SELECT_URG here. */ + if (*type & ~(SELECT_READ | SELECT_WRITE)) + return EINVAL; + + available = 0; + if (*type == 0) + return 0; + + mutex_lock (&global_lock); + + while (1) + { + if ((*type & SELECT_READ) && qsize (inputq)) + available |= SELECT_READ; + if ((*type & SELECT_WRITE) && qavail (outputq)) + available |= SELECT_WRITE; + + if (available) + { + *type = available; + mutex_unlock (&global_lock); + return 0; + } + + hurd_condition_wait (&select_alert, &global_lock); + } +} + +kern_return_t +trivfs_S_io_map (struct trivfs_protid *cred, + mach_port_t *rdobj, + mach_msg_type_name_t *rdtype, + mach_port_t *wrobj, + mach_msg_type_name_t *wrtype) +{ + return EOPNOTSUPP; +} + +/* Call all the scheduled async I/O handlers */ +static void +call_asyncs () +{ + struct async_req *ar, *nxt, **prevp; + mach_port_t err; + + /* If no I/O is possible or nobody wants async + messages, don't bother further. */ + if ((!(termflags & ICKY_ASYNC) && !async_requests) + || (!qsize (inputq) && !qavail (outputq))) + return; + + if ((termflags & ICKY_ASYNC) && !(termflags & NO_OWNER)) + hurd_sig_post (foreground_id, SIGIO, async_icky_id); + + for (ar = async_requests, prevp = &async_requests; + ar; + ar = nxt) + { + nxt = ar->next; + err = nowait_msg_sig_post (ar->notify, SIGIO, async_id); + if (err == MACH_SEND_INVALID_DEST) + { + /* Receiver died; remove the notification request. */ + *prevp = ar->next; + mach_port_deallocate (mach_task_self (), ar->notify); + free (ar); + } + else + prevp = &ar->next; + } +} + +/* Send a signal to the current process (group) of the terminal. */ +void +send_signal (int signo) +{ + mach_port_t right; + + if (!(termflags & NO_OWNER)) + { + right = ports_get_right (cttyid); + mach_port_insert_right (mach_task_self (), right, right, + MACH_MSG_TYPE_MAKE_SEND); + hurd_sig_post (foreground_id, signo, right); + mach_port_deallocate (mach_task_self (), right); + } +} + +error_t +trivfs_S_interrupt_operation (mach_port_t port) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, port, + tty_class); + if (!cred) + return EOPNOTSUPP; + + ports_interrupt_rpc (cred); + + ports_port_deref (cred); + return 0; +} + +void +report_carrier_off () +{ + termflags |= NO_CARRIER; + if (!(termstate.c_cflag & CLOCAL)) + send_signal (SIGHUP); +} + +void +report_carrier_on () +{ + termflags &= ~NO_CARRIER; + condition_broadcast (&carrier_alert); +} + +kern_return_t +S_term_get_nodename (io_t arg, + char *name) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, arg, + tty_class); + if (!cred) + return EOPNOTSUPP; + + strcpy (name, nodename); + + ports_port_deref (cred); + return 0; +} + +kern_return_t +S_term_set_nodename (io_t arg, + char *name) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, arg, + tty_class); + if (!cred) + return EOPNOTSUPP; + ports_port_deref (cred); + + if (strcmp (name, nodename)) + return EINVAL; + + return 0; +} + +kern_return_t +S_term_set_filenode (io_t arg, + file_t filenode) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, arg, + tty_class); + if (!cred) + return EOPNOTSUPP; + ports_port_deref (cred); + + return EINVAL; +} + +kern_return_t +S_term_get_bottom_type (io_t arg, + int *ttype) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, + arg, tty_class); + if (!cred) + return EOPNOTSUPP; + + ports_port_deref (cred); + *ttype = TERM_ON_MACHDEV; + return 0; +} + +kern_return_t +S_term_on_machdev (io_t arg, + device_t machdev) +{ + struct trivfs_protid *cred = ports_lookup_port (term_bucket, arg, + tty_class); + if (!cred) + return EOPNOTSUPP; + ports_port_deref (cred); + return EINVAL; +} + +kern_return_t +S_term_on_hurddev (io_t arg, + io_t hurddev) +{ + return EOPNOTSUPP; +} + +kern_return_t +S_term_on_pty (io_t arg, + mach_port_t *master) +{ + return EOPNOTSUPP; +} + +error_t +trivfs_goaway (struct trivfs_control *cntl, int flags) +{ + return EBUSY; +} |