From: exudnw@exu.ericsson.se (Dave Williams)
Newsgroups: comp.sys.sun.admin
Subject: Re: Disabling L1-A????
Date: 26 Feb 92 01:04:42 GMT
Reply-To: exudnw@exu.ericsson.se
Organization: Ericsson Network Systems

In article 185@romana.Tymnet.COM, jms@romana.Tymnet.COM (Joe Smith) writes:
>In article <1992Feb21.133709.17922@cs.wright.edu> shollen@valhalla.cs.wright.edu (Sheila Hollenbaugh) writes:
>>We are having a problem with students using L1-A every time they think
>>a workstation is not functioning properly.
>
>One way of discouraging the use of L1-A is to change /etc/rc to say:
>
>if [ -r /fastboot ]; then
>	rm -f /fastboot
>else
>	echo This workstation was not shutdown properly.
>	echo It will take a while to repair the damage.
>	echo Please wait ...
>	sleep 300		# Force them to wait 5 minutes
>fi
>

This from the dusty archives...

()()()()()()()()()()()()()() begin included article ()()()()()()()()()()()()()()()(

Article 21 of erinet.mailing-list.sun.managers:
Newsgroups: erinet.mailing-list.sun.managers
From: Meg Grice <mlg@vax2.cstp.umkc.edu>
Subject: SUMMARY: User's using L1-A
Date: Wed, 10 Jul 1991 15:33:07 GMT


Sun Managers,

Thanks for all the help.  The original question:

>>I have a user that thinks any problem with the computer should be fixed
>>with L1-A reboot.  I think L1-A should be used only as the next to
>>the last resort.  Is doing L1-A often bad for the computers?  I have
>>a Sparcstation 1, Sparcstation 1+, Sparcstation 2, and an SLC.  

I received over 70 responses, so I will not list the names individually.  
Thanks alot!


Summary
-------
I got a brief explanation of UNIX files system.

>The Unix kernel buffers all file system activity, keeping track of all 
>modifications in internal buffers, and then schedules
>a time to make the physical changes on the disk when it's conveinient
>for the OS.  So unless the system is brought down normally by having
>a sync(1) done, the info stored on disk may or may not accurately reflect
>the state of the world.  A program called /etc/update which is started from
>/etc/rc, sync's all file systems every 30 seconds to try to maintain
>their integrity upon crashes.

Almost everyone said that L1-A will not damage the hardware, but can
damage any local file systems.  So if a computer has a local disk that
is used for more than swapping it can be dangerous.  Several people
included horror stories about having to re-install the OS from tape.
Also, many attributed the "L1-A will fix everything" attitude to the
PC mentality.  

Methods of dealing with the user included:
------------------------------------------
1)  When (not if) his/her system gets screwed take quite a while to fix it.
2)  Explain to the user that the problem should be identified and fixed
    permenantly.
3)  Explain to the user that other people may be logged in or running 
    background jobs.
4)  Explain to the user the difference between an orderly shutdown and L1-A.
5)  Change the permissions on shutdown so that any user can run it.
    (This is not practical in my environment.)
6)  Explain to management about time lost in fixing problems caused by
    overuse of L1-A.
7)  You can't stop the user from doing an L1-A, so learn to live with it.
8)  Direct complaints from remote users to the culprit.
9)  Fix L1-A so that the root password is required for it to work.
    (I don't know how to do this.)
10) Take the machine away from the user and give him/her an X-terminal.
11) Provide a captive account that runs fastboot.
12) A ROM change is available from Sun to disable L1-A.
13) Turn on the password in the eeprom and set the security so that 
    an L1-A only gets the user to the point s/he can either
    continue or type a password to get to the other commands.
    (I'm not sure the older models have this feature).
14) Shoot the user.
15) Remind the user that the computer is not a PC, but a mini-computer or
    mainframe.
16) Disable L1-A.  (A C program is included at the end.  I haven't tested it.)
17) Disable the break key on server consoles.  (An adb script is included
    at the end.  I have not tested it.)
18) Take the workstation away from the user and give him/her a PC.
19) Require users that use L1-A to fill out detailed forms explaining why
    L1-A was necessary.


I received some information and advise to keep in mind.
1)  Sync the disk before using L1-A (sync; sync;).
2)  After L1-A, do a sync (newer systems) or g0 (older systems) to sync
    the disks.
3)  Make the console secure so that users cannot boot up single user.
4)  Solbourne's allow you to turn off the L1-A abort key.
5)  Someone said that the L1-A key should not be turned off.

********************** C Program to disable L1-A ************************
>From tres@roke.rap.ucar.EDU Tue Jul  2 16:35:10 1991
Meg,

	It's certainly not advisable, but probably not too big a deal in most
