parse.c

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

//*************************************************************************
// DecodeVmFlags()
//
//*************************************************************************
//ei FIX THIS!!!!!!!!!!!!!!!!!!
LPSTR DecodeVmFlags(ULONG flags)
{
    ULONG i;
/*
#define VM_READ		0x0001
#define VM_WRITE	0x0002
#define VM_EXEC		0x0004
#define VM_SHARED	0x0008

#define VM_MAYREAD	0x0010
#define VM_MAYWRITE	0x0020
#define VM_MAYEXEC	0x0040
#define VM_MAYSHARE	0x0080

#define VM_GROWSDOWN	0x0100
#define VM_GROWSUP	0x0200
#define VM_SHM		0x0400
#define VM_DENYWRITE	0x0800

#define VM_EXECUTABLE	0x1000
#define VM_LOCKED	0x2000
#define VM_IO           0x4000

#define VM_STACK_FLAGS	0x0177
*/
    static LPSTR flags_syms_on[]={"R","W","X","S","MR","MW","MX","MS","GD","GU","SHM","exe","LOCK","IO",""};
    static char temp[256];

	// terminate string
    *temp = 0;
//ei fix fix fix
#if 0

    if(flags == VM_STACK_FLAGS)
    {
        PICE_strcpy(temp," (STACK)");
    }
    else
    {
        for(i=0;i<15;i++)
        {
            if(flags&0x1)
            {
                PICE_strcat(temp," ");
                PICE_strcat(temp,flags_syms_on[i]);
            }
            flags >>= 1;
        }
    }
#endif
    return temp;
}

//*************************************************************************
// ShowVirtualMemory()
//
//*************************************************************************
COMMAND_PROTOTYPE(ShowVirtualMemory)
{
  PEPROCESS my_current = IoGetCurrentProcess();
  PLIST_ENTRY current_entry;
  PMADDRESS_SPACE vma = NULL;
  MEMORY_AREA* current;
  char filename[64];

  DPRINT((0,"ShowVirtualMemory()\n"));
  if( my_current )
    vma = &(my_current->AddressSpace);
  if( !vma )
    vma = my_init_mm;
  while( vma )
    {
      if(pArgs->Count == 0)
        {
	  PutStatusText("START    END      LENGTH   VMA      TYPE   ATTR");
	  current_entry = vma->MAreaListHead.Flink;
	  while (current_entry != &vma->MAreaListHead)
            {
	      *filename = 0;

	      current = CONTAINING_RECORD(current_entry,
					  MEMORY_AREA,
					  Entry);
				// find the filename
	      if(((current->Type == MEMORY_AREA_SECTION_VIEW) ) &&
		 current->Data.SectionData.Section->FileObject)
                {
		  if(IsAddressValid((ULONG)current->Data.SectionData.Section->FileObject->FileName.Buffer) )
		    PICE_sprintf(filename,"%.64S",current->Data.SectionData.Section->FileObject->FileName.Buffer);
                }

	      PICE_sprintf(tempCmd,"%.8X %.8X %.8X %.8X %x %x    %s\n",
			   (ULONG)current->BaseAddress,
			   (ULONG)current->BaseAddress+current->Length,
			   current->Length,
			   (ULONG)current,
			   current->Type, current->Attributes,//DecodeVmFlags(current->Type, current->Attributes),
			   filename);
	      Print(OUTPUT_WINDOW,tempCmd);

	      if(WaitForKey()==FALSE)
		break;
	      current_entry = current_entry->Flink;
            }
        }
      if( vma == &(my_current->AddressSpace) )
	vma = my_init_mm;  // switch to kernel memory area
      else vma = 0;        // if we already did kernel, end loop
    }
  return TRUE;
}

//*************************************************************************
// Ver()
//
//*************************************************************************
COMMAND_PROTOTYPE(Ver)
{
	//ei add kernel version info??!!
    PICE_sprintf(tempCmd,"pICE: version %u.%u (build %u) for Reactos\n",
                 PICE_MAJOR_VERSION,
                 PICE_MINOR_VERSION,
                 PICE_BUILD);

	Print(OUTPUT_WINDOW,tempCmd);

/*    PICE_sprintf(tempCmd,"pICE: loaded on %s kernel release %s\n",
		system_utsname.sysname,
		system_utsname.release);
 */
	Print(OUTPUT_WINDOW,tempCmd);
	Print(OUTPUT_WINDOW,"pICE: written by Klaus P. Gerlicher and Goran Devic.\n");
	Print(OUTPUT_WINDOW,"pICE: ported to Reactos by Eugene Ingerman.\n");

	return TRUE;
}

//*************************************************************************
// Hboot()
//
//*************************************************************************
COMMAND_PROTOTYPE(Hboot)
{
	// nudge the reset line through keyboard controller
	__asm__("\n\t \
		movb $0xFE,%al\n\t \
		outb %al,$0x64");
	// never gets here
	return TRUE;
}

