Variabelen lezen uit het geheugen via een pointer

[SvMp]

Ik wil vanuit een blok bytes variabelen lezen.
Deze variabelen kunnen allerlei groottes hebben (8-bit, 16-bit, 32-bit) en overal staan.

Bijvoorbeeld: Het lezen van een bootsector van een diskette, en daar een willekeurig 16-bits getal uithalen.
Dit valt niet mee helaas...

(voor Unix/Linux)

code:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main() {
    void *bootsector;
    int fd;

    fd=open("/dev/fd0",O_RDONLY);
    if (fd<0) {
        printf("Error while opening /dev/fd0.\n");
        return(-1);
    }

    bootsector=malloc(512);
    lseek(fd,0,SEEK_SET);
    read(fd,bootsector,512);

    printf("%x\n", (unsigned short int) *( ((unsigned short int*)bootsector) + 255 ) );

    close(fd);
    free(bootsector);
}

Dit progje leest de bootsector van een diskette, en zet het laatste 16-bits getal op het scherm. Bij bootsectors is dit standaard 0xaa55.
Natuurlijk geen zinvol programma, maar het is als test, en het is het begin van iets dat wel wat zinnigs gaat doen.

Ik lees eerst de 512 bytes van de bootsector in een ruimte waarnaar de pointer bootsector wijst.
Daarna probeer ik een waarde te lezen.
In dit geval een 16-bits getal, dat op de 510e byte staat (vanaf 0 geteld uiteraard).

code:

(unsigned short int) *( ((unsigned short int*)bootsector) + 255 )

Als eerste moet hij weten dat het een 16 bits unsigned getal is, vervolgens moet ik de pointer bootsector verhogen.
Maar nu het gekke: Omdat het om 16-bits getallen gaat, wordt ook verwacht dat ik in eenheden van 16-bits reken, terwijl het gewoon om een blok bytes gaat!
Dus in plaats van 510 moet ik 255 als offset gebruiken.

Als ik nou het laatste byte wil hebben, kan ik daar gewoon met +511 bij, want met bytes werk je ook in eenheden van bytes.

Maar wel dat ik nou bv. het 3e 16-bits getal wil hebben?
Kan ik dat voorelkaar krijgen zonder allemaal gegoochel met losse bytes? (oftewel: In een keer een 16-bits getal uitlezen op welke byte postitie dan ook, of in een keer een 16-bits getal uitlezen, op welke byte positie dan ook)

[Creepy]

unsigned char *bootsector gebruiken zodat je met
bootsector[0] de eerste byte hebt, bootsector[2] de derde byte etc?

en dan een unsigned unsigned short int *positie daarnaar toe laten wijzen?

*positie = bootsector[511];

alles ongetest uiteraard.. tis maar een idee..



met

code:

(unsigned short int) *( ((unsigned short int*)bootsector) + 255 )

cast je bootsector om naar een short int. dus bootsector + 255 zal 255 * de size van een short int erbij op tellen