sixserv blog[nks] » Linux

opengl-background unter compiz

nks — Fri, 19 Sep 2008 15:53:50 +0000

Eine weitere nette Spielerei für Leute mit zu viel Ressourcen

Ich hab sie nicht aber das ganze läuft auch auf einem 700Mhz Duron flüssig.

Ihr benötigt “xscreensaver” (und auch das Paket “fireflies” falls ihr es wie auf den Screenshots haben wollt, wobei sich “pong” auch ganz gut macht) und “xwinwrap” (xwinwrap does teh magic)

nks@hydra ~ $ nice -n 15 /usr/bin/xwinwrap -ni -argb -fs -s -st -sp -b -nf -- /usr/lib/misc/xscreensaver/fireflies -window-id WID

Das ganze sieht dann so aus:

Für mehr Infos:

http://swik.net/xwinwrap

Man kann neben xscreensaver auch Videos als Hintergrund laufen lassen

nks

software-kvm mit synergy

nks — Fri, 19 Sep 2008 14:54:05 +0000

Mir ist gestern die Fernbedienung meiner Sourround-Anlage auf den Boden gefallen – jetzt ist sie unbrauchbar. Also dachte ich mir: “Hey, mach doch den eee-pc zu deiner neuen Fernbedienung!”.

Also wenn ich im bett liege und die lautstärke regeln will, schnell per ssh auf den Rechner verbinden und alsamixer nutzen. Aber dafür is der eee ja schon bisl overkill. Dann erinnerte ich mich an meine Experimente vor einem Jahr die beiden desktop-pcs miteinander zu verbinden.

Ich hatte es auch mit synergy versucht, aber es war ziemlich buggy. Aber die neue Version läuft wesentlich stabiler. Also schnell auf allen 3 boxen synergy gemerged und ab an die config:

# nks's synergy configuration file
# eeerr0r is the synergy-server
# infected and hydra are the clients

section: screens
infected:
hydra:
eeerr0r:
end

section: links
# larry is to the right of moe and curly is above moe
infected:
right = eeerr0r
eeerr0r:
left = infected
right = hydra
hydra:
left = eeerr0r
end
section: aliases
infected:
192.168.178.30
hydra:
192.168.178.32
eeerr0r:
192.168.178.25
end

Das ganze dann auf dem System welches Tastatur und Maus bereitstellen soll unter “/etc/synergy.conf”
und dann ab in die shell:

nks@eeerr0r ~ $ synergys -f --config /etc/synergy.conf

nks@infected ~ $ synergyc -f eeerr0r

nks@hydra ~ $ synergyc -f eeerr0r

Und schon kann ich vom eee-pc aus beide Rechner kvm-style fernsteuern
das ganze funktioniert auch unter windows und mac os.

Besonders schön is das ganze in Kombination mit compiz weil man dann vom Bett/anywhere aus ranzoomen kann

Informationen & links:

ps: chase & status releasen demnächst ihr neues Album, zwar ziemlich die uk-kommerz schiene, aber “hurt you” und “pieces” laufen atm ja fast in jedem set, also man kann gespannt sein (wobei “hurt you” auch auf dem neuem Album ist)

pps:Ich hatte damals auch mit xdmx ruexperimentiert, hehe.. vll. probier ich demnächst auch wieder etwas damit rum, allerdings mit compiz etwas zu lahm, in Kombination mit chromium funktioniert es vll besser.

nks

kernel mode sockets part 2 (the clean way)

nks — Sat, 30 Aug 2008 00:34:27 +0000

Version 0.3 - 23.01.2009

Willkommen zu teil 2 der linux kernel mode socket Serie. Nun befassen wir uns mit einem sauberem weg der socketcalls vom kernel aus. Auch hierfür gibt es noch andere Wege. In einem der nächsten Teile bauen wir uns eine socket()-Funktion selber, aber nun zum sauberem socket

Auch hier müssen wir wieder set_fs/get_fs (man kann sie auch weglassen, aber in diesem Fall garantiere ich für NICHTS, bzw das Modul lässt sich kompilieren aber die Funktion funktioniert im besten Fall nicht…) nutzen da file-Operationen im kernelmode nicht gestattet sind, der Zugriff auf sockets ist ein Dateizugriff. Die Funktion inet_addr müssen wir uns nicht extra schreiben, hab ich zwischenzeitlich herausgefunden in der “linux/inet.h” gibt es in_aton()

Die Hauptschwierigkeit besteht in den neuen Strukturen iovec und msghdr. Die ich allerdings anhand von Kommentaren erklären werde, soweit wichtig, bzw unter den beiden links steht alles was man wissen muss (obwohl es nicht spezifisch um die linux Strukturen geht).

Ab an den Code:

/*
 * lkm_clean_socket.c - nks
 */

#include

#include

#include

#include

#include

#include

#include 
#include 

int init_module(void)
{
	struct socket *socket;
	struct sockaddr_in saddr;
	int errno;
	char buffer[1024];
	struct msghdr msg;
	struct iovec iov;
	mm_segment_t old_fs;

	printk(KERN_INFO "#sixserv/sixserv.org presents:\n");
	printk(KERN_INFO "simple & clean kernel mode socket - nks\n");

	if ((errno = sock_create(PF_INET,SOCK_STREAM,IPPROTO_TCP,&socket))<0)
	{
		printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
		printk(KERN_INFO "-- ERRNO: %d..\n",errno);
		return 0;
	}
	else
        {
		printk(KERN_INFO "++ Kernel Mode Socket is up ...\n");
		printk(KERN_INFO "++ ERRNO: %d..\n",errno);
        }

	saddr.sin_addr.s_addr = in_aton("79.140.33.153");
	saddr.sin_port = htons(80);
	saddr.sin_family = AF_INET;

	if ((errno = socket->ops->connect(socket,(struct sockaddr*)&saddr,sizeof(saddr),0))<0)
	{
		printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
		printk(KERN_INFO "-- ERRNO: %d..\n",errno);
		return 0;
        }
        else
        {
		printk(KERN_INFO "++ Kernel Mode Socket is up an connected...\n");
		printk(KERN_INFO "++ ERRNO: %d..\n",errno);
        }

	iov.iov_base = "GET / HTTP/1.0\r\n\r\n";
	iov.iov_len = sizeof("GET / HTTP/1.0\r\n\r\n");

	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	msg.msg_control = NULL;
	msg.msg_controllen = 0;
	msg.msg_name = NULL;
	msg.msg_namelen = 0;
	msg.msg_flags	= 0;

	old_fs = get_fs();
	set_fs(KERNEL_DS);	

	if ((errno = sock_sendmsg(socket,&msg,sizeof("GET / HTTP/1.0\r\n\r\n")))<0)
	{
		printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
		printk(KERN_INFO "-- ERRNO: %d..\n",errno);
		set_fs(old_fs);
		return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is sending stuff...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
		set_fs(old_fs);
        }	

	iov.iov_base = buffer;
	iov.iov_len = 1024;

	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	msg.msg_control = NULL;
	msg.msg_name = NULL;
	msg.msg_namelen = 0;

	old_fs = get_fs();
	set_fs(KERNEL_DS);

	if ((errno = sock_recvmsg(socket,&msg,1024,0))<0)
        {
                printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
                set_fs(old_fs);
                return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is recieving stuff...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
                printk(KERN_INFO "++ Recieved: %s..\n",buffer);
		set_fs(old_fs);

        }
	return 0;
}

void cleanup_module(void)
{
	printk(KERN_INFO "Goodbye world.\n");
}

MODULE_LICENSE("GPL");

Ein weiteres mal passen wir unsere Makfeile an:

obj-m += lkm_clean_socket.o

all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

Nach einem make ist das modul fertig und liegt unter dem namen "lkm_clean_socket.ko" im aktuellem verzeichnis.
Wenn alles geklappt hat machen wir folgendes:

# modinfo lkm_clean_socket.ko filename: lkm_clean_socket.ko license: GPL depends: vermagic: 2.6.25-gentoo-r7 SMP mod_unload PENTIUM4 # insmod lkm_clean_socket.ko # dmesg .... ++ Kernel Mode Socket is up ... ++ ERRNO: 0.. ++ Kernel Mode Socket is up an connected... ++ ERRNO: 0.. ++ Kernel Mode Socket is sending stuff... ++ ERRNO: 19.. ++ Kernel Mode Socket is recieving stuff... ++ ERRNO: 1024.. ++ Recieved: HTTP/1.1 200 OK Date: Sat, 30 Aug 2008 00:18:58 GMT Server: Apache X-Powered-By: PHP/5.2.0-8+etch11 X-Pingback: http://sixserv.org/xmlrpc.php Connection: close Content-Type: text/html; charset=UTF-8 http://mail.nl.linux.org/kernelnewbies/2001-10/msg00079.html

http://docs.sun.com/app/docs/doc/819-2257/iovec-9s?a=view

http://www.dre.vanderbilt.edu/Doxygen/Stable/ace/structmsghdr.html

http://qos.ittc.ku.edu/netlink/html/node7.html

