Some named pipe improvements (not usable yet!).

svn path=/trunk/; revision=1902

reactos/apps/tests/nptest/npclient.c

@@ -2,11 +2,12 @@
 
 VOID MyErrExit(LPTSTR Message)
 {
-	MessageBox(NULL, Message, NULL, MB_OK);
+//	MessageBox(NULL, Message, NULL, MB_OK);
+   puts(Message);
    ExitProcess(0);
 }
 
-DWORD main(int argc, char *argv[]) 
+int main(int argc, char *argv[])
 {
    HANDLE hPipe;
    LPVOID lpvMessage;

reactos/apps/tests/nptest/npserver.c

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

reactos/drivers/fs/np/Makefile

@@ -1,4 +1,4 @@
-# $Id: Makefile,v 1.5 2001/05/07 22:03:27 chorns Exp $
+# $Id: Makefile,v 1.6 2001/05/10 23:38:31 ekohl Exp $
 #
 # Named Pipes File System
 #
@@ -8,21 +8,25 @@ TARGETNAME=npfs
 
 #BASE_CFLAGS = -I../../../include
 
-OBJECTS = create.o fsctrl.o mount.o rw.o npfs.coff \
+OBJECTS = create.o fsctrl.o mount.o rw.o npfs.coff
-          ../../../ntoskrnl/ntoskrnl.a
+
+LIBS = ../../../ntoskrnl/ntoskrnl.a
 
 all: $(TARGETNAME).sys
 
 .phony: all
 
 clean:
-	- $(RM) create.o 
+	- $(RM) *.o 
-	- $(RM) mount.o
+	- $(RM) npfs.coff
+	- $(RM) junk.tmp
+	- $(RM) base.tmp
+	- $(RM) temp.exp
 	- $(RM) $(TARGETNAME).sys
 
 .phony: clean
 
-$(TARGETNAME).sys: $(OBJECTS)
+$(TARGETNAME).sys: $(OBJECTS) $(LIBS)
 	$(CC) \
 		-specs=../../svc_specs \
 		-mdll \
@@ -31,7 +35,7 @@ $(TARGETNAME).sys: $(OBJECTS)
 		-Wl,--defsym,_edata=__data_end__ \
 		-Wl,--defsym,_etext=etext \
 		-Wl,--base-file,base.tmp \
-		$(OBJECTS)
+		$(OBJECTS) $(LIBS)
 	$(RM) junk.tmp
 	$(DLLTOOL) \
 		--dllname $(TARGETNAME).sys \
@@ -46,9 +50,10 @@ $(TARGETNAME).sys: $(OBJECTS)
 		-specs=../../svc_specs \
 		-mdll \
 		-o $(TARGETNAME).sys \
-		$(OBJECTS) \
+		$(OBJECTS) $(LIBS) \
 		-Wl,temp.exp
 	$(RM) temp.exp
+	$(NM) --numeric-sort npfs.sys > npfs.sym
 
 npfs.coff: ../../../include/reactos/buildno.h npfs.rc
 

reactos/drivers/fs/np/create.c

@@ -1,4 +1,4 @@
-/* $Id: create.c,v 1.5 2001/05/01 11:09:01 ekohl Exp $
+/* $Id: create.c,v 1.6 2001/05/10 23:38:31 ekohl Exp $
  *
  * COPYRIGHT:  See COPYING in the top level directory
  * PROJECT:    ReactOS kernel
@@ -19,17 +19,9 @@
 
 /* GLOBALS *******************************************************************/
 
-static LIST_ENTRY PipeListHead;
-static KMUTEX PipeListLock;
 
 /* FUNCTIONS *****************************************************************/
 
-VOID NpfsInitPipeList(VOID)
-{
-   InitializeListHead(&PipeListHead);
-   KeInitializeMutex(&PipeListLock, 0);
-}
-
 NTSTATUS STDCALL
 NpfsCreate(PDEVICE_OBJECT DeviceObject,
 	   PIRP Irp)
@@ -39,7 +31,6 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
    NTSTATUS Status;
    PNPFS_PIPE Pipe;
    PNPFS_FCB Fcb;
-   PWSTR PipeName;
    PNPFS_PIPE current;
    PLIST_ENTRY current_entry;
    PNPFS_DEVICE_EXTENSION DeviceExt;
@@ -51,8 +42,6 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    FileObject = IoStack->FileObject;
    
-   PipeName = FileObject->FileName.Buffer;
-   
    Fcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_FCB));
    if (Fcb == NULL)
      {
@@ -64,15 +53,17 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
 	return(STATUS_NO_MEMORY);
      }
    
