sixserv blog

welcome to teh #sixserv!

Archive for the ‘coding’ Category

Wordpress 2.7: “Volldampf Voraus”

ohne Kommentare


Bereits 2.6 machte einen großen Schritt, das Backend wurde umgestaltet, Versionierung der Artikel, Google Gears Unterstützung, zahlreiche Verbesserungen der Usability und sonstige Neuerungen machten Wordpress noch ein Stück mehr zu einen der besten Weblog-Applikationen die es gibt. Mit 2.7 setzen die Entwickler noch eins drauf, die Funktion zum Update eines Plugins direkt vom Backend aus war ja schon erster Schritt, doch mit 2.7 wird es möglich das gesamte Wordpress direkt vom Backend aus zu upgraden.

Core Update

Core Update

Ebenfalls ist nun eine Plugin-Suche direkt im Backend integriert und neue Plugins können mit einem einzigen Klick installiert werden. Außerdem soll in Zukunft ein neuer Code-Editor für Theme und Plugin-Dateien, Syntax-Highlighting unterstützen, davon ist jedoch in der aktuellen Entwickler-Version noch nicht viel zu sehen.

Plugin Suche

Plugin Suche

Wordpress-Deutschland hat die Agenda der wohl erfolgreichsten Weblog-Software, Wordpress zusammengestellt. Außerdem gibt es ein Screencast vom neuen Backend.

Update: Am Design des Backends hat sich noch viel geändert aber es ist Grundlegend in die neue WP Version 2.7 eingegangen. Ich finde es ist sogar noch gelungener geworden wie die Entwickler-Version vermuten lies.

Geschrieben von apoc

8. Oktober 2008 @ 17:34

Posted in coding, php, wordpress

Tagged with , ,

Rbot Remote

ohne Kommentare


Ich setze schon lange den grandiosen IRC-Bot “rbot” ein. Ein überaus vielseitiger und einfach zu erweiternder Bot, der dazu auch noch in meiner lieblings Script-Sprache Ruby geschrieben ist. Vielleicht komme ich dazu einige meiner Plugins, die ich für ihn geschrieben habe, hier zu Veröffentlichen.

Eines der Features von rbot welches ich erst kürzlich entdeckt habe und was absolut genial ist, ist das Rbot Remote Interface. Per Default hört der Bot nämlich auf Port 7268(127.0.0.1) und stellt dort ein DRb(Distributed Ruby) Interface zur Verfügung. Dieses erlaubt es von Außen den Bot zu steuern und beispielsweise Funktionen eines Plugins auszuführen. RbotRemote kann z.B. dazu genutzt werden bei neuen SVN-Commits im RSS Plugin das Updaten eines Commit-Feeds zu starten. Denkbar ist dies natürlich auch für neue Blog-Posts innerhalb von Wordpress etc.

Da DRb logischerweise nur für Ruby zur Verfügung steht muss bspw. eine PHP-Webapplikation ein Ruby-Skript starten welches die gewünschte Aktionen am rbot auslöst. Hier als Beispiel-Skript wird eine Nachricht an #sixserv(btw: im Freenode) gesendet:

#!/usr/bin/ruby
 
require 'drb'
 
rbot = DRbObject.new_with_uri("druby://localhost:7268")
id = rbot.delegate(nil, "remote login owner [Owner/Auth Passwort]")[:return]
rbot.delegate(id, "dispatch say #sixserv Hallo Welt!")

In /bin/rbot-remote gibt es ein ähnliches, etwas komplexeres Beispiel welches die Eingaben von stdin erwartet.

Eine weitere Möglichkeit ist wie schon erwähnt eine Methode eines Plugins zu starten. Hier ein ganz einfaches rbot-Plugin:

class SimplePlugin < Plugin
  def sayfoo(m, params)
    @bot.say '#sixserv', 'foo'
    if params.has_key?(:bar) then
      @bot.say '#sixserv', params[:bar]
    end
  end
end
 
plugin = SimplePlugin.new
plugin.map 'sayfoo'
plugin.map 'sayfoo :bar'