cases if the user syncs the disks from the PROM before rebooting (in the old
PROM, typing 'g0' [that's a zero] forces a panic and syncs the disks, in the
newer OpenProm, just type 'sync').  But I wouldn't be too happy about a user
rebooting machines on a whim.

	Here's a small C program I got somewhere which allows you to disable
the L1-A abort sequence.  Works for me.  Good Luck.

-- 
Tres Hofmeister
tres@ncar.ucar.edu

/*
 * abort_key - enable or disable L1-A abort sequence.
 * Usage: abort_key y|n
 */

#include <sys/types.h>
#include <sys/ioctl.h>
#include <sundev/kbd.h>
#include <sundev/kbio.h>

main(argc,argv)
int argc;
char *argv[];
{
	struct kiockey key;
	int fd;
	int mode;
	char *c;

	if (argc != 2) {
		printf("\nUsage: abort_key y|n\n\n");
		exit(1);
	}

	switch (*(c= argv[1])) {
		case 'y':
			mode = 1;
			break;
		case 'n':
			mode = 0;
			break;
		default:
			printf("\nInvalid Argument\n");
			printf("Usage: abort_key y|n \n\n");
			exit(1);
	}

	fd = open("/dev/kbd", 1);
	if (fd < 0) {
		perror("OPEN");
		exit(1);
	}

	key.kio_tablemask = KIOCABORT1;

	ioctl( fd, KIOCGETKEY, &key);	/* read abort key entry */

	if (key.kio_station == 0)
		printf("L1-A reset sequence was disabled\n");
	else if (key.kio_station == 1)
		printf("L1-A reset sequence was enabled\n");

	if (mode == 1)
		key.kio_station = 1;
	else
		key.kio_station = 0;

	ioctl(fd, KIOCSETKEY, &key);	/* map it to a 'hole' in map */

	if (key.kio_station == 0)
		printf("L1-A reset sequence now disabled\n");
	else if (key.kio_station == 1)
		printf("L1-A reset sequence now enabled\n");
}
******************** End C Program ************************

********  adb script to disable break key on servers  *****
From:  Mark Nichols	internet: mnichols@pacesetter.com

We use the following adb script to disable breaks on our server
consoles.  Users get kind of nasty when you inadvertently hit the
break key while trying to hit the setup key. This might provide an
additional level of security when augmented with setting all the
entries in /etc/ttytab to unsecure on the clients as other people have
suggested. We have this patch installed on all of our Sun 3 and Sun 4
systems running Sun OS 4.0.3. We don't have any 4.1.1 machines yet so
I can't tell you if it will still work under 4.1.1.



----- Cut here ----
#! /bin/sh
# Patch to disable the BREAK key and L1-A in one fell swoop
adb -w -k /vmunix /dev/mem << EOF
montrap?w0x4e75
montrap/w0x4e75
EOF
***********************************************************

Meg Grice 
Unix Sys Admin, UMKC 
mlg@cssparc1.cstp.umkc.edu 
(816) 235-5212


)()()()()()()()()()()()()()()()( end included article )()()()()()()()()()()()()()()()(
---
= exudnw@exu.ericsson.se                                  (214)907-7928 =
= David Williams    "UNIX is an incantation oriented operating system"  =
= Ericsson Network Systems                                   --Me       =
= Richardson, TX 75081                        These opinions are my own.=



From fifi@hiss.han.de (Axel Zinser)
Newsgroups: comp.sys.sun.admin
Subject: Summary: How to disable 'L1 A'
Date: 15 May 92 14:54:27 GMT

Hi,

I've got several requests to forward the answers I got after posting
above question, so it seems to be the best to post a summary. It's
not really a summary but a meta-summary because it mainly consists
of a summary Kert Jans sent me made up by another solution from Claus
Assman. Like Kert Jans I've not tested all answers, but I assume
they all work fine. I first got 'btp' and installed it sucessfully
(Sun-OS 4.1.2/C2), Kert uses 'setabort' and it also works ok.

Thanks for all answers!

Axel
-------------------
>From erickson@laguna.ICS.UCI.EDU Fri Feb 21 17:51:55 1992
Received: from laguna.ics.uci.edu by Paris.ics.uci.edu id aa25171;
          21 Feb 92 13:50 PST
To: shollen@valhalla
Subject: Re: Disabling L1-A????
Newsgroups: comp.sys.sun.admin
Date: Fri, 21 Feb 92 13:50:32 -0800
>From: Scott Erickson <erickson@laguna.ICS.UCI.EDU>
Message-Id:  <9202211350.aa25171@Paris.ics.uci.edu>
Status: R

In comp.sys.sun.admin you write:

>We are having a problem with students using L1-A every time they think
>a workstation is not functioning properly.  I know this has probably
>been answered before, but I would like to disable L1-A or at least remap
>the interrupt sequence to something people do not know well.  If anyone
>out there has a summary of previous coverage or has done this, please
>email me.  If a summary is desired, I will be glad to provide one.

Here's a package we use on our Lab 3/50's.  The package consists of
setabort and abortkey.  The command we use in our rc.local file is:

	if [ -f /usr/local/etc/setabort ] ; then
		/usr/local/etc/setabort 1 81
	fi

This sets the abort sequence to L1-g.  The abortkey program turns on
and off the sequence, I belive.  We set the abort to L1-g so that we
in the support group could still abort.

/se
University of California Irvine             | 714/856-4035
Information and Computer Science Department | erickson@ics.uci.edu
Support Group                               | ucbvax!ucivax!erickson

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of shell archive."
# Contents:  Makefile abortkey.c setabort.c
# Wrapped by erickson@laguna.ics.uci.edu on Fri Feb 21 13:31:59 1992
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'Makefile' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Makefile'\"
else
echo shar: Extracting \"'Makefile'\" \(1904 characters\)
sed "s/^X//" >'Makefile' <<'END_OF_FILE'
X#############################################################################
X#
X#  Makefile for setabort
X#
X#  $Id: Makefile,v 1.3 1989/10/20 10:48:21 sources Exp $
X#############################################################################
X#
X#  If you move this makefile, update the variable below
X#  or else depend won't work.
X#############################################################################
XMAKEFILE	= Makefile
XRCSDIR		= ./RCS
XCC		= cc
XCFILES		=  setabort.c abortkey.c
XOFILES		=  setabort.o abortkey.o
XMANFILE		=  
XPROGRAM		= setabort
XPROGRAM2	= abortkey
X#############################################################################
X# Flags for Installation
X#############################################################################
XBINDIR		=  /usr/local/etc
XMANDIR		=  
XCURSUFFIX	= 
XMANSUFFIX	=  
X#############################################################################
X
XLIBS		= 
XDFLAGS		= 
XOPTFLAGS	=  -O
XLDFLAGS		=  -s
XCFLAGS		= $(OPTFLAGS) $(DFLAGS) 
XLINTFLAGS	=  -bchxz
X
Xall:	$(PROGRAM) $(PROGRAM2)
X
X$(PROGRAM):
X	$(CC) $(CFLAGS) $(LDFLAGS) $@.c -o $@ $(LIBS)
X
X$(PROGRAM2):
X	$(CC) $(CFLAGS) $(LDFLAGS) $@.c -o $@ $(LIBS)
X
Xlint:	
X	lint $(LINTFLAGS) $(CFILES)
X
Xinstall: $(PROGRAM) $(PROGRAM2)
X	install -o root -g staff -c -m 710 $(PROGRAM) $(BINDIR)
X	install -o root -g staff -c -m 710 $(PROGRAM2) $(BINDIR)
X
Xinst-man:	$(MANFILE)
X	install -c -m 644 $(MANFILE) $(MANDIR)/`basename $(MANFILE) $(CURSUFFIX)`$(MANSUFFIX)
X
Xinst-all: install inst-man
X
XTAGS: $(CFILES)
X	etags $(CFILES) > TAGS
X
Xtags: $(CFILES)
X	ctags $(CFILES) > tags
X
Xcheckin:
X	-@for i in $(CFILES) $(MANFILE) ; do \
X	    ( if test -f $$i ; then ( echo "Checking in $$i" ; ci -q $$i ) \
X	; fi ) ; done
X
Xcheckout: $(CFILES) $(MANFILE)
X
X$(CFILES) $(MANFILE):
X	co -q $@
X
Xclean:
X	rm -f *.o *.out *~ core $(PROGRAM) $(PROGRAM2)
X
Xclean-all: clean checkin
X	rm -f tags TAGS
X
Xdepend:
X	/usr/ucb/mkdep -f $(MAKEFILE) $(CFILES)
X
END_OF_FILE
if test 1904 -ne `wc -c <'Makefile'`; then
    echo shar: \"'Makefile'\" unpacked with wrong size!
fi
# end of 'Makefile'
fi
if test -f 'abortkey.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'abortkey.c'\"
else
echo shar: Extracting \"'abortkey.c'\" \(1411 characters\)
sed "s/^X//" >'abortkey.c' <<'END_OF_FILE'
X/* $Id: abortkey.c,v 1.2 1989/10/20 10:47:21 sources Exp $
X */
X
X#include <sys/types.h>
X#include <sys/ioctl.h>
X#include <sundev/kbd.h>
X#include <sundev/kbio.h>
X
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X    struct kiockey key;
X    int fd;
X    int mode = -1,
X    verb = 0;
X    char **av;
X    
X    for (av = &argv[1]; *av ; av++ ){
X	switch (av[0][0]) {
X	case 'y':
X	    mode = 1;
X	    break;
X	case 'n':
X	    mode = 0;
X	    break;
X	case '-':
X	    if (av[0][1] == 'v') {
X		verb = 1;
X		break;
X	    }
X	default:
X	    printf("unknown flag: %s\n",av[0]);
X	    printf("usage: %s [-v] y|n\n",argv[0]);
X	exit(1);
X	}
X    }
X    fd = open("/dev/kbd", 1);
X    if (fd < 0) {
X	perror("/dev/kbd");
X	exit(1);
X    }
X    key.kio_tablemask = KIOCABORT1;
X    
X    ioctl( fd, KIOCGETKEY, &key);   /* read abort key entry */
X    
X    if (key.kio_station == 0 && (verb  || mode == -1))
X	printf("L1-A reset sequence was disabled\n");
X    else if (key.kio_station == 1 && (verb || mode == -1))
X	printf("L1-A reset sequence was enabled\n");
X    
X    
X    switch (mode) {
X    case 1:
X	key.kio_station = 1;
X	break;
X    case 0:
X	key.kio_station = 0;
X	break;
X    default:
X	exit(0);
X    }
X    
X    ioctl(fd, KIOCSETKEY, &key);    /* map it t a 'hole' in map */
X    
X    if (key.kio_station == 0 && verb) 
X	printf("L1-A reset sequence now disabled\n"); 
X    else if (key.kio_station == 1 && verb) 
X	printf("L1-A reset sequence now enabled\n"); 
X}
END_OF_FILE
if test 1411 -ne `wc -c <'abortkey.c'`; then
    echo shar: \"'abortkey.c'\" unpacked with wrong size!