//*************************************************************************
// SetSrcDisplay()
//
//*************************************************************************
COMMAND_PROTOTYPE(SetSrcDisplay)
{
    ARGS Args;

	if(pArgs->Count==0)
	{
		bShowSrc=bShowSrc?FALSE:TRUE;
        PICE_memset(&Args,0,sizeof(ARGS));
        // make unassembler refresh all again
        ulLastDisassStartAddress=ulLastDisassEndAddress=0;
		Args.Count=0;
		Unassemble(&Args);
	}
	return TRUE;
}

//*************************************************************************
// I3here()
//
//*************************************************************************
COMMAND_PROTOTYPE(I3here)
{
	if(pArgs->Count==1)
	{
		if(pArgs->Value[0]==1)
		{
			if(!bInt3Here)
			{
				bInt3Here=TRUE;
				Print(OUTPUT_WINDOW,"I3HERE is now ON\n");
			}
			else
				Print(OUTPUT_WINDOW,"I3HERE is already ON\n");
		}
		else if(pArgs->Value[0]==0)
		{
			if(bInt3Here)
			{
				bInt3Here=FALSE;
				Print(OUTPUT_WINDOW,"I3HERE is now OFF\n");
			}
			else
				Print(OUTPUT_WINDOW,"I3HERE is already OFF\n");
		}
	}
	else if(pArgs->Count==0)
	{
		if(bInt3Here)
		{
			Print(OUTPUT_WINDOW,"I3HERE is ON\n");
		}
		else
		{
			Print(OUTPUT_WINDOW,"I3HERE is OFF\n");
		}
	}
	// never gets here
	return TRUE;
}

COMMAND_PROTOTYPE(I1here)
{
	if(pArgs->Count==1)
	{
		if(pArgs->Value[0]==1)
		{
			if(!bInt1Here)
			{
				bInt1Here=TRUE;
				Print(OUTPUT_WINDOW,"I1HERE is now ON\n");
			}
			else
				Print(OUTPUT_WINDOW,"I1HERE is already ON\n");
		}
		else if(pArgs->Value[0]==0)
		{
			if(bInt1Here)
			{
				bInt1Here=FALSE;
				Print(OUTPUT_WINDOW,"I1HERE is now OFF\n");
			}
			else
				Print(OUTPUT_WINDOW,"I1HERE is already OFF\n");
		}
	}
	else if(pArgs->Count==0)
	{
		if(bInt1Here)
		{
			Print(OUTPUT_WINDOW,"I1HERE is ON\n");
		}
		else
		{
			Print(OUTPUT_WINDOW,"I1HERE is OFF\n");
		}
	}
	// never gets here
	return TRUE;
}

COMMAND_PROTOTYPE(NextInstr)
{
    static char tempDisasm[256];
    ULONG addr,addrbefore;

	bNeedToFillBuffer=FALSE;

	if(!pArgs->Count)
	{
		addr=addrbefore=GetLinearAddress(CurrentCS,CurrentEIP);
		DPRINT((0,"addr before %.8X\n",addrbefore));
		Disasm(&addr,tempDisasm);
		DPRINT((0,"addr after %.8X\n",addr));
		CurrentEIP=CurrentEIP+(addr-addrbefore);
		// display register contents
		DisplayRegs();
		// unassemble
		DPRINT((0,"new CS:EIP %04.x:%.8X\n",CurrentCS,CurrentEIP));
        PICE_memset(pArgs,0,sizeof(ARGS));
        // make unassembler refresh all again
        ulLastDisassStartAddress=ulLastDisassEndAddress=0;
		pArgs->Count=2;
		pArgs->Value[0]=(ULONG)CurrentCS;
		pArgs->Value[1]=CurrentEIP;
		Unassemble(pArgs);
	}
	bNeedToFillBuffer=TRUE;
	return TRUE;
}

