Autor Thema: MyOS - CDROM Verzeichnis auslesen  (Gelesen 6625 mal)

paule22

  • Beiträge: 16
    • Profil anzeigen
Gespeichert
« am: 26. November 2012, 22:47 »
Hallo,

hier der Source und das Image(ISO) von MyOS.
Im Moment stecke ich am Auslesen der Verzeichnisse der CDROM fest.
Kann da einer Helfen?

Hier der Link

http://www1.zippyshare.com/v/27224402/file.html

Kompiliert mit MinGW (win32 - XP)
Getestet unter VM Ware Player

Danke

Jidder

  • Administrator
  • Beiträge: 1 625
    • Profil anzeigen
Gespeichert
« Antwort #1 am: 26. November 2012, 22:47 »
Hi und willkommen an Board.

Was ist denn das genaue Problem?
Dieser Text wird unter jedem Beitrag angezeigt.

paule22

  • Beiträge: 16
    • Profil anzeigen
Gespeichert
« Antwort #2 am: 27. November 2012, 09:25 »
Hallo,

ich habe keine Idee/Plan wie man ein Joilet CD-ROM FS ausliest.
Also es fehlen mir Kentnisse in der Implementierung von den Funktionen: read und fseek - write fällt ja aus.
Desweitereren würde ich gerne eine Festplatte ansprechen so als FAT32 oder so, aber wie gesagt,
da fehlt mir die Kenntnis.

Gruß

kevin

  • Administrator
  • Beiträge: 2 767
    • Profil anzeigen
Gespeichert
« Antwort #3 am: 27. November 2012, 12:23 »
Liegt das Problem im Moment beim CD-Laufwerk oder beim Joilet-FS?

So wie du die Frage gestellt hast, vermute ich mal, dass dir beides noch fehlt. Dann solltest du erstmal auf der Blockebene ansetzen, d.h. erst einmal einfach nur Sektoren auslesen und vielleicht einen Hexdump ausgeben, ohne das Dateisystem darauf zu interpretieren. Dafür brauchst du einen ATAPI-Treiber. (siehe auch: http://www.lowlevel.eu/wiki/AT_Attachment - und dort vor allem die Specs unter Weblinks)

Anschließend kannst du darauf aufbauend einen Dateisystemtreiber bauen, der die Funktionen des Gerätetreibers benutzt, um an die Daten ranzukommen, die er braucht. Wenn du es richtig machst, hast du passende Abstraktionen drin, so dass man den FS-Treiber auch mit anderen Geräten oder das CD-Laufwerk mit anderen FS-Treibern benutzen kann.
Thou shalt not follow the NULL pointer, for chaos and madness await thee at its end.

paule22

  • Beiträge: 16
    • Profil anzeigen
Gespeichert
« Antwort #4 am: 27. November 2012, 12:37 »
Hallo kevin,

das CD-Laufwerk kann ich ja ansprechen.
Sektoren auslesen geht auch schon recht gut - siehe source: start.c

aber halt das Verzeichnis aulesen nicht.
Bin halt noch recht neu in der Programmierung.

Gruß

kevin

  • Administrator
  • Beiträge: 2 767
    • Profil anzeigen
Gespeichert
« Antwort #5 am: 27. November 2012, 15:00 »
Fang z.B. mal hier an: http://www.lowlevel.eu/wiki/ISO9660

Für Beispielcode kannst du dir den CDI-Treiber für iso9660 anschauen, wobei Janoschs Code nicht von allen für überdurchschnittlich lesbar empfunden wird. ;)
Thou shalt not follow the NULL pointer, for chaos and madness await thee at its end.

paule22

  • Beiträge: 16
    • Profil anzeigen
Gespeichert
« Antwort #6 am: 27. November 2012, 20:22 »
Hallo,

so, nun bin ich soweit, das ich einige Header ausgelesen habe:

http://www22.zippyshare.com/v/32161655/file.html

siehe Source: start.c

Aber ich weiss nicht, ob das so richtig ist.
kann da mal einer mal ein Auge drauf werfen?

reichen die Header oder müssen zusätzliche ausgelesen werden?
Danke

paule22

  • Beiträge: 16
    • Profil anzeigen
Gespeichert
« Antwort #7 am: 28. November 2012, 11:16 »
Hallo,