linux-2.4.34.1/ net/ khttpd/*

include/linux/net.h

/usr/src/linux/*

ps:
cuil.com und metager2.de lassen sich beide in die Suchleiste integrieren (klickt einfach auf den namen dann fragt euch FF). Nach einigem testen gefällt mir metager2 wesentlich besser weil es VIEL mehr findet. Allerdings gefällt mir die Aufmachung von cuil.com, ich sehe noch einiges an potenzial.

pps:
Mal wieder ein musikalischer Tipp:
http://www.myspace.com/blue_nine

edit: Unterschiede zu Version 0.1 haben nur mit der Rechtschreibung zu tun!

kernel mode sockets part 1 (the dirty way)

nks — Thu, 28 Aug 2008 23:38:53 +0000

Version 0.3 – 23.01.2009

Kernel mode sockets sind hoch-interessant. Im ersten teil befasse ich mich mit einer einfachen Implementierung eines ziemlich simplen kernel mode sockets, das ist nicht der Weg wie man es machen sollte allerdings hilft es erstmal dem grundsätzlichem Verständnis von lkm – also kernel modulen unter linux.

Es ist natürlich trotzdem möglich diesen Code in einem rootkit zu verwenden etc. aber ich finde das dieser Code nichts in einem produktiven Umfeld zu suchen hat, man öffnet keine Dateien aus derm kernel mode.

Wir beginnen mit den Basics eines lkm.

Zu erst das klassische “Hello world.”:

/*
*  lkm_hello_world.c
*/
#include

#include


int init_module(void)
{
printk(KERN_INFO "Hello world.\n");
}
void cleanup_module(void)
{
printk(KERN_INFO "Goodbye world.\n");

}

Zum kompilieren des Moduls legen wir nun ein Makefile an:

obj-m += lkm_hello_world.o

all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

Vielleicht hat der ein oder andere versucht die sys/socket.h (etc.) einzubinden, aber das geht nicht. man sollte das auch nicht machen da das user-mode includes sind. Also machen wir weiter, wir erstellen wir einen simplen (dirty) socket im kernel mode. Ich hab mich dazu entschieden das wir den socket über den syscall “socketcall()” erstellen. Um syscalls aus dem kernel aufrufen zu können gab es bis kernel 2.6.19 die syscall macros (für alle mit einem neuerem kernel habe ich einen kleinen header mit den macros hoch geladen), allerdings kann man eigtl keine syscalls vom kernel aus machen, damit wir das können müssen wir aus dem kernel-space Adressraum in den user space Adressraum, das geschieht hier per set_fs(). und schon kann man userspace calls ausführen.

/*
*  lkm_dirty_socket.c - nks
*/
#include "syscall_macros.h" /* auskommentieren wenn die kernel version
unter 2.6.19/18 ist! */

#include

#include


#include

#include

#include

#include

#include


#include

#include


#include

#include 
#include


int errno; /* needed by socketcall() */

/*
int socketcall(int call, unsigned long *args);
wie wir sehen koennen werden der funktion socketcall() 2 call uebergeben,
also benutzen wir das _syscall2-makro:
*/
static inline _syscall2(int, socketcall, int, call, unsigned long *, args);
int init_module(void)
{
        unsigned long arg[3];
        int socket;
        mm_segment_t old_fs;
        struct sockaddr_in addr;
        struct sockaddr_in saddr;

        printk(KERN_INFO "#sixserv/sixserv.org presents:\n");
        printk(KERN_INFO "simple kernel mode socket - nks\n");

        old_fs = get_fs();

        /* die argumente fuer socketcall vorbereiten*/
        arg[0] = PF_INET;
        arg[1] = SOCK_STREAM;
        arg[2] = 0;

        set_fs(KERNEL_DS);
        if ((socket = socketcall(1, arg)) == -1) // SYS_SOCKET = 1
        {
                printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
                printk(KERN_INFO "-- ERRNO: %d..\n",errno);
                set_fs(old_fs);
                return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is up ...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
        }

        return 0;
}

void cleanup_module(void)
{
        printk(KERN_INFO "Goodbye world.\n");
}

nun muessen wir die Makefile an das neue modul anpassen

obj-m += lkm_dirty_socket.o

all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

Nun können wir mit einem

# make
#insmod lkm_dirty_socket

das Modul bauen und laden, mit dmesg sollte man dann die Meldungen sehen ob es geklappt hat sieht man wenn der folgende text in der debug Ausgabe erscheint:

++ Kernel Mode Socket is up …

Aber nur ein socket alleine ist ja bekanntlich ziemlich langweilig
Also verbinden wir uns mit einem http Server. Hierfür müssen wir noch ein paar Anpassungen an unserem bestehendem Code tätigen:

/*
*  lkm_dirty_socket.c - nks
*/
#include "syscall_macros.h" /* auskommentieren wenn die kernel version unter 2.6.19/18 ist! */

#include

#include


#include

#include

#include

#include

#include


#include

#include


#include

#include 
#include

int errno; /* needed by socketcall() */