-   KeLockMutex(&PipeListLock);
+   KeLockMutex(&DeviceExt->PipeListLock);
-   current_entry = PipeListHead.Flink;
+   current_entry = DeviceExt->PipeListHead.Flink;
-   while (current_entry != &PipeListHead)
+   while (current_entry != &DeviceExt->PipeListHead)
      {
 	current = CONTAINING_RECORD(current_entry,
 				    NPFS_PIPE,
 				    PipeListEntry);
 	
-	if (wcscmp(Pipe->Name, current->Name) == 0)
+	if (RtlCompareUnicodeString(&Pipe->PipeName,
+				    &current->PipeName,
+				    TRUE) == 0)
 	  {
 	     break;
 	  }
@@ -80,10 +71,10 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
 	current_entry = current_entry->Flink;
      }
    
-   if (current_entry == &PipeListHead)
+   if (current_entry == &DeviceExt->PipeListHead)
      {
 	ExFreePool(Fcb);
-	KeUnlockMutex(&PipeListLock);
+	KeUnlockMutex(&DeviceExt->PipeListLock);
 	
 	Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
 	Irp->IoStatus.Information = 0;
@@ -109,7 +100,10 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
    
    Pipe->ReferenceCount++;
    
-   KeUnlockMutex(&PipeListLock);
+   /* search for unconnected server fcb */
+   
+   
+   KeUnlockMutex(&DeviceExt->PipeListLock);
    
    FileObject->FsContext = Fcb;
    
@@ -121,6 +115,7 @@ NpfsCreate(PDEVICE_OBJECT DeviceObject,
    return(Status);
 }
 
+
 NTSTATUS STDCALL
 NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
 		    PIRP Irp)
@@ -129,7 +124,6 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
    PFILE_OBJECT FileObject;
    NTSTATUS Status = STATUS_SUCCESS;
    PNPFS_DEVICE_EXTENSION DeviceExt;
-   PWSTR PipeName;
    PNPFS_PIPE Pipe;
    PNPFS_FCB Fcb;
    KIRQL oldIrql;
@@ -143,8 +137,6 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    FileObject = IoStack->FileObject;
    
-   PipeName = FileObject->FileName.Buffer;
-   
    Buffer = (PIO_PIPE_CREATE_BUFFER)Irp->Tail.Overlay.AuxiliaryBuffer;
    
    Pipe = ExAllocatePool(NonPagedPool, sizeof(NPFS_PIPE));
@@ -171,9 +163,7 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
 	return(STATUS_NO_MEMORY);
      }
    
-   Pipe->Name = ExAllocatePool(NonPagedPool,
+   if (RtlCreateUnicodeString(&Pipe->PipeName, FileObject->FileName.Buffer) == 0)
-			       (wcslen(PipeName) + 1) * sizeof(WCHAR));
-   if (Pipe->Name == NULL)
      {
 	ExFreePool(Pipe);
 	ExFreePool(Fcb);
@@ -186,7 +176,6 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
 	return(STATUS_NO_MEMORY);
      }
    
-   wcscpy(Pipe->Name, PipeName);
    Pipe->ReferenceCount = 0;
    InitializeListHead(&Pipe->FcbListHead);
    KeInitializeSpinLock(&Pipe->FcbListLock);
@@ -194,15 +183,15 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
    Pipe->MaxInstances = Buffer->MaxInstances;
    Pipe->TimeOut = Buffer->TimeOut;
    
-   KeLockMutex(&PipeListLock);
+   KeLockMutex(&DeviceExt->PipeListLock);
-   current_entry = PipeListHead.Flink;
+   current_entry = DeviceExt->PipeListHead.Flink;
-   while (current_entry != &PipeListHead)
+   while (current_entry != &DeviceExt->PipeListHead)
      {
 	current = CONTAINING_RECORD(current_entry,
 				    NPFS_PIPE,
 				    PipeListEntry);
 	
-	if (wcscmp(Pipe->Name, current->Name) == 0)
+	if (RtlCompareUnicodeString(&Pipe->PipeName, &current->PipeName, TRUE) == 0)
 	  {
 	     break;
 	  }
@@ -210,16 +199,16 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
 	current_entry = current_entry->Flink;
      }
    