habe da den Source von start.c: , damit nicht das komplette archiv gesaugt werden muss ...
#include "arch.h"
#include "video.h"

#include "k_defines.h"
#include "ints.h"
#include "descriptor.h"
#include "pic.h"

#include "./drivers/mindrvr.h"


void testint(void);

extern int printf(char*,...);
extern int testfat(void);

extern int ticks;
extern int   InitializeMemoryManager(void);

extern short console_cursor_xpos;
extern short console_cursor_ypos;
extern int   console_color_attribut;

#define VK_A 0x1e61
#define VK_B 0x3062
#define VK_C 0x2e63
#define VK_D 0x2064
#define VK_E 0x1265
#define VK_F 0x2166
#define VK_G 0x2267
#define VK_H 0x2368
#define VK_I 0x1769
#define VK_J 0x246a
#define VK_K 0x256b
#define VK_L 0x266c
#define VK_M 0x326d
#define VK_N 0x316e
#define VK_O 0x186f
#define VK_P 0x1970
#define VK_Q 0x1071
#define VK_R 0x1372
#define VK_S 0x1f73
#define VK_T 0x1474
#define VK_U 0x1675
#define VK_V 0x2f76
#define VK_W 0x1177
#define VK_X 0x2d78
#define VK_Y 0x2c7a
#define VK_Z 0x1579

#define VK_BACKSPACE 0xe08
#define VK_RETURN 0x1c0d

#define VK_ESC 0x11b
#define VK_F1 0x3b00
#define VK_F2 0x3c00
#define VK_F3 0x3d00
#define VK_F4 0x3e00
#define VK_F5 0x3f00
#define VK_F6 0x4000
#define VK_F7 0x4100
#define VK_F8 0x4200
#define VK_F9 0x4300
#define VK_F10 0x4400

#define MAXKEYCODES 29

struct {
  unsigned short      keycode;
  unsigned int       extended;
  unsigned int          shift;
  char           *consolecode;
} __attribute__((packed)) GERMAN_KEYBOARD_STRUCT[MAXKEYCODES] = {
   VK_A, 0, 0, "a" ,
   VK_B, 0, 0, "b" ,
   VK_C, 0, 0, "c" ,
   VK_D, 0, 0, "d" ,
   VK_E, 0, 0, "e" ,
   VK_F, 0, 0, "f" ,
   VK_G, 0, 0, "g" ,
   VK_H, 0, 0, "h" ,
   VK_I, 0, 0, "i" ,
   VK_J, 0, 0, "j" ,
   VK_K, 0, 0, "k" ,
   VK_L, 0, 0, "l" ,
   VK_M, 0, 0, "m" ,
   VK_N, 0, 0, "n" ,
   VK_O, 0, 0, "o" ,
   VK_P, 0, 0, "p" ,
   VK_Q, 0, 0, "q" ,
   VK_R, 0, 0, "r" ,
   VK_S, 0, 0, "s" ,
   VK_T, 0, 0, "t" ,
   VK_U, 0, 0, "u" ,
   VK_V, 0, 0, "v" ,
   VK_W, 0, 0, "w" ,
   VK_X, 0, 0, "x" ,
   VK_Y, 0, 0, "y" ,
   VK_Z, 0, 0, "z" ,

   VK_BACKSPACE, 0,0, "\b" ,
   VK_RETURN,    0,0, "\n" ,

   0, 0, 0, "\0"
};

void nl(void)
{
  console_cursor_xpos = 0;
  console_cursor_ypos++;
}

struct CDROM_VolumeDescriptor
{
  unsigned char type;
  char ident[5];
  unsigned char version;
  char desc_type[2041];
} CD_VolumeDescriptor;

struct CDROM_BootRecord
{
  unsigned char type;
  char          ident[5];
  unsigned char version;
  char          sys_ident[32];
  char          boot_ident[32];
  char          boot_res[2048-64-7];
} CD_BootRecord;

struct CDROM_VolumeDescriptorSetTerminator
{
  unsigned char type;
  char ident[5];
  unsigned char version;
  char desc_type[2041];
} CD_VolumeSetTerminator;

