Nanoreseau.net

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
Cet outil décode les entêtes des fichiers Nanoréseau et permet d'en extraire les sections binaires.

Exemple d'utilisation :

<code>
$ nrfile -e NRDOS.MO5

NRFile, version 1.0

File: NRDOS.MO5 (7552 bytes)

Header:
   Station identifier: "        " (default)
   File type: binary
   File mode: binary
   File status: read/write
   Nanoreseau version: 3.1
   Creation date: 27/05/85
   Last modification date: 27/05/85
   Created on a: TO7
   Created with: unreferenced application
   File attributes: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
                    00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
                    00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

Binary contents:
   Format: extended
   Target computer: MO5
   Target application: unreferenced application
   Loading flags: broadcast, load application first
   Application: "NRDOS"

   Code section 1:
      Size: 7373 bytes
      Load address: 00-5000 (do not switch RAM page)

      Section has been dumped to NRDOS.MO5-00-5000.bin.

   Execution address: 00-5000 (do not switch RAM page)
</code>

Code source :
<code>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Undefine this for Unix-like systems
#define PATH_WINDOWS

int gExtract = 0;

FILE *gSource = NULL;
unsigned char *gBuffer = NULL;
char *gFilename = NULL;
long gSize = 0;

char gIdentifier[9] = {0};
unsigned char gFileType = 0;

void TargetApp(unsigned char xByte)
{
    switch (xByte)
    {
    case 0:
        printf("unreferenced application");
        break;
    case 1:
        printf("BASIC 1.0");
        break;
    case 2:
        printf("LOGO");
        break;
    case 3:
        printf("LSE");
        break;
    default:
        printf("unknown application");
    }

}

void TargetComputer(unsigned char xByte)
{
     switch (xByte)
    {
    case 0:
        printf("TO7");
        break;
    case 1:
        printf("MO5");
        break;
    case 2:
        printf("TO7/70");
        break;
    default:
        printf("unknown computer");
    }
}

void PageSwitch(unsigned char xPage)
{
  switch (xPage)
        {
        case 0:
            printf("do not switch RAM page");
            break;

        case 0x40:
        case 0x41:
        case 0x42:
        case 0x43:
        case 0x44:
        case 0x45:
            printf("switch to RAM page %d",xPage-0x40);
            break;

        case 0x80:
        case 0x81:
        case 0x82:
        case 0x83:
            printf("switch to 64K RAM expansion page %d",xPage-0x80);
            break;

        case 0xff:
            printf("switch to internal ROM [BASIC]");
            break;

        default:
            printf("unknown RAM page");
        }
        printf(")\n");
}

void AnalyseBinExt(unsigned char *xpBuffer)
{
    long lOffset = 38;
    unsigned int lSection = 1, lSize = 0, lAddress = 0;
    char lBuffer[33] = {0};
    char *lFilename = NULL;
    unsigned char lPage = 0;
    FILE *lDump = NULL;

    printf("   Target computer: ");
    TargetComputer(xpBuffer[1]);
    printf("\n");

    printf("   Target application: ");
    TargetApp(xpBuffer[2]);
    printf("\n");

    printf("   Loading flags: ");
    if (xpBuffer[3]&0x80)
    {
        printf("broadcast");
    }
    if (xpBuffer[3]&0x40)
    {
        if (xpBuffer[3]&0x80)
        {
            printf(", ");
        }
        printf("load application first");
    }
    printf("\n");

    strncpy(lBuffer,(char*)xpBuffer+6,32);
    printf("   Application: \"%s\"\n\n",lBuffer);

    while (xpBuffer[lOffset]!=3)
    {
        printf("   Code section %d:\n",lSection);
        lSize = xpBuffer[lOffset+1]*256+xpBuffer[lOffset+2];
        lPage = xpBuffer[lOffset+5];
        printf("      Size: %d bytes\n",lSize);
        lAddress = xpBuffer[lOffset+3]*256+xpBuffer[lOffset+4];
        printf("      Load address: %02X-%04X (",lPage,lAddress);

        PageSwitch(lPage);
        printf("\n");

        if (gExtract)
        {
            lFilename = (char*)malloc(strlen(gFilename+11));
            sprintf(lFilename,"%s-%02x-%04x.bin",gFilename,lPage,lAddress);
            lDump = fopen(lFilename,"wb");
            fwrite(xpBuffer+lOffset+6,lSize,1,lDump);
            fclose(lDump);
            printf("      Section has been dumped to %s.\n\n",lFilename);
            free(lFilename);
        }

        lOffset += 6+lSize;

        lSection++;
    }

    lPage = xpBuffer[lOffset+5];
    printf("   Execution address: %02X-%04X (",lPage,xpBuffer[lOffset+3]*256+xpBuffer[lOffset+4]);
    PageSwitch(lPage);
}

void AnalyseBinSimple(unsigned char *xpBuffer)
{
    long lOffset = 0;
    unsigned int lSection = 1, lSize = 0, lAddress = 0;
    char *lFilename = NULL;
    FILE *lDump = NULL;

    while (xpBuffer[lOffset]==0)
    {
        printf("   Code section %d:\n",lSection);
        lSize = xpBuffer[lOffset+1]*256+xpBuffer[lOffset+2];
        printf("      Size: %d bytes\n",lSize);
        lAddress = xpBuffer[lOffset+3]*256+xpBuffer[lOffset+4];
        printf("      Load address: %04X\n",lAddress);
        printf("\n");

        if (gExtract)
        {
            lFilename = (char*)malloc(strlen(gFilename+11));
            sprintf(lFilename,"%s-%04x.bin",gFilename,lAddress);
            lDump = fopen(lFilename,"wb");
            fwrite(xpBuffer+lOffset+6,lSize,1,lDump);
            fclose(lDump);
            printf("      Section has been dumped to %s.\n\n",lFilename);
            free(lFilename);
        }

        lOffset += 5+lSize;
        lSection++;
    }

    printf("   Execution address: %04X\n",xpBuffer[lOffset+3]*256+xpBuffer[lOffset+4]);
}

