This commit was manufactured by cvs2svn to create tag 'krnl0010'.

svn path=/tags/krnl0010/; revision=32

freeldr/FREELDR.INI

@@ -1,130 +0,0 @@
-# FreeLoader by Brian Palmer
-# FREELDR.INI - FreeLoader Initialization file
-#
-# Each line must be less than 1024 characters long
-# and must be either a section heading (i.e. [section_name])
-# or a setting (i.e. name=value) or a blank line.
-# Comments start with a '#' character.
-
-# Background colors can be any one of the following:
-# Black
-# Blue
-# Green
-# Cyan
-# Red
-# Magenta
-# Brown
-# Gray
-
-# Text colors can be any one of the background
-# colors and any of the following:
-# DarkGray
-# LightBlue
-# LightGreen
-# LightCyan
-# LightRed
-# LightMagenta
-# Yellow
-# White
-
-# [FREELOADER] Section Commands:
-#
-# MessageBox		- displays the specified text in a message box upon bootup
-# MessageLine		- adds a new line of text to a message box (must come before MessageBox command)
-# TitleText		- text that is displayed in the title box
-# StatusBarColor	- color of status bar's background
-# StatusBarTextColor	- color of status bar's text
-# BackdropTextColor	- color of the backdrop's fill
-# BackdropColor		- color of the backdrop's background
-# BackdropFillStyle	- backdrop fill style - can be Light, Medium, or Dark
-# TitleBoxTextColor	- title box text color
-# TitleBoxColor		- title box background color
-# MessageBoxTextColor	- message box text color
-# MessageBoxColor	- message box background color
-# MenuTextColor		- menu text color
-# MenuColor		- menu color
-# TextColor		- normal text color
-# SelectedTextColor	- selected text color
-# SelectedColor		- selected text background color
-# TimeOut		- sets the timeout (in seconds) before the first OS listed gets booted automagically
-
-# [OS-General] Section Commands:
-#
-# BootType		- sets the boot type: ReactOS, Linux, BootSector, Partition, Drive
-# BootDrive		- sets the boot drive: 0 - first floppy, 1 - second floppy, 0x80 - first hard disk, 0x81 - second hard disk
-# BootPartition		- sets the boot partition
-
-# [BootSector OSType] Section Commands:
-#
-# BootSector		- sets the filename of the bootsector to be loaded
-
-# [ReactOS OSType] Section Commands:
-#
-# Options		- sets the command line options for the kernel being booted
-# Kernel		- sets the kernel filename
-# Driver		- sets the name of one or more drivers to be loaded (one entry per driver)
-
-
-
-[FREELOADER]
-MessageLine=Welcome to FreeLoader!
-MessageLine=Copyright (c) 2000 by Brian Palmer <brianp@sginet.com>
-MessageLine=
-MessageBox=Edit your FREELDR.INI file to change your boot settings.
-TitleText=Boot Menu
-StatusBarColor=Cyan
-StatusBarTextColor=Black
-BackdropTextColor=White
-BackdropColor=Blue
-BackdropFillStyle=Medium
-TitleBoxTextColor=White
-TitleBoxColor=Red
-MessageBoxTextColor=White
-MessageBoxColor=Blue
-MenuTextColor=White
-MenuColor=Blue
-TextColor=Yellow
-SelectedTextColor=Black
-SelectedColor=Gray
-#OS=ReactOS
-#OS=ReactOS (Debug)
-#OS=Linux
-OS=3<> Floppy (A:)
-OS=Microsoft Windows (C:)
-OS=Drive D:
-#TimeOut=0
-
-#[ReactOS]
-#BootType=ReactOS
-#BootDrive=0
-#Options=/DEBUGPORT=SCREEN
-#Kernel=\NTOSKRNL.EXE
-#Driver=\DRIVERS\IDE.SYS
-#Driver=\DRIVERS\VFATFS.SYS
-
-#[ReactOS (Debug)]
-#BootType=ReactOS
-#BootDrive=0
-#Options=/DEBUG /DEBUGPORT=COM1 /BAUDRATE=19200
-#Kernel=\NTOSKRNL.EXE
-#Driver=\DRIVERS\IDE.SYS
-#Driver=\DRIVERS\VFATFS.SYS
-
-#[Linux]
-# Linux boot type not implemented yet
-#BootType=Partition
-#BootDrive=0x80
-#BootPartition=2
-
-[3<> Floppy (A:)]
-BootType=Drive
-BootDrive=0
-
-[Microsoft Windows (C:)]
-BootType=Drive
-BootDrive=0x80
-
-[Drive D:]
-BootType=Partition
-BootDrive=0x81
-BootPartition=1

freeldr/bootsect/BOOTSECT.ASM

@@ -1,256 +0,0 @@
-; BOOTSECT.ASM
-; FAT12/16 Boot Sector
-; Copyright (c) 1998 Brian Palmer
-
-org 7c00h
-
-segment .text
-
-bits 16
-
-start:
-        jmp short main
-        nop
-
-OEMName         db 'FreeLDR!'
-BytesPerSector  dw 512
-SectsPerCluster db 1
-ReservedSectors dw 1
-NumberOfFats    db 2
-MaxRootEntries  dw 512
-TotalSectors    dw 2880
-MediaDescriptor db 0f0h
-SectorsPerFat   dw 9
-SectorsPerTrack dw 18
-NumberOfHeads   dw 2
-HiddenSectors   dd 0
-TotalSectorsBig dd 0
-BootDrive       db 0
-Reserved        db 0
-ExtendSig       db 29h
-SerialNumber    dd 00000000h
-VolumeLabel     db 'FreeLoader!'
-FileSystem      db 'FAT12   '
-
-main:
-        cli
-        cld
-        xor ax,ax
-        mov ss,ax
-        mov sp,7c00h            ; Setup a stack
-        mov ax,cs               ; Setup segment registers
-        mov ds,ax               ; Make DS correct
-        mov es,ax               ; Make ES correct
-
-
-        sti                     ; Enable ints now
-        mov [BootDrive],dl      ; Save the boot drive
-        xor ax,ax               ; Zero out AX
-
-        ; Reset disk controller
-        int 13h         
-        jnc Continue1           
-        jmp BadBoot             ; Reset failed...
-
-Continue1:
-        ; Now we must find our way to the first sector of the root directory
-        xor ax,ax
-        xor cx,cx
-        mov al,[NumberOfFats]    ; Number of fats
-        mul WORD [SectorsPerFat] ; Times sectors per fat
-        add ax,WORD [HiddenSectors] 
-        adc dx,WORD [HiddenSectors+2] ; Add the number of hidden sectors 
-        add ax,[ReservedSectors]     ; Add the number of reserved sectors
-        adc dx,cx               ; Add carry bit
-        push ax                 ; Store it on the stack
-        push dx                 ; Save 32-bit logical start sector
-        push ax
-        push dx                 ; Save it for later use also
-        ; DX:AX now has the number of the starting sector of the root directory
-
-        ; Now calculate the size of the root directory
-        mov ax,0020h            ; Size of dir entry
-        mul WORD [MaxRootEntries] ; Times the number of entries
-        mov bx,[BytesPerSector]
-        add ax,bx
-        dec ax
-        div bx                  ; Divided by the size of a sector
-        ; AX now has the number of root directory sectors
-
-        xchg ax,cx              ; Now CX has number of sectors
-        pop  dx
-        pop  ax                 ; Restore logical sector start
-        push cx                 ; Save for later use
-        mov  bx,7c0h            ; We will load the root directory 
-        add  bx,20h             ; Right after the boot sector in memory
-        mov  es,bx
-        xor  bx,bx              ; We will load it to [0000:7e00h]
-        call ReadSectors        ; Read the sectors
-        jnc  Continue2          ; BadBoot on error
-        jmp  BadBoot
-Continue2:
-
-
-        ; Now we have to find our way through the root directory to
-        ; The OSLOADER.SYS file
-        mov  bx,[MaxRootEntries]; Search entire root directory
-        mov  ax,7e0h            ; We loaded at 07e0:0000
-        mov  es,ax
-        xor  di,di
-        mov  si,filename
-        mov  cx,11
-        rep  cmpsb              ; Compare filenames
-        jz   FoundFile          ; If same we found it
-        dec  bx
-        jnz  FindFile
-        jmp  ErrBoot
-
-FindFile:
-        mov  ax,es              ; We didn't find it in the previous dir entry
-        add  ax,2               ; So lets move to the next one
-        mov  es,ax              ; And search again
-        xor  di,di
-        mov  si,filename        
-        mov  cx,11
-        rep  cmpsb              ; Compare filenames
-        jz   FoundFile          ; If same we found it
-        dec  bx                 ; Keep searching till we run out of dir entries
-        jnz  FindFile           ; Last entry?
-        jmp  ErrBoot
-
-FoundFile:
-        xor  di,di              ; ES:DI has dir entry
-        xor  dx,dx
-        mov  ax,WORD [es:di+1ah]        ; Get start cluster
-        dec  ax
-        dec  ax
-        xor  ch,ch
-        mov  cl,BYTE [SectsPerCluster] ; Times sectors per cluster
-        mul  cx
-        pop  cx                 ; Get number of sectors for root dir
-        add  ax,cx
-        adc  dx,0
-        pop  cx                 ; Get logical start sector of
-        pop  bx                 ; Root directory
-        add  ax,bx              ; Now we have DX:AX with the logical start
-        adc  dx,cx              ; Sector of OSLOADER.SYS
-        push ax
-        push dx
-        mov  ax,WORD [es:di+1ch]
-        mov  dx,WORD [es:di+1eh]
-        mov  bx,[BytesPerSector]
-        dec  bx
-        add  ax,bx
-        adc  dx,0
-        div  WORD [BytesPerSector]
-        xchg ax,cx              ; Now CX has number of sectors of OSLOADER.SYS
-        pop  dx
-        pop  ax
-        mov  bx,800h
-        mov  es,bx
-        xor  bx,bx              ; Load ROSLDR at 0000:8000h
-        call ReadSectors        ; Load it
-        jc   BadBoot
-        mov  dl,[BootDrive]
-        xor  ax,ax
-        push ax
-        mov  ax,8000h
-        push ax                 ; We will do a far return to 0000:8000h
-        retf                    ; Transfer control to ROSLDR
-
-
-
-; Reads logical sectors into [ES:BX]
-; DX:AX has logical sector number to read
-; CX has number of sectors to read
-; CarryFlag set on error
-ReadSectors:
-        push ax
-        push dx
-        push cx
-        xchg ax,cx
-        xchg ax,dx
-        xor  dx,dx
-        div  WORD [SectorsPerTrack]
-        xchg ax,cx                    
-        div  WORD [SectorsPerTrack]    ; Divide logical by SectorsPerTrack
-        inc  dx                        ; Sectors numbering starts at 1 not 0
-        xchg cx,dx
-        div  WORD [NumberOfHeads]      ; Number of heads
-        mov  dh,dl                     ; Head to DH, drive to DL
-        mov  dl,[BootDrive]            ; Drive number
-        mov  ch,al                     ; Cylinder in CX
-        ror  ah,1                      ; Low 8 bits of cylinder in CH, high 2 bits
-        ror  ah,1                      ;  in CL shifted to bits 6 & 7
-        or   cl,ah                     ; Or with sector number
-        mov  ax,513
-        int  13h     ; DISK - READ SECTORS INTO MEMORY
-                     ; AL = number of sectors to read, CH = track, CL = sector
-                     ; DH = head, DL    = drive, ES:BX -> buffer to fill
-                     ; Return: CF set on error, AH =    status (see AH=01h), AL    = number of sectors read
-        pop  cx
-        pop  dx
-        pop  ax
-        jc   ReadFail
-        inc  ax       ;Increment Sector to Read
-        jnz  NoCarry
-        inc  dx
-
-
-NoCarry:
-        push bx
-        mov  bx,es
-        add  bx,20h
-        mov  es,bx
-        pop  bx
-                                        ; Increment read buffer for next sector
-        loop ReadSectors                ; Read next sector
-
-
-ReadFail:
-        ret   
-
-
-
-; Displays a bad boot message
-; And reboots
-BadBoot:
-        mov  si,msgDiskError    ; Bad boot disk message
-        call PutChars           ; Display it
-        mov  si,msgAnyKey       ; Press any key message
-        call PutChars           ; Display it
-
-		jmp  Reboot
-
-; Displays an error message
-; And reboots
-ErrBoot:
-        mov  si,msgFreeLdr      ; FreeLdr not found message
-        call PutChars           ; Display it
-        mov  si,msgAnyKey       ; Press any key message
-        call PutChars           ; Display it
-
-Reboot:
-        xor ax,ax       
-        int 16h                 ; Wait for a keypress
-        int 19h                 ; Reboot
-
-PutChars:
-        lodsb
-        or al,al
-        jz short Done
-        mov ah,0eh
-        mov bx,07h
-        int 10h
-        jmp short PutChars
-Done:
-        retn
-
-msgDiskError db 'Disk error',0dh,0ah,0
-msgFreeLdr   db 'FREELDR.SYS not found',0dh,0ah,0
-msgAnyKey    db 'Press any key to continue.',0dh,0ah,0
-filename     db 'FREELDR SYS'
-
-        times 510-($-$$) db 0   ; Pad to 510 bytes
-        dw 0aa55h       ; BootSector signature
-        

freeldr/bootsect/BTSECT32.ASM

@@ -1,351 +0,0 @@
-; BTSECT32.ASM
-; FAT32 Boot Sector
-; Copyright (c) 1998, 2000 Brian Palmer
-
-org 7c00h
-
-segment .text
-
-bits 16
-
-start:
-        jmp short main
-        nop
-
-OEMName				db 'FreeLDR!'
-BytesPerSector		dw 512
-SectsPerCluster		db 1
-ReservedSectors		dw 1
-NumberOfFats		db 2
-MaxRootEntries		dw 0			;512 - Always zero for FAT32 volumes
-TotalSectors		dw 0			;2880 - Always zero for FAT32 volumes
-MediaDescriptor		db 0f8h
-SectorsPerFat		dw 0			;9 - Always zero for FAT32 volumes
-SectorsPerTrack		dw 18
-NumberOfHeads		dw 2
-HiddenSectors		dd 0
-TotalSectorsBig		dd 0
-; FAT32 Inserted Info
-SectorsPerFatBig	dd	0
-ExtendedFlags		dw	0
-FSVersion			dw	0
-RootDirStartCluster	dd	0
-FSInfoSector		dw	0
-BackupBootSector	dw	6
-Reserved1			times 12 db 0
-; End FAT32 Inserted Info
-BootDrive			db 0
-Reserved			db 0
-ExtendSig			db 29h
-SerialNumber		dd 00000000h
-VolumeLabel			db 'FreeLoader!'
-FileSystem			db 'FAT32   '
-
-main:
-        cli
-        cld
-        xor ax,ax
-        mov ss,ax
-        mov sp,7c00h            ; Setup a stack
-        mov ax,cs               ; Setup segment registers
-        mov ds,ax               ; Make DS correct
-        mov es,ax               ; Make ES correct
-
-
-        sti                     ; Enable ints now
-        mov [BootDrive],dl      ; Save the boot drive
-        xor ax,ax               ; Zero out AX
-
-        ; Reset disk controller
-        int 13h         
-        jnc Continue
-        jmp BadBoot             ; Reset failed...
-
-Continue:
-		; First we have to load our extra boot code at
-		; sector 14 into memory at [0000:7e00h]
-		xor  dx,dx
-		mov  ax,0eh
-        add  ax,WORD [HiddenSectors] 
-        adc  dx,WORD [HiddenSectors+2] ; Add the number of hidden sectors 
-		mov  cx,1
-        mov  bx,7e0h
-        mov  es,bx				; Read sector to [0000:7e00h]
-		xor  bx,bx
-		call ReadSectors
-		jnc  Continue1
-		jmp  BadBoot
-
-
-Continue1:
-        ; Now we must get the first cluster of the root directory
-		mov  eax,DWORD [RootDirStartCluster]
-		cmp  eax,0ffffff8h		; Check to see if this is the last cluster in the chain
-		jb	 Continue2			; If not continue, if so BadBoot
-		jmp  ErrBoot
-Continue2:
-        mov  bx,800h
-        mov  es,bx				; Read cluster to [0000:8000h]
-        call ReadCluster        ; Read the cluster
-
-
-        ; Now we have to find our way through the root directory to
-        ; The OSLOADER.SYS file
-		xor  bx,bx
-        mov  bl,[SectsPerCluster]
-		shl  bx,4				; BX = BX * 512 / 32
-        mov  ax,800h            ; We loaded at 0800:0000
-        mov  es,ax
-        xor  di,di
-        mov  si,filename
-        mov  cx,11
-        rep  cmpsb              ; Compare filenames
-        jz   FoundFile          ; If same we found it
-        dec  bx
-        jnz  FindFile
-        jmp  ErrBoot
-
-FindFile:
-        mov  ax,es              ; We didn't find it in the previous dir entry
-        add  ax,2               ; So lets move to the next one
-        mov  es,ax              ; And search again
-        xor  di,di
-        mov  si,filename        
-        mov  cx,11
-        rep  cmpsb              ; Compare filenames
-        jz   FoundFile          ; If same we found it
-        dec  bx                 ; Keep searching till we run out of dir entries
-        jnz  FindFile           ; Last entry?
-
-		; Get the next root dir cluster and try again until we run out of clusters
-		mov  eax,DWORD [RootDirStartCluster]
-		call GetFatEntry
-		mov  [RootDirStartCluster],eax
-        jmp  Continue1
-
-FoundFile:
-        xor  di,di              ; ES:DI has dir entry
-        xor  dx,dx
-        mov  ax,WORD [es:di+14h]        ; Get start cluster high word
-		shl  eax,16
-        mov  ax,WORD [es:di+1ah]        ; Get start cluster low word
-
-        mov  bx,800h
-        mov  es,bx
-
-FoundFile2:
-		cmp  eax,0ffffff8h		; Check to see if this is the last cluster in the chain
-		jae	 FoundFile3			; If so continue, if not then read then next one
-		push eax
-        xor  bx,bx              ; Load ROSLDR starting at 0000:8000h
-		push es
-		call ReadCluster
-		pop  es
-
-		xor  bx,bx
-        mov  bl,[SectsPerCluster]
-		shl  bx,5				; BX = BX * 512 / 16
-		mov  ax,es				; Increment the load address by
-		add  ax,bx				; The size of a cluster
-		mov  es,ax
-
-		pop  eax
-		push es
-		call GetFatEntry		; Get the next entry
-		pop  es
-
-        jmp  FoundFile2			; Load the next cluster (if any)
-
-FoundFile3:
-        mov  dl,[BootDrive]
-        xor  ax,ax
-        push ax
-        mov  ax,8000h
-        push ax                 ; We will do a far return to 0000:8000h
-        retf                    ; Transfer control to ROSLDR
-
-
-
-; Reads logical sectors into [ES:BX]
-; DX:AX has logical sector number to read
-; CX has number of sectors to read
-; CarryFlag set on error
-ReadSectors:
-        push ax
-        push dx
-        push cx
-        xchg ax,cx
-        xchg ax,dx
-        xor  dx,dx
-        div  WORD [SectorsPerTrack]
-        xchg ax,cx                    
-        div  WORD [SectorsPerTrack]    ; Divide logical by SectorsPerTrack
-        inc  dx                        ; Sectors numbering starts at 1 not 0
-        xchg cx,dx
-        div  WORD [NumberOfHeads]      ; Number of heads
-        mov  dh,dl                     ; Head to DH, drive to DL
-        mov  dl,[BootDrive]            ; Drive number
-        mov  ch,al                     ; Cylinder in CX
-        ror  ah,1                      ; Low 8 bits of cylinder in CH, high 2 bits
-        ror  ah,1                      ;  in CL shifted to bits 6 & 7
-        or   cl,ah                     ; Or with sector number
-        mov  ax,513
-        int  13h     ; DISK - READ SECTORS INTO MEMORY
-                     ; AL = number of sectors to read, CH = track, CL = sector
-                     ; DH = head, DL    = drive, ES:BX -> buffer to fill
-                     ; Return: CF set on error, AH =    status (see AH=01h), AL    = number of sectors read
-        pop  cx
-        pop  dx
-        pop  ax
-        jc   ReadFail
-        inc  ax       ;Increment Sector to Read
-        jnz  NoCarry
-        inc  dx
-
-
-NoCarry:
-        push bx
-        mov  bx,es
-        add  bx,20h
-        mov  es,bx
-        pop  bx
-                                        ; Increment read buffer for next sector
-        loop ReadSectors                ; Read next sector
-
-
-ReadFail:
-        ret
-
-
-
-
-; Displays a bad boot message
-; And reboots
-BadBoot:
-        mov  si,msgDiskError    ; Bad boot disk message
-        call PutChars           ; Display it
-        mov  si,msgAnyKey       ; Press any key message
-        call PutChars           ; Display it
-
-		jmp  Reboot
-
-; Displays an error message
-; And reboots
-ErrBoot:
-        mov  si,msgFreeLdr      ; FreeLdr not found message
-        call PutChars           ; Display it
-        mov  si,msgAnyKey       ; Press any key message
-        call PutChars           ; Display it
-
-Reboot:
-        xor ax,ax       
-        int 16h                 ; Wait for a keypress
-        int 19h                 ; Reboot
-
-PutChars:
-        lodsb
-        or al,al
-        jz short Done
-        mov ah,0eh
-        mov bx,07h
-        int 10h
-        jmp short PutChars
-Done:
-        retn
-
-msgDiskError db 'Disk error',0dh,0ah,0
-msgFreeLdr   db 'FREELDR.SYS not found',0dh,0ah,0
-msgAnyKey    db 'Press any key to continue.',0dh,0ah,0
-filename     db 'FREELDR SYS'
-
-        times 510-($-$$) db 0   ; Pad to 510 bytes
-        dw 0aa55h       ; BootSector signature
-        
-
-; End of bootsector
-;
-; Now starts the extra boot code that we will store
-; at sector 14 on a FAT32 volume
-;
-; To remain multi-boot compatible with other operating
-; systems we must not overwrite anything other than
-; the bootsector which means we will have to use
-; a different sector like 14 to store our extra boot code
-;
-; Note: Win2k uses sector 12 for this purpose
-
-
-; Returns the FAT entry for a given cluster number
-; On entry EAX has cluster number
-; On return EAX has FAT entry for that cluster
-GetFatEntry:
-
-		shl   eax,2						; EAX = EAX * 4 (since FAT32 entries are 4 bytes)
-		mov   ecx,eax					; Save this for later in ECX
-		xor   edx,edx
-		movzx ebx,WORD [BytesPerSector]
-		push  ebx
-		div   ebx						; FAT Sector Number = EAX / BytesPerSector
-		movzx ebx,WORD [ReservedSectors]
-		add   eax,ebx					; FAT Sector Number += ReservedSectors
-		movzx ebx,WORD [HiddenSectors]
-		add   eax,ebx					; FAT Sector Number += HiddenSectors
-		pop   ebx
-		dec   ebx
-		and   ecx,ebx					; FAT Offset Within Sector = ECX % BytesPerSector
-		; EAX holds logical FAT sector number
-		; ECX holds FAT entry offset
-		push  ecx
-		ror   eax,16
-		mov   dx,ax
-		ror   eax,16
-		; DX:AX holds logical FAT sector number
-        mov  bx,7000h
-        mov  es,bx
-        xor  bx,bx              ; We will load it to [7000:0000h]
-		mov  cx,1
-		call ReadSectors
-		jnc  GetFatEntry1
-		jmp  BadBoot
-GetFatEntry1:
-        mov  bx,7000h
-        mov  es,bx
-		pop  ecx
-		mov  eax,DWORD [es:ecx]		; Get FAT entry
-		and  eax,0fffffffh			; Mask off reserved bits
-
-		ret
-
-
-; Reads cluster number in EAX into [ES:0000]
-ReadCluster:
-		; StartSector = ((Cluster - 2) * SectorsPerCluster) + ReservedSectors + HiddenSectors;
-
-		dec   eax
-		dec   eax
-		xor   edx,edx
-		movzx ebx,BYTE [SectsPerCluster]
-		mul   ebx
-		push  eax
-		xor   edx,edx
-		movzx eax,BYTE [NumberOfFats]
-		mul   DWORD [SectorsPerFatBig]
-		movzx ebx,WORD [ReservedSectors]
-		add   eax,ebx
-		add   eax,DWORD [HiddenSectors]
-		pop   ebx
-		add   eax,ebx			; EAX now contains the logical sector number of the cluster
-		ror   eax,16
-		mov   dx,ax
-		ror   eax,16
-        xor   bx,bx				; We will load it to [ES:0000], ES loaded before function call
-		movzx cx,BYTE [SectsPerCluster]
-		call  ReadSectors
-		jnc   ReadCluster1
-		jmp   BadBoot
-
-ReadCluster1:
-		ret
-
-        times 1022-($-$$) db 0   ; Pad to 1022 bytes
-        dw 0aa55h       ; BootSector signature

freeldr/bootsect/MAKE.BAT

@@ -1,2 +0,0 @@
-nasm -o bootsect.bin -f bin bootsect.asm
-nasm -o btsect32.bin -f bin btsect32.asm

freeldr/bootsect/bootsect.h

@@ -1,35 +0,0 @@
-unsigned char data[] = {
-
-0xeb, 0x3c, 0x90, 0x46, 0x72, 0x65, 0x65, 0x4c, 0x44, 0x52, 0x21, 0x00, 0x02, 0x01, 0x01, 0x00, 
-0x02, 0x00, 0x02, 0x40, 0x0b, 0xf0, 0x09, 0x00, 0x12, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x00, 0x46, 0x72, 0x65, 0x65, 0x4c, 
-0x6f, 0x61, 0x64, 0x65, 0x72, 0x21, 0x46, 0x41, 0x54, 0x31, 0x32, 0x20, 0x20, 0x20, 0xfa, 0xfc, 
-0x31, 0xc0, 0x8e, 0xd0, 0xbc, 0x00, 0x7c, 0x8c, 0xc8, 0x8e, 0xd8, 0x8e, 0xc0, 0xfb, 0x88, 0x16, 
-0x24, 0x7c, 0x31, 0xc0, 0xcd, 0x13, 0x73, 0x03, 0xe9, 0x0b, 0x01, 0x31, 0xc0, 0x31, 0xc9, 0xa0, 
-0x10, 0x7c, 0xf7, 0x26, 0x16, 0x7c, 0x03, 0x06, 0x1c, 0x7c, 0x13, 0x16, 0x1e, 0x7c, 0x03, 0x06, 
-0x0e, 0x7c, 0x11, 0xca, 0x50, 0x52, 0x50, 0x52, 0xb8, 0x20, 0x00, 0xf7, 0x26, 0x11, 0x7c, 0x8b, 
-0x1e, 0x0b, 0x7c, 0x01, 0xd8, 0x48, 0xf7, 0xf3, 0x91, 0x5a, 0x58, 0x51, 0xbb, 0xc0, 0x07, 0x81, 
-0xc3, 0x20, 0x00, 0x8e, 0xc3, 0x31, 0xdb, 0xe8, 0x8c, 0x00, 0x73, 0x03, 0xe9, 0xc7, 0x00, 0x8b, 
-0x1e, 0x11, 0x7c, 0xb8, 0xe0, 0x07, 0x8e, 0xc0, 0x31, 0xff, 0xbe, 0xd8, 0x7d, 0xb9, 0x0b, 0x00, 
-0xf3, 0xa6, 0x74, 0x1f, 0x4b, 0x75, 0x03, 0xe9, 0xbb, 0x00, 0x8c, 0xc0, 0x05, 0x02, 0x00, 0x8e, 
-0xc0, 0x31, 0xff, 0xbe, 0xd8, 0x7d, 0xb9, 0x0b, 0x00, 0xf3, 0xa6, 0x74, 0x06, 0x4b, 0x75, 0xea, 
-0xe9, 0xa2, 0x00, 0x31, 0xff, 0x31, 0xd2, 0x26, 0x8b, 0x45, 0x1a, 0x48, 0x48, 0x30, 0xed, 0x8a, 
-0x0e, 0x0d, 0x7c, 0xf7, 0xe1, 0x59, 0x01, 0xc8, 0x81, 0xd2, 0x00, 0x00, 0x59, 0x5b, 0x01, 0xd8, 
-0x11, 0xca, 0x50, 0x52, 0x26, 0x8b, 0x45, 0x1c, 0x26, 0x8b, 0x55, 0x1e, 0x8b, 0x1e, 0x0b, 0x7c, 
-0x4b, 0x01, 0xd8, 0x81, 0xd2, 0x00, 0x00, 0xf7, 0x36, 0x0b, 0x7c, 0x91, 0x5a, 0x58, 0xbb, 0x00, 
-0x08, 0x8e, 0xc3, 0x31, 0xdb, 0xe8, 0x0e, 0x00, 0x72, 0x4c, 0x8a, 0x16, 0x24, 0x7c, 0x31, 0xc0, 
-0x50, 0xb8, 0x00, 0x80, 0x50, 0xcb, 0x50, 0x52, 0x51, 0x91, 0x92, 0x31, 0xd2, 0xf7, 0x36, 0x18, 
-0x7c, 0x91, 0xf7, 0x36, 0x18, 0x7c, 0x42, 0x87, 0xca, 0xf7, 0x36, 0x1a, 0x7c, 0x88, 0xd6, 0x8a, 
-0x16, 0x24, 0x7c, 0x88, 0xc5, 0xd0, 0xcc, 0xd0, 0xcc, 0x08, 0xe1, 0xb8, 0x01, 0x02, 0xcd, 0x13, 
-0x59, 0x5a, 0x58, 0x72, 0x10, 0x40, 0x75, 0x01, 0x42, 0x53, 0x8c, 0xc3, 0x81, 0xc3, 0x20, 0x00, 
-0x8e, 0xc3, 0x5b, 0xe2, 0xc1, 0xc3, 0xbe, 0x96, 0x7d, 0xe8, 0x1b, 0x00, 0xbe, 0xbb, 0x7d, 0xe8, 
-0x15, 0x00, 0xe9, 0x0c, 0x00, 0xbe, 0xa3, 0x7d, 0xe8, 0x0c, 0x00, 0xbe, 0xbb, 0x7d, 0xe8, 0x06, 
-0x00, 0x31, 0xc0, 0xcd, 0x16, 0xcd, 0x19, 0xac, 0x08, 0xc0, 0x74, 0x09, 0xb4, 0x0e, 0xbb, 0x07, 
-0x00, 0xcd, 0x10, 0xeb, 0xf2, 0xc3, 0x44, 0x69, 0x73, 0x6b, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 
-0x0d, 0x0a, 0x00, 0x46, 0x52, 0x45, 0x45, 0x4c, 0x44, 0x52, 0x2e, 0x53, 0x59, 0x53, 0x20, 0x6e, 
-0x6f, 0x74, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x0d, 0x0a, 0x00, 0x50, 0x72, 0x65, 0x73, 0x73, 
-0x20, 0x61, 0x6e, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, 0x6e, 0x74, 
-0x69, 0x6e, 0x75, 0x65, 0x2e, 0x0d, 0x0a, 0x00, 0x46, 0x52, 0x45, 0x45, 0x4c, 0x44, 0x52, 0x20, 
-0x53, 0x59, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xaa
-};

freeldr/bootsect/btsect32.h

@@ -1,67 +0,0 @@
-unsigned char data[] = {
-
-0xeb, 0x58, 0x90, 0x46, 0x72, 0x65, 0x65, 0x4c, 0x44, 0x52, 0x21, 0x00, 0x02, 0x01, 0x01, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x12, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x00, 0x46, 0x72, 0x65, 0x65, 0x4c, 0x6f, 0x61, 0x64, 0x65, 
-0x72, 0x21, 0x46, 0x41, 0x54, 0x33, 0x32, 0x20, 0x20, 0x20, 0xfa, 0xfc, 0x31, 0xc0, 0x8e, 0xd0, 
-0xbc, 0x00, 0x7c, 0x8c, 0xc8, 0x8e, 0xd8, 0x8e, 0xc0, 0xfb, 0x88, 0x16, 0x40, 0x7c, 0x31, 0xc0, 
-0xcd, 0x13, 0x73, 0x03, 0xe9, 0x05, 0x01, 0x31, 0xd2, 0xb8, 0x0e, 0x00, 0x03, 0x06, 0x1c, 0x7c, 
-0x13, 0x16, 0x1e, 0x7c, 0xb9, 0x01, 0x00, 0xbb, 0xe0, 0x07, 0x8e, 0xc3, 0x31, 0xdb, 0xe8, 0xab, 
-0x00, 0x73, 0x03, 0xe9, 0xe6, 0x00, 0x66, 0xa1, 0x2c, 0x7c, 0x66, 0x3d, 0xf8, 0xff, 0xff, 0x0f, 
-0x72, 0x03, 0xe9, 0xe6, 0x00, 0xbb, 0x00, 0x08, 0x8e, 0xc3, 0xe8, 0xb2, 0x01, 0x31, 0xdb, 0x8a, 
-0x1e, 0x0d, 0x7c, 0xc1, 0xe3, 0x04, 0xb8, 0x00, 0x08, 0x8e, 0xc0, 0x31, 0xff, 0xbe, 0xee, 0x7d, 
-0xb9, 0x0b, 0x00, 0xf3, 0xa6, 0x74, 0x2a, 0x4b, 0x75, 0x03, 0xe9, 0xbe, 0x00, 0x8c, 0xc0, 0x05, 
-0x02, 0x00, 0x8e, 0xc0, 0x31, 0xff, 0xbe, 0xee, 0x7d, 0xb9, 0x0b, 0x00, 0xf3, 0xa6, 0x74, 0x11, 
-0x4b, 0x75, 0xea, 0x66, 0xa1, 0x2c, 0x7c, 0xe8, 0x16, 0x01, 0x66, 0xa3, 0x2c, 0x7c, 0xe9, 0xa5, 
-0xff, 0x31, 0xff, 0x31, 0xd2, 0x26, 0x8b, 0x45, 0x14, 0x66, 0xc1, 0xe0, 0x10, 0x26, 0x8b, 0x45, 
-0x1a, 0xbb, 0x00, 0x08, 0x8e, 0xc3, 0x66, 0x3d, 0xf8, 0xff, 0xff, 0x0f, 0x73, 0x22, 0x66, 0x50, 
-0x31, 0xdb, 0x06, 0xe8, 0x49, 0x01, 0x07, 0x31, 0xdb, 0x8a, 0x1e, 0x0d, 0x7c, 0xc1, 0xe3, 0x05, 
-0x8c, 0xc0, 0x01, 0xd8, 0x8e, 0xc0, 0x66, 0x58, 0x06, 0xe8, 0xd4, 0x00, 0x07, 0xe9, 0xd6, 0xff, 
-0x8a, 0x16, 0x40, 0x7c, 0x31, 0xc0, 0x50, 0xb8, 0x00, 0x80, 0x50, 0xcb, 0x50, 0x52, 0x51, 0x91, 
-0x92, 0x31, 0xd2, 0xf7, 0x36, 0x18, 0x7c, 0x91, 0xf7, 0x36, 0x18, 0x7c, 0x42, 0x87, 0xca, 0xf7, 
-0x36, 0x1a, 0x7c, 0x88, 0xd6, 0x8a, 0x16, 0x40, 0x7c, 0x88, 0xc5, 0xd0, 0xcc, 0xd0, 0xcc, 0x08, 
-0xe1, 0xb8, 0x01, 0x02, 0xcd, 0x13, 0x59, 0x5a, 0x58, 0x72, 0x10, 0x40, 0x75, 0x01, 0x42, 0x53, 
-0x8c, 0xc3, 0x81, 0xc3, 0x20, 0x00, 0x8e, 0xc3, 0x5b, 0xe2, 0xc1, 0xc3, 0xbe, 0xac, 0x7d, 0xe8, 
-0x1b, 0x00, 0xbe, 0xd1, 0x7d, 0xe8, 0x15, 0x00, 0xe9, 0x0c, 0x00, 0xbe, 0xb9, 0x7d, 0xe8, 0x0c, 
-0x00, 0xbe, 0xd1, 0x7d, 0xe8, 0x06, 0x00, 0x31, 0xc0, 0xcd, 0x16, 0xcd, 0x19, 0xac, 0x08, 0xc0, 
-0x74, 0x09, 0xb4, 0x0e, 0xbb, 0x07, 0x00, 0xcd, 0x10, 0xeb, 0xf2, 0xc3, 0x44, 0x69, 0x73, 0x6b, 
-0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x0d, 0x0a, 0x00, 0x46, 0x52, 0x45, 0x45, 0x4c, 0x44, 0x52, 
-0x2e, 0x53, 0x59, 0x53, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x0d, 0x0a, 
-0x00, 0x50, 0x72, 0x65, 0x73, 0x73, 0x20, 0x61, 0x6e, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x74, 
-0x6f, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x2e, 0x0d, 0x0a, 0x00, 0x46, 0x52, 
-0x45, 0x45, 0x4c, 0x44, 0x52, 0x20, 0x53, 0x59, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xaa, 
-0x66, 0xc1, 0xe0, 0x02, 0x66, 0x89, 0xc1, 0x66, 0x31, 0xd2, 0x66, 0x0f, 0xb7, 0x1e, 0x0b, 0x7c, 
-0x66, 0x53, 0x66, 0xf7, 0xf3, 0x66, 0x0f, 0xb7, 0x1e, 0x0e, 0x7c, 0x66, 0x01, 0xd8, 0x66, 0x0f, 
-0xb7, 0x1e, 0x1c, 0x7c, 0x66, 0x01, 0xd8, 0x66, 0x5b, 0x66, 0x4b, 0x66, 0x21, 0xd9, 0x66, 0x51, 
-0x66, 0xc1, 0xc8, 0x10, 0x89, 0xc2, 0x66, 0xc1, 0xc8, 0x10, 0xbb, 0x00, 0x70, 0x8e, 0xc3, 0x31, 
-0xdb, 0xb9, 0x01, 0x00, 0xe8, 0xf5, 0xfe, 0x73, 0x03, 0xe9, 0x30, 0xff, 0xbb, 0x00, 0x70, 0x8e, 
-0xc3, 0x66, 0x59, 0x26, 0x66, 0x67, 0x8b, 0x01, 0x66, 0x25, 0xff, 0xff, 0xff, 0x0f, 0xc3, 0x66, 
-0x48, 0x66, 0x48, 0x66, 0x31, 0xd2, 0x66, 0x0f, 0xb6, 0x1e, 0x0d, 0x7c, 0x66, 0xf7, 0xe3, 0x66, 
-0x50, 0x66, 0x31, 0xd2, 0x66, 0x0f, 0xb6, 0x06, 0x10, 0x7c, 0x66, 0xf7, 0x26, 0x24, 0x7c, 0x66, 
-0x0f, 0xb7, 0x1e, 0x0e, 0x7c, 0x66, 0x01, 0xd8, 0x66, 0x03, 0x06, 0x1c, 0x7c, 0x66, 0x5b, 0x66, 
-0x01, 0xd8, 0x66, 0xc1, 0xc8, 0x10, 0x89, 0xc2, 0x66, 0xc1, 0xc8, 0x10, 0x31, 0xdb, 0x0f, 0xb6, 
-0x0e, 0x0d, 0x7c, 0xe8, 0x96, 0xfe, 0x73, 0x03, 0xe9, 0xd1, 0xfe, 0xc3, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xaa
-};

freeldr/bootsect/c_data.c

@@ -1,49 +0,0 @@
-#include <stdio.h>
-
-char	in_filename[260];
-char	out_filename[260];
-FILE	*in;
-FILE	*out;
-
-int main(void)
-{
-	unsigned char	ch;
-	int				cnt = 0;
-
-	printf("Enter data filename: ");
-	scanf("%s", in_filename);
-	printf("Enter output filename: ");
-	scanf("%s", out_filename);
-
-	if ((in = fopen(in_filename, "rb")) == NULL)
-	{
-		printf("Couldn't open data file.\n");
-		return 0;
-	}
-	if ((out = fopen(out_filename, "wb")) == NULL)
-	{
-		printf("Couldn't open output file.\n");
-		return 0;
-	}
-
-	fprintf(out, "unsigned char data[] = {\n");
-
-	ch = fgetc(in);
-	while (!feof(in))
-	{
-		if (cnt != 0)
-			fprintf(out, ", ");
-		if (!(cnt % 16))
-			fprintf(out, "\n");
-		fprintf(out, "0x%02x", (int)ch);
-		cnt++;
-		ch = fgetc(in);
-	}
-
-	fprintf(out, "\n};");
-
-	fclose(in);
-	fclose(out);
-
-	return 0;
-}

freeldr/bootsect/install.bat

@@ -1 +0,0 @@
-debug bootsect.bin < install.src

freeldr/bootsect/install.src

@@ -1,2 +0,0 @@
-w 100 0 0 1
-q

freeldr/bootsect/win2k-12.asm

@@ -1,197 +0,0 @@
-00008000  660FB64610        movzx eax,byte [bp+NumberOfFats]
-00008005  668B4E24          mov ecx,[bp+SectorsPerFatBig]
-00008009  66F7E1            mul ecx
-0000800C  6603461C          add eax,[bp+HiddenSectors]
-00008010  660FB7560E        movzx edx,word [bp+ReservedSectors]
-00008015  6603C2            add eax,edx
-00008018  668946FC          mov [bp-0x4],eax
-0000801C  66C746F4FFFFFFFF  mov dword [bp-0xc],0xffffffff
-00008024  668B462C          mov eax,[bp+RootDirStartCluster]
-00008028  6683F802          cmp eax,byte +0x2
-0000802C  0F82A6FC          jc near 0x7cd6
-00008030  663DF8FFFF0F      cmp eax,0xffffff8
-00008036  0F839CFC          jnc near 0x7cd6
-0000803A  6650              push eax
-0000803C  6683E802          sub eax,byte +0x2
-00008040  660FB65E0D        movzx ebx,byte [bp+SectsPerCluster]
-00008045  8BF3              mov si,bx
-00008047  66F7E3            mul ebx
-0000804A  660346FC          add eax,[bp-0x4]
-0000804E  BB0082            mov bx,0x8200
-00008051  8BFB              mov di,bx
-00008053  B90100            mov cx,0x1
-00008056  E887FC            call 0x7ce0
-00008059  382D              cmp [di],ch
-0000805B  741E              jz 0x807b
-0000805D  B10B              mov cl,0xb
-0000805F  56                push si
-00008060  BE707D            mov si,0x7d70
-00008063  F3A6              repe cmpsb
-00008065  5E                pop si
-00008066  741B              jz 0x8083
-00008068  03F9              add di,cx
-0000806A  83C715            add di,byte +0x15
-0000806D  3BFB              cmp di,bx
-0000806F  72E8              jc 0x8059
-00008071  4E                dec si
-00008072  75DA              jnz 0x804e
-00008074  6658              pop eax
-00008076  E86500            call 0x80de
-00008079  72BF              jc 0x803a
-0000807B  83C404            add sp,byte +0x4
-0000807E  E955FC            jmp 0x7cd6
-00008081  0020              add [bx+si],ah
-00008083  83C404            add sp,byte +0x4
-00008086  8B7509            mov si,[di+0x9]
-00008089  8B7D0F            mov di,[di+0xf]
-0000808C  8BC6              mov ax,si
-0000808E  66C1E010          shl eax,0x10
-00008092  8BC7              mov ax,di
-00008094  6683F802          cmp eax,byte +0x2
-00008098  0F823AFC          jc near 0x7cd6
-0000809C  663DF8FFFF0F      cmp eax,0xffffff8
-000080A2  0F8330FC          jnc near 0x7cd6
-000080A6  6650              push eax
-000080A8  6683E802          sub eax,byte +0x2
-000080AC  660FB64E0D        movzx ecx,byte [bp+0xd]
-000080B1  66F7E1            mul ecx
-000080B4  660346FC          add eax,[bp-0x4]
-000080B8  BB0000            mov bx,0x0
-000080BB  06                push es
-000080BC  8E068180          mov es,[0x8081]
-000080C0  E81DFC            call 0x7ce0
-000080C3  07                pop es
-000080C4  6658              pop eax
-000080C6  C1EB04            shr bx,0x4
-000080C9  011E8180          add [0x8081],bx
-000080CD  E80E00            call 0x80de
-000080D0  0F830200          jnc near 0x80d6
-000080D4  72D0              jc 0x80a6
-000080D6  8A5640            mov dl,[bp+0x40]
-000080D9  EA00000020        jmp 0x2000:0x0
-000080DE  66C1E002          shl eax,0x2
-000080E2  E81100            call 0x80f6
-000080E5  26668B01          mov eax,[es:bx+di]
-000080E9  6625FFFFFF0F      and eax,0xfffffff
-000080EF  663DF8FFFF0F      cmp eax,0xffffff8
-000080F5  C3                ret
-000080F6  BF007E            mov di,0x7e00
-000080F9  660FB74E0B        movzx ecx,word [bp+0xb]
-000080FE  6633D2            xor edx,edx
-00008101  66F7F1            div ecx
-00008104  663B46F4          cmp eax,[bp-0xc]
-00008108  743A              jz 0x8144
-0000810A  668946F4          mov [bp-0xc],eax
-0000810E  6603461C          add eax,[bp+0x1c]
-00008112  660FB74E0E        movzx ecx,word [bp+0xe]
-00008117  6603C1            add eax,ecx
-0000811A  660FB75E28        movzx ebx,word [bp+0x28]
-0000811F  83E30F            and bx,byte +0xf
-00008122  7416              jz 0x813a
-00008124  3A5E10            cmp bl,[bp+0x10]
-00008127  0F83ABFB          jnc near 0x7cd6
-0000812B  52                push dx
-0000812C  668BC8            mov ecx,eax
-0000812F  668B4624          mov eax,[bp+0x24]
-00008133  66F7E3            mul ebx
-00008136  6603C1            add eax,ecx
-00008139  5A                pop dx
-0000813A  52                push dx
-0000813B  8BDF              mov bx,di
-0000813D  B90100            mov cx,0x1
-00008140  E89DFB            call 0x7ce0
-00008143  5A                pop dx
-00008144  8BDA              mov bx,dx
-00008146  C3                ret
-00008147  0000              add [bx+si],al
-00008149  0000              add [bx+si],al
-0000814B  0000              add [bx+si],al
-0000814D  0000              add [bx+si],al
-0000814F  0000              add [bx+si],al
-00008151  0000              add [bx+si],al
-00008153  0000              add [bx+si],al
-00008155  0000              add [bx+si],al
-00008157  0000              add [bx+si],al
-00008159  0000              add [bx+si],al
-0000815B  0000              add [bx+si],al
-0000815D  0000              add [bx+si],al
-0000815F  0000              add [bx+si],al
-00008161  0000              add [bx+si],al
-00008163  0000              add [bx+si],al
-00008165  0000              add [bx+si],al
-00008167  0000              add [bx+si],al
-00008169  0000              add [bx+si],al
-0000816B  0000              add [bx+si],al
-0000816D  0000              add [bx+si],al
-0000816F  0000              add [bx+si],al
-00008171  0000              add [bx+si],al
-00008173  0000              add [bx+si],al
-00008175  0000              add [bx+si],al
-00008177  0000              add [bx+si],al
-00008179  0000              add [bx+si],al
-0000817B  0000              add [bx+si],al
-0000817D  0000              add [bx+si],al
-0000817F  0000              add [bx+si],al
-00008181  0000              add [bx+si],al
-00008183  0000              add [bx+si],al
-00008185  0000              add [bx+si],al
-00008187  0000              add [bx+si],al
-00008189  0000              add [bx+si],al
-0000818B  0000              add [bx+si],al
-0000818D  0000              add [bx+si],al
-0000818F  0000              add [bx+si],al
-00008191  0000              add [bx+si],al
-00008193  0000              add [bx+si],al
-00008195  0000              add [bx+si],al
-00008197  0000              add [bx+si],al
-00008199  0000              add [bx+si],al
-0000819B  0000              add [bx+si],al
-0000819D  0000              add [bx+si],al
-0000819F  0000              add [bx+si],al
-000081A1  0000              add [bx+si],al
-000081A3  0000              add [bx+si],al
-000081A5  0000              add [bx+si],al
-000081A7  0000              add [bx+si],al
-000081A9  0000              add [bx+si],al
-000081AB  0000              add [bx+si],al
-000081AD  0000              add [bx+si],al
-000081AF  0000              add [bx+si],al
-000081B1  0000              add [bx+si],al
-000081B3  0000              add [bx+si],al
-000081B5  0000              add [bx+si],al
-000081B7  0000              add [bx+si],al
-000081B9  0000              add [bx+si],al
-000081BB  0000              add [bx+si],al
-000081BD  0000              add [bx+si],al
-000081BF  0000              add [bx+si],al
-000081C1  0000              add [bx+si],al
-000081C3  0000              add [bx+si],al
-000081C5  0000              add [bx+si],al
-000081C7  0000              add [bx+si],al
-000081C9  0000              add [bx+si],al
-000081CB  0000              add [bx+si],al
-000081CD  0000              add [bx+si],al
-000081CF  0000              add [bx+si],al
-000081D1  0000              add [bx+si],al
-000081D3  0000              add [bx+si],al
-000081D5  0000              add [bx+si],al
-000081D7  0000              add [bx+si],al
-000081D9  0000              add [bx+si],al
-000081DB  0000              add [bx+si],al
-000081DD  0000              add [bx+si],al
-000081DF  0000              add [bx+si],al
-000081E1  0000              add [bx+si],al
-000081E3  0000              add [bx+si],al
-000081E5  0000              add [bx+si],al
-000081E7  0000              add [bx+si],al
-000081E9  0000              add [bx+si],al
-000081EB  0000              add [bx+si],al
-000081ED  0000              add [bx+si],al
-000081EF  0000              add [bx+si],al
-000081F1  0000              add [bx+si],al
-000081F3  0000              add [bx+si],al
-000081F5  0000              add [bx+si],al
-000081F7  0000              add [bx+si],al
-000081F9  0000              add [bx+si],al
-000081FB  0000              add [bx+si],al
-000081FD  0055AA            add [di-0x56],dl

freeldr/bootsect/win2k.asm

@@ -1,174 +0,0 @@
-segment .text
-
-bits 16
-
-start:
-        jmp short main
-        nop
-
-OEMName				db 'FreeLDR!'
-BytesPerSector		dw 512
-SectsPerCluster		db 1
-ReservedSectors		dw 1
-NumberOfFats		db 2
-MaxRootEntries		dw 0			;512 - Always zero for FAT32 volumes
-TotalSectors		dw 0			;2880 - Always zero for FAT32 volumes
-MediaDescriptor		db 0f8h
-SectorsPerFat		dw 0			;9 - Always zero for FAT32 volumes
-SectorsPerTrack		dw 18
-NumberOfHeads		dw 2
-HiddenSectors		dd 0
-TotalSectorsBig		dd 0
-; FAT32 Inserted Info
-SectorsPerFatBig	dd	0
-ExtendedFlags		dw	0
-FSVersion			dw	0
-RootDirStartCluster	dd	0
-FSInfoSector		dw	0
-BackupBootSector	dw	6
-Reserved1			times 12 db 0
-; End FAT32 Inserted Info
-BootDrive			db 0
-Reserved			db 0
-ExtendSig			db 29h
-SerialNumber		dd 00000000h
-VolumeLabel			db 'FreeLoader!'
-FileSystem			db 'FAT12   '
-
-main:
-00007C5A  33C9              xor		cx,cx
-00007C5C  8ED1              mov		ss,cx
-00007C5E  BCF47B            mov		sp,0x7bf4
-00007C61  8EC1              mov		es,cx
-00007C63  8ED9              mov		ds,cx
-00007C65  BD007C            mov		bp,0x7c00
-00007C68  884E02            mov		[bp+0x2],cl
-00007C6B  8A5640            mov		dl,[bp+BootDrive]
-00007C6E  B408              mov		ah,0x8
-00007C70  CD13              int		0x13			; Int 13, func 8 - Get Drive Parameters
-00007C72  7305              jnc		0x7c79			; If no error jmp
-
-00007C74  B9FFFF            mov		cx,0xffff
-00007C77  8AF1              mov		dh,cl
-
-00007C79  660FB6C6          movzx	eax,dh
-00007C7D  40                inc		ax
-00007C7E  660FB6D1          movzx	edx,cl
-00007C82  80E23F            and		dl,0x3f
-00007C85  F7E2              mul		dx
-00007C87  86CD              xchg	cl,ch
-00007C89  C0ED06            shr		ch,0x6
-00007C8C  41                inc		cx
-00007C8D  660FB7C9          movzx	ecx,cx
-00007C91  66F7E1            mul		ecx
-00007C94  668946F8          mov		[bp-0x8],eax
-00007C98  837E1600          cmp		word [bp+TotalSectors],byte +0x0
-00007C9C  7538              jnz		print_ntldr_error_message
-
-00007C9E  837E2A00          cmp		word [bp+FSVersion],byte +0x0
-00007CA2  7732              ja		print_ntldr_error_message
-
-00007CA4  668B461C          mov		eax,[bp+0x1c]
-00007CA8  6683C00C          add		eax,byte +0xc
-00007CAC  BB0080            mov		bx,0x8000
-00007CAF  B90100            mov		cx,0x1
-00007CB2  E82B00            call	read_sectors
-00007CB5  E94803            jmp		0x8000
-
-print_disk_error_message:
-00007CB8  A0FA7D            mov		al,[DISK_ERR_offset_from_0x7d00]
-putchars:
-00007CBB  B47D              mov		ah,0x7d
-00007CBD  8BF0              mov		si,ax
-get_another_char:
-00007CBF  AC                lodsb
-00007CC0  84C0              test	al,al
-00007CC2  7417              jz		reboot
-00007CC4  3CFF              cmp		al,0xff
-00007CC6  7409              jz		print_reboot_message
-00007CC8  B40E              mov		ah,0xe
-00007CCA  BB0700            mov		bx,0x7
-00007CCD  CD10              int		0x10
-00007CCF  EBEE              jmp		short get_another_char
-print_reboot_message:
-00007CD1  A0FB7D            mov		al,[RESTART_ERR_offset_from_0x7d00]
-00007CD4  EBE5              jmp		short putchars
-print_ntldr_error_message:
-00007CD6  A0F97D            mov		al,[NTLDR_ERR_offset_from_0x7d00]
-00007CD9  EBE0              jmp		short putchars
-reboot:
-00007CDB  98                cbw
-00007CDC  CD16              int		0x16
-00007CDE  CD19              int		0x19
-
-read_sectors:
-00007CE0  6660              pushad
-00007CE2  663B46F8          cmp		eax,[bp-0x8]
-00007CE6  0F824A00          jc		near 0x7d34
-00007CEA  666A00            o32		push byte +0x0
-00007CED  6650              push	eax
-00007CEF  06                push	es
-00007CF0  53                push	bx
-00007CF1  666810000100      push	dword 0x10010
-00007CF7  807E0200          cmp		byte [bp+0x2],0x0
-00007CFB  0F852000          jnz		near 0x7d1f
-00007CFF  B441              mov		ah,0x41
-00007D01  BBAA55            mov		bx,0x55aa
-00007D04  8A5640            mov		dl,[bp+BootDrive]
-00007D07  CD13              int		0x13
-00007D09  0F821C00          jc		near 0x7d29
-00007D0D  81FB55AA          cmp		bx,0xaa55
-00007D11  0F851400          jnz		near 0x7d29
-00007D15  F6C101            test	cl,0x1
-00007D18  0F840D00          jz		near 0x7d29
-00007D1C  FE4602            inc		byte [bp+0x2]
-00007D1F  B442              mov		ah,0x42
-00007D21  8A5640            mov		dl,[bp+BootDrive]
-00007D24  8BF4              mov		si,sp
-00007D26  CD13              int		0x13
-00007D28  B0F9              mov		al,0xf9
-00007D2A  6658              pop		eax
-00007D2C  6658              pop		eax
-00007D2E  6658              pop		eax
-00007D30  6658              pop		eax
-00007D32  EB2A              jmp		short 0x7d5e
-00007D34  6633D2            xor		edx,edx
-00007D37  660FB74E18        movzx	ecx,word [bp+SectorsPerTrack]
-00007D3C  66F7F1            div		ecx
-00007D3F  FEC2              inc		dl
-00007D41  8ACA              mov		cl,dl
-00007D43  668BD0            mov		edx,eax
-00007D46  66C1EA10          shr		edx,0x10
-00007D4A  F7761A            div		word [bp+NumberOfHeads]
-00007D4D  86D6              xchg	dl,dh
-00007D4F  8A5640            mov		dl,[bp+BootDrive]
-00007D52  8AE8              mov		ch,al
-00007D54  C0E406            shl		ah,0x6
-00007D57  0ACC              or		cl,ah
-00007D59  B80102            mov		ax,0x201
-00007D5C  CD13              int		0x13
-00007D5E  6661              popad
-00007D60  0F8254FF          jc		near print_disk_error_message
-00007D64  81C30002          add		bx,0x200
-00007D68  6640              inc		eax
-00007D6A  49                dec		cx
-00007D6B  0F8571FF          jnz		near read_sectors
-00007D6F  C3                ret
-
-NTLDR		db 'NTLDR      '
-
-filler		times 49	db 0
-
-NTLDR_ERR	db 0dh,0ah,'NTLDR is missing',0ffh
-DISK_ERR	db 0dh,0ah,'Disk error',0ffh
-RESTART_ERR	db 0dh,0ah,'Press any key to restart',0dh,0ah
-
-more_filler	times 16	db 0
-
-NTLDR_offset_from_0x7d00						db 0
-NTLDR_ERR_offset_from_0x7d00					db 0ach
-DISK_ERR_offset_from_0x7d00						db 0bfh
-RESTART_ERR_offset_from_0x7d00					db 0cch
-
-						dw 0
-						dw 0aa55h

freeldr/build.bat

@@ -1,7 +0,0 @@
-cd bootsect
-call make.bat
-cd..
-cd freeldr
-make
-copy freeldr.sys ..
-cd ..

freeldr/freeldr/Makefile

@@ -1,89 +0,0 @@
-#
-#  FreeLoader
-#  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
-#
-#  This program is free software; you can redistribute it and/or modify
-#  it under the terms of the GNU General Public License as published by
-#  the Free Software Foundation; either version 2 of the License, or
-#  (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software
-#  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-	
-
-export CC = gcc
-export LD = ld
-export AR = ar
-export RM = cmd /C del
-export CP = cmd /C copy
-
-FLAGS = -Wall -nostdinc -fno-builtin
-
-# asmcode.o has to be first in the link line because it contains the startup code
-OBJS = asmcode.a asmcode.o ros.o boot.o freeldr.o stdlib.o fs.a fs.o fs_fat.o \
-	rosboot.o tui.o menu.o miscboot.o options.o linux.o
-ASM_OBJS = asmcode.o ros.o boot.o
-C_OBJS = freeldr.o stdlib.o fs.a rosboot.o tui.o menu.o miscboot.o options.o linux.o
-
-all:	freeldr.sys
-
-freeldr.sys:	asmcode.a c_code.a
-	$(LD) -N -Ttext=0x8000 --oformat=binary -o freeldr.sys asmcode.a c_code.a
-
-asmcode.a:	$(ASM_OBJS)
-	$(LD) -r -o asmcode.a $(ASM_OBJS)
-
-c_code.a:	$(C_OBJS)
-	$(LD) -r -o c_code.a $(C_OBJS)
-
-asmcode.o:	asmcode.S asmcode.h Makefile
-	$(CC) $(FLAGS) -o asmcode.o -c asmcode.S
-
-freeldr.o:	freeldr.c freeldr.h stdlib.h fs.h rosboot.h tui.h asmcode.h menu.h miscboot.h Makefile
-	$(CC) $(FLAGS) -o freeldr.o -c freeldr.c
-
-stdlib.o:	stdlib.c freeldr.h stdlib.h Makefile
-	$(CC) $(FLAGS) -o stdlib.o -c stdlib.c
-
-fs.a:	fs.o fs_fat.o Makefile
-	$(LD) -r -o fs.a fs.o fs_fat.o
-
-fs.o:	fs.c freeldr.h fs.h stdlib.h tui.h asmcode.h Makefile
-	$(CC) $(FLAGS) -o fs.o -c fs.c
-
-fs_fat.o:	fs_fat.c freeldr.h fs.h stdlib.h tui.h Makefile
-	$(CC) $(FLAGS) -o fs_fat.o -c fs_fat.c
-
-rosboot.o:	rosboot.c freeldr.h rosboot.h stdlib.h fs.h tui.h Makefile
-	$(CC) $(FLAGS) -o rosboot.o -c rosboot.c
-
-ros.o:	ros.S asmcode.h Makefile
-	$(CC) $(FLAGS) -o ros.o -c ros.S
-
-tui.o:	tui.c freeldr.h stdlib.h tui.h Makefile
-	$(CC) $(FLAGS) -o tui.o -c tui.c
-
-menu.o:	menu.c freeldr.h stdlib.h tui.h menu.h Makefile
-	$(CC) $(FLAGS) -o menu.o -c menu.c
-
-boot.o:	boot.S asmcode.h Makefile
-	$(CC) $(FLAGS) -o boot.o -c boot.S
-
-miscboot.o:	miscboot.c freeldr.h asmcode.h stdlib.h fs.h tui.h miscboot.h Makefile
-	$(CC) $(FLAGS) -o miscboot.o -c miscboot.c
-
-options.o:	options.c freeldr.h stdlib.h tui.h options.h Makefile
-	$(CC) $(FLAGS) -o options.o -c options.c
-
-linux.o:	linux.c freeldr.h stdlib.h tui.h linux.h Makefile
-	$(CC) $(FLAGS) -o linux.o -c linux.c
-
-clean:
-	$(RM) $(OBJS)

freeldr/freeldr/asmcode.h

@@ -1,57 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-	
-
-/* Defines needed for switching between real and protected mode */
-#define NULL_DESC	0x00	/* NULL descriptor */
-#define PMODE_CS	0x08	/* PMode code selector, base 0 limit 4g */
-#define PMODE_DS	0x10	/* PMode data selector, base 0 limit 4g */
-#define RMODE_CS	0x18	/* RMode code selector, base 0 limit 64k */
-#define RMODE_DS	0x20	/* RMode data selector, base 0 limit 64k */
-
-#define	KERNEL_BASE	0xC0000000
-//#define	USER_CS		0x08
-//#define	USER_DS		0x10
-//#define	KERNEL_CS	0x20
-//#define	KERNEL_DS	0x28
-#define	KERNEL_CS	0x08
-#define	KERNEL_DS	0x10
-
-#define CR0_PE_SET	0x00000001	/* OR this value with CR0 to enable pmode */
-#define CR0_PE_CLR	0xFFFFFFFE	/* AND this value with CR0 to disable pmode */
-
-#define	NR_TASKS	128		/* Space reserved in the GDT for TSS descriptors */
-
-#define STACK16ADDR	0x7000	/* The 16-bit stack top will be at 0000:7000 */
-#define STACK32ADDR	0x60000	/* The 32-bit stack top will be at 6000:0000, or 0x60000 */
-
-#define FILESYSADDR	0x80000	/* The filesystem data address will be at 8000:0000, or 0x80000 */
-
-#define FATCLUSTERBUF	0x60000	/* The fat filesystem's cluster buffer */
-
-#define SCREENBUFFER	0x68000	/* The screen contents will be saved here */
-#define FREELDRINIADDR	0x6C000	/* The freeldr.ini load address will be at 6000:C000, or 0x6C000 */
-
-#define	SCRATCHSEG	0x7000	/* The 512-byte fixed scratch area will be at 7000:0000, or 0x70000 */
-#define	SCRATCHOFF	0x0000	/* The 512-byte fixed scratch area will be at 7000:0000, or 0x70000 */
-#define	SCRATCHAREA	0x70000	/* The 512-byte fixed scratch area will be at 7000:0000, or 0x70000 */
-
-/* Makes "x" a global variable or label */
-#define EXTERN(x)	.global x; x:
-

freeldr/freeldr/boot.S

@@ -1,45 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-	.text
-	.code16
-
-#include "asmcode.h"
-
-
-	.code32
-EXTERN(_JumpToBootCode)
-	call	switch_to_real
-	.code16
-
-	/* Set the boot drive */
-	movb	(_BootDrive),%dl
-
-	ljmpl	$0x0000,$0x7C00
-
-
-	.code32
-EXTERN(_JumpToLinuxBootCode)
-	call	switch_to_real
-	.code16
-
-	/* Set the boot drive */
-	movb	(_BootDrive),%dl
-
-	ljmpl	$0x0200,$0x9000

freeldr/freeldr/freeldr.c

@@ -1,734 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-	
-#include "freeldr.h"
-#include "stdlib.h"
-#include "fs.h"
-#include "rosboot.h"
-#include "tui.h"
-#include "asmcode.h"
-#include "menu.h"
-#include "miscboot.h"
-#include "linux.h"
-
-// Variable BootDrive moved to asmcode.S
-//unsigned int	BootDrive = 0;		// BIOS boot drive, 0-A:, 1-B:, 0x80-C:, 0x81-D:, etc.
-unsigned int	BootPartition = 0;	// Boot Partition, 1-4
-BOOL			bTUILoaded = FALSE; // Tells us if the user interface is loaded
-
-char			*pFreeldrIni = (char *)(FREELDRINIADDR); // Load address for freeldr.ini
-char			*pScreenBuffer = (char *)(SCREENBUFFER); // Save address for screen contents
-int				nCursorXPos = 0;	// Cursor's X Position
-int				nCursorYPos = 0;	// Cursor's Y Position
-
-OSTYPE			OSList[16];
-int				nNumOS = 0;
-
-int				nTimeOut = -1;		// Time to wait for the user before booting
-
-void BootMain(void)
-{
-	int		i;
-	char	name[1024];
-	char	value[1024];
-	int		nOSToBoot;
-
-	enable_a20();
-
-	SaveScreen(pScreenBuffer);
-	nCursorXPos = wherex();
-	nCursorYPos = wherey();
-
-	printf("Loading FreeLoader...\n");
-
-	if (!ParseIniFile())
-	{
-		printf("Press any key to reboot.\n");
-		getch();
-		return;
-	}
-
-	clrscr();
-	hidecursor();
-	// Draw the backdrop and title box
-	DrawBackdrop();
-	bTUILoaded = TRUE;
-
-	if (nNumOS == 0)
-	{
-		DrawStatusText(" Press ENTER to reboot");
-		MessageBox("Error: there were no operating systems listed to boot.\nPress ENTER to reboot.");
-		clrscr();
-		showcursor();
-		RestoreScreen(pScreenBuffer);
-		return;
-	}
-	
-
-	DrawStatusText(" Press ENTER to continue");
-	// Find all the message box settings and run them
-	for (i=1; i<=GetNumSectionItems("FREELOADER"); i++)
-	{
-		ReadSectionSettingByNumber("FREELOADER", i, name, value);
-		if (stricmp(name, "MessageBox") == 0)
-			MessageBox(value);
-		if (stricmp(name, "MessageLine") == 0)
-			MessageLine(value);
-	}
-
-	for (;;)
-	{
-		nOSToBoot = RunMenu();
-
-		LoadAndBootLinux(0x80, 0, "vmlinuz", "");
-		switch (OSList[nOSToBoot].nOSType)
-		{
-		case OSTYPE_REACTOS:
-			LoadAndBootReactOS(nOSToBoot);
-			break;
-		case OSTYPE_LINUX:
-			MessageBox("Cannot boot this OS type yet!");
-			break;
-		case OSTYPE_BOOTSECTOR:
-			LoadAndBootBootSector(nOSToBoot);
-			break;
-		case OSTYPE_PARTITION:
-			LoadAndBootPartition(nOSToBoot);
-			break;
-		case OSTYPE_DRIVE:
-			LoadAndBootDrive(nOSToBoot);
-			break;
-		}
-	}
-
-	MessageBox("Press any key to reboot.");
-	RestoreScreen(pScreenBuffer);
-	showcursor();
-	gotoxy(nCursorXPos, nCursorYPos);
-}
-
-BOOL ParseIniFile(void)
-{
-	int		i;
-	char	name[1024];
-	char	value[1024];
-	FILE	Freeldr_Ini;	// File handle for freeldr.ini
-
-	// Open the boot drive for file access
-	if(!OpenDiskDrive(BootDrive, 0))
-	{
-		printf("Error opening boot drive for file access.\n");
-		return FALSE;
-	}
-
-	// Try to open freeldr.ini or fail
-	if(!OpenFile("freeldr.ini", &Freeldr_Ini))
-	{
-		printf("FREELDR.INI not found.\nYou need to re-install FreeLoader.\n");
-		return FALSE;
-	}
-
-	// Check and see if freeldr.ini is too big
-	// if so display a warning
-	if(GetFileSize(&Freeldr_Ini) > 0x4000)
-	{
-		printf("Warning: FREELDR.INI is bigger than 16k.\n");
-		printf("Only 16k of it will be loaded off the disk.\n");
-		printf("Press any key to continue.\n");
-		getch();
-	}
-
-	// Read freeldr.ini off the disk
-	ReadFile(&Freeldr_Ini, 0x4000, pFreeldrIni);
-
-	// Make sure the [FREELOADER] section exists
-	if(!GetNumSectionItems("FREELOADER"))
-	{
-		printf("Section [FREELOADER] not found in FREELDR.INI.\nYou need to re-install FreeLoader.\n");
-		return FALSE;
-	}
-
-	// Validate the settings in the [FREELOADER] section
-	for(i=1; i<=GetNumSectionItems("FREELOADER"); i++)
-	{
-		ReadSectionSettingByNumber("FREELOADER", i, name, value);
-		if(!IsValidSetting(name, value))
-		{
-			printf("Invalid setting in freeldr.ini.\nName: \"%s\", Value: \"%s\"\n", name, value);
-			printf("Press any key to continue.\n");
-			getch();
-		}
-		else
-			SetSetting(name, value);
-	}
-
-	return TRUE;
-}
-
-int GetNumSectionItems(char *section)
-{
-	int		i;
-	char	str[1024];
-	char	real_section[1024];
-	int		num_items = 0;
-	int		freeldr_ini_offset;
-	BOOL	bFoundSection = FALSE;
-
-	// Get the real section name
-	strcpy(real_section, "[");
-	strcat(real_section, section);
-	strcat(real_section, "]");
-
-	// Get to the beginning of the file
-	freeldr_ini_offset = 0;
-
-	// Find the section
-	while(freeldr_ini_offset < 0x4000)
-	{
-		// Read a line 
-		for(i=0; i<1024; i++,freeldr_ini_offset++)
-		{
-			if((freeldr_ini_offset < 0x4000) && (pFreeldrIni[freeldr_ini_offset] != '\n'))
-				str[i] = pFreeldrIni[freeldr_ini_offset];
-			else
-			{
-				freeldr_ini_offset++;
-				break;
-			}
-		}
-		str[i] = '\0';
-		//fgets(str, 1024, &Freeldr_Ini);
-
-		// Get rid of newline & linefeed characters (if any)
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-
-		// Skip comments
-		if(str[0] == '#')
-			continue;
-
-		// Skip blank lines
-		if(!strlen(str))
-			continue;
-
-		// If it isn't a section header then continue on
-		if(str[0] != '[')
-			continue;
-
-		// Check and see if we found it
-		if(stricmp(str, real_section) == 0)
-		{
-			bFoundSection = TRUE;
-			break;
-		}
-	}
-
-	// If we didn't find the section then we're outta here
-	if(!bFoundSection)
-		return 0;
-
-	// Now count how many settings are in this section
-	while(freeldr_ini_offset < 0x4000)
-	{
-		// Read a line 
-		for(i=0; i<1024; i++,freeldr_ini_offset++)
-		{
-			if((freeldr_ini_offset < 0x4000) && (pFreeldrIni[freeldr_ini_offset] != '\n'))
-				str[i] = pFreeldrIni[freeldr_ini_offset];
-			else
-			{
-				freeldr_ini_offset++;
-				break;
-			}
-		}
-		str[i] = '\0';
-		//fgets(str, 1024, &Freeldr_Ini);
-
-		// Get rid of newline & linefeed characters (if any)
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-
-		// Skip comments
-		if(str[0] == '#')
-			continue;
-
-		// Skip blank lines
-		if(!strlen(str))
-			continue;
-
-		// If we hit a new section then we're done
-		if(str[0] == '[')
-			break;
-
-		num_items++;
-	}
-
-	return num_items;
-}
-
-BOOL ReadSectionSettingByNumber(char *section, int num, char *name, char *value)
-{
-	char	str[1024];
-	char	real_section[1024];
-	int		num_items = 0;
-	int		i;
-	int		freeldr_ini_offset;
-	BOOL	bFoundSection = FALSE;
-
-	// Get the real section name
-	strcpy(real_section, "[");
-	strcat(real_section, section);
-	strcat(real_section, "]");
-
-	// Get to the beginning of the file
-	freeldr_ini_offset = 0;
-
-	// Find the section
-	while(freeldr_ini_offset < 0x4000)
-	{
-		// Read a line 
-		for(i=0; i<1024; i++,freeldr_ini_offset++)
-		{
-			if((freeldr_ini_offset < 0x4000) && (pFreeldrIni[freeldr_ini_offset] != '\n'))
-				str[i] = pFreeldrIni[freeldr_ini_offset];
-			else
-			{
-				freeldr_ini_offset++;
-				break;
-			}
-		}
-		str[i] = '\0';
-		//fgets(str, 1024, &Freeldr_Ini);
-
-		// Get rid of newline & linefeed characters (if any)
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-
-		// Skip comments
-		if(str[0] == '#')
-			continue;
-
-		// Skip blank lines
-		if(!strlen(str))
-			continue;
-
-		// If it isn't a section header then continue on
-		if(str[0] != '[')
-			continue;
-
-		// Check and see if we found it
-		if(stricmp(str, real_section) == 0)
-		{
-			bFoundSection = TRUE;
-			break;
-		}
-	}
-
-	// If we didn't find the section then we're outta here
-	if(!bFoundSection)
-		return FALSE;
-
-	// Now find the setting we are looking for
-	while(freeldr_ini_offset < 0x4000)
-	{
-		// Read a line 
-		for(i=0; i<1024; i++,freeldr_ini_offset++)
-		{
-			if((freeldr_ini_offset < 0x4000) && (pFreeldrIni[freeldr_ini_offset] != '\n'))
-				str[i] = pFreeldrIni[freeldr_ini_offset];
-			else
-			{
-				freeldr_ini_offset++;
-				break;
-			}
-		}
-		str[i] = '\0';
-		//fgets(str, 1024, &Freeldr_Ini);
-
-		// Get rid of newline & linefeed characters (if any)
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-
-		// Skip comments
-		if(str[0] == '#')
-			continue;
-
-		// Skip blank lines
-		if(!strlen(str))
-			continue;
-
-		// If we hit a new section then we're done
-		if(str[0] == '[')
-			break;
-
-		// Increment setting number
-		num_items++;
-
-		// Check and see if we found the setting
-		if(num_items == num)
-		{
-			for(i=0; i<strlen(str); i++)
-			{
-				// Check and see if this character is the separator
-				if(str[i] == '=')
-				{
-					name[i] = '\0';
-
-					strcpy(value, str+i+1);
-
-					return TRUE;
-				}
-				else
-					name[i] = str[i];
-			}
-		}
-	}
-
-	return FALSE;
-}
-
-BOOL ReadSectionSettingByName(char *section, char *valuename, char *name, char *value)
-{
-	char	str[1024];
-	char	real_section[1024];
-	char	temp[1024];
-	int		i;
-	int		freeldr_ini_offset;
-	BOOL	bFoundSection = FALSE;
-
-	// Get the real section name
-	strcpy(real_section, "[");
-	strcat(real_section, section);
-	strcat(real_section, "]");
-
-	// Get to the beginning of the file
-	freeldr_ini_offset = 0;
-
-	// Find the section
-	while(freeldr_ini_offset < 0x4000)
-	{
-		// Read a line 
-		for(i=0; i<1024; i++,freeldr_ini_offset++)
-		{
-			if((freeldr_ini_offset < 0x4000) && (pFreeldrIni[freeldr_ini_offset] != '\n'))
-				str[i] = pFreeldrIni[freeldr_ini_offset];
-			else
-			{
-				freeldr_ini_offset++;
-				break;
-			}
-		}
-		str[i] = '\0';
-		//fgets(str, 1024, &Freeldr_Ini);
-
-		// Get rid of newline & linefeed characters (if any)
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-
-		// Skip comments
-		if(str[0] == '#')
-			continue;
-
-		// Skip blank lines
-		if(!strlen(str))
-			continue;
-
-		// If it isn't a section header then continue on
-		if(str[0] != '[')
-			continue;
-
-		// Check and see if we found it
-		if(stricmp(str, real_section) == 0)
-		{
-			bFoundSection = TRUE;
-			break;
-		}
-	}
-
-	// If we didn't find the section then we're outta here
-	if(!bFoundSection)
-		return FALSE;
-
-	// Now find the setting we are looking for
-	while(freeldr_ini_offset < 0x4000)
-	{
-		// Read a line 
-		for(i=0; i<1024; i++,freeldr_ini_offset++)
-		{
-			if((freeldr_ini_offset < 0x4000) && (pFreeldrIni[freeldr_ini_offset] != '\n'))
-				str[i] = pFreeldrIni[freeldr_ini_offset];
-			else
-			{
-				freeldr_ini_offset++;
-				break;
-			}
-		}
-		str[i] = '\0';
-		//fgets(str, 1024, &Freeldr_Ini);
-
-		// Get rid of newline & linefeed characters (if any)
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-		if((str[strlen(str)-1] == '\n') || (str[strlen(str)-1] == '\r'))
-			str[strlen(str)-1] = '\0';
-
-		// Skip comments
-		if(str[0] == '#')
-			continue;
-
-		// Skip blank lines
-		if(!strlen(str))
-			continue;
-
-		// If we hit a new section then we're done
-		if(str[0] == '[')
-			break;
-
-		// Extract the setting name
-		for(i=0; i<strlen(str); i++)
-		{
-			if(str[i] != '=')
-				temp[i] = str[i];
-			else
-			{
-				temp[i] = '\0';
-				break;
-			}
-		}
-
-		// Check and see if we found the setting
-		if(stricmp(temp, valuename) == 0)
-		{
-			for(i=0; i<strlen(str); i++)
-			{
-				// Check and see if this character is the separator
-				if(str[i] == '=')
-				{
-					name[i] = '\0';
-
-					strcpy(value, str+i+1);
-
-					return TRUE;
-				}
-				else
-					name[i] = str[i];
-			}
-		}
-	}
-
-	return FALSE;
-}
-
-BOOL IsValidSetting(char *setting, char *value)
-{
-	if(stricmp(setting, "MessageBox") == 0)
-		return TRUE;
-	else if(stricmp(setting, "MessageLine") == 0)
-		return TRUE;
-	else if(stricmp(setting, "TitleText") == 0)
-		return TRUE;
-	else if(stricmp(setting, "StatusBarColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "StatusBarTextColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "BackdropTextColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "BackdropColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "BackdropFillStyle") == 0)
-	{
-		if(IsValidFillStyle(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "TitleBoxTextColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "TitleBoxColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "MessageBoxTextColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "MessageBoxColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "MenuTextColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "MenuColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "TextColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "SelectedTextColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "SelectedColor") == 0)
-	{
-		if(IsValidColor(value))
-			return TRUE;
-	}
-	else if(stricmp(setting, "OS") == 0)
-		return TRUE;
-	else if(stricmp(setting, "TimeOut") == 0)
-		return TRUE;
-	/*else if(stricmp(setting, "") == 0)
-		return TRUE;
-	else if(stricmp(setting, "") == 0)
-		return TRUE;
-	else if(stricmp(setting, "") == 0)
-		return TRUE;
-	else if(stricmp(setting, "") == 0)
-		return TRUE;
-	else if(stricmp(setting, "") == 0)
-		return TRUE;
-	else if(stricmp(setting, "") == 0)
-		return TRUE;
-	else if(stricmp(setting, "") == 0)
-		return TRUE;*/
-
-	return FALSE;
-}
-
-void SetSetting(char *setting, char *value)
-{
-	char	name[260];
-	char	v[260];
-
-	if(stricmp(setting, "TitleText") == 0)
-		strcpy(szTitleBoxTitleText, value);
-	else if(stricmp(setting, "StatusBarColor") == 0)
-		cStatusBarBgColor = TextToColor(value);
-	else if(stricmp(setting, "StatusBarTextColor") == 0)
-		cStatusBarFgColor = TextToColor(value);
-	else if(stricmp(setting, "BackdropTextColor") == 0)
-		cBackdropFgColor = TextToColor(value);
-	else if(stricmp(setting, "BackdropColor") == 0)
-		cBackdropBgColor = TextToColor(value);
-	else if(stricmp(setting, "BackdropFillStyle") == 0)
-		cBackdropFillStyle = TextToFillStyle(value);
-	else if(stricmp(setting, "TitleBoxTextColor") == 0)
-		cTitleBoxFgColor = TextToColor(value);
-	else if(stricmp(setting, "TitleBoxColor") == 0)
-		cTitleBoxBgColor = TextToColor(value);
-	else if(stricmp(setting, "MessageBoxTextColor") == 0)
-		cMessageBoxFgColor = TextToColor(value);
-	else if(stricmp(setting, "MessageBoxColor") == 0)
-		cMessageBoxBgColor = TextToColor(value);
-	else if(stricmp(setting, "MenuTextColor") == 0)
-		cMenuFgColor = TextToColor(value);
-	else if(stricmp(setting, "MenuColor") == 0)
-		cMenuBgColor = TextToColor(value);
-	else if(stricmp(setting, "TextColor") == 0)
-		cTextColor = TextToColor(value);
-	else if(stricmp(setting, "SelectedTextColor") == 0)
-		cSelectedTextColor = TextToColor(value);
-	else if(stricmp(setting, "SelectedColor") == 0)
-		cSelectedTextBgColor = TextToColor(value);
-	else if(stricmp(setting, "OS") == 0)
-	{
-		if(nNumOS >= 16)
-		{
-			printf("Error: you can only boot to at most 16 different operating systems.\n");
-			printf("Press any key to continue\n");
-			getch();
-			return;
-		}
-
-		if(!GetNumSectionItems(value))
-		{
-			printf("Error: OS \"%s\" listed.\n", value);
-			printf("It does not have it's own [section], or it is empty.\n");
-			printf("Press any key to continue\n");
-			getch();
-			return;
-		}
-
-		strcpy(OSList[nNumOS].name, value);
-
-		if (!ReadSectionSettingByName(value, "BootType", name, v))
-		{
-			printf("Unknown BootType for OS \"%s\"\n", value);
-			printf("Press any key to continue\n");
-			getch();
-			return;
-		}
-
-		if (stricmp(v, "ReactOS") == 0)
-			OSList[nNumOS].nOSType = OSTYPE_REACTOS;
-		else if (stricmp(v, "Linux") == 0)
-			OSList[nNumOS].nOSType = OSTYPE_LINUX;
-		else if (stricmp(v, "BootSector") == 0)
-			OSList[nNumOS].nOSType = OSTYPE_BOOTSECTOR;
-		else if (stricmp(v, "Partition") == 0)
-			OSList[nNumOS].nOSType = OSTYPE_PARTITION;
-		else if (stricmp(v, "Drive") == 0)
-			OSList[nNumOS].nOSType = OSTYPE_DRIVE;
-		else
-		{
-			printf("Unknown BootType for OS \"%s\"\n", value);
-			printf("Press any key to continue\n");
-			getch();
-			return;
-		}
-
-		nNumOS++;
-	}
-	else if(stricmp(setting, "TimeOut") == 0)
-		nTimeOut = atoi(value);
-}

freeldr/freeldr/freeldr.h

@@ -1,82 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef __FREELDR_H
-#define __FREELDR_H
-
-
-/* just some stuff */
-#define VERSION		"FreeLoader v0.8"
-#define COPYRIGHT	"Copyright (C) 1999, 2000 Brian Palmer <brianp@sginet.com>"
-
-#define ROSLDR_MAJOR_VERSION	0
-#define ROSLDR_MINOR_VERSION	8
-#define ROSLDR_PATCH_VERSION	0
-
-#define	size_t	unsigned int
-#define BOOL	int
-#define	NULL	0
-#define	TRUE	1
-#define FALSE	0
-#define BYTE	unsigned char
-#define WORD	unsigned short
-#define DWORD	unsigned long
-#define CHAR	char
-#define WCHAR	unsigned short
-#define LONG	long
-#define ULONG	unsigned long
-#define PULONG	unsigned long *
-#define PDWORD	DWORD *
-#define PWORD	WORD *
-
-#define	OSTYPE_REACTOS		1
-#define OSTYPE_LINUX		2
-#define OSTYPE_BOOTSECTOR	3
-#define OSTYPE_PARTITION	4
-#define OSTYPE_DRIVE		5
-
-typedef struct
-{
-	char	name[260];
-	int		nOSType;			// ReactOS or Linux or a bootsector, etc.
-} OSTYPE;
-
-extern unsigned int	BootDrive; // BIOS boot drive, 0-A:, 1-B:, 0x80-C:, 0x81-D:, etc.
-extern unsigned int	BootPartition;	// Boot Partition, 1-4
-extern BOOL			bTUILoaded; // Tells us if the user interface is loaded
-
-extern char			*pFreeldrIni; // Load address for freeldr.ini
-extern char			*pScreenBuffer; // Save address for screen contents
-extern int			nCursorXPos;	// Cursor's X Position
-extern int			nCursorYPos;	// Cursor's Y Position
-
-extern OSTYPE		OSList[16]; // The OS list
-extern int			nNumOS;		// Number of OSes listed
-
-extern int			nTimeOut;		// Time to wait for the user before booting
-
-void	BootMain(void);
-BOOL	ParseIniFile(void);
-int		GetNumSectionItems(char *section); // returns the number of items in a particular section (i.e. [FREELOADER])
-BOOL	ReadSectionSettingByNumber(char *section, int num, char *name, char *value); // Reads the num'th value from section
-BOOL	ReadSectionSettingByName(char *section, char *valuename, char *name, char *value); // Reads the value named name from section
-BOOL	IsValidSetting(char *setting, char *value);
-void	SetSetting(char *setting, char *value);
-
-#endif  // defined __FREELDR_H

freeldr/freeldr/fs.c

@@ -1,426 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include "freeldr.h"
-#include "fs.h"
-#include "stdlib.h"
-#include "tui.h"
-#include "asmcode.h"
-
-#define	FS_DO_ERROR(s)	\
-	{ \
-		if (bTUILoaded) \
-			MessageBox(s); \
-		else \
-		{ \
-			printf(s); \
-			printf("\nPress any key\n"); \
-			getch(); \
-		} \
-	}
-
-
-int		nSectorBuffered  = -1;	// Tells us which sector was read into SectorBuffer[]
-
-BYTE	SectorBuffer[512];		// 512 byte buffer space for read operations, ReadOneSector reads to here
-
-int		FSType = NULL;			// Type of filesystem on boot device, set by OpenDiskDrive()
-
-char	*pFileSysData = (char *)(FILESYSADDR); // Load address for filesystem data
-char	*pFat32FATCacheIndex = (char *)(FILESYSADDR); // Load address for filesystem data
-
-BOOL OpenDiskDrive(int nDrive, int nPartition)
-{
-	int		num_bootable_partitions = 0;
-	int		boot_partition = 0;
-	int		partition_type = 0;
-	int		head, sector, cylinder;
-	int		offset;
-
-	// Check and see if it is a floppy drive
-	if (nDrive < 0x80)
-	{
-		// Read boot sector
-		if (!biosdisk(_DISK_READ, nDrive, 0, 0, 1, 1, SectorBuffer))
-		{
-			FS_DO_ERROR("Disk Read Error");
-			return FALSE;
-		}
-
-		// Check for validity
-		if (*((WORD*)(SectorBuffer + 0x1fe)) != 0xaa55)//(SectorBuffer[0x1FE] != 0x55) || (SectorBuffer[0x1FF] != 0xAA))
-		{
-			FS_DO_ERROR("Invalid boot sector magic (0xaa55)");
-			return FALSE;
-		}
-	}
-	else
-	{
-		// Read master boot record
-		if (!biosdisk(_DISK_READ, nDrive, 0, 0, 1, 1, SectorBuffer))
-		{
-			FS_DO_ERROR("Disk Read Error");
-			return FALSE;
-		}
-
-		// Check for validity
-		if (*((WORD*)(SectorBuffer + 0x1fe)) != 0xaa55)//(SectorBuffer[0x1FE] != 0x55) || (SectorBuffer[0x1FF] != 0xAA))
-		{
-			FS_DO_ERROR("Invalid partition table magic (0xaa55)");
-			return FALSE;
-		}
-
-		if (nPartition == 0)
-		{
-			// Check for bootable partitions
-			if (SectorBuffer[0x1BE] == 0x80)
-				num_bootable_partitions++;
-			if (SectorBuffer[0x1CE] == 0x80)
-			{
-				num_bootable_partitions++;
-				boot_partition = 1;
-			}
-			if (SectorBuffer[0x1DE] == 0x80)
-			{
-				num_bootable_partitions++;
-				boot_partition = 2;
-			}
-			if (SectorBuffer[0x1EE] == 0x80)
-			{
-				num_bootable_partitions++;
-				boot_partition = 3;
-			}
-
-			// Make sure there was only one bootable partition
-			if (num_bootable_partitions > 1)
-			{
-				FS_DO_ERROR("Too many boot partitions");
-				return FALSE;
-			}
-
-			offset = 0x1BE + (boot_partition * 0x10);
-		}
-		else
-			offset = 0x1BE + ((nPartition-1) * 0x10);
-
-		partition_type = SectorBuffer[offset + 4];
-
-		// Check for valid partition
-		if (partition_type == 0)
-		{
-			FS_DO_ERROR("Invalid boot partition");
-			return FALSE;
-		}
-
-		head = SectorBuffer[offset + 1];
-		sector = (SectorBuffer[offset + 2] & 0x3F);
-		cylinder = SectorBuffer[offset + 3];
-		if (SectorBuffer[offset + 2] & 0x80)
-			cylinder += 0x200;
-		if (SectorBuffer[offset + 2] & 0x40)
-			cylinder += 0x100;
-
-		// Read partition boot sector
-		if (!biosdisk(_DISK_READ, nDrive, head, cylinder, sector, 1, SectorBuffer))
-		{
-			FS_DO_ERROR("Disk Read Error");
-			return FALSE;
-		}
-
-		// Check for validity
-		if (*((WORD*)(SectorBuffer + 0x1fe)) != 0xaa55)//(SectorBuffer[0x1FE] != 0x55) || (SectorBuffer[0x1FF] != 0xAA))
-		{
-			FS_DO_ERROR("Invalid boot sector magic (0xaa55)");
-			return FALSE;
-		}
-	}
-
-
-	// Reset data
-	nBytesPerSector = 0;
-	nSectorsPerCluster = 0;
-	nReservedSectors = 0;
-	nNumberOfFATs = 0;
-	nRootDirEntries = 0;
-	nTotalSectors16 = 0;
-	nSectorsPerFAT16 = 0;
-	nSectorsPerTrack = 0;
-	nNumberOfHeads = 0;
-	nHiddenSectors = 0;
-	nTotalSectors32 = 0;
-
-	nSectorsPerFAT32 = 0;
-	nExtendedFlags = 0;
-	nFileSystemVersion = 0;
-	nRootDirStartCluster = 0;
-
-	nRootDirSectorStart = 0;
-	nDataSectorStart = 0;
-	nSectorsPerFAT = 0;
-	nRootDirSectors = 0;
-	nTotalSectors = 0;
-	nNumberOfClusters = 0;
-
-	// Get data
-	memcpy(&nBytesPerSector, SectorBuffer + BPB_BYTESPERSECTOR, 2);
-	memcpy(&nSectorsPerCluster, SectorBuffer + BPB_SECTORSPERCLUSTER, 1);
-	memcpy(&nReservedSectors, SectorBuffer + BPB_RESERVEDSECTORS, 2);
-	memcpy(&nNumberOfFATs, SectorBuffer + BPB_NUMBEROFFATS, 1);
-	memcpy(&nRootDirEntries, SectorBuffer + BPB_ROOTDIRENTRIES, 2);
-	memcpy(&nTotalSectors16, SectorBuffer + BPB_TOTALSECTORS16, 2);
-	memcpy(&nSectorsPerFAT16, SectorBuffer + BPB_SECTORSPERFAT16, 2);
-	memcpy(&nSectorsPerTrack, SectorBuffer + BPB_SECTORSPERTRACK, 2);
-	memcpy(&nNumberOfHeads, SectorBuffer + BPB_NUMBEROFHEADS, 2);
-	memcpy(&nHiddenSectors, SectorBuffer + BPB_HIDDENSECTORS, 4);
-	memcpy(&nTotalSectors32, SectorBuffer + BPB_TOTALSECTORS32, 4);
-
-	memcpy(&nSectorsPerFAT32, SectorBuffer + BPB_SECTORSPERFAT32, 4);
-	memcpy(&nExtendedFlags, SectorBuffer + BPB_EXTENDEDFLAGS32, 2);
-	memcpy(&nFileSystemVersion, SectorBuffer + BPB_FILESYSTEMVERSION32, 2);
-	memcpy(&nRootDirStartCluster, SectorBuffer + BPB_ROOTDIRSTARTCLUSTER32, 4);
-
-	// Calc some stuff
-	if (nTotalSectors16 != 0)
-		nTotalSectors = nTotalSectors16;
-	else
-		nTotalSectors = nTotalSectors32; 
-
-	if (nSectorsPerFAT16 != 0)
-		nSectorsPerFAT = nSectorsPerFAT16;
-	else
-		nSectorsPerFAT = nSectorsPerFAT32; 
-
-	nRootDirSectorStart = (nNumberOfFATs * nSectorsPerFAT) + nReservedSectors;
-	nRootDirSectors = ((nRootDirEntries * 32) + (nBytesPerSector - 1)) / nBytesPerSector;
-	nDataSectorStart = nReservedSectors + (nNumberOfFATs * nSectorsPerFAT) + nRootDirSectors;
-	nNumberOfClusters = (nTotalSectors - nDataSectorStart) / nSectorsPerCluster;
-
-	// Determine FAT type
-	if (nNumberOfClusters < 4085)
-	{
-		/* Volume is FAT12 */
-		nFATType = FAT12;
-	}
-	else if (nNumberOfClusters < 65525)
-	{
-		/* Volume is FAT16 */
-		nFATType = FAT16;
-	}
-	else
-	{
-		/* Volume is FAT32 */
-		nFATType = FAT32;
-
-		// Check version
-		// we only work with version 0
-		if (*((WORD*)(SectorBuffer + BPB_FILESYSTEMVERSION32)) != 0)
-		{
-			FS_DO_ERROR("Error: FreeLoader is too old to work with this FAT32 filesystem.\nPlease update FreeLoader.");
-			return FALSE;
-		}
-	}
-
-	FSType = FS_FAT;
-
-	// Buffer the FAT table if it is small enough
-	if ((FSType == FS_FAT) && (nFATType == FAT12))
-	{
-		if (!ReadMultipleSectors(nReservedSectors, nSectorsPerFAT, pFileSysData))
-			return FALSE;
-	}
-	else if ((FSType == FS_FAT) && (nFATType == FAT16))
-	{
-		if (!ReadMultipleSectors(nReservedSectors, nSectorsPerFAT, pFileSysData))
-			return FALSE;
-	}
-	else if ((FSType == FS_FAT) && (nFATType == FAT32))
-	{
-		// The FAT table is too big to be buffered so
-		// we will initialize our cache and cache it
-		// on demand
-		for (offset=0; offset<256; offset++)
-			((int*)pFat32FATCacheIndex)[offset] = -1;
-	}
-
-	return TRUE;
-}
-
-BOOL ReadMultipleSectors(int nSect, int nNumberOfSectors, void *pBuffer)
-{
-	BOOL	bRetVal;
-	int		PhysicalSector;
-	int		PhysicalHead;
-	int		PhysicalTrack;
-	int		nNum;
-
-	nSect += nHiddenSectors;
-
-	while (nNumberOfSectors)
-	{
-		PhysicalSector = 1 + (nSect % nSectorsPerTrack);
-		PhysicalHead = (nSect / nSectorsPerTrack) % nNumberOfHeads;
-		PhysicalTrack = nSect / (nSectorsPerTrack * nNumberOfHeads);
-
-		if (PhysicalSector > 1)
-		{
-			if (nNumberOfSectors >= (nSectorsPerTrack - (PhysicalSector - 1)))
-				nNum = (nSectorsPerTrack - (PhysicalSector - 1));
-			else
-				nNum = nNumberOfSectors;
-		}
-		else
-		{
-			if (nNumberOfSectors >= nSectorsPerTrack)
-				nNum = nSectorsPerTrack;
-			else
-				nNum = nNumberOfSectors;
-		}
-
-		bRetVal = biosdisk(_DISK_READ, BootDrive, PhysicalHead, PhysicalTrack, PhysicalSector, nNum, pBuffer);
-
-		if (!bRetVal)
-		{
-			FS_DO_ERROR("Disk Error");
-			return FALSE;
-		}
-
-		pBuffer += (nNum * 512);
-		nNumberOfSectors -= nNum;
-		nSect += nNum;
-	}
-
-	return TRUE;
-}
-
-BOOL ReadOneSector(int nSect)
-{
-	BOOL	bRetVal;
-	int		PhysicalSector;
-	int		PhysicalHead;
-	int		PhysicalTrack;
-
-	nSectorBuffered = nSect;
-
-	nSect += nHiddenSectors;
-	PhysicalSector = 1 + (nSect % nSectorsPerTrack);
-	PhysicalHead = (nSect / nSectorsPerTrack) % nNumberOfHeads;
-	PhysicalTrack = nSect / (nSectorsPerTrack * nNumberOfHeads);
-
-
-	bRetVal = biosdisk(_DISK_READ, BootDrive, PhysicalHead, PhysicalTrack, PhysicalSector, 1, SectorBuffer);
-
-	if (!bRetVal)
-	{
-		FS_DO_ERROR("Disk Error");
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-BOOL OpenFile(char *filename, FILE *pFile)
-{
-	switch(FSType)
-	{
-	case FS_FAT:
-		if(!FATOpenFile(filename, &(pFile->fat)))
-			return FALSE;
-		pFile->filesize = pFile->fat.dwSize;
-		break;
-	default:
-		FS_DO_ERROR("Error: Unknown filesystem.");
-		return FALSE;
-		break;
-	}
-
-	return TRUE;
-}
-
-/*
- * ReadFile()
- * returns number of bytes read or EOF
- */
-int ReadFile(FILE *pFile, int count, void *buffer)
-{
-	switch(FSType)
-	{
-	case FS_FAT:
-		return FATRead(&(pFile->fat), count, buffer);
-	default:
-		FS_DO_ERROR("Error: Unknown filesystem.");
-		return EOF;
-	}
-
-	return 0;
-}
-
-DWORD GetFileSize(FILE *pFile)
-{
-	return pFile->filesize;
-}
-
-DWORD Rewind(FILE *pFile)
-{
-	switch (FSType)
-	{
-	case FS_FAT:
-		pFile->fat.dwCurrentCluster = pFile->fat.dwStartCluster;
-		pFile->fat.dwCurrentReadOffset = 0;
-		break;
-	default:
-		FS_DO_ERROR("Error: Unknown filesystem.");
-		break;
-	}
-
-	return pFile->filesize;
-}
-
-int feof(FILE *pFile)
-{
-	switch (FSType)
-	{
-	case FS_FAT:
-		if (pFile->fat.dwCurrentReadOffset >= pFile->fat.dwSize)
-			return TRUE;
-		else
-			return FALSE;
-		break;
-	default:
-		FS_DO_ERROR("Error: Unknown filesystem.");
-		return TRUE;
-		break;
-	}
-
-	return TRUE;
-}
-
-int fseek(FILE *pFile, DWORD offset)
-{
-	switch (FSType)
-	{
-	case FS_FAT:
-		return FATfseek(&(pFile->fat), offset);
-		break;
-	default:
-		FS_DO_ERROR("Error: Unknown filesystem.");
-		break;
-	}
-
-	return -1;
-}

freeldr/freeldr/fs.h

@@ -1,182 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef __FS_FAT_H
-#define __FS_FAT_H
-
-// Bootsector BPB defines
-#define BPB_JMPBOOT					0
-#define BPB_OEMNAME					3
-#define BPB_BYTESPERSECTOR			11
-#define BPB_SECTORSPERCLUSTER		13
-#define BPB_RESERVEDSECTORS			14
-#define BPB_NUMBEROFFATS			16
-#define BPB_ROOTDIRENTRIES			17
-#define BPB_TOTALSECTORS16			19
-#define BPB_MEDIADESCRIPTOR			21
-#define BPB_SECTORSPERFAT16			22
-#define BPB_SECTORSPERTRACK			24
-#define BPB_NUMBEROFHEADS			26
-#define BPB_HIDDENSECTORS			28
-#define BPB_TOTALSECTORS32			32
-
-// Fat12/16 extended BPB defines
-#define BPB_DRIVENUMBER16			36
-#define BPB_RESERVED16_1			37
-#define BPB_BOOTSIGNATURE16			38
-#define BPB_VOLUMESERIAL16			39
-#define BPB_VOLUMELABEL16			43
-#define BPB_FILESYSTEMTYPE16		54
-
-// Fat32 extended BPB defines
-#define BPB_SECTORSPERFAT32			36
-#define BPB_EXTENDEDFLAGS32			40
-#define BPB_FILESYSTEMVERSION32		42
-#define BPB_ROOTDIRSTARTCLUSTER32	44
-#define BPB_FILESYSTEMINFOSECTOR32	48
-#define BPB_BACKUPBOOTSECTOR32		50
-#define BPB_RESERVED32_1			52
-#define BPB_DRIVENUMBER32			64
-#define BPB_RESERVED32_2			65
-#define BPB_BOOTSIGNATURE32			66
-#define BPB_VOLUMESERIAL32			67
-#define BPB_VOLUMELABEL32			71
-#define BPB_FILESYSTEMTYPE32		82
-
-/*
- * Structure of MSDOS directory entry
- */
-typedef struct //_DIRENTRY
-{
-	BYTE	cFileName[11];	/* Filename + extension */
-	BYTE	cAttr;			/* File attributes */
-	BYTE	cReserved[10];	/* Reserved area */
-	WORD	wTime;			/* Time last modified */
-	WORD	wData;			/* Date last modified */
-	WORD	wCluster;		/* First cluster number */
-	DWORD	dwSize;			/* File size */
-} DIRENTRY, * PDIRENTRY;
-
-/*
- * Structure of internal file control block
- */
-typedef struct //_FCB
-{
-	BYTE	 	cAttr;			/* Open attributes */
-	BYTE	 	cSector;		/* Sector within cluster */
-	PDIRENTRY	pDirptr;		/* Pointer to directory entry */
-	WORD		wDirSector;		/* Directory sector */
-	WORD		wFirstCluster;	/* First cluster in file */
-	WORD		wLastCluster;	/* Last cluster read/written */
-	WORD		wNextCluster;	/* Next cluster to read/write */
-	WORD		wOffset;		/* Read/Write offset within sector */
-	DWORD		dwSize;			/* File size */
-	BYTE		cBuffer[512];	/* Data transfer buffer */
-} FCB, * PFCB;
-
-typedef struct //_FAT_STRUCT
-{
-	DWORD	dwStartCluster;		// File's starting cluster
-	DWORD	dwCurrentCluster;	// Current read cluster number
-	DWORD	dwSize;				// File size
-	DWORD	dwCurrentReadOffset;// Amount of data already read
-} FAT_STRUCT, * PFAT_STRUCT;
-
-typedef struct //_FILE
-{
-	//DIRENTRY		de;
-	//FCB				fcb;
-	FAT_STRUCT		fat;
-	unsigned long	filesize;
-} FILE;
-
-extern	int		nSectorBuffered;	// Tells us which sector was read into SectorBuffer[]
-extern	BYTE	SectorBuffer[512];	// 512 byte buffer space for read operations, ReadOneSector reads to here
-
-extern	int		nFATType;
-
-extern	DWORD	nBytesPerSector;		// Bytes per sector
-extern	DWORD	nSectorsPerCluster;		// Number of sectors in a cluster
-extern	DWORD	nReservedSectors;		// Reserved sectors, usually 1 (the bootsector)
-extern	DWORD	nNumberOfFATs;			// Number of FAT tables
-extern	DWORD	nRootDirEntries;		// Number of root directory entries (fat12/16)
-extern	DWORD	nTotalSectors16;		// Number of total sectors on the drive, 16-bit
-extern	DWORD	nSectorsPerFAT16;		// Sectors per FAT table (fat12/16)
-extern	DWORD	nSectorsPerTrack;		// Number of sectors in a track
-extern	DWORD	nNumberOfHeads;			// Number of heads on the disk
-extern	DWORD	nHiddenSectors;			// Hidden sectors (sectors before the partition start like the partition table)
-extern	DWORD	nTotalSectors32;		// Number of total sectors on the drive, 32-bit
-
-extern	DWORD	nSectorsPerFAT32;		// Sectors per FAT table (fat32)
-extern	DWORD	nExtendedFlags;			// Extended flags (fat32)
-extern	DWORD	nFileSystemVersion;		// File system version (fat32)
-extern	DWORD	nRootDirStartCluster;	// Starting cluster of the root directory (fat32)
-
-extern	DWORD	nRootDirSectorStart;	// Starting sector of the root directory (fat12/16)
-extern	DWORD	nDataSectorStart;		// Starting sector of the data area
-extern	DWORD	nSectorsPerFAT;			// Sectors per FAT table
-extern	DWORD	nRootDirSectors;		// Number of sectors of the root directory (fat32)
-extern	DWORD	nTotalSectors;			// Total sectors on the drive
-extern	DWORD	nNumberOfClusters;		// Number of clusters on the drive
-
-extern	int	FSType;						// Type of filesystem on boot device, set by OpenDiskDrive()
-
-extern	char *pFileSysData;				// Load address for filesystem data
-extern	char *pFat32FATCacheIndex;		// Load address for filesystem data
-
-BOOL	OpenDiskDrive(int nDrive, int nPartition);	// Opens the disk drive device for reading
-BOOL	ReadMultipleSectors(int nSect, int nNumberOfSectors, void *pBuffer);// Reads a sector from the open device
-BOOL	ReadOneSector(int nSect);				// Reads one sector from the open device
-BOOL	OpenFile(char *filename, FILE *pFile);	// Opens a file
-int		ReadFile(FILE *pFile, int count, void *buffer); // Reads count bytes from pFile into buffer
-DWORD	GetFileSize(FILE *pFile);
-DWORD	Rewind(FILE *pFile);	// Rewinds a file and returns it's size
-int		feof(FILE *pFile);
-int		fseek(FILE *pFILE, DWORD offset);
-
-BOOL	FATLookupFile(char *file, PFAT_STRUCT pFatStruct);
-int		FATGetNumPathParts(char *name);
-BOOL	FATGetFirstNameFromPath(char *buffer, char *name);
-void	FATParseFileName(char *buffer, char *name);
-DWORD	FATGetFATEntry(DWORD nCluster);
-BOOL	FATOpenFile(char *szFileName, PFAT_STRUCT pFatStruct);
-int		FATReadCluster(DWORD nCluster, char *cBuffer);
-int		FATRead(PFAT_STRUCT pFatStruct, int nNumBytes, char *cBuffer);
-int		FATfseek(PFAT_STRUCT pFatStruct, DWORD offset);
-
-
-#define	EOF	-1
-
-#define	ATTR_NORMAL		0x00
-#define	ATTR_READONLY	0x01
-#define	ATTR_HIDDEN		0x02
-#define	ATTR_SYSTEM		0x04
-#define	ATTR_VOLUMENAME	0x08
-#define	ATTR_DIRECTORY	0x10
-#define	ATTR_ARCHIVE	0x20
-
-#define	FS_FAT			1
-#define	FS_NTFS			2
-#define	FS_EXT2			3
-
-#define	FAT12			1
-#define	FAT16			2
-#define	FAT32			3
-
-#endif // #defined __FS_FAT_H

freeldr/freeldr/fs_fat.c

@@ -1,541 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include "freeldr.h"
-#include "fs.h"
-#include "stdlib.h"
-#include "tui.h"
-#include "asmcode.h"
-
-int		nFATType = FAT12;
-
-DWORD	nBytesPerSector;		// Bytes per sector
-DWORD	nSectorsPerCluster;		// Number of sectors in a cluster
-DWORD	nReservedSectors;		// Reserved sectors, usually 1 (the bootsector)
-DWORD	nNumberOfFATs;			// Number of FAT tables
-DWORD	nRootDirEntries;		// Number of root directory entries (fat12/16)
-DWORD	nTotalSectors16;		// Number of total sectors on the drive, 16-bit
-DWORD	nSectorsPerFAT16;		// Sectors per FAT table (fat12/16)
-DWORD	nSectorsPerTrack;		// Number of sectors in a track
-DWORD	nNumberOfHeads;			// Number of heads on the disk
-DWORD	nHiddenSectors;			// Hidden sectors (sectors before the partition start like the partition table)
-DWORD	nTotalSectors32;		// Number of total sectors on the drive, 32-bit
-
-DWORD	nSectorsPerFAT32;		// Sectors per FAT table (fat32)
-DWORD	nExtendedFlags;			// Extended flags (fat32)
-DWORD	nFileSystemVersion;		// File system version (fat32)
-DWORD	nRootDirStartCluster;	// Starting cluster of the root directory (fat32)
-
-DWORD	nRootDirSectorStart;	// Starting sector of the root directory (fat12/16)
-DWORD	nDataSectorStart;		// Starting sector of the data area
-DWORD	nSectorsPerFAT;			// Sectors per FAT table
-DWORD	nRootDirSectors;		// Number of sectors of the root directory (fat32)
-DWORD	nTotalSectors;			// Total sectors on the drive
-DWORD	nNumberOfClusters;		// Number of clusters on the drive
-
-BOOL FATReadRootDirectoryEntry(int nDirEntry, void *pDirEntryBuf)
-{
-	DWORD	nDirEntrySector;
-	int		nOffsetWithinSector;
-
-	nDirEntrySector = nRootDirSectorStart + ((nDirEntry * 32) / nBytesPerSector);
-
-	if (!ReadOneSector(nDirEntrySector))
-		return FALSE;
-
-	nOffsetWithinSector = (nDirEntry * 32) % nBytesPerSector;
-
-	memcpy(pDirEntryBuf, SectorBuffer + nOffsetWithinSector, 32);
-
-	if (*((char *)pDirEntryBuf) == 0x05)
-		*((char *)pDirEntryBuf) = 0xE5;
-
-	return TRUE;
-}
-
-BOOL FATReadDirectoryEntry(DWORD nDirStartCluster, int nDirEntry, void *pDirEntryBuf)
-{
-	DWORD	nRealDirCluster;
-	int		nSectorWithinCluster;
-	int		nOffsetWithinSector;
-	int		nSectorToRead;
-	int		i;
-
-	i = (nDirEntry * 32) / (nSectorsPerCluster * nBytesPerSector);
-	//if ((nDirEntry * 32) % (nSectorsPerCluster * nBytesPerSector))
-	//	i++;
-
-	for (nRealDirCluster = nDirStartCluster; i; i--)
-		nRealDirCluster = FATGetFATEntry(nRealDirCluster);
-
-	nSectorWithinCluster = ((nDirEntry * 32) % (nSectorsPerCluster * nBytesPerSector)) / nBytesPerSector;
-
-	nSectorToRead = ((nRealDirCluster - 2) * nSectorsPerCluster) + nDataSectorStart + nSectorWithinCluster;
-
-	if (!ReadOneSector(nSectorToRead))
-		return FALSE;
-
-	nOffsetWithinSector = (nDirEntry * 32) % nBytesPerSector;
-
-	memcpy(pDirEntryBuf, SectorBuffer + nOffsetWithinSector, 32);
-
-	if (*((char *)pDirEntryBuf) == 0x05)
-		*((char *)pDirEntryBuf) = 0xE5;
-
-	return TRUE;
-}
-
-/*
- * FATLookupFile()
- * This function searches the file system for the
- * specified filename and fills in a FAT_STRUCT structure
- * with info describing the file, etc. returns true
- * if the file exists or false otherwise
- */
-BOOL FATLookupFile(char *file, PFAT_STRUCT pFatStruct)
-{
-	int			i, j;
-	int			numparts;
-	char		filename[12];
-	BYTE		direntry[32];
-	int			nNumDirEntries;
-	FAT_STRUCT	fatstruct;
-	BOOL		bFound;
-	DWORD		cluster;
-
-	memset(pFatStruct, 0, sizeof(FAT_STRUCT));
-
-	// Check and see if the first character is '\' and remove it if so
-	if (*file == '\\')
-		file++;
-
-	// Figure out how many sub-directories we are nested in
-	numparts = FATGetNumPathParts(file);
-
-	// Loop once for each part
-	for (i=0; i<numparts; i++)
-	{
-		// Make filename compatible with MSDOS dir entry
-		if (!FATGetFirstNameFromPath(filename, file))
-			return FALSE;
-		// Advance to the next part of the path
-		for (; (*file != '\\') && (*file != '\0'); file++);
-		file++;
-
-		// If we didn't find the correct sub-directory the fail
-		if ((i != 0) && !bFound)
-			return FALSE;
-
-		bFound = FALSE;
-
-		// Check if we are pulling from the root directory of a fat12/fat16 disk
-		if ((i == 0) && ((nFATType == FAT12) || (nFATType == FAT16)))
-			nNumDirEntries = nRootDirEntries;
-		else if ((i == 0) && (nFATType == FAT32))
-		{
-			cluster = nRootDirStartCluster;
-			fatstruct.dwSize = nSectorsPerCluster * nBytesPerSector;
-			while((cluster = FATGetFATEntry(cluster)) < 0x0FFFFFF8)
-				fatstruct.dwSize += nSectorsPerCluster * nBytesPerSector;
-
-			fatstruct.dwStartCluster = nRootDirStartCluster;
-			nNumDirEntries = fatstruct.dwSize / 32;
-		}
-		else
-			nNumDirEntries = fatstruct.dwSize / 32;
-
-		// Loop through each directory entry
-		for (j=0; j<nNumDirEntries; j++)
-		{
-			// Read the entry
-			if ((i == 0) && ((nFATType == FAT12) || (nFATType == FAT16)))
-			{
-				if (!FATReadRootDirectoryEntry(j, direntry))
-					return FALSE;
-			}
-			else
-			{
-				if (!FATReadDirectoryEntry(fatstruct.dwStartCluster, j, direntry))
-					return FALSE;
-			}
-
-			if (memcmp(direntry, filename, 11) == 0)
-			{
-				fatstruct.dwStartCluster = 0;
-				fatstruct.dwCurrentCluster = 0;
-				memcpy(&fatstruct.dwStartCluster, direntry + 26, sizeof(WORD));
-				memcpy(&fatstruct.dwCurrentCluster, direntry + 20, sizeof(WORD));
-				fatstruct.dwStartCluster += (fatstruct.dwCurrentCluster * 0x10000);
-
-				if (direntry[11] & ATTR_DIRECTORY)
-				{
-					fatstruct.dwSize = nSectorsPerCluster * nBytesPerSector;
-					cluster = fatstruct.dwStartCluster;
-					switch (nFATType)
-					{
-					case FAT12:
-						while((cluster = FATGetFATEntry(cluster)) < 0xFF8)
-							fatstruct.dwSize += nSectorsPerCluster * nBytesPerSector;
-						break;
-					case FAT16:
-						while((cluster = FATGetFATEntry(cluster)) < 0xFFF8)
-							fatstruct.dwSize += nSectorsPerCluster * nBytesPerSector;
-						break;
-					case FAT32:
-						while((cluster = FATGetFATEntry(cluster)) < 0x0FFFFFF8)
-							fatstruct.dwSize += nSectorsPerCluster * nBytesPerSector;
-						break;
-					}
-				}
-
-				// If we have more parts to go and this isn't a directory then fail
-				if ((i < (numparts-1)) && !(direntry[11] & ATTR_DIRECTORY))
-					return FALSE;
-
-				// If this is supposed to be a file and it is a directory then fail
-				if ((i == (numparts-1)) && (direntry[11] & ATTR_DIRECTORY))
-					return FALSE;
-
-				bFound = TRUE;
-				break;
-			}
-		}
-	}
-
-	if(!bFound)
-		return FALSE;
-
-	memcpy(&pFatStruct->dwStartCluster, direntry + 26, sizeof(WORD));
-	memcpy(&pFatStruct->dwCurrentCluster, direntry + 20, sizeof(WORD));
-	pFatStruct->dwStartCluster += (pFatStruct->dwCurrentCluster * 0x10000);
-	pFatStruct->dwCurrentCluster = pFatStruct->dwStartCluster;
-
-	memcpy(&pFatStruct->dwSize, direntry + 28, sizeof(DWORD));
-	pFatStruct->dwCurrentReadOffset = 0;
-
-	return TRUE;
-}
-
-/*
- * FATGetNumPathParts()
- * This function parses a path in the form of dir1\dir2\file1.ext
- * and returns the number of parts it has (i.e. 3 - dir1,dir2,file1.ext)
- */
-int FATGetNumPathParts(char *name)
-{
-	int	i, num;
-
-	for(i=0,num=0; i<(int)strlen(name); i++)
-	{
-		if(name[i] == '\\')
-			num++;
-	}
-	num++;
-
-	return num;
-}
-
-/*
- * FATGetFirstNameFromPath()
- * This function parses a path in the form of dir1\dir2\file1.ext
- * and puts the first name of the path (e.g. "dir1") in buffer
- * compatible with the MSDOS directory structure
- */
-BOOL FATGetFirstNameFromPath(char *buffer, char *name)
-{
-	int		i;
-	char	temp[260];
-
-	// Copy all the characters up to the end of the
-	// string or until we hit a '\' character
-	// and put them in temp
-	for(i=0; i<(int)strlen(name); i++)
-	{
-		if(name[i] == '\\')
-			break;
-		else
-			temp[i] = name[i];
-	}
-	temp[i] = 0;
-
-	// If the filename is too long then fail
-	if(strlen(temp) > 12)
-		return FALSE;
-
-	FATParseFileName(buffer, temp);
-
-	return TRUE;
-}
-
-/*
- * FATParseFileName()
- * This function parses "name" which is in the form of file.ext
- * and puts it in "buffer" in the form of "FILE   EXT" which
- * is compatible with the MSDOS directory structure
- */
-void FATParseFileName(char *buffer, char *name)
-{
-	int i, j;
-
-	i = 0;
-	j = 0;
-
-	while(i < 8)
-		buffer[i++] = (name[j] && (name[j] != '.')) ? toupper(name[j++]) : ' ';
-
-	if(name[j] == '.')
-		j++;
-
-	while(i < 11)
-		buffer[i++] = name[j] ? toupper(name[j++]) : ' ';
-
-	buffer[i] = 0;
-}
-
-/*
- * FATGetFATEntry()
- * returns the FAT entry for a given cluster number
- */
-DWORD FATGetFATEntry(DWORD nCluster)
-{
-	DWORD	fat;
-	int		FATOffset;
-	int		ThisFATSecNum;
-	int		ThisFATEntOffset;
-	int		Idx;
-	BOOL	bEntryFound;
-
-	switch(nFATType)
-	{
-	case FAT12:
-		FATOffset = nCluster + (nCluster / 2);
-		ThisFATSecNum = (FATOffset / nBytesPerSector);
-		ThisFATEntOffset = (FATOffset % nBytesPerSector);
-		fat = *((WORD *) (pFileSysData + (ThisFATSecNum * nBytesPerSector) + ThisFATEntOffset));
-		if (nCluster & 0x0001) 
-			fat = fat >> 4;	/* Cluster number is ODD */
-		else
-			fat = fat & 0x0FFF;	/* Cluster number is EVEN */
-
-		return fat;
-		break;
-	case FAT16:
-		FATOffset = (nCluster * 2);
-		//ThisFATSecNum = nReservedSectors + (FATOffset / nBytesPerSector);
-		//ThisFATEntOffset = (FATOffset % nBytesPerSector);
-
-		//if (!ReadOneSector(ThisFATSecNum))
-		//	return NULL;
-
-		//fat = *((WORD *) &SectorBuffer[ThisFATEntOffset]);
-		fat = *((WORD *) (pFileSysData + FATOffset));
-
-		return fat;
-		break;
-	case FAT32:
-		//if (!ReadOneSector(ThisFATSecNum))
-		//	return NULL;
-
-		//fat = *((DWORD *) &SectorBuffer[ThisFATEntOffset]) & 0x0FFFFFFF;
-		//return fat;
-
-		// This code manages the fat32 fat table entry cache
-		// The cache is at address FILESYSADDR which is 128k in size
-		// The first two sectors will contain an array of DWORDs that
-		// Specify what fat sector is cached. The first two DWORDs
-		// should be zero.
-		FATOffset = (nCluster * 4);
-		ThisFATSecNum = nReservedSectors + (FATOffset / nBytesPerSector);
-		ThisFATEntOffset = (FATOffset % nBytesPerSector);
-
-		// Now we go through our cache and see if we already have the sector cached
-		bEntryFound = FALSE;
-		for (Idx=2; Idx<256; Idx++)
-		{
-			if (((int*)pFat32FATCacheIndex)[Idx] == ThisFATSecNum)
-			{
-				bEntryFound = TRUE;
-				break;
-			}
-		}
-
-		if (bEntryFound)
-		{
-			// Get the fat entry
-			fat = (*((DWORD *) (pFat32FATCacheIndex +
-				(Idx * nBytesPerSector) + ThisFATEntOffset))) & 0x0FFFFFFF;
-		}
-		else
-		{
-			if (!ReadOneSector(ThisFATSecNum))
-				return NULL;
-
-			// Move each sector down in the cache to make room for new sector
-			for (Idx=255; Idx>2; Idx--)
-			{
-				memcpy(pFat32FATCacheIndex + (Idx * nBytesPerSector), pFat32FATCacheIndex + ((Idx - 1) * nBytesPerSector), nBytesPerSector);
-				((int*)pFat32FATCacheIndex)[Idx] = ((int*)pFat32FATCacheIndex)[Idx - 1];
-			}
-
-			// Insert it into the cache
-			memcpy(pFat32FATCacheIndex + (2 * nBytesPerSector), SectorBuffer, nBytesPerSector);
-			((int*)pFat32FATCacheIndex)[2] = ThisFATSecNum;
-
-			// Get the fat entry
-			fat = (*((DWORD *) (pFat32FATCacheIndex +
-				(2 * nBytesPerSector) + ThisFATEntOffset))) & 0x0FFFFFFF;
-		}
-
-		return fat;
-		break;
-	}
-
-	return NULL;
-}
-
-/*
- * FATOpenFile()
- * Tries to open the file 'name' and returns true or false
- * for success and failure respectively
- */
-BOOL FATOpenFile(char *szFileName, PFAT_STRUCT pFatStruct)
-{
-	if(!FATLookupFile(szFileName, pFatStruct))
-		return FALSE;
-
-	/* Fill in file control information */
-	pFatStruct->dwCurrentCluster = pFatStruct->dwStartCluster;
-	pFatStruct->dwCurrentReadOffset = 0;
-
-	return TRUE;
-}
-
-/*
- * FATReadCluster()
- * Reads the specified cluster into memory
- * and returns the number of bytes read
- */
-int FATReadCluster(DWORD nCluster, char *cBuffer)
-{
-	int		nStartSector;
-
-	nStartSector = ((nCluster - 2) * nSectorsPerCluster) + nDataSectorStart;
-
-	ReadMultipleSectors(nStartSector, nSectorsPerCluster, cBuffer);
-
-	return (nSectorsPerCluster * nBytesPerSector);
-}
-
-/*
- * FATRead()
- * Reads nNumBytes from open file and
- * returns the number of bytes read
- */
-int FATRead(PFAT_STRUCT pFatStruct, int nNumBytes, char *cBuffer)
-{
-	int		nSectorWithinCluster;
-	int		nOffsetWithinSector;
-	int		nOffsetWithinCluster;
-	int		nNum;
-	int		nBytesRead = 0;
-
-	// If all the data is read return zero
-	if (pFatStruct->dwCurrentReadOffset >= pFatStruct->dwSize)
-		return 0;
-
-	// If they are trying to read more than there is to read
-	// then adjust the amount to read
-	if ((pFatStruct->dwCurrentReadOffset + nNumBytes) > pFatStruct->dwSize)
-		nNumBytes = pFatStruct->dwSize - pFatStruct->dwCurrentReadOffset;
-
-	while (nNumBytes)
-	{
-		// Check and see if the read offset is aligned to a cluster boundary
-		// if so great, if not then read the rest of the current cluster
-		if ((pFatStruct->dwCurrentReadOffset % (nSectorsPerCluster * nBytesPerSector)) != 0)
-		{
-			nSectorWithinCluster = ((pFatStruct->dwCurrentReadOffset / nBytesPerSector) % nSectorsPerCluster);
-			nOffsetWithinSector = (pFatStruct->dwCurrentReadOffset % nBytesPerSector);
-			nOffsetWithinCluster = (pFatStruct->dwCurrentReadOffset % (nSectorsPerCluster * nBytesPerSector));
-
-			// Read the cluster into the scratch area
-			FATReadCluster(pFatStruct->dwCurrentCluster, (char *)FATCLUSTERBUF);
-
-			nNum = (nSectorsPerCluster * nBytesPerSector) - (pFatStruct->dwCurrentReadOffset % (nSectorsPerCluster * nBytesPerSector));
-			if (nNumBytes >= nNum)
-			{
-				memcpy(cBuffer, (char *)(FATCLUSTERBUF + nOffsetWithinCluster), nNum);
-				nBytesRead += nNum;
-				cBuffer += nNum;
-				pFatStruct->dwCurrentReadOffset += nNum;
-				pFatStruct->dwCurrentCluster = FATGetFATEntry(pFatStruct->dwCurrentCluster);
-				nNumBytes -= nNum;
-			}
-			else
-			{
-				memcpy(cBuffer, (char *)(FATCLUSTERBUF + nOffsetWithinCluster), nNumBytes);
-				nBytesRead += nNumBytes;
-				cBuffer += nNumBytes;
-				pFatStruct->dwCurrentReadOffset += nNumBytes;
-				nNumBytes -= nNumBytes;
-			}
-		}
-		else
-		{
-			// Read the cluster into the scratch area
-			FATReadCluster(pFatStruct->dwCurrentCluster, (char *)FATCLUSTERBUF);
-
-			nNum = (nSectorsPerCluster * nBytesPerSector);
-			if (nNumBytes >= nNum)
-			{
-				memcpy(cBuffer, (char *)(FATCLUSTERBUF), nNum);
-				nBytesRead += nNum;
-				cBuffer += nNum;
-				pFatStruct->dwCurrentReadOffset += nNum;
-				pFatStruct->dwCurrentCluster = FATGetFATEntry(pFatStruct->dwCurrentCluster);
-				nNumBytes -= nNum;
-			}
-			else
-			{
-				memcpy(cBuffer, (char *)(FATCLUSTERBUF), nNumBytes);
-				nBytesRead += nNumBytes;
-				cBuffer += nNumBytes;
-				pFatStruct->dwCurrentReadOffset += nNumBytes;
-				nNumBytes -= nNumBytes;
-			}
-		}
-	}
-
-	return nBytesRead;
-}
-
-int FATfseek(PFAT_STRUCT pFatStruct, DWORD offset)
-{
-	DWORD		cluster;
-	int			numclusters;
-
-	numclusters = offset / (nSectorsPerCluster * nBytesPerSector);
-	for (cluster=pFatStruct->dwStartCluster; numclusters > 0; numclusters--)
-		cluster = FATGetFATEntry(cluster);
-
-	pFatStruct->dwCurrentCluster = cluster;
-	pFatStruct->dwCurrentReadOffset = offset;
-
-	return 0;
-}

freeldr/freeldr/linux.c

@@ -1,101 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-	
-#include "freeldr.h"
-#include "asmcode.h"
-#include "miscboot.h"
-#include "stdlib.h"
-#include "fs.h"
-#include "tui.h"
-#include "linux.h"
-
-void LoadAndBootLinux(int DriveNum, int Partition, char *vmlinuz, char *cmd_line)
-{
-	FILE	file;
-	char	temp[260];
-	char	bootsector[512];
-	char	setup[2048];
-	int		len;
-
-	BootDrive = DriveNum;
-	BootPartition = Partition;
-
-	if (!OpenDiskDrive(BootDrive, BootPartition))
-	{
-		MessageBox("Failed to open boot drive.");
-		return;
-	}
-
-	if (!OpenFile(vmlinuz, &file))
-	{
-		strcpy(temp, vmlinuz);
-		strcat(temp, " not found.");
-		MessageBox(temp);
-		return;
-	}
-
-	// Read boot sector
-	if (ReadFile(&file, 512, bootsector) != 512)
-	{
-		MessageBox("Disk Read Error");
-		return;
-	}
-	MessageBox("bootsector loaded");
-
-	// Read setup code
-	if (ReadFile(&file, 2048, setup) != 2048)
-	{
-		MessageBox("Disk Read Error");
-		return;
-	}
-	MessageBox("setup loaded");
-
-	// Read kernel code
-	len = GetFileSize(&file) - (2048 + 512);
-	//len = 0x200;
-	if (ReadFile(&file, len, (void*)0x100000) != len)
-	{
-		MessageBox("Disk Read Error");
-		return;
-	}
-	MessageBox("kernel loaded");
-
-	// Check for validity
-	if (*((WORD*)(bootsector + 0x1fe)) != 0xaa55)
-	{
-		MessageBox("Invalid boot sector magic (0xaa55)");
-		return;
-	}
-	if (*((DWORD*)(setup + 2)) != 0x53726448)
-	{
-		MessageBox("Invalid setup magic (\"HdrS\")");
-		return;
-	}
-
-	memcpy((void*)0x90000, bootsector, 512);
-	memcpy((void*)0x90200, setup, 2048);
-
-	RestoreScreen(pScreenBuffer);
-	showcursor();
-	gotoxy(nCursorXPos, nCursorYPos);
-
-	stop_floppy();
-	JumpToLinuxBootCode();
-}

freeldr/freeldr/linux.h

@@ -1,27 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef __LINUX_H
-#define __LINUX_H
-
-void	JumpToLinuxBootCode(void);	// Implemented in boot.S
-
-void	LoadAndBootLinux(int DriveNum, int Partition, char *vmlinuz, char *cmd_line);
-
-#endif // defined __LINUX_H

freeldr/freeldr/menu.c

@@ -1,190 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-	
-#include "freeldr.h"
-#include "stdlib.h"
-#include "tui.h"
-#include "menu.h"
-#include "options.h"
-
-static int nOSListBoxLeft;
-static int nOSListBoxRight;
-static int nOSListBoxTop;
-static int nOSListBoxBottom;
-
-static int nOSSelected = 0; // Currently selected OS (zero based)
-
-int RunMenu(void)
-{
-	int		key;
-	int		second;
-	BOOL	bDone = FALSE;
-
-	if (nTimeOut > 0)
-		nTimeOut++; // Increment the timeout since 0 doesn't count for a second
-
-	// Initialise the menu
-	InitMenu();
-
-	// Update the menu
-	DrawMenu();
-
-	second = getsecond();
-
-	// Loop
-	do
-	{
-		// Check for a keypress
-		if (kbhit())
-		{
-			// Cancel the timeout
-			if (nTimeOut != -1)
-			{
-				nTimeOut = -1;
-				DrawMenu();
-			}
-
-			// Get the key
-			key = getch();
-
-			// Is it extended?
-			if (key == 0)
-				key = getch(); // Yes - so get the extended key
-
-			// Process the key
-			switch (key)
-			{
-			case KEY_UP:
-				if (nOSSelected)
-				{
-					nOSSelected--;
-
-					// Update the menu
-					DrawMenu();
-				}
-				break;
-			case KEY_DOWN:
-				if (nOSSelected < (nNumOS-1))
-				{
-					nOSSelected++;
-
-					// Update the menu
-					DrawMenu();
-				}
-				break;
-			case KEY_ENTER:
-				bDone = TRUE;
-				break;
-			case KEY_F8:
-				DoOptionsMenu();
-				DrawBackdrop();
-				DrawMenu();
-				break;
-			}
-		}
-
-		// Update the date & time
-		UpdateDateTime();
-
-		if (nTimeOut > 0)
-		{
-			if (getsecond() != second)
-			{
-				second = getsecond();
-				nTimeOut--;
-
-				// Update the menu
-				DrawMenu();
-			}
-		}
-
-		if (nTimeOut == 0)
-			bDone = TRUE;
-	}
-	while (!bDone);
-
-	return nOSSelected;
-}
-
-void InitMenu(void)
-{
-	int		i;
-	int		height = 1; // Allow room for top & bottom borders
-	int		width = 0;
-
-	for(i=0; i<nNumOS; i++)
-	{
-		height++;
-		if(strlen(OSList[i].name) > width)
-			width = strlen(OSList[i].name);
-	}
-	width += 18; // Allow room for left & right borders, plus 8 spaces on each side
-
-	// Calculate the OS list box area
-	nOSListBoxLeft = (nScreenWidth - width) / 2;
-	nOSListBoxRight = nOSListBoxLeft + width;
-	nOSListBoxTop = (nScreenHeight - height) / 2 + 1;
-	nOSListBoxBottom = nOSListBoxTop + height;
-}
-
-void DrawMenu(void)
-{
-	int		i, j;
-	char	text[260];
-	char	temp[260];
-	int		space, space_left, space_right;
-
-	// Update the status bar
-	DrawStatusText(" Use \x18\x19 to select, ENTER to boot. Press F8 for advanced options.");
-
-	DrawBox(nOSListBoxLeft, nOSListBoxTop, nOSListBoxRight, nOSListBoxBottom, D_VERT, D_HORZ, TRUE, TRUE, ATTR(cMenuFgColor, cMenuBgColor));
-
-	for(i=0; i<nNumOS; i++)
-	{
-		space = (nOSListBoxRight - nOSListBoxLeft - 2) - strlen(OSList[i].name);
-		space_left = (space / 2) + 1;
-		space_right = (space - space_left) + 1;
-
-		text[0] = '\0';
-		for(j=0; j<space_left; j++)
-			strcat(text, " ");
-		strcat(text, OSList[i].name);
-		for(j=0; j<space_right; j++)
-			strcat(text, " ");
-
-		if(i == nOSSelected)
-		{
-			DrawText(nOSListBoxLeft+1, nOSListBoxTop+1+i, text, ATTR(cSelectedTextColor, cSelectedTextBgColor));
-		}
-		else
-		{
-			DrawText(nOSListBoxLeft+1, nOSListBoxTop+1+i, text, ATTR(cTextColor, cMenuBgColor));
-		}
-	}
-
-	if (nTimeOut >= 0)
-	{
-		strcpy(text, "[ Time Remaining: ");
-		itoa(nTimeOut, temp, 10);
-		strcat(text, temp);
-		strcat(text, " ]");
-
-		DrawText(nOSListBoxRight - strlen(text) - 1, nOSListBoxBottom, text, ATTR(cMenuFgColor, cMenuBgColor));
-	}
-}

freeldr/freeldr/menu.h

@@ -1,27 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef __MENU_H
-#define __MENU_H
-
-int		RunMenu(void);
-void	InitMenu(void);
-void	DrawMenu(void);
-
-#endif // #defined __MENU_H

freeldr/freeldr/miscboot.c

@@ -1,229 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-	
-#include "freeldr.h"
-#include "asmcode.h"
-#include "miscboot.h"
-#include "stdlib.h"
-#include "fs.h"
-#include "tui.h"
-
-void LoadAndBootBootSector(int nOSToBoot)
-{
-	FILE	file;
-	char	name[260];
-	char	value[260];
-	char	szFileName[1024];
-	int		i;
-
-	// Find all the message box settings and run them
-	for (i=1; i<=GetNumSectionItems(OSList[nOSToBoot].name); i++)
-	{
-		ReadSectionSettingByNumber(OSList[nOSToBoot].name, i, name, value);
-		if (stricmp(name, "MessageBox") == 0)
-			MessageBox(value);
-		if (stricmp(name, "MessageLine") == 0)
-			MessageLine(value);
-	}
-
-	if (!ReadSectionSettingByName(OSList[nOSToBoot].name, "BootDrive", name, value))
-	{
-		MessageBox("Boot drive not specified for selected OS!");
-		return;
-	}
-
-	BootDrive = atoi(value);
-
-	BootPartition = 0;
-	if (ReadSectionSettingByName(OSList[nOSToBoot].name, "BootPartition", name, value))
-		BootPartition = atoi(value);
-
-	if (!ReadSectionSettingByName(OSList[nOSToBoot].name, "BootSector", name, value))
-	{
-		MessageBox("Boot sector file not specified for selected OS!");
-		return;
-	}
-
-	if (!OpenDiskDrive(BootDrive, BootPartition))
-	{
-		MessageBox("Failed to open boot drive.");
-		return;
-	}
-
-	strcpy(szFileName, value);
-	if (!OpenFile(szFileName, &file))
-	{
-		strcat(value, " not found.");
-		MessageBox(value);
-		return;
-	}
-
-	// Read boot sector
-	if (ReadFile(&file, 512, (void*)0x7c00) != 512)
-	{
-		MessageBox("Disk Read Error");
-		return;
-	}
-
-	// Check for validity
-	if (*((WORD*)(0x7c00 + 0x1fe)) != 0xaa55)
-	{
-		MessageBox("Invalid boot sector magic (0xaa55)");
-		return;
-	}
-
-	RestoreScreen(pScreenBuffer);
-	showcursor();
-	gotoxy(nCursorXPos, nCursorYPos);
-
-	stop_floppy();
-	JumpToBootCode();
-}
-
-void LoadAndBootPartition(int nOSToBoot)
-{
-	char	name[260];
-	char	value[260];
-	int		head, sector, cylinder;
-	int		offset;
-	int		i;
-
-	// Find all the message box settings and run them
-	for (i=1; i<=GetNumSectionItems(OSList[nOSToBoot].name); i++)
-	{
-		ReadSectionSettingByNumber(OSList[nOSToBoot].name, i, name, value);
-		if (stricmp(name, "MessageBox") == 0)
-			MessageBox(value);
-		if (stricmp(name, "MessageLine") == 0)
-			MessageLine(value);
-	}
-
-	if (!ReadSectionSettingByName(OSList[nOSToBoot].name, "BootDrive", name, value))
-	{
-		MessageBox("Boot drive not specified for selected OS!");
-		return;
-	}
-
-	BootDrive = atoi(value);
-
-	if (!ReadSectionSettingByName(OSList[nOSToBoot].name, "BootPartition", name, value))
-	{
-		MessageBox("Boot partition not specified for selected OS!");
-		return;
-	}
-
-	BootPartition = atoi(value);
-
-	if (!biosdisk(_DISK_READ, BootDrive, 0, 0, 1, 1, SectorBuffer))
-	{
-		MessageBox("Disk Read Error");
-		return;
-	}
-
-	// Check for validity
-	if (*((WORD*)(SectorBuffer + 0x1fe)) != 0xaa55)
-	{
-		MessageBox("Invalid partition table magic (0xaa55)");
-		return;
-	}
-
-	offset = 0x1BE + ((BootPartition-1) * 0x10);
-
-	// Check for valid partition
-	if (SectorBuffer[offset + 4] == 0)
-	{
-		MessageBox("Invalid boot partition");
-		return;
-	}
-
-	head = SectorBuffer[offset + 1];
-	sector = (SectorBuffer[offset + 2] & 0x3F);
-	cylinder = SectorBuffer[offset + 3];
-	if (SectorBuffer[offset + 2] & 0x80)
-		cylinder += 0x200;
-	if (SectorBuffer[offset + 2] & 0x40)
-		cylinder += 0x100;
-
-	// Read partition boot sector
-	if (!biosdisk(_DISK_READ, BootDrive, head, cylinder, sector, 1, (void*)0x7c00))
-	{
-		MessageBox("Disk Read Error");
-		return;
-	}
-
-	// Check for validity
-	if (*((WORD*)(0x7c00 + 0x1fe)) != 0xaa55)
-	{
-		MessageBox("Invalid boot sector magic (0xaa55)");
-		return;
-	}
-
-	RestoreScreen(pScreenBuffer);
-	showcursor();
-	gotoxy(nCursorXPos, nCursorYPos);
-
-	stop_floppy();
-	JumpToBootCode();
-}
-
-void LoadAndBootDrive(int nOSToBoot)
-{
-	char	name[260];
-	char	value[260];
-	int		i;
-
-	// Find all the message box settings and run them
-	for (i=1; i<=GetNumSectionItems(OSList[nOSToBoot].name); i++)
-	{
-		ReadSectionSettingByNumber(OSList[nOSToBoot].name, i, name, value);
-		if (stricmp(name, "MessageBox") == 0)
-			MessageBox(value);
-		if (stricmp(name, "MessageLine") == 0)
-			MessageLine(value);
-	}
-
-	if (!ReadSectionSettingByName(OSList[nOSToBoot].name, "BootDrive", name, value))
-	{
-		MessageBox("Boot drive not specified for selected OS!");
-		return;
-	}
-
-	BootDrive = atoi(value);
-
-	if (!biosdisk(_DISK_READ, BootDrive, 0, 0, 1, 1, (void*)0x7c00))
-	{
-		MessageBox("Disk Read Error");
-		return;
-	}
-
-	// Check for validity
-	if (*((WORD*)(0x7c00 + 0x1fe)) != 0xaa55)
-	{
-		MessageBox("Invalid boot sector magic (0xaa55)");
-		return;
-	}
-
-	RestoreScreen(pScreenBuffer);
-	showcursor();
-	gotoxy(nCursorXPos, nCursorYPos);
-
-	stop_floppy();
-	JumpToBootCode();
-}

freeldr/freeldr/miscboot.h

@@ -1,29 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef __BOOT_H
-#define __BOOT_H
-
-void	JumpToBootCode(void);	// Implemented in boot.S
-
-void	LoadAndBootBootSector(int nOSToBoot);
-void	LoadAndBootPartition(int nOSToBoot);
-void	LoadAndBootDrive(int nOSToBoot);
-
-#endif // defined __BOOT_H

freeldr/freeldr/options.c

@@ -1,395 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-	
-#include "freeldr.h"
-#include "stdlib.h"
-#include "tui.h"
-#include "options.h"
-#include "miscboot.h"
-
-
-void DoOptionsMenu(void)
-{
-	int		OptionsMenuItemCount = 1; // Count is 1 because we don't show the "Set ReactOS Boot Flags" menu item yet
-	char	OptionsMenuItems[2][80] = {	"Boot Wizard", "Set ReactOS Boot Flags" /* i.e. Safe Mode, Last Known Good Configuration */	};
-	int		OptionsMenuItemSelected = 0;
-
-	while (OptionsMenuItemSelected != -1)
-	{
-		OptionsMenuItemSelected = RunOptionsMenu(OptionsMenuItems, OptionsMenuItemCount, OptionsMenuItemSelected, "[Advanced Options]");
-
-		switch (OptionsMenuItemSelected)
-		{
-		case 0:
-			DoDiskOptionsMenu();
-			break;
-		}
-	}
-}
-
-void DoDiskOptionsMenu(void)
-{
-	char	DiskMenuItems[25][80];
-	int		DiskMenuItemCount = 0;
-	int		FloppyDiskMenuItemCount = 0;
-	int		HardDiskMenuItemCount = 0;
-	int		DiskMenuItemSelected = 0;
-
-	char	temp[255];
-	int		i;
-
-	FloppyDiskMenuItemCount = (int)*((char *)((0x40 * 16) + 0x10)); // Get number of floppy disks from bios data area 40:10
-	if (FloppyDiskMenuItemCount & 1)
-		FloppyDiskMenuItemCount = (FloppyDiskMenuItemCount >> 6) + 1;
-	else
-		FloppyDiskMenuItemCount = 0;
-	HardDiskMenuItemCount = (int)*((char *)((0x40 * 16) + 0x75)); // Get number of hard disks from bios data area 40:75
-	DiskMenuItemCount = FloppyDiskMenuItemCount + HardDiskMenuItemCount;
-
-	for (i=0; i<FloppyDiskMenuItemCount; i++)
-	{
-		strcpy(DiskMenuItems[i], "Floppy Disk ");
-		itoa(i + 1, temp, 10);
-		strcat(DiskMenuItems[i], temp);
-	}
-
-	for (i=0; i<HardDiskMenuItemCount; i++)
-	{
-		strcpy(DiskMenuItems[i + FloppyDiskMenuItemCount], "Hard Disk ");
-		itoa(i + 1, temp, 10);
-		strcat(DiskMenuItems[i + FloppyDiskMenuItemCount], temp);
-		strcat(DiskMenuItems[i + FloppyDiskMenuItemCount], " (");
-		itoa((get_heads(i+0x80) * get_cylinders(i+0x80) * get_sectors(i+0x80)) / 2048, temp, 10);
-		strcat(DiskMenuItems[i + FloppyDiskMenuItemCount], temp);
-		strcat(DiskMenuItems[i + FloppyDiskMenuItemCount], " MB)");
-	}
-
-	DiskMenuItemSelected = 0;
-	while (DiskMenuItemSelected != -1)
-	{
-		DiskMenuItemSelected = RunOptionsMenu(DiskMenuItems, DiskMenuItemCount, DiskMenuItemSelected, "[Boot Wizard]");
-
-		if (DiskMenuItemSelected != -1)
-		{
-			if (DiskMenuItemSelected < FloppyDiskMenuItemCount)
-				DoBootOptionsMenu(DiskMenuItemSelected, DiskMenuItems[DiskMenuItemSelected]);
-			else
-				DoBootOptionsMenu((DiskMenuItemSelected - FloppyDiskMenuItemCount) + 0x80, DiskMenuItems[DiskMenuItemSelected]);
-		}
-	}
-}
-
-void DoBootOptionsMenu(int BootDriveNum, char *BootDriveText)
-{
-	int		BootOptionsMenuItemCount = 2;
-	char	BootOptionsMenuItems[2][80] = {	"Boot To ", "Pick A Boot Partition"	};
-	int		BootOptionsMenuItemSelected = 0;
-
-	strcat(BootOptionsMenuItems[0], BootDriveText);
-
-	while (BootOptionsMenuItemSelected != -1)
-	{
-		BootOptionsMenuItemSelected = RunOptionsMenu(BootOptionsMenuItems, BootOptionsMenuItemCount, BootOptionsMenuItemSelected, "[Boot Options]");
-
-		switch (BootOptionsMenuItemSelected)
-		{
-		case 0:
-			BootDrive = BootDriveNum;
-
-			if (!biosdisk(_DISK_READ, BootDrive, 0, 0, 1, 1, (void*)0x7c00))
-			{
-				MessageBox("Disk Read Error");
-				return;
-			}
-
-			// Check for validity
-			if (*((WORD*)(0x7c00 + 0x1fe)) != 0xaa55)
-			{
-				MessageBox("Invalid boot sector magic (0xaa55)");
-				return;
-			}
-
-			RestoreScreen(pScreenBuffer);
-			showcursor();
-			gotoxy(nCursorXPos, nCursorYPos);
-
-			stop_floppy();
-			JumpToBootCode();
-
-			break;
-		case 1:
-			if (BootDriveNum < 0x80)
-			{
-				MessageBox("This option is not available for a floppy disk.");
-				continue;
-			}
-			else
-				DoBootPartitionOptionsMenu(BootDriveNum);
-
-			break;
-		}
-	}
-}
-
-void DoBootPartitionOptionsMenu(int BootDriveNum)
-{
-	struct
-	{
-		int		partition_num;
-		int		partition_type;
-		int		head, sector, cylinder;
-	} BootPartitions[8];
-	int		BootOptionsMenuItemCount = 0;
-	char	BootOptionsMenuItems[8][80];
-	int		BootOptionsMenuItemSelected = 0;
-	int		head, sector, cylinder;
-	int		offset;
-	int		i;
-	char	temp[25];
-
-
-	BootDrive = BootDriveNum;
-
-	if (!biosdisk(_DISK_READ, BootDrive, 0, 0, 1, 1, SectorBuffer))
-	{
-		MessageBox("Disk Read Error");
-		return;
-	}
-
-	// Check for validity
-	if (*((WORD*)(SectorBuffer + 0x1fe)) != 0xaa55)
-	{
-		MessageBox("Invalid partition table magic (0xaa55)");
-		return;
-	}
-
-	offset = 0x1BE;
-
-	for (i=0; i<4; i++)
-	{
-		// Check for valid partition
-		if (SectorBuffer[offset + 4] != 0)
-		{
-			BootPartitions[BootOptionsMenuItemCount].partition_num = i;
-			BootPartitions[BootOptionsMenuItemCount].partition_type = SectorBuffer[offset + 4];
-
-			BootPartitions[BootOptionsMenuItemCount].head = SectorBuffer[offset + 1];
-			BootPartitions[BootOptionsMenuItemCount].sector = (SectorBuffer[offset + 2] & 0x3F);
-			BootPartitions[BootOptionsMenuItemCount].cylinder = SectorBuffer[offset + 3];
-			if (SectorBuffer[offset + 2] & 0x80)
-				BootPartitions[BootOptionsMenuItemCount].cylinder += 0x200;
-			if (SectorBuffer[offset + 2] & 0x40)
-				BootPartitions[BootOptionsMenuItemCount].cylinder += 0x100;
-
-			strcpy(BootOptionsMenuItems[BootOptionsMenuItemCount], "Boot To Partition ");
-			itoa(i+1, temp, 10);
-			strcat(BootOptionsMenuItems[BootOptionsMenuItemCount], temp);
-			strcat(BootOptionsMenuItems[BootOptionsMenuItemCount], " (Type: 0x");
-			itoa(BootPartitions[BootOptionsMenuItemCount].partition_type, temp, 16);
-			if (strlen(temp) < 2)
-				strcat(BootOptionsMenuItems[BootOptionsMenuItemCount], "0");
-			strcat(BootOptionsMenuItems[BootOptionsMenuItemCount], temp);
-			strcat(BootOptionsMenuItems[BootOptionsMenuItemCount], ")");
-
-			BootOptionsMenuItemCount++;
-		}
-
-		offset += 0x10;
-	}
-
-	while (BootOptionsMenuItemSelected != -1)
-	{
-		BootOptionsMenuItemSelected = RunOptionsMenu(BootOptionsMenuItems, BootOptionsMenuItemCount, BootOptionsMenuItemSelected, "[Boot Partition Options]");
-
-		if (BootOptionsMenuItemSelected != -1)
-		{
-			head = BootPartitions[BootOptionsMenuItemCount].head;
-			sector = BootPartitions[BootOptionsMenuItemCount].sector;
-			cylinder = BootPartitions[BootOptionsMenuItemCount].cylinder;
-
-			// Read partition boot sector
-			if (!biosdisk(_DISK_READ, BootDrive, head, cylinder, sector, 1, (void*)0x7c00))
-			{
-				MessageBox("Disk Read Error");
-				return;
-			}
-
-			// Check for validity
-			if (*((WORD*)(0x7c00 + 0x1fe)) != 0xaa55)
-			{
-				MessageBox("Invalid boot sector magic (0xaa55)");
-				return;
-			}
-
-			RestoreScreen(pScreenBuffer);
-			showcursor();
-			gotoxy(nCursorXPos, nCursorYPos);
-
-			stop_floppy();
-			JumpToBootCode();
-		}
-	}
-}
-
-int RunOptionsMenu(char OptionsMenuItems[][80], int OptionsMenuItemCount, int nOptionSelected, char *OptionsMenuTitle)
-{
-	int		key;
-	int		second;
-	BOOL	bDone = FALSE;
-	int		nOptionsMenuBoxLeft;
-	int		nOptionsMenuBoxRight;
-	int		nOptionsMenuBoxTop;
-	int		nOptionsMenuBoxBottom;
-
-
-	// Initialise the menu
-	InitOptionsMenu(&nOptionsMenuBoxLeft, &nOptionsMenuBoxTop, &nOptionsMenuBoxRight, &nOptionsMenuBoxBottom, OptionsMenuItemCount);
-
-	DrawBackdrop();
-
-	// Update the menu
-	DrawOptionsMenu(OptionsMenuItems, OptionsMenuItemCount, nOptionSelected, OptionsMenuTitle, nOptionsMenuBoxLeft, nOptionsMenuBoxTop, nOptionsMenuBoxRight, nOptionsMenuBoxBottom);
-
-	second = getsecond();
-
-	// Loop
-	do
-	{
-		// Check for a keypress
-		if (kbhit())
-		{
-			// Cancel the timeout
-			if (nTimeOut != -1)
-			{
-				nTimeOut = -1;
-				DrawOptionsMenu(OptionsMenuItems, OptionsMenuItemCount, nOptionSelected, OptionsMenuTitle, nOptionsMenuBoxLeft, nOptionsMenuBoxTop, nOptionsMenuBoxRight, nOptionsMenuBoxBottom);
-			}
-
-			// Get the key
-			key = getch();
-
-			// Is it extended?
-			if (key == 0)
-				key = getch(); // Yes - so get the extended key
-
-			// Process the key
-			switch (key)
-			{
-			case KEY_UP:
-				if (nOptionSelected)
-				{
-					nOptionSelected--;
-
-					// Update the menu
-					DrawOptionsMenu(OptionsMenuItems, OptionsMenuItemCount, nOptionSelected, OptionsMenuTitle, nOptionsMenuBoxLeft, nOptionsMenuBoxTop, nOptionsMenuBoxRight, nOptionsMenuBoxBottom);
-				}
-				break;
-			case KEY_DOWN:
-				if (nOptionSelected < (OptionsMenuItemCount - 1))
-				{
-					nOptionSelected++;
-
-					// Update the menu
-					DrawOptionsMenu(OptionsMenuItems, OptionsMenuItemCount, nOptionSelected, OptionsMenuTitle, nOptionsMenuBoxLeft, nOptionsMenuBoxTop, nOptionsMenuBoxRight, nOptionsMenuBoxBottom);
-				}
-				break;
-			case KEY_ENTER:
-				//MessageBox("The Advanced Options are still being implemented.");
-				bDone = TRUE;
-				break;
-			case KEY_ESC:
-				nOptionSelected = -1;
-				bDone = TRUE;
-				break;
-			}
-		}
-
-		// Update the date & time
-		UpdateDateTime();
-
-		if (nTimeOut > 0)
-		{
-			if (getsecond() != second)
-			{
-				second = getsecond();
-				nTimeOut--;
-
-				// Update the menu
-				DrawOptionsMenu(OptionsMenuItems, OptionsMenuItemCount, nOptionSelected, OptionsMenuTitle, nOptionsMenuBoxLeft, nOptionsMenuBoxTop, nOptionsMenuBoxRight, nOptionsMenuBoxBottom);
-			}
-		}
-
-		if (nTimeOut == 0)
-			bDone = TRUE;
-	}
-	while (!bDone);
-
-	return nOptionSelected;
-}
-
-void InitOptionsMenu(int *nOptionsMenuBoxLeft, int *nOptionsMenuBoxTop, int *nOptionsMenuBoxRight, int *nOptionsMenuBoxBottom, int OptionsMenuItemCount)
-{
-	int		height = OptionsMenuItemCount;
-	int		width = 20;
-
-	height += 1; // Allow room for top & bottom borders
-	width += 18; // Allow room for left & right borders, plus 8 spaces on each side
-
-	// Calculate the OS list box area
-	*nOptionsMenuBoxLeft = (nScreenWidth - width) / 2;
-	*nOptionsMenuBoxRight = *nOptionsMenuBoxLeft + width;
-	*nOptionsMenuBoxTop = (nScreenHeight - height) / 2 + 1;
-	*nOptionsMenuBoxBottom = *nOptionsMenuBoxTop + height;
-}
-
-void DrawOptionsMenu(char OptionsMenuItems[][80], int OptionsMenuItemCount, int nOptionSelected, char *OptionsMenuTitle, int nOptionsMenuBoxLeft, int nOptionsMenuBoxTop, int nOptionsMenuBoxRight, int nOptionsMenuBoxBottom)
-{
-	int		i, j;
-	char	text[260];
-	int		space, space_left, space_right;
-
-	// Update the status bar
-	DrawStatusText(" Use \x18\x19 to select, then press ENTER. Press ESC to go back.");
-
-	DrawBox(nOptionsMenuBoxLeft, nOptionsMenuBoxTop, nOptionsMenuBoxRight, nOptionsMenuBoxBottom, D_VERT, D_HORZ, TRUE, TRUE, ATTR(cMenuFgColor, cMenuBgColor));
-	DrawText(nOptionsMenuBoxLeft + (((nOptionsMenuBoxRight - nOptionsMenuBoxLeft) - strlen(OptionsMenuTitle)) / 2) + 1, nOptionsMenuBoxTop, OptionsMenuTitle, ATTR(cMenuFgColor, cMenuBgColor));
-
-	for(i=0; i<OptionsMenuItemCount; i++)
-	{
-		space = (nOptionsMenuBoxRight - nOptionsMenuBoxLeft - 2) - strlen(OptionsMenuItems[i]);
-		space_left = (space / 2) + 1;
-		space_right = (space - space_left) + 1;
-
-		text[0] = '\0';
-		for(j=0; j<space_left; j++)
-			strcat(text, " ");
-		strcat(text, OptionsMenuItems[i]);
-		for(j=0; j<space_right; j++)
-			strcat(text, " ");
-
-		if(i == nOptionSelected)
-		{
-			DrawText(nOptionsMenuBoxLeft+1, nOptionsMenuBoxTop+1+i, text, ATTR(cSelectedTextColor, cSelectedTextBgColor));
-		}
-		else
-		{
-			DrawText(nOptionsMenuBoxLeft+1, nOptionsMenuBoxTop+1+i, text, ATTR(cTextColor, cMenuBgColor));
-		}
-	}
-}

freeldr/freeldr/options.h

@@ -1,31 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef __OPTIONS_H
-#define __OPTIONS_H
-
-void	DoOptionsMenu(void);
-void	DoDiskOptionsMenu(void);
-void	DoBootOptionsMenu(int BootDriveNum, char *BootDriveText);
-void	DoBootPartitionOptionsMenu(int BootDriveNum);
-int		RunOptionsMenu(char OptionsMenuItems[][80], int OptionsMenuItemCount, int nOptionSelected, char *OptionsMenuTitle);
-void	InitOptionsMenu(int *nOptionsMenuBoxLeft, int *nOptionsMenuBoxTop, int *nOptionsMenuBoxRight, int *nOptionsMenuBoxBottom, int OptionsMenuItemCount);
-void	DrawOptionsMenu(char OptionsMenuItems[][80], int OptionsMenuItemCount, int nOptionSelected, char *OptionsMenuTitle, int nOptionsMenuBoxLeft, int nOptionsMenuBoxTop, int nOptionsMenuBoxRight, int nOptionsMenuBoxBottom);
-
-#endif // #defined __OPTIONS_H

freeldr/freeldr/ros.S

@@ -1,374 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-	.text
-	.code16
-
-#include "asmcode.h"
-
-	/*
-	 * Needed for enabling the a20 address line
-	 */
-empty_8042:
-	.word	0x00eb,0x00eb            // jmp $+2, jmp $+2
-	inb     $0x64,%al
-    testb   $0x02,%al
-    jnz     empty_8042
-	ret
-
-	/*
-	 * Enable the A20 address line (to allow access to over 1mb)
-	 */
-	.code32
-EXTERN(_enable_a20)
-	call	switch_to_real
-	.code16
-
-	call	empty_8042
-    movb	$0xD1,%al                // command write
-    outb	%al,$0x64
-	call	empty_8042
-    mov		$0xDF,%al                // A20 on
-    out		%al,$0x60
-	call	empty_8042
-	call	switch_to_prot
-	.code32
-
-	ret
-
-	.code16
-
-    /*
-     * Reprogram the PIC because they overlap the Intel defined
-     * exceptions 
-	 */
-reprogram_pic:
-	movb	$0x11,%al                // initialization sequence
-	outb    %al,$0x20                // send it to 8259A-1
-	.word	0x00eb,0x00eb            // jmp $+2, jmp $+2
-	outb    %al,$0xA0                // and to 8259A-2
-	.word	0x00eb,0x00eb
-	movb    $0x40,%al                // start of hardware int's (0x20)
-	outb    %al,$0x21
-	.word	0x00eb,0x00eb
-	movb    $0x48,%al                // start of hardware int's 2 (0x28)
-	outb    %al,$0xA1
-	.word	0x00eb,0x00eb
-	movb    $0x04,%al                // 8259-1 is master
-	outb    %al,$0x21
-	.word	0x00eb,0x00eb
-	movb	$0x02,%al                // 8259-2 is slave
-	outb	%al,$0xA1
-	.word	0x00eb,0x00eb
-	movb	$0x01,%al                // 8086 mode for both
-	outb	%al,$0x21
-	.word	0x00eb,0x00eb
-	outb	%al,$0xA1
-	.word	0x00eb,0x00eb
-	movb	$0xFF,%al                // mask off all interrupts for now
-	outb	%al,$0x21
-	.word	0x00eb,0x00eb
-	outb	%al,$0xA1
-	ret
-
-	/*
-	 * In: EDI = address
-	 * Out: FS = segment
-	 *      DI = base
-	 */
-convert_to_seg:
-	pushl	%eax
-
-	movl	%edi,%eax
-	//shrl	$16,%eax
-	//shll	$12,%eax
-	//movw	%ax,%fs
-
-	shrl	$4,%eax
-	movw	%ax,%fs
-	andl	$0xf,%edi
-
-	//andl	$0xFFFF,%edi
-
-	popl	%eax
-	ret
-
-	/*
-     * Here we assume the kernel is loaded at 1mb
-     * This boots the kernel
-	 */
-	.code32
-EXTERN(_boot_ros)
-	call	switch_to_real
-	.code16
-
-    /* Save cursor position */
-	movw    $3,%ax          //! Reset video mode
-	int     $0x10
-
-
-	movb    $10,%bl
-	movb    $12,%ah
-	int     $0x10
-
-	movw    $0x1112,%ax      //! Use 8x8 font
-	xorb	%bl,%bl
-	int     $0x10
-	movw    $0x1200,%ax      //! Use alternate print screen
-	movb    $0x20,%bl
-	int     $0x10
-	movb    $1,%ah         //! Define cursor (scan lines 6 to 7)
-	movw    $0x0607,%cx
-	int     $0x10
-
-	movb    $1,%ah
-	movw    $0x600,%cx
-	int     $0x10
-
-	MOVb      $6,%AH        //SCROLL ACTIVE PAGE UP
-	MOVb      $0x32,%AL      //CLEAR 25 LINES
-	MOVw      $0,%CX       //UPPER LEFT OF SCROLL
-	MOVw      $0x314F,%dx    //LOWER RIGHT OF SCROLL
-	MOVb      $(1*0x10+1),%bh  //USE NORMAL ATTRIBUTE ON BLANKED LINE
-	INT       $0x10         //VIDEO-IO
-
-
-	movw     $0,%dx
-	movb     $0,%dh
-
-	movb     $2,%ah
-	movb     $0,%bh
-	int     $0x10
-
-	movw     $0,%dx
-	movb     $0,%dh
-
-	movb     $2,%ah
-	movb     $0,%bh
-	int      $0x10
-
-	cli
-
-	// The page tables are setup elsewhere
-	/*
-	// Map in the lowmem page table (and reuse it for the identity map)
-	movl	_kernel_page_directory_base,%edi
-	call    convert_to_seg
-
-	movl	_lowmem_page_table_base,%eax
-	addl	$0x07,%eax
-	movl	%eax,%fs:(%edi)
-	movl	%eax,%fs:0xd00(%edi)//(0xd0000000/(1024*1024))(%edi)
-	
-	// Map the page tables from the page directory
-	movl	_kernel_page_directory_base,%eax
-	addl	$0x07,%eax
-	movl	%eax,%fs:0xf00(%edi)//(0xf0000000/(1024*1024))(%edi)
-
-	// Map in the kernel page table
-	movl	_system_page_table_base,%eax
-	addl	$0x07,%eax
-	movl	%eax,%fs:0xc00(%edi)//(0xc0000000/(1024*1024))(%edi)
-
-	// Setup the lowmem page table
-	movl	_lowmem_page_table_base,%edi
-	call	convert_to_seg
-
-	movl	$0,%ebx
-l9:
-	movl	%ebx,%eax
-	shll	$12,%eax        // ebx = ebx * 4096
-	addl	$07,%eax        // user, rw, present
-	movl	%eax,%fs:(%edi,%ebx,4)
-	incl	%ebx
-	cmpl	$1024,%ebx
-	jl		l9
-
-	// Setup the system page table
-	movl	_system_page_table_base,%edi
-	call	convert_to_seg
-
-	movl	$07,%eax
-l8:
-	movl	%eax,%edx
-	addl	_start_kernel,%edx
-	movl	%edx,%fs:(%edi)
-	addl	$4,%edi
-	addl	$0x1000,%eax
-	cmpl	$0x100007,%eax
-	jl      l8
-	*/
-
-	/*
-	 * Load the page directory into cr3
-	 */
-	movl	_kernel_page_directory_base,%eax
-	movl	%eax,%cr3
-
-	/*
-	 * Setup various variables
-	 */
-	movw	%ds,%bx
-	movzwl	%bx,%eax
-	shll	$4,%eax
-	addl	%eax,kernel_gdtbase
-
-	//call	enable_a20 // enabled elsewhere
-	call	reprogram_pic
-
-	/*
-	 * Load stack
-	 */
-	movw	%ds,%bx
-	movzwl	%bx,%eax
-	shll	$4,%eax
-	addl	$real_stack_end,%eax
-	movl	%eax,real_stack_base
-	movl	real_stack_base,%esp
-	movl	_boot_param_struct_base,%edx
-
-	/*
-	 * load gdt
-	 */
-	lgdt	kernel_gdtptr
-
-	/*       
-	 * Enter pmode and clear prefetch queue
-	 */
-	movl	%cr0,%eax
-	orl		$0x80010001,%eax
-	/*orl		$0x80000001,%eax*/
-	movl	%eax,%cr0
-	jmp		next
-next:
-	/*
-	 * NOTE: This must be position independant (no references to
-	 * non absolute variables)
-	 */
-
-	/*
-	 * Initalize segment registers
-	 */
-	movw	$KERNEL_DS,%ax
-	movw	%ax,%ds
-	movw	%ax,%ss
-	movw	%ax,%es
-	movw	%ax,%fs
-	movw	%ax,%gs
-
-	/*
-	 * Initalize eflags
-	 */
-	pushl	$0
-	popfl	
-
-	/*
-	 * Jump to start of 32 bit code at 0xc0000000 + 0x1000
-	 */
-	pushl	%edx
-	pushl	$0
-	ljmpl	$KERNEL_CS,$(KERNEL_BASE+0x1000)
-
-
-	.p2align	2	/* force 4-byte alignment */
-kernel_gdt:
-	.word 0               // Zero descriptor
-	.word 0
-	.word 0
-	.word 0
-                        
-	//.word 0x0000          // User code descriptor
-	//.word 0x0000          // base: 0h limit: 3gb
-	//.word 0xfa00
-	//.word 0x00cc
-                       
-	//.word 0x0000          // User data descriptor
-	//.word 0x0000          // base: 0h limit: 3gb
-	//.word 0xf200
-	//.word 0x00cc
-                    
-	//.word 0x0000         
-	//.word 0x0000         
-	//.word 0x0000
-	//.word 0x0000
-
-	.word 0xffff          // Kernel code descriptor 
-	.word 0x0000          // 
-	.word 0x9a00          // base 0h limit 4gb
-	.word 0x00cf
-                       
-	.word 0xffff          // Kernel data descriptor
-	.word 0x0000          // 
-	.word 0x9200          // base 0h limit 4gb
-	.word 0x00cf
-
-    /* TSS space */    
-	//.rept NR_TASKS
-	//.word 0
-	//.word 0
-	//.word 0
-	//.word 0
-	//.endr
-
-kernel_gdtptr:
-	.word	(((6+NR_TASKS)*8)-1)	/* Limit */
-kernel_gdtbase:
-	.long	kernel_gdt				/* Base Address */
-
-EXTERN(_boot_param_struct_base)
-	.long	0
-EXTERN(_start_mem)
-	.long	0
-EXTERN(_kernel_page_directory_base)
-	.long	0
-EXTERN(_system_page_table_base)
-	.long	0
-EXTERN(_lowmem_page_table_base)
-	.long	0
-EXTERN(_start_kernel)
-	.long	0
-EXTERN(_load_base)
-	.long	0
-
-/* boot_param structure */
-EXTERN(_boot_parameters)
-	.long	0		// Magic
-	.long	0		// Cursor X
-	.long	0		// Cursor Y
-	.long	0		// nr_files
-	.long	0		// start_mem
-	.long	0		// end_mem
-
-	.rept	64
-	.long	0		// List of module lengths (terminated by a 0)
-	.endr
-
-	.rept	256
-	.byte	0		// Kernel parameter string
-	.endr
-
-/* Our initial stack */
-real_stack:
-		.rept 1024
-		.byte 0
-		.endr
-real_stack_end:
-
-real_stack_base:
-		.long 0

freeldr/freeldr/rosboot.c

@@ -1,390 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-	
-#include "freeldr.h"
-#include "asmcode.h"
-#include "rosboot.h"
-#include "stdlib.h"
-#include "fs.h"
-#include "tui.h"
-
-extern boot_param	boot_parameters;			// Boot parameter structure passed to the kernel
-extern int	boot_param_struct_base;		// Physical address of the boot parameters structure
-extern int	start_mem;					// Start of the continuous range of physical kernel memory
-extern int	kernel_page_directory_base;	// Physical address of the kernel page directory
-extern int	system_page_table_base;		// Physical address of the system page table
-extern int	lowmem_page_table_base;		// Physical address of the low mem page table
-extern int	start_kernel;				// Physical address of the start of kernel code
-extern int	load_base;					// Physical address of the loaded kernel modules 
-
-static int	next_load_base;
-
-void LoadAndBootReactOS(int nOSToBoot)
-{
-	FILE		file;
-	char		name[1024];
-	char		value[1024];
-	char		szFileName[1024];
-	int			i;
-	int			nNumDriverFiles=0;
-	int			nNumFilesLoaded=0;
-
-	/*
-	 * Enable a20 so we can load at 1mb and initialize the page tables
-	 */
-	//enable_a20(); // enabled in freeldr.c
-	ReactOSMemInit();
-
-	// Setup kernel parameters
-	boot_param_struct_base = (int)&boot_parameters;
-	boot_parameters.magic = 0xdeadbeef;
-	boot_parameters.cursorx = 0;
-	boot_parameters.cursory = 0;
-	boot_parameters.nr_files = 0;
-	boot_parameters.start_mem = start_mem;
-	boot_parameters.end_mem = load_base;
-	boot_parameters.kernel_parameters[0] = 0;
-
-	next_load_base = load_base;
-
-	/*
-	 * Read the optional kernel parameters
-	 */
-	if(ReadSectionSettingByName(OSList[nOSToBoot].name, "Options", name, value))
-	{
-		strcpy(boot_parameters.kernel_parameters,value);
-	}
-
-	/*
-	 * Find the kernel image name
-	 */
-	if(!ReadSectionSettingByName(OSList[nOSToBoot].name, "Kernel", name, value))
-	{
-		MessageBox("Kernel image file not specified for selected operating system.");
-		return;
-	}
-
-	/*
-	 * Get the boot partition
-	 */
-	BootPartition = 0;
-	if (ReadSectionSettingByName(OSList[nOSToBoot].name, "BootPartition", name, value))
-		BootPartition = atoi(value);
-
-	/*
-	 * Make sure the boot drive is set in the .ini file
-	 */
-	if(!ReadSectionSettingByName(OSList[nOSToBoot].name, "BootDrive", name, value))
-	{
-		MessageBox("Boot drive not specified for selected operating system.");
-		return;
-	}
-
-	DrawBackdrop();
-
-	DrawStatusText(" Loading...");
-	DrawProgressBar(0);
-
-	/*
-	 * Set the boot drive and try to open it
-	 */
-	BootDrive = atoi(value);
-	if (!OpenDiskDrive(BootDrive, BootPartition))
-	{
-		MessageBox("Failed to open boot drive.");
-		return;
-	}
-
-	/*
-	 * Parse the ini file and count the kernel and drivers
-	 */
-	for (i=1; i<=GetNumSectionItems(OSList[nOSToBoot].name); i++)
-	{
-		/*
-		 * Read the setting and check if it's a driver
-		 */
-		ReadSectionSettingByNumber(OSList[nOSToBoot].name, i, name, value);
-		if ((stricmp(name, "Kernel") == 0) || (stricmp(name, "Driver") == 0))
-			nNumDriverFiles++;
-	}
-
-	/*
-	 * Parse the ini file and load the kernel and
-	 * load all the drivers specified
-	 */
-	for (i=1; i<=GetNumSectionItems(OSList[nOSToBoot].name); i++)
-	{
-		/*
-		 * Read the setting and check if it's a driver
-		 */
-		ReadSectionSettingByNumber(OSList[nOSToBoot].name, i, name, value);
-		if ((stricmp(name, "Kernel") == 0) || (stricmp(name, "Driver") == 0))
-		{
-			/*
-			 * Set the name and try to open the PE image
-			 */
-			strcpy(szFileName, value);
-			if (!OpenFile(szFileName, &file))
-			{
-				strcat(value, " not found.");
-				MessageBox(value);
-				return;
-			}
-
-			/*
-			 * Update the status bar with the current file
-			 */
-			strcpy(name, " Reading ");
-			strcat(name, value);
-			while (strlen(name) < 80)
-				strcat(name, " ");
-			DrawStatusText(name);
-
-			/*
-			 * Load the driver
-			 */
-			ReactOSLoadPEImage(&file);
-
-			nNumFilesLoaded++;
-			DrawProgressBar((nNumFilesLoaded * 100) / nNumDriverFiles);
-
-			// Increment the number of files we loaded
-			boot_parameters.nr_files++;
-		}
-		else if (stricmp(name, "MessageBox") == 0)
-		{
-			DrawStatusText(" Press ENTER to continue");
-			MessageBox(value);
-		}
-		else if (stricmp(name, "MessageLine") == 0)
-			MessageLine(value);
-		else if (stricmp(name, "ReOpenBootDrive") == 0)
-		{
-			if (!OpenDiskDrive(BootDrive, BootPartition))
-			{
-				MessageBox("Failed to open boot drive.");
-				return;
-			}
-		}
-	}
-
-	/*
-	 * End the list of modules we load with a zero length entry
-	 * and update the end of kernel mem
-	 */
-	boot_parameters.module_lengths[boot_parameters.nr_files] = 0;
-	boot_parameters.end_mem = next_load_base;
-
-	/*
-	 * Clear the screen and redraw the backdrop and status bar
-	 */
-	DrawBackdrop();
-	DrawStatusText(" Press any key to boot");
-
-	/*
-	 * Wait for user
-	 */
-	strcpy(name, "Kernel and Drivers loaded.\nPress any key to boot ");
-	strcat(name, OSList[nOSToBoot].name);
-	strcat(name, ".");
-	//MessageBox(name);
-
-	RestoreScreen(pScreenBuffer);
-
-	/*
-	 * Now boot the kernel
-	 */
-	stop_floppy();
-	ReactOSBootKernel();
-}
-
-void ReactOSMemInit(void)
-{
-	int		base;
-
-	/* Calculate the start of extended memory */
-	base = 0x100000;
-
-	/* Set the start of the page directory */
-	kernel_page_directory_base = base;
-
-	/*
-	 * Set the start of the continuous range of physical memory
-	 * occupied by the kernel
-	 */
-	start_mem = base;
-	base += 0x1000;
-
-	/* Calculate the start of the system page table (0xc0000000 upwards) */
-	system_page_table_base = base;
-	base += 0x1000;
-
-	/* Calculate the start of the page table to map the first 4mb */
-	lowmem_page_table_base = base;
-	base += 0x1000;
-
-	/* Set the position for the first module to be loaded */
-	load_base = base;
-
-	/* Set the address of the start of kernel code */
-	start_kernel = base;
-}
-
-void ReactOSBootKernel(void)
-{
-	int		i;
-	int		*pPageDirectory = (int *)kernel_page_directory_base;
-	int		*pLowMemPageTable = (int *)lowmem_page_table_base;
-	int		*pSystemPageTable = (int *)system_page_table_base;
-
-	/* Zero out the kernel page directory */
-	for(i=0; i<1024; i++)
-		pPageDirectory[i] = 0;
-
-	/* Map in the lowmem page table */
-	pPageDirectory[(0x00/4)] = lowmem_page_table_base + 0x07;
-
-	/* Map in the lowmem page table (and reuse it for the identity map) */
-	pPageDirectory[(0xd00/4)] = lowmem_page_table_base + 0x07;
-	
-	/* Map the page tables from the page directory */
-	pPageDirectory[(0xf00/4)] = kernel_page_directory_base + 0x07;
-
-	/* Map in the kernel page table */
-	pPageDirectory[(0xc00/4)] = system_page_table_base + 0x07;
-
-	/* Setup the lowmem page table */
-	for(i=0; i<1024; i++)
-		pLowMemPageTable[i] = (i * 4096) + 0x07;
-
-	/* Setup the system page table */
-	for(i=0; i<1024; i++)
-		pSystemPageTable[i] = ((i * 4096) + start_kernel) + 0x07;
-
-	boot_ros();
-}
-
-BOOL ReactOSLoadPEImage(FILE *pImage)
-{
-	unsigned int			Idx, ImageBase;
-	PULONG					PEMagic;
-	PIMAGE_DOS_HEADER		PEDosHeader;
-	PIMAGE_FILE_HEADER		PEFileHeader;
-	PIMAGE_OPTIONAL_HEADER	PEOptionalHeader;
-	PIMAGE_SECTION_HEADER	PESectionHeaders;
-
-	ImageBase = next_load_base;
-	boot_parameters.module_lengths[boot_parameters.nr_files] = 0;
-
-	/*
-	 * Load the headers
-	 */
-	ReadFile(pImage, 0x1000, (void *)next_load_base);
-
-	/*
-	 * Get header pointers
-	 */
-	PEDosHeader = (PIMAGE_DOS_HEADER) next_load_base;
-	PEMagic = (PULONG) ((unsigned int) next_load_base + 
-				PEDosHeader->e_lfanew);
-	PEFileHeader = (PIMAGE_FILE_HEADER) ((unsigned int) next_load_base + 
-					PEDosHeader->e_lfanew + sizeof(ULONG));
-	PEOptionalHeader = (PIMAGE_OPTIONAL_HEADER) ((unsigned int) next_load_base + 
-					PEDosHeader->e_lfanew + sizeof(ULONG) + sizeof(IMAGE_FILE_HEADER));
-	PESectionHeaders = (PIMAGE_SECTION_HEADER) ((unsigned int) next_load_base + 
-					PEDosHeader->e_lfanew + sizeof(ULONG) + sizeof(IMAGE_FILE_HEADER) +
-					sizeof(IMAGE_OPTIONAL_HEADER));
-
-	/*
-	 * Check file magic numbers
-	 */
-	if(PEDosHeader->e_magic != IMAGE_DOS_MAGIC)
-	{
-		MessageBox("Incorrect MZ magic");
-		return FALSE;
-	}
-	if(PEDosHeader->e_lfanew == 0)
-	{
-		MessageBox("Invalid lfanew offset");
-		return 0;
-	}
-	if(*PEMagic != IMAGE_PE_MAGIC)
-	{
-		MessageBox("Incorrect PE magic");
-		return 0;
-	}
-	if(PEFileHeader->Machine != IMAGE_FILE_MACHINE_I386)
-	{
-		MessageBox("Incorrect Architecture");
-		return 0;
-	}
-
-	/*
-	 * Get header size and bump next_load_base
-	 */
-	next_load_base += ROUND_UP(PEOptionalHeader->SizeOfHeaders, PEOptionalHeader->SectionAlignment);
-	boot_parameters.module_lengths[boot_parameters.nr_files] += ROUND_UP(PEOptionalHeader->SizeOfHeaders, PEOptionalHeader->SectionAlignment);
-	boot_parameters.end_mem += ROUND_UP(PEOptionalHeader->SizeOfHeaders, PEOptionalHeader->SectionAlignment);
-
-	/*
-	 * Copy image sections into virtual section
-	 */
-//  memcpy(DriverBase, ModuleLoadBase, PESectionHeaders[0].PointerToRawData);
-//  CurrentBase = (PVOID) ((DWORD)DriverBase + PESectionHeaders[0].PointerToRawData);
-//	CurrentSize = 0;
-	for (Idx = 0; Idx < PEFileHeader->NumberOfSections; Idx++)
-	{
-		/*
-		 * Copy current section into current offset of virtual section
-		 */
-		if (PESectionHeaders[Idx].Characteristics & 
-			(IMAGE_SECTION_CHAR_CODE | IMAGE_SECTION_CHAR_DATA))
-		{
-			//memcpy(PESectionHeaders[Idx].VirtualAddress + DriverBase,
-			//	(PVOID)(ModuleLoadBase + PESectionHeaders[Idx].PointerToRawData),
-			//	PESectionHeaders[Idx].Misc.VirtualSize /*SizeOfRawData*/);
-
-			//MessageBox("loading a section");
-			fseek(pImage, PESectionHeaders[Idx].PointerToRawData);
-			ReadFile(pImage, PESectionHeaders[Idx].Misc.VirtualSize /*SizeOfRawData*/, (void *)next_load_base);
-			//printf("PointerToRawData: %x\n", PESectionHeaders[Idx].PointerToRawData);
-			//printf("bytes at next_load_base: %x\n", *((unsigned long *)next_load_base));
-			//getch();
-		}
-		else
-		{
-			//memset(PESectionHeaders[Idx].VirtualAddress + DriverBase, 
-			//	'\0', PESectionHeaders[Idx].Misc.VirtualSize /*SizeOfRawData*/);
-
-			//MessageBox("zeroing a section");
-			memset((void *)next_load_base, '\0', PESectionHeaders[Idx].Misc.VirtualSize /*SizeOfRawData*/);
-		}
-
-		PESectionHeaders[Idx].PointerToRawData = next_load_base - ImageBase;
-
-		next_load_base += ROUND_UP(PESectionHeaders[Idx].Misc.VirtualSize,	PEOptionalHeader->SectionAlignment);
-		boot_parameters.module_lengths[boot_parameters.nr_files] += ROUND_UP(PESectionHeaders[Idx].Misc.VirtualSize,	PEOptionalHeader->SectionAlignment);
-		boot_parameters.end_mem += ROUND_UP(PESectionHeaders[Idx].Misc.VirtualSize,	PEOptionalHeader->SectionAlignment);
-
-		//DrawProgressBar((Idx * 100) / PEFileHeader->NumberOfSections);
-	}
-
-	return TRUE;
-}

freeldr/freeldr/rosboot.h

@@ -1,75 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef __ROSBOOT_H
-#define __ROSBOOT_H
-
-#include "freeldr.h"
-#include "stdlib.h"
-#include "pe.h"
-
-#define PACKED __attribute__((packed))
-
-void	LoadAndBootReactOS(int nOSToBoot);
-void	ReactOSMemInit(void);
-void	ReactOSBootKernel(void);
-BOOL	ReactOSLoadPEImage(FILE *pImage);
-void	enable_a20(void);
-void	boot_ros(void);
-
-
-// WARNING:
-// This structure is prototyped here but allocated in ros.S
-// if you change this prototype make sure to update ros.S
-typedef struct
-{
-	/*
-	 * Magic value (useless really)
-	 */
-	unsigned int magic;
-
-	/*
-	 * Cursor position
-	 */
-	unsigned int cursorx;
-	unsigned int cursory;
-
-	/*
-	 * Number of files (including the kernel) loaded
-	 */
-	unsigned int nr_files;
-
-	/*
-	 * Range of physical memory being used by the system
-	 */
-	unsigned int start_mem;
-	unsigned int end_mem;
-
-	/*
-	 * List of module lengths (terminated by a 0)
-	 */
-	unsigned int module_lengths[64];
-
-	/*
-	 * Kernel parameter string
-	 */
-	char kernel_parameters[256];
-} boot_param PACKED;
-
-#endif // defined __ROSBOOT_H

freeldr/freeldr/stdlib.c

@@ -1,306 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include "freeldr.h"
-#include "stdlib.h"
-
-/*
- * print() - prints unformatted text to stdout
- */
-void print(char *str)
-{
-	int	i;
-
-	for(i=0; i<strlen(str); i++)
-		putchar(str[i]);
-}
-
-/*
- * convert_to_ascii() - converts a number to it's ascii equivalent
- * from:
- *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 1996   Erich Boleyn  <erich@uruk.org>
- */
-char *convert_to_ascii(char *buf, int c, ...)
-{
-  unsigned long num = *((&c) + 1), mult = 10;
-  char *ptr = buf;
-
-  if (c == 'x')
-    mult = 16;
-
-  if ((num & 0x80000000uL) && c == 'd')
-    {
-      num = (~num)+1;
-      *(ptr++) = '-';
-      buf++;
-    }
-
-  do
-    {
-      int dig = num % mult;
-      *(ptr++) = ( (dig > 9) ? dig + 'a' - 10 : '0' + dig );
-    }
-  while (num /= mult);
-
-  /* reorder to correct direction!! */
-  {
-    char *ptr1 = ptr-1;
-    char *ptr2 = buf;
-    while (ptr1 > ptr2)
-      {
-	int c = *ptr1;
-	*ptr1 = *ptr2;
-	*ptr2 = c;
-	ptr1--;
-	ptr2++;
-      }
-  }
-
-  return ptr;
-}
-
-/*
- * printf() - prints formatted text to stdout
- * from:
- *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 1996   Erich Boleyn  <erich@uruk.org>
- */
-void printf(char *format, ... )
-{
-  int *dataptr = (int *) &format;
-  char c, *ptr, str[16];
-
-  dataptr++;
-
-  while ((c = *(format++)))
-    {
-      if (c != '%')
-	putchar(c);
-      else
-	switch (c = *(format++))
-	  {
-	  case 'd': case 'u': case 'x':
-	    *convert_to_ascii(str, c, *((unsigned long *) dataptr++)) = 0;
-
-	    ptr = str;
-
-	    while (*ptr)
-	      putchar(*(ptr++));
-	    break;
-
-	  case 'c': putchar((*(dataptr++))&0xff); break;
-
-	  case 's':
-	    ptr = (char *)(*(dataptr++));
-
-	    while ((c = *(ptr++)))
-	      putchar(c);
-	    break;
-	  }
-    }
-}
-	
-int strlen(char *str)
-{
-	int	len;
-
-	for(len=0; str[len] != '\0'; len++);
-
-	return len;
-}
-
-char *itoa(int value, char *string, int radix)
-{
-	if(radix == 16)
-	    *convert_to_ascii(string, 'x', value) = 0;
-	else
-	    *convert_to_ascii(string, 'd', value) = 0;
-
-	return string;
-}
-
-int toupper(int c)
-{
-	if((c >= 'a') && (c <= 'z'))
-		c -= 32;
-
-	return c;
-}
-
-int tolower(int c)
-{
-	if((c >= 'A') && (c <= 'Z'))
-		c += 32;
-
-	return c;
-}
-
-int memcmp(const void *buf1, const void *buf2, size_t count)
-{
-	size_t		i;
-	const char	*buffer1 = buf1;
-	const char	*buffer2 = buf2;
-
-	for(i=0; i<count; i++)
-	{
-		if(buffer1[i] == buffer2[i])
-			continue;
-		else
-			return (buffer1[i] - buffer2[i]);
-	}
-
-	return 0;
-}
-
-void *memcpy(void *dest, const void *src, size_t count)
-{
-	size_t		i;
-	char		*buf1 = dest;
-	const char	*buf2 = src;
-
-	for(i=0; i<count; i++)
-		buf1[i] = buf2[i];
-
-	return dest;
-}
-
-void *memset(void *dest, int c, size_t count)
-{
-	size_t		i;
-	char		*buf1 = dest;
-
-	for(i=0; i<count; i++)
-		buf1[i] = c;
-
-	return dest;
-}
-
-char *strcpy(char *dest, char *src)
-{
-	char	*ret = dest;
-
-	while(*src)
-		*dest++ = *src++;
-	*dest = 0;
-
-	return ret;
-}
-
-char *strcat(char *dest, char *src)
-{
-	char	*ret = dest;
-
-	while(*dest)
-		dest++;
-
-	while(*src)
-		*dest++ = *src++;
-	*dest = 0;
-
-	return ret;
-}
-
-int strcmp(const char *string1, const char *string2)
-{
-	while(*string1 == *string2)
-	{
-		if(*string1 == 0)
-			return 0;
-
-		string1++;
-		string2++;
-	}
-
-	return *(unsigned const char *)string1 - *(unsigned const char *)(string2);
-}
-
-int stricmp(const char *string1, const char *string2)
-{
-	while(tolower(*string1) == tolower(*string2))
-	{
-		if(*string1 == 0)
-			return 0;
-
-		string1++;
-		string2++;
-	}
-
-	return (int)tolower(*string1) - (int)tolower(*string2);
-}
-
-char *fgets(char *string, int n, FILE *stream)
-{
-	int	i;
-
-	for(i=0; i<(n-1); i++)
-	{
-		if(feof(stream))
-		{
-			i++;
-			break;
-		}
-
-		ReadFile(stream, 1, string+i);
-
-		if(string[i] == '\n')
-		{
-			i++;
-			break;
-		}
-	}
-	string[i] = '\0';
-
-	return string;
-}
-
-int atoi(char *string)
-{
-	int		i, j;
-	int		base;
-	int		result = 0;
-	char	*str;
-
-	if((string[0] == '0') && (string[1] == 'x'))
-	{
-		base = 16;
-		str = string + 2;
-	}
-	else
-	{
-		base = 10;
-		str = string;
-	}
-
-	for(i=strlen(str)-1,j=1; i>=0; i--)
-	{
-		if((str[i] < '0') || (str[i] > '9'))
-			break;
-
-		if(i == (strlen(str)-1))
-			result += (str[i] - '0');
-		else
-		{
-			result += (str[i] - '0') * (j * base);
-			j *= base;
-		}
-	}
-
-	return result;
-}

freeldr/freeldr/stdlib.h

@@ -1,74 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef __STDLIB_H
-#define __STDLIB_H
-
-#include "fs.h"
-
-void	putchar(int ch);		// Implemented in asmcode.S
-void	clrscr(void);			// Implemented in asmcode.S
-int		kbhit(void);			// Implemented in asmcode.S
-int		getch(void);			// Implemented in asmcode.S
-void	gotoxy(int x, int y);	// Implemented in asmcode.S
-int		getyear(void);			// Implemented in asmcode.S
-int		getday(void);			// Implemented in asmcode.S
-int		getmonth(void);			// Implemented in asmcode.S
-int		gethour(void);			// Implemented in asmcode.S
-int		getminute(void);		// Implemented in asmcode.S
-int		getsecond(void);		// Implemented in asmcode.S
-void	hidecursor(void);		// Implemented in asmcode.S
-void	showcursor(void);		// Implemented in asmcode.S
-int		wherex(void);			// Implemented in asmcode.S
-int		wherey(void);			// Implemented in asmcode.S
-
-int		strlen(char *str);
-char	*strcpy(char *dest, char *src);
-char	*strcat(char *dest, char *src);
-int		strcmp(const char *string1, const char *string2);
-int		stricmp(const char *string1, const char *string2);
-char	*itoa(int value, char *string, int radix);
-int		toupper(int c);
-int		tolower(int c);
-int		memcmp(const void *buf1, const void *buf2, size_t count);
-void	*memcpy(void *dest, const void *src, size_t count);
-void	*memset(void *dest, int c, size_t count);
-char	*fgets(char *string, int n, FILE *stream);
-int		atoi(char *string);
-
-
-void	print(char *str);
-void	printf(char *fmt, ...);
-
-int		biosdisk(int cmd, int drive, int head, int track, int sector, int nsects, void *buffer); // Implemented in asmcode.S
-void	stop_floppy(void);			// Implemented in asmcode.S
-int		get_heads(int drive);		// Implemented in asmcode.S
-int		get_cylinders(int drive);	// Implemented in asmcode.S
-int		get_sectors(int drive);		// Implemented in asmcode.S
-
-/* Values for biosdisk() */
-#define _DISK_RESET		0	// Unimplemented
-#define _DISK_STATUS	1	// Unimplemented
-#define _DISK_READ		2	// Reads a sector into memory
-#define _DISK_WRITE		3	// Unimplemented
-#define _DISK_VERIFY	4	// Unimplemented
-#define _DISK_FORMAT	5	// Unimplemented
-
-
-#endif  // defined __STDLIB_H

freeldr/freeldr/tui.c

@@ -1,572 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-	
-#include "freeldr.h"
-#include "stdlib.h"
-#include "tui.h"
-
-int		nScreenWidth = 80;		// Screen Width
-int		nScreenHeight = 25;		// Screen Height
-
-char	cStatusBarFgColor = COLOR_BLACK;		// Status bar foreground color
-char	cStatusBarBgColor = COLOR_CYAN;			// Status bar background color
-char	cBackdropFgColor = COLOR_WHITE;			// Backdrop foreground color
-char	cBackdropBgColor = COLOR_BLUE;			// Backdrop background color
-char	cBackdropFillStyle = MEDIUM_FILL;		// Backdrop fill style
-char	cTitleBoxFgColor = COLOR_WHITE;			// Title box foreground color
-char	cTitleBoxBgColor = COLOR_RED;			// Title box background color
-char	cMessageBoxFgColor = COLOR_WHITE;		// Message box foreground color
-char	cMessageBoxBgColor = COLOR_BLUE;		// Message box background color
-char	cMenuFgColor = COLOR_WHITE;				// Menu foreground color
-char	cMenuBgColor = COLOR_BLUE;				// Menu background color
-char	cTextColor = COLOR_YELLOW;				// Normal text color
-char	cSelectedTextColor = COLOR_BLACK;		// Selected text color
-char	cSelectedTextBgColor = COLOR_GRAY;		// Selected text background color
-char	szTitleBoxTitleText[260] = "Boot Menu";	// Title box's title text
-
-char	szMessageBoxLineText[4000] = "";
-
-void DrawBackdrop(void)
-{
-	// Fill in the backdrop
-	FillArea(0, 0, nScreenWidth-1, nScreenHeight-1, cBackdropFillStyle, ATTR(cBackdropFgColor, cBackdropBgColor));
-
-	// Draw the title box
-	DrawBox(1, 1, nScreenWidth, 5, D_VERT, D_HORZ, TRUE, FALSE, ATTR(cTitleBoxFgColor, cTitleBoxBgColor));
-
-	// Draw version
-	DrawText(3, 2, VERSION, ATTR(cTitleBoxFgColor, cTitleBoxBgColor));
-	// Draw copyright
-	DrawText(3, 3, "by Brian Palmer", ATTR(cTitleBoxFgColor, cTitleBoxBgColor));
-	DrawText(3, 4, "<brianp@sginet.com>", ATTR(cTitleBoxFgColor, cTitleBoxBgColor));
-
-	// Draw help text
-	//DrawText(nScreenWidth-15, 4, /*"F1 for Help"*/"F8 for Options", ATTR(cTitleBoxFgColor, cTitleBoxBgColor));
-
-	// Draw title
-	DrawText((nScreenWidth/2)-(strlen(szTitleBoxTitleText)/2), 3, szTitleBoxTitleText, ATTR(cTitleBoxFgColor, cTitleBoxBgColor));
-
-	// Draw date
-	DrawText(nScreenWidth-9, 2, "01/02/03", ATTR(cTitleBoxFgColor, cTitleBoxBgColor));
-	// Draw time
-	DrawText(nScreenWidth-9, 3, "10:12:34", ATTR(cTitleBoxFgColor, cTitleBoxBgColor));
-
-	// Draw status bar
-	DrawStatusText("");
-
-	// Update the date & time
-	UpdateDateTime();
-}
-
-/*
- * FillArea()
- * This function assumes coordinates are zero-based
- */
-void FillArea(int nLeft, int nTop, int nRight, int nBottom, char cFillChar, char cAttr /* Color Attributes */)
-{
-	char	*screen = (char *)SCREEN_MEM;
-	int		i, j;
-
-	for(i=nTop; i<=nBottom; i++)
-	{
-		for(j=nLeft; j<=nRight; j++)
-		{
-			screen[((i*2)*nScreenWidth)+(j*2)] = cFillChar;
-			screen[((i*2)*nScreenWidth)+(j*2)+1] = cAttr;
-		}
-	}
-}
-
-/*
- * DrawShadow()
- * This function assumes coordinates are zero-based
- */
-void DrawShadow(int nLeft, int nTop, int nRight, int nBottom)
-{
-	char	*screen = (char *)SCREEN_MEM;
-	int		i;
-
-	// Shade the bottom of the area
-	if(nBottom < (nScreenHeight-1))
-	{
-		for(i=nLeft+2; i<=nRight; i++)
-			screen[(((nBottom+1)*2)*nScreenWidth)+(i*2)+1] = ATTR(COLOR_GRAY, COLOR_BLACK);
-	}
-
-	// Shade the right of the area
-	if(nRight < (nScreenWidth-1))
-	{
-		for(i=nTop+1; i<=nBottom; i++)
-			screen[((i*2)*nScreenWidth)+((nRight+1)*2)+1] = ATTR(COLOR_GRAY, COLOR_BLACK);
-	}
-	if(nRight+1 < (nScreenWidth-1))
-	{
-		for(i=nTop+1; i<=nBottom; i++)
-			screen[((i*2)*nScreenWidth)+((nRight+2)*2)+1] = ATTR(COLOR_GRAY, COLOR_BLACK);
-	}
-
-	// Shade the bottom right corner
-	if((nRight < (nScreenWidth-1)) && (nBottom < (nScreenHeight-1)))
-		screen[(((nBottom+1)*2)*nScreenWidth)+((nRight+1)*2)+1] = ATTR(COLOR_GRAY, COLOR_BLACK);
-	if((nRight+1 < (nScreenWidth-1)) && (nBottom < (nScreenHeight-1)))
-		screen[(((nBottom+1)*2)*nScreenWidth)+((nRight+2)*2)+1] = ATTR(COLOR_GRAY, COLOR_BLACK);
-}
-
-/*
- * DrawBox()
- * This function assumes coordinates are one-based
- */
-void DrawBox(int nLeft, int nTop, int nRight, int nBottom, int nVertStyle, int nHorzStyle, int bFill, int bShadow, char cAttr)
-{
-	char	cULCorner, cURCorner, cLLCorner, cLRCorner;
-	char	cHorz, cVert;
-
-	nLeft--;
-	nTop--;
-	nRight--;
-	nBottom--;
-
-	cHorz = nHorzStyle;
-	cVert = nVertStyle;
-	if(nHorzStyle == HORZ)
-	{
-		if(nVertStyle == VERT)
-		{
-			cULCorner = UL;
-			cURCorner = UR;
-			cLLCorner = LL;
-			cLRCorner = LR;
-		}
-		else // nVertStyle == D_VERT
-		{
-			cULCorner = VD_UL;
-			cURCorner = VD_UR;
-			cLLCorner = VD_LL;
-			cLRCorner = VD_LR;
-		}
-	}
-	else // nHorzStyle == D_HORZ
-	{
-		if(nVertStyle == VERT)
-		{
-			cULCorner = HD_UL;
-			cURCorner = HD_UR;
-			cLLCorner = HD_LL;
-			cLRCorner = HD_LR;
-		}
-		else // nVertStyle == D_VERT
-		{
-			cULCorner = D_UL;
-			cURCorner = D_UR;
-			cLLCorner = D_LL;
-			cLRCorner = D_LR;
-		}
-	}
-
-	// Fill in box background
-	if(bFill)
-		FillArea(nLeft, nTop, nRight, nBottom, ' ', cAttr);
-
-	// Fill in corners
-	FillArea(nLeft, nTop, nLeft, nTop, cULCorner, cAttr);
-	FillArea(nRight, nTop, nRight, nTop, cURCorner, cAttr);
-	FillArea(nLeft, nBottom, nLeft, nBottom, cLLCorner, cAttr);
-	FillArea(nRight, nBottom, nRight, nBottom, cLRCorner, cAttr);
-
-	// Fill in left line
-	FillArea(nLeft, nTop+1, nLeft, nBottom-1, cVert, cAttr);
-	// Fill in top line
-	FillArea(nLeft+1, nTop, nRight-1, nTop, cHorz, cAttr);
-	// Fill in right line
-	FillArea(nRight, nTop+1, nRight, nBottom-1, cVert, cAttr);
-	// Fill in bottom line
-	FillArea(nLeft+1, nBottom, nRight-1, nBottom, cHorz, cAttr);
-
-	if(bShadow)
-		DrawShadow(nLeft, nTop, nRight, nBottom);
-}
-
-/*
- * DrawText()
- * This function assumes coordinates are one-based
- */
-void DrawText(int nX, int nY, char *text, char cAttr)
-{
-	char	*screen = (char *)SCREEN_MEM;
-	int		i, j;
-
-	nX--;
-	nY--;
-
-	// Draw the text
-	for(i=nX, j=0; text[j]; i++,j++)
-	{
-		screen[((nY*2)*nScreenWidth)+(i*2)] = text[j];
-		screen[((nY*2)*nScreenWidth)+(i*2)+1] = cAttr;
-	}
-}
-
-void DrawStatusText(char *text)
-{
-	int	i;
-
-	DrawText(1, nScreenHeight, text, ATTR(cStatusBarFgColor, cStatusBarBgColor));
-
-	for(i=strlen(text)+1; i<=nScreenWidth; i++)
-		DrawText(i, nScreenHeight, " ", ATTR(cStatusBarFgColor, cStatusBarBgColor));
-}
-
-void UpdateDateTime(void)
-{
-	char	date[260];
-	char	time[260];
-	char	temp[20];
-	int		hour, minute, second, bPM=FALSE;
-
-	switch(getmonth())
-	{
-	case 1:
-		strcpy(date, "January ");
-		break;
-	case 2:
-		strcpy(date, "February ");
-		break;
-	case 3:
-		strcpy(date, "March ");
-		break;
-	case 4:
-		strcpy(date, "April ");
-		break;
-	case 5:
-		strcpy(date, "May ");
-		break;
-	case 6:
-		strcpy(date, "June ");
-		break;
-	case 7:
-		strcpy(date, "July ");
-		break;
-	case 8:
-		strcpy(date, "August ");
-		break;
-	case 9:
-		strcpy(date, "September ");
-		break;
-	case 10:
-		strcpy(date, "October ");
-		break;
-	case 11:
-		strcpy(date, "November ");
-		break;
-	case 12:
-		strcpy(date, "December ");
-		break;
-	}
-	itoa(getday(), temp, 10);
-	if((getday() == 1) || (getday() == 21) || (getday() == 31))
-		strcat(temp, "st");
-	else if((getday() == 2) || (getday() == 22))
-		strcat(temp, "nd");
-	else if((getday() == 3) || (getday() == 23))
-		strcat(temp, "rd");
-	else
-		strcat(temp, "th");
-
-	strcat(date, temp);
-	strcat(date, " ");
-	itoa(getyear(), temp, 10);
-	strcat(date, temp);
-
-	// Draw the date
-	DrawText(nScreenWidth-strlen(date)-1, 2, date, ATTR(cTitleBoxFgColor, cTitleBoxBgColor));
-
-	hour = gethour();
-	if(hour > 12)
-	{
-		hour -= 12;
-		bPM = TRUE;
-	}
-	if (hour == 0)
-		hour = 12;
-	minute = getminute();
-	second = getsecond();
-	itoa(hour, temp, 10);
-	strcpy(time, "    ");
-	strcat(time, temp);
-	strcat(time, ":");
-	itoa(minute, temp, 10);
-	if(minute < 10)
-		strcat(time, "0");
-	strcat(time, temp);
-	strcat(time, ":");
-	itoa(second, temp, 10);
-	if(second < 10)
-		strcat(time, "0");
-	strcat(time, temp);
-	if(bPM)
-		strcat(time, " PM");
-	else
-		strcat(time, " AM");
-
-	// Draw the time
-	DrawText(nScreenWidth-strlen(time)-1, 3, time, ATTR(cTitleBoxFgColor, cTitleBoxBgColor));
-}
-
-void SaveScreen(char *buffer)
-{
-	char	*screen = (char *)SCREEN_MEM;
-	int		i;
-
-	for(i=0; i < (nScreenWidth * nScreenHeight * 2); i++)
-		buffer[i] = screen[i];
-}
-
-void RestoreScreen(char *buffer)
-{
-	char	*screen = (char *)SCREEN_MEM;
-	int		i;
-
-	for(i=0; i < (nScreenWidth * nScreenHeight * 2); i++)
-		screen[i] = buffer[i];
-}
-
-void MessageBox(char *text)
-{
-	int		width = 8;
-	int		height = 1;
-	int		curline = 0;
-	int		i , j, k;
-	int		x1, x2, y1, y2;
-	char	savebuffer[8000];
-	char	temp[260];
-	char	key;
-
-	SaveScreen(savebuffer);
-	strcat(szMessageBoxLineText, text);
-
-	// Find the height
-	for(i=0; i<strlen(szMessageBoxLineText); i++)
-	{
-		if(szMessageBoxLineText[i] == '\n')
-			height++;
-	}
-
-	// Find the width
-	for(i=0,j=0,k=0; i<height; i++)
-	{
-		while((szMessageBoxLineText[j] != '\n') && (szMessageBoxLineText[j] != 0))
-		{
-			j++;
-			k++;
-		}
-
-		if(k > width)
-			width = k;
-
-		k = 0;
-		j++;
-	}
-
-	// Calculate box area
-	x1 = (nScreenWidth - (width+2))/2;
-	x2 = x1 + width + 3;
-	y1 = ((nScreenHeight - height - 2)/2) + 1;
-	y2 = y1 + height + 4;
-
-	// Draw the box
-	DrawBox(x1, y1, x2, y2, D_VERT, D_HORZ, TRUE, TRUE, ATTR(cMessageBoxFgColor, cMessageBoxBgColor));
-
-	// Draw the text
-	for(i=0,j=0; i<strlen(szMessageBoxLineText)+1; i++)
-	{
-		if((szMessageBoxLineText[i] == '\n') || (szMessageBoxLineText[i] == 0))
-		{
-			temp[j] = 0;
-			j = 0;
-			DrawText(x1+2, y1+1+curline, temp, ATTR(cMessageBoxFgColor, cMessageBoxBgColor));
-			curline++;
-		}
-		else
-			temp[j++] = szMessageBoxLineText[i];
-	}
-
-	// Draw OK button
-	strcpy(temp, "   OK   ");
-	DrawText(x1+((x2-x1)/2)-3, y2-2, temp, ATTR(COLOR_BLACK, COLOR_GRAY));
-
-	for(;;)
-	{
-		if(kbhit())
-		{
-			key = getch();
-			if(key == KEY_EXTENDED)
-				key = getch();
-
-			if(key == KEY_ENTER)
-				break;
-			else if(key == KEY_SPACE)
-				break;
-		}
-
-		UpdateDateTime();
-	}
-
-	RestoreScreen(savebuffer);
-	UpdateDateTime();
-	strcpy(szMessageBoxLineText, "");
-}
-
-void MessageLine(char *text)
-{
-	strcat(szMessageBoxLineText, text);
-	strcat(szMessageBoxLineText, "\n");
-}
-
-BOOL IsValidColor(char *color)
-{
-	if(stricmp(color, "Black") == 0)
-		return TRUE;
-	else if(stricmp(color, "Blue") == 0)
-		return TRUE;
-	else if(stricmp(color, "Green") == 0)
-		return TRUE;
-	else if(stricmp(color, "Cyan") == 0)
-		return TRUE;
-	else if(stricmp(color, "Red") == 0)
-		return TRUE;
-	else if(stricmp(color, "Magenta") == 0)
-		return TRUE;
-	else if(stricmp(color, "Brown") == 0)
-		return TRUE;
-	else if(stricmp(color, "Gray") == 0)
-		return TRUE;
-	else if(stricmp(color, "DarkGray") == 0)
-		return TRUE;
-	else if(stricmp(color, "LightBlue") == 0)
-		return TRUE;
-	else if(stricmp(color, "LightGreen") == 0)
-		return TRUE;
-	else if(stricmp(color, "LightCyan") == 0)
-		return TRUE;
-	else if(stricmp(color, "LightRed") == 0)
-		return TRUE;
-	else if(stricmp(color, "LightMagenta") == 0)
-		return TRUE;
-	else if(stricmp(color, "Yellow") == 0)
-		return TRUE;
-	else if(stricmp(color, "White") == 0)
-		return TRUE;
-
-	return FALSE;
-}
-
-char TextToColor(char *color)
-{
-	if(stricmp(color, "Black") == 0)
-		return COLOR_BLACK;
-	else if(stricmp(color, "Blue") == 0)
-		return COLOR_BLUE;
-	else if(stricmp(color, "Green") == 0)
-		return COLOR_GREEN;
-	else if(stricmp(color, "Cyan") == 0)
-		return COLOR_CYAN;
-	else if(stricmp(color, "Red") == 0)
-		return COLOR_RED;
-	else if(stricmp(color, "Magenta") == 0)
-		return COLOR_MAGENTA;
-	else if(stricmp(color, "Brown") == 0)
-		return COLOR_BROWN;
-	else if(stricmp(color, "Gray") == 0)
-		return COLOR_GRAY;
-	else if(stricmp(color, "DarkGray") == 0)
-		return COLOR_DARKGRAY;
-	else if(stricmp(color, "LightBlue") == 0)
-		return COLOR_LIGHTBLUE;
-	else if(stricmp(color, "LightGreen") == 0)
-		return COLOR_LIGHTGREEN;
-	else if(stricmp(color, "LightCyan") == 0)
-		return COLOR_LIGHTCYAN;
-	else if(stricmp(color, "LightRed") == 0)
-		return COLOR_LIGHTRED;
-	else if(stricmp(color, "LightMagenta") == 0)
-		return COLOR_LIGHTMAGENTA;
-	else if(stricmp(color, "Yellow") == 0)
-		return COLOR_YELLOW;
-	else if(stricmp(color, "White") == 0)
-		return COLOR_WHITE;
-
-	return COLOR_BLACK;
-}
-
-BOOL IsValidFillStyle(char *fill)
-{
-	if(stricmp(fill, "Light") == 0)
-		return TRUE;
-	else if(stricmp(fill, "Medium") == 0)
-		return TRUE;
-	else if(stricmp(fill, "Dark") == 0)
-		return TRUE;
-
-	return FALSE;
-}
-
-char TextToFillStyle(char *fill)
-{
-	if(stricmp(fill, "Light") == 0)
-		return LIGHT_FILL;
-	else if(stricmp(fill, "Medium") == 0)
-		return MEDIUM_FILL;
-	else if(stricmp(fill, "Dark") == 0)
-		return DARK_FILL;
-
-	return LIGHT_FILL;
-}
-
-void DrawProgressBar(int nPos)
-{
-	int		left, top, right, bottom;
-	int		width = 50; // Allow for 50 "bars"
-	int		height = 2;
-	int		i;
-
-	if(nPos > 100)
-		nPos = 100;
-
-	left = (nScreenWidth - width - 4) / 2;
-	right = left + width + 3;
-	top = (nScreenHeight - height - 2) / 2;
-	top += 4;
-	bottom = top + height + 1;
-
-	// Draw the box
-	DrawBox(left, top, right, bottom, VERT, HORZ, TRUE, TRUE, ATTR(cMenuFgColor, cMenuBgColor));
-
-	// Draw the "Loading..." text
-	DrawText(70/2, top+1, "Loading...", ATTR(cTextColor, cMenuBgColor));
-
-	// Draw the percent complete
-	for(i=0; i<(nPos/2); i++)
-		DrawText(left+2+i, top+2, "\xDB", ATTR(cTextColor, cMenuBgColor));
-
-	// Draw the rest
-	for(; i<50; i++)
-		DrawText(left+2+i, top+2, "\xB2", ATTR(cTextColor, cMenuBgColor));
-
-	UpdateDateTime();
-}

freeldr/freeldr/tui.h

@@ -1,162 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1999, 2000  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef __TUI_H
-#define __TUI_H
-
-#define	SCREEN_MEM	0xB8000
-
-extern	int		nScreenWidth;		// Screen Width
-extern	int		nScreenHeight;		// Screen Height
-
-extern	char	cStatusBarFgColor;			// Status bar foreground color
-extern	char	cStatusBarBgColor;			// Status bar background color
-extern	char	cBackdropFgColor;			// Backdrop foreground color
-extern	char	cBackdropBgColor;			// Backdrop background color
-extern	char	cBackdropFillStyle;			// Backdrop fill style
-extern	char	cTitleBoxFgColor;			// Title box foreground color
-extern	char	cTitleBoxBgColor;			// Title box background color
-extern	char	cMessageBoxFgColor;			// Message box foreground color
-extern	char	cMessageBoxBgColor;			// Message box background color
-extern	char	cMenuFgColor;				// Menu foreground color
-extern	char	cMenuBgColor;				// Menu background color
-extern	char	cTextColor;					// Normal text color
-extern	char	cSelectedTextColor;			// Selected text color
-extern	char	cSelectedTextBgColor;		// Selected text background color
-extern	char	szTitleBoxTitleText[260];	// Title box's title text
-
-// Fills the entire screen with a backdrop
-void	DrawBackdrop(void);
-// Fills the area specified with cFillChar and cAttr
-void	FillArea(int nLeft, int nTop, int nRight, int nBottom, char cFillChar, char cAttr /* Color Attributes */);
-// Draws a shadow on the bottom and right sides of the area specified
-void	DrawShadow(int nLeft, int nTop, int nRight, int nBottom);
-// Draws a box around the area specified
-void	DrawBox(int nLeft, int nTop, int nRight, int nBottom, int nVertStyle, int nHorzStyle, int bFill, int bShadow, char cAttr);
-// Draws text at coordinates specified
-void	DrawText(int nX, int nY, char *text, char cAttr);
-// Draws text at the very bottom line on the screen
-void	DrawStatusText(char *text);
-// Updates the date and time
-void	UpdateDateTime(void);
-// Saves the screen so that it can be restored later
-void	SaveScreen(char *buffer);
-// Restores the screen from a previous save
-void	RestoreScreen(char *buffer);
-// Displays a message box on the screen with an ok button
-void	MessageBox(char *text);
-// Adds a line of text to the message box buffer
-void	MessageLine(char *text);
-// Returns true if color is valid
-BOOL	IsValidColor(char *color);
-// Converts the text color into it's equivalent color value
-char	TextToColor(char *color);
-// Returns true if fill is valid
-BOOL	IsValidFillStyle(char *fill);
-// Converts the text fill into it's equivalent fill value
-char	TextToFillStyle(char *fill);
-// Draws the progress bar showing nPos percent filled
-void	DrawProgressBar(int nPos);
-
-/*
- * Combines the foreground and background colors into a single attribute byte
- */
-#define	ATTR(cFore, cBack)	((cBack << 4)|cFore)
-
-/*
- * Fill styles for DrawBackdrop()
- */
-#define LIGHT_FILL			0xB0
-#define MEDIUM_FILL			0xB1
-#define DARK_FILL			0xB2
-
-/*
- * Screen colors
- */
-#define COLOR_BLACK			0
-#define COLOR_BLUE			1
-#define COLOR_GREEN			2
-#define COLOR_CYAN			3
-#define COLOR_RED			4
-#define COLOR_MAGENTA		5
-#define COLOR_BROWN			6
-#define COLOR_GRAY			7
-
-#define COLOR_DARKGRAY		8
-#define COLOR_LIGHTBLUE		9
-#define COLOR_LIGHTGREEN	10
-#define COLOR_LIGHTCYAN		11
-#define COLOR_LIGHTRED		12
-#define COLOR_LIGHTMAGENTA	13
-#define COLOR_YELLOW		14
-#define COLOR_WHITE			15
-
-/* Add COLOR_BLINK to a background to cause blinking */
-#define COLOR_BLINK			8
-
-/*
- * Defines for IBM box drawing characters
- */
-#define HORZ	(0xc4)  /* Single horizontal line */
-#define D_HORZ	(0xcd)  /* Double horizontal line.*/
-#define VERT    (0xb3)  /* Single vertical line   */
-#define D_VERT  (0xba)  /* Double vertical line.  */
-
-/* Definitions for corners, depending on HORIZ and VERT */
-#define UL		(0xda)
-#define UR		(0xbf)  /* HORZ and VERT */
-#define LL		(0xc0)
-#define LR		(0xd9)
-
-#define D_UL	(0xc9)
-#define D_UR	(0xbb)  /* D_HORZ and D_VERT */
-#define D_LL	(0xc8)
-#define D_LR	(0xbc)
-
-#define HD_UL	(0xd5)
-#define HD_UR	(0xb8)  /* D_HORZ and VERT */
-#define HD_LL	(0xd4)
-#define HD_LR	(0xbe)
-
-#define VD_UL	(0xd6)
-#define VD_UR	(0xb7)  /* HORZ and D_VERT */
-#define VD_LL	(0xd3)
-#define VD_LR	(0xbd)
-
-// Key codes
-#define KEY_EXTENDED	0x00
-#define	KEY_ENTER		0x0D
-#define KEY_SPACE		0x20
-#define KEY_UP			0x48
-#define KEY_DOWN		0x50
-#define KEY_LEFT		0x4B
-#define KEY_RIGHT		0x4D
-#define KEY_ESC			0x1B
-#define KEY_F1			0x3B
-#define KEY_F2			0x3C
-#define KEY_F3			0x3D
-#define KEY_F4			0x3E
-#define KEY_F5			0x3F
-#define KEY_F6			0x40
-#define KEY_F7			0x41
-#define KEY_F8			0x42
-#define KEY_F9			0x43
-#define KEY_F10			0x44
-
-#endif // #defined __TUI_H

freeldr/install.bat

@@ -1,5 +0,0 @@
-cd bootsect
-call install.bat
-cd..
-copy freeldr.sys a:\
-copy freeldr.ini a:\

freeldr/notes.txt

@@ -1,18 +0,0 @@
-FreeLoader notes
-
-To build FreeLoader you will need DJGPP because Mingw32 doesn't support 16-bit code
-FreeLoader does not currently work with extended partitions.
-Linux booting support needs to be added.
-ext2 filesystem support needs to be added.
-
-Current memory layout:
-
-0000:0000 - 0000:0FFF: Interrupt vector table & BIOS data
-0000:1000 - 0000:6FFF: Real mode stack area
-0000:7000 - xxxx:xxxx: FreeLoader program & data area
-xxxx:xxxx - 6000:0000: Protected mode stack area & heap
-6000:0000 - 6000:C000: Filesystem data buffer
-6000:C000 - 7000:0000: FREELDR.INI loaded here
-7000:0000 - 7000:FFFF: scratch area for any function's use (ie sector buffer for biosdisk()) - can be overwritten by any function
-8000:0000 - 9000:FFFF: fat table entry buffer
-A000:0000 - FFFF:FFFF: reserved

reactos/boot.bat

@@ -0,0 +1 @@
+loaders\dos\loadros ntoskrnl\kimage.bin %1 %2 %3 %4

reactos/copying_rex

@@ -1,3 +1,4 @@
+
 		    GNU GENERAL PUBLIC LICENSE
 		       Version 2, June 1991
 

reactos/doc/api.txt

@@ -0,0 +1,140 @@
+This file attempts to document the functions made publically available by
+the various subsystems.
+
+* Formatted I/O operations *
+
+NAME: int vsprintf(char *buf, const char *fmt, va_list args)
+NAME: int sprintf(char* buf, const char* fmt, ...)
+WHERE: internal/kernel.h
+FUNCTION: The same as the standard c library versions
+
+* PIO operations *
+
+NAME: in[b/w/l](port)
+WHERE: internal/io.h
+FUNCTION: Read an IO port of the specified size (byte/word or long)
+RETURNS: The value read
+
+NAME: out[b/w/l](port,val)
+WHERE: internal/io.h
+FUNCTION: Write an IO port of the specified size (byte/word or long)
+
+NAME: in_p[b/w/l](port)
+WHERE: internal/io.h
+FUNCTION: Read an IO port of the specified size (byte/word or long) with
+        a pause
+RETURNS: The value read
+
+NAME: out_p[b/w/l](port,val)
+WHERE: internal/io.h
+FUNCTION: Write an IO port of the specified size (byte/word or long) with
+        a pause
+
+* Bit operations *
+
+NAME: int set_bit(int nr, void* addr)
+NAME: int clear_bit(int nr, void* addr)
+NAME: int change_bit(int nr, void* addr)
+WHERE: internal/bitops.h>
+FUNCTION: Operate on a bit in the word pointed to by addr
+RETURN: 0 if the bit was cleared before the operations
+        non-zero otherwise
+
+* Debugging functions *
+
+NAME: DPRINT(fmt,....)
+WHERE: internal/debug.h
+FUNCTION: Outputs a string to the console if NDEBUG isn't defined before
+including internal/debug.h, a NOP otherwise
+ARGUMENTS: The same as printf
+
+NAME: printk
+WHERE: internal/kernel.h
+FUNCTION: Outputs a string to the console
+ARGUMENTS: The same as printf
+
+* Memory managment functions *
+
+NAME: unsigned int physical_to_linear(unsigned int paddr)
+WHERE: hal/page.h
+FUNCTION: Converts a physical address to a linear one
+RECEIVES:
+        paddr = the physical address to convert
+RETURNS: A virtual address where the memory at that physical address can be 
+accessed
+
+NAME: void* ExAllocatePool(unsigned int size, unsigned int type = 0);
+WHERE: internal/pool.h
+FUNCTION: Allocates a block of memory
+RECEIVES:
+        size = the size of the block to allocate
+        type = will be whether to allocate pagable memory
+RETURNS: The address of the block
+NOTE: This isn't interrupt safe
+
+NAME: void ExFreePool(void* block)
+WHERE: internal/pool.h
+FUNCTION: Frees a block of memory
+
+NAME: void free_page(unsigned int physical_base, unsigned int nr = 1)
+WHERE: internal/mm.h
+FUNCTION: Adds a continuous range of physical memory to the free list
+
+NAME: unsigned int get_free_page(void)
+WHERE: internal/mm.h
+FUNCTION: Gets a free page
+RETURNS: Its physical address
+
+NAME: unsigned int get_page_physical_address(unsigned int vaddr)
+WHERE: internal/mm.h
+FUNCTION: Gets the physical address of a page
+
+NAME: void mark_page_not_writable(unsigned int vaddr)
+WHERE: internal/mm.h
+FUNCTION: Prevent writing the page
+
+* DMA functions *
+
+NAME: unsigned int get_dma_page(unsigned int max_address)
+WHERE: internal/mm.h
+FUNCTION: Gets a page with a restricted physical address i.e. suitable for
+          dma
+RETURNS: The physical address of the page
+
+NAME: void disable_dma(unsigned int dmanr)
+WHERE:    internal/dma.h
+FUNCTION: Disables the specified dma channel
+
+NAME: void enable_dma(unsigned int dmanr)
+WHERE:    internal/dma.h
+FUNCTION: Enables the specified dma channel
+
+NAME: void clear_dma_ff(unsigned int dmanr)
+WHERE: internal/dma.h
+FUNCTION: Clear the dma flip-flop
+
+NAME: void set_dma_mode(unsigned int dmanr, char mode)
+WHERE: internal/dma.h
+FUNCTION: Sets the type of dma transfer
+
+NAME: void set_dma_page(unsigned int dmanr, char pagenr)
+WHERE: internal/dma.h
+FUNCTION: Set only the page register bits of the transfer address
+
+NAME: void set_dma_addr(unsigned int dmanr, unsigned int a)
+WHERE: internal/dma.h
+FUNCTION: Set the transfer address for dma
+NOTE: Assumes flip-flop is clear
+
+NAME: void set_dma_count(unsigned int dmanr, unsigned int count)
+WHERE: internal/dma.h
+FUNCTION: Sets the size of the transfer
+ARGUMENTS:
+        count = the number of bytes to transfer
+NOTE: Count must be even for channels 5-7
+
+NAME: int get_dma_residue(unsigned int dmanr)
+WHERE: internal/dma.h
+FUNCTION: Gets the residue remaining after a dma transfer on the channel
+
+

reactos/doc/buglist

@@ -0,0 +1,2 @@
+* Kernel bugs not fixed
+

reactos/doc/ddkfuncs.txt

@@ -0,0 +1,27 @@
+This is a list of the functions documented in the ddk that have been
+implemented
+
+IoAllocateController
+IoFreeController
+IoCreateController
+IoDeleteController
+IoStartNextPacket
+IoStartNextPacketByKey
+IoStartPacket
+IoSizeOfIrp
+IoMarkIrpPending
+IoFreeIrp
+IoConnectInterrupt
+IoDisconnectInterrupt
+IoGetCurrentIrpStackLocation
+IoGetNextIrpStackLocation
+IoRequestDpc
+IoInitializeDpc
+IoInitializeTimer
+IoStartTimer
+IoStopTimer
+
+Partially implemented
+
+IoCreateDevice
+IoCallDriver

reactos/doc/debug.txt

@@ -0,0 +1,19 @@
+Some notes on debugging the ReactOS kernel
+------------------------------------------
+
+* Interpreting crashes
+
+If the kernel causes a fatal cpu fault then it will print out a message and
+halt. This message contains important information for debugging the problem,
+look for these lines
+
+Exception: xx(yy)
+CS:EIP 20:zzzzzzzzzzzz
+
+Here xx is the type of error, usually either 14 or 13 and yy is the error
+code. Generally error codes 13 and 14 both mean the kernel tried to access
+some memory in an invalid way. zzzzzzzzz is the address of the erronous
+instruction.
+
+* Debugging with bochs
+

reactos/doc/faq.txt

@@ -0,0 +1,114 @@
+Kernel Development FAQ (for v0.0.7)
+
+This attempts to answer some of the common questions people developing for
+the kernel might want to ask (or at least what I think they should ask).
+Obviously I can only detail those parts which I have written so other
+developers please fill in the gaps.
+
+Q: What is this, what are you people, what's going on
+A: This is the ReactOS, an operating system intended as a clone of windows
+NT. See the project website (http://www.sid-dis.com/reactos/) for more details.
+
+Q: Why ReactOS
+A: To condemn Bill Gates to penury.
+
+Q: What do I need to compile the kernel
+A: DJGPP, get it from http://www.delorie.com/djgpp
+
+Q: How do I compile the kernel
+A: Unpack the zip. It is important not to install the kernel in the same
+directory as a previous version, this has caused a bit of confusion in the 
+past. Edit the makefile in the top level directory, in particular select the
+correct host to build from. Then run make in the top directory
+
+Q: What files are created when I make the kernel
+A: The following files are created in the kernel directory
+        kimage = the kernel as a coff executable
+        kimage.bin = the kernel as a raw binary image
+        kernel.sym = a list of the kernel symbols
+
+Q: How do I load the kernel
+A: Run the boot.bat batch file.
+
+Q: Does it boot from disk
+A: Not at the moment.
+
+Q: When I run the kernel it crashes
+A: The kernel (at the moment) can only be loaded from a clean system. That
+is one without EMM386 or any version of windows loaded. A quick way to
+ensure this (if you have windows 95) is to set the program to run in msdos
+mode and specify an empty config.sys and autoexec.bat. See the windows help
+for more information.
+
+If you do that and the problem persists then contact the kernel team
+(ros-kernel@sid-dis.com) as it is probably a bug in the kernel 
+
+Q6: How do I load a module with the kernel
+A: Add the names of any modules to be loaded to the command line of boot.bat.
+
+Q7: I want to add code to the kernel, how do I get it to be compiled
+A: You will need to edit the Makefile in kernel directory. There should be
+a statement like this 
+
+    OBJECTS = hal/head.o hal/exp.o kernel/vsprintf.o \
+              ....
+	      kernel/irqhand.o hal/page.o mm/virtual.o kernel/error.o \
+	      kernel/exports.o kernel/module.o
+
+Add the name of the object file (the file produced when your code is
+compiled) to the end of the statement (in this case after kernel/module.o).
+If you need to go onto a new line then add a slash to the end of the
+previous line. It is also very important to use an editor which preserves
+tabs.
+
+Q8: I want to add code to the kernel, how do I make it official
+A: Contact the kernel mailing list ros-kernel@sid-dis.com or our coordinator
+dwinkley@whitworth.edu. If it is for a specific section then the kernel
+website (http://www.geocities.com/SiliconValley/Peaks/1957) has a list of
+those working on individual areas, you might what to contact one of them
+instead.
+
+Q9: What header files should I use
+A: Don't include the usual DJGPP headers like stdio.h unless you are using
+something compiler based like stdargs.h. To use the DJGPP headers requires
+linking with libc which is useless in kernel mode.
+
+All the header files are in the top-level include directory which is laid
+out like this
+         include  = general win32 api declarations
+	 include/internal = private kernel headers
+	 include/internal/hal = HAL headers
+	 include/ddk = header files with declarations for modules
+
+There should be a file called api.txt which documents all of the functions
+(and which header files they need).
+
+Q11: I want to export my function for modules to use, how do I do that
+A: Add the function to the list in kernel/exports.lst, then remake the
+kernel. Note the function must be declared as extern "C".
+
+Q12: I want to make my functions part of the kernel interface to user mode,
+A: That section isn't finished yet, though it will probably mean adding a
+pointer to the function and the size of its parameters to a internal table
+somewhere.
+
+Q14: I want to write a module, what are the guidelines
+A: See modules.txt in this directory
+
+Q15: I want to write an ISR (interrupt service routine)
+A: See irq.txt in this directory
+
+Q16: I want to use DMA
+A: Firstly this answer covers only DMA via the dma chips *not*
+busmaster DMA.
+
+To program the dma chip use the functions in internal/dma.h (look in api.txt
+for details). PC DMA can only go to memory with a physical address below
+1mb (or 16mb on some systems), use the get_dma_page to allocate this kind
+of memory.
+
+Q17: You haven't answered my question
+A: Send your questions to ros-kernel@sid-dis.com
+
+
+- David Welch (welch@mcmail.com)

reactos/doc/internal/mm.txt

@@ -0,0 +1,10 @@
+This document describes the implementation of the memory managment
+
+
+* ReactOS memory map
+
+0x00000000 - 0xc0000000 = User memory 
+0xc0000000 - 0xd0000000 = Kernel memory 
+0xd0000000 - 0xffffffff = Identify map of physical memory
+
+* 

reactos/doc/internal/readme.txt

@@ -0,0 +1,2 @@
+This contains documentation describing the internals of the various kernel
+subsystems and a few other useful bits of information. 

reactos/doc/irq.txt

@@ -0,0 +1,135 @@
+** Introduction
+
+This attempts to document the ReactOS irq handling. As of v0.0.8 this has 
+changed to be more nt like, I will attempt to summarize the new
+implementation for those unavailable with nt device driver writing. Note,
+ReactOS doesn't have an exact implementation but the omissions are, except
+where noted, not user visible.
+
+** Steps in grabbing an irq vector
+
+* Call HalConnectInterrupt
+
+PROTOTYPE:
+
+ULONG HalGetInterruptVector(INTERFACE_TYPE InterfaceType,
+                            ULONG BusNumber,
+			    ULONG BusInterruptLevel,
+			    ULONG BusInterruptVector,
+			    OUT PKIRQL Irql,
+			    OUT PKAFFINITY Affinity)
+
+PURPOSE: 
+
+Translates a bus dependant interrupt vector to a system vector
+
+ARGUMENTS:
+
+      InterfaceType = Type of bus to which the device to receive interrupts 
+                      from is connected to. Currently only 'Internal' is
+		      recognized
+      BusNumber = Number of the bus the device is connected to 
+                  (currently ignored)
+      BusInterruptLevel = Bus specific interrupt level (currently ignored)
+      BusInterruptVector = Bus specific vector. Currently this is the same
+                           as the normal vector (09 is the keyboard vector
+                           for example)
+      Irql = On return contains the DIRQL for the vector
+      Affinity = On return contains the affinity mask for the vector
+                 (currently unimplemented)
+		 
+RETURNS:
+     The system mapped vector
+			    
+* Call IoConnectInterrupt
+
+PROTOTYPE:
+
+NTSTATUS IoConnectInterrupt(OUT PKINTERRUPT* InterruptObject,
+                            PKSERVICE_ROUTINE ServiceRoutine,
+			    PVOID ServiceContext,
+			    PKSPIN_LOCK SpinLock,
+			    ULONG Vector,
+			    KIRQL Irql,
+			    KIRQL SynchronizeIrql,
+			    KINTERRUPT_MODE InterruptMode,
+			    BOOLEAN ShareVector,
+			    KAFFINITY ProcessorEnableMask,
+			    BOOLEAN FloatingSave)
+
+PURPOSE:   
+
+Connect a service routine to an interrupt vector
+
+ARGUMENTS:
+
+         InterruptObject = Points to an object describes the interrupt on
+	                   return
+	 ServiceRoutine = Function to be called when the device interrupts
+	 ServiceContext = Parameters to be passed to the service routine
+	 SpinLock = Should be NULL
+	 Vector = System mapped vector returned from HalGetInterruptVector
+	 Irql = DIRQL returned from HalGetInterruptVector
+	 SynchronizeIrql = Should be the same as Irql
+	 InterruptMode = Device interrupt type (currently ignored)
+	 ShareVector = True if the interrupt vector can shared
+	 ProcessorEnableMask = Currently ignored
+	 FloatingSave = Should be false
+	 
+RETURNS: Status
+
+* Sample code for snarfing an interrupt vector
+
+
+      void grab_my_irq()
+      {
+            ULONG MappedIrq;
+	    KIRQL Dirql;
+	    KAFFINITY Affinity;
+	    PKINTERRUPT IrqObject;
+	    
+	    MappedIrq = HalGetInterruptVector(Internal,
+	                                      0,
+					      0,
+					      MY_VECTOR,
+					      &Dirql,
+					      &Affinity);
+            IoConnectInterrupt(&IrqObject,
+	                       my_irq_service_routine,
+			       my_context,
+			       NULL,
+			       MappedIrq,
+			       Dirql,
+			       Dirql,
+			       0, 
+			       FALSE,    // Not sharable
+			       Affinity, 
+			       FALSE);
+      }
+      
+** Designing an interrupt service routine
+
+An interrupt service routine should have the following prototype
+
+      BOOLEAN my_irq_service_routine(PKINTERRUPT Interrupt, 
+                                     PVOID ServiceContext);
+				     
+ARGUMENTS:
+         
+	 Interrupt = The same as the object returned from the 
+	             IoConnectInterrupt
+	 ServiceContext = A user defined parameters 
+	                  (passed to IoConnectInterrupt)
+			  
+RETURNS:
+
+         True if it handled the interrupt, false if it should be passed onto
+	 other devices sharing the same vector
+	 
+NOTES:
+
+         While an isr is executing all devices of a lower or equal priority
+	 can't interrupt. For this reason it is important that an isr 
+	 should complete in a short an interval as possible. The set of 
+	 routines an isr can call is also restricted. 
+	 

reactos/doc/irql.txt

@@ -0,0 +1,21 @@
+This document describes the state of a uniprocessor PC at each of the IRQ
+levels supported by the ReactOS kernel
+
+PASSIVE_LEVEL:    IF bit clear in the processor flags
+                  All irqs umasked at the PIC
+	
+APC_LEVEL: Unknown
+WAKE_LEVEL: Unknown
+	
+DISPATCH_LEVEL:   IF bit clear in the processor flags
+                  All irqs umasked at the PIC
+		  Thread dispatching disabled
+		  
+DIRQL (Device specific IRQ level):     
+          IF bit clear in the processor flags
+          Device's irq and all lower priority irqs masked at the PIC
+	  Thread dispatching disabled
+                                
+HIGH_LEVEL:       IF bit set in the processor flags
+                  All irqs masked at the PIC
+		  Thread dispatching disabled

reactos/doc/modules.txt

@@ -0,0 +1,33 @@
+** Introduction
+
+This is (an incomplete) guide to writing device drivers (and other kernel
+extensions) for ReactOS.
+
+** Setting up the build environment
+
+Create a new subdirectory in the modules directory and copy one of the
+existing module makefiles into it. Customize the makefile to compile the
+source files for the module. Note: generally it is not necessary to specify
+the compiler or compiler flags to use.
+
+** Initializing a module
+
+On loading the kernel will call the module function
+
+PROTOTYPE:
+
+       NTSTATUS ModuleEntry(PDRIVER_OBJECT DriverObject, 
+                            PUNICODE_STRING RegistryPath)
+
+PURPOSE:
+
+       Initializing the module
+       
+ARGUMENTS:
+
+       DriverObject = Pointer to an object describing the driver
+       RegistryPath = Currently NULL
+ 
+RETURNS:
+
+       STATUS_SUCCESS = If the module initialized successfully

reactos/doc/todo

@@ -0,0 +1,31 @@
+* Kernel things implemented [exceptions in brackets]
+
+Spinlocks [Uniprocessor only]
+IRQ levels [Not APC_LEVEL or WAKE_LEVEL, uniprocessor only]
+ISRs [Partial, uniprocessor only]
+Timers [Untested]
+DPCs [Untested]
+Objects [Partial]
+Namespace [Partial]
+Handle tables [One process only]
+Threads [Some initial work]
+RTL list functions [All except sequenced lists]
+Zones [Untested]
+Memory pool [Working but semantics partially incompatiable]
+Device objects [Some but no support for layering]
+IRP [Partial]
+Memory sections [Partial, no file mappings]
+PCI interface [Probes but no support]
+CreateFile API [Device only]
+ReadFile/WriteFile API [Device only]
+MDL functions [Untested]
+
+* Kernel things unimplemented (partial)
+
+Add support for source level debugging to Bochs
+Support for remote debugging
+Process managment
+Dispatcher objects (Mutex, Semaphore etc)
+Investigate user and kernel mode APCs
+Asynchronous I/O
+Optimization

reactos/doc/wstring.txt

@@ -0,0 +1,16 @@
+subject wstring.zip
+author Boudewijn Dekker
+date 06-06-98
+
+
+I wrote some inline wide character string functions. It are modified version
+of the ones in string.h. I added four more function nl stricmp, strnicmp,
+wcsicmp, and wcsnicmp. These are the case insensitive variants of
+strcmp, strncmp and wcscmp, wcsncmp. I tested all the functions but I
+would urge anyone to tested again. I removed an extern specifier
+__wcstok and strtok cause I it caused an compilation error when
+using strtok or wcstok. Please could someone see if this correct.
+I also used these string functions in lstring api functions.
+
+
+Boudewijn Dekker  

reactos/drivers/readme

@@ -0,0 +1,11 @@
+These are a selection of services for the ReactOS kernel. They include
+
+    parallel = parallel port driver
+    serial = serial port driver
+    mouse = mouse driver
+    null = null device driver
+    ide = IDE (hard disk) driver
+    keyboard = keyboard driver
+    loop = Allows accessing a file as a block device
+    scramdisk = Filesystem encryption driver
+    event = Sample driver demonstrating notifying a user thread using an event

reactos/include/base.h

@@ -0,0 +1,572 @@
+/* 
+   Base.h
+
+   Base definitions
+
+   Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+
+   Author: Scott Christley <scottc@net-community.com>
+
+   This file is part of the Windows32 API Library.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+   
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   If you are interested in a warranty or support for this source code,
+   contact Scott Christley <scottc@net-community.com> for more information.
+   
+   You should have received a copy of the GNU Library General Public
+   License along with this library; see the file COPYING.LIB.
+   If not, write to the Free Software Foundation, 
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/ 
+
+#ifndef _GNU_H_WINDOWS32_BASE
+#define _GNU_H_WINDOWS32_BASE
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifndef NULL
+#ifdef __cplusplus
+#define NULL  (0)
+#else
+#define NULL  ((void *)0)
+#endif
+#endif /* !NULL */
+
+#define FALSE 0
+#define TRUE 1
+
+#ifndef RC_INVOKED
+
+/* typedef ACMDRIVERENUMCB;
+typedef ACMDRIVERPROC;
+typedef ACMFILERCHOOSEHOOKPROC;
+typedef ACMFILTERENUMCB;
+typedef ACMFILTERTAGENUMCB;
+typedef ACMFORMATCHOOSEHOOKPROC;
+typedef ACMFORMATENUMCB;
+typedef ACMFORMATTAGENUMCB;
+typedef APPLET_PROC;
+*/
+typedef unsigned short ATOM;
+/* Changed from BOOL to WINBOOL to avoid Objective-C conflict */
+typedef int WINBOOL;
+typedef unsigned char BOOLEAN;
+typedef unsigned char BYTE;
+typedef unsigned long CALTYPE;
+typedef unsigned long CALID;
+typedef char CCHAR;
+typedef unsigned long COLORREF;
+#define CONST const
+
+/* Check VOID before defining CHAR, SHORT, and LONG */
+#ifndef VOID
+#define VOID void
+typedef char CHAR;
+typedef short SHORT;
+typedef long LONG;
+#endif
+
+/*
+typedef CTRYID;
+typedef DLGPROC;
+*/
+typedef unsigned int DWORD; /* was unsigned long */
+typedef double DWORDLONG, *PDWORDLONG;
+/*
+typedef EDITWORDBREAKPROC;
+typedef ENHMFENUMPROC;
+typedef ENUMRESLANGPROC;
+typedef ENUMRESNAMEPROC;
+typedef ENUMRESTYPEPROC;
+*/
+typedef float FLOAT;
+/* typedef GLOBALHANDLE; */
+typedef void *HANDLE;
+typedef HANDLE HACCEL;
+typedef HANDLE HBITMAP;
+typedef HANDLE HBRUSH;
+typedef HANDLE HCOLORSPACE;
+typedef HANDLE HCONV;
+typedef HANDLE HCONVLIST;
+typedef HANDLE HCURSOR;
+typedef HANDLE HDBC;
+typedef HANDLE HDC;
+typedef HANDLE HDDEDATA;
+typedef HANDLE HDESK;
+typedef HANDLE HDROP;
+typedef HANDLE HDWP;
+typedef HANDLE HENHMETAFILE;
+typedef HANDLE HENV;
+typedef int HFILE;
+typedef HANDLE HFONT;
+typedef HANDLE HGDIOBJ;
+typedef HANDLE HGLOBAL;
+typedef HANDLE HGLRC;
+typedef HANDLE HHOOK;
+typedef HANDLE HICON;
+typedef HANDLE HIMAGELIST;
+typedef HANDLE HINSTANCE;
+typedef HANDLE HKEY, *PHKEY;
+typedef HANDLE HKL;
+typedef HANDLE HLOCAL;
+typedef HANDLE HMENU;
+typedef HANDLE HMETAFILE;
+typedef HANDLE HMODULE;
+typedef HANDLE HPALETTE;
+typedef HANDLE HPEN;
+typedef HANDLE HRASCONN;
+typedef long HRESULT;
+typedef HANDLE HRGN;
+typedef HANDLE HRSRC;
+typedef HANDLE HSTMT;
+typedef HANDLE HSZ;
+typedef HANDLE HWINSTA;
+typedef HANDLE HWND;
+typedef int INT;
+typedef unsigned short LANGID;
+typedef DWORD LCID;
+typedef DWORD LCTYPE;
+/* typedef LOCALHANDLE */
+typedef double LONGLONG, *PLONGLONG;
+typedef unsigned short *LP;
+typedef long LPARAM;
+typedef WINBOOL *LPBOOL;
+typedef BYTE *LPBYTE;
+typedef CONST CHAR *LPCCH;
+typedef CHAR *LPCH;
+typedef COLORREF *LPCOLORREF;
+typedef const char *LPCSTR;
+typedef char* PCSZ;
+   
+#ifdef UNICODE
+typedef const unsigned short *LPCTSTR;
+#else
+typedef const char *LPCTSTR;
+#endif /* UNICODE */
+
+typedef const unsigned short *LPCWCH;
+typedef const unsigned short *LPCWSTR;
+typedef DWORD *LPDWORD;
+/* typedef LPFRHOOKPROC; */
+typedef HANDLE *LPHANDLE;
+/* typedef LPHANDLER_FUNCTION; */
+typedef int *LPINT;
+typedef long *LPLONG;
+typedef char *LPSTR;
+
+#ifdef UNICODE
+typedef unsigned short *LPTCH;
+typedef unsigned short *LPTSTR;
+#else
+typedef char *LPTCH;
+typedef char *LPTSTR;
+#endif /* UNICODE */
+
+typedef long LRESULT;
+typedef void *LPVOID;
+typedef const void *LPCVOID;
+typedef unsigned short *LPWCH;
+typedef unsigned short *LPWORD;
+typedef unsigned short *LPWSTR;
+typedef unsigned short *PWSTR;
+/* typedef NPSTR; */
+typedef unsigned short *NWPSTR;
+typedef WINBOOL *PWINBOOL;
+typedef BYTE *PBOOLEAN;
+typedef BYTE *PBYTE;
+typedef const CHAR *PCCH;
+typedef CHAR *PCH;
+typedef CHAR *PCHAR;
+typedef const char *PCSTR;
+typedef const unsigned short *PCWCH;
+typedef const unsigned short *PCWSTR;
+typedef DWORD *PDWORD;
+typedef float *PFLOAT;
+typedef HANDLE *PHANDLE;
+/* typedef PHKEY; */
+typedef int *PINT;
+/* typedef LCID *PLCID; */
+typedef long *PLONG;
+typedef short *PSHORT;
+/* typedef PSID; */
+typedef char *PSTR;
+typedef char *PSZ;
+
+#ifdef UNICODE
+typedef unsigned short *PTBYTE;
+typedef unsigned short *PTCH;
+typedef unsigned short *PTCHAR;
+typedef unsigned short *PTSTR;
+#else
+typedef unsigned char *PTBYTE;
+typedef char *PTCH;
+typedef char *PTCHAR;
+typedef char *PTSTR;
+#endif /* UNICODE */
+
+typedef unsigned char *PUCHAR;
+typedef unsigned int *PUINT;
+typedef unsigned long *PULONG;
+typedef unsigned short *PUSHORT;
+typedef void *PVOID;
+typedef unsigned short *PWCH;
+typedef unsigned short *PWCHAR;
+typedef unsigned short *PWORD;
+/*
+typedef PWSTR;
+typedef REGSAM;
+*/
+
+typedef short RETCODE;
+
+typedef HANDLE SC_HANDLE;
+typedef LPVOID  SC_LOCK;
+typedef SC_HANDLE *LPSC_HANDLE;
+typedef DWORD SERVICE_STATUS_HANDLE;
+/* typedef SPHANDLE; */
+
+#ifdef UNICODE
+typedef unsigned short TBYTE;
+typedef unsigned short TCHAR;
+typedef unsigned short BCHAR;
+#else
+typedef unsigned char TBYTE;
+typedef char TCHAR;
+typedef BYTE BCHAR;
+#endif /* UNICODE */
+
+typedef unsigned char UCHAR;
+typedef unsigned int UINT;
+typedef unsigned long ULONG;
+typedef unsigned short USHORT;
+typedef unsigned short WCHAR;
+typedef unsigned short WORD;
+typedef unsigned int WPARAM;
+/* typedef YIELDPROC; */
+
+/* Only use __stdcall under WIN32 compiler */
+#ifdef i386
+#define STDCALL     __attribute__ ((stdcall))
+#define CDECL       __attribute((cdecl))
+#define CALLBACK    WINAPI
+#define PASCAL      WINAPI
+#else
+#define STDCALL
+#define CDECL
+#define CALLBACK
+#define PASCAL
+#endif
+#define WINAPI      STDCALL
+#define APIENTRY    STDCALL
+#define WINGDIAPI
+
+#define _export
+
+/*
+  Enumerations
+*/
+typedef enum _ACL_INFORMATION_CLASS {
+  AclRevisionInformation = 1,   
+  AclSizeInformation            
+} ACL_INFORMATION_CLASS; 
+ 
+typedef enum _MEDIA_TYPE { 
+  Unknown,                
+  F5_1Pt2_512,            
+  F3_1Pt44_512,           
+  F3_2Pt88_512,           
+  F3_20Pt8_512,           
+  F3_720_512,             
+  F5_360_512,             
+  F5_320_512,             
+  F5_320_1024,            
+  F5_180_512,             
+  F5_160_512,             
+  RemovableMedia,         
+  FixedMedia              
+} MEDIA_TYPE; 
+ 
+#define RASCS_DONE 0x2000
+#define RASCS_PAUSED 0x1000
+typedef enum _RASCONNSTATE { 
+    RASCS_OpenPort = 0, 
+    RASCS_PortOpened, 
+    RASCS_ConnectDevice, 
+    RASCS_DeviceConnected, 
+    RASCS_AllDevicesConnected, 
+    RASCS_Authenticate, 
+    RASCS_AuthNotify, 
+    RASCS_AuthRetry, 
+    RASCS_AuthCallback, 
+    RASCS_AuthChangePassword, 
+    RASCS_AuthProject, 
+    RASCS_AuthLinkSpeed, 
+    RASCS_AuthAck, 
+    RASCS_ReAuthenticate, 
+    RASCS_Authenticated, 
+    RASCS_PrepareForCallback, 
+    RASCS_WaitForModemReset, 
+    RASCS_WaitForCallback,
+    RASCS_Projected, 
+ 
+    RASCS_StartAuthentication,  
+    RASCS_CallbackComplete,     
+    RASCS_LogonNetwork,         
+ 
+    RASCS_Interactive = RASCS_PAUSED, 
+    RASCS_RetryAuthentication, 
+    RASCS_CallbackSetByCaller, 
+    RASCS_PasswordExpired, 
+ 
+    RASCS_Connected = RASCS_DONE, 
+    RASCS_Disconnected 
+} RASCONNSTATE ; 
+ 
+typedef enum _RASPROJECTION {  
+    RASP_Amb = 0x10000, 
+    RASP_PppNbf = 0x803F, 
+    RASP_PppIpx = 0x802B, 
+    RASP_PppIp = 0x8021 
+} RASPROJECTION ; 
+ 
+typedef enum _SECURITY_IMPERSONATION_LEVEL {
+    SecurityAnonymous, 
+    SecurityIdentification, 
+    SecurityImpersonation, 
+    SecurityDelegation 
+} SECURITY_IMPERSONATION_LEVEL; 
+ 
+typedef enum _SID_NAME_USE { 
+    SidTypeUser = 1, 
+    SidTypeGroup, 
+    SidTypeDomain, 
+    SidTypeAlias, 
+    SidTypeWellKnownGroup, 
+    SidTypeDeletedAccount, 
+    SidTypeInvalid, 
+    SidTypeUnknown 
+} SID_NAME_USE, *PSID_NAME_USE; 
+ 
+typedef enum _TOKEN_INFORMATION_CLASS {
+    TokenUser = 1, 
+    TokenGroups, 
+    TokenPrivileges, 
+    TokenOwner, 
+    TokenPrimaryGroup, 
+    TokenDefaultDacl, 
+    TokenSource, 
+    TokenType, 
+    TokenImpersonationLevel, 
+    TokenStatistics 
+} TOKEN_INFORMATION_CLASS; 
+ 
+typedef enum tagTOKEN_TYPE {
+    TokenPrimary = 1, 
+    TokenImpersonation 
+} TOKEN_TYPE; 
+ 
+#endif /* ! defined (RC_INVOKED) */
+
+/*
+  Macros
+*/
+#define FORWARD_WM_NOTIFY(hwnd, idFrom, pnmhdr, fn)  (void)(fn)((hwnd), WM_NOTIFY, (WPARAM)(int)(id),  (LPARAM)(NMHDR FAR*)(pnmhdr)) 
+
+#define GetBValue(rgb)   ((BYTE) ((rgb) >> 16)) 
+#define GetGValue(rgb)   ((BYTE) (((WORD) (rgb)) >> 8)) 
+#define GetRValue(rgb)   ((BYTE) (rgb)) 
+#define RGB(r, g ,b)  ((DWORD) (((BYTE) (r) | ((WORD) (g) << 8)) | (((DWORD) (BYTE) (b)) << 16))) 
+
+#define HANDLE_WM_NOTIFY(hwnd, wParam, lParam, fn) (fn)((hwnd), (int)(wParam), (NMHDR FAR*)(lParam)) 
+
+#define HIBYTE(w)   ((BYTE) (((WORD) (w) >> 8) & 0xFF)) 
+#define HIWORD(l)   ((WORD) (((DWORD) (l) >> 16) & 0xFFFF)) 
+#define LOBYTE(w)   ((BYTE) (w)) 
+#define LOWORD(l)   ((WORD) (l)) 
+#define MAKELONG(a, b) ((LONG) (((WORD) (a)) | ((DWORD) ((WORD) (b))) << 16)) 
+#define MAKEWORD(a, b) ((WORD) (((BYTE) (a)) | ((WORD) ((BYTE) (b))) << 8)) 
+
+/* original Cygnus headers also had the following defined: */
+#define SEXT_HIWORD(l)     ((((int)l) >> 16))
+#define ZEXT_HIWORD(l)     ((((unsigned int)l) >> 16))
+#define SEXT_LOWORD(l)     ((int)(short)l)
+
+#define INDEXTOOVERLAYMASK(i) ((i) << 8) 
+#define INDEXTOSTATEIMAGEMASK(i) ((i) << 12) 
+
+#define MAKEINTATOM(i)   (LPTSTR) ((DWORD) ((WORD) (i))) 
+#define MAKEINTRESOURCE(i)  (LPTSTR) ((DWORD) ((WORD) (i)))
+
+#define MAKELANGID(p, s) ((((WORD) (s)) << 10) | (WORD) (p)) 
+#define PRIMARYLANGID(lgid)    ((WORD  )(lgid) & 0x3ff) 
+#define SUBLANGID(lgid)        ((WORD  )(lgid) >> 10) 
+
+#define LANGIDFROMLCID(lcid)   ((WORD) (lcid)) 
+#define SORTIDFROMLCID(lcid) ((WORD  )((((DWORD)(lcid)) & 0x000FFFFF) >> 16)) 
+#define MAKELCID(lgid, srtid)  ((DWORD)((((DWORD)((WORD)(srtid))) << 16) |  ((DWORD)((WORD)(lgid))))) 
+#define MAKELPARAM(l, h)   ((LPARAM) MAKELONG(l, h)) 
+#define MAKELRESULT(l, h)   ((LRESULT) MAKELONG(l, h)) 
+#define MAKEPOINTS(l)   (*((POINTS FAR *) & (l))) 
+#define MAKEROP4(fore,back) (DWORD)((((back) << 8) & 0xFF000000) | (fore)) 
+#define MAKEWPARAM(l, h)   ((WPARAM) MAKELONG(l, h)) 
+
+#ifndef max
+#define max(a, b)  (((a) > (b)) ? (a) : (b)) 
+#endif
+
+#ifndef min
+#define min(a, b)  (((a) < (b)) ? (a) : (b)) 
+#endif
+
+#define PALETTEINDEX(i) ((COLORREF) (0x01000000 | (DWORD) (WORD) (i))) 
+#define PALETTERGB(r, g, b)  (0x02000000 | RGB(r, g, b)) 
+#define POINTSTOPOINT(pt, pts) {(pt).x = (SHORT) LOWORD(pts); (pt).y = (SHORT) HIWORD(pts);} 
+#define POINTTOPOINTS(pt) (MAKELONG((short) ((pt).x), (short) ((pt).y))) 
+
+#define INDEXTOOVERLAYMASK(i) ((i) << 8)  
+#define INDEXTOSTATEIMAGEMASK(i) ((i) << 12)  
+
+#ifdef UNICODE
+#define TEXT(quote) L##quote 
+#else
+#define TEXT(quote) quote
+#endif
+
+#ifndef RC_INVOKED
+
+/*
+   Definitions for callback procedures
+*/
+typedef int CALLBACK (*BFFCALLBACK) (HWND, UINT, LPARAM, LPARAM);
+typedef UINT CALLBACK (*LPCCHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
+typedef UINT CALLBACK (*LPCFHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
+typedef DWORD CALLBACK (*PTHREAD_START_ROUTINE) (LPVOID);
+typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE;
+typedef DWORD CALLBACK (*EDITSTREAMCALLBACK) (DWORD, LPBYTE, LONG, LONG);
+typedef UINT CALLBACK (*LPFRHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
+typedef UINT CALLBACK (*LPOFNHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
+typedef UINT CALLBACK (*LPPRINTHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
+typedef UINT CALLBACK (*LPSETUPHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
+typedef WINBOOL CALLBACK (*DLGPROC) (HWND, UINT, WPARAM, LPARAM);
+typedef int CALLBACK (*PFNPROPSHEETCALLBACK) (HWND, UINT, LPARAM);
+typedef VOID CALLBACK (*LPSERVICE_MAIN_FUNCTION) (DWORD, LPTSTR);
+typedef int CALLBACK (*PFNTVCOMPARE) (LPARAM, LPARAM, LPARAM);
+typedef LRESULT CALLBACK (*WNDPROC) (HWND, UINT, WPARAM, LPARAM);
+typedef int CALLBACK (*FARPROC)(void);
+typedef FARPROC PROC;
+typedef WINBOOL CALLBACK (*ENUMRESTYPEPROC) (HANDLE, LPTSTR, LONG);
+typedef WINBOOL CALLBACK (*ENUMRESNAMEPROC) (HANDLE, LPCTSTR, LPTSTR, LONG);
+typedef WINBOOL CALLBACK (*ENUMRESLANGPROC) (HANDLE, LPCTSTR, LPCTSTR, WORD, LONG);
+typedef FARPROC DESKTOPENUMPROC;
+typedef WINBOOL CALLBACK (*ENUMWINDOWSPROC) (HWND, LPARAM);
+typedef WINBOOL CALLBACK (*ENUMWINDOWSTATIONPROC) (LPTSTR, LPARAM);
+typedef VOID CALLBACK (*SENDASYNCPROC) (HWND, UINT, DWORD, LRESULT);
+typedef VOID CALLBACK (*TIMERPROC) (HWND, UINT, UINT, DWORD);
+typedef FARPROC GRAYSTRINGPROC;
+typedef WINBOOL CALLBACK (*DRAWSTATEPROC) (HDC, LPARAM, WPARAM, int, int);
+typedef WINBOOL CALLBACK (*PROPENUMPROCEX) (HWND, LPCTSTR, HANDLE, DWORD);
+typedef WINBOOL CALLBACK (*PROPENUMPROC) (HWND, LPCTSTR, HANDLE);
+typedef LRESULT CALLBACK (*HOOKPROC) (int, WPARAM, LPARAM);
+typedef VOID CALLBACK (*ENUMOBJECTSPROC) (LPVOID, LPARAM);
+typedef VOID CALLBACK (*LINEDDAPROC) (int, int, LPARAM);
+typedef WINBOOL CALLBACK (*ABORTPROC) (HDC, int);
+typedef UINT CALLBACK (*LPPAGEPAINTHOOK) (HWND, UINT, WPARAM, LPARAM );
+typedef UINT CALLBACK (*LPPAGESETUPHOOK) (HWND, UINT, WPARAM, LPARAM );
+typedef int CALLBACK (*ICMENUMPROC) (LPTSTR, LPARAM);
+typedef LONG (*EDITWORDBREAKPROCEX) (char *, LONG, BYTE, INT);
+typedef int CALLBACK (*PFNLVCOMPARE) (LPARAM, LPARAM, LPARAM);
+typedef WINBOOL CALLBACK (*LOCALE_ENUMPROC) (LPTSTR);
+typedef WINBOOL CALLBACK (*CODEPAGE_ENUMPROC) (LPTSTR);
+typedef WINBOOL CALLBACK (*DATEFMT_ENUMPROC) (LPTSTR);
+typedef WINBOOL CALLBACK (*TIMEFMT_ENUMPROC) (LPTSTR);
+typedef WINBOOL CALLBACK (*CALINFO_ENUMPROC) (LPTSTR);
+typedef WINBOOL CALLBACK (*PHANDLER_ROUTINE) (DWORD);
+typedef WINBOOL CALLBACK (*LPHANDLER_FUNCTION) (DWORD);
+typedef UINT CALLBACK (*PFNGETPROFILEPATH) (LPCTSTR, LPSTR, UINT);
+typedef UINT CALLBACK (*PFNRECONCILEPROFILE) (LPCTSTR, LPCTSTR, DWORD);
+typedef WINBOOL CALLBACK (*PFNPROCESSPOLICIES) (HWND, LPCTSTR, LPCTSTR, LPCTSTR, DWORD);
+
+#define SECURITY_NULL_SID_AUTHORITY     {0,0,0,0,0,0}
+#define SECURITY_WORLD_SID_AUTHORITY    {0,0,0,0,0,1}
+#define SECURITY_LOCAL_SID_AUTHORITY    {0,0,0,0,0,2}
+#define SECURITY_CREATOR_SID_AUTHORITY  {0,0,0,0,0,3}
+#define SECURITY_NON_UNIQUE_AUTHORITY   {0,0,0,0,0,4}
+#define SECURITY_NT_AUTHORITY           {0,0,0,0,0,5}
+
+#define SE_CREATE_TOKEN_NAME              TEXT("SeCreateTokenPrivilege")
+#define SE_ASSIGNPRIMARYTOKEN_NAME        TEXT("SeAssignPrimaryTokenPrivilege")
+#define SE_LOCK_MEMORY_NAME               TEXT("SeLockMemoryPrivilege")
+#define SE_INCREASE_QUOTA_NAME            TEXT("SeIncreaseQuotaPrivilege")
+#define SE_UNSOLICITED_INPUT_NAME         TEXT("SeUnsolicitedInputPrivilege")
+#define SE_MACHINE_ACCOUNT_NAME           TEXT("SeMachineAccountPrivilege")
+#define SE_TCB_NAME                       TEXT("SeTcbPrivilege")
+#define SE_SECURITY_NAME                  TEXT("SeSecurityPrivilege")
+#define SE_TAKE_OWNERSHIP_NAME            TEXT("SeTakeOwnershipPrivilege")
+#define SE_LOAD_DRIVER_NAME               TEXT("SeLoadDriverPrivilege")
+#define SE_SYSTEM_PROFILE_NAME            TEXT("SeSystemProfilePrivilege")
+#define SE_SYSTEMTIME_NAME                TEXT("SeSystemtimePrivilege")
+#define SE_PROF_SINGLE_PROCESS_NAME       TEXT("SeProfileSingleProcessPrivilege")
+#define SE_INC_BASE_PRIORITY_NAME         TEXT("SeIncreaseBasePriorityPrivilege")
+#define SE_CREATE_PAGEFILE_NAME           TEXT("SeCreatePagefilePrivilege")
+#define SE_CREATE_PERMANENT_NAME          TEXT("SeCreatePermanentPrivilege")
+#define SE_BACKUP_NAME                    TEXT("SeBackupPrivilege")
+#define SE_RESTORE_NAME                   TEXT("SeRestorePrivilege")
+#define SE_SHUTDOWN_NAME                  TEXT("SeShutdownPrivilege")
+#define SE_DEBUG_NAME                     TEXT("SeDebugPrivilege")
+#define SE_AUDIT_NAME                     TEXT("SeAuditPrivilege")
+#define SE_SYSTEM_ENVIRONMENT_NAME        TEXT("SeSystemEnvironmentPrivilege")
+#define SE_CHANGE_NOTIFY_NAME             TEXT("SeChangeNotifyPrivilege")
+#define SE_REMOTE_SHUTDOWN_NAME           TEXT("SeRemoteShutdownPrivilege")
+
+#define SERVICES_ACTIVE_DATABASEW      L"ServicesActive"
+#define SERVICES_FAILED_DATABASEW      L"ServicesFailed"
+#define SERVICES_ACTIVE_DATABASEA      "ServicesActive"
+#define SERVICES_FAILED_DATABASEA      "ServicesFailed"
+#define SC_GROUP_IDENTIFIERW           L'+'
+#define SC_GROUP_IDENTIFIERA           '+'
+
+#ifdef UNICODE
+#define SERVICES_ACTIVE_DATABASE       SERVICES_ACTIVE_DATABASEW
+#define SERVICES_FAILED_DATABASE       SERVICES_FAILED_DATABASEW
+#define SC_GROUP_IDENTIFIER            SC_GROUP_IDENTIFIERW
+#else 
+#define SERVICES_ACTIVE_DATABASE       SERVICES_ACTIVE_DATABASEA
+#define SERVICES_FAILED_DATABASE       SERVICES_FAILED_DATABASEA
+#define SC_GROUP_IDENTIFIER            SC_GROUP_IDENTIFIERA
+#endif /* UNICODE */
+
+/* ---------------------------------- */
+/* From ddeml.h in old Cygnus headers */
+
+typedef void (*CALLB) (void);
+typedef CALLB PFNCALLBACK;
+
+typedef WINBOOL SECURITY_CONTEXT_TRACKING_MODE;
+
+/* End of stuff from ddeml.h in old Cygnus headers */
+/* ----------------------------------------------- */
+
+typedef FARPROC WNDENUMPROC;
+typedef FARPROC ENHMFENUMPROC;
+typedef DWORD CCSTYLE, *PCCSTYLE, *LPCCSTYLE;
+typedef DWORD CCSTYLEFLAGA, *PCCSTYLEFLAGA, *LPCCSTYLEFLAGA;
+#define DECLARE_HANDLE(s) typedef HANDLE s
+
+#endif /* ! defined (RC_INVOKED) */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _GNU_H_WINDOWS32_BASE */

reactos/include/coff.h

@@ -0,0 +1,339 @@
+/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
+#ifndef __dj_include_coff_h_
+#define __dj_include_coff_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//#ifndef __dj_ENFORCE_ANSI_FREESTANDING
+
+//#ifndef __STRICT_ANSI__
+
+//#ifndef _POSIX_SOURCE
+
+/*** coff information for Intel 386/486.  */
+
+/********************** FILE HEADER **********************/
+
+struct external_filehdr {
+	unsigned short f_magic;		/* magic number			*/
+	unsigned short f_nscns;		/* number of sections		*/
+	unsigned long f_timdat;	/* time & date stamp		*/
+	unsigned long f_symptr;	/* file pointer to symtab	*/
+	unsigned long f_nsyms;		/* number of symtab entries	*/
+	unsigned short f_opthdr;	/* sizeof(optional hdr)		*/
+	unsigned short f_flags;		/* flags			*/
+};
+
+
+/* Bits for f_flags:
+ *	F_RELFLG	relocation info stripped from file
+ *	F_EXEC		file is executable (no unresolved external references)
+ *	F_LNNO		line numbers stripped from file
+ *	F_LSYMS		local symbols stripped from file
+ *	F_AR32WR	file has byte ordering of an AR32WR machine (e.g. vax)
+ */
+
+#define F_RELFLG	(0x0001)
+#define F_EXEC		(0x0002)
+#define F_LNNO		(0x0004)
+#define F_LSYMS		(0x0008)
+
+
+
+#define	I386MAGIC	0x14c
+#define I386AIXMAGIC	0x175
+#define I386BADMAG(x) (((x).f_magic!=I386MAGIC) && (x).f_magic!=I386AIXMAGIC)
+
+
+#define	FILHDR	struct external_filehdr
+#define	FILHSZ	sizeof(FILHDR)
+
+
+/********************** AOUT "OPTIONAL HEADER" **********************/
+
+
+typedef struct 
+{
+  unsigned short 	magic;		/* type of file				*/
+  unsigned short	vstamp;		/* version stamp			*/
+  unsigned long	tsize;		/* text size in bytes, padded to FW bdry*/
+  unsigned long	dsize;		/* initialized data "  "		*/
+  unsigned long	bsize;		/* uninitialized data "   "		*/
+  unsigned long	entry;		/* entry pt.				*/
+  unsigned long 	text_start;	/* base of text used for this file */
+  unsigned long 	data_start;	/* base of data used for this file */
+}
+AOUTHDR;
+
+
+typedef struct gnu_aout {
+	unsigned long info;
+	unsigned long tsize;
+	unsigned long dsize;
+	unsigned long bsize;
+	unsigned long symsize;
+	unsigned long entry;
+	unsigned long txrel;
+	unsigned long dtrel;
+	} GNU_AOUT;
+
+#define AOUTSZ (sizeof(AOUTHDR))
+
+#define OMAGIC          0404    /* object files, eg as output */
+#define ZMAGIC          0413    /* demand load format, eg normal ld output */
+#define STMAGIC		0401	/* target shlib */
+#define SHMAGIC		0443	/* host   shlib */
+
+
+/********************** SECTION HEADER **********************/
+
+
+struct external_scnhdr {
+	char		s_name[8];	/* section name			*/
+	unsigned long		s_paddr;	/* physical address, aliased s_nlib */
+	unsigned long		s_vaddr;	/* virtual address		*/
+	unsigned long		s_size;		/* section size			*/
+	unsigned long		s_scnptr;	/* file ptr to raw data for section */
+	unsigned long		s_relptr;	/* file ptr to relocation	*/
+	unsigned long		s_lnnoptr;	/* file ptr to line numbers	*/
+	unsigned short		s_nreloc;	/* number of relocation entries	*/
+	unsigned short		s_nlnno;	/* number of line number entries*/
+	unsigned long		s_flags;	/* flags			*/
+};
+
+#define	SCNHDR	struct external_scnhdr
+#define	SCNHSZ	sizeof(SCNHDR)
+
+/*
+ * names of "special" sections
+ */
+#define _TEXT	".text"
+#define _DATA	".data"
+#define _BSS	".bss"
+#define _COMMENT ".comment"
+#define _LIB ".lib"
+
+/*
+ * s_flags "type"
+ */
+#define STYP_TEXT	 (0x0020)	/* section contains text only */
+#define STYP_DATA	 (0x0040)	/* section contains data only */
+#define STYP_BSS	 (0x0080)	/* section contains bss only */
+
+/********************** LINE NUMBERS **********************/
+
+/* 1 line number entry for every "breakpointable" source line in a section.
+ * Line numbers are grouped on a per function basis; first entry in a function
+ * grouping will have l_lnno = 0 and in place of physical address will be the
+ * symbol table index of the function name.
+ */
+struct external_lineno {
+	union {
+		unsigned long l_symndx __attribute__((packed));	/* function name symbol index, iff l_lnno == 0 */
+		unsigned long l_paddr __attribute__((packed));		/* (physical) address of line number */
+	} l_addr;
+	unsigned short l_lnno;						/* line number */
+};
+
+
+#define	LINENO	struct external_lineno
+#define	LINESZ	sizeof(LINENO)
+
+
+/********************** SYMBOLS **********************/
+
+#define E_SYMNMLEN	8	/* # characters in a symbol name	*/
+#define E_FILNMLEN	14	/* # characters in a file name		*/
+#define E_DIMNUM	4	/* # array dimensions in auxiliary entry */
+
+struct external_syment 
+{
+  union {
+    char e_name[E_SYMNMLEN];
+    struct {
+      unsigned long e_zeroes __attribute__((packed));
+      unsigned long e_offset __attribute__((packed));
+    } e;
+  } e;
+  unsigned long e_value __attribute__((packed));
+  short e_scnum;
+  unsigned short e_type;
+  unsigned char e_sclass;
+  unsigned char e_numaux;
+};
+
+#define N_BTMASK	(0xf)
+#define N_TMASK		(0x30)
+#define N_BTSHFT	(4)
+#define N_TSHIFT	(2)
+  
+union external_auxent {
+	struct {
+		unsigned long x_tagndx __attribute__((packed));		/* str, un, or enum tag indx */
+		union {
+			struct {
+			    unsigned short  x_lnno;				/* declaration line number */
+			    unsigned short  x_size; 				/* str/union/array size */
+			} x_lnsz;
+			unsigned long x_fsize __attribute__((packed));		/* size of function */
+		} x_misc;
+		union {
+			struct {					/* if ISFCN, tag, or .bb */
+			    unsigned long x_lnnoptr __attribute__((packed));	/* ptr to fcn line # */
+			    unsigned long x_endndx __attribute__((packed));	/* entry ndx past block end */
+			} x_fcn;
+			struct {					/* if ISARY, up to 4 dimen. */
+			    unsigned short x_dimen[E_DIMNUM];
+			} x_ary;
+		} x_fcnary;
+		unsigned short x_tvndx;						/* tv index */
+	} x_sym;
+
+	union {
+		char x_fname[E_FILNMLEN];
+		struct {
+			unsigned long x_zeroes __attribute__((packed));
+			unsigned long x_offset __attribute__((packed));
+		} x_n;
+	} x_file;
+
+	struct {
+		unsigned long x_scnlen __attribute__((packed));		/* section length */
+		unsigned short x_nreloc;					/* # relocation entries */
+		unsigned short x_nlinno;					/* # line numbers */
+	} x_scn;
+
+        struct {
+		unsigned long x_tvfill __attribute__((packed));		/* tv fill value */
+		unsigned short x_tvlen;						/* length of .tv */
+		unsigned short x_tvran[2];					/* tv range */
+	} x_tv;		/* info about .tv section (in auxent of symbol .tv)) */
+
+
+};
+
+#define	SYMENT	struct external_syment
+#define	SYMESZ	sizeof(SYMENT)
+#define	AUXENT	union external_auxent
+#define	AUXESZ	sizeof(AUXENT)
+
+
+#	define _ETEXT	"etext"
+
+
+/* Relocatable symbols have number of the section in which they are defined,
+   or one of the following: */
+
+#define N_UNDEF	((short)0)	/* undefined symbol */
+#define N_ABS	((short)-1)	/* value of symbol is absolute */
+#define N_DEBUG	((short)-2)	/* debugging symbol -- value is meaningless */
+#define N_TV	((short)-3)	/* indicates symbol needs preload transfer vector */
+#define P_TV	((short)-4)	/* indicates symbol needs postload transfer vector*/
+
+/*
+ * Type of a symbol, in low N bits of the word
+ */
+#define T_NULL		0
+#define T_VOID		1	/* function argument (only used by compiler) */
+#define T_CHAR		2	/* character		*/
+#define T_SHORT		3	/* short integer	*/
+#define T_INT		4	/* integer		*/
+#define T_LONG		5	/* long integer		*/
+#define T_FLOAT		6	/* floating point	*/
+#define T_DOUBLE	7	/* double word		*/
+#define T_STRUCT	8	/* structure 		*/
+#define T_UNION		9	/* union 		*/
+#define T_ENUM		10	/* enumeration 		*/
+#define T_MOE		11	/* member of enumeration*/
+#define T_UCHAR		12	/* unsigned character	*/
+#define T_USHORT	13	/* unsigned short	*/
+#define T_UINT		14	/* unsigned integer	*/
+#define T_ULONG		15	/* unsigned long	*/
+#define T_LNGDBL	16	/* long double		*/
+
+/*
+ * derived types, in n_type
+*/
+#define DT_NON		(0)	/* no derived type */
+#define DT_PTR		(1)	/* pointer */
+#define DT_FCN		(2)	/* function */
+#define DT_ARY		(3)	/* array */
+
+#define BTYPE(x)	((x) & N_BTMASK)
+
+#define ISPTR(x)	(((x) & N_TMASK) == (DT_PTR << N_BTSHFT))
+#define ISFCN(x)	(((x) & N_TMASK) == (DT_FCN << N_BTSHFT))
+#define ISARY(x)	(((x) & N_TMASK) == (DT_ARY << N_BTSHFT))
+#define ISTAG(x)	((x)==C_STRTAG||(x)==C_UNTAG||(x)==C_ENTAG)
+#define DECREF(x) ((((x)>>N_TSHIFT)&~N_BTMASK)|((x)&N_BTMASK))
+
+/********************** STORAGE CLASSES **********************/
+
+/* This used to be defined as -1, but now n_sclass is unsigned.  */
+#define C_EFCN		0xff	/* physical end of function	*/
+#define C_NULL		0
+#define C_AUTO		1	/* automatic variable		*/
+#define C_EXT		2	/* external symbol		*/
+#define C_STAT		3	/* static			*/
+#define C_REG		4	/* register variable		*/
+#define C_EXTDEF	5	/* external definition		*/
+#define C_LABEL		6	/* label			*/
+#define C_ULABEL	7	/* undefined label		*/
+#define C_MOS		8	/* member of structure		*/
+#define C_ARG		9	/* function argument		*/
+#define C_STRTAG	10	/* structure tag		*/
+#define C_MOU		11	/* member of union		*/
+#define C_UNTAG		12	/* union tag			*/
+#define C_TPDEF		13	/* type definition		*/
+#define C_USTATIC	14	/* undefined static		*/
+#define C_ENTAG		15	/* enumeration tag		*/
+#define C_MOE		16	/* member of enumeration	*/
+#define C_REGPARM	17	/* register parameter		*/
+#define C_FIELD		18	/* bit field			*/
+#define C_AUTOARG	19	/* auto argument		*/
+#define C_LASTENT	20	/* dummy entry (end of block)	*/
+#define C_BLOCK		100	/* ".bb" or ".eb"		*/
+#define C_FCN		101	/* ".bf" or ".ef"		*/
+#define C_EOS		102	/* end of structure		*/
+#define C_FILE		103	/* file name			*/
+#define C_LINE		104	/* line # reformatted as symbol table entry */
+#define C_ALIAS	 	105	/* duplicate tag		*/
+#define C_HIDDEN	106	/* ext symbol in dmert public lib */
+
+/********************** RELOCATION DIRECTIVES **********************/
+
+
+
+struct external_reloc {
+  unsigned long r_vaddr __attribute__((packed));
+  unsigned long r_symndx __attribute__((packed));
+  unsigned short r_type;
+};
+
+
+#define RELOC struct external_reloc
+#define RELSZ sizeof(RELOC)
+
+#define RELOC_REL32	20	/* 32-bit PC-relative address */
+#define RELOC_ADDR32	6	/* 32-bit absolute address */
+
+#define DEFAULT_DATA_SECTION_ALIGNMENT 4
+#define DEFAULT_BSS_SECTION_ALIGNMENT 4
+#define DEFAULT_TEXT_SECTION_ALIGNMENT 4
+/* For new sections we havn't heard of before */
+#define DEFAULT_SECTION_ALIGNMENT 4
+
+//#endif /* !_POSIX_SOURCE */
+//#endif /* !__STRICT_ANSI__ */
+//#endif /* !__dj_ENFORCE_ANSI_FREESTANDING */
+
+#ifndef __dj_ENFORCE_FUNCTION_CALLS
+#endif /* !__dj_ENFORCE_FUNCTION_CALLS */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !__dj_include_coff_h_ */

reactos/include/ddk/cfgtypes.h

@@ -0,0 +1,72 @@
+
+// registry key structures
+
+
+typedef struct _KEY_BASIC_INFORMATION {
+    LARGE_INTEGER LastWriteTime;
+    ULONG   TitleIndex;
+    ULONG   NameLength;
+    WCHAR   Name[1];           // variable size
+} KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;
+
+typedef struct _KEY_NODE_INFORMATION {
+    LARGE_INTEGER LastWriteTime;
+    ULONG   TitleIndex;
+    ULONG   ClassOffset;
+    ULONG   ClassLength;
+    ULONG   NameLength;
+    WCHAR   Name[1];            // variable size
+} KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION;
+
+typedef struct _KEY_FULL_INFORMATION {
+    LARGE_INTEGER LastWriteTime;
+    ULONG   TitleIndex;
+    ULONG   ClassOffset;
+    ULONG   ClassLength;
+    ULONG   SubKeys;
+    ULONG   MaxNameLen;
+    ULONG   MaxClassLen;
+    ULONG   Values;
+    ULONG   MaxValueNameLen;
+    ULONG   MaxValueDataLen;
+    WCHAR   Class[1];          // variable size
+} KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION;
+
+
+typedef struct _KEY_WRITE_TIME_INFORMATION {
+    LARGE_INTEGER LastWriteTime;
+} KEY_WRITE_TIME_INFORMATION, *PKEY_WRITE_TIME_INFORMATION;
+
+
+// key query value structures
+
+typedef struct _KEY_VALUE_BASIC_INFORMATION {
+    ULONG   TitleIndex;
+    ULONG   Type;
+    ULONG   NameLength;
+    WCHAR   Name[1];            // variable size
+} KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION;
+
+typedef struct _KEY_VALUE_FULL_INFORMATION {
+    ULONG   TitleIndex;
+    ULONG   Type;
+    ULONG   DataOffset;
+    ULONG   DataLength;
+    ULONG   NameLength;
+    WCHAR   Name[1];            // variable size
+} KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION;
+
+typedef struct _KEY_VALUE_PARTIAL_INFORMATION {
+    ULONG   TitleIndex;
+    ULONG   Type;
+    ULONG   DataLength;
+    UCHAR   Data[1];            // variable size
+} KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION;
+
+typedef struct _KEY_VALUE_ENTRY {
+    PUNICODE_STRING ValueName;
+    ULONG           DataLength;
+    ULONG           DataOffset;
+    ULONG           Type;
+} KEY_VALUE_ENTRY, *PKEY_VALUE_ENTRY;
+

reactos/include/ddk/dbgfuncs.h

@@ -0,0 +1,3 @@
+
+VOID DbgBreakPoint(VOID);
+ULONG DbgPrint(PCH Format,...);   

reactos/include/ddk/defines.h

@@ -0,0 +1,250 @@
+/* GENERAL DEFINITIONS ****************************************************/
+
+#include <internal/hal/irq.h>
+
+#include <ddk/kedef.h> 
+#include <ddk/iodef.h>
+
+/*
+ * PURPOSE: Number of a thread priority levels
+ */
+#define NR_PRIORITY_LEVELS (32)
+
+/*
+ * PURPOSE: Type of queue to insert a work item in
+ */
+enum
+{
+  CriticalWorkQueue,
+  DelayedWorkQueue,
+  HyperCriticalWorkQueue,
+};
+
+/*
+ * Types of memory to allocate
+ */
+enum
+{
+   NonPagedPool,
+   NonPagedPoolMustSucceed,
+   NonPagedPoolCacheAligned,
+   NonPagedPoolCacheAlignedMustS,
+   PagedPool,
+   PagedPoolCacheAligned,
+};
+   
+/*
+ * This is a list of bug check types (not MS's)
+ */
+enum
+{
+   APC_INDEX_MISMATCH = 1,
+   DEVICE_QUEUE_NOT_BUSY,
+   INVALID_AFFINITY_SET,
+   INVALID_DATA_ACCESS_TRAP,
+   INVALID_PROCESS_ATTACH_ATTEMPT,
+   INVALID_PROCESS_DEATTACH_ATTEMPT,
+   INVALID_SOFTWARE_INTERRUPT,
+   IRQL_NOT_DISPATCH_LEVEL,
+   IRQL_NOT_GREATER_OR_EQUAL,
+   NO_EXCEPTION_HANDLING_SUPPORT,
+   MAXIMUM_WAIT_OBJECTS_EXCEEDED,
+   MUTEX_LEVEL_NUMBER_VIOLATION,
+   NO_USER_MODE_CONTEXT,
+   SPIN_LOCK_ALREADY_OWNED,
+   SPIN_LOCK_NOT_OWNED,
+   THREAD_NOT_MUTEX_OWNER,
+   TRAP_CAUSE_UNKNOWN,
+   EMPTY_THREAD_REAPER_LIST,
+   CREATE_DELETE_LOCK_NOT_LOCKED,
+   LAST_CHANCE_CALLED_FROM_KMODE,
+   CID_HANDLE_CREATION,
+   CID_HANDLE_DELETION,
+   REFERENCE_BY_POINTER,
+   BAD_POOL_HEADER,
+   MEMORY_MANAGMENT,
+   PFN_SHARE_COUNT,
+   PFN_REFERENCE_COUNT,
+   NO_SPIN_LOCK_AVAILABLE,
+   KMODE_EXCEPTION_NOT_HANDLED,
+   SHARED_RESOURCE_CONV_ERROR,
+   KERNEL_APC_PENDING_DURING_EXIT,
+   QUOTA_UNDERFLOW,
+   FILE_SYSTEM,
+   FAT_FILE_SYSTEM,
+   NTFS_FILE_SYSTEM,
+   NPFS_FILE_SYSTEM,
+   CDFS_FILE_SYSTEM,
+   RDR_FILE_SYSTEM,
+   CORRUPT_ACCESS_TOKEN,
+   SECURITY_SYSTEM,
+   INCONSISTENT_IRP,
+   PANIC_STACK_SWITCH,
+   PORT_DRIVER_INTERNAL,
+   SCSI_DISK_DRIVER_INTERNAL,
+   INSTRUCTION_BUS_ERROR,
+   SET_OF_INVALID_CONTEXT,
+   PHASE0_INITIALIZATION_FAILED,
+   PHASE1_INITIALIZATION_FAILED,
+   UNEXPECTED_INITIALIZATION_CALL,
+   CACHE_MANAGER,
+   NO_MORE_IRP_STACK_LOCATIONS,
+   DEVICE_REFERENCE_COUNT_NOT_ZERO,
+   FLOPPY_INTERNAL_ERROR,
+   SERIAL_DRIVER_INTERNAL,
+   SYSTEM_EXIT_OWNED_MUTEX,
+   SYSTEM_UNWIND_PREVIOUS_USER,
+   SYSTEN_SERVICE_EXCEPTION,
+   INTERRUPT_UNWIND_ATTEMPTED,
+   INTERRUPT_EXCEPTION_NOT_HANDLED,
+   MULTIPROCESSOR_CONFIGURATION_NOT_SUPPORTED,
+   NO_MORE_SYSTEM_PTES,
+   TARGET_MDL_TOO_SMALL,
+   MUST_SUCCEED_POOL_EMPTY,
+   ATDISK_DRIVER_INTERNAL,
+   NO_SUCH_PARTITION,
+   MULTIPLE_IRP_COMPLETE_REQUESTS,
+   INSUFFICENT_SYSTEM_MAP_PAGES,
+   DEREF_UNKNOWN_LOGON_SERVICE,
+   REF_UNKNOWN_LOGON_SERVICE,
+   CANCEL_STATE_IN_COMPLETED_IRP,
+   PAGE_FAULT_WITH_INTERRUPTS_OFF,
+   IRQL_GT_ZERO_AT_SYSTEM_SERVICE,
+   STREAMS_INTERNAL_ERROR,
+   FATAL_UNHANDLED_HARD_ERROR,
+   NO_PAGES_AVAILABLE,
+   PFN_LIST_CORRUPT,
+   NDIS_INTERNAL_ERROR,
+   PAGE_FAULT_IN_NONPAGED_AREA,
+   REGISTRY_ERROR,
+   MAILSLOT_FILE_SYSTEM,
+   NO_BOOT_DEVICE,
+   LM_SERVER_INTERNAL_ERROR,
+   DATA_COHERENCY_EXCEPTION,
+   INSTRUCTION_COHERENCY_EXCEPTION,
+   XNS_INTERNAL_ERROR,
+   FTDISK_INTERNAL_ERROR,
+   PINBALL_FILE_SYSTEM,
+   CRITICAL_SERVICE_FAILED,
+   SET_ENV_VAR_FAILED,
+   HAL_INITIALIZED_FAILED,
+   UNSUPPORTED_PROCESSOR,
+   OBJECT_INITIALIZATION_FAILED,
+   SECURITY_INITIALIZATION_FAILED,
+   PROCESS_INITIALIZATION_FAILED,
+   HAL1_INITIALIZATION_FAILED,   
+};
+enum
+{
+   KBUG_NONE,
+   KBUG_ORPHANED_IRP,
+   KBUG_IO_STACK_OVERFLOW,
+   KBUG_OUT_OF_MEMORY,
+   KBUG_POOL_FREE_LIST_CORRUPT,
+     
+   /*
+    * These are well known but the actual value is unknown
+    */
+//   NO_PAGES_AVAILABLE,
+     
+   /*
+    * These are well known (MS) bug types
+    * (Reference: NT Insider 1997 - http://www.osr.com)
+    */
+   IRQL_NOT_LESS_OR_EQUAL = 0xa,
+//   KMODE_EXCEPTION_NOT_HANDLED = 0x1e,
+   UNEXPECTED_KERNEL_MODE_TRAP = 0x7f,
+   PAGE_FAULT_IN_NON_PAGED_AREA = 0x50,
+};
+
+/*
+ * PURPOSE: Object attributes
+ */
+enum
+{
+   OBJ_INHERIT = 0x1,
+   OBJ_PERMANENT = 0x2,
+   OBJ_EXCLUSIVE = 0x4,
+   OBJ_CASE_INSENSITIVE = 0x8,
+   OBJ_OPENIF = 0x10,
+};
+
+/*
+ * PURPOSE: DPC priorities
+ */
+enum
+{
+   High,
+   Medium,
+   Low,
+};
+
+/*
+ * PURPOSE: Timer types
+ */
+enum
+  {
+      NotificationTimer,
+      SynchronizationTimer,     
+  };
+   
+/*
+ * PURPOSE: Some drivers use these
+ */
+#define IN
+#define OUT
+#define OPTIONAL
+
+/*
+ * PURPOSE: Power IRP minor function numbers
+ */
+enum
+{
+   IRP_MN_QUERY_POWER,
+   IRP_MN_SET_POWER,
+   IRP_MN_WAIT_WAKE,
+   IRP_MN_QUERY_CAPABILITIES,
+   IRP_MN_POWER_SEQUENCE,
+};
+
+/*
+ * PURPOSE: Used all over
+ */
+enum
+{
+   KernelMode,
+   UserMode,
+};
+   
+/*
+ * PURPOSE: Arguments to MmProbeAndLockPages
+ */
+enum
+{
+   IoReadAccess,
+   IoWriteAccess,
+   IoModifyAccess,
+};
+
+#define MAXIMUM_VOLUME_LABEL_LENGTH (32)
+
+/*
+ * IRQ levels
+ */
+enum
+{
+   PASSIVE_LEVEL,
+     
+   /*
+    * Which order for these (only DISPATCH_LEVEL is important for now)
+    */
+   APC_LEVEL,
+   DISPATCH_LEVEL,
+     
+   /*
+    * Above here are device specific IRQ levels
+    */
+   FIRST_DEVICE_SPECIFIC_LEVEL,
+   HIGH_LEVEL = FIRST_DEVICE_SPECIFIC_LEVEL + NR_DEVICE_SPECIFIC_LEVELS,
+};
+  

reactos/include/ddk/exfuncs.h

@@ -0,0 +1,96 @@
+/* EXECUTIVE ROUTINES ******************************************************/
+
+VOID ExAcquireFastMutex(PFAST_MUTEX FastMutex);
+VOID ExAcquireFastMutexUnsafe(PFAST_MUTEX FastMutex);
+
+BOOLEAN ExAcquireResourceExclusive(PERESOURCE Resource, BOOLEAN Wait);
+BOOLEAN ExAcquireResourceExclusiveLite(PERESOURCE Resource, BOOLEAN Wait);
+BOOLEAN ExAcquireResourceSharedLite(PERESOURCE Resource, BOOLEAN Wait);
+BOOLEAN ExAcquireSharedStarveExclusive(PERESOURCE Resource, BOOLEAN Wait);
+BOOLEAN ExAcquireSharedWaitForExclusive(PERESOURCE Resource, BOOLEAN Wait);
+PVOID ExAllocateFromNPagedLookasideList(PNPAGED_LOOKASIDE_LIST LookSide);
+PVOID ExAllocateFromPagedLookasideList(PPAGED_LOOKASIDE_LIST LookSide);
+PVOID ExAllocateFromZone(PZONE_HEADER Zone);
+
+/*
+ * FUNCTION: Allocates memory from the nonpaged pool
+ * ARGUMENTS:
+ *      size = minimum size of the block to be allocated
+ *      PoolType = the type of memory to use for the block (ignored)
+ * RETURNS:
+ *      the address of the block if it succeeds
+ */
+PVOID ExAllocatePool(POOL_TYPE PoolType, ULONG size);
+
+PVOID ExAllocatePoolWithQuota(POOL_TYPE PoolType, ULONG NumberOfBytes);
+PVOID ExAllocatePoolWithQuotaTag(POOL_TYPE PoolType, ULONG NumberOfBytes,
+				 ULONG Tag);
+PVOID ExAllocatePoolWithTag(POOL_TYPE PoolType, ULONG NumberOfBytes,
+			    ULONG Tag);
+VOID ExConvertExclusiveToSharedLite(PERESOURCE Resource);
+VOID ExDeleteNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside);
+VOID ExDeletePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside);
+NTSTATUS ExDeleteResource(PERESOURCE Resource);
+NTSTATUS ExDeleteResourceLite(PERESOURCE Resource);
+NTSTATUS ExExtendZone(PZONE_HEADER Zone, PVOID Segment, ULONG SegmentSize);
+
+/*
+ * FUNCTION: Releases previously allocated memory
+ * ARGUMENTS:
+ *        block = block to free
+ */
+VOID ExFreePool(PVOID block);
+
+VOID ExFreeToNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
+				 PVOID Entry);
+VOID ExFreeToPagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside,
+				 PVOID Entry);
+PVOID ExFreeToZone(PZONE_HEADER Zone, PVOID Block);
+ERESOURCE_THREAD ExGetCurrentResourceThread(VOID);
+ULONG ExGetExclusiveWaiterCount(PERESOURCE Resource);
+ULONG ExGetSharedWaiterCount(PERESOURCE Resource);
+VOID ExInitializeFastMutex(PFAST_MUTEX FastMutex);
+VOID ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
+				     PALLOCATE_FUNCTION Allocate,
+				     PFREE_FUNCTION Free,
+				     ULONG Flags,
+				     ULONG Size,
+				     ULONG Tag,
+				     USHORT Depth);
+VOID ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside,
+				     PALLOCATE_FUNCTION Allocate,
+				     PFREE_FUNCTION Free,
+				     ULONG Flags,
+				     ULONG Size,
+				     ULONG Tag,
+				     USHORT Depth);
+NTSTATUS ExInitializeResource(PERESOURCE Resource);
+NTSTATUS ExInitializeResourceLite(PERESOURCE Resource);
+VOID ExInitializeSListHead(PSLIST_HEADER SListHead);
+VOID ExInitializeWorkItem(PWORK_QUEUE_ITEM Item,
+			  PWORKER_THREAD_ROUTINE Routine,
+			  PVOID Context);
+NTSTATUS ExInitializeZone(PZONE_HEADER Zone,
+			  ULONG BlockSize,
+			  PVOID InitialSegment,
+			  ULONG InitialSegmentSize);
+LARGE_INTEGER ExInterlockedAddLargeInteger(PLARGE_INTEGER Addend,
+					   LARGE_INTEGER Increment,
+					   PKSPIN_LOCK Lock);
+ULONG ExInterlockedAddUlong(PULONG Addend, ULONG Increment, PKSPIN_LOCK Lock);
+
+VOID ExInterlockedRemoveEntryList(PLIST_ENTRY ListHead, PLIST_ENTRY Entry,
+				  PKSPIN_LOCK Lock);
+VOID RemoveEntryFromList(PLIST_ENTRY ListHead, PLIST_ENTRY Entry);   
+PLIST_ENTRY ExInterlockedRemoveHeadList(PLIST_ENTRY Head, PKSPIN_LOCK Lock);
+
+PLIST_ENTRY ExInterlockedInsertTailList(PLIST_ENTRY ListHead,
+					PLIST_ENTRY ListEntry,
+					PKSPIN_LOCK Lock);
+
+PLIST_ENTRY ExInterlockedInsertHeadList(PLIST_ENTRY ListHead,
+					PLIST_ENTRY ListEntry,
+					PKSPIN_LOCK Lock);
+
+VOID ExQueueWorkItem(PWORK_QUEUE_ITEM WorkItem,
+		     WORK_QUEUE_TYPE QueueType);

reactos/include/ddk/extypes.h

@@ -0,0 +1,127 @@
+
+
+typedef ULONG INTERLOCKED_RESULT;
+typedef ULONG WORK_QUEUE_TYPE;
+
+typedef ULONG ERESOURCE_THREAD, *PERESOURCE_THREAD;
+
+typedef struct _OWNER_ENTRY
+{
+   ERESOURCE_THREAD OwnerThread;
+   union
+     {
+	LONG OwnerCount;
+	ULONG TableSize;
+     } a;
+} OWNER_ENTRY, *POWNER_ENTRY;
+
+typedef struct _ERESOURCE
+{
+   LIST_ENTRY SystemResourcesList;
+   POWNER_ENTRY OwnerTable;
+   SHORT ActiveCount;
+   USHORT Flag;
+   PKSEMAPHORE SharedWaiters;
+   PKEVENT ExclusiveWaiters;
+   OWNER_ENTRY OwnerThreads[2];
+   ULONG ContentionCount;
+   USHORT NumberOfSharedWaiters;
+   USHORT NumberOfExclusiveWaiters;
+   union
+     {
+	PVOID Address;
+	ULONG CreatorBackTraceIndex;
+     } a;
+   KSPIN_LOCK SpinLock;
+} ERESOURCE, *PERESOURCE;
+
+
+typedef struct 
+{
+   LONG Count;
+   struct _KTHREAD* Owner;
+   ULONG Contention;
+   KEVENT Event;
+   ULONG OldIrql;
+} FAST_MUTEX, *PFAST_MUTEX;
+
+typedef struct _ZONE_HEADER
+{
+   SINGLE_LIST_ENTRY FreeList;
+   SINGLE_LIST_ENTRY SegmentList;
+   ULONG BlockSize;
+   ULONG TotalSegmentSize;
+} ZONE_HEADER, *PZONE_HEADER;
+
+typedef struct _ZONE_SEGMENT
+{
+   SINGLE_LIST_ENTRY Entry;
+   ULONG size;
+} ZONE_SEGMENT, *PZONE_SEGMENT;
+
+typedef struct _ZONE_ENTRY
+{
+   SINGLE_LIST_ENTRY Entry;
+} ZONE_ENTRY, *PZONE_ENTRY;
+
+
+typedef VOID (*PWORKER_THREAD_ROUTINE)(PVOID Parameter);
+
+typedef struct _WORK_QUEUE_ITEM
+{
+   LIST_ENTRY Entry;
+   PWORKER_THREAD_ROUTINE Routine;
+   PVOID Context;
+} WORK_QUEUE_ITEM, *PWORK_QUEUE_ITEM;
+
+typedef PVOID (*PALLOCATE_FUNCTION)(POOL_TYPE PoolType,
+				   ULONG NumberOfBytes,
+				   ULONG Tag);
+typedef VOID (*PFREE_FUNCTION)(PVOID Buffer);
+
+typedef union _SLIST_HEADER
+{
+   ULONGLONG Alignment;
+   struct
+     {
+	SINGLE_LIST_ENTRY Next;
+	USHORT Depth;
+	USHORT Sequence;	
+     } s;
+} SLIST_HEADER, *PSLIST_HEADER;
+
+typedef struct
+{
+   SLIST_HEADER ListHead;
+   USHORT Depth;
+   USHORT Pad;
+   ULONG TotalAllocates;
+   ULONG AllocateMisses;
+   ULONG TotalFrees;
+   ULONG TotalMisses;
+   POOL_TYPE Type;
+   ULONG Tag;
+   ULONG Size;
+   PALLOCATE_FUNCTION Allocate;
+   PFREE_FUNCTION Free;
+   LIST_ENTRY ListEntry;
+   KSPIN_LOCK Lock;
+} NPAGED_LOOKASIDE_LIST, *PNPAGED_LOOKASIDE_LIST;
+
+typedef struct
+{
+   SLIST_HEADER ListHead;
+   USHORT Depth;
+   USHORT Pad;
+   ULONG TotalAllocates;
+   ULONG AllocateMisses;
+   ULONG TotalFrees;
+   ULONG TotalMisses;
+   POOL_TYPE Type;
+   ULONG Tag;
+   ULONG Size;
+   PALLOCATE_FUNCTION Allocate;
+   PFREE_FUNCTION Free;
+   LIST_ENTRY ListEntry;
+   FAST_MUTEX Lock;
+} PAGED_LOOKASIDE_LIST, *PPAGED_LOOKASIDE_LIST;

reactos/include/ddk/ioctrl.h

@@ -0,0 +1,18 @@
+#ifndef __INCLUDE_DDK_IOCTRL_H
+#define __INCLUDE_DDK_IOCTRL_H
+
+
+#define CTL_CODE(Dev, Func, Meth, Acc) ( ((Dev)<<16) | ((Acc)<<14) | ((Func)<<2) | (Meth))
+
+//  IOCTL Parameter buffering methods
+#define METHOD_BUFFERED    0
+#define METHOD_IN_DIRECT   1
+#define METHOD_OUT_DIRECT  2
+#define METHOD_NEITHER     3
+
+//  IOCTL File access type
+#define FILE_ANY_ACCESS    0
+#define FILE_READ_ACCESS   1
+#define FILE_WRITE_ACCESS  2
+
+#endif /* __INCLUDE_DDK_IOCTRL_H */

reactos/include/ddk/iodef.h

@@ -0,0 +1,301 @@
+#ifndef __INCLUDE_DDK_IODEF_H
+#define __INCLUDE_DDK_IODEF_H
+
+typedef enum _IO_QUERY_DEVICE_DESCRIPTION
+{
+   IoQueryDeviceIdentifier = 0,
+   IoQueryDeviceConfigurationData,
+   IoQueryDeviceComponentInformation,
+   IoQueryDeviceDataFormatMaximum,
+} IO_QUERY_DEVICE_DESCRIPTION, *PIO_QUERY_DEVICE_DESCRIPTION;
+
+typedef enum _CONFIGURATION_TYPE
+{
+   DiskController,
+   ParallelController,
+   MaximumType,
+} CONFIGURATION_TYPE, *PCONFIGURATION_TYPE;
+
+typedef enum _CM_RESOURCE_TYPE
+{
+   CmResourceTypePort = 1,
+   CmResourceTypeInterrupt,
+   CmResourceTypeMemory,
+   CmResourceTypeDma,
+   CmResourceTypeDeviceSpecific,
+   CmResourceTypeMaximum,
+} CM_RESOURCE_TYPE;
+
+typedef enum _CM_SHARE_DISPOSITION
+{
+   CmResourceShareDeviceExclusive = 1,
+   CmResourceShareDriverExclusive,
+   CmResourceShareShared,
+   CmResourceShareMaximum,
+} CM_SHARE_DISPOSITION;
+
+enum
+{
+   CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE,
+   CM_RESOURCE_INTERRUPT_LATCHED,
+};
+
+enum
+{
+   CM_RESOURCE_PORT_MEMORY,
+   CM_RESOURCE_PORT_IO,
+};
+
+/*
+ * PURPOSE: Irp flags
+ */
+enum
+{
+   /*
+    * Read any data from the actual backing media
+    */
+   IRP_NOCACHE,
+     
+   /*
+    * The I/O operation is performing paging
+    */
+   IRP_PAGING_IO,
+     
+   /*
+    * The IRP is for a mount operation
+    */
+   IRP_MOUNT_COMPLETION,
+     
+   /*
+    * The API expects synchronous behaviour
+    */
+   IRP_SYNCHRONOUS_API,
+     
+   /*
+    * The IRP is associated with a larger operation
+    */
+   IRP_ASSOCIATED_IRP,
+     
+   /*
+    * The AssociatedIrp.SystemBuffer field is valid
+    */
+   IRP_BUFFERED_IO,
+     
+   /*
+    * The system buffer was allocated from pool and should be deallocated 
+    * by the I/O manager
+    */
+   IRP_DEALLOCATE_BUFFER,
+     
+   /*
+    * The IRP is for an input operation
+    */
+   IRP_INPUT_OPERATION,
+     
+   /*
+    * The paging operation should complete synchronously 
+    */
+   IRP_SYNCHRONOUS_PAGING_IO,
+     
+   /*
+    * The IRP represents a filesystem create operation
+    */
+   IRP_CREATE_OPERATION,
+     
+   /*
+    * The IRP represents a filesystem read operation
+    */
+   IRP_READ_OPERATION,
+     
+   /*
+    * The IRP represents a filesystem write operation
+    */
+   IRP_WRITE_OPERATION,
+          
+   /*
+    * The IRP represents a filesystem close operation
+    */
+   IRP_CLOSE_OPERATION,
+     
+   /*
+    * Asynchronous behavior is advised but not required
+    */
+   IRP_DEFER_IO_COMPLETION,
+};
+
+/*
+ * I/O operation flags
+ */
+enum
+{
+   /*
+    * Force an access check even if opened in kernel mode
+    */
+   SL_FORCE_ACCESS_CHECK,
+     
+   /*
+    * The file being opened is a paging file
+    */
+   SL_OPEN_PAGING_FILE,
+     
+   SL_OPEN_TARGET_DIRECTORY,
+     
+   SL_CASE_SENSITIVE,
+     
+   SL_KEY_SPECIFIED,
+     
+   SL_OVERRIDE_VERIFY_VOLUME,
+     
+   SL_WRITE_THROUGH,
+     
+   SL_FT_SEQUENTIAL_WRITE,
+     
+   SL_FAIL_IMMEDIATELY,
+     
+   SL_EXCLUSIVE_LOCK,
+     
+   SL_RESTART_SCAN,
+     
+   SL_RETURN_SINGLE_ENTRY,
+     
+   SL_INDEX_SPECIFIED,
+     
+   SL_WATCH_TREE,
+     
+   SL_ALLOW_RAW_MOUNT,
+     
+   SL_PENDING_RETURNED,
+     
+};
+
+enum
+{
+   SL_INVOKE_ON_SUCCESS = 1,
+   SL_INVOKE_ON_ERROR = 2,
+   SL_INVOKE_ON_CANCEL = 4,
+};
+
+/*
+ * Possible flags for the device object flags
+ */
+enum
+{
+   DO_BUFFERED_IO = 0x1,
+   DO_DIRECT_IO   = 0x2,
+};
+
+/*
+ * Possible device types
+ */
+enum
+{
+   /*
+    * Standard define types
+    */
+   FILE_DEVICE_BEEP,
+   FILE_DEVICE_CDROM,
+   FILE_DEVICE_CONTROLLER,
+   FILE_DEVICE_DISK,
+   FILE_DEVICE_INPORT_PORT,
+   FILE_DEVICE_KEYBOARD,
+   FILE_DEVICE_MIDI_IN,
+   FILE_DEVICE_MIDI_OUT,
+   FILE_DEVICE_MOUSE,
+   FILE_DEVICE_NULL,
+   FILE_DEVICE_PARALLEL_PORT,
+   FILE_DEVICE_PRINTER,
+   FILE_DEVICE_SCANNER,
+   FILE_DEVICE_SERIAL_MOUSE_PORT,
+   FILE_DEVICE_SERIAL_PORT,
+   FILE_DEVICE_SCREEN,
+   FILE_DEVICE_TAPE,
+   FILE_DEVICE_UNKNOWN,
+   FILE_DEVICE_VIDEO,
+   FILE_DEVICE_VIRTUAL_DISK,
+   FILE_DEVICE_WAVE_IN,
+   FILE_DEVICE_WAVE_OUT,
+   FILE_DEVICE_8042_PORT,
+     
+   /*
+    * Values beyond this are reserved for ISVs
+    */
+   FILE_DEVICE_FIRST_FREE = 32768
+};
+
+
+
+/*
+ * Possible device characteristics
+ */
+enum
+{
+   FILE_REMOVABLE_MEDIA  = 0x1,
+   FILE_READ_ONLY_DEVICE = 0x2,
+   FILE_FLOPPY_DISKETTE  = 0x4,
+   FILE_WRITE_ONCE_MEDIA = 0x8,
+   FILE_REMOTE_DEVICE    = 0x10,
+};
+
+/*
+ * PURPOSE: Bus types
+ */
+enum
+{
+   Internal,
+   Isa,
+   MicroChannel,
+   TurboChannel,
+   PCIBus,
+   MaximumInterfaceType,
+};
+
+/*
+ * FIXME: These are not in the correct order
+ */
+enum
+{  
+     IRP_MJ_CREATE,
+     IRP_MJ_CREATE_NAMED_PIPE,
+     IRP_MJ_CLOSE,
+     IRP_MJ_READ,
+     IRP_MJ_WRITE,
+     IRP_MJ_QUERY_INFORMATION,
+     IRP_MJ_SET_INFORMATION,
+     IRP_MJ_QUERY_EA,
+     IRP_MJ_SET_EA,
+     IRP_MJ_FLUSH_BUFFERS,
+     IRP_MJ_QUERY_VOLUME_INFORMATION,
+     IRP_MJ_SET_VOLUME_INFORMATION,
+     IRP_MJ_DIRECTORY_CONTROL,
+     IRP_MJ_FILE_SYSTEM_CONTROL,     
+     IRP_MJ_DEVICE_CONTROL,
+     IRP_MJ_INTERNAL_DEVICE_CONTROL,
+     IRP_MJ_SHUTDOWN,
+     IRP_MJ_LOCK_CONTROL,
+     IRP_MJ_CLEANUP,
+     IRP_MJ_CREATE_MAILSLOT,
+     IRP_MJ_QUERY_SECURITY,
+     IRP_MJ_SET_SECURITY,
+     IRP_MJ_QUERY_POWER,
+     IRP_MJ_SET_POWER,
+     IRP_MJ_DEVICE_CHANGE,
+     IRP_MJ_QUERY_QUOTA,
+     IRP_MJ_SET_QUOTA,
+     IRP_MJ_PNP_POWER,
+     IRP_MJ_MAXIMUM_FUNCTION,
+};
+
+enum
+/*
+ * PURPOSE: Details about the result of a file open or create
+ */
+{
+     FILE_CREATED,
+//     FILE_OPENED,
+     FILE_OVERWRITTEN,
+     FILE_SUPERSEDED,
+     FILE_EXISTS,
+     FILE_DOES_NOT_EXIST,
+};
+
+#endif

reactos/include/ddk/iofuncs.h

@@ -0,0 +1,523 @@
+/* IO MANAGER ***************************************************************/
+
+/*
+ * FUNCTION: Registers the driver with WMI
+ * ARGUMENTS:
+ *          DeviceObject = Device to register
+ *          Action = Action to take
+ * RETURNS: Status (?)
+ */
+//NTSTATUS IoWMIRegistrationControl(DeviceObject, WMIREGACTION Action);
+ 
+/*
+ * FUNCTION: Synchronizes cancelable-state transistions for IRPs in a 
+ * multiprocessor-safe way
+ * ARGUMENTS:
+ *          Irpl = Variable to store the current IRQ level 
+ */
+VOID IoAcquireCancelSpinLock(PKIRQL Irpl);
+
+typedef IO_ALLOCATION_ACTION (*PDRIVER_CONTROL)(PDEVICE_OBJECT DeviceObject,
+					PIRP irp,
+					PVOID MapRegisterBase,
+					PVOID Context);
+
+/*
+ * FUNCTION: Allocates an adaptor object for a DMA operation on the target
+ * device
+ * ARGUMENTS:
+ *         Adaptor = Adapter channel or busmaster adapter to be allocated
+ *         DeviceObject = Target device for DMA
+ *         NumberOfMapRegisters = Number of map registers
+ *         ExecutionRoutine = Routine to be called when the adaptor is 
+ *                            available
+ *         Context = driver defined contex that will be passed to the
+ *                   execution routine
+ * RETURNS: Success or failure code
+ */
+NTSTATUS IoAllocateAdapterChannel(PADAPTER_OBJECT AdaperObject,
+				  PDEVICE_OBJECT DeviceObject,
+				  ULONG NumberOfMapRegisters,
+				  PDRIVER_CONTROL ExecutionRoutine,
+				  PVOID Context);
+
+/*
+ * FUNCTION: Sets up a call to a driver supplied controller object as 
+ * soon as it is available
+ * ARGUMENTS:
+ *        ControllerObject = Driver created controller object
+ *        DeviceObject = target device
+ *        ExecutionObject = Routine to be called
+ *        Context = Driver determined context to be based to the routine
+ */
+VOID IoAllocateController(PCONTROLLER_OBJECT ControllerObject,
+			  PDEVICE_OBJECT DeviceObject,
+			  PDRIVER_CONTROL ExecutionRoutine,
+			  PVOID Context);
+
+/*
+ * FUNCTION: Allocates an error log packet
+ * ARGUMENTS:
+ *         IoObject = Object which found the error
+ *         EntrySize = Size in bytes of the packet to be allocated
+ * RETURNS: On success a pointer to the allocated packet
+ *          On failure returns NULL
+ */
+PVOID IoAllocateErrorLogEntry(PVOID IoObject, UCHAR EntrySize);
+
+/*
+ * FUNCTION: Allocates an IRP
+ * ARGUMENTS:
+ *        StackSize = number of stack locations to allocate
+ *        ChargeQuota = Who knows
+ * RETURNS: On success the allocated IRP
+ *          On failure NULL
+ */
+PIRP IoAllocateIrp(CCHAR StackSize, BOOLEAN ChargeQuota);
+
+/*
+ * FUNCTION: Allocates an MDL large enough to map the supplied buffer
+ * ARGUMENTS:
+ *        VirtualAddress = base virtual address of the buffer to be mapped
+ *        Length = length of the buffer to be mapped
+ *        SecondaryBuffer = Whether the buffer is primary or secondary
+ *        ChargeQuota = Charge non-paged pool quota to current thread
+ *        Irp = Optional irp to be associated with the MDL
+ * RETURNS: On the success the allocated MDL
+ *          On failure NULL
+ */
+PMDL IoAllocateMdl(PVOID VirtualAddress, ULONG Length, 
+		   BOOLEAN SecondaryBuffer, BOOLEAN ChargeQuota,
+		   PIRP Irp);
+
+/*
+ * FUNCTION: Creates a symbolic link between the ARC name of a physical
+ * device and the name of the corresponding device object
+ * ARGUMENTS:
+ *        ArcName = ARC name of the device
+ *        DeviceName = Name of the device object
+ */
+VOID IoAssignArcName(PUNICODE_STRING ArcName, PUNICODE_STRING DeviceName);
+
+enum
+{
+   IO_NO_INCREMENT,
+};
+   
+/*
+ * FUNCTION: Takes a list of requested hardware resources and allocates them
+ * ARGUMENTS:
+ *        RegisterPath = 
+ *        DriverClassName = 
+ *        DriverObject = Driver object passed to the DriverEntry routine
+ *        DeviceObject = 
+ *        RequestedResources = List of resources
+ * RETURNS: 
+ */
+NTSTATUS IoAssignResources(PUNICODE_STRING RegistryPath,
+			   PUNICODE_STRING DriverClassName,
+			   PDRIVER_OBJECT DriverObject,
+			   PDEVICE_OBJECT DeviceObject,
+			   PIO_RESOURCE_REQUIREMENTS_LIST RequestedResources,
+			   PCM_RESOURCE_LIST* AllocatedResources);
+
+/*
+ * FUNCTION: Attaches the callers device object to a named target device
+ * ARGUMENTS:
+ *        SourceDevice = caller's device
+ *        TargetDevice = Name of the target device
+ *        AttachedDevice = Caller allocated storage. On return contains
+ *                         a pointer to the target device
+ * RETURNS: Success or failure code
+ */
+NTSTATUS IoAttachDevice(PDEVICE_OBJECT SourceDevice,
+			PUNICODE_STRING TargetDevice,
+			PDEVICE_OBJECT* AttachedDevice);
+
+/*
+ * FUNCTION: Obsolete
+ * ARGUMENTS:
+ *       SourceDevice = device to attach
+ *       TargetDevice = device to be attached to
+ * RETURNS: Success or failure code
+ */
+NTSTATUS IoAttachDeviceByPointer(PDEVICE_OBJECT SourceDevice,
+				 PDEVICE_OBJECT TargetDevice);
+
+/*
+ * FUNCTION: Attaches the callers device to the highest device in the chain
+ * ARGUMENTS:
+ *       SourceDevice = caller's device
+ *       TargetDevice = Device to attach
+ * RETURNS: On success the previously highest device
+ *          On failure NULL
+ */
+PDEVICE_OBJECT IoAttachDeviceToDeviceStack(PDEVICE_OBJECT SourceDevice,
+					   PDEVICE_OBJECT TargetDevice);
+
+/*
+ * FUNCTION: Builds a irp to be sent to lower level drivers
+ * ARGUMENTS:
+ *       MajorFunction = Major function code to be set in the IRP
+ *       DeviceObject = Next lower device object
+ *       Buffer = Buffer (only required for some major function codes)
+ *       Length = Length in bytes of the buffer 
+ *       StartingOffset = Starting offset on the target device
+ *       IoStatusBlock = Storage for status about the operation (optional)
+ * RETURNS: On success the IRP allocated
+ *          On failure NULL
+ */
+PIRP IoBuildAsynchronousFsdRequest(ULONG MajorFunction,
+				   PDEVICE_OBJECT DeviceObject,
+				   PVOID Buffer,
+				   ULONG Length,
+				   PLARGE_INTEGER StartingOffset,
+				   PIO_STATUS_BLOCK IoStatusBlock);
+
+/*
+ * FUNCTION: Allocates and sets up an IRP for a device control request
+ * ARGUMENTS:
+ *        IoControlCode = Type of request
+ *        DeviceObject = Target device
+ *        InputBuffer = Optional input buffer to the driver
+ *        InputBufferLength = Length of the input buffer
+ *        OutputBuffer = Optional output buffer
+ *        OutputBufferLength = Length of the output buffer
+ *        InternalDeviceIoControl = TRUE if the request is internal
+ *        Event = Initialized event for the caller to wait for the request
+ *                to be completed
+ *        IoStatusBlock = I/O status block to be set when the request is
+ *                        completed
+ * RETURNS: Returns the IRP created
+ */
+PIRP IoBuildDeviceIoControlRequest(ULONG IoControlCode,
+				   PDEVICE_OBJECT DeviceObject,
+				   PVOID InputBuffer,
+				   ULONG InputBufferLength,
+				   PVOID OutputBuffer,
+				   ULONG OutputBufferLength,
+				   BOOLEAN InternalDeviceIoControl,
+				   PKEVENT Event,
+				   PIO_STATUS_BLOCK IoStatusBlock);
+   
+
+VOID IoBuildPartialMdl(PMDL SourceMdl,
+		       PMDL TargetMdl,
+		       PVOID VirtualAddress,
+		       ULONG Length);
+
+PIRP IoBuildSynchronousFsdRequest(ULONG MajorFunction,
+				  PDEVICE_OBJECT DeviceObject,
+				  PVOID Buffer,
+				  ULONG Length,
+				  PLARGE_INTEGER StartingOffset,
+				  PKEVENT Event,
+				  PIO_STATUS_BLOCK IoStatusBlock);
+
+/*
+ * FUNCTION: Sends an irp to the next lower driver
+ */
+NTSTATUS IoCallDriver(PDEVICE_OBJECT DeviceObject, PIRP irp);
+
+BOOLEAN IoCancelIrp(PIRP Irp);
+
+NTSTATUS IoCheckShareAccess(ACCESS_MASK DesiredAccess,
+			    ULONG DesiredShareAccess,
+			    PFILE_OBJECT FileObject,
+			    PSHARE_ACCESS ShareAccess,
+			    BOOLEAN Update);
+
+/*
+ * FUNCTION: Indicates the caller has finished all processing for a given
+ * I/O request and is returning the given IRP to the I/O manager
+ * ARGUMENTS:
+ *         Irp = Irp to be cancelled
+ *         PriorityBoost = Increment by which to boost the priority of the
+ *                         thread making the request
+ */
+VOID IoCompleteRequest(PIRP Irp, CCHAR PriorityBoost);
+
+NTSTATUS IoConnectInterrupt(PKINTERRUPT* InterruptObject,
+			    PKSERVICE_ROUTINE ServiceRoutine,
+			    PVOID ServiceContext,
+			    PKSPIN_LOCK SpinLock,
+			    ULONG Vector,
+			    KIRQL Irql,
+			    KIRQL SynchronizeIrql,
+			    KINTERRUPT_MODE InterruptMode,
+			    BOOLEAN ShareVector,
+			    KAFFINITY ProcessorEnableMask,
+			    BOOLEAN FloatingSave);
+
+PCONTROLLER_OBJECT IoCreateController(ULONG Size);
+
+/*
+ * FUNCTION: Allocates memory for and intializes a device object for use for
+ * a driver
+ * ARGUMENTS:
+ *         DriverObject : Driver object passed by iomgr when the driver was
+ *                        loaded
+ *         DeviceExtensionSize : Number of bytes for the device extension
+ *         DeviceName : Unicode name of device
+ *         DeviceType : Device type
+ *         DeviceCharacteristics : Bit mask of device characteristics
+ *         Exclusive : True if only one thread can access the device at a
+ *                     time
+ * RETURNS:
+ *         Success or failure
+ *         DeviceObject : Contains a pointer to allocated device object
+ *                        if the call succeeded
+ * NOTES: See the DDK documentation for more information        
+ */
+NTSTATUS IoCreateDevice(PDRIVER_OBJECT DriverObject,
+			ULONG DeviceExtensionSize,
+			PUNICODE_STRING DeviceName,
+			DEVICE_TYPE DeviceType,
+			ULONG DeviceCharacteristics,
+			BOOLEAN Exclusive,
+                        PDEVICE_OBJECT* DeviceObject);
+
+
+PKEVENT IoCreateNotificationEvent(PUNICODE_STRING EventName,
+				  PHANDLE EventHandle);
+
+NTSTATUS IoCreateSymbolicLink(PUNICODE_STRING SymbolicLinkName,
+			      PUNICODE_STRING DeviceName);
+
+PKEVENT IoCreateSynchronizationEvent(PUNICODE_STRING EventName,
+				     PHANDLE EventHandle);
+
+NTSTATUS IoCreateUnprotectedSymbolicLink(PUNICODE_STRING SymbolicLinkName,
+					 PUNICODE_STRING DeviceName);
+
+
+VOID IoDeassignArcName(PUNICODE_STRING ArcName);
+
+VOID IoDeleteController(PCONTROLLER_OBJECT ControllerObject);
+
+VOID IoDeleteDevice(PDEVICE_OBJECT DeviceObject);
+
+NTSTATUS IoDeleteSymbolicLink(PUNICODE_STRING SymbolicLinkName);
+
+VOID IoDetachDevice(PDEVICE_OBJECT TargetDevice);
+
+VOID IoDisconnectInterrupt(PKINTERRUPT InterruptObject);
+
+BOOLEAN IoFlushAdapterBuffers(PADAPTER_OBJECT AdapterObject,
+			      PMDL Mdl,
+			      PVOID MapRegisterBase,
+			      PVOID CurrentVa,
+			      ULONG Length,
+			      BOOLEAN WriteToDevice);
+
+VOID IoFreeAdapterChannel(PADAPTER_OBJECT AdapterObject);
+VOID IoFreeController(PCONTROLLER_OBJECT ControllerObject);
+VOID IoFreeIrp(PIRP Irp);
+VOID IoFreeMapRegisters(PADAPTER_OBJECT AdapterObject,
+			PVOID MapRegisterBase,
+			ULONG NumberOfMapRegisters);
+VOID IoFreeMdl(PMDL Mdl);
+PCONFIGURATION_INFORMATION IoGetConfigurationInformation(VOID);
+
+
+/*
+ * FUNCTION: Returns a pointer to the callers stack location in the irp 
+ */
+PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(IRP* irp);
+
+struct _EPROCESS* IoGetCurrentProcess(VOID);
+
+NTSTATUS IoGetDeviceObjectPointer(PUNICODE_STRING ObjectName,
+				  ACCESS_MASK DesiredAccess,
+				  PFILE_OBJECT* FileObject,
+				  PDEVICE_OBJECT* DeviceObject);
+
+PDEVICE_OBJECT IoGetDeviceToVerify(PETHREAD Thread);
+
+PGENERIC_MAPPING IoGetFileObjectGenericMapping(VOID);
+
+ULONG IoGetFunctionCodeFromCtlCode(ULONG ControlCode);
+
+PVOID IoGetInitialStack(VOID);
+
+/*
+ * FUNCTION:  
+ */
+PIO_STACK_LOCATION IoGetNextIrpStackLocation(IRP* irp);
+
+PDEVICE_OBJECT IoGetRelatedDeviceObject(PFILE_OBJECT FileObject);
+
+VOID IoInitializeDpcRequest(PDEVICE_OBJECT DeviceObject,
+			    PIO_DPC_ROUTINE DpcRoutine);
+
+/*
+ * FUNCTION: Initalizes an irp allocated by the caller
+ * ARGUMENTS:
+ *          Irp = IRP to initalize
+ *          PacketSize = Size in bytes of the IRP
+ *          StackSize = Number of stack locations in the IRP
+ */
+VOID IoInitializeIrp(PIRP Irp, USHORT PacketSize, CCHAR StackSize);
+
+NTSTATUS IoInitializeTimer(PDEVICE_OBJECT DeviceObject,
+			   PIO_TIMER_ROUTINE TimerRoutine,
+			   PVOID Context);
+
+BOOLEAN IoIsErrorUserInduced(NTSTATUS Status);
+
+BOOLEAN IoIsTotalDeviceFailure(NTSTATUS Status);
+
+PIRP IoMakeAssociatedIrp(PIRP Irp, CCHAR StackSize);
+
+PHYSICAL_ADDRESS IoMapTransfer(PADAPTER_OBJECT AdapterObject,
+			       PMDL Mdl,
+			       PVOID MapRegisterBase,
+			       PVOID CurrentVa,
+			       PULONG Length,
+			       BOOLEAN WriteToDevice);
+
+/*
+ * FUNCTION: Marks an IRP as pending
+ * ARGUMENTS:
+ *         Irp = Irp to mark
+ * NOTE: If a driver doesn't complete the irp in its dispatch routine it
+ * must mark it pending otherwise the I/O manager will complete it on
+ * return from the dispatch routine.
+ */
+VOID IoMarkIrpPending(PIRP Irp);
+
+NTSTATUS IoQueryDeviceDescription(PINTERFACE_TYPE BusType,
+				  PULONG BusNumber,
+				  PCONFIGURATION_TYPE ControllerType,
+				  PULONG ControllerNumber,
+				  PCONFIGURATION_TYPE PeripheralType,
+				  PULONG PeripheralNumber,
+				  PIO_QUERY_DEVICE_ROUTINE CalloutRoutine,
+				  PVOID Context);
+
+VOID IoRaiseHardError(PIRP Irp, PVPB Vpb, PDEVICE_OBJECT RealDeviceObject);
+
+BOOLEAN IoRaiseHardInformationalError(NTSTATUS ErrorStatus,
+				      PUNICODE_STRING String,
+				      PKTHREAD Thread);
+
+NTSTATUS IoReadPartitionTable(PDEVICE_OBJECT DeviceObject,
+			      ULONG SectorSize,
+			      BOOLEAN ReturnedRecognizedPartitions,
+			      struct _DRIVE_LAYOUT_INFORMATION** PBuffer);
+
+VOID IoRegisterDriverReinitialization(PDRIVER_OBJECT DriverObject,
+				      PDRIVER_REINITIALIZE ReinitRoutine,
+				      PVOID Context);
+
+NTSTATUS IoRegisterShutdownNotification(PDEVICE_OBJECT DeviceObject);
+
+VOID IoReleaseCancelSpinLock(KIRQL Irql);
+
+VOID IoRemoveShareAccess(PFILE_OBJECT FileObject,
+			 PSHARE_ACCESS ShareAccess);
+
+NTSTATUS IoReportResourceUsage(PUNICODE_STRING DriverClassName,
+			       PDRIVER_OBJECT DriverObject,
+			       PCM_RESOURCE_LIST DriverList,
+			       ULONG DriverListSize,
+			       PDEVICE_OBJECT DeviceObject,
+			       PCM_RESOURCE_LIST DeviceList,
+			       ULONG DeviceListSize,
+			       BOOLEAN OverrideConflict,
+			       PBOOLEAN ConflictDetected);
+
+VOID IoRequestDpc(PDEVICE_OBJECT DeviceObject,
+		  PIRP Irp,
+		  PVOID Context);
+
+PDRIVER_CANCEL IoSetCancelRoutine(PIRP Irp, PDRIVER_CANCEL CancelRoutine);
+
+VOID IoSetCompletionRoutine(PIRP Irp,
+			    PIO_COMPLETION_ROUTINE CompletionRoutine,
+			    PVOID Context,
+			    BOOLEAN InvokeOnSuccess,
+			    BOOLEAN InvokeOnError,
+			    BOOLEAN InvokeOnCancel);
+
+VOID IoSetHardErrorOrVerifyDevice(PIRP Irp, PDEVICE_OBJECT DeviceObject);
+
+VOID IoSetNextIrpStackLocation(PIRP Irp);
+
+NTSTATUS IoSetPartitionInformation(PDEVICE_OBJECT DeviceObject,
+				   ULONG SectorSize,
+				   ULONG PartitionNumber,
+				   ULONG PartitionType);
+
+VOID IoSetShareAccess(ACCESS_MASK DesiredAccess,
+		      ULONG DesiredShareAccess,
+		      PFILE_OBJECT FileObject,
+		      PSHARE_ACCESS ShareAccess);
+
+/*
+ * FUNCTION:  Determines the size of an IRP
+ * ARGUMENTS: 
+ *           StackSize = number of stack locations in the IRP
+ * RETURNS: The size of the IRP in bytes 
+ */
+USHORT IoSizeOfIrp(CCHAR StackSize);
+
+/*
+ * FUNCTION: Dequeues the next IRP from the device's associated queue and
+ * calls its StartIo routine
+ * ARGUMENTS:
+ *          DeviceObject = Device object
+ *          Cancelable = True if IRPs in the queue can be cancelled
+ */
+VOID IoStartNextPacket(PDEVICE_OBJECT DeviceObject, BOOLEAN Cancelable);
+   
+VOID IoStartNextPacketByKey(PDEVICE_OBJECT DeviceObject, 
+			    BOOLEAN Cancelable,
+			    ULONG Key);
+
+/*
+ * FUNCTION: Calls the drivers StartIO routine with the IRP or queues it if
+ * the device is busy
+ * ARGUMENTS:
+ *         DeviceObject = Device to pass the IRP to 
+ *         Irp = Irp to be processed
+ *         Key = Optional value for where to insert the IRP
+ *         CancelFunction = Entry point for a driver supplied cancel function
+ */
+VOID IoStartPacket(PDEVICE_OBJECT DeviceObject, PIRP Irp, PULONG Key,
+		   PDRIVER_CANCEL CancelFunction);
+
+VOID IoStartTimer(PDEVICE_OBJECT DeviceObject);
+
+VOID IoStopTimer(PDEVICE_OBJECT DeviceObject);
+
+VOID IoUnregisterShutdownNotification(PDEVICE_OBJECT DeviceObject);
+
+VOID IoUpdateShareAccess(PFILE_OBJECT FileObject, PSHARE_ACCESS ShareAccess);
+
+VOID IoWriteErrorLogEntry(PVOID ElEntry);
+
+NTSTATUS IoWritePartitionTable(PDEVICE_OBJECT DeviceObject,
+			       ULONG SectorSize,
+			       ULONG SectorsPerTrack,
+			       ULONG NumberOfHeads,
+			       struct _DRIVE_LAYOUT_INFORMATION* PBuffer);
+
+typedef ULONG FS_INFORMATION_CLASS;
+
+// Preliminary guess
+NTKERNELAPI NTSTATUS IoQueryFileVolumeInformation(IN PFILE_OBJECT FileObject, 
+				  IN FS_INFORMATION_CLASS FsInformationClass, 
+						  IN ULONG Length, 
+						  OUT PVOID FsInformation, 
+						  OUT PULONG ReturnedLength);
+
+NTKERNELAPI // confirmed - Undocumented because it does not require a valid file handle 
+NTSTATUS 
+IoQueryFileInformation(
+IN PFILE_OBJECT FileObject,
+IN FILE_INFORMATION_CLASS FileInformationClass,
+IN ULONG Length,
+OUT PVOID FileInformation,
+OUT PULONG ReturnedLength
+);

reactos/include/ddk/iotypes.h

@@ -0,0 +1,581 @@
+/*
+ * 
+ */
+
+#ifndef __INCLUDE_DDK_IOTYPES_H
+#define __INCLUDE_DDK_IOTYPES_H
+
+/*
+ * These are referenced before they can be fully defined
+ */
+struct _DRIVER_OBJECT;
+struct _FILE_OBJECT;
+struct _DEVICE_OBJECT;
+struct _IRP;
+struct _IO_STATUS_BLOCK;
+
+/* SIMPLE TYPES *************************************************************/
+
+enum
+{
+   DeallocateObject,
+   KeepObject,
+};
+
+typedef ULONG INTERFACE_TYPE;
+typedef INTERFACE_TYPE* PINTERFACE_TYPE;
+
+/*
+ * FIXME: Definition needed
+ */
+typedef struct _SHARE_ACCESS
+{
+} SHARE_ACCESS, *PSHARE_ACCESS;
+
+/* FUNCTION TYPES ************************************************************/
+
+typedef VOID (*PDRIVER_REINITIALIZE)(struct _DRIVER_OBJECT* DriverObject,
+				     PVOID Context,
+				     ULONG Count);
+
+typedef NTSTATUS (*PIO_QUERY_DEVICE_ROUTINE)(PVOID Context,
+					     PUNICODE_STRING Pathname,
+					     INTERFACE_TYPE BusType,
+					     ULONG BusNumber,
+					     PKEY_VALUE_FULL_INFORMATION* BI,
+					     CONFIGURATION_TYPE ControllerType,
+					     ULONG ControllerNumber,
+					     PKEY_VALUE_FULL_INFORMATION* CI,
+					     CONFIGURATION_TYPE PeripheralType,
+					     ULONG PeripheralNumber,
+					     PKEY_VALUE_FULL_INFORMATION* PI);
+
+typedef NTSTATUS (*PIO_COMPLETION_ROUTINE)(struct _DEVICE_OBJECT* DeviceObject,
+					   struct _IRP* Irp,
+					   PVOID Context);
+
+typedef VOID (*PIO_APC_ROUTINE) (PVOID ApcContext,
+				 struct _IO_STATUS_BLOCK* IoStatusBlock,
+				 ULONG Reserved);
+
+
+/* STRUCTURE TYPES ***********************************************************/
+
+typedef struct _ADAPTER_OBJECT
+{
+} ADAPTER_OBJECT, *PADAPTER_OBJECT;
+
+/*
+ * PURPOSE: Special timer associated with each device
+ * NOTES: This is a guess
+ */
+typedef struct _IO_TIMER
+{
+   KTIMER timer;
+   KDPC dpc;
+} IO_TIMER, *PIO_TIMER;
+
+/*
+ * PURPOSE: IRP stack location
+ */
+typedef struct _IO_STACK_LOCATION
+{
+   /*
+    * Type of request
+    */
+   UCHAR MajorFunction;
+   
+   /*
+    * Further information about request type
+    */
+   UCHAR MinorFunction;
+   
+   /*
+    *
+    */
+   UCHAR Flags;
+   
+   /*
+    * FUNCTION: Various flags including for the io completion routine
+    */
+   UCHAR Control;
+   
+   /*
+    * Parameters for request
+    */
+   union
+     {
+	struct
+	  {
+	     /*
+	      * Number of bytes to be transferrred
+	      */
+	     ULONG Length;
+	     
+	     /*
+	      * Possibly used to sort incoming request (to be documented)
+	      */
+	     ULONG Key;
+	     
+	     /*
+	      * Optional starting offset for read
+	      */
+	     LARGE_INTEGER ByteOffset;
+	  } Read;
+	struct
+	  {
+	     ULONG Length;
+	     ULONG Key;
+	     LARGE_INTEGER ByteOffset;
+	  } Write;
+	struct
+	  {
+	     ULONG OutputBufferLength;
+	     ULONG InputBufferLength;
+	     ULONG IoControlCode;
+	     PVOID Type3InputBuffer;
+	  } DeviceIoControl;
+	
+     } Parameters;
+   
+   /*
+    * PURPOSE: Completion routine
+    * NOTE: If this is the nth stack location (where the 1st is passed to the
+    * highest level driver) then this is the completion routine set by
+    * the (n-1)th driver
+    */
+   PIO_COMPLETION_ROUTINE CompletionRoutine;
+   PVOID CompletionContext;
+   
+   /*
+    * Driver created device object representing the target device
+    */
+   struct _DEVICE_OBJECT* DeviceObject;
+   
+   /*
+    * File object (if any) associated with DeviceObject
+    */
+   struct _FILE_OBJECT* FileObject;
+} IO_STACK_LOCATION, *PIO_STACK_LOCATION;
+
+typedef struct _IO_STATUS_BLOCK
+{
+   /*
+    * Is the completion status
+    */
+   NTSTATUS Status;
+   
+   /*
+    * Is a request dependant value
+    */
+   ULONG Information;
+} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
+
+/*
+ * Driver entry point declaration
+ */
+typedef NTSTATUS (*PDRIVER_INITIALIZE)(struct _DRIVER_OBJECT* DriverObject,
+				       PUNICODE_STRING RegistryPath);
+
+/*
+ * Driver cancel declaration
+ */
+typedef NTSTATUS (*PDRIVER_CANCEL)(struct _DRIVER_OBJECT* DriverObject,
+				   PUNICODE_STRING RegistryPath);
+
+
+typedef struct _SECTION_OBJECT_POINTERS
+{
+   PVOID DataSectionObject;
+   PVOID SharedCacheMap;
+   PVOID ImageSectionObject;
+} SECTION_OBJECT_POINTERS, *PSECTION_OBJECT_POINTERS;
+
+typedef struct _IO_COMPLETION_CONTEXT
+{
+   PVOID Port;
+   ULONG Key;
+} IO_COMPLETION_CONTEXT, *PIO_COMPLETION_CONTEXT;
+
+#define FO_FILE_OPEN                    0x00000001
+#define FO_SYNCHRONOUS_IO               0x00000002
+#define FO_ALERTABLE_IO                 0x00000004
+#define FO_NO_INTERMEDIATE_BUFFERING    0x00000008
+#define FO_WRITE_THROUGH                0x00000010
+#define FO_SEQUENTIAL_ONLY              0x00000020
+#define FO_CACHE_SUPPORTED              0x00000040
+#define FO_NAMED_PIPE                   0x00000080
+#define FO_STREAM_FILE                  0x00000100
+#define FO_MAILSLOT                     0x00000200
+#define FO_GENERATE_AUDIT_ON_CLOSE      0x00000400
+#define FO_DIRECT_DEVICE_OPEN           0x00000800
+#define FO_FILE_MODIFIED                0x00001000
+#define FO_FILE_SIZE_CHANGED            0x00002000
+#define FO_CLEANUP_COMPLETE             0x00004000
+#define FO_TEMPORARY_FILE               0x00008000
+#define FO_DELETE_ON_CLOSE              0x00010000
+#define FO_OPENED_CASE_SENSITIVE        0x00020000
+#define FO_HANDLE_CREATED               0x00040000
+#define FO_FILE_FAST_IO_READ            0x00080000
+
+typedef struct _FILE_OBJECT
+{
+   CSHORT Type;
+   CSHORT Size;
+   struct _DEVICE_OBJECT* DeviceObject;
+   struct _VPB* Vpb;   
+   PVOID FsContext;
+   PVOID FsContext2;
+   PSECTION_OBJECT_POINTERS SectionObjectPointers;
+   PVOID PrivateCacheMap;
+   NTSTATUS FinalStatus;
+   struct _FILE_OBJECT* RelatedFileObject;
+   BOOLEAN LockOperation;
+   BOOLEAN DeletePending;
+   BOOLEAN ReadAccess;
+   BOOLEAN WriteAccess;
+   BOOLEAN DeleteAccess;
+   BOOLEAN SharedRead;
+   BOOLEAN SharedWrite;
+   BOOLEAN SharedDelete;
+   ULONG Flags;
+   UNICODE_STRING FileName;
+   LARGE_INTEGER CurrentByteOffset;
+   ULONG Waiters;
+   ULONG Busy;
+   PVOID LastLock;
+   KEVENT Lock;
+   KEVENT Event;
+   PIO_COMPLETION_CONTEXT CompletionContext;
+} FILE_OBJECT, *PFILE_OBJECT;
+
+
+typedef struct _IRP
+{
+   PMDL MdlAddress;
+   ULONG Flags;
+   union
+     {
+	struct _IRP* MasterIrp;
+	LONG IrpCount;
+	PVOID SystemBuffer;	
+     } AssociatedIrp;
+   LIST_ENTRY ThreadListEntry;
+   IO_STATUS_BLOCK IoStatus;
+   KPROCESSOR_MODE RequestorMode;
+   BOOLEAN PendingReturned;
+   BOOLEAN Cancel;
+   KIRQL CancelIrql;
+   PDRIVER_CANCEL CancelRoutine;
+   PVOID UserBuffer;
+   PVOID ApcEnvironment;
+   ULONG AllocationFlags;
+   PIO_STATUS_BLOCK UserIosb;
+   PKEVENT UserEvent;
+   union
+     {
+	struct
+	  {
+	     PIO_APC_ROUTINE UserApcRoutine;
+	     PVOID UserApcContext;
+	  } AsynchronousParameters;
+	LARGE_INTEGER AllocationSize;
+     } Overlay;
+   union
+     {
+	struct
+	  {
+	     KDEVICE_QUEUE_ENTRY DeviceQueueEntry;
+	     struct _ETHREAD* Thread;
+	     PCHAR AuxiliaryBuffer;
+	     LIST_ENTRY ListEntry;
+	     struct _IO_STACK_LOCATION* CurrentStackLocation;
+	     PFILE_OBJECT OriginalFileObject;
+	  } Overlay;	  
+	KAPC Apc;
+	ULONG CompletionKey;
+     } Tail;
+   ULONG CurrentLocation;
+   IO_STACK_LOCATION Stack[1];
+} IRP, *PIRP;
+
+
+typedef struct _VPB
+{
+   CSHORT Type;
+   CSHORT Size;
+   USHORT Flags;
+   USHORT VolumeLabelLength;
+   struct _DEVICE_OBJECT* DeviceObject;
+   struct _DEVICE_OBJECT* RealDevice;
+   ULONG SerialNumber;
+   ULONG ReferenceCount;
+   WCHAR VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH / sizeof(WCHAR)];
+} VPB, *PVPB;
+
+
+typedef struct _DEVICE_OBJECT
+{
+   CSHORT Type;
+   CSHORT Size;
+   LONG ReferenceCount;
+   struct _DRIVER_OBJECT* DriverObject;
+   struct _DEVICE_OBJECT* NextDevice;
+   struct _DEVICE_OBJECT* AttachedDevice;
+   struct _IRP* CurrentIrp;
+   PIO_TIMER Timer;
+   ULONG Flags;
+   ULONG Characteristics;
+   PVPB Vpb;
+   PVOID DeviceExtension;
+   DEVICE_TYPE DeviceType;
+   CCHAR StackSize;
+   union
+     {
+	LIST_ENTRY ListHead;
+	WAIT_CONTEXT_BLOCK Wcb;	
+     } Queue;
+   ULONG AlignmentRequirement;
+   KDEVICE_QUEUE DeviceQueue;
+   KDPC Dpc;
+   ULONG ActiveThreadCount;
+   PSECURITY_DESCRIPTOR SecurityDescriptor;
+   KEVENT DeviceLock;
+   USHORT SectorSize;
+   USHORT Spare1;
+   struct _DEVOBJ_EXTENSION* DeviceObjectExtension;
+   PVOID Reserved;
+} DEVICE_OBJECT, *PDEVICE_OBJECT;
+
+/*
+ * Dispatch routine type declaration
+ */
+typedef NTSTATUS (*PDRIVER_DISPATCH)(struct _DEVICE_OBJECT*, IRP*);
+
+/*
+ * Fast i/o routine type declaration
+ */
+typedef NTSTATUS (*PFAST_IO_DISPATCH)(struct _DEVICE_OBJECT*, IRP*);
+
+/*
+ * Dispatch routine type declaration
+ */
+typedef VOID (*PDRIVER_STARTIO)(struct _DEVICE_OBJECT*, IRP*);
+
+/*
+ * Dispatch routine type declaration
+ */
+typedef NTSTATUS (*PDRIVER_UNLOAD)(struct _DRIVER_OBJECT*);
+
+typedef struct _DRIVER_EXTENSION
+{
+   struct _DRIVER_OBJECT* DriverObject;
+   PDRIVER_ADD_DEVICE AddDevice;
+   ULONG Count;
+   UNICODE_STRING ServiceKeyName;
+} DRIVER_EXTENSION, *PDRIVER_EXTENSION;
+
+typedef struct _DRIVER_OBJECT
+{
+   /*
+    * PURPOSE: Magic values for debugging
+    */
+   CSHORT Type;
+   CSHORT Size;
+   PDEVICE_OBJECT DeviceObject;
+   ULONG Flags;
+   PVOID DriverStart;
+   ULONG DriverSize;
+   PVOID DriverSection;
+   PDRIVER_EXTENSION DriverExtension;
+   UNICODE_STRING DriverName;
+   PUNICODE_STRING HardwareDatabase;
+   PFAST_IO_DISPATCH FastIoDispatch;
+   PDRIVER_INITIALIZE DriverInit;
+   PDRIVER_STARTIO DriverStartIo;
+   PDRIVER_UNLOAD DriverUnload;
+   PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1];
+} DRIVER_OBJECT, *PDRIVER_OBJECT;
+
+
+typedef struct _CONFIGURATION_INFORMATION
+{
+   ULONG DiskCount;
+   ULONG FloppyCount;
+   ULONG CDRomCount;
+   ULONG TapeCount;
+   ULONG ScsiPortCount;
+   ULONG SerialCount;
+   ULONG ParallelCount;
+   BOOLEAN AtDiskPrimaryAddressClaimed;
+   BOOLEAN AtDiskSecondaryAddressClaimed;
+} CONFIGURATION_INFORMATION, *PCONFIGURATION_INFORMATION;
+
+typedef VOID (*PIO_DPC_ROUTINE)(PKDPC Dpc,
+				PDEVICE_OBJECT DeviceObject,
+				PIRP Irp,
+				PVOID Context);
+
+typedef VOID (*PIO_TIMER_ROUTINE)(PDEVICE_OBJECT DeviceObject,
+				  PVOID Context);
+
+#if WINDOWS_STRUCTS_DOESNT_ALREADY_DEFINE_THIS
+typedef struct _PARTITION_INFORMATION
+{
+   LARGE_INTEGER StartingOffset;
+   LARGE_INTEGER PartitionLength;
+   ULONG HiddenSectors;
+   ULONG PartitionNumber;
+   UCHAR PartitionType;
+   BOOLEAN BootIndicator;
+   BOOLEAN RecognizedPartition;
+   BOOLEAN RewritePartition;
+} PARTITION_INFORMATION, *PPARTITION_INFORMATION;
+#endif
+
+typedef struct _DRIVER_LAYOUT_INFORMATION
+{
+   ULONG PartitionCount;
+   ULONG Signature;
+   PARTITION_INFORMATION PartitionEntry[1];
+} DRIVER_LAYOUT_INFORMATION, *PDRIVER_LAYOUT_INFORMATION;
+
+
+
+
+
+typedef struct _IO_RESOURCE_DESCRIPTOR
+{
+   UCHAR Option;
+   UCHAR Type;
+   UCHAR SharedDisposition;
+   
+   /*
+    * Reserved for system use
+    */
+   UCHAR Spare1;             
+   
+   USHORT Flags;
+   
+   /*
+    * Reserved for system use
+    */
+   UCHAR Spare2;
+   
+   union
+     {
+	struct
+	  {
+	     ULONG Length;
+	     ULONG Alignment;
+	     PHYSICAL_ADDRESS MinimumAddress;
+	     PHYSICAL_ADDRESS MaximumAddress;
+	  } Port;
+	struct
+	  {
+	     ULONG Length;
+	     ULONG Alignment;
+	     PHYSICAL_ADDRESS MinimumAddress;
+	     PHYSICAL_ADDRESS MaximumAddress;
+	  } Memory;
+	struct
+	  { 
+	     ULONG MinimumVector;
+	     ULONG MaximumVector;
+	  } Interrupt;
+	struct
+	  {
+	     ULONG MinimumChannel;
+	     ULONG MaximumChannel;
+	  } Dma;
+     } u;     
+} IO_RESOURCE_DESCRIPTOR, *PIO_RESOURCE_DESCRIPTOR;
+
+typedef struct _IO_RESOURCE_LIST
+{
+   USHORT Version;
+   USHORT Revision;
+   ULONG Count;
+   IO_RESOURCE_DESCRIPTOR Descriptors[1];
+} IO_RESOURCE_LIST, *PIO_RESOURCE_LIST;
+
+typedef struct _IO_RESOURCES_REQUIREMENTS_LIST
+{
+   /*
+    * List size in bytes
+    */
+   ULONG ListSize;
+   
+   /*
+    * System defined enum for the bus
+    */
+   INTERFACE_TYPE InterfaceType;
+   
+   ULONG BusNumber;
+   ULONG SlotNumber;
+   ULONG Reserved[3];
+   ULONG AlternativeLists;
+   IO_RESOURCE_LIST List[1];   
+} IO_RESOURCES_REQUIREMENTS_LIST, *PIO_RESOURCE_REQUIREMENTS_LIST;
+
+typedef struct
+{
+   UCHAR Type;
+   UCHAR ShareDisposition;
+   USHORT Flags;
+   union
+     {
+	struct
+	  {
+	     PHYSICAL_ADDRESS Start;
+	     ULONG Length;
+	  } Port;
+	struct
+	  {
+	     ULONG Level;
+	     ULONG Vector;
+	     ULONG Affinity;
+	  } Interrupt;
+	struct
+	  {
+	     PHYSICAL_ADDRESS Start;
+	     ULONG Length;
+	  } Memory;
+	struct
+	  {
+	     ULONG Channel;
+	     ULONG Port;
+	     ULONG Reserved1;
+	  } Dma;
+	struct
+	  {
+	     ULONG DataSize;
+	     ULONG Reserved1;
+	     ULONG Reserved2;
+	  } DeviceSpecificData;
+     } u;
+} CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR;
+
+typedef struct
+{
+   USHORT Version;
+   USHORT Revision;
+   ULONG Count;
+   CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1];
+} CM_PARTIAL_RESOURCE_LIST;
+
+typedef struct
+{
+   INTERFACE_TYPE InterfaceType;
+   ULONG BusNumber;
+   CM_PARTIAL_RESOURCE_LIST PartialResourceList;
+} CM_FULL_RESOURCE_DESCRIPTOR;
+
+typedef struct
+{
+   ULONG Count;
+   CM_FULL_RESOURCE_DESCRIPTOR List[1];
+} CM_RESOURCE_LIST, *PCM_RESOURCE_LIST;
+
+
+#endif __INCLUDE_DDK_IOTYPES_H

reactos/include/ddk/kedef.h

@@ -0,0 +1,42 @@
+typedef enum _KINTERRUPT_MODE
+{
+   LevelSensitive,
+   Latched,
+} KINTERRUPT_MODE;
+
+typedef enum _EVENT_TYPE
+{
+   NotificationEvent,
+   SynchronizationEvent,
+   SemaphoreType,
+} EVENT_TYPE;
+
+typedef enum _KWAIT_REASON
+{
+   Executive,
+   FreePage,
+   PageIn,
+   PoolAllocation,
+   DelayExecution,
+   Suspended,
+   UserRequest,
+   WrExecutive,
+   WrFreePage,
+   WrPageIn,
+   WrDelayExecution,
+   WrSuspended,
+   WrUserRequest,
+   WrQueue,
+   WrLpcReceive,
+   WrLpcReply,
+   WrVirtualMemory,
+   WrPageOut,
+   WrRendezvous,
+   Spare2,
+   Spare3,
+   Spare4,
+   Spare5,
+   Spare6,
+   WrKernel,
+   MaximumWaitReason,
+} KWAIT_REASON;

reactos/include/ddk/kefuncs.h

@@ -0,0 +1,158 @@
+#ifndef __INCLUDE_DDK_KEFUNCS_H
+#define __INCLUDE_DDK_KEFUNCS_H
+
+/* KERNEL FUNCTIONS ********************************************************/
+
+struct _KAPC;
+
+void KeInitializeApc(
+	struct _KAPC *Apc,
+	PKTHREAD Thread,
+	UCHAR StateIndex,
+	PKKERNEL_ROUTINE KernelRoutine,
+	PKRUNDOWN_ROUTINE RundownRoutine,
+	PKNORMAL_ROUTINE NormalRoutine,
+	UCHAR Mode,
+	PVOID Context
+	);
+
+void KeInsertQueueApc(struct _KAPC *Apc, PVOID SystemArgument1,
+		      PVOID SystemArgument2, UCHAR Mode);
+void KeAttachProcess(struct _EPROCESS* Process);
+void KeDetachProcess(VOID);
+VOID KeDrainApcQueue(VOID);
+PKPROCESS KeGetCurrentProcess(VOID);
+
+/*
+ * FUNCTION: Acquires a spinlock so the caller can synchronize access to 
+ * data
+ * ARGUMENTS:
+ *         SpinLock = Initialized spinlock
+ *         OldIrql (OUT) = Set the previous irql on return 
+ */
+VOID KeAcquireSpinLock(PKSPIN_LOCK SpinLock, PKIRQL OldIrql);
+
+VOID KeAcquireSpinLockAtDpcLevel(PKSPIN_LOCK SpinLock);
+BOOLEAN KeCancelTimer(PKTIMER Timer);
+VOID KeClearEvent(PKEVENT Event);
+NTSTATUS KeDelayExecutionThread(KPROCESSOR_MODE WaitMode,
+				BOOLEAN Alertable,
+				PLARGE_INTEGER Internal);
+BOOLEAN KeDeregisterBugCheckCallback(PKBUGCHECK_CALLBACK_RECORD
+				     CallbackRecord);
+VOID KeEnterCriticalRegion(VOID);
+VOID KeFlushIoBuffers(PMDL Mdl, BOOLEAN ReadOperation, BOOLEAN DmaOperation);
+KIRQL KeGetCurrentIrql(VOID);
+ULONG KeGetCurrentProcessorNumber(VOID);
+ULONG KeGetDcacheFillSize(VOID);
+PKTHREAD KeGetCurrentThread(VOID);
+VOID KeInitializeCallbackRecord(PKBUGCHECK_CALLBACK_RECORD CallbackRecord);
+VOID KeInitializeDeviceQueue(PKDEVICE_QUEUE DeviceQueue);
+VOID KeInitializeDpc(PKDPC Dpc, PKDEFERRED_ROUTINE DeferredRoutine,
+		     PVOID DeferredContext);
+VOID KeInitializeEvent(PKEVENT Event, EVENT_TYPE Type, BOOLEAN State);
+VOID KeInitializeMutex(PKMUTEX Mutex, ULONG Level);
+VOID KeInitializeSemaphore(PKSEMAPHORE Semaphore, LONG Count, LONG Limit);
+VOID KeInitializeTimer(PKTIMER Timer);
+VOID KeInitializeTimerEx(PKTIMER Timer, TIMER_TYPE Type);
+BOOLEAN KeInsertByKeyDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
+				 PKDEVICE_QUEUE_ENTRY DeviceQueueEntry,
+				 ULONG SortKey);
+BOOLEAN KeInsertDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
+			    PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
+BOOLEAN KeInsertQueueDpc(PKDPC Dpc, PVOID SystemArgument1, 
+			 PVOID SystemArgument2);
+VOID KeLeaveCriticalRegion(VOID);   
+VOID KeLowerIrql(KIRQL NewIrql);
+LARGE_INTEGER KeQueryPerformanceCounter(PLARGE_INTEGER PerformanceFrequency);
+VOID KeQuerySystemTime(PLARGE_INTEGER CurrentTime);
+VOID KeQueryTickCount(PLARGE_INTEGER TickCount);
+ULONG KeQueryTimeIncrement(VOID);
+VOID KeRaiseIrql(KIRQL NewIrql, PKIRQL OldIrql);
+LONG KeReadStateEvent(PKEVENT Event);
+LONG KeReadStateMutex(PKMUTEX Mutex);
+LONG KeReadStateSemaphore(PKSEMAPHORE Semaphore);
+BOOLEAN KeReadStateTimer(PKTIMER Timer);
+BOOLEAN KeRegisterBugCheckCallback(PKBUGCHECK_CALLBACK_RECORD CallbackRecord,
+				   PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine,
+				   PVOID Buffer,
+				   ULONG Length,
+				   PUCHAR Component);
+LONG KeReleaseMutex(PKMUTEX Mutex, BOOLEAN Wait);
+LONG KeReleaseSemaphore(PKSEMAPHORE Semaphore, KPRIORITY Increment,
+			LONG Adjustment, BOOLEAN Wait);
+VOID KeReleaseSpinLock(PKSPIN_LOCK Spinlock, KIRQL NewIrql);
+VOID KeReleaseSpinLockFromDpcLevel(PKSPIN_LOCK Spinlock);
+PKDEVICE_QUEUE_ENTRY KeRemoveByKeyDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
+					      ULONG SortKey);
+PKDEVICE_QUEUE_ENTRY KeRemoveDeviceQueue(PKDEVICE_QUEUE DeviceQueue);
+BOOLEAN KeRemoveEntryDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
+				 PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
+BOOLEAN KeRemoveQueueDpc(PKDPC Dpc);
+LONG KeResetEvent(PKEVENT Event);
+LONG KeSetBasePriorityThread(PKTHREAD Thread, LONG Increment);
+LONG KeSetEvent(PKEVENT Event, KPRIORITY Increment, BOOLEAN Wait);
+KPRIORITY KeSetPriorityThread(PKTHREAD Thread, KPRIORITY Priority);
+BOOLEAN KeSetTimer(PKTIMER Timer, LARGE_INTEGER DueTime, PKDPC Dpc);
+BOOLEAN KeSetTimerEx(PKTIMER Timer, LARGE_INTEGER DueTime, LONG Period,
+		     PKDPC Dpc);
+VOID KeStallExecutionProcessor(ULONG MicroSeconds);
+BOOLEAN KeSynchronizeExecution(PKINTERRUPT Interrupt, 
+			       PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
+			       PVOID SynchronizeContext);
+NTSTATUS KeWaitForMultipleObjects(ULONG Count,
+				  PVOID Object[],
+				  WAIT_TYPE WaitType,
+				  KWAIT_REASON WaitReason,
+				  KPROCESSOR_MODE WaitMode,
+				  BOOLEAN Alertable,
+				  PLARGE_INTEGER Timeout,
+				  PKWAIT_BLOCK WaitBlockArray);
+NTSTATUS KeWaitForMutexObject(PKMUTEX Mutex, KWAIT_REASON WaitReason,
+			      KPROCESSOR_MODE WaitMode, BOOLEAN Alertable,
+			      PLARGE_INTEGER Timeout);
+NTSTATUS KeWaitForSingleObject(PVOID Object, KWAIT_REASON WaitReason,
+			       KPROCESSOR_MODE WaitMode,
+			       BOOLEAN Alertable, PLARGE_INTEGER Timeout);
+   
+/*
+ * FUNCTION: Initializes a spinlock
+ * ARGUMENTS:
+ *        SpinLock = Spinlock to initialize
+ */
+VOID KeInitializeSpinLock(PKSPIN_LOCK SpinLock);
+   
+/*
+ * FUNCTION: Sets the current irql without altering the current processor 
+ * state
+ * ARGUMENTS:
+ *          newlvl = IRQ level to set
+ * NOTE: This is for internal use only
+ */
+VOID KeSetCurrentIrql(KIRQL newlvl);
+
+
+/*
+ * FUNCTION: Brings the system down in a controlled manner when an 
+ * inconsistency that might otherwise cause corruption has been detected
+ * ARGUMENTS:
+ *           BugCheckCode = Specifies the reason for the bug check
+ *           BugCheckParameter[1-4] = Additional information about bug
+ * RETURNS: Doesn't
+ */
+VOID KeBugCheckEx(ULONG BugCheckCode,
+		  ULONG BugCheckParameter1,
+		  ULONG BugCheckParameter2,
+		  ULONG BugCheckParameter3,
+		  ULONG BugCheckParameter4);
+
+/*
+ * FUNCTION: Brings the system down in a controlled manner when an 
+ * inconsistency that might otherwise cause corruption has been detected
+ * ARGUMENTS:
+ *           BugCheckCode = Specifies the reason for the bug check
+ * RETURNS: Doesn't
+ */
+VOID KeBugCheck(ULONG BugCheckCode);
+
+#endif /* __INCLUDE_DDK_KEFUNCS_H */

reactos/include/ddk/ketypes.h

@@ -0,0 +1,299 @@
+/* KERNEL TYPES **************************************************************/
+
+#ifndef __INCLUDE_DDK_KETYPES_H
+#define __INCLUDE_DDK_KETYPES_H
+
+struct _KMUTANT;
+
+typedef LONG KPRIORITY;
+   
+typedef VOID (*PKBUGCHECK_CALLBACK_ROUTINE)(PVOID Buffer, ULONG Length);
+typedef BOOLEAN (*PKSYNCHRONIZE_ROUTINE)(PVOID SynchronizeContext);
+
+struct _KAPC;
+
+typedef VOID (*PKNORMAL_ROUTINE)(PVOID NormalContext,
+				 PVOID SystemArgument1,
+				 PVOID SystemArgument2);
+typedef VOID (*PKKERNEL_ROUTINE)(struct _KAPC* Apc,
+				PKNORMAL_ROUTINE* NormalRoutine,
+				PVOID* NormalContext,
+				PVOID* SystemArgument1,
+				PVOID* SystemArgument2);
+	      
+typedef VOID (*PKRUNDOWN_ROUTINE)(struct _KAPC* Apc);	      
+
+typedef struct
+/*
+ * PURPOSE: Object describing the wait a thread is currently performing
+ */
+{
+   LIST_ENTRY WaitListEntry;
+   struct _KTHREAD* Thread;
+   PVOID Object;
+   struct _KWAIT_BLOCK* NextWaitBlock;
+   USHORT WaitKey;
+   USHORT WaitType;
+} KWAIT_BLOCK, *PKWAIT_BLOCK;
+
+typedef struct _DISPATCHER_HEADER
+{
+   UCHAR Type;
+   UCHAR Absolute;
+   UCHAR Size;
+   UCHAR Inserted;
+   LONG SignalState;
+   LIST_ENTRY WaitListHead;
+} DISPATCHER_HEADER;
+
+struct _KDPC;
+
+typedef struct _KTIMER
+{
+   /*
+    * Pointers to maintain the linked list of activated timers
+    */
+   LIST_ENTRY entry;
+   
+   /*
+    * Absolute expiration time in system time units
+    */
+   signed long long expire_time;
+
+   /*
+    * Optional dpc associated with the timer 
+    */
+   struct _KDPC* dpc;
+   
+   /*
+    * True if the timer is signaled
+    */
+   BOOLEAN signaled;
+   
+   /*
+    * True if the timer is in the system timer queue
+    */
+   BOOLEAN running;
+   
+   /*
+    * Type of the timer either Notification or Synchronization
+    */
+   TIMER_TYPE type;
+   
+   /*
+    * Period of the timer in milliseconds (zero if once-only)
+    */
+   ULONG period;
+   
+} KTIMER, *PKTIMER;
+
+struct _KSPIN_LOCK;
+
+typedef struct _KSPIN_LOCK
+{
+   KIRQL irql;
+} KSPIN_LOCK, *PKSPIN_LOCK;
+
+typedef struct _KDEVICE_QUEUE
+{
+   LIST_ENTRY ListHead;
+   BOOLEAN Busy;
+   KSPIN_LOCK Lock;
+} KDEVICE_QUEUE, *PKDEVICE_QUEUE;
+
+#if RIGHT_DEFINITION_PROVIDED_ABOVE
+#define _KTHREAD _ETHREAD
+
+typedef struct _KTHREAD
+/*
+ * PURPOSE: Describes a thread of execution
+ */
+{
+   CSHORT Type;
+   CSHORT Size;
+ 
+   /*
+    * PURPOSE: Head of the queue of apcs
+    */
+   LIST_ENTRY ApcQueueHead;
+   
+   /*
+    * PURPOSE: Entry in the linked list of threads
+    */
+   LIST_ENTRY Entry;
+   
+   /*
+    * PURPOSE: Current state of the thread
+    */
+   ULONG State;
+   
+   /*
+    * PURPOSE: Priority modifier of the thread
+    */
+   ULONG Priority;
+   
+   /*
+    * PURPOSE: Pointer to our process
+    */
+   struct _EPROCESS* Process;
+   
+   /*
+    * PURPOSE: Handle of our process
+    */
+   HANDLE ProcessHandle;
+   
+   /*
+    * PURPOSE: Thread affinity mask
+    */
+   ULONG AffinityMask;
+   
+   /*
+    * PURPOSE: Saved thread context
+    */
+   hal_thread_state context;
+   
+   /*
+    * PURPOSE: Timeout for the thread to be woken up
+    */
+   signed long long int wake_time;
+   
+} KTHREAD, *PKTHREAD, *PETHREAD;
+#endif
+
+	      
+typedef struct _KAPC
+{
+   CSHORT Type;
+   CSHORT Size;
+   ULONG Spare0;
+   struct _KTHREAD* Thread;
+   LIST_ENTRY ApcListEntry;
+   PKKERNEL_ROUTINE KernelRoutine;
+   PKRUNDOWN_ROUTINE RundownRoutine;
+   PKNORMAL_ROUTINE NormalRoutine;
+   PVOID NormalContext;
+   PVOID SystemArgument1;
+   PVOID SystemArgument2;
+   CCHAR ApcStateIndex;
+   KPROCESSOR_MODE ApcMode;
+   BOOLEAN Inserted;
+} KAPC, *PKAPC;
+
+typedef struct
+{
+   LIST_ENTRY Entry;
+   PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine;
+   PVOID Buffer;
+   ULONG Length;
+   PUCHAR Component;
+   ULONG Checksum;
+   UCHAR State;
+} KBUGCHECK_CALLBACK_RECORD, *PKBUGCHECK_CALLBACK_RECORD;
+   
+typedef struct
+{
+   DISPATCHER_HEADER Header;
+   LIST_ENTRY MutantListEntry;
+   struct _KTHREAD* OwnerThread;
+   BOOLEAN Abandoned;
+   UCHAR ApcDisable;
+} KMUTEX, *PKMUTEX;
+   
+typedef struct
+{
+   DISPATCHER_HEADER Header;
+   LONG Limit;
+} KSEMAPHORE, *PKSEMAPHORE; 
+
+typedef struct _KEVENT
+/*
+ * PURPOSE: Describes an event
+ */
+{
+   /*
+    * PURPOSE: So we can use the general wait routine
+    */
+   DISPATCHER_HEADER Header;
+} KEVENT, *PKEVENT;
+
+
+
+typedef VOID (*PDRIVER_ADD_DEVICE)(VOID);
+
+struct _KDPC;
+
+/*
+ * PURPOSE: Defines a delayed procedure call routine
+ * NOTE:
+ *      Dpc = The associated DPC object
+ *      DeferredContext = Driver defined context for the DPC
+ *      SystemArgument[1-2] = Undocumented. 
+ * 
+ */
+typedef VOID (*PKDEFERRED_ROUTINE)(struct _KDPC* Dpc, PVOID DeferredContext, 
+			   PVOID SystemArgument1, PVOID SystemArgument2);
+
+typedef struct _KDPC
+/*
+ * PURPOSE: Defines a delayed procedure call object
+ */
+{
+   /*
+    * PURPOSE: Magic value to check this is the current object type
+    */
+   SHORT Type;
+   
+   /*
+    * PURPOSE: Target processor or zero if untargetted
+    */
+   UCHAR Number;
+   
+   /*
+    * PURPOSE: Indication of desired latency before exection
+    */
+   UCHAR Importance;
+   
+   LIST_ENTRY DpcListEntry; 
+   PKDEFERRED_ROUTINE DeferredRoutine;
+   PVOID DeferredContext;
+   PVOID SystemArgument1;
+   PVOID SystemArgument2;
+   
+   /*
+    * PURPOSE: If non-zero then already in queue
+    */
+   PULONG Lock;
+   
+} KDPC, *PKDPC;
+
+
+
+typedef struct _KDEVICE_QUEUE_ENTRY
+{
+   LIST_ENTRY Entry;
+   ULONG Key;
+} KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY;
+
+typedef struct _WAIT_CONTEXT_BLOCK
+{
+} WAIT_CONTEXT_BLOCK, *PWAIT_CONTEXT_BLOCK;
+
+struct _KINTERRUPT;
+
+typedef BOOLEAN (*PKSERVICE_ROUTINE)(struct _KINTERRUPT* Interrupt, 
+			     PVOID ServiceContext);
+
+typedef struct _KINTERRUPT
+{
+   ULONG Vector;
+   KAFFINITY ProcessorEnableMask;
+   PKSPIN_LOCK IrqLock;
+   BOOLEAN Shareable;
+   BOOLEAN FloatingSave;
+   PKSERVICE_ROUTINE ServiceRoutine;
+   PVOID ServiceContext;
+   LIST_ENTRY Entry;
+   KIRQL SynchLevel;
+} KINTERRUPT, *PKINTERRUPT;
+
+#endif /* __INCLUDE_DDK_KETYPES_H */

reactos/include/ddk/mmfuncs.h

@@ -0,0 +1,297 @@
+/* MEMORY MANAGMENT ******************************************************/
+
+#include <internal/hal/page.h>
+
+/*
+ * FUNCTION: Determines if the given virtual address is page aligned
+ */
+#define IS_PAGE_ALIGNED(Va) (((ULONG)Va)&0xfff)
+
+/*
+ * PURPOSE: Returns the byte offset of a field within a structure
+ */
+#define FIELD_OFFSET(Type,Field) (LONG)(&(((Type *)(0))->Field))
+
+/*
+ * PURPOSE: Returns the base address structure if the caller knows the 
+ * address of a field within the structure
+ * ARGUMENTS:
+ *          Address = address of the field
+ *          Type = Type of the whole structure
+ *          Field = Name of the field whose address is none
+ */
+#define CONTAINING_RECORD(Address,Type,Field) (Type *)(((LONG)Address) - FIELD_OFFSET(Type,Field))
+
+/*
+ * FUNCTION: Returns the number of pages spanned by an address range
+ * ARGUMENTS:
+ *          Va = start of range
+ *          Size = Size of range
+ * RETURNS: The number of pages
+ */
+extern inline unsigned int ADDRESS_AND_SIZE_TO_SPAN_PAGES(PVOID Va,
+							  ULONG Size)
+{
+   ULONG HighestAddr;
+   ULONG LowestAddr;
+   
+   HighestAddr = PAGE_ROUND_UP(Size + ((ULONG)Va));
+   LowestAddr = PAGE_ROUND_DOWN((ULONG)Va);
+   return((HighestAddr - LowestAddr) / PAGESIZE);
+}
+
+/*
+ * FUNCTION: Returns FALSE is the pointer is NULL, TRUE otherwise
+ */
+#define ARGUMENT_PRESENT(arg) ((arg)!=NULL)
+
+/*
+ * FUNCTION: Returns the byte offset of the address within its page
+ */
+#define BYTE_OFFSET(va) (((ULONG)va)%PAGESIZE)
+
+/*
+ * FUNCTION: Takes a count in bytes and returns the number of pages
+ * required to hold it
+ */
+#define BYTES_TO_PAGES(size) (?)
+
+/*
+ * FUNCTION: Allocates a range of physically contiguous cache aligned 
+ * memory from the non-paged pool
+ * ARGUMENTS:
+ *          NumberOfBytes = Size of the memory block to allocate
+ *          HighestAcceptableAddress = Highest address valid for the caller
+ * RETURNS: The virtual address of the memory block on success
+ *          NULL on error
+ */
+PVOID MmAllocateContiguousMemory(ULONG NumberOfBytes,
+				 PHYSICAL_ADDRESS HighestAcceptableAddress);
+
+/*
+ * FUNCTION: Allocates a virtual address range of noncached and cache
+ * aligned memory
+ * ARGUMENTS:
+ *         NumberOfBytes = Size of region to allocate
+ * RETURNS: The base address of the range on success
+ *          NULL on failure
+ */
+PVOID MmAllocateNonCachedMemory(ULONG NumberOfBytes);
+
+/*
+ * FUNCTION: Fills in the corresponding physical page array for a given MDL
+ * for a buffer in nonpaged system space
+ * ARGUMENTS:
+ *        MemoryDescriptorList = MDL to fill
+ */
+VOID MmBuildMdlForNonPagedPool(PMDL MemoryDescriptorList);
+
+/*
+ * FUNCTION: Allocates and initializes an MDL
+ * ARGUMENTS:
+ *        MemoryDescriptorList = Optional caller allocated MDL to initalize
+ *        Base = Base virtual address for buffer
+ *        Length = Length in bytes of the buffer
+ * RETURNS: A pointer to the initalized MDL
+ */
+PMDL MmCreateMdl(PMDL MemoryDescriptorList, PVOID Base, ULONG Length);
+
+/*
+ * FUNCTION: Releases a range of physically contiguous memory allocated
+ * with MmAllocateContiguousMemory
+ * ARGUMENTS:
+ *         BaseAddress = Vritual address of the memory to be freed
+ */
+VOID MmFreeContiguousMemory(PVOID BaseAddress);
+
+/*
+ * FUNCTION: Releases a range of noncached memory allocated with 
+ * MmAllocateNonCachedMemory
+ * ARGUMENTS:
+ *         BaseAddress = Virtual address to be freed
+ *         NumberOfBytes = size of the region to be freed
+ */
+VOID MmFreeNonCachedMemory(PVOID BaseAddress, ULONG NumberOfBytes);
+
+/*
+ * FUNCTION: Returns the length in bytes of a buffer described by an MDL
+ * ARGUMENTS:
+ *         Mdl = the mdl
+ * RETURNS: Size of the buffer 
+ */
+ULONG MmGetMdlByteCount(PMDL Mdl);
+
+/*
+ * FUNCTION: Returns the byte offset within a page of the buffer described
+ * by an MDL
+ * ARGUMENTS:
+ *         Mdl = the mdl
+ * RETURNS: The offset in bytes
+ */
+ULONG MmGetMdlByteOffset(PMDL Mdl);
+
+/*
+ * FUNCTION: Returns the initial virtual address for a buffer described
+ * by an MDL
+ * ARGUMENTS:
+ *        Mdl = the mdl
+ * RETURNS: The initial virtual address
+ */
+PVOID MmGetMdlVirtualAddress(PMDL Mdl);
+
+/*
+ * FUNCTION: Returns the physical address corresponding to a given valid
+ * virtual address
+ * ARGUMENTS:
+ *       BaseAddress = the virtual address
+ * RETURNS: The physical address
+ */
+PHYSICAL_ADDRESS MmGetPhysicalAddress(PVOID BaseAddress);
+
+/*
+ * FUNCTION: Maps the physical pages described by an MDL into system space
+ * ARGUMENTS:
+ *      Mdl = mdl
+ * RETURNS: The base system address for the mapped buffer
+ */
+PVOID MmGetSystemAddressForMdl(PMDL Mdl);
+
+/*
+ * FUNCTION: Initalizes an mdl
+ * ARGUMENTS: 
+ *       MemoryDescriptorList = MDL to be initalized
+ *       BaseVa = Base virtual address of the buffer 
+ *       Length = Length in bytes of the buffer
+ */
+VOID MmInitializeMdl(PMDL MemoryDescriptorList, PVOID BaseVa, ULONG Length);
+
+/*
+ * FUNCTION: Checks whether an address is valid for read/write
+ * ARGUMENTS:
+ *       VirtualAddress = address to be check
+ * RETURNS: TRUE if an access would be valid
+ */
+BOOLEAN MmIsAddressValid(PVOID VirtualAddress);
+
+/*
+ * FUNCTION: Checks if the current platform is a workstation or a server
+ * RETURNS: If the system is a server returns true
+ * NOTE: Drivers can use this as an estimate of the likely resources
+ * available
+ */
+BOOLEAN MmIsThisAnAsSystem(VOID);
+   
+/*
+ * FUNCTION: Locks a section of the driver's code into memory
+ * ARGUMENTS:
+ *        AddressWithinSection = Any address in the region
+ * RETURNS: A handle to the region
+ */
+PVOID MmLockPagableCodeSection(PVOID AddressWithinSection);
+
+/*
+ * FUNCTION: Locks a section of the driver's data into memory
+ * ARGUMENTS:
+ *        AddressWithinSection = Any address in the region
+ * RETURNS: A handle to the region
+ */
+PVOID MmLockPagableDataSection(PVOID AddressWithinSection);
+
+/*
+ * FUNCTION: Locks a section of memory
+ * ARGUMENTS: 
+ *         ImageSectionHandle = handle returned from MmLockPagableCodeSection
+ *                              or MmLockPagableDataSection
+ */
+VOID MmLockPagableSectionByHandle(PVOID ImageSectionHandle);
+   
+/*
+ * FUNCTION: Maps a physical memory range into system space
+ * ARGUMENTS:
+ *         PhysicalAddress = First physical address to map
+ *         NumberOfBytes = Number of bytes to map
+ *         CacheEnable = TRUE if the range can be cached
+ * RETURNS: The base virtual address which maps the region
+ */
+PVOID MmMapIoSpace(PHYSICAL_ADDRESS PhysicalAddress, ULONG NumberOfBytes,
+		   BOOLEAN CacheEnable);
+
+/*
+ * FUNCTION: Maps the pages described by a given MDL
+ * ARGUMENTS:
+ *        MemoryDescriptorList = MDL updated by MmProbeAndLockPages
+ *        AccessMode = Access mode in which to map the MDL
+ * RETURNS: The base virtual address which maps the buffer
+ */
+PVOID MmMapLockedPages(PMDL MemoryDescriptorList, KPROCESSOR_MODE AccessMode);
+
+/*
+ * FUNCTION: Makes the whole driver pageable
+ * ARGUMENTS:
+ *         AddressWithinSection = Any address within the driver
+ */
+VOID MmPageEntireDriver(PVOID AddressWithinSection);
+   
+/*
+ * FUNCTION: Resets the pageable status of a driver's sections to their
+ * compile time settings
+ * ARGUMENTS:
+ *         AddressWithinSection = Any address within the driver
+ */
+VOID MmResetDriverPaging(PVOID AddressWithinSection);
+   
+/*
+ * FUNCTION: Reinitializes a caller-allocated MDL
+ * ARGUMENTS:
+ *         Mdl = Points to the MDL that will be reused
+ */
+VOID MmPrepareMdlForReuse(PMDL Mdl);
+   
+/*
+ * FUNCTION: Probes the specified pages, makes them resident and locks
+ * the physical pages mapped by the virtual address range 
+ * ARGUMENTS:
+ *         MemoryDescriptorList = MDL which supplies the virtual address,
+ *                                byte offset and length
+ *         AccessMode = Access mode with which to probe the arguments
+ *         Operation = Types of operation for which the pages should be
+ *                     probed
+ */
+VOID MmProbeAndLockPages(PMDL MemoryDescriptorList, 
+			 KPROCESSOR_MODE AccessMode, 
+			 LOCK_OPERATION Operation);
+   
+/*
+ * FUNCTION: Returns an estimate of the amount of memory in the system
+ * RETURNS: Either MmSmallSystem, MmMediumSystem or MmLargeSystem
+ */
+MM_SYSTEM_SIZE MmQuerySystemSize(VOID);
+
+/*
+ * FUNCTION: Returns the number of bytes to allocate for an MDL 
+ * describing a given address range
+ * ARGUMENTS:
+ *          Base = Base virtual address for the region
+ *          Length = size in bytes of the region
+ * RETURNS: The number of bytes required for the MDL
+ */
+ULONG MmSizeOfMdl(PVOID Base, ULONG Length);
+   
+/*
+ * FUNCTION: Unlocks the physical pages described by a given MDL
+ * ARGUMENTS:
+ *          Mdl = Mdl to unlock
+ */
+VOID MmUnlockPages(PMDL Mdl);
+   
+/*
+ * FUNCTION: Releases a section of driver code or data previously locked into 
+ * memory
+ * ARGUMENTS: 
+ *         ImageSectionHandle = Handle for the locked section
+ */
+VOID MmUnlockPagableImageSection(PVOID ImageSectionHandle);
+
+VOID MmUnmapIoSpace(PVOID BaseAddress, ULONG NumberOfBytes);
+VOID MmUnmapLockedPages(PVOID BaseAddress, PMDL MemoryDescriptorList);
+PVOID MmAllocateSection(ULONG Length);

reactos/include/ddk/mmtypes.h

@@ -0,0 +1,35 @@
+
+enum
+{
+   MDL_MAPPED_TO_SYSTEM_VA = 0x1,
+   MDL_PAGES_LOCKED = 0x2,
+   MDL_SOURCE_IS_NONPAGED_POOL = 0x4,
+   MDL_ALLOCATED_FIXED_SIZE = 0x8,
+   MDL_PARTIAL = 0x10,
+   MDL_PARTIAL_HAS_BEEN_MAPPED = 0x20,
+   MDL_IO_PAGE_READ = 0x40,
+   MDL_WRITE_OPERATION = 0x80,
+   MDL_PARENT_MAPPED_SYSTEM_VA = 0x100,
+   MDL_LOCK_HELD = 0x200,
+   MDL_SCATTER_GATHER_VA = 0x400,
+   MDL_IO_SPACE = 0x800,
+   MDL_NETWORK_HEADER = 0x1000,
+   MDL_MAPPING_CAN_FAIL = 0x2000,
+   MDL_ALLOCATED_MUST_SUCCEED = 0x4000,
+   MDL_64_BIT_VA = 0x8000,
+};
+
+typedef struct _MDL
+/*
+ * PURPOSE: Describes a user buffer passed to a system API
+ */
+{
+   struct _MDL* Next;
+   CSHORT Size;
+   CSHORT MdlFlags;
+   struct _EPROCESS* Process;
+   PVOID MappedSystemVa;
+   PVOID StartVa;
+   ULONG ByteCount;
+   ULONG ByteOffset;
+} MDL, *PMDL;

reactos/include/ddk/ntddk.h

@@ -0,0 +1,62 @@
+/*
+ * COPYRIGHT:      See COPYING in the top level directory
+ * PROJECT:        ReactOS kernel
+ * FILE:           include/ddk/ntddk.h
+ * PURPOSE:        Interface definitions for drivers
+ * PROGRAMMER:     David Welch (welch@mcmail.com)
+ * UPDATE HISTORY:
+ *                 15/05/98: Created
+ */
+
+#ifndef __NTDDK_H
+#define __NTDDK_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* INCLUDES ***************************************************************/
+
+#include <windows.h>
+
+#define QUAD_PART(LI)  (*(LONGLONG *)(&LI))
+
+
+#define  IO_DISK_INCREMENT  4
+
+#define  FILE_WORD_ALIGNMENT  0x0001
+
+#define  FILE_OPENED          0x0001
+
+#include <ddk/status.h>
+#include <ddk/ntdef.h>
+#include <ddk/defines.h>
+#include <ddk/types.h>
+#include <ddk/cfgtypes.h>
+#include <ddk/ketypes.h>
+#include <ddk/obtypes.h>
+#include <ddk/mmtypes.h>
+#include <ddk/iotypes.h>
+#include <ddk/extypes.h>
+#include <ddk/pstypes.h>
+#include <ddk/setypes.h>
+#include <ddk/ioctrl.h>   
+#include <internal/hal/ddk.h>
+   
+#include <ddk/rtl.h>
+#include <ddk/zw.h>
+#include <ddk/exfuncs.h>
+#include <ddk/mmfuncs.h>
+#include <ddk/kefuncs.h>
+#include <ddk/iofuncs.h> 
+#include <ddk/psfuncs.h>
+#include <ddk/obfuncs.h>
+#include <ddk/dbgfuncs.h>
+      
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* __NTDDK_H */
+

reactos/include/ddk/ntdef.h

@@ -0,0 +1,10 @@
+#ifndef __INCLUDE_DDK_NTDEF_H
+#define __INCLUDE_DDK_NTDEF_H
+
+struct _KTHREAD;
+struct _ETHREAD;
+struct _EPROCESS;
+
+#define NTKERNELAPI
+
+#endif

reactos/include/ddk/obfuncs.h

@@ -0,0 +1,47 @@
+/* OBJECT MANAGER ************************************************************/
+
+/*
+ * FUNCTION: Decrements the object's reference count and performs retention
+ * checks
+ * ARGUMENTS:
+ *        Object = Object's body
+ */
+VOID ObDeferenceObject(PVOID Object);
+
+/*
+ * FUNCTION: Performs access validation on an object handle and if access
+ * is granted returns a pointer to the object's body
+ * ARGUMENTS:
+ *         Handle = Handle to the object 
+ *         DesiredAccess = Desired access to the object
+ *         ObjectType (OPTIONAL) = Pointer to the object's type definition
+ *         AccessMode = Access mode to use for the check
+ *         Object (OUT) = Caller supplied storage for a pointer to the object's
+ *                        body
+ *         HandleInformation (OUT) = Points to a structure which receives
+ *                                   information about the handle
+ * RETURNS: Status
+ */
+NTSTATUS ObReferenceObjectByHandle(HANDLE Handle,
+				   ACCESS_MASK DesiredAccess,
+				   POBJECT_TYPE ObjectType,
+				   KPROCESSOR_MODE AccessMode,
+				   PVOID* Object,
+				   POBJECT_HANDLE_INFORMATION HandleInfo);
+
+/*
+ * FUNCTION: Increments the reference count for a given object
+ * ARGUMENTS:
+ *      Object = Points to the body of the object
+ *      AccessMode = Requested access to the object
+ *      ObjectType = Pointer to the object's type definition
+ *      AccessMode = Access mode to use for the security check
+ * RETURNS: Status
+ */
+NTSTATUS ObReferenceObjectByPointer(PVOID Object,
+				    ACCESS_MASK DesiredAccess,
+				    POBJECT_TYPE ObjectType,
+				    KPROCESSOR_MODE AccessMode);
+
+NTSTATUS ObOpenObjectByName(POBJECT_ATTRIBUTES ObjectAttributes,
+			    PVOID* Object);

reactos/include/ddk/obtypes.h

@@ -0,0 +1,146 @@
+struct _DIRECTORY_OBJECT;
+
+typedef ULONG ACCESS_STATE, *PACCESS_STATE;
+
+typedef struct _OBJECT_HANDLE_INFORMATION {
+    ULONG HandleAttributes;
+    ACCESS_MASK GrantedAccess;
+} OBJECT_HANDLE_INFORMATION, *POBJECT_HANDLE_INFORMATION;
+
+struct _OBJECT;
+
+typedef struct _OBJECT_TYPE
+{   
+   /*
+    * PURPOSE: Name of the type
+    */
+   UNICODE_STRING TypeName;
+   
+   /*
+    * PURPOSE: Total number of objects of this type
+    */
+   ULONG TotalObjects;
+   
+   /*
+    * PURPOSE: Total number of handles of this type
+    */
+   ULONG TotalHandles;
+   
+   /*
+    * PURPOSE: Maximum objects of this type
+    */
+   ULONG MaxObjects;
+   
+   /*
+    * PURPOSE: Maximum handles of this type
+    */
+   ULONG MaxHandles;
+   
+   /*
+    * PURPOSE: Paged pool charge
+    */
+   ULONG PagedPoolCharge;
+   
+   /*
+    * PURPOSE: Nonpaged pool charge
+    */
+   ULONG NonpagedPoolCharge;
+   
+   /*
+    * PURPOSE: Dumps the object
+    * NOTE: To be defined
+    */
+   VOID (*Dump)(VOID);
+   
+   /*
+    * PURPOSE: Opens the object
+    * NOTE: To be defined
+    */
+   VOID (*Open)(VOID);
+   
+   /*
+    * PURPOSE: Called to close an object if OkayToClose returns true
+    */
+   VOID (*Close)(VOID);
+
+   /*
+    * PURPOSE: Called to close an object if OkayToClose returns true
+    */
+   VOID (*Delete)(VOID);
+
+   /*
+    * PURPOSE: Called when an open attempts to open a file apparently
+    * residing within the object
+    */
+   VOID (*Parse)(VOID);
+   
+   /*
+    */
+   VOID (*Security)(VOID);
+   
+   /*
+    */
+   VOID (*QueryName)(VOID);
+   
+   /*
+    * PURPOSE: Called when a process asks to close the object
+    */
+   VOID (*OkayToClose)(VOID);
+         
+} OBJECT_TYPE, *POBJECT_TYPE;
+
+
+typedef struct _OBJECT
+/*
+ * PURPOSE: Header for every object managed by the object manager
+ */
+{   
+   /*
+    * PURPOSE: Name of this entry
+    */
+   UNICODE_STRING name;
+   
+   /*
+    * PURPOSE: Our entry in our parents list of subdirectory
+    */
+   LIST_ENTRY entry;
+
+   /*
+    * PURPOSE: Number of non-handle references to this object
+    */
+   ULONG RefCount;
+   
+   /*
+    * PURPOSE: Number of handles opened to this object
+    */
+   ULONG HandleCount;
+   
+   struct _DIRECTORY_OBJECT* Parent;
+   
+   /*
+    * PURPOSE: Object type
+    * NOTE: This overlaps the first member of the object body
+    */
+   CSHORT Type;
+   
+   /*
+    * PURPOSE: Object size
+    * NOTE: This overlaps the second member of the object body
+    */
+   CSHORT Size;
+   
+   
+} OBJECT_HEADER, *POBJECT_HEADER;
+
+/*
+ * PURPOSE: Defines an object 
+ */
+typedef struct _OBJECT_ATTRIBUTES
+{
+   ULONG Length;
+   HANDLE RootDirectory;
+   PUNICODE_STRING ObjectName;
+   ULONG Attributes;
+   PVOID SecurityDescriptor;
+   PVOID SecurityQualityOfService;
+} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;

reactos/include/ddk/psfuncs.h

@@ -0,0 +1,31 @@
+
+
+
+/*
+ * FUNCTION: Creates a thread which executes in kernel mode
+ * ARGUMENTS:
+ *       ThreadHandle (OUT) = Caller supplied storage for the returned thread 
+ *                            handle
+ *       DesiredAccess = Requested access to the thread
+ *       ObjectAttributes = Object attributes (optional)
+ *       ProcessHandle = Handle of process thread will run in
+ *                       NULL to use system process
+ *       ClientId (OUT) = Caller supplied storage for the returned client id
+ *                        of the thread (optional)
+ *       StartRoutine = Entry point for the thread
+ *       StartContext = Argument supplied to the thread when it begins
+ *                     execution
+ * RETURNS: Success or failure status
+ */
+NTSTATUS PsCreateSystemThread(PHANDLE ThreadHandle,
+			      ACCESS_MASK DesiredAccess,
+			      POBJECT_ATTRIBUTES ObjectAttributes,
+			      HANDLE ProcessHandle,
+			      PCLIENT_ID ClientId,
+			      PKSTART_ROUTINE StartRoutine,
+                              PVOID StartContext);
+NTSTATUS PsTerminateSystemThread(NTSTATUS ExitStatus);
+NTSTATUS PsSuspendThread(VOID);
+NTSTATUS PsWakeThread(PETHREAD Thread);
+PETHREAD PsGetCurrentThread(VOID);
+struct _EPROCESS* PsGetCurrentProcess(VOID);

reactos/include/ddk/pstypes.h

@@ -0,0 +1,285 @@
+#ifndef __INCLUDE_DDK_PSTYPES_H
+#define __INCLUDE_DDK_PSTYPES_H
+
+#include <kernel32/heap.h>
+#include <internal/hal.h>
+
+typedef NTSTATUS (*PKSTART_ROUTINE)(PVOID StartContext);
+
+typedef struct _STACK_INFORMATION 
+{
+	PVOID 	BaseAddress;
+	PVOID	UpperAddress;
+} STACK_INFORMATION, *PSTACK_INFORMATION;
+
+typedef struct linux_sigcontext {
+        int     sc_gs;
+        int     sc_fs;
+        int     sc_es;
+        int     sc_ds;
+        int     sc_edi;
+        int     sc_esi;
+        int     sc_ebp;
+        int     sc_esp;
+        int     sc_ebx;
+        int     sc_edx;
+        int     sc_ecx;
+        int     sc_eax;
+        int     sc_trapno;
+        int     sc_err;
+        int     sc_eip;
+        int     sc_cs;
+        int     sc_eflags;
+        int     sc_esp_at_signal;
+        int     sc_ss;
+        int     sc_387;
+        int     sc_mask;
+        int     sc_cr2;
+} TRAP_FRAME, *PTRAP_FRAME;
+
+typedef ULONG THREADINFOCLASS;
+
+typedef void* ATOMTABLE;
+
+typedef struct _pPebInfo {
+	WCHAR*		WindowTitle;
+	WCHAR*		ImageFile;	
+	WCHAR*		CommandLine;
+	WCHAR*		DllPath;
+//	STARTUPINFOW	StartupInfo;
+} PEBINFO;
+
+typedef struct _LDR_ {
+	UCHAR	Initialized;
+	UCHAR	InInitializationOrderModuleList;
+	PVOID	InLoadOrderModuleList;
+	PVOID	InMemoryOrderModuleList;
+} LDR, *PLDR;
+
+
+typedef struct _NT_PEB
+{
+	UCHAR			InheritedAddressSpace;
+	UCHAR			ReadImageFileExecOptions;
+	UCHAR			BeingDebugged;
+	LONG			ImageBaseAddress; 
+	LDR			Ldr;
+	DWORD			dwTlsBits[2]; // tls in use bits 
+	WORD			NumberOfProcessors;
+	WORD			NtGlobalFlag;
+	DWORD			HeapReserve;
+	DWORD			HeapCommit;
+	DWORD			HeapDecommitFreeBlockThreshold;
+	DWORD			NumberOfHeaps;
+	DWORD			MaxiumNumberOfHeaps;
+	PEBINFO*		PebInfo; 
+	PHEAP			ProcessHeap; 
+	ATOMTABLE		LocalAtomTable;
+	LPCRITICAL_SECTION	CriticalSection;
+	DWORD			CriticalSectionTimeout; 
+	WORD			MajorVersion; 
+	WORD			MinorVersion; 
+	WORD			BuildNumber;  
+	WORD			PlatformId;	
+} NT_PEB, *PNT_PEB;	
+
+typedef struct _CLIENT_ID 
+{
+    HANDLE UniqueProcess;
+    HANDLE UniqueThread;
+} CLIENT_ID, *PCLIENT_ID;
+
+typedef struct _NT_TIB {
+    struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList;
+    PVOID StackBase;
+    PVOID StackLimit;
+    PVOID SubSystemTib;
+    union {
+        PVOID FiberData;
+        ULONG Version;
+    } Fib;
+    PVOID ArbitraryUserPointer;
+    struct _NT_TIB *Self;
+} NT_TIB, *PNT_TIB;
+
+typedef struct _NT_TEB
+{
+
+	NT_TIB			Tib; 
+	CLIENT_ID		Cid;
+	HANDLE			RPCHandle;
+	PVOID	 		TlsData;
+	NT_PEB			*pPeb;   
+	DWORD			LastErrorCode;
+	NTSTATUS		LastStatusValue; 
+	DWORD			LockCount;
+	UCHAR			HardErrorMode;
+	
+} NT_TEB;
+
+typedef struct _KTHREAD 
+{
+	DISPATCHER_HEADER 	DispatcherHeader;
+	TIME			ElapsedTime;
+	TIME			KernelTime;
+	TIME			UserTime;
+	STACK_INFORMATION	StackInformation;
+	PVOID			ServiceDescriptorTable;  // points to KeServiceDescriptorTable
+	KAFFINITY		Affinity;
+	KPRIORITY		CurrentPriority;
+	KPRIORITY		BasePriority;
+	ULONG			Quantum;
+	UCHAR			ThreadState; //Thread state is a typeless enum, otherwise it should be const integer
+	ULONG			FreezeCount;
+	ULONG			SuspendCount;
+	PTRAP_FRAME		TrapFrame; 
+	PVOID			*Tls;
+	KWAIT_BLOCK		WaitBlock[4];	
+	struct _KMUTANT*			MutantList;
+	PLIST_ENTRY		ApcList;
+	UCHAR			KernelApcDisable;
+	KTIMER			TimerBlock;
+	KDEVICE_QUEUE		DeviceQueue;
+	NT_TEB*			Teb;
+   
+        /*
+	 * PURPOSE: CPU state
+	 * NOTE: I have temporarily added this to give somewhere to store
+	 * cpu state when the thread isn't running
+	 */
+        hal_thread_state                   Context;
+        LIST_ENTRY Entry;
+} KTHREAD, *PKTHREAD;
+
+
+// According to documentation the stack should have a commited [ 1 page ] and
+// a reserved part [ 1 M ].
+
+typedef struct _INITIAL_TEB {
+	PVOID StackCommit;
+	PVOID StackReserved;
+} INITIAL_TEB, *PINITIAL_TEB;
+
+
+
+
+//ThreadState defines the current state of a thread
+//FIXME I am allready defined in psmgr.h as a enum
+/*
+enum 
+{
+	THREAD_STATE_INITIALIZED = 0,
+	THREAD_STATE_READY,
+	THREAD_STATE_RUNNING,
+	THREAD_STATE_STANDBY,		
+	THREAD_STATE_TERMINATED,
+	THREAD_STATE_WAIT,		
+	THREAD_STATE_TRANSITION,	
+	THREAD_STATE_RESERVED 	
+};
+*/
+
+// wait reason only applies for threads in a wait state
+// part of this enum is double ???? 
+
+/*
+typedef _KWAIT_REASON
+{
+	WAIT_EXCECUTIVE1 = 0,
+	WAIT_FREE_PAGE1,
+	WAIT_PAGE_IN1,
+	WAIT_POOL_ALLOCATION1,
+	WAIT_EXECUTION_DELAY1,
+	WAIT_SUSPENDED_CONDITION1,
+	WAIT_USER_REQUEST1,
+	WAIT_EXCECUTIVE2, 
+	WAIT_FREE_PAGE2,
+	WAIT_PAGE_IN2,
+	WAIT_POOL_ALLOCATION2,
+	WAIT_EXECUTION_DELAY2,
+	WAIT_SUSPENDED_CONDITION2,
+	WAIT_USER_REQUEST2,
+	WAIT_EVENT_PAIR_HIGH,
+	WAIT_EVENT_PAIR_LOW, 
+	WAIT_LPC_RECEIVE,
+	WAIT_LPC_REPLY,
+	WAIT_VIRTUAL_MEMORY,
+	WAIT_PAGE_OUT
+} KWAIT_REASON;	
+
+*/
+
+
+// TopLevelIrp can be one of the following values:
+// FIXME I belong somewhere else
+
+#define 	FSRTL_FSP_TOP_LEVEL_IRP			(0x01)
+#define 	FSRTL_CACHE_TOP_LEVEL_IRP		(0x02)
+#define 	FSRTL_MOD_WRITE_TOP_LEVEL_IRP		(0x03)
+#define		FSRTL_FAST_IO_TOP_LEVEL_IRP		(0x04)
+#define		FSRTL_MAX_TOP_LEVEL_IRP_FLAG		(0x04)
+
+typedef struct _TOP_LEVEL_IRP
+{
+	PIRP TopLevelIrp;
+	ULONG TopLevelIrpConst;
+} TOP_LEVEL_IRP;
+
+typedef struct _ETHREAD {
+	KTHREAD			Tcb;
+	TIME			CreateTime;
+	TIME			ExitTime;
+	NTSTATUS		ExitStatus;
+	LIST_ENTRY		PostBlockList;
+	LIST_ENTRY		TerminationPortList;  
+	ULONG			ActiveTimerListLock;
+	PVOID			ActiveTimerListHead;
+	CLIENT_ID		Cid;
+	PLARGE_INTEGER		LpcReplySemaphore;
+	PVOID			LpcReplyMessage;
+	PLARGE_INTEGER		LpcReplyMessageId;
+	PVOID			ImpersonationInfo;
+	LIST_ENTRY		IrpList; //
+	TOP_LEVEL_IRP		TopLevelIrp;
+	ULONG			ReadClusterSize;
+	UCHAR			ForwardClusterOnly;
+	UCHAR			DisablePageFaultClustering;
+	UCHAR			DeadThread;
+	UCHAR			HasTerminated;
+	ACCESS_MASK		GrantedAccess;
+	struct _EPROCESS*	ThreadsProcess;
+	PKSTART_ROUTINE		StartAddress;
+	LPTHREAD_START_ROUTINE  Win32StartAddress; // Should Specify a win32 start func
+	UCHAR 			LpcExitThreadCalled;
+	UCHAR 			HardErrorsAreDisabled;
+} ETHREAD, *PETHREAD;
+
+
+typedef struct _KPROCESS {
+	DISPATCHER_HEADER 	DispatcherHeader;
+	PVOID			PageTableDirectory; // FIXME: I shoud point to a PTD
+	TIME			ElapsedTime;
+	TIME			KernelTime;
+	TIME			UserTime;
+	LIST_ENTRY		InOutSwap;   // ??	
+	KSPIN_LOCK		SpinLock;
+	KAFFINITY		Affinity;
+	ULONG			StackCount;
+	KPRIORITY		BasePriority;
+	ULONG			DefaultThreadQuantum;
+	UCHAR			ProcessState;
+	ULONG			ThreadSeed;
+	UCHAR			DisableBoost;
+   
+   /*
+    * Added by David Welch (welch@mcmail.com)
+    */
+   LIST_ENTRY MemoryAreaList;
+} KPROCESS, *PKPROCESS;
+
+typedef struct _EPROCESS
+{
+   KPROCESS Pcb;
+} EPROCESS, *PEPROCESS;
+
+#endif /* __INCLUDE_DDK_PSTYPES_H */

reactos/include/ddk/rtl.h

@@ -0,0 +1,323 @@
+/*
+ * 
+ */
+
+#ifndef __DDK_RTL_H
+#define __DDK_RTL_H
+
+typedef struct _CONTROLLER_OBJECT
+{
+   CSHORT Type;
+   CSHORT Size;   
+   PVOID ControllerExtension;
+   KDEVICE_QUEUE DeviceWaitQueue;
+   ULONG Spare1;
+   LARGE_INTEGER Spare2;
+} CONTROLLER_OBJECT, *PCONTROLLER_OBJECT;
+   
+typedef struct _STRING
+{
+   /*
+    * Length in bytes of the string stored in buffer
+    */
+   USHORT Length;
+   
+   /*
+    * Maximum length of the string 
+    */
+   USHORT MaximumLength;
+   
+   /*
+    * String
+    */
+   PCHAR Buffer;
+} STRING, *PSTRING;
+
+typedef struct _ANSI_STRING
+{
+   /*
+    * Length in bytes of the string stored in buffer
+    */
+   USHORT Length;
+   
+   /*
+    * Maximum length of the string 
+    */
+   USHORT MaximumLength;
+   
+   /*
+    * String
+    */
+   PCHAR Buffer;
+} ANSI_STRING, *PANSI_STRING;
+
+typedef struct _TIME_FIELDS
+{
+   CSHORT Year;
+   CSHORT Month;
+   CSHORT Day;
+   CSHORT Hour;
+   CSHORT Minute;
+   CSHORT Second;
+   CSHORT Milliseconds;
+   CSHORT Weekday;
+} TIME_FIELDS, *PTIME_FIELDS;
+
+/*
+ * PURPOSE: Flags for RtlQueryRegistryValues
+ */
+enum
+{
+   RTL_QUERY_REGISTRY_SUBKEY,
+   RTL_QUERY_REGISTRY_TOPKEY,
+   RTL_QUERY_REGISTRY_REQUIRED,
+   RTL_QUERY_REGISTRY_NOVALUE,
+   RTL_QUERY_REGISTRY_NOEXPAND,
+   RTL_QUERY_REGISTRY_DIRECT,
+   RTL_QUERY_REGISTRY_DELETE,
+};
+
+typedef NTSTATUS (*PRTL_QUERY_REGISTRY_ROUTINE)(PWSTR ValueName,
+						ULONG ValueType,
+						PVOID ValueData,
+						ULONG ValueLength,
+						PVOID Context,
+						PVOID EntryContext);
+
+typedef struct _RTL_QUERY_REGISTRY_TABLE
+{
+   PRTL_QUERY_REGISTRY_ROUTINE QueryRoutine;
+   ULONG Flags;
+   PWSTR Name;
+   PVOID EntryContext;
+   ULONG DefaultType;
+   PVOID DefaultData;
+   ULONG DefaultLength;
+} RTL_QUERY_REGISTRY_TABLE, *PRTL_QUERY_REGISTRY_TABLE;
+
+/*
+ * PURPOSE: Used with RtlCheckRegistryKey, RtlCreateRegistryKey, 
+ * RtlDeleteRegistryKey
+ */
+enum
+{
+   RTL_REGISTRY_ABSOLUTE,
+   RTL_REGISTRY_SERVICES,
+   RTL_REGISTRY_CONTROL,
+   RTL_REGISTRY_WINDOWS_NT,
+   RTL_REGISTRY_DEVICEMAP,
+   RTL_REGISTRY_USER,
+   RTL_REGISTRY_OPTIONAL,
+   RTL_REGISTRY_VALUE,
+};
+
+/*
+ * FUNCTION: Sets up a parameter of type OBJECT_ATTRIBUTES for a 
+ * subsequent call to ZwCreateXXX or ZwOpenXXX
+ * ARGUMENTS:
+ *        InitializedAttributes (OUT) = Caller supplied storage for the
+ *                                      object attributes
+ *        ObjectName = Full path name for object
+ *        Attributes = Attributes for the object
+ *        RootDirectory = Where the object should be placed or NULL
+ *        SecurityDescriptor = Ignored
+ */
+VOID InitializeObjectAttributes(POBJECT_ATTRIBUTES InitializedAttributes,
+				PUNICODE_STRING ObjectName,
+				ULONG Attributes,
+				HANDLE RootDirectory,
+                                PSECURITY_DESCRIPTOR SecurityDescriptor);
+
+VOID InitializeListHead(PLIST_ENTRY ListHead);
+VOID InsertHeadList(PLIST_ENTRY ListHead, PLIST_ENTRY Entry);
+VOID InsertTailList(PLIST_ENTRY ListHead, PLIST_ENTRY Entry);
+BOOLEAN IsListEmpty(PLIST_ENTRY ListHead);
+PSINGLE_LIST_ENTRY PopEntryList(PSINGLE_LIST_ENTRY ListHead);
+VOID PushEntryList(PSINGLE_LIST_ENTRY ListHead, PSINGLE_LIST_ENTRY Entry);
+VOID RemoveEntryList(PLIST_ENTRY Entry);
+PLIST_ENTRY RemoveHeadList(PLIST_ENTRY ListHead);
+PLIST_ENTRY RemoveTailList(PLIST_ENTRY ListHead);
+ULONG RtlAnsiStringToUnicodeSize(PANSI_STRING AnsiString);
+NTSTATUS RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString,
+				      PANSI_STRING SourceString,
+				      BOOLEAN AllocateDestinationString);
+NTSTATUS RtlAppendUnicodeStringToString(PUNICODE_STRING Destination,
+					PUNICODE_STRING Source);
+NTSTATUS RtlAppendUnicodeToString(PUNICODE_STRING Destination,
+				  PWSTR Source);
+NTSTATUS RtlCharToInteger(PCSZ String, ULONG Base, PULONG Value);
+NTSTATUS RtlCheckRegistryKey(ULONG RelativeTo, PWSTR Path);
+ULONG RtlCompareMemory(PVOID Source1, PVOID Source2, ULONG Length);
+LONG RtlCompareString(PSTRING String1, PSTRING String2, 
+		      BOOLEAN CaseInsensitive);
+LONG RtlCompareUnicodeString(PUNICODE_STRING String1,
+			     PUNICODE_STRING String2,
+			     BOOLEAN BaseInsensitive);
+LARGE_INTEGER RtlConvertLongToLargeInteger(LONG SignedInteger);
+LARGE_INTEGER RtlConvertUlongToLargeInteger(ULONG UnsignedInteger);
+VOID RtlCopyBytes(PVOID Destination, CONST VOID* Source, ULONG Length);
+VOID RtlCopyMemory(VOID* Destination, VOID* Source, ULONG Length);
+VOID RtlCopyString(PSTRING DestinationString, PSTRING SourceString);
+VOID RtlCopyUnicodeString(PUNICODE_STRING DestinationString,
+			  PUNICODE_STRING SourceString);
+NTSTATUS RtlCreateRegistryKey(ULONG RelativeTo,
+			      PWSTR Path);
+NTSTATUS RtlCreateSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,
+				     ULONG Revision);
+NTSTATUS RtlDeleteRegistryValue(ULONG RelativeTo,
+				PWSTR Path,
+				PWSTR ValueName);
+LARGE_INTEGER RtlEnlargedIntegerMultiply(LONG Multiplicand,
+					 LONG Multiplier);
+ULONG RtlEnlargedUnsignedDivide(ULARGE_INTEGER Dividend,
+				ULONG Divisor,
+				PULONG Remainder);
+LARGE_INTEGER RtlEnlargedUnsignedMultiply(ULONG Multiplicand,
+					  ULONG Multiplier);
+BOOLEAN RtlEqualString(PSTRING String1,
+		       PSTRING String2,
+		       BOOLEAN CaseInSensitive);
+BOOLEAN RtlEqualUnicodeString(PUNICODE_STRING String1,
+			      PUNICODE_STRING String2,
+			      BOOLEAN CaseInSensitive);
+LARGE_INTEGER RtlExtendedIntegerMultiply(LARGE_INTEGER Multiplicand,
+					 LONG Multiplier);
+LARGE_INTEGER RtlExtendedLargeIntegerDivide(LARGE_INTEGER Dividend,
+					    ULONG Divisor,
+					    PULONG Remainder);
+LARGE_INTEGER RtlExtendedMagicDivide(LARGE_INTEGER Dividend,
+				     LARGE_INTEGER MagicDivisor,
+				     CCHAR ShiftCount);
+VOID RtlFillMemory(PVOID Destination, ULONG Length, UCHAR Fill);
+VOID RtlFreeAnsiString(PANSI_STRING AnsiString);
+VOID RtlFreeUnicodeString(PUNICODE_STRING UnicodeString);
+VOID RtlInitAnsiString(PANSI_STRING DestinationString,
+		       PCSZ SourceString);
+VOID RtlInitString(PSTRING DestinationString, PCSZ SourceString);
+VOID RtlInitUnicodeString(PUNICODE_STRING DestinationString,
+			  PCWSTR SourceString);
+NTSTATUS RtlIntegerToUnicodeString(ULONG Value,
+				   ULONG Base,
+				   PUNICODE_STRING String);
+LARGE_INTEGER RtlLargeIntegerAdd(LARGE_INTEGER Addend1,
+				 LARGE_INTEGER Addend2);
+VOID RtlLargeIntegerAnd(PLARGE_INTEGER Result,
+			LARGE_INTEGER Source,
+			LARGE_INTEGER Mask);
+
+/* MISSING FUNCTIONS GO HERE */
+LARGE_INTEGER RtlConvertLongToLargeInteger(LONG SignedInteger);
+LARGE_INTEGER RtlConvertUlongToLargeInteger(ULONG UnsignedInteger);
+LARGE_INTEGER RtlEnlargedIntegerMultiply(LONG Multiplicand,
+                                         LONG Multiplier);
+ULONG RtlEnlargedUnsignedDivide(ULARGE_INTEGER Dividend,
+				ULONG Divisor,
+				PULONG Remainder);
+LARGE_INTEGER RtlEnlargedUnsignedMultiply(ULONG Multiplicand,
+					  ULONG Multipler);
+LARGE_INTEGER RtlExtendedIntegerMultiply(LARGE_INTEGER Multiplicand,
+                                         LONG Multiplier);
+LARGE_INTEGER RtlExtendedLargeIntegerDivide(LARGE_INTEGER Dividend,
+					    ULONG Divisor,
+					    PULONG Remainder);
+LARGE_INTEGER RtlExtendedMagicDivide(LARGE_INTEGER Dividend,
+				     LARGE_INTEGER MagicDivisor,
+				     CCHAR ShiftCount);
+LARGE_INTEGER ExInterlockedAddLargeInteger(PLARGE_INTEGER Addend,
+					   LARGE_INTEGER Increment,
+					   PKSPIN_LOCK Lock);
+LARGE_INTEGER RtlLargeIntegerAdd(LARGE_INTEGER Addend1,
+                                 LARGE_INTEGER Addend2);
+VOID RtlLargeIntegerAnd(PLARGE_INTEGER Result,
+			LARGE_INTEGER Source,
+			LARGE_INTEGER Mask);
+LARGE_INTEGER RtlLargeIntegerArithmeticShift(LARGE_INTEGER LargeInteger,
+					     CCHAR ShiftCount);
+LARGE_INTEGER RtlLargeIntegerDivide(LARGE_INTEGER Dividend,
+				    LARGE_INTEGER Divisor,
+				    PLARGE_INTEGER Remainder);
+BOOLEAN RtlLargeIntegerEqualTo(LARGE_INTEGER Operand1,
+                               LARGE_INTEGER Operand2);
+BOOLEAN RtlLargeIntegerEqualToZero(LARGE_INTEGER Operand);
+BOOLEAN RtlLargeIntegerGreaterThan(LARGE_INTEGER Operand1,
+                                   LARGE_INTEGER Operand2);
+BOOLEAN RtlLargeIntegerGreaterThanOrEqualTo(LARGE_INTEGER Operand1,
+                                            LARGE_INTEGER Operand2);
+BOOLEAN RtlLargeIntegerGreaterThanOrEqualToZero(LARGE_INTEGER Operand1);
+BOOLEAN RtlLargeIntegerGreaterThanZero(LARGE_INTEGER Operand1);
+BOOLEAN RtlLargeIntegerLessThan(LARGE_INTEGER Operand1,
+                                LARGE_INTEGER Operand2);
+BOOLEAN RtlLargeIntegerLessThanOrEqualTo(LARGE_INTEGER Operand1,
+                                         LARGE_INTEGER Operand2);
+BOOLEAN RtlLargeIntegerLessThanOrEqualToZero(LARGE_INTEGER Operand);
+BOOLEAN RtlLargeIntegerLessThanZero(LARGE_INTEGER Operand);
+LARGE_INTEGER RtlLargeIntegerNegate(LARGE_INTEGER Subtrahend);
+BOOLEAN RtlLargeIntegerNotEqualTo(LARGE_INTEGER Operand1,
+                                  LARGE_INTEGER Operand2);
+BOOLEAN RtlLargeIntegerNotEqualToZero(LARGE_INTEGER Operand);
+LARGE_INTEGER RtlLargeIntegerShiftLeft(LARGE_INTEGER LargeInteger,
+				       CCHAR ShiftCount);
+LARGE_INTEGER RtlLargeIntegerShiftRight(LARGE_INTEGER LargeInteger,
+					CCHAR ShiftCount);
+LARGE_INTEGER RtlLargeIntegerSubtract(LARGE_INTEGER Minuend,
+				      LARGE_INTEGER Subtrahend);
+
+ULONG RtlLengthSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor);
+VOID RtlMoveMemory(PVOID Destination, CONST VOID* Source, ULONG Length);
+NTSTATUS RtlQueryRegistryValues(ULONG RelativeTo,
+				PWSTR Path, 
+				PRTL_QUERY_REGISTRY_TABLE QueryTable,
+				PVOID Context, PVOID Environment);
+VOID RtlRetrieveUlong(PULONG DestinationAddress,
+		      PULONG SourceAddress);
+VOID RtlRetrieveUshort(PUSHORT DestinationAddress,
+		       PUSHORT SourceAddress);
+NTSTATUS RtlSetDaclSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,
+				      BOOLEAN DaclPresent,
+				      PACL Dacl,
+				      BOOLEAN DaclDefaulted);
+VOID RtlStoreLong(PULONG Address, ULONG Value);
+VOID RtlStoreUshort(PUSHORT Address, USHORT Value);
+BOOLEAN RtlTimeFieldsToTime(PTIME_FIELDS TimeFields, PLARGE_INTEGER Time);
+VOID RtlTimeToTimeFields(PLARGE_INTEGER Time, PTIME_FIELDS TimeFields);
+PWSTR RtlStrtok(PUNICODE_STRING _string, PWSTR _sep, PWSTR* temp);
+VOID RtlGetCallersAddress(PVOID* CallersAddress);
+VOID RtlZeroMemory(PVOID Destination, ULONG Length);
+
+typedef struct {
+	ULONG    	Length;
+	ULONG    	Unknown[11];
+} RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
+
+// Heap creation routine
+
+HANDLE 
+STDCALL
+RtlCreateHeap(
+	ULONG Flags, 
+	PVOID BaseAddress, 
+	ULONG SizeToReserve, 
+	ULONG SizeToCommit, 
+	PVOID Unknown,
+	PRTL_HEAP_DEFINITION Definition
+	);
+
+PVOID 
+STDCALL 
+RtlAllocateHeap(
+	HANDLE Heap, 
+	ULONG Flags, 
+	ULONG Size 
+	);
+
+
+BOOLEAN 
+STDCALL 
+RtlFreeHeap(
+	HANDLE Heap, 
+	ULONG Flags, 
+	PVOID Address 
+	);
+
+
+#endif /* __DDK_RTL_H */

reactos/include/ddk/setypes.h

@@ -0,0 +1,41 @@
+/*
+ * COPYRIGHT:         See COPYING in the top level directory for details
+ * PROJECT:           ReactOS kernel
+ * FILE:              include/ddk/setypes.h
+ * PURPOSE:           Security manager types
+ * REVISION HISTORY:
+ *                 ??/??/??:    Created with empty stubs by David Welch
+ *                 29/08/98:    ACCESS_TOKEN definition from Boudewijn Dekker
+ */
+
+typedef ULONG ACCESS_MODE, *PACCESS_MODE;
+
+typedef struct _SECURITY_SUBJECT_CONTEXT
+{
+} SECURITY_SUBJECT_CONTEXT, *PSECURITY_SUBJECT_CONTEXT;
+
+typedef struct _SECURITY_DESCRIPTOR_CONTEXT
+{
+} SECURITY_DESCRIPTOR_CONTEXT, *PSECURITY_DESCRIPTOR_CONTEXT;
+
+typedef struct _ACCESS_TOKEN {
+	TOKEN_SOURCE			TokenSource;
+	LUID				AuthenticationId;
+	LARGE_INTEGER			ExpirationTime;
+	LUID				ModifiedId;
+	ULONG				UserAndGroupCount;
+	ULONG				PrivilegeCount;
+	ULONG				VariableLength;
+	ULONG				DynamicCharged;
+	ULONG				DynamicAvailable;
+	ULONG				DefaultOwnerIndex;
+	PACL				DefaultDacl;
+	TOKEN_TYPE			TokenType;
+	SECURITY_IMPERSONATION_LEVEL 	ImpersonationLevel;
+	UCHAR				TokenFlags;
+	UCHAR				TokenInUse;
+	UCHAR				Unused[2];
+	PVOID				ProxyData;
+	PVOID				AuditData;
+	UCHAR				VariablePart[0];
+} ACCESS_TOKEN, *PACCESS_TOKEN;

reactos/include/ddk/status.h

@@ -0,0 +1,159 @@
+#ifndef __INCLUDE_DDK_STATUS_H
+#define __INCLUDE_DDK_STATUS_H
+
+#define NT_SUCCESS(StatCode)  ((NTSTATUS)(StatCode) >= 0)
+
+/*
+ * Possible status codes
+ * FIXME: These may not be the actual values used by NT
+ */
+enum
+{
+   STATUS_SUCCESS = 0x0,
+   STATUS_INSUFFICIENT_RESOURCES = 0x80000000,
+   STATUS_OBJECT_NAME_EXISTS,
+   STATUS_OBJECT_NAME_COLLISION,
+//   STATUS_DATATYPE_MISALIGNMENT,
+   STATUS_CTL_FILE_NOT_SUPPORTED,
+//   STATUS_ACCESS_VIOLATION,
+   STATUS_PORT_ALREADY_SET,
+   STATUS_SECTION_NOT_IMAGE,
+   STATUS_BAD_WORKING_SET_LIMIT,
+   STATUS_INCOMPATIBLE_FILE_MAP,
+   STATUS_HANDLE_NOT_WAITABLE,
+   STATUS_PORT_DISCONNECTED,
+   STATUS_NOT_LOCKED,
+   STATUS_NOT_MAPPED_VIEW,
+   STATUS_UNABLE_TO_FREE_VM,
+   STATUS_UNABLE_TO_DELETE_SECTION,
+   STATUS_MORE_PROCESSING_REQUIRED,
+   STATUS_INVALID_CID,
+   STATUS_BAD_INITIAL_STACK,
+   STATUS_INVALID_VOLUME_LABEL,
+   STATUS_SECTION_NOT_EXTENDED,
+   STATUS_NOT_MAPPED_DATA,
+   STATUS_INFO_LENGTH_MISMATCH,
+   STATUS_INVALID_INFO_CLASS,
+   STATUS_SUSPEND_COUNT_EXCEEDED,
+   STATUS_NOTIFY_ENUM_DIR,
+   STATUS_REGISTRY_RECOVERED,
+   STATUS_REGISTRY_IO_FAILED,
+   STATUS_KEY_DELETED,
+   STATUS_NO_LOG_SPACE,
+   STATUS_KEY_HAS_CHILDREN,
+   STATUS_CHILD_MUST_BE_VOLATILE,
+   STATUS_REGISTRY_CORRUPT,
+   STATUS_DLL_NOT_FOUND,
+   STATUS_DLL_INIT_FAILED,
+   STATUS_ORDINAL_NOT_FOUND,
+   STATUS_ENTRYPOINT_NOT_FOUND,
+//   STATUS_PENDING,
+   STATUS_MORE_ENTRIES,
+//   STATUS_INTEGER_OVERFLOW,
+   STATUS_BUFFER_OVERFLOW,
+   STATUS_NO_MORE_FILES,
+   STATUS_NO_INHERITANCE,
+   STATUS_NO_MORE_EAS,
+   STATUS_NO_MORE_ENTRIES,
+   STATUS_GUIDS_EXHAUSTED,
+   STATUS_AGENTS_EXHAUSTED,
+   STATUS_UNSUCCESSFUL,
+   STATUS_NOT_IMPLEMENTED,
+   STATUS_ILLEGAL_FUNCTION,
+//   STATUS_IN_PAGE_ERROR,
+   STATUS_PAGEFILE_QUOTA,
+   STATUS_COMMITMENT_LIMIT,
+   STATUS_SECTION_TOO_BIG,
+   RPC_NT_SS_IN_NULL_CONTEXT,
+   RPC_NT_INVALID_BINDING,
+//   STATUS_INVALID_HANDLE,
+   STATUS_OBJECT_FILE_MISMATCH,
+   STATUS_FILE_CLOSED,
+   STATUS_INVALID_PORT_HANDLE,
+   STATUS_NOT_COMMITTED,
+   STATUS_INVALID_PARAMETER,
+   STATUS_INVALID_PARAMETER_1,
+   STATUS_INVALID_PARAMETER_2,
+   STATUS_INVALID_PARAMETER_3,
+   STATUS_INVALID_PARAMETER_4,
+   STATUS_INVALID_PARAMETER_5,
+   STATUS_INVALID_PARAMETER_6,
+   STATUS_INVALID_PARAMETER_7,
+   STATUS_INVALID_PARAMETER_8,
+   STATUS_INVALID_PARAMETER_9,
+   STATUS_INVALID_PARAMETER_10,
+   STATUS_INVALID_PARAMETER_11,
+   STATUS_INVALID_PARAMETER_12,
+   STATUS_INVALID_PARAMETER_MAX,
+   STATUS_INVALID_PAGE_PROTECTION,
+   STATUS_RESOURCE_DATA_NOT_FOUND,
+   STATUS_RESOURCE_TYPE_NOT_FOUND,
+   STATUS_RESOURCE_NAME_NOT_FOUND,
+   STATUS_RESOURCE_LANG_NOT_FOUND,
+   STATUS_NO_SUCH_DEVICE,
+   STATUS_NO_SUCH_FILE,
+   STATUS_INVALID_DEVICE_REQUEST,
+   STATUS_END_OF_FILE,
+   STATUS_FILE_FORCED_CLOSED,
+   STATUS_WRONG_VOLUME,
+   STATUS_NO_MEDIA,
+   STATUS_NO_MEDIA_IN_DEVICE,
+   STATUS_NONEXISTENT_SECTOR,
+   STATUS_WORKING_SET_QUOTA,
+//   STATUS_NO_MEMORY,
+   STATUS_CONFLICTING_ADDRESS,
+   STATUS_INVALID_SYSTEM_SERVICE,
+   STATUS_THREAD_IS_TERMINATING,
+   STATUS_PROCESS_IS_TERMINATING,
+   STATUS_INVALID_LOCK_SEQUENCE,
+   STATUS_INVALID_VIEW_SIZE,
+   STATUS_ALREADY_COMMITTED,
+   STATUS_ACCESS_DENIED,
+   STATUS_FILE_IS_A_DIRECTORY,
+   STATUS_CANNOT_DELETE,
+   STATUS_INVALID_COMPUTER_NAME,
+   STATUS_FILE_DELETED,
+   STATUS_DELETE_PENDING,
+   STATUS_PORT_CONNECTION_REFUSED,
+   STATUS_NO_SUCH_PRIVILEGE,
+   STATUS_PRIVILEGE_NOT_HELD,
+   STATUS_CANNOT_IMPERSONATE,
+   STATUS_LOGON_FAILURE,
+   STATUS_ACCOUNT_RESTRICTION,
+   STATUS_INVALID_LOGON_HOURS,
+   STATUS_INVALID_WORKSTATION,
+   STATUS_BUFFER_TOO_SMALL,
+   STATUS_UNABLE_TO_DECOMMIT_VM,
+   STATUS_DISK_CORRUPT_ERROR,
+   STATUS_OBJECT_NAME_INVALID,
+   STATUS_OBJECT_NAME_NOT_FOUND,
+//   STATUS_OBJECT_NAME_COLLISION,
+   STATUS_OBJECT_PATH_INVALID,
+   STATUS_OBJECT_PATH_NOT_FOUND,
+   STATUS_DFS_EXIT_PATH_FOUND,
+   STATUS_OBJECT_PATH_SYNTAX_BAD,
+   STATUS_DATA_OVERRUN,
+   STATUS_DATA_LATE_ERROR,
+   STATUS_DATA_ERROR,
+   STATUS_CRC_ERROR,
+   STATUS_SHARING_VIOLATION,
+   STATUS_QUOTA_EXCEEDED,
+   STATUS_MUTANT_NOT_OWNED,
+   STATUS_SEMAPHORE_LIMIT_EXCEEDED,
+   STATUS_DISK_FULL,
+   STATUS_LOCK_NOT_GRANTED,
+     
+   STATUS_DEVICE_NOT_READY,
+   STATUS_IO_TIMEOUT,
+   STATUS_MEDIA_WRITE_PROTECTED,
+   STATUS_NO_MEDIA_IN_DRIVE,
+   STATUS_VERIFY_REQUIRED,
+   STATUS_UNRECOGNIZED_MEDIA,
+   STATUS_UNRECOGNIZED_VOLUME,
+//   STATUS_WRONG_VOLUME,
+   STATUS_FS_DRIVER_REQUIRED,
+   STATUS_NOT_SUPPORTED = 9999,
+   STATUS_DISK_OPERATION_FAILED
+};
+
+#endif /* __INCLUDE_DDK_STATUS_H */

reactos/include/ddk/types.h

@@ -0,0 +1,73 @@
+#ifndef __DDK_TYPES_H
+#define __DDK_TYPES_H
+
+// these should be moved to a file like ntdef.h
+
+typedef const int CINT;
+
+
+typedef ULONG KAFFINITY, *PKAFFINITY;
+
+typedef LONG NTSTATUS, *PNTSTATUS;
+
+typedef ULONG DEVICE_TYPE;
+
+
+
+
+
+enum
+{
+   DIRECTORY_QUERY,
+   DIRECTORY_TRAVERSE,
+   DIRECTORY_CREATE_OBJECT,
+   DIRECTORY_CREATE_SUBDIRECTORY,
+   DIRECTORY_ALL_ACCESS,
+};
+
+typedef unsigned long long ULONGLONG;
+
+/*
+ * General type for status information
+ */
+//typedef LONG NTSTATUS;
+
+typedef struct _UNICODE_STRING
+{
+   USHORT Length;
+   USHORT MaximumLength;
+   PWSTR Buffer;
+} UNICODE_STRING, *PUNICODE_STRING;
+
+typedef enum _SECTION_INHERIT {
+    ViewShare = 1,
+    ViewUnmap = 2
+} SECTION_INHERIT;
+
+/*
+ * Various other types (all quite pointless)
+ */
+typedef ULONG KPROCESSOR_MODE;
+typedef UCHAR KIRQL;
+typedef KIRQL* PKIRQL;
+typedef ULONG IO_ALLOCATION_ACTION;
+typedef ULONG POOL_TYPE;
+typedef ULONG TIMER_TYPE;
+typedef ULONG MM_SYSTEM_SIZE;
+typedef ULONG LOCK_OPERATION;
+typedef ULONG KEY_INFORMATION_CLASS;
+typedef ULONG FILE_INFORMATION_CLASS;
+typedef ULONG KEY_VALUE_INFORMATION_CLASS;
+typedef LARGE_INTEGER PHYSICAL_ADDRESS;
+typedef PHYSICAL_ADDRESS* PPHYSICAL_ADDRESS;
+typedef ULONG WAIT_TYPE;
+//typedef ULONG KINTERRUPT_MODE;
+typedef USHORT CSHORT;
+
+
+typedef struct _TIME {
+	DWORD LowPart;
+	LONG HighPart;
+} TIME;
+
+#endif

reactos/include/devices.h

@@ -0,0 +1,16 @@
+typedef struct
+{
+	LPSTR LeftVolumeName;
+	LPSTR RightVolumeName;
+	ULONG DefaultVolume;
+	ULONG Type;
+	ULONG DeviceType;
+	char Key[4];
+	LPSTR PrototypeName;
+	PVOID DeferredRoutine;
+	PVOID ExclusionRoutine;
+	PVOID DispatchRoutine;
+	PVOID DevCapsRoutine;
+	PVOID HwSetVolume;
+	ULONG IoMethod;
+}SOUND_DEVICE_INIT;

reactos/include/errors.h

@@ -0,0 +1,713 @@
+/* 
+   Errors.h
+
+   Windows32 API error codes
+
+   Copyright (C) 1996 Free Software Foundation, Inc.
+
+   Author: Scott Christley <scottc@net-community.com>
+
+   This file is part of the Windows32 API Library.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+   
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   If you are interested in a warranty or support for this source code,
+   contact Scott Christley <scottc@net-community.com> for more information.
+   
+   You should have received a copy of the GNU Library General Public
+   License along with this library; see the file COPYING.LIB.
+   If not, write to the Free Software Foundation, 
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/ 
+
+#ifndef _GNU_H_WINDOWS32_ERROR
+#define _GNU_H_WINDOWS32_ERROR
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* Numerical order */
+
+#define LZERROR_UNKNOWNALG             (-8)
+#define LZERROR_BADVALUE               (-7)
+#define LZERROR_GLOBLOCK               (-6)
+#define LZERROR_GLOBALLOC              (-5)
+#define LZERROR_WRITE                  (-4)
+#define LZERROR_READ                   (-3)
+#define LZERROR_BADOUTHANDLE           (-2)
+#define LZERROR_BADINHANDLE            (-1)
+#define NO_ERROR                         0L
+#define ERROR_SUCCESS                    0L
+#define ERROR_INVALID_FUNCTION           1L
+#define ERROR_FILE_NOT_FOUND             2L
+#define ERROR_PATH_NOT_FOUND             3L
+#define ERROR_TOO_MANY_OPEN_FILES        4L
+#define ERROR_ACCESS_DENIED              5L
+#define ERROR_INVALID_HANDLE             6L
+#define ERROR_ARENA_TRASHED              7L
+#define ERROR_NOT_ENOUGH_MEMORY          8L
+#define ERROR_INVALID_BLOCK              9L
+#define ERROR_BAD_ENVIRONMENT            10L
+#define ERROR_BAD_FORMAT                 11L
+#define ERROR_INVALID_ACCESS             12L
+#define ERROR_INVALID_DATA               13L
+#define ERROR_OUTOFMEMORY                14L
+#define ERROR_INVALID_DRIVE              15L
+#define ERROR_CURRENT_DIRECTORY          16L
+#define ERROR_NOT_SAME_DEVICE            17L
+#define ERROR_NO_MORE_FILES              18L
+#define ERROR_WRITE_PROTECT              19L
+#define ERROR_BAD_UNIT                   20L
+#define ERROR_NOT_READY                  21L
+#define ERROR_BAD_COMMAND                22L
+#define ERROR_CRC                        23L
+#define ERROR_BAD_LENGTH                 24L
+#define ERROR_SEEK                       25L
+#define ERROR_NOT_DOS_DISK               26L
+#define ERROR_SECTOR_NOT_FOUND           27L
+#define ERROR_OUT_OF_PAPER               28L
+#define ERROR_WRITE_FAULT                29L
+#define ERROR_READ_FAULT                 30L
+#define ERROR_GEN_FAILURE                31L
+#define ERROR_SHARING_VIOLATION          32L
+#define ERROR_LOCK_VIOLATION             33L
+#define ERROR_WRONG_DISK                 34L
+#define ERROR_SHARING_BUFFER_EXCEEDED    36L
+#define ERROR_HANDLE_EOF                 38L
+#define ERROR_HANDLE_DISK_FULL           39L
+#define ERROR_NOT_SUPPORTED              50L
+#define ERROR_REM_NOT_LIST               51L
+#define ERROR_DUP_NAME                   52L
+#define ERROR_BAD_NETPATH                53L
+#define ERROR_NETWORK_BUSY               54L
+#define ERROR_DEV_NOT_EXIST              55L
+#define ERROR_TOO_MANY_CMDS              56L
+#define ERROR_ADAP_HDW_ERR               57L
+#define ERROR_BAD_NET_RESP               58L
+#define ERROR_UNEXP_NET_ERR              59L
+#define ERROR_BAD_REM_ADAP               60L
+#define ERROR_PRINTQ_FULL                61L
+#define ERROR_NO_SPOOL_SPACE             62L
+#define ERROR_PRINT_CANCELLED            63L
+#define ERROR_NETNAME_DELETED            64L
+#define ERROR_NETWORK_ACCESS_DENIED      65L
+#define ERROR_BAD_DEV_TYPE               66L
+#define ERROR_BAD_NET_NAME               67L
+#define ERROR_TOO_MANY_NAMES             68L
+#define ERROR_TOO_MANY_SESS              69L
+#define ERROR_SHARING_PAUSED             70L
+#define ERROR_REQ_NOT_ACCEP              71L
+#define ERROR_REDIR_PAUSED               72L
+#define ERROR_FILE_EXISTS                80L
+#define ERROR_CANNOT_MAKE                82L
+#define ERROR_FAIL_I24                   83L
+#define ERROR_OUT_OF_STRUCTURES          84L
+#define ERROR_ALREADY_ASSIGNED           85L
+#define ERROR_INVALID_PASSWORD           86L
+#define ERROR_INVALID_PARAMETER          87L
+#define ERROR_NET_WRITE_FAULT            88L
+#define ERROR_NO_PROC_SLOTS              89L
+#define ERROR_TOO_MANY_SEMAPHORES        100L
+#define ERROR_EXCL_SEM_ALREADY_OWNED     101L
+#define ERROR_SEM_IS_SET                 102L
+#define ERROR_TOO_MANY_SEM_REQUESTS      103L
+#define ERROR_INVALID_AT_INTERRUPT_TIME  104L
+#define ERROR_SEM_OWNER_DIED             105L
+#define ERROR_SEM_USER_LIMIT             106L
+#define ERROR_DISK_CHANGE                107L
+#define ERROR_DRIVE_LOCKED               108L
+#define ERROR_BROKEN_PIPE                109L
+#define ERROR_OPEN_FAILED                110L
+#define ERROR_BUFFER_OVERFLOW            111L
+#define ERROR_DISK_FULL                  112L
+#define ERROR_NO_MORE_SEARCH_HANDLES     113L
+#define ERROR_INVALID_TARGET_HANDLE      114L
+#define ERROR_INVALID_CATEGORY           117L
+#define ERROR_INVALID_VERIFY_SWITCH      118L
+#define ERROR_BAD_DRIVER_LEVEL           119L
+#define ERROR_CALL_NOT_IMPLEMENTED       120L
+#define ERROR_SEM_TIMEOUT                121L
+#define ERROR_INSUFFICIENT_BUFFER        122L
+#define ERROR_INVALID_NAME               123L
+#define ERROR_INVALID_LEVEL              124L
+#define ERROR_NO_VOLUME_LABEL            125L
+#define ERROR_MOD_NOT_FOUND              126L
+#define ERROR_PROC_NOT_FOUND             127L
+#define ERROR_WAIT_NO_CHILDREN           128L
+#define ERROR_CHILD_NOT_COMPLETE         129L
+#define ERROR_DIRECT_ACCESS_HANDLE       130L
+#define ERROR_NEGATIVE_SEEK              131L
+#define ERROR_SEEK_ON_DEVICE             132L
+#define ERROR_IS_JOIN_TARGET             133L
+#define ERROR_IS_JOINED                  134L
+#define ERROR_IS_SUBSTED                 135L
+#define ERROR_NOT_JOINED                 136L
+#define ERROR_NOT_SUBSTED                137L
+#define ERROR_JOIN_TO_JOIN               138L
+#define ERROR_SUBST_TO_SUBST             139L
+#define ERROR_JOIN_TO_SUBST              140L
+#define ERROR_SUBST_TO_JOIN              141L
+#define ERROR_BUSY_DRIVE                 142L
+#define ERROR_SAME_DRIVE                 143L
+#define ERROR_DIR_NOT_ROOT               144L
+#define ERROR_DIR_NOT_EMPTY              145L
+#define ERROR_IS_SUBST_PATH              146L
+#define ERROR_IS_JOIN_PATH               147L
+#define ERROR_PATH_BUSY                  148L
+#define ERROR_IS_SUBST_TARGET            149L
+#define ERROR_SYSTEM_TRACE               150L
+#define ERROR_INVALID_EVENT_COUNT        151L
+#define ERROR_TOO_MANY_MUXWAITERS        152L
+#define ERROR_INVALID_LIST_FORMAT        153L
+#define ERROR_LABEL_TOO_LONG             154L
+#define ERROR_TOO_MANY_TCBS              155L
+#define ERROR_SIGNAL_REFUSED             156L
+#define ERROR_DISCARDED                  157L
+#define ERROR_NOT_LOCKED                 158L
+#define ERROR_BAD_THREADID_ADDR          159L
+#define ERROR_BAD_ARGUMENTS              160L
+#define ERROR_BAD_PATHNAME               161L
+#define ERROR_SIGNAL_PENDING             162L
+#define ERROR_MAX_THRDS_REACHED          164L
+#define ERROR_LOCK_FAILED                167L
+#define ERROR_BUSY                       170L
+#define ERROR_CANCEL_VIOLATION           173L
+#define ERROR_ATOMIC_LOCKS_NOT_SUPPORTED 174L
+#define ERROR_INVALID_SEGMENT_NUMBER     180L
+#define ERROR_INVALID_ORDINAL            182L
+#define ERROR_ALREADY_EXISTS             183L
+#define ERROR_INVALID_FLAG_NUMBER        186L
+#define ERROR_SEM_NOT_FOUND              187L
+#define ERROR_INVALID_STARTING_CODESEG   188L
+#define ERROR_INVALID_STACKSEG           189L
+#define ERROR_INVALID_MODULETYPE         190L
+#define ERROR_INVALID_EXE_SIGNATURE      191L
+#define ERROR_EXE_MARKED_INVALID         192L
+#define ERROR_BAD_EXE_FORMAT             193L
+#define ERROR_ITERATED_DATA_EXCEEDS_64k  194L
+#define ERROR_INVALID_MINALLOCSIZE       195L
+#define ERROR_DYNLINK_FROM_INVALID_RING  196L
+#define ERROR_IOPL_NOT_ENABLED           197L
+#define ERROR_INVALID_SEGDPL             198L
+#define ERROR_AUTODATASEG_EXCEEDS_64k    199L
+#define ERROR_RING2SEG_MUST_BE_MOVABLE   200L
+#define ERROR_RELOC_CHAIN_XEEDS_SEGLIM   201L
+#define ERROR_INFLOOP_IN_RELOC_CHAIN     202L
+#define ERROR_ENVVAR_NOT_FOUND           203L
+#define ERROR_NO_SIGNAL_SENT             205L
+#define ERROR_FILENAME_EXCED_RANGE       206L
+#define ERROR_RING2_STACK_IN_USE         207L
+#define ERROR_META_EXPANSION_TOO_LONG    208L
+#define ERROR_INVALID_SIGNAL_NUMBER      209L
+#define ERROR_THREAD_1_INACTIVE          210L
+#define ERROR_LOCKED                     212L
+#define ERROR_TOO_MANY_MODULES           214L
+#define ERROR_NESTING_NOT_ALLOWED        215L
+#define ERROR_BAD_PIPE                   230L
+#define ERROR_PIPE_BUSY                  231L
+#define ERROR_NO_DATA                    232L
+#define ERROR_PIPE_NOT_CONNECTED         233L
+#define ERROR_MORE_DATA                  234L
+#define ERROR_VC_DISCONNECTED            240L
+#define ERROR_INVALID_EA_NAME            254L
+#define ERROR_EA_LIST_INCONSISTENT       255L
+#define ERROR_NO_MORE_ITEMS              259L
+#define ERROR_CANNOT_COPY                266L
+#define ERROR_DIRECTORY                  267L
+#define ERROR_EAS_DIDNT_FIT              275L
+#define ERROR_EA_FILE_CORRUPT            276L
+#define ERROR_EA_TABLE_FULL              277L
+#define ERROR_INVALID_EA_HANDLE          278L
+#define ERROR_EAS_NOT_SUPPORTED          282L
+#define ERROR_NOT_OWNER                  288L
+#define ERROR_TOO_MANY_POSTS             298L
+#define ERROR_PARTIAL_COPY               299L
+#define ERROR_MR_MID_NOT_FOUND           317L
+#define ERROR_INVALID_ADDRESS            487L
+#define ERROR_ARITHMETIC_OVERFLOW        534L
+#define ERROR_PIPE_CONNECTED             535L
+#define ERROR_PIPE_LISTENING             536L
+#define ERROR_EA_ACCESS_DENIED           994L
+#define ERROR_OPERATION_ABORTED          995L
+#define ERROR_IO_INCOMPLETE              996L
+#define ERROR_IO_PENDING                 997L
+#define ERROR_NOACCESS                   998L
+#define ERROR_SWAPERROR                  999L
+#define ERROR_STACK_OVERFLOW             1001L
+#define ERROR_INVALID_MESSAGE            1002L
+#define ERROR_CAN_NOT_COMPLETE           1003L
+#define ERROR_INVALID_FLAGS              1004L
+#define ERROR_UNRECOGNIZED_VOLUME        1005L
+#define ERROR_FILE_INVALID               1006L
+#define ERROR_FULLSCREEN_MODE            1007L
+#define ERROR_NO_TOKEN                   1008L
+#define ERROR_BADDB                      1009L
+#define ERROR_BADKEY                     1010L
+#define ERROR_CANTOPEN                   1011L
+#define ERROR_CANTREAD                   1012L
+#define ERROR_CANTWRITE                  1013L
+#define ERROR_REGISTRY_RECOVERED         1014L
+#define ERROR_REGISTRY_CORRUPT           1015L
+#define ERROR_REGISTRY_IO_FAILED         1016L
+#define ERROR_NOT_REGISTRY_FILE          1017L
+#define ERROR_KEY_DELETED                1018L
+#define ERROR_NO_LOG_SPACE               1019L
+#define ERROR_KEY_HAS_CHILDREN           1020L
+#define ERROR_CHILD_MUST_BE_VOLATILE     1021L
+#define ERROR_NOTIFY_ENUM_DIR            1022L
+#define ERROR_DEPENDENT_SERVICES_RUNNING 1051L
+#define ERROR_INVALID_SERVICE_CONTROL    1052L
+#define ERROR_SERVICE_REQUEST_TIMEOUT    1053L
+#define ERROR_SERVICE_NO_THREAD          1054L
+#define ERROR_SERVICE_DATABASE_LOCKED    1055L
+#define ERROR_SERVICE_ALREADY_RUNNING    1056L
+#define ERROR_INVALID_SERVICE_ACCOUNT    1057L
+#define ERROR_SERVICE_DISABLED           1058L
+#define ERROR_CIRCULAR_DEPENDENCY        1059L
+#define ERROR_SERVICE_DOES_NOT_EXIST     1060L
+#define ERROR_SERVICE_CANNOT_ACCEPT_CTRL 1061L
+#define ERROR_SERVICE_NOT_ACTIVE         1062L
+#define ERROR_FAILED_SERVICE_CONTROLLER_CONNECT 1063L
+#define ERROR_EXCEPTION_IN_SERVICE       1064L
+#define ERROR_DATABASE_DOES_NOT_EXIST    1065L
+#define ERROR_SERVICE_SPECIFIC_ERROR     1066L
+#define ERROR_PROCESS_ABORTED            1067L
+#define ERROR_SERVICE_DEPENDENCY_FAIL    1068L
+#define ERROR_SERVICE_LOGON_FAILED       1069L
+#define ERROR_SERVICE_START_HANG         1070L
+#define ERROR_INVALID_SERVICE_LOCK       1071L
+#define ERROR_SERVICE_MARKED_FOR_DELETE  1072L
+#define ERROR_SERVICE_EXISTS             1073L
+#define ERROR_ALREADY_RUNNING_LKG        1074L
+#define ERROR_SERVICE_DEPENDENCY_DELETED 1075L
+#define ERROR_BOOT_ALREADY_ACCEPTED      1076L
+#define ERROR_SERVICE_NEVER_STARTED      1077L
+#define ERROR_DUPLICATE_SERVICE_NAME     1078L
+#define ERROR_END_OF_MEDIA               1100L
+#define ERROR_FILEMARK_DETECTED          1101L
+#define ERROR_BEGINNING_OF_MEDIA         1102L
+#define ERROR_SETMARK_DETECTED           1103L
+#define ERROR_NO_DATA_DETECTED           1104L
+#define ERROR_PARTITION_FAILURE          1105L
+#define ERROR_INVALID_BLOCK_LENGTH       1106L
+#define ERROR_DEVICE_NOT_PARTITIONED     1107L
+#define ERROR_UNABLE_TO_LOCK_MEDIA       1108L
+#define ERROR_UNABLE_TO_UNLOAD_MEDIA     1109L
+#define ERROR_MEDIA_CHANGED              1110L
+#define ERROR_BUS_RESET                  1111L
+#define ERROR_NO_MEDIA_IN_DRIVE          1112L
+#define ERROR_NO_UNICODE_TRANSLATION     1113L
+#define ERROR_DLL_INIT_FAILED            1114L
+#define ERROR_SHUTDOWN_IN_PROGRESS       1115L
+#define ERROR_NO_SHUTDOWN_IN_PROGRESS    1116L
+#define ERROR_IO_DEVICE                  1117L
+#define ERROR_SERIAL_NO_DEVICE           1118L
+#define ERROR_IRQ_BUSY                   1119L
+#define ERROR_MORE_WRITES                1120L
+#define ERROR_COUNTER_TIMEOUT            1121L
+#define ERROR_FLOPPY_ID_MARK_NOT_FOUND   1122L
+#define ERROR_FLOPPY_WRONG_CYLINDER      1123L
+#define ERROR_FLOPPY_UNKNOWN_ERROR       1124L
+#define ERROR_FLOPPY_BAD_REGISTERS       1125L
+#define ERROR_DISK_RECALIBRATE_FAILED    1126L
+#define ERROR_DISK_OPERATION_FAILED      1127L
+#define ERROR_DISK_RESET_FAILED          1128L
+#define ERROR_EOM_OVERFLOW               1129L
+#define ERROR_NOT_ENOUGH_SERVER_MEMORY   1130L
+#define ERROR_POSSIBLE_DEADLOCK          1131L
+#define ERROR_MAPPED_ALIGNMENT           1132L
+#define ERROR_SET_POWER_STATE_VETOED     1140L
+#define ERROR_SET_POWER_STATE_FAILED     1141L
+#define ERROR_OLD_WIN_VERSION            1150L
+#define ERROR_APP_WRONG_OS               1151L
+#define ERROR_SINGLE_INSTANCE_APP        1152L
+#define ERROR_RMODE_APP                  1153L
+#define ERROR_INVALID_DLL                1154L
+#define ERROR_NO_ASSOCIATION             1155L
+#define ERROR_DDE_FAIL                   1156L
+#define ERROR_DLL_NOT_FOUND              1157L
+#define ERROR_BAD_USERNAME               2202L
+#define ERROR_NOT_CONNECTED              2250L
+#define ERROR_OPEN_FILES                 2401L
+#define ERROR_ACTIVE_CONNECTIONS         2402L
+#define ERROR_DEVICE_IN_USE              2404L
+#define ERROR_BAD_DEVICE                 1200L
+#define ERROR_CONNECTION_UNAVAIL         1201L
+#define ERROR_DEVICE_ALREADY_REMEMBERED  1202L
+#define ERROR_NO_NET_OR_BAD_PATH         1203L
+#define ERROR_BAD_PROVIDER               1204L
+#define ERROR_CANNOT_OPEN_PROFILE        1205L
+#define ERROR_BAD_PROFILE                1206L
+#define ERROR_NOT_CONTAINER              1207L
+#define ERROR_EXTENDED_ERROR             1208L
+#define ERROR_INVALID_GROUPNAME          1209L
+#define ERROR_INVALID_COMPUTERNAME       1210L
+#define ERROR_INVALID_EVENTNAME          1211L
+#define ERROR_INVALID_DOMAINNAME         1212L
+#define ERROR_INVALID_SERVICENAME        1213L
+#define ERROR_INVALID_NETNAME            1214L
+#define ERROR_INVALID_SHARENAME          1215L
+#define ERROR_INVALID_PASSWORDNAME       1216L
+#define ERROR_INVALID_MESSAGENAME        1217L
+#define ERROR_INVALID_MESSAGEDEST        1218L
+#define ERROR_SESSION_CREDENTIAL_CONFLICT 1219L
+#define ERROR_REMOTE_SESSION_LIMIT_EXCEEDED 1220L
+#define ERROR_DUP_DOMAINNAME             1221L
+#define ERROR_NO_NETWORK                 1222L
+#define ERROR_CANCELLED                  1223L
+#define ERROR_USER_MAPPED_FILE           1224L
+#define ERROR_CONNECTION_REFUSED         1225L
+#define ERROR_GRACEFUL_DISCONNECT        1226L
+#define ERROR_ADDRESS_ALREADY_ASSOCIATED 1227L
+#define ERROR_ADDRESS_NOT_ASSOCIATED     1228L
+#define ERROR_CONNECTION_INVALID         1229L
+#define ERROR_CONNECTION_ACTIVE          1230L
+#define ERROR_NETWORK_UNREACHABLE        1231L
+#define ERROR_HOST_UNREACHABLE           1232L
+#define ERROR_PROTOCOL_UNREACHABLE       1233L
+#define ERROR_PORT_UNREACHABLE           1234L
+#define ERROR_REQUEST_ABORTED            1235L
+#define ERROR_CONNECTION_ABORTED         1236L
+#define ERROR_RETRY                      1237L
+#define ERROR_CONNECTION_COUNT_LIMIT     1238L
+#define ERROR_LOGIN_TIME_RESTRICTION     1239L
+#define ERROR_LOGIN_WKSTA_RESTRICTION    1240L
+#define ERROR_INCORRECT_ADDRESS          1241L
+#define ERROR_ALREADY_REGISTERED         1242L
+#define ERROR_SERVICE_NOT_FOUND          1243L
+#define ERROR_NOT_AUTHENTICATED          1244L
+#define ERROR_NOT_LOGGED_ON              1245L
+#define ERROR_CONTINUE                   1246L
+#define ERROR_ALREADY_INITIALIZED        1247L
+#define ERROR_NO_MORE_DEVICES            1248L
+#define ERROR_NOT_ALL_ASSIGNED           1300L
+#define ERROR_SOME_NOT_MAPPED            1301L
+#define ERROR_NO_QUOTAS_FOR_ACCOUNT      1302L
+#define ERROR_LOCAL_USER_SESSION_KEY     1303L
+#define ERROR_NULL_LM_PASSWORD           1304L
+#define ERROR_UNKNOWN_REVISION           1305L
+#define ERROR_REVISION_MISMATCH          1306L
+#define ERROR_INVALID_OWNER              1307L
+#define ERROR_INVALID_PRIMARY_GROUP      1308L
+#define ERROR_NO_IMPERSONATION_TOKEN     1309L
+#define ERROR_CANT_DISABLE_MANDATORY     1310L
+#define ERROR_NO_LOGON_SERVERS           1311L
+#define ERROR_NO_SUCH_LOGON_SESSION      1312L
+#define ERROR_NO_SUCH_PRIVILEGE          1313L
+#define ERROR_PRIVILEGE_NOT_HELD         1314L
+#define ERROR_INVALID_ACCOUNT_NAME       1315L
+#define ERROR_USER_EXISTS                1316L
+#define ERROR_NO_SUCH_USER               1317L
+#define ERROR_GROUP_EXISTS               1318L
+#define ERROR_NO_SUCH_GROUP              1319L
+#define ERROR_MEMBER_IN_GROUP            1320L
+#define ERROR_MEMBER_NOT_IN_GROUP        1321L
+#define ERROR_LAST_ADMIN                 1322L
+#define ERROR_WRONG_PASSWORD             1323L
+#define ERROR_ILL_FORMED_PASSWORD        1324L
+#define ERROR_PASSWORD_RESTRICTION       1325L
+#define ERROR_LOGON_FAILURE              1326L
+#define ERROR_ACCOUNT_RESTRICTION        1327L
+#define ERROR_INVALID_LOGON_HOURS        1328L
+#define ERROR_INVALID_WORKSTATION        1329L
+#define ERROR_PASSWORD_EXPIRED           1330L
+#define ERROR_ACCOUNT_DISABLED           1331L
+#define ERROR_NONE_MAPPED                1332L
+#define ERROR_TOO_MANY_LUIDS_REQUESTED   1333L
+#define ERROR_LUIDS_EXHAUSTED            1334L
+#define ERROR_INVALID_SUB_AUTHORITY      1335L
+#define ERROR_INVALID_ACL                1336L
+#define ERROR_INVALID_SID                1337L
+#define ERROR_INVALID_SECURITY_DESCR     1338L
+#define ERROR_BAD_INHERITANCE_ACL        1340L
+#define ERROR_SERVER_DISABLED            1341L
+#define ERROR_SERVER_NOT_DISABLED        1342L
+#define ERROR_INVALID_ID_AUTHORITY       1343L
+#define ERROR_ALLOTTED_SPACE_EXCEEDED    1344L
+#define ERROR_INVALID_GROUP_ATTRIBUTES   1345L
+#define ERROR_BAD_IMPERSONATION_LEVEL    1346L
+#define ERROR_CANT_OPEN_ANONYMOUS        1347L
+#define ERROR_BAD_VALIDATION_CLASS       1348L
+#define ERROR_BAD_TOKEN_TYPE             1349L
+#define ERROR_NO_SECURITY_ON_OBJECT      1350L
+#define ERROR_CANT_ACCESS_DOMAIN_INFO    1351L
+#define ERROR_INVALID_SERVER_STATE       1352L
+#define ERROR_INVALID_DOMAIN_STATE       1353L
+#define ERROR_INVALID_DOMAIN_ROLE        1354L
+#define ERROR_NO_SUCH_DOMAIN             1355L
+#define ERROR_DOMAIN_EXISTS              1356L
+#define ERROR_DOMAIN_LIMIT_EXCEEDED      1357L
+#define ERROR_INTERNAL_DB_CORRUPTION     1358L
+#define ERROR_INTERNAL_ERROR             1359L
+#define ERROR_GENERIC_NOT_MAPPED         1360L
+#define ERROR_BAD_DESCRIPTOR_FORMAT      1361L
+#define ERROR_NOT_LOGON_PROCESS          1362L
+#define ERROR_LOGON_SESSION_EXISTS       1363L
+#define ERROR_NO_SUCH_PACKAGE            1364L
+#define ERROR_BAD_LOGON_SESSION_STATE    1365L
+#define ERROR_LOGON_SESSION_COLLISION    1366L
+#define ERROR_INVALID_LOGON_TYPE         1367L
+#define ERROR_CANNOT_IMPERSONATE         1368L
+#define ERROR_RXACT_INVALID_STATE        1369L
+#define ERROR_RXACT_COMMIT_FAILURE       1370L
+#define ERROR_SPECIAL_ACCOUNT            1371L
+#define ERROR_SPECIAL_GROUP              1372L
+#define ERROR_SPECIAL_USER               1373L
+#define ERROR_MEMBERS_PRIMARY_GROUP      1374L
+#define ERROR_TOKEN_ALREADY_IN_USE       1375L
+#define ERROR_NO_SUCH_ALIAS              1376L
+#define ERROR_MEMBER_NOT_IN_ALIAS        1377L
+#define ERROR_MEMBER_IN_ALIAS            1378L
+#define ERROR_ALIAS_EXISTS               1379L
+#define ERROR_LOGON_NOT_GRANTED          1380L
+#define ERROR_TOO_MANY_SECRETS           1381L
+#define ERROR_SECRET_TOO_LONG            1382L
+#define ERROR_INTERNAL_DB_ERROR          1383L
+#define ERROR_TOO_MANY_CONTEXT_IDS       1384L
+#define ERROR_LOGON_TYPE_NOT_GRANTED     1385L
+#define ERROR_NT_CROSS_ENCRYPTION_REQUIRED 1386L
+#define ERROR_NO_SUCH_MEMBER             1387L
+#define ERROR_INVALID_MEMBER             1388L
+#define ERROR_TOO_MANY_SIDS              1389L
+#define ERROR_LM_CROSS_ENCRYPTION_REQUIRED 1390L
+#define ERROR_NO_INHERITANCE             1391L
+#define ERROR_FILE_CORRUPT               1392L
+#define ERROR_DISK_CORRUPT               1393L
+#define ERROR_NO_USER_SESSION_KEY        1394L
+#define ERROR_LICENSE_QUOTA_EXCEEDED     1395L
+#define ERROR_INVALID_WINDOW_HANDLE      1400L
+#define ERROR_INVALID_MENU_HANDLE        1401L
+#define ERROR_INVALID_CURSOR_HANDLE      1402L
+#define ERROR_INVALID_ACCEL_HANDLE       1403L
+#define ERROR_INVALID_HOOK_HANDLE        1404L
+#define ERROR_INVALID_DWP_HANDLE         1405L
+#define ERROR_TLW_WITH_WSCHILD           1406L
+#define ERROR_CANNOT_FIND_WND_CLASS      1407L
+#define ERROR_WINDOW_OF_OTHER_THREAD     1408L
+#define ERROR_HOTKEY_ALREADY_REGISTERED  1409L
+#define ERROR_CLASS_ALREADY_EXISTS       1410L
+#define ERROR_CLASS_DOES_NOT_EXIST       1411L
+#define ERROR_CLASS_HAS_WINDOWS          1412L
+#define ERROR_INVALID_INDEX              1413L
+#define ERROR_INVALID_ICON_HANDLE        1414L
+#define ERROR_PRIVATE_DIALOG_INDEX       1415L
+#define ERROR_LISTBOX_ID_NOT_FOUND       1416L
+#define ERROR_NO_WILDCARD_CHARACTERS     1417L
+#define ERROR_CLIPBOARD_NOT_OPEN         1418L
+#define ERROR_HOTKEY_NOT_REGISTERED      1419L
+#define ERROR_WINDOW_NOT_DIALOG          1420L
+#define ERROR_CONTROL_ID_NOT_FOUND       1421L
+#define ERROR_INVALID_COMBOBOX_MESSAGE   1422L
+#define ERROR_WINDOW_NOT_COMBOBOX        1423L
+#define ERROR_INVALID_EDIT_HEIGHT        1424L
+#define ERROR_DC_NOT_FOUND               1425L
+#define ERROR_INVALID_HOOK_FILTER        1426L
+#define ERROR_INVALID_FILTER_PROC        1427L
+#define ERROR_HOOK_NEEDS_HMOD            1428L
+#define ERROR_GLOBAL_ONLY_HOOK           1429L
+#define ERROR_JOURNAL_HOOK_SET           1430L
+#define ERROR_HOOK_NOT_INSTALLED         1431L
+#define ERROR_INVALID_LB_MESSAGE         1432L
+#define ERROR_SETCOUNT_ON_BAD_LB         1433L
+#define ERROR_LB_WITHOUT_TABSTOPS        1434L
+#define ERROR_DESTROY_OBJECT_OF_OTHER_THREAD 1435L
+#define ERROR_CHILD_WINDOW_MENU          1436L
+#define ERROR_NO_SYSTEM_MENU             1437L
+#define ERROR_INVALID_MSGBOX_STYLE       1438L
+#define ERROR_INVALID_SPI_VALUE          1439L
+#define ERROR_SCREEN_ALREADY_LOCKED      1440L
+#define ERROR_HWNDS_HAVE_DIFF_PARENT     1441L
+#define ERROR_NOT_CHILD_WINDOW           1442L
+#define ERROR_INVALID_GW_COMMAND         1443L
+#define ERROR_INVALID_THREAD_ID          1444L
+#define ERROR_NON_MDICHILD_WINDOW        1445L
+#define ERROR_POPUP_ALREADY_ACTIVE       1446L
+#define ERROR_NO_SCROLLBARS              1447L
+#define ERROR_INVALID_SCROLLBAR_RANGE    1448L
+#define ERROR_INVALID_SHOWWIN_COMMAND    1449L
+#define ERROR_NO_SYSTEM_RESOURCES        1450L
+#define ERROR_NONPAGED_SYSTEM_RESOURCES  1451L
+#define ERROR_PAGED_SYSTEM_RESOURCES     1452L
+#define ERROR_WORKING_SET_QUOTA          1453L
+#define ERROR_PAGEFILE_QUOTA             1454L
+#define ERROR_COMMITMENT_LIMIT           1455L
+#define ERROR_MENU_ITEM_NOT_FOUND        1456L
+#define ERROR_EVENTLOG_FILE_CORRUPT      1500L
+#define ERROR_EVENTLOG_CANT_START        1501L
+#define ERROR_LOG_FILE_FULL              1502L
+#define ERROR_EVENTLOG_FILE_CHANGED      1503L
+#define RPC_S_INVALID_STRING_BINDING     1700L
+#define RPC_S_WRONG_KIND_OF_BINDING      1701L
+#define RPC_S_INVALID_BINDING            1702L
+#define RPC_S_PROTSEQ_NOT_SUPPORTED      1703L
+#define RPC_S_INVALID_RPC_PROTSEQ        1704L
+#define RPC_S_INVALID_STRING_UUID        1705L
+#define RPC_S_INVALID_ENDPOINT_FORMAT    1706L
+#define RPC_S_INVALID_NET_ADDR           1707L
+#define RPC_S_NO_ENDPOINT_FOUND          1708L
+#define RPC_S_INVALID_TIMEOUT            1709L
+#define RPC_S_OBJECT_NOT_FOUND           1710L
+#define RPC_S_ALREADY_REGISTERED         1711L
+#define RPC_S_TYPE_ALREADY_REGISTERED    1712L
+#define RPC_S_ALREADY_LISTENING          1713L
+#define RPC_S_NO_PROTSEQS_REGISTERED     1714L
+#define RPC_S_NOT_LISTENING              1715L
+#define RPC_S_UNKNOWN_MGR_TYPE           1716L
+#define RPC_S_UNKNOWN_IF                 1717L
+#define RPC_S_NO_BINDINGS                1718L
+#define RPC_S_NO_PROTSEQS                1719L
+#define RPC_S_CANT_CREATE_ENDPOINT       1720L
+#define RPC_S_OUT_OF_RESOURCES           1721L
+#define RPC_S_SERVER_UNAVAILABLE         1722L
+#define RPC_S_SERVER_TOO_BUSY            1723L
+#define RPC_S_INVALID_NETWORK_OPTIONS    1724L
+#define RPC_S_NO_CALL_ACTIVE             1725L
+#define RPC_S_CALL_FAILED                1726L
+#define RPC_S_CALL_FAILED_DNE            1727L
+#define RPC_S_PROTOCOL_ERROR             1728L
+#define RPC_S_UNSUPPORTED_TRANS_SYN      1730L
+#define RPC_S_UNSUPPORTED_TYPE           1732L
+#define RPC_S_INVALID_TAG                1733L
+#define RPC_S_INVALID_BOUND              1734L
+#define RPC_S_NO_ENTRY_NAME              1735L
+#define RPC_S_INVALID_NAME_SYNTAX        1736L
+#define RPC_S_UNSUPPORTED_NAME_SYNTAX    1737L
+#define RPC_S_UUID_NO_ADDRESS            1739L
+#define RPC_S_DUPLICATE_ENDPOINT         1740L
+#define RPC_S_UNKNOWN_AUTHN_TYPE         1741L
+#define RPC_S_MAX_CALLS_TOO_SMALL        1742L
+#define RPC_S_STRING_TOO_LONG            1743L
+#define RPC_S_PROTSEQ_NOT_FOUND          1744L
+#define RPC_S_PROCNUM_OUT_OF_RANGE       1745L
+#define RPC_S_BINDING_HAS_NO_AUTH        1746L
+#define RPC_S_UNKNOWN_AUTHN_SERVICE      1747L
+#define RPC_S_UNKNOWN_AUTHN_LEVEL        1748L
+#define RPC_S_INVALID_AUTH_IDENTITY      1749L
+#define RPC_S_UNKNOWN_AUTHZ_SERVICE      1750L
+#define EPT_S_INVALID_ENTRY              1751L
+#define EPT_S_CANT_PERFORM_OP            1752L
+#define EPT_S_NOT_REGISTERED             1753L
+#define RPC_S_NOTHING_TO_EXPORT          1754L
+#define RPC_S_INCOMPLETE_NAME            1755L
+#define RPC_S_INVALID_VERS_OPTION        1756L
+#define RPC_S_NO_MORE_MEMBERS            1757L
+#define RPC_S_NOT_ALL_OBJS_UNEXPORTED    1758L
+#define RPC_S_INTERFACE_NOT_FOUND        1759L
+#define RPC_S_ENTRY_ALREADY_EXISTS       1760L
+#define RPC_S_ENTRY_NOT_FOUND            1761L
+#define RPC_S_NAME_SERVICE_UNAVAILABLE   1762L
+#define RPC_S_INVALID_NAF_ID             1763L
+#define RPC_S_CANNOT_SUPPORT             1764L
+#define RPC_S_NO_CONTEXT_AVAILABLE       1765L
+#define RPC_S_INTERNAL_ERROR             1766L
+#define RPC_S_ZERO_DIVIDE                1767L
+#define RPC_S_ADDRESS_ERROR              1768L
+#define RPC_S_FP_DIV_ZERO                1769L
+#define RPC_S_FP_UNDERFLOW               1770L
+#define RPC_S_FP_OVERFLOW                1771L
+#define RPC_X_NO_MORE_ENTRIES            1772L
+#define RPC_X_SS_CHAR_TRANS_OPEN_FAIL    1773L
+#define RPC_X_SS_CHAR_TRANS_SHORT_FILE   1774L
+#define RPC_X_SS_IN_NULL_CONTEXT         1775L
+#define RPC_X_SS_CONTEXT_DAMAGED         1777L
+#define RPC_X_SS_HANDLES_MISMATCH        1778L
+#define RPC_X_SS_CANNOT_GET_CALL_HANDLE  1779L
+#define RPC_X_NULL_REF_POINTER           1780L
+#define RPC_X_ENUM_VALUE_OUT_OF_RANGE    1781L
+#define RPC_X_BYTE_COUNT_TOO_SMALL       1782L
+#define RPC_X_BAD_STUB_DATA              1783L
+#define ERROR_INVALID_USER_BUFFER        1784L
+#define ERROR_UNRECOGNIZED_MEDIA         1785L
+#define ERROR_NO_TRUST_LSA_SECRET        1786L
+#define ERROR_NO_TRUST_SAM_ACCOUNT       1787L
+#define ERROR_TRUSTED_DOMAIN_FAILURE     1788L
+#define ERROR_TRUSTED_RELATIONSHIP_FAILURE 1789L
+#define ERROR_TRUST_FAILURE              1790L
+#define RPC_S_CALL_IN_PROGRESS           1791L
+#define ERROR_NETLOGON_NOT_STARTED       1792L
+#define ERROR_ACCOUNT_EXPIRED            1793L
+#define ERROR_REDIRECTOR_HAS_OPEN_HANDLES 1794L
+#define ERROR_PRINTER_DRIVER_ALREADY_INSTALLED 1795L
+#define ERROR_UNKNOWN_PORT               1796L
+#define ERROR_UNKNOWN_PRINTER_DRIVER     1797L
+#define ERROR_UNKNOWN_PRINTPROCESSOR     1798L
+#define ERROR_INVALID_SEPARATOR_FILE     1799L
+#define ERROR_INVALID_PRIORITY           1800L
+#define ERROR_INVALID_PRINTER_NAME       1801L
+#define ERROR_PRINTER_ALREADY_EXISTS     1802L
+#define ERROR_INVALID_PRINTER_COMMAND    1803L
+#define ERROR_INVALID_DATATYPE           1804L
+#define ERROR_INVALID_ENVIRONMENT        1805L
+#define RPC_S_NO_MORE_BINDINGS           1806L
+#define ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT 1807L
+#define ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT 1808L
+#define ERROR_NOLOGON_SERVER_TRUST_ACCOUNT 1809L
+#define ERROR_DOMAIN_TRUST_INCONSISTENT  1810L
+#define ERROR_SERVER_HAS_OPEN_HANDLES    1811L
+#define ERROR_RESOURCE_DATA_NOT_FOUND    1812L
+#define ERROR_RESOURCE_TYPE_NOT_FOUND    1813L
+#define ERROR_RESOURCE_NAME_NOT_FOUND    1814L
+#define ERROR_RESOURCE_LANG_NOT_FOUND    1815L
+#define ERROR_NOT_ENOUGH_QUOTA           1816L
+#define RPC_S_NO_INTERFACES              1817L
+#define RPC_S_CALL_CANCELLED             1818L
+#define RPC_S_BINDING_INCOMPLETE         1819L
+#define RPC_S_COMM_FAILURE               1820L
+#define RPC_S_UNSUPPORTED_AUTHN_LEVEL    1821L
+#define RPC_S_NO_PRINC_NAME              1822L
+#define RPC_S_NOT_RPC_ERROR              1823L
+#define RPC_S_UUID_LOCAL_ONLY            1824L
+#define RPC_S_SEC_PKG_ERROR              1825L
+#define RPC_S_NOT_CANCELLED              1826L
+#define RPC_X_INVALID_ES_ACTION          1827L
+#define RPC_X_WRONG_ES_VERSION           1828L
+#define RPC_X_WRONG_STUB_VERSION         1829L
+#define RPC_S_GROUP_MEMBER_NOT_FOUND     1898L
+#define EPT_S_CANT_CREATE                1899L
+#define RPC_S_INVALID_OBJECT             1900L
+#define ERROR_INVALID_TIME               1901L
+#define ERROR_INVALID_FORM_NAME          1902L
+#define ERROR_INVALID_FORM_SIZE          1903L
+#define ERROR_ALREADY_WAITING            1904L
+#define ERROR_PRINTER_DELETED            1905L
+#define ERROR_INVALID_PRINTER_STATE      1906L
+#define ERROR_PASSWORD_MUST_CHANGE       1907L
+#define ERROR_DOMAIN_CONTROLLER_NOT_FOUND 1908L
+#define ERROR_ACCOUNT_LOCKED_OUT         1909L
+#define ERROR_NO_BROWSER_SERVERS_FOUND   6118L
+#define ERROR_INVALID_PIXEL_FORMAT       2000L
+#define ERROR_BAD_DRIVER                 2001L
+#define ERROR_INVALID_WINDOW_STYLE       2002L
+#define ERROR_METAFILE_NOT_SUPPORTED     2003L
+#define ERROR_TRANSFORM_NOT_SUPPORTED    2004L
+#define ERROR_CLIPPING_NOT_SUPPORTED     2005L
+#define ERROR_UNKNOWN_PRINT_MONITOR      3000L
+#define ERROR_PRINTER_DRIVER_IN_USE      3001L
+#define ERROR_SPOOL_FILE_NOT_FOUND       3002L
+#define ERROR_SPL_NO_STARTDOC            3003L
+#define ERROR_SPL_NO_ADDJOB              3004L
+#define ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED 3005L
+#define ERROR_PRINT_MONITOR_ALREADY_INSTALLED 3006L
+#define ERROR_WINS_INTERNAL              4000L
+#define ERROR_CAN_NOT_DEL_LOCAL_WINS     4001L
+#define ERROR_STATIC_INIT                4002L
+#define ERROR_INC_BACKUP                 4003L
+#define ERROR_FULL_BACKUP                4004L
+#define ERROR_REC_NON_EXISTENT           4005L
+#define ERROR_RPL_NOT_ALLOWED            4006L
+#define ERROR_NO_BROWSER_SERVERS_FOUND   6118L
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _GNU_H_WINDOWS32_ERROR */

reactos/include/in.h

@@ -0,0 +1,491 @@
+unsigned int wavelength=3891;
+
+unsigned char wave[]={
+0x52,0x49,0x46,0x46,0x2b,0xf,0x0,0x0,
+0x57,0x41,0x56,0x45,0x66,0x6d,0x74,0x20,
+0x10,0x0,0x0,0x0,0x1,0x0,0x1,0x0,
+0x22,0x56,0x0,0x0,0x22,0x56,0x0,0x0,
+0x1,0x0,0x8,0x0,0x64,0x61,0x74,0x61,
+0x7,0xf,0x0,0x0,0x80,0xce,0xb2,0x53,
+0x2e,0x75,0xca,0xbb,0x5d,0x2c,0x6a,0xc4,
+0xc2,0x68,0x2c,0x5f,0xbd,0xc8,0x74,0x2e,
+0x51,0xad,0xd0,0x8a,0x36,0x3f,0x98,0xd2,
+0xa2,0x46,0x33,0x81,0xcd,0xb5,0x58,0x2d,
+0x67,0xbe,0xc8,0x78,0x30,0x49,0xa3,0xd2,
+0x9b,0x43,0x34,0x80,0xcc,0xb9,0x60,0x2c,
+0x5e,0xb6,0xce,0x89,0x39,0x3b,0x8b,0xce,
+0xb4,0x5c,0x2d,0x5e,0xb6,0xce,0x89,0x39,
+0x3a,0x8b,0xce,0xb7,0x62,0x2d,0x54,0xaa,
+0xd1,0x9b,0x46,0x31,0x74,0xc2,0xc7,0x7b,
+0x34,0x41,0x94,0xcf,0xb3,0x61,0x2e,0x53,
+0xa6,0xd1,0xa3,0x4f,0x2e,0x65,0xb7,0xce,
+0x90,0x41,0x33,0x78,0xc3,0xc8,0x83,0x3a,
+0x38,0x80,0xc6,0xc4,0x7d,0x36,0x3c,0x86,
+0xc9,0xc0,0x76,0x34,0x40,0x8d,0xcb,0xbe,
+0x74,0x34,0x3e,0x87,0xc9,0xc1,0x78,0x36,
+0x3b,0x83,0xc7,0xc4,0x7e,0x39,0x39,0x7d,
+0xc2,0xc9,0x8a,0x42,0x32,0x6a,0xb6,0xce,
+0x9c,0x4f,0x2e,0x5b,0xa8,0xd0,0xab,0x5d,
+0x2f,0x49,0x94,0xcb,0xbe,0x78,0x39,0x38,
+0x77,0xbd,0xcc,0x95,0x4a,0x2f,0x5c,0xa7,
+0xcf,0xb0,0x68,0x33,0x40,0x83,0xc3,0xc9,
+0x8e,0x47,0x30,0x5c,0xa6,0xcf,0xb2,0x6b,
+0x34,0x3e,0x7e,0xbf,0xcc,0x99,0x51,0x2f,
+0x4f,0x96,0xcb,0xc1,0x81,0x40,0x32,0x64,
+0xab,0xcf,0xb0,0x6c,0x36,0x39,0x74,0xb7,
+0xce,0xa7,0x61,0x32,0x40,0x80,0xbe,0xcc,
+0x9d,0x56,0x30,0x48,0x88,0xc3,0xca,0x99,
+0x54,0x30,0x47,0x88,0xc2,0xca,0x98,0x55,
+0x30,0x47,0x87,0xc1,0xca,0x9a,0x58,0x31,
+0x42,0x80,0xbb,0xcd,0xa5,0x63,0x34,0x3b,
+0x73,0xb3,0xce,0xb1,0x6f,0x39,0x36,0x66,
+0xa6,0xcc,0xbe,0x84,0x47,0x30,0x50,0x8f,
+0xc4,0xc9,0x9b,0x5c,0x33,0x3f,0x77,0xb4,
+0xce,0xb2,0x77,0x40,0x32,0x57,0x96,0xc6,
+0xc7,0x99,0x5a,0x33,0x3e,0x73,0xb0,0xcd,
+0xb7,0x7e,0x45,0x31,0x4e,0x88,0xbe,0xcc,
+0xa9,0x6c,0x3b,0x34,0x5d,0x99,0xc7,0xc7,
+0x99,0x5d,0x35,0x3a,0x69,0xa3,0xca,0xc3,
+0x93,0x58,0x33,0x3c,0x6e,0xa8,0xcb,0xc0,
+0x8f,0x54,0x33,0x3f,0x6f,0xa8,0xcb,0xc1,
+0x91,0x58,0x34,0x3b,0x69,0xa3,0xc9,0xc5,
+0x98,0x5f,0x37,0x38,0x61,0x99,0xc4,0xc9,
+0xa5,0x6d,0x3e,0x33,0x52,0x88,0xba,0xcc,
+0xb3,0x80,0x4b,0x32,0x44,0x76,0xac,0xca,
+0xc2,0x96,0x5f,0x38,0x36,0x5b,0x91,0xbf,
+0xcb,0xaf,0x7b,0x49,0x32,0x44,0x75,0xa9,
+0xc9,0xc4,0x9d,0x68,0x3d,0x34,0x50,0x83,
+0xb5,0xcb,0xbc,0x8f,0x59,0x37,0x38,0x5d,
+0x91,0xbd,0xcb,0xb6,0x85,0x53,0x35,0x3a,
+0x60,0x94,0xbe,0xcb,0xb3,0x83,0x51,0x34,
+0x3c,0x62,0x95,0xbe,0xcb,0xb6,0x87,0x56,
+0x37,0x39,0x5a,0x8c,0xb9,0xcb,0xbb,0x90,
+0x5d,0x3a,0x35,0x52,0x80,0xb0,0xc9,0xc3,
+0x9f,0x6e,0x44,0x33,0x43,0x6d,0x9f,0xc2,
+0xc9,0xaf,0x81,0x53,0x37,0x39,0x57,0x85,
+0xb2,0xc9,0xc2,0x9f,0x6e,0x45,0x34,0x41,
+0x68,0x98,0xbe,0xca,0xb8,0x8e,0x61,0x3d,
+0x34,0x49,0x72,0xa1,0xc2,0xc9,0xb2,0x88,
+0x5a,0x3b,0x36,0x4e,0x7a,0xa6,0xc4,0xc8,
+0xb0,0x85,0x59,0x3b,0x36,0x4d,0x76,0xa3,
+0xc3,0xc9,0xb3,0x89,0x5d,0x3d,0x35,0x49,
+0x70,0x9c,0xbe,0xc9,0xba,0x96,0x6a,0x44,
+0x35,0x40,0x61,0x8d,0xb4,0xc8,0xc2,0xa4,
+0x7a,0x51,0x38,0x38,0x4f,0x78,0xa2,0xc0,
+0xc9,0xb8,0x93,0x68,0x45,0x35,0x3f,0x5f,
+0x89,0xaf,0xc6,0xc6,0xad,0x86,0x5e,0x3f,
+0x35,0x43,0x66,0x8f,0xb4,0xc7,0xc3,0xa9,
+0x81,0x58,0x3d,0x36,0x46,0x67,0x8f,0xb4,
+0xc7,0xc4,0xab,0x85,0x5d,0x3f,0x36,0x43,
+0x63,0x8a,0xb0,0xc5,0xc6,0xb1,0x8e,0x66,
+0x46,0x36,0x3c,0x56,0x7d,0xa2,0xbf,0xc8,
+0xbc,0x9c,0x77,0x51,0x3a,0x37,0x48,0x69,
+0x8f,0xb2,0xc5,0xc5,0xb2,0x8f,0x69,0x48,
+0x37,0x3b,0x51,0x75,0x9b,0xba,0xc7,0xc1,
+0xaa,0x86,0x62,0x44,0x37,0x3d,0x55,0x79,
+0x9d,0xba,0xc7,0xc1,0xa8,0x85,0x61,0x44,
+0x37,0x3c,0x54,0x75,0x99,0xb7,0xc6,0xc3,
+0xae,0x8e,0x69,0x4a,0x39,0x3a,0x4c,0x6b,
+0x8f,0xaf,0xc3,0xc6,0xb8,0x9c,0x79,0x57,
+0x3f,0x37,0x41,0x59,0x7c,0x9e,0xb9,0xc6,
+0xc2,0xad,0x8e,0x6c,0x4d,0x3b,0x38,0x46,
+0x61,0x82,0xa4,0xbc,0xc7,0xc0,0xaa,0x8a,
+0x68,0x4b,0x3a,0x39,0x48,0x62,0x84,0xa4,
+0xbc,0xc6,0xc1,0xad,0x8d,0x6d,0x4f,0x3c,
+0x38,0x44,0x5d,0x7d,0x9d,0xb6,0xc5,0xc4,
+0xb5,0x99,0x79,0x5b,0x43,0x38,0x3d,0x50,
+0x6c,0x8c,0xab,0xbf,0xc6,0xbf,0xaa,0x8d,
+0x6e,0x52,0x3e,0x38,0x41,0x56,0x73,0x92,
+0xae,0xc1,0xc6,0xbc,0xa5,0x87,0x6a,0x4f,
+0x3d,0x39,0x41,0x57,0x73,0x92,0xad,0xbf,
+0xc5,0xbe,0xa9,0x8d,0x70,0x53,0x40,0x39,
+0x3f,0x50,0x6b,0x88,0xa5,0xba,0xc5,0xc2,
+0xb3,0x9a,0x7e,0x61,0x49,0x3b,0x3a,0x46,
+0x5b,0x78,0x94,0xae,0xbf,0xc5,0xbe,0xad,
+0x93,0x77,0x5b,0x46,0x3b,0x3b,0x47,0x5b,
+0x77,0x92,0xac,0xbe,0xc5,0xc0,0xb1,0x9a,
+0x7e,0x63,0x4c,0x3e,0x3a,0x41,0x52,0x6a,
+0x85,0x9f,0xb4,0xc1,0xc4,0xbc,0xab,0x93,
+0x79,0x5f,0x4a,0x3d,0x3a,0x42,0x53,0x6a,
+0x82,0x9c,0xb1,0xc0,0xc4,0xbf,0xb0,0x9a,
+0x80,0x68,0x51,0x42,0x3a,0x3d,0x48,0x5c,
+0x73,0x8d,0xa4,0xb7,0xc2,0xc3,0xbc,0xac,
+0x96,0x7e,0x67,0x51,0x42,0x3b,0x3d,0x48,
+0x5a,0x70,0x88,0x9f,0xb2,0xbf,0xc3,0xbf,
+0xb3,0xa1,0x89,0x72,0x5c,0x4a,0x3e,0x3b,
+0x3f,0x4c,0x5e,0x75,0x8a,0xa1,0xb3,0xbf,
+0xc3,0xbf,0xb5,0xa3,0x8e,0x77,0x61,0x4e,
+0x41,0x3b,0x3d,0x46,0x55,0x69,0x80,0x95,
+0xa9,0xb8,0xc1,0xc3,0xbd,0xb0,0x9f,0x8a,
+0x75,0x61,0x4e,0x42,0x3c,0x3d,0x44,0x52,
+0x65,0x7a,0x8e,0xa2,0xb2,0xbd,0xc2,0xc0,
+0xb8,0xaa,0x98,0x83,0x6f,0x5c,0x4c,0x41,
+0x3c,0x3d,0x45,0x52,0x63,0x77,0x8b,0x9e,
+0xaf,0xbb,0xc1,0xc1,0xbc,0xb1,0xa1,0x8f,
+0x7b,0x67,0x56,0x48,0x3f,0x3c,0x3f,0x47,
+0x54,0x65,0x77,0x8a,0x9d,0xad,0xb9,0xc0,
+0xc2,0xbe,0xb5,0xa7,0x97,0x83,0x72,0x60,
+0x50,0x45,0x3e,0x3d,0x40,0x49,0x56,0x66,
+0x78,0x8a,0x9c,0xab,0xb7,0xbf,0xc1,0xbf,
+0xb8,0xac,0x9d,0x8c,0x7b,0x6a,0x59,0x4c,
+0x43,0x3d,0x3d,0x42,0x4b,0x57,0x67,0x79,
+0x89,0x9a,0xa8,0xb5,0xbd,0xc1,0xc0,0xbb,
+0xb1,0xa5,0x95,0x84,0x74,0x63,0x56,0x4a,
+0x42,0x3e,0x3e,0x43,0x4b,0x57,0x66,0x75,
+0x85,0x95,0xa4,0xb0,0xba,0xbf,0xc0,0xbe,
+0xb7,0xad,0xa0,0x92,0x81,0x72,0x63,0x55,
+0x4a,0x42,0x3e,0x3e,0x42,0x48,0x53,0x60,
+0x6e,0x7e,0x8d,0x9b,0xa9,0xb4,0xbb,0xbf,
+0xc0,0xbd,0xb7,0xad,0xa1,0x93,0x84,0x75,
+0x67,0x5a,0x4f,0x46,0x40,0x3e,0x3f,0x44,
+0x4b,0x56,0x63,0x71,0x80,0x8d,0x9a,0xa7,
+0xb1,0xb9,0xbe,0xc0,0xbe,0xb9,0xb2,0xa7,
+0x9c,0x8e,0x80,0x73,0x65,0x59,0x4f,0x47,
+0x41,0x3f,0x3f,0x43,0x49,0x53,0x5d,0x69,
+0x76,0x84,0x91,0x9e,0xa9,0xb3,0xba,0xbe,
+0xbf,0xbe,0xba,0xb3,0xaa,0xa0,0x93,0x86,
+0x7a,0x6d,0x60,0x55,0x4d,0x46,0x41,0x3f,
+0x40,0x44,0x49,0x51,0x5c,0x66,0x72,0x80,
+0x8b,0x97,0xa2,0xac,0xb4,0xba,0xbd,0xbe,
+0xbd,0xb9,0xb4,0xab,0xa1,0x96,0x8b,0x80,
+0x73,0x68,0x5d,0x52,0x4b,0x45,0x41,0x40,
+0x41,0x44,0x49,0x50,0x58,0x63,0x6e,0x7a,
+0x85,0x90,0x9b,0xa5,0xae,0xb5,0xba,0xbd,
+0xbe,0xbd,0xba,0xb4,0xae,0xa5,0x9b,0x91,
+0x85,0x7b,0x70,0x65,0x5b,0x53,0x4b,0x46,
+0x42,0x41,0x41,0x43,0x47,0x4c,0x54,0x5d,
+0x67,0x71,0x7c,0x86,0x90,0x9a,0xa3,0xac,
+0xb3,0xb8,0xbb,0xbd,0xbd,0xbb,0xb7,0xb2,
+0xac,0xa3,0x9b,0x91,0x87,0x7d,0x72,0x69,
+0x5f,0x57,0x50,0x4a,0x45,0x42,0x41,0x42,
+0x43,0x47,0x4c,0x53,0x5b,0x63,0x6c,0x76,
+0x80,0x88,0x93,0x9c,0xa4,0xab,0xb1,0xb6,
+0xba,0xbc,0xbd,0xbc,0xb9,0xb5,0xb0,0xaa,
+0xa2,0x9a,0x91,0x87,0x80,0x76,0x6c,0x63,
+0x5c,0x55,0x4e,0x49,0x45,0x43,0x42,0x42,
+0x44,0x47,0x4b,0x50,0x57,0x5e,0x66,0x6f,
+0x78,0x80,0x89,0x92,0x9a,0xa2,0xa8,0xae,
+0xb4,0xb7,0xba,0xbc,0xbc,0xbb,0xb8,0xb5,
+0xb0,0xab,0xa4,0x9d,0x95,0x8d,0x85,0x7c,
+0x74,0x6c,0x64,0x5c,0x56,0x51,0x4c,0x48,
+0x45,0x43,0x43,0x43,0x45,0x48,0x4b,0x50,
+0x56,0x5d,0x63,0x6b,0x73,0x7b,0x82,0x8a,
+0x92,0x99,0xa0,0xa7,0xac,0xb1,0xb5,0xb8,
+0xba,0xbb,0xbb,0xba,0xb8,0xb4,0xb1,0xac,
+0xa6,0xa0,0x9a,0x92,0x8b,0x83,0x7c,0x75,
+0x6d,0x66,0x60,0x5a,0x54,0x4f,0x4b,0x48,
+0x45,0x44,0x43,0x44,0x45,0x47,0x4a,0x4e,
+0x53,0x58,0x5e,0x64,0x6b,0x72,0x79,0x80,
+0x87,0x8d,0x94,0x9b,0xa1,0xa6,0xac,0xaf,
+0xb3,0xb6,0xb8,0xba,0xba,0xba,0xb9,0xb7,
+0xb4,0xb0,0xad,0xa8,0xa2,0x9d,0x97,0x90,
+0x8a,0x83,0x7d,0x76,0x70,0x69,0x64,0x5d,
+0x59,0x53,0x50,0x4c,0x49,0x47,0x45,0x44,
+0x44,0x45,0x46,0x48,0x4b,0x4f,0x52,0x57,
+0x5c,0x61,0x67,0x6c,0x72,0x79,0x80,0x85,
+0x8b,0x91,0x96,0x9c,0xa2,0xa7,0xab,0xaf,
+0xb2,0xb5,0xb7,0xb8,0xb9,0xb9,0xb9,0xb8,
+0xb6,0xb4,0xb1,0xae,0xaa,0xa6,0xa1,0x9c,
+0x96,0x91,0x8c,0x86,0x80,0x7a,0x75,0x6f,
+0x6a,0x64,0x5f,0x5b,0x56,0x52,0x4f,0x4c,
+0x4a,0x48,0x46,0x46,0x45,0x46,0x47,0x48,
+0x4a,0x4c,0x4f,0x52,0x56,0x5a,0x5e,0x63,
+0x68,0x6e,0x72,0x78,0x7d,0x82,0x88,0x8c,
+0x92,0x97,0x9b,0xa0,0xa4,0xa8,0xac,0xaf,
+0xb1,0xb3,0xb6,0xb7,0xb8,0xb8,0xb8,0xb7,
+0xb6,0xb5,0xb3,0xb0,0xad,0xaa,0xa7,0xa3,
+0x9f,0x9b,0x97,0x92,0x8c,0x87,0x82,0x7f,
+0x7a,0x75,0x70,0x6b,0x66,0x62,0x5e,0x5a,
+0x56,0x54,0x51,0x4e,0x4c,0x4a,0x49,0x47,
+0x47,0x47,0x47,0x47,0x48,0x4a,0x4b,0x4d,
+0x50,0x53,0x55,0x59,0x5d,0x61,0x64,0x68,
+0x6d,0x71,0x76,0x7b,0x7f,0x82,0x87,0x8b,
+0x90,0x95,0x98,0x9c,0xa0,0xa3,0xa7,0xaa,
+0xad,0xaf,0xb1,0xb3,0xb4,0xb5,0xb6,0xb7,
+0xb7,0xb6,0xb6,0xb5,0xb3,0xb2,0xb0,0xad,
+0xab,0xa8,0xa5,0xa2,0x9e,0x9a,0x96,0x93,
+0x8e,0x8a,0x86,0x81,0x7f,0x7a,0x76,0x72,
+0x6d,0x6a,0x65,0x62,0x5e,0x5b,0x58,0x55,
+0x53,0x50,0x4e,0x4c,0x4b,0x4a,0x49,0x48,
+0x48,0x48,0x49,0x49,0x4a,0x4b,0x4d,0x4f,
+0x51,0x54,0x56,0x59,0x5c,0x5f,0x63,0x66,
+0x6a,0x6e,0x72,0x76,0x7a,0x7e,0x80,0x85,
+0x89,0x8d,0x90,0x94,0x98,0x9c,0x9f,0xa2,
+0xa5,0xa7,0xaa,0xac,0xae,0xb0,0xb2,0xb3,
+0xb4,0xb5,0xb5,0xb5,0xb5,0xb5,0xb4,0xb3,
+0xb2,0xb0,0xaf,0xad,0xab,0xa8,0xa6,0xa3,
+0xa0,0x9d,0x9a,0x96,0x93,0x8f,0x8c,0x88,
+0x84,0x80,0x7e,0x7a,0x76,0x72,0x6f,0x6b,
+0x68,0x65,0x62,0x5f,0x5c,0x59,0x57,0x54,
+0x52,0x50,0x4f,0x4d,0x4c,0x4b,0x4a,0x4a,
+0x4a,0x4a,0x4a,0x4a,0x4b,0x4c,0x4d,0x4f,
+0x50,0x52,0x54,0x56,0x59,0x5c,0x5e,0x61,
+0x64,0x67,0x6a,0x6d,0x71,0x74,0x77,0x7b,
+0x7f,0x81,0x84,0x88,0x8b,0x8e,0x92,0x95,
+0x98,0x9b,0x9e,0xa1,0xa3,0xa5,0xa8,0xaa,
+0xac,0xad,0xaf,0xb0,0xb1,0xb2,0xb3,0xb3,
+0xb3,0xb3,0xb3,0xb3,0xb2,0xb2,0xb1,0xb0,
+0xae,0xac,0xab,0xa9,0xa7,0xa4,0xa2,0xa0,
+0x9d,0x9a,0x97,0x95,0x91,0x8f,0x8b,0x89,
+0x85,0x82,0x80,0x7d,0x79,0x76,0x73,0x70,
+0x6d,0x6a,0x68,0x65,0x62,0x5f,0x5d,0x5b,
+0x59,0x56,0x55,0x53,0x51,0x50,0x4f,0x4e,
+0x4d,0x4c,0x4c,0x4c,0x4b,0x4b,0x4c,0x4c,
+0x4d,0x4e,0x4e,0x50,0x51,0x53,0x54,0x56,
+0x58,0x5a,0x5b,0x5d,0x60,0x63,0x65,0x68,
+0x6a,0x6d,0x70,0x73,0x76,0x78,0x7c,0x7f,
+0x80,0x84,0x87,0x89,0x8c,0x8f,0x92,0x94,
+0x97,0x99,0x9c,0x9e,0xa0,0xa2,0xa5,0xa6,
+0xa8,0xaa,0xab,0xad,0xae,0xaf,0xaf,0xb0,
+0xb1,0xb1,0xb2,0xb2,0xb2,0xb1,0xb1,0xb1,
+0xb0,0xaf,0xae,0xad,0xac,0xab,0xa9,0xa8,
+0xa5,0xa4,0xa2,0xa0,0x9e,0x9c,0x99,0x97,
+0x95,0x92,0x90,0x8d,0x8b,0x88,0x86,0x82,
+0x80,0x7e,0x7b,0x78,0x76,0x73,0x71,0x6e,
+0x6c,0x69,0x67,0x65,0x63,0x60,0x5e,0x5d,
+0x5b,0x59,0x57,0x56,0x54,0x53,0x52,0x51,
+0x50,0x50,0x4f,0x4e,0x4e,0x4e,0x4d,0x4d,
+0x4e,0x4e,0x4e,0x4f,0x4f,0x50,0x51,0x52,
+0x53,0x54,0x56,0x57,0x58,0x5a,0x5c,0x5e,
+0x60,0x62,0x63,0x65,0x67,0x6a,0x6c,0x6f,
+0x71,0x73,0x75,0x78,0x7a,0x7d,0x7f,0x80,
+0x83,0x85,0x88,0x8a,0x8c,0x8f,0x91,0x93,
+0x95,0x97,0x99,0x9b,0x9d,0x9f,0xa1,0xa2,
+0xa4,0xa5,0xa7,0xa8,0xa9,0xaa,0xab,0xac,
+0xad,0xae,0xae,0xaf,0xaf,0xaf,0xaf,0xaf,
+0xaf,0xaf,0xaf,0xae,0xae,0xad,0xad,0xac,
+0xab,0xaa,0xa9,0xa8,0xa7,0xa5,0xa4,0xa3,
+0xa1,0x9f,0x9e,0x9c,0x9a,0x98,0x96,0x95,
+0x92,0x91,0x8e,0x8c,0x8a,0x88,0x86,0x84,
+0x81,0x80,0x7e,0x7c,0x7a,0x78,0x75,0x73,
+0x71,0x6f,0x6d,0x6b,0x6a,0x67,0x66,0x64,
+0x63,0x61,0x5f,0x5e,0x5c,0x5b,0x5a,0x58,
+0x57,0x56,0x55,0x54,0x53,0x53,0x52,0x51,
+0x51,0x50,0x50,0x50,0x50,0x50,0x50,0x50,
+0x50,0x50,0x51,0x51,0x52,0x53,0x53,0x54,
+0x55,0x56,0x57,0x58,0x59,0x5a,0x5c,0x5d,
+0x5f,0x60,0x61,0x63,0x64,0x66,0x68,0x69,
+0x6c,0x6d,0x6f,0x71,0x73,0x74,0x77,0x78,
+0x7a,0x7c,0x7e,0x80,0x81,0x83,0x84,0x87,
+0x88,0x8a,0x8c,0x8e,0x8f,0x92,0x93,0x94,
+0x96,0x98,0x99,0x9b,0x9d,0x9e,0x9f,0xa0,
+0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,
+0xa9,0xaa,0xaa,0xab,0xac,0xac,0xac,0xac,
+0xad,0xad,0xad,0xad,0xad,0xac,0xac,0xac,
+0xac,0xab,0xab,0xaa,0xaa,0xa9,0xa8,0xa7,
+0xa6,0xa6,0xa5,0xa4,0xa2,0xa1,0xa0,0x9f,
+0x9e,0x9d,0x9b,0x99,0x98,0x97,0x95,0x94,
+0x93,0x90,0x8f,0x8d,0x8c,0x8a,0x89,0x87,
+0x86,0x83,0x82,0x80,0x80,0x7e,0x7c,0x7b,
+0x79,0x78,0x76,0x75,0x72,0x71,0x6f,0x6e,
+0x6c,0x6b,0x6a,0x68,0x67,0x66,0x64,0x63,
+0x62,0x61,0x60,0x5e,0x5d,0x5c,0x5b,0x5a,
+0x59,0x59,0x58,0x57,0x56,0x56,0x55,0x55,
+0x54,0x54,0x54,0x53,0x53,0x53,0x53,0x53,
+0x53,0x53,0x53,0x53,0x53,0x54,0x54,0x54,
+0x55,0x55,0x56,0x56,0x56,0x57,0x58,0x59,
+0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,0x60,
+0x61,0x62,0x64,0x64,0x65,0x67,0x68,0x69,
+0x6b,0x6c,0x6e,0x6f,0x70,0x71,0x73,0x74,
+0x76,0x77,0x79,0x7a,0x7c,0x7d,0x7e,0x80,
+0x80,0x82,0x83,0x85,0x86,0x88,0x89,0x8a,
+0x8b,0x8d,0x8e,0x90,0x91,0x92,0x93,0x94,
+0x96,0x97,0x98,0x99,0x9a,0x9b,0x9c,0x9d,
+0x9e,0x9f,0xa0,0xa1,0xa2,0xa2,0xa3,0xa4,
+0xa5,0xa5,0xa6,0xa6,0xa7,0xa7,0xa8,0xa8,
+0xa8,0xa9,0xa9,0xa9,0xa9,0xa9,0xaa,0xaa,
+0xaa,0xa9,0xa9,0xa9,0xa9,0xa9,0xa9,0xa8,
+0xa8,0xa8,0xa7,0xa7,0xa6,0xa6,0xa5,0xa4,
+0xa4,0xa3,0xa2,0xa1,0xa1,0xa0,0x9f,0x9e,
+0x9d,0x9d,0x9c,0x9a,0x99,0x99,0x97,0x96,
+0x95,0x94,0x93,0x92,0x90,0x8f,0x8e,0x8d,
+0x8c,0x8a,0x89,0x88,0x87,0x85,0x84,0x83,
+0x81,0x80,0x80,0x7f,0x7d,0x7d,0x7b,0x7a,
+0x78,0x77,0x76,0x75,0x74,0x73,0x71,0x70,
+0x6f,0x6e,0x6c,0x6c,0x6b,0x69,0x68,0x68,
+0x66,0x65,0x65,0x64,0x63,0x62,0x61,0x60,
+0x5f,0x5f,0x5e,0x5d,0x5d,0x5c,0x5b,0x5b,
+0x5a,0x5a,0x59,0x59,0x58,0x58,0x58,0x57,
+0x57,0x57,0x57,0x57,0x56,0x56,0x56,0x56,
+0x56,0x56,0x56,0x57,0x57,0x57,0x57,0x57,
+0x58,0x58,0x58,0x59,0x59,0x5a,0x5a,0x5a,
+0x5b,0x5c,0x5c,0x5d,0x5d,0x5e,0x5f,0x5f,
+0x60,0x61,0x62,0x63,0x64,0x64,0x65,0x66,
+0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,
+0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,
+0x77,0x78,0x7a,0x7b,0x7c,0x7d,0x7e,0x80,
+0x80,0x81,0x81,0x83,0x84,0x85,0x86,0x87,
+0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,
+0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x96,
+0x98,0x98,0x99,0x9a,0x9b,0x9b,0x9c,0x9d,
+0x9d,0x9e,0x9f,0x9f,0xa0,0xa0,0xa1,0xa1,
+0xa2,0xa2,0xa3,0xa3,0xa3,0xa4,0xa4,0xa4,
+0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa6,0xa6,
+0xa6,0xa6,0xa6,0xa6,0xa6,0xa5,0xa5,0xa5,
+0xa5,0xa5,0xa5,0xa4,0xa4,0xa4,0xa3,0xa3,
+0xa3,0xa2,0xa2,0xa1,0xa1,0xa0,0xa0,0x9f,
+0x9f,0x9e,0x9e,0x9d,0x9d,0x9c,0x9b,0x9a,
+0x9a,0x99,0x98,0x97,0x97,0x96,0x95,0x95,
+0x93,0x93,0x92,0x91,0x90,0x8f,0x8e,0x8d,
+0x8d,0x8c,0x8b,0x8a,0x89,0x88,0x87,0x86,
+0x85,0x84,0x83,0x82,0x81,0x80,0x80,0x80,
+0x7e,0x7e,0x7d,0x7c,0x7b,0x7a,0x79,0x78,
+0x77,0x76,0x75,0x74,0x74,0x73,0x72,0x71,
+0x70,0x70,0x6e,0x6e,0x6d,0x6c,0x6b,0x6a,
+0x6a,0x69,0x68,0x67,0x67,0x66,0x65,0x65,
+0x64,0x64,0x63,0x62,0x62,0x62,0x61,0x61,
+0x60,0x60,0x5f,0x5f,0x5e,0x5e,0x5d,0x5d,
+0x5d,0x5d,0x5c,0x5c,0x5c,0x5c,0x5b,0x5b,
+0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,
+0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,
+0x5b,0x5c,0x5c,0x5c,0x5c,0x5d,0x5d,0x5d,
+0x5e,0x5e,0x5e,0x5f,0x5f,0x60,0x60,0x60,
+0x61,0x61,0x62,0x62,0x63,0x63,0x64,0x64,
+0x65,0x65,0x66,0x67,0x67,0x68,0x69,0x69,
+0x6a,0x6b,0x6b,0x6c,0x6d,0x6d,0x6e,0x6f,
+0x70,0x70,0x71,0x72,0x73,0x73,0x74,0x75,
+0x76,0x77,0x77,0x78,0x79,0x7a,0x7b,0x7b,
+0x7c,0x7d,0x7e,0x7e,0x80,0x80,0x80,0x81,
+0x82,0x82,0x83,0x84,0x85,0x85,0x86,0x87,
+0x88,0x88,0x89,0x8a,0x8b,0x8b,0x8c,0x8d,
+0x8d,0x8e,0x8f,0x90,0x90,0x91,0x92,0x92,
+0x93,0x93,0x94,0x95,0x95,0x96,0x96,0x97,
+0x97,0x98,0x99,0x99,0x99,0x9a,0x9a,0x9b,
+0x9b,0x9b,0x9c,0x9c,0x9d,0x9d,0x9d,0x9e,
+0x9e,0x9e,0x9e,0x9f,0x9f,0x9f,0x9f,0xa0,
+0xa0,0xa0,0xa0,0xa0,0xa0,0xa1,0xa1,0xa1,
+0xa1,0xa1,0xa1,0xa1,0xa1,0xa1,0xa1,0xa1,
+0xa1,0xa1,0xa1,0xa1,0xa0,0xa0,0xa0,0xa0,
+0xa0,0xa0,0x9f,0x9f,0x9f,0x9f,0x9f,0x9e,
+0x9e,0x9e,0x9d,0x9d,0x9d,0x9c,0x9c,0x9c,
+0x9b,0x9b,0x9a,0x9a,0x9a,0x99,0x99,0x98,
+0x98,0x97,0x97,0x96,0x96,0x95,0x95,0x94,
+0x94,0x93,0x93,0x92,0x92,0x91,0x90,0x90,
+0x8f,0x8f,0x8e,0x8d,0x8d,0x8c,0x8c,0x8b,
+0x8a,0x8a,0x89,0x88,0x88,0x87,0x87,0x86,
+0x85,0x85,0x84,0x83,0x83,0x82,0x81,0x81,
+0x80,0x80,0x80,0x7f,0x7e,0x7e,0x7d,0x7d,
+0x7c,0x7b,0x7a,0x7a,0x79,0x79,0x78,0x78,
+0x77,0x76,0x75,0x75,0x74,0x74,0x73,0x73,
+0x72,0x72,0x71,0x71,0x70,0x6f,0x6f,0x6e,
+0x6e,0x6d,0x6d,0x6c,0x6c,0x6b,0x6b,0x6a,
+0x6a,0x69,0x69,0x69,0x68,0x68,0x68,0x67,
+0x67,0x66,0x66,0x65,0x65,0x65,0x65,0x64,
+0x64,0x64,0x63,0x63,0x63,0x63,0x62,0x62,
+0x62,0x62,0x62,0x61,0x61,0x61,0x61,0x61,
+0x61,0x61,0x60,0x60,0x60,0x60,0x60,0x60,
+0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,
+0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x61,
+0x61,0x61,0x61,0x61,0x61,0x62,0x62,0x62,
+0x62,0x62,0x63,0x63,0x63,0x63,0x64,0x64,
+0x64,0x64,0x65,0x65,0x65,0x66,0x66,0x66,
+0x66,0x67,0x67,0x67,0x68,0x68,0x69,0x69,
+0x69,0x6a,0x6a,0x6b,0x6b,0x6b,0x6c,0x6c,
+0x6d,0x6d,0x6e,0x6e,0x6e,0x6f,0x6f,0x70,
+0x70,0x71,0x71,0x72,0x72,0x73,0x73,0x74,
+0x74,0x75,0x75,0x76,0x76,0x77,0x77,0x78,
+0x78,0x79,0x79,0x7a,0x7a,0x7b,0x7b,0x7c,
+0x7c,0x7d,0x7d,0x7e,0x7e,0x7f,0x80,0x80,
+0x80,0x80,0x81,0x81,0x82,0x82,0x83,0x83,
+0x84,0x84,0x84,0x85,0x85,0x86,0x86,0x87,
+0x87,0x88,0x88,0x89,0x89,0x8a,0x8a,0x8b,
+0x8b,0x8b,0x8c,0x8c,0x8d,0x8d,0x8e,0x8e,
+0x8e,0x8e,0x8f,0x8f,0x90,0x90,0x91,0x91,
+0x91,0x92,0x92,0x92,0x93,0x93,0x93,0x94,
+0x94,0x94,0x94,0x95,0x95,0x95,0x96,0x96,
+0x96,0x96,0x97,0x97,0x97,0x97,0x98,0x98,
+0x98,0x98,0x98,0x99,0x99,0x99,0x99,0x99,
+0x99,0x9a,0x9a,0x9a,0x9a,0x9a,0x9a,0x9a,
+0x9a,0x9a,0x9a,0x9b,0x9b,0x9b,0x9b,0x9b,
+0x9b,0x9b,0x9b,0x9b,0x9b,0x9b,0x9b,0x9b,
+0x9b,0x9b,0x9b,0x9b,0x9b,0x9a,0x9a,0x9a,
+0x9a,0x9a,0x9a,0x9a,0x9a,0x9a,0x9a,0x9a,
+0x99,0x99,0x99,0x99,0x99,0x99,0x98,0x98,
+0x98,0x98,0x98,0x98,0x97,0x97,0x97,0x97,
+0x96,0x96,0x96,0x96,0x96,0x95,0x95,0x95,
+0x94,0x94,0x94,0x94,0x94,0x93,0x93,0x93,
+0x92,0x92,0x92,0x91,0x91,0x91,0x90,0x90,
+0x90,0x90,0x8f,0x8f,0x8e,0x8e,0x8e,0x8e,
+0x8d,0x8d,0x8c,0x8c,0x8c,0x8b,0x8b,0x8b,
+0x8a,0x8a,0x89,0x89,0x89,0x89,0x88,0x88,
+0x87,0x87,0x86,0x86,0x86,0x85,0x85,0x85,
+0x84,0x84,0x84,0x83,0x83,0x82,0x82,0x82,
+0x81,0x81,0x80,0x80,0x80,0x80,0x80,0x80,
+0x7f,0x7f,0x7f,0x7e,0x7e,0x7d,0x7d,0x7d,
+0x7c,0x7c,0x7b,0x7b,0x7b,0x7b,0x7a,0x7a,
+0x79,0x79,0x79,0x78,0x78,0x77,0x77,0x77,
+0x77,0x76,0x76,0x75,0x75,0x75,0x75,0x74,
+0x74,0x74,0x73,0x73,0x73,0x72,0x72,0x72,
+0x72,0x71,0x71,0x71,0x70,0x70,0x70,0x6f,
+0x6f,0x6f,0x6f,0x6e,0x6e,0x6e,0x6e,0x6e,
+0x6d,0x6d,0x6d,0x6d,0x6c,0x6c,0x6c,0x6c,
+0x6c,0x6b,0x6b,0x6b,0x6b,0x6b,0x6a,0x6a,
+0x6a,0x6a,0x6a,0x6a,0x6a,0x69,0x69,0x69,
+0x69,0x69,0x69,0x69,0x69,0x68,0x68,0x68,
+0x68,0x68,0x68,0x68,0x68,0x68,0x68,0x68,
+0x68,0x67,0x67,0x67,0x67,0x67,0x67,0x67,
+0x67,0x67,0x67,0x67,0x67,0x67,0x67,0x67,
+0x67,0x67,0x67,0x67,0x67,0x67,0x67,0x67,
+0x67,0x67,0x67,0x67,0x68,0x68,0x68,0x68,
+0x68,0x68,0x68,0x68,0x68,0x68,0x68,0x68,
+0x68,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+0x69,0x6a,0x6a,0x6a,0x6a,0x6a,0x6a,0x6a,
+0x6b,0x6b,0x6b,0x6b,0x6b,0x6b,0x6c,0x6c,
+0x6c,0x6c,0x6c,0x6d,0x6d,0x6d,0x6d,0x6d,
+0x6d,0x6e,0x6e,0x6e,0x6e,0x6e,0x6f,0x6f,
+0x6f,0x6f,0x6f,0x70,0x70,0x70,0x70,0x71,
+0x71,0x71,0x71,0x72,0x72,0x72,0x72,0x73,
+0x73,0x73,0x73,0x73,0x74,0x74,0x74,0x74,
+0x75,0x75,0x75,0x76,0x76,0x76,0x76,0x77,
+0x77,0x77,0x77,0x77,0x78,0x78,0x79,0x79,
+0x79,0x79,0x79,0x7a,0x7a,0x7a,0x7a,0x7b,
+0x7b,0x7b,0x7c,0x7c,0x7c,0x7c,0x7c,0x7d,
+0x7d,0x7d,0x7e,0x7e,0x7e,0x7e,0x7f,0x7f,
+0x7f,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+0x80,0x80,0x81,0x81,0x81,0x82,0x82,0x82,
+0x82,0x82,0x83,0x83,0x83,0x83,0x84,0x84,
+0x84,0x84,0x84,0x85,0x85,0x85,0x86,0x86,
+0x86,0x86,0x87,0x87,0x87,0x87,0x87,0x88,
+0x88,0x88,0x88,0x88,0x89,0x89,0x89,0x89,
+0x89,0x89,0x8a,0x8a,0x8a,0x8a,0x8b,0x8b,
+0x8b,0x8b,0x8b,0x8b,0x8b,0x8c,0x8c,0x8c,
+0x8c,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,
+0x8d,0x8e,0x8e,0x8e,0x8e,0x8e,0x8e,0x8e,
+0x8f,0x8f,0x8f,0x8f,0x8f,0x8f,0x8f,0x8f,
+0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
+0x90,0x90,0x90,0x91,0x91,0x91,0x91,0x91,
+0x91,0x91,0x91,0x91,0x91,0x91,0x91,0x91,
+0x92,0x91,0x92,0x92,0x92,0x92,0x92,0x92,
+0x92,0x92,0x92,0x92,0x92,0x92,0x92,0x92,
+0x92,0x92,0x92,0x92,0x92,0x92,0x92,0x92,
+0x92,0x92,0x92,0x92,0x92,0x92,0x92,0x92,
+0x92,0x92,0x92,0x92,0x92,0x92,0x92,0x92,
+0x92,0x92,0x92,0x92,0x92,0x92,0x92,0x92,
+0x91,0x91,0x91,0x91,0x91,0x91,0x91,0x91,
+0x91,0x91,0x91,0x91,0x91,0x91,0x91,0x91,
+0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
+0x90,0x90,0x90,0x90,0x8f,0x8f,0x8f,0x8f,
+0x8f,0x8f,0x8f,0x8f,0x8f,0x8e,0x8e,0x8e,
+0x8e,0x8e,0x8e,0x8e,0x8e,0x8e,0x8d,0x8d,
+0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8c,
+0x8c,0x8c,0x8c,0x8c,0x8c,0x8c,0x8b,0x8b,
+0x8b,0x8b,0x8b,0x8b,0x8b,0x8a,0x8a,0x8a,
+0x8a,0x8a,0x8a,0x8a,0x89,0x89,0x89,0x89,
+0x89,0x89,0x88,0x88,0x88,0x88,0x88,0x88,
+0x88,0x87,0x87,0x87,0x87,0x87,0x86,0x86,
+0x86,0x86,0x86,0x86,0x86,0x86,0x85,0x85,
+0x85,0x85,0x85,0x84,0x84,0x84,0x84,0x84,
+0x84,0x84,0x84,0x83,0x83,0x83,0x83,0x83,
+0x83,0x82,0x82,0x82,0x82,0x82,0x81,0x81,
+0x81,0x81,0x81,0x81,0x81,0x81,0x80,0x80,
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+0x80,0x80,0x80,0x7f,0x7f,0x7f,0x7f,0x7f,
+0x7f,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7d,
+0x7e,0x7d,0x7d,0x7d,0x7d,0x7d,0x7d,0x7d,
+0x7d,0x7d,0x7d,0x7d,0x7d,0x7d,0x7d,0x7d,
+0x7d,0x7d,0x7d,0x7d,0x7d,0x7d,0x7d,0x7d,
+0x7d,0x7d,0x7d,0x7d,0x7d,0x7d,0x7e,0x7d,
+0x7d,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,
+0x7e,0x7e,0x7e,0x7f,0x7f,0x7f,0x7f,0x7f,
+0x7f,0x7f,0x80,0x80,0x80,0x80,0x80,0x80,
+};

reactos/include/internal/bitops.h

@@ -0,0 +1,140 @@
+#ifndef _I386_BITOPS_H
+#define _I386_BITOPS_H
+
+/*
+ * Copyright 1992, Linus Torvalds.
+ */
+/*
+ * Reused for the ReactOS kernel by David Welch (1998)
+ */
+
+/*
+ * These have to be done with inline assembly: that way the bit-setting
+ * is guaranteed to be atomic. All bit operations return 0 if the bit
+ * was cleared before the operation and != 0 if it was not.
+ *
+ * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
+ */
+
+#ifdef __SMP__
+#define LOCK_PREFIX "lock ; "
+#define SMPVOL volatile
+#else
+#define LOCK_PREFIX ""
+#define SMPVOL
+#endif
+
+/*
+ * Some hacks to defeat gcc over-optimizations..
+ */
+struct __dummy { unsigned long a[100]; };
+#define ADDR (*(struct __dummy *) addr)
+#define CONST_ADDR (*(const struct __dummy *) addr)
+
+extern __inline__ int set_bit(int nr, SMPVOL void * addr)
+{
+	int oldbit;
+
+	__asm__ __volatile__(LOCK_PREFIX
+		"btsl %2,%1\n\tsbbl %0,%0"
+		:"=r" (oldbit),"=m" (ADDR)
+		:"ir" (nr));
+	return oldbit;
+}
+
+extern __inline__ int clear_bit(int nr, SMPVOL void * addr)
+{
+	int oldbit;
+
+	__asm__ __volatile__(LOCK_PREFIX
+		"btrl %2,%1\n\tsbbl %0,%0"
+		:"=r" (oldbit),"=m" (ADDR)
+		:"ir" (nr));
+	return oldbit;
+}
+
+extern __inline__ int change_bit(int nr, SMPVOL void * addr)
+{
+	int oldbit;
+
+	__asm__ __volatile__(LOCK_PREFIX
+		"btcl %2,%1\n\tsbbl %0,%0"
+		:"=r" (oldbit),"=m" (ADDR)
+		:"ir" (nr));
+	return oldbit;
+}
+
+/*
+ * This routine doesn't need to be atomic.
+ */
+extern __inline__ int test_bit(int nr, const SMPVOL void * addr)
+{
+	return ((1UL << (nr & 31)) & (((const unsigned int *) addr)[nr >> 5])) != 0;
+}
+
+/*
+ * Find-bit routines..
+ */
+extern __inline__ int find_first_zero_bit(void * addr, unsigned size)
+{
+	int res;
+
+	if (!size)
+		return 0;
+	__asm__("cld\n\t"
+		"movl $-1,%%eax\n\t"
+		"xorl %%edx,%%edx\n\t"
+		"repe; scasl\n\t"
+		"je 1f\n\t"
+		"xorl -4(%%edi),%%eax\n\t"
+		"subl $4,%%edi\n\t"
+		"bsfl %%eax,%%edx\n"
+		"1:\tsubl %%ebx,%%edi\n\t"
+		"shll $3,%%edi\n\t"
+		"addl %%edi,%%edx"
+		:"=d" (res)
+		:"c" ((size + 31) >> 5), "D" (addr), "b" (addr)
+		:"ax", "cx", "di");
+	return res;
+}
+
+extern __inline__ int find_next_zero_bit (void * addr, int size, int offset)
+{
+	unsigned long * p = ((unsigned long *) addr) + (offset >> 5);
+	int set = 0, bit = offset & 31, res;
+	
+	if (bit) {
+		/*
+		 * Look for zero in first byte
+		 */
+		__asm__("bsfl %1,%0\n\t"
+			"jne 1f\n\t"
+			"movl $32, %0\n"
+			"1:"
+			: "=r" (set)
+			: "r" (~(*p >> bit)));
+		if (set < (32 - bit))
+			return set + offset;
+		set = 32 - bit;
+		p++;
+	}
+	/*
+	 * No zero yet, search remaining full bytes for a zero
+	 */
+	res = find_first_zero_bit (p, size - 32 * (p - (unsigned long *) addr));
+	return (offset + set + res);
+}
+
+/*
+ * ffz = Find First Zero in word. Undefined if no zero exists,
+ * so code should check against ~0UL first..
+ */
+extern __inline__ unsigned long ffz(unsigned long word)
+{
+	__asm__("bsfl %1,%0"
+		:"=r" (word)
+		:"r" (~word));
+	return word;
+}
+
+#endif /* _I386_BITOPS_H */

reactos/include/internal/ctype.h

@@ -0,0 +1,71 @@
+#ifndef _LINUX_CTYPE_H
+#define _LINUX_CTYPE_H
+
+
+#ifdef USE_OLD_CTYPE_IMPLEMENTATION
+
+#define _U	0x01	/* upper */
+#define _L	0x02	/* lower */
+#define _D	0x04	/* digit */
+#define _C	0x08	/* cntrl */
+#define _P	0x10	/* punct */
+#define _S	0x20	/* white space (space/lf/tab) */
+#define _X	0x40	/* hex digit */
+#define _SP	0x80	/* hard space (0x20) */
+
+extern unsigned char _ctype[];
+extern char _ctmp;
+
+#define isalnum(c) ((_ctype+1)[c]&(_U|_L|_D))
+#define isalpha(c) ((_ctype+1)[c]&(_U|_L))
+#define iscntrl(c) ((_ctype+1)[c]&(_C))
+#define isdigit(c) ((_ctype+1)[c]&(_D))
+#define isgraph(c) ((_ctype+1)[c]&(_P|_U|_L|_D))
+#define islower(c) ((_ctype+1)[c]&(_L))
+#define isprint(c) ((_ctype+1)[c]&(_P|_U|_L|_D|_SP))
+#define ispunct(c) ((_ctype+1)[c]&(_P))
+#define isspace(c) ((_ctype+1)[c]&(_S))
+#define isupper(c) ((_ctype+1)[c]&(_U))
+#define isxdigit(c) ((_ctype+1)[c]&(_D|_X))
+
+#define isascii(c) (((unsigned) c)<=0x7f)
+#define toascii(c) (((unsigned) c)&0x7f)
+
+#define tolower(c) (_ctmp=c,isupper(_ctmp)?_ctmp-('A'-'a'):_ctmp)
+#define toupper(c) (_ctmp=c,islower(_ctmp)?_ctmp-('a'-'A'):_ctmp)
+
+#else
+
+#define upalpha ('A' - 'a')
+
+extern inline char toupper(char c)
+{
+   if ((c>='a') && (c<='z')) return (c+upalpha);
+   return(c);
+}
+
+extern inline int islower(char c)
+{
+   if ((c>='a') && (c<='z')) return 1;
+   return 0;
+}
+
+extern inline int isdigit(char c)
+{
+   if ((c>='0') && (c<='9')) return 1;
+   return 0;
+}
+
+extern inline int isxdigit(char c)
+{
+   if (((c>='0') && (c<='9')) || ((toupper(c)>='A') && (toupper(c)<='Z')))
+     {
+	return 1;
+     }
+   return 0;
+}
+
+
+#endif
+
+#endif

reactos/include/internal/debug.h

@@ -0,0 +1,72 @@
+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS kernel
+ * FILE:            include/internal/debug.h
+ * PURPOSE:         Useful debugging macros
+ * PROGRAMMER:      David Welch (welch@mcmail.com)
+ * UPDATE HISTORY: 
+ *                28/05/98: Created
+ */
+
+/*
+ * NOTE: Define NDEBUG before including this header to disable debugging
+ * macros
+ */
+
+#ifndef __INTERNAL_DEBUG
+#define __INTERNAL_DEBUG
+
+#define UNIMPLEMENTED do {DbgPrint("%s at %s:%d is umimplemented, have a nice day\n",__FUNCTION__,__FILE__,__LINE__); for(;;);  } while(0);
+
+#ifndef NDEBUG
+#define DPRINT(fmt,args...) do { DbgPrint("(%s:%d) ",__FILE__,__LINE__); DbgPrint(fmt,args); } while(0);
+//#define assert(x) if (!(x)) {DbgPrint("Assertion "#x" failed at %s:%d\n", __FILE__,__LINE__); (*((unsigned int *)0))=1; for (;;); }
+#define assert(x) if (!(x)) {DbgPrint("Assertion "#x" failed at %s:%d\n", __FILE__,__LINE__); for (;;); }
+#define CHECKPOINT DbgPrint("%s:%d\n",__FILE__,__LINE__)
+#else
+#define DPRINT(fmt,args...)
+#define assert(x)
+#define CHECKPOINT
+#endif /* NDEBUG */
+
+/*
+ * FUNCTION: Assert a maximum value for the current irql
+ * ARGUMENTS:
+ *        x = Maximum irql
+ */
+#define ASSERT_IRQL(x) assert(KeGetCurrentIrql()<=(x))
+#define assert_irql(x) assert(KeGetCurrentIrql()<=(x))
+
+#define HBP_EXECUTE     (0)
+#define HBP_WRITE       (1)
+#define HBP_READWRITE   (3)
+
+#define HBP_BYTE        (0)
+#define HBP_WORD        (1)
+#define HBP_DWORD       (3)
+
+/*
+ * FUNCTION: Sets a hardware breakpoint
+ * ARGUMENTS:
+ *          i = breakpoint to set (0 to 3)
+ *          addr = linear address to break on
+ *          type = Type of access to break on
+ *          len = length of the variable to watch
+ * NOTES:
+ *       The variable to watch must be aligned to its length (i.e. a dword
+ *	 breakpoint must be aligned to a dword boundary)
+ * 
+ *       A fatal exception will be generated on the access to the variable.
+ *       It is (at the moment) only really useful for catching undefined
+ *       pointers if you know the variable effected but not the buggy
+ *       routine. 
+ * 
+ * FIXME: Extend to call out to kernel debugger on breakpoint
+ *        Add support for I/O breakpoints
+ * REFERENCES: See the i386 programmer manual for more details
+ */ 
+void set_breakpoint(unsigned int i, unsigned int addr, unsigned int type,
+		    unsigned int len);
+
+
+#endif /* __INTERNAL_DEBUG */

reactos/include/internal/dma.h

@@ -0,0 +1,267 @@
+/* $Id: dma.h,v 1.1.1.2 1998/08/25 04:27:32 rex Exp $
+ * linux/include/asm/dma.h: Defines for using and allocating dma channels.
+ * Written by Hennus Bergman, 1992.
+ * High DMA channel support & info by Hannu Savolainen
+ * and John Boyd, Nov. 1992.
+ */
+
+#ifndef _ASM_DMA_H
+#define _ASM_DMA_H
+
+#include <internal/hal/io.h>             /* need byte IO */
+
+
+#ifdef HAVE_REALLY_SLOW_DMA_CONTROLLER
+#define dma_outb	outb_p
+#else
+#define dma_outb	outb
+#endif
+
+#define dma_inb		inb
+
+/*
+ * NOTES about DMA transfers:
+ *
+ *  controller 1: channels 0-3, byte operations, ports 00-1F
+ *  controller 2: channels 4-7, word operations, ports C0-DF
+ *
+ *  - ALL registers are 8 bits only, regardless of transfer size
+ *  - channel 4 is not used - cascades 1 into 2.
+ *  - channels 0-3 are byte - addresses/counts are for physical bytes
+ *  - channels 5-7 are word - addresses/counts are for physical words
+ *  - transfers must not cross physical 64K (0-3) or 128K (5-7) boundaries
+ *  - transfer count loaded to registers is 1 less than actual count
+ *  - controller 2 offsets are all even (2x offsets for controller 1)
+ *  - page registers for 5-7 don't use data bit 0, represent 128K pages
+ *  - page registers for 0-3 use bit 0, represent 64K pages
+ *
+ * DMA transfers are limited to the lower 16MB of _physical_ memory.  
+ * Note that addresses loaded into registers must be _physical_ addresses,
+ * not logical addresses (which may differ if paging is active).
+ *
+ *  Address mapping for channels 0-3:
+ *
+ *   A23 ... A16 A15 ... A8  A7 ... A0    (Physical addresses)
+ *    |  ...  |   |  ... |   |  ... |
+ *    |  ...  |   |  ... |   |  ... |
+ *    |  ...  |   |  ... |   |  ... |
+ *   P7  ...  P0  A7 ... A0  A7 ... A0   
+ * |    Page    | Addr MSB | Addr LSB |   (DMA registers)
+ *
+ *  Address mapping for channels 5-7:
+ *
+ *   A23 ... A17 A16 A15 ... A9 A8 A7 ... A1 A0    (Physical addresses)
+ *    |  ...  |   \   \   ... \  \  \  ... \  \
+ *    |  ...  |    \   \   ... \  \  \  ... \  (not used)
+ *    |  ...  |     \   \   ... \  \  \  ... \
+ *   P7  ...  P1 (0) A7 A6  ... A0 A7 A6 ... A0   
+ * |      Page      |  Addr MSB   |  Addr LSB  |   (DMA registers)
+ *
+ * Again, channels 5-7 transfer _physical_ words (16 bits), so addresses
+ * and counts _must_ be word-aligned (the lowest address bit is _ignored_ at
+ * the hardware level, so odd-byte transfers aren't possible).
+ *
+ * Transfer count (_not # bytes_) is limited to 64K, represented as actual
+ * count - 1 : 64K => 0xFFFF, 1 => 0x0000.  Thus, count is always 1 or more,
+ * and up to 128K bytes may be transferred on channels 5-7 in one operation. 
+ *
+ */
+
+#define MAX_DMA_CHANNELS	8
+
+/* The maximum address that we can perform a DMA transfer to on this platform */
+#define MAX_DMA_ADDRESS      0x1000000
+
+/* 8237 DMA controllers */
+#define IO_DMA1_BASE	0x00	/* 8 bit slave DMA, channels 0..3 */
+#define IO_DMA2_BASE	0xC0	/* 16 bit master DMA, ch 4(=slave input)..7 */
+
+/* DMA controller registers */
+#define DMA1_CMD_REG		0x08	/* command register (w) */
+#define DMA1_STAT_REG		0x08	/* status register (r) */
+#define DMA1_REQ_REG            0x09    /* request register (w) */
+#define DMA1_MASK_REG		0x0A	/* single-channel mask (w) */
+#define DMA1_MODE_REG		0x0B	/* mode register (w) */
+#define DMA1_CLEAR_FF_REG	0x0C	/* clear pointer flip-flop (w) */
+#define DMA1_TEMP_REG           0x0D    /* Temporary Register (r) */
+#define DMA1_RESET_REG		0x0D	/* Master Clear (w) */
+#define DMA1_CLR_MASK_REG       0x0E    /* Clear Mask */
+#define DMA1_MASK_ALL_REG       0x0F    /* all-channels mask (w) */
+
+#define DMA2_CMD_REG		0xD0	/* command register (w) */
+#define DMA2_STAT_REG		0xD0	/* status register (r) */
+#define DMA2_REQ_REG            0xD2    /* request register (w) */
+#define DMA2_MASK_REG		0xD4	/* single-channel mask (w) */
+#define DMA2_MODE_REG		0xD6	/* mode register (w) */
+#define DMA2_CLEAR_FF_REG	0xD8	/* clear pointer flip-flop (w) */
+#define DMA2_TEMP_REG           0xDA    /* Temporary Register (r) */
+#define DMA2_RESET_REG		0xDA	/* Master Clear (w) */
+#define DMA2_CLR_MASK_REG       0xDC    /* Clear Mask */
+#define DMA2_MASK_ALL_REG       0xDE    /* all-channels mask (w) */
+
+#define DMA_ADDR_0              0x00    /* DMA address registers */
+#define DMA_ADDR_1              0x02
+#define DMA_ADDR_2              0x04
+#define DMA_ADDR_3              0x06
+#define DMA_ADDR_4              0xC0
+#define DMA_ADDR_5              0xC4
+#define DMA_ADDR_6              0xC8
+#define DMA_ADDR_7              0xCC
+
+#define DMA_CNT_0               0x01    /* DMA count registers */
+#define DMA_CNT_1               0x03
+#define DMA_CNT_2               0x05
+#define DMA_CNT_3               0x07
+#define DMA_CNT_4               0xC2
+#define DMA_CNT_5               0xC6
+#define DMA_CNT_6               0xCA
+#define DMA_CNT_7               0xCE
+
+#define DMA_PAGE_0              0x87    /* DMA page registers */
+#define DMA_PAGE_1              0x83
+#define DMA_PAGE_2              0x81
+#define DMA_PAGE_3              0x82
+#define DMA_PAGE_5              0x8B
+#define DMA_PAGE_6              0x89
+#define DMA_PAGE_7              0x8A
+
+#define DMA_MODE_READ	0x44	/* I/O to memory, no autoinit, increment, single mode */
+#define DMA_MODE_WRITE	0x48	/* memory to I/O, no autoinit, increment, single mode */
+#define DMA_MODE_CASCADE 0xC0   /* pass thru DREQ->HRQ, DACK<-HLDA only */
+
+/* enable/disable a specific DMA channel */
+static __inline__ void enable_dma(unsigned int dmanr)
+{
+	if (dmanr<=3)
+                dma_outb(DMA1_MASK_REG, dmanr);
+	else
+                dma_outb(DMA2_MASK_REG, dmanr & 3);
+}
+
+static __inline__ void disable_dma(unsigned int dmanr)
+{
+	if (dmanr<=3)
+                dma_outb(DMA1_MASK_REG, dmanr | 4);
+	else
+                dma_outb(DMA2_MASK_REG, (dmanr & 3) | 4);
+}
+
+/* Clear the 'DMA Pointer Flip Flop'.
+ * Write 0 for LSB/MSB, 1 for MSB/LSB access.
+ * Use this once to initialize the FF to a known state.
+ * After that, keep track of it. :-)
+ * --- In order to do that, the DMA routines below should ---
+ * --- only be used while interrupts are disabled! ---
+ */
+static __inline__ void clear_dma_ff(unsigned int dmanr)
+{
+	if (dmanr<=3)
+                dma_outb(DMA1_CLEAR_FF_REG, 0);
+	else
+                dma_outb(DMA2_CLEAR_FF_REG, 0);
+}
+
+/* set mode (above) for a specific DMA channel */
+static __inline__ void set_dma_mode(unsigned int dmanr, char mode)
+{
+	if (dmanr<=3)
+                dma_outb(DMA1_MODE_REG, mode | dmanr);
+	else
+                dma_outb(DMA2_MODE_REG, mode | (dmanr&3));
+}
+
+/* Set only the page register bits of the transfer address.
+ * This is used for successive transfers when we know the contents of
+ * the lower 16 bits of the DMA current address register, but a 64k boundary
+ * may have been crossed.
+ */
+static __inline__ void set_dma_page(unsigned int dmanr, char pagenr)
+{
+	switch(dmanr) {
+		case 0:
+                        dma_outb(DMA_PAGE_0, pagenr);
+			break;
+		case 1:
+                        dma_outb(DMA_PAGE_1, pagenr);
+			break;
+		case 2:
+                        dma_outb(DMA_PAGE_2, pagenr);
+			break;
+		case 3:
+                        dma_outb(DMA_PAGE_3, pagenr);
+			break;
+		case 5:
+                        dma_outb(DMA_PAGE_5, pagenr & 0xfe);
+			break;
+		case 6:
+                        dma_outb(DMA_PAGE_6, pagenr & 0xfe);
+			break;
+		case 7:
+                        dma_outb(DMA_PAGE_7, pagenr & 0xfe);
+			break;
+	}
+}
+
+
+/* Set transfer address & page bits for specific DMA channel.
+ * Assumes dma flipflop is clear.
+ */
+static __inline__ void set_dma_addr(unsigned int dmanr, unsigned int a)
+{
+	set_dma_page(dmanr, a>>16);
+	if (dmanr <= 3)  {
+            dma_outb(((dmanr&3)<<1) + IO_DMA1_BASE, a & 0xff);
+            dma_outb(((dmanr&3)<<1) + IO_DMA1_BASE, (a>>8) & 0xff );
+	}  else  {
+            dma_outb( ((dmanr&3)<<2) + IO_DMA2_BASE ,(a>>1) & 0xff );
+            dma_outb( ((dmanr&3)<<2) + IO_DMA2_BASE,(a>>9) & 0xff );
+	}
+}
+
+
+/* Set transfer size (max 64k for DMA1..3, 128k for DMA5..7) for
+ * a specific DMA channel.
+ * You must ensure the parameters are valid.
+ * NOTE: from a manual: "the number of transfers is one more
+ * than the initial word count"! This is taken into account.
+ * Assumes dma flip-flop is clear.
+ * NOTE 2: "count" represents _bytes_ and must be even for channels 5-7.
+ */
+static __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
+{
+        count--;
+	if (dmanr <= 3)  {
+	    dma_outb( count & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
+	    dma_outb( (count>>8) & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
+        } else {
+	    dma_outb( (count>>1) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
+	    dma_outb( (count>>9) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
+        }
+}
+
+
+/* Get DMA residue count. After a DMA transfer, this
+ * should return zero. Reading this while a DMA transfer is
+ * still in progress will return unpredictable results.
+ * If called before the channel has been used, it may return 1.
+ * Otherwise, it returns the number of _bytes_ left to transfer.
+ *
+ * Assumes DMA flip-flop is clear.
+ */
+static __inline__ int get_dma_residue(unsigned int dmanr)
+{
+	unsigned int io_port = (dmanr<=3)? ((dmanr&3)<<1) + 1 + IO_DMA1_BASE
+					 : ((dmanr&3)<<2) + 2 + IO_DMA2_BASE;
+
+	/* using short to get 16-bit wrap around */
+	unsigned short count;
+
+	count = 1 + dma_inb(io_port);
+	count += dma_inb(io_port) << 8;
+	
+	return (dmanr<=3)? count : (count<<1);
+}
+
+
+
+#endif /* _ASM_DMA_H */

reactos/include/internal/hal.h

@@ -0,0 +1,10 @@
+#ifndef __INCLUDE_INTERNAL_HAL_H
+#define __INCLUDE_INTERNAL_HAL_H
+
+#ifdef i386
+#include <internal/i386/hal.h>
+#else
+#error "Unknown processor"
+#endif
+
+#endif

reactos/include/internal/hal/ddk.h

@@ -0,0 +1,117 @@
+/*
+ * COPYRIGHT:                See COPYING in the top level directory
+ * PROJECT:                  ReactOS kernel
+ * FILE:                     include/internal/hal/ddk.h
+ * PURPOSE:                  HAL provided defintions for device drivers
+ * PROGRAMMER:               David Welch (welch@mcmail.com)
+ * REVISION HISTORY:
+ *              23/06/98:   Taken from linux system.h
+ */
+
+
+#ifndef __INCLUDE_INTERNAL_HAL_DDK_H
+#define __INCLUDE_INTERNAL_HAL_DDK_H
+
+enum
+{
+   DEVICE_DESCRIPTION_VERSION,
+   DEVICE_DESCRIPTION_VERSION1,
+};
+
+typedef ULONG DMA_WIDTH;
+typedef ULONG DMA_SPEED;
+typedef ULONG BUS_DATA_TYPE;
+
+/*
+ * PURPOSE: Types for HalGetBusData
+ */
+enum
+{
+   Cmos,
+   EisaConfiguration,
+   Pos,
+   PCIConfiguration,
+   MaximumBusDataType,
+};
+
+typedef struct _DEVICE_DESCRIPTION
+{
+   ULONG Version;
+   BOOLEAN Master;
+   BOOLEAN ScatterGather;
+   BOOLEAN DemandMode;
+   BOOLEAN AutoInitialize;
+   BOOLEAN Dma32BitAddress;
+   BOOLEAN IgnoreCount;
+   BOOLEAN Reserved1;
+   BOOLEAN Reserved2;
+   ULONG BusNumber;
+   ULONG DmaChannel;
+   INTERFACE_TYPE InterfaceType;
+   DMA_WIDTH DmaWidth;
+   DMA_SPEED DmaSpeed;
+   ULONG MaximumLength;
+   ULONG DmaPort;
+} DEVICE_DESCRIPTION, *PDEVICE_DESCRIPTION;
+
+PVOID HalAllocateCommonBuffer(PADAPTER_OBJECT AdapterObject,
+			      ULONG Length,
+			      PPHYSICAL_ADDRESS LogicalAddress,
+			      BOOLEAN CacheEnabled);
+NTSTATUS HalAssignSlotResources(PUNICODE_STRING RegistryPath,
+				PUNICODE_STRING DriverClassName,
+				PDRIVER_OBJECT DriverObject,
+				PDEVICE_OBJECT DeviceObject,
+				INTERFACE_TYPE BusType,
+				ULONG BusNumber,
+				ULONG SlotNumber,
+				PCM_RESOURCE_LIST* AllocatedResources);
+VOID HalExamineMBR(PDEVICE_OBJECT DeviceObject,
+		   ULONG SectorSize,
+		   ULONG MBRTypeIdentifier,
+		   PVOID Buffer);
+VOID HalFreeCommonBuffer(PADAPTER_OBJECT AdapterObject,
+			 ULONG Length,
+			 PHYSICAL_ADDRESS LogicalAddress,
+			 PVOID VirtualAddress,
+			 BOOLEAN CacheEnabled);
+PADAPTER_OBJECT HalGetAdapter(PDEVICE_DESCRIPTION DeviceDescription,
+			      PULONG NumberOfMapRegisters);
+ULONG HalGetBusData(BUS_DATA_TYPE BusDataType,
+		    ULONG BusNumber,
+		    ULONG SlotNumber,
+		    PVOID Buffer,
+		    ULONG Length);
+ULONG HalGetBusDataByOffset(BUS_DATA_TYPE BusDataType,
+			    ULONG BusNumber,
+			    ULONG SlotNumber,
+			    PVOID Buffer,
+			    ULONG Offset,
+			    ULONG Length);
+ULONG HalGetDmaAlignmentRequirement(VOID);
+ULONG HalGetInterruptVector(INTERFACE_TYPE InterfaceType,
+			    ULONG BusNumber,
+			    ULONG BusInterruptLevel,
+			    ULONG BusInterruptVector,
+			    PKIRQL Irql,
+			    PKAFFINITY Affinity);
+VOID HalQuerySystemInformation(VOID);
+ULONG HalReadDmaCounter(PADAPTER_OBJECT AdapterObject);
+ULONG HalSetBusData(BUS_DATA_TYPE BusDataType,
+		    ULONG BusNumber,
+		    ULONG SlotNumber,
+		    PVOID Buffer,
+		    ULONG Length);
+ULONG HalSetBusDataByOffset(BUS_DATA_TYPE BusDataType,
+			    ULONG BusNumber,
+			    ULONG SlotNumber,
+			    PVOID Buffer,
+			    ULONG Offset,
+			    ULONG Length);
+BOOLEAN HalTranslateBusAddress(INTERFACE_TYPE InterfaceType,
+			       ULONG BusNumber,
+			       PHYSICAL_ADDRESS BusAddress,
+			       PULONG AddressSpace,
+			       PPHYSICAL_ADDRESS TranslatedAddress);
+
+#endif /* __INCLUDE_INTERNAL_HAL_DDK_H */

reactos/include/internal/hal/io.h

@@ -0,0 +1,167 @@
+#ifndef _ASM_IO_H
+#define _ASM_IO_H
+
+/*
+ * This file contains the definitions for the x86 IO instructions
+ * inb/inw/inl/outb/outw/outl and the "string versions" of the same
+ * (insb/insw/insl/outsb/outsw/outsl). You can also use "pausing"
+ * versions of the single-IO instructions (inb_p/inw_p/..).
+ *
+ * This file is not meant to be obfuscating: it's just complicated
+ * to (a) handle it all in a way that makes gcc able to optimize it
+ * as well as possible and (b) trying to avoid writing the same thing
+ * over and over again with slight variations and possibly making a
+ * mistake somewhere.
+ */
+
+/*
+ * Thanks to James van Artsdalen for a better timing-fix than
+ * the two short jumps: using outb's to a nonexistent port seems
+ * to guarantee better timings even on fast machines.
+ *
+ * On the other hand, I'd like to be sure of a non-existent port:
+ * I feel a bit unsafe about using 0x80 (should be safe, though)
+ *
+ *		Linus
+ */
+
+#ifdef SLOW_IO_BY_JUMPING
+#define __SLOW_DOWN_IO __asm__ __volatile__("jmp 1f\n1:\tjmp 1f\n1:")
+#else
+#define __SLOW_DOWN_IO __asm__ __volatile__("outb %al,$0x80")
+#endif
+
+#ifdef REALLY_SLOW_IO
+#define SLOW_DOWN_IO { __SLOW_DOWN_IO; __SLOW_DOWN_IO; __SLOW_DOWN_IO; __SLOW_DOWN_IO; }
+#else
+#define SLOW_DOWN_IO __SLOW_DOWN_IO
+#endif
+
+/*
+ * Talk about misusing macros..
+ */
+
+#define __OUT1(s,x) \
+extern inline void __out##s(unsigned x value, unsigned short port) {
+
+#define __OUT2(s,s1,s2) \
+__asm__ __volatile__ ("out" #s " %" s1 "0,%" s2 "1"
+
+#define __OUT(s,s1,x) \
+__OUT1(s,x) __OUT2(s,s1,"w") : : "a" (value), "d" (port)); } \
+__OUT1(s##c,x) __OUT2(s,s1,"") : : "a" (value), "id" (port)); } \
+__OUT1(s##_p,x) __OUT2(s,s1,"w") : : "a" (value), "d" (port)); SLOW_DOWN_IO; } \
+__OUT1(s##c_p,x) __OUT2(s,s1,"") : : "a" (value), "id" (port)); SLOW_DOWN_IO; }
+
+#define __IN1(s) \
+extern inline RETURN_TYPE __in##s(unsigned short port) { RETURN_TYPE _v;
+
+#define __IN2(s,s1,s2) \
+__asm__ __volatile__ ("in" #s " %" s2 "1,%" s1 "0"
+
+#define __IN(s,s1,i...) \
+__IN1(s) __IN2(s,s1,"w") : "=a" (_v) : "d" (port) ,##i ); return _v; } \
+__IN1(s##c) __IN2(s,s1,"") : "=a" (_v) : "id" (port) ,##i ); return _v; } \
+__IN1(s##_p) __IN2(s,s1,"w") : "=a" (_v) : "d" (port) ,##i ); SLOW_DOWN_IO; return _v; } \
+__IN1(s##c_p) __IN2(s,s1,"") : "=a" (_v) : "id" (port) ,##i ); SLOW_DOWN_IO; return _v; }
+
+#define __INS(s) \
+extern inline void ins##s(unsigned short port, void * addr, unsigned long count) \
+{ __asm__ __volatile__ ("cld ; rep ; ins" #s \
+: "=D" (addr), "=c" (count) : "d" (port),"0" (addr),"1" (count)); }
+
+#define __OUTS(s) \
+extern inline void outs##s(unsigned short port, const void * addr, unsigned long count) \
+{ __asm__ __volatile__ ("cld ; rep ; outs" #s \
+: "=S" (addr), "=c" (count) : "d" (port),"0" (addr),"1" (count)); }
+
+#define RETURN_TYPE unsigned char
+/* __IN(b,"b","0" (0)) */
+__IN(b,"")
+#undef RETURN_TYPE
+#define RETURN_TYPE unsigned short
+/* __IN(w,"w","0" (0)) */
+__IN(w,"")
+#undef RETURN_TYPE
+#define RETURN_TYPE unsigned int
+__IN(l,"")
+#undef RETURN_TYPE
+
+__OUT(b,"b",char)
+__OUT(w,"w",short)
+__OUT(l,,int)
+
+__INS(b)
+__INS(w)
+__INS(l)
+
+__OUTS(b)
+__OUTS(w)
+__OUTS(l)
+
+/*
+ * Note that due to the way __builtin_constant_p() works, you
+ *  - can't use it inside a inline function (it will never be true)
+ *  - you don't have to worry about side effects within the __builtin..
+ */
+#define outb(port,val) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__outbc((val),(port)) : \
+	__outb((val),(port)))
+
+#define inb(port) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__inbc(port) : \
+	__inb(port))
+
+#define outb_p(port,val) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__outbc_p((val),(port)) : \
+	__outb_p((val),(port)))
+
+#define inb_p(port) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__inbc_p(port) : \
+	__inb_p(port))
+
+#define outw(port,val) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__outwc((val),(port)) : \
+	__outw((val),(port)))
+
+#define inw(port) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__inwc(port) : \
+	__inw(port))
+
+#define outw_p(port,val) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__outwc_p((val),(port)) : \
+	__outw_p((val),(port)))
+
+#define inw_p(port) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__inwc_p(port) : \
+	__inw_p(port))
+
+#define outl(port,val) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__outlc((val),(port)) : \
+	__outl((val),(port)))
+
+#define inl(port) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__inlc(port) : \
+	__inl(port))
+
+#define outl_p(port,val) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__outlc_p((val),(port)) : \
+	__outl_p((val),(port)))
+
+#define inl_p(port) \
+((__builtin_constant_p((port)) && (port) < 256) ? \
+	__inlc_p(port) : \
+	__inl_p(port))
+
+#endif

reactos/include/internal/hal/irq.h

@@ -0,0 +1,7 @@
+/*
+ * PURPOSE: The number of device specific level levels
+ */
+#define NR_DEVICE_SPECIFIC_LEVELS (16)
+
+
+

reactos/include/internal/hal/page.h

@@ -0,0 +1,82 @@
+/*
+ * Lowlevel memory managment definitions
+ */
+
+#ifndef __INTERNAL_HAL_PAGE_H
+#define __INTERNAL_HAL_PAGE_H
+
+#include <ddk/ntddk.h>
+
+#define PAGESIZE (4096)
+
+/*
+ * Sets a page entry
+ *      vaddr:          The virtual address to set the page entry for
+ *      attributes:     The access attributes to give the page
+ *      physaddr:       The physical address the page should map to
+ */
+void set_page(unsigned int vaddr, unsigned int attributes,
+              unsigned int physaddr);
+
+#define PAGE_ROUND_UP(x) ( (((ULONG)x)%PAGESIZE) ? ((((ULONG)x)&(~0xfff))+0x1000) : ((ULONG)x) )
+#define PAGE_ROUND_DOWN(x) (((ULONG)x)&(~0xfff))
+
+/*
+ * Page access attributes (or these together)
+ */
+#define PA_READ            (1<<0)
+#define PA_WRITE           ((1<<0)+(1<<1))
+#define PA_EXECUTE         PA_READ
+#define PA_PCD             (1<<4)
+#define PA_PWT             (1<<3)
+
+/*
+ * Page attributes
+ */
+#define PA_USER            (1<<2)
+#define PA_SYSTEM          (0)
+
+#define KERNEL_BASE        (0xc0000000)
+#define IDMAP_BASE         (0xd0000000)
+
+
+
+/*
+ * Return a linear address which can be used to access the physical memory
+ * starting at x 
+ */
+extern inline unsigned int physical_to_linear(unsigned int x)
+{
+        return(x+IDMAP_BASE);
+}
+
+extern inline unsigned int linear_to_physical(unsigned int x)
+{
+        return(x-IDMAP_BASE);
+}
+
+#define FLUSH_TLB    __asm__("movl %cr3,%eax\n\tmovl %eax,%cr3\n\t")
+
+extern inline unsigned int* get_page_directory(void)
+{
+        unsigned int page_dir=0;
+        __asm__("movl %%cr3,%0\n\t"
+                : "=r" (page_dir));
+        return((unsigned int *)physical_to_linear(page_dir));
+}
+
+
+/*
+ * Amount of memory that can be mapped by a page table
+ */
+#define PAGE_TABLE_SIZE (4*1024*1024)
+
+#define PAGE_MASK(x) (x&(~0xfff))
+#define VADDR_TO_PT_OFFSET(x)  (((x/1024)%4096))
+#define VADDR_TO_PD_OFFSET(x)  ((x)/(4*1024*1024))
+
+unsigned int* get_page_entry(unsigned int vaddr);
+
+BOOL is_page_present(unsigned int vaddr);
+
+#endif /* __INTERNAL_HAL_PAGE_H */

reactos/include/internal/hal/segment.h

@@ -0,0 +1,343 @@
+#ifndef _ASM_SEGMENT_H
+#define _ASM_SEGMENT_H
+
+#define ZERO_DS            0x18
+#define KERNEL_CS          0x20
+#define KERNEL_DS          0x28
+
+#ifndef __ASSEMBLY__
+
+/*
+ * Uh, these should become the main single-value transfer routines..
+ * They automatically use the right size if we just have the right
+ * pointer type..
+ */
+#define put_user(x,ptr) __put_user((unsigned long)(x),(ptr),sizeof(*(ptr)))
+#define get_user(ptr) ((__typeof__(*(ptr)))__get_user((ptr),sizeof(*(ptr))))
+
+/*
+ * This is a silly but good way to make sure that
+ * the __put_user function is indeed always optimized,
+ * and that we use the correct sizes..
+ */
+extern int bad_user_access_length(void);
+
+/*
+ * dummy pointer type structure.. gcc won't try to do something strange
+ * this way..
+ */
+struct __segment_dummy { unsigned long a[100]; };
+#define __sd(x) ((struct __segment_dummy *) (x))
+#define __const_sd(x) ((const struct __segment_dummy *) (x))
+
+static inline void __put_user(unsigned long x, void * y, int size)
+{
+	switch (size) {
+		case 1:
+			__asm__ ("movb %b1,%%fs:%0"
+				:"=m" (*__sd(y))
+				:"iq" ((unsigned char) x), "m" (*__sd(y)));
+			break;
+		case 2:
+			__asm__ ("movw %w1,%%fs:%0"
+				:"=m" (*__sd(y))
+				:"ir" ((unsigned short) x), "m" (*__sd(y)));
+			break;
+		case 4:
+			__asm__ ("movl %1,%%fs:%0"
+				:"=m" (*__sd(y))
+				:"ir" (x), "m" (*__sd(y)));
+			break;
+		default:
+			bad_user_access_length();
+	}
+}
+
+static inline unsigned long __get_user(const void * y, int size)
+{
+	unsigned long result;
+
+	switch (size) {
+		case 1:
+			__asm__ ("movb %%fs:%1,%b0"
+				:"=q" (result)
+				:"m" (*__const_sd(y)));
+			return (unsigned char) result;
+		case 2:
+			__asm__ ("movw %%fs:%1,%w0"
+				:"=r" (result)
+				:"m" (*__const_sd(y)));
+			return (unsigned short) result;
+		case 4:
+			__asm__ ("movl %%fs:%1,%0"
+				:"=r" (result)
+				:"m" (*__const_sd(y)));
+			return result;
+		default:
+			return bad_user_access_length();
+	}
+}
+
+static inline void __generic_memcpy_tofs(void * to, const void * from, unsigned long n)
+{
+    __asm__ volatile
+	("	cld
+		push %%es
+		push %%fs
+		cmpl $3,%0
+		pop %%es
+		jbe 1f
+		movl %%edi,%%ecx
+		negl %%ecx
+		andl $3,%%ecx
+		subl %%ecx,%0
+		rep; movsb
+		movl %0,%%ecx
+		shrl $2,%%ecx
+		rep; movsl
+		andl $3,%0
+	1:	movl %0,%%ecx
+		rep; movsb
+		pop %%es"
+	:"=abd" (n)
+	:"0" (n),"D" ((long) to),"S" ((long) from)
+	:"cx","di","si");
+}
+
+static inline void __constant_memcpy_tofs(void * to, const void * from, unsigned long n)
+{
+	switch (n) {
+		case 0:
+			return;
+		case 1:
+			__put_user(*(const char *) from, (char *) to, 1);
+			return;
+		case 2:
+			__put_user(*(const short *) from, (short *) to, 2);
+			return;
+		case 3:
+			__put_user(*(const short *) from, (short *) to, 2);
+			__put_user(*(2+(const char *) from), 2+(char *) to, 1);
+			return;
+		case 4:
+			__put_user(*(const int *) from, (int *) to, 4);
+			return;
+		case 8:
+			__put_user(*(const int *) from, (int *) to, 4);
+			__put_user(*(1+(const int *) from), 1+(int *) to, 4);
+			return;
+		case 12:
+			__put_user(*(const int *) from, (int *) to, 4);
+			__put_user(*(1+(const int *) from), 1+(int *) to, 4);
+			__put_user(*(2+(const int *) from), 2+(int *) to, 4);
+			return;
+		case 16:
+			__put_user(*(const int *) from, (int *) to, 4);
+			__put_user(*(1+(const int *) from), 1+(int *) to, 4);
+			__put_user(*(2+(const int *) from), 2+(int *) to, 4);
+			__put_user(*(3+(const int *) from), 3+(int *) to, 4);
+			return;
+	}
+#define COMMON(x) \
+__asm__("cld\n\t" \
+	"push %%es\n\t" \
+	"push %%fs\n\t" \
+	"pop %%es\n\t" \
+	"rep ; movsl\n\t" \
+	x \
+	"pop %%es" \
+	: /* no outputs */ \
+	:"c" (n/4),"D" ((long) to),"S" ((long) from) \
+	:"cx","di","si")
+
+	switch (n % 4) {
+		case 0:
+			COMMON("");
+			return;
+		case 1:
+			COMMON("movsb\n\t");
+			return;
+		case 2:
+			COMMON("movsw\n\t");
+			return;
+		case 3:
+			COMMON("movsw\n\tmovsb\n\t");
+			return;
+	}
+#undef COMMON
+}
+
+static inline void __generic_memcpy_fromfs(void * to, const void * from, unsigned long n)
+{
+    __asm__ volatile
+	("	cld
+		cmpl $3,%0
+		jbe 1f
+		movl %%edi,%%ecx
+		negl %%ecx
+		andl $3,%%ecx
+		subl %%ecx,%0
+		fs; rep; movsb
+		movl %0,%%ecx
+		shrl $2,%%ecx
+		fs; rep; movsl
+		andl $3,%0
+	1:	movl %0,%%ecx
+		fs; rep; movsb"
+	:"=abd" (n)
+	:"0" (n),"D" ((long) to),"S" ((long) from)
+	:"cx","di","si", "memory");
+}
+
+static inline void __constant_memcpy_fromfs(void * to, const void * from, unsigned long n)
+{
+	switch (n) {
+		case 0:
+			return;
+		case 1:
+			*(char *)to = __get_user((const char *) from, 1);
+			return;
+		case 2:
+			*(short *)to = __get_user((const short *) from, 2);
+			return;
+		case 3:
+			*(short *) to = __get_user((const short *) from, 2);
+			*((char *) to + 2) = __get_user(2+(const char *) from, 1);
+			return;
+		case 4:
+			*(int *) to = __get_user((const int *) from, 4);
+			return;
+		case 8:
+			*(int *) to = __get_user((const int *) from, 4);
+			*(1+(int *) to) = __get_user(1+(const int *) from, 4);
+			return;
+		case 12:
+			*(int *) to = __get_user((const int *) from, 4);
+			*(1+(int *) to) = __get_user(1+(const int *) from, 4);
+			*(2+(int *) to) = __get_user(2+(const int *) from, 4);
+			return;
+		case 16:
+			*(int *) to = __get_user((const int *) from, 4);
+			*(1+(int *) to) = __get_user(1+(const int *) from, 4);
+			*(2+(int *) to) = __get_user(2+(const int *) from, 4);
+			*(3+(int *) to) = __get_user(3+(const int *) from, 4);
+			return;
+	}
+#define COMMON(x) \
+__asm__("cld\n\t" \
+	"rep ; fs ; movsl\n\t" \
+	x \
+	: /* no outputs */ \
+	:"c" (n/4),"D" ((long) to),"S" ((long) from) \
+	:"cx","di","si","memory")
+
+	switch (n % 4) {
+		case 0:
+			COMMON("");
+			return;
+		case 1:
+			COMMON("fs ; movsb");
+			return;
+		case 2:
+			COMMON("fs ; movsw");
+			return;
+		case 3:
+			COMMON("fs ; movsw\n\tfs ; movsb");
+			return;
+	}
+#undef COMMON
+}
+
+#define memcpy_fromfs(to, from, n) \
+(__builtin_constant_p(n) ? \
+ __constant_memcpy_fromfs((to),(from),(n)) : \
+ __generic_memcpy_fromfs((to),(from),(n)))
+
+#define memcpy_tofs(to, from, n) \
+(__builtin_constant_p(n) ? \
+ __constant_memcpy_tofs((to),(from),(n)) : \
+ __generic_memcpy_tofs((to),(from),(n)))
+
+/*
+ * These are deprecated..
+ *
+ * Use "put_user()" and "get_user()" with the proper pointer types instead.
+ */
+
+#define get_fs_byte(addr) __get_user((const unsigned char *)(addr),1)
+#define get_fs_word(addr) __get_user((const unsigned short *)(addr),2)
+#define get_fs_long(addr) __get_user((const unsigned int *)(addr),4)
+
+#define put_fs_byte(x,addr) __put_user((x),(unsigned char *)(addr),1)
+#define put_fs_word(x,addr) __put_user((x),(unsigned short *)(addr),2)
+#define put_fs_long(x,addr) __put_user((x),(unsigned int *)(addr),4)
+
+#ifdef WE_REALLY_WANT_TO_USE_A_BROKEN_INTERFACE
+
+static inline unsigned short get_user_word(const short *addr)
+{
+	return __get_user(addr, 2);
+}
+
+static inline unsigned char get_user_byte(const char * addr)
+{
+	return __get_user(addr,1);
+}
+
+static inline unsigned long get_user_long(const int *addr)
+{
+	return __get_user(addr, 4);
+}
+
+static inline void put_user_byte(char val,char *addr)
+{
+	__put_user(val, addr, 1);
+}
+
+static inline void put_user_word(short val,short * addr)
+{
+	__put_user(val, addr, 2);
+}
+
+static inline void put_user_long(unsigned long val,int * addr)
+{
+	__put_user(val, addr, 4);
+}
+
+#endif
+
+/*
+ * Someone who knows GNU asm better than I should double check the following.
+ * It seems to work, but I don't know if I'm doing something subtly wrong.
+ * --- TYT, 11/24/91
+ * [ nothing wrong here, Linus: I just changed the ax to be any reg ]
+ */
+
+static inline unsigned long get_fs(void)
+{
+	unsigned long _v;
+	__asm__("mov %%fs,%w0":"=r" (_v):"0" (0));
+	return _v;
+}
+
+static inline unsigned long get_ds(void)
+{
+	unsigned long _v;
+	__asm__("mov %%ds,%w0":"=r" (_v):"0" (0));
+	return _v;
+}
+
+static inline void set_fs(unsigned long val)
+{
+	__asm__ __volatile__("mov %w0,%%fs": /* no output */ :"r" (val));
+}
+
+static inline void set_ds(unsigned long val)
+{
+        __asm__ __volatile__("mov %w0,%%ds": /* no output */ :"r" (val));
+}
+
+
+#endif /* __ASSEMBLY__ */
+
+#endif /* _ASM_SEGMENT_H */

reactos/include/internal/hal/segment.inc

@@ -0,0 +1,6 @@
+;
+; Useful prototypes and definitions
+;
+
+%define KERNEL_DS       028h
+%define KERNEL_CS       020h

reactos/include/internal/i386/hal.h

@@ -0,0 +1,71 @@
+/*
+ * 
+ */
+
+#ifndef __INTERNAL_HAL_HAL_H
+#define __INTERNAL_HAL_HAL_H
+
+typedef struct
+{
+   unsigned short previous_task;
+   unsigned short reserved1;
+   unsigned long esp0;
+   unsigned short ss0;
+   unsigned short reserved2;
+   unsigned long esp1;
+   unsigned short ss1;
+   unsigned short reserved3;
+   unsigned long esp2;
+   unsigned short ss2;
+   unsigned short reserved4;
+   unsigned long cr3;
+   unsigned long eip;
+   unsigned long eflags;
+   unsigned long eax;
+   unsigned long ecx;
+   unsigned long edx;
+   unsigned long ebx;
+   unsigned long esp;
+   unsigned long ebp;
+   unsigned long esi;
+   unsigned long edi;
+   unsigned short es;
+   unsigned short reserved5;
+   unsigned short cs;
+   unsigned short reserved6;
+   unsigned short ss;
+   unsigned short reserved7;
+   unsigned short ds;
+   unsigned short reserved8;
+   unsigned short fs;
+   unsigned short reserved9;
+   unsigned short gs;
+   unsigned short reserved10;
+   unsigned short ldt;
+   unsigned short reserved11;
+   unsigned short trap;
+   unsigned short iomap_base;
+   
+   unsigned short nr;
+   
+   unsigned char io_bitmap[1];
+} hal_thread_state;
+
+/*
+ * FUNCTION: Probes for a PCI bus
+ * RETURNS: True if found
+ */
+BOOL HalPciProbe(void);
+
+/*
+ * FUNCTION: Probes for a BIOS32 extension
+ */
+VOID Hal_bios32_probe(VOID);
+
+/*
+ * FUNCTION: Determines if a a bios32 service is present
+ */
+BOOLEAN Hal_bios32_is_service_present(ULONG service);
+
+
+#endif /* __INTERNAL_HAL_HAL_H */

reactos/include/internal/iomgr.h

@@ -0,0 +1,27 @@
+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS kernel
+ * FILE:            include/internal/iomgr.h
+ * PURPOSE:         Internal io manager declarations
+ * PROGRAMMER:      David Welch (welch@mcmail.com)
+ * UPDATE HISTORY:
+ *               28/05/97: Created
+ */
+
+#ifndef __INCLUDE_INTERNAL_IOMGR_H
+#define __INCLUDE_INTERNAL_IOMGR_H
+
+#include <ddk/ntddk.h>
+
+/*
+ * FUNCTION: Called to initalize a loaded driver
+ * ARGUMENTS: 
+ *          entry = pointer to the driver initialization routine
+ * RETURNS: Success or failure
+ */
+NTSTATUS InitalizeLoadedDriver(PDRIVER_INITIALIZE entry);
+
+VOID IoInitCancelHandling(VOID);
+VOID IoInitSymbolicLinkImplementation(VOID);
+
+#endif