struct CDROM_PrimaryVolumeDescriptor {
  unsigned char type;
  char          ident[5];
  unsigned char version;
  unsigned char unused_field_1;
  char          sys_ident[32];
  char          vol_ident[32];
  char          unused_field_2[8];
  int           vol_space_size;
  char          unused_field_3[32];
  int vol_set_size;
  int vol_seq_number;
  int log_block_size;
  int path_table_size;
  int location_L_path_table;
  int location_L_path_table_optional;
  int location_M_path_table;
  int location_M_path_table_optional;
  char root_directory_record[34];
  char volume_set_ident[128];
  char publisher_ident[128];
  char data_preparer_ident[128];
  char application_ident[128];
  char copyright_ident[37];
  char abstract_file_ident[37];
  char bib_file_ident[37];
  char volume_creation_date_time[17];
  char volume_modification_date_time[17];
  char volume_expiration_date_time[17];
  char volume_effective_date_time[17];
  int file_structure_version;
  int reserved_byte;
  char application_use[512];
  char reserved[653];
} CD_PrimaryVolume;

struct CDROM_VolumeTerminator {
  int type;
  char ident[5];
} CD_VolumeTerminator;

struct disk_packet
{
    byte size_pack;
    byte reserved1;
    byte no_of_blocks;
    byte reserved2;
    word offset;
    word segment;
    dword lba1;
    dword lba2;
} disk_pack;

void LBASectorRead(void *buffer, unsigned long lba)
{
    unsigned char bError = 0;
    REGS regs;

    disk_pack.size_pack = 16;
    disk_pack.no_of_blocks = 1;
    disk_pack.reserved1 = 0;
    disk_pack.reserved2 = 0;
    disk_pack.segment = (((unsigned int)buffer >> 16) << 12);
    disk_pack.offset  =  ((unsigned int)buffer & 0xffff);
    disk_pack.lba2 = lba >> 32;
    disk_pack.lba1 = lba & 0xffffffff;

regs.b.ds = (((unsigned int)&disk_pack >> 16) << 12);
regs.b.si =  ((unsigned int)&disk_pack &0xffff);
regs.b.dl = 0x9f;
regs.b.ah = 0x42;
int386(0x13,&regs,&regs);

    //printf("Error: %d\n",regs.b.ah);

}

int testint_flag = 0;

extern void testsector(void);

void BootMain(char *cmd)
{
  REGS regs;
  int i,c,k, pos = 0;
  char line[1024];
  short sx = 0,sy=15;

  //VideoClearScreen(0);
  printf("kaBOX Version 0.1 (c) 2005 Jens Kallup"); nl();
  printf("BETA-Version!"); nl(); nl();

  if (InitializeMemoryManager() == 0) {
    printf("Drücken Sie eine Taste zum Neustart des Computers.");  nl();
    ConsoleGetChar();
    VideoClearScreen(0);
    return;
  }

  //RunLoader();

  nl();
  //printf("1. --> %d\n", testint_flag);
  //int386(0x21,&regs,&regs);
  //printf("2. --> %d\n", testint_flag);

  nl();  // printf("ret from int 21"); nl();

  console_cursor_ypos = 15;

  {
//static unsigned char buffer[2048] = { 0 };
    //LBASectorRead(buffer,16);

LBASectorRead(&CD_VolumeDescriptor,16);
        CD_VolumeDescriptor.ident[5] = '\0';
printf(CD_VolumeDescriptor.ident);
nl();
if (CD_VolumeDescriptor.version == 0)
printf("CDVD: Boot Record.");
nl();


LBASectorRead(&CD_BootRecord,17);
CD_BootRecord.ident[5] = '\0';
printf(CD_BootRecord.ident); nl();
printf(CD_BootRecord.sys_ident); nl();
printf(CD_BootRecord.boot_ident); nl();


LBASectorRead(&CD_VolumeSetTerminator,18);
CD_VolumeTerminator.ident[5] = '\0';
printf(CD_BootRecord.ident); nl();
        printf("-----------"); nl();


LBASectorRead(&CD_PrimaryVolume,19);
CD_PrimaryVolume.ident[5] = '\0';
printf(CD_PrimaryVolume.ident); nl();


LBASectorRead(&CD_VolumeTerminator,20);
CD_VolumeTerminator.ident[5] = '\0';
printf(CD_VolumeTerminator.ident); nl();

  }

  nl();
  //printf("System erfolgreich geladen, bereit fuer Eingabe(n):>");
  nl(); nl();

  for (;;)
  {
    anfang:
    c = ConsoleGetChar();

    if ((c == VK_W)) {
      printf("ein w\n");
//int i = 0;
//int a = 2 / i;
printf("--> %d\n",c);

    }

    sx = console_cursor_xpos;
    sy = console_cursor_ypos;

    VideoGotoXY(50, 0);    printf("                       ");
    VideoGotoXY(50, 0);    printf("kcode: 0x%5x",c);
    VideoGotoXY(sx,sy);

    if (c == VK_BACKSPACE)
    {
      console_cursor_xpos--;

      if (console_cursor_xpos <= -1) {
        console_cursor_xpos = 79;
        console_cursor_ypos--;
      }

      if (console_cursor_ypos <= 0) {
        console_cursor_xpos = 0;
        console_cursor_ypos = 0;
      }

      VideoPutChar('_',console_color_attribut,console_cursor_xpos, console_cursor_ypos);
      VideoPutChar(' ',console_color_attribut,console_cursor_xpos+1, console_cursor_ypos);
      VideoGotoXY(console_cursor_xpos,console_cursor_ypos);
      goto anfang;
    }
    else if (c == VK_RETURN) {
      VideoGotoXY(0,++console_cursor_ypos);
      printf(":>_");
      VideoGotoXY(--console_cursor_xpos,console_cursor_ypos);
      goto anfang;
    }

    for (i = 0; i < sizeof(GERMAN_KEYBOARD_STRUCT); i++)
    {
      if (GERMAN_KEYBOARD_STRUCT[i].keycode == c) {
        printf("%s",GERMAN_KEYBOARD_STRUCT[i].consolecode);
        VideoPutChar('_',console_color_attribut,console_cursor_xpos, console_cursor_ypos);
      }
    }
  }
}

