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

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

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

@@ -2,7 +2,7 @@ In no particular order
 
 Rex Jolliff (rex@lvcablemodem.com)
 Boudewijn Dekker (ariadne@xs4all.nl)
-Eric Kohl (ekohl@abo.rhein-zeitung.de)
+Eric Kohl (ekohl@rz-online.de)
 Emanuele Aliberti (ea@iol.it)
 David Welch (welch@cwcom.net)
 Iwan Fatahi (i_fatahi@hotmail.com)
@@ -12,3 +12,30 @@ 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

@@ -1,16 +1,154 @@
-27/5/00:       Fixed issue with closing non-existent or already closed handle
+2001-03-18  David Welch  <welch@cwcom>
 
-26/1/99:       ZwCreateProcess now maps ntdll rather than the user-mode code
+	* 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.
 
-9/6/99:        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)
+2001-03-17  David Welch  <welch@cwcom.net>
 
-8/12/98:       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
+	* 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

@@ -17,15 +17,23 @@ structure like the following
 
 make directories C:\reactos,C:\reactos\system32,C:\reactos\system32\drivers
 
-Copy apps/shell/shell.exe to C:\reactos\system32
+Copy apps/system/shell/shell.exe to C:\reactos\system32
 Copy subsys/smss/smss.exe to C:\reactos\system32
-Copy services/dd/keyboard/keyboard.sys to C:\reactos\system32\drivers
+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 and
-loaders/dos/loadros.com, to a suitable directory. The system can then be
-booted with the command 'loadros.com ide.sys vfatfsd.sys'.
+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

@@ -6,62 +6,116 @@
 # Select your host
 #
 #HOST = mingw32-linux
-#HOST = djgpp-msdos
 #HOST = mingw32-windows
 
+PATH_TO_TOP = .
+
 include rules.mak
 
 #
 # Required to run the system
 #
 COMPONENTS = iface_native iface_additional ntoskrnl
-DLLS = ntdll kernel32 crtdll advapi32 fmifs gdi32
-#DLLS = mingw32
+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
-# SERVERS = posix linux os2
 
 #
 # Select the loader(s) you want to build
 #
+#LOADERS = boot dos
 LOADERS = dos
-# LOADERS = boot
 
 #
 # Select the device drivers and filesystems you want
 #
-DEVICE_DRIVERS = blue ide keyboard null parallel serial vidport
-# DEVICE_DRIVERS = beep event floppy ide_test mouse sound test test1
-FS_DRIVERS = vfat minix
-# FS_DRIVERS = minix ext2 template
-KERNEL_SERVICES = $(DEVICE_DRIVERS) $(FS_DRIVERS)
+#DEVICE_DRIVERS = beep floppy mouse sound test parallel serial
+DEVICE_DRIVERS = vidport vga blue ide null floppy
 
-APPS = args hello shell test cat bench apc shm lpc thread event file gditest \
-       pteb consume
-       
-#       objdir
+#INPUT_DRIVERS = keyboard
+INPUT_DRIVERS = keyboard mouclass psaux
 
-all: buildno $(COMPONENTS) $(DLLS) $(SUBSYS) $(LOADERS) $(KERNEL_SERVICES) $(APPS)
+#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: buildno_clean $(COMPONENTS:%=%_clean) $(DLLS:%=%_clean) $(LOADERS:%=%_clean) \
-       $(KERNEL_SERVICES:%=%_clean) $(SUBSYS:%=%_clean) $(APPS:%=%_clean)
-       
+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
 
-floppy: make_floppy_dirs autoexec_floppy $(COMPONENTS:%=%_floppy) \
-        $(DLLS:%=%_floppy) $(LOADERS:%=%_floppy) \
-        $(KERNEL_SERVICES:%=%_floppy) $(SUBSYS:%=%_floppy) \
-        $(APPS:%=%_floppy)
+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
 
-dist: clean_dist_dir make_dist_dirs $(COMPONENTS:%=%_dist) $(DLLS:%=%_dist) \
+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) \
-      $(APPS:%=%_dist)
+      $(SYS_APPS:%=%_dist) $(APPS:%=%_dist) $(NET_APPS:%=%_dist)
 
 #
 # Build number generator
@@ -72,11 +126,28 @@ buildno: include/reactos/version.h
 buildno_clean:
 	make -C apps/buildno clean
 
-buildno_floppy:
-
 buildno_dist:
 
-.PHONY: buildno buildno_clean buildno_floppy 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
@@ -87,13 +158,30 @@ $(APPS): %:
 $(APPS:%=%_clean): %_clean:
 	make -C apps/$* clean
 
-$(APPS:%=%_floppy): %_floppy:
-	make -C apps/$* floppy
-
 $(APPS:%=%_dist): %_dist:
 	make -C apps/$* dist
 
-.PHONY: $(APPS) $(APPS:%=%_clean) $(APPS:%=%_floppy) $(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
@@ -104,7 +192,7 @@ iface_native:
 iface_native_clean:
 	make -C iface/native clean
 
-iface_native_floppy:
+iface_native_install:
 
 iface_native_dist:
 
@@ -114,14 +202,32 @@ iface_additional:
 iface_additional_clean:
 	make -C iface/addsys clean
 
-iface_additional_floppy:
+iface_additional_install:
 
 iface_additional_dist:
 
-.PHONY: iface_native iface_native_clean iface_native_floppy \
+.PHONY: iface_native iface_native_clean iface_native_install \
         iface_native_dist \
-	iface_additional iface_additional_clean iface_additional_floppy \
-        iface_additional_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
@@ -132,14 +238,32 @@ $(DEVICE_DRIVERS): %:
 $(DEVICE_DRIVERS:%=%_clean): %_clean:
 	make -C services/dd/$* clean
 
-$(DEVICE_DRIVERS:%=%_floppy): %_floppy:
-	make -C services/dd/$* floppy
+$(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:%=%_floppy) $(DEVICE_DRIVERS:%=%_dist)
+        $(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/$*
@@ -147,14 +271,65 @@ $(FS_DRIVERS): %:
 $(FS_DRIVERS:%=%_clean): %_clean:
 	make -C services/fs/$* clean
 
-$(FS_DRIVERS:%=%_floppy): %_floppy:
-	make -C services/fs/$* floppy
+$(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:%=%_floppy) \
-        $(FS_DRIVERS:%=%_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
@@ -166,13 +341,13 @@ $(LOADERS): %:
 $(LOADERS:%=%_clean): %_clean:
 	make -C loaders/$* clean
 
-$(LOADERS:%=%_floppy): %_floppy:
-	make -C loaders/$* floppy
+$(LOADERS:%=%_install): %_install:
+	make -C loaders/$* install
 
 $(LOADERS:%=%_dist): %_dist:
 	make -C loaders/$* dist
 
-.PHONY: $(LOADERS) $(LOADERS:%=%_clean) $(LOADERS:%=%_floppy) \
+.PHONY: $(LOADERS) $(LOADERS:%=%_clean) $(LOADERS:%=%_install) \
         $(LOADERS:%=%_dist)
 
 #
@@ -185,13 +360,13 @@ ntoskrnl:
 ntoskrnl_clean:
 	make -C ntoskrnl clean
 
-ntoskrnl_floppy:
-	make -C ntoskrnl floppy
+ntoskrnl_install:
+	make -C ntoskrnl install
 
 ntoskrnl_dist:
 	make -C ntoskrnl dist
 
-.PHONY: ntoskrnl ntoskrnl_clean ntoskrnl_floppy ntoskrnl_dist
+.PHONY: ntoskrnl ntoskrnl_clean ntoskrnl_install ntoskrnl_dist
 
 #
 # Required DLLs
@@ -203,62 +378,49 @@ $(DLLS): %:
 $(DLLS:%=%_clean): %_clean:
 	make -C lib/$* clean
 
-$(DLLS:%=%_floppy): %_floppy:
-	make -C lib/$* floppy
+$(DLLS:%=%_install): %_install:
+	make -C lib/$* install
 
 $(DLLS:%=%_dist): %_dist:
 	make -C lib/$* dist
 
-.PHONY: $(DLLS) $(DLLS:%=%_clean) $(DLLS:%=%_floppy) $(DLLS:%=%_dist)
+.PHONY: $(DLLS) $(DLLS:%=%_clean) $(DLLS:%=%_install) $(DLLS:%=%_dist)
 
 #
 # Kernel Subsystems
 #
+
 $(SUBSYS): %:
 	make -C subsys/$*
 
 $(SUBSYS:%=%_clean): %_clean:
 	make -C subsys/$* clean
 
-$(SUBSYS:%=%_floppy): %_floppy:
-	make -C subsys/$* floppy
+$(SUBSYS:%=%_install): %_install:
+	make -C subsys/$* install
 
 $(SUBSYS:%=%_dist): %_dist:
 	make -C subsys/$* dist
 
-.PHONY: $(SUBSYS) $(SUBSYS:%=%_clean) $(SUBSYS:%=%_floppy) \
+.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
 
-install: all
-	./install.sh /mnt/hda1
-	./install.sh /mnt/hda4
-	./install.bochs
 
-make_floppy_dirs:
-ifeq ($(DOSCLI),yes)
-	mkdir $(FLOPPY_DIR)\dlls
-	mkdir $(FLOPPY_DIR)\apps
-	mkdir $(FLOPPY_DIR)\drivers
-	mkdir $(FLOPPY_DIR)\subsys
-else
-	mkdir $(FLOPPY_DIR)/dlls $(FLOPPY_DIR)/apps $(FLOPPY_DIR)/drivers
-	mkdir $(FLOPPY_DIR)/subsys
-endif
+.PHONY: make_install_dirs
 
-.PHONY: make_floppy_dirs
-
-autoexec_floppy: $(FLOPPY_DIR)/autoexec.bat
+autoexec_install: $(FLOPPY_DIR)/autoexec.bat
 
 $(FLOPPY_DIR)/autoexec.bat: bootflop.bat
-ifeq ($(DOSCLI),yes)
-	$(CP) bootflop.bat $(FLOPPY_DIR)\autoexec.bat
-else
 	$(CP) bootflop.bat $(FLOPPY_DIR)/autoexec.bat
-endif
 
 #
 # Make a distribution saveset
@@ -279,18 +441,13 @@ else
 	$(RM) -r $(DIST_DIR)
 endif
 
-make_dist_dirs:
-ifeq ($(DOSCLI),yes)
-	mkdir $(DIST_DIR)
-	mkdir $(DIST_DIR)\dlls
-	mkdir $(DIST_DIR)\apps
-	mkdir $(DIST_DIR)\drivers
-	mkdir $(DIST_DIR)\dlls
-	mkdir $(DIST_DIR)\subsys
-else
-	mkdir $(DIST_DIR) $(DIST_DIR)/dlls $(DIST_DIR)/apps $(DIST_DIR)/drivers
-	mkdir $(DIST_DIR)/subsys
-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
 
@@ -299,3 +456,5 @@ endif
 #
 etags:
 	find . -name "*.[ch]" -print | etags --language=c -
+
+# EOF

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

@@ -7,20 +7,10 @@
 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);
-}
-
-VOID STDCALL ApcRoutine(PVOID Context,
-			PIO_STATUS_BLOCK IoStatus,
-			ULONG Reserved)
+VOID STDCALL 
+ApcRoutine(PVOID Context,
+	   PIO_STATUS_BLOCK IoStatus,
+	   ULONG Reserved)
 {
    printf("(apc.exe) ApcRoutine(Context %p)\n", Context);
 }
@@ -92,7 +82,6 @@ int main(int argc, char* argv[])
    printf("Returned from wait\n");
    ZwClose(FileHandle);
    printf("Program finished\n");
-   for(;;);
    return 0;
 }
 

reactos/apps/tests/apc/makefile

@@ -1,7 +1,11 @@
 #
 #
 #
-OBJECTS= ../common/crt0.o apc.o
+PATH_TO_TOP = ../..
+
+CFLAGS = -g
+
+OBJECTS= apc.o
 PROGS= apc.exe
 
 BASE_CFLAGS = -I../../include
@@ -13,32 +17,22 @@ all: $(PROGS)
 .phony: all
 
 clean:
-	- $(RM) apc.o
-	- $(RM) apc.exe
-	- $(RM) apc.sym
+	- $(RM) apc.o apc.exe apc.sym
 
 .phony: clean
 
-floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+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
 
 apc.exe: $(OBJECTS) $(LIBS)
-	$(LD) $(OBJECTS) $(LIBS) -o apc.exe
+	$(CC) $(OBJECTS) $(LIBS) -o apc.exe
 	$(NM) --numeric-sort apc.exe > apc.sym
 
 include ../../rules.mak

reactos/apps/tests/args/makefile

@@ -1,6 +1,8 @@
 #
 #
 #
+PATH_TO_TOP = ../..
+
 OBJECTS= args.o
 PROGS= args.exe
 
@@ -11,29 +13,19 @@ all: $(PROGS)
 .phony: all
 
 clean:
-	- $(RM) args.o
-	- $(RM) args.exe
-	- $(RM) args.sym
+	- $(RM) args.o args.exe args.sym
 
 .phony: clean
 
-floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+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
 
 args.exe: $(OBJECTS)
 	$(CC) $(OBJECTS) -o args.exe

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-thread.c

@@ -1,14 +1,14 @@
 #include <stdio.h>
 #include <windows.h>
 
-#define NR_THREADS (0x1)
+#define NR_THREADS (30)
 
 
 DWORD WINAPI
 thread_main1(LPVOID param)
 {
    printf("Thread 1 running (Counter %lu)\n", (DWORD)param);
-
+   SleepEx(INFINITE, TRUE);
    return 0;
 }
 
@@ -17,7 +17,7 @@ DWORD WINAPI
 thread_main2(LPVOID param)
 {
    printf("Thread 2 running (Counter %lu)\n", (DWORD)param);
-
+   Sleep(INFINITE);
    return 0;
 }
 
@@ -77,6 +77,6 @@ int main (void)
 
    printf("Thread terminated...\n");
 #endif
-
+   printf("Exiting\n");
    return 0;
 }

reactos/apps/tests/bench/makefile

@@ -1,38 +1,28 @@
 #
 #
 #
+PATH_TO_TOP = ../..
+
 PROGS = bench-thread
 
 all: $(PROGS:%=%.exe)
 
 .phony: all
 
-clean: $(PROGS:%=%_clean)
-
-$(PROGS:%=%_clean): %_clean:
-	- $(RM) $*.o
-	- $(RM) $*.exe
-	- $(RM) $*.sym
+clean: 
+	- $(RM) *.o *.exe *.sym
 
 .phony: clean
 
-floppy: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
+install: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
 
 $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe): $(FLOPPY_DIR)/apps/%.exe: %.exe
-ifeq ($(DOSCLI),yes)
-	$(CP) $*.exe $(FLOPPY_DIR)\apps\$*.exe
-else
 	$(CP) $*.exe $(FLOPPY_DIR)/apps/$*.exe
-endif
 
 dist: $(PROGS:%=../../$(DIST_DIR)/apps/%.exe)
 
 $(PROGS:%=../../$(DIST_DIR)/apps/%.exe): ../../$(DIST_DIR)/apps/%.exe: %.exe
-ifeq ($(DOSCLI),yes)
-	$(CP) $*.exe ..\..\$(DIST_DIR)\apps\$*.exe
-else
 	$(CP) $*.exe ../../$(DIST_DIR)/apps/$*.exe
-endif
 
 bench-thread.exe: bench-thread.c
 	$(CC) $(CFLAGS) bench-thread.c -lkernel32 -o bench-thread.exe

reactos/apps/tests/consume/Makefile

@@ -1,6 +1,8 @@
 #
 #
 #
+PATH_TO_TOP = ../..
+
 OBJECTS = consume.o
 PROGS = consume.exe
 LIBS = 
@@ -8,30 +10,20 @@ CLEAN_FILES = consume.o consume.exe
 
 all: consume.exe
 
-clean: $(CLEAN_FILES:%=%_clean)
+clean: 
+	- $(RM) $(CLEAN_FILES)
 
-$(CLEAN_FILES:%=%_clean): %_clean:
-	- $(RM) $*
+.phony: clean 
 
-.phony: clean $(CLEAN_FILES:%=%_clean)
-
-floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+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
 
 consume.exe: $(OBJECTS)
 	$(CC) $(OBJECTS) -o consume.exe

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/makefile

@@ -1,38 +1,28 @@
 #
 #
 #
+PATH_TO_TOP = ../..
+
 PROGS = event
 
 all: $(PROGS:%=%.exe)
 
 .phony: all
 
-clean: $(PROGS:%=%_clean)
-
-$(PROGS:%=%_clean): %_clean:
-	- $(RM) $*.o
-	- $(RM) $*.exe
-	- $(RM) $*.sym
+clean: 
+	- $(RM) *.o *.exe *.sym
 
 .phony: clean
 
-floppy: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
+install: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
 
 $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe): $(FLOPPY_DIR)/apps/%.exe: %.exe
-ifeq ($(DOSCLI),yes)
-	$(CP) $*.exe $(FLOPPY_DIR)\apps\$*.exe
-else
 	$(CP) $*.exe $(FLOPPY_DIR)/apps/$*.exe
-endif
 
 dist: $(PROGS:%=../../$(DIST_DIR)/apps/%.exe)
 
 $(PROGS:%=../../$(DIST_DIR)/apps/%.exe): ../../$(DIST_DIR)/apps/%.exe: %.exe
-ifeq ($(DOSCLI),yes)
-	$(CP) $*.exe ..\..\$(DIST_DIR)\apps\$*.exe
-else
 	$(CP) $*.exe ../../$(DIST_DIR)/apps/$*.exe
-endif
 
 event.exe: event.c
 	$(CC) $(CFLAGS) event.c -lkernel32 -o event.exe

reactos/apps/tests/file/Makefile

@@ -1,6 +1,8 @@
 #
 #
 #
+PATH_TO_TOP = ../..
+
 OBJECTS= file.o
 PROGS= file.exe
 
@@ -11,29 +13,19 @@ all: $(PROGS)
 .phony: all
 
 clean:
-	- $(RM) file.o
-	- $(RM) file.exe
-	- $(RM) file.sym
+	- $(RM) file.o file.exe file.sym
 
 .phony: clean
 
-floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+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
 
 file.exe: $(OBJECTS)
 	$(CC) $(OBJECTS) $(BASE_CFLAGS) -o file.exe

reactos/apps/tests/gditest/gditest.c

@@ -4,53 +4,128 @@
 
 #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;
-	HPEN	RedPen, GreenPen;
-	HBITMAP	MyBitmap;
-	DWORD shit;
+  HDC  Desktop, MyDC, DC24;
+  HPEN  RedPen, GreenPen, BluePen, WhitePen;
+  HBITMAP  MyBitmap, DIB24;
+  HFONT  hf, tf;
+  BITMAPINFOHEADER BitInf;
+  BITMAPINFO BitPalInf;
 
-	GdiDllInitialize (NULL, DLL_PROCESS_ATTACH, NULL);
+  printf("Entering GDITest..\n");
 
-	// Set up a DC called Desktop that accesses DISPLAY
-	Desktop = CreateDCA("DISPLAY", NULL, NULL, NULL);
-	if (Desktop == NULL)
-		return 1;
+  GdiDllInitialize (NULL, DLL_PROCESS_ATTACH, NULL);
 
-	// Create a red pen and select it into the DC
-	RedPen = CreatePen(PS_SOLID, 8, 0x0000ff);
-	SelectObject(Desktop, RedPen);
+  // Set up a DC called Desktop that accesses DISPLAY
+  Desktop = CreateDCA("DISPLAY", NULL, NULL, NULL);
+  if (Desktop == NULL)
+    return 1;
 
-	// Draw a shap on the DC
-	MoveToEx(Desktop, 50, 50, NULL);
-	LineTo(Desktop, 200, 60);
-	LineTo(Desktop, 200, 300);
-	LineTo(Desktop, 50, 50);
+  // Background
+  Background (Desktop);
 
-	// Create a DC that is compatible with the DISPLAY DC along with a bitmap that is selected into it
-	MyDC = CreateCompatibleDC(Desktop);
-	MyBitmap = CreateCompatibleBitmap(Desktop, 151, 251);
-	SelectObject(MyDC, MyBitmap);
+  // Create a blue pen and select it into the DC
+  BluePen = CreatePen(PS_SOLID, 8, RGB(0, 0, 0xff));
+  SelectObject(Desktop, BluePen);
 
-	// Bitblt from the DISPLAY DC to MyDC and then back again in a different location
-	BitBlt(MyDC, 0, 0, 151, 251, Desktop, 50, 50, SRCCOPY);
+  // 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);
 
-	// Draw a rectangle on the memory DC before bltting back with a green pen
-	GreenPen = CreatePen(PS_SOLID, 3, 0x00ff00);
-	SelectObject(MyDC, GreenPen);
-	Rectangle(MyDC, 10, 10, 50, 50);
+  WhitePen = CreatePen(PS_SOLID, 3, RGB(0xff, 0xff, 0xff));
+  SelectObject(Desktop, GreenPen);
 
-	BitBlt(Desktop, 400, 100, 151, 251, MyDC, 0, 0, SRCCOPY);
+  MoveToEx(Desktop, 20, 70, NULL);
+  LineTo(Desktop, 500, 70);
+  MoveToEx(Desktop, 70, 20, NULL);
+  LineTo(Desktop, 70, 150);
 
-	TextOutA(Desktop, 200, 0, "ReactOS", 7);
-	TextOutA(Desktop, 200, 9, "This is a test of the ReactOS GDI functionality", 47);
-	TextOutA(Desktop, 200, 18, "The font being used is an internal static one", 45);
-	Sleep( 10000 );
-	// Free up everything
-	DeleteDC(Desktop);
-	DeleteDC(MyDC);
-	return 0;
+  // 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

@@ -1,46 +1,35 @@
 #
 #
 #
+PATH_TO_TOP = ../..
+
 PROGS = gditest
 
-OBJECTS= ../common/crt0.o
+OBJECTS = 
 LIBS= ../../lib/kernel32/kernel32.a ../../lib/gdi32/gdi32.a
-#LIBS= ../../lib/kernel32/kernel32.a ../../lib/crtdll/crtdll.a
-BASE_CFLAGS = -I../../include
+CFLAGS = -I../../include
 
 all: $(PROGS:%=%.exe)
 
 .phony: all
 
-$(PROGS:%=%_clean): %_clean:
-	- $(RM) $*.o
-	- $(RM) $*.exe
-	- $(RM) $*.sym
-
-clean: $(PROGS:%=%_clean)
+clean:
+	- $(RM) *.o *.exe *.sym
 
 .phony: clean
 
-floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
+install: $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
 
 $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe): $(FLOPPY_DIR)/apps/%.exe: %.exe
-ifeq ($(DOSCLI),yes)
-	$(CP) $*.exe $(FLOPPY_DIR)\apps\$*.exe
-else
 	$(CP) $*.exe $(FLOPPY_DIR)/apps/$*.exe
-endif
 
 dist: $(PROGS:%=../../$(DIST_DIR)/apps/%.exe)
 
 $(PROGS:%=../../$(DIST_DIR)/apps/%.exe): ../../$(DIST_DIR)/apps/%.exe: %.exe
-ifeq ($(DOSCLI),yes)
-	$(CP) $*.exe ..\..\$(DIST_DIR)\apps\$*.exe
-else
 	$(CP) $*.exe ../../$(DIST_DIR)/apps/$*.exe
-endif
 
 gditest.exe: gditest.c
-	$(CC) -specs=../../specs gditest.c $(BASE_CFLAGS) $(OBJECTS) $(LIBS) -lgcc -o gditest.exe
+	$(CC) $(CFLAGS) gditest.c $(LIBS) -o gditest.exe
 	$(NM) --numeric-sort gditest.exe > gditest.sym
 
 include ../../rules.mak

