folgender source ermoeglicht das reagieren auf keyboard interrupt's unter linux. er kann nach dem kompilieren mit dem befehl
insmod keymod.o (kernel version < 2.4.x)
insmod keymod.ko (kernel version > 2.4.x)
als modul gestartet werden. es reagiert sobald ein keyboard interrupt ausgeloest worden ist und gibt den aktuellen wert aus dem hardwareport 0x60 an eine weitere funktion (send_char()) die individuell realisiert werden kann weiter.
hinweis: dieser source koennte natuerlich als keylogger verwendet werden. ich moechte hiermit ausdruecklich darauf hinweisen dass dies nicht mein zeil war und bitte diesen nicht als solchen zu missbrauchen.

/******************************************************************************
** titel: dies ist ein treiber/modul welches als modul unter linux
** (redhat/suse) eingebunden werden kann. es reagiert auf den
** keyboard interrupt 1.wird ein keyboard interrupt ausgeloest liest
** es den aktuellen wert aus dem hardwareport 0x60 aus und gibt diesen
** an eine weitere funktion (send_char()) zur jeweiligen weiteren
** verarbeitung weiter. diese funktion kann beliebig angepasst werden.
** version: 1.0
** date: 07.03.2006
** autor: pec
*******************************************************************************/

/*-------------------------- System includes ---------------------------------*/
#include

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)
// kernel < 2.6.x (redhat 7.1)
#include
#include
#include
#include
#include
#else
// kernel > 2.6.x (suse 9.3)
#include
#include
#include
MODULE_AUTHOR("PEC");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Keyboard Interrupt");
MODULE_SUPPORTED_DEVICE("none");
#endif

#include
#include
#include
#include

/*-------------------------- globale structur ---------------------------------*/
struct IrqParm
{
short parm;
};

struct IrqParm irq_parm;


/*------------------------------ send_char() --------------------------------*/
static void send_char(void *scancode)
{
// hier kann die individuelle weitere verarbeitung realissiert werden

}


/*------------------------------ irq_handler() ------------------------------*/
/* wird ein keyboard interrupt ausgeloestdiese gibt diese funktion den
** aktuellen wert aus dem hardwareport 0x60 an die funktion send_char() weiter.
** die funktion send_char() kann individuell implementiert werden.
** author: pec
*/
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)
// kernel < 2.6.x (redhat 7.1)
void irq_handler(int irq,void *dev_id,struct pt_regs *regs)
#else
// kernel < 2.6.x (suse 9.3)
int irq_handler(int irq,void *dev_id,struct pt_regs *regs)
#endif
{
static unsigned char scancode;

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)
// kernel < 2.6.x (redhat 7.1)
static struct tq_struct task;
task.routine = send_char;
task.data = (void *)&scancode;
#else
// kernel > 2.6.x (suse 9.3)
static DECLARE_WORK(work, send_char, (void *)&scancode );
#endif

scancode = inb(0x60);

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)
// kernel < 2.6.x (redhat 7.1)
//queue_task(&task, &tq_immediate);
//mark_bh(IMMEDIATE_BH);
schedule_task( &task );
#else
// kernel > 2.6.x (suse 9.3)
schedule_work( &work );
#endif

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)
// kernel < 2.6.x (redhat 7.1)
return;
#else
// kernel > 2.6.x (suse 9.3)
return(0);
#endif
}





/******************************************************************************
************************* laden und entladen des moduls ***********************
******************************************************************************/
/*--------------------------- init_module() ---------------------------------*/
/* KERNEL-MODUL Deklaration
** diese funktionsbezeichnung ist zu waehlen wenn der source als kernel-modul
** laufen soll
** diese funktion wird sofort nach dem start des moduls aufgerufen und fuehrt
** die aufgaben zum starten des modules durch
*/
// int init_module(void)

/*--------------------------- drv_init() ------------------------------------*/
/* KERNEL-TREIBER Deklaration
** diese funktionsbezeichnung ist zu waehlen wenn der source als kernel-treiber
** laufen soll
** diese funktion wird sofort nach dem start des treibers aufgerufen und fuehrt
** die aufgaben zum starten des treibers durch
*/
static int __init drv_init(void)
{
printk("\n\n### Start running Keyboard Interrupt-Reader... ###\n");
printk("Kernel VCode: %d\n",LINUX_VERSION_CODE);

// wir muessen den originalen keyboard handler (irq) des kernels
// freigeben bzw. loeschen da er nicht mit uns teilen will. leider
// koennen wir nach abarbeiten unserer funktion den irq nicht wieder dem
// kernel zurueckgeben.das system muss danach rebooten um wieder auf normale
// keyboard aktivitaeten reagieren zu koennen
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)
// kernel < 2.6.x (redhat 7.1)
free_irq(1, NULL);
#else
// kernel > 2.6.x (suse 9.3)
#endif

// nun sollten wir den irq anfordern und aus ihm auslesen
request_irq(
1, // interrupt nr
irq_handler, // addresse der aufzturufenden funktion
SA_SHIRQ, // flag wir waren bereit den irq zu teilen (kann von mehreren aufgerufen werden)
//SA_INTERRUPT // waere noch schneller und wir wuerden nicht teilen (sind gesperrt)
//SA_SAMPLE_RANDOM // tritt zufaellig auf
"Interrupt Reader", // name als kennung
&irq_parm); // waehlbarere kennung fuer das geraet

return(0);
}

/*--------------------------- cleanup_module() ------------------------------*/
/* KERNEL-MODUL Deklaration
** diese funktionsbezeichnung ist zu waehlen wenn der source als kernel-modul
** laufen soll
** diese funktion wird nach/zum beenden des modules aufgerufen und beendet sauber
** das modul
*/
// void cleanup_module(void)