/*
 * Print only supports a-z and 0-9 and other keyboard characters
 */
void print(char *msg, unsigned int line)
{
char *vidmem = (char *)0xB8000;
    unsigned int i = line*80*2, color = 0x07;



while(*msg != 0)
{  
  vidmem[i] = *msg;
  i++;
  vidmem[i] = color;
  i++;
  *msg++;
}
}

void testint(void)
{
  print("TEST INT CALLED\n\n",10);
}

irgendwas stimmt da noch nicht mit den sectors.

Svenska

  • Beiträge: 1 792
    • Profil anzeigen
Gespeichert
« Antwort #8 am: 28. November 2012, 18:58 »
Hallo,

da deine structs genau die Datenstruktur im Dateisystem abbilden, solltest du sie alle mit "__attribute__((packed))" versehen, damit der Compiler keine Padding-Nullbytes dazwischen packt. Statt "int" solltest du außerdem Datentypen wie "uint32_t" u.ä. benutzen, die eine genau definierte und CPU-unabhängige Größe besitzen.

Prüfe mal deine Strukturen, ob die auch korrekt sind, z.B. ist ein "int vol_space_size" ein 32-Bit Integer, müsste aber laut Wiki 8 Bytes lang sein (4 Byte Little Endian, 4 Byte Big Endian).

Gruß,
Svenska

paule22

  • Beiträge: 16
    • Profil anzeigen
Gespeichert
« Antwort #9 am: 28. November 2012, 19:03 »
Hallo,

Danke für Deine Info.
kannst Du mir vielleicht eine Übersetzung "struct" für den Verzeichniseintrag machen?
Ich bin da etwas confused.
in lowlevel wird: 0x02    8    Erster Sektor des Datenbereichs (XE)
definert.
Die 8 - ist das ein char[8], int oder int64?

Svenska

  • Beiträge: 1 792
    • Profil anzeigen
Gespeichert
« Antwort #10 am: 28. November 2012, 19:18 »
Hallo,

da steht erstmal nur, dass der Eintrag acht Byte groß ist. Das sind char[8], uint32_t[2] oder uint64_t auch. Das "(XE)" ist weiter oben im Artikel als Both-Endian beschrieben, d.h. erst eine Little-Endian-Zahl, dann die gleiche Zahl nochmal in Big-Endian. Also ist in deiner Struct ein uint32_t[2] wohl die sinnvollste Darstellung (wobei du den zweiten Eintrag auf x86, x86_64 und den meisten ARMs ignorieren kannst).

Gruß,
Svenska

paule22

  • Beiträge: 16
    • Profil anzeigen
