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

svn path=/tags/krnl0018/; revision=2136

reactos/.cvsignore

@@ -0,0 +1,2 @@
+dist
+errors

reactos/.gdbinit

@@ -0,0 +1,7 @@
+file ntoskrnl/ntoskrnl.nostrip.exe
+#add-symbol-file lib/ntdll/ntdll.dll 0x77f61000
+#add-symbol-file lib/kernel32/kernel32.dll 0x77f01000
+#add-symbol-file apps/exp/exp.exe 0x401000
+#add-symbol-file subsys/csrss/csrss.exe 0x401000
+#add-symbol-file subsys/smss/smss.exe 0x401000
+break exp.c:254

reactos/CREDITS

@@ -0,0 +1,41 @@
+In no particular order
+
+Rex Jolliff (rex@lvcablemodem.com)
+Boudewijn Dekker (ariadne@xs4all.nl)
+Eric Kohl (ekohl@rz-online.de)
+Emanuele Aliberti (ea@iol.it)
+David Welch (welch@cwcom.net)
+Iwan Fatahi (i_fatahi@hotmail.com)
+Robert Bergkvist (fragdance@hotmail.com)
+Victor Kirhenshtein (sauros@iname.com)
+Jason Filby (jasonfilby@yahoo.com)
+Brian Palmer (brianp@sginet.com)
+Phillip Susi (phreak@iag.net)
+Paolo Pantaleo (paolopan@freemail.it)
+Casper S. Hornstrup (chorns@users.sourceforge.net)
+
+Source and inspiration from
+
+WINE (http://www.winehq.com)
+WinFree (http://www.stack.nl/~onno/win32/)
+Linux (http://www.kernel.org)
+
+References (Rex's at least)
+
+Baker, Art. The Windows NT Device Driver Book. Prentice Hall, 1997.
+Borate, Dabak & Phadke. Undocumented Windows NT. M&T Books, 1999.
+Brain, Marshall. Win32 System Services. Prentice Hall, 1996.
+Cant, Chris. Writing Windows WDM Device Drivers. R&D Books, 1999.
+Canton & Sanchez. IBM Microcomputers: A Programmer's Handbook. McGraw Hill, 1990.
+Davis & Wallace. Windows Undocumented File Formats. R&D Books, 1997.
+Mason & Viscarola. Windows NT Device Driver Development. Macmillan, 1999.
+Mitchell, Stan. Inside the Windows 95 File System. O'Reilly, 1997.
+Murray, James D. Windows NT Event Logging. O'Reilly, 1998.
+Nagar, Rajeev. Windows NT File System Internals. O'Reilly, 1997.
+Osbourne, Sandra. Windows NT Registry: A Settings Reference. New Riders, 1998.
+Pietrek, Matt. Windows 95 System Programming Secrets. IDG, 1995.
+Richter, Jeffery. Advanced Windows, 3rd ed. Microsoft, 1997.
+Simon, Richard J. Windows NT Win32 API Superbible. Waite Group, 1996.
+Solomon, David A. Inside Windows NT, 2nd Ed. Microsoft, 1998.
+"The NT Insider." Open Systems Resources, 1999-2000.
+

reactos/ChangeLog

@@ -0,0 +1,154 @@
+2001-03-18  David Welch  <welch@cwcom>
+
+	* ntoskrnl/ke/apc.c (KiDeliverApc): Bug fix.
+	* ntoskrnl/ke/apc.c (KeInsertQueueApc): More comments.
+	* ntoskrnl/ke/catch.c (KiDispatchException): Bug fix.
+	* ntoskrnl/ke/timer.c (KeDelayExecutionThread): Don't use removed 
+	function KeAddTimeoutThread.
+	* ntoskrnl/ke/timer.c (KeAddTimeoutThread): Removed.
+	* ntoskrnl/ke/wait.c (KeWaitForSingleObject, KeWaitForMultipleObjects):
+	Don't use KeAddTimeoutThread.
+	* ntoskrnl/mm/freelist.c (MmAllocateContiguousAlignedMemory): Bug fix
+	* ntoskrnl/mm/freelist.c (MmAllocatePage): Allocate from the top
+	memory.
+
+2001-03-17  David Welch  <welch@cwcom.net>
+
+	* ntoskrnl/ke/catch.c (KiDispatchException): Implementation of
+	exception handling, user-mode only.
+
+2001-03-16  David Welch  <welch@cwcom.net>
+
+	* include/ddk/zw.h: Corrected declarations of NtCreateProfile,
+	NtQueryIntervalProfile, NtSetIntervalProfile.
+	* include/ddk/zwtypes.h: Added definitions of KPROFILE_SOURCE.
+	* ntoskrnl/include/internal/ke.h: Added the interrupted EIP as a
+	parameter to KiUpdateSystemTime for profiling purposes.
+	* ntoskrnl/include/internal/nt: Added declaration for profiling
+	support initialization.
+	* ntoskrnl/ke/timer.c (KiUpdateSystemTime, KeExpireTimers): Call
+	the profiling code on a timer interrupt with the interrupt EIP.
+	* ntoskrnl/ke/i386/irq.c (KiDispatchInterrupt): Pass the interrupted
+	EIP to KiUpdateSystemTime.
+	* ntoskrnl/mm/virtual.c (NtReadVirtualMemory, NtWriteVirtualMemory):
+	Release the MDLs used properly.
+	* ntoskrnl/nt/nt.c: Call the profiling support initialization.
+	* ntoskrnl/nt/ntevent.c (NtCreateEvent): Don't try copying the
+	ObjectAttributes parameter if it is NULL.
+	* ntoskrnl/nt/profile.c: Implemented profiling.
+
+2001-03-16  David Welch  <welch@cwcom.net>
+
+	* ntoskrnl/include/internal/safe.h: Corrected typo.
+	* ntoskrnl/nt/ntevent.c (NtCreateEvent, NtOpenEvent, NtQueryEvent):
+	Corrected typos.
+	* ntoskrnl/rtl/mem.c: Missing header file.
+
+2001-03-16  David Welch  <welch@cwcom.net>
+
+	* ntoskrnl/include/internal/safe.h: Add definitions for handling
+	potentially unsafe pointers.
+
+2001-03-16  David Welch  <welch@cwcom.net>
+
+	* ntoskrnl/include/internal/mm.h: Removed MmSafeCopyToUser and
+	MmSafeCopyFromUser as source files need these but don't want internal 
+	mm definitions.
+	* ntoskrnl/nt/ntevent.c (NtCreateEvent, NtOpenEvent, NtPulseEvent,
+	NtQueryEvent, NtResetEvent, NtSetEvent): Copy data to and from
+	user mode safely.
+	* ntoskrnl/rtl/mem.c (MmCopyToCaller, MmCopyFromCaller): Helper
+	functions for copying data to and from potentially unsafe pointers.
+
+2000-12-23  David Welch  <welch@cwcom.net>
+
+	* All task switching is done in software.
+	* Beginnings of v86 mode support.
+
+2000-12-22  David Welch  <welch@cwcom.net>
+
+	* ntoskrnl/ps/kill.c (PiTerminateProcessThreads): Drop 
+	PiThreadListLock before calling PsTerminateOtherThread
+
+2000-12-16  David Welch  <welch@cwcom.net>
+
+	* ntoskrnl/ex/fmutex.c (ExReleaseFastMutexUnsafe): Only set the
+	fast mutex's owner back to NULL if it is being released
+
+2000-12-10  David Welch  <welch@cwcom.net>
+
+	* ntoskrnl/ke/i386/vm86_sup.S (Ki386RetToV86Mode): Added function
+	to do the raw switch to v86 mode.
+	* ntoskrnl/include/internal/vm86.h: Definitions for the v86 mode
+	support.
+
+2000-12-10  David Welch  <welch@cwcom.net>
+
+	* ntoskrnl/ke/i386/trap.s (PsBeginThreadWithContextInternal): Moved
+	to ntoskrnl/ke/i386/bswitch.S.
+	* ntoskrnl/ke/i386/trap.s (interrupt_handler2e): Moved to
+	ntoskrnl/ke/i386/syscall.S.
+	* ntoskrnl/ke/i386/trap.s (old_interrupt_handler2e): Removed.
+
+2000-12-04  David Welch  <welch@cwcom.net>
+
+	* ntoskrnl/ke/i386/irq.c (KiInterruptDispatch): Record the last PC 
+	value for a rescheduled thread.
+	* ntoskrnl/ke/i386/irqhand.s: Construct a primitive trap frame
+	in interrupt handlers.	
+	
+2000-08-30  David Welch  <welch@cwcom.net>
+
+	* Added calibration of KeStallExecutionProcessor timing
+	  (code from linux 2.2.16).
+	       
+	* Corrected compilation bugs in user32 library.
+
+	* Corrected compilation bugs related to anonymous structs
+	  in ndis code.
+	       
+	* Pass command line to kernel from loadros.
+	       
+	* Corrected PIC mask calculation.
+	       
+2000-05-27  David Welch <welch@cwcom.net>
+
+        * Fixed issue with closing non-existent or already closed
+          handle.
+
+2000-01-26  David Welch <welch@cwcom.net>
+
+        * ZwCreateProcess now maps ntdll rather than the user-mode
+          code.
+
+1999-09-06  David Welch <welch@cwcom.net>
+
+        * Implemented ZwOpenProcess.
+               
+	* Partially implemented killing other threads (possible memory
+          leaks).
+	       
+	* Made a start on a proper implemention of APCs (based on 
+	  article in NT insider).
+
+1998-12-08  David Welch <welch@cwcom.net>
+
+        * Corrected bug in shell (Read two keypresses and assumed they
+          where the key going up and down respectively).
+	       
+	* Corrected race in dpc handling.
+	       
+	* Took out cleanup sections in ZwReadFile (now handled by the 
+	  APC).
+	       
+	* Disabled broken code in kernel32.
+
+
+
+
+
+
+
+
+
+	

reactos/INSTALL

@@ -0,0 +1,39 @@
+1. Build environment
+
+To build the system you need either mingw32 installed on Windows or a
+mingw32 cross compiler running on unix.
+
+2. Building
+
+To build from Windows run make. To build from unix, edit rules.mak and change 
+the PREFIX variable to the correct value for your cross-compiler, then run 
+'make'.
+
+3. Installation
+
+Installation isn't yet automated, sorry. The system can only be installed on
+the first partition which must be formatted for DOS. Set up a directory
+structure like the following
+
+make directories C:\reactos,C:\reactos\system32,C:\reactos\system32\drivers
+
+Copy apps/system/shell/shell.exe to C:\reactos\system32
+Copy subsys/smss/smss.exe to C:\reactos\system32
+Copy apps/system/winlogon/winlogon.exe to C:\reactos\system32
+Copy apps/system/services/services.exe to C:\reactos\system32
+Copy services/input/keyboard/keyboard.sys to C:\reactos\system32\drivers
+Copy services/dd/blue/blue.sys to C:\reactos\system32\drivers
+Copy lib/ntdll/ntdll.dll to C:\reactos\system32
+Copy lib/kernel32/kernel32.dll to C:\reactos\system32
+Copy lib/crtdll/crtdll.dll to C:\reactos\system32
+
+The system can only be started from DOS. Copy the following files,
+services/dd/ide/ide.sys, services/fs/vfat/vfatfsd.sys
+ntoskrnl/ntoskrnl.exe and loaders/dos/loadros.com, to a suitable
+directory, such as C:\. The system can then be booted with the
+command 'loadros.com ntoskrnl.exe ide.sys vfatfs.sys'.
+
+
+You may also want to try running the enhanced shell, cmd.exe, found in
+the rosapps CVS module.  For more information see the doc directory
+

reactos/Makefile

@@ -0,0 +1,460 @@
+#
+# Global makefile
+#
+
+#
+# Select your host
+#
+#HOST = mingw32-linux
+#HOST = mingw32-windows
+
+PATH_TO_TOP = .
+
+include rules.mak
+
+#
+# Required to run the system
+#
+COMPONENTS = iface_native iface_additional ntoskrnl
+BUS = acpi isapnp
+DLLS = ntdll kernel32 advapi32 crtdll msvcrt fmifs gdi32 msafd \
+	ole32 oleaut32 secur32 shell32 user32 ws2_32 
+SUBSYS = smss win32k csrss
+
+#
+# Select the server(s) you want to build
+#
+#SERVERS = posix linux os2
+SERVERS = win32
+
+#
+# Select the loader(s) you want to build
+#
+#LOADERS = boot dos
+LOADERS = dos
+
+#
+# Select the device drivers and filesystems you want
+#
+#DEVICE_DRIVERS = beep floppy mouse sound test parallel serial
+DEVICE_DRIVERS = vidport vga blue ide null floppy
+
+#INPUT_DRIVERS = keyboard
+INPUT_DRIVERS = keyboard mouclass psaux
+
+#FS_DRIVERS = vfat minix ext2 template
+FS_DRIVERS = vfat ms np
+
+#NET_DRIVERS = ndis tdi tcpip tditest wshtcpip afd
+NET_DRIVERS = ndis tcpip tditest wshtcpip afd
+
+#NET_DEVICE_DRIVERS = ne2000
+NET_DEVICE_DRIVERS = ne2000
+
+#
+# storage drivers (don't change the order)
+#
+STORAGE_DRIVERS = class2 scsiport disk
+
+#
+# system applications (required for startup)
+#
+#SYS_APPS = shell winlogon services
+SYS_APPS = shell winlogon services
+
+APPS = args hello test cat bench apc shm lpc thread event file gditest \
+       pteb consume dump_shared_data vmtest regtest alive mstest nptest \
+       objdir atomtest
+
+#NET_APPS = ping roshttpd telnet
+NET_APPS = ping
+
+
+KERNEL_SERVICES = $(DEVICE_DRIVERS) $(INPUT_DRIVERS) $(FS_DRIVERS)  \
+	$(NET_DRIVERS) $(NET_DEVICE_DRIVERS) $(STORAGE_DRIVERS)
+
+all: rdel$(EXE_POSTFIX) buildno $(COMPONENTS) $(BUS) $(DLLS)  \
+	$(SUBSYS) $(LOADERS) $(KERNEL_SERVICES) $(SYS_APPS) $(APPS) $(NET_APPS)
+
+.PHONY: all
+
+clean: rdel$(EXE_POSTFIX) buildno_clean $(COMPONENTS:%=%_clean) \
+       $(BUS:%=%_clean) $(DLLS:%=%_clean) \
+       $(LOADERS:%=%_clean) $(KERNEL_SERVICES:%=%_clean) $(SUBSYS:%=%_clean) \
+       $(SYS_APPS:%=%_clean) $(APPS:%=%_clean) $(NET_APPS:%=%_clean)
+
+.PHONY: clean
+
+ifeq ($(HOST),mingw32-linux)
+rcopy$(EXE_POSTFIX): rcopy.c
+	$(HOST_CC) -g -DUNIX_PATHS rcopy.c -o rcopy$(EXE_POSTFIX)
+endif
+ifeq ($(HOST),mingw32-windows)
+rcopy$(EXE_POSTFIX): rcopy.c
+	$(HOST_CC) -g -DDOS_PATHS rcopy.c -o rcopy$(EXE_POSTFIX)
+endif
+
+ifeq ($(HOST),mingw32-linux)
+rmkdir$(EXE_POSTFIX): rmkdir.c
+	$(HOST_CC) -g -DUNIX_PATHS rmkdir.c -o rmkdir$(EXE_POSTFIX)
+endif
+ifeq ($(HOST),mingw32-windows)
+rmkdir$(EXE_POSTFIX): rmkdir.c
+	$(HOST_CC) -g -DDOS_PATHS rmkdir.c -o rmkdir$(EXE_POSTFIX)
+endif
+
+rdel$(EXE_POSTFIX): rdel.c
+	$(HOST_CC) -g rdel.c -liberty -o rdel$(EXE_POSTFIX)
+
+install: rcopy$(EXE_POSTFIX) rmkdir$(EXE_POSTFIX) make_install_dirs autoexec_install \
+        $(COMPONENTS:%=%_install) $(BUS:%=%_install) \
+        $(DLLS:%=%_install) $(LOADERS:%=%_install) \
+        $(KERNEL_SERVICES:%=%_install) $(SUBSYS:%=%_install) \
+        $(SYS_APPS:%=%_install) $(APPS:%=%_install)
+
+dist: rcopy$(EXE_POSTFIX) clean_dist_dir make_dist_dirs $(COMPONENTS:%=%_dist) \
+      $(BUS:%=%_dist) $(DLLS:%=%_dist) \
+      $(LOADERS:%=%_dist) $(KERNEL_SERVICES:%=%_dist) $(SUBSYS:%=%_dist) \
+      $(SYS_APPS:%=%_dist) $(APPS:%=%_dist) $(NET_APPS:%=%_dist)
+
+#
+# Build number generator
+#
+buildno: include/reactos/version.h
+	make -C apps/buildno
+
+buildno_clean:
+	make -C apps/buildno clean
+
+buildno_dist:
+
+buildno_install:
+
+.PHONY: buildno buildno_clean buildno_dist buildno_install
+
+#
+# System Applications
+#
+$(SYS_APPS): %:
+	make -C apps/system/$*
+
+$(SYS_APPS:%=%_clean): %_clean:
+	make -C apps/system/$* clean
+
+$(SYS_APPS:%=%_dist): %_dist:
+	make -C apps/system/$* dist
+
+$(SYS_APPS:%=%_install): %_install:
+	make -C apps/system/$* install
+
+.PHONY: $(SYS_APPS) $(SYS_APPS:%=%_clean) $(SYS_APPS:%=%_install) $(SYS_APPS:%=%_dist)
+
+#
+# Applications
+#
+$(APPS): %:
+	make -C apps/$*
+
+$(APPS:%=%_clean): %_clean:
+	make -C apps/$* clean
+
+$(APPS:%=%_dist): %_dist:
+	make -C apps/$* dist
+
+$(APPS:%=%_install): %_install:
+	make -C apps/$* install
+
+.PHONY: $(APPS) $(APPS:%=%_clean) $(APPS:%=%_install) $(APPS:%=%_dist)
+
+#
+# Network applications
+#
+$(NET_APPS): %:
+	make -C apps/net/$*
+
+$(NET_APPS:%=%_clean): %_clean:
+	make -C apps/net/$* clean
+
+$(NET_APPS:%=%_dist): %_dist:
+	make -C apps/net/$* dist
+
+$(NET_APPS:%=%_install): %_install:
+	make -C apps/net/$* install
+
+.PHONY: $(NET_APPS) $(NET_APPS:%=%_clean) $(NET_APPS:%=%_install) $(NET_APPS:%=%_dist)
+
+#
+# Interfaces
+#
+iface_native:
+	make -C iface/native
+
+iface_native_clean:
+	make -C iface/native clean
+
+iface_native_install:
+
+iface_native_dist:
+
+iface_additional:
+	make -C iface/addsys
+
+iface_additional_clean:
+	make -C iface/addsys clean
+
+iface_additional_install:
+
+iface_additional_dist:
+
+.PHONY: iface_native iface_native_clean iface_native_install \
+        iface_native_dist \
+        iface_additional iface_additional_clean iface_additional_install \
+        iface_additional_dist
+
+#
+# Bus driver rules
+#
+$(BUS): %:
+	make -C services/bus/$*
+
+$(BUS:%=%_clean): %_clean:
+	make -C services/bus/$* clean
+
+$(BUS:%=%_install): %_install:
+	make -C services/bus/$* install
+
+$(BUS:%=%_dist): %_dist:
+	make -C services/bus/$* dist
+
+.PHONY: $(BUS) $(BUS:%=%_clean) \
+        $(BUS:%=%_install) $(BUS:%=%_dist)
+
+#
+# Device driver rules
+#
+$(DEVICE_DRIVERS): %:
+	make -C services/dd/$*
+
+$(DEVICE_DRIVERS:%=%_clean): %_clean:
+	make -C services/dd/$* clean
+
+$(DEVICE_DRIVERS:%=%_install): %_install:
+	make -C services/dd/$* install
+
+$(DEVICE_DRIVERS:%=%_dist): %_dist:
+	make -C services/dd/$* dist
+
+.PHONY: $(DEVICE_DRIVERS) $(DEVICE_DRIVERS:%=%_clean) \
+        $(DEVICE_DRIVERS:%=%_install) $(DEVICE_DRIVERS:%=%_dist)
+
+#
+# Input driver rules
+#
+$(INPUT_DRIVERS): %:
+	make -C services/input/$*
+
+$(INPUT_DRIVERS:%=%_clean): %_clean:
+	make -C services/input/$* clean
+
+$(INPUT_DRIVERS:%=%_install): %_install:
+	make -C services/input/$* install
+
+$(INPUT_DRIVERS:%=%_dist): %_dist:
+	make -C services/input/$* dist
+
+.PHONY: $(INPUT_DRIVERS) $(INPUT_DRIVERS:%=%_clean) \
+        $(INPUT_DRIVERS:%=%_install) $(INPUT_DRIVERS:%=%_dist)
+
+$(FS_DRIVERS): %:
+	make -C services/fs/$*
+
+$(FS_DRIVERS:%=%_clean): %_clean:
+	make -C services/fs/$* clean
+
+$(FS_DRIVERS:%=%_install): %_install:
+	make -C services/fs/$* install
+
+$(FS_DRIVERS:%=%_dist): %_dist:
+	make -C services/fs/$* dist
+
+.PHONY: $(FS_DRIVERS) $(FS_DRIVERS:%=%_clean) \
+        $(FS_DRIVERS:%=%_install) $(FS_DRIVERS:%=%_dist)
+
+#
+# Network driver rules
+#
+$(NET_DRIVERS): %:
+	make -C services/net/$*
+
+$(NET_DRIVERS:%=%_clean): %_clean:
+	make -C services/net/$* clean
+
+$(NET_DRIVERS:%=%_install): %_install:
+	make -C services/net/$* install
+
+$(NET_DRIVERS:%=%_dist): %_dist:
+	make -C services/net/$* dist
+
+.PHONY: $(NET_DRIVERS) $(NET_DRIVERS:%=%_clean) \
+        $(NET_DRIVERS:%=%_install) $(NET_DRIVERS:%=%_dist)
+
+$(NET_DEVICE_DRIVERS): %:
+	make -C services/net/dd/$*
+
+$(NET_DEVICE_DRIVERS:%=%_clean): %_clean:
+	make -C services/net/dd/$* clean
+
+$(NET_DEVICE_DRIVERS:%=%_install): %_install:
+	make -C services/net/dd/$* install
+
+$(NET_DEVICE_DRIVERS:%=%_dist): %_dist:
+	make -C services/net/dd/$* dist
+
+.PHONY: $(NET_DEVICE_DRIVERS) $(NET_DEVICE_DRIVERS:%=%_clean) \
+        $(NET_DEVICE_DRIVERS:%=%_install) $(NET_DEVICE_DRIVERS:%=%_dist)
+
+#
+# storage driver rules
+#
+$(STORAGE_DRIVERS): %:
+	make -C services/storage/$*
+
+$(STORAGE_DRIVERS:%=%_clean): %_clean:
+	make -C services/storage/$* clean
+
+$(STORAGE_DRIVERS:%=%_install): %_install:
+	make -C services/storage/$* install
+
+$(STORAGE_DRIVERS:%=%_dist): %_dist:
+	make -C services/storage/$* dist
+
+.PHONY: $(STORAGE_DRIVERS) $(STORAGE_DRIVERS:%=%_clean) \
+        $(STORAGE_DRIVERS:%=%_install) $(STORAGE_DRIVERS:%=%_dist)
+
+#
+# Kernel loaders
+#
+
+$(LOADERS): %:
+	make -C loaders/$*
+
+$(LOADERS:%=%_clean): %_clean:
+	make -C loaders/$* clean
+
+$(LOADERS:%=%_install): %_install:
+	make -C loaders/$* install
+
+$(LOADERS:%=%_dist): %_dist:
+	make -C loaders/$* dist
+
+.PHONY: $(LOADERS) $(LOADERS:%=%_clean) $(LOADERS:%=%_install) \
+        $(LOADERS:%=%_dist)
+
+#
+# Required system components
+#
+
+ntoskrnl:
+	make -C ntoskrnl
+
+ntoskrnl_clean:
+	make -C ntoskrnl clean
+
+ntoskrnl_install:
+	make -C ntoskrnl install
+
+ntoskrnl_dist:
+	make -C ntoskrnl dist
+
+.PHONY: ntoskrnl ntoskrnl_clean ntoskrnl_install ntoskrnl_dist
+
+#
+# Required DLLs
+#
+
+$(DLLS): %:
+	make -C lib/$*
+
+$(DLLS:%=%_clean): %_clean:
+	make -C lib/$* clean
+
+$(DLLS:%=%_install): %_install:
+	make -C lib/$* install
+
+$(DLLS:%=%_dist): %_dist:
+	make -C lib/$* dist
+
+.PHONY: $(DLLS) $(DLLS:%=%_clean) $(DLLS:%=%_install) $(DLLS:%=%_dist)
+
+#
+# Kernel Subsystems
+#
+
+$(SUBSYS): %:
+	make -C subsys/$*
+
+$(SUBSYS:%=%_clean): %_clean:
+	make -C subsys/$* clean
+
+$(SUBSYS:%=%_install): %_install:
+	make -C subsys/$* install
+
+$(SUBSYS:%=%_dist): %_dist:
+	make -C subsys/$* dist
+
+.PHONY: $(SUBSYS) $(SUBSYS:%=%_clean) $(SUBSYS:%=%_install) \
+        $(SUBSYS:%=%_dist)
+
+#
+# Make an install floppy
+#
+make_install_dirs:
+	./rmkdir $(FLOPPY_DIR)/dlls
+	./rmkdir $(FLOPPY_DIR)/apps
+	./rmkdir $(FLOPPY_DIR)/drivers
+	./rmkdir $(FLOPPY_DIR)/subsys
+
+
+.PHONY: make_install_dirs
+
+autoexec_install: $(FLOPPY_DIR)/autoexec.bat
+
+$(FLOPPY_DIR)/autoexec.bat: bootflop.bat
+	$(CP) bootflop.bat $(FLOPPY_DIR)/autoexec.bat
+
+#
+# Make a distribution saveset
+#
+
+clean_dist_dir:
+ifeq ($(DOSCLI),yes)
+	- $(RM) $(DIST_DIR)\dlls\*.dll
+	- $(RM) $(DIST_DIR)\apps\*.exe
+	- $(RM) $(DIST_DIR)\drivers\*.sys
+	- $(RM) $(DIST_DIR)\subsys\*.exe
+	- $(RMDIR) $(DIST_DIR)\dlls
+	- $(RMDIR) $(DIST_DIR)\apps
+	- $(RMDIR) $(DIST_DIR)\drivers
+	- $(RMDIR) $(DIST_DIR)\subsys
+	- $(RMDIR) $(DIST_DIR)
+else
+	$(RM) -r $(DIST_DIR)
+endif
+
+make_dist_dirs: ./rmkdir
+	./rmkdir $(DIST_DIR)
+	./rmkdir $(DIST_DIR)/dlls
+	./rmkdir $(DIST_DIR)/apps
+	./rmkdir $(DIST_DIR)/drivers
+	./rmkdir $(DIST_DIR)/dlls
+	./rmkdir $(DIST_DIR)/subsys
+
+.PHONY: clean_dist_dir make_dist_dirs
+
+#
+#
+#
+etags:
+	find . -name "*.[ch]" -print | etags --language=c -
+
+# EOF

reactos/NEWS

@@ -0,0 +1,15 @@
+0.0.14:      Converted to PE format
+             All system libraries are now dlls
+             
+0.0.13:      Mostly bugfixes (I think)
+
+0.0.12:      Added support for multiple processes (not really tested)
+	     System calls
+	     kernel32 now compiles (only as a static library)
+	     Fixed invalid tss bug (hopefully)
+	     Added section support
+	     Added some of the ZwxxxVirtual calls
+	     Added prototype caching functions (only the Minix fsd actually
+	      uses them)
+	     Added handle access and type checking
+	     Prototype APC implementation (no support for user APCs)

reactos/README

@@ -0,0 +1,24 @@
+About Reactos
+
+1. What is Reactos
+
+A project aiming to make an approximate clone of Windows NT, compatible
+with most Windows applications.
+
+The project has a website at http://www.reactos.com/
+
+2. Building Reactos
+
+See the INSTALL file for more details.
+
+3. More information
+
+See the doc subdirectory for some sparse notes
+
+4. Who is responsible
+
+See the CREDITS file
+
+5. Recent developments
+
+See the NEWS file

reactos/apps/common/crt0.c

@@ -0,0 +1,33 @@
+#include <windows.h>
+
+extern int main(int args, char* argv[], char* environ[]);
+
+static unsigned int _argc = 0;
+static char** _argv = NULL;
+static char** _environ = NULL;
+
+int mainCRTStartup(PWSTR args)
+{
+   int nRet;
+   
+//   SetUnhandledExceptionFilter(NULL);
+   
+//   _fpreset();
+   
+//   __GetMainArgs(&_argc, &_argv, &_environ, 0);
+   
+   nRet = main(_argc, _argv, _environ);
+   
+//   _cexit();
+   
+   ExitProcess(nRet);
+}
+
+int WinMainCRTStartup()
+{
+   return mainCRTStartup(NULL);
+}
+
+void __main(void)
+{
+}

reactos/apps/tests/alive/Makefile

@@ -0,0 +1,47 @@
+#
+#
+#
+PATH_TO_TOP=../..
+
+TARGET_NAME=alive
+
+OBJECTS=\
+	$(TARGET_NAME).o
+
+LIBRARIES=\
+	$(PATH_TO_TOP)/lib/kernel32/kernel32.a\
+	$(PATH_TO_TOP)/lib/crtdll/crtdll.a\
+	$(PATH_TO_TOP)/lib/user32/user32.a
+
+PROGS=\
+	$(TARGET_NAME).exe
+
+BASE_CFLAGS = -I$(PATH_TO_TOP)/include
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) $(TARGET_NAME).o $(TARGET_NAME).exe $(TARGET_NAME).sym
+
+.phony: clean
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=$(PATH_TO_TOP)/$(DIST_DIR)/apps/%)
+
+$(PROGS:%=$(PATH_TO_TOP)/$(DIST_DIR)/apps/%): $(PATH_TO_TOP)/$(DIST_DIR)/apps/%: %
+	$(CP) $* $(PATH_TO_TOP)/$(DIST_DIR)/apps/$*
+
+$(TARGET_NAME).exe: $(OBJECTS)
+	$(CC)\
+		$(OBJECTS)\
+		$(LIBRARIES)\
+		-o $(TARGET_NAME).exe
+	$(NM) --numeric-sort $(TARGET_NAME).exe > $(TARGET_NAME).sym
+
+include $(PATH_TO_TOP)/rules.mak

reactos/apps/tests/alive/alive.c

@@ -0,0 +1,48 @@
+/* $Id: alive.c,v 1.2 2001/03/26 21:30:20 ea Exp $
+ *
+ */
+#include <windows.h>
+#include <stdlib.h>
+
+HANDLE	StandardOutput = INVALID_HANDLE_VALUE;
+CHAR	Message [80];
+DWORD	CharactersToWrite = 0;
+DWORD	WrittenCharacters = 0;
+INT	d = 0, h = 0, m = 0, s = 0;
+
+int
+main (int argc, char * argv [])
+{
+	StandardOutput = GetStdHandle (STD_OUTPUT_HANDLE);
+	if (INVALID_HANDLE_VALUE == StandardOutput)
+	{
+		return (EXIT_FAILURE);
+	}
+	while (TRUE)
+	{
+		/* Prepare the message and update it */
+		CharactersToWrite =
+			wsprintf (
+				Message,
+				"Alive for %dd %dh %d' %d\"   \r",
+				d, h, m, s
+				);
+		WriteConsole (
+			StandardOutput,
+			Message,
+			CharactersToWrite,
+			& WrittenCharacters,
+			NULL
+			);
+		/* suspend the execution for 1s */
+		Sleep (1000);
+		/* increment seconds */
+		++ s;
+		if (60 == s) { s = 0; ++ m; }
+		if (60 == m) { m = 0; ++ h; }
+		if (24 == h) { h = 0; ++ d; }
+	}
+	return (EXIT_SUCCESS);
+}
+
+/* EOF */

reactos/apps/tests/apc/apc.c

@@ -0,0 +1,87 @@
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <windows.h>
+#include <ddk/ntddk.h>
+
+HANDLE OutputHandle;
+HANDLE InputHandle;
+
+VOID STDCALL 
+ApcRoutine(PVOID Context,
+	   PIO_STATUS_BLOCK IoStatus,
+	   ULONG Reserved)
+{
+   printf("(apc.exe) ApcRoutine(Context %p)\n", Context);
+}
+
+int main(int argc, char* argv[])
+{
+   NTSTATUS Status;
+   HANDLE FileHandle;
+   OBJECT_ATTRIBUTES ObjectAttributes;
+   UNICODE_STRING FileName;
+   IO_STATUS_BLOCK IoStatus;
+   CHAR Buffer[256];
+   HANDLE EventHandle;
+   
+   AllocConsole();
+   InputHandle = GetStdHandle(STD_INPUT_HANDLE);
+   OutputHandle =  GetStdHandle(STD_OUTPUT_HANDLE);
+
+   printf("APC test program\n");
+   
+   EventHandle = CreateEventW(NULL,
+			      FALSE,
+			      FALSE,
+			      NULL);
+   if (EventHandle == INVALID_HANDLE_VALUE)
+     {
+	printf("Failed to create event\n");
+	return 0;
+     }
+   
+   printf("Opening file\n");
+   RtlInitUnicodeString(&FileName,
+			      L"\\C:\\a.txt");			      
+   InitializeObjectAttributes(&ObjectAttributes,
+			      &FileName,
+			      0,
+			      NULL,
+			      NULL);
+   
+   printf("Creating file\n");
+   FileHandle = CreateFileW(L"C:\\a.txt",
+			    FILE_GENERIC_READ | FILE_GENERIC_WRITE,
+			    0,
+			    NULL,
+			    OPEN_EXISTING,
+			    FILE_FLAG_OVERLAPPED,
+			    NULL);
+   if (FileHandle == INVALID_HANDLE_VALUE)
+     {
+	printf("Open failed\n");
+	return 0;
+     }
+   printf("Reading file\n");
+   Status = ZwReadFile(FileHandle,
+			NULL,
+			(PIO_APC_ROUTINE)ApcRoutine,
+			(PVOID)0xdeadbeef,
+			&IoStatus,
+			Buffer,
+			256,
+			NULL,
+			NULL);
+   if (!NT_SUCCESS(Status))
+     {
+	printf("Read failed\n");
+     }
+   printf("Waiting\n");
+   WaitForSingleObjectEx(EventHandle, INFINITE, TRUE);
+   printf("Returned from wait\n");
+   ZwClose(FileHandle);
+   printf("Program finished\n");
+   return 0;
+}
+

reactos/apps/tests/apc/makefile

@@ -0,0 +1,38 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+CFLAGS = -g
+
+OBJECTS= apc.o
+PROGS= apc.exe
+
+BASE_CFLAGS = -I../../include
+LIBS = ../../lib/crtdll/crtdll.a ../../lib/kernel32/kernel32.a \
+       ../../lib/ntdll/ntdll.a
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) apc.o apc.exe apc.sym
+
+.phony: clean
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+apc.exe: $(OBJECTS) $(LIBS)
+	$(CC) $(OBJECTS) $(LIBS) -o apc.exe
+	$(NM) --numeric-sort apc.exe > apc.sym
+
+include ../../rules.mak

reactos/apps/tests/args/args.c

@@ -0,0 +1,39 @@
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <windows.h>
+
+HANDLE OutputHandle;
+HANDLE InputHandle;
+
+void debug_printf(char* fmt, ...)
+{
+   va_list args;
+   char buffer[255];
+
+   va_start(args,fmt);
+   vsprintf(buffer,fmt,args);
+   WriteConsoleA(OutputHandle, buffer, strlen(buffer), NULL, NULL);
+   va_end(args);
+}
+
+
+int main(int argc, char* argv[])
+{
+   int i;
+
+   AllocConsole();
+   InputHandle = GetStdHandle(STD_INPUT_HANDLE);
+   OutputHandle =  GetStdHandle(STD_OUTPUT_HANDLE);
+
+   printf("GetCommandLineA() %s\n",GetCommandLineA());
+   debug_printf("GetCommandLineA() %s\n",GetCommandLineA());
+   debug_printf("argc %d\n", argc);
+   for (i=0; i<argc; i++)
+     {
+        debug_printf("Argv[%d]: %x\n",i,argv[i]);
+        debug_printf("Argv[%d]: '%s'\n",i,argv[i]);
+     }
+   return 0;
+}
+

reactos/apps/tests/args/makefile

@@ -0,0 +1,34 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+OBJECTS= args.o
+PROGS= args.exe
+
+BASE_CFLAGS = -I../../include
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) args.o args.exe args.sym
+
+.phony: clean
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+args.exe: $(OBJECTS)
+	$(CC) $(OBJECTS) -o args.exe
+	$(NM) --numeric-sort args.exe > args.sym
+
+include ../../rules.mak

reactos/apps/tests/atomtest/atomtest.c

@@ -0,0 +1,114 @@
+#include <stdio.h>
+#include <string.h>
+#include <windows.h>
+#include <ddk/ntddk.h>
+
+#define BUFFER_SIZE 256
+
+int main(int argc, char* argv[])
+{
+   PRTL_ATOM_TABLE AtomTable = NULL;
+   RTL_ATOM AtomA = -1, AtomB = -1, AtomC = -1;
+   NTSTATUS Status;
+   WCHAR Buffer[BUFFER_SIZE];
+   ULONG NameLength, Data1, Data2;
+
+   printf("Atom table test app\n\n");
+
+   printf("RtlCreateAtomTable()\n");
+   Status = RtlCreateAtomTable(37,
+			       &AtomTable);
+   printf("  Status 0x%08lx\n", Status);
+
+   if (NT_SUCCESS(Status))
+     {
+	printf("  AtomTable %p\n", AtomTable);
+
+	printf("RtlAddAtomToAtomTable()\n");
+	Status = RtlAddAtomToAtomTable(AtomTable,
+				       L"TestAtomA",
+				       &AtomA);
+	printf("  Status 0x%08lx\n", Status);
+	if (NT_SUCCESS(Status))
+	  {
+	     printf("  AtomA 0x%x\n", AtomA);
+	  }
+
+	printf("RtlAddAtomToAtomTable()\n");
+	Status = RtlAddAtomToAtomTable(AtomTable,
+				       L"TestAtomB",
+				       &AtomB);
+	printf("  Status 0x%08lx\n", Status);
+	if (NT_SUCCESS(Status))
+	  {
+	     printf("  AtomB 0x%x\n", AtomB);
+	  }
+
+
+	printf("RtlLookupAtomInAtomTable()\n");
+	Status = RtlLookupAtomInAtomTable(AtomTable,
+					  L"TestAtomA",
+					  &AtomC);
+	printf("  Status 0x%08lx\n", Status);
+	if (NT_SUCCESS(Status))
+	  {
+	     printf("  AtomC 0x%x\n", AtomC);
+	  }
+
+
+	printf("RtlPinAtomInAtomTable()\n");
+	Status = RtlPinAtomInAtomTable(AtomTable,
+				       AtomC);
+	printf("  Status 0x%08lx\n", Status);
+
+	printf("RtlPinAtomInAtomTable()\n");
+	Status = RtlPinAtomInAtomTable(AtomTable,
+				       AtomC);
+	printf("  Status 0x%08lx\n", Status);
+
+
+//	printf("RtlDeleteAtomFromAtomTable()\n");
+//	Status = RtlDeleteAtomFromAtomTable(AtomTable,
+//					    AtomC);
+//	printf("  Status 0x%08lx\n", Status);
+
+
+//	printf("RtlEmptyAtomTable()\n");
+//	Status = RtlEmptyAtomTable(AtomTable,
+//				   TRUE);
+//	printf("  Status 0x%08lx\n", Status);
+
+
+//	printf("RtlLookupAtomInAtomTable()\n");
+//	Status = RtlLookupAtomInAtomTable(AtomTable,
+//					  L"TestAtomA",
+//					  &AtomC);
+//	printf("  Status 0x%08lx\n", Status);
+
+
+	printf("RtlQueryAtomInAtomTable()\n");
+	NameLength = sizeof(WCHAR) * BUFFER_SIZE;
+	Status = RtlQueryAtomInAtomTable(AtomTable,
+					 AtomC,
+					 &Data1,
+					 &Data2,
+					 Buffer,
+					 &NameLength);
+	printf("  Status 0x%08lx\n", Status);
+	if (NT_SUCCESS(Status))
+	  {
+	     printf("  RefCount %ld\n", Data1);
+	     printf("  PinCount %ld\n", Data2);
+	     printf("  NameLength %lu\n", NameLength);
+	     printf("  AtomName: %S\n", Buffer);
+	  }
+
+	printf("RtlDestroyAtomTable()\n");
+	RtlDestroyAtomTable(AtomTable);
+
+
+	printf("Atom table test app finished\n");
+     }
+
+   return(0);
+}

reactos/apps/tests/atomtest/makefile

@@ -0,0 +1,34 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+OBJECTS = atomtest.o
+PROGS = atomtest.exe
+LIBS = ../../lib/crtdll/crtdll.a ../../lib/kernel32/kernel32.a \
+       ../../lib/ntdll/ntdll.a
+
+CLEAN_FILES = atomtest.o atomtest.exe
+
+all: atomtest.exe
+
+clean: 
+	- $(RM) $(CLEAN_FILES)
+
+.phony: clean 
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+atomtest.exe: $(OBJECTS) $(LIBS)
+	$(CC) $(OBJECTS) $(LIBS) -o atomtest.exe
+	$(NM) --numeric-sort atomtest.exe > atomtest.sym
+
+include ../../rules.mak

reactos/apps/tests/bench/bench-syscall.c

@@ -0,0 +1,8 @@
+/*
+ * 
+ */
+
+int main(int argc, char* argv[])
+{
+   
+}

reactos/apps/tests/bench/bench-thread.c

@@ -0,0 +1,82 @@
+#include <stdio.h>
+#include <windows.h>
+
+#define NR_THREADS (30)
+
+
+DWORD WINAPI
+thread_main1(LPVOID param)
+{
+   printf("Thread 1 running (Counter %lu)\n", (DWORD)param);
+   SleepEx(INFINITE, TRUE);
+   return 0;
+}
+
+
+DWORD WINAPI
+thread_main2(LPVOID param)
+{
+   printf("Thread 2 running (Counter %lu)\n", (DWORD)param);
+   Sleep(INFINITE);
+   return 0;
+}
+
+
+int main (void)
+{
+   HANDLE hThread;
+   DWORD i=0;
+   DWORD id;
+
+#if 1
+   printf("Creating %d threads...\n",NR_THREADS*2);
+   for (i=0;i<NR_THREADS;i++)
+     {
+	CreateThread(NULL,
+		     0,
+		     thread_main1,
+		     (LPVOID)i,
+		     0,
+		     &id);
+
+/*	CreateThread(NULL,
+		     0,
+		     thread_main2,
+		     (LPVOID)i,
+		     0,
+		     &id);*/
+     }
+
+   printf("All threads created...\n");
+   
+   /*
+    * Waiting for threads is not implemented yet.
+    * If you want to see all threads running, uncomment the
+    * call to SuspendThread(). The test application will
+    * freeze after all threads are created.
+    */
+/*   SuspendThread (GetCurrentThread()); */
+
+#else
+
+   printf("Creating thread...\n");
+
+   hThread = CreateThread(NULL,
+                          0,
+                          thread_main1,
+                          (LPVOID)i,
+                          0,
+                          &id);
+
+   printf("Thread created. Waiting for termination...\n");
+
+   WaitForSingleObject (hThread,
+                        -1);
+
+   CloseHandle (hThread);
+
+   printf("Thread terminated...\n");
+#endif
+   printf("Exiting\n");
+   return 0;
+}

reactos/apps/tests/bench/makefile

@@ -0,0 +1,31 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+PROGS = bench-thread
+
+all: $(PROGS:%=%.exe)
+
+.phony: all
+
+clean: 
+	- $(RM) *.o *.exe *.sym
+
+.phony: clean
+
+install: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%.exe): $(FLOPPY_DIR)/apps/%.exe: %.exe
+	$(CP) $*.exe $(FLOPPY_DIR)/apps/$*.exe
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%.exe)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%.exe): ../../$(DIST_DIR)/apps/%.exe: %.exe
+	$(CP) $*.exe ../../$(DIST_DIR)/apps/$*.exe
+
+bench-thread.exe: bench-thread.c
+	$(CC) $(CFLAGS) bench-thread.c -lkernel32 -o bench-thread.exe
+	$(NM) --numeric-sort bench-thread.exe > bench-thread.sym
+
+include ../../rules.mak

reactos/apps/tests/consume/Makefile

@@ -0,0 +1,31 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+OBJECTS = consume.o
+PROGS = consume.exe
+LIBS = 
+CLEAN_FILES = consume.o consume.exe
+
+all: consume.exe
+
+clean: 
+	- $(RM) $(CLEAN_FILES)
+
+.phony: clean 
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+consume.exe: $(OBJECTS)
+	$(CC) $(OBJECTS) -o consume.exe
+
+include ../../rules.mak

reactos/apps/tests/consume/consume.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <string.h>
+#include <windows.h>
+
+ULONG x[(4 * 1024 * 1024) / 4096];
+
+int main()
+{  
+   int i;
+   PUCHAR BaseAddress;
+   
+   BaseAddress = VirtualAlloc(NULL,
+			      4 * 1024 * 1024,
+			      MEM_COMMIT,
+			      PAGE_READONLY);
+   if (BaseAddress == NULL)
+     {
+	printf("Failed to allocate virtual memory");
+	return(1);
+     }
+   printf("BaseAddress %p\n", BaseAddress);
+   for (i = 0; i < ((4 * 1024 * 1024) / 4096); i++)
+     {
+	printf("%.6x, ", i*4096);
+	x[i] = BaseAddress[i*4096];
+     }
+   
+   return(0);
+}

reactos/apps/tests/count/Makefile

@@ -0,0 +1,47 @@
+#
+#
+#
+PATH_TO_TOP=../..
+
+TARGET_NAME=count
+
+OBJECTS=\
+	$(TARGET_NAME).o
+
+LIBRARIES=\
+	$(PATH_TO_TOP)/lib/kernel32/kernel32.a\
+	$(PATH_TO_TOP)/lib/crtdll/crtdll.a\
+	$(PATH_TO_TOP)/lib/user32/user32.a
+
+PROGS=\
+	$(TARGET_NAME).exe
+
+BASE_CFLAGS = -I$(PATH_TO_TOP)/include
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) $(TARGET_NAME).o $(TARGET_NAME).exe $(TARGET_NAME).sym
+
+.phony: clean
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=$(PATH_TO_TOP)/$(DIST_DIR)/apps/%)
+
+$(PROGS:%=$(PATH_TO_TOP)/$(DIST_DIR)/apps/%): $(PATH_TO_TOP)/$(DIST_DIR)/apps/%: %
+	$(CP) $* $(PATH_TO_TOP)/$(DIST_DIR)/apps/$*
+
+$(TARGET_NAME).exe: $(OBJECTS)
+	$(CC)\
+		$(OBJECTS)\
+		$(LIBRARIES)\
+		-o $(TARGET_NAME).exe
+	$(NM) --numeric-sort $(TARGET_NAME).exe > $(TARGET_NAME).sym
+
+include $(PATH_TO_TOP)/rules.mak

reactos/apps/tests/count/count.c

@@ -0,0 +1,15 @@
+/* $Id: count.c,v 1.1 2001/03/26 21:30:20 ea Exp $
+ *
+ */
+#include <stdlib.h>
+
+int n = 0;
+
+int
+main (int argc, char * argv [])
+{
+	while (1) printf ("%d ", n ++ );
+	return (0);
+}
+
+/* EOF */

reactos/apps/tests/dump_shared_data/dump_shared_data.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <ntddk.h>
+#include <napi/shared_data.h>
+
+int main()
+{
+   printf("TickCountLow: %x\n", 
+	  ((PKUSER_SHARED_DATA)USER_SHARED_DATA_BASE)->TickCountLow);
+}

reactos/apps/tests/dump_shared_data/makefile

@@ -0,0 +1,32 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+OBJECTS = dump_shared_data.o
+PROGS = dump_shared_data.exe
+LIBS = 
+CLEAN_FILES = dump_shared_data.o dump_shared_data.exe
+
+all: dump_shared_data.exe
+
+clean: 
+	- $(RM) $(CLEAN_FILES)
+
+.phony: clean 
+
+floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+dump_shared_data.exe: $(OBJECTS)
+	$(CC) $(OBJECTS) -o dump_shared_data.exe
+
+BASE_CFLAGS = -I../../include
+include ../../rules.mak

reactos/apps/tests/event/event.c

@@ -0,0 +1,33 @@
+#include <windows.h>
+#include <stdio.h>
+
+HANDLE events[2];
+
+DWORD WINAPI thread( LPVOID crap )
+{
+	SetEvent( events[0] );
+	if( crap )
+		SetEvent( events[1] );
+	return 1;
+}
+
+int main( void )
+{
+	DWORD id, Status;
+	printf( "Creating events\n" );
+	events[0] = CreateEvent( 0, TRUE, FALSE, 0 );
+	events[1] = CreateEvent( 0, TRUE, FALSE, 0 );
+	printf( "Created events\n" );
+	CreateThread( 0, 0, thread, 0, 0, &id );
+	printf( "WaitForSingleObject %s\n", ( WaitForSingleObject( events[0], INFINITE ) == WAIT_OBJECT_0 ? "worked" : "failed" ) );
+	ResetEvent( events[0] );
+	CreateThread( 0, 0, thread, 0, 0, &id );
+	printf( "WaitForMultipleObjects with waitall = FALSE %s\n", ( WaitForMultipleObjects( 2, events, FALSE, INFINITE ) == WAIT_OBJECT_0 ? "worked" : "failed" ) );
+	ResetEvent( events[0] );
+	CreateThread( 0, 0, thread, (void *)1, 0, &id );
+	Status = WaitForMultipleObjects( 2, events, TRUE, INFINITE );
+	printf( "WaitForMultipleObjects with waitall = TRUE %s\n", ( Status == WAIT_OBJECT_0 || Status == WAIT_OBJECT_0 + 1 ? "worked" : "failed" ) );
+	ResetEvent( events[0] );
+	printf( "WaitForSingleObject with timeout %s\n", ( WaitForSingleObject( events[0], 100 ) == WAIT_TIMEOUT ? "worked" : "failed" ) );
+	return 0;
+}

reactos/apps/tests/event/makefile

@@ -0,0 +1,31 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+PROGS = event
+
+all: $(PROGS:%=%.exe)
+
+.phony: all
+
+clean: 
+	- $(RM) *.o *.exe *.sym
+
+.phony: clean
+
+install: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%.exe): $(FLOPPY_DIR)/apps/%.exe: %.exe
+	$(CP) $*.exe $(FLOPPY_DIR)/apps/$*.exe
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%.exe)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%.exe): ../../$(DIST_DIR)/apps/%.exe: %.exe
+	$(CP) $*.exe ../../$(DIST_DIR)/apps/$*.exe
+
+event.exe: event.c
+	$(CC) $(CFLAGS) event.c -lkernel32 -o event.exe
+	$(NM) --numeric-sort event.exe > event.sym
+
+include ../../rules.mak

reactos/apps/tests/file/Makefile

@@ -0,0 +1,43 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+OBJECTS= file.o
+PROGS= file.exe
+
+BASE_CFLAGS = -I../../include
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) file.o file.exe file.sym
+
+.phony: clean
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+file.exe: $(OBJECTS)
+	$(CC) $(OBJECTS) $(BASE_CFLAGS) -o file.exe
+	$(NM) --numeric-sort file.exe > file.sym
+
+include ../../rules.mak
+
+
+
+
+
+
+
+
+

reactos/apps/tests/file/file.c

@@ -0,0 +1,54 @@
+/***********************************************************
+ * File read/write test utility                            *
+ **********************************************************/
+
+#include <windows.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+int main( void )
+{
+   HANDLE file;
+   char buffer[4096];
+   DWORD wrote;
+   int c;
+   
+   file = CreateFile("test.dat", 
+		     GENERIC_READ | GENERIC_WRITE, 
+		     0, 
+		     NULL, 
+		     CREATE_ALWAYS, 
+		     0, 
+		     0);
+   
+   if (file == INVALID_HANDLE_VALUE)
+      {
+	 printf("Error opening file (Status %x)\n", GetLastError());
+	 return 1;
+      }
+   for( c = 0; c < sizeof( buffer ); c++ )
+      buffer[c] = (char)c;
+   printf("Writing file\n");
+   if (WriteFile( file, buffer, 4096, &wrote, NULL) == FALSE)
+     {
+       printf("Error writing file (Status %x)\n", GetLastError());
+       exit(2);
+       }
+   printf("Reading file\n");
+   SetFilePointer( file, 0, 0, FILE_BEGIN );
+   if (ReadFile( file, buffer, 4096, &wrote, NULL) == FALSE)
+     {
+       printf("Error reading file (Status %x)\n", GetLastError());
+       exit(3);
+     }
+   for( c = 0; c < sizeof( buffer ); c++ )
+      if( buffer[c] != (char)c )
+	 {
+	    printf( "Error: data read back is not what was written\n" );
+	    CloseHandle( file );
+	    return 0;
+	 }
+   printf("Finished, works fine\n");
+   CloseHandle( file );
+   return 0;
+}

reactos/apps/tests/file/file.cpp

@@ -0,0 +1,39 @@
+/***********************************************************
+ * File read/write test utility                            *
+ **********************************************************/
+
+#include <windows.h>
+#include <iostream>
+#include <stdlib.h>
+
+int main( void )
+{
+  HANDLE file = CreateFile( "test.dat", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
+  char buffer[4096];
+
+  if( file == INVALID_HANDLE_VALUE )
+  {
+    FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), 0, buffer, 4096, NULL );
+    cout << "Error opening file: " << buffer << endl;
+    return 1;
+  }
+  DWORD wrote;
+  for( int c = 0; c < 1024; c++ )
+    if( WriteFile( file, buffer, 4096, &wrote, NULL ) == FALSE )
+    {
+      FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), 0, buffer, 4096, NULL );
+      cout << "Error writing file: " << buffer << endl;
+      exit(2);
+    }
+  cout << "File written, trying to read now" << endl;
+  for( int c = 0; c < 1024; c++ )
+    if( ReadFile( file, buffer, 4096, &wrote, NULL ) == FALSE )
+    {
+      FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), 0, buffer, 4096, NULL );
+      cout << "Error reading file: " << buffer << endl;
+      exit(3);
+    }
+  cout << "Test passed" << endl;
+
+  return 0;
+}

reactos/apps/tests/gditest/gditest.c

@@ -0,0 +1,131 @@
+/*
+ * gditest
+ */
+
+#include <windows.h>
+
+extern BOOL STDCALL GdiDllInitialize(HANDLE hInstance, DWORD Event, LPVOID Reserved);
+
+void __stdcall Background (HDC Desktop)
+{
+	HPEN Pen;
+	int x, y;
+	
+	Pen = CreatePen(PS_SOLID, 1, RGB(64, 64, 128));
+
+	SelectObject (Desktop, Pen);
+
+	MoveToEx (Desktop, 0, 0, NULL);
+	LineTo (Desktop, 640, 480);
+	for (y = 480, x = 0; x < 640; x+=2)
+	{
+		MoveToEx (Desktop, 0, 0, NULL);
+		LineTo (Desktop, x, y);
+	}
+	for (y = 0, x = 640; y < 480; y+=2)
+	{
+		MoveToEx (Desktop, 0, 0, NULL);
+		LineTo (Desktop, x, y);
+	}
+}
+
+int main (void)
+{
+  HDC  Desktop, MyDC, DC24;
+  HPEN  RedPen, GreenPen, BluePen, WhitePen;
+  HBITMAP  MyBitmap, DIB24;
+  HFONT  hf, tf;
+  BITMAPINFOHEADER BitInf;
+  BITMAPINFO BitPalInf;
+
+  printf("Entering GDITest..\n");
+
+  GdiDllInitialize (NULL, DLL_PROCESS_ATTACH, NULL);
+
+  // Set up a DC called Desktop that accesses DISPLAY
+  Desktop = CreateDCA("DISPLAY", NULL, NULL, NULL);
+  if (Desktop == NULL)
+    return 1;
+
+  // Background
+  Background (Desktop);
+
+  // Create a blue pen and select it into the DC
+  BluePen = CreatePen(PS_SOLID, 8, RGB(0, 0, 0xff));
+  SelectObject(Desktop, BluePen);
+
+  // Draw a shape on the DC
+  MoveToEx(Desktop, 50, 50, NULL);
+  LineTo(Desktop, 200, 60);
+  LineTo(Desktop, 200, 300);
+  LineTo(Desktop, 50, 50);
+  MoveToEx(Desktop, 50, 50, NULL);
+  LineTo(Desktop, 200, 50);
+
+  WhitePen = CreatePen(PS_SOLID, 3, RGB(0xff, 0xff, 0xff));
+  SelectObject(Desktop, GreenPen);
+
+  MoveToEx(Desktop, 20, 70, NULL);
+  LineTo(Desktop, 500, 70);
+  MoveToEx(Desktop, 70, 20, NULL);
+  LineTo(Desktop, 70, 150);
+
+  // Test font support
+  GreenPen = CreatePen(PS_SOLID, 3, RGB(0, 0xff, 0));
+  RedPen = CreatePen(PS_SOLID, 3, RGB(0xff, 0, 0));
+
+  hf = CreateFontA(24, 0, 0, TA_BASELINE, FW_NORMAL, FALSE, FALSE, FALSE,
+                   ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
+                   DEFAULT_QUALITY, FIXED_PITCH|FF_DONTCARE, "Helmet");
+  SelectObject(Desktop, hf);
+  SetTextColor(Desktop, RGB(0xff, 0, 0));
+  TextOutA(Desktop, 70, 70, "React", 5);
+  SetTextColor(Desktop, RGB(0, 0xff, 0));
+  TextOutA(Desktop, 140, 70, "OS", 2);
+
+  tf = CreateFontA(14, 0, 0, TA_BASELINE, FW_NORMAL, FALSE, FALSE, FALSE,
+                   ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
+                   DEFAULT_QUALITY, FIXED_PITCH|FF_DONTCARE, "Timmons");
+  SelectObject(Desktop, tf);
+  SetTextColor(Desktop, RGB(0xff, 0xff, 0xff));
+  TextOutA(Desktop, 70, 90, "This is a test of ReactOS text, using the FreeType 2 library!", 61);
+
+  // TEST 1: Copy from the VGA into a device compatible DC, draw on it, then blt it to the VGA again
+  MyDC = CreateCompatibleDC(Desktop);
+  MyBitmap = CreateCompatibleBitmap(Desktop, 151, 251);
+  SelectObject(MyDC, MyBitmap);
+  BitBlt(MyDC, 0, 0, 151, 251, Desktop, 50, 50, SRCCOPY); // can we say 151, 251 since bottom corner is not inclusive?
+
+  SelectObject(MyDC, GreenPen);
+  Rectangle(MyDC, 10, 10, 50, 50);
+
+  // TEST 2: Copy from the device compatible DC into a 24BPP bitmap, draw on it, then blt to the VGA again
+  BitInf.biSize = sizeof(BITMAPINFOHEADER);
+  BitInf.biWidth = 152;
+  BitInf.biHeight = -252; // it's top down (since BI_RGB is used, the sign is operative of direction)
+  BitInf.biPlanes = 1;
+  BitInf.biBitCount = 24;
+  BitInf.biCompression = BI_RGB;
+  BitInf.biSizeImage = 0;
+  BitInf.biXPelsPerMeter = 0;
+  BitInf.biYPelsPerMeter = 0;
+  BitInf.biClrUsed = 0;
+  BitInf.biClrImportant = 0;
+  BitPalInf.bmiHeader = BitInf;
+  DIB24 = (HBITMAP) CreateDIBSection(NULL, &BitPalInf, DIB_RGB_COLORS, NULL, NULL, 0);
+  DC24 = CreateCompatibleDC(NULL);
+  SelectObject(DC24, DIB24);
+
+  BitBlt(DC24, 0, 0, 101, 201, MyDC, 0, 0, SRCCOPY);
+  SelectObject(DC24, RedPen);
+  Rectangle(DC24, 80, 90, 100, 110);
+  MoveToEx(DC24, 80, 90, NULL);
+  LineTo(DC24, 100, 110);
+  BitBlt(Desktop, 200, 200, 110, 120, DC24, 0, 0, SRCCOPY);
+
+  Sleep( 990000 ); // fixme delay only 10000 (for 10 seconds)
+  // Free up everything
+  DeleteDC(Desktop);
+  DeleteDC(MyDC);
+  return 0;
+}

reactos/apps/tests/gditest/makefile

@@ -0,0 +1,35 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+PROGS = gditest
+
+OBJECTS = 
+LIBS= ../../lib/kernel32/kernel32.a ../../lib/gdi32/gdi32.a
+CFLAGS = -I../../include
+
+all: $(PROGS:%=%.exe)
+
+.phony: all
+
+clean:
+	- $(RM) *.o *.exe *.sym
+
+.phony: clean
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%.exe): $(FLOPPY_DIR)/apps/%.exe: %.exe
+	$(CP) $*.exe $(FLOPPY_DIR)/apps/$*.exe
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%.exe)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%.exe): ../../$(DIST_DIR)/apps/%.exe: %.exe
+	$(CP) $*.exe ../../$(DIST_DIR)/apps/$*.exe
+
+gditest.exe: gditest.c
+	$(CC) $(CFLAGS) gditest.c $(LIBS) -o gditest.exe
+	$(NM) --numeric-sort gditest.exe > gditest.sym
+
+include ../../rules.mak

reactos/apps/tests/hello/hello.c

@@ -0,0 +1,8 @@
+#include <stdio.h>
+#include <string.h>
+
+int main(int argc, char* argv[])
+{  
+   printf("Hello world\n");
+   return(0);
+}

reactos/apps/tests/hello/makefile

@@ -0,0 +1,31 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+OBJECTS = hello.o
+PROGS = hello.exe
+LIBS = 
+CLEAN_FILES = hello.o hello.exe
+
+all: hello.exe
+
+clean: 
+	- $(RM) $(CLEAN_FILES)
+
+.phony: clean 
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+hello.exe: $(OBJECTS)
+	$(CC) $(OBJECTS) -o hello.exe
+
+include ../../rules.mak

reactos/apps/tests/lpc/conport.c

@@ -0,0 +1,205 @@
+/* $Id: conport.c,v 1.6 2000/04/25 23:22:46 ea Exp $
+ *
+ * reactos/apps/lpc/conport.c
+ *
+ * To be run in a real WNT 4.0 system with
+ * "\SmApiPort" as argument. Do not try to
+ * connect to "\Windows\ApiPort" since that
+ * reboots immeditely.
+ * 
+ * Use Russinovich' HandleEx to verify
+ * conport.exe owns two unnamed LPC ports:
+ * the one created by kernel32.dll connecting
+ * to csrss.exe, and one connected to here.
+ *
+ * 19990627 (Emanuele Aliberti)
+ * 	Initial implementation.
+ * 19990704 (EA)
+ * 	Dump object's attributes moved in dumpinfo.c.
+ */
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define PROTO_LPC
+#include <ddk/ntddk.h>
+#include "dumpinfo.h"
+
+#define LPC_CONNECT_FLAG1 0x00000001
+#define LPC_CONNECT_FLAG2 0x00000010
+#define LPC_CONNECT_FLAG3 0x00000100
+#define LPC_CONNECT_FLAG4 0x00001000
+#define LPC_CONNECT_FLAG5 0x00010000
+
+NTSTATUS
+(STDCALL * ConnectPort)(
+	OUT	PHANDLE			PortHandle,
+	IN	PUNICODE_STRING		PortName,
+	IN	POBJECT_ATTRIBUTES	ObjectAttributes,
+	IN	DWORD	Unknown3,
+	IN	DWORD	Unknown4,
+	IN	DWORD	Unknown5,
+	IN	DWORD	Unknown6,
+	IN	ULONG	Flags
+	);
+
+NTSTATUS
+(STDCALL * QueryObject)(
+	IN	HANDLE	ObjectHandle,
+	IN	CINT	ObjectInformationClass,
+	OUT	PVOID	ObjectInformation,
+	IN	ULONG	Length,
+	OUT	PULONG	ResultLength
+	);
+  
+NTSTATUS
+(STDCALL * YieldExecution)(VOID);
+
+#define BUF_SIZE 1024
+#define MAXARG   1000000
+
+
+VOID
+TryConnectPort(char *port_name)
+{
+	DWORD			Status = 0;
+	HANDLE			Port = 0;
+	int			i;
+	UNICODE_STRING		PortName;
+	OBJECT_ATTRIBUTES	ObjectAttributes;
+	WORD			Name [BUF_SIZE] = {0};
+	int			dwx = 0;
+	char			* port_name_save = port_name;
+
+	/*
+	 * Convert the port's name to Unicode.
+	 */
+	for (
+		PortName.Length = 0;
+		(	*port_name
+			&& (PortName.Length < BUF_SIZE)
+			);
+		)
+	{
+		Name[PortName.Length++] = (WORD) *port_name++;
+	}
+	Name[PortName.Length] = 0;
+
+	PortName.Length = PortName.Length * sizeof (WORD);
+	PortName.MaximumLength = PortName.Length + sizeof (WORD);
+	PortName.Buffer = (PWSTR) Name;
+	/*
+	 * Prepare the port object attributes.
+	 */
+	ObjectAttributes.Length =
+		sizeof (OBJECT_ATTRIBUTES);
+	ObjectAttributes.RootDirectory =
+		NULL;
+	ObjectAttributes.ObjectName =
+		NULL /*& PortName */;
+	ObjectAttributes.Attributes =
+		OBJ_CASE_INSENSITIVE;
+	ObjectAttributes.SecurityDescriptor =
+		NULL;
+	ObjectAttributes.SecurityQualityOfService =
+		NULL;
+	/*
+	 * Try to issue a connection request.
+	 */
+	Port = 0;
+	Status = ConnectPort(
+			& Port,			/* & PortHandle */
+			& PortName,		/* & PortName */
+			& ObjectAttributes,	/* & PortAttributes */
+			NULL,			/* & SecurityQos */
+			NULL,			/* & SectionInfo */
+			NULL,			/* & MapInfo */
+			NULL,			/* & MaxMessageSize */
+			LPC_CONNECT_FLAG5	/* & ConnectInfoLength */
+			);
+	if (Status == STATUS_SUCCESS)
+	{
+		DumpInfo(
+			Name,
+			Status,
+			"connected",
+			Port
+			);
+		/* Hot waiting */
+		for (dwx=0; dwx<MAXARG; ++dwx)
+		{
+			YieldExecution();
+		}
+		if (FALSE == CloseHandle(Port))
+		{
+			printf(
+				"Could not close the port handle %08X.\n",
+				Port
+				);
+		}
+		return;
+	}
+	printf(
+		"Connection to port \"%s\" failed (Status = %08X).\n",
+		port_name_save,
+		Status
+		);
+}
+
+
+main( int argc, char * argv[] )
+{
+	HINSTANCE ntdll;
+
+	if (argc != 2)
+	{
+		printf("WNT LPC Port Connector\n");
+		printf("Usage: %s [port_name]\n",argv[0]);
+		exit(EXIT_FAILURE);
+	}
+	printf("LoadLibrary(NTDLL)\n");
+	ntdll = LoadLibrary("NTDLL");
+	if (ntdll == NULL)
+	{
+		printf("Could not load NTDLL\n");
+		return EXIT_FAILURE;
+	}
+	printf("GetProcAddress(NTDLL.NtConnectPort)\n");
+	ConnectPort = (VOID*) GetProcAddress(
+					ntdll,
+					"NtConnectPort"
+					);
+	if (ConnectPort == NULL)
+	{
+		FreeLibrary(ntdll);
+		printf("Could not find NTDLL.NtConnectPort\n");
+		return EXIT_FAILURE;
+	}
+	printf("GetProcAddress(NTDLL.NtQueryObject)\n");
+	QueryObject = (VOID*) GetProcAddress(
+					ntdll,
+					"NtQueryObject"
+					);
+	if (QueryObject == NULL)
+	{
+		FreeLibrary(ntdll);
+		printf("Could not find NTDLL.NtQueryObject\n");
+		return EXIT_FAILURE;
+	}
+	printf("GetProcAddress(NTDLL.NtYieldExecution)\n");
+	YieldExecution = (VOID*) GetProcAddress(
+					ntdll,
+					"NtYieldExecution"
+					);
+	if (YieldExecution == NULL)
+	{
+		FreeLibrary(ntdll);
+		printf("Could not find NTDLL.NtYieldExecution\n");
+		return EXIT_FAILURE;
+	}
+	printf("TryConnectPort(%s)\n",argv[1]);
+	TryConnectPort(argv[1]);
+	printf("Done\n");
+	return EXIT_SUCCESS;
+}
+
+/* EOF */

reactos/apps/tests/lpc/creport.c

@@ -0,0 +1,192 @@
+/* $Id: creport.c,v 1.2 1999/07/17 23:10:12 ea Exp $
+ *
+ * reactos/apps/lpc/creport.c
+ *
+ * To be run in a real WNT 4.0 system to
+ * create an LPC named port.
+ * 
+ * Use Russinovich' HandleEx to verify
+ * creport.exe owns the named LPC port
+ * you asked to create.
+ */
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define PROTO_LPC
+#include <ddk/ntddk.h>
+#include "dumpinfo.h"
+
+#define LPC_CONNECT_FLAG1 0x00000001
+#define LPC_CONNECT_FLAG2 0x00000010
+#define LPC_CONNECT_FLAG3 0x00000100
+#define LPC_CONNECT_FLAG4 0x00001000
+#define LPC_CONNECT_FLAG5 0x00010000
+
+NTSTATUS
+(STDCALL * CreatePort)(
+	/*OUT	PHANDLE			PortHandle,*/
+	PVOID	Buffer,
+	IN	POBJECT_ATTRIBUTES	PortAttributes	OPTIONAL,  
+	IN	ACCESS_MASK		DesiredAccess,
+	IN	DWORD			Unknown3,
+	IN	ULONG			Flags
+	);
+
+NTSTATUS
+(STDCALL * QueryObject)(
+	IN	HANDLE	ObjectHandle,
+	IN	CINT	ObjectInformationClass,
+	OUT	PVOID	ObjectInformation,
+	IN	ULONG	Length,
+	OUT	PULONG	ResultLength
+	);
+  
+NTSTATUS
+(STDCALL * YieldExecution)(VOID);
+
+#define BUF_SIZE 1024
+#define MAXARG   5000000
+
+
+VOID
+TryCreatePort(char *port_name)
+{
+	DWORD			Status = 0;
+	HANDLE			Port = 0;
+	int			i;
+	UNICODE_STRING		PortName;
+	OBJECT_ATTRIBUTES	ObjectAttributes;
+	WORD			Name [BUF_SIZE] = {0};
+	int			dwx = 0;
+	char			* port_name_save = port_name;
+
+	/*
+	 * Convert the port's name to Unicode.
+	 */
+	for (
+		PortName.Length = 0;
+		(	*port_name
+			&& (PortName.Length < BUF_SIZE)
+			);
+		)
+	{
+		Name[PortName.Length++] = (WORD) *port_name++;
+	}
+	Name[PortName.Length] = 0;
+
+	PortName.Length = PortName.Length * sizeof (WORD);
+	PortName.MaximumLength = PortName.Length + sizeof (WORD);
+	PortName.Buffer = (PWSTR) Name;
+	/*
+	 * Prepare the port object attributes.
+	 */
+	ObjectAttributes.Length =
+		sizeof (OBJECT_ATTRIBUTES);
+	ObjectAttributes.RootDirectory =
+		NULL;
+	ObjectAttributes.ObjectName =
+		& PortName;
+	ObjectAttributes.Attributes =
+		0; //OBJ_CASE_INSENSITIVE --> STATUS_INVALID_PARAMETER ==> case sensitive!;
+	ObjectAttributes.SecurityDescriptor =
+		NULL;
+	ObjectAttributes.SecurityQualityOfService =
+		NULL;
+	/*
+	 * Try to issue a connection request.
+	 */
+	Port = 0;
+	Status = CreatePort(
+			& Port,
+			& ObjectAttributes,
+			0, /* ACCESS_MASK? */
+			0, /* Unknown3 */
+			LPC_CONNECT_FLAG5
+			);
+	if (Status == STATUS_SUCCESS)
+	{
+		DumpInfo(
+			Name,
+			Status,
+			"created",
+			Port
+			);
+		/* Hot waiting */
+		for (dwx=0; dwx<MAXARG; ++dwx)
+		{
+			YieldExecution();
+		}
+		if (FALSE == CloseHandle(Port))
+		{
+			printf(
+				"Could not close the port handle %08X.\n",
+				Port
+				);
+		}
+		return;
+	}
+	printf(
+		"Creating port \"%s\" failed (Status = %08X).\n",
+		port_name_save,
+		Status
+		);
+}
+
+
+main( int argc, char * argv[] )
+{
+	HINSTANCE ntdll;
+
+	if (argc != 2)
+	{
+		printf("WNT LPC Port Creator\n");
+		printf("Usage: %s [port_name]\n",argv[0]);
+		exit(EXIT_FAILURE);
+	}
+	printf("LoadLibrary(NTDLL)\n");
+	ntdll = LoadLibrary("NTDLL");
+	if (ntdll == NULL)
+	{
+		printf("Could not load NTDLL\n");
+		return EXIT_FAILURE;
+	}
+	printf("GetProcAddress(NTDLL.NtCreatePort)\n");
+	CreatePort = (VOID*) GetProcAddress(
+					ntdll,
+					"NtCreatePort"
+					);
+	if (CreatePort == NULL)
+	{
+		FreeLibrary(ntdll);
+		printf("Could not find NTDLL.NtCreatePort\n");
+		return EXIT_FAILURE;
+	}
+	printf("GetProcAddress(NTDLL.NtQueryObject)\n");
+	QueryObject = (VOID*) GetProcAddress(
+					ntdll,
+					"NtQueryObject"
+					);
+	if (QueryObject == NULL)
+	{
+		FreeLibrary(ntdll);
+		printf("Could not find NTDLL.NtQueryObject\n");
+		return EXIT_FAILURE;
+	}
+	printf("GetProcAddress(NTDLL.NtYieldExecution)\n");
+	YieldExecution = (VOID*) GetProcAddress(
+					ntdll,
+					"NtYieldExecution"
+					);
+	if (YieldExecution == NULL)
+	{
+		FreeLibrary(ntdll);
+		printf("Could not find NTDLL.NtYieldExecution\n");
+		return EXIT_FAILURE;
+	}
+	printf("TryCreatePort(%s)\n",argv[1]);
+	TryCreatePort(argv[1]);
+	printf("Done\n");
+	return EXIT_SUCCESS;
+}
+
+/* EOF */

reactos/apps/tests/lpc/dumpinfo.c

@@ -0,0 +1,239 @@
+/* $Id: dumpinfo.c,v 1.2 1999/07/17 23:10:12 ea Exp $
+ *
+ * reactos/apps/lpc/dumpinfo.c
+ *
+ * ReactOS Operating System
+ *
+ * Dump a kernel object's attributes by its handle.
+ *
+ * 19990627 (Emanuele Aliberti)
+ * 	Initial implementation.
+ * 19990704 (EA)
+ * 	Added code to find the basic information buffer size
+ * 	for the LPC port object.
+ * 19990710 (EA)
+ * 
+ */
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ddk/ntddk.h>
+
+#define BUF_SIZE		1024
+#define MAX_BASIC_INFO_SIZE	512
+
+
+extern
+NTSTATUS
+(STDCALL * QueryObject)(
+	IN	HANDLE	ObjectHandle,
+	IN	CINT	ObjectInformationClass,
+	OUT	PVOID	ObjectInformation,
+	IN	ULONG	Length,
+	OUT	PULONG	ResultLength
+	);
+
+extern
+NTSTATUS
+(STDCALL * QueryInformationPort)(
+	IN	HANDLE	PortHandle,
+	IN	CINT	PortInformationClass,	/* guess */
+	OUT	PVOID	PortInformation,	/* guess */
+	IN	ULONG	PortInformationLength,	/* guess */
+	OUT	PULONG	ReturnLength		/* guess */
+	);
+
+
+/*
+static
+VOID
+DumpBuffer(
+	char	*Name,
+	BYTE	*buffer,
+	ULONG	size
+	)
+{
+	register ULONG i = 0;
+
+	printf("%s [%d] = ",Name,size);
+	for (	i = 0;
+		i != size;
+		++i
+		)
+	{
+		printf("%02X",buffer[i]);
+	}
+	printf("\n");
+}
+*/
+
+VOID
+DumpInfo (
+	LPCWSTR		Name,
+	NTSTATUS	Status,
+	LPCWSTR		Comment,
+	HANDLE		Port
+	)
+{
+	BYTE			ObjectInformation [BUF_SIZE] = {0};
+	ULONG			ResultLength;
+	
+	wprintf(
+		L"Port \"%s\" %s:\n",
+		Name,
+		Comment
+		);
+
+	printf("\tStatus = %08X\n",Status);
+	printf("\tPort   = %08X\n\n",Port);
+	/*
+	 * Query object information.
+	 */
+	printf("Basic Information:\n");
+	Status = QueryObject(
+			Port,
+			ObjectBasicInformation,
+			ObjectInformation,
+			sizeof (LPC_PORT_BASIC_INFORMATION),
+			& ResultLength
+			);
+	if (Status == STATUS_SUCCESS)
+	{
+		PLPC_PORT_BASIC_INFORMATION	i;
+
+		i = (PLPC_PORT_BASIC_INFORMATION) ObjectInformation;
+	
+		printf( "\tUnknown01 = 0x%08X\n", i->Unknown0 );
+		printf( "\tUnknown02 = 0x%08X\n", i->Unknown1 );
+		printf( "\tUnknown03 = 0x%08X\n", i->Unknown2 );
+		printf( "\tUnknown04 = 0x%08X\n", i->Unknown3 );
+		printf( "\tUnknown05 = 0x%08X\n", i->Unknown4 );
+		printf( "\tUnknown06 = 0x%08X\n", i->Unknown5 );
+		printf( "\tUnknown07 = 0x%08X\n", i->Unknown6 );
+		printf( "\tUnknown08 = 0x%08X\n", i->Unknown7 );
+		printf( "\tUnknown09 = 0x%08X\n", i->Unknown8 );
+		printf( "\tUnknown10 = 0x%08X\n", i->Unknown9 );
+		printf( "\tUnknown11 = 0x%08X\n", i->Unknown10 );
+		printf( "\tUnknown12 = 0x%08X\n", i->Unknown11 );
+		printf( "\tUnknown13 = 0x%08X\n", i->Unknown12 );
+		printf( "\tUnknown14 = 0x%08X\n", i->Unknown13 );
+	}
+	else
+	{
+		printf("\tStatus = %08X\n",Status);
+	}
+	printf("Type Information:\n");
+	Status = QueryObject(
+			Port,
+			ObjectTypeInformation,
+			ObjectInformation,
+			sizeof ObjectInformation,
+			& ResultLength
+			);
+	if (Status == STATUS_SUCCESS)
+	{
+		OBJECT_TYPE_INFORMATION	* i;
+
+		i = (OBJECT_TYPE_INFORMATION *) ObjectInformation;
+		
+		wprintf(
+			L"\tName: \"%s\"\n",
+			(i->Name.Length ? i->Name.Buffer : L"")
+			);
+/*
+FIXME: why this always raise an access violation exception?
+		wprintf(
+			L"\tType: \"%s\"\n",
+			(i->Type.Length ? i->Type.Buffer : L"")
+			);
+/**/
+		printf(
+			"\tTotal Handles: %d\n",
+			i->TotalHandles
+			);
+		printf(
+			"\tReference Count: %d\n",
+			i->ReferenceCount
+			);
+	}
+	else
+	{
+		printf("\tStatus = %08X\n",Status);
+	}
+	printf("Name Information:\n");
+	Status = QueryObject(
+			Port,
+			ObjectNameInformation,
+			ObjectInformation,
+			sizeof ObjectInformation,
+			& ResultLength
+			);
+	if (Status == STATUS_SUCCESS)
+	{
+		OBJECT_NAME_INFORMATION	* i;
+
+		i = (OBJECT_NAME_INFORMATION *) ObjectInformation;
+		wprintf(
+			L"\tName: \"%s\"\n",
+			(i->Name.Length ? i->Name.Buffer : L"")
+			);
+	}
+	else
+	{
+		printf("\tStatus = %08X\n",Status);
+	}
+	printf("Data Information:\n");
+	Status = QueryObject(
+			Port,
+			ObjectDataInformation,
+			ObjectInformation,
+			sizeof ObjectInformation,
+			& ResultLength
+			);
+	if (Status == STATUS_SUCCESS)
+	{
+		OBJECT_DATA_INFORMATION	* i;
+
+		i = (OBJECT_DATA_INFORMATION *) ObjectInformation;
+		printf(
+			"\tInherit Handle: %s\n",
+			(i->bInheritHandle ? "TRUE" : "FALSE")
+			);
+		printf(
+			"\tProtect from Close: %s\n",
+			(i->bProtectFromClose ? "TRUE" : "FALSE")
+			);
+	}
+	else
+	{
+		printf("\tStatus = %08X\n",Status);
+	}
+//---
+	printf("Port Information:\n");
+/*	Status = QueryInformationPort(
+			Port,
+			1, /* info class * /
+			ObjectInformation,
+			sizeof ObjectInformation,
+			& ResultLength
+			);
+	if (Status == STATUS_SUCCESS)
+	{
+		DWORD * i = ObjectInformation;
+		int j = 0;
+
+		while (j < ResultLength / sizeof (DWORD))
+		{
+			printf("\t%08X\n",i[j]);
+			++j;
+		}
+	}
+	else
+	{
+		printf("\tStatus = %08X\n",Status);
+	}
+*/
+}
+
+
+/* EOF */

reactos/apps/tests/lpc/dumpinfo.h

@@ -0,0 +1,8 @@
+VOID
+DumpInfo (
+	LPCWSTR		Name,
+	NTSTATUS	Status,
+	LPCWSTR		Comment,
+	HANDLE		Port
+	);
+

reactos/apps/tests/lpc/lpcclt.c

@@ -0,0 +1,75 @@
+/* $Id: lpcclt.c,v 1.7 2000/06/29 23:35:09 dwelch Exp $
+ *
+ * DESCRIPTION: Simple LPC Client
+ * PROGRAMMER:  David Welch
+ */
+#include <ddk/ntddk.h>
+#include <windows.h>
+#include <napi/lpc.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+HANDLE OutputHandle;
+HANDLE InputHandle;
+
+void debug_printf(char* fmt, ...)
+{
+   va_list args;
+   char buffer[255];
+
+   va_start(args,fmt);
+   vsprintf(buffer,fmt,args);
+   WriteConsoleA(OutputHandle, buffer, strlen(buffer), NULL, NULL);
+   va_end(args);
+}
+
+
+int main(int argc, char* argv[])
+{
+   UNICODE_STRING PortName;
+   NTSTATUS Status;
+   HANDLE PortHandle;
+   LPC_MAX_MESSAGE Request;
+   ULONG ConnectInfoLength;
+   
+   printf("(lpcclt.exe) Lpc client\n");
+   
+   RtlInitUnicodeString(&PortName, L"\\TestPort");
+   
+   printf("(lpcclt.exe) Connecting to port \"\\TestPort\"\n");
+   ConnectInfoLength = 0;
+   Status = NtConnectPort(&PortHandle,
+			  &PortName,
+			  NULL,
+			  0,
+			  0,
+			  0,
+			  NULL,
+			  &ConnectInfoLength);
+   if (!NT_SUCCESS(Status))
+     {
+	printf("(lpcclt.exe) Failed to connect (Status = 0x%08X)\n", Status);
+	return EXIT_FAILURE;
+     }
+   
+   strcpy(Request.Data, GetCommandLineA());
+   Request.Header.DataSize = strlen(Request.Data);
+   Request.Header.MessageSize = sizeof(LPC_MESSAGE_HEADER) + 
+     Request.Header.DataSize;
+   
+   printf("(lpcclt.exe) Sending message \"%s\"\n", 
+	  (char *) Request.Data);
+   Status = NtRequestPort(PortHandle, 
+			  &Request.Header);
+   if (!NT_SUCCESS(Status))
+     {
+	printf("(lpcclt.exe) Failed to send request (Status = 0x%8X)\n", 
+	       Status);
+	return EXIT_FAILURE;
+     }
+   
+   printf("(lpcclt.exe) Succeeded\n");
+   return EXIT_SUCCESS;
+}

reactos/apps/tests/lpc/lpcsrv.c

@@ -0,0 +1,111 @@
+/* $Id: lpcsrv.c,v 1.7 2000/06/29 23:35:10 dwelch Exp $
+ *
+ * DESCRIPTION: Simple LPC Server
+ * PROGRAMMER:  David Welch
+ */
+#include <ddk/ntddk.h>
+#include <windows.h>
+#include <napi/lpc.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+HANDLE OutputHandle;
+HANDLE InputHandle;
+
+void debug_printf(char* fmt, ...)
+{
+   va_list args;
+   char buffer[255];
+
+   va_start(args,fmt);
+   vsprintf(buffer,fmt,args);
+   WriteConsoleA(OutputHandle, buffer, strlen(buffer), NULL, NULL);
+   va_end(args);
+}
+
+
+int main(int argc, char* argv[])
+{
+   UNICODE_STRING PortName;
+   OBJECT_ATTRIBUTES ObjectAttributes;
+   NTSTATUS Status;
+   HANDLE NamedPortHandle;
+   HANDLE PortHandle;
+   LPC_MAX_MESSAGE ConnectMsg;
+   
+   printf("(lpcsrv.exe) Lpc test server\n");
+   
+   RtlInitUnicodeString(&PortName, L"\\TestPort");
+   InitializeObjectAttributes(&ObjectAttributes,
+			      &PortName,
+			      0,
+			      NULL,
+			      NULL);
+   
+   printf("(lpcsrv.exe) Creating port\n");
+   Status = NtCreatePort(&NamedPortHandle,
+			 &ObjectAttributes,
+			 0,
+			 0,
+			 0);
+   if (!NT_SUCCESS(Status))
+     {
+	printf("(lpcsrv.exe) Failed to create port (Status = 0x%08lX)\n", Status);
+	return EXIT_FAILURE;
+     }
+   
+   
+   printf("(lpcsrv.exe) Listening for connections\n");
+   Status = NtListenPort(NamedPortHandle,
+			 &ConnectMsg.Header);
+   if (!NT_SUCCESS(Status))
+     {
+	printf("(lpcsrv.exe) Failed to listen for connections (Status = 0x%08lX)\n", Status);
+	return EXIT_FAILURE;
+     }
+   
+   printf("(lpcsrv.exe) Accepting connections\n");
+   Status = NtAcceptConnectPort(&PortHandle,
+				NamedPortHandle,
+				NULL,
+				1,
+				0,
+				NULL);
+   if (!NT_SUCCESS(Status))
+     {
+	printf("(lpcsrv.exe) Failed to accept connection (Status = 0x%08lX)\n", Status);
+	return EXIT_FAILURE;
+     }   
+   
+   printf("(lpcsrv.exe) Completing connection\n");
+   Status = NtCompleteConnectPort(PortHandle);
+   if (!NT_SUCCESS(Status))
+     {
+	printf("(lpcsrv.exe) Failed to complete connection (Status = 0x%08lX)\n", Status);
+	return EXIT_FAILURE;
+     }
+   
+   for(;;)
+     {
+	LPC_MAX_MESSAGE Request;
+	
+	Status = NtReplyWaitReceivePort(PortHandle,
+					0,
+					NULL,
+					&Request.Header);
+	if (!NT_SUCCESS(Status))
+	  {
+	     printf("(lpcsrv.exe) Failed to receive request (Status = 0x%08lX)\n", Status);
+             return EXIT_FAILURE;
+	  }
+	
+	printf("(lpcsrv.exe) Message contents are <%s>\n", 
+	       Request.Data);
+     }
+   return EXIT_SUCCESS;
+}
+
+
+/* EOF */

reactos/apps/tests/lpc/makefile

@@ -0,0 +1,43 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+SRV_OBJECTS= lpcsrv.o
+CLT_OBJECTS= lpcclt.o
+
+PROGS= lpcsrv.exe lpcclt.exe
+
+BASE_CFLAGS = -I../../include
+LIBS = ../../lib/crtdll/crtdll.a ../../lib/kernel32/kernel32.a \
+       ../../lib/ntdll/ntdll.a
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) lpcsrv.o lpcsrv.exe lpcsrv.sym lpcclt.o lpcclt.exe lpcsrv.sym
+	
+.phony: clean
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+lpcsrv.exe: $(SRV_OBJECTS) $(LIBS)
+	$(CC) $(SRV_OBJECTS) $(LIBS) -o lpcsrv.exe
+	$(NM) --numeric-sort lpcsrv.exe > lpcsrv.sym
+
+lpcclt.exe: $(CLT_OBJECTS) $(LIBS)
+	$(CC) $(CLT_OBJECTS) $(LIBS) -o lpcclt.exe
+	$(NM) --numeric-sort lpcclt.exe > lpcclt.sym
+
+
+include ../../rules.mak

reactos/apps/tests/mstest/Makefile

@@ -0,0 +1,42 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+SRV_OBJECTS = msserver.o
+CLT_OBJECTS = msclient.o
+
+PROGS = msserver.exe msclient.exe
+
+BASE_CFLAGS = -I../../include
+LIBS = ../../lib/crtdll/crtdll.a ../../lib/kernel32/kernel32.a
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) *.o *.exe *.sym
+
+.phony: clean
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+msserver.exe: $(SRV_OBJECTS) $(LIBS)
+	$(CC) $(SRV_OBJECTS) $(LIBS) -o msserver.exe
+	$(NM) --numeric-sort msserver.exe > msserver.sym
+
+msclient.exe: $(CLT_OBJECTS) $(LIBS)
+	$(CC) $(CLT_OBJECTS) $(LIBS) -o msclient.exe
+	$(NM) --numeric-sort msclient.exe > msclient.sym
+
+
+include ../../rules.mak

reactos/apps/tests/mstest/msclient.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <windows.h>
+#include <tchar.h>
+
+#define BUFSIZE 1024
+#define MAILSLOT_TIMEOUT 1000
+
+
+int main(int argc, char *argv[])
+{
+   HANDLE hMailslot;
+   LPSTR lpszMailslotName = "\\\\.\\MAILSLOT\\mymailslot";
+   LPSTR lpszTestMessage = "Mailslot test message!";
+   DWORD cbLength, cbWritten;
+   
+   hMailslot = CreateFile(lpszMailslotName,
+			  GENERIC_WRITE,
+			  FILE_SHARE_READ,
+			  (LPSECURITY_ATTRIBUTES)NULL,
+			  OPEN_EXISTING,
+			  FILE_ATTRIBUTE_NORMAL,
+			  (HANDLE)NULL);
+   printf("hMailslot %x\n", (DWORD)hMailslot);
+   if (hMailslot == INVALID_HANDLE_VALUE)
+     {
+	printf("CreateFile() failed\n");
+	return 0;
+     }
+   
+   cbLength = (ULONG)strlen(lpszTestMessage)+1;
+   
+   WriteFile(hMailslot,
+	     lpszTestMessage,
+	     cbLength,
+	     &cbWritten,
+	     NULL);
+   
+   CloseHandle(hMailslot);
+   
+   return 0;
+}
+
+/* EOF */
+

reactos/apps/tests/mstest/msserver.c

@@ -0,0 +1,40 @@
+
+
+#include <windows.h>
+
+
+int main(int argc, char *argv[])
+{
+   HANDLE hMailslot;
+   CHAR chBuf[512];
+   BOOL fResult;
+   DWORD cbRead;
+   LPTSTR lpszMailslotName = "\\\\.\\mailslot\\mymailslot";
+
+   hMailslot = CreateMailslot(lpszMailslotName,
+			      512,
+			      MAILSLOT_WAIT_FOREVER,
+			      NULL);
+for (;;)
+{
+   fResult = ReadFile(hMailslot,
+		      chBuf,
+		      512,
+		      &cbRead,
+		      NULL);
+   if (fResult == FALSE)
+     {
+	printf("ReadFile() failed!\n");
+	CloseHandle(hMailslot);
+	return 0;
+     }
+
+   printf("Data read: %s\n", chBuf);
+}
+
+   CloseHandle(hMailslot);
+
+   return 0;
+}
+
+/* EOF */

reactos/apps/tests/nptest/Makefile

@@ -0,0 +1,42 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+SRV_OBJECTS = npserver.o
+CLT_OBJECTS = npclient.o
+
+PROGS = npserver.exe npclient.exe
+
+BASE_CFLAGS = -I../../include
+LIBS = ../../lib/crtdll/crtdll.a ../../lib/kernel32/kernel32.a
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) *.o *.exe *.sym
+
+.phony: clean
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+npserver.exe: $(SRV_OBJECTS) $(LIBS)
+	$(CC) $(SRV_OBJECTS) $(LIBS) -o npserver.exe
+	$(NM) --numeric-sort npserver.exe > npserver.sym
+
+npclient.exe: $(CLT_OBJECTS) $(LIBS)
+	$(CC) $(CLT_OBJECTS) $(LIBS) -o npclient.exe
+	$(NM) --numeric-sort npclient.exe > npclient.sym
+
+
+include ../../rules.mak

reactos/apps/tests/nptest/npclient.c

@@ -0,0 +1,100 @@
+#include <windows.h>
+
+VOID MyErrExit(LPTSTR Message)
+{
+//	MessageBox(NULL, Message, NULL, MB_OK);
+   puts(Message);
+   ExitProcess(0);
+}
+
+int main(int argc, char *argv[])
+{
+   HANDLE hPipe;
+   LPVOID lpvMessage;
+   CHAR chBuf[512];
+   BOOL fSuccess;
+   DWORD cbRead, cbWritten, dwMode;
+   LPTSTR lpszPipename = "\\\\.\\pipe\\mynamedpipe";
+
+// Try to open a named pipe; wait for it, if necessary.
+
+   while (1)
+   {
+      hPipe = CreateFile(
+         lpszPipename,   // pipe name
+         GENERIC_READ |  // read and write access
+         GENERIC_WRITE,
+         0,              // no sharing
+         NULL,           // no security attributes
+         OPEN_EXISTING,  // opens existing pipe
+         0,              // default attributes
+         NULL);          // no template file
+
+   // Break if the pipe handle is valid.
+
+      if (hPipe != INVALID_HANDLE_VALUE)
+         break;
+
+      // Exit if an error other than ERROR_PIPE_BUSY occurs.
+
+      if (GetLastError() != ERROR_PIPE_BUSY)
+         MyErrExit("Could not open pipe");
+
+      // All pipe instances are busy, so wait for 20 seconds.
+
+      if (! WaitNamedPipe(lpszPipename, 20000) )
+         MyErrExit("Could not open pipe");
+   }
+
+// The pipe connected; change to message-read mode.
+
+   dwMode = PIPE_READMODE_MESSAGE;
+   fSuccess = SetNamedPipeHandleState(
+      hPipe,    // pipe handle
+      &dwMode,  // new pipe mode
+      NULL,     // don't set maximum bytes
+      NULL);    // don't set maximum time
+   if (!fSuccess)
+      MyErrExit("SetNamedPipeHandleState");
+
+// Send a message to the pipe server.
+
+   lpvMessage = (argc > 1) ? argv[1] : "default message";
+
+   fSuccess = WriteFile(
+      hPipe,                  // pipe handle
+      lpvMessage,             // message
+      strlen(lpvMessage) + 1, // message length
+      &cbWritten,             // bytes written
+      NULL);                  // not overlapped
+   if (! fSuccess)
+      MyErrExit("WriteFile");
+
+   do
+   {
+   // Read from the pipe.
+
+      fSuccess = ReadFile(
+         hPipe,    // pipe handle
+         chBuf,    // buffer to receive reply
+         512,      // size of buffer
+         &cbRead,  // number of bytes read
+         NULL);    // not overlapped
+
+      if (! fSuccess && GetLastError() != ERROR_MORE_DATA)
+         break;
+
+      // Reply from the pipe is written to STDOUT.
+
+      if (! WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),
+         chBuf, cbRead, &cbWritten, NULL))
+      {
+         break;
+      }
+
+   } while (! fSuccess);  // repeat loop if ERROR_MORE_DATA
+
+   CloseHandle(hPipe);
+
+   return 0;
+}

reactos/apps/tests/nptest/npserver.c

@@ -0,0 +1,120 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <windows.h>
+#include <tchar.h>
+
+#define BUFSIZE 1024
+#define PIPE_TIMEOUT 1000
+
+VOID InstanceThread (LPVOID);
+
+VOID
+GetAnswerToRequest(LPTSTR lpRequest,
+		   LPTSTR lpReply,
+		   LPDWORD lpcbReplyBytes)
+{
+}
+
+VOID MyErrExit(LPTSTR Message)
+{
+//	MessageBox(NULL, Message, NULL, MB_OK);
+   puts(Message);
+   ExitProcess(0);
+}
+
+
+
+
+int xx = 0;
+
+int main(int argc, char *argv[])
+{
+   BOOL fConnected;
+   DWORD dwThreadId;
+   HANDLE hPipe, hThread;
+   LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe");
+
+//   for (;;)
+//     {
+	hPipe = CreateNamedPipe(lpszPipename,
+				PIPE_ACCESS_DUPLEX,
+				PIPE_TYPE_MESSAGE |
+				PIPE_READMODE_MESSAGE |
+				PIPE_WAIT,
+				PIPE_UNLIMITED_INSTANCES,
+				BUFSIZE,
+				BUFSIZE,
+				PIPE_TIMEOUT,
+				NULL);
+	if (hPipe == INVALID_HANDLE_VALUE)
+	  {
+	     printf("CreateNamedPipe() failed\n");
+	     return 0;
+	  }
+
+	fConnected = ConnectNamedPipe(hPipe,
+				      NULL) ? TRUE : (GetLastError () ==
+					    ERROR_PIPE_CONNECTED);
+	if (fConnected)
+	  {
+	     printf("Pipe connected!\n");
+
+	     DisconnectNamedPipe(hPipe);
+
+#if 0
+	     hThread = CreateThread(NULL,
+				    0,
+				    (LPTHREAD_START_ROUTINE) InstanceThread,
+				    (LPVOID) hPipe,
+				    0,
+				    &dwThreadId);
+	     if (hThread == NULL)
+	       MyErrExit("CreateThread");
+#endif
+	  }
+	else
+	  {
+//	     CloseHandle(hPipe);
+	  }
+//     }
+
+   CloseHandle(hPipe);
+
+   return 0;
+}
+
+VOID InstanceThread (LPVOID lpvParam)
+{
+   CHAR chRequest[BUFSIZE];
+   CHAR chReply[BUFSIZE];
+   DWORD cbBytesRead, cbReplyBytes, cbWritten;
+   BOOL fSuccess;
+   HANDLE hPipe;
+   
+   hPipe = (HANDLE)lpvParam;
+   while (1)
+     {
+	fSuccess = ReadFile(hPipe,
+			    chRequest,
+			    BUFSIZE,
+			    &cbBytesRead,
+			    NULL);
+	if (!fSuccess || cbBytesRead == 0)
+	  break;
+
+	GetAnswerToRequest(chRequest, chReply, &cbReplyBytes);
+
+	fSuccess = WriteFile(hPipe,
+			     chReply,
+			     cbReplyBytes,
+			     &cbWritten,
+			     NULL);
+	if (!fSuccess || cbReplyBytes != cbWritten)
+	  break;
+    }
+
+   FlushFileBuffers(hPipe);
+   DisconnectNamedPipe(hPipe);
+   CloseHandle(hPipe);
+}

reactos/apps/tests/pteb/Makefile

@@ -0,0 +1,31 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+OBJECTS = pteb.o
+PROGS = pteb.exe
+LIBS = 
+CLEAN_FILES = pteb.o pteb.exe
+
+all: pteb.exe
+
+clean: 
+	- $(RM) $(CLEAN_FILES)
+
+.phony: clean 
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+pteb.exe: $(OBJECTS)
+	$(CC) $(OBJECTS) -o pteb.exe
+
+include ../../rules.mak

reactos/apps/tests/pteb/pteb.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+
+int main(int argc, char* argv[])
+{  
+   int x;
+   
+   printf("TEB dumpper\n");
+   __asm__("movl %%fs:0x18, %0\n\t"
+	   : "=a" (x)
+	   : /* no inputs */);
+   printf("fs[0x18] %x\n", x);
+   return(0);
+}

reactos/apps/tests/regtest/makefile

@@ -0,0 +1,36 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+OBJECTS= regtest.o
+PROGS= regtest.exe
+LIBS= ../../lib/kernel32/kernel32.a ../../lib/ntdll/ntdll.a \
+      ../../lib/advapi32/advapi32.a
+
+BASE_CFLAGS = -I../../include
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) *.o *.exe *.sym
+
+.phony: clean
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+regtest.exe: $(OBJECTS) $(LIBS)
+	$(CC) $(OBJECTS) $(LIBS) -o regtest.exe
+	$(NM) --numeric-sort regtest.exe > regtest.sym
+
+include ../../rules.mak

reactos/apps/tests/regtest/regtest.c

@@ -0,0 +1,715 @@
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <windows.h>
+#include <ddk/ntddk.h>
+
+HANDLE OutputHandle;
+HANDLE InputHandle;
+
+void dprintf(char* fmt, ...)
+{
+   va_list args;
+   char buffer[255];
+
+   va_start(args,fmt);
+   vsprintf(buffer,fmt,args);
+   WriteConsoleA(OutputHandle, buffer, strlen(buffer), NULL, NULL);
+   va_end(args);
+}
+
+void do_enumeratekey(PWSTR Name)
+{
+ ULONG Index,Length,i;
+ KEY_BASIC_INFORMATION KeyInformation[5];
+ NTSTATUS Status;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ HANDLE hKey1;
+ UNICODE_STRING KeyName;
+
+  RtlInitUnicodeString(&KeyName, Name);
+  InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
+				, NULL, NULL);
+  Status=NtOpenKey( &hKey1, MAXIMUM_ALLOWED, &ObjectAttributes);
+    dprintf("NtEnumerateKey : \n");
+    Index=0;
+    while(Status == STATUS_SUCCESS)
+    {
+      Status=NtEnumerateKey(hKey1,Index++,KeyBasicInformation
+		,&KeyInformation[0], sizeof(KeyInformation)
+		,&Length);
+      if(Status== STATUS_SUCCESS)
+	{
+        dprintf("\tSubKey Name = ");
+	  for (i=0;i<KeyInformation[0].NameLength/2;i++)
+		dprintf("%C",KeyInformation[0].Name[i]);
+        dprintf("\n");
+	}
+    }
+  NtClose(hKey1);
+}
+
+void test1(void)
+{
+ HKEY hKey = NULL,hKey1;
+ OBJECT_ATTRIBUTES ObjectAttributes; 
+ NTSTATUS Status; 
+ UNICODE_STRING KeyName;
+ ULONG Index,Length,i;
+ KEY_BASIC_INFORMATION KeyInformation[5];
+ KEY_VALUE_FULL_INFORMATION KeyValueInformation[5];
+
+  dprintf("NtOpenKey \\Registry : ");
+  RtlInitUnicodeString(&KeyName, L"\\Registry");
+  InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+  Status=NtOpenKey( &hKey1, MAXIMUM_ALLOWED, &ObjectAttributes);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  if(Status==0)
+  {
+    dprintf("NtQueryKey : ");
+    Status=NtQueryKey(hKey1,KeyBasicInformation
+		,&KeyInformation[0], sizeof(KeyInformation)
+		,&Length);
+    dprintf("\t\t\t\t\tStatus =%x\n",Status);
+    if (Status == STATUS_SUCCESS)
+    {
+        dprintf("\tKey Name = ");
+	  for (i=0;i<KeyInformation[0].NameLength/2;i++)
+		dprintf("%C",KeyInformation[0].Name[i]);
+        dprintf("\n");
+    }
+    dprintf("NtEnumerateKey : \n");
+    Index=0;
+    while(Status == STATUS_SUCCESS)
+    {
+      Status=NtEnumerateKey(hKey1,Index++,KeyBasicInformation
+		,&KeyInformation[0], sizeof(KeyInformation)
+		,&Length);
+      if(Status== STATUS_SUCCESS)
+	{
+        dprintf("\tSubKey Name = ");
+	  for (i=0;i<KeyInformation[0].NameLength/2;i++)
+		dprintf("%C",KeyInformation[0].Name[i]);
+        dprintf("\n");
+	}
+    }
+    dprintf("NtClose : ");
+    Status = NtClose( hKey1 );
+    dprintf("\t\t\t\t\tStatus =%x\n",Status);
+  }
+  NtClose(hKey);
+
+  dprintf("NtOpenKey \\Registry\\Machine : ");
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine");
+  InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+  Status=NtOpenKey( &hKey1, MAXIMUM_ALLOWED, &ObjectAttributes);
+  dprintf("\t\t\tStatus =%x\n",Status);
+
+  dprintf("NtOpenKey System\\Setup : ");
+  RtlInitUnicodeString(&KeyName, L"System\\Setup");
+  InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
+				, hKey1 , NULL);
+  Status = NtOpenKey ( &hKey, KEY_READ , &ObjectAttributes);
+  dprintf("\t\t\tStatus =%x\n",Status);
+  if(Status==0)
+  {
+    dprintf("NtQueryValueKey : ");
+    RtlInitUnicodeString(&KeyName, L"CmdLine");
+    Status=NtQueryValueKey(hKey,&KeyName,KeyValueFullInformation
+		,&KeyValueInformation[0], sizeof(KeyValueInformation)
+		,&Length);
+    dprintf("\t\t\t\tStatus =%x\n",Status);
+    if (Status == STATUS_SUCCESS)
+    {
+        dprintf("\tValue:DO=%d, DL=%d, NL=%d, Name = "
+		,KeyValueInformation[0].DataOffset
+		,KeyValueInformation[0].DataLength
+		,KeyValueInformation[0].NameLength);
+	  for (i=0;i<10 && i<KeyValueInformation[0].NameLength/2;i++)
+		dprintf("%C",KeyValueInformation[0].Name[i]);
+        dprintf("\n");
+        dprintf("\t\tType = %d\n",KeyValueInformation[0].Type);
+	  if (KeyValueInformation[0].Type == REG_SZ)
+          dprintf("\t\tValue = %S\n",KeyValueInformation[0].Name+1
+    					+KeyValueInformation[0].NameLength/2);
+    }
+    dprintf("NtEnumerateValueKey : \n");
+    Index=0;
+    while(Status == STATUS_SUCCESS)
+    {
+      Status=NtEnumerateValueKey(hKey,Index++,KeyValueFullInformation
+		,&KeyValueInformation[0], sizeof(KeyValueInformation)
+		,&Length);
+      if(Status== STATUS_SUCCESS)
+	{
+        dprintf("\tValue:DO=%d, DL=%d, NL=%d, Name = "
+		,KeyValueInformation[0].DataOffset
+		,KeyValueInformation[0].DataLength
+		,KeyValueInformation[0].NameLength);
+	  for (i=0;i<KeyValueInformation[0].NameLength/2;i++)
+		dprintf("%C",KeyValueInformation[0].Name[i]);
+        dprintf(", Type = %d\n",KeyValueInformation[0].Type);
+	  if (KeyValueInformation[0].Type == REG_SZ)
+          dprintf("\t\tValue = %S\n",((char*)&KeyValueInformation[0]
+    					+KeyValueInformation[0].DataOffset));
+	}
+    }
+    dprintf("NtClose : ");
+    Status = NtClose( hKey );
+    dprintf("\t\t\t\t\tStatus =%x\n",Status);
+  }
+  NtClose( hKey1 );
+}
+
+void test2(void)
+{
+ HKEY hKey,hKey1;
+ OBJECT_ATTRIBUTES ObjectAttributes; 
+ UNICODE_STRING KeyName,ValueName;
+ NTSTATUS Status; 
+ KEY_VALUE_FULL_INFORMATION KeyValueInformation[5];
+ ULONG Index,Length,i;
+ char Buffer[10];
+ DWORD Result;
+  dprintf("NtCreateKey volatile: \n");
+  dprintf("  \\Registry\\Machine\\Software\\test2reactos: ");
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test2reactos");
+  InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
+				, NULL, NULL);
+  Status = NtCreateKey ( &hKey, KEY_ALL_ACCESS , &ObjectAttributes
+		,0,NULL,REG_OPTION_VOLATILE,NULL);
+  dprintf("\t\tStatus=%x\n",Status);
+  NtClose(hKey);
+  do_enumeratekey(L"\\Registry\\Machine\\Software");
+  dprintf("  ...\\test2 :");
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test2reactos\\test2");
+  InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
+				, NULL, NULL);
+  Status = NtCreateKey ( &hKey1, KEY_ALL_ACCESS , &ObjectAttributes
+		,0,NULL,REG_OPTION_VOLATILE,NULL);
+  dprintf("\t\t\t\t\tStatus=%x\n",Status);
+  dprintf("  ...\\TestVolatile :");
+  RtlInitUnicodeString(&KeyName, L"TestVolatile");
+  InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
+				, hKey1, NULL);
+  Status = NtCreateKey ( &hKey, KEY_ALL_ACCESS , &ObjectAttributes
+		,0,NULL,REG_OPTION_VOLATILE,NULL);
+  dprintf("\t\t\t\tStatus=%x\n",Status);
+  NtClose(hKey1);
+  RtlInitUnicodeString(&ValueName, L"TestREG_SZ");
+  dprintf("NtSetValueKey reg_sz: ");
+  Status=NtSetValueKey(hKey,&ValueName,0,REG_SZ,(PVOID)L"Test Reg_sz",24);
+  dprintf("\t\t\t\tStatus=%x\n",Status);
+  RtlInitUnicodeString(&ValueName, L"TestDWORD");
+  dprintf("NtSetValueKey reg_dword: ");
+  Status=NtSetValueKey(hKey,&ValueName,0,REG_DWORD,(PVOID)"reac",4);
+  dprintf("\t\t\tStatus=%x\n",Status);
+  NtClose(hKey);
+  dprintf("NtOpenKey \\Registry\\Machine\\Software\\test2reactos\\test2\\TestVolatile : ");
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test2reactos\\test2\\TestVolatile");
+  InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+  Status=NtOpenKey( &hKey, MAXIMUM_ALLOWED, &ObjectAttributes);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  if(Status==0)
+  {
+    dprintf("NtEnumerateValueKey : \n");
+    Index=0;
+    while(Status == STATUS_SUCCESS)
+    {
+      Status=NtEnumerateValueKey(hKey,Index++,KeyValueFullInformation
+		,&KeyValueInformation[0], sizeof(KeyValueInformation)
+		,&Length);
+      if(Status== STATUS_SUCCESS)
+	{
+        dprintf("\tValue:DO=%d, DL=%d, NL=%d, Name = "
+		,KeyValueInformation[0].DataOffset
+		,KeyValueInformation[0].DataLength
+		,KeyValueInformation[0].NameLength);
+	  for (i=0;i<KeyValueInformation[0].NameLength/2;i++)
+		dprintf("%C",KeyValueInformation[0].Name[i]);
+        dprintf(", Type = %d\n",KeyValueInformation[0].Type);
+	  if (KeyValueInformation[0].Type == REG_SZ)
+          dprintf("\t\tValue = %S\n",((char*)&KeyValueInformation[0]
+    					+KeyValueInformation[0].DataOffset));
+	}
+    }
+  }
+  NtClose(hKey);
+  dprintf("delete \\Registry\\Machine\\software\\test2reactos ?");
+  ReadConsoleA(InputHandle, Buffer, 3, &Result, NULL) ;
+  if (Buffer[0] != 'y' && Buffer[0] != 'Y') return;
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test2reactos\\test2\\TestVolatile");
+  InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+  dprintf("NtOpenKey : ");
+  Status=NtOpenKey( &hKey, KEY_ALL_ACCESS, &ObjectAttributes);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  dprintf("NtDeleteKey : ");
+  Status=NtDeleteKey(hKey);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  NtClose(hKey);
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test2reactos\\test2");
+  InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+  dprintf("NtOpenKey : ");
+  Status=NtOpenKey( &hKey, KEY_ALL_ACCESS, &ObjectAttributes);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  dprintf("NtDeleteKey : ");
+  Status=NtDeleteKey(hKey);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  NtClose(hKey);
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test2reactos");
+  InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+  dprintf("NtOpenKey : ");
+  Status=NtOpenKey( &hKey, KEY_ALL_ACCESS, &ObjectAttributes);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  dprintf("NtDeleteKey : ");
+  Status=NtDeleteKey(hKey);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  NtClose(hKey);
+}
+
+void test3(void)
+{
+ HKEY hKey,hKey1;
+ OBJECT_ATTRIBUTES ObjectAttributes; 
+ UNICODE_STRING KeyName,ValueName;
+ NTSTATUS Status; 
+ KEY_VALUE_FULL_INFORMATION KeyValueInformation[5];
+ ULONG Index,Length,i;
+ char Buffer[10];
+ DWORD Result;
+  dprintf("NtCreateKey non volatile: \n");
+  dprintf("  \\Registry\\Machine\\Software\\test3reactos: ");
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test3reactos");
+  InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
+				, NULL, NULL);
+  Status = NtCreateKey ( &hKey, KEY_ALL_ACCESS , &ObjectAttributes
+		,0,NULL,REG_OPTION_NON_VOLATILE,NULL);
+  dprintf("\t\tStatus=%x\n",Status);
+  NtClose(hKey);
+  do_enumeratekey(L"\\Registry\\Machine\\Software");
+  dprintf("NtOpenKey: ");
+  Status=NtOpenKey( &hKey, MAXIMUM_ALLOWED, &ObjectAttributes);
+  dprintf("\t\tStatus=%x\n",Status);
+  NtClose(hKey);
+  dprintf("  ...\\test3 :");
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test3reactos\\test3");
+  InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
+				, NULL, NULL);
+  Status = NtCreateKey ( &hKey, KEY_ALL_ACCESS , &ObjectAttributes
+		,0,NULL,REG_OPTION_NON_VOLATILE,NULL);
+  dprintf("\t\t\t\t\tStatus=%x\n",Status);
+  dprintf("NtOpenKey: ");
+  Status=NtOpenKey( &hKey1, MAXIMUM_ALLOWED, &ObjectAttributes);
+  dprintf("\t\tStatus=%x\n",Status);
+  NtClose(hKey);
+  dprintf("  ...\\testNonVolatile :");
+  RtlInitUnicodeString(&KeyName, L"TestNonVolatile");
+  InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
+				, hKey1, NULL);
+  Status = NtCreateKey ( &hKey, KEY_ALL_ACCESS , &ObjectAttributes
+		,0,NULL,REG_OPTION_NON_VOLATILE,NULL);
+  dprintf("\t\t\t\tStatus=%x\n",Status);
+  NtClose(hKey1);
+  RtlInitUnicodeString(&ValueName, L"TestREG_SZ");
+  dprintf("NtSetValueKey reg_sz: ");
+  Status=NtSetValueKey(hKey,&ValueName,0,REG_SZ,(PVOID)L"Test Reg_sz",24);
+  dprintf("\t\t\t\tStatus=%x\n",Status);
+  RtlInitUnicodeString(&ValueName, L"TestDWORD");
+  dprintf("NtSetValueKey reg_dword: ");
+  Status=NtSetValueKey(hKey,&ValueName,0,REG_DWORD,(PVOID)"reac",4);
+  dprintf("\t\t\tStatus=%x\n",Status);
+  NtClose(hKey);
+  dprintf("NtOpenKey \\Registry\\Machine\\Software\\test3reactos\\test3\\testNonVolatile : ");
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test3reactos\\test3\\testNonVolatile");
+  InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+  Status=NtOpenKey( &hKey, MAXIMUM_ALLOWED, &ObjectAttributes);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  if(Status==0)
+  {
+    dprintf("NtEnumerateValueKey : \n");
+    Index=0;
+    while(Status == STATUS_SUCCESS)
+    {
+      Status=NtEnumerateValueKey(hKey,Index++,KeyValueFullInformation
+		,&KeyValueInformation[0], sizeof(KeyValueInformation)
+		,&Length);
+      if(Status== STATUS_SUCCESS)
+	{
+        dprintf("\tValue:DO=%d, DL=%d, NL=%d, Name = "
+		,KeyValueInformation[0].DataOffset
+		,KeyValueInformation[0].DataLength
+		,KeyValueInformation[0].NameLength);
+	  for (i=0;i<KeyValueInformation[0].NameLength/2;i++)
+		dprintf("%C",KeyValueInformation[0].Name[i]);
+        dprintf(", Type = %d\n",KeyValueInformation[0].Type);
+	  if (KeyValueInformation[0].Type == REG_SZ)
+          dprintf("\t\tValue = %S\n",((char*)&KeyValueInformation[0]
+    					+KeyValueInformation[0].DataOffset));
+	}
+    }
+  }
+  NtClose(hKey);
+  dprintf("delete \\Registry\\Machine\\software\\test3reactos ?");
+  ReadConsoleA(InputHandle, Buffer, 3, &Result, NULL) ;
+  if (Buffer[0] != 'y' && Buffer[0] != 'Y') return;
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test3reactos\\test3\\testNonvolatile");
+  InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+  dprintf("NtOpenKey : ");
+  Status=NtOpenKey( &hKey, KEY_ALL_ACCESS, &ObjectAttributes);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  dprintf("NtDeleteKey : ");
+  Status=NtDeleteKey(hKey);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test3reactos\\test3");
+  InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+  dprintf("NtOpenKey : ");
+  Status=NtOpenKey( &hKey, KEY_ALL_ACCESS, &ObjectAttributes);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  dprintf("NtDeleteKey : ");
+  Status=NtDeleteKey(hKey);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  NtClose(hKey);
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\test3reactos");
+  InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+  dprintf("NtOpenKey : ");
+  Status=NtOpenKey( &hKey, KEY_ALL_ACCESS, &ObjectAttributes);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  dprintf("NtDeleteKey : ");
+  Status=NtDeleteKey(hKey);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  NtClose(hKey);
+}
+
+void test4(void)
+{
+ HKEY hKey = NULL,hKey1;
+ DWORD dwDisposition;
+ DWORD dwError;
+ DWORD  RegDataType, RegDataSize;
+ BOOL GlobalFifoEnable;
+ HKEY hPortKey;
+ DWORD RegDisposition;
+ WCHAR szClass[260];
+ DWORD cchClass;	
+ DWORD cSubKeys;	
+ DWORD cchMaxSubkey;	
+ DWORD cchMaxClass;	
+ DWORD cValues;	
+ DWORD cchMaxValueName;	
+ DWORD cbMaxValueData;	
+ DWORD cbSecurityDescriptor;	
+ FILETIME ftLastWriteTime;	
+ SYSTEMTIME LastWriteTime;
+
+   dprintf ("RegOpenKeyExW HKLM\\System\\Setup: ");
+   dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
+                           L"System\\Setup",
+                           0,
+                           KEY_ALL_ACCESS,
+                           &hKey1); 
+    dprintf("\t\tdwError =%x\n",dwError);
+   if (dwError == ERROR_SUCCESS)
+   {
+     dprintf("RegQueryInfoKeyW: ");
+     cchClass=260;
+     dwError = RegQueryInfoKeyW(hKey1
+	, szClass, &cchClass, NULL, &cSubKeys
+	, &cchMaxSubkey, &cchMaxClass, &cValues, &cchMaxValueName
+	, &cbMaxValueData, &cbSecurityDescriptor, &ftLastWriteTime);
+     dprintf ("\t\t\t\tdwError %x\n", dwError);
+     FileTimeToSystemTime(&ftLastWriteTime,&LastWriteTime);
+     dprintf ("\tnb of subkeys=%d,last write : %d/%d/%d %d:%02.2d'%02.2d''%03.3d\n",cSubKeys
+		,LastWriteTime.wMonth
+		,LastWriteTime.wDay
+		,LastWriteTime.wYear
+		,LastWriteTime.wHour
+		,LastWriteTime.wMinute
+		,LastWriteTime.wSecond
+		,LastWriteTime.wMilliseconds
+		);
+   }
+
+
+   dprintf ("RegOpenKeyExW: ");
+   dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
+                           L"System\\ControlSet001\\Services\\Serial",
+                           0,
+                           KEY_ALL_ACCESS,
+                           &hKey); 
+   dprintf ("\t\t\t\t\tdwError %x\n", dwError);
+   RegDataSize = sizeof(GlobalFifoEnable);
+   if (dwError == ERROR_SUCCESS)
+   {
+     dprintf ("RegQueryValueExW: ");
+     dwError = RegQueryValueExW(hKey,
+                        L"ForceFifoEnable",
+                        NULL,
+                        &RegDataType,
+                        (PBYTE)&GlobalFifoEnable,
+                        &RegDataSize);
+    dprintf("\t\t\t\tdwError =%x\n",dwError);
+    if (dwError == 0)
+    {
+        dprintf("\tValue:DT=%d, DS=%d, Value=%d\n"
+		,RegDataType
+		,RegDataSize
+		,GlobalFifoEnable);
+    }
+   }
+   dprintf ("RegCreateKeyExW: ");
+   dwError = RegCreateKeyExW(hKey,
+                         L"Parameters\\Serial001",
+                         0,
+                         NULL,
+                         0,
+                         KEY_ALL_ACCESS,
+                         NULL,
+                         &hPortKey,
+                         &RegDisposition
+                        );
+   dprintf ("\t\t\t\tdwError %x\n", dwError);
+
+   dprintf ("RegCreateKeyExW: ");
+   dwError = RegCreateKeyExW (HKEY_LOCAL_MACHINE,
+                              L"Software\\test4reactos\\test",
+                              0,
+                              NULL,
+                              REG_OPTION_NON_VOLATILE,
+                              KEY_ALL_ACCESS,
+                              NULL,
+                              &hKey,
+                              &dwDisposition);
+
+   dprintf ("\t\t\t\tdwError %x ", dwError);
+   dprintf ("dwDisposition %x\n", dwDisposition);
+   if (dwError == ERROR_SUCCESS)
+   {
+     dprintf ("RegSetValueExW: ");
+     dwError = RegSetValueExW (hKey,
+                             L"TestValue",
+                             0,
+                             REG_SZ,
+                             (BYTE*)L"TestString",
+                             20);
+
+     dprintf ("\t\t\t\tdwError %x\n", dwError);
+     dprintf ("RegCloseKey: ");
+     dwError = RegCloseKey (hKey);
+     dprintf ("\t\t\t\t\tdwError %x\n", dwError);
+   }
+   dprintf ("\n\n");
+
+   hKey = NULL;
+
+   dprintf ("RegCreateKeyExW: ");
+   dwError = RegCreateKeyExW (HKEY_LOCAL_MACHINE,
+                              L"software\\Test",
+                              0,
+                              NULL,
+                              REG_OPTION_VOLATILE,
+                              KEY_ALL_ACCESS,
+                              NULL,
+                              &hKey,
+                              &dwDisposition);
+
+   dprintf ("\t\t\t\tdwError %x ", dwError);
+   dprintf ("dwDisposition %x\n", dwDisposition);
+
+
+   if (dwError == ERROR_SUCCESS)
+   {
+     dprintf("RegQueryInfoKeyW: ");
+     cchClass=260;
+     dwError = RegQueryInfoKeyW(hKey
+	, szClass, &cchClass, NULL, &cSubKeys
+	, &cchMaxSubkey, &cchMaxClass, &cValues, &cchMaxValueName
+	, &cbMaxValueData, &cbSecurityDescriptor, &ftLastWriteTime);
+     dprintf ("\t\t\t\tdwError %x\n", dwError);
+     FileTimeToSystemTime(&ftLastWriteTime,&LastWriteTime);
+     dprintf ("\tnb of subkeys=%d,last write : %d/%d/%d %d:%02.2d'%02.2d''%03.3d\n",cSubKeys
+		,LastWriteTime.wMonth
+		,LastWriteTime.wDay
+		,LastWriteTime.wYear
+		,LastWriteTime.wHour
+		,LastWriteTime.wMinute
+		,LastWriteTime.wSecond
+		,LastWriteTime.wMilliseconds
+		);
+     dprintf ("RegCloseKey: ");
+     dwError = RegCloseKey (hKey);
+     dprintf ("\t\t\t\t\tdwError %x\n", dwError);
+   }
+   dprintf ("\nTests done...\n");
+}
+
+void test5(void)
+{
+ HKEY hKey,hKey1;
+ OBJECT_ATTRIBUTES ObjectAttributes; 
+ UNICODE_STRING KeyName,ValueName;
+ NTSTATUS Status; 
+ KEY_VALUE_FULL_INFORMATION KeyValueInformation[5];
+ ULONG Index,Length,i;
+ char Buffer[10];
+ DWORD Result;
+  dprintf("NtOpenKey : \n");
+  dprintf("  \\Registry\\Machine\\Software\\reactos : ");
+  RtlInitUnicodeString(&KeyName,L"\\Registry\\Machine\\Software\\reactos");
+  InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
+				, NULL, NULL);
+  Status=NtOpenKey( &hKey, KEY_ALL_ACCESS, &ObjectAttributes);
+  dprintf("\t\tStatus=%x\n",Status);
+  dprintf("NtFlushKey : \n");
+  Status = NtFlushKey(hKey);
+  dprintf("\t\tStatus=%x\n",Status);
+  dprintf("NtCloseKey : \n");
+  Status=NtClose(hKey);
+  dprintf("\t\tStatus=%x\n",Status);
+}
+
+void test6(void)
+{
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ UNICODE_STRING KeyName;
+ NTSTATUS Status;
+ LONG dwError;
+ TOKEN_PRIVILEGES NewPrivileges; 
+ HANDLE Token,hKey;
+ LUID Luid; 
+ BOOLEAN bRes;
+  Status=NtOpenProcessToken(GetCurrentProcess()
+	,TOKEN_ADJUST_PRIVILEGES,&Token);
+//	,TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,&Token);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+//  bRes=LookupPrivilegeValueA(NULL,SE_RESTORE_NAME,&Luid);
+//  dprintf("\t\t\t\tbRes =%x\n",bRes);
+  NewPrivileges.PrivilegeCount = 1; 
+  NewPrivileges.Privileges[0].Luid = Luid; 
+//  NewPrivileges.Privileges[0].Luid.u.LowPart=18;
+//  NewPrivileges.Privileges[0].Luid.u.HighPart=0;
+  NewPrivileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; 
+ 
+//  Status = NtAdjustPrivilegesToken( 
+  bRes = AdjustTokenPrivileges( 
+            Token, 
+            FALSE, 
+            &NewPrivileges, 
+            0, 
+            NULL, 
+            NULL 
+            ); 
+  dprintf("\t\t\t\tbRes =%x\n",bRes);
+ 
+//  Status=NtClose(Token); 
+//  dprintf("\t\t\t\tStatus =%x\n",Status);
+
+
+  RtlInitUnicodeString(&KeyName,L"test5");
+  InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
+				, NULL, NULL);
+  Status = NtLoadKey(HKEY_LOCAL_MACHINE,&ObjectAttributes);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+  dwError=RegLoadKey(HKEY_LOCAL_MACHINE,"def"
+		,"test5");
+  dprintf("\t\t\t\tdwError =%x\n",dwError);
+
+  dprintf("NtOpenKey \\Registry\\Machine : ");
+  RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine");
+  InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+  Status=NtOpenKey( &hKey, MAXIMUM_ALLOWED, &ObjectAttributes);
+  dprintf("\t\t\tStatus =%x\n",Status);
+  RtlInitUnicodeString(&KeyName,L"test5");
+  InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
+				, NULL, NULL);
+  Status = NtLoadKey(hKey,&ObjectAttributes);
+  dprintf("\t\t\t\tStatus =%x\n",Status);
+}
+
+int main(int argc, char* argv[])
+{
+ char Buffer[10];
+ DWORD Result;
+
+  AllocConsole();
+  InputHandle = GetStdHandle(STD_INPUT_HANDLE);
+  OutputHandle =  GetStdHandle(STD_OUTPUT_HANDLE);
+  while(1)
+  {
+    dprintf("choose test :\n");
+    dprintf("  0=Exit\n");
+    dprintf("  1=Ntxxx read functions\n");
+    dprintf("  2=Ntxxx write functions : volatile keys\n");
+    dprintf("  3=Ntxxx write functions : non volatile keys\n");
+    dprintf("  4=Regxxx functions\n");
+    dprintf("  5=FlushKey \n");
+    ReadConsoleA(InputHandle, Buffer, 3, &Result, NULL) ;
+    switch (Buffer[0])
+    {
+     case '0':
+      return(0);
+     case '1':
+      test1();
+      break;
+     case '2':
+      test2();
+      break;
+     case '3':
+      test3();
+      break;
+     case '4':
+      test4();
+      break;
+     case '5':
+      test5();
+      break;
+     case '6':
+      test6();
+      break;
+    }
+  }
+  return 0;
+}

reactos/apps/tests/shm/makefile

@@ -0,0 +1,43 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+SRV_OBJECTS= shmsrv.o
+CLT_OBJECTS= shmclt.o
+
+PROGS= shmsrv.exe shmclt.exe
+
+BASE_CFLAGS = -I../../include
+LIBS = ../../lib/crtdll/crtdll.a ../../lib/kernel32/kernel32.a \
+       ../../lib/ntdll/ntdll.a
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) *.o *.exe *.sym
+
+.phony: clean
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+shmsrv.exe: $(SRV_OBJECTS) $(LIBS)
+	$(CC) $(SRV_OBJECTS) $(LIBS) -o shmsrv.exe
+	$(NM) --numeric-sort shmsrv.exe > shmsrv.sym
+
+shmclt.exe: $(CLT_OBJECTS) $(LIBS)
+	$(CC) $(CLT_OBJECTS) $(LIBS) -o shmclt.exe
+	$(NM) --numeric-sort shmsrv.exe > shmclt.sym
+
+
+include ../../rules.mak

reactos/apps/tests/shm/shmclt.c

@@ -0,0 +1,61 @@
+#include <ddk/ntddk.h>
+#include <windows.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+
+HANDLE OutputHandle;
+HANDLE InputHandle;
+
+void debug_printf(char* fmt, ...)
+{
+   va_list args;
+   char buffer[255];
+
+   va_start(args,fmt);
+   vsprintf(buffer,fmt,args);
+   WriteConsoleA(OutputHandle, buffer, strlen(buffer), NULL, NULL);
+   va_end(args);
+}
+
+
+int
+main(int argc, char* argv[])
+{
+   HANDLE Section;
+   PVOID BaseAddress;
+   char buffer[256];
+   
+   printf("Shm test server\n");
+   
+   Section = OpenFileMappingW (
+//		PAGE_EXECUTE_READWRITE, invalid parameter
+		FILE_MAP_WRITE,
+		FALSE,
+		L"TestSection"
+		);
+   if (Section == NULL)
+     {
+	printf("Failed to open section (err=%d)", GetLastError());
+	return 1;
+     }
+   
+   BaseAddress = MapViewOfFile(Section,
+			       FILE_MAP_ALL_ACCESS,
+			       0,
+			       0,
+			       8192);
+   if (BaseAddress == NULL)
+     {
+	printf("Failed to map section (err=%d)\n", GetLastError());
+	return 1;
+     }
+   printf("BaseAddress %x\n", (UINT) BaseAddress);
+   printf("Copying from section\n");
+   strcpy(buffer, BaseAddress);
+   printf("Copyed <%s>\n", buffer);
+   
+//   for(;;);
+	return 0;
+}
+

reactos/apps/tests/shm/shmsrv.c

@@ -0,0 +1,53 @@
+/* $Id: shmsrv.c,v 1.5 2000/06/29 23:35:10 dwelch Exp $
+ *
+ * FILE  : reactos/apps/shm/shmsrv.c
+ * AUTHOR: David Welch
+ */
+#include <ddk/ntddk.h>
+#include <windows.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+
+int main(int argc, char* argv[])
+{
+   HANDLE Section;
+   PVOID BaseAddress;
+   
+   printf("Shm test server\n");
+   
+   Section = CreateFileMappingW (
+			(HANDLE) 0xFFFFFFFF,
+			NULL,
+			PAGE_READWRITE, 
+			0,
+			8192,
+			L"TestSection"
+			);
+   if (Section == NULL)
+     {
+	printf("Failed to create section (err=%d)", GetLastError());
+	return 1;
+     }
+   
+   printf("Mapping view of section\n");
+   BaseAddress = MapViewOfFile(Section,
+			       FILE_MAP_ALL_ACCESS,
+			       0,
+			       0,
+			       8192);
+   printf("BaseAddress %x\n", (UINT) BaseAddress);
+   if (BaseAddress == NULL)
+     {
+	printf("Failed to map section\n");
+     }
+   
+   printf("Copying to section\n");
+   printf("Copying %s\n", GetCommandLineA());
+   strcpy(BaseAddress, GetCommandLineA());
+   
+   Sleep(INFINITE);
+
+   return 0;
+}
+

reactos/apps/tests/test_old/bug2.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+int
+main (void)
+{
+  int i;
+  puts ("This should print \"wow = I\" for I from 0 to 39 inclusive.");
+  for (i = 0; i < 40; i++)
+    printf ("%s = %d\n", "wow", i);
+  return 0;
+}

reactos/apps/tests/test_old/bug3.c

@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <string.h>
+
+int
+main (void)
+{
+  FILE *f;
+  int i;
+  const char filename[] = "/tmp/bug3.test";
+
+  f = fopen(filename, "w+");
+  for (i=0; i<9000; i++)
+    putc ('x', f);
+  fseek (f, 8180L, 0);
+  fwrite ("Where does this text go?", 1, 24, f);
+  fflush (f);
+
+  rewind (f);
+  for (i=0; i<9000; i++)
+    {
+      int j;
+
+      if ((j = getc(f)) != 'x')
+	{
+	  if (i != 8180)
+	    {
+	      printf ("Test FAILED!");
+	      return 1;
+	    }
+	  else
+	    {
+	      char buf[25];
+
+	      buf[0] = j;
+	      fread (buf + 1, 1, 23, f);
+	      buf[24] = '\0';
+	      if (strcmp (buf, "Where does this text go?") != 0)
+		{
+		  printf ("%s\nTest FAILED!\n", buf);
+		  return 1;
+		}
+	      i += 23;
+	    }
+	}
+    }
+
+  fclose(f);
+  remove(filename);
+
+  puts ("Test succeeded.");
+
+  return 0;
+}

reactos/apps/tests/test_old/makefile

@@ -0,0 +1,68 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+PROGS= test-stdio tst-printf tstdiomisc bug2 bug3 \
+       temptest test-fseek test_rdwr testfsd
+
+all: $(PROGS:%=%.exe)
+
+.phony: all
+
+clean:
+	- $(RM) *.o *.exe *.sym
+
+.phony: clean
+
+install: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%.exe): $(FLOPPY_DIR)/apps/%.exe: %.exe
+	$(CP) $*.exe $(FLOPPY_DIR)/apps/$*.exe
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%.exe)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%.exe): ../../$(DIST_DIR)/apps/%.exe: %.exe
+	$(CP) $*.exe ../../$(DIST_DIR)/apps/$*.exe
+
+bug2.exe: bug2.c
+	$(CC) bug2.c -lkernel32 -o bug2.exe
+	$(NM) --numeric-sort bug2.exe > bug2.sym
+
+bug3.exe: bug3.c
+	$(CC) bug3.c -lkernel32 -o bug3.exe
+	$(NM) --numeric-sort bug3.exe > bug3.sym
+
+temptest.exe: temptest.c
+	$(CC) temptest.c -lkernel32 -o temptest.exe
+	$(NM) --numeric-sort temptest.exe > temptest.sym
+
+test-fseek.exe: test-fseek.c
+	$(CC) test-fseek.c -lkernel32 -o test-fseek.exe
+	$(NM) --numeric-sort test-fseek.exe > test-fseek.sym
+
+test-fwrite.exe: test-fwrite.c
+	$(CC) test-fwrite.c -lkernel32 -o test-fwrite.exe
+	$(NM) --numeric-sort test-fwrite.exe > test-fwrite.sym
+
+test_rdwr.exe: test_rdwr.c
+	$(CC) test_rdwr.c -lkernel32 -o test_rdwr.exe
+	$(NM) --numeric-sort test_rdwr.exe > test_rdwr.sym
+
+test-stdio.exe: test-stdio.c
+	$(CC) test-stdio.c -lkernel32 -o test-stdio.exe
+	$(NM) --numeric-sort test-stdio.exe > test-stdio.sym
+
+tst-printf.exe: tst-printf.c
+	$(CC) tst-printf.c -lkernel32 -o tst-printf.exe
+	$(NM) --numeric-sort tst-printf.exe > tst-printf.sym
+
+tstdiomisc.exe: tstdiomisc.c
+	$(CC) tstdiomisc.c -lkernel32 -o tstdiomisc.exe
+	$(NM) --numeric-sort tstdiomisc.exe > tstdiomisc.sym
+
+testfsd.exe: testfsd.c testsuite.c
+	$(CC) testfsd.c testsuite.c -lkernel32 -o testfsd.exe
+	$(NM) --numeric-sort testfsd.exe > testfsd.sym
+
+include ../../rules.mak

reactos/apps/tests/test_old/temptest.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <string.h>
+
+char *files[500];
+
+int
+main (int argc, char *argv[])
+{
+  FILE *fp;
+  int i;
+
+  for (i = 0; i < 500; i++) {
+    files[i] = tempnam (NULL, "file");
+    if (files[i] == NULL) {
+      printf ("tempnam failed\n");
+      exit (1);
+    }
+    printf ("file: %s\n", files[i]);
+    fp = fopen (files[i], "w");
+    fclose (fp);
+  }
+
+  for (i = 0; i < 500; i++)
+    remove (files[i]);
+
+  exit (0);
+}

reactos/apps/tests/test_old/test-fseek.c

@@ -0,0 +1,85 @@
+/* Copyright (C) 1991, 1992, 1996, 1997 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C 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.
+
+   The GNU C 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.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include <stdio.h>
+
+#define TESTFILE "/tmp/test.dat"
+
+int
+main (void)
+{
+  FILE *fp;
+  int i, j;
+
+  puts ("\nFile seek test");
+  fp = fopen (TESTFILE, "w");
+  if (fp == NULL)
+    {
+      perror (TESTFILE);
+      return 1;
+    }
+
+  for (i = 0; i < 256; i++)
+    putc (i, fp);
+  if (freopen (TESTFILE, "r", fp) != fp)
+    {
+      perror ("Cannot open file for reading");
+      return 1;
+    }
+
+  for (i = 1; i <= 255; i++)
+    {
+      printf ("%3d\n", i);
+      fseek (fp, (long) -i, SEEK_END);
+      if ((j = getc (fp)) != 256 - i)
+	{
+	  printf ("SEEK_END failed %d\n", j);
+	  break;
+	}
+      if (fseek (fp, (long) i, SEEK_SET))
+	{
+	  puts ("Cannot SEEK_SET");
+	  break;
+	}
+      if ((j = getc (fp)) != i)
+	{
+	  printf ("SEEK_SET failed %d\n", j);
+	  break;
+	}
+      if (fseek (fp, (long) i, SEEK_SET))
+	{
+	  puts ("Cannot SEEK_SET");
+	  break;
+	}
+      if (fseek (fp, (long) (i >= 128 ? -128 : 128), SEEK_CUR))
+	{
+	  puts ("Cannot SEEK_CUR");
+	  break;
+	}
+      if ((j = getc (fp)) != (i >= 128 ? i - 128 : i + 128))
+	{
+	  printf ("SEEK_CUR failed %d\n", j);
+	  break;
+	}
+    }
+  fclose (fp);
+  remove (TESTFILE);
+
+  puts ((i > 255) ? "Test succeeded." : "Test FAILED!");
+  return (i > 255) ? 0 : 1;
+}

reactos/apps/tests/test_old/test-fwrite.c

@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <string.h>
+
+int
+main (int argc, char *argv[])
+{
+  FILE *f = tmpfile ();
+  char obuf[99999], ibuf[sizeof obuf];
+  char *line;
+  size_t linesz;
+
+  if (! f)
+    {
+      perror ("tmpfile");
+      return 1;
+    }
+
+  if (fputs ("line\n", f) == EOF)
+    {
+      perror ("fputs");
+      return 1;
+    }
+
+  memset (obuf, 'z', sizeof obuf);
+  memset (ibuf, 'y', sizeof ibuf);
+
+  if (fwrite (obuf, sizeof obuf, 1, f) != 1)
+    {
+      perror ("fwrite");
+      return 1;
+    }
+
+  rewind (f);
+
+  line = NULL;
+  linesz = 0;
+  if (getline (&line, &linesz, f) != 5)
+    {
+      perror ("getline");
+      return 1;
+    }
+  if (strcmp (line, "line\n"))
+    {
+      puts ("Lines differ.  Test FAILED!");
+      return 1;
+    }
+
+  if (fread (ibuf, sizeof ibuf, 1, f) != 1)
+    {
+      perror ("fread");
+      return 1;
+    }
+
+  if (memcmp (ibuf, obuf, sizeof ibuf))
+    {
+      puts ("Buffers differ.  Test FAILED!");
+      return 1;
+    }
+
+  asprintf (&line, "\
+GDB is free software and you are welcome to distribute copies of it\n\
+ under certain conditions; type \"show copying\" to see the conditions.\n\
+There is absolutely no warranty for GDB; type \"show warranty\" for details.\n\
+");
+
+  puts ("Test succeeded.");
+  return 0;
+}

reactos/apps/tests/test_old/test-stdio.c

@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <string.h>
+
+int main()
+{
+   char msg1[] = "testing _write\n";
+   char msg2[] = "testing putchar.";
+   char msg3[] = "testing printf.";
+   char tmpbuf[255];
+   FILE* f1;
+   
+   write(1, msg1, strlen(msg1));
+   
+   write(1, msg2, strlen(msg2));
+   putchar('o'); putchar('k'); putchar('\n');
+   
+   write(1, msg3, strlen(msg3));
+   printf("ok\n");
+   
+   printf("Testing fopen\n");
+   f1 = fopen("tmp.txt","w+b");
+   if (f1 == NULL)
+     {
+	printf("fopen failed\n");
+	return(1);
+     }
+   
+   printf("Testing fwrite\n");
+   if (fwrite(msg1, 1, strlen(msg1)+1, f1) != (strlen(msg1)+1))
+     {
+	printf("fwrite failed\n");
+	return(1);
+     }
+   
+   printf("Testing fread\n");
+   fseek(f1, 0, SEEK_SET);
+   if (fread(tmpbuf, 1, strlen(msg1)+1, f1) != (strlen(msg1)+1))
+     {
+	printf("fread failed\n");
+	return(1);
+     }
+   if (strcmp(tmpbuf,msg1) != 0)
+     {
+	printf("fread failed, data corrupt\n");
+	return(1);
+     }
+   
+   printf("Testing fclose\n");
+   if (fclose(f1) != 0)
+     {
+	printf("fclose failed\n");
+	return(1);
+     }
+   return(0);
+}

reactos/apps/tests/test_old/test_rdwr.c

@@ -0,0 +1,129 @@
+/* Copyright (C) 1991, 1992, 1996, 1997, 1998 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C 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.
+
+   The GNU C 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.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+int
+main (int argc, char **argv)
+{
+  static const char hello[] = "Hello, world.\n";
+  static const char replace[] = "Hewwo, world.\n";
+  static const size_t replace_from = 2, replace_to = 4;
+  char filename[FILENAME_MAX];
+  char *name = strrchr (*argv, '/');
+  char buf[BUFSIZ];
+  FILE *f;
+  int lose = 0;
+
+  if (name != NULL)
+    ++name;
+  else
+    name = *argv;
+
+  (void) sprintf (filename, "/tmp/%s.test", name);
+
+  f = fopen (filename, "w+");
+  if (f == NULL)
+    {
+      perror (filename);
+      exit (1);
+    }
+
+  (void) fputs (hello, f);
+  rewind (f);
+  (void) fgets (buf, sizeof (buf), f);
+  rewind (f);
+  (void) fputs (buf, f);
+  rewind (f);
+  {
+    size_t i;
+    for (i = 0; i < replace_from; ++i)
+      {
+	int c = getc (f);
+	if (c == EOF)
+	  {
+	    printf ("EOF at %Zu.\n", i);
+	    lose = 1;
+	    break;
+	  }
+	else if (c != hello[i])
+	  {
+	    printf ("Got '%c' instead of '%c' at %Zu.\n",
+		    (unsigned char) c, hello[i], i);
+	    lose = 1;
+	    break;
+	  }
+      }
+  }
+
+  {
+    long int where = ftell (f);
+    if (where == (long int) replace_from)
+      {
+	register size_t i;
+	for (i = replace_from; i < replace_to; ++i)
+	  if (putc(replace[i], f) == EOF)
+	    {
+	      printf ("putc('%c') got %s at %Zu.\n",
+		      replace[i], strerror (errno), i);
+	      lose = 1;
+	      break;
+	    }
+      }
+    else if (where == -1L)
+      {
+	printf ("ftell got %s (should be at %Zu).\n",
+		strerror (errno), replace_from);
+	lose = 1;
+      }
+    else
+      {
+	printf ("ftell returns %lu; should be %Zu.\n", where, replace_from);
+	lose = 1;
+      }
+  }
+
+  if (!lose)
+    {
+      rewind (f);
+      if (fgets (buf, sizeof (buf), f) == NULL)
+	{
+	  printf ("fgets got %s.\n", strerror(errno));
+	  lose = 1;
+	}
+      else if (strcmp (buf, replace))
+	{
+	  printf ("Read \"%s\" instead of \"%s\".\n", buf, replace);
+	  lose = 1;
+	}
+    }
+
+  if (lose)
+    printf ("Test FAILED!  Losing file is \"%s\".\n", filename);
+  else
+    {
+      (void) remove (filename);
+      puts ("Test succeeded.");
+    }
+
+  exit (lose ? EXIT_FAILURE : EXIT_SUCCESS);
+}

reactos/apps/tests/test_old/testfsd.c

@@ -0,0 +1,315 @@
+/* $Id: testfsd.c,v 1.4 2001/07/04 03:07:54 rex Exp $
+ *
+ * FILE:          testFSD.c
+ * PURPOSE:       A test set for the File System Driver
+ * PROJECT:       ReactOS kernel
+ * COPYRIGHT:     See COPYING in the top level directory
+ * PROGRAMMER:    Rex Jolliff (rex@lvcablemodem.com)
+ *
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <windows.h>
+#include <string.h>
+
+#include "testsuite.h"
+
+const char *rootDir = "c:\\";
+const char *systemRootDir = "c:\\ReactOS";
+const char *systemDllDir = "c:\\ReactOS\\System32";
+const char *bogusRootFile = "c:\\bogus";
+const char *bogusDirAndFile = "c:\\bogus\\bogus";
+const char *bogusSystemRootFile = "c:\\ReactOS\\bogus";
+const char *bogusSystemDllFile = "c:\\ReactOS\\System32\\bogus";
+const char *shortFile = "c:\\ReactOS\\boot.bat";
+const char *longFile = "c:\\ReactOS\\loadros.com";
+
+void  testOpenExistant (void)
+{
+  HANDLE  fileHandle;
+
+  fileHandle  = CreateFile (rootDir, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+  fileHandle  = CreateFile (systemRootDir, GENERIC_READ, 0, 0, 
+                            OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+  fileHandle  = CreateFile (systemDllDir, GENERIC_READ, 0, 0, 
+                            OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+}
+
+void  testOpenNonExistant (void)
+{
+  DWORD  status;
+  HANDLE  fileHandle;
+
+  fileHandle  = CreateFile (bogusRootFile, GENERIC_READ, 0, 0, 
+                            OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle == INVALID_HANDLE_VALUE);
+  status = GetLastError ();
+  ASSERT (status == ERROR_FILE_NOT_FOUND);
+  CloseHandle (fileHandle);
+  fileHandle  = CreateFile (bogusDirAndFile, GENERIC_READ, 0, 0, 
+                            OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle == INVALID_HANDLE_VALUE);
+  status = GetLastError ();
+  ASSERT (status == ERROR_PATH_NOT_FOUND);
+  CloseHandle (fileHandle);
+  fileHandle  = CreateFile (bogusSystemRootFile, GENERIC_READ, 0, 0, 
+                            OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle == INVALID_HANDLE_VALUE);
+  status = GetLastError ();
+  ASSERT (status == ERROR_FILE_NOT_FOUND);
+  CloseHandle (fileHandle);
+  fileHandle  = CreateFile (bogusSystemDllFile, GENERIC_READ, 0, 0, 
+                            OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle == INVALID_HANDLE_VALUE);
+  status = GetLastError ();
+  ASSERT (status == ERROR_FILE_NOT_FOUND);
+  CloseHandle (fileHandle);
+}
+
+void  testCreateExistant (void)
+{
+  DWORD  status;
+  HANDLE  fileHandle;
+
+  fileHandle  = CreateFile (rootDir, GENERIC_READ, 0, 0, 
+                            CREATE_NEW, 0, 0);
+  ASSERT (fileHandle == INVALID_HANDLE_VALUE);
+  status = GetLastError ();
+  ASSERT (status == ERROR_ALREADY_EXISTS);
+  fileHandle  = CreateFile (systemRootDir, GENERIC_READ, 0, 0, 
+                            CREATE_NEW, 0, 0);
+  ASSERT (fileHandle == INVALID_HANDLE_VALUE);
+  status = GetLastError ();
+  ASSERT (status == ERROR_ALREADY_EXISTS);
+  fileHandle  = CreateFile (systemDllDir, GENERIC_READ, 0, 0, 
+                            CREATE_NEW, 0, 0);
+  ASSERT (fileHandle == INVALID_HANDLE_VALUE);
+  status = GetLastError ();
+  ASSERT (status == ERROR_ALREADY_EXISTS);
+}
+
+void  testCreateNonExistant (void)
+{
+  DWORD  status;
+  HANDLE  fileHandle;
+
+  fileHandle  = CreateFile (bogusRootFile, GENERIC_READ, 0, 0, 
+                            CREATE_NEW, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+  fileHandle  = CreateFile (bogusSystemRootFile, GENERIC_READ, 0, 0, 
+                            CREATE_NEW, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+  fileHandle  = CreateFile (bogusSystemDllFile, GENERIC_READ, 0, 0, 
+                            CREATE_NEW, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+#if 0
+  fileHandle  = CreateFile (bogusDirAndFile, GENERIC_READ, 0, 0, 
+                            CREATE_NEW, 0, 0);
+  ASSERT (fileHandle == INVALID_HANDLE_VALUE);
+  status = GetLastError ();
+  ASSERT (status == ERROR_PATH_NOT_FOUND);
+  CloseHandle (fileHandle);
+#endif
+}
+
+void testDeleteFiles (void)
+{
+  BOOL  returnValue;
+  HANDLE  fileHandle;
+
+  fileHandle  = CreateFile ("bogus", GENERIC_READ, 0, 0, 
+                            CREATE_NEW, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+  returnValue = DeleteFile ("bogus");
+  ASSERT_MSG (returnValue, 
+              "Delete of bogus failed, error:%d", 
+              GetLastError ());
+
+#if 0
+  returnValue = DeleteFile (bogusRootFile);
+  ASSERT_MSG (returnValue, 
+              "Delete of %s failed, error:%d", 
+              bogusRootFile, 
+              GetLastError ());
+  returnValue = DeleteFile (bogusRootFile);
+  ASSERT_MSG (!returnValue, 
+              "2nd Delete of %s succeeded but should fail",
+              bogusRootFile);
+  returnValue = DeleteFile (bogusSystemRootFile);
+  ASSERT_MSG (returnValue, 
+              "Delete of %s failed, error:%d", 
+              bogusSystemRootFile,
+              GetLastError ());
+  returnValue = DeleteFile (bogusSystemRootFile);
+  ASSERT_MSG (!returnValue, 
+              "2nd Delete of %s succeeded but should fail",
+              bogusSystemRootFile);
+  returnValue = DeleteFile (bogusSystemDllFile);
+  ASSERT_MSG (returnValue, 
+              "Delete of %s failed, error:%d", 
+              bogusSystemDllFile,
+              GetLastError ());
+  returnValue = DeleteFile (bogusSystemDllFile);
+  ASSERT_MSG (!returnValue, 
+              "2nd Delete of %s succeeded but should fail",
+              bogusSystemDllFile);
+  returnValue = DeleteFile (bogusDirAndFile);
+  ASSERT_MSG (!returnValue, 
+              "Delete of %s succeded but should fail",
+              bogusDirAndFile);
+#endif
+}
+
+void  testOpenWithBlankPathElements (void)
+{
+  HANDLE  fileHandle;
+
+  fileHandle = CreateFile ("c:", GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+  fileHandle = CreateFile ("c:\\\\", GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+  fileHandle = CreateFile ("c:\\\\reactos\\", GENERIC_READ, 0, 0, 
+                            OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+  fileHandle = CreateFile ("c:\\reactos\\\\", GENERIC_READ, 0, 0, 
+                            OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+  fileHandle = CreateFile ("c:\\reactos\\\\system32\\", GENERIC_READ, 0, 0, 
+                            OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+  fileHandle = CreateFile ("c:\\reactos\\system32\\\\", GENERIC_READ, 0, 0, 
+                            OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+}
+
+void testReadOnInvalidHandle (void)
+{
+  BOOL  returnValue;
+  char  buffer [256];
+  DWORD  bytesRead;
+
+  returnValue = ReadFile (INVALID_HANDLE_VALUE, 
+                          buffer, 
+                          256, 
+                          &bytesRead, 
+                          NULL);
+  ASSERT_MSG (!returnValue,
+              "Read from invalid handle succeeded but should fail",0);
+  ASSERT (GetLastError () != ENOFILE);
+}
+
+void testReadOnZeroLengthFile (void)
+{
+  BOOL  returnValue;
+  HANDLE  fileHandle;
+  char  buffer [256];
+  DWORD  bytesRead;
+
+  fileHandle  = CreateFile (bogusRootFile, GENERIC_READ, 0, 0, 
+                            CREATE_NEW, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  CloseHandle (fileHandle);
+  fileHandle  = CreateFile (bogusRootFile, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  returnValue = ReadFile (fileHandle, buffer, 256, &bytesRead, NULL);
+  ASSERT_MSG (!returnValue,
+              "Read from zero length file succeeded but should fail",0);
+  ASSERT (GetLastError () != ERROR_HANDLE_EOF);
+  CloseHandle (fileHandle);
+  returnValue = DeleteFile (bogusRootFile);
+  ASSERT_MSG (returnValue, 
+              "Delete of %s failed, error:%d", 
+              bogusRootFile, 
+              GetLastError ());
+}
+
+void testReadOnShortFile (void)
+{
+  BOOL  returnValue;
+  HANDLE  fileHandle;
+  char  buffer [256];
+  DWORD  bytesRead;
+
+  fileHandle  = CreateFile (shortFile, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  returnValue = ReadFile (fileHandle, 
+                          buffer, 
+                          256, 
+                          &bytesRead, 
+                          NULL);
+  ASSERT_MSG (returnValue,
+              "Read from short length file failed, error:%d",
+              GetLastError ());
+  ASSERT (bytesRead > 0 && bytesRead < 256);
+  CloseHandle (fileHandle);
+}
+
+void testReadOnLongFile (void)
+{
+  BOOL  returnValue;
+  HANDLE  fileHandle;
+  char  buffer [256];
+  DWORD  bytesRead;
+  int  count;
+
+  fileHandle  = CreateFile (longFile, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
+  ASSERT (fileHandle != INVALID_HANDLE_VALUE);
+  for (count = 0; count < 20; count++)
+  {
+    returnValue = ReadFile (fileHandle, 
+                            buffer, 
+                            256, 
+                            &bytesRead, 
+                            NULL); 
+    ASSERT_MSG (returnValue,
+                "Read from short length file failed, error:%d",
+                GetLastError ());
+    ASSERT (bytesRead == 256);
+  }
+  CloseHandle (fileHandle);
+}
+
+int main (void)
+{
+  TEST_RUNNER  testRunner;
+  TEST_SUITE  testsToRun [] =
+  {
+    ADD_TEST (testOpenExistant),
+    ADD_TEST (testOpenNonExistant),
+    ADD_TEST (testCreateExistant),
+    ADD_TEST (testCreateNonExistant),
+    ADD_TEST (testDeleteFiles),
+/*    ADD_TEST (testOverwriteExistant),*/
+/*    ADD_TEST (testOverwriteNonExistant),*/
+    ADD_TEST (testOpenWithBlankPathElements),
+    ADD_TEST (testReadOnInvalidHandle),
+    ADD_TEST (testReadOnZeroLengthFile),
+    ADD_TEST (testReadOnShortFile),
+    ADD_TEST (testReadOnLongFile),
+/*    ADD_TEST (test), */
+    END_TESTS
+  };
+
+  memset (&testRunner, 0, sizeof (TEST_RUNNER));
+  tsRunTests (&testRunner, testsToRun);
+  tsReportResults (&testRunner);
+}
+
+

reactos/apps/tests/test_old/testsuite.c

@@ -0,0 +1,65 @@
+
+#include <windows.h>
+#include <stdio.h>
+
+#include "testsuite.h"
+
+static PTEST_RUNNER iTestRunner = 0;
+
+void  tsRunTests (PTEST_RUNNER pTestRunner, PTEST_SUITE pTests)
+{
+  int testIndex;
+
+  iTestRunner = pTestRunner;
+  for (testIndex = 0; pTests [testIndex].testFunc != 0; testIndex++)
+  {
+    pTests [testIndex].testFunc ();
+    pTestRunner->tests++;
+  }
+}
+
+void  tsReportResults (PTEST_RUNNER pTestRunner)
+{
+  printf ("\nTotal of %d tests.\n"
+          "Assertions: %d\n"
+          "  Assertions which passed: %d\n"
+          "  Assertions which failed: %d\n",
+          pTestRunner->tests,
+          pTestRunner->assertions,
+          pTestRunner->successes,
+          pTestRunner->failures);
+  if (pTestRunner->failures == 0)
+  {
+    printf ("\n*** OK ***\n");
+  }
+  else
+  {
+    printf ("\n*** FAIL ***\n");
+  }
+}
+
+void  tsDoAssertion (BOOL  pTest, 
+                     PCHAR  pTestText, 
+                     PCHAR  pFunction, 
+                     int  pLine,
+                     ...)
+{
+  va_list  ap;
+
+  iTestRunner->assertions++;
+  if (!pTest) 
+  {
+    va_start (ap, pLine);
+    printf ("%s(%d): ", pFunction, pLine);
+    vprintf (pTestText, ap); 
+    printf ("\n");
+    va_end(ap);
+    iTestRunner->failures++;
+  }
+  else
+  {
+    iTestRunner->successes++;
+  }
+}
+
+

reactos/apps/tests/test_old/testsuite.h

@@ -0,0 +1,44 @@
+
+#ifndef H_TESTSUITE_H
+#define H_TESTSUITE_H
+
+struct TestSuite
+{
+  char *name;
+  void (*testFunc)(void);
+};
+
+typedef struct TestSuite  TEST_SUITE, *PTEST_SUITE;
+
+#define ADD_TEST(x)  {#x, x}
+#define END_TESTS  {0, 0}
+#define COUNT_TESTS(x)  (sizeof x/sizeof (struct TestSuite))
+
+struct TestRunner
+{
+  int  tests;
+  int  assertions;
+  int  failures;
+  int  successes;
+};
+
+typedef struct TestRunner  TEST_RUNNER, *PTEST_RUNNER;
+
+void  tsDoAssertion (BOOL pTest, 
+                     PCHAR pTestText, 
+                     PCHAR pFunction, 
+                     int pLine,
+                     ...);
+
+#ifdef ASSERT
+#undef ASSERT
+#endif
+#define  ASSERT(x) tsDoAssertion (x, "assertion \"" ## #x ## "\" failed", __FUNCTION__, __LINE__)
+#define  ASSERT_MSG(x,y,a...) tsDoAssertion (x, y, __FUNCTION__, __LINE__,a)
+
+void  tsRunTests (PTEST_RUNNER pTestRunner, PTEST_SUITE pTests);
+void  tsReportResults (PTEST_RUNNER pTestRunner);
+
+#endif
+
+

reactos/apps/tests/test_old/tst-printf.c

@@ -0,0 +1,311 @@
+/* Copyright (C) 1991, 92, 93, 95, 96, 97, 98 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C 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.
+
+   The GNU C 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.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifdef	BSD
+#include </usr/include/stdio.h>
+#define EXIT_SUCCESS 0
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#endif
+
+#include <float.h>
+
+void rfg1 (void);
+void rfg2 (void);
+
+
+void
+fmtchk (const char *fmt)
+{
+  (void) fputs(fmt, stdout);
+  (void) printf(":\t`");
+  (void) printf(fmt, 0x12);
+  (void) printf("'\n");
+}
+
+void
+fmtst1chk (const char *fmt)
+{
+  (void) fputs(fmt, stdout);
+  (void) printf(":\t`");
+  (void) printf(fmt, 4, 0x12);
+  (void) printf("'\n");
+}
+
+void
+fmtst2chk (const char *fmt)
+{
+  (void) fputs(fmt, stdout);
+  (void) printf(":\t`");
+  (void) printf(fmt, 4, 4, 0x12);
+  (void) printf("'\n");
+}
+
+/* This page is covered by the following copyright: */
+
+/* (C) Copyright C E Chew
+ *
+ * Feel free to copy, use and distribute this software provided:
+ *
+ *	1. you do not pretend that you wrote it
+ *	2. you leave this copyright notice intact.
+ */
+
+/*
+ * Extracted from exercise.c for glibc-1.05 bug report by Bruce Evans.
+ */
+
+#define DEC -123
+#define INT 255
+#define UNS (~0)
+
+/* Formatted Output Test
+ *
+ * This exercises the output formatting code.
+ */
+
+void
+fp_test (void)
+{
+  int i, j, k, l;
+  char buf[7];
+  char *prefix = buf;
+  char tp[20];
+
+  puts("\nFormatted output test");
+  printf("prefix  6d      6o      6x      6X      6u\n");
+  strcpy(prefix, "%");
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      for (k = 0; k < 2; k++) {
+	for (l = 0; l < 2; l++) {
+	  strcpy(prefix, "%");
+	  if (i == 0) strcat(prefix, "-");
+	  if (j == 0) strcat(prefix, "+");
+	  if (k == 0) strcat(prefix, "#");
+	  if (l == 0) strcat(prefix, "0");
+	  printf("%5s |", prefix);
+	  strcpy(tp, prefix);
+	  strcat(tp, "6d |");
+	  printf(tp, DEC);
+	  strcpy(tp, prefix);
+	  strcat(tp, "6o |");
+	  printf(tp, INT);
+	  strcpy(tp, prefix);
+	  strcat(tp, "6x |");
+	  printf(tp, INT);
+	  strcpy(tp, prefix);
+	  strcat(tp, "6X |");
+	  printf(tp, INT);
+	  strcpy(tp, prefix);
+	  strcat(tp, "6u |");
+	  printf(tp, UNS);
+	  printf("\n");
+	}
+      }
+    }
+  }
+  printf("%10s\n", (char *) NULL);
+  printf("%-10s\n", (char *) NULL);
+}
+
+int
+main (int argc, char *argv[])
+{
+  static char shortstr[] = "Hi, Z.";
+  static char longstr[] = "Good morning, Doctor Chandra.  This is Hal.  \
+I am ready for my first lesson today.";
+
+  fmtchk("%.4x");
+  fmtchk("%04x");
+  fmtchk("%4.4x");
+  fmtchk("%04.4x");
+  fmtchk("%4.3x");
+  fmtchk("%04.3x");
+
+  fmtst1chk("%.*x");
+  fmtst1chk("%0*x");
+  fmtst2chk("%*.*x");
+  fmtst2chk("%0*.*x");
+
+#ifndef	BSD
+  printf("bad format:\t\"%b\"\n");
+  printf("nil pointer (padded):\t\"%10p\"\n", (void *) NULL);
+#endif
+
+  printf("decimal negative:\t\"%d\"\n", -2345);
+  printf("octal negative:\t\"%o\"\n", -2345);
+  printf("hex negative:\t\"%x\"\n", -2345);
+  printf("long decimal number:\t\"%ld\"\n", -123456L);
+  printf("long octal negative:\t\"%lo\"\n", -2345L);
+  printf("long unsigned decimal number:\t\"%lu\"\n", -123456L);
+  printf("zero-padded LDN:\t\"%010ld\"\n", -123456L);
+  printf("left-adjusted ZLDN:\t\"%-010ld\"\n", -123456);
+  printf("space-padded LDN:\t\"%10ld\"\n", -123456L);
+  printf("left-adjusted SLDN:\t\"%-10ld\"\n", -123456L);
+
+  printf("zero-padded string:\t\"%010s\"\n", shortstr);
+  printf("left-adjusted Z string:\t\"%-010s\"\n", shortstr);
+  printf("space-padded string:\t\"%10s\"\n", shortstr);
+  printf("left-adjusted S string:\t\"%-10s\"\n", shortstr);
+  printf("null string:\t\"%s\"\n", (char *)NULL);
+  printf("limited string:\t\"%.22s\"\n", longstr);
+
+  printf("e-style >= 1:\t\"%e\"\n", 12.34);
+  printf("e-style >= .1:\t\"%e\"\n", 0.1234);
+  printf("e-style < .1:\t\"%e\"\n", 0.001234);
+  printf("e-style big:\t\"%.60e\"\n", 1e20);
+  printf ("e-style == .1:\t\"%e\"\n", 0.1);
+  printf("f-style >= 1:\t\"%f\"\n", 12.34);
+  printf("f-style >= .1:\t\"%f\"\n", 0.1234);
+  printf("f-style < .1:\t\"%f\"\n", 0.001234);
+  printf("g-style >= 1:\t\"%g\"\n", 12.34);
+  printf("g-style >= .1:\t\"%g\"\n", 0.1234);
+  printf("g-style < .1:\t\"%g\"\n", 0.001234);
+  printf("g-style big:\t\"%.60g\"\n", 1e20);
+
+  printf (" %6.5f\n", .099999999860301614);
+  printf (" %6.5f\n", .1);
+  printf ("x%5.4fx\n", .5);
+
+  printf ("%#03x\n", 1);
+
+  {
+    double d = FLT_MIN;
+    int niter = 17;
+
+    while (niter-- != 0)
+      printf ("%.17e\n", d / 2);
+    fflush (stdout);
+  }
+
+  printf ("%15.5e\n", 4.9406564584124654e-324);
+
+#define FORMAT "|%12.4f|%12.4e|%12.4g|\n"
+  printf (FORMAT, 0.0, 0.0, 0.0);
+  printf (FORMAT, 1.0, 1.0, 1.0);
+  printf (FORMAT, -1.0, -1.0, -1.0);
+  printf (FORMAT, 100.0, 100.0, 100.0);
+  printf (FORMAT, 1000.0, 1000.0, 1000.0);
+  printf (FORMAT, 10000.0, 10000.0, 10000.0);
+  printf (FORMAT, 12345.0, 12345.0, 12345.0);
+  printf (FORMAT, 100000.0, 100000.0, 100000.0);
+  printf (FORMAT, 123456.0, 123456.0, 123456.0);
+#undef	FORMAT
+
+  {
+    char buf[20];
+    printf ("sprintf (\"%%30s\", \"foo\") == %d, \"%.*s\"\n",
+	    sprintf (buf, "%30s", "foo"), sizeof (buf), buf);
+  }
+
+  fp_test ();
+
+  printf ("%e should be 1.234568e+06\n", 1234567.8);
+  printf ("%f should be 1234567.800000\n", 1234567.8);
+  printf ("%g should be 1.23457e+06\n", 1234567.8);
+  printf ("%g should be 123.456\n", 123.456);
+  printf ("%g should be 1e+06\n", 1000000.0);
+  printf ("%g should be 10\n", 10.0);
+  printf ("%g should be 0.02\n", 0.02);
+
+  {
+    double x=1.0;
+    printf("%.17f\n",(1.0/x/10.0+1.0)*x-x);
+  }
+
+  puts ("--- Should be no further output. ---");
+  rfg1 ();
+  rfg2 ();
+
+  {
+    char buf[200];
+    int result;
+
+    sprintf(buf,"%*s%*s%*s",-1,"one",-20,"two",-30,"three");
+
+    result = strcmp (buf,
+		     "onetwo                 three                         ");
+
+    puts (result != 0 ? "Test failed!" : "Test ok.");
+    return result != 0;
+  }
+}
+
+void
+rfg1 (void)
+{
+  char buf[100];
+
+  sprintf (buf, "%5.s", "xyz");
+  if (strcmp (buf, "     ") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, "     ");
+  sprintf (buf, "%5.f", 33.3);
+  if (strcmp (buf, "   33") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, "   33");
+  sprintf (buf, "%8.e", 33.3e7);
+  if (strcmp (buf, "   3e+08") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, "   3e+08");
+  sprintf (buf, "%8.E", 33.3e7);
+  if (strcmp (buf, "   3E+08") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, "   3E+08");
+  sprintf (buf, "%.g", 33.3);
+  if (strcmp (buf, "3e+01") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, "3e+01");
+  sprintf (buf, "%.G", 33.3);
+  if (strcmp (buf, "3E+01") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, "3E+01");
+}
+
+void
+rfg2 (void)
+{
+  int prec;
+  char buf[100];
+
+  prec = 0;
+  sprintf (buf, "%.*g", prec, 3.3);
+  if (strcmp (buf, "3") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, "3");
+  prec = 0;
+  sprintf (buf, "%.*G", prec, 3.3);
+  if (strcmp (buf, "3") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, "3");
+  prec = 0;
+  sprintf (buf, "%7.*G", prec, 3.33);
+  if (strcmp (buf, "      3") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, "      3");
+  prec = 3;
+  sprintf (buf, "%04.*o", prec, 33);
+  if (strcmp (buf, " 041") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, " 041");
+  prec = 7;
+  sprintf (buf, "%09.*u", prec, 33);
+  if (strcmp (buf, "  0000033") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, "  0000033");
+  prec = 3;
+  sprintf (buf, "%04.*x", prec, 33);
+  if (strcmp (buf, " 021") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, " 021");
+  prec = 3;
+  sprintf (buf, "%04.*X", prec, 33);
+  if (strcmp (buf, " 021") != 0)
+    printf ("got: '%s', expected: '%s'\n", buf, " 021");
+}

reactos/apps/tests/test_old/tstdiomisc.c

@@ -0,0 +1,56 @@
+#include <stdio.h>
+
+int
+t1 (void)
+{
+  int n = -1;
+  sscanf ("abc  ", "abc %n", &n);
+  printf ("t1: count=%d\n", n);
+
+  return n != 5;
+}
+
+int
+t2 (void)
+{
+  int result = 0;
+  int n;
+  long N;
+  int retval;
+#define SCAN(INPUT, FORMAT, VAR, EXP_RES, EXP_VAL) \
+  VAR = -1; \
+  retval = sscanf (INPUT, FORMAT, &VAR); \
+  printf ("sscanf (\"%s\", \"%s\", &x) => %d, x = %ld\n", \
+	  INPUT, FORMAT, retval, (long int) VAR); \
+  result |= retval != EXP_RES || VAR != EXP_VAL
+
+  SCAN ("12345", "%ld", N, 1, 12345);
+  SCAN ("12345", "%llllld", N, 0, -1);
+  SCAN ("12345", "%LLLLLd", N, 0, -1);
+  SCAN ("test ", "%*s%n",  n, 0, 4);
+  SCAN ("test ", "%2*s%n",  n, 0, -1);
+  SCAN ("12 ",   "%l2d",  n, 0, -1);
+  SCAN ("12 ",   "%2ld",  N, 1, 12);
+
+  n = -1;
+  N = -1;
+  retval = sscanf ("1 1", "%d %Z", &n, &N);
+  printf ("sscanf (\"1 1\", \"%%d %%Z\", &n, &N) => %d, n = %d, N = %ld\n", \
+	  retval, n, N); \
+  result |= retval != 1 || n != 1 || N != -1;
+
+  return result;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int result = 0;
+
+  result |= t1 ();
+  result |= t2 ();
+
+  result |= fflush (stdout) == EOF;
+
+  return result;
+}

reactos/apps/tests/thread/makefile

@@ -0,0 +1,31 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+PROGS = thread
+
+all: $(PROGS:%=%.exe)
+
+.phony: all
+
+clean: 
+	- $(RM) *.o *.exe *.sym
+
+.phony: clean
+
+install: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%.exe): $(FLOPPY_DIR)/apps/%.exe: %.exe
+	$(CP) $*.exe $(FLOPPY_DIR)/apps/$*.exe
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%.exe)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%.exe): ../../$(DIST_DIR)/apps/%.exe: %.exe
+	$(CP) $*.exe ../../$(DIST_DIR)/apps/$*.exe
+
+thread.exe: thread.c
+	$(CC) $(CFLAGS) thread.c -lkernel32 -o thread.exe
+	$(NM) --numeric-sort thread.exe > thread.sym
+
+include ../../rules.mak

reactos/apps/tests/thread/thread.c

@@ -0,0 +1,75 @@
+/* $Id: thread.c,v 1.7 2001/02/06 00:11:17 dwelch Exp $
+ *
+ *
+ *
+ *
+ */
+
+#include <stdio.h>
+#include <windows.h>
+#include <stdlib.h>
+
+#define NR_THREADS (10)
+
+ULONG nr;
+
+DWORD WINAPI thread_main1(LPVOID param)
+{
+   ULONG s;
+   
+   printf("Thread %ld running\n", (DWORD)param);
+   s = nr = ((nr * 1103515245) + 12345) & 0x7fffffff;
+   s = s % 10;
+   printf("s %ld\n", s);
+   Sleep(s);
+   printf("Thread %ld finished\n", (DWORD)param);
+   return 0;
+}
+
+// Shows the help on how to use these program to the user
+void showHelp(void)
+{
+
+printf("\nReactOS threads test program (built on %s).\n\n", __DATE__);
+printf("syntax:\tthread.exe <seed>\n");
+printf("\twhere <seed> is an integer number\n");
+printf("\texample: thread.exe 100\n");
+
+
+}
+
+int main (int argc, char* argv[])
+{
+   HANDLE hThread;
+   DWORD i=0;
+   DWORD id;
+   ULONG nr;
+   
+
+   // The user must supply one argument (the seed). if he/she doesn't
+   // then we show the help.
+   //   if(argc < 2) {
+   //		showHelp();
+   //		return 1;
+   //   }
+		
+   //   nr = atoi(argv[1]);
+   nr = 500;
+   printf("Seed %ld\n", nr);
+   
+   printf("Creating %d threads...\n",NR_THREADS*2);
+   for (i=0;i<NR_THREADS;i++)
+     {
+	CreateThread(NULL,
+		     0,
+		     thread_main1,
+		     (LPVOID)i,
+		     0,
+		     &id);
+
+     }
+
+   printf("All threads created...\n");
+   for(;;);
+   return 0;
+}

reactos/apps/tests/vmtest/Makefile

@@ -0,0 +1,31 @@
+#
+#
+#
+PATH_TO_TOP = ../..
+
+OBJECTS = vmtest.o
+PROGS = vmtest.exe
+LIBS = 
+CLEAN_FILES = vmtest.o vmtest.exe
+
+all: vmtest.exe
+
+clean: 
+	- $(RM) $(CLEAN_FILES)
+
+.phony: clean 
+
+floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+
+vmtest.exe: $(OBJECTS)
+	$(CC) $(OBJECTS) -o vmtest.exe
+
+include ../../rules.mak

reactos/apps/tests/vmtest/vmtest.c

@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <windows.h>
+
+int main()
+{
+   PVOID Base;
+   PVOID Ret;
+   
+   Base = VirtualAlloc(NULL,
+		       1048576,
+		       MEM_RESERVE,
+		       PAGE_READWRITE);
+   if (Base == NULL)
+     {
+	printf("VirtualAlloc failed 1\n");
+     }
+   
+   Ret = VirtualAlloc(Base + 4096,
+		      4096,
+		      MEM_COMMIT,
+		      PAGE_READWRITE);
+   if (Ret == NULL)
+     {
+	printf("VirtualAlloc failed 2\n");
+     }
+   
+   Ret = VirtualAlloc(Base + 12288,
+		      4096,
+		      MEM_COMMIT,
+		      PAGE_READWRITE);
+   if (Ret == NULL)
+     {
+	printf("VirtualAlloc failed 3\n");
+     }
+   
+   Ret = VirtualAlloc(Base + 20480,
+		      4096,
+		      MEM_COMMIT,
+		      PAGE_READWRITE);
+   if (Ret == NULL)
+     {
+	printf("VirtualAlloc failed 4\n");
+     }
+   
+   Ret = VirtualAlloc(Base + 4096,
+		      28672,
+		      MEM_RESERVE,
+		      PAGE_READWRITE);
+   if (Ret == NULL)
+     {
+	printf("VirtualAlloc failed 5\n");
+     }
+}
+

reactos/apps/utils/buildno/.cvsignore

@@ -0,0 +1,2 @@
+buildno
+buildno.exe

reactos/apps/utils/buildno/Makefile

@@ -0,0 +1,26 @@
+# $Id: Makefile,v 1.10 2001/07/15 21:18:49 rex Exp $
+#
+
+PATH_TO_TOP = ../..
+
+BASE_CFLAGS = 
+TARGETNAME=buildno
+CLEAN_FILES= $(TARGETNAME).o $(TARGETNAME)$(EXE_POSTFIX) $(TARGETNAME).sym
+
+all: $(TARGETNAME)$(EXE_POSTFIX)
+	$(EXE_PREFIX)$(TARGETNAME)$(EXE_POSTFIX)
+
+
+$(TARGETNAME)$(EXE_POSTFIX): $(TARGETNAME).c ../../include/reactos/version.h
+	$(HOST_CC) -g -o $(TARGETNAME)$(EXE_POSTFIX) $(TARGETNAME).c
+
+
+
+clean:
+	- $(RM) $(CLEAN_FILES)
+
+.phony: clean 
+
+include ../../rules.mak
+
+# EOF

reactos/apps/utils/buildno/buildno.c

@@ -0,0 +1,329 @@
+/* $Id: buildno.c,v 1.6 2001/04/11 22:13:21 dwelch Exp $
+ *
+ * buildno - Generate the build number for ReactOS
+ *
+ * Copyright (c) 1999,2000 Emanuele Aliberti
+ *
+ * License: GNU GPL
+ *
+ * It assumes the last release date is defined in
+ * <reactos/version.h> as a macro named
+ *
+ * KERNEL_RELEASE_DATE
+ *
+ * as a 32-bit unsigned long YYYYMMDD (UTC;
+ * MM=01-12; DD=01-31).
+ *
+ * The build number is the number of full days
+ * elapsed since the last release date (UTC).
+ *
+ * The build number is stored in the file
+ * <reactos/buildno.h> as a set of macros:
+ *
+ * KERNEL_VERSION_BUILD		base 10 number
+ * KERNEL_VERSION_BUILD_STR	C string
+ * KERNEL_VERSION_BUILD_RC	RC string
+ *
+ * REVISIONS
+ * ---------
+ * 2000-01-22 (ea)
+ * 	Fixed bugs: tm_year is (current_year - 1900),
+ * 	tm_month is 0-11 not 1-12 and code ignored TZ.
+ * 2000-12-10 (ea)
+ * 	Added -p option to make it simply print the
+ * 	version number, but skip buildno.h generation.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "../../include/reactos/version.h"
+
+#define FALSE 0
+#define TRUE  1
+
+/* File to (over)write */
+#define BUILDNO_INCLUDE_FILE "../../include/reactos/buildno.h"
+
+static char * argv0 = "";
+
+#ifdef DBG
+void
+tm_dump (const char *tag, struct tm * t)
+{
+	printf ("%s->tm_sec   = %d\n", tag, t->tm_sec);
+	printf ("%s->tm_min   = %d\n", tag, t->tm_min);
+	printf ("%s->tm_hour  = %d\n", tag, t->tm_hour);
+	printf ("%s->tm_mday  = %d\n", tag, t->tm_mday);
+	printf ("%s->tm_mon   = %d\n", tag, t->tm_mon);
+	printf ("%s->tm_year  = %d\n", tag, t->tm_year);
+	printf ("%s->tm_wday  = %d\n", tag, t->tm_wday);
+	printf ("%s->tm_yday  = %d\n", tag, t->tm_yday);
+	printf ("%s->tm_isdst = %d\n\n", tag, t->tm_isdst);
+}
+#endif
+
+
+int
+elapsed_days (
+	time_t	t_today,
+	time_t	t_release_day
+	)
+{
+	double	seconds = difftime (t_today, t_release_day);
+	double	days = seconds / (double) 86400.0;
+	char	buf [32];
+	char	* dot = buf;
+
+	sprintf (buf, "%f", days );
+
+	while ( *dot && *dot != '.') ++dot;
+	*dot = '\0';
+	
+	return atol (buf);
+}
+
+void
+write_h (int build)
+{
+  FILE	*h = NULL;
+  char* s;
+  char* s1;
+  int length;
+
+  s1 = s = malloc(256 * 1024);
+  
+  s = s + sprintf (s, "/* Do not edit - Machine generated */\n");
+	
+  s = s + sprintf (s, "#ifndef _INC_REACTOS_BUILDNO\n" );
+  s = s + sprintf (s, "#define _INC_REACTOS_BUILDNO\n" );
+  
+  s = s + sprintf (s, "#define KERNEL_VERSION_BUILD\t%d\n", build);
+  s = s + sprintf (s, "#define KERNEL_VERSION_BUILD_STR\t\"%d\"\n", build);
+  s = s + sprintf (s, "#define KERNEL_RELEASE_RC\t\"%d.%d.%d.%d\\0\"\n",
+		   KERNEL_VERSION_MAJOR, KERNEL_VERSION_MINOR,
+		   KERNEL_VERSION_PATCH_LEVEL, build);
+  s = s + sprintf (s, "#define KERNEL_RELEASE_STR\t\"%d.%d.%d.%d\"\n",
+		   KERNEL_VERSION_MAJOR,
+		   KERNEL_VERSION_MINOR,
+		   KERNEL_VERSION_PATCH_LEVEL,
+		   build);
+  s = s + sprintf (s, "#define KERNEL_VERSION_RC\t\"%d.%d.%d\\0\"\n",
+		   KERNEL_VERSION_MAJOR,
+		   KERNEL_VERSION_MINOR,
+		   KERNEL_VERSION_PATCH_LEVEL);
+  s = s + sprintf (s, "#define KERNEL_VERSION_STR\t\"%d.%d.%d\"\n", 
+		   KERNEL_VERSION_MAJOR,
+		   KERNEL_VERSION_MINOR,
+		   KERNEL_VERSION_PATCH_LEVEL);
+  s = s + sprintf (s, "#endif\n/* EOF */\n");
+
+  h = fopen (BUILDNO_INCLUDE_FILE, "r");
+  if (h != NULL)
+    {
+      fseek(h, 0, SEEK_END);
+      length = ftell(h);
+      if (length == strlen(s1))
+	{
+	  char* orig;
+	  
+	  orig = malloc(length);
+	  fseek(h, 0, SEEK_SET);
+	  fread(orig, 1, length, h);
+	  if (memcmp(s1, orig, length) == 0)
+	    {
+	      fclose(h);
+	      return;
+	    }
+	}
+      fclose(h);
+    }
+
+  h = fopen (BUILDNO_INCLUDE_FILE, "w");
+  if (!h) 
+    {
+      fprintf (stderr,
+	       "%s: can not create file \"%s\"!\n",
+	       argv0,
+	       BUILDNO_INCLUDE_FILE);
+      return;
+    }
+  fwrite(s1, 1, strlen(s1), h);
+  fclose (h);
+}
+
+void
+usage (void)
+{
+	fprintf (
+		stderr,
+		"Usage: %s [-{p|q}]\n\n  -p  print version number and exit\n  -q  run in quiet mode\n",
+		argv0
+		);
+	exit (EXIT_SUCCESS);
+}
+
+
+int
+main (int argc, char * argv [])
+{
+	int		print_only = FALSE;
+	int		quiet = FALSE;
+
+	int		year = 0;
+	int		month = 0;
+	int		day = 0;
+	int		build = 0;
+
+	time_t		t0 = 0;
+	struct tm	t0_tm = {0};
+	time_t		t1 = 0;
+	struct tm	* t1_tm = NULL;
+
+	argv0 = argv[0];
+		
+	switch (argc)
+	{
+		case 1:
+			break;
+		case 2:
+			if (argv[1][0] == '-')
+			{
+				if (argv[1][1] == 'q')
+				{
+					quiet = TRUE;
+				}
+				else  if (argv[1][1] == 'p')
+				{
+					print_only = TRUE;
+				}
+				else
+				{
+					usage ();
+				}
+			}
+			else
+			{
+				usage ();
+			}
+			break;
+		default:
+			usage ();
+	}
+	/*
+	 * Set TZ information.
+	 */
+	tzset ();
+	/*
+	 * We are building TODAY!
+	 */
+	time (& t0);
+	/*
+	 * "Parse" the release date.
+	 */
+	day = KERNEL_RELEASE_DATE % 100;
+	month = (	(	KERNEL_RELEASE_DATE
+				% 10000
+				)
+				- day
+			)
+			/ 100;
+	year =
+		(	KERNEL_RELEASE_DATE
+			- (month * 100)
+			- day
+			)
+			/ 10000;
+	if (FALSE == quiet)
+	{
+		printf ( "\n\
+ReactOS Build Number Generator\n\n\
+Last release: %4d-%02d-%02d\n",
+			year,
+			month,
+			day
+			);
+	}
+#ifdef DBG
+	tm_dump ("t0", & t0_tm);
+#endif
+	t0_tm.tm_year = (year - 1900);
+	t0_tm.tm_mon = --month; /* 0-11 */
+	t0_tm.tm_mday = day;
+	t0_tm.tm_hour = 0;
+	t0_tm.tm_min = 0;
+	t0_tm.tm_sec = 1;
+	t0_tm.tm_isdst = -1;
+	
+#ifdef DBG
+	tm_dump ("t0", & t0_tm);
+#endif
+
+	if (-1 == (t0 = mktime (& t0_tm)))
+	{
+		fprintf (
+			stderr,
+			"%s: can not convert release date!\n",
+			argv[0]
+			);
+		return EXIT_FAILURE;
+	}
+
+	time (& t1); /* current build time */
+	t1_tm = gmtime (& t1);
+
+#ifdef DBG
+	tm_dump ("t1", t1_tm);
+#endif
+	t1_tm->tm_year +=
+		(t1_tm->tm_year < 70)
+		? 2000
+		: 1900;
+#ifdef DBG
+	tm_dump ("t1", t1_tm);
+#endif
+	if (FALSE == quiet)
+	{
+		printf ( 
+			"Current date: %4d-%02d-%02d\n\n",
+			t1_tm->tm_year,
+			(t1_tm->tm_mon + 1),
+			t1_tm->tm_mday
+			);
+	}
+	/*
+	 * Compute delta days.
+	 */
+	build =	elapsed_days (t1, t0);
+
+	if (FALSE == quiet)
+	{
+		printf (
+			"Build number: %d (elapsed days since last release)\n",
+			build
+			);
+		printf (
+			"ROS Version : %d.%d.%d.%d\n",
+			KERNEL_VERSION_MAJOR,
+			KERNEL_VERSION_MINOR,
+			KERNEL_VERSION_PATCH_LEVEL,
+			build
+			);
+	}
+	/*
+	 * (Over)write the include file, unless
+	 * the user switched on -p.
+	 */
+	if (FALSE == print_only)
+	{
+		write_h (build);
+	}
+	else
+	{
+		printf ("%s: no code generated", argv [0]);
+	}
+
+	return EXIT_SUCCESS;
+}
+
+
+/* EOF */

reactos/apps/utils/cabman/cabinet.h

@@ -0,0 +1,431 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS cabinet manager
+ * FILE:        apps/cabman/cabinet.h
+ * PURPOSE:     Cabinet definitions
+ */
+#ifndef __CABINET_H
+#define __CABINET_H
+
+#include <string.h>
+
+/* Debugging */
+
+#define DBG
+
+#define NORMAL_MASK    0x000000FF
+#define SPECIAL_MASK   0xFFFFFF00
+#define MIN_TRACE      0x00000001
+#define MID_TRACE      0x00000002
+#define MAX_TRACE      0x00000003
+
+#define DEBUG_MEMORY   0x00000100
+
+#ifdef DBG
+
+extern DWORD DebugTraceLevel;
+
+#define DPRINT(_t_, _x_) \
+    if (((DebugTraceLevel & NORMAL_MASK) >= _t_) || \
+        ((DebugTraceLevel & _t_) > NORMAL_MASK)) { \
+        printf("(%s:%d)(%s) ", __FILE__, __LINE__, __FUNCTION__); \
+        printf _x_ ; \
+    }
+
+#define ASSERT(_b_) { \
+    if (!(_b_)) { \
+        printf("(%s:%d)(%s) ASSERTION: ", __FILE__, __LINE__, __FUNCTION__); \
+        printf(#_b_); \
+        ExitProcess(0); \
+    } \
+}
+
+#else /* DBG */
+
+#define DPRINT(_t_, _x_)
+
+#define ASSERT(_x_)
+
+#endif /* DBG */
+
+
+/* Macros */
+
+#ifndef CopyMemory
+#define CopyMemory(destination, source, length) memcpy(destination, source, length)
+#endif /* CopyMemory */
+
+/* Cabinet constants */
+
+#define CAB_SIGNATURE        0x4643534D // "MSCF"
+#define CAB_VERSION          0x0103
+#define CAB_BLOCKSIZE        32768
+
+#define CAB_COMP_MASK        0x00FF
+#define CAB_COMP_NONE        0x0000
+#define CAB_COMP_MSZIP       0x0001
+#define CAB_COMP_QUANTUM     0x0002
+#define CAB_COMP_LZX         0x0003
+
+#define CAB_FLAG_HASPREV     0x0001
+#define CAB_FLAG_HASNEXT     0x0002
+#define CAB_FLAG_RESERVE     0x0004
+
+#define CAB_ATTRIB_READONLY  0x0001
+#define CAB_ATTRIB_HIDDEN    0x0002
+#define CAB_ATTRIB_SYSTEM    0x0004
+#define CAB_ATTRIB_VOLUME    0x0008
+#define CAB_ATTRIB_DIRECTORY 0x0010
+#define CAB_ATTRIB_ARCHIVE   0x0020
+#define CAB_ATTRIB_EXECUTE   0x0040
+#define CAB_ATTRIB_UTF_NAME  0x0080
+
+#define CAB_FILE_MAX_FOLDER  0xFFFC
+#define CAB_FILE_CONTINUED   0xFFFD
+#define CAB_FILE_SPLIT       0xFFFE
+#define CAB_FILE_PREV_NEXT   0xFFFF
+
+
+/* Cabinet structures */
+
+typedef struct _CFHEADER
+{
+    DWORD Signature;        // File signature 'MSCF' (CAB_SIGNATURE)
+    DWORD Reserved1;        // Reserved field
+    DWORD CabinetSize;      // Cabinet file size
+    DWORD Reserved2;        // Reserved field
+    DWORD FileTableOffset;  // Offset of first CFFILE
+    DWORD Reserved3;        // Reserved field
+    WORD  Version;          // Cabinet version (CAB_VERSION)
+    WORD  FolderCount;      // Number of folders
+    WORD  FileCount;        // Number of files
+    WORD  Flags;            // Cabinet flags (CAB_FLAG_*)
+    WORD  SetID;            // Cabinet set id
+    WORD  CabinetNumber;    // Zero-based cabinet number
+/* Optional fields (depends on Flags)
+    WORD  CabinetResSize    // Per-cabinet reserved area size
+    CHAR  FolderResSize     // Per-folder reserved area size
+    CHAR  FileResSize       // Per-file reserved area size
+    CHAR  CabinetReserved[] // Per-cabinet reserved area
+    CHAR  CabinetPrev[]     // Name of previous cabinet file
+    CHAR  DiskPrev[]        // Name of previous disk
+    CHAR  CabinetNext[]     // Name of next cabinet file
+    CHAR  DiskNext[]        // Name of next disk
+ */
+} CFHEADER, *PCFHEADER;
+
+
+typedef struct _CFFOLDER
+{
+    DWORD DataOffset;       // Absolute offset of first CFDATA block in this folder
+    WORD  DataBlockCount;   // Number of CFDATA blocks in this folder in this cabinet
+    WORD  CompressionType;  // Type of compression used for all CFDATA blocks in this folder
+/* Optional fields (depends on Flags)
+    CHAR  FolderReserved[]  // Per-folder reserved area
+ */
+} CFFOLDER, *PCFFOLDER;
+
+
+typedef struct _CFFILE
+{
+    DWORD FileSize;         // Uncompressed file size in bytes
+    DWORD FileOffset;       // Uncompressed offset of file in the folder
+    WORD  FileControlID;    // File control ID (CAB_FILE_*)
+    WORD  FileDate;         // File date stamp, as used by DOS
+    WORD  FileTime;         // File time stamp, as used by DOS
+    WORD  Attributes;       // File attributes (CAB_ATTRIB_*)
+    /* After this is the NULL terminated filename */
+} CFFILE, *PCFFILE;
+
+
+typedef struct _CFDATA
+{
+    DWORD Checksum;         // Checksum of CFDATA entry
+    WORD  CompSize;         // Number of compressed bytes in this block
+    WORD  UncompSize;       // Number of uncompressed bytes in this block
+/* Optional fields (depends on Flags)
+    CHAR  DataReserved[]    // Per-datablock reserved area
+ */
+} CFDATA, *PCFDATA;
+
+typedef struct _CFDATA_NODE
+{
+    struct _CFDATA_NODE *Next;
+    struct _CFDATA_NODE *Prev;
+    DWORD               ScratchFilePosition;    // Absolute offset in scratch file
+    DWORD               AbsoluteOffset;         // Absolute offset in cabinet
+    DWORD               UncompOffset;           // Uncompressed offset in folder
+    CFDATA              Data;
+} CFDATA_NODE, *PCFDATA_NODE;
+
+typedef struct _CFFOLDER_NODE
+{
+    struct _CFFOLDER_NODE *Next;
+    struct _CFFOLDER_NODE *Prev;
+    DWORD                 UncompOffset;     // File size accumulator
+    DWORD                 AbsoluteOffset;
+    DWORD                 TotalFolderSize;  // Total size of folder in current disk
+    PCFDATA_NODE          DataListHead;
+    PCFDATA_NODE          DataListTail;
+    DWORD                 Index;
+    BOOL                  Commit;           // TRUE if the folder should be committed
+    BOOL                  Delete;           // TRUE if marked for deletion
+    CFFOLDER              Folder;
+} CFFOLDER_NODE, *PCFFOLDER_NODE;
+
+typedef struct _CFFILE_NODE
+{
+    struct _CFFILE_NODE *Next;
+    struct _CFFILE_NODE *Prev;
+    CFFILE              File;
+    LPTSTR              FileName;
+    PCFDATA_NODE        DataBlock;      // First data block of file. NULL if not known
+    BOOL                Commit;         // TRUE if the file data should be committed
+    BOOL                Delete;         // TRUE if marked for deletion
+	PCFFOLDER_NODE		FolderNode;		// Folder this file belong to
+} CFFILE_NODE, *PCFFILE_NODE;
+
+
+typedef struct _CAB_SEARCH
+{
+    TCHAR        Search[MAX_PATH];   // Search criteria
+    PCFFILE_NODE Next;               // Pointer to next node
+    PCFFILE      File;               // Pointer to current CFFILE
+    LPTSTR       FileName;           // Current filename
+} CAB_SEARCH, *PCAB_SEARCH;
+
+
+/* Constants */
+
+/* Status codes */
+#define CAB_STATUS_SUCCESS       0x00000000
+#define CAB_STATUS_FAILURE       0x00000001
+#define CAB_STATUS_NOMEMORY      0x00000002
+#define CAB_STATUS_CANNOT_OPEN   0x00000003
+#define CAB_STATUS_CANNOT_CREATE 0x00000004
+#define CAB_STATUS_CANNOT_READ   0x00000005
+#define CAB_STATUS_CANNOT_WRITE  0x00000006
+#define CAB_STATUS_FILE_EXISTS   0x00000007
+#define CAB_STATUS_INVALID_CAB   0x00000008
+#define CAB_STATUS_NOFILE        0x00000009
+#define CAB_STATUS_UNSUPPCOMP    0x0000000A
+
+
+
+/* Codecs */
+
+class CCABCodec {
+public:
+    /* Default constructor */
+    CCABCodec() {};
+    /* Default destructor */
+    virtual ~CCABCodec() {};
+    /* Compresses a data block */
+    virtual ULONG Compress(PVOID OutputBuffer,
+                           PVOID InputBuffer,
+                           DWORD InputLength,
+                           PDWORD OutputLength) = 0;
+    /* Uncompresses a data block */
+    virtual ULONG Uncompress(PVOID OutputBuffer,
+                             PVOID InputBuffer,
+                             DWORD InputLength,
+                             PDWORD OutputLength) = 0;
+};
+
+
+/* Codec status codes */
+#define CS_SUCCESS      0x0000  /* All data consumed */
+#define CS_NOMEMORY     0x0001  /* Not enough free memory */
+#define CS_BADSTREAM    0x0002  /* Bad data stream */
+
+
+/* Codec indentifiers */
+#define CAB_CODEC_RAW   0x00
+#define CAB_CODEC_LZX   0x01
+#define CAB_CODEC_MSZIP 0x02
+
+
+
+/* Classes */
+
+#ifndef CAB_READ_ONLY
+
+class CCFDATAStorage {
+public:
+    /* Default constructor */
+    CCFDATAStorage();
+    /* Default destructor */
+    virtual ~CCFDATAStorage();
+    ULONG Create(LPTSTR FileName);
+    ULONG Destroy();
+    ULONG Truncate();
+    ULONG Position();
+    ULONG Seek(LONG Position);
+    ULONG ReadBlock(PCFDATA Data, PVOID Buffer, PDWORD BytesRead);
+    ULONG WriteBlock(PCFDATA Data, PVOID Buffer, PDWORD BytesWritten);
+private:
+    BOOL FileCreated;
+    HANDLE FileHandle;
+};
+
+#endif /* CAB_READ_ONLY */
+
+class CCabinet {
+public:
+    /* Default constructor */
+    CCabinet();
+    /* Default destructor */
+    virtual ~CCabinet();
+    /* Returns a pointer to the filename part of a fully qualified filename */
+    LPTSTR GetFileName(LPTSTR Path);
+    /* Removes a filename from a fully qualified filename */
+    VOID RemoveFileName(LPTSTR Path);
+    /* Normalizes a path */
+    BOOL NormalizePath(LPTSTR Path, DWORD Length);
+    /* Returns name of cabinet file */
+    LPTSTR GetCabinetName();
+    /* Sets the name of the cabinet file */
+    VOID SetCabinetName(LPTSTR FileName);
+    /* Sets destination path for extracted files */
+    VOID SetDestinationPath(LPTSTR DestinationPath);
+    /* Returns destination path */
+    LPTSTR GetDestinationPath();
+    /* Returns zero-based current disk number */
+    DWORD GetCurrentDiskNumber();
+    /* Opens the current cabinet file */
+    ULONG Open();
+    /* Closes the current open cabinet file */
+    VOID Close();
+    /* Locates the first file in the current cabinet file that matches a search criteria */
+    ULONG FindFirst(LPTSTR FileName, PCAB_SEARCH Search);
+    /* Locates the next file in the current cabinet file */
+    ULONG FindNext(PCAB_SEARCH Search);
+    /* Extracts a file from the current cabinet file */
+    ULONG ExtractFile(LPTSTR FileName);
+    /* Select codec engine to use */
+    VOID SelectCodec(ULONG Id);
+#ifndef CAB_READ_ONLY
+    /* Creates a new cabinet file */
+    ULONG NewCabinet();
+    /* Forces a new disk to be created */
+    ULONG NewDisk();
+    /* Forces a new folder to be created */
+    ULONG NewFolder();
+    /* Writes a file to scratch storage */
+    ULONG WriteFileToScratchStorage(PCFFILE_NODE FileNode);
+    /* Forces the current disk to be written */
+    ULONG WriteDisk(DWORD MoreDisks);
+    /* Commits the current disk */
+    ULONG CommitDisk(DWORD MoreDisks);
+    /* Closes the current disk */
+    ULONG CloseDisk();
+    /* Closes the current cabinet */
+    ULONG CloseCabinet();
+    /* Adds a file to the current disk */
+    ULONG AddFile(LPTSTR FileName);
+    /* Sets the maximum size of the current disk */
+    VOID SetMaxDiskSize(DWORD Size);
+#endif /* CAB_READ_ONLY */
+
+    /* Default event handlers */
+
+    /* Handler called when a file is about to be overridden */
+    virtual BOOL OnOverwrite(PCFFILE Entry, LPTSTR FileName);
+    /* Handler called when a file is about to be extracted */
+    virtual VOID OnExtract(PCFFILE Entry, LPTSTR FileName);
+    /* Handler called when a new disk is to be processed */
+    virtual VOID OnDiskChange(LPTSTR CabinetName, LPTSTR DiskLabel);
+#ifndef CAB_READ_ONLY
+    /* Handler called when a file is about to be added */
+    virtual VOID OnAdd(PCFFILE Entry, LPTSTR FileName);
+    /* Handler called when a cabinet need a name */
+    virtual BOOL OnCabinetName(ULONG Number, LPTSTR Name);
+    /* Handler called when a disk needs a label */
+    virtual BOOL OnDiskLabel(ULONG Number, LPTSTR Label);
+#endif /* CAB_READ_ONLY */
+private:
+    PCFFOLDER_NODE LocateFolderNode(DWORD Index);
+    ULONG GetAbsoluteOffset(PCFFILE_NODE File);
+    ULONG LocateFile(LPTSTR FileName, PCFFILE_NODE *File);
+    ULONG ReadString(LPTSTR String, DWORD MaxLength);
+    ULONG ReadFileTable();
+    ULONG ReadDataBlocks(PCFFOLDER_NODE FolderNode);
+    PCFFOLDER_NODE NewFolderNode();
+    PCFFILE_NODE NewFileNode();
+    PCFDATA_NODE NewDataNode(PCFFOLDER_NODE FolderNode);
+    VOID DestroyDataNodes(PCFFOLDER_NODE FolderNode);
+    VOID DestroyFileNodes();
+    VOID DestroyDeletedFileNodes();
+    VOID DestroyFolderNodes();
+    VOID DestroyDeletedFolderNodes();
+    ULONG ComputeChecksum(PVOID Buffer, UINT Size, ULONG Seed);
+    ULONG ReadBlock(PVOID Buffer, DWORD Size, PDWORD BytesRead);
+#ifndef CAB_READ_ONLY
+    ULONG InitCabinetHeader();
+    ULONG WriteCabinetHeader(BOOL MoreDisks);
+    ULONG WriteFolderEntries();
+    ULONG WriteFileEntries();
+    ULONG CommitDataBlocks(PCFFOLDER_NODE FolderNode);
+    ULONG WriteDataBlock();
+    ULONG GetAttributesOnFile(PCFFILE_NODE File);
+    ULONG SetAttributesOnFile(PCFFILE_NODE File);
+#endif /* CAB_READ_ONLY */
+    DWORD CurrentDiskNumber;    // Zero based disk number
+    TCHAR CabinetName[256];     // Filename of current cabinet
+    TCHAR CabinetPrev[256];     // Filename of previous cabinet
+    TCHAR DiskPrev[256];        // Label of cabinet in file CabinetPrev
+    TCHAR CabinetNext[256];     // Filename of next cabinet
+    TCHAR DiskNext[256];        // Label of cabinet in file CabinetNext
+    DWORD TotalHeaderSize;      // Size of header and optional fields
+    DWORD NextFieldsSize;       // Size of next cabinet name and next disk label
+    DWORD TotalFolderSize;      // Size of all folder entries
+    DWORD TotalFileSize;        // Size of all file entries
+    DWORD FolderUncompSize;     // Uncompressed size of folder
+    DWORD BytesLeftInBlock;     // Number of bytes left in current block
+    BOOL ReuseBlock;
+    TCHAR DestPath[MAX_PATH];
+    HANDLE FileHandle;
+    BOOL FileOpen;
+    CFHEADER CABHeader;
+    ULONG CabinetReserved;
+    ULONG FolderReserved;
+    ULONG DataReserved;
+    PCFFOLDER_NODE FolderListHead;
+    PCFFOLDER_NODE FolderListTail;
+    PCFFOLDER_NODE CurrentFolderNode;
+    PCFDATA_NODE CurrentDataNode;
+    PCFFILE_NODE FileListHead;
+    PCFFILE_NODE FileListTail;
+    CCABCodec *Codec;
+    ULONG CodecId;
+    BOOL CodecSelected;
+    PVOID InputBuffer;
+    PVOID CurrentIBuffer;       // Current offset in input buffer
+    DWORD CurrentIBufferSize;   // Bytes left in input buffer
+    PVOID OutputBuffer;
+    DWORD TotalCompSize;        // Total size of current CFDATA block
+    PVOID CurrentOBuffer;       // Current offset in output buffer
+    DWORD CurrentOBufferSize;   // Bytes left in output buffer
+    DWORD BytesLeftInCabinet;
+    BOOL RestartSearch;
+    DWORD LastFileOffset;       // Uncompressed offset of last extracted file
+#ifndef CAB_READ_ONLY
+    DWORD LastBlockStart;       // Uncompressed offset of last block in folder
+    DWORD MaxDiskSize;
+    DWORD DiskSize;
+    DWORD PrevCabinetNumber;    // Previous cabinet number (where split file starts)
+    BOOL CreateNewDisk;
+    BOOL CreateNewFolder;
+
+    CCFDATAStorage *ScratchFile;
+    HANDLE SourceFile;
+    BOOL ContinueFile;
+    DWORD TotalBytesLeft;
+    BOOL BlockIsSplit;          // TRUE if current data block is split
+    ULONG NextFolderNumber;     // Zero based folder number
+#endif /* CAB_READ_ONLY */
+};
+
+#endif /* __CABINET_H */
+
+/* EOF */

reactos/apps/utils/cabman/cabman.h

@@ -0,0 +1,47 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS cabinet manager
+ * FILE:        apps/cabman/cabman.h
+ * PURPOSE:     Cabinet manager header
+ */
+#ifndef __CABMAN_H
+#define __CABMAN_H
+
+#include "cabinet.h"
+#include "dfp.h"
+
+/* Cabinet manager modes */
+#define CM_MODE_CREATE   0
+#define CM_MODE_DISPLAY  1
+#define CM_MODE_EXTRACT  2
+
+
+/* Classes */
+
+class CCABManager : public CDFParser {
+public:
+    CCABManager();
+    virtual ~CCABManager();
+    BOOL ParseCmdline(INT argc, PCHAR argv[]);
+    VOID Run();
+private:
+    VOID Usage();
+    VOID CreateCabinet();
+    VOID DisplayCabinet();
+    VOID ExtractFromCabinet();
+    /* Event handlers */
+    virtual BOOL OnOverwrite(PCFFILE File, LPTSTR FileName);
+    virtual VOID OnExtract(PCFFILE File, LPTSTR FileName);
+    virtual VOID OnDiskChange(LPTSTR CabinetName, LPTSTR DiskLabel);
+    virtual VOID OnAdd(PCFFILE Entry, LPTSTR FileName);
+    /* Configuration */
+    BOOL ProcessAll;
+    DWORD Mode;
+    BOOL PromptOnOverwrite;
+    TCHAR Location[MAX_PATH];
+    TCHAR FileName[MAX_PATH];
+};
+
+#endif /* __CABMAN_H */
+
+/* EOF */

reactos/apps/utils/cabman/dff.txt

@@ -0,0 +1,55 @@
+Directive File Format for ReactOS Cabinet Manager
+-------------------------------------------------
+
+Directives begin with a period ("."), and are followed by a command
+name, and possibly blank delimited arguments. Commands and variable names are
+case insensitive.
+
+Syntax                             Description
+-------------------------------------------------------------------------------
+;                                  Anything on a line after this is a comment
+<filename> [destination]           File copy command
+.Define variable=[value]           Define variable to be equal to value (*)
+.Delete variable                   Delete a variable definition (*)
+.New Disk|Cabinet|Folder           Start a new disk, cabinet or folder (* -- new disk will work)
+.Set variable=[value]              Set variable to be equal to value (*)
+%variable%                         Substitute value of variable (*)
+<blank line>                       Blank lines are ignored
+-------------------------------------------------------------------------------
+
+
+Standard variable                  Description
+-------------------------------------------------------------------------------
+Cabinet=ON|OFF                     Turns cabinet mode on or off (* -- currently always on)
+CabinetFileCountThreshold=count	   Threshold count of files per cabinet (*)
+CabinetNamen=filename              Cabinet file name for cabinet number n
+CabinetNameTemplate=template       Cabinet file name template
+                                   * is replaced by cabinet number
+Compress=ON|OFF                    Turns compression on or off (* -- currently always on)
+CompressionType=NONE|MSZIP         Compression engine to use (* -- currently always mszip)
+DiskLabeln=label                   Printed disk label name for disk n
+DiskLabelTemplate=template         Printed disk label name template
+                                   * is replaced by disk number
+FolderFileCountThreshold=count     Threshold count of files per folder (*)
+FolderSizeThreshold=size           Threshold folder size for current folder (*)
+MaxDiskFileCount=count             Maximum count of files per disk (*)
+MaxDiskSize[n]=size		   Maximum disk size (for disk n)
+ReservePerCabinetSize=size         Amount of space to reserve in each cabinet (*)
+ReservePerDataBlockSize=size       Amount of space to reserve in each data block (*)
+ReservePerFolderSize=size          Amount of space to reserve in each folder (*)
+SourceDir=path                     Default path for source files (*)
+-------------------------------------------------------------------------------
+(*) = not implemented
+
+
+MaxDiskSize
+-----------
+0 means disk size is unlimited. Standard sizes available are:
+
+    2.88M
+    1.44M
+    1.25M
+    1.2M
+    720K
+    360K
+    CDROM

reactos/apps/utils/cabman/dfp.cpp

@@ -0,0 +1,992 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS cabinet manager
+ * FILE:        apps/cabman/dfp.cpp
+ * PURPOSE:     Directive file parser
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * NOTES:       The directive file format is similar to the
+ *              directive file format used by Microsoft's MAKECAB
+ * REVISIONS:
+ *   CSH 21/03-2001 Created
+ */
+#include <windows.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "cabinet.h"
+#include "dfp.h"
+
+
+/* CDFParser */
+
+CDFParser::CDFParser()
+/*
+ * FUNCTION: Default constructor
+ */
+{
+    FileBuffer     = NULL;
+    FileLoaded     = FALSE;
+    CurrentOffset  = 0;
+    CurrentLine    = 0;
+    CabinetCreated = FALSE;
+    DiskCreated    = FALSE;
+    FolderCreated  = FALSE;
+    CabinetName    = NULL;
+    DiskLabel      = NULL;
+    MaxDiskSize    = NULL;
+
+    MaxDiskSizeAllSet      = FALSE;
+    CabinetNameTemplateSet = FALSE;
+    DiskLabelTemplateSet   = FALSE;
+}
+
+
+CDFParser::~CDFParser()
+/*
+ * FUNCTION: Default destructor
+ */
+{
+    PCABINET_NAME CNPrev;
+    PCABINET_NAME CNNext;
+    PDISK_NUMBER DNPrev;
+    PDISK_NUMBER DNNext;
+
+    if (FileBuffer)
+        HeapFree(GetProcessHeap(), 0, FileBuffer);
+    CNNext = CabinetName;
+    while (CNNext != NULL) {
+        CNPrev = CNNext->Next;
+        HeapFree(GetProcessHeap(), 0, CNNext);
+        CNNext = CNPrev;
+    }
+    CNNext = DiskLabel;
+    while (CNNext != NULL) {
+        CNPrev = CNNext->Next;
+        HeapFree(GetProcessHeap(), 0, CNNext);
+        CNNext = CNPrev;
+    }
+    DNNext = MaxDiskSize;
+    while (DNNext != NULL) {
+        DNPrev = DNNext->Next;
+        HeapFree(GetProcessHeap(), 0, DNNext);
+        DNNext = DNPrev;
+    }
+}
+
+
+ULONG CDFParser::Load(LPTSTR FileName)
+/*
+ * FUNCTION: Loads a directive file into memory
+ * ARGUMENTS:
+ *     FileName = Pointer to name of directive file
+ * RETURNS:
+ *     Status of operation
+ */
+{
+    DWORD BytesRead;
+    LONG FileSize;
+
+    if (FileLoaded)
+        return CAB_STATUS_SUCCESS;
+
+    /* Create cabinet file, overwrite if it already exists */
+    FileHandle = CreateFile(FileName, // Create this file
+        GENERIC_READ,                 // Open for reading
+        0,                            // No sharing
+        NULL,                         // No security
+        OPEN_EXISTING,                // Open the file
+        FILE_ATTRIBUTE_NORMAL,        // Normal file
+        NULL);                        // No attribute template
+    if (FileHandle == INVALID_HANDLE_VALUE)
+        return CAB_STATUS_CANNOT_OPEN;
+
+    FileSize = GetFileSize(FileHandle, NULL);
+    if (FileSize < 0) {
+        CloseHandle(FileHandle);
+        return CAB_STATUS_CANNOT_OPEN;
+    }
+
+    FileBufferSize = (ULONG)FileSize;
+
+    FileBuffer = (PCHAR)HeapAlloc(GetProcessHeap(), 0, FileBufferSize);
+    if (!FileBuffer) {
+        CloseHandle(FileHandle);
+        return CAB_STATUS_NOMEMORY;
+    }
+
+    if (!ReadFile(FileHandle, FileBuffer, FileBufferSize, &BytesRead, NULL)) {
+        CloseHandle(FileHandle);
+        HeapFree(GetProcessHeap(), 0, FileBuffer);
+        FileBuffer = NULL;
+        return CAB_STATUS_CANNOT_READ;
+    }
+
+    CloseHandle(FileHandle);
+
+    FileLoaded = TRUE;
+
+    DPRINT(MAX_TRACE, ("File (%d bytes)\n", FileBufferSize));
+
+    return CAB_STATUS_SUCCESS;
+}
+
+
+ULONG CDFParser::Parse()
+/*
+ * FUNCTION: Parses a loaded directive file
+ * RETURNS:
+ *     Status of operation
+ */
+{
+    BOOL Command;
+    ULONG Status;
+
+    if (!FileLoaded)
+        return CAB_STATUS_NOFILE;
+
+    while (ReadLine()) {
+        Command = FALSE;
+
+        while (CurrentToken != TokenEnd) {
+            switch (CurrentToken) {
+            case TokenInteger:
+                itoa(CurrentInteger, (LPTSTR)&CurrentString, 10);
+            case TokenIdentifier:
+                if (Command) {
+                    /* Command */
+                    Status = PerformCommand();
+
+                    if (Status == CAB_STATUS_FAILURE) {
+                        printf("Directive file contains errors at line %d.\n", (UINT)CurrentLine);
+                        DPRINT(MID_TRACE, ("Error while executing command.\n"));
+                    }
+
+                    if (Status != CAB_STATUS_SUCCESS)
+                        return Status;
+                } else {
+                    /* File copy */
+                    Status = PerformFileCopy();
+
+                    if (Status == CAB_STATUS_FAILURE) {
+                        printf("Directive file contains errors at line %d.\n", (UINT)CurrentLine);
+                        DPRINT(MID_TRACE, ("Error while copying file.\n"));
+                    }
+
+                    if (Status != CAB_STATUS_SUCCESS)
+                        return Status;
+                }
+                break;
+            case TokenSpace:
+                break;
+            case TokenSemi:
+                CurrentToken = TokenEnd;
+                continue;
+            case TokenPeriod:
+                Command = TRUE;
+                break;
+            default:
+                printf("Directive file contains errors at line %d.\n", (UINT)CurrentLine);
+                DPRINT(MIN_TRACE, ("Token is (%d).\n", (UINT)CurrentToken));
+                return CAB_STATUS_SUCCESS;
+            }
+            NextToken();
+        }
+    }
+
+	printf("\nWriting cabinet. This may take a while...\n\n");
+
+    if (DiskCreated) {
+        Status = WriteDisk(FALSE);
+        if (Status == CAB_STATUS_SUCCESS)
+            Status = CloseDisk();
+        if (Status != CAB_STATUS_SUCCESS) {
+            DPRINT(MIN_TRACE, ("Cannot write disk (%d).\n", (UINT)Status));
+            return Status;
+        }
+    }
+
+    if (CabinetCreated) {
+        Status = CloseCabinet();
+        if (Status != CAB_STATUS_SUCCESS) {
+            DPRINT(MIN_TRACE, ("Cannot close cabinet (%d).\n", (UINT)Status));
+            return Status;
+        }
+    }
+
+	printf("\nDone.\n");
+
+    return CAB_STATUS_SUCCESS;
+}
+
+
+BOOL CDFParser::OnDiskLabel(ULONG Number, LPTSTR Label)
+/*
+ * FUNCTION: Called when a disk needs a label
+ * ARGUMENTS:
+ *     Number = Cabinet number that needs a label
+ *     Label  = Pointer to buffer to place label of disk
+ * RETURNS:
+ *     TRUE if a disk label was returned, FALSE if not
+ */
+{
+    TCHAR Buffer[20];
+    INT i, j;
+    TCHAR ch;
+
+    Number += 1;
+
+    DPRINT(MID_TRACE, ("Giving disk (%d) a label...\n", (UINT)Number));
+
+    if (GetDiskName(&DiskLabel, Number, Label))
+        return TRUE;
+
+    if (DiskLabelTemplateSet) {
+        j = 0;
+        lstrcpy(Label, "");
+        for (i = 0; i < lstrlen(DiskLabelTemplate); i++) {
+            ch = DiskLabelTemplate[i];
+            if (ch == '*') {
+                lstrcat(Label, itoa(Number, Buffer, 10));
+                j += lstrlen(Buffer);
+            } else {
+                Label[j] = ch;
+                j++;
+            }
+            Label[j] = '\0';
+        }
+
+        DPRINT(MID_TRACE, ("Giving disk (%s) as a label...\n", Label));
+
+        return TRUE;
+    } else
+        return FALSE;
+}
+
+
+BOOL CDFParser::OnCabinetName(ULONG Number, LPTSTR Name)
+/*
+ * FUNCTION: Called when a cabinet needs a name
+ * ARGUMENTS:
+ *     Number = Disk number that needs a name
+ *     Name   = Pointer to buffer to place name of cabinet
+ * RETURNS:
+ *     TRUE if a cabinet name was returned, FALSE if not
+ */
+{
+    TCHAR Buffer[20];
+    INT i, j;
+    TCHAR ch;
+
+    Number += 1;
+
+    DPRINT(MID_TRACE, ("Giving cabinet (%d) a name...\n", (UINT)Number));
+
+    if (GetDiskName(&CabinetName, Number, Name))
+        return TRUE;
+
+    if (CabinetNameTemplateSet) {
+        j = 0;
+        lstrcpy(Name, "");
+        for (i = 0; i < lstrlen(CabinetNameTemplate); i++) {
+            ch = CabinetNameTemplate[i];
+            if (ch == '*') {
+                lstrcat(Name, itoa(Number, Buffer, 10));
+                j += lstrlen(Buffer);
+            } else {
+                Name[j] = ch;
+                j++;
+            }
+            Name[j] = '\0';
+        }
+
+        DPRINT(MID_TRACE, ("Giving cabinet (%s) as a name...\n", Name));
+
+        return TRUE;
+    } else
+        return FALSE;
+}
+
+
+BOOL CDFParser::SetDiskName(PCABINET_NAME *List, ULONG Number, LPTSTR String)
+/*
+ * FUNCTION: Sets an entry in a list
+ * ARGUMENTS:
+ *     List   = Address of pointer to list
+ *     Number = Disk number
+ *     String = Pointer to string
+ * RETURNS:
+ *     FALSE if there was not enough free memory available
+ */
+{
+    PCABINET_NAME CN;
+
+    CN = *List;
+    while (CN != NULL) {
+        if (CN->DiskNumber == Number) {
+            lstrcpy(CN->Name, String);
+            return TRUE;
+        }
+        CN = CN->Next;
+    }
+
+    CN = (PCABINET_NAME)HeapAlloc(GetProcessHeap(), 0, sizeof(CABINET_NAME));
+    if (!CN)
+        return FALSE;
+
+    CN->DiskNumber = Number;
+    lstrcpy(CN->Name, String);
+
+    CN->Next = *List;
+    *List = CN;
+
+    return TRUE;
+}
+
+
+BOOL CDFParser::GetDiskName(PCABINET_NAME *List, ULONG Number, LPTSTR String)
+/*
+ * FUNCTION: Returns an entry in a list
+ * ARGUMENTS:
+ *     List   = Address of pointer to list
+ *     Number = Disk number
+ *     String = Address of buffer to copy string to
+ * RETURNS:
+ *     FALSE if there was not enough free memory available
+ */
+{
+    PCABINET_NAME CN;
+
+    CN = *List;
+    while (CN != NULL) {
+        if (CN->DiskNumber == Number) {
+            lstrcpy(String, CN->Name);
+            return TRUE;
+        }
+        CN = CN->Next;
+    }
+
+    return FALSE;
+}
+
+
+BOOL CDFParser::SetDiskNumber(PDISK_NUMBER *List, ULONG Number, ULONG Value)
+/*
+ * FUNCTION: Sets an entry in a list
+ * ARGUMENTS:
+ *     List   = Address of pointer to list
+ *     Number = Disk number
+ *     Value  = Value to set
+ * RETURNS:
+ *     FALSE if there was not enough free memory available
+ */
+{
+    PDISK_NUMBER DN;
+
+    DN = *List;
+    while (DN != NULL) {
+        if (DN->DiskNumber == Number) {
+            DN->Number = Value;
+            return TRUE;
+        }
+        DN = DN->Next;
+    }
+
+    DN = (PDISK_NUMBER)HeapAlloc(GetProcessHeap(), 0, sizeof(DISK_NUMBER));
+    if (!DN)
+        return FALSE;
+
+    DN->DiskNumber = Number;
+    DN->Number = Value;
+
+    DN->Next = *List;
+    *List = DN;
+
+    return TRUE;
+}
+
+
+BOOL CDFParser::GetDiskNumber(PDISK_NUMBER *List, ULONG Number, PULONG Value)
+/*
+ * FUNCTION: Returns an entry in a list
+ * ARGUMENTS:
+ *     List   = Address of pointer to list
+ *     Number = Disk number
+ *     Value  = Address of buffer to place value
+ * RETURNS:
+ *     TRUE if the entry was found
+ */
+{
+    PDISK_NUMBER DN;
+
+    DN = *List;
+    while (DN != NULL) {
+        if (DN->DiskNumber == Number) {
+            *Value = DN->Number;
+            return TRUE;
+        }
+        DN = DN->Next;
+    }
+
+    return FALSE;
+}
+
+
+BOOL CDFParser::DoDiskLabel(ULONG Number, LPTSTR Label)
+/*
+ * FUNCTION: Sets the label of a disk
+ * ARGUMENTS:
+ *     Number = Disk number
+ *     Label  = Pointer to label of disk
+ * RETURNS:
+ *     FALSE if there was not enough free memory available
+ */
+{
+    DPRINT(MID_TRACE, ("Setting label of disk (%d) to '%s'\n", (UINT)Number, Label));
+
+    return SetDiskName(&DiskLabel, Number, Label);
+}
+
+
+VOID CDFParser::DoDiskLabelTemplate(LPTSTR Template)
+/*
+ * FUNCTION: Sets a disk label template to use
+ * ARGUMENTS:
+ *     Template = Pointer to disk label template
+ */
+{
+    DPRINT(MID_TRACE, ("Setting disk label template to '%s'\n", Template));
+
+    lstrcpy(DiskLabelTemplate, Template);
+    DiskLabelTemplateSet = TRUE;
+}
+
+
+BOOL CDFParser::DoCabinetName(ULONG Number, LPTSTR Name)
+/*
+ * FUNCTION: Sets the name of a cabinet
+ * ARGUMENTS:
+ *     Number = Disk number
+ *     Name   = Pointer to name of cabinet
+ * RETURNS:
+ *     FALSE if there was not enough free memory available
+ */
+{
+    DPRINT(MID_TRACE, ("Setting name of cabinet (%d) to '%s'\n", (UINT)Number, Name));
+
+    return SetDiskName(&CabinetName, Number, Name);
+}
+
+
+VOID CDFParser::DoCabinetNameTemplate(LPTSTR Template)
+/*
+ * FUNCTION: Sets a cabinet name template to use
+ * ARGUMENTS:
+ *     Template = Pointer to cabinet name template
+ */
+{
+    DPRINT(MID_TRACE, ("Setting cabinet name template to '%s'\n", Template));
+
+    lstrcpy(CabinetNameTemplate, Template);
+    CabinetNameTemplateSet = TRUE;
+}
+
+
+ULONG CDFParser::DoMaxDiskSize(BOOL NumberValid, ULONG Number)
+/*
+ * FUNCTION: Sets the maximum disk size
+ * ARGUMENTS:
+ *     NumberValid = TRUE if disk number is valid
+ *     Number      = Disk number
+ * RETURNS:
+ *     Status of operation
+ * NOTES:
+ *     Standard sizes are 2.88M, 1.44M, 1.25M, 1.2M, 720K, 360K, and CDROM
+ */
+{
+    ULONG A, B, Value;
+
+    if (IsNextToken(TokenInteger, TRUE)) {
+
+        A = CurrentInteger;
+
+        if (IsNextToken(TokenPeriod, FALSE)) {
+            if (!IsNextToken(TokenInteger, FALSE))
+                return CAB_STATUS_FAILURE;
+
+            B = CurrentInteger;
+
+        } else
+            B = 0;
+
+        if (CurrentToken == TokenIdentifier) {
+            switch (CurrentString[0]) {
+            case 'K':
+                if (B != 0)
+                    return CAB_STATUS_FAILURE;
+
+                if (A == 720)
+                    /* 720K disk */
+                    Value = 730112;
+                else if (A == 360)
+                    /* 360K disk */
+                    Value = 362496;
+                else
+                    return CAB_STATUS_FAILURE;
+                break;
+            case 'M':
+                if (A == 1) {
+                    if (B == 44)
+                        /* 1.44M disk */
+                        Value = 1457664;
+                    else if (B == 25)
+                        /* 1.25M disk */
+                        Value = 1300000; // FIXME: Value?
+                    else if (B == 2)
+                        /* 1.2M disk */
+                        Value = 1213952;
+                    else
+                        return CAB_STATUS_FAILURE;
+                } else if (A == 2) {
+                    if (B == 88)
+                        /* 2.88M disk */
+                        Value = 2915328;
+                    else
+                        return CAB_STATUS_FAILURE;
+                } else
+                    return CAB_STATUS_FAILURE;
+                break;
+            default:
+                DPRINT(MID_TRACE, ("Bad suffix (%c)\n", CurrentString[0]));
+                return CAB_STATUS_FAILURE;
+            }
+        } else
+            Value = A;
+    } else {
+        if ((CurrentToken != TokenString) &&
+            (strcmpi(CurrentString, "CDROM") != 0))
+            return CAB_STATUS_FAILURE;
+        /* CDROM */
+        Value = 640*1024*1024;  // FIXME: Correct size for CDROM?
+    }
+
+    if (NumberValid)
+        return (SetDiskNumber(&MaxDiskSize, Number, Value)?
+            CAB_STATUS_SUCCESS : CAB_STATUS_FAILURE);
+
+    MaxDiskSizeAll    = Value;
+    MaxDiskSizeAllSet = TRUE;
+
+    SetMaxDiskSize(Value);
+
+    return CAB_STATUS_SUCCESS;
+}
+
+
+ULONG CDFParser::SetupNewDisk()
+/*
+ * FUNCTION: Sets up parameters for a new disk
+ * RETURNS:
+ *     Status of operation
+ */
+{
+    ULONG Value;
+
+    if (!GetDiskNumber(&MaxDiskSize, GetCurrentDiskNumber(), &Value))  {
+        if (MaxDiskSizeAllSet)
+            Value = MaxDiskSizeAll;
+        else
+            Value = 0;
+    }
+    SetMaxDiskSize(Value);
+
+    return CAB_STATUS_SUCCESS;
+}
+
+
+ULONG CDFParser::PerformSetCommand()
+/*
+ * FUNCTION: Performs a set variable command
+ * RETURNS:
+ *     Status of operation
+ */
+{
+    SETTYPE SetType;
+    BOOL NumberValid = FALSE;
+    ULONG Number = 0;
+
+    if (!IsNextToken(TokenIdentifier, TRUE))
+        return CAB_STATUS_FAILURE;
+
+    if (strcmpi(CurrentString, "DiskLabel") == 0)
+        SetType = stDiskLabel;
+    else if (strcmpi(CurrentString, "DiskLabelTemplate") == 0)
+        SetType = stDiskLabelTemplate;
+    else if (strcmpi(CurrentString, "CabinetName") == 0)
+        SetType = stCabinetName;
+    else if (strcmpi(CurrentString, "CabinetNameTemplate") == 0)
+        SetType = stCabinetNameTemplate;
+    else if (strcmpi(CurrentString, "MaxDiskSize") == 0)
+        SetType = stMaxDiskSize;
+    else
+        return CAB_STATUS_FAILURE;
+
+    if ((SetType == stDiskLabel) || (SetType == stCabinetName)) {
+        if (!IsNextToken(TokenInteger, FALSE))
+            return CAB_STATUS_FAILURE;
+        Number = CurrentInteger;
+
+        if (!IsNextToken(TokenEqual, TRUE))
+            return CAB_STATUS_FAILURE;
+    } else if (SetType == stMaxDiskSize) {
+        if (IsNextToken(TokenInteger, FALSE)) {
+            NumberValid = TRUE;
+            Number = CurrentInteger;
+        } else {
+            NumberValid = FALSE;
+            while (CurrentToken == TokenSpace)
+                NextToken();
+            if (CurrentToken != TokenEqual)
+                return CAB_STATUS_FAILURE;
+        }
+    } else if (!IsNextToken(TokenEqual, TRUE))
+            return CAB_STATUS_FAILURE;
+
+    if (SetType != stMaxDiskSize) {
+        if (!IsNextToken(TokenString, TRUE))
+            return CAB_STATUS_FAILURE;
+    }
+
+    switch (SetType) {
+    case stDiskLabel:
+        if (!DoDiskLabel(Number, CurrentString))
+            DPRINT(MIN_TRACE, ("Not enough available free memory.\n"));
+        return CAB_STATUS_SUCCESS;
+    case stCabinetName:
+        if (!DoCabinetName(Number, CurrentString))
+            DPRINT(MIN_TRACE, ("Not enough available free memory.\n"));
+        return CAB_STATUS_SUCCESS;
+    case stDiskLabelTemplate:
+        DoDiskLabelTemplate(CurrentString);
+        return CAB_STATUS_SUCCESS;
+    case stCabinetNameTemplate:
+        DoCabinetNameTemplate(CurrentString);
+        return CAB_STATUS_SUCCESS;
+    case stMaxDiskSize:
+        return DoMaxDiskSize(NumberValid, Number);
+    default:
+        return CAB_STATUS_FAILURE;
+    }
+}
+
+
+ULONG CDFParser::PerformNewCommand()
+/*
+ * FUNCTION: Performs a new disk|cabinet|folder command
+ * RETURNS:
+ *     Status of operation
+ */
+{
+    NEWTYPE NewType;
+    ULONG Status;
+
+    if (!IsNextToken(TokenIdentifier, TRUE))
+        return CAB_STATUS_FAILURE;
+
+    if (strcmpi(CurrentString, "Disk") == 0)
+        NewType = ntDisk;
+    else if (strcmpi(CurrentString, "Cabinet") == 0)
+        NewType = ntCabinet;
+    else if (strcmpi(CurrentString, "Folder") == 0)
+        NewType = ntFolder;
+    else
+        return CAB_STATUS_FAILURE;
+
+    switch (NewType) {
+    case ntDisk:
+        if (DiskCreated) {
+            Status = WriteDisk(TRUE);
+            if (Status == CAB_STATUS_SUCCESS)
+                Status = CloseDisk();
+            if (Status != CAB_STATUS_SUCCESS) {
+                DPRINT(MIN_TRACE, ("Cannot write disk (%d).\n", (UINT)Status));
+                return CAB_STATUS_SUCCESS;
+            }
+            DiskCreated = FALSE;
+        }
+
+        Status = NewDisk();
+        if (Status != CAB_STATUS_SUCCESS) {
+            DPRINT(MIN_TRACE, ("Cannot create disk (%d).\n", (UINT)Status));
+            return CAB_STATUS_SUCCESS;
+        }
+        DiskCreated = TRUE;
+        SetupNewDisk();
+        return CAB_STATUS_SUCCESS;
+    case ntCabinet:
+        if (DiskCreated) {
+            Status = WriteDisk(TRUE);
+            if (Status == CAB_STATUS_SUCCESS)
+                Status = CloseDisk();
+            if (Status != CAB_STATUS_SUCCESS) {
+                DPRINT(MIN_TRACE, ("Cannot write disk (%d).\n", (UINT)Status));
+                return CAB_STATUS_SUCCESS;
+            }
+            DiskCreated = FALSE;
+        }
+
+        Status = NewCabinet();
+        if (Status != CAB_STATUS_SUCCESS) {
+            DPRINT(MIN_TRACE, ("Cannot create cabinet (%d).\n", (UINT)Status));
+            return CAB_STATUS_SUCCESS;
+        }
+        DiskCreated = TRUE;
+        SetupNewDisk();
+        return CAB_STATUS_SUCCESS;
+    case ntFolder:
+        Status = NewFolder();
+		ASSERT(Status == CAB_STATUS_SUCCESS);
+		return CAB_STATUS_SUCCESS;
+    default:
+        return CAB_STATUS_FAILURE;
+    }
+}
+
+
+ULONG CDFParser::PerformCommand()
+/*
+ * FUNCTION: Performs a command
+ * RETURNS:
+ *     Status of operation
+ */
+{
+    if (strcmpi(CurrentString, "Set") == 0)
+        return PerformSetCommand();
+    if (strcmpi(CurrentString, "New") == 0)
+        return PerformNewCommand();
+
+    return CAB_STATUS_FAILURE;
+}
+
+
+ULONG CDFParser::PerformFileCopy()
+/*
+ * FUNCTION: Performs a file copy
+ * RETURNS:
+ *     Status of operation
+ */
+{
+    ULONG Status;
+    ULONG i, j;
+    TCHAR ch;
+    TCHAR SrcName[MAX_PATH];
+    TCHAR DstName[MAX_PATH];
+
+    lstrcpy(SrcName, "");
+    lstrcpy(DstName, "");
+
+    i = lstrlen(CurrentString);
+    while ((i < LineLength) &&
+        ((ch = Line[i]) != ' ') &&
+         (ch != 0x09) &&
+         (ch != ';')) {
+        CurrentString[i] = ch;
+        i++;
+    }
+    CurrentString[i] = '\0';
+    CurrentToken = TokenString;
+    CurrentChar  = i + 1;
+    lstrcpy(SrcName, CurrentString);
+
+    SkipSpaces();
+
+    if (CurrentToken != TokenEnd) {
+        j = lstrlen(CurrentString); i = 0;
+        while ((CurrentChar + i < LineLength) &&
+            ((ch = Line[CurrentChar + i]) != ' ') &&
+             (ch != 0x09) &&
+             (ch != ';')) {
+            CurrentString[j + i] = ch;
+            i++;
+        }
+        CurrentString[j + i] = '\0';
+        CurrentToken = TokenString;
+        CurrentChar += i + 1;
+        lstrcpy(DstName, CurrentString);
+    }
+
+    if (!CabinetCreated) {
+
+        DPRINT(MID_TRACE, ("Creating cabinet.\n"));
+
+        Status = NewCabinet();
+        if (Status != CAB_STATUS_SUCCESS) {
+            DPRINT(MIN_TRACE, ("Cannot create cabinet (%d).\n", (UINT)Status));
+            printf("Cannot create cabinet.\n");
+            return CAB_STATUS_FAILURE;
+        }
+        CabinetCreated = TRUE;
+
+        DPRINT(MID_TRACE, ("Creating disk.\n"));
+
+        Status = NewDisk();
+        if (Status != CAB_STATUS_SUCCESS) {
+            DPRINT(MIN_TRACE, ("Cannot create disk (%d).\n", (UINT)Status));
+            printf("Cannot create disk.\n");
+            return CAB_STATUS_FAILURE;
+        }
+        DiskCreated = TRUE;
+        SetupNewDisk();
+    }
+
+    DPRINT(MID_TRACE, ("Adding file: '%s'   destination: '%s'.\n", SrcName, DstName));
+
+    Status = AddFile(SrcName);
+    if (Status != CAB_STATUS_SUCCESS) {
+        if (Status == CAB_STATUS_CANNOT_OPEN)
+		    printf("File does not exist: %s.\n", SrcName);
+        else if (Status == CAB_STATUS_NOMEMORY)
+            printf("Insufficient memory to add file: %s.\n", SrcName);
+        else
+            printf("Cannot add file: %s (%d).\n", SrcName, Status);
+        return Status;
+    }
+
+    return CAB_STATUS_SUCCESS;
+}
+
+
+VOID CDFParser::SkipSpaces()
+/*
+ * FUNCTION: Skips any spaces in the current line
+ */
+{
+    NextToken();
+    while (CurrentToken == TokenSpace)
+        NextToken();
+}
+
+
+BOOL CDFParser::IsNextToken(TOKEN Token, BOOL NoSpaces)
+/*
+ * FUNCTION: Checks if next token equals Token
+ * ARGUMENTS:
+ *     Token  = Token to compare with
+ *     SkipSp = TRUE if spaces should be skipped
+ * RETURNS:
+ *     FALSE if next token is diffrent from Token
+ */
+{
+    if (NoSpaces)
+        SkipSpaces();
+    else
+        NextToken();
+    return (CurrentToken == Token);
+}
+
+
+BOOL CDFParser::ReadLine()
+/*
+ * FUNCTION: Reads the next line into the line buffer
+ * RETURNS:
+ *     TRUE if there is a new line, FALSE if not
+ */
+{
+    ULONG i, j;
+    TCHAR ch;
+
+    if (CurrentOffset >= FileBufferSize)
+        return FALSE;
+
+    i = 0;
+    while (((j = CurrentOffset + i) < FileBufferSize) && (i < 127) &&
+        ((ch = FileBuffer[j]) != 0x0D)) {
+        Line[i] = ch;
+        i++;
+    }
+
+    Line[i]    = '\0';
+    LineLength = i;
+    
+    if (FileBuffer[CurrentOffset + i + 1] == 0x0A)
+        CurrentOffset++;
+
+    CurrentOffset += i + 1;
+
+    CurrentChar = 0;
+
+    CurrentLine++;
+
+    NextToken();
+
+    return TRUE;
+}
+
+
+VOID CDFParser::NextToken()
+/*
+ * FUNCTION: Reads the next token from the current line
+ */
+{
+    ULONG i;
+    TCHAR ch = ' ';
+
+    if (CurrentChar >= LineLength) {
+        CurrentToken = TokenEnd;
+        return;
+    }
+
+    switch (Line[CurrentChar]) {
+    case ' ':
+    case 0x09: CurrentToken = TokenSpace;
+        break;
+    case ';': CurrentToken = TokenSemi;
+        break;
+    case '=': CurrentToken = TokenEqual;
+        break;
+    case '.': CurrentToken = TokenPeriod;
+        break;
+    case '\\': CurrentToken = TokenBackslash;
+        break;
+    case '"':
+        i = 0;
+        while ((CurrentChar + i + 1 < LineLength) &&
+            ((ch = Line[CurrentChar + i + 1]) != '"')) {
+            CurrentString[i] = ch;
+            i++;
+        }
+        CurrentString[i] = '\0';
+        CurrentToken = TokenString;
+        CurrentChar += i + 2;
+        return;
+    default:
+        i = 0;
+        while ((CurrentChar + i < LineLength) &&
+            ((ch = Line[CurrentChar + i]) >= '0') && (ch <= '9')) {
+            CurrentString[i] = ch;
+            i++;
+        }
+        if (i > 0) {
+            CurrentString[i] = '\0';
+            CurrentInteger = atoi((PCHAR)CurrentString);
+            CurrentToken = TokenInteger;
+            CurrentChar += i;
+            return;
+        }
+        i = 0;
+        while (((CurrentChar + i < LineLength) &&
+            (((ch = Line[CurrentChar + i]) >= 'a') && (ch <= 'z')) ||
+            ((ch >= 'A') && (ch <= 'Z')) || (ch == '_'))) {
+            CurrentString[i] = ch;
+            i++;
+        }
+        if (i > 0) {
+            CurrentString[i] = '\0';
+            CurrentToken = TokenIdentifier;
+            CurrentChar += i;
+            return;
+        }
+        CurrentToken = TokenUnknown;
+    }
+    CurrentChar++;
+}
+
+/* EOF */

reactos/apps/utils/cabman/dfp.h

@@ -0,0 +1,130 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS cabinet manager
+ * FILE:        apps/cabman/dfp.h
+ * PURPOSE:     Directive file parser header
+ */
+#ifndef __DFP_H
+#define __DFP_H
+
+#include "cabinet.h"
+
+typedef struct _CABINET_NAME {
+    struct _CABINET_NAME *Next;
+    ULONG DiskNumber;
+    TCHAR Name[128];
+} CABINET_NAME, *PCABINET_NAME;
+
+typedef struct _DISK_NUMBER {
+    struct _DISK_NUMBER *Next;
+    ULONG DiskNumber;
+    ULONG Number;
+} DISK_NUMBER, *PDISK_NUMBER;
+
+typedef enum {
+    TokenUnknown,
+    TokenInteger,
+    TokenIdentifier,
+    TokenString,
+    TokenSpace,
+    TokenSemi,
+    TokenEqual,
+    TokenPeriod,
+    TokenBackslash,
+    TokenEnd,
+} TOKEN;
+
+
+typedef enum {
+    stCabinetName,
+    stCabinetNameTemplate,
+    stDiskLabel,
+    stDiskLabelTemplate,
+    stMaxDiskSize
+} SETTYPE;
+
+
+typedef enum {
+    ntDisk,
+    ntCabinet,
+    ntFolder,
+} NEWTYPE;
+
+
+/* Classes */
+
+class CDFParser : public CCabinet {
+public:
+    CDFParser();
+    virtual ~CDFParser();
+    ULONG Load(LPTSTR FileName);
+    ULONG Parse();
+private:
+    /* Event handlers */
+    virtual BOOL OnDiskLabel(ULONG Number, LPTSTR Label);
+    virtual BOOL OnCabinetName(ULONG Number, LPTSTR Name);
+
+    BOOL SetDiskName(PCABINET_NAME *List, ULONG Number, LPTSTR String);
+    BOOL GetDiskName(PCABINET_NAME *List, ULONG Number, LPTSTR String);
+    BOOL SetDiskNumber(PDISK_NUMBER *List, ULONG Number, ULONG Value);
+    BOOL GetDiskNumber(PDISK_NUMBER *List, ULONG Number, PULONG Value);
+    BOOL DoDiskLabel(ULONG Number, LPTSTR Label);
+    VOID DoDiskLabelTemplate(LPTSTR Template);
+    BOOL DoCabinetName(ULONG Number, LPTSTR Name);
+    VOID DoCabinetNameTemplate(LPTSTR Template);
+    ULONG DoMaxDiskSize(BOOL NumberValid, ULONG Number);
+    ULONG SetupNewDisk();
+    ULONG PerformSetCommand();
+    ULONG PerformNewCommand();
+    ULONG PerformCommand();
+    ULONG PerformFileCopy();
+    VOID SkipSpaces();
+    BOOL IsNextToken(TOKEN Token, BOOL NoSpaces);
+    BOOL ReadLine();
+    VOID NextToken();
+    /* Parsing */
+    BOOL FileLoaded;
+    HANDLE FileHandle;
+    PCHAR FileBuffer;
+    DWORD FileBufferSize;
+    ULONG CurrentOffset;
+    TCHAR Line[128];
+    ULONG LineLength;
+    ULONG CurrentLine;
+    ULONG CurrentChar;
+    /* Token */
+    TOKEN CurrentToken;
+    ULONG CurrentInteger;
+    TCHAR CurrentString[256];
+
+    /* State */
+    BOOL CabinetCreated;
+    BOOL DiskCreated;
+    BOOL FolderCreated;
+    /* Standard directive variable */
+    BOOL Cabinet;
+    ULONG CabinetFileCountThreshold;
+    PCABINET_NAME CabinetName;
+    BOOL CabinetNameTemplateSet;
+    TCHAR CabinetNameTemplate[128];
+    BOOL Compress;
+    ULONG CompressionType;
+    PCABINET_NAME DiskLabel;
+    BOOL DiskLabelTemplateSet;
+    TCHAR DiskLabelTemplate[128];
+    ULONG FolderFileCountThreshold;
+    ULONG FolderSizeThreshold;
+    ULONG MaxCabinetSize;
+    ULONG MaxDiskFileCount;
+    PDISK_NUMBER MaxDiskSize;
+    BOOL MaxDiskSizeAllSet;
+    ULONG MaxDiskSizeAll;
+    ULONG ReservePerCabinetSize;
+    ULONG ReservePerDataBlockSize;
+    ULONG ReservePerFolderSize;
+    TCHAR SourceDir[256];
+};
+
+#endif /* __DFP_H */
+
+/* EOF */

reactos/apps/utils/cabman/main.cpp

@@ -0,0 +1,493 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS cabinet manager
+ * FILE:        apps/cabman/main.cpp
+ * PURPOSE:     Main program
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH 21/03-2001 Created
+ */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <conio.h>
+#include <windows.h>
+#include <reactos/buildno.h>
+#include "cabman.h"
+
+
+#ifdef DBG
+
+DWORD DebugTraceLevel = MIN_TRACE;
+//DWORD DebugTraceLevel = MID_TRACE;
+//DWORD DebugTraceLevel = MAX_TRACE;
+
+#endif /* DBG */
+
+
+#define CM_VERSION  KERNEL_VERSION_STR
+
+
+LPTSTR Pad(LPTSTR Str, CHAR PadChar, UINT Length)
+/*
+ * FUNCTION: Pads a string with a character to make a given length
+ * ARGUMENTS:
+ *     Str     = Pointer to string to pad
+ *     PadChar = Character to pad with
+ *     Length  = Disired length of string
+ * RETURNS:
+ *     Pointer to string
+ * NOTES:
+ *     Str must be at least Length + 1 bytes
+ */
+{
+    UINT Len;
+
+    Len = lstrlen(Str);
+
+    if (Len < Length) {
+        memcpy(&Str[Length - Len], Str, Len + 1);
+        memset(Str, PadChar, Length - Len);
+    }
+    return Str;
+}
+
+
+LPTSTR Date2Str(LPTSTR Str, WORD Date)
+/*
+ * FUNCTION: Converts a DOS style date to a string
+ * ARGUMENTS:
+ *     Str  = Pointer to destination string
+ *     Date = DOS style date
+ * RETURNS:
+ *     Pointer to string
+ */
+{
+    DWORD dw;
+
+    /* Month */
+    Str[0] = (CHAR)('0' + ((Date & 0x01E0) >> 5) / 10);
+    Str[1] = (CHAR)('0' + ((Date & 0x01E0) >> 5) % 10);
+    Str[2] = '-';
+    /* Day */
+    Str[3] = (CHAR)('0' + (Date & 0x001F) / 10);
+    Str[4] = (CHAR)('0' + (Date & 0x001F) % 10);
+    Str[5] = '-';
+    /* Year */
+    dw = 1980 + ((Date & 0xFE00) >> 9);
+    Str[6] = (CHAR)('0' + dw / 1000); dw %= 1000;
+    Str[7] = (CHAR)('0' + dw / 100);  dw %= 100;
+    Str[8] = (CHAR)('0' + dw / 10);   dw %= 10;
+    Str[9] = (CHAR)('0' + dw % 10);
+    Str[10] = '\0';
+    return Str;
+}
+
+
+LPTSTR Time2Str(LPTSTR Str, WORD Time)
+/*
+ * FUNCTION: Converts a DOS style time to a string
+ * ARGUMENTS:
+ *     Str  = Pointer to destination string
+ *     Time = DOS style time
+ * RETURNS:
+ *     Pointer to string
+ */
+{
+    BOOL PM;
+    DWORD Hour;
+    DWORD dw;
+
+    Hour = ((Time & 0xF800) >> 11);
+    PM = (Hour >= 12);
+    Hour %= 12;
+    if (Hour == 0)
+        Hour = 12;
+
+    if (Hour >= 10)
+        Str[0] = (CHAR)('0' + Hour / 10);
+    else Str[0] = ' ';
+    Str[1] = (CHAR)('0' + Hour % 10);
+    Str[2] = ':';
+    /* Minute */
+    Str[3] = (CHAR)('0' + ((Time & 0x07E0) >> 5) / 10);
+    Str[4] = (CHAR)('0' + ((Time & 0x07E0) >> 5) % 10);
+    Str[5] = ':';
+    /* Second */
+    dw = 2 * (Time & 0x001F);
+    Str[6] = (CHAR)('0' + dw / 10);
+    Str[7] = (CHAR)('0' + dw % 10);
+
+    Str[8] = PM? 'p' : 'a';
+    Str[9] = '\0';
+    return Str;
+}
+
+
+LPTSTR Attr2Str(LPTSTR Str, WORD Attr)
+/*
+ * FUNCTION: Converts attributes to a string
+ * ARGUMENTS:
+ *     Str  = Pointer to destination string
+ *     Attr = Attributes
+ * RETURNS:
+ *     Pointer to string
+ */
+{
+    /* Archive */
+    if (Attr & CAB_ATTRIB_ARCHIVE)
+        Str[0] = 'A';
+    else
+        Str[0] = '-';
+
+    /* Hidden */
+    if (Attr & CAB_ATTRIB_HIDDEN)
+        Str[1] = 'H';
+    else
+        Str[1] = '-';
+
+    /* Read only */
+    if (Attr & CAB_ATTRIB_READONLY)
+        Str[2] = 'R';
+    else
+        Str[2] = '-';
+
+    /* System */
+    if (Attr & CAB_ATTRIB_SYSTEM)
+        Str[3] = 'S';
+    else
+        Str[3] = '-';
+
+    Str[4] = '\0';
+    return Str;
+}
+
+
+/* CCABManager */
+
+CCABManager::CCABManager()
+/*
+ * FUNCTION: Default constructor
+ */
+{
+    ProcessAll        = FALSE;
+    Mode              = CM_MODE_DISPLAY;
+    PromptOnOverwrite = TRUE;
+}
+
+
+CCABManager::~CCABManager()
+/*
+ * FUNCTION: Default destructor
+ */
+{
+}
+
+
+VOID CCABManager::Usage()
+/*
+ * FUNCTION: Display usage information on screen
+ */
+{
+    printf("ReactOS Cabinet Manager - Version %s\n\n", CM_VERSION);
+    printf("CABMAN [/D | /E] [/A] [/L dir] [/Y] cabinet [filename ...]\n");
+    printf("CABMAN /C dirfile\n");
+    printf("  cabinet   Cabinet file.\n");
+    printf("  filename  Name of the file to extract from the cabinet.\n");
+    printf("            Wild cards and multiple filenames\n");
+    printf("            (separated by blanks) may be used.\n\n");
+    printf("  dirfile   Name of the directive file to use.\n\n");
+    
+
+    printf("  /A        Process ALL cabinets. Follows cabinet chain\n");
+    printf("            starting in first cabinet mentioned.\n");
+    printf("  /C        Create cabinet.\n");
+    printf("  /D        Display cabinet directory.\n");
+    printf("  /E        Extract files from cabinet.\n");
+    printf("  /L dir    Location to place extracted files\n");
+    printf("            (default is current directory).\n");
+    printf("  /Y        Do not prompt before overwriting an existing file.\n\n");
+}
+
+
+BOOL CCABManager::ParseCmdline(INT argc, PCHAR argv[])
+/*
+ * FUNCTION: Parse command line arguments
+ * ARGUMENTS:
+ *     argc = Number of arguments on command line
+ *     argv = Pointer to list of command line arguments
+ * RETURNS:
+ *    TRUE if command line arguments was successfully parsed, false if not
+ */
+{
+    INT i;
+	BOOL ShowUsage;
+    BOOL FoundCabinet = FALSE;
+	
+    ShowUsage = (argc < 2);
+
+	for (i = 1; i < argc; i++) {
+		if (argv[i][0] == '/') {
+			switch (argv[i][1]) {
+            case 'a':
+            case 'A': ProcessAll = TRUE; break;
+            case 'c':
+            case 'C': Mode = CM_MODE_CREATE; break;
+            case 'd':
+            case 'D': Mode = CM_MODE_DISPLAY; break;
+            case 'e':
+			case 'E': Mode = CM_MODE_EXTRACT; break;
+            case 'l':
+			case 'L':
+                if (argv[i][2] == ' ') {
+                    i++;
+                    SetDestinationPath((LPTSTR)&argv[i][0]);
+                } else
+                    SetDestinationPath((LPTSTR)&argv[i][1]);
+                break;
+            case 'y':
+			case 'Y': PromptOnOverwrite = FALSE; break;
+			default:
+                printf("Bad parameter %s.\n", argv[i]);
+                return FALSE;
+			}
+		} else {
+			if ((FoundCabinet) || (Mode == CM_MODE_CREATE)) {
+                /* FIXME: There may be many of these if Mode != CM_MODE_CREATE */
+                lstrcpy((LPTSTR)FileName, argv[i]);
+            } else {
+                SetCabinetName(argv[i]);
+                FoundCabinet = TRUE;
+            }
+		}
+    }
+
+	if (ShowUsage) {
+		Usage();
+		return FALSE;
+	}
+
+    /* FIXME */
+    SelectCodec(CAB_CODEC_MSZIP);
+
+	return TRUE;
+}
+
+
+VOID CCABManager::CreateCabinet()
+/*
+ * FUNCTION: Create cabinet
+ */
+{
+    ULONG Status;
+
+    Status = Load((LPTSTR)&FileName);
+    if (Status != CAB_STATUS_SUCCESS) {
+        printf("Specified directive file could not be found: %s.\n", (LPTSTR)&FileName);
+        return;
+    }
+
+    Parse();
+}
+
+
+VOID CCABManager::DisplayCabinet()
+/*
+ * FUNCTION: Display cabinet contents
+ */
+{
+    CAB_SEARCH Search;
+    TCHAR Str[20];
+    DWORD FileCount = 0;
+    DWORD ByteCount = 0;
+
+    if (Open() == CAB_STATUS_SUCCESS) {
+        printf("Cabinet %s\n\n", GetCabinetName());
+
+        if (FindFirst("", &Search) == CAB_STATUS_SUCCESS) {
+            do {
+                if (Search.File->FileControlID != CAB_FILE_CONTINUED) {
+                    printf("%s ", Date2Str((LPTSTR)&Str, Search.File->FileDate));
+                    printf("%s ", Time2Str((LPTSTR)&Str, Search.File->FileTime));
+                    printf("%s ", Attr2Str((LPTSTR)&Str, Search.File->Attributes));
+                    printf("%s ", Pad(itoa(Search.File->FileSize, (LPTSTR)&Str, 10), ' ', 13));
+                    printf("%s\n", Search.FileName);
+
+                    FileCount++;
+                    ByteCount += Search.File->FileSize;
+                }
+            } while (FindNext(&Search) == CAB_STATUS_SUCCESS);
+        }
+
+        if (FileCount > 0) {
+            if (FileCount == 1)
+                printf("                 1 file    ");
+            else
+                printf("      %s files   ", 
+                    Pad(itoa(FileCount, (LPTSTR)&Str, 10), ' ', 12));
+
+            if (ByteCount == 1)
+                printf("           1 byte\n");
+            else
+                printf("%s bytes\n",
+                    Pad(itoa(ByteCount, (LPTSTR)&Str, 10), ' ', 12));
+        } else {
+            /* There should be at least one file in a cabinet */
+            printf("No files in cabinet.");
+        }
+    } else
+        printf("Cannot not open file: %s\n", GetCabinetName());
+}
+
+
+VOID CCABManager::ExtractFromCabinet()
+/*
+ * FUNCTION: Extract file(s) from cabinet
+ */
+{
+    CAB_SEARCH Search;
+    ULONG Status;
+
+    if (Open() == CAB_STATUS_SUCCESS) {
+        printf("Cabinet %s\n\n", GetCabinetName());
+
+        if (FindFirst("", &Search) == CAB_STATUS_SUCCESS) {
+            do {
+                switch (Status = ExtractFile(Search.FileName)) {
+                    case CAB_STATUS_SUCCESS:
+                        break;
+                    case CAB_STATUS_INVALID_CAB:
+                        printf("Cabinet contains errors.\n");
+                        return;
+                    case CAB_STATUS_UNSUPPCOMP:
+                        printf("Cabinet uses unsupported compression type.\n");
+                        return;
+                    case CAB_STATUS_CANNOT_WRITE:
+                        printf("You've run out of free space on the destination volume or the volume is damaged.\n");
+                        return;
+                    default:
+                        printf("Unspecified error code (%d).\n", (UINT)Status);
+                        return;
+                }
+            } while (FindNext(&Search) == CAB_STATUS_SUCCESS);
+        }
+    } else
+        printf("Cannot not open file: %s.\n", GetCabinetName());
+}
+
+
+VOID CCABManager::Run()
+/*
+ * FUNCTION: Process cabinet
+ */
+{
+    printf("ReactOS Cabinet Manager - Version %s\n\n", CM_VERSION);
+
+    switch (Mode) {
+    case CM_MODE_CREATE:  CreateCabinet(); break;
+    case CM_MODE_DISPLAY: DisplayCabinet(); break;
+    case CM_MODE_EXTRACT: ExtractFromCabinet(); break;
+    default:
+        break;
+    }
+    printf("\n");
+}
+
+
+/* Event handlers */
+
+BOOL CCABManager::OnOverwrite(PCFFILE File,
+                              LPTSTR FileName)
+/*
+ * FUNCTION: Called when extracting a file and it already exists
+ * ARGUMENTS:
+ *     File     = Pointer to CFFILE for file being extracted
+ *     Filename = Pointer to buffer with name of file (full path)
+ * RETURNS
+ *     TRUE if the file should be overwritten, FALSE if not
+ */
+{
+    TCHAR ch;
+
+    if (Mode == CM_MODE_CREATE)
+        return TRUE;
+
+    /* Should we prompt on overwrite? */
+    if (!PromptOnOverwrite)
+        return TRUE;
+
+    /* Ask if file should be overwritten */
+    printf("Overwrite %s (Yes/No/All)? ", GetFileName(FileName));
+    
+    for (;;) {
+        ch = _getch();
+        switch (ch) {
+            case 'Y':
+            case 'y': printf("%c\n", ch); return TRUE;
+            case 'N':
+            case 'n': printf("%c\n", ch); return FALSE;
+            case 'A':
+            case 'a': printf("%c\n", ch); PromptOnOverwrite = FALSE; return TRUE;
+        }
+    }
+}
+
+
+VOID CCABManager::OnExtract(PCFFILE File,
+                            LPTSTR FileName)
+/*
+ * FUNCTION: Called just before extracting a file
+ * ARGUMENTS:
+ *     File     = Pointer to CFFILE for file being extracted
+ *     FileName = Pointer to buffer with name of file (full path)
+ */
+{
+    printf("Extracting %s\n", GetFileName(FileName));
+}
+
+
+
+VOID CCABManager::OnDiskChange(LPTSTR CabinetName,
+                               LPTSTR DiskLabel)
+/*
+ * FUNCTION: Called when a new disk is to be processed
+ * ARGUMENTS:
+ *     CabinetName = Pointer to buffer with name of cabinet
+ *     DiskLabel   = Pointer to buffer with label of disk
+ */
+{
+    printf("\nChanging to cabinet %s - %s\n\n", CabinetName, DiskLabel);
+}
+
+
+VOID CCABManager::OnAdd(PCFFILE File,
+                        LPTSTR FileName)
+/*
+ * FUNCTION: Called just before adding a file to a cabinet
+ * ARGUMENTS:
+ *     File     = Pointer to CFFILE for file being added
+ *     FileName = Pointer to buffer with name of file (full path)
+ */
+{
+    printf("Adding %s\n", GetFileName(FileName));
+}
+
+
+INT main(INT argc, PCHAR argv[])
+/*
+ * FUNCTION: Main entry point
+ * ARGUMENTS:
+ *     argc = Number of arguments on command line
+ *     argv = Pointer to list of command line arguments
+ */
+{
+    CCABManager CABMgr;
+
+    if (CABMgr.ParseCmdline(argc, argv))
+        CABMgr.Run();
+
+    return 0;
+}
+
+/* EOF */

reactos/apps/utils/cabman/makefile

@@ -0,0 +1,54 @@
+#
+# Makefile for ReactOS Cabinet Manager
+#
+PATH_TO_TOP = ../..
+
+ZLIB_OBJECTS    = zlib/adler32.o zlib/deflate.o zlib/infblock.o zlib/infcodes.o \
+                  zlib/inflate.o zlib/inftrees.o zlib/infutil.o zlib/inffast.o \
+                  zlib/trees.o zlib/zutil.o
+ENGINE_OBJECTS  = $(ZLIB_OBJECTS) cabinet.o mszip.o raw.o
+TEST_OBJECTS    = $(ENGINE_OBJECTS) test.o
+OBJECTS         = $(ENGINE_OBJECTS) main.o dfp.o
+TARGET          = cabman
+PROGS           = $(TARGET).exe test.exe
+
+CFLAGS 		+= -O3
+
+CLEAN_FILES = *.o zlib/*.o $(TARGET).exe $(TARGET).sym test.exe test.sym
+
+
+all: $(PROGS)
+
+clean: 
+	- $(RM) $(CLEAN_FILES)
+
+.phony: clean 
+
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+
+$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
+ifeq ($(DOSCLI),yes)
+	$(CP) $* $(FLOPPY_DIR)\apps\$*
+else
+	$(CP) $* $(FLOPPY_DIR)/apps/$*
+endif
+
+dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
+
+$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
+ifeq ($(DOSCLI),yes)
+	$(CP) $* ..\..\$(DIST_DIR)\apps\$*
+else
+	$(CP) $* ../../$(DIST_DIR)/apps/$*
+endif
+
+$(TARGET).exe: $(OBJECTS)
+	$(CC) $(OBJECTS) -o $(TARGET).exe
+	$(NM) --numeric-sort $(TARGET).exe > $(TARGET).sym
+	
+test.exe: $(TEST_OBJECTS)
+	$(CC) $(TEST_OBJECTS) -o test.exe
+	$(NM) --numeric-sort test.exe > test.sym
+
+include ../../rules.mak
+

reactos/apps/utils/cabman/mszip.cpp

@@ -0,0 +1,172 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS cabinet manager
+ * FILE:        apps/cabman/mszip.cpp
+ * PURPOSE:     CAB codec for MSZIP compressed data
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * NOTES:       The ZLIB does the real work. Get the full version
+ *              from http://www.cdrom.com/pub/infozip/zlib/
+ * REVISIONS:
+ *   CSH 21/03-2001 Created
+ */
+#include <windows.h>
+#include <stdio.h>
+#include "mszip.h"
+
+
+/* Memory functions */
+
+voidpf MSZipAlloc(voidpf opaque, uInt items, uInt size)
+{
+    DPRINT(DEBUG_MEMORY, ("items = (%d)  size = (%d)\n", items, size));
+    return HeapAlloc(GetProcessHeap(), 0, items * size);
+}
+
+void MSZipFree (voidpf opaque, voidpf address)
+{
+    DPRINT(DEBUG_MEMORY, ("\n"));
+    HeapFree(GetProcessHeap(), 0, address);
+}
+
+
+/* CMSZipCodec */
+
+CMSZipCodec::CMSZipCodec()
+/*
+ * FUNCTION: Default constructor
+ */
+{
+    ZStream.zalloc = MSZipAlloc;
+    ZStream.zfree  = MSZipFree;
+    ZStream.opaque = (voidpf)0;
+}
+
+
+CMSZipCodec::~CMSZipCodec()
+/*
+ * FUNCTION: Default destructor
+ */
+{
+}
+
+
+ULONG CMSZipCodec::Compress(PVOID OutputBuffer,
+                            PVOID InputBuffer,
+                            DWORD InputLength,
+                            PDWORD OutputLength)
+/*
+ * FUNCTION: Compresses data in a buffer
+ * ARGUMENTS:
+ *     OutputBuffer   = Pointer to buffer to place compressed data
+ *     InputBuffer    = Pointer to buffer with data to be compressed
+ *     InputLength    = Length of input buffer
+ *     OutputLength   = Address of buffer to place size of compressed data
+ */
+{
+    PUSHORT Magic;
+
+    DPRINT(MAX_TRACE, ("InputLength (%d).\n", InputLength));
+
+    Magic  = (PUSHORT)OutputBuffer;
+    *Magic = MSZIP_MAGIC;
+
+    ZStream.next_in   = (PUCHAR)InputBuffer;
+    ZStream.avail_in  = InputLength;
+    ZStream.next_out  = (PUCHAR)((ULONG)OutputBuffer + 2);
+    ZStream.avail_out = CAB_BLOCKSIZE + 12;
+
+    /* WindowBits is passed < 0 to tell that there is no zlib header */
+    Status = deflateInit2(&ZStream,
+                          Z_BEST_COMPRESSION,
+                          Z_DEFLATED,
+                          -MAX_WBITS,
+                          8, /* memLevel */
+                          Z_DEFAULT_STRATEGY);
+    if (Status != Z_OK) {
+        DPRINT(MIN_TRACE, ("deflateInit() returned (%d).\n", Status));
+        return CS_NOMEMORY;
+    }
+
+    Status = deflate(&ZStream, Z_FINISH);
+    if ((Status != Z_OK) && (Status != Z_STREAM_END)) {
+        DPRINT(MIN_TRACE, ("deflate() returned (%d) (%s).\n", Status, ZStream.msg));
+        if (Status == Z_MEM_ERROR)
+            return CS_NOMEMORY;
+        return CS_BADSTREAM;
+    }
+
+    *OutputLength = ZStream.total_out + 2;
+
+    Status = deflateEnd(&ZStream);
+    if (Status != Z_OK) {
+        DPRINT(MIN_TRACE, ("deflateEnd() returned (%d).\n", Status));
+        return CS_BADSTREAM;
+    }
+
+    return CS_SUCCESS;
+}
+
+
+ULONG CMSZipCodec::Uncompress(PVOID OutputBuffer,
+                              PVOID InputBuffer,
+                              DWORD InputLength,
+                              PDWORD OutputLength)
+/*
+ * FUNCTION: Uncompresses data in a buffer
+ * ARGUMENTS:
+ *     OutputBuffer = Pointer to buffer to place uncompressed data
+ *     InputBuffer  = Pointer to buffer with data to be uncompressed
+ *     InputLength  = Length of input buffer
+ *     OutputLength = Address of buffer to place size of uncompressed data
+ */
+{
+    USHORT Magic;
+
+    DPRINT(MAX_TRACE, ("InputLength (%d).\n", InputLength));
+
+    Magic = *((PUSHORT)InputBuffer);
+
+    if (Magic != MSZIP_MAGIC) {
+        DPRINT(MID_TRACE, ("Bad MSZIP block header magic (0x%X)\n", Magic));
+        return CS_BADSTREAM;
+    }
+	
+	ZStream.next_in   = (PUCHAR)((ULONG)InputBuffer + 2);
+	ZStream.avail_in  = InputLength - 2;
+	ZStream.next_out  = (PUCHAR)OutputBuffer;
+    ZStream.avail_out = CAB_BLOCKSIZE + 12;
+
+    /* WindowBits is passed < 0 to tell that there is no zlib header.
+     * Note that in this case inflate *requires* an extra "dummy" byte
+     * after the compressed stream in order to complete decompression and
+     * return Z_STREAM_END.
+     */
+    Status = inflateInit2(&ZStream, -MAX_WBITS);
+    if (Status != Z_OK) {
+        DPRINT(MIN_TRACE, ("inflateInit2() returned (%d).\n", Status));
+        return CS_BADSTREAM;
+    }
+
+    while ((ZStream.total_out < CAB_BLOCKSIZE + 12) &&
+        (ZStream.total_in < InputLength - 2)) {
+        Status = inflate(&ZStream, Z_NO_FLUSH);
+        if (Status == Z_STREAM_END) break;
+        if (Status != Z_OK) {
+            DPRINT(MIN_TRACE, ("inflate() returned (%d) (%s).\n", Status, ZStream.msg));
+            if (Status == Z_MEM_ERROR)
+                return CS_NOMEMORY;
+            return CS_BADSTREAM;
+        }
+    }
+
+    *OutputLength = ZStream.total_out;
+
+    Status = inflateEnd(&ZStream);
+    if (Status != Z_OK) {
+        DPRINT(MIN_TRACE, ("inflateEnd() returned (%d).\n", Status));
+        return CS_BADSTREAM;
+    }
+    return CS_SUCCESS;
+}
+
+/* EOF */

reactos/apps/utils/cabman/mszip.h

@@ -0,0 +1,41 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS cabinet manager
+ * FILE:        apps/cabman/mszip.h
+ * PURPOSE:     CAB codec for MSZIP compressed data
+ */
+#ifndef __MSZIP_H
+#define __MSZIP_H
+
+#include "cabinet.h"
+#include "zlib/zlib.h"
+
+#define MSZIP_MAGIC 0x4B43
+
+
+/* Classes */
+
+class CMSZipCodec : public CCABCodec {
+public:
+    /* Default constructor */
+    CMSZipCodec();
+    /* Default destructor */
+    virtual ~CMSZipCodec();
+    /* Compresses a data block */
+    virtual ULONG Compress(PVOID OutputBuffer,
+                           PVOID InputBuffer,
+                           DWORD InputLength,
+                           PDWORD OutputLength);
+    /* Uncompresses a data block */
+    virtual ULONG Uncompress(PVOID OutputBuffer,
+                             PVOID InputBuffer,
+                             DWORD InputLength,
+                             PDWORD OutputLength);
+private:
+    INT Status;
+    z_stream ZStream; /* Zlib stream */
+};
+
+#endif /* __MSZIP_H */
+
+/* EOF */

reactos/apps/utils/cabman/raw.cpp

@@ -0,0 +1,69 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS cabinet manager
+ * FILE:        apps/cabman/raw.cpp
+ * PURPOSE:     CAB codec for uncompressed "raw" data
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH 21/03-2001 Created
+ */
+#include <windows.h>
+#include "raw.h"
+
+
+/* CRawCodec */
+
+CRawCodec::CRawCodec()
+/*
+ * FUNCTION: Default constructor
+ */
+{
+}
+
+
+CRawCodec::~CRawCodec()
+/*
+ * FUNCTION: Default destructor
+ */
+{
+}
+
+
+ULONG CRawCodec::Compress(PVOID OutputBuffer,
+                          PVOID InputBuffer,
+                          DWORD InputLength,
+                          PDWORD OutputLength)
+/*
+ * FUNCTION: Compresses data in a buffer
+ * ARGUMENTS:
+ *     OutputBuffer = Pointer to buffer to place compressed data
+ *     InputBuffer  = Pointer to buffer with data to be compressed
+ *     InputLength  = Length of input buffer
+ *     OutputLength = Address of buffer to place size of compressed data
+ */
+{
+    CopyMemory(OutputBuffer, InputBuffer, InputLength);
+    *OutputLength = InputLength;
+    return CS_SUCCESS;
+}
+
+
+ULONG CRawCodec::Uncompress(PVOID OutputBuffer,
+                            PVOID InputBuffer,
+                            DWORD InputLength,
+                            PDWORD OutputLength)
+/*
+ * FUNCTION: Uncompresses data in a buffer
+ * ARGUMENTS:
+ *     OutputBuffer = Pointer to buffer to place uncompressed data
+ *     InputBuffer  = Pointer to buffer with data to be uncompressed
+ *     InputLength  = Length of input buffer
+ *     OutputLength = Address of buffer to place size of uncompressed data
+ */
+{
+    CopyMemory(OutputBuffer, InputBuffer, InputLength);
+    *OutputLength = InputLength;
+    return CS_SUCCESS;
+}
+
+/* EOF */

reactos/apps/utils/cabman/raw.h

@@ -0,0 +1,35 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS cabinet manager
+ * FILE:        apps/cabman/raw.h
+ * PURPOSE:     CAB codec for uncompressed data
+ */
+#ifndef __RAW_H
+#define __RAW_H
+
+#include "cabinet.h"
+
+
+/* Classes */
+
+class CRawCodec : public CCABCodec {
+public:
+    /* Default constructor */
+    CRawCodec();
+    /* Default destructor */
+    virtual ~CRawCodec();
+    /* Compresses a data block */
+    virtual ULONG Compress(PVOID OutputBuffer,
+                           PVOID InputBuffer,
+                           DWORD InputLength,
+                           PDWORD OutputLength);
+    /* Uncompresses a data block */
+    virtual ULONG Uncompress(PVOID OutputBuffer,
+                             PVOID InputBuffer,
+                             DWORD InputLength,
+                             PDWORD OutputLength);
+};
+
+#endif /* __RAW_H */
+
+/* EOF */

reactos/apps/utils/cabman/test.cpp

@@ -0,0 +1,164 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     Test program for cabinet classes
+ * FILE:        apps/cabman/test.cpp
+ * PURPOSE:     Test program
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH 21/03-2001 Created
+ */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <conio.h>
+#include <windows.h>
+#include "test.h"
+
+
+#ifdef DBG
+
+DWORD DebugTraceLevel = MIN_TRACE;
+//DWORD DebugTraceLevel = MID_TRACE;
+//DWORD DebugTraceLevel = MAX_TRACE;
+
+#endif /* DBG */
+
+
+/* CCABManager */
+
+CCABTest::CCABTest()
+/*
+ * FUNCTION: Default constructor
+ */
+{
+    PromptOnOverwrite = FALSE;
+}
+
+
+CCABTest::~CCABTest()
+/*
+ * FUNCTION: Default destructor
+ */
+{
+}
+
+
+VOID CCABTest::ExtractFromCabinet()
+/*
+ * FUNCTION: Extract file(s) from cabinet
+ */
+{
+    CAB_SEARCH Search;
+    ULONG Status;
+
+    if (Open() == CAB_STATUS_SUCCESS) {
+        printf("Cabinet %s\n\n", GetCabinetName());
+
+        if (FindFirst("", &Search) == CAB_STATUS_SUCCESS) {
+            do {
+                switch (Status = ExtractFile(Search.FileName)) {
+                    case CAB_STATUS_SUCCESS:
+                        break;
+                    case CAB_STATUS_INVALID_CAB:
+                        printf("Cabinet contains errors.\n");
+                        return;
+                    case CAB_STATUS_UNSUPPCOMP:
+                        printf("Cabinet uses unsupported compression type.\n");
+                        return;
+                    case CAB_STATUS_CANNOT_WRITE:
+                        printf("You've run out of free space on the destination volume or the volume is damaged.\n");
+                        return;
+                    default:
+                        printf("Unspecified error code (%d).\n", (UINT)Status);
+                        return;
+                }
+            } while (FindNext(&Search) == CAB_STATUS_SUCCESS);
+        }
+    } else {
+        printf("Cannot not open file: %s.\n", GetCabinetName());
+	}
+}
+
+
+/* Event handlers */
+
+BOOL CCABTest::OnOverwrite(PCFFILE File,
+                           LPTSTR FileName)
+/*
+ * FUNCTION: Called when extracting a file and it already exists
+ * ARGUMENTS:
+ *     File     = Pointer to CFFILE for file being extracted
+ *     Filename = Pointer to buffer with name of file (full path)
+ * RETURNS
+ *     TRUE if the file should be overwritten, FALSE if not
+ */
+{
+    TCHAR ch;
+
+    /* Should we prompt on overwrite? */
+    if (!PromptOnOverwrite)
+        return TRUE;
+
+    /* Ask if file should be overwritten */
+    printf("Overwrite %s (Yes/No/All)? ", GetFileName(FileName));
+    
+    for (;;) {
+        ch = _getch();
+        switch (ch) {
+            case 'Y':
+            case 'y': printf("%c\n", ch); return TRUE;
+            case 'N':
+            case 'n': printf("%c\n", ch); return FALSE;
+            case 'A':
+            case 'a': printf("%c\n", ch); PromptOnOverwrite = FALSE; return TRUE;
+        }
+    }
+}
+
+
+VOID CCABTest::OnExtract(PCFFILE File,
+                         LPTSTR FileName)
+/*
+ * FUNCTION: Called just before extracting a file
+ * ARGUMENTS:
+ *     File     = Pointer to CFFILE for file being extracted
+ *     FileName = Pointer to buffer with name of file (full path)
+ */
+{
+    printf("Extracting %s\n", GetFileName(FileName));
+}
+
+
+
+VOID CCABTest::OnDiskChange(LPTSTR CabinetName,
+                            LPTSTR DiskLabel)
+/*
+ * FUNCTION: Called when a new disk is to be processed
+ * ARGUMENTS:
+ *     CabinetName = Pointer to buffer with name of cabinet
+ *     DiskLabel   = Pointer to buffer with label of disk
+ */
+{
+    printf("\nChanging to cabinet %s - %s\n\n", CabinetName, DiskLabel);
+}
+
+
+INT main(INT argc, PCHAR argv[])
+/*
+ * FUNCTION: Main entry point
+ * ARGUMENTS:
+ *     argc = Number of arguments on command line
+ *     argv = Pointer to list of command line arguments
+ */
+{
+    CCABTest CABTest;
+
+    // Specify your cabinet filename here
+    CABTest.SetCabinetName("ros1.cab");
+    CABTest.ExtractFromCabinet();
+
+    return 0;
+}
+
+/* EOF */

reactos/apps/utils/cabman/test.h

@@ -0,0 +1,32 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     Test program for cabinet classes
+ * FILE:        apps/cabman/test.h
+ * PURPOSE:     Test program header
+ */
+#ifndef __TEST_H
+#define __TEST_H
+
+#define CAB_READ_ONLY   // Define for smaller read only version
+#include "cabinet.h"
+
+
+/* Classes */
+
+class CCABTest : public CCabinet {
+public:
+    CCABTest();
+    virtual ~CCABTest();
+    VOID ExtractFromCabinet();
+    /* Event handlers */
+    virtual BOOL OnOverwrite(PCFFILE File, LPTSTR FileName);
+    virtual VOID OnExtract(PCFFILE File, LPTSTR FileName);
+    virtual VOID OnDiskChange(LPTSTR CabinetName, LPTSTR DiskLabel);
+private:
+    /* Configuration */
+    BOOL PromptOnOverwrite;
+};
+
+#endif /* __CABMAN_H */
+
+/* EOF */

reactos/apps/utils/cabman/zlib/ChangeLog

@@ -0,0 +1,475 @@
+
+		ChangeLog file for zlib
+
+Changes (21 March 2001)
+- Adapted for ReactOS (Casper S. Hornstrup)
+  . Removed all but core zlib itself
+
+Changes in 1.1.3 (9 July 1998)
+- fix "an inflate input buffer bug that shows up on rare but persistent
+  occasions" (Mark)
+- fix gzread and gztell for concatenated .gz files (Didier Le Botlan)
+- fix gzseek(..., SEEK_SET) in write mode
+- fix crc check after a gzeek (Frank Faubert)
+- fix miniunzip when the last entry in a zip file is itself a zip file
+  (J Lillge)
+- add contrib/asm586 and contrib/asm686 (Brian Raiter)
+  See http://www.muppetlabs.com/~breadbox/software/assembly.html
+- add support for Delphi 3 in contrib/delphi (Bob Dellaca)
+- add support for C++Builder 3 and Delphi 3 in contrib/delphi2 (Davide Moretti)
+- do not exit prematurely in untgz if 0 at start of block (Magnus Holmgren)
+- use macro EXTERN instead of extern to support DLL for BeOS (Sander Stoks)
+- added a FAQ file
+
+- Support gzdopen on Mac with Metrowerks (Jason Linhart)
+- Do not redefine Byte on Mac (Brad Pettit & Jason Linhart)
+- define SEEK_END too if SEEK_SET is not defined (Albert Chin-A-Young)
+- avoid some warnings with Borland C (Tom Tanner)
+- fix a problem in contrib/minizip/zip.c for 16-bit MSDOS (Gilles Vollant)
+- emulate utime() for WIN32 in contrib/untgz  (Gilles Vollant)
+- allow several arguments to configure (Tim Mooney, Frodo Looijaard)
+- use libdir and includedir in Makefile.in (Tim Mooney)
+- support shared libraries on OSF1 V4 (Tim Mooney)
+- remove so_locations in "make clean"  (Tim Mooney)
+- fix maketree.c compilation error (Glenn, Mark)
+- Python interface to zlib now in Python 1.5 (Jeremy Hylton)
+- new Makefile.riscos (Rich Walker)
+- initialize static descriptors in trees.c for embedded targets (Nick Smith)
+- use "foo-gz" in example.c for RISCOS and VMS (Nick Smith)
+- add the OS/2 files in Makefile.in too (Andrew Zabolotny)
+- fix fdopen and halloc macros for Microsoft C 6.0 (Tom Lane)
+- fix maketree.c to allow clean compilation of inffixed.h (Mark)
+- fix parameter check in deflateCopy (Gunther Nikl)
+- cleanup trees.c, use compressed_len only in debug mode (Christian Spieler)
+- Many portability patches by Christian Spieler:
+  . zutil.c, zutil.h: added "const" for zmem*
+  . Make_vms.com: fixed some typos
+  . Make_vms.com: msdos/Makefile.*: removed zutil.h from some dependency lists
+  . msdos/Makefile.msc: remove "default rtl link library" info from obj files
+  . msdos/Makefile.*: use model-dependent name for the built zlib library
+  . msdos/Makefile.emx, nt/Makefile.emx, nt/Makefile.gcc:
+     new makefiles, for emx (DOS/OS2), emx&rsxnt and mingw32 (Windows 9x / NT)
+- use define instead of typedef for Bytef also for MSC small/medium (Tom Lane)
+- replace __far with _far for better portability (Christian Spieler, Tom Lane)
+- fix test for errno.h in configure (Tim Newsham)
+
+Changes in 1.1.2 (19 March 98)
+- added contrib/minzip, mini zip and unzip based on zlib (Gilles Vollant)
+  See http://www.winimage.com/zLibDll/unzip.html
+- preinitialize the inflate tables for fixed codes, to make the code
+  completely thread safe (Mark)
+- some simplifications and slight speed-up to the inflate code (Mark)
+- fix gzeof on non-compressed files (Allan Schrum)
+- add -std1 option in configure for OSF1 to fix gzprintf (Martin Mokrejs)
+- use default value of 4K for Z_BUFSIZE for 16-bit MSDOS (Tim Wegner + Glenn)
+- added os2/Makefile.def and os2/zlib.def (Andrew Zabolotny)
+- add shared lib support for UNIX_SV4.2MP (MATSUURA Takanori)
+- do not wrap extern "C" around system includes (Tom Lane)
+- mention zlib binding for TCL in README (Andreas Kupries)
+- added amiga/Makefile.pup for Amiga powerUP SAS/C PPC (Andreas Kleinert)
+- allow "make install prefix=..." even after configure (Glenn Randers-Pehrson)
+- allow "configure --prefix $HOME" (Tim Mooney)
+- remove warnings in example.c and gzio.c (Glenn Randers-Pehrson)
+- move Makefile.sas to amiga/Makefile.sas
+
+Changes in 1.1.1 (27 Feb 98)
+- fix macros _tr_tally_* in deflate.h for debug mode  (Glenn Randers-Pehrson)
+- remove block truncation heuristic which had very marginal effect for zlib
+  (smaller lit_bufsize than in gzip 1.2.4) and degraded a little the
+  compression ratio on some files. This also allows inlining _tr_tally for
+  matches in deflate_slow.
+- added msdos/Makefile.w32 for WIN32 Microsoft Visual C++ (Bob Frazier)
+
+Changes in 1.1.0 (24 Feb 98)
+- do not return STREAM_END prematurely in inflate (John Bowler)
+- revert to the zlib 1.0.8 inflate to avoid the gcc 2.8.0 bug (Jeremy Buhler)
+- compile with -DFASTEST to get compression code optimized for speed only
+- in minigzip, try mmap'ing the input file first (Miguel Albrecht)
+- increase size of I/O buffers in minigzip.c and gzio.c (not a big gain
+  on Sun but significant on HP)
+
+- add a pointer to experimental unzip library in README (Gilles Vollant)
+- initialize variable gcc in configure (Chris Herborth)
+
+Changes in 1.0.9 (17 Feb 1998)
+- added gzputs and gzgets functions
+- do not clear eof flag in gzseek (Mark Diekhans)
+- fix gzseek for files in transparent mode (Mark Diekhans)
+- do not assume that vsprintf returns the number of bytes written (Jens Krinke)
+- replace EXPORT with ZEXPORT to avoid conflict with other programs
+- added compress2 in zconf.h, zlib.def, zlib.dnt
+- new asm code from Gilles Vollant in contrib/asm386
+- simplify the inflate code (Mark):
+ . Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new()
+ . ZALLOC the length list in inflate_trees_fixed() instead of using stack
+ . ZALLOC the value area for huft_build() instead of using stack
+ . Simplify Z_FINISH check in inflate()
+
+- Avoid gcc 2.8.0 comparison bug a little differently than zlib 1.0.8
+- in inftrees.c, avoid cc -O bug on HP (Farshid Elahi)
+- in zconf.h move the ZLIB_DLL stuff earlier to avoid problems with
+  the declaration of FAR (Gilles VOllant)
+- install libz.so* with mode 755 (executable) instead of 644 (Marc Lehmann)
+- read_buf buf parameter of type Bytef* instead of charf*
+- zmemcpy parameters are of type Bytef*, not charf* (Joseph Strout)
+- do not redeclare unlink in minigzip.c for WIN32 (John Bowler)
+- fix check for presence of directories in "make install" (Ian Willis)
+
+Changes in 1.0.8 (27 Jan 1998)
+- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant)
+- fix gzgetc and gzputc for big endian systems (Markus Oberhumer)
+- added compress2() to allow setting the compression level
+- include sys/types.h to get off_t on some systems (Marc Lehmann & QingLong)
+- use constant arrays for the static trees in trees.c instead of computing
+  them at run time (thanks to Ken Raeburn for this suggestion). To create
+  trees.h, compile with GEN_TREES_H and run "make test".
+- check return code of example in "make test" and display result
+- pass minigzip command line options to file_compress
+- simplifying code of inflateSync to avoid gcc 2.8 bug
+
+- support CC="gcc -Wall" in configure -s (QingLong)
+- avoid a flush caused by ftell in gzopen for write mode (Ken Raeburn)
+- fix test for shared library support to avoid compiler warnings
+- zlib.lib -> zlib.dll in msdos/zlib.rc (Gilles Vollant)
+- check for TARGET_OS_MAC in addition to MACOS (Brad Pettit)
+- do not use fdopen for Metrowerks on Mac (Brad Pettit))
+- add checks for gzputc and gzputc in example.c
+- avoid warnings in gzio.c and deflate.c (Andreas Kleinert)
+- use const for the CRC table (Ken Raeburn)
+- fixed "make uninstall" for shared libraries
+- use Tracev instead of Trace in infblock.c
+- in example.c use correct compressed length for test_sync
+- suppress +vnocompatwarnings in configure for HPUX (not always supported)
+
+Changes in 1.0.7 (20 Jan 1998)
+- fix gzseek which was broken in write mode
+- return error for gzseek to negative absolute position
+- fix configure for Linux (Chun-Chung Chen)
+- increase stack space for MSC (Tim Wegner)
+- get_crc_table and inflateSyncPoint are EXPORTed (Gilles Vollant)
+- define EXPORTVA for gzprintf (Gilles Vollant)
+- added man page zlib.3 (Rick Rodgers)
+- for contrib/untgz, fix makedir() and improve Makefile
+
+- check gzseek in write mode in example.c
+- allocate extra buffer for seeks only if gzseek is actually called
+- avoid signed/unsigned comparisons (Tim Wegner, Gilles Vollant)
+- add inflateSyncPoint in zconf.h
+- fix list of exported functions in nt/zlib.dnt and mdsos/zlib.def
+
+Changes in 1.0.6 (19 Jan 1998)
+- add functions gzprintf, gzputc, gzgetc, gztell, gzeof, gzseek, gzrewind and
+  gzsetparams (thanks to Roland Giersig and Kevin Ruland for some of this code)
+- Fix a deflate bug occuring only with compression level 0 (thanks to
+  Andy Buckler for finding this one).
+- In minigzip, pass transparently also the first byte for .Z files.
+- return Z_BUF_ERROR instead of Z_OK if output buffer full in uncompress()
+- check Z_FINISH in inflate (thanks to Marc Schluper)
+- Implement deflateCopy (thanks to Adam Costello)
+- make static libraries by default in configure, add --shared option.
+- move MSDOS or Windows specific files to directory msdos
+- suppress the notion of partial flush to simplify the interface
+  (but the symbol Z_PARTIAL_FLUSH is kept for compatibility with 1.0.4)
+- suppress history buffer provided by application to simplify the interface
+  (this feature was not implemented anyway in 1.0.4)
+- next_in and avail_in must be initialized before calling inflateInit or
+  inflateInit2
+- add EXPORT in all exported functions (for Windows DLL)
+- added Makefile.nt (thanks to Stephen Williams)
+- added the unsupported "contrib" directory:
+   contrib/asm386/ by Gilles Vollant <info@winimage.com>
+	386 asm code replacing longest_match().
+   contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
+        A C++ I/O streams interface to the zlib gz* functions
+   contrib/iostream2/  by Tyge L<>vset <Tyge.Lovset@cmr.no>
+	Another C++ I/O streams interface
+   contrib/untgz/  by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
+	A very simple tar.gz file extractor using zlib
+   contrib/visual-basic.txt by Carlos Rios <c_rios@sonda.cl>
+        How to use compress(), uncompress() and the gz* functions from VB.
+- pass params -f (filtered data), -h (huffman only), -1 to -9 (compression
+  level) in minigzip (thanks to Tom Lane)
+
+- use const for rommable constants in deflate
+- added test for gzseek and gztell in example.c
+- add undocumented function inflateSyncPoint() (hack for Paul Mackerras)
+- add undocumented function zError to convert error code to string
+  (for Tim Smithers)
+- Allow compilation of gzio with -DNO_DEFLATE to avoid the compression code.
+- Use default memcpy for Symantec MSDOS compiler.
+- Add EXPORT keyword for check_func (needed for Windows DLL)
+- add current directory to LD_LIBRARY_PATH for "make test"
+- create also a link for libz.so.1
+- added support for FUJITSU UXP/DS (thanks to Toshiaki Nomura)
+- use $(SHAREDLIB) instead of libz.so in Makefile.in (for HPUX)
+- added -soname for Linux in configure (Chun-Chung Chen,
+- assign numbers to the exported functions in zlib.def (for Windows DLL)
+- add advice in zlib.h for best usage of deflateSetDictionary
+- work around compiler bug on Atari (cast Z_NULL in call of s->checkfn)
+- allow compilation with ANSI keywords only enabled for TurboC in large model
+- avoid "versionString"[0] (Borland bug)
+- add NEED_DUMMY_RETURN for Borland
+- use variable z_verbose for tracing in debug mode (L. Peter Deutsch).
+- allow compilation with CC
+- defined STDC for OS/2 (David Charlap)	
+- limit external names to 8 chars for MVS (Thomas Lund)
+- in minigzip.c, use static buffers only for 16-bit systems
+- fix suffix check for "minigzip -d foo.gz"
+- do not return an error for the 2nd of two consecutive gzflush() (Felix Lee)
+- use _fdopen instead of fdopen for MSC >= 6.0 (Thomas Fanslau)
+- added makelcc.bat for lcc-win32 (Tom St Denis)
+- in Makefile.dj2, use copy and del instead of install and rm (Frank Donahoe)
+- Avoid expanded $Id: ChangeLog,v 1.1 2001/03/21 22:32:32 chorns Exp $. Use "rcs -kb" or "cvs admin -kb" to avoid Id expansion.
+- check for unistd.h in configure (for off_t)
+- remove useless check parameter in inflate_blocks_free
+- avoid useless assignment of s->check to itself in inflate_blocks_new
+- do not flush twice in gzclose (thanks to Ken Raeburn)
+- rename FOPEN as F_OPEN to avoid clash with /usr/include/sys/file.h
+- use NO_ERRNO_H instead of enumeration of operating systems with errno.h
+- work around buggy fclose on pipes for HP/UX
+- support zlib DLL with BORLAND C++ 5.0 (thanks to Glenn Randers-Pehrson)
+- fix configure if CC is already equal to gcc
+
+Changes in 1.0.5 (3 Jan 98)
+- Fix inflate to terminate gracefully when fed corrupted or invalid data
+- Use const for rommable constants in inflate
+- Eliminate memory leaks on error conditions in inflate
+- Removed some vestigial code in inflate
+- Update web address in README
+  
+Changes in 1.0.4 (24 Jul 96)
+- In very rare conditions, deflate(s, Z_FINISH) could fail to produce an EOF
+  bit, so the decompressor could decompress all the correct data but went
+  on to attempt decompressing extra garbage data. This affected minigzip too.
+- zlibVersion and gzerror return const char* (needed for DLL)
+- port to RISCOS (no fdopen, no multiple dots, no unlink, no fileno)
+- use z_error only for DEBUG (avoid problem with DLLs)
+
+Changes in 1.0.3 (2 Jul 96)
+- use z_streamp instead of z_stream *, which is now a far pointer in MSDOS
+  small and medium models; this makes the library incompatible with previous
+  versions for these models. (No effect in large model or on other systems.)
+- return OK instead of BUF_ERROR if previous deflate call returned with
+  avail_out as zero but there is nothing to do
+- added memcmp for non STDC compilers
+- define NO_DUMMY_DECL for more Mac compilers (.h files merged incorrectly)
+- define __32BIT__ if __386__ or i386 is defined (pb. with Watcom and SCO)
+- better check for 16-bit mode MSC (avoids problem with Symantec)
+
+Changes in 1.0.2 (23 May 96)
+- added Windows DLL support
+- added a function zlibVersion (for the DLL support)
+- fixed declarations using Bytef in infutil.c (pb with MSDOS medium model)
+- Bytef is define's instead of typedef'd only for Borland C
+- avoid reading uninitialized memory in example.c
+- mention in README that the zlib format is now RFC1950
+- updated Makefile.dj2
+- added algorithm.doc
+
+Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion]
+- fix array overlay in deflate.c which sometimes caused bad compressed data
+- fix inflate bug with empty stored block
+- fix MSDOS medium model which was broken in 0.99
+- fix deflateParams() which could generated bad compressed data.
+- Bytef is define'd instead of typedef'ed (work around Borland bug)
+- added an INDEX file
+- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32),
+  Watcom (Makefile.wat), Amiga SAS/C (Makefile.sas)
+- speed up adler32 for modern machines without auto-increment
+- added -ansi for IRIX in configure
+- static_init_done in trees.c is an int
+- define unlink as delete for VMS
+- fix configure for QNX
+- add configure branch for SCO and HPUX
+- avoid many warnings (unused variables, dead assignments, etc...)
+- no fdopen for BeOS
+- fix the Watcom fix for 32 bit mode (define FAR as empty)
+- removed redefinition of Byte for MKWERKS
+- work around an MWKERKS bug (incorrect merge of all .h files)
+
+Changes in 0.99 (27 Jan 96)
+- allow preset dictionary shared between compressor and decompressor
+- allow compression level 0 (no compression)
+- add deflateParams in zlib.h: allow dynamic change of compression level
+  and compression strategy.
+- test large buffers and deflateParams in example.c
+- add optional "configure" to build zlib as a shared library
+- suppress Makefile.qnx, use configure instead
+- fixed deflate for 64-bit systems (detected on Cray)
+- fixed inflate_blocks for 64-bit systems (detected on Alpha)
+- declare Z_DEFLATED in zlib.h (possible parameter for deflateInit2)
+- always return Z_BUF_ERROR when deflate() has nothing to do
+- deflateInit and inflateInit are now macros to allow version checking
+- prefix all global functions and types with z_ with -DZ_PREFIX
+- make falloc completely reentrant (inftrees.c)
+- fixed very unlikely race condition in ct_static_init
+- free in reverse order of allocation to help memory manager
+- use zlib-1.0/* instead of zlib/* inside the tar.gz
+- make zlib warning-free with "gcc -O3 -Wall -Wwrite-strings -Wpointer-arith
+  -Wconversion -Wstrict-prototypes -Wmissing-prototypes"
+- allow gzread on concatenated .gz files
+- deflateEnd now returns Z_DATA_ERROR if it was premature
+- deflate is finally (?) fully deterministic (no matches beyond end of input)
+- Document Z_SYNC_FLUSH
+- add uninstall in Makefile
+- Check for __cpluplus in zlib.h
+- Better test in ct_align for partial flush
+- avoid harmless warnings for Borland C++
+- initialize hash_head in deflate.c
+- avoid warning on fdopen (gzio.c) for HP cc -Aa
+- include stdlib.h for STDC compilers
+- include errno.h for Cray
+- ignore error if ranlib doesn't exist
+- call ranlib twice for NeXTSTEP
+- use exec_prefix instead of prefix for libz.a
+- renamed ct_* as _tr_* to avoid conflict with applications
+- clear z->msg in inflateInit2 before any error return
+- initialize opaque in example.c, gzio.c, deflate.c and inflate.c
+- fixed typo in zconf.h (_GNUC__ => __GNUC__)
+- check for WIN32 in zconf.h and zutil.c (avoid farmalloc in 32-bit mode)
+- fix typo in Make_vms.com (f$trnlnm -> f$getsyi)
+- in fcalloc, normalize pointer if size > 65520 bytes
+- don't use special fcalloc for 32 bit Borland C++
+- use STDC instead of __GO32__ to avoid redeclaring exit, calloc, etc...
+- use Z_BINARY instead of BINARY
+- document that gzclose after gzdopen will close the file
+- allow "a" as mode in gzopen.
+- fix error checking in gzread
+- allow skipping .gz extra-field on pipes
+- added reference to Perl interface in README
+- put the crc table in FAR data (I dislike more and more the medium model :)
+- added get_crc_table
+- added a dimension to all arrays (Borland C can't count).
+- workaround Borland C bug in declaration of inflate_codes_new & inflate_fast
+- guard against multiple inclusion of *.h (for precompiled header on Mac)
+- Watcom C pretends to be Microsoft C small model even in 32 bit mode.
+- don't use unsized arrays to avoid silly warnings by Visual C++:
+     warning C4746: 'inflate_mask' : unsized array treated as  '__far'
+     (what's wrong with far data in far model?).
+- define enum out of inflate_blocks_state to allow compilation with C++
+
+Changes in 0.95 (16 Aug 95)
+- fix MSDOS small and medium model (now easier to adapt to any compiler)
+- inlined send_bits
+- fix the final (:-) bug for deflate with flush (output was correct but
+  not completely flushed in rare occasions).
+- default window size is same for compression and decompression
+  (it's now sufficient to set MAX_WBITS in zconf.h).
+- voidp -> voidpf and voidnp -> voidp (for consistency with other
+  typedefs and because voidnp was not near in large model).
+
+Changes in 0.94 (13 Aug 95)
+- support MSDOS medium model
+- fix deflate with flush (could sometimes generate bad output)
+- fix deflateReset (zlib header was incorrectly suppressed)
+- added support for VMS
+- allow a compression level in gzopen()
+- gzflush now calls fflush
+- For deflate with flush, flush even if no more input is provided.
+- rename libgz.a as libz.a
+- avoid complex expression in infcodes.c triggering Turbo C bug
+- work around a problem with gcc on Alpha (in INSERT_STRING)
+- don't use inline functions (problem with some gcc versions)
+- allow renaming of Byte, uInt, etc... with #define.
+- avoid warning about (unused) pointer before start of array in deflate.c
+- avoid various warnings in gzio.c, example.c, infblock.c, adler32.c, zutil.c
+- avoid reserved word 'new' in trees.c
+
+Changes in 0.93 (25 June 95)
+- temporarily disable inline functions
+- make deflate deterministic
+- give enough lookahead for PARTIAL_FLUSH
+- Set binary mode for stdin/stdout in minigzip.c for OS/2
+- don't even use signed char in inflate (not portable enough)
+- fix inflate memory leak for segmented architectures
+
+Changes in 0.92 (3 May 95)
+- don't assume that char is signed (problem on SGI)
+- Clear bit buffer when starting a stored block
+- no memcpy on Pyramid
+- suppressed inftest.c
+- optimized fill_window, put longest_match inline for gcc
+- optimized inflate on stored blocks.
+- untabify all sources to simplify patches
+
+Changes in 0.91 (2 May 95)
+- Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h
+- Document the memory requirements in zconf.h
+- added "make install"
+- fix sync search logic in inflateSync
+- deflate(Z_FULL_FLUSH) now works even if output buffer too short
+- after inflateSync, don't scare people with just "lo world"
+- added support for DJGPP
+
+Changes in 0.9 (1 May 95)
+- don't assume that zalloc clears the allocated memory (the TurboC bug
+  was Mark's bug after all :)
+- let again gzread copy uncompressed data unchanged (was working in 0.71)
+- deflate(Z_FULL_FLUSH), inflateReset and inflateSync are now fully implemented
+- added a test of inflateSync in example.c
+- moved MAX_WBITS to zconf.h because users might want to change that.
+- document explicitly that zalloc(64K) on MSDOS must return a normalized
+  pointer (zero offset)
+- added Makefiles for Microsoft C, Turbo C, Borland C++
+- faster crc32()
+
+Changes in 0.8 (29 April 95)
+- added fast inflate (inffast.c)
+- deflate(Z_FINISH) now returns Z_STREAM_END when done. Warning: this
+  is incompatible with previous versions of zlib which returned Z_OK.
+- work around a TurboC compiler bug (bad code for b << 0, see infutil.h)
+  (actually that was not a compiler bug, see 0.81 above)
+- gzread no longer reads one extra byte in certain cases
+- In gzio destroy(), don't reference a freed structure
+- avoid many warnings for MSDOS
+- avoid the ERROR symbol which is used by MS Windows
+
+Changes in 0.71 (14 April 95)
+- Fixed more MSDOS compilation problems :( There is still a bug with
+  TurboC large model.
+
+Changes in 0.7 (14 April 95)
+- Added full inflate support.
+- Simplified the crc32() interface. The pre- and post-conditioning
+  (one's complement) is now done inside crc32(). WARNING: this is
+  incompatible with previous versions; see zlib.h for the new usage.
+
+Changes in 0.61 (12 April 95)
+- workaround for a bug in TurboC. example and minigzip now work on MSDOS.
+
+Changes in 0.6 (11 April 95)
+- added minigzip.c
+- added gzdopen to reopen a file descriptor as gzFile
+- added transparent reading of non-gziped files in gzread.
+- fixed bug in gzread (don't read crc as data)
+- fixed bug in destroy (gzio.c) (don't return Z_STREAM_END for gzclose).
+- don't allocate big arrays in the stack (for MSDOS)
+- fix some MSDOS compilation problems
+
+Changes in 0.5:
+- do real compression in deflate.c. Z_PARTIAL_FLUSH is supported but
+  not yet Z_FULL_FLUSH.
+- support decompression but only in a single step (forced Z_FINISH)
+- added opaque object for zalloc and zfree.
+- added deflateReset and inflateReset
+- added a variable zlib_version for consistency checking.
+- renamed the 'filter' parameter of deflateInit2 as 'strategy'.
+  Added Z_FILTERED and Z_HUFFMAN_ONLY constants.
+
+Changes in 0.4:
+- avoid "zip" everywhere, use zlib instead of ziplib.
+- suppress Z_BLOCK_FLUSH, interpret Z_PARTIAL_FLUSH as block flush
+  if compression method == 8.
+- added adler32 and crc32
+- renamed deflateOptions as deflateInit2, call one or the other but not both
+- added the method parameter for deflateInit2.
+- added inflateInit2
+- simplied considerably deflateInit and inflateInit by not supporting
+  user-provided history buffer. This is supported only in deflateInit2
+  and inflateInit2.
+
+Changes in 0.3:
+- prefix all macro names with Z_
+- use Z_FINISH instead of deflateEnd to finish compression.
+- added Z_HUFFMAN_ONLY
+- added gzerror()

reactos/apps/utils/cabman/zlib/README

@@ -0,0 +1,148 @@
+zlib 1.1.3 is a general purpose data compression library.  All the code
+is thread safe.  The data format used by the zlib library
+is described by RFCs (Request for Comments) 1950 to 1952 in the files 
+ftp://ds.internic.net/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate
+format) and rfc1952.txt (gzip format). These documents are also available in
+other formats from ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html
+
+All functions of the compression library are documented in the file zlib.h
+(volunteer to write man pages welcome, contact jloup@gzip.org). A usage
+example of the library is given in the file example.c which also tests that
+the library is working correctly. Another example is given in the file
+minigzip.c. The compression library itself is composed of all source files
+except example.c and minigzip.c.
+
+To compile all files and run the test program, follow the instructions
+given at the top of Makefile. In short "make test; make install"
+should work for most machines. For Unix: "configure; make test; make install"
+For MSDOS, use one of the special makefiles such as Makefile.msc.
+For VMS, use Make_vms.com or descrip.mms.
+
+Questions about zlib should be sent to <zlib@quest.jpl.nasa.gov>, or to
+Gilles Vollant <info@winimage.com> for the Windows DLL version.
+The zlib home page is http://www.cdrom.com/pub/infozip/zlib/
+The official zlib ftp site is ftp://ftp.cdrom.com/pub/infozip/zlib/
+Before reporting a problem, please check those sites to verify that
+you have the latest version of zlib; otherwise get the latest version and
+check whether the problem still exists or not.
+
+Mark Nelson <markn@tiny.com> wrote an article about zlib for the Jan. 1997
+issue of  Dr. Dobb's Journal; a copy of the article is available in
+http://web2.airmail.net/markn/articles/zlibtool/zlibtool.htm
+
+The changes made in version 1.1.3 are documented in the file ChangeLog.
+The main changes since 1.1.2 are:
+
+- fix "an inflate input buffer bug that shows up on rare but persistent
+  occasions" (Mark)
+- fix gzread and gztell for concatenated .gz files (Didier Le Botlan)
+- fix gzseek(..., SEEK_SET) in write mode
+- fix crc check after a gzeek (Frank Faubert)
+- fix miniunzip when the last entry in a zip file is itself a zip file
+  (J Lillge)
+- add contrib/asm586 and contrib/asm686 (Brian Raiter)
+  See http://www.muppetlabs.com/~breadbox/software/assembly.html
+- add support for Delphi 3 in contrib/delphi (Bob Dellaca)
+- add support for C++Builder 3 and Delphi 3 in contrib/delphi2 (Davide Moretti)
+- do not exit prematurely in untgz if 0 at start of block (Magnus Holmgren)
+- use macro EXTERN instead of extern to support DLL for BeOS (Sander Stoks)
+- added a FAQ file
+
+plus many changes for portability.
+
+Unsupported third party contributions are provided in directory "contrib".
+
+A Java implementation of zlib is available in the Java Development Kit 1.1
+http://www.javasoft.com/products/JDK/1.1/docs/api/Package-java.util.zip.html
+See the zlib home page http://www.cdrom.com/pub/infozip/zlib/ for details.
+
+A Perl interface to zlib written by Paul Marquess <pmarquess@bfsec.bt.co.uk>
+is in the CPAN (Comprehensive Perl Archive Network) sites, such as:
+ftp://ftp.cis.ufl.edu/pub/perl/CPAN/modules/by-module/Compress/Compress-Zlib*
+
+A Python interface to zlib written by A.M. Kuchling <amk@magnet.com>
+is available in Python 1.5 and later versions, see
+http://www.python.org/doc/lib/module-zlib.html
+
+A zlib binding for TCL written by Andreas Kupries <a.kupries@westend.com>
+is availlable at http://www.westend.com/~kupries/doc/trf/man/man.html
+
+An experimental package to read and write files in .zip format,
+written on top of zlib by Gilles Vollant <info@winimage.com>, is
+available at http://www.winimage.com/zLibDll/unzip.html
+and also in the contrib/minizip directory of zlib.
+
+
+Notes for some targets:
+
+- To build a Windows DLL version, include in a DLL project zlib.def, zlib.rc
+  and all .c files except example.c and minigzip.c; compile with -DZLIB_DLL
+  The zlib DLL support was initially done by Alessandro Iacopetti and is
+  now maintained by Gilles Vollant <info@winimage.com>. Check the zlib DLL
+  home page at http://www.winimage.com/zLibDll
+
+  From Visual Basic, you can call the DLL functions which do not take
+  a structure as argument: compress, uncompress and all gz* functions.
+  See contrib/visual-basic.txt for more information, or get
+  http://www.tcfb.com/dowseware/cmp-z-it.zip
+
+- For 64-bit Irix, deflate.c must be compiled without any optimization.
+  With -O, one libpng test fails. The test works in 32 bit mode (with
+  the -n32 compiler flag). The compiler bug has been reported to SGI.
+
+- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1   
+  it works when compiled with cc.
+
+- on Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1
+  is necessary to get gzprintf working correctly. This is done by configure.
+
+- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works
+  with other compilers. Use "make test" to check your compiler.
+
+- gzdopen is not supported on RISCOS, BEOS and by some Mac compilers.
+
+- For Turbo C the small model is supported only with reduced performance to
+  avoid any far allocation; it was tested with -DMAX_WBITS=11 -DMAX_MEM_LEVEL=3
+
+- For PalmOs, see http://www.cs.uit.no/~perm/PASTA/pilot/software.html
+  Per Harald Myrvang <perm@stud.cs.uit.no>
+
+
+Acknowledgments:
+
+  The deflate format used by zlib was defined by Phil Katz. The deflate
+  and zlib specifications were written by L. Peter Deutsch. Thanks to all the
+  people who reported problems and suggested various improvements in zlib;
+  they are too numerous to cite here.
+
+Copyright notice:
+
+ (C) 1995-1998 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+If you use the zlib library in a product, we would appreciate *not*
+receiving lengthy legal documents to sign. The sources are provided
+for free but without warranty of any kind.  The library has been
+entirely written by Jean-loup Gailly and Mark Adler; it does not
+include third-party code.
+
+If you redistribute modified sources, we would appreciate that you include
+in the file ChangeLog history information documenting your changes.

reactos/apps/utils/cabman/zlib/adler32.c

@@ -0,0 +1,48 @@
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-1998 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id: adler32.c,v 1.1 2001/03/21 22:32:32 chorns Exp $ */
+
+#include "zlib.h"
+
+#define BASE 65521L /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i)  {s1 += buf[i]; s2 += s1;}
+#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+
+/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+    uLong adler;
+    const Bytef *buf;
+    uInt len;
+{
+    unsigned long s1 = adler & 0xffff;
+    unsigned long s2 = (adler >> 16) & 0xffff;
+    int k;
+
+    if (buf == Z_NULL) return 1L;
+
+    while (len > 0) {
+        k = len < NMAX ? len : NMAX;
+        len -= k;
+        while (k >= 16) {
+            DO16(buf);
+	    buf += 16;
+            k -= 16;
+        }
+        if (k != 0) do {
+            s1 += *buf++;
+	    s2 += s1;
+        } while (--k);
+        s1 %= BASE;
+        s2 %= BASE;
+    }
+    return (s2 << 16) | s1;
+}

reactos/apps/utils/cabman/zlib/deflate.h

@@ -0,0 +1,318 @@
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-1998 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id: deflate.h,v 1.1 2001/03/21 22:32:32 chorns Exp $ */
+
+#ifndef _DEFLATE_H
+#define _DEFLATE_H
+
+#include "zutil.h"
+
+/* ===========================================================================
+ * Internal compression state.
+ */
+
+#define LENGTH_CODES 29
+/* number of length codes, not counting the special END_BLOCK code */
+
+#define LITERALS  256
+/* number of literal bytes 0..255 */
+
+#define L_CODES (LITERALS+1+LENGTH_CODES)
+/* number of Literal or Length codes, including the END_BLOCK code */
+
+#define D_CODES   30
+/* number of distance codes */
+
+#define BL_CODES  19
+/* number of codes used to transfer the bit lengths */
+
+#define HEAP_SIZE (2*L_CODES+1)
+/* maximum heap size */
+
+#define MAX_BITS 15
+/* All codes must not exceed MAX_BITS bits */
+
+#define INIT_STATE    42
+#define BUSY_STATE   113
+#define FINISH_STATE 666
+/* Stream status */
+
+
+/* Data structure describing a single value and its code string. */
+typedef struct ct_data_s {
+    union {
+        ush  freq;       /* frequency count */
+        ush  code;       /* bit string */
+    } fc;
+    union {
+        ush  dad;        /* father node in Huffman tree */
+        ush  len;        /* length of bit string */
+    } dl;
+} FAR ct_data;
+
+#define Freq fc.freq
+#define Code fc.code
+#define Dad  dl.dad
+#define Len  dl.len
+
+typedef struct static_tree_desc_s  static_tree_desc;
+
+typedef struct tree_desc_s {
+    ct_data *dyn_tree;           /* the dynamic tree */
+    int     max_code;            /* largest code with non zero frequency */
+    static_tree_desc *stat_desc; /* the corresponding static tree */
+} FAR tree_desc;
+
+typedef ush Pos;
+typedef Pos FAR Posf;
+typedef unsigned IPos;
+
+/* A Pos is an index in the character window. We use short instead of int to
+ * save space in the various tables. IPos is used only for parameter passing.
+ */
+
+typedef struct internal_state {
+    z_streamp strm;      /* pointer back to this zlib stream */
+    int   status;        /* as the name implies */
+    Bytef *pending_buf;  /* output still pending */
+    ulg   pending_buf_size; /* size of pending_buf */
+    Bytef *pending_out;  /* next pending byte to output to the stream */
+    int   pending;       /* nb of bytes in the pending buffer */
+    int   noheader;      /* suppress zlib header and adler32 */
+    Byte  data_type;     /* UNKNOWN, BINARY or ASCII */
+    Byte  method;        /* STORED (for zip only) or DEFLATED */
+    int   last_flush;    /* value of flush param for previous deflate call */
+
+                /* used by deflate.c: */
+
+    uInt  w_size;        /* LZ77 window size (32K by default) */
+    uInt  w_bits;        /* log2(w_size)  (8..16) */
+    uInt  w_mask;        /* w_size - 1 */
+
+    Bytef *window;
+    /* Sliding window. Input bytes are read into the second half of the window,
+     * and move to the first half later to keep a dictionary of at least wSize
+     * bytes. With this organization, matches are limited to a distance of
+     * wSize-MAX_MATCH bytes, but this ensures that IO is always
+     * performed with a length multiple of the block size. Also, it limits
+     * the window size to 64K, which is quite useful on MSDOS.
+     * To do: use the user input buffer as sliding window.
+     */
+
+    ulg window_size;
+    /* Actual size of window: 2*wSize, except when the user input buffer
+     * is directly used as sliding window.
+     */
+
+    Posf *prev;
+    /* Link to older string with same hash index. To limit the size of this
+     * array to 64K, this link is maintained only for the last 32K strings.
+     * An index in this array is thus a window index modulo 32K.
+     */
+
+    Posf *head; /* Heads of the hash chains or NIL. */
+
+    uInt  ins_h;          /* hash index of string to be inserted */
+    uInt  hash_size;      /* number of elements in hash table */
+    uInt  hash_bits;      /* log2(hash_size) */
+    uInt  hash_mask;      /* hash_size-1 */
+
+    uInt  hash_shift;
+    /* Number of bits by which ins_h must be shifted at each input
+     * step. It must be such that after MIN_MATCH steps, the oldest
+     * byte no longer takes part in the hash key, that is:
+     *   hash_shift * MIN_MATCH >= hash_bits
+     */
+
+    long block_start;
+    /* Window position at the beginning of the current output block. Gets
+     * negative when the window is moved backwards.
+     */
+
+    uInt match_length;           /* length of best match */
+    IPos prev_match;             /* previous match */
+    int match_available;         /* set if previous match exists */
+    uInt strstart;               /* start of string to insert */
+    uInt match_start;            /* start of matching string */
+    uInt lookahead;              /* number of valid bytes ahead in window */
+
+    uInt prev_length;
+    /* Length of the best match at previous step. Matches not greater than this
+     * are discarded. This is used in the lazy match evaluation.
+     */
+
+    uInt max_chain_length;
+    /* To speed up deflation, hash chains are never searched beyond this
+     * length.  A higher limit improves compression ratio but degrades the
+     * speed.
+     */
+
+    uInt max_lazy_match;
+    /* Attempt to find a better match only when the current match is strictly
+     * smaller than this value. This mechanism is used only for compression
+     * levels >= 4.
+     */
+#   define max_insert_length  max_lazy_match
+    /* Insert new strings in the hash table only if the match length is not
+     * greater than this length. This saves time but degrades compression.
+     * max_insert_length is used only for compression levels <= 3.
+     */
+
+    int level;    /* compression level (1..9) */
+    int strategy; /* favor or force Huffman coding*/
+
+    uInt good_match;
+    /* Use a faster search when the previous match is longer than this */
+
+    int nice_match; /* Stop searching when current match exceeds this */
+
+                /* used by trees.c: */
+    /* Didn't use ct_data typedef below to supress compiler warning */
+    struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
+    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
+    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
+
+    struct tree_desc_s l_desc;               /* desc. for literal tree */
+    struct tree_desc_s d_desc;               /* desc. for distance tree */
+    struct tree_desc_s bl_desc;              /* desc. for bit length tree */
+
+    ush bl_count[MAX_BITS+1];
+    /* number of codes at each bit length for an optimal tree */
+
+    int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
+    int heap_len;               /* number of elements in the heap */
+    int heap_max;               /* element of largest frequency */
+    /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+     * The same heap array is used to build all trees.
+     */
+
+    uch depth[2*L_CODES+1];
+    /* Depth of each subtree used as tie breaker for trees of equal frequency
+     */
+
+    uchf *l_buf;          /* buffer for literals or lengths */
+
+    uInt  lit_bufsize;
+    /* Size of match buffer for literals/lengths.  There are 4 reasons for
+     * limiting lit_bufsize to 64K:
+     *   - frequencies can be kept in 16 bit counters
+     *   - if compression is not successful for the first block, all input
+     *     data is still in the window so we can still emit a stored block even
+     *     when input comes from standard input.  (This can also be done for
+     *     all blocks if lit_bufsize is not greater than 32K.)
+     *   - if compression is not successful for a file smaller than 64K, we can
+     *     even emit a stored file instead of a stored block (saving 5 bytes).
+     *     This is applicable only for zip (not gzip or zlib).
+     *   - creating new Huffman trees less frequently may not provide fast
+     *     adaptation to changes in the input data statistics. (Take for
+     *     example a binary file with poorly compressible code followed by
+     *     a highly compressible string table.) Smaller buffer sizes give
+     *     fast adaptation but have of course the overhead of transmitting
+     *     trees more frequently.
+     *   - I can't count above 4
+     */
+
+    uInt last_lit;      /* running index in l_buf */
+
+    ushf *d_buf;
+    /* Buffer for distances. To simplify the code, d_buf and l_buf have
+     * the same number of elements. To use different lengths, an extra flag
+     * array would be necessary.
+     */
+
+    ulg opt_len;        /* bit length of current block with optimal trees */
+    ulg static_len;     /* bit length of current block with static trees */
+    uInt matches;       /* number of string matches in current block */
+    int last_eob_len;   /* bit length of EOB code for last block */
+
+#ifdef DEBUG
+    ulg compressed_len; /* total bit length of compressed file mod 2^32 */
+    ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
+#endif
+
+    ush bi_buf;
+    /* Output buffer. bits are inserted starting at the bottom (least
+     * significant bits).
+     */
+    int bi_valid;
+    /* Number of valid bits in bi_buf.  All bits above the last valid bit
+     * are always zero.
+     */
+
+} FAR deflate_state;
+
+/* Output a byte on the stream.
+ * IN assertion: there is enough room in pending_buf.
+ */
+#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
+
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+#define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
+/* In order to simplify the code, particularly on 16 bit machines, match
+ * distances are limited to MAX_DIST instead of WSIZE.
+ */
+
+        /* in trees.c */
+void _tr_init         OF((deflate_state *s));
+int  _tr_tally        OF((deflate_state *s, unsigned dist, unsigned lc));
+void _tr_flush_block  OF((deflate_state *s, charf *buf, ulg stored_len,
+			  int eof));
+void _tr_align        OF((deflate_state *s));
+void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,
+                          int eof));
+
+#define d_code(dist) \
+   ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
+/* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. _dist_code[256] and _dist_code[257] are never
+ * used.
+ */
+
+#ifndef DEBUG
+/* Inline versions of _tr_tally for speed: */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+  extern uch _length_code[];
+  extern uch _dist_code[];
+#else
+  extern const uch _length_code[];
+  extern const uch _dist_code[];
+#endif
+
+# define _tr_tally_lit(s, c, flush) \
+  { uch cc = (c); \
+    s->d_buf[s->last_lit] = 0; \
+    s->l_buf[s->last_lit++] = cc; \
+    s->dyn_ltree[cc].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+   }
+# define _tr_tally_dist(s, distance, length, flush) \
+  { uch len = (length); \
+    ush dist = (distance); \
+    s->d_buf[s->last_lit] = dist; \
+    s->l_buf[s->last_lit++] = len; \
+    dist--; \
+    s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
+    s->dyn_dtree[d_code(dist)].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+  }
+#else
+# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
+# define _tr_tally_dist(s, distance, length, flush) \
+              flush = _tr_tally(s, distance, length) 
+#endif
+
+#endif

reactos/apps/utils/cabman/zlib/infblock.c

@@ -0,0 +1,398 @@
+/* infblock.c -- interpret and process block types to last block
+ * Copyright (C) 1995-1998 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "infblock.h"
+#include "inftrees.h"
+#include "infcodes.h"
+#include "infutil.h"
+
+struct inflate_codes_state {int dummy;}; /* for buggy compilers */
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+/* Table for deflate from PKZIP's appnote.txt. */
+local const uInt border[] = { /* Order of the bit length code lengths */
+        16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+/*
+   Notes beyond the 1.93a appnote.txt:
+
+   1. Distance pointers never point before the beginning of the output
+      stream.
+   2. Distance pointers can point back across blocks, up to 32k away.
+   3. There is an implied maximum of 7 bits for the bit length table and
+      15 bits for the actual data.
+   4. If only one code exists, then it is encoded using one bit.  (Zero
+      would be more efficient, but perhaps a little confusing.)  If two
+      codes exist, they are coded using one bit each (0 and 1).
+   5. There is no way of sending zero distance codes--a dummy must be
+      sent if there are none.  (History: a pre 2.0 version of PKZIP would
+      store blocks with no distance codes, but this was discovered to be
+      too harsh a criterion.)  Valid only for 1.93a.  2.04c does allow
+      zero distance codes, which is sent as one code of zero bits in
+      length.
+   6. There are up to 286 literal/length codes.  Code 256 represents the
+      end-of-block.  Note however that the static length tree defines
+      288 codes just to fill out the Huffman codes.  Codes 286 and 287
+      cannot be used though, since there is no length base or extra bits
+      defined for them.  Similarily, there are up to 30 distance codes.
+      However, static trees define 32 codes (all 5 bits) to fill out the
+      Huffman codes, but the last two had better not show up in the data.
+   7. Unzip can check dynamic Huffman blocks for complete code sets.
+      The exception is that a single code would not be complete (see #4).
+   8. The five bits following the block type is really the number of
+      literal codes sent minus 257.
+   9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
+      (1+6+6).  Therefore, to output three times the length, you output
+      three codes (1+1+1), whereas to output four times the same length,
+      you only need two codes (1+3).  Hmm.
+  10. In the tree reconstruction algorithm, Code = Code + Increment
+      only if BitLength(i) is not zero.  (Pretty obvious.)
+  11. Correction: 4 Bits: # of Bit Length codes - 4     (4 - 19)
+  12. Note: length code 284 can represent 227-258, but length code 285
+      really is 258.  The last length deserves its own, short code
+      since it gets used a lot in very redundant files.  The length
+      258 is special since 258 - 3 (the min match length) is 255.
+  13. The literal/length and distance code bit lengths are read as a
+      single stream of lengths.  It is possible (and advantageous) for
+      a repeat code (16, 17, or 18) to go across the boundary between
+      the two sets of lengths.
+ */
+
+
+void inflate_blocks_reset(s, z, c)
+inflate_blocks_statef *s;
+z_streamp z;
+uLongf *c;
+{
+  if (c != Z_NULL)
+    *c = s->check;
+  if (s->mode == BTREE || s->mode == DTREE)
+    ZFREE(z, s->sub.trees.blens);
+  if (s->mode == CODES)
+    inflate_codes_free(s->sub.decode.codes, z);
+  s->mode = TYPE;
+  s->bitk = 0;
+  s->bitb = 0;
+  s->read = s->write = s->window;
+  if (s->checkfn != Z_NULL)
+    z->adler = s->check = (*s->checkfn)(0L, (const Bytef *)Z_NULL, 0);
+  Tracev((stderr, "inflate:   blocks reset\n"));
+}
+
+
+inflate_blocks_statef *inflate_blocks_new(z, c, w)
+z_streamp z;
+check_func c;
+uInt w;
+{
+  inflate_blocks_statef *s;
+
+  if ((s = (inflate_blocks_statef *)ZALLOC
+       (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)
+    return s;
+  if ((s->hufts =
+       (inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL)
+  {
+    ZFREE(z, s);
+    return Z_NULL;
+  }
+  if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL)
+  {
+    ZFREE(z, s->hufts);
+    ZFREE(z, s);
+    return Z_NULL;
+  }
+  s->end = s->window + w;
+  s->checkfn = c;
+  s->mode = TYPE;
+  Tracev((stderr, "inflate:   blocks allocated\n"));
+  inflate_blocks_reset(s, z, Z_NULL);
+  return s;
+}
+
+
+int inflate_blocks(s, z, r)
+inflate_blocks_statef *s;
+z_streamp z;
+int r;
+{
+  uInt t;               /* temporary storage */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Bytef *p;             /* input data pointer */
+  uInt n;               /* bytes available there */
+  Bytef *q;             /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
+
+  /* copy input/output information to locals (UPDATE macro restores) */
+  LOAD
+
+  /* process input based on current state */
+  while (1) switch (s->mode)
+  {
+    case TYPE:
+      NEEDBITS(3)
+      t = (uInt)b & 7;
+      s->last = t & 1;
+      switch (t >> 1)
+      {
+        case 0:                         /* stored */
+          Tracev((stderr, "inflate:     stored block%s\n",
+                 s->last ? " (last)" : ""));
+          DUMPBITS(3)
+          t = k & 7;                    /* go to byte boundary */
+          DUMPBITS(t)
+          s->mode = LENS;               /* get length of stored block */
+          break;
+        case 1:                         /* fixed */
+          Tracev((stderr, "inflate:     fixed codes block%s\n",
+                 s->last ? " (last)" : ""));
+          {
+            uInt bl, bd;
+            inflate_huft *tl, *td;
+
+            inflate_trees_fixed(&bl, &bd, &tl, &td, z);
+            s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);
+            if (s->sub.decode.codes == Z_NULL)
+            {
+              r = Z_MEM_ERROR;
+              LEAVE
+            }
+          }
+          DUMPBITS(3)
+          s->mode = CODES;
+          break;
+        case 2:                         /* dynamic */
+          Tracev((stderr, "inflate:     dynamic codes block%s\n",
+                 s->last ? " (last)" : ""));
+          DUMPBITS(3)
+          s->mode = TABLE;
+          break;
+        case 3:                         /* illegal */
+          DUMPBITS(3)
+          s->mode = BAD;
+          z->msg = (char*)"invalid block type";
+          r = Z_DATA_ERROR;
+          LEAVE
+      }
+      break;
+    case LENS:
+      NEEDBITS(32)
+      if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
+      {
+        s->mode = BAD;
+        z->msg = (char*)"invalid stored block lengths";
+        r = Z_DATA_ERROR;
+        LEAVE
+      }
+      s->sub.left = (uInt)b & 0xffff;
+      b = k = 0;                      /* dump bits */
+      Tracev((stderr, "inflate:       stored length %u\n", s->sub.left));
+      s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE);
+      break;
+    case STORED:
+      if (n == 0)
+        LEAVE
+      NEEDOUT
+      t = s->sub.left;
+      if (t > n) t = n;
+      if (t > m) t = m;
+      zmemcpy(q, p, t);
+      p += t;  n -= t;
+      q += t;  m -= t;
+      if ((s->sub.left -= t) != 0)
+        break;
+      Tracev((stderr, "inflate:       stored end, %lu total out\n",
+              z->total_out + (q >= s->read ? q - s->read :
+              (s->end - s->read) + (q - s->window))));
+      s->mode = s->last ? DRY : TYPE;
+      break;
+    case TABLE:
+      NEEDBITS(14)
+      s->sub.trees.table = t = (uInt)b & 0x3fff;
+#ifndef PKZIP_BUG_WORKAROUND
+      if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
+      {
+        s->mode = BAD;
+        z->msg = (char*)"too many length or distance symbols";
+        r = Z_DATA_ERROR;
+        LEAVE
+      }
+#endif
+      t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
+      if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
+      {
+        r = Z_MEM_ERROR;
+        LEAVE
+      }
+      DUMPBITS(14)
+      s->sub.trees.index = 0;
+      Tracev((stderr, "inflate:       table sizes ok\n"));
+      s->mode = BTREE;
+    case BTREE:
+      while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
+      {
+        NEEDBITS(3)
+        s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
+        DUMPBITS(3)
+      }
+      while (s->sub.trees.index < 19)
+        s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
+      s->sub.trees.bb = 7;
+      t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
+                             &s->sub.trees.tb, s->hufts, z);
+      if (t != Z_OK)
+      {
+        ZFREE(z, s->sub.trees.blens);
+        r = t;
+        if (r == Z_DATA_ERROR)
+          s->mode = BAD;
+        LEAVE
+      }
+      s->sub.trees.index = 0;
+      Tracev((stderr, "inflate:       bits tree ok\n"));
+      s->mode = DTREE;
+    case DTREE:
+      while (t = s->sub.trees.table,
+             s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
+      {
+        inflate_huft *h;
+        uInt i, j, c;
+
+        t = s->sub.trees.bb;
+        NEEDBITS(t)
+        h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
+        t = h->bits;
+        c = h->base;
+        if (c < 16)
+        {
+          DUMPBITS(t)
+          s->sub.trees.blens[s->sub.trees.index++] = c;
+        }
+        else /* c == 16..18 */
+        {
+          i = c == 18 ? 7 : c - 14;
+          j = c == 18 ? 11 : 3;
+          NEEDBITS(t + i)
+          DUMPBITS(t)
+          j += (uInt)b & inflate_mask[i];
+          DUMPBITS(i)
+          i = s->sub.trees.index;
+          t = s->sub.trees.table;
+          if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
+              (c == 16 && i < 1))
+          {
+            ZFREE(z, s->sub.trees.blens);
+            s->mode = BAD;
+            z->msg = (char*)"invalid bit length repeat";
+            r = Z_DATA_ERROR;
+            LEAVE
+          }
+          c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
+          do {
+            s->sub.trees.blens[i++] = c;
+          } while (--j);
+          s->sub.trees.index = i;
+        }
+      }
+      s->sub.trees.tb = Z_NULL;
+      {
+        uInt bl, bd;
+        inflate_huft *tl, *td;
+        inflate_codes_statef *c;
+
+        bl = 9;         /* must be <= 9 for lookahead assumptions */
+        bd = 6;         /* must be <= 9 for lookahead assumptions */
+        t = s->sub.trees.table;
+        t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
+                                  s->sub.trees.blens, &bl, &bd, &tl, &td,
+                                  s->hufts, z);
+        ZFREE(z, s->sub.trees.blens);
+        if (t != Z_OK)
+        {
+          if (t == (uInt)Z_DATA_ERROR)
+            s->mode = BAD;
+          r = t;
+          LEAVE
+        }
+        Tracev((stderr, "inflate:       trees ok\n"));
+        if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
+        {
+          r = Z_MEM_ERROR;
+          LEAVE
+        }
+        s->sub.decode.codes = c;
+      }
+      s->mode = CODES;
+    case CODES:
+      UPDATE
+      if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
+        return inflate_flush(s, z, r);
+      r = Z_OK;
+      inflate_codes_free(s->sub.decode.codes, z);
+      LOAD
+      Tracev((stderr, "inflate:       codes end, %lu total out\n",
+              z->total_out + (q >= s->read ? q - s->read :
+              (s->end - s->read) + (q - s->window))));
+      if (!s->last)
+      {
+        s->mode = TYPE;
+        break;
+      }
+      s->mode = DRY;
+    case DRY:
+      FLUSH
+      if (s->read != s->write)
+        LEAVE
+      s->mode = DONE;
+    case DONE:
+      r = Z_STREAM_END;
+      LEAVE
+    case BAD:
+      r = Z_DATA_ERROR;
+      LEAVE
+    default:
+      r = Z_STREAM_ERROR;
+      LEAVE
+  }
+}
+
+
+int inflate_blocks_free(s, z)
+inflate_blocks_statef *s;
+z_streamp z;
+{
+  inflate_blocks_reset(s, z, Z_NULL);
+  ZFREE(z, s->window);
+  ZFREE(z, s->hufts);
+  ZFREE(z, s);
+  Tracev((stderr, "inflate:   blocks freed\n"));
+  return Z_OK;
+}
+
+
+void inflate_set_dictionary(s, d, n)
+inflate_blocks_statef *s;
+const Bytef *d;
+uInt  n;
+{
+  zmemcpy(s->window, d, n);
+  s->read = s->write = s->window + n;
+}
+
+
+/* Returns true if inflate is currently at the end of a block generated
+ * by Z_SYNC_FLUSH or Z_FULL_FLUSH. 
+ * IN assertion: s != Z_NULL
+ */
+int inflate_blocks_sync_point(s)
+inflate_blocks_statef *s;
+{
+  return s->mode == LENS;
+}

reactos/apps/utils/cabman/zlib/infblock.h

@@ -0,0 +1,39 @@
+/* infblock.h -- header to use infblock.c
+ * Copyright (C) 1995-1998 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+struct inflate_blocks_state;
+typedef struct inflate_blocks_state FAR inflate_blocks_statef;
+
+extern inflate_blocks_statef * inflate_blocks_new OF((
+    z_streamp z,
+    check_func c,               /* check function */
+    uInt w));                   /* window size */
+
+extern int inflate_blocks OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    int));                      /* initial return code */
+
+extern void inflate_blocks_reset OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    uLongf *));                  /* check value on output */
+
+extern int inflate_blocks_free OF((
+    inflate_blocks_statef *,
+    z_streamp));
+
+extern void inflate_set_dictionary OF((
+    inflate_blocks_statef *s,
+    const Bytef *d,  /* dictionary */
+    uInt  n));       /* dictionary length */
+
+extern int inflate_blocks_sync_point OF((
+    inflate_blocks_statef *s));

reactos/apps/utils/cabman/zlib/infcodes.c

@@ -0,0 +1,257 @@
+/* infcodes.c -- process literals and length/distance pairs
+ * Copyright (C) 1995-1998 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "infblock.h"
+#include "infcodes.h"
+#include "infutil.h"
+#include "inffast.h"
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+typedef enum {        /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
+      START,    /* x: set up for LEN */
+      LEN,      /* i: get length/literal/eob next */
+      LENEXT,   /* i: getting length extra (have base) */
+      DIST,     /* i: get distance next */
+      DISTEXT,  /* i: getting distance extra */
+      COPY,     /* o: copying bytes in window, waiting for space */
+      LIT,      /* o: got literal, waiting for output space */
+      WASH,     /* o: got eob, possibly still output waiting */
+      END,      /* x: got eob and all data flushed */
+      BADCODE}  /* x: got error */
+inflate_codes_mode;
+
+/* inflate codes private state */
+struct inflate_codes_state {
+
+  /* mode */
+  inflate_codes_mode mode;      /* current inflate_codes mode */
+
+  /* mode dependent information */
+  uInt len;
+  union {
+    struct {
+      inflate_huft *tree;       /* pointer into tree */
+      uInt need;                /* bits needed */
+    } code;             /* if LEN or DIST, where in tree */
+    uInt lit;           /* if LIT, literal */
+    struct {
+      uInt get;                 /* bits to get for extra */
+      uInt dist;                /* distance back to copy from */
+    } copy;             /* if EXT or COPY, where and how much */
+  } sub;                /* submode */
+
+  /* mode independent information */
+  Byte lbits;           /* ltree bits decoded per branch */
+  Byte dbits;           /* dtree bits decoder per branch */
+  inflate_huft *ltree;          /* literal/length/eob tree */
+  inflate_huft *dtree;          /* distance tree */
+
+};
+
+
+inflate_codes_statef *inflate_codes_new(bl, bd, tl, td, z)
+uInt bl, bd;
+inflate_huft *tl;
+inflate_huft *td; /* need separate declaration for Borland C++ */
+z_streamp z;
+{
+  inflate_codes_statef *c;
+
+  if ((c = (inflate_codes_statef *)
+       ZALLOC(z,1,sizeof(struct inflate_codes_state))) != Z_NULL)
+  {
+    c->mode = START;
+    c->lbits = (Byte)bl;
+    c->dbits = (Byte)bd;
+    c->ltree = tl;
+    c->dtree = td;
+    Tracev((stderr, "inflate:       codes new\n"));
+  }
+  return c;
+}
+
+
+int inflate_codes(s, z, r)
+inflate_blocks_statef *s;
+z_streamp z;
+int r;
+{
+  uInt j;               /* temporary storage */
+  inflate_huft *t;      /* temporary pointer */
+  uInt e;               /* extra bits or operation */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Bytef *p;             /* input data pointer */
+  uInt n;               /* bytes available there */
+  Bytef *q;             /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
+  Bytef *f;             /* pointer to copy strings from */
+  inflate_codes_statef *c = s->sub.decode.codes;  /* codes state */
+
+  /* copy input/output information to locals (UPDATE macro restores) */
+  LOAD
+
+  /* process input and output based on current state */
+  while (1) switch (c->mode)
+  {             /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
+    case START:         /* x: set up for LEN */
+#ifndef SLOW
+      if (m >= 258 && n >= 10)
+      {
+        UPDATE
+        r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);
+        LOAD
+        if (r != Z_OK)
+        {
+          c->mode = r == Z_STREAM_END ? WASH : BADCODE;
+          break;
+        }
+      }
+#endif /* !SLOW */
+      c->sub.code.need = c->lbits;
+      c->sub.code.tree = c->ltree;
+      c->mode = LEN;
+    case LEN:           /* i: get length/literal/eob next */
+      j = c->sub.code.need;
+      NEEDBITS(j)
+      t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
+      DUMPBITS(t->bits)
+      e = (uInt)(t->exop);
+      if (e == 0)               /* literal */
+      {
+        c->sub.lit = t->base;
+        Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
+                 "inflate:         literal '%c'\n" :
+                 "inflate:         literal 0x%02x\n", t->base));
+        c->mode = LIT;
+        break;
+      }
+      if (e & 16)               /* length */
+      {
+        c->sub.copy.get = e & 15;
+        c->len = t->base;
+        c->mode = LENEXT;
+        break;
+      }
+      if ((e & 64) == 0)        /* next table */
+      {
+        c->sub.code.need = e;
+        c->sub.code.tree = t + t->base;
+        break;
+      }
+      if (e & 32)               /* end of block */
+      {
+        Tracevv((stderr, "inflate:         end of block\n"));
+        c->mode = WASH;
+        break;
+      }
+      c->mode = BADCODE;        /* invalid code */
+      z->msg = (char*)"invalid literal/length code";
+      r = Z_DATA_ERROR;
+      LEAVE
+    case LENEXT:        /* i: getting length extra (have base) */
+      j = c->sub.copy.get;
+      NEEDBITS(j)
+      c->len += (uInt)b & inflate_mask[j];
+      DUMPBITS(j)
+      c->sub.code.need = c->dbits;
+      c->sub.code.tree = c->dtree;
+      Tracevv((stderr, "inflate:         length %u\n", c->len));
+      c->mode = DIST;
+    case DIST:          /* i: get distance next */
+      j = c->sub.code.need;
+      NEEDBITS(j)
+      t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
+      DUMPBITS(t->bits)
+      e = (uInt)(t->exop);
+      if (e & 16)               /* distance */
+      {
+        c->sub.copy.get = e & 15;
+        c->sub.copy.dist = t->base;
+        c->mode = DISTEXT;
+        break;
+      }
+      if ((e & 64) == 0)        /* next table */
+      {
+        c->sub.code.need = e;
+        c->sub.code.tree = t + t->base;
+        break;
+      }
+      c->mode = BADCODE;        /* invalid code */
+      z->msg = (char*)"invalid distance code";
+      r = Z_DATA_ERROR;
+      LEAVE
+    case DISTEXT:       /* i: getting distance extra */
+      j = c->sub.copy.get;
+      NEEDBITS(j)
+      c->sub.copy.dist += (uInt)b & inflate_mask[j];
+      DUMPBITS(j)
+      Tracevv((stderr, "inflate:         distance %u\n", c->sub.copy.dist));
+      c->mode = COPY;
+    case COPY:          /* o: copying bytes in window, waiting for space */
+#ifndef __TURBOC__ /* Turbo C bug for following expression */
+      f = (uInt)(q - s->window) < c->sub.copy.dist ?
+          s->end - (c->sub.copy.dist - (q - s->window)) :
+          q - c->sub.copy.dist;
+#else
+      f = q - c->sub.copy.dist;
+      if ((uInt)(q - s->window) < c->sub.copy.dist)
+        f = s->end - (c->sub.copy.dist - (uInt)(q - s->window));
+#endif
+      while (c->len)
+      {
+        NEEDOUT
+        OUTBYTE(*f++)
+        if (f == s->end)
+          f = s->window;
+        c->len--;
+      }
+      c->mode = START;
+      break;
+    case LIT:           /* o: got literal, waiting for output space */
+      NEEDOUT
+      OUTBYTE(c->sub.lit)
+      c->mode = START;
+      break;
+    case WASH:          /* o: got eob, possibly more output */
+      if (k > 7)        /* return unused byte, if any */
+      {
+        Assert(k < 16, "inflate_codes grabbed too many bytes")
+        k -= 8;
+        n++;
+        p--;            /* can always return one */
+      }
+      FLUSH
+      if (s->read != s->write)
+        LEAVE
+      c->mode = END;
+    case END:
+      r = Z_STREAM_END;
+      LEAVE
+    case BADCODE:       /* x: got error */
+      r = Z_DATA_ERROR;
+      LEAVE
+    default:
+      r = Z_STREAM_ERROR;
+      LEAVE
+  }
+#ifdef NEED_DUMMY_RETURN
+  return Z_STREAM_ERROR;  /* Some dumb compilers complain without this */
+#endif
+}
+
+
+void inflate_codes_free(c, z)
+inflate_codes_statef *c;
+z_streamp z;
+{
+  ZFREE(z, c);
+  Tracev((stderr, "inflate:       codes free\n"));
+}

reactos/apps/utils/cabman/zlib/infcodes.h

@@ -0,0 +1,27 @@
+/* infcodes.h -- header to use infcodes.c
+ * Copyright (C) 1995-1998 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+struct inflate_codes_state;
+typedef struct inflate_codes_state FAR inflate_codes_statef;
+
+extern inflate_codes_statef *inflate_codes_new OF((
+    uInt, uInt,
+    inflate_huft *, inflate_huft *,
+    z_streamp ));
+
+extern int inflate_codes OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    int));
+
+extern void inflate_codes_free OF((
+    inflate_codes_statef *,
+    z_streamp ));
+

reactos/apps/utils/cabman/zlib/inffast.c

@@ -0,0 +1,170 @@
+/* inffast.c -- process literals and length/distance pairs fast
+ * Copyright (C) 1995-1998 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "infblock.h"
+#include "infcodes.h"
+#include "infutil.h"
+#include "inffast.h"
+
+struct inflate_codes_state {int dummy;}; /* for buggy compilers */
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+/* macros for bit input with no checking and for returning unused bytes */
+#define GRABBITS(j) {while(k<(j)){b|=((uLong)NEXTBYTE)<<k;k+=8;}}
+#define UNGRAB {c=z->avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;}
+
+/* Called with number of bytes left to write in window at least 258
+   (the maximum string length) and number of input bytes available
+   at least ten.  The ten bytes are six bytes for the longest length/
+   distance pair plus four bytes for overloading the bit buffer. */
+
+int inflate_fast(bl, bd, tl, td, s, z)
+uInt bl, bd;
+inflate_huft *tl;
+inflate_huft *td; /* need separate declaration for Borland C++ */
+inflate_blocks_statef *s;
+z_streamp z;
+{
+  inflate_huft *t;      /* temporary pointer */
+  uInt e;               /* extra bits or operation */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Bytef *p;             /* input data pointer */
+  uInt n;               /* bytes available there */
+  Bytef *q;             /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
+  uInt ml;              /* mask for literal/length tree */
+  uInt md;              /* mask for distance tree */
+  uInt c;               /* bytes to copy */
+  uInt d;               /* distance back to copy from */
+  Bytef *r;             /* copy source pointer */
+
+  /* load input, output, bit values */
+  LOAD
+
+  /* initialize masks */
+  ml = inflate_mask[bl];
+  md = inflate_mask[bd];
+
+  /* do until not enough input or output space for fast loop */
+  do {                          /* assume called with m >= 258 && n >= 10 */
+    /* get literal/length code */
+    GRABBITS(20)                /* max bits for literal/length code */
+    if ((e = (t = tl + ((uInt)b & ml))->exop) == 0)
+    {
+      DUMPBITS(t->bits)
+      Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
+                "inflate:         * literal '%c'\n" :
+                "inflate:         * literal 0x%02x\n", t->base));
+      *q++ = (Byte)t->base;
+      m--;
+      continue;
+    }
+    do {
+      DUMPBITS(t->bits)
+      if (e & 16)
+      {
+        /* get extra bits for length */
+        e &= 15;
+        c = t->base + ((uInt)b & inflate_mask[e]);
+        DUMPBITS(e)
+        Tracevv((stderr, "inflate:         * length %u\n", c));
+
+        /* decode distance base of block to copy */
+        GRABBITS(15);           /* max bits for distance code */
+        e = (t = td + ((uInt)b & md))->exop;
+        do {
+          DUMPBITS(t->bits)
+          if (e & 16)
+          {
+            /* get extra bits to add to distance base */
+            e &= 15;
+            GRABBITS(e)         /* get extra bits (up to 13) */
+            d = t->base + ((uInt)b & inflate_mask[e]);
+            DUMPBITS(e)
+            Tracevv((stderr, "inflate:         * distance %u\n", d));
+
+            /* do the copy */
+            m -= c;
+            if ((uInt)(q - s->window) >= d)     /* offset before dest */
+            {                                   /*  just copy */
+              r = q - d;
+              *q++ = *r++;  c--;        /* minimum count is three, */
+              *q++ = *r++;  c--;        /*  so unroll loop a little */
+            }
+            else                        /* else offset after destination */
+            {
+              e = d - (uInt)(q - s->window); /* bytes from offset to end */
+              r = s->end - e;           /* pointer to offset */
+              if (c > e)                /* if source crosses, */
+              {
+                c -= e;                 /* copy to end of window */
+                do {
+                  *q++ = *r++;
+                } while (--e);
+                r = s->window;          /* copy rest from start of window */
+              }
+            }
+            do {                        /* copy all or what's left */
+              *q++ = *r++;
+            } while (--c);
+            break;
+          }
+          else if ((e & 64) == 0)
+          {
+            t += t->base;
+            e = (t += ((uInt)b & inflate_mask[e]))->exop;
+          }
+          else
+          {
+            z->msg = (char*)"invalid distance code";
+            UNGRAB
+            UPDATE
+            return Z_DATA_ERROR;
+          }
+        } while (1);
+        break;
+      }
+      if ((e & 64) == 0)
+      {
+        t += t->base;
+        if ((e = (t += ((uInt)b & inflate_mask[e]))->exop) == 0)
+        {
+          DUMPBITS(t->bits)
+          Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
+                    "inflate:         * literal '%c'\n" :
+                    "inflate:         * literal 0x%02x\n", t->base));
+          *q++ = (Byte)t->base;
+          m--;
+          break;
+        }
+      }
+      else if (e & 32)
+      {
+        Tracevv((stderr, "inflate:         * end of block\n"));
+        UNGRAB
+        UPDATE
+        return Z_STREAM_END;
+      }
+      else
+      {
+        z->msg = (char*)"invalid literal/length code";
+        UNGRAB
+        UPDATE
+        return Z_DATA_ERROR;
+      }
+    } while (1);
+  } while (m >= 258 && n >= 10);
+
+  /* not enough input or output--restore pointers and return */
+  UNGRAB
+  UPDATE
+  return Z_OK;
+}