Wird die Methode extern aufgerufen kann man natürlich kein m.reply verwenden, wenn die Nachricht im Channel landen soll, ich habe das hier ganz einfach gelöst indem ich den Channel fest eingebunden habe. Hier noch das Skript welches sayfoo mit Parameter aufruft:

#!/usr/bin/ruby
 
require 'drb'
 
rbot = DRbObject.new_with_uri("druby://localhost:7268")
id = rbot.delegate(nil, "remote login owner [Owner/Auth Passwort]")[:return]
rbot.delegate(id, "dispatch sayfoo bar")

Geschrieben von apoc

15. September 2008 @ 23:14

Posted in rbot, ruby

Tagged with , , , , ,

Corporate Blogging mit User-Subdomains

mit einem Kommentar


Das Sixserv Blog ist ein Multiuser-Blog(d.h. Mehrere Autoren verfassen Artikel), unter der Hauptdomain(sixserv.org) sollten alle Artikel angezeigt werden. Wir wollten allerdings zusätzliche Subdomains(z.B. apoc.sixserv.org) die die Artikel des jeweiligen Autors anzeigt. Besonders wichtig dabei war das es möglich ist pro Subdomain unterschiedliche Themes zu verwenden.
Als Grundlage für dieses Vorhaben verwendete ich das Wordpress-Plugin Domain-Mirror von Dave McAleavy. Ich ergänzte es um die Möglichkeit pro Domain einen Benutzer sowie Theme eingeben zu können: Weiterlesen »

Geschrieben von apoc

2. September 2008 @ 02:44

Posted in coding, meta, php, wordpress

Tagged with , , ,

kernel mode sockets part 2 (the clean way)

mit 2 Kommentaren


version 0.1 -  30.08.2008

willkommen zu teil 2 der linux kernel mode socket serie. nun befassen wir uns mit einem sauberem weg der socketcalls vom kernel aus. auch hierfuer gibt es noch andere wege. in einem der naechstem teile bauen wir uns eine socket()-funktion selber, aber nun zum sauberem socket :D