reactos/apps/tests/hello/makefile

@@ -1,6 +1,8 @@
 #
 #
 #
+PATH_TO_TOP = ../..
+
 OBJECTS = hello.o
 PROGS = hello.exe
 LIBS = 
@@ -8,30 +10,20 @@ CLEAN_FILES = hello.o hello.exe
 
 all: hello.exe
 
-clean: $(CLEAN_FILES:%=%_clean)
+clean: 
+	- $(RM) $(CLEAN_FILES)
 
-$(CLEAN_FILES:%=%_clean): %_clean:
-	- $(RM) $*
+.phony: clean 
 
-.phony: clean $(CLEAN_FILES:%=%_clean)
-
-floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+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
 
 hello.exe: $(OBJECTS)
 	$(CC) $(OBJECTS) -o hello.exe

reactos/apps/tests/lpc/makefile

@@ -1,8 +1,10 @@
 #
 #
 #
-SRV_OBJECTS= ../common/crt0.o lpcsrv.o
-CLT_OBJECTS= ../common/crt0.o lpcclt.o
+PATH_TO_TOP = ../..
+
+SRV_OBJECTS= lpcsrv.o
+CLT_OBJECTS= lpcclt.o
 
 PROGS= lpcsrv.exe lpcclt.exe
 
@@ -15,39 +17,26 @@ all: $(PROGS)
 .phony: all
 
 clean:
-	- $(RM) lpcsrv.o
-	- $(RM) lpcsrv.exe
-	- $(RM) lpcsrv.sym
-	- $(RM) lpcclt.o
-	- $(RM) lpcclt.exe
-	- $(RM) lpcsrv.sym
+	- $(RM) lpcsrv.o lpcsrv.exe lpcsrv.sym lpcclt.o lpcclt.exe lpcsrv.sym
 	
 .phony: clean
 
-floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+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
 
 lpcsrv.exe: $(SRV_OBJECTS) $(LIBS)
-	$(LD) $(SRV_OBJECTS) $(LIBS) -o lpcsrv.exe
+	$(CC) $(SRV_OBJECTS) $(LIBS) -o lpcsrv.exe
 	$(NM) --numeric-sort lpcsrv.exe > lpcsrv.sym
 
 lpcclt.exe: $(CLT_OBJECTS) $(LIBS)
-	$(LD) $(CLT_OBJECTS) $(LIBS) -o lpcclt.exe
+	$(CC) $(CLT_OBJECTS) $(LIBS) -o lpcclt.exe
 	$(NM) --numeric-sort lpcclt.exe > lpcclt.sym
 
 

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

@@ -1,99 +1,100 @@
-#include <windows.h> 
- 
-VOID MyErrExit(LPTSTR Message)
-{
-	MessageBox(NULL, Message, NULL, MB_OK);
-	ExitProcess(0);
-}
-
-DWORD 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; 
-} 
+#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

@@ -2,57 +2,86 @@
 #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, LPTSTR, LPDWORD)
+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;
 
-DWORD main (VOID)
+int main(int argc, char *argv[])
 {
    BOOL fConnected;
    DWORD dwThreadId;
    HANDLE hPipe, hThread;
-   LPTSTR lpszPipename = "\\\\.\\pipe\\mynamedpipe";
+   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);	
+//   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)
-	  MyErrExit ("CreatePipe");
-	
-	fConnected = ConnectNamedPipe (hPipe,
-				       NULL) ? TRUE : (GetLastError () ==
+	  {
+	     printf("CreateNamedPipe() failed\n");
+	     return 0;
+	  }
+
+	fConnected = ConnectNamedPipe(hPipe,
+				      NULL) ? TRUE : (GetLastError () ==
 					    ERROR_PIPE_CONNECTED);
 	if (fConnected)
-	  {			
-	     hThread = CreateThread (NULL,	
-				     0,	
-				     (LPTHREAD_START_ROUTINE) InstanceThread,
-				     (LPVOID) hPipe,	
-				     0,	
-				     &dwThreadId);	
-	     if (hThread == NULL)
-	       MyErrExit ("CreateThread");
-	  }	
-	else		
 	  {
-	     CloseHandle (hPipe);
+	     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
 	  }
-     }
-   return 1;
+	else
+	  {
+//	     CloseHandle(hPipe);
+	  }
+//     }
+
+   CloseHandle(hPipe);
+
+   return 0;
 }
 
 VOID InstanceThread (LPVOID lpvParam)
@@ -63,28 +92,29 @@ VOID InstanceThread (LPVOID lpvParam)
    BOOL fSuccess;
    HANDLE hPipe;
    
-   hPipe = (HANDLE) lpvParam;
-   while (1)     
-     {      
-	fSuccess = ReadFile (hPipe,	
-			     chRequest,	
-			     BUFSIZE,	
-			     &cbBytesRead,	
-			     NULL);	
+   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;
+
+	GetAnswerToRequest(chRequest, chReply, &cbReplyBytes);
+
+	fSuccess = WriteFile(hPipe,
+			     chReply,
+			     cbReplyBytes,
+			     &cbWritten,
+			     NULL);
+	if (!fSuccess || cbReplyBytes != cbWritten)
+	  break;
     }
 
-   FlushFileBuffers(hPipe); 
-   DisconnectNamedPipe (hPipe);
-   CloseHandle (hPipe);
+   FlushFileBuffers(hPipe);
+   DisconnectNamedPipe(hPipe);
+   CloseHandle(hPipe);
 }

reactos/apps/tests/pteb/Makefile

@@ -1,6 +1,8 @@
 #
 #
 #
+PATH_TO_TOP = ../..
+
 OBJECTS = pteb.o
 PROGS = pteb.exe
 LIBS = 
@@ -8,30 +10,20 @@ CLEAN_FILES = pteb.o pteb.exe
 
 all: pteb.exe
 
-clean: $(CLEAN_FILES:%=%_clean)
+clean: 
+	- $(RM) $(CLEAN_FILES)
 
-$(CLEAN_FILES:%=%_clean): %_clean:
-	- $(RM) $*
+.phony: clean 
 
-.phony: clean $(CLEAN_FILES:%=%_clean)
-
-floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+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
 
 pteb.exe: $(OBJECTS)
 	$(CC) $(OBJECTS) -o pteb.exe

reactos/apps/tests/pteb/pteb.c

@@ -7,7 +7,7 @@ int main(int argc, char* argv[])
    
    printf("TEB dumpper\n");
    __asm__("movl %%fs:0x18, %0\n\t"
-	   : "=g" (x)
+	   : "=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

@@ -1,8 +1,10 @@
 #
 #
 #
-SRV_OBJECTS= ../common/crt0.o shmsrv.o
-CLT_OBJECTS= ../common/crt0.o shmclt.o
+PATH_TO_TOP = ../..
+
+SRV_OBJECTS= shmsrv.o
+CLT_OBJECTS= shmclt.o
 
 PROGS= shmsrv.exe shmclt.exe
 
@@ -15,36 +17,26 @@ all: $(PROGS)
 .phony: all
 
 clean:
-	- $(RM) *.o
-	- $(RM) *.exe
-	- $(RM) *.sym
+	- $(RM) *.o *.exe *.sym
 
 .phony: clean
 
-floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+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
 
 shmsrv.exe: $(SRV_OBJECTS) $(LIBS)
-	$(LD) $(SRV_OBJECTS) $(LIBS) -o shmsrv.exe
+	$(CC) $(SRV_OBJECTS) $(LIBS) -o shmsrv.exe
 	$(NM) --numeric-sort shmsrv.exe > shmsrv.sym
 
 shmclt.exe: $(CLT_OBJECTS) $(LIBS)
-	$(LD) $(CLT_OBJECTS) $(LIBS) -o shmclt.exe
+	$(CC) $(CLT_OBJECTS) $(LIBS) -o shmclt.exe
 	$(NM) --numeric-sort shmsrv.exe > shmclt.sym
 
 

reactos/apps/tests/test_old/makefile

@@ -1,39 +1,29 @@
 #
 #
 #
+PATH_TO_TOP = ../..
+
 PROGS= test-stdio tst-printf tstdiomisc bug2 bug3 \
-       temptest test-fseek test_rdwr
+       temptest test-fseek test_rdwr testfsd
 
 all: $(PROGS:%=%.exe)
 
 .phony: all
 
-$(PROGS:%=%_clean): %_clean:
-	- $(RM) $*.o
-	- $(RM) $*.exe
-	- $(RM) $*.sym
-
-clean: $(PROGS:%=%_clean)
+clean:
+	- $(RM) *.o *.exe *.sym
 
 .phony: clean
 
-floppy: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
+install: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
 
 $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe): $(FLOPPY_DIR)/apps/%.exe: %.exe
-ifeq ($(DOSCLI),yes)
-	$(CP) $*.exe $(FLOPPY_DIR)\apps\$*.exe
-else
 	$(CP) $*.exe $(FLOPPY_DIR)/apps/$*.exe
-endif
 
 dist: $(PROGS:%=../../$(DIST_DIR)/apps/%.exe)
 
 $(PROGS:%=../../$(DIST_DIR)/apps/%.exe): ../../$(DIST_DIR)/apps/%.exe: %.exe
-ifeq ($(DOSCLI),yes)
-	$(CP) $*.exe ..\..\$(DIST_DIR)\apps\$*.exe
-else
 	$(CP) $*.exe ../../$(DIST_DIR)/apps/$*.exe
-endif
 
 bug2.exe: bug2.c
 	$(CC) bug2.c -lkernel32 -o bug2.exe
@@ -71,4 +61,8 @@ 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/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/thread/makefile

@@ -1,38 +1,28 @@
 #
 #
 #
+PATH_TO_TOP = ../..
+
 PROGS = thread
 
 all: $(PROGS:%=%.exe)
 
 .phony: all
 
-clean: $(PROGS:%=%_clean)
-
-$(PROGS:%=%_clean): %_clean:
-	- $(RM) $*.o
-	- $(RM) $*.exe
-	- $(RM) $*.sym
+clean: 
+	- $(RM) *.o *.exe *.sym
 
 .phony: clean
 
-floppy: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
+install: # $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe)
 
 $(PROGS:%=$(FLOPPY_DIR)/apps/%.exe): $(FLOPPY_DIR)/apps/%.exe: %.exe
-ifeq ($(DOSCLI),yes)
-	$(CP) $*.exe $(FLOPPY_DIR)\apps\$*.exe
-else
 	$(CP) $*.exe $(FLOPPY_DIR)/apps/$*.exe
-endif
 
 dist: $(PROGS:%=../../$(DIST_DIR)/apps/%.exe)
 
 $(PROGS:%=../../$(DIST_DIR)/apps/%.exe): ../../$(DIST_DIR)/apps/%.exe: %.exe
-ifeq ($(DOSCLI),yes)
-	$(CP) $*.exe ..\..\$(DIST_DIR)\apps\$*.exe
-else
 	$(CP) $*.exe ../../$(DIST_DIR)/apps/$*.exe
-endif
 
 thread.exe: thread.c
 	$(CC) $(CFLAGS) thread.c -lkernel32 -o thread.exe

reactos/apps/tests/thread/thread.c

@@ -1,4 +1,4 @@
-/* $Id: thread.c,v 1.6 2000/01/31 20:24:27 ekohl Exp $
+/* $Id: thread.c,v 1.7 2001/02/06 00:11:17 dwelch Exp $
  *
  *
  *
@@ -48,12 +48,13 @@ int main (int argc, char* argv[])
 
    // The user must supply one argument (the seed). if he/she doesn't
    // then we show the help.
-   if(argc < 2) {
-		showHelp();
-		return 1;
-   }
+   //   if(argc < 2) {
+   //		showHelp();
+   //		return 1;
+   //   }
 		
-   nr = atoi(argv[1]);
+   //   nr = atoi(argv[1]);
+   nr = 500;
    printf("Seed %ld\n", nr);
    
    printf("Creating %d threads...\n",NR_THREADS*2);

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/Makefile

@@ -1,6 +1,8 @@
-# $Id: Makefile,v 1.6 2000/06/29 23:35:09 dwelch Exp $
+# $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
@@ -10,14 +12,12 @@ all: $(TARGETNAME)$(EXE_POSTFIX)
 
 
 $(TARGETNAME)$(EXE_POSTFIX): $(TARGETNAME).c ../../include/reactos/version.h
-	$(NATIVE_CC) -o $(TARGETNAME)$(EXE_POSTFIX) $(TARGETNAME).c
+	$(HOST_CC) -g -o $(TARGETNAME)$(EXE_POSTFIX) $(TARGETNAME).c
 
 
 
 clean:
-	- $(RM) $(TARGETNAME).o
-	- $(RM) $(TARGETNAME).sym
-	- $(RM) $(TARGETNAME)$(EXE_POSTFIX)
+	- $(RM) $(CLEAN_FILES)
 
 .phony: clean 
 

reactos/apps/utils/buildno/buildno.c

@@ -1,4 +1,4 @@
-/* $Id: buildno.c,v 1.4 2000/06/29 23:35:09 dwelch Exp $
+/* $Id: buildno.c,v 1.6 2001/04/11 22:13:21 dwelch Exp $
  *
  * buildno - Generate the build number for ReactOS
  *
@@ -29,6 +29,9 @@
  * 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>
@@ -82,73 +85,70 @@ elapsed_days (
 void
 write_h (int build)
 {
-	FILE	*h = NULL;
+  FILE	*h = NULL;
+  char* s;
+  char* s1;
+  int length;
 
-	h = fopen ( BUILDNO_INCLUDE_FILE, "w");
-	if (!h) 
+  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))
 	{
-		fprintf (
-			stderr,
-			"%s: can not create file \"%s\"!\n",
-			argv0,
-			BUILDNO_INCLUDE_FILE
-			);
-		return;
+	  char* orig;
+	  
+	  orig = malloc(length);
+	  fseek(h, 0, SEEK_SET);
+	  fread(orig, 1, length, h);
+	  if (memcmp(s1, orig, length) == 0)
+	    {
+	      fclose(h);
+	      return;
+	    }
 	}
-	fprintf (
-		h,
-		"/* Do not edit - Machine generated */\n"
-		);
-	
-	fprintf (h, "#ifndef _INC_REACTOS_BUILDNO\n" );
-	fprintf (h, "#define _INC_REACTOS_BUILDNO\n" );
+      fclose(h);
+    }
 
-	fprintf (
-		h,
-		"#define KERNEL_VERSION_BUILD\t%d\n",
-		build
-		);
-	fprintf (
-		h,
-		"#define KERNEL_VERSION_BUILD_STR\t\"%d\"\n",
-		build
-		);
-	fprintf (
-		h,
-		"#define KERNEL_RELEASE_RC\t\"%d.%d.%d.%d\\0\"\n",
-		KERNEL_VERSION_MAJOR,
-		KERNEL_VERSION_MINOR,
-		KERNEL_VERSION_PATCH_LEVEL,
-		build
-		);
-	fprintf (
-		h,
-		"#define KERNEL_RELEASE_STR\t\"%d.%d.%d.%d\"\n",
-		KERNEL_VERSION_MAJOR,
-		KERNEL_VERSION_MINOR,
-		KERNEL_VERSION_PATCH_LEVEL,
-		build
-		);
-	fprintf (
-		h,
-		"#define KERNEL_VERSION_RC\t\"%d.%d.%d\\0\"\n",
-		KERNEL_VERSION_MAJOR,
-		KERNEL_VERSION_MINOR,
-		KERNEL_VERSION_PATCH_LEVEL
-		);
-	fprintf (
-		h,
-		"#define KERNEL_VERSION_STR\t\"%d.%d.%d\"\n", 
-		KERNEL_VERSION_MAJOR,
-		KERNEL_VERSION_MINOR,
-		KERNEL_VERSION_PATCH_LEVEL
-		);
-	fprintf (
-		h,
-		"#endif\n/* EOF */\n"
-		);
-	
-	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
@@ -156,7 +156,7 @@ usage (void)
 {
 	fprintf (
 		stderr,
-		"Usage: %s [-q]\n\n  -q  quiet mode\n",
+		"Usage: %s [-{p|q}]\n\n  -p  print version number and exit\n  -q  run in quiet mode\n",
 		argv0
 		);
 	exit (EXIT_SUCCESS);
@@ -166,6 +166,7 @@ usage (void)
 int
 main (int argc, char * argv [])
 {
+	int		print_only = FALSE;
 	int		quiet = FALSE;
 
 	int		year = 0;
@@ -191,6 +192,10 @@ main (int argc, char * argv [])
 				{
 					quiet = TRUE;
 				}
+				else  if (argv[1][1] == 'p')
+				{
+					print_only = TRUE;
+				}
 				else
 				{
 					usage ();
@@ -305,9 +310,17 @@ Last release: %4d-%02d-%02d\n",
 			);
 	}
 	/*
-	 * (Over)write the include file.
+	 * (Over)write the include file, unless
+	 * the user switched on -p.
 	 */
-	write_h (build);
+	if (FALSE == print_only)
+	{
+		write_h (build);
+	}
+	else
+	{
+		printf ("%s: no code generated", argv [0]);
+	}
 
 	return EXIT_SUCCESS;
 }

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;
+}

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

@@ -0,0 +1,17 @@
+/* inffast.h -- header to use inffast.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.
+ */
+
+extern int inflate_fast OF((
+    uInt,
+    uInt,
+    inflate_huft *,
+    inflate_huft *,
+    inflate_blocks_statef *,
+    z_streamp ));

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

@@ -0,0 +1,151 @@
+/* inffixed.h -- table for decoding fixed codes
+ * Generated automatically by the maketree.c program
+ */
+
+/* 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.
+ */
+
+local uInt fixed_bl = 9;
+local uInt fixed_bd = 5;
+local inflate_huft fixed_tl[] = {
+    {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},
+    {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},192},
+    {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},160},
+    {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},224},
+    {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},144},
+    {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},208},
+    {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},176},
+    {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},240},
+    {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},
+    {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},200},
+    {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},168},
+    {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},232},
+    {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},152},
+    {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},216},
+    {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},184},
+    {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},248},
+    {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},
+    {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},196},
+    {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},164},
+    {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},228},
+    {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},148},
+    {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},212},
+    {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},180},
+    {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},244},
+    {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},204},
+    {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},172},
+    {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},236},
+    {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},156},
+    {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},220},
+    {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},188},
+    {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},252},
+    {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},
+    {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},194},
+    {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},162},
+    {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},226},
+    {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},146},
+    {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},210},
+    {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},178},
+    {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},242},
+    {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},
+    {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},202},
+    {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},170},
+    {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},234},
+    {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},154},
+    {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},218},
+    {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},186},
+    {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},250},
+    {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},
+    {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},198},
+    {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},166},
+    {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},230},
+    {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},150},
+    {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},214},
+    {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},182},
+    {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},246},
+    {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},206},
+    {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},174},
+    {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},238},
+    {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},158},
+    {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},222},
+    {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},190},
+    {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},254},
+    {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},
+    {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},193},
+    {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},161},
+    {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},225},
+    {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},145},
+    {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},209},
+    {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},177},
+    {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},241},
+    {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},
+    {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},201},
+    {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},169},
+    {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},233},
+    {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},153},
+    {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},217},
+    {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},185},
+    {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},249},
+    {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},
+    {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},197},
+    {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},165},
+    {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},229},
+    {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},149},
+    {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},213},
+    {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},181},
+    {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},245},
+    {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},205},
+    {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},173},
+    {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},237},
+    {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},157},
+    {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},221},
+    {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},189},
+    {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},253},
+    {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},
+    {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},195},
+    {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},163},
+    {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},227},
+    {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},147},
+    {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},211},
+    {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},179},
+    {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},243},
+    {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},
+    {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},203},
+    {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},171},
+    {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},235},
+    {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},155},
+    {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},219},
+    {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},187},
+    {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},251},
+    {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},
+    {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},199},
+    {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},167},
+    {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},231},
+    {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},151},
+    {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},215},
+    {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},183},
+    {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},247},
+    {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},207},
+    {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},175},
+    {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},239},
+    {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},159},
+    {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},223},
+    {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},191},
+    {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},255}
+  };
+local inflate_huft fixed_td[] = {
+    {{{80,5}},1}, {{{87,5}},257}, {{{83,5}},17}, {{{91,5}},4097},
+    {{{81,5}},5}, {{{89,5}},1025}, {{{85,5}},65}, {{{93,5}},16385},
+    {{{80,5}},3}, {{{88,5}},513}, {{{84,5}},33}, {{{92,5}},8193},
+    {{{82,5}},9}, {{{90,5}},2049}, {{{86,5}},129}, {{{192,5}},24577},
+    {{{80,5}},2}, {{{87,5}},385}, {{{83,5}},25}, {{{91,5}},6145},
+    {{{81,5}},7}, {{{89,5}},1537}, {{{85,5}},97}, {{{93,5}},24577},
+    {{{80,5}},4}, {{{88,5}},769}, {{{84,5}},49}, {{{92,5}},12289},
+    {{{82,5}},13}, {{{90,5}},3073}, {{{86,5}},193}, {{{192,5}},24577}
+  };

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

