SoFS-Nutzung von Android Tablets

Bislang gab es nur Hinweise, wie SoFS von Windows und MacOS aus nutzbar ist. Aber auch von Android aus kann man dank Webdav gut auf SoFS zugreifen. Man installiert sich dazu aus dem Google Playstore zunächst den „Total Commander“ und darin dann das Webdav plugin. Dieses dann mit https(!) checken, sofsdav.uni-koeln.de/private/<username> als pfad, username und password konfigurieren und fertig! Dem Hin- und Her-Kopieren von Dateien zwischen Android-Device und SoFS steht nur noch die verfügbare Bandbreite im Wege…

Tipps zur Forensik nach Durcheinander auf Plattenbereichen

Dann und wann geschieht es: der lvm verliert seine Konfiguration oder durch andere traurige Umstände hat man lediglich noch einen Haufen „extents“ bekannter Länge vorliegen, die einmal eine Platte waren.
Dem Autor passierte dies beim versehentlichen Löschen einer falschen virtual Disk im IBM SVC („SAN Volume Controller“).
Bekannt war hier noch, dass ein Solaris UFS mit knapp 1TB Grösse verloren gegangen war.
Schaut man sich dann in Ruhe ein paar Grundlagen zu UFS-Datenstrukturen auf disk an, etwa in
http://www.informit.com/articles/article.aspx?p=605371&seqNum=2, und besorgt sich einige „magic“ Konstanten aus den guten alten .h-files in einem alten Solaris, kann man sich ein kleines C-Programm wie dieses

findb.c:
 #define _LARGEFILE64_SOURCE
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>

/*
#define FS_MAGIC 0x011954
#define CG_MAGIC 0x090255
*/

#define FS_MAGIC 0x54190100
#define FSMOFF 343
#define CG_MAGIC 0x55020900

#define NEXT 2113
#define ESIZE 512*1024*1024
static char edata[ESIZE];
#define HEADL 32768*2048
#define SBDIST 6495
#define SBONE 2

long *edata32;

main()
{
long rb;
int fd;
unsigned int extno,boff,isbi,x,cgno;
off64_t offs, offo;
 extno=0;
 edata32=&edata;
 fd=open("/dev/sdb",O_RDONLY);
 if (fd<0) { printf("open errorn"); exit(99); }

 while(extno < NEXT) {
 printf("reading extent number %dn",extno);
 rb=read(fd,edata,ESIZE);
 if(rb != ESIZE) { printf("short readn"); exit(98); }
/*  rb=read(fd,edata,HEADL);
 if(rb != HEADL) { printf("short readn"); exit(98); }
 offs=ESIZE-HEADL;
 offo=lseek64(fd,offs,SEEK_CUR);
 if(offo == (off64_t) -1 ) {printf("seek errorn"); exit(97);} */
/*  printf(" sb %08x cg %08x n",edata32[2050],edata32[4097]); */
 boff=0;
 while((boff*4) <ESIZE) {
/*  while((boff*4) <HEADL) { */
/*  if(edata32[343+boff]==FS_MAGIC) { printf("fs magic found, ext=%d off=%d sblkno= %08xn ",extno,boff/2048,edata32[2+boff]); */
/*  isb=SBONE;
 while(isb < NEXT*65536) {
 if((isb & 0x0ffff) == boff/2048) break;
 isb=isb+SBDIST;
 }
 printf("isb=%d, ext=%dn",isb,isb/65536);
 } */
 if(edata32[1+boff]==CG_MAGIC) {
 x=edata32[3+boff];
 cgno= (x>>24) |
 ((x<<8) & 0x00FF0000) |
 ((x>>8) & 0x0000FF00) |
 (x<<24);
 printf("CG_MAGIC match, ext=%d off=%d cgx=%d time=%08x cyls=%dn",extno,boff/2048,cgno,edata32[2+boff],edata32[4+boff]>>24); }
 boff=boff+2048;
 }
 extno=extno+1;
 }
}