auch hier muessen wir wieder set_fs/get_fs (man kann sie auch weglassen, aber in diesem fall garantiere ich fuer NICHTS, bzw das modul laesst sih 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 muessen wir uns nicht extra schreiben, hab ich zwischenzeitlich rausgfeunden in der “linux/inet.h” gibt es in_aton() :D

die hauptschwierigkeit besteht in den neuen strukturen iovec und msghdr. die ich allerdings anhand von kommentaren erklaeren werde, soweit wichtig, bzw unter den beiden links steht alles was man wissen muss (obwohl es nich spezifisch um die linux strukturen geht).

kommen wir nun zum code:

/*
* lkm_clean_socket.c - nks
*/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/socket.h>
#include <linux/net.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <net/sock.h>
#include <asm/uaccess.h>

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;  /* anzahl der elemente in iov */
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;  /* anzahl der elemente in iov */
msg.msg_control = NULL;
msg.msg_name = NULL;
msg.msg_namelen = 0;

old_fs = get_fs();
set_fs(KERNEL_DS);

set_fs(old_fs);

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

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr" lang="de-DE">
<head profile="http://gmpg.org/xfn/11">
<title>sixserv blog</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<meta name="description" content="welcome to teh #sixserv!" />
<meta name="generator" content="WordPress 2.6.1" /> <!-- leave this for stats please -->
<link href="http://sixserv.org/wp-content/themes/journalist/style.css" rel="stylesheet" type="text/css" media="screen" />
<link rel="alternate" type="application/rss+xml" title="sixserv blog RSS Feed" href="http://sixserv.org/feed/" />
<link rel="shortcut icon" type="image/x-png" href="http://sixserv.org/wp-content/the
....
# rmmod lkm_clean_socket.ko

wie man sehen kann ist unser buffer ein wenig zu klein, und die errnos kann man sich eigtl auch sparen wenn kein fehler auftritt.

seid gespannt auf den naechsten teil der kernel mode serie :D

nks

quellen:

ps:
cuil.com und metager2.de lassen sich beide in die suchleiste oben integrieren (klickt einfach auf den namen dann fragt euch FF). nach einigem testen gefaellt mir metager2 wesentlich besser weil es VIEL mehr findet. allerdings gefaellt mir die aufmachung von cuil.com, ich sehe noch einiges an potenzial.

pps:
mal wieder ein musikalischer tipp
http://www.myspace.com/blue_nine

Geschrieben von nks

30. August 2008 @ 02:34

Posted in coding, linux

Tagged with , , , ,

bitlet.org privacy

ohne Kommentare


ich nutze gerne den bittorrent-client “BitLet”. wirklich genial und einfach. zeigt sehr schoen wie man mit Java auch nicht resourcenfressende ressourcen-schonende torrent-clients schreiben kann, im gegensatz zu Azureus/Vuze. ich nutze BitLet recht haeufig jedoch bereitet mir schon seit laengerem sorgen, dass auf der startseite eine history der letzten torrents liegt. das ist natuerlich sehr prakitsch fuers resumen bzw um den aktuellen stand des downloads zu sehen und ihn bei bedarf zu loeschen oder zu resumen, allerdings liegen diese daten auf dem server von BitLet.org.
BitLet hat somit auf ihren servern eine datenbank laufen die die IPs logt mit denen die user ihre downloads taetigen und die entsprechenden namen der .torrent-Files (mit ausgelesenen meta-daten und download-fortschritt). das wird vermutlich ueber ein cookie realisiert.

also ab und zu mal cookies loeschen…

bleibt abzuwarten was sich daraus ergibt.

nks

links:

Geschrieben von nks

29. August 2008 @ 02:19

Posted in java, torrent

Tagged with , , ,

kernel mode sockets part 1 (the dirty way)

mit einem Kommentar


version 0.2 - 29.08.2008

kernel mode sockets sind hoch-interessant. im ersten teil befasse ich mich mit einer einfachen implementierung einses ziemlich simplen kernel mode sockets, das ist nicht der weg wie man es machen sollte allerdings hilft es erstmal dem grundsaetzlichem verstaendnis von lkm - also kernel modulen unter linux.

es ist natuerlich trotzdem moeglich diesen code in einem rootkit zu verwenden etc. aber ich finde das dieser code nichts in einem produktiven umfeld zu suchen hat, man oeffnet keine dateien aus derm kernel mode.

wir beginnen mit den basics eines lkm.

wir beginnen mit dem klassischem “Hello world.”:

/*
*  lkm_hello_world.c
*/
#include <linux/module.h>
#include <linux/kernel.h>

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 ueber den syscall “socketcall()” erstellen. um syscalls aus dem kernel aufrufen zu koennen gab es bis kernel 2.6.19 die syscall macros (fuer alle mit einem neuerem kernel habe ich einen kleinen header mti den macros hochgeladen), allerdings kann man eigtl keine syscalls vom kernel aus machen, damit wir das koennen muessen wir aus derm kernel-space addressraum in den user space addressraum, das geschieht hier per set_fs(). und schon kann man userspace calls ausfuehren.

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

#include <linux/module.h>
#include <linux/kernel.h>

#include <linux/socket.h>
#include <linux/net.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/netdevice.h>

#include <linux/init.h>
#include <linux/syscalls.h>

#include <linux/fcntl.h>
#include <asm/uaccess.h>
#include <linux/unistd.h>

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 koennen 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 ausgaber erscheint:

++ Kernel Mode Socket is up …

aber nur ein socket alleine ist ja bekanntlich ziemlich langweilig :D
also verbinden wir uns mit einem http server. hierfuer muessen wir noch ein paar anpassungen an unserem bestehendem code taetigen:

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

#include <linux/module.h>
#include <linux/kernel.h>

#include <linux/socket.h>
#include <linux/net.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/netdevice.h>

#include <linux/init.h>
#include <linux/syscalls.h>

#include <linux/fcntl.h>
#include <asm/uaccess.h>
#include <linux/unistd.h>
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;
}

wie 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 uebergabe der parameter verwenden wir ein char array bzw zwei da recv und send jeweils 4 argumente haben.

die syscall macros hab ich fuer euch hochgeladen

quellen:

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

nks

ps:
benutzt oefters 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…

Geschrieben von nks

29. August 2008 @ 01:38

Posted in coding, linux

Tagged with , , , ,