@@ -0,0 +1,366 @@
+/* inflate.c -- zlib interface to inflate modules
+ * Copyright (C) 1995-1998 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "infblock.h"
+
+struct inflate_blocks_state {int dummy;}; /* for buggy compilers */
+
+typedef enum {
+      METHOD,   /* waiting for method byte */
+      FLAG,     /* waiting for flag byte */
+      DICT4,    /* four dictionary check bytes to go */
+      DICT3,    /* three dictionary check bytes to go */
+      DICT2,    /* two dictionary check bytes to go */
+      DICT1,    /* one dictionary check byte to go */
+      DICT0,    /* waiting for inflateSetDictionary */
+      BLOCKS,   /* decompressing blocks */
+      CHECK4,   /* four check bytes to go */
+      CHECK3,   /* three check bytes to go */
+      CHECK2,   /* two check bytes to go */
+      CHECK1,   /* one check byte to go */
+      DONE,     /* finished check, done */
+      BAD}      /* got an error--stay here */
+inflate_mode;
+
+/* inflate private state */
+struct internal_state {
+
+  /* mode */
+  inflate_mode  mode;   /* current inflate mode */
+
+  /* mode dependent information */
+  union {
+    uInt method;        /* if FLAGS, method byte */
+    struct {
+      uLong was;                /* computed check value */
+      uLong need;               /* stream check value */
+    } check;            /* if CHECK, check values to compare */
+    uInt marker;        /* if BAD, inflateSync's marker bytes count */
+  } sub;        /* submode */
+
+  /* mode independent information */
+  int  nowrap;          /* flag for no wrapper */
+  uInt wbits;           /* log2(window size)  (8..15, defaults to 15) */
+  inflate_blocks_statef 
+    *blocks;            /* current inflate_blocks state */
+
+};
+
+
+int ZEXPORT inflateReset(z)
+z_streamp z;
+{
+  if (z == Z_NULL || z->state == Z_NULL)
+    return Z_STREAM_ERROR;
+  z->total_in = z->total_out = 0;
+  z->msg = Z_NULL;
+  z->state->mode = z->state->nowrap ? BLOCKS : METHOD;
+  inflate_blocks_reset(z->state->blocks, z, Z_NULL);
+  Tracev((stderr, "inflate: reset\n"));
+  return Z_OK;
+}
+
+
+int ZEXPORT inflateEnd(z)
+z_streamp z;
+{
+  if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL)
+    return Z_STREAM_ERROR;
+  if (z->state->blocks != Z_NULL)
+    inflate_blocks_free(z->state->blocks, z);
+  ZFREE(z, z->state);
+  z->state = Z_NULL;
+  Tracev((stderr, "inflate: end\n"));
+  return Z_OK;
+}
+
+
+int ZEXPORT inflateInit2_(z, w, version, stream_size)
+z_streamp z;
+int w;
+const char *version;
+int stream_size;
+{
+  if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+      stream_size != sizeof(z_stream))
+      return Z_VERSION_ERROR;
+
+  /* initialize state */
+  if (z == Z_NULL)
+    return Z_STREAM_ERROR;
+  z->msg = Z_NULL;
+  if (z->zalloc == Z_NULL)
+  {
+    z->zalloc = zcalloc;
+    z->opaque = (voidpf)0;
+  }
+  if (z->zfree == Z_NULL) z->zfree = zcfree;
+  if ((z->state = (struct internal_state FAR *)
+       ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL)
+    return Z_MEM_ERROR;
+  z->state->blocks = Z_NULL;
+
+  /* handle undocumented nowrap option (no zlib header or check) */
+  z->state->nowrap = 0;
+  if (w < 0)
+  {
+    w = - w;
+    z->state->nowrap = 1;
+  }
+
+  /* set window size */
+  if (w < 8 || w > 15)
+  {
+    inflateEnd(z);
+    return Z_STREAM_ERROR;
+  }
+  z->state->wbits = (uInt)w;
+
+  /* create inflate_blocks state */
+  if ((z->state->blocks =
+      inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, (uInt)1 << w))
+      == Z_NULL)
+  {
+    inflateEnd(z);
+    return Z_MEM_ERROR;
+  }
+  Tracev((stderr, "inflate: allocated\n"));
+
+  /* reset state */
+  inflateReset(z);
+  return Z_OK;
+}
+
+
+int ZEXPORT inflateInit_(z, version, stream_size)
+z_streamp z;
+const char *version;
+int stream_size;
+{
+  return inflateInit2_(z, DEF_WBITS, version, stream_size);
+}
+
+
+#define NEEDBYTE {if(z->avail_in==0)return r;r=f;}
+#define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++)
+
+int ZEXPORT inflate(z, f)
+z_streamp z;
+int f;
+{
+  int r;
+  uInt b;
+
+  if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL)
+    return Z_STREAM_ERROR;
+  f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
+  r = Z_BUF_ERROR;
+  while (1) switch (z->state->mode)
+  {
+    case METHOD:
+      NEEDBYTE
+      if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"unknown compression method";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"invalid window size";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      z->state->mode = FLAG;
+    case FLAG:
+      NEEDBYTE
+      b = NEXTBYTE;
+      if (((z->state->sub.method << 8) + b) % 31)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"incorrect header check";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      Tracev((stderr, "inflate: zlib header ok\n"));
+      if (!(b & PRESET_DICT))
+      {
+        z->state->mode = BLOCKS;
+        break;
+      }
+      z->state->mode = DICT4;
+    case DICT4:
+      NEEDBYTE
+      z->state->sub.check.need = (uLong)NEXTBYTE << 24;
+      z->state->mode = DICT3;
+    case DICT3:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 16;
+      z->state->mode = DICT2;
+    case DICT2:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 8;
+      z->state->mode = DICT1;
+    case DICT1:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE;
+      z->adler = z->state->sub.check.need;
+      z->state->mode = DICT0;
+      return Z_NEED_DICT;
+    case DICT0:
+      z->state->mode = BAD;
+      z->msg = (char*)"need dictionary";
+      z->state->sub.marker = 0;       /* can try inflateSync */
+      return Z_STREAM_ERROR;
+    case BLOCKS:
+      r = inflate_blocks(z->state->blocks, z, r);
+      if (r == Z_DATA_ERROR)
+      {
+        z->state->mode = BAD;
+        z->state->sub.marker = 0;       /* can try inflateSync */
+        break;
+      }
+      if (r == Z_OK)
+        r = f;
+      if (r != Z_STREAM_END)
+        return r;
+      r = f;
+      inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was);
+      if (z->state->nowrap)
+      {
+        z->state->mode = DONE;
+        break;
+      }
+      z->state->mode = CHECK4;
+    case CHECK4:
+      NEEDBYTE
+      z->state->sub.check.need = (uLong)NEXTBYTE << 24;
+      z->state->mode = CHECK3;
+    case CHECK3:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 16;
+      z->state->mode = CHECK2;
+    case CHECK2:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 8;
+      z->state->mode = CHECK1;
+    case CHECK1:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE;
+
+      if (z->state->sub.check.was != z->state->sub.check.need)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"incorrect data check";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      Tracev((stderr, "inflate: zlib check ok\n"));
+      z->state->mode = DONE;
+    case DONE:
+      return Z_STREAM_END;
+    case BAD:
+      return Z_DATA_ERROR;
+    default:
+      return Z_STREAM_ERROR;
+  }
+#ifdef NEED_DUMMY_RETURN
+  return Z_STREAM_ERROR;  /* Some dumb compilers complain without this */
+#endif
+}
+
+
+int ZEXPORT inflateSetDictionary(z, dictionary, dictLength)
+z_streamp z;
+const Bytef *dictionary;
+uInt  dictLength;
+{
+  uInt length = dictLength;
+
+  if (z == Z_NULL || z->state == Z_NULL || z->state->mode != DICT0)
+    return Z_STREAM_ERROR;
+
+  if (adler32(1L, dictionary, dictLength) != z->adler) return Z_DATA_ERROR;
+  z->adler = 1L;
+
+  if (length >= ((uInt)1<<z->state->wbits))
+  {
+    length = (1<<z->state->wbits)-1;
+    dictionary += dictLength - length;
+  }
+  inflate_set_dictionary(z->state->blocks, dictionary, length);
+  z->state->mode = BLOCKS;
+  return Z_OK;
+}
+
+
+int ZEXPORT inflateSync(z)
+z_streamp z;
+{
+  uInt n;       /* number of bytes to look at */
+  Bytef *p;     /* pointer to bytes */
+  uInt m;       /* number of marker bytes found in a row */
+  uLong r, w;   /* temporaries to save total_in and total_out */
+
+  /* set up */
+  if (z == Z_NULL || z->state == Z_NULL)
+    return Z_STREAM_ERROR;
+  if (z->state->mode != BAD)
+  {
+    z->state->mode = BAD;
+    z->state->sub.marker = 0;
+  }
+  if ((n = z->avail_in) == 0)
+    return Z_BUF_ERROR;
+  p = z->next_in;
+  m = z->state->sub.marker;
+
+  /* search */
+  while (n && m < 4)
+  {
+    static const Byte mark[4] = {0, 0, 0xff, 0xff};
+    if (*p == mark[m])
+      m++;
+    else if (*p)
+      m = 0;
+    else
+      m = 4 - m;
+    p++, n--;
+  }
+
+  /* restore */
+  z->total_in += p - z->next_in;
+  z->next_in = p;
+  z->avail_in = n;
+  z->state->sub.marker = m;
+
+  /* return no joy or set up to restart on a new block */
+  if (m != 4)
+    return Z_DATA_ERROR;
+  r = z->total_in;  w = z->total_out;
+  inflateReset(z);
+  z->total_in = r;  z->total_out = w;
+  z->state->mode = BLOCKS;
+  return Z_OK;
+}
+
+
+/* Returns true if inflate is currently at the end of a block generated
+ * by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
+ * implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
+ * but removes the length bytes of the resulting empty stored block. When
+ * decompressing, PPP checks that at the end of input packet, inflate is
+ * waiting for these length bytes.
+ */
+int ZEXPORT inflateSyncPoint(z)
+z_streamp z;
+{
+  if (z == Z_NULL || z->state == Z_NULL || z->state->blocks == Z_NULL)
+    return Z_STREAM_ERROR;
+  return inflate_blocks_sync_point(z->state->blocks);
+}

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

@@ -0,0 +1,455 @@
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-1998 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+
+#if !defined(BUILDFIXED) && !defined(STDC)
+#  define BUILDFIXED   /* non ANSI compilers may not accept inffixed.h */
+#endif
+
+const char inflate_copyright[] =
+   " inflate 1.1.3 Copyright 1995-1998 Mark Adler ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+struct internal_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
+
+
+local int huft_build OF((
+    uIntf *,            /* code lengths in bits */
+    uInt,               /* number of codes */
+    uInt,               /* number of "simple" codes */
+    const uIntf *,      /* list of base values for non-simple codes */
+    const uIntf *,      /* list of extra bits for non-simple codes */
+    inflate_huft * FAR*,/* result: starting table */
+    uIntf *,            /* maximum lookup bits (returns actual) */
+    inflate_huft *,     /* space for trees */
+    uInt *,             /* hufts used in space */
+    uIntf * ));         /* space for values */
+
+/* Tables for deflate from PKZIP's appnote.txt. */
+local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+        /* see note #13 above about 258 */
+local const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
+        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112}; /* 112==invalid */
+local const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+        8193, 12289, 16385, 24577};
+local const uInt cpdext[30] = { /* Extra bits for distance codes */
+        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
+        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
+        12, 12, 13, 13};
+
+/*
+   Huffman code decoding is performed using a multi-level table lookup.
+   The fastest way to decode is to simply build a lookup table whose
+   size is determined by the longest code.  However, the time it takes
+   to build this table can also be a factor if the data being decoded
+   is not very long.  The most common codes are necessarily the
+   shortest codes, so those codes dominate the decoding time, and hence
+   the speed.  The idea is you can have a shorter table that decodes the
+   shorter, more probable codes, and then point to subsidiary tables for
+   the longer codes.  The time it costs to decode the longer codes is
+   then traded against the time it takes to make longer tables.
+
+   This results of this trade are in the variables lbits and dbits
+   below.  lbits is the number of bits the first level table for literal/
+   length codes can decode in one step, and dbits is the same thing for
+   the distance codes.  Subsequent tables are also less than or equal to
+   those sizes.  These values may be adjusted either when all of the
+   codes are shorter than that, in which case the longest code length in
+   bits is used, or when the shortest code is *longer* than the requested
+   table size, in which case the length of the shortest code in bits is
+   used.
+
+   There are two different values for the two tables, since they code a
+   different number of possibilities each.  The literal/length table
+   codes 286 possible values, or in a flat code, a little over eight
+   bits.  The distance table codes 30 possible values, or a little less
+   than five bits, flat.  The optimum values for speed end up being
+   about one bit more than those, so lbits is 8+1 and dbits is 5+1.
+   The optimum values may differ though from machine to machine, and
+   possibly even between compilers.  Your mileage may vary.
+ */
+
+
+/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
+#define BMAX 15         /* maximum bit length of any code */
+
+local int huft_build(b, n, s, d, e, t, m, hp, hn, v)
+uIntf *b;               /* code lengths in bits (all assumed <= BMAX) */
+uInt n;                 /* number of codes (assumed <= 288) */
+uInt s;                 /* number of simple-valued codes (0..s-1) */
+const uIntf *d;         /* list of base values for non-simple codes */
+const uIntf *e;         /* list of extra bits for non-simple codes */
+inflate_huft * FAR *t;  /* result: starting table */
+uIntf *m;               /* maximum lookup bits, returns actual */
+inflate_huft *hp;       /* space for trees */
+uInt *hn;               /* hufts used in space */
+uIntf *v;               /* working area: values in order of bit length */
+/* Given a list of code lengths and a maximum table size, make a set of
+   tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
+   if the given code set is incomplete (the tables are still built in this
+   case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
+   lengths), or Z_MEM_ERROR if not enough memory. */
+{
+
+  uInt a;                       /* counter for codes of length k */
+  uInt c[BMAX+1];               /* bit length count table */
+  uInt f;                       /* i repeats in table every f entries */
+  int g;                        /* maximum code length */
+  int h;                        /* table level */
+  register uInt i;              /* counter, current code */
+  register uInt j;              /* counter */
+  register int k;               /* number of bits in current code */
+  int l;                        /* bits per table (returned in m) */
+  uInt mask;                    /* (1 << w) - 1, to avoid cc -O bug on HP */
+  register uIntf *p;            /* pointer into c[], b[], or v[] */
+  inflate_huft *q;              /* points to current table */
+  struct inflate_huft_s r;      /* table entry for structure assignment */
+  inflate_huft *u[BMAX];        /* table stack */
+  register int w;               /* bits before this table == (l * h) */
+  uInt x[BMAX+1];               /* bit offsets, then code stack */
+  uIntf *xp;                    /* pointer into x */
+  int y;                        /* number of dummy codes added */
+  uInt z;                       /* number of entries in current table */
+
+
+  /* Generate counts for each bit length */
+  p = c;
+#define C0 *p++ = 0;
+#define C2 C0 C0 C0 C0
+#define C4 C2 C2 C2 C2
+  C4                            /* clear c[]--assume BMAX+1 is 16 */
+  p = b;  i = n;
+  do {
+    c[*p++]++;                  /* assume all entries <= BMAX */
+  } while (--i);
+  if (c[0] == n)                /* null input--all zero length codes */
+  {
+    *t = (inflate_huft *)Z_NULL;
+    *m = 0;
+    return Z_OK;
+  }
+
+
+  /* Find minimum and maximum length, bound *m by those */
+  l = *m;
+  for (j = 1; j <= BMAX; j++)
+    if (c[j])
+      break;
+  k = j;                        /* minimum code length */
+  if ((uInt)l < j)
+    l = j;
+  for (i = BMAX; i; i--)
+    if (c[i])
+      break;
+  g = i;                        /* maximum code length */
+  if ((uInt)l > i)
+    l = i;
+  *m = l;
+
+
+  /* Adjust last length count to fill out codes, if needed */
+  for (y = 1 << j; j < i; j++, y <<= 1)
+    if ((y -= c[j]) < 0)
+      return Z_DATA_ERROR;
+  if ((y -= c[i]) < 0)
+    return Z_DATA_ERROR;
+  c[i] += y;
+
+
+  /* Generate starting offsets into the value table for each length */
+  x[1] = j = 0;
+  p = c + 1;  xp = x + 2;
+  while (--i) {                 /* note that i == g from above */
+    *xp++ = (j += *p++);
+  }
+
+
+  /* Make a table of values in order of bit lengths */
+  p = b;  i = 0;
+  do {
+    if ((j = *p++) != 0)
+      v[x[j]++] = i;
+  } while (++i < n);
+  n = x[g];                     /* set n to length of v */
+
+
+  /* Generate the Huffman codes and for each, make the table entries */
+  x[0] = i = 0;                 /* first Huffman code is zero */
+  p = v;                        /* grab values in bit order */
+  h = -1;                       /* no tables yet--level -1 */
+  w = -l;                       /* bits decoded == (l * h) */
+  u[0] = (inflate_huft *)Z_NULL;        /* just to keep compilers happy */
+  q = (inflate_huft *)Z_NULL;   /* ditto */
+  z = 0;                        /* ditto */
+
+  /* go through the bit lengths (k already is bits in shortest code) */
+  for (; k <= g; k++)
+  {
+    a = c[k];
+    while (a--)
+    {
+      /* here i is the Huffman code of length k bits for value *p */
+      /* make tables up to required level */
+      while (k > w + l)
+      {
+        h++;
+        w += l;                 /* previous table always l bits */
+
+        /* compute minimum size table less than or equal to l bits */
+        z = g - w;
+        z = z > (uInt)l ? l : z;        /* table size upper limit */
+        if ((f = 1 << (j = k - w)) > a + 1)     /* try a k-w bit table */
+        {                       /* too few codes for k-w bit table */
+          f -= a + 1;           /* deduct codes from patterns left */
+          xp = c + k;
+          if (j < z)
+            while (++j < z)     /* try smaller tables up to z bits */
+            {
+              if ((f <<= 1) <= *++xp)
+                break;          /* enough codes to use up j bits */
+              f -= *xp;         /* else deduct codes from patterns */
+            }
+        }
+        z = 1 << j;             /* table entries for j-bit table */
+
+        /* allocate new table */
+        if (*hn + z > MANY)     /* (note: doesn't matter for fixed) */
+          return Z_MEM_ERROR;   /* not enough memory */
+        u[h] = q = hp + *hn;
+        *hn += z;
+
+        /* connect to last table, if there is one */
+        if (h)
+        {
+          x[h] = i;             /* save pattern for backing up */
+          r.bits = (Byte)l;     /* bits to dump before this table */
+          r.exop = (Byte)j;     /* bits in this table */
+          j = i >> (w - l);
+          r.base = (uInt)(q - u[h-1] - j);   /* offset to this table */
+          u[h-1][j] = r;        /* connect to last table */
+        }
+        else
+          *t = q;               /* first table is returned result */
+      }
+
+      /* set up table entry in r */
+      r.bits = (Byte)(k - w);
+      if (p >= v + n)
+        r.exop = 128 + 64;      /* out of values--invalid code */
+      else if (*p < s)
+      {
+        r.exop = (Byte)(*p < 256 ? 0 : 32 + 64);     /* 256 is end-of-block */
+        r.base = *p++;          /* simple code is just the value */
+      }
+      else
+      {
+        r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */
+        r.base = d[*p++ - s];
+      }
+
+      /* fill code-like entries with r */
+      f = 1 << (k - w);
+      for (j = i >> w; j < z; j += f)
+        q[j] = r;
+
+      /* backwards increment the k-bit code i */
+      for (j = 1 << (k - 1); i & j; j >>= 1)
+        i ^= j;
+      i ^= j;
+
+      /* backup over finished tables */
+      mask = (1 << w) - 1;      /* needed on HP, cc -O bug */
+      while ((i & mask) != x[h])
+      {
+        h--;                    /* don't need to update q */
+        w -= l;
+        mask = (1 << w) - 1;
+      }
+    }
+  }
+
+
+  /* Return Z_BUF_ERROR if we were given an incomplete table */
+  return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
+}
+
+
+int inflate_trees_bits(c, bb, tb, hp, z)
+uIntf *c;               /* 19 code lengths */
+uIntf *bb;              /* bits tree desired/actual depth */
+inflate_huft * FAR *tb; /* bits tree result */
+inflate_huft *hp;       /* space for trees */
+z_streamp z;            /* for messages */
+{
+  int r;
+  uInt hn = 0;          /* hufts used in space */
+  uIntf *v;             /* work area for huft_build */
+
+  if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL)
+    return Z_MEM_ERROR;
+  r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL,
+                 tb, bb, hp, &hn, v);
+  if (r == Z_DATA_ERROR)
+    z->msg = (char*)"oversubscribed dynamic bit lengths tree";
+  else if (r == Z_BUF_ERROR || *bb == 0)
+  {
+    z->msg = (char*)"incomplete dynamic bit lengths tree";
+    r = Z_DATA_ERROR;
+  }
+  ZFREE(z, v);
+  return r;
+}
+
+
+int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z)
+uInt nl;                /* number of literal/length codes */
+uInt nd;                /* number of distance codes */
+uIntf *c;               /* that many (total) code lengths */
+uIntf *bl;              /* literal desired/actual bit depth */
+uIntf *bd;              /* distance desired/actual bit depth */
+inflate_huft * FAR *tl; /* literal/length tree result */
+inflate_huft * FAR *td; /* distance tree result */
+inflate_huft *hp;       /* space for trees */
+z_streamp z;            /* for messages */
+{
+  int r;
+  uInt hn = 0;          /* hufts used in space */
+  uIntf *v;             /* work area for huft_build */
+
+  /* allocate work area */
+  if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+    return Z_MEM_ERROR;
+
+  /* build literal/length tree */
+  r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v);
+  if (r != Z_OK || *bl == 0)
+  {
+    if (r == Z_DATA_ERROR)
+      z->msg = (char*)"oversubscribed literal/length tree";
+    else if (r != Z_MEM_ERROR)
+    {
+      z->msg = (char*)"incomplete literal/length tree";
+      r = Z_DATA_ERROR;
+    }
+    ZFREE(z, v);
+    return r;
+  }
+
+  /* build distance tree */
+  r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v);
+  if (r != Z_OK || (*bd == 0 && nl > 257))
+  {
+    if (r == Z_DATA_ERROR)
+      z->msg = (char*)"oversubscribed distance tree";
+    else if (r == Z_BUF_ERROR) {
+#ifdef PKZIP_BUG_WORKAROUND
+      r = Z_OK;
+    }
+#else
+      z->msg = (char*)"incomplete distance tree";
+      r = Z_DATA_ERROR;
+    }
+    else if (r != Z_MEM_ERROR)
+    {
+      z->msg = (char*)"empty distance tree with lengths";
+      r = Z_DATA_ERROR;
+    }
+    ZFREE(z, v);
+    return r;
+#endif
+  }
+
+  /* done */
+  ZFREE(z, v);
+  return Z_OK;
+}
+
+
+/* build fixed tables only once--keep them here */
+#ifdef BUILDFIXED
+local int fixed_built = 0;
+#define FIXEDH 544      /* number of hufts used by fixed tables */
+local inflate_huft fixed_mem[FIXEDH];
+local uInt fixed_bl;
+local uInt fixed_bd;
+local inflate_huft *fixed_tl;
+local inflate_huft *fixed_td;
+#else
+#include "inffixed.h"
+#endif
+
+
+int inflate_trees_fixed(bl, bd, tl, td, z)
+uIntf *bl;               /* literal desired/actual bit depth */
+uIntf *bd;               /* distance desired/actual bit depth */
+inflate_huft * FAR *tl;  /* literal/length tree result */
+inflate_huft * FAR *td;  /* distance tree result */
+z_streamp z;             /* for memory allocation */
+{
+#ifdef BUILDFIXED
+  /* build fixed tables if not already */
+  if (!fixed_built)
+  {
+    int k;              /* temporary variable */
+    uInt f = 0;         /* number of hufts used in fixed_mem */
+    uIntf *c;           /* length list for huft_build */
+    uIntf *v;           /* work area for huft_build */
+
+    /* allocate memory */
+    if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+      return Z_MEM_ERROR;
+    if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+    {
+      ZFREE(z, c);
+      return Z_MEM_ERROR;
+    }
+
+    /* literal table */
+    for (k = 0; k < 144; k++)
+      c[k] = 8;
+    for (; k < 256; k++)
+      c[k] = 9;
+    for (; k < 280; k++)
+      c[k] = 7;
+    for (; k < 288; k++)
+      c[k] = 8;
+    fixed_bl = 9;
+    huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl,
+               fixed_mem, &f, v);
+
+    /* distance table */
+    for (k = 0; k < 30; k++)
+      c[k] = 5;
+    fixed_bd = 5;
+    huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd,
+               fixed_mem, &f, v);
+
+    /* done */
+    ZFREE(z, v);
+    ZFREE(z, c);
+    fixed_built = 1;
+  }
+#endif
+  *bl = fixed_bl;
+  *bd = fixed_bd;
+  *tl = fixed_tl;
+  *td = fixed_td;
+  return Z_OK;
+}

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