fi
# end of 'abortkey.c'
fi
if test -f 'setabort.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'setabort.c'\"
else
echo shar: Extracting \"'setabort.c'\" \(2856 characters\)
sed "s/^X//" >'setabort.c' <<'END_OF_FILE'
X/* $Id: setabort.c,v 1.2 1989/10/20 10:47:42 sources Exp $
X */
X#include <stdio.h>
X#include <sys/types.h>
X#include <sundev/kbio.h>
X#include <sundev/kbd.h>
X
Xstruct kiockey kiockey;
X
Xmain(argc, argv)
Xregister argc;
Xregister char *argv[];
X
X{
X    register fd, key1, key2;
X    int mode; /* 0: set to L1-A, 1: set to key1 key2, 2: disable */
X    int was_set = 0,
X        verb = 0;
X    char *prog;
X    
X    prog = argv[0];
X    if (strcmp(argv[1],"-v") == 0) {
X	verb = 1;
X	argc--;
X	argv++;
X    }
X    
X    if (argc > 3  || argc < 2) {
X	printf("usage: %s [-v] touche1 touche2\n",prog);
X	printf("   or: %s [-v] std | off\n",prog);     
X	exit(1);
X    }
X    
X    if ((fd = open("/dev/kbd", 2)) < 0) {
X	perror("/dev/kbd");
X	exit(1);
X    }
X    if (argc == 3) {
X	key1 = atoi(argv[1]);
X	key2 = atoi(argv[2]);
X	mode = 1;
X	if (key1 < 0 || key1 > 127 || key2 < 0 || key2 > 127) {
X	    printf("%s: INVALID KEY: key stations must be in range 0-127\n",prog);
X	    close(fd);
X	    exit(1);
X	}
X    } else if ( strcmp("std", argv[1]) == 0)  
X	mode = 0;
X    else if (strcmp("off", argv[1]) == 0)
X	mode = 2;
X    else {
X	printf("usage: %s [-v] touche1 touche2\n",prog);
X	printf("   or: %s [-v] std | off\n",prog);     
X	exit(1);
X    }
X    
X    
X    kiockey.kio_tablemask = KIOCABORT1;
X    
X    ioctl( fd, KIOCGETKEY, &kiockey);   /* read abort key entry */
X    
X    if (kiockey.kio_station == 0) {
X	if (verb)
X	    printf("Abort sequence was disabled\n");
X    }
X    else  {
X	was_set = 1;
X	if (verb)
X	    printf("Abort sequence was enabled and set to %d",
X		   kiockey.kio_station);
X    }
X    
X    switch (mode) {
X    case 0:
X	kiockey.kio_station = 0x01;
X	break;
X    case 1:
X	kiockey.kio_station = key1;
X	break;
X    case 2:
X	kiockey.kio_station = 0x00;
X	break;
X	
X    }
X    if (ioctl(fd, KIOCSETKEY, &kiockey) < 0) {
X	perror("kbd: KIOCSETKEY: KIOCABORT1:");
X	close(fd);
X	exit(1);
X    }
X    
X    kiockey.kio_tablemask = KIOCABORT2;
X    
X    if (was_set == 1) {
X	ioctl( fd, KIOCGETKEY, &kiockey);   /* read abort key entry */
X	if (verb)
X	    printf(" %d\n", kiockey.kio_station);
X    }
X    
X    switch (mode) {
X    case 0:
X	kiockey.kio_station = 0x4d;
X	break;
X    case 1:
X	kiockey.kio_station = key2;
X	break;
X    case 2:
X	kiockey.kio_station = 0x00;
X	break;
X	
X    }
X    if (ioctl(fd, KIOCSETKEY, &kiockey) < 0) {
X	perror("kbd: KIOCSETKEY: KIOCABORT2:");
X	close(fd);
X	exit(1);
X    }
X    
X    
X    kiockey.kio_tablemask = KIOCABORT1;
X    ioctl( fd, KIOCGETKEY, &kiockey);   /* read abort key entry */
X    
X    if (kiockey.kio_station == 0) {
X	if (verb)
X	    printf("Abort sequence disabled\n");
X    }
X    else {
X	if (verb)
X	    printf("Abort sequence enabled and set to %d",
X		   kiockey.kio_station);
X	kiockey.kio_tablemask = KIOCABORT2;
X	ioctl( fd, KIOCGETKEY, &kiockey);   /* read abort key entry */
X	if (verb)
X	    printf(" %d\n", kiockey.kio_station);
X    }
X    close(fd);
X    exit(0);
X}
END_OF_FILE
if test 2856 -ne `wc -c <'setabort.c'`; then
    echo shar: \"'setabort.c'\" unpacked with wrong size!
fi
# end of 'setabort.c'
fi
echo shar: End of shell archive.
exit 0

>From richard@borneo Mon Feb 24 08:25:36 1992
Received: from borneo.gmd.de (borneo) by gmdzi.gmd.de with SMTP id AA04027
  (5.65c/IDA-1.4.4 for <shollen@valhalla.cs.wright.edu>); Mon, 24 Feb 1992 14:25:11 +0100
Received: by borneo.gmd.de id AA04629; Mon, 24 Feb 92 14:25:21 +0100
Date: Mon, 24 Feb 92 14:25:21 +0100
>From: richard@borneo (Richard Czech)
Message-Id: <9202241325.AA04629@borneo.gmd.de>
Received: by hawaii.gmd.de id AA06095; Mon, 24 Feb 92 14:25:22 +0100
To: shollen@valhalla (Sheila Hollenbaugh)
Reply-To: czech@gmdzi.gmd.de
Subject: Re: Disabling L1-A????
Status: R

Hi Sheila!

In article <1992Feb21.133709.17922@cs.wright.edu> you write:
>We are having a problem with students using L1-A every time they think
>a workstation is not functioning properly.

I didn't tell anybody here in our institute about L1-A, but somebody 
heared something about it. The result was that some people press L1-A
because the machine gives an error message after they typed something
wrong...

Take a look at the attached program. It was posted a while ago in the news.
If you invoke it the L1-A sequence will be disabled. I installed this little 
program into rc.local.

There only one problem with it: If the machine really hangs and you can't
do anything you have to pull the power switch.

= ============================== l1a.c ================================
/*
 * The reset sequence disable program.
 */
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sundev/kbd.h>
#include <sundev/kbio.h>

main()
{
  struct kiockey key ;
  int fd ;
  int z,i ;

  fd = open( "/dev/kbd", 1 ) ;
  if( fd < 0 ) {
    perror("Open") ;
    exit( 1 ) ;
  }
  key.kio_tablemask = KIOCABORT1 ;
  ioctl( fd, KIOCGETKEY, &key ) ;             /* read abort key entry */
  if (key.kio_station == 0)
    printf("L1-A reset sequence already disabled\n");
  else if (key.kio_station == 1)
    printf("L1-A reset sequence enabled\n");
  key.kio_station = 0 ;
  ioctl( fd, KIOCSETKEY, &key ) ;             /* map it to a 'hole' in map */
  ioctl( fd, KIOCGETKEY, &key ) ;             /* verify the change */
  if (key.kio_station == 0)
    printf("L1-A reset sequence disabled\n");
  else if (key.kio_station == 1)
    printf("L1-A reset sequence still enabled\n");
}
= ========================================================================

----------------------------------------------------------------------
        Richard Czech                    e-mail: richard@borneo.gmd.de
          GMD-E.I.S.
        P.O.Box 13 16                    phone:     (+49) 2241 14 2039
D-5205 St. Augustin 1, Germany           fax:       (+49) 2241 14 2342
----------------------------------------------------------------------
Hey, I am the signature virus. Copy me into your .sig, help me spread!

>From nishino@tdo.sps.mot.com Sun Feb 23 21:55:59 1992
Received: from spsgate.sps.mot.com by relay1.UU.NET with SMTP 
	(5.61/UUNET-internet-primary) id AA25724; Sun, 23 Feb 92 21:55:44 -0500
Received: by spsgate.sps.mot.com (4.1/SMI-4.1)
	id AA26527; Sun, 23 Feb 92 19:54:39 MST
Received: from tdo.tdo.sps.mot.com (tdo.sps.mot.com) by motsps (4.1/SMI-4.0)
	id AA26765; Sun, 23 Feb 92 19:46:53 MST
Received: by tdo.tdo.sps.mot.com (4.1/6.4J-motj3.7)
	id AA02189; Mon, 24 Feb 92 11:46:37 JST