-   if (current_entry != &PipeListHead)
+   if (current_entry != &DeviceExt->PipeListHead)
      {
-	ExFreePool(Pipe->Name);
+	RtlFreeUnicodeString(&Pipe->PipeName);
 	ExFreePool(Pipe);
 	
 	Pipe = current;
      }
    else
      {
-	InsertTailList(&PipeListHead, &Pipe->PipeListEntry);
+	InsertTailList(&DeviceExt->PipeListHead, &Pipe->PipeListEntry);
      }
    Pipe->ReferenceCount++;
    
@@ -237,7 +226,11 @@ NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
    Fcb->IsServer = TRUE;
    Fcb->OtherSide = NULL;
    
-   KeUnlockMutex(&PipeListLock);
+   KeInitializeEvent(&Fcb->ConnectEvent,
+		     SynchronizationEvent,
+		     FALSE);
+   
+   KeUnlockMutex(&DeviceExt->PipeListLock);
    
    FileObject->FsContext = Fcb;
    
@@ -254,27 +247,48 @@ NTSTATUS STDCALL
 NpfsClose(PDEVICE_OBJECT DeviceObject,
 	  PIRP Irp)
 {
+   PNPFS_DEVICE_EXTENSION DeviceExt;
    PIO_STACK_LOCATION IoStack;
    PFILE_OBJECT FileObject;
    PNPFS_FCB Fcb;
-   NTSTATUS Status;
+   PNPFS_PIPE Pipe;
+   KIRQL oldIrql;
 
-   DPRINT1("NpfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
+   DPRINT("NpfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
+   DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    FileObject = IoStack->FileObject;
    Fcb =  FileObject->FsContext;
+   Pipe = Fcb->Pipe;
 
-   DPRINT1("Closing pipe %S\n", Fcb->Pipe->Name);
+   DPRINT("Closing pipe %wZ\n", &Pipe->PipeName);
 
-   Status = STATUS_SUCCESS;
+   KeLockMutex(&DeviceExt->PipeListLock);
 
-   Irp->IoStatus.Status = Status;
+   Pipe->ReferenceCount--;
+
+   KeAcquireSpinLock(&Pipe->FcbListLock, &oldIrql);
+   RemoveEntryList(&Fcb->FcbListEntry);
+   KeReleaseSpinLock(&Pipe->FcbListLock, oldIrql);
+   ExFreePool(Fcb);
+   FileObject->FsContext = NULL;
+
+   if (Pipe->ReferenceCount == 0)
+     {
+	RtlFreeUnicodeString(&Pipe->PipeName);
+	RemoveEntryList(&Pipe->PipeListEntry);
+	ExFreePool(Pipe);
+     }
+
+   KeUnlockMutex(&DeviceExt->PipeListLock);
+
+   Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    
-   return(Status);
+   return(STATUS_SUCCESS);
 }
 
 /* EOF */

reactos/drivers/fs/np/fsctrl.c

@@ -1,10 +1,11 @@
-/* $Id: fsctrl.c,v 1.2 2001/05/01 11:09:01 ekohl Exp $
+/* $Id: fsctrl.c,v 1.3 2001/05/10 23:38:31 ekohl Exp $
  *
  * COPYRIGHT:  See COPYING in the top level directory
  * PROJECT:    ReactOS kernel
  * FILE:       services/fs/np/fsctrl.c
  * PURPOSE:    Named pipe filesystem
  * PROGRAMMER: David Welch <welch@cwcom.net>
+ *             Eric Kohl <ekohl@rz-online.de>
  */
 
 /* INCLUDES ******************************************************************/
@@ -18,6 +19,31 @@
 
 /* FUNCTIONS *****************************************************************/
 
+static NTSTATUS
+NpfsConnectPipe(PNPFS_FCB Fcb)
+{
+   NTSTATUS Status;
+
+   Status = KeWaitForSingleObject(&Fcb->ConnectEvent,
+				  UserRequest,
+				  KernelMode,
+				  FALSE,
+				  NULL);
+
+   DPRINT("Finished waiting! Status: %x\n", Status);
+
+
+   return STATUS_SUCCESS;
+}
+
+
+static NTSTATUS
+NpfsDisconnectPipe(PNPFS_FCB Fcb)
+{
+
+   return STATUS_SUCCESS;
+}
+
 NTSTATUS STDCALL
 NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
 		      PIRP Irp)
@@ -29,6 +55,8 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
    PNPFS_PIPE Pipe;
    PNPFS_FCB Fcb;
    
+   DPRINT("NpfsFileSystemContol(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
+   
    DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    IoStack = IoGetCurrentIrpStackLocation(Irp);
    FileObject = IoStack->FileObject;
@@ -37,10 +65,18 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
    
    switch (IoStack->Parameters.FileSystemControl.IoControlCode)
      {
-      case FSCTL_WAIT_PIPE:
+      case FSCTL_PIPE_LISTEN:
+	DPRINT("Connecting pipe %wZ\n", &Pipe->PipeName);
+	Status = NpfsConnectPipe(Fcb);
 	break;
 
-      case FSCTL_LISTEN:
+      case FSCTL_PIPE_DISCONNECT:
+	DPRINT("Disconnecting pipe %wZ\n", &Pipe->PipeName);
+	Status = NpfsDisconnectPipe(Fcb);
+	break;
+
+#if 0
+      case FSCTL_WAIT_PIPE:
 	break;
 	
       case FSCTL_SET_STATE:
@@ -53,9 +89,18 @@ NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
 	     break;
 	  }
 	
+#endif
       default:
-     }
+        DPRINT("IoControlCode: %x\n", IoStack->Parameters.FileSystemControl.IoControlCode)
+        Status = STATUS_UNSUCCESSFUL;
      }
    
