console.c

winNT技术操作系统,国外开放的原代码和LIUX一样

  Request.Data.FillOutputRequest.Unicode = bUnicode;
  if(bUnicode)
    Request.Data.FillOutputRequest.Char.UnicodeChar = *((WCHAR*)cCharacter);
  else
    Request.Data.FillOutputRequest.Char.AsciiChar = *((CHAR*)cCharacter);
  Request.Data.FillOutputRequest.Position = dwWriteCoord;
  Request.Data.FillOutputRequest.Length = nLength;
  Status = CsrClientCallServer(&Request, NULL,
                               CsrRequest,
                               sizeof(CSR_API_MESSAGE));

  if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
  {
    SetLastErrorByStatus(Status);
    return FALSE;
  }

  if(lpNumberOfCharsWritten != NULL)
  {
    *lpNumberOfCharsWritten = Request.Data.FillOutputRequest.NrCharactersWritten;
  }

  return TRUE;
}

/*--------------------------------------------------------------
 *	FillConsoleOutputCharacterA
 *
 * @implemented
 */
BOOL STDCALL
FillConsoleOutputCharacterA(
	HANDLE		hConsoleOutput,
	CHAR		cCharacter,
	DWORD		nLength,
	COORD		dwWriteCoord,
	LPDWORD		lpNumberOfCharsWritten
	)
{
  return IntFillConsoleOutputCharacter(hConsoleOutput,
                                       &cCharacter,
                                       nLength,
                                       dwWriteCoord,
                                       lpNumberOfCharsWritten,
                                       FALSE);
}


/*--------------------------------------------------------------
 *	FillConsoleOutputCharacterW
 *
 * @implemented
 */
BOOL
STDCALL
FillConsoleOutputCharacterW(
	HANDLE		hConsoleOutput,
	WCHAR		cCharacter,
	DWORD		nLength,
	COORD		dwWriteCoord,
	LPDWORD		lpNumberOfCharsWritten
	)
{
  return IntFillConsoleOutputCharacter(hConsoleOutput,
                                       &cCharacter,
                                       nLength,
                                       dwWriteCoord,
                                       lpNumberOfCharsWritten,
                                       TRUE);
}


static BOOL
IntPeekConsoleInput(HANDLE hConsoleInput,
                    PINPUT_RECORD lpBuffer,
                    DWORD nLength,
                    LPDWORD lpNumberOfEventsRead,
                    BOOL bUnicode)
{
  CSR_API_MESSAGE Request; ULONG CsrRequest;
  PCSR_CAPTURE_BUFFER CaptureBuffer;
  NTSTATUS Status;
  ULONG Size;

  if(lpBuffer == NULL)
  {
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
  }

  Size = nLength * sizeof(INPUT_RECORD);

  /* Allocate a Capture Buffer */
  DPRINT("IntPeekConsoleInput: %lx %p\n", Size, lpNumberOfEventsRead);
  CaptureBuffer = CsrAllocateCaptureBuffer(1, Size);

  /* Allocate space in the Buffer */
  CsrCaptureMessageBuffer(CaptureBuffer,
                          NULL,
                          Size,
                          (PVOID*)&Request.Data.PeekConsoleInputRequest.InputRecord);

  /* Set up the data to send to the Console Server */
  CsrRequest = MAKE_CSR_API(PEEK_CONSOLE_INPUT, CSR_CONSOLE);
  Request.Data.PeekConsoleInputRequest.ConsoleHandle = hConsoleInput;
  Request.Data.PeekConsoleInputRequest.Unicode = bUnicode;
  Request.Data.PeekConsoleInputRequest.Length = nLength;

  /* Call the server */
  Status = CsrClientCallServer(&Request, 
                               CaptureBuffer,
                               CsrRequest,
                               sizeof(CSR_API_MESSAGE));
  DPRINT("Server returned: %x\n", Request.Status);

  /* Check for success*/
  if (NT_SUCCESS(Request.Status))
  {
    /* Return the number of events read */
    DPRINT("Events read: %lx\n", Request.Data.PeekConsoleInputRequest.Length);
    *lpNumberOfEventsRead = Request.Data.PeekConsoleInputRequest.Length;

    /* Copy into the buffer */
    DPRINT("Copying to buffer\n");
    RtlCopyMemory(lpBuffer,
                  Request.Data.PeekConsoleInputRequest.InputRecord, 
                  sizeof(INPUT_RECORD) * *lpNumberOfEventsRead);
  }
  else
  {
    /* Error out */
    *lpNumberOfEventsRead = 0;
    SetLastErrorByStatus(Request.Status);
  }

  /* Release the capture buffer */
  CsrFreeCaptureBuffer(CaptureBuffer);

  /* Return TRUE or FALSE */
  return NT_SUCCESS(Request.Status);
}