/*----------------------------- drv_exit() ----------------------------------*/
/* KERNEL-TREIBER Deklaration
** diese funktionsbezeichnung ist zu waehlen wenn der source als kernel-treiber
** laufen soll
** diese funktion wird nach/zum beenden des treibers aufgerufen und beendet sauber
** den treiber
*/
static void __exit drv_exit(void)
{
printk("### Stop running Keyboard Interrupt-Reader... ###\n");

// nun geben wir den von uns angeforderten irq wieder frei
free_irq(
1, // interrupt nr
&irq_parm); // waehlbarere kennung fuer das geraet
}

/* KERNEL-TREIBER Deklaration
** diese funktionsbezeichnung ist zu waehlen wenn der source als kernel-treiber
** laufen soll
*/
module_init( drv_init );
module_exit( drv_exit );

folgendes korn shell script gibt die ausgabe ueber das 'topas' systeminformationstool in einem file aus. dieses script kann als cronjob eingebunden werden.

#!/bin/ksh
###############################################################################
# titel: ueber cronjob die ausgabe durch das tool topas in einem file sichern
# author: pec
# date: 20.08.2008
# vers: 01.01
# descr: $1 intervall 5
# $2 sleep in seconds 60
###############################################################################
#
# =============================================================================
# variablen
# =============================================================================
INTVL="$1"
SLEEP="$2"

LOGS="_topas"
LOGD="/tmp/diag/"
LOGT="/tmp/diag/diag_topas"

HH=0
MM=0
SS=0
MON=0
DAY=0
YY=0
TIMEE=0
TIMEF=0
LOGF=0

CNT=0

TERMVAR_OLD=0
TERMVAR_NEW="vt220"

#==============================================================================
#---------------------------------- the_time ----------------------------------
#==============================================================================
# function for time stamp
#------------------------------------------------------------------------------
the_time()
{
HH=$(date +%H)
MM=$(date +%M)
SS=$(date +%S)
MON=$(date +%m)
DAY=$(date +%d)
YY=$(date +%Y)
YEAR=$(date +%y)

TIMEE=$DAY"/"$MON"/"$YY" "$HH":"$MM":"$SS
TIMEF=$YY$MON$DAY"_"$HH$MM$SS

LOGF=$LOGD"ars_"$TIMEF$LOGS".log"
}

#==============================================================================
#--------------------------------- read_topas ---------------------------------
#==============================================================================
# cat and transfer topas output
read_topas()
{
# aktuelle terminal umgebungsvariable sichern und neue setzten
TERMVAR_OLD=$TERM
export TERM=$TERMVAR_NEW

while [ ${CNT} -lt $INTVL ]
do
echo "\n\n----------------------------------------" >> $LOGF
echo "Start recording: "$TIMEE"\n" >> $LOGF
(sleep $SLEEP; echo q) | topas > $LOGF 2>&1 1>$LOGF 2>$LOGF
echo "\n\nStop recording!\n" >> $LOGF
echo "----------------------------------------" >> $LOGF
CNT=`expr $CNT + 1`
the_time
done

# wieder alte umgebunsgvaribale setzten
export TERM=$TERMVAR_OLD
}
#-----------------------------------------------------------------------------

#==============================================================================
#---------------------------------- start of script ---------------------------
#==============================================================================

# timestamp
the_time

# main (topas) function
read_topas

#==============================================================================
#---------------------------------- end of script -----------------------------
#==============================================================================


folgender source loest das problem einen layer ueber ein flash movie zu legen. flash hat ja die angewohnheit sich gaaaaanz nach oben zu legen. dafuer gibt es ja eigentlich eine sehr einfache loesung. fuegt man in das <embeded-tag> das attribut wmode="opaque" ein loest dies das problem zumindest unter windows im firefox und ie. aber! im firefox unter linux scheint das problem damit nicht geloest zu sein. firefox ist eben nicht firefox. fuer linux clients muss man also deutlich tiefer in die trickkiste greifen. im prinzip funktioniert es so: ueber das flash wird ein leeres iframe positioniert, und zwar genau so gross und an genau der stelle an der man nun auch seinen dhtml-layer (z.B. ein <div>) haben moechte. also dhtml-layer ueber <iframe> ueber flash.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!--
Layering HTML div over Flash in Firefox on Linux - it's possible!

The general idea is to put an iframe between the embedded Flash and the HTML element we
want to have displayed over the Flash. Just use the usual z-index stuff.

The only hack here is that the iframe has to have "display: none" at first, which should
be changed to "block" via JavaScript. It *must* be done via JS, otherwise it won't work.
-->

<html>
<head>
<meta content="text/html; charset=UTF-8" http-equiv="Content-type">
<title>Layering HTML div over Flash on Linux</title>
</head>

<!-- display: block must be set by javascript, it doesn't work directly in CSS -->
<body onload='document.getElementById("iframe").style.display="block"' style="background: #042073;">

<!-- this iframe is above the Flash, but below the div -->
<iframe
src="javascript:false"
style="position: absolute; top: 110px; left: 220px; display: none; width: 102px; height: 32px; z-index: 5;"
id="iframe"
frameborder="0"
scrolling="no">
</iframe>
<!-- iframe width is width of the div + borders, so 100 + 1 + 1 = 102 -->

<!-- the div we want to be displayed above the Flash -->
<div style="position: absolute; top: 110px; left: 220px; z-index: 10; display: block; width: 100px; height: 30px; border: 1px solid green; background: #fff">
Yes, I am a HTML Div!
</div>

<!-- this is the Flash element which we want as background -->
<embed style="width: 800px; height: 600px;"
type="application/x-shockwave-flash"
src="myflashvideo.swf"
quality="best"
wmode="transparent"
></embed>
</body>
</html>