+   Irp->IoStatus.Status = Status;
+   Irp->IoStatus.Information = 0;
+   
+   IoCompleteRequest(Irp, IO_NO_INCREMENT);
+   
+   return(Status);
+}
 
 /* EOF */

reactos/drivers/fs/np/mount.c

@@ -1,4 +1,4 @@
-/* $Id: mount.c,v 1.6 2001/05/07 22:03:27 chorns Exp $
+/* $Id: mount.c,v 1.7 2001/05/10 23:38:31 ekohl Exp $
  *
  * COPYRIGHT:  See COPYING in the top level directory
  * PROJECT:    ReactOS kernel
@@ -16,42 +16,19 @@
 #include <debug.h>
 
 
-/* GLOBALS *******************************************************************/
-
-//static PDRIVER_OBJECT DriverObject;
-
 /* FUNCTIONS *****************************************************************/
 
-NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT DriverObject,
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject,
 	    PUNICODE_STRING RegistryPath)
 {
+   PNPFS_DEVICE_EXTENSION DeviceExtension;
    PDEVICE_OBJECT DeviceObject;
-   NTSTATUS Status;
    UNICODE_STRING DeviceName;
    UNICODE_STRING LinkName;
+   NTSTATUS Status;
    
-   DbgPrint("Named Pipe Filesystem\n");
+   DbgPrint("Named Pipe FSD 0.0.2\n");
-   
-//   DriverObject = _DriverObject;
-   
-#if 0
-   RtlInitUnicodeString(&DeviceName, L"\\Device\\Npfs");
-   Status = IoCreateDevice(DriverObject,
-			   0,
-			   &DeviceName,
-			   FILE_DEVICE_NAMED_PIPE,
-			   0,
-			   FALSE,
-			   &DeviceObject);
-   if (!NT_SUCCESS(Status))
-     {
-	return(Status);
-     }
-   
-   RtlInitUnicodeString(&LinkName, L"\\??\\Pipe");
-   Status = IoCreateSymbolicLink(&LinkName,
-				 &DeviceName);
-#endif
    
    DeviceObject->Flags = 0;
    DriverObject->MajorFunction[IRP_MJ_CREATE] = NpfsCreate;
@@ -68,7 +45,6 @@ NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT DriverObject,
 //     NpfsSetInformation;
 //   DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = NpfsFlushBuffers;
 //   DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = NpfsShutdown;
-//   DriverObject->MajorFunction[IRP_MJ_CLEANUP] = NpfsCleanup;
 //   DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] = 
 //     NpfsQuerySecurity;
 //   DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] =
@@ -78,9 +54,9 @@ NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT DriverObject,
    
    DriverObject->DriverUnload = NULL;
    
-   RtlInitUnicodeString(&DeviceName, L"\\Device\\Npfs");
+   RtlInitUnicodeString(&DeviceName, L"\\Device\\NamedPipe");
    Status = IoCreateDevice(DriverObject,
-			   0,
+			   sizeof(NPFS_DEVICE_EXTENSION),
 			   &DeviceName,
 			   FILE_DEVICE_NAMED_PIPE,
 			   0,
@@ -88,25 +64,30 @@ NTSTATUS STDCALL DriverEntry(PDRIVER_OBJECT DriverObject,
 			   &DeviceObject);
    if (!NT_SUCCESS(Status))
      {
-	DPRINT1("Failed to create named pipe device! (Status %x)\n", Status);
+	DPRINT("Failed to create named pipe device! (Status %x)\n", Status);
 	return(Status);
      }
    
-   RtlInitUnicodeString(&LinkName, L"\\??\\Pipe");
+#if 0
+   /* FIXME: this should really be done by SMSS!! */
+   RtlInitUnicodeString(&LinkName, L"\\??\\PIPE");
    Status = IoCreateSymbolicLink(&LinkName,
 				 &DeviceName);
    if (!NT_SUCCESS(Status))
      {
-	DPRINT1("Failed to create named pipe symbolic link! (Status %x)\n", Status);
+	DPRINT("Failed to create named pipe symbolic link! (Status %x)\n", Status);
-
 //	IoDeleteDevice();
 	return(Status);
      }
+#endif
    
-   NpfsInitPipeList();
+   /* initialize the device extension */
+   DeviceExtension = DeviceObject->DeviceExtension;
+   InitializeListHead(&DeviceExtension->PipeListHead);
+   KeInitializeMutex(&DeviceExtension->PipeListLock,
+		     0);
    
    return(STATUS_SUCCESS);
 }
 
-
 /* EOF */

reactos/drivers/fs/np/npfs.h

@@ -3,12 +3,13 @@
 
 typedef struct
 {
-   PDEVICE_OBJECT StorageDevice;
+   LIST_ENTRY PipeListHead;
+   KMUTEX PipeListLock;
 } NPFS_DEVICE_EXTENSION, *PNPFS_DEVICE_EXTENSION;
 
 typedef struct
 {
-   PWCHAR Name;
+   UNICODE_STRING PipeName;
    LIST_ENTRY PipeListEntry;
    KSPIN_LOCK FcbListLock;
    LIST_ENTRY FcbListHead;
@@ -28,9 +29,9 @@ typedef struct _NPFS_FCB
    PNPFS_PIPE Pipe;
    struct _NPFS_FCB* OtherSide;
    BOOLEAN IsServer;
+   KEVENT ConnectEvent;
 } NPFS_FCB, *PNPFS_FCB;
 
-VOID NpfsPipeList(VOID);
 
 #define KeLockMutex(x) KeWaitForSingleObject(x, \
                                              UserRequest, \

reactos/include/napi/npipe.h

@@ -81,18 +81,48 @@ NTSTATUS STDCALL ZwCreateNamedPipeFile(OUT PHANDLE NamedPipeFileHandle,
 				       IN ULONG OutBufferSize,
 				       IN PLARGE_INTEGER DefaultTimeOut);
 
+#define FSCTL_PIPE_ASSIGN_EVENT \
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 0, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
-#define FSCTL_WAIT_PIPE \
+#define FSCTL_PIPE_DISCONNECT \
-        CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 1, METHOD_BUFFERED, FILE_ANY_ACCESS)
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 1, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
-#define FSCTL_LISTEN \
+#define FSCTL_PIPE_LISTEN \
-        CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 2, METHOD_BUFFERED, FILE_ANY_ACCESS)
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
-#define FSCTL_SET_STATE \
+#define FSCTL_PIPE_PEEK \
-        CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 3, METHOD_BUFFERED, FILE_ANY_ACCESS)
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 3, METHOD_BUFFERED, FILE_READ_DATA)
+
+#define FSCTL_PIPE_QUERY_EVENT \
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 4, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_TRANSCEIVE \
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 5, METHOD_NEITHER,  FILE_READ_DATA | FILE_WRITE_DATA)
+
+#define FSCTL_PIPE_WAIT \
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 6, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_IMPERSONATE \
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 7, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_SET_CLIENT_PROCESS \
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 8, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_QUERY_CLIENT_PROCESS \
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 9, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+#define FSCTL_PIPE_INTERNAL_READ \
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2045, METHOD_BUFFERED, FILE_READ_DATA)
+
+#define FSCTL_PIPE_INTERNAL_WRITE \
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2046, METHOD_BUFFERED, FILE_WRITE_DATA)
+
+#define FSCTL_PIPE_INTERNAL_TRANSCEIVE \
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2047, METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA)
+
+#define FSCTL_PIPE_INTERNAL_READ_OVFLOW \
+        CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2048, METHOD_BUFFERED, FILE_READ_DATA)
 