schreiben, was in der hier wiedergegebenen Form für alle Cylindergroup-Strukturen den Wert deren offset „cgx“ ausgibt, eben den laufenden index der jeweiligen cyclindergroup Struktur. Beachte die Zweckmässigkeit des Programms (nur ganz notwendige Fehlerabfragen) und die Tricks, um Solaris/Sparc Zahlen (BigEndian) in Linux/X86 Zahlen (LittleEndian) umzurechnen (Konstanten wurden per Hand konvertiert).

Durch Sortieren der extents (bekannter Grösse) kann man so mit etwas Glück die originale Reihenfolge der extents rekonstruieren. Dabei hat dieses script gute Dienste geleistet:

fsbchain.sh:
#!/bin/sh -vx
SBONE=0
SB=$SBONE

sbf=xfb64ec.out

while true ; do
l1=`grep "cgx=$SB$" $sbf`
if [ $? -ne 0 ]; then
echo end of chain
exit
fi
echo $l1
set - $l1
SBEXT=$1
echo `echo $SBEXT | cut -d = -f 2`>>extlist
ln=`grep "$SBEXT " $sbf | tail -1`
echo $ln
SBL=`echo $ln | cut -d = -f 3`
SB=`expr $SBL + 1`
echo $SB
#read
done

Mit ein paar weiteren shell scripten, die sicherstellen, dass nur valide CG-Blocks gezählt werden (deswegen werden Grösse und Datum mit ausgegeben) und einem anderen kleinen Hilfsprogramm

copyb.c:
#define _LARGEFILE64_SOURCE
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <limits.h>

#define ESIZE 512*1024*1024
static char edata[ESIZE];

main(argc,argv)
int argc;
char *argv[];
{
long rb;
int infd, outfd;
unsigned int extno,boff,isbi,x,cgno;
off64_t ioffs, ooffs, offo;
int ein,eout;

 ein=atoi(argv[1]);
 eout=atoi(argv[2]);
 printf("copying extent %d to extent %dn",ein,eout);

 infd=open("/dev/sdb",O_RDONLY);
 if (infd<0) { printf("input open errorn"); exit(99); }
 outfd=open("/dev/sdc",O_RDWR);
 if (outfd<0) { printf("output open errorn"); exit(99); }

 ioffs=(off64_t) ein * ESIZE;
 ooffs=(off64_t) eout * ESIZE;
 printf("input seek to %llu output seek to %llun",ioffs,ooffs);
 offo=lseek64(infd,ioffs,SEEK_SET);
 if(offo < 0 ) {printf("input seek errorn"); exit(97);}
 offo=lseek64(outfd,ooffs,SEEK_SET);
 if(offo < 0 ) {printf("output seek errorn"); exit(97);}
 rb=read(infd,edata,ESIZE);
 if(rb != ESIZE) { printf("short readn"); exit(98); }
 rb=write(outfd,edata,ESIZE);
 if(rb != ESIZE) { printf("short writen"); exit(98); }

}

zum effektiven Zusammensetzen des disk /dev/sdc aus den Daten der /dev/sdb nach einer eingelesenen Steuerdatei der Form

[root@nisad-pc03 ~]# head -10 extlist
12
307
21
407
268
304
305
19
314
357
[root@nisad-pc03 ~]#

