test/exec/dumpmem.c

   1 /*
   2     Copyright © 1995-2004 The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Memory Dump util functions.
   6     Lang: english
   7 */
   8
   9 #define  DEBUG  1
  10 #include <aros/debug.h>
  11
  12 #include <exec/memory.h>
  13 #include <dos/dos.h>
  14 #include <dos/exall.h>
  15 #include <dos/datetime.h>
  16 #include <proto/dos.h>
  17 #include <proto/utility.h>
  18 #include <utility/tagitem.h>
  19 #include <utility/utility.h>
  20
  21 #include <proto/alib.h>
  22 #include <proto/exec.h>
  23 #include <proto/dos.h>
  24
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <memory.h>
  29
  30 static const char version[] = "$VER: dumpmem.c 45.0 (10.2.2004)\n";
  31
  32 #define ARG_TEMPLATE "ADDRESS/A,SIZE/N/A,SERIAL/S,QUIET/S"
  33
  34 enum
  35 {
  36     ARG_ADDRESS,
  37     ARG_SIZE,
  38     ARG_SERIAL,
  39     ARG_QUIET,
  40     NOOFARGS
  41 };
  42
  43 /* unsigned int hextoint( char **value ); */
  44 void clean_string( char *dirtystring );
  45
  46 int main(int argc, char **argv)
  47 {
  48     IPTR args[NOOFARGS] = { (IPTR) NULL,         // ARG_ADDRESS
  49                             (IPTR) NULL,         // ARG_SIZE
  50                                    FALSE,        // ARG_SERIAL
  51                                    FALSE         // ARG_QUIET
  52     };
  53
  54     struct RDArgs           *rda;
  55     char                    outpstring[sizeof(unsigned int)*6];
  56     IPTR                    offset,start_address,dump_size = 0;
  57     int                     PROGRAM_ERROR = RETURN_OK;
  58     char                    *ERROR_TEXT,*HELPTXT;
  59
  60     HELPTXT =
  61         "ADDRESS  The start address to dump from (in hex)\n"
  62         "SIZE     The number of bytes to dump\n"
  63         "SERIAL   If specified, output will use serial debugging instead of stdout\n"
  64         "QUIET    Do not display warnings\n";
  65
  66     rda = ReadArgs(ARG_TEMPLATE, args, NULL);
  67     if (NULL != rda)
  68     {
  69         if (args[ARG_ADDRESS]!=0)
  70         {
  71
  72             if (args[ARG_SIZE]!=0)
  73             {
  74                 BOOL serial_out = (BOOL)args[ARG_SERIAL];
  75                 BOOL quiet_out = (BOOL)args[ARG_QUIET];
  76                 ULONG  *sizptr = (ULONG *)args[ARG_SIZE];
  77                 char   * pEnd;
  78
  79                 if ( sizptr != NULL ) dump_size = *sizptr;
  80                 else PROGRAM_ERROR = RETURN_FAIL;
  81
  82                 start_address = strtoul((CONST_STRPTR) args[ARG_ADDRESS], &pEnd, 16 );
  83                 dump_size = ( dump_size / sizeof(unsigned int));
  84
  85                 if ( dump_size <= 0)
  86                 {
  87                     ERROR_TEXT = "Size must be a positive value\n";
  88                     PROGRAM_ERROR = RETURN_FAIL;
  89                 }
  90
  91                 /* a quick warning */
  92                 if ( ( !quiet_out  ) && ( PROGRAM_ERROR != RETURN_FAIL ) )
  93                 {
  94                     TEXT szInput[256];
  95                     printf( "\n  *Some memory areas should NOT be read\n  use this tool carefully!\n  would you like to proceed? ");
  96
  97                     gets ( szInput );
  98
  99                     printf( "\n" );
 100
 101                     if ( ( strncmp( szInput, "n", 1) )||( strncmp( szInput, "N", 1) ) )
 102                     {
 103                         ERROR_TEXT = "User canceled..\n";
 104                         PROGRAM_ERROR = RETURN_FAIL;
 105                     }
 106                 }
 107
 108                 if ( PROGRAM_ERROR != RETURN_FAIL )
 109                 {
 110                     if (serial_out) kprintf("dumpmem - Memory Dump tool.\n© Copyright the AROS Dev Team.\n-----------------------------\n\nDumping From [%p] for %d bytes..\n\n", (void *)start_address, (dump_size * sizeof(unsigned int))); /* use kprintf so it is output on serial.. */
 111                     else printf("dumpmem - Memory Dump tool.\n© Copyright the AROS Dev Team.\n-----------------------------\n\nDumping From [%p] for %d bytes..\n\n", (void *)start_address, (int)(dump_size * sizeof(unsigned int))); /* use kprintf so it is output on serial.. */
 112
 113                     for ( offset = 0 ; offset < dump_size ; offset += sizeof(unsigned int) )
 114                     {
 115                         if ( SetSignal(0L,0L) & SIGBREAKF_CTRL_C )
 116                         {
 117                             SetIoErr( ERROR_BREAK );
 118                             PROGRAM_ERROR = RETURN_WARN;
 119                             break;
 120                         }
 121
 122                         if ( ( (offset/sizeof(unsigned int) ) % 6) == 0 )
 123                         {
 124                             if (serial_out) kprintf("0x%8.8llX        ",(unsigned long long)(start_address+offset));
 125                             else printf("0x%8.8llX        ",(unsigned long long)(start_address+offset));
 126                         }
 127
 128                         if (serial_out) kprintf("%8.8X", (unsigned int)((IPTR *)start_address+offset)[0]); /* use kprintf so it is output on serial.. */
 129                         else printf("%8.8X", (unsigned int)((IPTR *)start_address+offset)[0]); /* use kprintf so it is output on serial.. */
 130                         sprintf( (char *) &outpstring + ((((offset/sizeof(unsigned int)) % 6) * 4)) ,"%4.4s", (char *)((IPTR *)start_address+offset)[0]);
 131
 132                         if ( ((offset/sizeof(unsigned int)) % 6) == 5 )
 133                         {
 134                             clean_string( outpstring );
 135
 136                             if (serial_out) kprintf("       '%24.24s'                         \t\n",outpstring);
 137                             else printf("       '%24.24s'                         \t\n",outpstring);
 138                         }
 139                         else
 140                         {
 141                             if (serial_out)  kprintf(" ");
 142                             else printf(" ");
 143                         }
 144
 145                     }
 146
 147                     if (serial_out) kprintf("\n\nDump Complete. ");
 148                     else printf("\n\nDump Complete. ");
 149                 }
 150             }
 151             else ERROR_TEXT = HELPTXT;
 152         }
 153         else ERROR_TEXT = HELPTXT;
 154         FreeArgs(rda);
 155     }
 156     else ERROR_TEXT = HELPTXT;
 157
 158     if (ERROR_TEXT) puts( ERROR_TEXT );
 159     return PROGRAM_ERROR;
 160 }
 161
 162 /* convert a hex string to an int - deprecated */
 163 /*
 164 unsigned int hextoint(char **value)
 165 {
 166     struct CHexMap
 167     {
 168         char chr;
 169         int value;
 170     };
 171     const int HexMapL = 16;
 172     struct CHexMap HiHexMap[] =
 173     {
 174         {"0", 0},   {"1", 1},
 175         {"2", 2},   {"3", 3},
 176         {"4", 4},   {"5", 5},
 177         {"6", 6},   {"7", 7},
 178         {"8", 8},   {"9", 9},
 179         {"A", 10},  {"B", 11},
 180         {"C", 12},  {"D", 13},
 181         {"E", 14},  {"F", 15},
 182         {""}
 183     };
 184     struct CHexMap LoHexMap[] =
 185     {
 186         {"0", 0},   {"1", 1},
 187         {"2", 2},   {"3", 3},
 188         {"4", 4},   {"5", 5},
 189         {"6", 6},   {"7", 7},
 190         {"8", 8},   {"9", 9},
 191         {"a", 10},  {"b", 11},
 192         {"c", 12},  {"d", 13},
 193         {"e", 14},  {"f", 15},
 194         {""}
 195     };
 196     unsigned int result = 0,start=0;
 197
 198     printf(" converting %s to an int..\n",value);
 199
 200     if ((char *)value[0] == '0' && (((char *)value[1] == 'X')||((char *)value[1] == 'x') ) ) start = 2;
 201
 202     BOOL        firsttime = TRUE;
 203
 204     int vallen;
 205
 206     for (vallen = start; vallen < strlen(value) ; vallen++)
 207     {
 208         BOOL        found = FALSE;
 209         int         i;
 210
 211         printf(" Parsing $s\n",(char *)value[vallen]);
 212
 213         for ( i = 0 ; i < HexMapL; i++)
 214         {
 215             if (( (char *)value[vallen] == HiHexMap[i].chr )||( (char *)value[vallen] == LoHexMap[i].chr ))
 216             {
 217                 if (!firsttime) result <<= 4;
 218                 result |= HiHexMap[i].value;
 219                 found = TRUE;
 220                 break;
 221             }
 222         }
 223         if (!found) break;
 224         firsttime = FALSE;
 225     }
 226     return result;
 227 }*/
 228
 229 /* Replace all non printable characters with a '.' */
 230
 231 void clean_string( char *dirtystring )
 232 {
 233     int             i;
 234
 235     for (i = 0 ; i < (sizeof(unsigned int) * 6) ; i++)
 236     {
 237         if ((dirtystring[i] < 32) || (dirtystring[i] > 126))
 238             dirtystring[i] = '.';
 239     }
 240
 241 }