Date: Mon, 24 Feb 92 11:46:37 JST
>From: nishino@tdo.sps.mot.com (NISHINO-Kazuyuki)
Message-Id: <9202240246.AA02189@tdo.tdo.sps.mot.com>
To: shollen@valhalla
Subject: Re: Disabling L1-A????
Newsgroups: comp.sys.sun.admin
Organization: Nippon MOTOROLA Ltd. Tokyo, Japan
Cc: 
Status: RO

In article <1992Feb21.133709.17922@cs.wright.edu> you write:
>I would like to disable L1-A or at least remap
>the interrupt sequence to something people do not know well.  

 Please try following program. This program change abort sequence to 'L3+R5'.
But, anyone can read/change abort sequence. This program is not so strong
efftct.


/*
	special_setup.c			$Revision: 1.1 $
	$Date: 1991/02/07 14:56:31 $	$Author: nishino $
*/

#include	<stdio.h>
#include	<sys/types.h>
#include	<sys/file.h>
#include	<sundev/kbio.h>
#include	<sundev/kbd.h>

struct kiockey	key;
int		fd;

main()
{
        if ((fd = open("/dev/kbd", O_RDWR)) == -1)
                exit (9);

	key.kio_tablemask = KIOCABORT1;
	key.kio_station = 0x19;
        ioctl(fd, KIOCSETKEY, &key);

	key.kio_tablemask = KIOCABORT2;
	key.kio_station = 0x2e;
        ioctl(fd, KIOCSETKEY, &key);

	exit (0);
}

---
/*   NISHINO-kazuyuki / NIPPON MOTOROLA Ltd.  Tokyo Design Operations	*/
/*   nishino@tdo.sps.mot.com						*/
/*   nishino@tdo.sps.mot-j.co.jp (domestic only)			*/
/*   nishino@buttercup.e-tokyo.prug.or.jp (home)			*/

>From besancon@titus.polytechnique.fr Sun Feb 23 17:10:43 1992
Received: from poly.polytechnique.fr by chenas.inria.fr (5.65c8d/91.12.15)
	via Fnet-EUnet id AA09522; Sun, 23 Feb 1992 23:10:29 +0100 (MET)
Received: by poly.polytechnique.fr (5.57/Ultrix3.0-C)
	id AA21159; Sun, 23 Feb 92 23:11:44 +0100
Received: by titus (4.0/Sun-4.0)
	id AA07453; Sun, 23 Feb 92 23:10:18 +0100
Date: Sun, 23 Feb 92 23:10:18 +0100
>From: besancon@titus.polytechnique.fr (Thierry Besancon)
Message-Id: <9202232210.AA07453@titus>
Organization: LIX, Laboratoire d'Informatique de l'Ecole Polytechnique
        Ecole Polytechnique, 91128 Palaiseau Cedex, France
        tel: 69 33 34 85; fax: 69 33 30 14
To: shollen@valhalla
Subject: L1A
Status: RO

	Hello from France,

I've juste read in the news you got problems with students using
"L1A". Here are two C programs: "disable.c" suppresses the abort sequence
whereas "enable.c" installs the abort sequence YOU want (though it must always 
be a 2 keystroke sequence).
You must run one of these 2 programs each times you reboot the system if, of
course, you want them activated.
I personally run "enable" in /etc/rc.local and have rebound the abort
sequence to "R1Z"...

	Enjoy this,
		Thierry Besancon.
	
-------------------- disable.c ----------------------
 /*
  * disable.c	disable kbd abort sequence
  */
 
#include <stdio.h>
#include <sys/types.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sundev/kbd.h>
#include <sundev/kbio.h>
 
#define setkey(a,b)	ioctl(a,KIOCSETKEY,key)

main(argc, argv)
        int argc;
        int *argv[];
{
  struct kiockey keytable;
  register int console;
  register struct kiockey *key = &keytable;
  
  if ((console = open("/dev/kbd", O_RDONLY, 0)) <0)
    {
      perror("open()");
      exit(1);
    }
  /*
   * First key in abort sequence. Set value of kio_station to
   * kbd location from kb(4).
   */
  keytable.kio_station = 0;
  keytable.kio_tablemask = KIOCABORT1;
  keytable.kio_entry = 0xBE;
  keytable.kio_string[0] = 0;
  if (setkey(console, key) == -1)
    {
      perror("setkey()");
      exit(1);
    }
  /*
   * Second key in abort sequence. Set value of kio_station to
   * kbd location from kb(4).
   */
  keytable.kio_station = 0;
  keytable.kio_tablemask = KIOCABORT2;
  keytable.kio_entry = 0xBF;
  keytable.kio_string[0] = 0;
  if (setkey(console, key) == -1)
    {
      perror("setkey()");
      exit(1);
    }
}
-------------------- disable.c ----------------------
 /*
  * enable.c	enable kbd abort sequence
  */
 
#include <stdio.h>
#include <sys/types.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sundev/kbd.h>
#include <sundev/kbio.h>
 
#define setkey(a,b)	ioctl(a,KIOCSETKEY,key)

main(argc, argv)
        int argc;
        int *argv[];
{
  struct kiockey keytable;
  register int console;
  register struct kiockey *key = &keytable;
  
  if ((console = open("/dev/kbd", O_RDONLY, 0)) <0)
    {
      perror("open()");
      exit(1);
    }
  /*
   * First key in abort sequence. Set value of kio_station to
   * kbd location from kb(4).
   */
  keytable.kio_station = 0x01;
  keytable.kio_tablemask = KIOCABORT1;
  keytable.kio_entry = 0xBE;
  keytable.kio_string[0] = 0;
  if (setkey(console, key) == -1)
    {
      perror("setkey()");
      exit(1);
    }
  /*
   * Second key in abort sequence. Set value of kio_station to
   * kbd location from kb(4).
   */
  keytable.kio_station = 0x4D;
  keytable.kio_tablemask = KIOCABORT2;
  keytable.kio_entry = 0xBF;
  keytable.kio_string[0] = 0;
  if (setkey(console, key) == -1)
    {
      perror("setkey()");
      exit(1);
    }
}

>From dbm@mosaic.uncc.edu Sun Feb 23 14:58:16 1992
Received: from mosaic.uncc.edu by mcnc.mcnc.org (5.59/MCNC/6-25-91)
	id AA10089; Sun, 23 Feb 92 14:58:10 -0500
	for shollen@cs.wright.edu
Received: from ws1.uncc.edu by mosaic.uncc.edu (4.1/SMI-4.1)
	id AA04948; Sun, 23 Feb 92 14:58:08 EST
Date: Sun, 23 Feb 92 14:58:08 EST
>From: dbm@mosaic.uncc.edu (dwayne mcneil)
Message-Id: <9202231958.AA04948@mosaic.uncc.edu>
To: shollen@valhalla
Subject: L1A remap
Status: RO


Per your recent request on some Sun mailing list or newsgroup (I forget
which one...), attached is a short program which remaps the L1A abort
sequence.  I didn't write it...  A guy at Sun gave it to me, and it's
worked fine for us.  

We put this in /etc/rc.local and enable a PROM password, so if users
turn off the system, it will be out of commission until our workstation
guy's reboot it.

Also note you can enable the kill sequence in OW3, L1-ALT-DEL I believe,
so the user can unhang him/her self.

Good Luck...
Dwayne

BTW:  What is hanging your workstations?

----
/*
 * l1a.c
 * 
 * Program to remap L1A to something else.  For UNCC, we remap the keys
 * to non-existant keys.
 *
 * I don't know who orig wrote this (Janice? Jackson?).  It was provided
 * to us by a guy at Sun.  - Dwayne Mcneil.
 */

/*
 * Here's a program (courtesy of Jackson Wong) to change the ABORT1
 * and ABORT2 keys (L1-A) to two different keys. If you wanted to disable
 * this completely, you could map these to non-existant key stations.
 * (Anything that says "HOLE" under the KB(4S) manpage tables).
 * Janice
 */

/*
 *      move_abort.c
 *
 *      The following program is an example on how to move the system
 *      two-key abort sequence to somewhere else on the keyboard.
 *      See the manual section under KB(4S) for more detail.
 *      If you need to reset your keyboard to default, you can reboot
 *      your system.
 *
 *      Note:  This program does not need to be run setuid-root.
 *              (major security problem)
 *      -jackson
 */