Gespeichert
« Antwort #11 am: 28. November 2012, 19:32 »
Ok, Danke,

dann gleich noch eine Frage:
http://www.lowlevel.eu/wiki/ISO9660#Verzeichniseintrag

die letzten 3 items 0x23 X ident

wie kann man das in eine Struktur unterbringen?
Habe folgende Form, aber da weiss ich nicht ob die richtig ist:

struct CDROM_DirectoryItem {
  unsigned char sizeof_diritem;
  unsigned char number_of_extsectors;
  __int64       first_sector;
  __int64 sizeof_datarange;
  unsigned char created_year;  // since 1900
  unsigned char created_month;
  unsigned char created_day;
  unsigned char created_hour;
  unsigned char created_minute;
  unsigned char created_second;
  unsigned char gmt;
  unsigned char flags;
  unsigned char sizeof_interleaved_files;
  unsigned char wideof_block_files
  __int32 volume_sequence_number;
  unsigned char length_ident;
} CD_DirectoryItem __attribute__((packed));

Svenska

  • Beiträge: 1 792
    • Profil anzeigen
Gespeichert
« Antwort #12 am: 28. November 2012, 21:10 »
Hallo,

der Inhalt dieser Felder ist für ISO9660 nicht spezifiziert, daher kannst du die erstmal ignorieren.

Gruß,
Svenska

paule22

  • Beiträge: 16
    • Profil anzeigen
Gespeichert
« Antwort #13 am: 28. November 2012, 21:49 »
Hallo Svenska,

