reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-12-04 17:56:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
d16c0dc6ce
wine/dlls/ntdll/serial.c

325 lines
9.3 KiB
C
Raw Blame History

/* Main file for COMM support
*
* DEC 93 Erik Bos <erik@xs4all.nl>
* Copyright 1996 Marcus Meissner
* Copyright 2005 Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include "wine/port.h"
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#ifdef HAVE_TERMIOS_H
#include <termios.h>
#endif
#ifdef HAVE_IO_H
# include <io.h>
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_TERMIOS_H
#include <termios.h>
#endif
#include <fcntl.h>
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
#include <sys/types.h>
#ifdef HAVE_SYS_FILIO_H
# include <sys/filio.h>
#endif
#ifdef HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#ifdef HAVE_SYS_POLL_H
# include <sys/poll.h>
#endif
#ifdef HAVE_SYS_MODEM_H
# include <sys/modem.h>
#endif
#ifdef HAVE_SYS_STRTIO_H
# include <sys/strtio.h>
#endif
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "windef.h"
#include "winternl.h"
#include "winioctl.h"
#include "ddk/ntddser.h"
#include "ntdll_misc.h"
#include "wine/server.h"
#include "wine/library.h"
#include "wine/debug.h"
#ifdef HAVE_LINUX_SERIAL_H
#include <linux/serial.h>
#endif
WINE_DEFAULT_DEBUG_CHANNEL(comm);
static const char* iocode2str(DWORD ioc)
{
switch (ioc)
{
#define X(x) case (x): return #x;
X(IOCTL_SERIAL_CLEAR_STATS);
X(IOCTL_SERIAL_CLR_DTR);
X(IOCTL_SERIAL_CLR_RTS);
X(IOCTL_SERIAL_CONFIG_SIZE);
X(IOCTL_SERIAL_GET_BAUD_RATE);
X(IOCTL_SERIAL_GET_CHARS);
X(IOCTL_SERIAL_GET_COMMSTATUS);
X(IOCTL_SERIAL_GET_DTRRTS);
X(IOCTL_SERIAL_GET_HANDFLOW);
X(IOCTL_SERIAL_GET_LINE_CONTROL);
X(IOCTL_SERIAL_GET_MODEM_CONTROL);
X(IOCTL_SERIAL_GET_MODEMSTATUS);
X(IOCTL_SERIAL_GET_PROPERTIES);
X(IOCTL_SERIAL_GET_STATS);
X(IOCTL_SERIAL_GET_TIMEOUTS);
X(IOCTL_SERIAL_GET_WAIT_MASK);
X(IOCTL_SERIAL_IMMEDIATE_CHAR);
X(IOCTL_SERIAL_LSRMST_INSERT);
X(IOCTL_SERIAL_PURGE);
X(IOCTL_SERIAL_RESET_DEVICE);
X(IOCTL_SERIAL_SET_BAUD_RATE);
X(IOCTL_SERIAL_SET_BREAK_ON);
X(IOCTL_SERIAL_SET_BREAK_OFF);
X(IOCTL_SERIAL_SET_CHARS);
X(IOCTL_SERIAL_SET_DTR);
X(IOCTL_SERIAL_SET_FIFO_CONTROL);
X(IOCTL_SERIAL_SET_HANDFLOW);
X(IOCTL_SERIAL_SET_LINE_CONTROL);
X(IOCTL_SERIAL_SET_MODEM_CONTROL);
X(IOCTL_SERIAL_SET_QUEUE_SIZE);
X(IOCTL_SERIAL_SET_RTS);
X(IOCTL_SERIAL_SET_TIMEOUTS);
X(IOCTL_SERIAL_SET_WAIT_MASK);
X(IOCTL_SERIAL_SET_XOFF);
X(IOCTL_SERIAL_SET_XON);
X(IOCTL_SERIAL_WAIT_ON_MASK);
X(IOCTL_SERIAL_XOFF_COUNTER);
#undef X
default: { static char tmp[32]; sprintf(tmp, "IOCTL_SERIAL_%ld\n", ioc); return tmp; }
}
}
static NTSTATUS get_modem_status(int fd, DWORD* lpModemStat)
{
NTSTATUS status = STATUS_SUCCESS;
int mstat;
#ifdef TIOCMGET
if (ioctl(fd, TIOCMGET, &mstat) == -1)
{
WARN("ioctl failed\n");
status = FILE_GetNtStatus();
}
else
{
*lpModemStat = 0;
#ifdef TIOCM_CTS
if (mstat & TIOCM_CTS) *lpModemStat |= MS_CTS_ON;
#endif
#ifdef TIOCM_DSR
if (mstat & TIOCM_DSR) *lpModemStat |= MS_DSR_ON;
#endif
#ifdef TIOCM_RNG
if (mstat & TIOCM_RNG) *lpModemStat |= MS_RING_ON;
#endif
#ifdef TIOCM_CAR
/* FIXME: Not really sure about RLSD UB 990810 */
if (mstat & TIOCM_CAR) *lpModemStat |= MS_RLSD_ON;
#endif
TRACE("%04x -> %s%s%s%s\n", mstat,
(*lpModemStat & MS_RLSD_ON) ? "MS_RLSD_ON " : "",
(*lpModemStat & MS_RING_ON) ? "MS_RING_ON " : "",
(*lpModemStat & MS_DSR_ON) ? "MS_DSR_ON " : "",
(*lpModemStat & MS_CTS_ON) ? "MS_CTS_ON " : "");
}
#else
status = STATUS_NOT_SUPPORTED;
#endif
return status;
}
static NTSTATUS get_wait_mask(HANDLE hDevice, DWORD* mask)
{
NTSTATUS status;
SERVER_START_REQ( get_serial_info )
{
req->handle = hDevice;
if (!(status = wine_server_call( req )))
*mask = reply->eventmask;
}
SERVER_END_REQ;
return status;
}
static NTSTATUS purge(int fd, DWORD flags)
{
/*
** not exactly sure how these are different
** Perhaps if we had our own internal queues, one flushes them
** and the other flushes the kernel's buffers.
*/
if (flags & PURGE_TXABORT) tcflush(fd, TCOFLUSH);
if (flags & PURGE_RXABORT) tcflush(fd, TCIFLUSH);
if (flags & PURGE_TXCLEAR) tcflush(fd, TCOFLUSH);
if (flags & PURGE_RXCLEAR) tcflush(fd, TCIFLUSH);
return STATUS_SUCCESS;
}
static NTSTATUS set_wait_mask(HANDLE hDevice, DWORD mask)
{
NTSTATUS status;
SERVER_START_REQ( set_serial_info )
{
req->handle = hDevice;
req->flags = SERIALINFO_SET_MASK;
req->eventmask = mask;
status = wine_server_call( req );
}
SERVER_END_REQ;
return status;
}
static NTSTATUS xmit_immediate(HANDLE hDevice, int fd, char* ptr)
{
/* FIXME: not perfect as it should bypass the in-queue */
WARN("(%p,'%c') not perfect!\n", hDevice, *ptr);
if (write(fd, ptr, 1) != 1)
return FILE_GetNtStatus();
return STATUS_SUCCESS;
}
/******************************************************************
* COMM_DeviceIoControl
*
*
*/
NTSTATUS COMM_DeviceIoControl(HANDLE hDevice,
HANDLE hEvent, PIO_APC_ROUTINE UserApcRoutine,
PVOID UserApcContext,
PIO_STATUS_BLOCK piosb,
ULONG dwIoControlCode,
LPVOID lpInBuffer, DWORD nInBufferSize,
LPVOID lpOutBuffer, DWORD nOutBufferSize)
{
DWORD sz = 0, access = FILE_READ_DATA;
NTSTATUS status = STATUS_SUCCESS;
int fd;
TRACE("%p %s %p %ld %p %ld %p\n",
hDevice, iocode2str(dwIoControlCode), lpInBuffer, nInBufferSize,
lpOutBuffer, nOutBufferSize, piosb);
piosb->Information = 0;
if ((status = wine_server_handle_to_fd( hDevice, access, &fd, NULL ))) goto error;
switch (dwIoControlCode)
{
case IOCTL_SERIAL_GET_MODEMSTATUS:
if (lpOutBuffer && nOutBufferSize == sizeof(DWORD))
{
if (!(status = get_modem_status(fd, (DWORD*)lpOutBuffer)))
sz = sizeof(DWORD);
}
else status = STATUS_INVALID_PARAMETER;
break;
case IOCTL_SERIAL_GET_WAIT_MASK:
if (lpOutBuffer && nOutBufferSize == sizeof(DWORD))
{
if (!(status = get_wait_mask(hDevice, (DWORD*)lpOutBuffer)))
sz = sizeof(DWORD);
}
else
status = STATUS_INVALID_PARAMETER;
break;
case IOCTL_SERIAL_IMMEDIATE_CHAR:
if (lpInBuffer && nInBufferSize == sizeof(CHAR))
status = xmit_immediate(hDevice, fd, lpInBuffer);
else
status = STATUS_INVALID_PARAMETER;
break;
case IOCTL_SERIAL_PURGE:
if (lpInBuffer && nInBufferSize == sizeof(DWORD))
status = purge(fd, *(DWORD*)lpInBuffer);
else
status = STATUS_INVALID_PARAMETER;
break;
case IOCTL_SERIAL_SET_BREAK_OFF:
#if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
if (ioctl(fd, TIOCCBRK, 0) == -1)
{
TRACE("ioctl failed\n");
status = FILE_GetNtStatus();
}
#else
FIXME("ioctl not available\n");
status = STATUS_NOT_SUPPORTED;
#endif
break;
case IOCTL_SERIAL_SET_BREAK_ON:
#if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
if (ioctl(fd, TIOCSBRK, 0) == -1)
{
TRACE("ioctl failed\n");
status = FILE_GetNtStatus();
}
#else
FIXME("ioctl not available\n");
status = STATUS_NOT_SUPPORTED;
#endif
break;
case IOCTL_SERIAL_SET_WAIT_MASK:
if (lpInBuffer && nInBufferSize == sizeof(DWORD))
{
status = set_wait_mask(hDevice, *(DWORD*)lpInBuffer);
}
else status = STATUS_INVALID_PARAMETER;
break;
default:
FIXME("Unsupported IOCTL %lx (type=%lx access=%lx func=%lx meth=%lx)\n",
dwIoControlCode, dwIoControlCode >> 16, (dwIoControlCode >> 14) & 3,
(dwIoControlCode >> 2) & 0xFFF, dwIoControlCode & 3);
sz = 0;
status = STATUS_INVALID_PARAMETER;
break;
}
wine_server_release_fd( hDevice, fd );
error:
piosb->u.Status = status;
piosb->Information = sz;
if (hEvent) NtSetEvent(hEvent, NULL);
return status;
}
Reference in New Issue View Git Blame Copy Permalink