void AnalyseBin(unsigned char *xpBuffer)
{
    printf("Binary contents:\n   Format: ");
    if (xpBuffer[0] == 1)
    {
       printf("extended\n");
       AnalyseBinExt(xpBuffer);
    } else
    {
       printf("simple\n\n");
       AnalyseBinSimple(xpBuffer);
    }
}

void ExtractFilename(char *xSrcStr, char **xStrDst)
{
    char *lPtr = strrchr(xSrcStr,
#ifdef PATH_WINDOWS
    '\\'
#else
    '/'
#endif // PATH_WINDOWS
    );

    if (lPtr==NULL)
    {
        *xStrDst = (char*) malloc(strlen(xSrcStr));
        strcpy(*xStrDst,xSrcStr);
    }
    else
    {
        *xStrDst = (char*) malloc(strlen(lPtr));
        strcpy(*xStrDst,lPtr+1);
    }
}

void usage()
{
    printf("Usage: nrfile [-e] filename\n");
}

int main(int argc, char *argv[])
{
    long i;

    printf("NRFile, version 1.0\n");
    if ((argc!=2)&&(argc!=3))
    {
        usage();
        return -1;
    }

    if (argv[1][0]=='-')
    {
        if (argc!=3)
        {
           usage();
           return -1;
        }
        if (argv[1][1] == 'e')
        {
            gExtract = 1;
        }
        else
        {
           usage();
           return -1;
        }
    } else if (argc!=2)
    {
           usage();
           return -1;
    }



    if (gExtract)
    {
        ExtractFilename(argv[2],&gFilename);
        gSource = fopen(argv[2],"rb");
    } else
    {
        ExtractFilename(argv[1],&gFilename);
        gSource = fopen(argv[1],"rb");
    }

    if (gSource == NULL)
    {
        printf("Error: cannot open file.\n");
        free(gFilename);
        return -2;
    }

    fseek(gSource,0,SEEK_END);
    gSize = ftell(gSource);
    fseek(gSource,0,SEEK_SET);

    gBuffer = malloc(gSize);
    if (gBuffer == NULL)
    {
        printf("Error: cannot allocate memory.\n");
        free(gFilename);
        fclose(gSource);
        return -3;
    }
    memset(gBuffer,0,gSize);

    fread(gBuffer,1,gSize,gSource);
    fclose(gSource);

    if (strnicmp((char*)gBuffer,"*NRUSTL*",8))
    {
        printf("Error: this file is not Nanoreseau compatible.\n");
        free(gBuffer);
        free(gFilename);
        return -4;
    }

    printf("\nFile: %s (%lu bytes)\n\n",gFilename,gSize);
    printf("Header:\n");

    strncpy(gIdentifier,(char *)gBuffer+8,8);
    printf("   Station identifier: \"%s\"",gIdentifier);
    if (strncmp(gIdentifier,"        ",8) == 0)
    {
        printf(" (default)");
    }
    printf("\n");

    gFileType = gBuffer[17];
    printf("   File type: ");
    switch (gFileType)
    {
    case 0:
        printf("BASIC program");
        break;
    case 1:
        printf("BASIC data");
        break;
    case 2:
        printf("binary");
        break;
    case 3:
        printf("source code");
        break;
    case 5:
        printf("indexed data");
        break;
    default:
        printf("unknown");
    }
    printf("\n");

    printf("   File mode: ");
    switch (gBuffer[18])
    {
    case 0:
        printf("binary");
        break;
    case 0xff:
        printf("ASCII");
        break;
    default:
        printf("unknown");
    }
    printf("\n");

    printf("   File status: ");
    switch (gBuffer[23])
    {
    case 0:
        printf("read/write");
        break;
    case 0xff:
        printf("write protected");
        break;
    default:
        printf("unknown");
    }
    printf("\n");

    printf("   Nanoreseau version: %d.%d\n",gBuffer[24],gBuffer[25]);

    printf("   Creation date: %02d/%02d/%02d\n",gBuffer[28],gBuffer[27],gBuffer[26]);
    printf("   Last modification date: ");
    if ((gBuffer[29] == 0)&&(gBuffer[30] == 0)&&(gBuffer[31] == 0))
    {
        printf("never");
    }
    else
    {
        printf("%02d/%02d/%02d",gBuffer[31],gBuffer[30],gBuffer[29]);
    }
    printf("\n");

    printf("   Created on a: ");
    TargetComputer(gBuffer[32]);
    printf("\n");

    printf("   Created with: ");
    TargetApp(gBuffer[33]);
    printf("\n");

    printf("   File attributes: ");
    for (i=80;i<96;i++)
    {
        printf("%02X ",gBuffer[i]);
    }
    for (i=96;i<128;i++)
    {
        if (i%16==0)
        {
            printf("\n                    ");
        }
        printf("%02X ",gBuffer[i]);

    }
    printf("\n\n");

    if (gFileType == 2)
    {
        AnalyseBin(gBuffer+128);
    }

    free(gBuffer);
    free(gFilename);
    return 0;
}

</code>