ok.
hier nun die header. (die typen habe ich mal angepasst - types.h hab ich nicht, da gcc -nostdinclude
nun muss ich wissen,wie man an die Verzeichnisstruktur kommt.
Bitte kannst Du mir dabei helfen?

typedef unsigned char      __int8;
typedef unsigned short int __int16;
typedef unsigned       int __int32;
typedef long     long  int __int64;


struct CDROM_VolumeDescriptor
{
  unsigned char type;
  char ident[5];
  unsigned char version;
  char desc_type[2048-7];
} __attribute__((packed)) CD_VolumeDescriptor;

struct CDROM_BootRecord
{
  unsigned char type;
  char          ident[5];
  unsigned char version;
  char          sys_ident[32];
  char          boot_ident[32];
  char          boot_res[2048-64-7];
} __attribute__((packed)) CD_BootRecord;

struct CDROM_VolumeDescriptorSetTerminator
{
  unsigned char type;
  char ident[5];
  unsigned char version;
  char desc_type[2041];
} __attribute__((packed)) CD_VolumeSetTerminator;

struct CDROM_PrimaryVolumeDescriptor {
  unsigned char type;
  char          ident[5];
  unsigned char version;
  unsigned char unused_field_1;
  char          sys_ident[32];
  char          vol_ident[32];
  char          unused_field_2[8];
  int           vol_space_size;
  char          unused_field_3[32];
  int vol_set_size;
  int vol_seq_number;
  int log_block_size;
  int path_table_size;
  int location_L_path_table;
  int location_L_path_table_optional;
  int location_M_path_table;
  int location_M_path_table_optional;
  char root_directory_record[34];
  char volume_set_ident[128];
  char publisher_ident[128];
  char data_preparer_ident[128];
  char application_ident[128];
  char copyright_ident[37];
  char abstract_file_ident[37];
  char bib_file_ident[37];
  char volume_creation_date_time[17];
  char volume_modification_date_time[17];
  char volume_expiration_date_time[17];
  char volume_effective_date_time[17];
  int file_structure_version;
  char reserved_byte;
  char application_use[512];
  char reserved[653];
} __attribute__((packed)) CD_PrimaryVolume;

struct CDROM_VolumeTerminator {
  int type;
  char ident[5];
} __attribute__((packed)) CD_VolumeTerminator;

struct CDROM_DirectoryItem {
  __int8 sizeof_diritem;
  __int8 number_of_extsectors;
  __int64       first_sector;
  __int64 sizeof_datarange;
  __int8 created_year;  // since 1900
  __int8 created_month;
  __int8 created_day;
  __int8 created_hour;
  __int8 created_minute;
  __int8 created_second;
  __int8 gmt;
  __int8 flags;
  __int8 sizeof_interleaved_files;
  __int8 wideof_block_files;
  __int32 volume_sequence_number;
  __int8 length_ident;
  char ident[8];
} __attribute__((packed)) CD_DirectoryItem;

struct disk_packet
{
    byte size_pack;
    byte reserved1;
    byte no_of_blocks;
    byte reserved2;
    word offset;
    word segment;
    dword lba1;
    dword lba2;
} __attribute__((packed)) disk_pack;

void LBASectorRead(void *buffer, unsigned long lba)
{
    unsigned char bError = 0;
    REGS regs;

    disk_pack.size_pack = 16;
    disk_pack.no_of_blocks = 1;
    disk_pack.reserved1 = 0;
    disk_pack.reserved2 = 0;
    disk_pack.segment = (((unsigned int)buffer >> 16) << 12);
    disk_pack.offset  =  ((unsigned int)buffer & 0xffff);
    disk_pack.lba2 = lba >> 32;
    disk_pack.lba1 = lba & 0xffffffff;

regs.b.ds = (((unsigned int)&disk_pack >> 16) << 12);
regs.b.si =  ((unsigned int)&disk_pack &0xffff);
regs.b.dl = 0x9f;
regs.b.ah = 0x42;
int386(0x13,&regs,&regs);

    //printf("Error: %d\n",regs.b.ah);

}

...
  {
//static unsigned char buffer[2048] = { 0 };
    //LBASectorRead(buffer,16);

LBASectorRead(&CD_VolumeDescriptor,16);
        CD_VolumeDescriptor.ident[5] = '\0';
printf(CD_VolumeDescriptor.ident);
nl();
if (CD_VolumeDescriptor.version == 0)
printf("CDVD: Boot Record.");
nl();


LBASectorRead(&CD_BootRecord,17);
CD_BootRecord.ident[5] = '\0';
printf(CD_BootRecord.ident); nl();
printf(CD_BootRecord.sys_ident); nl();
printf(CD_BootRecord.boot_ident); nl();


LBASectorRead(&CD_VolumeSetTerminator,18);
CD_VolumeTerminator.ident[5] = '\0';
printf(CD_BootRecord.ident); nl();
        printf("-----------"); nl();


LBASectorRead(&CD_PrimaryVolume,16);
//CD_PrimaryVolume.ident[5] = '\0';
printf("%s",CD_PrimaryVolume.ident); nl();
printf("%d",CD_PrimaryVolume.location_L_path_table); nl();


LBASectorRead(&CD_DirectoryItem,24);
printf("i: %s",CD_DirectoryItem.ident); // hier wird nix ausgegeben
  }
...

Danke,
paule22

Svenska

  • Beiträge: 1 792
    • Profil anzeigen
Gespeichert
« Antwort #14 am: 29. November 2012, 00:36 »
Hallo,

hier nun die header. (die typen habe ich mal angepasst - types.h hab ich nicht, da gcc -nostdinclude
Ist vielleicht nicht so klug. Wenn du gcc -ffreestanding nimmst, kannst du die C-Standardheader (z.B. stdint.h, stdlib.h) benutzen. Die werden mit dem Compiler mitgeliefert und sind betriebssystem-unabhängig.

nun muss ich wissen,wie man an die Verzeichnisstruktur kommt.
Bitte kannst Du mir dabei helfen?
Nö, Doku lesen und umsetzen können musst du selbst. Außerdem hab ich das selbst noch nie gemacht. :-)

Du findest den Offset des Root-Ordners im primären Volume-Descriptor. Der Root-Ordner selbst enthält dann in seinem Datenbereich Dateien und weitere Unterverzeichnisse. Unterverzeichnisse enthalten dann in ihrem Datenbereich wieder Dateien und evtl. Unterverzeichnisse. Wenn du damit nicht weiterkommst, kannst du dir die entsprechenden Teile als Hexdump anschauen oder mit fertigem Code abgleichen (z.B. dem vorher genannten CDI-Treiber für tyndur).

Viel Erfolg,
Svenska

paule22

  • Beiträge: 16
    • Profil anzeigen
Gespeichert
« Antwort #15 am: 29. November 2012, 17:45 »
Hallo,

habe folgendes hexdump meines iso cd rom images:
http://www.freeimagehosting.net/htrkm

wenn ich nun, folgende struktur abbilde, erhalte ich keine ausgabe des namens(ident): https://gist.github.com/4170213

auch, wenn ich noch keinen Treiber benutze, müsste man doch die CD auslesen können?
Hat da jemand eine Idee, woran das nun liegen kann?

Gruß
paule22

Svenska

  • Beiträge: 1 792
    • Profil anzeigen
Gespeichert
« Antwort #16 am: 30. November 2012, 01:52 »
Hallo,

(a) Einen Hexdump macht man mit Hexadezimalzahlen. Die lassen sich besser lesen. :-)
(b) Ich vermute, du liest den falschen Sektor.

