home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / monitors / rsys / source.lha / src / RSysCheckOffsets.c < prev    next >
C/C++ Source or Header  |  1995-01-09  |  8KB  |  358 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *    RSysCheckOffsets.c
  6. *
  7. * Inhalt:
  8. *    void PrintLibOffsets(struct _liblist *liblist);
  9. *    void PrintDevOffsets(struct _devlist *devlist);
  10. *    void SysCheckOffs(void);
  11. *
  12. * Bemerkungen:
  13. *    Ermittlung der gepatchten Libraries und Devices im ROM.
  14. *
  15. * Erstellungsdatum:
  16. *    07-Jul-93    Rolf Böhme
  17. *
  18. * Änderungen:
  19. *    07-Jul-93    Rolf Böhme    Erstellung
  20. *
  21. ***************************************************************************
  22. */
  23.  
  24. #include "RSysFunc.h"
  25.  
  26. static struct func
  27. {
  28.    UWORD jmp;                   /* Assembler-Befehl jmp */
  29.    ULONG adr;                   /* Sprungadresse */
  30. };
  31.  
  32. struct Remember *FKey = NULL;
  33.  
  34. #define FKEY            ((struct Remember **)&FKey)
  35. #define ALLOCF(size)    AllocRemember(FKEY,(size),MEMF_CLEAR)
  36. #define FREEF(flag)     FreeRemember(FKEY,(flag))
  37.  
  38. struct List FuncList;
  39.  
  40. #define MAGIC_ROM_END   ((ULONG)0x01000000)
  41. #define MAGIC_ROM_SIZE  ((ULONG)(*((ULONG *)0x00FFFFEC)))
  42.  
  43. static ULONG kickromstart;
  44.  
  45. #define FUNCOFFS sizeof(struct func)
  46.  
  47. struct _liblist {
  48.    struct Library    *library;
  49.    UBYTE              libname[19];
  50.    ULONG              firstoff,
  51.                       lastoff;
  52. } libs[] =
  53. {
  54.    { NULL,(UBYTE *)"dos.library",         30L,0L },
  55.    { NULL,(UBYTE *)"exec.library",        30L,0L },
  56.    { NULL,(UBYTE *)"expansion.library",   30L,0L },
  57.    { NULL,(UBYTE *)"gadtools.library",    30L,0L },
  58.    { NULL,(UBYTE *)"graphics.library",    30L,0L },
  59.    { NULL,(UBYTE *)"icon.library",        30L,0L },
  60.    { NULL,(UBYTE *)"intuition.library",   30L,0L },
  61.    { NULL,(UBYTE *)"keymap.library",      30L,0L },
  62.    { NULL,(UBYTE *)"layers.library",      30L,0L },
  63.    { NULL,(UBYTE *)"mathffp.library",     30L,0L },
  64.    { NULL,(UBYTE *)"utility.library",     30L,0L },
  65.    { NULL,(UBYTE *)"workbench.library",   30L,0L }
  66. };
  67.  
  68. #define LIBCNT   sizeof(libs)/sizeof(struct _liblist)
  69.  
  70. struct _devlist {
  71.    struct Library    *device;
  72.    UBYTE              devname[19];
  73.    ULONG              firstoff,
  74.                       lastoff,
  75.                       flags;
  76.    long               unit;
  77. } devs[] =
  78. {
  79.    { NULL,(UBYTE *)"console.device",     42L, 0L,(ULONG)(-1), -1L},
  80.    { NULL,(UBYTE *)"input.device",       42L, 0L,(ULONG)0, 0 },
  81. /*   { NULL,(UBYTE *)"ramdrive.device",    42L, 0L,(ULONG)0, 0 }*/
  82. };
  83.  
  84. #define DEVCNT   sizeof(devs)/sizeof(struct _devlist)
  85.  
  86.  
  87. static void
  88. KillMemory(int kill)
  89. {
  90.    FREEF(TRUE);
  91.  
  92.    if(kill)
  93.       ErrorHandle(MEMORY_ERR, ALLOC_FAIL, KILL);
  94.  
  95.    return;
  96. }
  97.  
  98. static void
  99. makeblank(void)
  100. {
  101.    struct Node *blanknode = ALLOCF(sizeof(*blanknode));
  102.  
  103.    if(blanknode)
  104.    {
  105.       AddTail(&FuncList,blanknode);
  106.       return;
  107.    }
  108.  
  109.    KillMemory(KILL);
  110. }
  111.  
  112. static void
  113. makehead(UBYTE *title)
  114. {
  115.    struct Node *newnode = ALLOCF(sizeof(*newnode));
  116.  
  117.    if(newnode && (newnode->ln_Name = ALLOCF(strlen((char *)title)+1+5)))
  118.    {
  119.       sprintf(newnode->ln_Name,"---- %s",(char *)title);
  120.       AddTail(&FuncList,newnode);
  121.  
  122.       return;
  123.    }
  124.  
  125.    KillMemory(KILL);
  126. }
  127.  
  128. static void
  129. makerominfo(UBYTE *title, ULONG num)
  130. {
  131.    struct Node *newnode = ALLOCF(sizeof(*newnode));
  132.  
  133.    if(newnode && (newnode->ln_Name = ALLOCF(strlen((char *)title)+3+12)))
  134.    {
  135.       sprintf(newnode->ln_Name,"%s : 0x%08lx",(char *)title, num);
  136.       AddTail(&FuncList,newnode);
  137.  
  138.       return;
  139.    }
  140.  
  141.    KillMemory(KILL);
  142. }
  143.  
  144. static void
  145. makeromsizeinfo(UBYTE *title, ULONG num)
  146. {
  147.    struct Node *newnode = ALLOCF(sizeof(*newnode));
  148.  
  149.    if(newnode && (newnode->ln_Name = ALLOCF(strlen((char *)title)+3+12)))
  150.    {
  151.       sprintf(newnode->ln_Name,"%s : %lD Bytes",(char *)title, num);
  152.       AddTail(&FuncList,newnode);
  153.  
  154.       return;
  155.    }
  156.  
  157.    KillMemory(KILL);
  158. }
  159.  
  160. static void
  161. makeinfo(struct _liblist *ll)
  162. {
  163.    struct Node *newnode = ALLOCF(sizeof(*newnode));
  164.  
  165.    if(newnode && (newnode->ln_Name = ALLOCF(50)))
  166.    {
  167.       sprintf(newnode->ln_Name,"(%4ld functions, Address: 0x%08lx)",
  168.              (ll->library->lib_NegSize / 6), ll->library);
  169.  
  170.       AddTail(&FuncList,newnode);
  171.  
  172.       return;
  173.    }
  174.  
  175.    KillMemory(KILL);
  176. }
  177.  
  178. static void
  179. makeentry(long offs,ULONG adr)
  180. {
  181.    struct Node *newnode = ALLOCF(sizeof(*newnode));
  182.  
  183.    if(newnode && (newnode->ln_Name = ALLOCF(50)))
  184.    {
  185.       sprintf(newnode->ln_Name,"offs: -%5ld addr: 0x%08lx", offs, adr);
  186.  
  187.       AddTail(&FuncList,newnode);
  188.  
  189.       return;
  190.    }
  191.  
  192.    KillMemory(KILL);
  193. }
  194.  
  195. static void
  196. makesummary(int count)
  197. {
  198.    struct Node *newnode = ALLOCF(sizeof(*newnode));
  199.  
  200.    if(newnode && (newnode->ln_Name = ALLOCF(50)))
  201.    {
  202.       sprintf(newnode->ln_Name,"-> %4ld patched offsets found", count);
  203.  
  204.       AddTail(&FuncList,newnode);
  205.  
  206.       return;
  207.    }
  208.  
  209.    KillMemory(KILL);
  210. }
  211.  
  212. void
  213. PrintLibOffsets(struct _liblist *liblist)
  214. {
  215.    struct func *funcptr;
  216.    LONG  offs;
  217.    int j = 0,l = 0;
  218.  
  219.    makehead(liblist->libname);
  220.  
  221.    liblist->library = OpenLibrary(liblist->libname, 0L);
  222.    if (liblist->library)
  223.    {
  224.       makeinfo(liblist);
  225.  
  226.       Forbid();
  227.  
  228.       funcptr = (struct func *)liblist->library;
  229.       funcptr -= (liblist->firstoff / FUNCOFFS); /* Die ersten Funktionen ueberspringen */
  230.  
  231.       liblist->lastoff = (liblist->library->lib_NegSize / 6) * FUNCOFFS;
  232.  
  233.       for (offs = liblist->firstoff; offs <= liblist->lastoff;
  234.            offs += FUNCOFFS)
  235.       {
  236.          if ((funcptr->adr < kickromstart) || (funcptr->adr > MAGIC_ROM_END))
  237.          {
  238.             makeentry(offs,funcptr->adr);
  239.             j++;
  240.          }
  241.  
  242.          funcptr--;             /* Naechste Funktion */
  243.       }
  244.  
  245.       Permit();
  246.  
  247.       CloseLibrary(liblist->library);
  248.  
  249.       makesummary(j);
  250.    }
  251.    else
  252.       makehead((UBYTE *)"Can't open library!");
  253.  
  254.    makeblank();
  255.  
  256.    return;
  257. }
  258.  
  259. void
  260. PrintDevOffsets(struct _devlist *devlist)
  261. {
  262.    struct func *funcptr;
  263.  
  264.    struct IORequest ioreq;
  265.    LONG  offs;
  266.    int   j = 0,
  267.          err;
  268.  
  269.    makehead(devlist->devname);
  270.  
  271.    memset(&ioreq,0,sizeof(struct IORequest));
  272.  
  273.    err = OpenDevice(devlist->devname,devlist->unit,&ioreq,devlist->flags);
  274.    if (!err)
  275.    {
  276.       devlist->device = &(ioreq.io_Device->dd_Library);
  277.  
  278.       makeinfo((struct _liblist *)devlist);
  279.  
  280.       Forbid();
  281.  
  282.       funcptr = (struct func *)devlist->device;
  283.       funcptr -= (devlist->firstoff / FUNCOFFS); /* Die ersten Funktionen ueberspringen */
  284.  
  285.       devlist->lastoff = (devlist->device->lib_NegSize / 6) * FUNCOFFS;
  286.  
  287.       for (offs = devlist->firstoff; offs <= devlist->lastoff;
  288.            offs += FUNCOFFS)
  289.       {
  290.          if ((funcptr->adr < kickromstart) || (funcptr->adr > MAGIC_ROM_END))
  291.          {
  292.             makeentry(offs,funcptr->adr);
  293.             j++;
  294.          }
  295.  
  296.          funcptr--;             /* Naechste Funktion */
  297.       }
  298.  
  299.       Permit();
  300.  
  301.       CloseDevice(&ioreq);
  302.  
  303.       makesummary(j);
  304.    }
  305.    else
  306.       makehead((UBYTE *)"Can't open device!");
  307.  
  308.    makeblank();
  309.  
  310.    return;
  311. }
  312.  
  313.  
  314. void
  315. SysCheckOffs(void)
  316. {
  317.    register int i;
  318.    struct Node *node;
  319.  
  320.    PrintHeader(LIBRARYOFFS, NULL);
  321.  
  322.    EmptyListView();
  323.  
  324.    NewList(&FuncList);
  325.  
  326.    kickromstart = MAGIC_ROM_END - MAGIC_ROM_SIZE;
  327.  
  328.    makehead((UBYTE *)"Kick-ROM Info");
  329.    makerominfo((UBYTE *)"ROM Start ", kickromstart);
  330.    makeromsizeinfo((UBYTE *)"ROM Size  ", MAGIC_ROM_SIZE);
  331.    makeblank();
  332.  
  333.    for(i = 0; i < LIBCNT; i++)
  334.       PrintLibOffsets(&libs[i]);
  335.  
  336.    for(i = 0; i < DEVCNT; i++)
  337.       PrintDevOffsets(&devs[i]);
  338.  
  339.    countentries = CountNodes(&FuncList);
  340.  
  341.    Entries = AllocScrollEntries(countentries);
  342.  
  343.    for (i = 0, node = FuncList.lh_Head; i < countentries;
  344.         i++, node = node->ln_Succ)
  345.    {
  346.       strcpy(Entries[i].se_Entry,node->ln_Name);
  347.  
  348.       AddNodeToList(i, NO_SORT);
  349.    }
  350.  
  351.    KillMemory(NO_KILL);
  352.  
  353.    PrintStatistics();
  354.  
  355.    return;
  356. }
  357.  
  358.