@@ -0,0 +1,58 @@
+/* inftrees.h -- header to use inftrees.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.
+ */
+
+/* Huffman code lookup table entry--this entry is four bytes for machines
+   that have 16-bit pointers (e.g. PC's in the small or medium model). */
+
+typedef struct inflate_huft_s FAR inflate_huft;
+
+struct inflate_huft_s {
+  union {
+    struct {
+      Byte Exop;        /* number of extra bits or operation */
+      Byte Bits;        /* number of bits in this code or subcode */
+    } what;
+    uInt pad;           /* pad structure to a power of 2 (4 bytes for */
+  } word;               /*  16-bit, 8 bytes for 32-bit int's) */
+  uInt base;            /* literal, length base, distance base,
+                           or table offset */
+};
+
+/* Maximum size of dynamic tree.  The maximum found in a long but non-
+   exhaustive search was 1004 huft structures (850 for length/literals
+   and 154 for distances, the latter actually the result of an
+   exhaustive search).  The actual maximum is not known, but the
+   value below is more than safe. */
+#define MANY 1440
+
+extern int inflate_trees_bits OF((
+    uIntf *,                    /* 19 code lengths */
+    uIntf *,                    /* bits tree desired/actual depth */
+    inflate_huft * FAR *,       /* bits tree result */
+    inflate_huft *,             /* space for trees */
+    z_streamp));                /* for messages */
+
+extern int inflate_trees_dynamic OF((
+    uInt,                       /* number of literal/length codes */
+    uInt,                       /* number of distance codes */
+    uIntf *,                    /* that many (total) code lengths */
+    uIntf *,                    /* literal desired/actual bit depth */
+    uIntf *,                    /* distance desired/actual bit depth */
+    inflate_huft * FAR *,       /* literal/length tree result */
+    inflate_huft * FAR *,       /* distance tree result */
+    inflate_huft *,             /* space for trees */
+    z_streamp));                /* for messages */
+
+extern int inflate_trees_fixed OF((
+    uIntf *,                    /* literal desired/actual bit depth */
+    uIntf *,                    /* distance desired/actual bit depth */
+    inflate_huft * FAR *,       /* literal/length tree result */
+    inflate_huft * FAR *,       /* distance tree result */
+    z_streamp));                /* for memory allocation */

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

@@ -0,0 +1,87 @@
+/* inflate_util.c -- data and routines common to blocks and codes
+ * 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 */
+
+/* And'ing with mask[n] masks the lower n bits */
+uInt inflate_mask[17] = {
+    0x0000,
+    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
+    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
+};
+
+
+/* copy as much as possible from the sliding window to the output area */
+int inflate_flush(s, z, r)
+inflate_blocks_statef *s;
+z_streamp z;
+int r;
+{
+  uInt n;
+  Bytef *p;
+  Bytef *q;
+
+  /* local copies of source and destination pointers */
+  p = z->next_out;
+  q = s->read;
+
+  /* compute number of bytes to copy as far as end of window */
+  n = (uInt)((q <= s->write ? s->write : s->end) - q);
+  if (n > z->avail_out) n = z->avail_out;
+  if (n && r == Z_BUF_ERROR) r = Z_OK;
+
+  /* update counters */
+  z->avail_out -= n;
+  z->total_out += n;
+
+  /* update check information */
+  if (s->checkfn != Z_NULL)
+    z->adler = s->check = (*s->checkfn)(s->check, q, n);
+
+  /* copy as far as end of window */
+  zmemcpy(p, q, n);
+  p += n;
+  q += n;
+
+  /* see if more to copy at beginning of window */
+  if (q == s->end)
+  {
+    /* wrap pointers */
+    q = s->window;
+    if (s->write == s->end)
+      s->write = s->window;
+
+    /* compute bytes to copy */
+    n = (uInt)(s->write - q);
+    if (n > z->avail_out) n = z->avail_out;
+    if (n && r == Z_BUF_ERROR) r = Z_OK;
+
+    /* update counters */
+    z->avail_out -= n;
+    z->total_out += n;
+
+    /* update check information */
+    if (s->checkfn != Z_NULL)
+      z->adler = s->check = (*s->checkfn)(s->check, q, n);
+
+    /* copy */
+    zmemcpy(p, q, n);
+    p += n;
+    q += n;
+  }
+
+  /* update pointers */
+  z->next_out = p;
+  s->read = q;
+
+  /* done */
+  return r;
+}

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

@@ -0,0 +1,98 @@
+/* infutil.h -- types and macros common to blocks and codes
+ * 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.
+ */
+
+#ifndef _INFUTIL_H
+#define _INFUTIL_H
+
+typedef enum {
+      TYPE,     /* get type bits (3, including end bit) */
+      LENS,     /* get lengths for stored */
+      STORED,   /* processing stored block */
+      TABLE,    /* get table lengths */
+      BTREE,    /* get bit lengths tree for a dynamic block */
+      DTREE,    /* get length, distance trees for a dynamic block */
+      CODES,    /* processing fixed or dynamic block */
+      DRY,      /* output remaining window bytes */
+      DONE,     /* finished last block, done */
+      BAD}      /* got a data error--stuck here */
+inflate_block_mode;
+
+/* inflate blocks semi-private state */
+struct inflate_blocks_state {
+
+  /* mode */
+  inflate_block_mode  mode;     /* current inflate_block mode */
+
+  /* mode dependent information */
+  union {
+    uInt left;          /* if STORED, bytes left to copy */
+    struct {
+      uInt table;               /* table lengths (14 bits) */
+      uInt index;               /* index into blens (or border) */
+      uIntf *blens;             /* bit lengths of codes */
+      uInt bb;                  /* bit length tree depth */
+      inflate_huft *tb;         /* bit length decoding tree */
+    } trees;            /* if DTREE, decoding info for trees */
+    struct {
+      inflate_codes_statef 
+         *codes;
+    } decode;           /* if CODES, current state */
+  } sub;                /* submode */
+  uInt last;            /* true if this block is the last block */
+
+  /* mode independent information */
+  uInt bitk;            /* bits in bit buffer */
+  uLong bitb;           /* bit buffer */
+  inflate_huft *hufts;  /* single malloc for tree space */
+  Bytef *window;        /* sliding window */
+  Bytef *end;           /* one byte after sliding window */
+  Bytef *read;          /* window read pointer */
+  Bytef *write;         /* window write pointer */
+  check_func checkfn;   /* check function */
+  uLong check;          /* check on output */
+
+};
+
+
+/* defines for inflate input/output */
+/*   update pointers and return */
+#define UPDBITS {s->bitb=b;s->bitk=k;}
+#define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;}
+#define UPDOUT {s->write=q;}
+#define UPDATE {UPDBITS UPDIN UPDOUT}
+#define LEAVE {UPDATE return inflate_flush(s,z,r);}
+/*   get bytes and bits */
+#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;}
+#define NEEDBYTE {if(n)r=Z_OK;else LEAVE}
+#define NEXTBYTE (n--,*p++)
+#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}}
+#define DUMPBITS(j) {b>>=(j);k-=(j);}
+/*   output bytes */
+#define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q)
+#define LOADOUT {q=s->write;m=(uInt)WAVAIL;}
+#define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}}
+#define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT}
+#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;}
+#define OUTBYTE(a) {*q++=(Byte)(a);m--;}
+/*   load local pointers */
+#define LOAD {LOADIN LOADOUT}
+
+/* masks for lower bits (size given to avoid silly warnings with Visual C++) */
+extern uInt inflate_mask[17];
+
+/* copy as much as possible from the sliding window to the output area */
+extern int inflate_flush OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    int));
+
+struct internal_state      {int dummy;}; /* for buggy compilers */
+
+#endif

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

@@ -0,0 +1,85 @@
+/* maketree.c -- make inffixed.h table for decoding fixed codes
+ * Copyright (C) 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.
+ */
+
+/* This program is included in the distribution for completeness.
+   You do not need to compile or run this program since inffixed.h
+   is already included in the distribution.  To use this program
+   you need to compile zlib with BUILDFIXED defined and then compile
+   and link this program with the zlib library.  Then the output of
+   this program can be piped to inffixed.h. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "zutil.h"
+#include "inftrees.h"
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+/* generate initialization table for an inflate_huft structure array */
+void maketree(uInt b, inflate_huft *t)
+{
+  int i, e;
+
+  i = 0;
+  while (1)
+  {
+    e = t[i].exop;
+    if (e && (e & (16+64)) == 0)        /* table pointer */
+    {
+      fprintf(stderr, "maketree: cannot initialize sub-tables!\n");
+      exit(1);
+    }
+    if (i % 4 == 0)
+      printf("\n   ");
+    printf(" {{{%u,%u}},%u}", t[i].exop, t[i].bits, t[i].base);
+    if (++i == (1<<b))
+      break;
+    putchar(',');
+  }
+  puts("");
+}
+
+/* create the fixed tables in C initialization syntax */
+void main(void)
+{
+  int r;
+  uInt bl, bd;
+  inflate_huft *tl, *td;
+  z_stream z;
+
+  z.zalloc = zcalloc;
+  z.opaque = (voidpf)0;
+  z.zfree = zcfree;
+  r = inflate_trees_fixed(&bl, &bd, &tl, &td, &z);
+  if (r)
+  {
+    fprintf(stderr, "inflate_trees_fixed error %d\n", r);
+    return;
+  }
+  puts("/* inffixed.h -- table for decoding fixed codes");
+  puts(" * Generated automatically by the maketree.c program");
+  puts(" */");
+  puts("");
+  puts("/* WARNING: this file should *not* be used by applications. It is");
+  puts("   part of the implementation of the compression library and is");
+  puts("   subject to change. Applications should only use zlib.h.");
+  puts(" */");
+  puts("");
+  printf("local uInt fixed_bl = %d;\n", bl);
+  printf("local uInt fixed_bd = %d;\n", bd);
+  printf("local inflate_huft fixed_tl[] = {");
+  maketree(bl, tl);
+  puts("  };");
+  printf("local inflate_huft fixed_td[] = {");
+  maketree(bd, td);
+  puts("  };");
+}

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