Probiere mal Sektor 17+x, Byte 40 für das CD-Label. (x >= 0 und kann bei jeder CD anders sein).

Gruß,
Svenska

paule22

  • Beiträge: 16
    • Profil anzeigen
Gespeichert
« Antwort #17 am: 30. November 2012, 12:30 »
Hi Svenska,

ich lese ab Sector 16 den Primary Volume Descriptor.
l_path verweisst auf Sektor 24
also springe ich da hin

MNemo

  • Beiträge: 547
    • Profil anzeigen
Gespeichert
« Antwort #18 am: 30. November 2012, 14:21 »
Was genau passiert denn? Wird was falsches ausgegeben oder schmiert alles ab?

Du legst nämlich 'dr' als lokale variable auf dem Stack an.
Dabei ist nur 1 Byte für den Namen reserviert, weil identifier vom type char[1] ist.
Wenn du dann die Struktur überschreibst (mit einem ganzen Sektor, mehr als den reservierten Bytes),
dann garantiert dir keiner, dass du damit nicht die Rücksprungadresse von LBASectorRead(falls das nicht geInlined wird) überschreibst, oder dass dir später niemand die Daten verpfuscht (Parameter und Rücksprungadresse von printf)
„Wichtig ist nicht, besser zu sein als alle anderen. Wichtig ist, besser zu sein als du gestern warst!“

paule22

  • Beiträge: 16
    • Profil anzeigen
Gespeichert
« Antwort #19 am: 30. November 2012, 22:46 »
So,
jetzt hab ich schonmal eine Datei, mit Sektorposition und Größe.
ich weiss nur nicht, ob das WORD so richtig ist.
verchiedene andere Datentypen gaben Salat, oder ich mach was falsch.
kann da mal einer ein Auge drüber werfen?
weil, ich denke mal dass das WORD nur 65535 Sektoren lesen kann???

Danke schonmal
paule22


typedef unsigned short WORD;

struct directory_record
{
  char res1[108];

  WORD version;
  WORD sector;
  WORD sector_opt1;
  WORD sector_opt2;
  WORD sector_opt3;
  WORD length;
  WORD length_opt1;
  WORD length_opt2;
  WORD length_opt3;

  char res2[10];

  BYTE ident_length;
  char ident[12];
} DIR_RECORD;


struct disk_packet
{
    byte size_pack;
    byte reserved1;
    byte no_of_blocks;
    byte reserved2;
    word offset;
    word segment;
    dword lba1;
    dword lba2;
} __attribute__((packed)) disk_pack;


void LBASectorRead(void *buffer, unsigned long lba)
{
    unsigned char bError = 0;
    REGS regs;

    disk_pack.size_pack = 16;
    disk_pack.no_of_blocks = 1;
    disk_pack.reserved1 = 0;
    disk_pack.reserved2 = 0;
    disk_pack.segment = (((unsigned int)buffer >> 16) << 12);
    disk_pack.offset = ((unsigned int)buffer & 0xffff);
    disk_pack.lba2 = lba >> 32;
    disk_pack.lba1 = lba & 0xffffffff;

regs.b.ds = (((unsigned int)&disk_pack >> 16) << 12);
regs.b.si = ((unsigned int)&disk_pack &0xffff);
regs.b.dl = 0x9f;
regs.b.ah = 0x42;
int386(0x13,&regs,&regs);
}




struct directory_record dr[2];
LBASectorRead( &dr,23);

dr[0].ident[dr[0].ident_length-2] = '\0';

printf("--> %d , ver: %x , sec: %d , len: %d",
sizeof(dr[0]),
dr[0].version,
dr[0].sector,
dr[0].length); nl();

printf("--> %d", dr[0].ident_length); nl();
printf("==> %s", dr[0].ident);


http://www.freeimagehosting.net/mf1tf

 

Einloggen