/*
int socketcall(int call, unsigned long *args);
wie wir sehen koennen werden der funktion socketcall() 2 parameter uebergeben,
also benutzen wir das _syscall2-makro:
*/
static inline _syscall2(int, socketcall, int, call, unsigned long *, args);
int init_module(void)
{
        unsigned long arg[3];
        int socket;
        mm_segment_t old_fs;
        struct sockaddr_in addr;
        struct sockaddr_in saddr;
        unsigned long arg1[3];
        unsigned long args[4];
        char buffer[1024];

        printk(KERN_INFO "#sixserv/sixserv.org presents:\n");
        printk(KERN_INFO "simple kernel mode socket - nks\n");

        old_fs = get_fs();

        arg[0] = PF_INET;
        arg[1] = SOCK_STREAM;
        arg[2] = 0;

        set_fs(KERNEL_DS);
        if ((socket = socketcall(1, arg)) == -1) // SYS_SOCKET = 1
        {
                printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
                printk(KERN_INFO "-- ERRNO: %d..\n",errno);
                set_fs(old_fs);
                return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is up ...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
        }

        saddr.sin_addr.s_addr = inet_addr("79.140.33.153");
        saddr.sin_port = htons(80);
        saddr.sin_family = AF_INET;
        /* argumente fuer connect():
            int connect(int sockfd, struct sockaddr *serv_addr, int addrlen );
        */
        arg1[0] = socket;
        arg1[1] =  (unsigned long)&saddr;
        arg1[2] =  (unsigned long)sizeof(saddr);

         if ((socketcall(SYS_CONNECT, arg1)) == -1)
        {
                printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
                printk(KERN_INFO "-- ERRNO: %d..\n",errno);
                set_fs(old_fs);
                return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is up an connected...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
        }

        /* argumente fuer send():
            send(int s, const void *buf, size_t len, int flags);
        */
        args[0] = socket;
        args[1] = "GET / HTTP/1.0\r\n\r\n";
        args[2] = strlen("GET / HTTP/1.0\r\n\r\n");
        args[3] = 0;

         if ((socketcall(SYS_SEND, args)) == -1)
        {
                printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
                printk(KERN_INFO "-- ERRNO: %d..\n",errno);
                set_fs(old_fs);
                return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is sending stuff...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);

        }

        /* argumente fuer recv():
            int recv(int s, void *buf, size_t len, int flags);
        */
        args[0] = socket;
        args[1] = (unsigned long) buffer;
        args[2] = 1024;
        args[3] = 0;

        if ((socketcall(SYS_RECV, args)) == -1)
        {
                printk(KERN_INFO "-- Kernel Mode Socket ERROR...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
                set_fs(old_fs);
                return 0;
        }
        else
        {
                printk(KERN_INFO "++ Kernel Mode Socket is recieving stuff...\n");
                printk(KERN_INFO "++ ERRNO: %d..\n",errno);
                printk(KERN_INFO "++ Recieved: %s..\n",buffer);

        }

       set_fs(old_fs);
       return 0;
}

void cleanup_module(void)
{
        printk(KERN_INFO "Goodbye world.\n");
}

unsigned int inet_addr(char *str)
{
        int a,b,c,d;
        char arr[4];
        sscanf(str,"%d.%d.%d.%d",&a,&b,&c,&d);
        arr[0] = a; arr[1] = b; arr[2] = c; arr[3] = d;
        return *(unsigned int*)arr;
}

Wieder ist eine neue Funktion hinzugekommen inet_addr, aber viel interessanter sind die neuen socketcalls, beim lesen kann man anhand des call-Arguments gut sehen welche socket-Funktion nun aufgerufen wird. zur Übergabe der Parameter verwenden wir ein char array bzw zwei da recv und send jeweils 4 Argumente haben.

Die syscall macros hab ich für euch hochgeladen

quellen:

http://www.linuxjournal.com/node/8110/print

http://www.ibm.com/developerworks/linux/library/l-system-calls/

http://www.ibm.com/developerworks/linux/library/l-lkm/

http://www.gnugeneration.com/mirrors/kernel-api/book1.html

http://www.tldp.org/LDP/lkmpg/2.6/html/

http://www.ussg.iu.edu/hypermail/linux/kernel/0303.2/2007.html (inet_addr())

http://google.com/codesearch/

http://lkml.org

http://kerneltrap.org

/usr/src/linux/*

syscall_macros.h

Bei fragen etc. kommt doch einfach ins irc (#nullserv/#sixserv im freenode)

nks

ps:
benutzt öfters mal google-alternativen.. http://cuil.com oder http://metager2.de

pps:
chillig, und wie ich finde sehr geil: http://www.myspace.com/17thboulevard
bin gespannt auf das album…