@@ -0,0 +1,128 @@
+/* header created automatically with -DGEN_TREES_H */
+
+local const ct_data static_ltree[L_CODES+2] = {
+{{ 12},{  8}}, {{140},{  8}}, {{ 76},{  8}}, {{204},{  8}}, {{ 44},{  8}},
+{{172},{  8}}, {{108},{  8}}, {{236},{  8}}, {{ 28},{  8}}, {{156},{  8}},
+{{ 92},{  8}}, {{220},{  8}}, {{ 60},{  8}}, {{188},{  8}}, {{124},{  8}},
+{{252},{  8}}, {{  2},{  8}}, {{130},{  8}}, {{ 66},{  8}}, {{194},{  8}},
+{{ 34},{  8}}, {{162},{  8}}, {{ 98},{  8}}, {{226},{  8}}, {{ 18},{  8}},
+{{146},{  8}}, {{ 82},{  8}}, {{210},{  8}}, {{ 50},{  8}}, {{178},{  8}},
+{{114},{  8}}, {{242},{  8}}, {{ 10},{  8}}, {{138},{  8}}, {{ 74},{  8}},
+{{202},{  8}}, {{ 42},{  8}}, {{170},{  8}}, {{106},{  8}}, {{234},{  8}},
+{{ 26},{  8}}, {{154},{  8}}, {{ 90},{  8}}, {{218},{  8}}, {{ 58},{  8}},
+{{186},{  8}}, {{122},{  8}}, {{250},{  8}}, {{  6},{  8}}, {{134},{  8}},
+{{ 70},{  8}}, {{198},{  8}}, {{ 38},{  8}}, {{166},{  8}}, {{102},{  8}},
+{{230},{  8}}, {{ 22},{  8}}, {{150},{  8}}, {{ 86},{  8}}, {{214},{  8}},
+{{ 54},{  8}}, {{182},{  8}}, {{118},{  8}}, {{246},{  8}}, {{ 14},{  8}},
+{{142},{  8}}, {{ 78},{  8}}, {{206},{  8}}, {{ 46},{  8}}, {{174},{  8}},
+{{110},{  8}}, {{238},{  8}}, {{ 30},{  8}}, {{158},{  8}}, {{ 94},{  8}},
+{{222},{  8}}, {{ 62},{  8}}, {{190},{  8}}, {{126},{  8}}, {{254},{  8}},
+{{  1},{  8}}, {{129},{  8}}, {{ 65},{  8}}, {{193},{  8}}, {{ 33},{  8}},
+{{161},{  8}}, {{ 97},{  8}}, {{225},{  8}}, {{ 17},{  8}}, {{145},{  8}},
+{{ 81},{  8}}, {{209},{  8}}, {{ 49},{  8}}, {{177},{  8}}, {{113},{  8}},
+{{241},{  8}}, {{  9},{  8}}, {{137},{  8}}, {{ 73},{  8}}, {{201},{  8}},
+{{ 41},{  8}}, {{169},{  8}}, {{105},{  8}}, {{233},{  8}}, {{ 25},{  8}},
+{{153},{  8}}, {{ 89},{  8}}, {{217},{  8}}, {{ 57},{  8}}, {{185},{  8}},
+{{121},{  8}}, {{249},{  8}}, {{  5},{  8}}, {{133},{  8}}, {{ 69},{  8}},
+{{197},{  8}}, {{ 37},{  8}}, {{165},{  8}}, {{101},{  8}}, {{229},{  8}},
+{{ 21},{  8}}, {{149},{  8}}, {{ 85},{  8}}, {{213},{  8}}, {{ 53},{  8}},
+{{181},{  8}}, {{117},{  8}}, {{245},{  8}}, {{ 13},{  8}}, {{141},{  8}},
+{{ 77},{  8}}, {{205},{  8}}, {{ 45},{  8}}, {{173},{  8}}, {{109},{  8}},
+{{237},{  8}}, {{ 29},{  8}}, {{157},{  8}}, {{ 93},{  8}}, {{221},{  8}},
+{{ 61},{  8}}, {{189},{  8}}, {{125},{  8}}, {{253},{  8}}, {{ 19},{  9}},
+{{275},{  9}}, {{147},{  9}}, {{403},{  9}}, {{ 83},{  9}}, {{339},{  9}},
+{{211},{  9}}, {{467},{  9}}, {{ 51},{  9}}, {{307},{  9}}, {{179},{  9}},
+{{435},{  9}}, {{115},{  9}}, {{371},{  9}}, {{243},{  9}}, {{499},{  9}},
+{{ 11},{  9}}, {{267},{  9}}, {{139},{  9}}, {{395},{  9}}, {{ 75},{  9}},
+{{331},{  9}}, {{203},{  9}}, {{459},{  9}}, {{ 43},{  9}}, {{299},{  9}},
+{{171},{  9}}, {{427},{  9}}, {{107},{  9}}, {{363},{  9}}, {{235},{  9}},
+{{491},{  9}}, {{ 27},{  9}}, {{283},{  9}}, {{155},{  9}}, {{411},{  9}},
+{{ 91},{  9}}, {{347},{  9}}, {{219},{  9}}, {{475},{  9}}, {{ 59},{  9}},
+{{315},{  9}}, {{187},{  9}}, {{443},{  9}}, {{123},{  9}}, {{379},{  9}},
+{{251},{  9}}, {{507},{  9}}, {{  7},{  9}}, {{263},{  9}}, {{135},{  9}},
+{{391},{  9}}, {{ 71},{  9}}, {{327},{  9}}, {{199},{  9}}, {{455},{  9}},
+{{ 39},{  9}}, {{295},{  9}}, {{167},{  9}}, {{423},{  9}}, {{103},{  9}},
+{{359},{  9}}, {{231},{  9}}, {{487},{  9}}, {{ 23},{  9}}, {{279},{  9}},
+{{151},{  9}}, {{407},{  9}}, {{ 87},{  9}}, {{343},{  9}}, {{215},{  9}},
+{{471},{  9}}, {{ 55},{  9}}, {{311},{  9}}, {{183},{  9}}, {{439},{  9}},
+{{119},{  9}}, {{375},{  9}}, {{247},{  9}}, {{503},{  9}}, {{ 15},{  9}},
+{{271},{  9}}, {{143},{  9}}, {{399},{  9}}, {{ 79},{  9}}, {{335},{  9}},
+{{207},{  9}}, {{463},{  9}}, {{ 47},{  9}}, {{303},{  9}}, {{175},{  9}},
+{{431},{  9}}, {{111},{  9}}, {{367},{  9}}, {{239},{  9}}, {{495},{  9}},
+{{ 31},{  9}}, {{287},{  9}}, {{159},{  9}}, {{415},{  9}}, {{ 95},{  9}},
+{{351},{  9}}, {{223},{  9}}, {{479},{  9}}, {{ 63},{  9}}, {{319},{  9}},
+{{191},{  9}}, {{447},{  9}}, {{127},{  9}}, {{383},{  9}}, {{255},{  9}},
+{{511},{  9}}, {{  0},{  7}}, {{ 64},{  7}}, {{ 32},{  7}}, {{ 96},{  7}},
+{{ 16},{  7}}, {{ 80},{  7}}, {{ 48},{  7}}, {{112},{  7}}, {{  8},{  7}},
+{{ 72},{  7}}, {{ 40},{  7}}, {{104},{  7}}, {{ 24},{  7}}, {{ 88},{  7}},
+{{ 56},{  7}}, {{120},{  7}}, {{  4},{  7}}, {{ 68},{  7}}, {{ 36},{  7}},
+{{100},{  7}}, {{ 20},{  7}}, {{ 84},{  7}}, {{ 52},{  7}}, {{116},{  7}},
+{{  3},{  8}}, {{131},{  8}}, {{ 67},{  8}}, {{195},{  8}}, {{ 35},{  8}},
+{{163},{  8}}, {{ 99},{  8}}, {{227},{  8}}
+};
+
+local const ct_data static_dtree[D_CODES] = {
+{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
+{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
+{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
+{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
+{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
+{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
+};
+
+const uch _dist_code[DIST_CODE_LEN] = {
+ 0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
+ 8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
+10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
+18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+};
+
+const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {
+ 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
+13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+};
+
+local const int base_length[LENGTH_CODES] = {
+0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+64, 80, 96, 112, 128, 160, 192, 224, 0
+};
+
+local const int base_dist[D_CODES] = {
+    0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
+   32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
+ 1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
+};
+

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

@@ -0,0 +1,279 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-1998 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id: zconf.h,v 1.1 2001/03/21 22:32:33 chorns Exp $ */
+
+#ifndef _ZCONF_H
+#define _ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ */
+#ifdef Z_PREFIX
+#  define deflateInit_	z_deflateInit_
+#  define deflate	z_deflate
+#  define deflateEnd	z_deflateEnd
+#  define inflateInit_ 	z_inflateInit_
+#  define inflate	z_inflate
+#  define inflateEnd	z_inflateEnd
+#  define deflateInit2_	z_deflateInit2_
+#  define deflateSetDictionary z_deflateSetDictionary
+#  define deflateCopy	z_deflateCopy
+#  define deflateReset	z_deflateReset
+#  define deflateParams	z_deflateParams
+#  define inflateInit2_	z_inflateInit2_
+#  define inflateSetDictionary z_inflateSetDictionary
+#  define inflateSync	z_inflateSync
+#  define inflateSyncPoint z_inflateSyncPoint
+#  define inflateReset	z_inflateReset
+#  define compress	z_compress
+#  define compress2	z_compress2
+#  define uncompress	z_uncompress
+#  define adler32	z_adler32
+#  define crc32		z_crc32
+#  define get_crc_table z_get_crc_table
+
+#  define Byte		z_Byte
+#  define uInt		z_uInt
+#  define uLong		z_uLong
+#  define Bytef	        z_Bytef
+#  define charf		z_charf
+#  define intf		z_intf
+#  define uIntf		z_uIntf
+#  define uLongf	z_uLongf
+#  define voidpf	z_voidpf
+#  define voidp		z_voidp
+#endif
+
+#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
+#  define WIN32
+#endif
+#if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386)
+#  ifndef __32BIT__
+#    define __32BIT__
+#  endif
+#endif
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#if defined(MSDOS) && !defined(__32BIT__)
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32))  && !defined(STDC)
+#  define STDC
+#endif
+#if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__)
+#  ifndef STDC
+#    define STDC
+#  endif
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const
+#  endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Old Borland C incorrectly complains about missing returns: */
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500)
+#  define NEED_DUMMY_RETURN
+#endif
+
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__)
+   /* MSC small or medium model */
+#  define SMALL_MEDIUM
+#  ifdef _MSC_VER
+#    define FAR _far
+#  else
+#    define FAR far
+#  endif
+#endif
+#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
+#  ifndef __32BIT__
+#    define SMALL_MEDIUM
+#    define FAR _far
+#  endif
+#endif
+
+/* Compile with -DZLIB_DLL for Windows DLL support */
+#if defined(ZLIB_DLL)
+#  if defined(_WINDOWS) || defined(WINDOWS)
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+#    define ZEXPORT  WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA  WINAPIV
+#    else
+#      define ZEXPORTVA  FAR _cdecl _export
+#    endif
+#  endif
+#  if defined (__BORLANDC__)
+#    if (__BORLANDC__ >= 0x0500) && defined (WIN32)
+#      include <windows.h>
+#      define ZEXPORT __declspec(dllexport) WINAPI
+#      define ZEXPORTRVA __declspec(dllexport) WINAPIV
+#    else
+#      if defined (_Windows) && defined (__DLL__)
+#        define ZEXPORT _export
+#        define ZEXPORTVA _export
+#      endif
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  if defined (ZLIB_DLL)
+#    define ZEXTERN extern __declspec(dllexport)
+#  else
+#    define ZEXTERN extern __declspec(dllimport)
+#  endif
+#endif
+
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+
+#ifndef FAR
+#   define FAR
+#endif
+
+#if !defined(MACOS) && !defined(TARGET_OS_MAC)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void FAR *voidpf;
+   typedef void     *voidp;
+#else
+   typedef Byte FAR *voidpf;
+   typedef Byte     *voidp;
+#endif
+
+#ifdef HAVE_UNISTD_H
+#  include <sys/types.h> /* for off_t */
+#  include <unistd.h>    /* for SEEK_* and off_t */
+#  define z_off_t  off_t
+#endif
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+#ifndef z_off_t
+#  define  z_off_t long
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+#   pragma map(deflateInit_,"DEIN")
+#   pragma map(deflateInit2_,"DEIN2")
+#   pragma map(deflateEnd,"DEEND")
+#   pragma map(inflateInit_,"ININ")
+#   pragma map(inflateInit2_,"ININ2")
+#   pragma map(inflateEnd,"INEND")
+#   pragma map(inflateSync,"INSY")
+#   pragma map(inflateSetDictionary,"INSEDI")
+#   pragma map(inflate_blocks,"INBL")
+#   pragma map(inflate_blocks_new,"INBLNE")
+#   pragma map(inflate_blocks_free,"INBLFR")
+#   pragma map(inflate_blocks_reset,"INBLRE")
+#   pragma map(inflate_codes_free,"INCOFR")
+#   pragma map(inflate_codes,"INCO")
+#   pragma map(inflate_fast,"INFA")
+#   pragma map(inflate_flush,"INFLU")
+#   pragma map(inflate_mask,"INMA")
+#   pragma map(inflate_set_dictionary,"INSEDI2")
+#   pragma map(inflate_copyright,"INCOPY")
+#   pragma map(inflate_trees_bits,"INTRBI")
+#   pragma map(inflate_trees_dynamic,"INTRDY")
+#   pragma map(inflate_trees_fixed,"INTRFI")
+#   pragma map(inflate_trees_free,"INTRFR")
+#endif
+
+#endif /* _ZCONF_H */

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

@@ -0,0 +1,893 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.1.3, July 9th, 1998
+
+  Copyright (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
+
+
+  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).
+*/
+
+#ifndef _ZLIB_H
+#define _ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.1.3"
+
+/* 
+     The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed
+  data.  This version of the library supports only one compression method
+  (deflation) but other algorithms will be added later and will have the same
+  stream interface.
+
+     Compression can be done in a single step if the buffers are large
+  enough (for example if an input file is mmap'ed), or can be done by
+  repeated calls of the compression function.  In the latter case, the
+  application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+     The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio.
+
+     The library does not install any signal handler. The decoder checks
+  the consistency of the compressed data, so the library should never
+  crash even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: ascii or binary */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+   The application must update next_in and avail_in when avail_in has
+   dropped to zero. It must update next_out and avail_out when avail_out
+   has dropped to zero. The application must initialize zalloc, zfree and
+   opaque before calling the init function. All other fields are set by the
+   compression library and must not be updated by the application.
+
+   The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree. This can be useful for custom
+   memory management. The compression library attaches no meaning to the
+   opaque value.
+
+   zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+   On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this
+   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
+   pointers returned by zalloc for objects of exactly 65536 bytes *must*
+   have their offset normalized to zero. The default allocation function
+   provided by this library ensures this (see zutil.c). To reduce memory
+   requirements and avoid any allocation of 64K objects, at the expense of
+   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
+
+   The fields total_in and total_out can be used for statistics or
+   progress reports. After compression, total_in holds the total size of
+   the uncompressed data and may be saved for use in the decompressor
+   (particularly if the decompressor wants to decompress everything in
+   a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+/* Allowed flush values; see deflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative
+ * values are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_ASCII    1
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is
+   not compatible with the zlib.h header file used by the application.
+   This check is automatically made by deflateInit and inflateInit.
+ */
+
+/* 
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression. The fields
+   zalloc, zfree and opaque must be initialized before by the caller.
+   If zalloc and zfree are set to Z_NULL, deflateInit updates them to
+   use default allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at
+   all (the input data is simply copied a block at a time).
+   Z_DEFAULT_COMPRESSION requests a default compromise between speed and
+   compression (currently equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if level is not a valid compression level,
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).
+   msg is set to null if there is no error message.  deflateInit does not
+   perform any compression: this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may introduce some
+  output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows. deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly. This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).
+    Some output may be provided even if flush is not set.
+
+  Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating avail_in or avail_out accordingly; avail_out
+  should never be zero before the call. The application can consume the
+  compressed output when it wants, for example when the output buffer is full
+  (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
+  and with zero avail_out, it must be called again after making room in the
+  output buffer because there might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far. (In particular
+  avail_in is zero after the call if enough output space has been provided
+  before the call.)  Flushing may degrade compression for some compression
+  algorithms and so it should be used only when necessary.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
+  the compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there
+  was enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error. After
+  deflate has returned Z_STREAM_END, the only possible operations on the
+  stream are deflateReset or deflateEnd.
+  
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step. In this case, avail_out must be at least
+  0.1% larger than avail_in plus 12 bytes.  If deflate does not return
+  Z_STREAM_END, then it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update data_type if it can make a good guess about
+  the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
+  binary. This field is only for information purposes and does not affect
+  the compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero).
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded). In the error case,
+   msg may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/* 
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression. The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
+   value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller.  msg is set to null if there is no error
+   message. inflateInit does not perform any decompression apart from reading
+   the zlib header if present: this will be done by inflate().  (So next_in and
+   avail_in may be modified, but next_out and avail_out are unchanged.)
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may some
+  introduce some output latency (reading input without producing any output)
+  except when forced to flush.
+
+  The detailed semantics are as follows. inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing
+    will resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there
+    is no more input data or no more space in the output buffer (see below
+    about the flush parameter).
+
+  Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating the next_* and avail_* values accordingly.
+  The application can consume the uncompressed output when it wants, for
+  example when the output buffer is full (avail_out == 0), or after each
+  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+  must be called again after making room in the output buffer because there
+  might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
+  output as possible to the output buffer. The flushing behavior of inflate is
+  not specified for values of the flush parameter other than Z_SYNC_FLUSH
+  and Z_FINISH, but the current implementation actually flushes as much output
+  as possible anyway.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error. However if all decompression is to be performed in a single step
+  (a single call of inflate), the parameter flush should be set to
+  Z_FINISH. In this case all pending input is processed and all pending
+  output is flushed; avail_out must be large enough to hold all the
+  uncompressed data. (The size of the uncompressed data may have been saved
+  by the compressor for this purpose.) The next operation on this stream must
+  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+  is never required, but can be used to inform inflate that a faster routine
+  may be used for the single inflate() call.
+
+     If a preset dictionary is needed at this point (see inflateSetDictionary
+  below), inflate sets strm-adler to the adler32 checksum of the
+  dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise 
+  it sets strm->adler to the adler32 checksum of all output produced
+  so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
+  an error code as described below. At the end of the stream, inflate()
+  checks that its computed adler32 checksum is equal to that saved by the
+  compressor and returns Z_STREAM_END only if the checksum is correct.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect
+  adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
+  (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
+  enough memory, Z_BUF_ERROR if no progress is possible or if there was not
+  enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
+  case, the application may then call inflateSync to look for a good
+  compression block.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent. In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*   
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options. The
+   fields next_in, zalloc, zfree and opaque must be initialized before by
+   the caller.
+
+     The method parameter is the compression method. It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library. Larger values of this parameter result in better
+   compression at the expense of memory usage. The default value is 15 if
+   deflateInit is used instead.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state. memLevel=1 uses minimum memory but
+   is slow and reduces compression ratio; memLevel=9 uses maximum memory
+   for optimal speed. The default value is 8. See zconf.h for total memory
+   usage as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm. Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match).  Filtered data consists mostly of small values with a
+   somewhat random distribution. In this case, the compression algorithm is
+   tuned to compress them better. The effect of Z_FILTERED is to force more
+   Huffman coding and less string matching; it is somewhat intermediate
+   between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
+   the compression ratio but not the correctness of the compressed output even
+   if it is not set appropriately.
+
+      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
+   method). msg is set to null if there is no error message.  deflateInit2 does
+   not perform any compression: this will be done by deflate().
+*/
+                            
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output. This function must be called
+   immediately after deflateInit, deflateInit2 or deflateReset, before any
+   call of deflate. The compressor and decompressor must use exactly the same
+   dictionary (see inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary. Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size in
+   deflate or deflate2. Thus the strings most likely to be useful should be
+   put at the end of the dictionary, not at the front.
+
+     Upon return of this function, strm->adler is set to the Adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor. (The Adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.)
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if the compression method is bsort). deflateSetDictionary does not
+   perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter. The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and
+   can consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being NULL). msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.
+   The stream will keep the same compression level and any other attributes
+   that may have been set by deflateInit2.
+
+      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+				      int level,
+				      int strategy));
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different
+   strategy. If the compression level is changed, the input available so far
+   is compressed with the old level (and may be flushed); the new level will
+   take effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to
+   be compressed and flushed. In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
+   if strm->avail_out was zero.
+*/
+
+/*   
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter. The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library. The default value is 15 if inflateInit is used
+   instead. If a compressed stream with a larger window size is given as
+   input, inflate() will return with the error code Z_DATA_ERROR instead of
+   trying to allocate a larger window.
+
+      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
+   memLevel). msg is set to null if there is no error message.  inflateInit2
+   does not perform any decompression apart from reading the zlib header if
+   present: this will be done by inflate(). (So next_in and avail_in may be
+   modified, but next_out and avail_out are unchanged.)
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence. This function must be called immediately after a call of inflate
+   if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
+   can be determined from the Adler32 value returned by this call of
+   inflate. The compressor and decompressor must use exactly the same
+   dictionary (see deflateSetDictionary).
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect Adler32 value). inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/* 
+    Skips invalid compressed data until a full flush point (see above the
+  description of deflate with Z_FULL_FLUSH) can be found, or until all
+  available input is skipped. No output is provided.
+
+    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+  if no more input was provided, Z_DATA_ERROR if no flush point has been found,
+  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
+  case, the application may save the current current value of total_in which
+  indicates where valid compressed data was found. In the error case, the
+  application may repeatedly call inflateSync, providing more input each time,
+  until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.
+   The stream will keep attributes that may have been set by inflateInit2.
+
+      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the
+   basic stream-oriented functions. To simplify the interface, some
+   default options are assumed (compression level and memory usage,
+   standard memory allocation functions). The source code of these
+   utility functions can easily be modified if you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be at least 0.1% larger than
+   sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
+   compressed buffer.
+     This function can be used to compress a whole file at once if the
+   input file is mmap'ed.
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+/*
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least 0.1% larger than sourceLen plus
+   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be large enough to hold the
+   entire uncompressed data. (The size of the uncompressed data must have
+   been saved previously by the compressor and transmitted to the decompressor
+   by some mechanism outside the scope of this compression library.)
+   Upon exit, destLen is the actual size of the compressed buffer.
+     This function can be used to decompress a whole file at once if the
+   input file is mmap'ed.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted.
+*/
+
+
+typedef voidp gzFile;
+
+ZEXTERN gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
+/*
+     Opens a gzip (.gz) file for reading or writing. The mode parameter
+   is as in fopen ("rb" or "wb") but can also include a compression level
+   ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
+   Huffman only compression as in "wb1h". (See the description
+   of deflateInit2 for more information about the strategy parameter.)
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened or if there was
+   insufficient memory to allocate the (de)compression state; errno
+   can be checked to distinguish the two cases (if errno is zero, the
+   zlib error is Z_MEM_ERROR).  */
+
+ZEXTERN gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
+/*
+     gzdopen() associates a gzFile with the file descriptor fd.  File
+   descriptors are obtained from calls like open, dup, creat, pipe or
+   fileno (in the file has been previously opened with fopen).
+   The mode parameter is as in gzopen.
+     The next call of gzclose on the returned gzFile will also close the
+   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
+   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
+     gzdopen returns NULL if there was insufficient memory to allocate
+   the (de)compression state.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy. See the description
+   of deflateInit2 for the meaning of these parameters.
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+ZEXTERN int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.
+   If the input file was not in gzip format, gzread copies the given number
+   of bytes into the buffer.
+     gzread returns the number of uncompressed bytes actually read (0 for
+   end of file, -1 for error). */
+
+ZEXTERN int ZEXPORT    gzwrite OF((gzFile file, 
+				   const voidp buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes actually written
+   (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the args to the compressed file under
+   control of the format string, as in fprintf. gzprintf returns the number of
+   uncompressed bytes actually written (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+      Reads bytes from the compressed file until len-1 characters are read, or
+   a newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  The string is then terminated with a null
+   character.
+      gzgets returns buf, or Z_NULL in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzputc OF((gzFile file, int c));
+/*
+      Writes c, converted to an unsigned char, into the compressed file.
+   gzputc returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT    gzgetc OF((gzFile file));
+/*
+      Reads one byte from the compressed file. gzgetc returns this byte
+   or -1 in case of end of file or error.
+*/
+
+ZEXTERN int ZEXPORT    gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file. The parameter
+   flush is as in the deflate() function. The return value is the zlib
+   error number (see function gzerror below). gzflush returns Z_OK if
+   the flush parameter is Z_FINISH and all output could be flushed.
+     gzflush should be called only when strictly necessary because it can
+   degrade compression.
+*/
+
+ZEXTERN z_off_t ZEXPORT    gzseek OF((gzFile file,
+				      z_off_t offset, int whence));
+/* 
+      Sets the starting position for the next gzread or gzwrite on the
+   given compressed file. The offset represents a number of bytes in the
+   uncompressed data stream. The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow. If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+      gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+   gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+/*
+     Returns the starting position for the next gzread or gzwrite on the
+   given compressed file. This position represents a number of bytes in the
+   uncompressed data stream.
+
+   gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+     Returns 1 when EOF has previously been detected reading the given
+   input stream, otherwise zero.
+*/
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file
+   and deallocates all the (de)compression state. The return value is the zlib
+   error number (see function gzerror below).
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the
+   given compressed file. errnum is set to zlib error number. If an
+   error occurred in the file system and not in the compression library,
+   errnum is set to Z_ERRNO and the application may consult errno
+   to get the exact error code.
+*/
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the
+   compression library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum. If buf is NULL, this function returns
+   the required initial value for the checksum.
+   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster. Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+/*
+     Update a running crc with the bytes buf[0..len-1] and return the updated
+   crc. If buf is NULL, this function returns the required initial value
+   for the crc. Pre- and post-conditioning (one's complement) is performed
+   within this function so it shouldn't be done by the application.
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+#define deflateInit(strm, level) \
+        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+
+
+#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
+    struct internal_state {int dummy;}; /* hack for buggy compilers */
+#endif
+
+ZEXTERN const char   * ZEXPORT zError           OF((int err));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp z));
+ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ZLIB_H */

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

@@ -0,0 +1,225 @@
+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-1998 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h 
+ */
+
+/* @(#) $Id: zutil.c,v 1.1 2001/03/21 22:32:33 chorns Exp $ */
+
+#include "zutil.h"
+
+struct internal_state      {int dummy;}; /* for buggy compilers */
+
+#ifndef STDC
+extern void exit OF((int));
+#endif
+
+const char *z_errmsg[10] = {
+"need dictionary",     /* Z_NEED_DICT       2  */
+"stream end",          /* Z_STREAM_END      1  */
+"",                    /* Z_OK              0  */
+"file error",          /* Z_ERRNO         (-1) */
+"stream error",        /* Z_STREAM_ERROR  (-2) */
+"data error",          /* Z_DATA_ERROR    (-3) */
+"insufficient memory", /* Z_MEM_ERROR     (-4) */
+"buffer error",        /* Z_BUF_ERROR     (-5) */
+"incompatible version",/* Z_VERSION_ERROR (-6) */
+""};
+
+
+const char * ZEXPORT zlibVersion()
+{
+    return ZLIB_VERSION;
+}
+
+#ifdef DEBUG
+
+#  ifndef verbose
+#    define verbose 0
+#  endif
+int z_verbose = verbose;
+
+void z_error (m)
+    char *m;
+{
+    fprintf(stderr, "%s\n", m);
+    exit(1);
+}
+#endif
+
+/* exported to allow conversion of error code to string for compress() and
+ * uncompress()
+ */
+const char * ZEXPORT zError(err)
+    int err;
+{
+    return ERR_MSG(err);
+}
+
+
+#ifndef HAVE_MEMCPY
+
+void zmemcpy(dest, source, len)
+    Bytef* dest;
+    const Bytef* source;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = *source++; /* ??? to be unrolled */
+    } while (--len != 0);
+}
+
+int zmemcmp(s1, s2, len)
+    const Bytef* s1;
+    const Bytef* s2;
+    uInt  len;
+{
+    uInt j;
+
+    for (j = 0; j < len; j++) {
+        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
+    }
+    return 0;
+}
+
+void zmemzero(dest, len)
+    Bytef* dest;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = 0;  /* ??? to be unrolled */
+    } while (--len != 0);
+}
+#endif
+
+#ifdef __TURBOC__
+#if (defined( __BORLANDC__) || !defined(SMALL_MEDIUM)) && !defined(__32BIT__)
+/* Small and medium model in Turbo C are for now limited to near allocation
+ * with reduced MAX_WBITS and MAX_MEM_LEVEL
+ */
+#  define MY_ZCALLOC
+
+/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
+ * and farmalloc(64K) returns a pointer with an offset of 8, so we
+ * must fix the pointer. Warning: the pointer must be put back to its
+ * original form in order to free it, use zcfree().
+ */
+
+#define MAX_PTR 10
+/* 10*64K = 640K */
+
+local int next_ptr = 0;
+
+typedef struct ptr_table_s {
+    voidpf org_ptr;
+    voidpf new_ptr;
+} ptr_table;
+
+local ptr_table table[MAX_PTR];
+/* This table is used to remember the original form of pointers
+ * to large buffers (64K). Such pointers are normalized with a zero offset.
+ * Since MSDOS is not a preemptive multitasking OS, this table is not
+ * protected from concurrent access. This hack doesn't work anyway on
+ * a protected system like OS/2. Use Microsoft C instead.
+ */
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    voidpf buf = opaque; /* just to make some compilers happy */
+    ulg bsize = (ulg)items*size;
+
+    /* If we allocate less than 65520 bytes, we assume that farmalloc
+     * will return a usable pointer which doesn't have to be normalized.
+     */
+    if (bsize < 65520L) {
+        buf = farmalloc(bsize);
+        if (*(ush*)&buf != 0) return buf;
+    } else {
+        buf = farmalloc(bsize + 16L);
+    }
+    if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
+    table[next_ptr].org_ptr = buf;
+
+    /* Normalize the pointer to seg:0 */
+    *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
+    *(ush*)&buf = 0;
+    table[next_ptr++].new_ptr = buf;
+    return buf;
+}
+
+void  zcfree (voidpf opaque, voidpf ptr)
+{
+    int n;
+    if (*(ush*)&ptr != 0) { /* object < 64K */
+        farfree(ptr);
+        return;
+    }
+    /* Find the original pointer */
+    for (n = 0; n < next_ptr; n++) {
+        if (ptr != table[n].new_ptr) continue;
+
+        farfree(table[n].org_ptr);
+        while (++n < next_ptr) {
+            table[n-1] = table[n];
+        }
+        next_ptr--;
+        return;
+    }
+    ptr = opaque; /* just to make some compilers happy */
+    Assert(0, "zcfree: ptr not found");
+}
+#endif
+#endif /* __TURBOC__ */
+
+
+#if defined(M_I86) && !defined(__32BIT__)
+/* Microsoft C in 16-bit mode */
+
+#  define MY_ZCALLOC
+
+#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
+#  define _halloc  halloc
+#  define _hfree   hfree
+#endif
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    return _halloc((long)items, size);
+}
+
+void  zcfree (voidpf opaque, voidpf ptr)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    _hfree(ptr);
+}
+
+#endif /* MSC */
+
+
+#ifndef MY_ZCALLOC /* Any system without a special alloc function */
+
+#ifndef STDC
+extern voidp  calloc OF((uInt items, uInt size));
+extern void   free   OF((voidpf ptr));
+#endif
+
+voidpf zcalloc (opaque, items, size)
+    voidpf opaque;
+    unsigned items;
+    unsigned size;
+{
+    if (opaque) items += size - size; /* make compiler happy */
+    return (voidpf)calloc(items, size);
+}
+
+void  zcfree (opaque, ptr)
+    voidpf opaque;
+    voidpf ptr;
+{
+    free(ptr);
+    if (opaque) return; /* make compiler happy */
+}
+
+#endif /* MY_ZCALLOC */

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

