new rev

svn path=/branches/prep0016/; revision=1287

reactos/.cvsignore

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

reactos/CREDITS

@@ -0,0 +1,14 @@
+In no particular order
+
+Rex Jolliff (rex@lvcablemodem.com)
+Boudewijn Dekker (ariadne@xs4all.nl)
+Eric Kohl (ekohl@abo.rhein-zeitung.de)
+Emanuele Aliberti (ea@iol.it)
+David Welch (welch@cwcom.net)
+Iwan Fatahi (i_fatahi@hotmail.com)
+Robert Bergkvist (fragdance@hotmail.com)
+Victor Kirhenshtein (sauros@iname.com)
+Jason Filby (jasonfilby@yahoo.com)
+Brian Palmer (brianp@sginet.com)
+Phillip Susi (phreak@iag.net)
+Paolo Pantaleo (paolopan@freemail.it)

reactos/ChangeLog

@@ -0,0 +1,16 @@
+27/5/00:       Fixed issue with closing non-existent or already closed handle
+
+26/1/99:       ZwCreateProcess now maps ntdll rather than the user-mode code
+
+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)
+
+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
+               

reactos/INSTALL

@@ -0,0 +1,31 @@
+1. Build environment
+
+To build the system you need either mingw32 installed on Windows or a
+mingw32 cross compiler running on unix.
+
+2. Building
+
+To build from Windows run make. To build from unix, edit rules.mak and change 
+the PREFIX variable to the correct value for your cross-compiler, then run 
+'make'.
+
+3. Installation
+
+Installation isn't yet automated, sorry. The system can only be installed on
+the first partition which must be formatted for DOS. Set up a directory
+structure like the following
+
+make directories C:\reactos,C:\reactos\system32,C:\reactos\system32\drivers
+
+Copy apps/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 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'.

reactos/Makefile