#include        <stdio.h>
#include        <sys/types.h>
#include        <sys/file.h>
#include        <sys/ioctl.h>
#include        <sundev/kbd.h>
#include        <sundev/kbio.h>


main(argc, argv)
int argc;
char *argv[];
{
        struct  kiockey keytable;
        struct  kiockey *key;
        int     keyboard;

        if ((keyboard = open("/dev/kbd", O_RDONLY, 0)) < 0) {
            printf("can't open /dev/kbd \n");
            perror("move_abort");
            return;
            }

        /* move first abort key to "no" key */
        keytable.kio_tablemask = KIOCABORT1;
        key = &keytable;
        key->kio_station = 0 ; /* 0x4D */
        if (setkey(keyboard, key) == -1) {
                perror("move_abort: KIOCABORT1");
        }

        /* move second abort key to "d" key */
        keytable.kio_tablemask = KIOCABORT2;
        key = &keytable;
        key->kio_station = 79; /* 0x4F */
        if (setkey(keyboard, key) == -1) {
                perror("move_abort: KIOCABORT2");
        }

}


setkey(keyboard, kk)
int     keyboard;
struct  kiockey *kk;
{
        return((ioctl((keyboard), KIOCSETKEY, kk)));
}




>From Shane.Sigler@Eng.Sun.COM Fri Feb 21 21:07:33 1992
Received: from Eng.Sun.COM (zigzag-bb.Corp.Sun.COM) by Sun.COM (4.1/SMI-4.1)
	id AA21484; Fri, 21 Feb 92 18:07:25 PST
Received: from fullbore.Eng.Sun.COM by Eng.Sun.COM (4.1/SMI-4.1)
	id AA15719; Fri, 21 Feb 92 18:07:39 PST
Received: by fullbore.Eng.Sun.COM (4.1/SMI-4.1)
	id AA04066; Fri, 21 Feb 92 18:07:29 PST
Date: Fri, 21 Feb 92 18:07:29 PST
Message-Id: <9202220207.AA04066@fullbore.Eng.Sun.COM>
To: shollen@valhalla
Subject: Re: Disabling L1-A????
>From: Shane.Sigler@Eng.Sun.COM (Shane Sigler)
Status: RO

Sheila,
	
	I have a C program that some else wrote that will disable the L1-A 
key on a Sun, if you want I can send you the C code or the compiled program.

Shane Sigler
System Support Specialist


In article 17922@cs.wright.edu, shollen@valhalla.cs.wright.edu (Sheila Hollenbaugh) writes:
>
>We are having a problem with students using L1-A every time they think
>a workstation is not functioning properly.  I know this has probably
>been answered before, but I would like to disable L1-A or at least remap
>the interrupt sequence to something people do not know well.  If anyone
>out there has a summary of previous coverage or has done this, please
>email me.  If a summary is desired, I will be glad to provide one.
>
>Thanks!!
>-- 
>Sheila Hollenbaugh       Computer Systems Engineer
>Wright State University  Department of Computer Science & Engineering
>3171 Research Blvd., Kettering, OH 45420  (513) 259-1384 
>shollen@cs.wright.edu    or    shollen@valhalla.cs.wright.edu





>From setzer@math.ncsu.edu Mon Feb 24 11:37:18 1992
Received: from math.ncsu.edu by ncsuvx.ncsu.edu (5.65b/2 4/27/87)
	id AA10968; Mon, 24 Feb 92 11:36:31 -0500
Received: by math.ncsu.edu (4.1/SAM 07-20-90 10:07:54/m)
	id AA00320; Mon, 24 Feb 92 11:36:22 EST
Date: Mon, 24 Feb 92 11:36:22 EST
>From: setzer@math.ncsu.edu (William Setzer)
Posted-Date: Mon, 24 Feb 92 11:36:22 EST
Message-Id: <9202241636.AA00320@math.ncsu.edu>
To: shollen@valhalla (Sheila Hollenbaugh)
Subject: Disabling L1-A????
Status: R

: We are having a problem with students using L1-A every time they think
: a workstation is not functioning properly.

Here's something I wrote to do "everything you've ever wanted to do
with L1-A".  It's not "distributable"-level code or anything, but it
should be able to do what you want.  Comments, flames, and improvements
are welcome.


William

PS: BTP stands for "break to prom".

8<-8<-8<-8<- Cut 8<-8<-8<-8<-
#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of archive 1 (of 1)."
# Contents:  Makefile README btp.c keymap.c.type3 keymap.c.type4
#   keymap.h makekeymap
# Wrapped by setzer@math.ncsu.edu on Mon Feb 24 11:35:13 1992
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'Makefile' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Makefile'\"
else
echo shar: Extracting \"'Makefile'\" \(87 characters\)
sed "s/^X//" >'Makefile' <<'END_OF_FILE'
XCFLAGS=-g
X
XOBJS=btp.o keymap.o
X
Xall: $(OBJS)
X	cc -o btp $(OBJS)
X
Xkeymap.c:
X	makekeymap
END_OF_FILE
if test 87 -ne `wc -c <'Makefile'`; then
    echo shar: \"'Makefile'\" unpacked with wrong size!