COMMAND_PROTOTYPE(SetGetRegisters)
{
	ULONG i;

	if(pArgs->Count==0)
	{
		// display whole set
		for(i=0;RegKeyWords[i].pValue!=0;i++)
		{
			switch(RegKeyWords[i].ulSize)
			{
				case 1:
					PICE_sprintf(tempCmd,"%s = %.8X\n",RegKeyWords[i].KeyWord,*(PUCHAR)(RegKeyWords[i].pValue));
					break;
				case 2:
					PICE_sprintf(tempCmd,"%s = %.8X\n",RegKeyWords[i].KeyWord,*(PUSHORT)(RegKeyWords[i].pValue));
					break;
				case 4:
					PICE_sprintf(tempCmd,"%s = %.8X\n",RegKeyWords[i].KeyWord,*(PULONG)(RegKeyWords[i].pValue));
					break;
			}
			Print(OUTPUT_WINDOW,tempCmd);
			if(WaitForKey()==FALSE)break;
		}
	}
	else if(pArgs->Count==1)
	{
		// display selected register
		for(i=0;RegKeyWords[i].pValue!=0;i++)
		{
			if(PICE_strcmpi(pArgs->pToken[0],RegKeyWords[i].KeyWord)==0)
			{
				switch(RegKeyWords[i].ulSize)
				{
					case 1:
						PICE_sprintf(tempCmd,"%s = %.2X\n",RegKeyWords[i].KeyWord,*(PUCHAR)(RegKeyWords[i].pValue));
						break;
					case 2:
						PICE_sprintf(tempCmd,"%s = %.4X\n",RegKeyWords[i].KeyWord,*(PUSHORT)(RegKeyWords[i].pValue));
						break;
					case 4:
						PICE_sprintf(tempCmd,"%s = %.8X\n",RegKeyWords[i].KeyWord,*(PULONG)(RegKeyWords[i].pValue));
						break;
				}
				Print(OUTPUT_WINDOW,tempCmd);
				break;
			}
		}
	}
	else if(pArgs->Count==2)
	{
		// set selected register to value
		for(i=0;RegKeyWords[i].pValue!=0;i++)
		{
			if(PICE_strcmpi(pArgs->pToken[0],RegKeyWords[i].KeyWord)==0)
			{
				switch(RegKeyWords[i].ulSize)
				{
					case 1:
						*(PUCHAR)(RegKeyWords[i].pValue)=(UCHAR)pArgs->Value[1];
						break;
					case 2:
						*(PUSHORT)(RegKeyWords[i].pValue)=(USHORT)pArgs->Value[1];
						break;
					case 4:
						*(PULONG)(RegKeyWords[i].pValue)=(ULONG)pArgs->Value[1];
						break;
				}
				DisplayRegs();
                RepaintSource();
				break;
			}
		}
	}
	return TRUE;
}

//*************************************************************************
// SetCodeDisplay()
//
//*************************************************************************
COMMAND_PROTOTYPE(SetCodeDisplay)
{
    ARGS Args;

	if(pArgs->Count==0)
	{
		bCodeOn=bCodeOn?FALSE:TRUE;

        PICE_memset(&Args,0,sizeof(ARGS));
		Args.Count=0;
        // make unassembler refresh all again
        ulLastDisassStartAddress=ulLastDisassEndAddress=0;
		Unassemble(&Args);
	}
	else if(pArgs->Count==1)
	{
        bCodeOn=(pArgs->Value[0]==0)?FALSE:TRUE;

        PICE_memset(&Args,0,sizeof(ARGS));
		Args.Count=0;
        // make unassembler refresh all again
        ulLastDisassStartAddress=ulLastDisassEndAddress=0;
		Unassemble(&Args);
	}
	return TRUE;
}

//*************************************************************************
// ShowCPU()
//
//*************************************************************************
COMMAND_PROTOTYPE(ShowCPU)
{
ULONG i;

	for(i=0;CPUInfo[i].pValue!=NULL;i++)
	{
		PICE_sprintf(tempCmd,"%s = %.8X\n",CPUInfo[i].Name,*(CPUInfo[i].pValue));
		Print(OUTPUT_WINDOW,tempCmd);
		if(WaitForKey()==FALSE)break;
	}
	return TRUE;
}

//*************************************************************************
// WalkStack()
//
//*************************************************************************
COMMAND_PROTOTYPE(WalkStack)
{
	if(!pArgs->Count)
	{
		IntelStackWalk(CurrentEIP,CurrentEBP,CurrentESP);
	}

	return TRUE;
}

//*************************************************************************
// PokeDword()
//
//*************************************************************************
COMMAND_PROTOTYPE(PokeDword)
{
	ULONG ulData;

	// read old data
    ulData = ReadPhysMem(pArgs->Value[1],sizeof(ULONG));
	PICE_sprintf(tempCmd,"value @ %.8X was %.8X\n",pArgs->Value[1],ulData);
	Print(OUTPUT_WINDOW,tempCmd);

    // write new data
	WritePhysMem(pArgs->Value[1],pArgs->Value[2],sizeof(ULONG));

    // read check
	ulData = ReadPhysMem(pArgs->Value[1],sizeof(ULONG));
	PICE_sprintf(tempCmd,"value @ %.8X = %.8X\n",pArgs->Value[1],ulData);
	Print(OUTPUT_WINDOW,tempCmd);

	return TRUE;
}

//*************************************************************************
// PokeMemory()
//
//*************************************************************************
COMMAND_PROTOTYPE(PokeMemory)
{
    DPRINT((0,"PokeMemory()\n"));
	DPRINT((0,"PokeMemory(): value[0] = %.8X value[1] = %.8X value[3] = %.8X count = %.8X\n",pArgs->Value[0],pArgs->Value[1],pArgs->Value[2],pArgs->Count));

    // must be three parameters
    if(pArgs->Count == 3)
    {
        switch(pAr