[C++] Uitlezen binaire file, zoeken naar hexcode

[Jeroennl]

Ik zit met het volgende probleem ik lees een binair bestand in naar een variabele genaamd buffer. Hiermee wil ik gaan zoeken of een bepaalde hexcode voorkomt. Alleen zijn mijn waardes in de file 8bit dus ik heb gekozen voor char. Alleen levert deze char mij wat "rotzooi" op rondom mijn values.
Als gevolg van deze "rotzooi" kan ik niet vergelijken op hexcode of decimaal. Indien ik kies voor een short gaat alles goed alleen mis ik dan waardes(vb: 1 t/m 6 aanwezig 1,3,5 niet wenselijk dus zo vind ik mijn key niet.

Iemand enig idee hoe ik dit kan oplossen? In deze screenshot staat een voorbeeld van wat ik bedoel met betrekking tot verkeerde waardes, zie het watch scherm(gekozen voor hex weergave). Buffer bevat de juiste als char inclusief de niet wenselijke extra's zoals ÿ bijvoorbeeld. pt bevat de shorts wel correct alleen mis ik nu dus om en om een waarde.

Mijn code:

C++:

int main(array<System::String ^> ^args)
{
    FILE * f;
    char fname[FILENAME_MAX];
    long lSize;
    signed char * buffer;
    int result;
    int found_frame_key = 0;
    const int key_len = 8;

    sprintf_s(fname, FILENAME_MAX, "sense.raw");
    fopen_s(&f, fname, "rb");

    if(f) {
        fseek(f, 0, SEEK_END);
        lSize = ftell(f);
        fseek(f, 0, SEEK_SET);
        buffer = (signed char*) malloc((sizeof(signed char)*lSize));
        result = fread(buffer, 1, lSize, f);
        fclose(f);
    }


    int ssize = lSize/2;
    short *ps = (short *)buffer;
    short *pt = (short *)buffer;

    while(pt-ps < ssize-key_len) {
        if(pt[0] == 255 && pt[1] == 255 && pt[2] == 255 && pt[3] == 255 && pt[4] == 255 && pt[5] == 255) {
          found_frame_key = 1;
          break;
      }
      pt++;
    }
    if(found_frame_key) {
        printf("jeroen"); // alleen ter test implementatie ontbreekt.
    }
    getch();
}

[ Voor 0% gewijzigd door Jeroennl op 19-09-2008 17:48 . Reden: screenshot link klopte niet. ]

[.oisyn]

Waarom doe je die deling door 2 op regel 24?
Ah, je gebruikt shorts. Wat bedoel je met rotzooi. Wat is de data die je zoekt, in bytes? Als je je buffer als een char* blijft benaderen, dan zou je code moeten zoeken naar
FF FF FF FF FF FF

Momenteel zoek je naar
FF 00 FF 00 FF 00 FF 00 FF 00 FF 00

Aan je data in de hexeditor te zien zijn dat overigens wel signed shorts. Alle waarden liggen rond 0. Dus nogmaals, wat zoek je precies.

[ Voor 107% gewijzigd door .oisyn op 19-09-2008 18:02 ]

[Jeroennl]

Met rotzooi doel ik bijvoorbeeld op dat blokje wat achter 0x1 staat bij de value van buffer[0]. Wat ik verder hier nog bedoelde is dat de value van pt[0] gelijk is aan buffer[0] maar die van pt[1] niet aan die van buffer[1]. Hij slaat gewoon iedere keer een waarde over lijkt wel of die verloren is gegaan bij de conversie van char naar short.

Ik zoek om precies te zijn: FF 00 FF 00 FF 00 FF 00 00 00 00 00 00 00 00 00 deze key.

[.oisyn]

Logisch, een short is 2 bytes (op jouw machine). Als je de pointer dus met 1 ophoogt wijst hij naar de volgende short, 2 bytes verder. Denk eraan, a[b] is equivalent aan *(a+b). Pointers rekenen dus altijd in stapjes van het element waarnaar gewezen wordt, niet in bytes.

Maar begrijp ik het goed dat die key dus op elke positie kan beginnen, en dus niet alleen een veelvoud van 2? In dat geval kun je beter naar bytes zoeken in een char buffer. Kijk trouwens ook eens naar memcmp().

Maar, als je naar die specifieke key zoekt, waarom test je dan of pt[4] en pt[5] ook gelijk zijn aan 255?