-#define FSCTL_GET_STATE \
-        CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 4, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
 typedef struct _NPFS_WAIT_PIPE
 {

reactos/lib/kernel32/file/npipe.c

@@ -1,4 +1,4 @@
-/* $Id: npipe.c,v 1.4 2001/03/31 01:17:29 dwelch Exp $
+/* $Id: npipe.c,v 1.5 2001/05/10 23:37:06 ekohl Exp $
  *
  * COPYRIGHT:       See COPYING in the top level directory
  * PROJECT:         ReactOS system libraries
@@ -11,17 +11,18 @@
 /* INCLUDES *****************************************************************/
 
 #include <ddk/ntddk.h>
-#include <windows.h>
-#include <wchar.h>
-#include <string.h>
 #include <ntdll/rtl.h>
+#include <windows.h>
+//#include <wchar.h>
+//#include <string.h>
 
 #include <kernel32/kernel32.h>
 #include <kernel32/error.h>
 
 /* FUNCTIONS ****************************************************************/
 
-HANDLE STDCALL CreateNamedPipeA(LPCSTR lpName,
+HANDLE STDCALL
+CreateNamedPipeA(LPCSTR lpName,
 		 DWORD dwOpenMode,
 		 DWORD dwPipeMode,
 		 DWORD nMaxInstances,
@@ -51,7 +52,8 @@ HANDLE STDCALL CreateNamedPipeA(LPCSTR lpName,
    return(NamedPipeHandle);
 }
 
-HANDLE STDCALL CreateNamedPipeW(LPCWSTR lpName,
+HANDLE STDCALL
+CreateNamedPipeW(LPCWSTR lpName,
 		 DWORD dwOpenMode,
 		 DWORD dwPipeMode,
 		 DWORD nMaxInstances,
@@ -79,15 +81,17 @@ HANDLE STDCALL CreateNamedPipeW(LPCWSTR lpName,
 					 &NamedPipeName,
 					 NULL,
 					 NULL);
-   
    if (!Result)
      {
+	SetLastError(ERROR_PATH_NOT_FOUND);
 	return(INVALID_HANDLE_VALUE);
      }
    
+   DPRINT("Pipe name: %wZ\n", &NamedPipeName);
+   
    InitializeObjectAttributes(&ObjectAttributes,
 			      &NamedPipeName,
-			      0,
+			      OBJ_CASE_INSENSITIVE,
 			      NULL,
 			      NULL);
    
@@ -100,7 +104,7 @@ HANDLE STDCALL CreateNamedPipeW(LPCWSTR lpName,
    CreateOptions = 0;
    if (dwOpenMode & FILE_FLAG_WRITE_THROUGH)
      {
-	CreateOptions = CreateOptions | FILE_FLAG_WRITE_THROUGH;
+	CreateOptions = CreateOptions | FILE_WRITE_THROUGH;
      }
    if (dwOpenMode & FILE_FLAG_OVERLAPPED)
      {
@@ -146,7 +150,7 @@ HANDLE STDCALL CreateNamedPipeW(LPCWSTR lpName,
 	NonBlocking = FALSE;
      }
    
-   DefaultTimeOut.QuadPart = nDefaultTimeOut * 1000 * 1000;
+   DefaultTimeOut.QuadPart = nDefaultTimeOut * 10000;
    
    Status = NtCreateNamedPipeFile(&PipeHandle,
 				  DesiredAccess,
@@ -162,22 +166,28 @@ HANDLE STDCALL CreateNamedPipeW(LPCWSTR lpName,
 				  nInBufferSize,
 				  nOutBufferSize,
 				  &DefaultTimeOut);
+   
+   RtlFreeUnicodeString(&NamedPipeName);
+   
    if (!NT_SUCCESS(Status))
      {
+	DPRINT("NtCreateNamedPipe failed (Status %x)!\n", Status);
 	SetLastErrorByStatus (Status);
 	return(INVALID_HANDLE_VALUE);
      }
+   
    return(PipeHandle);
 }
 
-BOOL STDCALL WaitNamedPipeA(LPCSTR lpNamedPipeName,
+BOOL STDCALL
+WaitNamedPipeA(LPCSTR lpNamedPipeName,
 	       DWORD nTimeOut)
 {
    BOOL r;
    UNICODE_STRING NameU;
    ANSI_STRING NameA;
    
-   RtlInitAnsiString(&NameA, lpNamedPipeName);
+   RtlInitAnsiString(&NameA, (LPSTR)lpNamedPipeName);
    RtlAnsiStringToUnicodeString(&NameU, &NameA, TRUE);
    
    r = WaitNamedPipeW(NameU.Buffer, nTimeOut);
@@ -187,7 +197,8 @@ BOOL STDCALL WaitNamedPipeA(LPCSTR lpNamedPipeName,
    return(r);
 }
 
-BOOL STDCALL WaitNamedPipeW(LPCWSTR lpNamedPipeName,
+BOOL STDCALL
+WaitNamedPipeW(LPCWSTR lpNamedPipeName,
 	       DWORD nTimeOut)
 {
    UNICODE_STRING NamedPipeName;
@@ -198,7 +209,7 @@ BOOL STDCALL WaitNamedPipeW(LPCWSTR lpNamedPipeName,
    HANDLE FileHandle;
    IO_STATUS_BLOCK Iosb;
    
-   r = RtlDosPathNameToNtPathName_U(lpNamedPipeName,
+   r = RtlDosPathNameToNtPathName_U((LPWSTR)lpNamedPipeName,
 				    &NamedPipeName,
 				    NULL,
 				    NULL);
@@ -225,8 +236,9 @@ BOOL STDCALL WaitNamedPipeW(LPCWSTR lpNamedPipeName,
 	return(FALSE);
      }
    
-   WaitPipe.Timeout.QuadPart = nTimeOut * 1000 * 1000;
+   WaitPipe.Timeout.QuadPart = nTimeOut * 10000;
    
+#if 0
    Status = NtFsControlFile(FileHandle,
 			    NULL,
 			    NULL,
@@ -242,25 +254,26 @@ BOOL STDCALL WaitNamedPipeW(LPCWSTR lpNamedPipeName,
 	SetLastErrorByStatus (Status);
 	return(FALSE);
      }
+#endif
    
    NtClose(FileHandle);
    return(TRUE);
 }
 
-BOOL STDCALL ConnectNamedPipe(HANDLE hNamedPipe,
+BOOL STDCALL
-		      LPOVERLAPPED lpOverLapped)
+ConnectNamedPipe(HANDLE hNamedPipe,
+		 LPOVERLAPPED lpOverlapped)
 {
-   NPFS_LISTEN ListenPipe;
    IO_STATUS_BLOCK Iosb;
    HANDLE hEvent;
    PIO_STATUS_BLOCK IoStatusBlock;
    NTSTATUS Status;
    
-   if (lpOverLapped != NULL) 
+   if (lpOverlapped != NULL)
      {
-	lpOverLapped->Internal = STATUS_PENDING;
+	lpOverlapped->Internal = STATUS_PENDING;
-	hEvent = lpOverLapped->hEvent;
+	hEvent = lpOverlapped->hEvent;
-	IoStatusBlock = (PIO_STATUS_BLOCK)lpOverLapped;
+	IoStatusBlock = (PIO_STATUS_BLOCK)lpOverlapped;
      }
    else
      {
@@ -273,20 +286,33 @@ BOOL STDCALL ConnectNamedPipe(HANDLE hNamedPipe,
 			    NULL,
 			    NULL,
 			    IoStatusBlock,
-			    FSCTL_LISTEN,
+			    FSCTL_PIPE_LISTEN,
-			    &ListenPipe,
+			    NULL,
-			    sizeof(ListenPipe),
+			    0,
 			    NULL,
 			    0);
+   if ((lpOverlapped == NULL) && (Status == STATUS_PENDING))
+     {
+	Status = NtWaitForSingleObject(hNamedPipe,
+				       FALSE,
+				       NULL);
 	if (!NT_SUCCESS(Status))
 	  {
 	     SetLastErrorByStatus(Status);
 	     return(FALSE);
 	  }
+	Status = Iosb.Status;
+     }
+   if (!NT_SUCCESS(Status) || (Status == STATUS_PENDING))
+     {
+	SetLastErrorByStatus (Status);
+	return(FALSE);
+     }
    return(TRUE);
 }
 
-BOOL STDCALL SetNamedPipeHandleState(HANDLE hNamedPipe,
+BOOL STDCALL
+SetNamedPipeHandleState(HANDLE hNamedPipe,
 			LPDWORD lpMode,
 			LPDWORD lpMaxCollectionCount,
 			LPDWORD lpCollectDataTimeout)
@@ -296,6 +322,7 @@ BOOL STDCALL SetNamedPipeHandleState(HANDLE hNamedPipe,
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
    
+#if 0
    Status = NtFsControlFile(hNamedPipe,
 			    NULL,
 			    NULL,
@@ -311,6 +338,7 @@ BOOL STDCALL SetNamedPipeHandleState(HANDLE hNamedPipe,
 	SetLastErrorByStatus (Status);
 	return(FALSE);
      }
+#endif
    
    if (lpMode != NULL)
      {
@@ -359,6 +387,7 @@ BOOL STDCALL SetNamedPipeHandleState(HANDLE hNamedPipe,
 	SetState.Timeout = GetState.Timeout;
      }
    
+#if 0
    Status = NtFsControlFile(hNamedPipe,
 			    NULL,
 			    NULL,
@@ -374,6 +403,7 @@ BOOL STDCALL SetNamedPipeHandleState(HANDLE hNamedPipe,
 	SetLastErrorByStatus (Status);
 	return(FALSE);
      }
+#endif
    return(TRUE);
 }
 
@@ -394,8 +424,7 @@ CallNamedPipeA (
 }
 
 
-WINBOOL
+WINBOOL STDCALL
-STDCALL
 CallNamedPipeW (
 	LPCWSTR	lpNamedPipeName,
 	LPVOID	lpInBuffer,
@@ -410,18 +439,45 @@ CallNamedPipeW (
 	return FALSE;
 }
 
-WINBOOL
+
-STDCALL
+WINBOOL STDCALL
-DisconnectNamedPipe (
+DisconnectNamedPipe(HANDLE hNamedPipe)
-	HANDLE	hNamedPipe
-	)
 {
-	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+   IO_STATUS_BLOCK Iosb;
-	return FALSE;
+   NTSTATUS Status;
+
+   Status = NtFsControlFile(hNamedPipe,
+			    NULL,
+			    NULL,
+			    NULL,
+			    &Iosb,
+			    FSCTL_PIPE_DISCONNECT,
+			    NULL,
+			    0,
+			    NULL,
+			    0);
+   if (Status == STATUS_PENDING)
+     {
+	Status = NtWaitForSingleObject(hNamedPipe,
+				       FALSE,
+				       NULL);
+	if (!NT_SUCCESS(Status))
+	  {
+	     SetLastErrorByStatus(Status);
+	     return(FALSE);
+	  }
      }
 
-WINBOOL
+   if (!NT_SUCCESS(Status))
-STDCALL
+     {
+	SetLastErrorByStatus(Status);
+	return(FALSE);
+     }
+   return(TRUE);
+}
+
+
+WINBOOL STDCALL
 GetNamedPipeHandleStateW (
 	HANDLE	hNamedPipe,
 	LPDWORD	lpState,
@@ -437,8 +493,7 @@ GetNamedPipeHandleStateW (
 }
 
 
-WINBOOL
+WINBOOL STDCALL
-STDCALL
 GetNamedPipeHandleStateA (
 	HANDLE	hNamedPipe,
 	LPDWORD	lpState,
@@ -454,50 +509,42 @@ GetNamedPipeHandleStateA (
 }
 
 
-WINBOOL
+WINBOOL STDCALL
-STDCALL
+GetNamedPipeInfo(HANDLE hNamedPipe,
-GetNamedPipeInfo (
-	HANDLE	hNamedPipe,
 		 LPDWORD lpFlags,
 		 LPDWORD lpOutBufferSize,
 		 LPDWORD lpInBufferSize,
-	LPDWORD	lpMaxInstances
+		 LPDWORD lpMaxInstances)
-	)
 {
 	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 	return FALSE;
 }
 
-WINBOOL
+
-STDCALL
+WINBOOL STDCALL
-PeekNamedPipe (
+PeekNamedPipe(HANDLE hNamedPipe,
-	HANDLE	hNamedPipe,
 	      LPVOID lpBuffer,
 	      DWORD nBufferSize,
 	      LPDWORD lpBytesRead,
 	      LPDWORD lpTotalBytesAvail,
-	LPDWORD	lpBytesLeftThisMessage
+	      LPDWORD lpBytesLeftThisMessage)
-	)
 {
 	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 	return FALSE;
 }
 
-WINBOOL
+
-STDCALL
+WINBOOL STDCALL
-TransactNamedPipe (
+TransactNamedPipe(HANDLE hNamedPipe,
-	HANDLE		hNamedPipe,
 		  LPVOID lpInBuffer,
 		  DWORD nInBufferSize,
 		  LPVOID lpOutBuffer,
 		  DWORD nOutBufferSize,
 		  LPDWORD lpBytesRead,
-	LPOVERLAPPED	lpOverlapped
+		  LPOVERLAPPED lpOverlapped)
-	)
 {
 	SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 	return FALSE;
 }
 
-
 /* EOF */