Ob ähnliches Vorgehen bei ext2/ext3 Filesystemen gelingen würde dort gibt es sogenannte block groups, die wohl den cylinder groups im ufs entsprechen, mit  s_block_group_nr (block group # of this superblock) wird sich bei Gelegenheit zeigen (müssen).

C95K iscsi mode parameter und VMware iscsi software initiator

Wir hatten wiederholbar Probleme mit dem iSCSI-Verkehr zwischen einem ESX-Host vmnode8 und einer LUN, die vom Cisco 9509 SAN-director per iSCSI durch das IPS-8 board bereitgestellt wurde. Zwischen vmnode8 und c95k-rzkj-1 war wenigstens 1 router, wenn die Probleme auftraten. In einer Konfiguration ohne router, d.h. mit VMware host und c95k an einem switch waren die Probleme nicht zu beobachten.

Das Problem äusserte sich dadurch, dass bei dem Versuch der Installation eines Windows-Servers oder der Einrichtung einer disk unter knoppix mit fdisk I/O-Fehler auftraten.

Debugging mit tcpdump auf einem entsprechend auf den vSwitch (der auf promiscuous mode accept einzustellen war) des iSCSI-kernel-interfaces eingerichteten Gast zeigte, daß für eine Serie von mit TCP-Push gesendeten Paketen weniger Ack-Pakete zurückkamen, allerdings die sequencenumber korrekt inkremementiert war auf die Zahl des letzten gesendeten Bytes.

Cisco bietet zur Konfiguration eines iSCSI-(target) interfaces u.a. den mode parameter an:

interface iscsi
To configure an iSCSI interface, use the interface iscsi command. To revert to default values, use the no form of the command.
interface iscsi slot/port
mode {pass-thru | store-and-forward}
tcp qos value
interface iscsi slot/port
no mode {pass-thru | store-and-forward | cut-thru}
no tcp qos value
no interface iscsi slot/port
Syntax Description
Defaults
Disabled.
The TCP QoS default is 0.
The forwarding mode default is store-and-forward.

Bei uns standen aber alle Interfaces auf „mode pass-thru“. Umsetzen auf den „neuen“ Standardwert „mode store-and-forward“ ergab das offenbar vom VMware software iSCSI-initiator gewünschte Verhalten: nun wird offenbar für jedes TCP-Push ein ACK gesendet. Damit geht der fdisk-Vorgang dann rasch erfolgreich zuende.

Freedom Universal Keyboard² am Nokia N810

Bei der Nutzung der Bluetooth-Tastatur Freedom Universal Keyboard² am Nokia N810 Internet-Tablet fällt unschön auf, dass die Taste mit den Zeichen <, > und | nicht nutzbar ist. Die Eingabe von | ist damit über das BT-keyboard nicht möglich, wenn es unter Einstellungen/Steuerung/Bluetooth-Tastatur als „Generic 105-key PC“ Bluetooth Tastatur eingestellt ist.

Erste Abhilfe gibt die Einstellung als „Nokia SU-BW“. Man hat dann aber  mit verschiedensten Fehlbelegungen der Tastatur (Abweichung von der Beschriftung) zu kämpfen.

Die Dateien zur Konfiguration der X11-Tastatur-Eingabe sind unter /usr/share/X11/xkb/symbols/ zu finden.

Folgende Änderung macht das Keyboard der Beschreibung entsprechend nutzbar:

$ diff -c pc.orig pc
*** pc.orig    
--- pc  
***************
*** 34,40 ****
      key <LFSH> {      [ Shift_L       ]       };
      key <LCTL> {      [ Control_L     ]       };
      key <LALT> {      [ Alt_L,        Meta_L          ]       };
!     key <LWIN> {      [ Super_L                       ]       };

      key <RTSH> {      [ Shift_R       ]       };
      key <RCTL> {      [ Control_R     ]       };
--- 34,40 ----
      key <LFSH> {      [ Shift_L       ]       };
      key <LCTL> {      [ Control_L     ]       };
      key <LALT> {      [ Alt_L,        Meta_L          ]       };
!     key <LWIN> {      [ less, greater, bar, brokenbar                 ]       };

      key <RTSH> {      [ Shift_R       ]       };
      key <RCTL> {      [ Control_R     ]       };
$

Damit wird die Taste mit den Symbolen <, > und | von ihrer Bedeutung als Super-L(„Windows“)-Taste auf die gewünschte Interpretation umkonfiguriert.

Zusätzlich ist es nett, durch

$ diff -c de.orig de
*** de.orig     2009-01-26 09:14:28.000000000 +0100
--- de  2009-01-26 09:15:04.000000000 +0100
***************
*** 14,20 ****
      key <AE02>        { [         2,   quotedbl,  twosuperior,    oneeighth ] };
      key <AE03>        { [         3,    section, threesuperior,    sterling ] };
      key <AE04>        { [         4,     dollar,   onequarter,     currency ] };
!     key <AE11>        { [    ssharp,   question,    backslash, questiondown ] };
      key <AE12>        { [dead_acute, dead_grave, dead_cedilla,  dead_ogonek ] };

      key <AD03>        { [         e,          E,     EuroSign,     EuroSign ] };
--- 14,21 ----
      key <AE02>        { [         2,   quotedbl,  twosuperior,    oneeighth ] };
      key <AE03>        { [         3,    section, threesuperior,    sterling ] };
      key <AE04>        { [         4,     dollar,   onequarter,     currency ] };
! //    key <AE11>      { [    ssharp,   question,    backslash, questiondown ] };
!     key <AE11>        { [    ssharp,   question,    backslash, bar ]  };
      key <AE12>        { [dead_acute, dead_grave, dead_cedilla,  dead_ogonek ] };

      key <AD03>        { [         e,          E,     EuroSign,     EuroSign ] };
$

dafür zu sorgen, dass die Eingabe von Shift-AltGr-ß ein |-Zeichen (bar) erzeugt. Auf das Zeichen „questiondown“ kann meiner Meinung nach verzichtet werden.

Nettes Hilfswerkzeug für solche Dinge sind die auf dem N810 nicht vorhandenen X11-tools xev und xmodmap, die unter

http://maemo.lancode.de/?path=./diablo/binary

zu finden sind. Klar, dass all diese Dinge auch mit xmodmap zu erreichen sind, aber es fand sich nicht schnell eine Stelle, wo so ein xmodmap-command im system-startup zu verankern wäre. Die oben aufgezeigten config-changes werden jedoch einfach schon nach einem reboot wirksam.

Sonderzeichen vertical bar auf die Tastatur legen

Etwas unhandlich beim Nutzen des N810 Internet-Tablets mit deutscher Tastatur besonders als ssh-client zur Linux-Administration ist, dass das |-Zeichen (bar) nicht direkt zugänglich ist, sondern durch erst Drücken der Chr-Taste auf dem Bildschirm und dann noch erst nach scrollen des visuellen keyboards gedrückt werden kann.

Eine kleine Anpassung in der Datei

/usr/share/X11/xkb/symbols/nokia_vndr
$ diff -c rx-44.orig rx-44
*** rx-44.orig 
--- rx-44      
***************
*** 156,162 ****
      key <AC09>        {       [       l,              L,              parenright,     parenright      ]       };
      key <AC11>  {     [       udiaeresis,     Udiaeresis,     question,       question        ]       };

!     key <AB01>        {       [       y,              Y,              EuroSign,       EuroSign        ]       };
      key <AB02>        {       [       x,              X,              asciitilde,     asciitilde      ]       };
      key <AB03>        {       [       c,              C,              asterisk,       asterisk        ]       };
      key <AB04>        {       [       v,              V,              ampersand,      ampersand       ]       };
--- 156,163 ----
      key <AC09>        {       [       l,              L,              parenright,     parenright      ]       };
      key <AC11>  {     [       udiaeresis,     Udiaeresis,     question,       question        ]       };

! //    key <AB01>      {       [       y,              Y,              EuroSign,       EuroSign        ]       };
!     key <AB01>        {       [       y,              Y,              bar,    bar     ]       };
      key <AB02>        {       [       x,              X,              asciitilde,     asciitilde      ]       };
      key <AB03>        {       [       c,              C,              asterisk,       asterisk        ]       };
      key <AB04>        {       [       v,              V,              ampersand,      ampersand       ]       };
$

sorgt dafür, dass Fn-Y nach dem nächsten reboot statt dem €-Symbol ein |-Symbol schreibt. Das €-Zeichen ist nach wie vor über die Bildschirmtastatur (durch Chr einblendbar) verfügbar.