/*--------------------------------------------------------------
 * 	PeekConsoleInputA
 *
 * @implemented
 */
BOOL
WINAPI
PeekConsoleInputA(
	HANDLE			hConsoleInput,
	PINPUT_RECORD		lpBuffer,
	DWORD			nLength,
	LPDWORD			lpNumberOfEventsRead
	)
{
  return IntPeekConsoleInput(hConsoleInput, lpBuffer, nLength,
                             lpNumberOfEventsRead, FALSE);
}


/*--------------------------------------------------------------
 * 	PeekConsoleInputW
 *
 * @implemented
 */
BOOL
WINAPI
PeekConsoleInputW(
	HANDLE			hConsoleInput,
	PINPUT_RECORD		lpBuffer,
	DWORD			nLength,
	LPDWORD			lpNumberOfEventsRead
	)
{
  return IntPeekConsoleInput(hConsoleInput, lpBuffer, nLength,
                             lpNumberOfEventsRead, TRUE);
}


static BOOL
IntReadConsoleInput(HANDLE hConsoleInput,
                    PINPUT_RECORD lpBuffer,
                    DWORD nLength,
                    LPDWORD lpNumberOfEventsRead,
                    BOOL bUnicode)
{
  CSR_API_MESSAGE Request; ULONG CsrRequest;
  
  ULONG Read;
  NTSTATUS Status;

  CsrRequest = MAKE_CSR_API(READ_INPUT, CSR_CONSOLE);
  Read = 0;
  while(nLength > 0)
  {
    Request.Data.ReadInputRequest.ConsoleHandle = hConsoleInput;
    Request.Data.ReadInputRequest.Unicode = bUnicode;
    Status = CsrClientCallServer(&Request, NULL,
                                 CsrRequest,
                                 sizeof(CSR_API_MESSAGE));
    if(!NT_SUCCESS(Status) || !NT_SUCCESS(Status = Request.Status))
    {
      if(Read == 0)
      {
        /* we couldn't read a single record, fail */
        SetLastErrorByStatus(Status);
        return FALSE;
      }
      else
      {
        /* FIXME - fail gracefully in case we already read at least one record? */
        break;
      }
    }
    else if(Status == STATUS_PENDING)
    {
      if(Read == 0)
      {
        Status = NtWaitForSingleObject(Request.Data.ReadInputRequest.Event, FALSE, 0);
        if(!NT_SUCCESS(Status))
        {
          SetLastErrorByStatus(Status);
          break;
        }
      }
      else
      {
        /* nothing more to read (waiting for more input??), let's just bail */
        break;
      }
    }
    else
    {
      lpBuffer[Read++] = Request.Data.ReadInputRequest.Input;
      nLength--;

      if(!Request.Data.ReadInputRequest.MoreEvents)
      {
        /* nothing more to read, bail */
        break;
      }
    }
  }

  if(lpNumberOfEventsRead != NULL)
  {
    *lpNumberOfEventsRead = Read;
  }

  return (Read > 0);
}


/*--------------------------------------------------------------
 * 	ReadConsoleInputA
 *
 * @implemented
 */