fi
# end of 'Makefile'
fi
if test -f 'README' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'README'\"
else
echo shar: Extracting \"'README'\" \(1226 characters\)
sed "s/^X//" >'README' <<'END_OF_FILE'
XCongratulations!  You're now the proud owner of `btp', a program to do
Xeverything you've ever wanted to do to the "break to prom" key
Xsequence (L1-A).  This code has been lightly tested under SunOS 4.1.1,
Xand appears to work OK.
X
XThe only weird configuration problem is with the file `keymap.c'.  The
Xprogram `makekeymap' uses the output of `dumpkeys' to see what each
Xkey does, and sets up `keymap.c' appropriately.  I've included a
X`keymap.c' for type 3 and type 4 keyboards though, so you probably
Xwon't need to worry about it.  If you have a different type of
Xkeyboard, mail me and I'll see if I can remember what everything in
X`keymap.c' means.
X
XIf you try to set your BTP key sequence to a "bad" value, `btp' will
Xcomplain and exit, but you can override this behavior.  I haven't
Xactually tested all the "bad" configurations to see if they're "bad"
X-- the warnings are from a theoretical standpoint.  So feel free to
Xset your BTP key sequence to `Control-C'.  :-)
X
XThis code certainly isn't "distributable" quality, but it's good enough
Xto be useful.  I haven't written a man page or anything, but a quick
Xperusal through the code should get you going.  Comments, flames, and
Ximprovements are welcome.  Enjoy.
X
X
XWilliam
END_OF_FILE
if test 1226 -ne `wc -c <'README'`; then
    echo shar: \"'README'\" unpacked with wrong size!
fi
# end of 'README'
fi
if test -f 'btp.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'btp.c'\"
else
echo shar: Extracting \"'btp.c'\" \(4072 characters\)
sed "s/^X//" >'btp.c' <<'END_OF_FILE'
X#include <stdio.h>
X#include <ctype.h>
X#include <string.h>
X#include <varargs.h>
X#include <errno.h>
X#include <fcntl.h>
X#include <sys/types.h>
X#include <sundev/kbio.h>
X#include <sundev/kbd.h>
X#include "keymap.h"
X
Xint BtpFd = -1;
X
Xvoid BtpFatal(va_alist)
Xva_dcl
X{
X  va_list args;
X  char *fmt;
X  char buf[512];
X
X  va_start(args);
X  fmt = va_arg(args, char *);
X  vprintf(fmt, args);
X  va_end(args);
X  
X  if (BtpFd >= 0)
X    close(BtpFd);
X  exit(1);
X}
X
X
Xchar *usage[] =
X{
X  "Usage:  btp <option>\n",
X  " Where <option> is one of:\n",
X  "  q[uery]                    prints current BTP setting\n",
X  "  d[efault]                  sets BTP back to L1-A\n",
X  "  o[ff]                      disables BTP\n",
X  "  l[ist]                     lists possible keys by name and station\n",
X  "  [#]key1 [#]key2 [f]        sets BTP to key1-key2\n\n",
X  " `#' means that key is a station number rather than a name\n",
X  " `f' means set BTP to keys even though program thinks it's a bad idea\n",
X  NULL,
X};
X
Xvoid BtpUsage()
X{
X  char **ptr;
X
X  ptr = &usage[0];
X  while (*ptr)
X    printf(*ptr++);
X
X  BtpFatal("");
X}
X
Xvoid BtpListKeyNames()
X{
X  int i;
X
X  for (i = 0; keyMap[i].name; i++)
X    {
X      printf("%3d) %10s  ", i, keyMap[i].name);
X      if (i % 4 == 3)
X        printf("\n");
X    }
X}
X
Xint BtpNameToStation(str)
Xchar *str;
X{
X  register int i;
X
X  for (i = 0; keyMap[i].name; i++)
X    if (!strcmp(str, keyMap[i].name))
X      break;
X
X  if (keyMap[i].name)
X    return i;
X  BtpFatal("Unknown key name <%s>\n", str);
X}
X
Xvoid BtpSanityCheck(key, force)
Xint key, force;
X{
X  if (key < 0 || key > 127)
X      BtpFatal("<%d> is out of range (0-127).\n", key);
X
X  switch (keyMap[key].type)
X    {
X    case MOD:
X      printf("<%d (%s)> is a modifier key.\n", key, keyMap[key].name);
X      break;
X    case NONE:
X      printf("<%d> is a `null' key.  It will disable BTP.\n", key);
X      printf("`btp off' would be better if that's what you intend.\n");
X      break;
X    case RESERVED:
X      printf("<%d (%s)> is reserved.\n", key, keyMap[key].name);
X      break;
X    case UNKNOWN:
X      printf("I don't know what <%d> is.\n", key);
X      break;
X    case OK:
X      return;
X      break;
X    default:
X      BtpFatal("Internal sanity check error.\n");
X    }
X  if (force)
X    printf("Continuing anyway...\n");
X  else
X    BtpFatal("");
X}
X
Xvoid BtpQuery(fd)
Xint fd;
X{
X  struct kiockeymap kiockey1, kiockey2;
X  int key1, key2;
X
X  kiockey1.kio_tablemask = KIOCABORT1;
X  kiockey2.kio_tablemask = KIOCABORT2;
X  ioctl(BtpFd, KIOCGKEY, &kiockey1);
X  ioctl(BtpFd, KIOCGKEY, &kiockey2);
X  key1 = kiockey1.kio_station;
X  key2 = kiockey2.kio_station;
X  if (keyMap[key1].type == NONE)
X    printf("BTP key sequence is disabled\n");
X  else
X    printf("BTP key sequence is set to #%d-#%d (%s-%s)\n", key1, key2,
X           keyMap[key1].name, keyMap[key2].name);
X}
X
Xvoid BtpSet(key1, key2)
Xint key1, key2;
X{
X  struct kiockeymap kiockey1, kiockey2;
X
X  kiockey1.kio_tablemask = KIOCABORT1;
X  kiockey2.kio_tablemask = KIOCABORT2;
X  kiockey1.kio_station   = key1;
X  kiockey2.kio_station   = key2;
X  ioctl(BtpFd, KIOCSKEY, &kiockey1);
X  ioctl(BtpFd, KIOCSKEY, &kiockey2);
X}
X
Xmain(argc, argv)
Xint argc; char **argv;
X{
X  int key1, key2, force;
X  extern char *sys_errlist[];
X
X  if ((BtpFd = open("/dev/kbd", O_RDWR)) < 0)
X    BtpFatal("Couldn't open /dev/kbd: %s", sys_errlist[errno]);
X
X  if (argc == 2)
X    switch (*argv[1])
X      {
X      case 'd': BtpSet(L1_KEY, A_KEY); break;
X      case 'l': BtpListKeyNames(); break;
X      case 'o': BtpSet(NONE_KEY, NONE_KEY); break;
X      case 'q': /* done below */ break;
X      default:  BtpUsage(); break;
X      }
X  else if (argc == 3 || argc == 4)
X    {
X
X#define IsNumericArgv(X) (argv[X][0] == '#' && isdigit(argv[X][1]))
X
X      force = (argc == 4 && argv[3][0] == 'f');
X      key1  = (IsNumericArgv(1) ? atoi(argv[1]+1) : BtpNameToStation(argv[1]));
X      key2  = (IsNumericArgv(2) ? atoi(argv[2]+1) : BtpNameToStation(argv[2]));
X      BtpSanityCheck(key1, force);
X      BtpSanityCheck(key2, force);
X      BtpSet(key1, key2);
X    }
X  else
X    BtpUsage();
X
X  BtpQuery();
X  close(BtpFd);
X}
END_OF_FILE
if test 4072 -ne `wc -c <'btp.c'`; then
    echo shar: \"'btp.c'\" unpacked with wrong size!
fi
# end of 'btp.c'
fi
if test -f 'keymap.c.type3' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'keymap.c.type3'\"
else
echo shar: Extracting \"'keymap.c.type3'\" \(1608 characters\)
sed "s/^X//" >'keymap.c.type3' <<'END_OF_FILE'
X/* This file is generated automatically.
X * Make sure you know what you're doing if you edit it. */
X#include "keymap.h"
Xstruct keymapinfo keyMap[] = {
X"none", NONE,
X"L1", OK,
X"none", NONE,
X"L2", OK,
X"none", NONE,
X"F1", OK,
X"F2", OK,
X"none", NONE,
X"F3", OK,
X"none", NONE,
X"F4", OK,
X"none", NONE,
X"F5", OK,
X"none", NONE,
X"F6", OK,
X"none", NONE,
X"F7", OK,
X"F8", OK,
X"F9", OK,
X"alt", MOD,
X"none", NONE,
X"R1", OK,
X"R2", OK,
X"R3", OK,
X"none", NONE,
X"L3", OK,
X"L4", OK,
X"none", NONE,
X"none", NONE,
X"ESC", OK,
X"1", OK,
X"2", OK,
X"3", OK,
X"4", OK,
X"5", OK,
X"6", OK,
X"7", OK,
X"8", OK,
X"9", OK,
X"0", OK,
X"-", OK,
X"=", OK,
X"`", OK,
X"BS", OK,
X"none", NONE,
X"R4", OK,
X"R5", OK,
X"R6", OK,
X"none", NONE,
X"L5", OK,
X"none", NONE,
X"L6", OK,
X"none", NONE,
X"TAB", OK,
X"q", OK,
X"w", OK,
X"e", OK,
X"r", OK,
X"t", OK,
X"y", OK,
X"u", OK,
X"i", OK,
X"o", OK,
X"p", OK,
X"[", OK,
X"]", OK,
X"DEL", OK,
X"none", NONE,
X"R7", OK,
X"uparrow", OK,
X"R9", OK,
X"none", NONE,
X"L7", OK,
X"L8", OK,
X"none", NONE,
X"none", NONE,
X"leftctrl", MOD,
X"a", OK,
X"s", OK,
X"d", OK,
X"f", OK,
X"g", OK,
X"h", OK,
X"j", OK,
X"k", OK,
X"l", OK,
X";", OK,
X"\'", OK,
X"\\", OK,
X"RET", OK,
X"none", NONE,
X"leftarrow", OK,
X"R11", OK,
X"rightarrow", OK,
X"none", NONE,
X"L9", OK,
X"none", NONE,
X"L10", OK,
X"none", NONE,
X"leftshift", MOD,
X"z", OK,
X"x", OK,
X"c", OK,
X"v", OK,
X"b", OK,
X"n", OK,
X"m", OK,
X",", OK,
X".", OK,
X"/", OK,
X"rightshift", MOD,
X"LFD", OK,
X"R13", OK,
X"downarrow", OK,
X"R15", OK,
X"none", NONE,
X"none", NONE,
X"none", NONE,
X"none", NONE,
X"capslock", MOD,
X"meta", MOD,
X"'", OK,
X"meta", MOD,
X"none", NONE,
X"none", NONE,
X"none", NONE,
X"error", RESERVED,
X"idle", RESERVED,
X0,0 };
END_OF_FILE
if test 1608 -ne `wc -c <'keymap.c.type3'`; then
    echo shar: \"'keymap.c.type3'\" unpacked with wrong size!