@@ -0,0 +1,220 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * 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: zutil.h,v 1.1 2001/03/21 22:32:33 chorns Exp $ */
+
+#ifndef _Z_UTIL_H
+#define _Z_UTIL_H
+
+#include "zlib.h"
+
+#ifdef STDC
+#  include <stddef.h>
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+    extern int errno;
+#else
+#   include <errno.h>
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+typedef unsigned char  uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long  ulg;
+
+extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+  return (strm->msg = (char*)ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+        /* common constants */
+
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+        /* target dependencies */
+
+#ifdef MSDOS
+#  define OS_CODE  0x00
+#  if defined(__TURBOC__) || defined(__BORLANDC__)
+#    if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+       /* Allow compilation with ANSI keywords only enabled */
+       void _Cdecl farfree( void *block );
+       void *_Cdecl farmalloc( unsigned long nbytes );
+#    else
+#     include <alloc.h>
+#    endif
+#  else /* MSC or DJGPP */
+#    include <malloc.h>
+#  endif
+#endif
+
+#ifdef OS2
+#  define OS_CODE  0x06
+#endif
+
+#ifdef WIN32 /* Window 95 & Windows NT */
+#  define OS_CODE  0x0b
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#  define OS_CODE  0x02
+#  define F_OPEN(name, mode) \
+     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#ifdef AMIGA
+#  define OS_CODE  0x01
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#  define OS_CODE  0x05
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+#  define OS_CODE  0x07
+#  if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#    include <unix.h> /* for fdopen */
+#  else
+#    ifndef fdopen
+#      define fdopen(fd,mode) NULL /* No fdopen() */
+#    endif
+#  endif
+#endif
+
+#ifdef __50SERIES /* Prime/PRIMOS */
+#  define OS_CODE  0x0F
+#endif
+
+#ifdef TOPS20
+#  define OS_CODE  0x0a
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+#  define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600))
+#  define fdopen(fd,type)  _fdopen(fd,type)
+#endif
+
+
+        /* Common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  0x03  /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+#  define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+         /* functions */
+
+#ifdef HAVE_STRERROR
+   extern char *strerror OF((int));
+#  define zstrerror(errnum) strerror(errnum)
+#else
+#  define zstrerror(errnum) ""
+#endif
+
+#if defined(pyr)
+#  define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+  * You may have to use the same strategy for Borland C (untested).
+  * The __SC__ check is for Symantec.
+  */
+#  define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+#  define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+#    define zmemcpy _fmemcpy
+#    define zmemcmp _fmemcmp
+#    define zmemzero(dest, len) _fmemset(dest, 0, len)
+#  else
+#    define zmemcpy memcpy
+#    define zmemcmp memcmp
+#    define zmemzero(dest, len) memset(dest, 0, len)
+#  endif
+#else
+   extern void zmemcpy  OF((Bytef* dest, const Bytef* source, uInt len));
+   extern int  zmemcmp  OF((const Bytef* s1, const Bytef* s2, uInt len));
+   extern void zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef DEBUG
+#  include <stdio.h>
+   extern int z_verbose;
+   extern void z_error    OF((char *m));
+#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
+#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
+#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+
+typedef uLong (ZEXPORT *check_func) OF((uLong check, const Bytef *buf,
+				       uInt len));
+voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
+void   zcfree  OF((voidpf opaque, voidpf ptr));
+
+#define ZALLOC(strm, items, size) \
+           (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+#endif /* _Z_UTIL_H */

reactos/apps/utils/cat/makefile

@@ -1,6 +1,8 @@
 #
 #
 #
+PATH_TO_TOP = ../..
+
 OBJECTS= cat.o
 PROGS= cat.exe
 
@@ -9,29 +11,19 @@ all: cat.exe
 .phony: all
 
 clean:
-	- $(RM) cat.o
-	- $(RM) cat.exe
-	- $(RM) cat.sym
+	- $(RM) cat.o cat.exe cat.sym
 
 .phony: clean
 
-floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
+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
 
 .PHONY: floppy dist
 

reactos/apps/utils/net/ping/.cvsignore

@@ -0,0 +1 @@
+ping.coff

reactos/apps/utils/net/ping/makefile

@@ -0,0 +1,37 @@
+#
+# ReactOS Ping Utility
+#
+PATH_TO_TOP = ../../..
+
+TARGETNAME=ping
+CFLAGS = -I../../../include
+
+OBJECTS = $(TARGETNAME).o $(TARGETNAME).coff
+PROGS = $(TARGETNAME).exe
+LIBS = ../../../lib/ntdll/ntdll.a \
+       ../../../lib/ws2_32/ws2_32.a
+
+CLEAN_FILES = $(TARGETNAME).o $(TARGETNAME).exe $(TARGETNAME).sym
+
+all: $(TARGETNAME).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/$*
+
+$(TARGETNAME).exe: $(OBJECTS) $(LIBS)
+	$(CC) $(OBJECTS) $(LIBS) -o $(TARGETNAME).exe
+	$(NM) --numeric-sort $(TARGETNAME).exe > $(TARGETNAME).sym
+
+include ../../../rules.mak

reactos/apps/utils/net/ping/ping.c

@@ -0,0 +1,629 @@
+/* $Id: ping.c,v 1.5 2001/06/15 17:48:43 chorns Exp $
+ *
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS ping utility
+ * FILE:        apps/net/ping/ping.c
+ * PURPOSE:     Network test utility
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH  01/09/2000 Created
+ */
+#include <winsock2.h>
+#include <tchar.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#ifndef _MSC_VER
+
+//#define DBG
+
+/* FIXME: Where should this be? */
+#define CopyMemory(Destination, Source, Length) memcpy(Destination, Source, Length);
+
+/* Should be in the header files somewhere (exported by ntdll.dll) */
+long atol(const char *str);
+
+#ifndef __int64
+typedef long long __int64;
+#endif
+
+char * _i64toa(__int64 value, char *string, int radix);
+
+#endif
+
+
+/* General ICMP constants */
+#define ICMP_MINSIZE		8		/* Minimum ICMP packet size */
+#define ICMP_MAXSIZE		65535	/* Maximum ICMP packet size */
+
+/* ICMP message types */
+#define ICMPMSG_ECHOREQUEST	8		/* ICMP ECHO request message */
+#define ICMPMSG_ECHOREPLY	0		/* ICMP ECHO reply message */
+
+#pragma pack(4)
+
+/* IPv4 header structure */
+typedef struct _IPv4_HEADER {
+	unsigned char	IHL:4;
+	unsigned char	Version:4;
+	unsigned char	TOS;
+	unsigned short	Length;
+	unsigned short	Id;
+	unsigned short	FragFlags;
+	unsigned char	TTL;
+	unsigned char	Protocol;
+	unsigned short	Checksum;
+	unsigned int	SrcAddress;
+	unsigned int	DstAddress;
+} IPv4_HEADER, *PIPv4_HEADER;
+
+/* ICMP echo request/reply header structure */
+typedef struct _ICMP_HEADER {
+	unsigned char	Type;
+	unsigned char	Code;
+	unsigned short	Checksum;
+	unsigned short	Id;
+	unsigned short	SeqNum;
+} ICMP_HEADER, *PICMP_HEADER;
+
+typedef struct _ICMP_ECHO_PACKET {
+	ICMP_HEADER   Icmp;
+	LARGE_INTEGER Timestamp;
+} ICMP_ECHO_PACKET, *PICMP_ECHO_PACKET;
+
+#pragma pack(1)
+
+BOOL                InvalidOption;
+BOOL                NeverStop;
+BOOL                ResolveAddresses;
+UINT                PingCount;
+UINT                DataSize;   /* ICMP echo request data size */
+BOOL                DontFragment;
+ULONG               TTLValue;
+ULONG               TOSValue;
+ULONG               Timeout;
+CHAR                TargetName[256];
+SOCKET              IcmpSock;
+SOCKADDR_IN         Target;
+LPSTR               TargetIP;
+FD_SET              Fds;
+TIMEVAL             Timeval;
+UINT                CurrentSeqNum;
+UINT                SentCount;
+UINT                LostCount;
+BOOL                MinRTTSet;
+LARGE_INTEGER       MinRTT;     /* Minimum round trip time in microseconds */
+LARGE_INTEGER       MaxRTT;
+LARGE_INTEGER       SumRTT;
+LARGE_INTEGER       AvgRTT;
+LARGE_INTEGER       TicksPerMs; /* Ticks per millisecond */
+LARGE_INTEGER       TicksPerUs; /* Ticks per microsecond */
+BOOL                UsePerformanceCounter;
+
+
+/* Display the contents of a buffer */
+VOID DisplayBuffer(
+    PVOID Buffer,
+    DWORD Size)
+{
+    UINT i;
+    PCHAR p;
+
+    printf("Buffer (0x%X)  Size (0x%X).\n", Buffer, Size);
+
+    p = (PCHAR)Buffer;
+    for (i = 0; i < Size; i++) {
+      if (i % 16 == 0) {
+        printf("\n");
+      }
+      printf("%02X ", (p[i]) & 0xFF);
+    }
+}
+
+/* Display usage information on screen */
+VOID Usage(VOID)
+{
+	printf("\nUsage: ping [-t] [-n count] [-l size] [-w timeout] destination-host\n\n");
+	printf("Options:\n");
+	printf("    -t             Ping the specified host until stopped.\n");
+	printf("                   To stop - type Control-C.\n");
+	printf("    -n count       Number of echo requests to send.\n");
+	printf("    -l size        Send buffer size.\n");
+	printf("    -w timeout     Timeout in milliseconds to wait for each reply.\n\n");
+}
+
+/* Reset configuration to default values */
+VOID Reset(VOID)
+{
+    LARGE_INTEGER PerformanceCounterFrequency;
+
+    NeverStop             = FALSE;
+    ResolveAddresses      = FALSE;
+    PingCount             = 4;
+    DataSize              = 32;
+    DontFragment          = FALSE;
+    TTLValue              = 128;
+    TOSValue              = 0;
+    Timeout               = 1000;
+    UsePerformanceCounter = QueryPerformanceFrequency(&PerformanceCounterFrequency);
+
+    if (UsePerformanceCounter) {
+        /* Performance counters may return incorrect results on some multiprocessor
+           platforms so we restrict execution on the first processor. This may fail
+           on Windows NT so we fall back to GetCurrentTick() for timing */
+        if (SetThreadAffinityMask (GetCurrentThread(), 1) == 0) {
+            UsePerformanceCounter = FALSE;
+        }
+
+        /* Convert frequency to ticks per millisecond */
+        TicksPerMs.QuadPart = PerformanceCounterFrequency.QuadPart / 1000;
+        /* And to ticks per microsecond */
+        TicksPerUs.QuadPart = PerformanceCounterFrequency.QuadPart / 1000000;
+    }
+    if (!UsePerformanceCounter) {
+        /* 1 tick per millisecond for GetCurrentTick() */
+        TicksPerMs.QuadPart = 1;
+        /* GetCurrentTick() cannot handle microseconds */
+        TicksPerUs.QuadPart = 1;
+    }
+}
+
+/* Return ULONG in a string */
+ULONG GetULONG(LPSTR String)
+{
+    UINT i, Length;
+    ULONG Value;
+
+    i = 0;
+    Length = strlen(String);
+    while ((i < Length) && ((String[i] < '0') || (String[i] > '9'))) i++;
+    if ((i >= Length) || ((String[i] < '0') || (String[i] > '9'))) {
+        InvalidOption = TRUE;
+        return 0;
+    }
+    Value = (ULONG)atol(&String[i]);
+
+    return Value;
+}
+
+/* Return ULONG in a string. Try next paramter if not successful */
+ULONG GetULONG2(LPSTR String1, LPSTR String2, PINT i)
+{
+    ULONG Value;
+
+    Value = GetULONG(String1);
+    if (InvalidOption) {
+        InvalidOption = FALSE;
+        if (String2[0] != '-') {
+            Value = GetULONG(String2);
+            if (!InvalidOption)
+                *i += 1;
+        }
+    }
+
+    return Value;
+}
+
+/* Parse command line parameters */
+BOOL ParseCmdline(int argc, char* argv[])
+{
+    INT i;
+    BOOL ShowUsage;
+    BOOL FoundTarget;
+#if 1
+    lstrcpy(TargetName, "127.0.0.1");
+    PingCount = 1;
+    return TRUE;
+#endif
+    if (argc < 2) {
+        ShowUsage = TRUE;
+    } else {
+        ShowUsage = FALSE;
+    }
+    FoundTarget = FALSE;
+    InvalidOption = FALSE;
+
+    for (i = 1; i < argc; i++) {
+        if (argv[i][0] == '-') {
+            switch (argv[i][1]) {
+            case 't': NeverStop = TRUE; break;
+            case 'a': ResolveAddresses = TRUE; break;
+            case 'n': PingCount = GetULONG2(&argv[i][2], argv[i + 1], &i); break;
+            case 'l':
+                DataSize = GetULONG2(&argv[i][2], argv[i + 1], &i);
+                if ((DataSize < 0) || (DataSize > ICMP_MAXSIZE - sizeof(ICMP_ECHO_PACKET))) {
+                    printf("Bad value for option -l, valid range is from 0 to %d.\n",
+                        ICMP_MAXSIZE - sizeof(ICMP_ECHO_PACKET));
+                    return FALSE;
+                }
+                break;
+            case 'f': DontFragment = TRUE; break;
+            case 'i': TTLValue = GetULONG2(&argv[i][2], argv[i + 1], &i); break;
+            case 'v': TOSValue = GetULONG2(&argv[i][2], argv[i + 1], &i); break;
+            case 'w': Timeout  = GetULONG2(&argv[i][2], argv[i + 1], &i); break;
+            default:
+                printf("Bad option %s.\n", argv[i]);
+                Usage();
+                return FALSE;
+            }
+            if (InvalidOption) {
+                printf("Bad option format %s.\n", argv[i]);
+                return FALSE;
+            }
+        } else {
+            if (FoundTarget) {
+                printf("Bad parameter %s.\n", argv[i]);
+                return FALSE;
+            } else {
+				lstrcpy(TargetName, argv[i]);
+                FoundTarget = TRUE;
+            }
+        }
+    }
+
+    if ((!ShowUsage) && (!FoundTarget)) {
+        printf("Name or IP address of destination host must be specified.\n");
+        return FALSE;
+    }
+
+    if (ShowUsage) {
+        Usage();
+        return FALSE;
+    }
+    return TRUE;
+}
+
+/* Calculate checksum of data */
+WORD Checksum(PUSHORT data, UINT size)
+{
+    ULONG sum = 0;
+
+    while (size > 1) {
+        sum  += *data++;
+        size -= sizeof(USHORT);
+    }
+
+    if (size)
+        sum += *(UCHAR*)data;
+
+    sum = (sum >> 16) + (sum & 0xFFFF);
+    sum += (sum >> 16);
+
+    return (USHORT)(~sum);
+}
+
+/* Prepare to ping target */
+BOOL Setup(VOID)
+{
+    WORD     wVersionRequested;
+    WSADATA  WsaData;
+    INT	     Status;
+    ULONG    Addr;
+    PHOSTENT phe;
+
+    wVersionRequested = MAKEWORD(2, 2);
+ 
+    Status = WSAStartup(wVersionRequested, &WsaData);
+    if (Status != 0) {
+        printf("Could not initialize winsock dll.\n");	
+        return FALSE;
+    }
+
+    IcmpSock = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
+    if (IcmpSock == INVALID_SOCKET) {
+        printf("Could not create socket (#%d).\n", WSAGetLastError());
+        return FALSE;
+    }
+
+    ZeroMemory(&Target, sizeof(Target));
+    phe = NULL;
+    Addr = inet_addr(TargetName);
+    if (Addr == INADDR_NONE) {
+        phe = gethostbyname(TargetName);
+        if (phe == NULL) {
+            printf("Unknown host %s.\n", TargetName);
+            return FALSE;
+        } 
+    }
+	
+    if (phe != NULL) {
+        CopyMemory(&Target.sin_addr, phe->h_addr_list, phe->h_length);
+    } else {
+        Target.sin_addr.s_addr = Addr;
+    }
+
+    if (phe != NULL) {
+		Target.sin_family = phe->h_addrtype;
+    } else {
+        Target.sin_family = AF_INET;
+    }
+	
+    TargetIP		= inet_ntoa(Target.sin_addr);
+    CurrentSeqNum	= 0;
+    SentCount		= 0;
+	LostCount		= 0;
+    MinRTT.QuadPart = 0;
+    MaxRTT.QuadPart = 0;
+    SumRTT.QuadPart = 0;
+    MinRTTSet       = FALSE;
+    return TRUE;
+}
+
+/* Close socket */
+VOID Cleanup(VOID)
+{
+    if (IcmpSock != INVALID_SOCKET)
+        closesocket(IcmpSock);
+
+    WSACleanup();
+}
+
+VOID QueryTime(PLARGE_INTEGER Time)
+{
+    if (UsePerformanceCounter) {
+        if (QueryPerformanceCounter(Time) == 0) {
+            /* This should not happen, but we fall
+               back to GetCurrentTick() if it does */
+            Time->u.LowPart  = (ULONG)GetTickCount();
+            Time->u.HighPart = 0;
+
+            /* 1 tick per millisecond for GetCurrentTick() */
+            TicksPerMs.QuadPart = 1;
+            /* GetCurrentTick() cannot handle microseconds */
+            TicksPerUs.QuadPart = 1;
+
+            UsePerformanceCounter = FALSE;
+        }
+    } else {
+        Time->u.LowPart  = (ULONG)GetTickCount();
+        Time->u.HighPart = 0;
+    }
+}
+
+VOID TimeToMsString(LPSTR String, LARGE_INTEGER Time)
+{
+    UINT          i, Length;
+    CHAR          Convstr[40];
+    LARGE_INTEGER LargeTime;
+
+    LargeTime.QuadPart = Time.QuadPart / TicksPerMs.QuadPart;
+    _i64toa(LargeTime.QuadPart, Convstr, 10);
+	strcpy(String, Convstr);
+    strcat(String, ",");
+
+    LargeTime.QuadPart = (Time.QuadPart % TicksPerMs.QuadPart) / TicksPerUs.QuadPart;
+    _i64toa(LargeTime.QuadPart, Convstr, 10);
+    Length = strlen(Convstr);
+    if (Length < 4) {
+        for (i = 0; i < 4 - Length; i++)
+            strcat(String, "0");
+    }
+
+    strcat(String, Convstr);
+    strcat(String, "ms");
+}
+
+/* Locate the ICMP data and print it. Returns TRUE if the packet was good,
+   FALSE if not */
+BOOL DecodeResponse(PCHAR buffer, UINT size, PSOCKADDR_IN from)
+{
+    PIPv4_HEADER      IpHeader;
+    PICMP_ECHO_PACKET Icmp;
+  	UINT              IphLength;
+    CHAR              Time[100];
+    LARGE_INTEGER     RelativeTime;
+    LARGE_INTEGER     LargeTime;
+
+    IpHeader = (PIPv4_HEADER)buffer;
+
+    IphLength = IpHeader->IHL * 4;
+
+    if (size  < IphLength + ICMP_MINSIZE) {
+#ifdef DBG
+        printf("Bad size (0x%X < 0x%X)\n", size, IphLength + ICMP_MINSIZE);
+#endif DBG
+        return FALSE;
+    }
+
+    Icmp = (PICMP_ECHO_PACKET)(buffer + IphLength);
+
+    if (Icmp->Icmp.Type != ICMPMSG_ECHOREPLY) {
+#ifdef DBG
+        printf("Bad ICMP type (0x%X should be 0x%X)\n", Icmp->Icmp.Type, ICMPMSG_ECHOREPLY);
+#endif DBG
+        return FALSE;
+    }
+
+    if (Icmp->Icmp.Id != (USHORT)GetCurrentProcessId()) {
+#ifdef DBG
+        printf("Bad ICMP id (0x%X should be 0x%X)\n", Icmp->Icmp.Id, (USHORT)GetCurrentProcessId());
+#endif DBG
+        return FALSE;
+    }
+
+    QueryTime(&LargeTime);
+
+    RelativeTime.QuadPart = (LargeTime.QuadPart - Icmp->Timestamp.QuadPart);
+
+    TimeToMsString(Time, RelativeTime);
+
+    printf("Reply from %s: bytes=%d time=%s TTL=%d\n", inet_ntoa(from->sin_addr), 
+      size - IphLength - sizeof(ICMP_ECHO_PACKET), Time, IpHeader->TTL);
+    if (RelativeTime.QuadPart < MinRTT.QuadPart) {
+		  MinRTT.QuadPart = RelativeTime.QuadPart;
+      MinRTTSet = TRUE;
+    }
+	  if (RelativeTime.QuadPart > MaxRTT.QuadPart)
+	      MaxRTT.QuadPart = RelativeTime.QuadPart;
+    SumRTT.QuadPart += RelativeTime.QuadPart;
+
+	return TRUE;
+}
+
+/* Send and receive one ping */
+BOOL Ping(VOID)
+{
+    INT                 Status;
+    SOCKADDR            From;
+    UINT                Length;
+    PVOID               Buffer;
+    UINT                Size;
+    PICMP_ECHO_PACKET   Packet;
+
+    /* Account for extra space for IP header when packet is received */
+    Size   = DataSize + 128;
+    Buffer = GlobalAlloc(0, Size);
+    if (!Buffer) {
+        printf("Not enough free resources available.\n");
+        return FALSE;
+    }
+
+    ZeroMemory(Buffer, Size);
+    Packet = (PICMP_ECHO_PACKET)Buffer;
+
+    /* Assemble ICMP echo request packet */
+    Packet->Icmp.Type     = ICMPMSG_ECHOREQUEST;
+    Packet->Icmp.Code     = 0;
+    Packet->Icmp.Id	      = (USHORT)GetCurrentProcessId();
+    Packet->Icmp.SeqNum   = (USHORT)CurrentSeqNum;
+    Packet->Icmp.Checksum = 0;
+
+    /* Timestamp is part of data area */
+    QueryTime(&Packet->Timestamp);
+
+    CopyMemory(Buffer, &Packet->Icmp, sizeof(ICMP_ECHO_PACKET) + DataSize);
+    /* Calculate checksum for ICMP header and data area */
+    Packet->Icmp.Checksum = Checksum((PUSHORT)&Packet->Icmp, sizeof(ICMP_ECHO_PACKET) + DataSize);
+
+    CurrentSeqNum++;
+
+	/* Send ICMP echo request */
+
+    FD_ZERO(&Fds);
+    FD_SET(IcmpSock, &Fds);
+    Timeval.tv_sec  = Timeout / 1000;
+    Timeval.tv_usec = Timeout % 1000;
+    Status = select(0, NULL, &Fds, NULL, &Timeval);
+    if ((Status != SOCKET_ERROR) && (Status != 0)) {
+
+#ifdef DBG
+        printf("Sending packet\n");
+        DisplayBuffer(Buffer, sizeof(ICMP_ECHO_PACKET) + DataSize);
+        printf("\n");
+#endif DBG
+
+        Status = sendto(IcmpSock, Buffer, sizeof(ICMP_ECHO_PACKET) + DataSize,
+            0, (SOCKADDR*)&Target, sizeof(Target));
+        SentCount++;
+    }
+    if (Status == SOCKET_ERROR) {
+        if (WSAGetLastError() == WSAEHOSTUNREACH) {
+            printf("Destination host unreachable.\n");
+        } else {
+            printf("Could not transmit data (%d).\n", WSAGetLastError());
+        }
+        GlobalFree(Buffer);
+        return FALSE;
+    }
+
+    /* Expect to receive ICMP echo reply */
+    FD_ZERO(&Fds);
+    FD_SET(IcmpSock, &Fds);
+    Timeval.tv_sec  = Timeout / 1000;
+    Timeval.tv_usec = Timeout % 1000;
+
+    Status = select(0, &Fds, NULL, NULL, &Timeval);
+    if ((Status != SOCKET_ERROR) && (Status != 0)) {
+        Length = sizeof(From);
+        Status = recvfrom(IcmpSock, Buffer, Size, 0, &From, &Length);
+
+#ifdef DBG
+        printf("Received packet\n");
+        DisplayBuffer(Buffer, Status);
+        printf("\n");
+#endif DBG
+    }
+    if (Status == SOCKET_ERROR) {
+        if (WSAGetLastError() != WSAETIMEDOUT) {
+            printf("Could not receive data (%d).\n", WSAGetLastError());
+            GlobalFree(Buffer);
+            return FALSE;
+        }
+        Status = 0;
+    }
+
+    if (Status == 0) {
+        printf("Request timed out.\n");
+        LostCount++;
+        GlobalFree(Buffer);
+        return TRUE;
+    }
+
+    if (!DecodeResponse(Buffer, Status, (PSOCKADDR_IN)&From)) {
+        /* FIXME: Wait again as it could be another ICMP message type */
+        printf("Request timed out (incomplete datagram received).\n");
+        LostCount++;
+    }
+
+    GlobalFree(Buffer);
+    return TRUE;
+}
+
+
+/* Program entry point */
+int main(int argc, char* argv[])
+{
+    UINT Count;
+    CHAR MinTime[20];
+    CHAR MaxTime[20];
+    CHAR AvgTime[20];
+
+    Reset();
+
+    if ((ParseCmdline(argc, argv)) && (Setup())) {
+
+        printf("\nPinging %s [%s] with %d bytes of data:\n\n",
+            TargetName, TargetIP, DataSize);
+		
+		Count = 0;
+		while ((NeverStop) || (Count < PingCount)) {
+			Ping();
+			Sleep(Timeout);
+			Count++;
+		};
+
+        Cleanup();
+
+		/* Calculate avarage round trip time */
+        if ((SentCount - LostCount) > 0) {
+            AvgRTT.QuadPart = SumRTT.QuadPart / (SentCount - LostCount);
+        } else {
+            AvgRTT.QuadPart = 0;
+        }
+
+        /* Calculate loss percent */
+        if (LostCount > 0) {
+            Count = (SentCount * 100) / LostCount;
+        } else {
+            Count = 0;
+        }
+
+        if (!MinRTTSet)
+            MinRTT = MaxRTT;
+
+        TimeToMsString(MinTime, MinRTT);
+        TimeToMsString(MaxTime, MaxRTT);
+        TimeToMsString(AvgTime, AvgRTT);
+
+        /* Print statistics */
+        printf("\nPing statistics for %s:\n", TargetIP);
+        printf("    Packets: Sent = %d, Received = %d, Lost = %d (%d%% loss),\n",
+            SentCount, SentCount - LostCount, LostCount, Count);
+        printf("Approximate round trip times in milli-seconds:\n");
+        printf("    Minimum = %s, Maximum = %s, Average = %s\n",
+            MinTime, MaxTime, AvgTime);
+    }
+	return 0;
+}
+
+/* EOF */

reactos/apps/utils/net/ping/ping.rc

@@ -0,0 +1,39 @@
+#include <defines.h>
+#include <reactos/resource.h>
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+VS_VERSION_INFO VERSIONINFO
+	FILEVERSION	RES_UINT_FV_MAJOR,RES_UINT_FV_MINOR,RES_UINT_FV_REVISION,RES_UINT_FV_BUILD
+	PRODUCTVERSION	RES_UINT_PV_MAJOR,RES_UINT_PV_MINOR,RES_UINT_PV_REVISION,RES_UINT_PV_BUILD	
+	FILEFLAGSMASK	0x3fL
+#ifdef _DEBUG
+	FILEFLAGS	0x1L
+#else
+	FILEFLAGS	0x0L
+#endif
+	FILEOS		0x40004L
+	FILETYPE	0x2L
+	FILESUBTYPE	0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName",	RES_STR_COMPANY_NAME
+            VALUE "FileDescription",	"ReactOS TCP/IPv4 Win32 Ping\0"
+            VALUE "FileVersion",	RES_STR_FILE_VERSION
+            VALUE "InternalName",	"ping\0"
+            VALUE "LegalCopyright",	RES_STR_LEGAL_COPYRIGHT
+            VALUE "OriginalCopyright",	"Casper S. Hornstrup (chorns@users.sourceforge.net)\0"
+            VALUE "OriginalFilename",	"ping.exe\0"
+            VALUE "ProductName",	RES_STR_PRODUCT_NAME
+            VALUE "ProductVersion",	RES_STR_PRODUCT_VERSION
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+

reactos/apps/utils/net/roshttpd/common/list.cpp

@@ -0,0 +1,94 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        list.cpp
+ * PURPOSE:     A doubly linked list implementation
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH  01/09/2000 Created
+ * NOTES:       The linked list does it's own heap management for
+ *              better performance
+ * TODO:        - InsertBefore(), InsertAfter(), Move()
+ */
+#include <windows.h>
+#include <list.h>
+
+// **************************** CListNode ****************************
+
+HANDLE CListNode::hHeap = NULL;
+INT    CListNode::nRef = 0;
+
+// Default constructor
+CListNode::CListNode()
+{
+	Element = NULL;
+	Next = NULL;
+	Prev = NULL;
+}
+
+// Constructor with element and next as starter values
+CListNode::CListNode(PVOID element, CListNode *next, CListNode *prev)
+{
+	Element = element;
+	Next = next;
+	Prev = prev;
+}
+
+void* CListNode::operator new(/*size_t*/ UINT size)
+{
+    PVOID p;
+    if (hHeap == NULL) {
+        SYSTEM_INFO inf;
+        GetSystemInfo(&inf);
+        hHeap = HeapCreate(0, inf.dwAllocationGranularity, 0);
+    }
+    if ((p = HeapAlloc(hHeap, 0, size)) != NULL)
+        nRef++;
+    return p;
+}
+
+VOID CListNode::operator delete(void* p)
+{
+    if (HeapFree(hHeap, 0, p) != FALSE)
+        nRef--;
+    if (nRef == 0) {
+        HeapDestroy(hHeap);
+        hHeap = NULL;
+	}
+}
+
+// Set element
+VOID CListNode::SetElement(PVOID element)
+{
+	Element = element;
+}
+
+// Set pointer to next node in list
+VOID CListNode::SetNext(CListNode *next)
+{
+	Next = next;
+}
+
+// Set pointer to previous node in list
+VOID CListNode::SetPrev(CListNode *prev)
+{
+	Prev = prev;
+}
+
+// Get element of node
+PVOID CListNode::GetElement()
+{
+	return Element;
+}
+
+// Get pointer to next node in list
+CListNode *CListNode::GetNext()
+{
+	return Next;
+}
+
+// Get pointer to previous node in list
+CListNode *CListNode::GetPrev()
+{
+	return Prev;
+}

reactos/apps/utils/net/roshttpd/common/roshttpd.rc

@@ -0,0 +1,39 @@
+#include <defines.h>
+#include <reactos/resource.h>
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+VS_VERSION_INFO VERSIONINFO
+	FILEVERSION	RES_UINT_FV_MAJOR,RES_UINT_FV_MINOR,RES_UINT_FV_REVISION,RES_UINT_FV_BUILD
+	PRODUCTVERSION	RES_UINT_PV_MAJOR,RES_UINT_PV_MINOR,RES_UINT_PV_REVISION,RES_UINT_PV_BUILD	
+	FILEFLAGSMASK	0x3fL
+#ifdef _DEBUG
+	FILEFLAGS	0x1L
+#else
+	FILEFLAGS	0x0L
+#endif
+	FILEOS		0x40004L
+	FILETYPE	0x2L
+	FILESUBTYPE	0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName",	RES_STR_COMPANY_NAME
+            VALUE "FileDescription",	"ReactOS HTTP Win32 Server\0"
+            VALUE "FileVersion",	RES_STR_FILE_VERSION
+            VALUE "InternalName",	"roshttpd\0"
+            VALUE "LegalCopyright",	RES_STR_LEGAL_COPYRIGHT
+            VALUE "OriginalCopyright",	"Casper S. Hornstrup (chorns@users.sourceforge.net)\0"
+            VALUE "OriginalFilename",	"roshttpd.exe\0"
+            VALUE "ProductName",	RES_STR_PRODUCT_NAME
+            VALUE "ProductVersion",	RES_STR_PRODUCT_VERSION
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+

reactos/apps/utils/net/roshttpd/common/socket.cpp

@@ -0,0 +1,343 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        socket.cpp
+ * PURPOSE:     Socket classes
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH  01/09/2000 Created
+ */
+#include <error.h>
+#include <socket.h>
+#include <iterator.h>
+
+// ***************************** CSocket *****************************
+
+// Default constructor
+CSocket::CSocket()
+{
+    Active = FALSE;
+	Event  = WSA_INVALID_EVENT;
+	Events = 0;
+	Socket = INVALID_SOCKET;
+
+	// INET address family
+	SockAddrIn.sin_family = AF_INET;
+
+    // Any address will do
+    SockAddrIn.sin_addr.s_addr = INADDR_ANY;
+
+    // Convert to network ordering 
+    SockAddrIn.sin_port = htons(0);
+}
+
+// Default destructor
+CSocket::~CSocket()
+{
+}
+
+// Return winsock socket handle
+SOCKET CSocket::GetSocket()
+{
+	return Socket;
+}
+
+// Set winsock socket handle
+VOID CSocket::SetSocket(SOCKET socket)
+{
+	Socket = socket;
+}
+	
+
+// Return socket address
+SOCKADDR_IN CSocket::GetSockAddrIn()
+{
+	return SockAddrIn;
+}
+
+// Set socket address
+VOID CSocket::SetSockAddrIn(SOCKADDR_IN sockaddrin)
+{
+	SockAddrIn = sockaddrin;
+}
+
+// Associate winsock events with socket
+VOID CSocket::SetEvents(LONG lEvents)
+{
+	if (Event == WSA_INVALID_EVENT) {
+		// Create socket event
+		Event = WSACreateEvent();
+		if (Event == WSA_INVALID_EVENT)
+			throw ESocketOpen(TS("Unable to create event."));
+	}
+	
+	if (lEvents != Events) {
+		// Associate network events with socket
+		if (WSAEventSelect(Socket, Event, lEvents) == SOCKET_ERROR)
+			throw ESocketOpen(TS("Unable to select socket events."));
+		Events = lEvents;
+	}
+}
+
+// Return associated winsock events
+LONG CSocket::GetEvents()
+{
+	return Events;
+}
+
+// Open socket
+VOID CSocket::Open()
+{
+}
+
+// Close socket
+VOID CSocket::Close()
+{
+}
+
+
+// *********************** CServerClientSocket ***********************
+
+// Constructor with serversocket as parameter
+CServerClientSocket::CServerClientSocket(LPCServerSocket lpServerSocket)
+{
+	ServerSocket = lpServerSocket;
+}
+
+// Transmit data to socket
+INT CServerClientSocket::Transmit( LPSTR lpsBuffer, UINT nLength)
+{
+    return send(Socket, lpsBuffer, nLength, 0);
+}
+
+// Send a string to socket
+INT CServerClientSocket::SendText( LPSTR lpsText)
+{
+    static CHAR crlf[3] = {0x0D, 0x0A, 0x00};
+	INT nCount;
+
+    nCount = Transmit(lpsText, strlen(lpsText));
+	nCount += Transmit(crlf, strlen(crlf));
+	return nCount;
+}
+
+// Receive data from socket
+INT CServerClientSocket::Receive(LPSTR lpsBuffer, UINT nLength)
+{
+	return recv(Socket, lpsBuffer, nLength, 0);
+}
+
+// Process winsock messages if any
+VOID CServerClientSocket::MessageLoop()
+{
+	UINT nStatus;
+    WSANETWORKEVENTS NetworkEvents;
+
+    nStatus = WSAWaitForMultipleEvents(1, &Event, FALSE, 0, FALSE);
+    if ((nStatus == 0) && (WSAEnumNetworkEvents(Socket, Event, &NetworkEvents) != SOCKET_ERROR)) {
+        if ((NetworkEvents.lNetworkEvents & FD_READ) != 0) {
+			OnRead();
+		} 
+        if ((NetworkEvents.lNetworkEvents & FD_CLOSE) != 0) {
+			OnClose();
+        }
+    }
+}
+
+// Return server socket that own this socket
+LPCServerSocket CServerClientSocket::GetServerSocket()
+{
+	return ServerSocket;
+}
+
+
+// *********************** CServerClientThread ***********************
+
+CServerClientThread::CServerClientThread(LPCServerClientSocket lpSocket)
+{
+	ClientSocket = lpSocket;
+}
+
+CServerClientThread::~CServerClientThread()
+{
+	ClientSocket->GetServerSocket()->RemoveClient((LPCServerClientThread) this);
+}
+
+
+// ************************** CServerSocket **************************	
+
+// Default constructor
+CServerSocket::CServerSocket()
+{
+}
+
+// Default destructor
+CServerSocket::~CServerSocket()
+{
+	if (Active)
+		Close();
+}
+
+// Open server socket so clients can connect
+VOID CServerSocket::Open()
+{
+	assert(!Active);
+	
+	// Convert to network ordering 
+	SockAddrIn.sin_port = htons(Port);
+
+	if (Socket == INVALID_SOCKET) {
+		// Create socket
+		Socket = socket(AF_INET, SOCK_STREAM, 0);
+		if (Socket == INVALID_SOCKET)
+	        throw ESocketOpen(TS("Unable to allocate a socket."));
+	}
+
+	// Associate an address with server socket
+	if (bind(Socket, (struct sockaddr FAR *) &SockAddrIn, sizeof(SockAddrIn)) == SOCKET_ERROR)
+		throw ESocketOpen(TS("Unable to associate address with socket."));
+
+	// Listen for incoming connections
+	if (listen(Socket, MAX_PENDING_CONNECTS) != 0)
+		throw ESocketOpen(TS("Unable to listen on socket."));
+
+	// Associate network events with socket
+	SetEvents(FD_ACCEPT | FD_CONNECT | FD_CLOSE);
+
+	Active = TRUE;
+}
+
+// Close server socket and all current connections
+VOID CServerSocket::Close()
+{
+	assert(Active);
+
+	if (Event != WSA_INVALID_EVENT) {
+		// Tell winsock not to notify us about any events
+		if (WSAEventSelect(Socket, Event, 0) == SOCKET_ERROR)
+			throw ESocketClose(TS("Unable to select socket events."));
+
+		if (!WSACloseEvent(Event))
+			throw ESocketClose(TS("Unable to close socket event."));
+		Event = WSA_INVALID_EVENT;
+	}
+	
+	CIterator<LPCServerClientThread> *i = Connections.CreateIterator();
+
+	// Terminate and free all client threads
+	for (i->First(); !i->IsDone(); i->Next()) {
+		//i->CurrentItem()->Terminate();
+		delete i->CurrentItem();
+	}
+	delete i;
+	Connections.RemoveAll();
+
+	closesocket(Socket);
+	Socket = INVALID_SOCKET;
+
+	Active = FALSE;
+}
+
+// Set port number to listen on
+VOID CServerSocket::SetPort(UINT nPort)
+{
+	assert(!Active);
+
+	Port = nPort;
+}
+
+// Process messages from winsock if any
+VOID CServerSocket::MessageLoop()
+{
+    UINT nStatus;
+	INT nAddrLen;
+	SOCKET ClientSocket;
+	SOCKADDR_IN SockAddrIn;
+    WSANETWORKEVENTS NetworkEvents;
+	LPCServerClientSocket lpClient;
+	LPCServerClientThread lpThread;
+	
+    nStatus = WSAWaitForMultipleEvents(1, &Event, FALSE, 0, FALSE);
+    if ((nStatus == 0) && (WSAEnumNetworkEvents(Socket, Event, &NetworkEvents) != SOCKET_ERROR)) {
+        if ((NetworkEvents.lNetworkEvents & FD_ACCEPT) != 0) {
+			lpClient = OnGetSocket(this);
+			nAddrLen = sizeof(SockAddrIn);
+			ClientSocket = accept(Socket, (SOCKADDR *) &SockAddrIn, &nAddrLen);
+			if (ClientSocket != INVALID_SOCKET) {
+				// Set socket handle
+				lpClient->SetSocket(ClientSocket);
+				// Set socket address
+				lpClient->SetSockAddrIn(SockAddrIn);
+				// Set winsock events
+				lpClient->SetEvents(FD_READ | FD_CLOSE);
+				// Create client connection thread
+				lpThread = OnGetThread(lpClient);
+				// Add client thread to connection list
+				InsertClient(lpThread);
+				// Call OnAccept event handler
+				OnAccept(lpThread);
+			} else {
+				delete lpClient;
+				lpClient = NULL;
+				throw ESocketOpen(TS("No more sockets available."));
+			}
+		}
+        /*if ((NetworkEvents.lNetworkEvents & FD_CONNECT) != 0) {
+        }
+        if ((NetworkEvents.lNetworkEvents & FD_CLOSE) != 0) {
+        }*/
+    }
+}
+
+// Insert client into connection list
+VOID CServerSocket::InsertClient(LPCServerClientThread lpClient)
+{
+	Connections.Insert(lpClient);
+}
+
+// Remove client from connection list
+VOID CServerSocket::RemoveClient(LPCServerClientThread lpClient)
+{
+	Connections.Remove(lpClient);
+}
+
+// OnGetSocket event handler
+LPCServerClientSocket CServerSocket::OnGetSocket(LPCServerSocket lpServerSocket)
+{
+	return NULL;
+}
+
+// OnGetThread event handler
+LPCServerClientThread CServerSocket::OnGetThread(LPCServerClientSocket lpSocket)
+{
+	return NULL;
+}
+
+
+// Initialize WinSock DLL
+VOID InitWinsock()
+{
+    WORD wVersionRequested;
+    WSADATA wsaData;
+
+    wVersionRequested = MAKEWORD(2, 0);
+ 
+    if (WSAStartup(wVersionRequested, &wsaData) != 0)
+        // Return FALSE as we couldn't find a usable WinSock DLL
+		throw ESocketWinsock(TS("Unable to initialize winsock dll."));
+   
+    /* Confirm that the WinSock DLL supports 2.0 */
+ 
+    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 0) {
+        // We couldn't find a usable winsock dll
+        WSACleanup();
+		throw ESocketDll(TS("Winsock dll version is not 2.0 or higher."));
+    }
+}
+
+// Deinitialize WinSock DLL
+VOID DeinitWinsock()
+{
+	if (WSACleanup() != 0)
+		throw ESocketWinsock(TS("Unable to deinitialize winsock dll."));
+}

reactos/apps/utils/net/roshttpd/common/thread.cpp

@@ -0,0 +1,80 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        thread.cpp
+ * PURPOSE:     Generic thread class
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH  01/09/2000 Created
+ */
+#include <debug.h>
+#include <assert.h>
+#include <windows.h>
+#include <thread.h>
+
+// This is the thread entry code
+DWORD WINAPI ThreadEntry(LPVOID parameter)
+{
+	ThreadData *p = (ThreadData*) parameter;
+
+    p->ClassPtr->Execute();
+
+	SetEvent(p->hFinished);
+	return 0;
+}
+
+// Default constructor
+CThread::CThread()
+{
+	bTerminated = FALSE;
+	// Points to the class that is executed within thread
+	Data.ClassPtr = this;
+	// Create synchronization event
+	Data.hFinished = CreateEvent(NULL, TRUE, FALSE, NULL);
+
+	// FIXME: Do some error handling
+	assert(Data.hFinished != NULL);
+
+	// Create thread
+    hThread = CreateThread(NULL, 0, ThreadEntry, &Data, 0, &dwThreadId);
+
+	// FIXME: Do some error handling
+	assert(hThread != NULL);
+}
+
+// Default destructor
+CThread::~CThread()
+{
+	if ((hThread != NULL) && (Data.hFinished != NULL)) {
+		if (!bTerminated)
+			Terminate();
+		WaitForSingleObject(Data.hFinished, INFINITE);
+		CloseHandle(Data.hFinished);
+		CloseHandle(hThread);
+		hThread = NULL;
+	}
+}
+
+// Execute thread code
+void CThread::Execute()
+{
+	while (!bTerminated) Sleep(0);
+}
+
+// Post a message to the thread's message queue
+BOOL CThread::PostMessage(UINT Msg, WPARAM wParam, LPARAM lParam)
+{
+	return PostThreadMessage(dwThreadId, Msg, wParam, lParam);
+}
+
+// Gracefully terminate thread
+void CThread::Terminate()
+{
+	bTerminated = TRUE;
+}
+
+// Returns TRUE if thread is terminated, FALSE if not
+BOOL CThread::Terminated()
+{
+	return bTerminated;
+}

reactos/apps/utils/net/roshttpd/config.cpp

@@ -0,0 +1,130 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        config.cpp
+ * PURPOSE:     Daemon configuration
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH  01/09/2000 Created
+ */
+#include <new>
+#include <stdlib.h>
+#include <string.h>
+#include <config.h>
+
+using namespace std;
+
+LPCConfig pConfiguration;
+LPCHttpDaemonThread pDaemonThread;
+
+// Default constructor
+CConfig::CConfig()
+{
+	Reset();
+}
+
+// Default destructor
+CConfig::~CConfig()
+{
+	Clear();
+}
+
+// Clear configuration
+void CConfig::Reset()
+{
+	MainBase = NULL;
+	HttpBase = NULL;
+	DefaultResources.RemoveAll();
+}
+
+// Create default configuration. Can throw bad_alloc
+void CConfig::Default()
+{
+	Clear();
+	MainBase = (LPWSTR)_wcsdup(dcfgMainBase);
+	HttpBase = _strdup(dcfgHttpBase);
+
+	LPSTR lpsStr;
+	try {
+		lpsStr = _strdup(dcfgDefaultResource);
+		DefaultResources.Insert(lpsStr);
+	} catch (bad_alloc e) {
+		free((void *)lpsStr);
+		Clear();
+		throw;
+	}
+
+    Port = dcfgDefaultPort;
+}
+
+// Clear configuration
+void CConfig::Clear()
+{
+	if (MainBase != NULL)
+		free((void *)MainBase);
+	if (HttpBase != NULL)
+		free((void *)HttpBase);
+
+	// Free memory for all strings
+	CIterator<LPSTR> *i = DefaultResources.CreateIterator();
+	for (i->First(); !i->IsDone(); i->Next())
+		free((void *)i->CurrentItem());
+	delete i;
+
+	Reset();
+}
+
+// Load configuration
+BOOL CConfig::Load()
+{
+    Default();
+	return TRUE;
+}
+
+// Save configuration
+BOOL CConfig::Save()
+{
+    return TRUE;
+}
+
+// Return MainBase
+LPWSTR CConfig::GetMainBase()
+{
+	return MainBase;
+}
+
+// Set MainBase
+void CConfig::SetMainBase(LPWSTR lpwsMainBase)
+{
+	MainBase = lpwsMainBase;
+}
+
+// Return HttpBase
+LPSTR CConfig::GetHttpBase()
+{
+	return HttpBase;
+}
+
+// Set HttpBase
+void CConfig::SetHttpBase(LPSTR lpsHttpBase)
+{
+	HttpBase = lpsHttpBase;
+}
+
+// Return DefaultResources
+CList<LPSTR>* CConfig::GetDefaultResources()
+{
+	return &DefaultResources;
+}
+
+// Return bound port
+USHORT CConfig::GetPort()
+{
+    return Port;
+}
+
+// Set port
+VOID CConfig::SetPort(USHORT wPort)
+{
+    Port = wPort;
+}

reactos/apps/utils/net/roshttpd/error.cpp

@@ -0,0 +1,16 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        error.cpp
+ * PURPOSE:     Error reporting
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH  01/09/2000 Created
+ */
+#include <error.h>
+#include <stdio.h>
+
+void ReportErrorStr(LPTSTR lpsText)
+{
+    wprintf((__wchar_t*)lpsText);
+}

reactos/apps/utils/net/roshttpd/http.cpp

@@ -0,0 +1,380 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        http.cpp
+ * PURPOSE:     HTTP 1.1 parser engine
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH  01/09/2000 Created
+ * TODO:        - Implement message-body
+ *              - Implement more generel-header entries
+ *              - Implement more request-header entries
+ *              - Implement more entity-header entries
+ */
+#include <debug.h>
+#include <iostream.h>
+#include <string.h>
+#include <http.h>
+
+CHAR MethodTable[NUMMETHODS][8] = {"OPTIONS", "GET", "HEAD", "POST", "PUT", 
+    "DELETE", "TRACE"};
+
+CHAR GenerelTable[NUMGENERELS][18] = {"Cache-Control", "Connection", "Date", "Pragma", 
+    "Transfer-Encoding", "Upgrade", "Via"};
+
+CHAR RequestTable[NUMREQUESTS][20] = {"Accept", "Accept-Charset", "Accept-Encoding",
+    "Accept-Language", "Authorization", "From", "Host", "If-Modified-Since", "If-Match",
+    "If-None-Match", "If-Range", "If-Unmodified-Since", "Max-Forwards",
+    "Proxy-Authorization", "Range", "Referer", "User-Agent"};
+
+CHAR EntityTable[NUMENTITIES][17] = {"Allow", "Content-Base", "Content-Encoding",
+    "Content-Language", "Content-Length", "Content-Location", "Content-MD5",
+    "Content-Range", "Content-Type", "ETag", "Expires", "Last-Modified"};
+
+// *************************** CHttpParser ***************************
+
+// Default constructor
+CHttpParser::CHttpParser()
+{
+    nHead = 0;
+    nTail = 0;
+}
+
+// Default destructor
+CHttpParser::~CHttpParser()
+{
+}
+
+// Returns TRUE if a complete HTTP message is in buffer
+BOOL CHttpParser::Complete()
+{
+    UINT nTmp;
+
+    /*DPRINT("--1:-%d---\n", sBuffer[nHead-2]);
+    DPRINT("--2:-%d---\n", sBuffer[nHead-1]);
+
+    sBuffer[nHead] = '!';
+    sBuffer[nHead+1] = 0;
+    DPRINT("Examining buffer: (Head: %d, Tail: %d)\n", nHead, nTail);
+    DPRINT("%s\n", (LPSTR)&sBuffer[nTail]);*/
+
+    nTmp = nTail;
+    if (!Parse()) {
+        if (!bUnknownMethod)
+            nTail = nTmp;
+        return FALSE;
+    } else
+        return TRUE;
+}
+
+
+// Read a character from buffer
+BOOL CHttpParser::ReadChar(LPSTR lpsStr)
+{
+    if (nTail <= nHead) {
+        if (nTail != nHead) {
+            lpsStr[0] = sBuffer[nTail];
+            nTail++;
+            return TRUE;
+        } else {
+            lpsStr[0] = 0;
+            return FALSE;
+        }
+    } else {
+        if (nTail == sizeof(sBuffer))
+            nTail = 0;
+        if (nTail != nHead) {
+            lpsStr[0] = sBuffer[nTail];
+            nTail++;
+            return TRUE;
+        } else {
+            lpsStr[0] = 0;
+            return FALSE;
+        }
+    }
+}
+
+// Peek at a character in the buffer
+BOOL CHttpParser::PeekChar(LPSTR lpsStr)
+{
+    UINT nFakeTail;
+    
+    if (nTail == sizeof(sBuffer))
+        nFakeTail = 0;
+    else
+        nFakeTail = nTail;
+    if (nFakeTail != nHead) {
+        lpsStr[0] = sBuffer[nFakeTail];
+        return TRUE;
+    } else {
+        lpsStr[0] = 0;
+        return FALSE;
+    }
+}
+
+// Read a string from buffer. Only A-Z, a-z, 0-9 and '-' are valid characters
+BOOL CHttpParser::ReadString(LPSTR lpsStr, UINT nLength)
+{
+    UINT i = 0;
+    CHAR sTmp;
+    
+    while (PeekChar(&sTmp)) {
+        if (((sTmp >= 'A') && (sTmp <= 'Z')) || ((sTmp >= 'a') && (sTmp <= 'z')) ||
+            ((sTmp >= '0') && (sTmp <= '9')) || (sTmp == '-')) { 
+            if (i >= (nLength - 1)) {
+                lpsStr[0] = 0;
+                return FALSE;
+            }
+            ReadChar(&sTmp);
+            lpsStr[i] = sTmp;
+            i++;
+        } else {
+            lpsStr[i] = 0;
+            return TRUE;
+        }
+    }
+    lpsStr[0] = 0;
+    return FALSE;
+}
+
+// Read a string from buffer. Stop if SP or CR is found or when there are no more 
+// characters
+BOOL CHttpParser::ReadSpecial(LPSTR lpsStr, UINT nLength)
+{
+    UINT i = 0;
+    CHAR sTmp;
+ 
+    while (PeekChar(&sTmp) && (sTmp != ' ') && (sTmp != 13)) {
+        if (i >= (nLength - 1)) {
+            lpsStr[nLength - 1] = 0;
+            return FALSE;
+        }
+        ReadChar(&sTmp);
+        lpsStr[i] = sTmp;
+        i++;
+    }
+    lpsStr[i] = 0;
+    return TRUE;
+}
+
+// Skip until "sCh" is found
+VOID CHttpParser::Skip(CHAR sCh)
+{
+    CHAR sTmp;
+
+    while (PeekChar(&sTmp) && (sTmp != sCh))
+        ReadChar(&sTmp);
+}
+
+// Return TRUE if sCh is the next character
+BOOL CHttpParser::Expect(CHAR sCh)
+{
+    CHAR sTmp;
+
+    if (PeekChar(&sTmp)) {
+        if (sTmp == sCh) {
+            ReadChar(&sTmp);
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+// Return TRUE if CRLF are the next characters
+BOOL CHttpParser::ExpectCRLF()
+{
+    return (Expect(13) && Expect(10));
+}
+
+// Request = RequestLine | *( GenerelHeader | RequestHeader | EntityHeader ) 
+//           CRLF [ MessageBody ]
+BOOL CHttpParser::Parse()
+{
+    BOOL bStatus;
+
+
+    CHAR ch;
+
+    if (RequestLine()) {
+        do {
+            if (!ReadString(sHeader, sizeof(sHeader)))
+                break;
+            bStatus = (GenerelHeader());
+            bStatus = (RequestHeader() || bStatus);
+            bStatus = (EntityHeader() || bStatus);
+        } while (bStatus);
+        // CRLF
+        if (!ExpectCRLF())
+            return FALSE;
+        MessageBody();
+        return TRUE;
+    }
+    return FALSE;
+}
+
+// RequestLine = Method SP RequestURI SP HTTP-Version CRLF
+BOOL CHttpParser::RequestLine()
+{
+    CHAR sCh;
+    UINT i;
+
+    bUnknownMethod = FALSE;
+
+    // RFC 2068 states that servers SHOULD ignore any empty nine(s) received where a 
+    // Request-Line is expected
+    while (PeekChar(&sCh) && ((sCh == 13) || (sCh == 10)));
+    
+    if (!ReadString(sMethod, sizeof(sMethod)))
+        return FALSE;
+
+    for (i = 0; i < NUMMETHODS; i++) {
+        if (strcmp(MethodTable[i], sMethod) == 0) {
+            nMethodNo = i;
+            if (!Expect(' '))
+                return FALSE;
+            // URI (ie. host/directory/resource)
+            if (!ReadSpecial(sUri, sizeof(sUri)))
+                return FALSE;
+            if (!Expect(' '))
+                return FALSE;
+            // HTTP version (eg. HTTP/1.1)
+            if (!ReadSpecial(sVersion, sizeof(sVersion)))
+                return FALSE;
+            // CRLF
+            if (!ExpectCRLF())
+                return FALSE;
+
+            return TRUE;
+        }
+    }
+    bUnknownMethod = TRUE;
+    return FALSE;
+}
+
+// GenerelHeader = Cache-Control | Connection | Date | Pragma | Transfer-Encoding | 
+//                 Upgrade | Via
+BOOL CHttpParser::GenerelHeader()
+{
+    INT i;
+
+    for (i = 0; i < NUMGENERELS; i++) {
+        if (strcmp(GenerelTable[i], sHeader) == 0) {
+            switch (i) {
+                case 1: {
+                    //Connection
+                    Expect(':');
+                    Expect(' ');
+                    Skip(13);
+                    ExpectCRLF();
+                    break;
+                }
+                default: {
+                    Expect(':');
+                    Expect(' ');
+                    Skip(13);
+                    ExpectCRLF();
+                }
+            }
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+// RequestHeader = Accept | Accept-Charset | Accept-Encoding | Accept-Language |
+//                 Authorization | From | Host | If-Modified-Since | If-Match |
+//                 If-None-Match | If-Range | If-Unmodified-Since | Max-Forwards |
+//                 Proxy-Authorization | Range | Referer | User-Agent
+BOOL CHttpParser::RequestHeader()
+{
+    INT i;
+
+    for (i = 0; i < NUMREQUESTS; i++) {
+        if (strcmp(RequestTable[i], sHeader) == 0) {
+            switch (i) {
+                case 0: {
+                    //Accept
+                    Expect(':');
+                    Expect(' ');
+                    Skip(13);
+                    ExpectCRLF();
+                    break;
+                }
+                case 2: {
+                    //Accept-Encoding
+                    Expect(':');
+                    Expect(' ');
+                    Skip(13);
+                    ExpectCRLF();
+                    break;
+                }
+                case 3: {
+                    //Accept-Language
+                    Expect(':');
+                    Expect(' ');
+                    Skip(13);
+                    ExpectCRLF();
+                    break;
+                }
+                case 6: {
+                    //Host
+                    Expect(':');
+                    Expect(' ');
+                    Skip(13);
+                    ExpectCRLF();
+                    break;
+                }
+                case 16: {
+                    //User-Agent
+                    Expect(':');
+                    Expect(' ');
+                    Skip(13);
+                    ExpectCRLF();
+                    break;
+                }
+                default: {
+                    Expect(':');
+                    Expect(' ');
+                    Skip(13);
+                    ExpectCRLF();
+                    return TRUE;
+                }
+            }
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+// EntityHeader = Allow | Content-Base | Content-Encoding | Content-Language |
+//                Content-Length | Content-Location | Content-MD5 |
+//                Content-Range | Content-Type | ETag | Expires |
+//                Last-Modified | extension-header
+BOOL CHttpParser::EntityHeader()
+{
+    INT i;
+
+    for (i = 0; i < NUMENTITIES; i++) {
+        if (strcmp(EntityTable[i], sHeader) == 0) {
+            switch (i) {
+                case 0: 
+                default: {
+                    //cout << "<Entity-Header>: #" << i << endl; 
+                    Expect(':');
+                    Expect(' ');
+                    Skip(13);
+                    ExpectCRLF();
+                    return TRUE;
+                }
+            }
+            return FALSE;
+        }
+    }
+    return FALSE;
+}
+
+// MessageBody = *OCTET
+BOOL CHttpParser::MessageBody()
+{
+    return FALSE;
+}

reactos/apps/utils/net/roshttpd/httpd.cpp

@@ -0,0 +1,492 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        httpd.cpp
+ * PURPOSE:     HTTP daemon
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH  01/09/2000 Created
+ */
+#include <debug.h>
+#include <new>
+#include <malloc.h>
+#include <string.h>
+#include <config.h>
+#include <httpd.h>
+#include <error.h>
+
+using namespace std;
+
+CHAR HttpMsg400[] = "<HEAD><TITLE>400 Bad Request</TITLE></HEAD>\n\r<BODY><H1>400 Bad Request</H1>\n\rThe request had bad syntax.<BR>\n\r</BODY>\n\r\n\r";
+CHAR HttpMsg404[] = "<HEAD><TITLE>404 Not Found</TITLE></HEAD>\n\r<BODY><H1>404 Not Found</H1>\n\rThe requested URL was not found on this server.<BR>\n\r</BODY>\n\r\n\r";
+CHAR HttpMsg405[] = "<HEAD><TITLE>405 Method Not Allowed</TITLE></HEAD>\n\r<BODY><H1>405 Method Not Allowed</H1>\n\rThe requested method is not supported on this server.<BR>\n\r</BODY>\n\r\n\r";
+CHAR HttpMsg500[] = "<HEAD><TITLE>500 Internal Server Error</TITLE></HEAD>\n\r<BODY><H1>500 Internal Server Error</H1>\n\rAn internal error occurred.<BR>\n\r</BODY>\n\r\n\r";
+CHAR HttpMsg501[] = "<HEAD><TITLE>501 Not Implemented</TITLE></HEAD>\n\r<BODY><H1>501 Not Implemented</H1>\n\rThe feature is not implemented.<BR>\n\r</BODY>\n\r\n\r";
+
+
+// *************************** CHttpClient ***************************
+
+// Default constructor
+CHttpClient::CHttpClient()
+{
+}
+
+// Constructor with server socket as starter value
+CHttpClient::CHttpClient(CServerSocket *serversocket)
+{
+	ServerSocket = serversocket;
+}
+
+// Split URIs into its parts (ie. |http://|www.host.com|/resource|?parameters|)
+VOID CHttpClient::SplitUri(LPSTR lpsUri, LPSTR lpsHost, LPSTR lpsResource, LPSTR lpsParams)
+{
+    LPSTR lpsPos;
+	LPSTR lpsStr;
+    UINT i;
+
+	strcpy(lpsHost, "");
+	strcpy(lpsResource, "");
+	strcpy(lpsParams, "");
+
+    lpsPos = strstr(lpsUri, "://");
+    if (lpsPos != NULL)
+        lpsStr = &lpsPos[3];
+	else
+		lpsStr = lpsUri;
+        
+    lpsPos = strstr(lpsStr, "/");
+    if (lpsPos != NULL) {
+        strncat(lpsHost, lpsPos, lpsPos - lpsStr);
+        lpsStr = &lpsPos[1];
+
+        lpsPos = strstr(lpsStr, "?");
+        if (lpsPos != NULL) {
+            strncat(lpsResource, lpsStr, lpsPos - lpsStr);
+            strcpy(lpsParams, &lpsPos[1]);
+        } else {
+            strcpy(lpsResource, lpsStr);
+            strcpy(lpsParams, "");
+        }
+
+        // Replace "/" with "\"
+		for (i = 0; i < strlen(lpsResource); i++) {
+            if (lpsResource[i] == '/')
+                lpsResource[i] = '\\';
+        }
+    }
+}
+
+// Split resource into its parts (ie. |/path/|filename|.extension|)
+VOID CHttpClient::SplitResource(LPSTR lpsResource, LPSTR lpsPath, LPSTR lpsFilename, LPSTR lpsExtension)
+{
+    INT i,len,fileptr,extptr;
+	
+	strcpy(lpsPath, "");
+	strcpy(lpsFilename, "");
+	strcpy(lpsExtension, "");
+	
+	len = strlen(lpsResource);
+	if (len != 0) {
+		if (lpsResource[len - 1] == '/') {
+			// There is only a path
+			strcpy(lpsPath, lpsResource);
+		} else {
+			// Find extension
+			i = len - 1;
+			while ((i >= 0) && (lpsResource[i] != '.')) i--;
+			extptr = i;
+			while ((i >= 0) && (lpsResource[i] != '/')) i--;
+			if (i > 0) {
+				// There is at least one directory in the path (besides root directory)
+				fileptr = i + 1;
+				strncat(lpsPath, lpsResource, fileptr);
+			} else
+				fileptr = 1;
+			
+			// Get filename and possibly extension
+			if (extptr != 0) {
+				strncat(lpsFilename, &lpsResource[fileptr], extptr - fileptr);
+				// Get extension
+				strncat(lpsExtension, &lpsResource[extptr + 1], len - extptr - 1);
+			} else
+				strncat(lpsFilename, &lpsResource[fileptr], len - fileptr);
+		}
+	}
+}
+
+// Process HTTP request
+VOID CHttpClient::ProcessRequest()
+{
+    CHAR sStr[255];
+	CHAR sHost[255];
+    CHAR sResource[255];
+    CHAR sParams[255];
+
+    // Which method?
+    switch (Parser.nMethodNo) {
+		case hmGET: {
+			SplitUri(Parser.sUri, sHost, sResource, sParams);
+			
+			// Default resource?
+			if (strlen(sResource) == 0) {
+				CIterator<LPSTR> *i = pConfiguration->GetDefaultResources()->CreateIterator();
+
+				// FIXME: All default resources should be tried
+				// Iterate through all strings
+				//for (i->First(); !i->IsDone(); i->Next())
+				i->First();
+				if (!i->IsDone()) {
+					strcat(sResource, i->CurrentItem());
+					delete i;
+				} else {
+					// File not found
+					Report("404 Not Found", HttpMsg404);
+					break;
+				}
+			}
+			strcpy(sStr, pConfiguration->GetHttpBase());
+	        strcat(sStr, sResource);
+			SendFile(sStr);
+			break;
+		}
+		default: {
+			// Method is not implemented
+			Report("501 Not Implemented", HttpMsg501);
+		}
+	}
+}
+
+// Send a file to socket
+VOID CHttpClient::SendFile(LPSTR lpsFilename)
+{
+    CHAR str[255];
+    CHAR str2[32];
+    union BigNum {
+      //        unsigned __int64 Big;
+      unsigned long long Big;
+        struct {
+            DWORD Low;
+            DWORD High; 
+        } u;
+    } nTotalBytes;
+	DWORD nBytesToRead;
+	DWORD nBytesRead;
+	BOOL bStatus;
+
+	// Try to open file
+    hFile = CreateFileA(lpsFilename,
+        GENERIC_READ,               // Open for reading 
+        FILE_SHARE_READ,            // Share for reading 
+        NULL,                       // No security 
+        OPEN_EXISTING,              // Existing file only 
+        FILE_ATTRIBUTE_NORMAL,      // Normal file 
+        NULL);                      // No attr. template 
+    if (hFile == INVALID_HANDLE_VALUE) { 
+        // File not found
+        Report("404 Not Found", HttpMsg404);
+        return; 
+    }
+    // Get file size
+    nTotalBytes.u.Low = GetFileSize(hFile, &nTotalBytes.u.High);
+    if ((nTotalBytes.u.Low == 0xFFFFFFFF) && ((GetLastError()) != NO_ERROR)) {
+        // Internal server error
+		Report("500 Internal Server Error", HttpMsg500);
+		// Close file
+		CloseHandle(hFile);
+        return;
+    }
+
+	// Determine buffer size
+	if (nTotalBytes.Big < 65536)
+		nBufferSize = 1024;
+	else
+		nBufferSize = 32768;
+	// Allocate memory on heap
+	lpsBuffer = (PCHAR) malloc(nBufferSize);
+
+	if (lpsBuffer == NULL) {
+		// Internal server error
+		Report("500 Internal Server Error", HttpMsg500);
+		// Close file
+		CloseHandle(hFile);
+		return;
+	}
+
+	SendText("HTTP/1.1 200 OK");
+    SendText("Server: ROSHTTPD");
+    SendText("MIME-version: 1.0");
+    SendText("Content-Type: text/plain");
+    SendText("Accept-Ranges: bytes");
+    strcpy(str, "Content-Length: ");
+    _itoa(nTotalBytes.u.Low, str2, 10);
+    strcat(str, str2);
+    SendText(str);
+    SendText("");
+	// Read and transmit file
+	nTotalRead = 0;
+	nFileSize = nTotalBytes.Big;
+	bStop = FALSE;
+
+	fd_set wfds;
+	FD_ZERO(&wfds);
+	FD_SET(Socket, &wfds);
+	do {
+		MessageLoop();
+
+		if (nTotalRead + nBufferSize < nFileSize)
+			nBytesToRead = nBufferSize;
+		else nBytesToRead = nFileSize - nTotalRead;
+
+		bStatus = ReadFile(hFile, lpsBuffer, nBytesToRead, &nBytesRead, NULL);
+		if (bStatus) {
+			select(0, NULL, &wfds, NULL, NULL);
+			bStatus = (Transmit(lpsBuffer, nBytesRead) == (INT)nBytesRead);
+			nTotalRead += nBytesRead;
+		}
+    } while ((!bStop) && (bStatus) && (nTotalRead < nFileSize));
+
+	if (bStatus)
+		SendText("");
+	else
+		// We can't send an error message here as we are in the process of sending a file.
+		// We have to terminate the connection instead
+		Close();
+	
+	// Free allocated memory
+	free(lpsBuffer);
+
+	// Close file
+    CloseHandle(hFile);
+}
+
+// Report something to client
+VOID CHttpClient::Report(LPSTR lpsCode, LPSTR lpsStr)
+{
+    CHAR sTmp[128];
+    CHAR sTmp2[16];
+	
+    strcpy(sTmp, "HTTP/1.1 ");
+    strcat(sTmp, lpsCode);
+    SendText(sTmp);
+    SendText("Server: ROSHTTPD");
+    SendText("MIME-version: 1.0");
+    SendText("Content-Type: text/html");
+    SendText("Accept-Ranges: bytes");
+    strcpy(sTmp, "Content-Length: ");
+    if (lpsStr != NULL) {
+        _itoa(strlen(lpsStr), sTmp2, 10);
+        strcat(sTmp,  sTmp2);
+    } else
+        strcat(sTmp, "0");
+    SendText(sTmp);
+    SendText("");
+    if (lpsStr != NULL)
+        SendText(lpsStr);
+    SendText("");
+}
+
+// OnRead event handler
+VOID CHttpClient::OnRead()
+{
+	LONG nCount;
+
+	nCount = Receive((LPSTR) &Parser.sBuffer[Parser.nHead],
+        sizeof(Parser.sBuffer) - Parser.nHead);
+
+    Parser.nHead += nCount;
+	if (Parser.nHead >= sizeof(Parser.sBuffer))
+		Parser.nHead = 0;
+
+    if (Parser.Complete()) {
+		ProcessRequest();
+    }
+
+	if (Parser.bUnknownMethod) {
+		// Method Not Allowed
+		Report("405 Method Not Allowed", HttpMsg405);
+		// Terminate connection
+		Close();
+	}
+}
+/*
+// OnWrite event handler
+VOID CHttpClient::OnWrite()
+{
+	DWORD nBytesToRead;
+	DWORD nBytesRead;
+
+	OutputDebugString(_T("Can write\n"));
+
+	if (bSendingFile) {
+		if (nTotalRead + nBufferSize < nFileSize)
+			nBytesToRead = nBufferSize;
+		else nBytesToRead = nFileSize - nTotalRead;
+
+		bError = ReadFile(hFile, Buffer, nBytesToRead, &nBytesRead, NULL);
+		if (!bError) {
+			Transmit(Buffer, nBytesRead);
+			nTotalRead += nBytesRead;
+		}
+	}
+}
+*/
+// OnClose event handler
+VOID CHttpClient::OnClose()
+{
+	// Stop sending file if we are doing that now
+	bStop = TRUE;
+}
+
+
+// ************************ CHttpClientThread ************************
+
+// Constructor with client socket as starter value
+CHttpClientThread::CHttpClientThread(LPCServerClientSocket lpSocket)
+{
+	ClientSocket = lpSocket;
+}
+
+// Execute client thread code
+VOID CHttpClientThread::Execute()
+{
+    MSG Msg;
+
+	while (!Terminated()) {
+		((  CHttpClient *) ClientSocket)->MessageLoop();
+        if (PeekMessage(&Msg, 0, 0, 0, PM_REMOVE) != 0) {
+            switch (Msg.message) {
+                case HTTPD_START: {
+					// TODO: Start thread
+                    break;
+                }
+                case HTTPD_STOP: {
+					// TODO: Stop thread
+                    break;
+                }
+                default:
+                    DispatchMessage(&Msg);
+            }
+
+        }
+    }
+
+	if (ClientSocket != NULL) {
+		delete ClientSocket;
+		ClientSocket = NULL;
+	}
+}
+
+
+// *************************** CHttpDaemon ***************************
+
+// Default constructor
+CHttpDaemon::CHttpDaemon()
+{
+    State = hsStopped;
+	Start();
+}
+
+// Default destructor
+CHttpDaemon::~CHttpDaemon()
+{
+	if (State==hsRunning)
+		Stop();
+}
+
+// Return daemon state
+HTTPdState CHttpDaemon::GetState() const
+{
+	return State;
+}
+
+// Start HTTP daemon
+BOOL CHttpDaemon::Start()
+{
+	assert(State==hsStopped);
+
+	SetPort(pConfiguration->GetPort());
+
+	Open();
+	
+	State = hsRunning;
+	
+    return TRUE;
+}
+
+// Stop HTTP daemon
+BOOL CHttpDaemon::Stop()
+{
+	assert(State==hsRunning);
+
+	Close();
+
+	State = hsStopped;
+
+    return TRUE;
+}
+
+// OnGetSocket event handler
+LPCServerClientSocket CHttpDaemon::OnGetSocket(LPCServerSocket lpServerSocket)
+{
+	return new CHttpClient(lpServerSocket);
+}
+
+// OnGetThread event handler
+LPCServerClientThread CHttpDaemon::OnGetThread(LPCServerClientSocket lpSocket)
+{
+	return new CHttpClientThread(lpSocket);
+}
+
+// OnAccept event handler
+VOID CHttpDaemon::OnAccept(LPCServerClientThread lpThread)
+{
+}
+
+
+// ************************ CHttpDaemonThread ************************
+
+// Execute daemon thread code
+VOID CHttpDaemonThread::Execute()
+{
+	MSG Msg;
+	
+	try {
+		Daemon = NULL;
+		Daemon = new CHttpDaemon;
+
+		while (!Terminated()) {
+			Daemon->MessageLoop();
+			if (PeekMessage(&Msg, 0, 0, 0, PM_REMOVE) != 0) {
+	            switch (Msg.message) {
+		            case HTTPD_START: {
+			            if (Daemon->GetState() == hsStopped)
+				            Daemon->Start();
+					    break;
+					}
+					case HTTPD_STOP: {
+	                    if (Daemon->GetState() == hsRunning)
+							Daemon->Stop();
+						break;
+					}
+					case HTTPD_SUSPEND: {
+						if (Daemon->GetState() == hsRunning){}
+							// FIXME: Suspend service
+						break;
+					}
+					case HTTPD_RESUME: {
+						if (Daemon->GetState() != hsSuspended){}
+							// FIXME: Resume service
+						break;
+					}
+					default:
+                        DispatchMessage(&Msg);
+				}
+			}
+	    }
+		delete Daemon;
+	} catch (ESocket e) {
+		ReportErrorStr(e.what());
+	} catch	(bad_alloc e) {
+		ReportErrorStr(TS("Insufficient resources."));
+	}
+}

reactos/apps/utils/net/roshttpd/include/config.h

@@ -0,0 +1,49 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        include/config.h
+ */
+#ifndef __CONFIG_H
+#define __CONFIG_H
+
+#include <list.h>
+#include <httpd.h>
+
+// General constants
+#define APP_DESCRIPTION _T("ReactOS HTTP Daemon")
+
+// Default configuration
+#define dcfgDescription     _T("Default configuration")
+#define dcfgMainBase        _T("C:\\roshttpd\\")
+#define dcfgHttpBase        "C:\\roshttpd\\HttpBase\\"
+#define dcfgDefaultResource "index.html"
+#define dcfgDefaultPort     80
+
+class CConfig {
+public:
+	CConfig();
+	~CConfig();
+	VOID Default();
+	VOID Clear();
+	BOOL Load();
+	BOOL Save();
+	LPWSTR GetMainBase();
+	VOID SetMainBase(LPWSTR lpwsMainBase);
+	LPSTR GetHttpBase();
+	VOID SetHttpBase(LPSTR lpsHttpBase);
+	CList<LPSTR>* GetDefaultResources();
+    USHORT GetPort();
+    VOID SetPort(USHORT wPort);
+private:
+	VOID Reset();
+	LPWSTR MainBase;
+	LPSTR HttpBase;
+	CList<LPSTR> DefaultResources;
+    USHORT Port;
+};
+typedef CConfig* LPCConfig;
+
+extern LPCConfig pConfiguration;
+extern LPCHttpDaemonThread pDaemonThread;
+
+#endif /* __CONFIG_H */

reactos/apps/utils/net/roshttpd/include/debug.h

@@ -0,0 +1,17 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        include/debug.h
+ */
+#ifndef __DEBUG_H
+#define __DEBUG_H
+
+#include <stdio.h>
+
+#ifdef DBG
+#define DPRINT(x...)    printf(x)
+#else
+#define DPRINT(x...)
+#endif
+
+#endif /* __DEBUG_H */

reactos/apps/utils/net/roshttpd/include/error.h

@@ -0,0 +1,15 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        include/error.h
+ */
+#ifndef __ERROR_H
+#define __ERROR_H
+
+#include <windows.h>
+
+#define TS(x) (LPTSTR)_T(x)
+
+void ReportErrorStr(LPTSTR lpsText);
+
+#endif /* __ERROR_H */