BOOL WINAPI
ReadConsoleInputA(HANDLE hConsoleInput,
		  PINPUT_RECORD	lpBuffer,
		  DWORD	nLength,
		  LPDWORD lpNumberOfEventsRead)
{
  return IntReadConsoleInput(hConsoleInput, lpBuffer, nLength,
                             lpNumberOfEventsRead, FALSE);
}


/*--------------------------------------------------------------
 * 	ReadConsoleInputW
 *
 * @implemented
 */
BOOL
WINAPI
ReadConsoleInputW(
	HANDLE			hConsoleInput,
	PINPUT_RECORD		lpBuffer,
	DWORD			nLength,
	LPDWORD			lpNumberOfEventsRead
	)
{
  return IntReadConsoleInput(hConsoleInput, lpBuffer, nLength,
                             lpNumberOfEventsRead, TRUE);
}


static BOOL
IntWriteConsoleInput(HANDLE hConsoleInput,
                     PINPUT_RECORD lpBuffer,
                     DWORD nLength,
                     LPDWORD lpNumberOfEventsWritten,
                     BOOL bUnicode)
{
  CSR_API_MESSAGE Request; ULONG CsrRequest;
  PCSR_CAPTURE_BUFFER CaptureBuffer;
  NTSTATUS Status;
  DWORD Size;

  if(lpBuffer == NULL)
  {
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
  }

  Size = nLength * sizeof(INPUT_RECORD);

  /* Allocate a Capture Buffer */
  DPRINT("IntWriteConsoleInput: %lx %p\n", Size, lpNumberOfEventsWritten);
  CaptureBuffer = CsrAllocateCaptureBuffer(1, Size);

  /* Allocate space in the Buffer */
  CsrCaptureMessageBuffer(CaptureBuffer,
                          NULL,
                          Size,
                          (PVOID*)&Request.Data.WriteConsoleInputRequest.InputRecord);

  /* Set up the data to send to the Console Server */
  CsrRequest = MAKE_CSR_API(WRITE_CONSOLE_INPUT, CSR_CONSOLE);
  Request.Data.WriteConsoleInputRequest.ConsoleHandle = hConsoleInput;
  Request.Data.WriteConsoleInputRequest.Unicode = bUnicode;
  Request.Data.WriteConsoleInputRequest.Length = nLength;

  /* Call the server */
  Status = CsrClientCallServer(&Request, 
                               CaptureBuffer,
                               CsrRequest,
                               sizeof(CSR_API_MESSAGE));
  DPRINT("Server returned: %x\n", Request.Status);

  /* Check for success*/
  if (NT_SUCCESS(Request.Status))
  {
    /* Return the number of events read */
    DPRINT("Events read: %lx\n", Request.Data.WriteConsoleInputRequest.Length);
    *lpNumberOfEventsWritten = Request.Data.WriteConsoleInputRequest.Length;

    /* Copy into the buffer */
    DPRINT("Copying to buffer\n");
    RtlCopyMemory(lpBuffer, 
                  Request.Data.WriteConsoleInputRequest.InputRecord, 
                  sizeof(INPUT_RECORD) * *lpNumberOfEventsWritten);
  }
  else
  {
    /* Error out */
    *lpNumberOfEventsWritten = 0;
    SetLastErrorByStatus(Request.Status);
  }

  /* Release the capture buffer */
  CsrFreeCaptureBuffer(CaptureBuffer);

  /* Return TRUE or FALSE */
  return NT_SUCCESS(Request.Status);
}


/*--------------------------------------------------------------
 * 	WriteConsoleInputA
 *
 * @implemented
 */
BOOL
WINAPI
WriteConsoleInputA(
	HANDLE			 hConsoleInput,
	CONST INPUT_RECORD	*lpBuffer,
	DWORD			 nLength,
	LPDWORD			 lpNumberOfEventsWritten
	)
{
  return IntWriteConsoleInput(hConsoleInput,
                              (PINPUT_RECORD)lpBuffer,
                              nLength,
                              lpNumberOfEventsWritten,
                              FALSE);
}


/*--------------------------------------------------------------
 * 	WriteConsoleInputW
 *
 * @implemented
 */
