[C#] Header van ELF uitlezen

[Gehakt]

Ik moet tijdens een project voor school een applicatie schrijven in C#.
Hierbij moet ik een ELF bestand lezen en daarmee een ARM programmeren.

Ik heb verder geen les gehad in C# en mijn vraag is hoe ik bijvoorbeeld de header van een ELF file uitlees.

In C kon ik een structure over het bestand heen leggen en op deze manier de gegevens verkrijgen.
Is dit in C# op een vergelijkbare manier te bereiken? En waar kan ik daar informatie over vinden?

[lier]

Heb je al iets geprobeerd ?
Mijn eerste idee zou zijn dat je gebruik maakt van de StreamReader...zoek eens op Google (daar valt zeker wel iets te vinden).

[MTWZZ]

In C# is het zeker mogelijk om dit te doen.
Je kunt gewoon een struct maken en met de StructLayoutKindAttribute en FieldOffsetAttribute de struct zo inrichten dat je die direct kunt mappen vanaf binary data. Het mappen kun je doen met de Marshal.PtrToStructure method.
Als je met google op bovenstaande termen zoekt kom je volgens mij een artikeltje van CodeProject tegen waarin een voorbeeld staat.

[RobIII]

Op deze pagina lijken me voldoende resources te staan voor het ELF formaat.

Gehakt schreef op maandag 05 november 2007 @ 10:53:
Ik heb verder geen les gehad in C#

En toch die opdracht al? Vreemde school dan

Gehakt schreef op maandag 05 november 2007 @ 10:53:
In C kon ik een structure over het bestand heen leggen en op deze manier de gegevens verkrijgen.
Is dit in C# op een vergelijkbare manier te bereiken? En waar kan ik daar informatie over vinden?

Wat heb je zelf al gezocht/gevonden/geprobeerd? Al eens contact opgenomen met je docent/klasgenoten?

[Gehakt]

Ik zit op de opleiding embedded systemen. Daar krijg je eigenlijk alleen les in C en VHDL.
Binnen de opleiding hebben wij een ARM board wat door een leraar is gemaakt. Hier zit wat IO op waaronder USB.

Mijn opdracht is een bootloader schrijven voor het ARMboard en daarbij een applicatie die vervolgens de ARM kan programmeren via USB.

C# gebruiken leek mij het makkelijkst aan de windows kant.
Ik heb het al voor elkaar om via een Virtual COMMport gegevens van en naar het ARMboard te schrijven.

De volgende stap is het uit elkaar halen van een ELF file en het programma naar het ARMboard te verzenden.

Na het zien van de StreamReader class zie ik dat er ook 1 is voor lezen van binary bestanden.

Ik heb nu deze tutorial gevonden. http://msdn2.microsoft.com/en-us/library/36b93480.aspx
Echter hier word niet beschreven hoe ik bijvoorbeeld de volgende gegeven uit de header van het ELF bestand kan halen:

code:

typedef struct{
      Elf32_Word      p_type;
      (etc....)
}Elf32_Phdr;

Het project doe ik verder alleen en op klasgenoten hoef ik niet te rekenen want die hebben geen kaas gegeten van C#.

[ Voor 5% gewijzigd door Gehakt op 05-11-2007 12:30 ]

[MTWZZ]

Ik zal als ik vanavond thuis ben even wat voorbeeld code voor je opzoeken.
Ik heb een testje gemaakt waarmee je in ieder geval een deel van de ELF-header kunt uitlezen.
Via deze link heb ik de volgende struct gemaakt:

C#:

[StructLayout(LayoutKind.Explicit,Size=54)]
internal struct ElfHeader {
        [FieldOffset(0)]
        public byte e_ident;
        [FieldOffset(16)]
        public ushort       e_type;
        [FieldOffset(18)]
        public ushort       e_machine;
        [FieldOffset(20)]
        public uint       e_version;
        [FieldOffset(24)]
        public uint      e_entry;
        [FieldOffset(28)]
        public uint       e_phoff;
        [FieldOffset(32)]
        public uint       e_shoff;
        [FieldOffset(36)]
        public uint       e_flags;
        [FieldOffset(42)]
        public ushort       e_ehsize;
        [FieldOffset(44)]
        public ushort       e_phentsize;
        [FieldOffset(46)]
        public ushort       e_phnum;
        [FieldOffset(48)]
        public ushort       e_shentsize;
        [FieldOffset(50)]
        public ushort       e_shnum;
        [FieldOffset(52)]
        public ushort       e_shstrndx;
}

En met de volgende code kun je de ELF-header uitlezen en de byte[] array converteren naar de bovenstaande struct:

C#:

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;

public class elfreader {
        public static void Main(string[] args) {
                if(args.Length == 0) {
                        Console.Error.WriteLine("Usage: elfreader <file>");
                        return;
                }

                // Open een BinaryReader
                BinaryReader reader = new BinaryReader(File.OpenRead(file));

                // Maak een nieuwe instantie van de ElfHeader
                ElfHeader elfHeader = new ElfHeader();

                // Lees de header van een executable
                byte[] buff = new byte[Marshal.SizeOf(elfHeader)];
                reader.Read(buff, 0, Marshal.SizeOf(elfHeader));

                reader.Close();

                // Reserveer geheugen voor de ElfHeader
                IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(elfHeader));

                // Kopieer de ingelezen byte array naar het
                // gereserveerde geheugen
                Marshal.Copy(buff, 0, ptr, buff.Length);

                // Marshal vanuit het geheugen naar de
                // managed struct
                elfHeader = (ElfHeader)Marshal.PtrToStructure(ptr, typeof(ElfHeader));

                // Geef het geheugen weer vrij
                Marshal.FreeHGlobal(ptr);

                // En displayen
                Console.WriteLine("Type: {0}", elfHeader.e_type);
                Console.WriteLine("Version: {0}", elfHeader.e_version);
                Console.WriteLine("Program header offset: {0}", elfHeader.e_phoff);
                Console.WriteLine("Section header offset: {0}", elfHeader.e_shoff);
                Console.WriteLine("ELF header size: {0}", elfHeader.e_ehsize);
        }
}