fi
# end of 'keymap.c.type3'
fi
if test -f 'keymap.c.type4' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'keymap.c.type4'\"
else
echo shar: Extracting \"'keymap.c.type4'\" \(1584 characters\)
sed "s/^X//" >'keymap.c.type4' <<'END_OF_FILE'
X/* This file is generated automatically.
X * Make sure you know what you're doing if you edit it. */
X#include "keymap.h"
Xstruct keymapinfo keyMap[] = {
X"none", NONE,
X"L1", OK,
X"none", NONE,
X"L2", OK,
X"none", NONE,
X"F1", OK,
X"F2", OK,
X"F10", OK,
X"F3", OK,
X"F11", OK,
X"F4", OK,
X"F12", OK,
X"F5", OK,
X"altgraph", MOD,
X"F6", OK,
X"none", NONE,
X"F7", OK,
X"F8", OK,
X"F9", OK,
X"alt", MOD,
X"none", NONE,
X"R1", OK,
X"R2", OK,
X"R3", OK,
X"none", NONE,
X"L3", OK,
X"L4", OK,
X"none", NONE,
X"none", NONE,
X"ESC", OK,
X"1", OK,
X"2", OK,
X"3", OK,
X"4", OK,
X"5", OK,
X"6", OK,
X"7", OK,
X"8", OK,
X"9", OK,
X"0", OK,
X"-", OK,
X"=", OK,
X"`", OK,
X"BS", OK,
X"none", NONE,
X"R4", OK,
X"R5", OK,
X"R6", OK,
X"B13", OK,
X"L5", OK,
X"B10", OK,
X"L6", OK,
X"none", NONE,
X"TAB", OK,
X"q", OK,
X"w", OK,
X"e", OK,
X"r", OK,
X"t", OK,
X"y", OK,
X"u", OK,
X"i", OK,
X"o", OK,
X"p", OK,
X"[", OK,
X"]", OK,
X"DEL", OK,
X"compose", MOD,
X"R7", OK,
X"uparrow", OK,
X"R9", OK,
X"B15", OK,
X"L7", OK,
X"L8", OK,
X"none", NONE,
X"none", NONE,
X"leftctrl", MOD,
X"a", OK,
X"s", OK,
X"d", OK,
X"f", OK,
X"g", OK,
X"h", OK,
X"j", OK,
X"k", OK,
X"l", OK,
X";", OK,
X"\'", OK,
X"\\", OK,
X"RET", OK,
X"B11", OK,
X"leftarrow", OK,
X"R11", OK,
X"rightarrow", OK,
X"B8", OK,
X"L9", OK,
X"none", NONE,
X"L10", OK,
X"numlock", MOD,
X"leftshift", MOD,
X"z", OK,
X"x", OK,
X"c", OK,
X"v", OK,
X"b", OK,
X"n", OK,
X"m", OK,
X",", OK,
X".", OK,
X"/", OK,
X"rightshift", MOD,
X"LFD", OK,
X"R13", OK,
X"downarrow", OK,
X"R15", OK,
X"none", NONE,
X"none", NONE,
X"none", NONE,
X"L16", OK,
X"capslock", MOD,
X"meta", MOD,
X"'", OK,
X"meta", MOD,
X"none", NONE,
X"none", NONE,
X"B14", OK,
X"error", RESERVED,
X"idle", RESERVED,
X0,0 };
END_OF_FILE
if test 1584 -ne `wc -c <'keymap.c.type4'`; then
    echo shar: \"'keymap.c.type4'\" unpacked with wrong size!
fi
# end of 'keymap.c.type4'
fi
if test -f 'keymap.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'keymap.h'\"
else
echo shar: Extracting \"'keymap.h'\" \(189 characters\)
sed "s/^X//" >'keymap.h' <<'END_OF_FILE'
Xstruct keymapinfo
X{
X  char *name;
X  int  type;
X};
X
Xenum {OK, MOD, NONE, RESERVED, UNKNOWN};
X
X#define L1_KEY    1
X#define A_KEY    77
X#define NONE_KEY  0
X
Xextern struct keymapinfo keyMap[];
END_OF_FILE
if test 189 -ne `wc -c <'keymap.h'`; then
    echo shar: \"'keymap.h'\" unpacked with wrong size!