BOOL
WINAPI
WriteConsoleInputW(
	HANDLE			 hConsoleInput,
	CONST INPUT_RECORD	*lpBuffer,
	DWORD			 nLength,
	LPDWORD			 lpNumberOfEventsWritten
	)
{
  return IntWriteConsoleInput(hConsoleInput,
                              (PINPUT_RECORD)lpBuffer,
                              nLength,
                              lpNumberOfEventsWritten,
                              TRUE);
}


static BOOL
IntReadConsoleOutput(HANDLE hConsoleOutput,
                     PCHAR_INFO lpBuffer,
                     COORD dwBufferSize,
                     COORD dwBufferCoord,
                     PSMALL_RECT lpReadRegion,
                     BOOL bUnicode)
{
  CSR_API_MESSAGE Request; ULONG CsrRequest;
  PCSR_CAPTURE_BUFFER CaptureBuffer;
  NTSTATUS Status;
  DWORD Size, SizeX, SizeY;

  if(lpBuffer == NULL)
  {
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
  }

  Size = dwBufferSize.X * dwBufferSize.Y * sizeof(CHAR_INFO);

  /* Allocate a Capture Buffer */
  DPRINT("IntReadConsoleOutput: %lx %p\n", Size, lpReadRegion);
  CaptureBuffer = CsrAllocateCaptureBuffer(1, Size);

  /* Allocate space in the Buffer */
  CsrCaptureMessageBuffer(CaptureBuffer,
                          NULL,
                          Size,
                          (PVOID*)&Request.Data.ReadConsoleOutputRequest.CharInfo);

  /* Set up the data to send to the Console Server */
  CsrRequest = MAKE_CSR_API(READ_CONSOLE_OUTPUT, CSR_CONSOLE);
  Request.Data.ReadConsoleOutputRequest.ConsoleHandle = hConsoleOutput;
  Request.Data.ReadConsoleOutputRequest.Unicode = bUnicode;
  Request.Data.ReadConsoleOutputRequest.BufferSize = dwBufferSize;
  Request.Data.ReadConsoleOutputRequest.BufferCoord = dwBufferCoord;
  Request.Data.ReadConsoleOutputRequest.ReadRegion = *lpReadRegion;

  /* Call the server */
  Status = CsrClientCallServer(&Request, 
                               CaptureBuffer,
                               CsrRequest,
                               sizeof(CSR_API_MESSAGE));
  DPRINT("Server returned: %x\n", Request.Status);

  /* Check for success*/
  if (NT_SUCCESS(Request.Status))
  {
    /* Copy into the buffer */
    DPRINT("Copying to buffer\n");
    SizeX = Request.Data.ReadConsoleOutputRequest.ReadRegion.Right - 
            Request.Data.ReadConsoleOutputRequest.ReadRegion.Left + 1;
    SizeY = Request.Data.ReadConsoleOutputRequest.ReadRegion.Bottom - 
            Request.Data.ReadConsoleOutputRequest.ReadRegion.Top + 1;
    RtlCopyMemory(lpBuffer, 
                  Request.Data.ReadConsoleOutputRequest.CharInfo, 
                  sizeof(CHAR_INFO) * SizeX * SizeY);
  }
  else
  {
    /* Error out */
    SetLastErrorByStatus(Request.Status);
  }

  /* Return the read region */
  DPRINT("read region: %lx\n", Request.Data.ReadConsoleOutputRequest.ReadRegion);
  *lpReadRegion = Request.Data.ReadConsoleOutputRequest.ReadRegion;

  /* Release the capture buffer */
  CsrFreeCaptureBuffer(CaptureBuffer);

  /* Return TRUE or FALSE */
  return NT_SUCCESS(Request.Status);
}

/*--------------------------------------------------------------
 * 	ReadConsoleOutputA
 *
 * @implemented
 */
BOOL
WINAPI
ReadConsoleOutputA(
	HANDLE		hConsoleOutput,
	PCHAR_INFO	lpBuffer,
	COORD		dwBufferSize,