@@ -0,0 +1,301 @@
+#
+# Global makefile
+#
+
+#
+# Select your host
+#
+#HOST = mingw32-linux
+#HOST = djgpp-msdos
+#HOST = mingw32-windows
+
+include rules.mak
+
+#
+# Required to run the system
+#
+COMPONENTS = iface_native iface_additional ntoskrnl
+DLLS = ntdll kernel32 crtdll advapi32 fmifs gdi32
+#DLLS = mingw32
+SUBSYS = smss win32k csrss
+
+#
+# Select the server(s) you want to build
+#
+SERVERS = win32
+# SERVERS = posix linux os2
+
+#
+# Select the loader(s) you want to build
+#
+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)
+
+APPS = args hello shell test cat bench apc shm lpc thread event file gditest \
+       pteb consume
+       
+#       objdir
+
+all: buildno $(COMPONENTS) $(DLLS) $(SUBSYS) $(LOADERS) $(KERNEL_SERVICES) $(APPS)
+
+.PHONY: all
+
+clean: buildno_clean $(COMPONENTS:%=%_clean) $(DLLS:%=%_clean) $(LOADERS:%=%_clean) \
+       $(KERNEL_SERVICES:%=%_clean) $(SUBSYS:%=%_clean) $(APPS:%=%_clean)
+       
+.PHONY: clean
+
+floppy: make_floppy_dirs autoexec_floppy $(COMPONENTS:%=%_floppy) \
+        $(DLLS:%=%_floppy) $(LOADERS:%=%_floppy) \
+        $(KERNEL_SERVICES:%=%_floppy) $(SUBSYS:%=%_floppy) \
+        $(APPS:%=%_floppy)
+
+dist: clean_dist_dir make_dist_dirs $(COMPONENTS:%=%_dist) $(DLLS:%=%_dist) \
+      $(LOADERS:%=%_dist) $(KERNEL_SERVICES:%=%_dist) $(SUBSYS:%=%_dist) \
+      $(APPS:%=%_dist)
+
+#
+# Build number generator
+#
+buildno: include/reactos/version.h
+	make -C apps/buildno
+
+buildno_clean:
+	make -C apps/buildno clean
+
+buildno_floppy:
+
+buildno_dist:
+
+.PHONY: buildno buildno_clean buildno_floppy buildno_dist
+
+#
+# Applications
+#
+$(APPS): %:
+	make -C 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)
+
+#
+# Interfaces
+#
+iface_native:
+	make -C iface/native
+
+iface_native_clean:
+	make -C iface/native clean
+
+iface_native_floppy:
+
+iface_native_dist:
+
+iface_additional:
+	make -C iface/addsys
+
+iface_additional_clean:
+	make -C iface/addsys clean
+
+iface_additional_floppy:
+
+iface_additional_dist:
+
+.PHONY: iface_native iface_native_clean iface_native_floppy \
+        iface_native_dist \
+	iface_additional iface_additional_clean iface_additional_floppy \
+        iface_additional_dist \
+
+#
+# Device driver rules
+#
+$(DEVICE_DRIVERS): %:
+	make -C services/dd/$*
+
+$(DEVICE_DRIVERS:%=%_clean): %_clean:
+	make -C services/dd/$* clean
+
+$(DEVICE_DRIVERS:%=%_floppy): %_floppy:
+	make -C services/dd/$* floppy
+
+$(DEVICE_DRIVERS:%=%_dist): %_dist:
+	make -C services/dd/$* dist
+
+.PHONY: $(DEVICE_DRIVERS) $(DEVICE_DRIVERS:%=%_clean) \
+        $(DEVICE_DRIVERS:%=%_floppy) $(DEVICE_DRIVERS:%=%_dist)
+
+$(FS_DRIVERS): %:
+	make -C services/fs/$*
+
+$(FS_DRIVERS:%=%_clean): %_clean:
+	make -C services/fs/$* clean
+
+$(FS_DRIVERS:%=%_floppy): %_floppy:
+	make -C services/fs/$* floppy
+
+$(FS_DRIVERS:%=%_dist): %_dist:
+	make -C services/fs/$* dist
+
+.PHONY: $(FS_DRIVERS) $(FS_DRIVERS:%=%_clean) $(FS_DRIVERS:%=%_floppy) \
+        $(FS_DRIVERS:%=%_dist)
+
+#
+# Kernel loaders
+#
+
+$(LOADERS): %:
+	make -C loaders/$*
+
+$(LOADERS:%=%_clean): %_clean:
+	make -C loaders/$* clean
+
+$(LOADERS:%=%_floppy): %_floppy:
+	make -C loaders/$* floppy
+
+$(LOADERS:%=%_dist): %_dist:
+	make -C loaders/$* dist
+
+.PHONY: $(LOADERS) $(LOADERS:%=%_clean) $(LOADERS:%=%_floppy) \
+        $(LOADERS:%=%_dist)
+
+#
+# Required system components
+#
+
+ntoskrnl:
+	make -C ntoskrnl
+
+ntoskrnl_clean:
+	make -C ntoskrnl clean
+
+ntoskrnl_floppy:
+	make -C ntoskrnl floppy
+
+ntoskrnl_dist:
+	make -C ntoskrnl dist
+
+.PHONY: ntoskrnl ntoskrnl_clean ntoskrnl_floppy ntoskrnl_dist
+
+#
+# Required DLLs
+#
+
+$(DLLS): %:
+	make -C lib/$*
+
+$(DLLS:%=%_clean): %_clean:
+	make -C lib/$* clean
+
+$(DLLS:%=%_floppy): %_floppy:
+	make -C lib/$* floppy
+
+$(DLLS:%=%_dist): %_dist:
+	make -C lib/$* dist
+
+.PHONY: $(DLLS) $(DLLS:%=%_clean) $(DLLS:%=%_floppy) $(DLLS:%=%_dist)
+
+#
+# Kernel Subsystems
+#
+$(SUBSYS): %:
+	make -C subsys/$*
+
+$(SUBSYS:%=%_clean): %_clean:
+	make -C subsys/$* clean
+
+$(SUBSYS:%=%_floppy): %_floppy:
+	make -C subsys/$* floppy
+
+$(SUBSYS:%=%_dist): %_dist:
+	make -C subsys/$* dist
+
+.PHONY: $(SUBSYS) $(SUBSYS:%=%_clean) $(SUBSYS:%=%_floppy) \
+        $(SUBSYS:%=%_dist)
+
+#
+# Make an install floppy
+#
+
+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_floppy_dirs
+
+autoexec_floppy: $(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
+#
+
+clean_dist_dir:
+ifeq ($(DOSCLI),yes)
+	- $(RM) $(DIST_DIR)\dlls\*.dll
+	- $(RM) $(DIST_DIR)\apps\*.exe
+	- $(RM) $(DIST_DIR)\drivers\*.sys
+	- $(RM) $(DIST_DIR)\subsys\*.exe
+	- $(RMDIR) $(DIST_DIR)\dlls
+	- $(RMDIR) $(DIST_DIR)\apps
+	- $(RMDIR) $(DIST_DIR)\drivers
+	- $(RMDIR) $(DIST_DIR)\subsys
+	- $(RMDIR) $(DIST_DIR)
+else
+	$(RM) -r $(DIST_DIR)
+endif
+
+make_dist_dirs:
+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
+
+.PHONY: clean_dist_dir make_dist_dirs
+
+#
+#
+#
+etags:
+	find . -name "*.[ch]" -print | etags --language=c -

reactos/NEWS

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

reactos/README

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

reactos/apps/common/crt0.c

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

reactos/apps/tests/apc/apc.c

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

reactos/apps/tests/apc/makefile

@@ -0,0 +1,44 @@
+#
+#
+#
+OBJECTS= ../common/crt0.o apc.o
+PROGS= apc.exe
+
+BASE_CFLAGS = -I../../include
+LIBS = ../../lib/crtdll/crtdll.a ../../lib/kernel32/kernel32.a \
+       ../../lib/ntdll/ntdll.a
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) apc.o
+	- $(RM) apc.exe
+	- $(RM) apc.sym
+
+.phony: clean
+
+floppy: $(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
+	$(NM) --numeric-sort apc.exe > apc.sym
+
+include ../../rules.mak

reactos/apps/tests/args/args.c

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

reactos/apps/tests/args/makefile

@@ -0,0 +1,42 @@
+#
+#
+#
+OBJECTS= args.o
+PROGS= args.exe
+
+BASE_CFLAGS = -I../../include
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) args.o
+	- $(RM) args.exe
+	- $(RM) args.sym
+
+.phony: clean
+
+floppy: $(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
+	$(NM) --numeric-sort args.exe > args.sym
+
+include ../../rules.mak

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

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

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

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

reactos/apps/tests/bench/makefile

@@ -0,0 +1,41 @@
+#
+#
+#
+PROGS = bench-thread
+
+all: $(PROGS:%=%.exe)
+
+.phony: all
+
+clean: $(PROGS:%=%_clean)
+
+$(PROGS:%=%_clean): %_clean:
+	- $(RM) $*.o
+	- $(RM) $*.exe
+	- $(RM) $*.sym
+
+.phony: clean
+
+floppy: # $(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
+	$(NM) --numeric-sort bench-thread.exe > bench-thread.sym
+
+include ../../rules.mak

reactos/apps/tests/consume/Makefile

@@ -0,0 +1,39 @@
+#
+#
+#
+OBJECTS = consume.o
+PROGS = consume.exe
+LIBS = 
+CLEAN_FILES = consume.o consume.exe
+
+all: consume.exe
+
+clean: $(CLEAN_FILES:%=%_clean)
+
+$(CLEAN_FILES:%=%_clean): %_clean:
+	- $(RM) $*
+
+.phony: clean $(CLEAN_FILES:%=%_clean)
+
+floppy: $(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
+
+include ../../rules.mak

reactos/apps/tests/consume/consume.c

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

reactos/apps/tests/event/event.c

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

reactos/apps/tests/event/makefile

@@ -0,0 +1,41 @@
+#
+#
+#
+PROGS = event
+
+all: $(PROGS:%=%.exe)
+
+.phony: all
+
+clean: $(PROGS:%=%_clean)
+
+$(PROGS:%=%_clean): %_clean:
+	- $(RM) $*.o
+	- $(RM) $*.exe
+	- $(RM) $*.sym
+
+.phony: clean
+
+floppy: # $(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
+	$(NM) --numeric-sort event.exe > event.sym
+
+include ../../rules.mak

reactos/apps/tests/file/Makefile

@@ -0,0 +1,51 @@
+#
+#
+#
+OBJECTS= file.o
+PROGS= file.exe
+
+BASE_CFLAGS = -I../../include
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) file.o
+	- $(RM) file.exe
+	- $(RM) file.sym
+
+.phony: clean
+
+floppy: $(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
+	$(NM) --numeric-sort file.exe > file.sym
+
+include ../../rules.mak
+
+
+
+
+
+
+
+
+

reactos/apps/tests/file/file.c

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

reactos/apps/tests/file/file.cpp

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

reactos/apps/tests/gditest/gditest.c

@@ -0,0 +1,56 @@
+/*
+ * gditest
+ */
+
+#include <windows.h>
+
+
+int main (void)
+{
+	HDC	Desktop, MyDC;
+	HPEN	RedPen, GreenPen;
+	HBITMAP	MyBitmap;
+	DWORD shit;
+
+	GdiDllInitialize (NULL, DLL_PROCESS_ATTACH, NULL);
+
+	// Set up a DC called Desktop that accesses DISPLAY
+	Desktop = CreateDCA("DISPLAY", NULL, NULL, NULL);
+	if (Desktop == NULL)
+		return 1;
+
+	// Create a red pen and select it into the DC
+	RedPen = CreatePen(PS_SOLID, 8, 0x0000ff);
+	SelectObject(Desktop, RedPen);
+
+	// Draw a shap on the DC
+	MoveToEx(Desktop, 50, 50, NULL);
+	LineTo(Desktop, 200, 60);
+	LineTo(Desktop, 200, 300);
+	LineTo(Desktop, 50, 50);
+
+	// 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);
+
+	// 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 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);
+
+	BitBlt(Desktop, 400, 100, 151, 251, MyDC, 0, 0, SRCCOPY);
+
+	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;
+}
+

reactos/apps/tests/gditest/makefile

@@ -0,0 +1,46 @@
+#
+#
+#
+PROGS = gditest
+
+OBJECTS= ../common/crt0.o
+LIBS= ../../lib/kernel32/kernel32.a ../../lib/gdi32/gdi32.a
+#LIBS= ../../lib/kernel32/kernel32.a ../../lib/crtdll/crtdll.a
+BASE_CFLAGS = -I../../include
+
+all: $(PROGS:%=%.exe)
+
+.phony: all
+
+$(PROGS:%=%_clean): %_clean:
+	- $(RM) $*.o
+	- $(RM) $*.exe
+	- $(RM) $*.sym
+
+clean: $(PROGS:%=%_clean)
+
+.phony: clean
+
+floppy: $(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
+	$(NM) --numeric-sort gditest.exe > gditest.sym
+
+include ../../rules.mak

reactos/apps/tests/hello/hello.c

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

reactos/apps/tests/hello/makefile

@@ -0,0 +1,39 @@
+#
+#
+#
+OBJECTS = hello.o
+PROGS = hello.exe
+LIBS = 
+CLEAN_FILES = hello.o hello.exe
+
+all: hello.exe
+
+clean: $(CLEAN_FILES:%=%_clean)
+
+$(CLEAN_FILES:%=%_clean): %_clean:
+	- $(RM) $*
+
+.phony: clean $(CLEAN_FILES:%=%_clean)
+
+floppy: $(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
+
+include ../../rules.mak

reactos/apps/tests/lpc/conport.c

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

reactos/apps/tests/lpc/creport.c

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

reactos/apps/tests/lpc/dumpinfo.c

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

reactos/apps/tests/lpc/dumpinfo.h

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

reactos/apps/tests/lpc/lpcclt.c

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

reactos/apps/tests/lpc/lpcsrv.c

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

reactos/apps/tests/lpc/makefile

@@ -0,0 +1,54 @@
+#
+#
+#
+SRV_OBJECTS= ../common/crt0.o lpcsrv.o
+CLT_OBJECTS= ../common/crt0.o lpcclt.o
+
+PROGS= lpcsrv.exe lpcclt.exe
+
+BASE_CFLAGS = -I../../include
+LIBS = ../../lib/crtdll/crtdll.a ../../lib/kernel32/kernel32.a \
+       ../../lib/ntdll/ntdll.a
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) lpcsrv.o
+	- $(RM) lpcsrv.exe
+	- $(RM) lpcsrv.sym
+	- $(RM) lpcclt.o
+	- $(RM) lpcclt.exe
+	- $(RM) lpcsrv.sym
+	
+.phony: clean
+
+floppy: $(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
+	$(NM) --numeric-sort lpcsrv.exe > lpcsrv.sym
+
+lpcclt.exe: $(CLT_OBJECTS) $(LIBS)
+	$(LD) $(CLT_OBJECTS) $(LIBS) -o lpcclt.exe
+	$(NM) --numeric-sort lpcclt.exe > lpcclt.sym
+
+
+include ../../rules.mak

reactos/apps/tests/nptest/npclient.c

@@ -0,0 +1,99 @@
+#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; 
+} 

reactos/apps/tests/nptest/npserver.c

@@ -0,0 +1,90 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <windows.h>
+
+VOID InstanceThread (LPVOID);
+
+VOID GetAnswerToRequest (LPTSTR, LPTSTR, LPDWORD)
+{
+}
+
+int xx = 0;
+
+DWORD main (VOID)
+{
+   BOOL fConnected;
+   DWORD dwThreadId;
+   HANDLE hPipe, hThread;
+   LPTSTR lpszPipename = "\\\\.\\pipe\\mynamedpipe";
+
+   for (;;)
+     {
+	hPipe = CreateNamedPipe (lpszPipename,	
+				 PIPE_ACCESS_DUPLEX,	
+				 PIPE_TYPE_MESSAGE |	
+				 PIPE_READMODE_MESSAGE |	
+				 PIPE_WAIT,	
+				 PIPE_UNLIMITED_INSTANCES,	
+				 BUFSIZE,	
+				 BUFSIZE,	
+				 PIPE_TIMEOUT,	
+				 NULL);	
+	if (hPipe == INVALID_HANDLE_VALUE)
+	  MyErrExit ("CreatePipe");
+	
+	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);
+	  }
+     }
+   return 1;
+}
+
+VOID InstanceThread (LPVOID lpvParam)
+{
+   CHAR chRequest[BUFSIZE];
+   CHAR chReply[BUFSIZE];
+   DWORD cbBytesRead, cbReplyBytes, cbWritten;
+   BOOL fSuccess;
+   HANDLE hPipe;
+   
+   hPipe = (HANDLE) lpvParam;
+   while (1)     
+     {      
+	fSuccess = ReadFile (hPipe,	
+			     chRequest,	
+			     BUFSIZE,	
+			     &cbBytesRead,	
+			     NULL);	
+	if (!fSuccess || cbBytesRead == 0)
+	  break;
+	GetAnswerToRequest (chRequest, chReply, &cbReplyBytes);
+	
+	fSuccess = WriteFile (hPipe,	
+			      chReply,	
+			      cbReplyBytes,	
+			      &cbWritten,	
+			      NULL);	
+      if (!fSuccess || cbReplyBytes != cbWritten)
+	break;
+    }
+
+   FlushFileBuffers(hPipe); 
+   DisconnectNamedPipe (hPipe);
+   CloseHandle (hPipe);
+}

reactos/apps/tests/pteb/Makefile

@@ -0,0 +1,39 @@
+#
+#
+#
+OBJECTS = pteb.o
+PROGS = pteb.exe
+LIBS = 
+CLEAN_FILES = pteb.o pteb.exe
+
+all: pteb.exe
+
+clean: $(CLEAN_FILES:%=%_clean)
+
+$(CLEAN_FILES:%=%_clean): %_clean:
+	- $(RM) $*
+
+.phony: clean $(CLEAN_FILES:%=%_clean)
+
+floppy: $(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
+
+include ../../rules.mak

reactos/apps/tests/pteb/pteb.c

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

reactos/apps/tests/shm/makefile

@@ -0,0 +1,51 @@
+#
+#
+#
+SRV_OBJECTS= ../common/crt0.o shmsrv.o
+CLT_OBJECTS= ../common/crt0.o shmclt.o
+
+PROGS= shmsrv.exe shmclt.exe
+
+BASE_CFLAGS = -I../../include
+LIBS = ../../lib/crtdll/crtdll.a ../../lib/kernel32/kernel32.a \
+       ../../lib/ntdll/ntdll.a
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) *.o
+	- $(RM) *.exe
+	- $(RM) *.sym
+
+.phony: clean
+
+floppy: $(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
+	$(NM) --numeric-sort shmsrv.exe > shmsrv.sym
+
+shmclt.exe: $(CLT_OBJECTS) $(LIBS)
+	$(LD) $(CLT_OBJECTS) $(LIBS) -o shmclt.exe
+	$(NM) --numeric-sort shmsrv.exe > shmclt.sym
+
+
+include ../../rules.mak

reactos/apps/tests/shm/shmclt.c

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

reactos/apps/tests/shm/shmsrv.c

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

reactos/apps/tests/test_old/bug2.c

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

reactos/apps/tests/test_old/bug3.c

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

reactos/apps/tests/test_old/makefile

@@ -0,0 +1,74 @@
+#
+#
+#
+PROGS= test-stdio tst-printf tstdiomisc bug2 bug3 \
+       temptest test-fseek test_rdwr
+
+all: $(PROGS:%=%.exe)
+
+.phony: all
+
+$(PROGS:%=%_clean): %_clean:
+	- $(RM) $*.o
+	- $(RM) $*.exe
+	- $(RM) $*.sym
+
+clean: $(PROGS:%=%_clean)
+
+.phony: clean
+
+floppy: # $(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
+	$(NM) --numeric-sort bug2.exe > bug2.sym
+
+bug3.exe: bug3.c
+	$(CC) bug3.c -lkernel32 -o bug3.exe
+	$(NM) --numeric-sort bug3.exe > bug3.sym
+
+temptest.exe: temptest.c
+	$(CC) temptest.c -lkernel32 -o temptest.exe
+	$(NM) --numeric-sort temptest.exe > temptest.sym
+
+test-fseek.exe: test-fseek.c
+	$(CC) test-fseek.c -lkernel32 -o test-fseek.exe
+	$(NM) --numeric-sort test-fseek.exe > test-fseek.sym
+
+test-fwrite.exe: test-fwrite.c
+	$(CC) test-fwrite.c -lkernel32 -o test-fwrite.exe
+	$(NM) --numeric-sort test-fwrite.exe > test-fwrite.sym
+
+test_rdwr.exe: test_rdwr.c
+	$(CC) test_rdwr.c -lkernel32 -o test_rdwr.exe
+	$(NM) --numeric-sort test_rdwr.exe > test_rdwr.sym
+
+test-stdio.exe: test-stdio.c
+	$(CC) test-stdio.c -lkernel32 -o test-stdio.exe
+	$(NM) --numeric-sort test-stdio.exe > test-stdio.sym
+
+tst-printf.exe: tst-printf.c
+	$(CC) tst-printf.c -lkernel32 -o tst-printf.exe
+	$(NM) --numeric-sort tst-printf.exe > tst-printf.sym
+
+tstdiomisc.exe: tstdiomisc.c
+	$(CC) tstdiomisc.c -lkernel32 -o tstdiomisc.exe
+	$(NM) --numeric-sort tstdiomisc.exe > tstdiomisc.sym
+
+include ../../rules.mak

reactos/apps/tests/test_old/temptest.c

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

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

@@ -0,0 +1,85 @@
+/* Copyright (C) 1991, 1992, 1996, 1997 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include <stdio.h>
+
+#define TESTFILE "/tmp/test.dat"
+
+int
+main (void)
+{
+  FILE *fp;
+  int i, j;
+
+  puts ("\nFile seek test");
+  fp = fopen (TESTFILE, "w");
+  if (fp == NULL)
+    {
+      perror (TESTFILE);
+      return 1;
+    }
+
+  for (i = 0; i < 256; i++)
+    putc (i, fp);
+  if (freopen (TESTFILE, "r", fp) != fp)
+    {
+      perror ("Cannot open file for reading");
+      return 1;
+    }
+
+  for (i = 1; i <= 255; i++)
+    {
+      printf ("%3d\n", i);
+      fseek (fp, (long) -i, SEEK_END);
+      if ((j = getc (fp)) != 256 - i)
+	{
+	  printf ("SEEK_END failed %d\n", j);
+	  break;
+	}
+      if (fseek (fp, (long) i, SEEK_SET))
+	{
+	  puts ("Cannot SEEK_SET");
+	  break;
+	}
+      if ((j = getc (fp)) != i)
+	{
+	  printf ("SEEK_SET failed %d\n", j);
+	  break;
+	}
+      if (fseek (fp, (long) i, SEEK_SET))
+	{
+	  puts ("Cannot SEEK_SET");
+	  break;
+	}
+      if (fseek (fp, (long) (i >= 128 ? -128 : 128), SEEK_CUR))
+	{
+	  puts ("Cannot SEEK_CUR");
+	  break;
+	}
+      if ((j = getc (fp)) != (i >= 128 ? i - 128 : i + 128))
+	{
+	  printf ("SEEK_CUR failed %d\n", j);
+	  break;
+	}
+    }
+  fclose (fp);
+  remove (TESTFILE);
+
+  puts ((i > 255) ? "Test succeeded." : "Test FAILED!");
+  return (i > 255) ? 0 : 1;
+}

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

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

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

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

reactos/apps/tests/test_old/test_rdwr.c

@@ -0,0 +1,129 @@
+/* Copyright (C) 1991, 1992, 1996, 1997, 1998 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+int
+main (int argc, char **argv)
+{
+  static const char hello[] = "Hello, world.\n";
+  static const char replace[] = "Hewwo, world.\n";
+  static const size_t replace_from = 2, replace_to = 4;
+  char filename[FILENAME_MAX];
+  char *name = strrchr (*argv, '/');
+  char buf[BUFSIZ];
+  FILE *f;
+  int lose = 0;
+
+  if (name != NULL)
+    ++name;
+  else
+    name = *argv;
+
+  (void) sprintf (filename, "/tmp/%s.test", name);
+
+  f = fopen (filename, "w+");
+  if (f == NULL)
+    {
+      perror (filename);
+      exit (1);
+    }
+
+  (void) fputs (hello, f);
+  rewind (f);
+  (void) fgets (buf, sizeof (buf), f);
+  rewind (f);
+  (void) fputs (buf, f);
+  rewind (f);
+  {
+    size_t i;
+    for (i = 0; i < replace_from; ++i)
+      {
+	int c = getc (f);
+	if (c == EOF)
+	  {
+	    printf ("EOF at %Zu.\n", i);
+	    lose = 1;
+	    break;
+	  }
+	else if (c != hello[i])
+	  {
+	    printf ("Got '%c' instead of '%c' at %Zu.\n",
+		    (unsigned char) c, hello[i], i);
+	    lose = 1;
+	    break;
+	  }
+      }
+  }
+
+  {
+    long int where = ftell (f);
+    if (where == (long int) replace_from)
+      {
+	register size_t i;
+	for (i = replace_from; i < replace_to; ++i)
+	  if (putc(replace[i], f) == EOF)
+	    {
+	      printf ("putc('%c') got %s at %Zu.\n",
+		      replace[i], strerror (errno), i);
+	      lose = 1;
+	      break;
+	    }
+      }
+    else if (where == -1L)
+      {
+	printf ("ftell got %s (should be at %Zu).\n",
+		strerror (errno), replace_from);
+	lose = 1;
+      }
+    else
+      {
+	printf ("ftell returns %lu; should be %Zu.\n", where, replace_from);
+	lose = 1;
+      }
+  }
+
+  if (!lose)
+    {
+      rewind (f);
+      if (fgets (buf, sizeof (buf), f) == NULL)
+	{
+	  printf ("fgets got %s.\n", strerror(errno));
+	  lose = 1;
+	}
+      else if (strcmp (buf, replace))
+	{
+	  printf ("Read \"%s\" instead of \"%s\".\n", buf, replace);
+	  lose = 1;
+	}
+    }
+
+  if (lose)
+    printf ("Test FAILED!  Losing file is \"%s\".\n", filename);
+  else
+    {
+      (void) remove (filename);
+      puts ("Test succeeded.");
+    }
+
+  exit (lose ? EXIT_FAILURE : EXIT_SUCCESS);
+}

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

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

reactos/apps/tests/test_old/tstdiomisc.c

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

reactos/apps/tests/thread/makefile

@@ -0,0 +1,41 @@
+#
+#
+#
+PROGS = thread
+
+all: $(PROGS:%=%.exe)
+
+.phony: all
+
+clean: $(PROGS:%=%_clean)
+
+$(PROGS:%=%_clean): %_clean:
+	- $(RM) $*.o
+	- $(RM) $*.exe
+	- $(RM) $*.sym
+
+.phony: clean
+
+floppy: # $(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
+	$(NM) --numeric-sort thread.exe > thread.sym
+
+include ../../rules.mak

reactos/apps/tests/thread/thread.c

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

reactos/apps/utils/buildno/.cvsignore

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

reactos/apps/utils/buildno/Makefile

@@ -0,0 +1,26 @@
+# $Id: Makefile,v 1.6 2000/06/29 23:35:09 dwelch Exp $
+#
+
+BASE_CFLAGS = 
+TARGETNAME=buildno
+CLEAN_FILES= $(TARGETNAME).o $(TARGETNAME)$(EXE_POSTFIX) $(TARGETNAME).sym
+
+all: $(TARGETNAME)$(EXE_POSTFIX)
+	$(EXE_PREFIX)$(TARGETNAME)$(EXE_POSTFIX)
+
+
+$(TARGETNAME)$(EXE_POSTFIX): $(TARGETNAME).c ../../include/reactos/version.h
+	$(NATIVE_CC) -o $(TARGETNAME)$(EXE_POSTFIX) $(TARGETNAME).c
+
+
+
+clean:
+	- $(RM) $(TARGETNAME).o
+	- $(RM) $(TARGETNAME).sym
+	- $(RM) $(TARGETNAME)$(EXE_POSTFIX)
+
+.phony: clean 
+
+include ../../rules.mak
+
+# EOF

reactos/apps/utils/buildno/buildno.c

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

reactos/apps/utils/cat/cat.c

@@ -0,0 +1,26 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(int argc, char* argv[])
+{
+   int i;
+   FILE* in;
+   char ch;
+   
+   for (i=1; i<argc; i++)
+     {
+	in = fopen(argv[i],"r");
+	if (in == NULL)
+	  {
+	     printf("Failed to open file %s\n", argv[i]);
+	     return(0);
+	  }
+	
+	while ((ch = fgetc(in)) != EOF)
+	  {
+	     putchar(ch);
+	  }
+	fclose(in);
+     }
+   return 0;
+}

reactos/apps/utils/cat/makefile

@@ -0,0 +1,42 @@
+#
+#
+#
+OBJECTS= cat.o
+PROGS= cat.exe
+
+all: cat.exe
+
+.phony: all
+
+clean:
+	- $(RM) cat.o
+	- $(RM) cat.exe
+	- $(RM) cat.sym
+
+.phony: clean
+
+floppy: $(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
+
+cat.exe: $(OBJECTS) $(LIBS)
+	$(CC) $(OBJECTS) -o cat.exe
+	$(NM) --numeric-sort cat.exe > cat.sym
+
+include ../../rules.mak

reactos/apps/utils/objdir/makefile

@@ -0,0 +1,50 @@
+#
+#
+#
+OBJECTS= ../common/crt0.o objdir.o
+
+
+PROGS= objdir.exe 
+
+BASE_CFLAGS = -I../../include
+LIB_BASE=../../lib
+LIBS = \
+	$(LIB_BASE)/ntdll/ntdll.a \
+	$(LIB_BASE)/kernel32/kernel32.a \
+	$(LIB_BASE)/crtdll/crtdll.a
+
+all: $(PROGS)
+
+.phony: all
+
+clean:
+	- $(RM) objdir.o
+	- $(RM) objdir.exe
+	- $(RM) objdir.sym
+
+.phony: clean
+
+floppy: $(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
+
+objdir.exe: $(OBJECTS) $(LIBS)
+	$(LD) $(OBJECTS) $(LIBS) -o objdir.exe
+	$(NM) --numeric-sort objdir.exe > objdir.sym
+
+
+include ../../rules.mak

reactos/apps/utils/objdir/objdir.c

@@ -0,0 +1,163 @@
+/* $Id: objdir.c,v 1.3 2000/05/13 14:56:46 ea Exp $
+ *
+ * DESCRIPTION: Object Manager Simple Explorer
+ * PROGRAMMER:  David Welch
+ * REVISIONS
+ * 	2000-04-30 (ea)
+ * 		Added directory enumeration.
+ * 		(tested under nt4sp4/x86)
+ */
+
+#include <ddk/ntddk.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MAX_TYPE 64
+
+typedef
+struct _DIRECTORY_ENTRY_HEADER
+{
+	UNICODE_STRING	Name;
+	UNICODE_STRING	Type;
+	
+} DIRECTORY_ENTRY_HEADER;
+
+struct
+{
+	DIRECTORY_ENTRY_HEADER	Entry;
+	WCHAR			Buffer [MAX_PATH + MAX_TYPE + 2];
+	
+} DirectoryEntry;
+
+
+static
+const char *
+STDCALL
+StatusToName (NTSTATUS Status)
+{
+	static char RawValue [16];
+	
+	switch (Status)
+	{
+		case STATUS_OBJECT_NAME_INVALID:
+			return "STATUS_OBJECT_NAME_INVALID";
+		case STATUS_OBJECT_NAME_NOT_FOUND:
+			return "STATUS_OBJECT_NAME_NOT_FOUND";
+		case STATUS_PATH_SYNTAX_BAD:
+			return "STATUS_PATH_SYNTAX_BAD";
+	}
+	wsprintf (RawValue, "0x%08x", Status);
+	return (const char *) RawValue;
+}
+
+
+int main(int argc, char* argv[])
+{
+	UNICODE_STRING		DirectoryNameW;
+	ANSI_STRING		DirectoryNameA;
+	OBJECT_ATTRIBUTES	ObjectAttributes;
+	NTSTATUS		Status;
+	HANDLE			DirectoryHandle;
+	ULONG			BytesReturned = 0;
+	ULONG			EntryCount = 0;
+
+	/*
+	 * Check user arguments.
+	 */
+	if (2 != argc)
+	{
+		fprintf (
+			stderr,
+			"Usage: %s directory\n\n"
+			"  directory   a directory name in the system namespace\n",
+			argv [0]
+			);
+		return EXIT_FAILURE;
+	}
+	/*
+	 * Prepare parameters for next call.
+	 */
+	RtlInitAnsiString (
+		& DirectoryNameA,
+		argv [1]
+		);
+	RtlAnsiStringToUnicodeString (
+		& DirectoryNameW,
+		& DirectoryNameA,
+		TRUE
+		);
+	InitializeObjectAttributes (
+		& ObjectAttributes,
+		& DirectoryNameW,
+		0,
+		NULL,
+		NULL
+		);
+	/*
+	 * Try opening the directory the
+	 * user requested.
+	 */
+	Status = NtOpenDirectoryObject (
+			& DirectoryHandle,
+			DIRECTORY_QUERY,
+			& ObjectAttributes
+			);
+	if (!NT_SUCCESS(Status))
+	{
+		printf (
+			"Failed to open directory object (Status: %s)\n",
+			StatusToName (Status)
+			);
+		return EXIT_FAILURE;
+	}
+	/*
+	 * Enumerate each item in the directory.
+	 */
+	Status = NtQueryDirectoryObject (
+			DirectoryHandle,
+			& DirectoryEntry,
+			sizeof DirectoryEntry,
+			TRUE,
+			TRUE,
+			& BytesReturned,
+			& EntryCount
+			);
+	if (!NT_SUCCESS(Status))
+	{
+		printf (
+			"Failed to query directory object (Status: %s)\n",
+			StatusToName (Status)
+			);
+		NtClose (DirectoryHandle);
+		return EXIT_FAILURE;
+	}
+	wprintf (L"%d entries:\n", EntryCount);
+	while (STATUS_NO_MORE_ENTRIES != Status)
+	{
+		wprintf (
+			L"%-16s %s\n",
+			DirectoryEntry.Entry.Type.Buffer,
+			DirectoryEntry.Entry.Name.Buffer
+			);
+		Status = NtQueryDirectoryObject (
+				DirectoryHandle,
+				& DirectoryEntry,
+				sizeof DirectoryEntry,
+				TRUE,
+				FALSE,
+				& BytesReturned,
+				& EntryCount
+				);
+	}
+	/*
+	 * Free any resource.
+	 */
+	NtClose (DirectoryHandle);
+
+	return EXIT_SUCCESS;
+}
+
+
+/* EOF */

reactos/apps/utils/shell/makefile

@@ -0,0 +1,42 @@
+#
+#
+#
+OBJECTS= ../common/crt0.o shell.o
+PROGS= shell.exe
+LIBS= ../../lib/kernel32/kernel32.a ../../lib/ntdll/ntdll.a
+CLEAN_FILES= shell.o shell.exe shell.sym
+
+BASE_CFLAGS = -I../../include
+
+all: shell.exe
+
+clean: $(CLEAN_FILES:%=%_clean)
+
+$(CLEAN_FILES:%=%_clean): %_clean:
+	- $(RM) $*
+
+.phony: clean $(CLEAN_FILES:%=%_clean)
+
+floppy: $(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
+
+shell.exe: $(OBJECTS) $(LIBS)
+	$(CC) -specs=../../specs $(OBJECTS) $(LIBS) -lgcc -o shell.exe
+	$(NM) --numeric-sort shell.exe > shell.sym
+
+include ../../rules.mak

reactos/apps/utils/shell/shell.c

@@ -0,0 +1,494 @@
+/* $Id: shell.c,v 1.41 2000/07/11 04:40:00 phreak Exp $
+ *
+ * PROJECT    : ReactOS Operating System
+ * DESCRIPTION: ReactOS' Native Shell
+ * LICENSE    : See top level directory
+ *
+ */
+#define NTOS_MODE_USER
+#include <ntos.h>
+#include <windows.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+
+HANDLE InputHandle, OutputHandle;
+BOOL   bCanExit = TRUE;
+
+
+void debug_printf(char* fmt, ...)
+{
+   va_list args;
+   char buffer[255];
+
+   va_start(args,fmt);
+   vsprintf(buffer,fmt,args);
+   va_end(args);
+   WriteConsoleA(OutputHandle, buffer, strlen(buffer), NULL, NULL);
+}
+
+
+void ExecuteVer(void)
+{
+    debug_printf(
+	"Reactos Simple Shell\n(compiled on %s, at %s)\n",
+	__DATE__,
+	__TIME__
+	);
+}
+
+void ExecuteCd(char* cmdline)
+{
+   if (!SetCurrentDirectoryA(cmdline))
+     {
+	debug_printf("Invalid directory\n");
+     }
+}
+
+void ExecuteMd (char *cmdline)
+{
+   if (!CreateDirectoryA (cmdline, NULL))
+     {
+	debug_printf("Create Directory failed!\n");
+     }
+}
+
+void ExecuteDir(char* cmdline)
+{
+   HANDLE shandle;
+   WIN32_FIND_DATA FindData;
+   int nFile=0, nRep=0;
+   FILETIME fTime;
+   SYSTEMTIME sTime;
+
+   shandle = FindFirstFile("*",&FindData);
+
+   if (shandle==INVALID_HANDLE_VALUE)
+     {
+	debug_printf("File not found\n\n");
+	return;
+     }
+   do
+     {
+	debug_printf("%-15.15s",FindData.cAlternateFileName);
+	if(FindData.dwFileAttributes &FILE_ATTRIBUTE_DIRECTORY)
+	  debug_printf("<DIR>       "),nRep++;
+	else
+	  debug_printf(" %10d ",FindData.nFileSizeLow),nFile++;
+
+        FileTimeToLocalFileTime(&FindData.ftLastWriteTime ,&fTime);
+        FileTimeToSystemTime(&fTime, &sTime);
+        debug_printf("%02d/%02d/%04d %02d:%02d:%02d "
+            ,sTime.wMonth,sTime.wDay,sTime.wYear
+            ,sTime.wHour,sTime.wMinute,sTime.wSecond);
+
+	debug_printf("%s\n",FindData.cFileName);
+     } while(FindNextFile(shandle,&FindData));
+   debug_printf("\n    %d files\n    %d directories\n\n",nFile,nRep);
+   FindClose(shandle);
+}
+
+
+void ExecuteReboot(char* cmdline)
+{
+   NtShutdownSystem (ShutdownReboot);
+}
+
+
+void ExecuteType(char* cmdline)
+{
+   HANDLE FileHandle;
+   char c;
+   DWORD Result;
+
+   FileHandle = CreateFile(cmdline,
+			   FILE_GENERIC_READ,
+			   0,
+			   NULL,
+			   OPEN_EXISTING,
+			   0,
+			   NULL);
+   if (FileHandle == NULL)
+     {
+	debug_printf("Unknown file\n");
+	return;
+     }
+   while (ReadFile(FileHandle,
+		   &c,
+		   1,
+		   &Result,
+		   NULL))
+     {
+	debug_printf("%c",c);
+	c = 0;
+     }
+   CloseHandle(FileHandle);
+}
+
+int ExecuteProcess(char* name, char* cmdline, BOOL detached)
+{
+   PROCESS_INFORMATION	ProcessInformation;
+   STARTUPINFO		StartupInfo;
+   BOOL			ret;
+   CHAR			fullname[MAX_PATH];
+   PCHAR		p;
+   
+   /* append '.exe' if needed */
+   strcpy (fullname, name);
+   p = strrchr (fullname, '.');
+   if ((p == NULL) ||
+       (_stricmp (p, ".exe") != 0))
+     {
+	strcat (fullname, ".exe");
+     }
+
+   memset(&StartupInfo, 0, sizeof(StartupInfo));
+   StartupInfo.cb = sizeof (STARTUPINFO);
+   StartupInfo.lpTitle = name;
+   // set mode to default for new process
+   SetConsoleMode( GetStdHandle( STD_INPUT_HANDLE ), ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT | ENABLE_ECHO_INPUT );
+   ret = CreateProcessA(fullname,
+			cmdline,
+			NULL,
+			NULL,
+			FALSE,
+			((TRUE == detached)
+			 ? CREATE_NEW_CONSOLE
+			: 0
+			),
+			NULL,
+			NULL,
+			& StartupInfo,
+			& ProcessInformation
+			);
+   if (TRUE == detached)
+     {
+	if (ret)
+	  {
+	     debug_printf("%s detached:\n"
+			  "\thProcess = %08X\n"
+			  "\thThread  = %08X\n"
+			  "\tPID      = %d\n"
+			  "\tTID      = %d\n\n",
+			  name,
+			  ProcessInformation.hProcess,
+			  ProcessInformation.hThread,
+			  ProcessInformation.dwProcessId,
+			  ProcessInformation.dwThreadId);
+	     CloseHandle(ProcessInformation.hProcess);
+	     CloseHandle(ProcessInformation.hThread);
+	  }
+	else
+	  {
+	     debug_printf("Could not detach %s\n", name);
+	  }
+     }
+   else
+     {
+	if (ret)
+	  {
+//	     	debug_printf("ProcessInformation.hThread %x\n",
+//			     ProcessInformation.hThread);
+	     WaitForSingleObject(ProcessInformation.hProcess, INFINITE);
+	     CloseHandle(ProcessInformation.hProcess);
+//	     debug_printf("Thandle %x\n", ProcessInformation.hThread);
+	     CloseHandle(ProcessInformation.hThread);
+	  }
+     }
+   // reset mode
+   SetConsoleMode( GetStdHandle( STD_INPUT_HANDLE ), 0 );
+   return(ret);
+}
+
+void ExecuteStart(char* CommandLine)
+{
+	   char *ImageName = CommandLine;
+
+	   for (	;
+			(	(*CommandLine)
+				&& (*CommandLine != ' ')
+				&& (*CommandLine != '\t')
+				);
+			CommandLine++
+		);
+	   *CommandLine++ = '\0';
+	   while (	(*CommandLine)
+			&& (	(*CommandLine == ' ')
+				|| (*CommandLine == '\t')
+				)
+			);
+	   ExecuteProcess(
+		ImageName,
+		CommandLine,
+		TRUE
+		);
+	   return;
+}
+
+void
+ExecuteKill(char * lpPid)
+{
+	HANDLE	hProcess;
+	DWORD	dwProcessId;
+
+	dwProcessId = (DWORD) atol(lpPid);
+	debug_printf("dwProcessId %d\n",dwProcessId);
+	hProcess = OpenProcess(
+			PROCESS_TERMINATE,
+			FALSE,
+			dwProcessId
+			);
+	if (NULL == hProcess)
+	{
+		debug_printf(
+			"Could not open the process with PID = %d\n",
+			dwProcessId
+			);
+		return;
+	}
+	if (FALSE == TerminateProcess(
+			hProcess,
+			0
+			)
+	) {
+		debug_printf(
+			"Could not terminate the process with PID = %d\n",
+			dwProcessId
+			);
+	}
+	CloseHandle(hProcess);
+	return;
+}
+
+void ExecuteHelp (void * dummy)
+{
+	debug_printf (
+		"A:\t\t\tCurrent drive is A:\n"
+		"C:\t\t\tCurrent drive is C:\n"
+		"cd [directory]\t\tChange current directory\n"
+		"dir [directory]\t\tList directory\n"
+		"exit\t\t\tTerminate the shell\n"
+		"help\t\t\tPrint this help message\n"
+		"kill [pid]\t\tKill process which PID is pid\n"
+		"md [directory]\t\tCreate a new directory\n"
+		"reboot\t\t\tRestart the system\n"
+		"start [program.exe]\tDetach program.exe\n"
+		"type [file]\t\tPrint the file on console\n"
+		"validate\t\tValidate the process' heap\n"
+		"ver\t\t\tPrint version information\n"
+		"[program.exe]\t\tStart synchronously program.exe\n\n"
+		);
+}
+
+void ExecuteCommand(char* line)
+{
+   char* cmd;
+   char* tail;
+
+   if (isalpha(line[0]) && line[1] == ':' && line[2] == 0)
+     {
+	char szPath[MAX_PATH];
+	char szVar[5];
+
+	/* save curent directory in environment variable */
+	GetCurrentDirectory (MAX_PATH, szPath);
+
+	strcpy (szVar, "=A:");
+	szVar[1] = toupper (szPath[0]);
+	SetEnvironmentVariable (szVar, szPath);
+
+	/* check for current directory of new drive */
+	strcpy (szVar, "=A:");
+	szVar[1] = toupper (line[0]);
+	if (GetEnvironmentVariable (szVar, szPath, MAX_PATH) == 0)
+	  {
+	     /* no environment variable found */
+	     strcpy (szPath, "A:\\");
+	     szPath[0] = toupper (line[0]);
+	  }
+
+	/* set new current directory */
+	SetCurrentDirectory (szPath);
+	GetCurrentDirectory (MAX_PATH, szPath);
+	if (szPath[0] != (char)toupper (line[0]))
+	     debug_printf("Invalid drive\n");
+
+	return;
+     }
+
+   tail = line;
+   while ((*tail)!=' ' && (*tail)!=0)
+     {
+	tail++;	
+     }
+   if ((*tail)==' ')
+     {
+	*tail = 0;
+	tail++;
+     }
+   cmd = line;
+
+
+   if (cmd==NULL || *cmd == '\0' )
+     {
+	return;
+     }
+   if (strcmp(cmd,"cd")==0)
+     {
+	ExecuteCd(tail);
+	return;
+     }
+   if (strcmp(cmd,"dir")==0)
+     {
+	ExecuteDir(tail);
+	return;
+     }
+   if (strcmp(cmd,"kill")==0)
+     {
+	ExecuteKill(tail);
+	return;
+     }
+   if (strcmp(cmd,"md")==0)
+     {
+	ExecuteMd(tail);
+	return;
+     }
+   if (strcmp(cmd,"reboot")==0)
+     {
+	ExecuteReboot(tail);
+	return;
+     }
+   if (strcmp(cmd,"type")==0)
+     {
+	ExecuteType(tail);
+	return;
+     }
+   if (strcmp(cmd,"ver")==0)
+     {
+	ExecuteVer();
+	return;
+     }
+   if (strcmp(cmd,"validate")==0)
+     {
+	debug_printf("Validating heap...");
+	if (HeapValidate(GetProcessHeap(),0,NULL))
+	  {
+	     debug_printf("succeeded\n");
+	  }
+	else
+	  {
+	     debug_printf("failed\n");
+	  }
+	return;
+     }
+   if (strcmp(cmd,"start") == 0)
+     {
+	ExecuteStart(tail);
+	return;
+     }
+   if ((strcmp(cmd,"help") * strcmp(cmd,"?")) == 0)
+     {
+	ExecuteHelp(tail);
+	return;
+     }
+   if (strcmp(cmd,"exit")==0)
+     {
+        if (bCanExit == TRUE)
+          {
+             ExitProcess(0);
+          }
+	return;
+     }
+   if (ExecuteProcess(cmd,tail,FALSE))
+     {
+	return;
+     }
+   debug_printf("Unknown command '%s'\n", cmd);
+}
+
+void ReadLine(char* line)
+{
+   DWORD Result;
+   UCHAR CurrentDir[255];
+   int   length = 0;
+   int c;
+
+   GetCurrentDirectoryA(255,CurrentDir);
+   debug_printf("%s>", CurrentDir);
+
+   do
+     {
+       if ( !ReadConsoleA(InputHandle, line, 255 - length, &Result, NULL) )
+	  {
+	     debug_printf("Failed to read from console\n");
+	     for(;;);
+	  }
+       for( c = 0; c < Result; c++ )
+	 switch ( line[c] )
+	   {
+	   case '\b':
+	     if (length > 0)
+	       {
+		 debug_printf("\b \b");
+		 memmove( &line[c-1], &line[c], Result - c - 1 );
+		 c-=2;
+		 length--;
+		 Result--;
+	       }
+	     break;
+	   case '\n': 
+	     line[c] = 0;
+	     debug_printf( "\n" );
+	     return;
+	   default:
+	      debug_printf( "%c", line[c] );
+              length++;
+          }
+       line += Result;
+     } while (1);
+}
+
+void ParseCommandLine (void)
+{
+   char *pszCommandLine;
+
+   pszCommandLine = GetCommandLineA ();
+   _strupr (pszCommandLine);
+   if (strstr (pszCommandLine, "/P") != NULL)
+     {
+        debug_printf("Permanent shell\n");
+        bCanExit = FALSE;
+     }
+}
+
+int main(void)
+{
+   static char line[255];
+   
+   AllocConsole();
+   // clear line buffered mode
+   if( !SetConsoleMode( GetStdHandle( STD_INPUT_HANDLE ), 0 ) )
+     {
+       debug_printf( "Error: could not set console mode, error: %d\n", GetLastError() );
+       return GetLastError();
+     }
+   InputHandle = GetStdHandle(STD_INPUT_HANDLE);
+   OutputHandle = GetStdHandle(STD_OUTPUT_HANDLE);
+
+   debug_printf("Shell Starting...\n");
+
+   ParseCommandLine ();
+
+   for(;;)
+     {
+	ReadLine(line);
+	ExecuteCommand(line);
+     }
+
+   return 0;
+}
+
+/* EOF */

reactos/boot.bat

@@ -1 +1 @@
-loaders\dos\loadros kernel\kimage.bin %1 %2 %3 %4
+loadros ntoskrnl.exe ide.sys vfatfs.sys

reactos/bootflop.bat

@@ -0,0 +1,32 @@
+@ECHO OFF
+
+:
+: copy files to HD...
+:
+COPY /Y A:\DRIVERS\*.SYS C:\reactos\system32\drivers > NUL:
+COPY /Y A:\DLLS\*.DLL C:\reactos\system32 > NUL:
+COPY /Y A:\APPS\*.EXE C:\reactos\system32 > NUL:
+COPY /Y A:\SUBSYS\*.EXE C:\reactos\system32 > NUL:
+COPY /Y A:\SUBSYS\*.DLL C:\reactos\system32 > NUL:
+:
+: present a menu to the booter...
+:
+: ECHO 1) IDE,VFatFSD
+: ECHO 2) No Drivers
+: CHOICE /C:123 /T:1,3 "Select kernel boot config"
+: IF ERRORLEVEL 2 GOTO :L2
+
+:L1
+CLS
+LOADROS NTOSKRNL.EXE DRIVERS\IDE.SYS DRIVERS\VFATFSD.SYS
+GOTO :END
+
+:L2
+CLS
+LOADROS NTOSKRNL.EXE
+GOTO :END
+
+:END
+EXIT
+
+

reactos/doc/DIRS

@@ -1,20 +1,22 @@
-DIRECTORIES
-
-system           : compiled versions of the various system components and
-                   libraries
-mkernel          : microkernel source
-mkernel/hal      : hardware abstraction layer source
-mkernel/mm       : memory managment subsystem source
-mkernel/iomgr    : IO manager subsystem source
-include          : win32 headers
-include/internal : kernel private header files
-include/ntdll    : system library private header files
-include/kernel32 : system library private header files
-include/user32   : user interface private header files
-include/gdi32    : graphics interface private header files
-include/ddk      : header files for modules
-lib/ntdll        : NT dll source
-lib/kernel32     : kernel32 source
-doc              : documentation
-loaders/dos      : DOS based loader
-loaders/boot     : boot loader
+DIRECTORIES
+
+system           : compiled versions of the various system components and
+                   libraries
+ntoskrnl         : kernel source
+ntoskrnl/hal     : hardware abstraction layer source
+ntoskrnl/mm      : memory managment subsystem source
+ntoskrnl/io      : IO manager subsystem source
+ntoskrnl/ke      : kernel source
+include          : win32 headers
+include/internal : kernel private header files
+include/ntdll    : system library private header files
+include/kernel32 : system library private header files
+include/ddk      : header files for modules
+lib/ntdll        : NT dll source
+lib/kernel32     : kernel32 source
+doc              : documentation
+loaders/dos      : DOS based loader
+loaders/boot     : boot loader
+services         : various services (device drivers, filesystems etc)
+services/dd      : device drivers
+services/fs      : file systems

reactos/doc/HACKING

@@ -0,0 +1,130 @@
+* Introduction
+
+Having successfully built ReactOS and been amazed by what it does, you're
+now desperate to fill in some of the omissions, this document shows you how.
+
+* Prerequisites
+
+A working knowledge of NT driver development is useful for understanding the
+kernel and some of its abstractions. The NT4 ddk is available for free
+download from http://www.microsoft.com/hwdev/. The Windows 98 and Windows
+2000 DDKs are also available but the NT4 one is the most useful. See
+Legal Stuff below however.
+
+There are a number of books on NT driver development, I would recommend
+'Windows NT Device Driver Development' (http://www.osr.com/book/) since OSR
+seem to know their stuff. There is only one book on NT filesystem
+development 'Windows NT File System Internals'. Please don't buy any of
+these books unless you need to, and can afford it. 
+
+These mailing lists and newsgroups are useful for NT internals related 
+questions,
+           ntfsd@atria.com, ntdev@atria.com 
+	                    (subscribe by email to majordomo@atria.com)
+	   comp.os.????
+	   microsoft.public.????
+	   
+* Style
+
+There is no coding style used for ReactOS, however the following guidelines
+make things easier
+
+     Include information at the top of a module about its purpose, contact
+     information for its programmer and any useful notes. 
+     
+     Include a comment by each non-trival function describing its arguments,
+     purpose and any other notes.
+     
+     Update the documentation in this directory
+     
+These guidelines are an ideal, no one manages to implement them all the
+time, straightforward working code is probably just as good.
+
+* Debugging
+
+Debugging kernel-mode code is tricky, these are some snippets
+
+    DbgPrint writes a message to the console using a printf style format
+    string. The DPRINT macro (defined in internal/debug.h) expands to
+    DbgPrint unless NDEBUG is defined, this is useful for having copious
+    output from a module only when a problem is being debugging. DPRINT
+    also prefixes the message with the file and line number to make it
+    easier to see where output is coming from. DbgPrint can be used at any
+    point including in interrupt handlers.
+    
+    There are options in ntoskrnl/kd/kdebug.c for copying DbgPrint output
+    to a serial device or bochs logging port (parallel support should also
+    be added). This can be useful if a lot of output is being generated.
+    
+    It should be possible to include support for debugging the kernel with
+    gdb over a serial line. Bochs (a shareware CPU emulator) is also useful
+    for debugging the kernel, I wrote some patches to allow capture of console
+    output from within bochs to file and for debugging a kernel running
+    under bochs with gdb. Contact me (welch@cwcom.net) if you're are 
+    interested.
+    
+    If CPU reports an exception not handled by the kernel (any page fault
+    not part of virtual memory support or any other exception) the kernel 
+    will display output like this and halt
+    
+            General Protection Fault Exception: 13(0)
+	    CS:EIP  xxxxxxxx:xxxxxxx
+	    DS xxxx ES xxxx FS xxxx GS xxxxx
+	    EAX: xxxx EBX: xxxx
+	    ....
+	    EDI: xxxx EFLAGS: xxxx ESP: xxxx
+	    cr2: xxxx
+	    Stack: xxxx xxxx xxxx ...
+	           ....
+	    Frames: xxxx xxxx xxxx ...
+	           ....
+		   
+    The fault type will usually be either 'General Protection' or
+    'Page Fault', see your Intel manual for the more exotic types. The
+    'EIP' number is the address of the faulting instruction. If the 'CS'
+    number is 0x20 then the exception occured in kernel mode, if it is 0x11
+    then the exception occurred in user mode. 'cr2' is the address that the
+    faulting instruction was trying to access, if the exception was a page 
+    fault. The number printed after 'Frames' are any addresses on the stack
+    that look like function addresses. 
+    
+    
+    If the kernel detects a serious problem that it will bug check, displaying
+    output like this
+    
+           Bug detected (code x, param x x x x)
+	   Frames: xxx xxxx xxxx
+	           ....
+		   
+    Again the numbers printed after 'Frames' are any addresses on the stack
+    that look like function addresss. Usually the kernel will also print a
+    message describing the problem in more detail, the bug check code isn't
+    very useful at the moment. 
+    
+* Contacts
+
+    There is a mailing list for kernel development,
+    
+            ros-kernel@reactos.com
+	    
+    The main developers use a cvs account to coordinate changes, ask 
+    rex (rex@lvcablemodem.com) for an account if you are going to be adding
+    a lot of code. Smaller patches can go to the mailing list or to the
+    relevant developer (usually the comment at the top of a module will have
+    an email address). Regular snapshots are made available for download,
+    see the mailing list for announcements.
+    
+* Legal stuff
+
+    The ReactOS project is GPL'ed, please make sure any code submitted is
+    compatible with this. 
+    
+    The NT4 ddk license agreement allows its usage for developing nt drivers
+    only. Legally therefore it can not be used to develop ReactOS, neither the
+    documentation or the sample code. I'm not a lawyer, but I doubt the
+    effiacy of 'shrinkwrap licenses' particularly on freely downloadable 
+    software. The only precendent I know of, in a Scottish court, didn't
+    upload this type of license.
+    
+    Also the 'fair use' section of copyright law allows the 'quoting' of small
+    sections from copyrighted documents, e.g. Windows API or DDK documentation

reactos/doc/INDEX

@@ -0,0 +1,6 @@
+HACKING:   Some notes for adding code to ReactOS
+DIRS:      Explanation of directory layout
+INTERNALS: Some notes on kernel internals
+TODO:      Bugs and omissions, big and little things that need to be done
+NOTES:     Unsorted material, some of it is redundant
+BUGLIST:   Known bugs, please update when you find one

reactos/doc/INTERNALS

@@ -0,0 +1,43 @@
+A collection of articles on kernel internals, please add to this
+
+------------------------------------------------------------------------------
+IRQ level
+------------------------------------------------------------------------------
+
+IRQ level (IRQL) is a per-processor state in ReactOS used to coordinate
+execution between ISRs and between threads. There are several levels
+
+       PASSIVE_LEVEL, APC_LEVEL: The normal level for user mode and most
+       kernel mode code. At the moment APC_LEVEL is unused.
+       
+       DISPATCH_LEVEL: At this level all irqs are still allowed but thread
+       rescheduling on the current processor is disabled. This is used by
+       the spinlock synchronization primitive to implement its uniprocessor
+       semantics (multiprocessor is more complex). It is also used for some
+       other forms of synchronization, DPCs for example. Many APIs are
+       unavailable at this IRQL, usually those that might have to wait. It
+       is recommended that you don't spend too much time at this IRQL 
+       otherwise system responsiveness will be reduced.
+       
+       > DISPATCH_LEVEL: Each irq is assigned a priority (which will be 
+       greater than DISPATCH_LEVEL). At an irq's priority level that irq,
+       lower priority irqs and thread rescheduling are disabled. Higher
+       priority irqs can still run. Very few APIs are available at IRQLs
+       greater than DISPATCH_LEVEL.
+       
+       HIGH_LEVEL: All irqs are disabled.
+
+-------------------------------------------------------------------------------
+DPCs
+-------------------------------------------------------------------------------
+
+It is a design goal not to spend too much time in ISRs, for this reason
+ISRs should postpone most processing till it can run at a lower IRQL. The
+mechanism for this is a Delayed Procedure Call (DPC). When a DPC object is
+created, it is associated with a function. The DPC object can then be inserted
+in the DPC queue from an ISR. If the IRQL on return from the ISR is less than
+DISPATCH_LEVEL the DPC queue will be drained, otherwise this will happen when
+the IRQL level drops below DISPATCH_LEVEL or the processor becomes idle. When
+the DPC queue is drained each DPC object is removed and the associated
+function is called at DISPATCH_LEVEL. A DPC object can only be inserted once,
+further insertions before it is removed will have no effect. 

reactos/doc/apc

@@ -0,0 +1,36 @@
+  APC
+  
+   Asynchronous procedure call
+   
+   An APC is a Kernel-defined control object representing a procedure
+   that is called asynchronously. APCs are thread-context dependent; that
+   is, they are queued to a particular thread for execution.
+   
+   There are three different kinds of APCs in NT:
+   
+   User APCs are used by certain asynchronous NT system services to allow
+   user-mode applications or protected subsystems to synchronize the
+   execution of a thread with the completion of an operation or the
+   occurrence of an event such as a timers expiration. User APCs are, by
+   default, disabled. That is, they are queued to the user-mode thread,
+   but they are not executed except at well-defined points in the
+   program. Specifically, they can only be executed when an application
+   or protected subsystem has called a wait service and has enabled
+   alerts to occur, or if it has called the test-alert service.
+   
+   Kernel APCs are normal kernel-mode APCs. They are much like a normal
+   user APC except that they are executable by default. That is, they are
+   enabled except when the thread is already executing a Kernel APC.
+   (Note that a special Kernel APC always preempts these.)
+   
+   Special Kernel APCs cannot be blocked except by running at a raised
+   IRQL. They are executed at APC_LEVEL IRQL (see IDT), in kernel mode.
+   These types of APCs are used by the system to force a thread to
+   execute a procedure in the threads context. An example of this is I/O
+   completion: the I/O Manager needs to get back into the context of the
+   original requestor of the I/O operation so that it can copy buffers,
+   and so forth. In order to do this, the I/O Manager must be able to
+   access the virtual address space of the thread/process, and the most
+   efficient way to complete the operation is to be in the calling
+   threads context.
+   

reactos/doc/api.txt

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

reactos/doc/buglist

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

reactos/doc/faq.txt

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

reactos/doc/internal/mm.txt

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

reactos/doc/internal/readme.txt

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

reactos/doc/irq.txt

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

reactos/doc/irql.txt

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

reactos/doc/modules.txt

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

reactos/doc/notes

@@ -0,0 +1,696 @@
+*** This file contains messages I've culled off the net as well
+as previous discussions all of which have useful info on fixes
+that need to be added to ReactOS. messages are between five
+dashes on a line by themselves.  If you implement the fix
+reffered to in a message, feel free to delete it from the file.
+Rex ***
+-----
+Subject: [ros-kernel] Inside the Boot Process
+Date: Mon, 22 Mar 1999 22:05:47 +0100
+From: Emanuele Aliberti <ea@iol.it>
+
+For those working on the boot loader: in WinNt Magazine november 1998
+issue (http://www.winntmag.com/) there is a detailed description, by
+Mark Russinovich, of the r<>le the MBR, NTLDR, boot.ini, ntdetect.com...
+play in the boot process ("Inside the Boot Process, Part 1").
+-----
+Yes with DPCs, KeDrainDpcQueue should go to HIGH_LEVEL because 
+it needs to synchronize with KeInsertDpcQueue. Also the idle thread 
+should run at DISPATCH_LEVEL and regularly drain the dpc queue, that 
+way if an irq happens and the dpc can't be executed immediately it 
+will be executed as soon as the processor is idle rather than 
+waiting for the next timer tick
+-----
+About the console driver, I think it might be quite useful to have a simple 
+way for apps to print to the screen for debugging. But when the kernel is more 
+stable, console handling should be moved to user level because console printing 
+needs to know about windows and so on which can only be done at user level.
+-----
+Subject: Re: IMSAMP-how to avoid rebooting?
+Date: 9 Nov 1998 00:40:32 -0000
+From: Charles Bryant <n51190709.ch@chch.demon.co.uk>
+Newsgroups: comp.os.ms-windows.programmer.nt.kernel-mode
+References: 1, 2 , 3 , 4
+
+In article <un264wzle.fsf@xxx.yyy.zzz>, David C. <qqqq@xxx.yyy.zzz> wrote:
+>The reason it won't unload when something is bound to it is the same
+>reason you can't unload any other driver that has an open client.  If
+>you install any driver, and have a user program (or another driver) open
+>a handle to it, and then give the "net stop" command to unload it,
+>you'll find that the unload will be delayed until the user program
+>closes its handle.
+
+When developing a driver I found this to be a considerable nuisance.
+Frequently a bug would leave an IRP stuck in the driver and I
+couldn't unload and reload a fixed version. While reading NTDDK.H I
+found a suspicious constant and discovered that the Flags field in
+the device (the one which you OR in DO_BUFFERED_IO or DO_DIRECT_IO)
+has a bit called DO_UNLOAD_PENDING. By experiment I confirmed that
+this bit is set when you do 'net stop', so a driver can check it
+periodically (e.g. from a timer DPC every ten seconds) and cancel all
+queued IRPs if it is found to be set.
+
+Since this is not documented anywhere that I can find, it might be
+unwise to rely on it for production code, but it is very useful for
+debugging. Maybe someone with internals knowledge can comment on the
+reliability of it.
+-----
+Subject: Re: Kernel bugs
+Date: Fri, 23 Oct 1998 12:08:36 -0700
+From: rex <rex@lvcablemodem.com>
+To: Jason Filby <jasonfilby@yahoo.com>
+References: 1
+
+Jason Filby wrote:
+
+> Hi,
+>
+> Ok -- here's most of what I get when I press a key:
+>
+> Page fault detected at address 1fd4 with eip c042f794
+> Recursive page fault detected
+> Exception 14(2)
+> CS:EIP 20:c042f794
+>
+> Rex -- do you know of anyway to find out which function in what file
+> is causing the exception? I know that for problems in the kernel, you
+> just look in the ntoskrnl\kernel.sym file and find the EIP value which
+> matches the one given in the exception debug text. But what about
+> modules? How can we track exceptions that occur in functions in modules?
+>
+
+I know this is a little belated, but I thought I'd take astab at answering
+this anyway.  add an option to the
+makefile for the module to generate a listing file with
+symbol information.  Then, on a boot test, note the
+address that the module is loaded at, and subtract
+this from the EIP value.  add any offset used in the
+module link specification (I dont think there currently
+is one), and look for the last symbol with a lower
+address offset.
+
+Brian, I have an idea on how to make this exception
+dump information a little more useful.  We should
+have the load information for the load modules
+in memory somewhere.  Perhaps the exception
+dump could check offending addresses to see if
+they lie in the kernel or in a module, and if they
+lie in a module the proper offset could be subtracted
+and this number could be displayed seperately.  If
+I get a chance today, I'll make this change and send
+it to ya.
+
+Rex.
+-----
+Subject: [ros-kernel] Pet peeve of the week
+Resent-Date: Sun, 25 Oct 1998 11:57:40 -0600
+Resent-From: ros-kernel@sid-dis.com
+Date: Sun, 25 Oct 1998 09:53:48 -0800
+From: rex <rex@lvcablemodem.com>
+Reply-To: <ros-kernel@sid-dis.com>
+To: ReactOS Kernel Forum <ros-kernel@sid-dis.com>
+
+Hi all,
+
+I guess it's about time to start another mailstorm
+on the list. :)
+
+I have a suggestion for a change to the kernel.
+It not a very big change, and I hope everyone
+will agree that it makes sense.
+
+There is a structure used in many places in the
+kernel called LARGE_INTEGER.  the is also
+a version called ULARGE_INTEGER, but it
+is not used at all as far as I can tell.  this structure
+is equivalent to a long long int.  You can literally
+cast a pointer to a LARGE_INTEGER to a
+long long int and all manipulation will work
+seemlessly. My suggestion is that we replace the
+use of this structure with long long ints.  Even
+microsoft, in their infinite wisdom, has made this
+suggestion in the DDK documentation.  If you're
+wondering where, look at the RTL functions
+that manipulate LARGE_INTEGER structs.
+
+Replacing LI's with long long ints will work
+because they are binary compatable.  All software
+compiled to use LI's will manipulate long long ints
+correctly and vice versa. There is one problem
+with this suggestion: the LARGE_INTEGER type
+is a structure containing 2 members.  Any code
+that accesses the structure by members will break.
+I think the kernel side impact is minimal, and is
+worth the change.  However, the structure is used
+in several of the Win32 API functions, and needs
+to remain there.  I think we build a conditionally
+compiled version of the LARGE_INTEGER type.
+In kernel mode code (the kernel proper and drivers)
+the LARGE INTEGER will be the following:
+
+typedef long long int LARGE_INTEGER,
+    *PLARGE_INTEGER;
+typedef unsigned long long int ULARGE_INTEGER,
+    *PULARGE_INTEGER;
+
+and in user mode code it will expand out to the
+current definition (which by the way, is not
+strictly correct, but can't be because it uses a
+MS compiler extension).
+
+Brian, I would be willing to make the conversion
+to those kernel modules that needed it, and of
+course to the IDE driver if we want to go forward
+with the change.
+
+Lastly, I'll mention what made me consider this.
+I was fixing the timer routines, and two of the
+three problems turned out to be related to LI
+conversion problems.
+
+Rex.
+-----
+Subject:  Re: [ros-kernel] Pet peeve of the week
+Date: Thu, 29 Oct 1998 19:10:37 +0100
+From: Boudewijn <ariadne@xs4all.nl>
+To: rex@lvcablemodem.com
+References: 1
+
+Hai Rex
+
+    I think it is a good idea to wrap a makro around the member access
+to large integers.
+I haven't tested this, but do you think this is a good sugestion ?
+
+#ifdef COMPILER_LARGE_INTEGERS
+#define GET_LARGE_INTEGER_HIGH_PART(LargeInteger) ( ( LargeInteger >>
+32) )
+#define GET_LARGE_INTEGER_LOW_PART(LargeInteger) ( (LargeInteger &
+0xFFFFFFFF) )
+#define SET_LARGE_INTEGER_HIGH_PART(LargeInteger,Signed_Long) (
+LargeInteger |= ( ((LARGE_INTEGER)Signed_Long) << 32 ) )
+#define SET_LARGE_INTEGER_LOW_PART(LargeInteger,Unsigned_Long) (
+LargeInteger |= Unsigned_Long  )
+#else
+#define GET_LARGE_INTEGER_HIGH_PART(LargeInteger) (  (
+LargeInteger.HighPart) )
+#define GET_LARGE_INTEGER_LOW_PART(LargeInteger) (
+(LargeInteger.LowPart) )
+#define SET_LARGE_INTEGER_HIGH_PART(LargeInteger,Signed_Long) (
+LargeInteger.HighPart=  Signed_Long  )
+#define SET_LARGE_INTEGER_LOW_PART(LargeInteger,Unsigned_Long) (
+LargeInteger.LowPart = Unsigned_Long  )
+#endif
+
+Boudewijn
+-----
+Subject: Re: Question on "Sending buffers on the stack to asynchronous DeviceIoControl with buffered I/O"
+Date: Mon, 16 Nov 1998 11:24:57 -0800
+From: "-Paul" <paulsan@microsoftSPAM.com>
+Organization: Microsoft Corp.
+Newsgroups: microsoft.public.win32.programmer.kernel, comp.os.ms-windows.programmer.nt.kernel-mode
+References: 1
+
+Radu, I post the following information occassionally for questions such as
+yours.  I hope it helps.
+
+-Paul
+
+Here is an explanation of buffers and DeviceIoControl.
+
+First, here are the parameters,
+
+BOOL DeviceIoControl(
+    HANDLE hDevice, // handle to device of interest
+    DWORD dwIoControlCode, // control code of operation to perform
+    LPVOID lpInBuffer, // pointer to buffer to supply input data
+    DWORD nInBufferSize, // size of input buffer
+    LPVOID lpOutBuffer, // pointer to buffer to receive output data
+    DWORD nOutBufferSize, // size of output buffer
+    LPDWORD lpBytesReturned, // pointer to variable to receive output byte
+count
+    LPOVERLAPPED lpOverlapped  // pointer to overlapped structure for
+asynchronous operation
+   );
+
+METHOD_BUFFERED
+
+user-mode perspective
+
+lpInBuffer - optional, contains data that is written to the driver
+lpOutBuffer - optional, contains data that is read from the driver after
+the call has completed
+
+lpInBuffer and lpOutBuffer can be two buffers or a single shared buffer.
+If a shared buffer, lpInBuffer is overwritten by lpOutBuffer.
+
+
+I/O Manager perspective
+
+examines nInBufferSize and nOutBufferSize.  Allocates memory from non-paged
+pool and puts the address of this pool in Irp->AssociatedIrp.SystemBuffer.
+The size of this buffer is equal to the size of the larger of the two
+bufferes.  This buffer is accessible at any IRQL.
+
+copies nInBufferSize to irpSp->Parameters.DeviceIoControl.InputBufferLength
+copies nOutBufferSize to
+irpSp->Parameters.DeviceIoControl.OutputBufferLength
+copies contents of lpInBuffer to SystemBuffer allocated above
+calls your driver
+
+
+
+Device Driver perspective
+
+you have one buffer, Irp->AssociatedIrp.SystemBuffer.  You read input data
+from this buffer and you write output data to the same buffer, overwriting
+the input data.
+
+Before calling IoCompleteRequest, you must
+- set IoStatus.Status to an approriate NtStatus
+- if IoStatus.Status == STATUS_SUCCESS
+ set IoStatus.Information to the
+ number of bytes you want copied
+ from the SystemBuffer back into
+ lpOutBuffer.
+
+
+I/O Manager Completion Routine perspective
+
+looks at IoStatus block, if IoStatus.Status = STATUS_SUCCESS, copies the
+number of bytes specified by IoStatus.Information from
+Irp->AssociatedIrp.SystemBuffer into lpOutBuffer
+completes the request
+
+
+
+
+
+
+METHOD_IN_DIRECT
+
+user-mode perspective
+
+lpInBuffer - optional, contains data that is written to the driver.  This
+buffer is used in the exact same fashion as METHOD_BUFFERED.  To avoid
+confusion, mentally rename this buffer to lpControlBuffer.  This is
+typically a small, optional buffer that might contain a control structure
+with useful information for the device driver.  This buffer is smal and is
+double buffered.
+
+lpOutBuffer - NOT OPTIONAL, This LARGE buffer contains data that is read by
+the driver.  To avoid confusion, mentally rename this buffer to
+lpDataTransferBuffer.  This is physically the same buffer that the device
+driver will read from.  There is no double buffering.  Technically, this
+buffer is still optional, but since you are using this buffering method,
+what would be the point???
+
+I/O Manager perspective
+
+If lpInBuffer exists, allocates memory from non-paged pool and puts the
+address of this pool in Irp->AssociatedIrp.SystemBuffer.  This buffer is
+accessible at any IRQL.
+
+copies nInBufferSize to irpSp->Parameters.DeviceIoControl.InputBufferLength
+copies nOutBufferSize to
+irpSp->Parameters.DeviceIoControl.OutputBufferLength
+copies contents of lpInBuffer to SystemBuffer allocated above
+So far this is completely identical to METHOD_BUFFERED.  Most likely
+lpInBuffer (mentally renamed to lpControlBuffer) is very small in size.
+
+For lpOutBuffer (mentally renamed to lpDataTransferBuffer), an MDL is
+allocated.  lpOutBuffer is probed and locked into memory.  Then, the user
+buffer virtual addresses are checked to be sure they are readable in the
+caller's access mode.
+
+The MDL is address is stored in Irp->MdlAddress.
+Your driver is called.
+
+
+Device Driver perspective
+
+The device driver can read the copy of lpOutBuffer via
+Irp->AssociatedIrp.SystemBuffer.  Anything written by the device driver to
+this buffer is lost.  The I/O Manager does not copy any data back to the
+user-mode buffers as it did in the completion routine for METHOD_BUFFERED.
+Art Baker's book is wrong in this respect (page 168, "data going from the
+driver back to the caller is passed through an intermediate system-space
+buffer" and page 177, "When the IOCTL IRP is completed, the contents of the
+system buffer will be copied back into the callers original output buffer".
+
+The device driver accesses the Win32 buffer directly via Irp->MdlAddress.
+The driver uses whatever Mdl API's to read the buffer.  Usually, this
+buffer is to be written to some mass storage media or some similar
+operation.  Since this is a large data transfer, assume a completion
+routine is required.
+
+mark the Irp pending
+queue it
+return status pending
+
+
+
+
+Device Driver Completion Routine perspective
+
+standard completion routine operations
+set IoStatus.Status to an approriate NtStatus
+IoStatus.Information is not needed
+completete the request
+
+
+
+
+I/O Manager Completion Routine perspective
+
+standard I/O Manager completion routine operations
+unmap the pages
+deallocate the Mdl
+complete the request
+
+
+
+
+
+METHOD_OUT_DIRECT
+
+user-mode perspective
+
+lpInBuffer - optional, contains data that is written to the driver.  This
+buffer is used in the exact same fashion as METHOD_BUFFERED.  To avoid
+confusion, mentally rename this buffer to lpControlBuffer.  This is
+typically a small, optional buffer that might contain a control structure
+with useful information for the device driver.  This buffer is smal and is
+double buffered.
+
+lpOutBuffer - NOT OPTIONAL, This LARGE buffer contains data that is written
+by the driver and read by the wer-mode application when the request is
+completed.  To avoid confusion, mentally rename this buffer to
+lpDataTransferBuffer.  This is physically the same buffer that the device
+driver will write to.  There is no double buffering.  Technically, this
+buffer is still optional, but since you are using this buffering method,
+what would be the point???
+
+I/O Manager perspective
+
+If lpInBuffer exists, allocates memory from non-paged pool and puts the
+address of this pool in Irp->AssociatedIrp.SystemBuffer.  This buffer is
+accessible at any IRQL.
+
+copies nInBufferSize to irpSp->Parameters.DeviceIoControl.InputBufferLength
+copies nOutBufferSize to
+irpSp->Parameters.DeviceIoControl.OutputBufferLength
+copies contents of lpInBuffer to SystemBuffer allocated above
+So far this is completely identical to METHOD_BUFFERED.  Most likely
+lpInBuffer (mentally renamed to lpControlBuffer) is very small in size.
+
+For lpOutBuffer (mentally renamed to lpDataTransferBuffer), an MDL is
+allocated.  lpOutBuffer is probed and locked into memory.  Then the user
+buffer's addresses are checked to make sure the caller could write to them
+in the caller's access mode.
+
+The MDL is address is stored in Irp->MdlAddress.
+Your driver is called.
+
+
+Device Driver perspective
+
+The device driver can read the copy of lpOutBuffer via
+Irp->AssociatedIrp.SystemBuffer.  Anything written by the device driver to
+this buffer is lost.
+
+The device driver accesses the Win32 buffer directly via Irp->MdlAddress.
+The driver uses whatever Mdl API's to write data to the buffer.  Usually,
+this buffer is to be read from some mass storage media or some similar
+operation.  Since this is a large data transfer, assume a completion
+routine is required.
+
+mark the Irp pending
+queue it
+return status pending
+
+
+
+
+Device Driver Completion Routine perspective
+
+standard completion routine operations
+set IoStatus.Status to an approriate NtStatus
+IoStatus.Information is not needed
+completete the request
+
+
+
+
+I/O Manager Completion Routine perspective
+
+standard I/O Manager completion routine operations
+unmap the pages
+deallocate the Mdl
+complete the request
+
+
+
+
+METHOD_NEITHER
+
+I/O Manager perspective
+
+Irp->UserBuffer = lpOutputBuffer;
+IrpSp->Parameters.DeviceIoControl.Type3InputBuffer = lpInputBuffer;
+
+No comments here.  Don't use METHOD_DIRECT unless you know what you are
+doing.  Simple rule.
+
+If your IOCtl involves no data transfer buffers, then METHOD_NEITHER is the
+fastest path through the I/O Manager that involves an Irp.
+
+
+
+
+Final Comment
+
+Don't touch Irp->UserBuffer.  This is a bookmark for the I/O Manager.  Two
+major problems can occur.  1 - page fault at high IRQL, or 2 - you write
+something to Irp->UserBuffer and the I/O Manager overwrites you in its
+completion routine.  File systems access Irp->UserBuffer, but FSD writers
+know all of the above and know when it is safe to touch Irp->UserBuffer.
+
+
+
+Radu Woinaroski wrote in message <364F8F6E.2434B010@scitec.com.au>...
+>Hello,
+>
+>I have a kernel-mode device driver that accepts a number of IoControl
+>commands that use buffered data transfer (METHOD_BUFFERED).
+>
+>A user mode API provides a higher level access then the DeviceIoControl
+>function.
+>
+>The function is implemented like that
+>
+>BOOL
+Something( 
+> HANDLE hDevice , 
+> int param1, 
+> int param2, 
+> DWORD * pReturn, 
+> LPOVERLAPPED pOverlapped)
+>{
+> // here a data buffer on the stack sent to asynchronous DeviceIoControl
+>call
+> int aDataIn[2];
+> aDataIn[0] = param1;
+> aDataIn[1] = param2;
+>
+> return DeviceIoControl( 
+> hDevice,
+> DO_SOMETHING_IO, 
+> aDataIn,
+> sizeof(int)*2,
+> pReturn,
+> sizeof(DWORD),
+> pOverlapped);
+>}
+>
+>The aDataIn buffer will not exist after DeviceIoControl returns (and
+>when the I/O operation terminates). I know that for buffered IO the
+>input data buffer is copyed by de IOManager to a nonpaged-pool area
+>before passing the request to driver dispatch routine (DeviceControl).
+>At the point of calling the dispatch routine (DeviceControl) the driver
+>runs in the context of the calling thread so DeviceIoControl hasn't
+>returned yet (?? or so I think) so aDataI
+n will still be valid at the
+>time IOManager copyes it to its buffer. So, this apears to work ok (at
+>least in my opinion).
+>
+>Does I/O Manager use the Input buffer from the call to the Win32
+>DeviceIoControl any where else after the first copy ?
+>
+>Is there any reason why this approach (passing a buffer on the stack to
+>a asynchronous DeviceIoControl that uses buffered I/O) wouldn't work ?
+>
+>Allocating buffers from heap and deleting them on IO completion while
+>managing asynchronous IO seems too much work ;-) .
+>
+>Thanks in advance for your opinions
+>Radu W.
+>
+>--
+>Radu Woinaroski
+>Scitec
+>Sydney, Australia
+>Radu.Woinaroski@scitec.com.au
+-----
+Subject: Re: PCI ISR problem
+Date: Fri, 20 Nov 1998 18:04:48 GMT
+From: jeh@cmkrnl.com (Jamie Hanrahan)
+Organization: Kernel Mode Systems, San Diego, CA
+Newsgroups: comp.os.ms-windows.programmer.nt.kernel-mode
+References: 1
+
+On Thu, 19 Nov 1998 15:46:13 -0600, Eric Gardiner
+<eric.gardiner@natinst.com> wrote:
+
+>I'm having problems with NT4 not hooking the interrupt line indicated by
+>a PCI device.  Here's what I'm doing:
+>
+>1)  Enumerating the PCI buses on the system (using HalGetBusData) until
+>I find my device.
+>2)  Once my device is found, I read the "Interrupt Line Register" in the
+>device's PCI config space to determine what interrupt level to pass to
+>HalGetInterruptVector.
+
+Whups!  No.  Call HalAssignSlotResources and look at the returned
+CM_RESOURCE_LIST to find the vector, level, port addresses, etc., for
+your device.  (Then pass the returned CM_RESOURCE_LIST to ExFreePool.)
+
+
+See Knowledge Base article Q152044. 
+
+        --- Jamie Hanrahan, Kernel Mode Systems, San Diego CA (jeh@cmkrnl.com)
+Drivers, internals, networks, applications, and training for VMS and Windows NT
+NT kernel driver FAQ, links, and other information:  http://www.cmkrnl.com/
+
+Please post replies, followups, questions, etc., in news, not via e-mail. 
+-----
+Subject: Re: IRP canceling
+Date: Mon, 23 Nov 1998 09:05:47 -0500
+From: Walter Oney <waltoney@oneysoft.com>
+Organization: Walter Oney Software
+Newsgroups: comp.os.ms-windows.programmer.nt.kernel-mode
+References: 1
+
+Seol,Keun Seok wrote:
+> But, if the IRP was the CurrentIrp of the Device Object,
+> the Driver's Start I/O routine will try to process the IRP.
+> In the DDK help, the Start I/O routine MUST check the current IRP's
+> Cancel bit.
+> If set, Start I/O routine must just return.
+> 
+> But I think that the IRP already completed should not be accessed. 
+
+You're absolutely right. I recommend the following code in a standard
+StartIo routine to avoid the problem you point out:
+
+VOID StartIo(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+  {
+  KIRQL oldirql;
+  IoAcquireCancelSpinLock(&oldirql);
+  if (Irp != DeviceObject->CurrentIrp || Irp->Cancel)
+    {
+    IoReleaseCancelSpinLock(oldirql);
+    return;
+    }
+  else
+    {
+    IoSetCancelRoutine(Irp, NULL);
+    IoReleaseCancelSpinLock(oldirql);
+    }
+  . . .
+  }
+
+This dovetails with a standard cancel routine:
+
+VOID CancelRoutine(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+  {
+  if (DeviceObject->CurrentIrp == Irp)
+    {
+    IoReleaseCancelSpinLock(Irp->CancelIrql);
+    IoStartNextPacket(DeviceObject, TRUE);
+    }
+  else
+    {
+    KeRemoveEntryDeviceQueue(&DeviceObject->DeviceQueue,
+      &Irp->Tail.Overlay.DeviceQueueEntry);
+    IoReleaseCancelSpinLock(Irp->CancelIrql);
+    }
+  Irp->IoStatus.Status = STATUS_CANCELLED;
+  Irp->IoStatus.Information = 0;
+  IoCompleteRequest(Irp, IO_NO_INCREMENT);
+  }
+
+You need to remember that the C language specification requires that
+evaluation of boolean operators short circuit when the result is known.
+So, if StartIo discovers that the Irp it got as an argument is not the
+same as CurrentIrp, it will not attempt to evaulate Irp->Cancel.
+
+Now, as to why this works: StartIo gets called either by IoStartPacket
+or IoStartNextPacket. Each of them will grab the cancel spin lock and
+set CurrentIrp, then release the spin lock and call StartIo. If someone
+should sneak in on another CPU and cancel this very same IRP, your
+cancel routine will immediately release the spin lock and call
+IoStartNextPacket. One of two things will then happen. IoStartNextPacket
+may succeed in getting the cancel spin lock, whereupon it will nullify
+the CurrentIrp pointer. If another IRP is on the queue, it will remove
+it from the queue, set CurrentIrp to point to this *new* IRP, release
+the spin lock, and call StartIo. [You now have two instances of StartIo
+running on two different CPUs for two different IRPs, but it's not a
+problem because they won't be able to interfere with each other.]
+Meanwhile, your original instance of StartIo gets the cancel spin lock
+and sees that CurrentIrp is not equal to the IRP pointer it got as an
+argument, so it gives up.
+
+The second way this could play out is that StartIo gets the cancel lock
+before IoStartNextPacket does. In this case, CurrentIrp is still
+pointing to the IRP that's in the process of being cancelled and that
+StartIo got as an argument. But this IRP hasn't been completed yet (the
+CPU that's running your cancel routine is spinning inside
+IoStartNextPacket and therefore hasn't gotten to calling
+IoCompleteRequest yet), so no-one will have been able to call IoFreeIrp
+to make your pointer invalid.
+
+People may tell you that you should be using your own queues for IRPs so
+you can avoid bottlenecking the system on the global cancel spin lock.
+That's true enough, but doing it correctly with Plug and Play and Power
+management things in the way is gigantically complicated. There's a
+sample in the NT 5 beta-2 DDK called CANCEL that shows how to manage
+your own queue if you don't worry about PNP and POWER. I hear tell of an
+upcoming MSJ article by a Microsoft developer that may solve the
+complete problem.
+-----
+Subject: ANNOUNCE: ALINK v1.5
+Date: 16 Nov 1998 16:36:05 GMT
+From: anthony_w@my-dejanews.com
+Organization: Deja News - The Leader in Internet Discussion
+Newsgroups: comp.os.ms-windows.programmer.win32, comp.lang.asm.x86, comp.os.msdos.programmer
+
+ALINK is a freeware linker, creating MSDOS COM and EXE files and Win32 PE EXE
+and DLL files from OMF format OBJ and LIB files, win32-COFF format OBJ files,
+and win32 RES files.
+
+NEW for version 1.5:
+
+Win32 COFF object file support.
+
+Download it now from my home page.
+
+Anthony
+--
+anthony_w@geocities.com
+http://www.geocities.com/SiliconValley/Network/4311/index.html
+
+-----------== Posted via Deja News, The Discussion Network ==----------
+http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own    
+-----
+

reactos/doc/psmgr.texi

@@ -0,0 +1,100 @@
+\input texinfo @c -*-texinfo-*-
+@c %**start of header
+@setfilename psmgr.info
+@settitle Process Manager Design and Implementation
+@setchapternewpage odd
+@c %**end of header
+
+@ifinfo
+This document describes the ReactOS process manager design and implementation
+@end ifinfo
+
+@titlepage
+@title Process Manager Design and Implementation
+@author David Welch <david.welch@seh.ox.ac.uk>
+@page
+@vskip 0pt plus 1filll
+Copyright @copyright{} 1999 David Welch
+@end titlepage
+
+@node Top, Overview, , (dir)
+@comment node-name, next, previous, up
+
+@ifinfo
+This document describes the design and implementation of the reactos process 
+manager
+@end ifinfo
+
+@menu
+* Overview:: Overview of this document
+* External Interfaces:: External Interfaces
+* Data Structures:: Data Structures
+* Concept Index:: This index has two entries
+@end menu
+
+@node Overview, External Interfaces, top, top
+@comment node-name, next, previous, up
+@chapter Overview
+
+This document describes the design and implementation of the ReactOS process 
+manager. ReactOS is a GPLed operating system that attempts to be compatible 
+with Windows NT, for more information see @uref{http://www.reactos.com}.
+
+@node External Interfaces, Data Structures, Overview, top
+@comment node-name, next, previous, up
+@chapter External Interfaces
+
+This chapter describes the external interfaces provided by the process
+manager both to user-mode and to the rest of the kernel.
+
+@menu
+* NtCreateProcess:: Creates a new process
+@end menu
+
+@node NtCreateProcess, , , External Interfaces
+@comment node-name, next, previous, up
+
+@deftypefn Function NTSTATUS NtCreateProcess
+
+The parameters are
+@itemize @bullet
+@item
+HANDLE ProcessHandle: Received a handle for the created process on return.
+@item
+ACCESS_MASK DesiredAccess: Specifies the requested types of access to
+the created process.
+@item
+POBJECT_ATTRIBUTES ObjectAttributes: Specifies various attributes for the
+created process.
+@item
+HANDLE ParentProcessHandle: Specifies the parent process for the created
+process.
+@item
+BOOLEAN InheritObjectTable: True if the new process such inherit its parent's
+handles.
+@item
+HANDLE SectionHandle: If this parameter is NULL then the new process's
+address space will be a copy of its parent's. Otherwise the new process's
+address space will contain a mapping of the section pointed to by this
+handle and NTDLL.
+@item
+HANDLE DebugPort: Specifies a handle that will receive debug messages
+associated with this process.
+@item
+HANDLE ExceptionPort: Specifies a handle that will receive exception messages
+associated with this process.
+@end itemize
+
+The return value is either STATUS_SUCCESS or a value indicating the reason
+by failure.
+@end deftypefn
+
+@node Data Structures, Concept Index, External Interfaces, top
+@comment node-name, next, previous, up
+@chapter Data Structures
+
+@node Concept Index, ,Data Structures, Top
+@unnumbered Concept Index
+@printindex cp
+@contents
+@bye

reactos/doc/todo

@@ -1,31 +1,59 @@
-* Kernel things implemented [exceptions in brackets]
 
-Spinlocks [Uniprocessor only]
-IRQ levels [Not APC_LEVEL or WAKE_LEVEL, uniprocessor only]
-ISRs [Partial, uniprocessor only]
-Timers [Untested]
-DPCs [Untested]
-Objects [Partial]
-Namespace [Partial]
-Handle tables [One process only]
-Threads [Some initial work]
-RTL list functions [All except sequenced lists]
-Zones [Untested]
-Memory pool [Working but semantics partially incompatiable]
-Device objects [Some but no support for layering]
-IRP [Partial]
-Memory sections [Partial, no file mappings]
-PCI interface [Probes but no support]
-CreateFile API [Device only]
-ReadFile/WriteFile API [Device only]
-MDL functions [Untested]
+* Critical path tasks
+       Test and debug Registry routines
+       Finish multiple system service table support (HalRegisterServiceTable)
+       Modify GENNTDLL to generate all needed system service tables
 
-* Kernel things unimplemented (partial)
+* These tasks would be nice
+       Separate HAL into KM DLL
 
-Add support for source level debugging to Bochs
-Support for remote debugging
-Process managment
-Dispatcher objects (Mutex, Semaphore etc)
-Investigate user and kernel mode APCs
-Asynchronous I/O
-Optimization
+* Function groups totally or partially unimplemented
+
+       Dma functions (see hal/x86/dma.c)
+       PCI interface functions (see hal/x86/bios32.c, hal/x86/pci.c)
+       HalExamineMbr
+       Locale support (see ex/locale.c)
+       Shutdown support (see ex/power.c)
+       Zw(Set/Get)SystemInformation (see ex/sysinfo.c)
+       Adapter functions (see io/adapter.c)
+       Io cancelation support (see io/cancel, et al)
+       Directory change notification (see io/dir.c)
+       Error logging (see io/errlog.c)
+       Buffer flushing (see io/flush.c)
+       Io completion ports (see io/iocomp.c)
+       File locking (see io/lock.c)
+       Mailslots (see io/mailslot.c)
+       Named pipes (see io/npipe.c)
+       Hardware resource management (see io/resource.c)
+       File access checking (see io/share.c)
+       APCs to user-mode (see ke/apc.c, ke/apchelp.asm)
+       Exception support (see ke/catch.c)
+       Mutex support (see ke/mutex.c)
+       Semaphore support (see ke/sem.c)
+       Timer support (see ke/timer.c)
+       Properly calibrate delay loop (see ke/timer.c)
+       Waiting for multiple objects (see ke/wait.c)
+       Single linked lists (see rtl/slist.c)
+       Sequenced lists (see rtl/seqlist.c)
+       
+* Verify implementation
+
+       Fast mutexes (see ex/fmutex.c)
+       
+* Major areas
+
+       Security support (see se/*.c)
+       Registry support (see cm/*.c)
+       Paging support
+       File system cache support
+       SCSI miniport driver
+       Network support
+       Video drivers
+       USER and GDI modules
+       
+* Drivers
+       NTFS, EXT2 filesystems
+       Many others (use oem's where possible)
+       
+* For the future
+       DOS, Win16, POSIX subsystems

reactos/doc/wstring.txt

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

reactos/drivers/dd/beep/.cvsignore

@@ -0,0 +1,4 @@
+base.tmp
+junk.tmp
+temp.exp
+

reactos/drivers/dd/beep/beep.c

@@ -0,0 +1,284 @@
+/* $Id: beep.c,v 1.5 2000/07/02 10:54:12 ekohl Exp $
+ *
+ * COPYRIGHT:            See COPYING in the top level directory
+ * PROJECT:              ReactOS kernel
+ * FILE:                 services/dd/beep/beep.c
+ * PURPOSE:              BEEP device driver
+ * PROGRAMMER:           Eric Kohl (ekohl@abo.rhein-zeitung.de)
+ * UPDATE HISTORY:
+ *                       30/01/99 Created
+ *                       16/10/99 Minor fixes
+ */
+
+/* INCLUDES ****************************************************************/
+
+#include <ddk/ntddk.h>
+#include <ddk/ntddbeep.h>
+
+#define NDEBUG
+#include <internal/debug.h>
+
+
+/* TYEPEDEFS ***************************************************************/
+
+typedef struct tagBEEP_DEVICE_EXTENSION
+{
+    KDPC   Dpc;
+    KTIMER Timer;
+    KEVENT Event;
+    BOOL   BeepOn;
+} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
+
+
+/* FUNCTIONS ***************************************************************/
+
+
+VOID BeepDPC (PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
+{
+    PDEVICE_EXTENSION DeviceExtension = DeferredContext;
+
+    DPRINT ("BeepDPC() called!\n");
+    HalMakeBeep (0);
+    DeviceExtension->BeepOn = FALSE;
+    KeSetEvent (&(DeviceExtension->Event), 0, TRUE);
+
+    DPRINT ("BeepDPC() finished!\n");
+}
+
+
+NTSTATUS BeepCreate (PDEVICE_OBJECT DeviceObject, PIRP Irp)
+/*
+ * FUNCTION: Handles user mode requests
+ * ARGUMENTS:
+ *                       DeviceObject = Device for request
+ *                       Irp = I/O request packet describing request
+ * RETURNS: Success or failure
+ */
+{
+    PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
+    NTSTATUS status;
+
+    if (Stack->MajorFunction == IRP_MJ_CREATE)
+    {
+        DPRINT ("BeepCreate() called!\n");
+        Irp->IoStatus.Information = 0;
+        status = STATUS_SUCCESS;
+    }
+    else
+        status = STATUS_NOT_IMPLEMENTED;
+
+    Irp->IoStatus.Status = status;
+    IoCompleteRequest (Irp,IO_NO_INCREMENT);
+    return (status);
+}
+
+
+NTSTATUS BeepClose(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+/*
+ * FUNCTION: Handles user mode requests
+ * ARGUMENTS:
+ *                       DeviceObject = Device for request
+ *                       Irp = I/O request packet describing request
+ * RETURNS: Success or failure
+ */
+{
+    PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation (Irp);
+    NTSTATUS status;
+
+    switch (Stack->MajorFunction)
+    {
+        case IRP_MJ_CLOSE:
+            DPRINT ("BeepClose() called!\n");
+            Irp->IoStatus.Information = 0;
+            status = STATUS_SUCCESS;
+            break;
+
+        default:
+            status = STATUS_NOT_IMPLEMENTED;
+    }
+
+    Irp->IoStatus.Status = status;
+    IoCompleteRequest (Irp, IO_NO_INCREMENT);
+    return (status);
+}
+
+
+NTSTATUS BeepCleanup(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+/*
+ * FUNCTION: Handles user mode requests
+ * ARGUMENTS:
+ *                       DeviceObject = Device for request
+ *                       Irp = I/O request packet describing request
+ * RETURNS: Success or failure
+ */
+{
+    PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation (Irp);
+    NTSTATUS status;
+
+    if (Stack->MajorFunction == IRP_MJ_CLEANUP)
+    {
+        DPRINT ("BeepCleanup() called!\n");
+        Irp->IoStatus.Information = 0;
+        status = STATUS_SUCCESS;
+    }
+    else
+        status = STATUS_NOT_IMPLEMENTED;
+
+    Irp->IoStatus.Status = status;
+    IoCompleteRequest (Irp, IO_NO_INCREMENT);
+    return (status);
+}
+
+
+NTSTATUS BeepDeviceControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
+/*
+ * FUNCTION: Handles user mode requests
+ * ARGUMENTS:
+ *                       DeviceObject = Device for request
+ *                       Irp = I/O request packet describing request
+ * RETURNS: Success or failure
+ */
+{
+    PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
+    PDEVICE_EXTENSION DeviceExtension;
+    PBEEP_SET_PARAMETERS pbsp;
+    NTSTATUS status;
+
+    DeviceExtension = DeviceObject->DeviceExtension;
+
+    DPRINT ("BeepDeviceControl() called!\n");
+    if (Stack->Parameters.DeviceIoControl.IoControlCode == IOCTL_BEEP_SET)
+    {
+        Irp->IoStatus.Information = 0;
+        if (Stack->Parameters.DeviceIoControl.InputBufferLength == sizeof(BEEP_SET_PARAMETERS))
+        {
+            pbsp = (PBEEP_SET_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
+
+            if (pbsp->Frequency >= BEEP_FREQUENCY_MINIMUM &&
+                pbsp->Frequency <= BEEP_FREQUENCY_MAXIMUM)
+            {
+                LARGE_INTEGER DueTime;
+
+                DueTime.QuadPart = 0;
+
+                /* do the beep!! */
+                DPRINT ("Beep:\n  Freq: %lu Hz\n  Dur: %lu ms\n",
+                        pbsp->Frequency, pbsp->Duration);
+
+                if (pbsp->Duration >= 0)
+                {
+                    DueTime.QuadPart = (LONGLONG)pbsp->Duration * -10000;
+
+                    KeSetTimer (&DeviceExtension->Timer,
+                                DueTime,
+                                &DeviceExtension->Dpc);
+
+                    HalMakeBeep (pbsp->Frequency);
+                    DeviceExtension->BeepOn = TRUE;
+                    KeWaitForSingleObject (&(DeviceExtension->Event),
+                                           Executive,
+                                           KernelMode,
+                                           FALSE,
+                                           NULL);
+                }
+                else if (pbsp->Duration == (DWORD)-1)
+                {
+                    if (DeviceExtension->BeepOn)
+                    {
+                        HalMakeBeep (0);
+                        DeviceExtension->BeepOn = FALSE;
+                    }
+                    else
+                    {
+                        HalMakeBeep (pbsp->Frequency);
+                        DeviceExtension->BeepOn = TRUE;
+                    }
+                }
+
+                DPRINT ("Did the beep!\n");
+
+                status = STATUS_SUCCESS;
+            }
+            else
+            {
+                status = STATUS_INVALID_PARAMETER;
+            }
+        }
+        else
+        {
+            status = STATUS_INVALID_PARAMETER;
+        }
+    }
+    else
+    {
+        status = STATUS_NOT_IMPLEMENTED;
+    }
+
+    Irp->IoStatus.Status = status;
+    IoCompleteRequest (Irp, IO_NO_INCREMENT);
+    return (status);
+}
+
+
+NTSTATUS BeepUnload(PDRIVER_OBJECT DriverObject)
+{
+    DPRINT ("BeepUnload() called!\n");
+    return (STATUS_SUCCESS);
+}
+
+
+NTSTATUS
+STDCALL
+DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
+/*
+ * FUNCTION:  Called by the system to initalize the driver
+ * ARGUMENTS:
+ *            DriverObject = object describing this driver
+ *            RegistryPath = path to our configuration entries
+ * RETURNS:   Success or failure
+ */
+{
+    PDEVICE_EXTENSION DeviceExtension;
+    PDEVICE_OBJECT DeviceObject;
+    UNICODE_STRING DeviceName;
+    UNICODE_STRING SymlinkName;
+    NTSTATUS Status;
+
+    DbgPrint ("Beep Device Driver 0.0.2\n");
+
+    DriverObject->MajorFunction[IRP_MJ_CREATE] = BeepCreate;
+    DriverObject->MajorFunction[IRP_MJ_CLOSE] = BeepClose;
+    DriverObject->MajorFunction[IRP_MJ_CLEANUP] = BeepCleanup;
+    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = BeepDeviceControl;
+    DriverObject->DriverUnload = BeepUnload;
+
+    /* set up device extension */
+    DeviceExtension = DeviceObject->DeviceExtension;
+    DeviceExtension->BeepOn = FALSE;
+
+    KeInitializeDpc (&(DeviceExtension->Dpc),
+                     BeepDPC,
+                     DeviceExtension);
+    KeInitializeTimer (&(DeviceExtension->Timer));
+    KeInitializeEvent (&(DeviceExtension->Event),
+                       SynchronizationEvent,
+                       FALSE);
+
+    RtlInitUnicodeString (&DeviceName, L"\\Device\\Beep");
+    Status = IoCreateDevice (DriverObject,
+                             sizeof(DEVICE_EXTENSION),
+                             &DeviceName,
+                             FILE_DEVICE_BEEP,
+                             0,
+                             FALSE,
+                             &DeviceObject);
+    if (NT_SUCCESS(Status))
+        return Status;
+
+    RtlInitUnicodeString (&SymlinkName, L"\\??\\Beep");
+    IoCreateSymbolicLink (&SymlinkName, &DeviceName);
+
+    return (STATUS_SUCCESS);
+}
+
+/* EOF */

reactos/drivers/dd/beep/beep.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",	"PC Speaker Device Driver\0"
+            VALUE "FileVersion",	"0.0.2\0"
+            VALUE "InternalName",	"beep\0"
+            VALUE "LegalCopyright",	RES_STR_LEGAL_COPYRIGHT
+            VALUE "OriginalFilename",	"beep.sys\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/drivers/dd/beep/makefile

@@ -0,0 +1,71 @@
+# $Id: makefile,v 1.6 1999/12/04 20:58:35 ea Exp $
+#
+#
+TARGET = beep
+OBJECTS = beep.o beep.coff ../../../ntoskrnl/ntoskrnl.a
+
+BASE_CFLAGS = -I../../../include
+
+all: beep.sys
+
+.PHONY: all
+
+clean:
+	- $(RM) beep.o
+	- $(RM) beep.coff
+	- $(RM) junk.tmp
+	- $(RM) base.tmp
+	- $(RM) temp.exp
+	- $(RM) beep.sys
+
+.phony: clean
+
+floppy: $(FLOPPY_DIR)/drivers/$(TARGET).sys
+
+$(FLOPPY_DIR)/drivers/$(TARGET).sys: $(TARGET).sys
+ifeq ($(DOSCLI),yes)
+	$(CP) $(TARGET).sys $(FLOPPY_DIR)\drivers\$(TARGET).sys
+else
+	$(CP) $(TARGET).sys $(FLOPPY_DIR)/drivers/$(TARGET).sys
+endif
+
+dist: ../../../$(DIST_DIR)/drivers/$(TARGET).sys
+
+../../../$(DIST_DIR)/drivers/$(TARGET).sys: $(TARGET).sys
+ifeq ($(DOSCLI),yes)
+	$(CP) $(TARGET).sys ..\..\..\$(DIST_DIR)\drivers\$(TARGET).sys
+else
+	$(CP) $(TARGET).sys ../../../$(DIST_DIR)/drivers/$(TARGET).sys
+endif
+
+
+beep.sys: $(OBJECTS)
+	$(CC) \
+		-specs=../../svc_specs \
+		-mdll \
+		-o junk.tmp \
+		-Wl,--defsym,_end=end \
+		-Wl,--defsym,_edata=__data_end__ \
+		-Wl,--defsym,_etext=etext \
+		-Wl,--base-file,base.tmp \
+		$(OBJECTS)
+	- $(RM) junk.tmp
+	$(DLLTOOL) \
+		--dllname beep.sys \
+		--base-file base.tmp \
+		--output-exp temp.exp \
+		--kill-at
+	- $(RM) base.tmp
+	$(CC) \
+		--verbose \
+		-Wl,--image-base,0x10000 \
+		-Wl,-e,_DriverEntry@8 \
+		-Wl,temp.exp \
+		-specs=../../svc_specs \
+		-mdll \
+		-o $(TARGET).sys \
+		$(OBJECTS)
+	- $(RM) temp.exp
+
+include ../../../rules.mak
+

reactos/drivers/dd/blue/.cvsignore

@@ -0,0 +1,4 @@
+base.tmp
+junk.tmp
+temp.exp
+blue.coff

reactos/drivers/dd/blue/blue.c

@@ -0,0 +1,635 @@
+/* $Id: blue.c,v 1.26 2000/07/11 04:08:43 phreak Exp $
+ *
+ * COPYRIGHT:            See COPYING in the top level directory
+ * PROJECT:              ReactOS kernel
+ * FILE:                 services/dd/blue/blue.c
+ * PURPOSE:              Console (blue screen) device driver
+ * PROGRAMMER:           Eric Kohl (ekohl@abo.rhein-zeitung.de)
+ * UPDATE HISTORY:
+ *                       ??? Created
+ */
+
+/* INCLUDES ******************************************************************/
+
+#include <ddk/ntddk.h>
+#include <ddk/ntddblue.h>
+#include <string.h>
+#include <defines.h>
+
+#define NDEBUG
+#include <debug.h>
+
+
+/* DEFINITIONS ***************************************************************/
+
+#define VIDMEM_BASE        0xb8000
+#define VIDMEM_SIZE        0x2000
+
+#define CRTC_COMMAND       ((PUCHAR)0x3d4)
+#define CRTC_DATA          ((PUCHAR)0x3d5)
+
+#define CRTC_COLUMNS       0x01
+#define CRTC_OVERFLOW      0x07
+#define CRTC_ROWS          0x12
+#define CRTC_SCANLINES     0x09
+#define CRTC_CURSORSTART   0x0a
+#define CRTC_CURSOREND     0x0b
+#define CRTC_CURSORPOSHI   0x0e
+#define CRTC_CURSORPOSLO   0x0f
+
+#define ATTRC_WRITEREG     ((PUCHAR)0x3c0)
+#define ATTRC_READREG      ((PUCHAR)0x3c1)
+#define ATTRC_INPST1       ((PUCHAR)0x3da)
+
+#define TAB_WIDTH          8
+
+
+/* NOTES ******************************************************************/
+/*
+ *  [[character][attribute]][[character][attribute]]....
+ */
+
+
+/* TYPEDEFS ***************************************************************/
+
+typedef struct _DEVICE_EXTENSION
+{
+    PBYTE VideoMemory;    /* Pointer to video memory */
+    DWORD CursorSize;
+    BOOL  CursorVisible;
+    WORD  CharAttribute;
+    DWORD Mode;
+    BYTE  ScanLines;      /* Height of a text line */
+    WORD  Rows;           /* Number of rows        */
+    WORD  Columns;        /* Number of columns     */
+} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
+
+
+/* FUNCTIONS **************************************************************/
+
+NTSTATUS
+ScrCreate (PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+    PDEVICE_EXTENSION DeviceExtension;
+    PHYSICAL_ADDRESS BaseAddress;
+    NTSTATUS Status;
+    unsigned int offset;
+    BYTE data, value;
+
+    DeviceExtension = DeviceObject->DeviceExtension;
+
+    /* get pointer to video memory */
+    BaseAddress.QuadPart = VIDMEM_BASE;
+    DeviceExtension->VideoMemory =
+        (PBYTE)MmMapIoSpace (BaseAddress, VIDMEM_SIZE, FALSE);
+
+    /* disable interrupts */
+    __asm__("cli\n\t");
+
+    /* get current output position */
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
+    offset = READ_PORT_UCHAR (CRTC_DATA);
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
+    offset += (READ_PORT_UCHAR (CRTC_DATA) << 8);
+
+    /* switch blinking characters off */
+    READ_PORT_UCHAR (ATTRC_INPST1);
+    value = READ_PORT_UCHAR (ATTRC_WRITEREG);
+    WRITE_PORT_UCHAR (ATTRC_WRITEREG, 0x10);
+    data  = READ_PORT_UCHAR (ATTRC_READREG);
+    data  = data & ~0x08;
+    WRITE_PORT_UCHAR (ATTRC_WRITEREG, data);
+    WRITE_PORT_UCHAR (ATTRC_WRITEREG, value);
+    READ_PORT_UCHAR (ATTRC_INPST1);
+
+    /* read screen information from crt controller */
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_COLUMNS);
+    DeviceExtension->Columns = READ_PORT_UCHAR (CRTC_DATA) + 1;
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_ROWS);
+    DeviceExtension->Rows = READ_PORT_UCHAR (CRTC_DATA);
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_OVERFLOW);
+    data = READ_PORT_UCHAR (CRTC_DATA);
+    DeviceExtension->Rows |= (((data & 0x02) << 7) | ((data & 0x40) << 3));
+    DeviceExtension->Rows++;
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_SCANLINES);
+    DeviceExtension->ScanLines = (READ_PORT_UCHAR (CRTC_DATA) & 0x1F) + 1;
+
+    /* enable interrupts */
+    __asm__("sti\n\t");
+
+    /* calculate number of text rows */
+    DeviceExtension->Rows =
+        DeviceExtension->Rows / DeviceExtension->ScanLines;
+
+    DPRINT ("%d Columns  %d Rows %d Scanlines\n",
+            DeviceExtension->Columns,
+            DeviceExtension->Rows,
+            DeviceExtension->ScanLines);
+
+    DeviceExtension->CursorSize    = 5; /* FIXME: value correct?? */
+    DeviceExtension->CursorVisible = TRUE;
+
+    /* more initialization */
+    DeviceExtension->CharAttribute = 0x17;  /* light grey on blue */
+    DeviceExtension->Mode = ENABLE_PROCESSED_OUTPUT |
+                            ENABLE_WRAP_AT_EOL_OUTPUT;
+
+    /* show blinking cursor */
+    __asm__("cli\n\t");
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORSTART);
+    WRITE_PORT_UCHAR (CRTC_DATA, (DeviceExtension->ScanLines - 1) & 0x1F);
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSOREND);
+    data = READ_PORT_UCHAR (CRTC_DATA) & 0xE0;
+    WRITE_PORT_UCHAR (CRTC_DATA,
+                      data | ((DeviceExtension->ScanLines - 1) & 0x1F));
+    __asm__("sti\n\t");
+
+    Status = STATUS_SUCCESS;
+
+    Irp->IoStatus.Status = Status;
+    IoCompleteRequest (Irp, IO_NO_INCREMENT);
+
+    return (Status);
+}
+
+
+NTSTATUS
+ScrWrite (PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+    PIO_STACK_LOCATION stk = IoGetCurrentIrpStackLocation (Irp);
+    PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
+    NTSTATUS Status;
+    char *pch = Irp->UserBuffer;
+    char *vidmem;
+    int i, j, offset;
+    int cursorx, cursory;
+    int rows, columns;
+    int processed = DeviceExtension->Mode & ENABLE_PROCESSED_OUTPUT;
+
+    vidmem  = DeviceExtension->VideoMemory;
+    rows = DeviceExtension->Rows;
+    columns = DeviceExtension->Columns;
+
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
+    offset = READ_PORT_UCHAR (CRTC_DATA)<<8;
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
+    offset += READ_PORT_UCHAR (CRTC_DATA);
+
+    cursory = offset / columns;
+    cursorx = offset % columns;
+    if( processed == 0 )
+       {
+	  /* raw output mode */
+	  memcpy( &vidmem[(cursorx * 2) + (cursory * columns * 2)], pch, stk->Parameters.Write.Length );
+	  offset += (stk->Parameters.Write.Length / 2);
+       }
+    else {
+       for (i = 0; i < stk->Parameters.Write.Length; i++, pch++)
+	  {
+	     switch (*pch)
+		{
+		case '\b':
+		   if (cursorx > 0)
+		      {
+			 cursorx--;
+		      }
+		   else if (cursory > 0)
+		      {
+			 cursorx = columns - 1;
+			 cursory--;
+		      }
+		   vidmem[(cursorx * 2) + (cursory * columns * 2)] = ' ';
+		   vidmem[(cursorx * 2) + (cursory * columns * 2) + 1] = (char) DeviceExtension->CharAttribute;
+		   break;
+		   
+		case '\n':
+		   cursory++;
+		   cursorx = 0;
+		   break;
+		   
+		case '\r':
+		   break;
+		   
+		case '\t':
+		   offset = TAB_WIDTH - (cursorx % TAB_WIDTH);
+		   for (j = 0; j < offset; j++)
+		      {
+			 vidmem[(cursorx * 2) + (cursory * columns * 2)] = ' ';
+			 cursorx++;
+			 
+			 if (cursorx >= columns)
+			    {
+			       cursory++;
+			       cursorx = 0;
+			    }
+		      }
+		   break;
+		   
+		default:
+		   vidmem[(cursorx * 2) + (cursory * columns * 2)] = *pch;
+		   vidmem[(cursorx * 2) + (cursory * columns * 2) + 1] = (char) DeviceExtension->CharAttribute;
+		   cursorx++;
+		   if (cursorx >= columns)
+		      {
+			 cursory++;
+			 cursorx = 0;
+		      }
+		   break;
+		}
+	     if (cursory >= rows)
+		{
+		   unsigned short *LinePtr;
+
+		   memcpy (vidmem,
+			   &vidmem[columns * 2],
+			   columns * (rows - 1) * 2);
+
+		   LinePtr = (unsigned short *) &vidmem[columns * (rows - 1) * 2];
+
+		   for (j = 0; j < columns; j++)
+		      {
+			 LinePtr[j] = DeviceExtension->CharAttribute << 8;
+		      }
+		   cursory = rows - 1;
+		   for (j = 0; j < columns; j++)
+		      {
+			 vidmem[(j * 2) + (cursory * columns * 2)] = ' ';
+			 vidmem[(j * 2) + (cursory * columns * 2) + 1] = (char)DeviceExtension->CharAttribute;
+		      }
+		}
+	  }
+       
+       /* Set the cursor position */
+       offset = (cursory * columns) + cursorx;
+    }
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
+    WRITE_PORT_UCHAR (CRTC_DATA, offset);
+    WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
+    offset >>= 8;
+    WRITE_PORT_UCHAR (CRTC_DATA, offset);
+
+    Status = STATUS_SUCCESS;
+
+    Irp->IoStatus.Status = Status;
+    IoCompleteRequest (Irp, IO_NO_INCREMENT);
+
+    return (Status);
+}
+
+
+NTSTATUS
+ScrIoControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+    PIO_STACK_LOCATION stk = IoGetCurrentIrpStackLocation (Irp);
+    PDEVICE_EXTENSION DeviceExtension;
+    NTSTATUS Status;
+
+    DeviceExtension = DeviceObject->DeviceExtension;
+
+    switch (stk->Parameters.DeviceIoControl.IoControlCode)
+    {
+        case IOCTL_CONSOLE_GET_SCREEN_BUFFER_INFO:
+            {
+                PCONSOLE_SCREEN_BUFFER_INFO pcsbi = (PCONSOLE_SCREEN_BUFFER_INFO)Irp->AssociatedIrp.SystemBuffer;
+                int rows = DeviceExtension->Rows;
+                int columns = DeviceExtension->Columns;
+                unsigned int offset;
+
+                /* read cursor position from crtc */
+                __asm__("cli\n\t");
+                WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
+                offset = READ_PORT_UCHAR (CRTC_DATA);
+                WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
+                offset += (READ_PORT_UCHAR (CRTC_DATA) << 8);
+                __asm__("sti\n\t");
+
+                pcsbi->dwSize.X = columns;
+                pcsbi->dwSize.Y = rows;
+
+                pcsbi->dwCursorPosition.X = (SHORT)(offset % columns);
+                pcsbi->dwCursorPosition.Y = (SHORT)(offset / columns);
+
+                pcsbi->wAttributes = DeviceExtension->CharAttribute;
+
+                pcsbi->srWindow.Left   = 0;
+                pcsbi->srWindow.Right  = columns - 1;
+                pcsbi->srWindow.Top    = 0;
+                pcsbi->srWindow.Bottom = rows - 1;
+
+                pcsbi->dwMaximumWindowSize.X = columns;
+                pcsbi->dwMaximumWindowSize.Y = rows;
+
+                Irp->IoStatus.Information = sizeof (CONSOLE_SCREEN_BUFFER_INFO);
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+        case IOCTL_CONSOLE_SET_SCREEN_BUFFER_INFO:
+            {
+                PCONSOLE_SCREEN_BUFFER_INFO pcsbi = (PCONSOLE_SCREEN_BUFFER_INFO)Irp->AssociatedIrp.SystemBuffer;
+                unsigned int offset;
+
+                DeviceExtension->CharAttribute = pcsbi->wAttributes;
+                offset = (pcsbi->dwCursorPosition.Y * DeviceExtension->Columns) +
+                          pcsbi->dwCursorPosition.X;
+
+                __asm__("cli\n\t");
+                WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
+                WRITE_PORT_UCHAR (CRTC_DATA, offset);
+                WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
+                WRITE_PORT_UCHAR (CRTC_DATA, offset>>8);
+                __asm__("sti\n\t");
+
+                Irp->IoStatus.Information = 0;
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+        case IOCTL_CONSOLE_GET_CURSOR_INFO:
+            {
+                PCONSOLE_CURSOR_INFO pcci = (PCONSOLE_CURSOR_INFO)Irp->AssociatedIrp.SystemBuffer;
+
+                pcci->dwSize = DeviceExtension->CursorSize;
+                pcci->bVisible = DeviceExtension->CursorVisible;
+
+                Irp->IoStatus.Information = sizeof (CONSOLE_CURSOR_INFO);
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+        case IOCTL_CONSOLE_SET_CURSOR_INFO:
+            {
+                PCONSOLE_CURSOR_INFO pcci = (PCONSOLE_CURSOR_INFO)Irp->AssociatedIrp.SystemBuffer;
+                BYTE data, value;
+                DWORD size, height;
+
+                DeviceExtension->CursorSize = pcci->dwSize;
+                DeviceExtension->CursorVisible = pcci->bVisible;
+                height = DeviceExtension->ScanLines;
+                data = (pcci->bVisible) ? 0x40 : 0x20;
+
+                size = (pcci->dwSize * height) / 100;
+                if (size < 1)
+                    size = 1;
+
+                data |= (BYTE)(height - size);
+
+                __asm__("cli\n\t");
+                WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORSTART);
+                WRITE_PORT_UCHAR (CRTC_DATA, data);
+                WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSOREND);
+                value = READ_PORT_UCHAR (CRTC_DATA) & 0xE0;
+                WRITE_PORT_UCHAR (CRTC_DATA, value | (height - 1));
+
+                __asm__("sti\n\t");
+
+                Irp->IoStatus.Information = 0;
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+        case IOCTL_CONSOLE_GET_MODE:
+            {
+                PCONSOLE_MODE pcm = (PCONSOLE_MODE)Irp->AssociatedIrp.SystemBuffer;
+
+                pcm->dwMode = DeviceExtension->Mode;
+
+                Irp->IoStatus.Information = sizeof(CONSOLE_MODE);
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+        case IOCTL_CONSOLE_SET_MODE:
+            {
+                PCONSOLE_MODE pcm = (PCONSOLE_MODE)Irp->AssociatedIrp.SystemBuffer;
+
+                DeviceExtension->Mode = pcm->dwMode;
+
+                Irp->IoStatus.Information = 0;
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+        case IOCTL_CONSOLE_FILL_OUTPUT_ATTRIBUTE:
+            {
+                POUTPUT_ATTRIBUTE Buf = (POUTPUT_ATTRIBUTE)Irp->AssociatedIrp.SystemBuffer;
+                char *vidmem;
+                int offset;
+                DWORD dwCount;
+
+                vidmem = DeviceExtension->VideoMemory;
+                offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
+                         (Buf->dwCoord.X * 2) + 1;
+
+                for (dwCount = 0; dwCount < Buf->nLength; dwCount++)
+                {
+                    vidmem[offset + (dwCount * 2)] = (char) Buf->wAttribute;
+                }
+
+                Buf->dwTransfered = Buf->nLength;
+                
+                Irp->IoStatus.Information = 0;
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+        case IOCTL_CONSOLE_READ_OUTPUT_ATTRIBUTE:
+            {
+                POUTPUT_ATTRIBUTE Buf = (POUTPUT_ATTRIBUTE)Irp->AssociatedIrp.SystemBuffer;
+                PWORD pAttr = (PWORD)MmGetSystemAddressForMdl(Irp->MdlAddress);
+                char *vidmem;
+                int offset;
+                DWORD dwCount;
+
+                vidmem = DeviceExtension->VideoMemory;
+                offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
+                         (Buf->dwCoord.X * 2) + 1;
+
+                for (dwCount = 0; dwCount < stk->Parameters.Write.Length; dwCount++, pAttr++)
+                {
+                    (char) *pAttr = vidmem[offset + (dwCount * 2)];
+                }
+
+                Buf->dwTransfered = dwCount;
+
+                Irp->IoStatus.Information = sizeof(OUTPUT_ATTRIBUTE);
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+        case IOCTL_CONSOLE_WRITE_OUTPUT_ATTRIBUTE:
+            {
+                POUTPUT_ATTRIBUTE Buf = (POUTPUT_ATTRIBUTE)Irp->AssociatedIrp.SystemBuffer;
+                PWORD pAttr = (PWORD)MmGetSystemAddressForMdl(Irp->MdlAddress);
+                char *vidmem;
+                int offset;
+                DWORD dwCount;
+
+                vidmem = DeviceExtension->VideoMemory;
+                offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
+                         (Buf->dwCoord.X * 2) + 1;
+
+                for (dwCount = 0; dwCount < stk->Parameters.Write.Length; dwCount++, pAttr++)
+                {
+                    vidmem[offset + (dwCount * 2)] = (char) *pAttr;
+                }
+
+                Buf->dwTransfered = dwCount;
+
+                Irp->IoStatus.Information = sizeof(OUTPUT_ATTRIBUTE);
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+        case IOCTL_CONSOLE_SET_TEXT_ATTRIBUTE:
+            DeviceExtension->CharAttribute = (WORD)*(PWORD)Irp->AssociatedIrp.SystemBuffer;
+            Irp->IoStatus.Information = 0;
+            Status = STATUS_SUCCESS;
+            break;
+
+
+        case IOCTL_CONSOLE_FILL_OUTPUT_CHARACTER:
+            {
+                POUTPUT_CHARACTER Buf = (POUTPUT_CHARACTER)Irp->AssociatedIrp.SystemBuffer;
+                char *vidmem;
+                int offset;
+                DWORD dwCount;
+
+                vidmem = DeviceExtension->VideoMemory;
+                offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
+                         (Buf->dwCoord.X * 2);
+
+                CHECKPOINT
+
+                for (dwCount = 0; dwCount < Buf->nLength; dwCount++)
+                {
+                    vidmem[offset + (dwCount * 2)] = (char) Buf->cCharacter;
+                }
+
+                Buf->dwTransfered = Buf->nLength;
+
+                Irp->IoStatus.Information = 0;
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+        case IOCTL_CONSOLE_READ_OUTPUT_CHARACTER:
+            {
+                POUTPUT_CHARACTER Buf = (POUTPUT_CHARACTER)Irp->AssociatedIrp.SystemBuffer;
+                LPSTR pChar = (LPSTR)MmGetSystemAddressForMdl(Irp->MdlAddress);
+                char *vidmem;
+                int offset;
+                DWORD dwCount;
+
+                vidmem = DeviceExtension->VideoMemory;
+                offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
+                         (Buf->dwCoord.X * 2);
+
+                for (dwCount = 0; dwCount < stk->Parameters.Write.Length; dwCount++, pChar++)
+                {
+                    *pChar = vidmem[offset + (dwCount * 2)];
+                }
+
+                Buf->dwTransfered = dwCount;
+
+                Irp->IoStatus.Information = sizeof(OUTPUT_ATTRIBUTE);
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+        case IOCTL_CONSOLE_WRITE_OUTPUT_CHARACTER:
+            {
+                POUTPUT_CHARACTER Buf = (POUTPUT_CHARACTER)Irp->AssociatedIrp.SystemBuffer;
+                LPSTR pChar = (LPSTR)MmGetSystemAddressForMdl(Irp->MdlAddress);
+                char *vidmem;
+                int offset;
+                DWORD dwCount;
+
+                vidmem = DeviceExtension->VideoMemory;
+                offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
+                         (Buf->dwCoord.X * 2) + 1;
+
+                for (dwCount = 0; dwCount < stk->Parameters.Write.Length; dwCount++, pChar++)
+                {
+                    vidmem[offset + (dwCount * 2)] = (char) *pChar;
+                }
+
+                Buf->dwTransfered = dwCount;
+
+                Irp->IoStatus.Information = sizeof(OUTPUT_ATTRIBUTE);
+                Status = STATUS_SUCCESS;
+            }
+            break;
+
+
+        default:
+            Status = STATUS_NOT_IMPLEMENTED;
+    }
+
+    Irp->IoStatus.Status = Status;
+    IoCompleteRequest (Irp, IO_NO_INCREMENT);
+
+    return (Status);
+}
+
+
+NTSTATUS
+ScrDispatch (PDEVICE_OBJECT DeviceObject, PIRP Irp)
+{
+    PIO_STACK_LOCATION stk = IoGetCurrentIrpStackLocation(Irp);
+    NTSTATUS Status;
+
+    switch (stk->MajorFunction)
+    {
+        case IRP_MJ_CLOSE:
+            Status = STATUS_SUCCESS;
+            break;
+
+        default:
+            Status = STATUS_NOT_IMPLEMENTED;
+            break;
+    }
+
+
+    Irp->IoStatus.Status = Status;
+    IoCompleteRequest (Irp, IO_NO_INCREMENT);
+
+    return (Status);
+}
+
+
+/*
+ * Module entry point
+ */
+NTSTATUS
+STDCALL
+DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
+{
+    PDEVICE_OBJECT DeviceObject;
+    UNICODE_STRING DeviceName;
+    UNICODE_STRING SymlinkName;
+
+    DbgPrint ("Screen Driver 0.0.6\n");
+
+    DriverObject->MajorFunction[IRP_MJ_CREATE] = ScrCreate;
+    DriverObject->MajorFunction[IRP_MJ_CLOSE]  = ScrDispatch;
+    DriverObject->MajorFunction[IRP_MJ_READ]   = ScrDispatch;
+    DriverObject->MajorFunction[IRP_MJ_WRITE]  = ScrWrite;
+    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL ] = ScrIoControl;
+
+    RtlInitUnicodeString (&DeviceName, L"\\Device\\BlueScreen");
+    IoCreateDevice (DriverObject,
+                    sizeof(DEVICE_EXTENSION),
+                    &DeviceName,
+                    FILE_DEVICE_SCREEN,
+                    0,
+                    TRUE,
+                    &DeviceObject);
+
+    RtlInitUnicodeString (&SymlinkName, L"\\??\\BlueScreen");
+    IoCreateSymbolicLink (&SymlinkName, &DeviceName);
+
+    return (STATUS_SUCCESS);
+}
+
+/* EOF */

reactos/drivers/dd/blue/blue.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",	"HAL Console Device Driver\0"
+            VALUE "FileVersion",	"0.0.6\0"
+            VALUE "InternalName",	"blue\0"
+            VALUE "LegalCopyright",	RES_STR_LEGAL_COPYRIGHT
+            VALUE "OriginalFilename",	"blue.sys\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/drivers/dd/blue/makefile

@@ -0,0 +1,71 @@
+# $Id: makefile,v 1.11 2000/05/08 23:25:36 ekohl Exp $
+#
+#
+TARGET = blue
+
+BASE_CFLAGS = -I../../../include
+
+OBJECTS = $(TARGET).o $(TARGET).coff ../../../ntoskrnl/ntoskrnl.a
+
+all: $(TARGET).sys
+
+.phony: all
+
+clean:
+	- $(RM) $(TARGET).o
+	- $(RM) $(TARGET).coff
+	- $(RM) junk.tmp
+	- $(RM) base.tmp
+	- $(RM) temp.exp
+	- $(RM) blue.sys
+
+.phony: clean
+
+floppy: $(FLOPPY_DIR)/drivers/$(TARGET).sys
+
+$(FLOPPY_DIR)/drivers/$(TARGET).sys: $(TARGET).sys
+ifeq ($(DOSCLI),yes)
+	$(CP) $(TARGET).sys $(FLOPPY_DIR)\drivers\$(TARGET).sys
+else
+	$(CP) $(TARGET).sys $(FLOPPY_DIR)/drivers/$(TARGET).sys
+endif
+
+dist: ../../../$(DIST_DIR)/drivers/$(TARGET).sys
+
+../../../$(DIST_DIR)/drivers/$(TARGET).sys: $(TARGET).sys
+ifeq ($(DOSCLI),yes)
+	$(CP) $(TARGET).sys ..\..\..\$(DIST_DIR)\drivers\$(TARGET).sys
+else
+	$(CP) $(TARGET).sys ../../../$(DIST_DIR)/drivers/$(TARGET).sys
+endif
+
+$(TARGET).sys: $(OBJECTS)
+	$(CC) \
+		-specs=../../svc_specs \
+		-mdll \
+		-o junk.tmp \
+		-Wl,--defsym,_end=end \
+		-Wl,--defsym,_edata=__data_end__ \
+		-Wl,--defsym,_etext=etext \
+		-Wl,--base-file,base.tmp \
+		$(OBJECTS)
+	- $(RM) junk.tmp
+	$(DLLTOOL) \
+		--dllname $(TARGET).sys \
+		--base-file base.tmp \
+		--output-exp temp.exp \
+		--kill-at
+	- $(RM) base.tmp
+	$(CC) \
+		--verbose \
+		-Wl,--image-base,0x10000 \
+		-Wl,-e,_DriverEntry@8 \
+		-Wl,temp.exp \
+		-specs=../../svc_specs \
+		-mdll \
+		-o $(TARGET).sys \
+		$(OBJECTS)
+	- $(RM) temp.exp
+
+
+include ../../../rules.mak

reactos/drivers/dd/event/dirs

@@ -0,0 +1,2 @@
+DIRS=exe    \
+     sys

reactos/drivers/dd/event/exe/eventtes.c

@@ -0,0 +1,168 @@
+/*++
+
+Copyright (c) 1996  Microsoft Corporation
+
+Module Name:
+
+    EventTest.c
+
+Abstract:
+
+    Simple console test app demonstrating how a Win32 app can share 
+    an event object with a kernel-mode driver. For more information 
+    on using Event Objects at the application level see the Win32 SDK.
+
+Author:
+
+    Jeff Midkiff    (jeffmi)    23-Jul-96
+
+Enviroment:
+
+    User Mode
+
+Revision History:
+
+--*/
+
+
+//
+// INCLUDES
+//
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <winioctl.h>
+#include <conio.h>
+
+#include "event.h"
+
+
+//
+// MAIN
+//
+void __cdecl 
+main(
+    int argc, 
+    char ** argv
+    )
+{
+    BOOL    bStatus;
+    HANDLE  hDevice;
+    ULONG   ulReturnedLength;
+
+    SET_EVENT setEvent;
+    FLOAT fDelay;
+    
+
+    if ( (argc < 2) || (argv[1] == NULL) ) {
+        printf("event <delay>\n");
+        printf("\twhere <delay> = time to delay the event signal in seconds.\n");
+        exit(0);
+    }
+    sscanf( argv[1], "%f", &fDelay );
+
+    //
+    // open the device
+    //
+    hDevice = CreateFile(
+                "\\\\.\\EVENT",                     // lpFileName
+                GENERIC_READ | GENERIC_WRITE,       // dwDesiredAccess
+                FILE_SHARE_READ | FILE_SHARE_WRITE, // dwShareMode
+                NULL,                               // lpSecurityAttributes
+                OPEN_EXISTING,                      // dwCreationDistribution
+                0,                                  // dwFlagsAndAttributes
+                NULL                                // hTemplateFile
+                );
+                
+    if (hDevice == INVALID_HANDLE_VALUE) {
+        printf("CreateFile error = %d\n", GetLastError() );
+        exit(0);
+    }
+
+
+    //
+    // set the event signal delay
+    //
+    setEvent.DueTime.QuadPart = -((LONGLONG)(fDelay * 10.0E6));// use relative time for this sample
+
+
+    //
+    // test the driver for bad event handles
+    //
+    setEvent.hEvent = NULL;
+    bStatus = DeviceIoControl(
+                        hDevice,                // Handle to device
+                        IOCTL_SET_EVENT,        // IO Control code
+                        &setEvent,              // Input Buffer to driver.
+                        SIZEOF_SETEVENT,        // Length of input buffer in bytes.
+                        NULL,                   // Output Buffer from driver.
+                        0,                      // Length of output buffer in bytes.
+                        &ulReturnedLength,      // Bytes placed in buffer.
+                        NULL                    // synchronous call
+                        );
+    if ( !bStatus ) {
+        printf("Bad handle TEST returned code %d.\n\n", GetLastError() );
+    } else {
+        printf("we should never get here\n");
+        exit(0);
+    }
+
+
+    //
+    // 
+    //
+    setEvent.hEvent = CreateEvent( 
+                            NULL,   // lpEventAttributes
+                            TRUE,   // bManualReset
+                            FALSE,  // bInitialState
+                            NULL    // lpName
+                            );
+
+
+    if ( !setEvent.hEvent ) {
+        printf("CreateEvent error = %d\n", GetLastError() );
+    } else {
+
+        printf("Event HANDLE = 0x%x\n",  setEvent.hEvent );
+        printf("Press any key to exit.\n");
+        while( !_kbhit() ) {
+            bStatus = DeviceIoControl(
+                            hDevice,                // Handle to device
+                            IOCTL_SET_EVENT,        // IO Control code
+                            &setEvent,              // Input Buffer to driver.
+                            SIZEOF_SETEVENT,        // Length of input buffer in bytes.
+                            NULL,                   // Output Buffer from driver.
+                            0,                      // Length of output buffer in bytes.
+                            &ulReturnedLength,      // Bytes placed in buffer.
+                            NULL                    // synchronous call
+                            );
+
+            if ( !bStatus ) {
+                printf("Ioctl failed with code %d\n", GetLastError() );
+                break;
+            } else {
+                printf("Waiting for Event...\n");
+
+                WaitForSingleObject(setEvent.hEvent,
+                                    INFINITE );
+
+                printf("Event signalled.\n\n");
+
+                ResetEvent( setEvent.hEvent);
+                //printf("Event reset.\n");
+            }
+        }
+    }
+
+    //
+    // close the driver
+    //
+    if ( !CloseHandle(hDevice) )     {
+        printf("Failed to close device.\n");
+    }
+
+    exit(0);
+}
+
+
+// EOF

reactos/drivers/dd/event/exe/makefile

@@ -0,0 +1,7 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the driver components of the Windows NT DDK
+#
+
+!INCLUDE $(NTMAKEENV)\makefile.def

reactos/drivers/dd/event/exe/sources

@@ -0,0 +1,10 @@
+TARGETNAME=event
+TARGETPATH=$(BASEDIR)\lib
+TARGETTYPE=PROGRAM
+
+INCLUDES=..\sys
+
+SOURCES=eventtest.c
+
+UMTYPE=console
+UMBASE=0x100000

reactos/drivers/dd/event/readme.txt

@@ -0,0 +1,50 @@
+
+This sample demonstrates one way that a Windows NT kernel-mode device driver
+can share and explicitly signal an Event Object with a Win32 application.
+It is composed of two parts, a Windows NT kernel-mode device driver and a Win32 
+console test application. Both are built using the Windows NT DDK.
+
+
+Instructions:
+-------------
+
+1) Build the driver and test application in either the FREE or CHECKED build environment:
+
+        BLD
+
+    Both the driver and application are put in %NTDDK%\LIB\*\FREE | CHECKED on your build machine.
+
+
+2) Copy the newly built driver to your Target machine's %SystemRoot%\system32\drivers
+directory. Copy the newly built application to your target machine.
+Also copy the EVENT.INI file to your Target machine.
+
+
+3) Update the Target machine's Registry by running REGINI.EXE on the EVENT.INI file, i.e.:
+
+        REGINI EVENT.INI
+
+   This adds a driver key under the 
+   HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services tree in the Registry.
+   You can verify this by running REGEDIT32.EXE and looking at the \Event key.
+
+
+4) Reboot the Target machine for the Registry changes to take effect.
+Your driver will not load until you reboot.
+
+
+5) Load the driver from the command line:
+
+        NET START EVENT
+
+
+6) Run the test app from the command line:
+
+        EVENT <DELAY>
+
+            where DELAY = time to delay the Event signal in seconds.
+
+
+7) Unload the driver from the command line:
+    
+        NET STOP EVENT

reactos/drivers/dd/event/sys/event.c

@@ -0,0 +1,447 @@
+/*++
+
+Copyright (c) 1996  Microsoft Corporation
+
+Module Name:
+
+    Event.c
+
+Abstract:
+
+    This sample demonstrates one way that a Windows NT kernel-mode driver
+    can share and explicitly signal an Event Object with a Win32 application.
+
+    This sample uses the following method:
+        The application creates an event object using CreateEvent().
+        The app passes the event handle to the driver in a private IOCTL.
+        The driver is running in the app's thread context during the IOCTL so 
+        there is a valid user-mode handle at that time.
+        The driver dereferences the user-mode handle into system space & saves 
+        the new system handle for later use.
+        The driver signals the event via KeSetEvent() at IRQL <= DISPATCH_LEVEL.
+        The driver MUST delete any driver references to the event object at 
+        Unload time.
+
+    An alternative method would be to create a named event in the driver via 
+    IoCreateNotificationEvent and then open the event in user mode. This API 
+    however is new to Windows NT 4.0 so you can not use this method in your 
+    NT 3.5x drivers.
+    
+    Note that this sample's event can be signalled (almost) at will from within 
+    the driver. A different event signal can be set when the driver is setup to 
+    do asynchronous I/O, and it is opened with FILE_FLAG_OVERLAPPED, and an 
+    event handle is passed down in an OVERLAPPED struct from the app's Read, 
+    Write, or DeviceIoControl. This different event signal is set by the I/O 
+    Manager when the driver calls IoCompleteRequest on a pending Irp. This type 
+    of Irp completion signal is not the purpose of this sample, hence the lack of
+    Irp queing.
+
+Author:
+
+    Jeff Midkiff    (jeffmi)    23-Jul-96
+
+Enviroment:
+
+    Kernel Mode Only
+
+Revision History:
+
+--*/
+
+
+//
+// INCLUDES
+//
+#include "ntddk.h"
+#include "event.h"
+
+//
+// DEFINES
+//
+#define USER_NAME       L"\\DosDevices\\EVENT"
+#define SYSTEM_NAME     L"\\Device\\EVENT"
+
+//
+// DATA
+//
+typedef struct _DEVICE_EXTENSION {
+    KDPC    Dpc;
+    KTIMER  Timer;
+    HANDLE  hEvent;
+
+} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
+
+
+//
+// PROTOS
+//
+NTSTATUS
+DriverEntry(
+    IN PDRIVER_OBJECT DriverObject,
+    IN PUNICODE_STRING RegistryPath
+    );
+
+NTSTATUS
+Unload(
+    IN PDRIVER_OBJECT DriverObject
+    );
+
+NTSTATUS
+Dispatch(
+    IN PDEVICE_OBJECT DeviceObject,
+    IN PIRP Irp
+    );
+
+VOID
+CustomTimerDPC(
+    IN PKDPC Dpc,
+    IN PVOID DeferredContext,
+    IN PVOID SystemArgument1,
+    IN PVOID SystemArgument2
+    );
+
+
+NTSTATUS
+DriverEntry(
+    IN PDRIVER_OBJECT  DriverObject,
+    IN PUNICODE_STRING RegistryPath
+    )
+
+/*++
+
+Routine Description:
+
+    This routine gets called by the system to initialize the driver.
+
+Arguments:
+
+    DriverObject    - the system supplied driver object.
+    RegistryPath    - the system supplied registry path for this driver.
+
+Return Value:
+
+    NTSTATUS
+
+--*/
+
+{
+
+    PDEVICE_OBJECT      pDeviceObject;
+    PDEVICE_EXTENSION   pDeviceExtension;
+
+    UNICODE_STRING      usSystemName;
+    UNICODE_STRING      usUserName;
+
+    NTSTATUS            status;
+
+
+    KdPrint(("Event!DriverEntry - IN\n"));
+
+    //
+    // create the device object
+    //
+    RtlInitUnicodeString( &usSystemName, SYSTEM_NAME );
+
+    status = IoCreateDevice( 
+                DriverObject,               // DriverObject 
+                sizeof( DEVICE_EXTENSION ), // DeviceExtensionSize
+                &usSystemName,              // DeviceName
+                FILE_DEVICE_UNKNOWN,        // DeviceType
+                0,                          // DeviceCharacteristics
+                TRUE,                       // Exclusive
+                &pDeviceObject              // DeviceObject
+                );
+
+    if ( !NT_SUCCESS(status) ) {
+        KdPrint(("\tIoCreateDevice returned 0x%x\n", status));
+
+        return( status );
+    }
+
+    //
+    // Set up dispatch entry points for the driver.
+    //
+    DriverObject->MajorFunction[IRP_MJ_CREATE]          =
+    DriverObject->MajorFunction[IRP_MJ_CLOSE]           =
+    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]  = Dispatch;
+    DriverObject->DriverUnload = Unload;
+
+    //
+    // Create a symbolic link into user mode for the driver.
+    //
+    RtlInitUnicodeString( &usUserName, USER_NAME );
+    status = IoCreateSymbolicLink( &usUserName, &usSystemName );
+
+    if ( !NT_SUCCESS(status) ) {
+        IoDeleteDevice( pDeviceObject );
+        KdPrint(("\tIoCreateSymbolicLink returned 0x%x\n", status));
+
+        return( status );
+    }
+
+    //
+    // establish user-buffer access method
+    //
+    pDeviceObject->Flags |= DO_BUFFERED_IO;
+
+
+    //
+    // setup the device extension
+    //
+    pDeviceExtension = pDeviceObject->DeviceExtension;
+
+    KeInitializeDpc(
+        &pDeviceExtension->Dpc, // Dpc
+        CustomTimerDPC,         // DeferredRoutine
+        pDeviceObject           // DeferredContext
+        ); 
+
+    KeInitializeTimer(
+        &pDeviceExtension->Timer  // Timer
+        );
+
+    pDeviceExtension->hEvent = NULL;
+
+    KdPrint(("Event!DriverEntry - OUT\n"));
+
+    return( status );
+}
+
+
+
+NTSTATUS
+Unload(
+    IN PDRIVER_OBJECT DriverObject
+    )
+
+/*++
+
+Routine Description:
+
+    This routine gets called to remove the driver from the system.
+
+Arguments:
+
+    DriverObject    - the system supplied driver object.
+
+Return Value:
+
+    NTSTATUS
+
+--*/
+
+{
+
+    PDEVICE_OBJECT       pDeviceObject = DriverObject->DeviceObject;
+    PDEVICE_EXTENSION    pDeviceExtension = pDeviceObject->DeviceExtension;
+    UNICODE_STRING       usUserName;
+
+
+    KdPrint(("Event!Unload\n"));
+
+    //
+    // dereference the event object or it will NEVER go away until reboot
+    //
+    if ( pDeviceExtension->hEvent )
+    ObDereferenceObject( pDeviceExtension->hEvent );
+
+    // Delete the user-mode symbolic link.
+    RtlInitUnicodeString( &usUserName, USER_NAME );
+    IoDeleteSymbolicLink( &usUserName );
+
+    // Delete the DeviceObject
+    IoDeleteDevice( pDeviceObject );
+
+    return( STATUS_SUCCESS );
+}
+
+
+
+NTSTATUS
+Dispatch(
+    IN PDEVICE_OBJECT DeviceObject,
+    IN PIRP Irp
+    )
+
+/*++
+
+Routine Description:
+
+    This device control dispatcher handles IOCTLs.
+
+Arguments:
+
+    DeviceObject - Context for the activity.
+    Irp          - The device control argument block.
+
+Return Value:
+
+    NTSTATUS
+
+--*/
+
+{
+
+    PDEVICE_EXTENSION   pDeviceExtension;
+    PIO_STACK_LOCATION  pIrpStack;
+    PSET_EVENT          pSetEvent;
+
+    ULONG               ulInformation = 0L;
+    NTSTATUS            status = STATUS_NOT_IMPLEMENTED;
+
+
+    KdPrint(("Event!Dispatch - IN\n"));
+
+    pDeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
+    pIrpStack = IoGetCurrentIrpStackLocation( Irp );
+
+    switch( pIrpStack->MajorFunction )
+    {
+        case IRP_MJ_CREATE:
+        case IRP_MJ_CLOSE:
+            KdPrint(("\t%s\n", (IRP_MJ_CREATE == pIrpStack->MajorFunction) ? "IRP_MJ_CREATE" : "IRP_MJ_CLOSE"));
+
+            status = STATUS_SUCCESS;
+            break;
+
+        case IRP_MJ_DEVICE_CONTROL:
+            switch( pIrpStack->Parameters.DeviceIoControl.IoControlCode )
+            {
+                case IOCTL_SET_EVENT:
+                    KdPrint(("\tIOCTL_SET_EVENT\n"));
+
+                    if ( pIrpStack->Parameters.DeviceIoControl.InputBufferLength <  SIZEOF_SETEVENT ) {
+                        // Parameters are invalid
+                        KdPrint(("\tSTATUS_INVALID_PARAMETER\n"));
+
+                        status = STATUS_INVALID_PARAMETER;
+                    } else {
+                        pSetEvent = (PSET_EVENT)Irp->AssociatedIrp.SystemBuffer;
+                        KdPrint(("\tuser-mode HANDLE = 0x%x\n",  pSetEvent->hEvent ));
+
+                        status = ObReferenceObjectByHandle( pSetEvent->hEvent,
+                                                            SYNCHRONIZE,
+                                                            NULL,
+                                                            KernelMode,
+                                                            &pDeviceExtension->hEvent,
+                                                            NULL
+                                                            );
+                        if ( !NT_SUCCESS(status) ) {
+
+                            KdPrint(("\tUnable to reference User-Mode Event object, Error = 0x%x\n", status));
+
+                        } else {
+                        
+                            KdPrint(("\tkernel-mode HANDLE = 0x%x\n",  pDeviceExtension->hEvent ));
+
+                            //
+                            // Start the timer to run the CustomTimerDPC in DueTime seconds to
+                            // simulate an interrupt (which would queue a DPC).
+                            // The user's event object is signaled in the DPC.
+                            //
+
+                            // ensure relative time for this sample
+                            if ( pSetEvent->DueTime.QuadPart > 0 )
+                                pSetEvent->DueTime.QuadPart = -(pSetEvent->DueTime.QuadPart);
+                            KdPrint(("\tDueTime  = %d\n",  pSetEvent->DueTime.QuadPart ));
+
+                            KeSetTimer(
+                                &pDeviceExtension->Timer,   // Timer
+                                pSetEvent->DueTime,         // DueTime
+                                &pDeviceExtension->Dpc      // Dpc  
+                                );
+
+                           status = STATUS_SUCCESS;
+                        }
+                    }
+                    break;
+
+                default:
+                    // should never hit this
+                    ASSERT(0);
+                    status = STATUS_NOT_IMPLEMENTED;
+                    break;
+
+            } // switch IoControlCode
+            break;
+
+        default:
+            // should never hit this
+            ASSERT(0);
+            status = STATUS_NOT_IMPLEMENTED;
+            break;
+
+    } // switch MajorFunction
+
+
+    //
+    // complete the Irp
+    //
+    Irp->IoStatus.Status = status;
+    Irp->IoStatus.Information = ulInformation;
+    IoCompleteRequest( Irp, IO_NO_INCREMENT );
+
+    KdPrint(("Event!Dispatch - OUT\n"));
+    return status;
+}
+
+
+
+VOID
+CustomTimerDPC(
+    IN PKDPC Dpc,
+    IN PVOID DeferredContext,
+    IN PVOID SystemArgument1,
+    IN PVOID SystemArgument2
+    )
+
+/*++
+
+Routine Description:
+
+    This is the DPC associated with this drivers Timer object setup in DriverEntry.
+
+Arguments:
+
+    Dpc             -   our DPC object associated with our Timer
+    DeferredContext -   Context for the DPC that we setup in DriverEntry
+    SystemArgument1 -
+    SystemArgument2 -
+
+Return Value:
+
+    Nothing.
+
+--*/
+
+{
+
+    PDEVICE_OBJECT      pDeviceObject = DeferredContext;
+    PDEVICE_EXTENSION   pDeviceExtension = pDeviceObject->DeviceExtension;
+
+
+    KdPrint(("Event!CustomTimerDPC - IN\n"));
+
+    //
+    // Signal the Event created user-mode
+    //
+    // Note:  
+    // Do not call KeSetEvent from your ISR;
+    // you must call it at IRQL <= DISPATCH_LEVEL.
+    // Your ISR should queue a DPC and the DPC can
+    // then call KeSetEvent on the ISR's behalf.
+    //
+    KeSetEvent((PKEVENT)pDeviceExtension->hEvent,// Event
+                0,                                   // Increment
+                FALSE                                // Wait
+                );
+
+    // there is no Irp to complete here
+
+    KdPrint(("Event!CustomTimerDPC - OUT\n"));
+
+    return;
+}
+
+
+// EOF

reactos/drivers/dd/event/sys/event.h

@@ -0,0 +1,43 @@
+/*++
+
+Copyright (c) 1996  Microsoft Corporation
+
+Module Name:
+
+   Event.h
+
+Abstract:
+
+
+Author:
+
+   Jeff Midkiff    (jeffmi)    23-Jul-96
+
+Enviroment:
+
+
+Revision History:
+
+--*/
+
+#ifndef __EVENT__
+#define __EVENT__
+
+
+#include "devioctl.h"
+
+typedef struct _SET_EVENT
+{
+    HANDLE  hEvent;
+    LARGE_INTEGER DueTime; // requested DueTime in 100-nanosecond units
+
+} SET_EVENT, *PSET_EVENT;
+
+#define SIZEOF_SETEVENT sizeof(SET_EVENT)
+
+
+#define IOCTL_SET_EVENT \
+   CTL_CODE( FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED, FILE_ANY_ACCESS )
+
+
+#endif // __EVENT__

reactos/drivers/dd/event/sys/event.ini

@@ -0,0 +1,7 @@
+; note - the service name matches the driver's file (.sys) name
+
+\Registry\Machine\System\CurrentControlSet\Services\Event
+    Type = REG_DWORD 0x00000001
+    Start = REG_DWORD 0x00000003
+    Group = Extended Base
+    ErrorControl = REG_DWORD 0x00000001

reactos/drivers/dd/event/sys/event.rc

@@ -0,0 +1,11 @@
+#include <windows.h>
+
+#include <ntverp.h>
+
+#define	VER_FILETYPE	            VFT_DRV
+#define	VER_FILESUBTYPE	            VFT2_DRV_SYSTEM
+#define VER_FILEDESCRIPTION_STR     "Sample Event Driver"
+#define VER_INTERNALNAME_STR        "event.sys"
+
+#include "common.ver"
+

reactos/drivers/dd/event/sys/makefile

@@ -0,0 +1,7 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the driver components of the Windows NT DDK
+#
+
+!INCLUDE $(NTMAKEENV)\makefile.def