fi
# end of 'keymap.h'
fi
if test -f 'makekeymap' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'makekeymap'\"
else
echo shar: Extracting \"'makekeymap'\" \(1417 characters\)
sed "s/^X//" >'makekeymap' <<'END_OF_FILE'
X#!/home/local/bin/perl
X
X@keys=`dumpkeys`;
X
Xopen (KM, ">keymap.c") || die "Can't open 'keymap.c'!";
Xselect(KM);
Xprint "/* This file is generated automatically.\n";
Xprint " * Make sure you know what you're doing if you edit it. */\n";
Xprint "#include \"keymap.h\"\n";
Xprint "struct keymapinfo keyMap[] = {\n";
X
Xfor (@keys)
X{
X
X    if    (/error/)	{ print qq|"error", RESERVED|;  }
X    elsif (/idle/)	{ print qq|"idle", RESERVED|; }
X    elsif (/hole/)	{ print qq|"none", NONE|; }
X    elsif (/base (.) /)	{ print qq|"$1", OK|; }
X    elsif (/\^\[/)	{ print qq|"ESC", OK|; }
X    elsif (/lf.(\d+)/)	{ print qq|"L$1", OK|; }
X    elsif (/rf.(\d+)/)	{ print qq|"R$1", OK|; }
X    elsif (/tf.(\d+)/)	{ print qq|"F$1", OK|; }
X    elsif (/bf.(\d+)/)	{ print qq|"B$1", OK|; }
X    elsif (/compose/)	{ print qq|"compose", MOD|; }
X    elsif (/\+system/)	{ print qq|"L1", OK|;  }
X    elsif (/\+home/)	{ print qq|"home", OK|; }
X    elsif (/\+meta/)	{ print qq|"meta", MOD|; }
X    elsif (/\+(\w+arrow)/){ print qq|"$1", OK|; }
X    elsif (/\+(\w+)/)	{ print qq|"$1", MOD|; }
X    elsif (/\\177/)	{ print qq|"DEL", OK|; }
X    elsif (/\\n/)	{ print qq|"LFD", OK|; }
X    elsif (/\\r/)	{ print qq|"RET", OK|; }
X    elsif (/\\t/)	{ print qq|"TAB", OK|; }
X    elsif (/\\b/)	{ print qq|"BS", OK|; }
X    elsif (/'\\(.)/)	{ print qq|"\\$1", OK|; }
X    else		{ print qq|"unknown", UNKNOWN|; }
X
X    print ",\n";
X}
Xprint "0,0 };\n";
Xclose(KM);
X        
END_OF_FILE
if test 1417 -ne `wc -c <'makekeymap'`; then
    echo shar: \"'makekeymap'\" unpacked with wrong size!
fi
chmod +x 'makekeymap'
# end of 'makekeymap'
fi
echo shar: End of archive 1 \(of 1\).
cp /dev/null ark1isdone
MISSING=""
for I in 1 ; do
    if test ! -f ark${I}isdone ; then
	MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have the archive.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0

>From <@rock.db.toronto.edu:jdd@db.toronto.edu> Mon Feb 24 13:30:56 1992
Received: by rock.db.toronto.edu via suspension id <9048>; Mon, 24 Feb 1992 13:30:38 -0500
Received: by rock.db.toronto.edu id <9047>; Mon, 24 Feb 1992 13:06:59 -0500
>From: John DiMarco <jdd@db.toronto.edu>
To: shollen@valhalla
Subject: Re: Disabling L1-A????
Newsgroups: comp.sys.sun.admin
Message-Id: <92Feb24.130659est.9047@rock.db.toronto.edu>
Date: 	Mon, 24 Feb 1992 13:06:50 -0500
Status: R

In comp.sys.sun.admin you write:


>We are having a problem with students using L1-A every time they think
>a workstation is not functioning properly.  I know this has probably
>been answered before, but I would like to disable L1-A or at least remap
>the interrupt sequence to something people do not know well.  If anyone
>out there has a summary of previous coverage or has done this, please
>email me.  If a summary is desired, I will be glad to provide one.

Yes, it's possible: adb your kernel as follows:

#! /bin/sh
# Patch to disable the BREAK key and L1-A in one fell swoop
adb -w -k /vmunix /dev/mem << EOF
montrap?w0x4e75
montrap/w0x4e75
EOF

However, you probably don't want to do this, since users will just powercycle
the machine instead. That's worse!

John
--
John DiMarco                                              jdd@cdf.toronto.edu
Computing Disciplines Facility Systems Manager            jdd@cdf.utoronto.ca
University of Toronto                                     EA201B,(416)978-1928

-- 
Sheila Hollenbaugh       Computer Systems Engineer
Wright State University  Department of Computer Science & Engineering
3171 Research Blvd., Kettering, OH 45420  (513) 259-1384 
shollen@cs.wright.edu    or    shollen@valhalla.cs.wright.edu

--------------------------------------------------------------------------

>From: Claus Assmann <ca@idefix.informatik.uni-kiel.dbp.de>
To: fifi@hiss.han.de
Message-Id: <RFC-822:9205111425.AA15644@idefix.informatik.uni-kiel.dbp.de>
Subject: Re: How to disable 'L1 A'
Status: OR

In comp.sys.sun.admin you write:

>ist there any way to disable the key combination 'L1 A' or (better)
>map the function to any other key(s)?

You might use these:

/*
 *  remap_abort -- remap kbd abort sequence to something other than L1-a
 *  			Note that the abort sequence can be remapped to
 *			{0x00, 0x00} to completely disable keyboard aborts,
 *			but this may or may not be a good idea, depending
 *			on your environment.
 *
 *			This program can be run at any time by any user,
 *			but for best effect, it should be the very first
 *			thing run in /etc/rc.boot.
 *
 *  Author:
 *      D. Brent Chapman
 *      Capital Market Technology, Inc.
 *      capmkt!brent@{lll-tis.arpa,cogsci.berkeley.edu}
 *      {ucbvax!cogsci,lll-tis}!capmkt!brent
 *
 *  Inspired by code from Carol Wilhelmy of Sun Microsystems.
 */

#include    <stdio.h>
#include    <sys/types.h>
#include    <sys/file.h>
#include    <sys/ioctl.h>
#include    <sundev/kbd.h>
#include    <sundev/kbio.h>

/* define your own keys here !!!!!!!!!!!!!!!!	*/
#define KEY1	0x01
#define KEY2	0x70

main(argc, argv)
    int argc;
    char *argv[];
{
    struct  kiockey keytable;
    register int    console;
    register struct kiockey *key = &keytable;
    int mode;
    char *c;

    if (argc != 2) {
            printf("\nUSAGE: remap_abort y|n \n\n");
            exit(1);
    }
    switch (*(c= argv[1])) {
    case 'y':
            mode = 1;
            break;
    case 'n':
            mode = 0;
            break;
    default:
            printf("\nINVALID ARGUMENT\n");
            printf("USAGE: abort_key y|n \n\n");
    exit(1);
    }


    if ((console = open("/dev/kbd", O_RDONLY, 0)) < 0) {
        perror("open()");
        exit(1);
    }

    /*
     * First key in abort sequence. Set value of kio_station to
     * kbd location from kb(4).
     */

    keytable.kio_tablemask = KIOCABORT1;
    keytable.kio_station = mode ? 0x01 : KEY1;	/* set first key to KEY1 */
    keytable.kio_entry = 0xBE;		/* don't know if these are necessary, */
    keytable.kio_string[0] = 0;		/*   but they can't hurt	      */

    if (ioctl(console, KIOCSETKEY, key) == -1) {
        perror("ioctl[1]");
        exit(1);
    }

    /*
     * Second key in abort sequence. Set value of kio_station to
     * kbd location from kb(4).
     */

    keytable.kio_tablemask = KIOCABORT2;
    keytable.kio_station = mode ? 0x4d : KEY2;	/* set second key to KEY2 */
    keytable.kio_entry = 0xBF;		/* don't know if these are necessary, */
    keytable.kio_string[0] = 0;		/*   but they can't hurt	      */

    if (ioctl(console, KIOCSETKEY, key) == -1) {
        perror("ioctl[2]");
        exit(1);
    }
}

/*
 *  query_abort -- query the keyboard about the current abort key sequence
 *			(normally L1-a); see the kbd(4) man page for more
 *			info.
 *
 *  Author:
 *	D. Brent Chapman
 *	Capital Market Technology, Inc.
 *	capmkt!brent@{lll-tis.arpa,cogsci.berkeley.edu}
 *	{ucbvax!cogsci,lll-tis}!capmkt!brent
 *
 *  Inspired by code from Carol Wilhelmy of Sun Microsystems.
 */

#include    <stdio.h>
#include    <sys/types.h>
#include    <sys/file.h>
#include    <sys/ioctl.h>
#include    <sundev/kbd.h>
#include    <sundev/kbio.h>


main(argc, argv)
    int argc;
    char *argv[];
{
    int kbtype;
    struct  kiockey keytable;
    register int    console;
    register struct kiockey *key = &keytable;

    if ((console = open("/dev/kbd", O_RDONLY, 0)) < 0) {
        perror("open()");
        exit(1);
    }

    /*
     * Keyboard type.
     */

    if (ioctl(console, KIOCTYPE, &kbtype) == -1) {
	perror("ioctl[0]");
	exit(1);
    } else {
	printf("KIOCTYPE:\t%d ", kbtype);
	switch (kbtype) {
	    case KB_KLUNK:
		fputs("KB_KLUNK", stdout);
		break;
	    case KB_VT100:
		fputs("KB_VT100", stdout);
		break;
	    case KB_SUN2:
		fputs("KB_SUN2", stdout);
		break;
	    case KB_SUN3:
		fputs("KB_SUN3", stdout);
		break;
	    case KB_SUN4:
		fputs("KB_SUN4", stdout);
		break;
	    case KB_ASCII:
		fputs("KB_ASCII", stdout);
		break;
	}
	fputs("\n", stdout);
    }

    /*
     * First key in abort sequence.  Value of kio_station is
     * kbd location from kb(4).
     */

    keytable.kio_tablemask = KIOCABORT1;
    keytable.kio_station = 0;			/* I'm not sure if these  */
    keytable.kio_entry = 0xBE;			/* need to be set, but it */
    keytable.kio_string[0] = 0;			/* can't hurt.		  */

    if (ioctl(console, KIOCGETKEY, key) == -1) {
        perror("ioctl[1]");
        exit(1);
    } else {
	/* kio_station is what we're interested in; I'm not sure what 	*/
	/* kio_entry means or is good for.				*/
	printf("KIOCABORT1:\n");
	printf("\tkio_station = 0x%x\n", (int) keytable.kio_station);
    }

    /*
     * Second key in abort sequence.  Value of kio_station is
     * kbd location from kb(4).
     */

    keytable.kio_tablemask = KIOCABORT2;
    keytable.kio_station = 0;			/* Ditto comments above */
    keytable.kio_entry = 0xBF;
    keytable.kio_string[0] = 0;

    if (ioctl(console, KIOCGETKEY, key) == -1) {
        perror("ioctl[2]");
        exit(1);
    } else {
	/* kio_station is what we're interested in; I'm not sure what 	*/
	/* kio_entry means or is good for.				*/
	printf("KIOCABORT2:\n");
	printf("\tkio_station = 0x%x\n", (int) keytable.kio_station);
    }
}

Regards,

Claus
-- 
---
Experience is something you don't get until just after you need it.
                -- Olivier

-- 
Axel Zinser		+49 511 699945			       fifi@hiss.han.de
Uni Hildesheim, RZ	+49 5121 883577		      fifi@rz.uni-hildesheim.de
		Schlafen macht hungrig, Essen macht muede...