Dit is overigens nog maar het begin maar het geeft je denk ik wel wat aanknopingspunten

[ Voor 95% gewijzigd door MTWZZ op 05-11-2007 20:09 ]

[Niemand_Anders]

Maar als je al in C(++) kunt programmeren, waarom zou je dan uberhaupt c# gaan gebruiken. Via C(++) vind ik zelf IO-poort programming een stuk eenvoudiger. C# mag dan wel een SerialPort class hebben, maar dit is een beperkte c++ wrapper.

Ook uit ontrafelen van bestanden vind ik gemakkelijker met C++. Soms wil ik nog wel via C++.net een wrapper schrijven om mijn C++ class bijvoorbeeld te kunnen gebruiken in C# of VB.

[Laurens-R]

Begrijp ik nou goed dat je een bootloader moet schrijven?

Een bootloader kan je niet in C# schrijven omdat deze de .net runtime nodig heeft (tenzij je toevallig over een prachtomgeving alla singularity beschikt)

Dan moet je toch al snel aan C en assembly denken.

EDIT: Excuus mijn gebrek aan ontwikkelkennis voor embedded software, heeft er weer eens voor gezorgd dat ik onzin zit te blaten.

[ Voor 20% gewijzigd door Laurens-R op 06-11-2007 17:32 ]

[Gehakt]

Hardstikke bedankt voor je hulp MTWZZ. Ik had vandaag alleen even geen tijd om er naar te kijken maar zal het morgen zeker doen.

En om het nog even een keer duidelijk te maken.
De bootloader word voor het ARMboard geschreven in plain C.
Deze komt in een soort programmeermodus zodra er bijv bij het opstarten een toets word ingedrukt.
Die laad vervolgens een usbstack voor communicatie via de USB poort.

Aan de kant van windows zal er dan een programma geschreven moeten worden dat een ELF file uitleest en het programma hieruit dus naar het ARMboard schrijft.

De bootloader moet er vervolgens voor zorgen dat deze informatie in het RAM geschreven word en dat dit vervolgens ook uitgevoerd word als het programmeren klaar is.

Aan de windows kant heb ik gekozen voor C# omdat mij dit de makkelijkste programmeertaal leek voor windows.
Ik heb totaal geen kaas gegeten van OOP dus ik dacht dan kan ik net zo goed met C# beginnen ipv C++.

Hopelijk is het nu wat duidelijker.

[farlane]

Gigantisch wat een hoop (ranzige) code voor zoiets simpels, misschien is het nog wel strakker om het inlees / wegschrijf gedeelte in C++ te doen.

[MTWZZ]

@farlane:
Ranzigheid valt nog mee hoor. Ik ben met je eens dat het in C++ "netter" is maar de TS vroeg om een C# voorbeeld dus die heb ik gemaakt

[farlane]

MTWZZ schreef op woensdag 07 november 2007 @ 08:47:
@farlane:
Ranzigheid valt nog mee hoor. Ik ben met je eens dat het in C++ "netter" is maar de TS vroeg om een C# voorbeeld dus die heb ik gemaakt

Dat snap ik en ik heb repect voor je dat je de moeite hebt genomen om het uit te zoeken; het is ook geen kritiek op de code and sich

Het doet me alleen erg denken aan bijvoorbeeld VB6 waar je bij het minste of geringste moet teruggrijpen naar API calls of ongedocumenteerde API's om om de tekortkomingen van de taal/runtime te kontdraaien.

[MTWZZ]

farlane schreef op woensdag 07 november 2007 @ 15:35:
Dat snap ik en ik heb repect voor je dat je de moeite hebt genomen om het uit te zoeken; het is ook geen kritiek op de code and sich

Zo vatte ik het ook niet op

Het doet me alleen erg denken aan bijvoorbeeld VB6 waar je bij het minste of geringste moet teruggrijpen naar API calls of ongedocumenteerde API's om om de tekortkomingen van de taal/runtime te kontdraaien.

Gelukkig wordt dit bij elke .Net release steeds een stukje minder.